t1192: docs (NL) and build
@@ -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 elke209
korter (minimum 0,1 s, na ca. 767 blokken / 5 minuten). Elk spel en elke210
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 blokken213
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 in216
die kolom moet een hele cel onder de bovenste rij zitten. Is de gewenste217
kolom vol, geblokkeerd of bezet door een vertrekkende raket, dan kiest het218
blok een andere open kolom; is er geen enkele open, dan wacht het.219
212
### Raketvlam220
### Raketvlam213
221
214
De vlam onder een raketblok wisselt 25 keer per seconde naar een willekeurig222
De vlam onder een raketblok wisselt 25 keer per seconde naar een willekeurig@@ -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, then5686
// t1189: spawn timeline by elapsed play time (intro burst, ramp, then5685
// 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 as7397
* there is room; received blocks are never lost. Returns the block when7398
* it could drop right away, otherwise null (it waits in garbageQueue).7399
*7400
* Before t1192 every received block was created at once at the spawn7401
* row of its column. Several blocks aimed at the same column overlapped7402
* there: the second one "landed" on the first at y ≥ 13, was culled off7403
* the top and even counted as the receiver's own shot.7404
*/7390
GameCore.prototype.ingestGarbage = function (col)7405
GameCore.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 opening7418
* burst: every block already in the column must be at least a full cell7419
* 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 wanted7455
* 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
else7472
{ 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
GameCore.prototype.advanceSettle = function (dt)7489
GameCore.prototype.advanceSettle = function (dt)@@ -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." Daarna1116
Tests: `test/spawn-timeline.test.js`; browser:1116
Tests: `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 verloren1120
1121
Tim: bij ~5 blokken tegelijk naar iemand met nog maar twee vrije kolommen1122
viel soms alleen het eerste blok en verdwenen de rest.1123
1124
**Oorzaak.** `GameCore.ingestGarbage` maakte elk ontvangen blok meteen aan1125
op de spawnrij (y = 13) van de gekozen kolom, zonder te kijken of daar al1126
een blok zat; de gewenste kolom (`land_col`) won altijd. Meerdere blokken1127
in dezelfde kolom lagen dus op elkaar. In de volgende tik "landde" het1128
tweede blok op het eerste (`highestFallingBelow` → y = 13,99), waarna1129
`cullOffTop` het als boven het scherm uit verwijderde. Erger: het telde als1130
schot van de **ontvanger** (punt erbij en terug naar de verzender). Online1131
en offline (bots) gebruiken dezelfde `GameCore`, dus beide hadden dit. De1132
server en `online.js` gooien niets weg: de server markeert schoten als1133
afgeleverd en `Online.onIncoming` roept per blok `ingestGarbage` aan.1134
1135
**Oplossing (gedeelde `GameCore`).**1136
- `ingestGarbage(col)` zet het blok in `garbageQueue` (volgorde van1137
binnenkomst) en probeert meteen te droppen; geeft het blok terug als het1138
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 niet1141
vergrendeld/vol is, niet vertrekkend (t1184), er na alles wat nog valt1142
nog plek is (vast + vallend < 13), en de spawnrij vrij is1143
(`spawnCellClear`: elk blok in de kolom minstens een hele cel onder de1144
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 open1147
kolommen door vertrekkende raketten bezet zijn — dat verving de oude1148
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. De1151
vluchtanimatie mikt nog op `land_col`; een blok dat moet wachten of1152
uitwijkt verschijnt daarna bovenaan in de gekozen kolom.1153
1154
Tests: `test/garbage-queue.test.js` (o.a. exact scenario: 5 tegelijk, 21155
open kolommen → alle 5 landen; ook via offline bots);1156
`test/t1192-garbage-queue-playwright.py ROOT TAG` (twee browsers lokaal).1157