LCOV - code coverage report
Current view: top level - states - dungeon_floor.go Coverage Total Hit
Test: coverage.lcov Lines: 68.6 % 245 168
Test Date: 2026-11-19 00:25:22 Functions: - 0 0

            Line data    Source code
       1              : package states
       2              : 
       3              : import (
       4              :         "fmt"
       5              :         "math/rand/v2"
       6              :         "slices"
       7              : 
       8              :         gc "github.com/kijimaD/ruins/internal/components"
       9              :         "github.com/kijimaD/ruins/internal/consts"
      10              :         "github.com/kijimaD/ruins/internal/dungeon"
      11              :         mapplanner "github.com/kijimaD/ruins/internal/mapplanner"
      12              :         "github.com/kijimaD/ruins/internal/mapspawner"
      13              :         w "github.com/kijimaD/ruins/internal/world"
      14              :         "github.com/kijimaD/ruins/internal/world/lifecycle"
      15              :         "github.com/kijimaD/ruins/internal/world/query"
      16              :         "github.com/kijimaD/ruins/internal/world/stage"
      17              :         "github.com/mlange-42/ark/ecs"
      18              : )
      19              : 
      20              : // ダンジョンのフロア生成・階層遷移・ポータル配線を dungeon.go から分離する。
      21              : // DungeonState のメソッドはこのファイルにも置く。
      22              : 
      23              : // resolveDungeonDefinition は名前から通常ダンジョン定義を引く。未登録、またはオーバーワールドのような
      24              : // フロアを生成しない定義なら error を返す。フロア生成の入口を1箇所に集約する。
      25              : func resolveDungeonDefinition(world w.World, defName string) (*dungeon.DungeonDefinition, error) {
      26            1 :         def, found := dungeon.GetStageDefinition(world.Resources.RawMaster, defName)
      27            1 :         if !found {
      28            0 :                 return nil, fmt.Errorf("stage definition not found: %s", defName)
      29            0 :         }
      30            1 :         dk, ok := def.(*dungeon.DungeonDefinition)
      31            1 :         if !ok {
      32            0 :                 return nil, fmt.Errorf("stage definition cannot generate a floor: %s", defName)
      33            0 :         }
      34            1 :         return dk, nil
      35              : }
      36              : 
      37              : // dungeonStageKey は遺跡名と深度でダンジョン階のステージキーを返す。
      38              : // 遺跡はオーバーワールドの入口から名前付きで入り、複数の遺跡が同一 world に共存しうる。
      39              : // よって階のキーは遺跡名で区別する必要がある。enterDungeon が焼く入口(1階)のキーと
      40              : // descend が作る深い階のキーをこの関数で揃え、上り階段の結線が正しい階を指すようにする。
      41              : func dungeonStageKey(defName string, depth int) gc.StageKey {
      42            1 :         return gc.NewDungeonStage(defName, depth)
      43            1 : }
      44              : 
      45              : // spawnFloor は depth のフロアを生成して world に配置し、生成物に StageBound を付ける。
      46              : // プレイヤー開始位置と、開始位置に置いた上り階段エンティティを返す。上り階段には呼び出し側が
      47              : // 戻り先を結線する。プレイヤー配置・探索リセット・現ステージ更新は呼び出し側が行う
      48              : func (st *DungeonState) spawnFloor(world w.World, depth int, def *dungeon.DungeonDefinition, key gc.StageKey) (consts.Coord[consts.Tile], ecs.Entity, error) {
      49            1 :         var zero consts.Coord[consts.Tile]
      50            1 :         var noEntity ecs.Entity
      51            1 : 
      52            1 :         stageSeed := world.Resources.Config.RNG.Uint64()
      53            1 :         stageRNG := rand.New(rand.NewPCG(stageSeed, 0))
      54            1 : 
      55              :         // ビルダータイプを決定する
      56            1 :         var builderType mapplanner.PlannerType
      57            1 :         switch {
      58              :         case st.BuilderType.PlannerFunc == nil || st.BuilderType.Name == mapplanner.PlannerTypeRandom.Name:
      59              :                 // BuilderType 未設定(オーバーワールドから遺跡へ入った State は帯用で BuilderType を
      60              :                 // 持たない)か Random なら、定義のプランナープールから選ぶ。ゼロ値をそのまま使うと
      61              :                 // PlannerFunc が nil で生成が panic する
      62            1 :                 var err error
      63            1 :                 builderType, err = def.SelectPlanner(stageRNG)
      64            1 :                 if err != nil {
      65            0 :                         return zero, noEntity, err
      66            0 :                 }
      67              :         default:
      68            1 :                 builderType = st.BuilderType
      69              :         }
      70              : 
      71              :         // テーブル名と危険度をプランナーに渡す。エントリの解決はプランナーが行う。
      72              :         // 危険度は最初のフロア生成時に確定して全階で共有する。階に依らず同じ。
      73            1 :         builderType.EnemyTableName = def.EnemyTableName()
      74            1 :         builderType.ItemTableName = def.ItemTableName()
      75            1 :         builderType.EnemyCount = def.EnemyCount()
      76            1 :         builderType.ItemCount = def.ItemCount()
      77            1 :         builderType.Ground = def.Ground()
      78            1 :         // 危険度は enterDungeonWith が入口深度込みで確定し全階で共有する。未設定のデバッグ経路だけ日数版で補う
      79            1 :         if st.Danger == 0 {
      80            1 :                 st.Danger = query.DangerLevelAt(world)
      81            1 :         }
      82            1 :         builderType.Danger = st.Danger
      83            1 : 
      84            1 :         plan, err := mapplanner.Plan(world, consts.MapTileWidth, consts.MapTileHeight, stageSeed, builderType)
      85            1 :         if err != nil {
      86            0 :                 return zero, noEntity, err
      87            0 :         }
      88            1 :         level, err := mapspawner.Spawn(world, plan)
      89            1 :         if err != nil {
      90            0 :                 return zero, noEntity, err
      91            0 :         }
      92              :         // フィールド寸法と基本気温をこの階のStageFieldへ記録する。生成物と同じ明示 key に束縛するため、
      93              :         // SwapTo が CurrentStage を最後に更新する順序に依存しない
      94            1 :         field := query.EnsureStageField(world, key)
      95            1 :         field.Level = level
      96            1 :         field.BaseTemp = def.BaseTemperature()
      97            1 : 
      98            1 :         start, err := plan.GetPlayerStartPosition()
      99            1 :         if err != nil {
     100            0 :                 return zero, noEntity, err
     101            0 :         }
     102              : 
     103              :         // 上り階段を開始位置に置く。降りてきた場所が、上りで戻ってくる場所になる。
     104              :         // 最上階(floor 1)では上り階段がダンジョン脱出口を兼ねる。町(depth 0)には置かない
     105            1 :         var upStair ecs.Entity
     106            1 :         if depth > 0 {
     107            1 :                 e, err := lifecycle.SpawnProp(world, "warp_prev", start.X, start.Y)
     108            1 :                 if err != nil {
     109            0 :                         return zero, noEntity, err
     110            0 :                 }
     111            1 :                 upStair = e
     112              :         }
     113              : 
     114              :         // デバッグの街ステージには長く燃える火を hearth の上へ自動設置する。適温を確保して睡眠を入ってすぐ試せる。
     115              :         // 火の燃える残りは実行時の状態で raw に書けないので、ここで付ける
     116            1 :         if def.Name() == dungeon.DebugTownID {
     117            0 :                 if err := spawnDebugStageFire(world); err != nil {
     118            0 :                         return zero, noEntity, err
     119            0 :                 }
     120              :         }
     121              : 
     122              :         // 生成物(上り階段を含む)をこのステージへ束縛して識別できるようにする
     123            1 :         stage.Bind(world, key)
     124            1 : 
     125            1 :         return start, upStair, nil
     126              : }
     127              : 
     128              : // debugStageFireBurnTurns はデバッグ街の火が燃え続けるターン数。睡眠テスト中に消えない長さにする
     129              : const debugStageFireBurnTurns = 10000
     130              : 
     131              : // spawnDebugStageFire はテンプレートが置いた hearth の上へ長く燃える火を置く。
     132              : // 石組の中で火を焚く見た目になり、本番の着火と同じく fire prop へ Burning を付ける。
     133              : // hearth が無ければ何もしない
     134              : func spawnDebugStageFire(world w.World) error {
     135            0 :         var coord consts.Coord[consts.Tile]
     136            0 :         found := false
     137            0 :         q := query.ActiveFilter2[gc.RawID, gc.GridElement](world).Query()
     138            0 :         for q.Next() {
     139            0 :                 e := q.Entity()
     140            0 :                 if world.Components.RawID.Get(e).ID == "hearth" {
     141            0 :                         coord = world.Components.GridElement.Get(e).Coord
     142            0 :                         found = true
     143            0 :                         q.Close()
     144            0 :                         break
     145              :                 }
     146              :         }
     147            0 :         if !found {
     148            0 :                 return nil
     149            0 :         }
     150            0 :         fire, err := lifecycle.SpawnProp(world, "fire", coord.X, coord.Y)
     151            0 :         if err != nil {
     152            0 :                 return fmt.Errorf("failed to spawn debug stage fire: %w", err)
     153            0 :         }
     154            0 :         world.Components.Burning.Add(fire, &gc.Burning{Remaining: debugStageFireBurnTurns})
     155            0 :         return nil
     156              : }
     157              : 
     158              : // descend は1つ下の階へ swapTo で移動する。現階を退避し、未訪問なら生成、訪問済みなら再稼働する。
     159              : // TransPush で新ステートを積むのでなく、同一 State 内で現階と入れ替えるのが共存方式の要点
     160              : func (st *DungeonState) descend(world w.World) error {
     161              :         // 今いる遺跡の定義名は現ステージのキーから導出する
     162            1 :         defName := query.GetDungeon(world).CurrentStage.Name
     163            1 :         fromStage := dungeonStageKey(defName, st.Depth)
     164            1 :         // 現階の下り階段の位置。生成する階の上り階段の戻り先として結線する
     165            1 :         fromDownStairPos, hasDownStair := findPortalPosition(world, gc.InteractionPortalNext)
     166            1 : 
     167            1 :         nextDepth := st.Depth + 1
     168            1 :         target := dungeonStageKey(defName, nextDepth)
     169            1 : 
     170              :         // 生成は swapTo の callback で行う。未訪問のときだけ呼ばれる。
     171              :         // def 参照も生成時だけに閉じ、訪問済みの再稼働では不要にする
     172            1 :         var playerPos consts.Coord[consts.Tile]
     173            1 :         var generated bool
     174            1 :         if err := stage.SwapTo(world, target, func(world w.World, key gc.StageKey) error {
     175            1 :                 def, err := resolveDungeonDefinition(world, defName)
     176            1 :                 if err != nil {
     177            0 :                         return err
     178            0 :                 }
     179            1 :                 start, upStair, err := st.spawnFloor(world, nextDepth, def, key)
     180            1 :                 if err != nil {
     181            0 :                         return err
     182            0 :                 }
     183              :                 // 生成した階の上り階段に、降りてきた元階の下り階段への戻り先を焼く。
     184              :                 // これで ascend は探索なしに戻り先ステージと座標を引ける
     185            1 :                 if hasDownStair {
     186            1 :                         if cerr := setPortalConnection(world, upStair, fromStage, fromDownStairPos); cerr != nil {
     187            0 :                                 return cerr
     188            0 :                         }
     189              :                 }
     190            1 :                 playerPos = start
     191            1 :                 generated = true
     192            1 :                 return nil
     193              :         }); err != nil {
     194            0 :                 return err
     195            0 :         }
     196              : 
     197            1 :         st.Depth = nextDepth
     198            1 : 
     199              :         // 生成フロアは開始位置(=上り階段の位置)へ。訪問済みフロアの再訪は
     200              :         // そのフロアの上り階段、すなわち降りてくる側の位置へ戻す
     201            1 :         if generated {
     202            1 :                 return lifecycle.MovePlayerToPosition(world, playerPos)
     203            1 :         }
     204            1 :         pos, ok := findPortalPosition(world, gc.InteractionPortalPrev)
     205            1 :         if !ok {
     206              :                 // 訪問済みの階には必ず上り階段があるはず。無ければステージ切替済みで
     207              :                 // プレイヤーが元座標に取り残されるので、silent にせず error にする
     208            0 :                 return fmt.Errorf("no up stairs found on revisited floor: depth %d", nextDepth)
     209            0 :         }
     210            1 :         return lifecycle.MovePlayerToPosition(world, pos)
     211              : }
     212              : 
     213              : // findPortal は現ステージの指定種別ポータルのエンティティと位置を返す。
     214              : // 退避中ステージのポータルは ActiveFilter で除外される。先着1件を採用するが、途中 return せず
     215              : // 反復は最後まで続ける。Ark のワールドロックを外すため。実ゲームでは各ステージにポータルは
     216              : // 1つなので先着で一意に定まる
     217              : func findPortal(world w.World, kind gc.InteractionKind) (ecs.Entity, consts.Coord[consts.Tile], bool) {
     218            1 :         var found ecs.Entity
     219            1 :         var pos consts.Coord[consts.Tile]
     220            1 :         ok := false
     221            1 :         q := query.ActiveFilter2[gc.Interactable, gc.GridElement](world).Query()
     222            1 :         for q.Next() {
     223            1 :                 e := q.Entity()
     224            1 :                 if !ok && slices.Contains(world.Components.Interactable.Get(e).Interactions, kind) {
     225            1 :                         found = e
     226            1 :                         pos = world.Components.GridElement.Get(e).Coord
     227            1 :                         ok = true
     228            1 :                 }
     229              :         }
     230            1 :         return found, pos, ok
     231              : }
     232              : 
     233              : // findPortalPosition は findPortal のうち位置だけを返す薄いラッパー。
     234              : func findPortalPosition(world w.World, kind gc.InteractionKind) (consts.Coord[consts.Tile], bool) {
     235            1 :         _, pos, ok := findPortal(world, kind)
     236            1 :         return pos, ok
     237            1 : }
     238              : 
     239              : // setPortalConnection はポータルに行き先ステージと着地座標を結線する。
     240              : // 生成時に両端を結線し、以降の往復は探索でなくこの結線から行き先を引く。
     241              : func setPortalConnection(world w.World, portal ecs.Entity, target gc.StageKey, coord consts.Coord[consts.Tile]) error {
     242            1 :         return gc.Upsert(world.ECS, world.Components.PortalConnection, portal, &gc.PortalConnection{Stage: target, Coord: coord})
     243            1 : }
     244              : 
     245              : // ascend は現階の上り階段の結線した戻り先へ swapTo で移動する。上り先は訪問済み前提で再稼働する。
     246              : // 戻り先ステージと着地座標は生成時に上り階段へ結線済みなので、探索でなく結線から引く。
     247              : // 上り階段の結線があれば移動して true を返す。結線が無い、たとえば最上階の脱出口なら false を
     248              : // 返し、街やオーバーワールドへの脱出は呼び出し側が扱う。上り先が浅い階でも遺跡→地上でも同一機構。
     249              : func (st *DungeonState) ascend(world w.World) (bool, error) {
     250              :         // 現階の上り階段。生成時に戻り先が結線されている
     251            1 :         upStair, _, ok := findPortal(world, gc.InteractionPortalPrev)
     252            1 :         if !ok {
     253            0 :                 return false, nil
     254            0 :         }
     255            1 :         if !world.Components.PortalConnection.Has(upStair) {
     256              :                 // 結線なし。最上階の脱出口。呼び出し側が脱出を扱う
     257            0 :                 return false, nil
     258            0 :         }
     259              :         // 行き先を値でコピーする。swapTo が Suspended を付けてアーキタイプが変わると
     260              :         // コンポーネントポインタは無効化されるため、構造変更の前に取り出す
     261            1 :         conn := *world.Components.PortalConnection.Get(upStair)
     262            1 :         target := conn.Stage
     263            1 : 
     264              :         // 上り先は訪問済み前提。未訪問なら生成でなくエラーにする
     265            1 :         if err := stage.SwapTo(world, target, func(_ w.World, _ gc.StageKey) error {
     266            0 :                 return fmt.Errorf("destination floor above does not exist: %+v", target)
     267            0 :         }); err != nil {
     268            0 :                 return false, err
     269            0 :         }
     270              : 
     271            1 :         st.Depth = target.Depth
     272            1 :         // SwapTo 後は現ステージ=target なので現在地で判定する
     273            1 :         if query.IsOnOverworld(world) {
     274              :                 // 地上の StageField が resume で帯寸法の Level を戻すため寸法の手復元は不要。視界だけ強制再計算する
     275            1 :                 query.GetVisionState(world).RequestUpdate()
     276            1 :         }
     277              : 
     278            1 :         if err := lifecycle.MovePlayerToPosition(world, conn.Coord); err != nil {
     279            0 :                 return false, err
     280            0 :         }
     281            1 :         return true, nil
     282              : }
     283              : 
     284              : // enterDungeon はオーバーワールドから遺跡へ入る。現在地(入口座標)を上り階段へ結線して戻れるようにする。
     285              : // descend の遺跡版で、行き先が1つ深い階でなく遺跡1階になる。
     286              : func (st *DungeonState) enterDungeon(world w.World, defName string) error {
     287              :         // プランナーは遺跡定義のプールから選ぶ。Random を渡すと spawnFloor がプール抽選へ回す
     288            1 :         return st.enterDungeonWith(world, defName, mapplanner.PlannerTypeRandom)
     289            1 : }
     290              : 
     291              : // enterDungeonWith はプランナーを固定して遺跡へ入る。デバッグのプランナー単位進入で使う。
     292              : // builderType が Random または PlannerFunc 未設定なら spawnFloor が遺跡定義のプールから選ぶ。
     293              : // それ以外は指定プランナーで生成する。共存機構の往復は enterDungeon と同じ。
     294              : func (st *DungeonState) enterDungeonWith(world w.World, defName string, builderType mapplanner.PlannerType) error {
     295              :         // spawnFloor は st.BuilderType を読んでプランナーを決める。ここで進入ごとに確定する
     296            1 :         st.BuilderType = builderType
     297            1 : 
     298            1 :         fromStage := query.GetDungeon(world).CurrentStage
     299            1 :         player, err := query.GetPlayerEntity(world)
     300            1 :         if err != nil {
     301            0 :                 return err
     302            0 :         }
     303              :         // 入口のオーバーワールド座標。swapTo 前に値でコピーする
     304            1 :         fromPos := world.Components.GridElement.Get(player).Coord
     305            1 : 
     306              :         // 危険度は入口の北進度と日数の高い方で進入ごとに引き直し全階で共有する。swapTo 前の入口座標 fromPos から引く
     307            1 :         st.Danger = query.DangerLevelAt(world)
     308            1 :         if sb := query.GetSeamlessBand(world); sb != nil {
     309            1 :                 if d := query.DangerLevelForDepth(consts.NorthDepth(sb.SpawnChunkY(), sb.AbsChunkRow(fromPos.Y))); d > st.Danger {
     310            1 :                         st.Danger = d
     311            1 :                 }
     312              :         }
     313              : 
     314            1 :         target := gc.NewDungeonStage(defName, 1)
     315            1 :         // 既にその遺跡1階にいるなら自己スワップになるので何もしない。デバッグ進入で
     316              :         // 今いる遺跡を選んだ場合など。SwapTo は自己スワップを前提としない
     317            1 :         if fromStage == target {
     318            1 :                 return nil
     319            1 :         }
     320              : 
     321            1 :         var landing consts.Coord[consts.Tile]
     322            1 :         var generated bool
     323            1 :         if err := stage.SwapTo(world, target, func(world w.World, key gc.StageKey) error {
     324            1 :                 def, derr := resolveDungeonDefinition(world, defName)
     325            1 :                 if derr != nil {
     326            0 :                         return derr
     327            0 :                 }
     328            1 :                 start, upStair, serr := st.spawnFloor(world, 1, def, key)
     329            1 :                 if serr != nil {
     330            0 :                         return serr
     331            0 :                 }
     332              :                 // 遺跡の上り階段(=出口)に、入ってきたオーバーワールドの入口座標を結線する。
     333              :                 // これで exit は入った入口へ正確に戻れる。入口が複数でも曖昧にならない
     334            1 :                 if cerr := setPortalConnection(world, upStair, fromStage, fromPos); cerr != nil {
     335            0 :                         return cerr
     336            0 :                 }
     337            1 :                 landing = start
     338            1 :                 generated = true
     339            1 :                 return nil
     340              :         }); err != nil {
     341            0 :                 return err
     342            0 :         }
     343              : 
     344            1 :         st.Depth = 1
     345            1 :         // 現ステージ=遺跡1階のキーが定義名を持つため、別途 DefinitionName を記録する必要はない
     346              : 
     347            1 :         if generated {
     348            1 :                 return lifecycle.MovePlayerToPosition(world, landing)
     349            1 :         }
     350              :         // 再訪。遺跡の上り階段(入口)へ戻す。訪問済みなら必ず存在するはず。
     351              :         // 無ければプレイヤーが元座標に取り残されるので silent にせず error にする
     352            0 :         pos, ok := findPortalPosition(world, gc.InteractionPortalPrev)
     353            0 :         if !ok {
     354            0 :                 return fmt.Errorf("no up stairs found in revisited ruins: %s", defName)
     355            0 :         }
     356            0 :         return lifecycle.MovePlayerToPosition(world, pos)
     357              : }
     358              : 
     359              : // enterDebugPlannerFloor はデバッグ遺跡1階を指定プランナーで毎回作り直して入る。
     360              : //
     361              : // 共存方式では StageKey が永続し、再訪時 SwapTo は再生成せず既存ステージを resume する。
     362              : // プランナーを変えて見た目を試すこの用途では、それだと最初に作った階が resume され続けて
     363              : // 変わらない。そこで既存の階を Purge してから作り直す。現在地がその遺跡かどうかで分岐する。
     364              : func (st *DungeonState) enterDebugPlannerFloor(world w.World, defName string, builderType mapplanner.PlannerType) error {
     365              :         // spawnFloor は st.BuilderType を読む。自己スワップ経路でも効くよう先に確定する
     366            1 :         st.BuilderType = builderType
     367            1 :         st.Depth = 1
     368            1 : 
     369            1 :         target := gc.NewDungeonStage(defName, 1)
     370            1 :         from := query.GetDungeon(world).CurrentStage
     371            1 : 
     372            1 :         if from != target {
     373              :                 // 他ステージから入る。既存のデバッグ階を消してから通常の進入経路に載せる。
     374              :                 // Purge 済みなので SwapTo は resume でなく generate を通り、新プランナーで作り直す
     375            1 :                 stage.Purge(world, target)
     376            1 :                 return st.enterDungeonWith(world, defName, builderType)
     377            1 :         }
     378              : 
     379              :         // 既にその遺跡にいる。SwapTo は自己スワップを前提としないので、その場で作り直す。
     380              :         // 上り階段の戻り先結線を引き継がないと ascend が結線なしで失敗するため、Purge 前に控える
     381            1 :         def, err := resolveDungeonDefinition(world, defName)
     382            1 :         if err != nil {
     383            0 :                 return err
     384            0 :         }
     385            1 :         var carriedBack *gc.PortalConnection
     386            1 :         if up, _, ok := findPortal(world, gc.InteractionPortalPrev); ok && world.Components.PortalConnection.Has(up) {
     387            1 :                 conn := *world.Components.PortalConnection.Get(up)
     388            1 :                 carriedBack = &conn
     389            1 :         }
     390              : 
     391            1 :         stage.Purge(world, target)
     392            1 :         landing, upStair, err := st.spawnFloor(world, 1, def, target)
     393            1 :         if err != nil {
     394            0 :                 return err
     395            0 :         }
     396              :         // 控えた戻り先を新しい上り階段へ移す。これで作り直しても元の階へ ascend できる
     397            1 :         if carriedBack != nil {
     398            1 :                 if cerr := setPortalConnection(world, upStair, carriedBack.Stage, carriedBack.Coord); cerr != nil {
     399            0 :                         return cerr
     400            0 :                 }
     401              :         }
     402            1 :         stage.ResetExploredTiles(world)
     403            1 :         query.InvalidateSpatialIndex(world)
     404            1 :         return lifecycle.MovePlayerToPosition(world, landing)
     405              : }
        

Generated by: LCOV version 2.0-1