adrien/Battle-for-Tismo
1
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Halved the test suite's runtime and pruned trivial tests

Browse Source
This commit is contained in:
adrien
2026-09-23 10:43:19 +02:00
parent aed6ba94f2
commit 35c46aba10
20 changed files with 819 additions and 1014 deletions
Download Patch File Download Diff File Expand all files Collapse all files
client/js/devlog_data.js
+6 -6
View File
@@ -1,6 +1,12 @@
// Generated by scripts/generate-devlog.js from `git log`; do not edit.
// The pre-commit hook refreshes it so the main menu shows the latest commits.
export const DEVLOG = [
{
"hash": "aed6ba9",
"date": "2026-09-23",
"subject": "Rolled the central bank's commodity chart over the last two years",
"body": "The index is still 100 at January 2000's prices, but the chart now plots only the last twenty-four monthly samples and its end labels follow the window, so the graph stops growing as the game runs. A test covers the 24-month window and its end labels."
},
{
"hash": "2d36685",
"date": "2026-09-22",
@@ -54,11 +60,5 @@ export const DEVLOG = [
"date": "2026-09-22",
"subject": "Reworked the world around a fixed sea share and settled coasts",
"body": "World generation now aims at a fixed share of the ice-free tiles (60%) instead of a minimum continent count, bisecting the water level for it rather than sweeping every step, and still joins the ocean into one body. Ice and tundra are the outermost rows only, scaled down on small maps so the fixtures keep usable land.\n\nCities score their site, coastal plains best and landlocked worst, avoiding tundra and desert. Every nation that holds a coast gets a port city on each island it owns, and any landmass left empty is settled by the nearest nation, so no land starts unowned. A coastal city opens with a port already built.\n\nBundles the in-progress work in the tree: the commodity monthly price series and inflation the central bank's chart reads, and the rolling city-to-city migration graph the population map draws as flow arrows."
},
{
"hash": "71dad18",
"date": "2026-09-22",
"subject": "Let central banks work their reserves and cleared the landlocked famines",
"body": "Central banks now redeem the national money foreign banks hold, sell reserves to defend a weak rate, and cover part of strategic imports from reserves. Five repeatable technologies raise each commodity's output per unit of energy. Hostile troops on a road or sea lane sever trade, power and unit supply. Middlemen buy food to resell to neighbours at a markup, and starving regions buy before those topping up their buffers, which clears the landlocked famines. The economic map's trade graph gains a colour legend."
}
];
server/game_server.js
+1
View File
@@ -101,6 +101,7 @@ export class GameServer extends EventEmitter {
this.hostCiv = Number(setup.player_civ || 0);
this.testing = !!setup.testing;
this.state = new GameState();
if (setup.mapConfig) this.state.mapConfig = setup.mapConfig;
this.state.configure(this._loadCivs(setup.civilisations || []), Number(setup.seed || 0));
this.state.testing = this.testing;
this.state.onChanged(() => {
server/server.js
+2 -1
View File
@@ -110,6 +110,7 @@ export function startServer({
seed = 0,
testing = false,
civilisations = [],
mapConfig = null,
} = {}) {
const httpServer = createServer(serveStatic);
const wsServer = new WebSocketServer(httpServer, { path: "/ws" });
@@ -126,7 +127,7 @@ export function startServer({
};
const gameServer = new GameServer(network);
gameServer.configureGame({ seed, player_civ: 0, civilisations, testing });
gameServer.configureGame({ seed, player_civ: 0, civilisations, testing, mapConfig });
function broadcastPlayers() {
const players = {};
tests/data_test.js
+13 -111
View File
@@ -6,36 +6,20 @@ import {
GOVERNMENTS,
TECHNOLOGIES,
TRAINABLE_UNIT_IDS,
TERRAIN_TILES,
protoUnitById,
buildingById,
governmentById,
technologyById,
effectValue,
statusById,
STATUS_BATTLE,
PILLAGE,
pillageSteps,
POLICIES,
RESOURCE_BUILDINGS,
PILLAGE,
} from "../shared/data.js";
export class DataTest extends TestCase {
test_lookups_return_the_matching_entry() {
test_lookups_return_the_matching_entry_or_null() {
this.assertEqual(protoUnitById("modern_infantry"), PROTO_UNITS.find((u) => u.id === "modern_infantry"));
this.assertEqual(buildingById("barracks"), BUILDINGS.find((b) => b.id === "barracks"));
this.assertEqual(governmentById("republic"), GOVERNMENTS[0]);
this.assertEqual(technologyById("scientific_method"), TECHNOLOGIES[0]);
}
test_resource_building_output_is_scaled_up() {
// One work stands for a whole industry: the authored output is multiplied
// tenfold so fewer of them stand on the map.
const mill = RESOURCE_BUILDINGS.find((b) => b.id === "steel_mill");
this.assertApprox(mill.outputPerDay, 200_000, 1e-6);
}
test_unknown_lookups_return_null() {
this.assertNull(protoUnitById("nope"));
this.assertNull(buildingById("nope"));
this.assertNull(governmentById("nope"));
@@ -54,11 +38,11 @@ export class DataTest extends TestCase {
}
}
test_battle_status_is_rendered_and_triples_upkeep() {
const battle = statusById(STATUS_BATTLE);
this.assertNotNull(battle, "the battle status exists");
this.assertEqual(battle.icon, "icon_battle.svg");
this.assertEqual(battle.upkeepMultiplier, 3);
test_trainable_units_exist_in_the_catalogue() {
this.assertNotEmpty(TRAINABLE_UNIT_IDS);
for (const id of TRAINABLE_UNIT_IDS) {
this.assertNotNull(protoUnitById(id), `trainable unit ${id}`);
}
}
test_pillage_steps_compound_per_unit() {
@@ -75,29 +59,6 @@ export class DataTest extends TestCase {
this.assertApprox(two.productionMultiplier, 0.49, 1e-9);
}
test_trainable_units_exist_in_the_catalogue() {
this.assertNotEmpty(TRAINABLE_UNIT_IDS);
for (const id of TRAINABLE_UNIT_IDS) {
this.assertNotNull(protoUnitById(id), `trainable unit ${id}`);
}
}
test_artillery_is_expensive_slow_and_long_ranged() {
const infantry = protoUnitById("modern_infantry");
const artillery = protoUnitById("artillery");
this.assertNotNull(artillery, "artillery exists");
this.assertTrue(artillery.military, "artillery is military");
this.assertGreater(artillery.cost, infantry.cost * 2, "much more expensive");
this.assertGreater(artillery.upkeep, infantry.upkeep, "costlier to keep");
this.assertLess(artillery.speed, infantry.speed, "slower than infantry");
this.assertLess(artillery.defense, infantry.defense / 4, "nearly no defense");
this.assertGreater(artillery.attack, infantry.attack, "hits harder");
this.assertGreater(artillery.range, infantry.range, "outranges infantry");
this.assertEqual(artillery.range, 2);
this.assertTrue(TRAINABLE_UNIT_IDS.includes("artillery"), "artillery is trainable");
this.assertTrue(artillery.icon.endsWith(".svg"));
}
test_buildings_and_governments_carry_effects() {
for (const building of BUILDINGS) {
// A building carries either stat effects or a rule-based mechanic.
@@ -115,40 +76,12 @@ export class DataTest extends TestCase {
for (const government of GOVERNMENTS) {
this.assertNotEmpty(government.effects, `${government.id} effects`);
}
}
test_policy_effects_are_popularity_points_not_percentages() {
for (const policy of POLICIES) {
this.assertFalse(
policy.targetEffect.includes("%"),
`${policy.id} target effect is stated in popularity points`
);
this.assertFalse(
policy.politicalCost.includes("%"),
`${policy.id} political cost is stated in popularity points`
);
}
}
test_market_and_bank_are_gone() {
// The Market was removed and the tax-raising Bank is gone too: the state
// lives on trade taxes alone.
this.assertEqual(buildingById("market"), null);
this.assertEqual(buildingById("bank"), null);
}
test_new_buildings_declare_their_mechanics() {
const expected = {
barracks: "parallel_training",
shelters: "civilian_shelter",
aa_building: "air_defense",
shipyard: "parallel_building",
port: "port_production",
airport: "air_immigration",
};
for (const [id, mechanic] of Object.entries(expected)) {
this.assertEqual(buildingById(id).mechanic, mechanic, `${id} mechanic`);
}
// The gating buildings declare their placement requirements.
this.assertTrue(buildingById("port").coastal, "a port needs the coast");
this.assertNull(buildingById("port").requiresBuilding, "a port stands on its own");
this.assertEqual(buildingById("shipyard").requiresBuilding, "port", "a shipyard needs a port");
this.assertTrue(buildingById("shipyard").coastal, "a shipyard needs the coast too");
this.assertNull(buildingById("airport").requiresBuilding, "an airport stands on its own");
}
test_technologies_form_a_tree() {
@@ -162,20 +95,6 @@ export class DataTest extends TestCase {
}
}
test_ports_airports_and_shipyards_declare_their_requirements() {
const port = buildingById("port");
const airport = buildingById("airport");
const shipyard = buildingById("shipyard");
this.assertTrue(port.coastal, "a port needs the coast");
this.assertNull(port.requiresBuilding, "a port stands on its own");
this.assertTrue(shipyard.requiresBuilding === "port", "a shipyard needs a port");
this.assertTrue(shipyard.coastal, "a shipyard needs the coast too");
this.assertNull(airport.requiresBuilding, "an airport stands on its own");
this.assertTrue(port.icon.endsWith(".svg"));
this.assertTrue(airport.icon.endsWith(".svg"));
this.assertTrue(shipyard.icon.endsWith(".svg"));
}
test_aircraft_and_warships_are_gated_and_fuelled() {
for (const id of ["jet_fighter", "bomber"]) {
const plane = protoUnitById(id);
@@ -192,21 +111,4 @@ export class DataTest extends TestCase {
this.assertEqual(battleship.traversableTerrains, ["Sea"]);
this.assertTrue(battleship.icon.endsWith(".svg"));
}
test_effect_value_scales_with_level() {
const effect = { baseValue: 10, exponent: 1 };
this.assertApprox(effectValue(effect, 1), 10);
this.assertApprox(effectValue(effect, 3), 30);
this.assertEqual(effectValue(effect, 0), 0);
}
test_tundra_is_rocky_but_flat_and_unproductive() {
const tundra = TERRAIN_TILES.find((t) => t.terrainType === "Tundra");
this.assertNotNull(tundra, "tundra exists");
this.assertEqual(tundra.terrainClass, "Land", "tundra is land");
this.assertEqual(tundra.defenseBonus, 0, "tundra stays flat");
this.assertApprox(tundra.populationMultiplier, 0.05, 1e-9);
this.assertApprox(tundra.productionMultiplier, 0.2, 1e-9);
this.assertApprox(tundra.movementCostMultiplier, 2.0, 1e-9);
}
}
tests/diplomacy_test.js
+9 -10
View File
@@ -1,6 +1,6 @@
import { TestCase } from "./framework/test_case.js";
import { GameServer } from "../server/game_server.js";
import { smallState, SEED } from "./framework/helpers.js";
import { smallState, smallConfig, SEED } from "./framework/helpers.js";
function parseKey(k) {
const i = k.indexOf(",");
@@ -54,16 +54,15 @@ function fakeNetwork() {
function makeServer(civIds = ["france", "britain"]) {
const network = fakeNetwork();
const server = new GameServer(network);
server.configureGame({ seed: SEED, player_civ: 0, civilisations: civIds });
// These tests stage a unit on neutral coast next to foreign territory, which
// needs the two nations to share a landmass; regenerate the fixture as a
// single continent, with no small-island nations, so such a coast exists.
server.state.mapConfig = {
...server.state.mapConfig,
minContinents: 1,
smallIslandCount: 0,
};
server.state.configure(server.state.civilisations, SEED);
// needs the two nations to share a landmass; a single continent, with no
// small-island nations, guarantees such a coast exists.
server.configureGame({
seed: SEED,
player_civ: 0,
civilisations: civIds,
mapConfig: smallConfig({ smallIslandCount: 0 }),
});
return { server, network };
}
tests/economy_test.js
+6 -32
View File
@@ -1,5 +1,5 @@
import { TestCase } from "./framework/test_case.js";
import { ECONOMY, TAXES } from "../shared/data.js";
import { ECONOMY } from "../shared/data.js";
import { HOURS_PER_YEAR } from "../shared/game_state.js";
function config(overrides = {}) {
@@ -7,40 +7,24 @@ function config(overrides = {}) {
}
export class EconomyTest extends TestCase {
test_population_growth_scales_with_step() {
test_population_growth_scales_with_step_and_guards_invalid_periods() {
const cfg = config({ basePopulationGrowthRate: 0.005 });
const hourly = cfg.populationGrowthFactor(HOURS_PER_YEAR);
const daily = cfg.populationGrowthFactor(HOURS_PER_YEAR, 24);
this.assertApprox(daily, Math.pow(1 + hourly, 24) - 1, 1e-9);
this.assertApprox(Math.pow(1 + hourly, HOURS_PER_YEAR) - 1, 0.005, 1e-6);
}
test_population_growth_zero_rate_is_zero() {
const cfg = config({ basePopulationGrowthRate: 0 });
this.assertEqual(cfg.populationGrowthFactor(HOURS_PER_YEAR, 24), 0);
}
test_population_growth_guards_invalid_period() {
const cfg = config({ basePopulationGrowthRate: 0.005 });
this.assertEqual(config({ basePopulationGrowthRate: 0 }).populationGrowthFactor(HOURS_PER_YEAR, 24), 0);
this.assertEqual(cfg.populationGrowthFactor(0), 0);
this.assertEqual(cfg.populationGrowthFactor(HOURS_PER_YEAR, 0), 0);
}
test_production_capacity() {
test_production_capacity_and_training_hours_guard_their_divisor() {
const cfg = config({ gdpPerProductionPoint: 100000000 });
this.assertApprox(cfg.productionCapacity(1000000000), 10);
this.assertApprox(cfg.productionCapacity(0), 0);
}
test_production_capacity_guards_divisor() {
this.assertEqual(config({ gdpPerProductionPoint: 0 }).productionCapacity(1000), 0);
}
test_training_hours() {
this.assertApprox(config({ gdpPerProductionPoint: 100 }).trainingHours(1000, 50), 5);
}
test_training_hours_without_capacity_is_zero() {
this.assertEqual(config({ gdpPerProductionPoint: 0 }).trainingHours(1000, 50), 0);
}
@@ -53,18 +37,8 @@ export class EconomyTest extends TestCase {
1e-9,
"construction is ten times faster than training the same cost"
);
}
test_building_hours_follow_the_multiplier() {
const cfg = config({ gdpPerProductionPoint: 100, buildingTimeMultiplier: 0.5 });
this.assertApprox(cfg.buildingHours(1000, 50), 2.5);
const scaled = config({ gdpPerProductionPoint: 100, buildingTimeMultiplier: 0.5 });
this.assertApprox(scaled.buildingHours(1000, 50), 2.5);
this.assertEqual(config({ gdpPerProductionPoint: 0 }).buildingHours(1000, 50), 0);
}
test_trade_tax_defaults() {
this.assertApprox(TAXES.defaultSales, 0.2);
this.assertApprox(TAXES.defaultExport, 0.05);
this.assertApprox(TAXES.defaultImport, 0.05);
}
}
tests/framework/helpers.js
+3
View File
@@ -16,6 +16,9 @@ export async function withServer(fn, options = {}) {
log: () => {},
seed: SEED,
civilisations: ["france", "britain"],
// The integration fixtures do not care about the shape of the world, and
// the full default map costs about half a second to generate per fixture.
mapConfig: smallConfig(),
...options,
});
const address = await server.listen;
tests/framework/map_view_fixture.js
+28
View File
@@ -0,0 +1,28 @@
// Shared fixture for the map-view suites. Declares the `build` helper only --
// no `test_*` methods -- so each split suite inherits it without the runner
// re-running every test in every subclass.
import { TestCase } from "./test_case.js";
import { setupDom } from "./dom.js";
import { MapView } from "../../client/js/map_view.js";
import { CIVILISATIONS, PROTO_UNITS } from "../../shared/data.js";
import { mapLayers } from "./helpers.js";
export class MapViewFixture extends TestCase {
async build(state) {
const env = await setupDom();
const map = new MapView(env.$("#map-viewport"), env.$("#map-world"), mapLayers(env.$));
map.$viewport.width = () => 800;
map.$viewport.height = () => 600;
const snapshot = state.snapshot(0);
// The snapshot ships the nations in their seeded order; rebuild the full
// catalogue in that same order so owner indices line up, exactly as the
// game screen does.
const catalogue = snapshot.civs.map(
(c) => CIVILISATIONS.find((full) => full.id === c.id) || c
);
map.setCatalogue(catalogue, PROTO_UNITS);
map.applySnapshot(snapshot);
return { env, map, snapshot };
}
}
tests/game_server_test.js
+2 -2
View File
@@ -1,7 +1,7 @@
import { TestCase } from "./framework/test_case.js";
import { GameServer } from "../server/game_server.js";
import { CIVILISATIONS } from "../shared/data.js";
import { adjacentLand, SEED, grantBuilding } from "./framework/helpers.js";
import { adjacentLand, SEED, grantBuilding, smallConfig } from "./framework/helpers.js";
import { key } from "../shared/hex.js";
function fakeNetwork() {
@@ -20,7 +20,7 @@ function fakeNetwork() {
function makeServer(civIds = ["france", "britain"]) {
const network = fakeNetwork();
const server = new GameServer(network);
server.configureGame({ seed: SEED, player_civ: 0, civilisations: civIds });
server.configureGame({ seed: SEED, player_civ: 0, civilisations: civIds, mapConfig: smallConfig() });
return { server, network };
}
tests/hex_test.js
+25 -50
View File
@@ -10,23 +10,19 @@ export class HexTest extends TestCase {
return new MapTopology({ x: 10, y: 10 }, true);
}
test_flat_reports_flat() {
test_topology_type_width_and_period() {
this.assertFalse(this.flat().isCylindrical());
this.assertApprox(this.flat().periodPixels(), 0, 1e-9);
const cylinder = this.cylinder();
this.assertTrue(cylinder.isCylindrical());
this.assertEqual(cylinder.width, 10);
this.assertApprox(cylinder.periodPixels(), COL_STEP * 10, 1e-9);
}
test_cylindrical_reports_type_and_width() {
const topology = this.cylinder();
this.assertTrue(topology.isCylindrical());
this.assertEqual(topology.width, 10);
}
test_flat_wrap_is_identity() {
const topology = this.flat();
this.assertEqual(topology.wrapX(25), 25);
this.assertEqual(topology.wrapCoords(25, -3), { x: 25, y: -3 });
}
test_cylindrical_wrap_folds_x_into_range() {
test_wrap_x_folds_only_on_a_cylinder() {
const flatTopology = this.flat();
this.assertEqual(flatTopology.wrapX(25), 25);
this.assertEqual(flatTopology.wrapCoords(25, -3), { x: 25, y: -3 });
const topology = this.cylinder();
// Origin is -5, so the valid x range is -5..4.
this.assertEqual(topology.wrapX(-5), -5);
@@ -35,26 +31,23 @@ export class HexTest extends TestCase {
this.assertEqual(topology.wrapX(-6), 4);
}
test_flat_delta_is_plain_difference() {
test_wrapped_delta_takes_the_short_route() {
this.assertEqual(this.flat().wrappedDelta({ x: -5, y: 0 }, { x: 4, y: 0 }), { x: 9, y: 0 });
}
test_cylindrical_delta_takes_short_route() {
this.assertEqual(this.cylinder().wrappedDelta({ x: -5, y: 0 }, { x: 4, y: 0 }), { x: -1, y: 0 });
}
test_tile_distance_uses_wrap() {
this.assertApprox(this.cylinder().tileDistance({ x: -5, y: 0 }, { x: 4, y: 0 }), 1.0, 1e-9);
const topology = this.cylinder();
const delta = topology.pixelDelta({ x: 0, y: 0 }, { x: -4, y: 0 });
const expected = mapToLocal(-4, 0);
this.assertApprox(delta.x, expected.x, 1e-9);
this.assertApprox(delta.y, expected.y, 1e-9);
}
test_neighbours_are_the_six_flat_top_cells() {
test_neighbours_are_six_adjacent_cells_that_wrap() {
const topology = this.flat();
const neighbours = topology.neighbours(0, 0).map((c) => key(c.x, c.y)).sort();
this.assertEqual(neighbours, ["-1,-1", "-1,0", "0,-1", "0,1", "1,-1", "1,0"]);
}
test_neighbours_are_adjacent_in_pixel_space() {
const topology = this.flat();
const centre = mapToLocal(0, 0);
for (const neighbour of topology.neighbours(0, 0)) {
const delta = topology.pixelDelta({ x: 0, y: 0 }, neighbour);
@@ -64,39 +57,21 @@ export class HexTest extends TestCase {
this.assertApprox(local.x - centre.x, delta.x, 1e-9);
this.assertApprox(local.y - centre.y, delta.y, 1e-9);
}
}
test_neighbours_wrap_at_the_seam() {
const topology = this.cylinder();
for (const neighbour of topology.neighbours(-5, 0)) {
const cylinder = this.cylinder();
for (const neighbour of cylinder.neighbours(-5, 0)) {
this.assert(neighbour.x >= -5 && neighbour.x <= 4, `x ${neighbour.x} outside map`);
}
const west = topology.neighbours(-5, 0).some((c) => c.x === 4);
this.assertTrue(west, "the west neighbour of the seam wraps to the east edge");
this.assertTrue(
cylinder.neighbours(-5, 0).some((c) => c.x === 4),
"the west neighbour of the seam wraps to the east edge"
);
}
test_pixel_delta_matches_map_to_local() {
const topology = this.cylinder();
const from = { x: 0, y: 0 };
const to = { x: -4, y: 0 };
const delta = topology.pixelDelta(from, to);
const expected = mapToLocal(-4, 0);
this.assertApprox(delta.x, expected.x, 1e-9);
this.assertApprox(delta.y, expected.y, 1e-9);
}
test_period_pixels_matches_map_width() {
this.assertApprox(this.flat().periodPixels(), 0, 1e-9);
this.assertApprox(this.cylinder().periodPixels(), COL_STEP * 10, 1e-9);
}
test_key_and_parse_key_round_trip() {
test_key_and_parse_key_round_trip_and_odd_column_offset() {
for (const coords of [{ x: 0, y: 0 }, { x: 3, y: -4 }, { x: -12, y: 7 }]) {
this.assertEqual(parseKey(key(coords.x, coords.y)), coords);
}
}
test_odd_columns_are_pushed_down() {
const even = mapToLocal(0, 0);
const odd = mapToLocal(1, 0);
this.assertApprox(odd.x - even.x, COL_STEP, 1e-9);
tests/map_view_geometry_test.js
+274
View File
@@ -0,0 +1,274 @@
import { teardownDom } from "./framework/dom.js";
import { MapViewFixture } from "./framework/map_view_fixture.js";
import { mapToLocal, COL_STEP, HEX_W, parseKey } from "../shared/hex.js";
import { inwardOffset } from "../client/js/map_view.js";
import { CAMERA_TILT, HEIGHT_LIFT } from "../client/js/map_view/constants.js";
import { smallState } from "./framework/helpers.js";
export class MapViewGeometryTest extends MapViewFixture {
async test_centers_on_the_capital() {
const state = smallState();
const { env, map } = await this.build(state);
try {
const capital = state.cities.find((c) => c.civ === 0 && c.isCapital);
const local = mapToLocal(capital.coords.x, capital.coords.y);
this.assertApprox(map.camera.x, local.x, 1e-6);
this.assertApprox(map.camera.y, local.y, 1e-6);
this.assertTrue(env.$("#map-world").css("transform").includes("scale(1)"));
} finally {
teardownDom(env);
}
}
async test_tile_in_view_follows_the_camera() {
const state = smallState();
const { env, map } = await this.build(state);
try {
const capital = state.cities.find((c) => c.civ === 0 && c.isCapital);
const coords = { x: capital.coords.x, y: capital.coords.y };
map.centerOn(coords);
this.assertTrue(map.tileInView(coords), "the centred tile is in view");
this.assertTrue(map.tileInView(coords, 1), "still in view with a margin");
// Pan away along the (unwrapped) north-south axis: the tile drops out.
map.camera.y += 100000;
this.assertFalse(map.tileInView(coords), "a far tile is out of view");
} finally {
teardownDom(env);
}
}
async test_tile_at_screen_round_trips() {
const state = smallState();
const { env, map } = await this.build(state);
try {
const capital = state.cities.find((c) => c.civ === 0 && c.isCapital);
const local = mapToLocal(capital.coords.x, capital.coords.y);
const screenX = 400 + (local.x - map.camera.x) * map.camera.zoom;
const screenY = 300 + (local.y - map.camera.y) * map.camera.zoom * CAMERA_TILT;
this.assertEqual(map.tileAtScreen(screenX, screenY), capital.coords);
} finally {
teardownDom(env);
}
}
async test_tile_at_screen_accounts_for_the_height_lift() {
const state = smallState();
const { env, map } = await this.build(state);
try {
const capital = state.cities.find((c) => c.civ === 0 && c.isCapital);
const local = mapToLocal(capital.coords.x, capital.coords.y);
const height = 0.5;
map.glRenderer = { pointHeight: () => height };
const screenX = 400 + (local.x - map.camera.x) * map.camera.zoom;
// Where the raised tile centre is actually drawn.
const screenY = 300 +
((local.y - map.camera.y) * CAMERA_TILT - height * HEIGHT_LIFT) * map.camera.zoom;
this.assertEqual(map.tileAtScreen(screenX, screenY), capital.coords,
"the raised tile is selected where it is drawn");
} finally {
teardownDom(env);
}
}
async test_surface_inversion_picks_the_frontmost_crossing() {
const state = smallState();
const { env, map } = await this.build(state);
try {
// A plateau 10..30px south of the flat estimate. The pixel shows both the
// flat ground at y=90 and the raised plateau at y = 90 + 0.6*HEIGHT_LIFT/
// tilt; the plateau is drawn last, so it must win.
map.glRenderer = {
pointHeight: (x, y) => (y >= 100 && y <= 130 ? 0.6 : 0),
};
const expected = 90 + 0.6 * (HEIGHT_LIFT / CAMERA_TILT);
this.assertApprox(map._surfaceY(0, 90), expected, 0.5, "the frontmost surface wins");
} finally {
teardownDom(env);
}
}
async test_outline_runs_split_solid_and_dotted() {
const state = smallState();
const { env, map } = await this.build(state);
try {
const coords = [
{ x: 0, y: 0 }, { x: 10, y: 0 }, { x: 10, y: 10 }, { x: 0, y: 10 },
];
const hidden = [false, true, true, false];
this.assertEqual(map._outlineRuns(coords, hidden, false), "M0.00 10.00L0.00 0.00",
"the visible segment is its own run");
this.assertEqual(map._outlineRuns(coords, hidden, true),
"M0.00 0.00L10.00 0.00L10.00 10.00L0.00 10.00", "the hidden segments chain together");
} finally {
teardownDom(env);
}
}
async test_wrapped_tile_lookup_stays_in_range() {
const state = smallState();
const { env, map } = await this.build(state);
try {
const coords = map.tileAtScreen(100000, 300);
const minX = map.topology.originX;
const maxX = map.topology.originX + map.topology.width - 1;
this.assert(coords.x >= minX && coords.x <= maxX, `x ${coords.x} wrapped`);
} finally {
teardownDom(env);
}
}
async test_terrain_wraps_across_the_seam() {
const state = smallState();
const { env, map } = await this.build(state);
try {
this.assertGreater(map._period, 0, "the map has a wrap period");
const rec = map._chunks.values().next().value;
this.assertNotNull(rec, "a chunk is materialised");
const chunkKey = rec.cx + "," + rec.cy;
const beforeShift = rec.shift;
// Scrolling exactly one period must land on the same picture: every chunk
// advances to its next wrapped copy, cancelling the camera movement.
map.panBy(map._period, 0);
const after = map._chunks.get(chunkKey);
this.assertNotNull(after, "the same chunk stays materialised one period over");
this.assertApprox(after.shift, beforeShift + map._period, 1e-6);
this.assertTrue(
after.terrainEl.style.transform.includes(`translateX(${after.x + after.shift}px)`),
`expected translateX(${after.x + after.shift}px), got ${after.terrainEl.style.transform}`
);
} finally {
teardownDom(env);
}
}
async test_chunks_meet_seamlessly_at_the_wrap() {
const state = smallState();
const { env, map } = await this.build(state);
try {
// Sit on the seam (just past the east edge) so both the east-edge chunk
// and the wrapped copy of the west-edge chunk are on screen together.
const t = map.topology;
map.camera.x = (t.originX + t.width) * COL_STEP;
map.camera.y = 0;
map._applyCamera();
const rows = new Map();
for (const rec of map._chunks.values()) {
if (!rows.has(rec.cy)) rows.set(rec.cy, []);
rows.get(rec.cy).push(rec);
}
let row = null;
for (const list of rows.values()) {
if (!row || list.length > row.length) row = list;
}
this.assertGreater(row.length, 1, "several chunks share the seam row");
row.sort((a, b) => (a.x + a.shift) - (b.x + b.shift));
for (let i = 1; i < row.length; i++) {
const previousRight = row[i - 1].x + row[i - 1].shift + row[i - 1].px;
const currentLeft = row[i].x + row[i].shift;
this.assertApprox(currentLeft - previousRight, COL_STEP, 1e-6);
}
} finally {
teardownDom(env);
}
}
async test_dragging_wraps_with_transforms_not_layout() {
const state = smallState();
const { env, map } = await this.build(state);
try {
const rec = map._chunks.values().next().value;
const beforeLeft = rec.terrainEl.style.left;
// The drag path updates the camera but defers the chunk sync to the render
// loop; either way the chunk must be moved with a transform, not layout.
map.camera.x += map._period;
map._applyCamera(false);
map.animate(0);
this.assertEqual(rec.terrainEl.style.left, beforeLeft, "left is never rewritten");
this.assertTrue(rec.terrainEl.style.transform.includes("translateX"));
} finally {
teardownDom(env);
}
}
async test_wrap_shift_picks_the_copy_nearest_the_camera() {
const state = smallState();
const { env, map } = await this.build(state);
try {
const period = map._period;
map.camera.x = period;
this.assertEqual(map._wrapShift(0), period);
this.assertEqual(map._wrapShift(period), 0);
// A point already beside the camera is never shifted.
this.assertEqual(map._wrapShift(period - 10), 0);
} finally {
teardownDom(env);
}
}
async test_far_zoom_keeps_the_detailed_terrain() {
const state = smallState();
const { env, map } = await this.build(state);
try {
map.camera.zoom = 0.01;
map._applyCamera();
this.assertFalse(env.$("#map-world").hasClass("lod"));
this.assertTrue(env.$("#layer-terrain").hasClass("detail-layer"));
this.assertSize(env.$("#layer-overview"), 0, "there is no simplified overview");
} finally {
teardownDom(env);
}
}
async test_border_offset_points_towards_the_owner() {
const a = { x: 0, y: 0 };
const b = { x: 0, y: 10 };
this.assertEqual(inwardOffset(a, b, { x: -5, y: 5 }, 3), 3);
this.assertEqual(inwardOffset(a, b, { x: 5, y: 5 }, 3), -3);
}
async test_neighbouring_borders_are_inset_not_overlaid() {
const state = smallState();
const { env, map } = await this.build(state);
try {
// Bring the two-tile territory into view so its chunk is materialised.
map.camera.x = 0;
map.camera.y = 0;
map._applyCamera();
map.civilisations = [{ primaryColour: "#111111" }, { primaryColour: "#eeeeee" }];
map.territory = new Map([["0,0", 0], ["1,0", 1]]);
map._renderBorders();
// Each segment is nudged towards its owner's tile, so the two sides of a
// shared edge sit next to each other instead of painting over each other.
const segments = env.$("#layer-borders .border-seg").toArray();
this.assertGreater(segments.length, 0);
for (const segment of segments) {
this.assert(
segment.style.transform.includes("translateY"),
`expected an inset border, got ${segment.style.transform}`
);
}
} finally {
teardownDom(env);
}
}
async test_pan_moves_the_camera() {
const state = smallState();
const { env, map } = await this.build(state);
try {
const beforeX = map.camera.x;
const beforeY = map.camera.y;
map.panBy(10, -5);
this.assertApprox(map.camera.x, beforeX + 10, 1e-9);
this.assertApprox(map.camera.y, beforeY - 5, 1e-9);
} finally {
teardownDom(env);
}
}
}
tests/map_view_input_test.js
+331
View File
@@ -0,0 +1,331 @@
import { teardownDom } from "./framework/dom.js";
import { MapViewFixture } from "./framework/map_view_fixture.js";
import { mapToLocal, COL_STEP, HEX_W, parseKey } from "../shared/hex.js";
import { CAMERA_TILT, HEIGHT_LIFT } from "../client/js/map_view/constants.js";
import { smallState, adjacentLand, seaTile } from "./framework/helpers.js";
export class MapViewInputTest extends MapViewFixture {
async test_selecting_a_unit_marks_its_view() {
const state = smallState();
const { env, map, snapshot } = await this.build(state);
try {
const unit = snapshot.units.find((u) => u.civ === 0);
map.setSelectedUnit(unit.id);
this.assertSize(env.$("#layer-entities .unit.selected"), 1);
this.assertEqual(map.unitAt({ x: unit.coords[0], y: unit.coords[1] }), unit.id);
} finally {
teardownDom(env);
}
}
async test_click_handling_selects_and_orders() {
const state = smallState();
const { env, map, snapshot } = await this.build(state);
try {
const unit = snapshot.units.find((u) => u.civ === 0);
let selected = -1;
map.onUnitSelected = (id) => {
selected = id;
};
map._onLeftClick({ x: unit.coords[0], y: unit.coords[1] });
this.assertEqual(selected, unit.id);
let order = null;
map.onMoveOrdered = (ids, coords) => {
order = { ids, coords };
};
map.setSelectedUnit(unit.id);
const stateUnit = state.units.find((u) => u.id === unit.id);
const goal = adjacentLand(state, stateUnit);
map._onRightClick(goal);
this.assertEqual(order.ids, [unit.id]);
this.assertEqual(order.coords, goal);
let tile = null;
map.onTileRequested = (coords) => {
tile = coords;
};
map.clearSelection();
map._onRightClick(goal);
this.assertEqual(tile, goal);
} finally {
teardownDom(env);
}
}
async test_right_click_on_a_unit_icon_orders_the_selected_stack() {
const state = smallState();
const unit = state.units.find((u) => u.civ === 0);
const goal = adjacentLand(state, unit);
const target = state._spawnUnit(goal, 0, state.protoUnits[0]);
const { env, map } = await this.build(state);
try {
let moved = null;
map.onMoveOrdered = (ids, coords) => {
moved = { ids, coords };
};
map.setSelectedUnit(unit.id);
const local = mapToLocal(goal.x, goal.y);
const clientX = 400 + (local.x - map.camera.x) * map.camera.zoom;
const clientY = 300 + (local.y - map.camera.y) * map.camera.zoom * CAMERA_TILT;
const view = map._unitViews.get(target.id);
this.assertNotNull(view, "the target unit has a view");
// Real bubbling events, so the icon's own native handler is exercised:
// it must let right-clicks reach the viewport's mousedown listener.
const press = new env.window.MouseEvent("mousedown", { button: 2, bubbles: true, clientX, clientY });
view.dispatchEvent(press);
const release = new env.window.MouseEvent("mouseup", { button: 2, bubbles: true, clientX, clientY });
env.window.dispatchEvent(release);
this.assertNotNull(moved, "right-clicking an icon gives the order");
this.assertEqual(moved.ids, [unit.id]);
this.assertEqual(moved.coords, goal);
} finally {
teardownDom(env);
}
}
async test_left_click_selects_city_or_clears() {
const state = smallState();
const { env, map, snapshot } = await this.build(state);
try {
let chosen = null;
map.onCitySelected = (id) => {
chosen = id;
};
// A non-capital city tile has no unit on it.
const city = snapshot.cities.find((c) => c.civ === 0 && !c.isCapital);
const coords = { x: city.coords[0], y: city.coords[1] };
map._onLeftClick(coords);
this.assertEqual(chosen, city.id);
this.assertEqual(map.cityAt(coords).id, city.id);
let cleared = -1;
map.onUnitSelected = (id) => {
cleared = id;
};
map.setSelectedUnit(snapshot.units[0].id);
const sea = seaTile(state);
map._onLeftClick(sea);
this.assertEqual(cleared, 0, "clicking empty ground clears the selection");
this.assertEqual(map.unitAt(sea), 0);
this.assertNull(map.cityAt(sea));
} finally {
teardownDom(env);
}
}
async test_city_marker_click_reports_the_city() {
const state = smallState();
const { env, map, snapshot } = await this.build(state);
try {
let chosen = null;
map.onCitySelected = (id) => {
chosen = id;
};
const owned = env.$("#layer-entities .city[data-owned='1']");
this.assertGreater(owned.length, 0);
owned.first().find(".marker").click();
this.assertEqual(chosen, snapshot.cities.find((c) => c.civ === 0).id);
} finally {
teardownDom(env);
}
}
async test_clear_selection_notifies() {
const state = smallState();
const { env, map, snapshot } = await this.build(state);
try {
const unit = snapshot.units.find((u) => u.civ === 0);
map.setSelectedUnit(unit.id);
let selected = -1;
map.onUnitSelected = (id) => {
selected = id;
};
map.clearSelection();
this.assertEqual(selected, 0);
this.assertSize(env.$("#layer-entities .unit.selected"), 0);
} finally {
teardownDom(env);
}
}
async test_selected_tile_is_outlined() {
const state = smallState();
const { env, map } = await this.build(state);
try {
map.setSelectedTile({ x: 0, y: 0 });
const hex = env.$("#layer-highlight .tile-selection");
this.assertSize(hex, 1, "the outline is created");
this.assertTrue(hex.hasClass("active"), "the outline is shown");
const points = (hex.find("polygon").attr("points") || "").split(" ");
this.assertSize(points, 6, "a hexagon outline");
const wrapped = map._wrappedPosition(mapToLocal(0, 0));
this.assertApprox(parseFloat(hex[0].style.left), wrapped.x - HEX_W / 2, 1e-6);
map.clearSelectedTile();
this.assertFalse(hex.hasClass("active"), "the outline is hidden again");
} finally {
teardownDom(env);
}
}
async test_selected_tile_reports_its_region() {
const state = smallState();
const { env, map } = await this.build(state);
try {
this.assertGreater(map.regions.size, 0, "regions are mirrored from the snapshot");
const [tileKey, cityId] = map.regions.entries().next().value;
map.setSelectedTile(parseKey(tileKey));
this.assertEqual(map._selectedRegion, cityId, "the tile's region is selected as a whole");
map.clearSelectedTile();
this.assertNull(map._selectedRegion, "clearing drops the region");
} finally {
teardownDom(env);
}
}
async test_stacked_units_show_one_icon_with_a_count_badge() {
const state = smallState();
const unit = state.units.find((u) => u.civ === 0);
const second = state._spawnUnit(unit.coords, 0, state.protoUnits[0]);
const { env, map } = await this.build(state);
try {
const first = map._unitViews.get(unit.id);
const other = map._unitViews.get(second.id);
this.assertEqual(first.querySelector(".unit-count").style.display, "block");
this.assertEqual(first.querySelector(".unit-count").textContent, "2");
this.assertEqual(other.style.visibility, "hidden", "the follower is not drawn");
const ids = map.unitIdsAt({ x: unit.coords.x, y: unit.coords.y }).sort((a, b) => a - b);
this.assertEqual(ids, [unit.id, second.id].sort((a, b) => a - b), "both are selectable");
} finally {
teardownDom(env);
}
}
async test_right_click_on_a_friendly_stack_opens_the_menu() {
const state = smallState();
const unit = state.units.find((u) => u.civ === 0);
const second = state._spawnUnit(unit.coords, 0, state.protoUnits[0]);
const { env, map } = await this.build(state);
try {
let menu = null;
map.onStackMenu = (coords, ids, x, y) => {
menu = { coords, ids, x, y };
};
map._onRightClick({ x: unit.coords.x, y: unit.coords.y }, { clientX: 11, clientY: 22 });
this.assertNotNull(menu, "the stack menu opens");
this.assertEqual(menu.ids.sort((a, b) => a - b), [unit.id, second.id].sort((a, b) => a - b));
this.assertEqual(menu.x, 11);
this.assertEqual(menu.y, 22);
} finally {
teardownDom(env);
}
}
async test_stack_ids_group_units_sharing_a_tile() {
const state = smallState();
const unit = state.units.find((u) => u.civ === 0);
const second = state._spawnUnit(unit.coords, 0, state.protoUnits[0]);
const { env, map } = await this.build(state);
try {
const ids = map.stackIds(unit.id).sort((a, b) => a - b);
this.assertEqual(ids, [unit.id, second.id].sort((a, b) => a - b));
} finally {
teardownDom(env);
}
}
async test_right_click_on_a_friendly_stack_while_selected_moves_there() {
const state = smallState();
const unit = state.units.find((u) => u.civ === 0);
const second = state._spawnUnit(unit.coords, 0, state.protoUnits[0]);
const { env, map } = await this.build(state);
try {
let menu = null;
let moved = null;
map.onStackMenu = () => { menu = true; };
map.onMoveOrdered = (ids, coords) => { moved = { ids, coords }; };
map.setSelectedUnit(second.id);
map._onRightClick({ x: unit.coords.x, y: unit.coords.y }, {});
this.assertNull(menu, "the stack menu does not open over a selection");
this.assertNotNull(moved, "the selected stack is ordered onto the friendly tile");
this.assertEqual(moved.ids, [second.id]);
this.assertEqual(moved.coords, { x: unit.coords.x, y: unit.coords.y });
} finally {
teardownDom(env);
}
}
async test_right_click_on_an_enemy_stack_attacks_it() {
const state = smallState();
const unit = state.units.find((u) => u.civ === 0);
const goal = adjacentLand(state, unit);
state._spawnUnit(goal, 1, state.protoUnits[0]);
const { env, map } = await this.build(state);
try {
let attack = null;
let move = null;
map.onAttackOrdered = (ids, coords) => { attack = { ids, coords }; };
map.onMoveOrdered = (ids, coords) => { move = { ids, coords }; };
map.setSelectedUnit(unit.id);
map._onRightClick(goal, {});
this.assertNotNull(attack, "the enemy stack is attacked");
this.assertNull(move, "the enemy stack is not treated as a plain move");
this.assertEqual(attack.coords, goal);
} finally {
teardownDom(env);
}
}
async test_ctrl_right_click_schedules_a_destination() {
const state = smallState();
const unit = state.units.find((u) => u.civ === 0);
const goal = adjacentLand(state, unit);
const { env, map } = await this.build(state);
try {
let schedule = null;
let move = null;
map.onScheduleOrdered = (ids, coords) => { schedule = { ids, coords }; };
map.onMoveOrdered = (ids, coords) => { move = { ids, coords }; };
map.setSelectedUnit(unit.id);
map._onRightClick(goal, { ctrlKey: true });
this.assertNotNull(schedule, "Ctrl-right-click queues a destination");
this.assertNull(move, "a scheduled click is not a plain move");
this.assertEqual(schedule.coords, goal);
} finally {
teardownDom(env);
}
}
async test_a_moving_unit_splits_from_its_stack_at_once() {
const state = smallState();
const unit = state.units.find((u) => u.civ === 0);
const second = state._spawnUnit(unit.coords, 0, state.protoUnits[0]);
const { env, map } = await this.build(state);
try {
const tile = { x: unit.coords[0], y: unit.coords[1] };
map._unitMotion.get(unit.id).path = [tile, { x: tile.x + 1, y: tile.y }];
map._unitMotion.get(unit.id).segmentHours = [1];
map._unitMotion.get(unit.id).pathHours = 0.1;
map._assignStackOffsets();
this.assertEqual(
map._unitViews.get(unit.id).style.visibility,
"",
"the moving unit is drawn on its own"
);
this.assertEqual(
map._unitViews.get(second.id).style.visibility,
"",
"the unit left behind stays visible"
);
this.assertEqual(
map._unitViews.get(second.id).querySelector(".unit-count").style.display,
"none",
"the stack badge is gone the moment one member leaves"
);
} finally {
teardownDom(env);
}
}
}
tests/map_view_test.js
+4 -611
View File
@@ -1,29 +1,11 @@
import { TestCase } from "./framework/test_case.js";
import { setupDom, teardownDom } from "./framework/dom.js";
import { MapView, inwardOffset } from "../client/js/map_view.js";
import { teardownDom } from "./framework/dom.js";
import { MapViewFixture } from "./framework/map_view_fixture.js";
import { mapToLocal, COL_STEP, HEX_W, parseKey } from "../shared/hex.js";
import { CIVILISATIONS, PROTO_UNITS } from "../shared/data.js";
import { CAMERA_TILT, HEIGHT_LIFT } from "../client/js/map_view/constants.js";
import { defaultState, smallState, mapLayers, adjacentLand, seaTile, grantBuilding, stripPorts } from "./framework/helpers.js";
export class MapViewTest extends TestCase {
async build(state) {
const env = await setupDom();
const map = new MapView(env.$("#map-viewport"), env.$("#map-world"), mapLayers(env.$));
map.$viewport.width = () => 800;
map.$viewport.height = () => 600;
const snapshot = state.snapshot(0);
// The snapshot ships the nations in their seeded order; rebuild the full
// catalogue in that same order so owner indices line up, exactly as the
// game screen does.
const catalogue = snapshot.civs.map(
(c) => CIVILISATIONS.find((full) => full.id === c.id) || c
);
map.setCatalogue(catalogue, PROTO_UNITS);
map.applySnapshot(snapshot);
return { env, map, snapshot };
}
import { defaultState, smallState, adjacentLand, seaTile, grantBuilding, stripPorts } from "./framework/helpers.js";
export class MapViewRenderTest extends MapViewFixture {
async test_renders_terrain_territory_fog_and_entities() {
// A full-size map, so the viewport genuinely covers only part of it and the
// chunking is exercised; the other view tests use the small fixture.
@@ -180,271 +162,6 @@ export class MapViewTest extends TestCase {
}
}
async test_centers_on_the_capital() {
const state = smallState();
const { env, map } = await this.build(state);
try {
const capital = state.cities.find((c) => c.civ === 0 && c.isCapital);
const local = mapToLocal(capital.coords.x, capital.coords.y);
this.assertApprox(map.camera.x, local.x, 1e-6);
this.assertApprox(map.camera.y, local.y, 1e-6);
this.assertTrue(env.$("#map-world").css("transform").includes("scale(1)"));
} finally {
teardownDom(env);
}
}
async test_tile_in_view_follows_the_camera() {
const state = smallState();
const { env, map } = await this.build(state);
try {
const capital = state.cities.find((c) => c.civ === 0 && c.isCapital);
const coords = { x: capital.coords.x, y: capital.coords.y };
map.centerOn(coords);
this.assertTrue(map.tileInView(coords), "the centred tile is in view");
this.assertTrue(map.tileInView(coords, 1), "still in view with a margin");
// Pan away along the (unwrapped) north-south axis: the tile drops out.
map.camera.y += 100000;
this.assertFalse(map.tileInView(coords), "a far tile is out of view");
} finally {
teardownDom(env);
}
}
async test_tile_at_screen_round_trips() {
const state = smallState();
const { env, map } = await this.build(state);
try {
const capital = state.cities.find((c) => c.civ === 0 && c.isCapital);
const local = mapToLocal(capital.coords.x, capital.coords.y);
const screenX = 400 + (local.x - map.camera.x) * map.camera.zoom;
const screenY = 300 + (local.y - map.camera.y) * map.camera.zoom * CAMERA_TILT;
this.assertEqual(map.tileAtScreen(screenX, screenY), capital.coords);
} finally {
teardownDom(env);
}
}
async test_tile_at_screen_accounts_for_the_height_lift() {
const state = smallState();
const { env, map } = await this.build(state);
try {
const capital = state.cities.find((c) => c.civ === 0 && c.isCapital);
const local = mapToLocal(capital.coords.x, capital.coords.y);
const height = 0.5;
map.glRenderer = { pointHeight: () => height };
const screenX = 400 + (local.x - map.camera.x) * map.camera.zoom;
// Where the raised tile centre is actually drawn.
const screenY = 300 +
((local.y - map.camera.y) * CAMERA_TILT - height * HEIGHT_LIFT) * map.camera.zoom;
this.assertEqual(map.tileAtScreen(screenX, screenY), capital.coords,
"the raised tile is selected where it is drawn");
} finally {
teardownDom(env);
}
}
async test_surface_inversion_picks_the_frontmost_crossing() {
const state = smallState();
const { env, map } = await this.build(state);
try {
// A plateau 10..30px south of the flat estimate. The pixel shows both the
// flat ground at y=90 and the raised plateau at y = 90 + 0.6*HEIGHT_LIFT/
// tilt; the plateau is drawn last, so it must win.
map.glRenderer = {
pointHeight: (x, y) => (y >= 100 && y <= 130 ? 0.6 : 0),
};
const expected = 90 + 0.6 * (HEIGHT_LIFT / CAMERA_TILT);
this.assertApprox(map._surfaceY(0, 90), expected, 0.5, "the frontmost surface wins");
} finally {
teardownDom(env);
}
}
async test_outline_runs_split_solid_and_dotted() {
const state = smallState();
const { env, map } = await this.build(state);
try {
const coords = [
{ x: 0, y: 0 }, { x: 10, y: 0 }, { x: 10, y: 10 }, { x: 0, y: 10 },
];
const hidden = [false, true, true, false];
this.assertEqual(map._outlineRuns(coords, hidden, false), "M0.00 10.00L0.00 0.00",
"the visible segment is its own run");
this.assertEqual(map._outlineRuns(coords, hidden, true),
"M0.00 0.00L10.00 0.00L10.00 10.00L0.00 10.00", "the hidden segments chain together");
} finally {
teardownDom(env);
}
}
async test_wrapped_tile_lookup_stays_in_range() {
const state = smallState();
const { env, map } = await this.build(state);
try {
const coords = map.tileAtScreen(100000, 300);
const minX = map.topology.originX;
const maxX = map.topology.originX + map.topology.width - 1;
this.assert(coords.x >= minX && coords.x <= maxX, `x ${coords.x} wrapped`);
} finally {
teardownDom(env);
}
}
async test_terrain_wraps_across_the_seam() {
const state = smallState();
const { env, map } = await this.build(state);
try {
this.assertGreater(map._period, 0, "the map has a wrap period");
const rec = map._chunks.values().next().value;
this.assertNotNull(rec, "a chunk is materialised");
const chunkKey = rec.cx + "," + rec.cy;
const beforeShift = rec.shift;
// Scrolling exactly one period must land on the same picture: every chunk
// advances to its next wrapped copy, cancelling the camera movement.
map.panBy(map._period, 0);
const after = map._chunks.get(chunkKey);
this.assertNotNull(after, "the same chunk stays materialised one period over");
this.assertApprox(after.shift, beforeShift + map._period, 1e-6);
this.assertTrue(
after.terrainEl.style.transform.includes(`translateX(${after.x + after.shift}px)`),
`expected translateX(${after.x + after.shift}px), got ${after.terrainEl.style.transform}`
);
} finally {
teardownDom(env);
}
}
async test_chunks_meet_seamlessly_at_the_wrap() {
const state = smallState();
const { env, map } = await this.build(state);
try {
// Sit on the seam (just past the east edge) so both the east-edge chunk
// and the wrapped copy of the west-edge chunk are on screen together.
const t = map.topology;
map.camera.x = (t.originX + t.width) * COL_STEP;
map.camera.y = 0;
map._applyCamera();
const rows = new Map();
for (const rec of map._chunks.values()) {
if (!rows.has(rec.cy)) rows.set(rec.cy, []);
rows.get(rec.cy).push(rec);
}
let row = null;
for (const list of rows.values()) {
if (!row || list.length > row.length) row = list;
}
this.assertGreater(row.length, 1, "several chunks share the seam row");
row.sort((a, b) => (a.x + a.shift) - (b.x + b.shift));
for (let i = 1; i < row.length; i++) {
const previousRight = row[i - 1].x + row[i - 1].shift + row[i - 1].px;
const currentLeft = row[i].x + row[i].shift;
this.assertApprox(currentLeft - previousRight, COL_STEP, 1e-6);
}
} finally {
teardownDom(env);
}
}
async test_dragging_wraps_with_transforms_not_layout() {
const state = smallState();
const { env, map } = await this.build(state);
try {
const rec = map._chunks.values().next().value;
const beforeLeft = rec.terrainEl.style.left;
// The drag path updates the camera but defers the chunk sync to the render
// loop; either way the chunk must be moved with a transform, not layout.
map.camera.x += map._period;
map._applyCamera(false);
map.animate(0);
this.assertEqual(rec.terrainEl.style.left, beforeLeft, "left is never rewritten");
this.assertTrue(rec.terrainEl.style.transform.includes("translateX"));
} finally {
teardownDom(env);
}
}
async test_wrap_shift_picks_the_copy_nearest_the_camera() {
const state = smallState();
const { env, map } = await this.build(state);
try {
const period = map._period;
map.camera.x = period;
this.assertEqual(map._wrapShift(0), period);
this.assertEqual(map._wrapShift(period), 0);
// A point already beside the camera is never shifted.
this.assertEqual(map._wrapShift(period - 10), 0);
} finally {
teardownDom(env);
}
}
async test_far_zoom_keeps_the_detailed_terrain() {
const state = smallState();
const { env, map } = await this.build(state);
try {
map.camera.zoom = 0.01;
map._applyCamera();
this.assertFalse(env.$("#map-world").hasClass("lod"));
this.assertTrue(env.$("#layer-terrain").hasClass("detail-layer"));
this.assertSize(env.$("#layer-overview"), 0, "there is no simplified overview");
} finally {
teardownDom(env);
}
}
async test_border_offset_points_towards_the_owner() {
const a = { x: 0, y: 0 };
const b = { x: 0, y: 10 };
this.assertEqual(inwardOffset(a, b, { x: -5, y: 5 }, 3), 3);
this.assertEqual(inwardOffset(a, b, { x: 5, y: 5 }, 3), -3);
}
async test_neighbouring_borders_are_inset_not_overlaid() {
const state = smallState();
const { env, map } = await this.build(state);
try {
// Bring the two-tile territory into view so its chunk is materialised.
map.camera.x = 0;
map.camera.y = 0;
map._applyCamera();
map.civilisations = [{ primaryColour: "#111111" }, { primaryColour: "#eeeeee" }];
map.territory = new Map([["0,0", 0], ["1,0", 1]]);
map._renderBorders();
// Each segment is nudged towards its owner's tile, so the two sides of a
// shared edge sit next to each other instead of painting over each other.
const segments = env.$("#layer-borders .border-seg").toArray();
this.assertGreater(segments.length, 0);
for (const segment of segments) {
this.assert(
segment.style.transform.includes("translateY"),
`expected an inset border, got ${segment.style.transform}`
);
}
} finally {
teardownDom(env);
}
}
async test_selecting_a_unit_marks_its_view() {
const state = smallState();
const { env, map, snapshot } = await this.build(state);
try {
const unit = snapshot.units.find((u) => u.civ === 0);
map.setSelectedUnit(unit.id);
this.assertSize(env.$("#layer-entities .unit.selected"), 1);
this.assertEqual(map.unitAt({ x: unit.coords[0], y: unit.coords[1] }), unit.id);
} finally {
teardownDom(env);
}
}
async test_predict_move_starts_a_local_route() {
const state = smallState();
const { env, map, snapshot } = await this.build(state);
@@ -509,20 +226,6 @@ export class MapViewTest extends TestCase {
}
}
async test_pan_moves_the_camera() {
const state = smallState();
const { env, map } = await this.build(state);
try {
const beforeX = map.camera.x;
const beforeY = map.camera.y;
map.panBy(10, -5);
this.assertApprox(map.camera.x, beforeX + 10, 1e-9);
this.assertApprox(map.camera.y, beforeY - 5, 1e-9);
} finally {
teardownDom(env);
}
}
async test_syncs_and_draws_an_authoritative_path() {
const state = smallState();
const unit = state.units.find((u) => u.civ === 0);
@@ -594,285 +297,6 @@ export class MapViewTest extends TestCase {
}
}
async test_click_handling_selects_and_orders() {
const state = smallState();
const { env, map, snapshot } = await this.build(state);
try {
const unit = snapshot.units.find((u) => u.civ === 0);
let selected = -1;
map.onUnitSelected = (id) => {
selected = id;
};
map._onLeftClick({ x: unit.coords[0], y: unit.coords[1] });
this.assertEqual(selected, unit.id);
let order = null;
map.onMoveOrdered = (ids, coords) => {
order = { ids, coords };
};
map.setSelectedUnit(unit.id);
const stateUnit = state.units.find((u) => u.id === unit.id);
const goal = adjacentLand(state, stateUnit);
map._onRightClick(goal);
this.assertEqual(order.ids, [unit.id]);
this.assertEqual(order.coords, goal);
let tile = null;
map.onTileRequested = (coords) => {
tile = coords;
};
map.clearSelection();
map._onRightClick(goal);
this.assertEqual(tile, goal);
} finally {
teardownDom(env);
}
}
async test_right_click_on_a_unit_icon_orders_the_selected_stack() {
const state = smallState();
const unit = state.units.find((u) => u.civ === 0);
const goal = adjacentLand(state, unit);
const target = state._spawnUnit(goal, 0, state.protoUnits[0]);
const { env, map } = await this.build(state);
try {
let moved = null;
map.onMoveOrdered = (ids, coords) => {
moved = { ids, coords };
};
map.setSelectedUnit(unit.id);
const local = mapToLocal(goal.x, goal.y);
const clientX = 400 + (local.x - map.camera.x) * map.camera.zoom;
const clientY = 300 + (local.y - map.camera.y) * map.camera.zoom * CAMERA_TILT;
const view = map._unitViews.get(target.id);
this.assertNotNull(view, "the target unit has a view");
// Real bubbling events, so the icon's own native handler is exercised:
// it must let right-clicks reach the viewport's mousedown listener.
const press = new env.window.MouseEvent("mousedown", { button: 2, bubbles: true, clientX, clientY });
view.dispatchEvent(press);
const release = new env.window.MouseEvent("mouseup", { button: 2, bubbles: true, clientX, clientY });
env.window.dispatchEvent(release);
this.assertNotNull(moved, "right-clicking an icon gives the order");
this.assertEqual(moved.ids, [unit.id]);
this.assertEqual(moved.coords, goal);
} finally {
teardownDom(env);
}
}
async test_left_click_selects_city_or_clears() {
const state = smallState();
const { env, map, snapshot } = await this.build(state);
try {
let chosen = null;
map.onCitySelected = (id) => {
chosen = id;
};
// A non-capital city tile has no unit on it.
const city = snapshot.cities.find((c) => c.civ === 0 && !c.isCapital);
const coords = { x: city.coords[0], y: city.coords[1] };
map._onLeftClick(coords);
this.assertEqual(chosen, city.id);
this.assertEqual(map.cityAt(coords).id, city.id);
let cleared = -1;
map.onUnitSelected = (id) => {
cleared = id;
};
map.setSelectedUnit(snapshot.units[0].id);
const sea = seaTile(state);
map._onLeftClick(sea);
this.assertEqual(cleared, 0, "clicking empty ground clears the selection");
this.assertEqual(map.unitAt(sea), 0);
this.assertNull(map.cityAt(sea));
} finally {
teardownDom(env);
}
}
async test_city_marker_click_reports_the_city() {
const state = smallState();
const { env, map, snapshot } = await this.build(state);
try {
let chosen = null;
map.onCitySelected = (id) => {
chosen = id;
};
const owned = env.$("#layer-entities .city[data-owned='1']");
this.assertGreater(owned.length, 0);
owned.first().find(".marker").click();
this.assertEqual(chosen, snapshot.cities.find((c) => c.civ === 0).id);
} finally {
teardownDom(env);
}
}
async test_clear_selection_notifies() {
const state = smallState();
const { env, map, snapshot } = await this.build(state);
try {
const unit = snapshot.units.find((u) => u.civ === 0);
map.setSelectedUnit(unit.id);
let selected = -1;
map.onUnitSelected = (id) => {
selected = id;
};
map.clearSelection();
this.assertEqual(selected, 0);
this.assertSize(env.$("#layer-entities .unit.selected"), 0);
} finally {
teardownDom(env);
}
}
async test_selected_tile_is_outlined() {
const state = smallState();
const { env, map } = await this.build(state);
try {
map.setSelectedTile({ x: 0, y: 0 });
const hex = env.$("#layer-highlight .tile-selection");
this.assertSize(hex, 1, "the outline is created");
this.assertTrue(hex.hasClass("active"), "the outline is shown");
const points = (hex.find("polygon").attr("points") || "").split(" ");
this.assertSize(points, 6, "a hexagon outline");
const wrapped = map._wrappedPosition(mapToLocal(0, 0));
this.assertApprox(parseFloat(hex[0].style.left), wrapped.x - HEX_W / 2, 1e-6);
map.clearSelectedTile();
this.assertFalse(hex.hasClass("active"), "the outline is hidden again");
} finally {
teardownDom(env);
}
}
async test_selected_tile_reports_its_region() {
const state = smallState();
const { env, map } = await this.build(state);
try {
this.assertGreater(map.regions.size, 0, "regions are mirrored from the snapshot");
const [tileKey, cityId] = map.regions.entries().next().value;
map.setSelectedTile(parseKey(tileKey));
this.assertEqual(map._selectedRegion, cityId, "the tile's region is selected as a whole");
map.clearSelectedTile();
this.assertNull(map._selectedRegion, "clearing drops the region");
} finally {
teardownDom(env);
}
}
async test_stacked_units_show_one_icon_with_a_count_badge() {
const state = smallState();
const unit = state.units.find((u) => u.civ === 0);
const second = state._spawnUnit(unit.coords, 0, state.protoUnits[0]);
const { env, map } = await this.build(state);
try {
const first = map._unitViews.get(unit.id);
const other = map._unitViews.get(second.id);
this.assertEqual(first.querySelector(".unit-count").style.display, "block");
this.assertEqual(first.querySelector(".unit-count").textContent, "2");
this.assertEqual(other.style.visibility, "hidden", "the follower is not drawn");
const ids = map.unitIdsAt({ x: unit.coords.x, y: unit.coords.y }).sort((a, b) => a - b);
this.assertEqual(ids, [unit.id, second.id].sort((a, b) => a - b), "both are selectable");
} finally {
teardownDom(env);
}
}
async test_right_click_on_a_friendly_stack_opens_the_menu() {
const state = smallState();
const unit = state.units.find((u) => u.civ === 0);
const second = state._spawnUnit(unit.coords, 0, state.protoUnits[0]);
const { env, map } = await this.build(state);
try {
let menu = null;
map.onStackMenu = (coords, ids, x, y) => {
menu = { coords, ids, x, y };
};
map._onRightClick({ x: unit.coords.x, y: unit.coords.y }, { clientX: 11, clientY: 22 });
this.assertNotNull(menu, "the stack menu opens");
this.assertEqual(menu.ids.sort((a, b) => a - b), [unit.id, second.id].sort((a, b) => a - b));
this.assertEqual(menu.x, 11);
this.assertEqual(menu.y, 22);
} finally {
teardownDom(env);
}
}
async test_stack_ids_group_units_sharing_a_tile() {
const state = smallState();
const unit = state.units.find((u) => u.civ === 0);
const second = state._spawnUnit(unit.coords, 0, state.protoUnits[0]);
const { env, map } = await this.build(state);
try {
const ids = map.stackIds(unit.id).sort((a, b) => a - b);
this.assertEqual(ids, [unit.id, second.id].sort((a, b) => a - b));
} finally {
teardownDom(env);
}
}
async test_right_click_on_a_friendly_stack_while_selected_moves_there() {
const state = smallState();
const unit = state.units.find((u) => u.civ === 0);
const second = state._spawnUnit(unit.coords, 0, state.protoUnits[0]);
const { env, map } = await this.build(state);
try {
let menu = null;
let moved = null;
map.onStackMenu = () => { menu = true; };
map.onMoveOrdered = (ids, coords) => { moved = { ids, coords }; };
map.setSelectedUnit(second.id);
map._onRightClick({ x: unit.coords.x, y: unit.coords.y }, {});
this.assertNull(menu, "the stack menu does not open over a selection");
this.assertNotNull(moved, "the selected stack is ordered onto the friendly tile");
this.assertEqual(moved.ids, [second.id]);
this.assertEqual(moved.coords, { x: unit.coords.x, y: unit.coords.y });
} finally {
teardownDom(env);
}
}
async test_right_click_on_an_enemy_stack_attacks_it() { const state = smallState();
const unit = state.units.find((u) => u.civ === 0);
const goal = adjacentLand(state, unit);
state._spawnUnit(goal, 1, state.protoUnits[0]);
const { env, map } = await this.build(state);
try {
let attack = null;
let move = null;
map.onAttackOrdered = (ids, coords) => { attack = { ids, coords }; };
map.onMoveOrdered = (ids, coords) => { move = { ids, coords }; };
map.setSelectedUnit(unit.id);
map._onRightClick(goal, {});
this.assertNotNull(attack, "the enemy stack is attacked");
this.assertNull(move, "the enemy stack is not treated as a plain move");
this.assertEqual(attack.coords, goal);
} finally {
teardownDom(env);
}
}
async test_ctrl_right_click_schedules_a_destination() {
const state = smallState();
const unit = state.units.find((u) => u.civ === 0);
const goal = adjacentLand(state, unit);
const { env, map } = await this.build(state);
try {
let schedule = null;
let move = null;
map.onScheduleOrdered = (ids, coords) => { schedule = { ids, coords }; };
map.onMoveOrdered = (ids, coords) => { move = { ids, coords }; };
map.setSelectedUnit(unit.id);
map._onRightClick(goal, { ctrlKey: true });
this.assertNotNull(schedule, "Ctrl-right-click queues a destination");
this.assertNull(move, "a scheduled click is not a plain move");
this.assertEqual(schedule.coords, goal);
} finally {
teardownDom(env);
}
}
async test_city_name_carries_a_production_progress_bar() {
const state = smallState();
state.budgets.set(0, 1.0e15);
@@ -933,37 +357,6 @@ export class MapViewTest extends TestCase {
}
}
async test_a_moving_unit_splits_from_its_stack_at_once() {
const state = smallState();
const unit = state.units.find((u) => u.civ === 0);
const second = state._spawnUnit(unit.coords, 0, state.protoUnits[0]);
const { env, map } = await this.build(state);
try {
const tile = { x: unit.coords[0], y: unit.coords[1] };
map._unitMotion.get(unit.id).path = [tile, { x: tile.x + 1, y: tile.y }];
map._unitMotion.get(unit.id).segmentHours = [1];
map._unitMotion.get(unit.id).pathHours = 0.1;
map._assignStackOffsets();
this.assertEqual(
map._unitViews.get(unit.id).style.visibility,
"",
"the moving unit is drawn on its own"
);
this.assertEqual(
map._unitViews.get(second.id).style.visibility,
"",
"the unit left behind stays visible"
);
this.assertEqual(
map._unitViews.get(second.id).querySelector(".unit-count").style.display,
"none",
"the stack badge is gone the moment one member leaves"
);
} finally {
teardownDom(env);
}
}
async test_snapshot_truncation_uses_one_tile_index() {
const state = smallState();
const unit = state.units.find((u) => u.civ === 0);
tests/politics_test.js
+3 -1
View File
@@ -168,7 +168,9 @@ export class PoliticsModelTest extends TestCase {
state._shiftGovOpinion(0, 1, 0.49);
state.requestCampaign(0, 0, CAMPAIGN_GOVERNMENT, 1, 1);
state.requestSetCampaignSpending(0, state.campaigns[0].id, PROPAGANDA.maxHourlyCost);
daysPass(state, 4000);
// The opinion settles well inside a couple of hundred days; the ceiling is
// what matters, not the elapsed time.
daysPass(state, 200);
this.assertLess(
state.getGovOpinion(0, 1),
OPINION.max + 1e-9,
tests/rules_test.js
+37 -88
View File
@@ -5,8 +5,6 @@ import {
buildingUpkeep,
buildingEffectValue,
governmentChangeCost,
governmentEffects,
technologyEffects,
prerequisitesMet,
defenseFactors,
defenseMultiplier,
@@ -14,15 +12,7 @@ import {
productionFactors,
productionFromFactors,
} from "../shared/rules.js";
import {
effectValue,
GOVERNMENTS,
TECHNOLOGIES,
TERRAIN_TILES,
EFFECT_PRODUCTION,
EFFECT_RESEARCH,
EFFECT_CULTURE,
} from "../shared/data.js";
import { effectValue, TECHNOLOGIES, TERRAIN_TILES } from "../shared/data.js";
function proto(overrides = {}) {
return {
@@ -34,32 +24,28 @@ function proto(overrides = {}) {
};
}
function terrain(type) {
return TERRAIN_TILES.find((t) => t.terrainType === type);
}
export class RulesTest extends TestCase {
test_build_cost_grows_exponentially_with_level() {
test_build_cost_grows_with_level_and_ignores_gdp() {
const building = proto({ baseCost: 100, costAlpha: 2.0 });
this.assertApprox(buildingBuildCost(building, 0), 100);
this.assertApprox(buildingBuildCost(building, 1), 200);
this.assertApprox(buildingBuildCost(building, 2), 400);
this.assertApprox(buildingBuildCost(building, 3), 100 * Math.pow(2.0, 3));
}
test_build_cost_is_fixed_and_independent_of_gdp() {
const building = proto({ baseCost: 100, costAlpha: 1.5 });
this.assertApprox(buildingBuildCost(building, 0), 100);
this.assertApprox(buildingBuildCost(building, 3), 100 * Math.pow(1.5, 3));
}
test_upkeep_is_one_percent_of_the_levels_build_cost() {
test_upkeep_and_refund_follow_the_build_cost() {
const building = proto({ baseCost: 100, costAlpha: 2.0 });
this.assertEqual(buildingUpkeep(building, 0), 0);
this.assertApprox(buildingUpkeep(building, 1), 1);
this.assertApprox(buildingUpkeep(building, 2), 2);
this.assertApprox(buildingUpkeep(building, 3), 4);
}
test_refund_is_a_fraction_of_the_removed_level() {
const building = proto({ baseCost: 100, refundFraction: 0.5 });
this.assertApprox(buildingRefund(building, 1), 50);
this.assertApprox(buildingRefund(building, 2), 75);
const refunding = proto({ baseCost: 100, refundFraction: 0.5 });
this.assertApprox(buildingRefund(refunding, 1), 50);
this.assertApprox(buildingRefund(refunding, 2), 75);
}
test_effect_is_linear_or_sublinear() {
@@ -93,89 +79,60 @@ export class RulesTest extends TestCase {
this.assertApprox(governmentChangeCost(government, -50), 100);
}
test_catalogue_effects() {
const monarchy = GOVERNMENTS.find((g) => g.id === "monarchy");
this.assertApprox(governmentEffects(monarchy)[EFFECT_PRODUCTION], 0.1);
this.assertApprox(governmentEffects(monarchy)[EFFECT_CULTURE], 1.0);
const technocracy = GOVERNMENTS.find((g) => g.id === "technocracy");
this.assertGreater(
governmentEffects(technocracy)[EFFECT_RESEARCH],
governmentEffects(monarchy)[EFFECT_RESEARCH] || 0
);
const method = TECHNOLOGIES.find((t) => t.id === "scientific_method");
this.assertApprox(technologyEffects(method)[EFFECT_RESEARCH], 1.0);
this.assertApprox(technologyEffects(method)[EFFECT_PRODUCTION], 0.02);
}
test_prerequisites_met() {
const method = TECHNOLOGIES.find((t) => t.id === "scientific_method");
this.assertEmpty(method.prerequisites);
this.assertTrue(prerequisitesMet(method, new Set(), TECHNOLOGIES), "a root tech needs nothing");
const space = TECHNOLOGIES.find((t) => t.id === "space_program");
this.assertFalse(prerequisitesMet(space, new Set(), TECHNOLOGIES));
const index = (id) => TECHNOLOGIES.findIndex((t) => t.id === id);
this.assertFalse(prerequisitesMet(space, new Set(), TECHNOLOGIES), "missing all prerequisites");
this.assertFalse(
prerequisitesMet(space, new Set([index("scientific_method"), index("industrial_automation")]), TECHNOLOGIES)
prerequisitesMet(space, new Set([index("scientific_method"), index("industrial_automation")]), TECHNOLOGIES),
"still missing one"
);
this.assertTrue(
prerequisitesMet(
space,
new Set([index("scientific_method"), index("industrial_automation"), index("quantum_computing")]),
TECHNOLOGIES
)
),
"all prerequisites met"
);
}
test_root_technology_has_no_prerequisites() {
const method = TECHNOLOGIES.find((t) => t.id === "scientific_method");
this.assertEmpty(method.prerequisites);
this.assertTrue(prerequisitesMet(method, new Set(), TECHNOLOGIES));
}
test_defense_factors_and_multiplier() {
const mountain = terrain("Mountain");
const plains = terrain("Land");
test_defense_factors_come_from_the_tile_and_its_city() {
const mountain = TERRAIN_TILES.find((t) => t.terrainType === "Mountain");
const plains = TERRAIN_TILES.find((t) => t.terrainType === "Land");
this.assertSize(defenseFactors(plains, false), 0, "open land defends normally");
this.assertSize(defenseFactors(null, false), 0, "no tile, no factor");
const mountainFactors = defenseFactors(mountain, false);
this.assertSize(mountainFactors, 1);
this.assertEqual(mountainFactors[0].label, "Mountain");
this.assertApprox(mountainFactors[0].bonus, 1.0);
const cityFactors = defenseFactors(mountain, true);
this.assertSize(cityFactors, 2);
this.assertEqual(cityFactors[1].label, "City");
this.assertApprox(cityFactors[1].bonus, 0.5);
}
test_defense_multiplier_adds_terrain_and_city_bonuses() {
const forest = TERRAIN_TILES.find((t) => t.terrainType === "Forest");
const mountain = TERRAIN_TILES.find((t) => t.terrainType === "Mountain");
const plains = TERRAIN_TILES.find((t) => t.terrainType === "Land");
this.assertApprox(defenseMultiplier(plains, false), 1.0);
this.assertApprox(defenseMultiplier(forest, false), 1.33);
this.assertApprox(defenseMultiplier(terrain("Forest"), false), 1.33);
this.assertApprox(defenseMultiplier(mountain, false), 2.0);
this.assertApprox(defenseMultiplier(mountain, true), 2.5);
}
test_unit_defense_scales_the_base_stat() {
const mountain = TERRAIN_TILES.find((t) => t.terrainType === "Mountain");
this.assertApprox(unitDefense(100, mountain, false), 200);
this.assertApprox(unitDefense(100, mountain, true), 250);
this.assertApprox(unitDefense(100, null, false), 100);
this.assertApprox(terrain("Forest").defenseBonus, 0.33);
this.assertApprox(terrain("Hills").defenseBonus, 0.33);
this.assertApprox(mountain.defenseBonus, 1.0);
this.assertApprox(plains.defenseBonus, 0);
}
test_terrain_defense_bonuses_match_the_spec() {
const bonusOf = (type) => {
const tile = TERRAIN_TILES.find((t) => t.terrainType === type);
return tile ? tile.defenseBonus : 0;
};
this.assertApprox(bonusOf("Forest"), 0.33);
this.assertApprox(bonusOf("Hills"), 0.33);
this.assertApprox(bonusOf("Mountain"), 1.0);
this.assertApprox(bonusOf("Land"), 0);
}
test_production_factors_name_the_terrain_and_settlement() {
const plains = TERRAIN_TILES.find((t) => t.terrainType === "Land");
test_production_factors_and_application() {
const plains = terrain("Land");
const base = productionFactors(plains);
this.assertSize(base, 1);
this.assertEqual(base[0].label, "Land");
@@ -185,25 +142,17 @@ export class RulesTest extends TestCase {
this.assertSize(city, 2);
this.assertEqual(city[1].label, "City");
this.assertApprox(city[1].multiplier, 2);
const capital = productionFactors(plains, { cityKind: "capital" });
this.assertApprox(capital[1].multiplier, 2.5);
this.assertApprox(productionFactors(plains, { cityKind: "capital" })[1].multiplier, 2.5);
const near = productionFactors(plains, { nextToCity: true });
this.assertEqual(near[1].label, "Near city");
this.assertApprox(near[1].multiplier, 1.3);
}
test_production_factors_include_the_marks_of_war() {
const plains = TERRAIN_TILES.find((t) => t.terrainType === "Land");
const factors = productionFactors(plains, { pillagePenalty: 0.7, battleDeficit: 500 });
this.assertEqual(factors[1].label, "Pillaging");
this.assertApprox(factors[1].multiplier, 0.7);
this.assertEqual(factors[2].label, "Battle damage");
this.assertApprox(factors[2].amount, -500);
}
const war = productionFactors(plains, { pillagePenalty: 0.7, battleDeficit: 500 });
this.assertEqual(war[1].label, "Pillaging");
this.assertApprox(war[1].multiplier, 0.7);
this.assertEqual(war[2].label, "Battle damage");
this.assertApprox(war[2].amount, -500);
test_production_from_factors_applies_in_order_and_floors_at_zero() {
this.assertApprox(
productionFromFactors(10000, [{ multiplier: 2 }, { amount: -500 }]),
19500
tests/run_tests.js
+17 -4
View File
@@ -19,7 +19,9 @@ import { cpus } from "node:os";
const HERE = dirname(fileURLToPath(import.meta.url));
const SELF = fileURLToPath(import.meta.url);
const RESULT_MARKER = "__TEST_RESULT__";
const MAX_JOBS = 8;
// One worker per core, capped so a huge build machine is not flooded with
// jsdom workers. `--jobs N` still overrides this.
const MAX_JOBS = Math.min(16, cpus().length);
function flagValue(args, flag) {
const inline = args.find((arg) => arg.startsWith(`${flag}=`));
@@ -35,6 +37,19 @@ function discoverFiles() {
.sort();
}
// Every `test_*` method on a prototype chain, sorted. Walking the chain lets a
// suite share an inherited fixture base that declares no tests of its own;
// without that, those test methods would not be discovered on the subclass.
function testMethods(prototype) {
const names = new Set();
for (let proto = prototype; proto && proto !== Object.prototype; proto = Object.getPrototypeOf(proto)) {
for (const name of Object.getOwnPropertyNames(proto)) {
if (name.startsWith("test_") && name !== "constructor") names.add(name);
}
}
return [...names].sort();
}
// The TestCase classes a module exports, with their sorted test methods. Using
// the exports rather than a hand-written list means a new test file is picked
// up with no runner edit.
@@ -42,9 +57,7 @@ function testClasses(module) {
const classes = [];
for (const value of Object.values(module)) {
if (typeof value !== "function" || !value.prototype) continue;
const methods = Object.getOwnPropertyNames(value.prototype)
.filter((name) => name.startsWith("test_") && name !== "constructor")
.sort();
const methods = testMethods(value.prototype);
if (methods.length > 0) classes.push({ ctor: value, methods });
}
return classes;
tests/stacking_test.js
+51 -61
View File
@@ -42,30 +42,34 @@ export class StackingTest extends TestCase {
return counter;
}
test_friendly_units_can_share_a_tile() {
test_friendly_units_share_a_tile_and_move_at_the_slowest_speed() {
const state = smallState();
const pair = emptyLandPair(state);
const first = state._spawnUnit(pair.a, 0, state.protoUnits[0]);
state._spawnUnit(pair.a, 0, state.protoUnits[0]);
this.assertEqual(state.unitsAt(pair.a).length, 2, "both units stack");
this.assertTrue(state._canUnitEnter(first, pair.a), "a unit may join its own stack");
}
test_a_stack_moves_at_its_slowest_speed() {
const state = smallState();
const pair = emptyLandPair(state);
const infantry = state._spawnUnit(pair.a, 0, state.protoUnits[0]);
const artillery = state._spawnUnit(pair.a, 0, state.protoUnits[2]);
this.assertTrue(state.requestGroupMove([infantry.id, artillery.id], pair.b));
const slow = smallState();
const slowPair = emptyLandPair(slow);
const infantry = slow._spawnUnit(slowPair.a, 0, slow.protoUnits[0]);
const artillery = slow._spawnUnit(slowPair.a, 0, slow.protoUnits[2]);
this.assertTrue(slow.requestGroupMove([infantry.id, artillery.id], slowPair.b));
this.assertApprox(infantry.moveSpeed, 0.25, 1e-9, "pinned to the slowest member");
this.assertApprox(artillery.moveSpeed, 0.25, 1e-9);
state.advanceMovement(1000);
this.assertEqual(infantry.coords, pair.b);
this.assertEqual(artillery.coords, pair.b);
this.assertEqual(state.unitsAt(pair.b).length, 2, "the stack stays together");
slow.advanceMovement(1000);
this.assertEqual(infantry.coords, slowPair.b);
this.assertEqual(artillery.coords, slowPair.b);
this.assertEqual(slow.unitsAt(slowPair.b).length, 2, "the stack stays together");
const lone = smallState();
const lonePair = emptyLandPair(lone);
const solo = lone._spawnUnit(lonePair.a, 0, lone.protoUnits[0]);
lone.requestMove(solo.id, lonePair.b);
this.assertNull(solo.moveSpeed, "a solo move is not slowed by neighbours");
}
test_a_stack_of_one_type_pathfinds_once_and_shares_the_route() {
test_group_pathfinding_is_shared_per_unit_type() {
const state = smallState();
const pair = emptyLandPair(state);
const ids = [];
@@ -77,52 +81,43 @@ export class StackingTest extends TestCase {
for (const id of ids) {
this.assertTrue(state.findUnit(id).path === first, "the stack shares one route");
}
}
test_a_mixed_stack_pathfinds_once_per_unit_type() {
const state = smallState();
const pair = emptyLandPair(state);
const ids = [
state._spawnUnit(pair.a, 0, state.protoUnits[0]).id,
state._spawnUnit(pair.a, 0, state.protoUnits[0]).id,
state._spawnUnit(pair.a, 0, state.protoUnits[2]).id,
const mixed = smallState();
const mixedPair = emptyLandPair(mixed);
const mixedIds = [
mixed._spawnUnit(mixedPair.a, 0, mixed.protoUnits[0]).id,
mixed._spawnUnit(mixedPair.a, 0, mixed.protoUnits[0]).id,
mixed._spawnUnit(mixedPair.a, 0, mixed.protoUnits[2]).id,
];
const searches = this.countPathSearches(state);
this.assertTrue(state.requestGroupMove(ids, pair.b));
this.assertEqual(searches.count, 2, "one search per type, not per unit");
const mixedSearches = this.countPathSearches(mixed);
this.assertTrue(mixed.requestGroupMove(mixedIds, mixedPair.b));
this.assertEqual(mixedSearches.count, 2, "one search per type, not per unit");
}
test_a_lone_unit_keeps_its_own_speed() {
const state = smallState();
const pair = emptyLandPair(state);
const infantry = state._spawnUnit(pair.a, 0, state.protoUnits[0]);
state.requestMove(infantry.id, pair.b);
this.assertNull(infantry.moveSpeed, "a solo move is not slowed by neighbours");
}
test_garrisoned_units_heal_one_hp_per_hour() {
test_units_heal_only_when_garrisoned_and_never_past_maximum() {
const state = smallState();
const city = state.cities.find((c) => c.civ === 0);
const unit = state._spawnUnit(city.coords, 0, state.protoUnits[0]);
unit.hp = 100;
state.tickHour();
this.assertEqual(unit.hp, 101, "heals inside a friendly city");
for (let i = 0; i < 1000; i++) state.tickHour();
this.assertEqual(unit.hp, unit.maxHp, "never exceeds maximum");
}
test_units_in_the_field_do_not_heal() {
const state = smallState();
const pair = emptyLandPair(state);
const unit = state._spawnUnit(pair.a, 0, state.protoUnits[0]);
unit.hp = 100;
unit.hp = unit.maxHp - 1;
state.tickHour();
this.assertEqual(unit.hp, 100);
this.assertEqual(unit.hp, unit.maxHp, "reaches full health");
state.tickHour();
this.assertEqual(unit.hp, unit.maxHp, "never exceeds maximum");
const field = smallState();
const pair = emptyLandPair(field);
const wounded = field._spawnUnit(pair.a, 0, field.protoUnits[0]);
wounded.hp = 100;
field.tickHour();
this.assertEqual(wounded.hp, 100, "units in the field do not heal");
}
}
export class PillageTest extends TestCase {
test_pillaging_removes_population_and_heals() {
test_pillaging_removes_population_heals_and_compounds() {
const state = smallState();
// A port adds a flat production figure the pillage does not scale, which
// would keep the ratio above 0.7; drop the ports so the test isolates the
@@ -142,27 +137,25 @@ export class PillageTest extends TestCase {
this.assertApprox(state.tileProductionPenalty.get(k), 0.7, 1e-9);
this.assertApprox(state.getTileGdpPerCapita(coords), gdpBefore * 0.7, 1e-6);
this.assertApprox(unit.hp, 110, 1e-9, "heals 1 HP per 1000 people removed");
}
test_a_stack_pillages_once_per_unit_weakest_first() {
const state = smallState();
const coords = tileOwnedBy(state, 1);
const k = `${coords.x},${coords.y}`;
state.tilePopulation.set(k, 100000);
const strong = state._spawnUnit(coords, 0, state.protoUnits[0]);
const stack = smallState();
const stackCoords = tileOwnedBy(stack, 1);
const stackKey = `${stackCoords.x},${stackCoords.y}`;
stack.tilePopulation.set(stackKey, 100000);
const strong = stack._spawnUnit(stackCoords, 0, stack.protoUnits[0]);
strong.hp = strong.maxHp - 100;
const weak = state._spawnUnit(coords, 0, state.protoUnits[0]);
const weak = stack._spawnUnit(stackCoords, 0, stack.protoUnits[0]);
weak.hp = strong.maxHp / 2;
this.assertTrue(state.requestPillage([strong.id, weak.id]));
this.assertTrue(stack.requestPillage([strong.id, weak.id]));
this.assertApprox(state.tilePopulation.get(k), 81000, 1, "90% of 90% remains");
this.assertApprox(state.tileProductionPenalty.get(k), 0.49, 1e-9, "70% of 70% remains");
this.assertApprox(stack.tilePopulation.get(stackKey), 81000, 1, "90% of 90% remains");
this.assertApprox(stack.tileProductionPenalty.get(stackKey), 0.49, 1e-9, "70% of 70% remains");
this.assertApprox(weak.hp, strong.maxHp / 2 + 10, 1e-9, "the weakest pillages first");
this.assertApprox(strong.hp, strong.maxHp - 100 + 9, 1e-9, "the second heals for the 9000 it removed");
}
test_pillaging_needs_enemy_territory() {
test_pillaging_requires_enemy_territory_and_an_own_unit() {
const state = smallState();
const city = state.cities.find((c) => c.civ === 0);
const unit = state._spawnUnit(city.coords, 0, state.protoUnits[0]);
@@ -173,12 +166,9 @@ export class PillageTest extends TestCase {
if (state.civAt(pair.a) < 0) {
this.assertFalse(state.canPillage([neutral.id]), "cannot pillage unclaimed land");
}
}
test_pillaging_rejects_an_enemy_unit() {
const state = smallState();
const coords = tileOwnedBy(state, 1);
const enemy = state._spawnUnit(coords, 1, state.protoUnits[0]);
const enemyCoords = tileOwnedBy(state, 1);
const enemy = state._spawnUnit(enemyCoords, 1, state.protoUnits[0]);
this.assertFalse(state.requestPillage([enemy.id]));
}
}
tests/terrain_stats_test.js
+4 -27
View File
@@ -1,6 +1,5 @@
import { TestCase } from "./framework/test_case.js";
import { TerrainStats, DEFAULT_MOVEMENT_COST_MULTIPLIER } from "../shared/terrain_stats.js";
import { TERRAIN_TILES } from "../shared/data.js";
export class TerrainStatsTest extends TestCase {
test_authored_values_are_read() {
@@ -12,20 +11,13 @@ export class TerrainStatsTest extends TestCase {
this.assertApprox(stats.movementCostMultiplier({ x: 0, y: 0 }), 1.5);
}
test_unset_values_fall_back() {
const stats = new TerrainStats({ "0,0": {} });
test_unset_missing_and_zero_movement_fall_back() {
const stats = new TerrainStats({ "0,0": {}, "1,0": { movementCostMultiplier: 0 } });
this.assertApprox(stats.populationMultiplier({ x: 0, y: 0 }), 0.0);
this.assertApprox(stats.productionMultiplier({ x: 0, y: 0 }), 0.0);
this.assertApprox(stats.movementCostMultiplier({ x: 0, y: 0 }), DEFAULT_MOVEMENT_COST_MULTIPLIER);
}
test_zero_movement_cost_means_normal() {
const stats = new TerrainStats({ "0,0": { movementCostMultiplier: 0 } });
this.assertApprox(stats.movementCostMultiplier({ x: 0, y: 0 }), DEFAULT_MOVEMENT_COST_MULTIPLIER);
}
test_missing_tile_returns_defaults() {
const stats = new TerrainStats({ "0,0": {} });
this.assertApprox(stats.movementCostMultiplier({ x: 1, y: 0 }), DEFAULT_MOVEMENT_COST_MULTIPLIER);
// A tile off the map gets the same defaults as an unset one.
this.assertApprox(stats.populationMultiplier({ x: 9, y: 9 }), 0.0);
this.assertApprox(stats.movementCostMultiplier({ x: 9, y: 9 }), DEFAULT_MOVEMENT_COST_MULTIPLIER);
}
@@ -37,21 +29,6 @@ export class TerrainStatsTest extends TestCase {
"2,0": {},
});
this.assertApprox(stats.minMovementCostMultiplier(), 0.5);
}
test_min_movement_cost_without_tiles_is_default() {
this.assertApprox(new TerrainStats({}).minMovementCostMultiplier(), DEFAULT_MOVEMENT_COST_MULTIPLIER);
}
test_catalogue_exposes_terrain_multipliers() {
const land = TERRAIN_TILES.filter((t) => t.terrainClass === "Land");
this.assertNotEmpty(land);
for (const tile of land) {
this.assertHas(tile, "populationMultiplier");
this.assertHas(tile, "productionMultiplier");
this.assertHas(tile, "movementCostMultiplier");
}
const cheapest = Math.min(...TERRAIN_TILES.map((t) => t.movementCostMultiplier || DEFAULT_MOVEMENT_COST_MULTIPLIER));
this.assertGreaterOrEqual(cheapest, 0);
}
}
tests/testing_mode_test.js
+2 -1
View File
@@ -1,5 +1,5 @@
import { TestCase } from "./framework/test_case.js";
import { smallState, settleInlandCity } from "./framework/helpers.js";
import { smallState, settleInlandCity, smallConfig } from "./framework/helpers.js";
import { GameServer } from "../server/game_server.js";
import { isLoopback, isLocalRequest } from "../server/server.js";
@@ -13,6 +13,7 @@ function makeServer(testing) {
player_civ: 0,
civilisations: ["france", "britain"],
testing,
mapConfig: smallConfig(),
});
return server;
}
tests/text_format_test.js
+1 -9
View File
@@ -2,32 +2,24 @@ import { TestCase } from "./framework/test_case.js";
import { groupDigits, compact, hours, improvements } from "../shared/text_format.js";
export class TextFormatTest extends TestCase {
test_group_digits() {
test_number_and_list_formatting() {
this.assertEqual(groupDigits(0), "0");
this.assertEqual(groupDigits(7), "7");
this.assertEqual(groupDigits(123), "123");
// The separators are non-breaking spaces, so a number never wraps.
this.assertEqual(groupDigits(1234), "1\u00a0234");
this.assertEqual(groupDigits(1234567), "1\u00a0234\u00a0567");
this.assertEqual(groupDigits(-1234), "-1\u00a0234");
}
test_compact() {
this.assertEqual(compact(0), "0");
this.assertEqual(compact(7), "7");
this.assertEqual(compact(999), "999");
this.assertEqual(compact(1234), "1.23K");
this.assertEqual(compact(1234567), "1.23M");
this.assertEqual(compact(999950), "1M");
this.assertEqual(compact(-2500), "-2.5K");
}
test_hours() {
this.assertEqual(hours(0.5), "0.50 h");
this.assertEqual(hours(2.25), "2.3 h");
}
test_improvements() {
this.assertEqual(improvements([]), "None");
this.assertEqual(improvements(["Eiffel Tower", "Louvre"]), "Eiffel Tower, Louvre");
}