@inglorious/engine 0.2.0 → 0.3.0

package/src/{engine/behaviors → behaviors}/physics/clamped.js

@@ -1,36 +1,36 @@
-import { clampToBounds } from "@inglorious/engine/physics/bounds.js"
-import { extend, merge } from "@inglorious/utils/data-structures/objects.js"
-
-const DEFAULT_PARAMS = {
-  collisionGroup: "bounds",
-  depthAxis: "y",
-}
-
-export function clamped(params) {
-  params = extend(DEFAULT_PARAMS, params)
-
-  return (type) =>
-    extend(type, {
-      start(entity, api) {
-        type.start?.(entity, api)
-
-        entity.collisions ??= {}
-        entity.collisions[params.collisionGroup] ??= {}
-        entity.collisions[params.collisionGroup].shape ??= "rectangle"
-      },
-
-      update(entity, dt, api) {
-        type.update?.(entity, dt, api)
-
-        const game = api.getEntity("game")
-        merge(entity, {
-          position: clampToBounds(
-            entity,
-            game.bounds,
-            params.collisionGroup,
-            params.depthAxis,
-          ),
-        })
-      },
-    })
-}
+import { clampToBounds } from "@inglorious/engine/physics/bounds.js"
+import { extend, merge } from "@inglorious/utils/data-structures/objects.js"
+
+const DEFAULT_PARAMS = {
+  collisionGroup: "bounds",
+  depthAxis: "y",
+}
+
+export function clamped(params) {
+  params = extend(DEFAULT_PARAMS, params)
+
+  return (type) =>
+    extend(type, {
+      start(entity, api) {
+        type.start?.(entity, api)
+
+        entity.collisions ??= {}
+        entity.collisions[params.collisionGroup] ??= {}
+        entity.collisions[params.collisionGroup].shape ??= "rectangle"
+      },
+
+      update(entity, dt, api) {
+        type.update?.(entity, dt, api)
+
+        const game = api.getEntity("game")
+        merge(entity, {
+          position: clampToBounds(
+            entity,
+            game.bounds,
+            params.collisionGroup,
+            params.depthAxis,
+          ),
+        })
+      },
+    })
+}

package/src/{engine/behaviors → behaviors}/physics/collidable.js

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

package/src/{engine/behaviors → behaviors}/physics/jumpable.js

