@inglorious/engine 0.1.0 → 0.2.0

package/src/{ui → renderers}/react/game/stats/index.jsx

@@ -1,22 +1,22 @@
-import { toString } from "@inglorious/utils/math/linear-algebra/vector.js"
-
-const DECIMALS = 1
-
-export default function Stats({ instance, instances, className, style }) {
-  const { acceleration, velocity, position, orientation, ay, vy } =
-    instances[instance.target]
-
-  return (
-    <div className={className} style={style}>
-      {acceleration && <div>Acceleration: {toString(acceleration)}</div>}
-      {velocity && <div>Velocity: {toString(velocity)}</div>}
-      {position && <div>Position: {toString(position)}</div>}
-      {orientation != null && (
-        <div>Orientation: {orientation.toFixed(DECIMALS)}</div>
-      )}
-
-      {ay != null && <div>ay: {ay.toFixed(DECIMALS)}</div>}
-      {vy != null && <div>vy: {vy.toFixed(DECIMALS)}</div>}
-    </div>
-  )
-}
+import { toString } from "@inglorious/utils/math/linear-algebra/vector.js"
+
+const DECIMALS = 1
+
+export default function Stats({ entity, entities, className, style }) {
+  const { acceleration, velocity, position, orientation, ay, vy } =
+    entities[entity.target]
+
+  return (
+    <div className={className} style={style}>
+      {acceleration && <div>Acceleration: {toString(acceleration)}</div>}
+      {velocity && <div>Velocity: {toString(velocity)}</div>}
+      {position && <div>Position: {toString(position)}</div>}
+      {orientation != null && (
+        <div>Orientation: {orientation.toFixed(DECIMALS)}</div>
+      )}
+
+      {ay != null && <div>ay: {ay.toFixed(DECIMALS)}</div>}
+      {vy != null && <div>vy: {vy.toFixed(DECIMALS)}</div>}
+    </div>
+  )
+}

package/src/{ui → renderers}/react/hocs/with-absolute-position/index.jsx

@@ -1,20 +1,20 @@
-import { zero } from "@inglorious/utils/math/linear-algebra/vector.js"
-
-import classes from "./with-absolute-position.module.scss"
-
-export function withAbsolutePosition(Component) {
-  return function AbsolutePosition(props) {
-    const [, , , screenHeight] = props.instances.game.bounds
-    const { position = zero() } = props.instance
-
-    const [x, y, z] = position
-
-    return (
-      <Component
-        {...props}
-        className={classes.withAbsolutePosition}
-        style={{ "--x": `${x}px`, "--y": `${screenHeight - y - z}px` }}
-      />
-    )
-  }
-}
+import { zero } from "@inglorious/utils/math/linear-algebra/vector.js"
+
+import classes from "./with-absolute-position.module.scss"
+
+export function withAbsolutePosition(Component) {
+  return function AbsolutePosition(props) {
+    const [, , , screenHeight] = props.entities.game.bounds
+    const { position = zero() } = props.entity
+
+    const [x, y, z] = position
+
+    return (
+      <Component
+        {...props}
+        className={classes.withAbsolutePosition}
+        style={{ "--x": `${x}px`, "--y": `${screenHeight - y - z}px` }}
+      />
+    )
+  }
+}

package/src/{ui → renderers}/react/index.jsx

@@ -1,9 +1,9 @@
-import ReactDOM from "react-dom/client"
-
-import Game from "./game/index.jsx"
-
-export function start(game) {
-  ReactDOM.createRoot(document.getElementById("root")).render(
-    <Game config={game} />,
-  )
-}
+import ReactDOM from "react-dom/client"
+
+import Game from "./game/index.jsx"
+
+export function start(game) {
+  ReactDOM.createRoot(document.getElementById("root")).render(
+    <Game config={game} />,
+  )
+}

package/src/utils/algorithms/decision-tree.js

