Skip to content

GameboardRecipeGameRuntime

Defined in: src/runtime/runtime.ts:654

Runtime facade created from a recipe, preserving recipe-specific registries.

readonly actions: object

Defined in: src/runtime/runtime.ts:308

Raw board placement actions.

canOccupyPlacement: (options) => boolean

Return only the boolean occupancy result for a proposed placement.

InspectGameboardPlacementOccupancyOptions

boolean

clear: () => void

Remove all board tile, placement, and board-state traits from the world.

void

inspectPlacementOccupancy: (options) => GameboardPlacementOccupancyInspection

Inspect whether a proposed placement footprint can occupy its target tiles.

InspectGameboardPlacementOccupancyOptions

GameboardPlacementOccupancyInspection

loadPlan: (plan) => GameboardEntityIndex

Replace the current world contents with a complete generated board plan.

GameboardPlan

GameboardEntityIndex

movePlacement: (placement, to, options) => Entity

Move an existing placement to another tile while preserving unspecified state.

string | Entity

string | HexCoordinates

UpdateGameboardPlacementOptions = {}

Entity

removePlacement: (placement) => boolean

Remove an existing placement by entity or placement id.

string | Entity

boolean

spawnPlacement: (options) => Entity

Spawn a runtime placement into the board.

SpawnGameboardPlacementOptions

Entity

updatePlacement: (placement, options) => Entity

Update an existing runtime placement by entity or placement id.

string | Entity

UpdateGameboardPlacementOptions

Entity

GameboardRuntime.actions


readonly actors: object

Defined in: src/runtime/runtime.ts:310

Actor actions.

collision: (actor, target, profile) => GameboardActorCollisionReport

Inspect whether an actor can enter a target tile.

string | Entity | undefined

string | HexCoordinates

GameboardActorCollisionProfile = {}

GameboardActorCollisionReport

command: (target, options) => GameboardInteractionCommand

Plan a high-level interaction command from a target input.

GameboardInteractionTargetInput

GameboardInteractionCommandOptions = {}

GameboardInteractionCommand

interaction: (target, options) => GameboardInteractionTargetReport

Resolve and inspect an interaction target.

GameboardInteractionTargetInput

GameboardInteractionTargetOptions = {}

GameboardInteractionTargetReport

move: (actor, to, options) => Entity

Move an actor to another tile.

string | Entity

string | HexCoordinates

MoveGameboardActorOptions = {}

Entity

navigationProfile: (actor, options) => GameboardNavigationProfile

Create an actor-aware navigation profile.

string | Entity

GameboardActorNavigationOptions = {}

GameboardNavigationProfile

neighborhood: (center, options) => GameboardNeighborhoodInspection

Inspect a radius of tiles around a center.

GameboardNeighborhoodCenter

GameboardNeighborhoodInspectionOptions = {}

GameboardNeighborhoodInspection

read: () => GameboardActorSnapshot[]

Read all registered actors.

GameboardActorSnapshot[]

register: (placement, options) => Entity

Register an existing placement as an actor.

string | Entity

GameboardActorRegistrationOptions

Entity

select: (options) => GameboardActorSelection

Select actors with optional faction, team, tag, radius, and hostility filters.

GameboardActorSelectionOptions = {}

GameboardActorSelection

spawn: (options) => Entity

Spawn a placement and register it as an actor.

SpawnGameboardActorOptions

Entity

targets: (options) => GameboardActorTargetingReport

Select and path to candidate actor targets.

GameboardActorTargetingOptions

GameboardActorTargetingReport

tile: (coordinates, options) => GameboardTileInspection

Inspect one tile from an actor/gameplay perspective.

string | HexCoordinates

GameboardTileInspectionOptions = {}

GameboardTileInspection

update: (actor, options) => Entity

Update actor trait state while preserving omitted fields.

string | Entity

UpdateGameboardActorOptions

Entity

GameboardRuntime.actors


advanceAllQuests: (options?) => GameboardQuestSnapshot[]

Defined in: src/runtime/runtime.ts:571

Advance every quest against the current live actor, placement, and tile state.

AdvanceGameboardQuestOptions

GameboardQuestSnapshot[]

GameboardRuntime.advanceAllQuests


advanceQuest: (quest, options?) => GameboardQuestSnapshot

Defined in: src/runtime/runtime.ts:566

Advance one quest against the current live actor, placement, and tile state.

