rpg-engine 0.0.0-stage → 0.1.1

package/dist/dashboard/dice/celebration.js

@@ -0,0 +1,199 @@
+// The celebration of a rare face (D-281, D-282), all on the floor, since the camera far above sees no rise: for the highest face a gold halo close around the
+// die that grows and breathes once, sparks that fly out from it and twinkle out, and its numbers lit gold a moment (D-363); for the lowest the floor cracked
+// around the die, as the die is (D-410). With reduced motion, or a throw cut short, the halo or the cracks alone in their last form. Everything moves for about
+// a second, then stays until the dice go.
+import * as THREE from "three";
+import { floorCracks } from "./floor-cracks.js";
+// The halo's radius on the floor, half as wide around the die as it was, so that the eye goes to the numbers lit (D-410); how long it grows and breathes, and how
+// long a still halo takes to appear, in seconds.
+const haloRadius = 1.9;
+const growth = 0.25;
+const breathEnd = 1.2;
+const appear = 0.15;
+/** Celebrates a rare face of the die lying at this place. */
+export function celebrate(scene, at, rare, glow, pictures, showing) {
+    if (rare === "lowest") {
+        return floorCracks(scene, at, glow.lowest, glow.lights, showing.instant);
+    }
+    const blending = glow.lights ? THREE.AdditiveBlending : THREE.NormalBlending;
+    const resting = glow.highest.resting;
+    const halo = new THREE.Mesh(new THREE.PlaneGeometry(haloRadius * 2, haloRadius * 2), new THREE.MeshBasicMaterial({ map: pictures.halo, color: glow.highest.halo, transparent: true, depthWrite: false, blending, opacity: 0 }));
+    halo.rotation.x = -Math.PI / 2;
+    halo.position.set(at.x, 0.03, at.z);
+    scene.add(halo);
+    const particles = showing.instant
+        ? []
+        : flyOut(scene, at, Math.min(40, showing.particles), pictures.star, glow.highest.sparks, blending, { speed: [3.5, 6], friction: 3, life: [0.7, 1], size: [0.18, 0.32], growTo: 1, opacity: 1 });
+    let started;
+    let before;
+    return {
+        update(now) {
+            started ??= now;
+            const seconds = (now - started) / 1000;
+            const step = before === undefined ? 0 : Math.min(0.05, (now - before) / 1000);
+            before = now;
+            if (showing.instant) {
+                halo.scale.setScalar(1);
+                halo.material.opacity = resting * Math.min(1, seconds / appear);
+                return seconds < appear;
+            }
+            // It grows from half its size, then breathes once, out and back, and settles.
+            const grown = Math.min(1, seconds / growth);
+            const breath = seconds <= growth ? 0 : Math.sin(Math.min(1, (seconds - growth) / (breathEnd - growth)) * Math.PI) * 0.12;
+            halo.scale.setScalar(0.5 + 0.5 * (1 - (1 - grown) ** 3) + breath);
+            halo.material.opacity = seconds < growth ? grown : resting + (1 - resting) * Math.max(0, 1 - (seconds - growth) / (breathEnd - growth));
+            const flying = particles.filter((particle) => particle.move(step));
+            return flying.length > 0 || seconds < breathEnd;
+        },
+        dispose() {
+            scene.remove(halo);
+            halo.geometry.dispose();
+            halo.material.dispose();
+            particles.forEach((particle) => particle.dispose());
+        },
+    };
+}
+// How long the numbers of a highest face take to light, stay lit and go out, in milliseconds; and how bright they shine.
+const inkRise = 150;
+const inkHold = 450;
+const inkFall = 700;
+const inkShine = 2.2;
+// The embers off a branded face: how many at most, and their colours, from glowing orange to white-hot.
+const emberCount = 16;
+const emberColours = ["#ff7a1a", "#ffa236", "#ffd27a"];
+/** Lights a die's numbers in this colour a moment, as its highest face lands: they flare, hold and go out; lit low and still with reduced motion. */
+export function lightInk(inks, colour, instant) {
+    const started = performance.now();
+    inks.forEach((ink) => {
+        ink.emissive.set(colour);
+        ink.emissiveIntensity = instant ? inkShine / 3 : 0;
+    });
+    return {
+        update(now) {
+            if (instant) {
+                return false;
+            }
+            const elapsed = now - started;
+            const shine = elapsed < inkRise ? elapsed / inkRise : elapsed < inkRise + inkHold ? 1 : Math.max(0, 1 - (elapsed - inkRise - inkHold) / inkFall);
+            inks.forEach((ink) => {
+                ink.emissiveIntensity = inkShine * shine;
+            });
+            return shine > 0;
+        },
+        dispose() {
+            // The numbers go with their die.
+        },
+    };
+}
+/** A few embers that fly off the numbers of a die lit as a brand: small round glows, orange, flickering, gone within a second; none with reduced motion. */
+export function embers(scene, middle, pictures, showing) {
+    const count = showing.instant ? 0 : Math.min(emberCount, showing.particles);
+    const sparks = Array.from({ length: count }, () => {
+        const angle = Math.random() * Math.PI * 2;
+        const from = Math.random() * 0.55;
+        const sprite = new THREE.Sprite(new THREE.SpriteMaterial({ map: pictures.halo, color: emberColours[Math.floor(Math.random() * emberColours.length)], transparent: true, depthWrite: false, blending: THREE.AdditiveBlending, opacity: 0 }));
+        sprite.position.set(middle.x + Math.cos(angle) * from, middle.y + 0.95, middle.z + Math.sin(angle) * from);
+        scene.add(sprite);
+        return { sprite, angle, born: Math.random() * 0.45, life: 0.35 + Math.random() * 0.45, speed: 0.4 + Math.random() * 0.7, size: 0.07 + Math.random() * 0.06, phase: Math.random() * 6 };
+    });
+    let started;
+    let before;
+    return {
+        update(now) {
+            started ??= now;
+            const seconds = (now - started) / 1000;
+            const step = before === undefined ? 0 : Math.min(0.05, (now - before) / 1000);
+            before = now;
+            sparks.forEach((spark) => {
+                const age = (seconds - spark.born) / spark.life;
+                spark.sprite.visible = age > 0 && age < 1;
+                if (age > 0 && age < 1) {
+                    spark.sprite.position.x += Math.cos(spark.angle) * spark.speed * step;
+                    spark.sprite.position.z += Math.sin(spark.angle) * spark.speed * step;
+                    spark.sprite.scale.setScalar(spark.size * (1 - 0.6 * age) * (0.75 + 0.25 * Math.sin(40 * seconds + spark.phase)));
+                    spark.sprite.material.opacity = age < 0.15 ? age / 0.15 : 1 - (age - 0.15) / 0.85;
+                }
+            });
+            return sparks.some((spark) => seconds < spark.born + spark.life);
+        },
+        dispose() {
+            sparks.forEach((spark) => {
+                scene.remove(spark.sprite);
+                spark.sprite.material.dispose();
+            });
+        },
+    };
+}
+/** Makes the pictures of the celebrations, once for a stage; dispose them with it. */
+export function makePictures() {
+    return {
+        halo: picture(128, (context, size) => softSpot(context, size, [[0, 0.9], [0.35, 0.45], [1, 0]])),
+        star: picture(64, (context, size) => {
+            softSpot(context, size, [[0, 1], [0.2, 0.5], [0.5, 0]]);
+            // Four points: two thin rays across.
+            for (const [width, height] of [[size, size * 0.08], [size * 0.08, size]]) {
+                const gradient = context.createRadialGradient(size / 2, size / 2, 0, size / 2, size / 2, size / 2);
+                gradient.addColorStop(0, "rgba(255, 255, 255, 1)");
+                gradient.addColorStop(1, "rgba(255, 255, 255, 0)");
+                context.fillStyle = gradient;
+                context.fillRect((size - width) / 2, (size - height) / 2, width, height);
+            }
+        }),
+    };
+}
+/** Particles that fly out from the die along the floor, slowing, growing or twinkling, and fading over the second half of their life. */
+function flyOut(scene, at, count, map, colours, blending, kind) {
+    const [first, second] = colours.map((colour) => new THREE.Color(colour));
+    const between = (range) => range[0] + Math.random() * (range[1] - range[0]);
+    const twinkles = kind.growTo === 1;
+    return Array.from({ length: count }, () => {
+        const angle = Math.random() * Math.PI * 2;
+        const speed = between(kind.speed);
+        const velocity = new THREE.Vector2(Math.cos(angle) * speed, Math.sin(angle) * speed);
+        const life = between(kind.life);
+        const size = between(kind.size);
+        const phase = Math.random() * Math.PI * 2;
+        const sprite = new THREE.Sprite(new THREE.SpriteMaterial({ map, color: first.clone().lerp(second, Math.random()), transparent: true, depthWrite: false, blending, opacity: kind.opacity }));
+        sprite.position.set(at.x, 1, at.z);
+        sprite.scale.setScalar(size);
+        scene.add(sprite);
+        let age = 0;
+        return {
+            move(step) {
+                age += step;
+                velocity.multiplyScalar(Math.exp(-kind.friction * step));
+                sprite.position.x += velocity.x * step;
+                sprite.position.z += velocity.y * step;
+                const share = Math.min(1, age / life);
+                sprite.scale.setScalar(twinkles ? size * (0.7 + 0.3 * Math.sin(30 * age + phase)) : size * (1 + (kind.growTo - 1) * share));
+                sprite.material.opacity = kind.opacity * (share < 0.5 ? 1 : (1 - share) * 2);
+                sprite.visible = share < 1;
+                return share < 1;
+            },
+            dispose() {
+                scene.remove(sprite);
+                sprite.material.dispose();
+            },
+        };
+    });
+}
+/** A square picture drawn on a canvas, as a texture. */
+function picture(size, draw) {
+    const canvas = document.createElement("canvas");
+    canvas.width = size;
+    canvas.height = size;
+    const context = canvas.getContext("2d");
+    if (context !== null) {
+        draw(context, size);
+    }
+    const texture = new THREE.CanvasTexture(canvas);
+    texture.colorSpace = THREE.SRGBColorSpace;
+    return texture;
+}
+/** A round spot, white, as bright at each distance from its middle as the stops say. */
+function softSpot(context, size, stops) {
+    const gradient = context.createRadialGradient(size / 2, size / 2, 0, size / 2, size / 2, size / 2);
+    stops.forEach(([at, alpha]) => gradient.addColorStop(at, `rgba(255, 255, 255, ${alpha})`));
+    context.fillStyle = gradient;
+    context.fillRect(0, 0, size, size);
+}

