Games

std-arcade-flow

Headless win/lose authority for the arcade play-for-tickets loop: owns only result. Listens SCORE_CHANGED (tickets + tokens) and sets result to won once tickets reach the target, lost when tokens run out first, else none. Renders nothing.

Entity: ArcadeFlowData (runtime)

Traits

Config knobs

std-arcade-play

Headless arcade play-economy mechanic: the SOLE writer of tokens + tickets + machines. Applies a PLAY_MACHINE intent (spends a token, rolls a pseudo-random ticket payout within a configured range, emits BURST + SCORE_CHANGED). Renders nothing.

Entity: ArcadePlayData (runtime)

Traits

Config knobs

std-area-fill

the physical per-tick maximum — so teleports and respawns paint nothing) — height is linear interpolation of the config curve samples above the fill's baseline (the platformer body's leftSamp/rightSamp idiom). rateMode picks the rate: "area" (height × |dx|, default — fills fastest where the curve is tallest), "speed" (|dx| only, flat rate), or "ride" (|dx| only while the move reports skating — walking the same distance paints nothing). When a fill's filled reaches its target it flips reported and emits AREA_FILLED once (the shared entity carries the rest); each fill also stamps a frontier (x0 + span × min(1, filled/target)) so boards can shade the painted region left-to-right as the gauge grows. RESTART resets every live fill (re-arming the live entity set, so SET_FILLS-injected fills survive respawns). SET_FILLS replaces the fill set at runtime for boards that import their fills. Renders nothing; boards shade the painted region and read filled/frontier from the shared entity (the render authority).

Entity: AreaFillData (runtime)

Traits

Config knobs

std-audio-cue

swap them per game by rebinding this atom's config, never by hand-authoring a second audio layer.

Entity: AudioState (runtime)

Traits

Config knobs

std-camera-rig

a dead-zone camera: inside deadzoneX/deadzoneY the axis holds, outside it lerps by stiffness — clamps the result to bounds, eases camZoom toward camTargetZoom the same way, and decays camShake toward 0 by shakeDecay. Intents: FOLLOW retargets from a moving body's x/y/vx (vx feeds camLead, the horizontal look-ahead), CUT snaps position+target instantly (no ease, for teleports/cutscenes), SET_ZOOM retargets zoom (clamped to minZoom/maxZoom), SHAKE sets camShake for a consumer to jitter with at bind time — this atom never writes shake into camX/camY itself, RESTART reseeds from config. Emits CAMERA_MOVED every tick. Renders nothing — a board binds its own canvas camera prop straight to camX/camY/camZoom.

Entity: CameraState (runtime)

Traits

Config knobs

std-chase-ai

Headless chase-AI mechanic: enemies damage adjacent targets, else step toward the nearest target respecting tile passability and occupancy.

Entity: ChaseState (runtime)

Traits

Config knobs

std-choice-gate

the pad-lock touch pattern): the correct option stamps the gate solved + chosen on the shared entity and emits CHOICE_CORRECT once (a solved gate never judges again, so the path stays open); a wrong option emits CHOICE_WRONG carrying the gate id, the chosen optionId, and the option's world position, so the board can bounce the player back and float the gate's hint (the board owns the bounce — the atom only reports). RESTART unsolves every live gate (re-arming the live entity set, so SET_GATES-injected gates survive respawns). SET_GATES replaces the gate set at runtime for boards that import their gates. Renders nothing; boards draw the option platforms and labels from the shared entity (the render authority). Corresponds to the design-sheet field(s): challenge, agency.

Entity: ChoiceGateData (runtime)

Traits

Config knobs

std-coef-pad

