@v12-engine/engine 0.0.0-stage → 0.1.1

package/dist/debugCommands.d.ts

@@ -0,0 +1,213 @@
+import { type CommandDef, type DefinedCommand } from './commands';
+import type { PlayerId } from './entity';
+import { type Check, type Checked, type Fields } from './fields';
+import type { World } from './world';
+import { type TerrainPatch } from './ground';
+import type { MapObject } from './map';
+/**
+ * A debug command of a game's or a scene's own: one that goes through only for players allowed the debug tools
+ * (`world.debugPlayers`), and tells others so. Otherwise like `defineCommand`
+ *
+ * @beta
+ */
+export declare function defineDebugCommand<const T extends string, F extends Fields>(type: T, fields: F, execute: (world: World, player: PlayerId, command: Checked<F>) => void): DefinedCommand<T, F>;
+/**
+ * A prefab of the game's put down where it says, for the sender, turned as said: to try one out, and for the editor's Play
+ *
+ * @beta
+ */
+export declare const spawnPrefabCommand: DefinedCommand<"debug.spawnPrefab", {
+    prefab: Check<string>;
+    at: Check<import("./math").Vec2>;
+    facing: Check<number | undefined>;
+}>;
+/**
+ * A switch for trying things out: abilities used again at once, abilities that cost no mana, the units of those who may
+ * use the debug tools unharmed (`World.cheats`)
+ *
+ * @beta
+ */
+export declare const cheatCommand: DefinedCommand<"debug.cheat", {
+    cheat: Check<"invulnerable" | "noCooldowns" | "noManaCosts">;
+    on: Check<boolean>;
+}>;
+/**
+ * Lifts the fog for the sender's team, or puts it back: in the simulation itself, so that units react to what is shown
+ *
+ * @beta
+ */
+export declare const revealCommand: DefinedCommand<"debug.reveal", {
+    on: Check<boolean>;
+}>;
+/**
+ * The whole map explored for everyone, as a map that starts explored has it (`FogRules.startExplored`): the fog stays,
+ * over what is not seen now, but the ground is dim, not black, and what stands on it and is no player's is known. Or no
+ * longer: each team has explored what it sees now, and forgets what it does not
+ *
+ * @beta
+ */
+export declare const exploreCommand: DefinedCommand<"debug.explore", {
+    on: Check<boolean>;
+}>;
+/**
+ * The time of day, in a game with days and nights
+ *
+ * @beta
+ */
+export declare const hourCommand: DefinedCommand<"debug.hour", {
+    hour: Check<number>;
+}>;
+/**
+ * How fast the game goes, 0 to pause, 8 at most: whoever runs it (a session in the page, a server) goes by it
+ *
+ * @beta
+ */
+export declare const speedCommand: DefinedCommand<"debug.speed", {
+    speed: Check<number>;
+}>;
+/**
+ * Creates something at a point, for a player: a building or a resource where there is room, or a group of units
+ * (`count`, 50 at most). `hidden`: what can be invisible is out of sight from the start
+ *
+ * @beta
+ */
+export declare const spawnCommand: DefinedCommand<"debug.spawn", {
+    unitType: Check<string>;
+    owner: Check<number>;
+    point: Check<import("./math").Vec2>;
+    count: Check<number | undefined>;
+    hidden: Check<boolean | undefined>;
+}>;
+/**
+ * A brush: fills a circle with what stands on the grid (trees, rocks), thinner towards its edge, wherever there is room;
+ * or, with `erase`, clears it of that type
+ *
+ * @beta
+ */
+export declare const paintCommand: DefinedCommand<"debug.paint", {
+    unitType: Check<string>;
+    owner: Check<number>;
+    point: Check<import("./math").Vec2>;
+    radius: Check<number>;
+    erase: Check<boolean>;
+}>;
+/**
+ * Gives the sender this much of every resource
+ *
+ * @beta
+ */
+export declare const giveCommand: DefinedCommand<"debug.give", {
+    amount: Check<number>;
+}>;
+/**
+ * Gives the sender's heroes this much experience
+ *
+ * @beta
+ */
+export declare const experienceCommand: DefinedCommand<"debug.experience", {
+    amount: Check<number>;
+}>;
+/**
+ * Puts an item of the game's in the first free slot of what carries things
+ *
+ * @beta
+ */
+export declare const giveItemCommand: DefinedCommand<"debug.giveItem", {
+    entity: Check<number>;
+    item: Check<string>;
+}>;
+/**
+ * Raises heroes to a level (never down, and no further than they can go: `setHeroLevel`)
+ *
+ * @beta
+ */
+export declare const setLevelCommand: DefinedCommand<"debug.setLevel", {
+    entities: Check<number[]>;
+    level: Check<number>;
+}>;
+/**
+ * Wins the game for the sender's team: the others are out, and it is over. A game with a way to win of its own is
+ * ended all the same
+ *
+ * @beta
+ */
+export declare const winCommand: DefinedCommand<"debug.win", {}>;
+/**
+ * Puts the sender out of the game, as if beaten: the others play on, or win by the game's own rule
+ *
+ * @beta
+ */
+export declare const loseCommand: DefinedCommand<"debug.lose", {}>;
+/**
+ * Kills what it names, whoever's it is: what cannot be hurt included, but not scenery the map is made of
+ *
+ * @beta
+ */
+export declare const killCommand: DefinedCommand<"debug.kill", {
+    entities: Check<number[]>;
+}>;
+/**
+ * Changes a field of a definition while the game runs, as the editor's Data panel tries it: only one the game lets be
+ * changed (`GameModule.editable`), and for players allowed the debug tools
+ *
+ * @beta
+ */
+export declare const redefineCommand: DefinedCommand<"debug.redefine", {
+    kind: Check<"abilities" | "buffs" | "items" | "races" | "units" | "upgrades">;
+    id: Check<string>;
+    path: Check<string>;
+    value: Check<import("./gameData").FieldValue>;
+}>;
+/**
+ * An object placed on the map put in the world as the map's are as the world is made (`spawnMapObject`): its type,
+ * owner, where it stands and how it is turned, and the rest the map says of it (its health, level, items, the game's
+ * fields, its orders), kept as the entity of that object (`World.mapEntities`): what the editor's Play here sends as
+ * something is placed on the map while it plays (EQ10). A building where there is no room is refused, as `debug.spawn`
+ * refuses it
+ *
+ * @beta
+ */
+export declare const mapObjectCommand: DefinedCommand<"debug.mapObject", {
+    object: Check<MapObject>;
+}>;
+/**
+ * Moves what an object of the map became (`World.mapEntities`, by the object's id) where it stands on the map now,
+ * turned as it is: a unit is put there (`World.place`), the way there not its concern. A structure is not moved: the
+ * editor takes it away and puts it down again
+ *
+ * @beta
+ */
+export declare const placeCommand: DefinedCommand<"debug.place", {
+    object: Check<number>;
+    point: Check<import("./math").Vec2>;
+    facing: Check<number | undefined>;
+}>;
+/**
+ * Takes what objects of the map became (`World.mapEntities`, by the objects' ids) out of the world, whatever they
+ * are, scenery included: no corpse is left. What the editor's Play here sends as something is taken off the map
+ *
+ * @beta
+ */
+export declare const unplaceCommand: DefinedCommand<"debug.unplace", {
+    objects: Check<number[]>;
+}>;
+/**
+ * Reshapes a part of the ground as the patch has it (`World.reshapeGround`): what the editor's Play here sends of the
+ * map's ground as its heights, cliffs, water and paint are edited while it plays. A patch that does not fit the ground
+ * is refused
+ *
+ * @beta
+ */
+export declare const groundCommand: DefinedCommand<"debug.ground", {
+    patch: Check<TerrainPatch>;
+}>;
+/** The ground reshaped (`World.reshapeGround`): to everyone, as it is now */
+export declare const toldGround: import("./replication").ReplicatedEvent;
+/**
+ * The debug commands of the engine, which every game has; they go through only for who may use them
+ *
+ * @beta
+ */
+export declare const debugCommands: CommandDef[];
+/** What a player who may use the debug commands is told of them (`Snapshot.debug`): the switches on, and whether the map started explored */
+export declare const debugPart: import("./replication").SnapshotPart<keyof import(".").Snapshot>;

