@aethervtt/shard-dice 0.0.0-stage → 0.1.0

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[];

package/dist/hull.js

@@ -0,0 +1,154 @@
+import {
+  add,
+  cross,
+  dot,
+  EPSILON,
+  length,
+  normalize,
+  qConj,
+  qFromBasis,
+  qKey,
+  qMul,
+  qRotate,
+  round,
+  scale,
+  stableTangent,
+  sub
+} from "./math.js";
+function pointsOf(flat) {
+  const out = [];
+  for (let i = 0; i + 2 < flat.length; i += 3) out.push([flat[i], flat[i + 1], flat[i + 2]]);
+  return out;
+}
+const compareVector = (a, b) => a[1] - b[1] || a[2] - b[2] || a[0] - b[0];
+function convexFaces(points) {
+  const faces = /* @__PURE__ */ new Map();
+  const n = points.length;
+  for (let a = 0; a < n - 2; a++) {
+    for (let b = a + 1; b < n - 1; b++) {
+      for (let c = b + 1; c < n; c++) {
+        let normal = cross(sub(points[b], points[a]), sub(points[c], points[a]));
+        if (dot(normal, normal) < 1e-10) continue;
+        normal = normalize(normal);
+        const d = dot(normal, points[a]);
+        let positive = false;
+        let negative = false;
+        for (const p of points) {
+          const side = dot(normal, p) - d;
+          if (side > EPSILON) positive = true;
+          else if (side < -EPSILON) negative = true;
+          if (positive && negative) break;
+        }
+        if (positive && negative) continue;
+        if (positive) normal = scale(normal, -1);
+        const plane = dot(normal, points[a]);
+        const members = [];
+        for (let i = 0; i < n; i++) {
+          if (Math.abs(dot(normal, points[i]) - plane) < EPSILON * 3) members.push(i);
+        }
+        const key = members.join(":");
+        if (faces.has(key)) continue;
+        let center = [0, 0, 0];
+        for (const i of members) center = add(center, points[i]);
+        center = scale(center, 1 / members.length);
+        faces.set(key, { vertices: orderAround(members, points, normal, center), normal, center });
+      }
+    }
+  }
+  return [...faces.values()].sort((l, r) => compareVector(l.normal, r.normal));
+}
+function orderAround(members, points, normal, center) {
+  const t = stableTangent(normal);
+  const b = cross(normal, t);
+  const angle = (i) => {
+    const d = sub(points[i], center);
+    return Math.atan2(dot(d, b), dot(d, t));
+  };
+  return [...members].sort((l, r) => angle(l) - angle(r));
+}
+function tangentPolytope(normals) {
+  const triangles = convexFaces(normals);
+  const points = [];
+  const cells = normals.map(() => []);
+  for (const tri of triangles) {
+    const [a, b, c] = tri.vertices;
+    const na = normals[a];
+    const nb = normals[b];
+    const nc = normals[c];
+    const det = dot(na, cross(nb, nc));
+    const p = scale(add(add(cross(nb, nc), cross(nc, na)), cross(na, nb)), 1 / det);
+    const index = points.push(p) - 1;
+    for (const i of tri.vertices) cells[i].push(index);
+  }
+  const faces = normals.map((normal, i) => {
+    let center = [0, 0, 0];
+    for (const v of cells[i]) center = add(center, points[v]);
+    center = scale(center, 1 / cells[i].length);
+    return { vertices: orderAround(cells[i], points, normal, center), normal, center };
+  });
+  return { points, faces };
+}
+function hasPoint(points, p) {
+  for (const q of points) {
+    const dx = q[0] - p[0];
+    const dy = q[1] - p[1];
+    const dz = q[2] - p[2];
+    if (dx * dx + dy * dy + dz * dz < EPSILON * EPSILON * 9) return true;
+  }
+  return false;
+}
+function isSymmetry(points, q) {
+  for (const p of points) if (!hasPoint(points, qRotate(q, p))) return false;
+  return true;
+}
+function basisOf(a, b, c) {
+  const x = normalize(sub(b, a));
+  const ac = sub(c, a);
+  const yRaw = sub(ac, scale(x, dot(ac, x)));
+  if (length(yRaw) < 1e-6) return void 0;
+  const y = normalize(yRaw);
+  return [x, y, cross(x, y)];
+}
+function symmetryGroup(points) {
+  const n = points.length;
+  let anchor;
+  for (let b = 1; b < n && !anchor; b++) {
+    for (let c = b + 1; c < n && !anchor; c++) {
+      if (length(cross(sub(points[b], points[0]), sub(points[c], points[0]))) > 1e-4)
+        anchor = [0, b, c];
+    }
+  }
+  if (!anchor) return [];
+  const [p0, p1, p2] = anchor.map((i) => points[i]);
+  const d01 = length(sub(p1, p0));
+  const d02 = length(sub(p2, p0));
+  const d12 = length(sub(p2, p1));
+  const source = basisOf(p0, p1, p2);
+  const fromSource = qConj(qFromBasis(...source));
+  const found = /* @__PURE__ */ new Map();
+  for (let a = 0; a < n; a++) {
+    for (let b = 0; b < n; b++) {
+      if (b === a || Math.abs(length(sub(points[b], points[a])) - d01) > EPSILON * 10) continue;
+      for (let c = 0; c < n; c++) {
+        if (c === a || c === b) continue;
+        if (Math.abs(length(sub(points[c], points[a])) - d02) > EPSILON * 10) continue;
+        if (Math.abs(length(sub(points[c], points[b])) - d12) > EPSILON * 10) continue;
+        const target = basisOf(points[a], points[b], points[c]);
+        if (!target) continue;
+        const q = qMul(qFromBasis(...target), fromSource);
+        const moved = qRotate(q, p0);
+        if (length(sub(moved, points[a])) > EPSILON * 10) continue;
+        if (!isSymmetry(points, q)) continue;
+        found.set(qKey(q), q.map(round));
+      }
+    }
+  }
+  return [...found.entries()].sort(([l], [r]) => l.localeCompare(r)).map(([, q]) => q);
+}
+export {
+  convexFaces,
+  isSymmetry,
+  pointsOf,
+  symmetryGroup,
+  tangentPolytope
+};

