@v12-engine/engine 0.0.0-stage → 0.1.0

package/dist/registry.d.ts

@@ -0,0 +1,464 @@
+import type { AdvanceState, AlongPath, AttackGroundState, AttackState, FollowState, HoldState, PatrolState } from './orders/basic';
+import type { GameFileDef } from './gameFiles';
+import type { ReplicatedEvent, SnapshotPart } from './replication';
+import { type DataDefs, type DataKind } from './gameData';
+import { Definitions } from './definitions';
+import type { BuildState, RepairState, WorkState } from './orders/build';
+import type { CastState } from './orders/cast';
+import type { HarvestState } from './orders/harvest';
+import type { ItemOrderState } from './orders/items';
+import type { BoardState, LoadState, UnloadState } from './transport';
+import type { RaceDef } from './races';
+import type { Logger } from './log';
+import type { Component } from './components';
+import { type EventKey } from './events';
+import type { EffectHandler, EffectKind } from './abilities/effects';
+import type { CommandDef } from './commands';
+import { type AbilityDef, type BuffDef, type DayCycle, type ItemDef, type ResourceDef, type ResourceKind, type StatDef, type Stats, type UnitTypeDef, type UpgradeDef, type UpkeepTier } from './defs';
+import type { Entity, EntityId, Order, PlayerId } from './entity';
+import type { Vec2 } from './math';
+import type { StatPart } from './stats';
+import type { FormationDef } from './formation';
+import type { AssembledGame, GameModule } from './game';
+import { type GameRules } from './rules';
+import type { TileDef } from './tiles';
+import type { PrefabDef } from './prefabs';
+import type { TunableDef } from './tunables';
+import type { World } from './world';
+import type { CellLayerDef } from './cellLayers';
+import type { ResolvedScore } from './score';
+/** @beta */
+export type OrderStatus = 'running' | 'done' | 'failed';
+/**
+ * What an order can be given, every order's field in one: for what reads an order of any type (the queue, a save, a
+ * screen's waypoints). An order of a type is given its own of them (`OrderInits`)
+ *
+ * @beta
+ */
+export interface OrderParams {
+    target?: EntityId;
+    point?: Vec2;
+    /** Type to build, for build orders */
+    unitType?: string;
+    /** Ability to use, for cast orders */
+    ability?: string;
+    /** An item: the one to use, drop or hand over by its place in the inventory, or the one on the ground to pick up */
+    item?: number;
+    /** Direction to face at the end. Commands fill this in with the direction of travel */
+    facing?: number;
+    /**
+     * For a move: the group goes at the pace of its slowest (campaign plan GP1), so that it arrives together. The
+     * command works the pace out (`speedCap`)
+     */
+    together?: boolean;
+    /** For a move: the fastest it goes, set by the command for a group that goes `together`: the slowest one's speed */
+    speedCap?: number;
+    /** A path of the map, by its name (`MapPath`): for the orders that go along one (`followPath`, `attackPath`) */
+    path?: string;
+    /**
+     * Which way along `path`: to its first point or its last. Away from the end the unit is nearer to when left out: a
+     * minion back on its lane after a chase, past its middle, goes on the way it was going
+     */
+    towards?: 'first' | 'last';
+}
+/**
+ * What each order type is given (`Order.init`), by type (design review E14): the engine's, and a game's own added by
+ * declaration merging, as `OrderStates` is:
+ *
+ * ```ts
+ * declare module '@v12-engine/engine' {
+ * 	interface OrderInits {
+ * 		'mygame.dig': { point?: Vec2 }
+ * 	}
+ * }
+ * ```
+ *
+ * Every field may be missing from what a command sends, which comes from a player: the behaviour's `accepts` checks
+ * what it needs
+ *
+ * @beta
+ */
+export interface OrderInits {
+    move: Pick<OrderParams, 'point' | 'facing' | 'target' | 'together' | 'speedCap'>;
+    hold: Pick<OrderParams, 'facing'>;
+    attack: Pick<OrderParams, 'target' | 'facing'>;
+    attackMove: Pick<OrderParams, 'point' | 'facing'>;
+    followPath: Pick<OrderParams, 'path' | 'towards'>;
+    attackPath: Pick<OrderParams, 'path' | 'towards'>;
+    patrolPath: Pick<OrderParams, 'path' | 'towards'>;
+    patrol: Pick<OrderParams, 'point' | 'facing'>;
+    follow: Pick<OrderParams, 'target'>;
+    attackGround: Pick<OrderParams, 'point' | 'target'>;
+    cast: Pick<OrderParams, 'ability' | 'item' | 'target' | 'point'>;
+    harvest: Pick<OrderParams, 'target'>;
+    return: Pick<OrderParams, 'target'>;
+    build: Pick<OrderParams, 'unitType' | 'point' | 'facing'>;
+    construct: Pick<OrderParams, 'target'>;
+    repair: Pick<OrderParams, 'target'>;
+    pickUp: Pick<OrderParams, 'target' | 'item'>;
+    dropItem: Pick<OrderParams, 'item' | 'point' | 'target'>;
+    board: Pick<OrderParams, 'target'>;
+    load: Pick<OrderParams, 'target'>;
+    unload: Pick<OrderParams, 'point'>;
+}
+/**
+ * What an order of a type is given: its `OrderInits` entry, every order's fields (`OrderParams`) for a type not in it
+ *
+ * @beta
+ */
+export type OrderInitOf<Type extends string> = Type extends keyof OrderInits ? OrderInits[Type] : OrderParams;
+/**
+ * What a command asks a unit to do: the order's type and what it is given (`OrderInitOf`). Turned into an `Order` once
+ * it is accepted
+ *
+ * @beta
+ */
+export type OrderInit<Type extends string = string> = {
+    type: Type;
+    /**
+     * The formation units ordered to a point together take, by id (`FormationDef`): the engine's `rows`, `circle`,
+     * `square` or `none`, or a game's own. What the rules say (`GameRules.movement.formation`: `rows`) when left out
+     */
+    formation?: string;
+} & OrderInitOf<Type>;
+/**
+ * Logic behind an order type. Orders are the only way units act, which is what
+ * makes queueing work for everything. Game modules can register their own.
+ *
+ * `State` is what it keeps in the order (`Order.state`), every field optional: the order starts with none of them.
+ * `OrderStates` names each order type's, for `registry.order(type)` to hand back the behaviour typed
+ *
+ * @beta
+ */
+export interface OrderBehavior<State extends object = Record<string, any>, Init extends object = OrderParams> {
+    type: string;
+    /** Units ordered to a point together are spread out in a formation instead of all walking to the same spot */
+    formation?: boolean;
+    /** Whether the entity is able to carry out this order at all */
+    accepts(world: World, entity: Entity, init: Init): boolean;
+    /** Called once when the order reaches the front of the queue */
+    start?(world: World, entity: Entity, order: Order<State, Init>): void;
+    update(world: World, entity: Entity, order: Order<State, Init>, dt: number): OrderStatus;
+    /** Called when the order finishes or is interrupted, to undo anything it left behind */
+    end?(world: World, entity: Entity, order: Order<State, Init>): void;
+    /**
+     * Whether the unit is in the middle of it and cannot be called away (a cast past turning back): what was to come
+     * after is dropped, it is finished first (`interrupt`). Never, when left out
+     */
+    committed?(order: Order<State, Init>): boolean;
+    /**
+     * Whether the unit stands waiting by a fight for a spot in it (an attack-move held up): an ally on its way may ask it
+     * aside (`rules.movement.makesWay`). Never, when left out
+     */
+    waiting?(order: Order<State, Init>): boolean;
+    /** Whether the unit keeps something up that being stunned breaks off (a channelled ability). Never, when left out */
+    channelling?(order: Order<State, Init>): boolean;
+    /** Whether the unit has begun what it builds (its site is down): what it builds is counted as itself. Never, when left out */
+    building?(order: Order<State, Init>): boolean;
+}
+/**
+ * A fact the engine asks of an order, its behaviour's to say (`OrderBehavior.committed`, `waiting`, `channelling`,
+ * `building`)
+ *
+ * @beta
+ */
+export type OrderFact = 'committed' | 'waiting' | 'channelling' | 'building';
+/**
+ * What each order type keeps in its orders (`Order.state`), by type: the engine's, and a game's own added to it by
+ * declaration merging, for `registry.order(type)` to say what its behaviour keeps:
+ *
+ * ```ts
+ * declare module '@v12-engine/engine' {
+ * 	interface OrderStates {
+ * 		'mygame.dig': { dug?: number }
+ * 	}
+ * }
+ * ```
+ *
+ * @beta
+ */
+export interface OrderStates {
+    move: NoState;
+    hold: HoldState;
+    attack: AttackState;
+    attackMove: AdvanceState;
+    followPath: AlongPath;
+    attackPath: AlongPath & AdvanceState;
+    patrol: PatrolState;
+    follow: FollowState;
+    attackGround: AttackGroundState;
+    cast: CastState;
+    harvest: HarvestState;
+    return: HarvestState;
+    build: BuildState;
+    construct: WorkState;
+    repair: RepairState;
+    pickUp: ItemOrderState;
+    dropItem: ItemOrderState;
+    board: BoardState;
+    load: LoadState;
+    unload: UnloadState;
+}
+/**
+ * What an order that keeps nothing keeps
+ *
+ * @beta
+ */
+export type NoState = Record<string, never>;
+/**
+ * What an order of a type keeps: its `OrderStates` entry, any plain data for a type not in it
+ *
+ * @beta
+ */
+export type OrderStateOf<Type extends string> = Type extends keyof OrderStates ? OrderStates[Type] : Record<string, any>;
+/**
+ * The part of a tick a system runs in, see `PHASES` in the scheduler
+ *
+ * @beta
+ */
+export type SystemPhase = 'commands' | 'decide' | 'move' | 'resolve' | 'cleanup';
+/**
+ * Something that runs every tick, or every few: moves units, lands attacks, works out what each team sees.
+ * When it runs is worked out once, from its phase, then from what it says it comes before and after.
+ *
+ * @beta
+ */
+export interface System {
+    /** Unique in a world. A game's system with the name of a core one takes its place */
+    name: string;
+    /** `cleanup` when left out: after everything else in the tick */
+    phase?: SystemPhase;
+    /** Names of systems in the same phase this one runs ahead of, or after */
+    before?: string[];
+    after?: string[];
+    /** Runs once in so many ticks, for work that does not need doing every tick. Every tick when left out */
+    every?: number;
+    /** With `every`, the tick in each round it runs at: systems with the same `every` and other offsets spread the work */
+    offset?: number;
+    /**
+     * `dt` is the time since it last ran: the length of a tick, times `every`. Before `each`, for a system that has
+     * both. One of the two is needed
+     */
+    update?(world: World, dt: number): void;
+    /**
+     * What `each` is run for (OB5): every actor (`'actors'`, when left out), what has a component, in the order of its
+     * id as a walk through the actors would meet it (`EntityIndex.ordered`: a system about a few, like the buildings
+     * that train, does not look at every unit and tree), or the actors a test says yes to
+     *
+     * @beta
+     */
+    over?: SystemOver;
+    /**
+     * Run for each entity of `over`, in order, after `update`. The dead are not left out: a system that wants only the
+     * living says so
+     *
+     * @beta
+     */
+    each?(world: World, entity: Entity, dt: number): void;
+    /**
+     * What it keeps in itself, for a save: plain data. For state that is easier kept in a system than in a component
+     * (`World.state`): a computer player's plans, a director's mood
+     */
+    save?(world: World): unknown;
+    /** Takes back what `save` gave, in a world loaded from a save: when it is made, or added again (`addSystem`) */
+    restore?(world: World, data: unknown): void;
+}
+/**
+ * What a system runs `each` for (`System.over`): every actor, what has a component, or the actors a test says yes to
+ *
+ * @beta
+ */
+export type SystemOver = 'actors' | Component<unknown, unknown> | ((entity: Entity, world: World) => boolean);
+/**
+ * A system, or what makes one for each world: for a system that keeps state of its own, which belongs to one game
+ *
+ * @beta
+ */
+export type SystemDef = System | ((world: World) => System);
+/**
+ * What is thrown for a component or an event of its own that a game uses without listing it (`GameModule.components`,
+ * `GameModule.events`): no world finds it by its id, so a save, a snapshot or the index would lose it
+ *
+ * @beta
+ */
+export declare class UnlistedError extends Error {
+    /** What it is: a component or an event */
+    readonly kind: 'component' | 'event';
+    /** Its id */
+    readonly id: string;
+    /** The id of the game that used it */
+    readonly game: string;
+    constructor(
+    /** What it is: a component or an event */
+    kind: 'component' | 'event', 
+    /** Its id */
+    id: string, 
+    /** The id of the game that used it */
+    game: string);
+}
+/** @beta */
+export declare class Registry {
+    /** The game's unit types, buildings and resources (`GameModule.units`) */
+    readonly units: Definitions<UnitTypeDef>;
+    /** The orders units can be given, the engine's and the game's, by type */
+    readonly orders: Definitions<OrderBehavior<Record<string, any>, OrderParams>>;
+    /** How groups line up (`GameModule.formations`) */
+    readonly formations: Definitions<FormationDef>;
+    /** The game's research (`GameModule.upgrades`) */
+    readonly upgrades: Definitions<UpgradeDef>;
+    /** Every ability there is, of units, heroes and items alike (`GameModule.abilities`) */
+    readonly abilities: Definitions<AbilityDef>;
+    /** The game's buffs (`GameModule.buffs`) */
+    readonly buffs: Definitions<BuffDef>;
+    /** The game's items (`GameModule.items`) */
+    readonly items: Definitions<ItemDef>;
+    /** The game's races, in its order (`GameModule.races`): none in a game without */
+    readonly races: Definitions<RaceDef>;
+    /** The game's prefabs (`GameModule.prefabs`) */
+    readonly prefabs: Definitions<PrefabDef>;
+    /** The commands a world takes, the engine's and the game's, by type */
+    readonly commands: Definitions<CommandDef<import("./fields").Fields>>;
+    /** What each type of an ability's effect does, by type */
+    readonly effects: Definitions<EffectKind<keyof import("./defs").EffectTypes>>;
+    /**
+     * The kinds of definition a game's data is kept for (`DataKind`), each its collection: what the Data panel, mods,
+     * saves and a game's reload walk, one loop each
+     */
+    readonly kinds: {
+        readonly [K in DataKind]: Definitions<DataDefs[K]>;
+    };
+    /** The components the game lists (`GameModule.components`), and those its app keeps in its worlds, by id */
+    private readonly components;
+    /** The engine's own components (`coreComponents`) and the listed, by id: what `component` finds, in one look */
+    private readonly known;
+    /** The events of its own the game lists (`GameModule.events`), by id */
+    private readonly events;
+    /** Takes in the components and events a game lists. Throws for an id that is there twice, another way */
+    defineParts(components: readonly Component<unknown>[], events: readonly EventKey<unknown>[]): void;
+    /** A component of this game by its id: one the game lists, or one of the engine's own (`coreComponents`). None for any other */
+    component(id: string): Component<unknown> | undefined;
+    /** A component of this game by its id, as something of the world uses it: throws for one the game does not list (`UnlistedError`) */
+    used(id: string): Component<unknown>;
+    /**
+     * An event of the game's own by its id: listed, or the engine's (`core.`). One of a game's that it does not list
+     * throws (`UnlistedError`)
+     */
+    event(id: string): EventKey<unknown> | undefined;
+    /**
+     * The components the game lists, for what goes through them all: the map's fields they have
+     *
+     * @beta
+     */
+    listedComponents(): Iterable<Component<unknown, unknown>>;
+    /** Whether the game lists a component or an event, or it is one of the engine's own */
+    lists(kind: 'component' | 'event', id: string): boolean;
+    /** The log of the world this is the registry of, once there is one (`World.log`) */
+    log?: Logger;
+    /**
+     * Takes the definitions of another registry of the same game over its own (`world.reload`): its unit types,
+     * abilities, buffs, items, upgrades and races, the code of its effects and orders, its rules, and its module. Those
+     * it has that the other has not are kept (a world may have units of them). What the game is made of otherwise (its
+     * resources, stats, components, events) stays as it is: a world was made of it
+     */
+    takeFrom(other: Registry): void;
+    /** Lowest threshold first. Empty for a game without upkeep */
+    upkeep: UpkeepTier[];
+    /** Id of the game module it was made from */
+    game: string;
+    /** The game module it was made from */
+    module: GameModule | null;
+    private hashed?;
+    /** What identifies the game exactly, mods and code included (see `gameHash`). Worked out the first time it is asked for */
+    get hash(): string;
+    private dataHashed?;
+    /**
+     * What identifies the game's data: everything but how its code reads (see `gameHash`). What a server and a player
+     * check they share: the two run builds of the same code that print it differently
+     */
+    get dataHash(): string;
+    /** The version of what the game keeps in a save (`GameModule.saves.version`): 1 for a game that says none */
+    get saveVersion(): number;
+    /** The game's own stats, next to the engine's (`GameModule.stats`) */
+    stats: StatDef[];
+    /** The game put together with its packs (`assembleGame`): set as the registry is made of it */
+    assembly: AssembledGame | null;
+    /** The engine's parts and the game's that give an entity something as it is made (`Component.onSpawn`), in order */
+    spawning: readonly Component<unknown, unknown>[];
+    /** The engine's parts and the game's that call something off as an entity leaves its owner (`Component.onLeave`) */
+    leaving: readonly Component<unknown, unknown>[];
+    /** The engine's parts and the game's that may have a structure stand open, in nobody's way (`Component.passable`) */
+    passing: readonly Component<unknown, unknown>[];
+    /** Whether a structure stands open now, in nobody's way, by its parts (`Component.passable`): a gate opened */
+    standsOpen(entity: Entity): boolean;
+    /** What the game's packs add to a unit's stats (`GamePack.stats`): a hero's growth */
+    statParts: StatPart[];
+    /** How each event of the world is told to a player, the engine's then the packs' (`replicateEvent`), in order */
+    replications: readonly ReplicatedEvent[];
+    /** The parts of a player's snapshot, the engine's then the packs' (`SnapshotPart`), in order */
+    snapshotParts: readonly SnapshotPart[];
+    /** What the game counts of its players (`GameRules.score`), its stats made: null for a game that counts nothing */
+    score: ResolvedScore | null;
+    /** What each of the game's own files was read as (`GameModule.files`), by id */
+    private files;
+    /** The game's own files (`GameModule.files`), by id */
+    private fileDefs;
+    /** What the rules read of a file of the game's own data (`GameModule.files`): throws for one the game does not list */
+    file<T>(def: GameFileDef<T>): T;
+    /** Puts what a file of the game's is read as, for this registry's world alone: the editor's panel, as it is edited */
+    setFile<T>(def: GameFileDef<T>, value: T): void;
+    /** A file of the game's own data by its id (`waves.json`): what reads it, for an editor that writes it. None for one the game does not list */
+    fileDef(id: string): GameFileDef<unknown> | undefined;
+    /** A prefab of the game's by id, for `world.spawnPrefab`; throws for one there is not */
+    prefab(id: string): PrefabDef;
+    /** What the ground can be painted with, in the order of their indices: the first is 1 (`GameModule.tiles`) */
+    tiles: TileDef[];
+    /** The game's layers of cells (`GameModule.cellLayers`): what `Terrain.cells` is keyed by, with what each means */
+    cellLayers: CellLayerDef[];
+    /** The numbers of the rules to be tuned while the game plays (`GameModule.tunables`) */
+    tunables: TunableDef[];
+    /** A tunable by id, or nothing for one the game does not have */
+    tunable(id: string): TunableDef | undefined;
+    /** The index of a tile of the game, for painting the ground in code: `terrain.tiles[cell] = registry.tile('road')` */
+    tile(id: string): number;
+    /** The ids of the game's tiles, in the order of their indices */
+    get tileIds(): string[];
+    /** Every stat there is in the game, the engine's first */
+    statKeys: string[];
+    /** Every stat of the game at 0, its own at their default: what base stats start from */
+    statDefaults: Readonly<Stats>;
+    /** The game's numbers that are not about any one unit (`GameModule.rules`) */
+    rules: Readonly<GameRules>;
+    /** Null for a game where it is always day */
+    day: DayCycle | null;
+    /** What the game tells each player about itself, see `GameModule.report`. Asked by the session that runs the world */
+    report: ((world: World, player: PlayerId) => Record<string, unknown>) | null;
+    /** The resources of the game, in the order players are shown them */
+    resources: ResourceDef[];
+    /**
+     * The resource prices, bounties, revives and sales are in: the game's money. Null for a game without one,
+     * where there is nothing of that kind to pay with
+     */
+    currency: ResourceKind | null;
+    /** The command type, or undefined for one the game does not have: commands come from outside, and may name anything */
+    command(type: string): CommandDef | undefined;
+    /** The definition of a resource, or undefined for one the game does not have */
+    resource(id: ResourceKind): ResourceDef | undefined;
+    /** A unit type by id: throws for one the game does not have (`units`) */
+    unit(id: string): UnitTypeDef;
+    /** An upgrade by id: throws for one the game does not have (`upgrades`) */
+    upgrade(id: string): UpgradeDef;
+    /** A race by id: throws for one the game does not have (`races`) */
+    race(id: string): RaceDef;
+    /** An ability by id: throws for one the game does not have (`abilities`) */
+    ability(id: string): AbilityDef;
+    /** A buff by id: throws for one the game does not have (`buffs`) */
+    buff(id: string): BuffDef;
+    /** An item by id: throws for one the game does not have (`items`) */
+    item(id: string): ItemDef;
+    /** What an effect type does: throws for one there is not (`effects`) */
+    effect(type: string): EffectHandler;
+    /** An order type's behaviour, typed by what its orders keep (`OrderStates`): throws for one there is not (`orders`) */
+    order<Type extends string>(type: Type): OrderBehavior<OrderStateOf<Type>, OrderInitOf<Type>>;
+    /** A formation by id: throws for one there is not (`formations`) */
+    formation(id: string): FormationDef;
+}