package/dist/dashboard/dice/floor-cracks.js

@@ -0,0 +1,149 @@
+// The lowest face's mark on the floor (D-410): cracks that run out from under the die, hot at their tips, with a dull ring as it lands; they cool and stay
+// until the dice go, the floor broken as the die is. With reduced motion, or a throw cut short, they appear whole and cool.
+import * as THREE from "three";
+const tau = Math.PI * 2;
+// How many cracks run out, how long each is at most beyond its least, and its branches, in the floor's measure.
+const count = 7;
+const shortest = 0.55;
+const longer = 0.6;
+const branchShortest = 0.2;
+const branchLonger = 0.25;
+// How long the cracks take to run and to cool, and the ring to spread, in seconds; how long still cracks take to appear.
+const running = 0.35;
+const coolFrom = 0.3;
+const cooling = 0.8;
+const ringing = 0.35;
+const appear = 0.15;
+const moves = 1.2;
+/** Cracks the floor around the die lying at this place. */
+export function floorCracks(scene, at, colours, lights, instant) {
+    const { material, uniforms } = crackMaterial();
+    material.blending = lights ? THREE.AdditiveBlending : THREE.NormalBlending;
+    uniforms.colour.value.set(colours.crack);
+    uniforms.hot.value.set(colours.hot);
+    uniforms.rest.value = lights ? 0.75 : 0.9;
+    const geometry = crackGeometry();
+    const longest = Math.max(...geometry.getAttribute("along").array);
+    const cracks = onFloor(new THREE.Mesh(geometry, material), at);
+    const ringMaterial = new THREE.MeshBasicMaterial({ color: colours.ring, transparent: true, depthWrite: false, opacity: 0, blending: material.blending });
+    const ring = onFloor(new THREE.Mesh(new THREE.RingGeometry(1.0, 1.06, 96), ringMaterial), at);
+    scene.add(cracks, ring);
+    let started;
+    return {
+        update(now) {
+            started ??= now;
+            const seconds = (now - started) / 1000;
+            const shown = instant ? 3 : seconds;
+            uniforms.reach.value = longest * (1 - (1 - Math.min(1, shown / running)) ** 2);
+            uniforms.heat.value = 1 - Math.max(0, Math.min(1, (shown - coolFrom) / cooling));
+            uniforms.fade.value = instant ? Math.min(1, seconds / appear) : 1;
+            const spread = Math.min(1, shown / ringing);
+            ring.scale.setScalar(1 + 0.5 * (1 - (1 - spread) ** 3));
+            ringMaterial.opacity = instant ? 0 : 0.8 * (1 - spread);
+            return seconds < (instant ? appear : moves);
+        },
+        dispose() {
+            scene.remove(cracks, ring);
+            geometry.dispose();
+            material.dispose();
+            ring.geometry.dispose();
+            ringMaterial.dispose();
+        },
+    };
+}
+/** The cracks' material, to make its shader before a die lands. */
+export function floorCrackMaterial() {
+    return crackMaterial().material;
+}
+/** The cracks' material and its values: each point shown once the cracks have run as far, hot near their running tips and while the floor is still hot. */
+function crackMaterial() {
+    const uniforms = { reach: { value: 0 }, heat: { value: 1 }, fade: { value: 1 }, rest: { value: 1 }, colour: { value: new THREE.Color() }, hot: { value: new THREE.Color() } };
+    const material = new THREE.ShaderMaterial({
+        vertexShader: `
+attribute float along;
+varying float travelled;
+void main() {
+    travelled = along;
+    gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
+}`,
+        fragmentShader: `
+varying float travelled;
+uniform float reach;
+uniform float heat;
+uniform float fade;
+uniform float rest;
+uniform vec3 colour;
+uniform vec3 hot;
+void main() {
+    float edge = fwidth(travelled);
+    float shown = 1.0 - smoothstep(reach - edge, reach + edge, travelled);
+    float tip = 1.0 - smoothstep(0.0, 0.6, reach - travelled);
+    gl_FragColor = vec4(mix(colour, hot, clamp(max(tip * heat, heat * 0.7), 0.0, 1.0)), shown * mix(rest, 1.0, heat) * fade);
+    #include <colorspace_fragment>
+}`,
+        uniforms,
+        transparent: true,
+        depthWrite: false,
+    });
+    return { material, uniforms };
+}
+/** The cracks as strips of triangles, each point with how far along its crack it lies from the die. */
+function crackGeometry() {
+    const positions = [];
+    const along = [];
+    const indices = [];
+    for (let crack = 0; crack < count; crack++) {
+        const angle = (crack + 0.2 + Math.random() * 0.6) / count * tau;
+        const path = walk(new THREE.Vector2(Math.cos(angle), Math.sin(angle)).multiplyScalar(0.95), angle, shortest + Math.random() * longer, 0);
+        strip(path, 0.07, positions, along, indices);
+        // One branch from the middle of a crack, sometimes two.
+        for (let branch = 0; branch < 1 + Math.round(Math.random() * 0.6); branch++) {
+            const from = path[Math.floor(path.length * (0.35 + Math.random() * 0.35))] ?? path[0];
+            if (from !== undefined) {
+                const side = Math.random() < 0.5 ? -1 : 1;
+                strip(walk(from.point, from.heading + side * (0.5 + Math.random() * 0.4), branchShortest + Math.random() * branchLonger, from.along), 0.04, positions, along, indices);
+            }
+        }
+    }
+    const geometry = new THREE.BufferGeometry();
+    geometry.setAttribute("position", new THREE.Float32BufferAttribute(positions, 3));
+    geometry.setAttribute("along", new THREE.Float32BufferAttribute(along, 1));
+    geometry.setIndex(indices);
+    return geometry;
+}
+/** A jagged path on the floor: short straight steps, each turned a little from the way out. */
+function walk(start, heading, length, along) {
+    const steps = [{ point: start.clone(), heading, along }];
+    let travelled = 0;
+    while (travelled < length) {
+        const last = steps[steps.length - 1] ?? steps[0];
+        const turn = (last?.heading ?? heading) + (Math.random() - 0.5) * 0.9;
+        const step = 0.1 + Math.random() * 0.12;
+        const point = (last?.point ?? start).clone().add(new THREE.Vector2(Math.cos(turn), Math.sin(turn)).multiplyScalar(step));
+        travelled += step;
+        steps.push({ point, heading: heading * 0.6 + turn * 0.4, along: along + travelled });
+    }
+    return steps;
+}
+/** A path as a strip of triangles, as wide as given at its start and thinning to a point. */
+function strip(path, width, positions, along, indices) {
+    const first = positions.length / 3;
+    path.forEach((step, index) => {
+        const next = (path[Math.min(index + 1, path.length - 1)] ?? step).point;
+        const previous = (path[Math.max(index - 1, 0)] ?? step).point;
+        const direction = next.clone().sub(previous).normalize();
+        const half = width / 2 * (1 - index / Math.max(1, path.length - 1)) + 0.004;
+        positions.push(step.point.x - direction.y * half, step.point.y + direction.x * half, 0, step.point.x + direction.y * half, step.point.y - direction.x * half, 0);
+        along.push(step.along, step.along);
+        if (index > 0) {
+            const at = first + index * 2;
+            indices.push(at - 2, at - 1, at, at - 1, at + 1, at);
+        }
+    });
+}
+/** Lays a flat thing on the floor under the die. */
+function onFloor(object, at) {
+    object.rotation.x = -Math.PI / 2;
+    object.position.set(at.x, 0.03, at.z);
+    return object;
+}

