pixospritz-core 0.10.1 → 1.0.1

package/src/engine/actions/dialogue.js

@@ -0,0 +1,90 @@
+/*                                                 *\
+** ----------------------------------------------- **
+**          Calliope - Pixos Game Engine   	       **
+** ----------------------------------------------- **
+**  Copyright (c) 2020-2025 - Kyle Derby MacInnis  **
+**                                                 **
+**    Any unauthorized distribution or transfer    **
+**       of this work is strictly prohibited.      **
+**                                                 **
+**               All Rights Reserved.              **
+** ----------------------------------------------- **
+\*                                                 */
+
+export default {
+  // Initialize Dialogue Object
+  init: function (text, scrolling = true, options = {}) {
+    this.engine = this.sprite.engine;
+    this.text = text; // holds queue of dialogue
+    this.displayText = typeof text === 'string' ? text : this.text.shift(); // current statement
+    this.scrolling = scrolling;
+    this.options = options;
+    this.completed = false;
+    this.lastText = false;
+    this.speechOutput = true;
+    this.lastKey = new Date().getTime();
+    this.loaded = true;
+  },
+  // Update & Scroll
+  tick: function (time) {
+    if (!this.loaded) return;
+    // Check for Dialogue Completion (TODO - manual triggers + scroll / sections)
+    if (this.options && this.options.autoclose) {
+      this.endTime = this.endTime ? this.endTime : this.options.endTime ?? new Date().getTime() + (this.options.duration * 1000 ?? 10000); // 10 seconds default if autoclose
+      if (time > this.endTime) {
+        this.completed = true;
+      }
+    }
+    // Handle Input
+    this.checkInput(time);
+
+    // Dialogue
+    this.sprite.speak(this.displayText, false, this);
+
+    // Callback on Completion
+    if (this.completed && this.options.onClose) {
+      if (this.sprite.speech.clearHud) {
+        this.sprite.speech.clearHud();
+      }
+      this.options.onClose();
+    }
+    return this.completed;
+  },
+  // Handle Keyboard
+  checkInput: function (time) {
+    if (time > this.lastKey + 100) {
+      switch (this.engine.keyboard.lastPressedCode()) {
+        case 'Escape':
+          this.sprite.speak(false);
+          this.completed = true; // toggle
+          break;
+        case 'Enter':
+          if (typeof this.text === 'string' || this.text.length === 0) {
+            this.sprite.speak(false);
+            this.completed = true;
+          } else {
+            this.completed = false;
+            this.displayText = this.text.shift();
+            window.speechSynthesis.cancel();
+            this.speechOutput = true;
+            this.sprite.speak(this.displayText, false, this);
+          }
+          break;
+      }
+      // gamepad
+      if (this.engine.gamepad.keyPressed('a')) {
+        if (typeof this.text === 'string' || this.text.length === 0) {
+          this.sprite.speak(false);
+          this.completed = true;
+        } else {
+          this.completed = false;
+          this.displayText = this.text.shift();
+          window.speechSynthesis.cancel();
+          this.speechOutput = true;
+          this.sprite.speak(this.displayText, false, this);
+        }
+        return;
+      }
+    }
+  },
+};

package/src/engine/actions/face.js

@@ -0,0 +1,22 @@
+/*                                                 *\
+** ----------------------------------------------- **
+**          Calliope - Pixos Game Engine   	       **
+** ----------------------------------------------- **
+**  Copyright (c) 2020-2025 - Kyle Derby MacInnis  **
+**                                                 **
+**    Any unauthorized distribution or transfer    **
+**       of this work is strictly prohibited.      **
+**                                                 **
+**               All Rights Reserved.              **
+** ----------------------------------------------- **
+\*                                                 */
+
+export default {
+  init: function (facing) {
+    this.facing = facing;
+  },
+  tick: function (time) {
+    if (this.facing && this.facing != this.sprite.facing) this.sprite.setFacing(this.facing);
+    return true;
+  },
+};

