feat: multiplayer baccarat game

1 files changed, 97 insertions, 50 deletions

diff --git a/internal/casino/table.go b/internal/casino/table.go
index e993cb8..be2ea18 100644
--- a/internal/casino/table.go
+++ b/internal/casino/table.go
@@ -6,6 +6,81 @@ import (
 	"sync"
 )
 
+// tableGame is a multiplayer table game implementation. Table routes every
+// player interaction through this interface so new games plug in without
+// changing the dispatch layer.
+type tableGame interface {
+	join(name string) []Event
+	leave(name string) []Event
+	bet(name, spot string, amount int, wallet Wallet) []Event
+	tick() []Event
+	action(name, action string) []Event
+	rebet(name string) (spot string, amount int)
+	markDisconnected(name string) []Event
+	markConnected(name string)
+	hasParticipant(name string) bool
+}
+
+// tableBase carries the identity every table game needs to build events.
+type tableBase struct {
+	RoomID int
+	Config TableConfig
+}
+
+func (b tableBase) event(message string, public bool) Event {
+	return Event{RoomID: b.RoomID, TableID: b.Config.ID, Type: EventResult, Message: message, Public: public, Color: "casino_action"}
+}
+
+func (b tableBase) private(name, message string) Event {
+	e := b.event(message, false)
+	e.PrivateTo = name
+	return e
+}
+
+func (b tableBase) playerAction(name, publicMessage, privateMessage string) Event {
+	e := b.event(publicMessage, true)
+	e.PrivateTo = name
+	e.PrivateMessage = privateMessage
+	return e
+}
+
+// Table is the manager-facing handle for a multiplayer table. It only holds
+// routing state; all game logic lives in the tableGame implementation.
+type Table struct {
+	RoomID int
+	Config TableConfig
+	game   tableGame
+}
+
+func newTable(roomID int, cfg TableConfig, rng *rand.Rand) *Table {
+	cfg = cfg.Normalize()
+	t := &Table{RoomID: roomID, Config: cfg}
+	switch cfg.Game {
+	case GameBlackjack:
+		t.game = newBlackjackTable(roomID, cfg, rng)
+	case GameBaccarat:
+		t.game = newBaccaratTable(roomID, cfg, rng)
+	default:
+		t.game = newGenericTable(roomID, cfg, rng)
+	}
+	return t
+}
+
+func (t *Table) join(name string) []Event  { return t.game.join(name) }
+func (t *Table) leave(name string) []Event { return t.game.leave(name) }
+
+func (t *Table) bet(name, spot string, amount int, wallet Wallet) []Event {
+	return t.game.bet(name, spot, amount, wallet)
+}
+
+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) }
+
+func (t *Table) markDisconnected(name string) []Event { return t.game.markDisconnected(name) }
+func (t *Table) markConnected(name string)            { t.game.markConnected(name) }
+func (t *Table) hasParticipant(name string) bool      { return t.game.hasParticipant(name) }
+
 type tablePhase string
 
 const (
@@ -13,7 +88,9 @@ const (
 	phaseBetting tablePhase = "betting"
 )
 
-type Table struct {
+// genericTable is the fallback table game: every bettor's wager resolves
+// immediately against a simple spin once all connected players have bet.
+type genericTable struct {
 	mu     sync.Mutex
 	RoomID int
 	Config TableConfig
@@ -23,24 +100,19 @@ type Table struct {
 	phase        tablePhase
 	timer        countdown
 	rng          *rand.Rand
-	blackjack    *blackjackTable
 }
 
-func newTable(roomID int, cfg TableConfig, rng *rand.Rand) *Table {
-	t := &Table{
+func newGenericTable(roomID int, cfg TableConfig, rng *rand.Rand) *genericTable {
+	return &genericTable{
 		RoomID:       roomID,
 		Config:       cfg,
 		phase:        phaseWaiting,
 		participants: make(map[string]*Participant),
 		rng:          rng,
 	}
-	if cfg.Game == GameBlackjack {
-		t.blackjack = newBlackjackTable(roomID, cfg, rng)
-	}
-	return t
 }
 
-func (t *Table) seats() []*Participant {
+func (t *genericTable) seats() []*Participant {
 	seats := make([]*Participant, 0, len(t.order))
 	for _, name := range t.order {
 		if p := t.participants[name]; p != nil {
@@ -50,10 +122,7 @@ func (t *Table) seats() []*Participant {
 	return seats
 }
 
-func (t *Table) join(name string) []Event {
-	if t.blackjack != nil {
-		return t.blackjack.join(name)
-	}
+func (t *genericTable) join(name string) []Event {
 	t.mu.Lock()
 	defer t.mu.Unlock()
 	if p := t.participants[name]; p != nil {
@@ -68,10 +137,7 @@ func (t *Table) join(name string) []Event {
 	return []Event{{RoomID: t.RoomID, TableID: t.Config.ID, Type: EventJoined, Player: name, Message: fmt.Sprintf("%s joins the %s table.", name, t.Config.ID), Public: true}}
 }
 
-func (t *Table) leave(name string) []Event {
-	if t.blackjack != nil {
-		return t.blackjack.leave(name)
-	}
+func (t *genericTable) leave(name string) []Event {
 	t.mu.Lock()
 	defer t.mu.Unlock()
 	p := t.participants[name]
@@ -95,16 +161,16 @@ func (t *Table) leave(name string) []Event {
 	return events
 }
 
-func (t *Table) bet(name string, amount int, wallet Wallet) []Event {
-	if t.blackjack != nil {
-		return t.blackjack.bet(name, amount, wallet)
-	}
+func (t *genericTable) bet(name, spot string, amount int, wallet Wallet) []Event {
 	t.mu.Lock()
 	defer t.mu.Unlock()
 	p := t.participants[name]
 	if p == nil {
 		return []Event{{RoomID: t.RoomID, TableID: t.Config.ID, Type: EventResult, Player: name, PrivateTo: name, Message: "You aren't playing at that table."}}
 	}
+	if spot != "" {
+		return []Event{{RoomID: t.RoomID, TableID: t.Config.ID, Type: EventResult, Player: name, PrivateTo: name, Message: "That table doesn't take a bet target."}}
+	}
 	if t.phase != phaseWaiting && t.phase != phaseBetting {
 		return []Event{{RoomID: t.RoomID, TableID: t.Config.ID, Type: EventResult, Player: name, PrivateTo: name, Message: "That table isn't accepting bets."}}
 	}
@@ -135,10 +201,7 @@ func (t *Table) bet(name string, amount int, wallet Wallet) []Event {
 	return events
 }
 
-func (t *Table) tick() []Event {
-	if t.blackjack != nil {
-		return t.blackjack.tick()
-	}
+func (t *genericTable) tick() []Event {
 	t.mu.Lock()
 	defer t.mu.Unlock()
 	if t.phase != phaseBetting {
@@ -163,7 +226,7 @@ func (t *Table) tick() []Event {
 	return events
 }
 
-func (t *Table) resolveRound() []Event {
+func (t *genericTable) resolveRound() []Event {
 	var events []Event
 	for _, name := range t.order {
 		p := t.participants[name]
@@ -184,16 +247,13 @@ func (t *Table) resolveRound() []Event {
 	return events
 }
 
-func (t *Table) resetRound() {
+func (t *genericTable) resetRound() {
 	t.phase = phaseWaiting
 	t.timer.stop()
 	clearBets(t.seats())
 }
 
-func (t *Table) markDisconnected(name string) []Event {
-	if t.blackjack != nil {
-		return t.blackjack.markDisconnected(name)
-	}
+func (t *genericTable) markDisconnected(name string) []Event {
 	t.mu.Lock()
 	defer t.mu.Unlock()
 	if p := t.participants[name]; p != nil {
@@ -202,11 +262,7 @@ func (t *Table) markDisconnected(name string) []Event {
 	return nil
 }
 
-func (t *Table) markConnected(name string) {
-	if t.blackjack != nil {
-		t.blackjack.markConnected(name)
-		return
-	}
+func (t *genericTable) markConnected(name string) {
 	t.mu.Lock()
 	defer t.mu.Unlock()
 	if p := t.participants[name]; p != nil {
@@ -214,25 +270,16 @@ func (t *Table) markConnected(name string) {
 	}
 }
 
-func (t *Table) hasParticipant(name string) bool {
-	if t.blackjack != nil {
-		return t.blackjack.hasParticipant(name)
-	}
+func (t *genericTable) hasParticipant(name string) bool {
 	t.mu.Lock()
 	defer t.mu.Unlock()
 	return t.participants[name] != nil
 }
 
-func (t *Table) action(name, action string) []Event {
-	if t.blackjack == nil {
-		return []Event{{RoomID: t.RoomID, TableID: t.Config.ID, Type: EventResult, PrivateTo: name, Message: "That game has no player actions."}}
-	}
-	return t.blackjack.action(name, action)
+func (t *genericTable) action(name, action string) []Event {
+	return []Event{{RoomID: t.RoomID, TableID: t.Config.ID, Type: EventResult, PrivateTo: name, Message: "That game has no player actions."}}
 }
 
-func (t *Table) rebetAmount(name string) int {
-	if t.blackjack != nil {
-		return t.blackjack.rebetAmount(name)
-	}
-	return t.Config.MinBet
+func (t *genericTable) rebet(name string) (string, int) {
+	return "", t.Config.MinBet
 }