@zergai/ztc 0.4.0-beta.1 → 0.5.0-beta.1

package/dist/simulation/living/shared-kinds.d.ts

@@ -0,0 +1,24 @@
+import { type LivingKindDefinition } from './open-world.js';
+export declare const SHARED_KINDS: readonly LivingKindDefinition[];
+export declare function sharedKindMap(engine?: number): Record<string, LivingKindDefinition>;
+export declare const SLOT_RULES_ENGINE = 42;
+export declare function staysInPlace(kind: {
+    mechanics: readonly {
+        kind: string;
+    }[];
+    neverHeld?: boolean;
+} | undefined): boolean;
+export declare function neverHeld(engine: number, kindId: string, kind: {
+    mechanics: readonly {
+        kind: string;
+    }[];
+    neverHeld?: boolean;
+} | undefined): boolean;
+export declare function sealedPaper(engine: number, entity: {
+    kindId: string;
+    properties: Record<string, {
+        value: unknown;
+    } | undefined>;
+}): boolean;
+export declare function namesPerson(engine: number, kindId: string, propertyId: string): boolean;
+export declare function oneEachSlot(engine: number, kindId: string): string | null;

package/dist/simulation/living/shared-kinds.js

@@ -0,0 +1,96 @@
+import { kindDefinitionSchema } from './open-world.js';
+import { BODILESS_ENGINE, LIVING_ENGINE_VERSION, VOTES_ENGINE } from './types.js';
+// These definitions are data. The reducer gives each mechanic the same meaning
+// regardless of which kind attaches it.
+export const SHARED_KINDS = [
+    {
+        id: 'fire', name: 'Fire', meaning: 'Heat and flame that may grow or move.',
+        properties: [{ id: 'intensity', type: 'level' }, { id: 'severity', type: 'number' }], relations: [{ id: 'connected-to', targetKindId: 'fire' }],
+        mechanics: [{ kind: 'spread', propertyId: 'intensity', relationId: 'connected-to' }, { kind: 'signal', propertyId: 'intensity', relationId: 'connected-to', channel: 'sight' },
+            { kind: 'trigger', propertyId: 'severity', threshold: 1, direction: 'at-least', intent: 'Check the consequences of this danger.', delayMinutes: 15, minImportance: 7 }],
+    },
+    {
+        id: 'water', name: 'Water', meaning: 'Liquid that may flow to connected places.',
+        properties: [{ id: 'amount', type: 'level' }], relations: [{ id: 'connected-to', targetKindId: 'water' }],
+        mechanics: [{ kind: 'spread', propertyId: 'amount', relationId: 'connected-to' }],
+    },
+    {
+        id: 'smoke', name: 'Smoke', meaning: 'Airborne matter that can be seen or smelled.',
+        properties: [{ id: 'density', type: 'level' }, { id: 'severity', type: 'number' }], relations: [{ id: 'connected-to', targetKindId: 'smoke' }],
+        mechanics: [{ kind: 'spread', propertyId: 'density', relationId: 'connected-to' }, { kind: 'signal', propertyId: 'density', relationId: 'connected-to', channel: 'smell' },
+            { kind: 'trigger', propertyId: 'severity', threshold: 1, direction: 'at-least', intent: 'Check the consequences of this danger.', delayMinutes: 15, minImportance: 7 }],
+    },
+    {
+        id: 'sound', name: 'Sound', meaning: 'A disturbance that can be heard along a channel.',
+        properties: [{ id: 'strength', type: 'level' }], relations: [{ id: 'connected-to', targetKindId: 'sound' }],
+        mechanics: [{ kind: 'signal', propertyId: 'strength', relationId: 'connected-to', channel: 'sound' }],
+    },
+    { id: 'injury', name: 'Injury', meaning: 'Physical harm to a living person.', properties: [{ id: 'severity', type: 'level' }, { id: 'person', type: 'id' }], relations: [],
+        mechanics: [{ kind: 'gate', propertyId: 'severity', subjectPropertyId: 'person', atLeast: 'high', blockedActionKinds: ['incapacitate'] }] },
+    { id: 'illness', name: 'Illness', meaning: 'A condition that affects a living person over time.', properties: [{ id: 'severity', type: 'level' }, { id: 'person', type: 'id' }], relations: [],
+        mechanics: [{ kind: 'gate', propertyId: 'severity', subjectPropertyId: 'person', atLeast: 'high', blockedActionKinds: ['incapacitate'] }] },
+    { id: 'posture', name: 'Posture', meaning: 'A person’s current physical position.', properties: [{ id: 'state', type: 'level' }, { id: 'person', type: 'id' }], relations: [],
+        mechanics: [{ kind: 'change', propertyId: 'state', deltaPerMinute: 0, onEvent: { kind: 'move', subjectPropertyId: 'person', value: 'none' } }] },
+    { id: 'custody', name: 'Custody', meaning: 'Control of a person or thing by another.', properties: [{ id: 'holder', type: 'id' }, { id: 'held', type: 'id' }], relations: [],
+        mechanics: [{ kind: 'gate', propertyId: 'holder', subjectPropertyId: 'held', blockedActionKinds: ['move'] }] },
+    { id: 'money', name: 'Money', meaning: 'A transferable amount of value.', properties: [{ id: 'amount', type: 'number' }, { id: 'owner', type: 'id' }], relations: [], mechanics: [] },
+    { id: 'debt', name: 'Debt', meaning: 'An amount one party owes another.', properties: [{ id: 'quantity', type: 'number' }, { id: 'debtor', type: 'id' }, { id: 'recipient', type: 'id' }, { id: 'creditor', type: 'id' }], relations: [], mechanics: [] },
+    { id: 'authority', name: 'Authority', meaning: 'A grant of power to act for a group.', properties: [{ id: 'active', type: 'flag' }, { id: 'holder', type: 'id' }], relations: [], mechanics: [] },
+    { id: 'detention', name: 'Detention', meaning: 'A person is held under another’s authority.', properties: [{ id: 'active', type: 'flag' }, { id: 'subject', type: 'id' }, { id: 'holder', type: 'id' }], relations: [],
+        mechanics: [{ kind: 'gate', propertyId: 'active', subjectPropertyId: 'subject', blockedActionKinds: ['move'] }] },
+    { id: 'document', name: 'Document', meaning: 'A written record with content, an author and a date.', properties: [{ id: 'body', type: 'text', requiredOnCreate: true }, { id: 'author', type: 'id' }, { id: 'recorded-at', type: 'time' }, { id: 'signed', type: 'flag' }], relations: [], mechanics: [] },
+    { id: 'decision', name: 'Decision', meaning: 'A question its members settle by vote: each casts their own ballot, and the count decides it, not anyone\'s word.',
+        properties: [{ id: 'question', type: 'text', requiredOnCreate: true }, { id: 'needed', type: 'number' }, { id: 'opens-at', type: 'time' }, { id: 'closes-at', type: 'time' }], relations: [], mechanics: [] },
+    { id: 'item', name: 'Item', meaning: 'An ordinary physical thing, such as a tool, food, a container or a device; its condition says how it is now.', properties: [], relations: [], mechanics: [] },
+].map(definition => kindDefinitionSchema.parse(definition));
+// The engine that began a world decides its shared kinds, so an older save replays with the kinds it began with.
+const CLOCK_TIME_ENGINE = 38;
+// From engine 40 a thing in hand is simply held, so custody means only a person kept by another.
+const PERSON_CUSTODY_ENGINE = 40;
+const PERSON_CUSTODY = 'A person kept from leaving by another person; a thing in hand needs no custody.';
+// From engine 41 an ordinary thing has a kind of its own.
+const ITEM_ENGINE = 41;
+// From engine 42 a passing sound or a posture is no lasting thing: notices and conditions carry them.
+const PASSING_KINDS_ENGINE = 42;
+const PASSING_KINDS = new Set(['sound', 'posture']);
+export function sharedKindMap(engine = LIVING_ENGINE_VERSION) {
+    return Object.fromEntries(SHARED_KINDS.filter(kind => (kind.id !== 'item' || engine >= ITEM_ENGINE) && (kind.id !== 'decision' || engine >= VOTES_ENGINE)
+        && (!PASSING_KINDS.has(kind.id) || engine < PASSING_KINDS_ENGINE)).map((kind) => {
+        const timed = engine >= CLOCK_TIME_ENGINE ? kind
+            : { ...kind, properties: kind.properties.map(property => property.type === 'time' ? { ...property, type: 'number' } : property) };
+        const counted = kind.id === 'item' && engine >= SLOT_RULES_ENGINE ? { ...timed, properties: ITEM_SLOTS }
+            : kind.id === 'document' && engine >= SLOT_RULES_ENGINE ? { ...timed, meaning: SEALABLE_DOCUMENT, properties: [...timed.properties, { id: 'sealed', type: 'flag' }] } : timed;
+        return [kind.id, kind.id === 'custody' && engine >= PERSON_CUSTODY_ENGINE ? { ...counted, meaning: PERSON_CUSTODY } : counted];
+    }));
+}
+// From engine 42 an ordinary thing can be counted and owned, an id slot of a shared kind that names a
+// person must name one, and a person has one injury and one illness, which later rulings change.
+export const SLOT_RULES_ENGINE = 42;
+const ITEM_SLOTS = [{ id: 'count', type: 'number' }, { id: 'owner', type: 'id' }];
+const PERSON_SLOTS = {
+    injury: ['person'], illness: ['person'], custody: ['holder', 'held'], detention: ['subject', 'holder'], authority: ['holder'], money: ['owner'], item: ['owner'],
+};
+const ONE_EACH = { injury: 'person', illness: 'person' };
+// A sealed paper holds the words it was made with; no one reads or adds to them until it is opened.
+const SEALABLE_DOCUMENT = 'A written record with content, an author and a date; a sealed one keeps the words it was made with until someone opens it.';
+// A kind that spreads or carries through places, such as fire, water, smoke or sound, stays where it is: no one holds it.
+export function staysInPlace(kind) {
+    return kind?.neverHeld === true || (kind?.mechanics ?? []).some(mechanic => mechanic.kind === 'spread' || mechanic.kind === 'signal');
+}
+// Shared kinds that are a state of a person or a bond between people, not a thing: no one holds them.
+const BODILESS_KINDS = new Set(['injury', 'illness', 'posture', 'custody', 'detention', 'authority', 'debt', 'decision']);
+// Whether no one can hold a thing of this kind in a world begun on this engine.
+export function neverHeld(engine, kindId, kind) {
+    return staysInPlace(kind) || engine >= BODILESS_ENGINE && BODILESS_KINDS.has(kindId);
+}
+// Whether a thing is a paper still sealed, whose words no one may read or add to yet.
+export function sealedPaper(engine, entity) {
+    return engine >= SLOT_RULES_ENGINE && entity.kindId === 'document' && entity.properties.sealed?.value === true;
+}
+export function namesPerson(engine, kindId, propertyId) {
+    return engine >= SLOT_RULES_ENGINE && (PERSON_SLOTS[kindId]?.includes(propertyId) ?? false);
+}
+// The slot of which a person may have only one thing of this kind, if any.
+export function oneEachSlot(engine, kindId) {
+    return engine >= SLOT_RULES_ENGINE ? ONE_EACH[kindId] ?? null : null;
+}