@drincs/pixi-vn 0.6.0 → 0.6.2

package/dist/managers/StepManager.mjs

@@ -27,8 +27,7 @@ var __decorateClass = (decorators, target, key, kind) => {
   for (var i = decorators.length - 1, decorator; i >= 0; i--)
     if (decorator = decorators[i])
       result = (kind ? decorator(target, key, result) : decorator(result)) || result;
-  if (kind && result)
-    __defProp(target, key, result);
+  if (kind && result) __defProp(target, key, result);
   return result;
 };
 var __async = (__this, __arguments, generator) => {
@@ -74,7 +73,7 @@ var Label = class {
     this._choiseIndex = choiseIndex;
   }
   /**
-   * Get the id of the label
+   * Get the id of the label. This variable is used in the system to get the label by id, {@link getLabelById}
    */
   get id() {
     return this._id;
@@ -232,26 +231,35 @@ var GameStorageManager = _GameStorageManager;
 var TickerBase = class {
   /**
    * @param args The arguments that you want to pass to the ticker.
-   * @param duration The duration of the ticker. If is undefined, the ticker will be called every frame.
-   * @param priority The priority of the ticker. If is undefined, the priority will be UPDATE_PRIORITY.NORMAL.
+   * @param duration The duration of the ticker in seconds. If is undefined, the step will end only when the animation is finished (if the animation doesn't have a goal to reach then it won't finish). @default undefined
+   * @param priority The priority of the ticker. @default UPDATE_PRIORITY.NORMAL
    */
   constructor(args, duration, priority) {
+    /**
+     * Get the id of the ticker. This variable is used in the system to get the ticker by id, {@link geTickerInstanceById}
+     */
+    this.id = "ticker_id_not_set";
     this.args = args;
     this.duration = duration;
     this.priority = priority;
+    this.id = this.constructor.prototype.id;
   }
   /**
    * The method that will be called every frame.
    * This method should be overridden and you can use GameWindowManager.addCanvasElement() to get the canvas element of the canvas, and edit them.
-   * @param t The ticker that is calling this method
-   * @param args The arguments that you passed when you added the ticker
-   * @param tags The tags of the canvas elements that are connected to this ticker
+   * @param _ticker The ticker that is calling this method
+   * @param _args The arguments that you passed when you added the ticker
+   * @param _tags The tags of the canvas elements that are connected to this ticker
+   * @param _tickerId The id of the ticker. You can use this to get the ticker from the {@link GameWindowManager.currentTickers}
    */
-  fn(_t, _args, _tags) {
+  fn(_ticker, _args, _tags, _tickerId) {
     throw new Error("[Pixi'VN] The method TickerBase.fn() must be overridden");
   }
 };
 
+// src/constants.ts
+var Repeat = "repeat";
+
 // src/decorators/TickerDecorator.ts
 var registeredTickers = {};
 function tickerDecorator(name) {
@@ -260,25 +268,32 @@ function tickerDecorator(name) {
       name = target.name;
     }
     if (registeredTickers[name]) {
-      console.warn(`[Pixi'VN] Ticker ${name} already exists, it will be overwritten`);
+      console.info(`[Pixi'VN] Ticker ${name} already exists, it will be overwritten`);
     }
+    target.prototype.id = name;
     registeredTickers[name] = target;
   };
 }
-function geTickerInstanceByClassName(tickerName, args, duration, priority) {
+function geTickerInstanceById(tickerId, args, duration, priority) {
   try {
-    let ticker = registeredTickers[tickerName];
+    let ticker = registeredTickers[tickerId];
     if (!ticker) {
-      console.error(`[Pixi'VN] Ticker ${tickerName} not found`);
+      console.error(`[Pixi'VN] Ticker ${tickerId} not found`);
       return;
     }
     return new ticker(args, duration, priority);
   } catch (e) {
-    console.error(`[Pixi'VN] Error while getting Ticker ${tickerName}`, e);
+    console.error(`[Pixi'VN] Error while getting Ticker ${tickerId}`, e);
     return;
   }
 }
+var CANVAS_CONTAINER_ID = "CanvasContainer";
 var CanvasContainer = class extends Container {
+  constructor(options) {
+    super(options);
+    this.pixivnId = CANVAS_CONTAINER_ID;
+    this.pixivnId = this.constructor.prototype.pixivnId;
+  }
   get memory() {
     let memory = getMemoryContainer(this);
     this.children.forEach((child) => {
@@ -294,8 +309,12 @@ var CanvasContainer = class extends Container {
   }
 };
 function getMemoryContainer(element) {
+  let className = "CanvasContainer";
+  if (element.hasOwnProperty("pixivnId")) {
+    className = element.pixivnId;
+  }
   return {
-    className: "CanvasContainer",
+    pixivnId: className,
     elements: [],
     width: element.width,
     height: element.height,
@@ -411,40 +430,43 @@ function getTextStyle(style) {
 
 // src/decorators/EventDecorator.ts
 var registeredEvents = {};
-function getEventTypeByClassName(eventName) {
+function getEventTypeById(eventId) {
   try {
-    let eventType = registeredEvents[eventName];
+    let eventType = registeredEvents[eventId];
     if (!eventType) {
-      console.error(`[Pixi'VN] Event ${eventName} not found`);
+      console.error(`[Pixi'VN] Event ${eventId} not found`);
       return;
     }
     new eventType();
     return eventType;
   } catch (e) {
-    console.error(`[Pixi'VN] Error while getting Event ${eventName}`, e);
+    console.error(`[Pixi'VN] Error while getting Event ${eventId}`, e);
     return;
   }
 }
-function getEventInstanceByClassName(eventName) {
+function getEventInstanceById(eventId) {
   try {
-    let eventType = registeredEvents[eventName];
+    let eventType = registeredEvents[eventId];
     if (!eventType) {
-      console.error(`[Pixi'VN] Event ${eventName} not found`);
+      console.error(`[Pixi'VN] Event ${eventId} not found`);
       return;
     }
     let event = new eventType();
     return event;
   } catch (e) {
-    console.error(`[Pixi'VN] Error while getting Event ${eventName}`, e);
+    console.error(`[Pixi'VN] Error while getting Event ${eventId}`, e);
     return;
   }
 }
 
 // src/classes/canvas/CanvasSprite.ts
+var CANVAS_SPRITE_ID = "CanvasSprite";
 var CanvasSprite = class _CanvasSprite extends Sprite {
-  constructor() {
-    super(...arguments);
+  constructor(options) {
+    super(options);
+    this.pixivnId = CANVAS_SPRITE_ID;
     this._onEvents = {};
+    this.pixivnId = this.constructor.prototype.pixivnId;
   }
   get memory() {
     return getMemorySprite(this);
@@ -485,9 +507,9 @@ var CanvasSprite = class _CanvasSprite extends Sprite {
    * ```
    */
   onEvent(event, eventClass) {
-    let className = eventClass.name;
-    let instance = getEventInstanceByClassName(className);
-    this._onEvents[event] = className;
+    let id = eventClass.prototype.id;
+    let instance = getEventInstanceById(id);
+    this._onEvents[event] = id;
     if (instance) {
       super.on(event, () => {
         instance.fn(event, this);
@@ -516,7 +538,7 @@ var CanvasSprite = class _CanvasSprite extends Sprite {
 function getMemorySprite(element) {
   let temp = getMemoryContainer(element);
   return __spreadProps(__spreadValues({}, temp), {
-    className: "CanvasSprite",
+    pixivnId: element.pixivnId,
     textureImage: getTextureMemory(element.texture),
     anchor: { x: element.anchor.x, y: element.anchor.y },
     roundPixels: element.roundPixels,
@@ -539,8 +561,8 @@ function setMemorySprite(element, memory) {
   }
   memory.roundPixels && (element.roundPixels = memory.roundPixels);
   for (let event in memory.onEvents) {
-    let className = memory.onEvents[event];
-    let instance = getEventTypeByClassName(className);
+    let id = memory.onEvents[event];
+    let instance = getEventTypeById(id);
     if (instance) {
       element.onEvent(event, instance);
     }
@@ -548,9 +570,11 @@ function setMemorySprite(element, memory) {
 }
 
 // src/classes/canvas/CanvasImage.ts
+var CANVAS_IMAGE_ID = "CanvasImage";
 var CanvasImage = class _CanvasImage extends CanvasSprite {
   constructor(options, imageLink) {
     super(options);
+    this.pixivnId = CANVAS_IMAGE_ID;
     this.imageLink = "";
     if (imageLink) {
       this.imageLink = imageLink;
@@ -558,12 +582,13 @@ var CanvasImage = class _CanvasImage extends CanvasSprite {
   }
   get memory() {
     return __spreadProps(__spreadValues({}, getMemorySprite(this)), {
-      className: "CanvasImage",
-      textureImage: { image: this.imageLink }
+      pixivnId: this.pixivnId,
+      imageLink: this.imageLink
     });
   }
   set memory(memory) {
     setMemorySprite(this, memory);
+    this.imageLink = memory.imageLink;
   }
   static from(source, skipCache) {
     let sprite = Sprite.from(source, skipCache);
@@ -591,10 +616,13 @@ var CanvasImage = class _CanvasImage extends CanvasSprite {
     });
   }
 };
+var CANVAS_TEXT_ID = "CanvasText";
 var CanvasText = class extends Text {
-  constructor() {
-    super(...arguments);
+  constructor(options) {
+    super(options);
+    this.pixivnId = CANVAS_TEXT_ID;
     this._onEvents = {};
+    this.pixivnId = this.constructor.prototype.pixivnId;
   }
   get memory() {
     return getMemoryText(this);
@@ -635,9 +663,9 @@ var CanvasText = class extends Text {
    * ```
    */
   onEvent(event, eventClass) {
-    let className = eventClass.name;
-    let instance = getEventInstanceByClassName(className);
-    this._onEvents[event] = className;
+    let id = eventClass.prototype.id;
+    let instance = getEventInstanceById(id);
+    this._onEvents[event] = id;
     if (instance) {
       super.on(event, () => {
         instance.fn(event, this);
@@ -660,7 +688,7 @@ var CanvasText = class extends Text {
 function getMemoryText(element) {
   let temp = getMemoryContainer(element);
   return __spreadProps(__spreadValues({}, temp), {
-    className: "CanvasText",
+    pixivnId: element.pixivnId,
     anchor: { x: element.anchor.x, y: element.anchor.y },
     text: element.text,
     resolution: element.resolution,
@@ -683,8 +711,8 @@ function setMemoryText(element, memory) {
   memory.style && (element.style = memory.style);
   memory.roundPixels && (element.roundPixels = memory.roundPixels);
   for (let event in memory.onEvents) {
-    let className = memory.onEvents[event];
-    let instance = getEventTypeByClassName(className);
+    let id = memory.onEvents[event];
+    let instance = getEventTypeById(id);
     if (instance) {
       element.onEvent(event, instance);
     }
@@ -693,28 +721,28 @@ function setMemoryText(element, memory) {
 
 // src/decorators/CanvasElementDecorator.ts
 var registeredCanvasElement = {};
-function getCanvasElementInstanceByClassName(canvasName) {
+function getCanvasElementInstanceById(canvasId) {
   try {
-    let eventType = registeredCanvasElement[canvasName];
+    let eventType = registeredCanvasElement[canvasId];
     if (!eventType) {
-      if (canvasName === "CanvasContainer") {
+      if (canvasId === CANVAS_CONTAINER_ID) {
         eventType = CanvasContainer;
-      } else if (canvasName === "CanvasImage") {
+      } else if (canvasId === CANVAS_IMAGE_ID) {
         eventType = CanvasImage;
-      } else if (canvasName === "CanvasSprite") {
+      } else if (canvasId === CANVAS_SPRITE_ID) {
         eventType = CanvasSprite;
-      } else if (canvasName === "CanvasText") {
+      } else if (canvasId === CANVAS_TEXT_ID) {
         eventType = CanvasText;
       }
     }
     if (!eventType) {
-      console.error(`[Pixi'VN] CanvasElement ${canvasName} not found`);
+      console.error(`[Pixi'VN] CanvasElement ${canvasId} not found`);
       return;
     }
     let canvasElement = new eventType();
     return canvasElement;
   } catch (e) {
-    console.error(`[Pixi'VN] Error while getting CanvasElement ${canvasName}`, e);
+    console.error(`[Pixi'VN] Error while getting CanvasElement ${canvasId}`, e);
     return;
   }
 }
@@ -731,11 +759,11 @@ function exportCanvasElement(element) {
   return element.memory;
 }
 function importCanvasElement(memory) {
-  let element = getCanvasElementInstanceByClassName(memory.className);
+  let element = getCanvasElementInstanceById(memory.pixivnId);
   if (element) {
     element.memory = memory;
   } else {
-    throw new Error("[Pixi'VN] The element " + memory.className + " could not be created");
+    throw new Error("[Pixi'VN] The element " + memory.pixivnId + " could not be created");
   }
   return element;
 }
@@ -751,11 +779,8 @@ function asciiArtLog() {
     `);
 }
 
-// src/types/PauseType.ts
-var PauseValueType = "pause";
-
-// src/types/RepeatType.ts
-var Repeat = "repeat";
+// src/types/ticker/TagToRemoveAfterType.ts
+var tagToRemoveAfter = "tagToRemoveAfter";
 
 // src/managers/WindowManager.ts
 var _GameWindowManager = class _GameWindowManager {
@@ -939,25 +964,25 @@ var _GameWindowManager = class _GameWindowManager {
   /**
    * Remove a canvas element from the canvas.
    * And remove all tickers that are not connected to any canvas element.
-   * @param tag The tag of the canvas element to be removed.
+   * @param tags The tag of the canvas element to be removed.
    * @returns 
    * @example
    * ```typescript
    * GameWindowManager.removeCanvasElement("bunny");
    * ```
    */
-  static removeCanvasElement(tag) {
-    if (typeof tag === "string") {
-      tag = [tag];
+  static removeCanvasElement(tags) {
+    if (typeof tags === "string") {
+      tags = [tags];
     }
-    tag.forEach((t) => {
-      if (_GameWindowManager._children[t]) {
-        _GameWindowManager.app.stage.removeChild(_GameWindowManager._children[t]);
-        delete _GameWindowManager._children[t];
+    tags.forEach((tag) => {
+      if (_GameWindowManager._children[tag]) {
+        _GameWindowManager.app.stage.removeChild(_GameWindowManager._children[tag]);
+        delete _GameWindowManager._children[tag];
+        _GameWindowManager.removeTickerByCanvasElement(tag);
       }
     });
-    _GameWindowManager.removeTickersWithoutAssociatedCanvasElement();
-    _GameWindowManager.childrenTagsOrder = _GameWindowManager.childrenTagsOrder.filter((t) => !tag.includes(t));
+    _GameWindowManager.childrenTagsOrder = _GameWindowManager.childrenTagsOrder.filter((t) => !tags.includes(t));
   }
   /**
    * Get a canvas element by the tag.
@@ -987,18 +1012,43 @@ var _GameWindowManager = class _GameWindowManager {
     _GameWindowManager.app.stage.removeChildren();
     _GameWindowManager._children = {};
     _GameWindowManager.childrenTagsOrder = [];
-    _GameWindowManager.removeTickers();
+    _GameWindowManager.removeAllTickers();
   }
   /**
    * Edit the tag of a canvas element.
    * @param oldTag The old tag of the canvas element.
    * @param newTag The new tag of the canvas element.
    */
-  static editTagCanvasElement(oldTag, newTag) {
+  static editCanvasElementTag(oldTag, newTag) {
     if (_GameWindowManager._children[oldTag]) {
       _GameWindowManager._children[newTag] = _GameWindowManager._children[oldTag];
       delete _GameWindowManager._children[oldTag];
     }
+    if (_GameWindowManager._currentTickersSteps[oldTag]) {
+      _GameWindowManager._currentTickersSteps[newTag] = _GameWindowManager._currentTickersSteps[oldTag];
+      delete _GameWindowManager._currentTickersSteps[oldTag];
+    }
+    for (let id in _GameWindowManager._currentTickers) {
+      let ticker = _GameWindowManager._currentTickers[id];
+      if (ticker.canvasElementTags.includes(oldTag)) {
+        ticker.canvasElementTags = ticker.canvasElementTags.map((t) => t === oldTag ? newTag : t);
+        if (ticker.args.hasOwnProperty(tagToRemoveAfter)) {
+          let tagToRemoveAfter2 = ticker.args.tagToRemoveAfter;
+          if (typeof tagToRemoveAfter2 === "string") {
+            tagToRemoveAfter2 = [tagToRemoveAfter2];
+          }
+          if (Array.isArray(tagToRemoveAfter2)) {
+            ticker.args.tagToRemoveAfter = tagToRemoveAfter2.map((t) => t === oldTag ? newTag : t);
+          }
+        }
+      }
+    }
+    for (let timeout in _GameWindowManager._currentTickersTimeouts) {
+      let TickerTimeout = _GameWindowManager._currentTickersTimeouts[timeout];
+      if (TickerTimeout.tags.includes(oldTag)) {
+        TickerTimeout.tags = TickerTimeout.tags.map((t) => t === oldTag ? newTag : t);
+      }
+    }
   }
   /** Edit Tickers Methods */
   /**
@@ -1007,106 +1057,127 @@ var _GameWindowManager = class _GameWindowManager {
   static get currentTickers() {
     return _GameWindowManager._currentTickers;
   }
+  static get currentTickersList() {
+    return Object.values(_GameWindowManager._currentTickers);
+  }
+  static get currentTickersWithoutCreatedBySteps() {
+    return Object.fromEntries(Object.entries(_GameWindowManager._currentTickers).filter(([_, ticker]) => !ticker.createdByTicketStepsId));
+  }
   /**
    * The steps of the tickers
    */
   static get currentTickersSteps() {
     return _GameWindowManager._currentTickersSteps;
   }
+  static generateTickerId(tickerData) {
+    try {
+      return sha1(JSON.stringify(tickerData)).toString() + "_" + Math.random().toString(36).substring(7);
+    } catch (e) {
+      throw new Error(`[Pixi'VN] Error to generate ticker id: ${e}`);
+    }
+  }
   /**
-   * Run a ticker.
+   * Run a ticker. You can run multiple addTicker with the same tag and different tickerClasses.
+   * If you run a ticker with the same tag and tickerClass, the old ticker will be removed.
+   * If already exists a sequence of tickers with the same tag, it will be removed.
    * @param canvasEslementTag The tag of the canvas element that will use the ticker.
    * @param ticker The ticker class to be run.
    * @param args The arguments to be used in the ticker.
-   * @param duration The time to be used in the ticker. This number is in milliseconds. If it is undefined, the ticker will run forever.
+   * @param duration The time to be used in the ticker. This number is in seconds. If it is undefined, the ticker will run forever.
    * @param priority The priority to be used in the ticker.
    * @returns 
    * @example
    * ```typescript
-   * GameWindowManager.addTicker("alien", new TickerRotate({ speed: 0.2 }))
+   * GameWindowManager.addTicker("alien", new RotateTicker({ speed: 0.2 }))
    * ```
    */
   static addTicker(canvasElementTag, ticker) {
-    let tickerName = ticker.constructor.name;
+    let tickerId = ticker.id;
     if (typeof canvasElementTag === "string") {
       canvasElementTag = [canvasElementTag];
     }
-    let t = geTickerInstanceByClassName(tickerName, ticker.args, ticker.duration, ticker.priority);
-    if (!t) {
-      console.error(`[Pixi'VN] Ticker ${tickerName} not found`);
+    if (!geTickerInstanceById(tickerId, ticker.args, ticker.duration, ticker.priority)) {
+      console.error(`[Pixi'VN] Ticker ${tickerId} not found`);
       return;
     }
-    _GameWindowManager.removeAssociationBetweenTickerCanvasElement(canvasElementTag, ticker);
     let tickerHistory = {
       fn: () => {
       },
-      className: tickerName,
-      args: ticker.args,
+      id: tickerId,
+      args: createExportableElement(ticker.args),
       canvasElementTags: canvasElementTag,
       priority: ticker.priority,
       duration: ticker.duration
     };
-    _GameWindowManager.pushTicker(tickerHistory, t);
-    _GameWindowManager.removeTickersWithoutAssociatedCanvasElement();
+    let id = _GameWindowManager.generateTickerId(tickerHistory);
+    _GameWindowManager.pushTicker(id, tickerHistory, ticker);
     if (ticker.duration) {
       let timeout = setTimeout(() => {
         _GameWindowManager.removeTickerTimeoutInfo(timeout);
-        _GameWindowManager.nextTickerStep(canvasElementTag);
-      }, ticker.duration);
-      _GameWindowManager.addTickerTimeoutInfo(canvasElementTag, tickerName, timeout.toString());
+        let tickerTimeoutInfo = _GameWindowManager._currentTickersTimeouts[timeout.toString()];
+        if (tickerTimeoutInfo) {
+          _GameWindowManager.removeTicker(id);
+        }
+      }, ticker.duration * 1e3);
+      _GameWindowManager.addTickerTimeoutInfo(canvasElementTag, tickerId, timeout.toString(), true);
     }
   }
-  static pushTicker(tickerData, ticker) {
-    _GameWindowManager.removeAssociationBetweenTickerCanvasElement(tickerData.canvasElementTags, tickerData);
-    _GameWindowManager._currentTickers.push(tickerData);
+  static pushTicker(id, tickerData, ticker) {
+    _GameWindowManager.removeAssociationBetweenTickerCanvasElement(tickerData.canvasElementTags, ticker);
+    _GameWindowManager._currentTickers[id] = tickerData;
     tickerData.fn = (t) => {
-      ticker == null ? void 0 : ticker.fn(t, tickerData.args, tickerData.canvasElementTags);
+      let data = _GameWindowManager._currentTickers[id];
+      if (data) {
+        ticker == null ? void 0 : ticker.fn(t, data.args, data.canvasElementTags, id);
+      }
     };
     _GameWindowManager.app.ticker.add(tickerData.fn, void 0, tickerData.priority);
   }
   /**
-   * Run a sequence of tickers.
+   * Run a sequence of tickers. If exists a ticker steps with the same tag, it will be removed.
    * @param tag The tag of canvas element that will use the tickers.
    * @param steps The steps of the tickers.
+   * @param currentStepNumber The current step number. It is used to continue the sequence of tickers.
    * @returns
    * @example
    * ```typescript
    * GameWindowManager.addTickersSteps("alien", [
-   *     new TickerRotate({ speed: 0.1, clockwise: true }, 2000),
-   *     Pause(500),
-   *     new TickerRotate({ speed: 0.2, clockwise: false }, 2000),
+   *     new RotateTicker({ speed: 0.1, clockwise: true }, 2), // 2 seconds
+   *     Pause(1), // 1 second
+   *     new RotateTicker({ speed: 0.2, clockwise: false }, 2),
    *     Repeat,
    * ])
    * ```
    */
-  static addTickersSteps(tag, steps) {
+  static addTickersSteps(tag, steps, currentStepNumber = 0) {
     if (steps.length == 0) {
       console.warn("[Pixi'VN] The steps of the tickers is empty");
       return;
     }
-    let alredyExists = _GameWindowManager._currentTickersSteps[tag] !== void 0;
+    _GameWindowManager.removeTickerStepByCanvasElement(tag);
     _GameWindowManager._currentTickersSteps[tag] = {
-      currentStepNumber: 0,
-      steps: steps.map((s) => {
-        if (s === Repeat) {
-          return s;
-        }
-        if (!s.duration) {
-          console.warn("[Pixi'VN] Duration is not defined, so it will be set to 1000");
-          s.duration = 1e3;
+      currentStepNumber,
+      steps: steps.map((step) => {
+        if (step === Repeat) {
+          return step;
         }
-        if (s.hasOwnProperty("type") && s.type === PauseValueType) {
-          return s;
+        if (step.hasOwnProperty("type") && step.type === "pause") {
+          return step;
         }
-        let tickerName = s.constructor.name;
+        let tickerId = step.id;
         return {
-          ticker: tickerName,
-          args: s.args,
-          duration: s.duration
+          ticker: tickerId,
+          args: createExportableElement(step.args),
+          duration: step.duration
         };
       })
     };
-    if (!alredyExists) {
+    _GameWindowManager.runTickersSteps(tag);
+  }
+  static restoneTickersSteps(data) {
+    for (let tag in data) {
+      let steps = data[tag];
+      _GameWindowManager._currentTickersSteps[tag] = steps;
       _GameWindowManager.runTickersSteps(tag);
     }
   }
@@ -1120,70 +1191,106 @@ var _GameWindowManager = class _GameWindowManager {
         return;
       }
     }
-    if (step.hasOwnProperty("type") && step.type === PauseValueType) {
+    if (step.hasOwnProperty("type") && step.type === "pause") {
       let timeout = setTimeout(() => {
+        let tickerTimeoutInfo = _GameWindowManager._currentTickersTimeouts[timeout.toString()];
+        if (tickerTimeoutInfo) {
+          tickerTimeoutInfo.tags.forEach((tag2) => {
+            _GameWindowManager.nextTickerStep(tag2);
+          });
+        }
         _GameWindowManager.removeTickerTimeoutInfo(timeout);
-        _GameWindowManager.nextTickerStep(tag);
-      }, step.duration);
-      _GameWindowManager.addTickerTimeoutInfo(tag, "steps", timeout.toString());
+      }, step.duration * 1e3);
+      _GameWindowManager.addTickerTimeoutInfo(tag, "steps", timeout.toString(), false);
       return;
     }
-    let ticker = geTickerInstanceByClassName(step.ticker, step.args, step.duration, step.priority);
+    let ticker = geTickerInstanceById(step.ticker, step.args, step.duration, step.priority);
     if (!ticker) {
       console.error(`[Pixi'VN] Ticker ${step.ticker} not found`);
       return;
     }
-    _GameWindowManager.addTicker(tag, ticker);
+    let tickerName = ticker.id;
+    let tickerHistory = {
+      fn: () => {
+      },
+      id: tickerName,
+      args: createExportableElement(ticker.args),
+      canvasElementTags: [tag],
+      priority: ticker.priority,
+      duration: ticker.duration,
+      createdByTicketStepsId: tag
+    };
+    let id = _GameWindowManager.generateTickerId(tickerHistory);
+    _GameWindowManager.pushTicker(id, tickerHistory, ticker);
+    if (ticker.duration) {
+      let timeout = setTimeout(() => {
+        let tickerTimeoutInfo = _GameWindowManager._currentTickersTimeouts[timeout.toString()];
+        if (tickerTimeoutInfo) {
+          _GameWindowManager.removeTicker(id);
+          tickerTimeoutInfo.tags.forEach((tag2) => {
+            _GameWindowManager.nextTickerStep(tag2);
+          });
+        }
+        _GameWindowManager.removeTickerTimeoutInfo(timeout);
+      }, ticker.duration * 1e3);
+      _GameWindowManager.addTickerTimeoutInfo(tag, tickerName, timeout.toString(), false);
+    }
   }
   static nextTickerStep(tag) {
-    if (typeof tag === "string") {
-      tag = [tag];
+    if (_GameWindowManager._currentTickersSteps[tag]) {
+      let steps = _GameWindowManager._currentTickersSteps[tag];
+      if (steps.currentStepNumber + 1 < steps.steps.length) {
+        steps.currentStepNumber++;
+        _GameWindowManager._currentTickersSteps[tag] = steps;
+        _GameWindowManager.runTickersSteps(tag);
+      } else {
+        _GameWindowManager.removeTickerStepByCanvasElement(tag);
+      }
     }
-    tag.forEach((tag2) => {
-      if (_GameWindowManager._currentTickersSteps[tag2]) {
-        let steps = _GameWindowManager._currentTickersSteps[tag2];
-        if (steps.currentStepNumber + 1 < steps.steps.length) {
-          steps.currentStepNumber++;
-          _GameWindowManager._currentTickersSteps[tag2] = steps;
-          _GameWindowManager.runTickersSteps(tag2);
-        } else {
-          delete _GameWindowManager._currentTickersSteps[tag2];
-        }
+  }
+  static onEndOfTicker(canvasElementTags, ticker, canvasElementTagsToDelete, tickerId) {
+    let tickerData = _GameWindowManager._currentTickers[tickerId];
+    _GameWindowManager.removeAssociationBetweenTickerCanvasElement(canvasElementTags, ticker);
+    _GameWindowManager.removeCanvasElement(canvasElementTagsToDelete);
+    if (tickerData) {
+      _GameWindowManager.removeTicker(tickerId);
+      if (tickerData.duration == void 0 && tickerData.createdByTicketStepsId) {
+        _GameWindowManager.nextTickerStep(tickerData.createdByTicketStepsId);
       }
-    });
+    }
   }
   /**
    * Remove a connection between a canvas element and a ticker.
    * And remove the ticker if there is no canvas element connected to it.
-   * @param tag The tag of the canvas element that will use the ticker.
+   * @param tags The tag of the canvas element that will use the ticker.
    * @param ticker The ticker class to be removed.
    * @example
    * ```typescript
-   * GameWindowManager.removeAssociationBetweenTickerCanvasElement("alien", TickerRotate)
+   * GameWindowManager.removeAssociationBetweenTickerCanvasElement("alien", RotateTicker)
    * ```
    */
-  static removeAssociationBetweenTickerCanvasElement(tag, ticker) {
-    let tickerName;
-    if (ticker instanceof TickerBase) {
-      tickerName = ticker.constructor.name;
+  static removeAssociationBetweenTickerCanvasElement(tags, ticker) {
+    let tickerId;
+    if (typeof ticker === "string") {
+      tickerId = ticker;
+    } else if (ticker instanceof TickerBase) {
+      tickerId = ticker.id;
     } else {
-      tickerName = ticker.name;
+      tickerId = ticker.prototype.id;
     }
-    if (typeof tag === "string") {
-      tag = [tag];
+    if (typeof tags === "string") {
+      tags = [tags];
     }
-    _GameWindowManager._currentTickers = _GameWindowManager._currentTickers.map((t) => {
-      if (t.className === tickerName) {
-        t.canvasElementTags = t.canvasElementTags.filter((e) => !tag.includes(e));
+    for (let id in _GameWindowManager._currentTickers) {
+      let ticker2 = _GameWindowManager._currentTickers[id];
+      if (ticker2.id === tickerId) {
+        _GameWindowManager._currentTickers[id].canvasElementTags = ticker2.canvasElementTags.filter((e) => !tags.includes(e));
       }
-      return t;
-    });
-    for (let timeout in _GameWindowManager.currentTickersTimeouts) {
-      let t = _GameWindowManager.currentTickersTimeouts[timeout].tags.filter((e) => !tag.includes(e));
-      if (t.length == 0) {
-        _GameWindowManager.removeTickerTimeoutInfo(timeout);
-      } else {
-        _GameWindowManager.currentTickersTimeouts[timeout].tags = t;
+    }
+    for (let timeout in _GameWindowManager._currentTickersTimeouts) {
+      let TickerTimeout = _GameWindowManager._currentTickersTimeouts[timeout];
+      if (TickerTimeout.ticker === tickerId && TickerTimeout.canBeDeletedBeforeEnd) {
+        _GameWindowManager._currentTickersTimeouts[timeout].tags = TickerTimeout.tags.filter((t) => !tags.includes(t));
       }
     }
     _GameWindowManager.removeTickersWithoutAssociatedCanvasElement();
@@ -1192,49 +1299,117 @@ var _GameWindowManager = class _GameWindowManager {
    * Remove all tickers that are not connected to any existing canvas element.
    */
   static removeTickersWithoutAssociatedCanvasElement() {
-    let currentTickers = _GameWindowManager._currentTickers.map((t) => {
-      t.canvasElementTags = t.canvasElementTags.filter((e) => _GameWindowManager._children[e]);
-      return t;
-    });
-    currentTickers.filter((t) => t.canvasElementTags.length === 0).forEach((t) => {
-      _GameWindowManager.app.ticker.remove(t.fn);
-    });
-    currentTickers = currentTickers.filter((t) => t.canvasElementTags.length > 0);
-    _GameWindowManager._currentTickers = currentTickers;
+    for (let id in _GameWindowManager._currentTickers) {
+      let ticker = _GameWindowManager._currentTickers[id];
+      ticker.canvasElementTags = ticker.canvasElementTags.filter((e) => _GameWindowManager._children[e]);
+      if (ticker.canvasElementTags.length === 0) {
+        _GameWindowManager.removeTicker(id);
+      }
+    }
     for (let tag in _GameWindowManager._currentTickersSteps) {
       if (_GameWindowManager._children[tag] === void 0) {
         delete _GameWindowManager._currentTickersSteps[tag];
       }
     }
+    Object.entries(_GameWindowManager._currentTickersTimeouts).forEach(([timeout, { tags }]) => {
+      if (tags.length === 0) {
+        _GameWindowManager.removeTickerTimeout(timeout);
+      }
+    });
   }
-  static addTickerTimeoutInfo(tags, ticker, timeout) {
+  static addTickerTimeoutInfo(tags, ticker, timeout, canBeDeletedBeforeEnd) {
     if (typeof tags === "string") {
       tags = [tags];
     }
-    _GameWindowManager.currentTickersTimeouts[timeout] = {
+    _GameWindowManager._currentTickersTimeouts[timeout] = {
       tags,
-      ticker
+      ticker,
+      canBeDeletedBeforeEnd
     };
   }
   static removeTickerTimeoutInfo(timeout) {
     if (typeof timeout !== "string") {
       timeout = timeout.toString();
     }
-    if (_GameWindowManager.currentTickersTimeouts[timeout]) {
-      delete _GameWindowManager.currentTickersTimeouts[timeout];
+    if (_GameWindowManager._currentTickersTimeouts[timeout]) {
+      delete _GameWindowManager._currentTickersTimeouts[timeout];
+    }
+  }
+  static removeTickerTimeout(timeout) {
+    if (typeof timeout !== "string") {
+      timeout = timeout.toString();
+    }
+    clearTimeout(Number(timeout));
+    _GameWindowManager.removeTickerTimeoutInfo(timeout);
+  }
+  static removeTickerTimeoutsByTag(tag, checkCanBeDeletedBeforeEnd) {
+    for (let timeout in _GameWindowManager._currentTickersTimeouts) {
+      let tagsWithoutTagToRemove = _GameWindowManager._currentTickersTimeouts[timeout].tags.filter((t) => t !== tag);
+      if (tagsWithoutTagToRemove.length === 0) {
+        let canBeDeletedBeforeEnd = _GameWindowManager._currentTickersTimeouts[timeout].canBeDeletedBeforeEnd;
+        if (!checkCanBeDeletedBeforeEnd || canBeDeletedBeforeEnd) {
+          _GameWindowManager.removeTickerTimeout(timeout);
+        }
+      } else {
+        _GameWindowManager._currentTickersTimeouts[timeout].tags = tagsWithoutTagToRemove;
+      }
     }
   }
   /**
    * Remove all tickers from the canvas.
    */
-  static removeTickers() {
+  static removeAllTickers() {
     _GameWindowManager._currentTickersSteps = {};
-    _GameWindowManager._currentTickers.forEach((t) => {
-      _GameWindowManager.app.ticker.remove(t.fn);
+    Object.keys(_GameWindowManager._currentTickers).forEach((id) => {
+      _GameWindowManager.removeTicker(id);
+    });
+    _GameWindowManager._currentTickers = {};
+    for (let timeout in _GameWindowManager._currentTickersTimeouts) {
+      _GameWindowManager.removeTickerTimeout(timeout);
+    }
+  }
+  /**
+   * Remove all tickers from a canvas element.
+   * @param tag The tag of the canvas element that will use the ticker.
+   */
+  static removeTickerByCanvasElement(tag) {
+    if (typeof tag === "string") {
+      tag = [tag];
+    }
+    tag.forEach((tag2) => {
+      for (let id in _GameWindowManager._currentTickers) {
+        let ticker = _GameWindowManager._currentTickers[id];
+        if (ticker.canvasElementTags.includes(tag2)) {
+          _GameWindowManager.removeTicker(id);
+        }
+      }
+      if (_GameWindowManager._currentTickersSteps[tag2]) {
+        delete _GameWindowManager._currentTickersSteps[tag2];
+      }
+      _GameWindowManager.removeTickerTimeoutsByTag(tag2, false);
+      delete _GameWindowManager._currentTickersSteps[tag2];
     });
-    _GameWindowManager._currentTickers = [];
-    for (let timeout in _GameWindowManager.currentTickersTimeouts) {
-      _GameWindowManager.removeTickerTimeoutInfo(timeout);
+  }
+  static removeTickerStepByCanvasElement(tag) {
+    if (_GameWindowManager._currentTickersSteps[tag]) {
+      delete _GameWindowManager._currentTickersSteps[tag];
+    }
+    for (let id in _GameWindowManager._currentTickers) {
+      let ticker = _GameWindowManager._currentTickers[id];
+      if (ticker.createdByTicketStepsId === tag) {
+        _GameWindowManager.removeTicker(id);
+      }
+    }
+  }
+  static removeTicker(tickerId) {
+    let ticker = _GameWindowManager._currentTickers[tickerId];
+    if (ticker) {
+      if (ticker.args.hasOwnProperty(tagToRemoveAfter)) {
+        let tagToRemoveAfter2 = ticker.args.tagToRemoveAfter;
+        _GameWindowManager.removeCanvasElement(tagToRemoveAfter2);
+      }
+      _GameWindowManager.app.ticker.remove(ticker.fn);
+      delete _GameWindowManager._currentTickers[tickerId];
     }
   }
   /**
@@ -1261,7 +1436,8 @@ var _GameWindowManager = class _GameWindowManager {
       currentElements[tag] = exportCanvasElement(_GameWindowManager._children[tag]);
     }
     return {
-      currentTickers: createExportableElement(_GameWindowManager._currentTickers),
+      currentTickers: createExportableElement(_GameWindowManager.currentTickersWithoutCreatedBySteps),
+      currentTickersSteps: createExportableElement(_GameWindowManager._currentTickersSteps),
       currentElements: createExportableElement(currentElements),
       childrenTagsOrder: createExportableElement(_GameWindowManager.childrenTagsOrder)
     };
@@ -1296,15 +1472,20 @@ var _GameWindowManager = class _GameWindowManager {
       }
       if (data.hasOwnProperty("currentTickers")) {
         let currentTickers = data["currentTickers"];
-        currentTickers.forEach((t) => {
+        for (let id in currentTickers) {
+          let t = currentTickers[id];
           let tags = t.canvasElementTags;
-          let ticker = geTickerInstanceByClassName(t.className, t.args, t.duration, t.priority);
+          let ticker = geTickerInstanceById(t.id, t.args, t.duration, t.priority);
           if (ticker) {
             _GameWindowManager.addTicker(tags, ticker);
           } else {
-            console.error(`[Pixi'VN] Ticker ${t.className} not found`);
+            console.error(`[Pixi'VN] Ticker ${t.id} not found`);
           }
-        });
+        }
+      }
+      if (data.hasOwnProperty("currentTickersSteps")) {
+        let currentTickersSteps = data["currentTickersSteps"];
+        _GameWindowManager.restoneTickersSteps(currentTickersSteps);
       }
     } catch (e) {
       console.error("[Pixi'VN] Error importing data", e);
@@ -1318,11 +1499,14 @@ _GameWindowManager._children = {};
  * The order of the children tags.
  */
 _GameWindowManager.childrenTagsOrder = [];
-_GameWindowManager._currentTickers = [];
+_GameWindowManager._currentTickers = {};
 _GameWindowManager._currentTickersSteps = {};
-_GameWindowManager.currentTickersTimeouts = {};
+_GameWindowManager._currentTickersTimeouts = {};
 var GameWindowManager = _GameWindowManager;
 
+// src/types/CloseType.ts
+var Close = "close";
+
 // src/decorators/LabelDecorator.ts
 var registeredLabels = {};
 function getLabelById(id) {
@@ -1338,20 +1522,43 @@ function getLabelById(id) {
 function getDialogue() {
   return GameStorageManager.getVariable(GameStorageManager.keysSystem.CURRENT_DIALOGUE_MEMORY_KEY);
 }
-var TickerFadeAlpha = class extends TickerBase {
-  /**
-   * The method that will be called every frame to fade the alpha of the canvas element of the canvas.
-   * @param delta The delta time
-   * @param args The arguments that are passed to the ticker
-   * @param tags The tags of the canvas element that are connected to this ticker
-   */
-  fn(t, args, tags) {
+function getChoiceMenuOptions() {
+  let d = GameStorageManager.getVariable(GameStorageManager.keysSystem.CURRENT_MENU_OPTIONS_MEMORY_KEY);
+  if (d) {
+    let options = [];
+    d.forEach((option, index) => {
+      if (option.type === Close) {
+        let itemLabel = newCloseLabel(index);
+        options.push({
+          text: option.text,
+          label: itemLabel,
+          type: Close,
+          closeCurrentLabel: option.closeCurrentLabel,
+          props: {}
+        });
+        return;
+      }
+      let label = getLabelById(option.label);
+      if (label) {
+        let itemLabel = new Label(label.id, label.steps, label.onStepRun, index);
+        options.push(__spreadProps(__spreadValues({}, option), {
+          label: itemLabel
+        }));
+      }
+    });
+    return options;
+  }
+  return void 0;
+}
+var FadeAlphaTicker = class extends TickerBase {
+  fn(ticker, args, tags, tickerId) {
     let type = args.type === void 0 ? "hide" : args.type;
-    let speed = args.speed === void 0 ? 0.1 : args.speed;
+    let duration = args.duration === void 0 ? 1 : args.duration;
+    let speed = 1 / (duration * 60);
     let limit = args.limit === void 0 ? type === "hide" ? 0 : 1 : args.limit;
-    let removeElementAfter = args.tagToRemoveAfter || [];
-    if (typeof removeElementAfter === "string") {
-      removeElementAfter = [removeElementAfter];
+    let tagToRemoveAfter2 = args.tagToRemoveAfter || [];
+    if (typeof tagToRemoveAfter2 === "string") {
+      tagToRemoveAfter2 = [tagToRemoveAfter2];
     }
     if (type === "hide" && limit < 0) {
       limit = 0;
@@ -1372,61 +1579,88 @@ var TickerFadeAlpha = class extends TickerBase {
       let element = GameWindowManager.getCanvasElement(tag);
       if (element && element instanceof Container) {
         if (type === "show" && element.alpha < limit) {
-          element.alpha += speed * t.deltaTime;
+          element.alpha += speed * ticker.deltaTime;
         } else if (type === "hide" && element.alpha > limit) {
-          element.alpha -= speed * t.deltaTime;
-        } else {
+          element.alpha -= speed * ticker.deltaTime;
+        }
+        if (type === "show" && element.alpha >= limit) {
+          element.alpha = limit;
+          GameWindowManager.onEndOfTicker(tag, this, tagToRemoveAfter2, tickerId);
+        } else if (type === "hide" && element.alpha <= limit) {
           element.alpha = limit;
-          GameWindowManager.removeAssociationBetweenTickerCanvasElement(tag, this);
-          GameWindowManager.removeCanvasElement(removeElementAfter);
+          GameWindowManager.onEndOfTicker(tag, this, tagToRemoveAfter2, tickerId);
         }
       }
     });
   }
 };
-TickerFadeAlpha = __decorateClass([
+FadeAlphaTicker = __decorateClass([
   tickerDecorator()
-], TickerFadeAlpha);
+], FadeAlphaTicker);
 
 // src/functions/TickerUtility.ts
 function updateTickerProgression(args, propertyName, progression) {
-  if (args.hasOwnProperty(propertyName) && typeof args[propertyName] !== "number") {
+  if (args[propertyName] === void 0 || !progression || args[propertyName] === progression.limit) {
     return;
   }
-  if (args[propertyName] !== void 0 && progression && args[propertyName] !== progression.limit) {
+  if (typeof args[propertyName] === "number") {
     if (progression.type === "linear") {
-      args[propertyName] += progression.amt;
-      if (progression.limit !== void 0) {
-        if (args[propertyName] > progression.limit && progression.amt > 0) {
-          args[propertyName] = progression.limit;
-        } else if (args[propertyName] < progression.limit && progression.amt < 0) {
-          args[propertyName] = progression.limit;
-        }
-      }
+      args[propertyName] = getLinearProgression(args[propertyName], progression);
     } else if (progression.type === "exponential") {
-      args[propertyName] += args[propertyName] * progression.percentage;
-      if (progression.limit !== void 0) {
-        if (args[propertyName] > progression.limit && progression.percentage > 0) {
-          args[propertyName] = progression.limit;
-        } else if (args[propertyName] < progression.limit && progression.percentage < 0) {
-          args[propertyName] = progression.limit;
-        }
-      }
+      args[propertyName] = getExponentialProgression(args[propertyName], progression);
+    }
+  } else if (args[propertyName] !== void 0 && typeof args[propertyName] === "object" && args[propertyName].haveOwnProperty("x") && args[propertyName].haveOwnProperty("y") && typeof args[propertyName].x === "number" && typeof args[propertyName].y === "number") {
+    if (progression.type === "linear") {
+      args[propertyName].x = getLinearProgression(args[propertyName].x, progression);
+      args[propertyName].y = getLinearProgression(args[propertyName].y, progression);
+    } else if (progression.type === "exponential") {
+      args[propertyName].x = getExponentialProgression(args[propertyName].x, progression);
+      args[propertyName].y = getExponentialProgression(args[propertyName].y, progression);
     }
   }
 }
+function getLinearProgression(number, progression) {
+  if (progression.limit !== void 0) {
+    if (number > progression.limit && progression.amt > 0) {
+      return progression.limit;
+    } else if (number < progression.limit && progression.amt < 0) {
+      return progression.limit;
+    }
+  }
+  return number + progression.amt / 60;
+}
+function getExponentialProgression(number, progression) {
+  if (progression.limit !== void 0) {
+    if (number > progression.limit && progression.percentage > 0) {
+      return progression.limit;
+    } else if (number < progression.limit && progression.percentage < 0) {
+      return progression.limit;
+    }
+  }
+  return number + number * progression.percentage;
+}
 
-// src/classes/ticker/TickerMove.ts
-var TickerMove = class extends TickerBase {
-  /**
-   * The method that will be called every frame to move the canvas element of the canvas.
-   * @param t The ticker that is calling this method
-   * @param args The arguments that are passed to the ticker
-   * @param tags The tags of the canvas element that are connected to this ticker
-   */
-  fn(t, args, tags) {
-    let speed = args.speed === void 0 ? 0.1 : args.speed;
+// src/classes/ticker/MoveTicker.ts
+var MoveTicker = class extends TickerBase {
+  fn(ticker, args, tags, tickerId) {
+    let xSpeed = 1;
+    let ySpeed = 1;
+    if (args.speed) {
+      if (typeof args.speed === "number") {
+        xSpeed = args.speed;
+        ySpeed = args.speed;
+      } else {
+        xSpeed = args.speed.x;
+        ySpeed = args.speed.y;
+      }
+    }
+    xSpeed /= 60;
+    ySpeed /= 60;
     let destination = args.destination;
+    let tagToRemoveAfter2 = args.tagToRemoveAfter || [];
+    if (typeof tagToRemoveAfter2 === "string") {
+      tagToRemoveAfter2 = [tagToRemoveAfter2];
+    }
     tags.filter((tag) => {
       var _a;
       let element = GameWindowManager.getCanvasElement(tag);
@@ -1439,41 +1673,42 @@ var TickerMove = class extends TickerBase {
     }).forEach((tag) => {
       let element = GameWindowManager.getCanvasElement(tag);
       if (element && element instanceof Container) {
-        let xDistance = destination.x - element.x;
+        let xDistance = destination.x - element.x > 0 ? 1 : -1;
         if (xDistance != 0) {
-          element.x += xDistance / speed * t.deltaTime;
+          element.x += xDistance * xSpeed * ticker.deltaTime;
           let newDistance = destination.x - element.x;
           if (xDistance < 0 && newDistance > 0 || xDistance > 0 && newDistance < 0) {
             element.x = destination.x;
           }
         }
-        let yDistance = destination.y - element.y;
+        let yDistance = destination.y - element.y > 0 ? 1 : -1;
         if (yDistance != 0) {
-          element.y += yDistance / speed * t.deltaTime;
+          element.y += yDistance * ySpeed * ticker.deltaTime;
           let newDistance = destination.y - element.y;
           if (yDistance < 0 && newDistance > 0 || yDistance > 0 && newDistance < 0) {
             element.y = destination.y;
           }
         }
+        if (element.x == destination.x && element.y == destination.y) {
+          GameWindowManager.onEndOfTicker(tag, this, tagToRemoveAfter2, tickerId);
+        }
       }
     });
     if (args.speedProgression)
       updateTickerProgression(args, "speed", args.speedProgression);
   }
 };
-TickerMove = __decorateClass([
+MoveTicker = __decorateClass([
   tickerDecorator()
-], TickerMove);
-var TickerRotate = class extends TickerBase {
-  /**
-   * The method that will be called every frame to rotate the canvas element of the canvas.
-   * @param delta The delta time
-   * @param args The arguments that are passed to the ticker
-   * @param tags The tags of the canvas element that are connected to this ticker
-   */
-  fn(t, args, tags) {
-    let speed = args.speed === void 0 ? 0.1 : args.speed;
+], MoveTicker);
+var RotateTicker = class extends TickerBase {
+  fn(ticker, args, tags, tickerId) {
+    let speed = (args.speed === void 0 ? 1 : args.speed) / 60;
     let clockwise = args.clockwise === void 0 ? true : args.clockwise;
+    let tagToRemoveAfter2 = args.tagToRemoveAfter || [];
+    if (typeof tagToRemoveAfter2 === "string") {
+      tagToRemoveAfter2 = [tagToRemoveAfter2];
+    }
     tags.filter((tag) => {
       var _a;
       let element = GameWindowManager.getCanvasElement(tag);
@@ -1487,18 +1722,111 @@ var TickerRotate = class extends TickerBase {
       let element = GameWindowManager.getCanvasElement(tag);
       if (element && element instanceof Container) {
         if (clockwise)
-          element.rotation += speed * t.deltaTime;
+          element.rotation += speed * ticker.deltaTime;
         else
-          element.rotation -= speed * t.deltaTime;
+          element.rotation -= speed * ticker.deltaTime;
+        if (speed < 1e-5 && !(args.speedProgression && args.speedProgression.type == "linear" && args.speedProgression.amt != 0)) {
+          GameWindowManager.onEndOfTicker(tag, this, tagToRemoveAfter2, tickerId);
+        }
       }
     });
     if (args.speedProgression)
       updateTickerProgression(args, "speed", args.speedProgression);
   }
 };
-TickerRotate = __decorateClass([
+RotateTicker = __decorateClass([
   tickerDecorator()
-], TickerRotate);
+], RotateTicker);
+var ZoomTicker = class extends TickerBase {
+  fn(ticker, args, tags, tickerId) {
+    let xSpeed = 0.1;
+    let ySpeed = 0.1;
+    if (args.speed) {
+      if (typeof args.speed === "number") {
+        xSpeed = args.speed;
+        ySpeed = args.speed;
+      } else {
+        xSpeed = args.speed.x;
+        ySpeed = args.speed.y;
+      }
+    }
+    xSpeed /= 60;
+    ySpeed /= 60;
+    let tagToRemoveAfter2 = args.tagToRemoveAfter || [];
+    if (typeof tagToRemoveAfter2 === "string") {
+      tagToRemoveAfter2 = [tagToRemoveAfter2];
+    }
+    let type = args.type || "zoom";
+    let xLimit = type === "zoom" ? Infinity : 0;
+    let yLimit = type === "zoom" ? Infinity : 0;
+    if (args.limit) {
+      if (typeof args.limit === "number") {
+        xLimit = args.limit;
+        yLimit = args.limit;
+      } else {
+        xLimit = args.limit.x;
+        yLimit = args.limit.y;
+      }
+    }
+    tags.filter((tag) => {
+      var _a;
+      let element = GameWindowManager.getCanvasElement(tag);
+      if (args.startOnlyIfHaveTexture) {
+        if (element && element instanceof Sprite && ((_a = element.texture) == null ? void 0 : _a.label) == "EMPTY") {
+          return false;
+        }
+      }
+      return true;
+    }).forEach((tag) => {
+      let element = GameWindowManager.getCanvasElement(tag);
+      if (element && element instanceof Container) {
+        if (type === "zoom" && (element.scale.x < xLimit || element.scale.y < yLimit)) {
+          element.scale.x += xSpeed * ticker.deltaTime;
+          element.scale.y += ySpeed * ticker.deltaTime;
+        } else if (type === "unzoom" && (element.scale.x > xLimit || element.scale.y > yLimit)) {
+          element.scale.x -= xSpeed * ticker.deltaTime;
+          element.scale.y -= ySpeed * ticker.deltaTime;
+        }
+        if (type === "zoom") {
+          if (element.scale.x > xLimit) {
+            element.scale.x = xLimit;
+          }
+          if (element.scale.y > yLimit) {
+            element.scale.y = yLimit;
+          }
+          if (element.scale.x >= xLimit && element.scale.y >= yLimit) {
+            element.scale.x = xLimit;
+            element.scale.y = yLimit;
+            this.onEndOfTicker(tag, tickerId, element, tagToRemoveAfter2);
+          }
+        } else if (type === "unzoom") {
+          if (element.scale.x < xLimit) {
+            element.scale.x = xLimit;
+          }
+          if (element.scale.y < yLimit) {
+            element.scale.y = yLimit;
+          }
+          if (element.scale.x <= xLimit && element.scale.y <= yLimit) {
+            element.scale.x = xLimit;
+            element.scale.y = yLimit;
+            this.onEndOfTicker(tag, tickerId, element, tagToRemoveAfter2);
+          }
+        }
+        if (xSpeed < 1e-5 && ySpeed < 1e-5 && !(args.speedProgression && args.speedProgression.type == "linear" && args.speedProgression.amt != 0)) {
+          this.onEndOfTicker(tag, tickerId, element, tagToRemoveAfter2);
+        }
+      }
+    });
+    if (args.speedProgression)
+      updateTickerProgression(args, "speed", args.speedProgression);
+  }
+  onEndOfTicker(tag, tickerId, _element, tagToRemoveAfter2) {
+    GameWindowManager.onEndOfTicker(tag, this, tagToRemoveAfter2, tickerId);
+  }
+};
+ZoomTicker = __decorateClass([
+  tickerDecorator()
+], ZoomTicker);
 
 // src/functions/DiffUtility.ts
 function restoreDeepDiffChanges(data, differences) {
@@ -1605,7 +1933,8 @@ var _GameStepManager = class _GameStepManager {
         canvas: {
           childrenTagsOrder: [],
           currentElements: {},
-          currentTickers: []
+          currentTickers: {},
+          currentTickersSteps: {}
         },
         labelIndex: -1,
         openedLabels: []
@@ -1716,6 +2045,13 @@ var _GameStepManager = class _GameStepManager {
     _GameStepManager._openedLabels = _GameStepManager.originalStepData.openedLabels;
   }
   /* Run Methods */
+  static get canGoNext() {
+    let options = getChoiceMenuOptions();
+    if (options && options.length > 0) {
+      return false;
+    }
+    return true;
+  }
   /**
    * Execute the next step and add it to the history.
    * @param props The props to pass to the step.
@@ -1725,7 +2061,7 @@ var _GameStepManager = class _GameStepManager {
    * ```typescript
    *     function nextOnClick() {
    *     setLoading(true)
-   *     GameStepManager.runNextStep(yourParams)
+   *     GameStepManager.goNext(yourParams)
    *         .then((result) => {
    *             setUpdate((p) => p + 1)
    *             setLoading(false)
@@ -1740,8 +2076,12 @@ var _GameStepManager = class _GameStepManager {
    * }
    * ```
    */
-  static runNextStep(props, choiseMade) {
+  static goNext(props, choiseMade) {
     return __async(this, null, function* () {
+      if (!_GameStepManager.canGoNext) {
+        console.warn("[Pixi'VN] The player must make a choice");
+        return;
+      }
       _GameStepManager.increaseCurrentStepIndex();
       return yield _GameStepManager.runCurrentStep(props, choiseMade);
     });
@@ -1772,7 +2112,7 @@ var _GameStepManager = class _GameStepManager {
           return result;
         } else if (_GameStepManager.openedLabels.length > 1) {
           _GameStepManager.closeCurrentLabel();
-          return yield _GameStepManager.runNextStep(props, choiseMade);
+          return yield _GameStepManager.goNext(props, choiseMade);
         } else {
           _GameStepManager.restorLastLabelList();
           console.error("[Pixi'VN] The end of the game is not managed, so the game is blocked. Read this documentation to know how to manage the end of the game: https://pixi-vn.web.app/start/labels.html#how-manage-the-end-of-the-game");
@@ -1816,8 +2156,15 @@ var _GameStepManager = class _GameStepManager {
       }
       try {
         if (labelId === CLOSE_LABEL_ID) {
-          let closeLabel = newCloseLabel(choiseMade);
-          return _GameStepManager.closeChoiceMenu(closeLabel, props);
+          let closeCurrentLabel = newCloseLabel(choiseMade);
+          let choice = {
+            label: closeCurrentLabel,
+            text: "",
+            closeCurrentLabel: false,
+            type: "close",
+            props: {}
+          };
+          return _GameStepManager.closeChoiceMenu(choice, props);
         }
         let tempLabel = getLabelById(labelId);
         if (!tempLabel) {
@@ -1867,8 +2214,15 @@ var _GameStepManager = class _GameStepManager {
       }
       try {
         if (labelId === CLOSE_LABEL_ID) {
-          let closeLabel = newCloseLabel(choiseMade);
-          return _GameStepManager.closeChoiceMenu(closeLabel, props);
+          let closeCurrentLabel = newCloseLabel(choiseMade);
+          let choice = {
+            label: closeCurrentLabel,
+            text: "",
+            closeCurrentLabel: false,
+            type: "close",
+            props: {}
+          };
+          return _GameStepManager.closeChoiceMenu(choice, props);
         }
         let tempLabel = getLabelById(labelId);
         if (!tempLabel) {
@@ -1884,7 +2238,8 @@ var _GameStepManager = class _GameStepManager {
   }
   /**
    * When the player is in a choice menu, can use this function to exit to the choice menu.
-   * @param props The props to pass to the step.
+   * @param choice
+   * @param props
    * @returns StepLabelResultType or undefined.
    * @example
    * ```typescript
@@ -1895,13 +2250,17 @@ var _GameStepManager = class _GameStepManager {
    * })
    * ```
    */
-  static closeChoiceMenu(label, props) {
+  static closeChoiceMenu(choice, props) {
     return __async(this, null, function* () {
+      let label = choice.label;
       let choiseMade = void 0;
       if (typeof label.choiseIndex === "number") {
         choiseMade = label.choiseIndex;
       }
-      return _GameStepManager.runNextStep(props, choiseMade);
+      if (choice.closeCurrentLabel) {
+        _GameStepManager.closeCurrentLabel();
+      }
+      return _GameStepManager.goNext(props, choiseMade);
     });
   }
   /* After Update Methods */