package/dist/dashboard/dice/frost.js

@@ -0,0 +1,51 @@
+// The frost of an ice die (D-418): a picture made on the spot, rough noise of many sizes with a few bright grains, that bumps its surface and roughens its
+// shine, so that the light breaks on it as on ice.
+import * as THREE from "three";
+const size = 256;
+// The noise's cells across the picture, coarse to fine, and how much each counts.
+const octaves = [[4, 0.35], [8, 0.25], [16, 0.18], [32, 0.12], [64, 0.1]];
+// How many grains of frost, brighter, are scattered over it.
+const grains = 900;
+let made;
+/** The picture of frost, made once: grey, lighter where the surface stands up and is rougher. */
+export function frostPicture() {
+    if (made !== undefined) {
+        return made;
+    }
+    const canvas = document.createElement("canvas");
+    canvas.width = size;
+    canvas.height = size;
+    const context = canvas.getContext("2d");
+    if (context !== null) {
+        const image = context.createImageData(size, size);
+        const layers = octaves.map(([cells, weight]) => ({ cells, weight, values: Array.from({ length: cells * cells }, () => Math.random()) }));
+        for (let y = 0; y < size; y++) {
+            for (let x = 0; x < size; x++) {
+                const value = layers.reduce((sum, layer) => sum + layer.weight * noiseAt(layer.values, layer.cells, (x / size) * layer.cells, (y / size) * layer.cells), 0);
+                const at = (y * size + x) * 4;
+                image.data.set([value * 255, value * 255, value * 255, 255], at);
+            }
+        }
+        context.putImageData(image, 0, 0);
+        context.fillStyle = "rgba(255, 255, 255, 0.8)";
+        for (let grain = 0; grain < grains; grain++) {
+            context.fillRect(Math.random() * size, Math.random() * size, 1 + Math.random(), 1 + Math.random());
+        }
+    }
+    made = new THREE.CanvasTexture(canvas);
+    made.wrapS = THREE.RepeatWrapping;
+    made.wrapT = THREE.RepeatWrapping;
+    return made;
+}
+/** Smooth noise at a point of a grid of random values that wraps around, so that the picture tiles. */
+function noiseAt(values, cells, x, y) {
+    const [left, top] = [Math.floor(x), Math.floor(y)];
+    const [across, down] = [ease(x - left), ease(y - top)];
+    const value = (column, row) => values[((row % cells) * cells) + (column % cells)] ?? 0;
+    const upper = value(left, top) + (value(left + 1, top) - value(left, top)) * across;
+    const lower = value(left, top + 1) + (value(left + 1, top + 1) - value(left, top + 1)) * across;
+    return upper + (lower - upper) * down;
+}
+function ease(share) {
+    return share * share * (3 - 2 * share);
+}

