@wonderyard/vivarium 0.1.3 → 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

@@ -1,53 +1,308 @@
-const u = (e) => {
+const f = (e) => {
   switch (e.toLowerCase()) {
+    case "aliceblue":
+      return "#f0f8ff";
+    case "antiquewhite":
+      return "#faebd7";
+    case "aqua":
+    case "cyan":
+      return "#00ffff";
+    case "aquamarine":
+      return "#7fffd4";
+    case "azure":
+      return "#f0ffff";
+    case "beige":
+      return "#f5f5dc";
+    case "bisque":
+      return "#ffe4c4";
     case "black":
       return "#000000";
-    case "silver":
-      return "#c0c0c0";
-    case "gray":
-      return "#808080";
-    case "white":
-      return "#ffffff";
-    case "maroon":
-      return "#800000";
-    case "red":
-      return "#ff0000";
-    case "purple":
-      return "#800080";
+    case "blanchedalmond":
+      return "#ffebcd";
+    case "blue":
+      return "#0000ff";
+    case "blueviolet":
+      return "#8a2be2";
+    case "brown":
+      return "#a52a2a";
+    case "burlywood":
+      return "#deb887";
+    case "cadetblue":
+      return "#5f9ea0";
+    case "chartreuse":
+      return "#7fff00";
+    case "chocolate":
+      return "#d2691e";
+    case "coral":
+      return "#ff7f50";
+    case "cornflowerblue":
+      return "#6495ed";
+    case "cornsilk":
+      return "#fff8dc";
+    case "crimson":
+      return "#dc143c";
+    case "darkblue":
+      return "#00008b";
+    case "darkcyan":
+      return "#008b8b";
+    case "darkgoldenrod":
+      return "#b8860b";
+    case "darkgray":
+    case "darkgrey":
+      return "#a9a9a9";
+    case "darkgreen":
+      return "#006400";
+    case "darkkhaki":
+      return "#bdb76b";
+    case "darkmagenta":
+      return "#8b008b";
+    case "darkolivegreen":
+      return "#556b2f";
+    case "darkorange":
+      return "#ff8c00";
+    case "darkorchid":
+      return "#9932cc";
+    case "darkred":
+      return "#8b0000";
+    case "darksalmon":
+      return "#e9967a";
+    case "darkseagreen":
+      return "#8fbc8f";
+    case "darkslateblue":
+      return "#483d8b";
+    case "darkslategray":
+    case "darkslategrey":
+      return "#2f4f4f";
+    case "darkturquoise":
+      return "#00ced1";
+    case "darkviolet":
+      return "#9400d3";
+    case "deeppink":
+      return "#ff1493";
+    case "deepskyblue":
+      return "#00bfff";
+    case "dimgray":
+    case "dimgrey":
+      return "#696969";
+    case "dodgerblue":
+      return "#1e90ff";
+    case "firebrick":
+      return "#b22222";
+    case "floralwhite":
+      return "#fffaf0";
+    case "forestgreen":
+      return "#228b22";
     case "fuchsia":
+    case "magenta":
       return "#ff00ff";
+    case "gainsboro":
+      return "#dcdcdc";
+    case "ghostwhite":
+      return "#f8f8ff";
+    case "gold":
+      return "#ffd700";
+    case "goldenrod":
+      return "#daa520";
+    case "gray":
+    case "grey":
+      return "#808080";
     case "green":
       return "#008000";
+    case "greenyellow":
+      return "#adff2f";
+    case "honeydew":
+      return "#f0fff0";
+    case "hotpink":
+      return "#ff69b4";
+    case "indianred":
+      return "#cd5c5c";
+    case "indigo":
+      return "#4b0082";
+    case "ivory":
+      return "#fffff0";
+    case "khaki":
+      return "#f0e68c";
+    case "lavender":
+      return "#e6e6fa";
+    case "lavenderblush":
+      return "#fff0f5";
+    case "lawngreen":
+      return "#7cfc00";
+    case "lemonchiffon":
+      return "#fffacd";
+    case "lightblue":
+      return "#add8e6";
+    case "lightcoral":
+      return "#f08080";
+    case "lightcyan":
+      return "#e0ffff";
+    case "lightgoldenrodyellow":
+      return "#fafad2";
+    case "lightgray":
+    case "lightgrey":
+      return "#d3d3d3";
+    case "lightgreen":
+      return "#90ee90";
+    case "lightpink":
+      return "#ffb6c1";
+    case "lightsalmon":
+      return "#ffa07a";
+    case "lightseagreen":
+      return "#20b2aa";
+    case "lightskyblue":
+      return "#87cefa";
+    case "lightslategray":
+    case "lightslategrey":
+      return "#778899";
+    case "lightsteelblue":
+      return "#b0c4de";
+    case "lightyellow":
+      return "#ffffe0";
     case "lime":
       return "#00ff00";
-    case "olive":
-      return "#808000";
-    case "yellow":
-      return "#ffff00";
+    case "limegreen":
+      return "#32cd32";
+    case "linen":
+      return "#faf0e6";
+    case "maroon":
+      return "#800000";
+    case "mediumaquamarine":
+      return "#66cdaa";
+    case "mediumblue":
+      return "#0000cd";
+    case "mediumorchid":
+      return "#ba55d3";
+    case "mediumpurple":
+      return "#9370db";
+    case "mediumseagreen":
+      return "#3cb371";
+    case "mediumslateblue":
+      return "#7b68ee";
+    case "mediumspringgreen":
+      return "#00fa9a";
+    case "mediumturquoise":
+      return "#48d1cc";
+    case "mediumvioletred":
+      return "#c71585";
+    case "midnightblue":
+      return "#191970";
+    case "mintcream":
+      return "#f5fffa";
+    case "mistyrose":
+      return "#ffe4e1";
+    case "moccasin":
+      return "#ffe4b5";
+    case "navajowhite":
+      return "#ffdead";
     case "navy":
       return "#000080";
-    case "blue":
-      return "#0000ff";
+    case "oldlace":
+      return "#fdf5e6";
+    case "olive":
+      return "#808000";
+    case "olivedrab":
+      return "#6b8e23";
+    case "orange":
+      return "#ffa500";
+    case "orangered":
+      return "#ff4500";
+    case "orchid":
+      return "#da70d6";
+    case "palegoldenrod":
+      return "#eee8aa";
+    case "palegreen":
+      return "#98fb98";
+    case "paleturquoise":
+      return "#afeeee";
+    case "palevioletred":
+      return "#db7093";
+    case "papayawhip":
+      return "#ffefd5";
+    case "peachpuff":
+      return "#ffdab9";
+    case "peru":
+      return "#cd853f";
+    case "pink":
+      return "#ffc0cb";
+    case "plum":
+      return "#dda0dd";
+    case "powderblue":
+      return "#b0e0e6";
+    case "purple":
+      return "#800080";
+    case "rebeccapurple":
+      return "#663399";
+    case "red":
+      return "#ff0000";
+    case "rosybrown":
+      return "#bc8f8f";
+    case "royalblue":
+      return "#4169e1";
+    case "saddlebrown":
+      return "#8b4513";
+    case "salmon":
+      return "#fa8072";
+    case "sandybrown":
+      return "#f4a460";
+    case "seagreen":
+      return "#2e8b57";
+    case "seashell":
+      return "#fff5ee";
+    case "sienna":
+      return "#a0522d";
+    case "silver":
+      return "#c0c0c0";
+    case "skyblue":
+      return "#87ceeb";
+    case "slateblue":
+      return "#6a5acd";
+    case "slategray":
+    case "slategrey":
+      return "#708090";
+    case "snow":
+      return "#fffafa";
+    case "springgreen":
+      return "#00ff7f";
+    case "steelblue":
+      return "#4682b4";
+    case "tan":
+      return "#d2b48c";
     case "teal":
       return "#008080";
-    case "aqua":
-      return "#00ffff";
+    case "thistle":
+      return "#d8bfd8";
+    case "tomato":
+      return "#ff6347";
+    case "turquoise":
+      return "#40e0d0";
+    case "violet":
+      return "#ee82ee";
+    case "wheat":
+      return "#f5deb3";
+    case "white":
+      return "#ffffff";
+    case "whitesmoke":
+      return "#f5f5f5";
+    case "yellow":
+      return "#ffff00";
+    case "yellowgreen":
+      return "#9acd32";
     default:
       return e;
   }
-}, l = (e) => {
-  e = u(e);
-  const n = /^#?([a-f\d])([a-f\d])([a-f\d])$/i;
+}, i = (e) => {
+  e = f(e);
+  const t = /^#?([a-f\d])([a-f\d])([a-f\d])$/i;
   e = e.replace(
-    n,
-    (d, a, t, f) => a + a + t + t + f + f
+    t,
+    (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)
     throw new Error("Bad color");
-  const s = parseInt(r[1], 16), c = parseInt(r[2], 16);
-  return 4278190080 | parseInt(r[3], 16) << 16 | c << 8 | s;
+  const s = parseInt(r[1], 16), u = parseInt(r[2], 16);
+  return 4278190080 | parseInt(r[3], 16) << 16 | u << 8 | s;
 };
 export {
-  l as colorToABGR
+  i as colorToABGR
 };

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 {};