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 : }
|