@softov/ahpc 0.1.0

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

@@ -0,0 +1,285 @@
+import { alternate, art, blink } from './art.js';
+import { defineCreature } from './types.js';
+/**
+ * An owl. A comma for a beak, which is the only reason the face fits in three
+ * cells at every size.
+ *
+ * Angry is the one figure here that changes shape rather than expression - it
+ * opens its wings - and it is worth the extra rows, because an owl that is
+ * only scowling reads as an owl that is concentrating.
+ */
+export const owl = defineCreature({
+    name: 'owl',
+    label: 'Owl',
+    about: 'Has read the logs already',
+    draw: {
+        happy: [art `
+ ,___,
+ (^,^)
+ /)_)
+  " "
+`, art `
+  ,___,
+  (-,-)
+  /)_)
+   " "
+`, art `
+  ,___,
+  (^,^)
+   (_(\
+   " "
+`, art `
+ ,___,
+ (-,-)
+  (_(\
+  " "
+`],
+        sad: art `
+ ,___,
+ (T,T)
+ /)_)
+  " "
+`,
+        thinking: alternate(art `
+ ,___,  o
+ (o,o)
+ /)_)
+  " "
+`, art `
+ ,___,  .
+ (o,o)
+ /)_)
+  " "
+`),
+        executing: [art `
+ ,___,
+ (o,o)
+ /)_)
+  " "
+`, art `
+ ,___,
+ (o,-)
+ /)_)
+  " "
+`, art `
+ ,___,
+ (-,o)
+ /)_)
+  " "
+`],
+        error: art `
+  ,___,
+  (>,<)
+ /(___)\
+   v v
+`,
+    },
+    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 `v(T,T)v`,
+        thinking: art `,(-,o),`,
+        executing: [art `,(o,o),`, art `,(o,-),`, art `,(-,o),`],
+        error: art `\(>,<)/`,
+    },
+    /**
+     * Moving, and it is the one that gets to choose.
+     *
+     * Flight is not a pose here, it is a suspended gravity term - and something
+     * the creature decides once per trip, at intent time, never per tick. A roll
+     * against the mood's `fly` dial, plus a lean toward flying when the
+     * destination is far enough to be worth the take-off. Decided per tick it
+     * would flicker between walking and flying inside one journey.
+     *
+     * The flap is three frames on a clock rather than two derived from `vy`,
+     * because a hover controller keeps `vy` near zero and would pin a circling
+     * owl to one wing position. The glide has no left or right view on purpose:
+     * a bird planing is not pointed anywhere in particular, and the lookup chain
+     * falls through to the front one.
+     */
+    motion: {
+        gait: 'hop',
+        flies: true,
+        sits: true,
+        bounce: 0,
+        fallSpeed: 0.25,
+        hop: 0.45,
+        blink: '-,-',
+        faces: { happy: '^,^', sad: 'T,T', thinking: '-,o', executing: 'o,o', error: '>,<' },
+        tells: { happy: ',___,', sad: 'v___v', thinking: ',___,', executing: ',___,', error: '/___\\' },
+        poses: {
+            'idle.front': art `
+  #####
+  (%%%)
+  /)_)
+   " "
+`,
+            'idle.right': art `
+  #####
+  (%%%)
+  /)_)
+   " "
+`,
+            'idle.left': art `
+  #####
+  (%%%)
+  (_(\
+   " "
+`,
+            'sit.front': art `
+  #####
+  (%%%)
+  /)_)
+   " "
+`,
+            'walk.right': art `
+  #####
+  (%%%)
+  /)_)
+   ^ ^
+`,
+            'walk.left': art `
+  #####
+  (%%%)
+  (_(\
+   ^ ^
+`,
+            'fly.front': [art `
+   #####
+  \(%%%)/
+   (   )
+    " "
+`, art `
+   #####
+ __(%%%)__
+   (   )
+    " "
+`, art `
+   #####
+   (%%%)
+  /(   )\
+    " "
+`],
+            'fly.left': [art `
+   #####
+  \%%% )///
+   (   ---
+    " "
+`, art `
+   #####
+  _%%% )___
+   (    --
+    " "
+`, art `
+   #####
+   %%% )_
+  /(   \\
+    " "
+`],
+            'fly.right': [art `
+   #####
+\\\( %%%/
+ \--   )
+    " "
+`, art `
+   #####
+ __( %%%_
+ --    )
+    " "
+`, art `
+   #####
+  _( %%%
+ ///   )\
+    " "
+`],
+            jump: art `
+  #####
+ \(%%%)/
+   )w(
+`,
+            // The glide, which is also what a dropped owl does instead of falling.
+            fall: art `
+   #####
+---(%%%)---
+    )w(
+`,
+            land: art `
+  #####
+  (%%%)
+  /)_)
+`,
+            held: art `
+  #####
+  (%%%)
+  /)_(\
+   " "
+`,
+            sleep: art `
+  ,___,
+  (-,-)
+  /)_)
+   " "
+`,
+            // The one figure that changes shape rather than expression: an owl that
+            // is only scowling reads as an owl that is concentrating.
+            alarm: [
+                art `
+  #####
+\\(%%%)//
+  (___)
+   "w"
+`,
+                art `
+  #####
+__(%%%)__ 
+  (___)
+   "w"
+`,
+                art `
+  #####
+  (%%%)
+//(___)\\
+   "w"
+`
+            ],
+        },
+    },
+});

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

