soja-cli 1.4.0

package/dist/ui/mascot/engine.js

@@ -0,0 +1,146 @@
+/* eslint-disable @typescript-eslint/no-non-null-assertion -- canvas operations validate coordinates before writing. */
+/**
+ * Motor de escenas ASCII, sin dependencias.
+ * Una escena dibuja en un Canvas de celdas (carácter + tono) y el renderer
+ * (Ink, ANSI o navegador) traduce cada tono a un color.
+ */
+export class Canvas {
+    width;
+    height;
+    chars;
+    tones;
+    constructor(width, height) {
+        this.width = width;
+        this.height = height;
+        this.chars = new Array(width * height).fill(' ');
+        this.tones = new Array(width * height).fill(null);
+    }
+    /** Escribe un texto; los espacios son transparentes. */
+    put(x, y, text, tone = null) {
+        const rx = Math.round(x);
+        const ry = Math.round(y);
+        if (ry < 0 || ry >= this.height)
+            return;
+        for (let i = 0; i < text.length; i++) {
+            const ch = text[i];
+            const cx = rx + i;
+            if (ch === ' ' || cx < 0 || cx >= this.width)
+                continue;
+            this.chars[ry * this.width + cx] = ch;
+            this.tones[ry * this.width + cx] = tone;
+        }
+    }
+    /** Escribe un solo carácter, aunque sea un espacio (sirve para borrar). */
+    set(x, y, ch, tone = null) {
+        const rx = Math.round(x);
+        const ry = Math.round(y);
+        if (rx < 0 || rx >= this.width || ry < 0 || ry >= this.height)
+            return;
+        this.chars[ry * this.width + rx] = ch;
+        this.tones[ry * this.width + rx] = tone;
+    }
+    /** Dibuja un sprite de varias líneas con la parte superior en `top`. */
+    sprite(x, top, lines, tone) {
+        lines.forEach((line, i) => this.put(x, top + i, line, tone));
+    }
+    /** Filas agrupadas en segmentos del mismo tono, listas para renderizar. */
+    rows() {
+        const out = [];
+        for (let y = 0; y < this.height; y++) {
+            const row = [];
+            let tone;
+            let buf = '';
+            for (let x = 0; x < this.width; x++) {
+                const i = y * this.width + x;
+                const t = this.chars[i] === ' ' ? null : this.tones[i];
+                if (t !== tone && buf) {
+                    row.push({ text: buf, tone: tone ?? null });
+                    buf = '';
+                }
+                tone = t;
+                buf += this.chars[i];
+            }
+            if (buf)
+                row.push({ text: buf, tone: tone ?? null });
+            out.push(row);
+        }
+        return out;
+    }
+    toString() {
+        const lines = [];
+        for (let y = 0; y < this.height; y++) {
+            lines.push(this.chars.slice(y * this.width, (y + 1) * this.width).join(''));
+        }
+        return lines.join('\n');
+    }
+}
+/* ---------- utilidades compartidas ---------- */
+/** PRNG determinista (mulberry32) para que cada escena sea reproducible. */
+export function rng(seed = 1) {
+    let a = seed >>> 0;
+    return () => {
+        a = (a + 0x6d2b79f5) >>> 0;
+        let t = a;
+        t = Math.imul(t ^ (t >>> 15), t | 1);
+        t ^= t + Math.imul(t ^ (t >>> 7), t | 61);
+        return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+    };
+}
+const MIRROR = {
+    '/': '\\',
+    '\\': '/',
+    '[': ']',
+    ']': '[',
+    '(': ')',
+    ')': '(',
+    '<': '>',
+    '>': '<',
+};
+/** Voltea un sprite horizontalmente. */
+export function mirror(lines) {
+    const w = Math.max(...lines.map((l) => l.length));
+    return lines.map((l) => l
+        .padEnd(w)
+        .split('')
+        .reverse()
+        .map((c) => MIRROR[c] ?? c)
+        .join(''));
+}
+/** Sustituye la cara `o.o` del sprite. */
+export function withFace(lines, face) {
+    return lines.map((l) => l.replace('o.o', face));
+}
+/** Cara con parpadeo ocasional, desfasado por agente. */
+export function blink(t, i, face = 'o.o') {
+    return (t + i * 37) % 70 < 2 ? '-.-' : face;
+}
+export function soilLine(width, r) {
+    let s = '';
+    for (let i = 0; i < width; i++) {
+        const q = r();
+        s += q < 0.08 ? '.' : q < 0.12 ? ':' : q < 0.15 ? "'" : ' ';
+    }
+    return s;
+}
+export function drawGround(c, groundY, soil) {
+    for (let x = 0; x < c.width; x++)
+        c.set(x, groundY, '▀', 'soil');
+    soil.forEach((line, i) => c.put(0, groundY + 1 + i, line, 'soil'));
+}
+export function drawCloud(c, t, speed, offset, y, big = true) {
+    const x = ((t * speed + offset) % (c.width + 14)) - 12;
+    if (big) {
+        c.put(x, y, '  .--.', 'cloud');
+        c.put(x, y + 1, '.(    ).', 'cloud');
+    }
+    else {
+        c.put(x, y, ' .-. ', 'cloud');
+        c.put(x, y + 1, '(   )', 'cloud');
+    }
+}
+/** Sprites base del agente (5 de ancho, cara `o.o`). */
+export const AGENT = {
+    stand: [' .-. ', '(o.o)', '(   )', " ' ' "],
+    walk: [' .-. ', '(o.o)', '(   )', "  ' '"],
+    sit: [' .-. ', '(o.o)', '(___)'],
+};

