idioms/idiom/assets/module_game/game/Container_Manager.ts

import { _decorator, BoxCollider, Component, find, instantiate, Node, NodePool, Prefab, Quat, random, RigidBody, tween, Vec3 } from 'cc';
import ch_util from '../../ch/ch_util';
import { gui } from '../../core/ui/ui';
import { table_idiom } from '../../module_extra/table_ts/table_idiom';
import { table_level } from '../../module_extra/table_ts/table_level';
import { Hall } from '../hall/Hall';
import { UI_Idioms } from '../ui/UI_Idioms/UI_Idioms';
import { UI_Main } from '../ui/UI_Main/UI_Main';
import { CreateIdiom } from './CreateIdiom';
import { Cube_Infor, Cube_State } from './Cube_Infor';
import { GameCtl } from './GameCtl';
import { ch } from '../../ch/ch';

const { ccclass, property } = _decorator;

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

    @property([Prefab])
    prefabs: Prefab[] = [];

    level_config: any = null;//关卡配置
    config: any = null;//成语库
    idioms: any[] = [];//生成的成语
    index: number[] = [];//生成的成语角标,避免生成重复成语

    @property(CreateIdiom)
    create_node: CreateIdiom = null;

    @property([Node])
    nodes: Node[] = [];//位置节点 用于成语放入

    node_isIdiom: boolean[] = new Array(9).fill(false);

    idiom_combine: Map<Cube_Infor, number> = new Map();

    Cube_Pool: NodePool = new NodePool();
    nodeReferences: Node[] = []; // 额外维护的节点引用数组

    count: number = 0;

    private instantiateCube() {
        for (let i = 0; i < this.idioms.length * 2; i++) {
            let idiomIndex = Math.floor(i / 2);
            let isPiece1 = i % 2 === 0;
            let Text_Length = isPiece1
                ? this.idioms[idiomIndex].piece_1_word.length
                : this.idioms[idiomIndex].piece_2_word.length;
            const newCube = instantiate(this.prefabs[Text_Length - 1]);
            newCube.active = true; // 初始时设置为非激活状态
            // 按顺序为节点赋值文字内容
            newCube.getComponent(Cube_Infor).Text = isPiece1
                ? this.idioms[idiomIndex].piece_1_word
                : this.idioms[idiomIndex].piece_2_word;

            console.log("生成第" + i + "个节点:" + newCube.getComponent(Cube_Infor).Text);
            this.Cube_Pool.put(newCube);
        }
    }

    public getCube(): Node {
        console.log(this.Cube_Pool.size());
        const cube = this.Cube_Pool.get();
        if (cube)
            cube.active = true;
        return cube;
    }


    // 将方块回收到对象池
    public recycleCube(cube: Node): void {
        cube.active = false; // 将方块设置为非激活状态
        this.Cube_Pool.put(cube);
    }

    //清空对象池
    public clearCubePool() {
        this.Cube_Pool.clear();
    }


    //合成规则导入
    start() {
        this.config = table_idiom.getList();
        if (this.config.length === 2052) {
            console.log("合成规则导入成功");
        }
        this.level_config = table_level.getList();
        if (this.level_config.length === 5) {
            console.log("关卡配置导入成功");
        }
        this.level_idioms();

    }

    update(deltaTime: number) {

    }

    checkIdiom_Combine(matchedcube2: Cube_Infor, outMatchedCubes: Cube_Infor[]): boolean {
        if (this.idiom_combine.size < 2) {
            return false; // 至少需要两个方块
        }

        for (let cube of this.idiom_combine.keys()) {
            // 遍历 idioms 列表，检查是否匹配成语
            const matchedIdiom = this.idioms.find(
                idiom =>
                    idiom.piece_1_word === cube.Text && idiom.piece_2_word === matchedcube2.Text
            );

            if (matchedIdiom) {
                // 匹配成功
                outMatchedCubes.push(cube, matchedcube2);
                this.nodeReferences = this.nodeReferences.filter((el) => el !== matchedcube2.node && el !== cube.node);
                console.log("成功拼成成语: " + matchedIdiom.piece_1_word + matchedIdiom.piece_2_word);
                return true;
            }

            // 再检查逆序组合是否匹配
            const reverseMatchedIdiom = this.idioms.find(
                idiom =>
                    idiom.piece_1_word === matchedcube2.Text && idiom.piece_2_word === cube.Text
            );

            if (reverseMatchedIdiom) {
                // 匹配成功
                outMatchedCubes.push(matchedcube2, cube);
                this.nodeReferences = this.nodeReferences.filter((el) => el !== matchedcube2.node && el !== cube.node);
                console.log(
                    "成功拼成成语: " +
                    reverseMatchedIdiom.piece_1_word +
                    reverseMatchedIdiom.piece_2_word
                );
                return true;
            }
        }

        return false; // 没有匹配到成语
    }




    async level_idioms() {
        let level = Hall.getInstance().player.get_max_floor();
        this.clearCubePool();

        if (level === 0) {
            let str2: string = this.level_config[level].idiom_type_2;
            let idiom_type_2 = str2.split("_");
            console.log("idiom_type_2:", idiom_type_2);

            let selectedIdioms: Record<string, any[]> = {};

            [...idiom_type_2].forEach(rule => {
                let filteredIdioms = this.config.filter(item => item.piece_2_word === rule);
                console.log(`筛选2 ${rule} 后的成语：`, filteredIdioms);

                selectedIdioms[rule] = filteredIdioms;
            });

            for (let rule in selectedIdioms) {
                if (selectedIdioms.hasOwnProperty(rule)) {
                    this.idioms.push(...selectedIdioms[rule]);
                }
            }

            console.log("最终选中的成语：", this.idioms);
        }
        else {
            // 获取当前层级的筛选条件
            let str1: string = this.level_config[level].idiom_type_1;
            let idiom_type_1 = str1.split("_"); // 分割成数组
            console.log("idiom_type_1:", idiom_type_1);
            let str2: string = this.level_config[level].idiom_type_2;
            let idiom_type_2 = str2.split("_"); // 分割成数组
            console.log("idiom_type_2:", idiom_type_2);

            // 初始化保存结果的数组
            let selectedIdioms: Record<string, any[]> = {};

            // 遍历 idiom_type_1的每个规律
            [...idiom_type_1].forEach(rule => {
                // 从 config 中筛选符合当前规律的成语
                let filteredIdioms = this.config.filter(item => item.piece_1_word === rule);
                console.log(`筛选 ${rule} 后的成语：`, filteredIdioms);

                if (filteredIdioms.length < this.level_config[level].count) {
                    console.error(`规律 ${rule} 的成语数量不足，仅有 ${filteredIdioms.length} 个`);
                } else {
                    console.log(`规律 ${rule} 的成语数量：${filteredIdioms.length}`);
                    let selected = [];
                    // 随机选择不重复的成语
                    for (let i = 0; i < this.level_config[level].count;) {
                        let rand = ch_util.getRandomInt(0, filteredIdioms.length - 1); // 确保 rand 在有效范围内
                        let selectedIdiom = filteredIdioms[rand];
                        // 从数组中移除已选成语，避免再次选择
                        filteredIdioms.splice(rand, 1);
                        // 添加到已选数组中
                        selected.push(selectedIdiom);
                        console.log(`选中的成语：${selectedIdiom.idiom}`);
                        i++;
                    }
                    selectedIdioms[rule] = selected;
                }
            });
            // 遍历idiom_type_2 的每个规律
            [...idiom_type_2].forEach(rule => {
                // 从 config 中筛选符合当前规律的成语
                let filteredIdioms = this.config.filter(item => item.piece_2_word === rule);
                console.log(`筛选2 ${rule} 后的成语：`, filteredIdioms);

                if (filteredIdioms.length < this.level_config[level].count) {
                    console.error(`规律2 ${rule} 的成语数量不足，仅有 ${filteredIdioms.length} 个`);
                } else {
                    console.log(`规律2 ${rule} 的成语数量：${filteredIdioms.length}`);
                    let selected = [];
                    // 随机选择不重复的成语
                    for (let i = 0; i < this.level_config[level].count;) {
                        let rand = ch_util.getRandomInt(0, filteredIdioms.length - 1); // 确保 rand 在有效范围内
                        let selectedIdiom = filteredIdioms[rand];
                        // 从数组中移除已选成语，避免再次选择
                        filteredIdioms.splice(rand, 1);
                        // 添加到已选数组中
                        selected.push(selectedIdiom);
                        console.log(`选中的成语：${selectedIdiom.idiom}`);
                        i++;
                    }
                    selectedIdioms[rule] = selected;
                }
            });


            // 将所有选中的成语合并到 idioms 数组
            for (let rule in selectedIdioms) {
                if (selectedIdioms.hasOwnProperty(rule)) {
                    this.idioms.push(...selectedIdioms[rule]); // 使用扩展运算符合并成语
                }
            }

            console.log("最终选中的成语：", this.idioms); // 打印最终的成语数组
        }
        this.count = this.level_config[level].count;


        await this.instantiateCube();
        await gui.show(UI_Idioms);
        await this.create_node.nodeMoving();
        gui.show(UI_Main);
    }

    //消除一组
    eliminate() {
        //先判断槽内是否有方块，如果有，匹配槽内最前面一个与散落方块中的
        let cube;
        for (const [key, value] of this.idiom_combine) {
            if (value === 0) {
                cube = key;
                break;
            }
        }

        //槽中有方块
        if (cube) {
            const originalReferences = [...this.nodeReferences];
            for (const element of originalReferences) {
                if (this.idioms.find(c => c.idiom == element.getComponent(Cube_Infor).Text + cube.Text) && element.getComponent(Cube_Infor) !== cube) {
                    console.log(element.getComponent(Cube_Infor).Text);
                    element.getComponent(Cube_Infor).state = Cube_State.wait;
                    element.getComponent(Cube_Infor).rigidbody.type = RigidBody.Type.STATIC;
                    element.getComponent(BoxCollider).enabled = false;
                    let targetRotation = new Quat();
                    Quat.fromEuler(targetRotation, -90, 0, 0);
                    element.rotation = targetRotation;
                    // 使用filter过滤掉当前元素
                    GameCtl.instance.combine_ani(element.getComponent(Cube_Infor), cube);
                    this.nodeReferences = this.nodeReferences.filter((el) => el !== element && el !== cube.node);
                    break;
                }
                else if (this.idioms.find(c => c.idiom == cube.Text + element.getComponent(Cube_Infor).Text) && element.getComponent(Cube_Infor) !== cube) {
                    console.log(element.getComponent(Cube_Infor).Text);
                    element.getComponent(Cube_Infor).state = Cube_State.wait;
                    element.getComponent(Cube_Infor).rigidbody.type = RigidBody.Type.STATIC;
                    element.getComponent(BoxCollider).enabled = false;
                    let targetRotation = new Quat();
                    Quat.fromEuler(targetRotation, -90, 0, 0);
                    element.rotation = targetRotation;
                    GameCtl.instance.combine_ani(cube, element.getComponent(Cube_Infor));
                    this.nodeReferences = this.nodeReferences.filter((el) => el !== element && el !== cube.node);
                    break;
                }
            }
        }

        //槽中没有方块
        else {
            let flag: boolean = false;
            const originalReferences1 = [...this.nodeReferences];
            const originalReferences2 = [...this.nodeReferences];
            for (const element1 of originalReferences1) {
                for (const element2 of originalReferences2) {
                    if (this.idioms.find(c => c.idiom == element1.getComponent(Cube_Infor).Text + element2.getComponent(Cube_Infor).Text)) {
                        element1.getComponent(Cube_Infor).state = Cube_State.wait;
                        element1.getComponent(Cube_Infor).rigidbody.type = RigidBody.Type.STATIC;
                        let targetRotation = new Quat();
                        Quat.fromEuler(targetRotation, -90, 0, 0);
                        element1.rotation = targetRotation;

                        element2.getComponent(Cube_Infor).state = Cube_State.wait;
                        element2.getComponent(Cube_Infor).rigidbody.type = RigidBody.Type.STATIC;
                        element2.getComponent(BoxCollider).enabled = false;
                        element2.rotation = targetRotation;
                        // 使用filter过滤掉当前元素
                        GameCtl.instance.combine_ani(element1.getComponent(Cube_Infor), element2.getComponent(Cube_Infor));
                        this.nodeReferences = this.nodeReferences.filter((el) => el !== element1 && el !== element2);
                        flag = true;
                        break;
                    }
                    if (this.idioms.find(c => c.idiom == element2.getComponent(Cube_Infor).Text + element1.getComponent(Cube_Infor).Text)) {
                        element1.getComponent(Cube_Infor).state = Cube_State.wait;
                        element1.getComponent(Cube_Infor).rigidbody.type = RigidBody.Type.STATIC;
                        let targetRotation = new Quat();
                        Quat.fromEuler(targetRotation, -90, 0, 0);
                        element1.rotation = targetRotation;

                        element2.getComponent(Cube_Infor).state = Cube_State.wait;
                        element2.getComponent(Cube_Infor).rigidbody.type = RigidBody.Type.STATIC;
                        element2.getComponent(BoxCollider).enabled = false;
                        element2.rotation = targetRotation;
                        // 使用filter过滤掉当前元素
                        GameCtl.instance.combine_ani(element2.getComponent(Cube_Infor), element1.getComponent(Cube_Infor));
                        this.nodeReferences = this.nodeReferences.filter((el) => el !== element1 && el !== element2);
                        flag = true;
                        break;
                    }
                }
                if (flag === true) {
                    break;
                }
            }

        }
    }


    async shuffle() {
        // 回收所有非槽内的活跃节点
        this.nodeReferences.forEach(node => {
            const cubeInfo = node.getComponent(Cube_Infor);
            if (cubeInfo.state === Cube_State.live) {
                let targetRotation = new Quat();
                Quat.fromEuler(targetRotation, -90, 0, 0);
                node.rotation = targetRotation;
                this.recycleCube(node); // 回收到池中
            }
        });
        this.shufflePool();
        // 等待节点移动完成后执行后续逻辑
        await this.create_node.nodeMoving();
    }



    //清空槽子
    Empty() {
        for (let idiom of this.idiom_combine.keys()) {

            idiom.state = Cube_State.live;
            let posX = ch.util.getRandom(-3, 3);
            let posZ = ch.util.getRandom(-3, 3);
            tween(idiom.node).to(0.5, { position: new Vec3(posX, this.create_node.node.position.y + 5, posZ) }).call(() => {
                idiom.rigidbody.type = RigidBody.Type.DYNAMIC;
            }).start();
            //idiom.node.position = ;

        }
        this.idiom_combine.clear();
        this.node_isIdiom.fill(false);

        gui.get(UI_Idioms).all_light_Hide();
    }

    private shufflePool() {
        const poolSize = this.Cube_Pool.size();
        const tempArray = [];

        // 从池中取出所有节点到临时数组
        for (let i = 0; i < poolSize; i++) {
            tempArray.push(this.Cube_Pool.get());
        }

        // 只打乱部分节点（以 50% 为例，可调整比例）
        const shuffleCount = Math.ceil(poolSize * 0.5); // 只打乱前 50%
        for (let i = 0; i < shuffleCount; i++) {
            const randomIndex = Math.floor(Math.random() * poolSize);
            [tempArray[i], tempArray[randomIndex]] = [tempArray[randomIndex], tempArray[i]];
        }

        // 将打乱的节点放回池中
        tempArray.forEach(cube => this.Cube_Pool.put(cube));
    }

}