@aethervtt/shard-dice 0.0.0-stage → 0.2.0

package/dist/entrances.js

@@ -0,0 +1,54 @@
+import { ShardError } from "@aethervtt/shard-core";
+import { DICE_BUDGETS } from "./attachments.js";
+const MAX_ENTRANCES = 2;
+const entrances = /* @__PURE__ */ new Map();
+function budget(name, message) {
+  return new ShardError("dice/entrance-budget", `Entrance "${name}" ${message}`, {
+    hint: "Trim the scene, or raise DICE_BUDGETS with setDiceBudgets before defining it."
+  });
+}
+function defineDiceEntrance(name, def) {
+  if (!(def.vertices > 0) || def.vertices > DICE_BUDGETS.entranceVertices) {
+    throw budget(
+      name,
+      `declares ${def.vertices} vertices; the budget is ${DICE_BUDGETS.entranceVertices}`
+    );
+  }
+  if (!(def.durationMs > 0) || def.durationMs > DICE_BUDGETS.entranceMs) {
+    throw budget(name, `runs ${def.durationMs} ms; the budget is ${DICE_BUDGETS.entranceMs}`);
+  }
+  if (!(def.landAtMs >= 0 && def.landAtMs <= def.durationMs)) {
+    throw new ShardError(
+      "dice/invalid-entrance",
+      `Entrance "${name}" lands at ${def.landAtMs} ms, outside its ${def.durationMs} ms`,
+      { hint: "landAtMs is when the die lands: between 0 and durationMs.", path: "landAtMs" }
+    );
+  }
+  const spot = def.spot;
+  if (spot && spot !== "center" && !(Math.abs(spot[0]) <= 1 && Math.abs(spot[1]) <= 1)) {
+    throw new ShardError("dice/invalid-entrance", `Entrance "${name}" wants a spot off the tray`, {
+      hint: "spot is 'center', or [u, v] with each in \u22121..1 of the tray.",
+      path: "spot"
+    });
+  }
+  const existing = entrances.get(name);
+  if (existing && existing !== def) {
+    throw new ShardError("dice/registry-conflict", `Entrance "${name}" is already defined`, {
+      hint: "Give the new entrance its own name."
+    });
+  }
+  entrances.set(name, def);
+  return def;
+}
+function findDiceEntrance(name) {
+  return entrances.get(name);
+}
+function allDiceEntrances() {
+  return [...entrances.keys()].sort();
+}
+export {
+  MAX_ENTRANCES,
+  allDiceEntrances,
+  defineDiceEntrance,
+  findDiceEntrance
+};

package/dist/families.d.ts

@@ -0,0 +1,17 @@
+/** Opaque, one color, a few flecks in the pour. */
+export declare const SOLID: import("./material.js").DiceFamily;
+/**
+ * Translucent-looking resin without transparency: a tonal depth fake. Looking straight into a
+ * face sees deep color, swirled through the body; grazing angles and the chamfer catch light like
+ * thin resin does. The face on top glows a little once landed.
+ */
+export declare const RESIN: import("./material.js").DiceFamily;
+/** Metal: tinted by baseColor, brushed, with polished worn edges and enamel marks. */
+export declare const METAL: import("./material.js").DiceFamily;
+/**
+ * Glass: blended, clear through the middle of a face and bright at grazing angles, with opaque
+ * marks. Blended dice cast no shadow, so they get a contact blob on the tray. Always see-through,
+ * but not a fixed blend: the large-pool tier draws it opaque, so its dice batch.
+ */
+export declare const GLASS: import("./material.js").DiceFamily;
+export declare const BUILTIN_FAMILIES: readonly [import("./material.js").DiceFamily, import("./material.js").DiceFamily, import("./material.js").DiceFamily, import("./material.js").DiceFamily];

package/dist/families.js

