magmacrunch-threes 0.1.0__tar.gz

magmacrunch_threes-0.1.0/.gitignore

@@ -0,0 +1,7 @@
+# The link tools/link-shared.mjs makes to the website's arcade/shared/.
+/shared
+__pycache__/
+*.pyc
+.pytest_cache/
+node_modules/
+.DS_Store

magmacrunch_threes-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_threes-0.1.0/NOTICE

@@ -0,0 +1,36 @@
+threes
+Copyright 2026 magmacrunch media
+
+
+THE LICENCE
+
+Everything in this repository -- the game in web/, its terminal version in
+tui/, its tests, 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.
+
+
+THE NAME IS NOT OURS
+
+Threes! is Sirvo's game (Asher Vollmer, Greg Wohlwend and Jimmy Hinson, 2014), and
+its name is theirs. This is an unofficial fan implementation, played for free in the
+magmacrunch arcade, and is not affiliated with or endorsed by Sirvo. Nothing here
+claims the name, and the licence above grants no rights in it. What is licensed is
+this implementation only: the code and the arcade's presentation.
+
+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 page loads adenosine-puzzle.js, adenosine-score-client.js, arcade-base.css, puzzle/puzzle-base.css, puzzle/puzzle-grid.css, puzzle/puzzle-modals.css, puzzle/puzzle-responsive.css, score-server.js from the website's arcade/shared/.
+Those are part of the magmacrunch.com repository and adenosine, and are not copied here.

magmacrunch_threes-0.1.0/PKG-INFO

@@ -0,0 +1,75 @@
+Metadata-Version: 2.5
+Name: magmacrunch-threes
+Version: 0.1.0
+Summary: THREES - slide, merge, survive. Terminal version.
+Project-URL: Homepage, https://magmacrunch.com/arcade/threes/
+Author: magmacrunch media
+License-Expression: PolyForm-Noncommercial-1.0.0
+License-File: LICENSE
+License-File: NOTICE
+Keywords: arcade,games,puzzle,terminal,tiles,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'
+Description-Content-Type: text/markdown
+
+# THREES (terminal)
+
+Slide, merge, survive, 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.
+
+```
+pip install -e ".[dev]"
+python -m threes
+```
+
+## Keys
+
+| key | |
+|---|---|
+| arrows (or WASD, hjkl) | slide every tile one step |
+| `R` | new game |
+| `Esc` | the title (from the title, back to the arcade) |
+| `Q` | quit |
+
+1 + 2 makes 3, and from there same plus same; 1 + 1 and 2 + 2 do not merge.
+The new tile comes in on the edge you slid away from, and lights up for a
+moment so you can see where it landed.
+
+## It is the browser's game
+
+`threes/rules.py` is `web/js/game.js` plus the part of adenosine-puzzle's
+`createGame` it relies on: a move is the left slide with the board rotated
+round it, and only a move that changed something brings a tile and counts.
+`tests/test_oracle.py` checks it: `tools/js_oracle.mjs` loads the website's
+`adenosine-puzzle.js` and `web/js/game.js` unmodified with `Math.random`
+seeded, plays 300 games through the game's own `handleMove()`, and the test
+replays every move through the port and requires the same board, score and
+move count after each one, and the same answer to whether it moved at all.
+
+The oracle needs the website, for the bundle. It finds it the way
+`tools/link-shared.mjs` does: `../shared`, `$WEBSITE`, `../../website`,
+`../../../web/website`. CI checks the website out beside the game.
+
+The browser's choices are copied rather than improved, because both versions
+share a scoreboard and a rule changed in one would make its scores mean
+something else:
+
+- **Three new tiles in four are 1s** (75% 1, 15% 2, 10% 3), and a 1 merges only
+  with a 2, so the board fills with 1s and a game lasts a few dozen moves.
+  The original Threes! deals 1s and 2s about evenly.
+- **The score is the sum of every merge**, not the original's powers of three.
+
+Change either in `web/js/game.js` and here together, and the oracle will hold
+the two to each other.
+
+Needs a 56x21 terminal.
+
+## Licence
+
+[PolyForm Noncommercial 1.0.0](LICENSE), as the rest of this repository. See
+[NOTICE](NOTICE), which also says whose the name is.

