cli-arcade 2026.0.0__py3-none-any.whl

cli.py

@@ -0,0 +1,468 @@
+import curses
+import os
+import importlib.util
+import argparse
+import glob
+import sys
+
+# helper: recognize Enter from multiple terminals/keypads
+def is_enter_key(ch):
+    try:
+        enter_vals = {10, 13, getattr(curses, 'KEY_ENTER', -1), 343, 459}
+    except Exception:
+        enter_vals = {10, 13}
+    return ch in enter_vals
+
+TITLE = [
+     '    ________    ____   _________    __  ______________ ',
+    r'   / ____/ /   /  _/  / ____/   |  /  |/  / ____/ ___/ ',
+    r'  / /   / /    / /   / / __/ /| | / /|_/ / __/  \__ \ ',
+    r' / /___/ /____/ /   / /_/ / ___ |/ /  / / /___ ___/ / ',
+    r' \____/_____/___/   \____/_/  |_/_/  /_/_____//____/ '
+]
+
+def _discover_games():
+    base = os.path.dirname(__file__)
+    games = []
+    # only scan the 'games' subdirectory
+    games_dir = os.path.join(base, 'games')
+    if not os.path.isdir(games_dir):
+        return []
+    scan_roots = [games_dir]
+
+    for root in scan_roots:
+        for entry in sorted(os.listdir(root)):
+            dirpath = os.path.join(root, entry)
+            if not os.path.isdir(dirpath):
+                continue
+            if entry.startswith('__'):
+                continue
+            # prefer standardized <dir>/game.py
+            candidate = os.path.join(dirpath, "game.py")
+            file_to_check = None
+            if os.path.exists(candidate):
+                file_to_check = candidate
+            else:
+                pyfiles = [p for p in os.listdir(dirpath) if p.endswith('.py') and not p.startswith('_')]
+                if pyfiles:
+                    file_to_check = os.path.join(dirpath, pyfiles[0])
+            if not file_to_check:
+                continue
+            # use directory name as the display name
+            name = entry.replace('_', ' ').title()
+            rel = os.path.relpath(file_to_check, base).replace('\\', '/')
+            games.append((name, rel))
+    return games
+
+
+GAMES = _discover_games()
+
+
+def _read_console_aliases():
+    """Read console_scripts names from installed package metadata."""
+    try:
+        from importlib import metadata as importlib_metadata
+    except Exception:
+        return []
+
+    try:
+        dist = importlib_metadata.distribution('cli-games')
+        aliases = [ep.name for ep in dist.entry_points if ep.group == 'console_scripts']
+        return sorted(set(aliases))
+    except Exception:
+        return []
+
+
+def _menu(stdscr):
+    curses.curs_set(0)
+    stdscr.nodelay(False)
+    # ensure a cyan color pair is available for the title
+    if curses.has_colors():
+        try:
+          # init colors
+          curses.start_color()
+          curses.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:
+              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)
+              except Exception:
+                  pass
+          for i in range(1,8):
+              curses.init_pair(i, i, -1)
+        except Exception:
+            pass
+    sel = 0
+    top = 0
+    while True:
+        stdscr.clear()
+        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]
+        for i, line in enumerate(TITLE):
+            try:
+                stdscr.addstr(title_start + i, 0, line, curses.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))
+        start_y = title_h + 3
+        # number of lines available for the game list
+        avail = max(1, h - start_y - 2)
+        total = len(GAMES)
+        # clamp top so it stays within valid range
+        if top < 0:
+            top = 0
+        if top > max(0, total - avail):
+            top = max(0, total - avail)
+
+        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
+            try:
+                stdscr.addstr(start_y + vis_i, 2, name[:w-4], curses.color_pair(curses.COLOR_CYAN) | attr)
+            except Exception:
+                pass
+        # optional scrollbar indicator when list is long
+        if total > avail:
+            try:
+                # try to use glyphs from game_classes.tools when available
+                try:
+                    from game_classes.tools import glyph
+                    vbar = glyph('VBAR')
+                    block = glyph('THUMB')
+                except Exception:
+                    vbar = '|' 
+                    block = '#'
+                bar_y = start_y
+                bar_h = avail
+                thumb_h = max(1, int(bar_h * (avail / total)))
+                thumb_pos = int((bar_h - thumb_h) * (top / max(1, total - avail)))
+                for by in range(bar_h):
+                    stdscr.addstr(bar_y + by, w - 2, vbar)
+                for by in range(thumb_h):
+                    stdscr.addstr(bar_y + thumb_pos + by, w - 2, block)
+            except Exception:
+                pass
+        stdscr.refresh()
+
+        ch = stdscr.getch()
+        if ch == curses.KEY_UP:
+            sel = max(0, sel - 1)
+        elif ch == curses.KEY_DOWN:
+            sel = min(len(GAMES) - 1, sel + 1)
+        elif ch == curses.KEY_PPAGE:  # Page Up
+            sel = max(0, sel - avail)
+        elif ch == curses.KEY_NPAGE:  # Page Down
+            sel = min(len(GAMES) - 1, sel + avail)
+        elif is_enter_key(ch):
+            return sel
+        elif ch == 27:
+            return None
+        # adjust top to keep the selected item visible
+        if sel < top:
+            top = sel
+        elif sel >= top + avail:
+            top = sel - avail + 1
+
+
+def _run_game_by_index(choice):
+    """Load and run the game given by numeric index in GAMES."""
+    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
+    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:
+        # ensure both the game's directory and project root are on sys.path
+        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"  [ERROR] Failed to load game {name}: {e}")
+        return
+    finally:
+        for p in inserted:
+            try:
+                sys.path.remove(p)
+            except Exception:
+                pass
+    if hasattr(mod, 'main'):
+        try:
+            curses.wrapper(mod.main)
+        except Exception as e:
+            print(f"  [ERROR] Error running game {name}: {e}")
+    else:
+        print(f"  [INFO] Game {name} has no main(stdscr) entry point.")
+
+
+def _reset_game_by_index(choice, yes=False):
+    name, relpath = GAMES[choice]
+    base = os.path.dirname(__file__)
+    game_dir = os.path.dirname(os.path.join(base, relpath))
+    # find highscores files (common pattern in project) and user-data highscores
+    files = glob.glob(os.path.join(game_dir, 'highscores*.json'))
+    # try user-data location via HighScores
+    try:
+        from game_classes.highscores import HighScores
+        slug = os.path.basename(game_dir)
+        hs = HighScores(slug)
+        user_path = hs._path()
+        if user_path and os.path.exists(user_path):
+            files.append(user_path)
+    except Exception:
+        # if import fails or path not available, ignore
+        pass
+    if not files:
+        print(f"  [INFO] No highscore files found for '{name}' ({game_dir}).")
+        return
+    # dedupe and present
+    files = sorted(set(files))
+    print(f"  [INFO] Found {len(files)} highscore file(s) for '{name}':")
+    for f in files:
+        print(f'    [{choice}] {f}')
+    if not yes:
+        ans = input(f"  [ACTION] Delete these files for '{name}'? [y/N]: ")
+        if not ans.lower().startswith('y'):
+            print('  [CANCELED]')
+            return
+    for f in files:
+        try:
+            os.remove(f)
+            print(f"  [DELETED] {f}")
+        except Exception as e:
+            print(f"  [ERROR] Failed to delete {f}: {e}")
+
+
+def _reset_all_games(yes=False):
+    base = os.path.dirname(__file__)
+    all_files = []
+    for name, rel in GAMES:
+        game_dir = os.path.dirname(os.path.join(base, rel))
+        all_files.extend(glob.glob(os.path.join(game_dir, 'highscores*.json')))
+        # include user-data highscores when present
+        try:
+            from game_classes.highscores import HighScores
+            slug = os.path.basename(game_dir)
+            hs = HighScores(slug)
+            user_path = hs._path()
+            if user_path and os.path.exists(user_path):
+                all_files.append(user_path)
+        except Exception:
+            pass
+    if not all_files:
+        print('  [INFO] No highscore files found for any game.')
+        return
+    # dedupe list before showing
+    all_files = sorted(set(all_files))
+    print(f'  [INFO] Found {len(all_files)} highscore file(s):')
+    for i, f in enumerate(all_files):
+        print(f'    [{i}] {f}')
+    if not yes:
+        ans = input('  [ACTION] Delete all these highscore files? [y/N]: ')
+        if not ans.lower().startswith('y'):
+            print('  [CANCELED]')
+            return
+    for f in all_files:
+        try:
+            os.remove(f)
+            print(f"  [DELETED] {f}")
+        except Exception as e:
+            print(f"  [ERROR] Failed to delete {f}: {e}")
+
+# CLI version: read from setup.cfg to keep a single source of truth
+def _read_version_from_setupcfg():
+    try:
+        from importlib import metadata as importlib_metadata
+    except Exception:
+        return '0.0.0'
+
+    try:
+        return importlib_metadata.version('cli-games')
+    except Exception:
+        return '0.0.0'
+
+def main():
+    # support simple CLI subcommands (e.g. `clig list`)
+    # build epilog with examples and any console script aliases from setup.cfg
+    epilog_lines = [
+        'Examples:',
+        f'  %(prog)s',
+        f'  %(prog)s list [-h]',
+        f'  %(prog)s run [-h] [0, "Byte Bouncer"]',
+        f'  %(prog)s reset [-h] [0, "Byte Bouncer"] [-y]',
+    ]
+    aliases = _read_console_aliases()
+    if aliases:
+        epilog_lines.append('\nAliases: ' + ', '.join(aliases))
+    epilog = '\n'.join(epilog_lines) + '\n'
+
+    parser = argparse.ArgumentParser(
+        prog=os.path.basename(sys.argv[0]) or 'games',
+        description='Run the CLI Games menu or subcommands.',
+        epilog=epilog,
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+    # standard --version support
+    parser.add_argument('-v', '--version', action='version', version=f"%(prog)s {_read_version_from_setupcfg()}")
+    sub = parser.add_subparsers(dest='cmd')
+    sub.add_parser(
+        'list',
+        help='List available games',
+        description='List all available games with their zero-based indices.',
+        epilog='Example:\n  %(prog)s\n',
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+    runp = sub.add_parser(
+        'run',
+        help='Run a game by name or zero-based index',
+        description='Run a game directly without the menu.',
+        epilog='Examples:\n  %(prog)s 0\n  %(prog)s "Byte Bouncer"\n',
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+    runp.add_argument('game', help='Game name or zero-based index')
+    resetp = sub.add_parser(
+        'reset',
+        help='Reset highscores (delete highscore files)',
+        description='Delete highscores for one game or all games. Use with care.',
+        epilog='Examples:\n  %(prog)s\n  %(prog)s -y\n  %(prog)s 0\n  %(prog)s "Byte Bouncer" -y\n',
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+    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')
+    args, _rest = parser.parse_known_args()
+
+    if args.cmd == 'list':
+        base = os.path.dirname(__file__)
+        for i, (name, rel) in enumerate(GAMES):
+            print(f"  [{i}] {name}")
+        return
+
+    if args.cmd == 'run':
+        token = args.game
+        choice = None
+        # try integer (zero-based index)
+        try:
+            idx = int(token)
+            if 0 <= idx < len(GAMES):
+                choice = idx
+            else:
+                print(f"  [INFO] Index out of range: {idx}")
+                for i, (name, rel) in enumerate(GAMES):
+                    print(f"    [{i}] {name}")
+                return
+        except Exception:
+            # match by exact name (case-insensitive)
+            lowered = token.lower()
+            for i, (name, _) in enumerate(GAMES):
+                if name.lower() == lowered:
+                    choice = i
+                    break
+            # fallback: substring match
+            if choice is None:
+                for i, (name, _) in enumerate(GAMES):
+                    if lowered in name.lower():
+                        choice = i
+                        break
+            if choice is None:
+                print(f"  [INFO] Game not found: {token}")
+                for i, (name, rel) in enumerate(GAMES):
+                    print(f"    [{i}] {name}")
+                return
+        # run the selected game (skip menu)
+        try:
+            _run_game_by_index(choice)
+        except Exception as e:
+            print(f"  [ERROR] Error running game: {e}")
+        return
+
+    if args.cmd == 'reset':
+        token = args.game
+        yes = getattr(args, 'yes', False)
+        if token is None:
+            _reset_all_games(yes=yes)
+            return
+        # resolve token to index similar to 'run'
+        choice = None
+        try:
+            idx = int(token)
+            if 0 <= idx < len(GAMES):
+                choice = idx
+            else:
+                print(f"  [INFO] Index out of range: {idx}")
+                return
+        except Exception:
+            lowered = token.lower()
+            for i, (name, _) in enumerate(GAMES):
+                if name.lower() == lowered:
+                    choice = i
+                    break
+            if choice is None:
+                print(f"  [INFO] Game not found: {token}")
+                return
+        _reset_game_by_index(choice, yes=yes)
+        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'):
+        try:
+            curses.wrapper(mod.main)
+        except Exception as e:
+            print(f"  [ERROR] Error running game {name}: {e}")
+    else:
+        print(f"  [INFO] Game {name} has no main(stdscr) entry point.")
+
+
+if __name__ == '__main__':
+    main()

cli_arcade-2026.0.0.dist-info/METADATA

@@ -0,0 +1,136 @@
+Metadata-Version: 2.4
+Name: cli-arcade
+Version: 2026.0.0
+Summary: Collection of terminal CLI games
+Home-page: https://github.com/Bro-Code-Technologies/cli_games/tree/main/windows
+Author: Bro Code Technologies LLC
+Author-email: info@brocodetechnologies.com
+License: MIT
+Project-URL: Source, https://github.com/Bro-Code-Technologies/cli_games/tree/main/windows
+Project-URL: Issues, https://github.com/Bro-Code-Technologies/cli_games/tree/main/windows
+Project-URL: Documentation, https://github.com/Bro-Code-Technologies/cli_games/tree/main/windows
+Project-URL: Package, https://pypi.org/project/cli-games/
+Keywords: cli,terminal,games,curses
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: End Users/Desktop
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Games/Entertainment
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: appdirs
+Requires-Dist: windows-curses; sys_platform == "win32"
+Dynamic: license-file
+
+# CLI Games
+
+Collection of small terminal games bundled with a single CLI launcher.
+
+Requirements
+- Python 3.8+
+- On Windows: install `windows-curses` for curses support:
+
+```powershell
+pip install windows-curses
+```
+
+Quick start (developer)
+
+```powershell
+# install editable (recommended during development)
+pip install -e .
+
+# list installed console aliases and available games
+clig list
+
+# run interactive menu
+clig
+
+# run a game by zero-based index or name
+clig run 0
+clig run "Byte Bouncer"
+
+# reset highscores for one game or all
+clig reset 0
+clig reset "Byte Bouncer"
+clig reset -y  # skip confirmation
+```
+
+If the `clig` command is not found after installation, the installer likely wrote scripts to your user Scripts directory. On Windows add this to your PATH (PowerShell):
+
+```powershell
+$env:Path += ";$env:APPDATA\Python\Python<version>\Scripts"
+# or permanently via System settings: add %APPDATA%\Python\Python<version>\Scripts to your user PATH
+```
+
+You can always run the CLI directly without installing:
+
+```powershell
+python -m cli
+```
+
+Commands
+- `clig` — interactive curses menu
+- `clig list` — print available games and zero-based indices
+- `clig run <index|name>` — run a game directly (index is zero-based)
+- `clig reset [<index|name>] [-y]` — delete highscores for a game or all games
+- Aliases available: `cli-games`, `cli-game`
+
+Highscores storage and migration
+- Highscores are now stored in a user-writable application data directory. Typical locations:
+	- Windows (appdirs): `%LOCALAPPDATA%\cli-games\games\<game>\highscores.json`
+	- Fallback (no appdirs): `%USERPROFILE%\.cli-games\games\<game>\highscores.json`
+- On first run the CLI attempts to migrate any legacy `games/<game>/highscores.json` found in the project into the user data directory.
+
+Packaging & publishing (brief)
+
+- `setup.cfg` now declares `packages = find:` and `include_package_data = true` so `game_classes/` and `games/` are included in sdist/wheels. Remember to add a `MANIFEST.in` if you need additional files in source distributions.
+- Update `setup.cfg` version.
+- Build: `python -m build` (requires `build` package).
+- Upload: `twine upload dist/*` (requires `twine`).
+- The package exposes several console script aliases (see `setup.cfg` -> `options.entry_points.console_scripts`).
+
+Notes & Troubleshooting
+- On Windows, `curses` requires `windows-curses`.
+- The CLI requires a minimum terminal size; if the menu exits with an error, try enlarging your terminal or run `python -m cli` in a larger window.
+- Games should live in their own subdirectory (`games/<slug>/game.py`) and export a `main(stdscr)` entry point. The CLI uses the directory name (slug) as the display title.
+
+Terminal recommendations (Windows)
+- Recommended: use Windows Terminal or the VS Code integrated terminal for the best UTF-8 + glyph support.
+	- Install Windows Terminal via Microsoft Store or `winget`:
+
+```powershell
+winget install --id Microsoft.WindowsTerminal -e
+```
+
+- PowerShell (external) often uses OEM code page 437 and may not render some Unicode glyphs. If you prefer the external shell to render glyphs, either use Windows Terminal or make these changes:
+	- Change the console font to a glyph-capable font (Cascadia Code PL, Fira Code, DejaVu Sans Mono, or modern Consolas) via the console Properties → Font.
+	- Ensure UTF-8 is enabled for the session (temporary):
+
+```powershell
+chcp 65001
+[Console]::OutputEncoding = [System.Text.Encoding]::UTF8
+$env:PYTHONIOENCODING = 'utf-8'
+```
+
+	- To make the change persistent, add the above lines to your PowerShell profile (see `code $profile`), or prefer PowerShell Core (`pwsh`) which typically handles UTF-8 better.
+
+- If you cannot enable UTF-8 in your external terminal, the CLI will automatically fall back to safe ASCII glyphs for problematic terminals. To force ASCII output regardless of terminal detection, set the environment variable `CLI_GAMES_FORCE_ASCII=1` before running the CLI.
+
+- Advanced: enable system-wide UTF-8 (Region → Administrative → Change system locale → check “Beta: Use Unicode UTF-8 for worldwide language support”) and restart. This affects other apps and requires caution.
+
+Contributing
+- Add a new game by creating a subdirectory under `games/` with a `game.py` file that exports `main(stdscr)`.
+- Keep changes minimal and run `clig` locally to verify.
+
+License
+- MIT

cli_arcade-2026.0.0.dist-info/RECORD

@@ -0,0 +1,35 @@
+cli.py,sha256=Kc8jgyneJYYjLedgvniskd2_0mXyBg1R6-TLslJgcgE,17458
+cli_arcade-2026.0.0.dist-info/licenses/LICENSE,sha256=1PLSNFyGPi9COkVEeNYcUTuRLqGxzMLLTah05tByD4s,1099
+game_classes/__init__.py,sha256=A0o4vBUktOiONToIJb0hACalszBnFS9ls9WXPn3-KH0,28
+game_classes/game_base.py,sha256=q779LzYsK8rO0rWrj2iB5407wuLiZvuFiRBx6qQEfPQ,3505
+game_classes/highscores.py,sha256=uzK2NJU-hnmMcDT7TEWhkikKn4rnqiJMln8szOqqPX4,4060
+game_classes/menu.py,sha256=6frg15Ibx_H89g-KmHv53d6uWSUsxluhXMGvn4Nj7xY,2795
+game_classes/tools.py,sha256=TKkJ0bv2sbs_smjrXLCJZd9IIcZe_f96ms0uSBYA6gc,4972
+game_classes/__pycache__/__init__.cpython-313.pyc,sha256=zSl9ESMUQn5Vo_XXAA8DD7lpFHOtOwBruGvCOJ5qeuo,192
+game_classes/__pycache__/game_base.cpython-313.pyc,sha256=p6NUAgjNMXwPoNkQq01tUZm_ZYX18jaIMRZOm35vKsk,6962
+game_classes/__pycache__/highscores.cpython-313.pyc,sha256=diYyL8QT5LpS_68hz5s_kfHbgaqihyOygTABlkzg2MI,7067
+game_classes/__pycache__/menu.cpython-313.pyc,sha256=wseCBPJ5XKtVI8scyJrBZxAW2avD2JF3J0IpRUYzsR8,4459
+game_classes/__pycache__/tools.cpython-313.pyc,sha256=OrKBCCTPdimXHQZ7hXRCkB_0IcCQiG9POLdnnKgKjl8,7331
+games/__init__.py,sha256=Rg46lnLj_sezpnXaQTS1NXX5OaRhR_EWpNTyYUxycj4,21
+games/byte_bouncer/__init__.py,sha256=8hxIHRyUPB-X6vJXh1432ytKjOcfIzCbdpO5mmWA7iQ,33
+games/byte_bouncer/game.py,sha256=9SFBre-QvjTa5maKP-XjI-Fh-1dNgxeYxxtglrccnA4,8105
+games/byte_bouncer/__pycache__/byte_bouncer.cpython-313.pyc,sha256=JSTB6-_KCukAAVaZz9TpJ3V4gif_M3n_L5X1KOviSJ8,24605
+games/byte_bouncer/__pycache__/game.cpython-313.pyc,sha256=Z5xiPsrisDqe8Mx6FQjW3eHNiXMXuIY5mJlrVmNUfec,13017
+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=Mph_USmrroynsli43vD3luadYAOiPXmbs0JMOCDGxMk,9545
+games/star_ship/__pycache__/game.cpython-313.pyc,sha256=TnsJQS7zrwB0zG7CZ7VlTPE_qq063cZdZcL0Z66fu08,14623
+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=p4lrFHBoHZJLpsUr0jXmR9FI8OTZmwfGIS1Z29MoYzU,15699
+games/terminal_tumble/__pycache__/game.cpython-313.pyc,sha256=-xFF1wgupqiSoHz3QZwMNHxhAIV_UyIp0YifRdg8ijA,24104
+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.0.0.dist-info/METADATA,sha256=YdvaQUC9u0xS_teAd3dVSJTn0-hrxVNFE3gzh_erD2Y,5952
+cli_arcade-2026.0.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+cli_arcade-2026.0.0.dist-info/entry_points.txt,sha256=dEd6b2AwMr2o-sSOzi2aAfIy0ViqcnAkuHShiOMVr4o,75
+cli_arcade-2026.0.0.dist-info/top_level.txt,sha256=gTfYlz7gHYgPY0ugfJivukCOkNzmOisNR6VuJjAXPF4,23
+cli_arcade-2026.0.0.dist-info/RECORD,,

cli_arcade-2026.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.10.2)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

cli_arcade-2026.0.0.dist-info/entry_points.txt

@@ -0,0 +1,4 @@
+[console_scripts]
+cli-game = cli:main
+cli-games = cli:main
+clig = cli:main

cli_arcade-2026.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) 2026 Bro Code Technologies LLC
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

cli_arcade-2026.0.0.dist-info/top_level.txt

@@ -0,0 +1,3 @@
+cli
+game_classes
+games

game_classes/__init__.py

@@ -0,0 +1 @@
+"""game_classes package"""