string | Entity

AdvanceGameboardQuestOptions

GameboardQuestSnapshot

GameboardRuntime.advanceQuest


analyzeLayoutFill: (options) => GameboardLayoutFillAnalysis

Defined in: src/runtime/runtime.ts:447

Analyze seeded layout fill rules against the live projected world.

GameboardLayoutFillOptions

GameboardLayoutFillAnalysis

GameboardRuntime.analyzeLayoutFill


analyzePieceFills: (registry, fills, options?) => GameboardLayoutFillAnalysis

Defined in: src/runtime/runtime.ts:497

Analyze generated piece fills against the current projected plan.

GameboardPieceRegistry

readonly SeededGameboardPieceFillOptions[]

InspectSeededGameboardPieceFillsOptions

GameboardLayoutFillAnalysis

GameboardRuntime.analyzePieceFills


analyzePieceRegistry: (registry, options?) => GameboardPieceRegistryAnalysis

Defined in: src/runtime/runtime.ts:477

Analyze a custom piece registry.

GameboardPieceRegistry

AnalyzeGameboardPieceRegistryOptions

GameboardPieceRegistryAnalysis

GameboardRuntime.analyzePieceRegistry


canOccupyPlacement: (options) => boolean

Defined in: src/runtime/runtime.ts:369

Return the boolean result from inspectPlacementOccupancy.

InspectGameboardPlacementOccupancyOptions

boolean

GameboardRuntime.canOccupyPlacement


readonly commands: object

Defined in: src/runtime/runtime.ts:318

Command planning/execution actions.

execute: (commandOrTarget, options) => GameboardInteractionCommandExecution

Execute a command with optional host-game handlers.

GameboardInteractionCommandInput

GameboardInteractionCommandExecutionOptions = {}

GameboardInteractionCommandExecution

plan: (target, options) => GameboardInteractionCommand

Plan a command from a renderer or gameplay target.

GameboardInteractionTargetInput

GameboardInteractionCommandOptions = {}

GameboardInteractionCommand

preview: (commandOrTarget, options) => GameboardInteractionCommandPreview

Preview a command without mutating state.

GameboardInteractionCommandInput

GameboardInteractionCommandPreviewOptions = {}

GameboardInteractionCommandPreview

targetCommand: (options) => GameboardActorTargetCommandPlan

Select an actor target and plan a command against it.

GameboardActorTargetCommandOptions

GameboardActorTargetCommandPlan

GameboardRuntime.commands


createInteropSnapshot: (options?) => GameboardInteropSnapshot

Defined in: src/runtime/runtime.ts:420

Create an ECS interop snapshot from the live runtime.

GameboardRuntimeInteropOptions

GameboardInteropSnapshot

GameboardRuntime.createInteropSnapshot


createLayoutFillPlacements: (options) => SpawnGameboardPlacementOptions[]

Defined in: src/runtime/runtime.ts:449

Create seeded layout fill placement options without mutating the live world.

GameboardLayoutFillOptions

SpawnGameboardPlacementOptions[]

GameboardRuntime.createLayoutFillPlacements


createLayoutPlacements: (options) => SpawnGameboardPlacementOptions[]

Defined in: src/runtime/runtime.ts:443

Create layout placement spawn options without mutating the live world.

GameboardLayoutPlacementOptions

SpawnGameboardPlacementOptions[]

GameboardRuntime.createLayoutPlacements


createNavigation: (profile?) => GameboardNavigation

Defined in: src/runtime/runtime.ts:429

Create a pathfinding/navigation facade from the live projected world.

GameboardNavigationProfile

GameboardNavigation

GameboardRuntime.createNavigation


createOccupancyIndex: (profile?) => GameboardOccupancyIndex

Defined in: src/runtime/runtime.ts:427

Create a navigation occupancy index from the live projected world.

GameboardNavigationProfile

GameboardOccupancyIndex

GameboardRuntime.createOccupancyIndex


createPieceFillRules: (registry, options?) => GameboardLayoutFillRule[]

Defined in: src/runtime/runtime.ts:487

Create layout fill rules from selected registry pieces.

GameboardPieceRegistry

GameboardPieceRegistryFillRulesOptions

GameboardLayoutFillRule[]

GameboardRuntime.createPieceFillRules


createPiecePlacementOptions: (piece, options?) => GameboardLayoutPlacementOptions

