@drincs/nqtr 0.0.1

package/dist/index.mjs

@@ -0,0 +1,1057 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+
+// src/classes/Activity.ts
+import { getFlag } from "@drincs/pixi-vn";
+
+// src/managers/TimeManager.ts
+import { GameStorageManager } from "@drincs/pixi-vn";
+var TIME_SETTINGS_KEY = "___nqtr-time_manager_settings___";
+var TIME_DATA_KEY = "___nqtr-time_manager_data___";
+var TimeManager = class _TimeManager {
+  constructor() {
+  }
+  static set editSettings(value) {
+    let settings = {};
+    if (typeof value.minDayHour === "number") {
+      settings["minDayHour"] = value.minDayHour;
+    }
+    if (typeof value.maxDayHour === "number") {
+      settings["maxDayHour"] = value.maxDayHour;
+    }
+    if (typeof value.minDayHour === "number") {
+      settings["defaultTimeSpent"] = value.defaultTimeSpent;
+    }
+    if (Array.isArray(value.timeSlots)) {
+      settings["timeSlots"] = value.timeSlots;
+    }
+    if (typeof value.weekLength === "number") {
+      settings["weekLength"] = value.weekLength;
+    }
+    if (typeof value.newDayHour === "number") {
+      settings["newDayHour"] = value.newDayHour;
+    }
+    if (typeof value.weekendStartDay === "number") {
+      let weekLength = value.weekLength || _TimeManager.weekLength;
+      if (value.weekendStartDay >= weekLength) {
+        console.warn(`[NQTR] Weekend start day should be less than week length ${weekLength}`);
+      }
+      settings["weekendStartDay"] = value.weekendStartDay;
+    }
+    if (Array.isArray(value.weekDaysNames)) {
+      let weekLength = value.weekLength || _TimeManager.weekLength;
+      if (value.weekDaysNames.length !== weekLength) {
+        console.warn(`[NQTR] Week days names should be equal to week length ${weekLength}`);
+      }
+      settings["weekDaysNames"] = value.weekDaysNames;
+    }
+    GameStorageManager.setVariable(TIME_SETTINGS_KEY, settings);
+  }
+  static get minDayHour() {
+    let result = 0;
+    let settings = GameStorageManager.getVariable(TIME_SETTINGS_KEY);
+    if (settings && settings.hasOwnProperty("minDayHour")) {
+      result = settings.minDayHour || 0;
+    }
+    return result;
+  }
+  static get maxDayHour() {
+    let result = 24;
+    let settings = GameStorageManager.getVariable(TIME_SETTINGS_KEY);
+    if (settings && settings.hasOwnProperty("maxDayHour")) {
+      result = settings.maxDayHour || 24;
+    }
+    return result;
+  }
+  static get defaultTimeSpent() {
+    let result = 1;
+    let settings = GameStorageManager.getVariable(TIME_SETTINGS_KEY);
+    if (settings && settings.hasOwnProperty("defaultTimeSpent")) {
+      result = settings.defaultTimeSpent || 1;
+    }
+    return result;
+  }
+  static get newDayHour() {
+    let result = 0;
+    let settings = GameStorageManager.getVariable(TIME_SETTINGS_KEY);
+    if (settings && settings.hasOwnProperty("newDayHour")) {
+      result = settings.newDayHour || 0;
+    }
+    return result;
+  }
+  static get timeSlots() {
+    let result = [];
+    let settings = GameStorageManager.getVariable(TIME_SETTINGS_KEY);
+    if (settings && settings.hasOwnProperty("timeSlots")) {
+      result = settings.timeSlots || [];
+    }
+    return result;
+  }
+  static get weekLength() {
+    let result = 7;
+    let settings = GameStorageManager.getVariable(TIME_SETTINGS_KEY);
+    if (settings && settings.hasOwnProperty("weekLength")) {
+      result = settings.weekLength || 7;
+    }
+    return result;
+  }
+  static get weekendStartDay() {
+    let result = _TimeManager.weekLength - 1;
+    let settings = GameStorageManager.getVariable(TIME_SETTINGS_KEY);
+    if (settings && settings.hasOwnProperty("weekendStartDay")) {
+      result = settings.weekendStartDay || _TimeManager.weekLength - 1;
+    }
+    return result;
+  }
+  static get weekDaysNames() {
+    let result = [];
+    let settings = GameStorageManager.getVariable(TIME_SETTINGS_KEY);
+    if (settings && settings.hasOwnProperty("weekDaysNames")) {
+      result = settings.weekDaysNames || result;
+    }
+    return result;
+  }
+  static get currentHour() {
+    let data = GameStorageManager.getVariable(TIME_DATA_KEY) || {};
+    if (data.hasOwnProperty("currentHour") && typeof data.currentHour === "number") {
+      return data.currentHour;
+    }
+    return _TimeManager.minDayHour;
+  }
+  static set currentHour(value) {
+    let data = GameStorageManager.getVariable(TIME_DATA_KEY) || {};
+    if (typeof value === "number") {
+      data.currentHour = value;
+    } else {
+      delete data.currentHour;
+    }
+    GameStorageManager.setVariable(TIME_DATA_KEY, data);
+  }
+  static get currentDay() {
+    let data = GameStorageManager.getVariable(TIME_DATA_KEY) || {};
+    if (data.hasOwnProperty("currentDay") && typeof data.currentDay === "number") {
+      return data.currentDay;
+    }
+    return 0;
+  }
+  static set currentDay(value) {
+    let data = GameStorageManager.getVariable(TIME_DATA_KEY) || {};
+    if (typeof value === "number") {
+      data.currentDay = value;
+    } else {
+      delete data.currentDay;
+    }
+    GameStorageManager.setVariable(TIME_DATA_KEY, data);
+  }
+  static get isWeekend() {
+    return _TimeManager.weekDayNumber >= _TimeManager.weekendStartDay;
+  }
+  static get weekDayNumber() {
+    let result = _TimeManager.currentDay % _TimeManager.weekLength;
+    return result + 1;
+  }
+  static get weekDayName() {
+    let weekDayNumber = _TimeManager.weekDayNumber - 1;
+    if (weekDayNumber >= _TimeManager.weekDaysNames.length) {
+      console.warn(`[NQTR] Week day name is not defined for day ${weekDayNumber}`, _TimeManager.weekDaysNames);
+      return void 0;
+    }
+    return _TimeManager.weekDaysNames[weekDayNumber];
+  }
+  static newHour(timeSpent = _TimeManager.defaultTimeSpent) {
+    let newHour = _TimeManager.currentHour + timeSpent;
+    if (newHour >= _TimeManager.maxDayHour) {
+      _TimeManager.newDay();
+      newHour = _TimeManager.minDayHour + (newHour - _TimeManager.maxDayHour);
+    }
+    _TimeManager.currentHour = newHour;
+    return newHour;
+  }
+  static newDay(days = 1) {
+    let newDay = _TimeManager.currentDay + days;
+    _TimeManager.currentDay = newDay;
+    return newDay;
+  }
+  static nowIsBetween(fromHour, toHour) {
+    let currentHour = _TimeManager.currentHour;
+    if (fromHour < toHour) {
+      return currentHour >= fromHour && currentHour < toHour;
+    }
+    return currentHour >= fromHour || currentHour < toHour;
+  }
+};
+
+// src/classes/Activity.ts
+var ActivityStoredAbstract = class {
+  constructor(onRun, props) {
+    this.defaultName = props.name;
+    this.defaultFromHour = props.fromHour;
+    this.defaultToHour = props.toHour;
+    this.defaultFromDay = props.fromDay;
+    this.defaultToDay = props.toDay;
+    this.defaultDisabled = props.disabled || false;
+    this.defaultHidden = props.hidden || false;
+    this._iconElement = props.iconElement;
+    this._onRun = onRun;
+  }
+  get name() {
+    return this.getStorageProperty("name") || this.defaultName || "";
+  }
+  set name(value) {
+    this.setStorageProperty("name", value);
+  }
+  get fromHour() {
+    return this.getStorageProperty("fromHour") || this.defaultFromHour || TimeManager.minDayHour;
+  }
+  set fromHour(value) {
+    this.setStorageProperty("fromHour", value);
+  }
+  get toHour() {
+    return this.getStorageProperty("toHour") || this.defaultToHour || TimeManager.maxDayHour + 1;
+  }
+  set toHour(value) {
+    this.setStorageProperty("toHour", value);
+  }
+  get fromDay() {
+    return this.getStorageProperty("fromDay") || this.defaultFromDay;
+  }
+  set fromDay(value) {
+    this.setStorageProperty("fromDay", value);
+  }
+  get toDay() {
+    return this.getStorageProperty("toDay") || this.defaultToDay;
+  }
+  set toDay(value) {
+    this.setStorageProperty("toDay", value);
+  }
+  get disabled() {
+    let value = this.getStorageProperty("disabled") || this.defaultDisabled;
+    if (typeof value === "string") {
+      return getFlag(value);
+    }
+    return value;
+  }
+  set disabled(value) {
+    this.setStorageProperty("disabled", value);
+  }
+  get hidden() {
+    if (this.fromDay && this.fromDay > TimeManager.currentDay) {
+      return true;
+    }
+    if (!TimeManager.nowIsBetween(this.fromHour, this.toHour)) {
+      return true;
+    }
+    if (!this.isExpired) {
+      return true;
+    }
+    let value = this.getStorageProperty("hidden") || this.defaultHidden;
+    if (typeof value === "string") {
+      return getFlag(value);
+    }
+    return value;
+  }
+  set hidden(value) {
+    this.setStorageProperty("hidden", value);
+  }
+  get iconElement() {
+    return this._iconElement;
+  }
+  get onRun() {
+    return this._onRun;
+  }
+  isExpired() {
+    if (this.toDay && this.toDay <= TimeManager.currentDay) {
+      return true;
+    }
+    return false;
+  }
+  export() {
+    return {
+      name: this.getStorageProperty("name") || this.defaultName,
+      fromHour: this.getStorageProperty("fromHour") || this.defaultFromHour,
+      toHour: this.getStorageProperty("toHour") || this.defaultToHour,
+      fromDay: this.getStorageProperty("fromDay") || this.defaultFromDay,
+      toDay: this.getStorageProperty("toDay") || this.defaultToDay,
+      disabled: this.getStorageProperty("disabled") || this.defaultDisabled,
+      hidden: this.getStorageProperty("hidden") || this.defaultHidden,
+      iconElement: this._iconElement
+    };
+  }
+};
+var ActivityModel = class {
+  constructor(id, onRun, props) {
+    this._id = id;
+    this._name = props.name;
+    this._fromHour = props.fromHour;
+    this._toHour = props.toHour;
+    this._fromDay = props.fromDay;
+    this._toDay = props.toDay;
+    this._disabled = props.disabled || false;
+    this._hidden = props.hidden || false;
+    this._iconElement = props.iconElement;
+    this._onRun = onRun;
+  }
+  get id() {
+    return this._id;
+  }
+  get name() {
+    return this._name;
+  }
+  get fromHour() {
+    return this._fromHour;
+  }
+  get toHour() {
+    return this._toHour;
+  }
+  get fromDay() {
+    return this._fromDay;
+  }
+  get toDay() {
+    return this._toDay;
+  }
+  get disabled() {
+    if (typeof this._disabled === "string") {
+      return getFlag(this._disabled);
+    }
+    return this._disabled;
+  }
+  get hidden() {
+    if (this.fromDay && this.fromDay > TimeManager.currentDay) {
+      return true;
+    }
+    if (!this.isDeadline) {
+      return true;
+    }
+    if (typeof this._hidden === "string") {
+      return getFlag(this._hidden);
+    }
+    return this._hidden;
+  }
+  get iconElement() {
+    return this._iconElement;
+  }
+  get onRun() {
+    return this._onRun;
+  }
+  isDeadline() {
+    if (this.toDay && this.toDay <= TimeManager.currentDay) {
+      return true;
+    }
+    return false;
+  }
+  export() {
+    return {
+      name: this._name,
+      fromHour: this._fromHour,
+      toHour: this._toHour,
+      fromDay: this._fromDay,
+      toDay: this._toDay,
+      disabled: this._disabled,
+      hidden: this._hidden,
+      iconElement: this._iconElement
+    };
+  }
+};
+
+// src/classes/navigation/Location.ts
+import { getFlag as getFlag2, StoredClassModel } from "@drincs/pixi-vn";
+var LOCATION_CATEGORY = "__nqtr-location__";
+var LocationBaseModel = class extends StoredClassModel {
+  constructor(id, map, entrance, props) {
+    super(LOCATION_CATEGORY, id);
+    if (entrance.location.id !== id) {
+      throw new Error(`[NQTR] Entrance room ${entrance.id} is not in location ${id}`);
+    }
+    this._entrance = entrance;
+    this.defaultName = props.name || "";
+    this.defaultDisabled = props.disabled || false;
+    this.defaultHidden = props.hidden || false;
+    this._iconElement = props.iconElement;
+    this._map = map;
+  }
+  get entrance() {
+    return this._entrance;
+  }
+  get name() {
+    return this.getStorageProperty("name") || this.defaultName;
+  }
+  set name(value) {
+    this.setStorageProperty("name", value);
+  }
+  get disabled() {
+    let value = this.getStorageProperty("disabled") || this.defaultDisabled;
+    if (typeof value === "string") {
+      return getFlag2(value);
+    }
+    return value;
+  }
+  set disabled(value) {
+    this.setStorageProperty("disabled", value);
+  }
+  get hidden() {
+    let value = this.getStorageProperty("hidden") || this.defaultHidden;
+    if (typeof value === "string") {
+      return getFlag2(value);
+    }
+    return value;
+  }
+  set hidden(value) {
+    this.setStorageProperty("hidden", value);
+  }
+  get iconElement() {
+    return this._iconElement;
+  }
+  get map() {
+    return this._map;
+  }
+};
+
+// src/classes/navigation/Map.ts
+import { getFlag as getFlag3, StoredClassModel as StoredClassModel2 } from "@drincs/pixi-vn";
+var MAP_CATEGORY = "__nqtr-map__";
+var MapBaseModel = class extends StoredClassModel2 {
+  constructor(id, props) {
+    super(MAP_CATEGORY, id);
+    this.defaultName = props.name || "";
+    this.defaultImage = props.image;
+    this.defaultDisabled = props.disabled || false;
+    this.defaultHidden = props.hidden || false;
+  }
+  get name() {
+    return this.getStorageProperty("name") || this.defaultName;
+  }
+  set name(value) {
+    this.setStorageProperty("name", value);
+  }
+  get image() {
+    return this.getStorageProperty("image") || this.defaultImage;
+  }
+  set image(value) {
+    this.setStorageProperty("image", value);
+  }
+  get disabled() {
+    let value = this.getStorageProperty("disabled") || this.defaultDisabled;
+    if (typeof value === "string") {
+      return getFlag3(value);
+    }
+    return value;
+  }
+  set disabled(value) {
+    this.setStorageProperty("disabled", value);
+  }
+  get hidden() {
+    let value = this.getStorageProperty("hidden") || this.defaultHidden;
+    if (typeof value === "string") {
+      return getFlag3(value);
+    }
+    return value;
+  }
+  set hidden(value) {
+    this.setStorageProperty("hidden", value);
+  }
+};
+
+// src/classes/navigation/Room.ts
+import { getFlag as getFlag4, StoredClassModel as StoredClassModel3 } from "@drincs/pixi-vn";
+
+// src/decorators/ActivityDecorator.ts
+var registeredActivities = {};
+function saveActivity(activity) {
+  if (Array.isArray(activity)) {
+    activity.forEach((c) => saveActivity(c));
+    return;
+  }
+  if (registeredActivities[activity.id]) {
+    console.warn(`[NQTR] Activity id ${activity.id} already exists, it will be overwritten`);
+  }
+  registeredActivities[activity.id] = activity;
+}
+function getActivityById(id) {
+  try {
+    let activity = registeredActivities[id];
+    if (!activity) {
+      console.error(`[NQTR] Activity ${id} not found`);
+      return;
+    }
+    return activity;
+  } catch (e) {
+    console.error(`[NQTR] Error while getting Activity ${id}`, e);
+    return;
+  }
+}
+
+// src/decorators/CommitmentDecorator.ts
+import { GameStorageManager as GameStorageManager2 } from "@drincs/pixi-vn";
+var TEMPORARY_COMMITMENT_CATEGORY_MEMORY_KEY = "___nqtr-temporary_commitment___";
+var registeredCommitments = {};
+var fixedCommitments = {};
+function saveCommitment(commitment) {
+  if (Array.isArray(commitment)) {
+    commitment.forEach((c) => saveCommitment(c));
+    return;
+  }
+  if (registeredCommitments[commitment.id]) {
+    console.warn(`[NQTR] Commitment id ${commitment.id} already exists, it will be overwritten`);
+  }
+  registeredCommitments[commitment.id] = commitment;
+}
+function getCommitmentById(id) {
+  try {
+    let commitment = registeredCommitments[id];
+    if (!commitment) {
+      console.error(`[NQTR] Commitment ${id} not found`);
+      return;
+    }
+    return commitment;
+  } catch (e) {
+    console.error(`[NQTR] Error while getting Commitment ${id}`, e);
+    return;
+  }
+}
+function setFixedCommitments(commitments) {
+  if (Array.isArray(commitments)) {
+    commitments.forEach((c) => saveCommitment(c));
+    return;
+  }
+  if (registeredCommitments[commitments.id]) {
+    console.warn(`[NQTR] Commitment id ${commitments.id} already exists, it will be overwritten`);
+  }
+  registeredCommitments[commitments.id] = commitments;
+}
+function addTemporaryCommitment(commitment) {
+  if (!Array.isArray(commitment)) {
+    commitment = [commitment];
+  }
+  let commitmentsIds = commitment.map((commitment2) => {
+    let commitmentTest = getCommitmentById(commitment2.id);
+    if (!commitmentTest) {
+      console.warn(`[NQTR] Commitment ${commitment2.id} not found, it will be ignored`);
+      return void 0;
+    }
+    return commitment2.id;
+  }).filter((id) => id !== void 0);
+  GameStorageManager2.setVariable(TEMPORARY_COMMITMENT_CATEGORY_MEMORY_KEY, [commitmentsIds]);
+}
+function getFixedCommitments() {
+  return Object.values(fixedCommitments);
+}
+function getTemporaryCommitments() {
+  let commitmentsIds = GameStorageManager2.getVariable(TEMPORARY_COMMITMENT_CATEGORY_MEMORY_KEY);
+  if (!commitmentsIds) {
+    return [];
+  }
+  let commitments = commitmentsIds.map((id) => getCommitmentById(id)).filter((commitment) => commitment !== void 0);
+  return commitments;
+}
+
+// src/decorators/RoomDecorator.ts
+var registeredRooms = {};
+function saveRoom(room) {
+  if (Array.isArray(room)) {
+    room.forEach((c) => saveRoom(c));
+    return;
+  }
+  if (registeredRooms[room.id]) {
+    console.warn(`[NQTR] Room id ${room.id} already exists, it will be overwritten`);
+  }
+  registeredRooms[room.id] = room;
+}
+function getRoomById(id) {
+  try {
+    let room = registeredRooms[id];
+    if (!room) {
+      console.error(`[NQTR] Room ${id} not found`);
+      return;
+    }
+    return room;
+  } catch (e) {
+    console.error(`[NQTR] Error while getting Room ${id}`, e);
+    return;
+  }
+}
+
+// src/functions/RoutineFunctions.ts
+function clearExpiredRoutine() {
+  Object.entries(registeredCommitments).forEach(([_, commitment]) => {
+    if (commitment.isExpired()) {
+      delete registeredCommitments[commitment.id];
+    }
+  });
+}
+function getCurrentCommitments() {
+  let character_commitments = {};
+  let oltherCommitments = [];
+  getTemporaryCommitments().reverse().forEach((c) => {
+    if (!c.hidden) {
+      if (c.characters.length > 1) {
+        let allAvailable = c.characters.every((ch) => !character_commitments[ch.id]);
+        if (allAvailable) {
+          c.characters.forEach((ch) => {
+            character_commitments[ch.id] = c;
+          });
+        }
+      } else {
+        oltherCommitments.push(c);
+      }
+    }
+  });
+  getFixedCommitments().reverse().forEach((c) => {
+    if (!c.hidden) {
+      if (c.characters.length > 1) {
+        c.characters.forEach((ch) => {
+          if (!character_commitments[ch.id]) {
+            character_commitments[ch.id] = c;
+          }
+        });
+      } else {
+        oltherCommitments.push(c);
+      }
+    }
+  });
+  return Object.values(character_commitments).concat(oltherCommitments);
+}
+function getCommitmentByCharacter(character) {
+  getCurrentCommitments().forEach((c) => {
+    if (c.characters.map((ch) => ch.id).includes(character.id)) {
+      return c;
+    }
+  });
+  return void 0;
+}
+
+// src/classes/navigation/ActivityRoom.ts
+var ActivityRoom = class extends ActivityStoredAbstract {
+  constructor(id, room, onRun, props) {
+    super(onRun, props);
+    this._id = id;
+    this._room = room;
+  }
+  setStorageProperty(_, __) {
+    this._room.setActivity(this);
+  }
+  getStorageProperty(propertyName) {
+    let activity = this._room.getActivityMemory(this.id);
+    if (!activity || !activity.hasOwnProperty(propertyName)) {
+      return void 0;
+    }
+    return activity[propertyName];
+  }
+  get id() {
+    return this._id;
+  }
+  get room() {
+    return this._room;
+  }
+  export() {
+    let result = {};
+    if (this.name !== void 0) {
+      result["name"] = this.name;
+    }
+    if (this.fromHour !== void 0) {
+      result["fromHour"] = this.fromHour;
+    }
+    if (this.toHour !== void 0) {
+      result["toHour"] = this.toHour;
+    }
+    if (this.fromDay !== void 0) {
+      result["fromDay"] = this.fromDay;
+    }
+    if (this.toDay !== void 0) {
+      result["toDay"] = this.toDay;
+    }
+    if (this.disabled !== void 0) {
+      result["disabled"] = this.disabled;
+    }
+    return result;
+  }
+};
+
+// src/classes/navigation/Room.ts
+var ROOM_CATEGORY = "__nqtr-room__";
+var RoomBaseModel = class extends StoredClassModel3 {
+  constructor(id, location, props) {
+    var _a;
+    super(ROOM_CATEGORY, id);
+    this._location = location;
+    this.defaultName = props.name || "";
+    this.defaultImage = props.image;
+    this.defaultActivityIds = ((_a = props.defaultActivities) == null ? void 0 : _a.map((activity) => activity.id)) || [];
+    this.defaultDisabled = props.disabled || false;
+    this.defaultHidden = props.hidden || false;
+    this._iconElement = props.iconElement;
+  }
+  get location() {
+    return this._location;
+  }
+  get name() {
+    return this.getStorageProperty("name") || this.defaultName;
+  }
+  set name(value) {
+    this.setStorageProperty("name", value);
+  }
+  get image() {
+    return this.getStorageProperty("image") || this.defaultImage;
+  }
+  set image(value) {
+    this.setStorageProperty("image", value);
+  }
+  get defaultActivities() {
+    let roomMemories = this.getStorageProperty("activities_memory") || {};
+    let activities = this.defaultActivityIds.map((id) => {
+      let activity = getActivityById(id);
+      if (!activity) {
+        console.warn(`[NQTR] Activity with id ${id} not found, so it will be ignored.`);
+        return void 0;
+      }
+      let memory = activity.export();
+      if (roomMemories && roomMemories[id]) {
+        memory = __spreadValues(__spreadValues({}, memory), roomMemories[id]);
+      }
+      return new ActivityRoom(id, this, activity.onRun, memory);
+    }).filter((activity) => activity !== void 0);
+    return activities;
+  }
+  get activityIds() {
+    let addedActivityIds = this.getStorageProperty(`addedActivityIds`) || [];
+    return this.defaultActivityIds.concat(addedActivityIds);
+  }
+  get activities() {
+    let activities = this.activityIds.map((id) => {
+      return this.getActivity(id);
+    }).filter((activity) => activity !== void 0);
+    return activities;
+  }
+  getActivityMemory(id) {
+    let roomMemories = this.getStorageProperty("activities_memory") || {};
+    let roomMemory = roomMemories[id] || {};
+    return roomMemory;
+  }
+  getActivity(id) {
+    if (!this.activityIds.includes(id)) {
+      console.error(`[NQTR] Activity with id ${id} not found in room ${this.id}`);
+      return void 0;
+    }
+    let activity = getActivityById(id);
+    if (!activity) {
+      console.error(`[NQTR] Activity with id ${id} not found`);
+      return void 0;
+    }
+    let roomMemories = this.getStorageProperty("activities_memory") || {};
+    let roomMemory = roomMemories[id] || {};
+    roomMemory = __spreadValues(__spreadValues({}, activity.export()), roomMemory);
+    return new ActivityRoom(id, this, activity.onRun, roomMemory);
+  }
+  setActivity(activity) {
+    let roomMemories = this.getStorageProperty("activities_memory") || {};
+    roomMemories[activity.id] = activity.export();
+    this.setStorageProperty("activities_memory", roomMemories);
+  }
+  addActivity(activity) {
+    if (this.activityIds.includes(activity.id)) {
+      let currentActivity = this.getActivity(activity.id);
+      if (currentActivity && currentActivity.isExpired()) {
+        this.removeActivity(activity.id);
+        return;
+      } else {
+        console.error(`[NQTR] Activity with id ${activity.id} already exists in room ${this.id}, so it will be ignored.`);
+        return;
+      }
+    }
+    let addedActivityIds = this.getStorageProperty(`addedActivityIds`) || [];
+    addedActivityIds.push(activity.id);
+    this.setStorageProperty("addedActivityIds", addedActivityIds);
+  }
+  removeActivity(activity) {
+    let activityId = typeof activity === "string" ? activity : activity.id;
+    if (this.defaultActivityIds.includes(activityId)) {
+      console.warn(`[NQTR] Activity with id ${activityId} is a default activity, so it can't be removed. It will be hidden instead.`);
+      let activityToEdit = this.getActivity(activityId);
+      if (!activityToEdit) {
+        console.error(`[NQTR] Activity with id ${activityId} not found, so it can't be hidden.`);
+        return;
+      }
+      activityToEdit.hidden = true;
+      return;
+    }
+    let addedActivityIds = this.getStorageProperty(`addedActivityIds`) || [];
+    let index = addedActivityIds.indexOf(activityId);
+    if (index === -1) {
+      console.error(`[NQTR] Activity with id ${activityId} not found, so it can't be removed.`);
+      return;
+    }
+    addedActivityIds.splice(index, 1);
+    this.setStorageProperty("addedActivityIds", addedActivityIds);
+    let roomMemories = this.getStorageProperty("activities_memory") || {};
+    delete roomMemories[activityId];
+    this.setStorageProperty("activities_memory", roomMemories);
+  }
+  clearExpiredActivities() {
+    this.activities.forEach((activity) => {
+      if (activity.isExpired()) {
+        this.removeActivity(activity.id);
+      }
+    });
+  }
+  get disabled() {
+    let value = this.getStorageProperty("disabled") || this.defaultDisabled;
+    if (typeof value === "string") {
+      return getFlag4(value);
+    }
+    return value;
+  }
+  set disabled(value) {
+    this.setStorageProperty("disabled", value);
+  }
+  get hidden() {
+    let value = this.getStorageProperty("hidden") || this.defaultHidden;
+    if (typeof value === "string") {
+      return getFlag4(value);
+    }
+    return value;
+  }
+  set hidden(value) {
+    this.setStorageProperty("hidden", value);
+  }
+  get iconElement() {
+    return this._iconElement;
+  }
+  getRoutine() {
+    let commitments = getCurrentCommitments();
+    return commitments.filter((c) => c.room.id === this.id);
+  }
+};
+
+// src/classes/quest/Goal.ts
+var Goal = class {
+  constructor(props) {
+    this._description = props.description;
+    this.need = props.need || 1;
+    this.have = props.have || 0;
+  }
+  get description() {
+    return this._description;
+  }
+  get isComplete() {
+    return this.have >= this.need;
+  }
+  setComplete() {
+    this.have = this.need;
+  }
+  find() {
+    this.have++;
+  }
+  get export() {
+    return {
+      description: this.description,
+      need: this.need,
+      have: this.have
+    };
+  }
+};
+
+// src/classes/quest/Quest.ts
+import { StoredClassModel as StoredClassModel4 } from "@drincs/pixi-vn";
+var QUEST_CATEGORY = "__nqtr-quest__";
+var QuestBaseModel = class extends StoredClassModel4 {
+  constructor(id, stages, props) {
+    super(QUEST_CATEGORY, id);
+    this._stages = stages;
+    this._name = props.name || "";
+    this._description = props.description || "";
+    this._icon = props.icon || "";
+    this._image = props.image || "";
+    this._isInDevelopment = props.isInDevelopment || false;
+  }
+  get stages() {
+    return this._stages;
+  }
+  get name() {
+    return this._name;
+  }
+  get description() {
+    return this._description;
+  }
+  get icon() {
+    return this._icon;
+  }
+  get image() {
+    return this._image;
+  }
+  get isInDevelopment() {
+    return this._isInDevelopment;
+  }
+};
+
+// src/classes/quest/Stage.ts
+import { StoredClassModel as StoredClassModel5 } from "@drincs/pixi-vn";
+var STAGE_CATEGORY = "__nqtr-stage__";
+var StageBaseModel = class extends StoredClassModel5 {
+  constructor(id, props) {
+    super(STAGE_CATEGORY, id);
+    this._completed = false;
+    this._active = false;
+    this.defaultGoals = [];
+    this._name = props.name || "";
+    this._description = props.description || "";
+    this._adviceDescription = props.adviceDescription || "";
+    this._image = props.image || "";
+    this._daysRequiredToStart = props.daysRequiredToStart;
+    this._flagsRequired = props.flagsRequired;
+    this._questsRequired = props.questsRequired;
+    this._requestDescription = props.requestDescription || "";
+    this._onStart = props.onStart;
+    this._onEnd = props.onEnd;
+  }
+  get completed() {
+    return this._completed;
+  }
+  get active() {
+    return this._active;
+  }
+  get goals() {
+    let list = this.getStorageProperty("goals");
+    if (!list) {
+      return this.defaultGoals;
+    }
+    return list.map((goal) => new Goal(goal));
+  }
+  set goals(value) {
+    let list = value.map((goal) => goal.export);
+    this.setStorageProperty("goals", list);
+  }
+  get name() {
+    return this._name;
+  }
+  get description() {
+    return this._description;
+  }
+  get adviceDescription() {
+    return this._adviceDescription;
+  }
+  get image() {
+    return this._image;
+  }
+  get daysRequiredToStart() {
+    return this._daysRequiredToStart;
+  }
+  get flagsRequired() {
+    return this._flagsRequired;
+  }
+  get questsRequired() {
+    return this._questsRequired;
+  }
+  get requestDescription() {
+    return this._requestDescription;
+  }
+  get onStart() {
+    return this._onStart;
+  }
+  get onEnd() {
+    return this._onEnd;
+  }
+};
+
+// src/enums/ExecutionTypeEnum.ts
+var ExecutionTypeEnum = /* @__PURE__ */ ((ExecutionTypeEnum2) => {
+  ExecutionTypeEnum2["AUTOMATIC"] = "automatic";
+  ExecutionTypeEnum2["INTERACTION"] = "interaction";
+  return ExecutionTypeEnum2;
+})(ExecutionTypeEnum || {});
+
+// src/functions/NavigationFunctions.ts
+import { GameStorageManager as GameStorageManager3 } from "@drincs/pixi-vn";
+var CURRENT_ROOM_MEMORY_KEY = "___nqtr-current_room_memory___";
+function setCurrentRoom(room) {
+  let roomRegistrated = getRoomById(room.id);
+  if (!roomRegistrated) {
+    console.error(`[NQTR] The room ${room.id} is not registered, so it can't be set as current room`);
+    return;
+  }
+  localStorage.setItem(CURRENT_ROOM_MEMORY_KEY, room.id);
+}
+function getCurrentRoom() {
+  let roomId = GameStorageManager3.getVariable(CURRENT_ROOM_MEMORY_KEY);
+  if (!roomId) {
+    console.error(`[NQTR] The current room has not yet been set`);
+    return;
+  }
+  let room = getRoomById(roomId);
+  if (!room) {
+    console.error(`[NQTR] Current room ${roomId} not found`);
+    return;
+  }
+  return room;
+}
+function getCurrenrLocation() {
+  let room = getCurrentRoom();
+  if (!room) {
+    return;
+  }
+  return room.location;
+}
+function getCueerntMap() {
+  let location = getCurrenrLocation();
+  if (!location) {
+    return;
+  }
+  return location.map;
+}
+
+// src/functions/ActivityFunctions.ts
+function clearExpiredActivities() {
+  Object.entries(registeredRooms).forEach(([_, room]) => {
+    room.clearExpiredActivities();
+  });
+}
+function currentActivities() {
+  let currentRoom = getCurrentRoom();
+  if (!currentRoom) {
+    return [];
+  }
+  return currentRoom.activities.filter((activity) => !activity.hidden);
+}
+export {
+  ActivityModel,
+  ExecutionTypeEnum,
+  TimeManager as GameStepManager,
+  Goal,
+  LocationBaseModel,
+  MapBaseModel,
+  QuestBaseModel,
+  RoomBaseModel,
+  StageBaseModel,
+  addTemporaryCommitment,
+  clearExpiredActivities,
+  clearExpiredRoutine,
+  currentActivities,
+  getActivityById,
+  getCommitmentByCharacter,
+  getCommitmentById,
+  getCueerntMap,
+  getCurrenrLocation,
+  getCurrentCommitments,
+  getCurrentRoom,
+  getFixedCommitments,
+  getRoomById,
+  getTemporaryCommitments,
+  saveActivity,
+  saveCommitment,
+  saveRoom,
+  setCurrentRoom,
+  setFixedCommitments
+};
+//# sourceMappingURL=index.mjs.map