feat: multiplayer baccarat game

1 files changed, 25 insertions, 25 deletions

diff --git a/internal/casino/blackjack_test.go b/internal/casino/blackjack_test.go
index e8381fb..f1bef99 100644
--- a/internal/casino/blackjack_test.go
+++ b/internal/casino/blackjack_test.go
@@ -7,12 +7,12 @@ import (
 )
 
 func TestBlackjackHandTreatsAceAsElevenWhenPossible(t *testing.T) {
-	hand := &blackjackHand{cards: []blackjackCard{{rank: "A"}, {rank: "6"}}}
+	hand := &blackjackHand{cards: []card{{rank: "A"}, {rank: "6"}}}
 	total, soft := hand.total()
 	if total != 17 || !soft {
 		t.Fatalf("total=%d soft=%v, want soft 17", total, soft)
 	}
-	hand.cards = append(hand.cards, blackjackCard{rank: "K"})
+	hand.cards = append(hand.cards, card{rank: "K"})
 	total, soft = hand.total()
 	if total != 17 || soft {
 		t.Fatalf("total=%d soft=%v, want hard 17", total, soft)
@@ -21,18 +21,18 @@ func TestBlackjackHandTreatsAceAsElevenWhenPossible(t *testing.T) {
 
 func TestBlackjackSettlementRules(t *testing.T) {
 	rules := (BlackjackConfig{}).Normalize()
-	natural := &blackjackHand{bet: 10, cards: []blackjackCard{{rank: "A"}, {rank: "K"}}}
+	natural := &blackjackHand{bet: 10, cards: []card{{rank: "A"}, {rank: "K"}}}
 	if result, payout := settleHand(natural, 20, false, rules); result != "blackjack" || payout != 25 {
 		t.Fatalf("natural result=%s payout=%d", result, payout)
 	}
-	dealerNatural := &blackjackHand{bet: 10, cards: []blackjackCard{{rank: "A"}, {rank: "Q"}}}
+	dealerNatural := &blackjackHand{bet: 10, cards: []card{{rank: "A"}, {rank: "Q"}}}
 	if result, payout := settleHand(dealerNatural, 21, true, rules); result != "push" || payout != 10 {
 		t.Fatalf("dealer natural result=%s payout=%d", result, payout)
 	}
-	if result, payout := settleHand(&blackjackHand{bet: 10, cards: []blackjackCard{{rank: "10"}, {rank: "8"}}}, 21, true, rules); result != "dealer blackjack" || payout != 0 {
+	if result, payout := settleHand(&blackjackHand{bet: 10, cards: []card{{rank: "10"}, {rank: "8"}}}, 21, true, rules); result != "dealer blackjack" || payout != 0 {
 		t.Fatalf("dealer blackjack result=%s payout=%d", result, payout)
 	}
-	if result, payout := settleHand(&blackjackHand{bet: 10, cards: []blackjackCard{{rank: "10"}, {rank: "8"}}}, 22, false, rules); result != "win" || payout != 20 {
+	if result, payout := settleHand(&blackjackHand{bet: 10, cards: []card{{rank: "10"}, {rank: "8"}}}, 22, false, rules); result != "win" || payout != 20 {
 		t.Fatalf("dealer bust result=%s payout=%d", result, payout)
 	}
 }
@@ -42,10 +42,10 @@ func TestBlackjackTableStartsAfterAllPlayersBet(t *testing.T) {
 	table.join("alice")
 	table.join("bob")
 	wa, wb := &testWallet{credits: 100}, &testWallet{credits: 100}
-	if events := table.bet("alice", 10, wa); hasMessage(events, "round begins") {
+	if events := table.bet("alice", "", 10, wa); hasMessage(events, "round begins") {
 		t.Fatal("round started before all players bet")
 	}
-	events := table.bet("bob", 10, wb)
+	events := table.bet("bob", "", 10, wb)
 	if !hasMessage(events, "New blackjack hand") {
 		t.Fatalf("round did not start after all players bet: %+v", events)
 	}
@@ -55,7 +55,7 @@ func TestSoloBlackjackTurnDoesNotTimeout(t *testing.T) {
 	table := newBlackjackTable(1, TableConfig{ID: "blackjack", Game: GameBlackjack, Blackjack: BlackjackConfig{ActionTicks: 1}}, newTestRand())
 	table.participants["alice"] = &blackjackPlayer{
 		Participant: Participant{Name: "alice", HasBet: true, Connected: true},
-		hands:       []*blackjackHand{{bet: 10, cards: []blackjackCard{{rank: "10"}, {rank: "6"}}}},
+		hands:       []*blackjackHand{{bet: 10, cards: []card{{rank: "10"}, {rank: "6"}}}},
 	}
 	table.order = []string{"alice"}
 	table.phase = blackjackPlaying
@@ -70,18 +70,18 @@ func TestSoloBlackjackTurnDoesNotTimeout(t *testing.T) {
 func TestBlackjackRebetKeepsLastWager(t *testing.T) {
 	table := newBlackjackTable(1, TableConfig{ID: "blackjack", Game: GameBlackjack, MinBet: 5, MaxBet: 100}, newTestRand())
 	table.participants["alice"] = &blackjackPlayer{Participant: Participant{Name: "alice"}, lastBet: 25}
-	if got := table.rebetAmount("alice"); got != 25 {
-		t.Fatalf("rebet=%d, want 25", got)
+	if spot, got := table.rebet("alice"); got != 25 || spot != "" {
+		t.Fatalf("rebet=(%q, %d), want (\"\", 25)", spot, got)
 	}
 }
 
 func TestBlackjackPromptNamesActiveHandAndOnlyOffersAvailableActions(t *testing.T) {
 	table := newBlackjackTable(1, TableConfig{ID: "blackjack", Game: GameBlackjack}, newTestRand())
-	table.participants["alice"] = &blackjackPlayer{Participant: Participant{Name: "alice", HasBet: true, Connected: true}, hands: []*blackjackHand{{bet: 10, cards: []blackjackCard{{rank: "K"}, {rank: "6"}}}}}
+	table.participants["alice"] = &blackjackPlayer{Participant: Participant{Name: "alice", HasBet: true, Connected: true}, hands: []*blackjackHand{{bet: 10, cards: []card{{rank: "K"}, {rank: "6"}}}}}
 	table.order = []string{"alice"}
 	table.activePlayer = 0
 	table.activeHand = 0
-	table.dealer.cards = []blackjackCard{{rank: "10"}, {rank: "7"}}
+	table.dealer.cards = []card{{rank: "10"}, {rank: "7"}}
 	event := table.prompt()[0]
 	if event.Message != "Your turn (K,6).\nActions: hit, stand, double" {
 		t.Fatalf("prompt=%q", event.Message)
@@ -105,10 +105,10 @@ func TestBlackjackInsurancePaysOnDealerBlackjack(t *testing.T) {
 	w := &testWallet{credits: 100}
 	table.participants["alice"] = &blackjackPlayer{
 		Participant: Participant{Name: "alice", HasBet: true, Connected: true, Wallet: w, Wager: Wager{Total: 10}},
-		hands:       []*blackjackHand{{bet: 10, cards: []blackjackCard{{rank: "10"}, {rank: "8"}}}},
+		hands:       []*blackjackHand{{bet: 10, cards: []card{{rank: "10"}, {rank: "8"}}}},
 	}
 	table.order = []string{"alice"}
-	table.dealer.cards = []blackjackCard{{rank: "K"}, {rank: "A"}}
+	table.dealer.cards = []card{{rank: "K"}, {rank: "A"}}
 	table.phase = blackjackInsurance
 	events := table.action("alice", "insurance")
 	if w.credits != 95 {
@@ -130,10 +130,10 @@ func TestBlackjackInsuranceDeclineContinuesRound(t *testing.T) {
 	w := &testWallet{credits: 100}
 	table.participants["alice"] = &blackjackPlayer{
 		Participant: Participant{Name: "alice", HasBet: true, Connected: true, Wallet: w, Wager: Wager{Total: 10}},
-		hands:       []*blackjackHand{{bet: 10, cards: []blackjackCard{{rank: "10"}, {rank: "8"}}}},
+		hands:       []*blackjackHand{{bet: 10, cards: []card{{rank: "10"}, {rank: "8"}}}},
 	}
 	table.order = []string{"alice"}
-	table.dealer.cards = []blackjackCard{{rank: "9"}, {rank: "A"}}
+	table.dealer.cards = []card{{rank: "9"}, {rank: "A"}}
 	table.phase = blackjackInsurance
 	events := table.action("alice", "stand")
 	if !hasMessage(events, "You decline insurance.") {
@@ -150,14 +150,14 @@ func TestBlackjackInsuranceDeclineContinuesRound(t *testing.T) {
 func TestBlackjackDoubleSetsBust(t *testing.T) {
 	table := newBlackjackTable(1, TableConfig{ID: "blackjack", Game: GameBlackjack}, newTestRand())
 	// decks 0 disables the shuffle threshold so the forced card is drawn.
-	table.shoe = &blackjackShoe{cards: []blackjackCard{{rank: "K"}}}
+	table.shoe = &shoe{cards: []card{{rank: "K"}}}
 	w := &testWallet{credits: 100}
 	table.participants["alice"] = &blackjackPlayer{
 		Participant: Participant{Name: "alice", HasBet: true, Connected: true, Wallet: w, Wager: Wager{Total: 10}},
-		hands:       []*blackjackHand{{bet: 10, cards: []blackjackCard{{rank: "10"}, {rank: "6"}}}},
+		hands:       []*blackjackHand{{bet: 10, cards: []card{{rank: "10"}, {rank: "6"}}}},
 	}
 	table.order = []string{"alice"}
-	table.dealer.cards = []blackjackCard{{rank: "10"}, {rank: "7"}}
+	table.dealer.cards = []card{{rank: "10"}, {rank: "7"}}
 	table.phase = blackjackPlaying
 	hand := table.participants["alice"].hands[0]
 	events := table.action("alice", "double")
@@ -175,10 +175,10 @@ func TestBlackjackSplitAcesOnlyAllowResplit(t *testing.T) {
 	w := &testWallet{credits: 100}
 	table.participants["alice"] = &blackjackPlayer{
 		Participant: Participant{Name: "alice", HasBet: true, Connected: true, Wallet: w, Wager: Wager{Total: 10}},
-		hands:       []*blackjackHand{{bet: 10, fromSplit: true, cards: []blackjackCard{{rank: "A"}, {rank: "A"}}}},
+		hands:       []*blackjackHand{{bet: 10, fromSplit: true, cards: []card{{rank: "A"}, {rank: "A"}}}},
 	}
 	table.order = []string{"alice"}
-	table.dealer.cards = []blackjackCard{{rank: "10"}, {rank: "7"}}
+	table.dealer.cards = []card{{rank: "10"}, {rank: "7"}}
 	table.phase = blackjackPlaying
 	p := table.participants["alice"]
 	actions := table.availableActions(p, p.hands[0])
@@ -196,7 +196,7 @@ func TestBlackjackBettingIgnoresDisconnected(t *testing.T) {
 	table.join("bob")
 	table.markDisconnected("bob")
 	w := &testWallet{credits: 100}
-	events := table.bet("alice", 10, w)
+	events := table.bet("alice", "", 10, w)
 	if !hasMessage(events, "New blackjack hand") {
 		t.Fatalf("disconnected player stalled the round: %+v", events)
 	}
@@ -206,10 +206,10 @@ func TestBlackjackReconnectShowsTableSnapshot(t *testing.T) {
 	table := newBlackjackTable(1, TableConfig{ID: "blackjack", Game: GameBlackjack}, newTestRand())
 	table.participants["alice"] = &blackjackPlayer{
 		Participant: Participant{Name: "alice", HasBet: true, Connected: true},
-		hands:       []*blackjackHand{{bet: 10, cards: []blackjackCard{{rank: "10"}, {rank: "8"}}}},
+		hands:       []*blackjackHand{{bet: 10, cards: []card{{rank: "10"}, {rank: "8"}}}},
 	}
 	table.order = []string{"alice"}
-	table.dealer.cards = []blackjackCard{{rank: "10"}, {rank: "7"}}
+	table.dealer.cards = []card{{rank: "10"}, {rank: "7"}}
 	table.phase = blackjackPlaying
 	events := table.join("alice")
 	if len(events) != 1 || events[0].Blackjack == nil {