@@ -0,0 +1,131 @@
+import { t } from "@aethervtt/shard-core";
+import { defineDiceFamily } from "./material.js";
+const SOLID = defineDiceFamily("dice/SolidDice", {
+  fields: {
+    fleck: t.f32({
+      default: 0.25,
+      min: 0,
+      max: 1,
+      description: "How many flecks show in the body."
+    }),
+    fleckColor: t.color({ default: [1, 1, 1, 1], description: "Fleck color (linear)." }),
+    fleckScale: t.f32({
+      default: 16,
+      min: 1,
+      description: "Fleck density, per unit of die radius."
+    })
+  },
+  surface: `
+  let speck = smoothstep(0.8, 0.88, dice_noise(local * F.fleckScale));
+  p.base_color = mix(p.base_color, F.fleckColor.rgb, speck * F.fleck * m.face);`,
+  description: "Solid dice: an opaque body, optional flecks."
+});
+const RESIN = defineDiceFamily("dice/ResinDice", {
+  fields: {
+    resinDeep: t.color({
+      default: [0.02, 0.18, 0.2, 1],
+      description: "The deep tone, looking into the body."
+    }),
+    resinGlow: t.color({
+      default: [0.3, 0.9, 0.82, 1],
+      description: "The light tone, at thin edges."
+    }),
+    resinDepth: t.f32({
+      default: 0.85,
+      min: 0,
+      max: 1,
+      description: "How much of the tones replace baseColor."
+    }),
+    resinSwirl: t.f32({ default: 0.55, min: 0, max: 1, description: "Swirl through the pour." }),
+    resinScale: t.f32({
+      default: 2.4,
+      min: 0.1,
+      description: "Swirl size, per unit of die radius."
+    }),
+    resinLight: t.f32({
+      default: 2600,
+      min: 0,
+      unit: "cd/m\xB2",
+      description: "Light at thin edges."
+    }),
+    resinResultGlow: t.f32({
+      default: 3e3,
+      min: 0,
+      unit: "cd/m\xB2",
+      description: "Glow of the marks on top once landed."
+    }),
+    resinOpacity: t.f32({
+      default: 1,
+      min: 0.2,
+      max: 1,
+      description: "Below 1, the resin is see-through: its material blends (no shadow; a contact blob instead)."
+    })
+  },
+  surface: `
+  let nv = clamp(dot(p.normal, v), 0.0, 1.0);
+  let swirl = dice_fbm(local * F.resinScale + vec3f(value * 1.7));
+  let depth = clamp(pow(nv, 0.6) * (1.0 - 0.5 * F.resinSwirl) + swirl * F.resinSwirl * 0.6, 0.0, 1.0);
+  let tone = mix(F.resinGlow.rgb, F.resinDeep.rgb, depth);
+  p.base_color = mix(p.base_color, tone, F.resinDepth);
+  let thin = pow(1.0 - nv, 3.0) + (1.0 - m.face) * 0.45;
+  p.emissive += F.resinGlow.rgb * F.resinLight * thin;
+  p.emissive += look.mark_color.rgb * F.resinResultGlow * look.result * m.top * m.coverage;
+  p.roughness = min(p.roughness, 0.22);
+  p.alpha = F.resinOpacity;`,
+  translucent: (params) => typeof params.resinOpacity === "number" && params.resinOpacity < 1,
+  description: "Resin dice: a tonal depth fake, swirl, glowing thin edges, a lit result face."
+});
+const METAL = defineDiceFamily("dice/MetalDice", {
+  fields: {
+    metalWear: t.f32({ default: 0.6, min: 0, max: 1, description: "Polished, brighter edges." }),
+    metalGrain: t.f32({
+      default: 0.4,
+      min: 0,
+      max: 1,
+      description: "Brushed streaks in the roughness."
+    })
+  },
+  surface: `
+  p.metallic = 1.0;
+  let grain = dice_noise(local * vec3f(70.0, 2.5, 70.0));
+  p.roughness = clamp(p.roughness * (1.0 + (grain - 0.5) * F.metalGrain), 0.05, 1.0);
+  let edge = 1.0 - m.face;
+  p.roughness = mix(p.roughness, p.roughness * 0.35, edge * F.metalWear);
+  p.base_color = mix(p.base_color, min(p.base_color * 1.3 + vec3f(0.04), vec3f(1.0)), edge * F.metalWear);`,
+  description: "Metal dice: brushed, worn bright at the edges, enamel marks."
+});
+const GLASS = defineDiceFamily("dice/GlassDice", {
+  fields: {
+    glassClarity: t.f32({
+      default: 0.8,
+      min: 0,
+      max: 1,
+      description: "How clear the body is face-on."
+    }),
+    glassSparkle: t.f32({
+      default: 0.5,
+      min: 0,
+      max: 1,
+      description: "Inner glints as the die turns."
+    })
+  },
+  translucent: () => true,
+  surface: `
+  let nv = clamp(dot(p.normal, v), 0.0, 1.0);
+  let fresnel = pow(1.0 - nv, 2.5);
+  p.alpha = mix(1.0 - F.glassClarity, 0.9, fresnel) * m.face + (1.0 - m.face) * 0.55;
+  p.roughness = min(p.roughness, 0.08);
+  p.metallic = 0.0;
+  let glint = pow(dice_noise(local * 5.0 + v * 2.5), 10.0) * F.glassSparkle;
+  p.emissive += p.base_color * glint * 9000.0;
+  p.alpha = max(p.alpha, min(1.0, glint * 2.0));`,
+  description: "Glass dice: clear bodies, bright rims, opaque marks."
+});
+const BUILTIN_FAMILIES = [SOLID, RESIN, METAL, GLASS];
+export {
+  BUILTIN_FAMILIES,
+  GLASS,
+  METAL,
+  RESIN,
+  SOLID
+};

