games: you buy the deck, and win it back a card at a time
Solitaire, Vegas rules — the only shape solitaire has ever had as a gambling game. You don't win or lose the deal: the stake buys the deck outright, and every card you get home to a foundation pays a fifty-second of the tier's multiple back. Cash the board whenever you like and keep what you've banked, so a board that has gone dead is a decision rather than a wall. No undo: the stake is spent the moment the deck is bought, and an undo would be a way to walk a losing board backwards until it wins. Three deals, and the two dials are the whole difficulty of Klondike. Patient draws one with unlimited passes and pays 1.4x, so it takes 38 cards home to get square. Vegas draws three, three times round, 2.2x, square at 24. Cutthroat draws three and gives you one pass, 3.4x, square at 16 — most of those boards never clear, and you're ahead long before they would. internal/games/klondike is the same pure reducer as the other two, and Pays() is one function for the same reason hangman's is. Two fuzzers hold the deck together: no sequence of moves can lose or duplicate a card, and the board stays well-formed. They earned their keep immediately — the first thing they caught was a recycle that reversed the waste. It flips as a block, so the card drawn first comes out first, and reversing it would have dealt a different game on every pass and quietly broken the seed in the audit log. The browser never sees the stock or a face-down card, which here is most of the deck rather than blackjack's one hole card: a column sends how many cards are under it, never which. The table re-renders and animates the difference. Blackjack plays back a script because a hand only ever grows at one end; solitaire moves runs from anywhere to anywhere and an auto-finish moves eleven cards at once, so a script of "append this card there" would be a second engine over here and it would be the one that's wrong. Instead the board on screen is always exactly the board the server says exists, and each card is played from where it just was to where it now is. The events supply only what a diff can't: where a newly-revealed card came from, and what the board is worth. The rules are mirrored in JS on purpose, and only to light up the columns a held card can go to. Being shown where a card goes is the game teaching you; being told no after you commit is the game scolding you. The server still decides, and a disagreement snaps the board back to what it says. Two things came out into the open rather than being copied, which is the rule this room runs on: casino-cards.js (the deck — faces, pips, the flip) and PeteFX.spot() (the pile of chips and the number under it, which now owns the rule that the number is a readout of the pile). Blackjack uses both. Not yet driven in a browser.
This commit is contained in:
prosolis
@@ -6,6 +6,7 @@ import (
|
||||
|
||||
"pete/internal/games/blackjack"
|
||||
"pete/internal/games/hangman"
|
||||
"pete/internal/games/klondike"
|
||||
"pete/internal/storage"
|
||||
)
|
||||
|
||||
@@ -26,9 +27,9 @@ type gameTeaser struct {
|
||||
}
|
||||
|
||||
var comingSoon = []gameTeaser{
|
||||
{Name: "Trivia", Emoji: "🧠", Blurb: "Faster answers score higher."},
|
||||
{Name: "Hold'em", Emoji: "♠️", Blurb: "Six seats, and the house bots know how to play."},
|
||||
{Name: "UNO", Emoji: "🎴", Blurb: "Normal rules, or no mercy."},
|
||||
{Name: "Trivia", Emoji: "🧠", Blurb: "Faster answers score higher."},
|
||||
}
|
||||
|
||||
// betDenominations are the chips you build a bet out of.
|
||||
@@ -72,6 +73,8 @@ type gamesPage struct {
|
||||
Denominations []int64
|
||||
Tiers []hangman.Tier // hangman's three lengths, and what each pays
|
||||
MaxWrong int
|
||||
Deals []klondike.Tier // solitaire's three deals
|
||||
FullDeck int
|
||||
}
|
||||
|
||||
// casinoRoutes hangs every table off the mux.
|
||||
@@ -84,6 +87,7 @@ func (s *Server) casinoRoutes(mux *http.ServeMux) {
|
||||
mux.HandleFunc("GET /games", s.handleLobby)
|
||||
mux.HandleFunc("GET /games/blackjack", s.handleBlackjack)
|
||||
mux.HandleFunc("GET /games/hangman", s.handleHangman)
|
||||
mux.HandleFunc("GET /games/solitaire", s.handleSolitaire)
|
||||
|
||||
mux.HandleFunc("GET /api/games/table", s.handleTable)
|
||||
mux.HandleFunc("POST /api/games/buyin", s.handleBuyIn)
|
||||
@@ -94,6 +98,9 @@ func (s *Server) casinoRoutes(mux *http.ServeMux) {
|
||||
|
||||
mux.HandleFunc("POST /api/games/hangman/start", s.handleHangmanStart)
|
||||
mux.HandleFunc("POST /api/games/hangman/guess", s.handleHangmanGuess)
|
||||
|
||||
mux.HandleFunc("POST /api/games/solitaire/start", s.handleSolitaireStart)
|
||||
mux.HandleFunc("POST /api/games/solitaire/move", s.handleSolitaireMove)
|
||||
}
|
||||
|
||||
// requirePlayer sends an anonymous visitor to sign in and comes back here after.
|
||||
@@ -122,6 +129,8 @@ func (s *Server) gamesPage(r *http.Request) gamesPage {
|
||||
Denominations: betDenominations,
|
||||
Tiers: hangman.Tiers,
|
||||
MaxWrong: hangman.MaxWrong,
|
||||
Deals: klondike.Tiers,
|
||||
FullDeck: klondike.FullDeck,
|
||||
}
|
||||
}
|
||||
|
||||
@@ -145,3 +154,10 @@ func (s *Server) handleHangman(w http.ResponseWriter, r *http.Request) {
|
||||
}
|
||||
s.render(w, "hangman", s.gamesPage(r))
|
||||
}
|
||||
|
||||
func (s *Server) handleSolitaire(w http.ResponseWriter, r *http.Request) {
|
||||
if !s.requirePlayer(w, r) {
|
||||
return
|
||||
}
|
||||
s.render(w, "solitaire", s.gamesPage(r))
|
||||
}
|
||||
|
||||
@@ -13,6 +13,7 @@ import (
|
||||
"pete/internal/games/blackjack"
|
||||
"pete/internal/games/cards"
|
||||
"pete/internal/games/hangman"
|
||||
"pete/internal/games/klondike"
|
||||
"pete/internal/storage"
|
||||
)
|
||||
|
||||
@@ -177,7 +178,7 @@ type tableView struct {
|
||||
Euros float64 `json:"euros"` // advisory, and up to a couple of minutes stale
|
||||
Cap int64 `json:"cap"`
|
||||
|
||||
Game string `json:"game,omitempty"` // "blackjack" | "hangman", if one is live
|
||||
Game string `json:"game,omitempty"` // "blackjack" | "hangman" | "solitaire", if one is live
|
||||
|
||||
Hand *handView `json:"hand,omitempty"` // blackjack
|
||||
Events []eventView `json:"events,omitempty"` // blackjack, only on a move
|
||||
@@ -185,6 +186,9 @@ type tableView struct {
|
||||
Hangman *hangmanView `json:"hangman,omitempty"`
|
||||
HangEvents []hangman.Event `json:"hang_events,omitempty"`
|
||||
|
||||
Solitaire *solitaireView `json:"solitaire,omitempty"`
|
||||
SolEvents []solEventView `json:"sol_events,omitempty"`
|
||||
|
||||
Rake float64 `json:"rake_pct"`
|
||||
}
|
||||
|
||||
@@ -228,6 +232,13 @@ func (s *Server) table(user string) (tableView, error) {
|
||||
}
|
||||
hv := viewHangman(g)
|
||||
v.Hangman = &hv
|
||||
case gameSolitaire:
|
||||
var g klondike.State
|
||||
if err := json.Unmarshal(live.State, &g); err != nil {
|
||||
return s.dropUnreadable(user, v, err)
|
||||
}
|
||||
sv := viewSolitaire(g)
|
||||
v.Solitaire = &sv
|
||||
default:
|
||||
return s.dropUnreadable(user, v, fmt.Errorf("unknown game %q", live.Game))
|
||||
}
|
||||
@@ -482,6 +493,7 @@ func (s *Server) handleMove(w http.ResponseWriter, r *http.Request) {
|
||||
const (
|
||||
gameBlackjack = "blackjack"
|
||||
gameHangman = "hangman"
|
||||
gameSolitaire = "solitaire"
|
||||
)
|
||||
|
||||
// finished is what commit needs to know about a game it's writing back: enough
|
||||
|
||||
286
internal/web/games_solitaire.go
Normal file
286
internal/web/games_solitaire.go
Normal file
@@ -0,0 +1,286 @@
|
||||
package web
|
||||
|
||||
import (
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"log/slog"
|
||||
"math/rand/v2"
|
||||
"net/http"
|
||||
|
||||
"pete/internal/games/blackjack"
|
||||
"pete/internal/games/cards"
|
||||
"pete/internal/games/klondike"
|
||||
"pete/internal/storage"
|
||||
)
|
||||
|
||||
// Solitaire, played for chips. Vegas scoring: you buy the deck, and every card
|
||||
// you get home pays a slice of it back.
|
||||
//
|
||||
// The withheld information here is bigger than blackjack's single hole card —
|
||||
// it's the stock and every face-down card in the tableau, which between them are
|
||||
// most of the deck. So the view sends *counts* for both: a column says how many
|
||||
// cards are face-down under it, never which. A browser that held the stock would
|
||||
// be a browser that knows whether the next pull is worth taking, and this game is
|
||||
// nothing but that decision, repeated.
|
||||
//
|
||||
// The events, on the other hand, need no filtering at all, and that's worth
|
||||
// saying out loud because blackjack's do. Every card a klondike event carries is
|
||||
// a card the move itself just turned face up: the draw puts cards in the waste,
|
||||
// the flip turns a column's top card over, a move carries cards that were already
|
||||
// face up. There is no event here that mentions a card the player isn't now
|
||||
// looking at.
|
||||
|
||||
// solPileView is one tableau column: how deep the face-down stack is, and the
|
||||
// run sitting face up on top of it.
|
||||
type solPileView struct {
|
||||
Down int `json:"down"`
|
||||
Up []cardView `json:"up"`
|
||||
}
|
||||
|
||||
// solFoundView is one foundation. Only the top card matters — it's the only one
|
||||
// that can be played back off — so it's the only one sent, with a count for the
|
||||
// height of the pile.
|
||||
type solFoundView struct {
|
||||
Suit string `json:"suit"` // the glyph, so the empty pile can show what it wants
|
||||
Red bool `json:"red"`
|
||||
N int `json:"n"`
|
||||
Top *cardView `json:"top,omitempty"`
|
||||
}
|
||||
|
||||
// solitaireView is a board as its player may see it.
|
||||
type solitaireView struct {
|
||||
Tier klondike.Tier `json:"tier"`
|
||||
|
||||
Stock int `json:"stock"` // how many cards are left in it, not which
|
||||
Waste []cardView `json:"waste"` // the top few, in the order they were turned
|
||||
WasteN int `json:"waste_n"`
|
||||
Table []solPileView `json:"table"`
|
||||
Found []solFoundView `json:"found"`
|
||||
|
||||
Passes int `json:"passes"` // through the stock, counting this one; -1 unlimited
|
||||
Moves int `json:"moves"`
|
||||
CanAuto bool `json:"can_auto"`
|
||||
|
||||
Home int `json:"home"` // cards on the foundations
|
||||
PerCard float64 `json:"per_card"` // what one more is worth
|
||||
BreakEven int `json:"break_even"` // how many gets you square with the house
|
||||
Bet int64 `json:"bet"`
|
||||
Stands int64 `json:"stands"` // what cashing out right now actually pays
|
||||
|
||||
Phase string `json:"phase"`
|
||||
Outcome string `json:"outcome,omitempty"`
|
||||
Payout int64 `json:"payout,omitempty"`
|
||||
Rake int64 `json:"rake,omitempty"`
|
||||
Net int64 `json:"net"`
|
||||
}
|
||||
|
||||
// wasteShown is how much of the waste the felt fans out. Three, because that is
|
||||
// what a three-card draw puts down and the rest of the pile is just a pile.
|
||||
const wasteShown = 3
|
||||
|
||||
func viewSolitaire(g klondike.State) solitaireView {
|
||||
v := solitaireView{
|
||||
Tier: g.Tier,
|
||||
Stock: len(g.Stock),
|
||||
WasteN: len(g.Waste),
|
||||
Passes: g.PassesLeft(),
|
||||
Moves: g.Moves,
|
||||
CanAuto: g.CanAuto(),
|
||||
Home: g.Home(),
|
||||
PerCard: g.PerCard(),
|
||||
BreakEven: g.Tier.BreakEven(),
|
||||
Bet: g.Bet,
|
||||
// What cashing out right now would actually land on the stack, rake already
|
||||
// out of it. The pre-rake figure would have the felt advertising a number
|
||||
// the house doesn't hand over.
|
||||
Stands: g.Pays(),
|
||||
Phase: string(g.Phase),
|
||||
Outcome: string(g.Outcome),
|
||||
Payout: g.Payout,
|
||||
Rake: g.Rake,
|
||||
Net: g.Net(),
|
||||
}
|
||||
|
||||
from := len(g.Waste) - wasteShown
|
||||
if from < 0 {
|
||||
from = 0
|
||||
}
|
||||
for _, c := range g.Waste[from:] {
|
||||
v.Waste = append(v.Waste, viewCard(c))
|
||||
}
|
||||
|
||||
v.Table = make([]solPileView, klondike.Piles)
|
||||
for i, p := range g.Table {
|
||||
v.Table[i] = solPileView{Down: len(p.Down)}
|
||||
for _, c := range p.Up {
|
||||
v.Table[i].Up = append(v.Table[i].Up, viewCard(c))
|
||||
}
|
||||
}
|
||||
|
||||
v.Found = make([]solFoundView, klondike.Foundations)
|
||||
for i, f := range g.Found {
|
||||
suit := cards.Suit(i)
|
||||
fv := solFoundView{Suit: suit.String(), Red: suit == cards.Hearts || suit == cards.Diamonds, N: len(f)}
|
||||
if len(f) > 0 {
|
||||
top := viewCard(f[len(f)-1])
|
||||
fv.Top = &top
|
||||
}
|
||||
v.Found[i] = fv
|
||||
}
|
||||
return v
|
||||
}
|
||||
|
||||
// solEventView is one thing the table animates. See the note at the top: unlike
|
||||
// blackjack's, these need nothing stripped out of them.
|
||||
type solEventView struct {
|
||||
Kind string `json:"kind"`
|
||||
Cards []cardView `json:"cards,omitempty"`
|
||||
From string `json:"from,omitempty"`
|
||||
To string `json:"to,omitempty"`
|
||||
Home int `json:"home"`
|
||||
Pays int64 `json:"pays"`
|
||||
}
|
||||
|
||||
func viewSolEvents(evs []klondike.Event) []solEventView {
|
||||
out := make([]solEventView, 0, len(evs))
|
||||
for _, e := range evs {
|
||||
v := solEventView{Kind: e.Kind, From: e.From, To: e.To, Home: e.Home, Pays: e.Pays}
|
||||
for _, c := range e.Cards {
|
||||
v.Cards = append(v.Cards, viewCard(c))
|
||||
}
|
||||
out = append(out, v)
|
||||
}
|
||||
return out
|
||||
}
|
||||
|
||||
// handleSolitaireStart takes the stake and deals the board. Same order as a
|
||||
// blackjack deal: the chips are staked first, in the same statement that checks
|
||||
// they exist, so two starts fired at once cannot buy the same deck twice.
|
||||
func (s *Server) handleSolitaireStart(w http.ResponseWriter, r *http.Request) {
|
||||
user, ok := s.player(w, r)
|
||||
if !ok {
|
||||
return
|
||||
}
|
||||
var req struct {
|
||||
Bet int64 `json:"bet"`
|
||||
Tier string `json:"tier"`
|
||||
}
|
||||
if err := decodeJSON(r, &req); err != nil || req.Bet <= 0 {
|
||||
writeJSONStatus(w, http.StatusBadRequest, map[string]string{"error": "bet something"})
|
||||
return
|
||||
}
|
||||
tier, err := klondike.TierBySlug(req.Tier)
|
||||
if err != nil {
|
||||
writeJSONStatus(w, http.StatusBadRequest, map[string]string{"error": "pick a deal"})
|
||||
return
|
||||
}
|
||||
|
||||
if err := storage.Stake(user, req.Bet); err != nil {
|
||||
if errors.Is(err, storage.ErrInsufficientChips) || errors.Is(err, storage.ErrBadAmount) {
|
||||
writeJSONStatus(w, http.StatusBadRequest, map[string]string{"error": "not enough chips for that deck"})
|
||||
return
|
||||
}
|
||||
slog.Error("games: solitaire stake", "user", user, "err", err)
|
||||
http.Error(w, "internal error", http.StatusInternalServerError)
|
||||
return
|
||||
}
|
||||
|
||||
seed1, seed2 := newSeeds()
|
||||
rng := rand.New(rand.NewPCG(seed1, seed2))
|
||||
g, evs, err := klondike.New(req.Bet, tier, blackjack.DefaultRules().RakePct, rng)
|
||||
if err != nil {
|
||||
// The board never happened, so the stake never should have left.
|
||||
_ = storage.Award(user, req.Bet)
|
||||
slog.Error("games: solitaire deal", "user", user, "err", err)
|
||||
http.Error(w, "internal error", http.StatusInternalServerError)
|
||||
return
|
||||
}
|
||||
s.persistSolitaire(w, user, g, evs, seed1, seed2, true)
|
||||
}
|
||||
|
||||
// solitaireErrors are the illegal moves a player makes by playing, rather than
|
||||
// by tampering. Each gets said back to them in words, because "that move isn't
|
||||
// legal" over a board with 60 legal-looking targets on it is not an answer.
|
||||
var solitaireErrors = map[error]string{
|
||||
klondike.ErrWontGo: "that card doesn't go there",
|
||||
klondike.ErrNotASequence: "you can only lift a run that goes down in rank and alternates colour",
|
||||
klondike.ErrEmptyPile: "there's nothing there",
|
||||
klondike.ErrNoDraw: "the stock is empty",
|
||||
klondike.ErrNoPasses: "that was your last pass through the stock",
|
||||
klondike.ErrNothingHome: "nothing can go home right now",
|
||||
klondike.ErrGameOver: "that board is finished",
|
||||
}
|
||||
|
||||
// handleSolitaireMove plays one move: a draw, a card moved, a card sent home, an
|
||||
// auto-finish, or cashing the board in.
|
||||
func (s *Server) handleSolitaireMove(w http.ResponseWriter, r *http.Request) {
|
||||
user, ok := s.player(w, r)
|
||||
if !ok {
|
||||
return
|
||||
}
|
||||
var move klondike.Move
|
||||
if err := decodeJSON(r, &move); err != nil {
|
||||
http.Error(w, "bad json", http.StatusBadRequest)
|
||||
return
|
||||
}
|
||||
|
||||
live, err := storage.LoadLiveHand(user)
|
||||
if errors.Is(err, storage.ErrNoLiveHand) {
|
||||
writeJSONStatus(w, http.StatusConflict, map[string]string{"error": "no game in progress"})
|
||||
return
|
||||
}
|
||||
if err != nil {
|
||||
slog.Error("games: solitaire load", "user", user, "err", err)
|
||||
http.Error(w, "internal error", http.StatusInternalServerError)
|
||||
return
|
||||
}
|
||||
if live.Game != gameSolitaire {
|
||||
writeJSONStatus(w, http.StatusConflict, map[string]string{"error": "finish the hand you're in first"})
|
||||
return
|
||||
}
|
||||
var g klondike.State
|
||||
if err := json.Unmarshal(live.State, &g); err != nil {
|
||||
slog.Error("games: unreadable solitaire board", "user", user, "err", err)
|
||||
http.Error(w, "internal error", http.StatusInternalServerError)
|
||||
return
|
||||
}
|
||||
|
||||
next, evs, err := klondike.ApplyMove(g, move)
|
||||
if err != nil {
|
||||
msg, known := solitaireErrors[err]
|
||||
if !known {
|
||||
msg = "that move isn't legal here"
|
||||
}
|
||||
writeJSONStatus(w, http.StatusBadRequest, map[string]string{"error": msg})
|
||||
return
|
||||
}
|
||||
s.persistSolitaire(w, user, next, evs, live.Seed1, live.Seed2, false)
|
||||
}
|
||||
|
||||
// persistSolitaire writes the board back and answers the browser.
|
||||
func (s *Server) persistSolitaire(w http.ResponseWriter, user string, g klondike.State, evs []klondike.Event, seed1, seed2 uint64, fresh bool) {
|
||||
blob, err := json.Marshal(g)
|
||||
if err != nil {
|
||||
slog.Error("games: marshal solitaire", "user", user, "err", err)
|
||||
http.Error(w, "internal error", http.StatusInternalServerError)
|
||||
return
|
||||
}
|
||||
done := g.Phase == klondike.PhaseDone
|
||||
v, ok := s.commit(w, user, finished{
|
||||
Game: gameSolitaire, Blob: blob,
|
||||
Bet: g.Bet, Payout: g.Payout, Rake: g.Rake,
|
||||
Outcome: string(g.Outcome), Done: done,
|
||||
Seed1: seed1, Seed2: seed2, Fresh: fresh,
|
||||
})
|
||||
if !ok {
|
||||
return
|
||||
}
|
||||
// A finished board is gone from storage, so the table has none to show — but
|
||||
// the browser still needs the final one to animate the last cards onto.
|
||||
if done {
|
||||
sv := viewSolitaire(g)
|
||||
v.Solitaire = &sv
|
||||
}
|
||||
v.SolEvents = viewSolEvents(evs)
|
||||
writeJSON(w, v)
|
||||
}
|
||||
@@ -95,7 +95,7 @@ func New(cfg config.WebConfig, sources []config.SourceConfig, postingEnabled boo
|
||||
pages []string
|
||||
}{
|
||||
{"layout", []string{"_card"}, []string{"index", "channel", "weather", "bookmarks", "for-you", "status", "story"}},
|
||||
{"games_layout", []string{"_chipbar"}, []string{"games", "blackjack", "hangman"}},
|
||||
{"games_layout", []string{"_chipbar"}, []string{"games", "blackjack", "hangman", "solitaire"}},
|
||||
}
|
||||
tpls := make(map[string]*template.Template)
|
||||
for _, set := range sets {
|
||||
|
||||
@@ -570,10 +570,13 @@ html[data-phase="night"] {
|
||||
|
||||
/* One card. The wrapper does the flight, the inner face does the flip, so the
|
||||
two never fight over the same transform. */
|
||||
/* The size is a variable because solitaire has seven columns to fit and
|
||||
blackjack has two hands. Everything below is in terms of it, so a table can
|
||||
shrink its cards without a second set of rules. */
|
||||
.pete-card {
|
||||
perspective: 700px;
|
||||
height: 8.4rem;
|
||||
width: 6rem;
|
||||
height: var(--card-h, 8.4rem);
|
||||
width: var(--card-w, 6rem);
|
||||
animation: pete-deal 0.42s cubic-bezier(0.22, 1, 0.36, 1) backwards;
|
||||
}
|
||||
.pete-card-inner {
|
||||
@@ -1078,6 +1081,210 @@ html[data-phase="night"] {
|
||||
border-color: var(--accent);
|
||||
}
|
||||
|
||||
/* ---- solitaire -----------------------------------------------------------
|
||||
Seven columns, four foundations, a stock and a waste, all of which have to
|
||||
fit across the felt on a phone as well as a desk. So the card size is one
|
||||
variable derived from the width available, and every gap and fan below is
|
||||
derived from *that* — the board scales as one thing rather than as nine
|
||||
things that each stop fitting at a different width.
|
||||
|
||||
The cards themselves don't move by CSS here. A move in solitaire can take a
|
||||
card from anywhere to anywhere, so the table re-renders the board and then
|
||||
animates each card from where it just was (see the FLIP note in
|
||||
solitaire.js). CSS's job is only to say where things sit. */
|
||||
|
||||
.pete-solitaire {
|
||||
--card-w: clamp(2.5rem, 10.6vw, 5.2rem);
|
||||
--card-h: calc(var(--card-w) * 1.4);
|
||||
--fan-up: calc(var(--card-h) * 0.29); /* how much of a face-up card shows under the next */
|
||||
--fan-down: calc(var(--card-h) * 0.14); /* a face-down one shows less: there's nothing to read */
|
||||
}
|
||||
|
||||
/* An empty place a card could be: the stock when it's spent, a foundation
|
||||
waiting for its ace, a column waiting for a king. Same footprint as a card,
|
||||
so nothing on the board reflows when one empties. */
|
||||
.pete-slot {
|
||||
position: relative;
|
||||
display: grid;
|
||||
place-items: center;
|
||||
height: var(--card-h);
|
||||
width: var(--card-w);
|
||||
flex: none;
|
||||
border-radius: 0.55rem;
|
||||
border: 2px dashed rgba(255, 255, 255, 0.25);
|
||||
background: rgba(0, 0, 0, 0.12);
|
||||
box-shadow: inset 0 2px 8px rgba(0, 0, 0, 0.18);
|
||||
transition: border-color 0.18s ease, background 0.18s ease, transform 0.12s ease;
|
||||
}
|
||||
.pete-slot-glyph {
|
||||
font-size: calc(var(--card-w) * 0.42);
|
||||
line-height: 1;
|
||||
color: rgba(255, 255, 255, 0.3);
|
||||
}
|
||||
.pete-slot-glyph[data-red="1"] { color: rgba(255, 170, 170, 0.35); }
|
||||
|
||||
/* A card sitting *in* a slot — the top of a foundation. The slot keeps its
|
||||
footprint whether or not there's a card on it, so an ace going home doesn't
|
||||
reflow the row, and a drop target has somewhere to be while it's empty. */
|
||||
.pete-slot > .pete-card {
|
||||
position: absolute;
|
||||
inset: 0;
|
||||
height: 100%;
|
||||
width: 100%;
|
||||
}
|
||||
|
||||
/* The stock is a button, and it looks like the back of a card because that is
|
||||
what it is: a pile you can turn over. */
|
||||
.pete-stock {
|
||||
border-style: solid;
|
||||
border-color: rgba(0, 0, 0, 0.15);
|
||||
background:
|
||||
repeating-linear-gradient(45deg, rgba(255,255,255,0.10) 0 6px, transparent 6px 12px),
|
||||
linear-gradient(150deg, #b4553f, #8d3f2f);
|
||||
cursor: pointer;
|
||||
}
|
||||
.pete-stock:hover { filter: brightness(1.08); }
|
||||
.pete-stock:active { transform: translateY(1px) scale(0.98); }
|
||||
/* Spent, but there's a pass left: it stops being a pile of cards and starts
|
||||
being the gesture of turning the waste back over. */
|
||||
.pete-stock[data-empty="1"] {
|
||||
background: rgba(0, 0, 0, 0.12);
|
||||
border-style: dashed;
|
||||
border-color: rgba(255, 255, 255, 0.25);
|
||||
}
|
||||
/* Spent, and no passes left. Not a button any more — and it says so by looking
|
||||
like the dead thing it is rather than by silently refusing clicks. */
|
||||
.pete-stock[data-dead="1"] {
|
||||
cursor: default;
|
||||
opacity: 0.4;
|
||||
}
|
||||
.pete-stock[data-dead="1"]:hover { filter: none; }
|
||||
.pete-stock[data-dead="1"]:active { transform: none; }
|
||||
|
||||
.pete-slot-count {
|
||||
position: absolute;
|
||||
bottom: -0.5rem;
|
||||
left: 50%;
|
||||
transform: translateX(-50%);
|
||||
border-radius: 999px;
|
||||
background: rgba(0, 0, 0, 0.5);
|
||||
padding: 0.05rem 0.5rem;
|
||||
font-size: 0.7rem;
|
||||
font-weight: 700;
|
||||
font-variant-numeric: tabular-nums;
|
||||
color: #fff;
|
||||
}
|
||||
.pete-slot-recycle { color: rgba(255, 255, 255, 0.45); }
|
||||
.pete-slot-recycle svg { height: 1.4rem; width: 1.4rem; }
|
||||
|
||||
/* The waste. Three cards fanned sideways, the top one on the right — you can
|
||||
see what's under it, and only the top one is yours to take. */
|
||||
.pete-waste {
|
||||
position: relative;
|
||||
display: flex;
|
||||
height: var(--card-h);
|
||||
min-width: var(--card-w);
|
||||
}
|
||||
.pete-waste .pete-card + .pete-card {
|
||||
margin-left: calc(var(--card-w) * -0.72);
|
||||
}
|
||||
.pete-waste .pete-card { position: relative; }
|
||||
|
||||
/* The seven columns. They share the width evenly and never scroll: a board you
|
||||
have to scroll sideways is a board you can't plan on. */
|
||||
.pete-tableau {
|
||||
display: grid;
|
||||
grid-template-columns: repeat(7, var(--card-w));
|
||||
justify-content: space-between;
|
||||
gap: 0.5rem;
|
||||
align-items: start;
|
||||
min-height: calc(var(--card-h) * 2.6);
|
||||
}
|
||||
.pete-col {
|
||||
display: flex;
|
||||
flex-direction: column;
|
||||
align-items: center;
|
||||
min-height: var(--card-h);
|
||||
}
|
||||
/* Cards overlap up the column, and how much of one shows depends on whether
|
||||
there's anything to see. The rule keys off the card *above*, which is why
|
||||
it's an adjacent-sibling selector and not something the JS has to compute. */
|
||||
.pete-col .pete-card { position: relative; }
|
||||
.pete-col .pete-card[data-face="down"] + .pete-card {
|
||||
margin-top: calc(var(--fan-down) - var(--card-h));
|
||||
}
|
||||
.pete-col .pete-card[data-face="up"] + .pete-card {
|
||||
margin-top: calc(var(--fan-up) - var(--card-h));
|
||||
}
|
||||
|
||||
/* A card you can pick up says so. */
|
||||
.pete-card[data-live="1"] { cursor: pointer; }
|
||||
.pete-card[data-live="1"]:hover .pete-card-front {
|
||||
filter: brightness(1.06);
|
||||
}
|
||||
/* The card (or run) in your hand: lifted off the felt, and glowing, so it's
|
||||
obvious what a click on a column is about to move. */
|
||||
.pete-card[data-held="1"] {
|
||||
z-index: 5;
|
||||
transform: translateY(-0.55rem);
|
||||
transition: transform 0.14s cubic-bezier(0.34, 1.56, 0.64, 1);
|
||||
}
|
||||
.pete-card[data-held="1"] .pete-card-front {
|
||||
box-shadow:
|
||||
0 3px 0 rgba(0,0,0,0.18),
|
||||
0 10px 22px rgba(0,0,0,0.32),
|
||||
0 0 0 3px rgba(242, 181, 61, 0.9);
|
||||
}
|
||||
/* A place the held card would actually go. Lit *before* you click it, because
|
||||
the alternative is learning the rules by being told no. */
|
||||
.pete-slot[data-drop="1"],
|
||||
.pete-col[data-drop="1"] .pete-slot,
|
||||
.pete-col[data-drop="1"] .pete-card:last-child .pete-card-front {
|
||||
border-color: rgba(242, 181, 61, 0.9);
|
||||
box-shadow: 0 0 0 3px rgba(242, 181, 61, 0.45);
|
||||
}
|
||||
.pete-slot[data-drop="1"],
|
||||
.pete-col[data-drop="1"] .pete-slot {
|
||||
background: rgba(242, 181, 61, 0.12);
|
||||
}
|
||||
|
||||
/* A move that won't go. Said in the one language a board can speak. */
|
||||
.pete-nope { animation: pete-shake 0.4s cubic-bezier(0.36, 0.07, 0.19, 0.97); }
|
||||
|
||||
/* A card arriving on a foundation lands with a flash: it is the only move in
|
||||
the game that pays you, so it is the only one that gets a noise. */
|
||||
.pete-home-flash { animation: pete-home 0.5s ease-out; }
|
||||
@keyframes pete-home {
|
||||
0% { box-shadow: 0 0 0 0 rgba(242, 181, 61, 0.9); }
|
||||
100% { box-shadow: 0 0 0 1.4rem rgba(242, 181, 61, 0); }
|
||||
}
|
||||
|
||||
/* The rail: the house's rack, what you've banked, the meter. On a wide screen
|
||||
it's a column down the right of the felt; on a narrow one it lies down and
|
||||
sits under the board. */
|
||||
.pete-rail {
|
||||
display: flex;
|
||||
flex-direction: row;
|
||||
flex-wrap: wrap;
|
||||
align-items: center;
|
||||
justify-content: center;
|
||||
gap: 1rem 1.5rem;
|
||||
}
|
||||
@media (min-width: 1024px) {
|
||||
.pete-rail {
|
||||
flex-direction: column;
|
||||
justify-content: flex-start;
|
||||
width: 9.5rem;
|
||||
gap: 1.5rem;
|
||||
}
|
||||
}
|
||||
/* In the rail the rack is just another thing in a column, so it drops the
|
||||
absolute positioning it uses when it's pinned to the corner of a felt. */
|
||||
.pete-rack[data-at="rail"] {
|
||||
position: static;
|
||||
justify-content: center;
|
||||
}
|
||||
|
||||
@media (prefers-reduced-motion: reduce) {
|
||||
.pete-card,
|
||||
.pete-card::after,
|
||||
@@ -1089,6 +1296,9 @@ html[data-phase="night"] {
|
||||
.pete-shake,
|
||||
.pete-tile-hit,
|
||||
.pete-meter[data-hit="1"] { animation: none; }
|
||||
.pete-nope,
|
||||
.pete-home-flash { animation: none; }
|
||||
.pete-card[data-held="1"] { transition: none; }
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
File diff suppressed because one or more lines are too long
@@ -44,11 +44,12 @@
|
||||
var spotTotalEl = root.querySelector("[data-spot-total]");
|
||||
var houseEl = root.querySelector("[data-house]");
|
||||
|
||||
// Nothing is bet until a chip is on the felt. The number in the panel is a
|
||||
// readout of the pile, so it starts where the pile does — at nothing — rather
|
||||
// than at a default stake nobody put down.
|
||||
// The spot owns the chips on the felt and the number under them — see PeteFX.
|
||||
// Nothing is bet until a chip is on it, so `bet` starts at nothing rather than
|
||||
// at a default stake nobody put down.
|
||||
var spot = FX.spot({ spot: spotEl, stack: stackEl, total: spotTotalEl });
|
||||
|
||||
var bet = 0; // what you're building between hands
|
||||
var staked = 0; // what is actually sitting on the spot right now
|
||||
var busy = false; // a request is in flight, or cards are still landing
|
||||
var hand = null; // the hand as the server last described it
|
||||
|
||||
@@ -68,194 +69,23 @@
|
||||
}
|
||||
|
||||
// ---- drawing --------------------------------------------------------------
|
||||
|
||||
var dealt = 0; // how many cards this table has put down, ever — the tilt seed
|
||||
|
||||
// cardEl builds one card. face === null means face-down: the card is dealt,
|
||||
// but this browser has not been told what it is.
|
||||
function cardEl(face) {
|
||||
var wrap = document.createElement("div");
|
||||
wrap.className = "pete-card";
|
||||
wrap.dataset.face = face ? "up" : "down";
|
||||
// Every card flies out of the shoe, which sits in the top-right of the felt.
|
||||
// The offset is per-card, so a card landing further left flies further.
|
||||
wrap.style.setProperty("--deal-x", "14rem");
|
||||
wrap.style.setProperty("--deal-y", "-6rem");
|
||||
// Where it comes to rest. A degree or two either way is the whole difference
|
||||
// between cards that were dealt onto a table and cards that were laid out in
|
||||
// a grid, and it costs one custom property.
|
||||
wrap.style.setProperty("--tilt", FX.jitter(dealt++, 2.4).toFixed(2) + "deg");
|
||||
|
||||
var inner = document.createElement("div");
|
||||
inner.className = "pete-card-inner";
|
||||
|
||||
var front = document.createElement("div");
|
||||
front.className = "pete-card-front";
|
||||
var back = document.createElement("div");
|
||||
back.className = "pete-card-back";
|
||||
|
||||
inner.appendChild(front);
|
||||
inner.appendChild(back);
|
||||
wrap.appendChild(inner);
|
||||
if (face) paintFace(front, face);
|
||||
return wrap;
|
||||
}
|
||||
|
||||
// ---- the face ------------------------------------------------------------
|
||||
//
|
||||
// A card is drawn, not typed. The first attempt set the pips as text — "♠" in a
|
||||
// span — and at the size a card actually is, a suit character renders as a
|
||||
// speck: the shape is whatever font happened to answer, it doesn't scale, and
|
||||
// it can't be positioned to the half-row a real pip layout needs.
|
||||
//
|
||||
// So each face is one SVG on a 100×140 field (the proportions of a real card),
|
||||
// with the suits as vector shapes. Everything below is coordinates on that
|
||||
// field, which is why the pips land where a printed deck puts them instead of
|
||||
// where a flexbox felt like putting them.
|
||||
// The deck itself — the faces, the pips, the flip — is PeteCards, shared with
|
||||
// every other table in the room. Here a card is always dealt out of the shoe
|
||||
// and always lands with a degree or two of tilt on it, which are this table's
|
||||
// two opinions about a card and the only ones it has.
|
||||
|
||||
var SUIT_ART = {
|
||||
"♠": '<path d="M50 6C50 6 16 34 16 58a17 17 0 0 0 28 13c-1 12-5 19-12 25h36c-7-6-11-13-12-25a17 17 0 0 0 28-13C84 34 50 6 50 6Z"/>',
|
||||
"♥": '<path d="M50 96C50 96 8 66 8 38A22 22 0 0 1 50 24 22 22 0 0 1 92 38c0 28-42 58-42 58Z"/>',
|
||||
"♦": '<path d="M50 4 88 50 50 96 12 50Z"/>',
|
||||
"♣": '<g><circle cx="50" cy="28" r="19"/><circle cx="24" cy="62" r="19"/><circle cx="76" cy="62" r="19"/>' +
|
||||
'<path d="M44 60h12l7 36H37Z"/></g>',
|
||||
};
|
||||
var CARDS = window.PeteCards;
|
||||
|
||||
// Pip layouts, the way a real deck lays them out — which is not "N suits in a
|
||||
// row". [x, y] on the 100×140 field. The seven canonical rows sit at y = 27,
|
||||
// 41, 56, 70, 84, 99, 113; sevens, eights and tens carry a pip *between* two of
|
||||
// them, which is the whole reason this is a table of coordinates and not a
|
||||
// grid. Anything below the middle is printed upside down, so it is.
|
||||
var R = [0, 27, 41.4, 55.7, 70, 84.3, 98.6, 113]; // 1-indexed, R[4] is the middle
|
||||
var L = 30, C = 50, Rr = 70; // the three columns
|
||||
|
||||
var PIPS = {
|
||||
"A": [[C, 70, 2.1]],
|
||||
"2": [[C, R[1]], [C, R[7]]],
|
||||
"3": [[C, R[1]], [C, R[4]], [C, R[7]]],
|
||||
"4": [[L, R[1]], [Rr, R[1]], [L, R[7]], [Rr, R[7]]],
|
||||
"5": [[L, R[1]], [Rr, R[1]], [C, R[4]], [L, R[7]], [Rr, R[7]]],
|
||||
"6": [[L, R[1]], [Rr, R[1]], [L, R[4]], [Rr, R[4]], [L, R[7]], [Rr, R[7]]],
|
||||
"7": [[L, R[1]], [Rr, R[1]], [C, 48.5], [L, R[4]], [Rr, R[4]], [L, R[7]], [Rr, R[7]]],
|
||||
"8": [[L, R[1]], [Rr, R[1]], [C, 48.5], [L, R[4]], [Rr, R[4]], [C, 91.5], [L, R[7]], [Rr, R[7]]],
|
||||
"9": [[L, R[1]], [Rr, R[1]], [L, R[3]], [Rr, R[3]], [C, R[4]], [L, R[5]], [Rr, R[5]], [L, R[7]], [Rr, R[7]]],
|
||||
"10": [[L, R[1]], [Rr, R[1]], [C, 48.5], [L, R[3]], [Rr, R[3]], [L, R[5]], [Rr, R[5]], [C, 91.5], [L, R[7]], [Rr, R[7]]],
|
||||
};
|
||||
|
||||
var COURT = { "J": "Jack", "Q": "Queen", "K": "King" };
|
||||
|
||||
// One pip: the suit art, scaled and dropped at [x, y], turned over if it sits
|
||||
// below the middle of the card.
|
||||
function pipAt(suit, x, y, scale) {
|
||||
var s = (scale || 1) * 0.17;
|
||||
var turn = y > 70 ? " rotate(180 50 50)" : "";
|
||||
return '<g transform="translate(' + x + ' ' + y + ') scale(' + s + ') translate(-50 -50)' + turn + '">' +
|
||||
SUIT_ART[suit] + "</g>";
|
||||
}
|
||||
|
||||
// The corner index: rank over suit. Printed in both corners, the second one
|
||||
// upside down, which is what lets you read a card from a fanned hand.
|
||||
function index(face) {
|
||||
var g =
|
||||
'<g>' +
|
||||
'<text x="12" y="24" class="pete-card-idx">' + face.rank + "</text>" +
|
||||
'<g transform="translate(12 36) scale(0.13) translate(-50 -50)">' + SUIT_ART[face.suit] + "</g>" +
|
||||
"</g>";
|
||||
return g + '<g transform="rotate(180 50 70)">' + g + "</g>";
|
||||
}
|
||||
|
||||
// paintFace draws the card. The dealer's cards and yours use the same face,
|
||||
// because they came out of the same shoe.
|
||||
function paintFace(front, face) {
|
||||
front.dataset.red = face.red ? "1" : "0";
|
||||
|
||||
var body = "";
|
||||
if (COURT[face.rank]) {
|
||||
// Court cards: a framed panel, the suit above the letter and again below it
|
||||
// the other way up. A real court mirrors a *figure*; mirroring a letter just
|
||||
// stacks two of them into a blob, which is exactly what the first attempt
|
||||
// did. No portrait either — a drawn king would fight the room, and this
|
||||
// reads instantly at the size a card actually is.
|
||||
body =
|
||||
'<rect x="20" y="22" width="60" height="96" rx="6" class="pete-card-panel"/>' +
|
||||
pipAt(face.suit, 50, 38, 0.95) +
|
||||
'<text x="50" y="82" class="pete-card-court">' + face.rank + "</text>" +
|
||||
pipAt(face.suit, 50, 102, 0.95);
|
||||
} else {
|
||||
var spots = PIPS[face.rank] || [];
|
||||
for (var i = 0; i < spots.length; i++) {
|
||||
body += pipAt(face.suit, spots[i][0], spots[i][1], spots[i][2]);
|
||||
}
|
||||
}
|
||||
|
||||
front.innerHTML =
|
||||
'<svg class="pete-card-svg" viewBox="0 0 100 140" xmlns="http://www.w3.org/2000/svg" ' +
|
||||
'role="img" aria-label="' + ariaFor(face) + '">' + index(face) + body + "</svg>";
|
||||
}
|
||||
|
||||
// "A♠" is not something a screen reader should be asked to pronounce.
|
||||
function ariaFor(face) {
|
||||
var SUITS = { "♠": "spades", "♥": "hearts", "♦": "diamonds", "♣": "clubs" };
|
||||
var name = COURT[face.rank] || (face.rank === "A" ? "Ace" : face.rank);
|
||||
var suit = SUITS[face.suit];
|
||||
return suit ? name + " of " + suit : face.label;
|
||||
}
|
||||
|
||||
// turnOver flips a face-down card up, now that we've been told what it is.
|
||||
function turnOver(wrap, face) {
|
||||
if (!wrap) return;
|
||||
paintFace(wrap.querySelector(".pete-card-front"), face);
|
||||
wrap.dataset.face = "up";
|
||||
}
|
||||
function cardEl(face) { return CARDS.el(face); }
|
||||
var turnOver = CARDS.turnOver;
|
||||
|
||||
// ---- the money on the felt -------------------------------------------------
|
||||
//
|
||||
// `staked` is what the spot is holding. Every path that changes it also moves
|
||||
// chips to say so, so the two can't come apart: renderStack draws the pile,
|
||||
// and the fly* calls are what put it there.
|
||||
|
||||
function renderStack(amount) {
|
||||
staked = amount || 0;
|
||||
stackEl.innerHTML = "";
|
||||
spotEl.dataset.live = staked > 0 ? "1" : "0";
|
||||
|
||||
if (!staked) {
|
||||
spotTotalEl.classList.add("hidden");
|
||||
return;
|
||||
}
|
||||
FX.chipsFor(staked).forEach(function (d, i) {
|
||||
var c = FX.disc(d);
|
||||
c.style.setProperty("--i", i);
|
||||
c.style.setProperty("--spin", FX.jitter(i, 12).toFixed(1) + "deg");
|
||||
c.style.animationDelay = pace(i * 40) + "ms";
|
||||
stackEl.appendChild(c);
|
||||
});
|
||||
spotTotalEl.textContent = staked.toLocaleString();
|
||||
spotTotalEl.classList.remove("hidden");
|
||||
}
|
||||
|
||||
// pour throws a run of chips from one place to another and grows the pile on
|
||||
// the spot as each one lands — by the value of the chip that landed, so the
|
||||
// total under the pile counts up the way the chips do. The last chip carries
|
||||
// the remainder, because chipsFor caps how many chips it will make you watch
|
||||
// and the pile still has to end on the real number.
|
||||
function pour(from, to, amount, opts) {
|
||||
if (amount <= 0) return Promise.resolve();
|
||||
var base = staked;
|
||||
var chips = FX.chipsFor(amount, 8);
|
||||
var run = 0;
|
||||
return FX.flyMany(from, to, chips, Object.assign({
|
||||
onLand: function (d, i) {
|
||||
run += d;
|
||||
renderStack(base + (i === chips.length - 1 ? amount : run));
|
||||
},
|
||||
}, opts || {}));
|
||||
}
|
||||
|
||||
// stake moves chips from your pile onto the spot: the bet you build before a
|
||||
// deal, and the second bet a double puts down beside it.
|
||||
function stake(amount, from) {
|
||||
return pour(from || purseEl, spotEl, amount);
|
||||
return spot.pour(from || purseEl, amount);
|
||||
}
|
||||
|
||||
// settleChips is what the felt does about the outcome, after the cards have
|
||||
@@ -268,25 +98,17 @@
|
||||
|
||||
if (payout <= 0) {
|
||||
// The house takes it. The stack goes to the rack and doesn't come back.
|
||||
var lost = FX.chipsFor(final.bet, 8);
|
||||
var chain = FX.flyMany(spotEl, houseEl, lost, { gap: 45, lift: 0.6, fade: true });
|
||||
renderStack(0);
|
||||
return chain;
|
||||
return spot.sweep(houseEl, final.bet, { gap: 45, lift: 0.6, fade: true });
|
||||
}
|
||||
|
||||
// The house pays first, into the spot beside your stake, so you watch the
|
||||
// winnings arrive on top of the bet that earned them.
|
||||
var pay = pour(houseEl, spotEl, back, { gap: 60 });
|
||||
|
||||
// Paid, then swept up: the whole lot comes back to your pile, and only then
|
||||
// does the number in the bar move.
|
||||
return pay
|
||||
return spot
|
||||
.pour(houseEl, back, { gap: 60 })
|
||||
.then(function () { return wait(back > 0 ? 380 : 200); })
|
||||
.then(function () {
|
||||
var home = FX.flyMany(spotEl, purseEl, FX.chipsFor(payout, 8), { gap: 40, lift: 0.8 });
|
||||
renderStack(0);
|
||||
return home;
|
||||
});
|
||||
// Paid, then swept up: the whole lot comes back to your pile, and only then
|
||||
// does the number in the bar move.
|
||||
.then(function () { return spot.sweep(purseEl, payout, { gap: 40, lift: 0.8 }); });
|
||||
}
|
||||
|
||||
function totals(v) {
|
||||
@@ -312,12 +134,12 @@
|
||||
function paint(v) {
|
||||
dealerEl.innerHTML = "";
|
||||
playerEl.innerHTML = "";
|
||||
if (!v) { setPhase(null); renderStack(0); return; }
|
||||
if (!v) { setPhase(null); spot.render(0); return; }
|
||||
|
||||
v.player.forEach(function (c) { playerEl.appendChild(cardEl(c)); });
|
||||
v.dealer.forEach(function (c) { dealerEl.appendChild(cardEl(c)); });
|
||||
if (v.hole) dealerEl.appendChild(cardEl(null));
|
||||
renderStack(v.phase === "done" ? 0 : v.bet);
|
||||
spot.render(v.phase === "done" ? 0 : v.bet);
|
||||
totals(v);
|
||||
setPhase(v);
|
||||
}
|
||||
@@ -386,8 +208,8 @@
|
||||
// first, and a deal whose bet was typed rather than stacked (you kept last
|
||||
// hand's number and just pressed Deal). Either way the chips go down before
|
||||
// the card they're buying does.
|
||||
if (final && final.bet > staked) {
|
||||
var extra = final.bet - staked;
|
||||
if (final && final.bet > spot.amount) {
|
||||
var extra = final.bet - spot.amount;
|
||||
chain = chain.then(function () { return stake(extra); });
|
||||
}
|
||||
|
||||
@@ -499,7 +321,7 @@
|
||||
say(err.message, "bad");
|
||||
// Whatever we thought was on the felt, the server is the authority on it.
|
||||
return window.PeteGames.refresh().then(function (v) {
|
||||
if (v && !v.hand) renderStack(0);
|
||||
if (v && !v.hand) spot.render(0);
|
||||
});
|
||||
})
|
||||
.then(function () { busy = false; });
|
||||
@@ -531,12 +353,12 @@
|
||||
|
||||
// The chip you clicked is the chip that flies: same colour, same size, off
|
||||
// the button and onto the felt. The pile only grows once it gets there —
|
||||
// but `staked` moves now, so a Deal pressed mid-flight still knows the chip
|
||||
// is on its way and doesn't put a second one down.
|
||||
// but the spot's total moves now, so a Deal pressed mid-flight still knows
|
||||
// the chip is on its way and doesn't put a second one down.
|
||||
var target = bet;
|
||||
staked = bet;
|
||||
spot.amount = bet;
|
||||
FX.fly(btn, spotEl, { denom: d }).then(function () {
|
||||
if (bet >= target) renderStack(target); // unless Clear got there first
|
||||
if (bet >= target) spot.render(target); // unless Clear got there first
|
||||
});
|
||||
});
|
||||
});
|
||||
@@ -544,10 +366,9 @@
|
||||
var clearBtn = root.querySelector("[data-bet-clear]");
|
||||
if (clearBtn) {
|
||||
clearBtn.addEventListener("click", function () {
|
||||
if (busy || !staked) { bet = 0; showBet(); return; }
|
||||
FX.flyMany(spotEl, purseEl, FX.chipsFor(staked, 8), { gap: 40, lift: 0.7 });
|
||||
if (busy || !spot.amount) { bet = 0; showBet(); return; }
|
||||
spot.sweep(purseEl, null, { gap: 40, lift: 0.7 });
|
||||
bet = 0;
|
||||
renderStack(0);
|
||||
showBet();
|
||||
});
|
||||
}
|
||||
|
||||
172
internal/web/static/js/casino-cards.js
Normal file
172
internal/web/static/js/casino-cards.js
Normal file
@@ -0,0 +1,172 @@
|
||||
// The deck, as the room draws it.
|
||||
//
|
||||
// A card is drawn, not typed. The first attempt set the pips as text — "♠" in a
|
||||
// span — and at the size a card actually is, a suit character renders as a speck:
|
||||
// the shape is whatever font happened to answer, it doesn't scale, and it can't
|
||||
// be positioned to the half-row a real pip layout needs.
|
||||
//
|
||||
// So each face is one SVG on a 100×140 field (the proportions of a real card),
|
||||
// with the suits as vector shapes. Everything below is coordinates on that field,
|
||||
// which is why the pips land where a printed deck puts them instead of where a
|
||||
// flexbox felt like putting them.
|
||||
//
|
||||
// This started life inside blackjack.js. It's out here because solitaire deals
|
||||
// off the same deck, and the second table in a casino is exactly the moment a
|
||||
// copied card renderer becomes two card renderers that drift.
|
||||
//
|
||||
// Exposed as window.PeteCards. Nothing in here knows what game is being played.
|
||||
(function () {
|
||||
"use strict";
|
||||
|
||||
var SUIT_ART = {
|
||||
"♠": '<path d="M50 6C50 6 16 34 16 58a17 17 0 0 0 28 13c-1 12-5 19-12 25h36c-7-6-11-13-12-25a17 17 0 0 0 28-13C84 34 50 6 50 6Z"/>',
|
||||
"♥": '<path d="M50 96C50 96 8 66 8 38A22 22 0 0 1 50 24 22 22 0 0 1 92 38c0 28-42 58-42 58Z"/>',
|
||||
"♦": '<path d="M50 4 88 50 50 96 12 50Z"/>',
|
||||
"♣": '<g><circle cx="50" cy="28" r="19"/><circle cx="24" cy="62" r="19"/><circle cx="76" cy="62" r="19"/>' +
|
||||
'<path d="M44 60h12l7 36H37Z"/></g>',
|
||||
};
|
||||
|
||||
// Pip layouts, the way a real deck lays them out — which is not "N suits in a
|
||||
// row". [x, y] on the 100×140 field. The seven canonical rows sit at y = 27,
|
||||
// 41, 56, 70, 84, 99, 113; sevens, eights and tens carry a pip *between* two of
|
||||
// them, which is the whole reason this is a table of coordinates and not a
|
||||
// grid. Anything below the middle is printed upside down, so it is.
|
||||
var R = [0, 27, 41.4, 55.7, 70, 84.3, 98.6, 113]; // 1-indexed, R[4] is the middle
|
||||
var L = 30, C = 50, Rr = 70; // the three columns
|
||||
|
||||
var PIPS = {
|
||||
"A": [[C, 70, 2.1]],
|
||||
"2": [[C, R[1]], [C, R[7]]],
|
||||
"3": [[C, R[1]], [C, R[4]], [C, R[7]]],
|
||||
"4": [[L, R[1]], [Rr, R[1]], [L, R[7]], [Rr, R[7]]],
|
||||
"5": [[L, R[1]], [Rr, R[1]], [C, R[4]], [L, R[7]], [Rr, R[7]]],
|
||||
"6": [[L, R[1]], [Rr, R[1]], [L, R[4]], [Rr, R[4]], [L, R[7]], [Rr, R[7]]],
|
||||
"7": [[L, R[1]], [Rr, R[1]], [C, 48.5], [L, R[4]], [Rr, R[4]], [L, R[7]], [Rr, R[7]]],
|
||||
"8": [[L, R[1]], [Rr, R[1]], [C, 48.5], [L, R[4]], [Rr, R[4]], [C, 91.5], [L, R[7]], [Rr, R[7]]],
|
||||
"9": [[L, R[1]], [Rr, R[1]], [L, R[3]], [Rr, R[3]], [C, R[4]], [L, R[5]], [Rr, R[5]], [L, R[7]], [Rr, R[7]]],
|
||||
"10": [[L, R[1]], [Rr, R[1]], [C, 48.5], [L, R[3]], [Rr, R[3]], [L, R[5]], [Rr, R[5]], [C, 91.5], [L, R[7]], [Rr, R[7]]],
|
||||
};
|
||||
|
||||
var COURT = { "J": "Jack", "Q": "Queen", "K": "King" };
|
||||
var SUIT_NAMES = { "♠": "spades", "♥": "hearts", "♦": "diamonds", "♣": "clubs" };
|
||||
|
||||
// One pip: the suit art, scaled and dropped at [x, y], turned over if it sits
|
||||
// below the middle of the card.
|
||||
function pipAt(suit, x, y, scale) {
|
||||
var s = (scale || 1) * 0.17;
|
||||
var turn = y > 70 ? " rotate(180 50 50)" : "";
|
||||
return '<g transform="translate(' + x + ' ' + y + ') scale(' + s + ') translate(-50 -50)' + turn + '">' +
|
||||
SUIT_ART[suit] + "</g>";
|
||||
}
|
||||
|
||||
// The corner index: rank over suit. Printed in both corners, the second one
|
||||
// upside down, which is what lets you read a card from a fanned hand — and in
|
||||
// solitaire, from a column where all you can see is the top eighth of it.
|
||||
function index(face) {
|
||||
var g =
|
||||
'<g>' +
|
||||
'<text x="12" y="24" class="pete-card-idx">' + face.rank + "</text>" +
|
||||
'<g transform="translate(12 36) scale(0.13) translate(-50 -50)">' + SUIT_ART[face.suit] + "</g>" +
|
||||
"</g>";
|
||||
return g + '<g transform="rotate(180 50 70)">' + g + "</g>";
|
||||
}
|
||||
|
||||
// paint draws the face. Every table uses this one, because they all deal out of
|
||||
// the same deck.
|
||||
function paint(front, face) {
|
||||
front.dataset.red = face.red ? "1" : "0";
|
||||
|
||||
var body = "";
|
||||
if (COURT[face.rank]) {
|
||||
// Court cards: a framed panel, the suit above the letter and again below it
|
||||
// the other way up. A real court mirrors a *figure*; mirroring a letter just
|
||||
// stacks two of them into a blob, which is exactly what the first attempt
|
||||
// did. No portrait either — a drawn king would fight the room, and this
|
||||
// reads instantly at the size a card actually is.
|
||||
body =
|
||||
'<rect x="20" y="22" width="60" height="96" rx="6" class="pete-card-panel"/>' +
|
||||
pipAt(face.suit, 50, 38, 0.95) +
|
||||
'<text x="50" y="82" class="pete-card-court">' + face.rank + "</text>" +
|
||||
pipAt(face.suit, 50, 102, 0.95);
|
||||
} else {
|
||||
var spots = PIPS[face.rank] || [];
|
||||
for (var i = 0; i < spots.length; i++) {
|
||||
body += pipAt(face.suit, spots[i][0], spots[i][1], spots[i][2]);
|
||||
}
|
||||
}
|
||||
|
||||
front.innerHTML =
|
||||
'<svg class="pete-card-svg" viewBox="0 0 100 140" xmlns="http://www.w3.org/2000/svg" ' +
|
||||
'role="img" aria-label="' + aria(face) + '">' + index(face) + body + "</svg>";
|
||||
}
|
||||
|
||||
// "A♠" is not something a screen reader should be asked to pronounce.
|
||||
function aria(face) {
|
||||
var name = COURT[face.rank] || (face.rank === "A" ? "Ace" : face.rank);
|
||||
var suit = SUIT_NAMES[face.suit];
|
||||
return suit ? name + " of " + suit : face.label;
|
||||
}
|
||||
|
||||
var dealt = 0; // how many cards this page has put down, ever — the tilt seed
|
||||
|
||||
// el builds one card. face === null means face-down: the card is on the table,
|
||||
// but this browser has not been told what it is.
|
||||
//
|
||||
// opts.deal — fly it in from the shoe (blackjack). Solitaire turns this off:
|
||||
// it animates its own cards from wherever they actually came from,
|
||||
// and a board that re-renders would otherwise re-deal itself out of
|
||||
// the corner on every single move.
|
||||
// opts.tilt — a degree or two of resting angle. A dealt hand wants it; a
|
||||
// solitaire column does not, because thirteen tilted cards stacked
|
||||
// an eighth of an inch apart read as a mistake rather than as a
|
||||
// hand that was handled.
|
||||
function el(face, opts) {
|
||||
opts = opts || {};
|
||||
var deal = opts.deal !== false;
|
||||
var tilt = opts.tilt !== false;
|
||||
|
||||
var wrap = document.createElement("div");
|
||||
wrap.className = "pete-card";
|
||||
wrap.dataset.face = face ? "up" : "down";
|
||||
if (face) wrap.dataset.key = face.label; // one deck, so the label is an id
|
||||
|
||||
if (deal) {
|
||||
// Every card flies out of the shoe, which sits in the top-right of the felt.
|
||||
wrap.style.setProperty("--deal-x", "14rem");
|
||||
wrap.style.setProperty("--deal-y", "-6rem");
|
||||
} else {
|
||||
wrap.style.animation = "none";
|
||||
}
|
||||
wrap.style.setProperty("--tilt", tilt ? window.PeteFX.jitter(dealt++, 2.4).toFixed(2) + "deg" : "0deg");
|
||||
|
||||
var inner = document.createElement("div");
|
||||
inner.className = "pete-card-inner";
|
||||
|
||||
var front = document.createElement("div");
|
||||
front.className = "pete-card-front";
|
||||
var back = document.createElement("div");
|
||||
back.className = "pete-card-back";
|
||||
|
||||
inner.appendChild(front);
|
||||
inner.appendChild(back);
|
||||
wrap.appendChild(inner);
|
||||
if (face) paint(front, face);
|
||||
return wrap;
|
||||
}
|
||||
|
||||
// turnOver flips a face-down card up, now that we've been told what it is.
|
||||
function turnOver(wrap, face) {
|
||||
if (!wrap) return;
|
||||
paint(wrap.querySelector(".pete-card-front"), face);
|
||||
wrap.dataset.face = "up";
|
||||
wrap.dataset.key = face.label;
|
||||
}
|
||||
|
||||
window.PeteCards = {
|
||||
el: el,
|
||||
paint: paint,
|
||||
turnOver: turnOver,
|
||||
aria: aria,
|
||||
art: SUIT_ART,
|
||||
};
|
||||
})();
|
||||
@@ -144,6 +144,78 @@
|
||||
return Promise.all(each);
|
||||
}
|
||||
|
||||
// A bet spot: the pile of chips sitting on it, and the number printed under
|
||||
// the pile.
|
||||
//
|
||||
// The rule the whole room is built on lives in here, which is why it's one
|
||||
// object and not two variables on a table: **the number is a readout of the
|
||||
// pile, never the other way round.** There is no way to change one without the
|
||||
// other, so a settled game can't leave "your bet: 300" printed over an empty
|
||||
// circle, and a payout can't be counted before the chips that justify it have
|
||||
// landed.
|
||||
//
|
||||
// els: {spot, stack, total}. Blackjack's spot holds the stake; solitaire's
|
||||
// holds what you've banked, which grows a card at a time. Same object.
|
||||
function spot(els) {
|
||||
var api = {
|
||||
// What the pile is holding. Written by render, and readable by a table that
|
||||
// needs to know whether a chip is already on its way down.
|
||||
amount: 0,
|
||||
|
||||
render: function (n) {
|
||||
api.amount = n || 0;
|
||||
els.stack.innerHTML = "";
|
||||
if (els.spot) els.spot.dataset.live = api.amount > 0 ? "1" : "0";
|
||||
if (!api.amount) {
|
||||
if (els.total) els.total.classList.add("hidden");
|
||||
return;
|
||||
}
|
||||
chipsFor(api.amount).forEach(function (d, i) {
|
||||
var c = disc(d);
|
||||
c.style.setProperty("--i", i);
|
||||
c.style.setProperty("--spin", jitter(i, 12).toFixed(1) + "deg");
|
||||
c.style.animationDelay = (reduced ? 0 : i * 40) + "ms";
|
||||
els.stack.appendChild(c);
|
||||
});
|
||||
if (els.total) {
|
||||
els.total.textContent = api.amount.toLocaleString();
|
||||
els.total.classList.remove("hidden");
|
||||
}
|
||||
},
|
||||
|
||||
// pour throws a run of chips onto the spot and grows the pile as each one
|
||||
// lands — by the value of the chip that landed, so the total under the pile
|
||||
// counts up the way the chips do. The last chip carries the remainder,
|
||||
// because chipsFor caps how many chips it will make you watch and the pile
|
||||
// still has to end on the real number.
|
||||
pour: function (from, amount, opts) {
|
||||
if (amount <= 0) return Promise.resolve();
|
||||
var base = api.amount;
|
||||
var chips = chipsFor(amount, 8);
|
||||
var run = 0;
|
||||
return flyMany(from, els.spot, chips, Object.assign({
|
||||
onLand: function (d, i) {
|
||||
run += d;
|
||||
api.render(base + (i === chips.length - 1 ? amount : run));
|
||||
},
|
||||
}, opts || {}));
|
||||
},
|
||||
|
||||
// sweep sends chips off the spot to somewhere else — your pile, or the
|
||||
// house's rack. The spot is emptied *now* rather than when they land, so
|
||||
// nothing that is already in the air can be bet a second time.
|
||||
sweep: function (to, amount, opts) {
|
||||
var n = amount == null ? api.amount : amount;
|
||||
var left = api.amount - n;
|
||||
if (n <= 0) return Promise.resolve();
|
||||
var chain = flyMany(els.spot, to, chipsFor(n, 8), Object.assign({ gap: 40, lift: 0.8 }, opts || {}));
|
||||
api.render(left > 0 ? left : 0);
|
||||
return chain;
|
||||
},
|
||||
};
|
||||
return api;
|
||||
}
|
||||
|
||||
// burst: confetti out of a point. Saved for the things worth celebrating.
|
||||
function burst(target, opts) {
|
||||
if (reduced) return Promise.resolve();
|
||||
@@ -242,6 +314,7 @@
|
||||
jitter: jitter,
|
||||
fly: fly,
|
||||
flyMany: flyMany,
|
||||
spot: spot,
|
||||
burst: burst,
|
||||
count: count,
|
||||
centre: centre,
|
||||
|
||||
729
internal/web/static/js/solitaire.js
Normal file
729
internal/web/static/js/solitaire.js
Normal file
@@ -0,0 +1,729 @@
|
||||
// The solitaire table.
|
||||
//
|
||||
// Blackjack plays back a *script*: the server sends one event per card off the
|
||||
// shoe and the table deals them out in order. That works because a blackjack hand
|
||||
// only ever grows at one end. Solitaire doesn't: a move takes a run from anywhere
|
||||
// and puts it anywhere, an auto-finish moves eleven cards at once, and a single
|
||||
// move can turn a card over three columns away. A script of "append this card
|
||||
// there" would be a second engine over here, and it would be the one that's wrong.
|
||||
//
|
||||
// So this table re-renders the whole board from the server's view after every
|
||||
// move, and then animates the difference — FLIP: measure where every card *was*,
|
||||
// re-render, measure where it *is*, and play each card from its old place to its
|
||||
// new one. The board on screen is therefore always exactly the board the server
|
||||
// says exists, and the animation is derived from it rather than the other way
|
||||
// round. The events are still used, for the two things a diff genuinely cannot
|
||||
// tell you: where a newly-revealed card came from (out of the stock, or turned
|
||||
// over in place), and what the board is now worth.
|
||||
//
|
||||
// The money follows the same rule as every other table in the room: nothing about
|
||||
// it changes without a chip crossing the felt to make it change. Here the stake
|
||||
// buys the deck — it goes to the house and does not come back — and the spot in
|
||||
// the rail holds what you've *banked*, which grows by one card's worth every time
|
||||
// a card reaches a foundation and shrinks again if you take one back off.
|
||||
(function () {
|
||||
"use strict";
|
||||
|
||||
var root = document.querySelector("[data-solitaire]");
|
||||
if (!root) return;
|
||||
|
||||
var FX = window.PeteFX;
|
||||
var CARDS = window.PeteCards;
|
||||
|
||||
var stockEl = root.querySelector("[data-stock]");
|
||||
var stockCountEl = root.querySelector("[data-stock-count]");
|
||||
var stockRecycleEl = root.querySelector("[data-stock-recycle]");
|
||||
var wasteEl = root.querySelector("[data-waste]");
|
||||
var foundEl = root.querySelector("[data-foundations]");
|
||||
var tableauEl = root.querySelector("[data-tableau]");
|
||||
var verdictEl = root.querySelector("[data-verdict]");
|
||||
var homeEl = root.querySelector("[data-home]");
|
||||
var perCardEl = root.querySelector("[data-per-card]");
|
||||
var breakEvenEl = root.querySelector("[data-break-even]");
|
||||
var meterEl = root.querySelector("[data-meter]");
|
||||
|
||||
var playing = root.querySelector("[data-playing]");
|
||||
var betting = root.querySelector("[data-betting]");
|
||||
var autoBtn = root.querySelector("[data-auto]");
|
||||
var cashBtn = root.querySelector("[data-cash]");
|
||||
var cashAmountEl = root.querySelector("[data-cash-amount]");
|
||||
var startBtn = root.querySelector("[data-start]");
|
||||
var betAmountEl = root.querySelector("[data-bet-amount]");
|
||||
var gameMsg = root.querySelector("[data-game-msg]");
|
||||
var tableMsg = root.querySelector("[data-table-msg]");
|
||||
|
||||
var purseEl = document.querySelector("[data-chips]");
|
||||
var spotEl = root.querySelector("[data-spot]");
|
||||
var houseEl = root.querySelector("[data-house]");
|
||||
|
||||
// The spot in the rail. On this table it holds what you've banked, not a bet.
|
||||
var spot = FX.spot({
|
||||
spot: spotEl,
|
||||
stack: root.querySelector("[data-stack]"),
|
||||
total: root.querySelector("[data-spot-total]"),
|
||||
});
|
||||
|
||||
var FULL = 52;
|
||||
var MOVE_MS = 300; // one card's journey across the board
|
||||
var STEP_MS = 95; // the gap between two cards in a cascade
|
||||
var reduced = FX.reduced;
|
||||
|
||||
var bet = 0; // the deck you're building the price of
|
||||
var tier = null; // which deal
|
||||
var busy = false; // a request is in flight, or cards are still moving
|
||||
var board = null; // the board as the server last described it
|
||||
var held = null; // {pile, count, cards} — the run in your hand
|
||||
|
||||
function wait(ms) {
|
||||
return new Promise(function (r) { setTimeout(r, reduced ? 0 : ms); });
|
||||
}
|
||||
|
||||
function say(el, text, tone) {
|
||||
if (!text) { el.classList.add("hidden"); return; }
|
||||
el.textContent = text;
|
||||
el.classList.remove("hidden");
|
||||
el.style.color = tone === "bad" ? "#cc3d4a" : "";
|
||||
}
|
||||
|
||||
// ---- the rules, as the *browser* understands them --------------------------
|
||||
//
|
||||
// These mirror the engine, and they are not the engine: the server decides every
|
||||
// move and will refuse one this file thought was fine. They exist because you
|
||||
// cannot light up the columns a card can go to without knowing which those are,
|
||||
// and a table that makes you find that out by being told no is a table that
|
||||
// teaches Klondike by refusal. When the two disagree the server wins and the
|
||||
// board snaps back to whatever it says — see send().
|
||||
|
||||
var RANKS = { A: 1, J: 11, Q: 12, K: 13 };
|
||||
function rank(c) { return RANKS[c.rank] || parseInt(c.rank, 10); }
|
||||
|
||||
// isRun: descending by one, alternating colour — the only thing you may lift
|
||||
// off a column as a block.
|
||||
function isRun(cs) {
|
||||
for (var i = 1; i < cs.length; i++) {
|
||||
if (rank(cs[i]) !== rank(cs[i - 1]) - 1 || cs[i].red === cs[i - 1].red) return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
// accepts: what may be put where. A foundation takes its own suit in order from
|
||||
// the ace; a column takes a run that descends and alternates from its top card,
|
||||
// and an empty column takes a King and nothing else.
|
||||
function accepts(pile, cs) {
|
||||
if (!board || !cs || !cs.length) return false;
|
||||
|
||||
if (pile.charAt(0) === "f") {
|
||||
var f = board.found[parseInt(pile.slice(1), 10)];
|
||||
return !!f && cs.length === 1 && cs[0].suit === f.suit && rank(cs[0]) === f.n + 1;
|
||||
}
|
||||
|
||||
var col = board.table[parseInt(pile.slice(1), 10)];
|
||||
if (!col || !isRun(cs)) return false;
|
||||
if (!col.up || !col.up.length) return col.down === 0 && rank(cs[0]) === 13;
|
||||
var top = col.up[col.up.length - 1];
|
||||
return rank(cs[0]) === rank(top) - 1 && cs[0].red !== top.red;
|
||||
}
|
||||
|
||||
// cardsAt is the run you'd be picking up by clicking this card.
|
||||
function cardsAt(pile, idx) {
|
||||
if (!board) return null;
|
||||
if (pile === "waste") {
|
||||
return board.waste && board.waste.length ? [board.waste[board.waste.length - 1]] : null;
|
||||
}
|
||||
if (pile.charAt(0) === "f") {
|
||||
var f = board.found[parseInt(pile.slice(1), 10)];
|
||||
return f && f.top ? [f.top] : null;
|
||||
}
|
||||
var col = board.table[parseInt(pile.slice(1), 10)];
|
||||
if (!col || !col.up || idx >= col.up.length) return null;
|
||||
return col.up.slice(idx);
|
||||
}
|
||||
|
||||
// ---- drawing the board -----------------------------------------------------
|
||||
|
||||
// face builds a card element wired up for clicking. No deal flight and no tilt:
|
||||
// this table animates its own cards from wherever they actually came from, and a
|
||||
// column of thirteen tilted cards overlapping by an eighth of an inch reads as a
|
||||
// mistake rather than as a hand that was handled.
|
||||
function face(c, pile, idx) {
|
||||
var el = CARDS.el(c, { deal: false, tilt: false });
|
||||
el.dataset.pile = pile;
|
||||
el.dataset.idx = String(idx);
|
||||
return el;
|
||||
}
|
||||
|
||||
function slot(pile, glyph, red) {
|
||||
var el = document.createElement("div");
|
||||
el.className = "pete-slot";
|
||||
el.dataset.pile = pile;
|
||||
if (glyph) {
|
||||
el.innerHTML = '<span class="pete-slot-glyph" data-red="' + (red ? "1" : "0") + '">' + glyph + "</span>";
|
||||
}
|
||||
return el;
|
||||
}
|
||||
|
||||
function render(v) {
|
||||
board = v;
|
||||
if (!v) {
|
||||
wasteEl.innerHTML = "";
|
||||
foundEl.innerHTML = "";
|
||||
tableauEl.innerHTML = "";
|
||||
stockEl.dataset.dead = "1";
|
||||
stockCountEl.classList.add("hidden");
|
||||
stockRecycleEl.classList.add("hidden");
|
||||
meter(null);
|
||||
return;
|
||||
}
|
||||
|
||||
// The stock. Empty with a pass left is not the same thing as empty with none:
|
||||
// one is a gesture you can still make and the other is a dead pile, and the
|
||||
// difference is worth showing rather than leaving to a click that gets refused.
|
||||
var canRecycle = v.stock === 0 && v.waste_n > 0 && (v.passes < 0 || v.passes > 1);
|
||||
stockEl.dataset.empty = v.stock === 0 ? "1" : "0";
|
||||
stockEl.dataset.dead = v.stock === 0 && !canRecycle ? "1" : "0";
|
||||
stockCountEl.textContent = String(v.stock);
|
||||
stockCountEl.classList.toggle("hidden", v.stock === 0);
|
||||
stockRecycleEl.classList.toggle("hidden", !canRecycle);
|
||||
|
||||
// The waste: the last three, fanned, and only the top one is yours to take.
|
||||
wasteEl.innerHTML = "";
|
||||
(v.waste || []).forEach(function (c, i, all) {
|
||||
var el = face(c, "waste", i);
|
||||
if (i === all.length - 1) el.dataset.live = "1";
|
||||
wasteEl.appendChild(el);
|
||||
});
|
||||
|
||||
// The foundations. Each is a slot that stays put whether or not there's a card
|
||||
// on it, so the board doesn't reflow the moment an ace goes home — and so a
|
||||
// drop target has somewhere to be even when it's empty.
|
||||
foundEl.innerHTML = "";
|
||||
v.found.forEach(function (f, i) {
|
||||
var s = slot("f" + i, f.suit, f.red);
|
||||
if (f.top) {
|
||||
var el = face(f.top, "f" + i, 0);
|
||||
el.dataset.live = "1";
|
||||
s.appendChild(el);
|
||||
}
|
||||
foundEl.appendChild(s);
|
||||
});
|
||||
|
||||
// The seven columns.
|
||||
tableauEl.innerHTML = "";
|
||||
v.table.forEach(function (col, i) {
|
||||
var c = document.createElement("div");
|
||||
c.className = "pete-col";
|
||||
c.dataset.pile = "t" + i;
|
||||
|
||||
if (!col.down && !(col.up && col.up.length)) {
|
||||
c.appendChild(slot("t" + i));
|
||||
}
|
||||
for (var d = 0; d < col.down; d++) {
|
||||
c.appendChild(CARDS.el(null, { deal: false, tilt: false }));
|
||||
}
|
||||
(col.up || []).forEach(function (card, j) {
|
||||
var el = face(card, "t" + i, j);
|
||||
// A card is pickable if the run from it down is a run. Anything else is a
|
||||
// card you can see and can't lift, and it shouldn't offer.
|
||||
if (isRun(col.up.slice(j))) el.dataset.live = "1";
|
||||
c.appendChild(el);
|
||||
});
|
||||
tableauEl.appendChild(c);
|
||||
});
|
||||
|
||||
meter(v);
|
||||
controls(v);
|
||||
if (held) mark(); // a selection survives a re-render, so redraw what it lit
|
||||
}
|
||||
|
||||
// meter is what the board is worth. Every number in it comes off the server —
|
||||
// this file does no arithmetic about money, which is the point.
|
||||
function meter(v) {
|
||||
if (!v) {
|
||||
homeEl.innerHTML = '0<span class="text-white/40">/' + FULL + "</span>";
|
||||
perCardEl.textContent = "—";
|
||||
breakEvenEl.textContent = "";
|
||||
return;
|
||||
}
|
||||
homeEl.innerHTML = v.home + '<span class="text-white/40">/' + FULL + "</span>";
|
||||
perCardEl.textContent = "+" + v.per_card.toFixed(1);
|
||||
breakEvenEl.textContent =
|
||||
v.home >= v.break_even
|
||||
? "You're ahead of the house"
|
||||
: v.break_even - v.home + " more to break even";
|
||||
meterEl.dataset.cold = v.home === 0 ? "1" : "0";
|
||||
}
|
||||
|
||||
function controls(v) {
|
||||
var live = !!v && v.phase === "playing";
|
||||
playing.classList.toggle("hidden", !live);
|
||||
betting.classList.toggle("hidden", live);
|
||||
if (!live) return;
|
||||
autoBtn.disabled = !v.can_auto;
|
||||
cashAmountEl.textContent = (v.stands || 0).toLocaleString();
|
||||
}
|
||||
|
||||
// ---- FLIP ------------------------------------------------------------------
|
||||
//
|
||||
// Where every card is, right now. One deck, so a card's label is its identity.
|
||||
|
||||
function snapshot() {
|
||||
var map = {};
|
||||
root.querySelectorAll(".pete-card[data-key]").forEach(function (el) {
|
||||
map[el.dataset.key] = el.getBoundingClientRect();
|
||||
});
|
||||
map["#stock"] = stockEl.getBoundingClientRect();
|
||||
return map;
|
||||
}
|
||||
|
||||
// plan reads the events for the two things a before/after diff can't tell you:
|
||||
// where a card that is *new to the board* came from, and how much of a beat to
|
||||
// leave before it moves, so that an auto-finish cascades rather than teleporting.
|
||||
function planOf(events) {
|
||||
var origins = {}, delays = {}, at = 0;
|
||||
(events || []).forEach(function (e) {
|
||||
(e.cards || []).forEach(function (c) {
|
||||
if (e.kind === "draw") origins[c.label] = "draw";
|
||||
if (e.kind === "flip") origins[c.label] = "flip";
|
||||
delays[c.label] = at;
|
||||
});
|
||||
if (e.kind === "move" || e.kind === "home") at += STEP_MS;
|
||||
});
|
||||
return { origins: origins, delays: delays };
|
||||
}
|
||||
|
||||
// animate plays every card from where it was to where it is.
|
||||
function animate(before, plan) {
|
||||
if (reduced) return Promise.resolve();
|
||||
var waits = [];
|
||||
|
||||
root.querySelectorAll(".pete-card[data-key]").forEach(function (el) {
|
||||
var key = el.dataset.key;
|
||||
var now = el.getBoundingClientRect();
|
||||
var was = before[key];
|
||||
var delay = plan.delays[key] || 0;
|
||||
var origin = plan.origins[key];
|
||||
|
||||
// A card that was already on the board: play it from its old place. This is
|
||||
// every ordinary move, and it is also what makes an eleven-card auto-finish
|
||||
// animate itself for free.
|
||||
if (was && !origin) {
|
||||
var dx = was.left - now.left;
|
||||
var dy = was.top - now.top;
|
||||
if (Math.abs(dx) < 0.5 && Math.abs(dy) < 0.5) return;
|
||||
waits.push(slide(el, dx, dy, delay));
|
||||
return;
|
||||
}
|
||||
|
||||
// A card that has just been turned over. Out of the stock it flies as well as
|
||||
// turns; in a column it turns where it lies.
|
||||
if (origin === "draw") {
|
||||
var from = before["#stock"];
|
||||
waits.push(slide(el, from.left - now.left, from.top - now.top, delay));
|
||||
waits.push(turn(el, delay));
|
||||
} else if (origin === "flip") {
|
||||
waits.push(turn(el, delay));
|
||||
}
|
||||
});
|
||||
|
||||
return Promise.all(waits);
|
||||
}
|
||||
|
||||
function slide(el, dx, dy, delay) {
|
||||
return el.animate(
|
||||
[{ transform: "translate(" + dx + "px," + dy + "px)" }, { transform: "none" }],
|
||||
{
|
||||
duration: MOVE_MS,
|
||||
delay: delay,
|
||||
easing: "cubic-bezier(0.22, 1, 0.36, 1)",
|
||||
fill: "backwards",
|
||||
}
|
||||
).finished.catch(noop);
|
||||
}
|
||||
|
||||
// The card turns over on its own axis. The wrapper is doing the travelling, so
|
||||
// this has to be the inner face or the two transforms would fight.
|
||||
function turn(el, delay) {
|
||||
var inner = el.querySelector(".pete-card-inner");
|
||||
return inner.animate(
|
||||
[{ transform: "rotateY(180deg)" }, { transform: "rotateY(0deg)" }],
|
||||
{ duration: MOVE_MS, delay: delay, easing: "cubic-bezier(0.4, 0, 0.2, 1)", fill: "backwards" }
|
||||
).finished.catch(noop);
|
||||
}
|
||||
|
||||
// The recycle is the one move where cards *leave* the board, so FLIP has nothing
|
||||
// to animate: they're gone from the new render before it can measure them. They
|
||||
// get their flight here instead, out of the old DOM, before it's replaced.
|
||||
function recycleOut() {
|
||||
if (reduced) return Promise.resolve();
|
||||
var to = stockEl.getBoundingClientRect();
|
||||
var waits = [];
|
||||
wasteEl.querySelectorAll(".pete-card").forEach(function (el, i) {
|
||||
var now = el.getBoundingClientRect();
|
||||
waits.push(
|
||||
el.animate(
|
||||
[
|
||||
{ transform: "none", opacity: 1 },
|
||||
{ transform: "translate(" + (to.left - now.left) + "px," + (to.top - now.top) + "px) rotateY(180deg)", opacity: 1 },
|
||||
],
|
||||
{ duration: 260, delay: i * 50, easing: "cubic-bezier(0.4, 0, 1, 1)", fill: "forwards" }
|
||||
).finished.catch(noop)
|
||||
);
|
||||
});
|
||||
return Promise.all(waits);
|
||||
}
|
||||
|
||||
function noop() {}
|
||||
|
||||
// A card reaching a foundation is the only move in this game that pays you, so
|
||||
// it's the only one that makes a noise about it.
|
||||
function flashHome(events) {
|
||||
if (reduced) return;
|
||||
var at = 0;
|
||||
(events || []).forEach(function (e) {
|
||||
if (e.kind !== "home" || !e.to) {
|
||||
if (e.kind === "move") at += STEP_MS;
|
||||
return;
|
||||
}
|
||||
var when = at + MOVE_MS;
|
||||
at += STEP_MS;
|
||||
setTimeout(function () {
|
||||
var pile = foundEl.querySelector('[data-pile="' + e.to + '"]');
|
||||
if (!pile) return;
|
||||
pile.classList.remove("pete-home-flash");
|
||||
void pile.offsetWidth; // restart the animation if it's still running
|
||||
pile.classList.add("pete-home-flash");
|
||||
}, when);
|
||||
});
|
||||
}
|
||||
|
||||
// ---- the money -------------------------------------------------------------
|
||||
|
||||
// bank moves the spot to what the server says the board is worth. Up is chips
|
||||
// out of the house's rack; down — a card taken back off a foundation — is chips
|
||||
// going back to it. Either way the pile moves before the number does.
|
||||
function bank(pays) {
|
||||
var delta = (pays || 0) - spot.amount;
|
||||
if (delta === 0) return Promise.resolve();
|
||||
if (delta > 0) return spot.pour(houseEl, delta, { gap: 55 });
|
||||
return spot.sweep(houseEl, -delta, { gap: 40, lift: 0.6, fade: true });
|
||||
}
|
||||
|
||||
// ---- picking cards up ------------------------------------------------------
|
||||
|
||||
function mark() {
|
||||
root.querySelectorAll('[data-held="1"]').forEach(function (el) { delete el.dataset.held; });
|
||||
root.querySelectorAll('[data-drop="1"]').forEach(function (el) { delete el.dataset.drop; });
|
||||
if (!held) return;
|
||||
|
||||
// The run in your hand lifts off the felt.
|
||||
root.querySelectorAll('.pete-card[data-pile="' + held.pile + '"]').forEach(function (el) {
|
||||
if (held.pile === "waste" || held.pile.charAt(0) === "f") {
|
||||
if (el.dataset.live === "1") el.dataset.held = "1";
|
||||
} else if (parseInt(el.dataset.idx, 10) >= held.idx) {
|
||||
el.dataset.held = "1";
|
||||
}
|
||||
});
|
||||
|
||||
// And everywhere it could go lights up. This is the whole reason the rules are
|
||||
// mirrored over here: being shown where a card goes is the game teaching you,
|
||||
// and being told no after you commit is the game scolding you.
|
||||
root.querySelectorAll("[data-pile]").forEach(function (el) {
|
||||
var pile = el.dataset.pile;
|
||||
if (pile === held.pile || pile === "waste" || el.classList.contains("pete-card")) return;
|
||||
if (accepts(pile, held.cards)) el.dataset.drop = "1";
|
||||
});
|
||||
}
|
||||
|
||||
function pick(pile, idx) {
|
||||
var cs = cardsAt(pile, idx);
|
||||
if (!cs || !isRun(cs)) return;
|
||||
held = { pile: pile, idx: idx, count: cs.length, cards: cs };
|
||||
mark();
|
||||
}
|
||||
|
||||
function drop() {
|
||||
held = null;
|
||||
mark();
|
||||
}
|
||||
|
||||
function nope(el) {
|
||||
if (!el || reduced) return;
|
||||
el.classList.remove("pete-nope");
|
||||
void el.offsetWidth;
|
||||
el.classList.add("pete-nope");
|
||||
}
|
||||
|
||||
// A click on the board. The order matters: if something is in your hand and the
|
||||
// thing you clicked will take it, that's a move — otherwise it's you picking up
|
||||
// something else. Which means you never have to put a card down before choosing
|
||||
// a different one.
|
||||
root.querySelector(".pete-felt").addEventListener("click", function (e) {
|
||||
if (busy || !board || board.phase !== "playing") return;
|
||||
if (e.target.closest("[data-stock]")) return; // the stock has its own handler
|
||||
|
||||
var pileEl = e.target.closest("[data-pile]");
|
||||
if (!pileEl) { drop(); return; }
|
||||
|
||||
var cardEl = e.target.closest(".pete-card[data-key]");
|
||||
var pile = pileEl.dataset.pile;
|
||||
|
||||
if (held) {
|
||||
if (pile === held.pile) { drop(); return; } // clicking your own run puts it down
|
||||
if (accepts(pile, held.cards)) {
|
||||
var move = { kind: "move", from: held.pile, to: pile, count: held.count };
|
||||
drop();
|
||||
send(move);
|
||||
return;
|
||||
}
|
||||
// Not a place it goes. If what you clicked is a card you *could* pick up,
|
||||
// this was a change of mind rather than a bad move; only shake at a genuine
|
||||
// dead end.
|
||||
if (!cardEl || cardEl.dataset.live !== "1") { nope(pileEl); return; }
|
||||
}
|
||||
|
||||
if (cardEl && cardEl.dataset.live === "1") {
|
||||
pick(pile, parseInt(cardEl.dataset.idx, 10));
|
||||
} else {
|
||||
drop();
|
||||
}
|
||||
});
|
||||
|
||||
// Double-click sends a card home. It's the idiom every solitaire has used for
|
||||
// thirty years, and the alternative is asking the player which foundation — a
|
||||
// question with exactly one right answer.
|
||||
root.addEventListener("dblclick", function (e) {
|
||||
if (busy || !board || board.phase !== "playing") return;
|
||||
var cardEl = e.target.closest('.pete-card[data-live="1"]');
|
||||
if (!cardEl) return;
|
||||
var pile = cardEl.dataset.pile;
|
||||
if (pile.charAt(0) === "f") return; // it's already home
|
||||
e.preventDefault();
|
||||
drop();
|
||||
send({ kind: "home", from: pile });
|
||||
});
|
||||
|
||||
stockEl.addEventListener("click", function () {
|
||||
if (busy || !board || board.phase !== "playing") return;
|
||||
if (stockEl.dataset.dead === "1") {
|
||||
say(gameMsg, "That was your last pass through the stock.", "bad");
|
||||
nope(stockEl);
|
||||
return;
|
||||
}
|
||||
drop();
|
||||
send({ kind: "draw" });
|
||||
});
|
||||
|
||||
autoBtn.addEventListener("click", function () { drop(); send({ kind: "auto" }); });
|
||||
|
||||
cashBtn.addEventListener("click", function () {
|
||||
drop();
|
||||
send({ kind: "concede" });
|
||||
});
|
||||
|
||||
document.addEventListener("keydown", function (e) {
|
||||
if (e.metaKey || e.ctrlKey || e.altKey) return;
|
||||
if (/^(input|textarea|select)$/i.test(e.target.tagName || "")) return;
|
||||
if (e.key === "Escape") { drop(); return; }
|
||||
if (busy || !board || board.phase !== "playing") return;
|
||||
|
||||
var k = e.key.toLowerCase();
|
||||
if (k === " " || k === "d") { e.preventDefault(); stockEl.click(); }
|
||||
else if (k === "a" && !autoBtn.disabled) { e.preventDefault(); autoBtn.click(); }
|
||||
});
|
||||
|
||||
// ---- talking to the table --------------------------------------------------
|
||||
|
||||
var VERDICTS = {
|
||||
cleared: "Cleared the board! 🎉",
|
||||
cashed: "Board cashed.",
|
||||
};
|
||||
|
||||
function verdict(v) {
|
||||
var text = VERDICTS[v.outcome] || "";
|
||||
if (!text) { verdictEl.classList.add("hidden"); return; }
|
||||
if (v.net > 0) text += " +" + v.net.toLocaleString();
|
||||
else if (v.net < 0) text += " " + v.net.toLocaleString();
|
||||
verdictEl.textContent = text;
|
||||
verdictEl.classList.remove("hidden");
|
||||
// Clearing 52 cards out of a Vegas deal is the rarest thing that happens in
|
||||
// this room, so it's the one that gets the confetti.
|
||||
if (v.outcome === "cleared") FX.burst(verdictEl, { count: 40 });
|
||||
}
|
||||
|
||||
// play walks a server response onto the felt: the board is re-rendered, the
|
||||
// cards animate from where they were, and the chips follow.
|
||||
//
|
||||
// `money` — the chip bar catching up — is held back on a *settling* board until
|
||||
// the payout has physically swept home. A counter that pays you before the chips
|
||||
// arrive is a counter that has told you the ending.
|
||||
function play(view, money) {
|
||||
var v = view.solitaire;
|
||||
var events = view.sol_events || [];
|
||||
var settles = !!v && v.phase === "done";
|
||||
var recycled = events.some(function (e) { return e.kind === "recycle"; });
|
||||
|
||||
var pre = recycled ? recycleOut() : Promise.resolve();
|
||||
|
||||
return pre
|
||||
.then(function () {
|
||||
var before = snapshot();
|
||||
render(v);
|
||||
var plan = planOf(events);
|
||||
flashHome(events);
|
||||
return animate(before, plan);
|
||||
})
|
||||
.then(function () {
|
||||
if (!v) { money(); return; }
|
||||
return bank(v.stands).then(function () {
|
||||
if (!settles) { money(); return; }
|
||||
// The board is finished. Everything banked comes home, and only then
|
||||
// does the number in the bar move.
|
||||
verdict(v);
|
||||
return wait(300)
|
||||
.then(function () { return spot.sweep(purseEl, v.payout, { gap: 40, lift: 0.8 }); })
|
||||
.then(money)
|
||||
.then(function () { controls(null); showBet(); });
|
||||
});
|
||||
});
|
||||
}
|
||||
|
||||
function send(move) {
|
||||
if (busy) return;
|
||||
busy = true;
|
||||
say(gameMsg, "");
|
||||
return window.PeteGames.post("/api/games/solitaire/move", move)
|
||||
.then(function (view) { return play(view, function () { window.PeteGames.apply(view); }); })
|
||||
.catch(function (err) {
|
||||
say(gameMsg, err.message, "bad");
|
||||
// Whatever this file thought the board was, the server is the authority on
|
||||
// it. Ask, and draw what it says.
|
||||
return window.PeteGames.refresh().then(function (v) {
|
||||
if (v) { render(v.solitaire || null); spot.render(v.solitaire ? v.solitaire.stands : 0); }
|
||||
});
|
||||
})
|
||||
.then(function () { busy = false; });
|
||||
}
|
||||
|
||||
// ---- buying a deck ---------------------------------------------------------
|
||||
|
||||
function showBet() {
|
||||
betAmountEl.textContent = bet.toLocaleString();
|
||||
var money = window.PeteGames.view();
|
||||
startBtn.disabled = bet <= 0 || !tier || !money || money.chips < bet;
|
||||
}
|
||||
|
||||
root.querySelectorAll("[data-tier]").forEach(function (btn) {
|
||||
btn.addEventListener("click", function () {
|
||||
tier = btn.dataset.tier;
|
||||
root.querySelectorAll("[data-tier]").forEach(function (b) {
|
||||
b.dataset.on = b === btn ? "1" : "0";
|
||||
});
|
||||
showBet();
|
||||
});
|
||||
});
|
||||
|
||||
// The chip you click is the chip that flies. It lands on the spot in the rail,
|
||||
// which is where the price of the deck is stacked up before you pay it.
|
||||
root.querySelectorAll("[data-chip]").forEach(function (btn) {
|
||||
if (!btn.dataset.chip || btn.tagName !== "BUTTON") return;
|
||||
btn.addEventListener("click", function () {
|
||||
if (busy) return;
|
||||
var d = parseInt(btn.dataset.chip, 10);
|
||||
var money = window.PeteGames.view();
|
||||
if (money && bet + d > money.chips) {
|
||||
say(tableMsg, "You haven't got that many chips.", "bad");
|
||||
return;
|
||||
}
|
||||
bet += d;
|
||||
showBet();
|
||||
|
||||
var target = bet;
|
||||
spot.amount = bet;
|
||||
FX.fly(btn, spotEl, { denom: d }).then(function () {
|
||||
if (bet >= target) spot.render(target); // unless Clear got there first
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
root.querySelector("[data-bet-clear]").addEventListener("click", function () {
|
||||
if (busy) return;
|
||||
if (spot.amount) spot.sweep(purseEl, null, { gap: 40, lift: 0.7 });
|
||||
bet = 0;
|
||||
showBet();
|
||||
});
|
||||
|
||||
startBtn.addEventListener("click", function () {
|
||||
if (busy) return;
|
||||
if (!tier) { say(tableMsg, "Pick a deal first.", "bad"); return; }
|
||||
if (bet <= 0) { say(tableMsg, "Put something down for the deck.", "bad"); return; }
|
||||
|
||||
busy = true;
|
||||
say(tableMsg, "");
|
||||
var price = bet;
|
||||
|
||||
window.PeteGames.post("/api/games/solitaire/start", { bet: price, tier: tier })
|
||||
.then(function (view) {
|
||||
// The deck is *bought*: the chips on the spot go across to the house and
|
||||
// do not come back. Then the spot starts again at nothing, and from here
|
||||
// on it holds what the board has earned back.
|
||||
return spot
|
||||
.sweep(houseEl, price, { gap: 45, lift: 0.6 })
|
||||
.then(function () {
|
||||
bet = 0;
|
||||
showBet();
|
||||
window.PeteGames.apply(view);
|
||||
return dealOut(view.solitaire);
|
||||
});
|
||||
})
|
||||
.catch(function (err) {
|
||||
say(tableMsg, err.message, "bad");
|
||||
return window.PeteGames.refresh();
|
||||
})
|
||||
.then(function () { busy = false; });
|
||||
});
|
||||
|
||||
// dealOut lays the board and flies every card onto it out of the stock, one at a
|
||||
// time, across the columns — the way a deal actually goes down.
|
||||
function dealOut(v) {
|
||||
render(v);
|
||||
if (reduced || !v) return Promise.resolve();
|
||||
|
||||
var from = stockEl.getBoundingClientRect();
|
||||
var waits = [];
|
||||
|
||||
// The order a real deal goes in: one card to each column, then round again,
|
||||
// starting a column further along each time.
|
||||
var order = 0;
|
||||
for (var row = 0; row < 7; row++) {
|
||||
for (var col = row; col < 7; col++) {
|
||||
var colEl = tableauEl.children[col];
|
||||
var cardEl = colEl.children[row];
|
||||
if (!cardEl) continue;
|
||||
var now = cardEl.getBoundingClientRect();
|
||||
waits.push(slide(cardEl, from.left - now.left, from.top - now.top, order * 34));
|
||||
if (cardEl.dataset.face === "up") waits.push(turn(cardEl, order * 34));
|
||||
order++;
|
||||
}
|
||||
}
|
||||
return Promise.all(waits);
|
||||
}
|
||||
|
||||
// ---- coming in ------------------------------------------------------------
|
||||
|
||||
// The money bar owns the first fetch. The table picks up whatever it found —
|
||||
// including a board left mid-game by a reload or a redeploy, which comes back
|
||||
// exactly as it was, right down to what it has banked.
|
||||
var resumed = false;
|
||||
window.PeteGames.onUpdate(function (v) {
|
||||
if (!resumed) {
|
||||
resumed = true;
|
||||
if (v.solitaire) {
|
||||
render(v.solitaire);
|
||||
spot.render(v.solitaire.stands);
|
||||
} else {
|
||||
controls(null);
|
||||
}
|
||||
}
|
||||
showBet();
|
||||
});
|
||||
})();
|
||||
@@ -127,6 +127,7 @@
|
||||
|
||||
{{define "scripts"}}
|
||||
<script src="/static/js/casino-fx.js" defer></script>
|
||||
<script src="/static/js/casino-cards.js" defer></script>
|
||||
<script src="/static/js/games.js" defer></script>
|
||||
<script src="/static/js/blackjack.js" defer></script>
|
||||
{{end}}
|
||||
|
||||
@@ -58,6 +58,22 @@
|
||||
</p>
|
||||
</a>
|
||||
|
||||
<a href="/games/solitaire"
|
||||
class="group rounded-3xl bg-[color:var(--card)] p-6 shadow-pete border-2 border-[color:var(--ink)]/10 hover:-translate-y-0.5 hover:shadow-pete-lg transition">
|
||||
<div class="flex items-center gap-3">
|
||||
<span class="grid h-12 w-12 shrink-0 place-items-center rounded-2xl bg-[color:var(--accent)]/25 text-2xl">🂡</span>
|
||||
<div class="min-w-0">
|
||||
<h3 class="font-display text-xl font-bold">Solitaire</h3>
|
||||
<p class="text-sm text-[color:var(--ink)]/60">Buy the deck, win it back a card at a time.</p>
|
||||
</div>
|
||||
<span class="ml-auto shrink-0 rounded-full bg-theme-gaming px-3 py-1 text-xs font-bold uppercase tracking-wider text-white">Open</span>
|
||||
</div>
|
||||
<p class="mt-4 text-sm text-[color:var(--ink)]/70">
|
||||
Vegas rules. Your stake buys the deck and doesn't come back — every card you
|
||||
get home pays a slice of it in. Cash the board whenever you like.
|
||||
</p>
|
||||
</a>
|
||||
|
||||
{{range .Soon}}
|
||||
<div class="rounded-3xl bg-[color:var(--card)]/60 p-6 shadow-pete border-2 border-dashed border-[color:var(--ink)]/15">
|
||||
<div class="flex items-center gap-3">
|
||||
|
||||
168
internal/web/templates/solitaire.html
Normal file
168
internal/web/templates/solitaire.html
Normal file
@@ -0,0 +1,168 @@
|
||||
{{define "title"}}Solitaire · {{.Room.Name}}{{end}}
|
||||
|
||||
{{define "main"}}
|
||||
<div class="space-y-6" data-solitaire>
|
||||
|
||||
<div class="flex flex-wrap items-center justify-between gap-3">
|
||||
<div class="flex items-center gap-3 min-w-0">
|
||||
<a href="/games" class="grid h-10 w-10 shrink-0 place-items-center rounded-full bg-[color:var(--card)] shadow-pete border-2 border-[color:var(--ink)]/10 hover:bg-[color:var(--ink)]/5 transition" title="Back to the casino">
|
||||
<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="h-5 w-5" aria-hidden="true">
|
||||
<path d="M19 12H5"></path><polyline points="12 19 5 12 12 5"></polyline>
|
||||
</svg>
|
||||
<span class="sr-only">Back to the casino</span>
|
||||
</a>
|
||||
<h1 class="font-display text-3xl font-bold">Solitaire</h1>
|
||||
</div>
|
||||
<p class="text-sm text-[color:var(--ink)]/50">You buy the deck. Every card you get home buys some of it back.</p>
|
||||
</div>
|
||||
|
||||
{{template "_chipbar" .}}
|
||||
|
||||
<!-- The felt. The board takes the room; the money lives in a rail down the
|
||||
right of it, where the house rack can't collide with the foundations. -->
|
||||
<section class="pete-felt pete-solitaire relative overflow-hidden rounded-3xl p-4 sm:p-6 lg:p-8 shadow-pete-lg border-2 border-[color:var(--ink)]/10">
|
||||
<div class="grid gap-6 lg:grid-cols-[minmax(0,1fr),auto] lg:gap-8">
|
||||
|
||||
<!-- The board. -->
|
||||
<div class="min-w-0 space-y-4 sm:space-y-6">
|
||||
|
||||
<!-- The stock and the waste on the left, the foundations on the right,
|
||||
exactly where a real layout puts them. -->
|
||||
<div class="flex items-start justify-between gap-3">
|
||||
<div class="flex items-start gap-2 sm:gap-3">
|
||||
<button type="button" data-stock class="pete-slot pete-stock" aria-label="Turn over the stock">
|
||||
<span data-stock-count class="pete-slot-count">0</span>
|
||||
<span data-stock-recycle class="pete-slot-recycle hidden" aria-hidden="true">
|
||||
<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.5" stroke-linecap="round" stroke-linejoin="round">
|
||||
<path d="M3 12a9 9 0 0 1 15-6.7L21 8"></path><polyline points="21 3 21 8 16 8"></polyline>
|
||||
<path d="M21 12a9 9 0 0 1-15 6.7L3 16"></path><polyline points="3 21 3 16 8 16"></polyline>
|
||||
</svg>
|
||||
</span>
|
||||
</button>
|
||||
<div data-waste class="pete-waste" aria-label="The waste"></div>
|
||||
</div>
|
||||
|
||||
<div data-foundations class="flex items-start gap-1.5 sm:gap-2" aria-label="The foundations"></div>
|
||||
</div>
|
||||
|
||||
<!-- The seven columns. -->
|
||||
<div data-tableau class="pete-tableau" aria-label="The tableau"></div>
|
||||
|
||||
<!-- What just happened. -->
|
||||
<div class="flex min-h-[2.75rem] items-center">
|
||||
<p data-verdict class="hidden rounded-full bg-white/95 px-5 py-2 font-display text-lg font-bold text-[#2b2118] shadow-pete"></p>
|
||||
</div>
|
||||
</div>
|
||||
|
||||
<!-- The rail: the house's rack, what you've banked, and the meter that
|
||||
reads it. Everything the money does happens between these two. -->
|
||||
<aside class="pete-rail">
|
||||
<div class="pete-rack" data-at="rail" data-house aria-hidden="true">
|
||||
<span data-chip="500" style="--stack: 5"></span>
|
||||
<span data-chip="100" style="--stack: 7"></span>
|
||||
<span data-chip="25" style="--stack: 4"></span>
|
||||
<span data-chip="5" style="--stack: 6"></span>
|
||||
</div>
|
||||
|
||||
<div class="pete-spot" data-spot>
|
||||
<span class="pete-spot-label">Banked</span>
|
||||
<div class="pete-stack" data-stack></div>
|
||||
<span data-spot-total class="pete-spot-total hidden"></span>
|
||||
</div>
|
||||
|
||||
<div class="pete-meter w-full justify-center" data-meter>
|
||||
<span class="pete-meter-label">Home</span>
|
||||
<span data-home class="pete-meter-value">0<span class="text-white/40">/{{.FullDeck}}</span></span>
|
||||
</div>
|
||||
|
||||
<p class="text-center text-xs leading-relaxed text-white/55">
|
||||
<span data-per-card class="font-bold text-white/85">—</span> a card<br>
|
||||
<span data-break-even></span>
|
||||
</p>
|
||||
</aside>
|
||||
|
||||
</div>
|
||||
</section>
|
||||
|
||||
<!-- Playing: shown while a board is live. -->
|
||||
<section data-playing class="hidden rounded-3xl bg-[color:var(--card)] p-5 sm:p-6 shadow-pete border-2 border-[color:var(--ink)]/10">
|
||||
<div class="flex flex-wrap items-center gap-3">
|
||||
<button type="button" data-auto
|
||||
class="rounded-full bg-[color:var(--ink)]/5 px-5 py-2.5 font-display font-bold border-2 border-[color:var(--ink)]/10
|
||||
hover:bg-[color:var(--ink)]/10 active:translate-y-px disabled:opacity-40 disabled:pointer-events-none transition">
|
||||
Send home ⤴
|
||||
</button>
|
||||
|
||||
<p class="text-xs text-[color:var(--ink)]/45">
|
||||
Click a card, then where it goes. Double-click sends it home.
|
||||
</p>
|
||||
|
||||
<button type="button" data-cash
|
||||
class="ml-auto rounded-full bg-[color:var(--accent)] px-6 py-2.5 font-display font-bold text-white shadow-pete
|
||||
hover:brightness-105 active:translate-y-px disabled:opacity-40 disabled:pointer-events-none transition">
|
||||
Cash the board · <span data-cash-amount class="tabular-nums">0</span>
|
||||
</button>
|
||||
</div>
|
||||
<p data-game-msg class="hidden mt-3 rounded-2xl bg-[color:var(--ink)]/5 px-4 py-2 text-sm font-semibold"></p>
|
||||
</section>
|
||||
|
||||
<!-- Buying a deck: shown between games. -->
|
||||
<section data-betting class="rounded-3xl bg-[color:var(--card)] p-5 sm:p-6 shadow-pete border-2 border-[color:var(--ink)]/10">
|
||||
|
||||
<div class="text-xs font-semibold uppercase tracking-wider text-[color:var(--ink)]/50">Which deal?</div>
|
||||
<div class="mt-2 grid gap-2 sm:grid-cols-3">
|
||||
{{range .Deals}}
|
||||
<button type="button" data-tier="{{.Slug}}"
|
||||
class="pete-tier rounded-2xl border-2 p-3 text-left transition">
|
||||
<div class="flex items-baseline justify-between gap-2">
|
||||
<span class="font-display text-lg font-bold">{{.Name}}</span>
|
||||
<span class="font-display text-lg font-bold tabular-nums text-[color:var(--accent)]">{{printf "%.1f" .Base}}×</span>
|
||||
</div>
|
||||
<p class="mt-0.5 text-xs text-[color:var(--ink)]/50">{{.Blurb}}</p>
|
||||
<p class="mt-1.5 text-xs font-semibold text-[color:var(--ink)]/40">
|
||||
Square with the house at {{.BreakEven}} cards home.
|
||||
</p>
|
||||
</button>
|
||||
{{end}}
|
||||
</div>
|
||||
|
||||
<div class="mt-5 flex flex-wrap items-center gap-x-6 gap-y-4">
|
||||
<div>
|
||||
<div class="text-xs font-semibold uppercase tracking-wider text-[color:var(--ink)]/50">The deck costs</div>
|
||||
<div class="font-display text-3xl font-bold tabular-nums"><span data-bet-amount>0</span></div>
|
||||
</div>
|
||||
|
||||
<div class="flex flex-wrap items-center gap-2">
|
||||
{{range .Denominations}}
|
||||
<button type="button" data-chip="{{.}}" aria-label="Put {{.}} more down"
|
||||
class="pete-chip pete-disc grid h-12 w-12 place-items-center font-display text-sm font-bold text-white">
|
||||
<span>{{.}}</span>
|
||||
</button>
|
||||
{{end}}
|
||||
<button type="button" data-bet-clear
|
||||
class="rounded-full px-3 py-2 text-sm font-semibold text-[color:var(--ink)]/50 hover:text-[color:var(--ink)] transition">Clear</button>
|
||||
</div>
|
||||
|
||||
<button type="button" data-start
|
||||
class="ml-auto rounded-full bg-[color:var(--accent)] px-8 py-3 font-display text-lg font-bold text-white shadow-pete
|
||||
hover:brightness-105 active:translate-y-px disabled:opacity-40 disabled:pointer-events-none transition">
|
||||
Buy the deck
|
||||
</button>
|
||||
</div>
|
||||
<p class="mt-3 text-xs text-[color:var(--ink)]/40">
|
||||
The stake buys the deck outright, so it doesn't come back. What comes back is
|
||||
whatever you get home, a fifty-second of the multiple at a time. Stop whenever
|
||||
you like and keep it. There's no undo.
|
||||
</p>
|
||||
<p data-table-msg class="hidden mt-3 rounded-2xl bg-[color:var(--ink)]/5 px-4 py-2 text-sm font-semibold"></p>
|
||||
</section>
|
||||
|
||||
</div>
|
||||
{{end}}
|
||||
|
||||
{{define "scripts"}}
|
||||
<script src="/static/js/casino-fx.js" defer></script>
|
||||
<script src="/static/js/casino-cards.js" defer></script>
|
||||
<script src="/static/js/games.js" defer></script>
|
||||
<script src="/static/js/solitaire.js" defer></script>
|
||||
{{end}}
|
||||
Reference in New Issue
Block a user