@drincs/pixi-vn 0.6.1 → 0.6.3

package/dist/labels/{TickerTestLabel.js → CustomTickerCanvasElementTestLabel.js}

@@ -56,138 +56,6 @@ var __async = (__this, __arguments, generator) => {
     step((generator = generator.apply(__this, __arguments)).next());
   });
 };
-
-// src/decorators/CanvasElementDecorator.ts
-var registeredCanvasElement = {};
-function getCanvasElementInstanceByClassName(canvasName) {
-  try {
-    let eventType = registeredCanvasElement[canvasName];
-    if (!eventType) {
-      if (canvasName === "CanvasContainer") {
-        eventType = CanvasContainer;
-      } else if (canvasName === "CanvasImage") {
-        eventType = CanvasImage;
-      } else if (canvasName === "CanvasSprite") {
-        eventType = CanvasSprite;
-      } else if (canvasName === "CanvasText") {
-        eventType = CanvasText;
-      }
-    }
-    if (!eventType) {
-      console.error(`[Pixi'VN] CanvasElement ${canvasName} not found`);
-      return;
-    }
-    let canvasElement = new eventType();
-    return canvasElement;
-  } catch (e) {
-    console.error(`[Pixi'VN] Error while getting CanvasElement ${canvasName}`, e);
-    return;
-  }
-}
-
-// src/functions/CanvasUtility.ts
-function getTextureMemory(texture) {
-  let sourceTexture = texture.source;
-  let textureMemory = {
-    image: sourceTexture.label
-  };
-  return textureMemory;
-}
-function exportCanvasElement(element) {
-  return element.memory;
-}
-function importCanvasElement(memory) {
-  let element = getCanvasElementInstanceByClassName(memory.className);
-  if (element) {
-    element.memory = memory;
-  } else {
-    throw new Error("[Pixi'VN] The element " + memory.className + " could not be created");
-  }
-  return element;
-}
-
-// src/classes/canvas/CanvasContainer.ts
-var CanvasContainer = class extends pixi_js.Container {
-  get memory() {
-    let memory = getMemoryContainer(this);
-    this.children.forEach((child) => {
-      memory.elements.push(exportCanvasElement(child));
-    });
-    return memory;
-  }
-  set memory(value) {
-    setMemoryContainer(this, value);
-    value.elements.forEach((child) => {
-      this.addChild(importCanvasElement(child));
-    });
-  }
-};
-function getMemoryContainer(element) {
-  return {
-    className: "CanvasContainer",
-    elements: [],
-    width: element.width,
-    height: element.height,
-    isRenderGroup: element.isRenderGroup,
-    blendMode: element.blendMode,
-    tint: element.tint,
-    alpha: element.alpha,
-    angle: element.angle,
-    renderable: element.renderable,
-    rotation: element.rotation,
-    scale: { x: element.scale.x, y: element.scale.y },
-    pivot: { x: element.pivot.x, y: element.pivot.y },
-    position: { x: element.position.x, y: element.position.y },
-    skew: { x: element.skew.x, y: element.skew.y },
-    visible: element.visible,
-    culled: element.culled,
-    x: element.x,
-    y: element.y,
-    boundsArea: element.boundsArea,
-    cursor: element.cursor,
-    eventMode: element.eventMode,
-    interactive: element.interactive,
-    interactiveChildren: element.interactiveChildren,
-    hitArea: element.hitArea
-  };
-}
-function setMemoryContainer(element, memory) {
-  memory.width && (element.width = memory.width);
-  memory.height && (element.height = memory.height);
-  memory.isRenderGroup && (element.isRenderGroup = memory.isRenderGroup);
-  memory.blendMode && (element.blendMode = memory.blendMode);
-  memory.tint && (element.tint = memory.tint);
-  memory.alpha && (element.alpha = memory.alpha);
-  memory.angle && (element.angle = memory.angle);
-  memory.renderable && (element.renderable = memory.renderable);
-  memory.rotation && (element.rotation = memory.rotation);
-  if (memory.scale) {
-    if (typeof memory.scale === "number") {
-      element.scale.set(memory.scale, memory.scale);
-    } else {
-      element.scale.set(memory.scale.x, memory.scale.y);
-    }
-  }
-  if (memory.pivot) {
-    if (typeof memory.pivot === "number") {
-      element.pivot.set(memory.pivot, memory.pivot);
-    } else {
-      element.pivot.set(memory.pivot.x, memory.pivot.y);
-    }
-  }
-  memory.position && element.position.set(memory.position.x, memory.position.y);
-  memory.skew && element.skew.set(memory.skew.x, memory.skew.y);
-  memory.visible && (element.visible = memory.visible);
-  memory.culled && (element.culled = memory.culled);
-  memory.x && (element.x = memory.x);
-  memory.y && (element.y = memory.y);
-  memory.boundsArea && (element.boundsArea = memory.boundsArea);
-  memory.cursor && (element.cursor = memory.cursor);
-  memory.eventMode && (element.eventMode = memory.eventMode);
-  memory.interactive && (element.interactive = memory.interactive);
-  memory.interactiveChildren && (element.interactiveChildren = memory.interactiveChildren);
-  memory.hitArea && (element.hitArea = memory.hitArea);
-}
 function getTexture(imageUrl) {
   return __async(this, null, function* () {
     if (pixi_js.Assets.cache.has(imageUrl)) {
@@ -209,17 +77,19 @@ function getTexture(imageUrl) {
     });
   });
 }