package/dist/glyphs.d.ts

@@ -0,0 +1,29 @@
+import type { OutlineCommand } from '@aethervtt/shard-text';
+export interface DiceGlyphDef {
+    /** SVG path data (M L H V C S Q T A Z, absolute or relative), in `viewBox` units, y down. */
+    path: string;
+    /** min-x, min-y, width, height. Default 0 0 100 100. */
+    viewBox?: [number, number, number, number];
+}
+export interface DiceGlyph {
+    name: string;
+    /** The outline in glyph units: y up, the viewBox's middle at the origin, its height 1. */
+    commands: OutlineCommand[];
+    /** Width over height of the viewBox. */
+    aspect: number;
+}
+/** SVG path data to outline commands (still y down, in path units). */
+export declare function parseSvgPath(d: string, name?: string): OutlineCommand[];
+/** Maps commands through (x, y) → (a·x + b, c·y + d). */
+declare function transform(cmds: OutlineCommand[], a: number, b: number, c: number, d: number): OutlineCommand[];
+/**
+ * Registers a glyph a face layout can name. The same path again is a no-op; a different one under
+ * a taken name throws `dice/registry-conflict`.
+ */
+export declare function defineDiceGlyph(name: string, def: DiceGlyphDef): DiceGlyph;
+export declare function findDiceGlyph(name: string): DiceGlyph | undefined;
+export declare function allDiceGlyphs(): string[];
+export { transform as transformOutline };
+/** Built-in glyphs, in a 100 × 100 box. */
+export declare const BUILTIN_GLYPHS: Readonly<Record<string, DiceGlyphDef>>;
+export declare function registerBuiltinGlyphs(): void;

package/dist/glyphs.js

