multirepo

2026-09-04 13:54:54 +03:00
parent 1553c48807
commit 5b2452aa50
41 changed files with 544 additions and 2 deletions
@@ -0,0 +1,61 @@
+import Decimal, { DecimalSource } from "break_eternity.js";
+import { BehaviourDisplayInfo, BehaviourLink, BehaviourSocket, Resource, Resources, SerializedBehaviour } from "../types";
+
+export abstract class Behaviour {
+    public readonly id: string;
+    public readonly kind: string;
+    public readonly inputLinks: BehaviourLink[];
+
+    constructor(source: SerializedBehaviour) {
+        this.id = source.id;
+        this.kind = source.kind;
+        this.inputLinks = source.inputLinks.pins;
+    }
+
+    public getDisplayInfo(): BehaviourDisplayInfo {
+        return {
+            storages: {},
+            sockets: [
+                ...this.inputs.map((input, index) => ({
+                    type: 'input',
+                    index,
+                    resource: input,
+                } satisfies BehaviourSocket)),
+                ...this.outputs.map((output, index) => ({
+                    type: 'output',
+                    index,
+                    resource: output,
+                } satisfies BehaviourSocket)),
+            ],
+        };
+    }
+
+    public abstract get inputs(): Resource[];
+    public abstract get outputs(): Resource[];
+
+    /** Withdraws up to `amount` of `resource` from this behaviour's storage, returning how much was actually taken. */
+    public abstract take(resource: Resource, amount: DecimalSource): Decimal;
+
+    protected abstract give(resource: Resource, amount: DecimalSource): void;
+
+    /** Snapshot of everything currently held, keyed by resource. */
+    public abstract getStorage(): Partial<Resources>;
+
+    abstract reset(): void;
+
+    /**
+     * Advances this behaviour by `deltaTime`. Must pull whatever inputs it needs (via `resolve`)
+     * before advancing its own cycle, so that a cycle only completes once enough input was actually
+     * available — otherwise it stalls and tries again on a later tick.
+     *
+     * `fairShare(sourceId, resource)` caps how much of `resource` may be pulled from `sourceId` this
+     * tick: when several behaviours are linked to the same source for the same resource, each is
+     * capped to an equal share of what that source held right after its own tick, regardless of
+     * pull order, instead of whoever asks first draining it.
+     */
+    abstract tick(
+        deltaTime: number,
+        resolve: (id: string) => Behaviour | undefined,
+        fairShare: (sourceId: string, resource: Resource) => Decimal,
+    ): void;
+}