package/dist/dashboard/dice/load.js

@@ -0,0 +1,66 @@
+// The dice's models (D-278): their shapes and values from dice.json, loaded once, at the first throw; their meshes from dice.glb, or dice-sharp.glb for sharp
+// edges (D-354), all made by make-dice.py, each loaded the first time it is shown.
+// Each mesh gets the coordinates a grain's picture is laid by, as wood or stone (D-352), which make-dice.py does not make.
+import { BufferAttribute, Mesh } from "three";
+import { GLTFLoader } from "three/addons/loaders/GLTFLoader.js";
+import { faceNormals } from "./models.js";
+/** Loads the dice's shapes and values, and the meshes of the edges given at once, the others when first asked. */
+export async function loadDice(edges) {
+    const data = await fetch("/assets/dice/dice.json").then(async (response) => await response.json());
+    const meshes = new Map();
+    const looks = (edges) => {
+        const file = edges === "sharp" ? "dice-sharp.glb" : "dice.glb";
+        const loaded = meshes.get(file) ?? loadMeshes(file, data);
+        meshes.set(file, loaded);
+        return loaded;
+    };
+    await looks(edges);
+    return { models: new Map(Object.entries(data)), looks };
+}
+async function loadMeshes(file, data) {
+    const scene = (await new GLTFLoader().loadAsync(`/assets/dice/${file}`)).scene;
+    for (const die of scene.children) {
+        const shape = data[die.name]?.shape;
+        die.traverse((part) => {
+            if (part instanceof Mesh) {
+                part.geometry = withGrainCoordinates(part.geometry);
+                if (shape !== undefined && part.material.name === "ink") {
+                    part.geometry = withDieFaces(part.geometry, shape);
+                }
+            }
+        });
+    }
+    return new Map(scene.children.map((child) => [child.name, child]));
+}
+// How much of a grain's picture a unit of the die covers: a die, some two units across, shows most of it.
+const grainScale = 0.4;
+/** The ink with, at each corner, the outward direction of the die's face its number is on: the face that reaches farthest towards it. A clear die shows
+ * the numbers of the faces turned away only as engravings, each number whole (D-418). */
+function withDieFaces(geometry, shape) {
+    const normals = faceNormals(shape).map((normal) => normal.map((part) => part / (Math.hypot(...normal) || 1)));
+    const position = geometry.getAttribute("position");
+    const faces = new Float32Array(position.count * 3);
+    for (let corner = 0; corner < position.count; corner++) {
+        const point = [position.getX(corner), position.getY(corner), position.getZ(corner)];
+        const reach = normals.map((normal) => normal[0] * point[0] + normal[1] * point[1] + normal[2] * point[2]);
+        faces.set(normals[reach.indexOf(Math.max(...reach))] ?? [0, 0, 1], corner * 3);
+    }
+    geometry.setAttribute("dieFace", new BufferAttribute(faces, 3));
+    return geometry;
+}
+/** The geometry with each triangle on its own corners, laid on the picture along the axis it faces most, as a block of wood or stone is cut. */
+function withGrainCoordinates(geometry) {
+    const apart = geometry.index === null ? geometry : geometry.toNonIndexed();
+    const position = apart.getAttribute("position");
+    const coordinates = new Float32Array(position.count * 2);
+    for (let corner = 0; corner < position.count; corner += 3) {
+        const points = [0, 1, 2].map((offset) => [position.getX(corner + offset), position.getY(corner + offset), position.getZ(corner + offset)]);
+        const [a, b, c] = points;
+        const normal = [(b[1] - a[1]) * (c[2] - a[2]) - (b[2] - a[2]) * (c[1] - a[1]), (b[2] - a[2]) * (c[0] - a[0]) - (b[0] - a[0]) * (c[2] - a[2]), (b[0] - a[0]) * (c[1] - a[1]) - (b[1] - a[1]) * (c[0] - a[0])].map(Math.abs);
+        const facing = normal.indexOf(Math.max(...normal));
+        const [u, v] = [0, 1, 2].filter((axis) => axis !== facing);
+        points.forEach((point, offset) => coordinates.set([point[u] * grainScale, point[v] * grainScale], (corner + offset) * 2));
+    }
+    apart.setAttribute("uv", new BufferAttribute(coordinates, 2));
+    return apart;
+}