magmacrunch_threes-0.1.0/README.md

@@ -0,0 +1,58 @@
+# THREES (terminal)
+
+Slide, merge, survive, 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.
+
+```
+pip install -e ".[dev]"
+python -m threes
+```
+
+## Keys
+
+| key | |
+|---|---|
+| arrows (or WASD, hjkl) | slide every tile one step |
+| `R` | new game |
+| `Esc` | the title (from the title, back to the arcade) |
+| `Q` | quit |
+
+1 + 2 makes 3, and from there same plus same; 1 + 1 and 2 + 2 do not merge.
+The new tile comes in on the edge you slid away from, and lights up for a
+moment so you can see where it landed.
+
+## It is the browser's game
+
+`threes/rules.py` is `web/js/game.js` plus the part of adenosine-puzzle's
+`createGame` it relies on: a move is the left slide with the board rotated
+round it, and only a move that changed something brings a tile and counts.
+`tests/test_oracle.py` checks it: `tools/js_oracle.mjs` loads the website's
+`adenosine-puzzle.js` and `web/js/game.js` unmodified with `Math.random`
+seeded, plays 300 games through the game's own `handleMove()`, and the test
+replays every move through the port and requires the same board, score and
+move count after each one, and the same answer to whether it moved at all.
+
+The oracle needs the website, for the bundle. It finds it the way
+`tools/link-shared.mjs` does: `../shared`, `$WEBSITE`, `../../website`,
+`../../../web/website`. CI checks the website out beside the game.
+
+The browser's choices are copied rather than improved, because both versions
+share a scoreboard and a rule changed in one would make its scores mean
+something else:
+
+- **Three new tiles in four are 1s** (75% 1, 15% 2, 10% 3), and a 1 merges only
+  with a 2, so the board fills with 1s and a game lasts a few dozen moves.
+  The original Threes! deals 1s and 2s about evenly.
+- **The score is the sum of every merge**, not the original's powers of three.
+
+Change either in `web/js/game.js` and here together, and the oracle will hold
+the two to each other.
+
+Needs a 56x21 terminal.
+
+## Licence
+
+[PolyForm Noncommercial 1.0.0](LICENSE), as the rest of this repository. See
+[NOTICE](NOTICE), which also says whose the name is.

magmacrunch_threes-0.1.0/pyproject.toml

@@ -0,0 +1,50 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+# Prefixed like every other cabinet: PyPI cannot scope a family, so the prefix
+# claims it. The import package stays plain `threes`, and the command a player
+# types is `threes`.
+name = "magmacrunch-threes"
+version = "0.1.0"
+description = "THREES - slide, merge, survive. Terminal version."
+readme = "README.md"
+license = "PolyForm-Noncommercial-1.0.0"
+license-files = ["LICENSE", "NOTICE"]
+requires-python = ">=3.10"
+authors = [{ name = "magmacrunch media" }]
+keywords = ["arcade", "terminal", "tui", "games", "puzzle", "tiles"]
+
+# The engine, with its terminal backend. threes/rules.py imports neither and
+# runs on a bare interpreter, which tests/test_rules.py and
+# tests/test_oracle.py rely on. 0.7.0 is where magmacrunch.engine.ui.glyphs
+# arrives, which run() imports.
+dependencies = ["magmacrunch>=0.7.0"]
+
+[project.optional-dependencies]
+dev = ["pytest>=7.0", "ruff>=0.6"]
+
+[project.scripts]
+threes = "threes.__main__:main"
+
+# Found by a launcher enumerating installed games. This line is the whole of
+# what puts THREES on the arcade floor - see magmacrunch.engine.arcade.
+[project.entry-points."magmacrunch.games"]
+threes = "threes.arcade:GAME"
+
+[project.urls]
+Homepage = "https://magmacrunch.com/arcade/threes/"
+
+[tool.hatch.build.targets.wheel]
+packages = ["threes"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+
+[tool.ruff]
+target-version = "py310"
+line-length = 100
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "UP", "B"]

magmacrunch_threes-0.1.0/tests/conftest.py

