@inglorious/engine 0.1.0

package/src/game/animation.js

@@ -0,0 +1,26 @@
+const COUNTER_RESET = 0
+const DEFAULT_VALUE = 0
+
+export const Animation = { play }
+
+function play(what, state, instance, options) {
+  const { dt, onTick } = options
+  const {
+    speed,
+    defaultValue = DEFAULT_VALUE,
+    value = DEFAULT_VALUE,
+  } = instance[what]
+
+  if (state !== instance[what].state) {
+    instance[what].state = state
+    instance[what].counter = COUNTER_RESET
+    instance[what].value = defaultValue
+  }
+
+  instance[what].counter += dt
+  if (instance[what].counter >= speed) {
+    instance[what].counter = COUNTER_RESET
+    instance[what].value = value
+    onTick && onTick(instance, options)
+  }
+}

package/src/game/bounds.js

@@ -0,0 +1,66 @@
+import {
+  angle,
+  clamp,
+  createVector,
+  fromAngle,
+  multiply,
+  zero,
+} from "@inglorious/utils/math/linear-algebra/vector.js"
+import { sum } from "@inglorious/utils/math/linear-algebra/vectors.js"
+import { abs } from "@inglorious/utils/math/numbers.js"
+
+const X = 0
+const Z = 2
+
+export function bounce(instance, { dt, instances }) {
+  const [minX, minZ, maxX, maxZ] = instances.game.bounds
+  const [x, , z] = instance.position
+
+  const velocity = createVector(instance.maxSpeed, instance.orientation)
+  if (x < minX || x >= maxX) {
+    velocity[X] = -velocity[X]
+  }
+
+  if (z < minZ || z >= maxZ) {
+    velocity[Z] = -velocity[Z]
+  }
+
+  const position = sum(instance.position, multiply(velocity, dt))
+  const orientation = angle(velocity)
+
+  return { velocity, position, orientation }
+}
+
+// TODO: make the following functions pure
+export function clampToBounds(instance, [minX, minZ, maxX, maxZ]) {
+  instance.position = clamp(
+    instance.position,
+    [minX, minZ, minZ],
+    [maxX, maxZ, maxZ],
+  )
+}
+
+export function flip(instance, [minX, minZ, maxX, maxZ]) {
+  const [x, , z] = instance.position
+
+  const direction = fromAngle(instance.orientation)
+
+  if (x < minX || x >= maxX || z < minZ || z >= maxZ) {
+    if (x < minX) {
+      direction[X] = abs(direction[X])
+    } else if (x >= maxX) {
+      direction[X] = -abs(direction[X])
+    }
+
+    if (z < minZ) {
+      direction[Z] = abs(direction[Z])
+    } else if (z >= maxZ) {
+      direction[Z] = -abs(direction[Z])
+    }
+
+    instance.acceleration = zero()
+    instance.velocity = zero()
+  }
+
+  instance.orientation = angle(direction)
+}

package/src/game/decorators/character.js

@@ -0,0 +1,5 @@
+import draw from "@inglorious/ui/canvas/character.js"
+
+export function enableCharacter() {
+  return { draw }
+}

package/src/game/decorators/clamp-to-bounds.js

@@ -0,0 +1,15 @@
+import { extend } from "@inglorious/utils/data-structures/objects.js"
+
+import { clampToBounds } from "../bounds.js"
+
+export function enableClampToBounds() {
+  return (type) =>
+    extend(type, {
+      "game:update"(instance, event, options) {
+        type["game:update"]?.(instance, event, options)
+
+        const { instances } = options
+        clampToBounds(instance, instances.game.bounds)
+      },
+    })
+}

package/src/game/decorators/collisions.js

