@drincs/pixi-vn 0.6.1 → 0.6.2

package/dist/labels/StartLabel.js

@@ -56,6 +56,20 @@ var __async = (__this, __arguments, generator) => {
     step((generator = generator.apply(__this, __arguments)).next());
   });
 };
+
+// src/classes/CanvasEvent.ts
+var CanvasEvent = class {
+  constructor() {
+    /**
+     * Get the id of the event. This variable is used in the system to get the event by id, {@link getEventInstanceById}
+     */
+    this.id = "event_id_not_set";
+    this.id = this.constructor.prototype.id;
+  }
+  fn(_event, _element) {
+    throw new Error("[Pixi'VN] The method CanvasEvent.fn() must be overridden");
+  }
+};
 function getStepSha1(step) {
   let sha1String = sha1__default.default(step.toString().toLocaleLowerCase());
   return sha1String.toString();
@@ -79,7 +93,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;
@@ -168,17 +182,23 @@ 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;
 }
 
 // src/classes/canvas/CanvasContainer.ts
+var CANVAS_CONTAINER_ID = "CanvasContainer";
 var CanvasContainer = class extends pixi_js.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) => {
@@ -194,8 +214,12 @@ var CanvasContainer = class extends pixi_js.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,
@@ -311,40 +335,55 @@ function getTextStyle(style) {
 
 // src/decorators/EventDecorator.ts
 var registeredEvents = {};
-function getEventTypeByClassName(eventName) {
+function eventDecorator(name) {
+  return function(target) {
+    if (!name) {
+      name = target.name;
+    }
+    if (registeredEvents[name]) {
+      console.info(`[Pixi'VN] Event ${name} already exists, it will be overwritten`);
+    }
+    target.prototype.id = name;
+    registeredEvents[name] = target;
+  };
+}
+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 pixi_js.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);
@@ -385,9 +424,9 @@ var CanvasSprite = class _CanvasSprite extends pixi_js.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);
@@ -416,7 +455,7 @@ var CanvasSprite = class _CanvasSprite extends pixi_js.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,
@@ -439,8 +478,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);
     }
@@ -448,9 +487,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;
@@ -458,12 +499,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 = pixi_js.Sprite.from(source, skipCache);
@@ -491,10 +533,13 @@ var CanvasImage = class _CanvasImage extends CanvasSprite {
     });
   }
 };
+var CANVAS_TEXT_ID = "CanvasText";
 var CanvasText = class extends pixi_js.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);
@@ -535,9 +580,9 @@ var CanvasText = class extends pixi_js.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);
@@ -560,7 +605,7 @@ var CanvasText = class extends pixi_js.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,
@@ -583,8 +628,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);
     }
@@ -593,28 +638,40 @@ function setMemoryText(element, memory) {
 
 // src/decorators/CanvasElementDecorator.ts
 var registeredCanvasElement = {};
-function getCanvasElementInstanceByClassName(canvasName) {
+function canvasElementDecorator(name) {
+  return function(target) {
+    if (!name) {
+      name = target.name;
+    }
+    if (registeredCanvasElement[name]) {
+      console.warn(`[Pixi'VN] CanvasElement ${name} already registered`);
+    }
+    target.prototype.pixivnId = name;
+    registeredCanvasElement[name] = target;
+  };
+}
+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;
   }
 }
@@ -642,19 +699,20 @@ function tickerDecorator(name) {
     if (registeredTickers[name]) {
       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;
   }
 }