package/dist/ui/mascot/index.js

@@ -0,0 +1,6 @@
+export { AgentScene } from './AgentScene.js';
+export { SCENES, SCENE_IDS } from './scenes/index.js';
+export { TASK_STATE_SCENES, sceneForState } from './states.js';
+export { defaultPalette } from './palette.js';
+export { frameToAnsi, frameToText } from './ansi.js';
+export { Canvas } from './engine.js';

package/dist/ui/mascot/palette.js

@@ -0,0 +1,18 @@
+export const defaultPalette = {
+    agent: '#D85A30',
+    rock: '#9A9893',
+    soil: '#6B6A66',
+    dirt: '#C8913A',
+    spark: '#F2C14E',
+    fire: '#E24B4A',
+    flame: '#F2A93B',
+    water: '#4FA3E0',
+    good: '#63B34A',
+    bad: '#E24B4A',
+    accent: '#5AA9E6',
+    cloud: '#7D7C77',
+    wood: '#A9743F',
+    paper: '#E8E6DF',
+    leaf: '#5FAE54',
+    text: '#CFCDC6',
+};

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

@@ -0,0 +1,115 @@
+import { blink, drawGround, mirror, rng, soilLine, withFace } from '../engine.js';
+const W = 78;
+const H = 12;
+const G = 10;
+const BUG_A = [' \\  / ', '=(oo)=', ' /  \\ '];
+const BUG_B = [' /  \\ ', '=(oo)=', ' \\  / '];
+const NET_UP = [' .-. (@)', '(o.o)/  ', '(   )   ', " ' '    "];
+const NET_DOWN = [' .-.    ', '(o.o)   ', '(   )\\  ', " ' ' (@)"];
+const MAGNIFY = [' .-.   ', '(o.o)  ', '(   )-O', " ' '   "];
+const SCARED = ['\\.-./', '(O.O)', '(   )', " ' ' "];
+const CRATE_X = 36;
+export const bugHunt = {
+    id: 'bugHunt',
+    title: 'Cazando bugs',
+    useFor: 'Errores / tareas bloqueadas',
+    width: W,
+    height: H,
+    create(seed = 8) {
+        const r = rng(seed);
+        const soil = [soilLine(W, r)];
+        let t = 0;
+        let bx = 60;
+        let bv = -0.7;
+        let netX = 10;
+        let magX = 2;
+        let swing = 0;
+        let caught = 0;
+        let respawn = 0;
+        let caughtFlash = 0;
+        let dust = [];
+        return {
+            step() {
+                t++;
+                if (respawn) {
+                    respawn--;
+                    if (!respawn) {
+                        bx = r() < 0.5 ? 2 : W - 8;
+                        bv = bx < 10 ? 0.7 : -0.7;
+                    }
+                }
+                else {
+                    if (r() < 0.04)
+                        bv = -bv;
+                    if (r() < 0.02)
+                        bv *= 1.8;
+                    bv = Math.max(-1.3, Math.min(1.3, bv));
+                    if (Math.abs(bv) > 0.8 && r() < 0.1)
+                        bv *= 0.6;
+                    bx += bv;
+                    if (bx < 1 || bx > W - 7) {
+                        bv = -bv;
+                        bx = Math.max(1, Math.min(W - 7, bx));
+                    }
+                    if (t % 3 === 0)
+                        dust.push({ x: bx + (bv > 0 ? 0 : 5), y: G - 1, vx: -bv * 0.3, vy: -0.1, ch: '.', tone: 'soil', life: 0 });
+                }
+                const target = bx + 3;
+                const netFacesRight = target >= netX + 3;
+                const goal = netFacesRight ? target - 6 : target;
+                netX += Math.sign(goal - netX) * Math.min(0.6, Math.abs(goal - netX));
+                magX += Math.sign(netX - 9 - magX) * Math.min(0.35, Math.abs(netX - 9 - magX));
+                if (swing)
+                    swing--;
+                else if (!respawn && Math.abs(goal - netX) < 3 && t % 8 === 0)
+                    swing = 6;
+                if (swing === 3 && !respawn) {
+                    const netPoint = netFacesRight ? netX + 6 : netX - 1;
+                    if (Math.abs(netPoint - target) < 2.5) {
+                        caught++;
+                        respawn = 30;
+                        caughtFlash = 14;
+                    }
+                }
+                if (caughtFlash)
+                    caughtFlash--;
+                for (const d of dust) {
+                    d.x += d.vx;
+                    d.y += d.vy;
+                    d.life = (d.life ?? 0) + 1;
+                }
+                dust = dust.filter((d) => (d.life ?? 0) < 6);
+            },
+            draw(c) {
+                drawGround(c, G, soil);
+                c.put(CRATE_X - 1, G - 2, '[_____]', 'wood');
+                c.put(CRATE_X - 1, G - 1, '[_____]', 'wood');
+                const near = !respawn && Math.abs(bx + 3 - (CRATE_X + 2)) < 10;
+                c.sprite(CRATE_X, G - 6, near ? SCARED : withFace([' .-. ', '(o.o)', '(   )', " ' ' "], blink(t, 3)), 'agent');
+                if (near && t % 8 < 5)
+                    c.put(CRATE_X + 6, G - 7, '(!!)', 'cloud');
+                if (!respawn) {
+                    c.sprite(bx, G - 3, Math.floor(t / 2) % 2 ? BUG_A : BUG_B, 'leaf');
+                }
+                for (const d of dust)
+                    c.put(d.x, d.y, d.ch, d.tone);
+                const right = bx + 3 >= netX + 3;
+                let net = swing > 3 ? NET_UP : swing > 0 ? NET_DOWN : NET_UP;
+                if (!right)
+                    net = mirror(net);
+                const nx = right ? netX : netX - 3;
+                c.sprite(nx, G - 4, withFace(net, caughtFlash ? '^.^' : '>.<'), 'agent');
+                if (caughtFlash) {
+                    const px = right ? nx + 5 : nx;
+                    c.put(px, G - 5, '(@)', 'leaf');
+                    if (t % 6 < 4)
+                        c.put(nx - 1, G - 6, '(te tengo!)', 'good');
+                }
+                c.sprite(magX, G - 4, withFace(MAGNIFY, blink(t, 5, 'o.O')), 'agent');
+            },
+            status() {
+                return respawn ? `bug atrapado · total ${caught}` : `persiguiendo bug · atrapados ${caught}`;
+            },
+        };
+    },
+};

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