-function getTextStyle(style) {
-  let fill = style.fill;
-  if (fill instanceof Object) {
-    console.warn("[Pixi'VN] CanvasText.style.fill is a FillGradient or FillPattern, this is not supported yet.", fill);
-    fill = "#00FF00";
+function getFillGradientFillPattern(prop, propName) {
+  if (!(prop instanceof Object)) {
+    return prop;
   }
+  console.warn(`[Pixi'VN] CanvasText.style.${propName} is a FillGradient or FillPattern, this is not supported yet.`, prop);
+  return void 0;
+}
+function getTextStyle(style) {
   return {
     align: style.align,
     breakWords: style.breakWords,
     dropShadow: style.dropShadow,
-    fill,
+    fill: getFillGradientFillPattern(style.stroke, "fill"),
     fontFamily: style.fontFamily,
     fontSize: style.fontSize,
     fontStyle: style.fontStyle,
@@ -229,7 +99,7 @@ function getTextStyle(style) {
     letterSpacing: style.letterSpacing,
     lineHeight: style.lineHeight,
     padding: style.padding,
-    stroke: style.stroke,
+    stroke: getFillGradientFillPattern(style.stroke, "stroke"),
     textBaseline: style.textBaseline,
     trim: style.trim,
     whiteSpace: style.whiteSpace,
@@ -240,40 +110,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 pixi_js.Sprite {
-  constructor() {
-    super(...arguments);
+  constructor(options) {
+    super(options);
+    this.pixivnId = CANVAS_SPRITE_ID;
     this._onEvents = {};
+    this.pixivnId = this.constructor.prototype.pixivnId || CANVAS_SPRITE_ID;
   }
   get memory() {
     return getMemorySprite(this);
@@ -314,9 +187,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);
@@ -345,7 +218,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,
@@ -368,8 +241,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);
     }
@@ -377,9 +250,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;
@@ -387,12 +262,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);
@@ -420,10 +296,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 || CANVAS_TEXT_ID;
   }
   get memory() {
     return getMemoryText(this);
@@ -464,9 +343,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);
@@ -489,7 +368,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,
@@ -512,13 +391,175 @@ 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);
     }
   }
 }
