generated from nhcarrigan/template
hikari
8a332dc9ce
Adds computeEffectiveAdventurerStats to tick.ts to calculate per-unit gold/s, essence/s, and combat power with all active multipliers applied (upgrades, prestige, equipment, echo, crafted, companions). Updates AdventurerCard to display these effective values so players can see the true contribution of each adventurer rather than raw base stats.
851 lines
28 KiB
TypeScript
851 lines
28 KiB
TypeScript
/**
|
|
* @file Game tick engine for Elysium.
|
|
* @copyright nhcarrigan
|
|
* @license Naomi's Public License
|
|
* @author Naomi Carrigan
|
|
*/
|
|
/* eslint-disable @typescript-eslint/naming-convention -- Snake_case IDs and SCREAMING_SNAKE are conventional for game data */
|
|
/* eslint-disable complexity -- Tick engine is inherently complex with many game systems */
|
|
/* eslint-disable max-lines-per-function -- Tick engine processes many systems in one pass for performance */
|
|
/* eslint-disable max-statements -- Tick engine requires many state variables across all game systems */
|
|
/* eslint-disable max-lines -- Engine file necessarily exceeds line limit */
|
|
/* eslint-disable import/group-exports -- Exports appear alongside their definitions for readability */
|
|
/* eslint-disable import/exports-last -- Exports appear alongside their definitions for readability */
|
|
/* eslint-disable unicorn/no-array-reduce -- reduce is the most readable approach for multiplier chains */
|
|
/* eslint-disable max-nested-callbacks -- Tick engine requires nested array operations for game logic */
|
|
import {
|
|
type Achievement,
|
|
type Equipment,
|
|
type GameState,
|
|
computeSetBonuses,
|
|
getActiveCompanionBonus,
|
|
} from "@elysium/types";
|
|
import { EQUIPMENT_SETS } from "../data/equipmentSets.js";
|
|
import { updateChallengeProgress } from "../utils/dailyChallenges.js";
|
|
|
|
/**
|
|
* Checks all achievements against the current game state and returns an updated
|
|
* achievements array, marking newly-met conditions with the current timestamp.
|
|
* @param state - The current game state to check achievements against.
|
|
* @returns Updated achievements array with newly unlocked achievements timestamped.
|
|
*/
|
|
const checkAchievements = (state: GameState): Array<Achievement> => {
|
|
const now = Date.now();
|
|
return state.achievements.map((achievement) => {
|
|
if (achievement.unlockedAt !== null) {
|
|
return achievement;
|
|
}
|
|
|
|
const { condition } = achievement;
|
|
let met = false;
|
|
|
|
switch (condition.type) {
|
|
case "totalGoldEarned":
|
|
met = state.player.totalGoldEarned >= condition.amount;
|
|
break;
|
|
case "totalClicks":
|
|
met = state.player.totalClicks >= condition.amount;
|
|
break;
|
|
case "bossesDefeated":
|
|
met
|
|
= state.bosses.filter((boss) => {
|
|
return boss.status === "defeated";
|
|
}).length >= condition.amount;
|
|
break;
|
|
case "questsCompleted":
|
|
met
|
|
= state.quests.filter((quest) => {
|
|
return quest.status === "completed";
|
|
}).length >= condition.amount;
|
|
break;
|
|
case "adventurerTotal":
|
|
met
|
|
= state.adventurers.reduce((sum, adventurer) => {
|
|
return sum + adventurer.count;
|
|
}, 0) >= condition.amount;
|
|
break;
|
|
case "prestigeCount":
|
|
met = state.prestige.count >= condition.amount;
|
|
break;
|
|
case "equipmentOwned":
|
|
met
|
|
= state.equipment.filter((item) => {
|
|
return item.owned;
|
|
}).length >= condition.amount;
|
|
break;
|
|
default:
|
|
/* V8 ignore next -- @preserve */ break;
|
|
}
|
|
|
|
return met
|
|
? { ...achievement, unlockedAt: now }
|
|
: achievement;
|
|
});
|
|
};
|
|
|
|
/**
|
|
* Maximum value any resource can accumulate to. Beyond this JS floats lose all useful precision.
|
|
*/
|
|
export const RESOURCE_CAP = 1e300;
|
|
|
|
/**
|
|
* Probability of quest failure per zone — scales from 10% (early game) to 40% (end game).
|
|
* On failure the quest resets to "available" with no rewards; the player must wait the
|
|
* full duration again on their next attempt.
|
|
*/
|
|
export const zoneFailureChance: Record<string, number> = {
|
|
abyssal_trench: 0.24,
|
|
astral_void: 0.2,
|
|
celestial_reaches: 0.22,
|
|
cosmic_maelstrom: 0.4,
|
|
crystalline_spire: 0.28,
|
|
eternal_throne: 0.32,
|
|
frozen_peaks: 0.14,
|
|
infernal_court: 0.26,
|
|
infinite_expanse: 0.36,
|
|
primeval_sanctum: 0.4,
|
|
primordial_chaos: 0.34,
|
|
reality_forge: 0.38,
|
|
shadow_marshes: 0.16,
|
|
shattered_ruins: 0.12,
|
|
the_absolute: 0.4,
|
|
verdant_vale: 0.1,
|
|
void_sanctum: 0.3,
|
|
volcanic_depths: 0.18,
|
|
};
|
|
|
|
/**
|
|
* Caps a resource value at RESOURCE_CAP.
|
|
* @param value - The resource value to cap.
|
|
* @returns The capped value.
|
|
*/
|
|
const capResource = (value: number): number => {
|
|
return Math.min(value, RESOURCE_CAP);
|
|
};
|
|
|
|
/**
|
|
* Pure function — applies one game tick to the state.
|
|
* DeltaSeconds: time elapsed since last tick.
|
|
* Returns a new GameState (does not mutate the original).
|
|
* @param state - The current game state.
|
|
* @param deltaSeconds - Time elapsed since last tick in seconds.
|
|
* @returns A new GameState with the tick applied.
|
|
*/
|
|
/**
|
|
* Computes the effective gold earned per second across all adventurers,
|
|
* including all active multipliers (upgrades, prestige, equipment, etc.).
|
|
* @param state - The current game state.
|
|
* @returns Gold per second as a number.
|
|
*/
|
|
export const computeGoldPerSecond = (state: GameState): number => {
|
|
const equippedItems: Array<Equipment> = state.equipment.filter((item) => {
|
|
return item.equipped;
|
|
});
|
|
const equipmentGoldMultiplier = equippedItems.reduce((mult, item) => {
|
|
return mult * (item.bonus.goldMultiplier ?? 1);
|
|
}, 1);
|
|
const setGoldMultiplier = computeSetBonuses(
|
|
equippedItems.map((item) => {
|
|
return item.id;
|
|
}),
|
|
EQUIPMENT_SETS,
|
|
).goldMultiplier;
|
|
|
|
const runestonesIncome = state.prestige.runestonesIncomeMultiplier ?? 1;
|
|
const echoIncome = state.transcendence?.echoIncomeMultiplier ?? 1;
|
|
const craftedGoldMultiplier = state.exploration?.craftedGoldMultiplier ?? 1;
|
|
const companionBonus = getActiveCompanionBonus(
|
|
state.companions?.activeCompanionId,
|
|
state.companions?.unlockedCompanionIds ?? [],
|
|
);
|
|
const companionGoldMult
|
|
= companionBonus?.type === "passiveGold"
|
|
? 1 + companionBonus.value
|
|
: 1;
|
|
|
|
let goldPerSecond = 0;
|
|
for (const adventurer of state.adventurers) {
|
|
if (!adventurer.unlocked || adventurer.count === 0) {
|
|
continue;
|
|
}
|
|
const upgradeMultiplier = state.upgrades.
|
|
filter((upgrade) => {
|
|
const isGlobal = upgrade.target === "global";
|
|
const isThisAdventurer
|
|
= upgrade.target === "adventurer"
|
|
&& upgrade.adventurerId === adventurer.id;
|
|
return upgrade.purchased && (isGlobal || isThisAdventurer);
|
|
}).
|
|
reduce((mult, upgrade) => {
|
|
return mult * upgrade.multiplier;
|
|
}, 1);
|
|
const contribution
|
|
= adventurer.goldPerSecond
|
|
* adventurer.count
|
|
* upgradeMultiplier
|
|
* state.prestige.productionMultiplier
|
|
* runestonesIncome
|
|
* echoIncome
|
|
* equipmentGoldMultiplier
|
|
* setGoldMultiplier
|
|
* craftedGoldMultiplier
|
|
* companionGoldMult;
|
|
goldPerSecond = goldPerSecond + contribution;
|
|
}
|
|
return goldPerSecond;
|
|
};
|
|
|
|
/**
|
|
* Computes the current essence per second for the given game state,
|
|
* applying all relevant multipliers (upgrades, prestige, echo, crafted, companion).
|
|
* @param state - The current game state.
|
|
* @returns The total essence per second.
|
|
*/
|
|
export const computeEssencePerSecond = (state: GameState): number => {
|
|
const runestonesEssence = state.prestige.runestonesEssenceMultiplier ?? 1;
|
|
const craftedEssenceMultiplier
|
|
= state.exploration?.craftedEssenceMultiplier ?? 1;
|
|
const companionBonus = getActiveCompanionBonus(
|
|
state.companions?.activeCompanionId,
|
|
state.companions?.unlockedCompanionIds ?? [],
|
|
);
|
|
const companionEssenceMult
|
|
= companionBonus?.type === "essenceIncome"
|
|
? 1 + companionBonus.value
|
|
: 1;
|
|
|
|
let essencePerSecond = 0;
|
|
for (const adventurer of state.adventurers) {
|
|
if (!adventurer.unlocked || adventurer.count === 0) {
|
|
continue;
|
|
}
|
|
const upgradeMultiplier = state.upgrades.
|
|
filter((upgrade) => {
|
|
const isGlobal = upgrade.target === "global";
|
|
const isThisAdventurer
|
|
= upgrade.target === "adventurer"
|
|
&& upgrade.adventurerId === adventurer.id;
|
|
return upgrade.purchased && (isGlobal || isThisAdventurer);
|
|
}).
|
|
reduce((mult, upgrade) => {
|
|
return mult * upgrade.multiplier;
|
|
}, 1);
|
|
const contribution
|
|
= adventurer.essencePerSecond
|
|
* adventurer.count
|
|
* upgradeMultiplier
|
|
* state.prestige.productionMultiplier
|
|
* runestonesEssence
|
|
* craftedEssenceMultiplier
|
|
* companionEssenceMult;
|
|
essencePerSecond = essencePerSecond + contribution;
|
|
}
|
|
return essencePerSecond;
|
|
};
|
|
|
|
/**
|
|
* Computes the effective per-unit stats for a single adventurer type,
|
|
* applying all active multipliers (upgrades, prestige, equipment, echo,
|
|
* crafted, companion). The returned values represent what a single
|
|
* adventurer of this type currently contributes per second, matching the
|
|
* per-unit contribution used by computeGoldPerSecond and
|
|
* computeEssencePerSecond.
|
|
* @param state - The current game state.
|
|
* @param adventurerId - The ID of the adventurer to compute stats for.
|
|
* @returns Effective per-unit goldPerSecond, essencePerSecond, and combatPower.
|
|
*/
|
|
export const computeEffectiveAdventurerStats = (
|
|
state: GameState,
|
|
adventurerId: string,
|
|
): { combatPower: number; essencePerSecond: number; goldPerSecond: number } => {
|
|
const adventurer = state.adventurers.find((a) => {
|
|
return a.id === adventurerId;
|
|
});
|
|
|
|
/* V8 ignore next 3 -- @preserve */
|
|
if (adventurer === undefined) {
|
|
return { combatPower: 0, essencePerSecond: 0, goldPerSecond: 0 };
|
|
}
|
|
|
|
const upgradeMultiplier = state.upgrades.
|
|
filter((upgrade) => {
|
|
const isGlobal = upgrade.target === "global";
|
|
const isThisAdventurer
|
|
= upgrade.target === "adventurer"
|
|
&& upgrade.adventurerId === adventurerId;
|
|
return upgrade.purchased && (isGlobal || isThisAdventurer);
|
|
}).
|
|
reduce((mult, upgrade) => {
|
|
return mult * upgrade.multiplier;
|
|
}, 1);
|
|
|
|
const equippedItems = state.equipment.filter((item) => {
|
|
return item.equipped;
|
|
});
|
|
const equipmentGoldMultiplier = equippedItems.reduce((mult, item) => {
|
|
return mult * (item.bonus.goldMultiplier ?? 1);
|
|
}, 1);
|
|
const equipmentCombatMultiplier = equippedItems.reduce((mult, item) => {
|
|
return mult * (item.bonus.combatMultiplier ?? 1);
|
|
}, 1);
|
|
const equippedItemIds = equippedItems.map((item) => {
|
|
return item.id;
|
|
});
|
|
const setBonuses = computeSetBonuses(equippedItemIds, EQUIPMENT_SETS);
|
|
|
|
const runestonesIncome = state.prestige.runestonesIncomeMultiplier ?? 1;
|
|
const runestonesEssence = state.prestige.runestonesEssenceMultiplier ?? 1;
|
|
// eslint-disable-next-line stylistic/no-mixed-operators -- prestige count * factor is clear
|
|
const prestigeCombatMultiplier = 1 + state.prestige.count * 0.1;
|
|
const echoIncome = state.transcendence?.echoIncomeMultiplier ?? 1;
|
|
const echoCombatMultiplier = state.transcendence?.echoCombatMultiplier ?? 1;
|
|
const craftedGoldMultiplier
|
|
= state.exploration?.craftedGoldMultiplier ?? 1;
|
|
const craftedEssenceMultiplier
|
|
= state.exploration?.craftedEssenceMultiplier ?? 1;
|
|
const craftedCombatMultiplier
|
|
= state.exploration?.craftedCombatMultiplier ?? 1;
|
|
|
|
const companionBonus = getActiveCompanionBonus(
|
|
state.companions?.activeCompanionId,
|
|
state.companions?.unlockedCompanionIds ?? [],
|
|
);
|
|
const companionGoldMult
|
|
= companionBonus?.type === "passiveGold"
|
|
? 1 + companionBonus.value
|
|
: 1;
|
|
const companionEssenceMult
|
|
= companionBonus?.type === "essenceIncome"
|
|
? 1 + companionBonus.value
|
|
: 1;
|
|
const companionCombatMult
|
|
= companionBonus?.type === "bossDamage"
|
|
? 1 + companionBonus.value
|
|
: 1;
|
|
|
|
const goldPerSecond
|
|
= adventurer.goldPerSecond
|
|
* upgradeMultiplier
|
|
* state.prestige.productionMultiplier
|
|
* runestonesIncome
|
|
* echoIncome
|
|
* equipmentGoldMultiplier
|
|
* setBonuses.goldMultiplier
|
|
* craftedGoldMultiplier
|
|
* companionGoldMult;
|
|
|
|
const essencePerSecond
|
|
= adventurer.essencePerSecond
|
|
* upgradeMultiplier
|
|
* state.prestige.productionMultiplier
|
|
* runestonesEssence
|
|
* craftedEssenceMultiplier
|
|
* companionEssenceMult;
|
|
|
|
const combatPower
|
|
= adventurer.combatPower
|
|
* upgradeMultiplier
|
|
* prestigeCombatMultiplier
|
|
* equipmentCombatMultiplier
|
|
* setBonuses.combatMultiplier
|
|
* echoCombatMultiplier
|
|
* craftedCombatMultiplier
|
|
* companionCombatMult;
|
|
|
|
return { combatPower, essencePerSecond, goldPerSecond };
|
|
};
|
|
|
|
/**
|
|
* Computes the party's total combat power, applying all active multipliers
|
|
* (upgrades, prestige, equipment, set bonuses, echo, crafted, companion).
|
|
* This mirrors the server-side calculatePartyStats in boss.ts and is the
|
|
* single source of truth for all combat-power checks in the client:
|
|
* - Displayed as "Combat Power" in the resource bar
|
|
* - Displayed as "Party DPS" in the boss panel
|
|
* - Used to gate quest availability
|
|
* Note: the active companion's bossDamage bonus is intentionally included
|
|
* here, as it applies to the full combat power calculation (boss fights and
|
|
* quest gating alike), matching the server-side behaviour.
|
|
* @param state - The current game state.
|
|
* @returns The total party combat power.
|
|
*/
|
|
export const computePartyCombatPower = (state: GameState): number => {
|
|
let globalMultiplier = 1;
|
|
for (const upgrade of state.upgrades) {
|
|
if (upgrade.purchased && upgrade.target === "global") {
|
|
globalMultiplier = globalMultiplier * upgrade.multiplier;
|
|
}
|
|
}
|
|
|
|
// eslint-disable-next-line stylistic/no-mixed-operators -- prestige count * factor is clear
|
|
const prestigeMultiplier = 1 + state.prestige.count * 0.1;
|
|
|
|
const equipmentCombatMultiplier = state.equipment.
|
|
filter((item) => {
|
|
return item.equipped && item.bonus.combatMultiplier !== undefined;
|
|
}).
|
|
reduce((mult, item) => {
|
|
return mult * (item.bonus.combatMultiplier ?? 1);
|
|
}, 1);
|
|
|
|
const equippedItemIds = state.equipment.
|
|
filter((item) => {
|
|
return item.equipped;
|
|
}).
|
|
map((item) => {
|
|
return item.id;
|
|
});
|
|
const { combatMultiplier: setCombatMultiplier } = computeSetBonuses(
|
|
equippedItemIds,
|
|
EQUIPMENT_SETS,
|
|
);
|
|
|
|
const echoCombatMultiplier
|
|
= state.transcendence?.echoCombatMultiplier ?? 1;
|
|
const craftedCombatMultiplier
|
|
= state.exploration?.craftedCombatMultiplier ?? 1;
|
|
|
|
const companionBonus = getActiveCompanionBonus(
|
|
state.companions?.activeCompanionId,
|
|
state.companions?.unlockedCompanionIds ?? [],
|
|
);
|
|
const companionCombatMult
|
|
= companionBonus?.type === "bossDamage"
|
|
? 1 + companionBonus.value
|
|
: 1;
|
|
|
|
let partyCombatPower = 0;
|
|
for (const adventurer of state.adventurers) {
|
|
if (adventurer.count === 0) {
|
|
continue;
|
|
}
|
|
let adventurerMultiplier = 1;
|
|
for (const upgrade of state.upgrades) {
|
|
if (
|
|
upgrade.purchased
|
|
&& upgrade.target === "adventurer"
|
|
&& upgrade.adventurerId === adventurer.id
|
|
) {
|
|
adventurerMultiplier = adventurerMultiplier * upgrade.multiplier;
|
|
}
|
|
}
|
|
const contribution
|
|
= adventurer.combatPower
|
|
* adventurer.count
|
|
* adventurerMultiplier
|
|
* globalMultiplier
|
|
* prestigeMultiplier;
|
|
partyCombatPower = partyCombatPower + contribution;
|
|
}
|
|
|
|
return partyCombatPower
|
|
* equipmentCombatMultiplier
|
|
* setCombatMultiplier
|
|
* echoCombatMultiplier
|
|
* craftedCombatMultiplier
|
|
* companionCombatMult;
|
|
};
|
|
|
|
/**
|
|
* Pure function — applies one game tick to the state.
|
|
* DeltaSeconds: time elapsed since last tick.
|
|
* Returns a new GameState (does not mutate the original).
|
|
* @param state - The current game state.
|
|
* @param deltaSeconds - Time elapsed since last tick in seconds.
|
|
* @returns A new GameState with the tick applied.
|
|
*/
|
|
export const applyTick = (
|
|
state: GameState,
|
|
deltaSeconds: number,
|
|
): GameState => {
|
|
const equippedItems: Array<Equipment> = state.equipment.filter((item) => {
|
|
return item.equipped;
|
|
});
|
|
const equipmentGoldMultiplier = equippedItems.reduce((mult, item) => {
|
|
return mult * (item.bonus.goldMultiplier ?? 1);
|
|
}, 1);
|
|
const setGoldMultiplier = computeSetBonuses(
|
|
equippedItems.map((item) => {
|
|
return item.id;
|
|
}),
|
|
EQUIPMENT_SETS,
|
|
).goldMultiplier;
|
|
|
|
const runestonesIncome = state.prestige.runestonesIncomeMultiplier ?? 1;
|
|
const runestonesEssence = state.prestige.runestonesEssenceMultiplier ?? 1;
|
|
const runestonesCrystal = state.prestige.runestonesCrystalMultiplier ?? 1;
|
|
const echoIncome = state.transcendence?.echoIncomeMultiplier ?? 1;
|
|
const craftedGoldMultiplier = state.exploration?.craftedGoldMultiplier ?? 1;
|
|
const craftedEssenceMultiplier
|
|
= state.exploration?.craftedEssenceMultiplier ?? 1;
|
|
|
|
const companionBonus = getActiveCompanionBonus(
|
|
state.companions?.activeCompanionId,
|
|
state.companions?.unlockedCompanionIds ?? [],
|
|
);
|
|
const companionGoldMult
|
|
= companionBonus?.type === "passiveGold"
|
|
? 1 + companionBonus.value
|
|
: 1;
|
|
const companionEssenceMult
|
|
= companionBonus?.type === "essenceIncome"
|
|
? 1 + companionBonus.value
|
|
: 1;
|
|
const companionQuestTimeReduction
|
|
= companionBonus?.type === "questTime"
|
|
? companionBonus.value
|
|
: 0;
|
|
|
|
let goldGained = 0;
|
|
let essenceGained = 0;
|
|
|
|
for (const adventurer of state.adventurers) {
|
|
if (!adventurer.unlocked || adventurer.count === 0) {
|
|
continue;
|
|
}
|
|
|
|
const upgradeMultiplier = state.upgrades.
|
|
filter((upgrade) => {
|
|
const isGlobal = upgrade.target === "global";
|
|
const isThisAdventurer
|
|
= upgrade.target === "adventurer"
|
|
&& upgrade.adventurerId === adventurer.id;
|
|
return upgrade.purchased && (isGlobal || isThisAdventurer);
|
|
}).
|
|
reduce((mult, upgrade) => {
|
|
return mult * upgrade.multiplier;
|
|
}, 1);
|
|
|
|
const prestige = state.prestige.productionMultiplier;
|
|
|
|
const goldPerTick
|
|
= adventurer.goldPerSecond
|
|
* adventurer.count
|
|
* upgradeMultiplier
|
|
* prestige
|
|
* runestonesIncome
|
|
* echoIncome
|
|
* equipmentGoldMultiplier
|
|
* setGoldMultiplier
|
|
* craftedGoldMultiplier
|
|
* companionGoldMult
|
|
* deltaSeconds;
|
|
goldGained = goldGained + goldPerTick;
|
|
|
|
const essencePerTick
|
|
= adventurer.essencePerSecond
|
|
* adventurer.count
|
|
* upgradeMultiplier
|
|
* prestige
|
|
* runestonesEssence
|
|
* craftedEssenceMultiplier
|
|
* companionEssenceMult
|
|
* deltaSeconds;
|
|
essenceGained = essenceGained + essencePerTick;
|
|
}
|
|
|
|
// Complete active quests and apply their rewards
|
|
const now = Date.now();
|
|
let questGold = 0;
|
|
let questEssence = 0;
|
|
let questCrystals = 0;
|
|
|
|
let updatedUpgrades = state.upgrades;
|
|
let updatedAdventurers = state.adventurers;
|
|
let updatedEquipmentReference = state.equipment;
|
|
|
|
const updatedQuests = state.quests.map((quest) => {
|
|
const effectiveQuestMs
|
|
= quest.durationSeconds * (1 - companionQuestTimeReduction) * 1000;
|
|
if (
|
|
quest.status !== "active"
|
|
|| quest.startedAt === undefined
|
|
|| now < quest.startedAt + effectiveQuestMs
|
|
) {
|
|
return quest;
|
|
}
|
|
|
|
const failureChance = zoneFailureChance[quest.zoneId] ?? 0.2;
|
|
if (Math.random() < failureChance) {
|
|
const { startedAt: _dropped, ...questWithoutStartedAt } = quest;
|
|
return {
|
|
...questWithoutStartedAt,
|
|
lastFailedAt: now,
|
|
status: "available" as const,
|
|
};
|
|
}
|
|
|
|
for (const reward of quest.rewards) {
|
|
if (reward.type === "gold" && reward.amount !== undefined) {
|
|
questGold = questGold + reward.amount;
|
|
} else if (reward.type === "essence" && reward.amount !== undefined) {
|
|
questEssence = questEssence + reward.amount;
|
|
} else if (reward.type === "crystals" && reward.amount !== undefined) {
|
|
const crystalAmount = reward.amount;
|
|
const crystalGain = crystalAmount * runestonesCrystal;
|
|
questCrystals = questCrystals + crystalGain;
|
|
} else if (reward.type === "upgrade" && reward.targetId !== undefined) {
|
|
updatedUpgrades = updatedUpgrades.map((upgrade) => {
|
|
return upgrade.id === reward.targetId
|
|
? { ...upgrade, unlocked: true }
|
|
: upgrade;
|
|
});
|
|
} else if (
|
|
reward.type === "adventurer"
|
|
&& reward.targetId !== undefined
|
|
) {
|
|
updatedAdventurers = updatedAdventurers.map((adventurer) => {
|
|
return adventurer.id === reward.targetId
|
|
? { ...adventurer, unlocked: true }
|
|
: adventurer;
|
|
});
|
|
} else if (reward.type === "equipment" && reward.targetId !== undefined) {
|
|
const rewardTargetId = reward.targetId;
|
|
const currentEquipment = updatedEquipmentReference;
|
|
updatedEquipmentReference = currentEquipment.map((item) => {
|
|
if (item.id !== rewardTargetId) {
|
|
return item;
|
|
}
|
|
const slotEmpty = !currentEquipment.some((other) => {
|
|
return other.type === item.type && other.equipped;
|
|
});
|
|
return {
|
|
...item,
|
|
equipped: slotEmpty || item.equipped,
|
|
owned: true,
|
|
};
|
|
});
|
|
}
|
|
}
|
|
|
|
return { ...quest, status: "completed" as const };
|
|
});
|
|
|
|
// Unlock quests whose prerequisites are now all completed and whose zone is unlocked
|
|
const completedIds = new Set(
|
|
updatedQuests.
|
|
filter((quest) => {
|
|
return quest.status === "completed";
|
|
}).
|
|
map((quest) => {
|
|
return quest.id;
|
|
}),
|
|
);
|
|
const fullyUpdatedQuests = updatedQuests.map((quest) => {
|
|
if (quest.status !== "locked") {
|
|
return quest;
|
|
}
|
|
const questZone = state.zones.find((searchZone) => {
|
|
return searchZone.id === quest.zoneId;
|
|
});
|
|
if (questZone?.status === "locked") {
|
|
return quest;
|
|
}
|
|
if (
|
|
quest.prerequisiteIds.every((id) => {
|
|
return completedIds.has(id);
|
|
})
|
|
) {
|
|
return { ...quest, status: "available" as const };
|
|
}
|
|
return quest;
|
|
});
|
|
|
|
/*
|
|
* Unlock zones whose both conditions are now satisfied after quest completion:
|
|
* (1) the gate boss has been defeated, (2) the gate quest is now completed
|
|
*/
|
|
const updatedZones = state.zones.map((zone) => {
|
|
if (zone.status === "unlocked") {
|
|
return zone;
|
|
}
|
|
const bossOk
|
|
= zone.unlockBossId === null
|
|
|| state.bosses.some((boss) => {
|
|
return boss.id === zone.unlockBossId && boss.status === "defeated";
|
|
});
|
|
const questOk
|
|
= zone.unlockQuestId === null || completedIds.has(zone.unlockQuestId);
|
|
if (bossOk && questOk) {
|
|
return { ...zone, status: "unlocked" as const };
|
|
}
|
|
return zone;
|
|
});
|
|
|
|
// Activate the first boss in any zone that just became unlocked this tick
|
|
const newlyUnlockedZoneIds = new Set(
|
|
updatedZones.
|
|
filter((zone) => {
|
|
const wasLocked
|
|
= state.zones.find((originalZone) => {
|
|
return originalZone.id === zone.id;
|
|
})?.status === "locked";
|
|
return zone.status === "unlocked" && wasLocked;
|
|
}).
|
|
map((zone) => {
|
|
return zone.id;
|
|
}),
|
|
);
|
|
let updatedBosses = state.bosses;
|
|
if (newlyUnlockedZoneIds.size > 0) {
|
|
updatedBosses = state.bosses.map((boss) => {
|
|
if (newlyUnlockedZoneIds.has(boss.zoneId)) {
|
|
const zoneBosses = state.bosses.filter((zoneBoss) => {
|
|
return zoneBoss.zoneId === boss.zoneId;
|
|
});
|
|
const [ firstBoss ] = zoneBosses;
|
|
if (firstBoss?.id === boss.id && boss.status === "locked") {
|
|
return { ...boss, status: "available" as const };
|
|
}
|
|
}
|
|
return boss;
|
|
});
|
|
}
|
|
|
|
// Count quests newly completed this tick and update daily challenge progress
|
|
const newlyCompletedQuestCount = updatedQuests.filter((quest, index) => {
|
|
const wasNotCompleted = state.quests[index]?.status !== "completed";
|
|
return quest.status === "completed" && wasNotCompleted;
|
|
}).length;
|
|
|
|
let updatedDailyChallenges = state.dailyChallenges;
|
|
let challengeCrystals = 0;
|
|
if (updatedDailyChallenges !== undefined && newlyCompletedQuestCount > 0) {
|
|
const result = updateChallengeProgress(
|
|
updatedDailyChallenges,
|
|
"questsCompleted",
|
|
newlyCompletedQuestCount,
|
|
);
|
|
updatedDailyChallenges = result.updatedChallenges;
|
|
challengeCrystals = result.crystalsAwarded;
|
|
}
|
|
|
|
// Auto-unlock adventurer-specific upgrades when their adventurer is recruited
|
|
updatedUpgrades = updatedUpgrades.map((upgrade) => {
|
|
if (upgrade.unlocked || upgrade.adventurerId === undefined) {
|
|
return upgrade;
|
|
}
|
|
const adventurer = updatedAdventurers.find((a) => {
|
|
return a.id === upgrade.adventurerId;
|
|
});
|
|
return adventurer !== undefined && adventurer.count > 0
|
|
? { ...upgrade, unlocked: true }
|
|
: upgrade;
|
|
});
|
|
|
|
const goldValue = capResource(state.resources.gold + goldGained + questGold);
|
|
const essenceValue = capResource(
|
|
state.resources.essence + essenceGained + questEssence,
|
|
);
|
|
const totalGoldEarnedValue
|
|
= state.player.totalGoldEarned + goldGained + questGold;
|
|
|
|
const partialState: GameState = {
|
|
...state,
|
|
resources: {
|
|
...state.resources,
|
|
crystals: capResource(
|
|
state.resources.crystals + questCrystals + challengeCrystals,
|
|
),
|
|
essence: essenceValue,
|
|
gold: goldValue,
|
|
},
|
|
...updatedDailyChallenges === undefined
|
|
? {}
|
|
: { dailyChallenges: updatedDailyChallenges },
|
|
adventurers: updatedAdventurers,
|
|
bosses: updatedBosses,
|
|
equipment: updatedEquipmentReference,
|
|
lastTickAt: now,
|
|
player: {
|
|
...state.player,
|
|
totalGoldEarned: totalGoldEarnedValue,
|
|
},
|
|
quests: fullyUpdatedQuests,
|
|
upgrades: updatedUpgrades,
|
|
zones: updatedZones,
|
|
};
|
|
|
|
// Check achievements and apply crystal rewards for newly unlocked ones
|
|
const updatedAchievements = checkAchievements(partialState);
|
|
const crystalsFromAchievements = updatedAchievements.reduce(
|
|
(sum, achievement, index) => {
|
|
const wasLocked = state.achievements[index]?.unlockedAt === null;
|
|
const isNowUnlocked = achievement.unlockedAt !== null;
|
|
if (wasLocked && isNowUnlocked) {
|
|
return sum + (achievement.reward?.crystals ?? 0);
|
|
}
|
|
return sum;
|
|
},
|
|
0,
|
|
);
|
|
|
|
return {
|
|
...partialState,
|
|
achievements: updatedAchievements,
|
|
resources: {
|
|
...partialState.resources,
|
|
crystals: capResource(
|
|
partialState.resources.crystals + crystalsFromAchievements,
|
|
),
|
|
},
|
|
};
|
|
};
|
|
|
|
/**
|
|
* Calculates the effective click power, including upgrades and equipped trinkets.
|
|
* @param state - The current game state.
|
|
* @returns The calculated click power value.
|
|
*/
|
|
export const calculateClickPower = (state: GameState): number => {
|
|
const clickMultiplier = state.upgrades.
|
|
filter((upgrade) => {
|
|
return upgrade.purchased && upgrade.target === "click";
|
|
}).
|
|
reduce((mult, upgrade) => {
|
|
return mult * upgrade.multiplier;
|
|
}, 1);
|
|
|
|
const equippedItems = state.equipment.filter((item) => {
|
|
return item.equipped;
|
|
});
|
|
const equipmentClickMultiplier = equippedItems.
|
|
filter((item) => {
|
|
return item.bonus.clickMultiplier !== undefined;
|
|
}).
|
|
reduce((mult, item) => {
|
|
return mult * (item.bonus.clickMultiplier ?? 1);
|
|
}, 1);
|
|
const setClickMultiplier = computeSetBonuses(
|
|
equippedItems.map((item) => {
|
|
return item.id;
|
|
}),
|
|
EQUIPMENT_SETS,
|
|
).clickMultiplier;
|
|
|
|
const runestonesClick = state.prestige.runestonesClickMultiplier ?? 1;
|
|
const echoIncome = state.transcendence?.echoIncomeMultiplier ?? 1;
|
|
const craftedClickMultiplier = state.exploration?.craftedClickMultiplier ?? 1;
|
|
|
|
const companionClickBonus = getActiveCompanionBonus(
|
|
state.companions?.activeCompanionId,
|
|
state.companions?.unlockedCompanionIds ?? [],
|
|
);
|
|
const companionClickMult
|
|
= companionClickBonus?.type === "clickGold"
|
|
? 1 + companionClickBonus.value
|
|
: 1;
|
|
|
|
return (
|
|
state.baseClickPower
|
|
* clickMultiplier
|
|
* state.prestige.productionMultiplier
|
|
* runestonesClick
|
|
* echoIncome
|
|
* equipmentClickMultiplier
|
|
* setClickMultiplier
|
|
* craftedClickMultiplier
|
|
* companionClickMult
|
|
);
|
|
};
|