337 lines
14 KiB
JavaScript
337 lines
14 KiB
JavaScript
import { TestCase } from "./framework/test_case.js";
|
|
import { smallState, cityOf, stripPorts } from "./framework/helpers.js";
|
|
import { key } from "../shared/hex.js";
|
|
import { TRENCH } from "../shared/data/combat.js";
|
|
|
|
const BIG_BUDGET = 1.0e15;
|
|
|
|
function emptyLandPair(state) {
|
|
for (const cell of state.landCells) {
|
|
if (state.unitAt(cell) || state.cityAt(cell)) continue;
|
|
for (const neighbour of state.topology.neighbours(cell.x, cell.y)) {
|
|
if (!state._isLand(neighbour)) continue;
|
|
if (state.unitAt(neighbour) || state.cityAt(neighbour)) continue;
|
|
return { a: { x: cell.x, y: cell.y }, b: { x: neighbour.x, y: neighbour.y } };
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
function ownLand(state, civ = 0) {
|
|
for (const cell of state.landCells) {
|
|
if (state.civAt(cell) !== civ) continue;
|
|
if (state.unitAt(cell) || state.cityAt(cell)) continue;
|
|
return cell;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
export class TrenchTest extends TestCase {
|
|
test_infantry_dig_in_on_their_own_land() {
|
|
const state = smallState();
|
|
const coords = ownLand(state);
|
|
this.assertNotNull(coords, "the nation holds land");
|
|
const infantry = state._spawnUnit(coords, 0, state.protoUnits[0]);
|
|
this.assertTrue(state.requestDigTrench([infantry.id]));
|
|
this.assertTrue(state.trenches.has(key(coords.x, coords.y)));
|
|
this.assertFalse(state.requestDigTrench([infantry.id]), "already dug in");
|
|
}
|
|
|
|
test_only_infantry_can_dig() {
|
|
const state = smallState();
|
|
const coords = ownLand(state);
|
|
const artillery = state._spawnUnit(coords, 0, state.protoUnits[2]);
|
|
this.assertFalse(state.requestDigTrench([artillery.id]));
|
|
this.assertFalse(state.trenches.has(key(coords.x, coords.y)));
|
|
}
|
|
|
|
test_trenches_multiply_defense_and_cut_gdp() {
|
|
const state = smallState();
|
|
// A seeded port adds flat GDP that the trench multiplier would not scale.
|
|
stripPorts(state, 0);
|
|
const coords = ownLand(state);
|
|
const k = key(coords.x, coords.y);
|
|
const before = state.getTileGdpPerCapita(coords);
|
|
state.trenches.add(k);
|
|
state._gdpPerCapitaCache.delete(k);
|
|
this.assertApprox(
|
|
state.getTileGdpPerCapita(coords),
|
|
before * TRENCH.productionMultiplier,
|
|
1e-6,
|
|
"a trench costs the tile a fifth of its GDP per capita"
|
|
);
|
|
// Infantry attackers are blunted partly; artillery far more.
|
|
const infantryProto = state.protoUnits[0];
|
|
const artilleryProto = state.protoUnits[2];
|
|
this.assertApprox(
|
|
state._tileFortificationMultiplier(coords, infantryProto),
|
|
TRENCH.meleeDefenseMultiplier,
|
|
1e-9
|
|
);
|
|
this.assertApprox(
|
|
state._tileFortificationMultiplier(coords, artilleryProto),
|
|
TRENCH.artilleryDefenseMultiplier,
|
|
1e-9
|
|
);
|
|
}
|
|
}
|
|
|
|
export class CaptureTest extends TestCase {
|
|
test_infantry_captures_unaccompanied_artillery() {
|
|
const state = smallState();
|
|
const pair = emptyLandPair(state);
|
|
const artillery = state._spawnUnit(pair.a, 0, state.protoUnits[2]);
|
|
const infantry = state._spawnUnit(pair.b, 1, state.protoUnits[0]);
|
|
// A gun is usually spiked when taken; force the one-in-five capture.
|
|
state._random = () => 0.9;
|
|
this.assertTrue(state.requestMove(infantry.id, pair.a));
|
|
state.advanceMovement(1000);
|
|
this.assertEqual(artillery.civ, 1, "the battery changed hands");
|
|
}
|
|
|
|
test_infantry_beside_the_artillery_protects_it() {
|
|
const state = smallState();
|
|
const pair = emptyLandPair(state);
|
|
const artillery = state._spawnUnit(pair.a, 0, state.protoUnits[2]);
|
|
state._spawnUnit(pair.a, 0, state.protoUnits[0]);
|
|
const infantry = state._spawnUnit(pair.b, 1, state.protoUnits[0]);
|
|
this.assertTrue(state.requestMove(infantry.id, pair.a));
|
|
state.advanceMovement(1000);
|
|
this.assertEqual(artillery.civ, 0, "the artillery is not captured while sheltered");
|
|
}
|
|
|
|
test_walking_onto_a_radar_tower_captures_it() {
|
|
const state = smallState();
|
|
const pair = emptyLandPair(state);
|
|
const k = key(pair.a.x, pair.a.y);
|
|
state.tileImprovements.set(k, "radar_tower");
|
|
state.tileImprovementOwner.set(k, 0);
|
|
state.tileImprovementHp.set(k, 500);
|
|
const infantry = state._spawnUnit(pair.b, 1, state.protoUnits[0]);
|
|
this.assertTrue(state.requestMove(infantry.id, pair.a));
|
|
state.advanceMovement(1000);
|
|
this.assertEqual(state.tileImprovementOwner.get(k), 1, "the radar tower changed hands");
|
|
this.assertTrue(state.tileImprovements.has(k), "the tower is captured, not destroyed");
|
|
}
|
|
|
|
test_capturing_a_city_takes_its_aircraft() {
|
|
const state = smallState();
|
|
const city = cityOf(state, 1);
|
|
const airport = state.protoBuildings.findIndex((b) => b.id === "airport");
|
|
city.buildings[airport] = 1;
|
|
const jet = state._spawnUnit(
|
|
city.coords,
|
|
1,
|
|
state.protoUnits.find((u) => u.id === "jet_fighter"),
|
|
city.id
|
|
);
|
|
// Aircraft are usually destroyed with the field; force the one-in-five
|
|
// chance that the plane is taken intact.
|
|
state._random = () => 0.9;
|
|
state._captureCity(city, 0);
|
|
this.assertEqual(jet.civ, 0, "the aircraft is captured with the city");
|
|
this.assertEqual(jet.homeCityId, city.id);
|
|
}
|
|
}
|
|
|
|
export class TileImprovementTest extends TestCase {
|
|
test_a_radar_tower_takes_time_to_build() {
|
|
const state = smallState();
|
|
state.budgets.set(0, BIG_BUDGET);
|
|
const coords = ownLand(state);
|
|
const k = key(coords.x, coords.y);
|
|
this.assertTrue(state.requestBuildTileImprovement(0, coords, "radar_tower"));
|
|
this.assertFalse(state.tileImprovements.has(k), "not raised instantly");
|
|
for (let i = 0; i < 100000 && !state.tileImprovements.has(k); i++) state.advanceHour();
|
|
this.assertEqual(state.tileImprovements.get(k), "radar_tower", "the work completes");
|
|
this.assertEqual(state.tileImprovementOwner.get(k), 0);
|
|
}
|
|
|
|
test_a_coastal_cannon_needs_the_sea() {
|
|
const state = smallState();
|
|
state.budgets.set(0, BIG_BUDGET);
|
|
// A coastal preference can put every owned tile on the shore, so reach for
|
|
// a landlocked tile explicitly.
|
|
const inland = state.landCells.find((cell) =>
|
|
state.civAt(cell) === 0 &&
|
|
!state.unitAt(cell) &&
|
|
!state.cityAt(cell) &&
|
|
!state.isCoastalCoords(cell)
|
|
);
|
|
this.assertNotNull(inland, "the fixture has an inland tile");
|
|
this.assertFalse(
|
|
state.requestBuildTileImprovement(0, inland, "coastal_cannon"),
|
|
"an inland tile cannot host a coastal cannon"
|
|
);
|
|
}
|
|
|
|
test_improvements_cost_an_hourly_maintenance() {
|
|
const state = smallState();
|
|
state.budgets.set(0, BIG_BUDGET);
|
|
const coords = ownLand(state);
|
|
const k = key(coords.x, coords.y);
|
|
const before = state.getTileImprovementUpkeep(0);
|
|
state.tileImprovements.set(k, "fortifications");
|
|
state.tileImprovementOwner.set(k, 0);
|
|
state.tileImprovementHp.set(k, 2000);
|
|
this.assertGreater(state.getTileImprovementUpkeep(0), before, "forts carry upkeep");
|
|
}
|
|
|
|
test_fortifications_hold_permanent_control() {
|
|
const state = smallState();
|
|
const city = cityOf(state, 0);
|
|
// A tile right beside the city: without the fort it would fall with it.
|
|
const coords = state.topology
|
|
.neighbours(city.coords.x, city.coords.y)
|
|
.find((n) => state._isLand(n) && state.civAt(n) === 0 && !state.unitAt(n) && !state.cityAt(n));
|
|
this.assertNotNull(coords, "the city borders a tile of its own land");
|
|
const k = key(coords.x, coords.y);
|
|
state.tileImprovements.set(k, "fortifications");
|
|
state.tileImprovementOwner.set(k, 0);
|
|
state.tileImprovementHp.set(k, 2000);
|
|
state._captureCity(city, 1);
|
|
this.assertEqual(state.civAt(coords), 0, "the fort's area of control never changes hands");
|
|
}
|
|
|
|
test_a_coastal_cannon_fires_on_a_warship() {
|
|
const state = smallState();
|
|
const coastal = state.landCells.find((cell) =>
|
|
state.civAt(cell) === 0 &&
|
|
state.topology.neighbours(cell.x, cell.y).some(
|
|
(n) => state.tiles[key(n.x, n.y)].terrainClass === "Sea"
|
|
)
|
|
);
|
|
this.assertNotNull(coastal, "the nation holds a coastal tile");
|
|
const sea = state.topology.neighbours(coastal.x, coastal.y).find(
|
|
(n) => state.tiles[key(n.x, n.y)].terrainClass === "Sea"
|
|
);
|
|
const k = key(coastal.x, coastal.y);
|
|
state.tileImprovements.set(k, "coastal_cannon");
|
|
state.tileImprovementOwner.set(k, 0);
|
|
state.tileImprovementHp.set(k, 800);
|
|
const warship = state._spawnUnit(
|
|
sea,
|
|
1,
|
|
state.protoUnits.find((u) => u.id === "battleship")
|
|
);
|
|
const hp = warship.hp;
|
|
state._tickCoastalCannons();
|
|
this.assertLess(warship.hp, hp, "the cannon hits the warship");
|
|
this.assertTrue(state.tileImprovements.has(k), "the cannon survives (only fires)");
|
|
}
|
|
}
|
|
|
|
export class TransportTest extends TestCase {
|
|
coastalSetup(state) {
|
|
for (const cell of state.landCells) {
|
|
if (state.civAt(cell) !== 0) continue;
|
|
for (const neighbour of state.topology.neighbours(cell.x, cell.y)) {
|
|
if (state.tiles[key(neighbour.x, neighbour.y)].terrainClass !== "Sea") continue;
|
|
if (state.unitAt(cell) || state.unitAt(neighbour)) continue;
|
|
return { land: { x: cell.x, y: cell.y }, sea: { x: neighbour.x, y: neighbour.y } };
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
test_infantry_board_a_launch_and_are_carried() {
|
|
const state = smallState();
|
|
const spot = this.coastalSetup(state);
|
|
this.assertNotNull(spot, "the nation has a coastal tile");
|
|
const launchProto = state.protoUnits.find((u) => u.id === "launch");
|
|
const launch = state._spawnUnit(spot.sea, 0, launchProto);
|
|
const infantry = state._spawnUnit(spot.land, 0, state.protoUnits[0]);
|
|
this.assertTrue(state.requestEmbark([infantry.id], launch.id), "boarding begins");
|
|
for (let i = 0; i < 24; i++) state.advanceHour();
|
|
this.assertNull(state.findUnit(infantry.id), "the infantry left the map");
|
|
this.assertEqual(launch.cargo.length, 1, "the infantry is cargo");
|
|
}
|
|
|
|
test_a_spy_can_board_a_launch_and_go_ashore() {
|
|
const state = smallState();
|
|
const spot = this.coastalSetup(state);
|
|
this.assertNotNull(spot, "the nation has a coastal tile");
|
|
const launch = state._spawnUnit(spot.sea, 0, state.protoUnits.find((u) => u.id === "launch"));
|
|
const spyProto = state.protoUnits.find((u) => u.id === "spy");
|
|
const spy = state._spawnUnit(spot.land, 0, spyProto);
|
|
this.assertTrue(state.requestEmbark([spy.id], launch.id), "a spy may board");
|
|
for (let i = 0; i < 24; i++) state.advanceHour();
|
|
this.assertNull(state.findUnit(spy.id), "the spy left the map");
|
|
this.assertEqual(launch.cargo.length, 1, "the spy is cargo");
|
|
this.assertTrue(state.requestDisembark([launch.id], spot.land), "the spy goes ashore");
|
|
this.assertTrue(
|
|
state.unitsAt(spot.land).some((unit) => unit.proto === state.protoUnits.indexOf(spyProto)),
|
|
"the spy stands on the shore"
|
|
);
|
|
}
|
|
|
|
test_a_worker_stays_ashore() {
|
|
const state = smallState();
|
|
const spot = this.coastalSetup(state);
|
|
const launch = state._spawnUnit(spot.sea, 0, state.protoUnits.find((u) => u.id === "launch"));
|
|
const worker = state._spawnUnit(spot.land, 0, state.protoUnits.find((u) => u.id === "worker"));
|
|
this.assertFalse(state.requestEmbark([worker.id], launch.id), "only infantry and spies board");
|
|
}
|
|
|
|
test_a_loaded_launch_disembarks_its_stack() {
|
|
const state = smallState();
|
|
const spot = this.coastalSetup(state);
|
|
const launchProto = state.protoUnits.find((u) => u.id === "launch");
|
|
const launch = state._spawnUnit(spot.sea, 0, launchProto);
|
|
const infantry = state._spawnUnit(spot.land, 0, state.protoUnits[0]);
|
|
state.requestEmbark([infantry.id], launch.id);
|
|
for (let i = 0; i < 24; i++) state.advanceHour();
|
|
this.assertTrue(state.requestDisembark([launch.id], spot.land), "the troops go ashore");
|
|
this.assertEqual(launch.cargo.length, 0, "the launch is empty");
|
|
this.assertGreater(state.unitsAt(spot.land).length, 0, "a unit stands on the shore");
|
|
}
|
|
}
|
|
|
|
export class ZoneOfControlTest extends TestCase {
|
|
// Two neighbouring, unclaimed land tiles, so terrain and ownership never
|
|
// interfere with the zone-of-control check under test.
|
|
neutralPair(state) {
|
|
for (const cell of state.landCells) {
|
|
if (state.civAt(cell) !== 0) continue;
|
|
for (const neighbour of state.topology.neighbours(cell.x, cell.y)) {
|
|
if (!state._isLand(neighbour) || state.civAt(neighbour) !== 0) continue;
|
|
if (state.unitAt(cell) || state.unitAt(neighbour)) continue;
|
|
return { a: { x: cell.x, y: cell.y }, b: { x: neighbour.x, y: neighbour.y } };
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
test_a_unit_cannot_cross_between_two_denied_tiles() {
|
|
const state = smallState();
|
|
const pair = this.neutralPair(state);
|
|
this.assertNotNull(pair, "the map has two adjacent neutral land tiles");
|
|
const mover = state._spawnUnit(pair.a, 0, state.protoUnits[0]);
|
|
// The hostile is only denied by the artificial zone, not by occupancy.
|
|
const zoc = new Set([key(pair.a.x, pair.a.y), key(pair.b.x, pair.b.y)]);
|
|
this.assertFalse(
|
|
state._canUnitEnter(mover, pair.b, false, -1, null, zoc, pair.a),
|
|
"denied to denied is blocked"
|
|
);
|
|
this.assertTrue(
|
|
state._canUnitEnter(mover, pair.b, false, -1, null, new Set([key(pair.b.x, pair.b.y)]), pair.a),
|
|
"entering the ring from outside is allowed"
|
|
);
|
|
this.assertTrue(
|
|
state._canUnitEnter(mover, pair.b, true, -1, null, zoc, pair.a),
|
|
"a deliberate attack on the goal is allowed"
|
|
);
|
|
}
|
|
|
|
test_a_hostile_unit_denies_its_tile_and_neighbours() {
|
|
const state = smallState();
|
|
const pair = emptyLandPair(state);
|
|
state._spawnUnit(pair.a, 1, state.protoUnits[0]);
|
|
const zoc = state._zoneOfControl(0);
|
|
this.assertTrue(zoc.has(key(pair.a.x, pair.a.y)), "the hostile's tile is denied");
|
|
for (const neighbour of state.topology.neighbours(pair.a.x, pair.a.y)) {
|
|
this.assertTrue(zoc.has(key(neighbour.x, neighbour.y)), "each neighbour is denied");
|
|
}
|
|
}
|
|
}
|