@@ -1,145 +1,145 @@
-import { findCollision } from "@inglorious/engine/collision/detection.js"
-import { defaults, extend } from "@inglorious/utils/data-structures/objects.js"
-import {
-  angle,
-  magnitude,
-  zero,
-} from "@inglorious/utils/math/linear-algebra/vector.js"
-import { applyGravity } from "@inglorious/utils/physics/gravity.js"
-import { jump } from "@inglorious/utils/physics/jump.js"
-
-const DEFAULT_PARAMS = {
-  maxSpeed: 250,
-  maxJump: 100,
-  maxLeap: 100,
-  maxJumps: 1,
-}
-
-const DOUBLE = 2
-const HALF = 2
-const X = 0
-const Y = 1
-const NO_VELOCITY = 0
-const NO_PENETRAION = 0
-
-export function jumpable(params) {
-  params = extend(DEFAULT_PARAMS, params)
-
-  return (type) =>
-    extend(type, {
-      start(entity, api) {
-        type.start?.(entity, api)
-        defaults(entity, params)
-        entity.jumpsLeft ??= entity.maxJumps
-
-        entity.velocity ??= zero()
-        entity.vy ??= 0
-      },
-
-      jump(entity, { entityId }) {
-        if (entityId === entity.id && entity.jumpsLeft) {
-          entity.vy = jump(entity)
-          entity.groundObject = undefined
-          entity.jumpsLeft--
-        }
-      },
-
-      update(entity, dt, api) {
-        type.update?.(entity, dt, api)
-
-        const entities = api.getEntities()
-
-        entity.collisions ??= {}
-        entity.collisions.platform ??= {}
-        entity.collisions.platform.shape ??= "rectangle"
-
-        let width, height
-        if (entity.collisions.platform.shape === "circle") {
-          width = entity.collisions.platform.radius * DOUBLE
-          height = entity.collisions.platform.radius * DOUBLE
-        } else {
-          ;[width, height] = entity.size
-        }
-        const [prevX, prevY] = [...entity.position]
-
-        // 1. HORIZONTAL MOVEMENT & RESOLUTION
-        entity.position[X] += entity.velocity[X] * dt
-        const entityLeft = entity.position[X] - width / HALF
-        const entityRight = entity.position[X] + width / HALF
-
-        const collisionX = findCollision(entity, entities, "platform")
-        if (collisionX) {
-          const vx = entity.velocity[X]
-
-          // Check if moving right and crossing the platform's left edge
-          const prevRight = prevX + width / HALF
-          const platformLeft =
-            collisionX.position[X] - collisionX.size[X] / HALF
-          if (vx > NO_VELOCITY && prevRight <= platformLeft) {
-            const penetration = entityRight - platformLeft
-            if (penetration > NO_PENETRAION) entity.position[X] -= penetration
-            entity.velocity[X] = 0
-          }
-
-          // Check if moving left and crossing the platform's right edge
-          const prevLeft = prevX - width / HALF
-          const platformRight =
-            collisionX.position[X] + collisionX.size[X] / HALF
-          if (vx < NO_VELOCITY && prevLeft >= platformRight) {
-            const penetration = platformRight - entityLeft
-            if (penetration > NO_PENETRAION) entity.position[X] += penetration
-            entity.velocity[X] = 0
-          }
-        }
-
-        // 2. VERTICAL MOVEMENT & RESOLUTION
-        const wasOnGround = entity.groundObject
-        entity.groundObject = undefined
-
-        const { vy, position: nextGravityPosition } = applyGravity(entity, dt)
-        entity.vy = vy
-        entity.position[Y] = nextGravityPosition[Y]
-
-        const collisionY = findCollision(entity, entities, "platform")
-        if (collisionY) {
-          const prevBottom = prevY - height / HALF
-          const platformTop = collisionY.position[Y] + collisionY.size[Y] / HALF
-
-          // Landing on top of a platform (one-way platform logic)
-          if (entity.vy <= NO_VELOCITY && prevBottom >= platformTop) {
-            const entityBottom = entity.position[Y] - height / HALF
-            const penetration = platformTop - entityBottom
-            if (penetration > NO_PENETRAION) entity.position[Y] += penetration
-            entity.vy = 0
-            entity.groundObject = collisionY
-            entity.jumpsLeft = entity.maxJumps
-
-            // Only notify on the frame we actually land, not every frame we're on the ground.
-            if (!wasOnGround) {
-              api.notify("landed", {
-                entityId: entity.id,
-                targetId: collisionY.id,
-              })
-            }
-          }
-
-          // Hitting head on bottom of a platform
-          // else if (entity.vy > 0) {
-          //   const prevTop = prevY + height / HALF
-          //   const platformBottom =
-          //     collisionY.position[Y] - collisionY.size[Y] / HALF
-          //   if (prevTop <= platformBottom) {
-          //     const entityTop = entity.position[Y] + height / HALF
-          //     const penetration = entityTop - platformBottom
-          //     if (penetration > 0) entity.position[Y] -= penetration
-          //     entity.vy = 0
-          //   }
-          // }
-        }
-
-        entity.orientation = magnitude(entity.velocity)
-          ? angle(entity.velocity)
-          : entity.orientation
-      },
-    })
-}
+import { findCollision } from "@inglorious/engine/collision/detection.js"
+import { defaults, extend } from "@inglorious/utils/data-structures/objects.js"
+import {
+  angle,
+  magnitude,
+  zero,
+} from "@inglorious/utils/math/linear-algebra/vector.js"
+import { applyGravity } from "@inglorious/utils/physics/gravity.js"
+import { jump } from "@inglorious/utils/physics/jump.js"
+
+const DEFAULT_PARAMS = {
+  maxSpeed: 250,
+  maxJump: 100,
+  maxLeap: 100,
+  maxJumps: 1,
+}
+
+const DOUBLE = 2
+const HALF = 2
+const X = 0
+const Y = 1
+const NO_VELOCITY = 0
+const NO_PENETRAION = 0
+
+export function jumpable(params) {
+  params = extend(DEFAULT_PARAMS, params)
+
+  return (type) =>
+    extend(type, {
+      start(entity, api) {
+        type.start?.(entity, api)
+        defaults(entity, params)
+        entity.jumpsLeft ??= entity.maxJumps
+
+        entity.velocity ??= zero()
+        entity.vy ??= 0
+      },
+
+      jump(entity, { entityId }) {
+        if (entityId === entity.id && entity.jumpsLeft) {
+          entity.vy = jump(entity)
+          entity.groundObject = undefined
+          entity.jumpsLeft--
+        }
+      },
+
+      update(entity, dt, api) {
+        type.update?.(entity, dt, api)
+
+        const entities = api.getEntities()
+
+        entity.collisions ??= {}
+        entity.collisions.platform ??= {}
+        entity.collisions.platform.shape ??= "rectangle"
+
+        let width, height
+        if (entity.collisions.platform.shape === "circle") {
+          width = entity.collisions.platform.radius * DOUBLE
+          height = entity.collisions.platform.radius * DOUBLE
+        } else {
+          ;[width, height] = entity.size
+        }
+        const [prevX, prevY] = [...entity.position]
+
+        // 1. HORIZONTAL MOVEMENT & RESOLUTION
+        entity.position[X] += entity.velocity[X] * dt
+        const entityLeft = entity.position[X] - width / HALF
+        const entityRight = entity.position[X] + width / HALF
+
+        const collisionX = findCollision(entity, entities, "platform")
+        if (collisionX) {
+          const vx = entity.velocity[X]
+
+          // Check if moving right and crossing the platform's left edge
+          const prevRight = prevX + width / HALF
+          const platformLeft =
+            collisionX.position[X] - collisionX.size[X] / HALF
+          if (vx > NO_VELOCITY && prevRight <= platformLeft) {
+            const penetration = entityRight - platformLeft
+            if (penetration > NO_PENETRAION) entity.position[X] -= penetration
+            entity.velocity[X] = 0
+          }
+
+          // Check if moving left and crossing the platform's right edge
+          const prevLeft = prevX - width / HALF
+          const platformRight =
+            collisionX.position[X] + collisionX.size[X] / HALF
+          if (vx < NO_VELOCITY && prevLeft >= platformRight) {
+            const penetration = platformRight - entityLeft
+            if (penetration > NO_PENETRAION) entity.position[X] += penetration
+            entity.velocity[X] = 0
+          }
+        }
+
+        // 2. VERTICAL MOVEMENT & RESOLUTION
+        const wasOnGround = entity.groundObject
+        entity.groundObject = undefined
+
+        const { vy, position: nextGravityPosition } = applyGravity(entity, dt)
+        entity.vy = vy
+        entity.position[Y] = nextGravityPosition[Y]
+
+        const collisionY = findCollision(entity, entities, "platform")
+        if (collisionY) {
+          const prevBottom = prevY - height / HALF
+          const platformTop = collisionY.position[Y] + collisionY.size[Y] / HALF
+
+          // Landing on top of a platform (one-way platform logic)
+          if (entity.vy <= NO_VELOCITY && prevBottom >= platformTop) {
+            const entityBottom = entity.position[Y] - height / HALF
+            const penetration = platformTop - entityBottom
+            if (penetration > NO_PENETRAION) entity.position[Y] += penetration
+            entity.vy = 0
+            entity.groundObject = collisionY
+            entity.jumpsLeft = entity.maxJumps
+
+            // Only notify on the frame we actually land, not every frame we're on the ground.
+            if (!wasOnGround) {
+              api.notify("landed", {
+                entityId: entity.id,
+                targetId: collisionY.id,
+              })
+            }
+          }
+
+          // Hitting head on bottom of a platform
+          // else if (entity.vy > 0) {
+          //   const prevTop = prevY + height / HALF
+          //   const platformBottom =
+          //     collisionY.position[Y] - collisionY.size[Y] / HALF
+          //   if (prevTop <= platformBottom) {
+          //     const entityTop = entity.position[Y] + height / HALF
+          //     const penetration = entityTop - platformBottom
+          //     if (penetration > 0) entity.position[Y] -= penetration
+          //     entity.vy = 0
+          //   }
+          // }
+        }
+
+        entity.orientation = magnitude(entity.velocity)
+          ? angle(entity.velocity)
+          : entity.orientation
+      },
+    })
+}

