@inglorious/engine 1.1.0 → 2.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inglorious/engine",
-  "version": "1.1.0",
+  "version": "2.1.0",
   "description": "A JavaScript game engine written with global state, immutability, and pure functions in mind. Have fun(ctional programming) with it!",
   "author": "IceOnFire <antony.mistretta@gmail.com> (https://ingloriouscoderz.it)",
   "license": "MIT",
@@ -31,12 +31,17 @@
   },
   "dependencies": {
     "@inglorious/store": "4.0.0",
-    "@inglorious/utils": "3.2.0"
+    "@inglorious/utils": "3.5.0"
+  },
+  "peerDependencies": {
+    "@inglorious/store": "4.0.0",
+    "@inglorious/utils": "3.5.0"
   },
   "devDependencies": {
     "prettier": "^3.5.3",
     "vite": "^7.1.3",
-    "vitest": "^1.6.0"
+    "vitest": "^1.6.0",
+    "@inglorious/eslint-config": "1.0.0"
   },
   "engines": {
     "node": ">= 22"

package/src/behaviors/camera.js

@@ -57,7 +57,7 @@ export function camera(params) {
       }
     },
 
-    mouseWheel(entity, { deltaY }) {
+    mouseWheel(entity, deltaY) {
       const delta = Math.sign(deltaY)
       // Scrolling down (positive deltaY) should zoom out (decrease zoom value)
       entity.targetZoom -= delta * entity.zoomSpeed * entity.zoomSensitivity

package/src/behaviors/input/controls.js

@@ -1,37 +1,21 @@
-import { extend } from "@inglorious/utils/data-structures/objects.js"
-
 import { createGamepad, gamepadListener, gamepadsPoller } from "./gamepad.js"
 import { createInput, input } from "./input.js"
 import { createKeyboard, keyboard } from "./keyboard.js"
 
-const DEFAULT_PARAMS = {
-  name: "input0",
-}
-
-export function setupControls(params) {
-  params = extend(DEFAULT_PARAMS, params)
-
+export function controls(...targetIds) {
   return {
-    types: {
-      keyboard: [keyboard(params)],
-      gamepads_poller: [gamepadsPoller(params)],
-      gamepad_listener: [gamepadListener(params)],
-      input: [input(params)],
-    },
-    entities: {
-      gamepads: { type: "gamepads_poller" },
-    },
+    keyboard: [keyboard()],
+    gamepads_poller: [gamepadsPoller(targetIds)],
+    gamepad_listener: [gamepadListener()],
+    input: [input()],
   }
 }
 
-export function controlsEntities(
-  name = DEFAULT_PARAMS.name,
-  targetIds,
-  mapping = {},
-) {
+export function createControls(targetId, mapping = {}) {
   return {
-    [`keyboard_${name}`]: createKeyboard(`keyboard_${name}`, name, mapping),
-    [`gamepad_${name}`]: createGamepad(`gamepad_${name}`, name, mapping),
-    [name]: createInput(name, targetIds, mapping),
+    gamepads: { type: "gamepads_poller" },
+    [`keyboard_${targetId}`]: createKeyboard(targetId, mapping),
+    [`gamepad_${targetId}`]: createGamepad(targetId, mapping),
+    [`input_${targetId}`]: createInput(targetId, mapping),
   }
 }

package/src/behaviors/input/gamepad.js

@@ -1,8 +1,4 @@
-const DEFAULT_PARAMS = {
-  name: "gamepad_input0",
-}
-
-export function gamepadsPoller() {
+export function gamepadsPoller(targetIds = []) {
   return {
     create(entity, entityId) {
       if (entityId !== entity.id) return
@@ -12,9 +8,7 @@ export function gamepadsPoller() {
 
     update(entity, dt, api) {
       navigator.getGamepads().forEach((gamepad) => {
-        if (gamepad == null) {
-          return
-        }
+        if (gamepad == null) return
 
         const cache = (entity.gamepadStateCache[gamepad.index] ??= {
           axes: [],
@@ -22,12 +16,10 @@ export function gamepadsPoller() {
         })
 
         gamepad.axes.forEach((axis, index) => {
-          if (axis === cache.axes[index]) {
-            return
-          }
+          if (axis === cache.axes[index]) return
 
           api.notify("gamepadAxis", {
-            gamepadIndex: gamepad.index,
+            targetId: targetIds[gamepad.index],
             axis: `Axis${index}`,
             value: axis,
           })
@@ -40,12 +32,12 @@ export function gamepadsPoller() {
 
           if (isPressed && !wasPressed) {
             api.notify("gamepadPress", {
-              gamepadIndex: gamepad.index,
+              targetId: targetIds[gamepad.index],
               button: `Btn${index}`,
             })
           } else if (!isPressed && wasPressed) {
             api.notify("gamepadRelease", {
-              gamepadIndex: gamepad.index,
+              targetId: targetIds[gamepad.index],
               button: `Btn${index}`,
             })
           }
@@ -59,58 +51,42 @@ export function gamepadsPoller() {
 
 export function gamepadListener() {
   return {
-    gamepadAxis(entity, { gamepadIndex, axis, value }, api) {
-      if (entity.id !== `gamepad_input${gamepadIndex}`) {
-        return
-      }
+    gamepadAxis(entity, { targetId, axis, value }, api) {
+      if (targetId !== entity.targetId) return
 
       const action = entity.mapping[axis]
-      if (!action) {
-        return
-      }
+      if (!action) return
 
       entity[action] = value
-      api.notify("inputAxis", { controlId: entity.id, action, value })
+      api.notify("inputAxis", { targetId, action, value })
     },
 
-    gamepadPress(entity, { gamepadIndex, button }, api) {
-      if (entity.id !== `gamepad_input${gamepadIndex}`) {
-        return
-      }
+    gamepadPress(entity, { targetId, button }, api) {
+      if (targetId !== entity.targetId) return
 
       const action = entity.mapping[button]
-      if (!action) {
-        return
-      }
+      if (!action) return
 
       if (!entity[action]) {
         entity[action] = true
-        api.notify("inputPress", { controlId: entity.id, action })
+        api.notify("inputPress", { targetId, action })
       }
     },
 
-    gamepadRelease(entity, { gamepadIndex, button }, api) {
-      if (entity.id !== `gamepad_input${gamepadIndex}`) {
-        return
-      }
+    gamepadRelease(entity, { targetId, button }, api) {
+      if (targetId !== entity.targetId) return
 
       const action = entity.mapping[button]
-      if (!action) {
-        return
-      }
+      if (!action) return
 
       if (entity[action]) {
         entity[action] = false
-        api.notify("inputRelease", { controlId: entity.id, action })
+        api.notify("inputRelease", { targetId, action })
       }
     },
   }
 }
 
-export function createGamepad(
-  name = DEFAULT_PARAMS.name,
-  targetInput,
-  mapping = {},
-) {
-  return { id: name, type: "gamepad_listener", targetInput, mapping }
+export function createGamepad(targetId, mapping = {}) {
+  return { type: "gamepad_listener", targetId, mapping }
 }

package/src/behaviors/input/input.js

@@ -1,48 +1,31 @@
-const DEFAULT_PARAMS = {
-  name: "input0",
-}
-
 export function input() {
   return {
-    inputAxis(entity, { controlId, action, value }, api) {
-      if (!controlId.endsWith(entity.id)) {
-        return
-      }
+    inputAxis(entity, { targetId, action, value }, api) {
+      if (targetId !== entity.targetId) return
+
       entity[action] = value
 
-      entity.targetIds.forEach((targetId) => {
-        api.notify(action, { entityId: targetId, value })
-      })
+      api.notify(action, { entityId: entity.targetId, value })
     },
 
-    inputPress(entity, { controlId, action }, api) {
-      if (!controlId.endsWith(entity.id)) {
-        return
-      }
+    inputPress(entity, { targetId, action }, api) {
+      if (targetId !== entity.targetId) return
+
       entity[action] = true
 
-      entity.targetIds.forEach((targetId) => {
-        api.notify(action, targetId)
-      })
+      api.notify(action, entity.targetId)
     },
 
-    inputRelease(entity, { controlId, action }, api) {
-      if (!controlId.endsWith(entity.id)) {
-        return
-      }
+    inputRelease(entity, { targetId, action }, api) {
+      if (targetId !== entity.targetId) return
+
       entity[action] = false
 
-      entity.targetIds.forEach((targetId) => {
-        api.notify(`${action}End`, targetId)
-      })
+      api.notify(`${action}End`, entity.targetId)
     },
   }
 }
 
-export function createInput(
-  name = DEFAULT_PARAMS.name,
-  targetIds = [],
-  mapping = {},
-) {
-  return { id: name, type: "input", targetIds, mapping }
+export function createInput(targetId, mapping = {}) {
+  return { type: "input", targetId, mapping }
 }

package/src/behaviors/input/keyboard.js

@@ -1,7 +1,3 @@
-const DEFAULT_PARAMS = {
-  name: "keyboard0",
-}
-
 export function keyboard() {
   let handleKeyDown, handleKeyUp
   let currentDocument = null
@@ -26,36 +22,28 @@ export function keyboard() {
 
     keyboardKeyDown(entity, keyCode, api) {
       const action = entity.mapping[keyCode]
-      if (!action) {
-        return
-      }
+      if (!action) return
 
       if (!entity[action]) {
         entity[action] = true
-        api.notify("inputPress", { controlId: entity.id, action })
+        api.notify("inputPress", { targetId: entity.targetId, action })
       }
     },
 
     keyboardKeyUp(entity, keyCode, api) {
       const action = entity.mapping[keyCode]
-      if (!action) {
-        return
-      }
+      if (!action) return
 
       if (entity[action]) {
         entity[action] = false
-        api.notify("inputRelease", { controlId: entity.id, action })
+        api.notify("inputRelease", { targetId: entity.targetId, action })
       }
     },
   }
 }
 
-export function createKeyboard(
-  name = DEFAULT_PARAMS.name,
-  targetInput,
-  mapping = {},
-) {
-  return { id: name, type: "keyboard", targetInput, mapping }
+export function createKeyboard(targetId, mapping = {}) {
+  return { type: "keyboard", targetId, mapping }
 }
 
 function createKeyboardHandler(id, api) {

package/src/behaviors/input/mouse.js

@@ -1,12 +1,10 @@
 import { findCollision } from "@inglorious/engine/collision/detection.js"
 import { clampToBounds } from "@inglorious/engine/physics/bounds.js"
 import { zero } from "@inglorious/utils/math/vector.js"
-
-const DEFAULT_PARAMS = {
-  name: "mouse",
-}
+import { v } from "@inglorious/utils/v.js"
 
 const NO_Y = 0
+const HALF = 2
 
 export function mouse() {
   return {
@@ -37,10 +35,10 @@ export function mouse() {
   }
 }
 
-export function track(parent, options) {
-  const handleMouseMove = createHandler("mouseMove", parent, options)
-  const handleClick = createHandler("mouseClick", parent, options)
-  const handleWheel = createHandler("mouseWheel", parent, options)
+export function trackMouse(parent, api) {
+  const handleMouseMove = createHandler("mouseMove", parent, api)
+  const handleClick = createHandler("mouseClick", parent, api)
+  const handleWheel = createHandler("mouseWheel", parent, api)
 
   return {
     onMouseMove: handleMouseMove,
@@ -49,9 +47,8 @@ export function track(parent, options) {
   }
 }
 
-export function createMouse(name = DEFAULT_PARAMS.name, overrides = {}) {
+export function createMouse(overrides = {}) {
   return {
-    id: name,
     type: "mouse",
     layer: 999, // A high layer value to ensure it's always rendered on top
     position: zero(),
@@ -61,30 +58,50 @@ export function createMouse(name = DEFAULT_PARAMS.name, overrides = {}) {
 
 function createHandler(type, parent, api) {
   return (event) => {
+    event.preventDefault()
     event.stopPropagation()
 
     if (parent == null) {
       return
     }
 
-    // For wheel events, the payload is different from other mouse events.
     if (type === "mouseWheel") {
-      api.notify(type, { deltaY: event.deltaY })
+      api.notify(type, event.deltaY)
       return
     }
 
-    // For move and click events, the payload is the calculated position.
-    const payload = calculatePosition(event, parent)
+    const payload = calculatePosition(event, parent, api)
     api.notify(type, payload)
   }
 }
 
-function calculatePosition(event, parent) {
+function calculatePosition(event, parent, api) {
   const { clientX, clientY } = event
-  const { left, bottom } = parent.getBoundingClientRect()
+  const {
+    left,
+    bottom,
+    width: canvasWidth,
+    height: canvasHeight,
+  } = parent.getBoundingClientRect()
 
   const x = clientX - left
-  const z = bottom - clientY
+  const y = bottom - clientY
+
+  const game = api.getEntity("game")
+  const [gameWidth, gameHeight] = game.size
+
+  const scaleX = canvasWidth / gameWidth
+  const scaleY = canvasHeight / gameHeight
+  const scale = Math.min(scaleX, scaleY)
+
+  const scaledGameWidth = gameWidth * scale
+  const scaledGameHeight = gameHeight * scale
+
+  const offsetX = (canvasWidth - scaledGameWidth) / HALF
+  const offsetY = (canvasHeight - scaledGameHeight) / HALF
+
+  const gameX = (x - offsetX) / scale
+  const gameY = (y - offsetY) / scale
 
-  return [x, NO_Y, z]
+  return v(gameX, NO_Y, gameY)
 }

package/src/behaviors/input/touch.js

@@ -0,0 +1,127 @@
+import { findCollision } from "@inglorious/engine/collision/detection.js"
+import { clampToBounds } from "@inglorious/engine/physics/bounds.js"
+import { magnitude, zero } from "@inglorious/utils/math/vector.js"
+import { subtract } from "@inglorious/utils/math/vectors.js"
+import { v } from "@inglorious/utils/v.js"
+
+const NO_Y = 0
+const MOVEMENT_THRESHOLD = 5
+const HALF = 2
+
+export function touch() {
+  return {
+    create(entity, entityId) {
+      if (entityId !== entity.id) return
+
+      entity.collisions ??= {}
+      entity.collisions.bounds ??= { shape: "point" }
+    },
+
+    touchStart(entity, position) {
+      entity.isSwiping = false
+      entity.position = position
+    },
+
+    touchMove(entity, position, api) {
+      const game = api.getEntity("game")
+
+      const delta = subtract(position, entity.position)
+
+      if (magnitude(delta) > MOVEMENT_THRESHOLD) {
+        entity.isSwiping = true
+      }
+
+      entity.position = position
+
+      clampToBounds(entity, game.size)
+    },
+
+    touchEnd(entity, _, api) {
+      if (entity.isSwiping) {
+        api.notify("swipe", v(...entity.position))
+        entity.isSwiping = false
+        return
+      }
+
+      const entities = api.getEntities()
+      const clickedEntity = findCollision(entity, entities)
+      if (clickedEntity) {
+        api.notify("entityTouch", clickedEntity.id)
+      } else {
+        api.notify("sceneTouch", v(...entity.position))
+      }
+    },
+  }
+}
+
+export function trackTouch(parent, api) {
+  const handleTouchStart = createHandler("touchStart", parent, api)
+  const handleTouchMove = createHandler("touchMove", parent, api)
+  const handleTouchEnd = createHandler("touchEnd", parent, api)
+
+  return {
+    onTouchStart: handleTouchStart,
+    onTouchMove: handleTouchMove,
+    onTouchEnd: handleTouchEnd,
+  }
+}
+
+export function createTouch(overrides = {}) {
+  return {
+    type: "touch",
+    layer: 999, // A high layer value to ensure it's always rendered on top
+    position: zero(),
+    ...overrides,
+  }
+}
+
+function createHandler(type, parent, api) {
+  return (event) => {
+    event.preventDefault()
+    event.stopPropagation()
+
+    if (parent == null) {
+      return
+    }
+
+    if (type === "touchEnd") {
+      api.notify(type)
+      return
+    }
+
+    const payload = calculatePosition(event, parent, api)
+    api.notify(type, payload)
+  }
+}
+
+function calculatePosition(event, parent, api) {
+  const [touch] = event.touches
+  const { clientX, clientY } = touch
+  const {
+    left,
+    bottom,
+    width: canvasWidth,
+    height: canvasHeight,
+  } = parent.getBoundingClientRect()
+
+  const x = clientX - left
+  const y = bottom - clientY
+
+  const game = api.getEntity("game")
+  const [gameWidth, gameHeight] = game.size
+
+  const scaleX = canvasWidth / gameWidth
+  const scaleY = canvasHeight / gameHeight
+  const scale = Math.min(scaleX, scaleY)
+
+  const scaledGameWidth = gameWidth * scale
+  const scaledGameHeight = gameHeight * scale
+
+  const offsetX = (canvasWidth - scaledGameWidth) / HALF
+  const offsetY = (canvasHeight - scaledGameHeight) / HALF
+
+  const gameX = (x - offsetX) / scale
+  const gameY = (y - offsetY) / scale
+
+  return v(gameX, NO_Y, gameY)
+}

package/src/core/core-events.js

@@ -12,5 +12,8 @@ export const coreEvents = [
   "inputRelease",
   "mouseMove",
   "mouseClick",
+  "touchStart",
+  "touchMove",
+  "touchEnd",
   "spriteAnimationEnd",
 ]

package/src/behaviors/physics/collidable.js

@@ -1,20 +0,0 @@
-import { extend } from "@inglorious/utils/data-structures/objects.js"
-
-const DEFAULT_PARAMS = {
-  onState: "default",
-}
-
-export function collidable(params) {
-  params = extend(DEFAULT_PARAMS, params)
-
-  return (type) =>
-    extend(type, {
-      states: {
-        [params.onState]: {
-          update(entity, dt, api) {
-            type.states?.[params.onState].update?.(entity, dt, api)
-          },
-        },
-      },
-    })
-}