@wonderyard/vivarium 1.0.0 → 1.2.0

package/README.md

@@ -70,7 +70,7 @@ const canvas = document.createElement(canvas);
 document.body.appendChild(canvas);
 
 // Set the canvas size. This will be the automaton size as well.
-const size = 512;
+const size = 256;
 canvas.width = size;
 canvas.height = size;
 

package/dist/blueprint/ref-blueprint.d.ts

@@ -27,7 +27,8 @@ export declare class ElementBlueprint extends RefBlueprint {
     protected context: BlueprintContext;
     type: "element";
     id: string;
-    constructor(context: BlueprintContext, automaton: Automaton, element: Element);
+    index: number;
+    constructor(context: BlueprintContext, automaton: Automaton, element: Element, index: number);
 }
 /**
  * Blueprint for a kind. Returned by {@link VivariumBlueprint.kind | vivarium().kind()}.

package/dist/blueprint/ref-blueprint.js

@@ -1,8 +1,8 @@
-import { BaseBlueprint as r } from "./base-blueprint.js";
-import { R as n } from "../rule-blueprint-DGODv9IV.js";
-import { toRefIdOrPoint as p } from "./utils.js";
+import { BaseBlueprint as n } from "./base-blueprint.js";
+import { R as p } from "../rule-blueprint-DGODv9IV.js";
+import { toRefIdOrPoint as d } from "./utils.js";
 import { A as u } from "../constants-D4GX9YB2.js";
-class o extends r {
+class o extends n {
   constructor(e, t) {
     super(), this.automaton = e, this.id = t.id, this.name = t.name, this.type = t.type;
   }
@@ -20,29 +20,30 @@ class o extends r {
     const t = {
       fromId: this.id,
       fromType: this.type,
-      to: p(e),
+      to: d(e),
       when: [],
       accept: u.ALL
     };
-    return this.automaton.rules.push(t), new n(this.context, this.automaton, t);
+    return this.automaton.rules.push(t), new p(this.context, this.automaton, t);
   }
 }
-class h extends o {
-  constructor(e, t, s) {
-    super(t, s), this.context = e, this.id = s.id;
+class l extends o {
+  constructor(e, t, i, r) {
+    super(t, i), this.context = e, this.id = i.id, this.index = r;
   }
   type = "element";
   id;
+  index;
 }
-class l extends o {
-  constructor(e, t, s) {
-    super(t, s), this.context = e, this.id = s.id;
+class x extends o {
+  constructor(e, t, i) {
+    super(t, i), this.context = e, this.id = i.id;
   }
   type = "kind";
   id;
 }
 export {
-  h as ElementBlueprint,
-  l as KindBlueprint,
+  l as ElementBlueprint,
+  x as KindBlueprint,
   o as RefBlueprint
 };

package/dist/blueprint/vivarium-blueprint.js

@@ -1,11 +1,11 @@
 import { n as o } from "../rule-blueprint-DGODv9IV.js";
-import { BaseBlueprint as n } from "./base-blueprint.js";
-import { Helpers as a } from "./helpers.js";
-import { ElementBlueprint as h, KindBlueprint as m } from "./ref-blueprint.js";
-import { C as u, S as p } from "../constants-D4GX9YB2.js";
-class C extends n {
+import { BaseBlueprint as a } from "./base-blueprint.js";
+import { Helpers as h } from "./helpers.js";
+import { ElementBlueprint as m, KindBlueprint as u } from "./ref-blueprint.js";
+import { C as d, S as p } from "../constants-D4GX9YB2.js";
+class b extends a {
   constructor(t) {
-    super(), this.neighborhoodName = t, this.helpers = new a(this.neighborhoodName), this.neighbor = this.neighborhoodName === "cross" ? u : p, this.automaton = {
+    super(), this.neighborhoodName = t, this.helpers = new h(this.neighborhoodName), this.neighbor = this.neighborhoodName === "cross" ? d : p, this.automaton = {
       neighborhood: t ?? "square",
       elements: [],
       kinds: [],
@@ -36,16 +36,16 @@ class C extends n {
    * @param extensions - An optional array of kinds this element extends.
    * @returns An {@link ElementBlueprint} that can be used to define rules.
    */