Defined in: src/runtime/runtime.ts:457

Convert a piece declaration to layout placement options.

GameboardPieceDeclaration

GameboardPiecePlacementOptions

GameboardLayoutPlacementOptions

GameboardRuntime.createPiecePlacementOptions


createPiecePlacements: (piece, options?) => SpawnGameboardPlacementOptions[]

Defined in: src/runtime/runtime.ts:462

Create placement options for a piece against the current projected plan.

GameboardPieceDeclaration

GameboardPiecePlacementOptions

SpawnGameboardPlacementOptions[]

GameboardRuntime.createPiecePlacements


createPiecePoolFillRule: (pieces, options?) => GameboardLayoutFillRule

Defined in: src/runtime/runtime.ts:492

Create one pooled fill rule from a piece collection.

readonly GameboardPieceDeclaration[]

GameboardPieceCollectionLayoutRuleOptions

GameboardLayoutFillRule

GameboardRuntime.createPiecePoolFillRule


createPieceSourceUrlMap: (registry, options?) => Readonly<Record<string, string>>

Defined in: src/runtime/runtime.ts:515

Create an asset-id-to-URL map for local custom pieces.

GameboardPieceRegistry

GameboardPieceSourceUrlOptions

Readonly<Record<string, string>>

GameboardRuntime.createPieceSourceUrlMap


createRecipePieceSourceUrlMap: (options?) => Readonly<Record<string, string>>

Defined in: src/runtime/runtime.ts:662

Create an asset-id-to-URL map for recipe-local custom pieces.

GameboardPieceSourceUrlOptions

Readonly<Record<string, string>>


dispatchActorTargetCommand: (options, commandOptions?) => DispatchGameboardActorTargetCommandResult

Defined in: src/runtime/runtime.ts:592

Select an actor target and dispatch the planned command.

GameboardActorTargetCommandOptions

DispatchGameboardInteractionCommandOptions

DispatchGameboardActorTargetCommandResult

GameboardRuntime.dispatchActorTargetCommand


dispatchCommand: (commandOrTarget, options?) => DispatchGameboardInteractionCommandResult

Defined in: src/runtime/runtime.ts:587

Execute a command and return dispatch events.

GameboardInteractionCommandInput

DispatchGameboardInteractionCommandOptions

DispatchGameboardInteractionCommandResult

GameboardRuntime.dispatchCommand


executeCommand: (commandOrTarget, options?) => GameboardInteractionCommandExecution

Defined in: src/runtime/runtime.ts:597

Execute a command without wrapping it in system events.

GameboardInteractionCommandInput

GameboardInteractionCommandExecutionOptions

GameboardInteractionCommandExecution

GameboardRuntime.executeCommand


findActor: (actor) => GameboardActorSnapshot | undefined

Defined in: src/runtime/runtime.ts:535

Find one actor by entity, placement id, or stable actor id.

string | Entity

GameboardActorSnapshot | undefined

GameboardRuntime.findActor


findQuest: (quest) => GameboardQuestSnapshot | undefined

Defined in: src/runtime/runtime.ts:562

Find one quest by entity or stable quest id.

string | Entity

GameboardQuestSnapshot | undefined

GameboardRuntime.findQuest


inspectActorTargets: (options) => GameboardActorTargetingReport

Defined in: src/runtime/runtime.ts:418

Select and rank actor targets with path and command planning.

GameboardActorTargetingOptions

GameboardActorTargetingReport

GameboardRuntime.inspectActorTargets


inspectLayoutSites: (options?) => GameboardLayoutSiteInspection

Defined in: src/runtime/runtime.ts:439

Inspect layout candidates and rejections against the live projected world.

InspectGameboardLayoutSitesOptions

GameboardLayoutSiteInspection

GameboardRuntime.inspectLayoutSites


inspectNeighborhood: (center, options?) => GameboardNeighborhoodInspection

Defined in: src/runtime/runtime.ts:411

Inspect a radius around a tile, placement, actor, or coordinate.

GameboardNeighborhoodCenter

GameboardNeighborhoodInspectionOptions

GameboardNeighborhoodInspection

GameboardRuntime.inspectNeighborhood


inspectPieceFills: (registry, fills, options?) => SeededGameboardPieceFillInspection

Defined in: src/runtime/runtime.ts:503

Inspect generated piece fills with candidate and rejection details.

GameboardPieceRegistry

