# Aannames — Meteors

Waar de specificatie ruimte liet, staat hier hoe we het hebben ingevuld.
Als iets onduidelijk was, volgden we de geest van Meteos en (voor de
selectie-tween) Tim's bestaande KWin-effecten.

## Fase 1 — physics-fixes (t1098u, t1100u, t1101u)

### 1. Vallende blokken landen op vliegende clusters

Een gespawnd (vallend) blok ging soms door een vliegende cluster heen,
omdat de val alleen keek naar stilliggende/settling/locked blokken.

Aanname: het vallende blok botst alleen in dezelfde kolom. Het landt op
het hoogste vliegende clustermlid onder hem, wordt vracht van die
cluster (`state = flying`, zelfde `clusterId` en `vy`, geen vlam) en
vliegt mee, inclusief omhoog als de cluster nog stijgt. Nieuwe vracht
zit precies 1 tegel boven het hoogste clustermlid in die kolom.

Omgekeerd, als een stijgende cluster een vallend blok inrijdt, geldt
hetzelfde. Een cluster die al geland is (rigid settling) telt als vaste
ondergrond: daar landt een vallend blok gewoon op, het wordt geen vracht.

### 2. Grijze clusters landen als starre groep

Voorheen werd elke kolom bij landing platgedrukt op de stapel, waardoor
gaten verdwenen.

Aanname: zodra één lid de vloer of een stil blok raakt, stopt de hele
cluster als star lichaam. De relatieve posities blijven; een deel kan
dus boven een gat blijven hangen. Gekleurde vracht (meegedragen blokken)
blijft tot het einde van de settle-tijd van 3 s bij de groep — ze
verkleuren niet opnieuw, maar vallen ook niet eerder. Na de conversie
van de grijze blokken naar willekeurige kleuren laat de hele groep los.
Blokken mét steun blijven liggen; blokken zónder steun vallen
afzonderlijk, vanuit rust, met dezelfde zwaartekracht als een gewone
val (eerst versnellen tot `fallSpeed`, zie punt 3). Gestapelde hangende
blokken vallen als stapel (ze blijven op elkaar rusten, zonder te
overlappen).

### 3. Vloeiende snelheidsovergang op de apex

Voorheen sprong `vy` op de apex in één frame naar `-fallSpeed`.

Aanname: vanaf de apex (vy = 0) versnelt de cluster (en een handmatige
sprong) met constante `fallAccel` totdat `fallSpeed` is bereikt; daarna
constante daalsnelheid. `apexEaseTime = 0.15 * fallTime` en
`fallAccel = fallSpeed / apexEaseTime`. Lage luchtweerstand (kleine
`fallTime`) geeft dus een kortere, snellere overgang. Voor Terra
(`fallTime = 3`) is dat 0,45 s. Hetzelfde geldt voor hangende blokken
die na conversie uit rust gaan vallen. Blokken die van boven het veld
binnenkomen (spawn) starten al op `fallSpeed` — die vallen al een
tijdje.

### 4. Bounce bij landing (planeetparameter)

Aanname: de bounce is visueel (squash van de sprite, plus een heel klein
optisch terugveren in Y) en verandert de simulatiefysica niet. Elk blok
dat op de vloer of op een ander blok landt, krijgt een bounce; hangende
leden van een starre groep die niets raken, niet.

Snelheid hangt af van de luchtweerstand van het veld, via `fallTime`
(1 = weinig lucht, 5 = veel lucht):

- `bounceDuration = 0.12 * fallTime` (Terra: 0,36 s; bij `fallTime = 1`
  twee keer zo snel als bij `fallTime = 2`, enz.)
- `bounceSquash = 0.16` (subtiele verticale squash naar 84%, met lichte
  horizontale compensatie)

Beide zijn planeetparameters, klaar voor fase 3.

### 5. Handmatige sprong van het bovenste blok (t1100u)

Het naar boven slepen van een blok dat al het bovenste van zijn kolom
is, moest een handmatige sprong starten (tot net onder de bovenrand).
De core vroeg eerder dat de aanwijzer in de lege ruimte boven de stapel
kwam (`y > top + 1 + 0,25`). Wie het bovenste blok vasthad en het
voorbij zijn eigen positie trok, maar niet een hele tegel het gat in,
kreeg geen sprong. Op touch kon `lostpointercapture` de sleep ook te
vroeg beëindigen.

Aanname:

- Begon de sleep al op het bovenste blok, dan is een trek van
  `LAUNCH_PULL = 0,35` tegel omhoog vanaf het drukpunt genoeg
  (“voorbij zijn eigen positie”), voor muis én touch (zelfde
  Pointer-Events-pad).
- Begon de sleep lager in de stapel, dan blijft de oude drempel gelden:
  eerst wisselen, en pas lanceren als de aanwijzer in de lege ruimte
  boven de (nieuwe) top zit. Zo lanceer je niet per ongeluk een blok
  dat je alleen naar de bovenste plek wilt schuiven.
- De view luistert na `pointerdown` op `window` voor `pointermove` /
  `pointerup` / `pointercancel`, zodat een sleep boven het canvas
  (nodig bij een volle kolom) niet verloren gaat. `lostpointercapture`
  beëindigt de sleep niet meer.

### 6. Selectie-tween (t1101u)

Een vastgehouden (geselecteerd) blok krijgt dezelfde schaal-animatie
als de **DEFAULT**-instellingen van Tim's KWin Click Tween-effect.

Bron (op deze box): `/workspace/click-tween/`, specifiek:

- `settings.h`: `clickTime = 150` ms, `releaseTime = 720` ms,
  `clickEasing = easeOutBack`, `releaseEasing = easeOutElastic`
- `clicktween.cpp`: pers-doel `0.8`, loslaat-doel `1.0`; een onderbroken
  animatie start vanaf de huidige schaal (`QVariantAnimation`)
- `README.md`: “krimpt naar 80% in 150 ms”, “groeit in 720 ms terug”,
  “curveparameters zijn Qt-standaardwaarden”

Qt `QEasingCurve`-standaardwaarden, ook in de README genoemd:

- Back-overshoot: `1.70158`
- Elastic: amplitude `1.0`, periode `0.3`

Het blok blijft op 80% zolang het geselecteerd is, en veert bij loslaten
terug (ook als het ondertussen gelanceerd wordt). Muis en touch gebruiken
dezelfde tween.

## Fase 2 — multiplayer (samenvatting)

De miss-kans van 30% was de stage-2-parameter; stage 3 vervangt die door
parameter (`missChance`, standaard 0,30); de planeetformule
`Planet.missChance` (60%–5% via Power) is voor fase 3.

## Deploy: vreemde bestanden en favicon.ico

De FTP-guard blokkeert alleen een duidelijk verkeerd doel (FTP-root, pad
zonder `meteors` als laatste segment, map buiten `$timftproot`). Extra
bestanden die al in de remote map staan, worden alleen gelogd: we gebruiken
nooit `--delete`, dus ze blijven staan en zijn onschadelijk.

`favicon.ico` op de server wordt niet overschreven en niet verwijderd
(mogelijk van Tim of de host). De deploy sluit dat bestand uit van de
upload, ook als er lokaal een `build/favicon.ico` staat voor eigen gebruik.

### 7. Recolor stuurt blokken niet extra hard naar boven (t1102)

Na het herkleuren van een gelande grijze groep schoten blokken erboven
soms heel hard van de bovenkant af. Oorzaak: een restant van de
lanceringssnelheid (`vy` omhoog) of van een handmatige sprong, dat
na de release in `integrateFalling` alsnog werd gebruikt. Daarnaast
telde `releaseUnsupported` in dezelfde tick nog de hangende leden als
steun, zodat blokken die erop stonden `still` bleven en in
`resolveMatches` een match in de lucht konden vormen.

Aanname / aanpak:

- Bij elke overgang naar `still` of `falling` na release (en bij het
  loslaten van ongesteunde still-blokken) wordt `clearFlightState`
  aangeroepen: `vy = 0`, geen vlam, geen restant van een handmatige
  sprong.
- `releaseUnsupported` draait opnieuw ná `advanceSettle`, zodat
  blokken op zojuist losgelaten hangende leden vanaf rust vallen
  voordat er gematcht wordt.
- Een échte nieuwe match na herkleuren is toegestaan en gebruikt de
  normale sprong: `launchVelocity(planet, jumpHeight)` en de bijbehorende
  deceleratie, niet een opgetelde of achtergebleven `vy`. Dat zit in
  een regressietest (inclusief een kunstmatig achtergebleven `vy = 40`).

### 8. Botsende vliegende clusters smelten samen (t1102)

Twee (of meer) vliegende clusters die in dezelfde kolom in Y
overlappen, worden één cluster.

Aanname: de nieuwe snelheid is het **massagewogen gemiddelde op
blok-aantal** (niet het eenvoudige gemiddelde van de twee
clustersnelheden):

    vy = (n1·vy1 + n2·vy2) / (n1 + n2)

Hetzelfde gewogen gemiddelde geldt voor `decel` en `jumpHeight`.
De fase is `up` als de samengevoegde `vy > 0`, anders `down`.
Overlappende leden in één kolom worden van onder naar boven
aangepakt, zodat de hogere strak op de lagere rust (geen twee
blokken in dezelfde cel). Keuze vastgelegd: gewogen op blok-aantal.

### 9. Direct vastpakken, geen long-press (t1102 / t1103)

Er is **geen** long-press en **geen** wachttijd. Een blok wordt op
`pointerdown` (tap of klik) meteen vastgepakt en blijft in de sleep
zolang de vinger of muisknop omlaag is; loslaten beëindigt de sleep.
De click-tween start in hetzelfde moment als `pointerdown`.

Aanname:

- Verticaal: snap naar het dichtstbijzijnde still-blok in de kolom,
  tot `SNAP_Y = 0,65` tegel (een iets misplaatste druk pakt nog).
- Horizontaal: op de druk, als de aanwijzer binnen
  `HORIZONTAL_SLOP = 0,35` tegel van de kolomrand zit, mag het
  buurblok gepakt worden. Tijdens de sleep blijft de startkolom
  vast, ook bij een iets diagonale beweging.
- Wisselen: alleen een **minimale** opgetelde verticale afstand
  `SWAP_DISTANCE = 0,25` tegel per stap, zonder vertraging vóór de
  sleep. Een enkele grote `pointermove` (snelle swipe) loopt alle
  tegels langs (één wissel per tegel, geen overslaan). Er is geen
  extra drempel of hold voordat de sleep begint.
- `touch-action: none` op canvas en pagina, `preventDefault` op
  pointer-events met `{ passive: false }`, `setPointerCapture`,
  en window-listeners voor move/up (zoals al bij t1100).

## Fase 2 — multiplayer

### Polling en autorisatie

- De client pollt elke **0,75 s** (`Online.POLL_MS`). Dat valt in de gevraagde
  0,5–1 s. Er is geen websocket.
- Login via auth.timfalken.com (`/oauth/authorize`, `/oauth/token`, `/api/me`),
  client_id `projects.timfalken.com`. Callback
  `https://projects.timfalken.com/meteors/callback.php`. Het geheim zet Tim
  als protected projectgeheim `auth_client_secret` (niet opnieuw genereren);
  de deploy schrijft dan `data/config.php`. Zonder geheim blijft solo
  werken, met een duidelijke online-melding.
- Testers `auth.php?test=1` / `?test=2` alleen als `localDev()` waar is:
  loopback-host **én** loopback-remote-adres (zelfde regel als verhalenboek).
- Sessies staan in `data/sessions`, cookie-pad is de map van het script
  (`/meteors/` live). CSRF-token op elke POST (`X-CSRF-Token`).

### Lobby en wedstrijd

- Onbeperkt in de zin van de regel; praktisch maximum **32** (`METEORS_MAX_PLAYERS`).
- De host start alleen als iedereen gereed is en er minstens twee spelers zijn.
- Eigen veld is het hoofdspel; miniaturen van anderen staan in een strook
  boven het veld (onder de HUD).
- Afgeschoten blokjes gaan als `outgoingShots` mee in de volgende poll. De
  **server** kiest het doel en gooit de miss-kans (niet de client, zodat die
  niet kan valsspelen). Doel is een willekeurige andere speler die nog niet
  is uitgeschakeld.
- `missChance` is een **parameter**, standaard **0,30**, op de lobby én op
  `GameCore`. `Planet.missChance` (Power, 60 %–5 %) blijft voor stage 3 en
  wordt hier niet gebruikt.
