System.register(["__unresolved_0", "cc", "__unresolved_1", "__unresolved_2", "__unresolved_3", "__unresolved_4", "__unresolved_5", "__unresolved_6", "__unresolved_7", "__unresolved_8", "__unresolved_9", "__unresolved_10", "__unresolved_11", "__unresolved_12", "__unresolved_13", "__unresolved_14", "__unresolved_15"], function (_export, _context) {
  "use strict";

  var _reporterNs, _cclegacy, __checkObsolete__, __checkObsoleteInNamespace__, _decorator, geometry, Camera, screen, instantiate, v3, tween, MeshRenderer, Vec3, find, input, Input, Tween, PhysicsSystem, TileItem, Main, ResUtil, ComponentEx, audioMgr, BusyLoadingManager, BUSY_TYPE, Data, WindowManager, MsgHints, Utils, eventEmitter, platformSystem, GameConst, ITEM_TYPE, levelsData, PoolManager, _dec, _class, _crd, Ray, ccclass, property, executeInEditMode, GameNode;

  function _reportPossibleCrUseOfTileItem(extras) {
    _reporterNs.report("TileItem", "./TileItem", _context.meta, extras);
  }

  function _reportPossibleCrUseOfMain(extras) {
    _reporterNs.report("Main", "./Main", _context.meta, extras);
  }

  function _reportPossibleCrUseOfResUtil(extras) {
    _reporterNs.report("ResUtil", "../core/utils/ResUtil", _context.meta, extras);
  }

  function _reportPossibleCrUseOfComponentEx(extras) {
    _reporterNs.report("ComponentEx", "../core/component/ComponentEx", _context.meta, extras);
  }

  function _reportPossibleCrUseOfaudioMgr(extras) {
    _reporterNs.report("audioMgr", "../core/manager/AudioManager", _context.meta, extras);
  }

  function _reportPossibleCrUseOfBusyLoadingManager(extras) {
    _reporterNs.report("BusyLoadingManager", "../core/manager/BusyLoadingManager", _context.meta, extras);
  }

  function _reportPossibleCrUseOfBUSY_TYPE(extras) {
    _reporterNs.report("BUSY_TYPE", "../core/manager/BusyLoadingManager", _context.meta, extras);
  }

  function _reportPossibleCrUseOfData(extras) {
    _reporterNs.report("Data", "../core/manager/Data", _context.meta, extras);
  }

  function _reportPossibleCrUseOfWindowManager(extras) {
    _reporterNs.report("WindowManager", "../core/manager/WindowManager", _context.meta, extras);
  }

  function _reportPossibleCrUseOfMsgHints(extras) {
    _reporterNs.report("MsgHints", "../core/utils/MsgHints", _context.meta, extras);
  }

  function _reportPossibleCrUseOfUtils(extras) {
    _reporterNs.report("Utils", "../core/utils/Utils", _context.meta, extras);
  }

  function _reportPossibleCrUseOfDrawStarLayer(extras) {
    _reporterNs.report("DrawStarLayer", "../gameui/DrawStarLayer", _context.meta, extras);
  }

  function _reportPossibleCrUseOfeventEmitter(extras) {
    _reporterNs.report("eventEmitter", "../core/event/EventEmitter", _context.meta, extras);
  }

  function _reportPossibleCrUseOfplatformSystem(extras) {
    _reporterNs.report("platformSystem", "../platform/platformSystem", _context.meta, extras);
  }

  function _reportPossibleCrUseOfGameConst(extras) {
    _reporterNs.report("GameConst", "../core/common/GameConst", _context.meta, extras);
  }

  function _reportPossibleCrUseOfITEM_TYPE(extras) {
    _reporterNs.report("ITEM_TYPE", "../core/common/GameConst", _context.meta, extras);
  }

  function _reportPossibleCrUseOflevelsData(extras) {
    _reporterNs.report("levelsData", "../user/LevelsData", _context.meta, extras);
  }

  function _reportPossibleCrUseOfPoolManager(extras) {
    _reporterNs.report("PoolManager", "../core/manager/PoolManager", _context.meta, extras);
  }

  return {
    setters: [function (_unresolved_) {
      _reporterNs = _unresolved_;
    }, function (_cc) {
      _cclegacy = _cc.cclegacy;
      __checkObsolete__ = _cc.__checkObsolete__;
      __checkObsoleteInNamespace__ = _cc.__checkObsoleteInNamespace__;
      _decorator = _cc._decorator;
      geometry = _cc.geometry;
      Camera = _cc.Camera;
      screen = _cc.screen;
      instantiate = _cc.instantiate;
      v3 = _cc.v3;
      tween = _cc.tween;
      MeshRenderer = _cc.MeshRenderer;
      Vec3 = _cc.Vec3;
      find = _cc.find;
      input = _cc.input;
      Input = _cc.Input;
      Tween = _cc.Tween;
      PhysicsSystem = _cc.PhysicsSystem;
    }, function (_unresolved_2) {
      TileItem = _unresolved_2.TileItem;
    }, function (_unresolved_3) {
      Main = _unresolved_3.Main;
    }, function (_unresolved_4) {
      ResUtil = _unresolved_4.ResUtil;
    }, function (_unresolved_5) {
      ComponentEx = _unresolved_5.ComponentEx;
    }, function (_unresolved_6) {
      audioMgr = _unresolved_6.audioMgr;
    }, function (_unresolved_7) {
      BusyLoadingManager = _unresolved_7.default;
      BUSY_TYPE = _unresolved_7.BUSY_TYPE;
    }, function (_unresolved_8) {
      Data = _unresolved_8.default;
    }, function (_unresolved_9) {
      WindowManager = _unresolved_9.default;
    }, function (_unresolved_10) {
      MsgHints = _unresolved_10.default;
    }, function (_unresolved_11) {
      Utils = _unresolved_11.default;
    }, function (_unresolved_12) {
      eventEmitter = _unresolved_12.eventEmitter;
    }, function (_unresolved_13) {
      platformSystem = _unresolved_13.default;
    }, function (_unresolved_14) {
      GameConst = _unresolved_14.GameConst;
      ITEM_TYPE = _unresolved_14.ITEM_TYPE;
    }, function (_unresolved_15) {
      levelsData = _unresolved_15.levelsData;
    }, function (_unresolved_16) {
      PoolManager = _unresolved_16.PoolManager;
    }],
    execute: function () {
      _crd = true;

      _cclegacy._RF.push({}, "a2d93SPQfJDU4bqNJGq/PnA", "GameNode", undefined);

      __checkObsolete__(['_decorator', 'Node', 'geometry', 'Camera', 'screen', 'EventTouch', 'Prefab', 'instantiate', 'v3', 'tween', 'RigidBody', 'MeshRenderer', 'Vec3', 'find', 'input', 'Input', 'Tween', 'PhysicsSystem', 'view']);

      ({
        Ray
      } = geometry);
      ({
        ccclass,
        property,
        executeInEditMode
      } = _decorator);

      _export("GameNode", GameNode = (_dec = ccclass('GameNode'), _dec(_class = class GameNode extends (_crd && ComponentEx === void 0 ? (_reportPossibleCrUseOfComponentEx({
        error: Error()
      }), ComponentEx) : ComponentEx) {
        constructor(...args) {
          super(...args);
          this.lock = false;
          this.collectpos = [];
          this.collectTiles = [];
          this.allTiles = [];
          this.optionTiles = [];
          this.touchTileItem = null;
        }

        start() {
          setTimeout(() => {
            this.initWall();
            this.collectpos = [];
            this.GetNode("collectbox").children.map(a => {
              this.collectpos.push(a.worldPosition);
              a.active = false;
            });
          }, 100);
          (_crd && eventEmitter === void 0 ? (_reportPossibleCrUseOfeventEmitter({
            error: Error()
          }), eventEmitter) : eventEmitter).register(this, (_crd && GameConst === void 0 ? (_reportPossibleCrUseOfGameConst({
            error: Error()
          }), GameConst) : GameConst).CLEAR_ALL_BOX, () => {
            console.log("清空盒子");
            this.lock = false;
            setTimeout(() => {
              for (let i = 0; i < this.collectTiles.length; ++i) {
                this.pushBask(this.collectTiles[i].name);
              }

              this.collectTiles.map(a => {
                a.destroy();
              });
              this.collectTiles = [];
            }, 500);
          }); //提示

          (_crd && eventEmitter === void 0 ? (_reportPossibleCrUseOfeventEmitter({
            error: Error()
          }), eventEmitter) : eventEmitter).register(this, (_crd && GameConst === void 0 ? (_reportPossibleCrUseOfGameConst({
            error: Error()
          }), GameConst) : GameConst).USE_ITEM_HINT, this.prompt.bind(this));
        }

        onEnable() {
          input.on(Input.EventType.TOUCH_START, this.onTouchStart, this);
          input.on(Input.EventType.TOUCH_END, this.onTouchEnd, this);
          input.on(Input.EventType.TOUCH_MOVE, this.onTouchMove, this);
        }

        onDisable() {
          input.off(Input.EventType.TOUCH_START, this.onTouchStart, this);
          input.off(Input.EventType.TOUCH_END, this.onTouchEnd, this);
          input.off(Input.EventType.TOUCH_MOVE, this.onTouchMove, this);
        }

        moveToRightPos() {
          this.collectTiles.map((a, i) => {
            let tileItem = a.getComponent(_crd && TileItem === void 0 ? (_reportPossibleCrUseOfTileItem({
              error: Error()
            }), TileItem) : TileItem);
            Tween.stopAllByTarget(a);
            tween(a).to(0.3, {
              worldPosition: this.collectpos[i].clone(),
              worldScale: v3(1, 1, 1)
            }).call(() => {
              tileItem.auto_rotation = true;

              if (tileItem.removed) {
                (_crd && Utils === void 0 ? (_reportPossibleCrUseOfUtils({
                  error: Error()
                }), Utils) : Utils).remove(this.optionTiles, a);
                tween(a).to(0.25, {
                  worldPosition: tileItem.removedPos
                }, {
                  easing: 'backIn'
                }).call(async () => {
                  //最中央的播放移除特效
                  if (tileItem.playRmovedEff) {
                    //增加星星
                    let pos = this.GetNode("Main Camera").getComponent(Camera).convertToUINode(a.worldPosition, find("Canvas"));
                    let node_ani = await (_crd && ResUtil === void 0 ? (_reportPossibleCrUseOfResUtil({
                      error: Error()
                    }), ResUtil) : ResUtil).playSkAni("spine/effect_hecheng", "effect", find("Canvas"), pos);
                    (_crd && audioMgr === void 0 ? (_reportPossibleCrUseOfaudioMgr({
                      error: Error()
                    }), audioMgr) : audioMgr).playOneShot((_crd && GameConst === void 0 ? (_reportPossibleCrUseOfGameConst({
                      error: Error()
                    }), GameConst) : GameConst).audios.starCollect);
                    (_crd && platformSystem === void 0 ? (_reportPossibleCrUseOfplatformSystem({
                      error: Error()
                    }), platformSystem) : platformSystem).platform.vibrateShort();
                    (_crd && Utils === void 0 ? (_reportPossibleCrUseOfUtils({
                      error: Error()
                    }), Utils) : Utils).flyAnim((_crd && ITEM_TYPE === void 0 ? (_reportPossibleCrUseOfITEM_TYPE({
                      error: Error()
                    }), ITEM_TYPE) : ITEM_TYPE).Star, node_ani, (_crd && Main === void 0 ? (_reportPossibleCrUseOfMain({
                      error: Error()
                    }), Main) : Main).I._GameUI.starNode, 1, 0, b => {
                      if (b) {
                        (_crd && Main === void 0 ? (_reportPossibleCrUseOfMain({
                          error: Error()
                        }), Main) : Main).I._GameUI.star++;
                      }
                    });
                  }

                  (_crd && PoolManager === void 0 ? (_reportPossibleCrUseOfPoolManager({
                    error: Error()
                  }), PoolManager) : PoolManager).putNode(a);
                  this.moveToRightPos();
                  this.checkResult();
                }).start();
              }
            }).start();
          });
        }

        chooseTile(tile) {
          if (!tile || !tile.isValid) return;
          let tileItem = tile.getComponent(_crd && TileItem === void 0 ? (_reportPossibleCrUseOfTileItem({
            error: Error()
          }), TileItem) : TileItem);
          if (!tileItem) return;
          if (tileItem.isMoving) return;
          let chooseName = tile.name;
          this.optionTiles.push(tile); // 删除点击对象从列表

          tileItem.destoryCollider();

          for (var i = 0; i < this.allTiles.length; ++i) {
            if (this.allTiles[i] == tile) {
              this.allTiles.splice(i, 1);
              break;
            }
          } // 计算目标位置


          let targetPos;
          let bInsert = false;

          for (var i = this.collectTiles.length - 1; i >= 0; --i) {
            if (this.collectTiles[i].name == chooseName) {
              var _this$collectpos;

              targetPos = ((_this$collectpos = this.collectpos[i + 1]) == null ? void 0 : _this$collectpos.clone()) || this.collectpos[this.collectpos.length - 1].clone();
              this.collectTiles.splice(i + 1, 0, tile);
              bInsert = true;
              break;
            }
          }

          if (!bInsert) {
            var _this$collectpos$this;

            targetPos = ((_this$collectpos$this = this.collectpos[this.collectTiles.length]) == null ? void 0 : _this$collectpos$this.clone()) || this.collectpos[0].clone();
            this.collectTiles.push(tile);
          } //添加上抛动画 标记物品为移动中


          tileItem.isMoving = true;
          const startPos = tile.worldPosition.clone();
          const midHeight = 10; // 上抛高度

          const duration = 0.2; // 动画时长

          this.parabolicMovementWithScale(tile, startPos, targetPos, midHeight, duration, tile.scale.clone(), v3(1, 1, 1), n => {
            this.moveToRightPos();
            tile.getComponent(_crd && TileItem === void 0 ? (_reportPossibleCrUseOfTileItem({
              error: Error()
            }), TileItem) : TileItem).isMoving = false; //动画完成后执行原有逻辑

            let tmp = this.collectTiles.filter(a => {
              return a.name == chooseName;
            });

            if (tmp.length >= 3) {
              for (var i = this.collectTiles.length - 1; i >= 0; --i) {
                if (this.collectTiles[i].name == chooseName) {
                  let delNode = this.collectTiles[i];
                  delNode.getComponent(_crd && TileItem === void 0 ? (_reportPossibleCrUseOfTileItem({
                    error: Error()
                  }), TileItem) : TileItem).removed = true;
                  this.collectTiles.splice(i, 1);
                  delNode.getComponent(_crd && TileItem === void 0 ? (_reportPossibleCrUseOfTileItem({
                    error: Error()
                  }), TileItem) : TileItem).removedPos = tmp[1].worldPosition;
                  if (delNode == tmp[1]) delNode.getComponent(_crd && TileItem === void 0 ? (_reportPossibleCrUseOfTileItem({
                    error: Error()
                  }), TileItem) : TileItem).playRmovedEff = true;
                }
              }
            }

            this.checkResult();
          });
        }

        checkResult() {
          if (this.lock) return; //检测胜利和失败

          if (this.collectTiles.length >= 7) {
            this.lock = true;
            if (!(_crd && WindowManager === void 0 ? (_reportPossibleCrUseOfWindowManager({
              error: Error()
            }), WindowManager) : WindowManager).ins.isShow("OutOfBoxLayer")) (_crd && WindowManager === void 0 ? (_reportPossibleCrUseOfWindowManager({
              error: Error()
            }), WindowManager) : WindowManager).ins.open("OutOfBoxLayer");
          } else if (this.collectTiles.length == 0 && this.allTiles.length == 0) {
            this.lock = true;
            (_crd && WindowManager === void 0 ? (_reportPossibleCrUseOfWindowManager({
              error: Error()
            }), WindowManager) : WindowManager).ins.open("DrawStarLayer").then(com => {
              com.setStar((_crd && Main === void 0 ? (_reportPossibleCrUseOfMain({
                error: Error()
              }), Main) : Main).I._GameUI.star);
            });
          }
        }

        onTouchStart(event) {
          if ((_crd && Main === void 0 ? (_reportPossibleCrUseOfMain({
            error: Error()
          }), Main) : Main).I._GameUI.pasue) return;
          if ((_crd && Data === void 0 ? (_reportPossibleCrUseOfData({
            error: Error()
          }), Data) : Data).user.useMagnet) return;
          if (this.allTiles.length == 0) return;
          if (this.collectTiles.length >= 7) return;
          const p = event.getLocation();
          let camera = this.GetNode("Main Camera").getComponent(Camera);
          const r = new Ray();
          camera == null || camera.screenPointToRay(p.x, p.y, r);
          let b = PhysicsSystem.instance.raycastClosest(r, 1);

          if (b) {
            let collider = PhysicsSystem.instance.raycastClosestResult.collider;
            if (!collider || !collider.node || !collider.node.parent) return;
            let item = collider.node.parent.getComponent(_crd && TileItem === void 0 ? (_reportPossibleCrUseOfTileItem({
              error: Error()
            }), TileItem) : TileItem);
            if (!item || !item.node || !item.node.isValid) return;
            item.enableCollider = false;
            let pos = item.node.getWorldPosition();
            pos.y += 0.3;
            item.node.setWorldPosition(pos);
            this.touchTileItem = item;
          }
        }

        onTouchEnd(event) {
          if ((_crd && Main === void 0 ? (_reportPossibleCrUseOfMain({
            error: Error()
          }), Main) : Main).I._GameUI.pasue) return;
          if ((_crd && Data === void 0 ? (_reportPossibleCrUseOfData({
            error: Error()
          }), Data) : Data).user.useMagnet) return;
          if (!this.touchTileItem) return;
          if (this.allTiles.length == 0) return;

          if (this.collectTiles.length >= 7) {
            return;
          }

          const p = event.getLocation();
          let camera = this.GetNode("Main Camera").getComponent(Camera);
          const r = new Ray();
          camera == null || camera.screenPointToRay(p.x, p.y, r);
          let b = PhysicsSystem.instance.raycastClosest(r, 1);

          if (b) {
            let collider = PhysicsSystem.instance.raycastClosestResult.collider; // if(!collider.getComponent(RigidBody))return;

            let item = collider.node.parent.getComponent(_crd && TileItem === void 0 ? (_reportPossibleCrUseOfTileItem({
              error: Error()
            }), TileItem) : TileItem);

            if (item && item == this.touchTileItem) {
              (_crd && platformSystem === void 0 ? (_reportPossibleCrUseOfplatformSystem({
                error: Error()
              }), platformSystem) : platformSystem).platform.vibrateShort();
              this.chooseTile(item.node);
              this.touchTileItem = null;
              (_crd && audioMgr === void 0 ? (_reportPossibleCrUseOfaudioMgr({
                error: Error()
              }), audioMgr) : audioMgr).playOneShot((_crd && GameConst === void 0 ? (_reportPossibleCrUseOfGameConst({
                error: Error()
              }), GameConst) : GameConst).audios.tap);
            } else {
              this.touchTileItem.enableCollider = true;
            }
          }
        }

        onTouchMove(event) {
          if ((_crd && Main === void 0 ? (_reportPossibleCrUseOfMain({
            error: Error()
          }), Main) : Main).I._GameUI.pasue) return;
          if ((_crd && Data === void 0 ? (_reportPossibleCrUseOfData({
            error: Error()
          }), Data) : Data).user.useMagnet) return;
          if (this.allTiles.length == 0) return;

          if (this.collectTiles.length >= 7) {
            return;
          }

          const p = event.getLocation();
          let camera = this.GetNode("Main Camera").getComponent(Camera);
          const r = new Ray();
          camera == null || camera.screenPointToRay(p.x, p.y, r);
          let b = PhysicsSystem.instance.raycastClosest(r, 1);

          if (b) {
            let collider = PhysicsSystem.instance.raycastClosestResult.collider; // if(!collider.getComponent(RigidBody))return;

            let item = collider.node.parent.getComponent(_crd && TileItem === void 0 ? (_reportPossibleCrUseOfTileItem({
              error: Error()
            }), TileItem) : TileItem);

            if (item) {
              if (this.touchTileItem && item == this.touchTileItem) {} else {
                if (this.touchTileItem) this.touchTileItem.enableCollider = true;
                item.enableCollider = false;
                let pos = item.node.getWorldPosition();
                pos.y += 0.3; // console.log("切换")

                item.node.setWorldPosition(pos);
                this.touchTileItem = item;
              }
            } else {
              if (this.touchTileItem) {
                // console.log("无目标")
                this.touchTileItem.enableCollider = true;
                this.touchTileItem = null;
              }
            }
          }
        }

        initWall() {
          if (!PhysicsSystem.instance) return;
          const OFFSET = 25;
          let camera = this.GetNode("Main Camera").getComponent(Camera);
          const r = new Ray();
          let size = screen.windowSize; //左边墙

          camera == null || camera.screenPointToRay(OFFSET, size.height / 2, r);

          if (PhysicsSystem.instance.raycastClosest(r)) {
            const result = PhysicsSystem.instance.raycastClosestResult;
            this.GetNode("PlaneLeft").setWorldPosition(result.hitPoint);
          } //右边墙


          camera == null || camera.screenPointToRay(size.width - OFFSET, size.height / 2, r);

          if (PhysicsSystem.instance.raycastClosest(r)) {
            const result = PhysicsSystem.instance.raycastClosestResult;
            this.GetNode("PlaneRight").setWorldPosition(result.hitPoint);
          } //上边墙


          camera == null || camera.screenPointToRay(size.width / 2, size.height - OFFSET * 4, r);

          if (PhysicsSystem.instance.raycastClosest(r)) {
            const result = PhysicsSystem.instance.raycastClosestResult;
            this.GetNode("PlaneTop").setWorldPosition(result.hitPoint);
          }

          let minx = this.GetNode("PlaneLeft").worldPosition.x;
          let maxx = this.GetNode("PlaneRight").worldPosition.x;
          let scale = (maxx - minx) / 8.461091041564941;
          this.GetNode("bottom").scale = v3(scale, scale, scale); //格子位置

          camera == null || camera.screenPointToRay(size.width / 2, 10, r);

          if (PhysicsSystem.instance.raycastClosest(r)) {
            const result = PhysicsSystem.instance.raycastClosestResult; //result.hitPoint

            let p = new Vec3(result.hitPoint.x, 4, result.hitPoint.z);
            this.GetNode("bottom").setWorldPosition(p);
          } //下边墙


          this.GetNode("PlaneDown").setWorldPosition(this.GetNode("bottom").worldPosition.add3f(0, 0, -2.5 * scale));
        }

        async createTiles() {
          let Margin = 0;
          let minx = this.GetNode("PlaneLeft").worldPosition.x + Margin;
          let maxx = this.GetNode("PlaneRight").worldPosition.x - Margin;
          let maxz = this.GetNode("PlaneDown").worldPosition.z + Margin;
          let minz = this.GetNode("PlaneTop").worldPosition.z - Margin;
          let obj = (_crd && levelsData === void 0 ? (_reportPossibleCrUseOflevelsData({
            error: Error()
          }), levelsData) : levelsData).getCurLevelInfo(); //数量

          let tileCount = Math.floor(obj.count / 3);
          let names = (_crd && levelsData === void 0 ? (_reportPossibleCrUseOflevelsData({
            error: Error()
          }), levelsData) : levelsData).getModesNames();
          let tilepools = (_crd && Utils === void 0 ? (_reportPossibleCrUseOfUtils({
            error: Error()
          }), Utils) : Utils).getRandomElements(names, obj.kind);
          tilepools = (_crd && Utils === void 0 ? (_reportPossibleCrUseOfUtils({
            error: Error()
          }), Utils) : Utils).extendArray(tilepools, tileCount);
          (_crd && Main === void 0 ? (_reportPossibleCrUseOfMain({
            error: Error()
          }), Main) : Main).I._GameUI.pasue = true;
          (_crd && BusyLoadingManager === void 0 ? (_reportPossibleCrUseOfBusyLoadingManager({
            error: Error()
          }), BusyLoadingManager) : BusyLoadingManager).ins.addBusy((_crd && BUSY_TYPE === void 0 ? (_reportPossibleCrUseOfBUSY_TYPE({
            error: Error()
          }), BUSY_TYPE) : BUSY_TYPE).RES);

          for (let i = 0; i < tileCount; i++) {
            let ret = await (_crd && ResUtil === void 0 ? (_reportPossibleCrUseOfResUtil({
              error: Error()
            }), ResUtil) : ResUtil).loadModelPrefabName(tilepools[i]);
            if (!ret) continue; //获取节点下的 MeshRenderer 组件 设置阴影投射模式

            ret.data.getComponentInChildren(MeshRenderer).shadowCastingMode = MeshRenderer.ShadowCastingMode.ON;

            for (let j = 0; j < 3; j++) {
              const globalIndex = (i * 3 + j) % 9;
              let lnode = this.GetNode(`l${globalIndex}`);
              tween(this.node).delay(j * 0.03).call(() => {
                let nomal_node = instantiate(ret);
                nomal_node.name = ret.name;
                let tile = nomal_node.addComponent(_crd && TileItem === void 0 ? (_reportPossibleCrUseOfTileItem({
                  error: Error()
                }), TileItem) : TileItem);
                let rigid = tile.addCollider();
                nomal_node.scale = v3(1.25, 1.25, 1.25);

                if ((_crd && Data === void 0 ? (_reportPossibleCrUseOfData({
                  error: Error()
                }), Data) : Data).user.lv == 1) {
                  nomal_node.setWorldPosition(lnode.getWorldPosition());
                  nomal_node.parent = this.node;
                  this.allTiles.push(nomal_node);
                } else {
                  let p = v3((_crd && Utils === void 0 ? (_reportPossibleCrUseOfUtils({
                    error: Error()
                  }), Utils) : Utils).getRandomInt(minx / 2, maxx / 2), (_crd && Utils === void 0 ? (_reportPossibleCrUseOfUtils({
                    error: Error()
                  }), Utils) : Utils).getRandom(12, 15), (_crd && Utils === void 0 ? (_reportPossibleCrUseOfUtils({
                    error: Error()
                  }), Utils) : Utils).getRandomInt(minz / 2, maxz / 2));
                  nomal_node.setWorldRotationFromEuler((_crd && Utils === void 0 ? (_reportPossibleCrUseOfUtils({
                    error: Error()
                  }), Utils) : Utils).getRandom(0, 300), (_crd && Utils === void 0 ? (_reportPossibleCrUseOfUtils({
                    error: Error()
                  }), Utils) : Utils).getRandom(0, 300), (_crd && Utils === void 0 ? (_reportPossibleCrUseOfUtils({
                    error: Error()
                  }), Utils) : Utils).getRandom(0, 300));
                  nomal_node.setWorldPosition(p);
                  nomal_node.parent = this.node;
                  rigid.applyImpulse(v3(0, 3, 0));
                  this.allTiles.push(nomal_node);
                }
              }).start();
            }

            if (i == tileCount - 1) {
              (_crd && BusyLoadingManager === void 0 ? (_reportPossibleCrUseOfBusyLoadingManager({
                error: Error()
              }), BusyLoadingManager) : BusyLoadingManager).ins.removeBusy((_crd && BUSY_TYPE === void 0 ? (_reportPossibleCrUseOfBUSY_TYPE({
                error: Error()
              }), BUSY_TYPE) : BUSY_TYPE).RES);
              (_crd && Main === void 0 ? (_reportPossibleCrUseOfMain({
                error: Error()
              }), Main) : Main).I._GameUI.pasue = false;
            }
          }

          setTimeout(() => {
            if ((_crd && Data === void 0 ? (_reportPossibleCrUseOfData({
              error: Error()
            }), Data) : Data).user.useMagnet) {
              (_crd && Main === void 0 ? (_reportPossibleCrUseOfMain({
                error: Error()
              }), Main) : Main).I._GameUI.pasue = true;
              (_crd && Data === void 0 ? (_reportPossibleCrUseOfData({
                error: Error()
              }), Data) : Data).user.magnet--;
              let p = this.GetNode("magnet").worldPosition;
              this.GetNode("magnet").worldPosition = v3(-10, p.y, p.z);
              tween(this.GetNode("magnet")).to(0.5, {
                worldPosition: v3(0, p.y, p.z)
              }).call(async () => {
                let arr = [];

                for (var i = this.allTiles.length - 1; i >= 0; --i) {
                  let pick = false;
                  let item = this.allTiles[i];
                  let tmp = arr[0];

                  if (tmp) {
                    if (tmp.name == item.name && arr.length < 3) {
                      arr.push(item);
                      pick = true;
                    }
                  } else {
                    arr.push(item);
                    pick = true;
                  }

                  if (pick) {
                    let tile = this.allTiles[i].getComponent(_crd && TileItem === void 0 ? (_reportPossibleCrUseOfTileItem({
                      error: Error()
                    }), TileItem) : TileItem);
                    tile.destoryCollider();
                    this.GetNode("magnet_content").addChild(tile.node);
                    tween(tile.node).to(0.5, {
                      worldPosition: this.GetNode(arr.length % 2 ? "m_left" : "r_left").worldPosition
                    }).start();
                    this.allTiles.splice(i, 1);
                    console.log("删除", tile.name, this.allTiles.length);
                  }
                }

                (_crd && Data === void 0 ? (_reportPossibleCrUseOfData({
                  error: Error()
                }), Data) : Data).user.useMagnet = false;
              }).delay(1.5).to(0.5, {
                worldPosition: v3(10, p.y, p.z)
              }).call(() => {
                this.GetNode("magnet_content").removeAllChildren();
                (_crd && Main === void 0 ? (_reportPossibleCrUseOfMain({
                  error: Error()
                }), Main) : Main).I._GameUI.pasue = false;
                if ((_crd && Data === void 0 ? (_reportPossibleCrUseOfData({
                  error: Error()
                }), Data) : Data).user.useTime && (_crd && Data === void 0 ? (_reportPossibleCrUseOfData({
                  error: Error()
                }), Data) : Data).user.time > 0) (_crd && eventEmitter === void 0 ? (_reportPossibleCrUseOfeventEmitter({
                  error: Error()
                }), eventEmitter) : eventEmitter).dispatch((_crd && GameConst === void 0 ? (_reportPossibleCrUseOfGameConst({
                  error: Error()
                }), GameConst) : GameConst).USE_ITEM_TIME);
              }).start();
            } else {
              if ((_crd && Data === void 0 ? (_reportPossibleCrUseOfData({
                error: Error()
              }), Data) : Data).user.useTime && (_crd && Data === void 0 ? (_reportPossibleCrUseOfData({
                error: Error()
              }), Data) : Data).user.time > 0) {
                (_crd && eventEmitter === void 0 ? (_reportPossibleCrUseOfeventEmitter({
                  error: Error()
                }), eventEmitter) : eventEmitter).dispatch((_crd && GameConst === void 0 ? (_reportPossibleCrUseOfGameConst({
                  error: Error()
                }), GameConst) : GameConst).USE_ITEM_TIME);
              }
            }
          }, 2000);
        }
        /**
         * 提示
         */


        restart() {
          this.allTiles.map(a => a.destroy());
          this.allTiles = [];
          (_crd && Main === void 0 ? (_reportPossibleCrUseOfMain({
            error: Error()
          }), Main) : Main).I._GameUI.star = 0;
          this.collectTiles.map(a => a.destroy());
          this.collectTiles = [];
          this.createTiles();
          this.lock = false;
        }
        /**移除*/


        remove() {
          if (this.optionTiles.length === 0 || this.lock) return; // 获取最后一个收集的物品

          const lastItem = this.optionTiles.pop();
          if (!lastItem) return;
          (_crd && Utils === void 0 ? (_reportPossibleCrUseOfUtils({
            error: Error()
          }), Utils) : Utils).remove(this.collectTiles, lastItem);
          const tile = lastItem.getComponent(_crd && TileItem === void 0 ? (_reportPossibleCrUseOfTileItem({
            error: Error()
          }), TileItem) : TileItem);
          tile.removed = false;
          tile.auto_rotation = false; //播放撤销动画

          Tween.stopAllByTarget(lastItem); //const globalIndex = Math.floor(Math.random() * 9);

          let lnode = this.GetNode(`l${4}`);
          let p = lnode.position.clone();
          tween(tile.node).to(0.35, {
            worldPosition: new Vec3(p.x, p.y + 1, p.z),
            worldScale: v3(1.25, 1.25, 1.25)
          }).call(() => {
            tile.addCollider();
            tile.enableCollider = true;
            this.allTiles.push(lastItem); //向上施加力 然后在向下重力效果

            tile.rigid.applyImpulse(v3(0, 3, 0));
            this.moveToRightPos(); // 重新排列收集框中的物品
          }).start();
        }
        /**乱序*/


        mess() {
          if (this.allTiles.length === 0 || this.lock) return;
          this.allTiles.forEach((item, index) => {
            const tileItem = item.getComponent(_crd && TileItem === void 0 ? (_reportPossibleCrUseOfTileItem({
              error: Error()
            }), TileItem) : TileItem);
            tileItem.auto_rotation = false;
            tileItem.enableCollider = true;
            Tween.stopAllByTarget(item);
            tween(item).to(0.3, {
              worldPosition: this.GetNode("l4").worldPosition.clone().add(v3(0, 1, 0)),
              worldScale: v3(1.25, 1.25, 1.25)
            }).call(() => {
              const rigid = tileItem.addCollider();
              rigid.applyImpulse(v3((_crd && Utils === void 0 ? (_reportPossibleCrUseOfUtils({
                error: Error()
              }), Utils) : Utils).getRandom(-3, 3), (_crd && Utils === void 0 ? (_reportPossibleCrUseOfUtils({
                error: Error()
              }), Utils) : Utils).getRandom(5, 8), (_crd && Utils === void 0 ? (_reportPossibleCrUseOfUtils({
                error: Error()
              }), Utils) : Utils).getRandom(-3, 3)));
              item.setWorldRotationFromEuler((_crd && Utils === void 0 ? (_reportPossibleCrUseOfUtils({
                error: Error()
              }), Utils) : Utils).getRandom(0, 300), (_crd && Utils === void 0 ? (_reportPossibleCrUseOfUtils({
                error: Error()
              }), Utils) : Utils).getRandom(0, 300), (_crd && Utils === void 0 ? (_reportPossibleCrUseOfUtils({
                error: Error()
              }), Utils) : Utils).getRandom(0, 300));
            }).start();
          }); //audioManager.playOneShot(GameConst.audios.shuffle);

          (_crd && platformSystem === void 0 ? (_reportPossibleCrUseOfplatformSystem({
            error: Error()
          }), platformSystem) : platformSystem).platform.vibrateShort();
        }
        /**凑齐*/


        prompt() {
          if (this.collectTiles.length <= 0 || (_crd && Data === void 0 ? (_reportPossibleCrUseOfData({
            error: Error()
          }), Data) : Data).user.hint <= 0) return;
          let obj = {};

          for (var i = 0; i < this.collectTiles.length; ++i) {
            let name = this.collectTiles[i].name;
            if (!obj[name]) obj[name] = 0;
            obj[name]++;
          }

          let hint_succ = false;
          let bFind = false;
          let hint_name = "";

          for (const key in obj) {
            if (obj[key] == 2) {
              hint_name = key;
              bFind = true;
              break;
            }
          } //找到两个一样


          if (bFind) {
            console.log("找到两个一样");

            for (let i = 0; i < this.allTiles.length; ++i) {
              if (this.allTiles[i].name == hint_name) {
                this.chooseTile(this.allTiles[i]);
                break;
              }
            }

            hint_succ = true;
          } else {
            if (this.collectTiles.length >= 5) {
              (_crd && MsgHints === void 0 ? (_reportPossibleCrUseOfMsgHints({
                error: Error()
              }), MsgHints) : MsgHints).show("未找到合适物品");
              return;
            } else {
              hint_name = this.collectTiles[0] ? this.collectTiles[0].name : this.allTiles[0].name;
              let lsit = this.allTiles.filter(a => {
                return a.name == hint_name;
              });
              lsit.map((a, i) => {
                setTimeout(() => {
                  this.chooseTile(a);
                }, 350 * i);
              });
              hint_succ = true;
            }
          }

          if (hint_succ) {
            (_crd && Data === void 0 ? (_reportPossibleCrUseOfData({
              error: Error()
            }), Data) : Data).user.hint--;
          }
        } //放回场景中


        async pushBask(name) {
          let Margin = 0;
          let maxz = this.GetNode("PlaneDown").worldPosition.z + Margin;
          let minz = this.GetNode("PlaneTop").worldPosition.z - Margin;
          let minx = this.GetNode("PlaneLeft").worldPosition.x + Margin;
          let maxx = this.GetNode("PlaneRight").worldPosition.x - Margin;
          let ret = await (_crd && ResUtil === void 0 ? (_reportPossibleCrUseOfResUtil({
            error: Error()
          }), ResUtil) : ResUtil).loadModelPrefabName(name);
          let nomal_node = instantiate(ret);
          nomal_node.name = name;
          let tile = nomal_node.addComponent(_crd && TileItem === void 0 ? (_reportPossibleCrUseOfTileItem({
            error: Error()
          }), TileItem) : TileItem);
          let rigid = tile.addCollider();
          nomal_node.scale = v3(1.25, 1.25, 1.25);
          nomal_node.parent = this.node;
          rigid.applyImpulse(v3(0, 3, 0));
          let p = v3(minx + (maxx - minx) / 2, (_crd && Utils === void 0 ? (_reportPossibleCrUseOfUtils({
            error: Error()
          }), Utils) : Utils).getRandom(12, 15), minz + (maxz - minz) / 2);
          nomal_node.setWorldRotationFromEuler((_crd && Utils === void 0 ? (_reportPossibleCrUseOfUtils({
            error: Error()
          }), Utils) : Utils).getRandom(0, 300), (_crd && Utils === void 0 ? (_reportPossibleCrUseOfUtils({
            error: Error()
          }), Utils) : Utils).getRandom(0, 300), (_crd && Utils === void 0 ? (_reportPossibleCrUseOfUtils({
            error: Error()
          }), Utils) : Utils).getRandom(0, 300));
          nomal_node.setWorldPosition(p);
          this.allTiles.push(nomal_node);
        }
        /**
         * 抛物线运动工具（带缩放动画）
         * @param node 要移动的节点
         * @param startPos 起始坐标（世界坐标）
         * @param endPos 目标坐标（世界坐标）
         * @param height 抛物线最高点高度（相对于起点）
         * @param duration 动画时长（秒）
         * @param startScale 起始缩放（默认原始大小）
         * @param endScale 目标缩放（默认原始大小）
         * @param onComplete 完成回调
         */


        parabolicMovementWithScale(node, startPos, endPos, height = 2, duration = 1.5, startScale = Vec3.ONE, endScale = Vec3.ONE, onComplete) {
          if (Vec3.equals(startPos, endPos)) {
            onComplete == null || onComplete(node);
          } else {
            //初始化节点状态
            node.setWorldPosition(startPos.clone());
            node.setScale(startScale); //计算抛物线顶点

            const midPoint = new Vec3((startPos.x + endPos.x) / 2, Math.max(startPos.y, endPos.y) + height, (startPos.z + endPos.z) / 2); //创建组合动画

            return tween(node).to(duration, {
              worldPosition: endPos,
              worldScale: endScale
            }, {
              onUpdate: (target, ratio) => {
                //1. 计算抛物线位置
                const t = ratio;
                const invT = 1 - t;
                const tempPos = new Vec3(); // XZ轴线性插值

                Vec3.lerp(tempPos, startPos, endPos, t); //Y轴抛物线计算

                const y = invT * invT * startPos.y + 2 * invT * t * midPoint.y + t * t * endPos.y; //2. 计算当前缩放比例

                const currentScale = new Vec3();
                Vec3.lerp(currentScale, startScale, endScale, t); //更新节点状态

                target.worldPosition = new Vec3(tempPos.x, y, tempPos.z);
                target.setScale(currentScale);
              }
            }).call(() => {
              // 最终确保缩放精确
              node.setScale(endScale);
              onComplete == null || onComplete(node);
            }).start();
          }
        }

      }) || _class));

      _cclegacy._RF.pop();

      _crd = false;
    }
  };
});
//# sourceMappingURL=a3d88cd0d9a54ac67cc15217a5bc04b81e525a17.js.map