pan/heros
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Compare commits

base: pan:cdfcf1f8f1a328874fd5f5f96c5130db9f80fbd7
Branches Tags
pan:master pan:oh/0_7_1 pan:oh/0_7_251120 pan:oh/0.1.1120 pan:oh/10171 pan:oh/1017 pan:oneHero1010 pan:814 pan:817 pan:new0602 pan:new316 pan:new428 pan:one pan:skill pan:new pan:2412 pan:1227
...
compare: pan:b2cc25b32b5d09459ec940f537f30793c9e8997f
Branches Tags
pan:oh/0_7_1 pan:oh/0_7_251120 pan:oh/0.1.1120 pan:oh/10171 pan:oh/1017 pan:oneHero1010 pan:814 pan:817 pan:new0602 pan:new316 pan:new428 pan:one pan:skill pan:new pan:2412 pan:1227 pan:master

2 Commits
cdfcf1f8f1 ... b2cc25b32b

Author SHA1 Message Date
panw
b2cc25b32b feat(战斗系统): 添加反伤机制并优化属性变量命名 
添加新的技能配置5000(反伤)和实现反伤逻辑
将targetAttrs统一重命名为TAttrsComp以提高代码一致性
 2025-11-27 16:12:23 +08:00
panw
0692d58e01 refactor(天赋系统): 重构天赋效果枚举和属性处理逻辑 
- 重新组织TalEffet枚举，按功能分类并添加注释说明
- 移除冗余的DMG_RED属性
- 为HeroAttrsComp添加详细的JSDoc注释
- 优化天赋buff处理方法，区分数值型和计数型天赋
 2025-11-27 16:12:12 +08:00
4 changed files with 119 additions and 60 deletions
Expand all files Collapse all files

4
assets/script/game/common/config/SkillSet.ts
View File

