@johnmorrisdotca/dougu-sports 0.4.1 → 0.5.1

package/dist/emblems/ball/ball.soccer.store.js

@@ -0,0 +1,176 @@
+// Generic patterns of the kind a sports shop has on its wall, each in three colourways: stars, hexagon outlines, flames, chevrons, a two-tone swirl and a metallic glossy finish. Every pattern is our own
+// drawing on a construction of the family (the 32 panels, or gores that run from pole to pole), and the balls are the size of an 11-a-side ball (IFAB Law 2). No logo, no brand, no team.
+import { defineBall } from "./ball.engine.js";
+import { mix } from "./ball.core.js";
+import { frameAt, place, spiral, star, tongue, turned } from "./ball.decal.js";
+import { shrink, truncatedIcosahedron } from "./ball.polyhedra.js";
+import { gorePoint, gores } from "./ball.tilings.js";
+import { SOCCER_SIZE } from "./ball.soccer.size.js";
+const VIEW = { yaw: 30, pitch: 24, roll: 8 };
+const GLOSS = { gloss: 0.8, shade: "#2a3450", grain: { f: 1.1, a: 0.16 } };
+const lit = (s, seams, width = 0.45) => s.strokes(seams, "#fff", width, { deco: true, opacity: 0.45, dx: 0.3, dy: 0.35 });
+const ball = (id, en, ja, spec) => defineBall({ id, en, ja, size: SOCCER_SIZE, spec });
+// Stars: a five-pointed star on every panel, on a white or a night-blue ground.
+const stars = (w) => ({
+    view: VIEW,
+    base: w.main,
+    ground: w.ground,
+    mat: GLOSS,
+    draw(s, base, accent) {
+        const t = truncatedIcosahedron();
+        const dark = accent ?? w.dark;
+        let out = "";
+        for (const p of t.pentagons)
+            out += s.panel(p, dark, { ink: true });
+        const big = star(5, 0.2, 0.09);
+        const small = star(5, 0.12, 0.054);
+        out += s.panels([
+            ...t.hexagonCentres.map((c, i) => place(frameAt(c, t.hexagonPentagonSides[i][0]), turned(big, 0.35))),
+            ...t.pentagonCentres.map((c, i) => place(frameAt(c, t.pentagons[i][0]), small)),
+        ], base, { n: 1 });
+        out += s.strokes(t.edges, mix(dark, 0.2), 1.05);
+        return out + lit(s, t.edges);
+    },
+});
+// Hexagon outlines: two outlines inside each hexagon, one inside the other, like a honeycomb; the pentagons are solid.
+const hexagons = (w) => ({
+    view: VIEW,
+    base: w.main,
+    ground: w.ground,
+    mat: GLOSS,
+    draw(s, base, accent) {
+        const t = truncatedIcosahedron();
+        const dark = accent ?? w.dark;
+        let out = "";
+        for (const p of t.pentagons)
+            out += s.panel(p, dark, { ink: true });
+        t.hexagons.forEach((h, i) => {
+            out += s.strokes([shrink(h, t.hexagonCentres[i], 0.28), shrink(h, t.hexagonCentres[i], 0.58)], base, 1.1, { closed: true });
+        });
+        out += s.strokes(t.edges, mix(dark, 0.2), 1.1);
+        return out + lit(s, t.edges);
+    },
+});
+// Flames: five tongues of flame leave each dark pentagon, an outer one and a lighter inner one.
+const flames = (w, inner) => ({
+    view: VIEW,
+    base: w.main,
+    ground: w.ground,
+    mat: GLOSS,
+    draw(s, base, accent) {
+        const t = truncatedIcosahedron();
+        const core = accent ?? inner;
+        let out = "";
+        for (const p of t.pentagons)
+            out += s.panel(p, w.dark, { ink: true });
+        const flame = (r0, r1, a, wd) => tongue(spiral(r0, r1, a, 0.75), (u) => wd * Math.min(1, u * 6 + 0.3) * (1 - u) ** 0.75, 3);
+        const frames = t.pentagonCentres.map((c, i) => frameAt(c, t.pentagons[i][0]));
+        const rings = (r0, r1, da, wd) => frames.flatMap((f) => [0, 1, 2, 3, 4].map((k) => place(f, flame(r0, r1, Math.PI / 5 + (2 * Math.PI * k) / 5 + da, wd))));
+        out += s.panels(rings(0.19, 0.64, -0.1, 0.125), base, { n: 1 });
+        out += s.panels(rings(0.21, 0.45, -0.03, 0.06), core, { n: 1 });
+        return out + s.strokes(t.edges, mix(w.dark, 0.5), 1);
+    },
+});
+// Chevrons: eight gores from pole to pole, every other one coloured, crossed by three bands that bend into a V on each gore, so that round the ball they make a zigzag.
+const chevrons = (w) => ({
+    view: { yaw: 24, pitch: 24, roll: 0 },
+    base: w.main,
+    ground: w.ground,
+    mat: GLOSS,
+    draw(s, base, accent) {
+        const dark = accent ?? w.dark;
+        const tilt = [0, 22, 0];
+        const g = gores(8, 0, tilt);
+        const at = gorePoint(8, 0, tilt);
+        let out = "";
+        for (let i = 0; i < 8; i += 2)
+            out += s.panel(g.panels[i], base, { n: 1 });
+        for (let i = 0; i < 8; i++) {
+            for (const s0 of [-0.28, 0.02, 0.32]) {
+                const upper = [], lower = [];
+                for (let j = 0; j <= 4; j++) {
+                    const u = j / 4;
+                    const dip = 0.34 * Math.abs(u - 0.5);
+                    upper.push(at(i, u, s0 + 0.12 + dip));
+                    lower.push(at(i, u, s0 + dip));
+                }
+                const band = [...lower, ...upper.reverse()];
+                out += s.panel(band, dark, { n: 2 });
+                if (s.line)
+                    out += s.strokes([band], dark, 0.6, { closed: true });
+            }
+        }
+        out += s.strokes(g.seams, mix(dark, 0.3), 0.7);
+        return out + lit(s, g.seams, 0.4);
+    },
+});
+// Swirl: four gores that twist round the ball, two of them in one colour and two in the other.
+const swirl = (w) => ({
+    view: { yaw: 20, pitch: 24, roll: 0 },
+    base: w.main,
+    ground: w.ground,
+    mat: { gloss: 0.9, shade: "#2a3450", grain: { f: 0.8, a: 0.08 } },
+    draw(s, base) {
+        const g = gores(4, 330, [0, 24, 0], 24, 6);
+        let out = "";
+        for (const { ring, gore } of g.pieces) {
+            if (gore % 2 === 1)
+                continue;
+            out += s.panel(ring, base, { n: 4, ink: true });
+            out += s.strokes([ring], base, 0.5, { closed: true, deco: true });
+        }
+        out += s.strokes(g.seams, mix(w.dark, 0.2), 0.9);
+        return out + lit(s, g.seams, 0.5);
+    },
+});
+// Metallic: the 32 panels in a polished finish that mirrors the sky above and the ground below, a light metal on the hexagons and a dark one on the pentagons.
+const metallic = (w) => ({
+    view: VIEW,
+    base: w.dark,
+    ground: w.main,
+    mat: { gloss: 1, metal: true, shade: mix(w.dark, -0.4), rim: 0.8 },
+    draw(s, base) {
+        const t = truncatedIcosahedron();
+        let out = "";
+        for (const p of t.pentagons)
+            out += s.panel(p, base, { ink: true });
+        out += s.strokes(t.edges, mix(base, -0.2), 1.1);
+        return out + lit(s, t.edges, 0.55);
+    },
+});
+const BLUE = { ground: "#f4f6fb", main: "#1f56c4", dark: "#12306f" };
+const RED = { ground: "#f8f4f2", main: "#d8312f", dark: "#6e1313" };
+const NIGHT = { ground: "#16275a", main: "#f2c230", dark: "#0a1230" };
+const CYAN = { ground: "#f4f8fa", main: "#12a8c8", dark: "#143a52" };
+const MAGENTA = { ground: "#faf4f8", main: "#d62a8c", dark: "#4a1a52" };
+const LIME = { ground: "#f6f9ee", main: "#5fb81a", dark: "#1b3a12" };
+const FIRE = { ground: "#f6f1e8", main: "#ff6a13", dark: "#1b1b1f" };
+const ICE = { ground: "#f2f6fa", main: "#1e8cff", dark: "#0d1b3d" };
+const TOXIC = { ground: "#f3f6ea", main: "#2bbf5a", dark: "#241a3a" };
+const CHEV_RED = { ground: "#f8f6f2", main: "#d6312e", dark: "#1f2128" };
+const CHEV_GREEN = { ground: "#f8f6ee", main: "#1fa65a", dark: "#f0c81c" };
+const CHEV_BLUE = { ground: "#f6f7fa", main: "#1f5fbf", dark: "#f08a24" };
+const SWIRL_BLUE = { ground: "#f6f6f2", main: "#1f5fbf", dark: "#143f86" };
+const SWIRL_RED = { ground: "#1f2128", main: "#d6312e", dark: "#d6312e" };
+const SWIRL_TEAL = { ground: "#14b0c8", main: "#f08a24", dark: "#0c6d80" };
+const GOLD = { ground: "#e3b73a", main: "#e3b73a", dark: "#7a560f" };
+const SILVER = { ground: "#cdd3db", main: "#cdd3db", dark: "#4d5662" };
+const COBALT = { ground: "#5b93e0", main: "#5b93e0", dark: "#15306a" };
+export const BALL_SOCCER_STARS_BLUE = /* @__PURE__ */ ball("ball:soccer-stars-blue", "Soccer, stars, blue", "星柄・青", stars(BLUE));
+export const BALL_SOCCER_STARS_RED = /* @__PURE__ */ ball("ball:soccer-stars-red", "Soccer, stars, red", "星柄・赤", stars(RED));
+export const BALL_SOCCER_STARS_NIGHT = /* @__PURE__ */ ball("ball:soccer-stars-night", "Soccer, stars, night", "星柄・夜空", stars(NIGHT));
+export const BALL_SOCCER_HEXAGONS_CYAN = /* @__PURE__ */ ball("ball:soccer-hexagons-cyan", "Soccer, hexagons, cyan", "六角形柄・シアン", hexagons(CYAN));
+export const BALL_SOCCER_HEXAGONS_MAGENTA = /* @__PURE__ */ ball("ball:soccer-hexagons-magenta", "Soccer, hexagons, magenta", "六角形柄・マゼンタ", hexagons(MAGENTA));
+export const BALL_SOCCER_HEXAGONS_LIME = /* @__PURE__ */ ball("ball:soccer-hexagons-lime", "Soccer, hexagons, lime", "六角形柄・ライム", hexagons(LIME));
+export const BALL_SOCCER_FLAMES_FIRE = /* @__PURE__ */ ball("ball:soccer-flames-fire", "Soccer, flames, fire", "炎柄・ファイア", flames(FIRE, "#ffd21f"));
+export const BALL_SOCCER_FLAMES_ICE = /* @__PURE__ */ ball("ball:soccer-flames-ice", "Soccer, flames, ice", "炎柄・アイス", flames(ICE, "#c4e8ff"));
+export const BALL_SOCCER_FLAMES_TOXIC = /* @__PURE__ */ ball("ball:soccer-flames-toxic", "Soccer, flames, toxic", "炎柄・トキシック", flames(TOXIC, "#dcf23a"));
+export const BALL_SOCCER_CHEVRONS_RED = /* @__PURE__ */ ball("ball:soccer-chevrons-red", "Soccer, chevrons, red", "シェブロン柄・赤", chevrons(CHEV_RED));
+export const BALL_SOCCER_CHEVRONS_GREEN = /* @__PURE__ */ ball("ball:soccer-chevrons-green", "Soccer, chevrons, green", "シェブロン柄・緑", chevrons(CHEV_GREEN));
+export const BALL_SOCCER_CHEVRONS_BLUE = /* @__PURE__ */ ball("ball:soccer-chevrons-blue", "Soccer, chevrons, blue", "シェブロン柄・青", chevrons(CHEV_BLUE));
+export const BALL_SOCCER_SWIRL_BLUE = /* @__PURE__ */ ball("ball:soccer-swirl-blue", "Soccer, swirl, blue", "渦巻き柄・青", swirl(SWIRL_BLUE));
+export const BALL_SOCCER_SWIRL_RED = /* @__PURE__ */ ball("ball:soccer-swirl-red", "Soccer, swirl, red", "渦巻き柄・赤", swirl(SWIRL_RED));
+export const BALL_SOCCER_SWIRL_TEAL = /* @__PURE__ */ ball("ball:soccer-swirl-teal", "Soccer, swirl, teal", "渦巻き柄・ティール", swirl(SWIRL_TEAL));
+export const BALL_SOCCER_METALLIC_GOLD = /* @__PURE__ */ ball("ball:soccer-metallic-gold", "Soccer, metallic, gold", "メタリック・金", metallic(GOLD));
+export const BALL_SOCCER_METALLIC_SILVER = /* @__PURE__ */ ball("ball:soccer-metallic-silver", "Soccer, metallic, silver", "メタリック・銀", metallic(SILVER));
+export const BALL_SOCCER_METALLIC_COBALT = /* @__PURE__ */ ball("ball:soccer-metallic-cobalt", "Soccer, metallic, cobalt", "メタリック・コバルト", metallic(COBALT));