@@ -0,0 +1,36 @@
+import type { Creature, CreatureSpec, Facing, Form, Mood, Pose } from './types.js';
+export declare function registerCreature(spec: CreatureSpec): Creature;
+export declare function getCreature(name: string): Creature | undefined;
+/** Every one registered, in registration order. */
+export declare function listCreatures(): readonly Creature[];
+export declare function creatureNames(): readonly string[];
+export interface DrawOptions {
+    form?: Form;
+    /** Which frame of the cycle. Wraps, so a frame counter can be handed straight in. */
+    frame?: number;
+}
+/** The rows of one creature, in one mood, at one size. */
+export declare function drawCreature(name: string, mood?: Mood, options?: DrawOptions): string[];
+/** Every frame of one cell. One long, where the drawing does not move. */
+export declare function creatureFrames(name: string, mood?: Mood, form?: Form): string[][];
+/** What a form costs for one creature, whatever mood it is in. */
+export declare function creatureSize(name: string, form?: Form): {
+    width: number;
+    height: number;
+};
+/** The tallest anyone in the bood is, for a caller deciding whether there is room. */
+export declare function boodHeight(form?: Form): number;
+/**
+ * The chain, and the chain is the design rather than the first hit.
+ *
+ * A species that has no left view of a pose falls through to its front one and
+ * still reads right; the owl's glide is deliberately front-only, because a
+ * bird planing is not pointed anywhere in particular. Overrides come first at
+ * every step, so a mood that changes the outline rather than the expression -
+ * the cat at a keyboard while a turn is running - wins before a facing does.
+ */
+export declare function poseFrames(name: string, pose: Pose, facing: Facing, mood: Mood): string[][] | undefined;
+/** The moving half of one creature, or nothing if it was never drawn moving. */
+export declare function creatureMotion(name: string): Creature['motion'];
+/** Which of the bood have been drawn moving, for a picker that offers it. */
+export declare function livelyNames(): readonly string[];

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

