generated from nhcarrigan/template
264 lines
11 KiB
TypeScript
264 lines
11 KiB
TypeScript
/* eslint-disable max-lines-per-function -- Test suites naturally have many cases */
|
|
/* eslint-disable @typescript-eslint/consistent-type-assertions -- Tests build minimal state objects */
|
|
import { describe, expect, it } from "vitest";
|
|
import {
|
|
buildPostTranscendenceState,
|
|
calculateEchoes,
|
|
computeTranscendenceMultipliers,
|
|
isEligibleForTranscendence,
|
|
} from "../../src/services/transcendence.js";
|
|
import type { GameState } from "@elysium/types";
|
|
|
|
const makePlayer = (overrides: Partial<GameState["player"]> = {}) => ({
|
|
avatar: null,
|
|
characterName: "T",
|
|
discordId: "t",
|
|
discriminator: "0",
|
|
lifetimeAchievementsUnlocked: 0,
|
|
lifetimeAdventurersRecruited: 0,
|
|
lifetimeBossesDefeated: 0,
|
|
lifetimeClicks: 0,
|
|
lifetimeGoldEarned: 0,
|
|
lifetimeQuestsCompleted: 0,
|
|
totalClicks: 0,
|
|
totalGoldEarned: 0,
|
|
username: "u",
|
|
...overrides,
|
|
});
|
|
|
|
const makeMinimalState = (overrides: Partial<GameState> = {}): GameState =>
|
|
({
|
|
player: makePlayer(),
|
|
resources: { gold: 0, essence: 0, crystals: 0, runestones: 0 },
|
|
adventurers: [],
|
|
upgrades: [],
|
|
quests: [],
|
|
bosses: [],
|
|
equipment: [],
|
|
achievements: [],
|
|
zones: [],
|
|
exploration: { areas: [], materials: [], craftedRecipeIds: [], craftedGoldMultiplier: 1, craftedEssenceMultiplier: 1, craftedClickMultiplier: 1, craftedCombatMultiplier: 1 },
|
|
companions: { unlockedCompanionIds: [], activeCompanionId: null },
|
|
prestige: { count: 0, runestones: 0, productionMultiplier: 1, purchasedUpgradeIds: [] },
|
|
baseClickPower: 1,
|
|
lastTickAt: 0,
|
|
schemaVersion: 1,
|
|
...overrides,
|
|
} as GameState);
|
|
|
|
describe("computeTranscendenceMultipliers", () => {
|
|
it("returns all 1s with empty ids", () => {
|
|
const result = computeTranscendenceMultipliers([]);
|
|
expect(result.echoIncomeMultiplier).toBe(1);
|
|
expect(result.echoCombatMultiplier).toBe(1);
|
|
expect(result.echoPrestigeThresholdMultiplier).toBe(1);
|
|
expect(result.echoPrestigeRunestoneMultiplier).toBe(1);
|
|
expect(result.echoMetaMultiplier).toBe(1);
|
|
});
|
|
|
|
it("applies income upgrade when purchased", () => {
|
|
const result = computeTranscendenceMultipliers(["echo_income_1"]);
|
|
expect(result.echoIncomeMultiplier).toBeGreaterThan(1);
|
|
expect(result.echoCombatMultiplier).toBe(1);
|
|
});
|
|
|
|
it("applies combat upgrade when purchased", () => {
|
|
const result = computeTranscendenceMultipliers(["echo_combat_1"]);
|
|
expect(result.echoCombatMultiplier).toBeGreaterThan(1);
|
|
expect(result.echoIncomeMultiplier).toBe(1);
|
|
});
|
|
|
|
it("applies prestige_threshold upgrade when purchased", () => {
|
|
const result = computeTranscendenceMultipliers(["echo_prestige_threshold_1"]);
|
|
expect(result.echoPrestigeThresholdMultiplier).not.toBe(1);
|
|
});
|
|
|
|
it("applies prestige_runestones upgrade when purchased", () => {
|
|
const result = computeTranscendenceMultipliers(["echo_prestige_runestones_1"]);
|
|
expect(result.echoPrestigeRunestoneMultiplier).toBeGreaterThan(1);
|
|
});
|
|
|
|
it("applies echo_meta upgrade when purchased", () => {
|
|
const result = computeTranscendenceMultipliers(["echo_meta_1"]);
|
|
expect(result.echoMetaMultiplier).toBeGreaterThan(1);
|
|
});
|
|
});
|
|
|
|
describe("isEligibleForTranscendence", () => {
|
|
it("returns true when final boss is defeated", () => {
|
|
const state = makeMinimalState({
|
|
bosses: [{ id: "the_absolute_one", status: "defeated" }] as GameState["bosses"],
|
|
});
|
|
expect(isEligibleForTranscendence(state)).toBe(true);
|
|
});
|
|
|
|
it("returns false when final boss is available but not defeated", () => {
|
|
const state = makeMinimalState({
|
|
bosses: [{ id: "the_absolute_one", status: "available" }] as GameState["bosses"],
|
|
});
|
|
expect(isEligibleForTranscendence(state)).toBe(false);
|
|
});
|
|
|
|
it("returns false when final boss is not in the list", () => {
|
|
const state = makeMinimalState({ bosses: [] });
|
|
expect(isEligibleForTranscendence(state)).toBe(false);
|
|
});
|
|
|
|
it("returns false when a different boss is defeated", () => {
|
|
const state = makeMinimalState({
|
|
bosses: [{ id: "some_other_boss", status: "defeated" }] as GameState["bosses"],
|
|
});
|
|
expect(isEligibleForTranscendence(state)).toBe(false);
|
|
});
|
|
});
|
|
|
|
describe("calculateEchoes", () => {
|
|
it("handles prestige count of 0 by treating it as 1", () => {
|
|
// safeCount = max(0, 1) = 1; floor(224 / sqrt(1)) = 224
|
|
expect(calculateEchoes(0, 1)).toBe(224);
|
|
});
|
|
|
|
it("calculates echoes at count 1", () => {
|
|
// floor(224 / sqrt(1)) = 224
|
|
expect(calculateEchoes(1, 1)).toBe(224);
|
|
});
|
|
|
|
it("decreases echoes with higher prestige count", () => {
|
|
const echoesAt1 = calculateEchoes(1, 1);
|
|
const echoesAt4 = calculateEchoes(4, 1);
|
|
expect(echoesAt4).toBeLessThan(echoesAt1);
|
|
// floor(224 / sqrt(4)) = floor(224 / 2) = 112
|
|
expect(echoesAt4).toBe(112);
|
|
});
|
|
|
|
it("applies echoMetaMultiplier", () => {
|
|
const base = calculateEchoes(1, 1);
|
|
const withMult = calculateEchoes(1, 2);
|
|
expect(withMult).toBe(base * 2);
|
|
});
|
|
|
|
it("returns 50 echoes at the target prestige 20", () => {
|
|
// floor(224 / sqrt(20)) = floor(224 / 4.472) = floor(50.09) = 50
|
|
expect(calculateEchoes(20, 1)).toBe(50);
|
|
});
|
|
});
|
|
|
|
describe("buildPostTranscendenceState", () => {
|
|
it("increments transcendence count from 0", () => {
|
|
const state = makeMinimalState();
|
|
const { transcendenceData } = buildPostTranscendenceState(state, "T");
|
|
expect(transcendenceData.count).toBe(1);
|
|
});
|
|
|
|
it("accumulates echoes", () => {
|
|
const state = makeMinimalState({
|
|
transcendence: {
|
|
count: 1, echoes: 100, purchasedUpgradeIds: [],
|
|
echoIncomeMultiplier: 1, echoCombatMultiplier: 1,
|
|
echoPrestigeThresholdMultiplier: 1, echoPrestigeRunestoneMultiplier: 1, echoMetaMultiplier: 1,
|
|
},
|
|
});
|
|
const { transcendenceData, echoesEarned } = buildPostTranscendenceState(state, "T");
|
|
expect(transcendenceData.echoes).toBe(100 + echoesEarned);
|
|
});
|
|
|
|
it("persists codex from current state", () => {
|
|
const codex = { entries: [{ id: "e1", unlockedAt: 1000, sourceType: "exploration" as const }] };
|
|
const state = makeMinimalState({ codex });
|
|
const { transcendenceState } = buildPostTranscendenceState(state, "T");
|
|
expect(transcendenceState.codex).toEqual(codex);
|
|
});
|
|
|
|
it("persists story from current state", () => {
|
|
const story = { unlockedChapterIds: ["ch1"], completedChapters: [] };
|
|
const state = makeMinimalState({ story });
|
|
const { transcendenceState } = buildPostTranscendenceState(state, "T");
|
|
expect(transcendenceState.story).toEqual(story);
|
|
});
|
|
|
|
it("persists apotheosis from current state", () => {
|
|
const apotheosis = { count: 2 };
|
|
const state = makeMinimalState({ apotheosis });
|
|
const { transcendenceState } = buildPostTranscendenceState(state, "T");
|
|
expect(transcendenceState.apotheosis).toEqual(apotheosis);
|
|
});
|
|
|
|
it("persists active companion selection across transcendence", () => {
|
|
const companions = { unlockedCompanionIds: ["lyra", "vex"], activeCompanionId: "vex" };
|
|
const state = makeMinimalState({ companions });
|
|
const { transcendenceState } = buildPostTranscendenceState(state, "T");
|
|
expect(transcendenceState.companions).toEqual(companions);
|
|
});
|
|
|
|
it("falls back to fresh companion state when currentState.companions is undefined", () => {
|
|
const state = makeMinimalState({ companions: undefined });
|
|
const { transcendenceState } = buildPostTranscendenceState(state, "T");
|
|
expect(transcendenceState.companions).toEqual({ activeCompanionId: null, unlockedCompanionIds: [] });
|
|
});
|
|
|
|
it("resets prestige to fresh state", () => {
|
|
const state = makeMinimalState({
|
|
prestige: { count: 5, runestones: 500, productionMultiplier: 2, purchasedUpgradeIds: [] },
|
|
});
|
|
const { transcendenceState } = buildPostTranscendenceState(state, "T");
|
|
expect(transcendenceState.prestige.count).toBe(0);
|
|
expect(transcendenceState.prestige.runestones).toBe(0);
|
|
});
|
|
|
|
it("accumulates current-run gold and clicks into lifetime totals", () => {
|
|
const state = makeMinimalState({
|
|
player: makePlayer({ totalGoldEarned: 4_000_000, lifetimeGoldEarned: 1_000_000, totalClicks: 500 }),
|
|
});
|
|
const { transcendenceState } = buildPostTranscendenceState(state, "T");
|
|
expect(transcendenceState.player.lifetimeGoldEarned).toBe(5_000_000);
|
|
expect(transcendenceState.player.lifetimeClicks).toBe(500);
|
|
});
|
|
|
|
it("accumulates defeated bosses, completed quests, and recruited adventurers into lifetime totals", () => {
|
|
const boss = { id: "boss_1", status: "defeated" as const };
|
|
const quest = { id: "q_1", status: "completed" as const };
|
|
const adventurer = { id: "adv_1", count: 5 };
|
|
const state = makeMinimalState({
|
|
bosses: [ boss ] as GameState["bosses"],
|
|
quests: [ quest ] as GameState["quests"],
|
|
adventurers: [ adventurer ] as GameState["adventurers"],
|
|
});
|
|
const { transcendenceState } = buildPostTranscendenceState(state, "T");
|
|
expect(transcendenceState.player.lifetimeBossesDefeated).toBe(1);
|
|
expect(transcendenceState.player.lifetimeQuestsCompleted).toBe(1);
|
|
expect(transcendenceState.player.lifetimeAdventurersRecruited).toBe(5);
|
|
});
|
|
|
|
it("preserves achievements and accumulates newly-unlocked ones into the lifetime total", () => {
|
|
const achievement = { id: "ach_1", unlockedAt: Date.now() };
|
|
const state = makeMinimalState({
|
|
achievements: [ achievement ] as GameState["achievements"],
|
|
});
|
|
const { transcendenceState } = buildPostTranscendenceState(state, "T");
|
|
expect(transcendenceState.achievements).toEqual([ achievement ]);
|
|
expect(transcendenceState.player.lifetimeAchievementsUnlocked).toBe(1);
|
|
});
|
|
|
|
it("does not re-count achievements already folded into the lifetime total by a previous reset", () => {
|
|
const achievement = { id: "ach_1", unlockedAt: Date.now() };
|
|
const state = makeMinimalState({
|
|
achievements: [ achievement ] as GameState["achievements"],
|
|
player: makePlayer({ lifetimeAchievementsUnlocked: 1 }),
|
|
});
|
|
const { transcendenceState } = buildPostTranscendenceState(state, "T");
|
|
expect(transcendenceState.player.lifetimeAchievementsUnlocked).toBe(1);
|
|
});
|
|
|
|
it("preserves equipment ownership history across transcendence", () => {
|
|
const equipment = { id: "rusty_sword", owned: true, everOwned: true };
|
|
const state = makeMinimalState({
|
|
equipment: [ equipment ] as GameState["equipment"],
|
|
});
|
|
const { transcendenceState } = buildPostTranscendenceState(state, "T");
|
|
const matchingItem = transcendenceState.equipment.find((item) => {
|
|
return item.id === "rusty_sword";
|
|
});
|
|
expect(matchingItem?.everOwned).toBe(true);
|
|
});
|
|
});
|