BlueGit

projects-timfalken-com meteors

t1189/t1191: docs (NL) and build

timfa Grok Bot · pushed by timfa

Authored 2026-11-14 · 3 days ago

Hash
5f5bf73193faf47bfdc035a736c2f5ba9fcafaf6
Parent
7ab4a7f4
3 files changed +141 −12
README.md +6 −3
@@ -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 blok
202 veldhoogte en gaat hij zeker het scherm uit, dan valt er geen nieuw blok
203 en geen ontvangen (grijs) blok in de kolommen van die stapel: ze kiezen
203 en geen ontvangen (grijs) blok in de kolommen van die stapel: ze kiezen
204 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 blok
206 korter (start 1 s, minimum 0,1 s, na ca. 767 blokken / 5 minuten). Elk
206 (verdeeld over de legere kolommen), van 3 tot 6 s loopt de tussentijd
207 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 elke
210 ronde begint weer bij 0 s, ook voor bots en online.
208
211
209### Raketvlam
212### Raketvlam
210
213
build/game.js +95 −9
@@ -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, then
5685 // 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 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 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_END
5852 ? 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 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 */
5869GameCore.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
5880GameCore.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 ... */
5901GameCore.SPAWN_INTRO_END = 3;
5902/** ... at this interval (seconds) ... */
5903GameCore.SPAWN_INTRO_INTERVAL = 0.1;
5904/** ... then lerp back to PlanetMod.SPAWN_INTERVAL (1 s) until this time. */
5905GameCore.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 */
5916GameCore.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). */
5847GameCore.SPAWN_SPEEDUP = 0.997;
5933GameCore.SPAWN_SPEEDUP = 0.997;
5848/** The spawn interval never goes below this (seconds, t1187). */
5934/** The spawn interval never goes below this (seconds, t1187). */
docs/ASSUMPTIONS.md +40 −0
@@ -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
1077Tests: `test/spawn-speedup.test.js`.
1077Tests: `test/spawn-speedup.test.js`.
1078
1078
1079## t1189 / t1191 — openingsburst en aanloop van het spawn-tempo
1080
1081Tim (t1189): "In de eerste 5 seconden van een match, beginnen met 0.1s
1082tussen blokjes. Dan tussen de 5 en 8 seconden lerpen terug naar 1 per
1083seconde, 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
1116Tests: `test/spawn-timeline.test.js`; browser:
1117`test/t1189-spawn-timeline-playwright.py URL TAG`.
1118