@inglorious/engine 0.1.1 → 0.3.0

package/src/behaviors/controls/kinematic/modern.js

@@ -0,0 +1,76 @@
+import { modernMove } from "@inglorious/engine/movement/kinematic/modern.js"
+import { extend, merge } from "@inglorious/utils/data-structures/objects.js"
+import { zero } from "@inglorious/utils/math/linear-algebra/vector.js"
+
+import { createMovementEventHandlers } from "../event-handlers.js"
+
+const DEFAULT_PARAMS = {
+  maxSpeed: 250,
+}
+const X = 0
+const Z = 2
+
+export function modernVelocity(params) {
+  params = extend(DEFAULT_PARAMS, params)
+
+  return (type) =>
+    extend(type, {
+      ...createMovementEventHandlers([
+        "moveLeft",
+        "moveRight",
+        "moveUp",
+        "moveDown",
+        "moveLeftRight",
+        "moveUpDown",
+      ]),
+
+      start(entity, api) {
+        type.start?.(entity, api)
+
+        entity.maxSpeed ??= params.maxSpeed
+        entity.movement ??= {}
+      },
+
+      update(entity, dt, api) {
+        type.update?.(entity, dt, api)
+
+        const { movement, maxSpeed } = entity
+        entity.velocity = zero()
+
+        if (movement.moveLeft) {
+          entity.velocity[X] = -maxSpeed
+        }
+        if (movement.moveRight) {
+          entity.velocity[X] = maxSpeed
+        }
+        if (movement.moveUp) {
+          entity.velocity[Z] = maxSpeed
+        }
+        if (movement.moveDown) {
+          entity.velocity[Z] = -maxSpeed
+        }
+
+        if (movement.moveLeftRight) {
+          entity.velocity[X] += movement.moveLeftRight * maxSpeed
+        }
+        if (movement.moveUpDown) {
+          entity.velocity[Z] += -movement.moveUpDown * maxSpeed
+        }
+      },
+    })
+}
+
+export function modernControls(params) {
+  const velocityBehavior = modernVelocity(params)
+
+  return (type) => {
+    const newType = velocityBehavior(type)
+
+    return extend(newType, {
+      update(entity, dt, api) {
+        newType.update?.(entity, dt, api)
+        merge(entity, modernMove(entity, dt))
+      },
+    })
+  }
+}

package/src/behaviors/controls/kinematic/shooter.js

@@ -0,0 +1,82 @@
+import { face } from "@inglorious/engine/ai/movement/kinematic/face.js"
+import { tankMove } from "@inglorious/engine/movement/kinematic/tank.js"
+import { extend, merge } from "@inglorious/utils/data-structures/objects.js"
+import { zero } from "@inglorious/utils/math/linear-algebra/vector.js"
+import { pi } from "@inglorious/utils/math/trigonometry.js"
+
+import { createMovementEventHandlers } from "../event-handlers.js"
+
+const FULL_CIRCLE = 2
+const DEFAULT_PARAMS = {
+  maxSpeed: 250,
+  maxAngularSpeed: FULL_CIRCLE * pi(),
+}
+const X = 0
+const Z = 2
+
+export function shooterControls(params) {
+  params = extend(DEFAULT_PARAMS, params)
+
+  const DEADZONE = 0.1
+  const NO_MOVEMENT = 0
+
+  return (type) =>
+    extend(type, {
+      ...createMovementEventHandlers([
+        "moveLeft",
+        "moveRight",
+        "moveUp",
+        "moveDown",
+        "move",
+        "strafe",
+        "turn",
+      ]),
+
+      start(entity, api) {
+        type.start?.(entity, api)
+
+        entity.maxSpeed ??= params.maxSpeed
+        entity.maxAngularSpeed ??= params.maxAngularSpeed
+        entity.movement ??= {}
+      },
+
+      update(entity, dt, api) {
+        const mouse = api.getEntity("mouse")
+
+        const { movement, maxSpeed, maxAngularSpeed } = entity
+        entity.velocity = zero()
+
+        if (movement.moveLeft) {
+          entity.velocity[Z] = -maxSpeed
+        }
+        if (movement.moveRight) {
+          entity.velocity[Z] = maxSpeed
+        }
+        if (movement.moveUp) {
+          entity.velocity[X] = maxSpeed
+        }
+        if (movement.moveDown) {
+          entity.velocity[X] = -maxSpeed
+        }
+
+        if (movement.strafe) {
+          entity.velocity[Z] += movement.strafe * maxSpeed
+        }
+        if (movement.move) {
+          entity.velocity[X] += -movement.move * maxSpeed
+        }
+        if (movement.turn) {
+          entity.orientation += -movement.turn * maxAngularSpeed * dt
+        }
+
+        const isUsingAnalogMovement =
+          Math.abs(movement.move ?? NO_MOVEMENT) > DEADZONE ||
+          Math.abs(movement.strafe ?? NO_MOVEMENT) > DEADZONE
+
+        if (!isUsingAnalogMovement) {
+          merge(entity, face(entity, mouse, dt))
+        }
+        merge(entity, tankMove(entity, dt))
+      },
+    })
+}

