diff options
Diffstat (limited to 'internal')
31 files changed, 2172 insertions, 104 deletions
diff --git a/internal/casino/baccarat.go b/internal/casino/baccarat.go index 1e7ab23..e30de5b 100644 --- a/internal/casino/baccarat.go +++ b/internal/casino/baccarat.go @@ -21,15 +21,75 @@ const ( type baccaratPlayer struct { Participant - lastBet int - lastSpot string - // stakeID is the wallet handle of the wager record committed this - // round; the settlement returns it inside the payout. - stakeID string + // mainSpot is the spot of the committed main wager (player, banker or + // tie). Once the round ends it is what a bare "bet" repeats. + mainSpot string + // sides holds this round's optional side-bet stakes by spot. + sides map[string]Wager + // lastBets remembers the last stake placed on each spot so a bare "bet" + // can repeat the side bets and the main wager together. + lastBets map[string]int } func (p *baccaratPlayer) participantPtr() *Participant { return &p.Participant } +// totalStaked is every credit this seat has committed to the current round. +func (p *baccaratPlayer) totalStaked() int { + total := 0 + if p.HasBet { + total += p.Wager.Total + } + for _, w := range p.sides { + total += w.Total + } + return total +} + +// sideSpots lists committed side spots in the table's own order so menus and +// settlements never depend on map iteration. +func (p *baccaratPlayer) sideSpots(rules BaccaratConfig) []string { + var spots []string + for _, spot := range rules.spots() { + if baccaratIsMainSpot(spot) || p.sides[spot].Total == 0 { + continue + } + spots = append(spots, spot) + } + return spots +} + +// wagers lists the main wager first, then every side bet, as one settlement +// and snapshot unit each. +func (p *baccaratPlayer) wagers(rules BaccaratConfig) []baccaratWager { + var out []baccaratWager + if p.HasBet { + out = append(out, baccaratWager{spot: p.mainSpot, wager: p.Wager}) + } + for _, spot := range p.sideSpots(rules) { + out = append(out, baccaratWager{spot: spot, wager: p.sides[spot]}) + } + return out +} + +func (p *baccaratPlayer) hasLastBet() bool { + for _, amount := range p.lastBets { + if amount > 0 { + return true + } + } + return false +} + +// baccaratWager pairs a committed stake with the spot it rides on. +type baccaratWager struct { + spot string + wager Wager +} + +func baccaratIsMainSpot(spot string) bool { + return spot == baccaratSpotPlayer || spot == baccaratSpotBanker || spot == baccaratSpotTie +} + type baccaratTable struct { tableCore[*baccaratPlayer] Rules BaccaratConfig @@ -47,18 +107,26 @@ func newBaccaratTable(roomID int, cfg TableConfig, rng *rand.Rand) *baccaratTabl } func (t *baccaratTable) menuEvent(name string) Event { - if p := t.players.get(name); p != nil && p.HasBet { + p := t.players.get(name) + if p != nil && p.HasBet { return t.committedMenu(name) } commands := []MenuCommand{} - if p := t.players.get(name); p != nil && p.lastBet > 0 { - commands = append(commands, MenuCommand{Command: "bet", Desc: fmt.Sprintf("Repeat %d on %s (also: rebet)", p.lastBet, p.lastSpot)}, MenuCommand{Command: "bet <amount>", Desc: "Change amount; keep " + p.lastSpot}) + if p != nil && p.hasLastBet() { + commands = append(commands, MenuCommand{Command: "bet", Desc: "Repeat your last bets"}) + } + if p != nil && len(p.sides) > 0 { + commands = append(commands, MenuCommand{Command: "unbet", Desc: "Take back your side bets"}) } - commands = append(commands, MenuCommand{Command: fmt.Sprintf("bet %d banker", t.Config.MinBet), Desc: "Choose banker (b), player (p), or tie (t)"}, MenuCommand{Command: "bet <amount> on <target>", Desc: "One wager per round; targets: list"}, MenuCommand{Command: "stop", Desc: "Leave; during a round, leave afterward"}, MenuCommand{Command: "table / sitout", Desc: "Check the table / skip betting until you rejoin"}) + commands = append(commands, + MenuCommand{Command: fmt.Sprintf("bet %d banker", t.Config.MinBet)}, + MenuCommand{Command: "bet <amount> on <bet>"}, + MenuCommand{Command: "stop", Desc: "Leave; during a round, leave afterward"}, + MenuCommand{Command: "table / sitout", Desc: "Check the table / skip betting until you rejoin"}) commands = withTableHints(commands, t.wagerRows()) e := t.betMenuEvent(name, commands) - if p := t.players.get(name); p != nil { - e.Menu.Repeat = p.lastBet > 0 + if p != nil { + e.Menu.Repeat = p.hasLastBet() } return e } @@ -90,14 +158,19 @@ func (t *baccaratTable) leave(name string) []Event { } // A wager is committed for the round in flight; everyone else may stand // up whenever they like. - if p.HasBet { + if p.totalStaked() > 0 { return []Event{t.private(name, "You're in the middle of a baccarat round!")} } + var events []Event + events = append(events, t.refundSidesLocked(p)...) t.removeSeatLocked(name) - events := []Event{t.playerAction(name, fmt.Sprintf("%s stands up.", name), "You stand up.")} + events = append(events, t.playerAction(name, fmt.Sprintf("%s stands up.", name), "You stand up.")) return t.closeIfEmptyLocked(events) } +// bet commits one wager: a main bet (player, banker or tie) or a side bet. +// Side bets may only be placed before the main wager, so the main bet remains +// the single trigger that ends the betting window and deals the cards. func (t *baccaratTable) bet(name, spot string, amount int, wallet Wallet) []Event { t.mu.Lock() defer t.mu.Unlock() @@ -106,7 +179,7 @@ func (t *baccaratTable) bet(name, spot string, amount int, wallet Wallet) []Even return []Event{t.private(name, "You aren't playing baccarat.")} } if spot == "" { - spot = p.lastSpot + spot = p.mainSpot } if spot == "" { return []Event{t.private(name, "Bet on what? Try bet <amount> on "+t.Rules.betChoices()+".")} @@ -114,21 +187,61 @@ func (t *baccaratTable) bet(name, spot string, amount int, wallet Wallet) []Even if !t.Rules.allowsSpot(spot) { return []Event{t.private(name, "Baccarat bets must be on player, banker, or tie, or an enabled optional bet. Available: "+t.Rules.betChoices()+".")} } - if p.HasBet { - return []Event{t.private(name, "You have already bet this round.")} + events, ok := t.placeBetLocked(p, spot, amount, wallet) + if !ok { + return events + } + return t.finishBetLocked(events) +} + +// placeBetLocked validates and commits a single wager without deciding +// whether the round should start. It reports false with a refusal event when +// the wager is not allowed. +func (t *baccaratTable) placeBetLocked(p *baccaratPlayer, spot string, amount int, wallet Wallet) ([]Event, bool) { + isMain := baccaratIsMainSpot(spot) + if isMain && p.HasBet { + return []Event{t.private(p.Name, "You have already bet a main wager this round.")}, false + } + if !isMain { + if p.sides[spot].Total > 0 { + return []Event{t.private(p.Name, "You have already bet that side wager this round.")}, false + } + if p.HasBet { + return []Event{t.private(p.Name, "Place side bets before your main wager.")}, false + } } if amount < t.Config.MinBet || amount > t.Config.MaxBet { - return []Event{t.private(name, fmt.Sprintf("Baccarat bets must be %s.", betRangeText(t.Config.MinBet, t.Config.MaxBet)))} + return []Event{t.private(p.Name, fmt.Sprintf("Baccarat bets must be %s.", betRangeText(t.Config.MinBet, t.Config.MaxBet)))}, false } - wager, err := wallet.Wager(amount) + if wallet == nil { + return []Event{t.private(p.Name, "Wallet unavailable.")}, false + } + stake, err := wallet.Wager(amount) if err != nil { - return []Event{t.private(name, walletErrorMessage(err))} + return []Event{t.private(p.Name, walletErrorMessage(err))}, false } + p.Wallet = wallet p.SittingOut = false - p.HasBet, p.Wager, p.Wallet, p.lastBet, p.lastSpot, p.stakeID = true, wager, wallet, amount, spot, wager.ID - events := []Event{t.playerAction(name, - fmt.Sprintf("%s bets %d credits on %s.", name, amount, spot), - fmt.Sprintf("You bet %d credits on %s.", amount, spot))} + if p.lastBets == nil { + p.lastBets = map[string]int{} + } + p.lastBets[spot] = amount + if isMain { + p.HasBet, p.Wager, p.mainSpot = true, stake, spot + } else { + if p.sides == nil { + p.sides = map[string]Wager{} + } + p.sides[spot] = stake + } + return []Event{t.playerAction(p.Name, + fmt.Sprintf("%s bets %d credits on %s.", p.Name, amount, spot), + fmt.Sprintf("You bet %d credits on %s.", amount, spot))}, true +} + +// finishBetLocked opens the shared betting window and deals the moment every +// active seat has a main wager. Side bets on their own never deal. +func (t *baccaratTable) finishBetLocked(events []Event) []Event { events = t.openBettingLocked(events) if allBet(t.players.participants()) { events = append(events, t.deal()...) @@ -136,23 +249,95 @@ func (t *baccaratTable) bet(name, spot string, amount int, wallet Wallet) []Even return events } +// rebetAll repeats every remembered side bet and then the main wager in one +// command. It is the baccarat meaning of a bare "bet". +func (t *baccaratTable) rebetAll(name string, wallet Wallet) []Event { + t.mu.Lock() + defer t.mu.Unlock() + p := t.players.get(name) + if p == nil { + return []Event{t.private(name, "You aren't playing baccarat.")} + } + if p.HasBet { + return []Event{t.private(name, "You have already bet a main wager this round.")} + } + if !p.hasLastBet() { + return []Event{t.private(name, "Bet on what? Try bet <amount> on "+t.Rules.betChoices()+".")} + } + var events []Event + for _, spot := range t.Rules.spots() { + if baccaratIsMainSpot(spot) { + continue + } + if amount := p.lastBets[spot]; amount > 0 { + ev, ok := t.placeBetLocked(p, spot, amount, wallet) + events = append(events, ev...) + if !ok { + return events + } + } + } + if p.mainSpot != "" { + if amount := p.lastBets[p.mainSpot]; amount > 0 { + ev, ok := t.placeBetLocked(p, p.mainSpot, amount, wallet) + events = append(events, ev...) + if !ok { + return events + } + } + } + return t.finishBetLocked(events) +} + func (t *baccaratTable) tick() []Event { t.mu.Lock() defer t.mu.Unlock() if t.phase != baccaratBetting { return nil } - return t.advanceBettingLocked(t.deal, t.resetRound) + sitOuts, goRound, pending := t.window.advance(t.players.participants()) + if pending { + if !t.window.timer.warn() { + return nil + } + var warnings []Event + for _, p := range t.players.participants() { + if p.Connected && !p.HasBet && !p.SittingOut { + warnings = append(warnings, t.warning(p.Name, fmt.Sprintf("Betting closes in %d ticks. Bet now or sit out this hand.", t.window.timer.remaining()))) + } + } + return warnings + } + var events []Event + // A seat with side bets but no main wager is not in the round; return the + // side stakes rather than letting them ride on a hand their owner skipped. + for _, p := range t.players.ordered() { + if !p.HasBet && len(p.sides) > 0 { + events = append(events, t.refundSidesLocked(p)...) + } + } + for _, name := range sitOuts { + events = append(events, t.event(fmt.Sprintf("%s sits out this baccarat round.", name), true)) + } + if goRound { + return append(events, t.deal()...) + } + t.resetRound() + return events } func (t *baccaratTable) action(name, action string) []Event { t.mu.Lock() defer t.mu.Unlock() if action == "unbet" { - events, _ := t.unbetLocked(name) - return events + return t.unbetAllLocked(name) } if events, handled := t.controlLocked(name, action); handled { + // A seat that sits out or leaves before committing a main wager is not + // in the round; return any side stakes it already placed. + if p := t.players.get(name); p != nil && !p.HasBet && len(p.sides) > 0 { + events = append(events, t.refundSidesLocked(p)...) + } if t.phase == baccaratBetting && allBet(t.players.participants()) { return append(events, t.deal()...) } @@ -161,11 +346,76 @@ func (t *baccaratTable) action(name, action string) []Event { return []Event{t.private(name, "That game has no player actions.")} } +// unbetAllLocked returns every stake the seat has committed this round, main +// wager and side bets alike. +func (t *baccaratTable) unbetAllLocked(name string) []Event { + p := t.players.get(name) + if p == nil { + return []Event{t.private(name, "You aren't seated at this table.")} + } + if t.phase != baccaratWaiting && t.phase != baccaratBetting { + return []Event{t.private(name, "You can only take back bets before the round starts.")} + } + total := 0 + var ids []string + if p.HasBet { + total += p.Wager.Total + if p.Wager.ID != "" { + ids = append(ids, p.Wager.ID) + } + } + for _, w := range p.sides { + total += w.Total + if w.ID != "" { + ids = append(ids, w.ID) + } + } + if total == 0 { + return []Event{t.private(name, "Nothing to take back.")} + } + if p.Wallet != nil { + if err := p.Wallet.PayCredits(total, ids...); err != nil { + return []Event{t.private(name, payoutFailedMessage())} + } + } + p.HasBet, p.Wager = false, Wager{} + p.sides = nil + return []Event{t.private(name, fmt.Sprintf("You take back %d credits.", total))} +} + +// refundSidesLocked returns every side stake on a seat that never committed a +// main wager. +func (t *baccaratTable) refundSidesLocked(p *baccaratPlayer) []Event { + total := 0 + var ids []string + for _, spot := range p.sideSpots(t.Rules) { + w := p.sides[spot] + total += w.Total + if w.ID != "" { + ids = append(ids, w.ID) + } + } + if total == 0 { + return nil + } + if p.Wallet != nil { + if err := p.Wallet.PayCredits(total, ids...); err != nil { + return []Event{t.private(p.Name, "Your side bets could not be returned just now; the stake stays pending and will be refunded after the next server restart.")} + } + } + p.sides = nil + return []Event{t.private(p.Name, fmt.Sprintf("Your %d in side bets is returned; no main wager was placed.", total))} +} + func (t *baccaratTable) rebet(name string) (string, int) { t.mu.Lock() defer t.mu.Unlock() - if p := t.players.get(name); p != nil && p.lastBet > 0 { - return p.lastSpot, p.lastBet + p := t.players.get(name) + if p == nil { + return "", t.Config.MinBet + } + if p.mainSpot != "" && p.lastBets[p.mainSpot] > 0 { + return p.mainSpot, p.lastBets[p.mainSpot] } return "", t.Config.MinBet } @@ -192,17 +442,33 @@ func (t *baccaratTable) deal() []Event { if !p.HasBet { continue } - result, payout, settleErr := settleBaccaratHand(p.lastSpot, p.Wager.Total, player, banker, t.Rules) + wagers := p.wagers(t.Rules) + lines := make([]settlementLine, 0, len(wagers)) + var ids []string + totalStake, totalReturn := 0, 0 + var payoutErr error + for _, w := range wagers { + result, payout, err := settleBaccaratHand(w.spot, w.wager.Total, player, banker, t.Rules) + if err != nil && payoutErr == nil { + payoutErr = err + } + if w.wager.ID != "" { + ids = append(ids, w.wager.ID) + } + totalStake += w.wager.Total + totalReturn += payout + line := settlementLine{Label: w.spot, Odds: baccaratSettlementOdds(w.spot, player, banker, t.Rules), Result: result, Stake: w.wager.Total, Returned: payout} + if result == "win" && w.spot == baccaratSpotTie { + line.Tag = "casino_jackpot_win" + } + lines = append(lines, line) + } // The shared settlement path pays before announcing and leaves the - // stake pending on any failure, so a refund can never be paid on top + // stakes pending on any failure, so a refund can never be paid on top // of a payout that was not durable. - payoutFailed := settleStakeOutcome(p.Wallet, payout, []string{p.stakeID}, settleErr) - publicResult, _ := baccaratResultMessages(p.Name, result, payout) - line := settlementLine{Label: p.lastSpot, Odds: baccaratSettlementOdds(p.lastSpot, player, banker, t.Rules), Result: result, Stake: p.Wager.Total, Returned: payout} - if result == "win" && p.lastSpot == baccaratSpotTie { - line.Tag = "casino_jackpot_win" - } - privateResult := settlementText([]settlementLine{line}) + payoutFailed := settleStakeOutcome(p.Wallet, totalReturn, ids, payoutErr) + publicResult, _ := baccaratResultMessages(p.Name, returnResult(totalStake, totalReturn), totalReturn) + privateResult := settlementText(lines) if payoutFailed { privateResult = payoutFailedMessage() publicResult = p.Name + "’s settlement is pending recovery." @@ -212,21 +478,21 @@ func (t *baccaratTable) deal() []Event { // departures/sit-outs need it attached to the settlement. settlement.ShowBalance = !payoutFailed && (p.LeaveAfter || p.SitOutAfter || !p.Connected) if !payoutFailed { - settlement.Settlement = []SettlementLine{line} + settlement.Settlement = lines switch { - case line.Tag != "": - settlement.Color = line.Tag - case result == "win": + case len(lines) == 1 && lines[0].Tag != "": + settlement.Color = lines[0].Tag + case totalReturn > totalStake: settlement.Color = "casino_result_win" - case result == "push": + case totalReturn == totalStake: settlement.Color = "casino_result_push" default: settlement.Color = "casino_result_loss" } } events = append(events, settlement) - // settleStakeOutcome already consumed this stake by handle (a payout - // removed it, a push/loss resolved it). Deliberately do NOT call the + // settleStakeOutcome already consumed these stakes by handle (a payout + // removed them, a push/loss resolved them). Deliberately do NOT call the // player-wide ResolveStakes here: it would also consume a stake left // pending by an earlier failed payout, which must stay refundable. } @@ -252,10 +518,9 @@ func (t *baccaratTable) snapshot(player, banker []card) *BaccaratSnapshot { snapshot.Banker = append(snapshot.Banker, CardView{Rank: c.rank, Suit: c.suit}) } for _, p := range t.players.ordered() { - if !p.HasBet { - continue + for _, w := range p.wagers(t.Rules) { + snapshot.Bets = append(snapshot.Bets, BaccaratBetView{Name: p.Name, Spot: w.spot, Amount: w.wager.Total}) } - snapshot.Bets = append(snapshot.Bets, BaccaratBetView{Name: p.Name, Spot: p.lastSpot, Amount: p.Wager.Total}) } return snapshot } @@ -265,7 +530,7 @@ func (t *baccaratTable) resetRound() { t.window.close() clearBets(t.players.participants()) for _, p := range t.players.ordered() { - p.stakeID = "" + p.sides = nil } } @@ -281,7 +546,7 @@ func (t *baccaratTable) markDisconnected(name string) []Event { if !t.players.has(name) { return nil } - if p := t.players.get(name); p != nil && p.HasBet && p.Wallet != nil { + if p := t.players.get(name); p != nil && p.totalStaked() > 0 && p.Wallet != nil { if _, _, err := p.Wallet.RefundOutstanding(); err != nil { // The stake stays pending on disk and startup recovery will return // it, but tell the departing player instead of silently swallowing diff --git a/internal/casino/baccarat_multi_wager_test.go b/internal/casino/baccarat_multi_wager_test.go new file mode 100644 index 0000000..2a56e63 --- /dev/null +++ b/internal/casino/baccarat_multi_wager_test.go @@ -0,0 +1,118 @@ +package casino + +import "testing" + +// TestBaccaratSideBetsRideWithMain pins the multi-wager contract: a side bet +// is committed before the main wager, both settle in the same round, and only +// the main wager deals the cards. +func TestBaccaratSideBetsRideWithMain(t *testing.T) { + cfg := TableConfig{ID: "baccarat", Game: GameBaccarat, Baccarat: BaccaratConfig{PairBets: true}} + table := newBaccaratTestTable(cfg) + table.join("alice") + forceShoe(table, baccaratCards("5 5 5 5 5 5")...) + w := &testWallet{credits: 1000} + if events := table.bet("alice", "player_pair", 10, w); hasMessage(events, "New baccarat hand!") { + t.Fatal("side bet alone dealt a round") + } + if table.players.get("alice").HasBet { + t.Fatal("side bet counted as the round's main wager") + } + events := table.bet("alice", "player", 10, w) + if !hasMessage(events, "New baccarat hand!") { + t.Fatalf("main wager did not deal: %+v", events) + } + // Player and banker tie at 5; the player main pushes and the player pair wins 11:1. + if w.paid != 130 { + t.Fatalf("paid=%d, want 130", w.paid) + } + var labels []string + for _, e := range events { + for _, line := range e.Settlement { + labels = append(labels, line.Label) + } + } + if len(labels) != 2 || labels[0] != "player" || labels[1] != "player_pair" { + t.Fatalf("settlement labels=%v, want [player player_pair]", labels) + } + // The snapshot carries both bets for the table view. + var snapshot *BaccaratSnapshot + for _, e := range events { + if s, ok := e.Snapshot.(*BaccaratSnapshot); ok && len(s.Bets) > 0 { + snapshot = s + } + } + if snapshot == nil || len(snapshot.Bets) != 2 || + snapshot.Bets[0].Spot != "player" || snapshot.Bets[0].Amount != 10 || + snapshot.Bets[1].Spot != "player_pair" || snapshot.Bets[1].Amount != 10 { + t.Fatalf("snapshot bets=%+v", snapshot) + } +} + +// A side wager may not follow the main wager: the main is the deal trigger. +func TestBaccaratSideBetAfterMainRefused(t *testing.T) { + table := newBaccaratTestTable(TableConfig{ID: "baccarat", Game: GameBaccarat, Baccarat: BaccaratConfig{PairBets: true}, MaxPlayers: 2}) + table.join("alice") + table.join("bob") + w := &testWallet{credits: 1000} + table.bet("alice", "player", 10, w) + if events := table.bet("alice", "player_pair", 10, w); !hasMessage(events, "before your main wager") { + t.Fatalf("side bet after main accepted: %+v", events) + } +} + +// A bare "bet" repeats the remembered side bets and the main wager together. +func TestBaccaratRebetAll(t *testing.T) { + cfg := TableConfig{ID: "baccarat", Game: GameBaccarat, Baccarat: BaccaratConfig{PairBets: true}} + table := newBaccaratTestTable(cfg) + table.join("alice") + forceShoe(table, baccaratCards("5 5 5 5 5 5")...) + table.bet("alice", "player_pair", 10, &testWallet{credits: 1000}) + table.bet("alice", "player", 10, &testWallet{credits: 1000}) + forceShoe(table, baccaratCards("5 5 5 5 5 5")...) + w := &testWallet{credits: 1000} + events := table.rebetAll("alice", w) + if !hasMessage(events, "New baccarat hand!") || w.paid != 130 { + t.Fatalf("rebet all did not replay both wagers: paid=%d events=%+v", w.paid, events) + } +} + +// unbet returns the main wager and every side bet in one step. +func TestBaccaratUnbetReturnsAllWagers(t *testing.T) { + table := newBaccaratTestTable(TableConfig{ID: "baccarat", Game: GameBaccarat, Baccarat: BaccaratConfig{PairBets: true}}) + table.join("alice") + w := &testWallet{credits: 1000} + table.bet("alice", "player_pair", 10, w) + table.bet("alice", "banker_pair", 15, w) + if events := table.unbetAllLocked("alice"); !hasMessage(events, "take back 25") { + t.Fatalf("unbet did not return both side stakes: %+v", events) + } + if w.paid != 25 || len(w.open) != 0 { + t.Fatalf("paid=%d open=%d, want 25/0", w.paid, len(w.open)) + } +} + +// A side-only seat is not part of the round: the timer returns the side stake +// and the other seat's main wager still deals. +func TestBaccaratSideOnlySeatRefundedOnTimeout(t *testing.T) { + cfg := TableConfig{ID: "baccarat", Game: GameBaccarat, Baccarat: BaccaratConfig{PairBets: true}, MaxPlayers: 2, BettingTicks: 2} + table := newBaccaratTestTable(cfg) + table.join("alice") + table.join("bob") + wa, wb := &testWallet{credits: 1000}, &testWallet{credits: 1000} + table.bet("alice", "player_pair", 10, wa) + table.bet("bob", "player", 10, wb) + forceShoe(table, baccaratCards("5 5 5 5 5 5")...) + var events []Event + for i := 0; i < 4 && !hasMessage(events, "New baccarat hand!"); i++ { + events = append(events, table.tick()...) + } + if !hasMessage(events, "New baccarat hand!") { + t.Fatalf("side-only seat held the round open: %+v", events) + } + if wa.paid != 10 { + t.Fatalf("alice side stake not returned: paid=%d", wa.paid) + } + if !hasMessage(events, "side bets is returned") { + t.Fatalf("missing side-bet refund notice: %+v", events) + } +} diff --git a/internal/casino/baccarat_rules.go b/internal/casino/baccarat_rules.go index 82cc294..7b11a92 100644 --- a/internal/casino/baccarat_rules.go +++ b/internal/casino/baccarat_rules.go @@ -46,7 +46,7 @@ func (c TableConfig) BaccaratRulesText() string { "Banker, if Player stands: Draw on 0–5, stand on 6–7", "Banker, if Player draws: 0–2 draw; 3 draws except against 8; 4 against 2–7; 5 against 4–7; 6 against 6–7; 7 stands", "Fractional credits: Rounded down; any commission rounds up and is collected on each win", - "Wagers: One per player per round, including optional bets; no simultaneous main/optional wagers", + "Wagers: One main bet (player, banker or tie) plus any enabled side bets; side bets are placed before the main wager", "Available bets: " + b.betChoices(), "Bet limits (all wagers): " + betRangeText(c.MinBet, c.MaxBet) + " credits", fmt.Sprintf("Seats: %d; betting window: %d ticks", c.MaxPlayers, c.BettingTicks), diff --git a/internal/casino/baccarat_variants_test.go b/internal/casino/baccarat_variants_test.go index 094412e..fd84c25 100644 --- a/internal/casino/baccarat_variants_test.go +++ b/internal/casino/baccarat_variants_test.go @@ -105,7 +105,8 @@ func TestBaccaratEZLiveSettlementAndOptionalMenus(t *testing.T) { forceShoe(table, baccaratCards("A A A A 2 5")...) wa, wb := &testWallet{credits: 100}, &testWallet{credits: 100} table.bet("alice", "banker", 10, wa) - events = table.bet("bob", "dragon_7", 10, wb) + table.bet("bob", "dragon_7", 10, wb) + events = table.bet("bob", "player", 10, wb) if wa.paid != 10 || wb.paid != 410 { t.Fatalf("banker=%d dragon=%d", wa.paid, wb.paid) } @@ -125,7 +126,7 @@ func TestBaccaratRuleCard(t *testing.T) { for _, variant := range []string{BaccaratCommission, BaccaratSuper6, BaccaratEZ} { cfg := TableConfig{ID: "test", Game: GameBaccarat, Baccarat: BaccaratConfig{Variant: variant, Decks: 6, TiePayout: 9}} text := cfg.BaccaratRulesText() - for _, want := range []string{"Number of decks: 6", "Tie pays 9:1", "Player pair (player_pair): Not offered", "Dragon 7 (dragon_7): Not offered", "Panda 8 (panda_8): Not offered", "Super 6 bet (super_6): Not offered", "One per player per round"} { + for _, want := range []string{"Number of decks: 6", "Tie pays 9:1", "Player pair (player_pair): Not offered", "Dragon 7 (dragon_7): Not offered", "Panda 8 (panda_8): Not offered", "Super 6 bet (super_6): Not offered", "One main bet (player, banker or tie)"} { if !strings.Contains(text, want) { t.Errorf("missing %q: %s", want, text) } diff --git a/internal/casino/baccarat_wagers.go b/internal/casino/baccarat_wagers.go index cf2653e..d457cdc 100644 --- a/internal/casino/baccarat_wagers.go +++ b/internal/casino/baccarat_wagers.go @@ -16,9 +16,9 @@ func (t *baccaratTable) wagerRows() []WagerRow { banker = "1:1 (3-card 7 pushes)" } rows := []WagerRow{ - {"player (p)", "1:1", "Player's last digit beats Banker's"}, - {"banker (b)", banker, "Banker's last digit beats Player's"}, - {"tie (t)", fmt.Sprintf("%g:1", rules.TiePayout), "Both hands finish equal"}, + {"player", "1:1", "Player's last digit beats Banker's"}, + {"banker", banker, "Banker's last digit beats Player's"}, + {"tie", fmt.Sprintf("%g:1", rules.TiePayout), "Both hands finish equal"}, } if rules.PairBets { rows = append(rows, diff --git a/internal/casino/house_edge.go b/internal/casino/house_edge.go new file mode 100644 index 0000000..01fe7aa --- /dev/null +++ b/internal/casino/house_edge.go @@ -0,0 +1,138 @@ +package casino + +import ( + "fmt" + "math" + "strings" +) + +// HouseEdge is expected net loss / initial stake (not loss per roll, nor +// probability of losing). Parts keep grouped targets with different edges +// separate. Unknown analyses must never silently become a zero-percent edge. +// Values are unrounded fractions; only the presentation rounds percentages. +type HouseEdge struct { + Parts []EdgePart + Note string +} + +type EdgePart struct { + Label string + Loss float64 +} + +func edge(loss float64) HouseEdge { return HouseEdge{Parts: []EdgePart{{Loss: loss}}} } +func unknownEdge(reason string) HouseEdge { return HouseEdge{Note: "not verified: " + reason} } + +func (e HouseEdge) Text(precision int) string { + if precision != 2 { + precision = 0 + } + var parts []string + for _, p := range e.Parts { + // Avoid displaying negative zero while preserving genuine player edges. + percent := math.Round(p.Loss*100*math.Pow10(precision)) / math.Pow10(precision) + if percent == 0 { + percent = 0 + } + value := fmt.Sprintf("%.*f%%", precision, percent) + parts = append(parts, value) + } + if len(parts) == 0 { + return "" + } + return "House edge: " + strings.Join(parts, " / ") +} + +// HouseEdge dispatches through the game's registration. A new game must +// supply its own analysis; it never inherits another game's percentage. +// This is an off-the-top, pre-credit-rounding reference, not a card-counting +// aid or a prediction of the next outcome. Strategy assumptions and sources +// are documented alongside each game's calculation; Note is diagnostic only. +func (c TableConfig) HouseEdge(bet string) HouseEdge { + c = c.Normalize() + if def, ok := tableGameDefFor(c.Game); ok && def.houseEdge != nil { + return def.houseEdge(c, bet) + } + return unknownEdge("this game's rules have no house-edge analysis") +} + +// HouseEdge reads seat-specific settings under the game's lock. It does not +// alter game state, advance RNGs, or reveal cards from the current shoe. +func (t *Table) HouseEdge(name, bet string) HouseEdge { + if vp, ok := t.game.(*videoPokerTable); ok { + vp.mu.Lock() + defer vp.mu.Unlock() + if p := vp.players[name]; p != nil { + return pokerHouseEdge(p.config, bet, p.loaded, p.featureOn, p.hands) + } + } + if pg, ok := t.game.(*paiGowTable); ok && bet == "fortune" && t.Config.PaiGow.Envy { + pg.mu.Lock() + defer pg.mu.Unlock() + others, stake := 0, max(1, t.Config.MinBet) + for _, p := range pg.players { + if p.name == name { + if p.fortune.Total > 0 { + stake = p.fortune.Total + } + } else if p.main.Total > 0 { + others++ + } + } + e := t.Config.HouseEdge(bet) + e.Parts[0].Loss -= fortuneEnvyReturn(others, stake) + return e + } + return t.Config.HouseEdge(bet) +} + +func rouletteHouseEdge(c TableConfig, bet string) HouseEdge { + pockets := 37.0 + if c.Roulette.DoubleZero { + pockets = 38 + } + // Recognize the catalogue explicitly: a new target must not accidentally + // inherit the standard edge (the American basket is a counterexample). + for _, row := range (&rouletteTable{tableCore: newTableCore[*roulettePlayer](&tableBase{Config: c})}).wagerRows() { + if row.Bet == bet { + if bet == "basket" && c.Roulette.DoubleZero { + return edge(3 / pockets) + } + return edge((pockets - 36) / pockets) + } + } + return unknownEdge("unrecognized roulette target") +} + +func blackjackHouseEdge(c TableConfig, bet string) HouseEdge { + if bet == "insurance" { + // Given a dealer ace from a fresh shoe; NOT conditional on the player's + // visible cards or a running count. Remaining tens = 16 per deck. + b := c.Blackjack.Normalize() + e := edge(1 - float64(16*b.Decks)/float64(52*b.Decks-1)*(1+b.InsurancePayout)) + e.Note = "fresh shoe, dealer ace only; visible cards change this" + return e + } + switch bet { + case "main": + return edge(blackjackMainEdge(c.Blackjack)) + case "hit", "stand", "decline", "double", "split": + return HouseEdge{Note: "not a separate wager; decision EV depends on the hand"} + case "surrender": + return HouseEdge{Note: "returns half the original stake; not a new wager"} + } + return unknownEdge("unrecognized blackjack wager") +} + +func (c MachineConfig) HouseEdge() HouseEdge { + c = c.Normalize() + if c.Game != GameSlots { + return unknownEdge("unrecognized machine game") + } + if _, ok := slotVariants[c.Variant]; !ok { + return unknownEdge("unrecognized slot profile") + } + e := edge(1 - CalculateRTP(machineSlotProfile(c))) + e.Note = "includes free spins; before residual fractional-credit loss on leaving" + return e +} diff --git a/internal/casino/house_edge_baccarat.go b/internal/casino/house_edge_baccarat.go new file mode 100644 index 0000000..1598fd6 --- /dev/null +++ b/internal/casino/house_edge_baccarat.go @@ -0,0 +1,131 @@ +package casino + +import ( + "strings" + "sync" +) + +type baccaratProbabilities struct { + player, banker, tie, dragon, panda, six float64 +} + +var baccaratEdgeCache sync.Map // deck count -> baccaratProbabilities + +func baccaratHouseEdge(cfg TableConfig, bet string) HouseEdge { + c := cfg.Baccarat.Normalize() + spot := strings.Fields(bet) + if len(spot) == 0 { + return unknownEdge("unrecognized baccarat target") + } + p := baccaratFreshProbabilities(c.Decks) + var e HouseEdge + switch spot[0] { + case "player": + e = edge(p.banker - p.player) + case "banker": + loss := p.player - c.BankerPayout*p.banker + if c.Variant == BaccaratSuper6 { + loss += .5 * p.six + } + if c.Variant == BaccaratEZ { + loss += p.dragon + } + e = edge(loss) + case "tie": + e = edge(1 - (1+c.TiePayout)*p.tie) + case "player_pair", "banker_pair": + e = edge(1 - 12*float64(4*c.Decks-1)/float64(52*c.Decks-1)) + case "dragon_7": + e = edge(1 - 41*p.dragon) + case "panda_8": + e = edge(1 - 26*p.panda) + case "super_6": + e = edge(1 - 13*p.six) + default: + return unknownEdge("unrecognized baccarat target") + } + e.Note = "fresh shoe; before fractional-credit rounding" + return e +} + +// Enumerate value sequences WITHOUT replacement from the configured shoe. +// Tens/J/Q/K coalesce into value zero; rank-pair probability is separately +// exact by symmetry. At most 10^6 branches, cached by deck count. Uses the +// same banker tableau as playTableau; no sampled or generic casino rates. +func baccaratFreshProbabilities(decks int) baccaratProbabilities { + if v, ok := baccaratEdgeCache.Load(decks); ok { + return v.(baccaratProbabilities) + } + var out baccaratProbabilities + counts := [10]int{} + for i := range counts { + counts[i] = 4 * decks + } + counts[0] = 16 * decks + var cards [6]int + var deal func(int, float64) + finish := func(pt, bt, pn, bn int, prob float64) { + switch { + case pt > bt: + out.player += prob + if pn == 3 && pt == 8 { + out.panda += prob + } + case bt > pt: + out.banker += prob + if bn == 3 && bt == 7 { + out.dragon += prob + } + if bt == 6 { + out.six += prob + } + default: + out.tie += prob + } + } + deal = func(n int, prob float64) { + if n >= 4 { + pt, bt := (cards[0]+cards[1])%10, (cards[2]+cards[3])%10 + if pt >= 8 || bt >= 8 { + finish(pt, bt, 2, 2, prob) + return + } + playerDraw := pt <= 5 + if playerDraw && n == 4 { // draw Player's third below + } else { + third, pn := -1, 2 + if playerDraw { + third = cards[4] + pt = (pt + third) % 10 + pn = 3 + } + bankerDraw := (third < 0 && bt <= 5) || (third >= 0 && bankerDraws(bt, third)) + if !bankerDraw { + finish(pt, bt, pn, 2, prob) + return + } + needed := 5 + if playerDraw { + needed = 6 + } + if n == needed { + finish(pt, (bt+cards[n-1])%10, pn, 3, prob) + return + } + } + } + remaining := float64(52*decks - n) + for value, count := range counts { + if count == 0 { + continue + } + counts[value]-- + cards[n] = value + deal(n+1, prob*float64(count)/remaining) + counts[value]++ + } + } + deal(0, 1) + baccaratEdgeCache.Store(decks, out) + return out +} diff --git a/internal/casino/house_edge_blackjack.go b/internal/casino/house_edge_blackjack.go new file mode 100644 index 0000000..884cf75 --- /dev/null +++ b/internal/casino/house_edge_blackjack.go @@ -0,0 +1,182 @@ +package casino + +import "math" + +// A small infinite-shoe decision model supplies the effect of payout, H17, +// DAS and the game's unusual doubled-split-21 rule. Deck count and resplitting +// use the published basic-strategy rule adjustments at: +// https://wizardofodds.com/games/blackjack/rule-variations/ +// This is a reference estimate, not a finite-shoe/composition strategy solver. +func blackjackMainEdge(r BlackjackConfig) float64 { + r = r.Normalize() + base := BlackjackConfig{}.Normalize() + no := false + base.DoubleSplitBlackjack = &no + loss := .0043 - (blackjackReferenceEV(r) - blackjackReferenceEV(base)) + // Improvements relative to eight decks; interpolate uncommon deck counts. + decks := []float64{0, .0048, .0019, .00125, .0006, .0003, .0002, .0001, 0} + if r.Decks < len(decks) { + loss -= decks[r.Decks] + } else { + loss += .0006 * (1 - 8/float64(r.Decks)) + } + if r.MaxSplitHands == 2 { + loss += .001 + } else if r.MaxSplitHands == 3 { + loss += .0001 + } + if r.MaxSplitHands > 1 && r.AllowsResplitAces() { + loss -= .0008 + } + return loss +} + +// The split model allows one split; published adjustments above account for +// the configured resplit limit. Unlike-ten splitting does not change normal +// optimal play (tens are stood on). Shuffle penetration is not an off-top rule. +func blackjackReferenceEV(r BlackjackConfig) float64 { + probability := func(v int) float64 { + if v == 10 { + return 4.0 / 13 + } + return 1.0 / 13 + } + add := func(total, soft, v int) (int, int) { + if v == 1 { + total += 11 + soft++ + } else { + total += v + } + for total > 21 && soft > 0 { + total -= 10 + soft-- + } + return total, soft + } + result := 0.0 + for up := 1; up <= 10; up++ { + // Outcomes 17..21 and bust (22), conditional on no dealer natural. + type state struct{ total, soft int } + memoDealer := map[state][23]float64{} + var dealer func(int, int) [23]float64 + dealer = func(total, soft int) [23]float64 { + key := state{total, soft} + if v, ok := memoDealer[key]; ok { + return v + } + var out [23]float64 + if total > 21 { + out[22] = 1 + } else if total >= 17 && !(total == 17 && soft > 0 && r.DealerHitsSoft17()) { + out[total] = 1 + } else { + for v := 1; v <= 10; v++ { + t, s := add(total, soft, v) + child := dealer(t, s) + for i, p := range child { + out[i] += probability(v) * p + } + } + } + memoDealer[key] = out + return out + } + natural := 0.0 + if up == 1 { + natural = probability(10) + } + if up == 10 { + natural = probability(1) + } + var outcomes [23]float64 + for hole := 1; hole <= 10; hole++ { + if up+hole == 11 && (up == 1 || hole == 1) { + continue + } + t, s := add(0, 0, up) + t, s = add(t, s, hole) + dist := dealer(t, s) + for i, p := range dist { + outcomes[i] += probability(hole) * p / (1 - natural) + } + } + stand := func(total int) float64 { + if total > 21 { + return -1 + } + ev := outcomes[22] + for d := 17; d <= 21; d++ { + if total > d { + ev += outcomes[d] + } else if total < d { + ev -= outcomes[d] + } + } + return ev + } + memoPlayer := map[state]float64{} + var play func(int, int) float64 + play = func(total, soft int) float64 { + if total >= 21 { + return stand(total) + } + key := state{total, soft} + if v, ok := memoPlayer[key]; ok { + return v + } + hit := 0.0 + for v := 1; v <= 10; v++ { + t, s := add(total, soft, v) + hit += probability(v) * play(t, s) + } + ev := math.Max(stand(total), hit) + memoPlayer[key] = ev + return ev + } + hand := func(a, b int, split bool) float64 { + total, soft := add(0, 0, a) + total, soft = add(total, soft, b) + if split && a == 1 { + return stand(total) + } // one card on split aces + ev := play(total, soft) + if total < 21 && (!split || r.AllowsDoubleAfterSplit()) { + doubled := 0.0 + for v := 1; v <= 10; v++ { + t, _ := add(total, soft, v) + value := stand(t) + if split && t == 21 && r.CountsDoubleSplitBlackjack() { + value = r.BlackjackPayout + } + doubled += 2 * probability(v) * value + } + ev = math.Max(ev, doubled) + } + if !split && r.AllowsSurrender() { + ev = math.Max(ev, -.5) + } + return ev + } + for a := 1; a <= 10; a++ { + for b := 1; b <= 10; b++ { + ev := 0.0 + if a+b == 11 && (a == 1 || b == 1) { + ev = (1 - natural) * r.BlackjackPayout + } else { + ev = hand(a, b, false) + if a == b && r.MaxSplitHands > 1 { + split := 0.0 + for v := 1; v <= 10; v++ { + split += 2 * probability(v) * hand(a, v, true) + } + ev = math.Max(ev, split) + } + ev = (1-natural)*ev - natural + } + result += probability(up) * probability(a) * probability(b) * ev + } + } + } + return result +} diff --git a/internal/casino/house_edge_craps.go b/internal/casino/house_edge_craps.go new file mode 100644 index 0000000..06a6629 --- /dev/null +++ b/internal/casino/house_edge_craps.go @@ -0,0 +1,136 @@ +package casino + +import ( + "strconv" + "strings" +) + +func crapsHouseEdge(cfg TableConfig, bet string) HouseEdge { + c := cfg.Craps.Normalize() + switch bet { + case "pass", "come", "dontpass", "dontcome": + return edge(-crapsContractEV(c, bet, 0)) + case "odds pass", "odds come <n>", "odds dontpass", "odds dontcome <n>": + return edge(0) + case "buy <n>", "lay <n>": + e := HouseEdge{Note: "5% commission on wins, before upward credit rounding; small stakes cost more"} + for _, n := range []int{2, 3, 4, 5, 6, 8, 9, 10, 11, 12} { + if !c.number(n) { + continue + } + // Buy: 5% of stake times P(number before 7). + // Lay: 5% of true-odds profit times P(7 before number). + // Both reduce to .05 * ways(number)/(ways(number)+6). + w := float64(diceWays(n)) + e.Parts = append(e.Parts, EdgePart{strconv.Itoa(n), .05 * w / (w + 6)}) + } + return e + case "hard 4 / hard 10": + return edge(-crapsResolvedEV(c, "hard", 4)) + case "hard 6 / hard 8": + return edge(-crapsResolvedEV(c, "hard", 6)) + case "eleven / ace-deuce": + return edge(-crapsResolvedEV(c, "eleven", 0)) + case "aces / boxcars": + return edge(-crapsResolvedEV(c, "aces", 0)) + case "hop <a> <b>": + return HouseEdge{Parts: []EdgePart{{"unequal dice", -crapsResolvedEV(c, "hop", 12)}, {"doubles", -crapsResolvedEV(c, "hop", 11)}}} + case "small / tall": + return edge(1 - 35*crapsCollectProbability([]int{2, 3, 4, 5, 6})) + case "all": + return edge(1 - 176*crapsCollectProbability([]int{2, 3, 4, 5, 6, 8, 9, 10, 11, 12})) + case "fire": + return edge(1 - crapsFireReturn()) + case "field", "seven", "craps", "horn": + return edge(-crapsResolvedEV(c, bet, 0)) + } + if strings.HasPrefix(bet, "place ") { + n, err := strconv.Atoi(strings.TrimPrefix(bet, "place ")) + if err == nil && c.number(n) { + return edge(-crapsResolvedEV(c, "place", n)) + } + } + return unknownEdge("unrecognized craps target") +} + +func diceWays(n int) int { + if n < 2 || n > 12 { + return 0 + } + if n > 7 { + return 13 - n + } + return n - 1 +} + +// Enumerate the actual outcome function, skipping neutral rolls. Off-on- +// come-out wagers have the same eventual EV when left working to resolution. +func crapsResolvedEV(c CrapsConfig, kind string, n int) float64 { + sum, resolved := 0.0, 0.0 + for a := 1; a <= 6; a++ { + for b := 1; b <= 6; b++ { + ok, x, y := c.outcome(kind, n, a, b, 6) + if ok { + sum += float64(x) / float64(y) + resolved++ + } + } + } + return sum / resolved +} + +// A contract starts at n=0 and travels once to its personal point. Self +// loops (neutral dice or high-point come-out 2/3) are eliminated exactly. +func crapsContractEV(c CrapsConfig, kind string, n int) float64 { + sum, effective := 0.0, 0.0 + for a := 1; a <= 6; a++ { + for b := 1; b <= 6; b++ { + if c.variant() == "die_rich" && b != 1 { + continue + } + bb := b + if c.variant() == "die_rich" { + bb = 0 + } + ok, x, y := c.outcome(kind, n, a, bb, 6) + if ok { + sum += float64(x) / float64(y) + effective++ + continue + } + if n == 0 && c.pointNumber(a+bb) { + sum += crapsContractEV(c, kind, a+bb) + effective++ + } + } + } + return sum / effective +} + +// Probability of collecting all listed totals before ANY seven. All other +// rolls are self loops. This also accounts for duplicate rolls correctly. +func crapsCollectProbability(numbers []int) float64 { + full := (1 << len(numbers)) - 1 + memo := make(map[int]float64) + var visit func(int) float64 + visit = func(mask int) float64 { + if mask == full { + return 1 + } + if p, ok := memo[mask]; ok { + return p + } + numerator, denominator := 0.0, 6.0 + for i, n := range numbers { + if mask&(1<<i) != 0 { + continue + } + w := float64(diceWays(n)) + numerator += w * visit(mask|(1<<i)) + denominator += w + } + memo[mask] = numerator / denominator + return memo[mask] + } + return visit(0) +} diff --git a/internal/casino/house_edge_fire.go b/internal/casino/house_edge_fire.go new file mode 100644 index 0000000..3bb1697 --- /dev/null +++ b/internal/casino/house_edge_fire.go @@ -0,0 +1,61 @@ +package casino + +import "math/bits" + +// crapsFireReturn is the fire bet's exact expected return (profit plus stake +// where the bet wins; nothing where it loses) per unit staked. The bet +// resolves only on a point-phase seven-out — a come-out seven keeps the +// shooter's hand and the bet alive — paying 24/249/999:1 for 4/5/6 distinct +// made points. The state is the six-bit mask of distinct points made in the +// hand; come-out rolls and rerolls of an already-made point are self loops. +// Solved by fixed-point iteration over the 64 masks (the chain is absorbing +// and monotone, so iteration converges to the exact solution). +func crapsFireReturn() float64 { + numbers := []int{4, 5, 6, 8, 9, 10} + ways := make([]int, len(numbers)) + for i, n := range numbers { + ways[i] = diceWays(n) + } + pay := func(made int) float64 { + switch made { + case 4: + return 25 // 24:1 profit plus the returned stake + case 5: + return 250 + case 6: + return 1000 + } + return 0 + } + vCome := make([]float64, 64) + for it := 0; it < 2000; it++ { + next := make([]float64, 64) + for mask := 0; mask < 64; mask++ { + sum := 0.0 + for i := range numbers { + w := ways[i] + nm := mask | 1<<i + // Point-phase value of an established point n: making it + // moves to the come-out with the grown mask; a seven (6/36) + // resolves the bet at the CURRENT mask (not the grown one — + // the point has not been made). + made := bits.OnesCount(uint(mask)) + pointValue := (float64(w)/36*vCome[nm] + 6.0/36*pay(made)) / (1 - float64(36-w-6)/36) + sum += float64(w) / 36 * pointValue + } + next[mask] = sum / (24.0 / 36.0) + } + done := true + for i := range next { + if diff := next[i] - vCome[i]; diff > 1e-12 || diff < -1e-12 { + done = false + break + } + } + vCome = next + if done { + break + } + } + return vCome[0] +} diff --git a/internal/casino/house_edge_pai_gow.go b/internal/casino/house_edge_pai_gow.go new file mode 100644 index 0000000..82cff09 --- /dev/null +++ b/internal/casino/house_edge_pai_gow.go @@ -0,0 +1,55 @@ +package casino + +// Main-game reference estimates: published house-way play, not a solver for +// this implementation's house way or a player's chosen arrangement. Sources: +// https://wizardofodds.com/games/pai-gow-poker/ +// https://wizardofodds.com/games/ez-pai-gow-poker/ +// https://wizardofodds.com/games/face-up-pai-gow-poker/ +// The wheel convention can change individual results; these rounded reference +// estimates do not resolve its small effect on the full strategy distribution. +func paiGowHouseEdge(c TableConfig, bet string) HouseEdge { + r := c.PaiGow.Normalize() + switch bet { + case "main": + switch r.Variant { + case PaiGowClassic: + return edge(.027212) + case PaiGowEZ: + return edge(.0254) + case PaiGowFaceUp: + return edge(.0181) + case PaiGowNoPush: + // No published table for our tiebreaker variant. Use published classic + // win/loss/push frequencies, remove commission, then price tied extra + // cards as dealer wins. Five ace-valued cards (including joker), 12x4 + // other ranks. Card-removal correlation is ignored in this estimate. + return edge(.303847 - .291195 + .404958*(5.0*4+12*4*3)/(53*52)) + } + case "fortune": + profit := -121694196.0 + for i, row := range FortunePayTable(r.Envy) { + profit += float64(row.Odds * fortuneCombinations[i]) + } + return edge(-profit / 154143080) + case "pushace": + if rates, ok := r.pushAceRates(); ok { + // Published event probabilities (both ace-high, joker, plain ace-high). + return edge(1 - (.008700*float64(rates[2]+1) + .004100*float64(rates[1]+1) + .080800*float64(rates[0]+1))) + } + } + return unknownEdge("unrecognized pai gow wager") +} + +// Fortune table 8 category counts, also pinned by pai_gow_test.go. +var fortuneCombinations = []int{32, 72, 196, 1128, 26020, 184644, 307472, 4188528, 6172088, 7672500, 11034204, 2862000} + +func fortuneEnvyReturn(others, stake int) float64 { + if stake < 5 { + return 0 + } + total := 0.0 + for i, row := range FortunePayTable(true) { + total += float64(row.Envy * fortuneCombinations[i]) + } + return total / 154143080 * float64(others) / float64(stake) +} diff --git a/internal/casino/house_edge_rules_test.go b/internal/casino/house_edge_rules_test.go new file mode 100644 index 0000000..b79888f --- /dev/null +++ b/internal/casino/house_edge_rules_test.go @@ -0,0 +1,148 @@ +package casino + +import ( + "math" + "math/rand" + "strings" + "testing" +) + +func TestBlackjackEdgeRules(t *testing.T) { + no, yes := false, true + base := BlackjackConfig{DoubleSplitBlackjack: &no}.Normalize() + want := blackjackMainEdge(base) + if math.Abs(want-.0043) > 1e-10 { + t.Fatalf("standard eight decks: %g", want) + } + cases := []struct { + name string + change func(*BlackjackConfig) + higher bool + }{ + {"one deck", func(r *BlackjackConfig) { r.Decks = 1 }, false}, + {"two decks", func(r *BlackjackConfig) { r.Decks = 2 }, false}, + {"H17", func(r *BlackjackConfig) { r.DealerHitSoft17 = &yes }, true}, + {"6:5", func(r *BlackjackConfig) { r.BlackjackPayout = 1.2 }, true}, + {"no DAS", func(r *BlackjackConfig) { r.DoubleAfterSplit = &no }, true}, + {"surrender", func(r *BlackjackConfig) { r.Surrender = &yes }, false}, + {"no resplit", func(r *BlackjackConfig) { r.MaxSplitHands = 2 }, true}, + {"no split", func(r *BlackjackConfig) { r.MaxSplitHands = 1 }, true}, + {"resplit aces", func(r *BlackjackConfig) { r.ResplitAces = &yes }, false}, + {"double split blackjack", func(r *BlackjackConfig) { r.DoubleSplitBlackjack = &yes }, false}, + } + for _, tc := range cases { + t.Run(tc.name, func(t *testing.T) { + r := base + tc.change(&r) + got := blackjackMainEdge(r) + if (got > want) != tc.higher || math.Abs(got-want) < 1e-8 { + t.Fatalf("edge %g base %g", got, want) + } + }) + } + h17 := base + h17.DealerHitSoft17 = &yes + if math.Abs(blackjackMainEdge(h17)-want-.0022) > .0003 { + t.Fatal("H17 adjustment departed from published reference") + } + for _, action := range []string{"hit", "stand", "split", "double", "decline", "surrender"} { + if got := (TableConfig{Game: GameBlackjack}).HouseEdge(action).Text(2); got != "" { + t.Errorf("action %s has standalone edge: %s", action, got) + } + } +} + +func TestVideoPokerEdgeEveryCabinetSchedule(t *testing.T) { + for cabinet, games := range cabinetGames { + for _, variant := range games { + for _, tier := range []string{"low", "normal", "full"} { + c := (VideoPokerConfig{Cabinet: cabinet, Payout: tier, Variant: variant}).Normalize() + for _, hands := range CabinetHandCounts(cabinet, variant) { + for _, feature := range []bool{false, true} { + for coins := 1; coins <= 5; coins++ { + e := pokerHouseEdge(c, "main", coins, feature, hands) + if len(e.Parts) != 1 || math.IsNaN(e.Parts[0].Loss) { + t.Fatalf("missing edge %s %s %s hands=%d feature=%v coins=%d: %+v", cabinet, variant, tier, hands, feature, coins, e) + } + } + } + } + } + } + } +} + +func TestVideoPokerEdgeReferences(t *testing.T) { + for _, tc := range []struct { + c VideoPokerConfig + coins int + feature bool + hands int + want float64 + }{ + {VideoPokerConfig{}, 5, false, 1, .00456096}, + {VideoPokerConfig{Payout: "low"}, 5, false, 1, .038528}, + {VideoPokerConfig{}, 1, false, 1, .00456096 + 550*.00002476}, + {VideoPokerConfig{Cabinet: CabinetUXSingle}, 5, true, 1, .0028}, + {VideoPokerConfig{Cabinet: CabinetUXMulti}, 5, true, 3, .007022}, + {VideoPokerConfig{Cabinet: CabinetUXMulti}, 5, true, 10, .005780}, + {VideoPokerConfig{Cabinet: CabinetSuperTimesPay}, 5, true, 1, 1 - .99543904*(18.05/15)*5/6}, + {VideoPokerConfig{Cabinet: CabinetHotRoll}, 5, true, 3, .00456096}, + {VideoPokerConfig{Variant: "deuces_wild"}, 5, false, 1, -.007620}, + } { + e := pokerHouseEdge(tc.c, "main", tc.coins, tc.feature, tc.hands) + if len(e.Parts) != 1 || math.Abs(e.Parts[0].Loss-tc.want) > 1e-9 { + t.Fatalf("%+v: %+v want %g", tc, e, tc.want) + } + } +} + +func TestHouseEdgeUsesVideoPokerSeat(t *testing.T) { + cfg := (TableConfig{Game: GameVideoPoker}).Normalize() + game := newVideoPokerTable(1, cfg, rand.New(rand.NewSource(1))).(*videoPokerTable) + game.players["alice"] = &pokerPlayer{config: (VideoPokerConfig{Variant: "deuces_wild"}).Normalize(), loaded: 5, hands: 1} + table := &Table{game: game} + if got := table.HouseEdge("alice", "main").Text(2); got != "House edge: -0.76%" { + t.Fatal(got) + } + game.players["alice"].loaded = 1 + if got := table.HouseEdge("alice", "main").Text(2); got == "House edge: -0.76%" { + t.Fatal("coin selection ignored") + } +} + +func TestPaiGowEdgeReferences(t *testing.T) { + for _, tc := range []struct { + r PaiGowConfig + bet string + want float64 + }{ + {PaiGowConfig{}, "fortune", .034318}, + {PaiGowConfig{Envy: true}, "fortune", .044292}, + {PaiGowConfig{Variant: PaiGowFaceUp, PushAceHigh: "5_15_40"}, "pushace", .0929}, + {PaiGowConfig{Variant: PaiGowFaceUp, PushAceHigh: "5_12_40"}, "pushace", .1052}, + } { + e := paiGowHouseEdge(TableConfig{PaiGow: tc.r}, tc.bet) + if math.Abs(e.Parts[0].Loss-tc.want) > .000001 { + t.Fatalf("%+v: %+v", tc, e) + } + } + for _, variant := range []string{PaiGowClassic, PaiGowEZ, PaiGowNoPush, PaiGowFaceUp} { + if e := paiGowHouseEdge(TableConfig{PaiGow: PaiGowConfig{Variant: variant}}, "main"); len(e.Parts) != 1 { + t.Fatal(variant, e) + } + } + if fortuneEnvyReturn(2, 5) <= fortuneEnvyReturn(1, 5) || fortuneEnvyReturn(2, 4) != 0 { + t.Fatal("Envy eligibility/scaling") + } +} + +func TestHouseEdgeTextOnlyPercentage(t *testing.T) { + e := HouseEdge{Parts: []EdgePart{{Label: "something", Loss: .027027}}, Note: "explanation"} + if e.Text(0) != "House edge: 3%" || e.Text(2) != "House edge: 2.70%" { + t.Fatal(e.Text(2)) + } + if strings.Contains(e.Text(2), "explanation") || unknownEdge("unknown").Text(2) != "" { + t.Fatal("extra prose") + } +} diff --git a/internal/casino/house_edge_test.go b/internal/casino/house_edge_test.go new file mode 100644 index 0000000..5f75e44 --- /dev/null +++ b/internal/casino/house_edge_test.go @@ -0,0 +1,127 @@ +package casino + +import ( + "strings" + "testing" +) + +// TestKnownHouseEdges pins the exact expected-loss figures against +// independently derived values (the engine's own resolution rules for +// variant-specific bets, standard published mathematics for the classics). +// A changed payout or rule must break this test, never silently reprice the +// reference. +func TestKnownHouseEdges(t *testing.T) { + cases := []struct { + name string + cfg TableConfig + bet string + want float64 // expected loss per unit stake (unrounded fraction) + }{ + {"roulette straight", TableConfig{Game: GameRoulette}, "<number>", 1.0 / 37}, + {"roulette even money", TableConfig{Game: GameRoulette}, "red / black", 1.0 / 37}, + {"roulette DZ straight", TableConfig{Game: GameRoulette, Roulette: RouletteConfig{DoubleZero: true}}, "<number>", 2.0 / 38}, + {"roulette DZ basket", TableConfig{Game: GameRoulette, Roulette: RouletteConfig{DoubleZero: true}}, "basket", 3.0 / 38}, + {"craps pass", TableConfig{Game: GameCraps}, "pass", 0.014141414141414}, + {"craps dontpass", TableConfig{Game: GameCraps}, "dontpass", 0.013636363636364}, + {"craps come", TableConfig{Game: GameCraps}, "come", 0.014141414141414}, + {"craps dontcome", TableConfig{Game: GameCraps}, "dontcome", 0.013636363636364}, + {"craps odds", TableConfig{Game: GameCraps}, "odds pass", 0}, + {"craps field 2", TableConfig{Game: GameCraps}, "field", 0.055555555555556}, + {"craps field 3", TableConfig{Game: GameCraps, Craps: CrapsConfig{Field12: 3}}, "field", 0.027777777777778}, + {"craps seven", TableConfig{Game: GameCraps}, "seven", 1.0 / 6}, + {"craps craps", TableConfig{Game: GameCraps}, "craps", 1.0 / 9}, + {"craps eleven", TableConfig{Game: GameCraps}, "eleven / ace-deuce", 1.0 / 9}, + {"craps aces", TableConfig{Game: GameCraps}, "aces / boxcars", 5.0 / 36}, + {"craps horn", TableConfig{Game: GameCraps}, "horn", 0.125}, + {"craps place 4", TableConfig{Game: GameCraps}, "place 4", 0.066666666666667}, + {"craps place 5", TableConfig{Game: GameCraps}, "place 5", 0.04}, + {"craps place 6", TableConfig{Game: GameCraps}, "place 6", 0.015151515151515}, + {"craps hard 4", TableConfig{Game: GameCraps}, "hard 4 / hard 10", 1.0 / 9}, + {"craps hard 6", TableConfig{Game: GameCraps}, "hard 6 / hard 8", 1.0 / 11}, + {"craps small", TableConfig{Game: GameCraps}, "small / tall", 0.077613176297387}, + {"craps all", TableConfig{Game: GameCraps}, "all", 0.074644079069427}, + {"craps fire", TableConfig{Game: GameCraps}, "fire", 0.207627504982314}, + {"craps simplified", TableConfig{Game: GameCraps, Craps: CrapsConfig{Variant: "simplified"}}, "pass", 1.0 / 36}, + {"craps high point", TableConfig{Game: GameCraps, Craps: CrapsConfig{Variant: "high_point"}}, "pass", 0.023569023569024}, + {"craps die rich", TableConfig{Game: GameCraps, Craps: CrapsConfig{Variant: "die_rich"}}, "pass", 0}, + {"craps crapless", TableConfig{Game: GameCraps, Craps: CrapsConfig{Variant: "crapless"}}, "pass", 0.053823953823954}, + {"craps new york", TableConfig{Game: GameCraps, Craps: CrapsConfig{Variant: "new_york"}}, "pass", 0.014141414141414}, + {"craps new york dontpass", TableConfig{Game: GameCraps, Craps: CrapsConfig{Variant: "new_york"}}, "dontpass", 0.013636363636364}, + {"baccarat player", TableConfig{Game: GameBaccarat}, "player", 0.012350813289149}, + {"baccarat banker", TableConfig{Game: GameBaccarat}, "banker", 0.010579057842466}, + {"baccarat tie", TableConfig{Game: GameBaccarat}, "tie", 0.143596287787302}, + {"baccarat pair", TableConfig{Game: GameBaccarat}, "player_pair", 0.103614457831325}, + {"baccarat dragon", TableConfig{Game: GameBaccarat, Baccarat: BaccaratConfig{Dragon7: true}}, "dragon_7", 0.076113344724498}, + {"baccarat panda", TableConfig{Game: GameBaccarat, Baccarat: BaccaratConfig{Panda8: true}}, "panda_8", 0.101876321693189}, + {"baccarat super6 bet", TableConfig{Game: GameBaccarat, Baccarat: BaccaratConfig{Super6Bet: true}}, "super_6", 0.299771693848976}, + {"baccarat super6 banker", TableConfig{Game: GameBaccarat, Baccarat: BaccaratConfig{Variant: BaccaratSuper6}}, "banker", 0.014581044639736}, + {"baccarat ez banker", TableConfig{Game: GameBaccarat, Baccarat: BaccaratConfig{Variant: BaccaratEZ}}, "banker", 0.010183007571229}, + {"baccarat 6 decks player", TableConfig{Game: GameBaccarat, Baccarat: BaccaratConfig{Decks: 6}}, "player", 0.012374148986428}, + } + for _, tc := range cases { + if tc.bet == "" { + continue + } + got := tc.cfg.HouseEdge(tc.bet) + if strings.Contains(got.Note, "not verified") { + t.Fatalf("%s: expected a verified edge, got %q", tc.name, got.Text(2)) + } + if len(got.Parts) != 1 || abs64(got.Parts[0].Loss-tc.want) > 5e-13 { + t.Fatalf("%s: loss = %.18f, want %.18f", tc.name, got.Parts[0].Loss, tc.want) + } + } +} + +// Strategy games have reference estimates rather than missing readouts. +func TestStrategyHouseEdges(t *testing.T) { + for _, tc := range []struct { + name string + cfg TableConfig + bet string + }{ + {"blackjack main", TableConfig{Game: GameBlackjack}, "main"}, + {"paigow main", TableConfig{Game: GamePaiGow}, "main"}, + {"paigow fortune", TableConfig{Game: GamePaiGow}, "fortune"}, + {"video poker", TableConfig{Game: GameVideoPoker}, "main"}, + } { + got := tc.cfg.HouseEdge(tc.bet) + if len(got.Parts) != 1 || got.Text(2) == "" { + t.Fatalf("%s: missing reference edge: %+v", tc.name, got) + } + } +} + +// TestUnrecognizedTargetNeverInherits: a target the analysis does not know +// must be flagged, not silently given another bet's edge. +func TestUnrecognizedTargetNeverInherits(t *testing.T) { + for _, cfg := range []TableConfig{ + {Game: GameRoulette}, + {Game: GameCraps}, + {Game: GameBaccarat}, + {Game: GameBlackjack}, + {Game: GamePaiGow}, + {Game: GameVideoPoker}, + } { + if got := cfg.HouseEdge("not-a-bet"); got.Note == "" { + t.Fatalf("%s: unrecognized target inherited an edge: %s", cfg.Game, got.Text(2)) + } + } +} + +// TestHopBetsTwoParts pins the split hop analysis (easy vs doubles). +func TestHopBetsTwoParts(t *testing.T) { + got := (TableConfig{Game: GameCraps}).HouseEdge("hop <a> <b>") + if len(got.Parts) != 2 { + t.Fatalf("hop analysis: %s", got.Text(2)) + } + if abs64(got.Parts[0].Loss-1.0/9) > 5e-13 || abs64(got.Parts[1].Loss-5.0/36) > 5e-13 { + t.Fatalf("hop losses = %s", got.Text(2)) + } +} + +func abs64(x float64) float64 { + if x < 0 { + return -x + } + return x +} diff --git a/internal/casino/house_edge_video_poker.go b/internal/casino/house_edge_video_poker.go new file mode 100644 index 0000000..52af719 --- /dev/null +++ b/internal/casino/house_edge_video_poker.go @@ -0,0 +1,82 @@ +package casino + +// Published optimal max-coin returns and royal frequencies. Source pages: +// https://wizardofodds.com/games/video-poker/tables/{jacks-or-better, +// bonus-poker,bonus-poker-deluxe,double-bonus,double-double-bonus, +// deuces-wild,joker-poker-kings-or-better}/ +// Below max coins we price the reduced royal using that schedule's strategy; +// this is a reference estimate rather than a second optimal-strategy solver. +type pokerReturn struct{ rtp, royal float64 } + +var pokerReturns = map[string]map[string]pokerReturn{ + "jacks_or_better": {"9/6": {.99543904, .00002476}, "9/5": {.984498, .000025}, "8/6": {.983927, .000025}, "8/5": {.97298434, .00002489}, "7/5": {.961472, .000025}}, + "bonus_poker": {"8/5": {.991660, .000025}, "7/5": {.980147, .000025}, "6/5": {.968687, .000025}}, + "bonus_poker_deluxe": {"9/6": {.996417, .000024}, "9/5": {.985495, .000025}, "8/6": {.984928, .000024}, "8/5": {.974009, .000025}, "7/5": {.962526, .000025}}, + "double_bonus": {"10/7": {1.001725, .000021}, "9/7": {.991065, .000021}, "9/6/5": {.978062, .000024}, "9/6/4": {.963754, .000024}, "9/5/4": {.952738, .000025}, "8/5": {.941897, .000025}}, + "double_double_bonus": {"10/6": {1.000670, .000025}, "9/6": {.989808, .000025}, "8/6": {.978949, .000025}, "9/5": {.978729, .000025}, "8/5": {.967861, .000025}}, + "deuces_wild": {"25/15/9/5/3/2": {1.007620, .000022}, "25/15/9/4/4/3": {.989131, .000023}, "20/12/10/4/4/3": {.975791, .000023}, "25/16/13/4/3/2": {.967651, .000023}}, + "joker_poker": {"50/17/7/5/3": {.980854, .000025}, "50/16/7/5/3": {.972349, .000025}, "50/15/7/5/3": {.963848, .000025}}, +} + +// Ultimate X is a continuing-game reference, not the value of cashing in a +// particular banked multiplier. Entries are single / three / five / ten hands. +// Sources: .../tables/ultimate-x-single-line/ and .../tables/ultimate-x/. +var pokerUXReturns = map[string]map[string][4]float64{ + "jacks_or_better": {"9/6": {.9972, 0, 0, 0}, "8/6": {.9857, .992978, .994008, .994220}, "8/5": {.9738, .978730, .979671, .979795}, "7/5": {.9623, .967211, .968142, .968267}}, + "bonus_poker": {"8/5": {.9921, .992828, .993408, .994034}, "7/5": {.9809, .981242, .981817, .982439}, "6/5": {.9694, 0, 0, 0}}, + "bonus_poker_deluxe": {"9/6": {.9996, 0, 0, 0}, "8/6": {.9882, .995712, .996777, .997022}, "8/5": {.9747, .981052, .982014, .982169}, "7/5": {.9632, .969549, .970502, .970658}}, + "double_bonus": {"9/7": {.9921, .988866, .989590, .990359}, "9/6/5": {.9811, .984517, .985227, .985987}, "9/6/4": {.9662, .973059, .973764, .974517}, "9/5/4": {.9539, .959471, .960118, .960810}}, + "double_double_bonus": {"9/6": {.9905, .997261, .997928, .998663}, "9/5": {.9793, .983633, .984253, .984940}, "8/5": {.9680, .972266, .972859, .973521}}, + "deuces_wild": {"25/15/9/4/4/3": {.9905, .991282, .992657, .994362}, "20/12/10/4/4/3": {.9788, .979863, .981217, .982817}, "25/16/13/4/3/2": {.9681, .969387, .970777, .972477}}, + "joker_poker": {"50/17/7/5/3": {.9824, .989856, .990144, .990445}, "50/16/7/5/3": {.9738, .981190, .981474, .981771}, "50/15/7/5/3": {.9652, .972528, .972808, .973102}}, +} + +func videoPokerHouseEdge(c TableConfig, bet string) HouseEdge { + r := c.VideoPoker.Normalize() + return pokerHouseEdge(r, bet, 5, true, CabinetHandCounts(r.Cabinet, r.Variant)[0]) +} + +func pokerHouseEdge(c VideoPokerConfig, bet string, coins int, feature bool, hands int) HouseEdge { + if bet != "main" { + return unknownEdge("unrecognized video poker wager") + } + c = c.Normalize() + ref, ok := pokerReturns[c.Variant][c.PayTable] + if !ok { + return unknownEdge("unrecognized poker schedule") + } + rtp := ref.rtp + if coins > 0 && coins < 5 { + rtp -= 550 * ref.royal + feature = false + } + if feature { + switch c.Feature { + case PokerUltimateX: + ix := 0 + if c.Cabinet == CabinetUXMulti { + switch hands { + case 3: + ix = 1 + case 5: + ix = 2 + case 10: + ix = 3 + default: + return unknownEdge("unsupported hand count") + } + } + rtp = pokerUXReturns[c.Variant][c.PayTable][ix] + if rtp == 0 { + return unknownEdge("unsupported Ultimate X schedule") + } + case PokerSuperTimesPay: + // E[multiplier] = 14/15 + (2*.17+3*.33+4*.16+5*.24+8*.06+10*.04)/15. + rtp *= (14.0/15 + 4.05/15) * 5 / 6 + case PokerHotRoll: + // Five extra coins buy 5/6 normal hands and 1/6 at mean 7x. + rtp *= (5.0/6 + 7.0/6) / 2 + } + } + return edge(1 - rtp) +} diff --git a/internal/casino/manager.go b/internal/casino/manager.go index 2162656..5fa6439 100644 --- a/internal/casino/manager.go +++ b/internal/casino/manager.go @@ -285,6 +285,15 @@ func (m *Manager) Rebet(roomID int, tableID, name string) (string, int) { return "", 0 } +// RebetAll repeats every remembered wager for games that keep several; other +// games return nil and keep their single-wager rebet path. +func (m *Manager) RebetAll(roomID int, tableID, name string, wallet Wallet) []Event { + if table := m.Table(roomID, tableID); table != nil { + return table.RebetAll(name, wallet) + } + return nil +} + // MarkDisconnected removes the player from every table and machine, // forfeiting any wager they had committed, so seats free up immediately. func (m *Manager) MarkDisconnected(name string) []Event { diff --git a/internal/casino/registry.go b/internal/casino/registry.go index 25fbce5..dbf3b31 100644 --- a/internal/casino/registry.go +++ b/internal/casino/registry.go @@ -13,6 +13,9 @@ import ( // apart. The rule structs stay on TableConfig; this does not introduce a // config union. type tableGameDef struct { + // houseEdge analyzes this game's own configured wagers; nil means unverified, + // never zero. See house_edge.go for the loss/stake convention. + houseEdge func(TableConfig, string) HouseEdge // validate checks a raw (pre-Normalize) table config. validate func(TableConfig) error // normalize applies this game's rule defaults to a table config. @@ -42,7 +45,8 @@ var tableGames map[GameName]tableGameDef func init() { tableGames = map[GameName]tableGameDef{ GamePaiGow: { - validate: validatePaiGow, + houseEdge: paiGowHouseEdge, + validate: validatePaiGow, normalize: func(c TableConfig) TableConfig { c.PaiGow = c.PaiGow.Normalize() c.MaxPlayers = min(c.MaxPlayers, 6) @@ -56,6 +60,7 @@ func init() { helpTopic: func(TableConfig) string { return "pai gow poker" }, }, GameVideoPoker: { + houseEdge: videoPokerHouseEdge, validate: func(c TableConfig) error { if c.MaxPlayers > 1 { return fmt.Errorf("video poker cabinets have one seat") @@ -70,6 +75,7 @@ func init() { helpTopic: func(c TableConfig) string { return pokerHelpTopic(c.VideoPoker) }, }, GameCraps: { + houseEdge: crapsHouseEdge, validate: validateCraps, normalize: func(c TableConfig) TableConfig { c.Craps = c.Craps.Normalize(); return c }, ruleBlockName: "craps", @@ -79,6 +85,7 @@ func init() { helpTopic: func(c TableConfig) string { return c.Craps.helpTopic() }, }, GameRoulette: { + houseEdge: rouletteHouseEdge, validate: func(c TableConfig) error { if c.Roulette.SpinTicks < 0 || c.Roulette.SpinTicks > maxSpinTicks { return fmt.Errorf("roulette spin_ticks must be between 0 and %d", maxSpinTicks) @@ -101,6 +108,7 @@ func init() { helpTopic: func(TableConfig) string { return "roulette" }, }, GameBlackjack: { + houseEdge: blackjackHouseEdge, validate: validateBlackjackTable, normalize: normalizeBlackjackTable, ruleBlockName: "blackjack", @@ -112,6 +120,7 @@ func init() { helpTopic: func(TableConfig) string { return "blackjack" }, }, GameBaccarat: { + houseEdge: baccaratHouseEdge, validate: validateBaccaratTable, normalize: normalizeBaccaratTable, ruleBlockName: "baccarat", diff --git a/internal/casino/table.go b/internal/casino/table.go index b1beab9..2f4473b 100644 --- a/internal/casino/table.go +++ b/internal/casino/table.go @@ -107,6 +107,16 @@ func (t *Table) tick() []Event { return t.game.tick() } func (t *Table) action(name, action string) []Event { return t.game.action(name, action) } func (t *Table) rebet(name string) (string, int) { return t.game.rebet(name) } +// RebetAll repeats every remembered wager for a game that keeps more than one +// (currently baccarat's side bets plus main bet). It returns nil for games +// whose bare "bet" is a single-wager repeat. +func (t *Table) RebetAll(name string, wallet Wallet) []Event { + if b, ok := t.game.(*baccaratTable); ok { + return b.rebetAll(name, wallet) + } + return nil +} + func (t *Table) markDisconnected(name string) []Event { return t.game.markDisconnected(name) } func (t *Table) hasParticipant(name string) bool { return t.game.hasParticipant(name) } diff --git a/internal/casino/table_hints.go b/internal/casino/table_hints.go index 00eea53..51dda1a 100644 --- a/internal/casino/table_hints.go +++ b/internal/casino/table_hints.go @@ -69,17 +69,21 @@ func baccaratHintCommands(t *baccaratTable, name string) []MenuCommand { p := t.players.get(name) if p != nil && p.HasBet { return []MenuCommand{ + {Command: "unbet", Desc: "Take back all your wagers before the round"}, {Command: "stop", Desc: "Leave; during a round, leave afterward"}, {Command: "table / sitout", Desc: "Check the table / skip betting until you rejoin"}, } } commands := []MenuCommand{} - if p != nil && p.lastBet > 0 { - commands = append(commands, MenuCommand{Command: "bet", Desc: fmt.Sprintf("Repeat %d on %s (also: rebet)", p.lastBet, p.lastSpot)}, MenuCommand{Command: "bet <amount>", Desc: "Change amount; keep " + p.lastSpot}) + if p != nil && p.hasLastBet() { + commands = append(commands, MenuCommand{Command: "bet", Desc: "Repeat your last bets"}) + } + if p != nil && len(p.sides) > 0 { + commands = append(commands, MenuCommand{Command: "unbet", Desc: "Take back your side bets"}) } return append(commands, - MenuCommand{Command: fmt.Sprintf("bet %d banker", t.Config.MinBet), Desc: "Choose banker (b), player (p), or tie (t)"}, - MenuCommand{Command: "bet <amount> on <target>", Desc: "One wager per round; targets: list"}, + MenuCommand{Command: fmt.Sprintf("bet %d banker", t.Config.MinBet)}, + MenuCommand{Command: "bet <amount> on <bet>"}, MenuCommand{Command: "stop", Desc: "Leave; during a round, leave afterward"}, MenuCommand{Command: "table / sitout", Desc: "Check the table / skip betting until you rejoin"}, ) diff --git a/internal/casino/table_ux.go b/internal/casino/table_ux.go index 569128b..c7b9fd1 100644 --- a/internal/casino/table_ux.go +++ b/internal/casino/table_ux.go @@ -257,11 +257,16 @@ func (t *baccaratTable) status(name string) []Event { t.mu.Lock() defer t.mu.Unlock() e := t.private(name, "") + p := t.players.get(name) if text := t.seatStatusLocked(name); text != "" { + // Report every committed stake, not just the main wager. + if p != nil && p.HasBet && len(p.sides) > 0 && strings.HasPrefix(text, "Wager committed") { + text = fmt.Sprintf("Wager committed: %d", p.totalStaked()) + } e.Message = text } events := []Event{e} - if p := t.players.get(name); p != nil && !p.HasBet { + if p != nil && !p.HasBet { events = append(events, t.menuEvent(name)) } return events diff --git a/internal/casino/table_ux_test.go b/internal/casino/table_ux_test.go index ea8bc04..4d58a5f 100644 --- a/internal/casino/table_ux_test.go +++ b/internal/casino/table_ux_test.go @@ -223,7 +223,7 @@ func TestRebetMenusAndMidRoundJoin(t *testing.T) { } bac.bet("alice", "banker", 25, &testWallet{credits: 100}) menu := bac.menuEvent("alice").Menu - if !menu.Repeat || !strings.Contains(menu.Commands[0].Desc, "Repeat 25 on banker") { + if !menu.Repeat || menu.Commands[0].Command != "bet" || !strings.Contains(menu.Commands[0].Desc, "Repeat") { t.Fatalf("missing rebet details: %+v", menu) } } diff --git a/internal/game/casino.go b/internal/game/casino.go index 8238b7c..21f9627 100644 --- a/internal/game/casino.go +++ b/internal/game/casino.go @@ -419,6 +419,12 @@ func (g *Game) executeBet(sess *net.Session, args []string, rawInput string) { g.emitCasinoEvents(g.Casino.Action(table.RoomID, table.Config.ID, p.Name, strings.TrimSpace("coins "+strings.Join(args, " ")))) return } + // Baccarat repeats every remembered side bet and the main bet on a bare + // "bet"; games with one wager keep the generic single-rebet path below. + if table.Config.Game == casino.GameBaccarat && len(args) == 0 { + g.emitCasinoEvents(g.Casino.RebetAll(table.RoomID, table.Config.ID, p.Name, casinoWallet{g: g, p: p})) + return + } // Table bet syntax: bet | bet <amount> [on] <target> | bet min|max [on] <target>. // BEFORE an "on" keyword, a token that parses as an amount (or min/max) // sets the wager and any other token is the bet target; AFTER "on", the diff --git a/internal/game/casino_edge_list_test.go b/internal/game/casino_edge_list_test.go new file mode 100644 index 0000000..ff0b965 --- /dev/null +++ b/internal/game/casino_edge_list_test.go @@ -0,0 +1,97 @@ +package game + +import ( + "strings" + "testing" + + "thehouseoficarus/internal/item" + "thehouseoficarus/internal/player" +) + +func TestEdgeListAllTableGames(t *testing.T) { + for _, game := range []string{"blackjack", "baccarat", "roulette", "craps", "paigow", "video_poker"} { + t.Run(game, func(t *testing.T) { + g, sess, conn := houseEdgeGame(t, "name: Casino\ncasino_tables:\n - id: test\n game: "+game+"\n") + writeHouseEdgeManual(t, g, sess, 2) + g.executePlay(sess, []string{game}, "play "+game) + if strings.Contains(stripANSI(string(conn.data)), "RTP") { + t.Fatal("readout on join") + } + conn.data = nil + g.executeList(sess, nil, "list") + text := stripANSI(string(conn.data)) + if !strings.Contains(text, "RTP") { + t.Fatalf("no RTP column for %s: %s", game, text) + } + assertRTPColumn(t, text) + sess.Player.Inventory = nil + conn.data = nil + g.executeList(sess, nil, "list") + if strings.Contains(stripANSI(string(conn.data)), "RTP") { + t.Fatal("readout after reference removed") + } + }) + } +} + +func TestEdgeListBlackjackActionsOmitRTP(t *testing.T) { + g, sess, conn := houseEdgeGame(t, "name: BJ\ncasino_tables:\n - id: bj\n game: blackjack\n") + writeHouseEdgeManual(t, g, sess, 2) + g.executePlay(sess, []string{"bj"}, "play bj") + table, _ := g.Casino.Participation(sess.Player.Name) + for i := 0; i < 10 && len(table.Wagers(sess.Player.Name)) == 0; i++ { + g.executeBet(sess, []string{"1"}, "bet 1") + } + rows := table.Wagers(sess.Player.Name) + if len(rows) == 0 { + t.Skip("no action rows this deal") + } + insurance := false + for _, r := range rows { + if r.Bet == "insurance" { + insurance = true + } + } + conn.data = nil + g.executeList(sess, nil, "list") + text := stripANSI(string(conn.data)) + if insurance { + // Insurance is a real wager and carries an RTP. + if !strings.Contains(text, "RTP") { + t.Fatalf("insurance list lost its RTP:\n%s", text) + } + return + } + if strings.Contains(text, "RTP") { + t.Fatalf("action-only list showed an RTP column:\n%s", text) + } +} + +func TestEdgeListRealInstruments(t *testing.T) { + g, sess, conn := houseEdgeGame(t, roomRoulette) + g.ItemStore = item.NewItemStore("../../data") + sess.Player.Inventory = map[int]*player.InventorySlot{ + 0: {ItemID: "house_edge_tile", Quantity: 1}, + 1: {ItemID: "house_edge_computus", Quantity: 1}, + } + g.executePlay(sess, []string{"roulette"}, "play roulette") + conn.data = nil + g.executeList(sess, nil, "list") + text := stripANSI(string(conn.data)) + if strings.Count(text, "97.30%") != 12 { + t.Fatalf("best instrument not used: %s", text) + } + sess.Player.Inventory[1].Quantity = 0 + conn.data = nil + g.executeList(sess, nil, "list") + text = stripANSI(string(conn.data)) + if strings.Count(text, "97%") != 12 { + t.Fatalf("tile not used: %s", text) + } + sess.Player.Inventory[0].Quantity = 0 + conn.data = nil + g.executeList(sess, nil, "list") + if strings.Contains(stripANSI(string(conn.data)), "RTP") { + t.Fatal("zero-quantity item activated") + } +} diff --git a/internal/game/casino_house_edge.go b/internal/game/casino_house_edge.go new file mode 100644 index 0000000..8bc3a5b --- /dev/null +++ b/internal/game/casino_house_edge.go @@ -0,0 +1,190 @@ +package game + +import ( + "fmt" + "math" + "strings" + "unicode/utf8" + + "thehouseoficarus/internal/casino" + "thehouseoficarus/internal/net" + "thehouseoficarus/internal/ui" +) + +// Only carried, positive-quantity items count. The most precise instrument wins. +func (g *Game) casinoEdgePrecision(sess *net.Session) (int, bool) { + if sess == nil || sess.Player == nil || g.ItemStore == nil { + return 0, false + } + precision, found := 0, false + for _, slot := range sess.Player.Inventory { + if slot == nil || slot.Quantity <= 0 { + continue + } + def, err := g.ItemStore.Load(slot.ItemID) + if err != nil || def.HouseEdgePrecision == nil { + continue + } + p := *def.HouseEdgePrecision + if p != 0 && p != 2 { + continue + } + precision = max(precision, p) + found = true + } + return precision, found +} + +// Convert the unrounded loss, not the displayed/rounded house edge. +func casinoRTP(e casino.HouseEdge, precision int) string { + if len(e.Parts) != 1 { + return "—" + } + value := math.Round((1-e.Parts[0].Loss)*100*math.Pow10(precision)) / math.Pow10(precision) + if value == 0 { + value = 0 + } // no negative zero + return fmt.Sprintf("%.*f%%", precision, value) +} + +type casinoListRow struct { + bet, odds, win string + edge casino.HouseEdge +} + +// Only remove redundant commission prose. Exceptions such as Banker 6 paying +// half or three-card 7 pushing are rules, not redundant explanations. +func conciseCasinoOdds(odds string) string { + if at := strings.Index(odds, " ("); at >= 0 && strings.HasSuffix(odds, "% commission)") { + return odds[:at] + } + return odds +} + +func (g *Game) casinoListRows(sess *net.Session, t *casino.Table, wagers []casino.WagerRow) []casinoListRow { + _, enabled := g.casinoEdgePrecision(sess) + var rows []casinoListRow + for _, wager := range wagers { + row := casinoListRow{bet: wager.Bet, odds: conciseCasinoOdds(wager.Payout), win: wager.Win} + if enabled { + row.edge = t.HouseEdge(sess.Player.Name, wager.Bet) + } + if len(row.edge.Parts) <= 1 { + rows = append(rows, row) + continue + } + // Different target returns need distinct rows, not a list of unlabeled RTPs. + for _, part := range row.edge.Parts { + entry := row + if strings.Contains(wager.Bet, "<n>") { + entry.bet = strings.ReplaceAll(wager.Bet, "<n>", part.Label) + } else { + entry.win = part.Label + "; " + entry.win + } + entry.edge = casino.HouseEdge{Parts: []casino.EdgePart{part}} + rows = append(rows, entry) + } + } + return rows +} + +// Explicit list-only presentation. Wrap plain cells before applying color and +// handing them to the existing ANSI-aware table renderer; never truncate rules. +// The table stands alone: list names no heading and no balance above it. +func (g *Game) showCasinoListTable(sess *net.Session, hint string, rows []casinoListRow) { + precision, hasItem := g.casinoEdgePrecision(sess) + // The item adds a column only when at least one listed wager has a real + // analysis; decision actions such as hit/stand have none. + rtp := false + if hasItem { + for _, r := range rows { + if len(r.edge.Parts) > 0 { + rtp = true + break + } + } + } + headers := []string{"Bet", "Odds", "Win / action"} + categories := []string{"command", "casino_payout", ""} + if rtp { + headers = append(headers, "RTP") + categories = append(categories, "casino_emphasis") + } + cells := make([][]string, 0, len(rows)) + widths := make([]int, len(headers)) + for i, h := range headers { + widths[i] = utf8.RuneCountInString(h) + } + for _, r := range rows { + odds := r.odds + if odds == "" { + odds = "—" + } + row := []string{r.bet, odds, r.win} + if rtp { + row = append(row, casinoRTP(r.edge, precision)) + } + for i, c := range row { + widths[i] = max(widths[i], utf8.RuneCountInString(c)) + } + cells = append(cells, row) + } + width, unicode := 80, true + if p := sess.Player; p != nil { + unicode = p.OptionBool("unicode") + if wrap := p.OptionInt("wrap_width"); wrap > 0 { + width = min(width, wrap) + } + } + budget := max(len(headers), width-3*len(headers)-1) + for { + sum, widest := 0, 0 + for i, w := range widths { + sum += w + if w > widths[widest] { + widest = i + } + } + if sum <= budget || widths[widest] <= 1 { + break + } + widths[widest]-- + } + table := ui.Table{} + // Headers wrap too, so narrow terminals never lose a column label. + all := append([][]string{headers}, cells...) + for rowIndex, row := range all { + wrapped := make([][]string, len(row)) + height := 1 + for i, c := range row { + wrapped[i] = casinoWrapWords(c, widths[i]) + height = max(height, len(wrapped[i])) + } + for line := 0; line < height; line++ { + physical := make([]string, len(row)) + for i, parts := range wrapped { + if line >= len(parts) { + continue + } + category := categories[i] + if rowIndex == 0 { + category = "casino_action" + } + physical[i] = parts[line] + if category != "" { + physical[i] = g.colorize(sess, category, physical[i]) + } + } + if rowIndex == 0 && line == 0 { + table.Columns = physical + } else { + table.Rows = append(table.Rows, physical) + } + } + } + out := table.Render(unicode, width) + if hint != "" { + out = append(out, g.colorize(sess, "command", hint)) + } + sess.WriteLine(strings.Join(out, "\n")) +} diff --git a/internal/game/casino_rules_list_test.go b/internal/game/casino_rules_list_test.go index 3d91ecf..e83c277 100644 --- a/internal/game/casino_rules_list_test.go +++ b/internal/game/casino_rules_list_test.go @@ -85,6 +85,28 @@ func TestRulesOutsideCasinoFallsBackToGuide(t *testing.T) { } // TestListFollowsGameState covers the list contract end to end: come-out +// listTargets returns the bet names rendered in the first table column, +// working for both the unicode and ASCII table borders. +func listTargets(text string) map[string]bool { + targets := map[string]bool{} + for _, line := range strings.Split(text, "\n") { + line = strings.TrimSpace(line) + if !strings.HasPrefix(line, "║") && !strings.HasPrefix(line, "|") { + continue + } + line = strings.TrimPrefix(strings.TrimPrefix(line, "║"), "|") + for _, sep := range []string{"│", "|"} { + if at := strings.Index(line, sep); at >= 0 { + line = line[:at] + } + } + if cell := strings.TrimSpace(line); cell != "" { + targets[cell] = true + } + } + return targets +} + // lists the line and one-roll bets, a point adds place/odds rows, bonus // bets close after the first roll, and single-bet editions print one line. func TestListFollowsGameState(t *testing.T) { @@ -95,13 +117,14 @@ func TestListFollowsGameState(t *testing.T) { conn.data = nil g.executeList(sess, nil, "list") text := stripANSI(string(conn.data)) - for _, want := range []string{"bet <amount> on pass", "bet <amount> on dontpass", "bet <amount> on field", "bet <amount> on craps", "bet <amount> on fire"} { - if !strings.Contains(text, want) { + targets := listTargets(text) + for _, want := range []string{"pass", "dontpass", "field", "craps", "fire"} { + if !targets[want] { t.Fatalf("come-out list missing %q: %q", want, text) } } for _, gone := range []string{"place 6", "odds pass"} { - if strings.Contains(text, gone) { + if targets[gone] { t.Fatalf("come-out list advertised %q: %q", gone, text) } } @@ -111,37 +134,39 @@ func TestListFollowsGameState(t *testing.T) { conn.data = nil g.executeList(sess, nil, "list") text = stripANSI(string(conn.data)) - if !strings.Contains(text, "place 6") || !strings.Contains(text, "odds pass") { + targets = listTargets(text) + if !targets["place 6"] || !targets["odds pass"] { t.Fatalf("point list missing place/odds: %q", text) } - if strings.Contains(text, "bet <amount> on pass\n") || strings.Contains(text, "fire") { + if targets["fire"] { t.Fatalf("point list still advertising closed bets: %q", text) } } -// TestListSingleBetGamesStayBrief: editions with one wager (Simplified) and -// one-wager games (blackjack) answer in one line, no table. -func TestListSingleBetGamesStayBrief(t *testing.T) { +// TestListSingleBetGamesRenderOneRow: editions with one wager (Simplified) +// and one-wager games (blackjack) answer with a one-row table. +func TestListSingleBetGamesRenderOneRow(t *testing.T) { room := "name: Simple\ncasino_tables:\n - id: simple\n game: craps\n craps:\n variant: simplified\n" g, sess, conn := casinoCrapsGame(t, room) g.executePlay(sess, []string{"craps"}, "play craps") conn.data = nil g.executeList(sess, nil, "list") text := stripANSI(string(conn.data)) - if strings.Contains(text, "Bet") && strings.Contains(text, "Pays") && strings.Contains(text, "Win if") { - t.Fatalf("single-bet game rendered a table: %q", text) + if !strings.Contains(text, "Odds") { + t.Fatalf("single-bet list did not render the table header: %q", text) } - if !strings.Contains(text, "bet <amount> on pass") { - t.Fatalf("single-bet line missing the wager: %q", text) + if targets := listTargets(text); !targets["pass"] { + t.Fatalf("single-bet table missing the wager: %q", text) } - // Blackjack: one wager, no table, and the list command still answers. + // Blackjack: one wager, one row, and the list command still answers. room = "name: BJ\ncasino_tables:\n - id: bj\n game: blackjack\n" g, sess, conn = casinoCrapsGame(t, room) g.executePlay(sess, []string{"bj"}, "play bj") conn.data = nil g.executeList(sess, nil, "list") - if text := stripANSI(string(conn.data)); !strings.Contains(text, "only wager") { + text = stripANSI(string(conn.data)) + if targets := listTargets(text); !targets["bet <amount>"] { t.Fatalf("blackjack list: %q", text) } } @@ -225,8 +250,9 @@ func TestListRouletteAndBaccarat(t *testing.T) { conn.data = nil g.executeList(sess, nil, "list") text := stripANSI(string(conn.data)) - for _, want := range []string{"bet <amount> on <number>", "bet <amount> on red / black", "bet <amount> on voisins", "bet <amount> on basket"} { - if !strings.Contains(text, want) { + targets := listTargets(text) + for _, want := range []string{"<number>", "red / black", "voisins", "basket"} { + if !targets[want] { t.Fatalf("roulette list missing %q: %q", want, text) } } @@ -237,9 +263,31 @@ func TestListRouletteAndBaccarat(t *testing.T) { conn.data = nil g.executeList(sess, nil, "list") text = stripANSI(string(conn.data)) - for _, want := range []string{"bet <amount> on banker (b)", "1:1 (3-card 7 pushes)", "bet <amount> on dragon_7", "bet <amount> on panda_8"} { - if !strings.Contains(text, want) { + targets = listTargets(text) + for _, want := range []string{"banker", "dragon_7", "panda_8"} { + if !targets[want] { t.Fatalf("baccarat list missing %q: %q", want, text) } } + if !strings.Contains(text, "1:1 (3-card 7 pushes)") { + t.Fatalf("baccarat list dropped the EZ banker rule: %q", text) + } +} + +// The commission is implied by the 0.95:1 ratio and must not be repeated. +func TestListBaccaratDropsCommissionProse(t *testing.T) { + g, sess, conn := casinoCrapsGame(t, "name: B\ncasino_tables:\n - id: b\n game: baccarat\n") + g.executePlay(sess, []string{"b"}, "play b") + conn.data = nil + g.executeList(sess, nil, "list") + text := stripANSI(string(conn.data)) + if strings.Contains(text, "commission") { + t.Fatalf("list repeated the implied commission: %q", text) + } + if targets := listTargets(text); !targets["banker"] { + t.Fatalf("baccarat list lost the banker row: %q", text) + } + if !strings.Contains(text, "0.95:1") { + t.Fatalf("baccarat list lost the banker ratio: %q", text) + } } diff --git a/internal/game/casino_ux.go b/internal/game/casino_ux.go index 6d666f7..28fc361 100644 --- a/internal/game/casino_ux.go +++ b/internal/game/casino_ux.go @@ -365,7 +365,11 @@ func (g *Game) executeList(sess *net.Session, args []string, rawInput string) { return } if machine, ok := g.Casino.MachineFor(p.Name); ok { - sess.WriteLine(g.colorize(sess, "casino_action", "A "+casinoGameLabel(machine.Config.Game)+" takes one wager: bet <amount> (or bet max), then spin or autospin.")) + row := casinoListRow{bet: "bet <amount> / max", odds: "paytable", win: "spin / autospin"} + if _, enabled := g.casinoEdgePrecision(sess); enabled { + row.edge = machine.Config.HouseEdge() + } + g.showCasinoListTable(sess, "", []casinoListRow{row}) return } if table, playing := g.Casino.Participation(p.Name); playing && table != nil { @@ -375,9 +379,8 @@ func (g *Game) executeList(sess *net.Session, args []string, rawInput string) { g.executeShopList(sess, args, rawInput) } -// showCasinoWagerList renders the game's live wager list. Two or more rows -// become a brief table; a single row is one line; an empty list means the -// only bet is the ordinary amount-only wager. +// showCasinoWagerList renders the live bets/actions as a compact table. +// An empty wager catalogue can still represent an ordinary amount-only bet. func (g *Game) showCasinoWagerList(sess *net.Session, t *casino.Table) { if t.Config.Game == casino.GameVideoPoker { for _, h := range t.Hints(sess.Player.Name) { @@ -386,24 +389,18 @@ func (g *Game) showCasinoWagerList(sess *net.Session, t *casino.Table) { return } } - sess.WriteLine("This cabinet has one wager: load coins with bet [1-4|max], then deal. Use paytable for payouts.") + rows := g.casinoListRows(sess, t, []casino.WagerRow{{Bet: "main", Payout: "paytable", Win: "deal"}}) + rows[0].bet = "bet [1-4|max]" + g.showCasinoListTable(sess, "", rows) return } rows := t.Wagers(sess.Player.Name) // Blackjack rows are actions, not targets for a new bet. if t.Config.Game == casino.GameBlackjack && len(rows) > 0 { - commands := make([]casino.MenuCommand, 0, len(rows)) - for _, r := range rows { - commands = append(commands, casino.MenuCommand{Command: r.Bet, Desc: strings.Trim(r.Payout+" | "+r.Win, " |")}) - } - sess.WriteLine(g.renderCasinoCommands(sess, g.casinoBalance(sess), "Available actions", commands)) + g.showCasinoListTable(sess, "", g.casinoListRows(sess, t, rows)) return } - switch { - case len(rows) == 1: - r := rows[0] - sess.WriteLine(g.colorize(sess, "casino_action", "Your only wager: bet <amount> on "+r.Bet+" — "+r.Payout+" — "+r.Win+".")) - case len(rows) == 0: + if len(rows) == 0 { canBet := false for _, h := range t.Hints(sess.Player.Name) { if strings.HasPrefix(h.Command, "bet ") { @@ -414,14 +411,16 @@ func (g *Game) showCasinoWagerList(sess *net.Session, t *casino.Table) { sess.WriteLine(g.colorize(sess, "casino_action", "No new wagers are available right now.")) return } - sess.WriteLine(g.colorize(sess, "casino_action", "The only wager here is bet <amount>") + " (" + betRangeWords(t.Config.MinBet, t.Config.MaxBet) + ").") - default: - commands := make([]casino.MenuCommand, 0, len(rows)) - for _, r := range rows { - commands = append(commands, casino.MenuCommand{Command: "bet <amount> on " + r.Bet, Desc: r.Payout + " | " + r.Win}) + wager := casino.WagerRow{Bet: "main", Win: betRangeWords(t.Config.MinBet, t.Config.MaxBet)} + if t.Config.Game == casino.GameBlackjack { + wager.Payout = fmt.Sprintf("1:1; BJ %g:1", t.Config.Blackjack.Normalize().BlackjackPayout) } - sess.WriteLine(g.renderCasinoCommands(sess, g.casinoBalance(sess), t.Config.Label()+" — available bets", commands)) + list := g.casinoListRows(sess, t, []casino.WagerRow{wager}) + list[0].bet = "bet <amount>" + g.showCasinoListTable(sess, "", list) + return } + g.showCasinoListTable(sess, "bet <amount> on <bet>", g.casinoListRows(sess, t, rows)) } // showCasinoGameLook appends the live game state and hint menu for the diff --git a/internal/game/house_edge_test.go b/internal/game/house_edge_test.go new file mode 100644 index 0000000..82aa966 --- /dev/null +++ b/internal/game/house_edge_test.go @@ -0,0 +1,214 @@ +package game + +import ( + "os" + "path/filepath" + "regexp" + "strconv" + "strings" + "testing" + + "thehouseoficarus/internal/casino" + "thehouseoficarus/internal/combat" + "thehouseoficarus/internal/item" + "thehouseoficarus/internal/net" + "thehouseoficarus/internal/object" + "thehouseoficarus/internal/player" + "thehouseoficarus/internal/world" +) + +// houseEdgeGame runs a Game over a copy of the shipped data directory (so +// the real item, room and help definitions load) plus one synthetic room 1. +func houseEdgeGame(t *testing.T, roomYAML string) (*Game, *net.Session, *casinoTestConn) { + t.Helper() + dir := t.TempDir() + for _, name := range []string{"rooms", "objects", "help", "items", "mobs", "recipes"} { + source := filepath.Join("../../data", name) + entries, err := os.ReadDir(source) + if err != nil { + continue // data subdirectory not shipped in this repository state + } else if err := os.MkdirAll(filepath.Join(dir, name), 0o755); err != nil { + t.Fatal(err) + } + for _, entry := range entries { + if entry.IsDir() { + continue + } + data, err := os.ReadFile(filepath.Join(source, entry.Name())) + if err != nil { + t.Fatal(err) + } + if err := os.WriteFile(filepath.Join(dir, name, entry.Name()), data, 0644); err != nil { + t.Fatal(err) + } + } + } + return houseEdgeGameIn(t, dir, roomYAML) +} + +func houseEdgeGameIn(t *testing.T, dir, roomYAML string) (*Game, *net.Session, *casinoTestConn) { + t.Helper() + if err := os.MkdirAll(filepath.Join(dir, "rooms"), 0o755); err != nil { + t.Fatal(err) + } + if err := os.WriteFile(filepath.Join(dir, "rooms", "1.yaml"), []byte(roomYAML), 0644); err != nil { + t.Fatal(err) + } + if err := os.MkdirAll(filepath.Join(dir, "players", "characters"), 0o755); err != nil { + t.Fatal(err) + } + p := player.New("alice") + sess := &net.Session{Player: p, Conn: &casinoTestConn{}} + g := &Game{ + Deps: Deps{ + World: world.New(dir), ObjectStore: object.NewObjectStore(dir), + MobStore: world.NewMobStore(dir), AccountStore: player.NewAccountStore(dir), + DataDir: dir, ItemStore: item.NewItemStore(dir), + }, + Casino: casino.NewManager(1), + Combat: combat.NewTracker(), + safespot: NewSafespotManager(), + restTimers: make(map[string]uint64), + loggedInChars: map[string]*net.Session{"alice": sess}, + } + p.Credits = 100 + p.RoomID = 1 + return g, sess, sess.Conn.(*casinoTestConn) +} + +// writeHouseEdgeManual writes the named reference item into the copied data +// directory, reloads the store and places one in the player's inventory. +func writeHouseEdgeManual(t *testing.T, g *Game, sess *net.Session, precision int) { + t.Helper() + if err := os.MkdirAll(filepath.Join(g.Deps.DataDir, "items"), 0o755); err != nil { + t.Fatal(err) + } + yaml := []byte("name: edge reference\nhouse_edge_precision: " + strconv.Itoa(precision) + "\nvalue: 0\n") + if err := os.WriteFile(filepath.Join(g.Deps.DataDir, "items", "edge_reference.yaml"), yaml, 0644); err != nil { + t.Fatal(err) + } + g.ItemStore.Reload(g.Deps.DataDir) + sess.Player.Inventory = map[int]*player.InventorySlot{0: {ItemID: "edge_reference", Quantity: 1}} +} + +var rtpCellRE = regexp.MustCompile(`^-?[0-9]+(\.[0-9]+)?%$`) + +// The RTP column carries only percentages: no notes, labels or explanations. +func assertRTPColumn(t *testing.T, text string) { + t.Helper() + if !strings.Contains(text, "RTP") { + t.Fatalf("no RTP column:\n%s", text) + } + for _, line := range strings.Split(text, "\n") { + if !strings.Contains(line, "│") { + continue + } + fields := strings.Split(line, "│") + cell := strings.TrimSpace(fields[len(fields)-1]) + cell = strings.TrimSpace(strings.Trim(cell, "║")) + if cell == "" || cell == "RTP" || cell == "—" { + continue + } + if !rtpCellRE.MatchString(cell) { + t.Fatalf("RTP cell is not a bare percentage: %q in %q", cell, line) + } + } +} + +const roomRoulette = "name: RT\ncasino_tables:\n - id: rt\n game: roulette\n" +const roomCraps = "name: CR\ncasino_tables:\n - id: cr\n game: craps\n" +const roomSlots = "name: MB\ncasino_machines:\n - id: m1\n game: slots\n" + +// Merely joining must never display the item's readout. +func TestHouseEdgeJoinSilentTable(t *testing.T) { + g, sess, conn := houseEdgeGame(t, roomRoulette) + writeHouseEdgeManual(t, g, sess, 0) + g.executePlay(sess, []string{"roulette"}, "play roulette") + text := stripANSI(string(conn.data)) + if strings.Contains(text, "RTP") { + t.Fatalf("join displayed an edge:\n%s", text) + } + conn.data = nil + g.executeList(sess, nil, "list") + text = stripANSI(string(conn.data)) + if strings.Count(text, "97%") != 12 { + t.Fatalf("list missing the twelve roulette RTPs:\n%s", text) + } + assertRTPColumn(t, text) +} + +// TestHouseEdgeListAnnotatesEveryRow: the list command carries the same +// figures on each row while the state-based list is up. +func TestHouseEdgeListAnnotatesEveryRow(t *testing.T) { + g, sess, conn := houseEdgeGame(t, roomCraps) + writeHouseEdgeManual(t, g, sess, 0) + g.executePlay(sess, []string{"craps"}, "play craps") + g.executeBet(sess, []string{"10", "pass"}, "bet 10 pass") + conn.data = nil + g.executeList(sess, nil, "list") + text := stripANSI(string(conn.data)) + if strings.Count(text, "│") < 8 { + t.Fatalf("list did not annotate the wagers:\n%s", text) + } + assertRTPColumn(t, text) +} + +// Paytable is not list and must not carry the item's readout. +func TestHouseEdgePaytableSilentVideoPoker(t *testing.T) { + g, sess, conn := houseEdgeGame(t, "name: VP\ncasino_tables:\n - id: vp\n game: video_poker\n") + writeHouseEdgeManual(t, g, sess, 2) + g.executePlay(sess, []string{"vp"}, "play vp") + conn.data = nil + g.executeTableAction(sess, "paytable") + if text := stripANSI(string(conn.data)); strings.Contains(text, "RTP") { + t.Fatalf("paytable displayed the edge:\n%s", text) + } + conn.data = nil + g.executeList(sess, nil, "list") + text := stripANSI(string(conn.data)) + if !strings.Contains(text, "99.54%") { + t.Fatalf("video poker list missing RTP: %s", text) + } + assertRTPColumn(t, text) +} + +// Slots are silent on join and show two-decimal precision on list. +func TestHouseEdgeMachineJoinSilentListPrecision(t *testing.T) { + g, sess, conn := houseEdgeGame(t, roomSlots) + writeHouseEdgeManual(t, g, sess, 2) + g.executePlay(sess, []string{"slots"}, "play slots") + text := stripANSI(string(conn.data)) + if strings.Contains(text, "RTP") { + t.Fatalf("machine join displayed edge: %s", text) + } + conn.data = nil + g.executeList(sess, nil, "list") + text = stripANSI(string(conn.data)) + if !strings.Contains(text, "97.00%") { + t.Fatalf("machine list missing precision: %s", text) + } + assertRTPColumn(t, text) +} + +// TestHouseEdgeAbsentSilentWithoutItem pins the privacy contract: no item, +// no figures, not even on the same screens. +func TestHouseEdgeAbsentSilentWithoutItem(t *testing.T) { + g, sess, conn := houseEdgeGame(t, roomRoulette) + g.executePlay(sess, []string{"roulette"}, "play roulette") + g.executeList(sess, nil, "list") + if text := stripANSI(string(conn.data)); strings.Contains(text, "RTP") { + t.Fatalf("edge shown without any item:\n%s", text) + } +} + +// TestHouseEdgeMachineList: the machine's one-line list also carries it. +func TestHouseEdgeMachineList(t *testing.T) { + g, sess, conn := houseEdgeGame(t, roomSlots) + writeHouseEdgeManual(t, g, sess, 0) + g.executePlay(sess, []string{"m1"}, "play m1") + conn.data = nil + g.executeList(sess, nil, "list") + if text := stripANSI(string(conn.data)); !strings.Contains(text, "RTP") { + t.Fatalf("machine list missing the edge:\n%s", text) + } +} diff --git a/internal/game/render_baccarat_felt.go b/internal/game/render_baccarat_felt.go index 84f91e3..4757764 100644 --- a/internal/game/render_baccarat_felt.go +++ b/internal/game/render_baccarat_felt.go @@ -67,7 +67,7 @@ func renderBaccaratRulesFelt(cfg casino.TableConfig, mode string, unicode bool) "PLAYER: DRAWS 0-5; STANDS 6-7. BANKER VS A STANDING PLAYER: DRAWS 0-5.", "BANKER VS A DRAWING PLAYER: 0-2 ALWAYS DRAWS; 3 DRAWS UNLESS VS 8;", "4 DRAWS VS 2-7; 5 DRAWS VS 4-7; 6 DRAWS VS 6-7; 7 STANDS.", - "ONE WAGER PER PLAYER PER ROUND; SIDE BETS SETTLE INDEPENDENTLY.", + "ONE MAIN BET (PLAYER/BANKER/TIE) PLUS SIDE BETS; SIDE BETS FIRST.", } for i, line := range draw { c.text(3, 17+i, line, crapsInk) diff --git a/internal/game/render_baccarat_felt_test.go b/internal/game/render_baccarat_felt_test.go index dabaa36..a3bb01c 100644 --- a/internal/game/render_baccarat_felt_test.go +++ b/internal/game/render_baccarat_felt_test.go @@ -30,7 +30,7 @@ func TestBaccaratRulesFeltGeometryAndPhrases(t *testing.T) { "DRAGON 7", "PANDA 8", "SUPER 6", "NOT OFFERED", "DECKS", "SHUFFLE AT", "BET LIMITS", "1-100 CREDITS", "35 TICKS", "DRAWING — AUTOMATIC PUNTO BANCO", "DRAWS 0-5", "6 DRAWS VS 6-7", - "ONE WAGER PER PLAYER PER ROUND", + "ONE MAIN BET (PLAYER/BANKER/TIE) PLUS SIDE BETS", } { if !strings.Contains(art, want) { t.Fatalf("missing %q in unicode=%v felt", want, unicode) diff --git a/internal/game/video_poker_test.go b/internal/game/video_poker_test.go index f2ea43f..8ec44d7 100644 --- a/internal/game/video_poker_test.go +++ b/internal/game/video_poker_test.go @@ -73,7 +73,7 @@ func TestBlackjackListUsesRealActionCommands(t *testing.T) { conn.data = nil g.executeList(sess, nil, "list") text := stripANSI(string(conn.data)) - if strings.Contains(text, "bet <amount> on") || !strings.Contains(text, "Available actions") { + if strings.Contains(text, "bet <amount> on") || len(listTargets(text)) == 0 { t.Fatal(text) } } diff --git a/internal/item/house_edge_test.go b/internal/item/house_edge_test.go new file mode 100644 index 0000000..574a68f --- /dev/null +++ b/internal/item/house_edge_test.go @@ -0,0 +1,29 @@ +package item + +import "testing" + +// TestHouseEdgeItemDefinitions pins the two house-edge reference items: the +// tile shows whole percent, the computus shows hundredths. Neither stacks +// (the precision is a capability, not a quantity) and both are valuable +// enough that a player will bank them rather than drop them. +func TestHouseEdgeItemDefinitions(t *testing.T) { + store := NewItemStore("../../data") + for _, tc := range []struct { + id string + precision int + }{ + {"house_edge_tile", 0}, + {"house_edge_computus", 2}, + } { + def, err := store.Load(tc.id) + if err != nil { + t.Fatalf("load %s: %v", tc.id, err) + } + if def.HouseEdgePrecision == nil || *def.HouseEdgePrecision != tc.precision { + t.Fatalf("%s: house_edge_precision = %v, want %d", tc.id, def.HouseEdgePrecision, tc.precision) + } + if def.Stackable { + t.Fatalf("%s must not stack (its precision is a capability, not a quantity)", tc.id) + } + } +} diff --git a/internal/item/item.go b/internal/item/item.go index 809959e..c083d8e 100644 --- a/internal/item/item.go +++ b/internal/item/item.go @@ -91,6 +91,10 @@ type ItemDef struct { Tool *ToolDef `yaml:"tool,omitempty"` Requirements map[string]int `yaml:"requirements,omitempty"` + // Optional inventory-only casino reference capability. Supported precision: + // 0 (whole percent) or 2 (hundredths of a percent); nil grants nothing. + HouseEdgePrecision *int `yaml:"house_edge_precision,omitempty"` + MaxQuality int `yaml:"max_quality"` Craft CraftList `yaml:"craft,omitempty"` |