magmacrunch 0.1.0__py3-none-any.whl

magmacrunch/__init__.py

@@ -0,0 +1,20 @@
+"""The magmacrunch terminal arcade.
+
+A menu of every installed cabinet, and the wiring that seats one on the
+terminal it is already holding.
+
+Games are found by enumerating the ``magmacrunch.games`` entry point group -
+see :mod:`texastoast.arcade` for the contract. **Nothing in this package
+imports a game.** Installing one makes it appear here; uninstalling makes it
+vanish; neither needs a release of the arcade.
+
+Imports are kept out of this module so that ``import magmacrunch`` costs
+nothing: the launcher's own screens pull in the engine's terminal backend, and
+``magmacrunch --help`` should not pay for it.
+"""
+
+from __future__ import annotations
+
+__version__ = "0.1.0"
+
+__all__ = ["__version__"]

magmacrunch/__main__.py

@@ -0,0 +1,101 @@
+"""``magmacrunch`` - open the arcade.
+
+    magmacrunch            play
+    magmacrunch --list     print the installed cabinets and exit
+
+Discovery happens here, before the terminal is taken, and that placement is
+load-bearing. :func:`texastoast.arcade.discover` reports a game it could not
+load with :func:`warnings.warn`, and a warning written onto a live Textual
+screen corrupts it. Enumerating first puts anything it has to say on an
+ordinary terminal, where it can be read.
+
+``--list`` is the debugging surface for the same thing: it answers "why is my
+game not in the menu" without taking the screen over at all.
+"""
+
+from __future__ import annotations
+
+import argparse
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        prog="magmacrunch",
+        description="The magmacrunch terminal arcade.",
+    )
+    parser.add_argument(
+        "--list", action="store_true", dest="list_only",
+        help="print the installed cabinets and exit, without opening the arcade",
+    )
+    args = parser.parse_args()
+
+    # Imported here, not at module scope, so --help works without the engine
+    # or its terminal extra installed.
+    from texastoast.arcade import discover
+
+    games = discover()
+
+    if args.list_only:
+        _print(games)
+        return
+
+    from texastoast.core.tui_host import TuiHost
+
+    from magmacrunch.app import ARCADE_INFO, ArcadeApp
+
+    host = TuiHost(title=ARCADE_INFO.title, fps=ARCADE_INFO.fps,
+                   hold_ms=ARCADE_INFO.hold_ms)
+    host.push_scene(ArcadeApp(host, games).root_scene)
+    host.run()
+
+
+def _print(games: list) -> None:
+    """What ``--list`` shows: what was found, and what it wants.
+
+    Titles and blurbs are written by whoever wrote the game, so they can hold
+    anything Unicode holds - a suit glyph, a card, an emoji. Redirected to a
+    file on a legacy Windows codepage that is a ``UnicodeEncodeError``, and a
+    diagnostic that dies on the thing it is diagnosing is worse than useless.
+    Degrade the characters instead.
+    """
+    _degrade_gracefully()
+
+    if not games:
+        print("No cabinets installed.")
+        print()
+        print("  pip install magmacrunch-george-boole")
+        print("  pip install magmacrunch-thld")
+        print()
+        print("Any package declaring a magmacrunch.games entry point appears")
+        print("here. Nothing above this line is a hardcoded list.")
+        return
+
+    print(f"{len(games)} cabinet{'s' if len(games) != 1 else ''} installed:")
+    print()
+    for game in games:
+        info = game.info
+        print(f"  {info.key}")
+        print(f"    {info.title}")
+        print(f"    {info.blurb}")
+        print(f"    wants {info.min_cols}x{info.min_rows}, "
+              f"{info.fps} fps, hold {info.hold_ms} ms")
+        print()
+
+
+def _degrade_gracefully() -> None:
+    """Let stdout substitute characters it cannot encode rather than raising."""
+    import sys
+
+    reconfigure = getattr(sys.stdout, "reconfigure", None)
+    if reconfigure is None:
+        return
+    try:
+        reconfigure(errors="replace")
+    except (ValueError, OSError):
+        # Already detached, or not a stream that can be reconfigured. Printing
+        # is still worth attempting; this was only ever insurance.
+        pass
+
+
+if __name__ == "__main__":
+    main()

magmacrunch/app.py

@@ -0,0 +1,100 @@
+"""Wiring - what outlives one visit to a cabinet, and how the screen reaches it.
+
+Everything that draws lives in :mod:`magmacrunch.scenes`. This holds the host,
+the cabinets that were found, and the one decision the launcher actually makes:
+seating a game.
+
+**The terminal is not owned here.** It belongs to a
+:class:`~texastoast.core.tui_host.TuiHost`, which this is handed - the same
+arrangement the games use, for the same reason. The launcher is not a special
+case of the host; it is another thing seated on one, which is why the menu can
+sit underneath a game and come back when the game leaves.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from texastoast.arcade import ArcadeGame, GameInfo
+
+from magmacrunch import theme
+from magmacrunch.scenes import CabinetScene
+
+#: The launcher, described with the same dataclass it reads from cabinets.
+#:
+#: This is not decoration. ``TuiHost.seat()`` applies a seated game's ``fps``
+#: and ``hold_ms`` to the terminal and nothing puts them back, so the menu has
+#: to retune on the way out of a game - and having its own ``GameInfo`` makes
+#: that ``host.apply(ARCADE_INFO)`` rather than a pair of remembered numbers.
+ARCADE_INFO = GameInfo(
+    key="arcade",
+    title="magmacrunch arcade",
+    blurb="Every cabinet installed on this machine.",
+    # The menu changes only when a key is pressed, and edge input is what keeps
+    # one arrow press from running the selection down the whole list.
+    fps=20,
+    hold_ms=0,
+    min_cols=theme.MIN_COLS,
+    min_rows=theme.MIN_ROWS,
+)
+
+
+class ArcadeApp:
+    """A visit to the arcade, drawing on somebody else's terminal."""
+
+    #: What this asks of a terminal, in the same shape a cabinet declares it.
+    #: The menu reads it back through here when it retunes on the way out of a
+    #: game, which is why the scene needs no import from this module.
+    info = ARCADE_INFO
+
+    def __init__(self, host: Any, games: list[ArcadeGame] | None = None):
+        self.host = host
+        #: Sorted by title, the way :func:`texastoast.arcade.discover` returns
+        #: them. Discovery happens before the terminal is taken - see
+        #: ``__main__`` - so this is handed in rather than looked up.
+        self.games: list[ArcadeGame] = list(games or [])
+        #: What went wrong last time somebody chose a cabinet, if anything.
+        self.error: str = ""
+
+        #: The menu. The caller pushes it, so that this class does not decide
+        #: what the bottom of somebody else's scene stack is.
+        self.root_scene = CabinetScene(self)
+
+    # -- What the scene reaches for ----------------------------------
+
+    @property
+    def renderer(self):
+        return self.host.renderer
+
+    # -- The one decision --------------------------------------------
+
+    def play(self, game: ArcadeGame) -> bool:
+        """Seat a cabinet. Returns whether it started.
+
+        ``TuiHost.seat()`` calls ``game.start(host)``, and that is where a
+        cabinet's real imports finally happen - its rules, its screens, its
+        widgets. It is therefore the first moment a bad install can raise, and
+        it raises with the terminal live and a menu underneath.
+
+        :func:`texastoast.arcade.discover` already refuses to let one broken
+        game take down the whole menu. This keeps that promise past the point
+        where discovery stops looking: the arcade stays up and says which
+        cabinet is out of order.
+        """
+        self.error = ""
+        try:
+            self.host.seat(game)
+        except Exception as exc:  # noqa: BLE001 - one bad cabinet is not fatal
+            self.error = f"{game.info.title} would not start: {exc}"
+            return False
+        return True
+
+    # -- Introspection, for tests ------------------------------------
+
+    @property
+    def scene(self):
+        return self.host.scene
+
+    @property
+    def in_menu(self) -> bool:
+        return self.host.scene is self.root_scene