package/src/engine/actions/greeting.js

@@ -0,0 +1,28 @@
+/*                                                 *\
+** ----------------------------------------------- **
+**          Calliope - Pixos Game Engine   	       **
+** ----------------------------------------------- **
+**  Copyright (c) 2020-2025 - Kyle Derby MacInnis  **
+**                                                 **
+**    Any unauthorized distribution or transfer    **
+**       of this work is strictly prohibited.      **
+**                                                 **
+**               All Rights Reserved.              **
+** ----------------------------------------------- **
+\*                                                 */
+
+export default {
+  // Initialize Dialogue Object
+  init: function (greeting, options = {}) {
+    this.engine = this.sprite.engine;
+    this.greeting = greeting;
+    this.options = options;
+    this.completed = false;
+  },
+  // Update & Scroll
+  tick: function (time) {
+    if (!this.loaded) return;
+    this.sprite.setGreeting(this.text);
+    return true;
+  },
+};

package/src/engine/actions/interact.js

@@ -0,0 +1,86 @@
+/*                                                 *\
+** ----------------------------------------------- **
+**          Calliope - Pixos Game Engine   	       **
+** ----------------------------------------------- **
+**  Copyright (c) 2020-2025 - Kyle Derby MacInnis  **
+**                                                 **
+**    Any unauthorized distribution or transfer    **
+**       of this work is strictly prohibited.      **
+**                                                 **
+**               All Rights Reserved.              **
+** ----------------------------------------------- **
+\*                                                 */
+
+import { Vector } from '@Engine/utils/math/vector.js';
+import { Direction } from '@Engine/utils/enums.js';
+
+export default {
+  init: async function (from, facing, world) {
+    this.world = world;
+    this.from = new Vector(...from);
+    this.facing = facing;
+    this.offset = Direction.toOffset(facing);
+    this.lastKey = new Date().getTime();
+    this.completed = false;
+    // Determine Tile
+    this.to = [from[0] + this.offset[0], from[1] + this.offset[1]];
+    // Check for Sprites at that point
+    this.zone = world.zoneContaining(...this.to);
+    // Trigger interaction on Sprite
+    this.spriteList = this.zone.spriteList.filter((sprite) => sprite.pos.x === this.to[0] && sprite.pos.y === this.to[1]);
+    this.objectList = this.zone.objectList.filter((object) => object.pos.x === this.to[0] && object.pos.y === this.to[1]);
+    // -- pass through reference to "finish()" callback
+    this.finish = this.finish.bind(this);
+    // Trigger
+    this.interact();
+  },
+  // Trigger interactions in sprites
+  interact: async function () {
+    if (this.spriteList.length === 0 && this.objectList.length === 0) this.completed = true;
+    // objects
+    await Promise.all(this.objectList.map(async (object) => {
+      let faceChange = object.faceDir(Direction.reverse(this.facing));
+      if (faceChange) {
+        object.addAction(faceChange); // face towards avatar
+      }
+      return object.interact ? await this.zone.objectDict[object.id].interact(this.sprite, this.finish) : null;
+    }));
+    // sprite
+    await Promise.all(this.spriteList.map(async (sprite) => {
+      let faceChange = sprite.faceDir(Direction.reverse(this.facing));
+      if (faceChange) {
+        sprite.addAction(faceChange); // face towards avatar
+      }
+      return sprite.interact ? await this.zone.spriteDict[sprite.id].interact(this.sprite, this.finish) : null;
+    }));
+  },
+  // Callback to clear interaction
+  finish: function (result) {
+    if (result) this.completed = true;
+  },
+  // check input and completion
+  tick: function (time) {
+    if (!this.loaded) return;
+    this.checkInput(time);
+    return this.completed; // loop
+  },
+  // Handle Keyboard
+  checkInput: function (time) {
+    if (time > this.lastKey + Math.max(this.length, 200)) {
+      switch (this.sprite.engine.keyboard.lastPressed('q')) {
+        // close dialogue on q key press
+        case 'q':
+          // Needs to Cancel the Interaction on the Affected Sprite as well
+          this.completed = true; // toggle
+          break;
+        default:
+          this.lastKey = new Date().getTime();
+          return null;
+      }
+    }
+    // gamepad
+    if (this.sprite.engine.gamepad.keyPressed('a')) {
+      this.completed = true;
+    }
+  },
+};