package/dist/dashboard/dice/models.js

@@ -0,0 +1,138 @@
+// The direction that is up on the screen, on the floor: away from the camera, which looks from the near side.
+const screenUp = [0, 0, -1];
+/** The dice to throw for the dice of a roll: a d% as its tens and its units, a d10's 10 as its 0; dice with no model, as a d3 or dF, are left out. */
+export function diceToThrow(dice, kinds) {
+    return dice.flatMap((die) => {
+        // The face before a reroll, then the faces it showed after, more than one when it exploded.
+        const values = [...(die.rerolledFrom === undefined ? [] : [die.rerolledFrom]), ...(die.faces ?? [die.value])];
+        const dropped = die.dropped === true;
+        // A d% is celebrated on its tens.
+        const rare = rareFace(die);
+        const marked = rare === undefined ? {} : { rare };
+        if (die.sides === 100) {
+            return [{ kind: "d100", values: values.map((value) => Math.floor((value % 100) / 10) * 10), dropped, ...marked }, { kind: "d10", values: values.map((value) => value % 10), dropped }];
+        }
+        const kind = `d${die.sides}`;
+        return kinds.has(kind) ? [{ kind, values: die.sides === 10 ? values.map((value) => value % 10) : values, dropped, ...marked }] : [];
+    });
+}
+/** The rare face a die shows: its highest or its lowest, on a die of ten faces or more that counts; none for a dropped die, or one that exploded. */
+export function rareFace(die) {
+    if (typeof die.sides !== "number" || die.sides < 10 || die.dropped === true || (die.faces?.length ?? 1) > 1) {
+        return undefined;
+    }
+    return die.value === die.sides ? "highest" : die.value === 1 ? "lowest" : undefined;
+}
+/** The turns that leave a shape where it is: its symmetries, the identity among them. */
+export function symmetries(shape) {
+    const points = shape.vertices;
+    const size = Math.max(...points.map(length));
+    const sameLength = (one, other) => Math.abs(length(one) - length(other)) < size * 1e-4;
+    const [first] = points;
+    const second = points.find((point) => length(cross(first, point)) > size * size * 1e-2);
+    if (first === undefined || second === undefined) {
+        return [[0, 0, 0, 1]];
+    }
+    const source = frame(first, second);
+    const turns = [];
+    for (const to of points) {
+        for (const other of points) {
+            if (!sameLength(to, first) || !sameLength(other, second) || Math.abs(dot(to, other) - dot(first, second)) > size * size * 1e-4) {
+                continue;
+            }
+            const target = frame(to, other);
+            const turn = combine(target, conjugate(source));
+            if (points.every((point) => points.some((onto) => distance(rotate(turn, point), onto) < size * 1e-3))) {
+                turns.push(turn);
+            }
+        }
+    }
+    return turns;
+}
+/** The value a die shows, turned so: the one whose up direction points highest. */
+export function landedValue(model, turn) {
+    return model.values.reduce((best, value) => (rotate(turn, value.up)[1] > rotate(turn, best.up)[1] ? value : best));
+}
+/**
+ * The symmetry to show a die with, so that it shows the wanted value where it landed: of those that bring the wanted value's up direction onto the landed one's,
+ * the one that leaves its number most upright on the screen. The die is then shown as its turn, then this one.
+ */
+export function landingTurn(model, turns, turn, wanted) {
+    const landed = landedValue(model, turn);
+    const goal = model.values.find((value) => value.value === wanted);
+    if (goal === undefined) {
+        return [0, 0, 0, 1];
+    }
+    const fitting = turns.filter((symmetry) => distance(rotate(symmetry, goal.up), landed.up) < 1e-3 * length(landed.up));
+    const top = goal.top;
+    const upright = (symmetry) => (top === undefined ? 0 : dot(rotate(turn, rotate(symmetry, top)), screenUp));
+    return fitting.reduce((best, symmetry) => (best === undefined || upright(symmetry) > upright(best) ? symmetry : best), undefined) ?? [0, 0, 0, 1];
+}
+/** The outward directions of a shape's faces, by Newell's sum, right for a face whose corners are not quite in a plane. */
+export function faceNormals(shape) {
+    return shape.faces.map((face) => face.reduce((sum, corner, index) => {
+        const here = shape.vertices[corner] ?? [0, 0, 0];
+        const next = shape.vertices[face[(index + 1) % face.length] ?? 0] ?? [0, 0, 0];
+        return [sum[0] + (here[1] - next[1]) * (here[2] + next[2]), sum[1] + (here[2] - next[2]) * (here[0] + next[0]), sum[2] + (here[0] - next[0]) * (here[1] + next[1])];
+    }, [0, 0, 0]));
+}
+/** A vector turned. */
+export function rotate(turn, vector) {
+    const [x, y, z, w] = turn;
+    const [vx, vy, vz] = vector;
+    const tx = 2 * (y * vz - z * vy);
+    const ty = 2 * (z * vx - x * vz);
+    const tz = 2 * (x * vy - y * vx);
+    return [vx + w * tx + (y * tz - z * ty), vy + w * ty + (z * tx - x * tz), vz + w * tz + (x * ty - y * tx)];
+}
+/** The turn `second`, then `first`. */
+export function combine(first, second) {
+    const [ax, ay, az, aw] = first;
+    const [bx, by, bz, bw] = second;
+    return [aw * bx + ax * bw + ay * bz - az * by, aw * by - ax * bz + ay * bw + az * bx, aw * bz + ax * by - ay * bx + az * bw, aw * bw - ax * bx - ay * by - az * bz];
+}
+function conjugate(turn) {
+    return [-turn[0], -turn[1], -turn[2], turn[3]];
+}
+/** The turn that brings the axes onto the frame of two directions: x along the first, y toward the second, z across them. */
+function frame(first, second) {
+    const x = scale(first, 1 / length(first));
+    const along = dot(second, x);
+    const sideways = [second[0] - x[0] * along, second[1] - x[1] * along, second[2] - x[2] * along];
+    const y = scale(sideways, 1 / length(sideways));
+    const z = cross(x, y);
+    return fromAxes(x, y, z);
+}
+/** A turn from the directions the axes go to: the columns of its matrix. */
+function fromAxes(x, y, z) {
+    const trace = x[0] + y[1] + z[2];
+    if (trace > 0) {
+        const s = 0.5 / Math.sqrt(trace + 1);
+        return [(y[2] - z[1]) * s, (z[0] - x[2]) * s, (x[1] - y[0]) * s, 0.25 / s];
+    }
+    if (x[0] > y[1] && x[0] > z[2]) {
+        const s = 2 * Math.sqrt(1 + x[0] - y[1] - z[2]);
+        return [0.25 * s, (y[0] + x[1]) / s, (z[0] + x[2]) / s, (y[2] - z[1]) / s];
+    }
+    if (y[1] > z[2]) {
+        const s = 2 * Math.sqrt(1 + y[1] - x[0] - z[2]);
+        return [(y[0] + x[1]) / s, 0.25 * s, (z[1] + y[2]) / s, (z[0] - x[2]) / s];
+    }
+    const s = 2 * Math.sqrt(1 + z[2] - x[0] - y[1]);
+    return [(z[0] + x[2]) / s, (z[1] + y[2]) / s, 0.25 * s, (x[1] - y[0]) / s];
+}
+function dot(first, second) {
+    return first[0] * second[0] + first[1] * second[1] + first[2] * second[2];
+}
+function cross(first, second) {
+    return [first[1] * second[2] - first[2] * second[1], first[2] * second[0] - first[0] * second[2], first[0] * second[1] - first[1] * second[0]];
+}
+function length(vector) {
+    return Math.hypot(...vector);
+}
+function scale(vector, by) {
+    return [vector[0] * by, vector[1] * by, vector[2] * by];
+}
+function distance(first, second) {
+    return Math.hypot(first[0] - second[0], first[1] - second[1], first[2] - second[2]);
+}

