cli-arcade 2026.1.2__py3-none-any.whl → 2026.2.0__py3-none-any.whl

cli.py

@@ -1,18 +1,17 @@
-import curses
+from game_classes import ptk
+from game_classes.tools import verify_terminal_size
 import os
 import importlib.util
 import argparse
 import glob
 import sys
-import json
 import re
-import subprocess
-import urllib.request
+import time
 
 # helper: recognize Enter from multiple terminals/keypads
 def is_enter_key(ch):
     try:
-        enter_vals = {10, 13, getattr(curses, 'KEY_ENTER', -1), 343, 459}
+        enter_vals = {10, 13, getattr(ptk, 'KEY_ENTER', -1), 343, 459}
     except Exception:
         enter_vals = {10, 13}
     return ch in enter_vals
@@ -52,13 +51,38 @@ def _discover_games():
                     file_to_check = os.path.join(dirpath, pyfiles[0])
             if not file_to_check:
                 continue
+            # try to read declared minimum terminal size from the game file
+            min_cols = None
+            min_rows = None
+            try:
+                with open(file_to_check, 'r', encoding='utf-8') as fh:
+                    src = fh.read()
+                m = re.search(r'MIN_TERMINAL\s*=\s*\(\s*(\d+)\s*,\s*(\d+)\s*\)', src)
+                if m:
+                    min_cols = int(m.group(1))
+                    min_rows = int(m.group(2))
+                else:
+                    m1 = re.search(r'MIN_COLS\s*=\s*(\d+)', src)
+                    m2 = re.search(r'MIN_ROWS\s*=\s*(\d+)', src)
+                    if m1:
+                        min_cols = int(m1.group(1))
+                    if m2:
+                        min_rows = int(m2.group(1))
+            except Exception:
+                min_cols = None
+                min_rows = None
             # use directory name as the display name
             name = entry.replace('_', ' ').title()
             rel = os.path.relpath(file_to_check, base).replace('\\', '/')
             games.append((name, rel))
+            try:
+                GAME_MINS[rel] = (min_cols, min_rows)
+            except Exception:
+                pass
     return games
 
 
+GAME_MINS = {}
 GAMES = _discover_games()
 
 
@@ -78,29 +102,29 @@ def _read_console_aliases():
 
 
 def _menu(stdscr):
-    curses.curs_set(0)
+    ptk.curs_set(0)
     stdscr.nodelay(False)
     # ensure a cyan color pair is available for the title
-    if curses.has_colors():
+    if ptk.has_colors():
         try:
           # init colors
-          curses.start_color()
-          curses.use_default_colors()
+          ptk.start_color()
+          ptk.use_default_colors()
           # try to normalize key colors (0..1000 scale). Must run before init_pair.
-          if curses.can_change_color() and curses.COLORS >= 8:
+          if ptk.can_change_color() and ptk.COLORS >= 8:
               try:
-                  curses.init_color(curses.COLOR_MAGENTA, 1000, 0, 1000)
-                  curses.init_color(curses.COLOR_YELLOW, 1000, 1000, 0)
-                  curses.init_color(curses.COLOR_WHITE, 1000, 1000, 1000)
-                  curses.init_color(curses.COLOR_CYAN, 0, 1000, 1000)
-                  curses.init_color(curses.COLOR_BLUE, 0, 0, 1000)
-                  curses.init_color(curses.COLOR_GREEN, 0, 800, 0)
-                  curses.init_color(curses.COLOR_RED, 1000, 0, 0)
-                  curses.init_color(curses.COLOR_BLACK, 0, 0, 0)
+                  ptk.init_color(ptk.COLOR_MAGENTA, 1000, 0, 1000)
+                  ptk.init_color(ptk.COLOR_YELLOW, 1000, 1000, 0)
+                  ptk.init_color(ptk.COLOR_WHITE, 1000, 1000, 1000)
+                  ptk.init_color(ptk.COLOR_CYAN, 0, 1000, 1000)
+                  ptk.init_color(ptk.COLOR_BLUE, 0, 0, 1000)
+                  ptk.init_color(ptk.COLOR_GREEN, 0, 800, 0)
+                  ptk.init_color(ptk.COLOR_RED, 1000, 0, 0)
+                  ptk.init_color(ptk.COLOR_BLACK, 0, 0, 0)
               except Exception:
                   pass
           for i in range(1,8):