@@ -1,24 +1,24 @@
-/**
- * @typedef {import("./types").Conditions} Conditions
- * @typedef {import("./types").Outcome} Outcome
- * @typedef {import("./types").DecisionTree} DecisionTree
- */
-
-/**
- * Traverses a decision tree recursively based on the provided conditions and returns the resulting node.
- *
- * @param {DecisionTree} tree - The decision tree to traverse. Each node contains:
- *   - `test` {Function}: A function that evaluates the conditions and determines the next branch.
- *   - Branches keyed by the possible outcomes of the `test` function.
- * @param {Conditions} conditions - The conditions object passed to the `test` function at each node.
- * @returns {Outcome | DecisionTree} - The resulting outcome or decision tree itself after traversing the decision tree.
- */
-export function decide(tree, conditions) {
-  if (!tree.test) {
-    return tree
-  }
-
-  const value = tree.test(conditions)
-
-  return tree[value] && decide(tree[value](conditions), conditions)
-}
+/**
+ * @typedef {import("./types").Conditions} Conditions
+ * @typedef {import("./types").Outcome} Outcome
+ * @typedef {import("./types").DecisionTree} DecisionTree
+ */
+
+/**
+ * Traverses a decision tree recursively based on the provided conditions and returns the resulting node.
+ *
+ * @param {DecisionTree} tree - The decision tree to traverse. Each node contains:
+ *   - `test` {Function}: A function that evaluates the conditions and determines the next branch.
+ *   - Branches keyed by the possible outcomes of the `test` function.
+ * @param {Conditions} conditions - The conditions object passed to the `test` function at each node.
+ * @returns {Outcome | DecisionTree} - The resulting outcome or decision tree itself after traversing the decision tree.
+ */
+export function decide(tree, conditions) {
+  if (!tree.test) {
+    return tree
+  }
+
+  const value = tree.test(conditions)
+
+  return tree[value] && decide(tree[value](conditions), conditions)
+}

package/src/utils/algorithms/decision-tree.test.js