@@ -158,6 +158,10 @@ export interface SkillConfig {
}
export const SkillSet: Record<number, SkillConfig> = {
5000:{uuid:5000,name:"反伤",sp_name:"thorns",icon:"3036",TGroup:TGroup.Enemy,SType:SType.damage,act:"atk",DTType:DTType.single,DType:DType.ATK,
ap:0,map:0,cd:0,t_num:1,hit_num:1,hit:1,hitcd:0.2,speed:720,cost:0,with:0,dis:80,ready:0,EAnm:0,DAnm:9001,RType:RType.fixed,EType:EType.animationEnd,
buffs:[],neAttrs:[],info:"反伤",
},
// ========== 基础攻击 ========== 6001-6099
6001: {
uuid:6001,name:"挥击",sp_name:"atk_s1",icon:"3036",TGroup:TGroup.Enemy,SType:SType.damage,act:"atk",DTType:DTType.single,DType:DType.ATK,

34
assets/script/game/common/config/TalSet.ts
View File

@@ -19,19 +19,24 @@ export enum TriType {
export enum TalEffet {
ATK_DMG=1, // 伤害
SKILL_DMG=2, // 技能伤害
HP=3, // 回血 百分比
MP=4, //回蓝 百分比
BUFF = 5, // 暴击率，闪避率等，可叠加的触发后清零
STATS=6, // 状态
WFUNY=7, // 风怒
D_SKILL=8, //两次技能
SHIELD=9, // 护盾
DMG_RED=10, // 减伤
C_MSKILL=11, // 必杀技能必暴
C_ATK=12, // 普工必爆
C_SKILL=13, // 一般技能必暴
ATK_DMG=1, // 伤害 次数+伤害加成，如额外5次 伤害+20%
SKILL_DMG=2, // 技能伤害 次数+伤害加成，如额外5次 伤害+20%
DMG_RED=10, // 减伤 次数+减伤加成，如额外5次 伤害-20%
THORNS=14, //反伤 百分比 次数+反伤加成，如额外5次 反伤-20%
///////////////////////////////////////////////////////////////////////
HP=3, // 回血 百分比 直接触发，回血20%
MP=4, //回蓝 百分比 直接触发，回蓝20%
SHIELD=9, // 护盾 直接触发，获得20%的生命值护盾
////////////////////////////////////////////////////////////////////////
BUFF = 5, // 数值叠加 触发后清零： 暴击率，闪避率等，触发后效果取消
////////////////////////////////////////////////////////////////////////////////
STATS=6, // 状态 待定
WFUNY=7, // 风怒 次数 叠加 ，如额外5次 风怒
D_SKILL=8, //两次技能 次数 叠加，如额外5次 两次技能
C_MSKILL=11, // 必杀技能必暴 次数 叠加 ，如额外5次 必杀技能必暴
C_ATK=12, // 普工必爆 次数 叠加 ，如额外5次 普工必爆
C_SKILL=13, // 一般技能必暴 次数 叠加 ，如额外5次 一般技能必暴
}
export enum TalTarget {
@@ -48,7 +53,6 @@ export enum TalAttrs {
CRITICAL=Attrs.CRITICAL, // 暴击率
AP=Attrs.AP, // 攻击力
MP=Attrs.MAP, // 魔法攻击力
DMG_RED=Attrs.DMG_RED, // 魔法防御
}
/**
* 天赋配置接口
@@ -112,7 +116,7 @@ export const talConf: Record<number, ItalConf> = {
desc:"被攻击3次后, 给于目标50%的伤害"},
7102:{uuid:7102,name:"护盾",triType:TriType.DMG,Trigger:3,count:1,target:TalTarget.SELF,effet:TalEffet.SHIELD,vType:BType.RATIO, value:20,attrs:TalAttrs.NON,
desc:"被攻击3次后, 获得20%的生命值护盾"},
7103:{uuid:7103,name:"减伤",triType:TriType.DMG,Trigger:3,count:1,target:TalTarget.ENEMY,effet:TalEffet.DMG_RED,vType:BType.RATIO, value:50,attrs:TalAttrs.DMG_RED,
7103:{uuid:7103,name:"减伤",triType:TriType.DMG,Trigger:3,count:1,target:TalTarget.ENEMY,effet:TalEffet.DMG_RED,vType:BType.RATIO, value:50,attrs:TalAttrs.NON,
desc:"被攻击3次后, 下1次伤害减50%"},

107
assets/script/game/hero/HeroAtkSystem.ts
View File

@@ -30,7 +30,7 @@ interface FinalData {
*
* 重要概念：
* - damageEvent.Attrs: 施法者属性快照（创建技能时保存）
* - targetAttrs: 被攻击者实时属性
* - TAttrsComp: 被攻击者实时属性
* - 属性来源规范：攻击判定用施法者，防御判定用被攻击者
*/
@ecs.register('HeroAtkSystem')
@@ -51,10 +51,10 @@ export class HeroAtkSystem extends ecs.ComblockSystem implements ecs.ISystemUpd
*/
update(e: ecs.Entity): void {
if(!smc.mission.play || smc.mission.pause) return;
const model = e.get(HeroAttrsComp);
const TAttrsComp = e.get(HeroAttrsComp);
const damageQueue = e.get(DamageQueueComp);
if (!model || !damageQueue || damageQueue.isEmpty()) return;
if (!TAttrsComp || !damageQueue || damageQueue.isEmpty()) return;
// 标记正在处理
damageQueue.isProcessing = true;
@@ -73,13 +73,13 @@ export class HeroAtkSystem extends ecs.ComblockSystem implements ecs.ISystemUpd
if (this.debugMode) {
const casterName = damageEvent.caster?.ent?.get(HeroAttrsComp)?.hero_name || "未知";
const casterUuid = damageEvent.caster?.ent?.get(HeroAttrsComp)?.hero_uuid || 0;
console.log(`[HeroAtkSystem] 英雄${model.hero_name} (uuid: ${model.hero_uuid}) 受到 ${casterName}(uuid: ${casterUuid}）的 伤害 ${FDData.damage},${FDData.isCrit?"暴击":"普通"}攻击，技能ID ${damageEvent.s_uuid}`);
console.log(`[HeroAtkSystem] 英雄${TAttrsComp.hero_name} (uuid: ${TAttrsComp.hero_uuid}) 受到 ${casterName}(uuid: ${casterUuid}）的 伤害 ${FDData.damage},${FDData.isCrit?"暴击":"普通"}攻击，技能ID ${damageEvent.s_uuid}`);
}
// 如果目标已死亡，停止处理后续伤害
if (model.is_dead) {
if (TAttrsComp.is_dead) {
if (this.debugMode) {
console.log(`[HeroAtkSystem] ${model.hero_name} 已死亡，停止处理剩余伤害`);
console.log(`[HeroAtkSystem] ${TAttrsComp.hero_name} 已死亡，停止处理剩余伤害`);
}
damageQueue.clear(); // 清空剩余伤害
break;
@@ -91,7 +91,7 @@ export class HeroAtkSystem extends ecs.ComblockSystem implements ecs.ISystemUpd
e.remove(DamageQueueComp);
if (this.debugMode && processedCount > 0) {
console.log(`[HeroAtkSystem] ${model.hero_name} 伤害队列处理完成，共处理 ${processedCount} 个伤害事件`);
console.log(`[HeroAtkSystem] ${TAttrsComp.hero_name} 伤害队列处理完成，共处理 ${processedCount} 个伤害事件`);
}
}
}
@@ -109,7 +109,7 @@ export class HeroAtkSystem extends ecs.ComblockSystem implements ecs.ISystemUpd
* - HIT: 命中率（用于闪避计算）
* - AP/MAP: 攻击力（基础伤害计算）
*
* ✅ 正确使用被攻击者属性（targetAttrs - 实时）：
* ✅ 正确使用被攻击者属性（TAttrsComp - 实时）：
* - DODGE: 闪避率（用于闪避计算）
* - SHIELD_MAX: 护盾最大值（护盾吸收）
* - hp: 当前生命值（伤害应用）
@@ -124,17 +124,17 @@ export class HeroAtkSystem extends ecs.ComblockSystem implements ecs.ISystemUpd
* @returns 最终伤害数据（包含伤害值、暴击标记、闪避标记）
*/
private doAttack(target: ecs.Entity, damageEvent: DamageEvent): FinalData {
const targetAttrs = target.get(HeroAttrsComp);
const TAttrsComp = target.get(HeroAttrsComp);
const targetView = target.get(HeroViewComp);
let reDate:FinalData={
damage:0,
isCrit:false,
isDodge:false,
}
if (!targetAttrs || targetAttrs.is_dead) return reDate;
if (!TAttrsComp || TAttrsComp.is_dead) return reDate;
const caster = damageEvent.caster;
const attackerModel = caster?.ent?.get(HeroAttrsComp);
const attackerTAttrsComp = caster?.ent?.get(HeroAttrsComp);
// 获取技能配置
const skillConf = SkillSet[damageEvent.s_uuid];
@@ -145,19 +145,19 @@ export class HeroAtkSystem extends ecs.ComblockSystem implements ecs.ISystemUpd
// 闪避判定
// 闪避成功概率 = 被攻击者闪避率 - 施法者命中率
// targetAttrs.Attrs[Attrs.DODGE]: 被攻击者的实时闪避属性
// TAttrsComp.Attrs[Attrs.DODGE]: 被攻击者的实时闪避属性
// damageEvent.Attrs[Attrs.HIT]: 施法者在技能创建时的命中属性快照
const isDodge =this.checkChance((targetAttrs.Attrs[Attrs.DODGE]-damageEvent.Attrs[Attrs.HIT]) || 0);
const isDodge =this.checkChance((TAttrsComp.Attrs[Attrs.DODGE]-damageEvent.Attrs[Attrs.HIT]) || 0);
if (isDodge) {
// TODO: 触发闪避视图表现
reDate.isDodge=true;
return reDate;
}
// 暴击判定
// 使用施法者的暴击率属性（damageEvent.Attrs 快照），- 被攻击者的暴击抗性属性targetAttrs.Attrs[Attrs.CRITICAL_RESIST]
const isCrit = this.checkChance(damageEvent.Attrs[Attrs.CRITICAL]-targetAttrs.Attrs[Attrs.CRITICAL_RESIST]);
// 使用施法者的暴击率属性（damageEvent.Attrs 快照），- 被攻击者的暴击抗性属性TAttrsComp.Attrs[Attrs.CRITICAL_RESIST]
const isCrit = this.checkChance(damageEvent.Attrs[Attrs.CRITICAL]-TAttrsComp.Attrs[Attrs.CRITICAL_RESIST]);
// 计算基础伤害
let damage = this.dmgCount(damageEvent,targetAttrs);
let damage = this.dmgCount(damageEvent,TAttrsComp);
if (isCrit) {
// 暴击伤害计算
// 使用施法者的暴击伤害加成属性（damageEvent.Attrs 快照）
@@ -165,20 +165,22 @@ export class HeroAtkSystem extends ecs.ComblockSystem implements ecs.ISystemUpd
const casterCritDmg = damageEvent.Attrs[Attrs.CRITICAL_DMG] || 0;
damage = Math.floor(damage * (1 + (FightSet.CRIT_DAMAGE + casterCritDmg) / 100));
reDate.isCrit=true;
attackerModel?.useValueTalByAttr(Attrs.CRITICAL); // 清除施法者的暴击buff
attackerTAttrsComp?.useValueTalByAttr(Attrs.CRITICAL); // 清除施法者的暴击buff
}
// 护盾吸收
damage =Math.floor(this.absorbShield(targetAttrs, damage))
damage =Math.floor(this.absorbShield(TAttrsComp, damage))
if (damage <= 0) return reDate;
// 应用伤害到数据层
targetAttrs.hp -= damage;
targetAttrs.atked_count++;
TAttrsComp.hp -= damage;
TAttrsComp.atked_count++;
//反伤判定 并应用到施法者
this.check_thorns(TAttrsComp, caster?.ent,damage);
// 击退判定
// 使用施法者的击退概率属性（damageEvent.Attrs 快照）
// 击退成功后需要清理施法者的相关天赋buff
const isBack = this.checkChance(damageEvent.Attrs[Attrs.BACK_CHANCE] || 0);
if (isBack) attackerModel?.useValueTalByAttr(Attrs.BACK_CHANCE);
if (isBack) attackerTAttrsComp?.useValueTalByAttr(Attrs.BACK_CHANCE);
// ✅ 触发视图层表现（伤害数字、受击动画、后退）
@@ -186,7 +188,7 @@ export class HeroAtkSystem extends ecs.ComblockSystem implements ecs.ISystemUpd
// 检查死亡
if (targetAttrs.hp <= 0) {
if (TAttrsComp.hp <= 0) {
this.doDead(target);
// ✅ 触发死亡视图表现
if (targetView) {
@@ -195,12 +197,27 @@ export class HeroAtkSystem extends ecs.ComblockSystem implements ecs.ISystemUpd
}
if (this.debugMode) {
console.log(`[HeroAtkSystem] ${targetAttrs.hero_name} 受到 ${damage} 点伤害 (暴击: ${isCrit})`);
console.log(`[HeroAtkSystem] ${TAttrsComp.hero_name} 受到 ${damage} 点伤害 (暴击: ${isCrit})`);
}
reDate.damage=damage;
return reDate;
}
check_thorns(TAttrsComp:HeroAttrsComp, caster: ecs.Entity, damage:number) {
// 检查目标是否有反伤属性
if (!caster||damage<=0) return;
let thornsDamage=0;
thornsDamage=TAttrsComp.Attrs[Attrs.THORNS]||0+TAttrsComp.useCountValTal(Attrs.THORNS);
let CAttrs=caster.get(HeroAttrsComp);
// 计算反伤伤害
let thornsDmg=Math.floor(thornsDamage*damage/100);
// 应用反伤伤害到数据层
CAttrs.hp -= thornsDmg;
CAttrs.atked_count++;
let CView=caster.get(HeroViewComp);
// ✅ 触发视图层表现（伤害数字、受击动画、后退）
if (CView) CView.do_atked(thornsDmg, false, SkillSet[5000].uuid, false);
}
/**
* 详细伤害计算核心方法
*
@@ -343,16 +360,16 @@ export class HeroAtkSystem extends ecs.ComblockSystem implements ecs.ISystemUpd
* 这确保了死亡逻辑的单一性和一致性
*/
private doDead(entity: ecs.Entity): void {
const model = entity.get(HeroAttrsComp);
if (!model || model.is_dead) return;
const TAttrsComp = entity.get(HeroAttrsComp);
if (!TAttrsComp || TAttrsComp.is_dead) return;
model.is_dead = true;
TAttrsComp.is_dead = true;
// 触发死亡事件
this.onDeath(entity);
if (this.debugMode) {
console.log(`[HeroAtkSystem] ${model.hero_name} 死亡`);
console.log(`[HeroAtkSystem] ${TAttrsComp.hero_name} 死亡`);
}
}
@@ -395,24 +412,24 @@ export class HeroAtkSystem extends ecs.ComblockSystem implements ecs.ISystemUpd
* 2. 如果护盾值 < 伤害值：部分吸收，剩余伤害 = 原伤害 - 护盾值
* 3. 护盾被击破时，重置护盾最大值属性
*
* @param model 被攻击者的属性组件（包含当前护盾值）
* @param TAttrsComp 被攻击者的属性组件（包含当前护盾值）
* @param damage 原始伤害值
* @returns 剩余伤害值（护盾吸收后的结果）
*/
private absorbShield(model: HeroAttrsComp, damage: number): number {
if (model.shield <= 0) return damage;
private absorbShield(TAttrsComp: HeroAttrsComp, damage: number): number {
if (TAttrsComp.shield <= 0) return damage;
if (model.shield >= damage) {
model.shield -= damage;
if (model.shield <= 0) {
model.shield = 0;
model.Attrs[Attrs.SHIELD_MAX] = 0;
if (TAttrsComp.shield >= damage) {
TAttrsComp.shield -= damage;
if (TAttrsComp.shield <= 0) {
TAttrsComp.shield = 0;
TAttrsComp.Attrs[Attrs.SHIELD_MAX] = 0;
}
return 0;
} else {
const remainingDamage = damage - model.shield;
model.shield = 0;
model.Attrs[Attrs.SHIELD_MAX] = 0;
const remainingDamage = damage - TAttrsComp.shield;
TAttrsComp.shield = 0;
TAttrsComp.Attrs[Attrs.SHIELD_MAX] = 0;
return remainingDamage;
}
}
@@ -430,11 +447,11 @@ export class HeroAtkSystem extends ecs.ComblockSystem implements ecs.ISystemUpd
* @todo 当前对怪物实体直接返回，后续可以根据需求扩展怪物的被攻击逻辑
*/
private onAttacked(entity: ecs.Entity): void {
const model = entity.get(HeroAttrsComp);
if (!model || model.is_dead) return;
const TAttrsComp = entity.get(HeroAttrsComp);
if (!TAttrsComp || TAttrsComp.is_dead) return;
// 这里可以添加被攻击时的特殊处理逻辑
if (model.fac === FacSet.MON) return;
if (TAttrsComp.fac === FacSet.MON) return;
// 例如：触发某些天赋效果、反击逻辑等
}
@@ -458,13 +475,13 @@ export class HeroAtkSystem extends ecs.ComblockSystem implements ecs.ISystemUpd
* @important 死亡事件应该幂等，避免重复触发
*/
private onDeath(entity: ecs.Entity): void {
const model = entity.get(HeroAttrsComp);
if (!model) return;
const TAttrsComp = entity.get(HeroAttrsComp);
if (!TAttrsComp) return;
if (model.fac === FacSet.MON) {
if (TAttrsComp.fac === FacSet.MON) {
// 怪物死亡处理
this.scheduleDrop(entity);
} else if (model.fac === FacSet.HERO) {
} else if (TAttrsComp.fac === FacSet.HERO) {
// 英雄死亡处理
this.scheduleHeroDeath(entity);
}

34
assets/script/game/hero/HeroAttrsComp.ts
View File

@@ -441,6 +441,13 @@ export class HeroAttrsComp extends ecs.Comp {
}
/**
* 添加数值型天赋buff 数值会进行累加，count 时叠加层数
* @param t_uuid 天赋唯一标识
* @param attrIndex 属性索引
* @param bType buff类型(VALUE:数值型, RATIO:百分比型)
* @param value buff值
*/
addValueTal(t_uuid: number, attrIndex?: number, bType?: BType, value: number = 0) {
if (attrIndex === undefined || bType === undefined) return;
const buff = this.BUFFS_TAL[t_uuid];
@@ -452,6 +459,12 @@ export class HeroAttrsComp extends ecs.Comp {
}
this.recalculateSingleAttr(attrIndex);
}
/**
* 添加计数型天赋，每次添加数值已最新额覆盖久的，count为可用次数
* @param eff 天赋效果ID
* @param value 天赋值
*/
addCountTal(eff: number, value: number) {
const t = this.Talents[eff] || { value: 0, count: 0 };
t.value = value;
@@ -459,18 +472,34 @@ export class HeroAttrsComp extends ecs.Comp {
this.Talents[eff] = t;
}
/**
* 使用计数型天赋，如风怒 ，必爆等天赋，只需要返回是否暴击的，使用这个方法
* @param eff 天赋效果ID
* @returns 是否使用成功
*/
useCountTal(eff: number): boolean {
const t = this.Talents[eff];
if (!t || t.count <= 0) return false;
t.count -= 1;
return true;
}
/**
* 使用计数型天赋并返回天赋值，如额外5次 伤害+20% ，5次受伤，免伤20% 使用这个方法
* @param eff 天赋效果ID
* @returns 天赋值
*/
useCountValTal(eff: number): number {
const t = this.Talents[eff];
if (!t || t.value <= 0) return 0;
t.count -= 1;
return t.value;
}
/**
* 根据UUID移除数值型天赋buff
* @param t_uuid 天赋唯一标识
*/
useValueTalByUuid(t_uuid: number) {
const buff = this.BUFFS_TAL[t_uuid];
if (!buff) return;
@@ -478,6 +507,11 @@ export class HeroAttrsComp extends ecs.Comp {
delete this.BUFFS_TAL[t_uuid];
this.recalculateSingleAttr(attrIndex);
}
/**
* 根据属性索引移除数值型天赋buff
* @param attrIndex 属性索引
*/
useValueTalByAttr(attrIndex: number) {
let changed = false;
for (const key in this.BUFFS_TAL) {