@@ -0,0 +1,270 @@
+import { ShardError } from "@aethervtt/shard-core";
+const glyphs = /* @__PURE__ */ new Map();
+function parseError(name, message) {
+  return new ShardError("dice/invalid-glyph", `Glyph "${name}": ${message}`, {
+    hint: "Glyph paths are SVG path data (M, L, H, V, C, S, Q, T, A, Z)."
+  });
+}
+function arcToCubics(out, x1, y1, rxIn, ryIn, angle, large, sweep, x2, y2) {
+  if (x1 === x2 && y1 === y2) return;
+  let rx = Math.abs(rxIn);
+  let ry = Math.abs(ryIn);
+  if (rx === 0 || ry === 0) {
+    out.push({ type: "L", x: x2, y: y2 });
+    return;
+  }
+  const phi = angle * Math.PI / 180;
+  const cos = Math.cos(phi);
+  const sin = Math.sin(phi);
+  const dx = (x1 - x2) / 2;
+  const dy = (y1 - y2) / 2;
+  const xp = cos * dx + sin * dy;
+  const yp = -sin * dx + cos * dy;
+  const lambda = xp * xp / (rx * rx) + yp * yp / (ry * ry);
+  if (lambda > 1) {
+    rx *= Math.sqrt(lambda);
+    ry *= Math.sqrt(lambda);
+  }
+  const num = rx * rx * ry * ry - rx * rx * yp * yp - ry * ry * xp * xp;
+  const den = rx * rx * yp * yp + ry * ry * xp * xp;
+  const k = (large === sweep ? -1 : 1) * Math.sqrt(Math.max(0, num / den));
+  const cxp = k * rx * yp / ry;
+  const cyp = -k * ry * xp / rx;
+  const cx = cos * cxp - sin * cyp + (x1 + x2) / 2;
+  const cy = sin * cxp + cos * cyp + (y1 + y2) / 2;
+  const vAngle = (ux, uy, vx, vy) => Math.atan2(ux * vy - uy * vx, ux * vx + uy * vy);
+  const t1 = vAngle(1, 0, (xp - cxp) / rx, (yp - cyp) / ry);
+  let dt = vAngle((xp - cxp) / rx, (yp - cyp) / ry, (-xp - cxp) / rx, (-yp - cyp) / ry);
+  if (!sweep && dt > 0) dt -= Math.PI * 2;
+  if (sweep && dt < 0) dt += Math.PI * 2;
+  const segments = Math.ceil(Math.abs(dt) / (Math.PI / 2));
+  const step = dt / segments;
+  const kappa = 4 / 3 * Math.tan(step / 4);
+  const point = (t) => {
+    const ex = rx * Math.cos(t);
+    const ey = ry * Math.sin(t);
+    return [cos * ex - sin * ey + cx, sin * ex + cos * ey + cy];
+  };
+  const deriv = (t) => {
+    const ex = -rx * Math.sin(t);
+    const ey = ry * Math.cos(t);
+    return [cos * ex - sin * ey, sin * ex + cos * ey];
+  };
+  for (let i = 0; i < segments; i++) {
+    const a = t1 + i * step;
+    const b = a + step;
+    const [ax, ay] = point(a);
+    const [bx, by] = point(b);
+    const [dax, day] = deriv(a);
+    const [dbx, dby] = deriv(b);
+    out.push({
+      type: "C",
+      x1: ax + kappa * dax,
+      y1: ay + kappa * day,
+      x2: bx - kappa * dbx,
+      y2: by - kappa * dby,
+      x: bx,
+      y: by
+    });
+  }
+}
+function parseSvgPath(d, name = "path") {
+  const tokens = d.match(/[a-zA-Z]|-?(?:\d+\.?\d*|\.\d+)(?:e[-+]?\d+)?/g) ?? [];
+  const out = [];
+  let i = 0;
+  let cmd = "";
+  let x = 0;
+  let y = 0;
+  let sx = 0;
+  let sy = 0;
+  let cx = 0;
+  let cy = 0;
+  let prev = "";
+  const num = () => {
+    const t = tokens[i++];
+    if (t === void 0 || /[a-zA-Z]/.test(t))
+      throw parseError(name, `expected a number after ${cmd}`);
+    return Number(t);
+  };
+  const flag = () => num() !== 0;
+  while (i < tokens.length) {
+    const t = tokens[i];
+    if (/[a-zA-Z]/.test(t)) {
+      cmd = t;
+      i++;
+    } else if (!cmd) throw parseError(name, "path data must start with a command");
+    const rel = cmd === cmd.toLowerCase();
+    const ox = rel ? x : 0;
+    const oy = rel ? y : 0;
+    switch (cmd.toUpperCase()) {
+      case "M": {
+        x = ox + num();
+        y = oy + num();
+        sx = x;
+        sy = y;
+        out.push({ type: "M", x, y });
+        cmd = rel ? "l" : "L";
+        break;
+      }
+      case "L":
+        x = ox + num();
+        y = oy + num();
+        out.push({ type: "L", x, y });
+        break;
+      case "H":
+        x = ox + num();
+        out.push({ type: "L", x, y });
+        break;
+      case "V":
+        y = oy + num();
+        out.push({ type: "L", x, y });
+        break;
+      case "C": {
+        const x1 = ox + num();
+        const y1 = oy + num();
+        cx = ox + num();
+        cy = oy + num();
+        x = ox + num();
+        y = oy + num();
+        out.push({ type: "C", x1, y1, x2: cx, y2: cy, x, y });
+        break;
+      }
+      case "S": {
+        const reflect = prev === "C" || prev === "S";
+        const x1 = reflect ? 2 * x - cx : x;
+        const y1 = reflect ? 2 * y - cy : y;
+        cx = ox + num();
+        cy = oy + num();
+        x = ox + num();
+        y = oy + num();
+        out.push({ type: "C", x1, y1, x2: cx, y2: cy, x, y });
+        break;
+      }
+      case "Q":
+        cx = ox + num();
+        cy = oy + num();
+        x = ox + num();
+        y = oy + num();
+        out.push({ type: "Q", x1: cx, y1: cy, x, y });
+        break;
+      case "T": {
+        const reflect = prev === "Q" || prev === "T";
+        cx = reflect ? 2 * x - cx : x;
+        cy = reflect ? 2 * y - cy : y;
+        x = ox + num();
+        y = oy + num();
+        out.push({ type: "Q", x1: cx, y1: cy, x, y });
+        break;
+      }
+      case "A": {
+        const rx = num();
+        const ry = num();
+        const angle = num();
+        const large = flag();
+        const sweep = flag();
+        const ex = ox + num();
+        const ey = oy + num();
+        arcToCubics(out, x, y, rx, ry, angle, large, sweep, ex, ey);
+        x = ex;
+        y = ey;
+        break;
+      }
+      case "Z":
+        out.push({ type: "Z" });
+        x = sx;
+        y = sy;
+        break;
+      default:
+        throw parseError(name, `unknown command ${cmd}`);
+    }
+    prev = cmd.toUpperCase();
+  }
+  return out;
+}
+function transform(cmds, a, b, c, d) {
+  return cmds.map((k) => {
+    switch (k.type) {
+      case "M":
+      case "L":
+        return { type: k.type, x: a * k.x + b, y: c * k.y + d };
+      case "Q":
+        return { type: "Q", x1: a * k.x1 + b, y1: c * k.y1 + d, x: a * k.x + b, y: c * k.y + d };
+      case "C":
+        return {
+          type: "C",
+          x1: a * k.x1 + b,
+          y1: c * k.y1 + d,
+          x2: a * k.x2 + b,
+          y2: c * k.y2 + d,
+          x: a * k.x + b,
+          y: c * k.y + d
+        };
+      default:
+        return k;
+    }
+  });
+}
+function defineDiceGlyph(name, def) {
+  const [vx, vy, vw, vh] = def.viewBox ?? [0, 0, 100, 100];
+  const existing = glyphs.get(name);
+  const commands = transform(
+    parseSvgPath(def.path, name),
+    1 / vh,
+    -(vx + vw / 2) / vh,
+    -1 / vh,
+    (vy + vh / 2) / vh
+  );
+  const glyph = { name, commands, aspect: vw / vh };
+  if (existing) {
+    if (JSON.stringify(existing.commands) === JSON.stringify(commands)) return existing;
+    throw new ShardError(
+      "dice/registry-conflict",
+      `Glyph "${name}" is already defined, differently`,
+      {
+        hint: "Give the new glyph its own name."
+      }
+    );
+  }
+  glyphs.set(name, glyph);
+  return glyph;
+}
+function findDiceGlyph(name) {
+  return glyphs.get(name);
+}
+function allDiceGlyphs() {
+  return [...glyphs.keys()].sort();
+}
+const star = (points, outer, inner, turn = 0) => {
+  const out = [];
+  for (let i = 0; i < points * 2; i++) {
+    const a = -Math.PI / 2 + turn + i * Math.PI / points;
+    const r = i % 2 === 0 ? outer : inner;
+    out.push(`${(50 + Math.cos(a) * r).toFixed(2)} ${(50 + Math.sin(a) * r).toFixed(2)}`);
+  }
+  return `M${out.join("L")}Z`;
+};
+const BUILTIN_GLYPHS = {
+  star: { path: star(5, 48, 20) },
+  sun: { path: star(12, 48, 33) },
+  moon: { path: "M62 6A44 44 0 1 0 94 70A36 36 0 1 1 62 6Z" },
+  heart: {
+    path: "M50 90C22 68 4 52 4 32C4 16 16 6 29 6C39 6 46 12 50 20C54 12 61 6 71 6C84 6 96 16 96 32C96 52 78 68 50 90Z"
+  },
+  crown: { path: "M6 82L12 26L32 52L50 14L68 52L88 26L94 82Z" },
+  diamond: { path: "M50 2L90 50L50 98L10 50Z" }
+};
+let registered = false;
+function registerBuiltinGlyphs() {
+  if (registered) return;
+  registered = true;
+  for (const [name, def] of Object.entries(BUILTIN_GLYPHS)) defineDiceGlyph(name, def);
+}
+export {
+  BUILTIN_GLYPHS,
+  allDiceGlyphs,
+  defineDiceGlyph,
+  findDiceGlyph,
+  parseSvgPath,
+  registerBuiltinGlyphs,
+  transform as transformOutline
+};

