feat: roulette bets street, corner, split, etc.

1 files changed, 375 insertions, 1 deletions

diff --git a/internal/casino/roulette.go b/internal/casino/roulette.go
index 5784ac9..cae9d0d 100644
--- a/internal/casino/roulette.go
+++ b/internal/casino/roulette.go
@@ -56,9 +56,24 @@ func normalizeRouletteSpot(spot string) string {
 }
 
 // Returns the covered pockets and total-return multiplier (stake included).
-// Zero never belongs to an outside bet.
+// Zero never belongs to an outside bet. Combination bets (splits, streets,
+// corners, six-lines, trios and the basket) are parsed from a compact number
+// list: the leading keyword is optional because the covered set uniquely
+// identifies the bet.
 func rouletteBet(spot string, double bool) ([]string, int) {
 	spot = normalizeRouletteSpot(spot)
+	if pockets, mult := rouletteStraightBet(spot, double); mult > 0 {
+		return pockets, mult
+	}
+	if pockets, mult := rouletteOutsideBet(spot); mult > 0 {
+		return pockets, mult
+	}
+	return rouletteCombinationBet(spot, double)
+}
+
+// rouletteStraightBet covers a single pocket: any number, 0, or 00 (American
+// tables only). It pays 35:1, a 36x total return.
+func rouletteStraightBet(spot string, double bool) ([]string, int) {
 	if spot == "00" {
 		if double {
 			return []string{spot}, 36
@@ -68,6 +83,12 @@ func rouletteBet(spot string, double bool) ([]string, int) {
 	if n, err := strconv.Atoi(spot); err == nil && n >= 0 && n <= 36 && strconv.Itoa(n) == spot {
 		return []string{spot}, 36
 	}
+	return nil, 0
+}
+
+// rouletteOutsideBet covers the even-money, dozen, and row wagers, whose
+// pocket counts all divide 36 exactly, so the return is 36/len.
+func rouletteOutsideBet(spot string) ([]string, int) {
 	var pockets []string
 	for n := 1; n <= 36; n++ {
 		hit := false
@@ -107,6 +128,359 @@ func rouletteBet(spot string, double bool) ([]string, int) {
 	return pockets, 36 / len(pockets)
 }
 
+// rouletteComboKeywords maps the accepted names for a combination bet onto
+// its canonical kind. Several names share a kind ("square" is a corner,
+// "sixline"/"double street" is a line).
+var rouletteComboKeywords = map[string]string{
+	"split":         "split",
+	"street":        "street",
+	"corner":        "corner",
+	"square":        "corner",
+	"line":          "line",
+	"sixline":       "line",
+	"six-line":      "line",
+	"doublestreet":  "line",
+	"double-street": "line",
+	"trio":          "trio",
+	"basket":        "basket",
+}
+
+// Payout returns are 36/covered for every combination except the five-number
+// American basket, which pays a deliberately short 6:1 (7x total).
+func rouletteCombinationBet(spot string, double bool) ([]string, int) {
+	kind, nums, ok := parseRouletteCombination(spot, double)
+	if !ok {
+		return nil, 0
+	}
+	if kind == "" {
+		kind = inferRouletteCombination(nums)
+	}
+	switch kind {
+	case "split":
+		if len(nums) == 2 && rouletteAdjacent(nums[0], nums[1], double) {
+			return nums, 18
+		}
+	case "street":
+		if rouletteIsStreet(nums) {
+			return nums, 12
+		}
+	case "corner":
+		if rouletteIsCorner(nums, double) {
+			return nums, 9
+		}
+	case "line":
+		if rouletteIsLine(nums) {
+			return nums, 6
+		}
+	case "trio":
+		if rouletteIsTrio(nums, double) {
+			return nums, 12
+		}
+	case "basket":
+		if pockets, mult, valid := rouletteBasket(nums, double); valid {
+			return pockets, mult
+		}
+	}
+	return nil, 0
+}
+
+// parseRouletteCombination strips an optional leading keyword and converts the
+// remaining number tokens (separated by spaces, dashes, slashes, commas or
+// backslashes) into canonical pocket names. Duplicate numbers are rejected.
+func parseRouletteCombination(spot string, double bool) (string, []string, bool) {
+	fields := strings.Fields(strings.ToLower(spot))
+	if len(fields) == 0 {
+		return "", nil, false
+	}
+	kind := ""
+	switch fields[0] {
+	case "split", "street", "corner", "square", "line", "sixline", "six-line", "doublestreet", "double-street", "trio", "basket":
+		kind = fields[0]
+		fields = fields[1:]
+	case "six":
+		if len(fields) > 1 && fields[1] == "line" {
+			kind, fields = "sixline", fields[2:]
+		}
+	case "double":
+		if len(fields) > 1 && fields[1] == "street" {
+			kind, fields = "doublestreet", fields[2:]
+		}
+	}
+	if canonical, ok := rouletteComboKeywords[kind]; ok {
+		kind = canonical
+	} else if kind != "" {
+		return "", nil, false
+	}
+	if kind == "basket" && len(fields) == 0 {
+		return "basket", nil, true
+	}
+	if len(fields) == 0 {
+		return "", nil, false
+	}
+	raw := strings.NewReplacer("-", " ", "/", " ", ",", " ", "\\", " ").Replace(strings.Join(fields, " "))
+	seen := map[string]bool{}
+	var nums []string
+	for _, tok := range strings.Fields(raw) {
+		pocket, ok := roulettePocketToken(tok, double)
+		if !ok || seen[pocket] {
+			return "", nil, false
+		}
+		seen[pocket] = true
+		nums = append(nums, pocket)
+	}
+	if len(nums) == 0 {
+		return "", nil, false
+	}
+	return kind, nums, true
+}
+
+// roulettePocketToken canonicalizes one number token: a plain 0-36 value or
+// 00, rejecting non-canonical spellings such as "01", "+1" or "000".
+func roulettePocketToken(tok string, double bool) (string, bool) {
+	if tok == "00" {
+		return "00", double
+	}
+	n, err := strconv.Atoi(tok)
+	if err != nil || n < 0 || n > 36 || strconv.Itoa(n) != tok {
+		return "", false
+	}
+	return strconv.Itoa(n), true
+}
+
+// inferRouletteCombination identifies a bare number list by its size. Adjacency
+// and geometry are validated after this, so an ambiguous count still fails.
+func inferRouletteCombination(nums []string) string {
+	switch len(nums) {
+	case 2:
+		return "split"
+	case 3:
+		if rouletteIsStreet(nums) {
+			return "street"
+		}
+		return "trio"
+	case 4:
+		return "corner"
+	case 5:
+		return "basket"
+	case 6:
+		return "line"
+	}
+	return ""
+}
+
+// rouletteNumberCell maps 1-36 onto its column and row on the felt: column
+// 0-11 left to right, row 0-2 bottom to top (row 0 holds 1,4,7,...).
+func rouletteNumberCell(n string) (col, row int, ok bool) {
+	v, err := strconv.Atoi(n)
+	if err != nil || v < 1 || v > 36 {
+		return 0, 0, false
+	}
+	return (v - 1) / 3, (v - 1) % 3, true
+}
+
+// rouletteAdjacent reports whether two pockets share an edge: horizontally
+// (same row, neighboring columns) or vertically (same column, neighboring
+// rows). Zero and double zero use the felt's special zero edge.
+func rouletteAdjacent(a, b string, double bool) bool {
+	if a == "0" || a == "00" || b == "0" || b == "00" {
+		return rouletteZeroAdjacent(a, b, double)
+	}
+	ac, ar, ok := rouletteNumberCell(a)
+	if !ok {
+		return false
+	}
+	bc, br, ok := rouletteNumberCell(b)
+	if !ok {
+		return false
+	}
+	dc, dr := ac-bc, ar-br
+	if dc < 0 {
+		dc = -dc
+	}
+	if dr < 0 {
+		dr = -dr
+	}
+	return (dc == 1 && dr == 0) || (dc == 0 && dr == 1)
+}
+
+// The zero lane spans all three numbered rows, so 0 splits with 1, 2 and 3.
+// On an American felt the two zeros are adjacent to each other as well.
+func rouletteZeroAdjacent(a, b string, double bool) bool {
+	neighbors := func(other string) bool {
+		if other == "0" || other == "00" {
+			return double
+		}
+		return other == "1" || other == "2" || other == "3"
+	}
+	if a == "0" || a == "00" {
+		return neighbors(b)
+	}
+	return neighbors(a)
+}
+
+func rouletteIsStreet(nums []string) bool {
+	if len(nums) != 3 {
+		return false
+	}
+	set := map[int]bool{}
+	for _, s := range nums {
+		v, err := strconv.Atoi(s)
+		if err != nil {
+			return false
+		}
+		set[v] = true
+	}
+	if len(set) != 3 {
+		return false
+	}
+	for n := 1; n <= 34; n += 3 {
+		if set[n] && set[n+1] && set[n+2] {
+			return true
+		}
+	}
+	return false
+}
+
+func rouletteIsCorner(nums []string, double bool) bool {
+	if len(nums) != 4 {
+		return false
+	}
+	// The European "first four" (0,1,2,3) is the only zero corner.
+	if !double && rouletteIsFirstFour(nums) {
+		return true
+	}
+	cells := map[[2]int]bool{}
+	for _, s := range nums {
+		c, r, ok := rouletteNumberCell(s)
+		if !ok {
+			return false
+		}
+		cells[[2]int{c, r}] = true
+	}
+	if len(cells) != 4 {
+		return false
+	}
+	cols, rows := map[int]bool{}, map[int]bool{}
+	for cell := range cells {
+		cols[cell[0]] = true
+		rows[cell[1]] = true
+	}
+	if len(cols) != 2 || len(rows) != 2 {
+		return false
+	}
+	for c := range cols {
+		for r := range rows {
+			if !cells[[2]int{c, r}] {
+				return false
+			}
+		}
+	}
+	return true
+}
+
+func rouletteIsFirstFour(nums []string) bool {
+	if len(nums) != 4 {
+		return false
+	}
+	set := map[string]bool{}
+	for _, s := range nums {
+		set[s] = true
+	}
+	return set["0"] && set["1"] && set["2"] && set["3"]
+}
+
+// A six-line is two neighboring columns, i.e. six numbers across all three
+// rows of two adjacent streets.
+func rouletteIsLine(nums []string) bool {
+	if len(nums) != 6 {
+		return false
+	}
+	cols := map[int]bool{}
+	set := map[int]bool{}
+	for _, s := range nums {
+		c, _, ok := rouletteNumberCell(s)
+		if !ok {
+			return false
+		}
+		v, _ := strconv.Atoi(s)
+		cols[c] = true
+		set[v] = true
+	}
+	if len(cols) != 2 || len(set) != 6 {
+		return false
+	}
+	var c1, c2 int
+	first := true
+	for c := range cols {
+		if first {
+			c1, first = c, false
+		} else {
+			c2 = c
+		}
+	}
+	if c1 > c2 {
+		c1, c2 = c2, c1
+	}
+	return c2-c1 == 1
+}
+
+// A trio is any three distinct pockets drawn from 0, 00 and the first street
+// (1,2,3) that includes at least one zero. It pays the same 11:1 as a street.
+func rouletteIsTrio(nums []string, double bool) bool {
+	if len(nums) != 3 {
+		return false
+	}
+	hasZero := false
+	for _, s := range nums {
+		switch s {
+		case "0":
+			hasZero = true
+		case "00":
+			if !double {
+				return false
+			}
+			hasZero = true
+		default:
+			v, err := strconv.Atoi(s)
+			if err != nil || v < 1 || v > 3 {
+				return false
+			}
+		}
+	}
+	return hasZero
+}
+
+// The basket is the American five-number 0/00/1/2/3 bet, which pays a short
+// 6:1. On a single-zero felt the name covers the European first four instead.
+// An empty list means the bare "basket" keyword.
+func rouletteBasket(nums []string, double bool) ([]string, int, bool) {
+	if len(nums) == 0 {
+		if double {
+			return []string{"0", "00", "1", "2", "3"}, 7, true
+		}
+		return []string{"0", "1", "2", "3"}, 9, true
+	}
+	if double {
+		set := map[string]bool{}
+		for _, s := range nums {
+			set[s] = true
+		}
+		if len(nums) != 5 {
+			return nil, 0, false
+		}
+		for _, need := range []string{"0", "00", "1", "2", "3"} {
+			if !set[need] {
+				return nil, 0, false
+			}
+		}
+		return []string{"0", "00", "1", "2", "3"}, 7, true
+	}
+	if rouletteIsFirstFour(nums) {
+		return []string{"0", "1", "2", "3"}, 9, true
+	}
+	return nil, 0, false
+}
+
 type roulettePlayer struct {
 	Participant
 	lastSpot string