- Een raak schot komt na `flight_duration = 1,2 s` bij de ontvanger aan als
  vallend donkergrijs vuil (`ingestGarbage`), dat na de gewone 3 s settle
  een willekeurige kleur krijgt.
- De vlucht-tween is een kwadratische Bézier, met semi-willekeurige rotatie
  (tot ±720°) en krimpen (“de verte in”). Een miss vliegt het scherm af en
  vervaagt; een raak schot landt in de miniatuur van het doel.
- Uitgeschakelde spelers zijn toeschouwer (geen doelwit, geen shots). De
  laatste die overblijft is 1e; de eerder uitgeschakelden 2e, 3e, … Het
  podium blijft **5 seconden** (`METEORS_PODIUM_SECONDS`) en daarna gaat de
  lobby terug naar `waiting` (ready-vlaggen gereset).
- `data/` (sqlite, sessies) wordt nooit gespiegeld of gewist. Alleen
  `data/.htaccess` (Require all denied) wordt na de mirror gezet.
  Als het projectgeheim `auth_client_secret` niet leeg is, schrijft de
  deploy `data/config.php` vanuit dat geheim (waarde nooit in de logs).
  Is het leeg of afwezig, dan blijft een bestaand bestand staan. De groep
  `projects-timfalken-com` en verhalenboek hebben dit geheim niet (alleen
  FTP); Tim zet het op het meteors-project. Optioneel: `auth_client_id`
  (standaard `projects.timfalken.com`). `favicon.ico` blijft ongemoeid.
  `router.php` is alleen voor lokale `php -S` en gaat niet mee naar live.

## Fase 3 — planeten (velden)

- Een veld is een planeet, met een naam voor de planeet en voor het volk.
  De catalogus staat in `server/lib/planets.json` (bron voor JS én PHP) en
  telt **12** werelden, van makkelijk (Aurel: sinds t1199 gameplay-Power
  1/9, 53,9 % miss, getoonde Power 10 %; eerst 0 / 60 % / 0 %) tot moeilijk (Cinder: gameplay-Power 1, 5 % miss,
  getoonde Power 92 %). Terra (44 % getoonde Power) blijft de standaard.
- Zwaartekracht (`jumpsToClear` 2–4 sinds t1199, eerst 1–4): één sprong haalt
  `1,5 / jumpsToClear` van de veldhoogte (t1119, +50 %). Luchtweerstand
  (`fallTime` 1–5 s tot de bodem voor losse blokjes; een vliegende
  cluster zweeft na de apex in 2× `fallTime` naar beneden, t1122/t1124).
  Massa
  (`riseTime` 0,5–3 s tot de apex). Lage massa en lage luchtweerstand en
  hoge zwaartekracht zijn moeilijker. Bounce-duur en apex-ease schalen al
  met `fallTime` (gebouwd in stage 1).
- De interne (gameplay-)Power is het gemiddelde van die drie assen,
  genormaliseerd 0–1. Miss-kans = `0,60 − 0,55 × Power` (60 % bij 0,
  5 % bij 1). Dat formule blijft de gameplay: schoten en de server
  gebruiken hem onveranderd. De **getoonde** Power in kiezer, HUD en
  lobby is `1 − miss / 0,60` als percentage (0 % miss → 100 % Power,
  60 % miss → 0 % Power). Dat is alleen weergave (t1105). In
  multiplayer gebruikt de **server** de gameplay-Power van **jouw**
  planeet voor de blokjes die jij afschiet (niet de lobby-waarde, niet
  de planeet van het doel). De client kan dat niet vervalsen.
- De vier getallen op de kiezers en in de HUD: `g` als
  zwaartekracht (sinds t1199 als percentage + g, zie t1199), `d` als luchtdichtheid, `F` in newton,
  getoonde Power als percentage. Alleen de getallen, zonder uitleg.
  Verticale match van 3 = 120 % sprong, +5 % per extra blokje (al
  gebouwd, nergens uitgelegd).
- Elk veld heeft een eigen set van 5 kleuren, elk met een uniek vormpje
  en een uniek placeholder-PNG (`build/images/block-{planeet}-{kleur}.png`).
  Tim kan die bestanden zelf vervangen; de namen blijven gelijk. Te
  (her)genereren met `python3 scripts/gen_planet_blocks.py`.
- Planeetkeuze komt vóór solo-spel (`Spelen` opent de kiezer) en in de
  lobby (iedereen kiest zelf; zichtbaar voor de anderen). De keuze wordt
  onthouden in `localStorage` (`meteors-planet`). Na de start van een
  wedstrijd kun je niet meer wisselen.

## t1104 — 1:1-slepen en spontane raketten

- Oorzaak van de sleepbug: `moveDrag` werkte met een opgetelde
  pointer-delta en een drempel van `SWAP_DISTANCE` (0,25 tegel). Een
  klein stukje sleep deed daardoor al een hele tegel, en één grote
  `pointermove` (typisch op touch) kon de rest van de kolom aflopen —
  precies “meestal gelijk helemaal omlaag of omhoog”. De doelrij was
  niet de rij onder de vinger, dus als de vinger stopte kon het blokje
  al aan de top of de bodem zitten. Daarnaast liep de pointer-mapping
  via `canvas.width` / `app.tile`, wat deltas zou vermenigvuldigen met
  de devicePixelRatio als de backing-store en de CSS-maat ooit
  uit elkaar lopen.
- Nu: de doelrij is `floor(pointerY)`, geklemd op de still-stapel van
  de kolom. `swapToward` wisselt stap voor stap met elke buur, en stopt
  precies daar. Als de pointer stilstaat, beweegt er niets meer.
  Optrekken-boven-de-top om te lanceren blijft. Coordinaten komen uit
  `getBoundingClientRect` en de veldgrootte (10×13), zonder
  canvas-backing of `app.tile`.
- Spontane rijen (na vallen, settle/recolor, cargo-attach op een
  vliegende cluster, cluster-merge) worden altijd raketten, net als
  wanneer de speler ze maakt. In een al vliegende cluster geeft dat
  een extra sprong vanaf de huidige positie (`checkChainRelaunch`,
  dezelfde hoogte als bij een player-push). Mid-air hangend cargo na
  recolor valt nog steeds vanuit stilstand (t1102), geen launch.

## t1105 — getoonde Power omgekeerd

- Alleen de weergave. Gameplay `power()` en `missChance()` zijn
  onveranderd (`miss = 0,60 − 0,55 × power`). Getoonde Power =
  `1 − missChance / 0,60`, afgerond als percentage, in JS
  (`Planet.displayValues` / `formatStats`) en PHP (`Planets::displayValues`),
  dus op de planeetkiezer, in de HUD en in de lobby. 0 % miss is 100 %
  Power; Aurel 0 %, Terra 44 %, Cinder 92 %.


## t1106 — touch is leidend bij een echte aanraking

- De Playwright-tests van t1104 waren circulair: ze rekenden `field_to_client`
  met dezelfde CSS-rectformule als `fieldFromEvent`, dus ze konden de bug
  op Tims echte telefoon niet reproduceren. Onderzoek met CDP-touch op
  emulated Android (DPR 2,625/3), live site, URL-balk-resize, pointercancel
  en vallende kolommen liet zien dat correcte CSS-coördinaten wél 1:1
  blijven. De echte fout zat in de gebeurtenissen zelf.
- Op mobiel kan `PointerEvent.clientX/Y` tijdens een touch verkeerd zijn
  (onder andere bij een gezoomde visual viewport), terwijl
  `TouchEvent.changedTouches` de juiste plek houdt. Een reeks
  `pointermove`s die naar een ander veld-Y interpoleren, liep daardoor de
  hele kolom af — precies “één vakje slepen, blokje helemaal naar boven
  of beneden”.
- Aanvullend: `preventDefault` op een PointerEvent houdt op veel mobiele
  browsers het touch-scrollen niet tegen (daarvoor is een niet-passieve
  `touchmove` nodig). `setPointerCapture` eindigt daar vaak in
  `pointercancel`. `layout()` draaide elke frame en kon het canvas
  midden in een sleep verplaatsen (URL-balk).
- Oplossing: zolang een echte `touchstart` is binnengekomen
  (`app.activeTouchId`), zijn Touch Events leidend. `pointermove` /
  `pointerup` / `pointercancel` worden dan genegeerd. Als er geen
  TouchEvent komt (pointer-only touch, zoals sommige Playwright-paden),
  blijven de pointer-events gewoon werken. Document-listeners voor
  touch staan tijdens het spel op `{capture:true, passive:false}` en
  roepen `preventDefault` aan. Geen `setPointerCapture`. `pointercancel`
  en `touchcancel` beëindigen de sleep zonder lancering. `layout()`
  bevriest zolang er een sleep loopt en `layoutIfNeeded` slaat over als
  de viewport niet veranderde. Canvas heeft `touch-action:none` en
  `position:fixed`; `html,body` hebben `overscroll-behavior: none`.
- Debug: `?debug=drag` of `localStorage.meteors-debug-drag=1` toont een
  overlay (`#drag-debug`) met fase, event, bron, fieldY, doelrij, blockY,
  launch-intent, touchId en pointerId.
- Regressietest: vergiftigde `pointermove`s naar fieldY 9,5 plus
  correcte `touchmove`s naar 1,5 laten het blokje op y=1 staan, niet
  op de top. Die test faalde op het oude pointer-only pad.

## t1107 — slepen onder een vliegende cluster en door een gelande

- `isColumnStill` blijft streng (false zodra er iets vliegt, valt of
  settlet in de kolom). Alleen het sleep-pad gebruikt
  `columnAllowsDrag` (`!isColumnLocked`) en `isDraggableBlock`.
- Blokjes die stil of settlend op de grond staan, zijn sleepbaar, ook
  als er in dezelfde kolom een vliegende cluster boven hangt. De
  vliegende cluster zelf is niet sleepbaar: in Meteos speel je op de
  grond, raketten in de lucht herschik je niet.
- Een gelande cluster (fase `landed`: grijze raketblokjes en gekoppeld
  cargo, state SETTLING) is wél sleepbaar, zolang de kolom een
  aaneengesloten stapel is (geen gat). `swapToward` stopt bij een gat.
  Hangende leden (SETTLING telt als grounded) horen bij de stapel-top.
- Van plaats wisselen *binnen* dezelfde gelande cluster verandert alleen
  de posities. Een blokje *uit* de cluster wisselen haalt het eruit:
  een grijs blokje blijft settlen op zijn eigen resterende timer en
  recolored alleen; gekleurd cargo wordt STILL als het steun heeft,
  anders FALLING. Een blokje *in* de cluster wisselen krijgt dat
  `clusterId`, wordt SETTLING en `flame` uit. Een grijs blokje dat
  instapt met `settleTime` 0 kan de groeps-release vertragen tot zijn
  eigen 3 s om is. Lidmaatschap wordt pas ná de join van de ander
  gewist, zodat `leaveCluster` een nog niet-lege cluster niet verwijdert.
- `startManualLaunch` roept eerst `leaveCluster` aan, zodat een gooien
  vanuit een gelande groep het blokje losmaakt.

## t1108 — een gegooid blokje botst met vallende blokjes

- Een handmatig omhoog gegooid blokje (state MANUAL) botst met vallende
  blokjes op dezelfde manier als twee vliegende clusters: ze smelten
  samen tot één vliegende cluster. Snelheid, vertraging en spronghoogte
  zijn het massagemiddelde per blokje (zelfde regel als
  `mergeClusterGroup`). Een stapel aaneengesloten vallende blokjes
  gaat in één keer mee.
- Ze kunnen elkaar in één substep niet kruisen: zowel `integrateManual`
  als `integrateFalling` kijken naar het hele pad van die stap
  (swept overlap) en mergen vóór de posities elkaar passeren.
  `packClusterOverlaps` legt ze naast elkaar.
- De cluster krijgt `fromManual: true`. Vallend cargo dat daarna op
  zo'n cluster landt, wordt óók middeled (niet alleen “meegepakt” met
  de clustersnelheid). Gewone match-raketten houden de oude regel:
  cargo neemt `cluster.vy` over, zonder middelen. Dat pad is
  onveranderd.
- De spronghoogte van de worp wordt bij lancering bewaard als
  `manualJumpHeight`, zodat de merge die kan middelen.

## t1109 — pakken per rooster-cel, niet per sprite

- Hit-testing keek naar de afstand tot de simulatie-rechthoek van het
  blokje, met een drempel. Visueel staan sprites vaak iets naar binnen
  (padding, bounce, scale, tween), en de speler moest precies op de
  getekende sprite drukken.
