_TakeGoblet/assets/module_take_goblet/Script/LevelAction.ts

import { _decorator, BoxCollider2D, Button, CircleCollider2D, Collider2D, Component, find, instantiate, Node, NodeEventType, tween, view, Vec3, mat4, UITransform } from 'cc';
import { resLoader, ResLoader } from '../../core_tgx/base/ResLoader';
import { CupHeight, TakeGobletGlobalInstance, WaterColorLog, WaterColors } from './TakeGobletGlobalInstance';
import { OutArea } from './Component/OutArea';
import { WaitArea } from './Component/WaitArea';
import { CocktailCup } from './Component/CocktailCup';
import { OriginCup } from './Component/OriginCup';
import { Water } from './Component/Water';
import { EventDispatcher } from '../../core_tgx/easy_ui_framework/EventDispatcher';
import { GameEvent } from './Enum/GameEvent';
import { TempCup } from './Component/TempCup';
import { TempCups } from './Component/TempCups';
const { ccclass, property } = _decorator;

@ccclass('LevelAction')
export class LevelAction extends Component {

    @property(OutArea)
    outArea: OutArea = null!;  // 直接引用OutArea组件

    @property(WaitArea)
    waitArea: WaitArea = null!;  // 直接引用WaitArea组件

    @property(Node)
    tempCups: Node = null!;  //临时杯

    @property(Node)
    goblets: Node = null!;  //原浆区

    private originCupPositions = new Map<string, Vec3>(); // 改用唯一ID记录

    start() {
        this.originCupPositions.clear();
        this.generateInitialCups();
        this.registerListener();
    }

    onDestroy() {
        this.unregisterListener();
    }

    registerListener() {
        EventDispatcher.instance.on(GameEvent.EVENT_CLICK_ORIGIN_CUP, this.handlePourOriginCup, this);
        EventDispatcher.instance.on(GameEvent.EVENT_ORIGIN_CUP_DESTROYED, (uuid: string) => {
            if (!this.originCupPositions) return
            const targetPos = this.originCupPositions.get(uuid);
            if (targetPos) {
                this.spawnNewOriginCup(targetPos);
            }
        }, this);
        EventDispatcher.instance.on(GameEvent.EVENT_COCKTAIL_CUP_DESTROYED, this.handleCupDestroyed, this);
    }

    unregisterListener() {
        EventDispatcher.instance.off(GameEvent.EVENT_CLICK_ORIGIN_CUP, this.handlePourOriginCup, this);
        EventDispatcher.instance.off(GameEvent.EVENT_ORIGIN_CUP_DESTROYED, this.spawnNewOriginCup, this);
        EventDispatcher.instance.off(GameEvent.EVENT_COCKTAIL_CUP_DESTROYED, this.handleCupDestroyed, this);
    }

    private async generateInitialCups() {
        const instance = TakeGobletGlobalInstance.instance;
        const configs = instance.getInitialCupsConfig();

        const allCups: Node[] = [];
        for (const config of configs) {
            for (let i = 0; i < config.count; i++) {
                const prefab = await instance.loadAsyncCocktail(config.height);
                const cupNode = instantiate(prefab);
                const cup = cupNode.getComponent(CocktailCup)!;

                // 设置颜色并重置水位
                cup.cupColor = instance.getRandomColor();
                cup.reset();
                allCups.push(cupNode);
            }
        }

        console.log('allCups: ', allCups.length);
        // 分配初始位置
        allCups.slice(0, 2).forEach(cup => this.outArea.addCup(cup));
        allCups.slice(2).forEach(cup => this.waitArea.addCup(cup));

        // 在分配完调酒杯后添加
        this.generateOriginCups();

        // 初始化暂存区
        this.tempCups.children.forEach(tempCupNode => {
            const tempCup = tempCupNode.getComponent(TempCup)!;
            tempCup.reset(); // 重置所有暂存杯
        });
    }

    // 当调酒区杯子被消除时调用
    public async handleCupsRemoved(count: number) {
        for (let i = 0; i < count; i++) {
            const cup = this.waitArea.takeCup();
            if (cup) {
                this.outArea.addCup(cup);
            }
        }
    }

