308 lines
12 KiB
TypeScript
308 lines
12 KiB
TypeScript
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";
|
||
import { GameEvent } from "../common/config/GameEvent";
|
||
import { Skill } from "../skills/Skill";
|
||
import { SkillCom } from "../skills/SkillCom";
|
||
import { AnimType } from "../common/config/SkillSet";
|
||
|
||
|
||
/** 技能系统 */
|
||
@ecs.register('HeroSkillSystem')
|
||
export class HeroSkillSystem extends ecs.ComblockSystem implements ecs.ISystemUpdate {
|
||
// export class HeroSkillSystem implements ecs.ISystemUpdate {
|
||
// private updateInterval: number = 0.1; // 每0.1秒更新一次
|
||
// private accumulator: number = 0;
|
||
private _timers: { [key: string]: number } = {};
|
||
private _damageQueue: Array<{ timer: number; callback: () => void }> = [];
|
||
init(): void {
|
||
oops.message.on(GameEvent.MissionEnd, this.clear_timer, this);
|
||
}
|
||
filter(): ecs.IMatcher {
|
||
return ecs.allOf(HeroSkillsComp, 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);
|
||
}
|
||
|
||
// 更新所有技能冷却
|
||
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.node.parent, // 父节点
|
||
config.uuid, // 技能ID
|
||
targets[0]?.get(HeroViewComp).node.position // 目标位置
|
||
);
|
||
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;
|
||
targets.forEach(target => {
|
||
this.applySkillEffect(caster, target, config,skillEntity);
|
||
});
|
||
}
|
||
if (config.TargetGroup === TargetGroup.Self) {
|
||
this.applySkillEffect(caster, caster, config,skillEntity);
|
||
}
|
||
|
||
}
|
||
|
||
private selectEnemyTargets(caster: ecs.Entity, config: typeof SkillSet[keyof typeof SkillSet]): ecs.Entity[] {
|
||
const casterView = caster.get(HeroViewComp);
|
||
const team = casterView.fac;
|
||
const isEnemyTeam = team === 0 ? 1 : 0;
|
||
const candidates= ecs.query(ecs.allOf(HeroViewComp)).filter(e => e.get(HeroViewComp).fac !== team);
|
||
return this.filterFrontRow(candidates, isEnemyTeam);
|
||
}
|
||
private selectAllyTargets(caster: ecs.Entity, config: typeof SkillSet[keyof typeof SkillSet]): ecs.Entity[] {
|
||
const casterView = caster.get(HeroViewComp);
|
||
const team = casterView.fac;
|
||
const candidates= ecs.query(ecs.allOf(HeroViewComp)).filter(e => e.get(HeroViewComp).fac === team);
|
||
// 第二阶段：位置/血量等精细筛选
|
||
switch(config.TargetType) {
|
||
case TargetType.Melee:
|
||
return candidates.filter(e => e.get(HeroViewComp).type === 0);
|
||
case TargetType.Ranged:
|
||
return candidates.filter(e => e.get(HeroViewComp).type === 1);
|
||
case TargetType.SupportClass:
|
||
return candidates.filter(e => e.get(HeroViewComp).type === 2);
|
||
case TargetType.Random:
|
||
return this.pickRandomTarget(candidates, config.count || 1);
|
||
default:
|
||
return candidates;
|
||
}
|
||
}
|
||
|
||
/** 筛选最前排单位 */
|
||
private filterFrontRow(entities: ecs.Entity[], isEnemyTeam: number): ecs.Entity[] {
|
||
// 敌方最前排是x坐标最大的，我方最前排是x坐标最小的
|
||
const keyPos = isEnemyTeam ?
|
||
Math.min(...entities.map(e => e.get(HeroViewComp).node.position.x)) :
|
||
Math.max(...entities.map(e => e.get(HeroViewComp).node.position.x));
|
||
|
||
return entities.filter(e =>
|
||
Math.abs(e.get(HeroViewComp).node.position.x - keyPos) < 10
|
||
);
|
||
}
|
||
|
||
/** 随机选择目标 */
|
||
private pickRandomTarget(entities: ecs.Entity[], count: number): ecs.Entity[] {
|
||
const shuffled = [...entities].sort(() => 0.5 - Math.random());
|
||
return shuffled.slice(0, count);
|
||
}
|
||
|
||
/** 应用技能效果 */
|
||
private applySkillEffect(caster: ecs.Entity, target: ecs.Entity, config: typeof SkillSet[keyof typeof SkillSet],skillEntity:ecs.Entity) {
|
||
const casterView = caster.get(HeroViewComp);
|
||
const targetView = target.get(HeroViewComp);
|
||
|
||
// 直接计算伤害（包含防御减免）
|
||
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}伤害`);
|
||
}
|
||
|
||
private calculateDamage(caster: ecs.Entity, target: ecs.Entity, config: typeof SkillSet[keyof typeof SkillSet]) {
|
||
const result = {
|
||
value: 0,
|
||
isCrit: false,
|
||
isDodged: false,
|
||
delay: 0.3, // 默认延迟
|
||
ignoreDefense: false,
|
||
canCrit: true,
|
||
}
|
||
|
||
// 计算延迟时间
|
||
if (config.AnimType === AnimType.parabolic) {
|
||
const sourcePos = caster.get(HeroViewComp).node.position;
|
||
const targetPos = target.get(HeroViewComp).node.position;
|
||
// 计算距离除以速度得到时间
|
||
const distance = Math.abs(targetPos.x - sourcePos.x);
|
||
result.delay = distance / config.speed;
|
||
}
|
||
|
||
const sourceView = caster.get(HeroViewComp);
|
||
let final = sourceView.ap * config.ap / 100;
|
||
|
||
// 伤害浮动（±10%）
|
||
const damageFloat = 0.9 + Math.random() * 0.2; // 0.9~1.1
|
||
final *= damageFloat;
|
||
final = Math.round(final);
|
||
|
||
result.value = Math.max(1, final); // 确保最小伤害为1
|
||
result.isCrit = false;
|
||
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);
|
||
}
|
||
onDestroy() {
|
||
Object.values(this._timers).forEach(clearTimeout);
|
||
}
|
||
|
||
|
||
/** 应用负面状态 */
|
||
private applyDebuff(target: ecs.Entity, config: typeof SkillSet[keyof typeof SkillSet]) {
|
||
// 实现debuff逻辑...
|
||
}
|
||
|
||
}
|
||
|
||
|
||
|