idioms/idiom/temp/programming/packer-driver/targets/preview/chunks/63/635d373e206601884c96847cb1eeeefae856f2ab.js

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

  var _reporterNs, _cclegacy, __checkObsolete__, __checkObsoleteInNamespace__, _decorator, Component, director, find, Node, Vec3, Cube_Infor, Cube_State, Container_Manager, Hall, _dec, _dec2, _class, _class2, _descriptor, _crd, ccclass, property, CreateIdiom;

  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 _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 _reportPossibleCrUseOfContainer_Manager(extras) {
    _reporterNs.report("Container_Manager", "./Container_Manager", _context.meta, extras);
  }

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

  return {
    setters: [function (_unresolved_) {
      _reporterNs = _unresolved_;
    }, function (_cc) {
      _cclegacy = _cc.cclegacy;
      __checkObsolete__ = _cc.__checkObsolete__;
      __checkObsoleteInNamespace__ = _cc.__checkObsoleteInNamespace__;
      _decorator = _cc._decorator;
      Component = _cc.Component;
      director = _cc.director;
      find = _cc.find;
      Node = _cc.Node;
      Vec3 = _cc.Vec3;
    }, function (_unresolved_2) {
      Cube_Infor = _unresolved_2.Cube_Infor;
      Cube_State = _unresolved_2.Cube_State;
    }, function (_unresolved_3) {
      Container_Manager = _unresolved_3.Container_Manager;
    }, function (_unresolved_4) {
      Hall = _unresolved_4.Hall;
    }],
    execute: function () {
      _crd = true;

      _cclegacy._RF.push({}, "3b901oU5ZJHnp8TtJiYjZWZ", "CreateIdiom", undefined);

      __checkObsolete__(['_decorator', 'Component', 'debug', 'director', 'find', 'instantiate', 'Layers', 'Node', 'NodePool', 'Prefab', 'tween', 'Vec3']);

      ({
        ccclass,
        property
      } = _decorator);

      _export("CreateIdiom", CreateIdiom = (_dec = ccclass('CreateIdiom'), _dec2 = property([Node]), _dec(_class = (_class2 = class CreateIdiom extends Component {
        constructor() {
          super(...arguments);
          this.Container = void 0;
          this.animationRunning = false;

          // 控制是否有动画正在运行
          _initializerDefineProperty(this, "startPos", _descriptor, this);
        }

        onLoad() {
          this.Container = find('Container').getComponent(_crd && Container_Manager === void 0 ? (_reportPossibleCrUseOfContainer_Manager({
            error: Error()
          }), Container_Manager) : Container_Manager);
        }

        update(deltaTime) {}

        nodeMoving() {
          if ((_crd && Hall === void 0 ? (_reportPossibleCrUseOfHall({
            error: Error()
          }), Hall) : Hall).getInstance().player.get_max_floor() !== 0) {
            this.node.setPosition(new Vec3(0, 1.6, -0.5));
            var startPos = this.node.position; // 起点，抛物线开始的坐标

            var middlePos = new Vec3(this.node.position.x, this.node.position.y + 1, -0.5); // 中间控制点

            var destPos = new Vec3(this.node.position.x, this.node.position.y + 2, -0.5); // 终点，抛物线上升顶点

            var lastGeneratedPosition = null; // 记录上一次生成方块的位置
            // 保持原来贝塞尔曲线和螺旋效果的计算

            var twoBezier = (t, p1, cp, p2) => {
              var x = (1 - t) * (1 - t) * p1.x + 2 * t * (1 - t) * cp.x + t * t * p2.x;
              var y = (1 - t) * (1 - t) * p1.y + 2 * t * (1 - t) * cp.y + t * t * p2.y;
              var z = (1 - t) * (1 - t) * p1.z + 2 * t * (1 - t) * cp.z + t * t * p2.z;
              var angle = t * Math.PI * 10; // 缓动的半径计算方法，调整第一圈半径的变化速度

              var radius = 1.2 - Math.pow(t, 2); // 使用平方函数，t小的时候变化较大，t大时变化变缓

              var xOffset = Math.cos(angle) * radius;
              var zOffset = Math.sin(angle) * radius;
              return new Vec3(x + xOffset, y, z + zOffset);
            };

            var createdNodes = 0; // 已生成的节点计数

            var animationStopped = false; // 控制动画是否已经停止

            var t = 0; // 进度 t，0 为起点，1 为终点

            var updatePosition = () => {
              if (animationStopped) return;
              this.node.position = twoBezier(t, startPos, middlePos, destPos);
              var cube = this.Container.getCube();

              if (cube != null && cube.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) {
                var newNode = cube;
                newNode.parent = director.getScene(); // 随机左右偏移量，范围设定为 [-0.5, 0.5]

                var randomXOffset = Math.random() * 1 - 0.5; // 生成一个[-0.5, 0.5]之间的随机值

                newNode.setPosition(this.node.position.x + randomXOffset, this.node.position.y, this.node.position.z);
                this.Container.nodeReferences.push(newNode);
                lastGeneratedPosition = this.node.position.clone(); // 更新上次生成位置

                console.log(cube.getComponent(_crd && Cube_Infor === void 0 ? (_reportPossibleCrUseOfCube_Infor({
                  error: Error()
                }), Cube_Infor) : Cube_Infor).Text);
                createdNodes++;
              }

              var totalCubes = 60; // 设置生成方块的间隔，可以调整生成速度

              var interval = 0.01; // 控制生成间隔的速率，可以根据需要调整

              if (createdNodes >= totalCubes) {
                animationStopped = true;
                this.Container.canTouch = true;
                console.log("所有方块已拿完或没有方块了，停止动画");
              } // 这里控制 t 增加的速率


              t += interval;

              if (!animationStopped) {
                requestAnimationFrame(updatePosition);
              }
            };

            updatePosition();
          } else {
            for (var i = 0; i < this.Container.idioms.length * 2; i++) {
              var cube = this.Container.getCube();

              if (cube != null && cube.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) {
                var newNode = cube;
                newNode.parent = director.getScene(); // 随机左右偏移量，范围设定为 [-0.5, 0.5]

                var randomXOffset = Math.random() * 1 - 0.5; // 生成一个[-0.5, 0.5]之间的随机值

                newNode.setPosition(this.startPos[i].position.x, this.startPos[i].position.y, this.startPos[i].position.z);
                this.Container.nodeReferences.push(newNode);

                if (i > 1) {
                  newNode.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;
                }
              }
            }

            this.Container.canTouch = true;
          }
        }

      }, (_descriptor = _applyDecoratedDescriptor(_class2.prototype, "startPos", [_dec2], {
        configurable: true,
        enumerable: true,
        writable: true,
        initializer: function initializer() {
          return [];
        }
      })), _class2)) || _class));

      _cclegacy._RF.pop();

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