the pad-lock touch pattern), stamps the pad applied on the shared entity and emits COEF_PAD_APPLIED carrying the pad position AND its mod (x0, x1, a, h, k), so the board can append the mod to the body authority's curveMods (std-platformer-body with curveModsEnabled) and hop the player onto the reshaped surface. When every pad is applied it emits COEF_PAD_SET_COMPLETED once. RESTART un-applies every live pad (re-arming the live entity set, so SET_PADS-injected pads survive respawns; the board clears curveMods alongside — the pad reports, the board owns the road). SET_PADS replaces the pad set at runtime for boards that import their pads. Renders nothing; boards draw the pads and read applied from the shared entity (the render authority).

Entity: CoefPadData (runtime)

Traits

Config knobs

std-curve-fog

the atom listens BODY_MOVED and stamps fogX (the reveal horizon = player x + the region's lookAhead) onto the shared entity, and the board's render layer clips or ghosts every road sample past it, so the player must commit to jumps before the landing is visible and internalize where the function GOES (blowup, flattening, slow growth, divergence). Outside every region fogX sits at a large sentinel, i.e. fully revealed. Physics is untouched: the collider keeps the whole curve — the fog is purely visual. Renders nothing; boards clip their own curve/region samples against @entity.fogX (the render authority).

Entity: CurveFogData (runtime)

Traits

Config knobs

std-dungeon-combat

Headless dungeon combat authority: owns the enemy roster, hero HP, and kill score. Bump-attacks damage enemies; monster ticks chase the hero and deal contact damage.

Entity: DungeonCombatData (runtime)

Traits

Config knobs

std-fx-narrative

Headless pedagogy→fx translator for game boards and learning shells: turns high-level narrative events into big transient screen-space or world-space text effects consumed by std-fx-particles / fx-overlay. Levels emit NARRATE { text, style } and get a correctly styled, centered (or positioned) floating text burst without hand-rolling particle structs. Tutorials emit TUTORIAL_SHOW and the atom forwards SHOW to a composed std-tutorial-overlay trait. Renders nothing; centralizes the FX vocabulary so every level's teaching text looks and behaves the same. Corresponds to the design-sheet field(s): feedback.

Entity: FxNarrativeData (runtime)

Traits

Config knobs

std-fx-particles

stamping maxTtl (fade envelope) and bornAt (epoch ms, smooth render interpolation) when absent — decays each entry's ttl every tick, drops the dead ones, and clears on RESTART. Name-blind mechanism: the effect-kind vocabulary is consumer-declared (FxPreset tables at the render call sites). Composed onto a [runtime, shared] entity; renders nothing — the board/shell owns the single render authority (draw-fx-layer for space "world", fx-overlay for space "screen"). Corresponds to the design-sheet field(s): feedback, rewards.

Entity: FxState (runtime)

Traits

Config knobs

std-fx-trail

appends a dot only when the body's speed exceeds minSpeed (standing still leaves no trail) and prunes dots older than ttl on the same pass, so no decay tick is needed and a stopped body's trail simply stops growing (the render side fades each dot by bornAt/ttl). RESTART clears. Renders nothing.

Entity: FxTrailData (runtime)

Traits

Config knobs

std-gate-lock

stars, coins, keys) and flips every door whose cost is met, stamping open on the shared door rows and emitting GATE_OPENED for the first newly opened door (the shared entity is the render authority for the rest). While a closed door's rect contains the player it emits GATE_BLOCKED once per approach — re-arming only after the player steps out — so the board can answer with a PLACE back and a locked fx. RESTART re-locks every live door and zeroes the total (re-arming the live entity set, so SET_DOORS-injected doors survive respawns). SET_DOORS replaces the door set at runtime for boards that import their doors. Renders nothing; boards draw closed doors as bars/walls and open ones as gaps. Corresponds to the design-sheet field(s): challenge, rewards.

Entity: GateLockData (runtime)

Traits

Config knobs

std-gather

Headless resource-gathering mechanic: owns features + wood + stone. Listens HERO_STEPPED and, when the hero lands on a wood/stone-type feature, increments the matching resource, removes the node, emits a BURST pickup particle, and emits RESOURCES so survival-flow can decide loss. Never writes units.

