- {Object.entries(GOLEMS_DEF).map(([id, def]) => {
- const isEnabled = enabledGolems.includes(id);
- return (
-
-
-
{def.name}
-
{def.baseManaType}
-
+
+ {/* ─── Cores ─────────────────────────────────────────────── */}
+
+
+ Cores ({ALL_CORES.length})
+
+
+ {ALL_CORES.map((core) => (
+
+
- );
- })}
+ ))}
+
+
+
+ {/* ─── Frames ────────────────────────────────────────────── */}
+
+
+ Frames ({ALL_FRAMES.length})
+
+
+ {ALL_FRAMES.map((frame) => (
+
+
+
+
+ ))}
+
+
+
+ {/* ─── Mind Circuits ─────────────────────────────────────── */}
+
+
+ Mind Circuits ({ALL_MIND_CIRCUITS.length})
+
+
+ {ALL_MIND_CIRCUITS.map((circuit) => (
+
+
+
+
+ ))}
+
+
+
+ {/* ─── Enchantments ──────────────────────────────────────── */}
+
+
+ Enchantments ({ALL_GOLEM_ENCHANTMENTS.length})
+
+
+ {ALL_GOLEM_ENCHANTMENTS.map((enchant) => (
+
+
+
+
+ ))}
+
@@ -81,4 +244,4 @@ export function GolemDebugSection() {
);
}
-GolemDebugSection.displayName = "GolemDebugSection";
+GolemDebugSection.displayName = 'GolemDebugSection';
diff --git a/src/components/game/tabs/GolemancyTab.test.ts b/src/components/game/tabs/GolemancyTab.test.ts
deleted file mode 100644
index aa13157..0000000
--- a/src/components/game/tabs/GolemancyTab.test.ts
+++ /dev/null
@@ -1,148 +0,0 @@
-import { describe, it, expect } from 'vitest';
-
-// ─── Test: GolemancyTab barrel export ─────────────────────────────────────────
-
-describe('GolemancyTab module structure', () => {
- it('exports GolemancyTab from barrel index', async () => {
- const mod = await import('./GolemancyTab');
- expect(mod.GolemancyTab).toBeDefined();
- expect(typeof mod.GolemancyTab).toBe('function');
- });
-
- it('GolemancyTab has correct displayName', async () => {
- const { GolemancyTab } = await import('./GolemancyTab');
- expect(GolemancyTab.displayName).toBe('GolemancyTab');
- });
-});
-
-// ─── Test: Barrel export includes GolemancyTab ────────────────────────────────
-
-describe('Tab barrel export', () => {
- it('includes GolemancyTab in the tabs index', async () => {
- const mod = await import('@/components/game/tabs');
- expect(mod.GolemancyTab).toBeDefined();
- expect(typeof mod.GolemancyTab).toBe('function');
- });
-});
-
-// ─── Test: Golem data integrity ───────────────────────────────────────────────
-
-describe('Golem data', () => {
- it('all golems have required fields', async () => {
- const { GOLEMS_DEF } = await import('@/lib/game/data/golems');
- for (const [id, def] of Object.entries(GOLEMS_DEF)) {
- expect(def.id).toBe(id);
- expect(def.name).toBeTruthy();
- expect(def.description).toBeTruthy();
- expect(def.baseManaType).toBeTruthy();
- expect(def.summonCost.length).toBeGreaterThan(0);
- expect(def.maintenanceCost.length).toBeGreaterThan(0);
- expect(def.damage).toBeGreaterThan(0);
- expect(def.attackSpeed).toBeGreaterThan(0);
- expect(def.hp).toBeGreaterThan(0);
- expect(def.armorPierce).toBeGreaterThanOrEqual(0);
- expect(def.tier).toBeGreaterThanOrEqual(1);
- expect(def.unlockCondition).toBeTruthy();
- }
- });
-
- it('has golems across multiple tiers', async () => {
- const { GOLEMS_DEF } = await import('@/lib/game/data/golems');
- const tiers = new Set(Object.values(GOLEMS_DEF).map(g => g.tier));
- expect(tiers.size).toBeGreaterThanOrEqual(3);
- });
-
- it('earthGolem is the only base tier golem', async () => {
- const { GOLEMS_DEF } = await import('@/lib/game/data/golems');
- const baseGolems = Object.values(GOLEMS_DEF).filter(g => g.tier === 1);
- expect(baseGolems.length).toBe(1);
- expect(baseGolems[0].id).toBe('earthGolem');
- });
-
- it('voidstoneGolem is the highest tier', async () => {
- const { GOLEMS_DEF } = await import('@/lib/game/data/golems');
- const voidstone = GOLEMS_DEF.voidstoneGolem;
- expect(voidstone).toBeDefined();
- expect(voidstone.tier).toBe(4);
- });
-});
-
-// ─── Test: Golem utility functions ────────────────────────────────────────────
-
-describe('Golem utility functions', () => {
- it('getGolemSlots returns 0 for fabricator level < 2', async () => {
- const { getGolemSlots } = await import('@/lib/game/data/golems');
- expect(getGolemSlots(0)).toBe(0);
- expect(getGolemSlots(1)).toBe(0);
- });
-
- it('getGolemSlots scales with fabricator level', async () => {
- const { getGolemSlots } = await import('@/lib/game/data/golems');
- expect(getGolemSlots(2)).toBe(1);
- expect(getGolemSlots(4)).toBe(2);
- expect(getGolemSlots(10)).toBe(5);
- });
-
- it('isGolemUnlocked returns false for unknown golem', async () => {
- const { isGolemUnlocked } = await import('@/lib/game/data/golems');
- expect(isGolemUnlocked('nonexistent', {}, [])).toBe(false);
- });
-
- it('isGolemUnlocked checks attunement level', async () => {
- const { isGolemUnlocked } = await import('@/lib/game/data/golems');
- expect(isGolemUnlocked('earthGolem', { fabricator: { active: true, level: 1 } }, [])).toBe(false);
- expect(isGolemUnlocked('earthGolem', { fabricator: { active: true, level: 2 } }, [])).toBe(true);
- });
-
- it('isGolemUnlocked checks mana unlocked', async () => {
- const { isGolemUnlocked } = await import('@/lib/game/data/golems');
- expect(isGolemUnlocked('steelGolem', {}, [])).toBe(false);
- expect(isGolemUnlocked('steelGolem', {}, ['metal'])).toBe(true);
- });
-
- it('canAffordGolemSummon returns false for unknown golem', async () => {
- const { canAffordGolemSummon } = await import('@/lib/game/data/golems');
- expect(canAffordGolemSummon('nonexistent', 100, {})).toBe(false);
- });
-
- it('canAffordGolemSummon checks raw mana cost', async () => {
- const { canAffordGolemSummon } = await import('@/lib/game/data/golems');
- // earthGolem costs 10 earth
- const elements = { earth: { current: 5, max: 100, unlocked: true } };
- expect(canAffordGolemSummon('earthGolem', 0, elements)).toBe(false);
- elements.earth.current = 10;
- expect(canAffordGolemSummon('earthGolem', 0, elements)).toBe(true);
- });
-});
-
-// ─── Test: Combat store golemancy state ───────────────────────────────────────
-
-describe('Combat store golemancy', () => {
- it('toggleGolem is a function', async () => {
- const { useCombatStore } = await import('@/lib/game/stores/combatStore');
- const state = useCombatStore.getState();
- expect(typeof state.toggleGolem).toBe('function');
- });
-
- it('golemancy state has correct shape', async () => {
- const { useCombatStore } = await import('@/lib/game/stores/combatStore');
- const state = useCombatStore.getState();
- expect(state.golemancy).toBeDefined();
- expect(Array.isArray(state.golemancy.enabledGolems)).toBe(true);
- expect(Array.isArray(state.golemancy.summonedGolems)).toBe(true);
- expect(typeof state.golemancy.lastSummonFloor).toBe('number');
- });
-});
-
-// ─── Test: File size limit ────────────────────────────────────────────────────
-
-describe('File size limits (400 lines max)', () => {
- it('GolemancyTab.tsx is under 400 lines', async () => {
- const fs = await import('fs');
- const path = await import('path');
- const filePath = path.join(__dirname, 'GolemancyTab.tsx');
- const content = fs.readFileSync(filePath, 'utf-8');
- const lines = content.split('\n').length;
- expect(lines).toBeLessThan(400);
- });
-});
diff --git a/src/components/game/tabs/GolemancyTab.tsx b/src/components/game/tabs/GolemancyTab.tsx
index eb11637..921c66b 100644
--- a/src/components/game/tabs/GolemancyTab.tsx
+++ b/src/components/game/tabs/GolemancyTab.tsx
@@ -5,223 +5,53 @@ import { useShallow } from 'zustand/react/shallow';
import { useCombatStore } from '@/lib/game/stores/combatStore';
import { useAttunementStore } from '@/lib/game/stores/attunementStore';
import { useManaStore } from '@/lib/game/stores/manaStore';
-import { GOLEMS_DEF, isGolemUnlocked, canAffordGolemSummon, getGolemSlots } from '@/lib/game/data/golems';
-import type { GolemDef } from '@/lib/game/data/golems';
-import { ELEMENTS } from '@/lib/game/constants/elements';
-import { DebugName } from '@/components/game/debug/debug-context';
-import { Badge } from '@/components/ui/badge';
-import { ScrollArea } from '@/components/ui/scroll-area';
+import { usePrestigeStore } from '@/lib/game/stores/prestigeStore';
+import {
+ CORES, FRAMES, MIND_CIRCUITS, GOLEM_ENCHANTMENTS,
+ ALL_CORES, ALL_FRAMES, ALL_MIND_CIRCUITS, ALL_GOLEM_ENCHANTMENTS,
+} from '@/lib/game/data/golems';
+import {
+ getGolemSlots,
+ isComponentUnlocked,
+ computeGolemStats,
+ canAffordGolemDesign,
+} from '@/lib/game/data/golems/utils';
+import type { ComputedGolemStats, GolemEnchantmentDefinition } from '@/lib/game/data/golems/types';
+import type { BuilderSection } from './golemancy/types';
+import { GolemDesignBuilder } from './golemancy/GolemDesignBuilder';
+import { GolemLoadoutPanel } from './golemancy/GolemLoadoutPanel';
+import { ActiveGolemsPanel } from './golemancy/ActiveGolemsPanel';
+import { serializeDesign, buildGolemDesign } from './golemancy/golemancy-utils';
import clsx from 'clsx';
-// ─── Tier configuration ──────────────────────────────────────────────────────
-
-interface TierConfig {
- key: string;
- label: string;
- tier: number;
-}
-
-const TIERS: TierConfig[] = [
- { key: 'base', label: 'Base', tier: 1 },
- { key: 'elemental', label: 'Elemental', tier: 2 },
- { key: 'hybrid', label: 'Hybrid', tier: 3 },
-];
-
-function getTierLabel(tier: number): string {
- if (tier <= 1) return 'Base';
- if (tier <= 2) return 'Elemental';
- return 'Hybrid';
-}
-
-function getTierColor(tier: number): string {
- if (tier <= 1) return 'bg-gray-600';
- if (tier <= 2) return 'bg-blue-600';
- if (tier <= 3) return 'bg-purple-600';
- return 'bg-amber-500';
-}
-
-// ─── Helpers ─────────────────────────────────────────────────────────────────
-
-function formatCost(cost: GolemDef['summonCost'][number]): string {
- if (cost.type === 'raw') return `${cost.amount} raw`;
- const elem = cost.element ? ELEMENTS[cost.element] : null;
- return `${cost.amount} ${elem?.sym ?? ''} ${cost.element ?? ''}`.trim();
-}
-
-function formatUnlockCondition(golem: GolemDef): string {
- const cond = golem.unlockCondition;
- switch (cond.type) {
- case 'attunement_level':
- return `${cond.attunement} level ${cond.level}`;
- case 'mana_unlocked': {
- const elem = cond.manaType ? ELEMENTS[cond.manaType] : null;
- return `Unlock ${elem?.sym ?? ''} ${cond.manaType ?? ''}`.trim();
- }
- case 'dual_attunement':
- return `${cond.attunements?.join(' + ')} level ${cond.levels?.join('/')}`;
- default:
- return 'Unknown';
- }
-}
-
-// ─── Golem Card ──────────────────────────────────────────────────────────────
-
-interface GolemCardProps {
- golem: GolemDef;
- unlocked: boolean;
- enabled: boolean;
- summoned: boolean;
- canAfford: boolean;
- onToggle: (id: string) => void;
-}
-
-const GolemCard: React.FC
= React.memo(({
- golem,
- unlocked,
- enabled,
- summoned,
- canAfford,
- onToggle,
-}) => {
- const elemColor = ELEMENTS[golem.baseManaType]?.color ?? '#888';
- const elemSym = ELEMENTS[golem.baseManaType]?.sym ?? '';
-
- return (
-
- {/* Header */}
-
-
-
{golem.name}
-
{golem.description}
-
-
-
- {elemSym}
-
-
- T{golem.tier}
-
-
-
-
- {/* Stats grid */}
-
-
- Damage: {golem.damage}
-
-
- Attack Speed: {golem.attackSpeed}/h
-
-
- HP: {golem.hp}
-
-
- Armor Pierce: {Math.round(golem.armorPierce * 100)}%
-
- {golem.isAoe && (
-
- AoE: {golem.aoeTargets} targets
-
- )}
-
-
- {/* Special Abilities */}
- {golem.specialAbilities && golem.specialAbilities.length > 0 && (
-
-
Special:
- {golem.specialAbilities.map((ability, i) => (
-
- • {ability.name}: {ability.description}
-
- ))}
-
- )}
-
- {/* Costs */}
-
-
- Summon:{' '}
- {golem.summonCost.map((c, i) => (
- {formatCost(c)}{i < golem.summonCost.length - 1 ? ' + ' : ''}
- ))}
-
-
- Upkeep:{' '}
- {golem.maintenanceCost.map((c, i) => (
- {formatCost(c)}{i < golem.maintenanceCost.length - 1 ? ' + ' : ''}
- ))}/tick
-
-
-
- {/* Unlock requirement */}
- {!unlocked && (
-
- 🔒 Requires: {formatUnlockCondition(golem)}
-
- )}
-
- {/* Status + toggle */}
-
-
- {summoned ? (
- ● Summoned
- ) : enabled ? (
- ○ Queued
- ) : (
- — Idle
- )}
-
-
-
-
- {/* Header info */}
-
-
- Configure your golem loadout. Enabled golems are automatically summoned
- when entering the spire if you can afford the cost.
-
-
-
- Slots: {enabledCount}/{golemSlots}
-
-
- Summoned: {golemancy.summonedGolems.length}
-
-
+
+ {/* Header info */}
+
+
+ Design custom golems from components. Enabled golems are automatically
+ summoned when entering the spire if you can afford the cost.
+
+
+ Slots: {enabledCount}/{golemSlots}
+ Active: {golemancy.activeGolems.length}
+ Designs: {Object.keys(golemancy.golemDesigns).length}
-
- {/* Tier tabs */}
-
- {TIERS.map((tier) => {
- const count = golemsByTier[tier.key]?.length ?? 0;
- return (
-
- );
- })}
-
-
- {/* Golem cards */}
-
- {activeTierGolems.length === 0 ? (
-
- No golems in this tier.
-
- ) : (
-
- {activeTierGolems.map((golem) => {
- const unlocked = isGolemUnlocked(golem.id, attunementLookup, unlockedElements);
- const enabled = golemancy.enabledGolems.includes(golem.id);
- const summoned = golemancy.summonedGolems.some(g => g.golemId === golem.id);
- const canAfford = canAffordGolemSummon(golem.id, rawMana, elements);
- return (
-
- );
- })}
-
- )}
-
-
+
+ {/* Section tabs */}
+
+ {([
+ { key: 'builder', label: 'Design Builder' },
+ { key: 'loadout', label: `Loadout (${golemancy.golemLoadout.length})` },
+ { key: 'active', label: `Active (${golemancy.activeGolems.length})` },
+ ] as const).map(({ key, label }) => (
+
+ ))}
+
+
+ {/* ─── Builder Section ─────────────────────────────────────────────── */}
+ {activeSection === 'builder' && (
+
+ )}
+
+ {/* ─── Loadout Section ─────────────────────────────────────────────── */}
+ {activeSection === 'loadout' && (
+
+ )}
+
+ {/* ─── Active Golems Section ───────────────────────────────────────── */}
+ {activeSection === 'active' && (
+
+ )}
+
);
};
diff --git a/src/components/game/tabs/SpireCombatPage/SpireCombatControls.tsx b/src/components/game/tabs/SpireCombatPage/SpireCombatControls.tsx
index 891b164..512b0d7 100644
--- a/src/components/game/tabs/SpireCombatPage/SpireCombatControls.tsx
+++ b/src/components/game/tabs/SpireCombatPage/SpireCombatControls.tsx
@@ -4,7 +4,7 @@ import { useCombatStore, useManaStore, canAffordSpellCost } from '@/lib/game/sto
import { SPELLS_DEF, ELEMENTS } from '@/lib/game/constants';
import { Card, CardContent, CardHeader, CardTitle } from '@/components/ui/card';
import { Progress } from '@/components/ui/progress';
-import { GOLEMS_DEF } from '@/lib/game/data/golems';
+import { CORES, FRAMES } from '@/lib/game/data/golems';
import { DebugName } from '@/components/game/debug/debug-context';
interface SpireCombatControlsProps {
@@ -29,7 +29,8 @@ export function SpireCombatControls({ castProgress }: SpireCombatControlsProps)
.filter(([, state]) => state?.learned)
.map(([id]) => id);
- const summonedGolems = golemancy.summonedGolems || [];
+ const activeGolems = golemancy.activeGolems || [];
+ const golemDesigns = golemancy.golemDesigns || {};
return (
@@ -100,26 +101,28 @@ export function SpireCombatControls({ castProgress }: SpireCombatControlsProps)
🗿 Golems
- {summonedGolems.length === 0 ? (
+ {activeGolems.length === 0 ? (
No golems summoned.
) : (
- {summonedGolems.map((sg) => {
- const golemDef = GOLEMS_DEF[sg.golemId];
- if (!golemDef) return null;
- const elemColor = ELEMENTS[golemDef.baseManaType]?.color || '#888';
+ {activeGolems.map((ag) => {
+ const design = golemDesigns[ag.designId];
+ if (!design) return null;
+ const frame = FRAMES[design.frameId];
+ const core = CORES[design.coreId];
+ const elemColor = frame?.element ? ELEMENTS[frame.element]?.color || '#888' : '#888';
return (
●
- {golemDef.name}
+ {design.name}
- {golemDef.damage} dmg · {golemDef.attackSpeed}/h
+ {frame?.baseDamage ?? '?'} dmg · {core?.manaRegen ?? '?'} mp
);
diff --git a/src/components/game/tabs/golemancy/ActiveGolemsPanel.tsx b/src/components/game/tabs/golemancy/ActiveGolemsPanel.tsx
new file mode 100644
index 0000000..ddf2058
--- /dev/null
+++ b/src/components/game/tabs/golemancy/ActiveGolemsPanel.tsx
@@ -0,0 +1,83 @@
+'use client';
+
+import React from 'react';
+import { useCombatStore } from '@/lib/game/stores/combatStore';
+import { CORES } from '@/lib/game/data/golems';
+import type { RuntimeActiveGolem } from './types';
+import { Badge } from '@/components/ui/badge';
+import { ScrollArea } from '@/components/ui/scroll-area';
+
+// ─── Active Golem Card ───────────────────────────────────────────────────────
+
+interface ActiveGolemCardProps {
+ golem: RuntimeActiveGolem;
+}
+
+const ActiveGolemCard: React.FC
= React.memo(({ golem }) => {
+ const loadoutEntry = useCombatStore(s =>
+ s.golemancy.golemLoadout.find(e => e.designId === golem.designId),
+ );
+ const name = loadoutEntry?.design.name ?? golem.designId;
+ const core = loadoutEntry ? CORES[loadoutEntry.design.coreId] : null;
+ const maxMana = core?.manaCapacity ?? 100;
+
+ return (
+
+
+
{name}
+
+ Active
+
+
+
+
+ Summoned Floor: {golem.summonedFloor}
+
+
+ Rooms Left: {golem.roomsRemaining}
+
+
+ Mana:{' '}
+
+ {Math.round(golem.currentMana)}/{maxMana}
+
+
+
+ Atk Progress:{' '}
+ {Math.round(golem.attackProgress * 100)}%
+
+
+
+
No active golems in combat.
+
Enable golem designs in the Loadout and enter the spire.
+
+ {activeGolems.map(golem => (
+
+ ))}
+
+
+
+
+
+ onDesignNameChange(e.target.value)}
+ placeholder="Enter a name for this golem..."
+ className="w-full rounded bg-gray-800 border border-gray-700 px-3 py-1.5 text-xs text-gray-200 placeholder-gray-600 focus:outline-none focus:border-blue-500" />
+
+
+
(
+
+
+ {core.name}
+ T{core.tier}
+
+
{core.description}
+
+ Cap: {core.manaCapacity}Regen: {core.manaRegen}/hDuration: {core.maxRoomDuration}r
+
+ {!unlocked &&
🔒 {formatRequirement(core.unlockRequirement)}
}
+
+
+ {frame.name}
+ {frame.element && {ELEMENTS[frame.element]?.sym ?? ''} {frame.element}}
+
+
{frame.description}
+
+ DMG: {frame.baseDamage}SPD: {frame.attackSpeed}/h
+ AP: {Math.round(frame.armorPierce * 100)}%MA: {Math.round(frame.magicAffinity * 100)}%
+ {frame.aoeTargets > 1 && AoE: {frame.aoeTargets}}
+ {frame.specialEffect !== 'none' && {frame.specialEffect}}
+
+ {!unlocked &&
🔒 {formatRequirement(frame.unlockRequirement)}
}
+
+
+ {circuit.name}
+ Slots: {circuit.spellSlots}
+
+
{circuit.description}
+
Behavior: {circuit.behavior}
+ {!unlocked &&
🔒 {formatRequirement(circuit.unlockRequirement)}
}
+
+
4. Enchantments (Optional)
+ {usedEnchantmentCapacity}/{Math.round(enchantmentCapacity)} capacity
+
+ {usedEnchantmentCapacity > enchantmentCapacity &&
Over capacity! Remove enchantments to save design.
}
+
+ {ALL_GOLEM_ENCHANTMENTS.map(enchant => {
+ const isSelected = selectedEnchantmentIds.includes(enchant.id);
+ const canAdd = !isSelected && usedEnchantmentCapacity + enchant.capacityCost <= enchantmentCapacity;
+ return (
+
+ );
+ })}
+
+
+
+
+
+
+
+
Stats Preview
+
+
+
+
+
+
{entry.design.name}
+
+ {core?.name ?? '?'} + {frame?.name ?? '?'} + {circuit?.name ?? '?'}
+ {enchantments.length > 0 && ` + ${enchantments.length} enchantment(s)`}
+
+
+
+ {entry.enabled ? 'Enabled' : 'Disabled'}
+
+
+
+
+
+
+
+
+
No golem designs saved yet.
+
Use the Design Builder to create and save golem designs.
+
+ {loadout.map(entry => (
+
+ ))}
+
+ )}
+
+ );
+};
+
+GolemLoadoutPanel.displayName = 'GolemLoadoutPanel';
diff --git a/src/components/game/tabs/golemancy/GolemancyComponents.test.ts b/src/components/game/tabs/golemancy/GolemancyComponents.test.ts
new file mode 100644
index 0000000..5f9e515
--- /dev/null
+++ b/src/components/game/tabs/golemancy/GolemancyComponents.test.ts
@@ -0,0 +1,271 @@
+// ─── Test: computeGolemStats ──────────────────────────────────────────────────
+
+describe('computeGolemStats', () => {
+ it('computes stats for a basic golem design', async () => {
+ const { CORES, FRAMES, MIND_CIRCUITS } = await import('@/lib/game/data/golems');
+ const { computeGolemStats } = await import('@/lib/game/data/golems/utils');
+
+ const design = {
+ id: 'test_basic',
+ name: 'Test Basic',
+ core: CORES.basic,
+ frame: FRAMES.earth,
+ mindCircuit: MIND_CIRCUITS.simple,
+ enchantments: [],
+ selectedManaTypes: [],
+ selectedSpells: [],
+ };
+
+ const stats = computeGolemStats(design);
+
+ // Core-derived stats
+ expect(stats.manaCapacity).toBe(50);
+ expect(stats.manaRegen).toBe(0.5);
+ expect(stats.maxRoomDuration).toBe(3);
+
+ // Frame-derived stats
+ expect(stats.baseDamage).toBe(6);
+ expect(stats.attackSpeed).toBe(1.2);
+ expect(stats.armorPierce).toBe(0.05);
+ expect(stats.magicAffinity).toBe(0.3);
+ expect(stats.aoeTargets).toBe(1);
+
+ // Circuit-derived stats
+ expect(stats.spellSlots).toBe(0);
+
+ // Enchantment capacity = frame.magicAffinity * core.tierMultiplier
+ expect(stats.enchantmentCapacity).toBeCloseTo(0.3 * 1.0);
+
+ // Special effect from frame
+ expect(stats.specialEffect).toBe('none');
+
+ // Available mana types from core
+ expect(stats.availableManaTypes).toEqual(['earth']);
+ });
+
+ it('computes stats for an advanced golem with enchantments', async () => {
+ const { CORES, FRAMES, MIND_CIRCUITS, GOLEM_ENCHANTMENTS } = await import('@/lib/game/data/golems');
+ const { computeGolemStats } = await import('@/lib/game/data/golems/utils');
+
+ const design = {
+ id: 'test_advanced',
+ name: 'Test Advanced',
+ core: CORES.advanced,
+ frame: FRAMES.steel,
+ mindCircuit: MIND_CIRCUITS.advanced,
+ enchantments: [GOLEM_ENCHANTMENTS.sword_fire, GOLEM_ENCHANTMENTS.sword_metal],
+ selectedManaTypes: ['crystal', 'metal', 'fire'],
+ selectedSpells: [],
+ };
+
+ const stats = computeGolemStats(design);
+
+ // Core-derived stats
+ expect(stats.manaCapacity).toBe(200);
+ expect(stats.manaRegen).toBe(3.0);
+ expect(stats.maxRoomDuration).toBe(5);
+
+ // Frame-derived stats
+ expect(stats.baseDamage).toBe(18);
+ expect(stats.attackSpeed).toBe(1.6);
+ expect(stats.armorPierce).toBe(0.5);
+ expect(stats.magicAffinity).toBe(0.5);
+
+ // Circuit-derived stats
+ expect(stats.spellSlots).toBe(2);
+
+ // Enchantment capacity = frame.magicAffinity * core.tierMultiplier
+ expect(stats.enchantmentCapacity).toBeCloseTo(0.5 * 2.0);
+
+ // Selected mana types override core defaults
+ expect(stats.availableManaTypes).toEqual(['crystal', 'metal', 'fire']);
+
+ // Total summon cost includes all components + enchantments
+ expect(stats.totalSummonCost.length).toBeGreaterThan(0);
+
+ // Upkeep = core.manaRegen * 2 per hour
+ expect(stats.upkeepCostPerHour.length).toBe(1);
+ expect(stats.upkeepCostPerHour[0].amount).toBe(6.0); // 3.0 * 2
+ expect(stats.upkeepCostPerHour[0].element).toBe('crystal');
+ });
+
+ it('computes total summon cost from all components', async () => {
+ const { CORES, FRAMES, MIND_CIRCUITS } = await import('@/lib/game/data/golems');
+ const { computeGolemStats } = await import('@/lib/game/data/golems/utils');
+
+ const design = {
+ id: 'test_cost',
+ name: 'Test Cost',
+ core: CORES.basic,
+ frame: FRAMES.earth,
+ mindCircuit: MIND_CIRCUITS.simple,
+ enchantments: [],
+ selectedManaTypes: [],
+ selectedSpells: [],
+ };
+
+ const stats = computeGolemStats(design);
+
+ // basic core: 10 earth, earth frame: 5 raw, simple circuit: 3 raw
+ const rawCosts = stats.totalSummonCost.filter(c => c.type === 'raw');
+ const earthCosts = stats.totalSummonCost.filter(c => c.type === 'element' && c.element === 'earth');
+
+ const totalRaw = rawCosts.reduce((sum, c) => sum + c.amount, 0);
+ const totalEarth = earthCosts.reduce((sum, c) => sum + c.amount, 0);
+
+ expect(totalRaw).toBe(8); // 5 + 3
+ expect(totalEarth).toBe(10);
+ });
+});
+
+// ─── Test: canAffordGolemDesign ───────────────────────────────────────────────
+
+describe('canAffordGolemDesign', () => {
+ it('returns canAfford true when player has enough resources', async () => {
+ const { CORES, FRAMES, MIND_CIRCUITS } = await import('@/lib/game/data/golems');
+ const { canAffordGolemDesign } = await import('@/lib/game/data/golems/utils');
+
+ const design = {
+ id: 'test_afford',
+ name: 'Test Afford',
+ core: CORES.basic,
+ frame: FRAMES.earth,
+ mindCircuit: MIND_CIRCUITS.simple,
+ enchantments: [],
+ selectedManaTypes: [],
+ selectedSpells: [],
+ };
+
+ // basic core: 10 earth, earth frame: 5 raw, simple circuit: 3 raw
+ const result = canAffordGolemDesign(design, 100, {
+ earth: { current: 50, max: 100, unlocked: true },
+ });
+
+ expect(result.canAfford).toBe(true);
+ expect(result.missing).toBe('');
+ });
+
+ it('returns canAfford false when raw mana is insufficient', async () => {
+ const { CORES, FRAMES, MIND_CIRCUITS } = await import('@/lib/game/data/golems');
+ const { canAffordGolemDesign } = await import('@/lib/game/data/golems/utils');
+
+ const design = {
+ id: 'test_no_raw',
+ name: 'Test No Raw',
+ core: CORES.basic,
+ frame: FRAMES.earth,
+ mindCircuit: MIND_CIRCUITS.simple,
+ enchantments: [],
+ selectedManaTypes: [],
+ selectedSpells: [],
+ };
+
+ // Need 8 raw total (5 + 3), only have 3
+ const result = canAffordGolemDesign(design, 3, {
+ earth: { current: 50, max: 100, unlocked: true },
+ });
+
+ expect(result.canAfford).toBe(false);
+ expect(result.missing).toContain('raw mana');
+ });
+
+ it('returns canAfford false when element mana is insufficient', async () => {
+ const { CORES, FRAMES, MIND_CIRCUITS } = await import('@/lib/game/data/golems');
+ const { canAffordGolemDesign } = await import('@/lib/game/data/golems/utils');
+
+ const design = {
+ id: 'test_no_elem',
+ name: 'Test No Elem',
+ core: CORES.basic,
+ frame: FRAMES.earth,
+ mindCircuit: MIND_CIRCUITS.simple,
+ enchantments: [],
+ selectedManaTypes: [],
+ selectedSpells: [],
+ };
+
+ // Need 10 earth, only have 5
+ const result = canAffordGolemDesign(design, 100, {
+ earth: { current: 5, max: 100, unlocked: true },
+ });
+
+ expect(result.canAfford).toBe(false);
+ expect(result.missing).toContain('earth');
+ });
+
+ it('returns canAfford false when element is not unlocked', async () => {
+ const { CORES, FRAMES, MIND_CIRCUITS } = await import('@/lib/game/data/golems');
+ const { canAffordGolemDesign } = await import('@/lib/game/data/golems/utils');
+
+ const design = {
+ id: 'test_locked',
+ name: 'Test Locked',
+ core: CORES.basic,
+ frame: FRAMES.earth,
+ mindCircuit: MIND_CIRCUITS.simple,
+ enchantments: [],
+ selectedManaTypes: [],
+ selectedSpells: [],
+ };
+
+ // earth not in elements at all
+ const result = canAffordGolemDesign(design, 100, {});
+
+ expect(result.canAfford).toBe(false);
+ expect(result.missing).toContain('not unlocked');
+ });
+
+ it('returns canAfford false when element exists but unlocked is false', async () => {
+ const { CORES, FRAMES, MIND_CIRCUITS } = await import('@/lib/game/data/golems');
+ const { canAffordGolemDesign } = await import('@/lib/game/data/golems/utils');
+
+ const design = {
+ id: 'test_unlocked_false',
+ name: 'Test Unlocked False',
+ core: CORES.basic,
+ frame: FRAMES.earth,
+ mindCircuit: MIND_CIRCUITS.simple,
+ enchantments: [],
+ selectedManaTypes: [],
+ selectedSpells: [],
+ };
+
+ const result = canAffordGolemDesign(design, 100, {
+ earth: { current: 50, max: 100, unlocked: false },
+ });
+
+ expect(result.canAfford).toBe(false);
+ expect(result.missing).toContain('not unlocked');
+ });
+});
+
+// ─── Test: Combat store golemancy state ───────────────────────────────────────
+
+describe('Combat store golemancy', () => {
+ it('toggleGolem is a function', async () => {
+ const { useCombatStore } = await import('@/lib/game/stores/combatStore');
+ const state = useCombatStore.getState();
+ expect(typeof state.toggleGolem).toBe('function');
+ });
+
+ it('golemancy state has correct shape', async () => {
+ const { useCombatStore } = await import('@/lib/game/stores/combatStore');
+ const state = useCombatStore.getState();
+ expect(state.golemancy).toBeDefined();
+ expect(Array.isArray(state.golemancy.golemLoadout)).toBe(true);
+ expect(Array.isArray(state.golemancy.activeGolems)).toBe(true);
+ });
+});
+
+// ─── Test: File size limit ────────────────────────────────────────────────────
+
+describe('File size limits (400 lines max)', () => {
+ it('GolemancyTab.tsx is under 400 lines', async () => {
+ const fs = await import('fs');
+ const path = await import('path');
+ const filePath = path.join(__dirname, '..', 'GolemancyTab.tsx');
+ const content = fs.readFileSync(filePath, 'utf-8');
+ const lines = content.split('\n').length;
+ expect(lines).toBeLessThan(400);
+ });
+});
diff --git a/src/components/game/tabs/golemancy/GolemancySharedComponents.tsx b/src/components/game/tabs/golemancy/GolemancySharedComponents.tsx
new file mode 100644
index 0000000..02c1c86
--- /dev/null
+++ b/src/components/game/tabs/golemancy/GolemancySharedComponents.tsx
@@ -0,0 +1,82 @@
+'use client';
+
+import React from 'react';
+import type { ComputedGolemStats, CoreDefinition } from '@/lib/game/data/golems/types';
+import { ELEMENTS } from '@/lib/game/constants/elements';
+import clsx from 'clsx';
+import { formatManaCost, formatRequirement } from './golemancy-utils';
+
+interface ComponentSelectorProps {
+ label: string;
+ items: T[];
+ selectedId: string | null;
+ unlockedIds: Set;
+ onSelect: (id: string) => void;
+ renderItem: (item: T, unlocked: boolean, selected: boolean) => React.ReactNode;
+}
+
+export function ComponentSelector({
+ label, items, selectedId, unlockedIds, onSelect, renderItem,
+}: ComponentSelectorProps) {
+ return (
+
+
{label}
+
+ {items.map(item => {
+ const unlocked = unlockedIds.has(item.id);
+ const selected = selectedId === item.id;
+ return (
+
+ );
+ })}
+
+
Select all required components to see stats preview.
;
+ return (
+
+
+ {canAfford.canAfford ? '✓ Can afford summon cost' : `✗ Cannot afford: ${canAfford.missing}`}
+
+
+
Damage: {stats.baseDamage}
+
Atk Speed: {stats.attackSpeed}/h
+
Armor Pierce: {Math.round(stats.armorPierce * 100)}%
+
Magic Affinity: {Math.round(stats.magicAffinity * 100)}%
+
AoE Targets: {stats.aoeTargets}
+
Spell Slots: {stats.spellSlots}
+
Mana Capacity: {stats.manaCapacity}
+
Mana Regen: {stats.manaRegen}/h
+
Room Duration: {stats.maxRoomDuration} rooms
+
Enchant Cap: {Math.round(stats.enchantmentCapacity)}
+ {stats.specialEffect !== 'none' && (
+
Special:{' '}{stats.specialEffect}
+ )}
+
+
Summon Cost:{' '}
+ {stats.totalSummonCost.map((c, i) => {formatManaCost(c)}{i < stats.totalSummonCost.length - 1 ? ' + ' : ''})}
+
+
Upkeep:{' '}
+ {stats.upkeepCostPerHour.map((c, i) => {formatManaCost(c)}{i < stats.upkeepCostPerHour.length - 1 ? ' + ' : ''}/h)}
+
+
Mana Types:{' '}
+ {stats.availableManaTypes.map((mt, i) => {ELEMENTS[mt]?.sym ?? ''}{mt}{i < stats.availableManaTypes.length - 1 ? ', ' : ''})}
+
+