package/src/engine/actions/move.js

@@ -0,0 +1,67 @@
+/*                                                 *\
+** ----------------------------------------------- **
+**          Calliope - Pixos Game Engine   	       **
+** ----------------------------------------------- **
+**  Copyright (c) 2020-2025 - Kyle Derby MacInnis  **
+**                                                 **
+**    Any unauthorized distribution or transfer    **
+**       of this work is strictly prohibited.      **
+**                                                 **
+**               All Rights Reserved.              **
+** ----------------------------------------------- **
+\*                                                 */
+
+import { Vector, set, lerp } from '@Engine/utils/math/vector.js';
+import { Direction } from '@Engine/utils/enums.js';
+
+export default {
+  init: function (from, to, length, zone) {
+    this.zone = zone;
+    this.from = new Vector(...from);
+    this.to = new Vector(...to);
+    this.facing = Direction.fromOffset([Math.round(to.x - from.x), Math.round(to.y - from.y)]);
+    this.length = length;
+    this.spriteList = this.zone.spriteList.filter((sprite) => sprite.pos.x === this.to.x && sprite.pos.y === this.to.y);
+  },
+  // move
+  tick: function (time) {
+    if (!this.loaded) return;
+    // Set facing
+    if (this.facing && this.facing != this.sprite.facing) this.sprite.setFacing(this.facing);
+    // Transition & Move
+    let endTime = this.startTime + this.length;
+    let frac = (time - this.startTime) / this.length;
+    if (time >= endTime) {
+      this.sprite.pos.x = this.to.x;
+      this.sprite.pos.y = this.to.y;
+      let hx = this.sprite.pos.x + this.sprite.hotspotOffset.x;
+      let hy = this.sprite.pos.y + this.sprite.hotspotOffset.y;
+      this.sprite.pos.z = this.sprite.zone.getHeight(hx, hy);
+      frac = 1;
+      this.onStep();
+      // Get next frame
+      let newFrame = Math.floor(frac * 4);
+      if (newFrame != this.sprite.animFrame) this.sprite.setFrame(newFrame);
+      return time >= endTime;
+    } else {
+      this.sprite.pos.x = this.from.x + frac * (this.to.x - this.from.x);
+      this.sprite.pos.y = this.from.y + frac * (this.to.y - this.from.y);
+      let hx = this.sprite.pos.x + this.sprite.hotspotOffset.x;
+      let hy = this.sprite.pos.y + this.sprite.hotspotOffset.y;
+      this.sprite.pos.z = this.sprite.zone.getHeight(hx, hy);
+      // Get next frame
+      let newFrame = Math.floor(frac * 4);
+      if (newFrame != this.sprite.animFrame) this.sprite.setFrame(newFrame);
+    }
+    return false;
+  },
+  // Trigger interactions in sprite when finished moving
+  onStep: async function () {
+    if (this.spriteList.length === 0) this.completed = true;
+    await Promise.all(
+      this.spriteList.map(async (sprite) => {
+        return sprite.onStep ? await sprite.onStep(sprite, sprite) : null;
+      })
+    );
+  },
+};

package/src/engine/actions/patrol.js

