LCOV - code coverage report
Current view: top level - balance - markov.go Coverage Total Hit
Test: coverage.lcov Lines: 90.4 % 146 132
Test Date: 2026-11-19 00:25:22 Functions: - 0 0

            Line data    Source code
       1              : package balance
       2              : 
       3              : import (
       4              :         "sort"
       5              : 
       6              :         "github.com/kijimaD/ruins/internal/consts"
       7              :         "github.com/kijimaD/ruins/internal/formula"
       8              :         "github.com/kijimaD/ruins/internal/raw"
       9              :         "github.com/kijimaD/ruins/internal/rawschema"
      10              :         "github.com/kijimaD/ruins/internal/world/query"
      11              : )
      12              : 
      13              : // combatAttackCap は撃破攻撃数分布の打ち切り上限。DP は生存質量が尽きると早期終了するため通常は到達しない。
      14              : const combatAttackCap = 4000
      15              : 
      16              : // CombatOutcome は1対1戦闘を吸収マルコフ連鎖で解いた結果分布。平均でなく分布なので突然死の裾を捉える。
      17              : type CombatOutcome struct {
      18              :         PlayerDeathProb float64 // プレイヤーが倒される確率。P(敵の撃破攻撃数 < 自分の撃破攻撃数)
      19              :         ExpectedTurns   float64 // 決着までの期待ターン数。min(自分の撃破攻撃数, 敵の撃破攻撃数)の期待値
      20              :         TTKMedian       int     // 決着ターンの中央値
      21              :         TTKp95          int     // 決着ターンの95パーセンタイル。長引く不運側の裾
      22              : }
      23              : 
      24              : // damageProb はダメージ量と確率の組。map だと加算順が不定で非決定論になるため昇順スライスで持つ。
      25              : type damageProb struct {
      26              :         dmg int
      27              :         p   float64
      28              : }
      29              : 
      30              : // attackDamagePMF は1回の攻撃のダメージ分布を昇順スライスで返す。dmg=0 は miss。属性耐性は無いものとする
      31              : func attackDamagePMF(attacker, defender CombatantStats, weapon WeaponStats, skillMult consts.Percent) []damageProb {
      32            1 :         hitRate := formula.CalcHitRate(attacker.Dexterity, defender.Agility, weapon.Accuracy)
      33            1 :         baseAbil := attacker.Strength
      34            1 :         if weapon.IsRanged {
      35            1 :                 baseAbil = attacker.Sensation
      36            1 :         }
      37            1 :         critRolls := min(hitRate, formula.CriticalHitThreshold)
      38            1 :         pCrit := float64(critRolls) / float64(formula.DiceMax)
      39            1 :         pNormal := float64(hitRate-critRolls) / float64(formula.DiceMax)
      40            1 :         pMiss := float64(formula.DiceMax-hitRate) / float64(formula.DiceMax)
      41            1 : 
      42            1 :         acc := make(map[int]float64, 2*formula.DamageRandomRange+1)
      43            1 :         // 不変条件。命中は max(...,MinDamage) で MinDamage>=1 ゆえ 0 にならず、acc[0] は miss 一意になる。
      44              :         // TestAttackDamagePMF_命中は0ダメージにならない で担保する。
      45            1 :         acc[0] += pMiss
      46            1 :         for die := 1; die <= formula.DamageRandomRange; die++ {
      47            1 :                 in := formula.DamageInput{
      48            1 :                         Ability:      baseAbil,
      49            1 :                         Die:          die,
      50            1 :                         WeaponDamage: weapon.Damage,
      51            1 :                         SkillMult:    int(skillMult),
      52            1 :                         ElementMult:  int(consts.PercentBase),
      53            1 :                         Defense:      defender.Defense,
      54            1 :                 }
      55            1 :                 normal := formula.Damage(in)
      56            1 :                 in.Critical = true
      57            1 :                 crit := formula.Damage(in)
      58            1 :                 acc[normal] += pNormal / float64(formula.DamageRandomRange)
      59            1 :                 acc[crit] += pCrit / float64(formula.DamageRandomRange)
      60            1 :         }
      61            1 :         dmgs := make([]int, 0, len(acc))
      62            1 :         for d := range acc {
      63            1 :                 dmgs = append(dmgs, d)
      64            1 :         }
      65            1 :         sort.Ints(dmgs)
      66            1 :         pmf := make([]damageProb, len(dmgs))
      67            1 :         for i, d := range dmgs {
      68            1 :                 pmf[i] = damageProb{dmg: d, p: acc[d]}
      69            1 :         }
      70            1 :         return pmf
      71              : }
      72              : 
      73              : // killDistribution は pmf で HP hp を倒すのに要する攻撃回数の分布を返す。kill[k]=P(ちょうど k 回で倒す)。
      74              : // 残 HP を状態とする1次元 DP で、生存質量が尽きると早期終了する。
      75              : func killDistribution(pmf []damageProb, hp int) []float64 {
      76            1 :         if hp < 0 {
      77              :                 // 実敵の HP は formula.CalcHP の下限 HPBaseValue 以上で負にならない。負は呼び出し側のバグなので早期に落とす。
      78            0 :                 panic("killDistribution called with negative hp")
      79              :         }
      80            1 :         if hp == 0 {
      81            0 :                 return []float64{0, 1} // 既に倒れている扱い。1回で確定して倒す
      82            0 :         }
      83              :         // kill は到達攻撃回数ぶんだけ伸ばし、alive/next は2枚で ping-pong する。毎攻撃ぶん確保すると累積するため。
      84            1 :         kill := []float64{0}
      85            1 :         alive := make([]float64, hp+1)
      86            1 :         next := make([]float64, hp+1)
      87            1 :         alive[hp] = 1
      88            1 :         for k := 1; k <= combatAttackCap; k++ {
      89            1 :                 clear(next)
      90            1 :                 var killed, aliveMass float64
      91            1 :                 for r := 1; r <= hp; r++ {
      92            1 :                         if alive[r] == 0 {
      93            1 :                                 continue
      94              :                         }
      95            1 :                         for _, dp := range pmf {
      96            1 :                                 if dp.p == 0 {
      97            0 :                                         continue
      98              :                                 }
      99            1 :                                 if dp.dmg >= r {
     100            1 :                                         killed += alive[r] * dp.p
     101            1 :                                 } else {
     102            1 :                                         next[r-dp.dmg] += alive[r] * dp.p
     103            1 :                                         aliveMass += alive[r] * dp.p
     104            1 :                                 }
     105              :                         }
     106              :                 }
     107            1 :                 kill = append(kill, killed)
     108            1 :                 alive, next = next, alive
     109            1 :                 if aliveMass < 1e-12 {
     110            1 :                         break
     111              :                 }
     112              :         }
     113            1 :         return kill
     114              : }
     115              : 
     116              : // CombatDistribution は熟練度なしの1対1戦闘の結果分布を解く。静的下限で、スキルを織り込むときは
     117              : // CombatDistributionWithSkill を使う。
     118              : func CombatDistribution(player, enemy CombatantStats, playerWeapon, enemyWeapon WeaponStats) CombatOutcome {
     119            1 :         return CombatDistributionWithSkill(player, enemy, playerWeapon, enemyWeapon, consts.PercentBase)
     120            1 : }
     121              : 
     122              : // CombatDistributionWithSkill は熟練度倍率 playerSkillMult を織り込んだ1対1戦闘の結果分布を厳密に解く。先攻の
     123              : // 交互攻撃で撃破攻撃数 Kp と Ke は独立、死亡確率は P(Ke<Kp)、決着ターンは min(Kp,Ke) の分布。倍率はプレイヤー側だけに効く。
     124              : func CombatDistributionWithSkill(player, enemy CombatantStats, playerWeapon, enemyWeapon WeaponStats, playerSkillMult consts.Percent) CombatOutcome {
     125            1 :         kp := killDistribution(attackDamagePMF(player, enemy, playerWeapon, playerSkillMult), enemy.HP)
     126            1 :         ke := killDistribution(attackDamagePMF(enemy, player, enemyWeapon, consts.PercentBase), player.HP)
     127            1 : 
     128              :         // kp と ke は早期終了で長さが異なりうる。以降の畳み込みは相手側を同じ添字で引くので、短い方を
     129              :         // ゼロ詰めして長さを揃える。撃破質量が尽きた後の kill は0なので、詰めても分布は変わらない。
     130            1 :         n := max(len(kp), len(ke))
     131            1 :         for len(kp) < n {
     132            1 :                 kp = append(kp, 0)
     133            1 :         }
     134            1 :         for len(ke) < n {
     135            1 :                 ke = append(ke, 0)
     136            1 :         }
     137              : 
     138              :         // 累積分布。cumKp[k]=P(Kp<=k)
     139            1 :         cumKp := make([]float64, len(kp))
     140            1 :         cumKe := make([]float64, len(ke))
     141            1 :         var accP, accE float64
     142            1 :         for k := 1; k < len(kp); k++ {
     143            1 :                 accP += kp[k]
     144            1 :                 cumKp[k] = accP
     145            1 :         }
     146            1 :         for k := 1; k < len(ke); k++ {
     147            1 :                 accE += ke[k]
     148            1 :                 cumKe[k] = accE
     149            1 :         }
     150              : 
     151              :         // 死亡確率 P(Ke<Kp) = Σ ke[k]·P(Kp>k)
     152            1 :         var death float64
     153            1 :         for k := 1; k < len(ke); k++ {
     154            1 :                 death += ke[k] * (1 - cumKp[k])
     155            1 :         }
     156              : 
     157              :         // 決着ターン min(Kp,Ke) の分布。P(min=t)=P(Kp=t)P(Ke>=t)+P(Ke=t)P(Kp>=t)-P(Kp=t)P(Ke=t)
     158            1 :         var expTurns, cumMin float64
     159            1 :         median, p95 := 0, 0
     160            1 :         for t := 1; t < len(kp); t++ {
     161            1 :                 pKpGeT := 1 - cumKp[t-1]
     162            1 :                 pKeGeT := 1 - cumKe[t-1]
     163            1 :                 pMin := kp[t]*pKeGeT + ke[t]*pKpGeT - kp[t]*ke[t]
     164            1 :                 if pMin <= 0 {
     165            1 :                         continue
     166              :                 }
     167            1 :                 expTurns += float64(t) * pMin
     168            1 :                 cumMin += pMin
     169            1 :                 if median == 0 && cumMin >= 0.5 {
     170            1 :                         median = t
     171            1 :                 }
     172            1 :                 if p95 == 0 && cumMin >= 0.95 {
     173            1 :                         p95 = t
     174            1 :                 }
     175              :         }
     176            1 :         return CombatOutcome{PlayerDeathProb: death, ExpectedTurns: expTurns, TTKMedian: median, TTKp95: p95}
     177              : }
     178              : 
     179              : // DayRisk は経過日1日ぶんの戦闘リスク。敵プールを重みで期待した死亡確率と決着ターンを持つ。
     180              : // DifficultyCurve の PowerRatio が期待値の比なのに対し、こちらは分布から突然死の確率を直接測る。
     181              : type DayRisk struct {
     182              :         Day       int
     183              :         Danger    int
     184              :         DeathProb float64 // その日の敵プールに1体遭遇したときの重み付き死亡確率
     185              :         ExpTurns  float64 // 重み付き期待決着ターン
     186              : }
     187              : 
     188              : // PoolCombatRisk は危険度 danger の敵プールに1体遭遇したときの重み付き死亡確率と期待決着ターンを返す。各敵との
     189              : // 1対1をマルコフ連鎖で解き出現重みで平均する。帯に敵がいなければ ok=false。静的下限は PercentBase を渡す。
     190              : func PoolCombatRisk(master rawschema.Raws, player CombatantStats, playerWeapon WeaponStats, enemyTableName string, danger int, playerSkillMult consts.Percent) (deathProb, expTurns float64, ok bool, err error) {
     191            1 :         table, err := raw.GetEnemyTable(master, enemyTableName)
     192            1 :         if err != nil {
     193            1 :                 return 0, 0, false, err
     194            1 :         }
     195            1 :         var wSum, deathSum, turnSum float64
     196            1 :         for _, entry := range raw.EnemyEntriesAt(table, danger) {
     197            1 :                 enemy, err := LoadCombatantFromMember(master, entry.Id)
     198            1 :                 if err != nil {
     199            0 :                         return 0, 0, false, err
     200            0 :                 }
     201            1 :                 enemyWeapon, err := LoadEnemyWeapon(master, entry.Id)
     202            1 :                 if err != nil {
     203            0 :                         return 0, 0, false, err
     204            0 :                 }
     205            1 :                 o := CombatDistributionWithSkill(player, enemy, playerWeapon, enemyWeapon, playerSkillMult)
     206            1 :                 w := entry.Weight
     207            1 :                 wSum += w
     208            1 :                 deathSum += w * o.PlayerDeathProb
     209            1 :                 turnSum += w * o.ExpectedTurns
     210              :         }
     211            1 :         if wSum == 0 {
     212            0 :                 return 0, 0, false, nil
     213            0 :         }
     214            1 :         return deathSum / wSum, turnSum / wSum, true, nil
     215              : }
     216              : 
     217              : // CombatRiskCurve は経過日 1..days の戦闘リスクを敵プールの重みで期待して返す。プレイヤーは熟練度なしの
     218              : // 静的下限で見る。各敵との1対1をマルコフ連鎖で解き、出現重みで平均する。乱数を使わない。
     219              : func CombatRiskCurve(master rawschema.Raws, player CombatantStats, playerWeapon WeaponStats, enemyTableName string, days int) ([]DayRisk, error) {
     220            1 :         out := make([]DayRisk, 0, days)
     221            1 :         for day := 1; day <= days; day++ {
     222            1 :                 danger := int(query.DangerLevelForDay(day))
     223            1 :                 death, turns, ok, err := PoolCombatRisk(master, player, playerWeapon, enemyTableName, danger, consts.PercentBase)
     224            1 :                 if err != nil {
     225            0 :                         return nil, err
     226            0 :                 }
     227            1 :                 if !ok {
     228            0 :                         out = append(out, DayRisk{Day: day, Danger: danger})
     229            0 :                         continue
     230              :                 }
     231            1 :                 out = append(out, DayRisk{Day: day, Danger: danger, DeathProb: death, ExpTurns: turns})
     232              :         }
     233            1 :         return out, nil
     234              : }
        

Generated by: LCOV version 2.0-1