LCOV - code coverage report
Current view: top level - menuloop - screen.go Coverage Total Hit
Test: coverage.lcov Lines: 80.4 % 107 86
Test Date: 2026-11-19 00:25:22 Functions: - 0 0

            Line data    Source code
       1              : // Package menuloop はメニュー画面の共通ランタイムを提供する。
       2              : //
       3              : // 各メニュー state から UI 機構、mount・widget・overlay の入力ゲートと重ね、を Screen へ
       4              : // 集約し、state は Fetch・Menu・View と既存の DoAction を提供するだけにする。MVU の Model/View/Update
       5              : // に対応し、Screen がループを所有する。state package とは別 package にすることで、Model 契約を
       6              : // コンパイラに強制させ、state から Screen 内部へ触れられないようにする。
       7              : package menuloop
       8              : 
       9              : import (
      10              :         "slices"
      11              : 
      12              :         "github.com/hajimehoshi/ebiten/v2"
      13              :         es "github.com/kijimaD/ruins/internal/engine/states"
      14              :         "github.com/kijimaD/ruins/internal/hooks"
      15              :         "github.com/kijimaD/ruins/internal/inputmapper"
      16              :         "github.com/kijimaD/ruins/internal/keybind"
      17              :         "github.com/kijimaD/ruins/internal/resources"
      18              :         "github.com/kijimaD/ruins/internal/widgets/menuframe"
      19              :         "github.com/kijimaD/ruins/internal/widgets/overlay"
      20              :         "github.com/kijimaD/ruins/internal/widgets/uicore"
      21              :         w "github.com/kijimaD/ruins/internal/world"
      22              : )
      23              : 
      24              : // Selection は描画に要るカーソル位置。どのタブのどの行を強調するかを表す。
      25              : // PageSize は解決済みの1ページ件数。ItemsPerPageAuto を使う画面の描画が、カーソルと同じ
      26              : // ページ件数でページ送りできるよう渡す。0 はページ送りなし
      27              : type Selection struct {
      28              :         TabIndex  int
      29              :         ItemIndex int
      30              :         PageSize  int
      31              : }
      32              : 
      33              : // ItemsPerPageAuto は ItemsPerPage に、タブ帯つきモーダルの1ページへ収まる実測行数を
      34              : // 使う指定。実値は Update が UIResources から測って解決する。Menu は world を持たず
      35              : // 自力で測れないため、番兵で指定して Screen に解決させる。
      36              : // 測るのは見出し無し・タブ帯ありの構成に固定する。見出しを持つ画面はこの番兵を使わず、
      37              : // 自分の構成で menuframe.ListCapacity を呼んで求めた値を直接渡すこと
      38              : const ItemsPerPageAuto = -1
      39              : 
      40              : // MenuConfig は Fetch 済みの props から決まるメニュー構成。state 固有差をここで吸収する。
      41              : // TabCount が 0 のときは一覧を持たない画面として UseTabMenu を登録しない
      42              : type MenuConfig struct {
      43              :         Key          string
      44              :         TabCount     int
      45              :         ItemCounts   []int
      46              :         ItemsPerPage int      // 1ページの件数。0 はページ送りなし
      47              :         Skips        [][]bool // カーソルを飛ばす見出し行。nil 可
      48              :         InitialTab   int      // 初回に寄せるタブ番号。0 なら先頭のまま。1度だけ適用する。TabCount 未満を前提とする
      49              : }
      50              : 
      51              : // Model はメニュー1画面が Screen に対して満たす契約。UI 機構は持たず純粋な部品を提供する。
      52              : // DoAction・ConsumeTransition は既存の ActionHandler・BaseState をそのまま使う。メニュー入力は
      53              : // Screen が ReadInput で扱い、独自キーが要る state は KeyBindings の表で宣言する。
      54              : // カーソル移動系は Screen が吸うので、DoAction には画面の意味を持つ Action だけが届く
      55              : type Model[P any] interface {
      56              :         ConsumeTransition() es.Transition[w.World]
      57              :         DoAction(world w.World, action inputmapper.ActionID) (es.Transition[w.World], error)
      58              :         // Fetch は世界から表示 props を構築する。失敗は握りつぶさず error で返し、
      59              :         // Screen.Update がそのままフレームのエラーとして表面化させる
      60              :         Fetch(world w.World) (P, error)
      61              :         Menu(props P) MenuConfig
      62              :         // ViewUI は props とカーソルから本体を uicore のツリーへ組み、画面へ配置済みで返す
      63              :         ViewUI(world w.World, props P, cursor Selection, res resources.UIResources) uicore.Drawable
      64              : }
      65              : 
      66              : // KeyBindings は共通キーに加える独自キーを持つ state が満たす任意契約。キーと Action の
      67              : // 対応を表で返すだけで、キー読み取りの実行は keybind が担う。表は NewScreen が共通表と
      68              : // 1枚に合成し、共通キーとの重なりは構築時に拒否される。
      69              : // 実装 state は var _ menuloop.KeyBindings = &XState{} で綴りとシグネチャを静的に検証する
      70              : type KeyBindings interface {
      71              :         KeyBindings() []keybind.Binding
      72              : }
      73              : 
      74              : // Screen はメニューの UI ランタイム。mount・widget と overlay を保持し、毎フレームの
      75              : // 手順を回す。state は構造体にこれをポインタで持ち、Update と Draw を委譲する。
      76              : // widget は uicore のツリーを retained として扱い、props・カーソル・overlay が変わった
      77              : // フレームだけ組み直す。変化が無ければ前フレームのツリーを再利用する
      78              : type Screen[P any] struct {
      79              :         model Model[P] // メニュー画面本体。state 自身を指し、ループはこれ越しに部品を引く
      80              :         // table はこの画面のキー束縛。state 固有の断片と共通表を構築時に1枚へ合成済みで、
      81              :         // 実行時に表を重ねる階層は無い。重なりは MustMerge が構築時に拒否する
      82              :         table           []keybind.Binding
      83              :         mount           *hooks.Mount[P]
      84              :         bodyTree        uicore.Drawable // 本体のツリー。dirty なフレームだけ組み直す
      85              :         overlays        []overlay.Layer
      86              :         pendingOverlays []uicore.Drawable // ScreenRenderer な overlay の配置済みツリー。Draw で本体の上へ重ねる
      87              :         lastSelection   Selection         // 直近フレームで確定したカーソル位置。DoAction から参照する
      88              :         seeded          bool              // 初期タブへ寄せたか
      89              :         pageSize        int               // ItemsPerPageAuto の解決値。Update が最初のフレームで測る
      90              : }
      91              : 
      92              : // NewScreen は model と overlay を束ねて Screen を作る。model には state 自身を渡す。overlay は
      93              : // 優先順位順に、ポインタで渡し、state が保持する実体と同一を指す
      94              : func NewScreen[P any](model Model[P], overlays ...overlay.Layer) *Screen[P] {
      95            1 :         var frag []keybind.Binding
      96            1 :         if kb, ok := model.(KeyBindings); ok {
      97            0 :                 frag = kb.KeyBindings()
      98            0 :         }
      99            1 :         return &Screen[P]{
     100            1 :                 model:    model,
     101            1 :                 table:    keybind.MustMerge(frag, keybind.MenuCommon),
     102            1 :                 mount:    hooks.NewMount[P](),
     103            1 :                 overlays: overlays,
     104            1 :         }
     105              : }
     106              : 
     107              : // Props は現在の props を返す。View 以外から現在値を参照する必要があるとき使う
     108            1 : func (s *Screen[P]) Props() P { return s.mount.GetProps() }
     109              : 
     110              : // activeOverlay は登録順で最初の Active な overlay を返す。無ければ nil
     111              : func (s *Screen[P]) activeOverlay() overlay.Layer {
     112            1 :         for _, ov := range s.overlays {
     113            1 :                 if ov.Active() {
     114            1 :                         return ov
     115            1 :                 }
     116              :         }
     117            1 :         return nil
     118              : }
     119              : 
     120              : // dispatch は1件の Action を消費者の連鎖に流す。カーソルの mount、共通のキー一覧ヘルプ、
     121              : // 画面の DoAction の順に試し、先に消費したものが勝つ。DoAction には画面の意味を持つ
     122              : // Action だけが届く
     123              : func (s *Screen[P]) dispatch(world w.World, action inputmapper.ActionID) (es.Transition[w.World], error) {
     124            1 :         if s.mount.DispatchNav(action) {
     125            1 :                 return es.Transition[w.World]{Type: es.TransNone}, nil
     126            1 :         }
     127            1 :         if action == inputmapper.ActionOpenKeyHelp {
     128              :                 // ? のキー一覧ヘルプは全メニュー共通なので Screen が吸い、
     129              :                 // この画面の合成済みの表から一覧を組んで push する
     130            0 :                 return es.Transition[w.World]{Type: es.TransPush,
     131            0 :                         NewStateFuncs: []es.StateFactory[w.World]{NewKeyHelpState(s.table)}}, nil
     132            0 :         }
     133            1 :         return s.model.DoAction(world, action)
     134              : }
     135              : 
     136              : // Update はメニュー1フレームを進める。入力ゲート、Fetch/SetProps、
     137              : // UseTabMenu、dirty なら View 再構築と overlay 重ね、widget.Update、の順で回す
     138              : func (s *Screen[P]) Update(world w.World) (es.Transition[w.World], error) {
     139            1 :         m := s.model
     140            1 : 
     141              :         // 入力ゲート。Active な最上位 overlay が専有し、無ければ通常入力を dispatch の連鎖へ流す。
     142              :         // overlay が絡んだフレームは内容が入力で変わりうるので後段で必ず dirty にする
     143              :         // 入力ゲート。Active な最上位 overlay が入力を専有し、無ければ通常入力を dispatch の連鎖へ流す。
     144              :         // overlay と Screen が同一フレームで二度読まないよう、どちらか一方だけが読む
     145            1 :         ovBefore := s.activeOverlay()
     146            1 :         if ovBefore != nil {
     147            1 :                 if err := ovBefore.HandleInput(world); err != nil {
     148            1 :                         return es.Transition[w.World]{}, err
     149            1 :                 }
     150            1 :         } else if action, ok := keybind.ReadInput(world, s.table); ok {
     151            1 :                 if tr, err := s.dispatch(world, action); err != nil {
     152            1 :                         return es.Transition[w.World]{}, err
     153            2 :                 } else if tr.Type != es.TransNone {
     154            1 :                         return tr, nil
     155            1 :                 }
     156              :         }
     157              : 
     158            1 :         props, err := m.Fetch(world)
     159            1 :         if err != nil {
     160            0 :                 return es.Transition[w.World]{}, err
     161            0 :         }
     162            1 :         s.mount.SetProps(props)
     163            1 :         cfg := s.resolveConfig(world, m.Menu(props))
     164            1 :         if cfg.TabCount > 0 {
     165            1 :                 hooks.UseTabMenu(s.mount.Store(), cfg.Key, hooks.TabMenuConfig{
     166            1 :                         TabCount:     cfg.TabCount,
     167            1 :                         ItemCounts:   cfg.ItemCounts,
     168            1 :                         ItemsPerPage: cfg.ItemsPerPage,
     169            1 :                         Skips:        cfg.Skips,
     170            1 :                 })
     171            1 :                 if !s.seeded {
     172            1 :                         if cfg.InitialTab > 0 {
     173            0 :                                 s.setTab(cfg, cfg.InitialTab)
     174            0 :                         }
     175            1 :                         s.seeded = true
     176              :                 }
     177              :         }
     178              : 
     179              :         // mount の dirty を読む。初回・props 変化・入力受理のいずれかで立つ。カーソルは Dispatch で更新済み
     180            1 :         changed := s.mount.Update()
     181            1 :         sel := s.selection(cfg)
     182            1 : 
     183              :         // dirty なフレームだけ widget ツリーを組み直す。mount の dirty を状態変化の答えとし、
     184              :         // hooks の外にある overlay だけ別途 OR する。overlay が開閉・表示中のフレームは窓内容が
     185              :         // 入力で変わりうるので常に組み直す
     186            1 :         overlayInvolved := ovBefore != nil || s.activeOverlay() != nil
     187            1 :         dirty := s.bodyTree == nil || overlayInvolved || changed
     188            1 :         if dirty {
     189            1 :                 s.bodyTree = m.ViewUI(world, props, sel, world.Resources.UIResources)
     190            1 :                 s.pendingOverlays = s.pendingOverlays[:0]
     191            1 :                 rect := menuframe.WindowRect(world)
     192            1 :                 // overlay は登録順で入力優先度が決まる。activeOverlay は先頭の Active を入力先にするので、
     193              :                 // 描画は逆順に溜め、入力を受ける overlay を最前面にする。入れ子で開いた overlay が下に
     194              :                 // 隠れて操作不能になるのを防ぐ。ツリーは Draw で本体の上へ重ねる
     195            1 :                 for _, ov := range slices.Backward(s.overlays) {
     196            1 :                         if !ov.Active() {
     197            0 :                                 continue
     198              :                         }
     199            1 :                         if r, ok := ov.(overlay.ScreenRenderer); ok {
     200            0 :                                 if tree := r.RenderOverlay(world, rect); tree != nil {
     201            0 :                                         s.pendingOverlays = append(s.pendingOverlays, tree)
     202            0 :                                 }
     203              :                         }
     204              :                 }
     205              :         }
     206              : 
     207            1 :         s.lastSelection = sel
     208            1 :         return m.ConsumeTransition(), nil
     209              : }
     210              : 
     211              : // SetTab は指定タブへ直接カーソルを移す。キー入力を介さずにタブを設定する。
     212              : // DoAction など入力処理の最中に呼ぶ。同じフレームの再構築で移動が反映される。
     213              : // UseTabMenu 登録後、つまり Update が1度回った後に呼ぶこと。範囲外の tab は無視する。
     214              : // 構成は model から導出するので呼び出し側は tab 番号だけを渡す
     215              : func (s *Screen[P]) SetTab(tab int) {
     216            1 :         cfg := s.model.Menu(s.Props())
     217            1 :         if cfg.ItemsPerPage == ItemsPerPageAuto {
     218              :                 // SetTab は Update 後に呼ぶ前提なので、Update が測定済みの値をそのまま使う
     219            0 :                 cfg.ItemsPerPage = s.pageSize
     220            0 :         }
     221            1 :         s.setTab(cfg, tab)
     222              : }
     223              : 
     224              : // resolveConfig は MenuConfig の ItemsPerPageAuto を実測のページ行数へ解決する。
     225              : // 測定は Auto 指定の画面が最初に通ったときだけ行い、以後は測定済みの値を使う
     226              : func (s *Screen[P]) resolveConfig(world w.World, cfg MenuConfig) MenuConfig {
     227            1 :         if cfg.ItemsPerPage == ItemsPerPageAuto {
     228            0 :                 if s.pageSize == 0 {
     229            0 :                         s.pageSize = menuframe.ListCapacity(world, false, true)
     230            0 :                 }
     231            0 :                 cfg.ItemsPerPage = s.pageSize
     232              :         }
     233            1 :         return cfg
     234              : }
     235              : 
     236              : // setTab は構成を渡してタブを設定する内部処理。Update の初期タブ寄せと公開 SetTab が共有する
     237              : func (s *Screen[P]) setTab(cfg MenuConfig, tab int) {
     238            1 :         if cfg.TabCount == 0 || tab < 0 || tab >= cfg.TabCount {
     239            1 :                 return
     240            1 :         }
     241            1 :         hooks.SetTab(s.mount.Store(), cfg.Key, hooks.TabMenuConfig{
     242            1 :                 TabCount:     cfg.TabCount,
     243            1 :                 ItemCounts:   cfg.ItemCounts,
     244            1 :                 ItemsPerPage: cfg.ItemsPerPage,
     245            1 :                 Skips:        cfg.Skips,
     246            1 :         }, tab)
     247              : }
     248              : 
     249              : // Selection は前フレームで確定したカーソル位置を返す。カーソルは DoAction のあとの
     250              : // Dispatch で更新されるため、DoAction 内で読むと更新前、つまり画面に見えている確定位置になる
     251            1 : func (s *Screen[P]) Selection() Selection { return s.lastSelection }
     252              : 
     253              : // selection は現在のカーソル位置を mount から読む。一覧を持たない画面はゼロ値
     254              : func (s *Screen[P]) selection(cfg MenuConfig) Selection {
     255            1 :         if cfg.TabCount == 0 {
     256            1 :                 return Selection{}
     257            1 :         }
     258            1 :         ms, _ := hooks.GetState[hooks.TabMenuState](s.mount, cfg.Key)
     259            1 :         return Selection{TabIndex: ms.TabIndex, ItemIndex: ms.ItemIndex, PageSize: cfg.ItemsPerPage}
     260              : }
     261              : 
     262              : // Draw は保持中の UI を描き、その上に ScreenRenderer な overlay を重ねる。
     263              : // 各 state の Draw はこれへ委譲する
     264              : func (s *Screen[P]) Draw(screen *ebiten.Image) {
     265            1 :         cv := uicore.NewEbitenCanvas(screen)
     266            1 :         if s.bodyTree != nil {
     267            1 :                 s.bodyTree.Draw(cv)
     268            1 :         }
     269            1 :         for _, tree := range s.pendingOverlays {
     270            0 :                 tree.Draw(cv)
     271            0 :         }
     272              : }
        

Generated by: LCOV version 2.0-1