tanqiu/assets/scripts/FourUI/UpgradeSystem/UpgradeAni.ts

import { _decorator, Component, Node, Tween, tween, Vec3, Material, Sprite, resources, Label, JsonAsset } from 'cc';
import { JsonConfigLoader } from '../../Core/JsonConfigLoader';
import { Audio } from '../../AudioManager/AudioManager';
import BlinkScaleAnimator from '../../Animations/BlinkScaleAnimator';

const { ccclass, property } = _decorator;

/**
 * 植物升级动画控制器
 * 负责管理植物升级相关的动画效果
 */
@ccclass('UpgradeAni')
export class UpgradeAni extends Component {
    
    @property(Node)
    weaponSpriteNode: Node = null;
    
    @property(Node)
    upgradeBtnNode: Node = null; // Canvas/UpgradePanel/UpgradeBtn/UP节点
    
    @property(Label)
    currentDamageLabel: Label = null; // Canvas/UpgradePanel/NumberBack/CurrentDamage节点
    
    private blinkComp: BlinkScaleAnimator | null = null; // 闪烁动画组件引用
    private weaponsConfig: any = null; // 武器配置数据
    
    /**
     * 植物升级成功动画
     * 播放植物图标的放大缩小动画，并在升级期间应用扫描效果材质，同时播放升级音效
     * @param weaponIconNode 植物图标节点
     */
    public playWeaponUpgradeAnimation(weaponIconNode: Node): Promise<void> {
        return new Promise((resolve) => {
            if (!weaponIconNode) {
                resolve();
                return;
            }
            
            // 停止之前的动画，防止快速点击时动画冲突
            Tween.stopAllByTarget(weaponIconNode);
            
            // 重置到原始缩放状态，确保动画从正确的状态开始
            weaponIconNode.setScale(Vec3.ONE);
            
            // 保存原始缩放值
            const originalScale = Vec3.ONE.clone();
            
            let weaponSprite: Sprite = null;
            let originalMaterial: Material = null;
            
            console.log('[UpgradeAni] 开始武器升级动画，weaponSpriteNode:', this.weaponSpriteNode);
            
            // 播放植物升级音效
            Audio.playUISound('data/弹球音效/equipment level up finish');
            
            // 使用装饰器引用的WeaponSprite节点，获取其Sprite组件并保存原始材质
            if (this.weaponSpriteNode) {
                console.log('[UpgradeAni] 找到weaponSpriteNode，开始获取Sprite组件');
                weaponSprite = this.weaponSpriteNode.getComponent(Sprite);
                if (weaponSprite) {
                    console.log('[UpgradeAni] 找到Sprite组件，开始加载材质');
                    // 保存原始材质，优先保存customMaterial，如果没有则保存当前material
                    originalMaterial = weaponSprite.customMaterial || weaponSprite.material;
                    console.log('[UpgradeAni] 原始材质:', originalMaterial);
                    
                    // 加载并应用扫描效果材质
                    resources.load('shaders/scan-effect', Material, (err, scanMaterial) => {
                        console.log('[UpgradeAni] 材质加载回调，err:', err, 'scanMaterial:', scanMaterial);
                        if (!err && scanMaterial && weaponSprite) {
                            weaponSprite.material = scanMaterial;
                            console.log('[UpgradeAni] 应用扫描效果材质成功');
                        } else {
                            console.warn('[UpgradeAni] 加载扫描效果材质失败:', err);
                        }
                    });
                } else {
                    console.warn('[UpgradeAni] weaponSpriteNode上没有找到Sprite组件');
                }
            } else {
                console.warn('[UpgradeAni] weaponSpriteNode为null，请在编辑器中设置');
            }
            
            // 使用代码驱动的缩放动画：放大到1.5倍再缩回原始大小
            const upDuration = 0.25;
            const downDuration = 0.25;
            const scaleFactor = 1.5;
            const easingUp = 'sineOut';
            const easingDown = 'sineIn';
            
            const targetScale = new Vec3(
                originalScale.x * scaleFactor,
                originalScale.y * scaleFactor,
                originalScale.z
            );
            
            tween(weaponIconNode)
                .to(upDuration, { scale: targetScale }, { easing: easingUp })
                .to(downDuration, { scale: originalScale }, { easing: easingDown })
                .call(() => {
                    // 动画结束后恢复原始材质
                    if (weaponSprite && originalMaterial) {
                        if (weaponSprite.customMaterial === originalMaterial) {
                            weaponSprite.material = weaponSprite.customMaterial;
                        } else {
                            weaponSprite.material = originalMaterial;
                        }
                        console.log('[UpgradeAni] 恢复原始材质成功');
                    } else if (weaponSprite) {
                        if (weaponSprite.customMaterial) {
                            weaponSprite.material = weaponSprite.customMaterial;
                            console.log('[UpgradeAni] 恢复到customMaterial');
                        } else {
                            weaponSprite.material = null;
                            console.log('[UpgradeAni] 恢复到默认材质');
                        }
                    }
                    resolve();
                })
                .start();
        });
    }
    
    /**
     * 显示升级面板动画
     */
    public showPanel(): Promise<void> {
        return new Promise((resolve) => {
            const panel = this.node;
            if (!panel) {
                resolve();
                return;
            }
            
            // 确保面板激活
            panel.active = true;
            
            // 停止之前的动画
            Tween.stopAllByTarget(panel);
            
            // 设置初始状态：缩放为0
            panel.setScale(Vec3.ZERO);
            
            // 播放弹出动画
            tween(panel)
                .to(0.3, { scale: Vec3.ONE }, {
                    easing: 'backOut'
                })
                .call(() => {
                    resolve();
                })
                .start();
        });
    }
    
