System.register(["__unresolved_0", "cc", "__unresolved_1", "__unresolved_2", "__unresolved_3", "__unresolved_4", "__unresolved_5"], function (_export, _context) {
  "use strict";

  var _reporterNs, _cclegacy, __checkObsolete__, __checkObsoleteInNamespace__, _decorator, Camera, Component, find, geometry, Layers, Node, PhysicsSystem, Quat, RigidBody, tween, Vec3, gui, UI_Idioms, UI_Main, Container_Manager, Cube_Infor, Cube_State, _dec, _dec2, _dec3, _class, _class2, _descriptor, _descriptor2, _class3, _crd, ccclass, property, GameCtl;

  function _initializerDefineProperty(target, property, descriptor, context) { if (!descriptor) return; Object.defineProperty(target, property, { enumerable: descriptor.enumerable, configurable: descriptor.configurable, writable: descriptor.writable, value: descriptor.initializer ? descriptor.initializer.call(context) : void 0 }); }

  function _applyDecoratedDescriptor(target, property, decorators, descriptor, context) { var desc = {}; Object.keys(descriptor).forEach(function (key) { desc[key] = descriptor[key]; }); desc.enumerable = !!desc.enumerable; desc.configurable = !!desc.configurable; if ('value' in desc || desc.initializer) { desc.writable = true; } desc = decorators.slice().reverse().reduce(function (desc, decorator) { return decorator(target, property, desc) || desc; }, desc); if (context && desc.initializer !== void 0) { desc.value = desc.initializer ? desc.initializer.call(context) : void 0; desc.initializer = undefined; } if (desc.initializer === void 0) { Object.defineProperty(target, property, desc); desc = null; } return desc; }

  function _initializerWarningHelper(descriptor, context) { throw new Error('Decorating class property failed. Please ensure that ' + 'transform-class-properties is enabled and runs after the decorators transform.'); }

  function _reportPossibleCrUseOfgui(extras) {
    _reporterNs.report("gui", "../../core/ui/ui", _context.meta, extras);
  }

  function _reportPossibleCrUseOfUI_Idioms(extras) {
    _reporterNs.report("UI_Idioms", "../ui/UI_Idioms/UI_Idioms", _context.meta, extras);
  }

  function _reportPossibleCrUseOfUI_Main(extras) {
    _reporterNs.report("UI_Main", "../ui/UI_Main/UI_Main", _context.meta, extras);
  }

  function _reportPossibleCrUseOfContainer_Manager(extras) {
    _reporterNs.report("Container_Manager", "./Container_Manager", _context.meta, extras);
  }

  function _reportPossibleCrUseOfCube_Infor(extras) {
    _reporterNs.report("Cube_Infor", "./Cube_Infor", _context.meta, extras);
  }

  function _reportPossibleCrUseOfCube_State(extras) {
    _reporterNs.report("Cube_State", "./Cube_Infor", _context.meta, extras);
  }

  return {
    setters: [function (_unresolved_) {
      _reporterNs = _unresolved_;
    }, function (_cc) {
      _cclegacy = _cc.cclegacy;
      __checkObsolete__ = _cc.__checkObsolete__;
      __checkObsoleteInNamespace__ = _cc.__checkObsoleteInNamespace__;
      _decorator = _cc._decorator;
      Camera = _cc.Camera;
      Component = _cc.Component;
      find = _cc.find;
      geometry = _cc.geometry;
      Layers = _cc.Layers;
      Node = _cc.Node;
      PhysicsSystem = _cc.PhysicsSystem;
      Quat = _cc.Quat;
      RigidBody = _cc.RigidBody;
      tween = _cc.tween;
      Vec3 = _cc.Vec3;
    }, function (_unresolved_2) {
      gui = _unresolved_2.gui;
    }, function (_unresolved_3) {
      UI_Idioms = _unresolved_3.UI_Idioms;
    }, function (_unresolved_4) {
      UI_Main = _unresolved_4.UI_Main;
    }, function (_unresolved_5) {
      Container_Manager = _unresolved_5.Container_Manager;
    }, function (_unresolved_6) {
      Cube_Infor = _unresolved_6.Cube_Infor;
      Cube_State = _unresolved_6.Cube_State;
    }],
    execute: function () {
      _crd = true;

      _cclegacy._RF.push({}, "5237f+4/ftIlKW+rC062l8C", "GameCtl", undefined);

      __checkObsolete__(['_decorator', 'BoxCollider', 'Camera', 'Component', 'director', 'EventTouch', 'find', 'Game', 'geometry', 'Layers', 'Node', 'PhysicsSystem', 'Quat', 'RigidBody', 'Size', 'tween', 'UITransform', 'v3', 'Vec3']);

      ({
        ccclass,
        property
      } = _decorator);

      _export("GameCtl", GameCtl = (_dec = ccclass('GameCtl'), _dec2 = property(Camera), _dec3 = property([Node]), _dec(_class = (_class2 = (_class3 = class GameCtl extends Component {
        constructor(...args) {
          super(...args);

          _initializerDefineProperty(this, "camera", _descriptor, this);

          _initializerDefineProperty(this, "Ani", _descriptor2, this);

          this.canTouch = true;
          this.Container = void 0;
        }

        onLoad() {
          GameCtl.instance = this;
          console.log(find('Ani'));
          console.log('Camera value in onLoad:', this.camera);
          this.node.on(Node.EventType.TOUCH_START, this.onTouchStart, this);
          this.node.on(Node.EventType.TOUCH_MOVE, this.onTouchMove, this);
          this.node.on(Node.EventType.TOUCH_END, this.onTouchEnd, this);
          this.Container = find('Container').getComponent(_crd && Container_Manager === void 0 ? (_reportPossibleCrUseOfContainer_Manager({
            error: Error()
          }), Container_Manager) : Container_Manager);
        }

        update(deltaTime) {}

        onTouchStart(event) {}

        onTouchMove(event) {}

        onTouchEnd(event) {
          if (this.canTouch) {
            this.shootRay(event);
          }
        } //发射射线检测判断物体是否可消除


        shootRay(event) {
          if (!this.camera) return;
          let ray = new geometry.Ray();
          this.camera.screenPointToRay(event.getLocationX(), event.getLocationY(), ray);
          const index = Layers.nameToLayer('Cube');
          const cubeMask = 2 << index;
          const maxDistance = 100000;
          const queryTrigger = false;

          if (PhysicsSystem.instance.raycastClosest(ray, cubeMask, maxDistance, queryTrigger)) {
            const raycastClosestResult = PhysicsSystem.instance.raycastClosestResult;
            const hitPoint = raycastClosestResult.hitPoint;
            const hitNormal = raycastClosestResult.hitNormal;
            const collider = raycastClosestResult.collider;
            const distance = raycastClosestResult.distance;
            console.log(collider.node.name); //当前其余点击无效

            if (collider.node.getComponent(_crd && Cube_Infor === void 0 ? (_reportPossibleCrUseOfCube_Infor({
              error: Error()
            }), Cube_Infor) : Cube_Infor).state === (_crd && Cube_State === void 0 ? (_reportPossibleCrUseOfCube_State({
              error: Error()
            }), Cube_State) : Cube_State).live) {
              this.entryContainer(collider.node);
            }
          }

          console.log('发射了射线');
        }

        entryContainer(node) {
          // 判断容器剩余容量
          let startIndex = -1;
          let targetPos = new Vec3();
          let txt_length = node.getComponent(_crd && Cube_Infor === void 0 ? (_reportPossibleCrUseOfCube_Infor({
            error: Error()
          }), Cube_Infor) : Cube_Infor).Text.length;
          console.log(txt_length); // 判断字长 并 判断是否还有空间可放置

          switch (txt_length) {
            case 1:
              for (let i = 0; i < this.Container.node_isIdiom.length; i++) {
                if (this.Container.node_isIdiom[i] === false) {
                  startIndex = i; // 找到连续的三个 false，记录起始位置

                  break; // 找到第一个符合条件的位置后停止
                }
              }

              if (startIndex !== -1) {
                // 如果找到了一个值为 false 的元素
                targetPos = this.Container.nodes[startIndex].getWorldPosition().clone();
                this.Container.node_isIdiom[startIndex] = true;
                console.log(targetPos);
              } else {
                console.log("没有空间了");
              }

              break;

            case 2:
              {
                for (let i = 0; i < this.Container.node_isIdiom.length - 2; i++) {
                  if (this.Container.node_isIdiom[i] === false && this.Container.node_isIdiom[i + 1] === false) {
                    startIndex = i; // 找到连续的两个 false，记录起始位置

                    break; // 找到第一个符合条件的位置后停止
                  }
                }

                if (startIndex !== -1) {
                  console.log("找到连续的两个 false，起始索引是：", startIndex); // 可以在此使用 startIndex 进行后续操作，例如：

                  let pos1 = this.Container.nodes[startIndex].getWorldPosition();
                  let pos2 = this.Container.nodes[startIndex + 1].getWorldPosition();
                  this.Container.node_isIdiom[startIndex] = true;
                  this.Container.node_isIdiom[startIndex + 1] = true;
                  targetPos.set((pos1.x + pos2.x) / 2, (pos1.y + pos2.y) / 2, (pos1.z + pos2.z) / 2);
                  console.log(targetPos);
                }

                break;
              }

            case 3:
              {
                for (let i = 0; i < this.Container.node_isIdiom.length - 2; i++) {
                  if (this.Container.node_isIdiom[i] === false && this.Container.node_isIdiom[i + 1] === false && this.Container.node_isIdiom[i + 2] === false) {
                    startIndex = i; // 找到连续的三个 false，记录起始位置

                    break; // 找到第一个符合条件的位置后停止
                  }
                }

                if (startIndex !== -1) {
                  // 找到连续三个 false，startIndex 即为最前面的索引
                  console.log("找到连续的三个 false，起始索引是：", startIndex); // 可以在此使用 startIndex 进行后续操作，例如：

                  let pos1 = this.Container.nodes[startIndex].getWorldPosition();
                  let pos2 = this.Container.nodes[startIndex + 1].getWorldPosition();
                  let pos3 = this.Container.nodes[startIndex + 2].getWorldPosition();
                  this.Container.node_isIdiom[startIndex] = true;
                  this.Container.node_isIdiom[startIndex + 1] = true;
                  this.Container.node_isIdiom[startIndex + 2] = true;
                  targetPos.set((pos1.x + pos2.x + pos3.x) / 3, (pos1.y + pos2.y + pos3.y) / 3, (pos1.z + pos2.z + pos3.z) / 3);
                  console.log(targetPos);
                } else {
                  console.log("没有找到连续的三个 false");
                }

                break;
              }

            default:
              return;
          }

          if (startIndex !== -1) {
            // node.getComponent(Cube_Infor).lock = true;
            node.getComponent(_crd && Cube_Infor === void 0 ? (_reportPossibleCrUseOfCube_Infor({
              error: Error()
            }), Cube_Infor) : Cube_Infor).state = (_crd && Cube_State === void 0 ? (_reportPossibleCrUseOfCube_State({
              error: Error()
            }), Cube_State) : Cube_State).wait;
            node.getComponent(_crd && Cube_Infor === void 0 ? (_reportPossibleCrUseOfCube_Infor({
              error: Error()
            }), Cube_Infor) : Cube_Infor).rigidbody.type = RigidBody.Type.STATIC; // 禁用重力

            let targetRotation = new Quat();
            Quat.fromEuler(targetRotation, -90, 0, 0);
            this.canTouch = false;
            tween(node).to(0.5, {
              position: new Vec3(targetPos.x, targetPos.y, targetPos.z + 0.4),
              rotation: targetRotation
            }).call(() => {
              this.Container.idiom_combine.set(node.getComponent(_crd && Cube_Infor === void 0 ? (_reportPossibleCrUseOfCube_Infor({
                error: Error()
              }), Cube_Infor) : Cube_Infor), startIndex); // 执行判断成语合成逻辑

              let matchedCubes = [];
              let flag = this.Container.checkIdiom_Combine(node.getComponent(_crd && Cube_Infor === void 0 ? (_reportPossibleCrUseOfCube_Infor({
                error: Error()
              }), Cube_Infor) : Cube_Infor), matchedCubes);

              if (flag) {
                // 执行合成动画
                console.log("匹配的成语方块：", matchedCubes);
                this.combine_ani(matchedCubes[0], matchedCubes[1]);
              } else {
                //高亮
                (_crd && gui === void 0 ? (_reportPossibleCrUseOfgui({
                  error: Error()
                }), gui) : gui).get(_crd && UI_Idioms === void 0 ? (_reportPossibleCrUseOfUI_Idioms({
                  error: Error()
                }), UI_Idioms) : UI_Idioms).light_Show(node.getComponent(_crd && Cube_Infor === void 0 ? (_reportPossibleCrUseOfCube_Infor({
                  error: Error()
                }), Cube_Infor) : Cube_Infor));
                this.canTouch = true;
              }
            }).start();
          }
        } //合成动画


        combine_ani(cube1, cube2) {
          this.canTouch = true;

          for (let i = this.Container.idiom_combine.get(cube1); i < this.Container.idiom_combine.get(cube1) + cube1.Text.length; i++) {
            this.Container.node_isIdiom[i] = false;
          }

          this.Container.idiom_combine.delete(cube1);

          for (let i = this.Container.idiom_combine.get(cube2); i < this.Container.idiom_combine.get(cube2) + cube2.Text.length; i++) {
            this.Container.node_isIdiom[i] = false;
          }

          this.Container.idiom_combine.delete(cube2); // 取消相关字的高亮显示

          (_crd && gui === void 0 ? (_reportPossibleCrUseOfgui({
            error: Error()
          }), gui) : gui).get(_crd && UI_Idioms === void 0 ? (_reportPossibleCrUseOfUI_Idioms({
            error: Error()
          }), UI_Idioms) : UI_Idioms).light_Hide(cube1, cube2);
          (_crd && gui === void 0 ? (_reportPossibleCrUseOfgui({
            error: Error()
          }), gui) : gui).get(_crd && UI_Main === void 0 ? (_reportPossibleCrUseOfUI_Main({
            error: Error()
          }), UI_Main) : UI_Main).evt.emit((_crd && gui === void 0 ? (_reportPossibleCrUseOfgui({
            error: Error()
          }), gui) : gui).get(_crd && UI_Main === void 0 ? (_reportPossibleCrUseOfUI_Main({
            error: Error()
          }), UI_Main) : UI_Main).evt.key.update_remain);
          this.adjustContainer(); // 检测容器中哪些字需要高亮显示

          console.log(this.Container.node_isIdiom); // 在所有动画结束后执行

          this.Container.idioms = this.Container.idioms.filter(c => c.idiom !== cube1.Text + cube2.Text); // 创建第一个 tween 动画

          const tween1 = tween(cube1.node).to(0.1, {
            position: new Vec3(this.Ani[0].position.x, this.Ani[0].position.y, this.Ani[0].position.z + 0.4)
          }).call(() => {
            setTimeout(() => {
              cube1.state = (_crd && Cube_State === void 0 ? (_reportPossibleCrUseOfCube_State({
                error: Error()
              }), Cube_State) : Cube_State).dead;
              this.Container.recycleCube(cube1.node);
            }, 500.0);
          }); // 创建第二个 tween 动画

          const tween2 = tween(cube2.node).to(0.1, {
            position: new Vec3(this.Ani[1].position.x, this.Ani[1].position.y, this.Ani[1].position.z + 0.4)
          }).call(() => {
            setTimeout(() => {
              cube2.state = (_crd && Cube_State === void 0 ? (_reportPossibleCrUseOfCube_State({
                error: Error()
              }), Cube_State) : Cube_State).dead;
              this.Container.recycleCube(cube2.node);
            }, 500.0);
          }); // 使用 tween 的并行组合功能

          tween(cube1.node).parallel(tween1, tween2) // 并行执行 tween1 和 tween2
          .start();
        }

        adjustContainer() {
          const container = this.Container; // 新的 node_isIdiom 状态数组

          const newNodeIsIdiom = Array(container.node_isIdiom.length).fill(false); // 新的 idiom_combine 映射表

          const newIdiomCombine = new Map(); // 遍历 idiom_combine，重新计算位置

          for (const [cube, startIndex] of container.idiom_combine.entries()) {
            const txtLength = cube.Text.length; // 获取字长

            let targetIndex = -1; // 目标位置起始索引

            let targetPos = new Vec3();

            switch (txtLength) {
              case 1:
                {
                  // 找到一个空位
                  for (let i = 0; i < container.node_isIdiom.length; i++) {
                    if (!newNodeIsIdiom[i]) {
                      targetIndex = i;
                      break;
                    }
                  }

                  if (targetIndex !== -1) {
                    targetPos = container.nodes[targetIndex].getWorldPosition().clone();
                    newNodeIsIdiom[targetIndex] = true; // 占用位置
                  } else {
                    console.log("没有空位容纳单字 Cube_Infor");
                  }

                  break;
                }

              case 2:
                {
                  // 找到连续两个空位
                  for (let i = 0; i < container.node_isIdiom.length - 1; i++) {
                    if (!newNodeIsIdiom[i] && !newNodeIsIdiom[i + 1]) {
                      targetIndex = i;
                      break;
                    }
                  }

                  if (targetIndex !== -1) {
                    const pos1 = container.nodes[targetIndex].getWorldPosition();
                    const pos2 = container.nodes[targetIndex + 1].getWorldPosition();
                    targetPos.set((pos1.x + pos2.x) / 2, (pos1.y + pos2.y) / 2, (pos1.z + pos2.z) / 2);
                    newNodeIsIdiom[targetIndex] = true;
                    newNodeIsIdiom[targetIndex + 1] = true;
                  } else {
                    console.log("没有连续两个空位容纳双字 Cube_Infor");
                  }

                  break;
                }

              case 3:
                {
                  // 找到连续三个空位
                  for (let i = 0; i < container.node_isIdiom.length - 2; i++) {
                    if (!newNodeIsIdiom[i] && !newNodeIsIdiom[i + 1] && !newNodeIsIdiom[i + 2]) {
                      targetIndex = i;
                      break;
                    }
                  }

                  if (targetIndex !== -1) {
                    const pos1 = container.nodes[targetIndex].getWorldPosition();
                    const pos2 = container.nodes[targetIndex + 1].getWorldPosition();
                    const pos3 = container.nodes[targetIndex + 2].getWorldPosition();
                    targetPos.set((pos1.x + pos2.x + pos3.x) / 3, (pos1.y + pos2.y + pos3.y) / 3, (pos1.z + pos2.z + pos3.z) / 3);
                    newNodeIsIdiom[targetIndex] = true;
                    newNodeIsIdiom[targetIndex + 1] = true;
                    newNodeIsIdiom[targetIndex + 2] = true;
                  } else {
                    console.log("没有连续三个空位容纳三字 Cube_Infor");
                  }

                  break;
                }

              default:
                return;
            } // 移动 Cube_Infor 到目标位置


            if (targetIndex !== -1) {
              tween(cube.node).to(0.3, {
                position: new Vec3(targetPos.x, targetPos.y, targetPos.z + 0.4)
              }).start();
              newIdiomCombine.set(cube, targetIndex); // 更新新映射
            }
          } // 更新 container 状态


          container.node_isIdiom = newNodeIsIdiom;
          container.idiom_combine = newIdiomCombine;
          console.log("调整后的容器状态：", container.node_isIdiom);
          console.log("更新后的 idiom_combine：", [...container.idiom_combine.entries()]);
        }

      }, _class3.instance = null, _class3), (_descriptor = _applyDecoratedDescriptor(_class2.prototype, "camera", [_dec2], {
        configurable: true,
        enumerable: true,
        writable: true,
        initializer: function () {
          return null;
        }
      }), _descriptor2 = _applyDecoratedDescriptor(_class2.prototype, "Ani", [_dec3], {
        configurable: true,
        enumerable: true,
        writable: true,
        initializer: function () {
          return [];
        }
      })), _class2)) || _class));

      _cclegacy._RF.pop();

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