LCOV - code coverage report
Current view: top level - maingame - game.go Coverage Total Hit
Test: coverage.lcov Lines: 78.4 % 134 105
Test Date: 2026-11-19 00:25:22 Functions: - 0 0

            Line data    Source code
       1              : package maingame
       2              : 
       3              : import (
       4              :         "context"
       5              :         "fmt"
       6              :         "runtime"
       7              :         "runtime/trace"
       8              :         "time"
       9              : 
      10              :         "github.com/hajimehoshi/ebiten/v2"
      11              :         "github.com/hajimehoshi/ebiten/v2/ebitenutil"
      12              :         "github.com/hajimehoshi/ebiten/v2/inpututil"
      13              :         gc "github.com/kijimaD/ruins/internal/components"
      14              :         "github.com/kijimaD/ruins/internal/config"
      15              :         "github.com/kijimaD/ruins/internal/consts"
      16              :         "github.com/kijimaD/ruins/internal/crashreport"
      17              :         es "github.com/kijimaD/ruins/internal/engine/states"
      18              :         "github.com/kijimaD/ruins/internal/loader"
      19              :         "github.com/kijimaD/ruins/internal/raw"
      20              :         "github.com/kijimaD/ruins/internal/screeneffect"
      21              :         gs "github.com/kijimaD/ruins/internal/systems"
      22              :         w "github.com/kijimaD/ruins/internal/world"
      23              :         "github.com/kijimaD/ruins/internal/world/query"
      24              : )
      25              : 
      26              : // MainGame はebiten.Game interfaceを満たす
      27              : type MainGame struct {
      28              :         World        w.World
      29              :         StateMachine es.StateMachine[w.World]
      30              :         renderer     renderer
      31              : }
      32              : 
      33              : // NewMainGame はMainGameを初期化する
      34              : func NewMainGame(world w.World, stateMachine es.StateMachine[w.World]) (*MainGame, error) {
      35            1 :         filters, err := buildScreenFilters(world.Resources.Config.DisableScreenFilter)
      36            1 :         if err != nil {
      37            0 :                 return nil, err
      38            0 :         }
      39              : 
      40            1 :         return &MainGame{
      41            1 :                 World:        world,
      42            1 :                 StateMachine: stateMachine,
      43            1 :                 renderer:     newRenderer(screeneffect.NewPipeline(filters...)),
      44            1 :         }, nil
      45              : }
      46              : 
      47              : // buildScreenFilters は画面に重ねるポスト処理フィルタを設定に応じて組み立てる。
      48              : // フィルタを切ったときはシェーダを組み立てず、素通しのパイプラインになるよう空を返す。
      49              : func buildScreenFilters(disableScreenFilter bool) ([]screeneffect.Filter, error) {
      50            1 :         if disableScreenFilter {
      51            1 :                 return nil, nil
      52            1 :         }
      53              : 
      54            1 :         retroFilter, err := screeneffect.NewRetroFilter()
      55            1 :         if err != nil {
      56            0 :                 return nil, fmt.Errorf("failed to initialize retro filter: %w", err)
      57            0 :         }
      58              : 
      59            1 :         return []screeneffect.Filter{retroFilter}, nil
      60              : }
      61              : 
      62              : // Layout は論理解像度を返す。スプライトが32x32固定のため論理解像度は固定とし、
      63              : // ウィンドウサイズへの拡大縮小は Ebiten に任せる(ウィンドウは可変)。
      64              : // interface method のためシグネチャは変更できない
      65              : func (game *MainGame) Layout(_, _ int) (int, int) {
      66            1 :         defer crashreport.Guard()
      67            1 :         return consts.GameWidth, consts.GameHeight
      68            1 : }
      69              : 
      70              : // Update はゲームの更新処理を行う
      71              : func (game *MainGame) Update() error {
      72            1 :         defer crashreport.Guard()
      73            1 :         region := trace.StartRegion(context.Background(), "Update")
      74            1 :         defer region.End()
      75            1 : 
      76            1 :         game.tickPlayTime()
      77            1 : 
      78              :         // デバッグ表示をトグルする
      79            1 :         if ebiten.IsKeyPressed(ebiten.KeyShift) && inpututil.IsKeyJustPressed(ebiten.KeyTab) {
      80              :                 // パフォーマンスモニターは攻略に関係ないのでトグルできてよい
      81            0 :                 game.World.Resources.Config.ShowMonitor = !game.World.Resources.Config.ShowMonitor
      82            0 :         }
      83              : 
      84            1 :         if err := game.StateMachine.Update(game.World); err != nil {
      85            0 :                 return err
      86            0 :         }
      87              : 
      88              :         // ステートが空になったらゲームを終了
      89            1 :         if game.StateMachine.GetStateCount() == 0 {
      90            0 :                 return ebiten.Termination
      91            0 :         }
      92              : 
      93            1 :         return nil
      94              : }
      95              : 
      96              : // tickPlayTime はラン進行中だけ累積プレイ実時間を進める。プレイヤー不在のメインメニューは数えない。
      97              : func (game *MainGame) tickPlayTime() {
      98            1 :         if _, err := query.GetPlayerEntity(game.World); err != nil {
      99            1 :                 return
     100            1 :         }
     101            0 :         query.GetPlayTime(game.World).Tick(time.Now())
     102              : }
     103              : 
     104              : // Draw はゲームの描画処理を行う
     105              : // interface method だからシグネチャは変更できない
     106              : func (game *MainGame) Draw(screen *ebiten.Image) {
     107            1 :         defer crashreport.Guard()
     108            1 :         region := trace.StartRegion(context.Background(), "Draw")
     109            1 :         defer region.End()
     110            1 : 
     111            1 :         game.renderer.Draw(screen, game.StateMachine.GetStates(), game.World)
     112            1 : 
     113              :         // パフォーマンスモニターは最前面のデバッグ表示なので、ポスト処理の外で screen へ直に描く。
     114            1 :         if game.World.Resources.Config.ShowMonitor {
     115            0 :                 ebitenutil.DebugPrint(screen, getPerformanceInfo())
     116            0 :         }
     117              : }
     118              : 
     119              : // getPerformanceInfo はパフォーマンス情報を文字列として返す
     120              : func getPerformanceInfo() string {
     121            1 :         var mem runtime.MemStats
     122            1 :         runtime.ReadMemStats(&mem)
     123            1 : 
     124              :         // 最後のGCからの経過時間を計算
     125            1 :         var lastGCTime string
     126            1 :         if mem.LastGC > 0 {
     127            1 :                 lastGC := time.Unix(0, int64(mem.LastGC))
     128            1 :                 elapsed := time.Since(lastGC)
     129            1 :                 lastGCTime = fmt.Sprintf("%.2fs", elapsed.Seconds())
     130            1 :         } else {
     131            0 :                 lastGCTime = "N/A"
     132            0 :         }
     133              : 
     134            1 :         return fmt.Sprintf(`FPS: %.1f
     135            1 : Alloc: %.2fMB
     136            1 : HeapInuse: %.2fMB
     137            1 : StackInuse: %.2fMB
     138            1 : Sys: %.2fMB
     139            1 : NextGC: %.2fMB
     140            1 : TotalAlloc: %.2fMB
     141            1 : Mallocs: %d
     142            1 : Frees: %d
     143            1 : GC: %d
     144            1 : LastGC: %s
     145            1 : PauseTotalNs: %.2fms
     146            1 : Goroutines: %d
     147            1 : `,
     148            1 :                 ebiten.ActualFPS(),
     149            1 :                 float64(mem.Alloc/1024/1024),      // 現在割り当てられているメモリ
     150            1 :                 float64(mem.HeapInuse/1024/1024),  // ヒープで実際に使用中のメモリ
     151            1 :                 float64(mem.StackInuse/1024/1024), // スタックで使用中のメモリ
     152            1 :                 float64(mem.Sys/1024/1024),        // OSから取得した総メモリ
     153            1 :                 float64(mem.NextGC/1024/1024),     // 次回GC実行予定サイズ
     154            1 :                 float64(mem.TotalAlloc/1024/1024), // 起動後から割り当てられたヒープオブジェクトの累計バイト数
     155            1 :                 mem.Mallocs,                       // 割り当てられたヒープオブジェクトの回数
     156            1 :                 mem.Frees,                         // 解放されたヒープオブジェクトの回数
     157            1 :                 mem.NumGC,                         // GC実行回数
     158            1 :                 lastGCTime,                        // 最後のGC実行からの経過時間
     159            1 :                 float64(mem.PauseTotalNs)/1000000, // GC停止時間の累計(ミリ秒)
     160            1 :                 runtime.NumGoroutine(),            // 実行中のGoroutine数
     161            1 :         )
     162              : }
     163              : 
     164              : // InitWorld はゲームワールドを初期化する
     165              : func InitWorld(cfg *config.Config) (w.World, error) {
     166            1 :         world, err := w.InitWorld(&gc.Components{}, cfg)
     167            1 :         if err != nil {
     168            0 :                 return w.World{}, err
     169            0 :         }
     170              : 
     171              :         // ScreenDimensions は描画の基準(カメラ中心・HUD配置)であり、Layout が返す論理解像度と
     172              :         // 一致させる。論理解像度は固定のため consts の値を渡す。ウィンドウサイズ(cfg.User)とは
     173              :         // 分離する。cfg.User で大きなウィンドウを指定しても描画基準がズレないようにする
     174            1 :         world.Resources.SetScreenDimensions(consts.GameWidth, consts.GameHeight)
     175            1 : 
     176              :         // Rawデータを読み込む
     177            1 :         rw, err := loader.LoadRaws()
     178            1 :         if err != nil {
     179            0 :                 return w.World{}, err
     180            0 :         }
     181            1 :         world.Resources.RawMaster = rw
     182            1 :         defs, err := raw.NewConditionDefs(rw)
     183            1 :         if err != nil {
     184            0 :                 return w.World{}, err
     185            0 :         }
     186            1 :         world.Resources.ConditionDefs = defs
     187            1 :         skillDefs, err := raw.NewSkillDefs(rw)
     188            1 :         if err != nil {
     189            0 :                 return w.World{}, err
     190            0 :         }
     191            1 :         world.Resources.SkillDefs = skillDefs
     192            1 :         world.Resources.WeatherDefs = raw.NewWeatherDefs(rw)
     193            1 :         world.Resources.TileEnvDefs = raw.NewTileEnvDefs(rw)
     194            1 :         world.Resources.NeedDefs = raw.NewNeedDefs(rw)
     195            1 :         materialDefs, err := raw.NewMaterialDefs(rw)
     196            1 :         if err != nil {
     197            0 :                 return w.World{}, err
     198            0 :         }
     199            1 :         world.Resources.MaterialDefs = materialDefs
     200            1 :         world.Resources.CalendarDefs = raw.NewCalendarDefs(rw)
     201            1 : 
     202              :         // スプライトシートを読み込む
     203            1 :         spriteSheets, err := loader.LoadSpriteSheets(rw)
     204            1 :         if err != nil {
     205            0 :                 return w.World{}, err
     206            0 :         }
     207            1 :         world.Resources.SetSpriteSheets(spriteSheets)
     208            1 : 
     209              :         // UIリソースを読み込む
     210            1 :         uir, err := loader.LoadUIResources()
     211            1 :         if err != nil {
     212            0 :                 return w.World{}, err
     213            0 :         }
     214            1 :         world.Resources.UIResources = uir
     215            1 : 
     216            1 :         world.Updaters, world.Renderers = gs.InitializeSystems(world)
     217            1 : 
     218            1 :         return world, nil
     219              : }
        

Generated by: LCOV version 2.0-1