@@ -0,0 +1,56 @@
+"""Shared fixtures.
+
+The browser's own answers, generated once per session rather than committed,
+so the trace cannot go stale against a web build that has moved on. A
+committed trace agrees with itself forever; this one is regenerated from
+whatever ``web/js/game.js`` says today.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import shutil
+import subprocess
+from pathlib import Path
+
+import pytest
+
+TUI = Path(__file__).resolve().parents[1]
+ORACLE = TUI / "tools" / "js_oracle.mjs"
+WEB = TUI.parent / "web"
+
+
+def node_available() -> bool:
+    return shutil.which("node") is not None and (WEB / "js" / "game.js").exists()
+
+
+@pytest.fixture(scope="session")
+def trace(tmp_path_factory):
+    """Everything the browser did, as JSON. Skips when node or web/ is absent.
+
+    web/ is absent from an installed wheel, which is the case that matters:
+    these tests are a development guarantee, not something a player's machine
+    should have to satisfy. A web build that is present but will not load is a
+    failure, not a skip, so a broken oracle cannot pass by comparing nothing.
+    """
+    if not node_available():
+        # CI sets this, so a runner that lost node fails rather than passing
+        # with the one test that matters skipped.
+        if os.environ.get("THREES_REQUIRE_ORACLE"):
+            pytest.fail("THREES_REQUIRE_ORACLE is set and node or web/js/game.js is missing")
+        pytest.skip("needs node and web/js/game.js (absent from an installed wheel)")
+
+    node = shutil.which("node")
+    probe = subprocess.run([node, str(ORACLE), "--check"], capture_output=True,
+                           text=True, cwd=TUI)
+    if probe.returncode != 0:
+        pytest.fail("js_oracle.mjs cannot load the game (is the website beside it?):\n"
+                    + probe.stderr)
+
+    out = tmp_path_factory.mktemp("oracle") / "oracle.json"
+    proc = subprocess.run([node, str(ORACLE), str(out)], capture_output=True,
+                          text=True, cwd=TUI)
+    if proc.returncode != 0:
+        pytest.fail(f"js_oracle.mjs failed:\n{proc.stderr}")
+    return json.loads(out.read_text(encoding="utf-8"))

magmacrunch_threes-0.1.0/tests/test_app.py

@@ -0,0 +1,280 @@
+"""The screens, driven on a real host. Skipped without Textual."""
+
+from __future__ import annotations
+
+import asyncio
+from pathlib import Path
+
+import pytest
+
+pytest.importorskip("textual", reason='needs: pip install -e ".[dev]"')
+
+from magmacrunch.engine import scores as score_mod  # noqa: E402
+from magmacrunch.engine.arcade import ArcadeGame  # noqa: E402
+from magmacrunch.engine.core.tui_host import TuiHost  # noqa: E402
+from magmacrunch.engine.ui.glyphs import FALLBACKS  # noqa: E402
+
+from threes import rules, scenes  # noqa: E402
+from threes.app import ThreesApp  # noqa: E402
+from threes.arcade import GAME  # noqa: E402
+from threes.scenes import GameScene, InitialsScene, TitleScene  # noqa: E402
+
+TUI = Path(__file__).resolve().parents[1]
+
+
+@pytest.fixture(autouse=True)
+def isolated_scores(tmp_path, monkeypatch):
+    monkeypatch.setenv(score_mod.DATA_DIR_ENV, str(tmp_path))
+
+
+def settle(app):
+    app.host.stack.update(0.0)
+
+
+def hosted(seed=3, size=(80, 24)) -> ThreesApp:
+    host = TuiHost(title=GAME.info.title, fps=GAME.info.fps, hold_ms=GAME.info.hold_ms)
+    host.renderer.resize(*size)
+    app = ThreesApp(host, seed=seed)
+    host.push_scene(app.root_scene)
+    settle(app)
+    return app
+
+
+def playing(seed=3, size=(80, 24)):
+    app = hosted(seed, size)
+    app.start_game()
+    settle(app)
+    return app, app.host.scene
+
+
+def tap(app, key):
+    app.host.input.press(key)
+    for pressed in app.host.input.drain():
+        app.host.stack.dispatch_key(pressed)
+
+
+def frames(app, n, fps=GAME.info.fps):
+    for _ in range(n):
+        app.host.stack.update(1 / fps)
+
+
+def text(app) -> str:
+    app.host.stack.render()
+    return app.host.game.surface.buffer.to_text()
+
+
+def play_out(app, scene):
+    """Slide round in a circle until the board locks. Games here last a few
+    dozen moves, so this always ends."""
+    for i in range(2000):
+        if scene.over:
+            break
+        tap(app, ("left", "up", "right", "down")[i % 4])
+    assert scene.over
+    settle(app)
+
+
+def tiles(scene) -> int:
+    return sum(v != 0 for row in scene.board.grid for v in row)
+
+
+def test_the_game_is_a_valid_arcade_cabinet():
+    assert isinstance(GAME, ArcadeGame)
+    assert GAME.info.key == "threes"
+
+
+def test_scores_go_to_the_board_the_browser_already_has():
+    """main.js keeps its table as createScoring('threes')."""
+    assert GAME.info.scoreboard == "threes"
+    app = hosted()
+    assert app.scores.path.name.startswith("threes")
+
+
+def test_the_entry_point_names_the_object_the_arcade_will_load():
+    tomllib = pytest.importorskip("tomllib", reason="Python 3.11+")
+    meta = tomllib.loads((TUI / "pyproject.toml").read_text(encoding="utf-8"))
+    assert meta["project"]["entry-points"]["magmacrunch.games"] == {
+        "threes": "threes.arcade:GAME"}
+    assert meta["project"]["scripts"]["threes"] == "threes.__main__:main"
+
+
+def test_the_game_draws_at_exactly_its_declared_minimum():
+    app, _ = playing(size=(GAME.info.min_cols, GAME.info.min_rows))
+    assert "TERMINAL TOO SMALL" not in text(app)
+    app, _ = playing(size=(GAME.info.min_cols, GAME.info.min_rows - 1))
+    assert "TERMINAL TOO SMALL" in text(app)
+    app, _ = playing(size=(GAME.info.min_cols - 1, GAME.info.min_rows))
+    assert "TERMINAL TOO SMALL" in text(app)
+
+
+def test_a_game_starts_with_nine_tiles_on_the_board():
+    app, scene = playing()
+    assert tiles(scene) == rules.INITIAL_TILE_COUNT
+    shown = text(app)
+    for row in scene.board.grid:
+        for v in row:
+            if v:
+                assert str(v) in shown
+
+
+def test_an_arrow_slides_the_board_and_lights_the_tile_it_brings():
+    app, scene = playing()
+    scene.board.grid = [[0, 3, 0, 0], [0] * 4, [0] * 4, [0] * 4]
+    tap(app, "left")
+    b = scene.board
+    assert b.moves == 1 and b.grid[0][0] == 3
+    # Two tiles now: the 3 that slid, and the new one on the right edge.
+    assert tiles(scene) == 2
+    row, col = scene.flash
+    assert col == rules.SIZE - 1 and b.grid[row][col] in (1, 2, 3)
+    assert scene.flash_left > 0
+    frames(app, GAME.info.fps)
+    assert scene.flash_left == 0
+
+
+def test_wasd_and_hjkl_are_arrows_too():
+    for key, direction in (("a", "left"), ("h", "left"), ("w", "up"), ("k", "up"),
+                           ("d", "right"), ("l", "right"), ("s", "down"), ("j", "down")):
+        assert scenes.MOVE_KEYS[key] == direction
+
+
+def test_a_move_that_changes_nothing_brings_no_tile():
+    app, scene = playing()
+    scene.board.grid = [[3, 6, 3, 6], [6, 3, 6, 3], [3, 6, 3, 6], [6, 3, 6, 0]]
+    tap(app, "left")
+    assert scene.board.moves == 0
+    assert scene.board.grid[3][3] == 0
+
+
+def test_the_clock_runs_while_playing_and_stops_at_the_end():
+    app, scene = playing()
+    # One frame past three seconds: twenty steps of 1/20 sum to a hair under 1.
+    frames(app, GAME.info.fps * 3 + 1)
+    assert 3.0 < scene.elapsed < 3.2
+    assert "0:03" in text(app)
+    play_out(app, scene)
+    stopped = scene.elapsed
+    frames(app, GAME.info.fps * 2)
+    assert scene.elapsed == stopped
+
+
+def test_the_game_does_not_inherit_the_enter_that_started_it():
+    app = hosted()
+    tap(app, "enter")
+    settle(app)
+    scene = app.host.scene
+    assert isinstance(scene, GameScene)
+    assert scene.board.moves == 0
+
+
+def test_a_locked_board_asks_for_initials_and_files_the_browsers_extras():
+    app, scene = playing()
+    play_out(app, scene)
+    assert isinstance(app.host.scene, InitialsScene)
+    for key in ("j", "a", "m", "enter"):
+        tap(app, key)
+    settle(app)
+    entry = app.scores.load()[0]
+    assert (entry.initials, entry.score) == ("JAM", scene.board.score)
+    assert entry.extra == {"time": int(scene.elapsed), "highestTile": scene.board.high_tile}
+    assert "GAME OVER" in text(app)
+
+
+def test_mashing_arrows_at_the_end_does_not_restart_unseen():
+    app, scene = playing()
+    play_out(app, scene)
+    tap(app, "enter")                        # confirm initials
+    settle(app)
+    finished = scene.board
+    tap(app, "enter")
+    assert scene.board is finished
+    frames(app, int(GameScene.OVER_GRACE * GAME.info.fps) + 1)
+    tap(app, "enter")
+    assert scene.board is not finished and not scene.over
+
+
+def test_r_starts_a_new_game():
+    app, scene = playing()
+    for key in ("left", "up", "right", "down"):
+        tap(app, key)
+    old = scene.board
+    tap(app, "r")
+    assert scene.board is not old and scene.board.moves == 0
+
+
+def test_escape_returns_to_the_title_and_seated_to_the_arcade():
+    app, scene = playing()
+    tap(app, "escape")
+    settle(app)
+    assert isinstance(app.host.scene, TitleScene)
+    assert scenes.ARCADE_HELP not in text(app)
+
+    host = TuiHost(title="arcade", fps=20)
+
+    class Floor:
+        def update(self, dt): pass
+        def render(self): pass
+        def handle_key(self, key): return False
+
+    floor = Floor()
+    host.push_scene(floor)
+    host.seat(GAME)
+    host.stack.update(0)
+    host.renderer.resize(80, 24)
+    host.stack.render()
+    assert scenes.ARCADE_HELP in host.game.surface.buffer.to_text()
+    host.input.press("escape")
+    for key in host.input.drain():
+        host.stack.dispatch_key(key)
+    host.stack.update(0)
+    assert host.scene is floor
+
+
+def test_every_glyph_drawn_is_one_the_engine_can_degrade():
+    seen = set()
+
+    def sweep(app):
+        seen.update(ch for ch in text(app) if ord(ch) > 127)
+
+    app = hosted(size=(100, 30))
+    sweep(app)
+    for opener in (app.show_rules, app.show_scores):
+        opener()
+        settle(app)
+        sweep(app)
+        tap(app, "escape")
+        settle(app)
+    app.start_game()
+    settle(app)
+    scene = app.host.scene
+    for i in range(20):
+        tap(app, ("left", "up", "right", "down")[i % 4])
+        frames(app, 2)
+        sweep(app)
+    play_out(app, scene)
+    sweep(app)
+    unknown = {ch for ch in seen if ch not in FALLBACKS}
+    assert not unknown, f"not in magmacrunch.engine.ui.glyphs.GROUPS: {unknown}"
+
+
+def test_a_real_terminal_session_runs():
+    from magmacrunch.engine.core.tui_game import _GameApp
+
+    app = hosted()
+
+    async def go():
+        textual_app = _GameApp(app.host.game, app.host.game.surface)
+        app.host.game._app = textual_app
+        async with textual_app.run_test(size=(80, 24)) as pilot:
+            await pilot.pause()
+            await asyncio.sleep(0.2)
+            await pilot.press("enter")
+            await asyncio.sleep(0.2)
+            await pilot.press("left", "up", "right", "down")
+            await asyncio.sleep(0.5)
+            scene = app.host.scene
+            assert isinstance(scene, GameScene)
+            assert scene.board.moves >= 1
+            app.host.quit()
+
+    asyncio.run(go())