package/dist/emblems/ball/ball.soccer.vintage.d.ts

@@ -0,0 +1,11 @@
+import { type BallSpec } from "./ball.engine.ts";
+/** The late 1800s: eight long panels sewn by hand with a visible cross of thread, and a button where they meet at each end. */
+export declare const BALL_SOCCER_1870_HAND_STITCHED: import("./ball.core.ts").Piece<BallSpec>;
+/** The 1900s: eight panels, a round cap at each end, and a slit across which a lace is drawn to shut the casing once the bladder is in. */
+export declare const BALL_SOCCER_1900_LACED: import("./ball.core.ts").Piece<BallSpec>;
+/** The 1930s: eighteen strips, six panels of three, in two tones of leather, the seams stitched in two rows. */
+export declare const BALL_SOCCER_1930_18_PANEL: import("./ball.core.ts").Piece<BallSpec>;
+/** The 1950s: twelve pentagons, in four tones of chestnut leather so that no two that touch match, the seams stitched. */
+export declare const BALL_SOCCER_1950_12_PANEL: import("./ball.core.ts").Piece<BallSpec>;
+/** The 1960s: the 32 panels (twelve pentagons and twenty hexagons) in leather, tan hexagons and chestnut pentagons, stitched along the seams. */
+export declare const BALL_SOCCER_1960_32_PANEL_LEATHER: import("./ball.core.ts").Piece<BallSpec>;

