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

package/assets/fly/base/FlyBasePlayer.ts

@@ -0,0 +1,359 @@
+import { _decorator, Component, Node } from 'cc';
+import { FlyArrowLauncher } from './FlyArrowLauncher';
+import { FlyPlayerBuffSystem, PlayerBuffAttackResult, PlayerBuffOptions, PlayerBuffType, PlayerDamageType } from './FlyPlayerBuffSystem';
+import { Enum } from 'cc';
+import { Vec3 } from 'cc';
+import { FlyBaseHp } from './FlyBaseHp';
+import { FlySkiiManager } from './FlySkiiManager';
+import { UITransform } from 'cc';
+const { ccclass, property } = _decorator;
+export interface PlayerOptions {
+    attackDamageType?: PlayerDamageType;
+    baseAttackInterval?: number;
+    bulletEffectParent?: Node | null;
+}
+
+export type PlayerAttackHitCallback<T extends FlyBasePlayer> =
+    (target: T, hitPosition: Vec3, buffType: PlayerBuffType | any) => void;
+
+@ccclass('FlyBasePlayer')
+export class FlyBasePlayer extends Component {
+    @property({ type: Enum(PlayerDamageType), displayName: '攻击类型' })
+    attackDamageType = PlayerDamageType.Physical;
+    @property({
+        type: UITransform,
+        displayName: '碰撞盒',
+        tooltip: '玩家的碰撞盒；',
+    })
+    boxNode: UITransform | null = null;
+
+    // 未受攻速 Buff 影响时，两次攻击之间的基础等待时间，单位为秒。
+    @property({ displayName: '基础攻击间隔（秒）', min: 0 })
+    baseAttackInterval = 0.5;
+
+    @property({
+        type: Node,
+        displayName: '子弹特效父节点',
+        tooltip: '子弹和命中特效的挂载父节点；',
+    })
+    bulletEffectParent: Node | null = null;
+
+    @property({
+        type: FlyArrowLauncher,
+        displayName: '子弹发射器',
+        tooltip: '技能发射器挂载节点；',
+    })
+    flyArrowLauncher: FlyArrowLauncher | null = null;
+
+    @property({
+        type: FlyPlayerBuffSystem,
+        displayName: 'buff管理器',
+        tooltip: 'buff 管理器挂载节点；',
+    })
+    buffSystem: FlyPlayerBuffSystem | null = null;
+
+
+    @property({
+        type: FlyBaseHp,
+        displayName: '血量管理器',
+        tooltip: '基础血量挂载节点；',
+    })
+    flyBaseHp: FlyBaseHp | null = null;
+
+
+    public baseMaxHp: number | null = null;
+
+    onLoad(): void {
+        if (!this.boxNode) {
+            this.boxNode = this.node.getComponent(UITransform) ?? null;
+        }
+
+    }
+    start() {
+
+    }
+
+    /** 通过代码配置 Player 参数，可在 onLoad 前或运行时调用。 */
+    public configure(options: PlayerOptions): void {
+        if (options.attackDamageType !== undefined) {
+            this.attackDamageType = options.attackDamageType;
+        }
+        // 无效间隔不更新；有效值限制为非负数。
+        if (options.baseAttackInterval !== undefined && Number.isFinite(options.baseAttackInterval)) {
+            this.baseAttackInterval = Math.max(0, options.baseAttackInterval);
+        }
+        if (options.bulletEffectParent !== undefined) {
+            this.bulletEffectParent = options.bulletEffectParent;
+        }
+
+    }
+
+    /**碰撞盒子 */
+    getPlayerBox(): { width: number; height: number } {
+        return this.boxNode?.contentSize ?? { width: 0, height: 0 };
+    }
+
+
+
+    /** 尝试向目标位置发射子弹；处于攻击冷却时不会发射。 */
+    public fire(end: Vec3, onHit?: (hitPosition: Vec3, arrow: Node) => void): void {
+        const start = this.node;
+        // 攻速 Buff 系统负责冷却校验；冷却中则不发射。
+        if (!start || !end || !this.buffSystem.tryUseAttack(this.baseAttackInterval)) return;
+        this.flyArrowLauncher.fire(start.worldPosition, end, (hitPosition, arrow) => {
+            onHit?.(hitPosition, arrow);
+        });
+    }
+
+    //#region 发射子弹
+    /**
+     * 发射一次可命中多个目标的攻击。候选目标由场景层提供，以避免基础组件依赖特定阵营或节点结构。
+     */
+    public fireAtTargets<T extends FlyBasePlayer>(
+        buffType: PlayerBuffType | any,
+        primaryTarget: T,
+        candidateTargets: readonly T[],
+        onHit?: PlayerAttackHitCallback<T>,
+    ): void {
+        if (!primaryTarget || !primaryTarget.node.isValid || primaryTarget.isDead || !this.buffSystem.tryUseAttack(this.baseAttackInterval)) return;
+
+        //播放技能动画效果
+        FlySkiiManager.getInstance().EmitSkillAnim?.(buffType, this, primaryTarget, candidateTargets, (target) => {
+            if (!this.isValidAttackTarget(target)) return;
+            onHit?.(target as T, target.node.worldPosition, buffType);
+        });
+
+    }
+
+
+    /**
+     * 选择本次攻击目标：主目标始终优先，其他目标按与主目标的距离从近到远排列。
+     * 范围 Buff 先筛选候选目标；目标数量 Buff 再限制最终总数。
+     */
+    public getAttackTargets<T extends FlyBasePlayer>(
+        primaryTarget: T,
+        candidateTargets: readonly T[],
+    ): T[] {
+        if (!this.isValidAttackTarget(primaryTarget)) return [];
+
+        const { targetCount, areaAttackRadius } = this.buffSystem.getAttackTargetConfig();
+        const primaryPosition = primaryTarget.node.worldPosition;
+        const uniqueCandidates = new Set<T>();
+        const additionalTargets = candidateTargets.filter(candidate => {
+            if (candidate === primaryTarget || candidate.node === this.node || uniqueCandidates.has(candidate)) return false;
+            if (!this.isValidAttackTarget(candidate)) return false;
+            uniqueCandidates.add(candidate);
+            return areaAttackRadius === undefined
+                || Vec3.distance(primaryPosition, candidate.node.worldPosition) <= areaAttackRadius;
+        });
+
+        additionalTargets.sort((left, right) =>
+            Vec3.distance(primaryPosition, left.node.worldPosition)
+            - Vec3.distance(primaryPosition, right.node.worldPosition),
+        );
+
+        const targets = [primaryTarget, ...additionalTargets];
+        return targetCount === undefined ? targets : targets.slice(0, targetCount);
+    }
+
+    /** 验证目标是否为有效的攻击目标 */
+    public isValidAttackTarget(target: FlyBasePlayer | null | undefined): target is FlyBasePlayer {
+        return !!target && target !== this && target?.node?.isValid && !target.isDead;
+    }
+
+
+    /** 当前玩家是否已死亡；未配置血量组件时视为存活。 */
+    public get isDead(): boolean {
+        return this.flyBaseHp?.isDead ?? false;
+    }
+
+    /** 玩家死亡后销毁其节点；存活时不执行操作。 */
+    public destroyIfDead(): void {
+        if (this.isDead && this.node.isValid) {
+            this.node.destroy();
+        }
+    }
+
+    /** 当前最大生命值；未配置血量组件时返回 0。 */
+    public get maxHp(): number {
+        return this.flyBaseHp?.maxHp ?? 0;
+    }
+
+    /**
+     * 按伤害类型选择对应防御 Buff，计算并应用实际伤害。
+     * @returns 经过防御计算后的实际伤害值。
+     */
+    public takeDamage(
+        amount: number,
+        damageType = PlayerDamageType.Physical,
+        attackerBuffs?: FlyPlayerBuffSystem,
+    ): number {
+        const defenseType = damageType === PlayerDamageType.Magic
+            ? PlayerBuffType.MagicDefense
+            : PlayerBuffType.PhysicalDefense;
+        const actualDamage = this.buffSystem.calculateIncomingDamage(amount, defenseType, attackerBuffs);
+        this.flyBaseHp?.takeDamage(actualDamage);
+        return actualDamage;
+    }
+
+    /** 恢复生命值，可选择是否播放治疗动画。 */
+    public heal(amount: number, animate = true): void {
+        this.flyBaseHp?.heal(amount, animate);
+    }
+
+    /**
+     * 重复添加时同类型 Buff 数值累加。DoT 配置会在命中时尝试施加给目标。
+     */
+    public addBuff(options: PlayerBuffOptions): void {
+        const {
+            type,
+            value,
+            chance = 1,
+            duration,
+            damageType = PlayerDamageType.Magic,
+            onApplied,
+        } = options;
+
+        if (type === PlayerBuffType.CurrentHealth) {
+            this.buffSystem.applyCurrentHealthBuff(
+                value,
+                chance,
+                amount => this.applyHealthBuff(amount, true, onApplied),
+                duration,
+            );
+            return;
+        }
+
+        if (type === PlayerBuffType.DamageOverTime) {
+            this.buffSystem.addDamageOverTimeBuff(value, chance, duration, damageType);
+            return;
+        }
+
+        this.buffSystem.addBuff(type, value, chance, duration, () => this.onBuffExpired(type));
+        this.onBuffChanged(type);
+    }
+
+    /**
+     * 替换指定类型的现有 Buff。DoT 配置只替换攻击触发配置。
+     */
+    public resetBuff(options: PlayerBuffOptions): void {
+        const {
+            type,
+            value,
+            chance = 1,
+            duration,
+            damageType = PlayerDamageType.Magic,
+            onApplied,
+        } = options;
+
+        if (type === PlayerBuffType.CurrentHealth) {
+            this.buffSystem.applyCurrentHealthBuff(
+                value,
+                chance,
+                amount => this.applyHealthBuff(amount, false, onApplied),
+                duration,
+                true,
+            );
+            return;
+        }
+
+        if (type === PlayerBuffType.DamageOverTime) {
+            this.buffSystem.resetDamageOverTimeBuff(value, chance, duration, damageType);
+            return;
+        }
+
+        this.buffSystem.resetBuff(type, value, chance, duration, () => this.onBuffExpired(type));
+        this.onBuffChanged(type);
+    }
+
+    /** 应用治疗类 Buff，并将实际恢复量传给回调。 */
+    public applyHealthBuff(
+        amount: number,
+        animate: boolean,
+        onApplied?: (healedAmount: number) => void,
+    ): void {
+        const hp = this.flyBaseHp;
+        const previousHp = hp?.currentHp ?? 0;
+        this.heal(amount, animate);
+        const healedAmount = (hp?.currentHp ?? previousHp) - previousHp;
+        if (healedAmount > 0) onApplied?.(healedAmount);
+    }
+
+    /** 将攻击者的 DoT 效果交由 BuffSystem 按命中概率施加给目标。 */
+    public applyDamageOverTimeOnHit(target: FlyBasePlayer, onDamage?: (damage: number) => void): void {
+        if (target.isDead) return;
+
+        this.buffSystem.applyDamageOverTimeOnHit(
+            target.buffSystem,
+            (damage, damageType) => () => {
+                const actualDamage = target.takeDamage(damage, damageType);
+                if (actualDamage > 0) onDamage?.(actualDamage);
+                target.destroyIfDead();
+            },
+        );
+    }
+
+    /** Buff 变化时同步需要即时反映到血量组件的属性。 */
+    protected onBuffChanged(type: PlayerBuffType): void {
+        if (type === PlayerBuffType.MaxHealth) {
+            this.syncBuffedMaxHp();
+        }
+
+    }
+
+    /** Buff 到期时同步需要即时反映到血量组件的属性。 */
+    protected onBuffExpired(type: PlayerBuffType): void {
+        if (type === PlayerBuffType.MaxHealth) {
+            this.syncBuffedMaxHp();
+        }
+    }
+
+    /** 移除指定 Buff，并同步受该 Buff 影响的属性。 */
+    public removeBuff(type: PlayerBuffType): void {
+        this.buffSystem.removeBuff(type);
+        this.onBuffChanged(type);
+    }
+
+    /** 清除所有 Buff；具体重置逻辑由 resetBuffs 执行。 */
+    public clearBuffs(): void {
+        this.resetBuffs();
+    }
+
+    /** 重置 Buff 系统，并重新同步相关属性。 */
+    public resetBuffs(): void {
+        this.buffSystem.resetBuffs();
+        this.onBuffChanged(PlayerBuffType.MaxHealth);
+        this.onBuffChanged(PlayerBuffType.MovementSpeed);
+    }
+
+    /** 查询玩家是否拥有指定类型的 Buff。 */
+    public hasBuff(type: PlayerBuffType): boolean {
+        return this.buffSystem.hasBuff(type);
+    }
+
+    /** 根据基础伤害和目标最大生命值计算最终攻击结果。 */
+    public calculateAttack(baseDamage: number, targetMaxHp = 0): PlayerBuffAttackResult {
+        return this.buffSystem.calculateAttack(baseDamage, targetMaxHp);
+    }
+
+    /** 根据本次伤害计算生命偷取量。 */
+    public calculateLifesteal(damage: number): number {
+        return this.buffSystem.calculateLifesteal(damage);
+    }
+
+    /** 保留当前生命比例，并按最大生命值 Buff 更新生命上限与当前生命值。 */
+    public syncBuffedMaxHp(): void {
+        const hp = this.flyBaseHp;
+        if (!hp) return;
+        this.baseMaxHp ??= hp.maxHp;
+        const currentHpRatio = hp.maxHp > 0
+            ? Math.max(0, Math.min(hp.currentHp / hp.maxHp, 1))
+            : 1;
+        const effectiveMaxHp = this.baseMaxHp + this.buffSystem.getBuffValue(PlayerBuffType.MaxHealth);
+        hp.configure({
+            maxHp: effectiveMaxHp,
+            currentHp: effectiveMaxHp * currentHpRatio,
+        });
+    }
+
+}

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

