fix: SpireTab refresh - cast bar, mana costs, full-screen mode, exit button

src/lib/game/stores/__tests__/spire-tab-refresh.test.ts

@@ -0,0 +1,94 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { useCombatStore } from '../combatStore';
+import { useManaStore } from '../manaStore';
+import { useCraftingStore } from '../craftingStore';
+
+describe('SpireTab Refresh & Casting Fixes', () => {
+  beforeEach(() => {
+    // Reset stores
+    useCombatStore.setState({
+      currentFloor: 1,
+      floorHP: 100,
+      floorMaxHP: 100,
+      maxFloorReached: 1,
+      activeSpell: 'manaBolt',
+      currentAction: 'climb',
+      castProgress: 0,
+      spireMode: false,
+      equipmentSpellStates: [
+        { spellId: 'manaBolt', sourceEquipment: 'test-staff', castProgress: 0 }
+      ],
+    });
+
+    useManaStore.setState({
+      rawMana: 100,
+      elements: {
+        fire: { current: 50, max: 100, unlocked: true },
+        transference: { current: 20, max: 100, unlocked: true },
+      },
+    });
+  });
+
+  it('should update equipment spell cast progress', () => {
+    const initialState = useCombatStore.getState();
+    expect(initialState.castProgress).toBe(0);
+
+    // Simulate combat tick (simplified)
+    const newProgress = 0.5;
+    useCombatStore.setState({ castProgress: newProgress });
+
+    const updatedState = useCombatStore.getState();
+    expect(updatedState.castProgress).toBe(newProgress);
+  });
+
+  it('should deduct mana when casting spells', () => {
+    const initialMana = useManaStore.getState().rawMana;
+    expect(initialMana).toBeGreaterThan(0);
+
+    // Simulate spell cast (simplified - mana should decrease)
+    const spellCost = 10;
+    useManaStore.setState({ rawMana: initialMana - spellCost });
+
+    const updatedMana = useManaStore.getState().rawMana;
+    expect(updatedMana).toBe(initialMana - spellCost);
+  });
+
+  it('should have exitSpireMode function', () => {
+    const state = useCombatStore.getState();
+    expect(typeof state.exitSpireMode).toBe('function');
+  });
+
+  it('should set spireMode to false when exitSpireMode is called', () => {
+    // Enter spire mode first
+    useCombatStore.setState({ spireMode: true });
+    expect(useCombatStore.getState().spireMode).toBe(true);
+
+    // Exit spire mode
+    useCombatStore.getState().exitSpireMode();
+    expect(useCombatStore.getState().spireMode).toBe(false);
+  });
+
+  it('should NOT show study components when spireMode is true', () => {
+    // This is a UI test - we can only verify the state
+    useCombatStore.setState({ spireMode: true });
+    const state = useCombatStore.getState();
+    expect(state.spireMode).toBe(true);
+
+    // Study target should be null or ignored when in spire mode
+    // (UI conditionally renders based on spireMode)
+  });
+
+  it('should process equipment spell states in combat tick', () => {
+    const state = useCombatStore.getState();
+    expect(state.equipmentSpellStates.length).toBeGreaterThan(0);
+
+    // Simulate equipment spell progress
+    const updatedStates = state.equipmentSpellStates.map(s => 
+      ({ ...s, castProgress: 0.5 })
+    );
+    useCombatStore.setState({ equipmentSpellStates: updatedStates });
+
+    const updatedState = useCombatStore.getState();
+    expect(updatedState.equipmentSpellStates[0].castProgress).toBe(0.5);
+  });
+});

src/lib/game/stores/combat-actions.ts

@@ -47,7 +47,7 @@ export function processCombatTick(
   let currentFloor = state.currentFloor;
   let floorMaxHP = state.floorMaxHP;
 
-  // Process complete casts
+  // Process complete casts for active spell
   while (castProgress >= 1 && canAffordSpellCost(spellDef.cost, rawMana, elements)) {
     // Deduct spell cost
     const afterCost = deductSpellCost(spellDef.cost, rawMana, elements);
@@ -91,12 +91,56 @@ export function processCombatTick(
     }
   }
 
+  // Process equipment spell states (for progress bars in UI)
+  const updatedEquipmentSpellStates = [...state.equipmentSpellStates];
+  for (let i = 0; i < updatedEquipmentSpellStates.length; i++) {
+    const eSpell = updatedEquipmentSpellStates[i];
+    const eSpellDef = SPELLS_DEF[eSpell.spellId];
+    if (!eSpellDef) continue;
+
+    // Calculate progress for this equipment spell
+    const eSpellCastSpeed = eSpellDef.castSpeed || 1;
+    const eProgressPerTick = HOURS_PER_TICK * eSpellCastSpeed * totalAttackSpeed;
+    let eCastProgress = (eSpell.castProgress || 0) + eProgressPerTick;
+
+    // Process complete casts for equipment spells
+    while (eCastProgress >= 1 && canAffordSpellCost(eSpellDef.cost, rawMana, elements)) {
+      // Deduct cost
+      const eAfterCost = deductSpellCost(eSpellDef.cost, rawMana, elements);
+      rawMana = eAfterCost.rawMana;
+      elements = eAfterCost.elements;
+      totalManaGathered += eSpellDef.cost.amount;
+
+      // Calculate damage
+      const eFloorElement = getFloorElement(currentFloor);
+      const eDamage = calcDamage(
+        { skills, signedPacts: usePrestigeStore.getState().signedPacts },
+        eSpell.spellId,
+        eFloorElement,
+      );
+
+      const eResult = onDamageDealt(eDamage);
+      rawMana = eResult.rawMana;
+      elements = eResult.elements;
+      const eFinalDamage = eResult.modifiedDamage || eDamage;
+
+      floorHP = Math.max(0, floorHP - eFinalDamage);
+      eCastProgress -= 1;
+
+      if (floorHP <= 0) break; // Floor cleared, stop processing
+    }
+
+    // Update equipment spell state
+    updatedEquipmentSpellStates[i] = { ...eSpell, castProgress: eCastProgress % 1 };
+  }
+
   set({
     currentFloor,
     floorHP,
     floorMaxHP: getFloorMaxHP(currentFloor),
     maxFloorReached: Math.max(state.maxFloorReached, currentFloor),
     castProgress,
+    equipmentSpellStates: updatedEquipmentSpellStates,
   });
 
   return { rawMana, elements, logMessages, totalManaGathered };