-              curses.init_pair(i, i, -1)
+              ptk.init_pair(i, i, -1)
         except Exception:
             pass
     sel = 0
@@ -110,13 +134,13 @@ def _menu(stdscr):
         h, w = stdscr.getmaxyx()
         title_h = len(TITLE)
         title_start = 0
-        colors = [curses.COLOR_MAGENTA, curses.COLOR_MAGENTA, curses.COLOR_CYAN, curses.COLOR_CYAN, curses.COLOR_GREEN, curses.COLOR_GREEN]
+        colors = [ptk.COLOR_MAGENTA, ptk.COLOR_MAGENTA, ptk.COLOR_CYAN, ptk.COLOR_CYAN, ptk.COLOR_GREEN, ptk.COLOR_GREEN]
         for i, line in enumerate(TITLE):
             try:
-                stdscr.addstr(title_start + i, 0, line, curses.color_pair(colors[i]))
+                stdscr.addstr(title_start + i, 0, line, ptk.color_pair(colors[i]))
             except Exception:
                 pass
-        stdscr.addstr(title_h + 1, 2, "Use Up/Down, PageUp/PageDown, Enter to start, ESC to quit", curses.color_pair(curses.COLOR_WHITE))
+        stdscr.addstr(title_h + 1, 2, "Use Up/Down, PageUp/PageDown, Enter to start, ESC to quit", ptk.color_pair(ptk.COLOR_WHITE))
         start_y = title_h + 3
         # number of lines available for the game list
         avail = max(1, h - start_y - 2)
@@ -130,9 +154,9 @@ def _menu(stdscr):
         for vis_i in range(min(avail, total)):
             i = top + vis_i
             name = GAMES[i][0]
-            attr = curses.A_REVERSE if i == sel else curses.A_NORMAL
+            attr = ptk.A_REVERSE if i == sel else ptk.A_NORMAL
             try:
-                stdscr.addstr(start_y + vis_i, 2, name[:w-4], curses.color_pair(curses.COLOR_CYAN) | attr)
+                stdscr.addstr(start_y + vis_i, 2, name[:w-4], ptk.color_pair(ptk.COLOR_CYAN) | attr)
             except Exception:
                 pass
         # optional scrollbar indicator when list is long
@@ -159,15 +183,34 @@ def _menu(stdscr):
         stdscr.refresh()
 
         ch = stdscr.getch()
-        if ch == curses.KEY_UP:
+        if ch == ptk.KEY_UP:
             sel = max(0, sel - 1)
-        elif ch == curses.KEY_DOWN:
+        elif ch == ptk.KEY_DOWN:
             sel = min(len(GAMES) - 1, sel + 1)
-        elif ch == curses.KEY_PPAGE:  # Page Up
+        elif ch == ptk.KEY_PPAGE:  # Page Up
             sel = max(0, sel - avail)
-        elif ch == curses.KEY_NPAGE:  # Page Down
+        elif ch == ptk.KEY_NPAGE:  # Page Down
             sel = min(len(GAMES) - 1, sel + avail)
         elif is_enter_key(ch):
+            # Before leaving the menu, validate the selected game's minimum
+            # terminal size (if declared). If it's too small, show an
+            # on-screen message and keep the menu running.
+            try:
+                rel = GAMES[sel][1]
+                mins = GAME_MINS.get(rel)
+                if mins:
+                    min_cols, min_rows = mins
+                    if min_cols and min_rows and (w < int(min_cols) or h < int(min_rows)):
+                        try:
+                            msg = f"Terminal too small: {w}x{h}, need {min_cols}x{min_rows}. Resize to start."
+                            stdscr.addstr(max(0, h-1), 2, msg[:max(0, w-4)], ptk.color_pair(ptk.COLOR_RED))
+                            stdscr.refresh()
+                            time.sleep(1.5)
+                        except Exception:
+                            pass
+                        continue
+            except Exception:
+                pass
             return sel
         elif ch == 27:
             return None
@@ -178,7 +221,7 @@ def _menu(stdscr):
             top = sel - avail + 1
 
 
