soja-cli 1.4.0

package/dist/ui/mascot/scenes/deadline.js

@@ -0,0 +1,125 @@
+import { blink, drawGround, mirror, rng, soilLine, withFace } from '../engine.js';
+const W = 78;
+const H = 13;
+const G = 11;
+const RUN_A = [' .-.  ', '(o.o)=', '(   ) ', " / \\  "];
+const RUN_B = [' .-.  ', '(o.o)=', '(   ) ', "  |\\  "];
+const TYPE_A = [' .-.  ', '(o.o) ', '(   )/'];
+const TYPE_B = [' .-.  ', '(o.o) ', '(   )\\'];
+export const deadline = {
+    id: 'deadline',
+    title: 'Contra reloj',
+    useFor: 'Tareas vencidas o por vencer',
+    width: W,
+    height: H,
+    create(seed = 10) {
+        const r = rng(seed);
+        const soil = [soilLine(W, r)];
+        const runners = [
+            { x: 24, v: 0.9, n: 1 },
+            { x: 50, v: -1.1, n: 2 },
+            { x: 66, v: -0.8, n: 3 },
+        ];
+        let t = 0;
+        let secs = 59;
+        let delivered = 0;
+        let doneT = 0;
+        let papers = [];
+        let sweat = [];
+        let taps = 0;
+        return {
+            step() {
+                t++;
+                if (doneT) {
+                    doneT--;
+                    if (!doneT)
+                        secs = 59;
+                }
+                else {
+                    if (t % 5 === 0)
+                        secs--;
+                    if (secs <= 0) {
+                        secs = 0;
+                        doneT = 30;
+                        delivered++;
+                    }
+                }
+                const speedUp = !doneT && secs < 15 ? 1.4 : 1;
+                for (const a of runners) {
+                    if (doneT)
+                        continue;
+                    a.x += a.v * speedUp;
+                    if (a.x < 22 || a.x > W - 7) {
+                        a.v = -a.v;
+                        a.x = Math.max(22, Math.min(W - 7, a.x));
+                        if (r() < 0.6)
+                            papers.push({ x: a.x + 3, y: G - 3, vx: (r() - 0.5) * 1.2, vy: -0.6, ch: '▭', tone: 'paper' });
+                    }
+                    if (t % 6 === a.n)
+                        sweat.push({ x: a.x + (a.v > 0 ? 0 : 5), y: G - 4, vx: -Math.sign(a.v) * 0.4, vy: -0.3, ch: "'", tone: 'water' });
+                }
+                if (!doneT)
+                    taps++;
+                for (const p of papers) {
+                    p.x += p.vx;
+                    p.y += p.vy;
+                    p.vy += 0.06;
+                    p.vx *= 0.97;
+                }
+                papers = papers.filter((p) => p.y < G);
+                for (const s of sweat) {
+                    s.x += s.vx;
+                    s.y += s.vy;
+                    s.vy += 0.1;
+                }
+                sweat = sweat.filter((s) => s.y < G);
+            },
+            draw(c) {
+                drawGround(c, G, soil);
+                const urgent = !doneT && secs < 15;
+                const clockTone = doneT ? 'good' : urgent && t % 6 < 3 ? 'bad' : 'text';
+                c.put(29, 0, ' .--------------. ', 'rock');
+                c.put(29, 1, ' |              | ', 'rock');
+                c.put(29, 2, " '--------------' ", 'rock');
+                c.put(doneT ? 33 : 34, 1, doneT ? 'entregado!' : `23:59:${String(secs).padStart(2, '0')}`, clockTone);
+                if (urgent) {
+                    c.put(26, 1, '!!', 'bad');
+                    c.put(49, 1, '!!', 'bad');
+                }
+                c.put(1, G - 3, '▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄', 'wood');
+                c.put(2, G - 2, '||', 'wood');
+                c.put(2, G - 1, '||', 'wood');
+                c.put(13, G - 2, '||', 'wood');
+                c.put(13, G - 1, '||', 'wood');
+                c.put(9, G - 6, '.----.', 'rock');
+                c.put(9, G - 5, '|' + (doneT ? ' ok ' : '#'.repeat(Math.floor(t / 2) % 5).padEnd(4, '_')) + '|', doneT ? 'good' : 'accent');
+                c.put(9, G - 4, "'----'", 'rock');
+                c.put(9, G - 5, '|', 'rock');
+                c.put(14, G - 5, '|', 'rock');
+                c.sprite(3, G - 6, withFace(taps % 2 ? TYPE_A : TYPE_B, doneT ? '^.^' : urgent ? '>.<' : 'O.O'), 'agent');
+                if (!doneT && t % 4 < 2)
+                    c.put(7, G - 7, 'tap', 'cloud');
+                c.put(16, G - 4, '▭▭', 'paper');
+                c.put(16, G - 5, '▭', 'paper');
+                runners.forEach((a, i) => {
+                    const face = doneT ? '^.^' : urgent ? '>.<' : blink(t, i, 'O.O');
+                    let sp = doneT ? [' .-. ', '(o.o)', '(   )', " ' ' "] : Math.floor(t / 2) % 2 ? RUN_A : RUN_B;
+                    if (a.v < 0 && !doneT)
+                        sp = mirror(sp);
+                    c.sprite(a.x, G - 4, withFace(sp, face), 'agent');
+                    if (!doneT)
+                        c.put(a.v > 0 ? a.x + 6 : a.x - 1, G - 3, '▭', 'paper');
+                });
+                if (doneT && t % 8 < 5)
+                    c.put(40, G - 6, '(lo logramos!)', 'good');
+                for (const p of papers)
+                    c.put(p.x, p.y, p.ch, p.tone);
+                for (const s of sweat)
+                    c.put(s.x, s.y, s.ch, s.tone);
+            },
+            status() {
+                return doneT ? `entregado a tiempo · ${delivered} entregas` : `vence en ${secs}s · ${delivered} entregas`;
+            },
+        };
+    },
+};