    /**
     * 隐藏升级面板动画
     */
    public hidePanel(): Promise<void> {
        return new Promise((resolve) => {
            const panel = this.node;
            if (!panel) {
                resolve();
                return;
            }
            
            // 停止之前的动画
            Tween.stopAllByTarget(panel);
            
            // 播放缩小动画
            tween(panel)
                .to(0.2, { scale: Vec3.ZERO }, {
                    easing: 'backIn'
                })
                .call(() => {
                    // 动画结束后隐藏面板
                    panel.active = false;
                    resolve();
                })
                .start();
        });
    }
    
    /**
     * 立即隐藏面板（无动画）
     */
    public hidePanelImmediate(): void {
        const panel = this.node;
        if (panel) {
            // 停止所有动画
            Tween.stopAllByTarget(panel);
            // 立即隐藏
            panel.active = false;
            panel.setScale(Vec3.ONE);
        }
    }
    
    /**
     * 开始升级按钮闪烁动画
     * 当钞票足够升级时调用此方法
     */
    public startUpgradeBtnBlink(): void {
        if (!this.upgradeBtnNode) {
            console.warn('[UpgradeAni] upgradeBtnNode为null，请在编辑器中设置Canvas/UpgradePanel/UpgradeBtn/UP节点');
            return;
        }
        
        // 停止之前的闪烁动画
        this.stopUpgradeBtnBlink();
        
        // 重置到原始缩放状态
        this.upgradeBtnNode.setScale(Vec3.ONE);
        
        // 使用预挂载通用组件进行循环闪烁（放大缩小）
        const comp = this.upgradeBtnNode.getComponent(BlinkScaleAnimator);
        if (!comp) {
            console.warn('[UpgradeAni] 未挂载 BlinkScaleAnimator 组件，请在编辑器中为 upgradeBtnNode 预先添加该组件（默认禁用）。');
        } else {
            comp.scaleFactor = 1.5;
            comp.upDuration = 0.5;
            comp.downDuration = 0.5;
            comp.easingUp = 'sineInOut';
            comp.easingDown = 'sineInOut';
            comp.playOnEnable = false;
            comp.play();
            this.blinkComp = comp;
        }
        
        console.log('[UpgradeAni] 开始升级按钮闪烁动画');
    }
    
    /**
     * 停止升级按钮闪烁动画
     * 当钞票不够升级时调用此方法
     */
    public stopUpgradeBtnBlink(): void {
        if (this.blinkComp) {
            this.blinkComp.stop();
            this.blinkComp = null;
        }
        
        if (this.upgradeBtnNode) {
            Tween.stopAllByTarget(this.upgradeBtnNode);
            this.upgradeBtnNode.setScale(Vec3.ONE);
        }
        
        console.log('[UpgradeAni] 停止升级按钮闪烁动画');
    }
    
    /**
     * 检查升级按钮是否正在闪烁
     * @returns 是否正在闪烁
     */
    public isUpgradeBtnBlinking(): boolean {
        return this.blinkComp !== null;
    }
    
    /**
     * 加载武器配置数据
     */
    public async loadWeaponsConfig(): Promise<void> {
        try {
            this.weaponsConfig = await JsonConfigLoader.getInstance().loadConfig('weapons');
            console.log('[UpgradeAni] 武器配置加载成功:', this.weaponsConfig);
        } catch (error) {
            console.error('[UpgradeAni] 加载武器配置失败:', error);
            throw error;
        }
    }
    
    /**
     * 从JSON配置中获取武器在指定等级的伤害值
     * @param weaponId 武器ID
     * @param level 武器等级
     * @returns 伤害值
     */
    public getWeaponDamageFromConfig(weaponId: string, level: number): number {
        if (!this.weaponsConfig || !this.weaponsConfig.weapons) {
            console.warn('[UpgradeAni] 武器配置未加载');
            return 0;
        }
        
        const weaponConfig = this.weaponsConfig.weapons.find((w: any) => w.id === weaponId);
        if (!weaponConfig) {
            console.warn(`[UpgradeAni] 未找到武器配置: ${weaponId}`);
            return 0;
        }
        
        if (level === 0) {
            return 0; // 未解锁武器伤害为0
        }
        
        // 优先从upgradeConfig中获取伤害值
        if (weaponConfig.upgradeConfig && weaponConfig.upgradeConfig.levels) {
            const levelConfig = weaponConfig.upgradeConfig.levels[level.toString()];
            if (levelConfig && typeof levelConfig.damage === 'number') {
                return levelConfig.damage;
            }
        }
        
        // 如果upgradeConfig中没有伤害值，使用基础伤害 + 等级加成
        const baseDamage = weaponConfig.stats?.damage || 0;
        return baseDamage + (level - 1);
    }
    
    /**
     * 更新当前伤害显示
     * @param weaponId 武器ID
     * @param level 武器等级
     */
    public updateCurrentDamageDisplay(weaponId: string, level: number): void {
        if (!this.currentDamageLabel) {
            console.warn('[UpgradeAni] currentDamageLabel未设置，请在编辑器中设置Canvas/UpgradePanel/NumberBack/CurrentDamage节点');
            return;
        }
        
        const damage = this.getWeaponDamageFromConfig(weaponId, level);
        this.currentDamageLabel.string = damage.toString();
        
        console.log(`[UpgradeAni] 更新伤害显示: ${weaponId} 等级${level} 伤害${damage}`);
    }

}