+
+// src/decorators/CanvasElementDecorator.ts
+var registeredCanvasElement = {};
+function canvasElementDecorator(name) {
+  return function(target) {
+    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[canvasId];
+    if (!eventType) {
+      if (canvasId === CANVAS_CONTAINER_ID) {
+        eventType = CanvasContainer;
+      } else if (canvasId === CANVAS_IMAGE_ID) {
+        eventType = CanvasImage;
+      } else if (canvasId === CANVAS_SPRITE_ID) {
+        eventType = CanvasSprite;
+      } else if (canvasId === CANVAS_TEXT_ID) {
+        eventType = CanvasText;
+      }
+    }
+    if (!eventType) {
+      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 ${canvasId}`, e);
+    return;
+  }
+}
+
+// src/functions/CanvasUtility.ts
+function getTextureMemory(texture) {
+  let sourceTexture = texture.source;
+  let textureMemory = {
+    image: sourceTexture.label
+  };
+  return textureMemory;
+}
+function exportCanvasElement(element) {
+  return element.memory;
+}
+function importCanvasElement(memory) {
+  let element = getCanvasElementInstanceById(memory.pixivnId);
+  if (element) {
+    element.memory = memory;
+  } else {
+    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 || CANVAS_CONTAINER_ID;
+  }
+  get memory() {
+    let memory = getMemoryContainer(this);
+    this.children.forEach((child) => {
+      memory.elements.push(exportCanvasElement(child));
+    });
+    return memory;
+  }
+  set memory(value) {
+    setMemoryContainer(this, value);
+    value.elements.forEach((child) => {
+      this.addChild(importCanvasElement(child));
+    });
+  }
+};
+function getMemoryContainer(element) {
+  let className = "CanvasContainer";
+  if (element.hasOwnProperty("pixivnId")) {
+    className = element.pixivnId;
+  }
+  return {
+    pixivnId: className,
+    elements: [],
+    width: element.width,
+    height: element.height,
+    isRenderGroup: element.isRenderGroup,
+    blendMode: element.blendMode,
+    tint: element.tint,
+    alpha: element.alpha,
+    angle: element.angle,
+    renderable: element.renderable,
+    rotation: element.rotation,
+    scale: { x: element.scale.x, y: element.scale.y },
+    pivot: { x: element.pivot.x, y: element.pivot.y },
+    position: { x: element.position.x, y: element.position.y },
+    skew: { x: element.skew.x, y: element.skew.y },
+    visible: element.visible,
+    x: element.x,
+    y: element.y,
+    boundsArea: element.boundsArea,
+    cursor: element.cursor,
+    eventMode: element.eventMode,
+    interactive: element.interactive,
+    interactiveChildren: element.interactiveChildren,
+    hitArea: element.hitArea
+  };
+}
+function setMemoryContainer(element, memory) {
+  memory.width && (element.width = memory.width);
+  memory.height && (element.height = memory.height);
+  memory.isRenderGroup && (element.isRenderGroup = memory.isRenderGroup);
+  memory.blendMode && (element.blendMode = memory.blendMode);
+  memory.tint && (element.tint = memory.tint);
+  memory.alpha && (element.alpha = memory.alpha);
+  memory.angle && (element.angle = memory.angle);
+  memory.renderable && (element.renderable = memory.renderable);
+  memory.rotation && (element.rotation = memory.rotation);
+  if (memory.scale) {
+    if (typeof memory.scale === "number") {
+      element.scale.set(memory.scale, memory.scale);
+    } else {
+      element.scale.set(memory.scale.x, memory.scale.y);
+    }
+  }
+  if (memory.pivot) {
+    if (typeof memory.pivot === "number") {
+      element.pivot.set(memory.pivot, memory.pivot);
+    } else {
+      element.pivot.set(memory.pivot.x, memory.pivot.y);
+    }
+  }
+  memory.position && element.position.set(memory.position.x, memory.position.y);
+  memory.skew && element.skew.set(memory.skew.x, memory.skew.y);
+  memory.visible && (element.visible = memory.visible);
+  memory.x && (element.x = memory.x);
+  memory.y && (element.y = memory.y);
+  memory.boundsArea && (element.boundsArea = memory.boundsArea);
+  memory.cursor && (element.cursor = memory.cursor);
+  memory.eventMode && (element.eventMode = memory.eventMode);
+  memory.interactive && (element.interactive = memory.interactive);
+  memory.interactiveChildren && (element.interactiveChildren = memory.interactiveChildren);
+  memory.hitArea && (element.hitArea = memory.hitArea);
+}
+
+// src/decorators/CharacterDecorator.ts
+var registeredCharacters = {};
+function saveCharacter(character) {
+  if (Array.isArray(character)) {
+    character.forEach((c) => saveCharacter(c));
+    return;
+  }
+  if (registeredCharacters[character.id]) {
+    console.info(`[Pixi'VN] Character id ${character.id} already exists, it will be overwritten`);
+  }
+  registeredCharacters[character.id] = character;
+}
 function getStepSha1(step) {
   let sha1String = sha1__default.default(step.toString().toLocaleLowerCase());
   return sha1String.toString();
@@ -542,7 +583,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;
@@ -600,47 +641,231 @@ function newCloseLabel(choiseIndex) {
   return new Label(CLOSE_LABEL_ID, [], void 0, choiseIndex);
 }
 
+// src/types/CloseType.ts
+var Close = "close";
+
 // 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 {
+        character = props.character.id;
+      }
+    }
+    dialogue = new DialogueBaseModel(text, character);
+  } else {
+    dialogue = props;
+  }
+  GameStorageManager.setVariable(GameStorageManager.keysSystem.CURRENT_DIALOGUE_MEMORY_KEY, dialogue);
+  GameStorageManager.setVariable(GameStorageManager.keysSystem.LAST_DIALOGUE_ADDED_IN_STEP_MEMORY_KEY, GameStepManager.lastStepIndex);
+}
+function getDialogue() {
+  return GameStorageManager.getVariable(GameStorageManager.keysSystem.CURRENT_DIALOGUE_MEMORY_KEY);
+}
+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/functions/TickerUtility.ts
+function updateTickerProgression(args, propertyName, progression) {
+  if (args[propertyName] === void 0 || !progression || args[propertyName] === progression.limit) {
+    return;
+  }
+  if (typeof args[propertyName] === "number") {
+    if (progression.type === "linear") {
+      args[propertyName] = getLinearProgression(args[propertyName], progression);
+    } else if (progression.type === "exponential") {
+      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/TickerBase.ts
+var TickerBase = class {
+  /**
+   * @param args The arguments that you want to pass to the ticker.
+   * @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 _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(_ticker, _args, _tags, _tickerId) {
+    throw new Error("[Pixi'VN] The method TickerBase.fn() must be overridden");
+  }
+};
+
+// src/classes/ticker/ZoomTicker.ts
+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 {
-        characterId = props.character.id;
+        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 pixi_js.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 pixi_js.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);
+        }
       }
-    }
-    dialogue = new DialogueBaseModel(text, characterId);
-  } else {
-    dialogue = props;
+    });
+    if (args.speedProgression)
+      updateTickerProgression(args, "speed", args.speedProgression);
   }
-  GameStorageManager.setVariable(GameStorageManager.keysSystem.CURRENT_DIALOGUE_MEMORY_KEY, dialogue);
-  GameStorageManager.setVariable(GameStorageManager.keysSystem.LAST_DIALOGUE_ADDED_IN_STEP_MEMORY_KEY, GameStepManager.lastStepIndex);
-}
-function getDialogue() {
-  return GameStorageManager.getVariable(GameStorageManager.keysSystem.CURRENT_DIALOGUE_MEMORY_KEY);
-}
+  onEndOfTicker(tag, tickerId, _element, tagToRemoveAfter2) {
+    GameWindowManager.onEndOfTicker(tag, this, tagToRemoveAfter2, tickerId);
+  }
+};
+ZoomTicker = __decorateClass([
+  tickerDecorator()
+], ZoomTicker);
 
 // src/constants.ts
 var Repeat = "repeat";
-function Pause(duration) {
-  return {
-    type: "pause",
-    duration
-  };
-}
-
-// src/functions/ImageUtility.ts
-function removeCanvasElement(tag) {
-  GameWindowManager.removeCanvasElement(tag);
-}
 
 // src/functions/ExportUtility.ts
 function createExportableElement(element) {
@@ -779,31 +1004,6 @@ var _GameStorageManager = class _GameStorageManager {
 _GameStorageManager.storage = {};
 var GameStorageManager = _GameStorageManager;
 
-// src/classes/ticker/TickerBase.ts
-var TickerBase = class {
-  /**
-   * @param args The arguments that you want to pass to the ticker.
-   * @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) {
-    this.args = args;
-    this.duration = duration;
-    this.priority = priority;
-  }
-  /**
-   * 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 _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(_ticker, _args, _tags, _tickerId) {
-    throw new Error("[Pixi'VN] The method TickerBase.fn() must be overridden");
-  }
-};
-
 // src/decorators/TickerDecorator.ts
 var registeredTickers = {};
 function tickerDecorator(name) {
@@ -814,19 +1014,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;
   }
 }
@@ -898,7 +1099,7 @@ var _GameWindowManager = class _GameWindowManager {
         height
       }, options)).then(() => {
         _GameWindowManager._isInitialized = true;
-        this.addCanvasIntoElement(element);
+        this.addCanvasIntoHTMLElement(element);
         window.addEventListener("resize", _GameWindowManager.resize);
         _GameWindowManager.resize();
         asciiArtLog();
@@ -909,7 +1110,7 @@ var _GameWindowManager = class _GameWindowManager {
    * Add the canvas into a html element.
    * @param element it is the html element where I will put the canvas. Example: document.body
    */
-  static addCanvasIntoElement(element) {
+  static addCanvasIntoHTMLElement(element) {
     if (_GameWindowManager.isInitialized) {
       element.appendChild(_GameWindowManager.app.canvas);
     } else {
@@ -1155,18 +1356,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,
@@ -1182,11 +1383,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];
@@ -1227,9 +1428,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
         };
@@ -1267,16 +1468,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,
@@ -1333,26 +1534,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));
       }
     }
@@ -1538,11 +1739,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`);
           }
         }
       }
@@ -1743,6 +1944,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.
@@ -1752,7 +1960,7 @@ var _GameStepManager = class _GameStepManager {
    * ```typescript
    *     function nextOnClick() {
    *     setLoading(true)
-   *     GameStepManager.runNextStep(yourParams)
+   *     GameStepManager.goNext(yourParams)
    *         .then((result) => {
    *             setUpdate((p) => p + 1)
    *             setLoading(false)
@@ -1767,8 +1975,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);
     });
@@ -1799,7 +2011,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");
@@ -1947,7 +2159,7 @@ var _GameStepManager = class _GameStepManager {
       if (choice.closeCurrentLabel) {
         _GameStepManager.closeCurrentLabel();
       }
-      return _GameStepManager.runNextStep(props, choiseMade);
+      return _GameStepManager.goNext(props, choiseMade);
     });
   }
   /* After Update Methods */
