LCOV - code coverage report
Current view: top level - states - dungeon.go Coverage Total Hit
Test: coverage.lcov Lines: 72.0 % 150 108
Test Date: 2026-11-19 00:25:22 Functions: - 0 0

            Line data    Source code
       1              : package states
       2              : 
       3              : import (
       4              :         "context"
       5              :         "fmt"
       6              :         "runtime/trace"
       7              : 
       8              :         "github.com/hajimehoshi/ebiten/v2"
       9              :         gc "github.com/kijimaD/ruins/internal/components"
      10              :         "github.com/kijimaD/ruins/internal/consts"
      11              :         "github.com/kijimaD/ruins/internal/dungeon"
      12              :         es "github.com/kijimaD/ruins/internal/engine/states"
      13              :         mapplanner "github.com/kijimaD/ruins/internal/mapplanner"
      14              :         "github.com/kijimaD/ruins/internal/overworld"
      15              :         gs "github.com/kijimaD/ruins/internal/systems"
      16              :         "github.com/kijimaD/ruins/internal/widgets/theme"
      17              :         w "github.com/kijimaD/ruins/internal/world"
      18              :         "github.com/mlange-42/ark/ecs"
      19              : 
      20              :         "github.com/kijimaD/ruins/internal/world/lifecycle"
      21              :         "github.com/kijimaD/ruins/internal/world/query"
      22              :         "github.com/kijimaD/ruins/internal/world/stage"
      23              : )
      24              : 
      25              : // DungeonState はダンジョン探索中のゲームステート
      26              : type DungeonState struct {
      27              :         es.BaseState[w.World]
      28              :         // baseImage は下に敷く背景
      29              :         baseImage *ebiten.Image
      30              :         Depth     int
      31              :         // Danger はこの遺跡の危険度。最初のフロア生成時に確定し全階で共有する。階を降りても変わらない。
      32              :         // ゼロ値は未確定を表す。
      33              :         Danger consts.Danger
      34              :         // BuilderType は使用するマップビルダーのタイプ(BuilderTypeRandom の場合はランダム選択)
      35              :         BuilderType mapplanner.PlannerType
      36              :         // DefinitionName はダンジョン定義名。設定されていればOnStartでリソースに反映する
      37              :         DefinitionName string
      38              :         // Resume はセーブからの復帰モード。trueならマップ再生成とプレイヤー再配置を行わず、
      39              :         // 復元済みのワールド(地形・エンティティ・プレイヤー位置)をそのまま使う
      40              :         Resume bool
      41              : 
      42              :         // planner・newGame・driver・overworldDefinition はオーバーワールドモードのときだけ使う。
      43              :         // 帯固有のロジックは overworld.Driver に閉じ込め、DungeonState は保持と委譲だけ行う
      44              :         planner mapplanner.PlannerType
      45              :         newGame *overworld.NewGameParams // 新規開始の帯パラメータ。ロード復元では nil
      46              :         driver  *overworld.Driver        // OnStart で構成する帯ドライバ。通常ダンジョンでは nil
      47              :         // overworldDefinition はオーバーワールドの種別。非 nil ならこの State は帯モード。
      48              :         // 種別を State が直接持つことで、登録表に無いテスト用の種別も注入できる
      49              :         overworldDefinition *dungeon.OverworldDefinition
      50              : 
      51              :         // three は3D表示の状態と操作。3D固有のものは dungeon3D に隔離する
      52              :         three dungeon3D
      53              : 
      54              :         // showOpening は newGameOverworldState が config.SkipOpening から決める。初回 Update で重ねた後は false にし、再入では出さない
      55              :         showOpening bool
      56              : }
      57              : 
      58              : // isSeamless はこの State がオーバーワールド帯モードかを返す。オーバーワールドとダンジョンの
      59              : // 本質的な違いは帯の有無で、それは OverworldDefinition 種別を持つかで表す。フラグでなく型で判定する。
      60              : func (st DungeonState) isSeamless() bool {
      61            1 :         return st.overworldDefinition != nil
      62            1 : }
      63              : 
      64              : // NewOverworldState はオーバーワールド探索ステートのファクトリを返す。
      65              : //
      66              : // オーバーワールドは帯を持つステージ種別 OverworldDefinition で、専用の State 型は持たず DungeonState
      67              : // として動く。帯固有のロジックは overworld.Driver に閉じ込めてあり、DungeonState は OnStart で
      68              : // ドライバを構成して開始を委譲し、Update でシフトを委譲するだけ。
      69              : //
      70              : // definition は帯形状の供給元。本番は登録済みの dungeon.DungeonOverworld を渡す。
      71              : // params が非 nil なら新規開始として初期帯を生成する。nil ならセーブからの復元とみなし、
      72              : // 帯形状は Driver の Start がオーバーワールドの StageField の SeamlessBand から読み取って再構築する。
      73              : func NewOverworldState(planner mapplanner.PlannerType, definition *dungeon.OverworldDefinition, params *overworld.NewGameParams) es.StateFactory[w.World] {
      74            1 :         return func() (es.State[w.World], error) {
      75            1 :                 return &DungeonState{
      76            1 :                         // overworldDefinition を持たせることで OnStart が帯モードへ分岐する
      77            1 :                         DefinitionName:      definition.Name(),
      78            1 :                         planner:             planner,
      79            1 :                         newGame:             params,
      80            1 :                         overworldDefinition: definition,
      81            1 :                 }, nil
      82            1 :         }
      83              : }
      84              : 
      85              : // State interface ================
      86              : 
      87              : var _ es.State[w.World] = &DungeonState{}
      88              : 
      89              : // OnPause はステートが一時停止される際に呼ばれる
      90            1 : func (st *DungeonState) OnPause(_ w.World) error { return nil }
      91              : 
      92              : // OnResume はステートが再開される際に呼ばれる
      93            1 : func (st *DungeonState) OnResume(_ w.World) error { return nil }
      94              : 
      95              : // OnStart はステートが開始される際に呼ばれる
      96              : func (st *DungeonState) OnStart(world w.World) error {
      97            1 :         screenWidth := world.Resources.ScreenDimensions.Width
      98            1 :         screenHeight := world.Resources.ScreenDimensions.Height
      99            1 :         if screenWidth > 0 && screenHeight > 0 {
     100            1 :                 st.baseImage = ebiten.NewImage(screenWidth, screenHeight)
     101            1 :                 st.baseImage.Fill(theme.ScreenBackground)
     102            1 :         }
     103              : 
     104              :         // 開始時に視界を一度だけ強制再計算させる。VisionSystem は現ステージが変わらないと
     105              :         // キャッシュを無効化しないが、オーバーワールドは常に同一ステージ、通常ダンジョンの
     106              :         // ロード復帰も保存前と同じ現ステージで、いずれも自動再計算が働かない。加えて serde は
     107              :         // VisionState を空で復元するため、放置すると空の VisibleTiles のまま真っ暗になる。
     108              :         // オーバーワールドと通常ダンジョンで同じ扱いにするため、分岐前のここで立てる。
     109            1 :         query.GetVisionState(world).RequestUpdate()
     110            1 : 
     111              :         // Seamless なオーバーワールドは帯ドライバを構成して委譲する。帯固有のロジックは
     112              :         // overworld.Driver に閉じ込め、DungeonState はここで開始を委譲するだけにする
     113            1 :         if st.isSeamless() {
     114            1 :                 st.driver = overworld.NewDriver(st.planner, st.overworldDefinition, st.newGame)
     115            1 :                 if err := st.driver.Start(world); err != nil {
     116            0 :                         return err
     117            0 :                 }
     118              :                 // 新規開始直後に最初の復帰点を作る。ロード復帰では newGame が nil なので保存しない
     119            1 :                 if st.newGame != nil {
     120            1 :                         if err := autoSave(world, nil); err != nil {
     121            0 :                                 return err
     122            0 :                         }
     123              :                 }
     124            1 :                 return nil
     125              :         }
     126              : 
     127              :         // 進入先の遺跡定義名を決める。State に明示指定があればそれを使い、無ければ現ステージ、
     128              :         // すなわち今いる遺跡の名前を引き継ぐ。ダンジョン定義名は CurrentStage.Name から導出する。
     129            1 :         defName := st.DefinitionName
     130            1 :         if defName == "" {
     131            0 :                 defName = query.GetDungeon(world).CurrentStage.Name
     132            0 :         }
     133              :         // ダンジョン種別を取得する。ここは Seamless 判定を抜けた通常ダンジョンなので DungeonDefinition のはず
     134            1 :         def, err := resolveDungeonDefinition(world, defName)
     135            1 :         if err != nil {
     136            0 :                 return err
     137            0 :         }
     138              :         // 単一フロアを新規生成して現ステージに確定する。初回進入や golden の単発描画で使う。
     139              :         // これは共存を作らない: 他ステージの suspend も上り階段の結線もしないので、ゲーム中の
     140              :         // 階層移動(地上⇄遺跡・階の上り下り)には使わないこと。それらは enterDungeon/descend の
     141              :         // SwapTo を通し、退避と結線を伴って往復する。
     142              :         // 復帰モードでは再生成せず、復元済みの地形・エンティティ・プレイヤー位置をそのまま使う
     143            1 :         if !st.Resume {
     144            1 :                 key := dungeonStageKey(defName, st.Depth)
     145            1 :                 playerPos, _, err := st.spawnFloor(world, st.Depth, def, key)
     146            1 :                 if err != nil {
     147            0 :                         return err
     148            0 :                 }
     149              :                 // プレイヤーを配置する
     150            1 :                 if err := lifecycle.MovePlayerToPosition(world, playerPos); err != nil {
     151            0 :                         return err
     152            0 :                 }
     153              :                 // フロア移動時に探索済みマップをリセットし、現ステージを確定する
     154            1 :                 stage.ResetExploredTiles(world)
     155            1 :                 query.GetDungeon(world).CurrentStage = key
     156              :         }
     157              : 
     158              :         // 前フロア・復元前のSpatialIndexが残っている可能性があるため無効化して作り直す。
     159              :         // SpatialIndexはTurnPhaseEndでのみ無効化されるが、フロア遷移はTurnPhasePlayer中に
     160              :         // 発生するため、古いデータが残り移動不能になることがある
     161            1 :         query.InvalidateSpatialIndex(world)
     162            1 : 
     163            1 :         titleText := query.T(world, def.DisplayName())
     164            1 :         if st.Depth > 0 {
     165            1 :                 titleText = fmt.Sprintf("%s %dF", query.T(world, def.DisplayName()), st.Depth)
     166            1 :         }
     167            1 :         lifecycle.SpawnSplashText(world, titleText)
     168            1 : 
     169            1 :         return nil
     170              : }
     171              : 
     172              : // completeSwap はステージ入れ替え直後に視界とカメラを再計算し、遷移なしを返す。
     173              : // swap は Update の後段の handleStateChangeRequest で起きるため、このフレームの
     174              : // VisionSystem/CameraSystem は既に旧ステージで走った後になる。ここで再計算しないと、
     175              : // 入れ替え直後の1フレームが旧ステージの視点・視界のまま描かれてチラつく
     176              : func (st *DungeonState) completeSwap(world w.World) (es.Transition[w.World], error) {
     177            1 :         query.GetVisionState(world).RequestUpdate()
     178            1 :         if err := (&gs.VisionSystem{}).Update(world); err != nil {
     179            0 :                 return es.Transition[w.World]{}, err
     180            0 :         }
     181            1 :         if err := (&gs.CameraSystem{}).Update(world); err != nil {
     182            0 :                 return es.Transition[w.World]{}, err
     183            0 :         }
     184            1 :         return es.Transition[w.World]{Type: es.TransNone}, nil
     185              : }
     186              : 
     187              : // OnStop はステートが停止される際に呼ばれる。
     188              : //
     189              : // 共存方式ではオーバーワールドと遺跡が同一 world に共存し、退避中ステージも保持するため、
     190              : // ここでは何もしない。world を捨てるのは新しいゲームを始める・ロードのときで、
     191              : // world.ResetForNewGame と save の ECS.Reset が担う。ステージ単位の破棄が要る場合は stage.Purge を呼ぶ。
     192            0 : func (st *DungeonState) OnStop(_ w.World) error { return nil }
     193              : 
     194              : // checkPlayerDeath はプレイヤーの死亡状態をチェックする。Update フローの述語
     195              : func (st *DungeonState) checkPlayerDeath(world w.World) bool {
     196            1 :         playerDead := false
     197            1 :         playerDeadQuery := ecs.NewFilter2[gc.Player, gc.Dead](world.ECS).Query()
     198            1 :         // 早期 break しないこと。クエリは最後まで反復してワールドロックを解放する必要がある
     199            1 :         for playerDeadQuery.Next() {
     200            0 :                 playerDead = true
     201            0 :         }
     202            1 :         return playerDead
     203              : }
     204              : 
     205              : // Update はゲームステートの更新処理を行う
     206              : func (st *DungeonState) Update(world w.World) (es.Transition[w.World], error) {
     207              :         // カメラのポインタ操作は3Dへ委譲する。キー操作は束縛表を通して DoAction に届く
     208            1 :         st.three.update(world)
     209            1 : 
     210              :         // キー入力をActionに変換
     211            1 :         if action, ok := st.readAction(world); ok {
     212            1 :                 if transition, err := st.DoAction(world, action); err != nil {
     213            0 :                         return es.Transition[w.World]{}, err
     214            1 :                 } else if transition.Type != es.TransNone {
     215            1 :                         return transition, nil
     216            1 :                 }
     217              :         }
     218              : 
     219            1 :         if err := runUpdaters(world,
     220            1 :                 &gs.AnimationSystem{},
     221            1 :                 &gs.TurnSystem{},
     222            1 :                 // 死者回収は Dead マーカーの反応系。プレイヤーは1ターンに複数回行動できるので毎フレーム回す。
     223            1 :                 // TurnSystem の後に置き、このフレームの AI ターンで死んだ敵も同フレームで撤去する
     224            1 :                 &gs.DeadCleanupSystem{},
     225            1 :                 // 死の判定より前に、デバッグの無敵のプレイヤーを満たして起こす
     226            1 :                 &gs.DebugInvincibleSystem{},
     227            1 :                 &gs.VisionSystem{},
     228            1 :                 &gs.CameraSystem{},
     229            1 :                 &gs.HUDRenderingSystem{},
     230            1 :                 &gs.StatsChangedSystem{},
     231            1 :                 &gs.WeightDirtySystem{},
     232            1 :                 &gs.VisualEffectSystem{},
     233            1 :         ); err != nil {
     234            0 :                 return es.Transition[w.World]{}, err
     235            0 :         }
     236              : 
     237              :         // このフレームで視界を計算済みなので、背後に実プレイ画面を敷いたままオープニングを重ねられる
     238            1 :         if st.showOpening {
     239            0 :                 st.showOpening = false
     240            0 :                 return es.Transition[w.World]{Type: es.TransPush, NewStateFuncs: []es.StateFactory[w.World]{NewOpeningState}}, nil
     241            0 :         }
     242              : 
     243              :         // プレイヤー死亡チェック。死亡で run は終わり結果画面へ移る
     244            1 :         if st.checkPlayerDeath(world) {
     245            0 :                 return es.Transition[w.World]{Type: es.TransPush, NewStateFuncs: []es.StateFactory[w.World]{NewRunResultState}}, nil
     246            0 :         }
     247              : 
     248              :         // ステート遷移リクエストを処理
     249            1 :         transition, err := st.handleStateChangeRequest(world)
     250            1 :         if err != nil {
     251            0 :                 return es.Transition[w.World]{}, err
     252            0 :         }
     253            1 :         if transition.Type != es.TransNone {
     254            0 :                 return transition, nil
     255            0 :         }
     256              : 
     257              :         // BaseStateの共通処理を使用
     258            1 :         transition = st.ConsumeTransition()
     259            1 :         // 現ステージがオーバーワールドのときだけ帯をシフトする。帯ドライバは
     260              :         // オーバーワールド State だけが持ち、現ステージ深度0がオーバーワールドを表す。遺跡へ入ると
     261              :         // 同一 State 内で現ステージ深度が1以上へ変わり、そのあいだ帯を触らない。通常ダンジョンは
     262              :         // driver が nil で除外される。死亡やリクエスト遷移で早期 return したフレームも触らない
     263            1 :         if st.driver != nil && query.IsOnOverworld(world) && transition.Type == es.TransNone {
     264            1 :                 shifted, serr := st.driver.MaybeShift(world)
     265            1 :                 if serr != nil {
     266            0 :                         return es.Transition[w.World]{}, serr
     267            0 :                 }
     268            1 :                 if shifted {
     269              :                         // リベースでプレイヤーが中央へ動くが、カメラは Update 内で既に旧位置に合わせた後。
     270              :                         // カメラを再センタリングしないと、シフトしたフレームで視点がジャンプしてチラつく
     271            0 :                         if err := (&gs.CameraSystem{}).Update(world); err != nil {
     272            0 :                                 return es.Transition[w.World]{}, err
     273            0 :                         }
     274              :                 }
     275              :         }
     276            1 :         return transition, nil
     277              : }
     278              : 
     279              : // Draw はゲームステートの描画処理を行う。世界と HUD を screen へ描く。
     280              : // フィールドのライティングは vision が壁遮蔽込みで計算した per-tile の暗さを
     281              : // Render3DSystem が描く。地上は時間帯の色フィルタを世界へ一様に掛ける。
     282              : func (st *DungeonState) Draw(world w.World, screen *ebiten.Image) error {
     283            1 :         if st.baseImage != nil {
     284            1 :                 screen.DrawImage(st.baseImage, nil)
     285            1 :         }
     286              :         // まず世界レイヤを screen へローポリ3Dで描く。フォグと壁遮蔽は vision の per-tile 暗さで表現する
     287            1 :         r := trace.StartRegion(context.Background(), "draw:3D")
     288            1 :         err := st.three.draw(world, screen)
     289            1 :         r.End()
     290            1 :         if err != nil {
     291            0 :                 return err
     292            0 :         }
     293              :         // 時間帯の色は vision の環境光として per-tile に効く。全画面フィルタは松明で照らした
     294              :         // タイルまで暗くするので掛けない。HUD レイヤは screen へ等倍で描き読みやすさを保つ
     295            1 :         return drawRenderers(world, screen,
     296            1 :                 &gs.HUDRenderingSystem{}, &gs.VisualEffectSystem{})
     297              : }
     298              : 
     299              : // drawRenderers は登録済みのレンダラを順に target へ描く。未登録のものは飛ばす。
     300              : func drawRenderers(world w.World, target *ebiten.Image, renderers ...w.Renderer) error {
     301            1 :         for _, renderer := range renderers {
     302            1 :                 name := renderer.String()
     303            1 :                 sys, ok := world.Renderers[name]
     304            1 :                 if !ok {
     305              :                         // 未登録は描画されず無音で消える。登録漏れをエラーで表面化させる
     306            0 :                         return fmt.Errorf("renderer not registered: %s", name)
     307            0 :                 }
     308            1 :                 r := trace.StartRegion(context.Background(), "draw:"+name)
     309            1 :                 err := sys.Draw(world, target)
     310            1 :                 r.End()
     311            1 :                 if err != nil {
     312            0 :                         return err
     313            0 :                 }
     314              :         }
     315              : 
     316            1 :         return nil
     317              : }
        

Generated by: LCOV version 2.0-1