@@ -717,21 +775,21 @@ var ChoiceMenuOptionClose = class {
 // src/functions/DialogueUtility.ts
 function setDialogue(props) {
   let text = "";
-  let characterId = void 0;
+  let character = void 0;
   let dialogue;
   if (typeof props === "string") {
     text = props;
-    dialogue = new DialogueBaseModel(text, characterId);
+    dialogue = new DialogueBaseModel(text, character);
   } else if (!(props instanceof DialogueBaseModel)) {
     text = props.text;
     if (props.character) {
       if (typeof props.character === "string") {
-        characterId = props.character;
+        character = props.character;
       } else {
-        characterId = props.character.id;
+        character = props.character.id;
       }
     }
-    dialogue = new DialogueBaseModel(text, characterId);
+    dialogue = new DialogueBaseModel(text, character);
   } else {
     dialogue = props;
   }
@@ -757,6 +815,34 @@ function setChoiceMenuOptions(options) {
   GameStorageManager.setVariable(GameStorageManager.keysSystem.CURRENT_MENU_OPTIONS_MEMORY_KEY, value);
   GameStorageManager.setVariable(GameStorageManager.keysSystem.LAST_MENU_OPTIONS_ADDED_IN_STEP_MEMORY_KEY, GameStepManager.lastStepIndex);
 }
+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;
+}
 
 // src/classes/ticker/TickerBase.ts
 var TickerBase = class {
@@ -766,9 +852,14 @@ var TickerBase = class {
    * @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.
@@ -991,8 +1082,8 @@ var ZoomTicker = class extends TickerBase {
       tagToRemoveAfter2 = [tagToRemoveAfter2];
     }
     let type = args.type || "zoom";
-    let xLimit = Infinity;
-    let yLimit = Infinity;
+    let xLimit = type === "zoom" ? Infinity : 0;
+    let yLimit = type === "zoom" ? Infinity : 0;
     if (args.limit) {
       if (typeof args.limit === "number") {
         xLimit = args.limit;
@@ -1031,7 +1122,7 @@ var ZoomTicker = class extends TickerBase {
           if (element.scale.x >= xLimit && element.scale.y >= yLimit) {
             element.scale.x = xLimit;
             element.scale.y = yLimit;
-            GameWindowManager.onEndOfTicker(tag, this, tagToRemoveAfter2, tickerId);
+            this.onEndOfTicker(tag, tickerId, element, tagToRemoveAfter2);
           }
         } else if (type === "unzoom") {
           if (element.scale.x < xLimit) {
@@ -1043,21 +1134,36 @@ var ZoomTicker = class extends TickerBase {
           if (element.scale.x <= xLimit && element.scale.y <= yLimit) {
             element.scale.x = xLimit;
             element.scale.y = yLimit;
-            GameWindowManager.onEndOfTicker(tag, this, tagToRemoveAfter2, tickerId);
+            this.onEndOfTicker(tag, tickerId, element, tagToRemoveAfter2);
           }
         }
         if (xSpeed < 1e-5 && ySpeed < 1e-5 && !(args.speedProgression && args.speedProgression.type == "linear" && args.speedProgression.amt != 0)) {
-          GameWindowManager.onEndOfTicker(tag, this, tagToRemoveAfter2, tickerId);
+          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);
+var ZoomInOutTicker = class extends ZoomTicker {
+  constructor(props, duration, priority) {
+    super(props, duration, priority);
+  }
+  onEndOfTicker(tag, tickerId, element, tagToRemoveAfter2) {
+    if (element.children.length > 0) {
+      let elementChild = element.children[0];
+      GameWindowManager.addCanvasElement(tag, elementChild);
+    }
+    super.onEndOfTicker(tag, tickerId, element, tagToRemoveAfter2);
+  }
+};
 
 // src/constants.ts
 var Repeat = "repeat";
@@ -1172,6 +1278,147 @@ function showWithFadeTransition(_0, _1) {
 function removeWithFadeTransition(tag, props = {}, priority) {
   return removeWithDissolveTransition(tag, props, priority);
 }
+function moveIn(_0, _1) {
+  return __async(this, arguments, function* (tag, image, props = { direction: "right" }, priority) {
+    var _a;
+    let canvasElement;
+    if (typeof image === "string") {
+      canvasElement = addImage(tag, image);
+    } else {
+      canvasElement = image;
+      GameWindowManager.addCanvasElement(tag, canvasElement);
+    }
+    if (canvasElement instanceof CanvasImage && ((_a = canvasElement.texture) == null ? void 0 : _a.label) == "EMPTY") {
+      yield canvasElement.load();
+    }
+    let destination = { x: canvasElement.x, y: canvasElement.y };
+    if (props.direction == "up") {
+      canvasElement.y = GameWindowManager.canvasHeight + canvasElement.height;
+    } else if (props.direction == "down") {
+      canvasElement.y = -canvasElement.height;
+    } else if (props.direction == "left") {
+      canvasElement.x = GameWindowManager.canvasWidth + canvasElement.width;
+    } else if (props.direction == "right") {
+      canvasElement.x = -canvasElement.width;
+    }
+    let effect = new MoveTicker(__spreadProps(__spreadValues({}, props), {
+      destination,
+      startOnlyIfHaveTexture: true
+    }), priority);
+    GameWindowManager.addTicker(tag, effect);
+  });
+}
+function moveOut(tag, props = { direction: "right" }, priority) {
+  let canvasElement = GameWindowManager.getCanvasElement(tag);
+  if (!canvasElement) {
+    console.warn("[Pixi'VN] The canvas element is not found.");
+    return;
+  }
+  let destination = { x: canvasElement.x, y: canvasElement.y };
+  if (props.direction == "up") {
+    destination.y = -canvasElement.height;
+  } else if (props.direction == "down") {
+    destination.y = GameWindowManager.canvasHeight + canvasElement.height;
+  } else if (props.direction == "left") {
+    destination.x = -canvasElement.width;
+  } else if (props.direction == "right") {
+    destination.x = GameWindowManager.canvasWidth + canvasElement.width;
+  }
+  let effect = new MoveTicker(__spreadProps(__spreadValues({}, props), {
+    destination,
+    startOnlyIfHaveTexture: true,
+    tagToRemoveAfter: tag
+  }), priority);
+  GameWindowManager.addTicker(tag, effect);
+}
+function zoomIn(_0, _1) {
+  return __async(this, arguments, function* (tag, image, props = { direction: "right" }, priority) {
+    var _a;
+    let canvasElement;
+    if (typeof image === "string") {
+      canvasElement = new CanvasImage({}, image);
+    } else {
+      canvasElement = image;
+    }
+    if (canvasElement instanceof CanvasImage && ((_a = canvasElement.texture) == null ? void 0 : _a.label) == "EMPTY") {
+      yield canvasElement.load();
+    }
+    let container = new CanvasContainer();
+    container.addChild(canvasElement);
+    container.height = GameWindowManager.canvasHeight;
+    container.width = GameWindowManager.canvasWidth;
+    GameWindowManager.addCanvasElement(tag, container);
+    if (props.direction == "up") {
+      container.pivot.y = GameWindowManager.canvasHeight;
+      container.pivot.x = GameWindowManager.canvasWidth / 2;
+      container.y = GameWindowManager.canvasHeight;
+      container.x = GameWindowManager.canvasWidth / 2;
+    } else if (props.direction == "down") {
+      container.pivot.y = 0;
+      container.pivot.x = GameWindowManager.canvasWidth / 2;
+      container.y = 0;
+      container.x = GameWindowManager.canvasWidth / 2;
+    } else if (props.direction == "left") {
+      container.pivot.x = GameWindowManager.canvasWidth;
+      container.pivot.y = GameWindowManager.canvasHeight / 2;
+      container.x = GameWindowManager.canvasWidth;
+      container.y = GameWindowManager.canvasHeight / 2;
+    } else if (props.direction == "right") {
+      container.pivot.x = 0;
+      container.pivot.y = GameWindowManager.canvasHeight / 2;
+      container.x = 0;
+      container.y = GameWindowManager.canvasHeight / 2;
+    }
+    container.scale.set(0);
+    let effect = new ZoomInOutTicker(__spreadProps(__spreadValues({}, props), {
+      startOnlyIfHaveTexture: true,
+      type: "zoom",
+      limit: 1
+    }), priority);
+    GameWindowManager.addTicker(tag, effect);
+  });
+}
+function zoomOut(tag, props = { direction: "right" }, priority) {
+  let canvasElement = GameWindowManager.getCanvasElement(tag);
+  if (!canvasElement) {
+    console.warn("[Pixi'VN] The canvas element is not found.");
+    return;
+  }
+  let container = new CanvasContainer();
+  container.addChild(canvasElement);
+  container.height = GameWindowManager.canvasHeight;
+  container.width = GameWindowManager.canvasWidth;
+  GameWindowManager.addCanvasElement(tag, container);
+  if (props.direction == "up") {
+    container.pivot.y = GameWindowManager.canvasHeight;
+    container.pivot.x = GameWindowManager.canvasWidth / 2;
+    container.y = GameWindowManager.canvasHeight;
+    container.x = GameWindowManager.canvasWidth / 2;
+  } else if (props.direction == "down") {
+    container.pivot.y = 0;
+    container.pivot.x = GameWindowManager.canvasWidth / 2;
+    container.y = 0;
+    container.x = GameWindowManager.canvasWidth / 2;
+  } else if (props.direction == "left") {
+    container.pivot.x = GameWindowManager.canvasWidth;
+    container.pivot.y = GameWindowManager.canvasHeight / 2;
+    container.x = GameWindowManager.canvasWidth;
+    container.y = GameWindowManager.canvasHeight / 2;
+  } else if (props.direction == "right") {
+    container.pivot.x = 0;
+    container.pivot.y = GameWindowManager.canvasHeight / 2;
+    container.x = 0;
+    container.y = GameWindowManager.canvasHeight / 2;
+  }
+  container.scale.set(1);
+  let effect = new ZoomInOutTicker(__spreadProps(__spreadValues({}, props), {
+    startOnlyIfHaveTexture: true,
+    type: "unzoom",
+    limit: 0,
+    tagToRemoveAfter: tag
+  }), priority);
+  GameWindowManager.addTicker(tag, effect);
+}
 
 // src/functions/ExportUtility.ts
 function createExportableElement(element) {
@@ -1634,18 +1881,18 @@ var _GameWindowManager = class _GameWindowManager {
    * ```
    */
   static addTicker(canvasElementTag, ticker) {
-    let tickerName = ticker.constructor.name;
+    let tickerId = ticker.id;
     if (typeof canvasElementTag === "string") {
       canvasElementTag = [canvasElementTag];
     }
-    if (!geTickerInstanceByClassName(tickerName, ticker.args, ticker.duration, ticker.priority)) {
-      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;
     }
     let tickerHistory = {
       fn: () => {
       },
-      className: tickerName,
+      id: tickerId,
       args: createExportableElement(ticker.args),
       canvasElementTags: canvasElementTag,
       priority: ticker.priority,
@@ -1661,11 +1908,11 @@ var _GameWindowManager = class _GameWindowManager {
           _GameWindowManager.removeTicker(id);
         }
       }, ticker.duration * 1e3);
-      _GameWindowManager.addTickerTimeoutInfo(canvasElementTag, tickerName, timeout.toString(), true);
+      _GameWindowManager.addTickerTimeoutInfo(canvasElementTag, tickerId, timeout.toString(), true);
     }
   }
   static pushTicker(id, tickerData, ticker) {
-    _GameWindowManager.removeAssociationBetweenTickerCanvasElement(tickerData.canvasElementTags, tickerData);
+    _GameWindowManager.removeAssociationBetweenTickerCanvasElement(tickerData.canvasElementTags, ticker);
     _GameWindowManager._currentTickers[id] = tickerData;
     tickerData.fn = (t) => {
       let data = _GameWindowManager._currentTickers[id];
@@ -1706,9 +1953,9 @@ var _GameWindowManager = class _GameWindowManager {
         if (step.hasOwnProperty("type") && step.type === "pause") {
           return step;
         }
-        let tickerName = step.constructor.name;
+        let tickerId = step.id;
         return {
-          ticker: tickerName,
+          ticker: tickerId,
           args: createExportableElement(step.args),
           duration: step.duration
         };
@@ -1746,16 +1993,16 @@ var _GameWindowManager = class _GameWindowManager {
       _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;
     }
-    let tickerName = ticker.constructor.name;
+    let tickerName = ticker.id;
     let tickerHistory = {
       fn: () => {
       },
-      className: tickerName,
+      id: tickerName,
       args: createExportableElement(ticker.args),
       canvasElementTags: [tag],
       priority: ticker.priority,
@@ -1812,26 +2059,26 @@ var _GameWindowManager = class _GameWindowManager {
    * ```
    */
   static removeAssociationBetweenTickerCanvasElement(tags, ticker) {
-    let tickerName;
+    let tickerId;
     if (typeof ticker === "string") {
-      tickerName = ticker;
+      tickerId = ticker;
     } else if (ticker instanceof TickerBase) {
-      tickerName = ticker.constructor.name;
+      tickerId = ticker.id;
     } else {
-      tickerName = ticker.name;
+      tickerId = ticker.prototype.id;
     }
     if (typeof tags === "string") {
       tags = [tags];
     }
     for (let id in _GameWindowManager._currentTickers) {
       let ticker2 = _GameWindowManager._currentTickers[id];
-      if (ticker2.className === tickerName) {
+      if (ticker2.id === tickerId) {
         _GameWindowManager._currentTickers[id].canvasElementTags = ticker2.canvasElementTags.filter((e) => !tags.includes(e));
       }
     }
     for (let timeout in _GameWindowManager._currentTickersTimeouts) {
       let TickerTimeout = _GameWindowManager._currentTickersTimeouts[timeout];
-      if (TickerTimeout.ticker === tickerName && TickerTimeout.canBeDeletedBeforeEnd) {
+      if (TickerTimeout.ticker === tickerId && TickerTimeout.canBeDeletedBeforeEnd) {
         _GameWindowManager._currentTickersTimeouts[timeout].tags = TickerTimeout.tags.filter((t) => !tags.includes(t));
       }
     }
@@ -2017,11 +2264,11 @@ var _GameWindowManager = class _GameWindowManager {
         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`);
           }
         }
       }
@@ -2222,6 +2469,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.
@@ -2231,7 +2485,7 @@ var _GameStepManager = class _GameStepManager {
    * ```typescript
    *     function nextOnClick() {
    *     setLoading(true)
-   *     GameStepManager.runNextStep(yourParams)
+   *     GameStepManager.goNext(yourParams)
    *         .then((result) => {
    *             setUpdate((p) => p + 1)
    *             setLoading(false)
@@ -2246,8 +2500,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);
     });
@@ -2278,7 +2536,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");
@@ -2426,7 +2684,7 @@ var _GameStepManager = class _GameStepManager {
       if (choice.closeCurrentLabel) {
         _GameStepManager.closeCurrentLabel();
       }
-      return _GameStepManager.runNextStep(props, choiseMade);
+      return _GameStepManager.goNext(props, choiseMade);
     });
   }
   /* After Update Methods */
@@ -2754,15 +3012,15 @@ var DialogueBaseModel = class {
     if (typeof text === "string") {
       this.text = text;
       if (typeof character === "string") {
-        this.characterId = character;
+        this.character = character;
       } else {
-        this.characterId = character == null ? void 0 : character.id;
+        this.character = character == null ? void 0 : character.id;
       }
       this.oltherParams = oltherParams;
     } else {
       this.text = text.text;
-      if (text.characterId) {
-        this.characterId = text.characterId;
+      if (text.character) {
+        this.character = text.character;
       }
       this.oltherParams = text.oltherParams || {};
     }
@@ -2775,7 +3033,7 @@ var DialogueBaseModel = class {
   export() {
     return {
       text: this.text,
-      characterId: this.characterId,
+      character: this.character,
       oltherParams: this.oltherParams
     };
   }
@@ -2797,81 +3055,214 @@ var helmlokImage = "https://pixijs.com/assets/helmlok.png";
 var helmlokName = `<span style="color:blue">Helmlok</span>`;
 var skullyImage = "https://pixijs.com/assets/skully.png";
 var skullyName = `<span style="color:red">Skully</span>`;
+var bunnyImage = "https://pixijs.com/assets/bunny.png";
+var bunnyName = `Bunny`;
 
-// src/labels/MarkdownTest.ts
-var MARKDOWN_TEST_LABEL = "___pixi_vn_markdown_test___";
-var markdownTest = newLabel(MARKDOWN_TEST_LABEL, [
-  () => __async(void 0, null, function* () {
-    setDialogue({
+// src/labels/CanvasEventsTestLabel.ts
+var EventTest1 = class extends CanvasEvent {
+  fn(event, sprite) {
+    if (event === "pointerdown") {
+      sprite.scale.x *= 1.25;
+      sprite.scale.y *= 1.25;
+    }
+  }
+};
+EventTest1 = __decorateClass([
+  eventDecorator("___pixi_vn_canvas_events_test_event1___")
+], EventTest1);
+var EventTest2 = class extends CanvasEvent {
+  constructor() {
+    super(...arguments);
+    this.textureButtonDown = pixi_js.Texture.from("https://pixijs.com/assets/button_down.png");
+    this.textureButtonOver = pixi_js.Texture.from("https://pixijs.com/assets/button_over.png");
+    this.textureButton = pixi_js.Texture.from("https://pixijs.com/assets/button.png");
+  }
+  fn(event, sprite) {
+    if (event === "pointerdown") {
+      sprite.isdown = true;
+      sprite.texture = this.textureButtonDown;
+      sprite.alpha = 1;
+    } else if (event === "pointerup" || event === "pointerupoutside") {
+      sprite.isdown = false;
+      if (sprite.isOver) {
+        sprite.texture = this.textureButtonOver;
+      } else {
+        sprite.texture = this.textureButton;
+      }
+    } else if (event === "pointerover") {
+      sprite.isOver = true;
+      if (sprite.isdown) {
+        return;
+      }
+      sprite.texture = this.textureButtonOver;
+    } else if (event === "pointerout") {
+      sprite.isOver = false;
+      if (sprite.isdown) {
+        return;
+      }
+      sprite.texture = this.textureButton;
+    }
+  }
+};
+EventTest2 = __decorateClass([
+  eventDecorator("___pixi_vn_canvas_events_test_event2___")
+], EventTest2);
+var CANVAS_EVENTS_TEST_LABEL = "___pixi_vn_canvas_events_test___";
+var canvasEventsTestLabel = newLabel(
+  CANVAS_EVENTS_TEST_LABEL,
+  [
+    () => setDialogue({
       character: juliette,
-      text: `
-# Markdown Test
-
-Hello, this is a test of the markdown parser. Pixi'VN does not manage markdown, but you can implement a markdown parser to display text with markdown syntax.
-
-For example in React, you can use the library [react-markdown](https://www.npmjs.com/package/react-markdown).
-
-## Colored Text
-
-<span style="color:blue">some *blue* text</span>.
-
-<span style="color:red">some *red* text</span>.
-
-<span style="color:green">some *green* text</span>.
-
-## Bold Text
-
-**This is bold text.**
-
-## Italic Text
-
-*This is italic text.*
-
-## Delete Text
-
-~~This is deleted text.~~
-
-## Link Test
-
-[Link to Google](https://www.google.com)
-
-## H2 Test
-
-### H3 Test
-
-#### H4 Test
- 
-## Code Test
-
-\`Hello World\`
-
-\`\`\`js
-console.log("Hello World")
-\`\`\`
-
-## List Test
-
-- Item 1
-* Item 2
-- [x] Item 3
-
-## Table Test
-
-| Header 1 | Header 2 |
-| -------- | -------- |
-| Cell 1   | Cell 2   |
-
-## Separator Test
-
-***
-Footer
-
-`
+      text: "This is the test of clickable elements in a canvas."
+    }),
+    () => __async(void 0, null, function* () {
+      setDialogue({
+        character: juliette,
+        text: `This is my friend, ${bunnyName}. It's small now, but if you try to click on it it will get bigger and bigger. (This example is from the official [PixiJS website](https://pixijs.com/8.x/examples/events/click).)`
+      });
+      const texture = yield pixi_js.Assets.load(bunnyImage);
+      const sprite = CanvasSprite.from(texture);
+      sprite.anchor.set(0.5);
+      sprite.x = GameWindowManager.screen.width / 2;
+      sprite.y = GameWindowManager.screen.height / 2;
+      sprite.eventMode = "static";
+      sprite.cursor = "pointer";
+      sprite.onEvent("pointerdown", EventTest1);
+      GameWindowManager.addCanvasElement("bunny", sprite);
+    }),
+    () => __async(void 0, null, function* () {
+      GameWindowManager.clear();
+      setDialogue({
+        character: juliette,
+        text: `This is the test of buttons in a canvas. (This example is from the official [PixiJS website](https://pixijs.com/8.x/examples/events/interactivity).)`
+      });
+      yield pixi_js.Assets.load([
+        "https://pixijs.com/assets/bg_button.jpg",
+        "https://pixijs.com/assets/button.png",
+        "https://pixijs.com/assets/button_down.png",
+        "https://pixijs.com/assets/button_over.png"
+      ]);
+      const background = CanvasSprite.from("https://pixijs.com/assets/bg_button.jpg");
+      background.width = GameWindowManager.screen.width;
+      background.height = GameWindowManager.screen.height;
+      GameWindowManager.addCanvasElement("bg", background);
+      const textureButton = pixi_js.Texture.from("https://pixijs.com/assets/button.png");
+      const buttons = [];
+      const buttonPositions = [175, 75, 655, 75, 410, 325, 150, 465, 685, 445];
+      for (let i = 0; i < 5; i++) {
+        const button = new CanvasSprite(textureButton);
+        button.anchor.set(0.5);
+        button.x = buttonPositions[i * 2];
+        button.y = buttonPositions[i * 2 + 1];
+        button.eventMode = "static";
+        button.cursor = "pointer";
+        button.onEvent("pointerdown", EventTest2).onEvent("pointerup", EventTest2).onEvent("pointerupoutside", EventTest2).onEvent("pointerover", EventTest2).onEvent("pointerout", EventTest2);
+        GameWindowManager.addCanvasElement("button" + i, button);
+        buttons.push(button);
+      }
+      buttons[0].scale.set(1.2);
+      buttons[2].rotation = Math.PI / 10;
+      buttons[3].scale.set(0.8);
+      buttons[4].scale.set(0.8, 1.2);
+      buttons[4].rotation = Math.PI;
+    })
+  ]
+);
+var AlienTintingTest = class extends CanvasSprite {
+  constructor() {
+    super(...arguments);
+    this.direction = 0;
+    this.turningSpeed = 0;
+    this.speed = 0;
+  }
+  get memory() {
+    return __spreadProps(__spreadValues({}, super.memory), {
+      direction: this.direction,
+      turningSpeed: this.turningSpeed,
+      speed: this.speed
     });
-  })
-]);
+  }
+  set memory(memory) {
+    super.memory = memory;
+    this.direction = memory.direction;
+    this.turningSpeed = memory.turningSpeed;
+    this.speed = memory.speed;
+  }
+  static from(source, skipCache) {
+    let sprite = pixi_js.Sprite.from(source, skipCache);
+    let mySprite = new AlienTintingTest();
+    mySprite.texture = sprite.texture;
+    return mySprite;
+  }
+};
+AlienTintingTest = __decorateClass([
+  canvasElementDecorator("___pixi_vn_custom_canvas_element___")
+], AlienTintingTest);
+var TintingTestTicker = class extends TickerBase {
+  constructor() {
+    super({});
+  }
+  fn(_t, _args, tags) {
+    tags.forEach((tag) => {
+      const dudeBoundsPadding = 100;
+      const dudeBounds = new pixi_js.Rectangle(
+        -dudeBoundsPadding,
+        -dudeBoundsPadding,
+        GameWindowManager.screen.width + dudeBoundsPadding * 2,
+        GameWindowManager.screen.height + dudeBoundsPadding * 2
+      );
+      let dude = GameWindowManager.getCanvasElement(tag);
+      if (dude && dude instanceof AlienTintingTest) {
+        dude.direction += dude.turningSpeed * 0.01;
+        dude.x += Math.sin(dude.direction) * dude.speed;
+        dude.y += Math.cos(dude.direction) * dude.speed;
+        dude.rotation = -dude.direction - Math.PI / 2;
+        if (dude.x < dudeBounds.x) {
+          dude.x += dudeBounds.width;
+        } else if (dude.x > dudeBounds.x + dudeBounds.width) {
+          dude.x -= dudeBounds.width;
+        }
+        if (dude.y < dudeBounds.y) {
+          dude.y += dudeBounds.height;
+        } else if (dude.y > dudeBounds.y + dudeBounds.height) {
+          dude.y -= dudeBounds.height;
+        }
+      }
+    });
+  }
+};
+TintingTestTicker = __decorateClass([
+  tickerDecorator("___pixi_vn_custom_ticker___")
+], TintingTestTicker);
+var CUSTOM_TICKER_CANVAS_ELEMENT_TEST_LABEL = "___pixi_vn_custom_ticker_canvas_element_test___";
+var customTickerCanvasElementTestLabel = newLabel(
+  CUSTOM_TICKER_CANVAS_ELEMENT_TEST_LABEL,
+  [
+    () => __async(void 0, null, function* () {
+      const totalDudes = 100;
+      for (let i = 0; i < totalDudes; i++) {
+        const texture = yield pixi_js.Assets.load(eggHeadImage);
+        const dude = AlienTintingTest.from(texture);
+        dude.anchor.set(0.5);
+        dude.scale.set(0.8 + Math.random() * 0.3);
+        dude.x = Math.random() * GameWindowManager.screen.width;
+        dude.y = Math.random() * GameWindowManager.screen.height;
+        dude.tint = Math.random() * 16777215;
+        dude.direction = Math.random() * Math.PI * 2;
+        dude.turningSpeed = Math.random() - 0.8;
+        dude.speed = 2 + Math.random() * 2;
+        GameWindowManager.addCanvasElement("alien" + i, dude);
+        GameWindowManager.addTicker("alien" + i, new TintingTestTicker());
+      }
+      setDialogue({
+        character: juliette,
+        text: `This is a test of custom ticker and canvas element. In this test, we have created ${totalDudes} ${eggHeadName} with random tint, scale, position, direction, turning speed, and speed. With the custom ticker, we are moving the custom canvas element in a random direction. (This example is from the official [PixiJS website](https://pixijs.com/8.x/examples/events/interactivity).)`
+      });
+    })
+  ]
+);
 
-// src/labels/ShowImageTest.ts
+// src/labels/ImagesAnimationsTestLabel.ts
 var IMAGE_ANIMAIONS_TEST_LABEL = "___pixi_vn_images_animations_test___";
 var imagesAnimationsTest = newLabel(IMAGE_ANIMAIONS_TEST_LABEL, [
   () => __async(void 0, null, function* () {
@@ -2900,6 +3291,8 @@ var imagesAnimationsTest = newLabel(IMAGE_ANIMAIONS_TEST_LABEL, [
       new ChoiceMenuOption("Rotate", imagesRotateTest),
       new ChoiceMenuOption("Move", imagesMoveTest),
       new ChoiceMenuOption("Zoom", imagesZoomTest),
+      new ChoiceMenuOption("Move in/out", imagesMoveInOutTest),
+      new ChoiceMenuOption("Zoom in/out", imagesZoomInOutTest),
       new ChoiceMenuOptionClose("Cancel", true)
     ]);
   }),
@@ -3154,6 +3547,148 @@ var imagesZoomTest = newLabel("___pixi_vn_images_zoom_test___", [
     ]);
   }
 ]);
+var imagesMoveInOutTest = newLabel("___pixi_vn_images_move_in_out_test___", [
+  () => __async(void 0, null, function* () {
+    setDialogue({
+      character: juliette,
+      text: `Here's what's going to happen:
+- ${eggHeadName} will move in from the top with a speed of 800. If you go next, ${eggHeadName} will move out from the bottom with a speed of 800.
+- ${flowerTopName} will move in from the right with a speed of 800 and a speed progression of 0.02. If you go next, ${flowerTopName} will move out from the left with a speed of 800 and a speed progression of 0.02.
+- ${helmlokName} will move in from the left with a speed of 800. If you go next, ${helmlokName} will move out from the right with a speed of 800.
+- ${skullyName} will move in from the bottom with a speed of 800 and a speed progression of 0.02. If you go next, ${skullyName} will move out from the top with a speed of 800 and a speed progression of 0.02.`
+    });
+    let eggHead = new CanvasImage({ x: 100, y: 100 }, eggHeadImage);
+    let flowerTop = new CanvasImage({ x: 300, y: 100 }, flowerTopImage);
+    let helmlok = new CanvasImage({ x: 100, y: 300 }, helmlokImage);
+    let skully = new CanvasImage({ x: 300, y: 300 }, skullyImage);
+    moveIn("eggHead", eggHead, { speed: 800, direction: "down" });
+    moveIn("flowerTop", flowerTop, {
+      speed: 800,
+      direction: "left",
+      speedProgression: { type: "exponential", percentage: 0.02 }
+    });
+    moveIn("helmlok", helmlok, { speed: 800, direction: "right" });
+    moveIn("skully", skully, {
+      speed: 800,
+      direction: "up",
+      speedProgression: { type: "exponential", percentage: 0.02 }
+    });
+  }),
+  () => {
+    moveOut("eggHead", { speed: 800, direction: "down" });
+    moveOut("flowerTop", { speed: 800, direction: "left" });
+    moveOut("helmlok", { speed: 800, direction: "right" });
+    moveOut("skully", { speed: 800, direction: "up" });
+  }
+]);
+var imagesZoomInOutTest = newLabel("___pixi_vn_images_zoom_in_out_test___", [
+  () => __async(void 0, null, function* () {
+    GameWindowManager.removeCanvasElements();
+    let eggHead = new CanvasImage({ x: 100, y: 100 }, eggHeadImage);
+    let flowerTop = new CanvasImage({ x: 300, y: 100 }, flowerTopImage);
+    let helmlok = new CanvasImage({ x: 100, y: 300 }, helmlokImage);
+    let skully = new CanvasImage({ x: 300, y: 300 }, skullyImage);
+    zoomIn("eggHead", eggHead, { speed: 3, direction: "down" });
+    zoomIn("flowerTop", flowerTop, {
+      speed: 3,
+      direction: "left",
+      speedProgression: { type: "exponential", percentage: 0.02 }
+    });
+    zoomIn("helmlok", helmlok, { speed: 3, direction: "right" });
+    zoomIn("skully", skully, {
+      speed: 3,
+      direction: "up",
+      speedProgression: { type: "exponential", percentage: 0.02 }
+    });
+  }),
+  () => __async(void 0, null, function* () {
+    zoomOut("eggHead", {
+      speed: 3,
+      direction: "down",
+      speedProgression: { type: "exponential", percentage: 0.02 }
+    });
+    zoomOut("flowerTop", { speed: 3, direction: "left" });
+    zoomOut("helmlok", { speed: 3, direction: "right" });
+    zoomOut("skully", {
+      speed: 3,
+      direction: "up",
+      speedProgression: { type: "exponential", percentage: 0.02 }
+    });
+  })
+]);
+
+// src/labels/MarkdownTest.ts
+var MARKDOWN_TEST_LABEL = "___pixi_vn_markdown_test___";
+var markdownTest = newLabel(MARKDOWN_TEST_LABEL, [
+  () => __async(void 0, null, function* () {
+    setDialogue({
+      character: juliette,
+      text: `
+# Markdown Test
+
+Hello, this is a test of the markdown parser. Pixi'VN does not manage markdown, but you can implement a markdown parser to display text with markdown syntax.
+
+For example in React, you can use the library [react-markdown](https://www.npmjs.com/package/react-markdown).
+
+## Colored Text
+
+<span style="color:blue">some *blue* text</span>.
+
+<span style="color:red">some *red* text</span>.
+
+<span style="color:green">some *green* text</span>.
+
+## Bold Text
+
+**This is bold text.**
+
+## Italic Text
+
+*This is italic text.*
+
+## Delete Text
+
+~~This is deleted text.~~
+
+## Link Test
+
+[Link to Google](https://www.google.com)
+
+## H2 Test
+
+### H3 Test
+
+#### H4 Test
+ 
+## Code Test
+
+\`Hello World\`
+
+\`\`\`js
+console.log("Hello World")
+\`\`\`
+
+## List Test
+
+- Item 1
+* Item 2
+- [x] Item 3
+
+## Table Test
+
+| Header 1 | Header 2 |
+| -------- | -------- |
+| Cell 1   | Cell 2   |
+
+## Separator Test
+
+***
+Footer
+
+`
+    });
+  })
+]);
 
 // src/labels/StartLabel.ts
 var pixivnTestStartLabel = newLabel(
@@ -3185,7 +3720,9 @@ var pixivnTestStartLabel2 = newLabel(
       GameWindowManager.clear();
       setDialogue({ character: juliette, text: "Which test would you like to start with?" });
       setChoiceMenuOptions([
-        new ChoiceMenuOption("Images and Animations", imagesAnimationsTest),
+        new ChoiceMenuOption("Images, Transitions and Animations Test", imagesAnimationsTest),
+        new ChoiceMenuOption("Canvas Events Test Label", canvasEventsTestLabel),
+        new ChoiceMenuOption("Custom Ticker Canvas Element Test", customTickerCanvasElementTestLabel),
         new ChoiceMenuOption("Markdown Test", markdownTest)
       ]);
     },