Entity: GatherData (runtime)

Traits

Config knobs

std-gold

Headless gold-economy mechanic: the SOLE writer of gold. Listens a mine-hit signal and adds a fixed yield; emits GOLD_CHANGED. Renders nothing.

Entity: GoldData (runtime)

Traits

Config knobs

std-grid-tactics

Headless grid-tactics unit-authority: the SOLE writer of units. Applies MOVE/ATTACK/SPAWN/HEAL intents from any source (player, AI, production, or progression) and runs the enemy AI_TURN pipeline, emitting BURST hit-particles and UNITS_CHANGED survivor counts. Renders nothing.

Entity: TacticsState (runtime)

Traits

Config knobs

std-hero-nav

Headless single-hero navigation authority: the SOLE writer of units + movesLeft on objective boards. Applies a budget-limited MOVE intent (steps the hero one tile, spends a move, emits HERO_STEPPED) and an optional WANDER intent (random step for neutral NPCs). Renders nothing.

Entity: HeroNavData (runtime)

Traits

Config knobs

std-lives

BODY_HAZARD, BODY_FELL, PATROL_HIT — onto it) costs one life, respecting an invulnerability window so overlapping hazards can't chain-drain; losing a life emits LIFE_LOST plus RESPAWN with the current checkpoint (boards route RESPAWN to the body authority's PLACE), and losing the last emits GAME_OVER instead. Checkpoints advance automatically: BODY_MOVED crossing a configured checkpoint's atX moves the respawn point forward and emits CHECKPOINT_REACHED once per checkpoint (tracked by furthest atX reached, so checkpoints are ordered along the run). RESTART reseeds lives and respawn to the spawn. Renders nothing — HUDs read lives off the shared entity. Corresponds to the design-sheet field(s): challenge, feedback.

Entity: LivesData (runtime)

Traits

Config knobs

std-loop-lock

either direction counts); when |swept| reaches turns × 2π the lock flips unlocked and emits LOOP_UNLOCKED once. Entering the band reseeds the angle so leaving and returning never jumps the sweep; progress is kept across exits, so a revolution can be completed in stages. RESTART re-locks every live lock (re-arming the live entity set, so SET_LOCKS-injected locks survive respawns). SET_LOCKS replaces the lock set at runtime for boards that import their locks. Renders nothing; boards draw the ring/chest and read swept from the shared entity (the render authority). Corresponds to the design-sheet field(s): challenge, rewards.

Entity: LoopLockData (runtime)

Traits

Config knobs

std-market-flow

Headless win/lose authority for market-service boards: owns only result. Listens SERVICE_CHANGED (served + lost) and sets result to won when enough customers are served, lost when too many patience timers expire, else none. Renders nothing.

Entity: MarketFlowData (runtime)

Traits

Config knobs

std-mesh-asset-art

SOLE writer of @entity.meshAssetArt: collects volumetric asset catalogs published on the bus (MESH_ASSET_PUBLISH { kind, states }) into one kind → (state → draw-group items of draw-mesh descriptors) map that 3D board frames select per-row per anim state. INIT seeds from config and emits MESH_ASSET_SYNC so already-mounted catalogs republish regardless of mount order; the SYNC self-hop re-applies the seed after sibling canvas stashes exist (Almadar_Runtime_Gaps.md R-INIT-SEED-REPAINT-RACE). The 3D twin of SvgAssetArtCollector. Renders nothing — render authority stays with the frame.

Entity: StdMeshAssetArt (runtime)

Traits

Config knobs

std-motion-body