package/dist/ui/mascot/scenes/empty.js

@@ -0,0 +1,149 @@
+/* eslint-disable prefer-const -- the bird list is mutated in place by the scene engine. */
+import { blink, drawCloud, rng, soilLine, withFace } from '../engine.js';
+const W = 78;
+const H = 12;
+const WATER_Y = 8;
+const SHORE = 30;
+const DOCK_L = 28;
+const DOCK_R = 50;
+const FISHER_X = 43;
+const TREE = ['  .--.  ', ' (    ) ', '(  ~   )', " '-..-' "];
+const SIT_ROD = [' .-.  ', '(o.o)/', '(___) '];
+const SIT_PULL = [' .-. |', '(o.o)|', '(___) '];
+export const empty = {
+    id: 'empty',
+    title: 'Pescando',
+    useFor: 'Lista vacía / sin tareas pendientes',
+    width: W,
+    height: H,
+    create(seed = 9) {
+        const r = rng(seed);
+        const soil = [soilLine(SHORE, r), soilLine(SHORE, r), soilLine(SHORE, r)];
+        let t = 0;
+        let fish = 0;
+        let boots = 0;
+        let phase = 'wait';
+        let k = 0;
+        let waitFor = 50;
+        let catchKind = 'fish';
+        let flying = null;
+        let happy = 0;
+        let zs = [];
+        let weed = -10;
+        let birds = [{ x: 70, y: 1 }];
+        return {
+            step() {
+                t++;
+                k++;
+                if (phase === 'wait' && k > waitFor) {
+                    phase = 'bite';
+                    k = 0;
+                }
+                else if (phase === 'bite' && k > 10) {
+                    phase = 'pull';
+                    k = 0;
+                    catchKind = r() < 0.7 ? 'fish' : 'boot';
+                    flying = { x: FISHER_X + 9, y: WATER_Y, vx: -0.9, vy: -0.9, ch: catchKind === 'fish' ? '><>' : '_|', tone: catchKind === 'fish' ? 'water' : 'wood' };
+                }
+                else if (phase === 'pull' && k > 14) {
+                    phase = 'wait';
+                    k = 0;
+                    waitFor = 40 + Math.floor(r() * 50);
+                    if (catchKind === 'fish')
+                        fish++;
+                    else
+                        boots++;
+                    happy = 16;
+                    flying = null;
+                }
+                if (flying) {
+                    flying.x += flying.vx;
+                    flying.y += flying.vy;
+                    flying.vy += 0.14;
+                    if (flying.y > WATER_Y - 2)
+                        flying.y = WATER_Y - 2;
+                }
+                if (happy)
+                    happy--;
+                if (t % 16 === 0)
+                    zs.push({ x: 8, y: WATER_Y - 3, l: 0 });
+                for (const z of zs) {
+                    z.l++;
+                    z.y -= 0.15;
+                    z.x += 0.1;
+                }
+                zs = zs.filter((z) => z.l < 20);
+                weed += 0.4;
+                if (weed > SHORE + 6)
+                    weed = -30 - r() * 40;
+                for (const b of birds) {
+                    b.x -= 0.25;
+                    if (b.x < -4) {
+                        b.x = W + r() * 20;
+                        b.y = 1 + Math.floor(r() * 3);
+                    }
+                }
+            },
+            draw(c) {
+                drawCloud(c, t, 0.04, 30, 0);
+                for (let x = 0; x < SHORE; x++)
+                    c.set(x, WATER_Y, '▀', 'soil');
+                soil.forEach((l, i) => c.put(0, WATER_Y + 1 + i, l, 'soil'));
+                for (let y = WATER_Y; y < H; y++) {
+                    for (let x = SHORE; x < W; x++) {
+                        const v = (x + y * 3 + Math.floor(t / 3)) % 7;
+                        c.put(x, y, y === WATER_Y ? (v < 3 ? '~' : '-') : v === 0 ? '~' : ' ', 'water');
+                    }
+                }
+                c.sprite(1, WATER_Y - 7, TREE, 'leaf');
+                c.put(4, WATER_Y - 3, '||', 'wood');
+                c.put(4, WATER_Y - 2, '||', 'wood');
+                c.put(4, WATER_Y - 1, '||', 'wood');
+                c.put(7, WATER_Y - 2, ' .-.____ ', 'agent');
+                c.put(7, WATER_Y - 1, '(-.-_____)', 'agent');
+                for (const z of zs)
+                    c.put(z.x, z.y, z.l < 8 ? 'z' : 'Z', 'cloud');
+                if (weed > -3)
+                    c.put(weed, WATER_Y - 1, '@', 'dirt');
+                for (let x = DOCK_L; x <= DOCK_R; x++)
+                    c.put(x, WATER_Y - 1, '=', 'wood');
+                for (const px of [DOCK_L + 3, DOCK_R - 2])
+                    for (let y = WATER_Y; y < H - 1; y++)
+                        c.put(px, y, '|', 'wood');
+                c.put(FISHER_X - 7, WATER_Y - 2, '\\_/', 'rock');
+                if (fish)
+                    c.put(FISHER_X - 6, WATER_Y - 3, '>', 'water');
+                const face = happy ? (catchKind === 'fish' ? '^.^' : '-_-') : phase === 'bite' ? 'O.O' : blink(t, 1);
+                const pulling = phase === 'pull';
+                c.sprite(FISHER_X, WATER_Y - 4, withFace(pulling ? SIT_PULL : SIT_ROD, face), 'agent');
+                if (pulling) {
+                    c.put(FISHER_X + 5, WATER_Y - 6, '|', 'wood');
+                    c.put(FISHER_X + 5, WATER_Y - 7, '.', 'wood');
+                }
+                else {
+                    c.put(FISHER_X + 6, WATER_Y - 5, '/', 'wood');
+                    c.put(FISHER_X + 7, WATER_Y - 6, '/', 'wood');
+                    c.put(FISHER_X + 8, WATER_Y - 7, '.', 'wood');
+                    for (let y = WATER_Y - 6; y < WATER_Y; y++)
+                        c.put(FISHER_X + 9, y, ':', 'cloud');
+                    const bob = phase === 'bite' ? (t % 4 < 2 ? 1 : 0) : Math.floor(t / 8) % 2 ? 0 : 0;
+                    c.put(FISHER_X + 9, WATER_Y + bob, 'o', 'fire');
+                    if (phase === 'bite') {
+                        c.put(FISHER_X + 8, WATER_Y, '(', 'water');
+                        c.put(FISHER_X + 10, WATER_Y, ')', 'water');
+                        c.put(FISHER_X + 1, WATER_Y - 6, '!', 'spark');
+                    }
+                }
+                if (flying)
+                    c.put(flying.x, flying.y, flying.ch, flying.tone);
+                if (happy && t % 6 < 4)
+                    c.put(FISHER_X - 2, WATER_Y - 6, catchKind === 'fish' ? '(uno más!)' : '(una bota?)', 'cloud');
+                for (const b of birds)
+                    c.put(b.x, b.y, Math.floor(t / 4) % 2 ? 'v' : '-v-', 'cloud');
+            },
+            status() {
+                return `sin tareas pendientes · peces ${fish} · botas ${boots}`;
+            },
+        };
+    },
+};