@@ -0,0 +1,76 @@
+/* eslint-disable @typescript-eslint/no-non-null-assertion -- scene arrays are indexed within their declared bounds. */
+import { AGENT, blink, drawGround, mirror, rng, soilLine, withFace } from '../engine.js';
+const W = 78;
+const H = 13;
+const G = 11;
+const JUMP = ['\\.-./', '(^.^)', '(   )', " / \\ "];
+const CHEER = [' .-. ', '(^.^)', '(   )/', " ' ' "];
+const BOX = [" .----------. ", " |          | ", " |       // | ", " | \\\\   //  | ", " |  \\\\ //   | ", " |   \\V/    | ", " '----------' "];
+const CONFETTI = ['*', '+', '.', 'o', '~', "'"];
+const TONES = ['agent', 'accent', 'good', 'spark', 'water', 'flame'];
+export const celebrate = {
+    id: 'celebrate',
+    title: 'Celebrando',
+    useFor: 'Tarea completada / meta alcanzada',
+    width: W,
+    height: H,
+    create(seed = 6) {
+        const r = rng(seed);
+        const soil = [soilLine(W, r)];
+        const agents = [3, 12, 21, 52, 61, 70].map((x, i) => ({ x, off: i * 3, m: i >= 3 }));
+        let t = 0;
+        let streak = 1;
+        let confetti = [];
+        let bursts = [];
+        return {
+            step() {
+                t++;
+                for (let i = 0; i < 2; i++) {
+                    confetti.push({ x: r() * W, y: -1, vx: (r() - 0.5) * 0.3, vy: 0.15 + r() * 0.2, ch: CONFETTI[Math.floor(r() * CONFETTI.length)], tone: TONES[Math.floor(r() * TONES.length)] });
+                }
+                for (const p of confetti) {
+                    p.x += p.vx + Math.sin((t + p.y * 3) * 0.3) * 0.15;
+                    p.y += p.vy;
+                }
+                confetti = confetti.filter((p) => p.y < G);
+                if (t % 18 === 0) {
+                    bursts.push({ x: 8 + r() * (W - 16), y: 1 + r() * 3, l: 0, tone: TONES[Math.floor(r() * TONES.length)] });
+                    if (t % 90 === 0)
+                        streak++;
+                }
+                for (const b of bursts)
+                    b.l++;
+                bursts = bursts.filter((b) => b.l < 8);
+            },
+            draw(c) {
+                drawGround(c, G, soil);
+                for (const b of bursts) {
+                    const rad = b.l * 0.9;
+                    const ch = b.l < 3 ? '*' : b.l < 6 ? '+' : '.';
+                    for (let a = 0; a < 8; a++) {
+                        const ang = (a / 8) * Math.PI * 2;
+                        c.put(b.x + Math.cos(ang) * rad * 2, b.y + Math.sin(ang) * rad * 0.8, ch, b.tone);
+                    }
+                    if (b.l < 2)
+                        c.put(b.x, b.y, 'o', 'spark');
+                }
+                const pulse = Math.floor(t / 6) % 2;
+                c.sprite(32, G - 7, BOX, 'rock');
+                c.sprite(32, G - 7, BOX.map((l) => l.replace(/[.\-|']/g, ' ')), pulse ? 'good' : 'leaf');
+                agents.forEach((a, i) => {
+                    const ph = (t + a.off) % 12;
+                    const up = ph < 6 ? Math.round(Math.sin((ph / 6) * Math.PI) * 2) : 0;
+                    let sp = up > 0 ? JUMP : i % 2 ? CHEER : withFace(AGENT.stand, '^.^');
+                    if (a.m)
+                        sp = mirror(sp);
+                    c.sprite(a.x, G - 4 - up, withFace(sp, blink(t, i, '^.^')), 'agent');
+                });
+                for (const p of confetti)
+                    c.put(p.x, p.y, p.ch, p.tone);
+            },
+            status() {
+                return `tarea completada · racha x${streak}`;
+            },
+        };
+    },
+};

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

@@ -0,0 +1,156 @@
+/* eslint-disable prefer-const -- particle arrays are mutated in place by the scene engine. */
+import { AGENT, blink, drawGround, mirror, rng, soilLine, withFace } from '../engine.js';
+const W = 78;
+const H = 12;
+const G = 10;
+const CABINET = [' .------. ', ' |[ -- ]| ', ' |[ -- ]| ', ' |[ -- ]| ', " '------' "];
+const BIN = ['._____.', '|     |', '|     |', "'-----'"];
+const SWEEP_A = [' .-.   ', '(o.o)  ', '(   )\\ ', " ' '  #"];
+const SWEEP_B = [' .-.   ', '(o.o)  ', '(   )| ', " ' '  #"];
+const BROOM_UP = mirror([' .-. #', '(o.o)|', '(   )|', " ' '  "]);
+const CARRY = [' .-.  ', '(o.o) ', '(   )=', " ' '  "];
+const CARRY_B = [' .-.  ', '(o.o) ', '(   )=', "  ' ' "];
+const SWEEP_L = 22;
+const BIN_X = 70;
+const BOX_X = 16;
+const BOX_MAX = 6;
+export const cleaning = {
+    id: 'cleaning',
+    title: 'Limpiando',
+    useFor: 'Archivar / limpiar tareas completadas',
+    width: W,
+    height: H,
+    create(seed = 11) {
+        const r = rng(seed);
+        const soil = [soilLine(W, r)];
+        let t = 0;
+        let dust = new Set();
+        const sprinkle = (n) => {
+            for (let i = 0; i < n; i++)
+                dust.add(SWEEP_L + 6 + Math.floor(r() * (BIN_X - SWEEP_L - 8)));
+        };
+        sprinkle(18);
+        const sweepers = [
+            { x: SWEEP_L, dir: 1, load: 0, n: 1 },
+            { x: SWEEP_L + 20, dir: 1, load: 0, n: 2 },
+        ];
+        let bin = 0;
+        let archived = 0;
+        let boxes = BOX_MAX;
+        const arch = { x: BOX_X - 5, st: 'pick', k: 0 };
+        let puffs = [];
+        return {
+            step() {
+                t++;
+                for (const s of sweepers) {
+                    if (s.dir > 0) {
+                        s.x += 0.3;
+                        const head = Math.round(s.x + 6);
+                        for (const d of [head, head + 1]) {
+                            if (dust.has(d)) {
+                                dust.delete(d);
+                                s.load++;
+                                puffs.push({ x: d, y: G - 2, vx: (r() - 0.3) * 0.4, vy: -0.3 - r() * 0.2, ch: r() < 0.5 ? '.' : "'", tone: 'soil', life: 0 });
+                            }
+                        }
+                        if (t % 5 === s.n)
+                            puffs.push({ x: s.x + 6, y: G - 1, vx: r() * 0.4, vy: -0.25, ch: '.', tone: 'cloud', life: 0 });
+                        if (s.x + 7 >= BIN_X) {
+                            bin = Math.min(100, bin + s.load * 4);
+                            s.load = 0;
+                            s.dir = -1;
+                        }
+                    }
+                    else {
+                        s.x -= 0.45;
+                        if (s.x <= SWEEP_L) {
+                            s.dir = 1;
+                            sprinkle(5);
+                        }
+                    }
+                }
+                if (bin >= 100 && t % 40 === 0)
+                    bin = 0;
+                arch.k++;
+                if (arch.st === 'pick' && arch.k > 5) {
+                    if (boxes > 0) {
+                        boxes--;
+                        arch.st = 'go';
+                    }
+                    arch.k = 0;
+                }
+                else if (arch.st === 'go') {
+                    arch.x -= 0.4;
+                    if (arch.x <= 9) {
+                        arch.st = 'drop';
+                        arch.k = 0;
+                    }
+                }
+                else if (arch.st === 'drop' && arch.k > 5) {
+                    archived++;
+                    arch.st = 'back';
+                    arch.k = 0;
+                }
+                else if (arch.st === 'back') {
+                    arch.x += 0.4;
+                    if (arch.x >= BOX_X - 5) {
+                        arch.st = 'pick';
+                        arch.k = 0;
+                        if (boxes === 0)
+                            boxes = BOX_MAX;
+                    }
+                }
+                for (const p of puffs) {
+                    p.x += p.vx;
+                    p.y += p.vy;
+                    p.life = (p.life ?? 0) + 1;
+                }
+                puffs = puffs.filter((p) => (p.life ?? 0) < 7);
+            },
+            draw(c) {
+                drawGround(c, G, soil);
+                c.sprite(0, G - 5, CABINET, 'rock');
+                const drawer = arch.st === 'drop' ? 1 : -1;
+                if (drawer > 0)
+                    c.put(2, G - 3, '[====]', 'paper');
+                for (let i = 0; i < boxes; i++)
+                    c.put(BOX_X + (i % 2) * 3, G - 1 - Math.floor(i / 2), '[▤]', 'paper');
+                c.sprite(BIN_X, G - 4, BIN, 'rock');
+                const fill = Math.round((bin / 100) * 2);
+                for (let i = 0; i < fill; i++)
+                    c.put(BIN_X + 1, G - 2 - i, ':.:.:', 'soil');
+                if (bin >= 100 && t % 8 < 5)
+                    c.put(BIN_X - 1, G - 6, '(lleno)', 'cloud');
+                for (const d of dust)
+                    c.put(d, G - 1, t % 20 < 10 ? '.' : ',', 'soil');
+                sweepers.forEach((s, i) => {
+                    if (s.dir > 0) {
+                        const sp = Math.floor(t / 3) % 2 ? SWEEP_A : SWEEP_B;
+                        c.sprite(s.x, G - 4, withFace(sp, blink(t, i)), 'agent');
+                        if (s.load > 0)
+                            c.put(s.x + 7, G - 1, s.load > 4 ? '::' : ':', 'soil');
+                    }
+                    else {
+                        c.sprite(s.x, G - 4, withFace(BROOM_UP, Math.floor(t / 2) % 2 ? '^.^' : blink(t, i, '^.^')), 'agent');
+                    }
+                });
+                const w = Math.floor(t / 2) % 2;
+                if (arch.st === 'go') {
+                    c.sprite(arch.x, G - 4, withFace(mirror(w ? CARRY : CARRY_B), blink(t, 5)), 'agent');
+                    c.put(arch.x - 3, G - 2, '[▤]', 'paper');
+                }
+                else if (arch.st === 'drop') {
+                    c.sprite(arch.x, G - 4, withFace(mirror(CARRY), '^.^'), 'agent');
+                }
+                else {
+                    c.sprite(arch.x, G - 4, withFace(arch.st === 'back' && w ? AGENT.walk : AGENT.stand, blink(t, 5)), 'agent');
+                }
+                for (const p of puffs)
+                    c.put(p.x, p.y, p.ch, p.tone);
+            },
+            status() {
+                return `archivadas ${archived} · basura ${bin}%`;
+            },
+        };
+    },
+};

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

@@ -0,0 +1,105 @@
+/* eslint-disable @typescript-eslint/no-non-null-assertion, prefer-const -- scene arrays are indexed within bounds; particle arrays are mutated in place. */
+import { AGENT, blink, drawCloud, drawGround, rng, soilLine, withFace } from '../engine.js';
+const W = 78;
+const H = 12;
+const G = 10;
+const FRONT = 57;
+const GAP = 7;
+const CLOCK = 64;
+const PUNCH = [' .-.   ', '(o.o)  ', '(   )=]', " ' '   "];
+const TAP = [' .-. ', '(o.o)', '(   )', " '  ."];
+const TALK = ['(zzz)', '(ya?)', '(café..)', '(...)', '(lunes)'];
+export const clockIn = {
+    id: 'clockIn',
+    title: 'Ponchando entrada',
+    useFor: 'Inicio del día / cargando la app',
+    width: W,
+    height: H,
+    create(seed = 3) {
+        const r = rng(seed);
+        const soil = [soilLine(W, r)];
+        let t = 0;
+        let q = [];
+        let gone = [];
+        let nid = 6;
+        let punched = 0;
+        let flash = 0;
+        let mins = 7 * 60 + 52;
+        for (let i = 0; i < 5; i++)
+            q.push({ x: FRONT - GAP * i, k: 0, id: i + 1 });
+        return {
+            step() {
+                t++;
+                if (t % 25 === 0) {
+                    mins++;
+                    if (mins > 8 * 60 + 10)
+                        mins = 7 * 60 + 52;
+                }
+                q.forEach((a, i) => {
+                    const tx = FRONT - GAP * i;
+                    a.moving = a.x < tx;
+                    if (a.moving)
+                        a.x = Math.min(tx, a.x + 0.5);
+                });
+                const f = q[0];
+                if (f && f.x === FRONT) {
+                    f.k++;
+                    if (f.k === 9) {
+                        punched++;
+                        flash = 10;
+                    }
+                    if (f.k > 16) {
+                        gone.push(q.shift());
+                        q.push({ x: -6, k: 0, id: nid++ });
+                    }
+                }
+                for (const a of gone)
+                    a.x += 0.5;
+                gone = gone.filter((a) => a.x < W);
+                if (flash)
+                    flash--;
+            },
+            draw(c) {
+                drawCloud(c, t, 0.05, 50, 0);
+                drawGround(c, G, soil);
+                c.put(28, 1, ' ______________ ', 'wood');
+                c.put(28, 2, '| entrada 8:00 |', 'wood');
+                c.put(28, 3, "'--------------'", 'wood');
+                c.put(28, 2, '|', 'wood');
+                c.put(30, 2, 'entrada 8:00', 'text');
+                c.put(74, G - 6, '____', 'wood');
+                for (let y = G - 5; y < G; y++)
+                    c.put(74, y, '|  |', 'wood');
+                c.put(76, G - 3, 'o', 'spark');
+                const talker = Math.floor(t / 20) % 5;
+                q.forEach((a, i) => {
+                    const w = Math.floor(t / 2) % 2;
+                    let sp = a.moving ? (w ? AGENT.stand : AGENT.walk) : AGENT.stand;
+                    if (i === 0 && a.k >= 4 && a.k <= 14)
+                        sp = PUNCH;
+                    if (!a.moving && a.id % 3 === 2 && i > 0)
+                        sp = Math.floor(t / 3) % 2 ? AGENT.stand : TAP;
+                    const face = i === 0 && a.k > 9 ? '^.^' : a.id % 3 === 0 ? blink(t, a.id, '-.o') : blink(t, a.id);
+                    c.sprite(a.x, G - 4, withFace(sp, face), 'agent');
+                    if (i === talker && i > 0 && !a.moving)
+                        c.put(a.x - 1, G - 5, TALK[a.id % 5], 'cloud');
+                });
+                for (const a of gone)
+                    c.sprite(a.x, G - 4, withFace(Math.floor(t / 2) % 2 ? AGENT.stand : AGENT.walk, '^.^'), 'agent');
+                c.put(CLOCK, G - 5, ' ______ ', 'rock');
+                c.put(CLOCK, G - 4, '|      |', 'rock');
+                c.put(CLOCK, G - 3, '|      |', 'rock');
+                c.put(CLOCK, G - 2, '|[____]|', 'rock');
+                c.put(CLOCK, G - 1, "'------'", 'rock');
+                const hh = String(Math.floor(mins / 60)).padStart(2, '0');
+                const mm = String(mins % 60).padStart(2, '0');
+                c.put(CLOCK + 1, G - 4, hh + (t % 10 < 5 ? ':' : ' ') + mm, 'accent');
+                if (flash)
+                    c.put(CLOCK + 3, G - 3, 'ok', 'good');
+            },
+            status() {
+                return `ponchados ${punched} · en fila ${q.length}`;
+            },
+        };
+    },
+};