package/dist/golden.json

@@ -0,0 +1,17 @@
+{
+  "note": "0054's golden dice track: this roll (default tray 5.4 x 3.15, seed = its id) records this trackHash inline, in a worker, in Node and in Chromium.",
+  "roll": {
+    "id": "golden-roll",
+    "dice": [
+      { "kind": "d4", "value": 3 },
+      { "kind": "d6", "value": 5 },
+      { "kind": "d8", "value": 2 },
+      { "kind": "d10", "value": 7 },
+      { "kind": "d12", "value": 11 },
+      { "kind": "d20", "value": 20, "dropped": true },
+      { "kind": "percentile", "value": 42 },
+      { "kind": "d100", "value": 63 }
+    ]
+  },
+  "hash": "bf6ea022"
+}

package/dist/hull.d.ts

@@ -0,0 +1,32 @@
+import { type Q4, type V3 } from './math.js';
+export interface Face {
+    /** Vertex indices, counter-clockwise seen from outside. */
+    vertices: number[];
+    normal: V3;
+    center: V3;
+}
+export interface Polytope {
+    points: V3[];
+    faces: Face[];
+}
+export declare function pointsOf(flat: ArrayLike<number>): V3[];
+/**
+ * The faces of the convex hull of `points`: every plane through three points with all the others
+ * on one side, its coplanar points gathered into one polygon. Faces are sorted by normal, so the
+ * result doesn't depend on the order of `points` beyond their indices.
+ */
+export declare function convexFaces(points: readonly V3[]): Face[];
+/**
+ * The polytope whose faces are the tangent planes at unit `normals` (distance 1 from the center):
+ * a ball die's flattened cells. Each face's vertices are the corners where three planes meet,
+ * one per triangle of the points' hull.
+ */
+export declare function tangentPolytope(normals: readonly V3[]): Polytope;
+/** Whether rotating `points` by `q` gives the same set. */
+export declare function isSymmetry(points: readonly V3[], q: Q4): boolean;
+/**
+ * Every proper rotation that maps the point set onto itself, sorted by their canonical form. An
+ * anchor triple is sent to every triple of matching pair distances; the rotations that also map
+ * every other point onto the set are the group.
+ */
+export declare function symmetryGroup(points: readonly V3[]): Q4[];