@aethervtt/shard-dice 0.0.0-stage → 0.2.0

package/dist/layout.d.ts

@@ -0,0 +1,75 @@
+import { type AssetRef, type FieldValue, type Infer, ShardError } from '@aethervtt/shard-core';
+import { type DieDefinition } from './definition.js';
+export declare const FaceMarkSchema: import("@aethervtt/shard-core").FieldType<import("@aethervtt/shard-core").InferFields<{
+    kind: import("@aethervtt/shard-core").FieldType<"blank" | "glyph" | "pips" | "text", "u8">;
+    text: import("@aethervtt/shard-core").FieldType<string, "object">;
+    font: import("@aethervtt/shard-core").FieldType<AssetRef<"Font"> | null, "object">;
+    size: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    weight: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    underline: import("@aethervtt/shard-core").FieldType<"always" | "auto" | "never", "u8">;
+    count: import("@aethervtt/shard-core").FieldType<number, "u8">;
+    glyph: import("@aethervtt/shard-core").FieldType<string, "object">;
+    rotation: import("@aethervtt/shard-core").FieldType<number, "f32">;
+}>, "object">;
+/** A face layout: `data/**\/*.dice-layout.json`. */
+export declare const FaceLayout: import("@aethervtt/shard-assets").DataType<{
+    readonly version: import("@aethervtt/shard-core").FieldType<number, "u8">;
+    readonly id: import("@aethervtt/shard-core").FieldType<string, "object">;
+    readonly default: import("@aethervtt/shard-core").FieldType<import("@aethervtt/shard-core").InferFields<{
+        kind: import("@aethervtt/shard-core").FieldType<"blank" | "glyph" | "pips" | "text", "u8">;
+        text: import("@aethervtt/shard-core").FieldType<string, "object">;
+        font: import("@aethervtt/shard-core").FieldType<AssetRef<"Font"> | null, "object">;
+        size: import("@aethervtt/shard-core").FieldType<number, "f32">;
+        weight: import("@aethervtt/shard-core").FieldType<number, "f32">;
+        underline: import("@aethervtt/shard-core").FieldType<"always" | "auto" | "never", "u8">;
+        count: import("@aethervtt/shard-core").FieldType<number, "u8">;
+        glyph: import("@aethervtt/shard-core").FieldType<string, "object">;
+        rotation: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    }>, "object">;
+    readonly overrides: import("@aethervtt/shard-core").FieldType<import("@aethervtt/shard-core").InferFields<{
+        value: import("@aethervtt/shard-core").FieldType<number, "u16">;
+        mark: import("@aethervtt/shard-core").FieldType<import("@aethervtt/shard-core").InferFields<{
+            kind: import("@aethervtt/shard-core").FieldType<"blank" | "glyph" | "pips" | "text", "u8">;
+            text: import("@aethervtt/shard-core").FieldType<string, "object">;
+            font: import("@aethervtt/shard-core").FieldType<AssetRef<"Font"> | null, "object">;
+            size: import("@aethervtt/shard-core").FieldType<number, "f32">;
+            weight: import("@aethervtt/shard-core").FieldType<number, "f32">;
+            underline: import("@aethervtt/shard-core").FieldType<"always" | "auto" | "never", "u8">;
+            count: import("@aethervtt/shard-core").FieldType<number, "u8">;
+            glyph: import("@aethervtt/shard-core").FieldType<string, "object">;
+            rotation: import("@aethervtt/shard-core").FieldType<number, "f32">;
+        }>, "object">;
+    }>[], "object">;
+}, "dice/FaceLayout">;
+export type FaceLayoutValue = Infer<typeof FaceLayout>;
+export type FaceMark = FieldValue<typeof FaceMarkSchema>;
+/** A mark ready to draw: text resolved to characters, pips to a count. */
+export interface ResolvedMark {
+    kind: 'text' | 'pips' | 'glyph' | 'blank';
+    text: string;
+    font: AssetRef | null;
+    size: number;
+    weight: number;
+    underline: boolean;
+    count: number;
+    glyph: string;
+    /** Radians, clockwise. */
+    rotation: number;
+}
+/** Numbers on every face: each value's label, in the built-in numerals. */
+export declare const NUMBERS_LAYOUT: FaceLayoutValue;
+/** Pips on every face (up to 9). */
+export declare const PIPS_LAYOUT: FaceLayoutValue;
+/** The layout a die uses when its skin names none: pips on a d6, numbers everywhere else. */
+export declare function defaultLayoutFor(def: DieDefinition): FaceLayoutValue;
+/** Whether a label reads as another label of the die when the die is turned around. */
+export declare function ambiguousLabel(def: DieDefinition, label: string): boolean;
+/** The mark a value prints under a layout. */
+export declare function resolveMark(layout: FaceLayoutValue, def: DieDefinition, value: number): ResolvedMark;
+/**
+ * What a layout can't show on a die, by value: pips past 9, a glyph that isn't registered, text a
+ * font can't draw. Paths point into the layout.
+ */
+export declare function layoutProblems(layout: FaceLayoutValue, def: DieDefinition, canDraw?: (text: string, font: AssetRef | null) => boolean): ShardError[];
+/** The built-in numerals draw digits only. */
+export declare function builtinCanDraw(text: string, font: AssetRef | null): boolean;

