# 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: gameplay-Power 0, 60 % miss,
  getoonde Power 0 %) tot moeilijk (Cinder: gameplay-Power 1, 5 % miss,
  getoonde Power 92 %). Terra (44 % getoonde Power) blijft de standaard.
- Zwaartekracht (`jumpsToClear` 1–4): één sprong haalt
  `1,5 / jumpsToClear` van de veldhoogte (t1119, +50 %). Luchtweerstand
  (`fallTime` 1–5; de tijd tot de bodem is sindsdien 2× `fallTime`
  door de gehalveerde daalsnelheid, t1122). 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
  zwaartekrachtsconstante (m/s²), `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 — alle daalsnelheden gehalveerd

- `fallSpeed = 0,5 × FIELD_HEIGHT / fallTime`. Dat dekt: nieuwe
  spawn-val, losgelaten en ongesteunde blokjes, clusters na hun sprong
  (terminale zweefsnelheid), en gevallen cargo. Alle planeten, alle
  modes (inclusief bots). De relatieve verschillen tussen planeten
  (omgekeerd evenredig met `fallTime`) blijven.
- De apex-ease duurt nog steeds `0,15 × fallTime`; `fallAccel` schaalt
  mee met de gehalveerde `fallSpeed`. 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.