@@ -0,0 +1,109 @@
+/*                                                 *\
+** ----------------------------------------------- **
+**          Calliope - Pixos Game Engine   	       **
+** ----------------------------------------------- **
+**  Copyright (c) 2020-2025 - Kyle Derby MacInnis  **
+**                                                 **
+**    Any unauthorized distribution or transfer    **
+**       of this work is strictly prohibited.      **
+**                                                 **
+**               All Rights Reserved.              **
+** ----------------------------------------------- **
+\*                                                 */
+
+import { Vector } from '@Engine/utils/math/vector.js';
+import { Direction } from '@Engine/utils/enums.js';
+import { ActionLoader } from '@Engine/utils/loaders/index.js';
+
+export default {
+  init: async function (from, to, moveLength, zone) {
+    this.zone = zone;
+    this.from = new Vector(...from);
+    this.to = new Vector(...to);
+    this.lastKey = new Date().getTime();
+    this.completed = false;
+    this.direction = 1;
+    this.audio = await this.zone.engine.resourceManager.audioLoader.loadFromZip(this.sprite.zip, this.sprite.patrolSound ?? 'sewer-beat.mp3', true);
+    // Determine Path to Walk
+    [this.hasMoves, this.moveList] = this.sprite.zone.world.pathFind(from, to);
+    if (!this.hasMoves) {
+      this.completed = true; // no path - do not patrol
+    }
+    this.moveIndex = 1; // holds index position
+    this.moveLength = moveLength; // length of time per move
+
+    if (this.zone.audio) this.zone.audio.pauseAudio();
+    if (this.audio) this.audio.playAudio();
+  },
+  tick: function (time) {
+    if (!this.loaded) return;
+    this.checkInput(time);
+    // load up moves - todo (improve this and make it less manual)
+    let endTime = this.startTime + this.moveLength;
+    if (time > endTime) {
+      let move = this.moveList[this.moveIndex];
+      if (this.moveList.length > 2) {
+        // last position (for facing)
+        let last =
+          this.moveIndex == 0
+            ? this.moveList[this.moveIndex + 1]
+            : this.moveIndex + 1 >= this.moveList.length
+            ? this.moveList[this.moveList.length - 1]
+            : this.moveList[this.moveIndex - 1];
+        let facing = Direction.fromOffset([Math.round(move[0] - last[0]), Math.round(move[1] - last[1])]);
+        // Check for zone change
+        if (!this.sprite.zone.isInZone(move[0], move[1])) {
+          let zone = this.sprite.zone.world.zoneContaining(move[0], move[1]);
+          if (!zone || !zone.loaded || !zone.isWalkable(move[0], move[1], Direction.reverse(facing))) {
+            this.currentAction = this.sprite.faceDir(facing);
+          } else {
+            this.currentAction = new ActionLoader(
+              this.sprite.engine,
+              'changezone',
+              [this.sprite.zone.id, this.sprite.pos.toArray(), zone.id, move, this.moveLength],
+              this.sprite
+            );
+          }
+        } else {
+          // Load Next move
+          this.currentAction = new ActionLoader(this.sprite.engine, 'move', [last, move, this.moveLength, this.zone], this.sprite);
+        }
+
+        if (this.sprite.facing !== facing) {
+          this.currentAction = this.sprite.faceDir(facing);
+          // return this.completed;
+        }
+
+        if (this.currentAction) {
+          this.currentAction.facing = facing;
+          this.sprite.addAction(Promise.resolve(this.currentAction)).then(() => {});
+        }
+      }
+      // stop when done
+      if (this.moveIndex + this.direction >= this.moveList.length) {
+        this.direction *= -1;
+        this.completed = true;
+        if (this.zone.audio) this.zone.audio.playAudio();
+        if (this.audio) this.audio.pauseAudio();
+      }
+      this.moveIndex += this.direction;
+      this.startTime = time;
+    }
+    return this.completed; // loop
+  },
+  // Handle Keyboard
+  checkInput: function (time) {
+    if (time > this.lastKey + Math.max(this.moveLength, 200)) {
+      switch (this.sprite.engine.keyboard.lastPressed('q')) {
+        // quit on q key press
+        case 'q':
+          if (this.zone.audio) this.zone.audio.playAudio();
+          if (this.audio) this.audio.pauseAudio();
+          this.completed = true; // toggle
+        default:
+          this.lastKey = new Date().getTime();
+          return null;
+      }
+    }
+  },
+};

