@almadar/std 16.204.0 → 16.206.0

package/behaviors/lolo/ui/game/atoms/std-gate-lock.lolo

@@ -1,5 +1,5 @@
 app std-gate-lock "1.0.0"
-"Headless collectible-gate mechanic: doors that stay shut until the player's collected total reaches their cost. Listens COLLECT (the board's running total — 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 door and zeroes the total. Renders nothing; boards draw closed doors as bars/walls and open ones as gaps. Corresponds to the design-sheet field(s): challenge, rewards."
+"Headless collectible-gate mechanic: doors that stay shut until the player's collected total reaches their cost. Listens COLLECT (the board's running total — 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."
 orbital GateLockOrbital {
   type Door = {
     id : string!
@@ -49,8 +49,12 @@ orbital GateLockOrbital {
           (emit GATE_BLOCKED { id: (object/get (array/first @blocked) id), x: (object/get (array/first @blocked) x), y: (object/get (array/first @blocked) y) })
           null))
 
+      SET_DOORS -> active
+        (set @entity.doors (array/map @payload.doors (fn d (object/merge @d { open: false, touching: false, blocked: false }))))
+        (set @entity.total 0)
+
       RESTART -> active
-        (set @entity.doors (array/map @config.doors (fn d (object/merge @d { open: false, touching: false, blocked: false }))))
+        (set @entity.doors (array/map @entity.doors (fn d (object/merge @d { open: false, touching: false, blocked: false }))))
         (set @entity.total 0)
     }
 
@@ -73,6 +77,7 @@ orbital GateLockOrbital {
     listens {
       COLLECT { total : number! }
       BODY_MOVED { x : number!, y : number!, vx : number!, vy : number!, grounded : boolean!, skating : boolean!, speed : number! }
+      SET_DOORS { doors : [Door]! }
       RESTART { id : string }
     }
 
@@ -83,7 +88,7 @@ orbital GateLockOrbital {
         @tier "domain"
       doors : [Door] = []
         @label "Doors"
-        @description "One row per gate: id, min-corner rect (x, y, width, height in world units) and the collected total that opens it. open/touching are stamped at runtime."
+        @description "One row per gate: id, min-corner rect (x, y, width, height in world units) and the collected total that opens it. open/touching are stamped at runtime. Seeded onto the entity on INIT; the live set is entity.doors — SET_DOORS replaces it at runtime (boards that import doors), and RESTART re-arms the live set rather than re-reading config, so injected doors survive respawns."
         @tier "domain"
       reachMargin : number = 0.6
         @label "Reach Margin"

package/behaviors/lolo/ui/game/atoms/std-loop-lock.lolo

@@ -1,5 +1,5 @@
 app std-loop-lock "1.0.0"
-"Headless winding-lock mechanic: locks that open only after the player travels a full revolution around their anchor. Listens BODY_MOVED and, while the player stays within a radial band of a lock's ring, accumulates the wrapped angular delta of their position into swept (radians, signed — 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 lock. 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."
+"Headless winding-lock mechanic: locks that open only after the player travels a full revolution around their anchor. Listens BODY_MOVED and, while the player stays within a radial band of a lock's ring, accumulates the wrapped angular delta of their position into swept (radians, signed — 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."
 orbital LoopLockOrbital {
   type LoopLock = {
     id : string!
@@ -44,8 +44,11 @@ orbital LoopLockOrbital {
             (emit LOOP_UNLOCKED { id: (object/get (array/first @newly) id), x: (object/get (array/first @newly) x), y: (object/get (array/first @newly) y) }))
           null))
 
+      SET_LOCKS -> active
+        (set @entity.locks (array/map @payload.locks (fn l (object/merge @l { swept: 0, lastAngle: 0, inside: false, unlocked: false, reported: false }))))
+
       RESTART -> active
-        (set @entity.locks (array/map @config.locks (fn l (object/merge @l { swept: 0, lastAngle: 0, inside: false, unlocked: false, reported: false }))))
+        (set @entity.locks (array/map @entity.locks (fn l (object/merge @l { swept: 0, lastAngle: 0, inside: false, unlocked: false, reported: false }))))
     }
 
     emits {
@@ -60,6 +63,7 @@ orbital LoopLockOrbital {
 
     listens {
       BODY_MOVED { x : number!, y : number!, vx : number!, vy : number!, grounded : boolean!, skating : boolean!, speed : number! }
+      SET_LOCKS { locks : [LoopLock]! }
       RESTART { id : string }
     }
 
@@ -70,7 +74,7 @@ orbital LoopLockOrbital {
         @tier "domain"
       locks : [LoopLock] = []
         @label "Locks"
-        @description "One row per winding lock: id, anchor (x, y in world units), ring radius, radial tolerance band, and revolutions required. swept/inside/unlocked are stamped at runtime."
+        @description "One row per winding lock: id, anchor (x, y in world units), ring radius, radial tolerance band, and revolutions required. swept/inside/unlocked are stamped at runtime. Seeded onto the entity on INIT; the live set is entity.locks — SET_LOCKS replaces it at runtime (boards that import locks), and RESTART re-arms the live set rather than re-reading config, so injected locks survive respawns."
         @tier "domain"
     }
   }

package/behaviors/lolo/ui/game/atoms/std-pad-lock.lolo

@@ -1,5 +1,5 @@
 app std-pad-lock "1.0.0"
-"Headless pad-lock mechanic: floor pads that light when the player steps on them, completing a set when every pad is lit. Listens BODY_MOVED and lights any unlit live pad the player's rect touches (|dx| <= reachX, |dy| <= reachY of the pad center); a lit pad stays lit. Pads may carry a group number (grp 0 = ungrouped, always live): when groups are used, only pads of the lowest uncompleted group are live — 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 pad and resets the set. 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."
+"Headless pad-lock mechanic: floor pads that light when the player steps on them, completing a set when every pad is lit. Listens BODY_MOVED and lights any unlit live pad the player's rect touches (|dx| <= reachX, |dy| <= reachY of the pad center); a lit pad stays lit. Pads may carry a group number (grp 0 = ungrouped, always live): when groups are used, only pads of the lowest uncompleted group are live — 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."
 orbital PadLockOrbital {
   type PadLock = {
     id : string!
@@ -49,8 +49,14 @@ orbital PadLockOrbital {
               (emit PAD_SET_COMPLETED {}))
             null))))))))
 