@@ -0,0 +1,9 @@
+{
+  "ver": "4.0.24",
+  "importer": "typescript",
+  "imported": true,
+  "uuid": "1c545419-16a7-40f7-a796-39f7404249ec",
+  "files": [],
+  "subMetas": {},
+  "userData": {}
+}

package/assets/fly/base/FlyDamageLabel.ts

@@ -0,0 +1,198 @@
+import { _decorator, Component, Node, Label, BitmapFont, Font, UIOpacity, tween, Tween, Vec3, Color } from 'cc';
+
+const { ccclass, property } = _decorator;
+
+export enum FlyDamageLabelType {
+    /** 普通伤害飘字。 */
+    Damage,
+    /** 暴击伤害飘字。 */
+    Critical,
+    /** 治疗回复飘字。 */
+    Heal,
+    /** 中毒持续伤害飘字。 */
+    Poison,
+}
+
+@ccclass('FlyDamageLabel')
+export class FlyDamageLabel extends Component {
+    @property({ type: Node, displayName: '挂载父节点', tooltip: '飘字显示在这个父节点上，默认使用当前节点父节点' })
+    parentNode: Node | null = null;
+
+    @property({ type: Label, displayName: '标签组件', tooltip: '用于显示伤害值的标签组件' })
+    label: Label = null;
+
+    @property({ displayName: '上升高度', tooltip: '数字上升的距离' })
+    riseHeight = 60;
+
+
+
+    private isAnimating = false;
+    private originalOpacity: number | null = null;
+
+    @property({ displayName: '最高点停顿时长', tooltip: '飘字到达最高点后等待的秒数' })
+    peakPauseDuration = 0.1;
+
+
+    @property({ displayName: '动画持续时间', tooltip: '飘字动画的总持续时间' })
+    animationDuration = 1;
+
+    @property({ displayName: '普通伤害颜色' })
+    damageColor = new Color(255, 255, 255, 255);
+
+    @property({ displayName: '暴击颜色' })
+    criticalColor = new Color(255, 96, 64, 255);
+
+    @property({ displayName: '治疗颜色' })
+    healColor = new Color(80, 255, 120, 255);
+
+    @property({ displayName: '中毒颜色' })
+    poisonColor = new Color(180, 80, 220, 255);
+
+    @property({ type: BitmapFont, displayName: '普通伤害字体' })
+    damageFont: BitmapFont | null = null;
+
+    @property({ type: BitmapFont, displayName: '暴击字体' })
+    criticalFont: BitmapFont | null = null;
+
+    @property({ type: BitmapFont, displayName: '治疗字体' })
+    healFont: BitmapFont | null = null;
+
+    private originalFont: Font | null = null;
+    private hasOriginalFont = false;
+
+    private get activeLabel(): Label {
+        if (this.label) return this.label;
+        this.label = this.node.getComponent(Label) ?? this.node.addComponent(Label);
+        return this.label;
+    }
+
+    onLoad(): void {
+        ;
+    }
+
+    public show(
+        position: Vec3,
+        value: number,
+        parent: Node | null = this.parentNode ?? this.node.parent,
+        type: FlyDamageLabelType = FlyDamageLabelType.Damage,
+    ): void {
+        if (!parent) return;
+
+        const label = this.activeLabel;
+        if (!this.hasOriginalFont) {
+            this.originalFont = label.font;
+            this.hasOriginalFont = true;
+        }
+        const localPos = new Vec3(
+            position.x - parent.worldPosition.x,
+            position.y - parent.worldPosition.y,
+            0,
+        );
+        this.reset();
+        const opacity = this.node.getComponent(UIOpacity) ?? this.node.addComponent(UIOpacity);
+        if (this.originalOpacity === null) {
+            this.originalOpacity = opacity.opacity;
+        }
+        this.isAnimating = true;
+
+        this.node.parent = parent;
+        this.node.setPosition(localPos);
+        this.setLabelStyle(label, value, type);
+        opacity.opacity = 0;
+        this.node.active = true;
+
+        this.playAnimation(localPos, opacity);
+    }
+
+    protected setLabelStyle(label: Label, value: number, type: FlyDamageLabelType): void {
+        const absoluteValue = Math.abs(value);
+        switch (type) {
+            case FlyDamageLabelType.Critical:
+                label.string = `暴击 -${absoluteValue}`;
+                label.color = this.criticalColor.clone();
+                label.font = this.criticalFont ?? this.originalFont;
+                break;
+            case FlyDamageLabelType.Heal:
+                label.string = `+${absoluteValue}`;
+                label.color = this.healColor.clone();
+                label.font = this.healFont ?? this.originalFont;
+                break;
+            case FlyDamageLabelType.Poison:
+                label.string = `-${absoluteValue}`;
+                label.color = this.poisonColor.clone();
+                label.font = this.damageFont ?? this.originalFont;
+                break;
+            default:
+                label.string = `-${absoluteValue}`;
+                label.color = this.damageColor.clone();
+                label.font = this.damageFont ?? this.originalFont;
+                break;
+        }
+    }
+
+    protected playAnimation(startPosition: Vec3, opacity: UIOpacity): void {
+        const totalDuration = Math.max(this.animationDuration, this.peakPauseDuration + 0.3);
+        const movementDuration = totalDuration - this.peakPauseDuration;
+        const fallDuration = movementDuration * 0.6;
+        const riseDuration = movementDuration - fallDuration;
+        const fadeInDuration = 0.1;
+        const fadeDuration = Math.min(0.5, totalDuration - fadeInDuration);
+        const peakPos = new Vec3(startPosition.x, startPosition.y + this.riseHeight, 0);
+        // 随机选择下落方向、横向偏移和下落距离。
+        const horizontalDirection = Math.random() < 0.5 ? -1 : 1;
+        const horizontalDrift = horizontalDirection * (50 + Math.random() * 28);
+        const fallDistance = Math.max(100, this.riseHeight * (0.6 + Math.random() * 0.3));
+        const fallPos = new Vec3(peakPos.x + horizontalDrift, peakPos.y - fallDistance, 0);
+
+        // 保持原始大小，平滑上升至最高点，停顿后再斜向下落。
+        tween(this.node)
+            .to(riseDuration, { position: peakPos }, { easing: 'sineInOut' })
+            .delay(this.peakPauseDuration)
+            .to(fallDuration, { position: fallPos }, {
+                easing: 'linear',
+                onUpdate: (_target, ratio) => {
+                    const progress = Math.max(0, Math.min(ratio, 1));
+                    this.node.setPosition(
+                        peakPos.x + horizontalDrift * progress,
+                        peakPos.y - fallDistance * progress * progress,
+                        peakPos.z,
+                    );
+                },
+            })
+            .call(() => this.reset())
+            .start();
+
+        // 位移期间保持显示，并在动画末段淡出。
+        tween(opacity)
+            .to(fadeInDuration, { opacity: this.originalOpacity })
+            .delay(totalDuration - fadeInDuration - fadeDuration)
+            .to(fadeDuration, { opacity: 0 })
+            .start();
+
+    }
+
+    public reset(): void {
+        if (!this.isAnimating && !this.node.parent && !this.node.active) {
+            return;
+        }
+
+        const label = this.activeLabel;
+        const opacity = this.node.getComponent(UIOpacity);
+        Tween.stopAllByTarget(this.node);
+        if (opacity) {
+            Tween.stopAllByTarget(opacity);
+            opacity.opacity = this.originalOpacity ?? 255;
+        }
+        if (this.node.parent) {
+            this.node.removeFromParent();
+        }
+        this.node.active = false;
+        label.string = '';
+        label.color = this.damageColor.clone();
+        if (this.hasOriginalFont) {
+            label.font = this.originalFont;
+        }
+        this.node.setScale(1, 1, 1);
+        this.isAnimating = false;
+    }
+}

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

