LCOV - code coverage report
Current view: top level - components - need_defs.go Coverage Total Hit
Test: coverage.lcov Lines: 100.0 % 59 59
Test Date: 2026-11-19 00:25:22 Functions: - 0 0

            Line data    Source code
       1              : package components
       2              : 
       3              : import (
       4              :         "image/color"
       5              : 
       6              :         "github.com/kijimaD/ruins/internal/i18n"
       7              : 
       8              :         "github.com/kijimaD/ruins/internal/rawschema"
       9              : )
      10              : 
      11              : // HungerStage は空腹の段階1つの定義。raw の hungerStages の1行から組み立てる
      12              : type HungerStage struct {
      13              :         Level        rawschema.HungerStageId
      14              :         Name         i18n.Msgid  // 表示名
      15              :         From         float64     // 満腹度の割合がこれ以上の段階のうち From が最大のものになる
      16              :         Condition    Severity    // この段階で立つ栄養失調の重症度。SeverityNone なら立たない
      17              :         ReachedLog   i18n.Msgid  // 食べてこの段階に達したときのログ。空なら出さない
      18              :         WakesSleeper bool        // 寝ている者を起こす段階か
      19              :         Badge        *color.RGBA // HUD のバッジの色。nil ならバッジを出さない
      20              : }
      21              : 
      22              : // FatigueStage は疲労の段階1つの定義。raw の fatigueStages の1行から組み立てる
      23              : type FatigueStage struct {
      24              :         Level     rawschema.FatigueStageId
      25              :         Name      i18n.Msgid  // 表示名
      26              :         From      float64     // 疲労の割合がこれ以上の段階のうち From が最大のものになる
      27              :         Condition Severity    // この段階で立つ過労の重症度。SeverityNone なら立たない
      28              :         CanSleep  bool        // この段階で眠れるか
      29              :         Badge     *color.RGBA // HUD のバッジの色。nil ならバッジを出さない
      30              : }
      31              : 
      32              : // NeedDefs は空腹と疲労の段階の境目と、段階ごとに立つ不調と、鮮度の段階ごとの栄養の割合の表。
      33              : // 読み込み時に raw から1度だけ組み立て、以後は変えない
      34              : type NeedDefs struct {
      35              :         Hunger    []HungerStage
      36              :         Fatigue   []FatigueStage
      37              :         Freshness []FreshnessDef
      38              : }
      39              : 
      40              : // stageAt は割合 ratio が From 以上の段階のうち From が最大のものを返す。該当が無ければ ok=false
      41              : func stageAt[S any](stages []S, from func(S) float64, ratio float64) (S, bool) {
      42            1 :         var best S
      43            1 :         found := false
      44            1 :         for _, s := range stages {
      45            1 :                 if from(s) <= ratio && (!found || from(s) > from(best)) {
      46            1 :                         best, found = s, true
      47            1 :                 }
      48              :         }
      49            1 :         return best, found
      50              : }
      51              : 
      52              : // hungerStage は満腹度の割合に当たる空腹の段階を返す。該当が無ければ満腹とする
      53              : func (d NeedDefs) hungerStage(ratio float64) HungerStage {
      54            2 :         s, ok := stageAt(d.Hunger, func(s HungerStage) float64 { return s.From }, ratio)
      55            1 :         if !ok {
      56            1 :                 return HungerStage{Level: rawschema.HungerStageIdSatiated}
      57            1 :         }
      58            1 :         return s
      59              : }
      60              : 
      61              : // fatigueStage は疲労の割合に当たる疲労の段階を返す。該当が無ければ快調とする
      62              : func (d NeedDefs) fatigueStage(ratio float64) FatigueStage {
      63            2 :         s, ok := stageAt(d.Fatigue, func(s FatigueStage) float64 { return s.From }, ratio)
      64            1 :         if !ok {
      65            1 :                 return FatigueStage{Level: rawschema.FatigueStageIdRested}
      66            1 :         }
      67            1 :         return s
      68              : }
      69              : 
      70              : // HungerSeverity は空腹段階を栄養失調の不調の重症度へ写す。ok=false なら不調は立たない
      71              : func (d NeedDefs) HungerSeverity(level rawschema.HungerStageId) (Severity, bool) {
      72            1 :         for _, s := range d.Hunger {
      73            1 :                 if s.Level == level {
      74            1 :                         return s.Condition, s.Condition != SeverityNone
      75            1 :                 }
      76              :         }
      77            1 :         return SeverityNone, false
      78              : }
      79              : 
      80              : // HungerFrom は空腹の段階が始まる満腹度の割合を返す。未登録なら 0
      81              : func (d NeedDefs) HungerFrom(level rawschema.HungerStageId) float64 {
      82            1 :         for _, s := range d.Hunger {
      83            1 :                 if s.Level == level {
      84            1 :                         return s.From
      85            1 :                 }
      86              :         }
      87            1 :         return 0
      88              : }
      89              : 
      90              : // FatigueFrom は疲労の段階が始まる疲労の割合を返す。未登録なら 0
      91              : func (d NeedDefs) FatigueFrom(level rawschema.FatigueStageId) float64 {
      92            1 :         for _, s := range d.Fatigue {
      93            1 :                 if s.Level == level {
      94            1 :                         return s.From
      95            1 :                 }
      96              :         }
      97            1 :         return 0
      98              : }
      99              : 
     100              : // HungerName は空腹の段階の表示名 msgid を返す。未登録なら id をそのまま返す
     101              : func (d NeedDefs) HungerName(level rawschema.HungerStageId) i18n.Msgid {
     102            1 :         for _, s := range d.Hunger {
     103            1 :                 if s.Level == level {
     104            1 :                         return s.Name
     105            1 :                 }
     106              :         }
     107            1 :         return i18n.Msgid(level)
     108              : }
     109              : 
     110              : // FatigueName は疲労の段階の表示名 msgid を返す。未登録なら id をそのまま返す
     111              : func (d NeedDefs) FatigueName(level rawschema.FatigueStageId) i18n.Msgid {
     112            1 :         for _, s := range d.Fatigue {
     113            1 :                 if s.Level == level {
     114            1 :                         return s.Name
     115            1 :                 }
     116              :         }
     117            1 :         return i18n.Msgid(level)
     118              : }
     119              : 
     120              : // HungerStageOf は空腹の段階の定義を返す。未登録なら ok=false
     121              : func (d NeedDefs) HungerStageOf(level rawschema.HungerStageId) (HungerStage, bool) {
     122            1 :         for _, s := range d.Hunger {
     123            1 :                 if s.Level == level {
     124            1 :                         return s, true
     125            1 :                 }
     126              :         }
     127            1 :         return HungerStage{}, false
     128              : }
     129              : 
     130              : // FatigueStageOf は疲労の段階の定義を返す。未登録なら ok=false
     131              : func (d NeedDefs) FatigueStageOf(level rawschema.FatigueStageId) (FatigueStage, bool) {
     132            1 :         for _, s := range d.Fatigue {
     133            1 :                 if s.Level == level {
     134            1 :                         return s, true
     135            1 :                 }
     136              :         }
     137            1 :         return FatigueStage{}, false
     138              : }
     139              : 
     140              : // FreshnessAt は経過した段階数 stages に当たる鮮度の段階を返す。該当が無ければゼロ値
     141              : func (d NeedDefs) FreshnessAt(stages int) FreshnessDef {
     142            2 :         s, _ := stageAt(d.Freshness, func(s FreshnessDef) float64 { return float64(s.From) }, float64(stages))
     143            1 :         return s
     144              : }
     145              : 
     146              : // FreshnessOf は鮮度の段階の定義を返す。未登録ならゼロ値
     147              : func (d NeedDefs) FreshnessOf(level rawschema.FreshnessStageId) FreshnessDef {
     148            1 :         for _, s := range d.Freshness {
     149            1 :                 if s.Level == level {
     150            1 :                         return s
     151            1 :                 }
     152              :         }
     153            1 :         return FreshnessDef{}
     154              : }
        

Generated by: LCOV version 2.0-1