readonly SeededGameboardPieceFillOptions[]

InspectSeededGameboardPieceFillsOptions

SeededGameboardPieceFillInspection

GameboardRuntime.inspectPieceFills


inspectPiecePlacement: (piece, options?) => GameboardPiecePlacementInspection

Defined in: src/runtime/runtime.ts:467

Inspect where a piece can be placed against the current projected plan.

GameboardPieceDeclaration

GameboardPiecePlacementOptions

GameboardPiecePlacementInspection

GameboardRuntime.inspectPiecePlacement


inspectPlacementOccupancy: (options) => GameboardPlacementOccupancyInspection

Defined in: src/runtime/runtime.ts:365

Inspect whether a placement footprint can occupy the current live board.

This is the preflight path for construction cursors, drag previews, unit moves, and generated fills before mutating the world.

InspectGameboardPlacementOccupancyOptions

GameboardPlacementOccupancyInspection

GameboardRuntime.inspectPlacementOccupancy


inspectTile: (coordinates, options?) => GameboardTileInspection

Defined in: src/runtime/runtime.ts:406

Inspect one tile, placement, actor, or coordinate in live state.

string | HexCoordinates

GameboardTileInspectionOptions

GameboardTileInspection

GameboardRuntime.inspectTile


interact: (commandOrTarget, options?) => RunGameboardInteractionResult

Defined in: src/runtime/runtime.ts:602

Dispatch a command and optionally run systems.

GameboardInteractionCommandInput

RunGameboardInteractionOptions

RunGameboardInteractionResult

GameboardRuntime.interact


interactActorTarget: (options, interactionOptions?) => RunGameboardActorTargetInteractionResult

Defined in: src/runtime/runtime.ts:607

Target an actor, dispatch the command, and optionally run systems.

GameboardActorTargetCommandOptions

RunGameboardInteractionOptions

RunGameboardActorTargetInteractionResult

GameboardRuntime.interactActorTarget


loadPlan: (plan) => GameboardEntityIndex

Defined in: src/runtime/runtime.ts:322

Load a plan into the bound world.

GameboardPlan

GameboardEntityIndex

GameboardRuntime.loadPlan


mountInterop: <TEntity>(adapter, options?) => GameboardEcsMountResult<TEntity>

Defined in: src/runtime/runtime.ts:422

Mount the live runtime snapshot into another ECS/store adapter.

TEntity

GameboardEcsAdapter<TEntity>

GameboardRuntimeInteropOptions

GameboardEcsMountResult<TEntity>

GameboardRuntime.mountInterop


moveActor: (actor, to, options?) => Entity

Defined in: src/runtime/runtime.ts:546

Move an actor-backed placement by actor id or entity.

string | Entity

string | HexCoordinates

MoveGameboardActorOptions

Entity

GameboardRuntime.moveActor


readonly movement: object

Defined in: src/runtime/runtime.ts:312

Movement actions.

advance: (placement, options) => GameboardMovementAdvanceResult

Advance one placement along its requested path.

string | Entity

AdvanceGameboardMovementOptions = {}

GameboardMovementAdvanceResult

clear: (placement) => Entity

Clear active movement path state for a placement.

string | Entity

Entity

reachable: (placement, options) => GameboardReachableTile[]

Return tiles reachable by one movement agent.

string | Entity

GameboardMovementOptions = {}

GameboardReachableTile[]

requestMove: (placement, destination, options) => GameboardMovementRequestResult

Request movement to a destination.

string | Entity

string | HexCoordinates

GameboardMovementPathRequestOptions = {}

GameboardMovementRequestResult

resetBudget: (placement?, options) => readonly Entity[]

Reset movement budget for one or all movement agents.

string | Entity

GameboardMovementOptions = {}

readonly Entity[]

runSystem: (options) => GameboardMovementAdvanceResult[]

Advance all active movement agents.

AdvanceGameboardMovementOptions = {}

GameboardMovementAdvanceResult[]

setAgent: (placement, options) => Entity

Add or update a movement agent on a placement.

string | Entity

SetGameboardMovementAgentOptions = {}

Entity

GameboardRuntime.movement


movePlacement: (placement, to, options?) => Entity

Defined in: src/runtime/runtime.ts:394

Move one placement to a new tile or coordinate-like target.

Use this for actor movement, build previews, temporary markers, and gameplay props that should remain in the same Koota entity.

