magmacrunch-cribbage 0.1.0__tar.gz

magmacrunch_cribbage-0.1.0/.gitignore

@@ -0,0 +1,9 @@
+__pycache__/
+*.py[cod]
+*.egg-info/
+.pytest_cache/
+.ruff_cache/
+.venv/
+venv/
+dist/
+build/

magmacrunch_cribbage-0.1.0/LICENSE

@@ -0,0 +1,75 @@
+Required Notice: Copyright 2026 magmacrunch media (https://magmacrunch.com)
+
+# PolyForm Noncommercial License 1.0.0
+
+<https://polyformproject.org/licenses/noncommercial/1.0.0>
+
+## Acceptance
+
+In order to get any license under these terms, you must agree to them as both strict obligations and conditions to all your licenses.
+
+## Copyright License
+
+The licensor grants you a copyright license for the software to do everything you might do with the software that would otherwise infringe the licensor's copyright in it for any permitted purpose.  However, you may only distribute the software according to [Distribution License](#distribution-license) and make changes or new works based on the software according to [Changes and New Works License](#changes-and-new-works-license).
+
+## Distribution License
+
+The licensor grants you an additional copyright license to distribute copies of the software.  Your license to distribute covers distributing the software with changes and new works permitted by [Changes and New Works License](#changes-and-new-works-license).
+
+## Notices
+
+You must ensure that anyone who gets a copy of any part of the software from you also gets a copy of these terms or the URL for them above, as well as copies of any plain-text lines beginning with `Required Notice:` that the licensor provided with the software.  For example:
+
+> Required Notice: Copyright Yoyodyne, Inc. (http://example.com)
+
+## Changes and New Works License
+
+The licensor grants you an additional copyright license to make changes and new works based on the software for any permitted purpose.
+
+## Patent License
+
+The licensor grants you a patent license for the software that covers patent claims the licensor can license, or becomes able to license, that you would infringe by using the software.
+
+## Noncommercial Purposes
+
+Any noncommercial purpose is a permitted purpose.
+
+## Personal Uses
+
+Personal use for research, experiment, and testing for the benefit of public knowledge, personal study, private entertainment, hobby projects, amateur pursuits, or religious observance, without any anticipated commercial application, is use for a permitted purpose.
+
+## Noncommercial Organizations
+
+Use by any charitable organization, educational institution, public research organization, public safety or health organization, environmental protection organization, or government institution is use for a permitted purpose regardless of the source of funding or obligations resulting from the funding.
+
+## Fair Use
+
+You may have "fair use" rights for the software under the law. These terms do not limit them.
+
+## No Other Rights
+
+These terms do not allow you to sublicense or transfer any of your licenses to anyone else, or prevent the licensor from granting licenses to anyone else.  These terms do not imply any other licenses.
+
+## Patent Defense
+
+If you make any written claim that the software infringes or contributes to infringement of any patent, your patent license for the software granted under these terms ends immediately. If your company makes such a claim, your patent license ends immediately for work on behalf of your company.
+
+## Violations
+
+The first time you are notified in writing that you have violated any of these terms, or done anything with the software not covered by your licenses, your licenses can nonetheless continue if you come into full compliance with these terms, and take practical steps to correct past violations, within 32 days of receiving notice.  Otherwise, all your licenses end immediately.
+
+## No Liability
+
+***As far as the law allows, the software comes as is, without any warranty or condition, and the licensor will not be liable to you for any damages arising out of these terms or the use or nature of the software, under any kind of legal claim.***
+
+## Definitions
+
+The **licensor** is the individual or entity offering these terms, and the **software** is the software the licensor makes available under these terms.
+
+**You** refers to the individual or entity agreeing to these terms.
+
+**Your company** is any legal entity, sole proprietorship, or other kind of organization that you work for, plus all organizations that have control over, are under the control of, or are under common control with that organization.  **Control** means ownership of substantially all the assets of an entity, or the power to direct its management and policies by vote, contract, or otherwise.  Control can be direct or indirect.
+
+**Your licenses** are all the licenses granted to you for the software under these terms.
+
+**Use** means anything you do with the software requiring one of your licenses.

magmacrunch_cribbage-0.1.0/NOTICE

@@ -0,0 +1,34 @@
+cribbage
+Copyright 2026 magmacrunch media
+
+
+THE LICENCE
+
+Everything in this repository -- the browser client and the WebSocket server
+in web/, the terminal version in tui/, the tools, and the documentation -- is
+licensed under the PolyForm Noncommercial License 1.0.0, in the LICENSE file
+beside this one.
+
+Read it, learn from it, build on it, play with it. Any noncommercial purpose is
+permitted, and that includes personal projects, teaching and research. What is
+not permitted is commercial use: selling the game or a derivative of it,
+shipping it inside a product, or running it as part of a business.
+
+Cribbage is a traditional card game and nobody's property; this licence
+does not pretend otherwise. What is licensed is this implementation: the rules, the scoring, the AI opponent, the board renderer and the
+server.
+
+What is reserved: the magmacrunch name and marks and the visual design of the
+arcade. If you want to use any of it, ask.
+
+
+THIRD-PARTY COMPONENTS
+
+Fonts are loaded from Google Fonts under the SIL Open Font License 1.1 rather
+than shipped here as files.
+
+The client loads the adenosine cards, multiplayer and score bundles, the deck
+art and the arcade styles from the website's arcade/shared/, and the server
+imports server_base and card_constants from arcade/shared/multiplayer/. Those
+are part of the magmacrunch.com repository and adenosine, and are not copied
+here.

magmacrunch_cribbage-0.1.0/PKG-INFO

@@ -0,0 +1,148 @@
+Metadata-Version: 2.5
+Name: magmacrunch-cribbage
+Version: 0.1.0
+Summary: Cribbage against the computer. Terminal version.
+Project-URL: Homepage, https://magmacrunch.com/arcade/cribbage/
+Author: magmacrunch media
+License-Expression: PolyForm-Noncommercial-1.0.0
+License-File: LICENSE
+License-File: NOTICE
+Keywords: arcade,cards,cribbage,games,terminal,tui
+Requires-Python: >=3.10
+Requires-Dist: magmacrunch>=0.7.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == 'dev'
+Requires-Dist: ruff>=0.6; extra == 'dev'
+Requires-Dist: websockets>=14.0; extra == 'dev'
+Provides-Extra: online
+Requires-Dist: websockets>=14.0; extra == 'online'
+Description-Content-Type: text/markdown
+
+# Cribbage (terminal)
+
+Cribbage against the computer, in a terminal. The second version of the game
+beside `web/`, on the [magmacrunch](https://github.com/magmacrunch-media/magmacrunch)
+engine's terminal backend: a cabinet in the magmacrunch arcade and its own
+command, the same either way.
+
+```
+pipx install magmacrunch-cribbage
+cribbage
+```
+
+For working on it, from this folder:
+
+```
+node ../tools/link-shared.mjs     # once: the oracle needs ../shared
+pip install -e ".[dev]"
+python -m cribbage
+```
+
+## Keys
+
+| key | |
+|---|---|
+| `←` `→` | choose a card |
+| `SPACE` or `1`-`6` | mark it for the crib, or lay it when pegging |
+| `ENTER` | send the two to the crib, cut, lay the chosen card, or carry on after the show |
+| `R` | new game |
+| `Esc` | the title (from the title, back to the arcade) |
+| `Q` | quit |
+
+A card that would take the count past 31 is greyed and refused. The
+computer's moves arrive one at a time, under a second apart, so a pegging
+exchange can be followed. The show waits for Enter, because a count is the
+thing a cribbage player wants to check.
+
+## Playing a person online (a prototype)
+
+PLAY ONLINE on the title, or `cribbage --online`, connects to the arcade's
+own multiplayer server -- the one the browser's Multiplayer button uses -- so
+a terminal and a browser can share a room. Type a name, then `C` to create a
+room and read its four-letter code to your opponent, or `J` to join one by
+its code. The host starts the game once two are in.
+
+```
+pip install "magmacrunch-cribbage[online]"     # websockets, only for this
+cribbage --online
+cribbage --online --server ws://127.0.0.1:8766  # a web/server.py on this machine
+```
+
+The server keeps the rules. This client sends what you chose and draws what
+the server says, so it never disagrees with the browser about a score: the
+two are clients of one referee. `cribbage/online.py` has the protocol, split
+into `Table` (the server's state, no I/O, tested without a socket) and
+`Connection` (the WebSocket, on a thread of its own, polled once a frame).
+
+`tests/test_online.py` runs `web/server.py` in-process on a free port and
+plays it over real sockets: two clients through a whole game to 121, and two
+full terminal sessions through the lobby and a hand with keys alone. It
+never contacts the live server.
+
+What a prototype has not done yet:
+
+- **Nobody has played the live server from a terminal**, only a copy of it
+  run locally. The default address is `wss://magmacrunch.duckdns.org/cribbage`,
+  which is what `mpServerFor('cribbage', 8766)` gives the public site.
+- **No reconnect.** A dropped connection says so and the game is lost.
+- **No chat and no colour pick**, both of which the browser lobby has.
+- **Online games do not reach the high score table**, here or on the page.
+- **The server sends both hands to both players.** `get_state` puts every
+  hand in `playerHands`; the browser and this client both decline to draw the
+  opponent's, but anyone reading the socket can see it. That wants fixing in
+  `server.py`, for the browser's sake as much as this one's.
+
+## It is the browser's game, and the browser's opponent
+
+Everything that decides is ported from what the page runs:
+
+| here | there |
+|---|---|
+| `cribbage/cards.py` | the deck and `CribbageHandEval` from `adenosine-cards`, in the website's `arcade/shared/` |
+| `cribbage/ai.py` | `web/js/ai.js`, the opponent |
+| `cribbage/game.py` | `web/js/game.js`, and the turn-taking `web/js/main.js` wraps around it |
+
+`tests/test_oracle.py` holds the port to the page. `tools/js_oracle.mjs`
+loads `adenosine-cards.js`, `config.js`, `ai.js` and `game.js` unmodified,
+plays 120 games against the page's own AI with a scripted player, and the test
+replays every choice through the port. It requires the same deck, cut, hands,
+crib, count, turn, scores and kept cards after every move: about 15,000 moves,
+both sides winning, some games won on his heels and some on a go. `tests/test_cards.py` carries the 50 scoring cases from
+`web/tests/test-scoring.js`, converted line for line.
+
+Wins go to the `cribbage` board the page posts to, as the winner's final score
+with `finalScore` beside it. Losses are not recorded, as on the page.
+
+## Who leads when a hand runs out
+
+After a series, whoever did not lay the last card leads the next, unless
+their hand is empty: then the other side lays out what it has left, alone,
+and takes the go for the last card. The page used to hand the lead to the
+empty hand, then go straight to the show, so the other hand's cards were
+never pegged. The oracle's first 60 games hit that in 32 of them, dropping 42 cards.
+It was fixed in `web/js/game.js` and here in the same change, and the oracle
+now requires that no game drops a card. The multiplayer server already got
+this right.
+
+## Three more, fixed in the page and followed here
+
+cribbage#5 fixed three more bugs in `web/js/game.js`, and the port copies all
+three, so the oracle still holds:
+
+- **The show counts the kept cards.** Pegging empties the hands, and the show
+  used to score those empty hands, so only the crib counted. A game took about
+  21 hands; it now takes about ten.
+- **His heels can win.** A jack turned that takes the dealer to 121 ends the
+  game at the cut. The page used to play on past 121.
+- **So can the go.** The point for a go or the last card can end the game
+  too. The page used to reset the series and peg on.
+
+The oracle requires a game a little under 13 hands on average, and its 120
+games include wins on his heels and on a go.
+
+Needs a 60x22 terminal.
+
+## Licence
+
+[PolyForm Noncommercial 1.0.0](LICENSE), as the rest of this repository. See
+[NOTICE](NOTICE).

magmacrunch_cribbage-0.1.0/README.md

@@ -0,0 +1,128 @@
+# Cribbage (terminal)
+
+Cribbage against the computer, in a terminal. The second version of the game
+beside `web/`, on the [magmacrunch](https://github.com/magmacrunch-media/magmacrunch)
+engine's terminal backend: a cabinet in the magmacrunch arcade and its own
+command, the same either way.
+
+```
+pipx install magmacrunch-cribbage
+cribbage
+```
+
+For working on it, from this folder:
+
+```
+node ../tools/link-shared.mjs     # once: the oracle needs ../shared
+pip install -e ".[dev]"
+python -m cribbage
+```
+
+## Keys
+
+| key | |
+|---|---|
+| `←` `→` | choose a card |
+| `SPACE` or `1`-`6` | mark it for the crib, or lay it when pegging |
+| `ENTER` | send the two to the crib, cut, lay the chosen card, or carry on after the show |
+| `R` | new game |
+| `Esc` | the title (from the title, back to the arcade) |
+| `Q` | quit |
+
+A card that would take the count past 31 is greyed and refused. The
+computer's moves arrive one at a time, under a second apart, so a pegging
+exchange can be followed. The show waits for Enter, because a count is the
+thing a cribbage player wants to check.
+
+## Playing a person online (a prototype)
+
+PLAY ONLINE on the title, or `cribbage --online`, connects to the arcade's
+own multiplayer server -- the one the browser's Multiplayer button uses -- so
+a terminal and a browser can share a room. Type a name, then `C` to create a
+room and read its four-letter code to your opponent, or `J` to join one by
+its code. The host starts the game once two are in.
+
+```
+pip install "magmacrunch-cribbage[online]"     # websockets, only for this
+cribbage --online
+cribbage --online --server ws://127.0.0.1:8766  # a web/server.py on this machine
+```
+
+The server keeps the rules. This client sends what you chose and draws what
+the server says, so it never disagrees with the browser about a score: the
+two are clients of one referee. `cribbage/online.py` has the protocol, split
+into `Table` (the server's state, no I/O, tested without a socket) and
+`Connection` (the WebSocket, on a thread of its own, polled once a frame).
+
+`tests/test_online.py` runs `web/server.py` in-process on a free port and
+plays it over real sockets: two clients through a whole game to 121, and two
+full terminal sessions through the lobby and a hand with keys alone. It
+never contacts the live server.
+
+What a prototype has not done yet:
+
+- **Nobody has played the live server from a terminal**, only a copy of it
+  run locally. The default address is `wss://magmacrunch.duckdns.org/cribbage`,
+  which is what `mpServerFor('cribbage', 8766)` gives the public site.
+- **No reconnect.** A dropped connection says so and the game is lost.
+- **No chat and no colour pick**, both of which the browser lobby has.
+- **Online games do not reach the high score table**, here or on the page.
+- **The server sends both hands to both players.** `get_state` puts every
+  hand in `playerHands`; the browser and this client both decline to draw the
+  opponent's, but anyone reading the socket can see it. That wants fixing in
+  `server.py`, for the browser's sake as much as this one's.
+
+## It is the browser's game, and the browser's opponent
+
+Everything that decides is ported from what the page runs:
+
+| here | there |
+|---|---|
+| `cribbage/cards.py` | the deck and `CribbageHandEval` from `adenosine-cards`, in the website's `arcade/shared/` |
+| `cribbage/ai.py` | `web/js/ai.js`, the opponent |
+| `cribbage/game.py` | `web/js/game.js`, and the turn-taking `web/js/main.js` wraps around it |
+
+`tests/test_oracle.py` holds the port to the page. `tools/js_oracle.mjs`
+loads `adenosine-cards.js`, `config.js`, `ai.js` and `game.js` unmodified,
+plays 120 games against the page's own AI with a scripted player, and the test
+replays every choice through the port. It requires the same deck, cut, hands,
+crib, count, turn, scores and kept cards after every move: about 15,000 moves,
+both sides winning, some games won on his heels and some on a go. `tests/test_cards.py` carries the 50 scoring cases from
+`web/tests/test-scoring.js`, converted line for line.
+
+Wins go to the `cribbage` board the page posts to, as the winner's final score
+with `finalScore` beside it. Losses are not recorded, as on the page.
+
+## Who leads when a hand runs out
+
+After a series, whoever did not lay the last card leads the next, unless
+their hand is empty: then the other side lays out what it has left, alone,
+and takes the go for the last card. The page used to hand the lead to the
+empty hand, then go straight to the show, so the other hand's cards were
+never pegged. The oracle's first 60 games hit that in 32 of them, dropping 42 cards.
+It was fixed in `web/js/game.js` and here in the same change, and the oracle
+now requires that no game drops a card. The multiplayer server already got
+this right.
+
+## Three more, fixed in the page and followed here
+
+cribbage#5 fixed three more bugs in `web/js/game.js`, and the port copies all
+three, so the oracle still holds:
+
+- **The show counts the kept cards.** Pegging empties the hands, and the show
+  used to score those empty hands, so only the crib counted. A game took about
+  21 hands; it now takes about ten.
+- **His heels can win.** A jack turned that takes the dealer to 121 ends the
+  game at the cut. The page used to play on past 121.
+- **So can the go.** The point for a go or the last card can end the game
+  too. The page used to reset the series and peg on.
+
+The oracle requires a game a little under 13 hands on average, and its 120
+games include wins on his heels and on a go.
+
+Needs a 60x22 terminal.
+
+## Licence
+
+[PolyForm Noncommercial 1.0.0](LICENSE), as the rest of this repository. See
+[NOTICE](NOTICE).

magmacrunch_cribbage-0.1.0/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()

magmacrunch_cribbage-0.1.0/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"]

magmacrunch_cribbage-0.1.0/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()