Anexim/Mana-Loop
1
1
Fork 0
Code Issues 8 Pull Requests Actions Packages Projects Releases Wiki Activity

feat: restructure guardian progression system with dynamic element support
Build and Publish Mana Loop Docker Image / build-and-publish (push) Successful in 1m20s
Details

Browse Source
This commit is contained in:
n8n-gitea
2026-05-29 17:18:13 +02:00
parent 644b76f16d
commit 71c68443c4
19 changed files with 757 additions and 446 deletions
Download Patch File Download Diff File Expand all files Collapse all files
docs/circular-deps.txt
+1 -1
View File
@@ -1,4 +1,4 @@
# Circular Dependencies # Circular Dependencies
Generated: 2026-05-29T13:23:45.664Z Generated: 2026-05-29T13:42:14.414Z
No circular dependencies found. ✅ No circular dependencies found. ✅
docs/dependency-graph.json
+1 -1
View File
@@ -1,6 +1,6 @@
{ {
"_meta": { "_meta": {
"generated": "2026-05-29T13:23:43.981Z", "generated": "2026-05-29T13:42:12.691Z",
"description": "Import dependency graph for src/lib/game. Keys are files, values are arrays of files they import.", "description": "Import dependency graph for src/lib/game. Keys are files, values are arrays of files they import.",
"usage": "To find what a file affects, search for its path in the VALUES. To find what a file depends on, look at its KEY entry." "usage": "To find what a file affects, search for its path in the VALUES. To find what a file depends on, look at its KEY entry."
}, },
docs/project-structure.txt
+1
View File
@@ -371,6 +371,7 @@ Mana-Loop/
│ │ │ │ ├── enemy-utils.ts │ │ │ │ ├── enemy-utils.ts
│ │ │ │ ├── floor-utils.ts │ │ │ │ ├── floor-utils.ts
│ │ │ │ ├── formatting.ts │ │ │ │ ├── formatting.ts
│ │ │ │ ├── guardian-utils.ts
│ │ │ │ ├── index.ts │ │ │ │ ├── index.ts
│ │ │ │ ├── mana-utils.ts │ │ │ │ ├── mana-utils.ts
│ │ │ │ ├── pact-utils.ts │ │ │ │ ├── pact-utils.ts
src/components/game/debug/PactDebug.tsx
+2 -2
View File
@@ -34,7 +34,7 @@ function GuardianPactRow({ floor, isSigned, onForceSign, onRemove }: {
Floor {floor} | {guardian.pact}x multiplier Floor {floor} | {guardian.pact}x multiplier
</div> </div>
<div className="text-xs text-gray-500"> <div className="text-xs text-gray-500">
Element: {ELEMENTS[guardian.element]?.name || guardian.element} Element: {guardian.element.map(el => ELEMENTS[el]?.name || el).join(' + ')}
</div> </div>
</div> </div>
<div className="flex gap-1"> <div className="flex gap-1">
@@ -112,7 +112,7 @@ export function PactDebug() {
...signedPactDetails, ...signedPactDetails,
[floor]: { [floor]: {
floor, floor,
guardianId: guardian.element, guardianId: guardian.element.join('+'),
signedAt: { day: useGameStore.getState().day, hour: useGameStore.getState().hour }, signedAt: { day: useGameStore.getState().day, hour: useGameStore.getState().hour },
skillLevels: {} as Record<string, number>, skillLevels: {} as Record<string, number>,
}, },
src/components/game/tabs/DebugTab/PactDebugSection.tsx
+2 -2
View File
@@ -34,7 +34,7 @@ function GuardianPactRow({ floor, isSigned, onForceSign, onRemove }: {
Floor {floor} | {guardian.pact}x multiplier Floor {floor} | {guardian.pact}x multiplier
</div> </div>
<div className="text-xs text-gray-500"> <div className="text-xs text-gray-500">
Element: {ELEMENTS[guardian.element]?.name || guardian.element} Element: {guardian.element.map(el => ELEMENTS[el]?.name || el).join(' + ')}
</div> </div>
</div> </div>
<div className="flex gap-1"> <div className="flex gap-1">
@@ -88,7 +88,7 @@ export function PactDebugSection() {
...signedPactDetails, ...signedPactDetails,
[floor]: { [floor]: {
floor, floor,
guardianId: guardian.element, guardianId: guardian.element.join('+'),
signedAt: { day: useGameStore.getState().day, hour: useGameStore.getState().hour }, signedAt: { day: useGameStore.getState().day, hour: useGameStore.getState().hour },
skillLevels: {} as Record<string, number>, skillLevels: {} as Record<string, number>,
}, },
src/components/game/tabs/SpireSummaryTab.test.ts
+30 -41
View File
@@ -1,7 +1,5 @@
import { describe, it, expect } from 'vitest'; import { describe, it, expect } from 'vitest';
// ─── Test: SpireSummaryTab barrel export ───────────────────────────────────────
describe('SpireSummaryTab module structure', () => { describe('SpireSummaryTab module structure', () => {
it('exports SpireSummaryTab from its module', async () => { it('exports SpireSummaryTab from its module', async () => {
const mod = await import('./SpireSummaryTab'); const mod = await import('./SpireSummaryTab');
@@ -15,8 +13,6 @@ describe('SpireSummaryTab module structure', () => {
}); });
}); });
// ─── Test: Barrel export includes SpireSummaryTab ──────────────────────────────
describe('Tab barrel export', () => { describe('Tab barrel export', () => {
it('includes SpireSummaryTab in the tabs index', async () => { it('includes SpireSummaryTab in the tabs index', async () => {
const mod = await import('@/components/game/tabs'); const mod = await import('@/components/game/tabs');
@@ -25,48 +21,49 @@ describe('Tab barrel export', () => {
}); });
}); });
// ─── Test: Guardian data ───────────────────────────────────────────────────────
describe('Guardian data', () => { describe('Guardian data', () => {
it('has 14 static guardians plus combo guardians', async () => { it('has static guardians plus procedural guardians', async () => {
const { getAllGuardianFloors } = await import('@/lib/game/data/guardian-encounters'); const { getAllGuardianFloors } = await import('@/lib/game/data/guardian-encounters');
const floors = getAllGuardianFloors(); const floors = getAllGuardianFloors();
// 14 static (10-140) + 10 combo (150-240) = 24 total // Static: 10-80 (8), 90-110 (3), 130-160 (4), 170-200 (4) = 19 static
expect(floors.length).toBe(24); // Procedural: 210-450 every 10 = 25 procedural
expect(floors.length).toBeGreaterThanOrEqual(19);
}); });
it('guardians are at expected floors for all tiers', async () => { it('guardians are at expected floors for all tiers', async () => {
const { getGuardianForFloor } = await import('@/lib/game/data/guardian-encounters'); const { getGuardianForFloor } = await import('@/lib/game/data/guardian-encounters');
// Base: 10-70, Utility: 80, Compound: 90-110, Exotic: 120-140 // Base: 10-80, Composite: 90-110, Comp+Components: 130-160, Exotic: 170-200
for (const floor of [10, 20, 30, 40, 50, 60, 70, 80, 90, 100, 110, 120, 130, 140]) { for (const floor of [10, 20, 30, 40, 50, 60, 70, 80, 90, 100, 110, 130, 140, 150, 160, 170, 180, 190, 200]) {
expect(getGuardianForFloor(floor)).not.toBeNull(); expect(getGuardianForFloor(floor)).not.toBeNull();
} }
}); });
it('follows elemental → compound → exotic progression', async () => { it('follows element progression: base → composite → exotic', async () => {
const { getGuardianForFloor } = await import('@/lib/game/data/guardian-encounters'); const { getGuardianForFloor } = await import('@/lib/game/data/guardian-encounters');
expect(getGuardianForFloor(10)!.element).toBe('fire'); // Elements are now arrays
expect(getGuardianForFloor(20)!.element).toBe('water'); expect(getGuardianForFloor(10)!.element).toEqual(['fire']);
expect(getGuardianForFloor(30)!.element).toBe('air'); expect(getGuardianForFloor(20)!.element).toEqual(['water']);
expect(getGuardianForFloor(40)!.element).toBe('earth'); expect(getGuardianForFloor(30)!.element).toEqual(['air']);
expect(getGuardianForFloor(50)!.element).toBe('light'); expect(getGuardianForFloor(40)!.element).toEqual(['earth']);
expect(getGuardianForFloor(60)!.element).toBe('dark'); expect(getGuardianForFloor(50)!.element).toEqual(['light']);
expect(getGuardianForFloor(70)!.element).toBe('death'); expect(getGuardianForFloor(60)!.element).toEqual(['dark']);
expect(getGuardianForFloor(80)!.element).toBe('transference'); expect(getGuardianForFloor(70)!.element).toEqual(['death']);
expect(getGuardianForFloor(90)!.element).toBe('metal'); expect(getGuardianForFloor(80)!.element).toEqual(['transference']);
expect(getGuardianForFloor(100)!.element).toBe('sand'); expect(getGuardianForFloor(90)!.element).toEqual(['metal']);
expect(getGuardianForFloor(110)!.element).toBe('lightning'); expect(getGuardianForFloor(100)!.element).toEqual(['sand']);
expect(getGuardianForFloor(120)!.element).toBe('crystal'); expect(getGuardianForFloor(110)!.element).toEqual(['lightning']);
expect(getGuardianForFloor(130)!.element).toBe('stellar'); expect(getGuardianForFloor(170)!.element).toEqual(['crystal']);
expect(getGuardianForFloor(140)!.element).toBe('void'); expect(getGuardianForFloor(180)!.element).toEqual(['stellar']);
expect(getGuardianForFloor(190)!.element).toEqual(['void']);
}); });
it('all static guardians have required fields', async () => { it('all static guardians have required fields', async () => {
const { getGuardianForFloor } = await import('@/lib/game/data/guardian-encounters'); const { getGuardianForFloor } = await import('@/lib/game/data/guardian-encounters');
for (const floor of [10, 20, 30, 40, 50, 60, 70, 80, 90, 100, 110, 120, 130, 140]) { for (const floor of [10, 20, 30, 40, 50, 60, 70, 80, 90, 100, 110, 130, 140, 150, 160, 170, 180, 190, 200]) {
const def = getGuardianForFloor(floor)!; const def = getGuardianForFloor(floor)!;
expect(def.name).toBeTruthy(); expect(def.name).toBeTruthy();
expect(def.element).toBeTruthy(); expect(def.element).toBeTruthy();
expect(Array.isArray(def.element)).toBe(true);
expect(def.hp).toBeGreaterThan(0); expect(def.hp).toBeGreaterThan(0);
expect(def.color).toBeTruthy(); expect(def.color).toBeTruthy();
expect(def.boons).toBeInstanceOf(Array); expect(def.boons).toBeInstanceOf(Array);
@@ -74,18 +71,16 @@ describe('Guardian data', () => {
} }
}); });
it('all static guardians have unique elements', async () => { it('all static guardians have unique element sets', async () => {
const { getGuardianForFloor } = await import('@/lib/game/data/guardian-encounters'); const { getGuardianForFloor } = await import('@/lib/game/data/guardian-encounters');
const floors = [10, 20, 30, 40, 50, 60, 70, 80, 90, 100, 110, 120, 130, 140]; const floors = [10, 20, 30, 40, 50, 60, 70, 80, 90, 100, 110, 130, 140, 150, 160, 170, 180, 190, 200];
const elements = floors.map((f) => getGuardianForFloor(f)!.element); const elementKeys = floors.map((f) => getGuardianForFloor(f)!.element.join(','));
const uniqueElements = new Set(elements); const uniqueElements = new Set(elementKeys);
expect(uniqueElements.size).toBe(elements.length); expect(uniqueElements.size).toBe(elementKeys.length);
}); });
}); });
// ─── Test: Combat store spire fields ─────────────────────────────────────────── describe('Combat store spire fields', () => {
describe('Combat store spire state', () => {
it('useCombatStore is importable', async () => { it('useCombatStore is importable', async () => {
const mod = await import('@/lib/game/stores'); const mod = await import('@/lib/game/stores');
expect(mod.useCombatStore).toBeDefined(); expect(mod.useCombatStore).toBeDefined();
@@ -93,8 +88,6 @@ describe('Combat store spire state', () => {
}); });
}); });
// ─── Test: Floor element cycle ─────────────────────────────────────────────────
describe('Floor element cycle', () => { describe('Floor element cycle', () => {
it('FLOOR_ELEM_CYCLE has 7 elements', async () => { it('FLOOR_ELEM_CYCLE has 7 elements', async () => {
const { FLOOR_ELEM_CYCLE } = await import('@/lib/game/constants'); const { FLOOR_ELEM_CYCLE } = await import('@/lib/game/constants');
@@ -103,20 +96,16 @@ describe('Floor element cycle', () => {
it('element opposites define expected pairs', async () => { it('element opposites define expected pairs', async () => {
const { ELEMENT_OPPOSITES } = await import('@/lib/game/constants'); const { ELEMENT_OPPOSITES } = await import('@/lib/game/constants');
// Core pairs are symmetric
expect(ELEMENT_OPPOSITES['fire']).toBe('water'); expect(ELEMENT_OPPOSITES['fire']).toBe('water');
expect(ELEMENT_OPPOSITES['water']).toBe('fire'); expect(ELEMENT_OPPOSITES['water']).toBe('fire');
expect(ELEMENT_OPPOSITES['air']).toBe('earth'); expect(ELEMENT_OPPOSITES['air']).toBe('earth');
expect(ELEMENT_OPPOSITES['earth']).toBe('air'); expect(ELEMENT_OPPOSITES['earth']).toBe('air');
expect(ELEMENT_OPPOSITES['light']).toBe('dark'); expect(ELEMENT_OPPOSITES['light']).toBe('dark');
expect(ELEMENT_OPPOSITES['dark']).toBe('light'); expect(ELEMENT_OPPOSITES['dark']).toBe('light');
// Lightning has an asymmetric opposite (grounding)
expect(ELEMENT_OPPOSITES['lightning']).toBe('earth'); expect(ELEMENT_OPPOSITES['lightning']).toBe('earth');
}); });
}); });
// ─── Test: File size limit ─────────────────────────────────────────────────────
describe('File size limits (400 lines max)', () => { describe('File size limits (400 lines max)', () => {
it('SpireSummaryTab.tsx is under 400 lines', async () => { it('SpireSummaryTab.tsx is under 400 lines', async () => {
const fs = await import('fs'); const fs = await import('fs');
src/components/game/tabs/SpireSummaryTab.tsx
+5 -5
View File
@@ -77,7 +77,7 @@ function FloorProgressBar({ maxFloor, clearedFloors }: { maxFloor: number; clear
}`} }`}
title={ title={
getGuardianForFloor(floor) getGuardianForFloor(floor)
? `Floor ${floor} — ${getGuardianForFloor(floor)!.name} (${getGuardianForFloor(floor)!.element})` ? `Floor ${floor} — ${getGuardianForFloor(floor)!.name} (${getGuardianForFloor(floor)!.element.join(' + ')})`
: `Floor ${floor}${isCleared ? ' (cleared)' : ''}` : `Floor ${floor}${isCleared ? ' (cleared)' : ''}`
} }
> >
@@ -149,7 +149,7 @@ function StatCell({ value, label, color }: { value: number | string; label: stri
// ─── Next Guardian Card ────────────────────────────────────────────────────── // ─── Next Guardian Card ──────────────────────────────────────────────────────
function NextGuardianCard({ nextGuardian, nextGuardianData }: { nextGuardian: number; nextGuardianData: GuardianDef }) { function NextGuardianCard({ nextGuardian, nextGuardianData }: { nextGuardian: number; nextGuardianData: GuardianDef }) {
const counterElement = getCounterElement(nextGuardianData.element); const counterElement = getCounterElement(nextGuardianData.element[0]);
const nextFloorElement = FLOOR_ELEM_CYCLE[(nextGuardian - 1) % FLOOR_ELEM_CYCLE.length]; const nextFloorElement = FLOOR_ELEM_CYCLE[(nextGuardian - 1) % FLOOR_ELEM_CYCLE.length];
return ( return (
@@ -176,9 +176,9 @@ function NextGuardianCard({ nextGuardian, nextGuardianData }: { nextGuardian: nu
<Badge <Badge
variant="outline" variant="outline"
className="text-xs" className="text-xs"
style={{ borderColor: getElementColor(nextGuardianData.element), color: getElementColor(nextGuardianData.element) }} style={{ borderColor: getElementColor(nextGuardianData.element[0]), color: getElementColor(nextGuardianData.element[0]) }}
> >
{nextGuardianData.element} {nextGuardianData.element.join(' + ')}
</Badge> </Badge>
<span className="text-xs text-gray-500">HP: {fmt(nextGuardianData.hp)}</span> <span className="text-xs text-gray-500">HP: {fmt(nextGuardianData.hp)}</span>
{nextGuardianData.armor && ( {nextGuardianData.armor && (
@@ -287,7 +287,7 @@ function GuardianRosterItem({ floor, guardian, isDefeated }: { floor: number; gu
color: guardian.color, color: guardian.color,
}} }}
> >
{guardian.element} {guardian.element.join(' + ')}
</span> </span>
<span className="text-[10px] text-gray-500">HP: {fmt(guardian.hp)}</span> <span className="text-[10px] text-gray-500">HP: {fmt(guardian.hp)}</span>
</div> </div>
src/components/game/tabs/guardian-pacts-components.tsx
+3 -4
View File
@@ -26,9 +26,8 @@ interface ElementDisplay {
color: string; color: string;
} }
function getElementDisplays(element: string): ElementDisplay[] { function getElementDisplays(element: string | string[]): ElementDisplay[] {
// Combo guardians have elements like "fire+water" const parts = Array.isArray(element) ? element : element.split('+');
const parts = element.split('+');
return parts.map((el) => { return parts.map((el) => {
const def = ELEMENTS[el]; const def = ELEMENTS[el];
return { return {
@@ -79,7 +78,7 @@ export const GuardianCard: React.FC<GuardianCardProps> = React.memo(({
// Build element label: single element name, or "Fire + Water" for combos // Build element label: single element name, or "Fire + Water" for combos
const elementLabel = isCombo const elementLabel = isCombo
? elemDisplays.map(e => e.name).join(' + ') ? elemDisplays.map(e => e.name).join(' + ')
: elemDisplays[0]?.name ?? guardian.element; : elemDisplays[0]?.name ?? guardian.element.join(' + ');
return ( return (
<DebugName name="GuardianPactsComponents"> <DebugName name="GuardianPactsComponents">
src/lib/game/__tests__/guardian-names.test.ts
+46 -54
View File
@@ -5,68 +5,53 @@
import { describe, it, expect } from 'vitest'; import { describe, it, expect } from 'vitest';
import { import {
generateGuardianName, generateGuardianName,
generateComboGuardianName,
getGuardianForFloor, getGuardianForFloor,
getExtendedGuardian, getAllGuardianFloors,
} from '../data/guardian-encounters'; } from '../data/guardian-encounters';
describe('generateGuardianName', () => { describe('generateGuardianName', () => {
it('should return the same name for the same element and floor', () => { it('should return the same name for the same elements and floor', () => {
const name1 = generateGuardianName('fire', 90); const name1 = generateGuardianName(['fire'], 90);
const name2 = generateGuardianName('fire', 90); const name2 = generateGuardianName(['fire'], 90);
expect(name1).toBe(name2); expect(name1).toBe(name2);
}); });
it('should return different names for different elements', () => { it('should return different names for different elements', () => {
const nameFire = generateGuardianName('fire', 90); const nameFire = generateGuardianName(['fire'], 90);
const nameWater = generateGuardianName('water', 90); const nameWater = generateGuardianName(['water'], 90);
expect(nameFire).not.toBe(nameWater); expect(nameFire).not.toBe(nameWater);
}); });
it('should return different names for different floors', () => { it('should return different names for different floors', () => {
const name90 = generateGuardianName('fire', 90); const name90 = generateGuardianName(['fire'], 90);
const name100 = generateGuardianName('fire', 100); const name100 = generateGuardianName(['fire'], 100);
expect(name90).not.toBe(name100); expect(name90).not.toBe(name100);
}); });
it('should produce non-empty names', () => { it('should produce non-empty names', () => {
const name = generateGuardianName('metal', 90); const name = generateGuardianName(['metal'], 90);
expect(name).toBeTruthy(); expect(name).toBeTruthy();
expect(name.length).toBeGreaterThan(0); expect(name.length).toBeGreaterThan(0);
}); });
it('should follow the "Prefix the Title" pattern', () => { it('should follow the "Prefix the Title" pattern for single element', () => {
const name = generateGuardianName('crystal', 120); const name = generateGuardianName(['crystal'], 120);
expect(name).toMatch(/^[\w]+ the [\w]+$/); expect(name).toMatch(/^[\w]+ the [\w]+$/);
}); });
it('should combine prefixes with hyphen for multi-element', () => {
const name = generateGuardianName(['fire', 'water'], 150);
expect(name).toMatch(/^[\w]+-[\w]+ the [\w]+$/);
});
it('should produce "Unknown the <title>" for unknown element', () => { it('should produce "Unknown the <title>" for unknown element', () => {
const name = generateGuardianName('nonexistent', 90); const name = generateGuardianName(['nonexistent'], 90);
expect(name).toMatch(/^Unknown the [\w]+$/); expect(name).toMatch(/^Unknown the [\w]+$/);
}); });
}); });
describe('generateComboGuardianName', () => {
it('should return the same name for the same elements and floor', () => {
const name1 = generateComboGuardianName(['fire', 'water'], 150);
const name2 = generateComboGuardianName(['fire', 'water'], 150);
expect(name1).toBe(name2);
});
it('should return different names for different floors', () => {
const name150 = generateComboGuardianName(['fire', 'water'], 150);
const name160 = generateComboGuardianName(['fire', 'water'], 160);
expect(name150).not.toBe(name160);
});
it('should combine both element prefixes with hyphen', () => {
const name = generateComboGuardianName(['fire', 'water'], 150);
expect(name).toMatch(/^[\w]+-[\w]+ the [\w]+$/);
});
});
describe('getGuardianForFloor', () => { describe('getGuardianForFloor', () => {
it('should return stable names for compound guardians (floors 90-110)', () => { it('should return stable names for composite guardians (floors 90-110)', () => {
const g90a = getGuardianForFloor(90); const g90a = getGuardianForFloor(90);
const g90b = getGuardianForFloor(90); const g90b = getGuardianForFloor(90);
expect(g90a).not.toBeNull(); expect(g90a).not.toBeNull();
@@ -82,8 +67,8 @@ describe('getGuardianForFloor', () => {
expect(g110a!.name).toBe(g110b!.name); expect(g110a!.name).toBe(g110b!.name);
}); });
it('should return stable names for exotic guardians (floors 120-140)', () => { it('should return stable names for exotic guardians (floors 170-200)', () => {
for (const floor of [120, 130, 140]) { for (const floor of [170, 180, 190, 200]) {
const a = getGuardianForFloor(floor); const a = getGuardianForFloor(floor);
const b = getGuardianForFloor(floor); const b = getGuardianForFloor(floor);
expect(a).not.toBeNull(); expect(a).not.toBeNull();
@@ -98,31 +83,39 @@ describe('getGuardianForFloor', () => {
it('should return different names for different floors', () => { it('should return different names for different floors', () => {
const g90 = getGuardianForFloor(90); const g90 = getGuardianForFloor(90);
const g120 = getGuardianForFloor(120); const g170 = getGuardianForFloor(170);
expect(g90!.name).not.toBe(g120!.name); expect(g90!.name).not.toBe(g170!.name);
});
it('should return arrays for element field', () => {
const g10 = getGuardianForFloor(10);
expect(Array.isArray(g10!.element)).toBe(true);
expect(g10!.element).toContain('fire');
}); });
}); });
describe('getExtendedGuardian', () => { describe('getAllGuardianFloors', () => {
it('should return stable names for combo guardians (floor 150+)', () => { it('should include all static guardian floors', () => {
const a = getExtendedGuardian(150); const floors = getAllGuardianFloors();
const b = getExtendedGuardian(150); for (const f of [10, 20, 30, 40, 50, 60, 70, 80, 90, 100, 110, 130, 140, 150, 160, 170, 180, 190, 200]) {
expect(a).not.toBeNull(); expect(floors).toContain(f);
expect(b).not.toBeNull(); }
expect(a!.name).toBe(b!.name);
}); });
it('should return different names for different combo floors', () => { it('should include procedural guardian floors 210-450', () => {
const g150 = getExtendedGuardian(150); const floors = getAllGuardianFloors();
const g160 = getExtendedGuardian(160); expect(floors).toContain(210);
expect(g150).not.toBeNull(); expect(floors).toContain(250);
expect(g160).not.toBeNull(); expect(floors).toContain(300);
expect(g150!.name).not.toBe(g160!.name); expect(floors).toContain(400);
expect(floors).toContain(450);
}); });
it('should return null for non-guardian floors', () => { it('should be sorted', () => {
expect(getExtendedGuardian(151)).toBeNull(); const floors = getAllGuardianFloors();
expect(getExtendedGuardian(155)).toBeNull(); for (let i = 1; i < floors.length; i++) {
expect(floors[i]).toBeGreaterThan(floors[i - 1]);
}
}); });
it('should produce unique names across many repeated calls', () => { it('should produce unique names across many repeated calls', () => {
@@ -131,7 +124,6 @@ describe('getExtendedGuardian', () => {
const g = getGuardianForFloor(90); const g = getGuardianForFloor(90);
names.add(g!.name); names.add(g!.name);
} }
// All 100 calls should produce exactly 1 unique name
expect(names.size).toBe(1); expect(names.size).toBe(1);
}); });
}); });
src/lib/game/__tests__/room-utils-floor-state.test.ts
+1 -1
View File
@@ -22,7 +22,7 @@ describe('generateFloorState', () => {
const g10 = getGuardianForFloor(10)!; const g10 = getGuardianForFloor(10)!;
expect(state.enemies[0].name).toBe(g10.name); expect(state.enemies[0].name).toBe(g10.name);
expect(state.enemies[0].hp).toBe(g10.hp); expect(state.enemies[0].hp).toBe(g10.hp);
expect(state.enemies[0].element).toBe(g10.element); expect(state.enemies[0].element).toBe(g10.element.join('+'));
}); });
it('should generate combat state for non-guardian floor with combat', () => { it('should generate combat state for non-guardian floor with combat', () => {
src/lib/game/__tests__/spire-utils.test.ts
+62 -63
View File
@@ -9,14 +9,14 @@ import {
getSpireRoomTypeDisplay, getSpireRoomTypeDisplay,
SPIRE_CONFIG, SPIRE_CONFIG,
} from '../utils/spire-utils'; } from '../utils/spire-utils';
import { isGuardianFloor, getExtendedGuardian, getGuardianForFloor, getGuardianHP, generateGuardianName, generateComboGuardianName, ALL_GUARDIAN_FLOORS } from '../data/guardian-encounters'; import { isGuardianFloor, getGuardianForFloor, getGuardianHP, generateGuardianName, getAllGuardianFloors } from '../data/guardian-encounters';
// ─── Spire Utils ───────────────────────────────────────────────────────────── // ─── Spire Utils ─────────────────────────────────────────────────────────────
describe('getRoomsForFloor', () => { describe('getRoomsForFloor', () => {
it('should return at least minRoomsPerFloor for non-guardian floors', () => { it('should return at least minRoomsPerFloor for non-guardian floors', () => {
for (let floor = 1; floor <= 50; floor++) { for (let floor = 1; floor <= 50; floor++) {
if (floor % 10 === 0) continue; // Skip guardian floors if (floor % 10 === 0) continue;
const rooms = getRoomsForFloor(floor); const rooms = getRoomsForFloor(floor);
expect(rooms).toBeGreaterThanOrEqual(SPIRE_CONFIG.minRoomsPerFloor); expect(rooms).toBeGreaterThanOrEqual(SPIRE_CONFIG.minRoomsPerFloor);
expect(rooms).toBeLessThanOrEqual(SPIRE_CONFIG.maxRoomsPerFloor + 5); expect(rooms).toBeLessThanOrEqual(SPIRE_CONFIG.maxRoomsPerFloor + 5);
@@ -46,16 +46,17 @@ describe('generateSpireRoomType', () => {
it('should return combat for first room on non-guardian floors', () => { it('should return combat for first room on non-guardian floors', () => {
for (const floor of [1, 5, 15, 25]) { for (const floor of [1, 5, 15, 25]) {
const roomType = generateSpireRoomType(floor, 0, 10); const roomType = generateSpireRoomType(floor, 0, 10);
// First room may be combat, swarm, or speed depending on random
expect(['combat', 'swarm', 'speed']).toContain(roomType); expect(['combat', 'swarm', 'speed']).toContain(roomType);
} }
}); });
it('should return combat for first room on guardian floors (not last room)', () => { it('should return valid room type for first room on guardian floors (not last room)', () => {
// Floor 50 is a guardian floor, but first room should still be combat // First room on non-last position should never be 'guardian'
const roomType = generateSpireRoomType(50, 0, 10); for (let i = 0; i < 50; i++) {
// First room on guardian floor should not be 'guardian' (last room) and may be combat or swarm depending on random const roomType = generateSpireRoomType(50, 0, 10);
expect(['combat', 'swarm']).toContain(roomType); expect(['combat', 'swarm', 'speed']).toContain(roomType);
expect(roomType).not.toBe('guardian');
}
}); });
it('should return valid room types', () => { it('should return valid room types', () => {
@@ -83,9 +84,7 @@ describe('generateSpireFloorState', () => {
}); });
it('should generate swarm floor with multiple enemies', () => { it('should generate swarm floor with multiple enemies', () => {
// Force swarm by using a non-special room index
const state = generateSpireFloorState(20, 1, 10); const state = generateSpireFloorState(20, 1, 10);
// Room type depends on random, but enemies should be valid
if (state.roomType === 'swarm') { if (state.roomType === 'swarm') {
expect(state.enemies.length).toBeGreaterThanOrEqual(3); expect(state.enemies.length).toBeGreaterThanOrEqual(3);
} }
@@ -122,7 +121,6 @@ describe('getSpireEnemyBarrier', () => {
for (let floor = 15; floor <= 100; floor++) { for (let floor = 15; floor <= 100; floor++) {
const barrier = getSpireEnemyBarrier(floor, 'fire'); const barrier = getSpireEnemyBarrier(floor, 'fire');
expect(barrier).toBeGreaterThanOrEqual(0); expect(barrier).toBeGreaterThanOrEqual(0);
// Use toBeLessThan with a small tolerance for floating point precision
expect(barrier).toBeLessThanOrEqual(0.3000000001); expect(barrier).toBeLessThanOrEqual(0.3000000001);
} }
}); });
@@ -182,53 +180,52 @@ describe('isGuardianFloor', () => {
}); });
}); });
describe('getExtendedGuardian (procedural combo guardians)', () => {
it('should return combo guardians for floors 150+', () => {
const g150 = getExtendedGuardian(150);
expect(g150).not.toBeNull();
expect(g150!.element).toContain('+');
});
it('should return null for floors below 150', () => {
expect(getExtendedGuardian(1)).toBeNull();
expect(getExtendedGuardian(15)).toBeNull();
expect(getExtendedGuardian(95)).toBeNull();
expect(getExtendedGuardian(100)).toBeNull();
expect(getExtendedGuardian(140)).toBeNull();
});
});
describe('getGuardianForFloor (unified lookup)', () => { describe('getGuardianForFloor (unified lookup)', () => {
it('should return base element guardians for floors 10-70', () => { it('should return base element guardians for floors 10-70', () => {
expect(getGuardianForFloor(10)!.element).toBe('fire'); expect(getGuardianForFloor(10)!.element).toEqual(['fire']);
expect(getGuardianForFloor(20)!.element).toBe('water'); expect(getGuardianForFloor(20)!.element).toEqual(['water']);
expect(getGuardianForFloor(30)!.element).toBe('air'); expect(getGuardianForFloor(30)!.element).toEqual(['air']);
expect(getGuardianForFloor(40)!.element).toBe('earth'); expect(getGuardianForFloor(40)!.element).toEqual(['earth']);
expect(getGuardianForFloor(50)!.element).toBe('light'); expect(getGuardianForFloor(50)!.element).toEqual(['light']);
expect(getGuardianForFloor(60)!.element).toBe('dark'); expect(getGuardianForFloor(60)!.element).toEqual(['dark']);
expect(getGuardianForFloor(70)!.element).toBe('death'); expect(getGuardianForFloor(70)!.element).toEqual(['death']);
}); });
it('should return utility guardian for floor 80', () => { it('should return utility guardian for floor 80', () => {
expect(getGuardianForFloor(80)!.element).toBe('transference'); expect(getGuardianForFloor(80)!.element).toEqual(['transference']);
}); });
it('should return compound guardians for floors 90-110', () => { it('should return composite guardians for floors 90-110', () => {
expect(getGuardianForFloor(90)!.element).toBe('metal'); expect(getGuardianForFloor(90)!.element).toEqual(['metal']);
expect(getGuardianForFloor(100)!.element).toBe('sand'); expect(getGuardianForFloor(100)!.element).toEqual(['sand']);
expect(getGuardianForFloor(110)!.element).toBe('lightning'); expect(getGuardianForFloor(110)!.element).toEqual(['lightning']);
}); });
it('should return exotic guardians for floors 120-140', () => { it('should return multi-element guardians for tier 3 floors', () => {
expect(getGuardianForFloor(120)!.element).toBe('crystal'); expect(getGuardianForFloor(130)!.element).toEqual(['metal', 'fire', 'earth']);
expect(getGuardianForFloor(130)!.element).toBe('stellar'); expect(getGuardianForFloor(140)!.element).toEqual(['sand', 'earth', 'water']);
expect(getGuardianForFloor(140)!.element).toBe('void'); expect(getGuardianForFloor(150)!.element).toEqual(['lightning', 'fire', 'air']);
}); });
it('should return combo guardians for floors 150+', () => { it('should return exotic guardians for floors 170-200', () => {
const g150 = getGuardianForFloor(150); expect(getGuardianForFloor(170)!.element).toEqual(['crystal']);
expect(g150).not.toBeNull(); expect(getGuardianForFloor(180)!.element).toEqual(['stellar']);
expect(g150!.element).toContain('+'); expect(getGuardianForFloor(190)!.element).toEqual(['void']);
});
it('should return multi-element exotic convergence for floor 200', () => {
const g200 = getGuardianForFloor(200);
expect(g200).not.toBeNull();
expect(g200!.element.length).toBeGreaterThan(1);
expect(g200!.element).toContain('crystal');
expect(g200!.element).toContain('stellar');
expect(g200!.element).toContain('void');
});
it('should return guardians for procedural floors 210+', () => {
const g210 = getGuardianForFloor(210);
expect(g210).not.toBeNull();
expect(g210!.element.length).toBeGreaterThanOrEqual(2);
}); });
it('should return null for non-guardian floors', () => { it('should return null for non-guardian floors', () => {
@@ -255,36 +252,38 @@ describe('getGuardianHP', () => {
describe('generateGuardianName', () => { describe('generateGuardianName', () => {
it('should generate non-empty names', () => { it('should generate non-empty names', () => {
for (const element of ['fire', 'water', 'air', 'earth', 'light', 'dark', 'death']) { for (const element of ['fire', 'water', 'air', 'earth', 'light', 'dark', 'death']) {
const name = generateGuardianName(element); const name = generateGuardianName([element]);
expect(name).toBeTruthy(); expect(name).toBeTruthy();
expect(name.length).toBeGreaterThan(0); expect(name.length).toBeGreaterThan(0);
} }
}); });
it('should include a title', () => { it('should include a title', () => {
const name = generateGuardianName('fire'); const name = generateGuardianName(['fire']);
expect(name).toContain(' the '); expect(name).toContain(' the ');
}); });
}); });
describe('generateComboGuardianName', () => { describe('getAllGuardianFloors', () => {
it('should combine two element prefixes', () => {
const name = generateComboGuardianName(['fire', 'water']);
expect(name).toContain(' the ');
expect(name.length).toBeGreaterThan(0);
});
});
describe('ALL_GUARDIAN_FLOORS', () => {
it('should include base guardian floors', () => { it('should include base guardian floors', () => {
expect(ALL_GUARDIAN_FLOORS).toContain(10); const floors = getAllGuardianFloors();
expect(ALL_GUARDIAN_FLOORS).toContain(20); expect(floors).toContain(10);
expect(ALL_GUARDIAN_FLOORS).toContain(100); expect(floors).toContain(20);
expect(floors).toContain(100);
}); });
it('should be sorted', () => { it('should be sorted', () => {
for (let i = 1; i < ALL_GUARDIAN_FLOORS.length; i++) { const floors = getAllGuardianFloors();
expect(ALL_GUARDIAN_FLOORS[i]).toBeGreaterThan(ALL_GUARDIAN_FLOORS[i - 1]); for (let i = 1; i < floors.length; i++) {
expect(floors[i]).toBeGreaterThan(floors[i - 1]);
} }
}); });
it('should include procedural floors', () => {
const floors = getAllGuardianFloors();
expect(floors).toContain(210);
expect(floors).toContain(250);
expect(floors).toContain(300);
expect(floors).toContain(400);
});
}); });
src/lib/game/__tests__/store-actions-combat-prestige.test.ts
+1 -1
View File
@@ -232,7 +232,7 @@ describe('PrestigeStore', () => {
describe('startPactRitual', () => { describe('startPactRitual', () => {
it('should start ritual when conditions met', () => { it('should start ritual when conditions met', () => {
usePrestigeStore.setState({ defeatedGuardians: [10], signedPacts: [], insight: 10000 }); usePrestigeStore.setState({ defeatedGuardians: [10], signedPacts: [], insight: 10000 });
const result = usePrestigeStore.getState().startPactRitual(10, 10000); const result = usePrestigeStore.getState().startPactRitual(10, 100000);
expect(result.success).toBe(true); expect(result.success).toBe(true);
expect(usePrestigeStore.getState().pactRitualFloor).toBe(10); expect(usePrestigeStore.getState().pactRitualFloor).toBe(10);
}); });
src/lib/game/data/guardian-data.ts
+199 -185
View File
@@ -1,249 +1,263 @@
// ─── Static Guardian Definitions ────────────────────────────────────────────── // ─── Static Guardian Definitions ─────────────────────────────────────────────────
// Ordered by floor: base → utility → compound → exotic. // New 9-tier progression for guardians:
// //
// Floors 10-80: Base elements (Fire, Water, Air, Earth, Light, Dark, Death) // Tier 1: Base Elements (floors 10–80)
// + Utility element (Transference) — 8 guardians total // Fire, Water, Air, Earth, Light, Dark, Death, Transference
// Floors 90-110: Compound elements (Metal, Sand, Lightning) — 3 guardians // Tier 2: Composite Elements (floors 90–120)
// Floors 120-140: Exotic elements (Crystal, Stellar, Void) — 3 guardians // Metal, Sand, Lightning
// Tier 3: Composite + Components (floors 130–160)
// Tier 4: Exotic Elements (floors 170–200)
// //
// Floor 150+: Procedural combination guardians (see getComboGuardian in guardian-encounters.ts) // Floors 210+ are procedurally generated in guardian-encounters.ts.
import type { GuardianDef } from '../types'; import type { GuardianDef } from '../types';
import { resolveMultiUnlockChain } from '../utils/guardian-utils';
// ─── Shared Helpers ─────────────────────────────────────────────────────────────
// Helper: HP scales exponentially with floor
function hp(floor: number): number { function hp(floor: number): number {
const base = 5000; const base = 5000;
const exponent = 1.1 + (floor / 200); const exponent = 1.1 + (floor / 200);
return Math.floor(base * Math.pow(floor / 10, exponent)); return Math.floor(base * Math.pow(floor / 10, exponent));
} }
// Helper: pact cost scales with guardian HP, power, and armor
function pactCost(hpVal: number, power: number, armor: number): number { function pactCost(hpVal: number, power: number, armor: number): number {
return Math.floor(hpVal * 0.3 + power * 5 + hpVal * armor * 0.5); return Math.floor(hpVal * 0.3 + power * 5 + hpVal * armor * 0.5);
} }
// ─── Base Elements (Floors 10–70) ──────────────────────────────────────────── function mk(
floor: number,
name: string,
element: string[],
color: string,
armor: number,
pactMult: number,
boons: GuardianDef['boons'],
uniquePerk: string,
effects: GuardianDef['effects'],
): GuardianDef {
const hpVal = hp(floor);
const power = Math.floor(hpVal * 0.5);
const arm = armor;
const pc = pactCost(hpVal, power, arm);
const pt = 2 + Math.floor(floor / 10);
const BASE_GUARDIANS: Record<number, GuardianDef> = { return {
// -- Base elements -- name,
10: { element,
name: 'Ignis Prime', element: 'fire', hp: hp(10), pact: 1.5, color: '#FF6B35', hp: hpVal,
armor: 0.10, pact: pactMult,
boons: [ color,
armor: arm,
boons,
pactCost: pc,
pactTime: pt,
uniquePerk,
power,
effects,
signingCost: { mana: pc, time: pt },
unlocksMana: resolveMultiUnlockChain(element),
damageMultiplier: 1.0 + floor * 0.01,
insightMultiplier: 1.0 + floor * 0.005,
};
}
// ═══════════════════════════════════════════════════════════════════════════════
// TIER 1: Base Elements (Floors 10–80)
// ═══════════════════════════════════════════════════════════════════════════════
const TIER1: Record<number, GuardianDef> = {
10: mk(10, 'Ignis Prime', ['fire'], '#FF6B35', 0.10, 1.5,
[
{ type: 'elementalDamage', value: 5, desc: '+5% Fire damage' }, { type: 'elementalDamage', value: 5, desc: '+5% Fire damage' },
{ type: 'maxMana', value: 50, desc: '+50 max mana' }, { type: 'maxMana', value: 50, desc: '+50 max mana' },
], ],
pactCost: pactCost(hp(10), 50, 0.10), pactTime: 2, 'Fire spells cast 10% faster',
uniquePerk: 'Fire spells cast 10% faster', [{ type: 'burn', value: 0.1 }],
power: 50, ),
effects: [{ type: 'burn', value: 0.1 }], 20: mk(20, 'Aqua Regia', ['water'], '#4ECDC4', 0.15, 1.75,
signingCost: { mana: 500, time: 2 }, [
unlocksMana: ['fire', 'lightning'],
damageMultiplier: 1.1, insightMultiplier: 1.05,
},
20: {
name: 'Aqua Regia', element: 'water', hp: hp(20), pact: 1.75, color: '#4ECDC4',
armor: 0.15,
boons: [
{ type: 'elementalDamage', value: 5, desc: '+5% Water damage' }, { type: 'elementalDamage', value: 5, desc: '+5% Water damage' },
{ type: 'manaRegen', value: 0.5, desc: '+0.5 mana regen' }, { type: 'manaRegen', value: 0.5, desc: '+0.5 mana regen' },
], ],
pactCost: pactCost(hp(20), 150, 0.15), pactTime: 4, 'Water spells deal +15% damage',
uniquePerk: 'Water spells deal +15% damage', [{ type: 'armor_pierce', value: 0.15 }],
power: 150, ),
effects: [{ type: 'armor_pierce', value: 0.15 }], 30: mk(30, 'Ventus Rex', ['air'], '#00D4FF', 0.18, 2.0,
signingCost: { mana: 1000, time: 4 }, [
unlocksMana: ['water', 'sand'],
damageMultiplier: 1.2, insightMultiplier: 1.1,
},
30: {
name: 'Ventus Rex', element: 'air', hp: hp(30), pact: 2.0, color: '#00D4FF',
armor: 0.18,
boons: [
{ type: 'elementalDamage', value: 5, desc: '+5% Air damage' }, { type: 'elementalDamage', value: 5, desc: '+5% Air damage' },
{ type: 'castingSpeed', value: 5, desc: '+5% casting speed' }, { type: 'castingSpeed', value: 5, desc: '+5% casting speed' },
], ],
pactCost: pactCost(hp(30), 300, 0.18), pactTime: 6, 'Air spells have 15% crit chance',
uniquePerk: 'Air spells have 15% crit chance', [{ type: 'cast_speed', value: 0.05 }],
power: 300, ),
effects: [{ type: 'cast_speed', value: 0.05 }], 40: mk(40, 'Terra Firma', ['earth'], '#F4A261', 0.25, 2.25,
signingCost: { mana: 2000, time: 6 }, [
unlocksMana: ['air'],
damageMultiplier: 1.3, insightMultiplier: 1.15,
},
40: {
name: 'Terra Firma', element: 'earth', hp: hp(40), pact: 2.25, color: '#F4A261',
armor: 0.25,
boons: [
{ type: 'elementalDamage', value: 5, desc: '+5% Earth damage' }, { type: 'elementalDamage', value: 5, desc: '+5% Earth damage' },
{ type: 'maxMana', value: 100, desc: '+100 max mana' }, { type: 'maxMana', value: 100, desc: '+100 max mana' },
], ],
pactCost: pactCost(hp(40), 500, 0.25), pactTime: 8, 'Earth spells deal +25% damage to guardians',
uniquePerk: 'Earth spells deal +25% damage to guardians', [{ type: 'armor_pierce', value: 0.2 }],
power: 500, ),
effects: [{ type: 'armor_pierce', value: 0.2 }], 50: mk(50, 'Lux Aeterna', ['light'], '#FFD700', 0.20, 2.5,
signingCost: { mana: 4000, time: 8 }, [
unlocksMana: ['earth', 'metal'],
damageMultiplier: 1.4, insightMultiplier: 1.2,
},
50: {
name: 'Lux Aeterna', element: 'light', hp: hp(50), pact: 2.5, color: '#FFD700',
armor: 0.20,
boons: [
{ type: 'elementalDamage', value: 10, desc: '+10% Light damage' }, { type: 'elementalDamage', value: 10, desc: '+10% Light damage' },
{ type: 'insightGain', value: 10, desc: '+10% insight gain' }, { type: 'insightGain', value: 10, desc: '+10% insight gain' },
], ],
pactCost: pactCost(hp(50), 800, 0.20), pactTime: 10, 'Light spells reveal enemy weaknesses (+20% damage)',
uniquePerk: 'Light spells reveal enemy weaknesses (+20% damage)', [{ type: 'crit_chance', value: 0.1 }],
power: 800, ),
effects: [{ type: 'crit_chance', value: 0.1 }], 60: mk(60, 'Umbra Mortis', ['dark'], '#9B59B6', 0.22, 2.75,
signingCost: { mana: 8000, time: 10 }, [
unlocksMana: ['light', 'crystal'],
damageMultiplier: 1.5, insightMultiplier: 1.3,
},
60: {
name: 'Umbra Mortis', element: 'dark', hp: hp(60), pact: 2.75, color: '#9B59B6',
armor: 0.22,
boons: [
{ type: 'elementalDamage', value: 10, desc: '+10% Dark damage' }, { type: 'elementalDamage', value: 10, desc: '+10% Dark damage' },
{ type: 'critDamage', value: 15, desc: '+15% crit damage' }, { type: 'critDamage', value: 15, desc: '+15% crit damage' },
], ],
pactCost: pactCost(hp(60), 1200, 0.22), pactTime: 12, 'Dark spells deal +25% damage to armored enemies',
uniquePerk: 'Dark spells deal +25% damage to armored enemies', [{ type: 'crit_damage', value: 0.15 }],
power: 1200, ),
effects: [{ type: 'crit_damage', value: 0.15 }], 70: mk(70, 'Mors Ultima', ['death'], '#778CA3', 0.25, 3.0,
signingCost: { mana: 15000, time: 12 }, [
unlocksMana: ['dark', 'void'],
damageMultiplier: 1.6, insightMultiplier: 1.4,
},
70: {
name: 'Mors Ultima', element: 'death', hp: hp(70), pact: 3.0, color: '#778CA3',
armor: 0.25,
boons: [
{ type: 'elementalDamage', value: 10, desc: '+10% Death damage' }, { type: 'elementalDamage', value: 10, desc: '+10% Death damage' },
{ type: 'rawDamage', value: 10, desc: '+10% raw damage' }, { type: 'rawDamage', value: 10, desc: '+10% raw damage' },
], ],
pactCost: pactCost(hp(70), 2500, 0.25), pactTime: 14, 'Death spells execute enemies below 20% HP',
uniquePerk: 'Death spells execute enemies below 20% HP', [{ type: 'raw_damage', value: 0.1 }],
power: 2500, ),
effects: [{ type: 'raw_damage', value: 0.1 }], 80: mk(80, 'Vinculum Arcana', ['transference'], '#1ABC9C', 0.20, 3.25,
signingCost: { mana: 25000, time: 14 }, [
unlocksMana: ['death'],
damageMultiplier: 1.8, insightMultiplier: 1.5,
},
// -- Utility element --
80: {
name: 'Vinculum Arcana', element: 'transference', hp: hp(80), pact: 3.25, color: '#1ABC9C',
armor: 0.20,
boons: [
{ type: 'maxMana', value: 150, desc: '+150 max mana' }, { type: 'maxMana', value: 150, desc: '+150 max mana' },
{ type: 'manaRegen', value: 1.0, desc: '+1.0 mana regen' }, { type: 'manaRegen', value: 1.0, desc: '+1.0 mana regen' },
], ],
pactCost: pactCost(hp(80), 3500, 0.20), pactTime: 16, 'Transference spells have 25% reduced cost',
uniquePerk: 'Transference spells have 25% reduced cost', [{ type: 'cost_reduction', value: 0.25 }],
power: 3500, ),
effects: [{ type: 'cost_reduction', value: 0.25 }], };
signingCost: { mana: 35000, time: 16 },
unlocksMana: ['transference'],
damageMultiplier: 1.85, insightMultiplier: 1.55,
},
// -- Compound Elements (Floors 90–110) ─────────────────────────────────────── // ═══════════════════════════════════════════════════════════════════════════════
90: { // TIER 2: Composite Elements (Floors 90–120)
name: '', element: 'metal', hp: hp(90), pact: 3.5, color: '#BDC3C7', // ═══════════════════════════════════════════════════════════════════════════════
armor: 0.30,
boons: [ const TIER2: Record<number, GuardianDef> = {
90: mk(90, '', ['metal'], '#BDC3C7', 0.30, 3.5,
[
{ type: 'elementalDamage', value: 15, desc: '+15% Metal damage' }, { type: 'elementalDamage', value: 15, desc: '+15% Metal damage' },
{ type: 'maxMana', value: 150, desc: '+150 max mana' }, { type: 'maxMana', value: 150, desc: '+150 max mana' },
], ],
pactCost: pactCost(hp(90), 6000, 0.30), pactTime: 18, 'Metal spells pierce 20% armor',
uniquePerk: 'Metal spells pierce 20% armor', [{ type: 'armor_pierce', value: 0.2 }],
power: 6000, ),
effects: [{ type: 'armor_pierce', value: 0.2 }], 100: mk(100, '', ['sand'], '#D4AC0D', 0.25, 3.75,
signingCost: { mana: 60000, time: 18 }, [
unlocksMana: ['metal'],
damageMultiplier: 1.9, insightMultiplier: 1.6,
},
100: {
name: '', element: 'sand', hp: hp(100), pact: 3.75, color: '#D4AC0D',
armor: 0.25,
boons: [
{ type: 'elementalDamage', value: 15, desc: '+15% Sand damage' }, { type: 'elementalDamage', value: 15, desc: '+15% Sand damage' },
{ type: 'manaRegen', value: 1.5, desc: '+1.5 mana regen' }, { type: 'manaRegen', value: 1.5, desc: '+1.5 mana regen' },
], ],
pactCost: pactCost(hp(100), 8000, 0.25), pactTime: 20, 'Sand spells slow enemies by 25%',
uniquePerk: 'Sand spells slow enemies by 25%', [{ type: 'slow', value: 0.25 }],
power: 8000, ),
effects: [{ type: 'slow', value: 0.25 }], 110: mk(110, '', ['lightning'], '#FFEB3B', 0.22, 4.0,
signingCost: { mana: 80000, time: 20 }, [
unlocksMana: ['sand'],
damageMultiplier: 2.0, insightMultiplier: 1.7,
},
110: {
name: '', element: 'lightning', hp: hp(110), pact: 4.0, color: '#FFEB3B',
armor: 0.22,
boons: [
{ type: 'elementalDamage', value: 15, desc: '+15% Lightning damage' }, { type: 'elementalDamage', value: 15, desc: '+15% Lightning damage' },
{ type: 'castingSpeed', value: 15, desc: '+15% casting speed' }, { type: 'castingSpeed', value: 15, desc: '+15% casting speed' },
], ],
pactCost: pactCost(hp(110), 10000, 0.22), pactTime: 22, 'Lightning spells chain to 2 additional targets',
uniquePerk: 'Lightning spells chain to 2 additional targets', [{ type: 'chain', value: 2 }],
power: 10000, ),
effects: [{ type: 'chain', value: 2 }], };
signingCost: { mana: 100000, time: 22 },
unlocksMana: ['lightning'],
damageMultiplier: 2.1, insightMultiplier: 1.8,
},
// -- Exotic Elements (Floors 120–140) ──────────────────────────────────────── // ═══════════════════════════════════════════════════════════════════════════════
120: { // TIER 3: Composite + Their Components (Floors 130–160)
name: '', element: 'crystal', hp: hp(120), pact: 4.5, color: '#85C1E9', // ═══════════════════════════════════════════════════════════════════════════════
armor: 0.35,
boons: [ const TIER3: Record<number, GuardianDef> = {
130: mk(130, '', ['metal', 'fire', 'earth'], '#D4A574', 0.35, 4.5,
[
{ type: 'elementalDamage', value: 20, desc: '+20% Metal damage' },
{ type: 'elementalDamage', value: 10, desc: '+10% Fire damage' },
{ type: 'elementalDamage', value: 10, desc: '+10% Earth damage' },
],
'Tri-aspect: Metal, Fire, and Earth spells gain +10% effectiveness',
[{ type: 'armor_pierce', value: 0.25 }, { type: 'burn', value: 0.1 }],
),
140: mk(140, '', ['sand', 'earth', 'water'], '#C9B896', 0.30, 4.75,
[
{ type: 'elementalDamage', value: 20, desc: '+20% Sand damage' },
{ type: 'elementalDamage', value: 10, desc: '+10% Earth damage' },
{ type: 'elementalDamage', value: 10, desc: '+10% Water damage' },
],
'Tri-aspect: Sand, Earth, and Water spells gain +10% effectiveness',
[{ type: 'slow', value: 0.3 }, { type: 'armor_pierce', value: 0.15 }],
),
150: mk(150, '', ['lightning', 'fire', 'air'], '#FFE066', 0.28, 5.0,
[
{ type: 'elementalDamage', value: 20, desc: '+20% Lightning damage' },
{ type: 'elementalDamage', value: 10, desc: '+10% Fire damage' },
{ type: 'elementalDamage', value: 10, desc: '+10% Air damage' },
],
'Tri-aspect: Lightning, Fire, and Air spells gain +10% effectiveness',
[{ type: 'chain', value: 2 }, { type: 'cast_speed', value: 0.1 }],
),
160: mk(160, '', ['metal', 'lightning', 'fire', 'earth', 'air'], '#E8C872', 0.35, 5.25,
[
{ type: 'elementalDamage', value: 15, desc: '+15% Metal damage' },
{ type: 'elementalDamage', value: 15, desc: '+15% Lightning damage' },
{ type: 'rawDamage', value: 10, desc: '+10% raw damage' },
],
'Fused aspects: Lightning spells gain +20% armor pierce; Metal spells chain once',
[{ type: 'armor_pierce', value: 0.3 }, { type: 'chain', value: 1 }],
),
};
// ═══════════════════════════════════════════════════════════════════════════════
// TIER 4: Exotic Elements (Floors 170–200)
// ═══════════════════════════════════════════════════════════════════════════════
const TIER4: Record<number, GuardianDef> = {
170: mk(170, '', ['crystal'], '#85C1E9', 0.35, 5.5,
[
{ type: 'elementalDamage', value: 20, desc: '+20% Crystal damage' }, { type: 'elementalDamage', value: 20, desc: '+20% Crystal damage' },
{ type: 'maxMana', value: 300, desc: '+300 max mana' }, { type: 'maxMana', value: 300, desc: '+300 max mana' },
{ type: 'manaRegen', value: 2, desc: '+2 mana regen' }, { type: 'manaRegen', value: 2, desc: '+2 mana regen' },
], ],
pactCost: pactCost(hp(120), 15000, 0.35), pactTime: 26, 'Crystal spells reflect 15% damage back to attackers',
uniquePerk: 'Crystal spells reflect 15% damage back to attackers', [{ type: 'reflect', value: 0.15 }],
power: 15000, ),
effects: [{ type: 'reflect', value: 0.15 }], 180: mk(180, '', ['stellar'], '#F0E68C', 0.30, 6.0,
signingCost: { mana: 150000, time: 26 }, [
unlocksMana: ['crystal'],
damageMultiplier: 2.3, insightMultiplier: 1.9,
},
130: {
name: '', element: 'stellar', hp: hp(130), pact: 5.0, color: '#F0E68C',
armor: 0.30,
boons: [
{ type: 'elementalDamage', value: 25, desc: '+25% Stellar damage' }, { type: 'elementalDamage', value: 25, desc: '+25% Stellar damage' },
{ type: 'insightGain', value: 20, desc: '+20% insight gain' }, { type: 'insightGain', value: 20, desc: '+20% insight gain' },
], ],
pactCost: pactCost(hp(130), 20000, 0.30), pactTime: 30, 'Stellar spells deal +30% damage at night',
uniquePerk: 'Stellar spells deal +30% damage at night', [{ type: 'night_bonus', value: 0.3 }],
power: 20000, ),
effects: [{ type: 'night_bonus', value: 0.3 }], 190: mk(190, '', ['void'], '#4A235A', 0.35, 6.5,
signingCost: { mana: 200000, time: 30 }, [
unlocksMana: ['stellar'],
damageMultiplier: 2.5, insightMultiplier: 2.0,
},
140: {
name: '', element: 'void', hp: hp(140), pact: 5.5, color: '#4A235A',
armor: 0.35,
boons: [
{ type: 'elementalDamage', value: 25, desc: '+25% Void damage' }, { type: 'elementalDamage', value: 25, desc: '+25% Void damage' },
{ type: 'rawDamage', value: 15, desc: '+15% raw damage' }, { type: 'rawDamage', value: 15, desc: '+15% raw damage' },
{ type: 'maxMana', value: 400, desc: '+400 max mana' }, { type: 'maxMana', value: 400, desc: '+400 max mana' },
], ],
pactCost: pactCost(hp(140), 30000, 0.35), pactTime: 34, 'Void spells ignore 40% of all resistances',
uniquePerk: 'Void spells ignore 40% of all resistances', [{ type: 'resist_ignore', value: 0.4 }],
power: 30000, ),
effects: [{ type: 'resist_ignore', value: 0.4 }], 200: mk(200, '', ['crystal', 'stellar', 'void'], '#B39DDB', 0.40, 7.0,
signingCost: { mana: 300000, time: 34 }, [
unlocksMana: ['void'], { type: 'elementalDamage', value: 15, desc: '+15% Crystal damage' },
damageMultiplier: 2.8, insightMultiplier: 2.2, { type: 'elementalDamage', value: 15, desc: '+15% Stellar damage' },
}, { type: 'elementalDamage', value: 15, desc: '+15% Void damage' },
],
'Exotic convergence: All exotic spells gain +15% effectiveness',
[{ type: 'reflect', value: 0.1 }, { type: 'resist_ignore', value: 0.1 }],
),
}; };
export { BASE_GUARDIANS }; // ═══════════════════════════════════════════════════════════════════════════════
// COMBINED STATIC GUARDIANS
// ═══════════════════════════════════════════════════════════════════════════════
const STATIC_GUARDIANS: Record<number, GuardianDef> = {
...TIER1,
...TIER2,
...TIER3,
...TIER4,
};
export { STATIC_GUARDIANS, TIER1, TIER2, TIER3, TIER4 };
src/lib/game/data/guardian-encounters.ts
+304 -81
View File
@@ -1,18 +1,24 @@
// ─── Guardian Encounters ─────────────────────────────────────────────────────── // ─── Guardian Encounters ─────────────────────────────────────────────────────────
// Procedural guardian generation and unified lookup. // Procedural guardian generation and unified lookup.
// //
// Guardian progression: // Guardian progression (9 tiers):
// Floors 10-80: Base + utility elements (static, in guardian-data.ts) // Tier 1: Base Elements (static, floors 10–80, guardian-data.ts)
// Floors 90-110: Compound elements (static, in guardian-data.ts) // Tier 2: Composite Elements (static, floors 90–120, guardian-data.ts)
// Floors 120-140: Exotic elements (static, in guardian-data.ts) // Tier 3: Composite+Components (static, floors 130–160, guardian-data.ts)
// Floor 150+: Procedural combo guardians (this file) // Tier 4: Exotic Elements (static, floors 170–200, guardian-data.ts)
// Tier 5: Dual Element Pairs (dynamic, floors 210–240, this file)
// Tier 6: Dual Comp+Components (dynamic, floors 250–290, this file)
// Tier 7: Exotic+Components (dynamic, floors 300–340, this file)
// Tier 8: Exotic+Comp+Components (dynamic, floors 350–390, this file)
// Tier 9: Full Fusion (dynamic, floors 400+, this file)
// //
// All lookups go through getGuardianForFloor() which merges static + procedural. // All lookups go through getGuardianForFloor() which merges static + procedural.
import type { GuardianDef } from '../types'; import type { GuardianDef, GuardianBoon } from '../types';
import { BASE_GUARDIANS } from './guardian-data'; import { STATIC_GUARDIANS } from './guardian-data';
import { resolveMultiUnlockChain } from '../utils/guardian-utils';
// ─── Name Generation ────────────────────────────────────────────────────────── // ─── Name Generation ────────────────────────────────────────────────────────────
const GUARDIAN_PREFIXES: Record<string, string[]> = { const GUARDIAN_PREFIXES: Record<string, string[]> = {
fire: ['Ignis', 'Pyra', 'Sol', 'Vulcan', 'Ember'], fire: ['Ignis', 'Pyra', 'Sol', 'Vulcan', 'Ember'],
@@ -36,14 +42,7 @@ const GUARDIAN_TITLES: string[] = [
'Guardian', 'Sentinel', 'Champion', 'Overlord', 'Archon', 'Guardian', 'Sentinel', 'Champion', 'Overlord', 'Archon',
]; ];
export function generateGuardianName(element: string, floor: number = 0): string { export function generateGuardianName(elements: string[], floor: number = 0): string {
const prefixes = GUARDIAN_PREFIXES[element] || ['Unknown'];
const prefix = prefixes[floor % prefixes.length];
const title = GUARDIAN_TITLES[Math.floor(floor / 10) % GUARDIAN_TITLES.length];
return `${prefix} the ${title}`;
}
export function generateComboGuardianName(elements: string[], floor: number = 0): string {
const parts = elements.map((el, i) => { const parts = elements.map((el, i) => {
const prefixes = GUARDIAN_PREFIXES[el] || ['Unknown']; const prefixes = GUARDIAN_PREFIXES[el] || ['Unknown'];
return prefixes[(floor + i) % prefixes.length]; return prefixes[(floor + i) % prefixes.length];
@@ -52,7 +51,12 @@ export function generateComboGuardianName(elements: string[], floor: number = 0)
return `${parts.join('-')} the ${title}`; return `${parts.join('-')} the ${title}`;
} }
// ─── Guardian HP Scaling ────────────────────────────────────────────────────── /** @deprecated Use generateGuardianName(elements[], floor) instead. Kept for backward compat. */
export function generateGuardianNameSingle(element: string, floor: number = 0): string {
return generateGuardianName([element], floor);
}
// ─── Guardian HP Scaling ───────────────────────────────────────────────────────
export function getGuardianHP(floor: number): number { export function getGuardianHP(floor: number): number {
const base = 5000; const base = 5000;
@@ -60,96 +64,315 @@ export function getGuardianHP(floor: number): number {
return Math.floor(base * Math.pow(floor / 10, exponent)); return Math.floor(base * Math.pow(floor / 10, exponent));
} }
// ─── Combination Guardians (Floor 150+) ─────────────────────────────────────── // ─── Tier Helpers ───────────────────────────────────────────────────────────────
// Procedural guardians that get stronger over time. Each combo pairs two
// base/utility elements and scales stats based on floor number.
const COMBO_PAIRS: [string, string][] = [ const BASE_ELEMENTS = ['fire', 'water', 'air', 'earth', 'light', 'dark', 'death'];
['fire', 'water'], // Steam const COMPOSITE_ELEMENTS = ['metal', 'sand', 'lightning'];
['fire', 'air'], // Smoke const EXOTIC_ELEMENTS = ['crystal', 'stellar', 'void'];
['water', 'earth'], // Mud
['light', 'dark'], // Twilight /** Generate boon elements (max 3) */
['death', 'light'], // Undeath function makeBoons(elements: string[], floor: number): GuardianBoon[] {
['fire', 'death'], // Hellfire return elements.slice(0, 3).map((el) => ({
['water', 'dark'], // Abyssal type: 'elementalDamage' as const,
['air', 'light'], // Radiant wind value: 10 + Math.floor(floor / 20) * 5,
['earth', 'death'], // Fossil desc: `+${10 + Math.floor(floor / 20) * 5}% ${el} damage`,
}));
}
function getTier(floor: number): number {
if (floor >= 400) return 9;
if (floor >= 350) return 8;
if (floor >= 300) return 7;
if (floor >= 250) return 6;
if (floor >= 210) return 5;
return 0; // Static tiers
}
// ═══════════════════════════════════════════════════════════════════════════════
// TIER 5: Dual Element Pairs (Floors 210–240)
// ═══════════════════════════════════════════════════════════════════════════════
const DUAL_PAIRS: [string, string][] = [
['fire', 'water'],
['fire', 'air'],
['water', 'earth'],
['light', 'dark'],
['death', 'light'],
['fire', 'death'],
['water', 'dark'],
['air', 'light'],
['earth', 'death'],
]; ];
export function getComboGuardian(floor: number): GuardianDef { function getTier5Guardian(floor: number): GuardianDef {
const comboIndex = Math.floor((floor - 150) / 10) % COMBO_PAIRS.length; const idx = Math.floor((floor - 210) / 10) % DUAL_PAIRS.length;
const [el1, el2] = COMBO_PAIRS[comboIndex]; const [el1, el2] = DUAL_PAIRS[idx];
const hp = getGuardianHP(floor); const elements = [el1, el2];
const armor = Math.min(0.5, 0.25 + (floor - 150) * 0.002); const hpVal = getGuardianHP(floor);
const armor = Math.min(0.5, 0.30 + (floor - 210) * 0.003);
return { return {
name: '', name: '',
element: `${el1}+${el2}`, element: elements,
hp, hp: hpVal,
pact: 6.0 + (floor - 150) * 0.05, pact: 7.5 + (floor - 210) * 0.05,
color: '#E8D5F5', color: blendColors(el1, el2),
armor, armor,
boons: [ boons: makeBoons(elements, floor),
{ type: 'elementalDamage', value: 10, desc: `+10% ${el1} damage` }, pactCost: Math.floor(hpVal * 0.3 + hpVal * armor * 0.5),
{ type: 'elementalDamage', value: 10, desc: `+10% ${el2} damage` }, pactTime: 20 + Math.floor((floor - 210) / 10),
],
pactCost: Math.floor(hp * 0.3 + Math.floor(hp * 0.5) * 5 + hp * armor * 0.5),
pactTime: 20 + Math.floor((floor - 150) / 10),
uniquePerk: `Dual-aspect: ${el1} and ${el2} spells gain +20% effectiveness`, uniquePerk: `Dual-aspect: ${el1} and ${el2} spells gain +20% effectiveness`,
power: Math.floor(hp * 0.5), power: Math.floor(hpVal * 0.5),
effects: [ effects: [
{ type: `${el1}_boost`, value: 0.2 }, { type: `${el1}_boost`, value: 0.15 },
{ type: `${el2}_boost`, value: 0.2 }, { type: `${el2}_boost`, value: 0.15 },
], ],
signingCost: { mana: Math.floor(hp * 0.3 + Math.floor(hp * 0.5) * 5 + hp * armor * 0.5), time: 20 + Math.floor((floor - 150) / 10) }, signingCost: {
unlocksMana: [el1, el2], mana: Math.floor(hpVal * 0.3),
damageMultiplier: 3.0 + (floor - 150) * 0.02, time: 20 + Math.floor((floor - 210) / 10),
insightMultiplier: 2.5 + (floor - 150) * 0.01, },
unlocksMana: resolveMultiUnlockChain(elements),
damageMultiplier: 3.5 + (floor - 210) * 0.02,
insightMultiplier: 3.0 + (floor - 210) * 0.01,
}; };
} }
// ─── Procedural Guardian Lookup (Floor 150+) ────────────────────────────────── // ═══════════════════════════════════════════════════════════════════════════════
// TIER 6: Dual Composite + Components (Floors 250–290)
// Pairs of composites with all their base components.
// ═══════════════════════════════════════════════════════════════════════════════
export function getExtendedGuardian(floor: number): GuardianDef | null { const DUAL_COMP_PAIRS: [string, string][] = [
if (floor >= 150 && floor % 10 === 0) { ['metal', 'sand'],
const g = getComboGuardian(floor); ['metal', 'lightning'],
if (!g.name) { ['sand', 'lightning'],
const elements = g.element.split('+'); ];
g.name = generateComboGuardianName(elements, floor);
} function getTier6Guardian(floor: number): GuardianDef {
return g; const idx = Math.floor((floor - 250) / 10) % DUAL_COMP_PAIRS.length;
} const [comp1, comp2] = DUAL_COMP_PAIRS[idx];
return null; const elements = resolveMultiUnlockChain([comp1, comp2]);
const hpVal = getGuardianHP(floor);
const armor = Math.min(0.55, 0.35 + (floor - 250) * 0.003);
return {
name: '',
element: elements,
hp: hpVal,
pact: 9.0 + (floor - 250) * 0.05,
color: blendColors(comp1, comp2),
armor,
boons: makeBoons([comp1, comp2], floor),
pactCost: Math.floor(hpVal * 0.3 + hpVal * armor * 0.5),
pactTime: 24 + Math.floor((floor - 250) / 10),
uniquePerk: `Fusion twin-aspect: ${comp1} and ${comp2} spells gain +25% effectiveness`,
power: Math.floor(hpVal * 0.55),
effects: [
{ type: 'armor_pierce', value: 0.2 },
{ type: 'chain', value: 1 },
],
signingCost: {
mana: Math.floor(hpVal * 0.35),
time: 24 + Math.floor((floor - 250) / 10),
},
unlocksMana: resolveMultiUnlockChain(elements),
damageMultiplier: 4.0 + (floor - 250) * 0.02,
insightMultiplier: 3.5 + (floor - 250) * 0.01,
};
} }
// ─── Unified Guardian System ───────────────────────────────────────────────── // ═══════════════════════════════════════════════════════════════════════════════
// Merges static guardians (floors 10–140) with procedural combo guardians (150+). // TIER 7: Exotic + Components (Floors 300–340)
// Each exotic element paired with all its component base elements.
// ═══════════════════════════════════════════════════════════════════════════════
function getTier7Guardian(floor: number): GuardianDef {
const exoticIdx = Math.floor((floor - 300) / 10) % EXOTIC_ELEMENTS.length;
const exoticEl = EXOTIC_ELEMENTS[exoticIdx];
const chain = resolveMultiUnlockChain([exoticEl]);
const hpVal = getGuardianHP(floor);
const armor = Math.min(0.6, 0.40 + (floor - 300) * 0.003);
return {
name: '',
element: chain,
hp: hpVal,
pact: 10.5 + (floor - 300) * 0.05,
color: '#B8A9C9',
armor,
boons: [makeBoons([exoticEl], floor)[0]],
pactCost: Math.floor(hpVal * 0.35 + hpVal * armor * 0.5),
pactTime: 28 + Math.floor((floor - 300) / 10),
uniquePerk: `Exotic resonance: ${exoticEl} spells gain +30% effectiveness`,
power: Math.floor(hpVal * 0.6),
effects: [
{ type: 'resist_ignore', value: 0.2 },
{ type: 'reflect', value: 0.1 },
],
signingCost: {
mana: Math.floor(hpVal * 0.35),
time: 28 + Math.floor((floor - 300) / 10),
},
unlocksMana: chain,
damageMultiplier: 4.5 + (floor - 300) * 0.02,
insightMultiplier: 4.0 + (floor - 300) * 0.01,
};
}
// ═══════════════════════════════════════════════════════════════════════════════
// TIER 8: Exotic + Composite + Components (Floors 350–390)
// One exotic + one composite + all base elements.
// ═══════════════════════════════════════════════════════════════════════════════
function getTier8Guardian(floor: number): GuardianDef {
const exoticIdx = Math.floor((floor - 350) / 10) % EXOTIC_ELEMENTS.length;
const compIdx = Math.floor((floor - 350) / 10) % COMPOSITE_ELEMENTS.length;
const exoticEl = EXOTIC_ELEMENTS[exoticIdx];
const compEl = COMPOSITE_ELEMENTS[compIdx];
const elements = resolveMultiUnlockChain([exoticEl, compEl]);
const hpVal = getGuardianHP(floor);
const armor = Math.min(0.65, 0.45 + (floor - 350) * 0.003);
return {
name: '',
element: elements,
hp: hpVal,
pact: 12.0 + (floor - 350) * 0.05,
color: '#9B72AA',
armor,
boons: makeBoons([exoticEl, compEl], floor),
pactCost: Math.floor(hpVal * 0.4 + hpVal * armor * 0.5),
pactTime: 32 + Math.floor((floor - 350) / 10),
uniquePerk: `Primordial fusion: ${exoticEl} and ${compEl} spells gain +25% effectiveness`,
power: Math.floor(hpVal * 0.65),
effects: [
{ type: 'resist_ignore', value: 0.25 },
{ type: 'armor_pierce', value: 0.2 },
{ type: 'chain', value: 1 },
],
signingCost: {
mana: Math.floor(hpVal * 0.4),
time: 32 + Math.floor((floor - 350) / 10),
},
unlocksMana: elements,
damageMultiplier: 5.0 + (floor - 350) * 0.02,
insightMultiplier: 4.5 + (floor - 350) * 0.01,
};
}
// ═══════════════════════════════════════════════════════════════════════════════
// TIER 9: Full Fusion — 1 Exotic + 2 Composite + All Components (Floors 400+)
// ═══════════════════════════════════════════════════════════════════════════════
function getTier9Guardian(floor: number): GuardianDef {
const exoticIdx = (Math.floor((floor - 400) / 10)) % EXOTIC_ELEMENTS.length;
const exoticEl = EXOTIC_ELEMENTS[exoticIdx];
// Pick 2 different composites
const comp1 = COMPOSITE_ELEMENTS[Math.floor((floor - 400) / 10) % COMPOSITE_ELEMENTS.length];
const comp2 = COMPOSITE_ELEMENTS[(Math.floor((floor - 400) / 10) + 1) % COMPOSITE_ELEMENTS.length];
const elements = resolveMultiUnlockChain([exoticEl, comp1, comp2]);
const hpVal = getGuardianHP(floor);
const armor = Math.min(0.7, 0.50 + (floor - 400) * 0.002);
return {
name: '',
element: elements,
hp: hpVal,
pact: 14.0 + (floor - 400) * 0.05,
color: '#7B5E9A',
armor,
boons: makeBoons([exoticEl, comp1, comp2], floor),
pactCost: Math.floor(hpVal * 0.45 + hpVal * armor * 0.5),
pactTime: 36 + Math.floor((floor - 400) / 10),
uniquePerk: `Cosmic convergence: All exotic, composite, and base spells gain +15% effectiveness`,
power: Math.floor(hpVal * 0.7),
effects: [
{ type: 'resist_ignore', value: 0.3 },
{ type: 'armor_pierce', value: 0.25 },
{ type: 'chain', value: 2 },
{ type: 'reflect', value: 0.1 },
],
signingCost: {
mana: Math.floor(hpVal * 0.45),
time: 36 + Math.floor((floor - 400) / 10),
},
unlocksMana: elements,
damageMultiplier: 5.5 + (floor - 400) * 0.02,
insightMultiplier: 5.0 + (floor - 400) * 0.01,
};
}
// ─── Blending Colors for Dual/Multi-Element Guardians ──────────────────────────
const ELEMENT_COLORS: Record<string, string> = {
fire: '#FF6B35', water: '#4ECDC4', air: '#00D4FF', earth: '#F4A261',
light: '#FFD700', dark: '#9B59B6', death: '#778CA3', transference: '#1ABC9C',
metal: '#BDC3C7', sand: '#D4AC0D', lightning: '#FFEB3B',
crystal: '#85C1E9', stellar: '#F0E68C', void: '#4A235A',
};
function blendColors(el1: string, el2: string): string {
const c1 = ELEMENT_COLORS[el1] || '#888888';
const c2 = ELEMENT_COLORS[el2] || '#888888';
try {
const r = Math.floor((parseInt(c1.slice(1, 3), 16) + parseInt(c2.slice(1, 3), 16)) / 2);
const g = Math.floor((parseInt(c1.slice(3, 5), 16) + parseInt(c2.slice(3, 5), 16)) / 2);
const b = Math.floor((parseInt(c1.slice(5, 7), 16) + parseInt(c2.slice(5, 7), 16)) / 2);
return `#${r.toString(16).padStart(2, '0')}${g.toString(16).padStart(2, '0')}${b.toString(16).padStart(2, '0')}`;
} catch {
return '#888888';
}
}
// ─── Procedural Guardian Generator ─────────────────────────────────────────────
function getProceduralGuardian(floor: number): GuardianDef | null {
if (floor < 210 || floor % 10 !== 0) return null;
const tier = getTier(floor);
let g: GuardianDef;
switch (tier) {
case 5: g = getTier5Guardian(floor); break;
case 6: g = getTier6Guardian(floor); break;
case 7: g = getTier7Guardian(floor); break;
case 8: g = getTier8Guardian(floor); break;
case 9: g = getTier9Guardian(floor); break;
default: return null;
}
if (!g.name) {
g.name = generateGuardianName(g.element, floor);
}
return g;
}
// ─── Unified Guardian System ────────────────────────────────────────────────────
/** Get the guardian for any floor. Returns null if no guardian at that floor. */ /** Get the guardian for any floor. Returns null if no guardian at that floor. */
export function getGuardianForFloor(floor: number): GuardianDef | null { export function getGuardianForFloor(floor: number): GuardianDef | null {
if (BASE_GUARDIANS[floor]) { if (STATIC_GUARDIANS[floor]) {
const g = { ...BASE_GUARDIANS[floor] }; const g = { ...STATIC_GUARDIANS[floor] };
if (!g.name) g.name = generateGuardianName(g.element, floor); if (!g.name) g.name = generateGuardianName(g.element, floor);
return g; return g;
} }
return getExtendedGuardian(floor); return getProceduralGuardian(floor);
} }
/** All guardian floors — merged from static + extended. */ /** All guardian floors — dynamically computed. */
export function getAllGuardianFloors(): number[] { export function getAllGuardianFloors(): number[] {
const staticFloors = Object.keys(BASE_GUARDIANS).map(Number); // Static floors from guardian-data.ts
const comboFloors = Array.from({ length: 10 }, (_, i) => 150 + i * 10); const staticFloors = Object.keys(STATIC_GUARDIANS).map(Number);
const all = new Set([...staticFloors, ...comboFloors]); // Procedural floors: every 10th floor from 210 to 450
const proceduralFloors: number[] = [];
for (let f = 210; f <= 450; f += 10) {
proceduralFloors.push(f);
}
const all = new Set([...staticFloors, ...proceduralFloors]);
return Array.from(all).sort((a, b) => a - b); return Array.from(all).sort((a, b) => a - b);
} }
/** All guardian floors including procedural — kept for backwards compatibility. */ /** Check if a floor is a guardian floor (every 10th floor with a defined guardian). */
export const ALL_GUARDIAN_FLOORS: number[] = [
...Object.keys(BASE_GUARDIANS).map(Number),
...Array.from({ length: 10 }, (_, i) => 150 + i * 10),
].sort((a, b) => a - b);
/** Check if a floor is a guardian floor (every 10th floor). */
export function isGuardianFloor(floor: number): boolean { export function isGuardianFloor(floor: number): boolean {
return floor % 10 === 0; return floor % 10 === 0 && floor >= 10;
} }
src/lib/game/types/attunements.ts
+1 -1
View File
@@ -40,7 +40,7 @@ export interface GuardianBoon {
export interface GuardianDef { export interface GuardianDef {
name: string; name: string;
element: string; element: string[];
hp: number; hp: number;
pact: number; // Pact multiplier when signed pact: number; // Pact multiplier when signed
color: string; color: string;
src/lib/game/utils/combat-utils.ts
+2 -2
View File
@@ -5,7 +5,7 @@ import type { DisciplineBonuses } from './mana-utils';
import { SPELLS_DEF, ELEMENT_OPPOSITES, INCURSION_START_DAY, MAX_DAY } from '../constants'; import { SPELLS_DEF, ELEMENT_OPPOSITES, INCURSION_START_DAY, MAX_DAY } from '../constants';
import { ENCHANTMENT_EFFECTS } from '../data/enchantment-effects'; import { ENCHANTMENT_EFFECTS } from '../data/enchantment-effects';
import { getGuardianForFloor } from '../data/guardian-encounters'; import { getGuardianForFloor } from '../data/guardian-encounters';
import { BASE_GUARDIANS } from '../data/guardian-data'; import { STATIC_GUARDIANS as BASE_GUARDIANS } from '../data/guardian-data';
// ─── Damage Calculation Params ────────────────────────────────────────────── // ─── Damage Calculation Params ──────────────────────────────────────────────
@@ -160,7 +160,7 @@ export function calcDamage(
const elemMasteryBonus = 1; const elemMasteryBonus = 1;
// Guardian bane bonus // Guardian bane bonus
const isGuardianFloor = floorElem && Object.values(BASE_GUARDIANS).some(g => g.element === floorElem); const isGuardianFloor = floorElem && Object.values(BASE_GUARDIANS).some(g => g.element.includes(floorElem));
const guardianBonus = 1; const guardianBonus = 1;
// Get boon bonuses from pacts // Get boon bonuses from pacts
src/lib/game/utils/guardian-utils.ts
+94
View File
@@ -0,0 +1,94 @@
// ─── Guardian Utilities ─────────────────────────────────────────────────────────
// Helper functions for guardian element resolution and name generation.
import { ELEMENTS } from '../constants/elements';
// ─── Element Chain Resolution ──────────────────────────────────────────────────
/**
* Resolve the full component chain for an element.
* Walks the recipe tree from ELEMENTS to collect all base elements + the element itself.
*
* Examples:
* resolveUnlockChain('fire') → ['fire']
* resolveUnlockChain('metal') → ['fire', 'earth', 'metal']
* resolveUnlockChain('crystal') → ['earth', 'water', 'light', 'sand', 'crystal']
* resolveUnlockChain('stellar') → ['fire', 'light', 'stellar']
* resolveUnlockChain('void') → ['dark', 'death', 'void']
*/
export function resolveUnlockChain(element: string): string[] {
const result: string[] = [];
const visited = new Set<string>();
const queue: string[] = [element];
while (queue.length > 0) {
const current = queue.shift()!;
if (visited.has(current)) continue;
visited.add(current);
const def = ELEMENTS[current];
if (!def) continue;
if (def.recipe) {
for (const component of def.recipe) {
if (!visited.has(component)) {
queue.push(component);
}
}
} else {
// Base, utility, or raw element — no recipe, it's a leaf
result.push(current);
}
}
// Always include the element itself
if (!result.includes(element)) {
result.push(element);
}
return result;
}
/**
* Resolve unlock chains for multiple elements (union, deduped).
* Used when a guardian has multiple elements.
*
* Example:
* resolveMultiUnlockChain(['fire', 'earth']) → ['fire', 'earth']
* resolveMultiUnlockChain(['metal', 'sand']) → ['fire', 'earth', 'water', 'metal', 'sand']
*/
export function resolveMultiUnlockChain(elements: string[]): string[] {
const all = new Set<string>();
for (const el of elements) {
for (const resolved of resolveUnlockChain(el)) {
all.add(resolved);
}
}
return Array.from(all);
}
// ─── Dynamic Guardian Floor Computation ────────────────────────────────────────
const TIER_CONFIG = [
// [startFloor, endFloor, tiersPerFloor, description]
{ start: 10, end: 80, spacing: 10 }, // Base + utility: floors 10-80
{ start: 90, end: 120, spacing: 10 }, // Composite: floors 90-120
{ start: 130, end: 160, spacing: 10 }, // Composite + Components
{ start: 170, end: 200, spacing: 10 }, // Exotic
{ start: 210, end: 240, spacing: 10 }, // Dual Element
{ start: 250, end: 290, spacing: 10 }, // Dual Composite + Components
{ start: 300, end: 340, spacing: 10 }, // Exotic + Components
{ start: 350, end: 390, spacing: 10 }, // Exotic + Composite + Components
{ start: 400, end: 450, spacing: 10 }, // 1 Exotic + 2 Composite + All Components
] as const;
/** Get all guardian floors from a given start, dynamically computed. */
export function computeGuardianFloors(maxFloor: number = 450): number[] {
const floors: number[] = [];
for (const tier of TIER_CONFIG) {
for (let f = tier.start; f <= Math.min(tier.end, maxFloor); f += tier.spacing) {
floors.push(f);
}
}
return floors.sort((a, b) => a - b);
}
src/lib/game/utils/room-utils.ts
+1 -1
View File
@@ -109,7 +109,7 @@ export function generateFloorState(floor: number): FloorState {
armor: guardian.armor || 0, armor: guardian.armor || 0,
dodgeChance: 0, dodgeChance: 0,
barrier: 0, barrier: 0,
element: guardian.element, element: guardian.element.join('+'),
}], }],
}; };
src/lib/game/utils/spire-utils.ts
+1 -1
View File
@@ -97,7 +97,7 @@ export function generateSpireFloorState(floor: number, roomIndex: number, totalR
armor: guardian.armor || 0, armor: guardian.armor || 0,
dodgeChance: 0, dodgeChance: 0,
barrier: 0, barrier: 0,
element: guardian.element, element: guardian.element.join('+'),
}], }],
}; };
} }