@@ -2142,6 +2354,120 @@ _GameStepManager._openedLabels = [];
 _GameStepManager._originalStepData = void 0;
 var GameStepManager = _GameStepManager;
 
+// src/classes/StoredClassModel.ts
+var StoredClassModel = class {
+  /**
+   * @param categoryId The id of the category. For example if you are storing a character class, you can use "characters" as categoryId. so all instances of the character class will be stored in the "characters" category.
+   * @param id The id of instance of the class. This id must be unique for the category.
+   */
+  constructor(categoryId, id) {
+    this.categoryId = categoryId;
+    this._id = id;
+  }
+  /**
+   * Is id of the stored class. is unique for this class.
+   */
+  get id() {
+    return this._id;
+  }
+  /**
+   * Update a property in the storage.
+   * @param propertyName The name of the property to set.
+   * @param value The value to set. If is undefined, the property will be removed from the storage.
+   */
+  setStorageProperty(propertyName, value) {
+    let storage = GameStorageManager.getVariable(this.categoryId);
+    if (!storage) {
+      storage = {};
+    }
+    if (!storage.hasOwnProperty(this.id)) {
+      storage[this.id] = {};
+    }
+    if (value === void 0 || value === null) {
+      if (storage[this.id].hasOwnProperty(propertyName)) {
+        delete storage[this.id][propertyName];
+      }
+    } else {
+      storage[this.id] = __spreadProps(__spreadValues({}, storage[this.id]), { [propertyName]: value });
+    }
+    if (Object.keys(storage[this.id]).length === 0) {
+      delete storage[this.id];
+    }
+    GameStorageManager.setVariable(this.categoryId, storage);
+  }
+  /**
+   * Get a property from the storage.
+   * @param propertyName The name of the property to get.
+   * @returns The value of the property. If the property is not found, returns undefined.
+   */
+  getStorageProperty(propertyName) {
+    let storage = GameStorageManager.getVariable(this.categoryId);
+    if (storage && storage.hasOwnProperty(this.id) && storage[this.id].hasOwnProperty(propertyName)) {
+      return storage[this.id][propertyName];
+    }
+    return void 0;
+  }
+};
+
+// src/classes/CharacterBaseModel.ts
+var CharacterBaseModel2 = class extends StoredClassModel {
+  /**
+   * @param id The id of the character.
+   * @param props The properties of the character.
+   */
+  constructor(id, props) {
+    super(GameStorageManager.keysSystem.CHARACTER_CATEGORY_KEY, id);
+    this.defaultName = "";
+    this.defaultName = props.name;
+    this.defaultSurname = props.surname;
+    this.defaultAge = props.age;
+    this._icon = props.icon;
+    this._color = props.color;
+  }
+  /***
+   * The name of the character.
+   * If you set undefined, it will return the default name.
+   */
+  get name() {
+    return this.getStorageProperty("name") || this.defaultName;
+  }
+  set name(value) {
+    this.setStorageProperty("name", value);
+  }
+  /**
+   * The surname of the character.
+   * If you set undefined, it will return the default surname.
+   */
+  get surname() {
+    return this.getStorageProperty("surname") || this.defaultSurname;
+  }
+  set surname(value) {
+    this.setStorageProperty("surname", value);
+  }
+  /**
+   * The age of the character.
+   * If you set undefined, it will return the default age.
+   */
+  get age() {
+    return this.getStorageProperty("age") || this.defaultAge;
+  }
+  set age(value) {
+    this.setStorageProperty("age", value);
+  }
+  /**
+   * The icon of the character.
+   */
+  get icon() {
+    return this._icon;
+  }
+  /**
+   * The color of the character.
+   */
+  get color() {
+    return this._color;
+  }
+};
+
 // src/classes/DialogueBaseModel.ts
 var DialogueBaseModel = class {
   /**
@@ -2161,15 +2487,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 || {};
     }
@@ -2182,7 +2508,7 @@ var DialogueBaseModel = class {
   export() {
     return {
       text: this.text,
-      characterId: this.characterId,
+      character: this.character,
       oltherParams: this.oltherParams
     };
   }
@@ -2255,50 +2581,6 @@ var FadeAlphaTicker = class extends TickerBase {
 FadeAlphaTicker = __decorateClass([
   tickerDecorator()
 ], FadeAlphaTicker);
-
-// src/functions/TickerUtility.ts
-function updateTickerProgression(args, propertyName, progression) {
-  if (args[propertyName] === void 0 || !progression || args[propertyName] === progression.limit) {
-    return;
-  }
-  if (typeof args[propertyName] === "number") {
-    if (progression.type === "linear") {
-      args[propertyName] = getLinearProgression(args[propertyName], progression);
-    } else if (progression.type === "exponential") {
-      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/MoveTicker.ts
 var MoveTicker = class extends TickerBase {
   fn(ticker, args, tags, tickerId) {
     let xSpeed = 1;
@@ -2395,211 +2677,113 @@ var RotateTicker = class extends TickerBase {
 RotateTicker = __decorateClass([
   tickerDecorator()
 ], 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 = Infinity;
-    let yLimit = Infinity;
-    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 pixi_js.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 pixi_js.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;
-            GameWindowManager.onEndOfTicker(tag, this, tagToRemoveAfter2, tickerId);
-          }
-        } 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;
-            GameWindowManager.onEndOfTicker(tag, this, tagToRemoveAfter2, tickerId);
-          }
+
+// src/labels/TestConstant.ts
+var juliette = new CharacterBaseModel2("___pixivn_juliette___", {
+  name: "Juliette",
+  age: 25,
+  icon: "https://firebasestorage.googleapis.com/v0/b/pixi-vn.appspot.com/o/public%2Fcharacters%2Fjuliette-square.webp?alt=media&token=5856ae7b-d99e-4563-86ec-cbc48cc9c6b4",
+  color: "#ac0086"
+});
+saveCharacter(juliette);
+var eggHeadImage = "https://pixijs.com/assets/eggHead.png";
+var eggHeadName = `<span style="color:purple">Egg Head</span>`;
+
+// src/labels/CustomTickerCanvasElementTestLabel.ts
+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);
+exports.TintingTestTicker = class TintingTestTicker 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 (xSpeed < 1e-5 && ySpeed < 1e-5 && !(args.speedProgression && args.speedProgression.type == "linear" && args.speedProgression.amt != 0)) {
-          GameWindowManager.onEndOfTicker(tag, this, tagToRemoveAfter2, tickerId);
+        if (dude.y < dudeBounds.y) {
+          dude.y += dudeBounds.height;
+        } else if (dude.y > dudeBounds.y + dudeBounds.height) {
+          dude.y -= dudeBounds.height;
         }
       }
     });
-    if (args.speedProgression)
-      updateTickerProgression(args, "speed", args.speedProgression);
   }
 };
-ZoomTicker = __decorateClass([
-  tickerDecorator()
-], ZoomTicker);
-
-// src/labels/TickerTestLabel.ts
-var alien1Tag = "alien1";
-var alien2Tag = "alien2";
-var alien3Tag = "alien3";
-var alien4Tag = "alien4";
-var tickerTestLabel = newLabel(
-  "TickerTestLabel",
+exports.TintingTestTicker = __decorateClass([
+  tickerDecorator("___pixi_vn_custom_ticker___")
+], exports.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* () {
-      let my_speed = 0.1;
-      const texture = yield pixi_js.Assets.load("https://pixijs.com/assets/eggHead.png");
-      const alien = CanvasSprite.from(texture);
-      alien.anchor.set(0.5);
-      GameWindowManager.addCanvasElement(alien1Tag, alien);
-      alien.x = 100;
-      alien.y = 100;
-      GameWindowManager.addTicker(alien1Tag, new RotateTicker({ speed: my_speed }));
-      setDialogue(`I have added a image with a tag ${alien1Tag} and I connected a RotateTicker with a speed of ${my_speed} to it.`);
-    }),
-    () => __async(void 0, null, function* () {
-      let my_speed = 0.1;
-      const texture = yield pixi_js.Assets.load("https://pixijs.com/assets/eggHead.png");
-      const alien = CanvasSprite.from(texture);
-      alien.anchor.set(0.5);
-      GameWindowManager.addCanvasElement(alien2Tag, alien);
-      alien.x = 300;
-      alien.y = 100;
-      GameWindowManager.addTicker(alien2Tag, new RotateTicker({ speed: my_speed }));
-      setDialogue(`I have added a image with a tag ${alien2Tag} and I connected a RotateTicker with a speed of ${my_speed} to it.`);
-    }),
-    () => setDialogue(`Since ${alien1Tag} and ${alien2Tag} they have the same ticker with the same speed, only one RotateTicker will be performed`),
-    () => {
-      GameWindowManager.addTicker(alien1Tag, new RotateTicker({ speed: 0.2 }));
-      setDialogue(`I have changed the speed of the RotateTicker connected to ${alien1Tag} to 0.2`);
-    },
-    () => setDialogue(`Since ${alien1Tag} have a different speed, it will perform a different RotateTicker`),
-    () => {
-      removeCanvasElement(alien1Tag);
-      setDialogue(`I have remove the image with the tag ${alien1Tag}`);
-    },
-    () => setDialogue(`Since ${alien1Tag} is removed, the RotateTicker connected to it will not be performed`),
-    () => {
-      GameWindowManager.removeAssociationBetweenTickerCanvasElement(alien2Tag, RotateTicker);
-      setDialogue(`I have removed the RotateTicker connected to ${alien2Tag}`);
-    },
-    () => __async(void 0, null, function* () {
-      removeCanvasElement(alien2Tag);
-      let duration = 7e3;
-      const texture = yield pixi_js.Assets.load("https://pixijs.com/assets/eggHead.png");
-      const alien = CanvasSprite.from(texture);
-      alien.anchor.set(0.5);
-      GameWindowManager.addCanvasElement(alien3Tag, alien);
-      alien.x = 500;
-      alien.y = 100;
-      GameWindowManager.addTicker(alien3Tag, new RotateTicker({ speed: 0.1 }, duration));
-      setDialogue(`I have added a image with a tag ${alien3Tag} and I connected a RotateTicker with a speed of 0.1 and a duration of ${duration} to it. After ${duration}ms, the RotateTicker will be removed.`);
-    }),
-    () => __async(void 0, null, function* () {
-      let my_speed = 0.1;
-      let my_speed2 = 0.3;
-      const texture = yield pixi_js.Assets.load("https://pixijs.com/assets/eggHead.png");
-      const alien = CanvasSprite.from(texture);
-      alien.anchor.set(0.5);
-      GameWindowManager.addCanvasElement(alien1Tag, alien);
-      alien.x = 100;
-      alien.y = 100;
-      GameWindowManager.addTickersSteps(alien1Tag, [
-        new RotateTicker({ speed: my_speed }, 1e3),
-        new RotateTicker({ speed: my_speed2 }, 1e3)
-      ]);
-      setDialogue(`I have added a image with a tag ${alien1Tag} and I connected a RotateTicker with a speed of ${my_speed} and a duration of 1000ms and then I connected a RotateTicker with a speed of ${my_speed2} and a duration of 1000ms to it.`);
-    }),
-    () => __async(void 0, null, function* () {
-      const texture = yield pixi_js.Assets.load("https://pixijs.com/assets/eggHead.png");
-      const alien = CanvasSprite.from(texture);
-      alien.anchor.set(0.5);
-      GameWindowManager.addCanvasElement(alien2Tag, alien);
-      alien.x = 300;
-      alien.y = 100;
-      GameWindowManager.addTickersSteps(alien2Tag, [
-        new RotateTicker({ speed: 0.1, clockwise: true }, 2e3),
-        Pause(500),
-        new RotateTicker({ speed: 0.2, clockwise: false }, 2e3),
-        Repeat
-      ]);
-      setDialogue(`I have added a image with a tag ${alien2Tag} and I connected a RotateTicker with a speed of 0.1 and a duration of 2000ms and then I connected a RotateTicker with a speed of 0.2 and a duration of 2000ms to it. After 500ms, the RotateTicker will be repeated.`);
-    }),
-    () => __async(void 0, null, function* () {
-      const texture = yield pixi_js.Assets.load("https://pixijs.com/assets/eggHead.png");
-      const alien = CanvasSprite.from(texture);
-      alien.anchor.set(0.5);
-      GameWindowManager.addCanvasElement(alien4Tag, alien);
-      alien.x = 700;
-      alien.y = 100;
-      let speed = 0;
-      let speedLimit = 0.5;
-      let amt = 1e-3;
-      GameWindowManager.addTicker(alien4Tag, new RotateTicker({ speed, speedProgression: { type: "linear", amt, limit: speedLimit } }));
-      GameWindowManager.addTickersSteps(
-        alien2Tag,
-        [
-          new FadeAlphaTicker({
-            duration: 1,
-            type: "hide"
-          }, 3e3),
-          new FadeAlphaTicker({
-            duration: 1,
-            type: "show"
-          }, 3e3),
-          Repeat
-        ]
-      );
-      setDialogue(`I have added a image with a tag ${alien4Tag} and I connected a RotateTicker with a speed of ${speed} and a linear speed progression of ${amt} and a limit of ${speedLimit} to it.`);
+      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 exports.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).)`
+      });
     })
   ]
 );
 
-exports.tickerTestLabel = tickerTestLabel;
-//# sourceMappingURL=out.js.map
-//# sourceMappingURL=TickerTestLabel.js.map
+exports.customTickerCanvasElementTestLabel = customTickerCanvasElementTestLabel;
+//# sourceMappingURL=CustomTickerCanvasElementTestLabel.js.map
+//# sourceMappingURL=CustomTickerCanvasElementTestLabel.js.map