thrust acceleration plus the board-wide bias field (biasAx/biasAy — the hill-force / wind / conveyor-belt channel, written only through the SET_BIAS intent) plus gravity feed velocity, damping bleeds it, maxSpeed caps it, velocity steps position, and the world walls clamp it (a clamped axis kills that axis's velocity). Intents: THRUST sets a body's acceleration (hold-to-push input: keydown pushes, keyup zeroes), IMPULSE kicks velocity instantly (jumps, d-pad nudges), PLACE teleports (spawns, curve-riding pins), SET_GRAVITY retunes the pull live, SET_BIAS steers the bias field, RESTART reseeds. Emits BODY_MOVED for the lead body (bodies[0]) every tick so boards that subscribe can react — boards that don't subscribe pay nothing. Renders nothing.

Entity: MotionBodyData (runtime)

Traits

Config knobs

std-objective-flow

Headless win/lose authority for objective boards: owns only result. Listens PROGRESS (objectivesLeft + movesLeft) and sets result to won when every objective is reached, lost when the move budget runs out first, else none. Renders nothing. Corresponds to the design-sheet field(s): goals, feedback.

Entity: FlowState (runtime)

Traits

Config knobs

std-objective-reach

Headless reach-the-objective mechanic: owns features + score + objectivesLeft. Listens HERO_STEPPED and, when the hero lands on a target-type feature, scores it (optionally removing the model), emits a BURST pickup particle, and emits PROGRESS so round-flow can decide win/lose. Never writes units.

Entity: ObjectiveState (runtime)

Traits

Config knobs

std-pad-lock

pads of later groups refuse to light until the current group finishes, so one sum must be finished before the next. When a group completes the trait emits PAD_GROUP_COMPLETED once for it (first newly completed group reports; the shared entity carries the rest); when every pad in the set is lit it stamps completed and emits PAD_SET_COMPLETED once. The lowest uncompleted group is stamped on the shared entity as currentGrp so boards can pulse exactly the live pads (0 = no group open / ungrouped pads). RESTART unlights every live pad and resets the set (re-arming the live entity set, so SET_PADS-injected pads survive respawns). SET_PADS replaces the pad set at runtime for boards that import their pads. Renders nothing; boards draw the pads and read lit from the shared entity (the render authority). Corresponds to the design-sheet field(s): challenge, mechanics.

Entity: PadLockData (runtime)

Traits

Config knobs

std-patience

Headless customer-service mechanic: owns a stationary customer roster with per-customer patience. Decrements patience every tick, serves nearby customers on HERO_STEPPED (resets their patience + scores), and emits CUSTOMER_LOST when a timer expires. Never writes units.

Entity: PatienceData (runtime)

Traits

Config knobs

std-patrol-hazard

cy = y + waveAmp·sin(2πt/wavePeriod from a per-row time accumulator — and the hit test and render read cy, so a waveAmp of 0 keeps the flat beat), tracks the player position off the body authority's BODY_MOVED, and emits PATROL_HIT once per contact — a per-patrol hit flag re-arms only after the player separates, so damage rules stay sparse (when two patrols connect on the same tick the first reports; the other reports on the next tick). Patrols live on a [runtime, shared] entity for the render layer (boards draw them as markers/sprites); damage, lives, and respawn stay downstream (std-lives) — this atom simulates, it never judges. SET_PATROLS replaces the live patrol set at runtime for boards that import their patrols; RESTART re-arms the live set, so injected patrols survive respawns. Renders nothing. Corresponds to the design-sheet field(s): challenge, dynamics.

Entity: PatrolState (runtime)

Traits

Config knobs

std-pickup

the platformer twin of grid std-gather. Listens BODY_MOVED and, when the player touches an uncollected feature (|dx| <= reachX, |dy| <= reachY of the feature center — the coef-pad touch idiom minus the grounded requirement, so airborne pickups work), stamps it collected on the shared entity and emits PICKED once per item (id, kind, position, glyph, message) plus COLLECT{total} with the running count (the event std-gate-lock already consumes). A feature carrying active: false is visible but NOT collectible (gated pickups — e.g. a star that only counts once the curve passes through it); FEATURES_ACTIVE{updates:[{id,active}]} flips gates in place without re-arming collected. When every feature is collected it emits PICKUP_SET_COMPLETED once. RESTART re-arms every feature and zeroes the count (re-arming the live entity set, so SET_FEATURES-injected features survive). SET_FEATURES replaces the collectible set at runtime for boards that import their features; ADD_FEATURES appends without disturbing the live set (mid-game gem drops). kind is board-defined vocabulary (star, boost, …) — this atom reports, boards judge. Renders nothing; boards draw the features and read collected from the shared entity. Corresponds to the design-sheet field(s): rewards.

Entity: PickupData (runtime)

Traits

Config knobs

std-platformer-body

a body moving in the gravity direction that overlaps a ground/platform tile lands on its anti-gravity face (vy zeroed, grounded set), while a body moving against gravity passes through, so jumping up through a platform and walking up a staircase both just work. The sign of gravity IS the vertical convention: positive pulls toward +y (screen boards, y down — sprite canvases), negative toward −y (math canvases, y up); jumps always fire against it. Geometry lives on the shared entity: config platforms/skateCurve/driftRegions seed entity.platforms/skateCurve/driftRegions on INIT, and SET_PLATFORMS / SET_SKATE_CURVE / SET_DRIFT_REGIONS replace them at runtime (RESTART keeps the live set, so boards that import geometry never lose it on a respawn). Intents: STEER sets horizontal velocity (dir −1/0/1 × moveSpeed, hold-to-run: keydown steers, keyup steers 0), JUMP kicks vertical velocity when grounded, PLACE teleports (spawns, hazard respawns), RESTART reseeds. Emits BODY_MOVED every tick for the render layer (boards that don't subscribe pay nothing), plus the sparse rule signals a board needs to score: BODY_JUMPED, BODY_LANDED (with impact speed), BODY_HAZARD (once per hazard entry, re-arms on exit), BODY_GOAL (same arming), BODY_FELL (once per fall past killY, re-armed by PLACE/RESTART). Drift regions: the driftRegions set lists axis-aligned rects each carrying a constant acceleration (ax, ay) applied with the same 0.033s dt whenever the body's center is inside (empty list = zero behavior change). Curve skating: when config.skate is on and the grounded body comes within skateSnap of the skateCurve surface, the body rides the curve — y snaps to the interpolated surface and tangential gravity (g·slope/(1+slope²)) accelerates vx, and the vertical velocity is the tangential projection (s = vx·cos θ, vy = s·sin θ — no discontinuous jumps at sample boundaries), so the body slides downhill along the graph itself and launches ballistically off its ends; jumping kicks free. Sparse BODY_SKATE_START/BODY_SKATE_END signals fire on engage/disengage so boards can layer fx. Lives, score, and win/lose stay downstream — this atom simulates, it never judges. Renders nothing. Corresponds to the design-sheet field(s): mechanics, dynamics.

Entity: PlatformerBodyData (runtime)

Traits

Config knobs

std-production

Headless unit-production mechanic: accrues productionPoints each turn (AI_TURN) and, on an affordable PRODUCE, emits a SPAWN intent for the grid-tactics authority to place a new unit. Owns only productionPoints (+ its spawn counter); never writes units directly.

Entity: ProductionState (runtime)

Traits

Config knobs

std-round-flow

Headless win/lose round-resolution mechanic: derives result (victory/defeat/none) from team survivor counts on each UNITS_CHANGED signal and emits GAME_END. Owns only result; boards own their own phase/turn. Renders nothing.

Entity: RoundState (runtime)

Traits

Config knobs

std-score

Headless scoring mechanic: awards points when the enemy survivor count drops on a UNITS_CHANGED signal. Owns only score (+ its kill baseline); renders nothing.

Entity: ScoreState (runtime)

Traits

Config knobs

std-survival-flow

Headless win/lose authority for the nature-survival board: owns only result. Listens RESOURCES (movesLeft) and sets result to lost when the move budget runs out before the camp is built; listens BUILD_CAMP (the render-gated win intent) and sets result to won. Renders nothing.

Entity: SurvivalFlowData (runtime)

Traits

Config knobs

std-svg-asset-art

SOLE writer of @entity.svgAssetArt: collects vector asset catalogs published on the bus (SVG_ASSET_PUBLISH { kind, states }) into one kind → (state → draw-group items) map that board frames select per-row per anim state. INIT seeds from config and emits SVG_ASSET_SYNC so already-mounted catalogs republish regardless of mount order; the SYNC self-hop re-applies the seed after sibling canvas stashes exist (Almadar_Runtime_Gaps.md R-INIT-SEED-REPAINT-RACE). Renders nothing — render authority stays with the frame.

Entity: StdSvgAssetArt (runtime)

Traits

Config knobs

std-tutorial-autodemo

the organism maps DEMO_* to its own steering, so a demo cannot self-cancel through the board's input path.

Entity: AutoDemoData (runtime)

Traits

Config knobs

std-tutorial-overlay

title, a live previewTrait frame playing the mechanic via std-tutorial-autodemo (a bare game canvas, no shell chrome), one line of body copy, a step counter, and Back / Next / Skip — composed entirely from registered render types (stack + text + button + trait frame) into the overlay slot, so no new UI component is needed. autoShow opens it on INIT for first-time players; a board's help button re-opens it any time via SHOW (which rewinds to step one). DISMISS (or finishing the last step) marks the run done, clears the overlay, and emits TUTORIAL_DONE so the board can unpause or log. Steps are pure config — a board teaches a new mechanic by adding one { id, title, body, demoId } row plus a previewTrait binding. Corresponds to the design-sheet field(s): feedback, agency.

Entity: TutorialState (runtime)

Traits

Config knobs

std-velocity-gate

a failing move resets the hold. The first newly opened gate emits VELOCITY_GATE_OPENED (the shared entity carries the rest). Entering a closed INSTANT gate while NOT passing emits VELOCITY_GATE_DENIED once per approach — re-arming only after the player steps out — so the board can answer with a PLACE back and a hint fx; dwell gates never deny (a hot entry is fine — coming to rest inside is the point), a failed hold simply resets. RESTART re-closes every live gate (re-arming the live entity set, so SET_VGATES-injected gates survive respawns). SET_VGATES replaces the gate set at runtime for boards that import their gates. Renders nothing; boards draw the gate band/chest and read open/held from the shared entity (the render authority). Corresponds to the design-sheet field(s): challenge, mechanics.

Entity: VelocityGateData (runtime)

Traits

Config knobs

std-xp

raising the threshold and emitting a HEAL reward the grid-tactics authority applies. Owns only xp/xpToNext/level (+ kill baseline); never writes units.

Entity: XpState (runtime)

Traits

Config knobs

std-zone-card

name, concept, objective — for a while after every crossing. Listens BODY_MOVED and, when the player's x crosses into a different config zone, stamps the shared entity (zoneId, card, enteredAt) and emits ZONE_CHANGED carrying the card fields; the card self-clears ttlTicks BODY_MOVED ticks later (a per-move tick counter on the entity, so pauses at speed zero still age it out) and boards clear it early via CARD_DISMISS (renamed to a board-scoped progress event) on any mechanic completion. RESTART clears the card and the clock. Renders nothing; boards draw the card from the shared entity (the render authority).

Entity: ZoneCardData (runtime)

Traits

Config knobs

std-arcade-board-3d

3D arcade-hall FRAME: composes hero-nav (free roam) + arcade-play (token/ticket economy) + fx-particles + arcade-flow (win/lose) onto one shared GameState with a single render authority. Games consume this molecule and supply only theme/assets/units/tiles/machines via config.

Entity: GameState (runtime)

Traits

Config knobs

std-crew-board-2d

2D multi-unit crew-management board FRAME: composes hero-nav (unit-by-id move authority, no combat) + fx-particles onto one shared GameState with a canvas-2d render and select/deselect/move intent. Games consume this molecule and supply only theme/assets/units/tiles via config.

Entity: GameState (runtime)

Traits

Config knobs

std-dungeon-board-2d

2D key-move dungeon-crawl board FRAME: composes hero-nav (key-move intent) + dungeon-combat (bump-attack, monster chase, hero HP) + objective-reach (exit/chest) + fx-particles + objective-flow (win) onto one shared GameState with a canvas-2d render. Games consume this molecule and supply only theme/assets/tiles/units/enemies/features via config.

Entity: GameState (runtime)

Traits

Config knobs

std-market-board-3d

3D single-hero market-service board FRAME: composes hero-nav (hero movement) + patience (stationary customers + starve timers) + fx-particles + market-flow (win/lose) onto one shared GameState with a single render authority. Games consume this molecule and supply only theme/assets/units/customers via config.

Entity: GameState (runtime)

Traits

Config knobs

std-objective-board-3d

3D single-hero objective board FRAME: composes hero-nav (units + move budget) + objective-reach (targets) + fx-particles + objective-flow (win/lose) onto one shared GameState with a single render authority. Games consume this molecule and supply only theme/assets/units/targets via config.

Entity: GameState (runtime)

Traits

Config knobs

std-platformer-board-2d

input forwarding (LEFT/RIGHT/STOP/JUMP → STEER/JUMP intents), goal scoring, hazard/pit lives with respawn, PLAY_AGAIN reset — physics, particles, and the win gate belong to the atoms. Games consume this organism and supply level geometry (platforms, in both BodyAuthority.platforms for collision and the render-side platforms knob), theme/assets, and physics feel via config/traitOverrides.

Entity: GameState (runtime)

Traits

Config knobs

std-platformer-puzzle

platformer-body, pickup, objective-flow, choice-gate, fx-particles, fx-narrative, tutorial-overlay — as the pillars a level rebinds: agency (body), challenge (choice), goal (objective), reward (pickup), feedback (fx, narrative, tutorial). Levels rebind these authorities locally and add their own geometry, render, and math rules. Math targets and grade levels stay downstream in the domain package; this substrate is domain-agnostic.

Entity: PlatformerPuzzleData (runtime)

Traits

Config knobs

std-survival-board-3d

3D single-hero survival board FRAME: composes hero-nav (units + move budget as energy) + gather (wood/stone resource nodes) + fx-particles + survival-flow (build-camp win / energy-out loss) onto one shared GameState with a single render authority. Games consume this molecule and supply only theme/assets/units/tiles/features/camp thresholds via config.

Entity: GameState (runtime)

Traits

Config knobs

std-tactics-board-2d

2D player-controlled grid-tactics board FRAME: composes grid-tactics (units authority) + fx-particles + round-flow + a player-intent/render trait onto one shared GameState with a canvas-2d render. Games consume this molecule and supply only theme/assets/units via config.

Entity: GameState (runtime)

Traits

Config knobs

std-tactics-board-3d

3D player-controlled grid-tactics board FRAME: composes grid-tactics (units authority) + fx-particles + round-flow + a player-intent/render trait onto one shared GameState. Games consume this molecule and supply only theme/assets/units via config.

Entity: GameState (runtime)

Traits

Config knobs

std-worldmap-board-2d

2D isometric overworld-travel board FRAME: composes grid-tactics (units authority) + round-flow (win/lose) + gold + a player-intent/render trait onto one shared GameState with an isometric canvas-2d render. Games consume this molecule and supply theme/assets/units/tiles/features via config.

Entity: GameState (runtime)

Traits

Config knobs

One ui-* behavior per UI pattern, generated 1:1 from the pattern registry: its config knobs are the pattern's props.