package/src/{engine/behaviors → behaviors}/ui/button.js

@@ -1,17 +1,17 @@
-export function button() {
-  return {
-    states: {
-      default: {
-        entityClick(entity) {
-          entity.state = "pressed"
-        },
-      },
-
-      pressed: {
-        entityRelease(entity) {
-          entity.state = "default"
-        },
-      },
-    },
-  }
-}
+export function button() {
+  return {
+    states: {
+      default: {
+        entityClick(entity) {
+          entity.state = "pressed"
+        },
+      },
+
+      pressed: {
+        entityRelease(entity) {
+          entity.state = "default"
+        },
+      },
+    },
+  }
+}

package/src/{engine/collision → collision}/detection.js

@@ -1,110 +1,110 @@
-import { filter } from "@inglorious/utils/data-structures/object.js"
-import * as circle from "@inglorious/utils/math/geometry/circle.js"
-import * as hitmask from "@inglorious/utils/math/geometry/hitmask.js"
-import * as line from "@inglorious/utils/math/geometry/line.js"
-import * as point from "@inglorious/utils/math/geometry/point.js"
-import * as rectangle from "@inglorious/utils/math/geometry/rectangle.js"
-import * as segment from "@inglorious/utils/math/geometry/segment.js"
-import { zero } from "@inglorious/utils/math/linear-algebra/vector.js"
-import { add } from "@inglorious/utils/math/linear-algebra/vectors.js"
-
-const Z = 2 // Z-axis index.
-
-const Shape = {
-  circle,
-  line,
-  point,
-  rectangle,
-  segment,
-  hitmask,
-}
-
-/**
- * Finds the first collision between a point and a list of entities.
- *
- * @param {Point} entity - The point to check for collisions.
- * @param {Options} options - Options for collision detection.
- * @returns {Entity | undefined} The first entity that collides with the point, or undefined if none are found.
- */
-export function findCollision(entity, entities, collisionGroup = "hitbox") {
-  const otherEntities = filter(
-    entities,
-    (id, { collisions }) => id !== entity.id && collisions?.[collisionGroup],
-  )
-
-  return Object.values(otherEntities)
-    .toSorted((a, b) => a.position[Z] - b.position[Z])
-    .find((target) => collidesWith(entity, target, collisionGroup))
-}
-
-export function collidesWith(entity, target, collisionGroup = "hitbox") {
-  const entityShape = getCollisionShape(entity, collisionGroup)
-  const targetShape = getCollisionShape(target, collisionGroup)
-
-  if (!entityShape || !targetShape) {
-    return false
-  }
-
-  return shapeCollidesWith(entityShape, targetShape)
-}
-
-function shapeCollidesWith(entity, target) {
-  const shapeFns = Shape[entity.shape]
-
-  switch (target.shape) {
-    case "circle":
-      return shapeFns.intersectsCircle(entity, target)
-
-    case "line":
-      return shapeFns.intersectsLine(entity, target)
-
-    case "point":
-      return shapeFns.intersectsPoint(entity, target)
-
-    case "rectangle":
-      return shapeFns.intersectsRectangle(entity, target)
-
-    case "segment":
-      return shapeFns.intersectsSegment(entity, target)
-  }
-}
-
-export function findCollisions(entity, target, collisionGroup = "hitbox") {
-  const entityShape = getCollisionShape(entity, collisionGroup)
-  const targetShape = getCollisionShape(target, collisionGroup)
-
-  if (!entityShape || !targetShape) {
-    return false
-  }
-
-  const shapeFns = Shape[entityShape.shape]
-  if (!shapeFns || !shapeFns.findCollisions) {
-    return false
-  }
-
-  return shapeFns.findCollisions(entityShape, targetShape)
-}
-
-/**
- * Correctly calculates the absolute position and size of an entity's
- * collision shape, including any offsets.
- */
-function getCollisionShape(entity, collisionGroup = "hitbox") {
-  const collision = entity.collisions[collisionGroup]
-  if (!collision) {
-    return null
-  }
-
-  const position = add(
-    entity.position,
-    collision.offset ?? zero(),
-    entity.offset ?? zero(),
-  )
-
-  return {
-    ...collision,
-    position,
-    size: collision.size ?? entity.size,
-    radius: collision.radius ?? entity.radius,
-  }
-}
+import { filter } from "@inglorious/utils/data-structures/object.js"
+import * as circle from "@inglorious/utils/math/geometry/circle.js"
+import * as hitmask from "@inglorious/utils/math/geometry/hitmask.js"
+import * as line from "@inglorious/utils/math/geometry/line.js"
+import * as point from "@inglorious/utils/math/geometry/point.js"
+import * as rectangle from "@inglorious/utils/math/geometry/rectangle.js"
+import * as segment from "@inglorious/utils/math/geometry/segment.js"
+import { zero } from "@inglorious/utils/math/linear-algebra/vector.js"
+import { add } from "@inglorious/utils/math/linear-algebra/vectors.js"
+
+const Z = 2 // Z-axis index.
+
+const Shape = {
+  circle,
+  line,
+  point,
+  rectangle,
+  segment,
+  hitmask,
+}
+
+/**
+ * Finds the first collision between a point and a list of entities.
+ *
+ * @param {Point} entity - The point to check for collisions.
+ * @param {Options} options - Options for collision detection.
+ * @returns {Entity | undefined} The first entity that collides with the point, or undefined if none are found.
+ */
+export function findCollision(entity, entities, collisionGroup = "hitbox") {
+  const otherEntities = filter(
+    entities,
+    (id, { collisions }) => id !== entity.id && collisions?.[collisionGroup],
+  )
+
+  return Object.values(otherEntities)
+    .toSorted((a, b) => a.position[Z] - b.position[Z])
+    .find((target) => collidesWith(entity, target, collisionGroup))
+}
+
+export function collidesWith(entity, target, collisionGroup = "hitbox") {
+  const entityShape = getCollisionShape(entity, collisionGroup)
+  const targetShape = getCollisionShape(target, collisionGroup)
+
+  if (!entityShape || !targetShape) {
+    return false
+  }
+
+  return shapeCollidesWith(entityShape, targetShape)
+}
+
+function shapeCollidesWith(entity, target) {
+  const shapeFns = Shape[entity.shape]
+
+  switch (target.shape) {
+    case "circle":
+      return shapeFns.intersectsCircle(entity, target)
+
+    case "line":
+      return shapeFns.intersectsLine(entity, target)
+
+    case "point":
+      return shapeFns.intersectsPoint(entity, target)
+
+    case "rectangle":
+      return shapeFns.intersectsRectangle(entity, target)
+
+    case "segment":
+      return shapeFns.intersectsSegment(entity, target)
+  }
+}
+
+export function findCollisions(entity, target, collisionGroup = "hitbox") {
+  const entityShape = getCollisionShape(entity, collisionGroup)
+  const targetShape = getCollisionShape(target, collisionGroup)
+
+  if (!entityShape || !targetShape) {
+    return false
+  }
+
+  const shapeFns = Shape[entityShape.shape]
+  if (!shapeFns || !shapeFns.findCollisions) {
+    return false
+  }
+
+  return shapeFns.findCollisions(entityShape, targetShape)
+}
+
+/**
+ * Correctly calculates the absolute position and size of an entity's
+ * collision shape, including any offsets.
+ */
+function getCollisionShape(entity, collisionGroup = "hitbox") {
+  const collision = entity.collisions[collisionGroup]
+  if (!collision) {
+    return null
+  }
+
+  const position = add(
+    entity.position,
+    collision.offset ?? zero(),
+    entity.offset ?? zero(),
+  )
+
+  return {
+    ...collision,
+    position,
+    size: collision.size ?? entity.size,
+    radius: collision.radius ?? entity.radius,
+  }
+}