@siegesailor/terminal-sigma 1.4.0 → 1.5.0

package/build/pixel-art.js

@@ -1,135 +1,255 @@
-// The pet lives on a stage as wide as its panel and 28 pixels tall. Each
-// terminal cell draws 2 stacked pixels with "▀", foreground for the top and
-// background for the bottom, so the stage takes 14 rows.
-export const stageHeight = 28;
-export const defaultLook = { size: 1, build: "average", gender: "other" };
+// The character stands on a stage as wide as its panel and 32 pixels tall.
+// Each terminal cell draws 2 stacked pixels with "▀", foreground for the top
+// and background for the bottom, so the stage takes 16 rows.
+export const stageHeight = 32;
+export const defaultLook = {
+    height: 23,
+    build: "average",
+    gender: "other",
+    style: "desk",
+    hair: "dark",
+};
+// 145 cm draws 20 pixels tall and 205 cm 26; the build follows the BMI.
 export function lookOf(profile) {
     if (!profile) {
         return defaultLook;
     }
     const bmi = profile.weight / (profile.height / 100) ** 2;
     let build = "average";
-    if (bmi < 20) {
+    if (bmi < 19.5) {
         build = "slim";
     }
-    else if (bmi >= 27) {
-        build = "broad";
+    else if (bmi >= 30) {
+        build = "heavy";
+    }
+    else if (bmi >= 25) {
+        build = "stocky";
+    }
+    let hair = "dark";
+    if (profile.age >= 70) {
+        hair = "white";
+    }
+    else if (profile.age >= 55) {
+        hair = "grey";
     }
     return {
-        size: Math.min(Math.max(Math.floor((profile.height - 150) / 12), 0), 3),
+        height: Math.min(Math.max(Math.round(20 + (profile.height - 145) / 10), 19), 27),
         build,
         gender: profile.gender,
+        style: profile.workStyle,
+        hair,
         goal: profile.goal,
     };
 }
-export const noBadges = { meal: false, workout: false, focus: false };
 // Each equipment slot upgrades once from level 2 and again 4 levels later,
 // staggered so every level from 2 to 9 changes exactly 1 piece.
 export const gearOf = (level) => {
     const tier = (slot) => Math.min(Math.max(Math.floor((level - 2 - slot) / 4) + 1, 0), 2);
-    return { gadget: tier(0), wear: tier(1), headwear: tier(2), aura: tier(3) };
+    return { gadget: tier(0), wear: tier(1), headwear: tier(2), carry: tier(3) };
 };
-// The pet grows twice: a hatchling below level 4, an adult from level 7.
-export const growthOf = (level) => level >= 7 ? 2 : level >= 4 ? 1 : 0;
-const widthOf = { slim: 13, average: 15, broad: 18 };
-const shapeOf = (look, level, squash = 0) => {
-    const growth = growthOf(level) - 1;
-    const width = widthOf[look.build] + growth * 2 - squash;
-    const height = 9 + look.size + growth * 2 + squash;
-    return { width, height, top: height + 1 };
+// The feet stand on row 1, in the middle of their shadow.
+const ground = 1;
+const halfWidths = {
+    female: [3, 2, 3],
+    male: [4, 3, 3],
+    other: [3, 3, 3],
 };
+// A head of 5 rows and a neck take 6 of the height; legs take 56% of the rest.
+function bodyOf(look) {
+    const span = look.height - 6;
+    const legs = Math.round(span * 0.56);
+    const torso = span - legs;
+    let [chest, waist, hips] = halfWidths[look.gender];
+    switch (look.build) {
+        case "slim": {
+            chest -= look.gender === "male" ? 1 : 0;
+            waist = Math.max(waist - 1, 2);
+            hips = Math.max(hips - 1, 2);
+            break;
+        }
+        case "stocky": {
+            waist += 1;
+            break;
+        }
+        case "heavy": {
+            chest += 1;
+            waist += 2;
+            hips += 1;
+            break;
+        }
+        case "average": {
+            break;
+        }
+    }
+    if (look.goal === "buildMuscle") {
+        chest += 1;
+    }
+    const hip = ground + legs;
+    const shoulder = hip + torso - 1;
+    const chin = shoulder + 2;
+    return {
+        hip,
+        shoulder,
+        chin,
+        top: chin + 4,
+        legs,
+        chest,
+        waist,
+        hips,
+        arm: look.build === "heavy" || look.goal === "buildMuscle" ? 2 : 1,
+        reach: torso + 1,
+    };
+}
 const span = (put, from, to, y, key) => {
     for (let x = from; x <= to; x++) {
         put(x, y, key);
     }
 };
-const icon = (rows, x, y) => (put) => {
-    for (const [offset, row] of rows.entries()) {
-        for (const [index, key] of [...row].entries()) {
-            put(x + index, y - offset, key);
-        }
+const pointsOf = ([x0, y0], [x1, y1]) => {
+    const points = [];
+    const steps = Math.max(Math.abs(x1 - x0), Math.abs(y1 - y0), 1);
+    for (let step = 0; step <= steps; step++) {
+        points.push([
+            Math.round(x0 + ((x1 - x0) * step) / steps),
+            Math.round(y0 + ((y1 - y0) * step) / steps),
+        ]);
+    }
+    return points;
+};
+const hanging = (b, side, swing = 0) => [
+    side * (b.chest + 1),
+    b.shoulder - b.reach + swing,
+];
+// A standing desk at the waist, with the laptop's lid facing out.
+const desk = (put, _upper, b) => {
+    const top = b.hip + 1;
+    span(put, -8, 8, top, "L");
+    for (let y = 0; y < top; y++) {
+        put(-7, y, "x");
+        put(7, y, "x");
+    }
+    for (let y = top + 1; y <= top + 3; y++) {
+        span(put, -2, 2, y, "d");
+    }
+    put(0, top + 2, "l");
+};
+const cup = ([x, y], steam) => (_put, upper) => {
+    span(upper, x, x + 1, y, "Q");
+    span(upper, x, x + 1, y + 1, "Q");
+    upper(x, y + 1, "o");
+    if (steam !== undefined) {
+        upper(x + (steam % 2), y + 3, "v");
+        upper(x + 1 - (steam % 2), y + 4, "v");
     }
 };
-const sparkles = (points) => (put, shape) => {
-    for (const [x, y] of points) {
-        put(x < 0 ? x : shape.width - 1 + x, y + shape.top, "y");
+const apple = ([x, y], isBitten) => (_put, upper) => {
+    span(upper, x, x + 1, y, "F");
+    upper(x, y + 1, "F");
+    upper(x + 1, y + 1, isBitten ? "." : "F");
+    upper(x + 1, y + 2, "G");
+};
+const barbell = (y) => (_put, upper, b) => {
+    const end = b.chest + 6;
+    span(upper, -end, end, y, "d");
+    for (const x of [-end, -end + 1, end - 1, end]) {
+        span(upper, x, x, y - 1, "D");
+        upper(x, y, "D");
+        span(upper, x, x, y + 1, "D");
     }
 };
-const laptop = (put, { width }) => {
-    span(put, width + 3, width + 8, 0, "x");
-    for (let y = 1; y <= 2; y++) {
-        put(width + 7, y, "x");
+const sparkles = (points) => (put) => {
+    for (const [x, y] of points) {
+        put(x, y, "y");
     }
-    span(put, width + 3, width + 7, 3, "L");
-    for (let y = 4; y <= 7; y++) {
-        put(width + 6, y, "l");
-        put(width + 7, y, "L");
+};
+const sleepyZ = (at) => (put, _upper, b) => {
+    const rows = ["ZZZZ", "..Z.", ".Z..", "ZZZZ"];
+    for (const [offset, row] of rows.entries()) {
+        for (const [index, key] of [...row].entries()) {
+            put(3 + (at % 2) + index, b.top + 4 + at - offset, key);
+        }
     }
 };
-const held = (rows, dy) => (put, shape) => {
-    icon(rows, shape.width + 2, dy(shape))(put, shape, 0);
+// Standing in place between walks: breathing, blinking, looking about, and
+// waving when every target is met.
+const resting = (t, mood) => (b) => {
+    const isWaving = mood === "happy" && t >= 3 && t <= 5;
+    let turn = 0;
+    if (t === 2 || t === 3) {
+        turn = -1;
+    }
+    else if (t === 4) {
+        turn = 1;
+    }
+    return {
+        mouth: mood === "happy" ? "smile" : undefined,
+        bob: Math.floor(t / 2) % 2,
+        eyes: t === 6 ? "closed" : "open",
+        turn,
+        lift: mood === "happy" && t === 1 ? 1 : 0,
+        hands: isWaving
+            ? [undefined, [b.chest + 3 + (t % 2), b.top - 1]]
+            : undefined,
+    };
 };
-// Where the pet stands and what it does on every tick of `counter`.
-function sceneOf(activity, counter, width, shape, mood) {
-    const home = 3;
-    const minimum = 3;
-    const maximum = Math.max(width - shape.width - 3, minimum + 1);
+const walking = (step, mood) => (b) => ({
+    mouth: mood === "happy" ? "smile" : undefined,
+    turn: 1,
+    step: [0, 1, 0, 3][step % 4],
+    bob: step % 2 === 0 ? 1 : 0,
+    hands: [
+        hanging(b, -1, step % 4 === 3 ? 1 : 0),
+        hanging(b, 1, step % 4 === 1 ? 1 : 0),
+    ],
+});
+// Where the character stands and what it does on every tick of `counter`.
+function sceneOf(activity, counter, width, mood) {
+    const home = Math.floor(width / 2);
+    const minimum = 8;
+    const maximum = Math.max(width - 9, minimum + 1);
     const travel = maximum - minimum;
     const tick = counter % 4;
+    const mouth = mood === "happy" ? "smile" : undefined;
     if (activity === "idle" && mood === "sleepy") {
-        // Napping in place: breathing, with Zs drifting up.
+        // Dozing on its feet: nodding, yawning, with Zs drifting up.
+        const at = counter % 6;
+        const isYawning = at === 4;
         return {
-            x: Math.floor((width - shape.width) / 2),
+            x: home,
             facing: 1,
-            pose: { squash: tick < 2 ? 0 : 1, eyes: "closed" },
-            props: [
-                (put, { width: body, top }) => {
-                    const rise = counter % 6;
-                    icon(["zzzz", "..z.", ".z..", "zzzz"], body - 2 + rise, top + 4 + rise)(put, shape, 0);
-                },
-            ],
+            pose: (b) => ({
+                eyes: "closed",
+                bob: at % 3 === 0 ? 1 : 0,
+                mouth: isYawning ? "open" : undefined,
+                hands: isYawning ? [undefined, [2, b.chin]] : undefined,
+            }),
+            props: [sleepyZ(at)],
         };
     }
     if (activity === "idle") {
         // Wander: pause, walk across, pause and look about, walk back.
-        const pause = 6;
-        const cycle = 2 * (pause + travel);
-        const at = counter % cycle;
-        const isHappy = mood === "happy";
-        const walk = (step) => ({
-            step: step % 2 === 0 ? 1 : 2,
-            look: 1,
-            lift: isHappy && step % 2 === 1 ? 1 : 0,
-            eyes: isHappy ? "happy" : "open",
-        });
-        const rest = (moment) => ({
-            squash: Math.floor(moment / 2) % 2,
-            eyes: isHappy ? "happy" : moment === 4 ? "closed" : "open",
-            arms: isHappy && moment % 2 === 0 ? ["up", "up"] : undefined,
-        });
+        const pause = 8;
+        const at = counter % (2 * (pause + travel));
         if (at < pause) {
-            return {
-                x: minimum,
-                facing: at === 2 || at === 3 ? -1 : 1,
-                pose: rest(at),
-            };
+            return { x: minimum, facing: 1, pose: resting(at, mood) };
         }
         if (at < pause + travel) {
-            return { x: minimum + at - pause, facing: 1, pose: walk(at - pause) };
+            const step = at - pause;
+            return { x: minimum + step, facing: 1, pose: walking(step, mood) };
         }
         if (at < 2 * pause + travel) {
-            const moment = at - pause - travel;
             return {
                 x: maximum,
-                facing: moment === 2 || moment === 3 ? 1 : -1,
-                pose: rest(moment),
+                facing: -1,
+                pose: resting(at - pause - travel, mood),
             };
         }
         const step = at - 2 * pause - travel;
-        return { x: maximum - step, facing: -1, pose: walk(step) };
+        return { x: maximum - step, facing: -1, pose: walking(step, mood) };
     }
     switch (activity) {
         case "run": {
+            // Laps across the stage, 2 pixels a tick, with the arms bent.
             const lap = Math.max(Math.ceil(travel / 2), 1);
             const at = counter % (2 * lap);
             const forward = at < lap;
@@ -139,125 +259,166 @@ function sceneOf(activity, counter, width, shape, mood) {
                     ? Math.min(minimum + step * 2, maximum)
                     : Math.max(maximum - step * 2, minimum),
                 facing: forward ? 1 : -1,
-                pose: {
-                    step: counter % 2 === 0 ? 1 : 2,
-                    lift: counter % 2,
-                    look: 1,
-                    arms: counter % 2 === 0 ? ["up", "down"] : ["down", "up"],
-                },
-                props: [icon(["vv.", "...", ".vv"], -6, 6)],
+                pose: (b) => ({
+                    mouth,
+                    turn: 1,
+                    step: counter % 2 === 0 ? 1 : 3,
+                    bob: counter % 2,
+                    hands: [
+                        [-(b.chest + 2), b.hip + 2 + (counter % 2)],
+                        [b.chest + 2, b.hip + 3 - (counter % 2)],
+                    ],
+                }),
+                props: [
+                    (put, _upper, b) => {
+                        put(-(b.chest + 4), b.top - 1 - (counter % 2), "v");
+                        put(-(b.chest + 6), b.hip + (counter % 3), "v");
+                    },
+                ],
             };
         }
         case "focus": {
+            // Typing at a standing desk, the laptop's glow on the face.
             return {
                 x: home,
                 facing: 1,
-                pose: {
-                    look: 1,
-                    squash: tick < 2 ? 0 : 1,
-                    arms: ["down", tick % 2 === 0 ? "forward" : "mid"],
-                },
+                pose: (b) => ({
+                    mouth,
+                    bob: tick === 3 ? 1 : 0,
+                    hands: [
+                        [-3, b.hip + 2 + (tick % 2)],
+                        [3, b.hip + 3 - (tick % 2)],
+                    ],
+                }),
                 props: [
-                    laptop,
-                    (put, { width: body }) => {
-                        put(body + 5 + (tick % 2), 9 + tick, "y");
-                        put(body + 7 - (tick % 2), 9 + ((tick + 2) % 4), "y");
+                    desk,
+                    (put, _upper, b) => {
+                        put(-3 + tick, b.top + 2 + (tick % 2), "y");
                     },
                 ],
             };
         }
         case "break": {
-            const step = counter % 6;
-            const sipping = step >= 4;
+            // A coffee, sipped every few ticks.
+            const at = counter % 6;
+            const isSipping = at >= 4;
+            const hand = (b) => isSipping ? [2, b.chin] : [b.chest + 2, b.hip + 2];
             return {
                 x: home,
                 facing: 1,
-                pose: {
-                    look: 1,
-                    squash: step % 2,
-                    eyes: sipping ? "closed" : "open",
-                    arms: ["down", sipping ? "up" : "mid"],
-                },
+                pose: (b) => ({
+                    mouth,
+                    bob: at % 2,
+                    eyes: isSipping ? "closed" : "open",
+                    hands: [undefined, hand(b)],
+                }),
                 props: [
-                    held(["QQ", "Qc"], (shape) => sipping ? shape.top - 1 : Math.ceil(shape.height / 2) + 2),
-                    ...(sipping
-                        ? []
-                        : [
-                            held(step % 2 === 0 ? [".v", "v."] : ["v.", ".v"], (shape) => Math.ceil(shape.height / 2) + 5),
-                        ]),
+                    (put, upper, b) => {
+                        cup(hand(b), isSipping ? undefined : at)(put, upper, b);
+                    },
                 ],
             };
         }
         case "eat": {
-            const atMouth = tick === 1 || tick === 2;
+            const isBiting = tick === 1 || tick === 2;
+            const hand = (b) => isBiting ? [2, b.chin] : [b.chest + 2, b.hip + 3];
             return {
                 x: home,
                 facing: 1,
-                pose: {
-                    look: 1,
-                    squash: tick === 2 ? 1 : 0,
-                    eyes: tick === 2 ? "happy" : "open",
-                    arms: ["down", atMouth ? "up" : "mid"],
-                },
+                pose: (b) => ({
+                    bob: tick === 2 ? 1 : 0,
+                    mouth: isBiting ? "open" : mouth,
+                    hands: [undefined, hand(b)],
+                }),
                 props: [
-                    held(tick === 3 ? [".G", "F.", "FF"] : [".G", "FF", "FF"], (shape) => atMouth ? shape.top - 2 : Math.ceil(shape.height / 2) + 2),
+                    (put, upper, b) => {
+                        const [x, y] = hand(b);
+                        apple([x, y - 1], tick === 3)(put, upper, b);
+                    },
                 ],
             };
         }
         case "lift": {
-            const up = tick === 1 || tick === 2;
+            // An overhead press: rack, press, lock out, lower.
+            const height = (b) => [b.shoulder, b.shoulder + 3, b.top + 1, b.shoulder + 3][tick] ??
+                b.shoulder;
             return {
                 x: home,
                 facing: 1,
-                pose: {
-                    arms: up ? ["up", "up"] : ["mid", "mid"],
-                    lift: tick === 2 ? 1 : 0,
-                    squash: up ? 0 : 1,
+                pose(b) {
+                    const y = height(b);
+                    const x = tick === 2 ? b.chest + 1 : b.chest + 2;
+                    return {
+                        mouth,
+                        bob: tick === 0 ? 1 : 0,
+                        hands: [
+                            [-x, y],
+                            [x, y],
+                        ],
+                    };
                 },
                 props: [
-                    (put, shape) => {
-                        const y = up ? shape.top + 3 : Math.ceil(shape.height / 2) + 4;
-                        span(put, -3, shape.width + 2, y, "d");
-                        icon(["DD", "DD", "DD"], -4, y + 1)(put, shape, 0);
-                        icon(["DD", "DD", "DD"], shape.width + 2, y + 1)(put, shape, 0);
+                    (put, upper, b) => {
+                        barbell(height(b))(put, upper, b);
                     },
                 ],
             };
         }
         case "stretch": {
+            // Reach up, rise on the toes, open the arms wide, and come down.
             return {
                 x: home,
                 facing: 1,
-                pose: {
-                    arms: tick < 2 ? ["up", "up"] : ["mid", "mid"],
-                    squash: tick < 2 ? -1 : 1,
-                    eyes: tick === 1 ? "closed" : "open",
+                pose(b) {
+                    const reaches = [
+                        [1, b.top + 2],
+                        [1, b.top + 3],
+                        [b.chest + 6, b.shoulder],
+                        [b.chest + 4, b.shoulder + 4],
+                    ];
+                    const [x, y] = reaches[tick] ?? [1, b.top + 2];
+                    return {
+                        mouth,
+                        bob: tick === 1 ? 0 : 1,
+                        lift: tick === 1 ? 1 : 0,
+                        eyes: tick === 1 ? "closed" : "open",
+                        hands: [
+                            [-x, y],
+                            [x, y],
+                        ],
+                    };
                 },
             };
         }
         case "levelUp": {
+            const lift = [0, 2, 3, 1][tick] ?? 0;
             return {
                 x: home,
                 facing: 1,
-                pose: {
-                    arms: ["up", "up"],
-                    lift: [0, 2, 3, 1][tick] ?? 0,
-                    eyes: "happy",
-                },
+                pose: (b) => ({
+                    mouth: "smile",
+                    lift,
+                    hands: [
+                        [-(b.chest + 3), b.top],
+                        [b.chest + 3, b.top],
+                    ],
+                }),
                 props: [
-                    sparkles(tick % 2 === 0
-                        ? [
-                            [-3, 2],
-                            [3, 4],
-                            [-4, -3],
-                            [4, -1],
-                        ]
-                        : [
-                            [-4, 4],
-                            [4, 2],
-                            [-3, -1],
-                            [3, -3],
-                        ]),
+                    (put, upper, b) => {
+                        sparkles(tick % 2 === 0
+                            ? [
+                                [-8, b.top],
+                                [8, b.top + 2],
+                                [-9, b.shoulder],
+                                [9, b.shoulder - 2],
+                            ]
+                            : [
+                                [-9, b.top + 2],
+                                [9, b.top],
+                                [-8, b.shoulder - 2],
+                                [8, b.shoulder],
+                            ])(put, upper, b);
+                    },
                 ],
             };
         }
@@ -269,226 +430,361 @@ export const intervalOf = (activity) => ({
     break: 380,
     eat: 300,
     run: 110,
-    lift: 400,
+    lift: 420,
     stretch: 480,
     levelUp: 160,
 })[activity];
 // How many ticks one loop of an activity takes on a stage of `width`.
 export function cycleOf(activity, width) {
-    const travel = Math.max(width - 21, 4);
+    const travel = Math.max(width - 17, 1);
     if (activity === "idle") {
-        return 2 * (6 + travel);
+        return 2 * (8 + travel);
     }
     if (activity === "run") {
         return 2 * Math.max(Math.ceil(travel / 2), 1);
     }
     return activity === "break" ? 6 : 4;
 }
-// Behind the body: a cape that flares and ripples, or sparkles of the aura.
-function paintBehind({ put, shape, gear, counter }) {
-    if (gear.wear === 2) {
-        for (let y = 2; y <= shape.top - 2; y++) {
-            const flare = Math.floor((shape.top - y) / 3) + ((counter + y) % 4 < 2 ? 0 : 1);
-            span(put, -1 - flare, -1, y, y === 2 ? "s" : "S");
+// The tops by work style: a hoodie, a shirt under an apron, a tee, a tank.
+const topOf = {
+    desk: ["C", "c"],
+    standing: ["Q", "U"],
+    active: ["C", "c"],
+    athlete: ["S", "z"],
+};
+// How much of the arm the sleeve covers, from the shoulder down.
+const sleeveOf = {
+    desk: 1,
+    standing: 0.5,
+    active: 0.3,
+    athlete: 0,
+};
+// Jeans and sneakers, chinos and shoes, cargo pants and boots, or shorts
+// and running shoes.
+const bottomOf = {
+    desk: { pants: "P", shade: "p", shoe: "w", shoeRows: 1 },
+    standing: { pants: "N", shade: "n", shoe: "b", shoeRows: 1 },
+    active: { pants: "O", shade: "V", shoe: "B", shoeRows: 2 },
+    athlete: { pants: "x", shade: "S", shoe: "S", shoeRows: 1 },
+};
+const hairKeys = { dark: "h", grey: "H", white: "I" };
+// An oval on the ground with the feet in its middle, shrinking in the air.
+function paintShadow(put, b, lift) {
+    const half = b.hips + 4 - Math.min(lift, 2);
+    span(put, -half + 2, half - 2, ground - 1, "A");
+    span(put, -half, half, ground, "A");
+    span(put, -half + 2, half - 2, ground + 1, "A");
+}
+// Long hair falls behind the shoulders, so it goes on before the body.
+function paintHairBehind({ upper, b, look, counter }) {
+    const hair = hairKeys[look.hair];
+    if (look.gender !== "female") {
+        return;
+    }
+    if (look.style === "athlete") {
+        // A ponytail that swings.
+        const sway = counter % 4 < 2 ? 0 : 1;
+        upper(3, b.chin + 3, hair);
+        upper(4, b.chin + 2, hair);
+        upper(4 + sway, b.chin + 1, hair);
+        upper(4 + sway, b.chin, hair);
+        return;
+    }
+    for (let y = b.shoulder - 2; y <= b.chin + 3; y++) {
+        upper(-3, y, hair);
+        upper(3, y, hair);
+    }
+    for (let y = b.shoulder - 1; y < b.chin; y++) {
+        span(upper, -2, 2, y, hair);
+    }
+}
+function paintLegs({ put, b, look, pose }) {
+    const { pants, shade, shoe, shoeRows } = bottomOf[look.style];
+    const thigh = b.hips;
+    const calf = Math.max(thigh - 1, 2);
+    const knee = ground + Math.floor(b.legs / 2);
+    const shorts = ground + Math.round(b.legs * 0.55);
+    for (const side of [-1, 1]) {
+        const isLifted = (side === -1 && pose.step === 1) || (side === 1 && pose.step === 3);
+        const sole = ground + (isLifted ? 1 : 0);
+        for (let y = sole; y < b.hip; y++) {
+            const width = y >= knee ? thigh : calf;
+            let key = pants;
+            if (y < sole + shoeRows) {
+                key = shoe;
+            }
+            else if (look.style === "athlete" && y < shorts) {
+                key = "s";
+            }
+            for (let x = 1; x <= width; x++) {
+                put(side * x, y, key);
+            }
+            if (key === pants) {
+                put(side * width, y, shade);
+            }
+        }
+        // Shoes stick out a little past the ankle.
+        put(side * (calf + 1), sole, shoe);
+        if (look.style === "active") {
+            put(side * thigh, knee + 1, "V");
+            put(side * thigh, knee + 2, "V");
         }
     }
-    if (gear.aura === 2) {
-        const sway = counter % 2;
-        put(-3 - sway, shape.top - 1, "y");
-        put(shape.width + 2 + sway, shape.top - 3, "y");
-        put(-2, 3 + sway, "y");
+    // The thighs meet at the crotch, and all the way down on a heavy build.
+    let crotch = b.hip - 1;
+    if (look.build === "heavy") {
+        crotch = look.style === "athlete" ? shorts : knee;
+    }
+    for (let y = crotch; y < b.hip; y++) {
+        put(0, y, pants);
     }
 }
-// 4 short legs, like the Claude Code mascot; sneakers for an endurance goal.
-function paintLegs({ put, shape, look, pose }) {
-    const columns = [1, 3, shape.width - 4, shape.width - 2];
-    const foot = look.goal === "endurance" ? "w" : "o";
-    for (const [index, x] of columns.entries()) {
-        const isLifted = (pose.step === 1 && index % 2 === 0) ||
-            (pose.step === 2 && index % 2 === 1);
-        if (!isLifted) {
-            put(x, 0, foot);
+function paintTorso({ upper, b, look, gear }) {
+    const [main, shade] = topOf[look.style];
+    const torso = b.shoulder - b.hip + 1;
+    const chestRows = Math.ceil(torso * 0.45);
+    const halfAt = (y) => {
+        if (b.shoulder - y < chestRows) {
+            return b.chest;
+        }
+        return y - b.hip < 2 ? Math.max(b.hips, b.waist) : b.waist;
+    };
+    for (let y = b.hip; y <= b.shoulder; y++) {
+        const half = halfAt(y);
+        span(upper, -half, half, y, main);
+        upper(-half, y, shade);
+        upper(half, y, shade);
+    }
+    span(upper, -1, 1, b.shoulder + 1, "s");
+    switch (look.style) {
+        case "desk": {
+            // A hoodie: the hood behind the neck, drawstrings, a front pocket.
+            upper(-2, b.shoulder + 1, shade);
+            upper(2, b.shoulder + 1, shade);
+            upper(-1, b.shoulder - 1, "w");
+            upper(1, b.shoulder - 1, "w");
+            span(upper, -2, 2, b.hip + 1, shade);
+            break;
+        }
+        case "standing": {
+            // A collared shirt under an apron that hangs over the thighs.
+            upper(-1, b.shoulder, "w");
+            upper(1, b.shoulder, "w");
+            upper(0, b.shoulder, "s");
+            for (const x of [-2, 2]) {
+                upper(x, b.shoulder, "S");
+                upper(x, b.shoulder - 1, "S");
+            }
+            for (let y = b.hip - 2; y <= b.shoulder - 2; y++) {
+                span(upper, -b.waist, b.waist, y, "S");
+            }
+            span(upper, -1, 1, b.hip + 1, "z");
+            break;
+        }
+        case "active": {
+            upper(0, b.shoulder, shade);
+            break;
+        }
+        case "athlete": {
+            upper(0, b.shoulder, "s");
+            span(upper, -b.chest, b.chest, b.shoulder - 2, shade);
+            break;
         }
-        put(x, 1, "o");
     }
-}
-function paintBody({ put, shape, look, gear }) {
-    const { width, top } = shape;
-    for (let y = 2; y <= top; y++) {
-        const isEdge = y === 2 || y === top;
-        span(put, isEdge ? 1 : 0, isEdge ? width - 2 : width - 1, y, y === 2 ? "o" : "O");
+    if (gear.wear === 2) {
+        // An open jacket over whatever is underneath.
+        for (let y = b.hip; y <= b.shoulder; y++) {
+            const half = halfAt(y);
+            span(upper, -half, -half + 1, y, "X");
+            span(upper, half - 1, half, y, "X");
+        }
     }
-    span(put, 1, 2, top - 1, "h");
-    if (look.goal === "loseFat") {
-        span(put, 0, width - 1, top - 1, "w");
+    if (gear.carry >= 1) {
+        // Backpack straps over both shoulders.
+        for (let y = b.shoulder - 3; y <= b.shoulder; y++) {
+            upper(-(b.chest - 1), y, "B");
+            upper(b.chest - 1, y, "B");
+        }
     }
-    else if (look.goal === "maintain") {
-        const middle = Math.floor(width / 2);
-        icon(["r.r", "rrr", ".r."], middle - 1, 6)(put, shape, 0);
+    if (gear.wear >= 1) {
+        // A scarf around the neck, its end hanging down the chest.
+        span(upper, -2, 2, b.shoulder + 1, "S");
+        upper(1, b.shoulder, "z");
+        upper(1, b.shoulder - 1, "z");
     }
-    if (gear.wear === 1) {
-        span(put, 0, width - 1, top - 5, "S");
-        put(-1, top - 5, "S");
-        put(-2, top - 6, "s");
+    if (gear.carry === 2) {
+        // A gold medal on its ribbon.
+        upper(-1, b.shoulder, "z");
+        upper(1, b.shoulder, "z");
+        upper(0, b.shoulder - 1, "z");
+        upper(0, b.shoulder - 2, "g");
     }
 }
-function paintFace({ put, shape, pose, counter }) {
-    const look = pose.look ?? 0;
-    const eyeY = shape.top - 3;
-    const eyes = [
-        Math.round(shape.width * 0.3) + look,
-        Math.round(shape.width * 0.7) - 1 + look,
-    ];
-    for (const x of eyes) {
-        if (pose.eyes === "closed") {
-            span(put, x, x + 1, eyeY, "e");
-        }
-        else if (pose.eyes === "happy") {
-            put(x - 1, eyeY, "e");
-            put(x, eyeY + 1, "e");
-            put(x + 1, eyeY, "e");
-            put(x, eyeY - 2, "r");
+function paintArms({ upper, b, look, gear, pose }) {
+    const isJacket = gear.wear === 2;
+    const [main, shade] = isJacket ? ["X", "X"] : topOf[look.style];
+    const sleeve = isJacket ? 1 : sleeveOf[look.style];
+    for (const [index, side] of [-1, 1].entries()) {
+        const joint = [side * (b.chest + 1), b.shoulder];
+        const hand = pose.hands?.[index] ?? hanging(b, side);
+        const points = pointsOf(joint, hand);
+        const covered = Math.round((points.length - 1) * sleeve);
+        const isLevel = Math.abs(hand[0] - joint[0]) > Math.abs(hand[1] - joint[1]);
+        const [thickX, thickY] = isLevel ? [0, -1] : [side, 0];
+        for (const [step, [x, y]] of points.entries()) {
+            const isHand = step === points.length - 1;
+            const isSleeve = !isHand && (step < covered || (step === 0 && sleeve > 0));
+            upper(x, y, isSleeve ? main : "s");
+            if (b.arm === 2 && step < points.length - 2) {
+                upper(x + thickX, y + thickY, isSleeve ? shade : "q");
+            }
         }
-        else {
-            put(x, eyeY, "e");
-            put(x, eyeY + 1, counter % 23 === 0 ? "O" : "e");
+        const wrist = points.at(-2);
+        if (side === 1 && gear.gadget === 2 && wrist && points.length > 2) {
+            upper(wrist[0], wrist[1], "t");
         }
     }
 }
-// Side nubs; a muscle goal makes them bigger.
-function paintArms({ put, shape, look, pose }) {
-    const size = look.goal === "buildMuscle" ? 3 : 2;
-    const [back, front] = pose.arms ?? ["down", "down"];
-    const rowOf = (arm) => ({
-        down: 3 + size - 1,
-        mid: Math.ceil(shape.height / 2) + size,
-        up: shape.top + size - 1,
-        forward: Math.ceil(shape.height / 2) + size,
-    })[arm];
-    const nub = (x, arm) => {
-        const reach = arm === "forward" ? 1 : 0;
-        for (let row = 0; row < size; row++) {
-            span(put, x + reach, x + reach + size - 1, rowOf(arm) - row, row === size - 1 ? "o" : "O");
-        }
-    };
-    nub(-size, back);
-    nub(shape.width, front);
-}
-// Gender sets an ornament at the back of the head, level the gear on top.
-function paintHead({ put, shape, look, gear, counter }) {
-    const { width, top } = shape;
-    if (look.gender === "female") {
-        icon(["r.r", "rrr", "r.r"], 0, top + 3)(put, shape, 0);
-    }
-    else if (look.gender === "male") {
-        put(1, top + 1, "O");
-        put(2, top + 2, "O");
-        put(3, top + 1, "O");
+function paintHead({ upper, b, look, gear, pose }) {
+    const { chin } = b;
+    const hair = hairKeys[look.hair];
+    const turn = pose.turn ?? 0;
+    const jaw = look.build === "heavy" ? 2 : 1;
+    span(upper, -jaw, jaw, chin, "s");
+    span(upper, -2, 2, chin + 1, "s");
+    span(upper, -2, 2, chin + 2, "s");
+    span(upper, -2, 2, chin + 3, hair);
+    span(upper, -1, 1, chin + 4, hair);
+    const eye = pose.eyes === "closed" ? "q" : "e";
+    upper(turn - 1, chin + 1, eye);
+    upper(turn + 1, chin + 1, eye);
+    let mouth = "q";
+    if (pose.mouth === "smile") {
+        mouth = "m";
+    }
+    else if (pose.mouth === "open") {
+        mouth = "e";
+    }
+    upper(turn, chin, mouth);
+    // Short hair with sideburns, a side-swept fringe, or a chin-length bob.
+    if (look.gender === "male") {
+        upper(-2, chin + 2, hair);
+        upper(2, chin + 2, hair);
+    }
+    else if (look.gender === "female") {
+        upper(-2, chin + 2, hair);
+        upper(-1, chin + 2, hair);
+        upper(2, chin + 2, hair);
     }
     else {
-        put(2, top + 1, "G");
-        put(1, top + 2, "G");
-        put(3, top + 3, "G");
+        for (const x of [-3, 3]) {
+            for (let y = chin; y <= chin + 3; y++) {
+                upper(x, y, hair);
+            }
+        }
+        upper(-2, chin + 2, hair);
+        upper(2, chin + 2, hair);
     }
     if (gear.gadget >= 1) {
-        span(put, 5, width - 2, top + 1, "k");
-        icon(["S", "S"], -1, top - 1)(put, shape, 0);
-        icon(["S", "S"], width, top - 1)(put, shape, 0);
-    }
-    if (gear.gadget === 2) {
-        put(width - 3, top + 2, "k");
-        put(width - 3, top + 3, counter % 2 === 0 ? "t" : "y");
+        // Headphones: a band over the top and a cup on each ear.
+        upper(-2, chin + 4, "k");
+        upper(2, chin + 4, "k");
+        span(upper, -1, 1, chin + 5, "k");
+        for (const x of [-3, 3]) {
+            upper(x, chin + 1, "k");
+            upper(x, chin + 2, "k");
+        }
     }
     if (gear.headwear === 1) {
-        span(put, 5, width - 3, top + 1, "S");
-        span(put, 6, width - 4, top + 2, "S");
-        span(put, width - 2, width, top + 1, "s");
+        span(upper, -1, 1, chin + 4, "S");
+        span(upper, -2, 2, chin + 3, "S");
+        span(upper, -3 + turn, 3 + turn, chin + 2, "z");
     }
     else if (gear.headwear === 2) {
-        span(put, 6, width - 3, top + 1, "g");
-        put(6, top + 2, "g");
-        put(Math.floor((width + 3) / 2), top + 2, "g");
-        put(width - 3, top + 2, "g");
-        put(Math.floor((width + 3) / 2), top + 1, "t");
-    }
-    if (gear.aura >= 1) {
-        const bob = counter % 4 < 2 ? 0 : 1;
-        put(width + 4, top + 2 + bob, "t");
-        put(width + 4, top + 3 + bob, "y");
+        span(upper, -2, 2, chin + 5, "g");
+        for (const x of [-2, 0, 2]) {
+            upper(x, chin + 6, "g");
+        }
+        upper(0, chin + 5, "t");
     }
 }
 export function paletteOf(palette) {
-    const { cloak, cloakShade, glow } = palette.sprite;
+    const { cloak, cloakShade, scarf, scarfShade, glow } = palette.sprite;
     return new Map([
-        ["c", "#5A3A25"],
+        ["A", "#121212"],
+        ["B", "#3E3226"],
+        ["b", "#6B4A2E"],
+        ["C", cloak],
+        ["c", cloakShade],
         ["D", "#50555F"],
-        ["d", "#8A8F99"],
-        ["e", "#1E1E1E"],
+        ["d", "#9AA0AA"],
+        ["e", "#2B2B2B"],
         ["F", "#C8473F"],
         ["G", "#6FA35A"],
         ["g", "#D9B45A"],
-        ["h", palette.soft],
+        ["H", "#9C9C9C"],
+        ["h", "#4A3222"],
+        ["I", "#E4E4E4"],
         ["k", "#2B2B2B"],
         ["L", "#4A505B"],
         ["l", glow],
-        ["O", palette.accent],
-        ["o", palette.deep],
+        ["m", "#B5524A"],
+        ["N", "#B59A6A"],
+        ["n", "#937B52"],
+        ["O", "#5E6B45"],
+        ["o", "#5A3A25"],
+        ["P", "#3E6870"],
+        ["p", "#33565D"],
         ["Q", "#E6E0D4"],
-        ["r", "#E87A90"],
-        ["S", cloak],
-        ["s", cloakShade],
-        ["T", "#E5533D"],
+        ["q", "#C99872"],
+        ["S", scarf],
+        ["s", "#E2B48C"],
         ["t", glow],
+        ["U", "#B4AE9F"],
+        ["V", "#4A5536"],
         ["v", "#9AA0A8"],
         ["w", "#F2F2F2"],
+        ["X", "#2F3540"],
         ["x", "#3D414B"],
         ["y", palette.soft],
-        ["z", "#C8C8C8"],
+        ["Z", "#C8C8C8"],
+        ["z", scarfShade],
     ]);
 }
 // The pixel keys of 1 frame, row by row, "." where nothing is drawn.
-export function composeScene({ activity, counter, level, look, mood, badges, width, }) {
+export function composeScene({ activity, counter, level, look, mood, width, }) {
     const canvas = Array.from({ length: stageHeight }, () => Array.from({ length: width }, () => "."));
-    const plain = (column, y, key) => {
-        const row = canvas[stageHeight - 1 - y];
+    const scene = sceneOf(activity, counter, width, mood);
+    const b = bodyOf(look);
+    const pose = scene.pose(b);
+    const lift = pose.lift ?? 0;
+    // The character's x = 0 is its center column, mirrored when facing left.
+    const plant = (rise) => (x, y, key) => {
+        const column = scene.x + scene.facing * x;
+        const row = canvas[stageHeight - 1 - (y + rise)];
         if (row && column >= 0 && column < width && key !== ".") {
             row[column] = key;
         }
     };
-    const baseShape = shapeOf(look, level);
-    const scene = sceneOf(activity, counter, width, baseShape, mood);
-    const shape = shapeOf(look, level, scene.pose.squash ?? 0);
-    const lift = scene.pose.lift ?? 0;
-    // Local x runs from the body's left edge toward where the pet faces.
-    const put = (x, y, key) => {
-        const column = scene.facing === 1 ? scene.x + x : scene.x + baseShape.width - 1 - x;
-        plain(column, y + lift, key);
-    };
+    const put = plant(lift);
+    const upper = plant(lift - (pose.bob ?? 0));
     const paint = {
         put,
-        shape,
+        upper,
+        b,
         look,
         gear: gearOf(level),
-        pose: scene.pose,
+        pose,
         counter,
     };
-    paintBehind(paint);
+    paintShadow(plant(0), b, lift);
+    paintHairBehind(paint);
     paintLegs(paint);
-    paintBody(paint);
-    paintFace(paint);
+    paintTorso(paint);
     paintArms(paint);
     paintHead(paint);
     for (const draw of scene.props ?? []) {
-        draw(put, shape, counter);
-    }
-    // Today's badges float in the top right corner, whatever the pet does.
-    const icons = [
-        badges.focus ? ["GGG", "TTT", "TTT"] : undefined,
-        badges.meal ? [".G.", "FFF", ".F."] : undefined,
-        badges.workout ? ["D.D", "DdD", "D.D"] : undefined,
-    ].filter((rows) => rows !== undefined);
-    for (const [index, rows] of icons.entries()) {
-        icon(rows, width - 4 - index * 4, stageHeight - 2)(plain, shape, 0);
+        draw(put, upper, b);
     }
     return canvas.map((row) => row.join(""));
 }