package/dist/layout.js

@@ -0,0 +1,137 @@
+import { defineDataType } from "@aethervtt/shard-assets";
+import { ShardError, t } from "@aethervtt/shard-core";
+import { labelOf } from "./definition.js";
+import { findDiceGlyph } from "./glyphs.js";
+const MARK_FIELDS = {
+  kind: t.enum(["text", "pips", "glyph", "blank"], {
+    description: "text prints characters (the value's label unless `text` says otherwise); pips draws dots; glyph draws a registered vector path; blank prints nothing."
+  }),
+  text: t.string({ description: "Text marks: what to print. Empty prints the value's label." }),
+  font: t.handle("Font", {
+    description: "Text marks: the font's outlines. Null uses the built-in numerals (digits only)."
+  }),
+  size: t.f32({ default: 1, min: 0.2, max: 2, description: "Scales the die's mark size." }),
+  weight: t.f32({
+    default: 0.035,
+    min: -0.05,
+    max: 0.12,
+    unit: "em",
+    description: "Thickens (or thins) text and glyph strokes, from the distance field."
+  }),
+  underline: t.enum(["auto", "always", "never"], {
+    description: "auto underlines a label that reads as another of the die\u2019s labels upside down (6 and 9, 16 and 91)."
+  }),
+  count: t.u8({ max: 9, description: "Pips: how many. 0 draws the value." }),
+  glyph: t.string({
+    description: "Glyph marks: the name of a registered glyph (defineDiceGlyph)."
+  }),
+  rotation: t.f32({ unit: "deg", description: "Turns the mark on its face, clockwise." })
+};
+const FaceMarkSchema = t.struct(MARK_FIELDS, { description: "One mark on a face." });
+const FaceLayout = defineDataType(
+  "dice/FaceLayout",
+  {
+    version: t.u8({ default: 1, min: 1, max: 1, description: "Format version: 1." }),
+    id: t.string({ description: "A name for tools and errors." }),
+    default: FaceMarkSchema,
+    overrides: t.list(
+      t.struct({
+        value: t.u16({ min: 1, max: 100, description: "The value (not the face) it overrides." }),
+        mark: FaceMarkSchema
+      }),
+      { description: "Marks for particular values, by value." }
+    )
+  },
+  {
+    extension: "dice-layout",
+    description: "What each value of a die prints: a default mark, and overrides by value."
+  }
+);
+const mark = (m) => ({
+  ...FaceMarkSchema.defaultValue(),
+  ...m
+});
+const NUMBERS_LAYOUT = {
+  version: 1,
+  id: "numbers",
+  default: mark({ kind: "text" }),
+  overrides: []
+};
+const PIPS_LAYOUT = {
+  version: 1,
+  id: "pips",
+  default: mark({ kind: "pips" }),
+  overrides: []
+};
+function defaultLayoutFor(def) {
+  return def.id === "d6" ? PIPS_LAYOUT : NUMBERS_LAYOUT;
+}
+const TURNED = { "0": "0", "1": "1", "6": "9", "8": "8", "9": "6" };
+function upsideDown(label) {
+  let out = "";
+  for (let i = label.length - 1; i >= 0; i--) {
+    const c = TURNED[label[i]];
+    if (c === void 0) return void 0;
+    out += c;
+  }
+  return out;
+}
+function ambiguousLabel(def, label) {
+  const turned = upsideDown(label);
+  if (turned === void 0 || turned === label) return false;
+  for (let v = 1; v <= def.sides; v++) if (labelOf(def, v) === turned) return true;
+  return false;
+}
+function resolveMark(layout, def, value) {
+  const m = layout.overrides.find((o) => o.value === value)?.mark ?? layout.default;
+  const text = m.kind === "text" ? m.text || labelOf(def, value) : "";
+  return {
+    kind: m.kind,
+    text,
+    font: m.font,
+    size: m.size,
+    weight: m.weight,
+    underline: m.kind === "text" && (m.underline === "always" || m.underline === "auto" && ambiguousLabel(def, text)),
+    count: m.kind === "pips" ? m.count || value : 0,
+    glyph: m.glyph,
+    rotation: m.rotation * Math.PI / 180
+  };
+}
+function layoutProblems(layout, def, canDraw = builtinCanDraw) {
+  const out = [];
+  for (let value = 1; value <= def.sides; value++) {
+    const index = layout.overrides.findIndex((o) => o.value === value);
+    const path = index >= 0 ? `/overrides/${index}/mark` : "/default";
+    const m = resolveMark(layout, def, value);
+    let problem;
+    if (m.kind === "pips" && (m.count < 1 || m.count > 9)) problem = `${m.count} pips (1 to 9 draw)`;
+    else if (m.kind === "glyph" && !findDiceGlyph(m.glyph))
+      problem = m.glyph ? `glyph "${m.glyph}", which isn't registered` : "a glyph with no name";
+    else if (m.kind === "text" && !canDraw(m.text, m.font))
+      problem = `"${m.text}", which the font can't draw`;
+    if (problem) {
+      out.push(
+        new ShardError(
+          "dice/layout-missing-value",
+          `Layout "${layout.id}" can't show ${value} on a ${def.id}: it asks for ${problem}`,
+          { path, hint: `Give value ${value} a mark the die can draw, in overrides.` }
+        )
+      );
+    }
+  }
+  return out;
+}
+function builtinCanDraw(text, font) {
+  return font !== null || /^[0-9]+$/.test(text);
+}
+export {
+  FaceLayout,
+  FaceMarkSchema,
+  NUMBERS_LAYOUT,
+  PIPS_LAYOUT,
+  ambiguousLabel,
+  builtinCanDraw,
+  defaultLayoutFor,
+  layoutProblems,
+  resolveMark
+};