@@ -0,0 +1,9 @@
+{
+  "ver": "4.0.24",
+  "importer": "typescript",
+  "imported": true,
+  "uuid": "ae703a65-e5fd-4f61-a418-9b8aca504600",
+  "files": [],
+  "subMetas": {},
+  "userData": {}
+}

package/assets/fly/base/FlyDamageLabelManager.ts

@@ -0,0 +1,111 @@
+import { _decorator, Component, Node, Vec3, NodePool, instantiate, Prefab, Enum } from 'cc';
+import { FlyDamageLabel, FlyDamageLabelType } from './FlyDamageLabel';
+
+const { ccclass, property } = _decorator;
+
+export enum FlyDamageLabelTemplateType {
+    Node,
+    Prefab,
+}
+
+@ccclass('FlyDamageLabelManager')
+export class FlyDamageLabelManager extends Component {
+    @property({ type: Enum(FlyDamageLabelTemplateType), displayName: '资源类型' })
+    templateType = FlyDamageLabelTemplateType.Node;
+
+    @property({ type: Node, displayName: '模板节点', tooltip: '当资源类型为 Node 时使用', visible(this: FlyDamageLabelManager) { return this.templateType === FlyDamageLabelTemplateType.Node; } })
+    template: Node | null = null;
+
+    @property({ type: Prefab, displayName: '模板 Prefab', tooltip: '当资源类型为 Prefab 时使用', visible(this: FlyDamageLabelManager) { return this.templateType === FlyDamageLabelTemplateType.Prefab; } })
+    prefabTemplate: Prefab | null = null;
+
+    @property({ displayName: '缓存数量', tooltip: '预创建的伤害文本节点数量' })
+    cacheCount = 8;
+
+    private battery: NodePool = new NodePool();
+
+    protected onLoad(): void {
+        this.ensureTemplate();
+        for (let i = 0; i < this.cacheCount; i++) {
+            const node = this.createNode();
+            node.active = false;
+            this.battery.put(node);
+        }
+    }
+
+    private ensureTemplate(): void {
+        if (this.templateType === FlyDamageLabelTemplateType.Node) {
+            if (this.template) return;
+            const templateNode = new Node('FlyDamageLabelTemplate');
+            templateNode.addComponent(FlyDamageLabel);
+            this.template = templateNode;
+            return;
+        }
+
+        if (this.prefabTemplate) return;
+    }
+
+    private createNode(): Node {
+        if (this.templateType === FlyDamageLabelTemplateType.Node) {
+            if (!this.template) {
+                this.ensureTemplate();
+            }
+            const node = instantiate(this.template!);
+            node.name = 'FlyDamageLabelItem';
+            node.active = false;
+            return node;
+        }
+
+        if (!this.prefabTemplate) {
+            this.ensureTemplate();
+        }
+        const node = instantiate(this.prefabTemplate!);
+        node.name = 'FlyDamageLabelItem';
+        node.active = false;
+        return node;
+    }
+
+    public show(
+        position: Vec3,
+        value: number,
+        type: FlyDamageLabelType = FlyDamageLabelType.Damage,
+        parent: Node | null = this.node.parent ?? this.node,
+
+    ): void {
+        if (!parent) return;
+
+        let labelNode = this.battery.get() as Node | null;
+        if (!labelNode) {
+            labelNode = this.createNode();
+        }
+
+        const label = labelNode.getComponent(FlyDamageLabel);
+        if (!label) {
+            labelNode.addComponent(FlyDamageLabel);
+        }
+
+        const activeLabel = labelNode.getComponent(FlyDamageLabel)!;
+        activeLabel.reset();
+        labelNode.parent = parent;
+        labelNode.active = true;
+        activeLabel.show(position, value, parent, type);
+
+        this.scheduleOnce(() => {
+            this.recycle(labelNode);
+        }, activeLabel.animationDuration + 0.05);
+    }
+
+    public recycle(node: Node): void {
+        if (!node || !node.isValid) return;
+
+        const label = node.getComponent(FlyDamageLabel);
+        label?.reset();
+        node.removeFromParent();
+        node.active = false;
+        if (this.battery.size() < this.cacheCount) {
+            this.battery.put(node);
+        } else {
+            node.destroy();
+        }
+    }
+}

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

@@ -0,0 +1,9 @@
+{
+  "ver": "4.0.24",
+  "importer": "typescript",
+  "imported": true,
+  "uuid": "d025d3ad-5691-4a7f-a6a6-a23a5fc5d8a6",
+  "files": [],
+  "subMetas": {},
+  "userData": {}
+}