-def _run_game_by_index(choice):
+def _run_game_by_index(choice, from_menu=False):
     """Load and run the game given by numeric index in GAMES."""
     name, relpath = GAMES[choice]
     base = os.path.dirname(__file__)
@@ -211,7 +254,29 @@ def _run_game_by_index(choice):
                 pass
     if hasattr(mod, 'main'):
         try:
-            curses.wrapper(mod.main)
+            # If the module exposes minimum terminal requirements, verify
+            # them before entering the alternate screen so messages are visible
+            try:
+                min_cols = getattr(mod, 'MIN_COLS', None)
+                min_rows = getattr(mod, 'MIN_ROWS', None)
+                if min_cols is None and hasattr(mod, 'MIN_TERMINAL'):
+                    t = getattr(mod, 'MIN_TERMINAL')
+                    if isinstance(t, (tuple, list)) and len(t) >= 2:
+                        min_cols, min_rows = t[0], t[1]
+                if min_cols is not None and min_rows is not None:
+                    verify_terminal_size(name, int(min_cols), int(min_rows))
+            except SystemExit:
+                return
+            except Exception:
+                pass
+
+            ptk.wrapper(mod.main)
+            # If launched via `clia run`, exit the process after the game ends.
+            if not from_menu:
+                try:
+                    sys.exit(0)
+                except SystemExit:
+                    raise
         except Exception as e:
             print(f"  [ERROR] Error running game {name}: {e}")
     else:
@@ -304,43 +369,6 @@ def _read_version_from_setupcfg():
     except Exception:
         return '0.0.0'
 
-
-def _version_key(ver):
-    parts = []
-    for chunk in re.split(r'(\d+)', ver):
-        if not chunk:
-            continue
-        if chunk.isdigit():
-            parts.append((0, int(chunk)))
-        else:
-            parts.append((1, chunk.lower()))
-    return parts
-
-
-def _fetch_latest_version(package):
-    url = f"https://pypi.org/pypi/{package}/json"
-    try:
-        with urllib.request.urlopen(url, timeout=5) as resp:
-            data = json.load(resp)
-        return data.get('info', {}).get('version')
-    except Exception as e:
-        print(f"  [ERROR] Failed to check latest version: {e}")
-        return None
-
-
-def _is_update_available(current, latest):
-    if not latest:
-        return False
-    try:
-        return _version_key(latest) > _version_key(current)
-    except Exception:
-        return latest != current
-
-
-def _run_pip_update(package):
-    cmd = [sys.executable, '-m', 'pip', 'install', '--upgrade', package]
-    return subprocess.call(cmd)
-
 def main():
     # support simple CLI subcommands (e.g. `clia list`)
     # build epilog with examples and any console script aliases from setup.cfg
@@ -350,7 +378,6 @@ def main():
         f'  %(prog)s list [-h]',
         f'  %(prog)s run [-h] [0, "Byte Bouncer"]',
         f'  %(prog)s reset [-h] [0, "Byte Bouncer"] [-y]',
-        f'  %(prog)s update [--check] [-y]',
     ]
     aliases = _read_console_aliases()
     if aliases:
@@ -390,15 +417,6 @@ def main():
     )
     resetp.add_argument('game', nargs='?', help='Optional game name or zero-based index (omit to reset all)')
     resetp.add_argument('-y', '--yes', action='store_true', help='Do not prompt; proceed with deletion')
-    updatep = sub.add_parser(
-        'update',
-        help='Update cli-arcade package from PyPI',
-        description='Check PyPI for a newer version and update if available.',
-        epilog='Examples:\n  %(prog)s\n  %(prog)s --check\n  %(prog)s -y\n',
-        formatter_class=argparse.RawDescriptionHelpFormatter,
-    )
-    updatep.add_argument('-c', '--check', action='store_true', help='Only check for updates (do not install)')
-    updatep.add_argument('-y', '--yes', action='store_true', help='Do not prompt; proceed with update')
     args, _rest = parser.parse_known_args()
 
     if args.cmd == 'list':
@@ -440,7 +458,7 @@ def main():
                 return
         # run the selected game (skip menu)
         try:
-            _run_game_by_index(choice)
+            _run_game_by_index(choice, from_menu=False)
         except Exception as e:
             print(f"  [ERROR] Error running game: {e}")
         return
