初始仓库迁移

src/hooks/useGameFlow.ts

@@ -0,0 +1,233 @@
+import { useEffect, useState } from 'react';
+
+import {
+  buildCustomWorldPlayableCharacters,
+  createCharacterSkillCooldowns,
+  getCharacterMaxMana,
+  setRuntimeCharacterOverrides,
+} from '../data/characterPresets';
+import { setRuntimeCustomWorldProfile } from '../data/customWorldRuntime';
+import { getInitialPlayerCurrency } from '../data/economy';
+import { applyEquipmentLoadoutToState, buildInitialEquipmentLoadout, createEmptyEquipmentLoadout } from '../data/equipmentEffects';
+import { buildInitialNpcState, buildInitialPlayerInventory } from '../data/npcInteractions';
+import { createInitialGameRuntimeStats } from '../data/runtimeStats';
+import { ensureSceneEncounterPreview,RESOLVED_ENTITY_X_METERS } from '../data/sceneEncounterPreviews';
+import { getScenePreset,getWorldCampScenePreset } from '../data/scenePresets';
+import { AnimationState, Character, CustomWorldProfile, Encounter, GameState, SceneNpc, WorldType } from '../types';
+import type { BottomTab } from '../types/navigation';
+
+const PLAYER_MAX_HP = 180;
+
+export type {BottomTab} from '../types/navigation';
+
+function createInitialCampEncounter(
+  worldType: WorldType | null,
+  playerCharacter: Character,
+): Encounter | null {
+  if (!worldType) return null;
+
+  const campScenePreset = getWorldCampScenePreset(worldType) ?? getScenePreset(worldType, 0);
+  const npcCandidates = (campScenePreset?.npcs ?? [])
+    .filter((npc: SceneNpc) => Boolean(npc.characterId))
+    .filter((npc: SceneNpc) => npc.characterId !== playerCharacter.id);
+  if (npcCandidates.length === 0) return null;
+
+  const npc = npcCandidates[Math.floor(Math.random() * npcCandidates.length)] ?? null;
+  if (!npc) return null;
+
+  return {
+    id: npc.id,
+    kind: 'npc',
+    characterId: npc.characterId,
+    npcName: npc.name,
+    npcDescription: npc.description,
+    npcAvatar: npc.avatar,
+    context: npc.role,
+    gender: npc.gender,
+    specialBehavior: 'initial_companion',
+    xMeters: RESOLVED_ENTITY_X_METERS,
+  };
+}
+
+function createInitialGameState(): GameState {
+  return {
+    worldType: null,
+    customWorldProfile: null,
+    playerCharacter: null,
+    runtimeStats: createInitialGameRuntimeStats(),
+    currentScene: 'Selection',
+    storyHistory: [],
+    characterChats: {},
+    lastObserveSignsSceneId: null,
+    lastObserveSignsReport: null,
+    animationState: AnimationState.IDLE,
+    currentEncounter: null,
+    npcInteractionActive: false,
+    currentScenePreset: null,
+    sceneMonsters: [],
+    playerX: 0,
+    playerOffsetY: 0,
+    playerFacing: 'right',
+    playerActionMode: 'idle',
+    scrollWorld: false,
+    inBattle: false,
+    playerHp: PLAYER_MAX_HP,
+    playerMaxHp: PLAYER_MAX_HP,
+    playerMana: 0,
+    playerMaxMana: 0,
+    playerSkillCooldowns: {},
+    activeBuildBuffs: [],
+    activeCombatEffects: [],
+    playerCurrency: 0,
+    playerInventory: [],
+    playerEquipment: createEmptyEquipmentLoadout(),
+    npcStates: {},
+    quests: [],
+    roster: [],
+    companions: [],
+    currentBattleNpcId: null,
+    currentNpcBattleMode: null,
+    currentNpcBattleOutcome: null,
+    sparReturnEncounter: null,
+    sparPlayerHpBefore: null,
+    sparPlayerMaxHpBefore: null,
+    sparStoryHistoryBefore: null,
+  };
+}
+
+export function useGameFlow() {
+  const [gameState, setGameState] = useState<GameState>(() => createInitialGameState());
+  const [bottomTab, setBottomTab] = useState<BottomTab>('adventure');
+  const [isMapOpen, setIsMapOpen] = useState(false);
+
+  useEffect(() => {
+    setRuntimeCustomWorldProfile(gameState.customWorldProfile);
+    setRuntimeCharacterOverrides(
+      gameState.customWorldProfile ? buildCustomWorldPlayableCharacters(gameState.customWorldProfile) : null,
+    );
+  }, [gameState.customWorldProfile]);
+
+  const resetGame = () => {
+    setBottomTab('adventure');
+    setIsMapOpen(false);
+    setGameState(createInitialGameState());
+  };
+
+  const handleWorldSelect = (type: WorldType, customWorldProfile: CustomWorldProfile | null = null) => {
+    const resolvedWorldType = customWorldProfile ? WorldType.CUSTOM : type;
+    setRuntimeCustomWorldProfile(customWorldProfile);
+    setRuntimeCharacterOverrides(
+      customWorldProfile ? buildCustomWorldPlayableCharacters(customWorldProfile) : null,
+    );
+    const initialScenePreset = getScenePreset(resolvedWorldType, 0) ?? null;
+    setIsMapOpen(false);
+    setGameState(prev =>
+      ensureSceneEncounterPreview({
+        ...prev,
+        worldType: resolvedWorldType,
+        customWorldProfile,
+        currentScenePreset: initialScenePreset,
+        sceneMonsters: [],
+        currentEncounter: null,
+        npcInteractionActive: false,
+        lastObserveSignsSceneId: null,
+        lastObserveSignsReport: null,
+        playerActionMode: 'idle',
+        activeCombatEffects: [],
+        activeBuildBuffs: [],
+        inBattle: false,
+        currentBattleNpcId: null,
+        currentNpcBattleMode: null,
+        currentNpcBattleOutcome: null,
+        sparReturnEncounter: null,
+        sparPlayerHpBefore: null,
+        sparPlayerMaxHpBefore: null,
+        sparStoryHistoryBefore: null,
+      }),
+    );
+  };
+
+  const handleBackToWorldSelect = () => {
+    setBottomTab('adventure');
+    setIsMapOpen(false);
+    setGameState(createInitialGameState());
+  };
+
+  const handleCharacterSelect = (character: Character) => {
+    setBottomTab('adventure');
+    setIsMapOpen(false);
+
+    const initialScenePreset = gameState.worldType
+      ? getWorldCampScenePreset(gameState.worldType) ?? getScenePreset(gameState.worldType, 0)
+      : null;
+    const initialEncounter = createInitialCampEncounter(gameState.worldType, character);
+    const initialNpcState = initialEncounter
+      ? buildInitialNpcState(initialEncounter, gameState.worldType)
+      : null;
+    const initialEquipment = buildInitialEquipmentLoadout(character);
+
+    setGameState(prev =>
+      ensureSceneEncounterPreview(
+        applyEquipmentLoadoutToState({
+          ...prev,
+          playerCharacter: character,
+          runtimeStats: createInitialGameRuntimeStats({ isActiveRun: true }),
+          currentScene: 'Story',
+          storyHistory: [],
+          characterChats: {},
+          currentEncounter: initialEncounter,
+          npcInteractionActive: false,
+          currentScenePreset: initialScenePreset,
+          lastObserveSignsSceneId: null,
+          lastObserveSignsReport: null,
+          animationState: AnimationState.IDLE,
+          sceneMonsters: [],
+          playerX: 0,
+          playerOffsetY: 0,
+          playerFacing: 'right',
+          playerActionMode: 'idle',
+          scrollWorld: false,
+          inBattle: false,
+          playerHp: PLAYER_MAX_HP,
+          playerMaxHp: PLAYER_MAX_HP,
+          playerMana: getCharacterMaxMana(character),
+          playerMaxMana: getCharacterMaxMana(character),
+          playerSkillCooldowns: createCharacterSkillCooldowns(character),
+          activeBuildBuffs: [],
+          activeCombatEffects: [],
+          playerCurrency: getInitialPlayerCurrency(gameState.worldType),
+          playerInventory: buildInitialPlayerInventory(character, gameState.worldType),
+          playerEquipment: createEmptyEquipmentLoadout(),
+          npcStates: initialEncounter && initialNpcState
+            ? {
+                [initialEncounter.id!]: initialNpcState,
+              }
+            : {},
+          quests: [],
+          roster: [],
+          companions: [],
+          currentBattleNpcId: null,
+          currentNpcBattleMode: null,
+          currentNpcBattleOutcome: null,
+          sparReturnEncounter: null,
+          sparPlayerHpBefore: null,
+          sparPlayerMaxHpBefore: null,
+          sparStoryHistoryBefore: null,
+        }, initialEquipment),
+      ),
+    );
+  };
+
+  return {
+    gameState,
+    setGameState,
+    bottomTab,
+    setBottomTab,
+    isMapOpen,
+    setIsMapOpen,
+    resetGame,
+    handleWorldSelect,
+    handleBackToWorldSelect,
+    handleCharacterSelect,
+  };
+}