@wonderyard/vivarium 0.1.4 → 0.1.5

package/dist/blueprint/ref-blueprint.js

@@ -1,7 +1,7 @@
 import { BaseBlueprint as r } from "./base-blueprint.js";
-import { R as n } from "../rule-blueprint-Df5BKApy.js";
+import { R as n } from "../rule-blueprint-Dhi6aLUs.js";
 import { toRefIdOrPoint as p } from "./utils.js";
-import { A as u } from "../constants-Ry69vZz5.js";
+import { A as u } from "../constants-CBz0gZS0.js";
 class o extends r {
   constructor(e, t) {
     super(), this.automaton = e, this.id = t.id, this.name = t.name, this.type = t.type;

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

@@ -8,8 +8,7 @@ export declare class RuleBlueprint extends BaseBlueprint {
     protected rule: Rule;
     constructor(context: BlueprintContext, automaton: Automaton, rule: Rule);
     private condition;
-    count(refBlueprintOrNeighbor: RefBlueprint | AnyNeighbor, count: number[]): RuleBlueprintWithAccept;
-    count(refBlueprintOrNeighbor: RefBlueprint | AnyNeighbor, ...count: number[]): RuleBlueprintWithAccept;
+    count(refBlueprintOrNeighbor: RefBlueprint | AnyNeighbor, ...count: (number | number[])[]): RuleBlueprintWithAccept;
     is(neighbor: AnyNeighbor, refBlueprintOrNeighbor: RefBlueprint | AnyNeighbor): RuleBlueprintWithAccept;
     chance(part: number, whole?: number): RuleBlueprintWithAccept;
 }

package/dist/blueprint/rule-blueprint.js

@@ -1,7 +1,7 @@
-import { R as m } from "../rule-blueprint-Df5BKApy.js";
+import { R as m } from "../rule-blueprint-Dhi6aLUs.js";
 import "./base-blueprint.js";
 import "./utils.js";
-import "../constants-Ry69vZz5.js";
+import "../constants-CBz0gZS0.js";
 export {
   m as RuleBlueprint
 };

package/dist/blueprint/utils.js

@@ -1,4 +1,4 @@
-import { n as t } from "../constants-Ry69vZz5.js";
+import { n as t } from "../constants-CBz0gZS0.js";
 const s = (o) => typeof o == "string" ? t[o] : o.id;
 export {
   s as toRefIdOrPoint

package/dist/blueprint/vivarium-blueprint.js

@@ -1,8 +1,8 @@
-import { n as o } from "../rule-blueprint-Df5BKApy.js";
+import { n as o } from "../rule-blueprint-Dhi6aLUs.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-Ry69vZz5.js";
+import { C as u, S as p } from "../constants-CBz0gZS0.js";
 class C extends n {
   constructor(t) {
     super(), this.neighborhoodName = t, this.helpers = new a(this.neighborhoodName), this.neighbor = this.neighborhoodName === "cross" ? u : p, this.automaton = {

package/dist/common/constants.js

@@ -1,4 +1,4 @@
-import { A as o, C as e, a5 as p, a1 as c, a2 as n, a6 as t, S as r, a4 as u, cf as i, a7 as G, n as d } from "../constants-Ry69vZz5.js";
+import { A as o, C as e, b as p, G as c, a as n, O as t, S as r, T as u, cf as G, c as i, n as O } from "../constants-CBz0gZS0.js";
 export {
   o as Accept,
   e as Cross,
@@ -8,7 +8,7 @@ export {
   t as Opcode,
   r as Square,
   u as To,
-  i as WORKGROUP_SIZE,
-  G as acceptMap,
-  d as neighborhoodPoints
+  G as WORKGROUP_SIZE,
+  i as acceptMap,
+  O as neighborhoodPoints
 };

package/dist/common/utils.js

@@ -48,11 +48,10 @@ const f = (e) => {
     case "darkgoldenrod":
       return "#b8860b";
     case "darkgray":
+    case "darkgrey":
       return "#a9a9a9";
     case "darkgreen":
       return "#006400";
-    case "darkgrey":
-      return "#a9a9a9";
     case "darkkhaki":
       return "#bdb76b";
     case "darkmagenta":
@@ -72,7 +71,6 @@ const f = (e) => {
     case "darkslateblue":
       return "#483d8b";
     case "darkslategray":
-      return "#2f4f4f";
     case "darkslategrey":
       return "#2f4f4f";
     case "darkturquoise":
@@ -84,7 +82,6 @@ const f = (e) => {
     case "deepskyblue":
       return "#00bfff";
     case "dimgray":
-      return "#696969";
     case "dimgrey":
       return "#696969";
     case "dodgerblue":
@@ -142,11 +139,10 @@ const f = (e) => {
     case "lightgoldenrodyellow":
       return "#fafad2";
     case "lightgray":
+    case "lightgrey":
       return "#d3d3d3";
     case "lightgreen":
       return "#90ee90";
-    case "lightgrey":
-      return "#d3d3d3";
     case "lightpink":
       return "#ffb6c1";
     case "lightsalmon":
@@ -156,7 +152,6 @@ const f = (e) => {
     case "lightskyblue":
       return "#87cefa";
     case "lightslategray":
-      return "#778899";
     case "lightslategrey":
       return "#778899";
     case "lightsteelblue":
@@ -262,7 +257,6 @@ const f = (e) => {
     case "slateblue":
       return "#6a5acd";
     case "slategray":
-      return "#708090";
     case "slategrey":
       return "#708090";
     case "snow":
@@ -301,7 +295,7 @@ const f = (e) => {
   const t = /^#?([a-f\d])([a-f\d])([a-f\d])$/i;
   e = e.replace(
     t,
-    (l, a, n, c) => a + a + n + n + c + c
+    (l, a, c, n) => a + a + c + c + n + n
   );
   const r = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(e);
   if (!r)

package/dist/{constants-Ry69vZz5.js → constants-CBz0gZS0.js}

@@ -2366,42 +2366,42 @@ const Hn = {
 export {
   O as $,
   Qi as A,
-  Ie as B,
+  jn as B,
   qi as C,
-  jt as D,
-  w as E,
-  bh as F,
-  In as G,
-  Is as H,
-  Qs as I,
+  Nn as D,
+  J as E,
+  dh as F,
+  Dn as G,
+  wh as H,
+  Ie as I,
   Ks as J,
-  $n as K,
-  En as L,
-  es as M,
-  sh as N,
-  kn as O,
-  Bi as P,
-  si as Q,
-  Gt as R,
+  Y as K,
+  jt as L,
+  w as M,
+  En as N,
+  Ji as O,
+  bh as P,
+  Bi as Q,
+  In as R,
   Zi as S,
-  mh as T,
-  b as U,
+  Xi as T,
+  Is as U,
   z as V,
   Tn as W,
-  $ as X,
+  Qs as X,
   On as Y,
-  re as Z,
+  es as Z,
   Te as _,
-  ki as a,
+  Wn as a,
   en as a$,
-  Ve as a0,
-  Dn as a1,
-  Wn as a2,
-  Y as a3,
-  Xi as a4,
-  Kn as a5,
-  Ji as a6,
-  Hn as a7,
+  sh as a0,
+  kn as a1,
+  si as a2,
+  Gt as a3,
+  b as a4,
+  $ as a5,
+  re as a6,
+  Ve as a7,
   xh as a8,
   F as a9,
   fn as aA,
@@ -2457,7 +2457,7 @@ export {
   Xh as ax,
   Jh as ay,
   Qh as az,
-  _h as b,
+  Kn as b,
   Oh as b$,
   sn as b0,
   Rh as b1,
@@ -2522,7 +2522,7 @@ export {
   jh as bx,
   uh as by,
   Ui as bz,
-  $i as c,
+  Hn as c,
   d as c0,
   Mn as c1,
   Pt as c2,
@@ -2539,27 +2539,27 @@ export {
   Cn as cd,
   Fn as ce,
   Zn as cf,
-  Ys as d,
-  Xe as e,
+  mh as d,
+  ki as e,
   qs as f,
-  Ce as g,
+  _h as g,
   Ue as h,
   n as i,
-  Sn as j,
-  Pn as k,
+  $i as j,
+  Ys as k,
   Rs as l,
   zh as m,
   Bn as n,
-  a as o,
+  Xe as o,
   Hs as p,
-  jn as q,
-  Nn as r,
-  J as s,
+  Ce as q,
+  $n as r,
+  a as s,
   pt as t,
   Ls as u,
-  dh as v,
+  Sn as v,
   Zs as w,
-  wh as x,
+  Pn as x,
   Us as y,
   ph as z
 };

package/dist/{rule-blueprint-Df5BKApy.js → rule-blueprint-Dhi6aLUs.js}

@@ -1,50 +1,51 @@
 import { BaseBlueprint as s } from "./blueprint/base-blueprint.js";
-import { toRefIdOrPoint as o } from "./blueprint/utils.js";
-import { n as a, a7 as c } from "./constants-Ry69vZz5.js";
+import { toRefIdOrPoint as r } from "./blueprint/utils.js";
+import { n as c, c as a } from "./constants-CBz0gZS0.js";
 const h = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";
-let n = (i = 21) => {
+let o = (i = 21) => {
   let t = "", e = crypto.getRandomValues(new Uint8Array(i |= 0));
   for (; i--; )
     t += h[e[i] & 63];
   return t;
 };
 class u extends s {
-  constructor(t, e, r) {
-    super(), this.context = t, this.automaton = e, this.rule = r;
+  constructor(t, e, n) {
+    super(), this.context = t, this.automaton = e, this.rule = n;
   }
   condition(t) {
-    return this.assertNotCreated(), this.rule.when = [...this.rule.when, t], new d(this.context, this.automaton, this.rule);
+    return this.assertNotCreated(), this.rule.when = [...this.rule.when, t], new l(this.context, this.automaton, this.rule);
   }
-  count(t, e = this.automaton.neighborhood === "cross" ? [1, 2, 3, 4] : [1, 2, 3, 4, 5, 6, 7, 8]) {
-    return this.condition({
+  count(t, ...e) {
+    let n = this.automaton.neighborhood === "cross" ? [1, 2, 3, 4] : [1, 2, 3, 4, 5, 6, 7, 8];
+    return e.length !== 0 && (n = e.flat()), this.condition({
       type: "count",
-      id: n(),
-      check: o(t),
-      count: Array.isArray(e) ? e : [e]
+      id: o(),
+      check: r(t),
+      count: n
     });
   }
   is(t, e) {
     return this.condition({
       type: "is",
-      id: n(),
-      compare: a[t],
-      with: o(e)
+      id: o(),
+      compare: c[t],
+      with: r(e)
     });
   }
   chance(t, e = 100) {
     return t < 0 && (t = 0), e <= 0 && (e = 1), t > e && (t = e), t = Math.floor(t), e = Math.floor(e), this.condition({
       type: "chance",
-      id: n(),
+      id: o(),
       ratio: { part: t, whole: e }
     });
   }
 }
-class d extends u {
+class l extends u {
   accept(t) {
-    this.assertNotCreated(), this.rule.accept = c[t];
+    this.assertNotCreated(), this.rule.accept = a[t];
   }
 }
 export {
   u as R,
-  n
+  o as n
 };

package/dist/webgpu/compiler.d.ts

@@ -1,27 +1,14 @@
-import { TgpuRoot } from 'typegpu';
 import { Automaton } from '../automaton/types';
+import { GpuCondition, GpuElement, GpuRule } from '../common/constants';
 import * as d from "typegpu/data";
-export declare const compileGpuAutomaton: (root: TgpuRoot, automaton: Automaton) => {
-    neighborhood: import('typegpu').TgpuBuffer<d.U32> & import('typegpu').UniformFlag;
-    elements: import('typegpu').TgpuBuffer<d.WgslArray<d.WgslStruct<{
-        color: d.U32;
-        ruleStart: d.U32;
-        ruleEnd: d.U32;
-    }>>> & import('typegpu').StorageFlag;
-    rules: import('typegpu').TgpuBuffer<d.WgslArray<d.WgslStruct<{
-        toType: d.U32;
-        toId: d.U32;
-        toNeighbor: d.Vec2u;
-        accept: d.U32;
-        conditionsStart: d.U32;
-        conditionsEnd: d.U32;
-    }>>> & import('typegpu').StorageFlag;
-    conditions: import('typegpu').TgpuBuffer<d.WgslArray<d.WgslStruct<{
-        opcode: d.U32;
-        checkId: d.U32;
-        countOrWithId: d.U32;
-        checkPointOrComparePoint: d.Vec2u;
-        withPoint: d.Vec2u;
-        chance: d.F32;
-    }>>> & import('typegpu').StorageFlag;
+type GpuRuleType = d.Infer<typeof GpuRule>;
+type GpuElementType = d.Infer<typeof GpuElement>;
+type GpuConditionType = d.Infer<typeof GpuCondition>;
+export type GpuAutomaton = {
+    gpuNeighborhood: number;
+    gpuElements: GpuElementType[];
+    gpuRules: GpuRuleType[];
+    gpuConditions: GpuConditionType[];
 };
+export declare const compileGpuAutomaton: (automaton: Automaton) => GpuAutomaton;
+export {};

package/dist/webgpu/compiler.js

@@ -1,6 +1,129 @@
-import "../constants-Ry69vZz5.js";
-import "../common/utils.js";
-import { g as r } from "../compiler-CEYR17Vv.js";
+import { G as N, a as O, K as I, T as u, b as k, O as m } from "../constants-CBz0gZS0.js";
+import { colorToABGR as g } from "../common/utils.js";
+const T = (n) => {
+  if (n.some((t) => t > 31))
+    throw console.warn(
+      `Elements with an index greater than 31 and extending one or more kinds are not allowed when they are involved in conditions referencing kinds.
+To assign a lower index, move the elements with extensions higher in the definition list or reduce the overall number of elements and kinds.`
+    ), new Error(
+      "Element in condition involving kinds has an index greater than 31"
+    );
+}, P = (n, t, f) => {
+  const { elements: h } = f, p = h.findIndex((r) => r.id === n);
+  if (p !== -1)
+    t.opcode = m.COUNT_ELEMENT, t.checkId = p;
+  else {
+    const r = h.map((s, d) => ({ ...s, index: d })).filter(
+      (s) => s.extensions.some((d) => d === n)
+    ).map((s) => s.index);
+    T(r);
+    const c = r.reduce((s, d) => (s |= 1 << d, s), 0);
+    t.checkId = c, t.opcode = m.COUNT_KIND;
+  }
+}, _ = (n, t) => {
+  t.opcode = m.COUNT_POINT, t.checkPointOrComparePoint = I(n.x, n.y);
+}, S = (n, t, f) => {
+  const { check: h, count: p } = n;
+  if (typeof h > "u")
+    throw new Error("condition.check is undefined");
+  typeof h == "string" ? P(h, t, f) : _(h, t), t.countOrWithId = p.reduce(
+    // Packing numbers as positional bits.
+    // Example: [2, 3] -> 0b000001100
+    (r, c) => (r |= 1 << c, r),
+    0
+  );
+}, M = (n, t, f) => {
+  const h = n.compare;
+  if (typeof h > "u")
+    throw new Error("condition.compare is undefined");
+  if (typeof n.with > "u")
+    throw new Error("condition.with is undefined");
+  if (t.checkPointOrComparePoint = I(
+    h.x,
+    h.y
+  ), typeof n.with == "string") {
+    const p = n.with;
+    if (f.elements.some((r) => r.id === p)) {
+      t.opcode = m.IS_ELEMENT;
+      const r = f.elements.findIndex(
+        (c) => c.id === p
+      );
+      t.countOrWithId = r;
+    } else {
+      const r = f.elements.map((s, d) => ({ ...s, index: d })).filter(
+        (s) => s.extensions.some((d) => d === p)
+      ).map((s) => s.index);
+      T(r);
+      const c = r.reduce((s, d) => (s |= 1 << d, s), 0);
+      t.countOrWithId = c, t.opcode = m.IS_KIND;
+    }
+  } else
+    t.opcode = m.IS_POINT, t.withPoint = I(n.with.x, n.with.y);
+}, G = (n) => {
+  const { elements: t, rules: f } = n, h = f.filter((e) => e.fromType === "element").reduce(
+    (e, o) => {
+      const l = t.findIndex(
+        (i) => i.id === o.fromId
+      );
+      return e[l].push(o), e;
+    },
+    t.map(() => [])
+  ), p = f.filter((e) => e.fromType === "kind").reduce((e, o) => (t.forEach((l, i) => {
+    l.extensions.includes(o.fromId) && e[i].push(o);
+  }), e), h), r = [];
+  let c = [];
+  const s = /* @__PURE__ */ new Map();
+  p.forEach((e) => {
+    e.forEach((o, l) => {
+      let i, a;
+      const w = `${o.fromId}:${l.toString()}`;
+      o.fromType === "kind" && s.has(w) ? [i, a] = s.get(w) : (i = c.length, Array.isArray(o.when) ? c = c.concat(o.when) : c = c.concat([o.when]), a = c.length, s.set(w, [i, a])), r.push({
+        ...o,
+        conditionsStart: i,
+        conditionsEnd: a
+      });
+    });
+  });
+  const d = [], y = [], x = [];
+  let E = 0;
+  return t.forEach((e, o) => {
+    const l = E, i = E + p[o].length;
+    E = i;
+    const a = N({
+      color: g(e.color),
+      ruleStart: l,
+      ruleEnd: i
+    });
+    d.push(a);
+  }), r.forEach((e) => {
+    const { conditionsStart: o, conditionsEnd: l } = e, i = O({
+      toType: u.ELEMENT_ID,
+      toId: 0,
+      toNeighbor: I(),
+      conditionsStart: o,
+      conditionsEnd: l,
+      accept: e.accept
+    });
+    if (y.push(i), typeof e.to > "u")
+      throw new Error("rule.to is undefined");
+    typeof e.to == "string" ? (i.toType = u.ELEMENT_ID, i.toId = t.findIndex((a) => a.id === e.to)) : (i.toType = u.POINT, i.toNeighbor = I(e.to.x, e.to.y));
+  }), c.forEach((e) => {
+    const o = k({
+      opcode: m.NOOP,
+      checkId: 0,
+      countOrWithId: 0,
+      checkPointOrComparePoint: I(),
+      withPoint: I(),
+      chance: 0
+    });
+    x.push(o), e.type === "count" ? S(e, o, n) : e.type === "is" ? M(e, o, n) : (o.opcode = m.CHANCE, o.chance = e.ratio.part / e.ratio.whole);
+  }), {
+    gpuNeighborhood: n.neighborhood === "cross" ? 4 : 8,
+    gpuElements: d,
+    gpuRules: y,
+    gpuConditions: x
+  };
+};
 export {
-  r as compileGpuAutomaton
+  G as compileGpuAutomaton
 };