BlueGit

projects-timfalken-com meteors

t1192: docs (NL) and build

timfa Grok Bot · pushed by timfa

Authored 2026-11-14 · 3 days ago

Hash
196dca39e82480cee5e4fd90417f279d67eabd58
Parent
b396b85d
3 files changed +140 −7
README.md +8 −0
@@ -209,6 +209,14 @@ op het podium en daarna ga je terug naar de lobby.
209 209 korter (minimum 0,1 s, na ca. 767 blokken / 5 minuten). Elk spel en elke
210 210 ronde begint weer bij 0 s, ook voor bots en online.
211 211
212 ### Ontvangen blokken
213
214 Blokken die je van een tegenstander (of bot) krijgt gaan nooit verloren.
215 Ze komen in een wachtrij en vallen pas als er plek is: het vorige blok in
216 die kolom moet een hele cel onder de bovenste rij zitten. Is de gewenste
217 kolom vol, geblokkeerd of bezet door een vertrekkende raket, dan kiest het
218 blok een andere open kolom; is er geen enkele open, dan wacht het.
219
212 220 ### Raketvlam
213 221
214 222 De vlam onder een raketblok wisselt 25 keer per seconde naar een willekeurig
@@ -209,6 +209,14 @@ op het podium en daarna ga je terug naar de lobby.
209 korter (minimum 0,1 s, na ca. 767 blokken / 5 minuten). Elk spel en elke
209 korter (minimum 0,1 s, na ca. 767 blokken / 5 minuten). Elk spel en elke
210 ronde begint weer bij 0 s, ook voor bots en online.
210 ronde begint weer bij 0 s, ook voor bots en online.
211
211
212### Ontvangen blokken
213
214Blokken die je van een tegenstander (of bot) krijgt gaan nooit verloren.
215Ze komen in een wachtrij en vallen pas als er plek is: het vorige blok in
216die kolom moet een hele cel onder de bovenste rij zitten. Is de gewenste
217kolom vol, geblokkeerd of bezet door een vertrekkende raket, dan kiest het
218blok een andere open kolom; is er geen enkele open, dan wacht het.
219
212### Raketvlam
220### Raketvlam
213
221
214De vlam onder een raketblok wisselt 25 keer per seconde naar een willekeurig
222De vlam onder een raketblok wisselt 25 keer per seconde naar een willekeurig
build/game.js +93 −7
@@ -5179,6 +5179,8 @@ function GameCore (planet, rng)
5179 5179 this.drag = null;
5180 5180 this.gameOverTime = 0;
5181 5181 this.outgoingShots = [];
5182 /** Received garbage waiting for room (t1192). */
5183 this.garbageQueue = [];
5182 5184 // Stage-2 default; stage 3 replaces this with Planet.missChance (Power).
5183 5185 this.missChance = optsMissChance(arguments);
5184 5186 // t1112: invariant checker. strictInvariants throws (tests);
@@ -5683,6 +5685,9 @@ GameCore.prototype.tick = function (dt)
5683 5685
5684 5686 // t1189: spawn timeline by elapsed play time (intro burst, ramp, then
5685 5687 // the per-spawn speed-up). Interval is re-read after every spawn.
5688 // t1192: waiting received blocks drop first, as soon as there is room.
5689 if (this.garbageQueue.length)
5690 { this.drainGarbageQueue(); }
5686 5691 this.spawnTimer += dt;
5687 5692 var iv = this.currentSpawnInterval();
5688 5693 while (this.spawnTimer >= iv)
@@ -7387,17 +7392,98 @@ GameCore.prototype.pickGarbageColumn = function (preferred)
7387 7392 return eligible[Math.floor(this.rng() * eligible.length) % eligible.length];
7388 7393 };
7389 7394
7395 /**
7396 * Receive one garbage block (t1192). It is queued and dropped as soon as
7397 * there is room; received blocks are never lost. Returns the block when
7398 * it could drop right away, otherwise null (it waits in garbageQueue).
7399 *
7400 * Before t1192 every received block was created at once at the spawn
7401 * row of its column. Several blocks aimed at the same column overlapped
7402 * there: the second one "landed" on the first at y ≥ 13, was culled off
7403 * the top and even counted as the receiver's own shot.
7404 */
7390 7405 GameCore.prototype.ingestGarbage = function (col)
7391 7406 {
7392 7407 if (this.state !== 'playing')
7393 7408 { return null; }
7394 var chosen = this.pickGarbageColumn(col);
7395 if (chosen == null)
7396 { return null; }
7397 var block = this.createBlock(chosen, this.height, COLOR_GRAY, STATE_FALLING);
7398 block.vy = -this.planet.fallSpeed;
7399 block.flame = false;
7400 return block;
7409 var want = (col != null && isFinite(col)) ? (col | 0) : null;
7410 var item = { col: want, block: null };
7411 this.garbageQueue.push(item);
7412 this.drainGarbageQueue();
7413 return item.block;
7414 };
7415
7416 /**
7417 * Can a block enter `col` at the spawn row now? Same rule as the opening
7418 * burst: every block already in the column must be at least a full cell
7419 * below the spawn row (no overlap).
7420 */
7421 GameCore.prototype.spawnCellClear = function (col)
7422 {
7423 for (var i = 0; i < this.blocks.length; i++)
7424 {
7425 var b = this.blocks[i];
7426 if (b.col === col && b.y > this.height - 1 + 1e-9)
7427 { return false; }
7428 }
7429 return true;
7430 };
7431
7432 /** Columns a queued garbage block can drop into right now (t1192). */
7433 GameCore.prototype.garbageDropColumns = function ()
7434 {
7435 var open = this.eligibleGarbageColumns();
7436 var departing = this.departingColumns();
7437 var out = [];
7438 for (var i = 0; i < open.length; i++)
7439 {
7440 var c = open[i];
7441 if (departing[c])
7442 { continue; }
7443 // Room left for one more block once everything in flight lands.
7444 if (this.groundedCount(c) + this.fallingCount(c) >= this.height)
7445 { continue; }
7446 if (!this.spawnCellClear(c))
7447 { continue; }
7448 out.push(c);
7449 }
7450 return out;
7451 };
7452
7453 /**
7454 * Drop queued garbage in arrival order while there is room. The wanted
7455 * column (server land_col / bot pick) wins when it can take a block,
7456 * otherwise a random open one. When nothing is open the rest waits.
7457 * Returns how many blocks dropped.
7458 */
7459 GameCore.prototype.drainGarbageQueue = function ()
7460 {
7461 var dropped = 0;
7462 while (this.garbageQueue.length && this.state === 'playing')
7463 {
7464 var cols = this.garbageDropColumns();
7465 if (!cols.length)
7466 { break; }
7467 var item = this.garbageQueue[0];
7468 var chosen = null;
7469 if (item.col != null && cols.indexOf(item.col) >= 0)
7470 { chosen = item.col; }
7471 else
7472 { chosen = cols[Math.floor(this.rng() * cols.length) % cols.length]; }
7473 this.garbageQueue.shift();
7474 var block = this.createBlock(chosen, this.height, COLOR_GRAY, STATE_FALLING);
7475 block.vy = -this.planet.fallSpeed;
7476 block.flame = false;
7477 item.block = block;
7478 dropped++;
7479 }
7480 return dropped;
7481 };
7482
7483 /** Received blocks still waiting for room (t1192). */
7484 GameCore.prototype.pendingGarbage = function ()
7485 {
7486 return this.garbageQueue.length;
7401 7487 };
7402 7488
7403 7489 GameCore.prototype.advanceSettle = function (dt)
@@ -5179,6 +5179,8 @@ function GameCore (planet, rng)
5179 this.drag = null;
5179 this.drag = null;
5180 this.gameOverTime = 0;
5180 this.gameOverTime = 0;
5181 this.outgoingShots = [];
5181 this.outgoingShots = [];
5182 /** Received garbage waiting for room (t1192). */
5183 this.garbageQueue = [];
5182 // Stage-2 default; stage 3 replaces this with Planet.missChance (Power).
5184 // Stage-2 default; stage 3 replaces this with Planet.missChance (Power).
5183 this.missChance = optsMissChance(arguments);
5185 this.missChance = optsMissChance(arguments);
5184 // t1112: invariant checker. strictInvariants throws (tests);
5186 // t1112: invariant checker. strictInvariants throws (tests);
@@ -5683,6 +5685,9 @@ GameCore.prototype.tick = function (dt)
5683
5685
5684 // t1189: spawn timeline by elapsed play time (intro burst, ramp, then
5686 // t1189: spawn timeline by elapsed play time (intro burst, ramp, then
5685 // the per-spawn speed-up). Interval is re-read after every spawn.
5687 // the per-spawn speed-up). Interval is re-read after every spawn.
5688 // t1192: waiting received blocks drop first, as soon as there is room.
5689 if (this.garbageQueue.length)
5690 { this.drainGarbageQueue(); }
5686 this.spawnTimer += dt;
5691 this.spawnTimer += dt;
5687 var iv = this.currentSpawnInterval();
5692 var iv = this.currentSpawnInterval();
5688 while (this.spawnTimer >= iv)
5693 while (this.spawnTimer >= iv)
@@ -7387,17 +7392,98 @@ GameCore.prototype.pickGarbageColumn = function (preferred)
7387 return eligible[Math.floor(this.rng() * eligible.length) % eligible.length];
7392 return eligible[Math.floor(this.rng() * eligible.length) % eligible.length];
7388};
7393};
7389
7394
7395/**
7396 * Receive one garbage block (t1192). It is queued and dropped as soon as
7397 * there is room; received blocks are never lost. Returns the block when
7398 * it could drop right away, otherwise null (it waits in garbageQueue).
7399 *
7400 * Before t1192 every received block was created at once at the spawn
7401 * row of its column. Several blocks aimed at the same column overlapped
7402 * there: the second one "landed" on the first at y ≥ 13, was culled off
7403 * the top and even counted as the receiver's own shot.
7404 */
7390GameCore.prototype.ingestGarbage = function (col)
7405GameCore.prototype.ingestGarbage = function (col)
7391{
7406{
7392 if (this.state !== 'playing')
7407 if (this.state !== 'playing')
7393 { return null; }
7408 { return null; }
7394 var chosen = this.pickGarbageColumn(col);
7409 var want = (col != null && isFinite(col)) ? (col | 0) : null;
7395 if (chosen == null)
7410 var item = { col: want, block: null };
7396 { return null; }
7411 this.garbageQueue.push(item);
7397 var block = this.createBlock(chosen, this.height, COLOR_GRAY, STATE_FALLING);
7412 this.drainGarbageQueue();
7398 block.vy = -this.planet.fallSpeed;
7413 return item.block;
7399 block.flame = false;
7414};
7400 return block;
7415
7416/**
7417 * Can a block enter `col` at the spawn row now? Same rule as the opening
7418 * burst: every block already in the column must be at least a full cell
7419 * below the spawn row (no overlap).
7420 */
7421GameCore.prototype.spawnCellClear = function (col)
7422{
7423 for (var i = 0; i < this.blocks.length; i++)
7424 {
7425 var b = this.blocks[i];
7426 if (b.col === col && b.y > this.height - 1 + 1e-9)
7427 { return false; }
7428 }
7429 return true;
7430};
7431
7432/** Columns a queued garbage block can drop into right now (t1192). */
7433GameCore.prototype.garbageDropColumns = function ()
7434{
7435 var open = this.eligibleGarbageColumns();
7436 var departing = this.departingColumns();
7437 var out = [];
7438 for (var i = 0; i < open.length; i++)
7439 {
7440 var c = open[i];
7441 if (departing[c])
7442 { continue; }
7443 // Room left for one more block once everything in flight lands.
7444 if (this.groundedCount(c) + this.fallingCount(c) >= this.height)
7445 { continue; }
7446 if (!this.spawnCellClear(c))
7447 { continue; }
7448 out.push(c);
7449 }
7450 return out;
7451};
7452
7453/**
7454 * Drop queued garbage in arrival order while there is room. The wanted
7455 * column (server land_col / bot pick) wins when it can take a block,
7456 * otherwise a random open one. When nothing is open the rest waits.
7457 * Returns how many blocks dropped.
7458 */
7459GameCore.prototype.drainGarbageQueue = function ()
7460{
7461 var dropped = 0;
7462 while (this.garbageQueue.length && this.state === 'playing')
7463 {
7464 var cols = this.garbageDropColumns();
7465 if (!cols.length)
7466 { break; }
7467 var item = this.garbageQueue[0];
7468 var chosen = null;
7469 if (item.col != null && cols.indexOf(item.col) >= 0)
7470 { chosen = item.col; }
7471 else
7472 { chosen = cols[Math.floor(this.rng() * cols.length) % cols.length]; }
7473 this.garbageQueue.shift();
7474 var block = this.createBlock(chosen, this.height, COLOR_GRAY, STATE_FALLING);
7475 block.vy = -this.planet.fallSpeed;
7476 block.flame = false;
7477 item.block = block;
7478 dropped++;
7479 }
7480 return dropped;
7481};
7482
7483/** Received blocks still waiting for room (t1192). */
7484GameCore.prototype.pendingGarbage = function ()
7485{
7486 return this.garbageQueue.length;
7401};
7487};
7402
7488
7403GameCore.prototype.advanceSettle = function (dt)
7489GameCore.prototype.advanceSettle = function (dt)
docs/ASSUMPTIONS.md +39 −0
@@ -1116,3 +1116,42 @@ seconde, en daarna pas de rate increase doen die we nu hebben." Daarna
1116 1116 Tests: `test/spawn-timeline.test.js`; browser:
1117 1117 `test/t1189-spawn-timeline-playwright.py URL TAG`.
1118 1118
1119 ## t1192 — ontvangen blokken gaan nooit verloren
1120
1121 Tim: bij ~5 blokken tegelijk naar iemand met nog maar twee vrije kolommen
1122 viel soms alleen het eerste blok en verdwenen de rest.
1123
1124 **Oorzaak.** `GameCore.ingestGarbage` maakte elk ontvangen blok meteen aan
1125 op de spawnrij (y = 13) van de gekozen kolom, zonder te kijken of daar al
1126 een blok zat; de gewenste kolom (`land_col`) won altijd. Meerdere blokken
1127 in dezelfde kolom lagen dus op elkaar. In de volgende tik "landde" het
1128 tweede blok op het eerste (`highestFallingBelow` → y = 13,99), waarna
1129 `cullOffTop` het als boven het scherm uit verwijderde. Erger: het telde als
1130 schot van de **ontvanger** (punt erbij en terug naar de verzender). Online
1131 en offline (bots) gebruiken dezelfde `GameCore`, dus beide hadden dit. De
1132 server en `online.js` gooien niets weg: de server markeert schoten als
1133 afgeleverd en `Online.onIncoming` roept per blok `ingestGarbage` aan.
1134
1135 **Oplossing (gedeelde `GameCore`).**
1136 - `ingestGarbage(col)` zet het blok in `garbageQueue` (volgorde van
1137 binnenkomst) en probeert meteen te droppen; geeft het blok terug als het
1138 direct viel, anders `null` (het wacht).
1139 - `drainGarbageQueue()` draait bij elke `tick` vóór het gewone spawnen.
1140 Een kolom kan een blok nemen (`garbageDropColumns`) als hij niet
1141 vergrendeld/vol is, niet vertrekkend (t1184), er na alles wat nog valt
1142 nog plek is (vast + vallend < 13), en de spawnrij vrij is
1143 (`spawnCellClear`: elk blok in de kolom minstens een hele cel onder de
1144 spawnrij — dezelfde regel als de openingsburst, nooit overlap).
1145 - De gewenste kolom wint als die kan; anders een willekeurige open kolom.
1146 Is er geen open kolom, dan blijft het blok wachten (ook als alle open
1147 kolommen door vertrekkende raketten bezet zijn — dat verving de oude
1148 terugval naar de gewenste kolom).
1149 - Na game over worden geen blokken meer aangenomen (zoals voorheen).
1150 - Online bepaalt het eigen apparaat van de ontvanger de plaatsing. De
1151 vluchtanimatie mikt nog op `land_col`; een blok dat moet wachten of
1152 uitwijkt verschijnt daarna bovenaan in de gekozen kolom.
1153
1154 Tests: `test/garbage-queue.test.js` (o.a. exact scenario: 5 tegelijk, 2
1155 open kolommen → alle 5 landen; ook via offline bots);
1156 `test/t1192-garbage-queue-playwright.py ROOT TAG` (twee browsers lokaal).
1157
@@ -1116,3 +1116,42 @@ seconde, en daarna pas de rate increase doen die we nu hebben." Daarna
1116Tests: `test/spawn-timeline.test.js`; browser:
1116Tests: `test/spawn-timeline.test.js`; browser:
1117`test/t1189-spawn-timeline-playwright.py URL TAG`.
1117`test/t1189-spawn-timeline-playwright.py URL TAG`.
1118
1118
1119## t1192 — ontvangen blokken gaan nooit verloren
1120
1121Tim: bij ~5 blokken tegelijk naar iemand met nog maar twee vrije kolommen
1122viel soms alleen het eerste blok en verdwenen de rest.
1123
1124**Oorzaak.** `GameCore.ingestGarbage` maakte elk ontvangen blok meteen aan
1125op de spawnrij (y = 13) van de gekozen kolom, zonder te kijken of daar al
1126een blok zat; de gewenste kolom (`land_col`) won altijd. Meerdere blokken
1127in dezelfde kolom lagen dus op elkaar. In de volgende tik "landde" het
1128tweede blok op het eerste (`highestFallingBelow` → y = 13,99), waarna
1129`cullOffTop` het als boven het scherm uit verwijderde. Erger: het telde als
1130schot van de **ontvanger** (punt erbij en terug naar de verzender). Online
1131en offline (bots) gebruiken dezelfde `GameCore`, dus beide hadden dit. De
1132server en `online.js` gooien niets weg: de server markeert schoten als
1133afgeleverd en `Online.onIncoming` roept per blok `ingestGarbage` aan.
1134
1135**Oplossing (gedeelde `GameCore`).**
1136- `ingestGarbage(col)` zet het blok in `garbageQueue` (volgorde van
1137 binnenkomst) en probeert meteen te droppen; geeft het blok terug als het
1138 direct viel, anders `null` (het wacht).
1139- `drainGarbageQueue()` draait bij elke `tick` vóór het gewone spawnen.
1140 Een kolom kan een blok nemen (`garbageDropColumns`) als hij niet
1141 vergrendeld/vol is, niet vertrekkend (t1184), er na alles wat nog valt
1142 nog plek is (vast + vallend < 13), en de spawnrij vrij is
1143 (`spawnCellClear`: elk blok in de kolom minstens een hele cel onder de
1144 spawnrij — dezelfde regel als de openingsburst, nooit overlap).
1145- De gewenste kolom wint als die kan; anders een willekeurige open kolom.
1146 Is er geen open kolom, dan blijft het blok wachten (ook als alle open
1147 kolommen door vertrekkende raketten bezet zijn — dat verving de oude
1148 terugval naar de gewenste kolom).
1149- Na game over worden geen blokken meer aangenomen (zoals voorheen).
1150- Online bepaalt het eigen apparaat van de ontvanger de plaatsing. De
1151 vluchtanimatie mikt nog op `land_col`; een blok dat moet wachten of
1152 uitwijkt verschijnt daarna bovenaan in de gekozen kolom.
1153
1154Tests: `test/garbage-queue.test.js` (o.a. exact scenario: 5 tegelijk, 2
1155open kolommen → alle 5 landen; ook via offline bots);
1156`test/t1192-garbage-queue-playwright.py ROOT TAG` (twee browsers lokaal).
1157