package/dist/emblems/ball/ball.soccer.vintage.js

@@ -0,0 +1,135 @@
+// Vintage soccer balls, in worn leather (tan, brown, chestnut) with the stitching of their time, each on the construction of its period: the hand-stitched casing of the late 1800s (eight long panels and a
+// button at each end), the laced ball of the 1900s (eight panels, a round cap at each end and a lace across a slit), the 18 strips of the 1930s (six panels of three strips), the 12 panels of the
+// 1950s and the 32 panels of the 1960s. The panels are our own layouts of the sources in docs/references.md; no maker's ball, mark or pattern is drawn.
+import { defineBall } from "./ball.engine.js";
+import { blend, mix } from "./ball.core.js";
+import { across, lacing, noise, running, scuffs } from "./ball.decal.js";
+import { paint18, seams18 } from "./ball.family.panelled.js";
+import { smallCircle } from "./ball.math.js";
+import { truncatedIcosahedron } from "./ball.polyhedra.js";
+import { dodecahedron, gorePoint, gores } from "./ball.tilings.js";
+import { SOCCER_SIZE } from "./ball.soccer.size.js";
+/** The ball the Laws describe from 1872: a sphere 27 to 28 inches (68.6 to 71.1 cm) round. The Laws' mass for the early years is left out, because the secondary sources read disagree on the figure and the year. */
+const OLD_SIZE = {
+    extentMm: 698.5 / Math.PI,
+    diameterMm: 698.5 / Math.PI,
+    circumferenceMm: 698.5,
+    rule: "Laws of the Game of the Football Association, revised 1872: the ball is a sphere 27 to 28 inches round",
+    note: "Before 1872 there was no rule. Diameter worked out from the middle of the circumference range. No mass is given, because the early figures could not be confirmed in a primary text.",
+};
+const LEATHER = { gloss: 0.22, shade: "#2b1608", grain: { f: 2.1, a: 0.34 } };
+const THREAD = "#e9d8b0";
+/** A tone of leather: no two panels of old leather are alike. */
+const tone = (base, i, spread = 0.2) => mix(base, (noise(i, 4) - 0.5) * spread);
+/** The seam of leather: a dark crease, with the highlight of its raised edge. */
+const crease = (s, seams, colour, width = 1.3) => s.strokes(seams, colour, width) + s.strokes(seams, "#fff", width * 0.3, { deco: true, opacity: 0.3, dx: 0.25, dy: 0.3 });
+const spec = (base, view, draw, shade = LEATHER.shade) => ({ view, base, mat: { ...LEATHER, shade }, draw });
+/** The long gores, each one panel painted in a tone of the leather (a gore is a lune, so it is cut at the limb as one piece). */
+function paintGores(s, g, base) {
+    let out = "";
+    g.panels.forEach((ring, i) => {
+        out += s.panel(ring, tone(base, i), { n: 1 });
+    });
+    return out;
+}
+const POLES = [(g) => g.seams[0][0], (g) => g.seams[0][g.seams[0].length - 1]];
+/** The late 1800s: eight long panels sewn by hand with a visible cross of thread, and a button where they meet at each end. */
+export const BALL_SOCCER_1870_HAND_STITCHED = /* @__PURE__ */ defineBall({
+    id: "ball:soccer-1870-hand-stitched",
+    en: "Soccer ball, hand-stitched",
+    ja: "手縫いのサッカーボール",
+    size: OLD_SIZE,
+    spec: spec("#b98a55", { yaw: 20, pitch: 28, roll: -8 }, (s, base, accent) => {
+        const g = gores(8, 0, [0, 28, 0], 24, 4);
+        let out = paintGores(s, g, base);
+        out += scuffs(s, mix(base, -0.6), mix(base, 0.55), { dark: 18, pale: 8, seed: 2 });
+        out += crease(s, g.seams, mix(base, -0.62));
+        out += s.strokes(across(g.seams, 0.085, 0.024, 0.013), accent ?? THREAD, 0.75, { deco: true });
+        for (const pole of POLES) {
+            out += s.dots([pole(g)], 0.1, mix(base, -0.38), { light: true });
+            out += s.dots([pole(g)], 0.045, mix(base, -0.62), { light: false });
+        }
+        return out;
+    }),
+});
+/** The 1900s: eight panels, a round cap at each end, and a slit across which a lace is drawn to shut the casing once the bladder is in. */
+export const BALL_SOCCER_1900_LACED = /* @__PURE__ */ defineBall({
+    id: "ball:soccer-1900-laced",
+    en: "Soccer ball, laced",
+    ja: "紐つきのサッカーボール",
+    size: OLD_SIZE,
+    spec: spec("#8a5a30", { yaw: 24, pitch: 22, roll: 6 }, (s, base, accent) => {
+        const g = gores(8, 0, [0, 18, 0], 24, 4);
+        const at = gorePoint(8, 0, [0, 18, 0]);
+        let out = paintGores(s, g, base);
+        const poles = POLES.map((p) => p(g));
+        const rim = poles.map((p) => smallCircle(p, 0.32, 40));
+        poles.forEach((p, i) => {
+            out += s.panel(rim[i], mix(base, -0.16), { n: 1 });
+        });
+        out += scuffs(s, mix(base, -0.6), mix(base, 0.5), { dark: 18, pale: 8, seed: 5 });
+        out += crease(s, g.seams.map((c) => c.slice(3, 22)), mix(base, -0.62), 1.2) + crease(s, rim, mix(base, -0.62), 1.2);
+        out += s.strokes(across(g.seams.map((c) => c.slice(3, 22)), 0.1, 0.02), accent ?? THREAD, 0.6, { deco: true });
+        const lace = lacing(at(7, 0.5, 0), at(7, 0.5, 0.2), 0.62, 6, 0.032);
+        out += s.stroke(lace.slit, mix(base, -0.75), 2.4);
+        out += s.dots(lace.eyelets, 0.011, mix(base, -0.7), { light: false });
+        out += s.strokes(lace.crossings, accent ?? THREAD, 0.85, { deco: true });
+        out += s.strokes(lace.ends, accent ?? THREAD, 0.85, { deco: true });
+        return out;
+    }),
+});
+/** The 1930s: eighteen strips, six panels of three, in two tones of leather, the seams stitched in two rows. */
+export const BALL_SOCCER_1930_18_PANEL = /* @__PURE__ */ defineBall({
+    id: "ball:soccer-1930-18-panel",
+    en: "Soccer ball, 18 strips",
+    ja: "18枚貼りの革ボール",
+    size: OLD_SIZE,
+    spec: spec("#9c4f26", { yaw: 28, pitch: 22, roll: 0 }, (s, base, accent) => {
+        const light = blend(base, "#d9a56a", 0.55);
+        const seams = seams18();
+        let out = paint18(s, [[base, light], [light, base], [base, light], [light, base], [base, light], [light, base]]);
+        out += scuffs(s, mix(base, -0.6), mix(base, 0.55), { dark: 11, pale: 5, seed: 3 });
+        out += crease(s, seams, mix(base, -0.6), 1.15);
+        out += s.strokes(running(seams, 0.13), accent ?? THREAD, 0.6, { deco: true });
+        return out;
+    }),
+});
+/** The 1950s: twelve pentagons, in four tones of chestnut leather so that no two that touch match, the seams stitched. */
+export const BALL_SOCCER_1950_12_PANEL = /* @__PURE__ */ defineBall({
+    id: "ball:soccer-1950-12-panel",
+    en: "Soccer ball, 12 panels",
+    ja: "12枚貼りの革ボール",
+    size: OLD_SIZE,
+    spec: spec("#7a3a1c", { yaw: 30, pitch: 24, roll: 8 }, (s, base, accent) => {
+        const g = dodecahedron();
+        const fill = [mix(base, 0.1), mix(base, -0.12), mix(base, 0.26), mix(base, 0.02)];
+        let out = "";
+        g.panels.forEach((p, i) => {
+            out += s.panel(p, fill[g.colour[i]], { n: 6, ink: g.colour[i] === 1 });
+        });
+        out += scuffs(s, mix(base, -0.6), mix(base, 0.55), { dark: 12, pale: 5, seed: 7 });
+        out += crease(s, g.seams, mix(base, -0.6), 1.2);
+        out += s.strokes(running(g.seams, 0.11), accent ?? THREAD, 0.55, { deco: true });
+        return out;
+    }),
+});
+/** The 1960s: the 32 panels (twelve pentagons and twenty hexagons) in leather, tan hexagons and chestnut pentagons, stitched along the seams. */
+export const BALL_SOCCER_1960_32_PANEL_LEATHER = /* @__PURE__ */ defineBall({
+    id: "ball:soccer-1960-32-panel-leather",
+    en: "Soccer ball, 32 leather",
+    ja: "32枚貼りの革ボール",
+    size: SOCCER_SIZE,
+    spec: {
+        ...spec("#6e3517", { yaw: 30, pitch: 24, roll: 8 }, (s, base, accent) => {
+            const t = truncatedIcosahedron();
+            let out = "";
+            for (const p of t.pentagons)
+                out += s.panel(p, base, { ink: true });
+            out += scuffs(s, mix(base, -0.5), "#f0d2a8", { dark: 6, pale: 3, seed: 11 });
+            out += crease(s, t.edges, mix(base, -0.55), 1.1);
+            out += s.strokes(running(t.edges, 0.13), accent ?? THREAD, 0.5, { deco: true });
+            return out;
+        }),
+        ground: "#d6a976",
+    },
+});