    private generateOriginCups() {
        const outCups = this.outArea.getCups() as Node[];
        const waitCups = this.waitArea.getCups() as Node[];

        // DOTO 取前7个杯子颜色后期修改
        const allCups = [...outCups, ...waitCups].slice(0, 7);
        const colors = allCups.map(cup => {
            const comp = cup.getComponent(CocktailCup);
            return comp ? comp.cupColor : WaterColors.Blue;
        });

        this.goblets.children.forEach(originCupNode => {
            const originCup = originCupNode.getComponent(OriginCup)!;
            const waters = originCup.waters.children;

            for (let i = 0; i < originCup.cupHeight; i++) {
                const waterNode = waters[i];
                const water = waterNode.getComponent(Water);
                if (water) {
                    water.initColor(colors[Math.floor(Math.random() * colors.length)]);
                    waterNode.active = true;
                }
            }

            // 在生成初始原浆杯时记录位置
            const id = originCupNode.uuid; // 使用节点唯一ID
            this.originCupPositions.set(id, originCupNode.position.clone());
            console.log('在生成初始原浆杯时记录id : ', id, originCupNode.position);
        });
    }

    private findTargetCupInOutArea(color: WaterColors): { node: Node, comp: CocktailCup } | null {
        const validCups = this.outArea.getCups()
            .map(node => ({
                node,
                comp: node.getComponent(CocktailCup)!
            }))
            .filter(({ comp }) =>
                comp &&
                comp.cupColor === color &&
                !comp.isFull
            );

        if (validCups.length === 0) return null;

        const sorted = validCups.sort((a, b) => (a.comp.remainingCapacity ?? 0) - (b.comp.remainingCapacity ?? 0));
        return sorted[0];
    }

    public async handlePourOriginCup(originCup: OriginCup) {
        // 如果子节点0是底层，需要反转顺序
        const colors: WaterColors[] = [];
        for (let i = originCup.waters.children.length - 1; i >= 0; i--) {
            const waterNode = originCup.waters.children[i];
            if (waterNode.active) {
                const water = waterNode.getComponent(Water);
                colors.push(water.color);
            }
        }

        let hasUnprocessed = false; // 标记是否有未处理的水层

        for (const color of colors) {
            let targetNode: Node | null = this.findTargetCupInOutArea(color)?.node || null;
            let targetIsTemp = false;

            // 调酒区未找到，查找暂存区
            if (!targetNode) {
                const tempCupsComp = this.tempCups.getComponent(TempCups);
                if (!tempCupsComp) {
                    console.error('TempCups component not found!');
                    continue;
                }
                const tempCup = tempCupsComp.findAvailableTempCup();
                if (tempCup) {
                    targetNode = tempCup.node;
                    targetIsTemp = true;
                }
            }

            if (!targetNode) {
                hasUnprocessed = true;
                console.log(`颜色${WaterColors[color]}未找到可用杯子`);
                continue; // 继续尝试处理后续颜色
            }

            await this.pourAnimation(
                originCup.node,
                targetNode,
                color,
                undefined,
                targetIsTemp
            );

            // 更新目标杯
            if (targetIsTemp) {
                const tempCupComp = targetNode.getComponent(TempCup)!;
                tempCupComp.fill(color);
            } else {
                const cocktailCup = targetNode.getComponent(CocktailCup)!;
                await cocktailCup.addLayer(color); // 等待添加水层流程完成
            }

            this.hideCurrentWaterLayer(originCup);
        }

        // 处理完所有颜色后检查剩余水层
        const remaining = originCup.waters.children.filter(n => n.active).length;
        if (hasUnprocessed || remaining > 0) {
            console.log("游戏结束：仍有未处理的水层");
            // 触发游戏结束逻辑
        } else {
            // 所有水层处理完毕，销毁原浆杯
            originCup.destroyOriginCup();
            this.addWaitCupToOutArea();
        }
    }

    // 新增方法：处理暂存区倒水到调酒区
    private async handlePourTempCupToOutArea() {
        const tempCupsComp = this.tempCups.getComponent(TempCups)!;
        const filledCups = tempCupsComp.getFilledCups();

        for (const tempCup of filledCups) {
            const originalPos = tempCup.node.position.clone();
            const colors = tempCup.getColors();
            let hasProcessed = false; // 标记是否有处理过颜色

            for (const color of colors) {
                const targetCup = this.findTargetCupInOutArea(color);
                if (!targetCup) {
                    console.log(`颜色${WaterColors[color]}未找到可用调酒杯`);
                    continue;
                }

                await this.pourAnimation(
                    tempCup.node,
                    targetCup.node,
                    color,
                    originalPos,
                    true
                );

                const cocktailCup = targetCup.comp;
                await cocktailCup.addLayer(color);
                hasProcessed = true; // 标记已处理
            }
            // 仅当有处理过颜色时才重置暂存杯
            if (hasProcessed) {
                tempCup.reset();
            }
        }
    }

