LCOV - code coverage report
Current view: top level - consts - dice.go Coverage Total Hit
Test: coverage.lcov Lines: 98.2 % 55 54
Test Date: 2026-11-19 00:25:22 Functions: - 0 0

            Line data    Source code
       1              : package consts
       2              : 
       3              : import (
       4              :         "errors"
       5              :         "fmt"
       6              :         "math/rand/v2"
       7              :         "strconv"
       8              :         "strings"
       9              : )
      10              : 
      11              : // Dice は個数抽選。Base 個の Sides 面ダイスの和に Bonus を足す。1d3+1 は {Base:1, Sides:3, Bonus:1}。
      12              : // 固定値は Nd1 で表す。5固定は {Base:5, Sides:1}。数字だけの定数表記は使わず、常にダイス形にする。
      13              : type Dice struct {
      14              :         Base  int
      15              :         Sides int
      16              :         Bonus int
      17              : }
      18              : 
      19              : var (
      20              :         // errDiceEmpty はダイス表記が空のときに返す
      21              :         errDiceEmpty = errors.New("dice is empty")
      22              :         // errDiceNoD はダイス表記に区切りの d が無いときに返す
      23              :         errDiceNoD = errors.New("dice notation requires d; write fixed values like \"1d1\"")
      24              :         // errDiceCountOmitted はダイス表記の個数が省略されているときに返す
      25              :         errDiceCountOmitted = errors.New("dice count cannot be omitted; example \"1d6\"")
      26              :         // errDiceCountInvalid はダイス表記の個数が整数でないときに返す
      27              :         errDiceCountInvalid = errors.New("invalid dice count")
      28              :         // errDiceBonusInvalid はダイス表記の補正値が整数でないときに返す
      29              :         errDiceBonusInvalid = errors.New("invalid dice bonus")
      30              :         // errDiceSidesInvalid はダイス表記の面数が整数でないときに返す
      31              :         errDiceSidesInvalid = errors.New("invalid dice sides")
      32              :         // errDiceCountTooSmall はダイスの個数が1未満のときに返す
      33              :         errDiceCountTooSmall = errors.New("dice count must be at least 1")
      34              :         // errDiceSidesTooSmall はダイスの面数が1未満のときに返す
      35              :         errDiceSidesTooSmall = errors.New("dice sides must be at least 1")
      36              : )
      37              : 
      38              : // ParseDice は "1d3+1" "2d4" "1d1" のような表記を Dice へ変換する。
      39              : // d の前が個数、後ろが面数、続く +/- 以降が Bonus になる。個数・面数は必ず書く。
      40              : // 固定値も "1d1" のように書き、数字だけの省略表記は許さない。表記が一意になり読み手が迷わない。
      41              : // 区切りは小文字 d に統一する。大文字 D は受け付けない。
      42              : // 動的入力用。固定リテラルには MustParseDice を使う。regexp は使わず strings で足りる。ParseWeight と同じ方針。
      43              : func ParseDice(s string) (Dice, error) {
      44            1 :         if s == "" {
      45            1 :                 return Dice{}, errDiceEmpty
      46            1 :         }
      47              : 
      48              :         // 前後空白も含め厳密に扱う。空白混じりは各数値の Atoi が弾く
      49              :         // d は必須。数字だけの定数表記は許さず、固定値も "1d1" と書かせる
      50            1 :         before, after, ok := strings.Cut(s, "d")
      51            1 :         if !ok {
      52            1 :                 return Dice{}, fmt.Errorf("%w: %q", errDiceNoD, s)
      53            1 :         }
      54              : 
      55              :         // 個数は省略できない。"d6" でなく "1d6" と明示的に書かせて表記を一意にする。
      56            1 :         if before == "" {
      57            1 :                 return Dice{}, fmt.Errorf("%w: %q", errDiceCountOmitted, s)
      58            1 :         }
      59            1 :         base, err := strconv.Atoi(before)
      60            1 :         if err != nil {
      61            1 :                 return Dice{}, fmt.Errorf("%w: %q", errDiceCountInvalid, s)
      62            1 :         }
      63              : 
      64              :         // 面数部と Bonus 部。sides[+/-bonus]
      65            1 :         rest := after
      66            1 :         bonus := 0
      67            1 :         sidesPart := rest
      68            1 :         if bi := strings.IndexAny(rest, "+-"); bi >= 0 {
      69            1 :                 sidesPart = rest[:bi]
      70            1 :                 b, err := strconv.Atoi(rest[bi:])
      71            1 :                 if err != nil {
      72            1 :                         return Dice{}, fmt.Errorf("%w: %q", errDiceBonusInvalid, s)
      73            1 :                 }
      74            1 :                 bonus = b
      75              :         }
      76            1 :         sides, err := strconv.Atoi(sidesPart)
      77            1 :         if err != nil {
      78            1 :                 return Dice{}, fmt.Errorf("%w: %q", errDiceSidesInvalid, s)
      79            1 :         }
      80              : 
      81              :         // d を書いたなら個数は1以上を要求する。"0d6" は定数のつもりの誤記とみなして弾く。
      82              :         // 定数は "5" のように d を書かずに表す。
      83            1 :         if base < 1 {
      84            1 :                 return Dice{}, fmt.Errorf("%w: %q", errDiceCountTooSmall, s)
      85            1 :         }
      86            1 :         if sides < 1 {
      87            1 :                 return Dice{}, fmt.Errorf("%w: %q", errDiceSidesTooSmall, s)
      88            1 :         }
      89            1 :         return Dice{Base: base, Sides: sides, Bonus: bonus}, nil
      90              : }
      91              : 
      92              : // MustParseDice は ParseDice のパニック版。固定リテラルやテスト値のように失敗があり得ない箇所で使う。
      93              : // regexp.MustCompile と同じ発想。動的な入力には error を返す ParseDice を使う。
      94              : func MustParseDice(s string) Dice {
      95            1 :         d, err := ParseDice(s)
      96            1 :         if err != nil {
      97            0 :                 panic(err)
      98              :         }
      99            1 :         return d
     100              : }
     101              : 
     102              : // Roll は Base 個の Sides 面ダイスの和に Bonus を足す。
     103              : // 有効な Dice は Base>=1・Sides>=1。ParseDice が保証する。ゼロ値など不正な Dice を
     104              : // 直接渡したバグを即座に気づけるよう panic する。
     105              : // rng は呼び出し側が渡す。共有 RNG を汚さず決定的に抽選するため、内部で乱数器を持たない。
     106              : func (d Dice) Roll(rng *rand.Rand) int {
     107            1 :         if d.Base < 1 || d.Sides < 1 {
     108            1 :                 panic(fmt.Sprintf("invalid Dice; construct via ParseDice: %+v", d))
     109              :         }
     110            1 :         sum := d.Bonus
     111            1 :         for range d.Base {
     112            1 :                 sum += rng.IntN(d.Sides) + 1
     113            1 :         }
     114            1 :         return sum
     115              : }
     116              : 
     117              : // Min は取りうる最小値。Base 個の最小目1 の和に Bonus を足す。
     118              : func (d Dice) Min() int {
     119            1 :         return d.Base + d.Bonus
     120            1 : }
     121              : 
     122              : // Max は取りうる最大値。Base 個の最大目 Sides の和に Bonus を足す。
     123              : func (d Dice) Max() int {
     124            1 :         return d.Base*d.Sides + d.Bonus
     125            1 : }
     126              : 
     127              : // String は正規化表記を返す。ParseDice(d.String()) が元の Dice に戻る往復性を保つ。
     128              : // 表示・save 往復・ゴールデンで表記が揺れないようにするため、常に NdM 形で出す。
     129              : func (d Dice) String() string {
     130            1 :         s := fmt.Sprintf("%dd%d", d.Base, d.Sides)
     131            1 :         switch {
     132              :         case d.Bonus > 0:
     133            1 :                 s += fmt.Sprintf("+%d", d.Bonus)
     134              :         case d.Bonus < 0:
     135            1 :                 s += strconv.Itoa(d.Bonus) // マイナス符号を含む
     136              :         }
     137            1 :         return s
     138              : }
        

Generated by: LCOV version 2.0-1