package/dist/emblems/ball/ball.tilings.d.ts

@@ -58,4 +58,30 @@ export interface Gores {
  * whole is then tilted by the rotation `tilt` (yaw, pitch and roll in degrees) so that the poles are not on the ball's spin axis.
  */
 export declare function gores(count?: number, twist?: number, tilt?: readonly [number, number, number], steps?: number, bands?: number): Gores;
+/** The point of a gore: gore `i` of `count`, `u` of the way across it (0 on its left seam, 1 on its right) and `s` from the south pole (-1) to the north (1), turned by `tilt` like `gores`. */
+export declare function gorePoint(count?: number, twist?: number, tilt?: readonly [number, number, number]): (i: number, u: number, s: number) => V3;
+/** Colours the centres with `k` colours so that no two neighbours (centres at angle `gap` or less apart) share one, by search; the result is the colour of each. */
+export declare function colourCentres(centres: readonly V3[], gap: number, k?: number): number[];
+type Icosahedron = Tiling & {
+    colour: number[];
+};
+/**
+ * The 20-panel layout: an icosahedron. Its 12 vertices are the cyclic permutations of (0, +-1, +-phi); its 20 triangles are about the directions of a dodecahedron's vertices. `colour` is a
+ * four-colouring of the triangles (no two that share an edge match), found by search.
+ */
+export declare function icosahedron(): Icosahedron;
+export interface Octahedron {
+    /** The eight triangular panels, with their edges bent into S curves (dense rings: use one sample per edge). */
+    panels: V3[][];
+    centres: V3[];
+    /** Every one of the 12 edges once, as an S curve from one end to the other. */
+    seams: V3[][];
+    /** 0 or 1, so that no two panels that share an edge match. */
+    parity: number[];
+}
+/**
+ * The 8-panel layout: an octahedron whose twelve edges are bent into S curves, a quarter of the way along to one side and three quarters of the way to the other, so the eight triangles are
+ * twisted into curved panels. The curve is the same turned half a turn about the edge's middle, and it is carried to itself by the cube's rotations, so the panels are alike and the layout has a hand.
+ */
+export declare function octahedron8(lift?: number, steps?: number): Octahedron;
 export {};

package/dist/emblems/ball/ball.tilings.js

@@ -210,3 +210,90 @@ export function gores(count = 6, twist = 150, tilt = [0, 0, 0], steps = 24, band
     }
     return { panels, centres, seams, pieces };
 }
