magmacrunch-cribbage 0.1.0__py3-none-any.whl

cribbage/__main__.py

@@ -0,0 +1,34 @@
+"""``python -m cribbage`` -- play cribbage against the computer in a terminal."""
+
+from __future__ import annotations
+
+import argparse
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        prog="cribbage", description="Cribbage against the computer.")
+    parser.add_argument("--seed", type=int, default=None,
+                        help="fix the session's deals, for a reproducible one")
+    parser.add_argument("--play", action="store_true", help="skip the title screen")
+    parser.add_argument("--online", action="store_true",
+                        help="go straight to the online lobby (a prototype)")
+    parser.add_argument("--server", default=None,
+                        help="the multiplayer server to play online through, "
+                             "e.g. ws://127.0.0.1:8766 for a web/server.py run "
+                             "locally. Default: the arcade's own")
+    parser.add_argument(
+        "--ascii", action="store_true", dest="ascii_only",
+        help="draw with plain ASCII instead of box, suit and block glyphs. "
+             "Detected automatically from the terminal's encoding; this "
+             "forces it. MAGMACRUNCH_ASCII=1 says the same for every cabinet.",
+    )
+    args = parser.parse_args()
+
+    from cribbage.app import run
+
+    run(args.seed, args.play, args.ascii_only, args.server, args.online)
+
+
+if __name__ == "__main__":
+    main()

cribbage/ai.py

@@ -0,0 +1,124 @@
+"""The opponent: ``CribbageAI`` from ``web/js/ai.js``, line for line.
+
+Two decisions and nothing else -- which two cards to throw to the crib, and
+which card to lay while pegging -- each made by scoring every option with a
+hand-tuned heuristic and taking the first best. Ties go to the earliest
+option, as ``score > bestScore`` gives them in the browser, which is why the
+loops below walk the hand in the same order it does.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+
+from cribbage.cards import Card, order, value
+
+MAX_PEG_COUNT = 31
+
+
+def select_crib_cards(hand: Sequence[Card], crib_is_opponents: bool) -> list[Card]:
+    """Two cards to discard. ``crib_is_opponents`` is True when the human
+    deals, so the crib these land in is not the AI's to score."""
+    if len(hand) != 6:
+        return list(hand[:2])
+    best: list[Card] | None = None
+    best_score = float("-inf")
+    for i in range(len(hand)):
+        for j in range(i + 1, len(hand)):
+            discard = [hand[i], hand[j]]
+            remaining = [c for k, c in enumerate(hand) if k not in (i, j)]
+            score = score_crib_discard(remaining, discard, crib_is_opponents)
+            if score > best_score:
+                best_score = score
+                best = discard
+    return best or list(hand[:2])
+
+
+def score_crib_discard(remaining: Sequence[Card], discard: Sequence[Card],
+                       crib_is_opponents: bool) -> float:
+    score = 0
+    for i in range(len(remaining)):
+        for j in range(i + 1, len(remaining)):
+            if value(remaining[i].rank) + value(remaining[j].rank) == 15:
+                score += 4
+
+    ranks: dict[str, int] = {}
+    for c in remaining:
+        ranks[c.rank] = ranks.get(c.rank, 0) + 1
+    score += 2 * sum(1 for n in ranks.values() if n == 2)
+
+    orders = sorted(order(c.rank) for c in remaining)
+    for i in range(len(orders) - 2):
+        if orders[i + 1] == orders[i] + 1 and orders[i + 2] == orders[i] + 2:
+            score += 3
+
+    suits: dict[str, int] = {}
+    for c in remaining:
+        suits[c.suit] = suits.get(c.suit, 0) + 1
+    score += 2 * sum(1 for n in suits.values() if n == 3)
+
+    score += sum(1 for c in remaining if c.rank == "5")
+
+    if crib_is_opponents:
+        for c in discard:
+            if c.rank == "5":
+                score -= 2
+            if c.rank in ("10", "J", "Q", "K"):
+                score -= 1
+    return score
+
+
+def select_pegging_card(hand: Sequence[Card], count: int,
+                        played: Sequence[Card]) -> Card | None:
+    """The card to lay, or None for a go."""
+    playable = [c for c in hand if value(c.rank) + count <= MAX_PEG_COUNT]
+    if not playable:
+        return None
+    if len(playable) == 1:
+        return playable[0]
+    best: Card | None = None
+    best_score = float("-inf")
+    for c in playable:
+        score = score_pegging_play(c, count, played, hand)
+        if score > best_score:
+            best_score = score
+            best = c
+    return best or playable[0]
+
+
+def score_pegging_play(card: Card, count: int, played: Sequence[Card],
+                       hand: Sequence[Card]) -> float:
+    score: float = 0
+    new_count = count + value(card.rank)
+
+    if new_count in (15, 31):
+        score += 2
+
+    if played:
+        if card.rank == played[-1].rank:
+            score += 2
+            if len(played) >= 2 and played[-2].rank == card.rank:
+                score += 4
+            if len(played) >= 3 and played[-3].rank == card.rank:
+                score += 6
+
+    # Only the last three cards are looked at for a run, as in the browser.
+    if len(played) >= 2:
+        last = [*played[-2:], card]
+        ranked = sorted(last, key=lambda c: order(c.rank))
+        if all(i == 0 or order(c.rank) == order(ranked[i - 1].rank) + 1
+               for i, c in enumerate(ranked)):
+            score += len(last)
+
+    if new_count not in (15, 31) and new_count in (10, 20, 25):
+        score -= 1
+
+    if new_count > 25:
+        score -= value(card.rank) / 10
+
+    after = [c for c in hand if c != card]
+    score += sum(1 for c in after if value(c.rank) + new_count <= MAX_PEG_COUNT) * 0.5
+    return score
+
+
+__all__ = ["select_crib_cards", "select_pegging_card"]

