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

  var _reporterNs, _cclegacy, __checkObsolete__, __checkObsoleteInNamespace__, _decorator, Component, director, error, instantiate, Node, UITransform, Widget, assetManager, tween, v3, UIOpacity, Vec3, Tween, ui_base, ResolutionAutoFit, ui, _dec, _class, _crd, ccclass, property, ui_updater, GameUILayers, gui;

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

  function _reportPossibleCrUseOfResolutionAutoFit(extras) {
    _reporterNs.report("ResolutionAutoFit", "./ui_ResolutionAutoFit", _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;
      error = _cc.error;
      instantiate = _cc.instantiate;
      Node = _cc.Node;
      UITransform = _cc.UITransform;
      Widget = _cc.Widget;
      assetManager = _cc.assetManager;
      tween = _cc.tween;
      v3 = _cc.v3;
      UIOpacity = _cc.UIOpacity;
      Vec3 = _cc.Vec3;
      Tween = _cc.Tween;
    }, function (_unresolved_2) {
      ui_base = _unresolved_2.default;
    }, function (_unresolved_3) {
      ResolutionAutoFit = _unresolved_3.ResolutionAutoFit;
    }],
    execute: function () {
      _crd = true;

      _cclegacy._RF.push({}, "81e48wxjGBMPp2rQOJDljTG", "ui", undefined);

      __checkObsolete__(['_decorator', 'Component', 'director', 'error', 'instantiate', 'Node', 'Prefab', 'UITransform', 'Widget', 'assetManager', 'AssetManager', 'tween', 'v3', 'UIOpacity', 'Vec3', 'ProgressBar', 'Sprite', 'Tween']);

      ({
        ccclass,
        property
      } = _decorator);
      ui_updater = (_dec = ccclass('ui_updater'), _dec(_class = class ui_updater extends Component {
        update(dt) {
          (_crd && ui_base === void 0 ? (_reportPossibleCrUseOfui_base({
            error: Error()
          }), ui_base) : ui_base).updateAll(dt);
        }

      }) || _class);

      _export("GameUILayers", GameUILayers = /*#__PURE__*/function (GameUILayers) {
        GameUILayers[GameUILayers["GAME"] = 0] = "GAME";
        GameUILayers[GameUILayers["JOY_STICK"] = 1] = "JOY_STICK";
        GameUILayers[GameUILayers["HUD"] = 2] = "HUD";
        GameUILayers[GameUILayers["POPUP"] = 3] = "POPUP";
        GameUILayers[GameUILayers["ALERT"] = 4] = "ALERT";
        GameUILayers[GameUILayers["NOTICE"] = 5] = "NOTICE";
        GameUILayers[GameUILayers["LOADING"] = 6] = "LOADING";
        GameUILayers[GameUILayers["OVERLAY"] = 7] = "OVERLAY";
        return GameUILayers;
      }({}));

      /**ui管理模块*/
      ui = class ui {
        constructor() {
          this._uiCanvas = void 0;
          this._uiRoot = void 0;
          this._clss_loading = new Set();
        }

        static getInstance() {
          if (!this._instance) this._instance = new ui();
          return this._instance;
        }

        delay(ms) {
          return new Promise(resolve => setTimeout(resolve, ms));
        }

        delay_second(s) {
          return new Promise(resolve => setTimeout(resolve, s * 1000));
        }

        progressBar_anim(bar, progress, duration) {
          if (duration === void 0) {
            duration = 0.2;
          }

          if (bar.progress >= progress) {
            bar.progress = progress;
            return;
          } else {
            return new Promise(resolve => tween(bar).to(duration, {
              progress: progress
            }).call(() => {
              resolve();
            }).start());
          }
        }

        fillRange_anim(sp, progress, duration, limt) {
          if (duration === void 0) {
            duration = 0.2;
          }

          if (limt === void 0) {
            limt = 0;
          }

          if (limt > 0 && sp.fillRange >= progress && limt < 0 && sp.fillRange <= progress) {
            sp.fillRange = progress;
            return;
          } else {
            return new Promise(resolve => tween(sp).to(duration, {
              fillRange: progress
            }).call(() => {
              resolve();
            }).start());
          }
        }

        scale_anim(node, duration, start, end) {
          if (duration === void 0) {
            duration = 0.2;
          }

          if (start === void 0) {
            start = 0.5;
          }

          if (end === void 0) {
            end = 1;
          }

          node.setScale(start, start, 1);
          return new Promise(resolve => tween(node).to(duration, {
            scale: v3(end, end, 1)
          }).call(() => {
            resolve();
          }).start());
        }

        scale_elasticOut_anim(node, duration, start, end) {
          if (duration === void 0) {
            duration = 0.2;
          }

          if (start === void 0) {
            start = 0.5;
          }

          if (end === void 0) {
            end = 1;
          }

          node.setScale(start, start, 1);
          return new Promise(resolve => tween(node).to(duration, {
            scale: v3(end, end, 1)
          }, {
            easing: 'elasticOut'
          }).call(() => {
            resolve();
          }).start());
        }

        fade_anim(node, duration, startOpacity, targetOpacity) {
          var _node$getComponent;

          if (duration === void 0) {
            duration = 0.2;
          }

          if (startOpacity === void 0) {
            startOpacity = 0;
          }

          if (targetOpacity === void 0) {
            targetOpacity = 255;
          }

          var opacity = (_node$getComponent = node.getComponent(UIOpacity)) != null ? _node$getComponent : node.addComponent(UIOpacity);
          opacity.opacity = startOpacity;
          return new Promise(resolve => {
            tween(opacity).to(duration, {
              opacity: targetOpacity
            }).call(() => {
              resolve();
            }).start();
          });
        }

        shake_anim(node, duration, intensity, shakeCount) {
          if (duration === void 0) {
            duration = 0.2;
          }

          if (intensity === void 0) {
            intensity = 5;
          }

          if (shakeCount === void 0) {
            shakeCount = 7;
          }

          return new Promise(resolve => {
            var originalPosition = node.position.clone(); // 保存原始位置  

            var shakeDuration = duration / (shakeCount * 2); // 每次抖动的持续时间  

            var shakeTween = tween(node);

            for (var i = 0; i < shakeCount; i++) {
              var offsetX = i % 2 === 0 ? intensity : -intensity; // 交替偏移  

              shakeTween.to(shakeDuration, {
                position: v3(originalPosition.x + offsetX, originalPosition.y, originalPosition.z)
              }).to(shakeDuration, {
                position: originalPosition
              }); // 回到原位  
            }

            shakeTween.call(() => {
              resolve();
            }).start(); // 开始抖动动画  
          });
        }

        rotate_shake_anim(node, duration, intensity, shakeCount) {
          if (duration === void 0) {
            duration = 0.3;
          }

          if (intensity === void 0) {
            intensity = 5;
          }

          if (shakeCount === void 0) {
            shakeCount = 5;
          }

          return new Promise(resolve => {
            var originalAngle = node.angle; // 保存原始角度  

            var shakeDuration = duration / (shakeCount * 2); // 每次晃动的持续时间  

            var shakeTween = tween(node);

            for (var i = 0; i < shakeCount; i++) {
              var offsetAngle = i % 2 === 0 ? intensity : -intensity; // 交替旋转  

              shakeTween.to(shakeDuration, {
                angle: originalAngle + offsetAngle
              }).to(shakeDuration, {
                angle: originalAngle
              }); // 回到原位  
            }

            shakeTween.call(() => {
              resolve();
            }).start(); // 开始角度晃动动画  
          });
        }

        scale_shake_anim(node, duration, intensity, shakeCount, reset) {
          if (duration === void 0) {
            duration = 0.3;
          }

          if (intensity === void 0) {
            intensity = 0.1;
          }

          if (shakeCount === void 0) {
            shakeCount = 10;
          }

          if (reset === void 0) {
            reset = null;
          }

          if (reset) {
            Tween.stopAllByTarget(node);
            node.setScale(reset, reset, reset);
          }

          return new Promise(resolve => {
            var originalScale = node.scale.clone(); // 保存原始缩放  

            var shakeDuration = duration / (shakeCount * 2); // 每次震动的持续时间  

            var shakeTween = tween(node);

            for (var i = 0; i < shakeCount; i++) {
              var offsetScale = i % 2 === 0 ? intensity : -intensity; // 交替缩放  

              shakeTween.to(shakeDuration, {
                scale: v3(originalScale.x + offsetScale, originalScale.y + offsetScale, originalScale.z)
              }).to(shakeDuration, {
                scale: originalScale
              }); // 回到原位  
            }

            shakeTween.call(() => {
              resolve();
            }).start(); // 开始缩放震动动画  
          });
        }

        opacity_shake_anim(node, duration, intensity, shakeCount) {
          var _node$getComponent2;

          if (duration === void 0) {
            duration = 0.8;
          }

          if (intensity === void 0) {
            intensity = 80;
          }

          if (shakeCount === void 0) {
            shakeCount = 5;
          }

          var opacity = (_node$getComponent2 = node.getComponent(UIOpacity)) != null ? _node$getComponent2 : node.addComponent(UIOpacity);
          var originalOpacity = opacity.opacity;
          var shakeDuration = duration / (shakeCount * 2);
          return new Promise(resolve => {
            var shakeTween = tween(opacity);

            for (var i = 0; i < shakeCount; i++) {
              var offsetOpacity = i % 2 === 0 ? intensity : -intensity;
              shakeTween.to(shakeDuration, {
                opacity: Math.min(Math.max(originalOpacity + offsetOpacity, 0), 255)
              }).to(shakeDuration, {
                opacity: originalOpacity
              });
            }

            shakeTween.call(() => {
              resolve();
            }).start(); // 开始透明度震动动画  
          });
        }
        /**处理弹跳动画*/


        bounce_anim(node, height, duration) {
          if (height === void 0) {
            height = 100;
          }

          if (duration === void 0) {
            duration = 0.5;
          }

          return new Promise(resolve => {
            tween(node).to(duration, {
              position: node.position.clone().add(new Vec3(0, height, 0))
            }, {
              easing: 'bounceOut'
            }) // 向上弹跳  
            .to(duration, {
              position: node.position
            }, {
              easing: 'bounceIn'
            }) // 回到原位  
            .call(() => {
              resolve();
            }) //完成动画  
            .start(); //开始动画
          });
        }
        /**
         * 奖励物飞行动画
         * @param node 奖励物节点
         * @param startPos 起始爆开点
         * @param targetPos 最终目标点
         * @param explosionDistance 爆开距离
         * @param explosionDuration 爆开时间
         * @param stayDuration 停留时间
         * @param moveDuration 移动到目标的时间
         * @returns 
         */


        reward_fly_anim(node, startPos, targetPos, explosionDistance, explosionDuration, stayDuration, moveDuration) {
          if (explosionDistance === void 0) {
            explosionDistance = 100;
          }

          if (explosionDuration === void 0) {
            explosionDuration = 0.3;
          }

          if (stayDuration === void 0) {
            stayDuration = 0.5;
          }

          if (moveDuration === void 0) {
            moveDuration = 0.3;
          }

          node.setPosition(startPos);
          return new Promise(resolve => {
            //随机方向
            var randomDirection = new Vec3(Math.random() * 2 - 1, Math.random() * 2 - 1, 0).normalize();
            var explosionEndPos = startPos.add(randomDirection.multiplyScalar(explosionDistance)); // 爆炸效果的位置  

            tween(node).to(explosionDuration, {
              worldPosition: explosionEndPos
            }) // 爆炸动画  
            .delay(stayDuration) //停留时间  
            .to(moveDuration, {
              worldPosition: targetPos
            }, {
              easing: 'cubicIn'
            }).call(() => {
              resolve();
            }).start();
          });
        }

        createFullScreenNode() {
          var canvas = this._uiCanvas.getComponent(UITransform);

          var node = new Node();
          node.layer = this._uiCanvas.layer;
          var uiTransform = node.addComponent(UITransform);
          uiTransform.width = canvas.width;
          uiTransform.height = canvas.height;
          var widget = node.addComponent(Widget);
          widget.isAlignBottom = true;
          widget.isAlignTop = true;
          widget.isAlignLeft = true;
          widget.isAlignRight = true;
          widget.left = 0;
          widget.right = 0;
          widget.top = 0;
          widget.bottom = 0;
          return node;
        }

        getLayers() {
          return Object.values(GameUILayers).filter(value => typeof value === 'number');
        }
        /**
         * @en init,`don't call more than once`.
         * @zh 初始化UIMgr,`不要多次调用`
         *  */


        init(uiCanvas) {
          if (this._uiCanvas) return;
          if (!uiCanvas) throw error('uiCanvas must be a Node or Prefab');

          if (uiCanvas instanceof Node) {
            this._uiCanvas = uiCanvas;
          } else {
            this._uiCanvas = instantiate(uiCanvas);
            director.getScene().addChild(this._uiCanvas);
          }

          this._uiCanvas.name = '__ui_canvas__';
          director.addPersistRootNode(this._uiCanvas);

          if (!this._uiCanvas.getComponent(ui_updater)) {
            this._uiCanvas.addComponent(ui_updater);
          }

          var canvas = this._uiCanvas.getComponent(UITransform);

          this._uiCanvas.addComponent(_crd && ResolutionAutoFit === void 0 ? (_reportPossibleCrUseOfResolutionAutoFit({
            error: Error()
          }), ResolutionAutoFit) : ResolutionAutoFit);

          this._uiRoot = this.createFullScreenNode();
          this._uiRoot.name = 'root';
          canvas.node.addChild(this._uiRoot);
          var layers = this.getLayers(); //create layers

          for (var i = 0; i < layers.length; ++i) {
            var layerNode = this.createFullScreenNode();
            layerNode.name = 'layer_' + GameUILayers[layers[i]];

            this._uiRoot.addChild(layerNode);
          }
        }
        /**获取层级节点*/


        getLayerNode(layerIndex) {
          return this._uiRoot.children[layerIndex] || this._uiRoot;
        }
        /**关闭所有界面*/


        closeAll() {
          (_crd && ui_base === void 0 ? (_reportPossibleCrUseOfui_base({
            error: Error()
          }), ui_base) : ui_base).closeAll();
        }
        /**关闭和释放所有界面 */


        closeAndReleaseAll() {
          (_crd && ui_base === void 0 ? (_reportPossibleCrUseOfui_base({
            error: Error()
          }), ui_base) : ui_base).closeAndReleaseAll();
        }
        /**关闭某个界面*/


        close(uiCls) {
          var _this$get;

          (_this$get = this.get(uiCls)) == null || _this$get.close();
        }
        /**获取界面*/


        get(uiCls) {
          var all = ui_base._uis;

          for (var i = 0; i < all.length; ++i) {
            var c = all[i];

            if (c instanceof uiCls) {
              return c;
            }
          }

          return null;
        }
        /**某个界面是否显示中*/


        isShowing(uiCls) {
          return ui_base._hasCls(uiCls);
        }

        /**是否有正在加载中的界面*/
        isLoading(uiCls) {
          if (!uiCls) return this._clss_loading.size > 0;
          return this._clss_loading.has(uiCls);
        }
        /***
         * @en show ui by the given parameters.
         * @zh 显示UI
         * @param uiCls the class, must inherits from the class `UIController`.
         * @returns the instance of `uiCls`
         *  */


        show(uiCls) {
          var _arguments = arguments,
              _this = this;

          return _asyncToGenerator(function* () {
            if (_this.isLoading(uiCls)) return null;
            if (_this.isShowing(uiCls)) return null;
            var ui = new uiCls();

            _this._clss_loading.add(uiCls);

            var bundleName = ui.bundle;

            if (bundleName) {
              var bundle = assetManager.getBundle(bundleName);

              for (var _len = _arguments.length, data = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
                data[_key - 1] = _arguments[_key];
              }

              if (!bundle) {
                try {
                  var loadedBundle = yield _this.loadBundleAsync(bundleName);
                  return yield _this._create(loadedBundle, ui, uiCls, ...data);
                } catch (err) {
                  console.error(err);

                  _this._clss_loading.delete(uiCls);
                }
              } else {
                return yield _this._create(bundle, ui, uiCls, ...data);
              }
            } else {
              _this._clss_loading.delete(uiCls);

              console.error("ui no bundle name");
              return null;
            }
          })();
        }

        _create(bundle, ui, uiCls) {
          var _arguments2 = arguments,
              _this2 = this;

          return _asyncToGenerator(function* () {
            try {
              var data = yield _this2.loadPrefabAsync(bundle, ui.prefab);
              var node = instantiate(data);

              var parent = _this2.getLayerNode(ui.layer);

              parent.addChild(node);

              for (var _len2 = _arguments2.length, p = new Array(_len2 > 3 ? _len2 - 3 : 0), _key2 = 3; _key2 < _len2; _key2++) {
                p[_key2 - 3] = _arguments2[_key2];
              }

              ui._setup(uiCls, node, ...p);

              _this2._clss_loading.delete(uiCls);

              return ui;
            } catch (err) {
              console.error(err);

              _this2._clss_loading.delete(uiCls);

              return;
            }
          })();
        }

        loadBundleAsync(bundleName) {
          return new Promise((resolve, reject) => {
            assetManager.loadBundle(bundleName, null, (err, loadedBundle) => {
              if (err) {
                reject(err);
              } else {
                resolve(loadedBundle);
              }
            });
          });
        }

        loadPrefabAsync(bundle, prefabName) {
          return new Promise((resolve, reject) => {
            bundle.load(prefabName, (err, data) => {
              if (err) {
                reject(err);
              } else {
                resolve(data);
              }
            });
          });
        }

      };
      ui._instance = void 0;

      _export("gui", gui = ui.getInstance());

      _export("ui_base", ui_base);

      _cclegacy._RF.pop();

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