idioms/idiom/temp/programming/packer-driver/targets/editor/chunks/c0/c0e9a0408b2c77521760095bef7e3d1dc8b428fc.js

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

  var _cclegacy, PeriodData, _crd, PeriodDataUpdate;

  _export("default", void 0);

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

      _cclegacy._RF.push({}, "6e040Hgcc1C2r4oXdDQnwvy", "PeriodData", undefined);

      _export("PeriodDataUpdate", PeriodDataUpdate = /*#__PURE__*/function (PeriodDataUpdate) {
        PeriodDataUpdate[PeriodDataUpdate["none"] = 0] = "none";
        PeriodDataUpdate[PeriodDataUpdate["day"] = 1] = "day";
        PeriodDataUpdate[PeriodDataUpdate["week"] = 2] = "week";
        PeriodDataUpdate[PeriodDataUpdate["month"] = 3] = "month";
        return PeriodDataUpdate;
      }({}));
      /**周期数据
       * @param T 为一个枚举类型
       * @param update PeriodDataUpdate 更新周期
       * @param limt 限制值最大，最小
       * 调用check检测更新
       * @exampl
      定义数据枚举  字段名和字段key需要一致
      export enum day_type{
         score ="score",
         level ="level",
         relive="relive",
      }
      初始所有定义数据
      day_data = new PeriodData<day_type>(PeriodDataUpdate.day,
               Object.keys(day_type) as day_type[],
               new Map([
                     [day_type.relive,{min:0,max:3}],//限制每日复活3次
               ])
            );
      day_data.get(day_type.score)...
      */


      _export("default", PeriodData = class PeriodData {
        constructor(update, limt) {
          this._data = new Map();
          this._data_Array = new Map();
          this._last = 0;
          this._update = void 0;
          this._update = update;
          if (!limt) return; //遍历所有键进行初始化

          limt.forEach((v, key) => {
            var _v$min;

            this._data.set(key, {
              v: (_v$min = v.min) != null ? _v$min : 0,
              min: v.min,
              max: v.max
            });
          }, this);
        }
        /**
        * 序列化（数据库存储）
        */


        serialize() {
          const obj = {};

          this._data.forEach((value, key) => {
            obj[String(key)] = value.v;
          });

          const obj1 = {};

          this._data_Array.forEach((value, key) => {
            obj1[String(key)] = value;
          });

          const data = {
            "last": this._last,
            "data": obj,
            "data_Array": obj1
          };
          return data;
        }
        /**
        * 反序列化
        */


        unserialize(data) {
          var _data$last;

          if (!data) return;
          this._last = (_data$last = data.last) != null ? _data$last : 0;
          const obj = data.data;

          if (obj) {
            for (const key in obj) {
              const value = obj[key];
              this._get(key).v = value;
            }
          }

          const obj1 = data.data_Array;

          if (obj1) {
            for (const key in obj1) {
              const value = obj1[key];
              this.set_Array(key, value);
            }
          }
        }

        _get(key) {
          let data = this._data.get(key);

          if (!data) {
            data = {
              v: 0,
              min: 0,
              max: null
            };

            this._data.set(key, data);
          }

          return data;
        }

        _get_Array(key) {
          let data = this._data_Array.get(key);

          if (!data) {
            data = new Array(7).fill(false);

            this._data_Array.set(key, data);
          }

          return data;
        }
        /**如果有必要，重新设置数据的min,max*/


        set(key, value, min, max) {
          const d = this._get(key);

          d.v = value;
          d.min = min;
          d.max = max;
        }
        /**获取数据*/


        get(key) {
          return this._get(key).v;
        }

        set_Array(key, value) {
          this._data_Array.set(key, value);
        }
        /**获取数据*/


        get_Array(key) {
          return this._get_Array(key);
        }
        /**有大最值的话，获取数据为剩余可用次数*/


        get_available(key) {
          const d = this._get(key);

          if (d.max) return d.max - d.v;
          return d.v;
        }

        isEnble(key) {
          const d = this._get(key);

          return d.v > 0;
        }

        enble(key) {
          this._get(key).v = 1;
        }

        disEnble(key) {
          this._get(key).v = 0;
        }
        /**增加数据的值*/


        add(key, n = 1) {
          return this.change(key, n);
        }
        /**减小数据的值*/


        sub(key, n = 1) {
          return this.change(key, -n);
        }
        /**改变数据 n>0增加 小于0减少*/


        change(key, n) {
          const d = this._get(key);

          if (!d) return null;
          d.v += n;
          if (d.min && d.v < d.min) d.v = d.min;
          if (d.max && d.v > d.max) d.v = d.max;
          return d.v;
        }
        /**改变数据，比原本值大直接替换，没有改变返回null*/


        change_big(key, n) {
          const d = this._get(key);

          if (!d) return null;

          if (n > d.v) {
            d.v = n;
            if (d.min && d.v < d.min) d.v = d.min;
            if (d.max && d.v > d.max) d.v = d.max;
            return d.v;
          }

          return null;
        }
        /**改变数据，比原本值小直接替换，没有改变返回null*/


        change_sm(key, n) {
          const d = this._get(key);

          if (!d) return null;

          if (n < d.v) {
            d.v = n;
            if (d.min && d.v < d.min) d.v = d.min;
            if (d.max && d.v > d.max) d.v = d.max;
            return d.v;
          }

          return null;
        }
        /**检测更新now当前时间戳(ms)*/


        check(now) {
          if (this._update == PeriodDataUpdate.none) return false;

          if (this._update == PeriodDataUpdate.day) {
            if (!this.isSameDate(now, this._last)) {
              this._last = now;
              this.reset();
              return true;
            }
          }

          if (this._update == PeriodDataUpdate.week) {
            if (!this.areDatesInSameWeek(now, this._last)) {
              this._last = now;
              this.reset();
              this._data_Array = new Map();
              return true;
            }
          }

          if (this._update == PeriodDataUpdate.month) {
            if (!this.areDatesInSameMonth(now, this._last)) {
              this._last = now;
              this.reset();
              return true;
            }
          }

          return false;
        }

        reset() {
          for (const key of this._data.keys()) {
            var _data$min;

            const data = this._get(key);

            data.v = (_data$min = data.min) != null ? _data$min : 0;
          }
        }
        /**判定两个时间是否是同一天*/


        isSameDate(timestamp1, timestamp2) {
          let date1 = new Date(timestamp1);
          let date2 = new Date(timestamp2);
          return date1.getFullYear() == date2.getFullYear() && date1.getMonth() == date2.getMonth() && date1.getDate() == date2.getDate();
        }
        /**判定两个时间是否是同一周*/


        areDatesInSameWeek(date1, date2) {
          const startOfWeek1 = this.getStartOfWeek(new Date(date1));
          const startOfWeek2 = this.getStartOfWeek(new Date(date2));
          return startOfWeek1.getTime() === startOfWeek2.getTime();
        }

        getStartOfWeek(date) {
          const startOfWeek = new Date(date);
          const day = startOfWeek.getDay(); // 星期日是 0，星期一是 1，依此类推  

          const diff = startOfWeek.getDate() - day; // 计算当前日期所在周的第一天  

          startOfWeek.setDate(diff); // 设置为该周的第一天  

          startOfWeek.setHours(0, 0, 0, 0); // 设置时间为 00:00:00  

          return startOfWeek;
        }

        areDatesInSameMonth(date1, date2) {
          const d1 = new Date(date1);
          const d2 = new Date(date2);
          return d1.getFullYear() === d2.getFullYear() && d1.getMonth() === d2.getMonth();
        }

      });

      _cclegacy._RF.pop();

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