idioms/idiom/temp/programming/packer-driver/targets/preview/chunks/67/67f356369ce567fe1898b7ae72038ee83758a446.js

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

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

  function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }

  function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }

  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);
  }

  function _reportPossibleCrUseOfHall(extras) {
    _reporterNs.report("Hall", "../hall/Hall", _context.meta, extras);
  }

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

  function _reportPossibleCrUseOfUI_Lock(extras) {
    _reporterNs.report("UI_Lock", "../ui/UI_Lock/UI_Lock", _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;
      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;
    }, function (_unresolved_7) {
      Hall = _unresolved_7.Hall;
    }, function (_unresolved_8) {
      UI_LatticeFull = _unresolved_8.UI_LatticeFull;
    }, function (_unresolved_9) {
      UI_Lock = _unresolved_9.UI_Lock;
    }],
    execute: function () {
      _crd = true;

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

      __checkObsolete__(['_decorator', 'BoxCollider', 'Camera', 'Component', 'director', 'EventTouch', 'find', 'Game', 'geometry', 'Layers', 'Layout', '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() {
          super(...arguments);

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

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

          this.Container = void 0;
        }

        onLoad() {
          GameCtl.instance = this;
          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.Container.canTouch) {
            this.shootRay(event);
          }
        } //发射射线检测判断物体是否可消除


        shootRay(event) {
          if (!this.camera) return;
          var ray = new geometry.Ray();
          this.camera.screenPointToRay(event.getLocationX(), event.getLocationY(), ray);

          if (PhysicsSystem.instance.raycastClosest(ray)) {
            var _collider$node$getCom;

            var raycastClosestResult = PhysicsSystem.instance.raycastClosestResult;
            var collider = raycastClosestResult.collider;
            console.log(collider.node.name); //当前其余点击无效

            if (((_collider$node$getCom = collider.node.getComponent(_crd && Cube_Infor === void 0 ? (_reportPossibleCrUseOfCube_Infor({
              error: Error()
            }), Cube_Infor) : Cube_Infor)) == null ? void 0 : _collider$node$getCom.state) === (_crd && Cube_State === void 0 ? (_reportPossibleCrUseOfCube_State({
              error: Error()
            }), Cube_State) : Cube_State).live) {
              // if(gui.get(UI_Main).getLayout<Layout_Main>().Hand.active==true)
              // {
              //     gui.get(UI_Main).getLayout<Layout_Main>().Hand.active=false;
              // }
              this.entryContainer(collider.node);
            } else if (collider.node.name == 'Lock') {
              //解锁槽子
              this.UnLock(collider.node);
            }
          }

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

        entryContainer(node) {
          // 判断容器剩余容量
          var startIndex = -1;
          var targetPos = new Vec3();
          var 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 (var i = 0; i < this.Container.unlock_Num; 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 (var _i = 0; _i < this.Container.unlock_Num - 1; _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 进行后续操作，例如：

                  var pos1 = this.Container.nodes[startIndex].getWorldPosition();
                  var 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 (var _i2 = 0; _i2 < this.Container.unlock_Num - 2; _i2++) {
                  if (this.Container.node_isIdiom[_i2] === false && this.Container.node_isIdiom[_i2 + 1] === false && this.Container.node_isIdiom[_i2 + 2] === false) {
                    startIndex = _i2; // 找到连续的三个 false，记录起始位置

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

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

                  var _pos = this.Container.nodes[startIndex].getWorldPosition();

                  var _pos2 = this.Container.nodes[startIndex + 1].getWorldPosition();

                  var 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((_pos.x + _pos2.x + pos3.x) / 3, (_pos.y + _pos2.y + pos3.y) / 3, (_pos.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; // 禁用重力

            var targetRotation = new Quat();
            Quat.fromEuler(targetRotation, -90, 0, 0);
            this.Container.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); // 执行判断成语合成逻辑

              var matchedCubes = [];
              var 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)); //判断槽子满了吗

                var count = 0;

                for (var element of this.Container.node_isIdiom) {
                  if (element == true) {
                    count++;
                  }
                }

                if (count == this.Container.unlock_Num) {
                  (_crd && gui === void 0 ? (_reportPossibleCrUseOfgui({
                    error: Error()
                  }), gui) : gui).show(_crd && UI_LatticeFull === void 0 ? (_reportPossibleCrUseOfUI_LatticeFull({
                    error: Error()
                  }), UI_LatticeFull) : UI_LatticeFull);
                } else if (count >= this.Container.unlock_Num - 2 && this.Container.unlock_Num != 9) {
                  if (!this.Container.is_Show_UI_Lock) {
                    (_crd && gui === void 0 ? (_reportPossibleCrUseOfgui({
                      error: Error()
                    }), gui) : gui).show(_crd && UI_Lock === void 0 ? (_reportPossibleCrUseOfUI_Lock({
                      error: Error()
                    }), UI_Lock) : UI_Lock);
                    this.Container.is_Show_UI_Lock = true;
                  }
                }

                this.Container.canTouch = true;
              }
            }).start();
          }
        } //合成动画


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

          for (var 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 (var _i3 = this.Container.idiom_combine.get(cube2); _i3 < this.Container.idiom_combine.get(cube2) + cube2.Text.length; _i3++) {
            this.Container.node_isIdiom[_i3] = 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 动画

          var 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 动画

          var 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
          .call(() => {
            (_crd && Hall === void 0 ? (_reportPossibleCrUseOfHall({
              error: Error()
            }), Hall) : Hall).getInstance().player.set_combine_num(1);
          }).start();
        }

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

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

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

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

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

            var targetPos = new Vec3();

            switch (txtLength) {
              case 1:
                {
                  // 找到一个空位
                  for (var i = 0; i < container.unlock_Num; 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 (var _i4 = 0; _i4 < container.unlock_Num - 1; _i4++) {
                    if (!newNodeIsIdiom[_i4] && !newNodeIsIdiom[_i4 + 1]) {
                      targetIndex = _i4;
                      break;
                    }
                  }

                  if (targetIndex !== -1) {
                    var pos1 = container.nodes[targetIndex].getWorldPosition();
                    var 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 (var _i5 = 0; _i5 < container.unlock_Num - 2; _i5++) {
                    if (!newNodeIsIdiom[_i5] && !newNodeIsIdiom[_i5 + 1] && !newNodeIsIdiom[_i5 + 2]) {
                      targetIndex = _i5;
                      break;
                    }
                  }

                  if (targetIndex !== -1) {
                    var _pos3 = container.nodes[targetIndex].getWorldPosition();

                    var _pos4 = container.nodes[targetIndex + 1].getWorldPosition();

                    var pos3 = container.nodes[targetIndex + 2].getWorldPosition();
                    targetPos.set((_pos3.x + _pos4.x + pos3.x) / 3, (_pos3.y + _pos4.y + pos3.y) / 3, (_pos3.z + _pos4.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()]);
        }

        UnLock(node) {
          var _this = this;

          return _asyncToGenerator(function* () {
            var res = yield chsdk.playRewardAd('解锁槽位');

            if (res) {
              node.active = false;
              _this.Container.unlock_Num += 1;
            }
          })();
        }

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

      _cclegacy._RF.pop();

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