package/src/engine/actions/prompt.js

@@ -0,0 +1,185 @@
+/*                                                 *\
+** ----------------------------------------------- **
+**          Calliope - Pixos Game Engine   	       **
+** ----------------------------------------------- **
+**  Copyright (c) 2020-2025 - Kyle Derby MacInnis  **
+**                                                 **
+**    Any unauthorized distribution or transfer    **
+**       of this work is strictly prohibited.      **
+**                                                 **
+**               All Rights Reserved.              **
+** ----------------------------------------------- **
+\*                                                 */
+
+export default {
+  // Initialize Dialogue Object
+  init: function (menu, activeMenus, scrolling = true, options = {}) {
+    this.engine = this.sprite.engine;
+    this.text = '';
+    this.scrolling = scrolling;
+    this.line = 0;
+    this.options = options;
+    this.completed = false;
+    this.lastKey = new Date().getTime();
+    this.listenerId = this.engine.gamepad.attachListener(this.hookListener());
+    this.touches = [];
+    this.menuDict = menu ?? {};
+    this.activeMenus = activeMenus ?? [];
+    this.selectedMenu = {};
+    this.selectedMenuId = null;
+    this.isTouched = false;
+  },
+  // Update & Scroll
+  tick: function (time) {
+    if (!this.loaded) return;
+    // Check for Dialogue Completion (TODO - manual triggers + scroll / sections)
+    if (this.options && this.options.autoclose) {
+      this.endTime = this.endTime ? this.endTime : this.options.endTime ?? new Date().getTime() + 10000; // 10 seconds default if autoclose
+      if (time > this.endTime) {
+        this.completed = true;
+      }
+    }
+
+    // Handle Input
+    this.checkInput(time);
+    // Draw Active Menus to Screen
+    Object.keys(this.menuDict)
+      .filter((key) => this.activeMenus.includes(key))
+      .map((id) => {
+        let section = this.menuDict[id];
+        let colors = section.colours;
+        if (section.active) {
+          colors['background'] = '#555';
+        }
+        this.engine.hud.drawButton(section.text, section.x, section.y, section.w, section.h, section.colours);
+      });
+
+    this.textbox = this.engine.hud.scrollText(this.prompt + this.text, this.scrolling, this.options);
+
+    if (this.completed) {
+      this.unhookListener();
+      // this.engine.hud.clearHud();
+    }
+    return this.completed;
+  },
+
+  unhookListener: function () {
+    // remove listener
+    this.engine.gamepad.removeListener(this.listenerId);
+    this.listenerId = null;
+  },
+
+  hookListener: function () {
+    /**
+     * Normalize event to extract touches array.
+     * Works with mouse events, touch events, and pre-processed events from WebGLView.
+     */
+    const normalizeTouches = (e) => {
+      // Pre-computed canvas coordinates from WebGLView
+      if (e.canvasX !== undefined && e.canvasY !== undefined) {
+        return [{ x: e.canvasX, y: e.canvasY, identifier: 'normalized' }];
+      }
+      // Touch events
+      if (e.touches && e.touches.length > 0) {
+        return Array.from(e.touches).map(t => ({ x: t.clientX, y: t.clientY, identifier: t.identifier }));
+      }
+      // Touch end uses changedTouches
+      if (e.changedTouches && e.changedTouches.length > 0) {
+        return Array.from(e.changedTouches).map(t => ({ x: t.clientX, y: t.clientY, identifier: t.identifier }));
+      }
+      // Mouse events
+      if (e.clientX !== undefined && e.clientY !== undefined) {
+        return [{ x: e.clientX, y: e.clientY, identifier: 'mouse' }];
+      }
+      // Already normalized (legacy format)
+      if (e.touches) {
+        return e.touches;
+      }
+      return [];
+    };
+    
+    let touchstart = (e) => {
+      const touches = normalizeTouches(e);
+      this.isTouched = true;
+      this.touches = touches;
+      if (this.isTouched && this.touches.length > 0 && this.lastKey + 100 < new Date().getTime()) {
+        let x = this.touches[0].x;
+        let y = this.touches[0].y;
+        let self = this;
+        self.activeMenus
+          .filter((key) => {
+            let w = self.menuDict[key];
+            if (x < w.x + w.w && x > w.x && y < w.y + w.h && y > w.y) {
+              return true;
+            }
+            return false;
+          })
+          .map((key) => {
+            let w = self.menuDict[key];
+            if (w.trigger) w.trigger(this);
+            if (w.children) {
+              self.activeMenus = w.children;
+            }
+          });
+      }
+    };
+    let touchmove = (e) => {
+      this.touches = normalizeTouches(e);
+    };
+    let touchend = (e) => {
+      this.isTouched = false;
+      this.touches = normalizeTouches(e);
+    };
+    let mousemove = touchmove;
+    let mousedown = touchstart;
+    let mouseup = touchend;
+    return {
+      touchstart,
+      touchmove,
+      touchend,
+      mousedown,
+      mousemove,
+      mouseup,
+    };
+  },
+  // Handle Keyboard & Mouse & Touch
+  checkInput: function (time) {
+    // TODO -- Reimplement mouse / touch handler support
+
+    // TOOD -- Is there a cleaner way to do this? I feel like this should be less hacky
+    // Keyboard
+    if (time > this.lastKey + 200) {
+      let skipChar = false;
+      switch (this.engine.keyboard.lastPressedCode()) {
+        case 'Escape':
+          this.completed = true;
+          skipChar = true;
+          break;
+        case 'Backspace':
+          let arr = this.text.split('');
+          arr.pop();
+          this.text = arr.join('');
+          this.lastKey = time;
+          skipChar = true;
+          break;
+        case 'Enter':
+          this.sprite.setGreeting(this.text);
+          if (this.sprite.speech.clearHud) this.sprite.speech.clearHud();
+          this.speechbox = this.sprite.speech.scrollText(this.text);
+          this.sprite.speech.loadImage();
+          this.completed = true;
+          skipChar = true;
+          break;
+      }
+      // debounce keypresses
+      // write to chat box
+      if (!skipChar) {
+        let char = this.engine.keyboard.lastPressedKey();
+        if (char) {
+          this.lastKey = time;
+          this.text += '' + char;
+        }
+      }
+    }
+  },
+};

