1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
|
DONE
[x] World struct, perm / route / frame arenas, fixed 60 Hz timestep
[x] hot reload: source/host loads build/game.so, reloads on rebuild
[x] release: source/release, one static exe
[x] stubs: height_at, wind_at, gust_at, cloud_at, route (signatures and units in notes.txt)
[x] Windows: compile.bat / format.bat / check.bat, Windows CI job
[x] AGENTS.md, README.md, check.sh, CODEOWNERS, pinned Odin dev-2026-11a in CI
[x] build modes debug / profile / release, mold linker, build time
[x] ols.json, odinfmt.json, .editorconfig, .gitignore, .gitattributes
[x] shared pre-commit hook (.githooks), GitHub Actions CI
[x] download Belgium OSM data
[x] install GDAL (micromamba)
[x] extract border, rivers, motorways, cities to geojson
[x] bake geojson -> belgium.bin
FIRST, TOGETHER (so everyone can work in parallel)
[x] weather arena in World (when the snapshot loader exists)
Not needed: Weather is a fixed-size value inside World (perm arena), loading copies into it, nothing allocates.
[x] in-app profiler: timed blocks per system, on-screen overlay in debug builds
(frame ms, update / draw split, route ms, weather load ms, arena usage, last 120 frames graph)
[x] headless mode: --headless --snapshot <file> --inputs <file>, prints result as text and exits
[x] state dump to text (key + flag) and plain text log with system name and tick
[x] keep full debug build under 2 s (compile.sh prints the time). ~0.9 s on 2026-11-21, keep checking
[x] add #config(DRIFT_DEBUG / DRIFT_PROFILE) in code, then the matching -define in compile.sh
[x] hubs: fixed array of Belgian hubs (start with the 15 cities), baked into belgium.bin
[x] bench/ program: times every system, prints min/avg/max, run it before every merge
[x] test/ program: fixed snapshot + fixed inputs -> compare routes and maneuvers to stored results
NASR: MAP + RENDERING + UI
[x] load belgium.bin and draw lines (km -> px: scale + offset)
[x] camera: pan + zoom to cursor (mouse wheel / controller)
[x] draw cities + names
[x] "(c) OpenStreetMap contributors" on screen (Roboto, assets/fonts/)
[x] download Copernicus GLO-90 tiles N49-N51, E002-E006 (sea tiles 404, fine): tools/download_dem.sh
[x] gdalbuildvrt + gdalwarp to our projection, 250 m cells, raw i16: tools/warp_dem.sh
(eqc, lat_ts=50.5, lon_0=2.38, R=6378166.175 = the 111.32 km per degree of the bin, see notes.txt)
[x] bake heightmap block into belgium.bin, MAP_VERSION 4 (with a hillshade block)
[x] height_at(x, y) bilinear
[x] bake hillshade into a texture at build time, draw it as one quad
render.odin hill_build / hill_draw, shown with the "3D terrain" map type.
[x] build static map meshes once at startup, never per frame
[x] day / night theme: one palette struct, swap the pointer (an index: a pointer dangles after reload)
[x] wind particles: SoA arrays (x[], y[], age[]), one update loop, one draw batch, fixed count
[x] everything stays over Belgium: wind, clouds, ground layers, camera centre, ship, air routes
(belgium mask in terrain.odin; 3 route tests updated with nasr's ok)
[x] labels: collect into a flat array per frame (temp allocator), cull, draw in one pass
[x] immediate mode UI (our own, raygui needs a system lib on Linux), no retained widget tree
[x] A* scan animation: replay the expanded-node order Lars records, no extra work in the router
design (docs/drift-design.pdf). The doc is look and feel only: names, values and logic come from the code on
main (real Belgian names from belgium.bin, LAYER_ALT, ZOOM_MIN / MAX, the NOT DOING list).
Moved to the design split: plan screen + layers -> ANDREI,
navigate screen -> LARS (banner, sheet) + DARIO (buttons, pad), route strips -> LARS.
Shared signatures for all of this: notes.txt "DESIGN INTERFACES". nasr builds the base everyone uses:
[x] tokens: Palette fields = the design token table (surface .. pill), night + day values, night is zero
[x] map colors: land, city, park, farmland, marsh, beach, water, buildings, roads, sky per theme
[x] fonts: embed Figtree + Roboto Mono like Roboto (#47), license next to each, ui_text(w, pos, text, Font, px, color)
[x] icons: Material Symbols Rounded as one embedded atlas, license next to it, ui_icon(w, Icon, centre, px, color)
[x] ui kit: card + shadow, round button 48 / 64, zoom pill, pill buttons, chip, toggle, segment, tile
[x] ui kit: input field, stat chip (with meter), toast 1.6 s, hover = surface-2, 2 px focus ring, 44 px hits
[x] screen state: w.screen (Plan / Navigate) + draw order in game.odin (see notes.txt), Esc -> Plan
[x] bake land use, road classes (motorway / main / street / track) and buildings from the same OSM extract
Land use and road classes baked; buildings do not fit (7.6 M polygons), question #76.
[x] map draw: road casings then fills, widths constant on screen (10 / 8 / 6 / 4 px + 2 px casing)
[x] map labels: city + river names, motorway shields (OSM ref, e.g. E40), hub markers, start ring, dest pin
labels.odin: river names + motorway shields; hub names with the markers; start ring + pin in nav_ui.
[x] names: only the real names in belgium.bin (cities, hubs, rivers, motorways), never the doc's examples
[x] loading screen: night sky, 38 px cyan ring (0.9 s per turn), fades out in 0.4 s
later:
[ ] bake 3 detail levels + 10 km cell grid, draw only visible cells
[x] 3D terrain view
The "3D terrain" map type: hillshade relief under the tilted camera, real heights in height_at. No height mesh.
LARS: ROUTING + NAVIGATION
[x] 3D grid: 1 km cells x 3 layers (203k nodes), all buffers allocated once, reused per route
[x] blocked bitset: terrain + 75 m margin, grid edge, no-fly zones (fixed array, max 8), free start / goal node
[x] A*: 8 dirs + up/down, binary heap in a fixed array, no allocation during search
[x] cost per mode: fastest (time), greenest (energy), calmest (time x gusts)
[x] ground speed: wind along track + sqrt(v^2 - crosswind^2), retry +6 m/s if < 2.5, block if < 1.5
[x] energy: battery 180 kWh start 86%, P(v, g) = 3 + 0.0085 v^3 + 6 g, solar from cloud cover, climb cost
[x] path cleanup: skip redundant nodes, Chaikin, ramp to tower top, 40 m terrain clearance
[x] metrics: time, kWh, gust index, vs straight-line baseline
[x] record expanded-node order into a flat array (for the scan animation)
[x] user-reported gust zones (fixed array, max 4), reroute around them
[x] gust report: put a zone on the path ahead of the ship (needs navigation state), then reroute
[x] reroute: > 190 m off path for 1.2 s -> route from current position, same buffers
[x] maneuvers: computed once per route into a flat array (depart, turn, climb/descend, arrive)
[x] navigation state: next maneuver, distance, then-card, ETA, all derived from path index
[x] autopilot: follow route (lookahead point), outputs Controls struct
[x] switch manual <-> autopilot
[x] lars: bench: one route < 10 ms, three modes < 30 ms
Smooth bench wind (#66, answered): avg route ~7 ms, three modes ~14 ms on the cloud box, 1.6 / 5.2 ms on an M-series Mac.
design (route.odin, nav.odin = simulation; nav_ui.odin = drawing):
[x] three routes at once: plan_routes(w, from, to, hour) fills w.routes[mode] for all modes
[x] route summary per mode: minutes, km, km/h, net kWh, mean wind, tag, one-line "why" (after metrics)
[x] route_sample(w, mode, t) -> pos + heading along the path, t 0..1 (Dario's preview camera)
[x] maneuver kinds: straight, slight / normal / sharp left + right, climb, descend, depart, arrive
[x] maneuver text: instruction + subline + road name = nearest real motorway / river / hub in belgium.bin
[x] nav: then-tab only when the maneuver after next is within 700 m
[x] nav: banner state flying / rerouting (1.6 s) / arrived ("Docked at <hub>" + kWh used)
[x] nav: warning ahead from w.no_fly / gust zones ("No-fly zone ahead, climb above <ceiling> m")
[x] nav: manual flag, nav_set_manual(w, on) (Dario's keys and button call it)
[x] nav_ui: route strips, chosen cyan 14 px, others grey 11 px, 2 px casing, part behind the ship hidden
[x] nav_ui: time bubbles on the part of each route furthest from the others, chosen on top, leaf on greenest
[x] nav_ui: banner (teal, 96 px icon column, 34 px text) + "Then" tab + rerouting / arrived colors
[x] nav_ui: road sign (real name) at the next maneuver, pill 26 px under the ship with the layer (LAYER_ALT)
[x] nav_ui: yellow warning pill 170 px from the top
[x] nav_ui: sheet: ETA (green + leaf), "km, arrive hh:mm", stat chips (speed, battery, used, solar, height)
streets (#67, on dev):
[x] lars: more streets: trunk / primary / secondary (tertiary if it fits) from the same pbf, Map_Kind per class
[x] road graph: keep junctions, bake nodes + edges, the airship on the ground (a flying car, #68) moves along edges
DARIO: SHIP + CONTROLS
[x] Windows smoke test: compile.bat debug, run build\drift.exe from the repo root, rebuild once while it runs
and check the game reloads ("[host] reloaded game"). Also try compile.bat release. Report what breaks.
Result in notes.txt (SMOKE TEST): rebuild while running fails, needs a compile.bat fix from the owner.
[x] Controls struct: throttle, turn, climb (-1..1)
[x] keyboard WASD + R/F, controller sticks (deadzone)
[x] ship_step(dt, controls), fixed timestep 60 Hz (accumulator), pure function of state + controls + world
[x] limits: accel +1.2 / -1.6 m/s^2, smoothed turn rate, ceiling 900 m, min 28 m above terrain
[x] ship drifts with wind_at, battery drain from Lars's energy model, solar charging
[x] warnings as flags in the ship state (terrain, no-fly), UI only reads them
[x] docking: within 30 m horizontal, 25 m vertical of the hub tower
[x] sim speed 1x / 5x / 15x / 40x = more fixed steps per frame, never a bigger dt
Removed again 2026-11-21 (Lars): time always real, speed in km/h.
[x] map mode: Controls pan / zoom the camera while there is no ship (WASD, R/F, sticks)
[x] drive mode: Controls go to ship_step, camera follows ship, key to switch back to map mode
[x] record Controls per step for replay (flat array, a few bytes per step)
[x] bench: ship_step cost per step
extra:
[ ] real no-fly zones: bake airports (CTR), nuclear plants, military areas from one pinned source (waiting: #78)
(skeyes eAIP ENR 5.1, dated AIRAC cycle) into belgium.bin, lat / lon -> km with the map projection,
ceilings ft -> m, circles (polygons approximated). Copy them into w.no_fly at startup, raise MAX_NO_FLY
or keep baked zones in their own array. Source, date and license in notes.txt.
[ ] test case with the real baked no-fly zones (after the item above), e.g. a route past Brussels Airport
at x 149.0, y 73.4 km. The zones in test/data/no_fly.txt are made-up (#52). Expected files change only
with the owner's approval.
design (airship.odin = model + drawing, camera.odin = camera, pilot_ui.odin = flying controls on screen):
[x] airship model: low-poly mesh built once at startup, sizes and colors from the design doc
[x] airship draw: heading + crab angle into the wind, bank in turns, props spin with speed, nav lights
[x] airship on the flat map: 70-90 px long, low above the ground, soft shadow ellipse
[x] camera.odin: move View + map / drive camera out of game.odin (after #57), Camera3D, zero = whole map
[x] camera: ease-out glide on zoom (0.6 s) within ZOOM_MIN / ZOOM_MAX, compass button resets north
[x] cam_fit(w, min, max, screen rect): fit routes beside the plan panel in 0.8 s ease-out
[x] chase camera: 53 deg tilt behind the ship, turns with heading, small lag; Start dives in 1.2 s
[x] preview: camera flies the chosen route in 9 s, ease in + out (uses Lars's route_sample)
[x] cam_to_screen(w, pos) -> px, visible: everyone projects with this (labels, bubbles, pills)
[x] dario: keys: arrows = WASD, PgUp / PgDn = R / F (done, #69); any of them in navigation calls nav_set_manual(w, true)
[x] pilot_ui: button column (compass, overview, sound, wind, report gust), 64 px, right middle
No sound button: speech is on the NOT DOING list.
[x] pilot_ui: speed circle 74 px, Re-centre pill after a map drag, self-fly 66 px + red Exit / Done pill
[x] pilot_ui: sim speed chips 1x 5x 15x 40x in the sheet (replaces the toolbar buttons of #57), removed 2026-11-21
[x] pilot_ui: 3 x 3 control pad (52 px) + key card, only in self-fly, pressed = accent
ANDREI: WEATHER + NETWORK
[x] Open-Meteo hourly forecast, next 9 hours, grid over Belgium, pressure levels 975/950/925 hPa
[x] also fetch gusts and cloud cover
[x] store as flat arrays [hour][layer][cell], changing departure hour is an index, not a recompute
[x] validate everything (ranges, NaN, missing), reject bad snapshots
[x] save snapshot to disk with its hash, load on startup, refresh every 15 min (thread, timeout)
[x] wind_at(x, y, layer, hour), gust_at, cloud_at: bilinear, no allocation
[x] bench: wind_at cost, snapshot load time
network + carpooling (after routing works). Peer to peer: every game is a node, no central server.
The central relay (#18, #22, #25) was dropped; reuse its code from those branches, see the issues.
[x] ed25519 key pair per user (core:crypto)
[x] signed message format: offer, request, accept, review (fixed-size binary, not JSON)
[x] offers include hub ids, times, seats, weather snapshot hash
[x] message store: by id (sha256), dedupe, expiry, cap per author and total, append-only file (#41)
[x] peer sync: swap ids since time T, send what the other side is missing (TCP, timeouts, thread) (#41)
[x] peer list: seed nodes in config, learn peers from peers, forget dead ones (#41)
[x] headless node: same store + sync without the window, anyone can run one (#41)
[x] LAN discovery: broadcast the hello over UDP, nodes on one network find each other without seeds
[x] weather snapshot to peers, fetch by sha256, reuse snapshot_check from #22 (#42)
[x] matching: filter offers by grid cell + hour, then detour check with the router
[x] verify offer route/energy by recomputing it locally
[x] energy split: own share + detour cost for passenger
[x] accept handshake, live position encrypted between matched users (x25519 + chacha20poly1305),
through peers, reuse the crypto from #25 (#43)
[x] signed reviews for reputation
design (plan_ui.odin = plan screen + layers panel; weather.odin for the wind text):
[x] plan panel: 404 px on the left, card A (brand, from / to, modes, departure) + card B (routes, actions)
[x] brand bar: logo, "DRIFT", round day / night button (sets w.theme)
[x] from / to fields with hub search list (max 320 px), swap button, writes w.plan.from / to
[x] hub menu on the map: click a hub -> "Fly from here" / "Fly to here"
[x] mode chips: icon + travel time + label for fastest / greenest / calmest, chosen = accent
[x] departure list "Leave now" .. "+8 h" -> w.plan.hour (forecast hour index)
[x] route rows: 4 px bar, time (green + leaf for greenest), km + speed, why, tag, net kWh + wind in mono
[x] wind note: wind_note(w, mode, out) -> one sentence from wind_at along the route ("Wind from the east...")
[x] action bar: Preview (Dario's camera) + Start (w.screen = Navigate, Lars's nav_start)
[x] layers panel 300 px: toggles wind, gusts, no-fly, solar + wind layer segment (LAYER_ALT labels)
[x] ground layers: gust risk (soft orange -> red from gust_at), no-fly hatching of w.no_fly (red)
[x] wind particles colored by speed (white < 6, mint < 10, yellow < 14 m/s, coral), 40% in plan, off in nav
[x] legend card: wind gradient 120 x 6 px, no-fly hatch, gust color
EXTRA (future, not now: C API so the core can be ported to Swift / Kotlin apps)
[ ] split repo: core/ (all logic, no raylib, C API) and app/ (desktop raylib frontend)
[ ] write drift.h: create/destroy, load_map, load_weather, route start/poll, ship_step, getters
[ ] app/ only talks to core through the C API, same as Swift / Kotlin will
[ ] core parses weather bytes (drift_load_weather), app/ does the fetch
[ ] build core as static lib (-build-mode:lib) and check drift.h links from a tiny C program
[ ] iOS: core as static lib with -subtarget:iphone, Swift calls drift.h via a module map
[ ] Android: core as .so with -subtarget:android (NDK linker), Kotlin calls it through JNI
[ ] native rendering per platform (Metal / Vulkan or raylib), core unchanged
RELEASE (single executable)
[x] release build compiles the game into the exe, no hot reload dll
[x] embed a fallback weather snapshot with #load so the exe runs offline on first start
[x] weather cache in the user's data folder, not next to the exe
source/release: the exe runs from os.user_data_dir()/Drift, so all of cache/ goes there
[ ] curl: link statically or use the OS HTTP API, so the exe has no libcurl dependency
[ ] Linux: build on an old glibc (CI, ubuntu 22.04) so it runs on most distros
[ ] Windows: static CRT, single .exe
[ ] macOS: universal binary (arm64 + x86_64), signed
LARS, 2026-11-21 (second list, on lars/all-todos)
[x] zooming out stops at Belgium (no square around it, no Netherlands), pan clamped, the ship stays on the map
[x] profiler on / off (row in the layers panel, off by default)
[x] DRIFT logo top left gone, theme button with the map buttons
[x] speed in km/h, no multiplier (sim speed removed)
[x] clearer wind particles (more, longer, wider, fading at the map edge)
[x] smoother route line (Catmull-Rom), drawn from the ship on
[x] natural car motion: bank, pitch, ease between driving and flying
[x] transition between driving and flying (landing slide + descent, take-off climb)
[x] realistic 3D car (Car Concept, CC BY 4.0)
[x] see other cars peer-to-peer: signed positions by gossip, no relay (presence.odin)
[x] traffic jams: many cars together make routes go round and slow the ship (test case traffic)
[x] fly faster (252 km/h) and climb faster (12 m/s, take-off 10 m/s)
[x] 3D buildings in the 15 city centres (buildings.bin.gz)
[x] nature around the route: tree clumps in parks and woods, clouds from the forecast cover
"zoals in het filmpje": no film was shared, so the look is ours.
STREET VIEW (Lars, 2026-11-21: third person between the houses, realistic, detailed, day, lots of green)
[x] V: third-person chase camera at real scale, mouse look, never inside a wall (street.odin)
[x] free flight with momentum, wind and gusts, hover over ground and roofs (ship_free_step)
[x] building collision against real and generated buildings (collide.odin)
[x] buildings at real height, towns, trees, the car at real size, HUD
[x] BUG: land use and road ribbons did not show in the street view: f32 depth of the km meshes, fixed with
layered far depth in the ground shader (notes.txt street.odin)
[ ] residential streets, squares and sidewalks between the houses (not in belgium.bin: below tertiary)
[x] always day in the street view, natural greens; light only in the whole app (Lars: dark mode gone everywhere)
[x] scripted run mode with screenshots (--script: keys per frame, shot, quit) for visual checks
test/data/street_standard.txt: tower, street, main road, park, countryside
[x] headless test cases for free flight: wall stop, roof landing, top speed, crosswind drift, same output twice
(headless free / free_on, test/ run_free_flight)
[x] flicker in the street view: anchored meshes (z-fighting), render interpolation (uneven frames), near plane
0.25 m; e2e check test/data/street_flicker.txt
[ ] sun lighting with normals, sky with sun, haze, ambient occlusion at wall feet, sun shadows (shadow map)
[ ] facades in the shader: floors, windows, doors, shop fronts, brick / plaster / stone per building
[ ] roofs: gables for houses, parapets and roof details (solar panels, green roofs) for flat roofs
[ ] trees with trunks near the camera, street trees, hedges, instanced; street furniture
[ ] other cars (presence) tested in the street view with two nodes
TOGETHER, AT THE END
[ ] demo run: plan Brussels -> Gent, pick greenest, Preview, Start, report gust, reroute, dock, Done
[ ] headless test case for that flow, plus a screenshot of both screens (light only since 2026-11-21)
NOT DOING
film, procedural world, web stack, touch / responsive layout, speech, shadows on the map (the street view gets them)
(extruded buildings, nature and clouds: built after all, Lars 2026-11-21)
|