@@ -0,0 +1,24 @@
+import { extend } from "@inglorious/utils/data-structures/objects.js"
+
+const DEFAULT_PARAMS = {
+  onState: "default",
+}
+
+export function enableCollisions(params) {
+  params = extend(DEFAULT_PARAMS, params)
+
+  return (type) =>
+    extend(type, {
+      states: {
+        [params.onState]: {
+          "game:update"(instance, event, options) {
+            type.states?.[params.onState]["game:update"]?.(
+              instance,
+              event,
+              options,
+            )
+          },
+        },
+      },
+    })
+}

package/src/game/decorators/controls/dynamic/modern.js

@@ -0,0 +1,48 @@
+import modernMove from "@inglorious/engine/movement/dynamic/modern.js"
+import { extend, merge } from "@inglorious/utils/data-structures/objects.js"
+import { zero } from "@inglorious/utils/math/linear-algebra/vector.js"
+
+const DEFAULT_PARAMS = {
+  maxAcceleration: 500,
+}
+const X = 0
+const Z = 2
+
+export function enableModernControls(params) {
+  params = extend(DEFAULT_PARAMS, params)
+
+  return (type) =>
+    extend(type, {
+      "game:update"(instance, event, options) {
+        type["game:update"]?.(instance, event, options)
+
+        const maxAcceleration =
+          instance.maxAcceleration ?? params.maxAcceleration
+
+        const { input0 } = options.instances
+        instance.acceleration = zero()
+
+        if (input0.left) {
+          instance.acceleration[X] = -maxAcceleration
+        }
+        if (input0.right) {
+          instance.acceleration[X] = maxAcceleration
+        }
+        if (input0.down) {
+          instance.acceleration[Z] = -maxAcceleration
+        }
+        if (input0.up) {
+          instance.acceleration[Z] = maxAcceleration
+        }
+
+        if (input0.leftRight != null) {
+          instance.acceleration[X] += input0.leftRight * maxAcceleration
+        }
+        if (input0.upDown != null) {
+          instance.acceleration[Z] += -input0.upDown * maxAcceleration
+        }
+
+        merge(instance, modernMove(instance, options))
+      },
+    })
+}

package/src/game/decorators/controls/dynamic/shooter.js

@@ -0,0 +1,47 @@
+import face from "@inglorious/engine/ai/movement/dynamic/face.js"
+import tankMove from "@inglorious/engine/movement/dynamic/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"
+
+const FULL_CIRCLE = 2
+const DEFAULT_PARAMS = {
+  maxAngularSpeed: FULL_CIRCLE * pi(),
+  maxSpeed: 250,
+}
+const X = 0
+const Z = 2
+
+export function enableShooterControls(params) {
+  params = extend(DEFAULT_PARAMS, params)
+
+  return (type) =>
+    extend(type, {
+      "game:update"(instance, event, options) {
+        instance.maxAngularSpeed =
+          instance.maxAngularSpeed ?? params.maxAngularSpeed
+        instance.maxAcceleration =
+          instance.maxAcceleration ?? params.maxAcceleration
+        instance.maxSpeed = instance.maxSpeed ?? params.maxSpeed
+
+        const { input0, mouse } = options.instances
+        instance.acceleration = zero()
+
+        if (input0.left) {
+          instance.acceleration[Z] = -instance.maxAcceleration
+        }
+        if (input0.down) {
+          instance.acceleration[X] = -instance.maxAcceleration
+        }
+        if (input0.right) {
+          instance.acceleration[Z] = instance.maxAcceleration
+        }
+        if (input0.up) {
+          instance.acceleration[X] = instance.maxAcceleration
+        }
+
+        merge(instance, face(instance, mouse, options))
+        merge(instance, tankMove(instance, options))
+      },
+    })
+}

package/src/game/decorators/controls/dynamic/tank.js