- Nu: de druk wordt een cel `floor(col)`, `floor(y)`. Elke druk binnen
  die cel — hoeken, kieren tussen sprites, een visueel verschoven
  sprite — pakt het blokje dat die cel inneemt. Dat gebruikt
  simulatiecellen, niet de getekende bounds (tweens blijven view-only).
- Staat er geen blokje in die cel (midden in een animatie, y niet
  geheel), dan de dichtstbijzijnde sleepbare in dezelfde kolom binnen
  een halve tegel (`SNAP_Y = 0,5`). Alleen als de primaire cel leeg is
  en de druk dicht bij de rand zit, geldt nog een kleine horizontale
  slop naar de buurkolom. Lanceren-door-optrekken blijft.

## t1110 — match na landing van een cluster, en grotere vlammen

- Als een vliegende cluster landt en samen met al liggende blokjes een
  geldige rij vormt (3 of meer dezelfde kleur, horizontaal of
  verticaal), telt dat als een match en worden het raketten.
- Aanname: grijze raketblokjes hebben geen kleur en doen niet mee aan
  een match zolang ze grijs zijn. Gekleurd cargo in de gelande cluster
  (SETTLING) is wél matchbaar, meteen bij de landing, ook in een
  gemengde rij met al stilliggende blokjes. Zodra de grijze blokjes
  recoloren en de groep wordt losgelaten, geldt hetzelfde voor die
  nieuwe kleuren: een gemengde rij met rustende buren lanceert in
  dezelfde tick.
- `findMatchLines` neemt daarom STILL én SETTLING mee, zolang
  `color >= 0`. Grijze SETTLING (geen kleur) blijft uitgesloten.
- De vlam onder raketten is 3× zo groot, in lengte én breedte
  (`0,85 × 3` tegels). De bovenkant van de vlam blijft op dezelfde
  overlap in het blokje; de extra lengte steekt naar beneden uit.

## t1111 / t1112 — schot in een cluster, en physics-audit

- Zie `docs/PHYSICS.md` voor de volledige lijst van gevonden oorzaken
  (video `t1111.webm`) en de herschreven regels.
- Schot in een vliegende cluster: de geraakte kolom 1 cel omhoog, het
  schot sluit onderaan aan, rooster-uitgelijnd, als lid. Elke volgende
  worp hetzelfde. Vliegende clusters zijn één star lichaam (één `y`/`vy`,
  gehele offsets). Geen twee blokjes delen een cel of overlappen;
  volgorde in een kolom blijft; verdwijnen/dupliceren/kleur veranderen
  alleen via de bekende regels (match → grijs, grijs recolor, of
  scoren over de bovenkant).
- `?debug` (of `?debug=physics` / `?debug=drag`) zet de
  invariant-checker aan en toont overtredingen in de overlay.

## t1119 — Offline Strijd, en +50 % spronghoogte

- **Offline Strijd** is een knop op het hoofdmenu. Het speelt als
  multiplayer (zelfde schoten, miss-kans van jouw planeet, zichtbare
  tegenstandervelden), maar volledig client-side tegen lokale bots.
  Geen server, geen login.
- De speler kiest zelf een planeet (dezelfde kiezer als solo). Elke
  bot krijgt altijd een willekeurig veld en een willekeurige planeet
  uit de catalogus.
- Progressie, tot de speler verliest: **1 tegenstander voor 1 ronde**;
  daarna **N tegenstanders voor N−1 rondes** (N ≥ 2). Dus: ronde 1 → 1
  bot; ronde 2 → 2 bots; ronde 3–4 → 3 bots; ronde 5–7 → 4 bots; enz.
  Na een gewonnen ronde (alle bots uitgeschakeld, dezelfde winconditie
  als multiplayer) volgt de volgende ronde met een vers veld. Na verlies
  een eindscherm met de bereikte ronde (de ronde waarin je verloor) en
  terug naar het menu.
- Bot-skill start op **5 %** in ronde 1 en stijgt **1 % per ronde**,
  met een plafond van 100 %. De HUD toont ronde, aantal tegenstanders
  en skill.
- Skill-mechaniek: elke 0,5 s dobbelt elke levende bot. Als
  `roll < skill` mag hij één blokje verticaal in een kolom verplaatsen,
  zo ver als nodig is om een match te maken, mits zo'n zet bestaat
  (kortste zet, daarna laagste kolom / fromY / toY). Anders doet hij
  die tick niets. Bots gehoorzamen verder normale fysica, inclusief
  landing-chain, schoten en miss-kans van *hun* planeet.
- Mini's zijn klein (kleiner naarmate er meer bots zijn) en worden
  maximaal 10 keer per seconde getekend, zodat veel botvelden op mobiel
  blijven lopen.
- **Minimum spronghoogte +50 %** (t1119, alle modes, ook bots):
  `baseJumpHeight = 1,5 × FIELD_HEIGHT / jumpsToClear`. Verticale en
  extra-blok-bonussen blijven relatief hetzelfde (120 %, +5 %). De
  omhoog-snelheid volgt daaruit via de bestaande `launchVelocity` /
  `launchDeceleration` (massa / `riseTime` onveranderd). De PHP-server
  berekent geen spronghoogte; die fysica leeft in `planet.js`, gedeeld
  door solo, online-client en Offline Strijd. De miss-kans-formules
  (Power) zijn onveranderd.

## t1120 — landing-chain sprongbonus

- Als een cluster landt en die landing **direct** een match maakt
  (gekleurd cargo in dezelfde tick, of na recolor van de grijzen in
  dezelfde landing), is die lancering **25 % sterker**.
- Valt het cluster opnieuw en maakt de volgende landing weer een
  match, dan komt er weer **+25 %** bij. De keten is **additief**:
  stap 1, 2, 3, … → ×1,25, ×1,50, ×1,75
  (`1 + 0,25 × chain`), niet multiplicatief (niet 1,25³).
- De teller hoort bij het cluster. Hij gaat naar 0 als het cluster
  verdwijnt (scoort over de bovenkant, of oplost) of landt **zonder**
  match. Mid-lucht-matches (keten-herlancering) gebruiken de bestaande
  spronghoogte en wijzigen de teller niet. Geldt voor grond- én
  stapellandingen, en voor bots. Een klein HUD-label toont
  `x2 +50%` (keten en totale bonus).

## t1121 — visuele wissel-tween

- Als twee blokjes van plaats wisselen (spelersleep én bot-zetten),
  animeert het **verplaatste** blokje naar zijn nieuwe cel in **100 ms**
  met `easeOutCubic` (in het gevraagde bereik 80–120 ms).
- Puur visueel: de simulatie en het rooster zijn meteen bijgewerkt,
  de invariant-checker ziet alleen de logische posities.
- Het vastgehouden (gesleepte) blokje volgt de pointer, zonder tween.
- Bij snelle opeenvolgende wissels start een lopende tween opnieuw
  vanaf de huidige visuele y, zodat er niet wordt gesnapt.

## t1122 / t1124 — alleen de cluster-zweef naar beneden is gehalveerd

- Tim bedoelde met „daalsnelheid” alleen hoe een cluster na zijn sprong
  weer omlaag zweeft (t1124). Nieuwe blokjes die het scherm in vallen
  waren al goed en gaan weer op de oude snelheid:
  `fallSpeed = FIELD_HEIGHT / fallTime`. Hetzelfde geldt voor
  losgelaten of ongesteunde losse blokjes en gevallen cargo, tenzij ze
  lid zijn van een dalende cluster (dan zweven ze mee).
- Alleen de post-apex-zweef van een **vliegende cluster** is gehalveerd
  (alle modes, inclusief bots):
  `clusterFallSpeed = 0,5 × FIELD_HEIGHT / fallTime`. De relatieve
  verschillen tussen planeten (omgekeerd evenredig met `fallTime`)
  blijven. Een handmatige sprong (omhooggetrokken blokje) daalt op de
  volle `fallSpeed`.
- De apex-ease van die clusterzweef duurt nog steeds
  `0,15 × fallTime`; `clusterFallAccel` schaalt mee met de gehalveerde
  eindsnelheid. Bounce-duur is onveranderd (`0,12 × fallTime`).
  Omhoog-lancering is onveranderd, behalve de aparte +50 % spronghoogte
  van t1119. `fallTime` in de catalogus en in de Power-formule blijft
  hetzelfde getal (1–5).

## t1123 — rode puls bij volle kolommen

- Een kolom die **minstens 10 van de 13 rijen** gevuld heeft (net
  boven 70 %) pulst rood, als een vloeiende sinus-alpha (ongeveer
  0,55 Hz, alpha 0,16–0,44) **achter** de blokjes.
- Geteld worden alleen rustende blokjes: `still`, `settling` en
  `locked`. **Vliegende, vallende en handmatig gelanceerde** (in de
  lucht) blokjes tellen niet mee: die zijn tijdelijk en zouden de
  waarschuwing laten flikkeren.
- Geldt voor het veld van de speler én voor tegenstander-/bot-mini's
  (zelfde puls-klok). Rendering is goedkoop: tien quads op het
  hoofdveld, één `fillRect` per waarschuwingskolom op de mini-canvas.

## t1125 — mini's links/rechts en boogjes tussen velden

- **Breed scherm:** als er aan weerszijden van het geschaalde veld
  genoeg marge is voor minstens één mini (eventueel een kleinere)
  én de tegels minstens 18 px blijven, staan de tegenstanders
  **naast** het veld. Alleen écht smalle of staande vensters
  (korter dan 700 px breed, of staand onder 850 px) houden de rij
  boven het veld (t1131). Geen harde 960 px-drempel: een kort
  liggend venster zoals 1024×532 met 3 bots is dus sides.
- **Plaatsing (t1127, t1133):** mini's worden aan de **buitenrand**
  van het scherm verankerd en vullen naar binnen, richting het veld.
  Volgorde: 1e links buiten, 2e rechts buiten, 3e links één stap
  naar binnen, 4e rechts één stap naar binnen, enzovoort. De
  onderste rij sluit aan op de onderkant van het veld. Eerst wordt
  een rij horizontaal volgelegd; pas als er aan die kant geen
  kolom meer bij past, komt er een extra rij naar boven (weer
  beginnend aan de buitenrand). Mini's worden kleiner als gestapelde
  rijen anders in de HUD zouden lopen. Het veld gebruikt de volle
  hoogte onder de HUD plus de boog-padding (`miniH = 0`).
- **Smal scherm / telefoon:** de bestaande layout blijft: mini's in
  een wrappende rij boven het veld.
- **Boogjes** zijn puur visueel. De vluchttijd blijft 1,2 s, gelijk
  aan de bestaande aflevering (`deliver_at` / Offline `_deliver`).
  We vertragen de gameplay-aflevering níét: een late poll stapt
  mid-arc in via de server-`age` (seconden sinds `created`). Als de
  vlucht al voorbij is (`age ≥ duration`), tekenen we geen inhaalboog;
  de incoming is dan al op schema afgeleverd.
- Vorm: een parabool in schermcoördinaten,
  `x = lerp`, `y = lerp − 4·h·t·(1−t)` (y groeit naar beneden).
  Booghoogte `h` is 0,28 × afstand, geklemd tussen 48 en 220 px,
  met ease-in-out-cubic. Hits van vijand→speler schalen van mini-tegel
  naar volle tegel; speler→vijand andersom; vijand→vijand blijven
  klein. Missers hergebruiken de bestaande fade-en-wegvlieg-animatie;
  vijand-missers starten kleiner (mini-schaal).
- Vijand→vijand (bot-bot of remote-remote) worden in `#flights-back`
  getekend (z-index 5, onder `#flights` z-index 6). Een CSS
  `clip-path` spaart het rechthoek van het spelersveld uit, zodat
  die blokjes achter het veld langs gaan, niet ervoor. Ze blijven
  zichtbaar in de zijmarges.
- Online ziet elke client alle recente schoten via `shot_flights`
  op de poll (`from_id`, `target_id`, `miss`, `age`,
  `flight_duration`). Eigen `shot_results` blijven bestaan; de
  client de-dupliceert op id. Extra velden zijn backward compatible.
- Performance: alleen CSS-transforms, één tick per frame, beelden
  verdwijnen na 1,2 s. Geen pooling nodig voor tientallen bots.

## t1126 — boogje eindigt in de kolom waar het blok verschijnt

- De landingskolom (`land_col`) wordt gekozen **bij het begin van de
  vlucht**, niet pas bij aflevering, en dezelfde waarde geldt voor
  het eindpunt van de boog én voor `ingestGarbage`.
- Offline: bij het afvuren kiest het doel-veld een open kolom
  (`pickGarbageColumn`); die zit op het flight-resultaat en op de
  pending delivery.
