LCOV - code coverage report
Current view: top level - overworld - driver.go Coverage Total Hit
Test: coverage.lcov Lines: 76.9 % 134 103
Test Date: 2026-11-19 00:25:22 Functions: - 0 0

            Line data    Source code
       1              : package overworld
       2              : 
       3              : import (
       4              :         "fmt"
       5              : 
       6              :         gc "github.com/kijimaD/ruins/internal/components"
       7              :         "github.com/kijimaD/ruins/internal/consts"
       8              :         "github.com/kijimaD/ruins/internal/dungeon"
       9              :         "github.com/kijimaD/ruins/internal/gamelog"
      10              :         mapplanner "github.com/kijimaD/ruins/internal/mapplanner"
      11              :         "github.com/kijimaD/ruins/internal/raw"
      12              :         w "github.com/kijimaD/ruins/internal/world"
      13              :         "github.com/kijimaD/ruins/internal/world/lifecycle"
      14              :         "github.com/kijimaD/ruins/internal/world/query"
      15              :         "github.com/kijimaD/ruins/internal/worldstream"
      16              : )
      17              : 
      18              : // NewGameParams は新規オーバーワールド開始時のプレイ固有パラメータ。
      19              : // プレイごとに変わるのは RunSeed だけ。帯形状は OverworldDefinition マスタが持つ。
      20              : type NewGameParams struct {
      21              :         RunSeed uint64
      22              : }
      23              : 
      24              : // Driver はオーバーワールド帯の実行時状態と操作をまとめる。DungeonState が保持し委譲する。
      25              : // オーバーワールドとダンジョンの本質的な違いは「フロアを作り直さず帯をスライドさせ続ける」点だけで、
      26              : // その帯固有のロジックをこの Driver に閉じ込め、states パッケージから分離する。
      27              : type Driver struct {
      28              :         planner mapplanner.PlannerType
      29              :         // definition は帯形状の供給元。新規開始で使い、ロード復元では帯形状を SeamlessBand から得るので不要
      30              :         definition *dungeon.OverworldDefinition
      31              :         params     *NewGameParams // 新規開始のプレイ固有パラメータ。ロード復元では nil
      32              :         band       *worldstream.Band
      33              :         gen        worldstream.ChunkGen
      34              : }
      35              : 
      36              : // NewDriver は帯ドライバを構成する。params が非 nil なら新規開始、nil ならロード復元。
      37              : // definition は新規開始時の帯形状の供給元。ロード復元では帯形状を SeamlessBand から得るので nil でよい。
      38              : // 実際の帯生成・復元は Start で行う。
      39              : func NewDriver(planner mapplanner.PlannerType, definition *dungeon.OverworldDefinition, params *NewGameParams) *Driver {
      40            1 :         return &Driver{planner: planner, definition: definition, params: params}
      41            1 : }
      42              : 
      43              : // Start は帯ドライバを用意する。新規開始なら初期帯を生成し現ステージをオーバーワールドに
      44              : // 確定する。ロード復元なら SeamlessBand から Band と ChunkGen を作り直す。
      45              : func (dr *Driver) Start(world w.World) error {
      46            1 :         d := query.GetDungeon(world)
      47            1 : 
      48              :         // 視界の強制再計算は呼び出し側 DungeonState.OnStart が開始時にまとめて立てる。
      49              :         // オーバーワールドと通常ダンジョンで同じ扱いにするため、ここでは触らない。
      50              : 
      51              :         // 帯データは現ステージの StageField が持つ。ロード復元なら serde で戻っており、新規開始なら未生成で nil。
      52            1 :         sb := query.GetSeamlessBand(world)
      53            1 :         if sb != nil && sb.Active {
      54              :                 // ロード復元。CurrentStage は serde で復元済みなので触らない。帯データは
      55              :                 // オーバーワールドの StageField にしか無く、遺跡滞在中のセーブは現ステージが遺跡なので
      56              :                 // ここには到達しない。newResumeStateFactory が DungeonState を選ぶ。
      57            1 :                 if err := dr.restoreFromSave(world, sb); err != nil {
      58            0 :                         return err
      59            0 :                 }
      60              :         } else {
      61              :                 // 新規開始。オーバーワールドから始める。共存機構が現在地を識別するのに使う。
      62            1 :                 d.CurrentStage = gc.NewOverworldStage()
      63            1 :                 if err := dr.startInitialBand(world); err != nil {
      64            0 :                         return err
      65            0 :                 }
      66              :         }
      67              : 
      68            1 :         return nil
      69              : }
      70              : 
      71              : // restoreFromSave はセーブ済みの SeamlessBand から Band ドライバと ChunkGen を再構築する。
      72              : // 帯タイル・Level・プレイヤーは serde で復元済みなので再生成はしない。
      73              : func (dr *Driver) restoreFromSave(world w.World, sb *gc.SeamlessBand) error {
      74              :         // Rows がゼロ値なら1へ正規化して1行の帯として復元する
      75            1 :         rows := max(sb.Rows, 1)
      76            1 :         dr.band = worldstream.NewBandAt(sb.ChunkW, sb.ChunkH, sb.Cols, rows, sb.NorthIndex)
      77            1 :         dr.gen = NewChunkGen(world, sb.RunSeed, sb.ChunkW, sb.ChunkH, max(sb.Cols, 1), dr.planner)
      78            1 :         query.InvalidateSpatialIndex(world)
      79            1 :         return nil
      80            1 : }
      81              : 
      82              : // startInitialBand は新規開始として初期帯を決定的生成し、帯状態を SeamlessBand へ記録し、
      83              : // プレイヤーとキューブを中央チャンク付近へ置く。帯パラメータは params から取る。
      84              : //
      85              : // この関数は新規開始で一度だけ走る。セーブ復帰は Start が restoreFromSave の枝を選ぶのでここは走らず、
      86              : // プレイヤー・キューブ・全エンティティは serde で復元される。したがってここでの生成に復帰時の
      87              : // 二重生成対策は要らない。
      88              : func (dr *Driver) startInitialBand(world w.World) error {
      89            1 :         p := dr.params
      90            1 :         if p == nil {
      91            0 :                 return fmt.Errorf("starting a new overworld requires band parameters")
      92            0 :         }
      93            1 :         if dr.definition == nil {
      94            0 :                 return fmt.Errorf("starting a new overworld requires a band shape definition")
      95            0 :         }
      96              : 
      97              :         // 帯形状はマスタ、すなわち OverworldDefinition から取る。RunSeed だけがプレイ固有
      98            1 :         chunkW, chunkH, cols, rows := dr.definition.BandShape()
      99            1 :         dr.band = worldstream.NewBand(chunkW, chunkH, cols, rows)
     100            1 :         dr.gen = NewChunkGen(world, p.RunSeed, chunkW, chunkH, cols, dr.planner)
     101            1 : 
     102              :         // 帯データを現ステージ、すなわちオーバーワールドの StageField エンティティへ確保する。
     103              :         // 以後この帯データの有無がオーバーワールド判定を兼ねる。値を書き込んでセーブに対応する
     104            1 :         sb := query.EnsureSeamlessBand(world)
     105            1 :         sb.Active = true
     106            1 :         sb.RunSeed = p.RunSeed
     107            1 :         sb.NorthIndex = dr.band.NorthIndex()
     108            1 :         sb.ChunkW = chunkW
     109            1 :         sb.ChunkH = chunkH
     110            1 :         sb.Cols = dr.band.Cols()
     111            1 :         sb.Rows = dr.band.Rows()
     112            1 : 
     113              :         // 初期帯 = cols*chunkW × chunkH の単一マップを決定的生成する。探索履歴はStageField が持ち初期化済み
     114            1 :         if err := dr.generateBandChunks(world, chunkW, chunkH); err != nil {
     115            0 :                 return err
     116            0 :         }
     117              : 
     118              :         // プレイヤーを開始チャンクの真ん中に一番近い歩行可能タイルへ湧かせる。開始チャンクは墜落現場で、
     119              :         // 絵の真ん中を歩ける地面にしてある。居なければ生成、居れば移動
     120            1 :         start := spawnChunkOf(sb.Cols, sb.SpawnChunkY())
     121            1 :         center := consts.Coord[consts.Tile]{
     122            1 :                 X: start.X.Tiles(chunkW) + chunkW/2,
     123            1 :                 Y: start.Y.Tiles(chunkH) + chunkH/2,
     124            1 :         }
     125            1 :         spawn := walkableSpawnNear(world, center, nil)
     126            1 :         if _, err := query.GetPlayerEntity(world); err != nil {
     127            1 :                 name, perr := raw.PlayerMemberID(world.Resources.RawMaster)
     128            1 :                 if perr != nil {
     129            0 :                         return perr
     130            0 :                 }
     131            1 :                 if _, serr := lifecycle.SpawnPlayer(world, spawn, name); serr != nil {
     132            0 :                         return fmt.Errorf("failed to spawn player: %w", serr)
     133            0 :                 }
     134            1 :         } else if merr := lifecycle.MovePlayerToPosition(world, spawn); merr != nil {
     135            0 :                 return fmt.Errorf("failed to place player: %w", merr)
     136            0 :         }
     137              : 
     138              :         // 押せる移動拠点キューブをプレイヤー近くの歩行可能タイルへ1体置く
     139            1 :         cubePos := walkableSpawnNear(world, spawn.Add(consts.Coord[consts.Tile]{X: 2}), map[consts.Coord[consts.Tile]]bool{spawn: true})
     140            1 :         cube, cerr := lifecycle.SpawnCube(world, cubePos)
     141            1 :         if cerr != nil {
     142            0 :                 return fmt.Errorf("failed to spawn cube: %w", cerr)
     143            0 :         }
     144              :         // 展開すると貨物が現れる往復を最初から見せるため、既定の貨物を1つ畳んで入れておく
     145            1 :         if derr := lifecycle.StowDefaultCubeCargo(world, cube); derr != nil {
     146            0 :                 return fmt.Errorf("failed to stow default cube cargo: %w", derr)
     147            0 :         }
     148              : 
     149            1 :         query.InvalidateSpatialIndex(world)
     150            1 :         return nil
     151              : }
     152              : 
     153              : // walkableSpawnNear は center から外側のリングへ順に探し、BlockPass が無く taken にも無い最初のタイル座標を返す。
     154              : // キューブは BlockPass を持たないので、先に置いたプレイヤーやキューブの座標は taken で避ける。
     155              : // 開始チャンクが荒れ地でなく建物でも、プレイヤーを壁の中へ湧かせないための安全策。
     156              : // 帯は全域が dirt で埋まり歩行可能タイルが必ず近くにあるため、見つからなければ中央を返す。
     157              : func walkableSpawnNear(world w.World, center consts.Coord[consts.Tile], taken map[consts.Coord[consts.Tile]]bool) consts.Coord[consts.Tile] {
     158            1 :         blocked := make(map[gc.GridElement]bool)
     159            1 :         q := query.ActiveFilter2[gc.GridElement, gc.BlockPass](world).Query()
     160            1 :         for q.Next() {
     161            1 :                 blocked[*world.Components.GridElement.Get(q.Entity())] = true
     162            1 :         }
     163            1 :         x0, y0 := int(center.X), int(center.Y)
     164            1 :         at := func(x, y int) consts.Coord[consts.Tile] {
     165            1 :                 return consts.Coord[consts.Tile]{X: consts.Tile(x), Y: consts.Tile(y)}
     166            1 :         }
     167            2 :         isBlocked := func(x, y int) bool { return blocked[gc.GridElement{Coord: at(x, y)}] || taken[at(x, y)] }
     168            1 :         for r := range 100 {
     169            1 :                 for dy := -r; dy <= r; dy++ {
     170            1 :                         for dx := -r; dx <= r; dx++ {
     171              :                                 // リングの外周だけ見る。内側は前の r で確認済み
     172            1 :                                 if r > 0 && dx > -r && dx < r && dy > -r && dy < r {
     173            1 :                                         continue
     174              :                                 }
     175            1 :                                 if !isBlocked(x0+dx, y0+dy) {
     176            1 :                                         return at(x0+dx, y0+dy)
     177            1 :                                 }
     178              :                         }
     179              :                 }
     180              :         }
     181            0 :         return at(x0, y0)
     182              : }
     183              : 
     184              : // generateBandChunks は Level を帯全域に設定し、rows × K のチャンクを各スロットへ決定的生成する。
     185              : // Level 設定は帯寸法が不変なので再設定しても冪等で無害。
     186              : func (dr *Driver) generateBandChunks(world w.World, chunkW, chunkH consts.Tile) error {
     187            1 :         overworldKey := gc.NewOverworldStage()
     188            1 :         field := query.EnsureStageField(world, overworldKey)
     189            1 :         field.Level = gc.Level{TileWidth: dr.band.Width(), TileHeight: dr.band.Height()}
     190            1 :         field.BaseTemp = dungeon.BaseTemperatureFor(world.Resources.RawMaster, overworldKey.Name)
     191            1 :         for cy := range dr.band.Rows() {
     192            1 :                 for i := range dr.band.Cols() {
     193              :                         // X は有界なので絶対チャンク列はそのまま i。Y は北進ぶん負へずらした絶対チャンク行
     194            1 :                         c := consts.Coord[consts.Chunk]{X: i, Y: cy - dr.band.NorthIndex()}
     195            1 :                         if err := dr.gen(c, i.Tiles(chunkW), cy.Tiles(chunkH)); err != nil {
     196            0 :                                 return fmt.Errorf("failed to generate chunk (x=%d, y=%d): %w", c.X, c.Y, err)
     197            0 :                         }
     198              :                 }
     199              :         }
     200            1 :         return nil
     201              : }
     202              : 
     203              : // NorthIndex は帯の現在の北インデックスを返す。テストや検証用。
     204              : func (dr *Driver) NorthIndex() consts.Chunk {
     205            1 :         return dr.band.NorthIndex()
     206            1 : }
     207              : 
     208              : // MaybeShift はプレイヤーが中央チャンクを出ていれば帯をシフトし、シフトしたかを返す。
     209              : // シフトするとリベースでプレイヤーが中央へ動くため、呼び出し側はカメラを再センタリングする。
     210              : //
     211              : // 座標を平行移動する破壊的操作なので、ターンが完全に解決した安定点でのみ行う。すなわち
     212              : // プレイヤーターンの Player フェーズかつプレイヤーが継続アクティビティ中でないとき。
     213              : func (dr *Driver) MaybeShift(world w.World) (bool, error) {
     214            1 :         if query.GetTurnState(world).Phase != gc.TurnPhasePlayer {
     215            0 :                 return false, nil
     216            0 :         }
     217            1 :         playerEntity, err := query.GetPlayerEntity(world)
     218            1 :         if err != nil {
     219            0 :                 return false, fmt.Errorf("shift check requires a player: %w", err)
     220            0 :         }
     221            1 :         if query.HasActivity(world, playerEntity) {
     222            0 :                 return false, nil
     223            0 :         }
     224              :         // 中央チャンクに収まるまでシフトを繰り返す。各シフトはプレイヤーを chunkH ぶん中央へ寄せるため、
     225              :         // 必ず有限回で収束する。
     226            1 :         shifted := false
     227            1 :         for {
     228            1 :                 localY := world.Components.GridElement.Get(playerEntity).Y
     229            1 :                 if dr.band.ShouldShiftNorth(localY) {
     230            1 :                         if err := dr.band.ShiftNorth(world, dr.gen); err != nil {
     231            0 :                                 return shifted, err
     232            0 :                         }
     233            1 :                         shifted = true
     234            1 :                         continue
     235              :                 }
     236              :                 // 南シフトはしない。帯は北へのみ進み破棄済みチャンクを再生成しないので、
     237              :                 // 到達した最南端より南へは戻れない。後戻り不可はこの北進だけで保つ
     238            1 :                 break
     239              :         }
     240            1 :         if shifted {
     241              :                 // Band の最終 northIndex を永続状態へ書き戻す。セーブに要るのは最終値だけなので、
     242              :                 // シフトのたびでなくループを抜けてから一度だけ同期する
     243            1 :                 query.GetSeamlessBand(world).NorthIndex = dr.band.NorthIndex()
     244            1 :                 dr.warnStrandedCube(world)
     245            1 :         }
     246            1 :         return shifted, nil
     247              : }
     248              : 
     249              : // warnStrandedCube は次の北シフトで破棄される南端の行にキューブがあればログで警告する。
     250              : func (dr *Driver) warnStrandedCube(world w.World) {
     251            1 :         for _, tile := range query.CubeTiles(world) {
     252            1 :                 if dr.band.InSouthRow(tile.Y) {
     253            1 :                         gamelog.New(query.GetGameLog(world)).
     254            1 :                                 Markup(query.T(world, "The cube is too far behind. Go further north and it will be left behind.")).
     255            1 :                                 Log()
     256            1 :                         return
     257            1 :                 }
     258              :         }
     259              : }
        

Generated by: LCOV version 2.0-1