@@ -472,74 +490,21 @@ def main():
         _reset_game_by_index(choice, yes=yes)
         return
 
-    if args.cmd == 'update':
-        package = 'cli-arcade'
-        current = _read_version_from_setupcfg()
-        if current == '0.0.0':
-            print('  [INFO] Installed version not detected (running from source?).')
-        latest = _fetch_latest_version(package)
-        if not latest:
-            print('  [INFO] Unable to determine latest version.')
-            return
-        if _is_update_available(current, latest):
-            print(f"  [INFO] Update available: {current} -> {latest}")
-            if args.check:
-                return
-            if not getattr(args, 'yes', False):
-                ans = input('  [ACTION] Update now? [y/N]: ')
-                if not ans.lower().startswith('y'):
-                    print('  [CANCELED]')
-                    return
-            code = _run_pip_update(package)
-            if code == 0:
-                print(f"  [OK] Updated {package}.")
-            else:
-                print(f"  [ERROR] Update failed with exit code {code}.")
+    # Interactive menu loop: verify terminal size before showing menu each time,
+    # run the selected game, then return to the menu when the game exits.
+    while True:
+        try:
+            verify_terminal_size('CLI Arcade', 70, 20)
+        except SystemExit:
             return
-        print(f"  [OK] You are up to date ({current}).")
-        return
-
-    # run the menu under curses, then launch the chosen game's main()
-    choice = curses.wrapper(_menu)
-    if choice is None:
-        return
-    name, relpath = GAMES[choice]
-    base = os.path.dirname(__file__)
-    path = os.path.join(base, relpath)
-    if not os.path.exists(path):
-        print(f"  [INFO] Game file not found: {path}")
-        return
-    # Ensure the game's directory is on sys.path so local imports (like `highscores`) resolve
-    game_dir = os.path.dirname(path)
-    spec = importlib.util.spec_from_file_location(f"cli_game_{choice}", path)
-    mod = importlib.util.module_from_spec(spec)
-    inserted = []
-    try:
-        proj_root = os.path.dirname(__file__)
-        if game_dir and game_dir not in sys.path:
-            sys.path.insert(0, game_dir)
-            inserted.append(game_dir)
-        if proj_root and proj_root not in sys.path:
-            sys.path.insert(0, proj_root)
-            inserted.append(proj_root)
-        spec.loader.exec_module(mod)
-    except Exception as e:
-        print(f"  [INFO] Failed to load game {name}: {e}")
-        return
-    finally:
-        for p in inserted:
-            try:
-                sys.path.remove(p)
-            except Exception:
-                pass
-    # call the game's main function if present
-    if hasattr(mod, 'main'):
+        choice = ptk.wrapper(_menu)
+        if choice is None:
+            break
+        # Run the selected game (this returns when the game exits, e.g. ESC)
         try:
-            curses.wrapper(mod.main)
+            _run_game_by_index(choice, from_menu=True)
         except Exception as e:
-            print(f"  [ERROR] Error running game {name}: {e}")
-    else:
-        print(f"  [INFO] Game {name} has no main(stdscr) entry point.")
+            print(f"  [ERROR] Error running game: {e}")
 
 
 if __name__ == '__main__':

