t1189/t1191: docs (NL) and build
@@ -202,9 +202,12 @@ op het podium en daarna ga je terug naar de lobby.
202
202
veldhoogte en gaat hij zeker het scherm uit, dan valt er geen nieuw blok
203
203
en geen ontvangen (grijs) blok in de kolommen van die stapel: ze kiezen
204
204
een andere kolom.
205
- Het tempo loopt op: na elk nieuw blok wordt de spawn-interval 0,3%
206
korter (start 1 s, minimum 0,1 s, na ca. 767 blokken / 5 minuten). Elk
207
spel en elke ronde begint weer op 1 s, ook voor bots.
205
- Start van elke match/ronde: de eerste 3 s valt er elke 0,1 s een blok
206
(verdeeld over de legere kolommen), van 3 tot 6 s loopt de tussentijd
207
lineair terug naar 1 s.
208
- Daarna loopt het tempo op: na elk nieuw blok wordt de spawn-interval 0,3%
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.
208
211
209
212
### Raketvlam
210
213
@@ -202,9 +202,12 @@ op het podium en daarna ga je terug naar de lobby.202
veldhoogte en gaat hij zeker het scherm uit, dan valt er geen nieuw blok202
veldhoogte en gaat hij zeker het scherm uit, dan valt er geen nieuw blok203
en geen ontvangen (grijs) blok in de kolommen van die stapel: ze kiezen203
en geen ontvangen (grijs) blok in de kolommen van die stapel: ze kiezen204
een andere kolom.204
een andere kolom.205
- Het tempo loopt op: na elk nieuw blok wordt de spawn-interval 0,3%205
- Start van elke match/ronde: de eerste 3 s valt er elke 0,1 s een blok206
korter (start 1 s, minimum 0,1 s, na ca. 767 blokken / 5 minuten). Elk206
(verdeeld over de legere kolommen), van 3 tot 6 s loopt de tussentijd207
spel en elke ronde begint weer op 1 s, ook voor bots.207
lineair terug naar 1 s.208
- Daarna loopt het tempo op: na elk nieuw blok wordt de spawn-interval 0,3%209
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.208
211
209
### Raketvlam212
### Raketvlam210
213
@@ -5171,6 +5171,8 @@ function GameCore (planet, rng)
5171
5171
this.nextClusterId = 1;
5172
5172
this.spawnTimer = 0;
5173
5173
this.spawnInterval = PlanetMod.SPAWN_INTERVAL;
5174
/** Seconds of actual play in this match / round (t1189). */
5175
this.playTime = 0;
5174
5176
this.settleTime = PlanetMod.SETTLE_TIME;
5175
5177
this.score = 0;
5176
5178
this.state = 'playing';
@@ -5679,12 +5681,17 @@ GameCore.prototype.tick = function (dt)
5679
5681
{ return; }
5680
5682
dt = Math.min(dt, 0.1);
5681
5683
5684
// t1189: spawn timeline by elapsed play time (intro burst, ramp, then
5685
// the per-spawn speed-up). Interval is re-read after every spawn.
5682
5686
this.spawnTimer += dt;
5683
while (this.spawnTimer >= this.spawnInterval)
5687
var iv = this.currentSpawnInterval();
5688
while (this.spawnTimer >= iv)
5684
5689
{
5685
this.spawnTimer -= this.spawnInterval;
5690
this.spawnTimer -= iv;
5686
5691
this.trySpawn();
5692
iv = this.currentSpawnInterval();
5687
5693
}
5694
this.playTime += dt;
5688
5695
5689
5696
var left = dt;
5690
5697
while (left > 1e-12)
@@ -5822,27 +5829,106 @@ GameCore.prototype.trySpawn = function ()
5822
5829
{ continue; }
5823
5830
var alreadyFalling = false;
5824
5831
var list = this.blocksInColumn(col);
5832
// t1189/t1191: during the opening burst and ramp a column may take
5833
// another block as soon as the previous falling one has cleared a
5834
// full cell below the spawn row (no overlap); later the classic
5835
// one-falling-block-per-column rule applies.
5836
var opening = this.playTime < GameCore.SPAWN_RAMP_END;
5825
5837
for (var i = 0; i < list.length; i++)
5826
5838
{
5827
if (list[i].state === STATE_FALLING)
5828
{
5829
alreadyFalling = true;
5830
break;
5831
}
5839
if (list[i].state !== STATE_FALLING)
5840
{ continue; }
5841
if (opening && list[i].y <= this.height - 1 + 1e-9)
5842
{ continue; }
5843
alreadyFalling = true;
5844
break;
5832
5845
}
5833
5846
if (!alreadyFalling)
5834
5847
{ eligible.push(col); }
5835
5848
}
5836
5849
if (!eligible.length)
5837
5850
{ return null; }
5838
var col = eligible[Math.floor(this.rng() * eligible.length) % eligible.length];
5851
var col = this.playTime < GameCore.SPAWN_INTRO_END
5852
? this.pickWeightedSpawnColumn(eligible)
5853
: eligible[Math.floor(this.rng() * eligible.length) % eligible.length];
5839
5854
var color = this.randomColor();
5840
5855
var block = this.createBlock(col, this.height, color, STATE_FALLING);
5841
5856
block.vy = -this.planet.fallSpeed;
5842
this.speedUpSpawning();
5857
// t1187/t1188 speed-up only counts blocks spawned after the intro (t1189).
5858
if (this.playTime >= GameCore.SPAWN_RAMP_END)
5859
{ this.speedUpSpawning(); }
5843
5860
return block;
5844
5861
};
5845
5862
5863
/**
5864
* Burst-phase column choice (t1191): weight each eligible column by its
5865
* free cells (height − grounded − already falling blocks, min 1), so the fast opening burst fills
5866
* the field evenly instead of piling onto one column. One rng() draw, like
5867
* the uniform pick.
5868
*/
5869
GameCore.prototype.fallingCount = function (col)
5870
{
5871
var n = 0;
5872
for (var i = 0; i < this.blocks.length; i++)
5873
{
5874
if (this.blocks[i].col === col && this.blocks[i].state === STATE_FALLING)
5875
{ n++; }
5876
}
5877
return n;
5878
};
5879
5880
GameCore.prototype.pickWeightedSpawnColumn = function (eligible)
5881
{
5882
var weights = [];
5883
var total = 0;
5884
for (var i = 0; i < eligible.length; i++)
5885
{
5886
var w = Math.max(1, this.height - this.groundedCount(eligible[i]) - this.fallingCount(eligible[i]));
5887
weights.push(w);
5888
total += w;
5889
}
5890
var r = this.rng() * total;
5891
for (var j = 0; j < eligible.length; j++)
5892
{
5893
r -= weights[j];
5894
if (r < 0)
5895
{ return eligible[j]; }
5896
}
5897
return eligible[eligible.length - 1];
5898
};
5899
5900
/** t1189/t1191: first seconds of a match spawn fast ... */
5901
GameCore.SPAWN_INTRO_END = 3;
5902
/** ... at this interval (seconds) ... */
5903
GameCore.SPAWN_INTRO_INTERVAL = 0.1;
5904
/** ... then lerp back to PlanetMod.SPAWN_INTERVAL (1 s) until this time. */
5905
GameCore.SPAWN_RAMP_END = 6;
5906
5907
/**
5908
* Spawn interval right now (t1189):
5909
* playTime < 3 s → 0.1 s (burst, weighted column choice)
5910
* 3 s – 6 s → linear 0.1 s → 1.0 s
5911
* ≥ 6 s → spawnInterval (starts at 1 s, ×0.997 per spawn
5912
* after 6 s, floor 0.1 s)
5913
* An interval set above the 1 s start (tests / tools use 1e9 to switch
5914
* spawning off) is always respected.
5915
*/
5916
GameCore.prototype.currentSpawnInterval = function ()
5917
{
5918
var base = PlanetMod.SPAWN_INTERVAL;
5919
if (this.spawnInterval > base + 1e-9)
5920
{ return this.spawnInterval; }
5921
var t = this.playTime || 0;
5922
if (t < GameCore.SPAWN_INTRO_END)
5923
{ return GameCore.SPAWN_INTRO_INTERVAL; }
5924
if (t < GameCore.SPAWN_RAMP_END)
5925
{
5926
var k = (t - GameCore.SPAWN_INTRO_END) / (GameCore.SPAWN_RAMP_END - GameCore.SPAWN_INTRO_END);
5927
return GameCore.SPAWN_INTRO_INTERVAL + (base - GameCore.SPAWN_INTRO_INTERVAL) * k;
5928
}
5929
return this.spawnInterval;
5930
};
5931
5846
5932
/** Each spawned block shrinks the spawn interval by 0.3% (t1187 / t1188). */
5847
5933
GameCore.SPAWN_SPEEDUP = 0.997;
5848
5934
/** The spawn interval never goes below this (seconds, t1187). */
@@ -5171,6 +5171,8 @@ function GameCore (planet, rng)5171
this.nextClusterId = 1;5171
this.nextClusterId = 1;5172
this.spawnTimer = 0;5172
this.spawnTimer = 0;5173
this.spawnInterval = PlanetMod.SPAWN_INTERVAL;5173
this.spawnInterval = PlanetMod.SPAWN_INTERVAL;5174
/** Seconds of actual play in this match / round (t1189). */5175
this.playTime = 0;5174
this.settleTime = PlanetMod.SETTLE_TIME;5176
this.settleTime = PlanetMod.SETTLE_TIME;5175
this.score = 0;5177
this.score = 0;5176
this.state = 'playing';5178
this.state = 'playing';@@ -5679,12 +5681,17 @@ GameCore.prototype.tick = function (dt)5679
{ return; }5681
{ return; }5680
dt = Math.min(dt, 0.1);5682
dt = Math.min(dt, 0.1);5681
5683
5684
// t1189: spawn timeline by elapsed play time (intro burst, ramp, then5685
// the per-spawn speed-up). Interval is re-read after every spawn.5682
this.spawnTimer += dt;5686
this.spawnTimer += dt;5683
while (this.spawnTimer >= this.spawnInterval)5687
var iv = this.currentSpawnInterval();5688
while (this.spawnTimer >= iv)5684
{5689
{5685
this.spawnTimer -= this.spawnInterval;5690
this.spawnTimer -= iv;5686
this.trySpawn();5691
this.trySpawn();5692
iv = this.currentSpawnInterval();5687
}5693
}5694
this.playTime += dt;5688
5695
5689
var left = dt;5696
var left = dt;5690
while (left > 1e-12)5697
while (left > 1e-12)@@ -5822,27 +5829,106 @@ GameCore.prototype.trySpawn = function ()5822
{ continue; }5829
{ continue; }5823
var alreadyFalling = false;5830
var alreadyFalling = false;5824
var list = this.blocksInColumn(col);5831
var list = this.blocksInColumn(col);5832
// t1189/t1191: during the opening burst and ramp a column may take5833
// another block as soon as the previous falling one has cleared a5834
// full cell below the spawn row (no overlap); later the classic5835
// one-falling-block-per-column rule applies.5836
var opening = this.playTime < GameCore.SPAWN_RAMP_END;5825
for (var i = 0; i < list.length; i++)5837
for (var i = 0; i < list.length; i++)5826
{5838
{5827
if (list[i].state === STATE_FALLING)5839
if (list[i].state !== STATE_FALLING)5828
{5840
{ continue; }5829
alreadyFalling = true;5841
if (opening && list[i].y <= this.height - 1 + 1e-9)5830
break;5842
{ continue; }5831
}5843
alreadyFalling = true;5844
break;5832
}5845
}5833
if (!alreadyFalling)5846
if (!alreadyFalling)5834
{ eligible.push(col); }5847
{ eligible.push(col); }5835
}5848
}5836
if (!eligible.length)5849
if (!eligible.length)5837
{ return null; }5850
{ return null; }5838
var col = eligible[Math.floor(this.rng() * eligible.length) % eligible.length];5851
var col = this.playTime < GameCore.SPAWN_INTRO_END5852
? this.pickWeightedSpawnColumn(eligible)5853
: eligible[Math.floor(this.rng() * eligible.length) % eligible.length];5839
var color = this.randomColor();5854
var color = this.randomColor();5840
var block = this.createBlock(col, this.height, color, STATE_FALLING);5855
var block = this.createBlock(col, this.height, color, STATE_FALLING);5841
block.vy = -this.planet.fallSpeed;5856
block.vy = -this.planet.fallSpeed;5842
this.speedUpSpawning();5857
// t1187/t1188 speed-up only counts blocks spawned after the intro (t1189).5858
if (this.playTime >= GameCore.SPAWN_RAMP_END)5859
{ this.speedUpSpawning(); }5843
return block;5860
return block;5844
};5861
};5845
5862
5863
/**5864
* Burst-phase column choice (t1191): weight each eligible column by its5865
* free cells (height − grounded − already falling blocks, min 1), so the fast opening burst fills5866
* the field evenly instead of piling onto one column. One rng() draw, like5867
* the uniform pick.5868
*/5869
GameCore.prototype.fallingCount = function (col)5870
{5871
var n = 0;5872
for (var i = 0; i < this.blocks.length; i++)5873
{5874
if (this.blocks[i].col === col && this.blocks[i].state === STATE_FALLING)5875
{ n++; }5876
}5877
return n;5878
};5879
5880
GameCore.prototype.pickWeightedSpawnColumn = function (eligible)5881
{5882
var weights = [];5883
var total = 0;5884
for (var i = 0; i < eligible.length; i++)5885
{5886
var w = Math.max(1, this.height - this.groundedCount(eligible[i]) - this.fallingCount(eligible[i]));5887
weights.push(w);5888
total += w;5889
}5890
var r = this.rng() * total;5891
for (var j = 0; j < eligible.length; j++)5892
{5893
r -= weights[j];5894
if (r < 0)5895
{ return eligible[j]; }5896
}5897
return eligible[eligible.length - 1];5898
};5899
5900
/** t1189/t1191: first seconds of a match spawn fast ... */5901
GameCore.SPAWN_INTRO_END = 3;5902
/** ... at this interval (seconds) ... */5903
GameCore.SPAWN_INTRO_INTERVAL = 0.1;5904
/** ... then lerp back to PlanetMod.SPAWN_INTERVAL (1 s) until this time. */5905
GameCore.SPAWN_RAMP_END = 6;5906
5907
/**5908
* Spawn interval right now (t1189):5909
* playTime < 3 s → 0.1 s (burst, weighted column choice)5910
* 3 s – 6 s → linear 0.1 s → 1.0 s5911
* ≥ 6 s → spawnInterval (starts at 1 s, ×0.997 per spawn5912
* after 6 s, floor 0.1 s)5913
* An interval set above the 1 s start (tests / tools use 1e9 to switch5914
* spawning off) is always respected.5915
*/5916
GameCore.prototype.currentSpawnInterval = function ()5917
{5918
var base = PlanetMod.SPAWN_INTERVAL;5919
if (this.spawnInterval > base + 1e-9)5920
{ return this.spawnInterval; }5921
var t = this.playTime || 0;5922
if (t < GameCore.SPAWN_INTRO_END)5923
{ return GameCore.SPAWN_INTRO_INTERVAL; }5924
if (t < GameCore.SPAWN_RAMP_END)5925
{5926
var k = (t - GameCore.SPAWN_INTRO_END) / (GameCore.SPAWN_RAMP_END - GameCore.SPAWN_INTRO_END);5927
return GameCore.SPAWN_INTRO_INTERVAL + (base - GameCore.SPAWN_INTRO_INTERVAL) * k;5928
}5929
return this.spawnInterval;5930
};5931
5846
/** Each spawned block shrinks the spawn interval by 0.3% (t1187 / t1188). */5932
/** Each spawned block shrinks the spawn interval by 0.3% (t1187 / t1188). */5847
GameCore.SPAWN_SPEEDUP = 0.997;5933
GameCore.SPAWN_SPEEDUP = 0.997;5848
/** The spawn interval never goes below this (seconds, t1187). */5934
/** The spawn interval never goes below this (seconds, t1187). */@@ -1076,3 +1076,43 @@ Tests: `test/departing.test.js`; browser:
1076
1076
1077
1077
Tests: `test/spawn-speedup.test.js`.
1078
1078
1079
## t1189 / t1191 — openingsburst en aanloop van het spawn-tempo
1080
1081
Tim (t1189): "In de eerste 5 seconden van een match, beginnen met 0.1s
1082
tussen blokjes. Dan tussen de 5 en 8 seconden lerpen terug naar 1 per
1083
seconde, en daarna pas de rate increase doen die we nu hebben." Daarna
1084
(t1191) aangepast: burst de eerste **3 s**, dan lerp van **3 naar 6 s**.
1085
1086
- `GameCore.playTime`: seconden echte speeltijd van deze match/ronde. Telt
1087
vanaf de eerste `tick` van een nieuwe `GameCore`; er is geen aftelling,
1088
dus de tijd start als het spelen start. Elke ronde/match maakt een nieuwe
1089
core, dus de klok begint steeds bij 0 (spelers, bots, online).
1090
- `GameCore.currentSpawnInterval()`:
1091
- `playTime < SPAWN_INTRO_END` (3 s): `SPAWN_INTRO_INTERVAL` = 0,1 s.
1092
- 3 s – `SPAWN_RAMP_END` (6 s): lineair van 0,1 s naar 1,0 s
1093
(`PlanetMod.SPAWN_INTERVAL`). De lerp-duur van 3 s is behouden uit de
1094
eerste versie (aanname).
1095
- Vanaf 6 s: `spawnInterval`, start 1 s, ×0,997 per gespawnd blok,
1096
minimum 0,1 s (t1187/t1188). **Alleen blokken die na 6 s spawnen
1097
tellen** voor die versnelling.
1098
- De interval wordt na elke spawn opnieuw gelezen.
1099
- **Kolomkeuze in de burst** ("weighted column choice", t1191): tijdens de
1100
eerste 3 s kiest `pickWeightedSpawnColumn` een kolom met gewicht = vrije
1101
cellen (13 − vaste − al vallende blokken, minimaal 1). Legere kolommen
1102
krijgen dus vaker een blok; daarna weer uniform willekeurig. (De exacte
1103
weging stond niet in de opdracht; dit is mijn invulling.)
1104
- **Meerdere vallende blokken per kolom in de opening:** met 0,1 s
1105
tussentijd zouden na 10 blokken alle kolommen bezet zijn (regel: één
1106
vallend blok per kolom) en zou de burst ~2 s stilvallen. Tot 6 s mag een
1107
kolom daarom een nieuw blok krijgen zodra het vorige vallende blok een
1108
hele cel onder de spawnrij zit (geen overlap). Na 6 s geldt weer één
1109
vallend blok per kolom.
1110
- Gemeten: 30 blokken in 0–3 s, 6 in 3–6 s (36 in de eerste 6 s).
1111
- De regel voor vertrekkende raketten (t1184) blijft gelden, ook in de
1112
burst.
1113
- Testhaak: een `spawnInterval` boven 1 s (tests/tools zetten 1e9 om
1114
spawnen uit te zetten) wordt altijd gerespecteerd, ook in de burst.
1115
1116
Tests: `test/spawn-timeline.test.js`; browser:
1117
`test/t1189-spawn-timeline-playwright.py URL TAG`.
1118
@@ -1076,3 +1076,43 @@ Tests: `test/departing.test.js`; browser:1076
1076
1077
Tests: `test/spawn-speedup.test.js`.1077
Tests: `test/spawn-speedup.test.js`.1078
1078
1079
## t1189 / t1191 — openingsburst en aanloop van het spawn-tempo1080
1081
Tim (t1189): "In de eerste 5 seconden van een match, beginnen met 0.1s1082
tussen blokjes. Dan tussen de 5 en 8 seconden lerpen terug naar 1 per1083
seconde, en daarna pas de rate increase doen die we nu hebben." Daarna1084
(t1191) aangepast: burst de eerste **3 s**, dan lerp van **3 naar 6 s**.1085
1086
- `GameCore.playTime`: seconden echte speeltijd van deze match/ronde. Telt1087
vanaf de eerste `tick` van een nieuwe `GameCore`; er is geen aftelling,1088
dus de tijd start als het spelen start. Elke ronde/match maakt een nieuwe1089
core, dus de klok begint steeds bij 0 (spelers, bots, online).1090
- `GameCore.currentSpawnInterval()`:1091
- `playTime < SPAWN_INTRO_END` (3 s): `SPAWN_INTRO_INTERVAL` = 0,1 s.1092
- 3 s – `SPAWN_RAMP_END` (6 s): lineair van 0,1 s naar 1,0 s1093
(`PlanetMod.SPAWN_INTERVAL`). De lerp-duur van 3 s is behouden uit de1094
eerste versie (aanname).1095
- Vanaf 6 s: `spawnInterval`, start 1 s, ×0,997 per gespawnd blok,1096
minimum 0,1 s (t1187/t1188). **Alleen blokken die na 6 s spawnen1097
tellen** voor die versnelling.1098
- De interval wordt na elke spawn opnieuw gelezen.1099
- **Kolomkeuze in de burst** ("weighted column choice", t1191): tijdens de1100
eerste 3 s kiest `pickWeightedSpawnColumn` een kolom met gewicht = vrije1101
cellen (13 − vaste − al vallende blokken, minimaal 1). Legere kolommen1102
krijgen dus vaker een blok; daarna weer uniform willekeurig. (De exacte1103
weging stond niet in de opdracht; dit is mijn invulling.)1104
- **Meerdere vallende blokken per kolom in de opening:** met 0,1 s1105
tussentijd zouden na 10 blokken alle kolommen bezet zijn (regel: één1106
vallend blok per kolom) en zou de burst ~2 s stilvallen. Tot 6 s mag een1107
kolom daarom een nieuw blok krijgen zodra het vorige vallende blok een1108
hele cel onder de spawnrij zit (geen overlap). Na 6 s geldt weer één1109
vallend blok per kolom.1110
- Gemeten: 30 blokken in 0–3 s, 6 in 3–6 s (36 in de eerste 6 s).1111
- De regel voor vertrekkende raketten (t1184) blijft gelden, ook in de1112
burst.1113
- Testhaak: een `spawnInterval` boven 1 s (tests/tools zetten 1e9 om1114
spawnen uit te zetten) wordt altijd gerespecteerd, ook in de burst.1115
1116
Tests: `test/spawn-timeline.test.js`; browser:1117
`test/t1189-spawn-timeline-playwright.py URL TAG`.1118