You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
140 lines
3.4 KiB
140 lines
3.4 KiB
package roller
|
|
|
|
import (
|
|
"crypto/rand"
|
|
"errors"
|
|
"fmt"
|
|
"math/big"
|
|
"strconv"
|
|
"strings"
|
|
)
|
|
|
|
func ParseRollString(s string) (int64, string, error) {
|
|
s = strings.ReplaceAll(s, "-", "+-")
|
|
parts := strings.Split(s, "+")
|
|
var out int64
|
|
var outString string = " <= "
|
|
for i, part := range parts {
|
|
adv := false
|
|
dis := false
|
|
if strings.HasSuffix(part, "a") {
|
|
adv = true
|
|
} else if strings.HasSuffix(part, "d") {
|
|
dis = true
|
|
}
|
|
part = strings.TrimSuffix(part, "a")
|
|
part = strings.TrimSuffix(part, "d")
|
|
if c, err := strconv.ParseInt(part, 10, 64); err == nil && i != 0 {
|
|
out += c
|
|
if c < 0 {
|
|
outString += " - " + strconv.FormatInt(-1*c, 10)
|
|
} else {
|
|
outString += " + " + strconv.FormatInt(c, 10)
|
|
}
|
|
} else {
|
|
i, s, err := processDie(part, adv, dis)
|
|
if err != nil {
|
|
return i, outString, err
|
|
}
|
|
out += i
|
|
outString += s
|
|
}
|
|
}
|
|
return out, strings.Replace(outString, " <= + ", " <= ", 1), nil
|
|
}
|
|
|
|
func processDie(part string, adv, dis bool) (int64, string, error) {
|
|
var mult int64 = 1
|
|
var size int64
|
|
var outString string = ""
|
|
var val int64
|
|
if strings.HasPrefix(part, "-") {
|
|
mult = -1
|
|
part = strings.TrimPrefix(part, "-")
|
|
}
|
|
if strings.Contains(part, "d") {
|
|
ps := strings.Split(part, "d")
|
|
count, err := strconv.Atoi(ps[0])
|
|
if err != nil {
|
|
count = 1
|
|
}
|
|
size, err = strconv.ParseInt(ps[1], 10, 64)
|
|
if err != nil {
|
|
return -1, outString, errors.New("invalid format")
|
|
}
|
|
for i := 0; i < count; i++ {
|
|
i, s, err := rollDie(size, adv, dis)
|
|
if err != nil {
|
|
return i, outString, err
|
|
}
|
|
val += i * mult
|
|
if mult > 0 {
|
|
outString += " + " + s
|
|
} else if mult < 0 {
|
|
outString += " - " + s
|
|
} else if mult > 0 {
|
|
outString += s
|
|
}
|
|
}
|
|
} else if strings.Contains(part, "x") {
|
|
ps := strings.Split(part, "x")
|
|
if len(ps) < 2 {
|
|
return -1, outString, errors.New("invalid format")
|
|
}
|
|
modifer, err := strconv.ParseInt(ps[0], 10, 64)
|
|
if err != nil {
|
|
return -1, outString, errors.New("invalid format")
|
|
}
|
|
multiple, err := strconv.ParseInt(ps[1], 10, 64)
|
|
if err != nil {
|
|
return -1, outString, errors.New("invalid format")
|
|
}
|
|
out := modifer * multiple * mult
|
|
if out < 0 {
|
|
outString += " - " + strconv.FormatInt(-1*out, 10)
|
|
} else {
|
|
outString += " + " + strconv.FormatInt(out, 10)
|
|
}
|
|
val += out
|
|
}
|
|
return val, outString, nil
|
|
}
|
|
|
|
func rollDie(i int64, adv, dis bool) (int64, string, error) {
|
|
if i <= 1 {
|
|
return -2, "", errors.New("invalid die")
|
|
}
|
|
size := big.NewInt(i)
|
|
one := big.NewInt(1)
|
|
num, err := rand.Int(rand.Reader, size)
|
|
if err != nil {
|
|
return -1, "", errors.New("can't get die roll")
|
|
}
|
|
num.Add(num, one)
|
|
if i == 10 && num.Cmp(big.NewInt(10)) == 0 {
|
|
num = big.NewInt(0)
|
|
}
|
|
if adv {
|
|
num2, err := rand.Int(rand.Reader, size)
|
|
if err != nil {
|
|
return -1, "", errors.New("can't get die roll")
|
|
}
|
|
num2.Add(num2, one)
|
|
if num2.Cmp(num) == 1 {
|
|
return num2.Int64(), fmt.Sprintf("{ ~~%s~~ %s }", num.String(), num2.String()), nil
|
|
}
|
|
return num.Int64(), fmt.Sprintf("{ ~~%s~~ %s }", num2.String(), num.String()), nil
|
|
} else if dis {
|
|
num2, err := rand.Int(rand.Reader, size)
|
|
if err != nil {
|
|
return -1, "", errors.New("can't get die roll")
|
|
}
|
|
num2.Add(num2, one)
|
|
if num2.Cmp(num) == -1 {
|
|
return num2.Int64(), fmt.Sprintf("{ ~~%s~~ %s }", num.String(), num2.String()), nil
|
|
}
|
|
return num.Int64(), fmt.Sprintf("{ ~~%s~~ %s }", num2.String(), num.String()), nil
|
|
}
|
|
return num.Int64(), fmt.Sprintf("{ %s }", num.String()), nil
|
|
}
|