fix: resolve mana conversion, Spire/Grimoire tab errors, and legacy store references

- Fix mana conversion to deduct from regen instead of mana pool (resolves player stuck at 1 mana below cap) - Fix Spire Tab error by removing unused legacy import (store-modules/enemy-utils) - Fix Grimoire Tab error by adding Array.isArray check for effects.map - Move utility functions from legacy store-modules to utils/ to eliminate legacy dependencies - Add regression test for mana conversion fix - Update SpellsTab.tsx imports to use utils instead of legacy stores
2026-05-08 13:48:53 +02:00
parent e4fb66df9f
commit 2130d30133
10 changed files with 396 additions and 19 deletions
@@ -0,0 +1,29 @@
+// ─── Activity Log Helper ───────────────────────────────────────────────
+// Moved from store-modules/activity-log.ts to eliminate legacy dependencies
+
+import type { ActivityLogEntry } from '../types';
+
+function createActivityEntry(
+  eventType: string,
+  message: string,
+  details?: ActivityLogEntry['details']
+): ActivityLogEntry {
+  return {
+    id: `act_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
+    timestamp: Date.now(), // Use timestamp for ordering
+    eventType: eventType as any,
+    message,
+    details,
+  };
+}
+
+export function addActivityLogEntry(
+  state: { activityLog: ActivityLogEntry[] },
+  eventType: string,
+  message: string,
+  details?: ActivityLogEntry['details']
+): ActivityLogEntry[] {
+  const entry = createActivityEntry(eventType, message, details);
+  // Keep last 50 entries, newest first
+  return [entry, ...state.activityLog.slice(0, 49)];
+}
@@ -0,0 +1,58 @@
+// ─── Enemy Naming System ───────────────────────────────────────────────
+// Moved from store-modules/enemy-utils.ts to eliminate legacy dependencies
+
+import type { EnemyState } from '../types';
+import { SWARM_CONFIG } from '../constants';
+import { getFloorMaxHP, getFloorElement } from './floor-utils';
+
+// Enemy names by element and floor tier
+const ENEMY_NAMES_BY_ELEMENT: Record<string, string[]> = {
+  fire: ['Fire Imp', 'Flame Sprite', 'Emberling', 'Scorchling', 'Inferno Whelp'],
+  water: ['Water Elemental', 'Tidal Wraith', 'Aqua Sprite', 'Drowned One', 'Tsunami Spawn'],
+  air: ['Wind Sylph', 'Gale Rider', 'Storm Spirit', 'Zephyr Darter', 'Cyclone Wisp'],
+  earth: ['Stone Golem', 'Earth Elemental', 'Graveling', 'Mountain Giant', 'Terra Brute'],
+  light: ['Light Saint', 'Radiant Angel', 'Luminous Spirit', 'Divine Warden', 'Holy Sentinel'],
+  dark: ['Shadow Assassin', 'Dark Cultist', 'Umbral Fiend', 'Void Walker', 'Night Stalker'],
+  death: ['Skeleton Warrior', 'Zombie Lord', 'Lichling', 'Bone Reaper', 'Necrotic Wraith'],
+  // Special element names
+  lightning: ['Storm Elemental', 'Thunder Hawk', 'Lightning Eel', 'Shock Sprite', 'Voltaic Wisp'],
+  metal: ['Iron Golem', 'Steel Guardian', 'Rust Monster', 'Chrome Beetle', 'Mercury Spirit'],
+  sand: ['Sand Wraith', 'Dune Stalker', 'Desert Spirit', 'Cactus Thrasher', 'Mirage Runner'],
+  crystal: ['Crystal Guardian', 'Prism Sprite', 'Gem Hound', 'Diamond Golem', 'Shardling'],
+  stellar: ['Star Spawn', 'Cosmic Entity', 'Nova Spirit', 'Astral Watcher', 'Supernova Seed'],
+  void: ['Void Lord', 'Abyssal Horror', 'Entropy Spawn', 'Chaos Elemental', 'Nether Beast'],
+};
+
+// Get enemy name based on element and floor tier (1-100)
+export function getEnemyName(element: string, floor: number): string {
+  const names = ENEMY_NAMES_BY_ELEMENT[element] || ['Unknown Entity'];
+  // Higher floors get "stronger" sounding names (pick from later in the list)
+  const tierIndex = Math.min(names.length -1, Math.floor(floor / 20));
+  const randomIndex = (tierIndex + Math.floor(Math.random() * (names.length - tierIndex))) % names.length;
+  return names[randomIndex!];
+}
+
+// Generate enemies for a swarm room
+export function generateSwarmEnemies(floor: number): EnemyState[] {
+  const baseHP = getFloorMaxHP(floor);
+  const element = getFloorElement(floor);
+  const numEnemies = SWARM_CONFIG.minEnemies + 
+    Math.floor(Math.random() * (SWARM_CONFIG.maxEnemies - SWARM_CONFIG.minEnemies + 1));
+  
+  const enemies: EnemyState[] = [];
+  for (let i = 0; i < numEnemies; i++) {
+    const enemyName = getEnemyName(element, floor);
+    enemies.push({
+      id: `enemy_${i}`,
+      name: enemyName,
+      hp: Math.floor(baseHP * SWARM_CONFIG.hpMultiplier),
+      maxHP: Math.floor(baseHP * SWARM_CONFIG.hpMultiplier),
+      armor: SWARM_CONFIG.armorBase + Math.floor(floor / 10) * SWARM_CONFIG.armorPerFloor,
+      dodgeChance: 0,
+      healthRegen: 0, // Will be set by caller if needed
+      barrier: 0, // Will be set by caller if needed
+      element,
+    });
+  }
+  return enemies;
+}
@@ -0,0 +1,222 @@
+// ─── Room Generation Functions ───────────────────────────────────────
+// Moved from store-modules/room-utils.ts to eliminate legacy dependencies
+
+import type { RoomType, FloorState, EnemyState } from '../types';
+import { GUARDIANS, FLOOR_ELEM_CYCLE, PUZZLE_ROOMS, PUZZLE_ROOM_INTERVAL, PUZZLE_ROOM_CHANCE, SWARM_ROOM_CHANCE, SPEED_ROOM_CHANCE, FLOOR_ARMOR_CONFIG, SWARM_CONFIG, SPEED_ROOM_CONFIG } from '../constants';
+import { getFloorMaxHP } from './floor-utils';
+import { getFloorElement } from './floor-utils';
+import { getEnemyName } from './enemy-utils';
+
+// Generate room type for a floor
+export function generateRoomType(floor: number): RoomType {
+  // Guardian floors are always guardian type
+  if (GUARDIANS[floor]) {
+    return 'guardian';
+  }
+  
+  // Check for puzzle room (every PUZZLE_ROOM_INTERVAL floors)
+  if (floor % PUZZLE_ROOM_INTERVAL === 0 && Math.random() < PUZZLE_ROOM_CHANCE) {
+    return 'puzzle';
+  }
+  
+  // Check for swarm room
+  if (Math.random() < SWARM_ROOM_CHANCE) {
+    return 'swarm';
+  }
+  
+  // Check for speed room
+  if (Math.random() < SPEED_ROOM_CHANCE) {
+    return 'speed';
+  }
+  
+  // Default to combat
+  return 'combat';
+}
+
+// Get armor for a non-guardian floor
+export function getFloorArmor(floor: number): number {
+  if (GUARDIANS[floor]) {
+    return GUARDIANS[floor].armor || 0;
+  }
+  
+  // Armor becomes more common on higher floors
+  if (floor < 10) return 0;
+  
+  const armorChance = Math.min(FLOOR_ARMOR_CONFIG.maxArmorChance, 
+    FLOOR_ARMOR_CONFIG.baseChance + (floor - 10) * FLOOR_ARMOR_CONFIG.chancePerFloor);
+  
+  if (Math.random() > armorChance) return 0;
+  
+  // Scale armor with floor
+  const armorRange = FLOOR_ARMOR_CONFIG.maxArmor - FLOOR_ARMOR_CONFIG.minArmor;
+  const floorProgress = Math.min(1, (floor - 10) / 90);
+  return FLOOR_ARMOR_CONFIG.minArmor + armorRange * floorProgress * Math.random();
+}
+
+// Get dodge chance for a speed room
+export function getDodgeChance(floor: number): number {
+  return Math.min(
+    SPEED_ROOM_CONFIG.maxDodge,
+    SPEED_ROOM_CONFIG.baseDodgeChance + floor * SPEED_ROOM_CONFIG.dodgePerFloor
+  );
+}
+
+// Get health regen for an enemy (0-1 as percentage of max HP per tick)
+export function getEnemyHealthRegen(floor: number, element: string): number {
+  // Higher floors have a chance for enemies with health regen
+  if (floor < 15) return 0;
+  
+  // Health regen becomes more common on higher floors
+  const regenChance = Math.min(0.3, (floor - 15) * 0.005); // Max 30% chance
+  if (Math.random() > regenChance) return 0;
+  
+  // Scale regen with floor (0.5% to 3% of max HP per tick)
+  const floorProgress = Math.min(1, (floor - 15) / 85);
+  return 0.005 + floorProgress * 0.025;
+}
+
+// Get barrier for an enemy (0-1 as percentage of max HP)
+export function getEnemyBarrier(floor: number, element: string): number {
+  // Barrier appears on higher floors, more common with certain elements
+  if (floor < 20) return 0;
+  
+  // Barrier chance based on element - light/water/earth more likely
+  const barrierElements = ['light', 'water', 'earth'];
+  const baseChance = barrierElements.includes(element) ? 0.15 : 0.08;
+  const floorBonus = Math.min(0.25, (floor - 20) * 0.003); // Max 25% additional chance
+  const barrierChance = Math.min(0.4, baseChance + floorBonus);
+  
+  if (Math.random() > barrierChance) return 0;
+  
+  // Barrier is 10% to 30% of max HP
+  const floorProgress = Math.min(1, (floor - 20) / 80);
+  return 0.1 + floorProgress * 0.2;
+}
+
+// Generate enemies for a swarm room
+export function generateSwarmEnemies(floor: number): EnemyState[] {
+  const baseHP = getFloorMaxHP(floor);
+  const element = getFloorElement(floor);
+  const numEnemies = SWARM_CONFIG.minEnemies + 
+    Math.floor(Math.random() * (SWARM_CONFIG.maxEnemies - SWARM_CONFIG.minEnemies + 1));
+  
+  const enemies: EnemyState[] = [];
+  for (let i = 0; i < numEnemies; i++) {
+    const enemyName = getEnemyName(element, floor);
+    enemies.push({
+      id: `enemy_${i}`,
+      name: enemyName,
+      hp: Math.floor(baseHP * SWARM_CONFIG.hpMultiplier),
+      maxHP: Math.floor(baseHP * SWARM_CONFIG.hpMultiplier),
+      armor: SWARM_CONFIG.armorBase + Math.floor(floor / 10) * SWARM_CONFIG.armorPerFloor,
+      dodgeChance: 0,
+      healthRegen: getEnemyHealthRegen(floor, element),
+      barrier: getEnemyBarrier(floor, element),
+      element,
+    });
+  }
+  return enemies;
+}
+
+// Generate initial floor state
+export function generateFloorState(floor: number): FloorState {
+  const roomType = generateRoomType(floor);
+  const element = getFloorElement(floor);
+  const baseHP = getFloorMaxHP(floor);
+  const guardian = GUARDIANS[floor];
+  
+  switch (roomType) {
+    case 'guardian':
+      return {
+        roomType: 'guardian',
+        enemies: [{
+          id: 'guardian',
+          name: guardian.name,
+          hp: guardian.hp,
+          maxHP: guardian.hp,
+          armor: guardian.armor || 0,
+          dodgeChance: 0,
+          healthRegen: 0.01, // Guardians have 1% HP regen per tick
+          barrier: 0,
+          element: guardian.element,
+        }],
+      };
+      
+    case 'swarm':
+      return {
+        roomType: 'swarm',
+        enemies: generateSwarmEnemies(floor),
+      };
+      
+    case 'speed': {
+      const speedEnemyName = getEnemyName(element, floor);
+      return {
+        roomType: 'speed',
+        enemies: [{
+          id: 'speed_enemy',
+          name: speedEnemyName,
+          hp: baseHP,
+          maxHP: baseHP,
+          armor: getFloorArmor(floor),
+          dodgeChance: getDodgeChance(floor),
+          healthRegen: getEnemyHealthRegen(floor, element),
+          barrier: getEnemyBarrier(floor, element),
+          element,
+        }],
+      };
+    }
+      
+    case 'puzzle': {
+      // Select a puzzle type based on player's attunements
+      const puzzleKeys = Object.keys(PUZZLE_ROOMS);
+      const selectedPuzzle = puzzleKeys[Math.floor(Math.random() * puzzleKeys.length)];
+      const puzzle = PUZZLE_ROOMS[selectedPuzzle];
+      return {
+        roomType: 'puzzle',
+        enemies: [],
+        puzzleProgress: 0,
+        puzzleRequired: 1,
+        puzzleId: selectedPuzzle,
+        puzzleAttunements: puzzle.attunements,
+      };
+    }
+      
+    default: // combat
+      const combatEnemyName = getEnemyName(element, floor);
+      return {
+        roomType: 'combat',
+        enemies: [{
+          id: 'enemy',
+          name: combatEnemyName,
+          hp: baseHP,
+          maxHP: baseHP,
+          armor: getFloorArmor(floor),
+          dodgeChance: 0,
+          healthRegen: getEnemyHealthRegen(floor, element),
+          barrier: getEnemyBarrier(floor, element),
+          element,
+        }],
+      };
+  }
+}
+
+// Get puzzle progress speed based on attunements
+export function getPuzzleProgressSpeed(
+  puzzleId: string, 
+  attunements: Record<string, any>
+): number {
+  const puzzle = PUZZLE_ROOMS[puzzleId];
+  if (!puzzle) return 0.02; // Default slow progress
+  
+  let speed = puzzle.baseProgressPerTick;
+  
+  // Add bonus for each relevant attunement level
+  for (const attId of puzzle.attunements) {
+    const attState = attunements[attId];
+    if (attState?.active) {
+      speed += puzzle.attunementBonus * (attState.level || 1);
+    }
+  }
+  
+  return speed;
+}