package/dist/remains.d.ts

@@ -0,0 +1,119 @@
+import type { GamePack } from './packs/pack';
+import type { ResourceKind, UnitTypeDef } from './defs';
+import type { Entity, PlayerId } from './entity';
+import type { World } from './world';
+/**
+ * What rubble or a pile is to be, as a game says it for a death: the unit type it is, and how much of its resource it
+ * holds (the type's `resource.amount` when left out)
+ *
+ * @beta
+ */
+export interface RemainsSpec {
+    type: string;
+    amount?: number;
+}
+/**
+ * What the remains of a game are made of (`withRemains`)
+ *
+ * @beta
+ */
+export interface RemainsOptions {
+    /**
+     * The rubble a fallen building leaves, put down where it stood once it is gone: a type (a resource with a footprint,
+     * see `rubbleType`), worked out for the death, or `null` for none. None when left out
+     */
+    rubble?: string | ((world: World, dead: Entity) => RemainsSpec | string | null | undefined);
+    /**
+     * The pile a fallen unit drops: a type (a resource with no footprint, see `pileType`) and how much, or `null` for
+     * none. None when left out
+     */
+    piles?: (world: World, dead: Entity, killer: Entity | undefined) => RemainsSpec | null | undefined;
+    /** How near a unit comes to a pile to pick it up, in cells: 0.8 when left out */
+    reach?: number;
+    /** Who may pick a pile up: any unit of a player's that is not a structure, when left out */
+    picksUp?: (world: World, unit: Entity, pile: Entity) => boolean;
+}
+/**
+ * What a pile holds: the resource and how much. Told to everyone, for its look and its tooltip
+ *
+ * @beta
+ */
+export declare const pileOf: import("./components").Component<{
+    kind: ResourceKind;
+    amount: number;
+}, {
+    kind: ResourceKind;
+    amount: number;
+}>;
+/** The piles there are and the rubble to put down once the building it is of is gone, kept with the world */
+export declare const remains: import("./components").Component<{
+    piles: number[];
+    rubble: Record<number, {
+        type: string;
+        amount?: number;
+        x: number;
+        z: number;
+    }>;
+}, {
+    piles: number[];
+    rubble: Record<number, {
+        type: string;
+        amount?: number;
+        x: number;
+        z: number;
+    }>;
+}>;
+/**
+ * A pile was picked up: by whom (a unit's id and its owner), what and how much
+ *
+ * @beta
+ */
+export declare const pileTaken: import("./events").EventKey<{
+    pile: number;
+    by: number;
+    player: PlayerId;
+    kind: ResourceKind;
+    amount: number;
+}>;
+/**
+ * A type of rubble, to put in the game's units: a resource that blocks its footprint, gathered (cleared) as `kind`
+ * by the game's workers, with no look of its own (the game's looks give it one)
+ *
+ * @beta
+ */
+export declare function rubbleType(def: {
+    id: string;
+    name?: string;
+    footprint: {
+        w: number;
+        d: number;
+    };
+    kind: ResourceKind;
+    amount?: number;
+    slots?: number;
+}): UnitTypeDef;
+/**
+ * A type of pile, to put in the game's units: something lying on the ground that blocks nothing, is fought by nobody,
+ * and is handed (`pileOf`: its kind and how much) to who walks over it. `kind` and `amount` are what it holds when the
+ * death that drops it says nothing else
+ *
+ * @beta
+ */
+export declare function pileType(def: {
+    id: string;
+    name?: string;
+    kind: ResourceKind;
+    amount?: number;
+}): UnitTypeDef & {
+    pile: {
+        kind: ResourceKind;
+        amount: number;
+    };
+};
+/**
+ * Remains that are things for a game (`RemainsOptions`): rubble where buildings fell, piles where units did. The game
+ * is the same otherwise; its units list the types (`rubbleType`, `pileType`, or its own)
+ *
+ * @beta
+ */
+export declare function withRemains(options?: RemainsOptions): GamePack;