shortcutxl 0.2.12 → 0.2.13

package/xll/modules/gameboy.py

@@ -1,241 +1,241 @@
-"""
-Game Boy emulator in Excel — type =gb_start() to play Pokemon Red!
-
-Runs a Game Boy ROM via PyBoy at full 160x144 resolution.
-Colors are auto-detected from the game's actual palette.
-
-Arrow keys + Z (A) + X (B) + Enter (Start) + Backspace (Select).
-Type =gb_stop() to end.
-"""
-import shortcut_xl
-from shortcut_xl import xl_func, xl_log
-import ctypes
-import os
-import time
-
-WIDTH = 160
-HEIGHT = 144
-TARGET_EMU_FPS = 60  # Game Boy runs at ~60 FPS
-
-# Column letter helper
-def _col_letter(n):
-    s = ""
-    while n > 0:
-        n, rem = divmod(n - 1, 26)
-        s = chr(65 + rem) + s
-    return s
-
-_GRID_RANGE = f"A3:{_col_letter(WIDTH)}{2 + HEIGHT}"
-
-# Key mappings: Windows VK code -> PyBoy button name
-_KEY_MAP = {
-    0x25: 'left',
-    0x26: 'up',
-    0x27: 'right',
-    0x28: 'down',
-    0x5A: 'a',       # Z
-    0x58: 'b',       # X
-    0x0D: 'start',   # Enter
-    0x08: 'select',  # Backspace
-}
-
-_state = {
-    'pyboy': None,
-    'running': False,
-    '_formatted': False,
-    '_keys_held': set(),
-    '_palette_bgr': None,
-    '_last_tick': 0.0,
-}
-
-# Excel OnKey strings to suppress during gameplay
-_ONKEY_SUPPRESS = [
-    "z", "Z", "x", "X",
-    "{LEFT}", "{RIGHT}", "{UP}", "{DOWN}",
-    "~", "{BS}",
-]
-
-
-def _suppress_keys(app):
-    for k in _ONKEY_SUPPRESS:
-        app.OnKey(k, "")
-
-
-def _restore_keys(app):
-    for k in _ONKEY_SUPPRESS:
-        app.OnKey(k)
-
-
-def _poll_keys():
-    pb = _state['pyboy']
-    if not pb:
-        return
-    currently_held = set()
-    for vk in _KEY_MAP:
-        if ctypes.windll.user32.GetAsyncKeyState(vk) & 0x8000:
-            currently_held.add(vk)
-    prev = _state['_keys_held']
-    for vk in currently_held - prev:
-        pb.button_press(_KEY_MAP[vk])
-    for vk in prev - currently_held:
-        pb.button_release(_KEY_MAP[vk])
-    _state['_keys_held'] = currently_held
-
-
-def _detect_palette():
-    """Scan screen for unique colors, build sorted palette."""
-    import numpy as np
-    screen = _state['pyboy'].screen.ndarray[:, :, :3]
-    unique = np.unique(screen.reshape(-1, 3), axis=0)
-    brightness = np.sum(unique, axis=1)
-    order = np.argsort(brightness)
-    palette = [tuple(unique[i]) for i in order]
-    _state['_palette_bgr'] = [
-        int(b) * 65536 + int(g) * 256 + int(r) for r, g, b in palette
-    ]
-    # Build threshold list from midpoints between palette brightness levels
-    b_sorted = sorted(brightness)
-    thresholds = []
-    for i in range(len(b_sorted) - 1):
-        thresholds.append((b_sorted[i] + b_sorted[i + 1]) / 2.0 / 3.0)  # per-channel avg
-    _state['_thresholds'] = thresholds
-    xl_log(f"gb palette: {len(palette)} colors, thresholds={thresholds}")
-
-
-def _grab_frame():
-    """Fast frame grab: threshold-based, returns list-of-lists (no tuple conversion)."""
-    import numpy as np
-    screen = _state['pyboy'].screen.ndarray[:, :, 0]  # R channel (GB is grayscale R=G=B)
-    thresholds = _state.get('_thresholds', [64, 128, 192])
-
-    indices = np.zeros(screen.shape, dtype=np.uint8)
-    for i, t in enumerate(thresholds):
-        indices[screen >= t] = i + 1
-
-    return indices.tolist()  # list-of-lists — fast C-level conversion
-
-
-def _render(grid):
-    def _paint(app):
-        app.Calculation = -4135  # xlCalculationManual
-        sheet = app.ActiveSheet
-
-        if not _state['_formatted']:
-            _state['_formatted'] = True
-            area = sheet.Range(_GRID_RANGE)
-            area.ColumnWidth = 0.75
-            area.RowHeight = 5
-            area.NumberFormat = ";;;"
-
-            # Conditional formatting from detected palette
-            area.FormatConditions.Delete()
-            for val, bgr in enumerate(_state['_palette_bgr']):
-                fc = area.FormatConditions.Add(1, 3, str(val))
-                fc.Interior.Color = bgr
-                fc.Font.Color = bgr
-                fc.StopIfTrue = False
-
-            _suppress_keys(app)
-
-        sheet.Range(_GRID_RANGE).Value = grid
-        sheet.Range("A1").Value = "GAME BOY"
-        sheet.Range("A2").Value = (
-            chr(8592) + chr(8593) + chr(8594) + chr(8595)
-            + "  Z=A  X=B  Enter=Start  Back=Select   gb_stop() to end"
-        )
-
-    shortcut_xl.xl_batch(_paint)
-
-
-def _tick():
-    if not _state['running']:
-        return
-    try:
-        pb = _state['pyboy']
-        now = time.perf_counter()
-        elapsed = now - _state['_last_tick']
-        _state['_last_tick'] = now
-
-        # Advance emulator to keep game at real speed
-        # Even if rendering is slow, the game plays at correct pace
-        frames_to_run = max(1, min(int(elapsed * TARGET_EMU_FPS), 10))
-        _poll_keys()
-        for _ in range(frames_to_run - 1):
-            pb.tick(1, False)  # advance without rendering
-        pb.tick(1, True)       # render last frame only
-
-        # Re-detect palette every ~2 seconds of game time
-        if pb.frame_count % 120 == 0:
-            _detect_palette()
-            _state['_formatted'] = False
-
-        grid = _grab_frame()
-        _render(grid)
-    except Exception as e:
-        xl_log(f"gameboy tick error: {e}")
-        import traceback
-        xl_log(traceback.format_exc())
-        _state['running'] = False
-        shortcut_xl.schedule_call(_restore_calc, 0.3)
-        return
-    # Schedule next tick immediately — render as fast as COM allows
-    shortcut_xl.schedule_call(_tick, 0.001)
-
-
-def _restore_calc():
-    def _do(app):
-        _restore_keys(app)
-        app.Calculation = -4105  # xlCalculationAutomatic
-    shortcut_xl.xl_batch(_do)
-
-
-@xl_func
-def gb_start(rom_path=""):
-    if _state['running']:
-        return "Already running! gb_stop() first"
-
-    if not rom_path or rom_path is None:
-        rom_path = "pokemon_red"
-
-    if not os.path.isfile(rom_path):
-        modules_dir = os.path.dirname(os.path.abspath(__file__))
-        roms_dir = os.path.join(os.path.dirname(modules_dir), "roms")
-        candidate = os.path.join(roms_dir, rom_path if rom_path.endswith(".gb") else rom_path + ".gb")
-        if os.path.isfile(candidate):
-            rom_path = candidate
-
-    if not os.path.isfile(rom_path):
-        return f"ROM not found: {rom_path}"
-
-    try:
-        from pyboy import PyBoy
-        pb = PyBoy(rom_path, window='null')
-        for _ in range(200):
-            pb.tick(1, True)
-        _state['pyboy'] = pb
-    except Exception as e:
-        xl_log(f"gb_start error: {e}")
-        return f"Failed: {e}"
-
-    _detect_palette()
-
-    _state['running'] = True
-    _state['_formatted'] = False
-    _state['_keys_held'] = set()
-    _state['_last_tick'] = time.perf_counter()
-    shortcut_xl.schedule_call(_tick, 0.1)
-    return "GAME BOY!"
-
-
-@xl_func
-def gb_stop():
-    _state['running'] = False
-    pb = _state.get('pyboy')
-    if pb:
-        try:
-            pb.stop(False)
-        except Exception:
-            pass
-        _state['pyboy'] = None
-    shortcut_xl.schedule_call(_restore_calc, 0.3)
-    return "Stopped"
+"""
+Game Boy emulator in Excel — type =gb_start() to play Pokemon Red!
+
+Runs a Game Boy ROM via PyBoy at full 160x144 resolution.
+Colors are auto-detected from the game's actual palette.
+
+Arrow keys + Z (A) + X (B) + Enter (Start) + Backspace (Select).
+Type =gb_stop() to end.
+"""
+import shortcut_xl
+from shortcut_xl import xl_func, xl_log
+import ctypes
+import os
+import time
+
+WIDTH = 160
+HEIGHT = 144
+TARGET_EMU_FPS = 60  # Game Boy runs at ~60 FPS
+
+# Column letter helper
+def _col_letter(n):
+    s = ""
+    while n > 0:
+        n, rem = divmod(n - 1, 26)
+        s = chr(65 + rem) + s
+    return s
+
+_GRID_RANGE = f"A3:{_col_letter(WIDTH)}{2 + HEIGHT}"
+
+# Key mappings: Windows VK code -> PyBoy button name
+_KEY_MAP = {
+    0x25: 'left',
+    0x26: 'up',
+    0x27: 'right',
+    0x28: 'down',
+    0x5A: 'a',       # Z
+    0x58: 'b',       # X
+    0x0D: 'start',   # Enter
+    0x08: 'select',  # Backspace
+}
+
+_state = {
+    'pyboy': None,
+    'running': False,
+    '_formatted': False,
+    '_keys_held': set(),
+    '_palette_bgr': None,
+    '_last_tick': 0.0,
+}
+
+# Excel OnKey strings to suppress during gameplay
+_ONKEY_SUPPRESS = [
+    "z", "Z", "x", "X",
+    "{LEFT}", "{RIGHT}", "{UP}", "{DOWN}",
+    "~", "{BS}",
+]
+
+
+def _suppress_keys(app):
+    for k in _ONKEY_SUPPRESS:
+        app.OnKey(k, "")
+
+
+def _restore_keys(app):
+    for k in _ONKEY_SUPPRESS:
+        app.OnKey(k)
+
+
+def _poll_keys():
+    pb = _state['pyboy']
+    if not pb:
+        return
+    currently_held = set()
+    for vk in _KEY_MAP:
+        if ctypes.windll.user32.GetAsyncKeyState(vk) & 0x8000:
+            currently_held.add(vk)
+    prev = _state['_keys_held']
+    for vk in currently_held - prev:
+        pb.button_press(_KEY_MAP[vk])
+    for vk in prev - currently_held:
+        pb.button_release(_KEY_MAP[vk])
+    _state['_keys_held'] = currently_held
+
+
+def _detect_palette():
+    """Scan screen for unique colors, build sorted palette."""
+    import numpy as np
+    screen = _state['pyboy'].screen.ndarray[:, :, :3]
+    unique = np.unique(screen.reshape(-1, 3), axis=0)
+    brightness = np.sum(unique, axis=1)
+    order = np.argsort(brightness)
+    palette = [tuple(unique[i]) for i in order]
+    _state['_palette_bgr'] = [
+        int(b) * 65536 + int(g) * 256 + int(r) for r, g, b in palette
+    ]
+    # Build threshold list from midpoints between palette brightness levels
+    b_sorted = sorted(brightness)
+    thresholds = []
+    for i in range(len(b_sorted) - 1):
+        thresholds.append((b_sorted[i] + b_sorted[i + 1]) / 2.0 / 3.0)  # per-channel avg
+    _state['_thresholds'] = thresholds
+    xl_log(f"gb palette: {len(palette)} colors, thresholds={thresholds}")
+
+
+def _grab_frame():
+    """Fast frame grab: threshold-based, returns list-of-lists (no tuple conversion)."""
+    import numpy as np
+    screen = _state['pyboy'].screen.ndarray[:, :, 0]  # R channel (GB is grayscale R=G=B)
+    thresholds = _state.get('_thresholds', [64, 128, 192])
+
+    indices = np.zeros(screen.shape, dtype=np.uint8)
+    for i, t in enumerate(thresholds):
+        indices[screen >= t] = i + 1
+
+    return indices.tolist()  # list-of-lists — fast C-level conversion
+
+
+def _render(grid):
+    def _paint(app):
+        app.Calculation = -4135  # xlCalculationManual
+        sheet = app.ActiveSheet
+
+        if not _state['_formatted']:
+            _state['_formatted'] = True
+            area = sheet.Range(_GRID_RANGE)
+            area.ColumnWidth = 0.75
+            area.RowHeight = 5
+            area.NumberFormat = ";;;"
+
+            # Conditional formatting from detected palette
+            area.FormatConditions.Delete()
+            for val, bgr in enumerate(_state['_palette_bgr']):
+                fc = area.FormatConditions.Add(1, 3, str(val))
+                fc.Interior.Color = bgr
+                fc.Font.Color = bgr
+                fc.StopIfTrue = False
+
+            _suppress_keys(app)
+
+        sheet.Range(_GRID_RANGE).Value = grid
+        sheet.Range("A1").Value = "GAME BOY"
+        sheet.Range("A2").Value = (
+            chr(8592) + chr(8593) + chr(8594) + chr(8595)
+            + "  Z=A  X=B  Enter=Start  Back=Select   gb_stop() to end"
+        )
+
+    shortcut_xl.xl_batch(_paint)
+
+
+def _tick():
+    if not _state['running']:
+        return
+    try:
+        pb = _state['pyboy']
+        now = time.perf_counter()
+        elapsed = now - _state['_last_tick']
+        _state['_last_tick'] = now
+
+        # Advance emulator to keep game at real speed
+        # Even if rendering is slow, the game plays at correct pace
+        frames_to_run = max(1, min(int(elapsed * TARGET_EMU_FPS), 10))
+        _poll_keys()
+        for _ in range(frames_to_run - 1):
+            pb.tick(1, False)  # advance without rendering
+        pb.tick(1, True)       # render last frame only
+
+        # Re-detect palette every ~2 seconds of game time
+        if pb.frame_count % 120 == 0:
+            _detect_palette()
+            _state['_formatted'] = False
+
+        grid = _grab_frame()
+        _render(grid)
+    except Exception as e:
+        xl_log(f"gameboy tick error: {e}")
+        import traceback
+        xl_log(traceback.format_exc())
+        _state['running'] = False
+        shortcut_xl.schedule_call(_restore_calc, 0.3)
+        return
+    # Schedule next tick immediately — render as fast as COM allows
+    shortcut_xl.schedule_call(_tick, 0.001)
+
+
+def _restore_calc():
+    def _do(app):
+        _restore_keys(app)
+        app.Calculation = -4105  # xlCalculationAutomatic
+    shortcut_xl.xl_batch(_do)
+
+
+@xl_func
+def gb_start(rom_path=""):
+    if _state['running']:
+        return "Already running! gb_stop() first"
+
+    if not rom_path or rom_path is None:
+        rom_path = "pokemon_red"
+
+    if not os.path.isfile(rom_path):
+        modules_dir = os.path.dirname(os.path.abspath(__file__))
+        roms_dir = os.path.join(os.path.dirname(modules_dir), "roms")
+        candidate = os.path.join(roms_dir, rom_path if rom_path.endswith(".gb") else rom_path + ".gb")
+        if os.path.isfile(candidate):
+            rom_path = candidate
+
+    if not os.path.isfile(rom_path):
+        return f"ROM not found: {rom_path}"
+
+    try:
+        from pyboy import PyBoy
+        pb = PyBoy(rom_path, window='null')
+        for _ in range(200):
+            pb.tick(1, True)
+        _state['pyboy'] = pb
+    except Exception as e:
+        xl_log(f"gb_start error: {e}")
+        return f"Failed: {e}"
+
+    _detect_palette()
+
+    _state['running'] = True
+    _state['_formatted'] = False
+    _state['_keys_held'] = set()
+    _state['_last_tick'] = time.perf_counter()
+    shortcut_xl.schedule_call(_tick, 0.1)
+    return "GAME BOY!"
+
+
+@xl_func
+def gb_stop():
+    _state['running'] = False
+    pb = _state.get('pyboy')
+    if pb:
+        try:
+            pb.stop(False)
+        except Exception:
+            pass
+        _state['pyboy'] = None
+    shortcut_xl.schedule_call(_restore_calc, 0.3)
+    return "Stopped"