@@ -0,0 +1,55 @@
+import tankMove from "@inglorious/engine/movement/dynamic/tank.js"
+import { extend, merge } from "@inglorious/utils/data-structures/objects.js"
+import { zero } from "@inglorious/utils/math/linear-algebra/vector.js"
+
+const DEFAULT_PARAMS = {
+  maxAngularSpeed: 10,
+  maxAcceleration: 500,
+  maxSpeed: 250,
+}
+const X = 0
+const Z = 2
+
+export function enableTankControls(params) {
+  params = extend(DEFAULT_PARAMS, params)
+
+  return (type) =>
+    extend(type, {
+      "game:update"(instance, event, options) {
+        instance.maxAngularSpeed =
+          instance.maxAngularSpeed ?? params.maxAngularSpeed
+        instance.maxAcceleration =
+          instance.maxAcceleration ?? params.maxAcceleration
+        instance.maxSpeed = instance.maxSpeed ?? params.maxSpeed
+
+        instance.acceleration = zero()
+
+        const { input0 } = options.instances
+        if (input0.left) {
+          instance.orientation += 0.1
+        }
+        if (input0.down) {
+          instance.acceleration[X] = -instance.maxAcceleration
+        }
+        if (input0.right) {
+          instance.orientation -= 0.1
+        }
+        if (input0.up) {
+          instance.acceleration[X] = instance.maxAcceleration
+        }
+
+        if (input0.leftRight != null) {
+          instance.orientation +=
+            -input0.leftRight * instance.maxAngularSpeed * options.dt
+        }
+        if (input0.upDown != null) {
+          instance.acceleration[X] += -input0.upDown * instance.maxAcceleration
+        }
+        if (input0.strafe != null) {
+          instance.acceleration[Z] += input0.strafe * instance.maxAcceleration
+        }
+
+        merge(instance, tankMove(instance, options))
+      },
+    })
+}

package/src/game/decorators/controls/kinematic/modern.js

@@ -0,0 +1,49 @@
+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"
+
+const DEFAULT_PARAMS = {
+  onState: "default",
+  movementStrategy: "kinematic",
+  maxSpeed: 250,
+}
+const X = 0
+const Z = 2
+
+export function enableModernControls(params) {
+  params = extend(DEFAULT_PARAMS, params)
+
+  return (type) =>
+    extend(type, {
+      "game:update"(instance, event, options) {
+        type["game:update"]?.(instance, event, options)
+
+        const maxSpeed = instance.maxSpeed ?? params.maxSpeed
+
+        const { input0 } = options.instances
+        instance.velocity = zero()
+
+        if (input0.left) {
+          instance.velocity[X] = -maxSpeed
+        }
+        if (input0.down) {
+          instance.velocity[Z] = -maxSpeed
+        }
+        if (input0.right) {
+          instance.velocity[X] = maxSpeed
+        }
+        if (input0.up) {
+          instance.velocity[Z] = maxSpeed
+        }
+
+        if (input0.leftRight != null) {
+          instance.velocity[X] += input0.leftRight * maxSpeed
+        }
+        if (input0.upDown != null) {
+          instance.velocity[Z] += -input0.upDown * maxSpeed
+        }
+
+        merge(instance, modernMove(instance, options))
+      },
+    })
+}

package/src/game/decorators/controls/kinematic/shooter.js

@@ -0,0 +1,45 @@
+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"
+
+const FULL_CIRCLE = 2
+const DEFAULT_PARAMS = {
+  maxAngularSpeed: FULL_CIRCLE * pi(),
+  maxSpeed: 250,
+}
+const X = 0
+const Z = 2
+
+export function enableShooterControls(params) {
+  params = extend(DEFAULT_PARAMS, params)
+
+  return (type) =>
+    extend(type, {
+      "game:update"(instance, event, options) {
+        instance.maxAngularSpeed =
+          instance.maxAngularSpeed ?? params.maxAngularSpeed
+        instance.maxSpeed = instance.maxSpeed ?? params.maxSpeed
+
+        const { input0, mouse } = options.instances
+        instance.velocity = zero()
+
+        if (input0.left) {
+          instance.velocity[Z] = -instance.maxSpeed
+        }
+        if (input0.down) {
+          instance.velocity[X] = -instance.maxSpeed
+        }
+        if (input0.right) {
+          instance.velocity[Z] = instance.maxSpeed
+        }
+        if (input0.up) {
+          instance.velocity[X] = instance.maxSpeed
+        }
+
+        merge(instance, face(instance, mouse, options))
+        merge(instance, tankMove(instance, options))
+      },
+    })
+}

