oriverse-engine 0.1.1

package/dist/GAME_AUTHORING.md

@@ -0,0 +1,512 @@
+# Oriverse game authoring guide (artifact / CDN build)
+
+How to write a complete small game in Weave for the Oriverse artifact engine.
+Everything here works offline and fully procedurally — no market assets, no network.
+Three complete, engine-tested example games are at the end; pattern-match from them.
+The full language/API reference is `weave_documentation.txt` (same folder/URL as this file).
+
+## 1. The shape of a game
+
+A game is ONE block of Weave text (the "world description") placed inside the
+`<script type="text/weave" id="oriverse-weave">` tag of your `game.html`. It has two layers:
+
+```text
+#class SomeClass          <- class code: events + functions (one block per class)
+    ...weave statements...
+#end
+#texture SomeTexture      <- optional procedural texture DSL
+#end
+#mesh SomeMesh            <- optional procedural mesh DSL
+#end
+
+saved thing { ... }       <- spawnable-later object templates
+object Floor { ... }      <- scene objects placed at boot
+display hint { ... }      <- visual-only object (no collision/interaction)
+physics crate { ... }     <- dynamic (gravity) object
+region goal { ... }       <- invisible overlap-test volume
+screenCanvas HUD { ... }  <- 2D screen-space UI
+```
+
+The engine boots straight into play mode. A player spawns at `Origin()` (0,0,0) with a
+third-person camera. If you do NOT define `#class player`, a default controller is
+injected: WASD camera-relative movement + Space jump. Define `#class player ... #end`
+only to customize movement/camera/abilities.
+
+## 2. World description basics
+
+- Units: 1 unit = 1 cm. Z is up. A tile is 100x100 cm. The player is 180 cm tall, 40 wide.
+- Primitive models: `"cube"`, `"sphere"`, `"cylinder"`, `"capsule"`, `"cone"`, `"wedge"`.
+  Base cube is 100x100x100; sphere is 100 diameter.
+- `position = (x, y, z)` for mesh-backed objects is the BOTTOM-CENTER pivot (an object at
+  z=0 stands on the ground plane). `size = (x, y, z)` stretches; scalar `size = 80` is uniform.
+- For axis-aligned walls/floors prefer exact corners:
+  `object NorthWall { model="cube" bounds_min=(-1500,1100,0) bounds_max=(1500,1180,280) }`
+- `color = (r, g, b)` channels are 0-1 floats (or `#RRGGBB`). FOOTGUN: 0-255 style values
+  clamp every channel to 1 and render untinted white.
+- Attach a class with `:` — `object Tower : TowerClass { ... }`. Override class variables
+  from the scene: `object boss : Enemy { override MaxHP = 500 }` (Number/Bool/Vector only).
+- Tags need no declaration: `tag = Tag.Coin` in a clause, `AddTag(Tag.Coin)` in code.
+- Object kinds: `object` (static, collides), `physics` (dynamic, falls), `display`
+  (visual-only: no collision, no Touched/Click events), `crowd` (NPC with avoidance),
+  `region` (invisible overlap volume), `saved` (template for runtime spawning).
+- A hidden "manager" object is the standard place for game state and loops:
+
+```text
+display manager : GameManager { visible = false }
+```
+
+## 3. Class code: events, loops, timers
+
+```text
+#class GameManager
+var Score = 0                 // class variables persist; readable/writable cross-object
+event OnPreSpawn {            // runs before OnSpawned; put AddTag(...) here
+    AddTag(Tag.Manager)
+}
+event OnSpawned {             // main entry; runs once when the object spawns
+    var tmr = Timer()         // Timer starts in the Done state
+    forever {                 // once per frame (implicit WaitNextFrame between iterations)
+        if tmr.IsDone() {
+            tmr.StartCountDown(0.5)
+            // ... do something every 0.5 s ...
+        }
+    }
+}
+event KeyboardDown[R] {       // any player pressed R (use ...ByThisPlayer only in #class player)
+    RestartGame()
+}
+#end
+```
+
+- `forever { ... }` = per-frame loop; `Wait(seconds)` sleeps inside event code;
+  `continue` skips to the next frame inside `forever`.
+- At most ONE continuous move and ONE continuous rotate stick per object per frame
+  (`Move*Continuously`, `RotateToward*` — the last call wins). Teleports win over moves.
+- `GetPosition()` returns the transform from the START of the current frame.
+- Cross-object access works on variables and functions: `other.Score += 1`, `other.Pop()`.
+- Text concat: `"Score: " + Score`. Random: `RandomNumber(from, to)` (deterministic per tick).
+- Debug: `Print("...")` to console, `Say("...")` as a speech bubble,
+  `SpawnFloatingText("+1", Vector(0,1,0))` for damage/pickup popups.
+
+## 4. The player class
+
+Default (injected when you don't write one):
+
+```text
+#class player
+event OnSpawned {
+    forever {
+        var Direction = GetPlayerInputDirectionCamera(Key.W, Key.S, Key.A, Key.D)
+        MoveInDirectionContinuouslyFacing(Direction, 900)
+    }
+}
+event KeyboardDownByThisPlayer[Space] {
+    if IsOnGround() {
+        Jump(1000)
+    }
+}
+#end
+```
+
+Customization patterns (all inside `#class player`):
+
+- Speed/feel: change `900` (cm/s); prefer `GetMoveVectorCamera()` for gameplay movement
+  (it also handles mobile thumbsticks). `Jump(1400)` for a higher jump.
+- Actions: `event ActionDownByThisPlayer[Primary]` (left click / tap), `[Secondary]`,
+  `[Interact]` (E), `[Jump]`. `IsActionPressedByThisPlayer(Action.Primary)` for held state.
+- Aim at the crosshair: `GetMouseTargetObjectWithTag(Tag.Target)` returns the object under
+  the crosshair (or `None` — always check `.Exists()`).
+- Dash (compose motion yourself; last continuous call in a frame wins):
+
+```text
+var DashTmr : Timer
+event KeyboardDownByThisPlayer[LeftShift] {
+    DashTmr.StartCountDown(0.15)
+}
+event OnSpawned {
+    forever {
+        var dir = GetMoveVectorCamera()
+        if not DashTmr.IsDone() {
+            MoveInDirectionContinuouslyFacing(dir, 2800)
+        } else {
+            MoveInDirectionContinuouslyFacing(dir, 900)
+        }
+    }
+}
+```
+
+- IMPORTANT: `#class player` is auto-attached to every player. Never declare a player
+  `object` in the scene, and never spawn one.
+
+## 5. Spawning and despawning at runtime
+
+Declare a template with `saved`, then spawn instances from code:
+
+```text
+saved coin {
+    display coin : Coin { model = "cylinder" size = (60, 60, 12) color = (1, 0.85, 0.2) }
+}
+```
+
+- `SpawnObject(SavedObject.coin, Position(x, y, z))` -> returns the new Object.
+- `Destroy()` removes the calling object (or `other.Destroy()`).
+- Census by tag: `GetAllObjectsWithTag(Tag.Coin).Count()`, `NearestObjectWithTag(Tag.X)`,
+  `DestroyObjectsWithTag(Tag.X)`.
+- A `saved` clause must contain exactly one root object (or one root group).
+
+## 6. Collision and proximity interactions
+
+Two robust patterns (see the frame model in the docs for exact timing):
+
+1. Proximity poll (best for pickups/damage auras; works with `display` objects too):
+
+```text
+forever {
+    var p = NearestPlayer()
+    if p.Exists() and SurfaceGapTo(p) < 70 {
+        p.SpawnFloatingText("+1", Vector(1, 0.9, 0.2))
+        Destroy()
+    }
+}
+```
+
+2. Contact events on colliding objects (`object`/`physics`, NOT `display`):
+
+```text
+event Touched {
+    if Event.TouchedObject.IsPlayer() { ... }
+}
+```
+
+Regions fire `event EnterRegion` / `ExitRegion` with `Event.TouchedObject` — use a
+`region` for goal areas, kill floors below the map, checkpoints.
+
+## 7. Score and UI text
+
+Declare a screen canvas in the world description, then update labels from code:
+
+```text
+screenCanvas HUD {
+    textLabel ScoreText { offset = (20, 20) text = "Score: 0" color = (1, 1, 0.85) }
+    textLabel MidText { align = (center, center) text = "" color = (1, 1, 0.3) }
+}
+```
+
+- UI base units assume a 1600x900 window and scale with resize.
+- From code: `ResolveObjectByNameOnce("ScoreText").SetText("Score: " + Score)` — resolve
+  once into a var outside the `forever` loop, then call `SetText` on it.
+- A centered label with empty text doubles as the win/lose banner.
+- For panels/menus prefer auto-layout containers (`vStack`/`hStack`/`grid`); every direct
+  child of a stack needs an explicit `size`. See the `<ui>` docs section.
+
+## 8. Win / lose / restart
+
+The manager pattern (used by all three examples):
+
+- Keep `var GameOver = false` (or `RoundOver`) on the tagged manager.
+- Losing conditions write it cross-object: `NearestObjectWithTag(Tag.Manager).GameOver = true`.
+- The manager's `forever` loop shows the banner and freezes scoring when set.
+- `event KeyboardDown[R] { RestartGame() }` reloads the whole world (fresh state).
+
+## 9. Procedural textures and meshes (quickstarts)
+
+`#texture` defines a material usable as `material = "Name"` on any object (verbatim
+docs example; see `<texture_dsl_examples>` in the docs for concrete/wood/metal/brick):
+
+```text
+#texture StylizedGrass
+tile_m = 3.0;
+wrap = repeat;
+let n = noise.fbm(uv * 4.0, octaves: 4, seed: 5, period: 4);
+out.color = ramp(n, [0.0: vec3(0.337, 0.376, 0.165), 1.0: vec3(0.408, 0.459, 0.212)]);
+out.orm = orm(occlusion: 0.8, roughness: 0.55, metallic: 0.0);
+#end
+object Ground { model = "cube" bounds_min = (-2000, -2000, -100) bounds_max = (2000, 2000, 0) material = "StylizedGrass" }
+```
+
+`#mesh` defines a static model usable as `model = "mesh.Name"`:
+
+```text
+#mesh Rock
+let base = scale(sphere(r: 90, segments: 10, material: "Stone"), (1.4, 0.85, 0.55));
+out.geo = displace(base, amount: 18, seed: 4);
+#end
+object RockA { model = "mesh.Rock" position = (300, 400, 0) }
+```
+
+Mesh DSL statements end with `;` and use `let`; pair material slots with a flat
+`#texture Stone color=#8B8B84` for quick color-blocking. Full generator list is in the
+`<mesh_dsl_usage>` docs section.
+
+## 10. Footguns (each one has burned an AI before)
+
+- Colors are 0-1 floats. `color = (255, 200, 50)` renders WHITE, silently.
+- Everything must be procedural. `Ori.model.*` / market URLs hard-error in this build.
+- `display` objects never get `Touched`/`ClickThisObject` events and don't collide.
+  Use the proximity-poll pattern, or use `object`/`physics`/`region` kinds.
+- One continuous move per object per frame; the last call wins. Compose speeds yourself
+  (see the dash pattern) instead of calling `Move*` twice.
+- `None` is only valid for Object variables; always guard with `.Exists()` before use.
+- `KeyboardDownByThisPlayer` / `ActionDownByThisPlayer` / `IsKeyPressedByThisPlayer` /
+  `GetMoveVectorCamera` belong in `#class player` only; plain `KeyboardDown[..]` fires
+  for ANY player and belongs in manager-style classes.
+- `for i in 0..8` excludes 8. Statements can share a line with `;`.
+- Don't declare or spawn player objects; `#class player` auto-attaches to each player.
+- Class-level `var T : Timer` declares a timer field; local `var t = Timer()` also works.
+  New timers start Done — call `StartCountDown(s)` to arm.
+- Don't rely on cross-object `OnSpawned` ordering; it is unspecified.
+
+## 11. Complete example games (engine-tested)
+
+Each example below ships as a `.weave` file in `examples/` (same folder/URL as this
+file), is compiled and run by the engine's native test suite on every build, and is
+kept under ~100 lines. To play one: replace the contents of the `#oriverse-weave`
+script tag in `game.html` with the example source.
+
+### 11a. Coin Collector (`examples/coin_collector.weave`)
+
+Collect 10 spinning coins; HUD counter; win banner + R to restart. Demonstrates: saved
+objects + runtime spawning, tags, proximity pickup, default player controller.
+
+```text
+// Coin Collector — walk into the 10 spinning coins to collect them all. Press R to replay.
+// Demonstrates: saved objects + runtime spawning, tags, proximity pickup, HUD score text,
+// win + restart flow. Movement uses the engine's default player controller (no #class player).
+
+#class Coin
+event OnPreSpawn {
+    AddTag(Tag.Coin)
+}
+event OnSpawned {
+    forever {
+        RotateLeftInstantly(4)
+        var p = NearestPlayer()
+        if p.Exists() and SurfaceGapTo(p) < 70 {
+            p.SpawnFloatingText("+1", Vector(1, 0.9, 0.2))
+            Destroy()
+        }
+    }
+}
+#end
+
+#class GameManager
+var TotalCoins = 10
+var SeenCoins = false
+event OnSpawned {
+    for i in 0..TotalCoins {
+        var pos = Position(RandomNumber(-1400, 1400), RandomNumber(-1400, 1400), 80)
+        SpawnObject(SavedObject.coin, pos)
+    }
+    var scoreLabel = ResolveObjectByNameOnce("ScoreText")
+    var midLabel = ResolveObjectByNameOnce("MidText")
+    forever {
+        // Spawned coins register their tag on the next tick, so wait until the census
+        // has seen at least one coin before treating "0 left" as a win.
+        var left = GetAllObjectsWithTag(Tag.Coin).Count()
+        var collected = TotalCoins - left
+        scoreLabel.SetText("Coins: " + collected + " / " + TotalCoins)
+        if left == 0 and collected == TotalCoins and SeenCoins {
+            midLabel.SetText("YOU WIN!  Press R to play again")
+        } else {
+            midLabel.SetText("")
+        }
+        if left > 0 {
+            SeenCoins = true
+        }
+    }
+}
+event KeyboardDown[R] {
+    RestartGame()
+}
+#end
+
+saved coin {
+    display coin : Coin { model = "cylinder" size = (60, 60, 12) rotation = (90, 0, 0) color = (1, 0.85, 0.2) }
+}
+
+object Ground {
+    model = "cube"
+    position = (0, 0, -50)
+    size = (4000, 4000, 100)
+    color = (0.32, 0.5, 0.34)
+}
+object PillarA { position = (400, 400, 150) size = (100, 100, 300) color = (0.62, 0.58, 0.52) }
+object PillarB { position = (-600, 300, 150) size = (100, 100, 300) color = (0.62, 0.58, 0.52) }
+object PillarC { position = (200, -700, 150) size = (100, 100, 300) color = (0.62, 0.58, 0.52) }
+display manager : GameManager { visible = false }
+
+screenCanvas HUD {
+    textLabel ScoreText { offset = (20, 20) text = "Coins: 0 / 10" color = (1, 1, 0.85) }
+    textLabel MidText { align = (center, center) text = "" color = (1, 1, 0.3) }
+}
+```
+
+### 11b. Dodge the Falling Blocks (`examples/dodge_blocks.weave`)
+
+Red physics cubes rain down; touching one ends the run; survival-seconds score.
+Demonstrates: timed spawner, dynamic physics objects, cross-object state writes,
+lose + restart flow.
+
+```text
+// Dodge the Falling Blocks — red cubes rain down; touching one ends the run. Press R to retry.
+// Demonstrates: a hidden manager object, timed spawning with Timer, dynamic physics objects,
+// cross-object variable writes (block -> manager), survival-seconds score, lose + restart flow.
+// Movement uses the engine's default player controller (no #class player).
+
+#class FallingBlock
+var LifeTmr : Timer
+event OnSpawned {
+    LifeTmr.StartCountDown(8) // despawn landed blocks so the arena stays playable
+    forever {
+        if LifeTmr.IsDone() {
+            Destroy()
+        }
+        var p = NearestPlayer()
+        if p.Exists() and SurfaceGapTo(p) < 5 {
+            NearestObjectWithTag(Tag.Manager).GameOver = true
+        }
+    }
+}
+#end
+
+#class GameManager
+var GameOver = false
+var Score = 0
+event OnPreSpawn {
+    AddTag(Tag.Manager)
+}
+event OnSpawned {
+    var secondTmr = Timer()
+    var dropTmr = Timer()
+    var scoreLabel = ResolveObjectByNameOnce("ScoreText")
+    var midLabel = ResolveObjectByNameOnce("MidText")
+    forever {
+        if GameOver {
+            midLabel.SetText("GAME OVER — survived " + Score + " s. Press R to retry")
+            continue
+        }
+        if secondTmr.IsDone() {
+            secondTmr.StartCountDown(1)
+            Score += 1
+            scoreLabel.SetText("Survived: " + Score + " s")
+        }
+        if dropTmr.IsDone() {
+            dropTmr.StartCountDown(0.35)
+            var pos = Position(RandomNumber(-900, 900), RandomNumber(-900, 900), 1300)
+            SpawnObject(SavedObject.block, pos)
+        }
+    }
+}
+event KeyboardDown[R] {
+    RestartGame()
+}
+#end
+
+saved block {
+    physics block : FallingBlock { model = "cube" size = (120, 120, 120) color = (0.85, 0.25, 0.2) }
+}
+
+object Ground {
+    model = "cube"
+    position = (0, 0, -50)
+    size = (2200, 2200, 100)
+    color = (0.4, 0.42, 0.5)
+}
+display manager : GameManager { visible = false }
+
+screenCanvas HUD {
+    textLabel ScoreText { offset = (20, 20) text = "Survived: 0 s" color = (1, 1, 1) }
+    textLabel MidText { align = (center, center) text = "" color = (1, 0.45, 0.35) }
+}
+```
+
+### 11c. Target Range (`examples/target_range.weave`)
+
+Click the floating spheres through the crosshair; 30-second round. Demonstrates: custom
+`#class player` (movement + jump + shooting), crosshair ray queries, user-defined funcs
+called cross-object, TeleportTo respawn, countdown timer.
+
+```text
+// Target Range — aim at the floating spheres and left-click to score. 30-second round, R restarts.
+// Demonstrates: a custom #class player (movement + jump + click-to-shoot with the crosshair ray),
+// user-defined funcs called cross-object, TeleportTo respawn, countdown round timer, HUD score.
+
+#class player
+event OnSpawned {
+    forever {
+        var dir = GetMoveVectorCamera()
+        MoveInDirectionContinuouslyFacing(dir, 900)
+    }
+}
+event KeyboardDownByThisPlayer[Space] {
+    if IsOnGround() {
+        Jump(1000)
+    }
+}
+event ActionDownByThisPlayer[Primary] {
+    var t = GetMouseTargetObjectWithTag(Tag.Target)
+    if t.Exists() and not NearestObjectWithTag(Tag.Manager).RoundOver {
+        t.Pop()
+    }
+}
+#end
+
+#class Target
+func Pop() {
+    SpawnFloatingText("+1", Vector(0.3, 1, 0.4))
+    NearestObjectWithTag(Tag.Manager).Hits += 1
+    TeleportTo(Position(RandomNumber(-1200, 1200), RandomNumber(500, 1600), RandomNumber(100, 500)))
+}
+event OnPreSpawn {
+    AddTag(Tag.Target)
+}
+#end
+
+#class GameManager
+var Hits = 0
+var TimeLeft = 30
+var RoundOver = false
+event OnPreSpawn {
+    AddTag(Tag.Manager)
+}
+event OnSpawned {
+    var secondTmr = Timer()
+    secondTmr.StartCountDown(1)
+    var scoreLabel = ResolveObjectByNameOnce("ScoreText")
+    var midLabel = ResolveObjectByNameOnce("MidText")
+    forever {
+        scoreLabel.SetText("Hits: " + Hits + "   Time: " + TimeLeft)
+        if RoundOver {
+            continue
+        }
+        if secondTmr.IsDone() {
+            secondTmr.StartCountDown(1)
+            TimeLeft -= 1
+            if TimeLeft <= 0 {
+                RoundOver = true
+                midLabel.SetText("TIME!  Final score: " + Hits + " — press R to retry")
+            }
+        }
+    }
+}
+event KeyboardDown[R] {
+    RestartGame()
+}
+#end
+
+object Ground {
+    model = "cube"
+    position = (0, 0, -50)
+    size = (4000, 4000, 100)
+    color = (0.45, 0.4, 0.35)
+}
+object TargetA : Target { model = "sphere" position = (-600, 900, 250) size = 90 color = (1, 0.3, 0.3) }
+object TargetB : Target { model = "sphere" position = (0, 1200, 350) size = 90 color = (1, 0.3, 0.3) }
+object TargetC : Target { model = "sphere" position = (700, 800, 200) size = 90 color = (1, 0.3, 0.3) }
+display manager : GameManager { visible = false }
+
+screenCanvas HUD {
+    textLabel ScoreText { offset = (20, 20) text = "Hits: 0   Time: 30" color = (1, 1, 0.85) }
+    textLabel MidText { align = (center, center) text = "" color = (0.4, 1, 0.5) }
+}
+```

package/dist/examples/coin_collector.weave

@@ -0,0 +1,70 @@
+// Coin Collector — walk into the 10 spinning coins to collect them all. Press R to replay.
+// Demonstrates: saved objects + runtime spawning, tags, proximity pickup, HUD score text,
+// win + restart flow. Movement uses the engine's default player controller (no #class player).
+
+#class Coin
+event OnPreSpawn {
+    AddTag(Tag.Coin)
+}
+event OnSpawned {
+    forever {
+        RotateLeftInstantly(4)
+        var p = NearestPlayer()
+        if p.Exists() and SurfaceGapTo(p) < 70 {
+            p.SpawnFloatingText("+1", Vector(1, 0.9, 0.2))
+            Destroy()
+        }
+    }
+}
+#end
+
+#class GameManager
+var TotalCoins = 10
+var SeenCoins = false
+event OnSpawned {
+    for i in 0..TotalCoins {
+        var pos = Position(RandomNumber(-1400, 1400), RandomNumber(-1400, 1400), 80)
+        SpawnObject(SavedObject.coin, pos)
+    }
+    var scoreLabel = ResolveObjectByNameOnce("ScoreText")
+    var midLabel = ResolveObjectByNameOnce("MidText")
+    forever {
+        // Spawned coins register their tag on the next tick, so wait until the census
+        // has seen at least one coin before treating "0 left" as a win.
+        var left = GetAllObjectsWithTag(Tag.Coin).Count()
+        var collected = TotalCoins - left
+        scoreLabel.SetText("Coins: " + collected + " / " + TotalCoins)
+        if left == 0 and collected == TotalCoins and SeenCoins {
+            midLabel.SetText("YOU WIN!  Press R to play again")
+        } else {
+            midLabel.SetText("")
+        }
+        if left > 0 {
+            SeenCoins = true
+        }
+    }
+}
+event KeyboardDown[R] {
+    RestartGame()
+}
+#end
+
+saved coin {
+    display coin : Coin { model = "cylinder" size = (60, 60, 12) rotation = (90, 0, 0) color = (1, 0.85, 0.2) }
+}
+
+object Ground {
+    model = "cube"
+    position = (0, 0, -50)
+    size = (4000, 4000, 100)
+    color = (0.32, 0.5, 0.34)
+}
+object PillarA { position = (400, 400, 150) size = (100, 100, 300) color = (0.62, 0.58, 0.52) }
+object PillarB { position = (-600, 300, 150) size = (100, 100, 300) color = (0.62, 0.58, 0.52) }
+object PillarC { position = (200, -700, 150) size = (100, 100, 300) color = (0.62, 0.58, 0.52) }
+display manager : GameManager { visible = false }
+
+screenCanvas HUD {
+    textLabel ScoreText { offset = (20, 20) text = "Coins: 0 / 10" color = (1, 1, 0.85) }
+    textLabel MidText { align = (center, center) text = "" color = (1, 1, 0.3) }
+}

package/dist/examples/dodge_blocks.weave

@@ -0,0 +1,70 @@
+// Dodge the Falling Blocks — red cubes rain down; touching one ends the run. Press R to retry.
+// Demonstrates: a hidden manager object, timed spawning with Timer, dynamic physics objects,
+// cross-object variable writes (block -> manager), survival-seconds score, lose + restart flow.
+// Movement uses the engine's default player controller (no #class player).
+
+#class FallingBlock
+var LifeTmr : Timer
+event OnSpawned {
+    LifeTmr.StartCountDown(8) // despawn landed blocks so the arena stays playable
+    forever {
+        if LifeTmr.IsDone() {
+            Destroy()
+        }
+        var p = NearestPlayer()
+        if p.Exists() and SurfaceGapTo(p) < 5 {
+            NearestObjectWithTag(Tag.Manager).GameOver = true
+        }
+    }
+}
+#end
+
+#class GameManager
+var GameOver = false
+var Score = 0
+event OnPreSpawn {
+    AddTag(Tag.Manager)
+}
+event OnSpawned {
+    var secondTmr = Timer()
+    var dropTmr = Timer()
+    var scoreLabel = ResolveObjectByNameOnce("ScoreText")
+    var midLabel = ResolveObjectByNameOnce("MidText")
+    forever {
+        if GameOver {
+            midLabel.SetText("GAME OVER — survived " + Score + " s. Press R to retry")
+            continue
+        }
+        if secondTmr.IsDone() {
+            secondTmr.StartCountDown(1)
+            Score += 1
+            scoreLabel.SetText("Survived: " + Score + " s")
+        }
+        if dropTmr.IsDone() {
+            dropTmr.StartCountDown(0.35)
+            var pos = Position(RandomNumber(-900, 900), RandomNumber(-900, 900), 1300)
+            SpawnObject(SavedObject.block, pos)
+        }
+    }
+}
+event KeyboardDown[R] {
+    RestartGame()
+}
+#end
+
+saved block {
+    physics block : FallingBlock { model = "cube" size = (120, 120, 120) color = (0.85, 0.25, 0.2) }
+}
+
+object Ground {
+    model = "cube"
+    position = (0, 0, -50)
+    size = (2200, 2200, 100)
+    color = (0.4, 0.42, 0.5)
+}
+display manager : GameManager { visible = false }
+
+screenCanvas HUD {
+    textLabel ScoreText { offset = (20, 20) text = "Survived: 0 s" color = (1, 1, 1) }
+    textLabel MidText { align = (center, center) text = "" color = (1, 0.45, 0.35) }
+}