@@ -0,0 +1,218 @@
+import { anchorOf, framesOf, metric, square } from './art.js';
+import { BOUNDS, FORMS, MOODS } from './types.js';
+/**
+ * The bood.
+ *
+ * Late-binding, by name, the way every other registry in this runtime works:
+ * a creature is looked up when it is drawn, not linked when it is imported.
+ * Which means a consumer can `registerCreature` their own and it is on the
+ * same footing as the six that ship - there is no built-in list to be on.
+ */
+const BOOD = new Map();
+/** What went wrong, and which drawing it was. */
+class BadDrawing extends Error {
+    constructor(name, form, mood, said) {
+        super(`creature "${name}" ${form}/${mood}: ${said}`);
+        this.name = 'BadDrawing';
+    }
+}
+/** What went wrong in the moving half, and which pose it was. */
+class BadMotion extends Error {
+    constructor(name, key, said) {
+        super(`creature "${name}" motion/${key}: ${said}`);
+        this.name = 'BadMotion';
+    }
+}
+/**
+ * Plain ASCII, every character, and it is checked rather than claimed.
+ *
+ * Not one glyph in a creature is one whose width the terminal gets to decide.
+ * Box drawing and the half-block set are the ones that get eaten by a CJK font
+ * setting, and art that is one cell wider on somebody else's machine does not
+ * look narrow, it looks broken. A `block` that renders six cells wide has also
+ * quietly broken whatever was laid out beside it.
+ */
+const PRINTABLE = /^[\x20-\x7e]*$/;
+export function registerCreature(spec) {
+    const art = {};
+    const size = {};
+    for (const form of FORMS) {
+        const bound = BOUNDS[form];
+        const byMood = {};
+        for (const mood of MOODS) {
+            const frames = framesOf(spec[form][mood]).map((rows) => [...rows]);
+            if (frames.length === 0)
+                throw new BadDrawing(spec.name, form, mood, 'no frames');
+            for (const rows of frames) {
+                if (rows.length === 0)
+                    throw new BadDrawing(spec.name, form, mood, 'an empty frame');
+                if (rows.length > bound.rows) {
+                    throw new BadDrawing(spec.name, form, mood, `${rows.length} rows, and ${form} allows ${bound.rows}`);
+                }
+                for (const row of rows) {
+                    if (row.length > bound.cols) {
+                        throw new BadDrawing(spec.name, form, mood, `a row ${row.length} cells wide, and ${form} allows ${bound.cols}`);
+                    }
+                    if (!PRINTABLE.test(row)) {
+                        throw new BadDrawing(spec.name, form, mood, `"${row}" uses a glyph whose width a terminal gets to decide`);
+                    }
+                }
+            }
+            byMood[mood] = frames;
+        }
+        // Squared per form, not per creature: `draw` being sixteen cells wide is
+        // no reason for `inline` to be, and a mood change must not move what is
+        // under the figure.
+        art[form] = byMood;
+        size[form] = square(MOODS.map((mood) => byMood[mood]));
+    }
+    const creature = {
+        name: spec.name, label: spec.label, about: spec.about ?? '', art, size,
+        motion: spec.motion ? registerMotion(spec.name, spec.motion) : undefined,
+    };
+    BOOD.set(creature.name, creature);
+    return creature;
+}
+/**
+ * The moving half, framed and slot-checked.
+ *
+ * The check that matters is the slot width. A `%` run one cell wider than the
+ * face that fills it does not fail, it draws a rabbit with a column of its own
+ * head missing - and only in the moods whose token is short. That is a bug
+ * nobody finds by looking at the happy one, so it is settled here, once, for
+ * every mood against every pose.
+ */
+function registerMotion(name, motion) {
+    const faces = MOODS.map((mood) => motion.faces[mood]);
+    const tells = MOODS.map((mood) => motion.tells[mood]);
+    const oneWidth = (tokens, what) => {
+        const widths = new Set(tokens.map((token) => token.length));
+        if (widths.size !== 1)
+            throw new BadMotion(name, what, `${widths.size} different widths, and a slot has one`);
+        return [...widths][0];
+    };
+    const faceWidth = oneWidth([...faces, motion.blink], 'faces');
+    const tellWidth = oneWidth(tells, 'tells');
+    const frame = (key, cell) => {
+        const frames = framesOf(cell).map((rows) => [...rows]);
+        if (frames.length === 0)
+            throw new BadMotion(name, key, 'no frames');
+        for (const rows of frames) {
+            if (rows.length === 0)
+                throw new BadMotion(name, key, 'an empty frame');
+            if (rows.length > BOUNDS.draw.rows) {
+                throw new BadMotion(name, key, `${rows.length} rows, and a figure allows ${BOUNDS.draw.rows}`);
+            }
+            for (const row of rows) {
+                if (!PRINTABLE.test(row)) {
+                    throw new BadMotion(name, key, `"${row}" uses a glyph whose width a terminal gets to decide`);
+                }
+                for (const run of row.match(/%+/g) ?? []) {
+                    if (run.length !== faceWidth)
+                        throw new BadMotion(name, key, `a ${run.length}-cell face slot, and the faces are ${faceWidth}`);
+                }
+                for (const run of row.match(/#+/g) ?? []) {
+                    if (run.length !== tellWidth)
+                        throw new BadMotion(name, key, `a ${run.length}-cell tell slot, and the tells are ${tellWidth}`);
+                }
+            }
+        }
+        return frames;
+    };
+    const poses = {};
+    for (const [key, cell] of Object.entries(motion.poses))
+        poses[key] = frame(key, cell);
+    if (!poses['idle.front'] && !poses.idle)
+        throw new BadMotion(name, 'idle', 'no idle to fall back to');
+    const overrides = {};
+    for (const [mood, byPose] of Object.entries(motion.overrides ?? {})) {
+        const framed = {};
+        for (const [key, cell] of Object.entries(byPose))
+            framed[key] = frame(`${mood}/${key}`, cell);
+        overrides[mood] = framed;
+    }
+    const every = [...Object.values(poses), ...Object.values(overrides).flatMap((byPose) => Object.values(byPose))];
+    const reach = { left: 0, right: 0 };
+    for (const frames of every) {
+        const anchor = anchorOf(frames);
+        const { width } = metric(frames[0]);
+        reach.left = Math.max(reach.left, anchor);
+        reach.right = Math.max(reach.right, width - 1 - anchor);
+    }
+    return { ...motion, poses, overrides, reach };
+}
+export function getCreature(name) {
+    return BOOD.get(name);
+}
+/** Every one registered, in registration order. */
+export function listCreatures() {
+    return [...BOOD.values()];
+}
+export function creatureNames() {
+    return [...BOOD.keys()];
+}
+/**
+ * A miss is drawn, not thrown.
+ *
+ * A name that is not registered is a runtime miss - the same thing a missing
+ * component registration is - and the answer is the first creature registered
+ * rather than a blank space, because a blank space in the middle of an empty
+ * screen looks like the screen is broken.
+ */
+function resolve(name) {
+    return (name === undefined ? undefined : BOOD.get(name)) ?? BOOD.values().next().value;
+}
+/** The rows of one creature, in one mood, at one size. */
+export function drawCreature(name, mood = 'happy', options = {}) {
+    const frames = creatureFrames(name, mood, options.form);
+    const at = ((options.frame ?? 0) % frames.length + frames.length) % frames.length;
+    return frames[at];
+}
+/** Every frame of one cell. One long, where the drawing does not move. */
+export function creatureFrames(name, mood = 'happy', form = 'draw') {
+    const creature = resolve(name);
+    if (!creature)
+        return [[]];
+    return creature.art[form][mood];
+}
+/** What a form costs for one creature, whatever mood it is in. */
+export function creatureSize(name, form = 'draw') {
+    return resolve(name)?.size[form] ?? { width: 0, height: 0 };
+}
+/** The tallest anyone in the bood is, for a caller deciding whether there is room. */
+export function boodHeight(form = 'draw') {
+    return Math.max(0, ...listCreatures().map((creature) => creature.size[form].height));
+}
+/**
+ * The chain, and the chain is the design rather than the first hit.
+ *
+ * A species that has no left view of a pose falls through to its front one and
+ * still reads right; the owl's glide is deliberately front-only, because a
+ * bird planing is not pointed anywhere in particular. Overrides come first at
+ * every step, so a mood that changes the outline rather than the expression -
+ * the cat at a keyboard while a turn is running - wins before a facing does.
+ */
+export function poseFrames(name, pose, facing, mood) {
+    const motion = resolve(name)?.motion;
+    if (!motion)
+        return undefined;
+    const chain = [
+        `${pose}.${facing}`, `${pose}.front`, `${pose}.right`, pose,
+        `idle.${facing}`, 'idle.front', 'idle',
+    ];
+    const override = motion.overrides[mood];
+    for (const key of chain) {
+        const hit = override?.[key] ?? motion.poses[key];
+        if (hit)
+            return hit;
+    }
+    return undefined;
+}
+/** The moving half of one creature, or nothing if it was never drawn moving. */
+export function creatureMotion(name) {
+    return resolve(name)?.motion;
+}
+/** Which of the bood have been drawn moving, for a picker that offers it. */
+export function livelyNames() {
+    return listCreatures().filter((creature) => creature.motion).map((creature) => creature.name);
+}

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

@@ -0,0 +1,31 @@
+import type { BoxProps, RenderOutput, SemanticVariant } from '@textui/core';
+import type { Form, Mood } from './types.js';
+export interface CreatureProps extends BoxProps {
+    /** Which one. Left out, one is picked at random and kept for this mount. */
+    name?: string;
+    mood?: Mood;
+    /** How much room it gets: the whole figure, a 3x5 portrait, or one line of 5. */
+    form?: Form;
+    /**
+     * Off pins frame zero - the still.
+     *
+     * Also pinned when the runtime has animation off, without asking: `useFrame`
+     * returns zero there, which is the whole reason frame zero is the still.
+     */
+    animated?: boolean;
+    /** Override the mood's own tone. */
+    tone?: SemanticVariant;
+    /**
+     * Gravity, and a will of its own.
+     *
+     * Opt-in, and it needs a creature that has been drawn moving - three of the
+     * six have been. Anything else keeps the still it always had rather than
+     * jittering in place, because a creature with no walk cycle standing in a
+     * ten-row box is worse than a creature in one row.
+     */
+    lively?: boolean;
+    /** The field it lives in, in cells. Only read when `lively`. */
+    fieldWidth?: number;
+    fieldHeight?: number;
+}
+export declare const Creature: (props: CreatureProps) => RenderOutput;