package/src/engine/actions/script.js

@@ -0,0 +1,42 @@
+/*                                                 *\
+** ----------------------------------------------- **
+**          Calliope - Pixos Game Engine   	       **
+** ----------------------------------------------- **
+**  Copyright (c) 2020-2025 - Kyle Derby MacInnis  **
+**                                                 **
+**    Any unauthorized distribution or transfer    **
+**       of this work is strictly prohibited.      **
+**                                                 **
+**               All Rights Reserved.              **
+** ----------------------------------------------- **
+\*                                                 */
+
+import { debug } from '@Engine/utils/debug-logger.js';
+
+export default {
+  init: function (triggerId, zone, onCompleted = null) {
+    this.zone = zone;
+    this.world = zone.world;
+    this.lastKey = new Date().getTime();
+    this.completed = false;
+    this.onCompleted = () => debug('Script', 'script finished');
+    if (onCompleted) this.onCompleted = onCompleted;
+    // Determine Tile
+    this.triggerId = triggerId;
+    // Trigger
+    this.triggerScript();
+  },
+  // Trigger interactions in sprites
+  triggerScript: function () {
+    if (!this.triggerId) this.completed = true;
+    Promise.all(this.zone.scripts.filter((x) => x.id === this.triggerId).map(async (x) => await x.trigger.call(this.zone))).then(() => {
+      this.completed = true;
+    });
+  },
+  // check input and completion
+  tick: function (time) {
+    if (!this.loaded) return;
+    if (this.completed) this.onCompleted();
+    return this.completed; // loop
+  },
+};