{cli_arcade-2026.1.2.dist-info → cli_arcade-2026.2.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cli-arcade
-Version: 2026.1.2
+Version: 2026.2.0
 Summary: Collection of terminal CLI games
 Home-page: https://github.com/Bro-Code-Technologies/cli-arcade/tree/main/windows
 Author: Bro Code Technologies LLC
@@ -10,7 +10,7 @@ Project-URL: Source, https://github.com/Bro-Code-Technologies/cli-arcade/tree/ma
 Project-URL: Issues, https://github.com/Bro-Code-Technologies/cli-arcade/tree/main/windows
 Project-URL: Documentation, https://github.com/Bro-Code-Technologies/cli-arcade/tree/main/windows
 Project-URL: Package, https://pypi.org/project/cli-arcade/
-Keywords: cli,terminal,arcade,games,curses
+Keywords: cli,terminal,arcade,games
 Classifier: Development Status :: 4 - Beta
 Classifier: Environment :: Console
 Classifier: Intended Audience :: End Users/Desktop
@@ -28,17 +28,17 @@ Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: appdirs
-Requires-Dist: windows-curses; sys_platform == "win32"
+Requires-Dist: prompt_toolkit
 Dynamic: license-file
 
 # CLI Arcade
 
 Collection of small terminal games bundled with a single CLI launcher.
 
-Requirements
+## Requirements
 - Python 3.8+
 
-Quick start
+## Quick start
 ```powershell
 # list installed console aliases and available games
 clia list
@@ -54,23 +54,45 @@ clia run "Byte Bouncer"
 clia reset 0
 clia reset "Byte Bouncer"
 clia reset -y  # skip confirmation
-
-# check for updates and optionally update
-clia update
-clia update --check  # only check for updates
-clia update -y       # skip confirmation
 ```
 
-Commands
-- `clia` — interactive curses menu
+## Commands
+- `clia` — interactive terminal menu
 - `clia list` — print available games and zero-based indices
 - `clia run <index|name>` — run a game directly (index is zero-based)
 - `clia reset [<index|name>] [-y]` — delete highscores for a game or all games
-- `clia update [--check] [-y]` — check for updates and optionally update
 - Aliases available: `cli-arcade`
 
-License
+## License
 - MIT
 
-Changelog
-- See CHANGELOG.md
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+## 2026.0.0
+- Initial release as CLI Game.
+
+## 2026.1.0
+- Project renamed to CLI Arcade.
+- Packaging metadata updated for PyPI.
+- Documentation refresh.
+
+### 2026.1.1
+- Updated TITLE ASCII art.
+- Added `clia update` command to check for and install updates from PyPI.
+  - (YANKED)
+
+### 2026.1.2 (YANKED)
+- Version bump for testing the update mechanism.
+
+### 2026.1.3
+- Removed `clia update` command.
+
+### 2026.2.0
+- Refactoring using `prompt_toolkit` replacing `windows-curses` for better cross-platform compatibility.
+- Restore/clear alternate screen on run/exit (no UI artifacts).
+- Centralize terminal-size checks in CLI; games expose `MIN_COLS`/`MIN_ROWS`.
+- Byte Bouncer & Star Ship: floor + off-screen right wall; left-column bug fixed.
+- `ptk`: default-attribute/color emission fix; add helper to exit alt screen.
+- Fixed 180 movement glitch in Star Ship.

cli_arcade-2026.2.0.dist-info/RECORD

@@ -0,0 +1,41 @@
+cli.py,sha256=sf70SoYU89X2b5CENYvqC7z8KntRadlV3IQHJXrgkw0,19567
+cli_arcade-2026.2.0.dist-info/licenses/LICENSE,sha256=1PLSNFyGPi9COkVEeNYcUTuRLqGxzMLLTah05tByD4s,1099
+game_classes/__init__.py,sha256=A0o4vBUktOiONToIJb0hACalszBnFS9ls9WXPn3-KH0,28
+game_classes/game_base.py,sha256=8OaMHwPE6KKhwRCbUoI0Kypf2CN6RVxze_zdqaw7HhE,3499
+game_classes/highscores.py,sha256=dDK-7lFXSMwIqExXGp6_-7QfQz6CIf12lJ22poeCdh4,4061
+game_classes/menu.py,sha256=wx-dITSozG1VCfyFeFKgooRXEijQygDCTBRvoKnd7-8,2798
+game_classes/ptk.py,sha256=CpbE7KJ3HXTRuaeMJSIMEfGzcwjmPMtURjyHPOFWVoY,8119
+game_classes/tools.py,sha256=sZR4m8NSil4UhmZ2qDsl1iEi1hZMwUPVBFR5hSmiEBc,5106
+game_classes/__pycache__/__init__.cpython-313.pyc,sha256=zSl9ESMUQn5Vo_XXAA8DD7lpFHOtOwBruGvCOJ5qeuo,192
+game_classes/__pycache__/game_base.cpython-313.pyc,sha256=NKAgCBXxM7nZ8mt6wFy1MxUW6DK7EBhqXiLr1sVmtiA,6977
+game_classes/__pycache__/highscores.cpython-313.pyc,sha256=0rYMYs6NOzT-f00Me20F-46kUR_x8ZXk2jngO5amLy4,7080
+game_classes/__pycache__/menu.cpython-313.pyc,sha256=urqSfGlJJdfTKI1kqXOT0oPXjo1Ny9MyYA8QroVQHzQ,4488
+game_classes/__pycache__/ptk.cpython-313.pyc,sha256=ZTwAGo3hlFRhk5rNbLiUBOMmR_odse9v_XTkHXdjxpw,14412
+game_classes/__pycache__/ptk_curses.cpython-313.pyc,sha256=XqhJ78tqyT0HFd5UV_1_IrGl-W5PuW4WyJve5RiY3uo,13820
+game_classes/__pycache__/ptk_game_base.cpython-313.pyc,sha256=tRzGtoCErAHsUpoEWVjQN4PQ0Gw5N9RW3nJHJW2IT24,6915
+game_classes/__pycache__/ptk_menu.cpython-313.pyc,sha256=jyBSuLVxNm7ueGjAIKhd7D_ZEFpwLv9U1iim_ElClHk,2448
+game_classes/__pycache__/ptk_tools.cpython-313.pyc,sha256=Y-lBpAMlt8HfgQEio4isDGpwXclYUsyzs9wGoeGJkmE,5061
+game_classes/__pycache__/tools.cpython-313.pyc,sha256=0MS9Cai_D0LaIQ6w6c6BLSJ45XvnUr4BjHSQdFYnQ7Y,7316
+games/__init__.py,sha256=Rg46lnLj_sezpnXaQTS1NXX5OaRhR_EWpNTyYUxycj4,21
+games/byte_bouncer/__init__.py,sha256=8hxIHRyUPB-X6vJXh1432ytKjOcfIzCbdpO5mmWA7iQ,33
+games/byte_bouncer/game.py,sha256=EpTzObLNF_cGfB-xRkUlqCwYt7A7IGk8nENkOdqoV3c,8877
+games/byte_bouncer/__pycache__/byte_bouncer.cpython-313.pyc,sha256=JSTB6-_KCukAAVaZz9TpJ3V4gif_M3n_L5X1KOviSJ8,24605
+games/byte_bouncer/__pycache__/game.cpython-313.pyc,sha256=0H66QPFncbxvKVlMRPKEXjJDYtw1pPAw5I9sz3kWdIA,13965
+games/byte_bouncer/__pycache__/highscores.cpython-313.pyc,sha256=g3FozKpWGDVsTVETNpb6lRHcKA3ZIsQio8Kh7KCGVCI,3125
+games/star_ship/__init__.py,sha256=X8AdhoccmNVu6yl7MalsxIsMxuEsddRdlvEQmhZMD0A,30
+games/star_ship/game.py,sha256=aN3LVh-kaYppAy-J259Y6XROT5pvEAFDjGd1404oWBw,10992
+games/star_ship/__pycache__/game.cpython-313.pyc,sha256=hWqwV12a1VF-_Lc8Uzd7ono4ZN3gNJ4RQ-gK69OayVw,15922
+games/star_ship/__pycache__/highscores.cpython-313.pyc,sha256=nHbEOTWeX0U9D47K2EP5S5uDPI0WW52Eg7h_NesG1OU,3148
+games/star_ship/__pycache__/nibbles.cpython-313.pyc,sha256=Yv2P-GwEc30zA24aO7k0hkk1AOja6K85AFvmjLIffqQ,20510
+games/star_ship/__pycache__/snek.cpython-313.pyc,sha256=3Mwyy6vjGFRmNyAWSqV5JRilLOxiCSndBmwua_Y7VTs,13313
+games/star_ship/__pycache__/star_ship.cpython-313.pyc,sha256=9gJt10MTzVTSwsc4I16TDZTaAXclfhfGTzgfYgZNOKo,28021
+games/terminal_tumble/__init__.py,sha256=axTd7hCgnLRNU8QS73NnQY3q5xjIb3ZYQORJ9Lz8l_E,36
+games/terminal_tumble/game.py,sha256=UbtrMS4wi5MiIMHfreP51VlrHHlfxEPJpFmsLgdUgWs,15633
+games/terminal_tumble/__pycache__/game.cpython-313.pyc,sha256=DrjmLzJYY5QoYXghGh-ORn26Yax9Gmd6fSCZGdgYbRQ,24073
+games/terminal_tumble/__pycache__/highscores.cpython-313.pyc,sha256=UPnU9Zq88q2TZq1qXyo8e2Y_PdOgwvu5mncIkunFah8,3154
+games/terminal_tumble/__pycache__/terminal_tumble.cpython-313.pyc,sha256=7oLpmmkYjpLYRC0bjRoEkHbIUNq7FZVJToGoja94m0o,38016
+cli_arcade-2026.2.0.dist-info/METADATA,sha256=dBo3dzuaIBHOOOKkyi8NMZw7OacdGshIWdDEtMKZ5Ik,3229
+cli_arcade-2026.2.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+cli_arcade-2026.2.0.dist-info/entry_points.txt,sha256=nNElhZv4nM_lrOYpvnOChtJn1XsWwQr8sI344flzzTQ,56
+cli_arcade-2026.2.0.dist-info/top_level.txt,sha256=gTfYlz7gHYgPY0ugfJivukCOkNzmOisNR6VuJjAXPF4,23
+cli_arcade-2026.2.0.dist-info/RECORD,,

game_classes/game_base.py

@@ -1,9 +1,9 @@
-import curses
+from game_classes import ptk
 import time
 from game_classes.tools import get_terminal_size
 
 class GameBase:
-  def __init__(self, stdscr, player_name, tick, color=curses.COLOR_GREEN):
+  def __init__(self, stdscr, player_name, tick, color=ptk.COLOR_GREEN):
     self.stdscr = stdscr
     self.player_name = player_name
     self.tick = tick
@@ -65,7 +65,7 @@ class GameBase:
         return True
       if not getattr(self, 'over', False):
         # toggle pause on Backspace
-        if ch in (curses.KEY_BACKSPACE, 127, 8):
+        if ch in (ptk.KEY_BACKSPACE, 127, 8):
           self.paused = not getattr(self, 'paused', False)
         # movement only when not paused
         elif not getattr(self, 'paused', False):
@@ -76,7 +76,7 @@ class GameBase:
     try:
       py = max(0, min(self.height, self.height // 2))
       px = max(0, (self.width - len(msg)) // 2)
-      self.stdscr.addstr(py, px, msg, curses.color_pair(curses.COLOR_RED) | curses.A_BOLD)
+      self.stdscr.addstr(py, px, msg, ptk.color_pair(ptk.COLOR_RED) | ptk.A_BOLD)
     except Exception:
       pass
 
@@ -85,7 +85,7 @@ class GameBase:
     try:
       for i, line in enumerate(self.title):
         try:
-          self.stdscr.addstr(i, 0, line, curses.color_pair(self.color) | curses.A_BOLD)
+          self.stdscr.addstr(i, 0, line, ptk.color_pair(self.color) | ptk.A_BOLD)
         except Exception:
           pass
     except Exception:

game_classes/menu.py

@@ -1,4 +1,4 @@
-import curses
+from game_classes import ptk
 from game_classes.tools import is_enter_key
 
 class Menu:
@@ -19,7 +19,7 @@ class Menu:
                 return name.strip() or 'Player'
             elif ch in (27,):
                 return False
-            elif ch in (curses.KEY_BACKSPACE, 127, 8):
+            elif ch in (ptk.KEY_BACKSPACE, 127, 8):
                 name = name[:-1]
             elif 32 <= ch <= 126 and len(name) < max_len:
                 name += chr(ch)
@@ -34,7 +34,7 @@ class Menu:
         title_height = len(self.game.title)
         for i, line in enumerate(self.game.title):
             try:
-                self.game.stdscr.addstr(i, 0, line, curses.color_pair(self.game.color) | curses.A_BOLD)
+                self.game.stdscr.addstr(i, 0, line, ptk.color_pair(self.game.color) | ptk.A_BOLD)
             except Exception:
                 pass
 
@@ -51,7 +51,7 @@ class Menu:
         self.game.stdscr.refresh()
         while True:
             ch = self.game.stdscr.getch()
-            # if ch in (ord('s'), ord('S')) or ch == curses.KEY_DOWN:
+            # if ch in (ord('s'), ord('S')) or ch == ptk.KEY_DOWN:
             if is_enter_key(ch):
                 # prompt for name before starting, centered over the title block
                 prompt_y = title_height + 3