package/dist/ui/mascot/scenes/fire.js

@@ -0,0 +1,138 @@
+/* eslint-disable @typescript-eslint/no-non-null-assertion, prefer-const -- scene arrays are indexed within bounds; particle arrays are mutated in place. */
+import { blink, drawCloud, drawGround, rng, soilLine, withFace } from '../engine.js';
+const W = 78;
+const H = 13;
+const G = 11;
+const HOUSE_X = 60;
+const PASS = [8, 15, 22, 29, 36, 43];
+const THROWER = 50;
+const REACH_L = ['  .-. ', ' (o.o)', '_(   )', "  ' ' "];
+const REACH_R = [' .-.  ', '(o.o) ', '(   )_', " ' '  "];
+const THROW = [' .-.  /', '(o.o)/ ', '(   )  ', " ' '   "];
+const WELL = ['  ___  ', ' /___\\ ', '  | |  ', ' [   ] ', ' [___] '];
+const HOUSE = ['    ____    ', '   /    \\   ', '  /______\\  ', '  |[]  []|  ', '  |  __  |  ', '  |_|  |_|  '];
+export const fire = {
+    id: 'fire',
+    title: 'Apagando incendio',
+    useFor: 'Tareas urgentes / incidente crítico',
+    width: W,
+    height: H,
+    create(seed = 5) {
+        const r = rng(seed);
+        const soil = [soilLine(W, r)];
+        let t = 0;
+        let I = 10;
+        let outT = 0;
+        let throwT = 0;
+        let thrown = 0;
+        let buckets = [];
+        let water = [];
+        let smoke = [];
+        let flames = [];
+        return {
+            step() {
+                t++;
+                if (t % 16 === 0)
+                    buckets.push({ x: 6 });
+                for (const b of buckets)
+                    b.x += 0.5;
+                if (buckets.length && buckets[0].x >= THROWER - 1) {
+                    buckets.shift();
+                    if (I > 0) {
+                        throwT = 8;
+                        thrown++;
+                        for (let i = 0; i < 6; i++) {
+                            water.push({ x: THROWER + 6, y: G - 4, vx: 0.75 + r() * 0.35, vy: -0.55 - r() * 0.25, ch: "'.:"[i % 3], tone: 'water' });
+                        }
+                    }
+                }
+                if (throwT)
+                    throwT--;
+                for (const p of water) {
+                    p.x += p.vx;
+                    p.y += p.vy;
+                    p.vy += 0.1;
+                }
+                water = water.filter((p) => {
+                    if (p.x >= HOUSE_X + 2 && p.x <= HOUSE_X + 12 && I > 0) {
+                        I = Math.max(0, I - 0.25);
+                        smoke.push({ x: p.x, y: p.y, l: 0, steam: true });
+                        return false;
+                    }
+                    return p.y < G && p.x < W;
+                });
+                if (I > 0) {
+                    I = Math.min(10, I + 0.03);
+                    outT = 0;
+                    if (t % 3 === 0)
+                        smoke.push({ x: HOUSE_X + 2 + r() * 8, y: G - 2 - I * 0.6, l: 0 });
+                }
+                else {
+                    outT++;
+                    if (outT < 40 && t % 4 === 0)
+                        smoke.push({ x: HOUSE_X + 2 + r() * 8, y: G - 2, l: 0 });
+                    if (outT > 70)
+                        I = 2;
+                }
+                for (const s of smoke) {
+                    s.l++;
+                    s.y -= 0.2;
+                    s.x += 0.1 + Math.sin((s.l + s.x) * 0.4) * 0.1;
+                }
+                smoke = smoke.filter((s) => s.l < (s.steam ? 8 : 26) && s.y > -1);
+                flames = [];
+                for (let col = 0; col < 10; col++) {
+                    flames.push(Math.max(0, Math.round(I * 0.7 * (0.55 + 0.45 * Math.sin(t * 0.7 + col * 1.3)) + (r() - 0.5) * 1.4)));
+                }
+            },
+            draw(c) {
+                drawCloud(c, t, 0.05, 0, 0);
+                drawGround(c, G, soil);
+                c.sprite(0, G - 5, WELL, 'rock');
+                c.put(2, G - 2, '~~~', 'water');
+                c.sprite(HOUSE_X, G - 6, HOUSE, 'wood');
+                if (I > 0) {
+                    flames.forEach((h, col) => {
+                        const x = HOUSE_X + 2 + col;
+                        for (let k = 0; k < h; k++) {
+                            const top = k === h - 1;
+                            const ch = top ? "^'^"[(t + x) % 3] : k < 2 ? 'wWw'[(t + x + k) % 3] : ')(('[(t + x + k) % 3];
+                            c.put(x, G - 1 - k, ch, top || k > h * 0.6 ? 'flame' : 'fire');
+                        }
+                    });
+                }
+                const hot = I > 6;
+                const out = I <= 0;
+                PASS.forEach((x, i) => {
+                    const cx = x + 2.5;
+                    const b = buckets.find((b) => b.x + 1.5 > cx - 6 && b.x + 1.5 < cx + 4);
+                    const pose = b && b.x + 1.5 < cx ? REACH_L : REACH_R;
+                    c.sprite(x, G - 4, withFace(pose, out ? '^.^' : hot ? blink(t, i, '>.<') : blink(t, i)), 'agent');
+                });
+                for (const b of buckets) {
+                    c.put(b.x, G - 2, '\\_/', 'rock');
+                    c.put(b.x + 1, G - 3, '~', 'water');
+                }
+                c.sprite(THROWER, G - 4, withFace(throwT > 3 ? THROW : REACH_R, out ? '^.^' : hot ? '>.<' : blink(t, 9)), 'agent');
+                if (throwT > 3)
+                    c.put(THROWER + 6, G - 5, '\\~/', 'water');
+                if (hot && Math.floor(t / 20) % 2)
+                    c.put(7, G - 5, '(agua!)', 'cloud');
+                if (out) {
+                    c.put(14, G - 5, '(uf!)', 'cloud');
+                    c.put(35, G - 5, '(listo)', 'cloud');
+                    if (t % 10 < 6)
+                        c.put(HOUSE_X + 5, G - 8, 'ok', 'good');
+                }
+                for (const p of water)
+                    c.put(p.x, p.y, p.ch, p.tone);
+                for (const s of smoke)
+                    c.put(s.x, s.y, s.steam ? '~' : s.l < 8 ? '.' : s.l < 16 ? 'o' : 'O', 'cloud');
+            },
+            status() {
+                const lv = Math.ceil(I / 2);
+                return `fuego ${'▮'.repeat(lv)}${'▯'.repeat(5 - lv)} · baldes ${thrown}${I <= 0 ? ' · apagado' : ''}`;
+            },
+        };
+    },
+};