+/** The point of a gore: gore `i` of `count`, `u` of the way across it (0 on its left seam, 1 on its right) and `s` from the south pole (-1) to the north (1), turned by `tilt` like `gores`. */
+export function gorePoint(count = 6, twist = 150, tilt = [0, 0, 0]) {
+    const m = rotation((tilt[0] * Math.PI) / 180, (tilt[1] * Math.PI) / 180, (tilt[2] * Math.PI) / 180);
+    return (i, u, s) => apply(m, lonLat((2 * Math.PI * (i + u)) / count + ((twist * Math.PI) / 180) * (s / 2), (s * Math.PI) / 2));
+}
+/** Colours the centres with `k` colours so that no two neighbours (centres at angle `gap` or less apart) share one, by search; the result is the colour of each. */
+export function colourCentres(centres, gap, k = 4) {
+    const colour = centres.map(() => -1);
+    const next = (i, j) => dot(centres[i], centres[j]) > Math.cos(gap) - 1e-6 && i !== j;
+    const paint = (i) => {
+        if (i === centres.length)
+            return true;
+        for (let c = 0; c < k; c++) {
+            if (centres.every((_, j) => j >= i || !next(i, j) || colour[j] !== c)) {
+                colour[i] = c;
+                if (paint(i + 1))
+                    return true;
+            }
+        }
+        colour[i] = -1;
+        return false;
+    };
+    paint(0);
+    return colour;
+}
+let icosa;
+/**
+ * The 20-panel layout: an icosahedron. Its 12 vertices are the cyclic permutations of (0, +-1, +-phi); its 20 triangles are about the directions of a dodecahedron's vertices. `colour` is a
+ * four-colouring of the triangles (no two that share an edge match), found by search.
+ */
+export function icosahedron() {
+    if (icosa !== undefined)
+        return icosa;
+    const verts = [];
+    for (const a of signs)
+        for (const b of signs)
+            verts.push(norm([0, a, b * PHI]), norm([a, b * PHI, 0]), norm([b * PHI, 0, a]));
+    const near = (a, b) => Math.abs(dot(a, b) - 1 / Math.sqrt(5)) < 1e-6;
+    const centres = [];
+    for (let i = 0; i < 12; i++)
+        for (let j = i + 1; j < 12; j++)
+            for (let k = j + 1; k < 12; k++)
+                if (near(verts[i], verts[j]) && near(verts[i], verts[k]) && near(verts[j], verts[k]))
+                    centres.push(norm(add(add(verts[i], verts[j]), verts[k])));
+    const t = tiling(verts, centres, centres.map(() => 0), 5);
+    // Triangles that share an edge have centres at the angle whose cosine is sqrt 5 / 3.
+    icosa = { ...t, colour: colourCentres(centres, Math.acos(Math.sqrt(5) / 3) + 1e-6, 4) };
+    return icosa;
+}
+const octas = new Map();
+/**
+ * The 8-panel layout: an octahedron whose twelve edges are bent into S curves, a quarter of the way along to one side and three quarters of the way to the other, so the eight triangles are
+ * twisted into curved panels. The curve is the same turned half a turn about the edge's middle, and it is carried to itself by the cube's rotations, so the panels are alike and the layout has a hand.
+ */
+export function octahedron8(lift = 0.16, steps = 14) {
+    const hit = octas.get(lift * 1000 + steps);
+    if (hit !== undefined)
+        return hit;
+    const edge = (a, b) => {
+        const [p, q] = keyOf(a) < keyOf(b) ? [a, b] : [b, a];
+        const pts = Array.from({ length: steps + 1 }, (_, j) => bent(p, q, j / steps, lift, 0.5));
+        return keyOf(a) < keyOf(b) ? pts : pts.reverse();
+    };
+    const panels = [];
+    const centres = [];
+    const parity = [];
+    const seams = [];
+    const seen = new Set();
+    for (const sx of signs)
+        for (const sy of signs)
+            for (const sz of signs) {
+                const a = [sx, 0, 0], b = [0, sy, 0], c = [0, 0, sz];
+                panels.push([...edge(a, b).slice(0, -1), ...edge(b, c).slice(0, -1), ...edge(c, a).slice(0, -1)]);
+                centres.push(norm([sx, sy, sz]));
+                parity.push(sx * sy * sz > 0 ? 0 : 1);
+                for (const [p, q] of [[a, b], [b, c], [c, a]]) {
+                    const key = [keyOf(p), keyOf(q)].sort().join("|");
+                    if (seen.has(key))
+                        continue;
+                    seen.add(key);
+                    seams.push(edge(p, q));
+                }
+            }
+    const result = { panels, centres, seams, parity };
+    octas.set(lift * 1000 + steps, result);
+    return result;
+}

