idioms/idiom/temp/programming/packer-driver/targets/editor/chunks/e0/e08485787ba9b2ad7c98e435102c966d3f5c64ae.js

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

  var _cclegacy, Random, _crd;

  function get_new_random(seed) {
    return new Random(seed);
  }

  _export("default", get_new_random);

  return {
    setters: [function (_cc) {
      _cclegacy = _cc.cclegacy;
    }],
    execute: function () {
      _crd = true;

      _cclegacy._RF.push({}, "0df919aG5RLDb2SUzCkvbif", "Random", undefined);

      /**设种一个随机种子保证随机结果一致
       * 后面需要可以引入 seedrandom 库
      */
      Random = class Random {
        /**当前种子*/
        get seed() {
          return this._seed;
        }
        /**原始种子*/


        get start_seed() {
          return this._start_seed;
        }
        /**随机种子*/


        constructor(seed) {
          this._seed = void 0;
          this._start_seed = void 0;
          this.set_seed(seed);
        }
        /**设置当前开始种子*/


        set_seed(seed) {
          this._seed = seed;
          this._start_seed = seed;
        }

        _nextSeed() {
          this._seed = (this._seed * 9301 + 49297) % 233280;
        }
        /**0.0(含)-1.0(不含)*/


        _nextFloat() {
          this._nextSeed();

          return this._seed / 233280;
        }
        /**0(含)-max(不含) */


        _nextInt(max) {
          max = Math.floor(max);

          this._nextSeed();

          return this._seed % max;
        }
        /**
         * 生成指定范围的随机浮点数
         * @param min   最小值(含)
         * @param max   最大值(不含)
        */


        float(min = 0, max = 1) {
          return this._nextFloat() * (max - min) + min;
        }
        /**
         * 生成指定范围的随机整数
         * @param min 最小值(含)
         * @param max 最大值(不含)
         * @returns
         */


        int(min = 0, max = 100) {
          return this._nextInt(max - min) + Math.ceil(min);
        }
        /** 生成随机整数 -1 或 1*/


        dir() {
          return Math.floor(this.float() * 2) === 0 ? -1 : 1;
        }
        /**
        * 在指定数组中随机取出N个不重复的数据
        * @param resArr
        * @param ranNum
        * @returns {Array}
        */


        getDiffValueFromArr(resArr, ranNum) {
          let arr = new Array();
          let result = new Array();

          if (!resArr || resArr.length <= 0 || ranNum <= 0) {
            return result;
          }

          for (let i = 0; i < resArr.length; i++) {
            arr.push(resArr[i]);
          }

          if (ranNum >= arr.length) return arr;
          ranNum = Math.min(ranNum, arr.length - 1);

          for (let i = 0; i < ranNum; i++) {
            let ran = this.int(0, arr.length - 1);
            result.push(arr.splice(ran, 1)[0]);
          }

          return result;
        }
        /**
        * 生成指定范围的随机整数
         * @param min   最小值
         * @param max   最大值
         * @param type  类型
         * @example
         //type=1 [min,max) 得到一个两数之间的随机整数,这个值不小于min（如果min不是整数的话，得到一个向上取整的 min），并且小于（但不等于）max  
         //type=2 [min,max] 得到一个两数之间的随机整数，包括两个数在内,这个值比min大（如果min不是整数，那就不小于比min大的整数），但小于（但不等于）max
         //type=3 (min,max) 得到一个两数之间的随机整数
        */


        int_type(min, max, type) {
          min = Math.ceil(min);
          max = Math.floor(max);

          switch (type) {
            case 1:
              // [min,max) 得到一个两数之间的随机整数,这个值不小于min（如果min不是整数的话，得到一个向上取整的 min），并且小于（但不等于）max  
              return Math.floor(this._nextFloat() * (max - min)) + min;

            case 2:
              // [min,max] 得到一个两数之间的随机整数，包括两个数在内,这个值比min大（如果min不是整数，那就不小于比min大的整数），但小于（但不等于）max
              return Math.floor(this._nextFloat() * (max - min + 1)) + min;

            case 3:
              // (min,max) 得到一个两数之间的随机整数
              return Math.floor(this._nextFloat() * (max - min - 1)) + min + 1;
          }

          return 0;
        }

      };
      /**创建一个设定好种子的随机数实例*/

      _cclegacy._RF.pop();

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