Skip to content

GameboardRuntime

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

Bound gameboard facade for one live board instance.

The facade keeps the raw Koota world and action bundles available, but adds game-oriented reads and mutations that project the live board before navigation, layout, piece-fill, scenario, and interop operations. Prefer this object at scene boundaries, React providers, integration tests, and external ECS bridges when the board is actively changing during play.

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


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


advanceAllQuests: (options?) => GameboardQuestSnapshot[]

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

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

AdvanceGameboardQuestOptions

GameboardQuestSnapshot[]


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


analyzeLayoutFill: (options) => GameboardLayoutFillAnalysis

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

Analyze seeded layout fill rules against the live projected world.

GameboardLayoutFillOptions

GameboardLayoutFillAnalysis


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


analyzePieceRegistry: (registry, options?) => GameboardPieceRegistryAnalysis

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

Analyze a custom piece registry.

GameboardPieceRegistry

AnalyzeGameboardPieceRegistryOptions

GameboardPieceRegistryAnalysis


canOccupyPlacement: (options) => boolean

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

Return the boolean result from inspectPlacementOccupancy.

InspectGameboardPlacementOccupancyOptions

boolean


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


createInteropSnapshot: (options?) => GameboardInteropSnapshot

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

Create an ECS interop snapshot from the live runtime.

GameboardRuntimeInteropOptions

GameboardInteropSnapshot


createLayoutFillPlacements: (options) => SpawnGameboardPlacementOptions[]

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

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

GameboardLayoutFillOptions

SpawnGameboardPlacementOptions[]


createLayoutPlacements: (options) => SpawnGameboardPlacementOptions[]

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

Create layout placement spawn options without mutating the live world.

GameboardLayoutPlacementOptions

SpawnGameboardPlacementOptions[]


createNavigation: (profile?) => GameboardNavigation

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

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

GameboardNavigationProfile

GameboardNavigation


createOccupancyIndex: (profile?) => GameboardOccupancyIndex

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

Create a navigation occupancy index from the live projected world.

GameboardNavigationProfile

GameboardOccupancyIndex


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

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

Create layout fill rules from selected registry pieces.

GameboardPieceRegistry

GameboardPieceRegistryFillRulesOptions

GameboardLayoutFillRule[]


createPiecePlacementOptions: (piece, options?) => GameboardLayoutPlacementOptions

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

Convert a piece declaration to layout placement options.

GameboardPieceDeclaration

GameboardPiecePlacementOptions

GameboardLayoutPlacementOptions


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[]


createPiecePoolFillRule: (pieces, options?) => GameboardLayoutFillRule

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

Create one pooled fill rule from a piece collection.

readonly GameboardPieceDeclaration[]

GameboardPieceCollectionLayoutRuleOptions

GameboardLayoutFillRule


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>>


dispatchActorTargetCommand: (options, commandOptions?) => DispatchGameboardActorTargetCommandResult

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

Select an actor target and dispatch the planned command.

GameboardActorTargetCommandOptions

DispatchGameboardInteractionCommandOptions

DispatchGameboardActorTargetCommandResult


dispatchCommand: (commandOrTarget, options?) => DispatchGameboardInteractionCommandResult

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

Execute a command and return dispatch events.

GameboardInteractionCommandInput

DispatchGameboardInteractionCommandOptions

DispatchGameboardInteractionCommandResult


executeCommand: (commandOrTarget, options?) => GameboardInteractionCommandExecution

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

Execute a command without wrapping it in system events.

GameboardInteractionCommandInput

GameboardInteractionCommandExecutionOptions

GameboardInteractionCommandExecution


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


findQuest: (quest) => GameboardQuestSnapshot | undefined

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

Find one quest by entity or stable quest id.

string | Entity

GameboardQuestSnapshot | undefined


inspectActorTargets: (options) => GameboardActorTargetingReport

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

Select and rank actor targets with path and command planning.

GameboardActorTargetingOptions

GameboardActorTargetingReport


inspectLayoutSites: (options?) => GameboardLayoutSiteInspection

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

Inspect layout candidates and rejections against the live projected world.

InspectGameboardLayoutSitesOptions

