pyboy 2.2.2__tar.gz → 2.3.0__tar.gz

{pyboy-2.2.2/pyboy.egg-info → pyboy-2.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pyboy
-Version: 2.2.2
+Version: 2.3.0
 Summary: Game Boy emulator written in Python
 Author-email: Mads Ynddal <mads@ynddal.dk>
 License: GNU Lesser General Public License

{pyboy-2.2.2 → pyboy-2.3.0}/pyboy/__main__.py

@@ -87,6 +87,11 @@ parser.add_argument(
 parser.add_argument("-s", "--scale", default=defaults["scale"], type=int, help="The scaling multiplier for the window")
 parser.add_argument("--sound", action="store_true", help="Enable sound (beta)")
 parser.add_argument("--no-renderer", action="store_true", help="Disable rendering (internal use)")
+parser.add_argument(
+    "--gameshark",
+    type=str,
+    help="Add GameShark cheats on start-up. Add multiple by comma separation (i.e. '010138CD, 01033CD1')"
+)
 
 gameboy_type_parser = parser.add_mutually_exclusive_group()
 gameboy_type_parser.add_argument(

{pyboy-2.2.2 → pyboy-2.3.0}/pyboy/api/__init__.py

@@ -7,6 +7,7 @@ Tools to help interfacing with the Game Boy hardware
 """
 
 from . import constants
+from .gameshark import GameShark
 from .screen import Screen
 from .sprite import Sprite
 from .tile import Tile

pyboy-2.3.0/pyboy/api/gameshark.pxd

@@ -0,0 +1,24 @@
+#
+# License: See LICENSE.md file
+# GitHub: https://github.com/Baekalfen/PyBoy
+#
+
+from libc.stdint cimport uint8_t
+
+from pyboy.logging.logging cimport Logger
+
+
+cdef Logger logger
+
+cdef class GameShark:
+    cdef object memory
+    cdef dict cheats
+    cdef bint enabled
+
+    cdef uint8_t _get_value(self, int, int) noexcept
+    cdef void _set_value(self, int, int, int) noexcept
+    cdef tuple _convert_cheat(self, str code) noexcept
+    cpdef void add(self, str code) noexcept
+    cpdef void remove(self, str code, bint restore_value=*) noexcept
+    cpdef void clear_all(self, bint restore_value=*) noexcept
+    cdef void tick(self) noexcept

pyboy-2.3.0/pyboy/api/gameshark.py

@@ -0,0 +1,153 @@
+#
+# License: See LICENSE.md file
+# GitHub: https://github.com/Baekalfen/PyBoy
+#
+
+from pyboy.logging import get_logger
+
+logger = get_logger(__name__)
+
+
+class GameShark:
+    def __init__(self, memory):
+        self.memory = memory
+        self.cheats = {}
+        self.enabled = False
+
+    def _convert_cheat(self, gameshark_code):
+        '''
+        A GameShark code for these consoles is written in the format ttvvaaaa. tt specifies the type, which is usually 01.
+        vv specifies the hexadecimal value the code will write into the game's memory. aaaa specifies the memory address
+        that will be modified, with the low byte first (e.g. address C056 is written as 56C0).
+        Example 011556C0 would output:
+        type = 01
+        value = 0x15
+        address = 0x56C0
+
+        For more details:
+        https://doc.kodewerx.org/hacking_gb.html
+
+        There seems to be conflicting information about the presence of other types than 01.
+        '''
+        # Check if the input cheat code has the correct length (8 characters)
+        if len(gameshark_code) != 8:
+            raise ValueError("Invalid cheat code length. Cheat code must be 8 characters long.")
+
+        # Extract components from the cheat code
+        _type = int(gameshark_code[:2], 16)
+        value = int(gameshark_code[2:4], 16) # Convert hexadecimal value to an integer
+        unconverted_address = gameshark_code[4:] # Ex:   1ED1
+        lower = unconverted_address[:2] # Ex:  1E
+        upper = unconverted_address[2:] # Ex:  D1
+        address_converted = upper + lower # Ex: 0xD11E   # Converting to Ram Readable address
+        address = int(address_converted, 16)
+
+        if not 0x8000 <= address:
+            raise ValueError("Invalid GameShark code provided. Address not in the RAM range")
+
+        return (_type, value, address)
+
+    def _get_value(self, _type, address):
+        if _type == 0x01:
+            # 8-bit RAM write
+            # Writes the byte xx to the address zzyy.
+            return self.memory[address]
+        # elif (_type & 0xF0) == 0x80:
+        #     # 8-bit RAM write (with bank change)
+        #     # Changes the RAM bank to b, then writes the byte xx to the address zzyy.
+        #     bank = _type & 0xF
+        #     pass
+        # elif (_type & 0xF0) == 0x90:
+        #     # 8-bit RAM write (with WRAM bank change)
+        #     # Changes the WRAM bank to b and then writes the byte xx to the address zzyy. GBC only.
+        #     bank = _type & 0xF
+        #     pass
+        else:
+            raise ValueError("Invalid GameShark type", _type)
+
+    def _set_value(self, _type, value, address):
+        if _type == 0x01:
+            # 8-bit RAM write
+            # Writes the byte xx to the address zzyy.
+            self.memory[address] = value
+        # elif (_type & 0xF0) == 0x80:
+        #     # 8-bit RAM write (with bank change)
+        #     # Changes the RAM bank to b, then writes the byte xx to the address zzyy.
+        #     bank = _type & 0xF
+        #     pass
+        # elif (_type & 0xF0) == 0x90:
+        #     # 8-bit RAM write (with WRAM bank change)
+        #     # Changes the WRAM bank to b and then writes the byte xx to the address zzyy. GBC only.
+        #     bank = _type & 0xF
+        #     pass
+        else:
+            raise ValueError("Invalid GameShark type", _type)
+
+    def add(self, code):
+        """
+        Add a GameShark cheat to the emulator.
+
+        Example:
+        ```python
+        >>> pyboy.gameshark.add("01FF16D0")
+        ```
+
+        Args:
+            code (str): GameShark code to add
+        """
+        self.enabled = True
+        _type, value, address = self._convert_cheat(code)
+        if code not in self.cheats:
+            self.cheats[code] = (self._get_value(_type, address), (_type, value, address))
+        else:
+            logger.error("GameShark code already applied!")
+
+    def remove(self, code, restore_value=True):
+        """
+        Remove a GameShark cheat from the emulator.
+
+        Example:
+        ```python
+        >>> pyboy.gameshark.add("01FF16D0")
+        >>> pyboy.gameshark.remove("01FF16D0")
+        ```
+
+        Args:
+            code (str): GameShark code to remove
+            restore_value (bool): True to restore original value at address, otherwise don't restore
+        """
+
+        if not code in self.cheats:
+            raise ValueError("GameShark code cannot be removed. Hasn't been applied.")
+
+        original_value, (_type, _, address) = self.cheats.pop(code)
+        if restore_value:
+            self._set_value(_type, original_value, address)
+
+        if len(self.cheats) == 0:
+            self.enabled = False
+
+    def clear_all(self, restore_value=True):
+        """
+        Remove all GameShark cheats from the emulator.
+
+        Example:
+        ```python
+        >>> pyboy.gameshark.clear_all()
+        ```
+
+        Args:
+            restore_value (bool): Restore the original values of the memory addresses that were modified by the cheats.
+        """
+        # NOTE: Create a list so we don't remove from the iterator we are going through
+        for code in list(self.cheats.keys()):
+            self.remove(code, restore_value)
+
+    def tick(self):
+        if not self.enabled:
+            return
+        # https://gbdev.io/pandocs/Shark_Cheats.html
+        # "As far as it is understood, patching is implemented by hooking the original VBlank interrupt handler, and
+        # re-writing RAM values each frame."
+        for _, (_, (_type, value, address)) in self.cheats.items():
+            self._set_value(_type, value, address)

{pyboy-2.2.2 → pyboy-2.3.0}/pyboy/plugins/base_plugin.pxd

@@ -6,7 +6,7 @@
 cimport cython
 cimport numpy as cnp
 from cpython.array cimport array
-from libc.stdint cimport uint8_t, uint16_t, uint32_t
+from libc.stdint cimport uint8_t, uint16_t, uint32_t, int64_t
 
 from pyboy.core.lcd cimport Renderer
 from pyboy.core.mb cimport Motherboard
@@ -38,6 +38,7 @@ cdef class PyBoyWindowPlugin(PyBoyPlugin):
     cdef bint enable_title
     cdef Renderer renderer
 
+    cdef int64_t _ftime
     cdef bint frame_limiter(self, int) noexcept
     cdef void set_title(self, str) noexcept
 

{pyboy-2.2.2 → pyboy-2.3.0}/pyboy/plugins/base_plugin.py

@@ -13,6 +13,7 @@ __pdoc__ = {
 
 import io
 import random
+import time
 from array import array
 
 import numpy as np
@@ -65,6 +66,8 @@ class PyBoyWindowPlugin(PyBoyPlugin):
     def __init__(self, pyboy, mb, pyboy_argv, *args, **kwargs):
         super().__init__(pyboy, mb, pyboy_argv, *args, **kwargs)
 
+        self._ftime = time.perf_counter_ns()
+
         if not self.enabled():
             return
 
@@ -83,7 +86,14 @@ class PyBoyWindowPlugin(PyBoyPlugin):
         self.renderer = self.mb.lcd.renderer
 
     def frame_limiter(self, speed):
-        return False
+        self._ftime += int((1.0 / (60.0*speed)) * 1_000_000_000)
+        now = time.perf_counter_ns()
+        if (self._ftime > now):
+            delay = (self._ftime - now) // 1_000_000
+            time.sleep(delay / 1000)
+        else:
+            self._ftime = now
+        return True
 
     def set_title(self, title):
         pass

{pyboy-2.2.2 → pyboy-2.3.0}/pyboy/plugins/window_null.py

@@ -22,6 +22,8 @@ class WindowNull(PyBoyWindowPlugin):
                 'Deprecated use of "headless" or "dummy" window. Change to "null" window instead. https://github.com/Baekalfen/PyBoy/wiki/Migrating-from-v1.x.x-to-v2.0.0'
             )
 
+        pyboy.set_emulation_speed(0)
+
     def enabled(self):
         return self.pyboy_argv.get("window") in ["null", "headless", "dummy"]
 

{pyboy-2.2.2 → pyboy-2.3.0}/pyboy/plugins/window_open_gl.pxd

@@ -22,7 +22,6 @@ cdef int ROWS, COLS
 cdef class WindowOpenGL(PyBoyWindowPlugin):
     cdef list events
 
-    cdef int64_t _ftime
     cdef void _glkeyboard(self, str, int, int, bint) noexcept
     cdef void _glkeyboardspecial(self, char, int, int, bint) noexcept
 

{pyboy-2.2.2 → pyboy-2.3.0}/pyboy/plugins/window_open_gl.py

@@ -50,7 +50,7 @@ class WindowOpenGL(PyBoyWindowPlugin):
         glPixelZoom(self.scale, self.scale)
         glutReshapeFunc(self._glreshape)
         glutDisplayFunc(self._gldraw)
-        self._ftime = time.perf_counter_ns()
+        
 
     # Cython does not cooperate with lambdas
     def _key(self, c, x, y):
@@ -139,16 +139,6 @@ class WindowOpenGL(PyBoyWindowPlugin):
         glDrawPixels(COLS, ROWS, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8_REV, buf)
         glFlush()
 
-    def frame_limiter(self, speed):
-        self._ftime += int((1.0 / (60.0*speed)) * 1_000_000_000)
-        now = time.perf_counter_ns()
-        if (self._ftime > now):
-            delay = (self._ftime - now) // 1_000_000
-            time.sleep(delay / 1000)
-        else:
-            self._ftime = now
-        return True
-
     def enabled(self):
         if self.pyboy_argv.get("window") == "OpenGL":
             if opengl_enabled:

{pyboy-2.2.2 → pyboy-2.3.0}/pyboy/plugins/window_sdl2.pxd

@@ -25,7 +25,6 @@ cpdef list sdl2_event_pump(list) noexcept
 
 cdef class WindowSDL2(PyBoyWindowPlugin):
 
-    cdef int64_t _ftime
     cdef dict _key_down
     cdef dict _key_up
     cdef bint fullscreen

{pyboy-2.2.2 → pyboy-2.3.0}/pyboy/plugins/window_sdl2.py

@@ -157,9 +157,7 @@ class WindowSDL2(PyBoyWindowPlugin):
 
         if not self.enabled():
             return
-
         sdl2.SDL_Init(sdl2.SDL_INIT_VIDEO | sdl2.SDL_INIT_GAMECONTROLLER)
-        self._ftime = time.perf_counter_ns()
 
         self._window = sdl2.SDL_CreateWindow(
             b"PyBoy", sdl2.SDL_WINDOWPOS_CENTERED, sdl2.SDL_WINDOWPOS_CENTERED, self._scaledresolution[0],
@@ -205,16 +203,6 @@ class WindowSDL2(PyBoyWindowPlugin):
         else:
             return False
 
-    def frame_limiter(self, speed):
-        self._ftime += int((1.0 / (60.0*speed)) * 1_000_000_000)
-        now = time.perf_counter_ns()
-        if (self._ftime > now):
-            delay = (self._ftime - now) // 1_000_000
-            sdl2.SDL_Delay(delay)
-        else:
-            self._ftime = now
-        return True
-
     def stop(self):
         sdl2.SDL_DestroyWindow(self._window)
         for _ in range(10): # At least 2 to close

{pyboy-2.2.2 → pyboy-2.3.0}/pyboy/pyboy.pxd

@@ -8,6 +8,7 @@ cimport cython
 from libc cimport time
 from libc.stdint cimport int64_t, uint64_t
 
+from pyboy.api.gameshark cimport GameShark
 from pyboy.api.memory_scanner cimport MemoryScanner
 from pyboy.api.screen cimport Screen
 from pyboy.api.tilemap cimport TileMap
@@ -59,6 +60,7 @@ cdef class PyBoy:
     cdef readonly TileMap tilemap_window
     cdef readonly object game_wrapper
     cdef readonly MemoryScanner memory_scanner
+    cdef readonly GameShark gameshark
     cdef readonly str cartridge_title
 
     cdef bint limit_emulationspeed

{pyboy-2.2.2 → pyboy-2.3.0}/pyboy/pyboy.py

@@ -13,6 +13,7 @@ import time
 
 import numpy as np
 
+from pyboy.api.gameshark import GameShark
 from pyboy.api.memory_scanner import MemoryScanner
 from pyboy.api.screen import Screen
 from pyboy.api.tilemap import TileMap
@@ -50,6 +51,7 @@ class PyBoy:
         sound=False,
         sound_emulated=False,
         cgb=None,
+        gameshark=None,
         log_level=defaults["log_level"],
         **kwargs
     ):
@@ -355,6 +357,21 @@ class PyBoy:
             A game-specific wrapper object.
         """
 
+        self.gameshark = GameShark(self.memory)
+        """
+        Provides an instance of the `pyboy.api.gameshark.GameShark` handler. This allows you to inject GameShark-based cheat codes.
+
+        Example:
+        ```python
+        >>> pyboy.gameshark.add("010138CD")
+        >>> pyboy.gameshark.remove("010138CD")
+        >>> pyboy.gameshark.clear_all()
+        ```
+        """
+        if gameshark:
+            for code in gameshark.split(","):
+                self.gameshark.add(code.strip())
+
         self.initialized = True
 
     def _tick(self, render):
@@ -365,6 +382,7 @@ class PyBoy:
         self._handle_events(self.events)
         t_pre = time.perf_counter_ns()
         if not self.paused:
+            self.gameshark.tick()
             self.__rendering(render)
             # Reenter mb.tick until we eventually get a clean exit without breakpoints
             while self.mb.tick():
@@ -970,7 +988,8 @@ class PyBoy:
 
         A `target_speed` of `0` means unlimited. I.e. fastest possible execution.
 
-        Some window types do not implement a frame-limiter, and will always run at full speed.
+        Due to backwards compatibility, the null window starts at unlimited speed (i.e. `target_speed=0`), while
+        others start at realtime (i.e. `target_speed=1`).
 
         Example:
         ```python
@@ -984,11 +1003,6 @@ class PyBoy:
         Args:
             target_speed (int): Target emulation speed as multiplier of real-time.
         """
-        if self.initialized and self._plugin_manager.window_null_enabled:
-            logger.warning(
-                'This window type does not support frame-limiting. `pyboy.set_emulation_speed(...)` will have no effect, as it\'s always running at full speed.'
-            )
-
         if target_speed > 5:
             logger.warning("The emulation speed might not be accurate when speed-target is higher than 5")
         self.target_emulationspeed = target_speed

{pyboy-2.2.2 → pyboy-2.3.0/pyboy.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pyboy
-Version: 2.2.2
+Version: 2.3.0
 Summary: Game Boy emulator written in Python
 Author-email: Mads Ynddal <mads@ynddal.dk>
 License: GNU Lesser General Public License

{pyboy-2.2.2 → pyboy-2.3.0}/pyboy.egg-info/SOURCES.txt

@@ -20,6 +20,8 @@ pyboy.egg-info/requires.txt
 pyboy.egg-info/top_level.txt
 pyboy/api/__init__.py
 pyboy/api/constants.py
+pyboy/api/gameshark.pxd
+pyboy/api/gameshark.py
 pyboy/api/memory_scanner.pxd
 pyboy/api/memory_scanner.py
 pyboy/api/screen.pxd

{pyboy-2.2.2 → pyboy-2.3.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "pyboy"
-version = "2.2.2"
+version = "2.3.0"
 authors = [
     {name = "Mads Ynddal", email = "mads@ynddal.dk"}
 ]