package/dist/emblems/ball/ball.volleyball.flag.d.ts

@@ -0,0 +1,12 @@
+import { type BallSpec } from "./ball.engine.ts";
+export declare const BALL_VOLLEYBALL_COLOURS: import("./ball.core.ts").Piece<BallSpec>;
+export declare const BALL_VOLLEYBALL_BRAZIL: import("./ball.core.ts").Piece<BallSpec>;
+export declare const BALL_VOLLEYBALL_JAPAN: import("./ball.core.ts").Piece<BallSpec>;
+export declare const BALL_VOLLEYBALL_CANADA: import("./ball.core.ts").Piece<BallSpec>;
+export declare const BALL_VOLLEYBALL_USA: import("./ball.core.ts").Piece<BallSpec>;
+export declare const BALL_VOLLEYBALL_ITALY: import("./ball.core.ts").Piece<BallSpec>;
+export declare const BALL_VOLLEYBALL_POLAND: import("./ball.core.ts").Piece<BallSpec>;
+export declare const BALL_VOLLEYBALL_FRANCE: import("./ball.core.ts").Piece<BallSpec>;
+export declare const BALL_VOLLEYBALL_SERBIA: import("./ball.core.ts").Piece<BallSpec>;
+export declare const BALL_VOLLEYBALL_NETHERLANDS: import("./ball.core.ts").Piece<BallSpec>;
+export declare const BALL_VOLLEYBALL_GERMANY: import("./ball.core.ts").Piece<BallSpec>;