-  element(t, e, r = []) {
+  element(t, e, i = []) {
     this.assertNotCreated(), this.assertUniqueName(t), this.assertUniqueColor(e);
     const s = {
       type: "element",
       id: o(),
       name: t,
       color: e,
-      extensions: r.map((i) => i.id)
-    };
-    return this.automaton.elements.push(s), new h(this.context, this.automaton, s);
+      extensions: i.map((r) => r.id)
+    }, n = this.automaton.elements.push(s) - 1;
+    return new m(this.context, this.automaton, s, n);
   }
   /**
    * Defines a new kind in the vivarium. A kind groups elements that share common behavior.
@@ -60,7 +60,7 @@ class C extends n {
       id: o(),
       name: t
     };
-    return this.automaton.kinds.push(e), new m(this.context, this.automaton, e);
+    return this.automaton.kinds.push(e), new u(this.context, this.automaton, e);
   }
   /**
    * Finalizes the vivarium and produces an {@link Automaton} object. After calling this method,
@@ -75,5 +75,5 @@ class C extends n {
   }
 }
 export {
-  C as VivariumBlueprint
+  b as VivariumBlueprint
 };

package/dist/main.d.ts

@@ -1,6 +1,6 @@
+export { Helpers } from './blueprint/helpers';
+export { ElementBlueprint, KindBlueprint, RefBlueprint, } from './blueprint/ref-blueprint';
+export { RuleBlueprint, RuleBlueprintWithAccept, } from './blueprint/rule-blueprint';
+export { VivariumBlueprint } from './blueprint/vivarium-blueprint';
 export { vivarium } from './vivarium/vivarium';
 export { setup } from './webgpu/setup';
-export { VivariumBlueprint } from './blueprint/vivarium-blueprint';
-export { RefBlueprint, ElementBlueprint, KindBlueprint, } from './blueprint/ref-blueprint';
-export { RuleBlueprint, RuleBlueprintWithAccept, } from './blueprint/rule-blueprint';
-export { Helpers } from './blueprint/helpers';

package/dist/main.js

@@ -1,17 +1,17 @@
-import { vivarium as t } from "./vivarium/vivarium.js";
-import { setup as i } from "./webgpu/setup.js";
-import { VivariumBlueprint as u } from "./blueprint/vivarium-blueprint.js";
-import { ElementBlueprint as m, KindBlueprint as n, RefBlueprint as f } from "./blueprint/ref-blueprint.js";
-import { R as B, a } from "./rule-blueprint-DGODv9IV.js";
-import { Helpers as R } from "./blueprint/helpers.js";
+import { Helpers as t } from "./blueprint/helpers.js";
+import { ElementBlueprint as i, KindBlueprint as o, RefBlueprint as u } from "./blueprint/ref-blueprint.js";
+import { R as m, a as n } from "./rule-blueprint-DGODv9IV.js";
+import { VivariumBlueprint as x } from "./blueprint/vivarium-blueprint.js";
+import { vivarium as a } from "./vivarium/vivarium.js";
+import { setup as R } from "./webgpu/setup.js";
 export {
-  m as ElementBlueprint,
-  R as Helpers,
-  n as KindBlueprint,
-  f as RefBlueprint,
-  B as RuleBlueprint,
-  a as RuleBlueprintWithAccept,
-  u as VivariumBlueprint,
-  i as setup,
-  t as vivarium
+  i as ElementBlueprint,
+  t as Helpers,
+  o as KindBlueprint,
+  u as RefBlueprint,
+  m as RuleBlueprint,
+  n as RuleBlueprintWithAccept,
+  x as VivariumBlueprint,
+  R as setup,
+  a as vivarium
 };

package/dist/webgpu/setup.d.ts

@@ -63,16 +63,20 @@ export declare const mainCompute: import('typegpu').TgpuComputeFn<{
 }>;
 /**
  * Initializes the WebGPU simulation for a given canvas and automaton. The grid is randomly initialized
- * with the defined elements.
+ * with the defined elements unless an `initialGrid` is provided.
+ *
+ * Use `index` found in `ElementBlueprint` instances to reference elements when building the initialGrid.
  *
  * @param options - An object containing the `canvas` element and the compiled `automaton`.
  * @param options.canvas - The HTML canvas element. Its `width` and `height` define the grid dimensions.
  * @param options.automaton - The compiled automaton produced by {@link VivariumBlueprint.create | vivarium().create()}.
+ * @param options.initialGrid - An optional 2d array of element indices to use instead of random initialization. Alternatively, you can pass a flat (1d) array with one index per cell, row-major order.
  * @returns An object with an `evolve` function that advances the simulation by one step, a `setAutomaton` function to update the automaton, and the underlying `tgpuRoot`.
  */
-export declare const setup: ({ canvas, automaton, }: {
+export declare const setup: ({ canvas, automaton, initialGrid, }: {
     canvas: HTMLCanvasElement;
     automaton: Automaton;
+    initialGrid?: number[] | number[][];
 }) => {
     evolve: () => Promise<void>;
     setAutomaton: ({ automaton }: {