package/dist/ui/mascot/scenes/index.js

@@ -0,0 +1,25 @@
+import { working } from './working.js';
+import { resting } from './resting.js';
+import { clockIn } from './clockIn.js';
+import { planning } from './planning.js';
+import { fire } from './fire.js';
+import { celebrate } from './celebrate.js';
+import { syncing } from './syncing.js';
+import { bugHunt } from './bugHunt.js';
+import { empty } from './empty.js';
+import { deadline } from './deadline.js';
+import { cleaning } from './cleaning.js';
+export const SCENES = {
+    working,
+    resting,
+    clockIn,
+    planning,
+    fire,
+    celebrate,
+    syncing,
+    bugHunt,
+    empty,
+    deadline,
+    cleaning,
+};
+export const SCENE_IDS = Object.keys(SCENES);

package/dist/ui/mascot/scenes/planning.js

@@ -0,0 +1,73 @@
+/* eslint-disable @typescript-eslint/no-non-null-assertion -- scene arrays are indexed within their declared bounds. */
+import { blink, drawGround, rng, soilLine, withFace } from '../engine.js';
+const W = 78;
+const H = 12;
+const G = 10;
+const BX = 46;
+const VALS = [3, 3, 3, 2, 3, 2, 2, 2, 1, 2, 1, 1, 1, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0];
+const IDEAS = ['( ? )', '( ! )', '(...)', '( % )', '(ok!)'];
+const SEATED = [' .-. ', '(o.o)', '(   )'];
+const POINT_UP = [' .-.   ', '(o.o) /', '(   )/ ', " ' '   "];
+const POINT_SIDE = [' .-.   ', '(o.o)  ', '(   )--', " ' '   "];
+export const planning = {
+    id: 'planning',
+    title: 'Analizando planes',
+    useFor: 'Planificación / revisión de sprint',
+    width: W,
+    height: H,
+    create(seed = 4) {
+        const r = rng(seed);
+        const soil = [soilLine(W, r)];
+        let t = 0;
+        const cycle = () => Math.floor(t / 3) % (VALS.length + 20);
+        return {
+            step() {
+                t++;
+            },
+            draw(c) {
+                drawGround(c, G, soil);
+                c.put(BX, 0, ' ' + '_'.repeat(30), 'rock');
+                for (let y = 1; y < 7; y++)
+                    c.put(BX, y, '|' + ' '.repeat(30) + '|', 'rock');
+                c.put(BX, 7, '|' + '_'.repeat(30) + '|', 'rock');
+                c.put(BX + 4, 8, '/', 'rock');
+                c.put(BX + 3, 9, '/', 'rock');
+                c.put(BX + 27, 8, '\\', 'rock');
+                c.put(BX + 28, 9, '\\', 'rock');
+                c.put(BX + 2, 1, 'plan v2', 'text');
+                for (let y = 2; y < 6; y++)
+                    c.put(BX + 3, y, '|', 'cloud');
+                c.put(BX + 3, 6, '+' + '-'.repeat(26), 'cloud');
+                const n = cycle();
+                const done = n >= VALS.length;
+                const shown = Math.min(n, VALS.length);
+                for (let i = 0; i < shown; i++)
+                    c.put(BX + 5 + i, 2 + VALS[i], i === shown - 1 ? '*' : '.', 'accent');
+                if (done && t % 10 < 6)
+                    c.put(BX + 30, 1, '!', 'good');
+                [11, 20, 29].forEach((x, i) => {
+                    const face = done ? '^.^' : i === 1 ? blink(t, 7, '-.o') : blink(t, 8 + i);
+                    c.sprite(x, G - 6, withFace(SEATED, face), 'agent');
+                    if (Math.floor((t + i * 17) / 22) % 3 < 2) {
+                        c.put(x - 1, G - 8, IDEAS[(Math.floor(t / 66) + i) % 5], 'cloud');
+                        c.put(x + 3, G - 7, 'o', 'cloud');
+                    }
+                });
+                c.put(16, G - 4, 'c[]', 'paper');
+                c.put(17 + ((t >> 3) % 2), G - 5, '~', 'cloud');
+                c.put(25, G - 4, '[=]', 'accent');
+                c.put(8, G - 3, '▄'.repeat(31), 'wood');
+                for (const lx of [9, 36]) {
+                    c.put(lx, G - 2, '||', 'wood');
+                    c.put(lx, G - 1, '||', 'wood');
+                }
+                const pose = Math.floor(t / 20) % 2 ? POINT_UP : POINT_SIDE;
+                c.sprite(39, G - 4, withFace(pose, done ? '^.^' : blink(t, 11)), 'agent');
+            },
+            status() {
+                const n = cycle();
+                return n >= VALS.length ? 'plan aprobado' : `analizando · ${Math.round((n / VALS.length) * 100)}%`;
+            },
+        };
+    },
+};

