feat(战斗系统): 添加伤害比例属性并应用到伤害计算

在SDataCom中添加dmg_ratio属性用于调整伤害比例
修改HeroAtkSystem中的伤害计算公式，将dmg_ratio纳入计算

assets/script/game/common/config/TalSet.ts

@@ -9,28 +9,30 @@ export enum TriType {
     ATK = 2,      //普通攻击触发
     DMG = 3,    // 受伤触发
     SKILL = 4, // 技能触发
-    HPL = 5,    // 失去生命值触发
-    HPA = 6,    // 获得生命值触发
-    INIT = 7,       // 初始触发,如:多1个技能
-    DEAD = 8          // 基于死亡触发
+    MAX = 5, // 必杀触发
+    HPL = 6,    // 失去生命值触发
+    HPA = 7,    // 获得生命值触发
+    INIT = 8,       // 初始触发,如:多1个技能
+    DEAD = 9,          // 基于死亡触发
 }
 
 
 
 export enum TalEffet {
-    DMG=1, // 伤害
-    HP=2, // 回血 百分比
-    MP=3, //回蓝 百分比
-    BUFF = 4, // 暴击率，闪避率等，可叠加的触发后清零
-    STATS=5, // 状态
-    WFUNY=6, // 风怒
-    SPLASH=7, // 溅射
-    D_SKILL=8, //两次技能
-    SHIELD=9, // 护盾
-    LDMG=10, // 减伤
-    C_ATK=11, // 普工必爆
-    C_SKILL=12, // 一般技能必暴
-    C_MSKILL=13, // 必杀技能必暴
+    ATK_DMG=1, // 伤害
+    SKILL_DMG=2, // 技能伤害  
+    HP=3, // 回血 百分比
+    MP=4, //回蓝 百分比
+    BUFF = 5, // 暴击率，闪避率等，可叠加的触发后清零
+    STATS=6, // 状态
+    WFUNY=7, // 风怒
+    SPLASH=8, // 溅射
+    D_SKILL=9, //两次技能
+    SHIELD=10, // 护盾
+    LDMG=11, // 减伤
+    C_ATK=12, // 普工必爆
+    C_SKILL=13, // 一般技能必暴
+    C_MSKILL=14, // 必杀技能必暴
 }
 
 export enum TalTarget {
@@ -107,7 +109,7 @@ export const talConf: Record<number, ItalConf> = {
         desc:"普通攻击10次后, 下次一般技能额外释放1次,伤害100%"},
     
     /*** 受伤触发 ***/
-    7101:{uuid:7101,name:"反击",triType:TriType.DMG,Trigger:3,count:1,target:TalTarget.ENEMY,effet:TalEffet.DMG,vType:BType.RATIO, value:50,attrs:TalAttrs.NON,
+    7101:{uuid:7101,name:"反击",triType:TriType.DMG,Trigger:3,count:1,target:TalTarget.ENEMY,effet:TalEffet.ATK_DMG,vType:BType.RATIO, value:50,attrs:TalAttrs.NON,
         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%的生命值护盾"},

assets/script/game/hero/HeroAtkSystem.ts

@@ -156,9 +156,9 @@ export class HeroAtkSystem extends ecs.ComblockSystem  implements ecs.ISystemUpd
         // 暴击判定
         // 使用施法者的暴击率属性（damageEvent.Attrs 快照）
         const isCrit = this.checkChance(damageEvent.Attrs[Attrs.CRITICAL]);
-        if (isCrit)  attackerModel?.clearTalBuffByAttr(Attrs.CRITICAL);
+        if (isCrit)  attackerModel?.useValueTalByAttr(Attrs.CRITICAL);   // 清除施法者的暴击buff
         // 计算伤害
-        let damage = this.dmgCount(damageEvent.Attrs,targetAttrs.Attrs,damageEvent.s_uuid);
+        let damage = this.dmgCount(damageEvent,targetAttrs.Attrs);
         if (isCrit) {
             // 暴击伤害计算
             // 使用施法者的暴击伤害加成属性（damageEvent.Attrs 快照）
@@ -179,7 +179,7 @@ export class HeroAtkSystem extends ecs.ComblockSystem  implements ecs.ISystemUpd
         // 使用施法者的击退概率属性（damageEvent.Attrs 快照）
         // 击退成功后需要清理施法者的相关天赋buff
         const isBack = this.checkChance(damageEvent.Attrs[Attrs.BACK_CHANCE] || 0);
-        if (isBack) attackerModel?.clearTalBuffByAttr(Attrs.BACK_CHANCE);
+        if (isBack) attackerModel?.useValueTalByAttr(Attrs.BACK_CHANCE);
 
 
         // ✅ 触发视图层表现（伤害数字、受击动画、后退）
@@ -203,48 +203,124 @@ export class HeroAtkSystem extends ecs.ComblockSystem  implements ecs.ISystemUpd
         return reDate;
     }
     /**
-     * 基础伤害计算
-     * 根据技能配置和施法者属性计算基础伤害值
+     * 详细伤害计算核心方法
      * 
-     * @param CAttrs 施法者属性快照（包含攻击力等关键属性）
-     * @param s_uuid 技能ID，用于获取技能配置
-     * @returns 基础伤害值（未考虑暴击、抗性等因素）
+     * 这是整个战斗系统中最核心的伤害计算方法，负责根据施法者属性、目标属性和技能配置
+     * 计算最终的基础伤害值。该方法采用多阶段的伤害计算公式，综合考虑了物理和魔法伤害
+     * 以及各种属性加成和抗性减免。
      * 
-     * @todo 后续可以扩展更多伤害计算公式：
-     * - 技能倍率加成
-     * - 元素伤害计算
-     * - 真实伤害/魔法伤害/物理伤害区分
+     * 计算流程：
+     * 1. 获取技能配置
+     * 2. 计算原始物理伤害和魔法伤害
+     * 3. 应用防御减免
+     * 4. 应用物理/魔法攻击力和抗性修正
+     * 5. 应用元素属性加成和抗性修正
+     * 6. 应用最终伤害减免
+     * 7. 确保伤害值非负
+     * 
+     * @param CAttrs 施法者属性快照对象，包含所有攻击力、属性加成等战斗属性
+     * @param TAttrs 目标属性对象，包含所有防御力、抗性等防御属性
+     * @param s_uuid 技能ID，用于获取技能配置信息和伤害类型
+     * @returns 经过完整计算后的最终伤害值（未考虑暴击）
+     * 
+     * @important 注意事项：
+     * - 此方法计算的是基础伤害，暴击计算在外部处理
+     * - 所有除法和乘法计算后都进行取整操作，确保游戏中的伤害值为整数
+     * - 元素伤害只应用于魔法伤害部分
      */
-    private dmgCount(CAttrs:any,TAttrs:any,s_uuid:number){
-        let sConf = SkillSet[s_uuid];
+    private dmgCount(damageEvent:any,TAttrs:any){
+        // 1. 获取技能配置 - 如果技能不存在，直接返回0伤害
+        const CAttrs=damageEvent.Attrs;
+        let sConf = SkillSet[damageEvent.s_uuid];
         if (!sConf) return 0;
-        let apBase = (sConf.ap||0)*CAttrs[Attrs.AP]/100;
-        let mapBase = (sConf.map||0)*CAttrs[Attrs.MAP]/100;
-        const def = (TAttrs[Attrs.DEF]||0);
-        const mdef = (TAttrs[Attrs.MDEF]||0);
-        const apRed = def / (def + FightSet.DEF_C);
-        const mapRed = mdef / (mdef + FightSet.MDEF_C);
-        let apAfter = Math.floor(apBase * (1 - apRed));
-        let mapAfter = Math.floor(mapBase * (1 - mapRed));
+        
+        // 2. 计算原始物理伤害和魔法伤害
+        // 物理伤害基础值 = 技能物理倍率 * (施法者物理攻击力 + 额外物理伤害) / 100 * 伤害比例
+        let apBase = (sConf.ap||0)*(CAttrs[Attrs.AP]+damageEvent.ext_dmg)/100*damageEvent.dmg_ratio;
+        // 魔法伤害基础值 = 技能魔法倍率 * (施法者魔法攻击力 + 额外魔法伤害) / 100 * 伤害比例
+        let mapBase = (sConf.map||0)*(CAttrs[Attrs.MAP]+damageEvent.ext_dmg)/100*damageEvent.dmg_ratio;
+        
+        // 3. 获取目标防御属性
+        const def = (TAttrs[Attrs.DEF]||0);    // 目标物理防御
+        const mdef = (TAttrs[Attrs.MDEF]||0);  // 目标魔法防御
+        
+        // 4. 计算防御减免系数（采用公式：防御/(防御+常数)，确保防御值不会导致伤害减到0）
+        const apRed = def / (def + FightSet.DEF_C);   // 物理防御减免系数
+        const mapRed = mdef / (mdef + FightSet.MDEF_C); // 魔法防御减免系数
+        
+        // 5. 应用防御减免到基础伤害，向下取整
+        let apAfter = Math.floor(apBase * (1 - apRed));   // 物理伤害 - 防御减免
+        let mapAfter = Math.floor(mapBase * (1 - mapRed)); // 魔法伤害 - 防御减免
+        
+        // 6. 应用物理/魔法攻击力和抗性修正
+        // 物理伤害修正：基础伤害 * (1 + 物理攻击力加成%) * (1 - 目标物理抗性%)
         apAfter = this.applyPR(apAfter, CAttrs[Attrs.PHYS_POWER]||0, TAttrs[Attrs.PHYS_RES]||0);
+        // 魔法伤害修正：基础伤害 * (1 + 魔法攻击力加成%) * (1 - 目标魔法抗性%)
         mapAfter = this.applyPR(mapAfter, CAttrs[Attrs.MAGIC_POWER]||0, TAttrs[Attrs.MAGIC_RES]||0);
+        
+        // 7. 根据技能元素类型，应用元素属性加成和抗性修正
         switch (sConf.DType) {
             case DType.ICE:
+                // 冰系伤害修正：魔法伤害 * (1 + 冰系攻击力加成%) * (1 - 目标冰系抗性%)
                 mapAfter = this.applyPR(mapAfter, CAttrs[Attrs.ICE_POWER]||0, TAttrs[Attrs.ICE_RES]||0);
                 break;
             case DType.FIRE:
+                // 火系伤害修正：魔法伤害 * (1 + 火系攻击力加成%) * (1 - 目标火系抗性%)
                 mapAfter = this.applyPR(mapAfter, CAttrs[Attrs.FIRE_POWER]||0, TAttrs[Attrs.FIRE_RES]||0);
                 break;
             case DType.WIND:
+                // 风系伤害修正：魔法伤害 * (1 + 风系攻击力加成%) * (1 - 目标风系抗性%)
                 mapAfter = this.applyPR(mapAfter, CAttrs[Attrs.WIND_POWER]||0, TAttrs[Attrs.WIND_RES]||0);
                 break;
         }
+        
+        // 8. 计算最终总伤害（物理伤害 + 魔法伤害）
         let total = apAfter + mapAfter;
+        
+        // 9. 应用最终伤害减免效果（如特殊天赋、buff等提供的减免）
         total = Math.floor(total * (1 - ((TAttrs[Attrs.DAMAGE_REDUCTION]||0)/100)));
+        
+        // 10. 确保伤害值非负，返回最终伤害
         return Math.max(0,total);
     }
 
+/**
+     * 应用攻击力加成和抗性减免的通用计算方法
+     * 
+     * 这是一个核心的伤害修正计算方法，用于处理各种类型的攻击力加成和抗性减免。
+     * 该方法采用乘法叠加的方式，分别应用攻击者的加成属性和目标的抗性属性。
+     * 
+     * 计算公式：
+     * 最终值 = 基础值 × (1 + 攻击力加成% / 100) × (1 - 抗性% / 100)
+     * 
+     * 适用场景：
+     * - 物理攻击力加成和物理抗性减免
+     * - 魔法攻击力加成和魔法抗性减免
+     * - 元素攻击力加成和元素抗性减免
+     * - 其他需要同时考虑加成和减免的属性修正
+     * 
+     * 计算逻辑说明：
+     * 1. 首先将百分比转换为小数形式（除以100）
+     * 2. 应用攻击者的加成：基础值 × (1 + 加成系数)
+     * 3. 应用目标的抗性：上一步结果 × (1 - 抗性系数)
+     * 4. 向下取整，确保结果为整数
+     * 
+     * @param base 基础值（通常是经过防御减免后的伤害值）
+     * @param power 攻击者的攻击力加成值（百分比形式，如50表示50%）
+     * @param res 目标的抗性值（百分比形式，如30表示30%）
+     * @returns 经过攻击力加成和抗性减免后的最终值（向下取整）
+     * 
+     * @important 注意事项：
+     * - 当抗性值大于100时，可能导致最终值为负数或零
+     * - 所有计算结果会向下取整，确保游戏中的数值为整数
+     * - 此方法可以被多次调用，以叠加不同类型的加成和减免
+     */
     private applyPR(base: number, power: number, res: number): number {
+        // 计算公式：基础值 × (1 + 攻击力加成%) × (1 - 抗性%)
+        // 1. 将百分比转换为小数：power/100 和 res/100
+        // 2. 应用攻击力加成：1 + (power/100)
+        // 3. 应用抗性减免：1 - (res/100)
+        // 4. 最终计算并向下取整
         return Math.floor(base * (1 + (power/100)) * (1 - (res/100)));
     }
     /**

assets/script/game/hero/HeroAttrsComp.ts

@@ -35,7 +35,9 @@ export class HeroAttrsComp extends ecs.Comp {
     shield: number = 0;         // 当前护盾
     Attrs: any = [];            // 最终属性数组（经过Buff计算后）
     NeAttrs: any = [];           // 负面状态数组
-    Talents: Record<number, talTrigger> = {};
+     //计数型天赋buff
+    Talents: Record<number, talTrigger> = {};  
+    //数值型天赋buff
     BUFFS_TAL: Record<number, {count:number,BType:BType,attrIndex:number,value: number}> = {};
     
     // ==================== 技能距离缓存 ====================
@@ -407,7 +409,7 @@ export class HeroAttrsComp extends ecs.Comp {
     }
     
  
-    addTalBuff(t_uuid: number, attrIndex?: number, bType?: BType, value: number = 0) {
+    addValueTal(t_uuid: number, attrIndex?: number, bType?: BType, value: number = 0) {
         if (attrIndex === undefined || bType === undefined) return;
         const buff = this.BUFFS_TAL[t_uuid];
         if (!buff) {
@@ -418,14 +420,33 @@ export class HeroAttrsComp extends ecs.Comp {
         }
         this.recalculateSingleAttr(attrIndex);
     }
-    clearTalBuff(t_uuid: number) {
+    addCountTal(eff: number, value: number) {
+        const t = this.Talents[eff] || { value: 0, count: 0 };
+        t.value = value;
+        t.count += 1;
+        this.Talents[eff] = t;
+    }
+
+    useCountTal(eff: number): boolean {
+        const t = this.Talents[eff];
+        if (!t || t.count <= 0) return false;
+        t.count -= 1;
+        return true;
+    }
+    useCountValTal(eff: number): number {
+        const t = this.Talents[eff];
+        if (!t || t.value <= 0) return 0;
+        t.count -= 1;
+        return t.value;
+    }
+    useValueTalByUuid(t_uuid: number) {
         const buff = this.BUFFS_TAL[t_uuid];
         if (!buff) return;
         const attrIndex = buff.attrIndex;
         delete this.BUFFS_TAL[t_uuid];
         this.recalculateSingleAttr(attrIndex);
     }
-    clearTalBuffByAttr(attrIndex: number) {
+    useValueTalByAttr(attrIndex: number) {
         let changed = false;
         for (const key in this.BUFFS_TAL) {
             const b = this.BUFFS_TAL[Number(key)];
@@ -436,20 +457,7 @@ export class HeroAttrsComp extends ecs.Comp {
         }
         if (changed) this.recalculateSingleAttr(attrIndex);
     }
-    
-    addTalent(eff: number, value: number) {
-        const t = this.Talents[eff] || { value: 0, count: 0 };
-        t.value = value;
-        t.count += 1;
-        this.Talents[eff] = t;
-    }
-    consumeTalent(eff: number): boolean {
-        const t = this.Talents[eff];
-        if (!t || t.count <= 0) return false;
-        t.count -= 1;
-        return true;
-    }
-
+ 
     reset() {
         // 重置为初始状态
         this.hero_uuid = 1001;

assets/script/game/hero/SACastSystem.ts

@@ -143,11 +143,12 @@ export class SACastSystem extends ecs.ComblockSystem implements ecs.ISystemUpdat
         // 1. 播放施法动画
         heroView.playSkillEffect(s_uuid);
 /**********************天赋处理*************************************************************************/
-        // 2. 更新攻击类型的天赋触发值
+        // 2. 更新攻击类型的天赋触发值，技能和必杀级
         if(casterEntity.has(TalComp)){
             const talComp = casterEntity.get(TalComp);
             if (hset === HSSet.atk) talComp.updateCur(TriType.ATK);
-            if (hset != HSSet.atk)   talComp.updateCur(TriType.SKILL);
+            if (hset === HSSet.skill) talComp.updateCur(TriType.SKILL);
+            if (hset === HSSet.max) talComp.updateCur(TriType.MAX);
         }
 /**********************天赋处理*************************************************************************/
         // 获取目标位置
@@ -156,31 +157,54 @@ export class SACastSystem extends ecs.ComblockSystem implements ecs.ISystemUpdat
             console.warn("[SACastSystem] 没有找到有效目标");
             return false;
         }
-        // 2. 延迟创建技能实体（等待动画）
-        const delay = 0.3
-        heroView.scheduleOnce(() => {
-            this.createSkill(s_uuid, heroView,targets);
-        }, delay);
-
-         //风怒wfuny 只针对 普通攻击起效
-        if (hset === HSSet.atk && heroAttrs.consumeTalent(TalEffet.WFUNY)){  
-            heroView.playSkillEffect(s_uuid);
-            //需要再添加 风怒动画
-            this.createSkill(s_uuid, heroView,targets); 
-        }
-        // 双技能 只针对 技能起效
-        if(hset === HSSet.skill && heroAttrs.consumeTalent(TalEffet.D_SKILL)){
-            targets = this.sTargets(heroView, s_uuid);
-            if (targets.length === 0) {
-                console.warn("[SACastSystem] 没有找到有效目标");
-                return false;
+        // 2.1 普通攻击逻辑
+        if (hset === HSSet.atk){
+            let delay = 0.3
+            let ext_dmg = heroAttrs.useCountValTal(TalEffet.ATK_DMG);
+            let splash = heroAttrs.useCountValTal(TalEffet.SPLASH);
+            heroView.scheduleOnce(() => {
+                this.createSkill(s_uuid, heroView,targets,ext_dmg,splash); 
+            }, delay);
+              //风怒wfuny 只针对 普通攻击起效
+            if (heroAttrs.useCountTal(TalEffet.WFUNY)){  
+                let ext2_dmg = heroAttrs.useCountValTal(TalEffet.ATK_DMG);
+                let splash2 = heroAttrs.useCountValTal(TalEffet.SPLASH);
+                let delay = 0.3
+                heroView.playSkillEffect(s_uuid);
+                //需要再添加 风怒动画
+                heroView.scheduleOnce(() => {
+                    this.createSkill(s_uuid, heroView,targets,ext2_dmg,splash2);
+                },delay);
             }
+        }
+        // 2.2 技能攻击逻辑
+        if(hset === HSSet.skill){
+            let delay = 0.3
+            let ext_dmg = heroAttrs.useCountValTal(TalEffet.SKILL_DMG);
+            heroView.scheduleOnce(() => {
+                this.createSkill(s_uuid, heroView,targets,ext_dmg); 
+            }, delay);
+            // 双技能 只针对 技能起效
+            if(heroAttrs.useCountTal(TalEffet.D_SKILL)){
+                let ext2_dmg = heroAttrs.useCountValTal(TalEffet.SKILL_DMG);
+                let delay = 0.3
+                heroView.playSkillEffect(s_uuid);
+                //需要再添加 双技能动画
+                heroView.scheduleOnce(() => {
+                    this.createSkill(s_uuid, heroView,targets,ext2_dmg);
+                },delay);
+            }
+        }
+        // 2.3 必杀技能逻辑
+        if(hset === HSSet.max){
+            let delay = 0.3
             heroView.playSkillEffect(s_uuid);
-            //需要再添加 双技能动画
+            //需要再添加 最大伤害动画
             heroView.scheduleOnce(() => {
                 this.createSkill(s_uuid, heroView,targets);
-            }, delay);
+            },delay);
         }
+       
         
 
         return true;
@@ -190,7 +214,7 @@ export class SACastSystem extends ecs.ComblockSystem implements ecs.ISystemUpdat
     /**
      * 创建技能实体
      */
-    private createSkill(s_uuid: number, caster: HeroViewComp,targets:Vec3[]=[],ext_dmg:number=0) {
+    private createSkill(s_uuid: number, caster: HeroViewComp,targets:Vec3[]=[],ext_dmg:number=0,splash:number=0) {
         // 检查节点有效性
         if (!caster.node || !caster.node.isValid) {
             console.warn("[SACastSystem] 施法者节点无效");
@@ -215,7 +239,7 @@ export class SACastSystem extends ecs.ComblockSystem implements ecs.ISystemUpdat
         const targetPos = targets[0]; // 使用第一个目标位置
         // console.log(`[SACastSystem]: ${s_uuid}, 起始位置: ${startPos}, 目标位置: ${targetPos}`);
         // 加载技能实体（包括预制体、组件初始化等）
-        skill.load(startPos, parent, s_uuid, targetPos, caster,ext_dmg);
+        skill.load(startPos, parent, s_uuid, targetPos, caster,ext_dmg,splash);
         
     }
     /**

assets/script/game/hero/TalComp.ts

@@ -189,6 +189,10 @@ export class TalComp extends ecs.Comp {
         } 
     }
     //执行天赋触发效果
+    // 功能：
+    // - 根据天赋类型执行相应的效果
+    // - 支持计数型和数值型天赋 
+    // --heroAttrs.addTalent 是计数型天赋buff heroAttrs.addTalBuff 是数值型天赋buff
     doTriggerTal(uuid: number) {
         // 检查天赋是否存在
         if (!this.Tals[uuid]) {
@@ -198,23 +202,38 @@ export class TalComp extends ecs.Comp {
         const talent = this.Tals[uuid];
         const heroAttrs=this.ent.get(HeroAttrsComp);
         switch(talent.effet){
+            case TalEffet.ATK_DMG:
+                heroAttrs.addCountTal(TalEffet.ATK_DMG, talent.value + talent.value_add);
+                break;
+            case TalEffet.SKILL_DMG:
+                heroAttrs.addCountTal(TalEffet.SKILL_DMG, talent.value + talent.value_add);
+                break;
+            case TalEffet.LDMG:
+                heroAttrs.addCountTal(TalEffet.LDMG, talent.value + talent.value_add);
+                break;
+            // case TalEffet.HP:
+            //     heroAttrs.addCountTal(TalEffet.HP, talent.value + talent.value_add);
+            //     break;
+            // case TalEffet.MP:
+            //     heroAttrs.addCountTal(TalEffet.MP, talent.value + talent.value_add);
+            //     break;
             case TalEffet.WFUNY:
-                heroAttrs.addTalent(TalEffet.WFUNY, talent.value + talent.value_add);
+                heroAttrs.addCountTal(TalEffet.WFUNY, talent.value + talent.value_add);
                 break;
             case TalEffet.D_SKILL:
-                heroAttrs.addTalent(TalEffet.D_SKILL, talent.value + talent.value_add);
+                heroAttrs.addCountTal(TalEffet.D_SKILL, talent.value + talent.value_add);
                 break;
             case TalEffet.C_ATK:
-                    heroAttrs.addTalent(TalEffet.C_ATK, talent.value + talent.value_add);
+                    heroAttrs.addCountTal(TalEffet.C_ATK, talent.value + talent.value_add);
                 break;
             case TalEffet.C_SKILL:
-                    heroAttrs.addTalent(TalEffet.C_SKILL, talent.value + talent.value_add);
+                    heroAttrs.addCountTal(TalEffet.C_SKILL, talent.value + talent.value_add);
                 break;
             case TalEffet.C_MSKILL:
-                    heroAttrs.addTalent(TalEffet.C_MSKILL, talent.value + talent.value_add);
+                    heroAttrs.addCountTal(TalEffet.C_MSKILL, talent.value + talent.value_add);
                 break;
             case TalEffet.BUFF:
-                heroAttrs.addTalBuff(talent.uuid, talent.attrs, talent.vType, talent.value + talent.value_add);
+                heroAttrs.addValueTal(talent.uuid, talent.attrs, talent.vType, talent.value + talent.value_add);
                 break;
         }
     }

assets/script/game/skill/SDataCom.ts

@@ -12,6 +12,9 @@ export class SDataCom extends ecs.Comp {
     group:BoxSet=BoxSet.HERO
     fac: number = 0;            // 0:hero 1:monster
     s_uuid:number=0
+    ext_dmg:number=0 //额外伤害
+    splash:number=0 //溅射伤害 
+    dmg_ratio:number=1 //伤害比例
     hit_count:number=0 //击中数量
     reset() {
         this.Attrs=null
@@ -20,6 +23,9 @@ export class SDataCom extends ecs.Comp {
         this.s_uuid=0
         this.caster=null
         this.hit_count=0
+        this.ext_dmg=0
+        this.splash=0
+        this.dmg_ratio=1
     }
 }
 

assets/script/game/skill/Skill.ts

@@ -29,7 +29,7 @@ export class Skill extends ecs.Entity {
         this.addComponents<SMoveDataComp>(SMoveDataComp);
     }
     load(startPos: Vec3, parent: Node, s_uuid: number, targetPos: Vec3,
-        caster:HeroViewComp,ext_dmg:number=0) {
+        caster:HeroViewComp,ext_dmg:number=0,splash:number=0) {
         const config = SkillSet[s_uuid];
         
         if (!config) {
@@ -93,6 +93,8 @@ export class Skill extends ecs.Entity {
         sDataCom.Attrs={...cAttrsComp.Attrs}
         sDataCom.s_uuid=s_uuid
         sDataCom.fac=cAttrsComp.fac
+        sDataCom.ext_dmg=ext_dmg
+        sDataCom.splash=splash
     }
 
     /** 模块资源释放 */

assets/script/game/wx_clound_client_api/USAGE.md

@@ -201,10 +201,10 @@ console.log("道具1001数量:", itemInfo.result.data.count);
 const talents = await WxCloudApi.getTalents();
 
 // 添加天赋点
-const result = await WxCloudApi.addTalent(1001, 1);
+const result = await WxCloudApi.addCountTal(1001, 1);
 
 // 消耗天赋点
-const result = await WxCloudApi.consumeTalent(1001, 1);
+const result = await WxCloudApi.useCountTal(1001, 1);
 ```
 
 ### 装备操作