LCOV - code coverage report
Current view: top level - balance - economy.go Coverage Total Hit
Test: coverage.lcov Lines: 86.5 % 89 77
Test Date: 2026-11-19 00:25:22 Functions: - 0 0

            Line data    Source code
       1              : package balance
       2              : 
       3              : import (
       4              :         "math"
       5              : 
       6              :         "github.com/kijimaD/ruins/internal/consts"
       7              :         "github.com/kijimaD/ruins/internal/raw"
       8              :         "github.com/kijimaD/ruins/internal/rawschema"
       9              :         "github.com/kijimaD/ruins/internal/world/query"
      10              : )
      11              : 
      12              : // ExpectedLootValue は危険度 danger で itemTable から拾える1個あたりの期待売買価値を返す。該当帯エントリと
      13              : // その指すアイテムグループの中身を2段で重み付き平均する。収入側の指標。
      14              : func ExpectedLootValue(master rawschema.Raws, itemTableName string, danger int) float64 {
      15            1 :         table, err := raw.GetItemTable(master, itemTableName)
      16            1 :         if err != nil {
      17            1 :                 return 0
      18            1 :         }
      19            1 :         var wSum, vSum float64
      20            1 :         for _, e := range raw.ItemEntriesAt(table, danger) {
      21            1 :                 wSum += e.Weight
      22            1 :                 vSum += e.Weight * expectedGroupValue(master, e.Id)
      23            1 :         }
      24            1 :         if wSum == 0 {
      25            0 :                 return 0
      26            0 :         }
      27            1 :         return vSum / wSum
      28              : }
      29              : 
      30              : // expectedGroupValue はアイテムグループかアイテムコレクションから拾う1個あたりの期待売買価値を返す。各行の価値を、
      31              : // 1回の抽選で出る個数の期待値で重み付けする。どちらでもなくアイテムを直接指す場合はその価値を返す。
      32              : func expectedGroupValue(master rawschema.Raws, id string) float64 {
      33            1 :         draws, ok := expectedDraws(master, id)
      34            1 :         if !ok {
      35            0 :                 if it, e := raw.FindItem(master, id); e == nil {
      36            0 :                         return float64(it.Value)
      37            0 :                 }
      38            0 :                 return 0
      39              :         }
      40            1 :         var nSum, vSum float64
      41            1 :         for _, d := range draws {
      42            1 :                 it, err := raw.FindItem(master, d.id)
      43            1 :                 if err != nil {
      44            0 :                         continue
      45              :                 }
      46            1 :                 nSum += d.count
      47            1 :                 vSum += d.count * float64(it.Value)
      48              :         }
      49            1 :         if nSum == 0 {
      50            0 :                 return 0
      51            0 :         }
      52            1 :         return vSum / nSum
      53              : }
      54              : 
      55              : // expectedDraw はアイテム1種と、1回の抽選で出る個数の期待値の組。
      56              : type expectedDraw struct {
      57              :         id    string
      58              :         count float64
      59              : }
      60              : 
      61              : // expectedDraws は id が指すグループかコレクションを1回引いたときに、各行が出る個数の期待値を返す。グループは重みの比で
      62              : // 1行だけ、コレクションは各行を出現確率で独立に出し、出た行は pack のダイスの期待値の個数になる。
      63              : func expectedDraws(master rawschema.Raws, id string) ([]expectedDraw, bool) {
      64            1 :         if g, err := raw.GetItemGroup(master, id); err == nil {
      65            1 :                 var wSum float64
      66            1 :                 for _, e := range g.Entries {
      67            1 :                         wSum += e.Weight
      68            1 :                 }
      69            1 :                 out := make([]expectedDraw, 0, len(g.Entries))
      70            1 :                 for _, e := range g.Entries {
      71            1 :                         if wSum > 0 {
      72            1 :                                 out = append(out, expectedDraw{id: e.Id, count: e.Weight / wSum * expectedPack(e.Pack)})
      73            1 :                         }
      74              :                 }
      75            1 :                 return out, true
      76              :         }
      77            1 :         if c, err := raw.GetItemCollection(master, id); err == nil {
      78            1 :                 out := make([]expectedDraw, 0, len(c.Entries))
      79            1 :                 for _, e := range c.Entries {
      80            1 :                         out = append(out, expectedDraw{id: e.Id, count: e.Chance / 100 * expectedPack(e.Pack)})
      81            1 :                 }
      82            1 :                 return out, true
      83              :         }
      84            0 :         return nil, false
      85              : }
      86              : 
      87              : // expectedPack は pack のダイスの期待値を返す。解釈できない表記は0。
      88              : func expectedPack(pack rawschema.Dice) float64 {
      89            1 :         d, err := consts.ParseDice(pack)
      90            1 :         if err != nil {
      91            0 :                 return 0
      92            0 :         }
      93            1 :         return float64(d.Min()+d.Max()) / 2
      94              : }
      95              : 
      96              : // ExpectedNetLootValue は危険度 danger で拾える1個あたりの店売りの期待手取り額を返す。額面の
      97              : // ExpectedLootValue に売却倍率を掛けた実収入側の終端指標。
      98              : func ExpectedNetLootValue(master rawschema.Raws, itemTableName string, danger int) float64 {
      99            1 :         value := ExpectedLootValue(master, itemTableName, danger)
     100            1 :         if value <= 0 {
     101            1 :                 return 0
     102            1 :         }
     103              :         // CalculateSellPrice は Currency 整数を取るので期待価値を1個ぶんだけ丸める。丸めは1品あたり0.5未満。
     104            1 :         return float64(query.CalculateSellPrice(int(math.Round(value))))
     105              : }
     106              : 
     107              : // ExpectedRunLootIncome はダンジョンの行 d を floors 層探索して拾う loot の期待手取り総額を返す。各層で
     108              : // アイテムの数の期待値の個数を拾い、層の深さを危険度として ExpectedNetLootValue を積む。到達層数は生存依存の scenario 入力。
     109              : // 高い危険度の層でアイテムの配置が1個足す分は含めない。
     110              : func ExpectedRunLootIncome(master rawschema.Raws, d rawschema.Dungeon, floors int) float64 {
     111            1 :         perFloor := d.ItemCount.Mean()
     112            1 :         total := 0.0
     113            1 :         for depth := 1; depth <= floors; depth++ {
     114            1 :                 total += perFloor * ExpectedNetLootValue(master, d.ItemTable, depth)
     115            1 :         }
     116            1 :         return total
     117              : }
     118              : 
     119              : // CheapestFoodCostPerNutrition は満腹度1点を回復するのに要する最小の購入価値を返す。栄養価を持つ
     120              : // アイテムのうち、価値÷栄養が最小のものを賢い調達とみなす。食料が無ければ0を返す。
     121              : func CheapestFoodCostPerNutrition(master rawschema.Raws) float64 {
     122            1 :         best := 0.0
     123            1 :         items := raw.PtrSlice(master.Items)
     124            1 :         for i := range items {
     125            1 :                 it := &items[i]
     126            1 :                 if it.ProvidesNutrition == nil || *it.ProvidesNutrition <= 0 || it.Value <= 0 {
     127            1 :                         continue
     128              :                 }
     129            1 :                 cost := float64(it.Value) / float64(*it.ProvidesNutrition)
     130            1 :                 if best == 0 || cost < best {
     131            1 :                         best = cost
     132            1 :                 }
     133              :         }
     134            1 :         return best
     135              : }
     136              : 
     137              : // CostOfLivingPerDay は補給なしの1日で失う満腹度を、最安の食料で埋め戻す購入費用を返す。1日の満腹度
     138              : // 減耗は turnsPerDay/HungerDrainTurns で、これに満腹度1点あたりの最小食料費を掛ける。経済の支出側の下端。
     139              : func CostOfLivingPerDay(master rawschema.Raws, p Params) float64 {
     140            1 :         hungerPerDay := p.TurnsPerDay / p.HungerDrainTurns
     141            1 :         return hungerPerDay * CheapestFoodCostPerNutrition(master)
     142            1 : }
     143              : 
     144              : // EconomyDay は経過日1日ぶんの経済の断面。危険度に応じた1個あたり手取りと、1日の食費を賄うのに要する
     145              : // loot 個数を持つ。個数が小さいほど、その日の loot は生活費に対して価値が高い。
     146              : type EconomyDay struct {
     147              :         Day            int
     148              :         Danger         int
     149              :         NetLootValue   float64 // 1個あたりの期待手取り
     150              :         LootPerDayFood float64 // 1日の食費を賄うのに要する loot 個数
     151              : }
     152              : 
     153              : // EconomyProgression は経過日 1..days の経済を、危険度に応じた loot 手取りと一定の生活費で表す。進むほど loot
     154              : // 価値が上がり生活費が相対的に軽くなるかを見る。乱数を使わない。
     155              : func EconomyProgression(master rawschema.Raws, itemTableName string, days int, p Params) []EconomyDay {
     156            1 :         costPerDay := CostOfLivingPerDay(master, p)
     157            1 :         out := make([]EconomyDay, 0, days)
     158            1 :         for day := 1; day <= days; day++ {
     159            1 :                 danger := int(query.DangerLevelForDay(day))
     160            1 :                 net := ExpectedNetLootValue(master, itemTableName, danger)
     161            1 :                 perFood := 0.0
     162            1 :                 if net > 0 {
     163            1 :                         perFood = costPerDay / net
     164            1 :                 }
     165            1 :                 out = append(out, EconomyDay{Day: day, Danger: danger, NetLootValue: net, LootPerDayFood: perFood})
     166              :         }
     167            1 :         return out
     168              : }
        

Generated by: LCOV version 2.0-1