GameboardLayoutSiteInspection


inspectNeighborhood: (center, options?) => GameboardNeighborhoodInspection

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

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

GameboardNeighborhoodCenter

GameboardNeighborhoodInspectionOptions

GameboardNeighborhoodInspection


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


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


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


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


interact: (commandOrTarget, options?) => RunGameboardInteractionResult

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

Dispatch a command and optionally run systems.

GameboardInteractionCommandInput

RunGameboardInteractionOptions

RunGameboardInteractionResult


interactActorTarget: (options, interactionOptions?) => RunGameboardActorTargetInteractionResult

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

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

GameboardActorTargetCommandOptions

RunGameboardInteractionOptions

RunGameboardActorTargetInteractionResult


loadPlan: (plan) => GameboardEntityIndex

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

Load a plan into the bound world.

GameboardPlan

GameboardEntityIndex


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>


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


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


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


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


plan: () => GameboardPlan

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

Project the live world to a renderable plan.

GameboardPlan


planActorTargetCommand: (options) => GameboardActorTargetCommandPlan

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

Plan a command against the selected actor target.

GameboardActorTargetCommandOptions

GameboardActorTargetCommandPlan


planCommand: (target, options?) => GameboardInteractionCommand

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

Plan a command from a renderer or gameplay target.

GameboardInteractionTargetInput

GameboardInteractionCommandOptions

GameboardInteractionCommand


planPatrolRoute: (options) => GameboardPatrolRoutePlan

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

Plan one patrol route from the live projected world.

GameboardPatrolRouteOptions

GameboardPatrolRoutePlan


planPatrolRoutes: (options) => GameboardPatrolRouteSet

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

Plan a patrol route set from the live projected world.

GameboardPatrolRouteSetOptions

GameboardPatrolRouteSet


planSpawnGroups: (options) => GameboardSpawnGroupPlan

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

Plan spawn groups from the live projected world.

GameboardSpawnGroupOptions

GameboardSpawnGroupPlan


previewCommand: (commandOrTarget, options?) => GameboardInteractionCommandPreview

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

Preview command execution without mutating state.

GameboardInteractionCommandInput

GameboardInteractionCommandPreviewOptions

GameboardInteractionCommandPreview


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


readActors: () => GameboardActorSnapshot[]

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

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

GameboardActorSnapshot[]


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[]


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[]


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[]


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.


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


readQuests: () => GameboardQuestSnapshot[]

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

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

GameboardQuestSnapshot[]


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


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


selectActors: (options?) => GameboardActorSelection

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

Select actors from live state using actor-aware filters.

GameboardActorSelectionOptions

GameboardActorSelection


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

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

Select declarations from a custom piece registry.

GameboardPieceRegistry

GameboardPieceRegistrySelection

GameboardPieceDeclaration[]


selectSpawnLocations: (options) => SpawnLocation[]

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

Select deterministic spawn locations from the live projected world.

GameboardSpawnLocationOptions

SpawnLocation[]


snapshot: (options?) => GameboardRuntimeSnapshot

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

Read a serializable runtime snapshot.

GameboardRuntimeSnapshotOptions

GameboardRuntimeSnapshot


spawnActor: (options) => Entity

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

Spawn an actor-backed placement.

SpawnGameboardActorOptions

Entity


spawnLayoutFill: (options) => Entity[]

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

Spawn a generated layout fill into the live world.

GameboardLayoutFillOptions

Entity[]


spawnLayoutPlacements: (options) => Entity[]

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

Spawn explicit layout placements into the live world.

GameboardLayoutPlacementOptions

Entity[]


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

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

Spawn one declared piece into the live world.

GameboardPieceDeclaration

GameboardPiecePlacementOptions

Entity[]


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[]


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


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


summarizePlan: (options?) => GameboardPlanSummary

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

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

SummarizeGameboardPlanOptions

GameboardPlanSummary


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


tick: (options?) => RunGameboardSystemsResult

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

Run enabled systems for one game-loop tick.

RunGameboardSystemsOptions

RunGameboardSystemsResult


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


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


validationPlan: () => GameboardPlan

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

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

GameboardPlan


readonly world: World

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

Bound Koota world.