@almadar/std 16.187.0 → 16.189.0

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

@@ -0,0 +1,79 @@
+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)."
+orbital LoopLockOrbital {
+  type LoopLock = {
+    id : string!
+    x : number!
+    y : number!
+    radius : number!
+    band : number!
+    turns : number!
+    swept : number
+    lastAngle : number
+    inside : boolean
+    unlocked : boolean
+    reported : boolean
+  }
+
+  entity LoopLockData [runtime, shared] {
+    id : string!
+    locks : [LoopLock] = []
+  }
+
+  trait LoopLock -> @rebindable LoopLockData [lifecycle] {
+    initial: active
+
+    state active {
+      INIT -> active
+        (set @entity.locks (array/map @config.locks (fn l (object/merge @l { swept: 0, lastAngle: 0, inside: false, unlocked: false, reported: false }))))
+
+      BODY_MOVED -> active when @config.running
+        (set @entity.locks (array/map @entity.locks (fn l
+          (let ((dx (- @payload.x (object/get @l x))) (dy (- @payload.y (object/get @l y))))
+          (let ((dist (math/hypot @dx @dy)) (ang (math/atan2 @dy @dx)))
+          (let ((in (<= (math/abs (- @dist (object/get @l radius))) (object/get @l band))))
+          (let ((d (if (and @in (== (object/get @l inside) true))
+                     (math/atan2 (math/sin (- @ang (object/get @l lastAngle))) (math/cos (- @ang (object/get @l lastAngle))))
+                     0)))
+          (let ((swept (+ (object/get @l swept) @d)))
+            (object/merge @l { inside: @in, lastAngle: (if @in @ang (object/get @l lastAngle)), swept: @swept, unlocked: (or (object/get @l unlocked) (>= (math/abs @swept) (* (object/get @l turns) 6.283185307179586))) })))))))))
+        (let ((newly (array/filter @entity.locks (fn l (and (== (object/get @l unlocked) true) (== (object/get @l reported) false))))))
+        (if (> (array/len @newly) 0)
+          (do
+            (set @entity.locks (array/map @entity.locks (fn l (if (== (object/get @l id) (object/get (array/first @newly) id)) (object/merge @l { reported: true }) @l))))
+            (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))
+
+      RESTART -> active
+        (set @entity.locks (array/map @config.locks (fn l (object/merge @l { swept: 0, lastAngle: 0, inside: false, unlocked: false, reported: false }))))
+    }
+
+    emits {
+      LOOP_UNLOCKED -> external {
+        id : string!
+        x : number!
+        y : number!
+      }
+        @description "A lock's angular sweep reached turns × 2π and it flipped unlocked; boards layer treasure fx and rewards. When several locks open on one move, the first reports and the shared entity carries the rest."
+        @tier "domain"
+    }
+
+    listens {
+      BODY_MOVED { x : number!, y : number!, vx : number!, vy : number!, grounded : boolean!, skating : boolean!, speed : number! }
+      RESTART { id : string }
+    }
+
+    config {
+      running : boolean = true
+        @label "Running"
+        @description "When true, BODY_MOVED accumulates angular sweep and unlocks locks; toggle to freeze every lock as-is."
+        @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."
+        @tier "domain"
+    }
+  }
+
+  page "/loop-lock" as LoopLockPage -> LoopLock
+}

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

@@ -0,0 +1,97 @@
+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)."
+orbital PadLockOrbital {
+  type PadLock = {
+    id : string!
+    x : number!
+    y : number!
+    grp : number!
+    lit : boolean
+  }
+
+  entity PadLockData [runtime, shared] {
+    id : string!
+    pads : [PadLock] = []
+    groupsDone : [number] = []
+    currentGrp : number = 0
+    completed : boolean = false
+  }
+
+  trait PadLock -> @rebindable PadLockData [lifecycle] {
+    initial: active
+
+    state active {
+      INIT -> active
+        (set @entity.pads (array/map @config.pads (fn p (object/merge @p { lit: false }))))
+        (set @entity.groupsDone [])
+        (set @entity.currentGrp 0)
+        (set @entity.completed false)
+
+      BODY_MOVED -> active when @config.running
+        (let ((grpIds (array/reduce (array/map (array/filter @entity.pads (fn p (> (object/get @p grp) 0))) (fn p (object/get @p grp))) [] (fn acc g (if (> (array/len (array/filter @acc (fn x (== @x @g)))) 0) @acc (array/append @acc @g))))))
+        (let ((openGrps (array/filter @grpIds (fn g (< (array/len (array/filter @entity.pads (fn p (and (== (object/get @p grp) @g) (== (object/get @p lit) true))))) (array/len (array/filter @entity.pads (fn p (== (object/get @p grp) @g)))))))))
+        (let ((currentGrp (array/reduce @openGrps 9999 (fn acc g (math/min @acc @g)))))
+        (let ((newPads (array/map @entity.pads (fn p
+          (object/merge @p { lit: (or (object/get @p lit) (and (or (== (object/get @p grp) 0) (== (object/get @p grp) @currentGrp)) (and (<= (math/abs (- @payload.x (object/get @p x))) @config.reachX) (<= (math/abs (- @payload.y (object/get @p y))) @config.reachY)))) })))))
+        (let ((doneNow (array/filter @grpIds (fn g (== (array/len (array/filter @newPads (fn p (and (== (object/get @p grp) @g) (== (object/get @p lit) true))))) (array/len (array/filter @newPads (fn p (== (object/get @p grp) @g)))))))))
+        (let ((newlyGrp (array/filter @doneNow (fn g (== (array/len (array/filter @entity.groupsDone (fn d (== @d @g)))) 0)))))
+        (do
+          (set @entity.pads @newPads)
+          (set @entity.currentGrp (if (== @currentGrp 9999) 0 @currentGrp))
+          (if (> (array/len @newlyGrp) 0)
+            (do
+              (set @entity.groupsDone @doneNow)
+              (emit PAD_GROUP_COMPLETED { grp: (array/first @newlyGrp) }))
+            null)
+          (if (and (== @entity.completed false) (== (array/len (array/filter @newPads (fn p (== (object/get @p lit) false)))) 0))
+            (do
+              (set @entity.completed true)
+              (emit PAD_SET_COMPLETED {}))
+            null))))))))
+
+      RESTART -> active
+        (set @entity.pads (array/map @config.pads (fn p (object/merge @p { lit: false }))))
+        (set @entity.groupsDone [])
+        (set @entity.currentGrp 0)
+        (set @entity.completed false)
+    }
+
+    emits {
+      PAD_GROUP_COMPLETED -> external {
+        grp : number!
+      }
+        @description "Every pad of one group is lit; fires once per group, in group order — later groups stay dead until the lowest uncompleted group finishes. Boards layer a small fx and unlock the next group's pads."
+        @tier "domain"
+      PAD_SET_COMPLETED -> external {
+      }
+        @description "Every pad in the set is lit; fires once per run. Boards layer the treasure fx and spill the bonus reward."
+        @tier "domain"
+    }
+
+    listens {
+      BODY_MOVED { x : number!, y : number!, vx : number!, vy : number!, grounded : boolean!, skating : boolean!, speed : number! }
+      RESTART { id : string }
+    }
+
+    config {
+      running : boolean = true
+        @label "Running"
+        @description "When true, BODY_MOVED lights touched live pads and reports group/set completion; toggle to freeze every pad as-is."
+        @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."
+        @tier "domain"
+      reachX : number = 0.7
+        @label "Reach X"
+        @description "Horizontal tolerance (world units) around a pad's center when testing player contact (approximates the body's half-width plus a step)."
+        @tier "domain"
+      reachY : number = 1.2
+        @label "Reach Y"
+        @description "Vertical tolerance (world units) around a pad's center when testing player contact (covers skating over the surface the pad sits on)."
+        @tier "domain"
+    }
+  }
+
+  page "/pad-lock" as PadLockPage -> PadLock
+}

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), 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."
+"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."
 orbital PatrolHazardOrbital {
   type Patrol = {
     id : string!
@@ -7,8 +7,12 @@ orbital PatrolHazardOrbital {
     x1 : number!
     y : number!
     speed : number!
+    waveAmp : number
+    wavePeriod : number
     x : number
     dir : number
+    t : number
+    cy : number
     touching : boolean
     hit : boolean
   }
@@ -25,7 +29,7 @@ orbital PatrolHazardOrbital {
 
     state active {
       INIT -> active
-        (set @entity.patrols (array/map @config.patrols (fn p (object/merge @p { x: (object/get @p x0), dir: 1, touching: false, hit: false }))))
+        (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.px @config.playerSpawnX)
         (set @entity.py @config.playerSpawnY)
 
@@ -34,7 +38,7 @@ orbital PatrolHazardOrbital {
         (set @entity.py @payload.y)
 
       RESTART -> active
-        (set @entity.patrols (array/map @config.patrols (fn p (object/merge @p { x: (object/get @p x0), dir: 1, touching: false, hit: false }))))
+        (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 }))))
     }
 
     ticks {
@@ -45,11 +49,14 @@ orbital PatrolHazardOrbital {
           (let ((overshoot (> @nx (object/get @p x1))) (undershoot (< @nx (object/get @p x0))))
           (let ((cx (if @overshoot (object/get @p x1) (if @undershoot (object/get @p x0) @nx)))
                 (cdir (if @overshoot -1 (if @undershoot 1 (object/get @p dir)))))
-          (let ((near (and (<= (math/abs (- @entity.px @cx)) @config.hitRadius) (<= (math/abs (- @entity.py (object/get @p y))) @config.hitRadius))))
-            (object/merge @p { x: @cx, dir: @cdir, hit: (and @near (== (object/get @p touching) false)), touching: @near }))))))))
+          (let ((nt (+ (object/get @p t) 0.033)))
+          (let ((amp (if (== (object/get @p waveAmp) null) 0 (object/get @p waveAmp))) (period (if (== (object/get @p wavePeriod) null) 3 (object/get @p wavePeriod))))
+          (let ((cy (+ (object/get @p y) (* @amp (math/sin (/ (* 6.283185307179586 @nt) @period))))))
+          (let ((near (and (<= (math/abs (- @entity.px @cx)) @config.hitRadius) (<= (math/abs (- @entity.py @cy)) @config.hitRadius))))
+            (object/merge @p { x: @cx, dir: @cdir, t: @nt, cy: @cy, hit: (and @near (== (object/get @p touching) false)), touching: @near })))))))))))
         (let ((hits (array/filter @entity.patrols (fn p (== (object/get @p hit) true)))))
         (if (> (array/len @hits) 0)
-          (emit PATROL_HIT { id: (object/get (array/first @hits) id), x: (object/get (array/first @hits) x), y: (object/get (array/first @hits) y) })
+          (emit PATROL_HIT { id: (object/get (array/first @hits) id), x: (object/get (array/first @hits) x), y: (object/get (array/first @hits) cy) })
           null))
     }
 
