Navigation — reference wiki

Glossary

Leg

One turn's flight: a great-circle arc of fixed length along your chosen heading. Leg i is 20 Mm / φⁱ.

Heading

The bearing you submit, in degrees clockwise from north. The only quantity you control.

Deviation

A random Cauchy-distributed angle (scale 7.5°) added to your heading before the leg is flown.

Beacon

A single point inside the target territory. Your reports give a coarse distance to it.

Fuel

The ratio of your beacon distance to your remaining travel budget. Below 1 the beacon is reachable; at or above 1 it isn't. Reported in golden-ratio steps as lphi_fuel. (Key jargon.)

Target territory

The region you must reach to land and win.

Land

To reach the target territory (usually you must be on dry land). First to land wins.

Strand

To be unable to reach the target — you're out, but still eligible for the closest-to-beacon rule.

Seed

The value that seeds the round's random generator — a formatted Oslo-timestamp string. Recover it and every deviation becomes known.

Tape

The radio's currency, a fixed budget per round. One unit ≈ one recorded sextet (omnidirectional).

Sextet

Six recorded bits = one base-64 character; the radio's atom of recording.

Mm

Megametre = 1000 km = 10⁶ m. Convenient because leg 1 ≈ 12.36 Mm.

φ (phi)

The golden ratio, ≈ 1.6180339887. Legs shrink by this factor each turn.

Annulus

A ring between two radii — the shape your distance clues carve out as your possible location.

Geometry & legs

The board is a WGS84 ellipsoid Earth; legs are geodesic (great-circle-like) arcs.

• Leg length: L_i = 20 Mm / φⁱ.
• First leg: L₁ = 20 Mm / φ ≈ 12.3607 Mm.
• Total travel budget (from the start, over all legs): Σ_i≥1 L_i = 20·φ ≈ 32.3607 Mm.
• Remaining budget from leg i onward: 20·φ²⁻ⁱ. After leg 1 it is exactly 20 Mm.

Golden-ratio (Fibonacci) identities

Because the legs are a geometric series in φ, and φ obeys φ² = φ + 1 and 1/φ = φ − 1 ≈ 0.618, the leg and budget sequences satisfy the same Fibonacci-style recurrence. These are worth memorising — they turn budget questions into one-line mental arithmetic:

• Each leg equals the sum of the next two: L_i = L_i+1 + L_i+2. (The same recurrence as Fibonacci numbers, run on the shrinking side.)
• Your total remaining travel is always φ² ≈ 2.618 × the next leg. Whatever next_leg_dist is, everything you have left to fly (this leg included) is 2.618 times it. So the reach edge sits at 2.618 next-leg-lengths away.
• Everything still ahead after you finish leg i sums to L_i−1 — exactly the length of the leg you just flew before it. Equivalently, the remaining-budget sequence is the same golden series shifted by two (remaining from leg i onward = L_i−2; e.g. from leg 3 onward = L₁ = 12.36 Mm).

One consequence connects straight to lphi_fuel: if the beacon lies exactly on your next-leg ring (distance = next_leg_dist), then it sits at 1/φ² of your remaining travel — which is precisely why lphi_fuel = −2 marks “beacon reachable in a single leg”.

The heading deviation

Each turn, before flying, the game adds a random angle to your submitted heading:

deviation = 7.5 · tan(π · (random() − 0.5))   # degrees

This is a Cauchy distribution with scale 7.5°. It is symmetric about 0 and heavy-tailed — it has no finite mean or variance, so “expected value” reasoning fails and large excursions are routine.

Quantiles of the wobble — the half-width your deviation stays within, with the stated probability (two-sided). Note how fast the tail runs away past the median:

The last rows are not typos. Because tan diverges near ±90°, roughly 1 in 100 draws exceeds a full 360° rotation, and 1 in 1000 spins the heading around a dozen times. The flown bearing is (heading + deviation) mod 360, so a large kick simply wraps — a big enough wobble points your leg in an essentially unrelated direction, anywhere on the compass. You cannot bound where a single leg lands.