string | Entity

string | HexCoordinates

Omit<UpdateGameboardPlacementOptions, "at">

Entity

GameboardRuntime.movePlacement


readonly patrol: object

Defined in: src/runtime/runtime.ts:314

Patrol actions.

advance: (placement, options) => GameboardPatrolAdvanceResult

Advance one patrol agent.

string | Entity

AdvanceGameboardPatrolOptions = {}

GameboardPatrolAdvanceResult

clear: (placement) => Entity

Remove patrol traits from a placement.

string | Entity

Entity

read: () => GameboardPatrolSnapshot[]

Read all patrol snapshots.

GameboardPatrolSnapshot[]

run: (options) => GameboardPatrolAdvanceResult[]

Advance every patrol agent in the world.

AdvanceGameboardPatrolOptions = {}

GameboardPatrolAdvanceResult[]

set: (placement, options) => Entity

Attach or replace a patrol agent.

string | Entity

SetGameboardPatrolAgentOptions

Entity

GameboardRuntime.patrol


plan: () => GameboardPlan

Defined in: src/runtime/runtime.ts:324

Project the live world to a renderable plan.

GameboardPlan

GameboardRuntime.plan


planActorTargetCommand: (options) => GameboardActorTargetCommandPlan

Defined in: src/runtime/runtime.ts:578

Plan a command against the selected actor target.

GameboardActorTargetCommandOptions

GameboardActorTargetCommandPlan

GameboardRuntime.planActorTargetCommand


planCommand: (target, options?) => GameboardInteractionCommand

Defined in: src/runtime/runtime.ts:573

Plan a command from a renderer or gameplay target.

GameboardInteractionTargetInput

GameboardInteractionCommandOptions

GameboardInteractionCommand

GameboardRuntime.planCommand


planPatrolRoute: (options) => GameboardPatrolRoutePlan

Defined in: src/runtime/runtime.ts:435

Plan one patrol route from the live projected world.

GameboardPatrolRouteOptions

GameboardPatrolRoutePlan

GameboardRuntime.planPatrolRoute


planPatrolRoutes: (options) => GameboardPatrolRouteSet

Defined in: src/runtime/runtime.ts:437

Plan a patrol route set from the live projected world.

GameboardPatrolRouteSetOptions

GameboardPatrolRouteSet

GameboardRuntime.planPatrolRoutes


planSpawnGroups: (options) => GameboardSpawnGroupPlan

Defined in: src/runtime/runtime.ts:433

Plan spawn groups from the live projected world.

GameboardSpawnGroupOptions

GameboardSpawnGroupPlan

GameboardRuntime.planSpawnGroups


previewCommand: (commandOrTarget, options?) => GameboardInteractionCommandPreview

Defined in: src/runtime/runtime.ts:582

Preview command execution without mutating state.

GameboardInteractionCommandInput

GameboardInteractionCommandPreviewOptions

GameboardInteractionCommandPreview

GameboardRuntime.previewCommand


readonly quests: object

Defined in: src/runtime/runtime.ts:316

Quest actions.

advance: (quest, options) => GameboardQuestSnapshot

Advance one quest entity.

string | Entity

AdvanceGameboardQuestOptions = {}

GameboardQuestSnapshot

advanceAll: (options) => GameboardQuestSnapshot[]

Advance every quest entity.

AdvanceGameboardQuestOptions = {}

GameboardQuestSnapshot[]

find: (quest) => GameboardQuestSnapshot | undefined

Find one quest snapshot.

string | Entity

GameboardQuestSnapshot | undefined

read: () => GameboardQuestSnapshot[]

Read all quest snapshots.

GameboardQuestSnapshot[]

spawn: (definition, options) => Entity

Spawn a quest entity.

GameboardQuestDefinition

SpawnGameboardQuestOptions = {}

Entity

GameboardRuntime.quests


readActors: () => GameboardActorSnapshot[]

Defined in: src/runtime/runtime.ts:537

Read all registered actors joined with their placement and tile records.

GameboardActorSnapshot[]

GameboardRuntime.readActors


readActorsForTile: (coordinates) => GameboardActorSnapshot[]

Defined in: src/runtime/runtime.ts:544

Read registered actors whose placement origin is one tile.

Use this for hover cards, collision probes, encounter checks, and external ECS sync when a game needs actor semantics instead of raw placements.

string | HexCoordinates