@@ -75,7 +82,7 @@ orbital PatrolHazardOrbital {
         @tier "domain"
       patrols : [Patrol] = []
         @label "Patrols"
-        @description "One row per patroller: id, the [x0, x1] beat it walks, its fixed y, and its speed in units/s. Current x/dir/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."
         @tier "domain"
       hitRadius : number = 0.7
         @label "Hit Radius"

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). 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, 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."
+"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."
 orbital PlatformerBodyOrbital {
   type PlatformerBody = {
     x : number!
@@ -23,12 +23,29 @@ orbital PlatformerBodyOrbital {
     x : number!
     y : number!
   }
+  type BodyDriftRegion = {
+    id : string!
+    x0 : number!
+    x1 : number!
+    y0 : number!
+    y1 : number!
+    ax : number!
+    ay : number!
+  }
+  type CurveMod = {
+    x0 : number!
+    x1 : number!
+    a : number!
+    h : number!
+    k : number!
+  }
 
   entity PlatformerBodyData [runtime, shared] {
     id : string!
     body : PlatformerBody = { x: 0, y: 0, width: 1, height: 1, vx: 0, vy: 0, grounded: false, facingRight: true }
     fell : boolean = false
     hazardId : string = ""
+    curveMods : [CurveMod] = []
     goalId : string = ""
     skating : boolean = false
   }
@@ -57,8 +74,12 @@ orbital PlatformerBodyOrbital {
         (set @entity.hazardId "")
         (set @entity.skating false)
 
+      CURVE_MOD_ADD -> active when @config.curveModsEnabled
+        (set @entity.curveMods (array/append @entity.curveMods { x0: @payload.x0, x1: @payload.x1, a: @payload.a, h: @payload.h, k: @payload.k }))
+
       RESTART -> active
         (set @entity.body @config.spawn)
+        (set @entity.curveMods [])
         (set @entity.fell false)
         (set @entity.hazardId "")
         (set @entity.goalId "")
@@ -69,7 +90,10 @@ orbital PlatformerBodyOrbital {
       physicsTick every 33ms
         when (and @config.running (> @entity.body.width 0))
         (let ((gdir (if (> @config.gravity 0) 1 -1)))
-        (let ((vy1 (math/clamp (+ @entity.body.vy (* @config.gravity 0.033)) (- 0 @config.maxFallSpeed) @config.maxFallSpeed)))
+        (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 ((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 (* (+ @config.gravity @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))))
@@ -83,15 +107,25 @@ orbital PlatformerBodyOrbital {
         (let ((rightSamp (if @inRange (array/first (array/filter @config.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 ((curveMod (if (and @config.curveModsEnabled @inRange) (array/find @entity.curveMods (fn m (and (>= @cx (object/get @m x0)) (<= @cx (object/get @m x1))))) null)))
+        (let ((modX (if (== @curveMod null) @cx (- @cx (object/get @curveMod h)))))
+        (let ((modInRange (and (!= @curveMod null) (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)))) @leftSamp)))
+        (let ((modRight (if @modInRange (array/first (array/filter @config.skateCurve (fn s (> (object/get @s x) @modX)))) @rightSamp)))
+        (let ((modSlope (if @modInRange (/ (- (object/get @modRight y) (object/get @modLeft y)) (- (object/get @modRight x) (object/get @modLeft x))) @slope)))
+        (let ((modCurveY (if @modInRange (+ (object/get @modLeft y) (* @modSlope (- @modX (object/get @modLeft x)))) @curveY)))
+        (let ((slope (if (== @curveMod null) @slope (* (object/get @curveMod a) @modSlope))))
+        (let ((curveY (if (== @curveMod null) @curveY (+ (* (object/get @curveMod a) @modCurveY) (object/get @curveMod k)))))
         (let ((movingUp (< (* @vy1 @gdir) -0.01)))
         (let ((skateNow (and @inRange (and (<= (math/abs (- @ny2 @curveY)) @config.skateSnap) (and (or @landed @entity.skating) (or @entity.body.grounded (not @movingUp)))))))
         (let ((vx2 (if @skateNow (math/clamp (+ @entity.body.vx (* (/ (* @config.gravity @slope) (+ 1 (* @slope @slope))) 0.033)) (- 0 @config.maxFallSpeed) @config.maxFallSpeed) @entity.body.vx)))
-        (let ((fy (if @skateNow @curveY @ny2)) (fvy (if @skateNow (* @slope @vx2) @vy2)) (fgrounded (or @landed @skateNow)))
+        (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 ((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 @vx2), vy: @fvy, grounded: @fgrounded }))
+            (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 }))
             (set @entity.skating @skateNow)
             (if (and @skateNow (== @entity.skating false))
               (emit BODY_SKATE_START { x: @nx, y: @fy, slope: @slope })
@@ -121,7 +155,7 @@ orbital PlatformerBodyOrbital {
                 (set @entity.fell true)
                 (emit BODY_FELL { x: @nx, y: @fy }))
               null)
-            (emit BODY_MOVED { x: @nx, y: @fy, vx: @entity.body.vx, vy: @fvy, grounded: @fgrounded, skating: @skateNow, speed: (math/hypot @entity.body.vx @fvy) }))))))))))))))))))))))))
+            (emit BODY_MOVED { x: @nx, y: @fy, vx: @entity.body.vx, vy: @fvy, grounded: @fgrounded, skating: @skateNow, speed: (math/hypot @entity.body.vx @fvy) })))))))))))))))))))))))))))))))))))))
     }
 
     emits {
@@ -188,6 +222,7 @@ orbital PlatformerBodyOrbital {
       STEER { dir : number! }
       JUMP { id : string }
       PLACE { x : number!, y : number! }
+      CURVE_MOD_ADD { x0 : number!, x1 : number!, a : number!, h : number!, k : number! }
       RESTART { id : string }
     }
 
@@ -208,6 +243,10 @@ orbital PlatformerBodyOrbital {
         @label "Gravity"
         @description "Units/s² added to vertical velocity; the SIGN is the vertical convention — positive pulls toward +y (screen boards, y down), negative toward −y (math canvases, y up) — and jumps always fire against it"
         @tier "domain"
+      curveModsEnabled : boolean = false
+        @label "Curve Mods Enabled"
+        @description "When true, entity.curveMods reshape the skate surface inside each mod's x-range: the road samples the base curve at (x − h) and applies a·y + k (slope scales by a) — coefficient pads lift/tilt the segment the player is riding. Default off: boards without coef pads pay nothing."
+        @tier "domain"
       jumpStrength : number = 11
         @label "Jump Strength"
         @description "Vertical speed in units/s imparted by JUMP, directed against gravity; apex height ≈ jumpStrength² / (2·|gravity|)"
@@ -244,6 +283,10 @@ orbital PlatformerBodyOrbital {
         @label "Skate Snap"
         @description "Max vertical gap (world units) between the body's min corner and the curve surface for skating to engage or stay engaged; larger values grab earlier on landing, smaller values release sooner on bumps"
         @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."
+        @tier "domain"
     }
   }
 

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

@@ -0,0 +1,101 @@
+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)."
+orbital VelocityGateOrbital {
+  type VelocityGate = {
+    id : string!
+    x : number!
+    y : number!
+    width : number!
+    height : number!
+    minSpeed : number!
+    maxSpeed : number!
+    dwellMs : number!
+    dir : number!
+    hint : string
+    open : boolean
+    touching : boolean
+    denied : boolean
+    held : number
+    reported : boolean
+  }
+
+  entity VelocityGateData [runtime, shared] {
+    id : string!
+    gates : [VelocityGate] = []
+  }
+
+  trait VelocityGate -> @rebindable VelocityGateData [lifecycle] {
+    initial: active
+
+    state active {
+      INIT -> active
+        (set @entity.gates (array/map @config.gates (fn g (object/merge @g { open: false, touching: false, denied: false, held: 0, reported: false }))))
+
+      BODY_MOVED -> active when @config.running
+        (set @entity.gates (array/map @entity.gates (fn g
+          (let ((inside (and (== (object/get @g open) false)
+                             (and (>= @payload.x (- (object/get @g x) @config.reachMargin))
+                                  (and (<= @payload.x (+ (object/get @g x) (object/get @g width) @config.reachMargin))
+                                       (and (>= @payload.y (- (object/get @g y) @config.reachMargin))
+                                            (<= @payload.y (+ (object/get @g y) (object/get @g height) @config.reachMargin))))))))
+          (let ((dirOk (or (== (object/get @g dir) 0) (== (math/sign @payload.vx) (object/get @g dir)))))
+          (let ((pass (and @inside (and (>= @payload.speed (object/get @g minSpeed)) (and (<= @payload.speed (object/get @g maxSpeed)) @dirOk)))))
+          (let ((held (if @pass (+ (object/get @g held) 33) 0)))
+          (let ((openNow (or (object/get @g open) (if (> (object/get @g dwellMs) 0) (>= @held (object/get @g dwellMs)) @pass))))
+            (object/merge @g { touching: @inside, held: @held, open: @openNow, denied: (and (== (object/get @g dwellMs) 0) (and @inside (and (== @pass false) (== (object/get @g touching) false)))) })))))))))
+        (let ((newly (array/filter @entity.gates (fn g (and (== (object/get @g open) true) (== (object/get @g reported) false))))))
+        (if (> (array/len @newly) 0)
+          (do
+            (set @entity.gates (array/map @entity.gates (fn g (if (== (object/get @g id) (object/get (array/first @newly) id)) (object/merge @g { reported: true }) @g))))
+            (emit VELOCITY_GATE_OPENED { id: (object/get (array/first @newly) id), x: (object/get (array/first @newly) x), y: (object/get (array/first @newly) y) }))
+          null))
+        (let ((denied (array/filter @entity.gates (fn g (== (object/get @g denied) true)))))
+        (if (> (array/len @denied) 0)
+          (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))
+
+      RESTART -> active
+        (set @entity.gates (array/map @config.gates (fn g (object/merge @g { open: false, touching: false, denied: false, held: 0, reported: false }))))
+    }
+
+    emits {
+      VELOCITY_GATE_OPENED -> external {
+        id : string!
+        x : number!
+        y : number!
+      }
+        @description "A gate's speed band was satisfied (instantly, or held for its dwell) and it flipped open; boards layer treasure fx and rewards. When several gates open on one move, the first reports and the shared entity carries the rest."
+        @tier "domain"
+      VELOCITY_GATE_DENIED -> external {
+        id : string!
+        x : number!
+        y : number!
+        speed : number!
+      }
+        @description "The player entered a closed gate outside its speed band or against its direction; fires once per approach and re-arms after they step out. Boards answer with a PLACE back plus a hint fx."
+        @tier "domain"
+    }
+
+    listens {
+      BODY_MOVED { x : number!, y : number!, vx : number!, vy : number!, grounded : boolean!, skating : boolean!, speed : number! }
+      RESTART { id : string }
+    }
+
+    config {
+      running : boolean = true
+        @label "Running"
+        @description "When true, BODY_MOVED tests every gate's band and opens/denies; toggle to freeze every gate as-is."
+        @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."
+        @tier "domain"
+      reachMargin : number = 0.6
+        @label "Reach Margin"
+        @description "Extra world units padded around a closed gate's rect when testing player contact (approximates the body's size)."
+        @tier "domain"
+    }
+  }
+
+  page "/velocity-gate" as VelocityGatePage -> VelocityGate
+}

package/behaviors/lolo/ui/game/atoms/std-zone-card.lolo

@@ -0,0 +1,95 @@
+app std-zone-card "1.0.0"
+"Headless zone-guidance mechanic for side-view boards: tracks which band of the world the player is in and holds up that zone's 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)."
+orbital ZoneCardOrbital {
+  type ZoneCard = {
+    name : string!
+    concept : string
+    objective : string
+  }
+  type ZoneCardZone = {
+    id : string!
+    name : string!
+    concept : string
+    objective : string
+    x0 : number!
+    x1 : number!
+  }
+
+  entity ZoneCardData [runtime, shared] {
+    id : string!
+    zoneId : string = ""
+    card : ZoneCard
+    enteredAt : number = 0
+    ticks : number = 0
+  }
+
+  trait ZoneCard -> @rebindable ZoneCardData [lifecycle] {
+    initial: active
+
+    state active {
+      INIT -> active
+        (set @entity.zoneId "")
+        (set @entity.card null)
+        (set @entity.enteredAt 0)
+        (set @entity.ticks 0)
+
+      BODY_MOVED -> active when @config.running
+        (set @entity.ticks (+ @entity.ticks 1))
+        (let ((zmatch (array/filter @config.zones (fn z (and (>= @payload.x (object/get @z x0)) (< @payload.x (object/get @z x1)))))))
+        (do
+          (if (and (> (array/len @zmatch) 0) (!= @entity.zoneId (object/get (array/first @zmatch) id)))
+            (do
+              (set @entity.zoneId (object/get (array/first @zmatch) id))
+              (set @entity.card { name: (object/get (array/first @zmatch) name), concept: (object/get (array/first @zmatch) concept), objective: (object/get (array/first @zmatch) objective) })
+              (set @entity.enteredAt @entity.ticks)
+              (emit ZONE_CHANGED { id: (object/get (array/first @zmatch) id), name: (object/get (array/first @zmatch) name), concept: (object/get (array/first @zmatch) concept), objective: (object/get (array/first @zmatch) objective) }))
+            null)
+          (if (and (!= @entity.card null) (> (- @entity.ticks @entity.enteredAt) @config.ttlTicks))
+            (set @entity.card null)
+            null)))
+
+      CARD_DISMISS -> active
+        (set @entity.card null)
+
+      RESTART -> active
+        (set @entity.zoneId "")
+        (set @entity.card null)
+        (set @entity.enteredAt 0)
+        (set @entity.ticks 0)
+    }
+
+    emits {
+      ZONE_CHANGED -> external {
+        id : string!
+        name : string!
+        concept : string
+        objective : string
+      }
+        @description "The player crossed into a different zone; carries the zone's card fields (name, concept, objective) so boards can swap banners/guides and hold the card up. Fires once per crossing."
+        @tier "domain"
+    }
+
+    listens {
+      BODY_MOVED { x : number!, y : number!, vx : number!, vy : number!, grounded : boolean!, skating : boolean!, speed : number! }
+      CARD_DISMISS { id : string }
+      RESTART { id : string }
+    }
+
+    config {
+      running : boolean = true
+        @label "Running"
+        @description "When true, BODY_MOVED tracks the current zone and ages the card; toggle to freeze the card as-is."
+        @tier "domain"
+      zones : [ZoneCardZone] = []
+        @label "Zones"
+        @description "One row per world band: id, display name, the one-line concept, the zone's objective text, and the x-range (x0..x1) the band covers."
+        @tier "domain"
+      ttlTicks : number = 120
+        @label "TTL Ticks"
+        @description "BODY_MOVED ticks the card stays up after a zone crossing (≈ 4s at 30 moves/s) before it clears itself."
+        @tier "domain"
+    }
+  }
+
+  page "/zone-card" as ZoneCardPage -> ZoneCard
+}

package/behaviors/lolo/ui/game/organisms/std-platformer-board-2d.lolo

@@ -79,6 +79,14 @@ orbital PlatformerBoard2DOrbital {
     right : Asset
   }
 
+  type BoardCurveMod = {
+    x0 : number!
+    x1 : number!
+    a : number!
+    h : number!
+    k : number!
+  }
+
   entity GameState [runtime, shared] {
     id : string!
     body : PlatformerBody = { x: 80, y: 320, width: 32, height: 48, vx: 0, vy: 0, grounded: false, facingRight: true }
@@ -86,6 +94,7 @@ orbital PlatformerBoard2DOrbital {
     hazardId : string = ""
     goalId : string = ""
     skating : boolean = false
+    curveMods : [BoardCurveMod] = []
     fx : [Fx] = []
     result : string = "none"
     score : number = 0