panw
40c430546c
添加英雄击杀计数功能，用于统计英雄击杀敌人数量 优化HeroAtkSystem中变量命名，将attackerTAttrsComp改为更清晰的CAttrsComp 修复荆棘伤害可能导致英雄死亡时未触发死亡表现的问题
573 lines
19 KiB
TypeScript
573 lines
19 KiB
TypeScript
import { ecs } from "../../../../extensions/oops-plugin-framework/assets/libs/ecs/ECS";
|
||
import { Attrs, AttrsType, BType, NeAttrs } from "../common/config/HeroAttrs";
|
||
import { BuffConf } from "../common/config/SkillSet";
|
||
import { HeroInfo, AttrSet } from "../common/config/heroSet";
|
||
import { HeroSkillsComp } from "./HeroSkills";
|
||
import { HeroViewComp } from "./HeroViewComp";
|
||
|
||
|
||
interface talTrigger{
|
||
value:number
|
||
count:number
|
||
}
|
||
@ecs.register('HeroAttrs')
|
||
export class HeroAttrsComp extends ecs.Comp {
|
||
Ebus:any=null!
|
||
// ==================== 角色基础信息 ====================
|
||
hero_uuid: number = 1001;
|
||
hero_name: string = "hero";
|
||
lv: number = 1;
|
||
type: number = 0; // 0近战 1远程 2辅助
|
||
fac: number = 0; // 0:hero 1:monster
|
||
|
||
// ==================== 基础属性（有初始值） ====================
|
||
base_ap: number = 0; // 基础攻击
|
||
base_map: number = 0; // 基础魔法攻击
|
||
base_def: number = 5; // 基础防御
|
||
base_hp: number = 100; // 基础血量
|
||
base_mp: number = 100; // 基础魔法值
|
||
base_speed: number = 100; // 基础移动速度
|
||
base_dis: number = 100; // 基础距离
|
||
|
||
// ==================== 动态属性值 ====================
|
||
hp: number = 100; // 当前血量
|
||
mp: number = 100; // 当前魔法值
|
||
shield: number = 0; // 当前护盾
|
||
Attrs: any = []; // 最终属性数组（经过Buff计算后）
|
||
NeAttrs: any = []; // 负面状态数组
|
||
//计数型天赋buff
|
||
Talents: Record<number, talTrigger> = {};
|
||
//数值型天赋buff
|
||
BUFFS_TAL: Record<number, {count:number,BType:BType,attrIndex:number,value: number}> = {};
|
||
|
||
// ==================== 技能距离缓存 ====================
|
||
maxSkillDistance: number = 0; // 最远技能攻击距离（缓存，受MP影响）
|
||
minSkillDistance: number = 0; // 最近技能攻击距离（缓存，不受MP影响，用于停止位置判断）
|
||
|
||
// ==================== Buff/Debuff 系统 ====================
|
||
/** 持久型buff数组 - 不会自动过期 */
|
||
BUFFS: Record<number, Array<{value: number, BType: BType}>> = {};
|
||
|
||
/** 临时型buff数组 - 按时间自动过期 */
|
||
BUFFS_TEMP: Record<number, Array<{value: number, BType: BType, remainTime: number}>> = {};
|
||
|
||
|
||
// ==================== 标记状态 ====================
|
||
is_dead: boolean = false;
|
||
is_count_dead: boolean = false;
|
||
is_atking: boolean = false; // 是否正在攻击
|
||
is_stop: boolean = false; // 是否正在停止
|
||
is_boss: boolean = false;
|
||
is_big_boss: boolean = false;
|
||
is_master: boolean = false;
|
||
is_friend: boolean = false;
|
||
is_kalami: boolean = false;
|
||
// ==================== 计数统计 ====================
|
||
atk_count: number = 0; // 攻击次数
|
||
atked_count: number = 0; // 被攻击次数
|
||
killed_count:number=0;
|
||
// 注意：技能数据已迁移到 HeroSkillsComp，不再存储在这里
|
||
|
||
start(){
|
||
}
|
||
// ==================== BUFF 系统初始化 ====================
|
||
/**
|
||
* 初始化角色的 buff debuff
|
||
* 从 HeroInfo 读取初始配置，建立属性系统
|
||
*/
|
||
initAttrs() {
|
||
// 清空现有 buff/debuff
|
||
this.BUFFS = {};
|
||
this.BUFFS_TEMP = {};
|
||
this.BUFFS_TAL = {};
|
||
this.Talents = {};
|
||
|
||
// 获取英雄配置
|
||
const heroInfo = HeroInfo[this.hero_uuid];
|
||
if (!heroInfo) return;
|
||
|
||
// 1. 重置为基础值
|
||
this.Attrs[Attrs.HP_MAX] = this.base_hp;
|
||
this.Attrs[Attrs.MP_MAX] = this.base_mp;
|
||
this.Attrs[Attrs.DEF] = this.base_def;
|
||
this.Attrs[Attrs.AP] = this.base_ap;
|
||
this.Attrs[Attrs.MAP] = this.base_map;
|
||
this.Attrs[Attrs.SPEED] = this.base_speed;
|
||
this.Attrs[Attrs.DIS] = this.base_dis;
|
||
|
||
// 2. 初始化其他属性（无初始值的）
|
||
for (const attrKey in this.Attrs) {
|
||
const attrIndex = parseInt(attrKey);
|
||
if (
|
||
attrIndex !== Attrs.HP_MAX &&
|
||
attrIndex !== Attrs.MP_MAX &&
|
||
attrIndex !== Attrs.DEF &&
|
||
attrIndex !== Attrs.AP &&
|
||
attrIndex !== Attrs.MAP &&
|
||
attrIndex !== Attrs.SPEED &&
|
||
attrIndex !== Attrs.DIS
|
||
) {
|
||
this.Attrs[attrIndex] = 0;
|
||
}
|
||
}
|
||
|
||
// 加载初始 buff
|
||
if (heroInfo.buff && heroInfo.buff.length > 0) {
|
||
for (const buffConf of heroInfo.buff) {
|
||
this.addBuff(buffConf);
|
||
}
|
||
}
|
||
}
|
||
/*******************基础属性管理********************/
|
||
|
||
add_hp(value:number,isValue:boolean){
|
||
let addValue = value;
|
||
if(!isValue){
|
||
addValue = value * this.Attrs[Attrs.HP_MAX];
|
||
}
|
||
let heroView = this.ent.get(HeroViewComp);
|
||
if(heroView){
|
||
heroView.health(addValue);
|
||
}
|
||
this.hp += addValue;
|
||
this.hp = Math.max(0, Math.min(this.hp, this.Attrs[Attrs.HP_MAX]));
|
||
}
|
||
add_mp(value:number,isValue:boolean){
|
||
let addValue = value;
|
||
if(!isValue){
|
||
addValue = value * this.Attrs[Attrs.MP_MAX];
|
||
}
|
||
let heroView = this.ent.get(HeroViewComp);
|
||
if(heroView){
|
||
heroView.mp_add(addValue);
|
||
}
|
||
this.mp += addValue;
|
||
this.mp = Math.max(0, Math.min(this.mp, this.Attrs[Attrs.MP_MAX]));
|
||
}
|
||
add_shield(value:number,isValue:boolean){
|
||
let addValue = value;
|
||
this.shield += addValue;
|
||
this.shield = Math.max(0, Math.min(this.shield, this.Attrs[Attrs.HP_MAX]));
|
||
}
|
||
// ==================== BUFF 管理 ====================
|
||
/**
|
||
* 添加 buff 效果（支持多次叠加）
|
||
* @param buffConf buff 配置 (来自 SkillSet.BuffConf heroSet.buff)
|
||
*/
|
||
addBuff(buffConf: BuffConf) {
|
||
const isPermanent = buffConf.time === 0;
|
||
const attrIndex = buffConf.buff;
|
||
|
||
if (isPermanent) {
|
||
// 添加持久buff到BUFFS - 直接追加到数组
|
||
if (!this.BUFFS[attrIndex]) {
|
||
this.BUFFS[attrIndex] = [];
|
||
}
|
||
this.BUFFS[attrIndex].push({ value: buffConf.value, BType: buffConf.BType });
|
||
} else {
|
||
// 添加临时buff到BUFFS_TEMP - 直接追加到数组
|
||
if (!this.BUFFS_TEMP[attrIndex]) {
|
||
this.BUFFS_TEMP[attrIndex] = [];
|
||
}
|
||
this.BUFFS_TEMP[attrIndex].push({
|
||
value: buffConf.value,
|
||
BType: buffConf.BType,
|
||
remainTime: buffConf.time
|
||
});
|
||
}
|
||
|
||
// 重新计算受影响的属性
|
||
this.recalculateSingleAttr(attrIndex);
|
||
}
|
||
|
||
|
||
|
||
// ==================== 属性计算系统 ====================
|
||
/**
|
||
* 重新计算单个属性
|
||
* @param attrIndex 属性索引
|
||
*/
|
||
recalculateSingleAttr(attrIndex: number) {
|
||
// 1. 获取基础值
|
||
const baseValues: Record<number, number> = {
|
||
[Attrs.HP_MAX]: this.base_hp,
|
||
[Attrs.MP_MAX]: this.base_mp,
|
||
[Attrs.DEF]: this.base_def,
|
||
[Attrs.AP]: this.base_ap,
|
||
[Attrs.MAP]: this.base_map,
|
||
[Attrs.SPEED]: this.base_speed,
|
||
[Attrs.SHIELD_MAX]: 0
|
||
};
|
||
|
||
const baseVal = baseValues[attrIndex] !== undefined ? baseValues[attrIndex] : 0;
|
||
|
||
// 2. 收集所有数值型 buff/debuff
|
||
let totalValue = baseVal;
|
||
|
||
// 遍历持久buff数组
|
||
if (this.BUFFS[attrIndex] && this.BUFFS[attrIndex].length > 0) {
|
||
for (const buff of this.BUFFS[attrIndex]) {
|
||
if (buff.BType === BType.VALUE) {
|
||
totalValue += buff.value;
|
||
}
|
||
}
|
||
}
|
||
// 遍历临时buff数组
|
||
if (this.BUFFS_TEMP[attrIndex] && this.BUFFS_TEMP[attrIndex].length > 0) {
|
||
for (const buff of this.BUFFS_TEMP[attrIndex]) {
|
||
if (buff.BType === BType.VALUE) {
|
||
totalValue += buff.value;
|
||
}
|
||
}
|
||
}
|
||
for (const key in this.BUFFS_TAL) {
|
||
const buff = this.BUFFS_TAL[Number(key)];
|
||
if (buff.attrIndex === attrIndex && buff.BType === BType.VALUE) {
|
||
totalValue += buff.value;
|
||
}
|
||
}
|
||
|
||
// 3. 收集所有百分比型 buff/debuff
|
||
let totalRatio = 0;
|
||
|
||
// 遍历持久buff数组
|
||
if (this.BUFFS[attrIndex] && this.BUFFS[attrIndex].length > 0) {
|
||
for (const buff of this.BUFFS[attrIndex]) {
|
||
if (buff.BType === BType.RATIO) {
|
||
totalRatio += buff.value;
|
||
}
|
||
}
|
||
}
|
||
// 遍历临时buff数组
|
||
if (this.BUFFS_TEMP[attrIndex] && this.BUFFS_TEMP[attrIndex].length > 0) {
|
||
for (const buff of this.BUFFS_TEMP[attrIndex]) {
|
||
if (buff.BType === BType.RATIO) {
|
||
totalRatio += buff.value;
|
||
}
|
||
}
|
||
}
|
||
for (const key in this.BUFFS_TAL) {
|
||
const buff = this.BUFFS_TAL[Number(key)];
|
||
if (buff.attrIndex === attrIndex && buff.BType === BType.RATIO) {
|
||
totalRatio += buff.value;
|
||
}
|
||
}
|
||
|
||
// 4. 根据属性类型计算最终值
|
||
const attrType = AttrsType[attrIndex];
|
||
const isRatioAttr = attrType === BType.RATIO;
|
||
|
||
if (isRatioAttr) {
|
||
// 百分比型属性：直接加减
|
||
this.Attrs[attrIndex] = totalValue + totalRatio;
|
||
} else {
|
||
// 数值型属性：(基础值+数值) × (1 + 百分比/100)
|
||
this.Attrs[attrIndex] = Math.floor(totalValue * (1 + totalRatio / 100));
|
||
}
|
||
|
||
// 5. 确保属性值合理
|
||
this.clampSingleAttr(attrIndex);
|
||
}
|
||
|
||
/**
|
||
* 确保单个属性值合理
|
||
*/
|
||
private clampSingleAttr(attrIndex: number) {
|
||
switch(attrIndex) {
|
||
case Attrs.HP_MAX:
|
||
case Attrs.MP_MAX:
|
||
this.Attrs[attrIndex] = Math.max(1, this.Attrs[attrIndex]);
|
||
break;
|
||
case Attrs.DEF:
|
||
case Attrs.AP:
|
||
case Attrs.MAP:
|
||
this.Attrs[attrIndex] = Math.max(1, this.Attrs[attrIndex]);
|
||
break;
|
||
case Attrs.CRITICAL:
|
||
case Attrs.DODGE:
|
||
case Attrs.HIT:
|
||
this.Attrs[attrIndex] = Math.max(0, Math.min(AttrSet.ATTR_MAX, this.Attrs[attrIndex]));
|
||
break;
|
||
}
|
||
}
|
||
|
||
// ==================== 临时 BUFF/DEBUFF 更新 ====================
|
||
/**
|
||
* 更新临时 buff/debuff 的剩余时间
|
||
* @param dt 时间增量
|
||
*/
|
||
updateTemporaryBuffsDebuffs(dt: number) {
|
||
const affectedAttrs = new Set<number>();
|
||
|
||
// 更新临时型buff
|
||
for (const attrIndex in this.BUFFS_TEMP) {
|
||
const buffs = this.BUFFS_TEMP[attrIndex];
|
||
buffs.forEach(buff => {
|
||
buff.remainTime -= dt;
|
||
if (buff.remainTime <= 0) {
|
||
const index = buffs.indexOf(buff);
|
||
if (index > -1) {
|
||
buffs.splice(index, 1);
|
||
}
|
||
}
|
||
});
|
||
if (buffs.length === 0) {
|
||
delete this.BUFFS_TEMP[attrIndex];
|
||
affectedAttrs.add(parseInt(attrIndex));
|
||
}
|
||
}
|
||
|
||
// 负面状态更新
|
||
for (const key in this.NeAttrs) {
|
||
const debuff = this.NeAttrs[key];
|
||
debuff.remainTime -= dt;
|
||
if (debuff.remainTime <= 0) {
|
||
debuff.remainTime = 0;
|
||
}
|
||
}
|
||
|
||
// 只重新计算受影响的属性
|
||
affectedAttrs.forEach(attrIndex => {
|
||
this.recalculateSingleAttr(attrIndex);
|
||
});
|
||
}
|
||
|
||
// ==================== BUFF 辅助方法 ====================
|
||
/**
|
||
* 清空buff
|
||
* @param attrIndex 属性索引，如果为空则清理所有buff
|
||
* @param isBuff true时清理value>0的增益buff，false时清理value<0的减益buff
|
||
*/
|
||
clearBuffs(attrIndex?: number, isBuff: boolean = true): void {
|
||
if (attrIndex === undefined) {
|
||
for (const attrIndex in this.BUFFS_TEMP) {
|
||
this.clearBuffsForAttr(parseInt(attrIndex), isBuff);
|
||
}
|
||
} else {
|
||
this.clearBuffsForAttr(attrIndex, isBuff);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 清理指定属性的buff
|
||
* @param attrIndex 属性索引
|
||
* @param isBuff true清理增益buff，false清理减益buff
|
||
*/
|
||
private clearBuffsForAttr(attrIndex: number, isBuff: boolean): void {
|
||
const buffContainer = this.BUFFS_TEMP;
|
||
|
||
if (!buffContainer[attrIndex]) return;
|
||
|
||
buffContainer[attrIndex] = buffContainer[attrIndex].filter(buff => {
|
||
const shouldClear = isBuff ? buff.value > 0 : buff.value < 0;
|
||
return !shouldClear;
|
||
});
|
||
|
||
if (buffContainer[attrIndex].length === 0) {
|
||
delete buffContainer[attrIndex];
|
||
}
|
||
|
||
this.recalculateSingleAttr(attrIndex);
|
||
}
|
||
|
||
// ==================== NeAttrs（负面状态）管理 ====================
|
||
/**
|
||
* 清理单个NeAttr（负面状态）
|
||
*/
|
||
clearNeAttr(neAttrIndex: number): void {
|
||
if (this.NeAttrs[neAttrIndex]) {
|
||
this.NeAttrs[neAttrIndex].value = 0;
|
||
this.NeAttrs[neAttrIndex].time = 0;
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 清理所有NeAttrs（负面状态）
|
||
*/
|
||
clearAllNeAttrs(): void {
|
||
for (const key in this.NeAttrs) {
|
||
this.NeAttrs[key].value = 0;
|
||
this.NeAttrs[key].time = 0;
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 检查是否处于眩晕状态
|
||
*/
|
||
public isStun(): boolean {
|
||
return this.NeAttrs[NeAttrs.IN_STUN]?.time > 0;
|
||
}
|
||
|
||
/**
|
||
* 检查是否处于冰冻状态
|
||
*/
|
||
public isFrost(): boolean {
|
||
return this.NeAttrs[NeAttrs.IN_FROST]?.time > 0;
|
||
}
|
||
|
||
// ==================== 技能距离缓存管理 ====================
|
||
/**
|
||
* 更新技能距离缓存
|
||
* 在技能初始化、新增技能、MP变化时调用
|
||
* @param skillsComp 技能组件
|
||
*/
|
||
public updateSkillDistanceCache(skillsComp: HeroSkillsComp): void {
|
||
if (!skillsComp) {
|
||
this.maxSkillDistance = 0;
|
||
this.minSkillDistance = 0;
|
||
return;
|
||
}
|
||
|
||
// 最远距离使用当前MP可施放的技能
|
||
this.maxSkillDistance = skillsComp.getMaxSkillDistance(this.mp);
|
||
// 最近距离使用所有技能中的最小距离，不考虑MP限制，用于停止位置判断
|
||
this.minSkillDistance = skillsComp.getAbsoluteMinSkillDistance();
|
||
}
|
||
|
||
/**
|
||
* 获取缓存的最远技能攻击距离
|
||
* @returns 最远攻击距离
|
||
*/
|
||
public getCachedMaxSkillDistance(): number {
|
||
return this.maxSkillDistance;
|
||
}
|
||
|
||
/**
|
||
* 获取缓存的最近技能攻击距离
|
||
* @returns 最近攻击距离
|
||
*/
|
||
public getCachedMinSkillDistance(): number {
|
||
return this.minSkillDistance;
|
||
}
|
||
|
||
|
||
/**
|
||
* 添加数值型天赋buff 数值会进行累加，count 时叠加层数
|
||
* @param t_uuid 天赋唯一标识
|
||
* @param attrIndex 属性索引
|
||
* @param bType buff类型(VALUE:数值型, RATIO:百分比型)
|
||
* @param value buff值
|
||
*/
|
||
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) {
|
||
this.BUFFS_TAL[t_uuid] = { count: 1, BType: bType, attrIndex, value };
|
||
} else {
|
||
buff.count += 1;
|
||
buff.value += value;
|
||
}
|
||
this.recalculateSingleAttr(attrIndex);
|
||
}
|
||
|
||
/**
|
||
* 添加计数型天赋，每次添加数值已最新额覆盖久的，count为可用次数
|
||
* @param eff 天赋效果ID
|
||
* @param value 天赋值
|
||
*/
|
||
addCountTal(eff: number, value: number) {
|
||
const t = this.Talents[eff] || { value: 0, count: 0 };
|
||
t.value = value;
|
||
t.count += 1;
|
||
this.Talents[eff] = t;
|
||
}
|
||
|
||
/**
|
||
* 使用计数型天赋，如风怒 ，必爆等天赋，只需要返回是否暴击的，使用这个方法
|
||
* @param eff 天赋效果ID
|
||
* @returns 是否使用成功
|
||
*/
|
||
useCountTal(eff: number): boolean {
|
||
const t = this.Talents[eff];
|
||
if (!t || t.count <= 0) return false;
|
||
t.count -= 1;
|
||
return true;
|
||
}
|
||
|
||
/**
|
||
* 使用计数型天赋并返回天赋值，如额外5次 伤害+20% ，5次受伤，免伤20% 使用这个方法
|
||
* @param eff 天赋效果ID
|
||
* @returns 天赋值
|
||
*/
|
||
useCountValTal(eff: number): number {
|
||
const t = this.Talents[eff];
|
||
if (!t || t.value <= 0) return 0;
|
||
t.count -= 1;
|
||
return t.value;
|
||
}
|
||
|
||
/**
|
||
* 根据UUID移除数值型天赋buff
|
||
* @param t_uuid 天赋唯一标识
|
||
*/
|
||
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);
|
||
}
|
||
|
||
/**
|
||
* 根据属性索引移除数值型天赋buff
|
||
* @param attrIndex 属性索引
|
||
*/
|
||
useValueTalByAttr(attrIndex: number) {
|
||
let changed = false;
|
||
for (const key in this.BUFFS_TAL) {
|
||
const b = this.BUFFS_TAL[Number(key)];
|
||
if (b && b.attrIndex === attrIndex) {
|
||
delete this.BUFFS_TAL[Number(key)];
|
||
changed = true;
|
||
}
|
||
}
|
||
if (changed) this.recalculateSingleAttr(attrIndex);
|
||
}
|
||
|
||
reset() {
|
||
// 重置为初始状态
|
||
this.hero_uuid = 1001;
|
||
this.hero_name = "hero";
|
||
this.lv = 1;
|
||
this.type = 0;
|
||
this.fac = 0;
|
||
this.base_ap = 0;
|
||
this.base_map = 0;
|
||
this.base_def = 5;
|
||
this.base_hp = 100;
|
||
this.base_mp = 100;
|
||
this.base_speed = 100;
|
||
this.base_dis = 100;
|
||
this.hp = 100;
|
||
this.mp = 100;
|
||
this.shield = 0;
|
||
this.Attrs = [];
|
||
this.NeAttrs = [];
|
||
this.BUFFS = {};
|
||
this.BUFFS_TEMP = {};
|
||
this.BUFFS_TAL = {};
|
||
this.Talents = {};
|
||
// 重置技能距离缓存
|
||
this.maxSkillDistance = 0;
|
||
this.minSkillDistance = 0;
|
||
this.is_dead = false;
|
||
this.is_count_dead = false;
|
||
this.is_atking = false;
|
||
this.is_stop = false;
|
||
this.is_boss = false;
|
||
this.is_big_boss = false;
|
||
this.is_master = false;
|
||
this.is_friend = false;
|
||
this.is_kalami = false;
|
||
this.atk_count = 0;
|
||
this.atked_count = 0;
|
||
this.killed_count =0;
|
||
}
|
||
|
||
|
||
|
||
}
|
||
|
||
|
||
|