- Online: de server kiest `land_col` (0–9) bij `recordShots`, slaat
  het op bij het schot, en stuurt het mee in `shot_results`,
  `shot_flights` en `incoming`. Een late poll of mid-arc (`age`)
  ziet dus dezelfde kolom. De client onthoudt `land_col` ook zelf
  (`_pendingLandCol`) als vangnet.
- Als de gekozen kolom bij aflevering niet meer open is (vol of
  vergrendeld in de 1,2 s vliegtijd), valt `ingestGarbage` terug op
  een andere open kolom. Dat is zeldzaam; dan kan de boog van de
  echte kolom afwijken.
- Speler→vijand en vijand→vijand richten óók op `land_col`: het
  eindpunt is de bovenkant van die kolom op de mini van het doel
  (makkelijk, zelfde veld).

## t1128 — vijand↔speler-boogjes gaan om het veld heen

- Boogjes tussen een vijand en het veld van de speler (beide
  richtingen) mogen **niet over het binnenveld** bewegen. Het pad
  gaat eerst omhoog aan de buitenkant, dan over de bovenrand, en
  buigt pas daar de doelkolom in. Het eindpunt blijft de bovenkant
  van `land_col`.
- Als begin- en eindpunt al boven de bovenrand liggen (smalle
  layout, mini's boven het veld) is een gewone parabool genoeg:
  die blijft vanzelf boven het veld.
- Vijand→vijand blijft een kleine parabool **achter** het veld
  (`#flights-back` + clip-path), onveranderd.

## t1129 — padding boven het veld in de brede weergave

- Alleen in de **brede** (sides) layout krijgt het veld extra ruimte
  bovenin (`ARC_TOP_PAD` = 100 px tussen HUD en veld, tegels iets
  kleiner indien nodig) zodat de omweg-boogjes over de bovenrand
  passen. Smal en mobiel blijven onveranderd (mini's boven het veld,
  geen extra pad).

## t1130 — raak-schoten zijn visueel grijs

- Wat de ontvanger binnenkrijgt is altijd een grijs vuilblok
  (`ingestGarbage`). Daarom worden **alle raak-schoten** — vijand→
  speler, speler→vijand en vijand→vijand — als grijze blokjes
  getekend (`images/block-gray.png`), niet in de kleur van de
  schutter. Zo komt het boogje overeen met wat er landt.
- Missers houden de kleur van de schutter: daar wordt niets
  ontvangen, het blokje vliegt weg en vervaagt zoals voorheen.

## t1127 / t1131 / t1133 — mini's van de rand naar binnen, horizontaal eerst

- Tim wilde eerst horizontaal plaatsen en pas verticaal stapelen als
  de marge vol is (t1127), en de mini's „uitgelijnd van ons veld
  weg” (t1131 / t1133): verankerd aan de **buitenrand** van het
  scherm, elke volgende op die kant één stap verder naar het veld
  toe. Dat is het omgekeerde van „eerst tegen het veld, dan naar
  buiten”.
- Bij 8 tegenstanders past één rij op 1400×900 en 1920×1080; op een
  smaller breed scherm (bijv. 1280×900) wrapt de vierde per kant
  naar een rij daarboven, opnieuw aan de buitenrand.
- De drempel voor sides is versoepeld (t1131): zodra er een mini
  naast het veld past — ook een kleinere — kiezen we sides, ook in
  een kort liggend venster (1024×532, 3 bots). Boogjes vertrekken
  vanaf de **bovenkant** van de mini, gaan omhoog en in een ruime
  boog over de bovenrand naar de landingskolom, niet over de mini's
  of over het binnenveld.

## t1134 — soepele boogjes, en écht uit het veld vliegen

- De oude polyline met hoekpunten (omhoog, horizontaal, omlaag) is
  vervangen door een **C¹-ketting van kubische Béziers**: omhoog
  uit de lanceerkolom (of langs de buitenkant), een vloeiende
  kwart-draai, een rechte kruising boven het veld, en een vloeiende
  duik de landingskolom in. Raaklijnen en snelheid sluiten aan de
  gewrichten naadloos aan — geen zichtbare hoeken, geen ruk in het
  tempo. `easeInOutCubic` (snelheid 0 aan begin en eind) is voor
  raak-schoten verdwenen; `smoothParam` houdt aan de uiteinden een
  niet-nul snelheid.
- Speler↔vijand gaat nog steeds om het veld heen en mag alleen de
  **lanceer- en landingskolom** gebruiken, niet het binnenveld.
  Vijand→vijand blijft een kleine soepele boog achter het veld.
- Een uitgaand schot start op de **echte exit-pose** van de raket
  (zelfde positie en formaat, `fieldToViewport` met het
  +0,5-tegel-midden, `y ≥ 13`). De boog gaat vanaf daar omhoog
  verder, zonder pop-in boven het veld. (De vroege overname bij
  `y ≳ 11,6` is in t1137 teruggedraaid.)

## t1135 — soepel het veld invliegen, naadloze overdracht

- De boog duikt **de landingskolom in** en eindigt op de
  spawn-pose van `ingestGarbage`: `y = 13` (een halve tegel boven
  de canvasrand), volle tegelgrootte, raaklijn recht naar beneden.
  De eindsnelheid is afgestemd op `fallSpeed` van de planeet, zodat
  het vallende grijze blok dezelfde positie, grootte en snelheid
  overneemt — geen pop-in aan de bovenkant. Offline levert
  `battle.tick` het blok eerst af en verwijdert daarna de vlucht
  (één frame overlap op dezelfde pose).
- Aankomst bij een vijand-mini gaat het blokje iets **de mini in**
  (`y = 12` in de landingskolom, op mini-formaat). Er is geen live
  vallende sprite op de mini; het volgende snapshot toont het cel.

## t1136 — multiplayer ziet er hetzelfde uit als Offline Strijd

- Online en offline delen dezelfde presentatie: `MiniLayout`
  (buitenrand, horizontaal eerst, onder uitgelijnd, `ARC_TOP_PAD`),
  `Online.spawnFlights` / `tickFlights` (C¹-bogen om het veld,
  `land_col`, grijze raak-schoten, uitvliegen vanuit de cel,
  invliegen naar de spawn-pose, vijand→vijand achter het veld) en
  dezelfde startregel voor de lokale raket (pas bij het echte
  schot, `y ≥ 13`).
- De server bewaart nu ook de **lanceercel** (`from_col`, `from_y`)
  en stuurt die mee op `shot_results` en `shot_flights`, zodat een
  andere client het blokje uit de juiste cel van de mini ziet
  vertrekken (niet vanaf een vast punt boven de mini). Zonder
  lokale `startX` (typisch voor een remote poll) gebruikt
  `spawnFlights` die `col`/`y`.
- Geverifieerd met Playwright: lokale PHP-server, test-auth,
  twee Playwright-clients in een echte lobby (lokale PHP-server met test-auth), daarna `shot_flights` via
  `Online._handleTransitions` (het echte poll-pad) op 1920×1080
  en 1024×532, plus dezelfde bogen in Offline Strijd (early/mid/
  late en een korte webm).

## t1137 — pas een boogje als het blok echt het veld verlaat

- Tim zag raketten die net niet hoog genoeg gingen een boogje
  maken, het veld uit en weer in, omdat de visuele overname al bij
  `y ≳ 11,6` (met `vy > 0`) begon. Een raket die daar piekt en
  terugvalt is nog van het veld en mag geen boog krijgen.
- Een vlucht start **alleen** bij het echte schot, hetzelfde moment
  als `cullOffTop`: `y ≥ 13` (hoogte van het veld). Dat geldt voor
  het spelersveld, vijand-mini's, offline en online.
  `Online.hasLeftTheField` en `previewExit` weigeren alles daaronder.
  De overdracht blijft naadloos: start op de exit-pose, volle
  grootte, raaklijn omhoog, daarna de soepele boog naar het doel.
- Een raket die onder de rand piekt produceert geen `outgoingShot`
  en geen vlucht; een raket die `y ≥ 13` kruist precies één schot
  en één vlucht, beginnend op die exit-pose.

## t1138 — één grote, vloeiende ballistische boog

- Tim vond de bogen na t1134–t1137 al beter, maar wilde ze nóg
  vloeiender: geen ketting van stukjes (kwart-draai, rechte
  kruising op de top, duik) maar één grote, ronde, doorlopende
  curve, als een ballistische parabool.
- Speler↔vijand is nu **één enkele Bézier van graad 7** (één
  polynoom, dus C^∞ op (0, 1)): start op de exit-pose (`y = 13`,
  raaklijn recht omhoog), een ruime ronde kroon **boven** het veld
  (mag hoger — we gebruiken de top-padding ruim, apex zo'n 150 px
  boven de veldrand), en een duik de `land_col` in, recht naar
  beneden, met een eindsnelheid afgestemd op `fallSpeed`. Het
  binnenveld wordt nooit gekruist: horizontaal verkeer zit op de
  top, verticaal alleen in de lanceer-/landingskolom of buiten het
  veld. Geen rechte cruise, geen zichtbare knikken; de kromming
  verandert geleidelijk. De parameter loopt over de **booglengte**
  (arc-length) met een zachte Hermite-easing, zodat de snelheid
  langs het pad glad is en de aankomst bij `fallSpeed` past.
- Vijand→vijand krijgt dezelfde soepele parabool, getekend achter
  het veld (`#flights-back`, clip-path). De startregel van t1137
  (`y ≥ 13`) en de grijze raak-schoten blijven ongewijzigd.
- Unit-tests toetsen krommingscontinuïteit, maximale
  krommingsverandering, geen lange rechte middenstukken, verticale
  uiteinden, corridors, en de fallSpeed-overdracht. Playwright
  legt early/mid/late vast op 1024×532 en 1920×1080, plus een
  webm van beide formaten.


## t1139 — Planeetontwerper

- De ontwerper is alleen beschikbaar op het hoofdmenu, en alleen als
  je bent ingelogd. Tot de live OAuth-callback en het CI-geheim
  `auth_client_secret` zijn ingericht, is dat op productie onzichtbaar.
  Lokaal kun je inloggen met `auth.php?test=1` (of `test=2`).
- Levenslange punten staan in het server-profiel (`profiles`). Alleen
  ingelogde spellen tellen mee. Bots leveren geen punten op.
  - **Spelen** (solo): de score aan het einde van het spel.
  - **Offline Strijd**: de score van **elke ronde**, gewonnen of
    verloren, omdat de score per ronde opnieuw begint.
  - **Online**: de server kent de score via de poll; punten worden
    toegekend bij uitschakeling of als de lobby klaar is, één keer per
    `online:{lobbyId}:{userId}`. De client kan hier geen punten
    insturen.
- Anti-cheat voor solo/offline: `play_begin` geeft een eenmalig token
  (geldig 6 uur). `play_finish` klempt de score op 0–10000, weigert
  een positieve score als het spel korter dan 3 seconden duurde, en
  laat maximaal 4 punten per seconde door. Herhaalde finishes van
  hetzelfde token zijn een no-op. Overduidelijk valsspelen wordt
  geklemd, niet keihard verboden, zodat een trage verbinding geen
  eerlijke score weggooit.
- Het blokjesregister (`server/lib/blocks.json`) is append-only: de
  volgorde ligt nu vast. Eerst Terra's vijf (gratis), daarna 43 nieuwe
  icoontjes (eerste, Fehu, op 500 punten; daarna telkens 14,5 % meer,
  afgerond en strikt stijgend — de laatste icoon zit rond de 147 000
  punten), daarna de 55 kleuren van de officiële niet-Terra-planeten
  als lange staart (de laatste zit in de honderden miljoenen). Punten
  zijn een **eis**, geen uitgave. Officiële planeten blijven hun eigen
  blokjes gebruiken zonder ontgrendeling; ontgrendelen is alleen voor
  de ontwerper.
- Een speler mag tot 30 eigen planeten hebben. Id's zijn `c_` plus
  16 hex-tekens. Namen (planeet en volk) zijn 1–32 tekens, zonder
  tags. De vijf blokjes moeten verschillend en ontgrendeld zijn.
- Nieuwe blokjes-plaatjes staan in `build/images/block-*.png`, 64×64,
  in dezelfde stijl als Terra (gekleurde silhouet, donkere omtrek,
  highlight, slagschaduw). Gegenereerd door
  `scripts/gen_unlock_blocks.py`.

## t1140 — Eigen planeten in elke modus

- In Spelen, Offline Strijd en Online Spelen toont de planeetkiezer
  naast de officiële catalogus ook **je eigen** ontworpen planeten
  (badge "Eigen"). Planeten van anderen staan daar niet in.
- Voor Online stuurt de client alleen het planeet-id. De server
  controleert eigendom, legt een **snapshot** (`planet_json`) vast bij
  kiezen/aanmaken/joinen, en stuurt de volledige configuratie
  (variabelen, kleuren, `miss_chance`) mee in de lobby. Tegenstanders
  onthouden die snapshot om fysica, miss-kans en sprites te simuleren;
  een latere wijziging of verwijdering verandert een lopend spel niet.


## t1141 — taalkeuze (i18n)

- De standaardtaal is **Engels**, ook als de browser op Nederlands staat.
  Er is geen automatische detectie van de browsertaal.
- De keuze staat in `localStorage` (`meteors-locale`) en in een cookie
  (voor de inlogpagina’s). Ben je ingelogd, dan wordt ze ook in het
  serverprofiel bewaard (`set_locale`). Bij inloggen wint de
  profieltaal; is die nog leeg, dan wordt de lokale keuze naar de
  server geschreven.
- Vlaggen zijn lokale SVG’s in `build/images/flags/` (geen emoji).
  Engels gebruikt de vlag van het Verenigd Koninkrijk, Chinees die van
  de Volksrepubliek (vereenvoudigd Chinees), Koreaans die van
  Zuid-Korea.
- Officiële planeetnamen (Terra, Aurel, …) blijven eigennaam;
  bevolkingsnamen en blokjesnamen zijn vertaald. Zelfgekozen namen van
  eigen planeten blijven ongewijzigd.
- Serverfouten blijven in het Nederlands in de API (bestaande tests);
  de client vertaalt bekende meldingen naar de actieve taal.
- CJK-tekst gebruikt systeemfonts (Hiragino, PingFang, YaHei, Malgun
  Gothic, Noto Sans CJK, …) als fallback. Knoppen mogen wrappen zodat
  langere vertalingen (Duits, Nederlands) niet over de rand lopen.


## t1143 — leeg speelscherm na inloggen

- De live-screenshot (HUD “PUNTEN 0” en “Terra”, geen veld, wel sterren)
  kwam doordat `new Scene` “WebGL is not supported” gooide *nadat* de
  HUD al zichtbaar was met de standaard-HTML (“Terra”, score 0). De
  Scene-constructor plaatst eerst een transparant canvas en initialises
  daarna WebGL; bij een blocklist blijft dat canvas leeg en schijnt het
  sterrenveld erdoorheen. In de page-console staat die fout, in het
  Chrome-GPU-log “WebGL1 blocklisted”.
- Dat is geen fout in de planeetkeuze, `?online=1`, i18n of `play_begin`.
  Dezelfde flow (inloggen, Back, Nederlands, eigen planeet “Testplaneet
  Ada”, Spelen) toont het veld en de juiste HUD-naam zodra WebGL
  beschikbaar is (o.a. met SwiftShader). Uitgelogd solo op live ook.
- `startPlay` toont de HUD nu pas ná een geslaagde scene, vangt een
  WebGL-fout, ruimt wees-canvasses op en toont een melding op het menu.
- Solo-game-over roept `play_finish` aan; verdiende punten gaan bij een
  ingelogde speler naar het levenslange totaal (anti-cheat: o.a. min. 3 s
  bij score > 0, max. 4 punten/s).


## t1144 — bots kijken 1 of 2 zetten vooruit

- Alleen in **Offline Strijd**. Online is PvP: er zijn geen server-side
  bots, en die zijn ook niet toegevoegd.
- Als een bot zijn kansrol haalt (`roll < skill`) en er ligt al een
  match op het veld, doet hij niets (zoals in t1119) en vergeet hij
  een eventueel onthouden plan.
- Anders zoekt hij eerst een **onmiddellijke** match: dezelfde kortste
  verticale zet als in t1119 (daarna laagste kolom / fromY / toY). Die
  gaat altijd voor, ongeacht de skill.
- Is er geen onmiddellijke match, dan kan hij tot **diepte 2** zoeken:
  een eerste verschuiving die zelf geen match maakt, maar een tweede
  mogelijk maakt. Hij voert alleen de eerste zet van het beste plan uit
  en onthoudt de rest (`bot.plan`).
- Het **beste** plan is dat met de kleinste som van de twee afstanden,
  dan de kortste eerste zet, daarna dezelfde kolom/fromY/toY-volgorde
  als t1119 (eerst voor de eerste zet, dan voor de tweede).
- Op de volgende geslaagde rol volgt hij de onthouden tweede zet als
  die nog legaal is en (als laatste stap) nog een match maakt — ook
  als de skill dan te laag is om een *nieuw* plan te starten. Een
  gevolgde zet vereist nog steeds een gewonnen rol die tick. Is het
  plan ongeldig geworden, dan plant hij opnieuw (eerst onmiddellijk,
  dan eventueel een nieuwe setup).
- De kans om een **nieuw** 2-stapsplan te zoeken hangt van de skill af:
  **0 % bij skill ≤ 10 %** (rondes 1–6), daarna lineair naar **100 %
  bij skill ≥ 40 %** (ronde 36 en verder). Zo blijven vroege rondes
  makkelijk en worden late bots slimmer.
- De zoektocht blijft goedkoop op een veld van 10×13: alleen legale
  verticale zetten binnen aaneengesloten segmenten (geen sprong over
  een gat, geen vergrendelde kolom, geen enkel blokje alleen),
  apply+undo op één rooster, korte zetten eerst, stop bij het eerste
  1+1-plan (dat is door de sorteervolgorde al de winnaar), en een
  plafond van **4000** bord-evaluaties per tick. Als dat plafond wordt
  bereikt kan een zeldzame langere setup worden gemist.


## t1173 / t1174 — puntenscherm na een spel of ronde

- Alleen voor **ingelogde** spelers. Uitgelogd blijft alles zoals het
  was (game-over-overlay in solo, de oude vertraging tussen
  Offline-rondes, podium in Online).
- **Gewonnen of verloren:** Spelen (solo) eindigt altijd doordat je
  veld vol loopt, dus daar staat “You lost...”. Offline Strijd: een
  gewonnen ronde (alle bots uit) → “You won!”, verlies → “You lost...”.
  Online: plek 1 → “You won!”, anders “You lost...”. Teksten staan in
  alle tien talen (`reward.won` / `reward.lost`).
- **Volgorde:** de titel staat 1 s gecentreerd en schuift dan in 0,6 s
  naar boven. Pas als de server het nieuwe totaal heeft bevestigd
  begint het tellen: het getal onderaan start op het totaal vóór de
  ronde en elk aankomend blokje telt er 1 bij op, tot het nieuwe
  totaal. Bij 0 verdiende punten staat het getal kort (1,5 s) in beeld
  zonder blokjes. Aan het eind blijft het eindtotaal 1,5 s staan.
- **Tempo (t1174, i.p.v. een overslaanknop; aangepast in t1175, t1177 en t1178):**
  `rate = 15 + 10·t` blokjes/s (`RATE0 = 15`, `ACCEL = 10` in
  `src/reward.js`; t1174 had 5 + 1·t, t1175 5 + 3·t, t1177 10 + 5·t).
  Na t seconden zijn er `15t + 10t²/2` vertrokken; blokje i vertrekt op
  `t = (−15 + √(225 + 20i)) / 10`. Het laatste blokje vertrekt bij 253
  punten na ≈ 5,8 s, bij 800 na ≈ 11,2 s en bij 2000 na ≈ 18,6 s, plus
  0,7 s vlucht.
- **Prestaties (t1178):** aan het eind van 2000 punten gaan er ~200
  blokjes/s weg en zijn er ~140 tegelijk in de lucht. Gemeten in
  headless Chrome: desktop 1280×800 ~59 fps; mobiel 390×844 @3× met
  4× CPU-vertraging ~59 fps (p95 16,7 ms), ook met een lopend speelveld
  erachter. Eén 2D-canvas, geen DOM-element per blokje, dus geen extra
  begrenzing nodig. Er is **geen** overslaan-knop en
  geen sneltoets om meteen naar het eindtotaal te springen. Wel mag je
  tijdens die laatste 1,5 s (eindtotaal staat al) tikken/klikken of
  Spatie/Enter drukken om meteen door te gaan.
- **Bron van de getallen:** solo en Offline gebruiken het antwoord van
  `play_finish`: nieuw totaal = `lifetime_points`, start =
  `lifetime_points − awarded`. Online is er geen `play_finish`; de
  server kent de punten zelf toe bij uitschakeling/einde. Het start-
  getal is het profieltotaal bij de start van de wedstrijd, het
  eindgetal het totaal uit de poll die de wedstrijd als afgelopen meldt
  (de toekenning gebeurt in dezelfde transactie, vóór het antwoord).
  Antwoordt de server niet binnen 8 s of met een fout, dan wordt niets
  geteld en gaat het scherm na 1,5 s verder.
- **Blokjes:** willekeurig gekozen uit de vijf blokjes (plaatjes) van
  de planeet waarmee je die ronde speelde, ook bij eigen planeten. Ze
  starten op een willekeurige x net boven het scherm en volgen een
  kwadratische boog met een willekeurig controlepunt naar het getal.
- **Daarna:** solo → menu; Offline gewonnen → volgende ronde; Offline
  verloren → het bestaande resultaatscherm; Online → de lobby. Omdat
  de server de lobby na 5 s podium al terugzet, wacht de client met
  teruggaan tot het puntenscherm klaar is. Is de lobby dan nog niet
  terug, dan zie je de rest van het podium.
- **Techniek:** een DOM-overlay met één 2D-canvas voor de vliegende
  blokjes (geen extra WebGL-context), ~20 tegelijk in beeld, getekend
  via `requestAnimationFrame` (frames worden afgekapt op 0,1 s, dus een
  achtergrondtab springt niet). Werkt op desktop en mobiel. Bij
  `prefers-reduced-motion` vliegen er geen blokjes en springt de titel
  zonder animatie naar boven; het getal telt in hetzelfde tempo op.

## t1181 — vliegende blokken lokaal en vloeiend

**Oorzaak van het haperen.** De vlucht van een weggeschoten blok werd pas
gemaakt als de poll-response met `shot_results` terugkwam. Schoten wachtten
op de volgende poll (`setInterval`, 750 ms) plus de round trip, terwijl
`cullOffTop` het blok al had weggehaald: 140–740 ms niets, daarna verscheen
de vlucht ineens. De lokale preview (`previewExit`) bestond wel maar werd
nooit aangeroepen. Ontvangers lieten late vluchten halverwege de boog
beginnen (terugdateren met `age`).

**Oplossing (alleen presentatie, spellogica en payload ongewijzigd).**
- Zender: `Online.startLocalShot` start op het lokale clear-moment direct een
  vlucht (`previewExit`), uit `tickOnline`.
- `Online.flushShotsSoon` stuurt schoten meteen mee met een extra poll
  (minstens `FLUSH_MIN_GAP_MS` = 120 ms tussen polls, nooit twee tegelijk).
- Serverantwoord: dezelfde vlucht wordt via `retargetFlight` vanuit de
  huidige positie naar het echte doel gebogen, met de resterende duur.
- Is de server traag, dan wacht de preview bij de top
  (`PREVIEW_HOLD_MS` = 2500 ms) in plaats van te verdwijnen.
- Ontvanger: altijd de hele boog vanaf het veld van de zender, duur
  `max(50%, duur − age)` (`LATE_MIN_SHARE`).
- Animatie per frame met `requestAnimationFrame` op tijd (niet op poll/tick).

Tests: `test/flight-local.test.js`; browser: `test/t1181-flights-playwright.py`
(desktop-zender + mobiele ontvanger).

## t1182 — voorspelling op mini-velden

- `src/miniPredict.js` (`MiniPredict`): tussen twee snapshots vallen
  blokken met `state: 'falling'` verder met de valsnelheid van die speler
  (`13 / planet.fallTime`), met sub-cel posities.
- Nooit voorspeld: landen, vastzetten of lijnen wissen. Een voorspeld blok
  stopt bovenop het eerste obstakel in zijn kolom en wacht op de server.
- Snapshot krijgt `t` (zendertijd, ms, alleen visueel). De ontvanger zet die
  om naar de eigen klok met de kleinste waargenomen aankomst-offset
  (laatste 16), zodat een laat binnenkomende snapshot op het juiste moment
  wordt geplaatst. Dezelfde snapshot opnieuw = geen herstart.
- Bijsturen: achterlopend blok haalt in (`RECONCILE_S` = 0,16 s), een blok
  dat vooruitloopt valt even langzamer (50%) — nooit omhoog. Meer dan
  `SNAP_CELLS` = 1,5 cel verschil: direct naar de serverpositie.
- Extrapolatie maximaal `MAX_EXTRAP_S` = 1,5 s na de laatste snapshot.

Tests: `test/mini-predict.test.js`, plus de mini-meting in
`test/t1181-flights-playwright.py`.

## t1183 — raketvlam: random frames, flip, schaal en rotatie

- Nieuwe sprite van Tim (`build/images/flame.png`, 4 frames op een rij)
  ongewijzigd gebruikt.
- `src/flameFx.js` (`FlameFx`) stuurt de vlam aan in plaats van de
  framework-animatie `burn`:
  - `FPS` = 25 (was 0,08 s per frame = 12,5 fps; verdubbeld).
  - Elke tick een willekeurig frame dat **altijd** anders is dan het huidige
    (uniform uit de andere drie).
  - 50% kans op horizontaal spiegelen (`mirrorX`).
  - Onafhankelijke variatie: totale schaal ±6% (`SCALE_VAR`), breedte ±7%
    (`WIDTH_VAR`), hoogte ±7% (`HEIGHT_VAR`); samen maximaal ca. ±13%.
  - Rotatie ±2,5° (`ROT_VAR_DEG`).
  - Elke vlam heeft een eigen willekeurige fase, zodat meerdere raketten
    niet tegelijk wisselen.
- Anker: het framework tekent sprites gecentreerd en roteert/spiegelt om
  het midden. `FlameFx.pose` zet het midden op `anker + R(θ)·(0, h/2)`, zodat
  het bovenste midden (waar de vlam het blok raakt) exact op dezelfde plek
  blijft. Het framework rondt de positie af op hele pixels (max. 0,5 px).
- Verminderde beweging (`prefers-reduced-motion: reduce`): 12,5 fps, wel
  willekeurige frames, geen spiegelen/schalen/roteren. (Het effect had dit
  eerder niet; dit is de "nette" ondergrens.)
- Bij een haperend frame (lange dt) wordt één keer gerold, niet tientallen
  keren.

Tests: `test/flame-fx.test.js`; browser: `test/t1183-flame-playwright.py URL TAG`.

## t1184 / t1185 / t1186 — niet laten vallen op een vertrekkende raket

Tims woorden: "blokjes niet laten vallen op rijen waarvan nu blokken omhoog
vliegen waarvan de hoogste voorbij 75% vanaf de grond is die zeker het
scherm gaan verlaten".

- **"Rijen" = kolommen.** Blokken vallen per kolom (10 breed, 13 hoog) en
  een raket (vliegend cluster) stijgt in de kolommen waarin hij zit.
- **Vertrekkende stapel** (`GameCore.departingColumns`): een vliegend
  cluster dat nog stijgt (`phase 'up'`), waarvan het hoogste blok op of
  boven `0,75 × 13 = 9,75` staat (`GameCore.DEPART_SHARE`), waarvan de
  top (y + vy²/(2·decel)) de bovenrand haalt ("zeker het scherm uit"), en
  waar in zijn kolommen geen vast blok boven hangt. Alle kolommen waarin
  dat cluster blokken heeft tellen als vertrekkend.
- **Nieuwe blokken** (`trySpawn`) slaan die kolommen over. Zijn alle open
  kolommen vertrekkend, dan valt er die tik niets (de volgende spawn-tik
  probeert opnieuw).
- **Ontvangen blokken** (garbage van een tegenstander of bot,
  `ingestGarbage` / `pickGarbageColumn`): de gewenste kolom (`land_col` van
  de server) wint alleen als die niet vertrekkend is; anders een
  willekeurige andere open kolom. Zijn alle open kolommen vertrekkend, dan
  valt het blok toch (in de gewenste kolom), zodat er nooit garbage
  verdwijnt.
- Ze vallen dus niet door de raket heen en ook niet erop: ze kiezen een
  andere kolom. Blokken die al vielen voordat de stapel de 75% passeerde
  houden de bestaande regels (ze kunnen als lading meeliften).
- **Online consistent:** elk veld wordt door de eigen client gesimuleerd
  met dezelfde gedeelde `GameCore` (solo, offline met bots en online). De
  server kiest alleen een voorkeurskolom (`land_col`, willekeurig 0–9) en
  hoeft niets te weten van raketten; de client wijkt uit zoals bij volle
  of geblokkeerde kolommen (t1126). De vluchtanimatie mikt nog op
  `land_col`; het blok verschijnt dan in de gekozen kolom.

Tests: `test/departing.test.js`; browser:
`test/t1184-departing-playwright.py URL TAG` (desktop + mobiel).

## t1187 / t1188 — spawn-tempo loopt op

- Na elk echt gespawnd blok (`trySpawn` die een blok maakt):
  `spawnInterval *= GameCore.SPAWN_SPEEDUP` (0,997 = 0,3% korter; eerst
  3% gevraagd, door Tim aangepast naar 0,3%).
- Start `PlanetMod.SPAWN_INTERVAL` = 1 s; minimum
  `GameCore.SPAWN_INTERVAL_MIN` = 0,1 s (aanname, Tim kan dit aanpassen).
- Het minimum wordt bereikt na ca. 767 blokken, ongeveer 300 s (5 min).
- Geen spawn (alle kolommen dicht of vertrekkend) = geen versnelling.
- Elk spel en elke ronde maakt een nieuwe `GameCore`, dus het tempo begint
  steeds weer op 1 s. Spelers en bots (offline) en online velden gebruiken
  dezelfde code.

Tests: `test/spawn-speedup.test.js`.

## t1189 / t1191 — openingsburst en aanloop van het spawn-tempo

Tim (t1189): "In de eerste 5 seconden van een match, beginnen met 0.1s
tussen blokjes. Dan tussen de 5 en 8 seconden lerpen terug naar 1 per
seconde, en daarna pas de rate increase doen die we nu hebben." Daarna
(t1191) aangepast: burst de eerste **3 s**, dan lerp van **3 naar 6 s**.

- `GameCore.playTime`: seconden echte speeltijd van deze match/ronde. Telt
  vanaf de eerste `tick` van een nieuwe `GameCore`; er is geen aftelling,
  dus de tijd start als het spelen start. Elke ronde/match maakt een nieuwe
  core, dus de klok begint steeds bij 0 (spelers, bots, online).
- `GameCore.currentSpawnInterval()`:
  - `playTime < SPAWN_INTRO_END` (3 s): `SPAWN_INTRO_INTERVAL` = 0,1 s.
  - 3 s – `SPAWN_RAMP_END` (6 s): lineair van 0,1 s naar 1,0 s
    (`PlanetMod.SPAWN_INTERVAL`). De lerp-duur van 3 s is behouden uit de
    eerste versie (aanname).
  - Vanaf 6 s: `spawnInterval`, start 1 s, ×0,997 per gespawnd blok,
    minimum 0,1 s (t1187/t1188). **Alleen blokken die na 6 s spawnen
    tellen** voor die versnelling.
  - De interval wordt na elke spawn opnieuw gelezen.
- **Kolomkeuze in de burst** ("weighted column choice", t1191): tijdens de
  eerste 3 s kiest `pickWeightedSpawnColumn` een kolom met gewicht = vrije
  cellen (13 − vaste − al vallende blokken, minimaal 1). Legere kolommen
  krijgen dus vaker een blok; daarna weer uniform willekeurig. (De exacte
  weging stond niet in de opdracht; dit is mijn invulling.)
- **Meerdere vallende blokken per kolom in de opening:** met 0,1 s
  tussentijd zouden na 10 blokken alle kolommen bezet zijn (regel: één
  vallend blok per kolom) en zou de burst ~2 s stilvallen. Tot 6 s mag een
  kolom daarom een nieuw blok krijgen zodra het vorige vallende blok een
  hele cel onder de spawnrij zit (geen overlap). Na 6 s geldt weer één
  vallend blok per kolom.
- Gemeten: 30 blokken in 0–3 s, 6 in 3–6 s (36 in de eerste 6 s).
- De regel voor vertrekkende raketten (t1184) blijft gelden, ook in de
  burst.
- Testhaak: een `spawnInterval` boven 1 s (tests/tools zetten 1e9 om
  spawnen uit te zetten) wordt altijd gerespecteerd, ook in de burst.

Tests: `test/spawn-timeline.test.js`; browser:
`test/t1189-spawn-timeline-playwright.py URL TAG`.

## t1192 — ontvangen blokken gaan nooit verloren

Tim: bij ~5 blokken tegelijk naar iemand met nog maar twee vrije kolommen
viel soms alleen het eerste blok en verdwenen de rest.

**Oorzaak.** `GameCore.ingestGarbage` maakte elk ontvangen blok meteen aan
op de spawnrij (y = 13) van de gekozen kolom, zonder te kijken of daar al
een blok zat; de gewenste kolom (`land_col`) won altijd. Meerdere blokken
in dezelfde kolom lagen dus op elkaar. In de volgende tik "landde" het
tweede blok op het eerste (`highestFallingBelow` → y = 13,99), waarna
`cullOffTop` het als boven het scherm uit verwijderde. Erger: het telde als
schot van de **ontvanger** (punt erbij en terug naar de verzender). Online
en offline (bots) gebruiken dezelfde `GameCore`, dus beide hadden dit. De
server en `online.js` gooien niets weg: de server markeert schoten als
afgeleverd en `Online.onIncoming` roept per blok `ingestGarbage` aan.

**Oplossing (gedeelde `GameCore`).**
- `ingestGarbage(col)` zet het blok in `garbageQueue` (volgorde van
  binnenkomst) en probeert meteen te droppen; geeft het blok terug als het
  direct viel, anders `null` (het wacht).
- `drainGarbageQueue()` draait bij elke `tick` vóór het gewone spawnen.
  Een kolom kan een blok nemen (`garbageDropColumns`) als hij niet
  vergrendeld/vol is, niet vertrekkend (t1184), er na alles wat nog valt
  nog plek is (vast + vallend < 13), en de spawnrij vrij is
  (`spawnCellClear`: elk blok in de kolom minstens een hele cel onder de
  spawnrij — dezelfde regel als de openingsburst, nooit overlap).
- De gewenste kolom wint als die kan; anders een willekeurige open kolom.
  Is er geen open kolom, dan blijft het blok wachten (ook als alle open
  kolommen door vertrekkende raketten bezet zijn — dat verving de oude
  terugval naar de gewenste kolom).
- Na game over worden geen blokken meer aangenomen (zoals voorheen).
- Online bepaalt het eigen apparaat van de ontvanger de plaatsing. De
  vluchtanimatie mikt nog op `land_col`; een blok dat moet wachten of
  uitwijkt verschijnt daarna bovenaan in de gekozen kolom.

Tests: `test/garbage-queue.test.js` (o.a. exact scenario: 5 tegelijk, 2
open kolommen → alle 5 landen; ook via offline bots);
`test/t1192-garbage-queue-playwright.py ROOT TAG` (twee browsers lokaal).


## t1193 — Menu tijdens het spel en login-redirect

**Login-redirect (oorzaak).** `callback.php` stuurde na elke geslaagde
login hard naar `index.html?online=1`, en `main.js` opende bij
`?online=1` altijd het online-paneel. Daardoor belandde je ook na
inloggen vanaf het hoofdmenu in online spelen. **Oplossing:** `auth.php`
onthoudt `?return=` (alleen de whitelist-waarde `online`, via
`loginReturnTarget`) in de sessie; `callback.php` stuurt alleen dan naar
`index.html?online=1`, anders naar `index.html` (hoofdmenu, ingelogd).
De inlogknop in het online-paneel gebruikt `auth.php?return=online`,
de menuknop gewoon `auth.php`. `main.js` haalt `?online=1` na gebruik
uit de URL (`history.replaceState`), zodat herladen niet opnieuw naar
online springt. Aan auth.timfalken.com is niets veranderd.

**Menuknop.** Alleen in Spelen en Offline Strijd (niet online/toeschouwen),
rechtsboven naast de HUD (eigen flex-container, overlapt niet; ook op
mobiel getest). Aanname: **het spel pauzeert** zolang het menu open is
(`app.paused`: geen `GameCore`-tick, geen bots, geen vluchten) — dat is
offline eerlijk en verwacht. Online is er geen knop (pauzeren kan daar niet).

**Stoppen.** “Terug naar hoofdmenu” beëindigt de wedstrijd. Ingelogd:
eerst het puntenscherm met neutrale titel “Spel beëindigd” via de
bestaande `play_finish`/reward-flow, daarna het hoofdmenu (in Offline
Strijd dus **geen** volgende ronde of resultaatscherm). Uitgelogd: direct
naar het hoofdmenu (de laatste score staat daar, zoals na game over).
Misbruik: stoppen gaat door dezelfde server-check als een normaal einde
(punten begrensd op speelduur sinds `play_start`, één finish per sessie),
dus snel stoppen levert niets extra op.

## t1194 — Tempo van het puntenscherm

Blokje *i* (0-gebaseerd) van *n* vertrekt op het moment *t* waarop
`3t + a·t²/2 = i`, met tempo r(t) = 3 + a·t blokjes/s en T = 4 s.
De versnelling volgt uit “het laatste blokje (i = n−1) vertrekt op T”:
`a = 2·((n−1) − 3T) / T²`. Aanname: is `n − 1 ≤ 3T` (≤ 13 punten), dan
zou *a* ≤ 0 worden; dan gebruiken we een **vast tempo** `(n−1)/T`
(a = 0), zodat ook dan het laatste blokje op ~4 s vertrekt. Bij 1 punt
vertrekt het ene blokje meteen. Vluchtduur, de tik-regel van de laatste
1,5 s, 0 punten en het foutpad zijn ongewijzigd.

## t1195 — Weggehaalde teksten

Verwijderd in alle talen (sleutels weg): de tagline onder “Meteors”,
de uitleg na het totaal in de Planeetontwerper (alleen “Totaal: N
punten.” blijft), de ondertitel van de planeetkeuze, en in de HUD van
Offline Strijd “· N tegenstander(s) · Skill X%” (alleen “Ronde N”).

## t1196 — Laatst gekozen planeet

De planeet die je in een planeetkeuzescherm bevestigt (of in de lobby
kiest) wordt onthouden. Ingelogd: kolom `last_planet` in `profiles`,
via `api.php?action=set_last_planet`, terug in `me`/`poll` (zoals de
taal). De server accepteert alleen bekende standaardplaneten of een
eigen planeet van díe gebruiker. Uitgelogd (en als terugval):
`localStorage` (`meteors-planet`). Bij elk planeetkeuzescherm (Spelen,
Offline Strijd, Online) staat die planeet vooraan geselecteerd. Is een
eigen planeet intussen verwijderd, dan geeft de server `null` en kiest
de client Terra (geen fout).

## t1197 — Combo en “+x%”

- Elke match (elk gelanceerd cluster) telt in de lopende combo. De sprong
  van een match krijgt **+1 % per eerdere match in de combo**
  (`GameCore.COMBO_STEP` = 0,01; was 5 %, verlaagd in t1198): 1e +0 %,
  2e +1 %, 3e +2 %, … met een **plafond van +30 %**
  (`GameCore.COMBO_MAX_STEPS` = 30): combobonus = `0,01·min(combo, 30)`.
  De combo blijft doortellen, maar de bonus stijgt niet verder.
  Aanname: de eerste match zelf krijgt nog niets — de combo beloont
  doorgaan.
- Geen match gedurende 5 s (`GameCore.COMBO_RESET_S`, speeltijd; telt
  niet door tijdens pauze) → combo terug naar 0.
- Combinatie met de landingsketting (t1120, +25 % per stap): **additief**,
  `factor = 1 + 0,25·ketting + 0,01·min(combo, 30)`; het plafond geldt
  alleen voor het combodeel, de landingsketting blijft ongewijzigd. De HUD toont het totaal van
  de laatste lancering als simpel “+x%” (geel, oranje rand), zolang de
  geboosterde cluster vliegt of de combo nog loopt.
- Zit in de gedeelde `GameCore`, dus spelers en bots (offline, online)
  doen precies hetzelfde. Tests: `test/combo.test.js`.

## t1198 — Resultaatscherm Offline Strijd

“Je speelde tegen N tegenstander(s) met skill X%.” is vervangen door
“X tegenstander(s) verslagen” (enkelvoud/meervoud per taal, incl. pl/ru
few/many). X = alle bots die over alle gespeelde rondes uitgeschakeld
zijn (`OfflineBattle.defeated`, één keer per bot). Aanname: in de
verloren ronde tellen bots die al vóór jou uit waren mee; de rest niet.
“Je hebt ronde N bereikt.” blijft.

## t1199 — Zwaartekracht minimaal 2,0, getoond als percentage

**Minimum.** `jumpsToClear` loopt nu van 2,0 tot 4,0
(`Planet.GRAVITY_MIN`/`GRAVITY_MAX`, `Planets::GRAVITY_MIN`/`MAX`). De
slider in de planeetontwerper begint op 2; client (`createPlanet`) en
server (`Planets::clampGravity`, bij opslaan in `saveCustomPlanet`)
klemmen alles daaronder naar 2.

**Standaardplaneten** die onder 2 zaten zijn naar 2,0 gezet:
Aurel 1 → 2, Lunara 1 → 2, Zephyr 1 → 2 (lucht en massa ongewijzigd).

**Bestaande eigen planeten.** Gekozen: **klemmen bij laden en opslaan**,
geen migratie van de database. Een oude rij met bijv. 1,2 blijft zo in
de database staan, maar komt overal (lijst, lobby-snapshot, spel) als
2,0 terug; zodra de eigenaar hem opnieuw opslaat staat er 2,0. Zo is er
geen eenmalig script nodig en is het gedrag meteen overal gelijk.

**Weergave.** Lineair in de waarde: `pct = (v − 1) × 100`, dus 2,0 =
100 %, 3,0 = 200 %, 4,0 = 300 %. Tim schreef “100% - 9.81g”; het
g-getal is daarom **meegeschaald met het percentage**:
`g = 9,81 × (v − 1)` (2,0 = 9,81 g, 3,0 = 19,62 g, 4,0 = 29,43 g). Zo
betekent 300 % ook echt 3× 9,81. (Vroeger was het `9,81 × v / 2`,
waardoor 4,0 = 19,62 was en dus niet bij 300 % zou passen.) Tekst via
i18n-sleutel `stats.gravity` (`{pct}% ({g}g)`; in de/fr/pl/ru/es met
spatie: `{pct} % ({g} g)`). Kaarten en HUD: `g 100% (9.81g) d … F … N
Power …%`; ontwerper: label “Zwaartekracht” met `100% (9.81g)`.

**Balans / Power.** De Power-formule houdt bewust de oude as
`(v − 1) / 3`. Daardoor houden alle planeten waarvan de fysica niet
veranderde (Terra, Cinder, …) exact dezelfde Power en miss-kans. Alleen
de drie verhoogde planeten worden moeilijker, wat klopt met hun lagere
sprong: Aurel 0 % → 10 % getoonde Power (miss 60 % → 53,9 %), Lunara
45 % → 55 % (33,1 % → 26,9 %), Zephyr 31 % → 42 % (41,1 % → 35,0 %).
Gevolg: de laagst mogelijke Power is nu 1/9 (getoond 10 %, miss ≈ 54 %)
in plaats van 0. Herschalen naar 2–4 zou Terra en alle andere
ongewijzigde planeten juist makkelijker laten lijken (Terra 44 % → 34 %)
zonder dat er iets aan hun spel veranderde; dat vond ik minder logisch.
Aurel blijft de makkelijkste en Cinder de moeilijkste planeet.
Spronghoogte bij 2,0: 1,5 × 13 / 2 = 9,75 tegels (op de oude 1,0 was
dat 19,5); één sprong vanaf de bodem haalt het veld dus niet meer.

## t1200 — “+x%” toont alleen de combo

De gele “+x%” boven het veld toont nu **alleen de combobonus**:
`0,01 × min(combo, 30)` als percentage (`GameCore.comboBonusPct()`), dus
wat de volgende match van de combo krijgt (na 1 match +1 %, na 3 matches
+3 %, maximaal +30 %). De landingsketting (+25 % per stap) telt nog
gewoon mee in de spronghoogte, maar niet meer in dit getal. De tekst is
alleen zichtbaar zolang die combobonus > 0 is; na 5 s zonder match
(combo terug naar 0) verdwijnt hij. Dit vervangt de weergave-regel uit
t1197 (“totaal van de laatste lancering”).

## t1201 — Hoofdmenu: Spelen en Overleven

- De grote knop **Spelen** start nu wat vroeger “Offline Strijd” was
  (rondes tegen bots). De tweede knop heet **Overleven** (EN “Survival”,
  in alle 10 talen) en start het eindeloze spel alleen (vroeger
  “Spelen”).
- **Interne ids blijven gelijk:** de modi heten intern nog `offline`
  (rondes) en `solo` (eindeloos); `play_finish`/`play_begin` sturen
  dezelfde `mode`-waarden, dus server, profielen en punten-caps blijven
  compatibel. Alleen de knop-id `btn-offline` is hernoemd naar
  `btn-survival` (puur client-side; de Playwright-scripts zijn mee
  aangepast). De i18n-sleutel `menu.offline` is vervangen door
  `menu.survival`.
- Puntenscherm, volgende ronde, uitslag en terugkeer naar het menu
  volgen de modus (`app.offline`), niet de knop; daar veranderde niets.
- Namen voor de speler: het planeetkeuzescherm toont boven het raster
  voor welke modus je kiest (Spelen / Overleven / Online spelen), het
  pauzemenu toont de lopende modus. De titel van het resultaatscherm na
  de rondes was “Offline Strijd”; dat is nu neutraal **“Uitslag”**
  (EN “Results”), omdat “Spelen” als titel vreemd leest. De zin
  “Je kunt wel alleen spelen.” (online niet beschikbaar) is nu
  “Je kunt wel offline spelen.”, omdat “alleen spelen” niet meer één
  modus is.
- De knop onderaan het planeetscherm blijft “Spelen” (start), ook bij
  Overleven; het label erboven noemt de modus.

## t1203 — Miniaturen schalen op smalle schermen

**Probleem.** In de bovenrij (smal/staand scherm) hadden de miniaturen
vaste maten per aantal (80/56/40 px breed) en liepen ze via flex-wrap
naar een tweede rij. Bij bijv. 6 bots op ~460 px kwam de 6e op een
tweede rij die (deels) achter het eigen veld viel.

**Oplossing (`src/miniLayout.js`, gedeeld door Spelen/bots en Online).**
- De beschikbare band is de hele ruimte tussen de HUD en de bovenkant van
  het eigen veld (niet alleen de vaste `miniH`), over de schermbreedte.
- `topMiniFit(n, breedte, bandhoogte)` zoekt de **grootste** mini
  (canvasbreedte 80 → 32 px, hoogte 13/10 daarvan) waarbij alle *n* in
  de band passen, eventueel in meerdere rijen; de rijen worden
  gebalanceerd (6 → 3 + 3, niet 5 + 1) en gecentreerd. Het label schaalt
  mee: 11 px bij volle maat, **minimaal 9 px**; namen worden zo nodig
  afgekapt met “…”.
- **Gekozen minimum: 32 px canvasbreedte (×42 px hoog), labels 9 px.**
  Dat is 3,2 px per kolom: kleiner leest het veld niet meer als veld en
  is 9 px tekst niet meer leesbaar. Gemeten: 6 bots → 62 px (412×915),
  57 px (360×800), 59 px (460×900, één rij); 12 → 52/44/54 px;
  16 → 37/33/43 px. Tot ~16–20 tegenstanders past alles op een telefoon.
- De bovenrij wordt nu, net als de zij-layout, absoluut geplaatst
  (`#minis.placed`), zodat er niets meer onvoorspelbaar wrapt.

**Sorteren alleen bij echt te veel.** Zolang alles past blijft de
volgorde exact zoals hij was (ook met verslagen tegenstanders). Past het
zelfs bij 32 px niet (bijv. 31 bots op 360×800: 24 plekken), dan krijgen
eerst alle levende tegenstanders een plek en daarna de verslagen, elk in
de oorspronkelijke volgorde (stabiel). Alles wat niet meer past komt in
de rijen eronder, dus achter het veld — en dat zijn dan alleen verslagen
tegenstanders. (Zijn er meer levenden dan plekken, dan vallen de laatste
levenden er alsnog achter; dat komt pas voor bij 25+ levende
tegenstanders op een telefoon.) De volgorde wordt bij elke update
opnieuw bepaald, dus een tegenstander die uitvalt schuift pas dan naar
achteren.

Brede schermen (zij-layout) zijn ongewijzigd.


## t1246 — Inlogvraag bij de start

Als je het spel opent en niet bent ingelogd, verschijnt meteen een
overlay: **Inloggen?** met de gewone inlogknop (naar `auth.php`,
dezelfde flow als de menulink, dus na succes terug naar het hoofdmenu)
en daaronder **Speel als gast**. Een ingelogde speler ziet deze vraag
nooit. De overlay gebruikt de bestaande i18n en de stijl van het
pauzemenu, op desktop en mobiel.

**Sessiekeuze.** “Speel als gast” (en ook het aanklikken van Inloggen)
wordt onthouden in `sessionStorage` onder de sleutel
`meteors-login-prompt`. Daardoor komt de vraag niet terug als je in
dezelfde tab naar het menu terugkeert of de pagina herlaadt, maar wel
bij een verse start (nieuw tabblad of de tab sluiten). `localStorage`
zou de keuze permanent maken; dat is niet de bedoeling.

**Terugkomst van de auth-callback.** Na een geslaagde login is
`Online.me` gezet, dus de vraag verschijnt niet. Om te voorkomen dat de
vraag wél terugkomt na een afgebroken of mislukte login (of na
`?online=1` / `?auth=unconfigured`), wordt de sessievlag ook gezet
zodra je op Inloggen klikt, en bij het laden als de URL of de
`document.referrer` op een terugkomst van auth wijst
(`callback.php`, auth.timfalken.com, `?online=1`, `?auth=`). Aan
auth.timfalken.com is niets veranderd.

Tests: `test/login-prompt.test.js`; Playwright
`test/t1246-login-prompt-playwright.py URL TAG`.

## t1247 — Ranglijst

Onder **Online spelen** op het hoofdmenu staat **Ranglijst**. Het scherm
heeft twee tabs: **Top 10** (wereldwijd) en **Vrienden**.

**Punten.** Gesorteerd op `profiles.lifetime_points`, hetzelfde
profieltotaal waar het puntenscherm (t1173) naartoe telt. Gelijk
spel: alfabetisch op naam, daarna `user_id`. Maximaal 10 rijen.
Wie niet in de top 10 staat, krijgt geen extra rij.

**Namen en avatars.** Bij inloggen (en bij `me`) bewaart de server naam
en `avatar_url` van auth.timfalken.com op het profiel. Ontbreekt een
naam (oude rijen), dan valt de weergave terug op het deel na `:` in het
user-id. De avatar is dezelfde aanpak als in Allianties: een gekleurde
cirkel met initialen, met het profielfotootje eroverheen als dat
laadt; bij een fout blijft de cirkel staan. Ongeldige URL’s
(`javascript:` e.d.) worden geweigerd.

**Vrienden.** De server haalt `GET /api/friends` op auth.timfalken.com op
met het bestaande OAuth-access-token uit de sessie (gezet in
`callback.php`). Elk vriend-id wordt `auth:{id}` en gekoppeld aan het
lokale profiel. Een vriend die Meteors nog nooit heeft gespeeld (0 punten) wordt
niet getoond (t1263). Aan
auth.timfalken.com is niets veranderd. Vrienden beheer je op je
accountpagina daar.

**Gasten.** De wereldwijde tab is een open GET (`api.php?action=leaderboard`,
geen CSRF, geen login). De vriendentab toont “Log in om te zien hoe je
vrienden ervoor staan” met een link naar `auth.php`. De API geeft voor
gasten op `scope=friends` `login_required: true` en een lege lijst,
geen 401.

**Lokaal.** Zonder auth-token (testers `test_user_1` / `test_user_2`)
zijn die twee testers elkaars vriend, zodat de vriendentab lokaal
getest kan worden. Op productie bestaat die koppeling niet.

**Markering.** Sta je in de getoonde lijst, dan krijgt je rij de class
`you` (lichte gouden achtergrond). Op de vriendentab sta je zelf ook
tussen je vrienden, gerangschikt op punten (t1263), tenzij je 0 punten
hebt.

Tests: `server/tests/run.php` (t1247), `test/leaderboard.test.js`;
Playwright `test/t1247-leaderboard-playwright.py URL TAG`.

## t1249 — Namen en avatars van auth.timfalken.com

Auth heeft **geen** publieke lookup van gebruikersnaam per id. Wel:
`GET /api/friends` (bearer-token van de kijker) levert `id`, `username`
en `avatar_url`; `GET /api/me` hetzelfde voor jezelf; `GET /avatar/{id}`
is publiek maar geeft alleen de foto (geen naam), en 404 zonder foto.
Aan auth.timfalken.com is niets veranderd.

**Aanpak in Meteors.** Als je ingelogd de ranglijst (wereldwijd of
vrienden) opent, haalt de server je vriendenlijst op met jouw token.
Die namen/avatars, plus die van jezelf, worden over de getoonde rijen
gelegd en teruggeschreven op bestaande profielen (`rememberIdentities`).
Een fallback-naam zoals “3” voor `auth:3` telt niet als echte naam.
Vrienden die Meteors nooit hebben gespeeld krijgen geen nieuw profiel
(ze blijven dus van de wereldwijde top 10 af).

**Cache.** De vriendenlijst per kijker staat in `friends_cache` en
wordt 10 minuten hergebruikt (`Store::FRIENDS_CACHE_TTL`). Faalt auth,
dan mag een verlopen cache nog worden gebruikt. Een gast ziet echte
namen zodra een eerdere ingelogde kijker (die die mensen als vriend
heeft, of de spelers zelf) ze heeft laten backfillen; anders blijft
de id-terugval.

**Voorstel (niet gebouwd).** Een kleine auth-API, bijvoorbeeld
`GET /api/users/{id}` of `GET /api/profiles?ids=1,2,3` (publiek of
met client credentials), die alleen `{id, username, avatar_url}`
teruggeeft, zou ook gasten en niet-vrienden op de wereldwijde lijst
van echte namen kunnen voorzien. Dat vereist een wijziging op
auth.timfalken.com; die is hier niet gedaan.

Tests: `server/tests/run.php` (t1249).

## t1256 — Cache-busting voor JS, CSS en vertalingen

Tim (Brave, mobiel, ingelogd, NL) zag op het hoofdmenu de knop
**menu.leaderboard** (de ruwe i18n-sleutel) en een tik deed niets. De
live catalogus had de sleutel wél in alle talen (NL: “Ranglijst”), de
knop staat onder **Online spelen**, en als gast in NL (desktop en
mobiele emulatie) werkt label én tik. De HTML-fallback van de knop is
“Leaderboard”; dat de sleutel zichtbaar was, betekent dat `I18n.apply`
liep tegen een catalogus zonder die sleutel — typisch nieuwe
`index.html` (met de knop en `data-i18n`) naast een oude gecachete
`game.js` (zonder sleutel en zonder `bindLeaderboard`). “Sitegegevens
wissen” in Brave wist niet altijd de HTTP-cache van JS.

**Aanpak.** `src/build.sh` zet een SHA-256-hash (12 hex tekens) als
`?v=` op `game.js`, `style.css` en `framework.js` in `index.html`.
`i18n.json` wordt in `game.js` ingebouwd, dus die hash dekt de
vertalingen. `index.html` krijgt `Cache-Control: no-cache` (`.htaccess`
en `router.php`); JS/CSS/JSON mogen lang gecached worden (`immutable`).
De live host serveert statische bestanden via nginx, dus `.htaccess`
grijpt daar mogelijk niet; de querystring doet het cache-busting dan
alsnog. `I18n.apply` valt terug op Engels en daarna op de bestaande
labeltekst, zodat een ontbrekende sleutel nooit rauw in de UI verschijnt.
De ranglijstknop luistert ook op `pointerup` (zoals Spelen / Overleven).

Tests: `test/cache-bust.test.js`, `test/i18n.test.js` (t1256).

## t1250 — Taal van auth.timfalken.com als standaard

De OIDC-claim `locale` staat op `POST /oauth/token` (`user.locale`) en
`GET /api/me` (`user.locale`). Het is een BCP 47-tag: `en`, `nl`,
`de`, `fr`, `ja`, `zh-Hans`, `ko`, `pl`, `ru` of `es`. Intern slaat
auth Chinees op als `zh`; Meteors mapt `zh-Hans` (en `zh-CN` e.d.)
naar `zh`. Aan auth.timfalken.com is niets veranderd.

**Ingelogd.** Zolang je in Meteors zelf geen taal hebt gekozen, volgt
het spel die auth-claim (gezet bij de callback, ververst bij `action=me`).
Een keuze in de vlaggenkiezer wordt opgeslagen (`profiles.locale` plus
`locale_explicit`, en `localStorage meteors-locale-chosen`) en wint
altijd, ook als je later op auth.timfalken.com van taal wisselt.

**Gasten.** Ongewijzigd: `localStorage` / standaard Engels. Een
bestaande `profiles.locale` zonder expliciete vlag telt niet als
in-game keuze (de oude code schreef die soms automatisch).

Tests: `server/tests/run.php` (t1250), `test/i18n.test.js`.

## t1253 — Ranglijstnamen via GET /api/profiles

Auth heeft nu een publieke lookup: `GET /api/profiles?ids=1,2,3`
geeft `{profiles:[{id,username,avatar_url}]}` (max 50 ids, 60
verzoeken per minuut per IP, `Cache-Control` 60 s). `GET /api/users/{id}`
is dezelfde velden voor één gebruiker. Geen token, geen e-mail of
locale. Aan auth.timfalken.com is niets veranderd.

Meteors haalt bij de ranglijst (wereldwijd en vrienden) de auth-ids
in batch op, bewaart ze ~10 minuten in `profiles_cache`
(`Store::PROFILES_CACHE_TTL`) en schrijft echte namen/avatars terug
op bestaande profielen (`rememberIdentities`). Zo zien ook gasten
“lucia” in plaats van “3”. Faalt auth, dan volgt de bestaande keten:
verse of verlopen cache, vriendenlijst, opgeslagen naam, anders het
deel na `:` in het user-id.

Tests: `server/tests/run.php` (t1253), `test/leaderboard.test.js`.

## t1263 — Geen 0 punten, en jezelf op de vriendentab

**Geen 0 punten.** Op beide tabs (wereldwijd en vrienden) worden
spelers met `lifetime_points = 0` weggelaten, inclusief vrienden die
Meteors nog nooit hebben gespeeld. Rangen tellen alleen over de
getoonde rijen (maximaal 10).

**Jezelf bij vrienden.** De vriendentab zet de ingelogde speler bij
zijn vrienden en rangschikt iedereen op punten (gelijkspel: naam, dan
`user_id`). Zit je niet in die top 10, dan komt er geen extra rij —
hetzelfde als op de wereldwijde tab.

**Ook jij verdwijnt bij 0 punten.** Dezelfde regel geldt voor jezelf.
Anders zou de vriendentab als enige een 0-puntenrij krijgen, en een
lege lijst (niemand heeft nog gescoord) zou vreemd alleen “jij, 0
punten” tonen. Zodra je punten hebt, sta je er gewoon bij, met de
markering `you`.

Tests: `server/tests/run.php` (t1263).

## t1278 — Puntentelling na een online rematch

**Oorzaak.** “You won!” / “You lost...” schoof na een online wedstrijd
wel omhoog, maar de optelling (blokjes naar het puntentotaal) bleef
uit. Solo en Offline Strijd gebruikten `play_finish` (`awarded` +
nieuw totaal). Online kende de server de punten zelf toe met sleutel
`online:{lobbyId}:{userId}`. De lobby wordt na het podium echter
teruggezet naar `waiting` en hergebruikt. De tweede (en volgende)
wedstrijd in dezelfde lobby vond die sleutel al en kende 0 punten
toe. De client vergeleek het profieltotaal bij de start met dat uit
de finished-poll: die waren gelijk, `earned` werd 0, de tel-fase
werd overgeslagen. De titel schuift via CSS, onafhankelijk van die
fase, dus die zag je wél. Een eerste wedstrijd in een verse lobby
werkte; dat is waarom de bestaande Playwright-check groen bleef.

**Oplossing.** De toekenningssleutel is nu
`online:{lobbyId}:{started}:{userId}` (`started` wordt bij elke
`startGame` opnieuw gezet). Een oude sleutel telt alleen mee als hij
bij déze wedstrijd hoort (`created >= started`), zodat een lobby die
tijdens het podium werd uitgerold geen dubbele punten krijgt. De poll
stuurt `online_awarded` mee (zelfde formule als `play_finish`). De
client gebruikt dat voor het puntenscherm.

Tests: `server/tests/run.php` (t1278, inclusief rematch),
`test/online-reward.test.js`, `test/reward.test.js`.