@@ -1,102 +1,153 @@
-import { length } from "@inglorious/utils/math/linear-algebra/vector.js"
-import { subtract } from "@inglorious/utils/math/linear-algebra/vectors.js"
-import { expect, test } from "vitest"
-
-import { decide } from "./decision-tree.js"
-
-test("it should make a decision based on a binary decision tree", () => {
-  const instance = { state: "sleeping", position: [0, 0, 0] }
-  const target = { position: [10, 0, 0] }
-  const tree = {
-    test: ({ instance }) => instance.state === "idle",
-    true: () => ({
-      test: ({ instance, mouse }) => {
-        const distance = length(subtract(mouse.position, instance.position))
-        return distance < 250
-      },
-      true: () => "aware",
-    }),
-    false: () => ({
-      test: ({ instance }) => instance.state === "chasing",
-      true: () => ({
-        test: ({ instance, mouse }) => {
-          const distance = length(subtract(mouse.position, instance.position))
-          return distance >= 250
-        },
-        true: () => "idle",
-        false: () => ({
-          test: ({ instance, mouse }) => {
-            const distance = length(subtract(mouse.position, instance.position))
-            return distance < 10
-          },
-          true: () => "sleepy",
-        }),
-      }),
-      false: () => ({
-        test: ({ instance }) => ["sleepy", "sleeping"].includes(instance.state),
-        true: () => ({
-          test: ({ instance, mouse }) => {
-            const distance = length(subtract(mouse.position, instance.position))
-            return distance >= 10
-          },
-          true: () => "aware",
-        }),
-      }),
-    }),
-  }
-
-  const state = decide(tree, { instance, mouse: target })
-
-  expect(state).toBe("aware")
-})
-
-test("it should make a decision on a multi-child tree", () => {
-  const instance = { state: "sleeping", position: [0, 0, 0] }
-  const target = { position: [10, 0, 0] }
-  const tree = {
-    test: ({ instance }) => instance.state,
-    idle: () => ({
-      test: ({ instance, target }) => {
-        const distance = length(subtract(target.position, instance.position))
-        return distance < 250
-      },
-      true: () => "aware",
-      false: ({ instance }) => instance.state,
-    }),
-    chasing: () => ({
-      test: ({ instance, target }) => {
-        const distance = length(subtract(target.position, instance.position))
-        return distance >= 250
-      },
-      true: () => "idle",
-      false: () => ({
-        test: ({ instance, target }) => {
-          const distance = length(subtract(target.position, instance.position))
-          return distance < 10
-        },
-        true: () => "sleepy",
-        false: ({ instance }) => instance.state,
-      }),
-    }),
-    sleepy: () => ({
-      test: ({ instance, target }) => {
-        const distance = length(subtract(target.position, instance.position))
-        return distance >= 10
-      },
-      true: () => "aware",
-      false: ({ instance }) => instance.state,
-    }),
-    sleeping: () => ({
-      test: ({ instance, target }) => {
-        const distance = length(subtract(target.position, instance.position))
-        return distance >= 10
-      },
-      true: () => "aware",
-      false: ({ instance }) => instance.state,
-    }),
-  }
-
-  const state = decide(tree, { instance, target })
-
-  expect(state).toBe("aware")
-})
+import { length } from "@inglorious/utils/math/linear-algebra/vector.js"
+import { subtract } from "@inglorious/utils/math/linear-algebra/vectors.js"
+import { expect, test } from "vitest"
+
+import { decide } from "./decision-tree.js"
+
+test("it should make a decision based on a binary decision tree", () => {
+  const entity = { state: "sleeping", position: [0, 0, 0] }
+  const target = { position: [10, 0, 0] }
+  const tree = {
+    test({ entity }) {
+      return entity.state === "idle"
+    },
+    true() {
+      return {
+        test({ entity, target }) {
+          const distance = length(subtract(target.position, entity.position))
+          return distance < 250
+        },
+        true() {
+          return "aware"
+        },
+      }
+    },
+    false() {
+      return {
+        test({ entity }) {
+          return entity.state === "chasing"
+        },
+        true() {
+          return {
+            test({ entity, target }) {
+              const distance = length(
+                subtract(target.position, entity.position),
+              )
+              return distance >= 250
+            },
+            true() {
+              return "idle"
+            },
+            false() {
+              return {
+                test({ entity, target }) {
+                  const distance = length(
+                    subtract(target.position, entity.position),
+                  )
+                  return distance < 10
+                },
+                true() {
+                  return "sleepy"
+                },
+              }
+            },
+          }
+        },
+        false() {
+          return {
+            test({ entity }) {
+              return ["sleepy", "sleeping"].includes(entity.state)
+            },
+            true() {
+              return {
+                test({ entity, target }) {
+                  const distance = length(
+                    subtract(target.position, entity.position),
+                  )
+                  return distance >= 10
+                },
+                true() {
+                  return "aware"
+                },
+              }
+            },
+          }
+        },
+      }
+    },
+  }
+
+  const state = decide(tree, { entity, target })
+
+  expect(state).toBe("aware")
+})
+
+test("it should make a decision on a multi-child tree", () => {
+  const entity = { state: "sleeping", position: [0, 0, 0] }
+  const target = { position: [10, 0, 0] }
+  const wakeUp = () => ({
+    test({ entity, target }) {
+      const distance = length(subtract(target.position, entity.position))
+      return distance >= 10
+    },
+    true() {
+      return "aware"
+    },
+    false({ entity }) {
+      return entity.state
+    },
+  })
+
+  const tree = {
+    test({ entity }) {
+      return entity.state
+    },
+    idle() {
+      return {
+        test({ entity, target }) {
+          const distance = length(subtract(target.position, entity.position))
+          return distance < 250
+        },
+        true() {
+          return "aware"
+        },
+        false({ entity }) {
+          return entity.state
+        },
+      }
+    },
+    chasing() {
+      return {
+        test({ entity, target }) {
+          const distance = length(subtract(target.position, entity.position))
+          return distance >= 250
+        },
+        true() {
+          return "idle"
+        },
+        false() {
+          return {
+            test({ entity, target }) {
+              const distance = length(
+                subtract(target.position, entity.position),
+              )
+              return distance < 10
+            },
+            true() {
+              return "sleepy"
+            },
+            false({ entity }) {
+              return entity.state
+            },
+          }
+        },
+      }
+    },
+    sleepy: wakeUp,
+    sleeping: wakeUp,
+  }
+
+  const state = decide(tree, { entity, target })
+
+  expect(state).toBe("aware")
+})