85 lines
2.0 KiB
Go
85 lines
2.0 KiB
Go
package tiles
|
|
|
|
import (
|
|
"fmt"
|
|
"slices"
|
|
"strconv"
|
|
"strings"
|
|
"unicode"
|
|
)
|
|
|
|
var jpnZiPaiTileTypes []string = []string{"DO", "NA", "XI", "BE", "BA", "FA", "ZH"}
|
|
|
|
// Translate numberized Zi Pai to 2-letter format
|
|
// rule can be "CHN" or "JPN"
|
|
// If rule is "CHN", it should translate as DO XI NA BE ZH FA BA
|
|
// If rule is "JPN", it should translate as DO NA XI BE BA FA ZH
|
|
func ziPaiShortSplit(num int, rule string) (string, error) {
|
|
if num < 1 || num > 7 {
|
|
return "", fmt.Errorf("invalid zi pai index %d", num)
|
|
}
|
|
switch rule {
|
|
case "CHN":
|
|
return TileTypes[num-1+27], nil
|
|
case "JPN":
|
|
return jpnZiPaiTileTypes[num-1], nil
|
|
}
|
|
return "", fmt.Errorf("error calling ziPaiShortSplit()")
|
|
}
|
|
|
|
func huaPaiShortSplit(num int) (string, error) {
|
|
if num < 1 || num > 8 {
|
|
return "", fmt.Errorf("invalid hua pai index %d", num)
|
|
}
|
|
return TileHuaTypes[num-1], nil
|
|
}
|
|
|
|
func shortToArray(tiles string) ([]string, error) {
|
|
var ret []string
|
|
var stack []string
|
|
var rule string
|
|
|
|
// Check if it's jpn format
|
|
tiles = strings.ToUpper(tiles)
|
|
if strings.Contains(tiles, "M") || strings.Contains(tiles, "S") || strings.Contains(tiles, "P") {
|
|
rule = "JPN"
|
|
} else {
|
|
rule = "CHN"
|
|
}
|
|
|
|
for _, char := range tiles {
|
|
if unicode.IsDigit(char) {
|
|
stack = append(stack, string(char))
|
|
} else {
|
|
switch string(char) {
|
|
case "W", "M":
|
|
for _, prefix := range stack {
|
|
ret = append(ret, prefix+"W")
|
|
}
|
|
case "T", "S":
|
|
for _, prefix := range stack {
|
|
ret = append(ret, prefix+"T")
|
|
}
|
|
case "B", "P":
|
|
for _, prefix := range stack {
|
|
ret = append(ret, prefix+"B")
|
|
}
|
|
case "Z":
|
|
for _, prefix := range stack {
|
|
num, _ := strconv.Atoi(prefix)
|
|
ziPaiStr, _ := ziPaiShortSplit(num, rule)
|
|
ret = append(ret, ziPaiStr)
|
|
}
|
|
}
|
|
stack = []string{}
|
|
}
|
|
}
|
|
// Check return value valid, if not return error
|
|
for _, t := range ret {
|
|
if !slices.Contains(TileTypes, t) {
|
|
return []string{}, fmt.Errorf("invalid tile string with %s", t)
|
|
}
|
|
}
|
|
return ret, nil
|
|
}
|