cribbage/app.py

@@ -0,0 +1,111 @@
+"""Wiring -- what outlives one game, and how the screens reach it.
+
+Everything that draws lives in :mod:`cribbage.scenes`; everything that decides
+lives in :mod:`cribbage.game`. **The terminal is not owned here**: it belongs
+to a ``TuiHost``, which is what lets this run as its own command or be seated
+by the arcade.
+"""
+
+from __future__ import annotations
+
+import random
+from typing import Any
+
+from magmacrunch.engine.scores import ScoreBook
+
+from cribbage.arcade import INFO
+from cribbage.scenes import GameScene, TitleScene
+
+
+class CribbageApp:
+    def __init__(self, host: Any, seed: int | None = None,
+                 scores: ScoreBook | None = None, server: str | None = None):
+        self.host = host
+        #: The multiplayer server PLAY ONLINE connects to. The arcade's own by
+        #: default; ``--server`` points it somewhere else, such as a server.py
+        #: running on this machine.
+        from cribbage.online import DEFAULT_SERVER
+
+        self.server = server or DEFAULT_SERVER
+        #: Where each game's shuffles and cuts come from. Seeded, so
+        #: ``--seed`` replays a whole session.
+        self.rng = random.Random(seed)
+        #: The board the browser posts to. It records wins only, as the
+        #: player's final score, which is what the page saves.
+        self.scores = scores or ScoreBook(INFO.scoreboard)
+        self.initials = "AAA"
+        self.last_rank: int | None = None
+        self.root_scene = TitleScene(self)
+
+    @property
+    def renderer(self):
+        return self.host.renderer
+
+    def new_rand(self):
+        return random.Random(self.rng.randrange(1 << 32)).random
+
+    def start_game(self) -> None:
+        self.host.push_scene(GameScene(self))
+
+    def play_online(self) -> None:
+        """The lobby. A prototype: see :mod:`cribbage.online`."""
+        from cribbage.online_scenes import OnlineLobbyScene
+
+        self.host.push_scene(OnlineLobbyScene(self, self.server))
+
+    def show_scores(self) -> None:
+        from cribbage.scenes import ScoresScene
+
+        self.host.push_scene(ScoresScene(self))
+
+    def show_rules(self) -> None:
+        from cribbage.scenes import RulesScene
+
+        self.host.push_scene(RulesScene(self))
+
+    def enter_initials(self, score: int, extra: dict) -> None:
+        from cribbage.scenes import InitialsScene
+
+        self.host.push_scene(InitialsScene(self, score, extra))
+
+    def to_title(self) -> None:
+        self.host.pop_scene()
+
+    def leave(self) -> None:
+        self.host.pop_scene()
+
+    @property
+    def best(self) -> int:
+        return self.scores.best()
+
+    def qualifies(self, score: int) -> bool:
+        return score > 0 and self.scores.qualifies(score)
+
+    def record(self, score: int, initials: str | None = None,
+               extra: dict | None = None):
+        self.initials = initials or self.initials
+        result = self.scores.save(self.initials, score, **(extra or {}))
+        self.last_rank = result.rank
+        return result
+
+    @property
+    def scene(self):
+        return self.host.scene
+
+
+def run(seed: int | None = None, skip_title: bool = False,
+        ascii_only: bool = False, server: str | None = None,
+        online: bool = False) -> None:
+    """Play cribbage as its own command."""
+    from magmacrunch.engine.core.tui_host import TuiHost
+    from magmacrunch.engine.ui.glyphs import Glyphs
+
+    host = TuiHost(title=INFO.title, fps=INFO.fps, hold_ms=INFO.hold_ms,
+                   glyphs=Glyphs.detect(ascii_only=ascii_only))
+    app = CribbageApp(host, seed, server=server)
+    host.push_scene(app.root_scene)
+    if online:
+        app.play_online()
+    elif skip_title:
+        host.push_scene(GameScene(app))
+    host.run()

