LCOV - code coverage report
Current view: top level - balance - build.go Coverage Total Hit
Test: coverage.lcov Lines: 81.8 % 55 45
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              : )
      10              : 
      11              : // BuildProfile は評価するプレイヤーのビルド。能力と武器に加え、スキル成長ぶんの熟練度倍率を持つ。
      12              : // 倍率は実ゲームと同じく base 全体へ切り捨てで掛かる。静的下限は倍率 PercentBase の1プロファイル。
      13              : type BuildProfile struct {
      14              :         Name      string
      15              :         Player    CombatantStats
      16              :         Weapon    WeaponStats
      17              :         SkillMult consts.Percent
      18              : }
      19              : 
      20              : // buildStages は代表ビルドの段階と、その段階までに想定する累積攻撃回数。攻撃回数は scenario 入力で、
      21              : // スキル成長 SkillLevelAfterAttacks と熟練度 SkillDamageMultiplier を経由してダメージ倍率になる。
      22              : var buildStages = []struct {
      23              :         name    string
      24              :         attacks int
      25              : }{
      26              :         {"下限(0攻撃)", 0},
      27              :         {"中盤(500攻撃)", 500},
      28              :         {"後半(2000攻撃)", 2000},
      29              : }
      30              : 
      31              : // RepresentativeBuilds は基準プレイヤーを土台に、想定攻撃回数から導いた強化度合いで段階を表した代表ビルドを返す。
      32              : // 倍率はスキル成長と熟練度の実システムから導き、スキル由来のダメージ倍率だけを反映する。攻撃回数は設計仮説。
      33              : func RepresentativeBuilds(master rawschema.Raws) ([]BuildProfile, error) {
      34            1 :         player, err := LoadCombatantFromMember(master, BaselinePlayer)
      35            1 :         if err != nil {
      36            0 :                 return nil, err
      37            0 :         }
      38            1 :         weapon, err := LoadWeaponFromItem(master, BaselineWeapon)
      39            1 :         if err != nil {
      40            0 :                 return nil, err
      41            0 :         }
      42            1 :         defs, err := raw.NewSkillDefs(master)
      43            1 :         if err != nil {
      44            0 :                 return nil, err
      45            0 :         }
      46            1 :         builds := make([]BuildProfile, 0, len(buildStages))
      47            1 :         for _, st := range buildStages {
      48            1 :                 mult := SkillDamagePercent(defs, SkillLevelAfterAttacks(0, st.attacks))
      49            1 :                 builds = append(builds, BuildProfile{Name: st.name, Player: player, Weapon: weapon, SkillMult: mult})
      50            1 :         }
      51            1 :         return builds, nil
      52              : }
      53              : 
      54              : // DaySpreadRow は代表ビルド間の、ある日の戦力比の幅。強武器ほど戦力比が上がるので、最大は最強ビルド、
      55              : // 最小は下限ビルドに対応する。幅が広いほどビルド次第で難易度が大きく振れる。
      56              : type DaySpreadRow struct {
      57              :         Day      int
      58              :         MinRatio float64
      59              :         MaxRatio float64
      60              : }
      61              : 
      62              : // Spread は最大と最小の差。後半のブレの大きさを表す。
      63              : func (r DaySpreadRow) Spread() float64 {
      64            1 :         return r.MaxRatio - r.MinRatio
      65            1 : }
      66              : 
      67              : // BuildSpread は代表ビルドで敵テーブルのカーブを評価し、各日の戦力比の最小と最大を返す。後半で幅が急に開くなら
      68              : // バフが強すぎて終盤が崩れやすいことを示す。
      69              : func BuildSpread(master rawschema.Raws, profiles []BuildProfile, enemyTableName string, days int) ([]DaySpreadRow, error) {
      70            1 :         curves := make([][]DayMetric, 0, len(profiles))
      71            1 :         for _, p := range profiles {
      72            1 :                 c, err := DifficultyCurveWithSkill(master, p.Player, p.Weapon, enemyTableName, days, p.SkillMult)
      73            1 :                 if err != nil {
      74            0 :                         return nil, err
      75            0 :                 }
      76            1 :                 curves = append(curves, c)
      77              :         }
      78            1 :         out := make([]DaySpreadRow, 0, days)
      79            1 :         for i := range days {
      80            1 :                 mn, mx := math.Inf(1), math.Inf(-1)
      81            1 :                 for _, c := range curves {
      82            1 :                         r := c[i].PowerRatio
      83            1 :                         mn = math.Min(mn, r)
      84            1 :                         mx = math.Max(mx, r)
      85            1 :                 }
      86            1 :                 out = append(out, DaySpreadRow{Day: i + 1, MinRatio: mn, MaxRatio: mx})
      87              :         }
      88            1 :         return out, nil
      89              : }
      90              : 
      91              : // StageSpread は1つのゲーム段階での、代表ビルド間の戦力比の幅の最大と、その許容幅。
      92              : type StageSpread struct {
      93              :         Stage     string
      94              :         FromDay   int
      95              :         ToDay     int
      96              :         MaxSpread float64 // 段階内の日で最大の戦力比の幅
      97              :         Tolerance float64 // 許容する幅
      98              : }
      99              : 
     100              : // InRange は段階内の最大の幅が許容幅に収まるかを返す。
     101              : func (s StageSpread) InRange() bool {
     102            1 :         return s.MaxSpread <= s.Tolerance
     103            1 : }
     104              : 
     105              : // stageBands はゲーム段階の日範囲とブレの許容幅。後半ほどバフで開きやすいので許容を絞る。設計仮説で見直す。
     106              : var stageBands = []struct {
     107              :         name     string
     108              :         from, to int
     109              :         tol      float64
     110              : }{
     111              :         {"序盤", 1, 7, 2.0},
     112              :         {"中盤", 8, 14, 1.6},
     113              :         {"終盤", 15, 21, 1.2},
     114              : }
     115              : 
     116              : // StageSpreads は代表ビルドの戦力比の幅を段階ごとに集計し、各段階での最大の幅と許容帯を返す。
     117              : // 幅が許容を超える段階はビルド次第で難易度が振れすぎる。特に終盤の超過はバフが強すぎる兆候。
     118              : func StageSpreads(master rawschema.Raws, profiles []BuildProfile, enemyTableName string) ([]StageSpread, error) {
     119            1 :         spread, err := BuildSpread(master, profiles, enemyTableName, 21)
     120            1 :         if err != nil {
     121            0 :                 return nil, err
     122            0 :         }
     123            1 :         byDay := make(map[int]float64, len(spread))
     124            1 :         for _, r := range spread {
     125            1 :                 byDay[r.Day] = r.Spread()
     126            1 :         }
     127            1 :         out := make([]StageSpread, 0, len(stageBands))
     128            1 :         for _, st := range stageBands {
     129            1 :                 mx := 0.0
     130            1 :                 for d := st.from; d <= st.to; d++ {
     131            1 :                         mx = math.Max(mx, byDay[d])
     132            1 :                 }
     133            1 :                 out = append(out, StageSpread{Stage: st.name, FromDay: st.from, ToDay: st.to, MaxSpread: mx, Tolerance: st.tol})
     134              :         }
     135            1 :         return out, nil
     136              : }
        

Generated by: LCOV version 2.0-1