package/src/game/decorators/controls/kinematic/tank.js

@@ -0,0 +1,52 @@
+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"
+
+const DEFAULT_PARAMS = {
+  maxAngularSpeed: 10,
+  maxSpeed: 250,
+}
+const X = 0
+const Z = 2
+
+export function enableTankControls(params) {
+  params = extend(DEFAULT_PARAMS, params)
+
+  return (type) =>
+    extend(type, {
+      "game:update"(instance, event, options) {
+        instance.maxAngularSpeed =
+          instance.maxAngularSpeed ?? params.maxAngularSpeed
+        instance.maxSpeed = instance.maxSpeed ?? params.maxSpeed
+
+        const { input0 } = options.instances
+        instance.velocity = zero()
+
+        if (input0.left) {
+          instance.orientation += 0.1
+        }
+        if (input0.down) {
+          instance.velocity[X] = -instance.maxSpeed
+        }
+        if (input0.right) {
+          instance.orientation -= 0.1
+        }
+        if (input0.up) {
+          instance.velocity[X] = instance.maxSpeed
+        }
+
+        if (input0.leftRight != null) {
+          instance.orientation +=
+            -input0.leftRight * instance.maxAngularSpeed * options.dt
+        }
+        if (input0.upDown != null) {
+          instance.velocity[X] += -input0.upDown * instance.maxSpeed
+        }
+        if (input0.strafe != null) {
+          instance.velocity[Z] += input0.strafe * instance.maxSpeed
+        }
+
+        merge(instance, tankMove(instance, options))
+      },
+    })
+}

package/src/game/decorators/debug/collisions.js

@@ -0,0 +1,32 @@
+import drawHitmask from "@inglorious/ui/canvas/image/hitmask.js"
+import drawCircle from "@inglorious/ui/canvas/shapes/circle.js"
+import drawRectangle from "@inglorious/ui/canvas/shapes/rectangle.js"
+import { extend } from "@inglorious/utils/data-structures/objects.js"
+
+const Shape = {
+  circle: drawCircle,
+  rectangle: drawRectangle,
+  hitmask: drawHitmask,
+}
+
+export function enableCollisionsDebug() {
+  return (type) =>
+    extend(type, {
+      draw(ctx, instance, options) {
+        type.draw(ctx, instance, options)
+
+        if (!options.instances.game.debug) {
+          return
+        }
+
+        ctx.save()
+
+        Object.values(instance.collisions).forEach((collision) => {
+          const draw = Shape[collision.shape]
+          draw(ctx, { ...collision, color: "#00FF00" }, options)
+        })
+
+        ctx.restore()
+      },
+    })
+}

package/src/game/decorators/double-jump.js