package/src/behaviors/controls/kinematic/tank.js

@@ -0,0 +1,67 @@
+import { tankMove } from "@inglorious/engine/movement/kinematic/tank.js"
+import { extend, merge } from "@inglorious/utils/data-structures/objects.js"
+import { zero } from "@inglorious/utils/math/linear-algebra/vector.js"
+
+import { createMovementEventHandlers } from "../event-handlers.js"
+
+const DEFAULT_PARAMS = {
+  maxSpeed: 250,
+  maxAngularSpeed: 10,
+}
+const X = 0
+const Z = 2
+
+export function tankControls(params) {
+  params = extend(DEFAULT_PARAMS, params)
+
+  return (type) =>
+    extend(type, {
+      ...createMovementEventHandlers([
+        "turnLeft",
+        "turnRight",
+        "moveForward",
+        "moveBackward",
+        "strafe",
+        "move",
+        "turn",
+      ]),
+
+      start(entity, api) {
+        type.start?.(entity, api)
+
+        entity.maxSpeed ??= params.maxSpeed
+        entity.maxAngularSpeed ??= params.maxAngularSpeed
+        entity.movement ??= {}
+      },
+
+      update(entity, dt) {
+        const { movement, maxSpeed, maxAngularSpeed } = entity
+        entity.velocity = zero()
+
+        if (movement.turnLeft) {
+          entity.orientation += maxAngularSpeed * dt
+        }
+        if (movement.turnRight) {
+          entity.orientation -= maxAngularSpeed * dt
+        }
+        if (movement.moveForward) {
+          entity.velocity[X] = maxSpeed
+        }
+        if (movement.moveBackward) {
+          entity.velocity[X] = -maxSpeed
+        }
+
+        if (movement.strafe) {
+          entity.velocity[Z] += movement.strafe * maxSpeed
+        }
+        if (movement.move) {
+          entity.velocity[X] += -movement.move * maxSpeed
+        }
+        if (movement.turn) {
+          entity.orientation += -movement.turn * maxAngularSpeed * dt
+        }
+
+        merge(entity, tankMove(entity, dt))
+      },
+    })
+}

package/src/behaviors/debug/collision.js

@@ -0,0 +1,29 @@
+import { extend } from "@inglorious/utils/data-structures/objects.js"
+
+export function collisionGizmos(params) {
+  return (type) =>
+    extend(type, {
+      render(entity, ctx, api) {
+        type.render(entity, ctx, api)
+
+        const game = api.getEntity("game")
+
+        if (!game.debug) {
+          return
+        }
+
+        if (!params?.shapes) {
+          return
+        }
+
+        ctx.save()
+
+        Object.values(entity.collisions).forEach((collision) => {
+          const render = params.shapes[collision.shape]
+          render?.({ ...entity, ...collision, color: "#00FF00" }, ctx, api)
+        })
+
+        ctx.restore()
+      },
+    })
+}

package/src/behaviors/fps.js

@@ -0,0 +1,29 @@
+import { Ticker } from "@inglorious/engine/animation/ticker.js"
+import { extend } from "@inglorious/utils/data-structures/objects.js"
+
+const DEFAULT_PARAMS = {
+  accuracy: 1,
+  size: 16,
+  speed: 1,
+  defaultValue: 0.016666666666666666,
+}
+
+export function fps(params) {
+  params = extend(DEFAULT_PARAMS, params)
+
+  return {
+    start(entity) {
+      entity.dt ??= { ...params }
+    },
+
+    update(entity, dt) {
+      Ticker.tick({
+        target: entity.dt,
+        dt,
+        onTick: (target, dt) => {
+          target.value = dt
+        },
+      })
+    },
+  }
+}

