pixelheros/assets/script/game/hero/MonMoveComp.ts

import { ecs } from "../../../../extensions/oops-plugin-framework/assets/libs/ecs/ECS";
import { HeroViewComp } from "./HeroViewComp";
import { HeroAttrsComp } from "./HeroAttrsComp";
import { smc } from "../common/SingletonModuleComp";
import { BoxSet, FacSet } from "../common/config/GameSet";
import { Node } from "cc";

@ecs.register('MonMoveComp')
export class MonMoveComp extends ecs.Comp {
    /** 朝向：1=向右，-1=向左 */
    direction: number = -1;
    /** 当前移动目标 X */
    targetX: number = 0;
    /** 是否允许移动（出生落地前会短暂关闭） */
    moving: boolean = true;
    /** 站位基准 Y */
    baseY: number = 0;
    /** 出生序，用于同条件渲染排序稳定 */
    spawnOrder: number = 0;

    reset() {
        this.direction = -1;
        this.targetX = 0;
        this.moving = true;
        this.baseY = 0;
        this.spawnOrder = 0;
    }
}

@ecs.register('MonMoveSystem')
export class MonMoveSystem extends ecs.ComblockSystem implements ecs.ISystemUpdate {
    /** 怪物接近英雄后的停船距离：小于该阈值即停下交战 */
    private readonly combatHaltDistance = 80;
    /** 渲染层级重排节流，避免每帧排序 */
    private readonly renderSortInterval = 0.05;
    private lastRenderSortAt = 0;
    private monMoveMatcher: ecs.IMatcher | null = null;
    private heroViewMatcher: ecs.IMatcher | null = null;
    private readonly renderEntries: { node: Node; bossPriority: number; frontScore: number; spawnOrder: number; eid: number }[] = [];
    private renderEntryCount = 0;

    private getMonMoveMatcher(): ecs.IMatcher {
        if (!this.monMoveMatcher) {
            this.monMoveMatcher = ecs.allOf(HeroAttrsComp, HeroViewComp, MonMoveComp);
        }
        return this.monMoveMatcher;
    }

    private getHeroViewMatcher(): ecs.IMatcher {
        if (!this.heroViewMatcher) {
            this.heroViewMatcher = ecs.allOf(HeroAttrsComp, HeroViewComp);
        }
        return this.heroViewMatcher;
    }

    filter(): ecs.IMatcher {
        return ecs.allOf(MonMoveComp, HeroViewComp, HeroAttrsComp);
    }

    update(e: ecs.Entity) {
        /** 战斗未开始/暂停时不驱动移动 */
        if (!smc.mission.play || smc.mission.pause) return;

        const model = e.get(HeroAttrsComp);
        const move = e.get(MonMoveComp);
        const view = e.get(HeroViewComp);
        if (!model || !move || !view || !view.node) return;
        if (model.fac !== FacSet.MON) return;
        if (!move.moving) return;

        /** 关卡阶段性冻结怪物行为 */
        if (smc.mission.stop_mon_action) {
            this.clearCombatTarget(model);
            view.status_change("idle");
            return;
        }

        if (model.is_stop || model.is_dead || model.is_reviving || model.isFrost()) {
            this.clearCombatTarget(model);
            if (!model.is_reviving) view.status_change("idle");
            return;
        }

        /** 所有移动都锁定在 baseY，避免出现“漂移” */
        if (view.node.position.y !== move.baseY) {
            view.node.setPosition(view.node.position.x, move.baseY, 0);
        }
        // 渲染层级统交由 MoveSystem 统一处理，避免两个 System 争抢 setSiblingIndex

        // 仅在战斗中才处理索敌；非战斗阶段也允许向左推进，让怪物自然逼近英雄阵地
        const nearestEnemy = smc.mission.in_fight ? this.findNearestEnemy(e) : null;
        if (nearestEnemy) {
            /** 有敌人：边移动边攻击 */
            this.processCombatLogic(e, move, view, model, nearestEnemy);
            this.syncCombatTarget(model, view, nearestEnemy);
        } else {
            /** 无敌人：清目标并继续向左推进 */
            this.clearCombatTarget(model);
            model.is_atking = false;
            this.moveLeft(view, move, model);
        }
    }