@@ -0,0 +1,70 @@
+import { collidesWith } from "@inglorious/engine/collision/detection.js"
+import { extend, merge } from "@inglorious/utils/data-structures/objects.js"
+import { applyGravity } from "@inglorious/utils/physics/gravity.js"
+import { jump } from "@inglorious/utils/physics/jump.js"
+
+import { enableFsm } from "./fsm.js"
+
+const DEFAULT_PARAMS = {
+  onState: "default",
+  onInput: "input0",
+  maxSpeed: 250,
+  maxJump: 100,
+  maxLeap: 100,
+}
+const FALLING = 0
+
+export function enableDoubleJump(params) {
+  params = extend(DEFAULT_PARAMS, params)
+
+  const freeFall = createFreeFall(params)
+
+  return enableFsm({
+    jumping: {
+      "input:press"(instance, event, options) {
+        instance.onInput = instance.onInput ?? params.onInput
+        instance.maxJump = instance.maxJump ?? params.maxJump
+        instance.maxLeap = instance.maxLeap ?? params.maxLeap
+        instance.maxSpeed = instance.maxSpeed ?? params.maxSpeed
+
+        const { id, action } = event.payload
+        if (id.endsWith(instance.onInput) && action === "jump") {
+          instance.state = "doubleJumping"
+          merge(instance, jump(instance, options))
+        }
+      },
+    },
+
+    doubleJumping: {
+      "game:update"(instance, event, options) {
+        freeFall(instance, event, options)
+      },
+    },
+  })
+}
+
+// TODO: this is a copy-paste of jump.js. Can we reduce duplication?
+function createFreeFall(params) {
+  return (instance, event, options) => {
+    instance.maxLeap = instance.maxLeap ?? params.maxLeap
+
+    merge(instance, applyGravity(instance, options))
+
+    const { instances } = options
+    const targets = Object.values(instances).filter(
+      ({ type }) => type === "platform",
+    )
+
+    targets.forEach((target) => {
+      if (instance.vy < FALLING && collidesWith(instance, target, "platform")) {
+        instance.vy = 0
+        const [x, , z] = instance.position
+        const { radius } = instance.collisions.platform
+        const [, targetY] = target.position
+        const py = targetY + radius
+        instance.position = [x, py, z]
+        instance.state = params.onState
+      }
+    })
+  }
+}

package/src/game/decorators/fps.js

@@ -0,0 +1,30 @@
+import { Animation } from "@inglorious/game/animation.js"
+import draw from "@inglorious/ui/canvas/fps.js"
+import { extend } from "@inglorious/utils/data-structures/objects.js"
+
+const DEFAULT_PARAMS = {
+  accuracy: 1,
+  size: 16,
+  speed: 1,
+  defaultValue: 0.016666666666666666,
+}
+
+export function enableFps(params) {
+  params = extend(DEFAULT_PARAMS, params)
+
+  return {
+    draw,
+
+    "game:start"(instance) {
+      instance.dt = instance.dt ?? params
+    },
+
+    "game:update"(instance, event, options) {
+      Animation.play("dt", "default", instance, { ...options, onTick })
+    },
+  }
+}
+
+function onTick(instance, options) {
+  instance.dt.value = options.dt
+}

package/src/game/decorators/fsm.js

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

package/src/game/decorators/fsm.test.js

@@ -0,0 +1,56 @@
+import { createStore } from "@inglorious/engine/store"
+import { expect, test } from "vitest"
+
+import { enableFsm } from "./fsm"
+
+test("it should add a finite state machine", () => {
+  const config = {
+    types: {
+      kitty: [
+        enableFsm({
+          default: {
+            "cat:meow"(instance) {
+              instance.state = "meowing"
+            },
+          },
+          meowing: {
+            "game:update"(instance) {
+              instance.treats++
+            },
+          },
+        }),
+      ],
+    },
+    instances: {
+      instance1: {
+        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",
+        type: "kitty",
+        layer: 0,
+        state: "meowing",
+        treats: 1,
+      },
+    },
+  }
+
+  store.notify({ id: "cat:meow" })
+  store.update()
+
+  const state = store.getState()
+  expect(state).toStrictEqual(afterState)
+})

package/src/game/decorators/game.js

@@ -0,0 +1,11 @@
+export function enableGame() {
+  return {
+    "keyboard:keyUp"(instance, event) {
+      const code = event.payload
+
+      if (code === "KeyC") {
+        instance.debug = !instance.debug
+      }
+    },
+  }
+}

package/src/game/decorators/image/image.js

@@ -0,0 +1,5 @@
+import draw from "@inglorious/ui/canvas/image/image.js"
+
+export function enableImage() {
+  return { draw }
+}

package/src/game/decorators/image/sprite.js

@@ -0,0 +1,5 @@
+import draw from "@inglorious/ui/canvas/image/sprite.js"
+
+export function enableSprite() {
+  return { draw }
+}