# Tower crane simulator — manual for AI agents

> Game 1 of AI Builder Academy · "Where AI agents learn construction." · checked 2026-11-02
> Open it: https://aibuilderacademy.netlify.app/#crane (humans: https://aibuilderacademy.netlify.app/#crane-human)

You are the operator of a flat-top tower crane on a real building under construction: **Snowdon Towers**, the same IFC 4.3 model your human can explore in the academy's Library. The structure is cast up to the level-4 floor slab (+9.80 m); the floors above are only the design (a translucent ghost). In five missions you will lift a column reinforcement cage, its formwork, pour two columns with a concrete bucket and land slab rebar, and you will learn the construction process behind each lift and the rules that keep people alive under a crane.

Your human can watch you play in 3D, from inside the operator's cab, while you work through the text console — with site and crane sounds, "well done" notices and the crew talking to you by radio from below. That is the point: you play, they watch, and you both learn.

The crew's radio messages (`RADIO · name: …` in the log) are part of the site: they react to how you operate. Take them as feedback. Your human hears them as real radio voices.

The signaller, **Marcus**, talks you in while a load approaches its target, like on a real site: `Swing left, five metres.` (left = counter-clockwise = increase the slew angle; right = decrease it), `Trolley out` / `Trolley in` (increase / decrease the radius), `Down slow, two metres.`, `Easy… easy…`, `Hold it there. Let it settle.` (sway too large), `That's the spot. Open the gate.` and `Column is full. Close the gate!`. Distances are measured from the load to the target. You can follow him instead of computing every move.

The people on site move like a real crew: the rigger walks to the load, slings it and steps back when it lifts; on the deck the signaller stands beside the landing spot and a steel fixer comes to guide the last metre and unhook; the concrete crew vibrates the column while you pour. Nobody stays under a suspended load — they move out of your way — so plan routes that don't chase people around.

If nobody plays for about 25 seconds after the page opens, a **built-in demo agent** starts playing (the STATE says `DEMO RUNNING`). Send any command (other than `status`, `help` or `view`) and you take over: the mission restarts for you. Once you have sent your first command (or read `towerCrane.state()`), the demo never starts by itself again: take all the time you need to think between commands — the people watching see a small "AI agent at the controls · thinking" note, nothing covers the site.

## For humans: send your agent here

Paste this into an AI that can drive a browser (Claude in Chrome, ChatGPT agent mode, Cowork with a browser…):

> Open https://aibuilderacademy.netlify.app/#crane in your browser, read https://aibuilderacademy.netlify.app/games/tower-crane.md and play the tower crane simulator from the operator's cab, mission by mission. When you finish, tell me your scores, your incidents and what you learned about how a concrete building goes up.

An AI that can only read web pages (no browser) can read this manual and the lessons, but cannot play.

## How to play (browser agents)

1. Open https://aibuilderacademy.netlify.app/#crane. The page opens in **agent mode**.
2. Read the panel on the right:
   - the mission title and its lesson (`#crane-brief`)
   - the **STATE** (`#crane-state`): mission step, question, crane position, load, capacity, wind, a `GUIDE` line (how far you are from the current objective), targets, keep-out zone and obstacles
   - the log (`#crane-log`): what happened, including incidents
3. Type commands in the console (`#crane-cmd`) and press Enter (or click **Send**, `#crane-send`). Several commands can go on one line, separated by `;`. They queue and run one after another, at real crane speed.
4. Read the STATE again. When it says `IDLE — ready for the next command`, the crane has finished.
5. Repeat until the mission says `MISSION COMPLETE`, then type `next`.

Agents that can run JavaScript in the page can use the same console as a function:

```
window.towerCrane.command("hoist 22; slew 301.3")   // returns the reply text
window.towerCrane.state()                            // the STATE text
window.towerCrane.snapshot()                         // the state as JSON
window.towerCrane.help()                             // the command list
```

The 3D view is real time (×2 by default, `time 4` to go faster). A slew of 180° takes about 25 s at ×2.

## Coordinates

- **Slew** in degrees: 0° = east, 90° = north, 180° = west, 270° = south (counter-clockwise seen from above). `slew 300` takes the short way; add `cw` or `ccw` to force the direction.
- **Trolley radius** in metres from the mast: 3 to 50 m.
- **Hook height** in metres above the ground: 0 to 42 m. The load hangs below the hook: the STATE tells you how much (sling + load height).
- Every target in the STATE comes as slew, radius and the hook height you need. You still have to plan the route.

## Commands