package/dist/index.d.ts

@@ -0,0 +1,31 @@
+export { allDiceAttachments, DICE_BUDGETS, type DiceAttachmentContext, type DiceAttachmentDef, type DiceSceneContext, defineDiceAttachment, findDiceAttachment, MAX_ATTACHMENTS, setDiceBudgets, } from './attachments.js';
+export { BUILTIN_DICE, D4, D6, D8, D10, D10_TENS, D12, D20, D100_BALL, DIE_KINDS, type DieKind, KIND_DEFINITIONS, kindSides, percentileValues, registerBuiltinDice, } from './builtins.js';
+export { CELL_PAD, type CellLayout, cellLayout, type FaceCell, MARK_RANGE } from './cells.js';
+export { DiceDie, DiceRollRequest } from './components.js';
+export { allDice, type DieDefinition, type DieGeometry, defineDie, dieGeometry, dieHash, findDie, frameOf, labelOf, physicalScale, requireDie, type ValueFrame, validateDieDefinition, } from './definition.js';
+export { DieDefinitionAsset, type DieDefinitionAssetValue, dieDefinitionOf, } from './definition-asset.js';
+export { type DiceCondition, type DiceEffect, DiceEffectRecipe, type DiceEffectRecipeValue, diceEffectRecipe, type MatchedRecipe, matchRecipes, RECIPE_LIMITS, recipeProblems, } from './effects.js';
+export { allDiceEntrances, type DiceEntranceContext, type DiceEntranceDef, defineDiceEntrance, findDiceEntrance, MAX_ENTRANCES, } from './entrances.js';
+export { BUILTIN_FAMILIES, GLASS, METAL, RESIN, SOLID } from './families.js';
+export { allDiceGlyphs, BUILTIN_GLYPHS, type DiceGlyph, type DiceGlyphDef, defineDiceGlyph, findDiceGlyph, parseSvgPath, registerBuiltinGlyphs, } from './glyphs.js';
+export { landingCorrection, markAngle, naturalValue, restingHeight, restRotation, topAlignment, } from './landing.js';
+export { ambiguousLabel, defaultLayoutFor, FaceLayout, type FaceLayoutValue, type FaceMark, layoutProblems, NUMBERS_LAYOUT, PIPS_LAYOUT, type ResolvedMark, resolveMark, } from './layout.js';
+export { type BakeMarksOptions, bakeMarks, clearMarkCache, MARK_MARGIN, type MarkAtlas, markAtlasKey, markPlacements, type Placement as MarkPlacement, } from './marks.js';
+export { allDiceFamilies, DICE_FIELDS, DICE_SHADERS, type DiceFamily, type DiceFamilyOptions, defineDiceFamily, findDiceFamily, isDiceMaterial, } from './material.js';
+export { dieMesh, floorQuad } from './mesh.js';
+export { diceMethods } from './methods.js';
+export { NUMERAL_HEIGHT } from './numerals.js';
+export { type DicePluginOptions, dicePlugin, TOP_DOWN } from './plugin.js';
+export { type DiceThumbnail, type DiceThumbnailOptions, renderDiceThumbnail } from './preview.js';
+export { type DiceQuality, type DiceQualityChoice, resolveDiceQuality } from './quality.js';
+export { type DiceLookKey, type DiceResourceEntry, DiceResources, RELEASE_AFTER_MS, } from './resources.js';
+export { type DiceQualityPreference, type DiceRoll, type DiceRollDie, expandRoll, type PhysicalDie, presentationScale, rollTrackRequest, viewportTray, } from './roll.js';
+export { BALL_DAMPING, DICE_CLEANUP_STEP, DICE_GROUPS, DICE_SETTLE_RULE, type DiceSettleParams, type DiceTray, diceSettle, outsideTray, restingFlat, } from './settle.js';
+export { BUILTIN_SKINS, DICE_SKINS, DiceSkin, type DiceSkinValue, type DiceSkinVariant, diceSkin, IMPACT_SOUNDS, type ImpactSound, MAX_SKIN_EFFECTS, type SkinContext, skinVariant, validateDiceSkin, } from './skin.js';
+export { ACCENT_CUES, type AccentCue, accentSamples, DiceSoundBank, IMPACT_LAYERS, IMPACT_VARIATIONS, impactLayer, impactSamples, impactStrength, wavBytes, } from './sound.js';
+export { studioEnvironment } from './studio.js';
+export { ANIMATED_DEMAND, type DiceOutcome, type DicePhase, type DicePlayOptions, DiceTable, type DiceTableOptions, DiceTableState, ENTRANCE_DEMAND, ENTRANCE_WAIT_MS, PRESENTATION_DEMAND, PREVIEW_TRAY, } from './table.js';
+export { DICE_CONTACTS, DICE_GRAVITY, DICE_MAX_STEPS, DICE_STEP, type DiceTrackDie, type DiceTrackRequest, diceSettleParams, diceTrackScene, LAUNCH_EDGES, type LaunchEdge, laneLayout, launchEdgeOf, MAX_DICE, PLACED_DROP_STEPS, placeDie, placedFrom, placementSpots, seedOf, type UnlandedReason, unlandedDice, } from './track.js';
+export { DiceTray as DiceTrayMaterial, TRAY_SHADERS } from './tray.js';
+export { type DiceVariantEntry, diceVariants } from './variants.js';
+export { type DiceWindow, spawnDiceWindow } from './windows.js';