package/dist/dashboard/dice/pool.js

@@ -0,0 +1,49 @@
+// The dice of the tray, by their sides, from the top of its column: 100 is the d%, thrown as its tens and its units; the d20, the most thrown, is the nearest
+// to the button.
+export const trayDice = [100, 4, 6, 8, 10, 12, 20];
+/** Whether the tray can throw these dice by itself: kinds it has, all counting or with the highest or the lowest one alone kept, as one of two dropped, and a
+ * number; never a reroll, an explosion or more dice kept or dropped, which the engine alone makes, so that a check asking one keeps its button by hand (D-339,
+ * D-380, D-397). */
+export function trayThrows(dice) {
+    const terms = dice.toLowerCase().replace(/\s+/g, "").replaceAll("−", "-").match(/[+-]?[^+-]+/g) ?? [];
+    return terms.some((term) => term.includes("d")) && terms.every((term) => {
+        const die = /^\+?(\d*)d(\d+|%)(k[hl]1?|d[hl]1?)?$/.exec(term);
+        const kept = die?.[3] === undefined || die[3].startsWith("k") || die[1] === "2";
+        return /^[+-]?\d+$/.test(term) || (die !== null && kept && trayDice.includes(die[2] === "%" ? 100 : Number(die[2])));
+    });
+}
+/** A die's name, as the tray shows it: d20, and d% for the percentile. */
+export function dieName(sides) {
+    return sides === 100 ? "d%" : `d${sides}`;
+}
+/** The kinds' choices of which count, for those of two dice or more alone, but the d%. */
+export function keptOf(pool, keeps) {
+    return Object.fromEntries(Object.entries(keeps).filter(([sides, keep]) => keep !== undefined && Number(sides) !== 100 && pool.filter((chosen) => chosen === Number(sides)).length >= 2));
+}
+/** The dice chosen as a notation, the biggest first, with which count and the modifier: 2d20kh1+1d6+3, 4d6dl1. */
+export function notation(pool, modifier, keeps) {
+    const kinds = [...new Set(pool)].sort((first, second) => second - first);
+    const dice = kinds.map((sides) => {
+        const count = pool.filter((chosen) => chosen === sides).length;
+        const keep = keeps[sides];
+        const kept = keep === undefined ? "" : keep === "highest" ? "kh1" : "kl1";
+        return `${count}${dieName(sides)}${kept}`;
+    }).join("+");
+    return modifier === 0 ? dice : `${dice}${modifier > 0 ? "+" : "-"}${Math.abs(modifier)}`;
+}
+/** The dice thrown with the one that does not count dropped, for each kind whose highest or lowest count: the lowest or the highest of its faces. */
+export function withDropped(dice, keeps) {
+    const dropped = new Set(Object.entries(keeps).flatMap(([sides, keep]) => {
+        const ofKind = dice.map((die, index) => ({ die, index })).filter(({ die }) => die.sides === Number(sides));
+        const sorted = ofKind.toSorted((first, second) => (keep === "highest" ? first.die.value - second.die.value : second.die.value - first.die.value));
+        // All but the last, the highest for the highest kept, the lowest for the lowest.
+        return sorted.length < 2 ? [] : sorted.slice(0, -1).map(({ index }) => index);
+    }));
+    return dice.map((die, index) => (dropped.has(index) ? { ...die, dropped: true } : die));
+}
+/** The dice thrown as the chat writes them: each kind's faces in brackets, a dropped one in parentheses, the biggest first, then the modifier. */
+export function diceText(dice, modifier) {
+    const kinds = [...new Set(dice.map((die) => die.sides))].sort((first, second) => Number(second) - Number(first));
+    const faces = kinds.map((sides) => `[${dice.filter((die) => die.sides === sides).map((die) => (die.dropped === true ? `(${die.value})` : String(die.value))).join(", ")}]`).join(" + ");
+    return modifier === 0 ? faces : `${faces} ${modifier > 0 ? "+" : "−"} ${Math.abs(modifier)}`;
+}