GameboardActorSnapshot[]

GameboardRuntime.readActorsForTile


readPlacementOccupancy: () => PlacementOccupancySnapshot[]

Defined in: src/runtime/runtime.ts:351

Read every placement footprint currently reserving or blocking tiles.

The returned records include origin and occupied tile metadata, so UI and pathfinding bridges can reason about multi-hex structures and blockers.

PlacementOccupancySnapshot[]

GameboardRuntime.readPlacementOccupancy


readPlacementOccupancyForTile: (coordinates) => PlacementOccupancySnapshot[]

Defined in: src/runtime/runtime.ts:358

Read occupancy records for one tile.

Prefer this over filtering readPlacementOccupancy() in UI panels, collision probes, and external ECS bridges that only need one hex.

string | HexCoordinates

PlacementOccupancySnapshot[]

GameboardRuntime.readPlacementOccupancyForTile


readPlacements: () => object[]

Defined in: src/runtime/runtime.ts:337

Read serializable placement records from live state.

Use this for save data, editor panels, renderer diffing, and external ECS mirrors that do not need raw Koota relation stores.

GameboardRuntime.readPlacements


readPlacementsForTile: (coordinates) => object[]

Defined in: src/runtime/runtime.ts:344

Read serializable placement records that occupy one tile.

This includes placements whose multi-tile footprint covers the tile, not only placements whose canonical origin is the tile.

string | HexCoordinates

GameboardRuntime.readPlacementsForTile


readQuests: () => GameboardQuestSnapshot[]

Defined in: src/runtime/runtime.ts:564

Read all quest snapshots from live state for HUDs, saves, and tests.

GameboardQuestSnapshot[]

GameboardRuntime.readQuests


readonly recipe: GameboardRecipe

Defined in: src/runtime/runtime.ts:656

Source recipe used to create the runtime.


readonly optional recipeLayoutArchetypes?: Readonly<Record<string, GameboardLayoutArchetype>>

Defined in: src/runtime/runtime.ts:658

Layout archetypes declared by the recipe.


readonly optional recipePieceRegistry?: GameboardPieceRegistry

Defined in: src/runtime/runtime.ts:660

Piece registry declared by the recipe.


registerActor: (placement, options) => Entity

Defined in: src/runtime/runtime.ts:528

Attach actor state to an existing placement.

Register existing placements when a neutral prop, marker, structure, or externally declared piece becomes selectable, interactive, hostile, or quest-addressable after startup.

string | Entity

GameboardActorRegistrationOptions

Entity

GameboardRuntime.registerActor


removePlacement: (placement) => boolean

Defined in: src/runtime/runtime.ts:404

Remove one placement entity and its placement relations from the live world.

Returns false when the entity or placement id cannot be found.

string | Entity

boolean

GameboardRuntime.removePlacement


selectActors: (options?) => GameboardActorSelection

Defined in: src/runtime/runtime.ts:416

Select actors from live state using actor-aware filters.

GameboardActorSelectionOptions

GameboardActorSelection

GameboardRuntime.selectActors


selectPieces: (registry, selection?) => GameboardPieceDeclaration[]

Defined in: src/runtime/runtime.ts:482

Select declarations from a custom piece registry.

GameboardPieceRegistry

GameboardPieceRegistrySelection

GameboardPieceDeclaration[]

GameboardRuntime.selectPieces


selectSpawnLocations: (options) => SpawnLocation[]

Defined in: src/runtime/runtime.ts:431

Select deterministic spawn locations from the live projected world.

GameboardSpawnLocationOptions

SpawnLocation[]

GameboardRuntime.selectSpawnLocations


snapshot: (options?) => GameboardRuntimeSnapshot

Defined in: src/runtime/runtime.ts:330

Read a serializable runtime snapshot.

GameboardRuntimeSnapshotOptions

GameboardRuntimeSnapshot

GameboardRuntime.snapshot


spawnActor: (options) => Entity

Defined in: src/runtime/runtime.ts:520

Spawn an actor-backed placement.

SpawnGameboardActorOptions

Entity

GameboardRuntime.spawnActor


spawnLayoutFill: (options) => Entity[]

Defined in: src/runtime/runtime.ts:455

Spawn a generated layout fill into the live world.

GameboardLayoutFillOptions

Entity[]

GameboardRuntime.spawnLayoutFill


spawnLayoutPlacements: (options) => Entity[]

