@softov/ahpc 0.1.0

package/dist/src/view/bood/art.js

@@ -0,0 +1,152 @@
+/**
+ * The drawing tag.
+ *
+ * A tagged template reading `strings.raw`, because this is drawing. A figure
+ * whose every backslash has to be doubled to survive the parser is one
+ * somebody will eventually get wrong, and the mistake does not look like a
+ * mistake - it looks like a slightly worse cat.
+ *
+ *     art`
+ *  /\_/\
+ * ( ^.^ )
+ * `
+ *
+ * The leading and trailing blank lines are the ones the backticks sit on, and
+ * they are dropped. Nothing else is: art starts at column zero in the file,
+ * because leading spaces are part of the animal and a dedent would eat them.
+ */
+export function art(strings) {
+    const rows = strings.raw.join('').split('\n');
+    if (rows[0]?.trim() === '')
+        rows.shift();
+    if (rows[rows.length - 1]?.trim() === '')
+        rows.pop();
+    return rows;
+}
+/** One cell's frames, however the file wrote them. One frame, or several. */
+export function framesOf(cell) {
+    return Array.isArray(cell[0]) ? cell : [cell];
+}
+/**
+ * Square a form off: one width, one height, across every mood and every frame.
+ *
+ * Padded once, here, rather than by the compositor - because the compositor
+ * pads to the widest row *it* was given, and a centred figure with one short
+ * row leans. And because a frame one row taller than the next does not read as
+ * animation, it reads as the line underneath it jumping.
+ */
+export function square(cells) {
+    const width = Math.max(0, ...cells.flatMap((frames) => frames.flatMap((rows) => rows.map((row) => row.length))));
+    const height = Math.max(0, ...cells.flatMap((frames) => frames.map((rows) => rows.length)));
+    for (const frames of cells) {
+        for (let at = 0; at < frames.length; at += 1) {
+            const rows = frames[at].map((row) => row.padEnd(width));
+            while (rows.length < height)
+                rows.push(' '.repeat(width));
+            frames[at] = rows;
+        }
+    }
+    return { width, height };
+}
+/**
+ * A long open and a short shut.
+ *
+ * Two frames alternating at the ticker's rate is not a blink, it is a strobe.
+ * The hold lives in the data rather than in the component, because how long a
+ * cat's eyes stay open is a fact about the cat.
+ */
+export const blink = (open, shut) => [open, open, open, shut];
+/** Two frames, each held for two - a slow alternation inside a fast ticker. */
+export const alternate = (a, b) => [a, a, b, b];
+/**
+ * Fill a pose's slots: a run of `%` takes the face, a run of `#` the tell.
+ *
+ * The run is written exactly as wide as the token that fills it, so a filled
+ * row is the same length as the row it came from and nothing downstream has to
+ * re-measure. `registerCreature` checks that at registration; the padding here
+ * is what happens when somebody registers their own creature at runtime and
+ * got it wrong, and a short token is better than a row that shifts.
+ */
+export function fill(rows, face, tell) {
+    return rows.map((row) => row
+        .replace(/%+/g, (run) => pad(face, run.length))
+        .replace(/#+/g, (run) => pad(tell, run.length)));
+}
+function pad(token, width) {
+    if (token.length === width)
+        return token;
+    return token.length > width ? token.slice(0, width) : token.padEnd(width);
+}
+/**
+ * What one frame is, and where the animal is inside it.
+ *
+ * The anchor is the middle of the face slot - the creature's identity point -
+ * and a figure is placed by it rather than by its left edge. That is what lets
+ * a cat turn side-on: the walking drawing is twice as wide as the front one
+ * with the head at the far end, and anchored on the face the body swings round
+ * a head that stays where it was. Anchored on the corner it would jump ten
+ * cells every time the cat turned round.
+ *
+ * A pose that pins its own face has no slot to read, so it falls back to the
+ * middle, which is where a symmetrical drawing's identity is anyway.
+ */
+export function metric(rows) {
+    let width = 0;
+    let anchor = -1;
+    for (const row of rows) {
+        if (row.length > width)
+            width = row.length;
+        const slot = /%+/.exec(row);
+        if (slot && anchor < 0)
+            anchor = slot.index + Math.floor(slot[0].length / 2);
+    }
+    return { width, height: rows.length, anchor: anchor < 0 ? Math.floor(width / 2) : anchor };
+}
+/**
+ * The anchor a whole pose is placed by: frame zero's, shared by every frame.
+ *
+ * Per-frame anchors would hold the face still and slide everything else, which
+ * is the wrong half of the motion to believe. The cat at the keyboard bobs its
+ * head one cell between frames; taking the anchor from frame zero keeps the
+ * desk still and moves the head, which is what the drawing means.
+ */
+export function anchorOf(frames) {
+    return metric(frames[0]).anchor;
+}
+/**
+ * Write a figure into a field of rows, bottom-aligned and anchored.
+ *
+ * Bottom-aligned because the feet own the y: the landing squash is a row
+ * shorter than the stand, and padding underneath would sink the creature
+ * through the floor at exactly the moment it hits it.
+ *
+ * Anything off the field is dropped rather than wrapped, so a creature halfway
+ * out of a narrow box is half a creature instead of a smear down the far side.
+ */
+export function blit(field, rows, x, y, anchor) {
+    const out = [...field];
+    const left = Math.round(x) - anchor;
+    const top = Math.round(y) - rows.length + 1;
+    for (let at = 0; at < rows.length; at += 1) {
+        const line = top + at;
+        if (line < 0 || line >= out.length)
+            continue;
+        const into = out[line];
+        const art = rows[at];
+        let built = '';
+        for (let col = 0; col < art.length; col += 1) {
+            const cell = left + col;
+            if (cell < 0 || cell >= into.length)
+                continue;
+            if (built === '')
+                built = into;
+            const glyph = art[col];
+            if (glyph === ' ')
+                continue;
+            built = built.slice(0, cell) + glyph + built.slice(cell + 1);
+        }
+        if (built !== '')
+            out[line] = built;
+    }
+    return out;
+}

package/dist/src/view/bood/beetle.d.ts

@@ -0,0 +1,7 @@
+/**
+ * A beetle. Antennae up, six legs, a shell drawn as a row of equals.
+ *
+ * The legs are what move while it is working. Antennae carry sad, the way the
+ * cat's tail does: they come down, and they stay down until the mood does.
+ */
+export declare const beetle: import("./types.js").CreatureSpec;

package/dist/src/view/bood/beetle.js

@@ -0,0 +1,123 @@
+import { alternate, art, blink } from './art.js';
+import { defineCreature } from './types.js';
+/**
+ * A beetle. Antennae up, six legs, a shell drawn as a row of equals.
+ *
+ * The legs are what move while it is working. Antennae carry sad, the way the
+ * cat's tail does: they come down, and they stay down until the mood does.
+ */
+export const beetle = defineCreature({
+    name: 'beetle',
+    label: 'Beetle',
+    about: 'Carries more than it weighs',
+    draw: {
+        happy: blink(art `
+   \   /
+  __\_/__
+ /( ^.^ )\
+ \|=====|/
+  /  |  \
+`, art `
+   \   /
+  __\_/__
+ /( -.- )\
+ \|=====|/
+  /  |  \
+`),
+        sad: art `
+   |   |
+  __\_/__
+ /( T.T )\
+ \|=====|/
+  \  |  /
+`,
+        thinking: alternate(art `
+   \  /    o
+  __\_/__
+ /( o.- )\
+ \|=====|/
+  /  |  \
+`, art `
+   \  /    .
+  __\_/__
+ /( o.- )\
+ \|=====|/
+  /  |  \
+`),
+        executing: [art `
+   \   /
+  __\_/__
+ /( o.o )\
+ \|=====|/
+  /  |  \
+`, art `
+   \   /
+  __\_/__
+ /( o.- )\
+ \|=====|/
+  \  |  /
+`, art `
+   \   /
+  __\_/__
+ /( -.o )\
+ \|=====|/
+  /  |  \
+`],
+        error: art `
+  \     /
+  _\___/_
+ /( >.< )\
+ \|=====|/
+  /  |  \
+`,
+    },
+    block: {
+        happy: blink(art `
+_\_/_
+(^.^)
+/ | \
+`, art `
+_\_/_
+(-.-)
+/ | \
+`),
+        sad: art `
+_|_|_
+(T.T)
+\ | /
+`,
+        thinking: art `
+_\_/_
+(-.o)
+/ | \
+`,
+        executing: [art `
+_\_/_
+(o.o)
+/ | \
+`, art `
+_\_/_
+(o.-)
+\ | /
+`, art `
+_\_/_
+(-.o)
+/ | \
+`],
+        error: art `
+_\_/_
+(>.<)
+/ | \
+`,
+    },
+    // Square brackets rather than the slashes the bigger forms use: a drawing
+    // that ends in a backslash cannot be written as a template literal at all,
+    // and the shell is the beetle's other outline anyway.
+    inline: {
+        happy: blink(art `[^.^]`, art `[-.-]`),
+        sad: art `[T.T]`,
+        thinking: art `[-.o]`,
+        executing: [art `[o.o]`, art `[o.-]`, art `[-.o]`],
+        error: art `[>.<]`,
+    },
+});

package/dist/src/view/bood/bunny.d.ts

@@ -0,0 +1,8 @@
+/**
+ * A bunny. The ears are the tell.
+ *
+ * Up and open when things are well, folded flat when they are not. At block
+ * and inline size there are no ears to fold, so the face does all of it -
+ * which is what those two sizes are for.
+ */
+export declare const bunny: import("./types.js").CreatureSpec;

package/dist/src/view/bood/bunny.js

@@ -0,0 +1,228 @@
+import { alternate, art, blink } from './art.js';
+import { defineCreature } from './types.js';
+/**
+ * A bunny. The ears are the tell.
+ *
+ * Up and open when things are well, folded flat when they are not. At block
+ * and inline size there are no ears to fold, so the face does all of it -
+ * which is what those two sizes are for.
+ */
+export const bunny = defineCreature({
+    name: 'bunny',
+    label: 'Bunny',
+    about: 'Quiet, and faster than it looks',
+    draw: {
+        happy: blink(art `
+  (\_/)
+  ( ^.^)
+ c(")_(")
+`, art `
+  (\_/)
+  ( -.-)
+ c(")_(")
+`),
+        // Ears down. The face alone would read as a bunny squinting.
+        sad: art `
+  (,_,)
+  ( T.T)
+ c(")_(")
+`,
+        thinking: alternate(art `
+  (\_/)  o
+  ( o.-)
+ c(")_(")
+`, art `
+  (\_/)  .
+  ( o.-)
+ c(")_(")
+`),
+        executing: [art `
+  (\_/)
+  ( o.o)
+ c(")_(")
+`, art `
+  (\_/)
+  ( o.-)
+ c(")_(")
+`, art `
+  (\_/)
+  ( -.o)
+ c(")_(")
+`],
+        error: art `
+  (\_/)
+  ( >.<)
+ c(")_(")
+`,
+    },
+    block: {
+        happy: blink(art `
+(\_/)
+(^.^)
+("_")
+`, art `
+(\_/)
+(-.-)
+("_")
+`),
+        sad: art `
+(,_,)
+(T.T)
+("_")
+`,
+        thinking: art `
+(\_/)
+(-.o)
+("_")
+`,
+        executing: [art `
+(\_/)
+(o.o)
+("_")
+`, art `
+(\_/)
+(o.-)
+("_")
+`, art `
+(\_/)
+(-.o)
+("_")
+`],
+        error: art `
+(\_/)
+(>.<)
+("_")
+`,
+    },
+    inline: {
+        happy: blink(art `(\^.^/)`, art `(\-.-/)`),
+        sad: art `(,T.T,)`,
+        thinking: art `(\-.o/)`,
+        executing: [art `(\o.o/)`, art `(\o.-/)`, art `(\-.o/)`],
+        error: art `(x>.<x)`,
+    },
+    /**
+     * Moving, and the ears keep doing the work.
+     *
+     * The forepaw is what says which way it is pointed - planted at the front
+     * when it is facing right, trailed behind when it is facing left - and it is
+     * a `c` on both sides here. The reference sheet mirrors it properly, as `c`
+     * and an open o, and that second glyph is U+0254: not ASCII, and East Asian
+     * Ambiguous, which means two cells wide under a CJK font setting. A rabbit
+     * one cell wider on somebody else's terminal does not look wide, it looks
+     * broken. So the paw curves the wrong way going left, which nobody reads at
+     * one cell, and the drawing is the same width everywhere.
+     *
+     * There is no walk cycle, because a bunny cannot travel without leaving the
+     * ground: `walk` is the crouch it launches from and is over in two frames.
+     */
+    motion: {
+        gait: 'hop',
+        flies: false,
+        sits: true,
+        bounce: 0.25,
+        fallSpeed: 1.15,
+        hop: 1,
+        blink: '-.-',
+        faces: { happy: '^.^', sad: 'T.T', thinking: '-.o', executing: 'o.o', error: '>.<' },
+        tells: { happy: '(\\_/)', sad: '(,_,)', thinking: '(\\_/)', executing: '(\\_/)', error: '(x_x)' },
+        poses: {
+            // Front is what it returns to: after a couple of seconds it looks at you,
+            // and shifts its weight from one paw to the other while it waits.
+            'idle.front': [art `
+  #####
+  (%%%)
+c((_ _))
+`, art `
+  #####
+  (%%%)
+ ((_ _))D
+`],
+            'idle.right': [art `
+ #####
+ ( %%%)
+c(")_(")
+`],
+            'idle.left': [art `
+   #####
+  (%%% )
+ (")_(")D
+`],
+            'sit.front': art `
+  #####
+  (%%%)
+ ((_ _))
+`,
+            'sit.right': art `
+ #####
+ ( %%%)
+ C(")(")
+`,
+            'sit.left': art `
+  #####
+ (%%% )
+ (")(")D
+`,
+            'walk.right': art `
+ #####
+ ( %%%)
+.(")_(")
+`,
+            'walk.left': art `
+   #####
+  (%%% )
+ (")_(")D
+`,
+            'jump.right': art `
+  #####
+  ( %%%)
+C((")(")
+(") (")
+`,
+            'jump.left': art `
+  #####
+ (%%% )
+ (")("))D
+  (") (")
+`,
+            'fall.right': art `
+ #####
+ ( %%%)
+C(")_(")
+  '   '
+`,
+            'fall.left': art `
+   #####
+  (%%% )
+ (")_(")D
+  '   '
+`,
+            // A squash is wider and shorter. Bottom-aligned, so it settles onto the
+            // floor rather than sinking through it.
+            land: art `
+  #####
+  (%%%)
+ ((" "))
+`,
+            held: art `
+  #####
+  (%%%)
+  ("|")
+ (")U(")
+`,
+            // Pins its own face over the mood, and the mood comes straight back when
+            // anything wakes it.
+            sleep: art `
+  (,_,)
+  (-.-)
+ ((_ _))
+`,
+            alarm: art `
+  #####
+  (%%%)
+C((_ _))
+  ^   ^
+`,
+        },
+    },
+});

package/dist/src/view/bood/cat.d.ts

@@ -0,0 +1,9 @@
+/**
+ * A cat, in three sizes.
+ *
+ * The tail is what carries the mood at full size after the face does: up and
+ * curled when things are well, flat when they are not, swishing while there is
+ * work going on. Which is a second carrier of the same meaning, and that is the
+ * point - a 16-colour session and a piped log both keep the tail.
+ */
+export declare const cat: import("./types.js").CreatureSpec;