@cc-component/cc-fly 0.0.0-stage → 1.0.0

package/assets/fly/base/FlyPlayerBuffSystem.ts

@@ -0,0 +1,673 @@
+import { _decorator, Component } from 'cc';
+
+const { ccclass } = _decorator;
+
+export enum PlayerBuffType {
+    /** value 为伤害倍率，例如 2 表示双倍伤害；chance 为触发概率。 */
+    CriticalDamage,
+    /** value 为固定增加的攻击伤害。 */
+    FlatDamage,
+    /** value 为吸血比例，范围 0 到 1。 */
+    Lifesteal,
+    /** value 为伤害加成比例，范围 0 到 1。 */
+    PercentDamage,
+    /** value 为固定增加的最大生命值。 */
+    MaxHealth,
+    /** value 为攻速加成比例，例如 0.5 表示提高 50%。 */
+    AttackSpeed,
+    /** value 为额外暴击倍率，例如 0.5 会让 2 倍暴击提高到 2.5 倍。 */
+    CriticalDamageBonus,
+    /** value 为物理防御数值。 */
+    PhysicalDefense,
+    /** value 为魔法防御数值。 */
+    MagicDefense,
+    /** value 为目标最大生命值伤害比例，例如 0.1 表示额外造成 10%。 */
+    MaxHealthDamage,
+    /** value 为固定物理防御穿透点数。 */
+    PhysicalPenetration,
+    /** value 为固定魔法防御穿透点数。 */
+    MagicPenetration,
+    /** 兼容用通用百分比穿透，物理和魔法攻击都会生效。 */
+    PercentPenetration,
+    /** value 为物理百分比穿透比例，例如 0.2 表示穿透 20% 物防。 */
+    PhysicalPercentPenetration,
+    /** value 为魔法百分比穿透比例，例如 0.2 表示穿透 20% 魔防。 */
+    MagicPercentPenetration,
+    /** value 为伤害减免比例，例如 0.2 表示减少 20% 伤害。 */
+    DamageReduction,
+    /** value 为物理伤害减免比例。 */
+    PhysicalDamageReduction,
+    /** value 为魔法伤害减免比例。 */
+    MagicDamageReduction,
+    /** value 为闪避概率，例如 0.2 表示有 20% 概率完全闪避。 */
+    Dodge,
+    /** value 为物理攻击闪避概率。 */
+    PhysicalDodge,
+    /** value 为魔法攻击闪避概率。 */
+    MagicDodge,
+    /** value 为格挡减伤比例；chance 为格挡触发概率。 */
+    Block,
+    /** value 为生命恢复量；有 duration 时按每秒恢复，否则立即恢复。 */
+    CurrentHealth,
+    /** value 为每秒伤害，duration 为持续秒数，chance 为施加概率。 */
+    DamageOverTime,
+    /** 目标身上的限时 DoT 层。 */
+    DamageOverTimeEffect,
+    /** value 为移动速度加成比例，例如 0.2 表示提高 20%。 */
+    MovementSpeed,
+    /** value 为移动速度降低比例，范围 0 到 1。 */
+    Slow,
+    /** value 为单次攻击命中的目标总数，包含主目标。 */
+    AttackTargetCount,
+    /** value 为以主目标为圆心的范围攻击半径，单位为 Cocos 世界坐标。 */
+    AreaAttackRadius,
+    /** value 为攻击距离，单位为 Cocos 世界坐标。 */
+    AttackDistance,
+}
+
+export enum PlayerDamageType {
+    Physical,
+    Magic,
+}
+
+/** Player Buff 配置；只需填写对应 Buff 使用的属性。 */
+export interface PlayerBuffOptions {
+    type: PlayerBuffType | any;
+    value: number;
+    chance?: number;
+    duration?: number;
+    damageType?: PlayerDamageType;
+    /** CurrentHealth 每次实际恢复生命后调用，参数为实际恢复量。 */
+    onApplied?: (healedAmount: number) => void;
+}
+
+/** 供 UI 展示的单层 Buff 信息。 */
+export interface PlayerBuffDescription {
+    type: PlayerBuffType;
+    description: string;
+    value: number;
+    chance?: number;
+    duration?: number;
+    damageType?: PlayerDamageType;
+}
+
+/** 一次攻击结算后交给命中逻辑处理的结果。 */
+export interface PlayerBuffAttackResult {
+    damage: number;
+    isCritical: boolean;
+    lifestealAmount: number;
+}
+
+/** 一次攻击的多目标与范围配置；未配置的字段为 undefined。 */
+export interface PlayerAttackTargetConfig {
+    targetCount?: number;
+    areaAttackRadius?: number;
+}
+
+interface PlayerBuffData {
+    value: number;
+    chance: number;
+    duration?: number;
+    expireCallback?: () => void;
+    onExpire?: () => void;
+    onTick?: () => void;
+}
+
+interface PlayerDamageOverTimeBuff {
+    damagePerSecond: number;
+    chance: number;
+    duration: number;
+    damageType: PlayerDamageType;
+}
+
+@ccclass('FlyPlayerBuffSystem')
+export class FlyPlayerBuffSystem extends Component {
+    private buffs = new Map<PlayerBuffType, PlayerBuffData[]>();
+    private isAttackCoolingDown = false;
+    /** 该角色攻击时触发的 DoT 配置，不代表其正在承受 DoT。 */
+    private damageOverTimeBuffs: PlayerDamageOverTimeBuff[] = [];
+
+    /** 添加一层攻击触发型 DoT 配置；同类配置可以并存。 */
+    public addDamageOverTimeBuff(
+        damagePerSecond: number,
+        chance: number,
+        duration: number | undefined,
+        damageType: PlayerDamageType,
+    ): void {
+        const buff = this.normalizeDamageOverTimeBuff(damagePerSecond, chance, duration, damageType);
+        if (buff) this.damageOverTimeBuffs.push(buff);
+    }
+
+    /** 替换所有攻击触发型 DoT 配置，只保留新配置。 */
+    public resetDamageOverTimeBuff(
+        damagePerSecond: number,
+        chance: number,
+        duration: number | undefined,
+        damageType: PlayerDamageType,
+    ): void {
+        const buff = this.normalizeDamageOverTimeBuff(damagePerSecond, chance, duration, damageType);
+        if (!buff) return;
+        this.damageOverTimeBuffs = [buff];
+    }
+
+    /** 校验并规范化 DoT 配置；参数无效时返回 null。 */
+    private normalizeDamageOverTimeBuff(
+        damagePerSecond: number,
+        chance: number,
+        duration: number | undefined,
+        damageType: PlayerDamageType,
+    ): PlayerDamageOverTimeBuff | null {
+        if (!Number.isFinite(damagePerSecond) || !Number.isFinite(chance)
+            || duration === undefined || !Number.isFinite(duration) || duration < 0) {
+            return null;
+        }
+
+        return {
+            damagePerSecond: Math.max(0, damagePerSecond),
+            chance: Math.max(0, Math.min(chance, 1)),
+            duration,
+            damageType,
+        };
+    }
+
+    /** 命中时逐层检定触发概率，并将成功的 DoT 效果重设到目标身上。 */
+    public applyDamageOverTimeOnHit(
+        target: FlyPlayerBuffSystem,
+        createTick: (damagePerSecond: number, damageType: PlayerDamageType) => () => void,
+    ): void {
+        for (const buff of this.damageOverTimeBuffs) {
+            if (Math.random() < buff.chance) {
+                target.resetBuff(
+                    PlayerBuffType.DamageOverTimeEffect,
+                    buff.damagePerSecond,
+                    1,
+                    buff.duration,
+                    undefined,
+                    createTick(buff.damagePerSecond, buff.damageType),
+                );
+            }
+        }
+    }
+
+    /** 按概率立即恢复生命，或在指定持续时间内按秒恢复。 */
+    public applyCurrentHealthBuff(
+        value: number,
+        chance: number,
+        onApply: (amount: number) => void,
+        duration?: number,
+        reset = false,
+    ): void {
+        if (!Number.isFinite(value) || !Number.isFinite(chance)
+            || (duration !== undefined && (!Number.isFinite(duration) || duration < 0))) return;
+        if (Math.random() >= Math.max(0, Math.min(chance, 1))) return;
+
+        const amount = Math.max(0, value);
+        if (duration === undefined || duration === 0) {
+            onApply(amount);
+            return;
+        }
+
+        if (reset) {
+            this.resetBuff(
+                PlayerBuffType.CurrentHealth,
+                amount,
+                1,
+                duration,
+                undefined,
+                () => onApply(amount),
+            );
+        } else {
+            this.addBuff(
+                PlayerBuffType.CurrentHealth,
+                amount,
+                1,
+                duration,
+                undefined,
+                () => onApply(amount),
+            );
+        }
+    }
+
+    /** 获取所有持续生效的 Buff；同类型的不同层分别返回。 */
+    public getBuffDescriptions(): PlayerBuffDescription[] {
+        const descriptions: PlayerBuffDescription[] = [];
+
+        for (const [type, layers] of this.buffs) {
+            if (type === PlayerBuffType.DamageOverTimeEffect) continue;
+
+            for (const layer of layers) {
+                if (type === PlayerBuffType.CurrentHealth && !layer.onTick) continue;
+                descriptions.push({
+                    type,
+                    description: type === PlayerBuffType.CurrentHealth
+                        ? `持续恢复生命（${layer.value}点/秒）`
+                        : this.describeBuff(type, layer.value, layer.chance),
+                    value: layer.value,
+                    ...(
+                        type === PlayerBuffType.CriticalDamage || type === PlayerBuffType.Block
+                            ? { chance: layer.chance }
+                            : {}
+                    ),
+                    ...(layer.duration !== undefined ? { duration: layer.duration } : {}),
+                });
+            }
+        }
+
+        for (const buff of this.damageOverTimeBuffs) {
+            descriptions.push({
+                type: PlayerBuffType.DamageOverTime,
+                description: `命中施加中毒（${buff.damagePerSecond}点/秒），触发率${Math.round(buff.chance * 100)}%`,
+                value: buff.damagePerSecond,
+                chance: buff.chance,
+                duration: buff.duration,
+                damageType: buff.damageType,
+            });
+        }
+
+        return descriptions;
+    }
+
+    private describeBuff(type: PlayerBuffType, value: number, chance: number): string {
+        const percent = (amount: number): string => `${amount * 100}%`;
+        switch (type) {
+            case PlayerBuffType.CriticalDamage: return `暴击伤害倍率（${value}倍），触发率${Math.round(chance * 100)}%`;
+            case PlayerBuffType.FlatDamage: return `固定攻击伤害（+${value}）`;
+            case PlayerBuffType.Lifesteal: return `吸血（${percent(value)}）`;
+            case PlayerBuffType.PercentDamage: return `伤害加成（${percent(value)}）`;
+            case PlayerBuffType.MaxHealth: return `最大生命值（+${value}）`;
+            case PlayerBuffType.AttackSpeed: return `攻速加成（${percent(value)}）`;
+            case PlayerBuffType.CriticalDamageBonus: return `额外暴击倍率（+${value}）`;
+            case PlayerBuffType.PhysicalDefense: return `物理防御（${value}）`;
+            case PlayerBuffType.MagicDefense: return `魔法防御（${value}）`;
+            case PlayerBuffType.MaxHealthDamage: return `最大生命伤害（${percent(value)}）`;
+            case PlayerBuffType.PhysicalPenetration: return `物理固定穿透（${value}）`;
+            case PlayerBuffType.MagicPenetration: return `魔法固定穿透（${value}）`;
+            case PlayerBuffType.PercentPenetration: return `通用百分比穿透（${percent(value)}）`;
+            case PlayerBuffType.PhysicalPercentPenetration: return `物理百分比穿透（${percent(value)}）`;
+            case PlayerBuffType.MagicPercentPenetration: return `魔法百分比穿透（${percent(value)}）`;
+            case PlayerBuffType.DamageReduction: return `伤害减免（${percent(value)}）`;
+            case PlayerBuffType.PhysicalDamageReduction: return `物理伤害减免（${percent(value)}）`;
+            case PlayerBuffType.MagicDamageReduction: return `魔法伤害减免（${percent(value)}）`;
+            case PlayerBuffType.Dodge: return `闪避率（${percent(value)}）`;
+            case PlayerBuffType.PhysicalDodge: return `物理闪避率（${percent(value)}）`;
+            case PlayerBuffType.MagicDodge: return `魔法闪避率（${percent(value)}）`;
+            case PlayerBuffType.Block: return `格挡减伤（${percent(value)}），触发率${Math.round(chance * 100)}%`;
+            case PlayerBuffType.DamageOverTimeEffect: return `中毒伤害（${value}点/秒）`;
+            case PlayerBuffType.DamageOverTime: return `命中施加中毒（${value}点/秒）`;
+            case PlayerBuffType.MovementSpeed: return `移动速度加成（${percent(value)}）`;
+            case PlayerBuffType.Slow: return `移动速度降低（${percent(value)}）`;
+            case PlayerBuffType.AttackTargetCount: return `攻击目标数量（${value}个，包含主目标）`;
+            case PlayerBuffType.AreaAttackRadius: return `范围攻击半径（${value}）`;
+            case PlayerBuffType.CurrentHealth: return `即时生命恢复（${value}）`;
+            case PlayerBuffType.AttackDistance: return `攻击距离（${value}）`;
+
+
+
+
+            default: return `Buff（${value}）`;
+        }
+    }
+
+    /** 移动速度加成与减速相抵后得到的移动倍率，最低为 0。 */
+    public getMovementSpeedMultiplier(): number {
+        return Math.max(
+            0,
+            1 + this.getBuffValue(PlayerBuffType.MovementSpeed) - this.getBuffValue(PlayerBuffType.Slow),
+        );
+    }
+
+    /** 添加 Buff；同类型数值累加，duration 以秒为单位且到期只移除本层。
+     * type: Buff 类型 any是自定义类型
+     * value: Buff 数值
+     * chance: Buff 触发概率
+     * duration: Buff 持续时间（秒）
+     * onExpire: Buff 到期回调
+     * onTick: Buff 每秒触发回调
+     */
+    public addBuff(
+        type: PlayerBuffType | any,
+        value: number,
+        chance = 1,
+        duration?: number,
+        onExpire?: () => void,
+        onTick?: () => void,
+    ): void {
+        const data = this.normalizeBuffData(type, value, chance);
+        if (!data) return;
+
+        if (duration !== undefined && (!Number.isFinite(duration) || duration < 0)) return;
+        const layers = this.buffs.get(type) ?? [];
+        layers.push(data);
+        this.buffs.set(type, layers);
+
+        if (duration !== undefined) {
+            data.duration = duration;
+            data.onExpire = onExpire;
+            data.onTick = onTick;
+            this.scheduleBuffLayer(type, data, duration);
+        }
+    }
+
+    /** 替换指定类型的所有 Buff 层，并可设置新层的持续时间。 */
+    public resetBuff(
+        type: PlayerBuffType,
+        value: number,
+        chance = 1,
+        duration?: number,
+        onExpire?: () => void,
+        onTick?: () => void,
+    ): void {
+        const data = this.normalizeBuffData(type, value, chance);
+        if (!data) return;
+        if (duration !== undefined && (!Number.isFinite(duration) || duration < 0)) return;
+
+        this.removeBuff(type);
+        const layers = [data];
+        this.buffs.set(type, layers);
+        if (duration !== undefined) {
+            data.duration = duration;
+            data.onExpire = onExpire;
+            data.onTick = onTick;
+            this.scheduleBuffLayer(type, data, duration);
+        }
+    }
+
+    private scheduleBuffLayer(type: PlayerBuffType, layer: PlayerBuffData, duration: number): void {
+        let remainingDuration = duration;
+        if (layer.onTick) {
+            layer.onTick();
+            if (!this.buffs.get(type)?.includes(layer)) return;
+        }
+
+        if (remainingDuration <= 0) {
+            this.removeBuffLayer(type, layer);
+            layer.onExpire?.();
+            return;
+        }
+
+        const scheduleNext = (): void => {
+            const delay = layer.onTick ? Math.min(1, remainingDuration) : remainingDuration;
+            layer.expireCallback = () => {
+                if (!this.buffs.get(type)?.includes(layer)) return;
+
+                remainingDuration -= delay;
+
+                if (remainingDuration <= 0) {
+                    this.removeBuffLayer(type, layer);
+                    layer.onExpire?.();
+                    return;
+                }
+                layer.onTick?.();
+                if (!this.buffs.get(type)?.includes(layer)) return;
+                scheduleNext();
+            };
+            this.scheduleOnce(layer.expireCallback, delay);
+        };
+
+        scheduleNext();
+    }
+
+    private normalizeBuffData(type: PlayerBuffType, value: number, chance: number): PlayerBuffData | null {
+        if (!Number.isFinite(value) || !Number.isFinite(chance)) return null;
+
+        let normalizedValue: number;
+        switch (type) {
+            case PlayerBuffType.CriticalDamage:
+                normalizedValue = Math.max(1, value);
+                break;
+            case PlayerBuffType.FlatDamage:
+            case PlayerBuffType.MaxHealth:
+            case PlayerBuffType.CriticalDamageBonus:
+            case PlayerBuffType.PhysicalPenetration:
+            case PlayerBuffType.MagicPenetration:
+            case PlayerBuffType.CurrentHealth:
+            case PlayerBuffType.DamageOverTime:
+            case PlayerBuffType.DamageOverTimeEffect:
+                normalizedValue = Math.max(0, value);
+                break;
+            case PlayerBuffType.MovementSpeed:
+                normalizedValue = Math.max(0, value);
+                break;
+            case PlayerBuffType.PhysicalDefense:
+            case PlayerBuffType.MagicDefense:
+                normalizedValue = value;
+                break;
+            case PlayerBuffType.AttackSpeed:
+            case PlayerBuffType.AreaAttackRadius:
+                normalizedValue = Math.max(0, value);
+                break;
+            case PlayerBuffType.AttackTargetCount:
+                normalizedValue = Math.max(1, Math.floor(value));
+                break;
+            case PlayerBuffType.PercentPenetration:
+            case PlayerBuffType.PhysicalPercentPenetration:
+            case PlayerBuffType.MagicPercentPenetration:
+            case PlayerBuffType.DamageReduction:
+            case PlayerBuffType.PhysicalDamageReduction:
+            case PlayerBuffType.MagicDamageReduction:
+            case PlayerBuffType.Dodge:
+            case PlayerBuffType.PhysicalDodge:
+            case PlayerBuffType.MagicDodge:
+            case PlayerBuffType.Block:
+            case PlayerBuffType.Slow:
+            case PlayerBuffType.AttackDistance:
+                normalizedValue = Math.max(0, Math.min(value, 1));
+                break;
+            default:
+                normalizedValue = Math.max(0, Math.min(value, 1));
+                break;
+        }
+
+        return {
+            value: normalizedValue,
+            chance: Math.max(0, Math.min(chance, 1)),
+        };
+    }
+
+    /** 移除指定类型的 Buff。 */
+    public removeBuff(type: PlayerBuffType): void {
+        if (type === PlayerBuffType.DamageOverTime) {
+            this.damageOverTimeBuffs = [];
+        }
+        const layers = this.buffs.get(type);
+        if (layers) {
+            for (const layer of layers) {
+                if (layer.expireCallback) this.unschedule(layer.expireCallback);
+            }
+        }
+        this.buffs.delete(type);
+    }
+
+    private removeBuffLayer(type: PlayerBuffType, layer: PlayerBuffData): void {
+        const layers = this.buffs.get(type);
+        if (!layers) return;
+
+        const layerIndex = layers.indexOf(layer);
+        if (layerIndex < 0) return;
+        layers.splice(layerIndex, 1);
+        if (layer.expireCallback) this.unschedule(layer.expireCallback);
+        if (layers.length === 0) this.buffs.delete(type);
+        console.log(`${PlayerBuffType[type]} Buff 已到期移除，剩余 ${layers.length} 层`);
+    }
+
+    /** 清除当前角色的所有 Buff。 */
+    public clearBuffs(): void {
+        this.resetBuffs();
+    }
+
+    /** 重置 Buff 状态，移除当前拥有的所有 Buff。 */
+    public resetBuffs(): void {
+        this.damageOverTimeBuffs = [];
+        for (const type of this.buffs.keys()) {
+            this.removeBuff(type);
+        }
+    }
+
+    /** 查询角色是否拥有指定 Buff。 */
+    public hasBuff(type: PlayerBuffType): boolean {
+        if (type === PlayerBuffType.DamageOverTime && this.damageOverTimeBuffs.length > 0) {
+            return true;
+        }
+        return (this.buffs.get(type)?.length ?? 0) > 0;
+    }
+
+    /** 读取 Buff 数值；未持有该 Buff 时返回 0。 */
+    public getBuffValue(type: PlayerBuffType | any): number {
+        return this.buffs.get(type)?.reduce((total, layer) => total + layer.value, 0) ?? 0;
+    }
+
+    /** 获取当前攻击所需的多目标与范围配置。 */
+    public getAttackTargetConfig(): PlayerAttackTargetConfig {
+        const targetCount = this.hasBuff(PlayerBuffType.AttackTargetCount)
+            ? Math.max(1, Math.floor(this.getBuffValue(PlayerBuffType.AttackTargetCount)))
+            : undefined;
+        const areaAttackRadius = this.hasBuff(PlayerBuffType.AreaAttackRadius)
+            ? this.getBuffValue(PlayerBuffType.AreaAttackRadius)
+            : undefined;
+
+        return { targetCount, areaAttackRadius };
+    }
+
+    private getBuffData(type: PlayerBuffType): PlayerBuffData | null {
+        const layers = this.buffs.get(type);
+        if (!layers?.length) return null;
+
+        return layers.reduce((combined, layer) => ({
+            value: combined.value + layer.value,
+            chance: 1 - (1 - combined.chance) * (1 - layer.chance),
+        }), { value: 0, chance: 0 });
+    }
+
+    /** 正抗性使用递减公式，负抗性会提高受到的伤害。 */
+    public calculateIncomingDamage(
+        amount: number,
+        defenseType: PlayerBuffType,
+        attackerBuffs?: FlyPlayerBuffSystem,
+    ): number {
+        const safeDamage = Number.isFinite(amount) ? Math.max(0, amount) : 0;
+        const isMagicDamage = defenseType === PlayerBuffType.MagicDefense;
+        const dodgeType = isMagicDamage ? PlayerBuffType.MagicDodge : PlayerBuffType.PhysicalDodge;
+        const dodgeChance = Math.min(1,
+            this.getBuffValue(PlayerBuffType.Dodge) + this.getBuffValue(dodgeType),
+        );
+        if (Math.random() < dodgeChance) {
+            console.log(`成功闪避${isMagicDamage ? '魔法' : '物理'}攻击，本次未受到伤害`);
+            return 0;
+        }
+
+        /** 根据本次伤害类型选择对应的固定穿透属性。 */
+        const flatPenetrationType = isMagicDamage
+            ? PlayerBuffType.MagicPenetration
+            : PlayerBuffType.PhysicalPenetration;
+        const defense = this.getBuffValue(defenseType);
+        /** 通用穿透与对应类型穿透相加，最多穿透 100% 防御。 */
+        const percentPenetrationType = isMagicDamage
+            ? PlayerBuffType.MagicPercentPenetration
+            : PlayerBuffType.PhysicalPercentPenetration;
+        const percentPenetration = Math.min(1,
+            (attackerBuffs?.getBuffValue(PlayerBuffType.PercentPenetration) ?? 0)
+            + (attackerBuffs?.getBuffValue(percentPenetrationType) ?? 0),
+        );
+        /** 先削减百分比防御，再减去固定穿透；结果可低于零。 */
+        const effectiveDefense = defense * (1 - percentPenetration)
+            - (attackerBuffs?.getBuffValue(flatPenetrationType) ?? 0);
+        /** 正防御使用递减减伤；负防御按负抗性规则放大伤害。 */
+        const damageMultiplier = effectiveDefense >= 0
+            ? 100 / (100 + effectiveDefense)
+            : 2 - 100 / (100 - effectiveDefense);
+        /** 应用伤害倍率并取整，然后记录防御实际改变的伤害值。 */
+        const damageAfterDefense = Math.round(safeDamage * damageMultiplier);
+        this.logDefenseChange(defenseType, safeDamage - damageAfterDefense);
+
+        let damageAfterBlock = damageAfterDefense;
+        const blockBuff = this.getBuffData(PlayerBuffType.Block);
+        const blockRatio = Math.min(1, this.getBuffValue(PlayerBuffType.Block));
+        if (blockBuff && Math.random() < blockBuff.chance) {
+            const blockedDamage = Math.round(damageAfterBlock * blockRatio);
+            damageAfterBlock = Math.max(0, damageAfterBlock - blockedDamage);
+            if (blockedDamage > 0) {
+                console.log(`格挡减少了 ${blockedDamage} 点伤害`);
+            }
+        }
+
+        const damageReductionType = isMagicDamage
+            ? PlayerBuffType.MagicDamageReduction
+            : PlayerBuffType.PhysicalDamageReduction;
+        const damageReduction = Math.min(1,
+            this.getBuffValue(PlayerBuffType.DamageReduction)
+            + this.getBuffValue(damageReductionType),
+        );
+        const actualDamage = Math.round(damageAfterBlock * (1 - damageReduction));
+        const reducedDamage = damageAfterBlock - actualDamage;
+        if (reducedDamage > 0) {
+            console.log(`伤害减免减少了 ${reducedDamage} 点伤害`);
+        }
+        return actualDamage;
+    }
+
+    private logDefenseChange(defenseType: PlayerBuffType, reducedDamage: number): void {
+        if (reducedDamage === 0) return;
+
+        const damageTypeName = defenseType === PlayerBuffType.MagicDefense ? '魔法' : '物理';
+        if (reducedDamage > 0) {
+            console.log(`${damageTypeName}防御减少了 ${reducedDamage} 点伤害`);
+        } else {
+            console.log(`${damageTypeName}负抗性增加了 ${Math.abs(reducedDamage)} 点伤害`);
+        }
+    }
+
+    /** 按实际造成的伤害和吸血比例计算回复量。 */
+    public calculateLifesteal(damage: number): number {
+        const safeDamage = Number.isFinite(damage) ? Math.max(0, damage) : 0;
+        return Math.floor(safeDamage * this.getBuffValue(PlayerBuffType.Lifesteal));
+    }
+
+    /** 按攻速 Buff 缩短基础攻击间隔，间隔单位为秒。 */
+    public getAttackInterval(baseAttackInterval: number): number {
+        const safeBaseInterval = Number.isFinite(baseAttackInterval)
+            ? Math.max(0, baseAttackInterval)
+            : 0;
+        return safeBaseInterval / (1 + this.getBuffValue(PlayerBuffType.AttackSpeed));
+    }
+
+    /** 按最终攻击间隔占用一次攻击机会，并由 Buff 系统管理冷却。 */
+    public tryUseAttack(baseAttackInterval: number): boolean {
+        if (this.isAttackCoolingDown) return false;
+
+        const attackInterval = this.getAttackInterval(baseAttackInterval);
+        if (attackInterval <= 0) return true;
+
+        console.log(`当前攻击间隔：${attackInterval} 秒`);
+        this.isAttackCoolingDown = true;
+        this.scheduleOnce(() => {
+            this.isAttackCoolingDown = false;
+        }, attackInterval);
+        return true;
+    }
+
+    /** 按基础伤害、目标最大生命值伤害、增伤和暴击计算攻击结果。 */
+    public calculateAttack(baseDamage: number, targetMaxHp = 0): PlayerBuffAttackResult {
+        /** 将非法或负数基础伤害归零。 */
+        const safeBaseDamage = Number.isFinite(baseDamage) ? Math.max(0, baseDamage) : 0;
+        /** 按目标最大生命值比例计算额外伤害。 */
+        const safeTargetMaxHp = Number.isFinite(targetMaxHp) ? Math.max(0, targetMaxHp) : 0;
+        const maxHealthDamage = safeTargetMaxHp * this.getBuffValue(PlayerBuffType.MaxHealthDamage);
+        /** 加入固定攻击力和最大生命值伤害后，再应用百分比伤害加成。 */
+        const flatDamage = this.getBuffValue(PlayerBuffType.FlatDamage);
+        const damageBonus = this.getBuffValue(PlayerBuffType.PercentDamage);
+        /** 按暴击 Buff 的触发概率决定本次是否暴击。 */
+        const criticalBuff = this.getBuffData(PlayerBuffType.CriticalDamage);
+        const isCritical = !!criticalBuff && Math.random() < criticalBuff.chance;
+        /** 暴击时叠加额外暴击倍率，否则仍按普通伤害结算。 */
+        const criticalMultiplier = isCritical
+            ? criticalBuff.value + this.getBuffValue(PlayerBuffType.CriticalDamageBonus)
+            : 1;
+        /** 应用百分比加成和暴击倍率，并取整为整数伤害。 */
+        const damage = Math.round((safeBaseDamage + flatDamage + maxHealthDamage) * (1 + damageBonus) * criticalMultiplier);
+        return {
+            damage,
+            isCritical,
+            lifestealAmount: this.calculateLifesteal(damage),
+        };
+    }
+}

package/assets/fly/base/FlyPlayerBuffSystem.ts.meta

@@ -0,0 +1,9 @@
+{
+  "ver": "4.0.24",
+  "importer": "typescript",
+  "imported": true,
+  "uuid": "3af632c8-e289-4d12-9969-f34fd71ef44b",
+  "files": [],
+  "subMetas": {},
+  "userData": {}
+}