LCOV - code coverage report
Current view: top level - balance - baseline.go Coverage Total Hit
Test: coverage.lcov Lines: 87.9 % 431 379
Test Date: 2026-11-19 00:25:22 Functions: - 0 0

            Line data    Source code
       1              : package balance
       2              : 
       3              : import (
       4              :         "fmt"
       5              :         "math"
       6              :         "sort"
       7              :         "strings"
       8              : 
       9              :         "github.com/kijimaD/ruins/internal/consts"
      10              :         "github.com/kijimaD/ruins/internal/raw"
      11              :         "github.com/kijimaD/ruins/internal/rawschema"
      12              :         "github.com/kijimaD/ruins/internal/world/query"
      13              :         "github.com/olekukonko/tablewriter/tw"
      14              : )
      15              : 
      16              : // ベースライン導出の基準。プレイヤーは強化なしの素手を最悪ケースとして固定する。cmd と探索で
      17              : // 同じ値を参照し、テーブルと実機能がずれるのを防ぐ。
      18              : const (
      19              :         BaselinePlayer    = "ash"
      20              :         BaselineWeapon    = "bare_hands"
      21              :         BaselineDays      = 21
      22              :         BaselineAreaTable = "ruins_area"
      23              :         BaselineDungeon   = "forgotten_ruins"
      24              : )
      25              : 
      26              : // colDanger は複数の表で使う危険度列の見出し。文字列の重複を1つにまとめる。
      27              : const colDanger = "危険度"
      28              : 
      29              : // TargetPowerRatio は素手・無装備の床の戦力比の目標中心値を返す。床は下限リファレンスで主基準ではない。
      30              : // 主基準は想定プレイヤーの死亡確率 TargetExpectedDeath。敵を進行で強化する設計では後半に床が下回るのが正常。
      31              : func TargetPowerRatio(day int) float64 {
      32            1 :         const d0, m0, d1, m1 = 1, 2.5, 20, 1.3
      33            1 :         switch {
      34              :         case day <= d0:
      35            1 :                 return m0
      36              :         case day >= d1:
      37            1 :                 return m1
      38              :         default:
      39            1 :                 return m0 + (m1-m0)*float64(day-d0)/float64(d1-d0)
      40              :         }
      41              : }
      42              : 
      43              : // TargetExpectedDeath は想定プレイヤーの死亡確率の目標帯を返す。主基準。day1 の [0,2%] から day15 以降の
      44              : // [2%,9%] へ線形に開き、序盤は安全・後半に緊張を立てる。値は設計仮説でプレイで見直す。
      45              : func TargetExpectedDeath(day int) (lo, hi float64) {
      46            1 :         t := float64(day-1) / 14
      47            1 :         t = max(0, min(1, t))
      48            1 :         return 0.02 * t, 0.02 + 0.07*t
      49            1 : }
      50              : 
      51              : // targetBand は目標帯の許容幅。中心±この値を目標帯内とみなす。
      52              : const targetBand = 0.3
      53              : 
      54              : // BaselineRow はベースライン表の1行。ある日の実測 powerRatio と目標帯の関係を持つ。
      55              : type BaselineRow struct {
      56              :         Day        int
      57              :         Danger     int
      58              :         PowerRatio float64
      59              :         Target     float64
      60              :         InRange    bool
      61              : }
      62              : 
      63              : // Baseline は指定した敵テーブルの序盤戦闘ベースラインを返す。プレイヤーは強化なしの素手を
      64              : // 最悪ケースとして固定し、難易度カーブを目標帯と突き合わせる。
      65              : func Baseline(master rawschema.Raws, playerName, weaponName, enemyTableName string, days int) ([]BaselineRow, error) {
      66            1 :         player, err := LoadCombatantFromMember(master, playerName)
      67            1 :         if err != nil {
      68            0 :                 return nil, err
      69            0 :         }
      70            1 :         weapon, err := LoadWeaponFromItem(master, weaponName)
      71            1 :         if err != nil {
      72            0 :                 return nil, err
      73            0 :         }
      74            1 :         curve, err := DifficultyCurve(master, player, weapon, enemyTableName, days)
      75            1 :         if err != nil {
      76            0 :                 return nil, err
      77            0 :         }
      78            1 :         rows := make([]BaselineRow, len(curve))
      79            1 :         for i, m := range curve {
      80            1 :                 tg := TargetPowerRatio(m.Day)
      81            1 :                 rows[i] = BaselineRow{
      82            1 :                         Day:        m.Day,
      83            1 :                         Danger:     m.Danger,
      84            1 :                         PowerRatio: m.PowerRatio,
      85            1 :                         Target:     tg,
      86            1 :                         InRange:    m.PowerRatio >= tg-targetBand && m.PowerRatio <= tg+targetBand,
      87            1 :                 }
      88              :         }
      89            1 :         return rows, nil
      90              : }
      91              : 
      92              : // RenderBaselineMarkdown は全敵テーブルのベースラインを markdown 表にする。日次の powerRatio と目標・帯内かを
      93              : // 並べ、パラメータ変更の影響を diff で読めるようにする。テーブル名は raw 由来の実行時データ。
      94              : func RenderBaselineMarkdown(master rawschema.Raws, playerName, weaponName string, days int) (string, error) {
      95            1 :         var b strings.Builder
      96            1 :         fmt.Fprintf(&b, "# バランスベースライン\n\n")
      97            1 :         fmt.Fprintf(&b, "実コードの戦闘式と raw.toml から乱数なしで導出したバランスの現状値。`make balance-report` で再生成する。\n")
      98            1 :         fmt.Fprintf(&b, "パラメータを変えたときはこのファイルの差分が影響を示す。目標や式の詳細は docs/balance/approach.md を参照。\n\n")
      99            1 : 
     100              :         // 目標帯ダッシュボード。ドメイン横断でスカラー指標が設計上の許容帯に収まるかを一望する
     101            1 :         fmt.Fprintf(&b, "## 目標帯(ドメイン横断)\n\n")
     102            1 :         fmt.Fprintf(&b, "**概要**: 各ドメインのスカラー指標が設計上の目標帯に収まるか。戦闘は日で変わるので下の難易度カーブ側で内外を持つ。\n")
     103            1 :         fmt.Fprintf(&b, "目標帯は設計仮説でプレイで見直す。静的下限がこの範囲に収まれば実プレイは少なくともこれだけ快適という下限側の目安。\n\n")
     104            1 :         targets := DomainTargets(master)
     105            1 :         domainRows := make([][]string, 0, len(targets))
     106            1 :         for _, c := range targets {
     107            1 :                 mark := "外"
     108            1 :                 if c.InRange() {
     109            1 :                         mark = "内"
     110            1 :                 }
     111            1 :                 domainRows = append(domainRows, []string{c.Domain, c.Metric, fmt.Sprintf("%.2f", c.Value), fmt.Sprintf("%.2f〜%.2f", c.Lo, c.Hi), mark})
     112              :         }
     113            1 :         writeMDTable(&b, []string{"ドメイン", "指標", "現状", "目標帯", "判定"}, []tw.Align{alignL, alignL, alignR, alignC, alignC}, domainRows)
     114            1 : 
     115              :         // 序盤戦闘のカーブ
     116            1 :         fmt.Fprintf(&b, "## 序盤戦闘の難易度カーブ\n\n")
     117            1 :         fmt.Fprintf(&b, "**概要**: 各日に素手・無装備の床プレイヤーがどれだけ有利かを戦力比で表す。戦力比は敵を倒す速さ÷敵に倒される速さで、1.0が互角、大きいほど楽。\n")
     118            1 :         fmt.Fprintf(&b, "床は難易度の下限リファレンスで主基準ではない。主基準は「進行カーブ」の想定プレイヤーの死亡確率。敵を進行で強化する設計では床は後半に目標帯を下回り 外 になるのが正常で、装備しないと生き残れないことを表す。\n")
     119            1 :         fmt.Fprintf(&b, "プレイヤーは強化なしの `%s` + `%s` に固定する。\n", playerName, weaponName)
     120            1 :         fmt.Fprintf(&b, "目標帯は day1=2.5 から day20=1.3 へ下げ、許容幅±%.1f。目標は設計仮説でプレイで見直す。判定「内」が目標帯の中、「外」が外。\n\n", targetBand)
     121            1 : 
     122            1 :         tables := raw.PtrSlice(master.EnemyTables)
     123            2 :         sort.Slice(tables, func(i, j int) bool { return tables[i].Id < tables[j].Id })
     124            1 :         for _, table := range tables {
     125            1 :                 rows, err := Baseline(master, playerName, weaponName, table.Id, days)
     126            1 :                 if err != nil {
     127            0 :                         return "", err
     128            0 :                 }
     129            1 :                 fmt.Fprintf(&b, "### %s (%s)\n\n", table.Name, table.Id)
     130            1 :                 var curveRows [][]string
     131            1 :                 for _, r := range rows {
     132            1 :                         mark := "外"
     133            1 :                         if r.InRange {
     134            1 :                                 mark = "内"
     135            1 :                         }
     136            1 :                         curveRows = append(curveRows, []string{fmt.Sprintf("%d", r.Day), fmt.Sprintf("%d", r.Danger), fmt.Sprintf("%.2f", r.PowerRatio), fmt.Sprintf("%.2f", r.Target), mark})
     137              :                 }
     138            1 :                 writeMDTable(&b, []string{"日", colDanger, "戦力比", "目標", "判定"}, []tw.Align{alignR, alignR, alignR, alignR, alignC}, curveRows)
     139              :         }
     140              : 
     141              :         // 戦闘リスク。期待値の比でなく、分布から突然死の確率を測る
     142            1 :         if err := renderCombatRisk(&b, master, playerName, weaponName, days); err != nil {
     143            0 :                 return "", err
     144            0 :         }
     145              : 
     146              :         // 気候。世界温度の季節変動
     147            1 :         fmt.Fprintf(&b, "## 気候(世界温度の季節変動)\n\n")
     148            1 :         fmt.Fprintf(&b, "**概要**: 屋外の世界温度は1年周期で春から夏ピーク、秋、冬底へ巡る。緯度勾配・時間帯・遮蔽を含まない季節そのもの。\n")
     149            1 :         fmt.Fprintf(&b, "冬は準備なしでは生存できない寒さになり、生存圧の寒さ側の上流入力になる。\n\n")
     150            1 :         calendar := raw.NewCalendarDefs(master)
     151            1 :         var climateRows [][]string
     152            1 :         for _, day := range []int{1, 4, 8, 12, 16, 20, 24, 28} {
     153            1 :                 climateRows = append(climateRows, []string{fmt.Sprintf("%d", day), fmt.Sprintf("%d", WorldTemperatureAtDay(calendar, day))})
     154            1 :         }
     155            1 :         writeMDTable(&b, []string{"経過日", "世界温度(℃)"}, []tw.Align{alignR, alignR}, climateRows)
     156            1 : 
     157              :         // 生存圧
     158            1 :         fmt.Fprintf(&b, "## 生存圧\n\n")
     159            1 :         fmt.Fprintf(&b, "**概要**: 補給なしで生き延びられる時間。食料は日単位、寒さはターン単位で時間スケールが大きく違う。\n")
     160            1 :         fmt.Fprintf(&b, "飢えは満腹度が尽きるまで、寒さは平熱から低体温が発生するまでを表す。実効温度は周囲温度に断熱を足した値。\n\n")
     161            1 :         params := DefaultParams(master)
     162            1 :         writeMDTable(&b, []string{"指標", "値"}, []tw.Align{alignL, alignR}, [][]string{
     163            1 :                 {"栄養失調まで(満腹度33%未満)の日数", fmt.Sprintf("%.2f", DaysUntilStarving(params))},
     164            1 :                 {"満腹度が尽きるまでの日数", fmt.Sprintf("%.2f", DaysUntilHungerEmpty(params))},
     165            1 :                 {"睡眠なしで疲労までの日数", fmt.Sprintf("%.2f", DaysUntilTired(params))},
     166            1 :                 {"睡眠なしで過労までの日数", fmt.Sprintf("%.2f", DaysUntilExhausted(params))},
     167            1 :                 {"満タンから睡眠で回復し切るターン(地べた)", fmt.Sprintf("%.0f", SleepTurnsToFullRecover(params))},
     168            1 :                 {"釣り合いに要する睡眠時間の割合", fmt.Sprintf("%.0f%%", SleepTimeFraction(params)*100)},
     169            1 :         })
     170            1 :         var hypoRows [][]string
     171            1 :         for _, temp := range []int{-20, -10, 0, 5, 10, 15} {
     172            1 :                 hypoRows = append(hypoRows, []string{fmt.Sprintf("%d", temp), fmt.Sprintf("%.0f", TurnsToHypothermia(temp))})
     173            1 :         }
     174            1 :         writeMDTable(&b, []string{"実効温度(℃)", "低体温までのターン"}, []tw.Align{alignR, alignR}, hypoRows)
     175            1 : 
     176              :         // 身体の連鎖。状態異常→血液低下→HP減
     177            1 :         fmt.Fprintf(&b, "## 身体の連鎖(血液→HP)\n\n")
     178            1 :         fmt.Fprintf(&b, "**概要**: 状態異常は血液を下げ、血液が危険域(40)を割ると毎ターンHPが減り始める。連鎖の終端を示す。\n")
     179            1 :         fmt.Fprintf(&b, "上流は状態異常の重症度で、切傷は重症度1段あたり血液-25、低体温は-22。重症(×3)の切傷1つで血液は約25まで落ちる。\n\n")
     180            1 :         var bloodRows [][]string
     181            1 :         for _, blood := range []int{100, 50, 40, 30, 20, 10, 0} {
     182            1 :                 bloodRows = append(bloodRows, []string{fmt.Sprintf("%d", blood), fmt.Sprintf("%d", HPDrainPerTurnAtBlood(blood))})
     183            1 :         }
     184            1 :         writeMDTable(&b, []string{"血液", "HP減(/ターン)"}, []tw.Align{alignR, alignR}, bloodRows)
     185            1 : 
     186              :         // 経済
     187            1 :         fmt.Fprintf(&b, "## 経済(loot の手取り)\n\n")
     188            1 :         fmt.Fprintf(&b, "**概要**: 拾った loot を店で売った実収入。売値は価値の一定割合。\n\n")
     189            1 : 
     190              :         // 収入側。危険度ごとに拾えるアイテムの期待価値
     191            1 :         fmt.Fprintf(&b, "収入側。危険度ごとに拾える1個あたりの期待価値。危険度が上がるほど高価な loot が出る。\n\n")
     192            1 :         var lootValueRows [][]string
     193            1 :         for _, danger := range []int{1, 3, 5, 8} {
     194            1 :                 lootValueRows = append(lootValueRows, []string{fmt.Sprintf("%d", danger),
     195            1 :                         fmt.Sprintf("%.0f", ExpectedLootValue(master, "ruins_area", danger)),
     196            1 :                         fmt.Sprintf("%.0f", ExpectedLootValue(master, "forest", danger)),
     197            1 :                         fmt.Sprintf("%.0f", ExpectedLootValue(master, "cave", danger))})
     198            1 :         }
     199            1 :         writeMDTable(&b, []string{colDanger, "廃墟", "森", "洞窟"}, []tw.Align{alignR, alignR, alignR, alignR}, lootValueRows)
     200            1 : 
     201            1 :         fmt.Fprintf(&b, "手取り側。上の額面に売却倍率を掛けた1個あたりの期待手取り。\n\n")
     202            1 :         var netLootRows [][]string
     203            1 :         for _, danger := range []int{1, 3, 5, 8} {
     204            1 :                 netLootRows = append(netLootRows, []string{fmt.Sprintf("%d", danger),
     205            1 :                         fmt.Sprintf("%.0f", ExpectedNetLootValue(master, "ruins_area", danger)),
     206            1 :                         fmt.Sprintf("%.0f", ExpectedNetLootValue(master, "forest", danger)),
     207            1 :                         fmt.Sprintf("%.0f", ExpectedNetLootValue(master, "cave", danger))})
     208            1 :         }
     209            1 :         writeMDTable(&b, []string{colDanger, "廃墟", "森", "洞窟"}, []tw.Align{alignR, alignR, alignR, alignR}, netLootRows)
     210            1 : 
     211            1 :         if err := writeRunIncome(&b, master); err != nil {
     212            0 :                 return "", err
     213            0 :         }
     214              : 
     215              :         // 経済の進行。支出側の生活費と、日ごとに loot がそれを賄えるか
     216            1 :         fmt.Fprintf(&b, "経済の進行。1日の食費は満腹度減耗を最安の食料で埋め戻す費用で %.0f。日が進むと危険度が上がり loot 手取りも上がるので、\n", CostOfLivingPerDay(master, DefaultParams(master)))
     217            1 :         fmt.Fprintf(&b, "1日分の食費を賄うのに要る loot 個数が減る。個数が小さいほど、その日の探索は生活費に対して割が良い。\n\n")
     218            1 :         var econProgRows [][]string
     219            1 :         for _, d := range EconomyProgression(master, "ruins_area", days, params) {
     220            1 :                 econProgRows = append(econProgRows, []string{fmt.Sprintf("%d", d.Day), fmt.Sprintf("%d", d.Danger), fmt.Sprintf("%.0f", d.NetLootValue), fmt.Sprintf("%.2f", d.LootPerDayFood)})
     221            1 :         }
     222            1 :         writeMDTable(&b, []string{"日", colDanger, "1個あたり手取り", "1日分の食費に要る loot 個数"}, []tw.Align{alignR, alignR, alignR, alignR}, econProgRows)
     223            1 : 
     224              :         // 物流
     225            1 :         fmt.Fprintf(&b, "## 物流(燃料・重量・航続)\n\n")
     226            1 :         fmt.Fprintf(&b, "**概要**: キューブがどれだけ随伴できるか。1歩の燃費は基準%d+積載1kgごとに%dで、積むほど悪化する。\n", consts.FollowFuelBase, consts.FollowFuelPerKg)
     227            1 :         fmt.Fprintf(&b, "燃料はくべた時点で燃料ポイントになり重量を持たない。燃料タンクの基準容量は%dで、新規開始時は満タン。積載容量は%dkg。\n\n", consts.CubeFuelCapacityBase, consts.CubeWeightCapacityKg)
     228            1 :         var fuelCostRows [][]string
     229            1 :         for _, kg := range []int{0, 100, 250, 500} {
     230            1 :                 load := consts.Milligram(kg) * consts.MilligramPerKg
     231            1 :                 fuelCostRows = append(fuelCostRows, []string{fmt.Sprintf("%d", kg), fmt.Sprintf("%d", query.FollowFuelCost(load)), fmt.Sprintf("%.0f", FollowRangeTiles(consts.CubeFuelCapacityBase, load))})
     232            1 :         }
     233            1 :         writeMDTable(&b, []string{"積荷(kg)", "燃費(/歩)", "満タン航続(歩)"}, []tw.Align{alignR, alignR, alignR}, fuelCostRows)
     234            1 :         materials, err := raw.NewMaterialDefs(master)
     235            1 :         if err != nil {
     236            0 :                 return "", err
     237            0 :         }
     238            1 :         writeMDTable(&b, []string{"くべる燃料", "燃料ポイント", "積荷0の航続(歩)"}, []tw.Align{alignL, alignR, alignR}, [][]string{
     239            1 :                 {"OIL 10kg", fmt.Sprintf("%d", materials.HeatOf(rawschema.OIL, 10*consts.MilligramPerKg)), fmt.Sprintf("%.0f", FollowRangeTiles(materials.HeatOf(rawschema.OIL, 10*consts.MilligramPerKg), 0))},
     240            1 :                 {"WOOD 10kg", fmt.Sprintf("%d", materials.HeatOf(rawschema.WOOD, 10*consts.MilligramPerKg)), fmt.Sprintf("%.0f", FollowRangeTiles(materials.HeatOf(rawschema.WOOD, 10*consts.MilligramPerKg), 0))},
     241            1 :         })
     242            1 : 
     243            1 :         fmt.Fprintf(&b, "同じ燃料は火にくべると燃焼ターンになる。地面直の火は熱量の半分を時間へ変える。\n\n")
     244            1 :         writeMDTable(&b, []string{"燃料", "燃焼ターン"}, []tw.Align{alignL, alignR}, [][]string{
     245            1 :                 {"OIL 10kg", fmt.Sprintf("%d", FuelBurnTurns(materials, rawschema.OIL, 10))},
     246            1 :                 {"WOOD 10kg", fmt.Sprintf("%d", FuelBurnTurns(materials, rawschema.WOOD, 10))},
     247            1 :         })
     248            1 : 
     249              :         // 感度行列。つまみ×メトリクスの横断ヤコビアン
     250            1 :         renderSensitivityMatrix(&b, master)
     251            1 : 
     252              :         // 交換レート。同じメトリクスを保つためのつまみ間の相互補償
     253            1 :         renderExchangeRates(&b, master)
     254            1 : 
     255              :         // 境界マージン。目標帯を割るまでのつまみの余白
     256            1 :         renderBoundaryMargins(&b, master)
     257            1 : 
     258              :         // 武器・スキルの各分析。劣化量・viability・スキル深度をまとめて書き出す
     259            1 :         if err := renderWeaponSkillSections(&b, master); err != nil {
     260            0 :                 return "", err
     261            0 :         }
     262              : 
     263              :         // ビルド別のブレ。静的下限に加え、スキル・装備・バフで戦力が振れる幅を見る
     264            1 :         if builds, err := RepresentativeBuilds(master); err == nil {
     265            1 :                 fmt.Fprintf(&b, "## ビルド別のブレ(廃墟)\n\n")
     266            1 :                 fmt.Fprintf(&b, "**概要**: 強化なしの下限に加え、想定攻撃回数から導いたスキル熟練度でダメージが伸びたビルドを重ね、戦力比が振れる幅を見る。\n")
     267            1 :                 names := make([]string, 0, len(builds))
     268            1 :                 for _, bp := range builds {
     269            1 :                         names = append(names, bp.Name)
     270            1 :                 }
     271            1 :                 fmt.Fprintf(&b, "ビルドは %v。倍率は恣意的でなくスキル成長と熟練度から導く。幅が広いほどビルド次第で難易度が振れ、終盤で許容を超えるならバフが強すぎる。\n\n", names)
     272            1 :                 if spread, err := BuildSpread(master, builds, "ruins_area", 21); err == nil {
     273            1 :                         var spreadRows [][]string
     274            1 :                         for _, r := range spread {
     275            1 :                                 if r.Day%4 == 1 || r.Day == 21 {
     276            1 :                                         spreadRows = append(spreadRows, []string{fmt.Sprintf("%d", r.Day), fmt.Sprintf("%.2f", r.MinRatio), fmt.Sprintf("%.2f", r.MaxRatio), fmt.Sprintf("%.2f", r.Spread())})
     277            1 :                                 }
     278              :                         }
     279            1 :                         writeMDTable(&b, []string{"日", "下限の戦力比", "最強の戦力比", "幅"}, []tw.Align{alignR, alignR, alignR, alignR}, spreadRows)
     280              :                 }
     281            1 :                 if stages, err := StageSpreads(master, builds, "ruins_area"); err == nil {
     282            1 :                         fmt.Fprintf(&b, "段階ごとのブレ幅と許容帯。終盤ほど許容を絞る。判定「外」はビルド次第で振れすぎる段階。許容帯は設計仮説。\n\n")
     283            1 :                         var stageRows [][]string
     284            1 :                         for _, s := range stages {
     285            1 :                                 mark := "外"
     286            1 :                                 if s.InRange() {
     287            0 :                                         mark = "内"
     288            0 :                                 }
     289            1 :                                 stageRows = append(stageRows, []string{s.Stage, fmt.Sprintf("%d-%d", s.FromDay, s.ToDay), fmt.Sprintf("%.2f", s.MaxSpread), fmt.Sprintf("%.2f", s.Tolerance), mark})
     290              :                         }
     291            1 :                         writeMDTable(&b, []string{"段階", "日", "最大の幅", "許容", "判定"}, []tw.Align{alignL, alignL, alignR, alignR, alignC}, stageRows)
     292              :                 }
     293              :         }
     294              : 
     295              :         // 多目的探索。序盤・中盤・終盤の目標逸脱を同時に小さくする武器倍率の非劣集合
     296            1 :         fmt.Fprintf(&b, "## 多目的探索(Pareto 前線)\n\n")
     297            1 :         fmt.Fprintf(&b, "**概要**: プレイヤー武器 bare_hands と敵武器 bite のダメージ倍率を格子で動かし、day1・day10・day20 の目標戦力比からの逸脱を同時に見る。\n")
     298            1 :         fmt.Fprintf(&b, "単変数探索は day20 しか合わせられないが、複数日はトレードオフになる。どれかを詰めると別が緩む非劣な組だけを載せる。逸脱は小さいほど目標に近い。\n\n")
     299            1 :         paretoKnobs := []string{BaselineWeapon, "bite"}
     300            1 :         front := ParetoFront(master, paretoKnobs, []float64{0.8, 1.0, 1.5}, []int{1, 10, 20})
     301            1 :         sort.Slice(front, func(i, j int) bool {
     302            1 :                 if front[i].Factors[paretoKnobs[0]] != front[j].Factors[paretoKnobs[0]] {
     303            0 :                         return front[i].Factors[paretoKnobs[0]] < front[j].Factors[paretoKnobs[0]]
     304            0 :                 }
     305            1 :                 return front[i].Factors[paretoKnobs[1]] < front[j].Factors[paretoKnobs[1]]
     306              :         })
     307            1 :         var paretoRows [][]string
     308            1 :         for _, p := range front {
     309            1 :                 paretoRows = append(paretoRows, []string{
     310            1 :                         fmt.Sprintf("%.1f", p.Factors[paretoKnobs[0]]), fmt.Sprintf("%.1f", p.Factors[paretoKnobs[1]]),
     311            1 :                         fmt.Sprintf("%.2f", p.Deviations[0]), fmt.Sprintf("%.2f", p.Deviations[1]), fmt.Sprintf("%.2f", p.Deviations[2]),
     312            1 :                 })
     313            1 :         }
     314            1 :         writeMDTable(&b, []string{"bare_hands倍率", "bite倍率", "day1逸脱", "day10逸脱", "day20逸脱"}, []tw.Align{alignR, alignR, alignR, alignR, alignR}, paretoRows)
     315            1 : 
     316              :         // 進行・成長。スキルを上げるのに要する攻撃回数
     317            1 :         fmt.Fprintf(&b, "## 進行・成長(スキル)\n\n")
     318            1 :         fmt.Fprintf(&b, "**概要**: 武器スキルを上げるのに要する攻撃回数。1攻撃ごとに減衰しながら経験値が入り、スキル値が高いほど遅くなる。\n")
     319            1 :         fmt.Fprintf(&b, "能力値が高いほど成長が速い。ここは静的下限として攻撃回数だけを見る。経過日への写像は攻撃頻度に依るので載せない。\n\n")
     320            1 :         var skillRows [][]string
     321            1 :         for _, abil := range []int{0, 5, 10} {
     322            1 :                 skillRows = append(skillRows, []string{fmt.Sprintf("%d", abil),
     323            1 :                         fmt.Sprintf("%d", AttacksToSkillLevel(abil, 10)), fmt.Sprintf("%d", AttacksToSkillLevel(abil, 30)), fmt.Sprintf("%d", AttacksToSkillLevel(abil, 50)),
     324            1 :                         fmt.Sprintf("%d", SkillLevelAfterAttacks(abil, 100))})
     325            1 :         }
     326            1 :         writeMDTable(&b, []string{"能力値", "Lv10まで", "Lv30まで", "Lv50まで", "100攻撃で到達Lv"}, []tw.Align{alignR, alignR, alignR, alignR, alignR}, skillRows)
     327            1 :         return b.String(), nil
     328              : }
     329              : 
     330              : // renderCombatRisk は戦闘リスクのカーブを markdown で書き出す。難易度カーブが期待値の比を見るのに対し、
     331              : // こちらは吸収マルコフ連鎖で解いた死亡確率と決着ターンを日ごとに出す。突然死の裾を可視化する。
     332              : func renderCombatRisk(b *strings.Builder, master rawschema.Raws, playerName, weaponName string, days int) error {
     333            1 :         player, err := LoadCombatantFromMember(master, playerName)
     334            1 :         if err != nil {
     335            0 :                 return err
     336            0 :         }
     337            1 :         weapon, err := LoadWeaponFromItem(master, weaponName)
     338            1 :         if err != nil {
     339            0 :                 return err
     340            0 :         }
     341            1 :         curve, err := CombatRiskCurve(master, player, weapon, BaselineAreaTable, days)
     342            1 :         if err != nil {
     343            0 :                 return err
     344            0 :         }
     345            1 :         fmt.Fprintf(b, "## 戦闘リスク(死亡確率・廃墟)\n\n")
     346            1 :         fmt.Fprintf(b, "**概要**: その日の敵プールに1体遭遇したときに倒される確率と、決着までの期待ターン。戦力比が期待値の比なのに対し、\n")
     347            1 :         fmt.Fprintf(b, "こちらは戦闘を吸収マルコフ連鎖として厳密に解き、平均では見えない突然死の裾を測る。プレイヤーは強化なしの `%s` + `%s` 固定。\n\n", playerName, weaponName)
     348            1 :         var riskRows [][]string
     349            1 :         for _, d := range curve {
     350            1 :                 riskRows = append(riskRows, []string{fmt.Sprintf("%d", d.Day), fmt.Sprintf("%d", d.Danger), fmt.Sprintf("%.1f%%", d.DeathProb*100), fmt.Sprintf("%.1f", d.ExpTurns)})
     351            1 :         }
     352            1 :         writeMDTable(b, []string{"日", colDanger, "死亡確率", "期待決着ターン"}, []tw.Align{alignR, alignR, alignR, alignR}, riskRows)
     353            1 :         return renderProgression(b, master, player, weapon, days)
     354              : }
     355              : 
     356              : // renderProgression は静的下限と想定プレイヤーの進行カーブを markdown で書き出す。難易度の側は日→危険度で
     357              : // 進み、プレイヤーの側は想定攻撃頻度からその日の想定スキルで進む。床と想定の帯で進行度調整を見る。
     358              : func renderProgression(b *strings.Builder, master rawschema.Raws, player CombatantStats, weapon WeaponStats, days int) error {
     359            1 :         curve, err := ProgressionCurve(master, player, weapon, BaselineAreaTable, days, DefaultAttacksPerDay)
     360            1 :         if err != nil {
     361            0 :                 return err
     362            0 :         }
     363            1 :         fmt.Fprintf(b, "## 進行カーブ(床 vs 想定プレイヤー・廃墟)\n\n")
     364            1 :         fmt.Fprintf(b, "**概要**: 難易度の側は日→危険度で進み、プレイヤーの側は1日%d攻撃の仮説からその日の想定スキルで進む。\n", DefaultAttacksPerDay)
     365            1 :         fmt.Fprintf(b, "床はスキル0・無装備の最悪ケース、想定はその日までに育ったスキルと装備防御を織り込んだ体験。主基準は想定の死亡確率で、目標帯 TargetExpectedDeath と照合して 内/外 を出す。床は難易度の下限リファレンスで、後半は目標を下回るハードモードになるのが正常。攻撃頻度と装備防御は設計仮説。\n\n")
     366            1 :         var rows [][]string
     367            1 :         for _, d := range curve {
     368            1 :                 lo, hi := TargetExpectedDeath(d.Day)
     369            1 :                 mark := "外"
     370            1 :                 if d.DeathExpected >= lo && d.DeathExpected <= hi {
     371            1 :                         mark = "内"
     372            1 :                 }
     373            1 :                 rows = append(rows, []string{
     374            1 :                         fmt.Sprintf("%d", d.Day), fmt.Sprintf("%d", d.Danger), fmt.Sprintf("%d", d.SkillLevel), fmt.Sprintf("+%d", d.GearDefense),
     375            1 :                         fmt.Sprintf("%.1f%%", d.DeathFloor*100), fmt.Sprintf("%.1f%%", d.DeathExpected*100), fmt.Sprintf("%.0f〜%.0f%%", lo*100, hi*100),
     376            1 :                         mark, fmt.Sprintf("%.1f", d.TurnsFloor), fmt.Sprintf("%.1f", d.TurnsExpected),
     377            1 :                 })
     378              :         }
     379            1 :         writeMDTable(b, []string{"日", colDanger, "想定Lv", "想定防御", "死亡(床)", "死亡(想定)", "想定の目標帯", "判定", "決着ターン(床)", "決着ターン(想定)"}, []tw.Align{alignR, alignR, alignR, alignR, alignR, alignR, alignC, alignC, alignR, alignR}, rows)
     380            1 :         fmt.Fprintf(b, "想定の死亡確率が目標帯に収まれば、成長込みでも後半に狙った緊張が保たれている。床は無装備・無成長の下限で、後半に目標を下回る=装備しないと生き残れないことを表す。\n\n")
     381            1 :         return nil
     382              : }
     383              : 
     384              : // renderSensitivityMatrix はドメイン横断の感度行列を markdown で書き出す。RenderBaselineMarkdown の
     385              : // 複雑度を抑えるため別関数にする。
     386              : func renderSensitivityMatrix(b *strings.Builder, master rawschema.Raws) {
     387            1 :         fmt.Fprintf(b, "## 感度行列(各つまみ+10%%、ドメイン横断)\n\n")
     388            1 :         fmt.Fprintf(b, "**概要**: どのつまみがどのメトリクスをどれだけ動かすか。各つまみを+10%%したときの各メトリクスの変化率。\n")
     389            1 :         fmt.Fprintf(b, "多くはブロック対角、すなわち各つまみは自分のドメインだけを動かす。横断するのは1日ターン数のような共通の分母だけ。整数丸めで小さな値は表に出ないことがある。\n\n")
     390            1 :         header := append([]string{"つまみ(ドメイン)"}, SensitivityMetricNames...)
     391            1 :         aligns := make([]tw.Align, 1+len(SensitivityMetricNames))
     392            1 :         aligns[0] = alignL
     393            1 :         for i := 1; i < len(aligns); i++ {
     394            1 :                 aligns[i] = alignR
     395            1 :         }
     396            1 :         knobs := CrossDomainSensitivity(master)
     397            1 :         rows := make([][]string, 0, len(knobs))
     398            1 :         for _, k := range knobs {
     399            1 :                 row := []string{fmt.Sprintf("%s(%s)", k.Knob, k.Domain)}
     400            1 :                 for _, c := range k.Cells {
     401            1 :                         if c.PctChange == 0 {
     402            1 :                                 row = append(row, "-")
     403            1 :                         } else {
     404            1 :                                 row = append(row, fmt.Sprintf("%+.1f%%", c.PctChange))
     405            1 :                         }
     406              :                 }
     407            1 :                 rows = append(rows, row)
     408              :         }
     409            1 :         writeMDTable(b, header, aligns, rows)
     410              : }
     411              : 
     412              : // renderExchangeRates はメトリクスごとの交換レート表を markdown で書き出す。行のつまみを+10%した
     413              : // とき、列のつまみをどれだけ動かせば同じメトリクスに据え置けるかの相互補償を示す。
     414              : func renderExchangeRates(b *strings.Builder, master rawschema.Raws) {
     415            1 :         fmt.Fprintf(b, "## 交換レート(相互補償)\n\n")
     416            1 :         fmt.Fprintf(b, "**概要**: あるつまみを+10%%したとき、同じメトリクスを元へ戻すには別のつまみをどれだけ動かせばよいか。\n")
     417            1 :         fmt.Fprintf(b, "行のつまみを+10%%し、列のつまみの変化率で打ち消す。実式を二分探索で解いた値で、感度の比の線形近似より正確。\n")
     418            1 :         fmt.Fprintf(b, "そのメトリクスを動かすつまみが2つ以上あるときだけ表を出す。負は相手を減らして打ち消すことを表す。範囲外で両立不能なら「×」。\n\n")
     419            1 :         for _, mx := range ExchangeRates(master) {
     420            1 :                 fmt.Fprintf(b, "### %s\n\n", mx.Metric)
     421            1 :                 header := append([]string{"+10%↓ \\ 補償→"}, mx.Knobs...)
     422            1 :                 aligns := make([]tw.Align, 1+len(mx.Knobs))
     423            1 :                 aligns[0] = alignL
     424            1 :                 for i := 1; i < len(aligns); i++ {
     425            1 :                         aligns[i] = alignR
     426            1 :                 }
     427            1 :                 rows := make([][]string, 0, len(mx.Rows))
     428            1 :                 for _, row := range mx.Rows {
     429            1 :                         cells := []string{row.Knob}
     430            1 :                         for _, c := range row.Cells {
     431            1 :                                 switch {
     432              :                                 case c.Compensator == row.Knob:
     433            1 :                                         cells = append(cells, "-")
     434              :                                 case !c.OK:
     435            0 :                                         cells = append(cells, "×")
     436              :                                 default:
     437            1 :                                         cells = append(cells, fmt.Sprintf("%+.1f%%", c.PctChange))
     438              :                                 }
     439              :                         }
     440            1 :                         rows = append(rows, cells)
     441              :                 }
     442            1 :                 writeMDTable(b, header, aligns, rows)
     443              :         }
     444              : }
     445              : 
     446              : // renderBoundaryMargins は目標帯の余白を markdown で書き出す。各つまみを動かして目標帯を割るまでの
     447              : // 変化率を、崖の近い順に並べる。凍結ゲートの点固定を余白監視へ拡張したもの。
     448              : func renderBoundaryMargins(b *strings.Builder, master rawschema.Raws) {
     449            1 :         margins := BoundaryMargins(master)
     450            1 :         sort.Slice(margins, func(i, j int) bool {
     451            1 :                 if margins[i].OK != margins[j].OK {
     452            1 :                         return margins[i].OK
     453            1 :                 }
     454            1 :                 return math.Abs(margins[i].NearestPct) < math.Abs(margins[j].NearestPct)
     455              :         })
     456            1 :         fmt.Fprintf(b, "## 目標帯の余白(境界マージン)\n\n")
     457            1 :         fmt.Fprintf(b, "**概要**: 各つまみを動かしたとき、メトリクスが目標帯を割るまでの余白。崖の近い順に並ぶ。\n")
     458            1 :         fmt.Fprintf(b, "凍結ゲートが現在値の点を固定するのに対し、こちらは崖までの距離を測る。余白が小さいつまみほど、少しの調整で帯を外れる。範囲内で端に届かなければ「遠い」。\n\n")
     459            1 :         rows := make([][]string, 0, len(margins))
     460            1 :         for _, m := range margins {
     461            1 :                 if !m.OK {
     462            1 :                         rows = append(rows, []string{m.Metric, m.Knob, "-", "遠い"})
     463            1 :                         continue
     464              :                 }
     465            1 :                 rows = append(rows, []string{m.Metric, m.Knob, m.Edge, fmt.Sprintf("%+.1f%%", m.NearestPct)})
     466              :         }
     467            1 :         writeMDTable(b, []string{"メトリクス", "つまみ", "最寄りの端", "余白"}, []tw.Align{alignL, alignL, alignC, alignR}, rows)
     468              : }
     469              : 
     470              : // renderWeaponRestriction は武器を素手へ制限したときの死亡確率の劣化量を書き出す。劣化が大きい順に必須な武器を、
     471              : // 小さい順に効かない死にコンテンツ候補を見せる。Restricted Play の翻案。
     472              : func renderWeaponRestriction(b *strings.Builder, master rawschema.Raws) error {
     473            1 :         const day = 20
     474            1 :         values, baseDeath, err := WeaponRestrictionValues(master, BaselineAreaTable, day)
     475            1 :         if err != nil {
     476            0 :                 return err
     477            0 :         }
     478            1 :         if len(values) == 0 {
     479            0 :                 return nil
     480            0 :         }
     481            1 :         fmt.Fprintf(b, "## 要素の劣化量(武器を素手へ制限・廃墟day%d)\n\n", day)
     482            1 :         fmt.Fprintf(b, "**概要**: 各武器(近接・遠距離)を持たせたときの死亡確率と、素手へ制限したときの死亡確率の上昇量。上昇量が大きいほどその武器は必須で、\n")
     483            1 :         fmt.Fprintf(b, "ゼロに近いほど素手と大差ない死にコンテンツ候補。素手の死亡確率は %.1f%%。Restricted Play をサバイバルへ翻案した指標。\n", baseDeath*100)
     484            1 :         fmt.Fprintf(b, "遠距離武器は弾薬の消費と費用を含めないので、その劣化量は弾薬コストを無視した上限として読む。\n\n")
     485            1 : 
     486            1 :         const top, bottom = 15, 5
     487            1 :         var rows [][]string
     488            1 :         for i, v := range values {
     489            1 :                 if len(values) > top+bottom && i >= top && i < len(values)-bottom {
     490            1 :                         continue
     491              :                 }
     492            1 :                 if i == top && len(values) > top+bottom {
     493            0 :                         rows = append(rows, []string{fmt.Sprintf("… (%d件省略)", len(values)-top-bottom), "", "", ""})
     494            0 :                 }
     495            1 :                 rows = append(rows, []string{v.Element, fmt.Sprintf("%.1f%%", v.DeathProbWith*100), fmt.Sprintf("%+.1f%%", v.Degradation*100), fmt.Sprintf("%.1f", v.ExpTurnsWith)})
     496              :         }
     497            1 :         writeMDTable(b, []string{"武器", "死亡確率", "劣化量(素手比)", "期待決着ターン"}, []tw.Align{alignL, alignR, alignR, alignR}, rows)
     498            1 :         if len(values) > top+bottom {
     499            1 :                 fmt.Fprintf(b, "全%d武器のうち上位%d件と下位%d件を表示。\n\n", len(values), top, bottom)
     500            1 :         } else {
     501            0 :                 fmt.Fprintf(b, "全%d武器を表示。\n\n", len(values))
     502            0 :         }
     503            1 :         return nil
     504              : }
     505              : 
     506              : // renderWeaponSkillSections は武器・スキルの各分析を順に書き出す。RenderBaselineMarkdown の複雑度を
     507              : // 抑えるため、エラーを返すレンダラをまとめる。
     508              : func renderWeaponSkillSections(b *strings.Builder, master rawschema.Raws) error {
     509            1 :         if err := renderWeaponRestriction(b, master); err != nil {
     510            0 :                 return err
     511            0 :         }
     512            1 :         if err := renderViability(b, master); err != nil {
     513            0 :                 return err
     514            0 :         }
     515            1 :         return renderSkillDepth(b, master)
     516              : }
     517              : 
     518              : // renderViability は武器ロスターの viability を markdown で書き出す。Pfau の知見に基づき、使える武器が
     519              : // 多く、罠が少なく、viable どうしに差がある状態を健全とみなす。全ビルド等価な symmetry は避ける。
     520              : func renderViability(b *strings.Builder, master rawschema.Raws) error {
     521            1 :         const day = 20
     522            1 :         s, err := WeaponViability(master, BaselineAreaTable, day)
     523            1 :         if err != nil {
     524            0 :                 return err
     525            0 :         }
     526            1 :         if s.Total == 0 {
     527            0 :                 return nil
     528            0 :         }
     529            1 :         fmt.Fprintf(b, "## 武器の viability(廃墟day%d)\n\n", day)
     530            1 :         fmt.Fprintf(b, "**概要**: プレイヤーは全選択肢が等価な symmetry を嫌い、どれも使えるが差がある viability を好む。\n")
     531            1 :         fmt.Fprintf(b, "死亡確率が %.0f%%以下を viable とし、素手より弱いものを罠として数える。viable どうしの決着ターンに幅があれば選択に意味がある。\n\n", s.Ceiling*100)
     532            1 :         verdict := "symmetry寄り。選択の差が小さい"
     533            1 :         if s.Distinct() {
     534            0 :                 verdict = "viabilityあり。使える武器に差がある"
     535            0 :         }
     536            1 :         writeMDTable(b, []string{"指標", "値"}, []tw.Align{alignL, alignR}, [][]string{
     537            1 :                 {"評価した武器(近接・遠距離)", fmt.Sprintf("%d", s.Total)},
     538            1 :                 {fmt.Sprintf("viable(死亡確率%.0f%%以下)", s.Ceiling*100), fmt.Sprintf("%d (%.0f%%)", s.Viable, s.ViableRate()*100)},
     539            1 :                 {"罠(素手より弱い)", fmt.Sprintf("%d", s.Traps)},
     540            1 :                 {"viable の決着ターン幅", fmt.Sprintf("%.1f〜%.1f", s.ViableTTKMin, s.ViableTTKMax)},
     541            1 :                 {"判定", verdict},
     542            1 :         })
     543            1 :         fmt.Fprintf(b, "罠は装備すると素手より不利になる死にコンテンツ候補。viable が多く差があるほど、ビルドの選択が意味を持つ。\n\n")
     544            1 :         return nil
     545              : }
     546              : 
     547              : // renderSkillDepth はスキル進行の手応えを markdown で書き出す。弱い武器と強い武器で、レベルアップが
     548              : // 体験に響く実効ティアと、丸めで死んだティアの割合を対比する。
     549              : func renderSkillDepth(b *strings.Builder, master rawschema.Raws) error {
     550            1 :         const day = 20
     551            1 :         fmt.Fprintf(b, "## スキル深度(レベルアップの手応え・廃墟day%d)\n\n", day)
     552            1 :         fmt.Fprintf(b, "**概要**: 素手スキルを1レベル上げるたびに、敵プールの撃破ターンがどれだけ縮むか。熟練度倍率は実ゲームと同じく\n")
     553            1 :         fmt.Fprintf(b, "能力+ダイス+武器の base 全体へ切り捨てで掛かる。撃破ターンが動かないレベルは体験に響かない死んだティア。NTBEA のティア識別性を翻案した指標。\n\n")
     554            1 : 
     555            1 :         var rows [][]string
     556            1 :         weapons := []string{BaselineWeapon, "iron_sword"}
     557            1 :         for _, wn := range weapons {
     558            1 :                 prof, err := SkillDepthProfileFor(master, wn, BaselineAreaTable, day)
     559            1 :                 if err != nil {
     560            0 :                         return err
     561            0 :                 }
     562            1 :                 total := len(prof.Tiers) - 1
     563            1 :                 if total < 1 {
     564            0 :                         continue
     565              :                 }
     566            1 :                 gap := "-"
     567            1 :                 if prof.EffectiveSteps > 0 {
     568            1 :                         gap = fmt.Sprintf("%.3f", prof.MinEffectiveGap)
     569            1 :                 }
     570            1 :                 rows = append(rows, []string{wn, fmt.Sprintf("%d", total), fmt.Sprintf("%d", prof.EffectiveSteps), fmt.Sprintf("%d", prof.DeadTiers), gap})
     571              :         }
     572            1 :         writeMDTable(b, []string{"武器", "総レベル", "実効ティア", "死んだティア", "実効の最小改善(ターン)"}, []tw.Align{alignL, alignR, alignR, alignR, alignR}, rows)
     573            1 :         fmt.Fprintf(b, "熟練度が base 全体へ効くので進行の大半は手応えがある。死んだティアは撃破ターンが既に短い高レベル帯に偏る。弱い武器ほど base が小さく、切り捨てでわずかに死にやすい。\n\n")
     574            1 :         return nil
     575              : }
     576              : 
     577              : // writeRunIncome は基準のダンジョンを探索1回で拾う loot の期待収入の表を書く
     578              : func writeRunIncome(b *strings.Builder, master rawschema.Raws) error {
     579            1 :         ruins, err := raw.GetDungeon(master, BaselineDungeon)
     580            1 :         if err != nil {
     581            0 :                 return err
     582            0 :         }
     583            1 :         fmt.Fprintf(b, "探索1回の期待収入。各層で約%g個拾い層の深さを危険度として手取りを積んだ閉形式。層数は生存に依る scenario 入力。\n", ruins.ItemCount.Mean())
     584            1 :         fmt.Fprintf(b, "総収支はこの収入から移動燃料コストを引くが、1回の移動タイル数はコードにない設計値なのでコスト側は別途与える。\n\n")
     585            1 :         var runIncomeRows [][]string
     586            1 :         for _, floors := range []int{1, 3, 5, 10} {
     587            1 :                 runIncomeRows = append(runIncomeRows, []string{fmt.Sprintf("%d", floors), fmt.Sprintf("%.0f", ExpectedRunLootIncome(master, ruins, floors))})
     588            1 :         }
     589            1 :         writeMDTable(b, []string{"探索層数", "廃墟の期待収入"}, []tw.Align{alignR, alignR}, runIncomeRows)
     590            1 :         return nil
     591              : }
        

Generated by: LCOV version 2.0-1