package/dist/ui/mascot/scenes/resting.js

@@ -0,0 +1,90 @@
+import { AGENT, blink, drawCloud, drawGround, mirror, rng, soilLine, withFace } from '../engine.js';
+const W = 78;
+const H = 12;
+const G = 10;
+const TREE = ['   .--~~--.  ', ' .(  ~   ~ ). ', '(  ~   ~   ~ )', " '-.______.-' "];
+const STRETCH = ['\\ .-. /', ' (o.O) ', ' (   ) ', "  ' '  "];
+const COFFEE = [' .-.    ', '(o.o)c[]', '(___)   '];
+export const resting = {
+    id: 'resting',
+    title: 'Descansando',
+    useFor: 'Sin actividad / en pausa',
+    width: W,
+    height: H,
+    create(seed = 2) {
+        const r = rng(seed);
+        const soil = [soilLine(W, r)];
+        let t = 0;
+        let zs = [];
+        let leaves = [];
+        return {
+            step() {
+                t++;
+                const sw = Math.floor(t / 10) % 2;
+                if (t % 14 === 0)
+                    zs.push({ x: 11, y: G - 3, l: 0 });
+                if (t % 18 === 5)
+                    zs.push({ x: 39 + sw, y: G - 6, l: 0 });
+                if (t % 25 === 0)
+                    leaves.push({ x: 1 + r() * 11, y: 5 });
+                for (const z of zs) {
+                    z.l++;
+                    z.y -= 0.15;
+                    z.x += 0.12;
+                }
+                zs = zs.filter((z) => z.l < 22);
+                for (const l of leaves) {
+                    l.y += 0.12;
+                    l.x += Math.sin(l.y * 2) * 0.3;
+                }
+                leaves = leaves.filter((l) => l.y < G - 0.5);
+            },
+            draw(c) {
+                drawCloud(c, t, 0.05, 10, 0);
+                drawGround(c, G, soil);
+                c.put(73, 0, '\\ | /', 'spark');
+                c.put(73, 1, '- O -', 'spark');
+                c.put(73, 2, '/ | \\', 'spark');
+                c.sprite(0, 2, TREE, 'leaf');
+                for (let y = 6; y < G; y++)
+                    c.put(6, y, '||', 'wood');
+                c.put(10, G - 2, ' .-.____ ', 'agent');
+                c.put(10, G - 1, '(-.-_____)', 'agent');
+                const sip = t % 50 < 8;
+                c.sprite(21, G - 3, withFace(COFFEE, sip ? '^.^' : blink(t, 1)), 'agent');
+                c.put(26, G - 2, 'c[]', 'paper');
+                c.put(27 + ((t >> 3) % 2), G - 3, '~', 'cloud');
+                const sw = Math.floor(t / 10) % 2;
+                for (let y = G - 5; y < G; y++) {
+                    c.put(33, y, '|', 'wood');
+                    c.put(49, y, '|', 'wood');
+                }
+                c.put(34, G - 4, '\\', 'wood');
+                c.put(48, G - 4, '/', 'wood');
+                c.put(35, G - 3, '\\___________/', 'wood');
+                c.put(38 + sw, G - 5, ' .-.___', 'agent');
+                c.put(38 + sw, G - 4, '(-.-___)', 'agent');
+                if (Math.floor(t / 24) % 3 === 0)
+                    c.sprite(53, G - 4, STRETCH, 'agent');
+                else
+                    c.sprite(54, G - 4, withFace(AGENT.stand, blink(t, 2)), 'agent');
+                const ph = Math.floor(t / 15) % 4;
+                c.sprite(62, G - 3, withFace(AGENT.sit, blink(t, 3)), 'agent');
+                c.sprite(68, G - 3, withFace(mirror(AGENT.sit), ph === 1 ? '^.^' : blink(t, 4)), 'agent');
+                if (ph === 0)
+                    c.put(61, G - 4, '(bla)', 'cloud');
+                if (ph === 1)
+                    c.put(67, G - 4, '(jaja)', 'cloud');
+                if (ph === 2)
+                    c.put(61, G - 4, '(...)', 'cloud');
+                for (const z of zs)
+                    c.put(z.x, z.y, z.l < 8 ? 'z' : 'Z', 'cloud');
+                for (const l of leaves)
+                    c.put(l.x, l.y, ',', 'leaf');
+            },
+            status() {
+                return 'en pausa · recargando energía';
+            },
+        };
+    },
+};