    // 修改原有方法，在添加新杯子后触发暂存区倒水
    private async addWaitCupToOutArea() {
        // 原有添加逻辑保持不变
        const waitCups = this.waitArea.cups;
        const outCups = this.outArea.getCups();
        const needAddCount = outCups.length === 0 ? 2 : 1;

        const movingCups: Node[] = [];
        for (let i = 0; i < needAddCount; i++) {
            if (waitCups.length === 0) break;
            movingCups.push(waitCups.pop()!);
        }

        const newCups: Node[] = [];
        for (const cup of movingCups) {
            const comp = cup.getComponent(CocktailCup)!;
            const prefab = await TakeGobletGlobalInstance.instance.loadAsyncCocktail(comp.cupHeight);
            const newCup = instantiate(prefab);
            const newComp = newCup.getComponent(CocktailCup)!;

            newComp.cupColor = comp.cupColor;
            newComp.reset();

            const targetX = outCups.length === 0 ?
                (newCups.length === 0 ? -125 : -45) :
                -45;
            newCup.setPosition(new Vec3(targetX, 0, 0));

            newCups.push(newCup);
            cup.destroy();
        }

        const outNodes = this.outArea.node.getChildByName('OutNodes')!;
        newCups.forEach(cup => cup.setParent(outNodes));

        // 执行统一平移
        this.outArea.getCups().concat(this.waitArea.getCups()).forEach(cup => {
            tween(cup)
                .by(0.3, { position: new Vec3(80, 0, 0) }, { easing: 'sineOut' })
                .start();
        });

        // 在添加完成后处理暂存区倒水
        await this.handlePourTempCupToOutArea();
    }

    private async pourAnimation(
        origin: Node,
        target: Node,
        color: WaterColors,
        originalPos?: Vec3,
        isTempCup: boolean = false
    ) {
        // 使用正确的坐标转换
        const originParent = origin.parent!;
        const targetWorldPos = target.worldPosition;
        const localPos = originParent.getComponent(UITransform)!.convertToNodeSpaceAR(targetWorldPos);

        // 调整Y轴偏移量
        if (isTempCup) {
            localPos.y += 80; // 暂存杯偏移
        } else {
            localPos.y += 150; // 调酒杯偏移
        }

        // 移动动画到目标位置
        await new Promise<void>(resolve => {
            tween(origin)
                .to(0.5, { position: localPos })
                .call(resolve)
                .start();
        });

        // 正确应用返回动画逻辑
        if (isTempCup && originalPos) {
            await new Promise(resolve => {
                tween(origin)
                    .to(0.3, { position: originalPos })
                    .call(resolve)
                    .start();
            });
        }
    }

    // 新增辅助方法
    private hideCurrentWaterLayer(originCup: OriginCup) {
        const activeWaters = originCup.waters.children.filter(n => n.active);
        if (activeWaters.length >= 0) {
            const topIndex = activeWaters.length - 1;
            activeWaters[topIndex].active = false;
        }
    }

    private async spawnNewOriginCup(targetPos: Vec3) {
        // 创建新原浆杯
        const height = TakeGobletGlobalInstance.instance.generateOriginCupHeight();
        const prefab = await TakeGobletGlobalInstance.instance.loadAsyncOriginCup(height);
        const newCup = instantiate(prefab);

        // 设置初始位置（屏幕左侧）
        const uiTransform = this.node.getComponent(UITransform)!;
        newCup.setPosition(-uiTransform.width / 2, 0, 0);
        this.goblets.addChild(newCup);

        // 记录新杯子的初始位置
        this.originCupPositions.set(newCup.uuid, targetPos);

        // 移动动画到原位置
        tween(newCup)
            .to(0.5, { position: targetPos })
            .start();

        // DOTO 获取颜色配置
        const colors = this.getAvailableColors(5); // 获取前5个颜色
        this.setupOriginCupColors(newCup, colors);
    }

    // 获取可用颜色
    private getAvailableColors(count: number): WaterColors[] {
        const outCups = this.outArea.getCups();
        const waitCups = this.waitArea.getCups();
        const allCups = [...outCups, ...waitCups].slice(0, count);

        return allCups.map(cup => {
            const comp = cup.getComponent(CocktailCup);
            return comp ? comp.cupColor : WaterColors.Blue;
        });
    }

    // 设置原浆杯颜色
    private setupOriginCupColors(cupNode: Node, colors: WaterColors[]) {
        const originCup = cupNode.getComponent(OriginCup)!;
        const waters = originCup.waters.children;

        // 暂时写死5层水
        const waterCount = 5;
        for (let i = 0; i < waterCount; i++) {
            const waterNode = waters[i];
            if (!waterNode) continue;

            const water = waterNode.getComponent(Water)!;
            water.color = colors[Math.floor(Math.random() * colors.length)];
            waterNode.active = true;
        }
    }

    private handleCupDestroyed(destroyedCup: Node) {
        // 从outArea移除被销毁的杯子
        this.outArea.removeCup(destroyedCup);
    }
}