Release alpha 13 balance and mission tests

server/nakama/tests/balance_mission_test.js

@@ -0,0 +1,149 @@
+const fs = require("fs");
+const vm = require("vm");
+const path = require("path");
+const assert = require("assert");
+
+const source = fs.readFileSync(path.join(__dirname, "..", "runtime", "build", "index.js"), "utf8");
+const context = { console, Math, Date, JSON, isFinite };
+vm.createContext(context);
+vm.runInContext(source, context);
+
+function seedRandom(seed) {
+  let value = seed >>> 0;
+  return function () {
+    value = (value * 1664525 + 1013904223) >>> 0;
+    return value / 0x100000000;
+  };
+}
+
+function samplePath(route) {
+  const samples = [];
+  for (let i = 0; i < route.length - 1; i++) {
+    const [ax, ay] = route[i], [bx, by] = route[i + 1];
+    const length = Math.hypot(bx - ax, by - ay);
+    const steps = Math.max(1, Math.ceil(length / 40));
+    for (let step = 0; step < steps; step++) {
+      const ratio = step / steps;
+      samples.push([ax + (bx - ax) * ratio, ay + (by - ay) * ratio, length / steps]);
+    }
+  }
+  return samples;
+}
+
+const pathSamples = [samplePath(context.PATHS[0]), samplePath(context.PATHS[1])];
+const areaFactor = [1, 1, 1.65, 1.6, 1.9, 1.35, 1];
+
+function nextWaveComposition(state, wave) {
+  const schedule = context.buildWaveSchedule(state, wave, context.wavePopulation(state, wave));
+  const counts = Array(context.ENEMIES.length).fill(0);
+  for (const entry of schedule) counts[entry.type] += 1;
+  return { schedule, counts };
+}
+
+function chooseTowerType(state, composition, fixedType) {
+  if (fixedType !== null) return fixedType;
+  let bestType = 1, bestScore = -1;
+  for (let towerType = 0; towerType < context.TOWERS.length; towerType++) {
+    const tower = context.TOWERS[towerType];
+    let score = 0;
+    for (let enemyType = 0; enemyType < context.ENEMIES.length; enemyType++) {
+      const count = composition.counts[enemyType];
+      if (!count) continue;
+      const enemy = context.ENEMIES[enemyType];
+      if (tower.targetClass !== "both" && tower.targetClass !== enemy.category) continue;
+      const damage = tower.damage * (tower.targetClass === "both" ? tower.bothScale || 1 : 1);
+      const exposedDps = damage / tower.cooldown;
+      const shieldChance = enemyType === 4 ? 1 : 0.25;
+      const shieldMultiplier = towerType === 1 || towerType === 5 ? 1 : 1 - shieldChance * (1 - (enemy.shieldResistance || 0.28));
+      const bossWeight = composition.schedule.some(entry => entry.type === enemyType && entry.boss) ? 1.2 : 1;
+      score += count * Math.sqrt(enemy.hp) * exposedDps * shieldMultiplier * areaFactor[towerType] * bossWeight;
+    }
+    score /= Math.max(1, tower.cost);
+    if (score > bestScore) { bestScore = score; bestType = towerType; }
+  }
+  return bestType;
+}
+
+function choosePosition(state, owner, range) {
+  const xMin = owner === 0 ? 120 : 1520;
+  const xMax = owner === 0 ? 1440 : 2840;
+  let best = null, bestScore = -1;
+  for (let y = 120; y <= 680; y += 80) for (let x = xMin; x <= xMax; x += 80) {
+    if (!context.validBuildPosition(state, owner, x, y)) continue;
+    const rangeSq = range * range;
+    let score = 0;
+    for (const [px, py, weight] of pathSamples[owner]) {
+      const covered = state.towers.some(tower => tower.owner === owner &&
+        context.distanceSquared(tower.x, tower.y, px, py) <= context.towerRange(state, tower) ** 2);
+      if (!covered && context.distanceSquared(x, y, px, py) <= rangeSq) score += weight;
+    }
+    if (score > bestScore) { bestScore = score; best = [x, y]; }
+  }
+  return best;
+}
+
+function runMission(difficulty, fixedType = null) {
+  let random = seedRandom(0xB45710 + difficulty * 7919 + (fixedType === null ? 0 : fixedType * 97));
+  context.Math = Object.create(Math);
+  context.Math.random = () => random();
+  const state = context.initialState({ difficulty, mode: "balance_test" });
+  state.started = true;
+  let wavesCompleted = 0, totalSpawned = 0, totalBreached = 0;
+  const trace = [];
+  const maxTicksPerWave = 24000;
+
+  for (let wave = 1; wave <= 15 && !state.gameOver; wave++) {
+    const composition = nextWaveComposition(state, wave);
+    for (let owner = 0; owner < 2; owner++) {
+      let guard = 32;
+      while (guard-- > 0) {
+        const towerType = chooseTowerType(state, composition, fixedType);
+        const tower = context.TOWERS[towerType];
+        if (state.credits[owner] < tower.cost) break;
+        const position = choosePosition(state, owner, tower.range);
+        if (!position) break;
+        state.credits[owner] -= tower.cost;
+        state.towers.push({ id: state.nextTowerId++, type: towerType, x: position[0], y: position[1], owner, level: 1, cooldown: 0.15, angle: owner === 0 ? 0 : Math.PI });
+      }
+    }
+    if (!context.startWave(state)) break;
+    const beforeSpawn = state.nextEnemyId;
+    let tick = 0;
+    while (state.waveActive && !state.gameOver && tick++ < maxTicksPerWave) {
+      context.updateWave(state, 0.1, { broadcastMessage() {} });
+      context.updateEnemies(state, 0.1);
+      context.updateTowers(state, 0.1);
+    }
+    totalSpawned += state.nextEnemyId - beforeSpawn;
+    totalBreached += Math.max(0, 30 - state.reactorLives);
+    trace.push({wave, lives: state.reactorLives, spawned: state.nextEnemyId - beforeSpawn, towers: state.towers.length, credits: [...state.credits], enemyLeft: state.enemies.length, towerTypes: state.towers.map(t => t.type)});
+    if (tick >= maxTicksPerWave) break;
+    if (!state.gameOver) wavesCompleted++;
+  }
+  return { difficulty, fixedType, wavesCompleted, reactorLives: state.reactorLives, trace,
+    towers: state.towers.length, spawned: totalSpawned, remainingEnemies: state.enemies.length,
+    credits: state.credits.reduce((sum, value) => sum + value, 0) };
+}
+
+const baseline = [];
+for (let difficulty = 0; difficulty < context.DIFFICULTIES.length; difficulty++) {
+  baseline.push(runMission(difficulty));
+}
+const towerRuns = [];
+for (let tower = 0; tower < context.TOWERS.length; tower++) {
+  for (let difficulty = 0; difficulty < context.DIFFICULTIES.length; difficulty++) {
+    towerRuns.push(runMission(difficulty, tower));
+  }
+}
+
+assert.strictEqual(baseline.length, 3);
+assert.ok(towerRuns.length === context.TOWERS.length * 3);
+assert.ok(baseline.every(result => result.spawned > 0), "mission simulations must use the real wave scheduler");
+console.log("BALANCE MISSION RESULTS (Nakama wave/combat code, fixed-seed greedy build planner, level-1 towers)");
+console.log("planner: " + baseline.map(r => `D${r.difficulty} ${r.wavesCompleted}/15 waves, reactor ${r.reactorLives}, ${r.towers} towers`).join(" | "));
+for (let tower = 0; tower < context.TOWERS.length; tower++) {
+  const values = towerRuns.filter(result => result.fixedType === tower)
+    .map(r => `D${r.difficulty} ${r.wavesCompleted}/15, R${r.reactorLives}, ${r.towers}T`).join(" | ");
+  console.log(`tower ${tower} (${context.TOWERS[tower].targetClass}): ${values}`);
+}
+console.log(`BALANCE_MISSION_TEST_OK scenarios=${baseline.length + towerRuns.length}`);