+      SET_PADS -> active
+        (set @entity.pads (array/map @payload.pads (fn p (object/merge @p { lit: false }))))
+        (set @entity.groupsDone [])
+        (set @entity.currentGrp 0)
+        (set @entity.completed false)
+
       RESTART -> active
-        (set @entity.pads (array/map @config.pads (fn p (object/merge @p { lit: false }))))
+        (set @entity.pads (array/map @entity.pads (fn p (object/merge @p { lit: false }))))
         (set @entity.groupsDone [])
         (set @entity.currentGrp 0)
         (set @entity.completed false)
@@ -70,6 +76,7 @@ orbital PadLockOrbital {
 
     listens {
       BODY_MOVED { x : number!, y : number!, vx : number!, vy : number!, grounded : boolean!, skating : boolean!, speed : number! }
+      SET_PADS { pads : [PadLock]! }
       RESTART { id : string }
     }
 
@@ -80,7 +87,7 @@ orbital PadLockOrbital {
         @tier "domain"
       pads : [PadLock] = []
         @label "Pads"
-        @description "One row per floor pad: id, center (x, y in world units), and grp (0 = ungrouped, always live; N = live only while it is the lowest uncompleted group). lit is stamped at runtime."
+        @description "One row per floor pad: id, center (x, y in world units), and grp (0 = ungrouped, always live; N = live only while it is the lowest uncompleted group). lit is stamped at runtime. Seeded onto the entity on INIT; the live set is entity.pads — SET_PADS replaces it at runtime (boards that import pads), and RESTART re-arms the live set rather than re-reading config, so injected pads survive respawns."
         @tier "domain"
       reachX : number = 0.7
         @label "Reach X"

package/behaviors/lolo/ui/game/atoms/std-patrol-hazard.lolo

@@ -1,5 +1,5 @@
 app std-patrol-hazard "1.0.0"
-"Headless patrol-hazard mechanic for side-view boards: moves each configured patrol back and forth along its [x0, x1] beat at its own speed (33ms tick, ping-pong with clamped turnarounds; a patrol declaring waveAmp/wavePeriod also bobs vertically — 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. Renders nothing. Corresponds to the design-sheet field(s): challenge, dynamics."
+"Headless patrol-hazard mechanic for side-view boards: moves each configured patrol back and forth along its [x0, x1] beat at its own speed (33ms tick, ping-pong with clamped turnarounds; a patrol declaring waveAmp/wavePeriod also bobs vertically — 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."
 orbital PatrolHazardOrbital {
   type Patrol = {
     id : string!
@@ -37,8 +37,13 @@ orbital PatrolHazardOrbital {
         (set @entity.px @payload.x)
         (set @entity.py @payload.y)
 
+      SET_PATROLS -> active
+        (set @entity.patrols (array/map @payload.patrols (fn p (object/merge @p { x: (object/get @p x0), dir: 1, t: 0, cy: (object/get @p y), touching: false, hit: false }))))
+        (set @entity.px @config.playerSpawnX)
+        (set @entity.py @config.playerSpawnY)
+
       RESTART -> active
-        (set @entity.patrols (array/map @config.patrols (fn p (object/merge @p { x: (object/get @p x0), dir: 1, t: 0, cy: (object/get @p y), touching: false, hit: false }))))
+        (set @entity.patrols (array/map @entity.patrols (fn p (object/merge @p { x: (object/get @p x0), dir: 1, t: 0, cy: (object/get @p y), touching: false, hit: false }))))
     }
 
     ticks {
@@ -72,6 +77,7 @@ orbital PatrolHazardOrbital {
 
     listens {
       BODY_MOVED { x : number!, y : number!, vx : number!, vy : number!, grounded : boolean!, skating : boolean!, speed : number! }
+      SET_PATROLS { patrols : [Patrol]! }
       RESTART { id : string }
     }
 
@@ -82,7 +88,7 @@ orbital PatrolHazardOrbital {
         @tier "domain"
       patrols : [Patrol] = []
         @label "Patrols"
-        @description "One row per patroller: id, the [x0, x1] beat it walks, its base y, its speed in units/s, and optionally waveAmp/wavePeriod for a vertical sine bob (waveAmp 0 = flat ping-pong). Current x/dir/t/cy/touching/hit are stamped at runtime."
+        @description "One row per patroller: id, the [x0, x1] beat it walks, its base y, its speed in units/s, and optionally waveAmp/wavePeriod for a vertical sine bob (waveAmp 0 = flat ping-pong). Current x/dir/t/cy/touching/hit are stamped at runtime. Seeded onto the entity on INIT; the live set is entity.patrols — SET_PATROLS replaces it at runtime (boards that import patrols), and RESTART re-arms the live set rather than re-reading config, so injected patrols survive respawns."
         @tier "domain"
       hitRadius : number = 0.7
         @label "Hit Radius"

package/behaviors/lolo/ui/game/atoms/std-pickup.lolo

@@ -1,5 +1,5 @@
 app std-pickup "1.0.0"
-"Headless side-view collectible authority — 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). When every feature is collected it emits PICKUP_SET_COMPLETED once. RESTART re-arms every feature and zeroes the count. 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."
+"Headless side-view collectible authority — 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."
 orbital PickupOrbital {
   type PickupFeature = {
     id : string!
@@ -9,6 +9,12 @@ orbital PickupOrbital {
     glyph : string
     message : string
     collected : boolean
+    active : boolean
+  }
+
+  type PickupActiveUpdate = {
+    id : string!
+    active : boolean!
   }
 
   entity PickupData [runtime, shared] {
@@ -30,8 +36,9 @@ orbital PickupOrbital {
       BODY_MOVED -> active when @config.running
         (let ((touch (array/filter @entity.pickups (fn f
           (and (== (object/get @f collected) false)
-            (and (<= (math/abs (- @payload.x (object/get @f x))) @config.reachX)
-              (<= (math/abs (- @payload.y (object/get @f y))) @config.reachY)))))))
+            (and (!= (object/get @f active) false)
+              (and (<= (math/abs (- @payload.x (object/get @f x))) @config.reachX)
+                (<= (math/abs (- @payload.y (object/get @f y))) @config.reachY))))))))
         (if (> (array/len @touch) 0)
           (let ((f (array/first @touch)))
           (let ((remaining (array/len (array/filter @entity.pickups (fn c (and (== (object/get @c collected) false) (!= (object/get @c id) (object/get @f id))))))))
@@ -47,8 +54,22 @@ orbital PickupOrbital {
               null))))
           null))
 
+      SET_FEATURES -> active
+        (set @entity.pickups (array/map @payload.features (fn f (object/merge @f { collected: false }))))
+        (set @entity.pickupCompleted false)
+        (set @entity.total 0)
+
+      ADD_FEATURES -> active
+        (set @entity.pickups (array/concat @entity.pickups (array/map @payload.features (fn f (object/merge @f { collected: false })))))
+        (set @entity.pickupCompleted false)
+
+      FEATURES_ACTIVE -> active
+        (set @entity.pickups (array/map @entity.pickups (fn f
+          (let ((m (array/filter @payload.updates (fn u (== (object/get @u id) (object/get @f id))))))
+          (if (> (array/len @m) 0) (object/merge @f { active: (object/get (array/first @m) active) }) @f)))))
+
       RESTART -> active
-        (set @entity.pickups (array/map @config.features (fn f (object/merge @f { collected: false }))))
+        (set @entity.pickups (array/map @entity.pickups (fn f (object/merge @f { collected: false }))))
         (set @entity.pickupCompleted false)
         (set @entity.total 0)
     }
@@ -77,6 +98,9 @@ orbital PickupOrbital {
 
     listens {
       BODY_MOVED { x : number!, y : number!, vx : number!, vy : number!, grounded : boolean!, skating : boolean!, speed : number! }
+      SET_FEATURES { features : [PickupFeature]! }
+      ADD_FEATURES { features : [PickupFeature]! }
+      FEATURES_ACTIVE { updates : [PickupActiveUpdate]! }
       RESTART { id : string }
     }
 
@@ -87,7 +111,7 @@ orbital PickupOrbital {
         @tier "domain"
       features : [PickupFeature] = []
         @label "Features"
-        @description "One row per collectible: id, center (x, y in world units), board-defined kind (star, boost, …), display glyph and message floated on pickup. collected is stamped at runtime."
+        @description "One row per collectible: id, center (x, y in world units), board-defined kind (star, boost, …), display glyph and message floated on pickup. collected is stamped at runtime. Seeded onto the entity on INIT; the live set is entity.pickups — SET_FEATURES replaces it at runtime (boards that import collectibles), and RESTART re-arms the live set rather than re-reading config, so injected features survive respawns."
         @tier "domain"
       reachX : number = 0.7
         @label "Reach X"

package/behaviors/lolo/ui/game/atoms/std-platformer-body.lolo

@@ -1,5 +1,5 @@
 app std-platformer-body "1.0.0"
-"Headless run/jump platformer-physics authority: the SOLE writer of body + fell + hazardId + goalId on side-view boards. Where std-motion-body owns free 2D drift (no collision), this atom owns the platformer contract: every 33ms physics tick it integrates gravity into the body's vertical velocity, steps position in per-second units, and collides the body rect against the config platforms with one-way semantics — 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. 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: config.driftRegions 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 config.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."
+"Headless run/jump platformer-physics authority: the SOLE writer of body + fell + hazardId + goalId on side-view boards. Where std-motion-body owns free 2D drift (no collision), this atom owns the platformer contract: every 33ms physics tick it integrates gravity into the body's vertical velocity, steps position in per-second units, and collides the body rect against the platform set with one-way semantics — 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."
 orbital PlatformerBodyOrbital {
   type PlatformerBody = {
     x : number!
@@ -55,6 +55,9 @@ orbital PlatformerBodyOrbital {
     goalId : string = ""
     skating : boolean = false
     tuning : PlatformerTuning = {}
+    platforms : [PlatformerPlatform] = []
+    skateCurve : [PlatformerCurveSample] = []
+    driftRegions : [BodyDriftRegion] = []
   }
 
   trait PlatformerBody -> @rebindable PlatformerBodyData [lifecycle] {
@@ -67,6 +70,9 @@ orbital PlatformerBodyOrbital {
         (set @entity.hazardId "")
         (set @entity.goalId "")
         (set @entity.skating false)
+        (set @entity.platforms @config.platforms)
+        (set @entity.skateCurve @config.skateCurve)
+        (set @entity.driftRegions @config.driftRegions)
 
       STEER -> active when @config.running
         (set @entity.body (object/merge @entity.body { vx: (* @payload.dir (if (== (object/get @entity.tuning moveSpeed null) null) @config.moveSpeed (object/get @entity.tuning moveSpeed null))), facingRight: (if (!= @payload.dir 0) (> @payload.dir 0) @entity.body.facingRight) }))
@@ -87,11 +93,23 @@ orbital PlatformerBodyOrbital {
       CURVE_MOD_CLEAR -> active when @config.curveModsEnabled
         (set @entity.curveMods [])
 
+      CURVE_MOD_CLEAR_RANGE -> active when @config.curveModsEnabled
+        (set @entity.curveMods (array/filter @entity.curveMods (fn m (or (< (object/get @m x1) @payload.x0) (> (object/get @m x0) @payload.x1)))))
+
       SET_TUNING -> active
         (set @entity.tuning (object/merge @entity.tuning (if (== @payload.jumpStrength null) {} { jumpStrength: @payload.jumpStrength })))
         (set @entity.tuning (object/merge @entity.tuning (if (== @payload.moveSpeed null) {} { moveSpeed: @payload.moveSpeed })))
         (set @entity.tuning (object/merge @entity.tuning (if (== @payload.gravity null) {} { gravity: @payload.gravity })))
 
+      SET_PLATFORMS -> active
+        (set @entity.platforms @payload.platforms)
+
+      SET_SKATE_CURVE -> active
+        (set @entity.skateCurve @payload.curve)
+
+      SET_DRIFT_REGIONS -> active
+        (set @entity.driftRegions @payload.regions)
+
       RESTART -> active
         (set @entity.body @config.spawn)
         (set @entity.curveMods [])
@@ -108,29 +126,29 @@ orbital PlatformerBodyOrbital {
         (let ((eg (if (== (object/get @entity.tuning gravity null) null) @config.gravity (object/get @entity.tuning gravity null))))
         (let ((gdir (if (> @eg 0) 1 -1)))
         (let ((bcx (+ (object/get @entity.body x) (/ (object/get @entity.body width) 2))) (bcy (+ (object/get @entity.body y) (/ (object/get @entity.body height) 2))))
-        (let ((drift (array/find @config.driftRegions (fn r (and (>= @bcx (object/get @r x0)) (and (<= @bcx (object/get @r x1)) (and (>= @bcy (object/get @r y0)) (<= @bcy (object/get @r y1)))))))))
+        (let ((drift (array/find @entity.driftRegions (fn r (and (>= @bcx (object/get @r x0)) (and (<= @bcx (object/get @r x1)) (and (>= @bcy (object/get @r y0)) (<= @bcy (object/get @r y1)))))))))
         (let ((dax (if (== @drift null) 0 (object/get @drift ax))) (day (if (== @drift null) 0 (object/get @drift ay))))
         (let ((vy1 (math/clamp (+ @entity.body.vy (* (+ @eg @day) 0.033)) (- 0 @config.maxFallSpeed) @config.maxFallSpeed)))
         (let ((bw (object/get @entity.body width)) (bh (object/get @entity.body height)))
         (let ((nx (math/clamp (+ @entity.body.x (* @entity.body.vx 0.033)) @config.xMin @config.xMax)))
         (let ((ny (+ @entity.body.y (* @vy1 0.033))))
         (let ((rect { x: @nx, y: @ny, w: @bw, h: @bh }))
-        (let ((hit (array/find @config.platforms (fn p (and (or (== (object/get @p type) "ground") (== (object/get @p type) "platform")) (geo/aabb-overlap @rect { x: @p.x, y: @p.y, w: @p.width, h: @p.height }))))))
+        (let ((hit (array/find @entity.platforms (fn p (and (or (== (object/get @p type) "ground") (== (object/get @p type) "platform")) (geo/aabb-overlap @rect { x: @p.x, y: @p.y, w: @p.width, h: @p.height }))))))
         (let ((landed (and (!= @hit null) (> (* @vy1 @gdir) 0))))
         (let ((ny2 (if @landed (if (> @gdir 0) (- (object/get @hit y) @bh) (+ (object/get @hit y) (object/get @hit height))) @ny)) (vy2 (if @landed 0 @vy1)))
         (let ((cx (+ @nx (/ @bw 2))))
-        (let ((inRange (and @config.skate (and (> (array/len @config.skateCurve) 1) (and (>= @cx (object/get (array/first @config.skateCurve) x)) (< @cx (object/get (array/last @config.skateCurve) x)))))))
-        (let ((leftSamp (if @inRange (array/last (array/filter @config.skateCurve (fn s (<= (object/get @s x) @cx)))) { x: 0, y: 0 })))
-        (let ((rightSamp (if @inRange (array/first (array/filter @config.skateCurve (fn s (> (object/get @s x) @cx)))) { x: 1, y: 0 })))
+        (let ((inRange (and @config.skate (and (> (array/len @entity.skateCurve) 1) (and (>= @cx (object/get (array/first @entity.skateCurve) x)) (< @cx (object/get (array/last @entity.skateCurve) x)))))))
+        (let ((leftSamp (if @inRange (array/last (array/filter @entity.skateCurve (fn s (<= (object/get @s x) @cx)))) { x: 0, y: 0 })))
+        (let ((rightSamp (if @inRange (array/first (array/filter @entity.skateCurve (fn s (> (object/get @s x) @cx)))) { x: 1, y: 0 })))
         (let ((slope (if @inRange (/ (- (object/get @rightSamp y) (object/get @leftSamp y)) (- (object/get @rightSamp x) (object/get @leftSamp x))) 0)))
         (let ((curveY (if @inRange (+ (object/get @leftSamp y) (* @slope (- @cx (object/get @leftSamp x)))) 0)))
         (let ((gapBreak (and (> @config.skateMaxGap 0) (> (- (object/get @rightSamp x) (object/get @leftSamp x)) @config.skateMaxGap))))
         (let ((mods (if (and @config.curveModsEnabled @inRange) (array/filter @entity.curveMods (fn m (and (>= @cx (object/get @m x0)) (<= @cx (object/get @m x1))))) [])))
         (let ((modded (array/reduce @mods { y: @curveY, s: @slope } (fn (acc m)
           (let ((modX (* (object/get @m b) (- @cx (object/get @m h)))))
-          (let ((modInRange (and (>= @modX (object/get (array/first @config.skateCurve) x)) (< @modX (object/get (array/last @config.skateCurve) x)))))
-          (let ((modLeft (if @modInRange (array/last (array/filter @config.skateCurve (fn s (<= (object/get @s x) @modX)))) null)))
-          (let ((modRight (if @modInRange (array/first (array/filter @config.skateCurve (fn s (> (object/get @s x) @modX)))) null)))
+          (let ((modInRange (and (>= @modX (object/get (array/first @entity.skateCurve) x)) (< @modX (object/get (array/last @entity.skateCurve) x)))))
+          (let ((modLeft (if @modInRange (array/last (array/filter @entity.skateCurve (fn s (<= (object/get @s x) @modX)))) null)))
+          (let ((modRight (if @modInRange (array/first (array/filter @entity.skateCurve (fn s (> (object/get @s x) @modX)))) null)))
           (let ((modOK (and @modInRange (and (!= @modLeft null) (!= @modRight null)))))
           (let ((modSlope (if @modOK (/ (- (object/get @modRight y) (object/get @modLeft y)) (- (object/get @modRight x) (object/get @modLeft x))) 0)))
           (let ((modCurveY (if @modOK (+ (object/get @modLeft y) (* @modSlope (- @modX (object/get @modLeft x)))) 0)))
@@ -145,8 +163,8 @@ orbital PlatformerBodyOrbital {
         (let ((vx2 (if @skateNow (math/clamp (+ @entity.body.vx (* (/ (* @eg @slope) (+ 1 (* @slope @slope))) 0.033)) (- 0 @config.maxFallSpeed) @config.maxFallSpeed) @entity.body.vx)))
         (let ((vx3 (if (== @drift null) @vx2 (math/clamp (+ @vx2 (* @dax 0.033)) (- 0 @config.maxFallSpeed) @config.maxFallSpeed))))
         (let ((fy (if @skateNow @curveY @ny2)) (fvy (if @skateNow (* (* @vx2 (math/cos (math/atan @slope))) (math/sin (math/atan @slope))) @vy2)) (fgrounded (or @landed @skateNow)))
-        (let ((hazardHit (array/find @config.platforms (fn p (and (== (object/get @p type) "hazard") (geo/aabb-overlap @rect { x: @p.x, y: @p.y, w: @p.width, h: @p.height }))))))
-        (let ((goalHit (array/find @config.platforms (fn p (and (== (object/get @p type) "goal") (geo/aabb-overlap @rect { x: @p.x, y: @p.y, w: @p.width, h: @p.height }))))))
+        (let ((hazardHit (array/find @entity.platforms (fn p (and (== (object/get @p type) "hazard") (geo/aabb-overlap @rect { x: @p.x, y: @p.y, w: @p.width, h: @p.height }))))))
+        (let ((goalHit (array/find @entity.platforms (fn p (and (== (object/get @p type) "goal") (geo/aabb-overlap @rect { x: @p.x, y: @p.y, w: @p.width, h: @p.height }))))))
         (let ((fellNow (if (> @gdir 0) (> @fy @config.killY) (< @fy @config.killY))))
           (do
             (set @entity.body (object/merge @entity.body { x: @nx, y: @fy, vx: (if (or (== @nx @config.xMin) (== @nx @config.xMax)) 0 @vx3), vy: @fvy, grounded: @fgrounded }))
@@ -252,7 +270,11 @@ orbital PlatformerBodyOrbital {
       PLACE { x : number!, y : number! }
       CURVE_MOD_ADD { x0 : number!, x1 : number!, a : number!, b : number, h : number!, k : number! }
       CURVE_MOD_CLEAR { }
+      CURVE_MOD_CLEAR_RANGE { x0 : number!, x1 : number! }
       SET_TUNING { jumpStrength : number, moveSpeed : number, gravity : number }
+      SET_PLATFORMS { platforms : [PlatformerPlatform]! }
+      SET_SKATE_CURVE { curve : [PlatformerCurveSample]! }
+      SET_DRIFT_REGIONS { regions : [BodyDriftRegion]! }
       RESTART { id : string }
     }
 
@@ -267,7 +289,7 @@ orbital PlatformerBodyOrbital {
         @tier "domain"
       platforms : [PlatformerPlatform] = []
         @label "Platforms"
-        @description "Level geometry as min-corner rects: ground/platform tiles are solid one-way landing surfaces, hazard tiles emit BODY_HAZARD on touch, goal tiles emit BODY_GOAL"
+        @description "Level geometry as min-corner rects: ground/platform tiles are solid one-way landing surfaces, hazard tiles emit BODY_HAZARD on touch, goal tiles emit BODY_GOAL. Seeded onto the entity on INIT; the live set is entity.platforms — SET_PLATFORMS replaces it at runtime (boards that import geometry, e.g. stitched open worlds) and RESTART deliberately does NOT reseed it, so injected geometry survives respawns."
         @tier "domain"
       gravity : number = 24
         @label "Gravity"
@@ -307,7 +329,7 @@ orbital PlatformerBodyOrbital {
         @tier "domain"
       skateCurve : [PlatformerCurveSample] = []
         @label "Skate Curve"
-        @description "Surface samples (x strictly increasing) the body skates when skate is on; y is the surface height for the body's MIN corner, linearly interpolated between bracketing samples — mirror the render-side curve so what you see is what you ride"
+        @description "Surface samples (x strictly increasing) the body skates when skate is on; y is the surface height for the body's MIN corner, linearly interpolated between bracketing samples — mirror the render-side curve so what you see is what you ride. Seeded onto the entity on INIT; the live curve is entity.skateCurve — SET_SKATE_CURVE replaces it at runtime (stitched mega-curves) and RESTART does not reseed it."
         @tier "domain"
       skateMaxGap : number = 0
         @label "Skate Max Gap"
@@ -319,7 +341,7 @@ orbital PlatformerBodyOrbital {
         @tier "domain"
       driftRegions : [BodyDriftRegion] = []
         @label "Drift Regions"
-        @description "Axis-aligned rects (x0..x1, y0..y1 in world units) each carrying a constant acceleration (ax, ay in units/s²) applied with the physics dt whenever the body's center is inside — winds, currents, gradient pushes. Empty list = zero behavior change."
+        @description "Axis-aligned rects (x0..x1, y0..y1 in world units) each carrying a constant acceleration (ax, ay in units/s²) applied with the physics dt whenever the body's center is inside — winds, currents, gradient pushes. Empty list = zero behavior change. Seeded onto the entity on INIT; the live set is entity.driftRegions — SET_DRIFT_REGIONS replaces it at runtime and RESTART does not reseed it."
         @tier "domain"
     }
   }

package/behaviors/lolo/ui/game/atoms/std-velocity-gate.lolo

@@ -1,5 +1,5 @@
 app std-velocity-gate "1.0.0"
-"Headless velocity-gate mechanic: gates that open only when the player crosses them inside a speed band, optionally in a required direction, optionally sustained for a dwell. Listens BODY_MOVED and, per closed gate, tests the player's rect (padded by reachMargin), their speed against [minSpeed, maxSpeed], and their horizontal direction against dir (0 = either). Instant gates (dwellMs 0) open on the first passing cross; dwell gates (dwellMs > 0) accumulate ~33ms per passing move and open once held reaches dwellMs — 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 gate. 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."
+"Headless velocity-gate mechanic: gates that open only when the player crosses them inside a speed band, optionally in a required direction, optionally sustained for a dwell. Listens BODY_MOVED and, per closed gate, tests the player's rect (padded by reachMargin), their speed against [minSpeed, maxSpeed], and their horizontal direction against dir (0 = either). Instant gates (dwellMs 0) open on the first passing cross; dwell gates (dwellMs > 0) accumulate ~33ms per passing move and open once held reaches dwellMs — 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."
 orbital VelocityGateOrbital {
   type VelocityGate = {
     id : string!
@@ -54,8 +54,11 @@ orbital VelocityGateOrbital {
           (emit VELOCITY_GATE_DENIED { id: (object/get (array/first @denied) id), x: (object/get (array/first @denied) x), y: (object/get (array/first @denied) y), speed: @payload.speed })
           null))
 
+      SET_VGATES -> active
+        (set @entity.gates (array/map @payload.gates (fn g (object/merge @g { open: false, touching: false, denied: false, held: 0, reported: false }))))
+
       RESTART -> active
-        (set @entity.gates (array/map @config.gates (fn g (object/merge @g { open: false, touching: false, denied: false, held: 0, reported: false }))))
+        (set @entity.gates (array/map @entity.gates (fn g (object/merge @g { open: false, touching: false, denied: false, held: 0, reported: false }))))
     }
 
     emits {
@@ -78,6 +81,7 @@ orbital VelocityGateOrbital {
 
     listens {
       BODY_MOVED { x : number!, y : number!, vx : number!, vy : number!, grounded : boolean!, skating : boolean!, speed : number! }
+      SET_VGATES { gates : [VelocityGate]! }
       RESTART { id : string }
     }
 
@@ -88,7 +92,7 @@ orbital VelocityGateOrbital {
         @tier "domain"
       gates : [VelocityGate] = []
         @label "Gates"
-        @description "One row per velocity gate: id, min-corner rect (x, y, width, height in world units), the speed band [minSpeed, maxSpeed] that opens it, the hold required (dwellMs 0 = instant), the horizontal direction required (dir -1/0/+1), and an optional hint shown when denied. open/touching/denied/held/reported are stamped at runtime."
+        @description "One row per velocity gate: id, min-corner rect (x, y, width, height in world units), the speed band [minSpeed, maxSpeed] that opens it, the hold required (dwellMs 0 = instant), the horizontal direction required (dir -1/0/+1), and an optional hint shown when denied. open/touching/denied/held/reported are stamped at runtime. Seeded onto the entity on INIT; the live set is entity.gates — SET_VGATES replaces it at runtime (boards that import gates), and RESTART re-arms the live set rather than re-reading config, so injected gates survive respawns."
         @tier "domain"
       reachMargin : number = 0.6
         @label "Reach Margin"