package/dist/emblems/ball/ball.volleyball.flag.js

@@ -0,0 +1,36 @@
+// Volleyballs in national colours: the 18-panel indoor ball (six groups of three strips) with its panels in the colours of a country's flag, three colours to a ball. They are only colours: no flag is drawn,
+// no crest or federation's mark, and the ball is the indoor ball of the FIVB's rule. `colors` takes any three colours for any of them, and `ball:volleyball-colours` is the same ball with colours of your own.
+import { defineBall } from "./ball.engine.js";
+import { strips18 } from "./ball.family.panelled.js";
+import { BALL_VOLLEYBALL } from "./ball.volleyball.js";
+const WHITE = "#f6f4ee";
+/** The ball with the colours of one flag: `tint` replaces the first colour, `accent` the second and `colors` all three. The six faces take the three colours in pairs, so each colour is the outer strips of two faces and the middle strip of two others. */
+function nation(id, en, ja, colours, view = { yaw: 28, pitch: 22, roll: 0 }) {
+    return defineBall({
+        id,
+        en,
+        ja,
+        size: BALL_VOLLEYBALL.size,
+        spec: {
+            view,
+            base: colours[0],
+            ground: "#e9e7e0",
+            mat: { gloss: 0.75, shade: "#1a2a50", grain: { f: 1.2, a: 0.12 } },
+            draw: (s, base, accent, picked) => {
+                const [a, b, c] = picked ?? [base, accent ?? colours[1], colours[2]];
+                return strips18(s, [[a, b], [b, c], [c, a], [a, c], [b, a], [c, b]], "#3a4560");
+            },
+        },
+    });
+}
+export const BALL_VOLLEYBALL_COLOURS = /* @__PURE__ */ nation("ball:volleyball-colours", "Volleyball, three colours", "三色のバレーボール", ["#f3c81c", "#1f5fbf", WHITE]);
+export const BALL_VOLLEYBALL_BRAZIL = /* @__PURE__ */ nation("ball:volleyball-brazil", "Volleyball, Brazil", "バレー（ブラジル）", ["#009c3b", "#ffdf00", "#002776"]);
+export const BALL_VOLLEYBALL_JAPAN = /* @__PURE__ */ nation("ball:volleyball-japan", "Volleyball, Japan", "バレー（日本）", [WHITE, "#bc002d", "#7d0020"]);
+export const BALL_VOLLEYBALL_CANADA = /* @__PURE__ */ nation("ball:volleyball-canada", "Volleyball, Canada", "バレー（カナダ）", ["#d52b1e", WHITE, "#9b1c14"]);
+export const BALL_VOLLEYBALL_USA = /* @__PURE__ */ nation("ball:volleyball-usa", "Volleyball, USA", "バレー（アメリカ）", ["#b22234", WHITE, "#3c3b6e"]);
+export const BALL_VOLLEYBALL_ITALY = /* @__PURE__ */ nation("ball:volleyball-italy", "Volleyball, Italy", "バレー（イタリア）", ["#009246", WHITE, "#ce2b37"]);
+export const BALL_VOLLEYBALL_POLAND = /* @__PURE__ */ nation("ball:volleyball-poland", "Volleyball, Poland", "バレー（ポーランド）", [WHITE, "#dc143c", "#9b1030"]);
+export const BALL_VOLLEYBALL_FRANCE = /* @__PURE__ */ nation("ball:volleyball-france", "Volleyball, France", "バレー（フランス）", ["#0055a4", WHITE, "#ef4135"]);
+export const BALL_VOLLEYBALL_SERBIA = /* @__PURE__ */ nation("ball:volleyball-serbia", "Volleyball, Serbia", "バレー（セルビア）", ["#c6363c", "#0c4076", WHITE]);
+export const BALL_VOLLEYBALL_NETHERLANDS = /* @__PURE__ */ nation("ball:volleyball-netherlands", "Volleyball, Netherlands", "バレー（オランダ）", ["#ae1c28", WHITE, "#21468b"]);
+export const BALL_VOLLEYBALL_GERMANY = /* @__PURE__ */ nation("ball:volleyball-germany", "Volleyball, Germany", "バレー（ドイツ）", ["#1b1b1b", "#dd0000", "#ffce00"]);

package/dist/emblems/emblem.core.d.ts

@@ -56,6 +56,8 @@ export interface EmblemOptions {
      * (made safe first), `emblem` a dougu id, `flag` a country code (`ca` and `us` are drawn here; another needs the `flags` option, a renderer like hata's). See `PuckFace`. Anything that is not a puck ignores it.
      */
     face?: PuckFace;
+    /** A ball with panels in several colours (the national volleyballs, `ball:volleyball-flag` and the rest): three colours for its panels, each a hex colour or `rgb()`; one that is not a colour is dropped, and fewer than three are repeated. Anything else ignores it. */
+    colors?: readonly string[];
     /** A puck: a renderer for the flag codes this package does not draw (`face.flag`): `(code, { shape: "round" | "square" | "rect", size, theme }) => svg`, synchronous, the same as taisen-brackets takes (hata's `flag()` is asynchronous, so load the flags first). */
     flags?: FlagRenderer;
 }