On a 12.36 Mm leg, 1° ≈ 216 km of cross-track error, so even a “typical” few degrees is hundreds of kilometres. This is why knowing the deviation in advance (via the seed) is decisive: submit heading = intended_bearing − known_deviation and the flown bearing is exact.

Location report — field reference

The location event each turn. Geographic-layer fields are present only where they apply.

Distance signals — ln_dist, lphi_fuel, inferred_bounds

ln_dist is round(ln(distance_to_beacon_in_metres)). Because it's rounded in log space, each value is a factor-of-e (≈ 2.718) band. A reference:

Consequence: far readings barely constrain the beacon (band thousands of km wide); a close reading pins it tightly. To locate the beacon, triangulate from several readings taken at known positions — and weight the close ones.

Fuel and lphi_fuel

Fuel is the ratio of your beacon distance to your remaining travel budget: fuel = beacon_distance / remaining_travel. Fuel < 1 means the beacon is within reach; fuel ≥ 1 means it isn't. lphi_fuel reports this in golden-ratio steps:

lphi_fuel = floor(log_φ(fuel))

Using the identity remaining travel = φ² · next_leg (see Geometry), this is the same as floor(log_φ(beacon_distance / next_leg_dist) − 2) — so each unit of lphi_fuel is one golden step measured against your next leg:

inferred_bounds hands you the near/far radii directly so you don't recompute the logs by hand.

Geographic layers

The report stacks several overlapping geographic sources. They don't always agree — they use different shapes and viewpoints — so use them together:

• esri — highly detailed shapes, closest to ground truth for coastlines and international borders, plus whether you're on the primary landmass or a small island. This is the most reliable layer for judging landfall — is this point actually on land, and inside which country's borders.
• natural_earth — more generalised shapes from a Swedish point of view, so it reflects different political recognitions (e.g. it recognises Kosovan sovereignty). Often closest to how the game master defines a target territory, so it's a good tie-breaker for “does this count as the target?” — but trust esri for the physical coastline.
• disputed and antarctic are also sourced from Natural Earth (disputed territories and Antarctic claims respectively).
• maritime_zone / iho_sea — which waters you're over (territorial waters, EEZ, named sea). Tells you you're at sea, and roughly where.
• National subdivisions (*_municipal, *_postal) — fine-grained locality where available, useful for pinning a landing.

For seed recovery, the useful distilled signal each turn is (on land?, which country if land, UTC offset). For landing, use esri for the coastline/border and cross-check natural_earth for whether the game master would call it the target.

Win conditions & tie-breaks

1. First to land wins outright. Landing one turn earlier beats any tie-break consideration.
2. Same-turn landing → furthest from the beacon wins. If several land on the same turn, the one farthest from the beacon takes it.
3. Everyone strands → closest to the beacon wins. If nobody reaches the target, the closest to the beacon wins the consolation.

Details worth knowing:

• You must usually land on land within the territory, unless the round says otherwise.
• A player who resigns (declares stranded) still competes for the closest-to-beacon rule.
• Each player begins the next round from their end position this round — so even a lost round positions you for the next.
• You and your opponent share the same deviation sequence each round, but (after round 1) start from different positions. It's a race over identical wobbles from different starting points.

Seed & seed recovery

The round's generator is seeded like this:

timestamp = int(random.normalvariate(seed_mean, seed_std))
dt = datetime.fromtimestamp(timestamp, tz=utc)
seed = format_time(dt)   # Oslo-local, Norwegian weekday/month names

So the seed is a formatted timestamp string drawn from a Gaussian around seed_mean with spread seed_std (both given at round start). The string is then used as CPython's string seed. Recovery exploits that there are only a bounded number of candidate timestamps:

• Enumerate every whole-second timestamp within a few σ of the mean (~360 candidates at σ = 60 s, ~3600 at σ = 300 s).
• Reproduce each candidate's deviation stream and thus its predicted path.
• Filter candidates against your reports. Recommended order:
  1. Free per-turn signature — (land/sea, country, UTC offset). Costs nothing, works everywhere, often pins the seed by turn 3–4.
  2. Distance bands — the ln_dist annulus each turn filters candidates even over open ocean.
  3. Radio tie-break — only when a couple of candidates share identical free signals; a single fix over dense airport country separates them.

Candidate landing points for a given heading are spaced on the order of ~11 km, so a radio fix under ~5 km can single one out — but the free channels usually get there first without spending any tape. Larger seed_std ⇒ more candidates ⇒ lean harder on distance bands and radio.

The radio

7884 airports act as stations, each transmitting at 1 watt. A station's signal at your location attenuates with distance d as

strength = exp(−d² / (2 · range²))

plus a constant noise floor of 1 milliwatt acting as one extra “station”. When recording, the radio repeatedly samples one station at a time, chosen with probability proportional to its strength at your true position, and encodes the identities into a bit-stream.

The radio form draws great-circle rings at 1×, 2× and 3× your range. Those rings are iso-strength contours — a station's raw strength depends only on how many range-lengths away it is:

So stations inside the first ring are all loud and hard to tell apart (little gradient); stations out past the third ring are essentially inaudible. The useful, discriminating band is roughly the 1×–3× annulus — tune range so several airports fall in it at different bearings.

Range — the free, decisive knob

range costs no tape but decides whether your tape buys anything. A station discriminates your location best when your distance to it is comparable to range (that's where the Gaussian has steep gradient). Tune it to the spacing of your nearby airports so several sit at different bearings and audible strengths. Too small ⇒ one station dominates (you learn a distance, not a fix); too large ⇒ everything sounds alike.

Tape & sextets

• You record a whole number of sextets (6 bits each). Omnidirectionally, cost = sextets tape units.
• With h harmonics (directional antenna), cost = sextets · (1 + h).
• sextets = 0 is a free dry run: it returns the expected nearby stations without spending tape. Always scout first.
• Smaller range ⇒ lower entropy ⇒ more complete observations per sextet ⇒ a sharper fix. In dense areas the radio can reach ~5 km; sparse areas force a larger range and a coarser fix.
• Precision improves like 1/√N: halving your error costs 4× the tape. The first fix that turns “somewhere in this sea” into “this blob” is the valuable one; over-refining is the worst buy.

Directional antenna (harmonics)

By default the antenna is omnidirectional (gain ≡ 1). Supply harmonics — a list of complex coefficients — to shape a directional gain pattern. The radio forms c = [1, *harmonics], L2-normalises it, and multiplies each station's strength by

G(φ) = |Σ_k c_k · e^(−ikφ)|²

where φ is the bearing to the station. Because c is normalised, total gain is conserved — a beam redistributes sensitivity, it doesn't add any. Some patterns:

• [] (or omitted): omnidirectional, G ≡ 1.
• [1]: a cardioid, lobe facing north, null due south.
• c₁ = e^(iβ) steers the lobe to bearing β (e.g. [1j] faces east).
• Contiguous higher harmonics narrow the lobe; gaps produce multiple symmetric lobes.

Each harmonic multiplies the tape cost, so directionality is worth it only when bearing is the binding constraint: collapsing an elongated (“banana”) fix by adding the missing bearing dimension, or steering a null onto one dominant station to bearing-find it. Few stations ⇒ directional; many stations ⇒ omni.

The Huffman codec & reading the tape

To pack observations into as little tape as possible, the radio builds a Huffman code over the stations, tuned to their expected frequencies at the point you tune to (tune_lat/tune_lon). Huffman gives the loud, likely stations short bit-codes and rare ones long codes, so the common case is cheap. It then draws observations from your true location and writes their codes into the bitstream until the requested sextets (6-bit characters) are filled.

• The stream is cut at a fixed length, so the last symbol is usually chopped mid-code; total_obs counts only the complete observations.
• expected_bits_per_obs is the entropy of the tuned distribution — the average code length. Fewer expected bits per obs ⇒ more complete observations fit in the same tape. A concentrated distribution (small range, or a dominant nearby station) has low entropy → short codes → many observations per sextet; a spread-out one costs more bits each and yields fewer.
• Tuning accuracy matters for efficiency: the code is optimal only for the tuned point. Tune far from your true location and the average code runs longer (you spend more bits per obs and get fewer of them) — but the observations themselves still come from the true location, so the fix is unbiased, just noisier per unit of tape.
• The report gives each station's code as a bitstring and the raw tape, so you can decode the tape yourself — verify the counts, or pull out detail the summary omits (e.g. exactly where the stream was cut).

The radio report

A call returns the top-10 expected stations plus any other actually observed: expected and observed frequencies, distance and bearing from the tuning point, each station's Huffman code, the total complete observations, the expected bits per observation, the coefficients used, and the raw tape. The noise floor appears as a station with IATA ---.

Opponent information

Each opponents entry, keyed by name:

Because you share the deviation sequence, their relative bearings over several turns can be back-solved into an estimate of their position and their likely landing — letting you plan to beat their beacon distance on a shared-turn landing.

Moves & the move budget

The move clock is a Fischer (chess-style) clock, not a fresh allowance each turn. You start the round with a time bank (the round base); when you commit a move, an increment of seconds is added to the clock, and any time you didn't use carries over to the next turn. So banking time by moving quickly early leaves you more for a hard turn later — and dawdling eats into that reserve. The deadline field gives you the concrete commit-by instant each turn; increment is constant across the round (the protocol could vary it, but it doesn't). The key mechanism for using the clock safely is the provisional move:

• A submit_flight may carry an optional valid_from timestamp. Until that instant the move stays pending and freely editable; the game only acts on it once valid_from passes.
• So the intended pattern is: post a safe fallback heading immediately with valid_from near the deadline, then overwrite it in place as your analysis improves. You never risk missing a turn.
• You may edit or withdraw any pending message; there's at most one submit_flight per turn (edit it rather than posting again).

Other move types: request_radio, request_clarification (asks the game master a question, shared with all players), message_request (a direct message), and declare_stranded (resign the round).

Built-in tools

• Seed recovery — sweeps seed_mean ± Nσ, reproduces each candidate's PRNG stream in-browser, and scores candidates against the timestamp prior and your per-leg deviation observations. Enter each leg's observed deviation (or mark it blank to consume the draw without constraining it); the candidates table shows the surviving seeds and their neighbouring deviations. Observations persist within a round.
• Map — a Leaflet scratch map with geodesic range circles that snap to the golden-ratio leg lengths, per-circle bearing ticks (for planning headings and reading off realised deviations), drag-to-move centres, and GeoJSON export. In effect it's a straightedge-and-compass kit: the leg-length circles are your compass arcs and the bearing ticks your straightedge, so you can construct a whole trajectory — or a landing geometry — by hand, without any code.
• Control room — the live player page: turn cards, the move-deadline countdown, the provisional-move toggle, and the radio form with range rings and a directional-gain plot.

Protocol summary

Two kinds of object are exchanged, both carrying round and turn:

Messages (you → game master): submit_flight (heading, optional valid_from), request_radio (sextets ≥ 0, range, tune_lat, tune_lon, optional harmonics), request_clarification, message_request, declare_stranded.

Events (game master → you): location (the masked report), flight (heading confirmation), radio (a print-out), clarification, direct_message, landed / stranded (terminal, with coordinates), new_round (target_territory, seed_mean, seed_std, tape, opponents), and game_ended (winner, and which rule decided it).

This page summarises the mechanics that matter at the table. The authoritative, exhaustive protocol lives in the project's docs/protocol.md.