magmacrunch/banner.py

@@ -0,0 +1,172 @@
+"""The title art, and picking the biggest one that fits.
+
+``arcade.css`` sets ``Press Start 2P`` on nearly every string on the arcade
+page. None of that can come across: a terminal program does not choose its
+font. What carries the same look instead is art drawn *out of characters*,
+which reads the same in whatever monospace font the terminal is set to - and
+the web page already does exactly this for its own title, in Courier Prime
+rather than Press Start 2P, for the same reason.
+
+A terminal is small and resizable, so one piece of art is not enough. The
+variants below are ordered **best first** and :func:`best_fit` returns the
+first the window can actually hold, down to a single line of spaced capitals
+that fits anything. Best rather than widest, because two variants can differ
+on both axes: :data:`ARCADE` is narrower than :data:`WELCOME` and wants twice
+the rows, and on an ordinary 80x24 terminal it is the one worth showing.
+
+That ladder is what keeps the floor low: the banner gives up room before the
+cabinets have to, so the smallest window the arcade draws in is set by one
+card and not by the art.
+
+**Adding art:** put it in :data:`VARIANTS` at the rung it deserves and nothing
+else changes. Art is measured, not declared - a variant too big for the window
+is simply never chosen, so a wrong guess costs a rung rather than breaking a
+screen. That is why :data:`FULL` can sit at the top at 119 columns without
+hurting anyone running a normal terminal.
+"""
+
+from __future__ import annotations
+
+from texastoast.ui import bigtext
+
+#: The arcade page's complete title art, from ``website/arcade/index.html``.
+#:
+#: 119x19 - it needs about a 121x34 terminal, which is a maximised window on a
+#: large monitor and nothing smaller. It is here because it costs nothing to
+#: offer and looks like the website when there is room for it.
+FULL = r"""                                                                                                              /$$      
+                                                                                                             | $$      
+  /$$$$$$/$$$$   /$$$$$$   /$$$$$$  /$$$$$$/$$$$   /$$$$$$   /$$$$$$$  /$$$$$$  /$$   /$$ /$$$$$$$   /$$$$$$$| $$$$$$$ 
+ | $$_  $$_  $$ |____  $$ /$$__  $$| $$_  $$_  $$ |____  $$ /$$_____/ /$$__  $$| $$  | $$| $$__  $$ /$$_____/| $$__  $$
+ | $$ \ $$ \ $$  /$$$$$$$| $$  \ $$| $$ \ $$ \ $$  /$$$$$$$| $$      | $$  \__/| $$  | $$| $$  \ $$| $$      | $$  \ $$
+ | $$ | $$ | $$ /$$__  $$| $$  | $$| $$ | $$ | $$ /$$__  $$| $$      | $$      | $$  | $$| $$  | $$| $$      | $$  | $$
+ | $$ | $$ | $$|  $$$$$$$|  $$$$$$$| $$ | $$ | $$|  $$$$$$$|  $$$$$$$| $$      |  $$$$$$/| $$  | $$|  $$$$$$$| $$  | $$
+ |__/ |__/ |__/ \_______/ \____  $$|__/ |__/ |__/ \_______/ \_______/|__/       \______/ |__/ |__/ \_______/|__/ |__/  
+                          /$$  \ $$                                                                                    
+                         |  $$$$$$/                                                                                    
+                          \______/                                                                                     
+                                                /$$                                                                    
+                                               | $$                                                                    
+  /$$$$$$   /$$$$$$   /$$$$$$$  /$$$$$$   /$$$$$$$  /$$$$$$                                                            
+ |____  $$ /$$__  $$ /$$_____/ |____  $$ /$$__  $$ /$$__  $$                                                           
+  /$$$$$$$| $$  \__/| $$        /$$$$$$$| $$  | $$| $$$$$$$$                                                           
+ /$$__  $$| $$      | $$       /$$__  $$| $$  | $$| $$_____/                                                           
+|  $$$$$$$| $$      |  $$$$$$$|  $$$$$$$|  $$$$$$$|  $$$$$$$                                                           
+ \_______/|__/       \_______/ \_______/ \_______/ \_______/                                                           """
+
+#: MAGMACRUNCH at 71x5 - **the rung a standard 80x24 terminal gets**, and the
+#: only wordmark that fits one. :data:`FULL` says the same word in 119 columns
+#: and eleven rows, which no ordinary window has; this says it in five.
+CHUNKY = """\
+                                                                 __
+.--------.---.-.-----.--------.---.-.----.----.--.--.-----.----.|  |--.
+|        |  _  |  _  |        |  _  |  __|   _|  |  |     |  __||     |
+|__|__|__|___._|___  |__|__|__|___._|____|__| |_____|__|__|____||__|__|
+               |_____|"""
+
+#: The ARCADE half of :data:`FULL` on its own, 60x8. Narrower than
+#: :data:`CHUNKY`, so it is what a window between about 62 and 72 columns gets
+#: - and it is the half of the big art that was always going to survive the
+#: trip, since the MAGMACRUNCH word above it cannot.
+ARCADE = r"""                                                /$$         
+                                               | $$         
+  /$$$$$$   /$$$$$$   /$$$$$$$  /$$$$$$   /$$$$$$$  /$$$$$$ 
+ |____  $$ /$$__  $$ /$$_____/ |____  $$ /$$__  $$ /$$__  $$
+  /$$$$$$$| $$  \__/| $$        /$$$$$$$| $$  | $$| $$$$$$$$
+ /$$__  $$| $$      | $$       /$$__  $$| $$  | $$| $$_____/
+|  $$$$$$$| $$      |  $$$$$$$|  $$$$$$$|  $$$$$$$|  $$$$$$$
+ \_______/|__/       \_______/ \_______/ \_______/ \_______/"""
+
+#: The thin strapline alone, 69x4. Wider than :data:`ARCADE` but a quarter of
+#: the height, which is what makes it the right answer for a short window.
+WELCOME = r"""           |                            |             |    |         
+ . . .,---.|    ,---.,---.,-.-.,---.    |--- ,---.    |--- |---.,---.
+ | | ||---'|    |    |   || | ||---'    |    |   |    |    |   ||---'
+ `-'-'`---'`---'`---'`---'` ' '`---'    `---'`---'    `---'`   '`---'"""
+
+#: The name in the engine's block face, 54x3 - the same lettering the two
+#: cabinets set their own titles in, so the family reads as one thing rather
+#: than as three hand-drawn alphabets.
+BLOCK = bigtext.block("MAGMACRUNCH")
+
+#: A last piece of art before the plain line: two rows rather than three, and
+#: six columns narrower than :data:`BLOCK`, which is the whole of why it is
+#: still here. Hand-drawn, because a two-row face cannot tell B from D and is
+#: therefore no use as a general alphabet - it only works because this one
+#: word happens not to contain the letters that collide.
+WORDMARK = """█▀▄▀█ ▄▀█ █▀▀ █▀▄▀█ ▄▀█ █▀▀ █▀█ █ █ █▄ █ █▀▀ █ █
+█ ▀ █ █▀█ █▄█ █ ▀ █ █▀█ █▄▄ █▀▄ █▄█ █ ▀█ █▄▄ █▀█"""
+
+#: The bottom rung, and the reason the floor is as low as it is. Spaced
+#: capitals are not art, but they fit a 36-column window and still read as a
+#: title rather than a sentence.
+PLAIN = "M A G M A C R U N C H   A R C A D E"
+
+
+def lines(art: str) -> list[str]:
+    return art.split("\n")
+
+
+def size(art: str) -> tuple[int, int]:
+    """``(cols, rows)`` the art occupies."""
+    rows = lines(art)
+    return max((len(line) for line in rows), default=0), len(rows)
+
+
+def over(top: str, bottom: str) -> str:
+    """One block above another, each centred on the wider of the two.
+
+    Composed rather than written out, so that a stacked variant cannot drift
+    from the pieces it is made of. Each block is indented as a whole; centring
+    the *lines* would ragged a block apart, since art lines are not all the
+    same length before padding.
+    """
+    width = max(size(top)[0], size(bottom)[0])
+
+    def block(art: str) -> list[str]:
+        indent = " " * ((width - size(art)[0]) // 2)
+        return [(indent + line).ljust(width) for line in lines(art)]
+
+    return "\n".join(block(top) + [" " * width] + block(bottom))
+
+
+#: MAGMACRUNCH over ARCADE at 71x14: everything :data:`FULL` says, in the
+#: width an ordinary terminal has. It needs a tall window rather than a wide
+#: one, which is the easier of the two to come by.
+STACK = over(CHUNKY, ARCADE)
+
+#: The strapline over the ARCADE wordmark, 69x13.
+HERO = over(WELCOME, ARCADE)
+
+#: Best first. :func:`best_fit` walks this in order and takes the first that
+#: fits, so the ordering is the editorial judgement and the measuring is not.
+#:
+#: The order is not by width. :data:`ARCADE` is narrower than :data:`CHUNKY`
+#: and twice as tall, and which of them a window can take depends on both.
+VARIANTS: tuple[str, ...] = (
+    FULL, STACK, HERO, CHUNKY, ARCADE, WELCOME, BLOCK, WORDMARK, PLAIN,
+)
+
+
+def best_fit(cols: int, rows: int) -> list[str]:
+    """The best variant fitting ``cols`` x ``rows``, as lines to draw.
+
+    Lines come back padded to the art's own width. Art is a block, and a
+    caller centring each line by its own length would ragged the block apart -
+    the top line of :data:`WELCOME` is mostly leading space, so it would sit a
+    dozen cells right of the line beneath it.
+
+    Returns an empty list when even :data:`PLAIN` will not fit, which the
+    caller should treat as "no banner this frame" rather than an error: a
+    window that short has better uses for the row, and the cabinets are the
+    part worth keeping.
+    """
+    for art in VARIANTS:
+        w, h = size(art)
+        if w <= cols and h <= rows:
+            return [line.ljust(w) for line in lines(art)]
+    return []
+
+
+__all__ = ["ARCADE", "BLOCK", "CHUNKY", "FULL", "HERO", "PLAIN", "STACK", "VARIANTS",
+           "WELCOME", "WORDMARK", "best_fit", "lines", "over", "size"]

magmacrunch/cards.py

@@ -0,0 +1,174 @@
+"""The cabinet cards, and where they go.
+
+``.game-grid`` on magmacrunch.com is a two-column grid of bordered cards, each
+carrying a title, a description, a ``▶ ENTER`` line in that card's own accent
+colour, and a border that lights up in the same colour under the cursor. This
+is that, in cells.
+
+Layout is separated from drawing because layout is the part with arithmetic in
+it: how many columns a window takes, how many rows of cards fit under the
+banner, and which page of cards the selected one is on. All of it is pure and
+none of it needs a terminal, so it is tested directly.
+"""
+
+from __future__ import annotations
+
+import textwrap
+from dataclasses import dataclass
+
+from magmacrunch import theme
+
+# Box drawing for the card border. Light rather than heavy: the border is
+# chrome, and the accent colour is what makes the selected card loud.
+TL, TR, BL, BR, H, V = "┌", "┐", "└", "┘", "─", "│"
+
+
+@dataclass(frozen=True)
+class Slot:
+    """Where one card goes, and which cabinet is in it."""
+
+    index: int
+    x: int
+    y: int
+
+
+def columns(width: int) -> int:
+    """How many cards fit across ``width``.
+
+    Two at most - ``.game-grid`` is ``repeat(2, 1fr)`` until 1100px and a
+    terminal is never the wide case.
+    """
+    usable = width - 2 * theme.MARGIN_X
+    if usable >= theme.MAX_COLS * theme.CARD_W + theme.GAP_X:
+        return theme.MAX_COLS
+    return 1
+
+
+def rows(height: int) -> int:
+    """How many rows of cards fit in ``height`` cells."""
+    if height < theme.CARD_H:
+        return 0
+    return 1 + (height - theme.CARD_H) // (theme.CARD_H + theme.GAP_Y)
+
+
+def page_start(selected: int, capacity: int) -> int:
+    """Index of the first card on the page holding ``selected``.
+
+    Paged rather than scrolled by one: a grid that slides a row at a time
+    makes the cards move under the cursor on almost every keypress, where a
+    page turns rarely and lands somewhere predictable.
+    """
+    if capacity <= 0:
+        return 0
+    return (selected // capacity) * capacity
+
+
+def layout(count: int, selected: int, width: int, height: int) -> list[Slot]:
+    """Slots for the cards visible in a ``width`` x ``height`` region.
+
+    The region is what is left after the banner and the chrome have taken
+    theirs. Cards that do not fit on the selected card's page are simply not
+    in the result - see :func:`page_start`.
+    """
+    cols = columns(width)
+    row_count = rows(height)
+    capacity = cols * row_count
+    if capacity <= 0 or count <= 0:
+        return []
+
+    first = page_start(selected, capacity)
+    shown = min(capacity, count - first)
+
+    used_rows = -(-shown // cols)   # ceil
+    grid_w = cols * theme.CARD_W + (cols - 1) * theme.GAP_X
+    grid_h = used_rows * theme.CARD_H + (used_rows - 1) * theme.GAP_Y
+    origin_x = max(theme.MARGIN_X, (width - grid_w) // 2)
+    # Centred vertically as well as horizontally: a part-full last page left
+    # hard against the banner leaves a block of dead rows under it, which
+    # reads as a screen that failed to finish drawing.
+    origin_y = max(0, (height - grid_h) // 2)
+
+    slots = []
+    for offset in range(shown):
+        row, col = divmod(offset, cols)
+        slots.append(Slot(
+            index=first + offset,
+            x=origin_x + col * (theme.CARD_W + theme.GAP_X),
+            y=origin_y + row * (theme.CARD_H + theme.GAP_Y),
+        ))
+    return slots
+
+
+def pages(count: int, width: int, height: int) -> int:
+    """How many pages ``count`` cabinets take. One when they all fit."""
+    capacity = columns(width) * rows(height)
+    if capacity <= 0:
+        return 0
+    return (count + capacity - 1) // capacity
+
+
+def _wrap(text: str, width: int, limit: int) -> list[str]:
+    """``text`` over at most ``limit`` lines, the last one elided if it runs on."""
+    if width <= 0 or limit <= 0:
+        return []
+    out = textwrap.wrap(text, width) or [""]
+    if len(out) <= limit:
+        return out
+    kept = out[:limit]
+    kept[-1] = kept[-1][:max(0, width - 1)].rstrip() + "…"
+    return kept
+
+
+def draw(renderer, slot: Slot, info, *, accent: str, selected: bool,
+         enabled: bool, cursor: bool) -> None:
+    """One card.
+
+    ``cursor`` is the blinking underscore after ENTER, which the web page
+    shows only under the pointer (``.card-arrow`` is ``opacity: 0`` until
+    ``:hover``). Here that is the selected card, blinking on the frame clock.
+    """
+    x, y, w, h = slot.x, slot.y, theme.CARD_W, theme.CARD_H
+    border = accent if selected else theme.CARD_BORDER
+    if not enabled:
+        border = theme.CARD_BORDER
+
+    renderer.draw_rect(x, y, w, h, theme.CARD_BG)
+    renderer.ui_text(x, y, TL + H * (w - 2) + TR, fill=border)
+    renderer.ui_text(x, y + h - 1, BL + H * (w - 2) + BR, fill=border)
+    for row in range(1, h - 1):
+        renderer.ui_text(x, y + row, V, fill=border)
+        renderer.ui_text(x + w - 1, y + row, V, fill=border)
+
+    left = x + 1 + theme.CARD_PAD
+    inner = theme.CARD_INNER
+    title_fill = theme.CARD_TITLE if enabled else theme.MUTED
+
+    line = y + 1
+    for text in _wrap(info.title, inner, 2):
+        renderer.ui_text(left, line, text, fill=title_fill)
+        line += 1
+
+    line += 1
+    if enabled:
+        for text in _wrap(info.blurb, inner, 3):
+            renderer.ui_text(left, line, text, fill=theme.MUTED)
+            line += 1
+    else:
+        # A greyed card with no explanation is a bug report waiting to happen.
+        for text in _wrap(f"needs {info.min_cols}x{info.min_rows}", inner, 2):
+            renderer.ui_text(left, line, text, fill=theme.MUTED)
+            line += 1
+
+    play_y = y + h - 2
+    if enabled:
+        # The cursor belongs to the selected card alone - ``.card-arrow`` is
+        # ``opacity: 0`` until ``:hover``, and a grid where every card blinks
+        # says nothing about which one Enter would start.
+        play = theme.PLAY + ("_" if cursor and selected else "")
+        renderer.ui_text(left, play_y, play,
+                         fill=accent if selected else theme.MUTED)
+    else:
+        renderer.ui_text(left, play_y, "TOO BIG", fill=theme.CARD_BORDER)
+
+
+__all__ = ["Slot", "columns", "draw", "layout", "page_start", "pages", "rows"]

magmacrunch/scenes.py

@@ -0,0 +1,284 @@
+"""The arcade floor, as a scene.
+
+One screen: the title art, a grid of every cabinet that was found, and a way
+into one. It draws through the engine's ``Renderer``/``UISurface`` protocols
+and does not know what Textual is.
+
+The layout follows magmacrunch.com's arcade page - banner, tagline, a blinking
+INSERT COIN, then the card grid - and gives up its parts in that order as the
+window shrinks, so that the cabinets are the last thing to go. See
+:mod:`magmacrunch.banner` and :mod:`magmacrunch.cards`.
+
+Modality is the stack, not a flag - the engine's own rule. This sits at the
+bottom; seating a cabinet pushes its scenes on top, and the cabinet leaving
+pops back down to here. Nothing needs an ``in_game`` boolean, and the floor
+cannot be updated while a game is over it because the stack will not call it.
+
+The engine's ``Menu`` widget is deliberately not used. It draws a centred list
+of single-line rows, which is the wrong shape for a grid of bordered cards -
+so selection state lives here instead, in :attr:`CabinetScene.selected`.
+"""
+
+from __future__ import annotations
+
+from magmacrunch import banner, cards, theme
+
+MENU_HELP = "↑↓←→ CHOOSE    ENTER PLAY    Q QUIT"
+
+EMPTY_FLOOR = (
+    "NO CABINETS INSTALLED",
+    "",
+    "pip install magmacrunch-george-boole",
+    "pip install magmacrunch-thld",
+    "",
+    "Any package declaring a magmacrunch.games entry point",
+    "appears here - no release of the arcade needed.",
+)
+
+
+def _fit(text: str, width: int) -> str:
+    """Trim to ``width``, marking the cut so a clipped line reads as clipped."""
+    if width <= 1 or len(text) <= width:
+        return text
+    return text[:width - 1] + "…"
+
+
+def _too_small(renderer, cols: int, rows: int) -> bool:
+    """Say so rather than drawing a clipped screen.
+
+    Two short lines rather than one long one, because the message is being
+    shown precisely when the terminal is narrow: a single line stating both
+    sizes runs past 40 columns and gets cut mid-number, which reads as a bug in
+    the thing reporting the problem.
+    """
+    if renderer.width >= cols and renderer.height >= rows:
+        return False
+    renderer.ui_text(1, 1, "TERMINAL TOO SMALL", fill=theme.ERROR)
+    renderer.ui_text(
+        1, 2,
+        f"need {cols}x{rows}, have {renderer.width}x{renderer.height}",
+        fill=theme.MUTED,
+    )
+    return True
+
+
+class CabinetScene:
+    """The grid of installed games.
+
+    ``render_below`` is deliberately *not* set: a cabinet seated on top covers
+    this completely, so drawing underneath it would be wasted work.
+    """
+
+    def __init__(self, app):
+        self.app = app
+        #: Which cabinet the cursor is on. Kept here rather than in a widget
+        #: because the grid is drawn here - see the module docstring.
+        self.selected = 0
+        #: Seconds since the scene started, for the blinking cursor and coin.
+        #: A frame clock rather than a wall clock so the blink is the engine's
+        #: business and stays put when the loop is stopped in a test.
+        self.elapsed = 0.0
+
+    # -- The grid ----------------------------------------------------
+
+    @property
+    def highlighted(self):
+        if not self.app.games:
+            return None
+        return self.app.games[self.selected]
+
+    def _enabled(self, game) -> bool:
+        """Whether this window is big enough to seat ``game``.
+
+        ``GameInfo.fits`` exists for exactly this. Asked at the moment it is
+        needed rather than cached, so a resize is reflected in the same frame
+        that draws it.
+        """
+        r = self.app.renderer
+        return game.info.fits(r.width, r.height)
+
+    def _grid_region(self) -> tuple[int, int]:
+        """``(width, height)`` left for cards after the chrome takes its share."""
+        r = self.app.renderer
+        used = self._banner_rows() + theme.HEADER_ROWS + theme.FOOTER_ROWS + 2
+        return r.width, max(0, r.height - used)
+
+    def _banner_rows(self) -> int:
+        r = self.app.renderer
+        return len(banner.best_fit(r.width - 2, self._banner_budget()))
+
+    def _banner_budget(self) -> int:
+        """Rows the banner may have.
+
+        It is given whatever is left once one row of cards and the chrome are
+        accounted for, so the art stands down before the cabinets do. That is
+        what keeps the floor at one card rather than at the widest banner.
+        """
+        r = self.app.renderer
+        spare = r.height - (theme.HEADER_ROWS + theme.CARD_H + theme.FOOTER_ROWS + 2)
+        return max(0, spare)
+
+    def _move(self, delta: int) -> None:
+        if not self.app.games:
+            return
+        self.selected = (self.selected + delta) % len(self.app.games)
+
+    def _move_row(self, delta: int) -> None:
+        """Up/down moves by a whole row of the grid, not by one card."""
+        if not self.app.games:
+            return
+        width, height = self._grid_region()
+        self._move(delta * cards.columns(width))
+
+    def choose(self) -> None:
+        game = self.highlighted
+        if game is None or not self._enabled(game):
+            return
+        if not self.app.play(game):
+            # Nothing was pushed, so nothing will pop and no on_resume will
+            # fire. The error is drawn on the floor instead.
+            pass
+
+    # -- Stack hooks -------------------------------------------------
+
+    def on_resume(self) -> None:
+        """Take the terminal back from a cabinet that has just left.
+
+        ``TuiHost.seat()`` applies the seated game's declared ``fps`` and
+        ``hold_ms``, and nothing puts them back - so a real-time cabinet
+        handing control back would leave the floor running at its frame rate
+        with its held-key decay, and arrows would skate across the grid on
+        auto-repeat instead of stepping.
+
+        Retuning here rather than in the host is deliberate: the host cannot
+        know what to revert *to*. Only whatever is underneath does, and that
+        is this.
+        """
+        self.app.host.apply(self.app.info)
+
+    # -- Frame -------------------------------------------------------
+
+    def update(self, dt: float) -> None:
+        self.elapsed += dt
+
+    def handle_key(self, key: str) -> bool:
+        if key in ("left", "a", "h"):
+            self._move(-1)
+        elif key in ("right", "d", "l"):
+            self._move(1)
+        elif key in ("up", "w", "k"):
+            self._move_row(-1)
+        elif key in ("down", "s", "j"):
+            self._move_row(1)
+        elif key in ("enter", "space"):
+            self.choose()
+        elif key == "q":
+            self.app.host.quit()
+        elif key == "escape":
+            # The same call a cabinet makes to leave. This is the bottom of the
+            # stack, so it ends the session - see TuiHost.pop_scene.
+            self.app.host.pop_scene()
+        else:
+            return False
+        return True
+
+    def render(self) -> None:
+        r = self.app.renderer
+        r.clear()
+        r.draw_rect(0, 0, r.width, r.height, theme.BG)
+
+        if _too_small(r, theme.MIN_COLS, theme.MIN_ROWS):
+            r.present()
+            return
+
+        cx = r.width // 2
+        y = self._render_header(r, cx)
+
+        if self.app.games:
+            self._render_grid(r, y)
+        else:
+            self._render_empty_floor(r, cx, y)
+
+        self._render_footer(r, cx)
+        r.present()
+
+    def _render_header(self, r, cx: int) -> int:
+        """Banner, tagline and coin. Returns the first row below them."""
+        y = 0
+        art = banner.best_fit(r.width - 2, self._banner_budget())
+        for line in art:
+            r.ui_text(cx, y, line, fill=theme.CYAN, anchor="n")
+            y += 1
+
+        r.ui_text(cx, y, theme.TAGLINE, fill=theme.PINK, anchor="n")
+        y += 1
+        if self._blink(theme.COIN_BLINK_SECONDS):
+            r.ui_text(cx, y, theme.INSERT_COIN, fill=theme.YELLOW, anchor="n")
+        y += 2
+        return y
+
+    def _render_grid(self, r, top: int) -> None:
+        width, height = self._grid_region()
+        slots = cards.layout(len(self.app.games), self.selected, width, height)
+        cursor = self._blink(theme.BLINK_SECONDS)
+
+        for slot in slots:
+            game = self.app.games[slot.index]
+            cards.draw(
+                r, cards.Slot(slot.index, slot.x, slot.y + top), game.info,
+                accent=theme.accent(slot.index),
+                selected=slot.index == self.selected,
+                enabled=self._enabled(game),
+                cursor=cursor,
+            )
+
+        total = cards.pages(len(self.app.games), width, height)
+        if total > 1 and slots:
+            capacity = cards.columns(width) * cards.rows(height)
+            here = self.selected // capacity + 1
+            # Directly under the grid rather than at a fixed row near the
+            # bottom, where it would land on the error line.
+            below = top + max(s.y for s in slots) + theme.CARD_H
+            r.ui_text(r.width // 2, below, f"PAGE {here}/{total}",
+                      fill=theme.MUTED, anchor="n")
+
+    def _render_footer(self, r, cx: int) -> None:
+        if self.app.error:
+            r.ui_text(cx, r.height - 4, _fit(self.app.error, r.width - 2),
+                      fill=theme.ERROR, anchor="n")
+        r.ui_text(cx, r.height - 3, _fit(MENU_HELP, r.width - 2),
+                  fill=theme.MUTED, anchor="n")
+        self._render_credits(r, cx)
+
+    def _render_credits(self, r, cx: int) -> None:
+        """The signature, with the domain in the colour the web page links in.
+
+        Drawn as two runs at computed positions rather than one centred
+        string, because ``.credits-row a`` is cyan against muted text and a
+        single ``ui_text`` gets one colour. Falls back to the copyright alone
+        when the window is too narrow to carry both.
+        """
+        y = r.height - 2
+        full = theme.COPYRIGHT + theme.CREDITS_SEP + theme.DOMAIN
+        if len(full) + 2 > r.width:
+            r.ui_text(cx, y, _fit(theme.COPYRIGHT, r.width - 2),
+                      fill=theme.CARD_BORDER, anchor="n")
+            return
+        x = cx - len(full) // 2
+        r.ui_text(x, y, theme.COPYRIGHT + theme.CREDITS_SEP,
+                  fill=theme.CARD_BORDER)
+        r.ui_text(x + len(theme.COPYRIGHT) + len(theme.CREDITS_SEP), y,
+                  theme.DOMAIN, fill=theme.CYAN)
+
+    def _render_empty_floor(self, r, cx: int, top: int) -> None:
+        for i, line in enumerate(EMPTY_FLOOR):
+            fill = theme.YELLOW if i == 0 else theme.MUTED
+            r.ui_text(cx, top + i + 1, _fit(line, r.width - 2),
+                      fill=fill, anchor="n")
+
+    def _blink(self, period: float) -> bool:
+        """On for the first half of each period, off for the second.
+
+        ``animation: blink 0.6s step-end infinite`` in ``arcade.css``.
+        """
+        return (self.elapsed % period) < period / 2

magmacrunch/theme.py

@@ -0,0 +1,96 @@
+"""Palette and layout for the arcade floor, in character cells.
+
+The colours are magmacrunch.com's arcade page, lifted from ``arcade.css`` so
+the terminal and the browser are recognisably the same place. What could not
+come with them is the typography: ``arcade.css`` sets ``Press Start 2P`` on
+almost everything, and **a terminal program does not choose its font** - the
+font is whatever the person running it has their emulator set to. The web page
+already runs into this itself, which is why its own title art is Courier Prime
+rather than Press Start 2P: pixel lettering in a terminal has to be drawn out
+of block glyphs, not asked for. See :mod:`magmacrunch.banner`.
+
+Split out so :mod:`magmacrunch.scenes` and :mod:`magmacrunch.app` can share it
+without importing each other. Nothing here imports the engine.
+
+Every measurement is **cells**, not pixels.
+"""
+
+from __future__ import annotations
+
+TAGLINE = "EVERY CABINET ON THIS MACHINE"
+INSERT_COIN = "INSERT COIN"
+
+# ── Palette ─────────────────────────────────────────────────────────
+# arcade.css, near enough verbatim. The names are the web page's roles.
+
+#: ``body { background: #0a0612 }``
+BG = "#0a0612"
+#: ``.game-card { background: #150b29 }``
+CARD_BG = "#150b29"
+#: ``.game-card { border: 2px solid #3a2d5c }`` - the resting border.
+CARD_BORDER = "#3a2d5c"
+#: ``.card-title { color: #f0f8ff }``
+CARD_TITLE = "#f0f8ff"
+#: ``.card-desc`` and ``.breadcrumb`` - the muted body colour.
+MUTED = "#8a7fa8"
+
+CYAN = "#00f0ff"      # .arcade-title-ascii, links
+PINK = "#ff2e9c"      # .arcade-subtitle, --nav-accent, the default card colour
+YELLOW = "#fff733"    # .insert-coin, the scoreboard header
+GREEN = "#39ff6e"     # card-games card
+AMBER = "#ffe03a"     # puzzles card
+
+ERROR = PINK
+
+#: One accent per cabinet, cycled by position, in the order the four category
+#: cards use them on the web page. ``.game-card:hover`` puts this on the
+#: border and ``.card-play`` puts it on the ENTER line, which is exactly what
+#: a selected card does here.
+ACCENTS = (CYAN, GREEN, AMBER, PINK)
+
+
+def accent(index: int) -> str:
+    return ACCENTS[index % len(ACCENTS)]
+
+
+# ── Cards ───────────────────────────────────────────────────────────
+
+#: A card is 32x9 with a two-cell gutter, and the grid is at most two across
+#: - ``.game-grid`` is ``repeat(2, 1fr)`` until 1100px, and a terminal is
+#: never the wide case.
+CARD_W = 32
+CARD_H = 9
+GAP_X = 2
+GAP_Y = 1
+MAX_COLS = 2
+
+#: Border on both sides plus a cell of padding inside it.
+CARD_PAD = 1
+#: What a card has left for text.
+CARD_INNER = CARD_W - 2 * (1 + CARD_PAD)
+
+MARGIN_X = 2
+#: Rows above the grid that are not the banner: the tagline and INSERT COIN.
+HEADER_ROWS = 2
+#: Rows below it: the error line, the key help and the credits.
+FOOTER_ROWS = 3
+
+#: The footer signature, in two parts so the domain can carry the link colour
+#: the web page gives it (``.credits-row a { color: #00f0ff }``).
+COPYRIGHT = "© 2026 magmacrunch media"
+DOMAIN = "magmacrunch.com"
+CREDITS_SEP = "  ·  "
+
+PLAY = "▶ ENTER"
+#: ``.card-arrow { animation: blink 0.6s step-end infinite }`` - the cursor
+#: after ENTER on the selected card, on for one half-period and off the next.
+BLINK_SECONDS = 0.6
+#: ``.insert-coin { animation: blink 1s step-end infinite }``
+COIN_BLINK_SECONDS = 1.0
+
+#: Smallest terminal the floor is drawn in: one card, one column, plus the
+#: chrome that never goes away. Derived so the floor cannot drift from the
+#: layout. The banner is not in it - it stands down to whatever fits, and at
+#: the bottom rung it is one line. See :func:`magmacrunch.banner.best_fit`.
+MIN_COLS = CARD_W + 2 * MARGIN_X
+MIN_ROWS = 1 + HEADER_ROWS + CARD_H + FOOTER_ROWS + 2

magmacrunch-0.1.0.dist-info/METADATA

@@ -0,0 +1,140 @@
+Metadata-Version: 2.5
+Name: magmacrunch
+Version: 0.1.0
+Summary: The magmacrunch terminal arcade - a menu of every installed cabinet
+Project-URL: Homepage, https://magmacrunch.com/arcade/
+Author: magmacrunch media
+License-Expression: PolyForm-Noncommercial-1.0.0
+License-File: LICENSE
+License-File: NOTICE
+Keywords: arcade,games,launcher,terminal,tui
+Requires-Python: >=3.10
+Requires-Dist: magmacrunch-george-boole>=0.1.0
+Requires-Dist: magmacrunch-moonlight-drift>=0.1.0
+Requires-Dist: magmacrunch-thld>=0.1.0
+Requires-Dist: texastoast[tui]>=0.10.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == 'dev'
+Requires-Dist: ruff>=0.6; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# magmacrunch
+
+The terminal arcade. One command, a menu of every cabinet installed on the
+machine, and a way into one.
+
+```
+pip install magmacrunch
+magmacrunch
+```
+
+```
+                                                             __
+ .--------.---.-.-----.--------.---.-.----.----.--.--.-----.----.|  |--.
+ |        |  _  |  _  |        |  _  |  __|   _|  |  |     |  __||     |
+ |__|__|__|___._|___  |__|__|__|___._|____|__| |_____|__|__|____||__|__|
+                |_____|
+                   EVERY CABINET ON THIS MACHINE
+                            INSERT COIN
+
+
+┌──────────────────────────────┐  ┌──────────────────────────────┐
+│ George Boole Has Entered The │  │ Texas Hold'Em Lava Dome      │
+│ Chat                         │  │                              │
+│                              │  │ Solo hold'em against a       │
+│ 2048 played with logic gates │  │ threshold that climbs every  │
+│ — merge, invert, overflow.   │  │ round.                       │
+│                              │  │                              │
+│ ▶ ENTER_                     │  │ ▶ ENTER                      │
+└──────────────────────────────┘  └──────────────────────────────┘
+
+                ↑↓←→ CHOOSE    ENTER PLAY    Q QUIT
+           © 2026 magmacrunch media  ·  magmacrunch.com
+```
+
+It is `magmacrunch.com/arcade` in a shell — the same palette, the same card
+grid, the same blinking cursor on the card you are about to start. The one
+thing that could not come across is the typography: `arcade.css` sets
+`Press Start 2P` on nearly every string, and a terminal program does not
+choose its font. Pixel lettering has to be *drawn*, out of block glyphs, which
+is what the narrow title variant does — and what the web page's own title art
+does too, in Courier Prime rather than Press Start 2P, for the same reason.
+
+The title art stands down as the window grows or shrinks, and always before
+the cabinets have to — which is what keeps the floor as low as it is:
+
+| window | banner |
+|---|---|
+| 121×34 and up | the full site wordmark, MAGMACRUNCH over ARCADE, 119×19 |
+| ~73×30 | the same two words in 71 columns instead of 119 |
+| **80×24** | **MAGMACRUNCH alone, 71×5** |
+| ~62–72 cols | the ARCADE wordmark alone, 60×8 |
+| ~50 cols | a block-glyph MAGMACRUNCH, 48×2 |
+| 36 cols | spaced capitals |
+
+Art is measured rather than declared, so the 119-column piece can sit at the
+top of the list without ever bothering someone on an ordinary terminal — it
+is simply never the one that fits. Adding your own is one entry in `VARIANTS`
+in [`banner.py`](magmacrunch/banner.py) and nothing else.
+
+Choosing a cabinet starts it on the terminal the arcade is already holding.
+Leaving the game brings you back here. Every game is also its own command
+(`george-boole`, `lava-dome`, `moonlight-drift`) and plays identically either way — the arcade is
+not a wrapper around them, it is the same host they run on.
+
+## What is installed
+
+```
+magmacrunch --list
+```
+
+Prints every cabinet found, what terminal size it wants, and how it wants
+input. If a game you installed is not in the menu, this says why — a game that
+fails to load is reported rather than silently skipped.
+
+## How games get here
+
+Games are **not** bundled. Each one lives in its own repo alongside its browser
+and Wii versions, publishes its own wheel, and declares an entry point:
+
+```toml
+[project.entry-points."magmacrunch.games"]
+george-boole = "boole.arcade:GAME"
+```
+
+pointing at an object with `info: GameInfo` and `start(host) -> scene`. The
+launcher enumerates that group at startup. **Installing a game makes it appear
+here; uninstalling makes it vanish; neither needs a release of the arcade.**
+
+Nothing in this package imports a game, so the arcade runs with none installed
+and tells you how to get one. The contract lives in
+[`texastoast.arcade`](https://pypi.org/project/texastoast/); the two cabinets
+above are worked examples of it.
+
+## Cabinets
+
+| | |
+|---|---|
+| `magmacrunch-george-boole` | 2048 played with logic gates |
+| `magmacrunch-thld` | Solo hold'em against a climbing threshold |
+| `magmacrunch-moonlight-drift` | Thread the columns; hold to climb |
+
+Installing `magmacrunch` installs all three.
+
+## Requires
+
+Python 3.10+, and a terminal at least 36×17. Individual cabinets ask for more
+(around 59×22); below that their card greys out, says the size it wants, and
+cannot be started. The arcade's own floor is deliberately lower than any
+game's, so getting to the floor is never the thing that fails.
+
+Two cards sit side by side from 70 columns and stack into one below that. More
+cabinets than fit are paged, not scrolled.
+
+Truecolor helps but is not required.
+
+## Licence
+
+PolyForm Noncommercial 1.0.0 — see [LICENSE](LICENSE) and [NOTICE](NOTICE).
+Noncommercial because the games it seats are. The engine underneath,
+[texastoast](https://pypi.org/project/texastoast/), stays Apache-2.0.

magmacrunch-0.1.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+magmacrunch/__init__.py,sha256=a4EEYSnLnwyaBHKgxnHvCImPwTLg1b7TzhWDxIlk6Co,705
+magmacrunch/__main__.py,sha256=SAJjcnMmuQbiQA3rE2UY8wmqNJ_08wtILIkNhcsSplE,3290
+magmacrunch/app.py,sha256=F8ky-2yZXGQ5-q5c8mMSX9WO66EkT-KLf_EtO2jH3dk,3944
+magmacrunch/banner.py,sha256=UjtHesK9_R4z7-3r6jV_4UxQN81S1WWvTsirV19HfcA,9597
+magmacrunch/cards.py,sha256=zDKL9UjDoFEV9MCgIMq1-tbD1jLG1mFjTsLfxv7RNKE,6185
+magmacrunch/scenes.py,sha256=aJnuPZuesbT08c0YxwxdbGThtkgoe8Px3dCfQf7nSAo,10871
+magmacrunch/theme.py,sha256=kAx6KOLLLeNdj6BnFCCcQ-DLuwxN03ZbrtDX2Tf1G8A,3904
+magmacrunch-0.1.0.dist-info/METADATA,sha256=aynF4E12HXiPgjxJDEkUlxxj1X0Ls3qGUIVJ3C2a4kA,5915
+magmacrunch-0.1.0.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
+magmacrunch-0.1.0.dist-info/entry_points.txt,sha256=0JqIHnkppyYXU3HVxCTiZWUdA19NYzy1UDPaxSQUrFo,58
+magmacrunch-0.1.0.dist-info/licenses/LICENSE,sha256=dQ7s_huoOpXIV8Gtdt3ZVm4N2UofO4MvxlappsL14Q8,4640
+magmacrunch-0.1.0.dist-info/licenses/NOTICE,sha256=4NAfifkrNa6CCMl7Q8ibvd3y4Xhvykwf-muPIg6LB8c,1330
+magmacrunch-0.1.0.dist-info/RECORD,,

magmacrunch-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.0
+Root-Is-Purelib: true
+Tag: py3-none-any

magmacrunch-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+magmacrunch = magmacrunch.__main__:main

magmacrunch-0.1.0.dist-info/licenses/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-0.1.0.dist-info/licenses/NOTICE

@@ -0,0 +1,33 @@
+magmacrunch — the terminal arcade
+Copyright 2026 magmacrunch media
+
+
+THE LICENCE
+
+Everything in this repository -- the launcher, the tests, the build files 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 it or a derivative of it, shipping it
+inside a product, or running it as part of a business.
+
+It is Noncommercial because the games it seats are. This package contains no
+game code -- it finds installed games by entry point and never imports one --
+but it depends on them, and a package cannot be more permissive than what it
+depends on.
+
+
+WHAT THIS DEPENDS ON
+
+texastoast, the engine, with its terminal backend. Apache License 2.0,
+copyright 2026 magmacrunch media. https://pypi.org/project/texastoast/
+
+texastoast's terminal backend depends in turn on Textual, and through it on
+Rich (MIT, copyright Will McGugan). Both carry their own licences in the
+installed distributions.
+
+The cabinets -- magmacrunch-george-boole, magmacrunch-thld -- are each
+PolyForm Noncommercial 1.0.0, copyright 2026 magmacrunch media, and carry
+their own NOTICE files.