package/src/behaviors/fsm.js

@@ -0,0 +1,33 @@
+import { extend } from "@inglorious/utils/data-structures/objects.js"
+
+const DEFAULT_STATE = "default"
+
+export function fsm(states) {
+  const uniqueEventNames = [
+    ...new Set(Object.values(states).flatMap(Object.keys)),
+  ]
+
+  return (type) => {
+    return extend(type, {
+      start(entity, api) {
+        type.start?.(entity, api)
+
+        entity.state ??= DEFAULT_STATE
+      },
+
+      ...uniqueEventNames.reduce(
+        (acc, eventName) => ({
+          ...acc,
+
+          [eventName](entity, event, api) {
+            type[eventName]?.(entity, event, api)
+
+            const state = states[entity.state]
+            state?.[eventName]?.(entity, event, api)
+          },
+        }),
+        {},
+      ),
+    })
+  }
+}

package/src/{game/decorators → behaviors}/fsm.test.js

@@ -1,54 +1,47 @@
-import { createStore } from "@inglorious/engine/store"
 import { expect, test } from "vitest"
 
-import { enableFsm } from "./fsm"
+import { createStore } from "../core/store.js"
+import { fsm } from "./fsm.js"
 
 test("it should add a finite state machine", () => {
   const config = {
     types: {
       kitty: [
-        enableFsm({
+        fsm({
           default: {
-            "cat:meow"(instance) {
-              instance.state = "meowing"
+            catMeow(entity) {
+              entity.state = "meowing"
             },
           },
           meowing: {
-            "game:update"(instance) {
-              instance.treats++
+            update(entity) {
+              entity.treats++
             },
           },
         }),
       ],
     },
-    instances: {
-      instance1: {
+    entities: {
+      entity1: {
         type: "kitty",
         treats: 0,
       },
     },
   }
-  const store = createStore(config)
   const afterState = {
-    events: [],
-    instances: {
-      game: {
-        id: "game",
-        type: "game",
-        layer: 0,
-        bounds: [0, 0, 800, 600],
-      },
-      instance1: {
-        id: "instance1",
+    entities: {
+      entity1: {
+        id: "entity1",
         type: "kitty",
-        layer: 0,
         state: "meowing",
         treats: 1,
       },
     },
   }
 
-  store.notify({ id: "cat:meow" })
+  const store = createStore(config)
+  store.notify("start")
+  store.notify("catMeow")
   store.update()
 
   const state = store.getState()

package/src/behaviors/game.js

@@ -0,0 +1,15 @@
+export function game() {
+  return {
+    keyboardKeyUp(entity, code) {
+      switch (code) {
+        case "KeyC":
+          entity.debug = !entity.debug
+          break
+
+        case "KeyD":
+          entity.devMode = !entity.devMode
+          break
+      }
+    },
+  }
+}

package/src/behaviors/input/controls.js

@@ -0,0 +1,37 @@
+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)
+
+  return {
+    types: {
+      keyboard: [keyboard(params)],
+      gamepads_poller: [gamepadsPoller(params)],
+      gamepad_listener: [gamepadListener(params)],
+      input: [input(params)],
+    },
+    entities: {
+      gamepads: { type: "gamepads_poller" },
+    },
+  }
+}
+
+export function controlsEntities(
+  name = DEFAULT_PARAMS.name,
+  targetIds,
+  mapping = {},
+) {
+  return {
+    [`keyboard_${name}`]: createKeyboard(`keyboard_${name}`, name, mapping),
+    [`gamepad_${name}`]: createGamepad(`gamepad_${name}`, name, mapping),
+    [name]: createInput(name, targetIds, mapping),
+  }
+}

package/src/behaviors/input/gamepad.js

@@ -0,0 +1,114 @@
+const DEFAULT_PARAMS = {
+  name: "gamepad_input0",
+}
+
+export function gamepadsPoller() {
+  return {
+    start(entity) {
+      entity.gamepadStateCache ??= {}
+    },
+
+    update(entity, dt, api) {
+      navigator.getGamepads().forEach((gamepad) => {
+        if (gamepad == null) {
+          return
+        }
+
+        const cache = (entity.gamepadStateCache[gamepad.index] ??= {
+          axes: [],
+          buttons: [],
+        })
+
+        gamepad.axes.forEach((axis, index) => {
+          if (axis === cache.axes[index]) {
+            return
+          }
+
+          api.notify("gamepadAxis", {
+            gamepadIndex: gamepad.index,
+            axis: `Axis${index}`,
+            value: axis,
+          })
+          cache.axes[index] = axis
+        })
+
+        gamepad.buttons.forEach((button, index) => {
+          const wasPressed = cache.buttons[index]
+          const isPressed = button.pressed
+
+          if (isPressed && !wasPressed) {
+            api.notify("gamepadPress", {
+              gamepadIndex: gamepad.index,
+              button: `Btn${index}`,
+            })
+          } else if (!isPressed && wasPressed) {
+            api.notify("gamepadRelease", {
+              gamepadIndex: gamepad.index,
+              button: `Btn${index}`,
+            })
+          }
+
+          cache.buttons[index] = isPressed
+        })
+      })
+    },
+  }
+}
+
+export function gamepadListener() {
+  return {
+    gamepadAxis(entity, { gamepadIndex, axis, value }, api) {
+      if (entity.id !== `gamepad_input${gamepadIndex}`) {
+        return
+      }
+
+      const action = entity.mapping[axis]
+      if (!action) {
+        return
+      }
+
+      entity[action] = value
+      api.notify("inputAxis", { controlId: entity.id, action, value })
+    },
+
+    gamepadPress(entity, { gamepadIndex, button }, api) {
+      if (entity.id !== `gamepad_input${gamepadIndex}`) {
+        return
+      }
+
+      const action = entity.mapping[button]
+      if (!action) {
+        return
+      }
+
+      if (!entity[action]) {
+        entity[action] = true
+        api.notify("inputPress", { controlId: entity.id, action })
+      }
+    },
+
+    gamepadRelease(entity, { gamepadIndex, button }, api) {
+      if (entity.id !== `gamepad_input${gamepadIndex}`) {
+        return
+      }
+
+      const action = entity.mapping[button]
+      if (!action) {
+        return
+      }
+
+      if (entity[action]) {
+        entity[action] = false
+        api.notify("inputRelease", { controlId: entity.id, action })
+      }
+    },
+  }
+}
+
+export function createGamepad(
+  name = DEFAULT_PARAMS.name,
+  targetInput,
+  mapping = {},
+) {
+  return { id: name, type: "gamepad_listener", targetInput, mapping }
+}

package/src/behaviors/input/input.js

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

package/src/behaviors/input/keyboard.js

@@ -0,0 +1,64 @@
+const DEFAULT_PARAMS = {
+  name: "keyboard0",
+}
+
+export function keyboard() {
+  let handleKeyDown, handleKeyUp
+  let currentDocument = null
+
+  return {
+    start(_, api) {
+      currentDocument = document.body.ownerDocument || document
+
+      handleKeyDown = createKeyboardHandler("keyboardKeyDown", api)
+      handleKeyUp = createKeyboardHandler("keyboardKeyUp", api)
+
+      currentDocument.addEventListener("keydown", handleKeyDown)
+      currentDocument.addEventListener("keyup", handleKeyUp)
+    },
+
+    stop() {
+      currentDocument.removeEventListener("keydown", handleKeyDown)
+      currentDocument.removeEventListener("keyup", handleKeyUp)
+    },
+
+    keyboardKeyDown(entity, keyCode, api) {
+      const action = entity.mapping[keyCode]
+      if (!action) {
+        return
+      }
+
+      if (!entity[action]) {
+        entity[action] = true
+        api.notify("inputPress", { controlId: entity.id, action })
+      }
+    },
+
+    keyboardKeyUp(entity, keyCode, api) {
+      const action = entity.mapping[keyCode]
+      if (!action) {
+        return
+      }
+
+      if (entity[action]) {
+        entity[action] = false
+        api.notify("inputRelease", { controlId: entity.id, action })
+      }
+    },
+  }
+}
+
+export function createKeyboard(
+  name = DEFAULT_PARAMS.name,
+  targetInput,
+  mapping = {},
+) {
+  return { id: name, type: "keyboard", targetInput, mapping }
+}
+
+function createKeyboardHandler(id, api) {
+  return (event) => {
+    event.stopPropagation()
+    api.notify(id, event.code)
+  }
+}