    private clearCombatTarget(model: HeroAttrsComp): void {
        model.combat_target_eid = -1;
        model.enemy_in_cast_range = false;
    }

    private syncCombatTarget(model: HeroAttrsComp, selfView: HeroViewComp, enemyView: HeroViewComp): void {
        if (!enemyView || !enemyView.node || !enemyView.ent) {
            this.clearCombatTarget(model);
            return;
        }
        const enemyAttrs = enemyView.ent.get(HeroAttrsComp);
        if (!enemyAttrs || enemyAttrs.is_dead || enemyAttrs.is_reviving || enemyAttrs.fac === model.fac) {
            this.clearCombatTarget(model);
            return;
        }
        model.combat_target_eid = enemyView.ent.eid;
        model.enemy_in_cast_range = this.isEnemyInAttackRange(model, selfView.node.position.x, enemyView.node.position.x);
    }

    private isEnemyInAttackRange(model: HeroAttrsComp, selfX: number, enemyX: number): boolean {
        const dist = Math.abs(selfX - enemyX);
        const attackRange = model.dis;
        return dist <= attackRange;
    }

    private processCombatLogic(e: ecs.Entity, move: MonMoveComp, view: HeroViewComp, model: HeroAttrsComp, enemy: HeroViewComp) {
        const selfX = view.node.position.x;
        const enemyX = enemy.node.position.x;
        // 停船判定使用固定阈值（80），不依赖技能攻击范围
        const inRange = Math.abs(selfX - enemyX) <= this.combatHaltDistance;

        if (inRange) {
            // 接触到英雄方：停止移动，进入攻击状态，由 SCastSystem 负责技能释放
            model.is_atking = true;
            const dir = enemyX > selfX ? 1 : -1;
            view.scale = dir;
            if (view.status === "move") {
                view.status_change("idle");
            }
        } else {
            // 未接触：继续向左推进
            model.is_atking = false;
            this.moveLeft(view, move, model);
        }
    }

    /**
     * 持续向左推进：怪物不再固定站位，而是以 speed/3 的速度向左移动，
     * 直到抵达左边界（基地位置）后转入待机，由 SCastSystem 继续负责技能释放。
     */
    private moveLeft(view: HeroViewComp, move: MonMoveComp, model: HeroAttrsComp) {
        const currentX = view.node.position.x;
        if (currentX <= BoxSet.LETF_END) {
            if (view.status !== "atk") {
                view.status_change("idle");
            }
            return;
        }
        const dir = -1;
        move.direction = dir;
        const speed = model.speed / 3;
        const delta = speed * this.dt * dir;
        const newX = Math.max(BoxSet.LETF_END, currentX + delta);
        if (Math.abs(newX - currentX) >= 0.01) {
            view.node.setPosition(newX, view.node.position.y, 0);
            view.status_change("move");
        }
    }

    private findNearestEnemy(entity: ecs.Entity): HeroViewComp | null {
        const currentView = entity.get(HeroViewComp);
        if (!currentView?.node) return null;
        
        const currentPos = currentView.node.position;
        const myFac = entity.get(HeroAttrsComp).fac;
        
        let nearest: HeroViewComp | null = null;
        let minDis = Infinity;
        
        /** 遍历筛出最近敌人：以 X 轴距离为主，Y 轴距离作为同排的决胜权重，使角色优先攻击同路的敌人 */
        ecs.query(this.getHeroViewMatcher()).forEach(e => {
            const m = e.get(HeroAttrsComp);
            if (m.fac !== myFac && !m.is_dead) {
                const v = e.get(HeroViewComp);
                if (v?.node) {
                    const dx = Math.abs(currentPos.x - v.node.position.x);
                    const dy = Math.abs(currentPos.y - v.node.position.y);
                    const d = dx + dy * 0.1; // Y轴权重较小，仅在 X 相近时起决定作用
                    if (d < minDis) {
                        minDis = d;
                        nearest = v;
                    }
                }
            }
        });
        return nearest;
    }
}