Defined in: src/runtime/runtime.ts:453

Spawn explicit layout placements into the live world.

GameboardLayoutPlacementOptions

Entity[]

GameboardRuntime.spawnLayoutPlacements


spawnPiece: (piece, options?) => Entity[]

Defined in: src/runtime/runtime.ts:472

Spawn one declared piece into the live world.

GameboardPieceDeclaration

GameboardPiecePlacementOptions

Entity[]

GameboardRuntime.spawnPiece


spawnPieceFills: (registry, fills, options?) => Entity[]

Defined in: src/runtime/runtime.ts:509

Spawn generated piece fills into the live world.

GameboardPieceRegistry

readonly SeededGameboardPieceFillOptions[]

InspectSeededGameboardPieceFillsOptions

Entity[]

GameboardRuntime.spawnPieceFills


spawnPlacement: (options) => Entity

Defined in: src/runtime/runtime.ts:376

Spawn one renderable placement into the live world.

Pass occupancyGuard: true when the spawn should fail instead of overlapping an existing blocker or missing footprint tile.

SpawnGameboardPlacementOptions

Entity

GameboardRuntime.spawnPlacement


spawnQuest: (definition, options?) => Entity

Defined in: src/runtime/runtime.ts:557

Spawn a quest definition into the live world.

Quest objectives can reference actor ids, placement ids, and tile keys, so scenario and runtime-created quests use the same progression surface.

GameboardQuestDefinition

SpawnGameboardQuestOptions

Entity

GameboardRuntime.spawnQuest


summarizePlan: (options?) => GameboardPlanSummary

Defined in: src/runtime/runtime.ts:326

Summarize the live projected plan for editor, diagnostics, and bridge code.

SummarizeGameboardPlanOptions

GameboardPlanSummary

GameboardRuntime.summarizePlan


readonly systems: object

Defined in: src/runtime/runtime.ts:320

System dispatch/tick actions.

dispatchActorTargetCommand: (options, commandOptions) => DispatchGameboardActorTargetCommandResult

Select an actor target, then execute its planned command.

GameboardActorTargetCommandOptions

DispatchGameboardInteractionCommandOptions = {}

DispatchGameboardActorTargetCommandResult

dispatchCommand: (commandOrTarget, options) => DispatchGameboardInteractionCommandResult

Execute one command and emit dispatch event records.

GameboardInteractionCommandInput

DispatchGameboardInteractionCommandOptions = {}

DispatchGameboardInteractionCommandResult

interact: (commandOrTarget, options) => RunGameboardInteractionResult

Dispatch a command and optionally tick systems.

GameboardInteractionCommandInput

RunGameboardInteractionOptions = {}

RunGameboardInteractionResult

interactActorTarget: (options, interactionOptions) => RunGameboardActorTargetInteractionResult

Target an actor, dispatch the command, and optionally tick systems.

GameboardActorTargetCommandOptions

RunGameboardInteractionOptions = {}

RunGameboardActorTargetInteractionResult

run: (options) => RunGameboardSystemsResult

Run enabled patrol, movement, and quest systems for one tick.

RunGameboardSystemsOptions = {}

RunGameboardSystemsResult

GameboardRuntime.systems


tick: (options?) => RunGameboardSystemsResult

Defined in: src/runtime/runtime.ts:612

Run enabled systems for one game-loop tick.

RunGameboardSystemsOptions

RunGameboardSystemsResult

GameboardRuntime.tick


updateActor: (actor, options) => Entity

Defined in: src/runtime/runtime.ts:533

Update actor state while preserving omitted fields and placement binding.

string | Entity

UpdateGameboardActorOptions

Entity

GameboardRuntime.updateActor


updatePlacement: (placement, options) => Entity

Defined in: src/runtime/runtime.ts:384

Update one placement in the live world while preserving omitted fields.

The helper refreshes placement classification and footprint relations when fields such as coordinates, kind, layer, footprint, tags, or blocking behavior change.

string | Entity

UpdateGameboardPlacementOptions

Entity

GameboardRuntime.updatePlacement


validationPlan: () => GameboardPlan

Defined in: src/runtime/runtime.ts:328

Project the live world to a plan shape suitable for validation.

GameboardPlan

GameboardRuntime.validationPlan


readonly world: World

Defined in: src/runtime/runtime.ts:306

Bound Koota world.

GameboardRuntime.world