927ed84163
Phase D backend: UNO is now a session like hold'em, not a single stake. You sit
with a buy-in stack, ante into a pot each hand, and leave with what's in front of
you. The engine lost its `You` constant and its measured multiples: ApplyMove
takes the acting seat, New takes a seat list, a Tier carries an ante instead of a
Base, and a hand settles by moving the pot to the winner (less rake, and never
when a bot takes it) rather than paying a multiple. A mercy kill puts a seat out
of the hand, not out of the game — the last one standing takes the pot.
The redaction moved to the web layer, where hold'em's already lives: the engine
now stamps every seat's hand onto its events, and viewUno/viewUnoEvents strip
everything that isn't the viewer's own. TestUnoViewNeverLeaksAnotherSeatsCards is
the wall. unoTable implements tableGame; /uno/{sit,move,leave,tables,stream,chat,
say} mirror hold'em, with stream/chat/say now shared game-agnostic handlers.
The frontend is not done: uno.js still calls the retired solo endpoint, so the
page renders but is not yet playable. All engine and web tests are green.
Claude-Session: https://claude.ai/code/session_013M5nD7PgUboJXoDcYHzpuJ
678 lines
21 KiB
Go
678 lines
21 KiB
Go
package web
|
|
|
|
import (
|
|
"encoding/json"
|
|
"errors"
|
|
"log/slog"
|
|
"net/http"
|
|
"time"
|
|
|
|
"pete/internal/games/blackjack"
|
|
"pete/internal/games/uno"
|
|
"pete/internal/storage"
|
|
)
|
|
|
|
// UNO, played for chips at a shared table.
|
|
//
|
|
// Like hold'em, this is a session: you sit down with a stack, ante into a pot each
|
|
// hand, and leave with what is in front of you. Chips cross the border twice —
|
|
// sit-down and get-up — and every ante and pot in between moves inside the state
|
|
// blob. Solo play is just a table nobody else has joined.
|
|
//
|
|
// The seam is the same as hold'em: one request plays a human's move plus every
|
|
// bot turn it hands off to, returned as a script the felt animates. What a viewer
|
|
// is allowed to see is their own hand, the card and colour in play, the pot, and
|
|
// how many cards each other seat holds — never the deck, another seat's hand, or
|
|
// the face of a card a bot drew. The engine emits every seat's hand (a shared
|
|
// stream cannot know who is watching); the redaction that keeps a hand private is
|
|
// here, and a missed case fans it to every subscriber.
|
|
|
|
// unoCardView is one card, ready to draw: colour and face as words, not the
|
|
// engine's integers.
|
|
type unoCardView struct {
|
|
Color string `json:"color"`
|
|
Value string `json:"value"`
|
|
Wild bool `json:"wild"`
|
|
}
|
|
|
|
func viewUnoCard(c uno.Card) unoCardView {
|
|
return unoCardView{Color: c.Color.String(), Value: c.Value.String(), Wild: c.IsWild()}
|
|
}
|
|
|
|
// unoSeatView is one seat at the table: a name, a card count, and a stack. A
|
|
// seat's cards are a *count* — there is no field here for what they are.
|
|
type unoSeatView struct {
|
|
Name string `json:"name"`
|
|
Bot bool `json:"bot"`
|
|
You bool `json:"you"`
|
|
Cards int `json:"cards"`
|
|
Stack int64 `json:"stack"`
|
|
Ante int64 `json:"ante,omitempty"`
|
|
Uno bool `json:"uno"` // down to one card
|
|
Called bool `json:"called"` // …and said so. Uno true and this false is a seat you can catch
|
|
Out bool `json:"out"` // not in this hand — mercy-killed, or sitting one out
|
|
}
|
|
|
|
// unoView is a table as one seat may see it.
|
|
type unoView struct {
|
|
Tier uno.Tier `json:"tier"`
|
|
YourSeat int `json:"your_seat"`
|
|
Seats []unoSeatView `json:"seats"`
|
|
|
|
Hand []unoCardView `json:"hand"` // yours, and only yours
|
|
Playable []int `json:"playable"` // which of them can legally go down
|
|
Top unoCardView `json:"top"` // the card in play
|
|
Color string `json:"color"` // the colour in play, which a wild renames
|
|
Deck int `json:"deck"` // cards left to draw
|
|
|
|
UnoAt []int `json:"uno_at"` // your cards that would leave you on one
|
|
Catchable []int `json:"catchable"` // seats sitting on one card they never called
|
|
|
|
Turn int `json:"turn"`
|
|
Dir int `json:"dir"`
|
|
Dealer int `json:"dealer"`
|
|
HandNo int `json:"hand_no"`
|
|
|
|
Pending int `json:"pending"` // No Mercy: the bill a stack has run up
|
|
|
|
Pot int64 `json:"pot"` // the antes riding on this hand
|
|
Ante int64 `json:"ante"` // what each seat puts in
|
|
Stack int64 `json:"stack"` // what's in front of you
|
|
BoughtIn int64 `json:"bought_in"` // your own buy-in, from the border ledger
|
|
Phase string `json:"phase"`
|
|
|
|
// The last hand's verdict, so the felt can land it between hands.
|
|
Winner int `json:"winner"`
|
|
LastPot int64 `json:"last_pot,omitempty"`
|
|
Rake int64 `json:"rake,omitempty"`
|
|
Outcome string `json:"outcome,omitempty"`
|
|
}
|
|
|
|
// viewUno renders the table as one seat may see it. viewer is which seat is
|
|
// looking — their hand is the only one it will ever put in the payload.
|
|
//
|
|
// This is the security boundary. The same view fans to every subscriber's stream,
|
|
// so a seat that renders anyone else's cards fans them to the whole table.
|
|
// TestUnoViewNeverLeaksAnotherSeatsCards renders every seat's view and greps for
|
|
// cards that are not theirs.
|
|
func viewUno(g uno.State, viewer int) unoView {
|
|
v := unoView{
|
|
Tier: g.Tier,
|
|
YourSeat: viewer,
|
|
Top: viewUnoCard(g.Top()),
|
|
Color: g.Color.String(),
|
|
Deck: g.Left(),
|
|
Turn: g.Turn,
|
|
Dir: g.Dir,
|
|
Dealer: g.Dealer,
|
|
HandNo: g.HandNo,
|
|
Pending: g.Pending,
|
|
Pot: g.Pot,
|
|
Ante: g.Tier.Ante,
|
|
BoughtIn: g.BoughtIn, // a table total; the caller overrides it with this seat's own stake
|
|
Phase: string(g.Phase),
|
|
Winner: g.Winner,
|
|
LastPot: g.LastPot,
|
|
Rake: g.Rake,
|
|
Outcome: string(g.Outcome),
|
|
}
|
|
if viewer >= 0 && viewer < len(g.Seats) {
|
|
v.Stack = g.Seats[viewer].Stack
|
|
}
|
|
counts := g.Counts()
|
|
for i := range g.Seats {
|
|
p := g.Seats[i]
|
|
live := g.Live(i)
|
|
seat := unoSeatView{
|
|
Name: p.Name,
|
|
Bot: p.Bot,
|
|
You: i == viewer,
|
|
Cards: counts[i],
|
|
Stack: p.Stack,
|
|
Ante: p.Ante,
|
|
Uno: live && counts[i] == 1,
|
|
Called: i < len(g.Called) && g.Called[i],
|
|
Out: !live,
|
|
}
|
|
v.Seats = append(v.Seats, seat)
|
|
}
|
|
|
|
// The wall. Only the viewer's own hand crosses the wire.
|
|
if viewer >= 0 && viewer < len(g.Hands) {
|
|
for _, c := range g.Hands[viewer] {
|
|
v.Hand = append(v.Hand, viewUnoCard(c))
|
|
}
|
|
}
|
|
if v.Hand == nil {
|
|
v.Hand = []unoCardView{}
|
|
}
|
|
// Empty arrays, never null: the felt indexes into these.
|
|
v.Playable = g.Playable(viewer)
|
|
if v.Playable == nil {
|
|
v.Playable = []int{}
|
|
}
|
|
v.UnoAt = g.UnoAt(viewer)
|
|
if v.UnoAt == nil {
|
|
v.UnoAt = []int{}
|
|
}
|
|
v.Catchable = g.Catchable(viewer)
|
|
if v.Catchable == nil {
|
|
v.Catchable = []int{}
|
|
}
|
|
return v
|
|
}
|
|
|
|
// unoEventView is one beat of the script the felt plays back. The engine attaches
|
|
// every seat's hand and drawn cards; this is the wall where the ones the viewer
|
|
// isn't entitled to are stripped.
|
|
type unoEventView struct {
|
|
Kind string `json:"kind"`
|
|
Seat int `json:"seat"`
|
|
Card *unoCardView `json:"card,omitempty"`
|
|
Color string `json:"color,omitempty"`
|
|
N int `json:"n,omitempty"`
|
|
Left int `json:"left"`
|
|
By int `json:"by"`
|
|
Text string `json:"text,omitempty"`
|
|
Hand []unoCardView `json:"hand,omitempty"`
|
|
}
|
|
|
|
func viewUnoEvents(evs []uno.Event, viewer int) []unoEventView {
|
|
out := make([]unoEventView, 0, len(evs))
|
|
for _, e := range evs {
|
|
v := unoEventView{Kind: e.Kind, Seat: e.Seat, N: e.N, Left: e.Left, By: e.By, Text: e.Text}
|
|
if e.Color != uno.Wild {
|
|
v.Color = e.Color.String()
|
|
}
|
|
// A hand rides an event only if it is the viewer's own. The engine stamps every
|
|
// seat's hand; this strips the rest.
|
|
if e.Seat == viewer && e.Hand != nil {
|
|
v.Hand = make([]unoCardView, 0, len(e.Hand))
|
|
for _, c := range e.Hand {
|
|
v.Hand = append(v.Hand, viewUnoCard(c))
|
|
}
|
|
}
|
|
// A card rides an event only if it is a card played face up, or one the viewer
|
|
// drew. A bot's (or another human's) drawn card never carries a face.
|
|
if e.Card != nil {
|
|
if e.Kind == uno.EvDraw || e.Kind == uno.EvForced {
|
|
if e.Seat == viewer {
|
|
c := viewUnoCard(*e.Card)
|
|
v.Card = &c
|
|
}
|
|
} else {
|
|
c := viewUnoCard(*e.Card)
|
|
v.Card = &c
|
|
}
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return out
|
|
}
|
|
|
|
// ---- sitting down ----------------------------------------------------------
|
|
|
|
// unoSeatRows mirrors the engine's seats into the storage rows that shadow them,
|
|
// index for index. A human's staked is the buy-in that crossed the border; a
|
|
// bot's is zero.
|
|
func unoSeatRows(g uno.State, human string, buyIn int64) []storage.Seat {
|
|
rows := make([]storage.Seat, len(g.Seats))
|
|
for i := range g.Seats {
|
|
p := g.Seats[i]
|
|
row := storage.Seat{Seat: i, Name: p.Name}
|
|
if !p.Bot {
|
|
row.MatrixUser = human
|
|
row.Staked = buyIn
|
|
}
|
|
rows[i] = row
|
|
}
|
|
return rows
|
|
}
|
|
|
|
// handleUnoSit seats a player at a fresh table of their own or at an open chair on
|
|
// somebody else's.
|
|
func (s *Server) handleUnoSit(w http.ResponseWriter, r *http.Request) {
|
|
user, ok := s.player(w, r)
|
|
if !ok {
|
|
return
|
|
}
|
|
var req struct {
|
|
Tier string `json:"tier"`
|
|
BuyIn int64 `json:"buyin"`
|
|
Table string `json:"table"`
|
|
Seat *int `json:"seat"`
|
|
}
|
|
if err := decodeJSON(r, &req); err != nil {
|
|
http.Error(w, "bad json", http.StatusBadRequest)
|
|
return
|
|
}
|
|
if req.Table != "" {
|
|
s.joinUno(w, r, user, req.Table, req.Seat, req.BuyIn)
|
|
return
|
|
}
|
|
s.openUno(w, r, user, req.Tier, req.BuyIn)
|
|
}
|
|
|
|
// openUno opens a fresh table with the player in seat zero and bots in the rest —
|
|
// the old solo flow, now a real shared table with no other humans on it yet.
|
|
func (s *Server) openUno(w http.ResponseWriter, r *http.Request, user, tierSlug string, buyIn int64) {
|
|
tier, err := uno.TierBySlug(tierSlug)
|
|
if err != nil {
|
|
writeJSONStatus(w, http.StatusBadRequest, map[string]string{"error": "pick a table"})
|
|
return
|
|
}
|
|
if buyIn < tier.MinBuy || buyIn > tier.MaxBuy {
|
|
writeJSONStatus(w, http.StatusBadRequest, map[string]string{"error": "that isn't a legal buy-in for this table"})
|
|
return
|
|
}
|
|
|
|
name := s.displayName(r, user)
|
|
seed1, seed2 := newSeeds()
|
|
g, _, err := uno.New(tier, uno.TableSeats(tier, name, tier.Bots, buyIn), blackjack.DefaultRules().RakePct, seed1, seed2)
|
|
if err != nil {
|
|
slog.Error("games: uno open", "user", user, "err", err)
|
|
http.Error(w, "internal error", http.StatusInternalServerError)
|
|
return
|
|
}
|
|
blob, err := json.Marshal(g)
|
|
if err != nil {
|
|
slog.Error("games: marshal new uno", "user", user, "err", err)
|
|
http.Error(w, "internal error", http.StatusInternalServerError)
|
|
return
|
|
}
|
|
id, err := storage.NewTableID()
|
|
if err != nil {
|
|
slog.Error("games: mint table id", "user", user, "err", err)
|
|
http.Error(w, "internal error", http.StatusInternalServerError)
|
|
return
|
|
}
|
|
|
|
t := storage.Table{
|
|
ID: id, Game: gameUno, Tier: tier.Slug, State: blob,
|
|
Seed1: seed1, Seed2: seed2, Phase: string(g.Phase), HandNo: int64(g.HandNo),
|
|
}
|
|
err = storage.OpenSoloTable(t, unoSeatRows(g, user, buyIn), buyIn)
|
|
switch {
|
|
case errors.Is(err, storage.ErrInsufficientChips), errors.Is(err, storage.ErrBadAmount):
|
|
writeJSONStatus(w, http.StatusBadRequest, map[string]string{"error": "not enough chips to sit down"})
|
|
return
|
|
case errors.Is(err, storage.ErrHandInProgress):
|
|
writeJSONStatus(w, http.StatusConflict, map[string]string{"error": "finish the game you're in first"})
|
|
return
|
|
case err != nil:
|
|
slog.Error("games: open solo uno table", "user", user, "err", err)
|
|
http.Error(w, "internal error", http.StatusInternalServerError)
|
|
return
|
|
}
|
|
s.writeUnoTable(w, user, nil)
|
|
}
|
|
|
|
// pickOpenUnoSeat chooses a chair to join: the one asked for if it is a bot's,
|
|
// otherwise the first bot seat. Returns -1 if there is nowhere to sit.
|
|
func pickOpenUnoSeat(g uno.State, want *int) int {
|
|
if want != nil {
|
|
i := *want
|
|
if i >= 0 && i < len(g.Seats) && g.Seats[i].Bot {
|
|
return i
|
|
}
|
|
return -1
|
|
}
|
|
for i := range g.Seats {
|
|
if g.Seats[i].Bot {
|
|
return i
|
|
}
|
|
}
|
|
return -1
|
|
}
|
|
|
|
// joinUno sits a player at an open chair on an existing table, one transaction
|
|
// under the table lock, so two people racing for the last seat cannot both win it.
|
|
func (s *Server) joinUno(w http.ResponseWriter, r *http.Request, user, tableID string, wantSeat *int, buyIn int64) {
|
|
name := s.displayName(r, user)
|
|
var respErr error
|
|
err := s.tableLocks.withTable(tableID, func() error {
|
|
t, _, err := storage.LoadTable(tableID)
|
|
if errors.Is(err, storage.ErrNoSuchTable) {
|
|
respErr = storage.ErrNoSuchTable
|
|
return nil
|
|
}
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if t.Game != gameUno {
|
|
respErr = uno.ErrUnknownMove
|
|
return nil
|
|
}
|
|
var g uno.State
|
|
if err := json.Unmarshal(t.State, &g); err != nil {
|
|
return err
|
|
}
|
|
if unoPlaying(g) {
|
|
respErr = uno.ErrHandLive // you join between hands
|
|
return nil
|
|
}
|
|
seat := pickOpenUnoSeat(g, wantSeat)
|
|
if seat < 0 {
|
|
respErr = uno.ErrTableFull
|
|
return nil
|
|
}
|
|
if err := g.Occupy(seat, name, buyIn); err != nil {
|
|
respErr = err
|
|
return nil
|
|
}
|
|
blob, err := json.Marshal(g)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.State, t.Phase, t.HandNo = blob, string(g.Phase), int64(g.HandNo)
|
|
err = storage.SitDown(storage.Sit{
|
|
Table: t,
|
|
Seat: storage.Seat{Seat: seat, MatrixUser: user, Name: name, Staked: buyIn},
|
|
BuyIn: buyIn,
|
|
})
|
|
switch {
|
|
case errors.Is(err, storage.ErrInsufficientChips), errors.Is(err, storage.ErrBadAmount):
|
|
respErr = storage.ErrInsufficientChips
|
|
return nil
|
|
case errors.Is(err, storage.ErrHandInProgress):
|
|
respErr = storage.ErrHandInProgress
|
|
return nil
|
|
case errors.Is(err, storage.ErrSeatTaken), errors.Is(err, storage.ErrStaleTable):
|
|
respErr = storage.ErrSeatTaken
|
|
return nil
|
|
case err != nil:
|
|
return err
|
|
}
|
|
s.publishTable(tableID)
|
|
return nil
|
|
})
|
|
if err != nil {
|
|
slog.Error("games: join uno", "user", user, "table", tableID, "err", err)
|
|
http.Error(w, "internal error", http.StatusInternalServerError)
|
|
return
|
|
}
|
|
if respErr != nil {
|
|
writeJSONStatus(w, unoJoinStatus(respErr), map[string]string{"error": unoJoinMessage(respErr)})
|
|
return
|
|
}
|
|
s.writeUnoTable(w, user, nil)
|
|
}
|
|
|
|
func unoJoinStatus(err error) int {
|
|
switch {
|
|
case errors.Is(err, storage.ErrNoSuchTable), errors.Is(err, uno.ErrTableFull),
|
|
errors.Is(err, storage.ErrSeatTaken), errors.Is(err, uno.ErrHandLive):
|
|
return http.StatusConflict
|
|
default:
|
|
return http.StatusBadRequest
|
|
}
|
|
}
|
|
|
|
func unoJoinMessage(err error) string {
|
|
switch {
|
|
case errors.Is(err, storage.ErrNoSuchTable):
|
|
return "that table has closed"
|
|
case errors.Is(err, uno.ErrTableFull), errors.Is(err, storage.ErrSeatTaken):
|
|
return "that seat is taken"
|
|
case errors.Is(err, uno.ErrHandLive):
|
|
return "a hand is in play — sit down when it's over"
|
|
case errors.Is(err, uno.ErrBadBuyIn):
|
|
return "that isn't a legal buy-in for this table"
|
|
case errors.Is(err, storage.ErrInsufficientChips):
|
|
return "not enough chips to sit down"
|
|
case errors.Is(err, storage.ErrHandInProgress):
|
|
return "finish the game you're in first"
|
|
default:
|
|
return "you can't sit there"
|
|
}
|
|
}
|
|
|
|
// ---- playing a hand --------------------------------------------------------
|
|
|
|
// handleUnoMove plays one move at the player's table: a hand move, or dealing the
|
|
// next hand. Leaving is its own endpoint.
|
|
func (s *Server) handleUnoMove(w http.ResponseWriter, r *http.Request) {
|
|
user, ok := s.player(w, r)
|
|
if !ok {
|
|
return
|
|
}
|
|
var move uno.Move
|
|
if err := decodeJSON(r, &move); err != nil {
|
|
http.Error(w, "bad json", http.StatusBadRequest)
|
|
return
|
|
}
|
|
if move.Kind == uno.MoveLeave {
|
|
s.leaveUno(w, user)
|
|
return
|
|
}
|
|
|
|
tableID, seat, err := storage.PlayerSeat(user)
|
|
if errors.Is(err, storage.ErrNoLiveHand) {
|
|
writeJSONStatus(w, http.StatusConflict, map[string]string{"error": "you're not at a table"})
|
|
return
|
|
}
|
|
if err != nil {
|
|
slog.Error("games: uno move seat", "user", user, "err", err)
|
|
http.Error(w, "internal error", http.StatusInternalServerError)
|
|
return
|
|
}
|
|
|
|
var respErr error
|
|
var respEvents []uno.Event
|
|
err = s.tableLocks.withTable(tableID, func() error {
|
|
t, seats, err := storage.LoadTable(tableID)
|
|
if errors.Is(err, storage.ErrNoSuchTable) {
|
|
respErr = storage.ErrNoSuchTable
|
|
return nil
|
|
}
|
|
if err != nil {
|
|
return err
|
|
}
|
|
var g uno.State
|
|
if err := json.Unmarshal(t.State, &g); err != nil {
|
|
return err
|
|
}
|
|
|
|
next, evs, aerr := uno.ApplyMove(g, seat, move)
|
|
if aerr != nil {
|
|
respErr = aerr
|
|
return nil
|
|
}
|
|
|
|
// A solo session that just ended (the one human got up or busted at the deal)
|
|
// is not a table any more: cash the seat out and close the felt. Only a solo
|
|
// table reaches PhaseDone; a shared table plays on.
|
|
if next.Phase == uno.PhaseDone {
|
|
if err := s.settleUnoLeave(t, next, seat, user); err != nil {
|
|
if errors.Is(err, storage.ErrStaleTable) {
|
|
respErr = storage.ErrStaleTable
|
|
return nil
|
|
}
|
|
return err
|
|
}
|
|
respEvents = evs
|
|
s.publishTable(tableID)
|
|
return nil
|
|
}
|
|
|
|
st, err := unoStep(next, evs, seats)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
acting := seats[seat]
|
|
acting.Away = false
|
|
acting.LastSeen = time.Now().Unix()
|
|
|
|
t.State, t.Phase, t.HandNo, t.Deadline = st.State, st.Phase, st.HandNo, st.Deadline
|
|
if err := storage.CommitTable(storage.TableCommit{
|
|
Table: t, Seats: []storage.Seat{acting}, Audit: st.Audit,
|
|
}); err != nil {
|
|
if errors.Is(err, storage.ErrStaleTable) {
|
|
respErr = storage.ErrStaleTable
|
|
return nil
|
|
}
|
|
return err
|
|
}
|
|
respEvents = evs
|
|
s.publishTable(tableID)
|
|
return nil
|
|
})
|
|
if err != nil {
|
|
slog.Error("games: uno move", "user", user, "table", tableID, "err", err)
|
|
http.Error(w, "internal error", http.StatusInternalServerError)
|
|
return
|
|
}
|
|
if respErr != nil {
|
|
writeJSONStatus(w, unoMoveStatus(respErr), map[string]string{"error": unoMoveMessage(respErr)})
|
|
return
|
|
}
|
|
s.writeUnoTable(w, user, respEvents)
|
|
}
|
|
|
|
func unoMoveStatus(err error) int {
|
|
switch {
|
|
case errors.Is(err, storage.ErrStaleTable), errors.Is(err, storage.ErrNoSuchTable):
|
|
return http.StatusConflict
|
|
default:
|
|
return http.StatusBadRequest
|
|
}
|
|
}
|
|
|
|
func unoMoveMessage(err error) string {
|
|
switch {
|
|
case errors.Is(err, storage.ErrStaleTable):
|
|
return "the table moved on — take another look"
|
|
case errors.Is(err, storage.ErrNoSuchTable):
|
|
return "that table has closed"
|
|
case errors.Is(err, uno.ErrHandLive):
|
|
return "finish the hand first"
|
|
case errors.Is(err, uno.ErrNoHand):
|
|
return "there's no hand in play — deal one"
|
|
case errors.Is(err, uno.ErrNotYourTurn):
|
|
return "it isn't your turn"
|
|
case errors.Is(err, uno.ErrCantPlay):
|
|
return "that card doesn't go on this one"
|
|
case errors.Is(err, uno.ErrNeedColor):
|
|
return "pick a colour for the wild"
|
|
case errors.Is(err, uno.ErrMustPlayNow):
|
|
return "play the card you drew, or pass"
|
|
case errors.Is(err, uno.ErrCantPass):
|
|
return "draw first, then you can pass"
|
|
case errors.Is(err, uno.ErrMustStack):
|
|
return "answer the stack with a draw card, or take it"
|
|
case errors.Is(err, uno.ErrNoStack):
|
|
return "there's nothing pointed at you to take"
|
|
case errors.Is(err, uno.ErrNoCatch):
|
|
return "there's nobody in that seat to catch"
|
|
default:
|
|
return "that move isn't legal here"
|
|
}
|
|
}
|
|
|
|
// ---- getting up ------------------------------------------------------------
|
|
|
|
// handleUnoLeave is the get-up endpoint. Leaving is its own route because it is a
|
|
// storage operation, not an engine move — the chips cross the border and the felt
|
|
// may close.
|
|
func (s *Server) handleUnoLeave(w http.ResponseWriter, r *http.Request) {
|
|
user, ok := s.player(w, r)
|
|
if !ok {
|
|
return
|
|
}
|
|
s.leaveUno(w, user)
|
|
}
|
|
|
|
// leaveUno gets a player up from their table, turning what is in front of them
|
|
// back into chips. It refuses mid-hand and closes the felt behind the last human.
|
|
func (s *Server) leaveUno(w http.ResponseWriter, user string) {
|
|
tableID, seat, err := storage.PlayerSeat(user)
|
|
if errors.Is(err, storage.ErrNoLiveHand) {
|
|
writeJSONStatus(w, http.StatusConflict, map[string]string{"error": "you're not at a table"})
|
|
return
|
|
}
|
|
if err != nil {
|
|
slog.Error("games: uno leave seat", "user", user, "err", err)
|
|
http.Error(w, "internal error", http.StatusInternalServerError)
|
|
return
|
|
}
|
|
|
|
var respErr error
|
|
err = s.tableLocks.withTable(tableID, func() error {
|
|
t, _, err := storage.LoadTable(tableID)
|
|
if errors.Is(err, storage.ErrNoSuchTable) {
|
|
respErr = storage.ErrNoSuchTable
|
|
return nil
|
|
}
|
|
if err != nil {
|
|
return err
|
|
}
|
|
var g uno.State
|
|
if err := json.Unmarshal(t.State, &g); err != nil {
|
|
return err
|
|
}
|
|
if unoPlaying(g) {
|
|
respErr = uno.ErrHandLive
|
|
return nil
|
|
}
|
|
if err := s.settleUnoLeave(t, g, seat, user); err != nil {
|
|
if errors.Is(err, storage.ErrStaleTable) {
|
|
respErr = storage.ErrStaleTable
|
|
return nil
|
|
}
|
|
return err
|
|
}
|
|
s.publishTable(tableID)
|
|
return nil
|
|
})
|
|
if err != nil {
|
|
slog.Error("games: uno leave", "user", user, "table", tableID, "err", err)
|
|
http.Error(w, "internal error", http.StatusInternalServerError)
|
|
return
|
|
}
|
|
if respErr != nil {
|
|
writeJSONStatus(w, unoMoveStatus(respErr), map[string]string{"error": unoMoveMessage(respErr)})
|
|
return
|
|
}
|
|
s.writeUnoTable(w, user, nil)
|
|
}
|
|
|
|
// settleUnoLeave vacates a seat, credits the stack home, and closes the table if
|
|
// nobody human is left — all inside the caller's lock.
|
|
func (s *Server) settleUnoLeave(t storage.Table, g uno.State, seat int, user string) error {
|
|
home, err := g.Vacate(seat)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
blob, err := json.Marshal(g)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.State, t.Phase, t.HandNo, t.Deadline = blob, string(g.Phase), int64(g.HandNo), 0
|
|
if err := storage.LeaveTable(storage.Leave{
|
|
Table: t, Seat: seat, MatrixUser: user, Bot: g.Seats[seat].Name, Amount: home,
|
|
}); err != nil {
|
|
return err
|
|
}
|
|
return storage.CloseTable(t.ID)
|
|
}
|
|
|
|
// ---- the response ----------------------------------------------------------
|
|
|
|
// writeUnoTable answers with the whole page state — the money and the table as the
|
|
// player's own seat may see it — plus, when a move produced one, the redacted event
|
|
// script for that seat to animate.
|
|
func (s *Server) writeUnoTable(w http.ResponseWriter, user string, evs []uno.Event) {
|
|
v, err := s.table(user)
|
|
if err != nil {
|
|
slog.Error("games: uno table", "user", user, "err", err)
|
|
http.Error(w, "internal error", http.StatusInternalServerError)
|
|
return
|
|
}
|
|
if len(evs) > 0 {
|
|
if _, seat, serr := storage.PlayerSeat(user); serr == nil {
|
|
v.UnoEvents = viewUnoEvents(evs, seat)
|
|
}
|
|
}
|
|
writeJSON(w, v)
|
|
}
|