LCOV - code coverage report
Current view: top level - balance - search.go Coverage Total Hit
Test: coverage.lcov Lines: 87.7 % 122 107
Test Date: 2026-11-19 00:25:22 Functions: - 0 0

            Line data    Source code
       1              : package balance
       2              : 
       3              : import (
       4              :         "maps"
       5              :         "math"
       6              : 
       7              :         "github.com/kijimaD/ruins/internal/raw"
       8              :         "github.com/kijimaD/ruins/internal/rawschema"
       9              : )
      10              : 
      11              : // ruinsDay20PowerRatio は現行 master の廃墟 day20 の戦力比を返す。探索と感度の目的関数。
      12              : func ruinsDay20PowerRatio(master rawschema.Raws) float64 {
      13            1 :         player, err := LoadCombatantFromMember(master, BaselinePlayer)
      14            1 :         if err != nil {
      15            0 :                 return 0
      16            0 :         }
      17            1 :         weapon, err := LoadWeaponFromItem(master, BaselineWeapon)
      18            1 :         if err != nil {
      19            0 :                 return 0
      20            0 :         }
      21            1 :         curve, err := DifficultyCurve(master, player, weapon, BaselineAreaTable, BaselineDays)
      22            1 :         if err != nil || len(curve) == 0 {
      23            0 :                 return 0
      24            0 :         }
      25            1 :         return curve[len(curve)-1].PowerRatio
      26              : }
      27              : 
      28              : // withScaledMeleeDamage は itemID の近接ダメージを factor 倍した状態で fn を呼び、後で元へ戻す。master の item は
      29              : // backing array を共有するので値を退避・復元する。並行変更は競合するので、使うなら master を呼び出しごとに独立させる。
      30              : func withScaledMeleeDamage(master rawschema.Raws, itemID string, factor float64, fn func()) {
      31            1 :         items := raw.PtrSlice(master.Items)
      32            1 :         for i := range items {
      33            1 :                 if items[i].Id == itemID && items[i].Melee != nil {
      34            1 :                         orig := items[i].Melee.Damage
      35            1 :                         // 丸めで反映する。切り捨てだと factor=1.1 で奇数値が変化せず摂動が無反応になる
      36            1 :                         items[i].Melee.Damage = int(math.Round(float64(orig) * factor))
      37            1 :                         fn()
      38            1 :                         items[i].Melee.Damage = orig
      39            1 :                         return
      40            1 :                 }
      41              :         }
      42            1 :         fn()
      43              : }
      44              : 
      45              : // SolveScalar は eval が単調な区間 [lo,hi] で eval(x)=target となる x を二分探索で返す。端点が挟まなければ ok=false。
      46              : // iters が0以下なら精緻化せず区間中点を返す。
      47              : func SolveScalar(eval func(float64) float64, target, lo, hi float64, iters int) (float64, bool) {
      48            1 :         flo, fhi := eval(lo), eval(hi)
      49            1 :         if (flo-target)*(fhi-target) > 0 {
      50            1 :                 return 0, false
      51            1 :         }
      52            1 :         for range iters {
      53            1 :                 mid := (lo + hi) / 2
      54            1 :                 fm := eval(mid)
      55            1 :                 if (flo-target)*(fm-target) <= 0 {
      56            1 :                         hi = mid
      57            1 :                 } else {
      58            1 :                         lo, flo = mid, fm
      59            1 :                 }
      60              :         }
      61            1 :         return (lo + hi) / 2, true
      62              : }
      63              : 
      64              : // withScaledMeleeDamages は複数アイテムの近接ダメージを同時に factor 倍して fn を呼び、後で全て戻す。単変数版の
      65              : // 多変数化で、並行変更が競合する点も同じ。
      66              : func withScaledMeleeDamages(master rawschema.Raws, factors map[string]float64, fn func()) {
      67            1 :         items := raw.PtrSlice(master.Items)
      68            1 :         type saved struct {
      69            1 :                 idx  int
      70            1 :                 orig int
      71            1 :         }
      72            1 :         restore := make([]saved, 0, len(factors))
      73            1 :         for i := range items {
      74            1 :                 if items[i].Melee == nil {
      75            1 :                         continue
      76              :                 }
      77            1 :                 factor, ok := factors[items[i].Id]
      78            1 :                 if !ok {
      79            1 :                         continue
      80              :                 }
      81            1 :                 restore = append(restore, saved{idx: i, orig: items[i].Melee.Damage})
      82            1 :                 items[i].Melee.Damage = int(math.Round(float64(items[i].Melee.Damage) * factor))
      83              :         }
      84            1 :         fn()
      85            1 :         for _, s := range restore {
      86            1 :                 items[s.idx].Melee.Damage = s.orig
      87            1 :         }
      88              : }
      89              : 
      90              : // ParetoPoint は多目的探索の1点。決定変数の武器ダメージ倍率と、代表日ごとの目標戦力比からの逸脱を持つ。
      91              : type ParetoPoint struct {
      92              :         Factors    map[string]float64 // 決定変数。武器 id ごとの近接ダメージ倍率
      93              :         Deviations []float64          // 目的。repDays と同順の |PowerRatio(day) - TargetPowerRatio(day)|
      94              : }
      95              : 
      96              : // combatDeviations は現行 master の廃墟カーブで、代表日ごとの目標戦力比からの逸脱の絶対値を返す。
      97              : // すべての代表日で導出できたときだけ ok を true にする。
      98              : func combatDeviations(master rawschema.Raws, repDays []int) ([]float64, bool) {
      99            1 :         player, err := LoadCombatantFromMember(master, BaselinePlayer)
     100            1 :         if err != nil {
     101            0 :                 return nil, false
     102            0 :         }
     103            1 :         weapon, err := LoadWeaponFromItem(master, BaselineWeapon)
     104            1 :         if err != nil {
     105            0 :                 return nil, false
     106            0 :         }
     107            1 :         maxDay := 0
     108            1 :         for _, d := range repDays {
     109            1 :                 if d > maxDay {
     110            1 :                         maxDay = d
     111            1 :                 }
     112              :         }
     113            1 :         curve, err := DifficultyCurve(master, player, weapon, BaselineAreaTable, maxDay)
     114            1 :         if err != nil {
     115            0 :                 return nil, false
     116            0 :         }
     117            1 :         devs := make([]float64, len(repDays))
     118            1 :         for i, d := range repDays {
     119            1 :                 if d < 1 || d > len(curve) {
     120            0 :                         return nil, false
     121            0 :                 }
     122            1 :                 devs[i] = math.Abs(curve[d-1].PowerRatio - TargetPowerRatio(d))
     123              :         }
     124            1 :         return devs, true
     125              : }
     126              : 
     127              : // gridFactors は knobs の各つまみに levels の各水準を割り当てた全組み合わせを返す。格子探索の候補集合。
     128              : func gridFactors(knobs []string, levels []float64) []map[string]float64 {
     129            1 :         combos := []map[string]float64{{}}
     130            1 :         for _, knob := range knobs {
     131            1 :                 next := make([]map[string]float64, 0, len(combos)*len(levels))
     132            1 :                 for _, base := range combos {
     133            1 :                         for _, lv := range levels {
     134            1 :                                 m := make(map[string]float64, len(base)+1)
     135            1 :                                 maps.Copy(m, base)
     136            1 :                                 m[knob] = lv
     137            1 :                                 next = append(next, m)
     138            1 :                         }
     139              :                 }
     140            1 :                 combos = next
     141              :         }
     142            1 :         return combos
     143              : }
     144              : 
     145              : // dominates は a のすべての目的が b 以下で、少なくとも1つで真に小さいとき真を返す。逸脱は小さいほど良い。
     146              : func dominates(a, b []float64) bool {
     147            1 :         strictly := false
     148            1 :         for i := range a {
     149            1 :                 if a[i] > b[i] {
     150            1 :                         return false
     151            1 :                 }
     152            1 :                 if a[i] < b[i] {
     153            1 :                         strictly = true
     154            1 :                 }
     155              :         }
     156            1 :         return strictly
     157              : }
     158              : 
     159              : // ParetoFront は knobs×levels の格子で武器ダメージ倍率を動かし、代表日 repDays の目標逸脱の非劣な点集合を返す。
     160              : // 複数日のトレードオフは逸脱ベクトルの非劣集合で初めて意味を持つ。withScaledMeleeDamages が master を書き換えるので
     161              : // この格子ループは並行化しない。並行なら格子点ごとに独立した master をロードすること。
     162              : func ParetoFront(master rawschema.Raws, knobs []string, levels []float64, repDays []int) []ParetoPoint {
     163            1 :         combos := gridFactors(knobs, levels)
     164            1 :         points := make([]ParetoPoint, 0, len(combos))
     165            1 :         for _, factors := range combos {
     166            1 :                 var devs []float64
     167            1 :                 var ok bool
     168            1 :                 withScaledMeleeDamages(master, factors, func() {
     169            1 :                         devs, ok = combatDeviations(master, repDays)
     170            1 :                 })
     171            1 :                 if !ok {
     172            0 :                         continue
     173              :                 }
     174            1 :                 points = append(points, ParetoPoint{Factors: factors, Deviations: devs})
     175              :         }
     176            1 :         front := make([]ParetoPoint, 0, len(points))
     177            1 :         for i := range points {
     178            1 :                 dominated := false
     179            1 :                 for j := range points {
     180            1 :                         if i != j && dominates(points[j].Deviations, points[i].Deviations) {
     181            1 :                                 dominated = true
     182            1 :                                 break
     183              :                         }
     184              :                 }
     185            1 :                 if !dominated {
     186            1 :                         front = append(front, points[i])
     187            1 :                 }
     188              :         }
     189            1 :         return front
     190              : }
        

Generated by: LCOV version 2.0-1