package/dist/debugging.d.ts

@@ -0,0 +1,10 @@
+/**
+ * The debug tools' part of the engine (`@v12-engine/engine/debug`): the debug commands a game gives its cheats and its
+ * debug panel (`debugCommands`, `defineDebugCommand`), the inspector over a world (`inspect`, `listWorld`,
+ * `EventLog`) and the checks of the engine's invariants (`setDebugChecks`). What the inspector gives (`Inspection`,
+ * `WorldListing`) is the main entry's, as a session's debug face (`SessionDebug`) carries it. A game that ships no
+ * debug tools imports none of this
+ */
+export { cheatCommand, debugCommands, defineDebugCommand, experienceCommand, exploreCommand, giveCommand, giveItemCommand, groundCommand, hourCommand, killCommand, loseCommand, mapObjectCommand, paintCommand, placeCommand, redefineCommand, revealCommand, setLevelCommand, spawnCommand, spawnPrefabCommand, speedCommand, unplaceCommand, winCommand } from './debugCommands';
+export { type DebugChecks, setDebugChecks } from './debug';
+export { EventLog, inspect } from './inspect';

package/dist/definitions.d.ts

@@ -0,0 +1,43 @@
+/**
+ * One kind of definition of a game's, by key (`Definitions`): its unit types, its abilities, its buffs... What every
+ * kind of a registry is, so that each is defined, found, listed and replaced the one way, and a tool that walks every
+ * kind (the Data panel, mods, saves) walks one list (`Registry.kinds`)
+ */
+/**
+ * The definitions of one kind, by key: in the order they were defined, one of a key defined again in the place of the
+ * one before it
+ *
+ * @beta
+ */
+export declare class Definitions<T> {
+    /** What one is called, for what is said of one there is not: `unit type`, `ability` */
+    readonly kind: string;
+    /** Its key: the id, or an order's or a command's type */
+    private readonly keyOf;
+    /** What a definition must be to be taken: throws for one that is not */
+    private readonly check?;
+    private readonly byKey;
+    constructor(
+    /** What one is called, for what is said of one there is not: `unit type`, `ability` */
+    kind: string, 
+    /** Its key: the id, or an order's or a command's type */
+    keyOf?: (def: T) => string, 
+    /** What a definition must be to be taken: throws for one that is not */
+    check?: ((def: T) => void) | undefined);
+    /** Takes a definition, in the place of the one of its key where there is one */
+    define(def: T): this;
+    /** Takes the definition of a key out: false for one there is not */
+    remove(key: string): boolean;
+    /** The definition of a key: throws for one there is not */
+    get(key: string): T;
+    /** The definition of a key, or nothing for one there is not */
+    find(key: string): T | undefined;
+    has(key: string): boolean;
+    /** Every definition, in the order they were defined */
+    all(): T[];
+    /** Every key, in the order they were defined */
+    keys(): string[];
+    get size(): number;
+    /** Takes another's definitions over its own: those it has that the other has not are kept */
+    takeFrom(other: Definitions<T>): void;
+}