LCOV - code coverage report
Current view: top level - systems - turn_system.go Coverage Total Hit
Test: coverage.lcov Lines: 85.2 % 149 127
Test Date: 2026-11-19 00:25:22 Functions: - 0 0

            Line data    Source code
       1              : package systems
       2              : 
       3              : import (
       4              :         "context"
       5              :         "runtime/trace"
       6              :         "strconv"
       7              : 
       8              :         "github.com/kijimaD/ruins/internal/activity"
       9              :         "github.com/kijimaD/ruins/internal/aiinput"
      10              :         gc "github.com/kijimaD/ruins/internal/components"
      11              :         "github.com/kijimaD/ruins/internal/consts"
      12              :         "github.com/kijimaD/ruins/internal/gamelog"
      13              :         "github.com/kijimaD/ruins/internal/logger"
      14              :         w "github.com/kijimaD/ruins/internal/world"
      15              : 
      16              :         "github.com/kijimaD/ruins/internal/world/query"
      17              : )
      18              : 
      19              : // TurnSystem はターン管理を行うシステム。
      20              : //
      21              : // 1ゲームターンは Player → AI → End の3フェーズで進む。Update は毎フレーム1回呼ばれ、
      22              : // 通常は1回につき1フェーズだけ進めるので、1ターン = 3フレームで消化される。
      23              : //
      24              : //      Player: プレイヤーの行動。入力を待つか、継続アクティビティを1ステップ進める
      25              : //      AI:     敵・NPC を一括処理し、視界の再計算を要求する
      26              : //      End:    AP回復・空腹・気温・GameTime を1ターン進める
      27              : //
      28              : // 継続アクティビティ中(押し・休息・分解など)は例外で、fastForwardActivity が完了・中断・
      29              : // 上限まで1フレーム内で複数ターンをまとめて回す。各ターンは通常と同じ3ステップを通すので、
      30              : // 敵・時間の進行も毎ターンの中断判定も保たれ、ゲーム上の結果は1フレーム1ターンと変わらない。
      31              : // 縮むのは実時間で、省かれるのは途中ターンの描画だけ。継続中の入力は DungeonState が
      32              : // HasActivity で塞ぐため、フェーズが Player のままでも操作は受け付けない。
      33              : type TurnSystem struct{}
      34              : 
      35              : // String はシステム名を返す
      36              : // w.Updater interfaceを実装
      37              : func (sys TurnSystem) String() string {
      38            1 :         return "TurnSystem"
      39            1 : }
      40              : 
      41              : // fastForwardTurnsPerFrame は継続アクティビティ中に1フレームで進めるターン数。
      42              : // 通常プレイは1ターン=3フレームなので、この値ぶんを毎フレーム進めると通常の約3倍速で流れる。
      43              : // あえて小さく保ち、押し・休息・分解・睡眠のいずれも所要実時間がターン数に比例するようにする。
      44              : // 時計・日付・疲労バーが動くのが見え、長い作業ほど長くかかるのでコストが体感できる。値を大きくすると
      45              : // 数フレームで焼き切れて経過が一瞬に潰れ、コストが分からなくなる。1フレームで消化しきれない分は
      46              : // 次フレームへ持ち越す。継続中の入力は DungeonState が HasActivity で塞ぐ。
      47              : // この値では過労気味の睡眠 約530ターンで約3秒、短い押しや分解は一瞬で終わる。
      48              : const fastForwardTurnsPerFrame = 3
      49              : 
      50              : // Update はターン管理を行う
      51              : // w.Updater interfaceを実装
      52              : func (sys *TurnSystem) Update(world w.World) error {
      53            1 :         turnState := query.GetTurnState(world)
      54            1 : 
      55            1 :         switch turnState.Phase {
      56              :         case gc.TurnPhasePlayer:
      57              :                 // プレイヤーが継続アクション中なら、実時間を食わないよう複数ターンを一気に進める。
      58              :                 // 各ターンは通常と同じ 継続ステップ→AI→終了 を回すので、敵・NPC・時間は同じ速さで進み、
      59              :                 // 敵接近などによる毎ターンの中断判定も保たれる。縮むのは実時間だけ。
      60            1 :                 if playerHasActivity(world) {
      61            1 :                         return sys.fastForwardActivity(world, turnState)
      62            1 :                 }
      63              :                 // APが最小行動コストを満たさない場合は自動でターンを終了
      64            1 :                 if shouldAutoEndTurn(world) {
      65            1 :                         turnState.Phase = gc.TurnPhaseAI
      66            1 :                         return nil
      67            1 :                 }
      68              :                 // プレイヤー入力処理はDungeonStateで実行される
      69              :         case gc.TurnPhaseAI:
      70            1 :                 if err := runAIPhase(world); err != nil {
      71            0 :                         return err
      72            0 :                 }
      73            1 :                 turnState.Phase = gc.TurnPhaseEnd
      74              :         case gc.TurnPhaseEnd:
      75            1 :                 if err := runEndPhase(world, turnState); err != nil {
      76            0 :                         return err
      77            0 :                 }
      78            1 :                 turnState.Phase = gc.TurnPhasePlayer
      79              :         }
      80            1 :         return nil
      81              : }
      82              : 
      83              : // fastForwardActivity はプレイヤーの継続アクティビティを、完了・中断・上限まで1フレーム内で
      84              : // 複数ターン進める。1ターンは通常フローと同じ 継続ステップ→AI→ターン終了 を回すので、
      85              : // ゲーム上の結果は1フレーム1ターンで進めた場合と変わらず、縮むのは実時間だけ。
      86              : func (sys *TurnSystem) fastForwardActivity(world w.World, turnState *gc.TurnState) error {
      87              :         // fast-forward は1フレームで複数ターン回すので、turn:AI / turn:End が1つの TurnSystem region に連なる
      88            1 :         for range fastForwardTurnsPerFrame {
      89            1 :                 if !playerHasActivity(world) {
      90            1 :                         break // 完了・中断したら通常進行へ戻す
      91              :                 }
      92            1 :                 if _, err := processPlayerContinuousActivity(world); err != nil {
      93            0 :                         return err
      94            0 :                 }
      95            1 :                 if err := runAIPhase(world); err != nil {
      96            0 :                         return err
      97            0 :                 }
      98            1 :                 if err := runEndPhase(world, turnState); err != nil {
      99            0 :                         return err
     100            0 :                 }
     101              :         }
     102              :         // フェーズは Player のまま。継続中なら次フレームで続きを、完了なら通常の入力待ちへ。
     103              :         // 継続中の入力は DungeonState が HasActivity で塞ぐのでフェーズが Player でも受け付けない。
     104            1 :         turnState.Phase = gc.TurnPhasePlayer
     105            1 :         return nil
     106              : }
     107              : 
     108              : // runAIPhase は全AI・NPCを一括処理し、視界の再計算を要求する。
     109              : func runAIPhase(world w.World) error {
     110            1 :         region := trace.StartRegion(context.Background(), "turn:AI")
     111            1 :         defer region.End()
     112            1 : 
     113              :         // AIターン: 全AI・NPCを一括処理
     114            1 :         if err := processAITurn(world); err != nil {
     115            0 :                 return err
     116            0 :         }
     117              :         // AIターン完了後に視界を再計算させる
     118            1 :         query.GetVisionState(world).RequestUpdate()
     119            1 :         return nil
     120              : }
     121              : 
     122              : // runEndPhase はturn end processingをして1ゲームターンを確定させる。
     123              : func runEndPhase(world w.World, turnState *gc.TurnState) error {
     124            1 :         region := trace.StartRegion(context.Background(), "turn:End")
     125            1 :         defer region.End()
     126            1 : 
     127            1 :         if err := processTurnEnd(world); err != nil {
     128            0 :                 return err
     129            0 :         }
     130              :         // 空間インデックスを無効化する。次ターンで再構築される
     131            1 :         query.InvalidateSpatialIndex(world)
     132            1 :         turnState.TurnNumber++
     133            1 :         // ターン確定はこの1点なので、ここでトレースへ番号を刻む
     134            1 :         trace.Log(context.Background(), "turn", strconv.Itoa(int(turnState.TurnNumber)))
     135            1 :         // ゲーム内時間を1ターン進める。昼夜・気温の時間修正がこれに依存する。
     136              :         // GameTime は Dungeon 内で永続なのでセーブ/ロードでも一貫する
     137            1 :         query.GetGameTime(world).Advance()
     138            1 :         notifyEnvironmentChange(world)
     139            1 :         return nil
     140              : }
     141              : 
     142              : // notifyEnvironmentChange は季節や日の出入りが変わったらゲームログへ出す。
     143              : // 変化は現在ターンと直前ターンの導出値の差で判定するので、GameTime.Advance の直後に呼ぶ。
     144              : func notifyEnvironmentChange(world w.World) {
     145            1 :         gt := query.GetGameTime(world)
     146            1 : 
     147            1 :         if gt.SeasonJustChanged() {
     148            1 :                 name := query.SeasonName(world, gt.GetSeason())
     149            1 :                 gamelog.New(query.GetGameLog(world)).
     150            1 :                         Markup(gamelog.Tag("system", query.T(world, "The season changed to %s.", name))).
     151            1 :                         Log()
     152            1 :         }
     153              : 
     154              :         // 知らせるのは日の出と日の入りだけ。夜明け入りが日の出、夜入りが日の入り。
     155              :         // 夕は太陽がまだ空にある薄暮なので、沈み切って夜になった瞬間を日の入りとする。
     156            1 :         if tod, changed := gt.TimeOfDayJustChanged(); changed {
     157            1 :                 switch tod {
     158              :                 case gc.TimeDawn:
     159            1 :                         gamelog.New(query.GetGameLog(world)).
     160            1 :                                 Markup(gamelog.Tag("system", query.T(world, "The sun rises."))).
     161            1 :                                 Log()
     162              :                 case gc.TimeNight:
     163            1 :                         gamelog.New(query.GetGameLog(world)).
     164            1 :                                 Markup(gamelog.Tag("system", query.T(world, "The sun sets."))).
     165            1 :                                 Log()
     166            1 :                 default:
     167              :                         // ほかの区分は日の出入りではないので出さない
     168              :                 }
     169              :         }
     170              : }
     171              : 
     172              : // playerHasActivity はプレイヤーが継続アクティビティ中かを返す。
     173              : func playerHasActivity(world w.World) bool {
     174            1 :         playerEntity, err := query.GetPlayerEntity(world)
     175            1 :         if err != nil {
     176            1 :                 return false
     177            1 :         }
     178            1 :         return query.HasActivity(world, playerEntity)
     179              : }
     180              : 
     181              : // shouldAutoEndTurn はプレイヤーのAPがマイナスの場合にtrueを返す
     182              : // APがマイナスの間は自動でターンを経過させる
     183              : func shouldAutoEndTurn(world w.World) bool {
     184            1 :         playerEntity, err := query.GetPlayerEntity(world)
     185            1 :         if err != nil {
     186            1 :                 return false
     187            1 :         }
     188              : 
     189            1 :         turnBased := world.Components.TurnBased.Get(playerEntity)
     190            1 :         if turnBased == nil {
     191            1 :                 return false
     192            1 :         }
     193              : 
     194              :         // APが最小閾値未満の場合は自動でターンを終了
     195            1 :         return turnBased.AP.Current < consts.MinActionThreshold
     196              : }
     197              : 
     198              : // processAITurn はAIターンの処理を行う
     199              : func processAITurn(world w.World) error {
     200            1 :         log := logger.New(logger.CategoryTurn)
     201            1 :         log.Debug("AI turn processing start")
     202            1 : 
     203            1 :         processor := aiinput.NewProcessor(world.Resources.Config.RNG)
     204            1 :         if err := processor.ProcessAll(world); err != nil {
     205            0 :                 return err
     206            0 :         }
     207              : 
     208            1 :         log.Debug("AI turn processing done")
     209            1 :         return nil
     210              : }
     211              : 
     212              : // processTurnEnd はturn end processingを行う
     213              : func processTurnEnd(world w.World) error {
     214            1 :         log := logger.New(logger.CategoryTurn)
     215            1 :         turnState := query.GetTurnState(world)
     216            1 : 
     217            1 :         log.Debug("turn end processing", "turn", turnState.TurnNumber)
     218            1 : 
     219              :         // 全エンティティのアクションポイントを回復
     220            1 :         query.RestoreAllActionPoints(world)
     221            1 : 
     222              :         // 空腹を1ターンにつき1回進める。行動種別に依らず全員が等しく空腹になる
     223            1 :         progressTurnHunger(world)
     224            1 : 
     225              :         // 疲労を1ターンにつき1回進める。睡眠中は蓄積せず減る
     226            1 :         progressTurnFatigue(world)
     227            1 : 
     228            1 :         return runTurnEndSystems(world)
     229            1 : }
     230              : 
     231              : // runTurnEndSystems はターン終了時に実行するシステム群を呼び出す。
     232              : // DeadCleanupSystem は dungeon 側で毎フレーム走るが、fast-forward は1フレームで複数ターンを回すため、
     233              : // 燃え尽きた火を各ターンで回収できるよう FireSystem の後ろに置いてここでも回す。
     234              : func runTurnEndSystems(world w.World) error {
     235            1 :         for _, updater := range []w.Updater{
     236            1 :                 &AutoInteractionSystem{},
     237            1 :                 // 気温が天候を読むので TemperatureSystem より前に天候を進める
     238            1 :                 &WeatherSystem{},
     239            1 :                 &TemperatureSystem{},
     240            1 :                 &HealthRegenSystem{},
     241            1 :                 &ConditionSystem{},
     242            1 :                 &FireSystem{},
     243            1 :                 &DeadCleanupSystem{},
     244            1 :                 &DebugInvincibleSystem{},
     245            1 :                 &AreaEntrySystem{},
     246            1 :         } {
     247            1 :                 name := updater.String()
     248            1 :                 if sys, ok := world.Updaters[name]; ok {
     249            1 :                         r := trace.StartRegion(context.Background(), "turnend:"+name)
     250            1 :                         err := sys.Update(world)
     251            1 :                         r.End()
     252            1 :                         if err != nil {
     253            0 :                                 return err
     254            0 :                         }
     255              :                 }
     256              :         }
     257              : 
     258            1 :         return nil
     259              : }
     260              : 
     261              : // processPlayerContinuousActivity はプレイヤーの継続アクションを1ステップ処理する。
     262              : // 進行中なら true を返し、呼び出し側がAIフェーズへ遷移させて世界を1ターン進める
     263              : func processPlayerContinuousActivity(world w.World) (bool, error) {
     264            1 :         if !playerHasActivity(world) {
     265            1 :                 return false, nil
     266            1 :         }
     267            1 :         playerEntity, err := query.GetPlayerEntity(world)
     268            1 :         if err != nil {
     269            0 :                 return false, err
     270            0 :         }
     271              : 
     272            1 :         log := logger.New(logger.CategoryTurn)
     273            1 :         log.Debug("player continuous action processing")
     274            1 : 
     275              :         // 継続アクションの1ターン分を処理
     276            1 :         if err := activity.ProcessContinuousActivities(world); err != nil {
     277            0 :                 return false, err
     278            0 :         }
     279              : 
     280            1 :         if !query.HasActivity(world, playerEntity) {
     281            1 :                 log.Debug("player continuous action done")
     282            1 :         }
     283              : 
     284              :         // 継続中でも完了でもターンコストを消費する
     285            1 :         query.ConsumeActionPoints(world, playerEntity, consts.StandardActionCost)
     286            1 :         return true, nil
     287              : }
        

Generated by: LCOV version 2.0-1