eb4b370533
1. 调整近战默认攻击距离从150改为100 2. 将击退相关属性从概率改为击退距离增量，同步更新所有配置、UI显示和技能描述 3. 移除旧的击退概率判定逻辑，改为直接应用击退距离增量 4. 优化受击击退的处理流程，统一参数传递
567 lines
22 KiB
TypeScript
567 lines
22 KiB
TypeScript
import { ecs } from "../../../../extensions/oops-plugin-framework/assets/libs/ecs/ECS";
|
||
import { FacSet } from "../common/config/GameSet";
|
||
import { Attrs } from "../common/config/HeroAttrs";
|
||
import { FightSet } from "../common/config/GameSet";
|
||
import { SkillSet } from "../common/config/SkillSet";
|
||
import { HeroAttrsComp } from "./HeroAttrsComp";
|
||
import { HeroViewComp } from "./HeroViewComp";
|
||
import { DamageQueueComp, DamageEvent } from "./DamageQueueComp";
|
||
import { smc } from "../common/SingletonModuleComp";
|
||
import { HeroInfo } from "../common/config/heroSet";
|
||
import { oops } from "db://oops-framework/core/Oops";
|
||
import { GameEvent } from "../common/config/GameEvent";
|
||
import { SkillTriggerType } from "../common/config/heroSet";
|
||
import { FieldSkillType } from "../common/config/SkillSet";
|
||
|
||
import { mLogger } from "../common/Logger";
|
||
import { SkillTriggerHelper } from "./SkillTriggerHelper";
|
||
import { getMonsterGoldDrop } from "../map/RogueConfig";
|
||
import { MissionEconomy } from "../map/MissionEconomy";
|
||
|
||
/** 最终伤害数据接口
|
||
* 用于封装一次攻击计算的所有结果数据
|
||
* @property damage - 最终造成的伤害值（已考虑所有加成和减免）
|
||
* @property isCrit - 是否为暴击攻击
|
||
*/
|
||
interface FinalData {
|
||
damage: number;
|
||
isCrit: boolean;
|
||
}
|
||
/**
|
||
* 英雄攻击系统 - 伤害处理核心系统
|
||
*
|
||
* 职责：
|
||
* 1. 处理所有伤害事件的计算和分发
|
||
* 2. 管理伤害队列的处理流程
|
||
* 3. 协调视图层的表现更新
|
||
*
|
||
* 重要概念：
|
||
* - damageEvent.Attrs: 施法者属性快照（创建技能时保存）
|
||
* - TAttrsComp: 被攻击者实时属性
|
||
* - 属性来源规范：攻击判定用施法者，防御判定用被攻击者
|
||
*/
|
||
@ecs.register('HeroAtkSystem')
|
||
export class HeroAtkSystem extends ecs.ComblockSystem implements ecs.ISystemUpdate {
|
||
|
||
private debugMode: boolean = false; // 是否启用调试模式
|
||
|
||
/**
|
||
* 过滤器：处理拥有伤害队列的实体
|
||
*/
|
||
filter(): ecs.IMatcher {
|
||
return ecs.allOf(HeroAttrsComp, DamageQueueComp);
|
||
}
|
||
|
||
/**
|
||
* 系统更新（每帧调用）
|
||
* 处理伤害队列中的所有伤害事件
|
||
*/
|
||
update(e: ecs.Entity): void {
|
||
if (!smc.mission.play) return
|
||
if (smc.mission.pause) return
|
||
const TAttrsComp = e.get(HeroAttrsComp)
|
||
const damageQueue = e.get(DamageQueueComp)
|
||
|
||
if (!TAttrsComp || !damageQueue || damageQueue.isEmpty()) return;
|
||
|
||
// 标记正在处理
|
||
damageQueue.isProcessing = true;
|
||
|
||
// 处理队列中的所有伤害事件
|
||
let processedCount = 0;
|
||
while (!damageQueue.isEmpty()) {
|
||
const damageEvent = damageQueue.getNextDamageEvent();
|
||
if (!damageEvent) break;
|
||
|
||
// 处理单个伤害事件
|
||
this.doAttack(e, damageEvent);
|
||
processedCount++;
|
||
damageQueue.processedCount++;
|
||
// 如果目标已死亡，停止处理后续伤害
|
||
if (TAttrsComp.is_dead) {
|
||
mLogger.log(this.debugMode, 'HeroAtkSystem', ` ${TAttrsComp.hero_name} 已死亡，停止处理剩余伤害`);
|
||
damageQueue.clear(); // 清空剩余伤害
|
||
break;
|
||
}
|
||
}
|
||
|
||
// 如果队列已空，移除伤害队列组件
|
||
if (damageQueue.isEmpty()) {
|
||
e.remove(DamageQueueComp);
|
||
|
||
if (processedCount > 0) {
|
||
mLogger.log(this.debugMode, 'HeroAtkSystem', ` ${TAttrsComp.hero_name} 伤害队列处理完成，共处理 ${processedCount} 个伤害事件`);
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
/** 检查并触发受击附加技能 (atked) */
|
||
private checkAndTriggerAtkedSkills(heroAttrs: HeroAttrsComp, heroView: HeroViewComp) {
|
||
SkillTriggerHelper.trigger(SkillTriggerType.Atked, heroAttrs, heroView);
|
||
}
|
||
|
||
/**
|
||
* 执行攻击计算 - 核心伤害计算逻辑
|
||
*
|
||
* @param target 目标实体（被攻击者）
|
||
* @param damageEvent 伤害事件数据（包含施法者信息和属性快照）
|
||
* @returns 最终伤害数据（包含伤害值、暴击标记、闪避标记）
|
||
*/
|
||
private doAttack(target: ecs.Entity, damageEvent: DamageEvent): FinalData {
|
||
const TAttrsComp = target.get(HeroAttrsComp);
|
||
const targetView = target.get(HeroViewComp);
|
||
let reDate: FinalData = {
|
||
damage: 0,
|
||
isCrit: false,
|
||
}
|
||
if (!TAttrsComp || TAttrsComp.is_dead || TAttrsComp.is_reviving) return reDate;
|
||
|
||
const casterEid = damageEvent.casterEid;
|
||
|
||
// 获取技能配置
|
||
const skillConf = SkillSet[damageEvent.s_uuid];
|
||
if (!skillConf) return reDate;
|
||
|
||
// 触发被攻击事件
|
||
this.onAttacked(target);
|
||
|
||
// 暴击判定
|
||
// 使用施法者的暴击率属性（damageEvent.Attrs 快照），- 被攻击者的暴击抗性属
|
||
const criticalChance = (damageEvent.Attrs[Attrs.critical] || 0) - TAttrsComp.getFinalCriticalRes();
|
||
const isCrit = this.checkChance(criticalChance);
|
||
|
||
// 计算基础伤害
|
||
let damage = this.dmgCount(damageEvent, TAttrsComp);
|
||
|
||
mLogger.log(this.debugMode, 'HeroAtkSystem', " dmgCount", damage)
|
||
if (isCrit) {
|
||
const critDamageBonus = damageEvent.Attrs[Attrs.critical_damage] || 0;
|
||
damage = Math.floor(damage * (1 + (FightSet.CRIT_DAMAGE + critDamageBonus) / 100));
|
||
reDate.isCrit = true;
|
||
if (damageEvent.Attrs.fac === FacSet.HERO) {
|
||
// 【评分系统 - 输出分】统计暴击次数与暴击造成的总伤害
|
||
smc.vmdata.scores.crt_count++;
|
||
smc.vmdata.scores.crit_dmg_total += damage;
|
||
}
|
||
}
|
||
mLogger.log(this.debugMode, 'HeroAtkSystem', " after crit", damage)
|
||
// 护盾吸收
|
||
const shieldResult = this.absorbShield(TAttrsComp, damage);
|
||
damage = shieldResult.remainingDamage;
|
||
if (shieldResult.absorbedDamage > 0) {
|
||
// 【评分系统 - 防御分】统计护盾成功抵挡伤害的次数
|
||
smc.vmdata.scores.shield_block_count += 1;
|
||
}
|
||
mLogger.log(this.debugMode, 'HeroAtkSystem', " after shield", damage)
|
||
// 显示护盾格挡飘字
|
||
if (shieldResult.absorbedDamage > 0 && targetView) {
|
||
targetView.shield_tip(shieldResult.absorbedDamage);
|
||
}
|
||
if (damage <= 0) return reDate;
|
||
|
||
// TAttrsComp.hp -= damage; // 应用伤害到数据层
|
||
TAttrsComp.add_hp(-damage); // 使用 add_hp 以触发 dirty_hp 和 UI 更新
|
||
|
||
if (damageEvent.Attrs.fac === FacSet.HERO) {
|
||
// 【评分系统 - 输出分】统计团队造成的总伤害以及单次最高伤害记录
|
||
smc.vmdata.scores.total_dmg += damage;
|
||
if (damage > smc.vmdata.scores.highest_dmg) {
|
||
smc.vmdata.scores.highest_dmg = damage;
|
||
}
|
||
}
|
||
|
||
// 受击计数：只有实际造成伤害才 +1（被格挡不计数）
|
||
TAttrsComp.atked_count++;
|
||
this.checkAndTriggerAtkedSkills(TAttrsComp, targetView);
|
||
|
||
mLogger.log(this.debugMode, 'HeroAtkSystem', ` 英雄${TAttrsComp.hero_name} (uuid: ${TAttrsComp.hero_uuid}) 受到 eid:${casterEid} 的 伤害 ${damage},${isCrit ? "暴击" : "普通"}攻击,技能ID ${damageEvent.s_uuid}`);
|
||
|
||
// 冰冻判定
|
||
const freezeChance = (damageEvent.Attrs[Attrs.freeze_chance] || 0) - (TAttrsComp.freeze_res || 0);
|
||
const isFrost = !TAttrsComp.isFrost() && this.checkChance(freezeChance);
|
||
|
||
// 击晕判定
|
||
const stunChance = (damageEvent.Attrs[Attrs.stun_chance] || 0) - TAttrsComp.getFinalStunRes();
|
||
const isStun = !TAttrsComp.isStun() && this.checkChance(stunChance);
|
||
|
||
// 击退：受击默认后退，击退属性不再作为概率，而是转换为后退距离的增量
|
||
// 击退增量 = 施法者击退强化（原击退概率）- 被攻击者击退抗性 + 击退距离强化
|
||
const knockbackBonus = (damageEvent.Attrs[Attrs.knockback_chance] || 0) - (TAttrsComp.getFinalKnockbackRes() || 0);
|
||
const knockbackExtra = Math.max(0, knockbackBonus + (damageEvent.Attrs[Attrs.knockback_distance] || 0));
|
||
|
||
// ✅ 触发视图层表现（伤害数字、受击动画、冰冻、击晕、击退）
|
||
if (targetView) {
|
||
targetView.do_atked(damage, isCrit, damageEvent.s_uuid, knockbackExtra);
|
||
targetView.playEnd(skillConf.endAnm);
|
||
if (isFrost) {
|
||
TAttrsComp.toFrost();
|
||
targetView.in_iced(FightSet.FROST_TIME);
|
||
if (damageEvent.Attrs.fac === FacSet.HERO) {
|
||
smc.vmdata.scores.freeze_count++;
|
||
}
|
||
}
|
||
if (isStun) {
|
||
TAttrsComp.toStun();
|
||
targetView.in_stun(FightSet.STUN_TIME);
|
||
if (damageEvent.Attrs.fac === FacSet.HERO) {
|
||
smc.vmdata.scores.stun_count++;
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
// 检查死亡
|
||
if (TAttrsComp.hp <= 0) {
|
||
// 先触发死亡技能（如亡语），不管后续是否续命都应触发
|
||
this.triggerDeadSkills(target);
|
||
|
||
// 濒死回血（revive 系）：不是真正复活，而是血量归零瞬间消耗 1 次续命次数，
|
||
// 按比例回血继续战斗。次数每回合重置（见 MissionComp.healAllHeroes）。
|
||
let canRevive = false;
|
||
let maxReviveCount = 0;
|
||
let reviveHpPercent = 50; // 默认恢复50%
|
||
let reviveSkillConf: any = null; // 提取出来的复活技能配置
|
||
if (TAttrsComp.runtime_revive) {
|
||
const reviveConf = TAttrsComp.runtime_revive;
|
||
maxReviveCount = reviveConf.r_num + Math.floor((TAttrsComp.lv - 1) * reviveConf.upr);
|
||
if (TAttrsComp.revived_count < maxReviveCount) {
|
||
canRevive = true;
|
||
// 从配置表中读取对应的复活技能配置，ap 字段代表恢复生命值的百分比
|
||
reviveSkillConf = SkillSet[reviveConf.s_uuid];
|
||
if (reviveSkillConf && reviveSkillConf.ap) {
|
||
reviveHpPercent = reviveSkillConf.ap;
|
||
}
|
||
}
|
||
}
|
||
|
||
if (canRevive) {
|
||
TAttrsComp.revived_count++;
|
||
TAttrsComp.is_reviving = true; // 标记为正在复活
|
||
// 根据技能配置恢复生命值
|
||
TAttrsComp.hp = Math.floor(TAttrsComp.hp_max * (reviveHpPercent / 100));
|
||
TAttrsComp.dirty_hp = true;
|
||
|
||
// 触发复活动画
|
||
if (targetView && reviveSkillConf) {
|
||
targetView.playReady(reviveSkillConf.readyAnm);
|
||
targetView.skill_name('', reviveSkillConf.uuid, SkillTriggerType.Revive);
|
||
// 延迟 0.5 秒后恢复状态，让特效有时间播放，同时也能体现“正在复活”的过程
|
||
targetView.scheduleOnce(() => {
|
||
if (targetView.node && targetView.node.isValid) {
|
||
targetView.alive();
|
||
}
|
||
}, 0.5);
|
||
} else if (targetView) {
|
||
targetView.alive();
|
||
}
|
||
mLogger.log(this.debugMode, 'HeroAtkSystem', ` Hero waiting to revive! Lives revived: ${TAttrsComp.revived_count}/${maxReviveCount}, Hp restored: ${reviveHpPercent}%`);
|
||
return reDate;
|
||
}
|
||
|
||
this.doDead(target);
|
||
// ✅ 触发死亡视图表现
|
||
if (targetView) {
|
||
targetView.do_dead();
|
||
}
|
||
}
|
||
|
||
mLogger.log(this.debugMode, 'HeroAtkSystem', ` ${TAttrsComp.hero_name} 受到 ${damage} 点伤害 (暴击: ${isCrit})`);
|
||
|
||
|
||
reDate.damage = damage;
|
||
return reDate;
|
||
}
|
||
|
||
/**
|
||
* 详细伤害计算核心方法
|
||
*
|
||
|
||
* 计算流程：
|
||
* 1. 获取技能配置
|
||
* 2. 计算原始物理伤害
|
||
* 3. 应用最终伤害减免
|
||
* 4. 确保伤害值非负
|
||
*
|
||
* @param CAttrs 施法者属性快照对象，包含所有攻击力、属性加成等战斗属性
|
||
* @param TAttrs 目标属性对象，包含所有防御力、抗性等防御属性
|
||
* @param s_uuid 技能ID，用于获取技能配置信息和伤害类型
|
||
* @returns 经过完整计算后的最终伤害值（未考虑暴击）
|
||
*
|
||
* @important 注意事项：
|
||
|
||
*/
|
||
private dmgCount(damageEvent: DamageEvent, TAttrsComp: HeroAttrsComp) {
|
||
// 1. 获取技能配置 - 如果技能不存在，直接返回0伤害
|
||
const CAttrs = damageEvent.Attrs;
|
||
const TAttrs = TAttrsComp;
|
||
let sConf = SkillSet[damageEvent.s_uuid];
|
||
if (!sConf) return 0;
|
||
mLogger.log(this.debugMode, 'HeroAtkSystem', ` 伤害处理对象`, CAttrs, TAttrs);
|
||
// 2. 计算原始物理伤害和魔法伤害
|
||
// 物理伤害基础值 = 技能物理倍率 * (施法者物理攻击力 + 额外伤害) / 100 * 额外伤害比例
|
||
let apBase = (sConf.ap || 0) * (CAttrs[Attrs.ap] + damageEvent.ext_dmg) / 100 * damageEvent.dmg_ratio;
|
||
mLogger.log(this.debugMode, 'HeroAtkSystem', ` 物理伤害基础值: ${apBase}, 技能ap=${sConf.ap},施法者物理攻击力: ${CAttrs[Attrs.ap]},}
|
||
额外伤害:${damageEvent.ext_dmg}, 额外伤害比例:${damageEvent.dmg_ratio}`);
|
||
|
||
// 4. 确保伤害值非负
|
||
let total = Math.max(0, apBase);
|
||
|
||
if (this.debugMode) mLogger.log(this.debugMode, 'HeroAtkSystem', ` 最终伤害: ${total} (Base: ${apBase}`);
|
||
return total;
|
||
}
|
||
|
||
|
||
/**
|
||
* 触发死亡技能（如亡语）
|
||
* 不管是否复活，只要血量归零都触发
|
||
*/
|
||
private triggerDeadSkills(entity: ecs.Entity): void {
|
||
const TAttrsComp = entity.get(HeroAttrsComp);
|
||
if (!TAttrsComp) return;
|
||
|
||
const view = entity.get(HeroViewComp);
|
||
if (view) {
|
||
SkillTriggerHelper.trigger(SkillTriggerType.Dead, TAttrsComp, view);
|
||
// 【新增】仅英雄阵营派发全局死亡事件（怪物死亡会误触发海量卡牌效果）
|
||
if (TAttrsComp.fac === FacSet.HERO) {
|
||
oops.message.dispatchEvent(GameEvent.HeroDead, { eid: entity.eid });
|
||
}
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 处理角色死亡
|
||
*
|
||
* 死亡处理流程：
|
||
* 1. 标记死亡状态（is_dead = true）
|
||
* 2. 英雄阵营：快照死亡状态到 smc.mission.dead_heroes（供后续复活机制重新召唤）
|
||
* 3. 触发死亡事件（onDeath）
|
||
*
|
||
* @param entity 死亡的实体
|
||
*
|
||
* @important 死亡状态一旦设置，该实体将不再处理新的伤害事件
|
||
* 英雄为真实死亡：视图动画结束后由 HeroViewComp.realDead 销毁实体
|
||
*/
|
||
private doDead(entity: ecs.Entity): void {
|
||
const TAttrsComp = entity.get(HeroAttrsComp);
|
||
if (!TAttrsComp || TAttrsComp.is_dead) return;
|
||
|
||
TAttrsComp.is_dead = true;
|
||
|
||
// 英雄真实死亡：记录快照，供后续复活机制（重新召唤）消费
|
||
if (TAttrsComp.fac === FacSet.HERO) {
|
||
this.recordDeadHero(TAttrsComp);
|
||
}
|
||
|
||
// 触发死亡事件
|
||
this.onDeath(entity);
|
||
|
||
if (this.debugMode) {
|
||
mLogger.log(this.debugMode, 'HeroAtkSystem', ` ${TAttrsComp.hero_name} 死亡`);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 快照死亡英雄的静态/成长数据到 smc.mission.dead_heroes。
|
||
* 仅记录重新召唤所需字段，不含战斗内临时状态（buff、技能 CD 等）。
|
||
*
|
||
* @param attrs 死亡英雄的属性组件
|
||
*/
|
||
private recordDeadHero(attrs: HeroAttrsComp): void {
|
||
smc.mission.dead_heroes.push({
|
||
uuid: attrs.hero_uuid,
|
||
lv: attrs.lv,
|
||
card_lv: attrs.card_lv,
|
||
posIndex: attrs.posIndex,
|
||
wave: Math.max(1, smc.vmdata?.mission_data?.level ?? 1),
|
||
});
|
||
mLogger.log(this.debugMode, 'HeroAtkSystem',
|
||
` 死亡英雄已记录: ${attrs.hero_name}(uuid=${attrs.hero_uuid}) lv=${attrs.lv} pos=${attrs.posIndex} wave=${smc.vmdata?.mission_data?.level}, 当前共 ${smc.mission.dead_heroes.length} 个`);
|
||
}
|
||
|
||
|
||
|
||
/**
|
||
* 统一概率判定方法
|
||
*
|
||
* 用于所有概率相关的判定：
|
||
* - 暴击率判定
|
||
* - 闪避率判定
|
||
* - 冰冻/击晕概率判定
|
||
* - 其他特殊效果概率
|
||
*
|
||
* @param rate 概率值（0-100的百分比）
|
||
* @returns true-判定成功，false-判定失败
|
||
*
|
||
* @example
|
||
* ```typescript
|
||
* // 10%概率触发
|
||
* if (this.checkChance(10)) {
|
||
* // 触发特殊效果
|
||
* }
|
||
* ```
|
||
*
|
||
* @important 概率为0或负数时直接返回false，避免不必要的随机数计算
|
||
*/
|
||
private checkChance(rate: number): boolean {
|
||
if (rate <= 0) return false;
|
||
if (rate >= 70) rate = 70
|
||
const r = Math.random() * 100;
|
||
return r < rate;
|
||
}
|
||
|
||
|
||
/**
|
||
* 护盾吸收伤害
|
||
*
|
||
* 护盾吸收逻辑：
|
||
* 1. 护盾值大于 0 时，抵挡本次伤害（免伤）
|
||
* 2. 每次抵挡消耗 1 点护盾值
|
||
* 3. 护盾归零时，重置护盾最大值属性
|
||
*
|
||
* @param TAttrsComp 被攻击者的属性组件（包含当前护盾值）
|
||
* @param damage 原始伤害值
|
||
* @returns {remainingDamage, absorbedDamage} 剩余伤害值和被格挡的伤害值
|
||
*/
|
||
private absorbShield(TAttrsComp: HeroAttrsComp, damage: number): { remainingDamage: number, absorbedDamage: number } {
|
||
if (TAttrsComp.shield <= 0) {
|
||
mLogger.log(this.debugMode, 'HeroAtkSystem', " 护盾值小于等于0，无法吸收伤害");
|
||
return { remainingDamage: damage, absorbedDamage: 0 };
|
||
}
|
||
TAttrsComp.shield = Math.max(0, TAttrsComp.shield - 1);
|
||
if (TAttrsComp.shield <= 0) {
|
||
TAttrsComp.shield = 0;
|
||
}
|
||
TAttrsComp.dirty_shield = true;
|
||
mLogger.log(this.debugMode, 'HeroAtkSystem', ` 护盾抵挡1次伤害，剩余次数 ${TAttrsComp.shield}`);
|
||
return { remainingDamage: 0, absorbedDamage: damage };
|
||
}
|
||
|
||
/**
|
||
* 被攻击时触发的事件
|
||
*
|
||
* 预留的扩展点，用于处理被攻击时的特殊逻辑：
|
||
* - 触发反伤效果（荆棘光环等）
|
||
* - 触发被攻击天赋（如受击回血、受击反击等）
|
||
* - 触发特殊状态（如受伤狂暴、受伤护盾等）
|
||
*
|
||
* @param entity 被攻击的实体
|
||
*
|
||
* @todo 当前对怪物实体直接返回，后续可以根据需求扩展怪物的被攻击逻辑
|
||
*/
|
||
private onAttacked(entity: ecs.Entity): void {
|
||
const TAttrsComp = entity.get(HeroAttrsComp);
|
||
if (!TAttrsComp || TAttrsComp.is_dead) return;
|
||
TAttrsComp.atked_count++;
|
||
// 这里可以添加被攻击时的特殊处理逻辑
|
||
if (TAttrsComp.fac === FacSet.MON) return;
|
||
|
||
// 例如：触发某些天赋效果、反击逻辑等
|
||
}
|
||
|
||
/**
|
||
* 死亡时触发的事件
|
||
*
|
||
* 根据实体阵营类型处理不同的死亡逻辑：
|
||
*
|
||
* - FacSet.MON（怪物）：触发掉落逻辑
|
||
* - 延迟执行掉落，避免阻塞主逻辑
|
||
* - 可以扩展：经验值计算、任务进度等
|
||
*
|
||
* - FacSet.HERO（英雄）：触发英雄死亡特殊处理
|
||
* - 游戏结束判定
|
||
* - 复活机制检查
|
||
* - 死亡惩罚/奖励
|
||
*
|
||
* @param entity 死亡的实体
|
||
*
|
||
* @important 死亡事件应该幂等，避免重复触发
|
||
*/
|
||
private onDeath(entity: ecs.Entity): void {
|
||
const TAttrsComp = entity.get(HeroAttrsComp);
|
||
if (!TAttrsComp) return;
|
||
|
||
if (TAttrsComp.fac === FacSet.MON) {
|
||
// 怪物死亡处理
|
||
this.scheduleDrop(entity);
|
||
// oops.message 全局事件总线：怪物死亡（连杀计数等表现层消费）
|
||
oops.message.dispatchEvent(GameEvent.MonDead, {
|
||
isBoss: !!TAttrsComp.is_boss,
|
||
worldPos: entity.get(HeroViewComp)?.node?.worldPosition?.clone() ?? null,
|
||
});
|
||
} else if (TAttrsComp.fac === FacSet.HERO) {
|
||
// 英雄死亡处理
|
||
this.scheduleHeroDeath(entity);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 怪物死亡掉落金币
|
||
*
|
||
* 实现说明：
|
||
* - 通过 hero_uuid 查 HeroInfo 获取 monType
|
||
* - 按怪物类型查 MonsterGoldSet 获取固定金币掉落数（Boss 有独立的高额奖励）
|
||
* - 调用 MissionEconomy.addCoin 统一发放金币（会自动触发 UI 更新和评分统计）
|
||
*
|
||
* @param entity 死亡的怪物实体
|
||
*/
|
||
private scheduleDrop(entity: ecs.Entity): void {
|
||
const TAttrsComp = entity.get(HeroAttrsComp);
|
||
if (!TAttrsComp) return;
|
||
|
||
// 通过 hero_uuid 查配置获取怪物类型
|
||
const info = HeroInfo[TAttrsComp.hero_uuid];
|
||
const monType = info?.monType ?? 0;
|
||
const gold = getMonsterGoldDrop(monType, !!TAttrsComp.is_boss);
|
||
if (gold <= 0) return;
|
||
|
||
MissionEconomy.addCoin(gold);
|
||
// oops.message 全局事件总线：金币飞行表现（账务已即时结算，飞行纯视觉）
|
||
oops.message.dispatchEvent(GameEvent.CoinFly, {
|
||
worldPos: entity.get(HeroViewComp)?.node?.worldPosition?.clone() ?? null,
|
||
gold,
|
||
isBoss: !!TAttrsComp.is_boss,
|
||
});
|
||
mLogger.log(this.debugMode, 'HeroAtkSystem',
|
||
` ${TAttrsComp.hero_name} 死亡掉落金币 ${gold}（monType=${monType}, isBoss=${TAttrsComp.is_boss}）`);
|
||
}
|
||
|
||
/**
|
||
* 延迟执行英雄死亡逻辑
|
||
*
|
||
* 英雄死亡的特殊处理，比普通怪物复杂：
|
||
*
|
||
* 处理内容包括：
|
||
* - 检查复活次数和复活条件
|
||
* - 触发游戏结束界面（如适用）
|
||
* - 记录死亡统计信息
|
||
* - 处理死亡惩罚（经验损失、装备损坏等）
|
||
*
|
||
* @param entity 死亡的英雄实体
|
||
*
|
||
* @important 英雄死亡通常需要玩家交互，所以必须延迟处理
|
||
* 给玩家足够的反馈时间和操作空间
|
||
*/
|
||
private scheduleHeroDeath(entity: ecs.Entity): void {
|
||
// 这里可以添加英雄死亡的特殊处理
|
||
// 例如：触发游戏结束、复活机制等
|
||
}
|
||
|
||
/**
|
||
* 启用调试模式
|
||
*/
|
||
enableDebug() {
|
||
this.debugMode = true;
|
||
}
|
||
|
||
/**
|
||
* 禁用调试模式
|
||
*/
|
||
disableDebug() {
|
||
this.debugMode = false;
|
||
}
|
||
|
||
|
||
}
|