[{"_1":2,"_168":-5,"_169":-5},"loaderData",{"_3":4,"_91":92},"root",{"_5":6,"_34":35,"_64":65},"ctx",{"_7":8,"_23":-5,"_24":25,"_26":27,"_28":20,"_29":20,"_30":20,"_31":32,"_33":20},"auth",{"_9":-5,"_10":-5,"_11":-5,"_12":-5,"_13":-5,"_14":-5,"_15":-5,"_16":-5,"_17":-5,"_18":-5,"_19":20,"_21":22},"sessionClaims","sessionId","sessionStatus","userId","actor","orgId","orgRole","orgSlug","orgPermissions","factorVerificationAge","isAuthenticated",false,"tokenType","session_token","user","preferencesKeybindings","default","preferencesTheme","light","preferencesFixers","preferencesCopilot","preferencesSelectionAi","notificationCount",0,"flagDenols","ENV",{"_36":37,"_38":39,"_40":41,"_42":43,"_44":45,"_46":47,"_48":49,"_50":51,"_52":53,"_54":55,"_56":57,"_58":59,"_60":61,"_62":63},"REACT_APP_SENTRY_DSN","https://586020d86f05489db63a554690acf1e9@o1398359.ingest.sentry.io/6724499","VAL_RUNTIME_NAME","prod","RENDER_GIT_COMMIT","230fbbe1911b69d46be82b6db4e617b331d282a6","RENDER_GIT_BRANCH","main","CLERK_PUBLISHABLE_KEY","pk_live_Y2xlcmsudmFsLnRvd24k","POSTHOG_API_TOKEN","phc_nmoyuAkStEZuUp69rYlg1DZgrIt19Gx0Y4Hwf8tGgJP","POSTHOG_API_HOST","https://wart.val.town","WEB_API_TEMPLATE","https://{val}.web.val.run","APP_URL","https://www.val.town","MODULE_URL","https://esm.town","VANITY_WEB_API_TEMPLATE","https://{label}.val.run/","DENOLS_URL","https://lsp.val.town","NODE_ENV","production","API_URL","https://api.val.town","clerkState",{"_66":67},"__internal_clerk_state",{"_68":69,"_70":45,"_71":72,"_73":72,"_74":20,"_75":72,"_76":72,"_77":72,"_78":72,"_79":80,"_89":20,"_90":20},"__clerk_ssr_state",{"_21":22,"_9":-5,"_10":-5,"_11":-5,"_12":-5,"_13":-5,"_14":-5,"_15":-5,"_16":-5,"_17":-5,"_18":-5,"_19":20},"__publishableKey","__proxyUrl","","__domain","__isSatellite","__signInUrl","__signUpUrl","__afterSignInUrl","__afterSignUpUrl","__clerk_debug",{"_81":20,"_19":20,"_82":72,"_83":84,"_85":72,"_86":45,"_87":20,"_88":72},"isSignedIn","proxyUrl","reason","session-token-and-uat-missing","message","publishableKey","isSatellite","domain","__telemetryDisabled","__telemetryDebug","routes/embed.x.$handle.$name.$",{"_93":94,"_95":96,"_97":98,"_99":100,"_147":148,"_165":166,"_167":-5},"handle","saolsen","name","gameplay_poker","path","main.tsx","project",{"_101":102,"_95":96,"_103":104,"_105":-5,"_106":107,"_108":109,"_110":-5,"_111":-5,"_12":112,"_113":-5,"_114":107,"_115":-5,"_116":32,"_14":117,"_118":119,"_120":119,"_121":122,"_123":122,"_124":122,"_125":119,"_126":119,"_23":127,"_130":131,"_133":134,"_146":20},"id","ae616736-27ac-11f0-9edc-569c3dd06744","createdAt",["D",1746228306194],"deletedAt","legacyEnvVars",true,"privacy","public","description","imageUrl","e1269f9c-67ab-446c-9c3f-debdc882a7b8","pinnedFileId","pinPreview","screenshotVersion","likeCount","6af58753-71c6-4397-9d5b-2473eb888976","userPerm","r","valPerm","blobPerm","rw","emailPerm","sqlitePerm","projectPerm","telemetryPerm",{"_93":94,"_128":129},"profileImageUrl","https://images.clerk.dev/oauth_github/img_2QtXHzN3gDPhKsBOvKsst8LTxC5.png","org",{"_93":94,"_132":129},"avatar","branch",{"_135":136,"_95":43,"_101":137,"_138":102,"_139":-5,"_140":-5,"_141":-5,"_142":-5,"_143":-5,"_144":96,"_145":94},"version",6,"ae61a610-27ac-11f0-9edc-569c3dd06744","projectId","forkedBranchId","forkedBranchVersion","forkedProjectPrivacy","forkedProjectId","forkedProjectOrgId","projectName","userHandle","isOwned","file",{"_101":149,"_95":98,"_150":151,"_152":-5,"_153":137,"_154":136,"_155":107,"_103":156,"_135":157,"_158":159,"_160":161,"_162":20,"_163":-5,"_97":164},"ae9928d8-27ac-11f0-9edc-569c3dd06744","fileId","ae63d6f6-27ac-11f0-9edc-569c3dd06744","parentId","branchId","branchVersion","latest",["D",1714330784465],5,"fileType","script","content","/**\n * # Poker\n *\n * This module implements a game of poker.\n * The poker game is Texas Hold'em, a variant of poker where each player is\n * dealt two private cards and shares five community cards.\n * This variant is No-Limit 1/2, meaning there is no limit to the amount of\n * chips a player can bet, and there are blinds of 1 and 2 chips, which are the\n * forced bets for the first two players each round.\n *\n * Each player gets 100 chips to start the match. The match plays in a series of\n * rounds, each round is a hand of poker. The match continues until all players\n * except one are out of chips. The remaining player is the winner.\n *\n * * See {@link Poker} for the {@link Game} definition which links\n * to the {@link PokerState} type, the {@link PokerAction} type and the\n * update logic {@link checkAction}.\n *\n * @module\n */\n\nimport {\n type Game,\n GameError,\n GameErrorKind,\n GameKind,\n type Json,\n type JsonObject,\n type Player,\n ResultKind,\n type Status,\n StatusKind,\n Unreachable,\n} from \"https://esm.town/v/saolsen/gameplay_games\";\n\n/**\n * The ranks of the cards in a deck.\n */\nexport enum Rank {\n AceLow,\n Two,\n Three,\n Four,\n Five,\n Six,\n Seven,\n Eight,\n Nine,\n Ten,\n Jack,\n Queen,\n King,\n Ace,\n}\n\n/**\n * The suits of the playing cards.\n */\nexport enum Suit {\n Clubs,\n Diamonds,\n Hearts,\n Spades,\n}\n\n/**\n * A playing card.\n */\nexport interface Card extends JsonObject {\n /** The rank of the card. */\n rank: Rank;\n /** The suit of the card. */\n suit: Suit;\n}\n\n/**\n * The string names for {@link Rank} values.\n */\nexport const RANK_NAMES = [\n \"A\",\n \"2\",\n \"3\",\n \"4\",\n \"5\",\n \"6\",\n \"7\",\n \"8\",\n \"9\",\n \"10\",\n \"J\",\n \"Q\",\n \"K\",\n \"A\",\n];\n\n/**\n * The string names for {@link Suit} values.\n */\nexport const SUIT_NAMES = [\"♣\", \"♦\", \"♥\", \"♠\"];\n\n/**\n * Helper function to create a {@link Card} from a string.\n *\n * @param {string} s The string representation of the card.\n *\n * @returns {Card} The card.\n */\nexport function cardFromString(s: string): Card {\n const rank_s = s.slice(0, -1);\n const rank = RANK_NAMES.indexOf(rank_s);\n if (rank === -1) {\n throw new Error(`Invalid rank: ${rank_s}`);\n }\n const suit_s = s.slice(-1);\n const suit = SUIT_NAMES.indexOf(suit_s);\n if (suit === -1) {\n throw new Error(`Invalid suit: ${suit_s}`);\n }\n return { rank: rank as Rank, suit: suit as Suit };\n}\n\n/**\n * Helper function to create a string from a {@link Card}.\n *\n * @param {Card} c The card.\n *\n * @returns {string} The string representation of the card.\n */\nexport function cardToString(c: Card): string {\n return RANK_NAMES[c.rank] + SUIT_NAMES[c.suit];\n}\n\n/**\n * A standard deck of playing cards.\n * * The deck is ascending in order from \"2♣\" to \"A♠\"\n *\n * @returns {Card[]} A deck of cards.\n */\nexport function deck(): Card[] {\n const cards: Card[] = [];\n for (let rank: Rank = 0; rank <= Rank.Ace; rank++) {\n if (rank === Rank.AceLow) {\n continue;\n }\n for (let suit: Suit = 0; suit <= Suit.Spades; suit++) {\n cards.push({ rank, suit });\n }\n }\n return cards;\n}\n\n/**\n * Shuffle a deck of cards.\n * * The deck is shuffled in place.\n *\n * @param {Card[]} cards The deck of cards to shuffle.\n */\nexport function shuffle(cards: Card[]) {\n let i = cards.length;\n while (i !== 0) {\n const rand_i = Math.floor(Math.random() * i--);\n [cards[i], cards[rand_i]] = [cards[rand_i], cards[i]];\n }\n}\n\n/**\n * The different kinds of poker hands.\n * * Used to tag {@link Hand}.\n */\nexport enum HandKind {\n HighCard,\n OnePair,\n TwoPair,\n ThreeOfAKind,\n Straight,\n Flush,\n FullHouse,\n FourOfAKind,\n StraightFlush,\n}\n\n/**\n * A {@link Hand} without any pairs, straights or flushes.\n *\n * HighCard is the lowest possible hand.\n *\n * HighCard hands are ranked by their card ranks from highest to lowest.\n */\nexport interface HighCard {\n kind: HandKind.HighCard;\n /** The ranks of the cards in the hand, in descending order. */\n ranks: [Rank, Rank, Rank, Rank, Rank];\n}\n\n/**\n * A {@link Hand} with a single pair.\n *\n * OnePair hands are compared by their pair rank and then by the ranks of the\n * other cards in the hand from highest to lowest.\n */\nexport interface OnePair {\n kind: HandKind.OnePair;\n /** The rank of the pair. */\n two: Rank;\n /** The ranks of the other cards in the hand, in descending order. */\n ranks: [Rank, Rank, Rank];\n}\n\n/**\n * A {@link Hand} with two pairs.\n *\n * TwoPair hands are compared by their high pair rank, then by their low pair\n * rank, and then by the rank of the other card in the hand.\n */\nexport interface TwoPair {\n kind: HandKind.TwoPair;\n /** The rank of the higher ranked pair. */\n high_two: Rank;\n /**The rank of the lower ranked pair. */\n low_two: Rank;\n /** The rank of the other card in the hand. */\n other: Rank;\n}\n\n/**\n * A {@link Hand} with three of a kind.\n *\n * ThreeOfAKind hands are compared by their three of a kind rank and then by the\n * ranks of the other cards in the hand from highest to lowest.\n */\nexport interface ThreeOfAKind {\n kind: HandKind.ThreeOfAKind;\n /** The rank of the three of a kind. */\n three: Rank;\n /** The ranks of the other cards in the hand, in descending order. */\n ranks: [Rank, Rank];\n}\n\n/**\n * A {@link Hand} with a straight.\n *\n * Straight hands are compared by the rank of the cards in the straight from\n * highest to lowest.\n */\nexport interface Straight {\n kind: HandKind.Straight;\n /** The ranks of the cards in the straight, in descending order. */\n ranks: [Rank, Rank, Rank, Rank, Rank];\n}\n\n/**\n * A {@link Hand} with a flush.\n *\n * Flush hands are compared by the ranks of the cards in the flush from highest\n * to lowest.\n */\nexport interface Flush {\n kind: HandKind.Flush;\n /** The ranks of the cards in the flush, in descending order. */\n ranks: [Rank, Rank, Rank, Rank, Rank];\n}\n\n/**\n * A {@link Hand} with a full house (Three of a kind and a pair).\n *\n * FullHouse hands are compared by the rank of the three of a kind and then by\n * the rank of the pair.\n */\nexport interface FullHouse {\n kind: HandKind.FullHouse;\n /** The rank of the three of a kind. */\n three: Rank;\n /** The rank of the pair. */\n two: Rank;\n}\n\n/**\n * A {@link Hand} with four of a kind.\n *\n * FourOfAKind hands are compared by the rank of the four of a kind and then by\n * the rank of the other card in the hand.\n */\nexport interface FourOfAKind {\n kind: HandKind.FourOfAKind;\n /** The rank of the four of a kind. */\n four: Rank;\n /** The rank of the other card in the hand. */\n other: Rank;\n}\n\n/**\n * A {@link Hand} with a straight flush.\n *\n * StraightFlush hands are compared by the rank of the cards in the straight\n * flush from highest to lowest.\n */\nexport interface StraightFlush {\n kind: HandKind.StraightFlush;\n /** The ranks of the cards in the straight flush, in descending order. */\n ranks: [Rank, Rank, Rank, Rank, Rank];\n}\n\n/**\n * A poker hand represents and equivalence class of hands that have the same\n * score, rather than a specific set of 5 cards.\n *\n * For instance, two different sets of cards,\n *\n * `[\"A♠\", \"Q♠\", \"8♠\", \"10♠\", \"6♣\"]` and `[\"A♥\", \"Q♥\", \"10♥\", \"8♥\", \"6♣\"]`\n *\n * would both be represented by the same hand.\n *\n * ```ts\n * {\n * kind: HandKind.HighCard,\n * ranks: [\n * Rank.Ace,\n * Rank.Queen,\n * Rank.Ten,\n * Rank.Eight,\n * Rank.Six\n * ]\n * }\n * ```\n *\n * There are `2,598,960` distinct sets of `5` cards but there are only `7462`\n * distinct hands.\n */\nexport type Hand =\n | HighCard\n | OnePair\n | TwoPair\n | ThreeOfAKind\n | Straight\n | Flush\n | FullHouse\n | FourOfAKind\n | StraightFlush;\n\n/**\n * Function to compute the {@link Hand} of a list of 5 cards.\n *\n * @param {Card[]} cards The list of 5 cards.\n *\n * @returns {Hand} The hand of the cards.\n */\nexport function hand(cards: Card[]): Hand {\n if (cards.length !== 5) {\n throw new Error(`Invalid number of cards: ${cards.length}`);\n }\n if (new Set(cards).size !== 5) {\n throw new Error(\"Duplicate cards\");\n }\n\n cards.sort().reverse();\n let card_ranks = cards.map((c) => c.rank);\n const hand_ranks: Map = new Map();\n for (const card of cards) {\n const count = hand_ranks.get(card.rank) || 0;\n hand_ranks.set(card.rank, count + 1);\n }\n switch (hand_ranks.size) {\n case 5: {\n const is_flush = new Set(cards.map((c) => c.suit)).size === 1;\n if (\n JSON.stringify(card_ranks)\n === JSON.stringify([Rank.Ace, Rank.Five, Rank.Four, Rank.Three, Rank.Two])\n ) {\n card_ranks = [Rank.Five, Rank.Four, Rank.Three, Rank.Two, Rank.AceLow];\n }\n const is_straight = card_ranks[0] - card_ranks[4] === 4;\n const ranks = card_ranks as [Rank, Rank, Rank, Rank, Rank];\n if (is_flush && is_straight) {\n return { kind: HandKind.StraightFlush, ranks };\n }\n if (is_flush) {\n return { kind: HandKind.Flush, ranks };\n }\n if (is_straight) {\n return { kind: HandKind.Straight, ranks };\n }\n return { kind: HandKind.HighCard, ranks };\n }\n case 4: {\n let two: Rank | null = null;\n for (const [rank, count] of hand_ranks) {\n if (count === 2) {\n two = rank;\n break;\n }\n }\n const ranks = card_ranks.filter((r) => r !== two!) as [Rank, Rank, Rank];\n return { kind: HandKind.OnePair, two: two!, ranks };\n }\n case 3: {\n let three: Rank | null = null;\n const two_ranks: Rank[] = [];\n for (const [rank, count] of hand_ranks) {\n if (count === 3) {\n three = rank;\n break;\n }\n if (count === 2) {\n two_ranks.push(rank);\n }\n }\n if (three !== null) {\n const ranks = card_ranks.filter((r) => r !== three) as [Rank, Rank];\n return { kind: HandKind.ThreeOfAKind, three, ranks };\n }\n two_ranks.sort();\n const [low_two, high_two] = two_ranks;\n const other = card_ranks.find(\n (r) => r !== low_two && r !== high_two,\n ) as Rank;\n return { kind: HandKind.TwoPair, high_two, low_two, other };\n }\n case 2: {\n let four: Rank | null = null;\n let three: Rank | null = null;\n let two: Rank | null = null;\n for (const [rank, count] of hand_ranks) {\n if (count === 4) {\n four = rank;\n break;\n } else if (count === 3) {\n three = rank;\n } else if (count === 2) {\n two = rank;\n }\n }\n if (four !== null) {\n const other = card_ranks.find((r) => r !== four) as Rank;\n return { kind: HandKind.FourOfAKind, four, other };\n }\n return { kind: HandKind.FullHouse, three: three!, two: two! };\n }\n default: {\n throw new Error(\"Invalid number of ranks\");\n }\n }\n}\n\n/**\n * Helper function to compute a value for a {@link Hand} that can be compared\n * to other hands.\n *\n * This is used by {@link compareHands} to determine which hand is better.\n *\n * The value is an array of numbers where the first element is the kind of the\n * hand and the rest of the elements are the relevant ranks of the hand.\n *\n * Since hands are compared by their kind first, the returned list of\n * numbers can be different lengths depending on the kind of the hand. Only\n * if the kinds are the same will the rest of the ranks be compared.\n *\n * @param {Hand} hand The hand to compute the comparison value for.\n *\n * @returns {number[]} The comparison value for the hand.\n */\nexport function handRank(hand: Hand): number[] {\n const hand_rank: number[] = [hand.kind];\n switch (hand.kind) {\n case HandKind.HighCard:\n case HandKind.Straight:\n case HandKind.Flush:\n case HandKind.StraightFlush: {\n for (const rank of hand.ranks) {\n hand_rank.push(rank);\n }\n break;\n }\n case HandKind.OnePair: {\n hand_rank.push(hand.two);\n for (const rank of hand.ranks) {\n hand_rank.push(rank);\n }\n break;\n }\n case HandKind.TwoPair: {\n hand_rank.push(hand.high_two);\n hand_rank.push(hand.low_two);\n hand_rank.push(hand.other);\n break;\n }\n case HandKind.ThreeOfAKind: {\n hand_rank.push(hand.three);\n for (const rank of hand.ranks) {\n hand_rank.push(rank);\n }\n break;\n }\n case HandKind.FullHouse: {\n hand_rank.push(hand.three);\n hand_rank.push(hand.two);\n break;\n }\n case HandKind.FourOfAKind: {\n hand_rank.push(hand.four);\n hand_rank.push(hand.other);\n break;\n }\n default: {\n throw new Unreachable(hand);\n }\n }\n return hand_rank;\n}\n\n/**\n * Comparator function for {@link Hand} values.\n *\n * @param {Hand} a A hand to compare.\n * @param {Hand} b A hand to compare.\n *\n * @returns {number}\n * a negative number if a is better, a positive number if b is better,\n * and 0 if they are equal.\n */\nexport function compareHands(a: Hand, b: Hand): number {\n const a_rank = handRank(a);\n const b_rank = handRank(b);\n const length = Math.min(a_rank.length, b_rank.length);\n for (let i = 0; i < length; i++) {\n if (a_rank[i] < b_rank[i]) {\n return -1;\n } else if (a_rank[i] > b_rank[i]) {\n return 1;\n }\n }\n return 0;\n}\n\n/**\n * Computes the best hand from a list of 7 cards.\n *\n * Checks every possible combination of 5 cards from the 7 and returns the\n * hand with the highest value.\n *\n * @param {Card[]} cards The list of 7 cards.\n *\n * @returns {Hand} The best hand (made from 5 of them) from the cards.\n */\nexport function bestHand(cards: Card[]): Hand {\n console.assert(cards.length === 7);\n const hand_cards = [];\n for (let i = 0; i <= 2; i++) {\n for (let ii = i + 1; ii <= 3; ii++) {\n for (let iii = ii + 1; iii <= 4; iii++) {\n for (let iv = iii + 1; iv <= 5; iv++) {\n for (let v = iv + 1; v <= 6; v++) {\n const hand = [cards[i], cards[ii], cards[iii], cards[iv], cards[v]];\n hand_cards.push(hand);\n }\n }\n }\n }\n }\n console.assert(hand_cards.length === 21);\n return hand_cards.map(hand).sort(compareHands).reverse()[0];\n}\n\n/**\n * The different states of a player in a poker match.\n */\nexport enum RoundPlayerStatus {\n /** The player is still playing in this round. */\n Playing = \"playing\",\n /** The player has gone all in, they cannot take any more actions in this\n * round because they are out of chips to bet with.\n */\n AllIn = \"all-in\",\n /** The player has folded, they are out of this round. */\n Folded = \"folded\",\n /** The player is out of the match, they are out of chips. */\n Out = \"out\",\n}\n\n/**\n * The different stages of a round of poker.\n */\nexport enum RoundStage {\n /** The stage before any shared cards are dealt. */\n PreFlop = \"preflop\",\n /** The stage after the first three shared cards are dealt. */\n Flop = \"flop\",\n /** The stage after the fourth shared card is dealt. */\n Turn = \"turn\",\n /** The stage after the fifth shared card is dealt. */\n River = \"river\",\n /** The stage at the end of the round when all cards are revealed and the pot\n * is awarded to the winning players.\n */\n Showdown = \"showdown\",\n}\n\n/**\n * The state for a round of poker.\n *\n * The match is played in rounds, each round is a hand of poker.\n * The round progresses through the stages of preflop, flop, turn, river, and\n * showdown.\n * At the end of the round, the pot is awarded to the player with the best hand.\n * If there is a tie, the pot is split between the tied players.\n *\n * If there is only one player with chips after a round, they are the winner and\n * the match is over.\n *\n * Otherwise, the dealer button moves to the next player and a new round begins.\n */\nexport interface Round extends JsonObject {\n /** The stage of the round. */\n stage: RoundStage;\n /** The deck of cards for the round. */\n deck: Card[];\n /** The shared cards on the table. */\n table_cards: Card[];\n /** The current bet amount for the stage. This is the value players must call\n * to continue playing.\n */\n bet: number;\n /** The total amount of chips in the pot. */\n pot: number;\n /** The index of the {@link Player} that is the dealer. */\n dealer: number;\n /** The index of the active {@link Player} (the player who's turn it is). */\n active_player: number;\n /** The status of each player in the round, indexed by {@link Player} index. */\n player_status: RoundPlayerStatus[];\n /** The amount of chips each player has bet in the stage, indexed by\n * {@link Player} index.\n *\n * Chips stay in player_bets until the end of the stage when they are added to\n * the pot.\n */\n player_bets: number[];\n /** The private cards each player has, indexed by {@link Player} index. */\n player_cards: [Card, Card][];\n}\n\n/**\n * The state of a poker match.\n */\nexport interface PokerState extends JsonObject {\n /** poker */\n game: typeof GameKind.Poker;\n /** The amount of chips each player has. */\n player_chips: number[];\n /** The small and big blinds for the match. */\n blinds: [number, number];\n /** The index of the current {@link Round}. */\n round: number;\n /** The list of rounds in the match.\n * * `view.rounds[view.round]` is the current round.\n */\n rounds: Round[];\n}\n\n/**\n * The {@link Player} specific view of a round of poker.\n *\n * This view is used to show each player only their own private cards.\n * It hides the deck and other player's private cards.\n */\nexport interface RoundView extends JsonObject {\n /** The stage of the round. */\n stage: RoundStage;\n /** The shared cards on the table. */\n table_cards: Card[];\n /** The current bet amount for the stage. This is the value players must call\n * to continue playing.\n */\n bet: number;\n /** The total amount of chips in the pot. */\n pot: number;\n /** The index of the {@link Player} that is the dealer. */\n dealer: number;\n /** The index of the active {@link Player} (the player who's turn it is). */\n active_player: number;\n /** The status of each player in the round, indexed by {@link Player} index. */\n player_status: RoundPlayerStatus[];\n /** The amount of chips each player has bet in the stage, indexed by\n * {@link Player} index.\n *\n * Chips stay in player_bets until the end of the stage when they are added to\n * the pot.\n */\n player_bets: number[];\n /** The private cards for the {@link Player} */\n my_cards: [Card, Card];\n}\n\n/**\n * The {@link Player} specific view of a poker match.\n *\n * This view is used to show each player only their own private cards.\n * It hides the deck and other player's private cards.\n */\nexport interface PokerView extends JsonObject {\n /** poker */\n game: typeof GameKind.Poker;\n /** The amount of chips each player has. */\n player_chips: number[];\n /** The small and big blinds for the match. */\n blinds: [number, number];\n /** The index of the current {@link Round}. */\n round: number;\n /** The list of rounds in the match.\n * * `view.rounds[view.round]` is the current round.\n */\n rounds: RoundView[];\n}\n\n/**\n * The different kinds of actions a player can take in a round of poker.\n * * Used to tag {@link PokerAction}.\n */\nexport enum PokerActionKind {\n /** The player folds, they are out of the round. */\n Fold = \"fold\",\n /** The player checks, they do not bet any chips. */\n Check = \"check\",\n /** The player bets an amount of chips. */\n Bet = \"bet\",\n /** The player adds chips up to current bet amount. */\n Call = \"call\",\n /** The player adds chips up to current bet amount and then\n * some additional chips to raise the bet.\n */\n Raise = \"raise\",\n}\n\n/**\n * The player folds, they are out of the round.\n */\nexport interface FoldAction extends JsonObject {\n kind: typeof PokerActionKind.Fold;\n}\n\n/** The player checks, they do not bet any chips. */\nexport interface CheckAction extends JsonObject {\n kind: typeof PokerActionKind.Check;\n}\n\n/** The player bets an amount of chips. */\nexport interface BetAction extends JsonObject {\n kind: typeof PokerActionKind.Bet;\n /** The amount of chips to bet. */\n amount: number;\n}\n\n/** The player adds chips up to current bet amount. */\nexport interface CallAction extends JsonObject {\n kind: typeof PokerActionKind.Call;\n}\n\n/** The player adds chips up to current bet amount and then some additional\n * chips to raise the bet.\n */\nexport interface RaiseAction extends JsonObject {\n kind: typeof PokerActionKind.Raise;\n /** The amount of chips to raise the bet by.\n * * The total amount of chips bet will be the amount needed to call + this\n * amount.\n */\n amount: number;\n}\n\n/**\n * A player action in a round of poker.\n */\nexport type PokerAction =\n | FoldAction\n | CheckAction\n | BetAction\n | CallAction\n | RaiseAction;\n\n/**\n * The arguments to create a Poker game.\n */\nexport interface PokerArgs {\n /** The players of the game.\n * * Must have at least 2 players.\n */\n players: Player[];\n}\n\n/**\n * Function to create a new Poker game.\n *\n * @param {PokerArgs} args The arguments to create the game.\n *\n * @returns {[PokerState, Status] | GameError}\n * The initial gamestate and the status of the game,\n * or an error if the arguments are invalid.\n */\nexport function newGame(\n args: PokerArgs,\n): [PokerState, Status] | GameError {\n const { players } = args;\n if (players.length < 2) {\n return new GameError(\n GameErrorKind.Args,\n \"Poker requires at least 2 players.\",\n );\n }\n\n const round_deck = deck();\n shuffle(round_deck);\n\n const player_status: RoundPlayerStatus[] = [];\n const player_chips: number[] = [];\n const player_bets: number[] = [];\n const player_cards: [Card, Card][] = [];\n\n for (let i = 0; i < players.length; i++) {\n player_status.push(RoundPlayerStatus.Playing);\n player_chips.push(100);\n player_bets.push(0);\n player_cards.push([round_deck.pop()!, round_deck.pop()!]);\n }\n\n let bet = 0;\n let active_player = 1;\n\n const round_blinds = players.length === 2 ? [2, 1] : [1, 2];\n const small_blind = Math.min(player_chips[active_player], round_blinds[0]);\n player_chips[active_player] -= small_blind;\n player_bets[active_player] += small_blind;\n bet = small_blind;\n\n active_player = playerAfter(active_player, player_status)!;\n\n const big_blind = Math.min(player_chips[active_player], round_blinds[1]);\n player_chips[active_player] -= big_blind;\n player_bets[active_player] += big_blind;\n bet = Math.max(small_blind, big_blind);\n\n active_player = playerAfter(active_player, player_status)!;\n\n return [{\n game: GameKind.Poker,\n player_chips,\n blinds: [1, 2],\n round: 0,\n rounds: [{\n stage: RoundStage.PreFlop,\n deck: round_deck,\n table_cards: [],\n bet,\n pot: 0,\n dealer: 0,\n active_player,\n player_status,\n player_bets,\n player_cards,\n }],\n }, { status: StatusKind.InProgress, active_player: active_player }];\n}\n\n/**\n * Check if an action is valid.\n *\n * @param {PokerState | PokerView} state The game state.\n * @param {number} player The index of the {@link Player} making the action.\n * @param {PokerAction} action The action to check.\n *\n * @returns {null | GameError} null if the action is valid, or a GameError if it is invalid.\n */\nexport function checkAction(\n state: PokerState | PokerView,\n player: number,\n action: PokerAction,\n): null | GameError {\n if (player !== state.rounds[state.round].active_player) {\n return new GameError(GameErrorKind.Player, \"It is not this player's turn.\");\n }\n\n const player_chips = state.player_chips[player];\n const round = state.rounds[state.round];\n\n switch (action.kind) {\n case PokerActionKind.Fold: {\n break;\n }\n case PokerActionKind.Check: {\n if (round.bet !== round.player_bets[player]) {\n return new GameError(\n GameErrorKind.Action,\n \"Cannot check, you have to fold, call, or raise.\",\n );\n }\n break;\n }\n case PokerActionKind.Bet: {\n if (round.bet !== 0) {\n return new GameError(\n GameErrorKind.Action,\n \"Cannot bet, you have to call or raise.\",\n );\n }\n if (action.amount > player_chips) {\n return new GameError(GameErrorKind.Action, \"Not enough chips.\");\n }\n break;\n }\n case PokerActionKind.Call: {\n if (round.bet === 0) {\n return new GameError(\n GameErrorKind.Action,\n \"Nothing to call, check instead.\",\n );\n }\n break;\n }\n case PokerActionKind.Raise: {\n if (round.bet === 0) {\n return new GameError(\n GameErrorKind.Action,\n \"Nothing to raise, bet instead.\",\n );\n }\n\n const call_amount = round.bet - round.player_bets[player];\n if (call_amount + action.amount > player_chips) {\n return new GameError(GameErrorKind.Action, \"Not enough chips.\");\n }\n break;\n }\n default: {\n const _: never = action;\n }\n }\n\n return null;\n}\n\n/**\n * Get the index of the next {@link RoundPlayerStatus.Playing} {@link Player}\n * in the round.\n *\n * @param {number | null} player The index of the active player.\n * @param {RoundPlayerStatus[]} player_status The status of each player in the round.\n *\n * @returns {number | null} The index of the next {@link Player}, or null if\n * there are no more {@link RoundPlayerStatus.Playing} players.\n */\nfunction playerAfter(\n player: number | null,\n player_status: RoundPlayerStatus[],\n): number | null {\n if (player === null) {\n return null;\n }\n const num_players = player_status.length;\n for (let i = 1; i < num_players; i++) {\n const active_player = (player + i) % num_players;\n if (player_status[active_player] === \"playing\") {\n return active_player;\n }\n }\n return null;\n}\n\n/**\n * Apply an action to the game state.\n * * Mutates the passed in game state.\n * * Handles the logic of the game and moves to the next stage or round when\n * needed.\n *\n * @param {PokerState} state The game state.\n * @param {number} player The index of the {@link Player} making the action.\n * @param {Connect4Action} action The action to apply.\n *\n * @returns {Status | GameError} The status of the game after the action,\n * or an error if the action is invalid.\n */\nexport function applyAction(\n state: PokerState,\n player: number,\n action: PokerAction,\n): Status | GameError {\n const check = checkAction(state, player, action);\n if (check instanceof GameError) {\n return check;\n }\n\n const round = state.rounds[state.round];\n const num_players = state.player_chips.length;\n\n switch (action.kind) {\n case PokerActionKind.Fold: {\n round.player_status[player] = RoundPlayerStatus.Folded;\n break;\n }\n case PokerActionKind.Check: {\n break;\n }\n case PokerActionKind.Bet: {\n round.player_bets[player] += action.amount;\n state.player_chips[player] -= action.amount;\n round.bet = action.amount;\n if (state.player_chips[player] === 0) {\n round.player_status[player] = RoundPlayerStatus.AllIn;\n }\n break;\n }\n case PokerActionKind.Call: {\n const call_amount = round.bet - round.player_bets[player];\n if (call_amount >= state.player_chips[player]) {\n // all in\n round.player_bets[player] += state.player_chips[player];\n state.player_chips[player] = 0;\n round.player_status[player] = RoundPlayerStatus.AllIn;\n } else {\n round.player_bets[player] += call_amount;\n state.player_chips[player] -= call_amount;\n }\n break;\n }\n case PokerActionKind.Raise: {\n const call_amount = round.bet - round.player_bets[player];\n round.player_bets[player] += call_amount + action.amount;\n state.player_chips[player] -= call_amount + action.amount;\n round.bet += action.amount;\n if (state.player_chips[player] === 0) {\n round.player_status[player] = RoundPlayerStatus.AllIn;\n }\n break;\n }\n default: {\n const _: never = action;\n }\n }\n\n const round_player = round.active_player;\n\n round.active_player = playerAfter(\n round.active_player,\n round.player_status,\n )!;\n\n let stage_over = false;\n check_stage_over: {\n // TODO: The person who posts the big blind should get a chance to raise\n // before the flop. Right now that's a bug because if it gets back around\n // to him all bets will match and the round will end.\n\n // If no one else can go, the stage is over.\n if (round.active_player === null) {\n round.active_player = round_player;\n stage_over = true;\n break check_stage_over;\n }\n\n // If everyone has checked, the stage is over.\n if (\n round.bet === 0\n && round.active_player === playerAfter(round.dealer, round.player_status)\n ) {\n stage_over = true;\n break check_stage_over;\n }\n\n // If everyone except one person has folded, the stage is over.\n if (\n round.player_status.filter((s) => s === \"playing\" || s === \"all-in\")\n .length === 1\n ) {\n stage_over = true;\n break check_stage_over;\n }\n\n // If everyone still playing has bet the same amount, the stage is over.\n if (round.bet !== 0) {\n for (let i = 0; i < state.player_chips.length; i++) {\n if (\n round.player_status[i] === \"playing\"\n && round.player_bets[i] < round.bet\n ) {\n break check_stage_over;\n }\n }\n stage_over = true;\n }\n }\n let round_over = false;\n\n if (stage_over) {\n // Move all bets to the pot\n for (let i = 0; i < num_players; i++) {\n round.pot += round.player_bets[i];\n round.player_bets[i] = 0;\n }\n\n round.bet = 0;\n round.active_player = playerAfter(\n round.dealer,\n round.player_status,\n )!;\n\n for (let i = 0; i < num_players; i++) {\n round.pot += round.player_bets[i];\n round.player_bets[i] = 0;\n }\n\n // If only one player left, the round is over.\n if (playerAfter(round.active_player, round.player_status) === null) {\n // draw remaining cards and go to showdown.\n const num_table_cards = round.table_cards.length;\n for (let i = 0; i < 5 - num_table_cards; i++) {\n round.table_cards.push(round.deck.pop()!);\n }\n round.active_player = round_player;\n round.stage = RoundStage.Showdown;\n round_over = true;\n } else {\n // Move to the next stage.\n switch (round.stage) {\n case RoundStage.PreFlop: {\n round.table_cards.push(round.deck.pop()!);\n round.table_cards.push(round.deck.pop()!);\n round.table_cards.push(round.deck.pop()!);\n round.stage = RoundStage.Flop;\n break;\n }\n case RoundStage.Flop: {\n round.table_cards.push(round.deck.pop()!);\n round.stage = RoundStage.Turn;\n break;\n }\n case RoundStage.Turn: {\n round.table_cards.push(round.deck.pop()!);\n round.stage = RoundStage.River;\n break;\n }\n case RoundStage.River: {\n round.stage = RoundStage.Showdown;\n round_over = true;\n break;\n }\n case RoundStage.Showdown: {\n throw new Error(\"Invalid stage\");\n }\n default: {\n const _: never = round.stage;\n }\n }\n }\n }\n\n if (!round_over) {\n return {\n status: StatusKind.InProgress,\n active_player: round.active_player,\n };\n }\n\n // Evaluate the hands and determine the winner.\n const playing_players = [];\n for (let i = 0; i < num_players; i++) {\n if (\n round.player_status[i] === RoundPlayerStatus.Playing\n || round.player_status[i] === RoundPlayerStatus.AllIn\n ) {\n playing_players.push(i);\n }\n }\n\n const winning_players = [];\n\n if (playing_players.length === 1) {\n // Only one player left, they are the winner.\n winning_players.push(playing_players[0]);\n } else {\n // Compare players' hands to determine the winner.\n const active_players = [];\n for (let i = 0; i < playing_players.length; i++) {\n active_players.push({\n player: i,\n hand: bestHand([...round.player_cards[i], ...round.table_cards]),\n });\n }\n\n active_players.sort((a, b) => compareHands(a.hand, b.hand)).reverse();\n\n const winning_hand = active_players[0].hand;\n for (let i = 0; i < active_players.length; i++) {\n if (compareHands(active_players[i].hand, winning_hand) === 0) {\n winning_players.push(active_players[i].player);\n }\n }\n }\n\n if (winning_players.length === 1) {\n const winning_player = winning_players[0];\n state.player_chips[winning_player] += round.pot;\n } else {\n const split_pot = Math.floor(round.pot / winning_players.length);\n for (const player of winning_players) {\n state.player_chips[player] += split_pot;\n }\n }\n\n // Set up the next round.\n\n let players_left = 0;\n let winner = 0;\n const next_round_player_status: RoundPlayerStatus[] = [];\n for (let i = 0; i < num_players; i++) {\n const player_status = round.player_status[i];\n if (player_status === \"out\" || state.player_chips[i] === 0) {\n next_round_player_status.push(RoundPlayerStatus.Out);\n } else {\n players_left++;\n winner = i;\n next_round_player_status.push(RoundPlayerStatus.Playing);\n }\n }\n\n if (players_left == 1) {\n return {\n status: StatusKind.Over,\n result: {\n kind: ResultKind.Winner,\n players: [winner],\n },\n };\n }\n\n const next_round_deck = deck();\n shuffle(next_round_deck);\n\n const next_round_player_bets: number[] = [];\n const next_round_player_cards: [Card, Card][] = [];\n\n for (let i = 0; i < num_players; i++) {\n next_round_player_bets.push(0);\n if (next_round_player_status[i] === RoundPlayerStatus.Playing) {\n next_round_player_cards.push([\n next_round_deck.pop()!,\n next_round_deck.pop()!,\n ]);\n } else {\n // dummy cards, todo maybe make this a map so we\n // don't have to fill out cards for players that are out.\n next_round_player_cards.push([\n { rank: Rank.AceLow, suit: Suit.Clubs },\n { rank: Rank.AceLow, suit: Suit.Clubs },\n ]);\n }\n }\n\n const next_round_dealer = playerAfter(\n round.dealer,\n next_round_player_status,\n )!;\n let next_round_active_player = playerAfter(\n next_round_dealer,\n next_round_player_status,\n )!;\n\n let bet = 0;\n\n const round_blinds = players_left === 2 ? [2, 1] : [1, 2];\n const small_blind = Math.min(\n state.player_chips[next_round_active_player],\n round_blinds[0],\n );\n state.player_chips[next_round_active_player] -= small_blind;\n next_round_player_bets[next_round_active_player] += small_blind;\n bet = small_blind;\n\n next_round_active_player = playerAfter(\n next_round_active_player,\n next_round_player_status,\n )!;\n\n const big_blind = Math.min(\n state.player_chips[next_round_active_player],\n round_blinds[1],\n );\n state.player_chips[next_round_active_player] -= big_blind;\n next_round_player_bets[next_round_active_player] += big_blind;\n bet = Math.max(small_blind, big_blind);\n\n next_round_active_player = playerAfter(\n next_round_active_player,\n next_round_player_status,\n )!;\n\n state.round++;\n state.rounds.push({\n stage: RoundStage.PreFlop,\n deck: next_round_deck,\n table_cards: [],\n bet,\n pot: 0,\n dealer: next_round_dealer,\n active_player: next_round_active_player,\n player_status: next_round_player_status,\n player_bets: next_round_player_bets,\n player_cards: next_round_player_cards,\n });\n\n return {\n status: StatusKind.InProgress,\n active_player: next_round_active_player,\n };\n}\n\n/**\n * Get the player specific view of the game state.\n *\n * The view is similar to the game state, but the rounds only show the player's\n * private cards. The other player's private cards and the deck are hidden.\n *\n * @param {PokerState} state The game state.\n * @param {number} player The index of the {@link Player} to get the view for.\n *\n * @returns {PokerView | GameError} The player's game view.\n */\nexport function getView(\n state: PokerState,\n player: number,\n): PokerView | GameError {\n const rounds = [];\n for (const round of state.rounds) {\n rounds.push({\n stage: round.stage,\n table_cards: round.table_cards,\n bet: round.bet,\n pot: round.pot,\n dealer: round.dealer,\n active_player: round.active_player,\n player_status: round.player_status,\n player_bets: round.player_bets,\n my_cards: round.player_cards[player],\n });\n }\n return {\n ...state,\n rounds,\n };\n}\n\n/**\n * Poker Agent Response.\n *\n * @template T The type of the agent data.\n * * Must extend {@link Json} which restricts it to a JSON serializable type.\n */\nexport interface PokerAgentResponse<\n T extends Json = Json,\n> {\n /** The action to take. */\n action: PokerAction;\n /** Optional data to save.\n *\n * This data will be passed back to the agent on the next turn. It allows you\n * to save state between turns.\n */\n agent_data?: T;\n}\n\n/**\n * Function type for a Poker Agent.\n *\n * * Takes the current game state and optional agent data.\n * * Returns a response with the action to take and optional agent data to save.\n *\n * On the first turn, `agent_data` will be `undefined`.\n *\n * On subsequent turns, `agent_data` will be the data returned by the agent's\n * previous turn.\n *\n * If the agent did not return `agent_data`, it will be `undefined`.\n *\n * To keep `agent_data` between turns, it must be returned in the response each\n * time, even if it is not modified.\n *\n * @template T The type of the agent data.\n * * Must extend {@link Json} which restricts it to a JSON serializable type.\n */\nexport type PokerAgent<\n T extends Json = Json,\n> = (\n state: PokerView,\n agent_data?: T,\n) => PokerAgentResponse;\n\n/**\n * Function type for an async Poker Agent.\n *\n * * Takes the current game state and optional agent data.\n * * Returns a response with the action to take and optional agent data to save.\n *\n * On the first turn, `agent_data` will be `undefined`.\n *\n * On subsequent turns, `agent_data` will be the data returned by the agent's\n * previous turn.\n *\n * If the agent did not return `agent_data`, it will be `undefined`.\n *\n * To keep `agent_data` between turns, it must be returned in the response each\n * time, even if it is not modified.\n *\n * @template T The type of the agent data.\n * * Must extend {@link Json} which restricts it to a JSON serializable type.\n */\nexport type PokerAsyncAgent<\n T extends Json = Json,\n> = (\n state: PokerView,\n agent_data?: T,\n) => Promise;\n\n/**\n * Poker {@link Game} Definition.\n */\nexport const Poker: Game<\n PokerArgs,\n PokerState,\n PokerAction,\n PokerView,\n GameError\n> = {\n kind: GameKind.Poker,\n newGame,\n checkAction,\n applyAction,\n getView,\n};","deleted","label",[98],"permalink","https://www.val.town/x/saolsen/gameplay_poker/code/main.tsx","extension","actionData","errors"]