技能系统修改为 只负责普通技能

assets/script/game/skill/HeroSkillSystem.ts

@@ -1,7 +1,6 @@
 import { Node, Vec3 } from "cc";
 import { ecs } from "../../../../extensions/oops-plugin-framework/assets/libs/ecs/ECS";
 import { HeroViewComp } from "../hero/HeroViewComp";
-import { HeroSkillsComp } from "./heroSkillsComp";
 import { SkillSet, TargetGroup, TargetType } from "../common/config/SkillSet";
 import { CdType } from "../common/config/SkillSet";
 import { oops } from "db://oops-framework/core/Oops";
@@ -23,109 +22,45 @@ export class HeroSkillSystem extends ecs.ComblockSystem implements ecs.ISystemUp
         oops.message.on(GameEvent.MissionEnd, this.clear_timer, this);
     }
     filter(): ecs.IMatcher {
-        return ecs.allOf(HeroSkillsComp, HeroViewComp);
+        return ecs.allOf(HeroViewComp);
     }
-
-
     update(e: ecs.Entity) {
         //return false
         // 处理伤害队列
-        this.processDamageQueue();
         const view = e.get(HeroViewComp);
-        const skills = e.get(HeroSkillsComp);
-        
-        // 使用固定时间步长更新
-  
             // 只在攻击状态触发技能
-            if (view.is_atking) {
-                this.processSkills(e, skills);
+            if (view.is_atking &&view.at > view.cd) {
+                const config = SkillSet[view.atk_skill];
+                if (!config) return;
+                this.castSkill(e, view.atk_skill, config);
+                view.at = 0;
             }
-            
-            // 更新所有技能冷却
-            skills.skills.forEach(skillId => {
-                this.updateCooldown(skills, skillId);
-            });
+
     }
 
-    private processDamageQueue() {
-        const delta = this.dt;
-        for (let i = this._damageQueue.length - 1; i >= 0; i--) {
-            this._damageQueue[i].timer -= delta;
-            if (this._damageQueue[i].timer <= 0) {
-                this._damageQueue[i].callback();
-                this._damageQueue.splice(i, 1);
-            }
-        }
-    }
-
-    /** 处理所有技能逻辑 */
-    private processSkills(entity: ecs.Entity, comp: HeroSkillsComp) {
-        comp.skills.forEach(skillId => {
-            const config = SkillSet[skillId];
-            if (!config) return;
-           
-            // 检查释放条件
-            if (this.checkSkillCondition(entity, config)) {
-                this.castSkill(entity, skillId, config);
-            }
-        });
-    }
-
-    /** 更新技能冷却 */
-    private updateCooldown(comp: HeroSkillsComp, skillId: number) {
-        let cd = comp.cooldowns.has(skillId) ? comp.cooldowns.get(skillId)! : 0;
-        if (cd > 0) {
-            comp.cooldowns.set(skillId, cd - this.dt);
-        }
-    }
-
-    /** 检查技能释放条件 */
-    private checkSkillCondition(entity: ecs.Entity, config: typeof SkillSet[keyof typeof SkillSet]): boolean {
-        const view = entity.get(HeroViewComp);
-        const comp = entity.get(HeroSkillsComp);
-        switch(config.CdType){
-            case CdType.SkillCD:
-                return (comp.cooldowns.get(config.uuid as number) ?? 0) <= 0;
-            case CdType.HeroCD:
-                return view.at >= view.cd;
-        }   
-    }
-
-
-
     /** 施放技能 */
     private castSkill(caster: ecs.Entity, skillId: number, config: typeof SkillSet[keyof typeof SkillSet]) {
         const view = caster.get(HeroViewComp);
-        const comp = caster.get(HeroSkillsComp);
         const skillEntity = ecs.getEntity<Skill>(Skill);
         console.log(view.hero_name+"施放技能:"+config.uuid+"=>"+view.hero_name);
-        
-        // 处理CD和消耗
-        switch(config.CdType) {
-            case CdType.SkillCD:
-                view.as.max()
-                comp.cooldowns.set(skillId, config.cd); // 重置冷却时间
-                break;
-            case CdType.HeroCD:
-                view.as.atk()
-                view.at = view.at-view.cd;       // 重置普攻计时器
-                break;
-        }
         if (config.TargetGroup === TargetGroup.Enemy) {
             const targets = this.selectEnemyTargets(caster, config);
             if (targets.length === 0) return;
             skillEntity.load(
                 view.node.position,    // 起始位置
-                view.fac,              // 阵营
+                view.box_group,              // 阵营
                 view.node.parent,      // 父节点
                 config.uuid,           // 技能ID
-                targets[0]?.get(HeroViewComp).node.position // 目标位置
+                targets[0]?.get(HeroViewComp).node.position, // 目标位置
+                targets[0]?.get(HeroViewComp),
+                view
             );
             targets.forEach(target => {
                 this.applySkillEffect(caster, target, config,skillEntity);
                 console.log("施放技能:"+config.uuid+"=>"+target.get(HeroViewComp).hero_name);
             });
         }
+
         if (config.TargetGroup === TargetGroup.Ally) {
             const targets = this.selectAllyTargets(caster, config);
             if (targets.length === 0) return;
@@ -190,10 +125,7 @@ export class HeroSkillSystem extends ecs.ComblockSystem implements ecs.ISystemUp
         
         // 直接计算伤害（包含防御减免）
         const damageResult = this.calculateDamage(caster, target, config);
-        
-        // 将施法者传入applyDamage方法
-        this.applyDamage(caster, target, damageResult,skillEntity);
-        
+          
         // 播放技能特效
         casterView.playSkillEffect(config.uuid);
         console.log(`${casterView.hero_name} 对 ${targetView.hero_name} 造成 ${damageResult.value}伤害`);
@@ -231,61 +163,6 @@ export class HeroSkillSystem extends ecs.ComblockSystem implements ecs.ISystemUp
         return result;
     }
 
-    private applyDamage(caster: ecs.Entity, target: ecs.Entity, result: any,skillEntity:ecs.Entity) {
-        const casterView = caster.get(HeroViewComp);
-        const targetView = target.get(HeroViewComp);
-        const skillView = skillEntity.get(SkillCom);
-        if (!casterView || !targetView || !skillView) return;
-       
-        // 计算距离
-        const distance = this.calculateDistance(
-            skillView.node.position,
-            targetView.node.position
-        );
-        
-       
-        // 计算实际延迟时间(秒)
-        const actualDelay = distance / (skillView.speed+targetView.speed);
-        console.log("skillView:"+skillView.node.position+ "  targetView:"+targetView.node.position+ "  actualDelay:"+actualDelay + "  dis:"+distance+ "  skillView.speed:"+skillView.speed+ "  targetView.speed:"+targetView.speed);
-       
-       
-        this._damageQueue.push({
-            timer: actualDelay,
-            callback: () => {
-                if (!targetView?.ent.has(HeroViewComp)) return;
-                
-                let remainingDamage = result.value;
-                if (targetView.shield > 0) {
-                    const shieldAbsorb = Math.min(targetView.shield, remainingDamage);
-                    targetView.shield -= shieldAbsorb;
-                    remainingDamage -= shieldAbsorb;
-                    
-                    if (targetView.shield <= 0) {
-                        targetView.BUFFCOMP.show_shield(false);
-                    }
-                }
-                
-                if (remainingDamage > 0) {
-                    targetView.hp -= remainingDamage;
-                    if(targetView.hp <= 0) {
-                        targetView.BUFFCOMP.dead()
-                        targetView.to_grave();
-                    }
-                    targetView.showDamage(result.value, true);
-                } else {
-                    targetView.BUFFCOMP.tooltip(5,"*吸收*");
-                }
-            }
-        });
-    }
-
-    // 添加计算距离的辅助方法
-    private calculateDistance(pos1: Vec3, pos2: Vec3): number {
-        const dx = pos2.x - pos1.x;
-        const dy = pos2.y - pos1.y;
-        return Math.sqrt(dx * dx + dy * dy);
-    }
-
     public clear_timer() {
         console.log("clear_timer");
         Object.values(this._timers).forEach(clearTimeout);