package/dist/marks.d.ts

@@ -0,0 +1,54 @@
+import type { AssetRef } from '@aethervtt/shard-core';
+import { type Font } from '@aethervtt/shard-text';
+import { type CellLayout } from './cells.js';
+import type { DieGeometry } from './definition.js';
+import { type FaceLayoutValue, type ResolvedMark } from './layout.js';
+export interface MarkAtlas {
+    /** What it was baked from: definition hash, layout, fonts. */
+    key: string;
+    width: number;
+    height: number;
+    layout: CellLayout;
+    /** Distance range in pixels. */
+    range: number;
+    pixels: Uint8Array;
+    /** Values drawn, per face (d4 faces carry three). */
+    values: number[][];
+    /** How long the bake took, ms. */
+    ms: number;
+}
+export interface BakeMarksOptions {
+    /** Loaded fonts for text marks that name one. */
+    font?: (ref: AssetRef) => Font | undefined;
+}
+export interface Placement {
+    mark: ResolvedMark;
+    /** Center in cell pixels (y up). */
+    x: number;
+    y: number;
+    /** Mark height in pixels. */
+    height: number;
+    /** Up direction angle, radians counter-clockwise from +y. */
+    angle: number;
+    /** The flat area the mark keeps inside, in cell pixels: [x0, y0, x1, y1, …]. */
+    region: number[];
+    /** The largest height the mark's ink can take there, keeping the margin clear. */
+    fit: number;
+}
+/** The share of a region's inscribed radius a mark's ink keeps clear of its edges. */
+export declare const MARK_MARGIN = 0.12;
+/**
+ * Every mark of a die under a layout, where the bake draws it: at the definition's height, shrunk
+ * (one scale for the whole die, so its numbers match) until every mark's ink fits its region.
+ */
+export declare function markPlacements(g: DieGeometry, layout: FaceLayoutValue, options?: BakeMarksOptions): Placement[][];
+/** The cache key of a bake: the definition's hash, the layout's content, and its fonts' guids. */
+export declare function markAtlasKey(g: DieGeometry, layout: FaceLayoutValue): string;
+/**
+ * Bakes a die's marks under a layout into one MSDF atlas: glyph outlines from the font (or the
+ * built-in numerals), pips as analytic circles, glyphs from their registered paths. Cached by
+ * (definition, layout).
+ */
+export declare function bakeMarks(g: DieGeometry, layout: FaceLayoutValue, options?: BakeMarksOptions): MarkAtlas;
+/** Drops every cached bake (tests, or a host changing fonts under the same refs). */
+export declare function clearMarkCache(): void;