229 lines
10 KiB
JavaScript
229 lines
10 KiB
JavaScript
import { TestCase } from "./framework/test_case.js";
|
|
import { smallState, stripPorts } from "./framework/helpers.js";
|
|
import {
|
|
TECHNOLOGIES,
|
|
EFFECT_INFANTRY_ATTACK,
|
|
EFFECT_CONSTRUCTION_SPEED,
|
|
EFFECT_PRODUCTION,
|
|
EFFECT_RESEARCH,
|
|
} from "../shared/data.js";
|
|
import { NEWS_TECHNOLOGY } from "../shared/data/relations.js";
|
|
|
|
export class GameStateTechnologyTest extends TestCase {
|
|
index(state, id) {
|
|
return state.technologies.findIndex((t) => t.id === id);
|
|
}
|
|
|
|
// Focuses `id` and pours exactly its cost of points into it, the way a nation
|
|
// would over time; returns the index.
|
|
complete(state, id, civ = 0) {
|
|
const index = this.index(state, id);
|
|
this.assertTrue(state.requestFocusTechnology(civ, index), `focusing ${id}`);
|
|
state._addResearch(civ, state.getTechnologyCost(civ, index));
|
|
return index;
|
|
}
|
|
|
|
test_catalogue_links_prerequisites() {
|
|
const root = TECHNOLOGIES.find((t) => t.id === "industrial_automation");
|
|
this.assertEmpty(root.prerequisites, "the lowest tier needs nothing");
|
|
this.assertGreater(root.cost, 0);
|
|
const space = TECHNOLOGIES.find((t) => t.id === "space_program");
|
|
this.assertEqual(space.prerequisites, ["industrial_automation", "quantum_computing"]);
|
|
}
|
|
|
|
test_every_civilisation_starts_with_nothing_researched() {
|
|
const state = smallState();
|
|
this.assertSize(state.technologies, TECHNOLOGIES.length);
|
|
this.assertFalse(state.isResearched(0, 0));
|
|
this.assertEmpty(state.getResearchedIndices(0));
|
|
}
|
|
|
|
test_research_points_fill_the_focused_technology() {
|
|
const state = smallState();
|
|
const index = this.index(state, "quantum_computing");
|
|
this.assertTrue(state.requestFocusTechnology(0, index), "the focus is accepted");
|
|
const cost = state.getTechnologyCost(0, index);
|
|
// Points flow in as they are created; just short of the cost leaves it in
|
|
// progress rather than in a bank.
|
|
state._addResearch(0, cost - 1);
|
|
this.assertFalse(state.isResearched(0, index), "still researching");
|
|
this.assertApprox(state.getTechnologyProgress(0), cost - 1, 1e-6);
|
|
state._addResearch(0, 1);
|
|
this.assertTrue(state.isResearched(0, index), "the technology is discovered");
|
|
this.assertEqual(state.getFocusedTechnology(0), -1, "the focus clears");
|
|
}
|
|
|
|
test_research_is_never_gated_on_the_treasury() {
|
|
const state = smallState();
|
|
// A treasury deep in the red does not stop a nation focusing or accruing
|
|
// research: the shortfall is central-bank debt, not a spending limit.
|
|
state.budgets.set(0, -1_000_000);
|
|
const index = this.index(state, "quantum_computing");
|
|
this.assertTrue(state.requestFocusTechnology(0, index), "the focus is accepted in debt");
|
|
state._addResearch(0, 5);
|
|
this.assertApprox(state.getTechnologyProgress(0), 5, 1e-9, "points still accrue");
|
|
this.assertLess(state.getBudget(0), 0, "the treasury stayed in debt");
|
|
}
|
|
|
|
test_switching_focus_keeps_committed_progress() {
|
|
const state = smallState();
|
|
const weapons = this.index(state, "infantry_weapons");
|
|
const armour = this.index(state, "body_armour");
|
|
this.assertTrue(state.requestFocusTechnology(0, weapons));
|
|
state._addResearch(0, 7);
|
|
this.assertApprox(state.getTechnologyProgress(0, weapons), 7, 1e-9);
|
|
// Switch focus: the weapons points stay committed.
|
|
this.assertTrue(state.requestFocusTechnology(0, armour));
|
|
this.assertApprox(state.getTechnologyProgress(0, weapons), 7, 1e-9, "weapons kept its work");
|
|
this.assertApprox(state.getTechnologyProgress(0, armour), 0, 1e-9);
|
|
state._addResearch(0, 5);
|
|
this.assertApprox(state.getTechnologyProgress(0, armour), 5, 1e-9);
|
|
// Switching back resumes from the seven points already committed.
|
|
this.assertTrue(state.requestFocusTechnology(0, weapons));
|
|
this.assertApprox(state.getTechnologyProgress(0, weapons), 7, 1e-9);
|
|
this.assertEqual(state.getTechnologyProgress(0), 7, "the focus reports its own progress");
|
|
this.assertApprox(state.snapshot(0).techProgress[0][weapons], 7, 1e-9, "progress is shipped");
|
|
}
|
|
|
|
test_nothing_is_researched_without_a_focus() {
|
|
const state = smallState();
|
|
const index = this.index(state, "quantum_computing");
|
|
// Points created with nothing focused are simply not stored anywhere.
|
|
state._addResearch(0, state.getTechnologyCost(0, index) * 10);
|
|
this.assertFalse(state.isResearched(0, index));
|
|
this.assertApprox(state.getTechnologyProgress(0), 0, 1e-9);
|
|
}
|
|
|
|
test_focus_rejects_unknown_technology_and_civilisation() {
|
|
const state = smallState();
|
|
this.assertFalse(state.requestFocusTechnology(0, 999), "unknown technology");
|
|
this.assertFalse(state.requestFocusTechnology(999, 0), "unknown civilisation");
|
|
}
|
|
|
|
test_focus_rejects_when_prerequisites_are_missing() {
|
|
const state = smallState();
|
|
const space = this.index(state, "space_program");
|
|
this.assertFalse(state.canResearchTechnology(0, space));
|
|
this.assertFalse(state.requestFocusTechnology(0, space));
|
|
}
|
|
|
|
test_prerequisites_unlock_the_tree() {
|
|
const state = smallState();
|
|
const space = this.index(state, "space_program");
|
|
this.assertFalse(state.requestFocusTechnology(0, space), "locked before its prerequisites");
|
|
const automation = this.index(state, "industrial_automation");
|
|
this.complete(state, "industrial_automation");
|
|
this.assertTrue(state.isResearched(0, automation));
|
|
this.assertFalse(state.canResearchTechnology(0, space), "one prerequisite is not enough");
|
|
this.complete(state, "quantum_computing");
|
|
this.assertTrue(state.requestFocusTechnology(0, space), "both prerequisites met");
|
|
}
|
|
|
|
test_technology_effects_are_folded_into_gdp() {
|
|
const state = smallState();
|
|
stripPorts(state, 0);
|
|
const index = this.index(state, "renewable_energy");
|
|
const added = TECHNOLOGIES[index].effects.find((e) => e.stat === EFFECT_PRODUCTION).baseValue;
|
|
const base = state.getNationalModifiers(0)[EFFECT_PRODUCTION] || 0;
|
|
const before = state.getPlayerGdp(0);
|
|
this.complete(state, "renewable_energy");
|
|
this.assertApprox(state.getPlayerGdp(0), (before * (1 + base + added)) / (1 + base), 0.01);
|
|
}
|
|
|
|
test_researched_technology_adds_its_research_rate() {
|
|
const withTech = smallState();
|
|
const without = smallState();
|
|
this.complete(withTech, "quantum_computing");
|
|
this.assertApprox(
|
|
withTech.viewerStats(0).researchRate - without.viewerStats(0).researchRate,
|
|
4.0,
|
|
1e-9
|
|
);
|
|
}
|
|
|
|
test_snapshot_exposes_technologies_and_progress() {
|
|
const state = smallState();
|
|
const index = this.complete(state, "quantum_computing");
|
|
const snapshot = state.snapshot(0);
|
|
this.assertSize(snapshot.technologies, state.technologies.length);
|
|
this.assertSize(snapshot.researched, state.civilisations.length);
|
|
this.assertTrue(snapshot.researched[0].includes(index));
|
|
this.assertEmpty(snapshot.researched[1]);
|
|
}
|
|
|
|
test_repeatable_research_costs_two_percent_more_each_level() {
|
|
const state = smallState();
|
|
const index = this.index(state, "infantry_weapons");
|
|
const base = state.getTechnologyCost(0, index);
|
|
this.assertTrue(state.requestFocusTechnology(0, index), "first level");
|
|
state._addResearch(0, base);
|
|
this.assertEqual(state.getTechnologyRepeatCount(0, index), 1);
|
|
this.assertApprox(
|
|
state.getTechnologyCost(0, index),
|
|
base * 1.02,
|
|
1e-6,
|
|
"the next level costs 2% more"
|
|
);
|
|
this.assertTrue(state.requestFocusTechnology(0, index), "second level");
|
|
state._addResearch(0, state.getTechnologyCost(0, index));
|
|
this.assertEqual(state.getTechnologyRepeatCount(0, index), 2);
|
|
this.assertApprox(state.getTechnologyCost(0, index), base * 1.02 * 1.02, 1e-6);
|
|
}
|
|
|
|
test_repeatable_effects_stack_with_each_level() {
|
|
const state = smallState();
|
|
const weapons = this.index(state, "infantry_weapons");
|
|
const construction = this.index(state, "construction_technology");
|
|
for (let level = 0; level < 2; level++) {
|
|
state.requestFocusTechnology(0, weapons);
|
|
state._addResearch(0, state.getTechnologyCost(0, weapons));
|
|
}
|
|
state.requestFocusTechnology(0, construction);
|
|
state._addResearch(0, state.getTechnologyCost(0, construction));
|
|
const modifiers = state.getCivModifiers(0);
|
|
this.assertApprox(modifiers[EFFECT_INFANTRY_ATTACK], 0.02, 1e-9, "two levels stack");
|
|
this.assertApprox(modifiers[EFFECT_CONSTRUCTION_SPEED], 0.01, 1e-9);
|
|
this.assertApprox(state.constructionSpeedMultiplier(0), 1 / 1.01, 1e-9);
|
|
}
|
|
|
|
test_repeatable_research_notifies_without_news() {
|
|
const state = smallState();
|
|
this.complete(state, "quantum_computing");
|
|
this.complete(state, "body_armour");
|
|
const notices = state.news.filter((entry) => entry.type === NEWS_TECHNOLOGY);
|
|
const normalNotice = notices.find((entry) => entry.technology === "quantum_computing");
|
|
const repeatNotice = notices.find((entry) => entry.technology === "body_armour");
|
|
this.assertNotNull(normalNotice);
|
|
this.assertFalse(!!normalNotice.repeatable, "a discovery is a real news event");
|
|
this.assertNotNull(repeatNotice);
|
|
this.assertTrue(repeatNotice.repeatable, "a repeat level is only a notice");
|
|
}
|
|
|
|
test_repeatable_technologies_have_a_theme() {
|
|
for (const proto of TECHNOLOGIES) {
|
|
this.assertTrue(
|
|
typeof proto.theme === "string" && proto.theme.length > 0,
|
|
`${proto.id} is filed under a theme`
|
|
);
|
|
}
|
|
}
|
|
|
|
test_completing_a_repeatable_keeps_it_focused() {
|
|
const state = smallState();
|
|
const index = this.complete(state, "infantry_weapons");
|
|
this.assertEqual(state.getTechnologyRepeatCount(0, index), 1, "one level done");
|
|
this.assertEqual(state.getFocusedTechnology(0), index, "it stays focused");
|
|
// Fresh points keep flowing into the next level without another order.
|
|
state._addResearch(0, state.getTechnologyCost(0, index));
|
|
this.assertEqual(state.getTechnologyRepeatCount(0, index), 2, "the next level completes");
|
|
this.assertApprox(state.getTechnologyProgress(0, index), 0, 1e-9, "reset for the next level");
|
|
}
|
|
|
|
test_research_costs_a_hundred_times_the_catalogue_price() {
|
|
const state = smallState();
|
|
const index = this.index(state, "quantum_computing");
|
|
const proto = TECHNOLOGIES[index];
|
|
this.assertEqual(state.getTechnologyCost(0, index), proto.cost * 100);
|
|
}
|
|
}
|