cribbage/arcade.py

@@ -0,0 +1,39 @@
+"""What the arcade needs to know to launch this game. Kept tiny: a menu loads
+one of these per installed game just to draw a card."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from magmacrunch.engine.arcade import GameInfo
+
+from cribbage import theme
+
+INFO = GameInfo(
+    key="cribbage",
+    title="Cribbage",
+    blurb="First to 121 against the computer. Fifteen two, fifteen four.",
+    # Turn-based. The frame rate only paces the computer's moves and the
+    # cursor; edge input so one arrow press moves one card.
+    fps=20,
+    hold_ms=0,
+    min_cols=theme.MIN_COLS,
+    min_rows=theme.MIN_ROWS,
+    accent=theme.ACCENT,
+)
+
+
+class CribbageGame:
+    """Satisfies :class:`magmacrunch.engine.arcade.ArcadeGame`."""
+
+    info = INFO
+
+    def start(self, host: Any) -> Any:
+        from cribbage.app import CribbageApp
+
+        return CribbageApp(host).root_scene
+
+
+GAME = CribbageGame()
+
+__all__ = ["GAME", "INFO", "CribbageGame"]

cribbage/cards.py

@@ -0,0 +1,221 @@
+"""Cards, the deck, and cribbage's scoring.
+
+A port of the parts of ``@magmacrunch/adenosine-cards`` the game uses: the
+``Deck`` and its shuffle, and ``CribbageHandEval`` with ``CRIBBAGE_SCORE``.
+The browser loads those from the website's ``arcade/shared/``, so they are
+not in this repo's ``web/`` at all; ``tools/js_oracle.mjs`` loads the same
+bundle the page does and ``tests/test_oracle.py`` holds this to it.
+
+Two numbers per rank, and keeping them apart is the whole trick. ``value`` is
+what a card counts toward fifteen and thirty-one (court cards are ten);
+``order`` is where it sits in a run (J, Q and K are 11, 12 and 13). The
+package once built runs out of values, which made J-Q-K three tens.
+"""
+
+from __future__ import annotations
+
+import math
+from collections.abc import Callable, Sequence
+from dataclasses import dataclass
+
+#: The bundle's order, which is also the order a fresh deck is built in --
+#: and therefore part of what a seeded shuffle deals.
+SUITS = ("hearts", "diamonds", "clubs", "spades")
+RANKS = ("A", "2", "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K")
+
+SUIT_SYMBOLS = {"hearts": "♥", "diamonds": "♦", "clubs": "♣", "spades": "♠"}
+RED = frozenset({"hearts", "diamonds"})
+
+SCORE = {
+    "FIFTEEN": 2, "PAIR": 2, "THREE_OF_KIND": 6, "FOUR_OF_KIND": 12,
+    "FLUSH_4": 4, "FLUSH_5": 5, "NIBS": 1, "HIS_HEELS": 2, "GO": 1,
+    "THIRTY_ONE": 2,
+}
+
+ORDER = {rank: i + 1 for i, rank in enumerate(RANKS)}
+
+
+def order(rank: str) -> int:
+    return ORDER.get(rank, 0)
+
+
+def value(rank: str) -> int:
+    return min(order(rank), 10)
+
+
+@dataclass(frozen=True)
+class Card:
+    """A card is its suit and rank. Two cards equal by value, as the browser
+    compares them (``c.suit === card.suit && c.rank === card.rank``)."""
+
+    suit: str
+    rank: str
+
+    def __str__(self) -> str:
+        return f"{self.rank}{SUIT_SYMBOLS[self.suit]}"
+
+    @property
+    def red(self) -> bool:
+        return self.suit in RED
+
+
+class Deck:
+    """``AdCards.Deck``: built in suit-then-rank order, dealt from the end."""
+
+    def __init__(self) -> None:
+        self.cards = [Card(s, r) for s in SUITS for r in RANKS]
+
+    def shuffle(self, rand: Callable[[], float]) -> None:
+        """Fisher-Yates from the top down, one draw per position, as the
+        bundle does it. Same draws, same deck."""
+        for i in range(len(self.cards) - 1, 0, -1):
+            j = math.floor(rand() * (i + 1))
+            self.cards[i], self.cards[j] = self.cards[j], self.cards[i]
+
+    def deal(self) -> Card:
+        return self.cards.pop()
+
+
+# ── CribbageHandEval ────────────────────────────────────────────────
+
+def count_fifteens(cards: Sequence[Card]) -> int:
+    n = len(cards)
+    count = 0
+    for mask in range(1, 1 << n):
+        if sum(value(cards[i].rank) for i in range(n) if mask & (1 << i)) == 15:
+            count += 1
+    return count
+
+
+def count_pairs(cards: Sequence[Card]) -> int:
+    counts: dict[str, int] = {}
+    for c in cards:
+        counts[c.rank] = counts.get(c.rank, 0) + 1
+    points = 0
+    for n in counts.values():
+        if n == 2:
+            points += SCORE["PAIR"]
+        elif n == 3:
+            points += SCORE["THREE_OF_KIND"]
+        elif n == 4:
+            points += SCORE["FOUR_OF_KIND"]
+    return points
+
+
+def count_runs(cards: Sequence[Card]) -> int:
+    """Only the longest run in each consecutive block, once per way the
+    duplicate ranks can build it: 2-3-4-5 is 4, a double run of three is 6."""
+    if len(cards) < 3:
+        return 0
+    counts: dict[int, int] = {}
+    for c in cards:
+        o = order(c.rank)
+        counts[o] = counts.get(o, 0) + 1
+    unique = sorted(counts)
+    total = 0
+    i = 0
+    while i < len(unique):
+        j = i
+        while j + 1 < len(unique) and unique[j + 1] == unique[j] + 1:
+            j += 1
+        length = j - i + 1
+        if length >= 3:
+            ways = 1
+            for k in range(i, j + 1):
+                ways *= counts[unique[k]]
+            total += length * ways
+        i = j + 1
+    return total
+
+
+def count_flush(hand: Sequence[Card], starter: Card | None, is_crib: bool) -> int:
+    """The starter never makes a four-card flush; a crib flush must be five."""
+    if len(hand) < 4:
+        return 0
+    suit = hand[0].suit
+    if not all(c.suit == suit for c in hand):
+        return 0
+    if starter is not None and starter.suit == suit:
+        return SCORE["FLUSH_5"]
+    return 0 if is_crib else SCORE["FLUSH_4"]
+
+
+def count_nobs(hand: Sequence[Card], starter: Card | None) -> int:
+    if starter is None:
+        return 0
+    for c in hand:
+        if c.rank == "J" and c.suit == starter.suit:
+            return SCORE["NIBS"]
+    return 0
+
+
+@dataclass(frozen=True)
+class HandScore:
+    fifteens: int
+    pairs: int
+    runs: int
+    flush: int
+    nobs: int
+
+    @property
+    def total(self) -> int:
+        return self.fifteens + self.pairs + self.runs + self.flush + self.nobs
+
+
+def score_hand(hand: Sequence[Card], starter: Card | None,
+               is_crib: bool = False) -> HandScore:
+    every = [*hand, starter] if starter is not None else list(hand)
+    return HandScore(
+        fifteens=count_fifteens(every) * SCORE["FIFTEEN"],
+        pairs=count_pairs(every),
+        runs=count_runs(every),
+        flush=count_flush(hand, starter, is_crib),
+        nobs=count_nobs(hand, starter),
+    )
+
+
+@dataclass(frozen=True)
+class PegScore:
+    points: int
+    description: str
+
+
+def score_pegging_play(card: Card, played: Sequence[Card]) -> PegScore:
+    """Laying ``card`` on the series so far. Every category counts: a card
+    that makes thirty-one and completes a run scores both."""
+    sequence = [*played, card]
+    count = sum(value(c.rank) for c in sequence)
+    points = 0
+    said: list[str] = []
+    if count == 15:
+        points += SCORE["FIFTEEN"]
+        said.append("Fifteen!")
+    if count == 31:
+        points += SCORE["THIRTY_ONE"]
+        said.append("Thirty-one!")
+    matching = 1
+    for prev in reversed(played):
+        if prev.rank != card.rank:
+            break
+        matching += 1
+    if matching == 2:
+        points += SCORE["PAIR"]
+        said.append("Pair!")
+    elif matching == 3:
+        points += SCORE["THREE_OF_KIND"]
+        said.append("Pair royal!")
+    elif matching >= 4:
+        points += SCORE["FOUR_OF_KIND"]
+        said.append("Double pair royal!")
+    for length in range(len(sequence), 2, -1):
+        tail = sorted(order(c.rank) for c in sequence[-length:])
+        if all(i == 0 or o == tail[i - 1] + 1 for i, o in enumerate(tail)):
+            points += length
+            said.append(f"Run of {length}!")
+            break
+    return PegScore(points, " + ".join(said))
+
+
+__all__ = ["RANKS", "SCORE", "SUITS", "SUIT_SYMBOLS", "Card", "Deck",
+           "HandScore", "PegScore", "order", "score_hand",
+           "score_pegging_play", "value"]