Complete skill system redesign: Add all upgrade trees, special effects, and comprehensive tests
All checks were successful
Build and Publish Mana Loop Docker Image / build-and-publish (push) Successful in 1m51s
All checks were successful
Build and Publish Mana Loop Docker Image / build-and-publish (push) Successful in 1m51s
- Added upgrade trees for ALL skills with max > 1 - Added 40+ new special effects for upgrades - Created 38 new comprehensive tests for skill system - Updated docs/skills.md with full documentation - All new tests pass, lint clean
This commit is contained in:
Z User
347
src/lib/game/__tests__/skill-system.test.ts
Normal file
347
src/lib/game/__tests__/skill-system.test.ts
Normal file
@@ -0,0 +1,347 @@
|
||||
import { describe, it, expect } from 'vitest';
|
||||
import {
|
||||
SKILL_EVOLUTION_PATHS,
|
||||
getBaseSkillId,
|
||||
generateTierSkillDef,
|
||||
getUpgradesForSkillAtMilestone,
|
||||
getNextTierSkill,
|
||||
getTierMultiplier,
|
||||
canTierUp,
|
||||
getAvailableUpgrades,
|
||||
} from '../skill-evolution';
|
||||
import { SKILLS_DEF } from '../constants';
|
||||
|
||||
describe('Skill Evolution Paths', () => {
|
||||
it('should have evolution paths for all skills with max > 1', () => {
|
||||
const skillsWithMaxGt1 = Object.entries(SKILLS_DEF)
|
||||
.filter(([_, def]) => def.max > 1)
|
||||
.map(([id]) => id);
|
||||
|
||||
for (const skillId of skillsWithMaxGt1) {
|
||||
expect(SKILL_EVOLUTION_PATHS[skillId], `Missing evolution path for ${skillId}`).toBeDefined();
|
||||
}
|
||||
});
|
||||
|
||||
it('should have at least one tier for each evolution path', () => {
|
||||
for (const [skillId, path] of Object.entries(SKILL_EVOLUTION_PATHS)) {
|
||||
expect(path.tiers.length, `${skillId} should have at least one tier`).toBeGreaterThanOrEqual(1);
|
||||
expect(path.baseSkillId, `${skillId} baseSkillId should match`).toBe(skillId);
|
||||
}
|
||||
});
|
||||
|
||||
it('should have correct tier multipliers (10x per tier)', () => {
|
||||
for (const [skillId, path] of Object.entries(SKILL_EVOLUTION_PATHS)) {
|
||||
for (const tier of path.tiers) {
|
||||
const expectedMultiplier = Math.pow(10, tier.tier - 1);
|
||||
expect(tier.multiplier, `${skillId} tier ${tier.tier} multiplier`).toBe(expectedMultiplier);
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
it('should have valid skill IDs for each tier', () => {
|
||||
for (const [skillId, path] of Object.entries(SKILL_EVOLUTION_PATHS)) {
|
||||
for (const tier of path.tiers) {
|
||||
if (tier.tier === 1) {
|
||||
expect(tier.skillId, `${skillId} tier 1 skillId`).toBe(skillId);
|
||||
} else {
|
||||
expect(tier.skillId, `${skillId} tier ${tier.tier} skillId`).toContain('_t');
|
||||
}
|
||||
}
|
||||
}
|
||||
});
|
||||
});
|
||||
|
||||
describe('getBaseSkillId', () => {
|
||||
it('should return the same ID for base skills', () => {
|
||||
expect(getBaseSkillId('manaWell')).toBe('manaWell');
|
||||
expect(getBaseSkillId('manaFlow')).toBe('manaFlow');
|
||||
expect(getBaseSkillId('enchanting')).toBe('enchanting');
|
||||
});
|
||||
|
||||
it('should extract base ID from tiered skills', () => {
|
||||
expect(getBaseSkillId('manaWell_t2')).toBe('manaWell');
|
||||
expect(getBaseSkillId('manaFlow_t3')).toBe('manaFlow');
|
||||
expect(getBaseSkillId('enchanting_t5')).toBe('enchanting');
|
||||
});
|
||||
});
|
||||
|
||||
describe('generateTierSkillDef', () => {
|
||||
it('should return null for non-existent skills', () => {
|
||||
expect(generateTierSkillDef('nonexistent', 1)).toBeNull();
|
||||
});
|
||||
|
||||
it('should return null for non-existent tiers', () => {
|
||||
// Most skills don't have tier 10
|
||||
expect(generateTierSkillDef('manaWell', 10)).toBeNull();
|
||||
});
|
||||
|
||||
it('should return correct tier definition', () => {
|
||||
const tier1 = generateTierSkillDef('manaWell', 1);
|
||||
expect(tier1).not.toBeNull();
|
||||
expect(tier1?.name).toBe('Mana Well');
|
||||
expect(tier1?.tier).toBe(1);
|
||||
expect(tier1?.multiplier).toBe(1);
|
||||
|
||||
const tier2 = generateTierSkillDef('manaWell', 2);
|
||||
expect(tier2).not.toBeNull();
|
||||
expect(tier2?.name).toBe('Deep Reservoir');
|
||||
expect(tier2?.tier).toBe(2);
|
||||
expect(tier2?.multiplier).toBe(10);
|
||||
});
|
||||
});
|
||||
|
||||
describe('getUpgradesForSkillAtMilestone', () => {
|
||||
it('should return empty array for non-existent skills', () => {
|
||||
const upgrades = getUpgradesForSkillAtMilestone('nonexistent', 5, {});
|
||||
expect(upgrades).toEqual([]);
|
||||
});
|
||||
|
||||
it('should return upgrades for manaWell at milestone 5', () => {
|
||||
const upgrades = getUpgradesForSkillAtMilestone('manaWell', 5, { manaWell: 1 });
|
||||
expect(upgrades.length).toBeGreaterThan(0);
|
||||
|
||||
// All should be milestone 5
|
||||
for (const upgrade of upgrades) {
|
||||
expect(upgrade.milestone).toBe(5);
|
||||
}
|
||||
});
|
||||
|
||||
it('should return upgrades for manaWell at milestone 10', () => {
|
||||
const upgrades = getUpgradesForSkillAtMilestone('manaWell', 10, { manaWell: 1 });
|
||||
expect(upgrades.length).toBeGreaterThan(0);
|
||||
|
||||
// All should be milestone 10
|
||||
for (const upgrade of upgrades) {
|
||||
expect(upgrade.milestone).toBe(10);
|
||||
}
|
||||
});
|
||||
|
||||
it('should return tier 2 upgrades when at tier 2', () => {
|
||||
const upgrades = getUpgradesForSkillAtMilestone('manaWell', 5, { manaWell: 2 });
|
||||
expect(upgrades.length).toBeGreaterThan(0);
|
||||
|
||||
// Should have tier 2 specific upgrades
|
||||
const upgradeIds = upgrades.map(u => u.id);
|
||||
expect(upgradeIds.some(id => id.startsWith('mw_t2'))).toBe(true);
|
||||
});
|
||||
});
|
||||
|
||||
describe('getNextTierSkill', () => {
|
||||
it('should return null for non-existent skills', () => {
|
||||
expect(getNextTierSkill('nonexistent')).toBeNull();
|
||||
});
|
||||
|
||||
it('should return next tier for tier 1 skills', () => {
|
||||
expect(getNextTierSkill('manaWell')).toBe('manaWell_t2');
|
||||
expect(getNextTierSkill('manaFlow')).toBe('manaFlow_t2');
|
||||
});
|
||||
|
||||
it('should return next tier for higher tier skills', () => {
|
||||
expect(getNextTierSkill('manaWell_t2')).toBe('manaWell_t3');
|
||||
expect(getNextTierSkill('manaWell_t3')).toBe('manaWell_t4');
|
||||
});
|
||||
|
||||
it('should return null for max tier skills', () => {
|
||||
// manaWell has 5 tiers
|
||||
expect(getNextTierSkill('manaWell_t5')).toBeNull();
|
||||
});
|
||||
});
|
||||
|
||||
describe('getTierMultiplier', () => {
|
||||
it('should return 1 for tier 1 skills', () => {
|
||||
expect(getTierMultiplier('manaWell')).toBe(1);
|
||||
expect(getTierMultiplier('manaFlow')).toBe(1);
|
||||
});
|
||||
|
||||
it('should return 10 for tier 2 skills', () => {
|
||||
expect(getTierMultiplier('manaWell_t2')).toBe(10);
|
||||
expect(getTierMultiplier('manaFlow_t2')).toBe(10);
|
||||
});
|
||||
|
||||
it('should return correct multiplier for higher tiers', () => {
|
||||
expect(getTierMultiplier('manaWell_t3')).toBe(100);
|
||||
expect(getTierMultiplier('manaWell_t4')).toBe(1000);
|
||||
expect(getTierMultiplier('manaWell_t5')).toBe(10000);
|
||||
});
|
||||
});
|
||||
|
||||
describe('canTierUp', () => {
|
||||
const mockAttunements = {
|
||||
enchanter: { level: 10, active: true },
|
||||
fabricator: { level: 10, active: true },
|
||||
invoker: { level: 10, active: true },
|
||||
};
|
||||
|
||||
it('should return false for non-existent skills', () => {
|
||||
const result = canTierUp('nonexistent', 10, {}, mockAttunements);
|
||||
expect(result.canTierUp).toBe(false);
|
||||
expect(result.reason).toBe('No evolution path');
|
||||
});
|
||||
|
||||
it('should return false if not at max level', () => {
|
||||
const result = canTierUp('manaWell', 5, { manaWell: 1 }, mockAttunements);
|
||||
expect(result.canTierUp).toBe(false);
|
||||
expect(result.reason).toBe('Need level 10 to tier up');
|
||||
});
|
||||
|
||||
it('should return true when at max level with attunement', () => {
|
||||
const result = canTierUp('manaWell', 10, { manaWell: 1 }, mockAttunements);
|
||||
expect(result.canTierUp).toBe(true);
|
||||
});
|
||||
|
||||
it('should return false if already at max tier', () => {
|
||||
const result = canTierUp('manaWell_t5', 10, { manaWell: 5 }, mockAttunements);
|
||||
expect(result.canTierUp).toBe(false);
|
||||
expect(result.reason).toBe('Already at max tier');
|
||||
});
|
||||
});
|
||||
|
||||
describe('getAvailableUpgrades', () => {
|
||||
const manaWellTier1Tree = SKILL_EVOLUTION_PATHS.manaWell.tiers[0].upgrades;
|
||||
|
||||
it('should return only upgrades for specified milestone', () => {
|
||||
const available = getAvailableUpgrades(
|
||||
manaWellTier1Tree as any[],
|
||||
[],
|
||||
5,
|
||||
[]
|
||||
);
|
||||
|
||||
for (const upgrade of available) {
|
||||
expect(upgrade.milestone).toBe(5);
|
||||
}
|
||||
});
|
||||
|
||||
it('should exclude already chosen upgrades', () => {
|
||||
const available = getAvailableUpgrades(
|
||||
manaWellTier1Tree as any[],
|
||||
['mw_t1_l5_capacity'],
|
||||
5,
|
||||
['mw_t1_l5_capacity']
|
||||
);
|
||||
|
||||
const ids = available.map(u => u.id);
|
||||
expect(ids).not.toContain('mw_t1_l5_capacity');
|
||||
});
|
||||
});
|
||||
|
||||
describe('Skill Definitions', () => {
|
||||
it('should have valid max levels for all skills', () => {
|
||||
for (const [skillId, def] of Object.entries(SKILLS_DEF)) {
|
||||
expect(def.max, `${skillId} max level`).toBeGreaterThanOrEqual(1);
|
||||
expect(def.max, `${skillId} max level`).toBeLessThanOrEqual(10);
|
||||
}
|
||||
});
|
||||
|
||||
it('should have study time defined for all skills', () => {
|
||||
for (const [skillId, def] of Object.entries(SKILLS_DEF)) {
|
||||
expect(def.studyTime, `${skillId} study time`).toBeGreaterThanOrEqual(0);
|
||||
}
|
||||
});
|
||||
|
||||
it('should have base cost defined for all skills', () => {
|
||||
for (const [skillId, def] of Object.entries(SKILLS_DEF)) {
|
||||
expect(def.base, `${skillId} base cost`).toBeGreaterThan(0);
|
||||
}
|
||||
});
|
||||
|
||||
it('should have correct categories for skills', () => {
|
||||
const validCategories = ['mana', 'study', 'research', 'ascension', 'enchant',
|
||||
'effectResearch', 'invocation', 'pact', 'fabrication', 'golemancy', 'craft'];
|
||||
|
||||
for (const [skillId, def] of Object.entries(SKILLS_DEF)) {
|
||||
expect(validCategories, `${skillId} category`).toContain(def.cat);
|
||||
}
|
||||
});
|
||||
});
|
||||
|
||||
describe('Upgrade Tree Structure', () => {
|
||||
it('should have valid effect types for all upgrades', () => {
|
||||
const validTypes = ['multiplier', 'bonus', 'special'];
|
||||
|
||||
for (const [skillId, path] of Object.entries(SKILL_EVOLUTION_PATHS)) {
|
||||
for (const tier of path.tiers) {
|
||||
for (const upgrade of tier.upgrades) {
|
||||
expect(validTypes, `${upgrade.id} effect type`).toContain(upgrade.effect.type);
|
||||
}
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
it('should have milestone 5 or 10 for all upgrades', () => {
|
||||
for (const [skillId, path] of Object.entries(SKILL_EVOLUTION_PATHS)) {
|
||||
for (const tier of path.tiers) {
|
||||
for (const upgrade of tier.upgrades) {
|
||||
expect([5, 10], `${upgrade.id} milestone`).toContain(upgrade.milestone);
|
||||
}
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
it('should have unique upgrade IDs within each skill', () => {
|
||||
for (const [skillId, path] of Object.entries(SKILL_EVOLUTION_PATHS)) {
|
||||
const allIds: string[] = [];
|
||||
for (const tier of path.tiers) {
|
||||
for (const upgrade of tier.upgrades) {
|
||||
expect(allIds, `${upgrade.id} should be unique in ${skillId}`).not.toContain(upgrade.id);
|
||||
allIds.push(upgrade.id);
|
||||
}
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
it('should have descriptions for all upgrades', () => {
|
||||
for (const [skillId, path] of Object.entries(SKILL_EVOLUTION_PATHS)) {
|
||||
for (const tier of path.tiers) {
|
||||
for (const upgrade of tier.upgrades) {
|
||||
expect(upgrade.desc, `${upgrade.id} should have description`).toBeTruthy();
|
||||
expect(upgrade.desc.length, `${upgrade.id} description length`).toBeGreaterThan(0);
|
||||
}
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
it('should have special descriptions for special effects', () => {
|
||||
for (const [skillId, path] of Object.entries(SKILL_EVOLUTION_PATHS)) {
|
||||
for (const tier of path.tiers) {
|
||||
for (const upgrade of tier.upgrades) {
|
||||
if (upgrade.effect.type === 'special') {
|
||||
expect(upgrade.effect.specialDesc, `${upgrade.id} should have special description`).toBeTruthy();
|
||||
expect(upgrade.effect.specialId, `${upgrade.id} should have special ID`).toBeTruthy();
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
});
|
||||
});
|
||||
|
||||
describe('Skill Level and Tier Calculations', () => {
|
||||
it('should calculate tier 2 level 1 as equivalent to tier 1 level 10', () => {
|
||||
// Base skill gives +100 max mana per level
|
||||
// At tier 1 level 10: 10 * 100 = 1000 max mana
|
||||
// At tier 2 level 1 with 10x multiplier: 1 * 100 * 10 = 1000 max mana
|
||||
const tier1Level10Effect = 10 * 100; // level * base
|
||||
const tier2Level1Effect = 1 * 100 * 10; // level * base * tierMultiplier
|
||||
|
||||
expect(tier2Level1Effect).toBe(tier1Level10Effect);
|
||||
});
|
||||
|
||||
it('should have increasing power with tiers', () => {
|
||||
// Tier 3 level 1 should be stronger than tier 2 level 10
|
||||
const tier2Level10 = 10 * 100 * 10; // level * base * tierMultiplier
|
||||
const tier3Level1 = 1 * 100 * 100; // level * base * tierMultiplier
|
||||
|
||||
expect(tier3Level1).toBe(tier2Level10);
|
||||
});
|
||||
|
||||
it('should have correct max tier for skills', () => {
|
||||
// Skills with max 5 should typically have 2-3 tiers
|
||||
// Skills with max 10 should typically have 3-5 tiers
|
||||
|
||||
const manaWellPath = SKILL_EVOLUTION_PATHS.manaWell;
|
||||
expect(manaWellPath.tiers.length).toBe(5); // manaWell has 5 tiers
|
||||
|
||||
const manaFlowPath = SKILL_EVOLUTION_PATHS.manaFlow;
|
||||
expect(manaFlowPath.tiers.length).toBe(5); // manaFlow has 5 tiers
|
||||
});
|
||||
});
|
||||
588
src/lib/game/__tests__/skills.test.ts
Normal file
588
src/lib/game/__tests__/skills.test.ts
Normal file
@@ -0,0 +1,588 @@
|
||||
/**
|
||||
* Comprehensive Skill Tests
|
||||
*
|
||||
* Tests each skill to verify they work exactly as their descriptions say.
|
||||
* Updated for the new skill system with tiers and upgrade trees.
|
||||
*/
|
||||
|
||||
import { describe, it, expect } from 'vitest';
|
||||
import {
|
||||
computeMaxMana,
|
||||
computeElementMax,
|
||||
computeRegen,
|
||||
computeClickMana,
|
||||
calcInsight,
|
||||
getMeditationBonus,
|
||||
} from '../computed-stats';
|
||||
import {
|
||||
SKILLS_DEF,
|
||||
PRESTIGE_DEF,
|
||||
GUARDIANS,
|
||||
getStudySpeedMultiplier,
|
||||
getStudyCostMultiplier,
|
||||
ELEMENTS,
|
||||
} from '../constants';
|
||||
import {
|
||||
SKILL_EVOLUTION_PATHS,
|
||||
getUpgradesForSkillAtMilestone,
|
||||
getNextTierSkill,
|
||||
getTierMultiplier,
|
||||
generateTierSkillDef,
|
||||
canTierUp,
|
||||
} from '../skill-evolution';
|
||||
import type { GameState } from '../types';
|
||||
|
||||
// ─── Test Helpers ───────────────────────────────────────────────────────────
|
||||
|
||||
function createMockState(overrides: Partial<GameState> = {}): GameState {
|
||||
const elements: Record<string, { current: number; max: number; unlocked: boolean }> = {};
|
||||
const baseElements = ['fire', 'water', 'air', 'earth', 'light', 'dark', 'death', 'transference', 'metal', 'sand', 'crystal', 'stellar', 'void', 'lightning'];
|
||||
baseElements.forEach((k) => {
|
||||
elements[k] = { current: 0, max: 10, unlocked: baseElements.slice(0, 4).includes(k) };
|
||||
});
|
||||
|
||||
return {
|
||||
day: 1,
|
||||
hour: 0,
|
||||
loopCount: 0,
|
||||
gameOver: false,
|
||||
victory: false,
|
||||
paused: false,
|
||||
rawMana: 100,
|
||||
meditateTicks: 0,
|
||||
totalManaGathered: 0,
|
||||
elements,
|
||||
currentFloor: 1,
|
||||
floorHP: 100,
|
||||
floorMaxHP: 100,
|
||||
castProgress: 0,
|
||||
currentRoom: {
|
||||
roomType: 'combat',
|
||||
enemies: [{ id: 'enemy', hp: 100, maxHP: 100, armor: 0, dodgeChance: 0, element: 'fire' }],
|
||||
},
|
||||
maxFloorReached: 1,
|
||||
signedPacts: [],
|
||||
activeSpell: 'manaBolt',
|
||||
currentAction: 'meditate',
|
||||
spells: { manaBolt: { learned: true, level: 1, studyProgress: 0 } },
|
||||
skills: {},
|
||||
skillProgress: {},
|
||||
skillUpgrades: {},
|
||||
skillTiers: {},
|
||||
parallelStudyTarget: null,
|
||||
equippedInstances: { mainHand: null, offHand: null, head: null, body: null, hands: null, accessory1: null, accessory2: null },
|
||||
equipmentInstances: {},
|
||||
enchantmentDesigns: [],
|
||||
designProgress: null,
|
||||
preparationProgress: null,
|
||||
applicationProgress: null,
|
||||
equipmentCraftingProgress: null,
|
||||
unlockedEffects: [],
|
||||
equipmentSpellStates: [],
|
||||
equipment: { mainHand: null, offHand: null, head: null, body: null, hands: null, accessory: null },
|
||||
inventory: [],
|
||||
blueprints: {},
|
||||
lootInventory: { materials: {}, blueprints: [] },
|
||||
schedule: [],
|
||||
autoSchedule: false,
|
||||
studyQueue: [],
|
||||
craftQueue: [],
|
||||
currentStudyTarget: null,
|
||||
achievements: { unlocked: [], progress: {} },
|
||||
totalSpellsCast: 0,
|
||||
totalDamageDealt: 0,
|
||||
totalCraftsCompleted: 0,
|
||||
attunements: {
|
||||
enchanter: { id: 'enchanter', active: true, level: 1, experience: 0 },
|
||||
invoker: { id: 'invoker', active: false, level: 1, experience: 0 },
|
||||
fabricator: { id: 'fabricator', active: false, level: 1, experience: 0 },
|
||||
},
|
||||
golemancy: {
|
||||
enabledGolems: [],
|
||||
summonedGolems: [],
|
||||
lastSummonFloor: 0,
|
||||
},
|
||||
insight: 0,
|
||||
totalInsight: 0,
|
||||
prestigeUpgrades: {},
|
||||
memorySlots: 3,
|
||||
memories: [],
|
||||
incursionStrength: 0,
|
||||
containmentWards: 0,
|
||||
log: [],
|
||||
loopInsight: 0,
|
||||
...overrides,
|
||||
} as GameState;
|
||||
}
|
||||
|
||||
// ─── Mana Skills Tests ─────────────────────────────────────────────────────────
|
||||
|
||||
describe('Mana Skills', () => {
|
||||
describe('Mana Well (+100 max mana)', () => {
|
||||
it('should add 100 max mana per level', () => {
|
||||
const state0 = createMockState({ skills: { manaWell: 0 } });
|
||||
const state1 = createMockState({ skills: { manaWell: 1 } });
|
||||
const state5 = createMockState({ skills: { manaWell: 5 } });
|
||||
const state10 = createMockState({ skills: { manaWell: 10 } });
|
||||
|
||||
expect(computeMaxMana(state0, { maxManaBonus: 0, maxManaMultiplier: 1 })).toBe(100);
|
||||
expect(computeMaxMana(state1, { maxManaBonus: 0, maxManaMultiplier: 1 })).toBe(100 + 100);
|
||||
expect(computeMaxMana(state5, { maxManaBonus: 0, maxManaMultiplier: 1 })).toBe(100 + 500);
|
||||
expect(computeMaxMana(state10, { maxManaBonus: 0, maxManaMultiplier: 1 })).toBe(100 + 1000);
|
||||
});
|
||||
|
||||
it('skill definition should match description', () => {
|
||||
expect(SKILLS_DEF.manaWell.desc).toBe("+100 max mana");
|
||||
expect(SKILLS_DEF.manaWell.max).toBe(10);
|
||||
});
|
||||
|
||||
it('should have upgrade tree', () => {
|
||||
expect(SKILL_EVOLUTION_PATHS.manaWell).toBeDefined();
|
||||
expect(SKILL_EVOLUTION_PATHS.manaWell.tiers.length).toBe(5);
|
||||
});
|
||||
});
|
||||
|
||||
describe('Mana Flow (+1 regen/hr)', () => {
|
||||
it('should add 1 regen per hour per level', () => {
|
||||
const state0 = createMockState({ skills: { manaFlow: 0 } });
|
||||
const state1 = createMockState({ skills: { manaFlow: 1 } });
|
||||
const state5 = createMockState({ skills: { manaFlow: 5 } });
|
||||
|
||||
const effects = { regenBonus: 0, regenMultiplier: 1, permanentRegenBonus: 0 };
|
||||
expect(computeRegen(state0, effects)).toBe(2);
|
||||
expect(computeRegen(state1, effects)).toBe(2 + 1);
|
||||
expect(computeRegen(state5, effects)).toBe(2 + 5);
|
||||
});
|
||||
|
||||
it('skill definition should match description', () => {
|
||||
expect(SKILLS_DEF.manaFlow.desc).toBe("+1 regen/hr");
|
||||
expect(SKILLS_DEF.manaFlow.max).toBe(10);
|
||||
});
|
||||
});
|
||||
|
||||
describe('Mana Spring (+2 mana regen)', () => {
|
||||
it('should add 2 mana regen', () => {
|
||||
const state0 = createMockState({ skills: { manaSpring: 0 } });
|
||||
const state1 = createMockState({ skills: { manaSpring: 1 } });
|
||||
|
||||
const effects = { regenBonus: 0, regenMultiplier: 1, permanentRegenBonus: 0 };
|
||||
expect(computeRegen(state0, effects)).toBe(2);
|
||||
expect(computeRegen(state1, effects)).toBe(2 + 2);
|
||||
});
|
||||
|
||||
it('skill definition should match description', () => {
|
||||
expect(SKILLS_DEF.manaSpring.desc).toBe("+2 mana regen");
|
||||
expect(SKILLS_DEF.manaSpring.max).toBe(1);
|
||||
});
|
||||
});
|
||||
|
||||
describe('Elemental Attunement (+50 elem mana cap)', () => {
|
||||
it('should add 50 element mana capacity per level', () => {
|
||||
const state0 = createMockState({ skills: { elemAttune: 0 } });
|
||||
const state1 = createMockState({ skills: { elemAttune: 1 } });
|
||||
const state5 = createMockState({ skills: { elemAttune: 5 } });
|
||||
|
||||
expect(computeElementMax(state0, { elementCapBonus: 0, elementCapMultiplier: 1 })).toBe(10);
|
||||
expect(computeElementMax(state1, { elementCapBonus: 0, elementCapMultiplier: 1 })).toBe(10 + 50);
|
||||
expect(computeElementMax(state5, { elementCapBonus: 0, elementCapMultiplier: 1 })).toBe(10 + 250);
|
||||
});
|
||||
|
||||
it('skill definition should match description', () => {
|
||||
expect(SKILLS_DEF.elemAttune.desc).toBe("+50 elem mana cap");
|
||||
expect(SKILLS_DEF.elemAttune.max).toBe(10);
|
||||
});
|
||||
});
|
||||
|
||||
describe('Mana Overflow (+25% mana from clicks)', () => {
|
||||
it('skill definition should match description', () => {
|
||||
expect(SKILLS_DEF.manaOverflow.desc).toBe("+25% mana from clicks");
|
||||
expect(SKILLS_DEF.manaOverflow.max).toBe(5);
|
||||
});
|
||||
|
||||
it('should require Mana Well 3', () => {
|
||||
expect(SKILLS_DEF.manaOverflow.req).toEqual({ manaWell: 3 });
|
||||
});
|
||||
});
|
||||
|
||||
describe('Mana Tap (+1 mana/click)', () => {
|
||||
it('should add 1 mana per click', () => {
|
||||
const state0 = createMockState({ skills: { manaTap: 0 } });
|
||||
const state1 = createMockState({ skills: { manaTap: 1 } });
|
||||
|
||||
expect(computeClickMana(state0, { clickManaBonus: 0, clickManaMultiplier: 1 })).toBe(1);
|
||||
expect(computeClickMana(state1, { clickManaBonus: 0, clickManaMultiplier: 1 })).toBe(2);
|
||||
});
|
||||
|
||||
it('skill definition should match description', () => {
|
||||
expect(SKILLS_DEF.manaTap.desc).toBe("+1 mana/click");
|
||||
expect(SKILLS_DEF.manaTap.max).toBe(1);
|
||||
});
|
||||
});
|
||||
|
||||
describe('Mana Surge (+3 mana/click)', () => {
|
||||
it('should add 3 mana per click', () => {
|
||||
const state1 = createMockState({ skills: { manaSurge: 1 } });
|
||||
expect(computeClickMana(state1, { clickManaBonus: 0, clickManaMultiplier: 1 })).toBe(1 + 3);
|
||||
});
|
||||
|
||||
it('should stack with Mana Tap', () => {
|
||||
const state = createMockState({ skills: { manaTap: 1, manaSurge: 1 } });
|
||||
expect(computeClickMana(state, { clickManaBonus: 0, clickManaMultiplier: 1 })).toBe(1 + 1 + 3);
|
||||
});
|
||||
|
||||
it('should require Mana Tap 1', () => {
|
||||
expect(SKILLS_DEF.manaSurge.req).toEqual({ manaTap: 1 });
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
// ─── Study Skills Tests ─────────────────────────────────────────────────────────
|
||||
|
||||
describe('Study Skills', () => {
|
||||
describe('Quick Learner (+10% study speed)', () => {
|
||||
it('should multiply study speed by 10% per level', () => {
|
||||
expect(getStudySpeedMultiplier({})).toBe(1);
|
||||
expect(getStudySpeedMultiplier({ quickLearner: 1 })).toBe(1.1);
|
||||
expect(getStudySpeedMultiplier({ quickLearner: 3 })).toBe(1.3);
|
||||
expect(getStudySpeedMultiplier({ quickLearner: 5 })).toBe(1.5);
|
||||
});
|
||||
|
||||
it('skill definition should match description', () => {
|
||||
expect(SKILLS_DEF.quickLearner.desc).toBe("+10% study speed");
|
||||
expect(SKILLS_DEF.quickLearner.max).toBe(10);
|
||||
});
|
||||
});
|
||||
|
||||
describe('Focused Mind (-5% study mana cost)', () => {
|
||||
it('should reduce study mana cost by 5% per level', () => {
|
||||
expect(getStudyCostMultiplier({})).toBe(1);
|
||||
expect(getStudyCostMultiplier({ focusedMind: 1 })).toBe(0.95);
|
||||
expect(getStudyCostMultiplier({ focusedMind: 3 })).toBe(0.85);
|
||||
expect(getStudyCostMultiplier({ focusedMind: 5 })).toBe(0.75);
|
||||
});
|
||||
|
||||
it('skill definition should match description', () => {
|
||||
expect(SKILLS_DEF.focusedMind.desc).toBe("-5% study mana cost");
|
||||
expect(SKILLS_DEF.focusedMind.max).toBe(10);
|
||||
});
|
||||
});
|
||||
|
||||
describe('Meditation Focus (Up to 2.5x regen after 4hrs)', () => {
|
||||
it('should provide meditation bonus caps', () => {
|
||||
expect(SKILLS_DEF.meditation.desc).toContain("2.5x");
|
||||
expect(SKILLS_DEF.meditation.max).toBe(1);
|
||||
});
|
||||
});
|
||||
|
||||
describe('Knowledge Retention (+20% study progress saved)', () => {
|
||||
it('skill definition should match description', () => {
|
||||
expect(SKILLS_DEF.knowledgeRetention.desc).toBe("+20% study progress saved on cancel");
|
||||
expect(SKILLS_DEF.knowledgeRetention.max).toBe(3);
|
||||
});
|
||||
});
|
||||
|
||||
describe('Deep Trance (Extend to 6hrs for 3x)', () => {
|
||||
it('skill definition should match description', () => {
|
||||
expect(SKILLS_DEF.deepTrance.desc).toContain("6hrs");
|
||||
expect(SKILLS_DEF.deepTrance.max).toBe(1);
|
||||
});
|
||||
|
||||
it('should require Meditation 1', () => {
|
||||
expect(SKILLS_DEF.deepTrance.req).toEqual({ meditation: 1 });
|
||||
});
|
||||
});
|
||||
|
||||
describe('Void Meditation (Extend to 8hrs for 5x)', () => {
|
||||
it('skill definition should match description', () => {
|
||||
expect(SKILLS_DEF.voidMeditation.desc).toContain("8hrs");
|
||||
expect(SKILLS_DEF.voidMeditation.max).toBe(1);
|
||||
});
|
||||
|
||||
it('should require Deep Trance 1', () => {
|
||||
expect(SKILLS_DEF.voidMeditation.req).toEqual({ deepTrance: 1 });
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
// ─── Ascension Skills Tests ─────────────────────────────────────────────────────
|
||||
|
||||
describe('Ascension Skills', () => {
|
||||
describe('Insight Harvest (+10% insight gain)', () => {
|
||||
it('should multiply insight gain by 10% per level', () => {
|
||||
const state0 = createMockState({ maxFloorReached: 10, skills: { insightHarvest: 0 } });
|
||||
const state1 = createMockState({ maxFloorReached: 10, skills: { insightHarvest: 1 } });
|
||||
const state5 = createMockState({ maxFloorReached: 10, skills: { insightHarvest: 5 } });
|
||||
|
||||
const insight0 = calcInsight(state0);
|
||||
const insight1 = calcInsight(state1);
|
||||
const insight5 = calcInsight(state5);
|
||||
|
||||
expect(insight1).toBeGreaterThan(insight0);
|
||||
expect(insight5).toBeGreaterThan(insight1);
|
||||
});
|
||||
|
||||
it('skill definition should match description', () => {
|
||||
expect(SKILLS_DEF.insightHarvest.desc).toBe("+10% insight gain");
|
||||
expect(SKILLS_DEF.insightHarvest.max).toBe(5);
|
||||
});
|
||||
});
|
||||
|
||||
describe('Guardian Bane (+20% dmg vs guardians)', () => {
|
||||
it('skill definition should match description', () => {
|
||||
expect(SKILLS_DEF.guardianBane.desc).toBe("+20% dmg vs guardians");
|
||||
expect(SKILLS_DEF.guardianBane.max).toBe(3);
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
// ─── Enchanter Skills Tests ─────────────────────────────────────────────────────
|
||||
|
||||
describe('Enchanter Skills', () => {
|
||||
describe('Enchanting (Unlock enchantment design)', () => {
|
||||
it('skill definition should exist', () => {
|
||||
expect(SKILLS_DEF.enchanting).toBeDefined();
|
||||
expect(SKILLS_DEF.enchanting.attunement).toBe('enchanter');
|
||||
});
|
||||
});
|
||||
|
||||
describe('Efficient Enchant (-5% enchantment capacity cost)', () => {
|
||||
it('skill definition should exist', () => {
|
||||
expect(SKILLS_DEF.efficientEnchant).toBeDefined();
|
||||
expect(SKILLS_DEF.efficientEnchant.max).toBe(5);
|
||||
});
|
||||
});
|
||||
|
||||
describe('Disenchanting (Recover mana from removed enchantments)', () => {
|
||||
it('skill definition should exist', () => {
|
||||
expect(SKILLS_DEF.disenchanting).toBeDefined();
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
// ─── Golemancy Skills Tests ────────────────────────────────────────────────────
|
||||
|
||||
describe('Golemancy Skills', () => {
|
||||
describe('Golem Mastery (+10% golem damage)', () => {
|
||||
it('skill definition should exist', () => {
|
||||
expect(SKILLS_DEF.golemMastery).toBeDefined();
|
||||
expect(SKILLS_DEF.golemMastery.attunementReq).toBeDefined();
|
||||
});
|
||||
});
|
||||
|
||||
describe('Golem Efficiency (+5% attack speed)', () => {
|
||||
it('skill definition should exist', () => {
|
||||
expect(SKILLS_DEF.golemEfficiency).toBeDefined();
|
||||
});
|
||||
});
|
||||
|
||||
describe('Golem Longevity (+1 floor duration)', () => {
|
||||
it('skill definition should exist', () => {
|
||||
expect(SKILLS_DEF.golemLongevity).toBeDefined();
|
||||
});
|
||||
});
|
||||
|
||||
describe('Golem Siphon (-10% maintenance)', () => {
|
||||
it('skill definition should exist', () => {
|
||||
expect(SKILLS_DEF.golemSiphon).toBeDefined();
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
// ─── Meditation Bonus Tests ─────────────────────────────────────────────────────
|
||||
|
||||
describe('Meditation Bonus', () => {
|
||||
it('should start at 1x with no meditation', () => {
|
||||
expect(getMeditationBonus(0, {})).toBe(1);
|
||||
});
|
||||
|
||||
it('should ramp up over time without skills', () => {
|
||||
const bonus1hr = getMeditationBonus(25, {}); // 1 hour of ticks
|
||||
expect(bonus1hr).toBeGreaterThan(1);
|
||||
|
||||
const bonus4hr = getMeditationBonus(100, {}); // 4 hours
|
||||
expect(bonus4hr).toBeGreaterThan(bonus1hr);
|
||||
});
|
||||
|
||||
it('should cap at 1.5x without meditation skill', () => {
|
||||
const bonus = getMeditationBonus(200, {}); // 8 hours
|
||||
expect(bonus).toBe(1.5);
|
||||
});
|
||||
|
||||
it('should give 2.5x with meditation skill after 4 hours', () => {
|
||||
const bonus = getMeditationBonus(100, { meditation: 1 });
|
||||
expect(bonus).toBe(2.5);
|
||||
});
|
||||
|
||||
it('should give 3.0x with deepTrance skill after 6 hours', () => {
|
||||
const bonus = getMeditationBonus(150, { meditation: 1, deepTrance: 1 });
|
||||
expect(bonus).toBe(3.0);
|
||||
});
|
||||
|
||||
it('should give 5.0x with voidMeditation skill after 8 hours', () => {
|
||||
const bonus = getMeditationBonus(200, { meditation: 1, deepTrance: 1, voidMeditation: 1 });
|
||||
expect(bonus).toBe(5.0);
|
||||
});
|
||||
});
|
||||
|
||||
// ─── Skill Prerequisites Tests ──────────────────────────────────────────────────
|
||||
|
||||
describe('Skill Prerequisites', () => {
|
||||
it('Mana Overflow should require Mana Well 3', () => {
|
||||
expect(SKILLS_DEF.manaOverflow.req).toEqual({ manaWell: 3 });
|
||||
});
|
||||
|
||||
it('Mana Surge should require Mana Tap 1', () => {
|
||||
expect(SKILLS_DEF.manaSurge.req).toEqual({ manaTap: 1 });
|
||||
});
|
||||
|
||||
it('Deep Trance should require Meditation 1', () => {
|
||||
expect(SKILLS_DEF.deepTrance.req).toEqual({ meditation: 1 });
|
||||
});
|
||||
|
||||
it('Void Meditation should require Deep Trance 1', () => {
|
||||
expect(SKILLS_DEF.voidMeditation.req).toEqual({ deepTrance: 1 });
|
||||
});
|
||||
|
||||
it('Efficient Enchant should require Enchanting 3', () => {
|
||||
expect(SKILLS_DEF.efficientEnchant.req).toEqual({ enchanting: 3 });
|
||||
});
|
||||
});
|
||||
|
||||
// ─── Study Time Tests ───────────────────────────────────────────────────────────
|
||||
|
||||
describe('Study Times', () => {
|
||||
it('all skills should have reasonable study times', () => {
|
||||
Object.entries(SKILLS_DEF).forEach(([id, skill]) => {
|
||||
expect(skill.studyTime).toBeGreaterThan(0);
|
||||
expect(skill.studyTime).toBeLessThanOrEqual(72);
|
||||
});
|
||||
});
|
||||
|
||||
it('ascension skills should have long study times', () => {
|
||||
const ascensionSkills = Object.entries(SKILLS_DEF).filter(([, s]) => s.cat === 'ascension');
|
||||
ascensionSkills.forEach(([, skill]) => {
|
||||
expect(skill.studyTime).toBeGreaterThanOrEqual(20);
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
// ─── Prestige Upgrade Tests ─────────────────────────────────────────────────────
|
||||
|
||||
describe('Prestige Upgrades', () => {
|
||||
it('all prestige upgrades should have valid costs', () => {
|
||||
Object.entries(PRESTIGE_DEF).forEach(([id, upgrade]) => {
|
||||
expect(upgrade.cost).toBeGreaterThan(0);
|
||||
expect(upgrade.max).toBeGreaterThan(0);
|
||||
});
|
||||
});
|
||||
|
||||
it('Mana Well prestige should add 500 starting max mana', () => {
|
||||
const state0 = createMockState({ prestigeUpgrades: { manaWell: 0 } });
|
||||
const state1 = createMockState({ prestigeUpgrades: { manaWell: 1 } });
|
||||
const state5 = createMockState({ prestigeUpgrades: { manaWell: 5 } });
|
||||
|
||||
expect(computeMaxMana(state0, { maxManaBonus: 0, maxManaMultiplier: 1 })).toBe(100);
|
||||
expect(computeMaxMana(state1, { maxManaBonus: 0, maxManaMultiplier: 1 })).toBe(100 + 500);
|
||||
expect(computeMaxMana(state5, { maxManaBonus: 0, maxManaMultiplier: 1 })).toBe(100 + 2500);
|
||||
});
|
||||
|
||||
it('Elemental Attunement prestige should add 25 element cap', () => {
|
||||
const state0 = createMockState({ prestigeUpgrades: { elementalAttune: 0 } });
|
||||
const state1 = createMockState({ prestigeUpgrades: { elementalAttune: 1 } });
|
||||
const state10 = createMockState({ prestigeUpgrades: { elementalAttune: 10 } });
|
||||
|
||||
expect(computeElementMax(state0, { elementCapBonus: 0, elementCapMultiplier: 1 })).toBe(10);
|
||||
expect(computeElementMax(state1, { elementCapBonus: 0, elementCapMultiplier: 1 })).toBe(10 + 25);
|
||||
expect(computeElementMax(state10, { elementCapBonus: 0, elementCapMultiplier: 1 })).toBe(10 + 250);
|
||||
});
|
||||
});
|
||||
|
||||
// ─── Integration Tests ──────────────────────────────────────────────────────────
|
||||
|
||||
describe('Integration Tests', () => {
|
||||
it('skill costs should scale with level', () => {
|
||||
const skill = SKILLS_DEF.manaWell;
|
||||
for (let level = 0; level < skill.max; level++) {
|
||||
const cost = skill.base * (level + 1);
|
||||
expect(cost).toBeGreaterThan(0);
|
||||
}
|
||||
});
|
||||
|
||||
it('all skills should have valid categories', () => {
|
||||
const validCategories = ['mana', 'study', 'ascension', 'enchant', 'effectResearch', 'invocation', 'pact', 'fabrication', 'golemancy', 'research', 'craft'];
|
||||
Object.values(SKILLS_DEF).forEach(skill => {
|
||||
expect(validCategories).toContain(skill.cat);
|
||||
});
|
||||
});
|
||||
|
||||
it('all prerequisite skills should exist', () => {
|
||||
Object.entries(SKILLS_DEF).forEach(([id, skill]) => {
|
||||
if (skill.req) {
|
||||
Object.keys(skill.req).forEach(reqId => {
|
||||
expect(SKILLS_DEF[reqId]).toBeDefined();
|
||||
});
|
||||
}
|
||||
});
|
||||
});
|
||||
|
||||
it('all prerequisite levels should be within skill max', () => {
|
||||
Object.entries(SKILLS_DEF).forEach(([id, skill]) => {
|
||||
if (skill.req) {
|
||||
Object.entries(skill.req).forEach(([reqId, reqLevel]) => {
|
||||
expect(reqLevel).toBeLessThanOrEqual(SKILLS_DEF[reqId].max);
|
||||
});
|
||||
}
|
||||
});
|
||||
});
|
||||
|
||||
it('all attunement-requiring skills should have valid attunement', () => {
|
||||
const validAttunements = ['enchanter', 'invoker', 'fabricator'];
|
||||
Object.entries(SKILLS_DEF).forEach(([id, skill]) => {
|
||||
if (skill.attunement) {
|
||||
expect(validAttunements).toContain(skill.attunement);
|
||||
}
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
// ─── Skill Evolution Tests ──────────────────────────────────────────────────────
|
||||
|
||||
describe('Skill Evolution', () => {
|
||||
it('skills with max > 1 should have evolution paths', () => {
|
||||
const skillsWithMaxGt1 = Object.entries(SKILLS_DEF)
|
||||
.filter(([_, def]) => def.max > 1)
|
||||
.map(([id]) => id);
|
||||
|
||||
for (const skillId of skillsWithMaxGt1) {
|
||||
expect(SKILL_EVOLUTION_PATHS[skillId], `Missing evolution path for ${skillId}`).toBeDefined();
|
||||
}
|
||||
});
|
||||
|
||||
it('tier multiplier should be 10^(tier-1)', () => {
|
||||
expect(getTierMultiplier('manaWell')).toBe(1);
|
||||
expect(getTierMultiplier('manaWell_t2')).toBe(10);
|
||||
expect(getTierMultiplier('manaWell_t3')).toBe(100);
|
||||
expect(getTierMultiplier('manaWell_t4')).toBe(1000);
|
||||
expect(getTierMultiplier('manaWell_t5')).toBe(10000);
|
||||
});
|
||||
|
||||
it('getNextTierSkill should return correct next tier', () => {
|
||||
expect(getNextTierSkill('manaWell')).toBe('manaWell_t2');
|
||||
expect(getNextTierSkill('manaWell_t2')).toBe('manaWell_t3');
|
||||
expect(getNextTierSkill('manaWell_t5')).toBeNull();
|
||||
});
|
||||
|
||||
it('generateTierSkillDef should return valid definitions', () => {
|
||||
const tier1 = generateTierSkillDef('manaWell', 1);
|
||||
expect(tier1).not.toBeNull();
|
||||
expect(tier1?.name).toBe('Mana Well');
|
||||
expect(tier1?.multiplier).toBe(1);
|
||||
|
||||
const tier2 = generateTierSkillDef('manaWell', 2);
|
||||
expect(tier2).not.toBeNull();
|
||||
expect(tier2?.name).toBe('Deep Reservoir');
|
||||
expect(tier2?.multiplier).toBe(10);
|
||||
});
|
||||
});
|
||||
|
||||
console.log('✅ All skill tests defined.');
|
||||
Reference in New Issue
Block a user