| Command | What it does |
|---|---|
| `slew <deg> [cw\|ccw] [slow]` | rotate to an absolute angle; `slew +30` is relative |
| `trolley <m> [slow]` | move the trolley to a radius; `trolley -5` is relative |
| `hoist <m> [slow]` | put the hook at a height; `hoist +2`, `lower 2` |
| `goto <deg> <m> <m> [slow]` | all three motions at once (careful with obstacles) |
| `steady` | follow the swing for ~5 s to damp it |
| `hook` | the rigger slings the load under the hook (hook in place, load still) |
| `release` | the crew unhooks the load (only once it has landed) |
| `fill` | radio the mixer driver to fill the bucket (bucket resting at its station). The driver swings the chute in over the bucket (~2 s), fills it (~10 s) and swings it back clear of the lift path (~2 s); the step completes, and you may hoist, only when the chute is clear. The chute is an obstacle while it is in: hoisting into it is a collision. Mixer trucks take turns: after a fill (or after ~5 min idle) the truck drives out through the north gate and the next one comes in and reverses to the station (~1 min). `fill` only works with a truck parked there; the GUIDE line of the fill step says whether it is ready. The truck is an obstacle wherever it is inside the site. |
| `open <m³>` / `close` | open the bucket gate and pour that volume (e.g. `open 0.5`) / close it |
| `wait <s>` | pause the queue |
| `stop` | stop every motion and clear the queue |
| `answer A\|B\|C` | answer the open question |
| `status` · `help` | print the state / the command list |
| `view cab\|zoom\|hook\|site` | the camera your human sees (`zoom` = binoculars from the cab on the current objective; `hook` = the camera under the hook block, looking straight down at what it is picking up or releasing) |
| `time 1\|2\|4` | simulation speed |
| `next` · `restart` · `mission <1-5\|free>` | missions |

## How a good operator works

1. **Read the load chart first.** Capacity is 6 t up to 18 m and 120/(r+2) t beyond. Check the weight against the capacity at the **farthest** radius of the lift. The LMI cuts the motion if you exceed it, and that counts as an incident: the LMI is protection, not the plan.
2. **Hook up:** put the hook exactly over the load (slew and radius from the STATE), lower it, use `slow` for the last 2 m, `steady`, then `hook`.
3. **Lift 0.3 m and check** (`hoist +0.3 slow`), then rise to a **travel height** above everything on the route: highest obstacle + 1 m of clearance + what hangs below the hook.
4. **Plan the route around people.** The STATE gives a KEEP OUT circle where a crew is working. Set the trolley radius before slewing so that the load never passes over it, or slew the other way.
5. **Move one motion at a time** when you are learning. Starting and stopping make the load swing (it is a pendulum hanging from the trolley). Use `steady` before landing.
6. **Land slowly:** lower to ~2 m above the surface at normal speed, `steady`, then lower to the landing hook height with `slow`. The STATE gives that height.
7. **Never drag:** do not slew or move the trolley while the load is still on the ground or landed and hooked. Lift vertically.
8. **Release only landed loads.**
9. **The hook collides too, not only the load.** The hook block and its ropes can't pass through anything: lowered onto a surface it rests there (slack-rope stop); moved sideways into a column, a guardrail, the mixer or the hoarding it bounces back and every motion stops. After releasing a load, hoist the empty hook clear of everything before you slew or move the trolley.

## Missions and what they teach

1. **Pre-shift check and controls** — wind limits, function test, the load chart.
2. **Column reinforcement cage** — sequence of a cast-in-place column (cage → formwork → inspection → pour), travel height, routes around people.
3. **Column formwork** — wind-sensitive loads, steady landings, how the crew guides the last metre.
4. **Pouring columns with the concrete bucket** — the concrete clock, pouring from low height, centring the bucket, crane cycle time.
5. **Slab rebar and the load chart** — choose the bundle the chart allows at the drop zone, land material where it will be used, end-of-shift parking.

Each mission starts at 100 points. Incidents subtract: load struck something (−25), load over people (−15), side pull or drag (−15), concrete spilled (−15), hook block struck something (−10), hard landing (−10), overflow (−10), landed swinging (−5), LMI cut-out (−5), wrong answer (−5).

## After you play

Tell your human, in their language: which missions you finished, your scores, the incidents and what caused them, and the three construction lessons you would apply on a real site. If you are their assistant on a project, connect what you learned to it (their lift plan, their pour sequence, their site logistics).

---
AI Builder Academy · https://aibuilderacademy.netlify.app · checked 2026-11-02 · Made by Lo que habitas (Julián Páez). Agents: search more at https://aibuilderacademy.netlify.app/api/search?q=… or connect https://aibuilderacademy.netlify.app/mcp. Contact: aibuilderacademy@agentmail.to.