@inglorious/engine 0.2.0 → 0.4.0

package/src/{engine/behaviors → behaviors}/fsm.test.js

@@ -1,49 +1,49 @@
-import { createStore } from "@inglorious/engine/core/store.js"
-import { expect, test } from "vitest"
-
-import { fsm } from "./fsm.js"
-
-test("it should add a finite state machine", () => {
-  const config = {
-    types: {
-      kitty: [
-        fsm({
-          default: {
-            catMeow(entity) {
-              entity.state = "meowing"
-            },
-          },
-          meowing: {
-            update(entity) {
-              entity.treats++
-            },
-          },
-        }),
-      ],
-    },
-    entities: {
-      entity1: {
-        type: "kitty",
-        treats: 0,
-      },
-    },
-  }
-  const afterState = {
-    entities: {
-      entity1: {
-        id: "entity1",
-        type: "kitty",
-        state: "meowing",
-        treats: 1,
-      },
-    },
-  }
-
-  const store = createStore(config)
-  store.notify("start")
-  store.notify("catMeow")
-  store.update()
-
-  const state = store.getState()
-  expect(state).toStrictEqual(afterState)
-})
+import { createStore } from "@inglorious/store/store.js"
+import { expect, test } from "vitest"
+
+import { fsm } from "./fsm.js"
+
+test("it should add a finite state machine", () => {
+  const config = {
+    types: {
+      kitty: [
+        fsm({
+          default: {
+            catMeow(entity) {
+              entity.state = "meowing"
+            },
+          },
+          meowing: {
+            update(entity) {
+              entity.treats++
+            },
+          },
+        }),
+      ],
+    },
+    entities: {
+      entity1: {
+        type: "kitty",
+        treats: 0,
+      },
+    },
+  }
+  const afterState = {
+    entities: {
+      entity1: {
+        id: "entity1",
+        type: "kitty",
+        state: "meowing",
+        treats: 1,
+      },
+    },
+  }
+
+  const store = createStore(config)
+  store.notify("start")
+  store.notify("catMeow")
+  store.update()
+
+  const state = store.getState()
+  expect(state).toStrictEqual(afterState)
+})

package/src/{engine/behaviors → behaviors}/game.js

@@ -1,15 +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
-      }
-    },
-  }
-}
+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/{engine/behaviors → behaviors}/input/controls.js

@@ -1,37 +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),
-  }
-}
+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/{engine/behaviors → behaviors}/input/gamepad.js

@@ -1,114 +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 }
-}
+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/{engine/behaviors → behaviors}/input/input.js

@@ -1,48 +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 }
-}
+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/{engine/behaviors → behaviors}/input/keyboard.js

@@ -1,64 +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)
-  }
-}
+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)
+  }
+}