pyboy 2.5.3__tar.gz → 2.6.0__tar.gz

pyboy-2.6.0/PKG-INFO

@@ -0,0 +1,228 @@
+Metadata-Version: 2.4
+Name: pyboy
+Version: 2.6.0
+Summary: Game Boy emulator written in Python
+Author-email: Mads Ynddal <mads@ynddal.dk>
+License-Expression: LGPL-3.0-only
+Project-URL: Homepage, https://github.com/Baekalfen/PyBoy
+Project-URL: Documentation, https://docs.pyboy.dk/index.html
+Project-URL: Repository, https://github.com/Baekalfen/PyBoy.git
+Keywords: gameboy,game boy,emulator,cython,pypy
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Cython
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Classifier: Topic :: System :: Emulators
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE.md
+Requires-Dist: numpy
+Requires-Dist: pysdl2
+Requires-Dist: pysdl2-dll
+Provides-Extra: all
+Requires-Dist: pyopengl; extra == "all"
+Requires-Dist: markdown; extra == "all"
+Requires-Dist: pdoc3; extra == "all"
+Requires-Dist: gym; extra == "all"
+Dynamic: license-file
+
+<p align="center">
+<img src="extras/README/pyboy.svg" width="480">
+</p>
+
+__If you have any questions, or just want to chat, [join us on Discord](https://discord.gg/wUbag3KNqQ).__
+
+[![Discord](https://img.shields.io/discord/584149554132418570?style=for-the-badge&logo=Discord&label=PyBoy)](https://discord.gg/wUbag3KNqQ)
+
+<!---
+Generate GIF with the layout and captions
+-->
+<table>
+  <tbody>
+    <tr>
+      <td colspan=2 align="center"><a href=https://github.com/PWhiddy/PokemonRedExperiments>Train RL agents to play Pokemon Red</a>
+      </td>
+      <td align="center"><a href=https://github.com/Baekalfen/PyBoy/wiki/Experimental-and-optional-features#rewind-time>Rewind any game</a><br>
+      </td>
+    </tr>
+    <tr>
+      <td colspan=2 align="center">
+        <div align="center">
+        <a href="http://www.youtube.com/watch?feature=player_embedded&v=DcYLT37ImBY" target="_blank">
+        <img src="http://img.youtube.com/vi/DcYLT37ImBY/maxresdefault.jpg" alt="Watch the video" width="500" border="10" />
+        <!-- <img src="http://img.youtube.com/vi/DcYLT37ImBY/hqdefault.jpg" alt="Watch the video" width="500" border="10" /> -->
+        </a>
+        <!-- https://www.youtube.com/watch?v=DcYLT37ImBY -->
+        <!-- <img src="extras/README/8.gif" width="400"><br> -->
+        </div>
+      </td>
+      <td align="center">
+        <img src="extras/README/5.gif" width="250">
+      </td>
+    </tr>
+    <tr>
+      <td align="center">Play the classics<br>
+      </td>
+      <td align="center"><a href=https://github.com/lixado/PyBoy-RL>Create your own AI</a><br>
+      </td>
+      <td align="center"><a href=https://github.com/uiucanh/tetris>Beat world records with AI</a><br>
+      </td>
+    </tr>
+    <tr>
+      <td align="center">
+        <img src="extras/README/1.gif" width="250">
+      </td>
+      <td align="center">
+        <img src="extras/README/6.gif" width="250">
+      </td>
+      <td align="center">
+        <img src="extras/README/7.gif" width="250">
+      </td>
+    </tr>
+  </tbody>
+</table>
+
+Getting Started
+===============
+The instructions are simple:
+
+```sh
+$ pip install pyboy
+```
+
+For details, see [installation instructions](https://github.com/Baekalfen/PyBoy/wiki/Installation).
+
+Now you're ready! Either use PyBoy directly from the terminal
+```sh
+$ pyboy game_rom.gb
+```
+
+Or use it in your Python scripts:
+```python
+from pyboy import PyBoy
+pyboy = PyBoy('game_rom.gb')
+while pyboy.tick():
+    pass
+pyboy.stop()
+```
+
+<!-- Or using the context manager:
+```python
+from pyboy import PyBoy
+with PyBoy('game_rom.gb') as pyboy:
+    while pyboy.tick():
+        pass
+``` -->
+
+
+The API
+=======
+
+If you are looking to make a bot or AI, then these resources are a good place to start:
+ * [PyBoy API Documentation](https://baekalfen.github.io/PyBoy/index.html)
+ * [Wiki Pages](https://github.com/Baekalfen/PyBoy/wiki/)
+   * [Using PyBoy with Gym](https://github.com/Baekalfen/PyBoy/wiki/Using-PyBoy-with-Gym)
+   * [Example: Kirby](https://github.com/Baekalfen/PyBoy/wiki/Example-Kirby)
+   * [Example: Tetris](https://github.com/Baekalfen/PyBoy/wiki/Example-Tetris)
+   * [Example: Super Mario Land](https://github.com/Baekalfen/PyBoy/wiki/Example-Super-Mario-Land)
+   * [Code Examples](https://github.com/Baekalfen/PyBoy/tree/master/extras/examples)
+ * [Discord](https://discord.gg/wUbag3KNqQ)
+
+
+When the emulator is running, you can easily access [PyBoy's API](https://baekalfen.github.io/PyBoy/index.html):
+```python
+pyboy.set_emulation_speed(0) # No speed limit
+pyboy.button('down')
+pyboy.button('a')
+pyboy.tick() # Process at least one frame to let the game register the input
+value_of_interest = pyboy.memory[0xC345]
+
+pil_image = pyboy.screen.image
+pil_image.save('screenshot.png')
+```
+
+The [Wiki](https://github.com/Baekalfen/PyBoy/wiki) shows how to interface with PyBoy from your own project.
+
+Performance
+===========
+
+Performance is a priority for PyBoy, to make your AI training and scripts as fast as possible.
+
+The easiest way to improve your performance, is to skip rendering of unnecessary frames. If you know your
+character takes X frames to move, or the game doesn't take input every frame, you can skip those to potentially triple
+your performance. All game logic etc. will still process.
+
+Here is a simple comparison of rendering every frame, rendering every 15th frame, and not rendering any frames (higher is better). See [`pyboy.tick`](https://docs.pyboy.dk/#pyboy.PyBoy.tick) for how it works. Your performance will depend on the game.
+
+<table>
+  <tbody>
+    <tr>
+      <td align="center">
+        Full rendering
+      </td>
+      <td align="center">
+        Frame-skip 15
+      </td>
+      <td align="center">
+        No rendering
+      </td>
+    </tr>
+    <tr>
+      <td>
+      x124 realtime
+      </td>
+      <td>
+      x344 realtime
+      </td>
+      <td>
+      x395 realtime
+      </td>
+    </tr>
+<tr> <!-- Markdown/HTML broken after this -->
+<td>
+
+```python
+for _ in range(target):
+    pyboy.tick()
+
+```
+</td>
+<td >
+
+```python
+for _ in range(target//15):
+    pyboy.tick(15)
+
+```
+</td>
+<td >
+
+```python
+pyboy.tick(target, False)
+
+```
+</td>
+</tr>
+  </tbody>
+</table>
+
+The Game Boy was originally running at 60 frames per second, so a speed-up of 100x realtime is 6,000 frames per
+second. And trivially from the table above, simulating 395 hours of gameplay can be done in 1 hour with no rendering.
+
+It's also recommended to be running multiple instances of PyBoy in parallel. On an 8-core machine, you could potentially
+do 3160 hours of gameplay in 1 hour.
+
+Contributing
+============
+Any contribution is appreciated. The currently known problems are tracked in [the Issues tab](https://github.com/Baekalfen/PyBoy/issues). Feel free to take a swing at any one of them. If you have something original in mind, come and [discuss it on on Discord](https://discord.gg/wUbag3KNqQ).
+
+[![Discord](https://img.shields.io/discord/584149554132418570?style=for-the-badge&logo=Discord&label=PyBoy)](https://discord.gg/wUbag3KNqQ)
+
+For the more major features, there are the following that you can give a try. They are also described in more detail in the [project list in the Wiki](https://github.com/Baekalfen/PyBoy/wiki/Student-Projects):
+* Hacking games
+* Link Cable
+* Debugger (VSCode, GDB, terminal or otherwise)
+* AI - [use the `api`](https://baekalfen.github.io/PyBoy/index.html) or game wrappers to train a neural network
+* Game Wrappers - make wrappers for popular games
+
+If you want to implement something which is not on the list, feel free to do so anyway. If you want to merge it into our repo, then just send a pull request and we will have a look at it.

{pyboy-2.5.3 → pyboy-2.6.0}/pyboy/core/lcd.py

@@ -42,12 +42,12 @@ class LCD:
 
         self.speed_shift = 0
         self.clock = 0
-        self.clock_target = FRAME_CYCLES << self.speed_shift
+        self.clock_target = FRAME_CYCLES
         self.frame_done = False
         self.first_frame = False
         self.reset = False
         self._cycles_to_interrupt = 0
-        self._cycles_to_frame = (FRAME_CYCLES << self.speed_shift) - self.clock
+        self._cycles_to_frame = (FRAME_CYCLES - self.clock) << self.speed_shift
         self.next_stat_mode = 2
         self.LY = 0x00
         self._STAT.set_mode(0)
@@ -63,7 +63,7 @@ class LCD:
         self._scanlineparameters = [[0, 0, 0, 0, 0] for _ in range(ROWS)]
         self.last_cycles = 0
         self._cycles_to_interrupt = 0
-        self._cycles_to_frame = (FRAME_CYCLES << self.speed_shift) - self.clock
+        self._cycles_to_frame = (FRAME_CYCLES - self.clock) << self.speed_shift
 
         if self.cgb:
             # Setting for both modes, even though CGB is ignoring them. BGP[0] used in scanline_blank.
@@ -115,9 +115,9 @@ class LCD:
             self.reset = True
 
     def cycles_to_mode0(self):
-        mode2 = 80 << self.speed_shift
-        mode3 = 170 << self.speed_shift
-        mode1 = 456 << self.speed_shift
+        mode2 = 80
+        mode3 = 170
+        mode1 = 456
 
         mode = self._STAT._mode
         # Remaining cycles for this already active mode
@@ -144,7 +144,7 @@ class LCD:
         self.last_cycles = _cycles
 
         interrupt_flag = 0
-        self.clock += cycles
+        self.clock += cycles >> self.speed_shift
 
         if self.clock >= self.clock_target:
             if self._LCDC.lcd_enable and (self.LY == 153 or self.reset):
@@ -159,7 +159,7 @@ class LCD:
 
                 # Reset to new frame and start from mode 2
                 self.LY = 0
-                self.clock %= FRAME_CYCLES << self.speed_shift
+                self.clock %= FRAME_CYCLES
                 self.clock_target = 0
                 self.next_stat_mode = 2
 
@@ -167,7 +167,7 @@ class LCD:
                 interrupt_flag |= self._STAT.set_mode(self.next_stat_mode)
 
                 # self._STAT._mode == 2:  # Searching OAM
-                self.clock_target += 80 << self.speed_shift
+                self.clock_target += 80
                 self.next_stat_mode = 3
                 interrupt_flag |= self._STAT.update_LYC(self.LYC, self.LY)
 
@@ -185,14 +185,14 @@ class LCD:
                 # LCD state machine
                 if self._STAT._mode == 2:  # Searching OAM
                     self.LY += 1
-                    self.clock_target += 80 << self.speed_shift
+                    self.clock_target += 80
                     self.next_stat_mode = 3
                     interrupt_flag |= self._STAT.update_LYC(self.LYC, self.LY)
                 elif self._STAT._mode == 3:
-                    self.clock_target += 170 << self.speed_shift
+                    self.clock_target += 170
                     self.next_stat_mode = 0
                 elif self._STAT._mode == 0:  # HBLANK
-                    self.clock_target += 206 << self.speed_shift
+                    self.clock_target += 206
 
                     # Recorded for API
                     bx, by = self.getviewport()
@@ -212,7 +212,7 @@ class LCD:
                     else:
                         self.next_stat_mode = 1
                 elif self._STAT._mode == 1:  # VBLANK
-                    self.clock_target += 456 << self.speed_shift
+                    self.clock_target += 456
                     self.next_stat_mode = 1
 
                     self.LY += 1
@@ -229,15 +229,16 @@ class LCD:
             else:
                 # See also `self.set_lcdc`
                 self.frame_done = True
-                self.clock %= FRAME_CYCLES << self.speed_shift
-                self.clock_target = FRAME_CYCLES << self.speed_shift
+                self.clock %= FRAME_CYCLES
+                self.clock_target = FRAME_CYCLES
 
                 # Renderer
                 self.renderer.blank_screen(self)
 
-        self._cycles_to_interrupt = self.clock_target - self.clock
+        # NOTE: speed_shift because they are using in externally in mb
+        self._cycles_to_interrupt = (self.clock_target - self.clock) << self.speed_shift
         # TODO: STAT Cycles to interrupts
-        self._cycles_to_frame = (FRAME_CYCLES << self.speed_shift) - self.clock
+        self._cycles_to_frame = (FRAME_CYCLES - self.clock) << self.speed_shift
         return interrupt_flag
 
     def save_state(self, f):
@@ -337,8 +338,9 @@ class LCD:
                 self.last_cycles = f.read_64bit()
             self.clock = f.read_64bit()
             self.clock_target = f.read_64bit()
-            self._cycles_to_interrupt = self.clock_target - self.clock
-            self._cycles_to_frame = (FRAME_CYCLES << self.speed_shift) - self.clock
+            # NOTE: speed_shift because they are using in externally in mb
+            self._cycles_to_interrupt = (self.clock_target - self.clock) << self.speed_shift
+            self._cycles_to_frame = (FRAME_CYCLES - self.clock) << self.speed_shift
             self.next_stat_mode = f.read()
 
             if self.cgb:

{pyboy-2.5.3 → pyboy-2.6.0}/pyboy/core/mb.pxd

@@ -13,6 +13,7 @@ cimport pyboy.core.cpu
 cimport pyboy.core.interaction
 cimport pyboy.core.lcd
 cimport pyboy.core.ram
+cimport pyboy.core.serial
 cimport pyboy.core.sound
 cimport pyboy.core.timer
 from pyboy.logging.logging cimport Logger
@@ -23,7 +24,7 @@ cdef Logger logger
 
 cdef int64_t MAX_CYCLES
 cdef uint16_t STAT, LY, LYC
-cdef int INTR_TIMER, INTR_HIGHTOLOW
+cdef int INTR_TIMER, INTR_SERIAL, INTR_HIGHTOLOW
 cdef uint16_t OPCODE_BRK
 cdef int STATE_VERSION
 
@@ -35,6 +36,7 @@ cdef class Motherboard:
     cdef pyboy.core.lcd.LCD lcd
     cdef pyboy.core.cpu.CPU cpu
     cdef pyboy.core.timer.Timer timer
+    cdef pyboy.core.serial.Serial serial
     cdef pyboy.core.sound.Sound sound
     cdef pyboy.core.cartridge.base_mbc.BaseMBC cartridge
     cdef bint bootrom_enabled

{pyboy-2.5.3 → pyboy-2.6.0}/pyboy/core/mb.py

@@ -9,14 +9,15 @@ from pyboy.utils import (
     PyBoyException,
     PyBoyOutOfBoundsException,
     INTR_TIMER,
+    INTR_SERIAL,
     INTR_HIGHTOLOW,
     OPCODE_BRK,
+    MAX_CYCLES,
 )
 
-from . import bootrom, cartridge, cpu, interaction, lcd, ram, sound, timer
+from . import bootrom, cartridge, cpu, interaction, lcd, ram, serial, sound, timer
 
 logger = pyboy.logging.get_logger(__name__)
-MAX_CYCLES = 1 << 31
 
 
 class Motherboard:
@@ -48,6 +49,7 @@ class Motherboard:
             logger.debug("Cartridge type auto-detected to %s", ("CGB" if self.cartridge.cgb else "DMG"))
 
         self.timer = timer.Timer()
+        self.serial = serial.Serial()
         self.interaction = interaction.Interaction()
         self.ram = ram.RAM(cgb, randomize=randomize)
         self.cpu = cpu.CPU(self)
@@ -95,7 +97,9 @@ class Motherboard:
         bit0 = self.key1 & 0b1
         if bit0 == 1:
             self.double_speed = not self.double_speed
+            self.lcd.tick(self.cpu.cycles)
             self.lcd.speed_shift = 1 if self.double_speed else 0
+            self.sound.tick(self.cpu.cycles)
             self.sound.speed_shift = 1 if self.double_speed else 0
             logger.debug("CGB double speed is now: %d", self.double_speed)
             self.key1 ^= 0b10000001
@@ -244,6 +248,7 @@ class Motherboard:
         self.timer.save_state(f)
         self.cartridge.save_state(f)
         self.interaction.save_state(f)
+        self.serial.save_state(f)
         f.flush()
         logger.debug("State saved.")
 
@@ -289,6 +294,8 @@ class Motherboard:
             self.timer.load_state(f, state_version)
         self.cartridge.load_state(f, state_version)
         self.interaction.load_state(f, state_version)
+        if state_version >= 15:
+            self.serial.load_state(f, state_version)
         f.flush()
         logger.debug("State loaded.")
 
@@ -321,7 +328,7 @@ class Motherboard:
                         self.lcd._cycles_to_interrupt,  # TODO: Be more agreesive. Only if actual interrupt enabled.
                         self.lcd._cycles_to_frame,
                         self.sound._cycles_to_interrupt,
-                        # self.serial.cycles_to_interrupt(),
+                        self.serial._cycles_to_interrupt,
                         mode0_cycles,
                     ),
                 )
@@ -334,6 +341,9 @@ class Motherboard:
 
             self.sound.tick(self.cpu.cycles)
 
+            if self.serial.tick(self.cpu.cycles):
+                self.cpu.set_interruptflag(INTR_SERIAL)
+
             if self.timer.tick(self.cpu.cycles):
                 self.cpu.set_interruptflag(INTR_TIMER)
 
@@ -380,7 +390,14 @@ class Motherboard:
         elif 0xFEA0 <= i < 0xFF00:  # Empty but unusable for I/O
             return self.ram.non_io_internal_ram0[i - 0xFEA0]
         elif 0xFF00 <= i < 0xFF4C:  # I/O ports
-            if 0xFF04 <= i <= 0xFF07:
+            if 0xFF01 <= i <= 0xFF02:
+                if self.serial.tick(self.cpu.cycles):
+                    self.cpu.set_interruptflag(INTR_SERIAL)
+                if i == 0xFF01:
+                    return self.serial.SB
+                elif i == 0xFF02:
+                    return self.serial.SC
+            elif 0xFF04 <= i <= 0xFF07:
                 if self.timer.tick(self.cpu.cycles):
                     self.cpu.set_interruptflag(INTR_TIMER)
 
@@ -510,11 +527,16 @@ class Motherboard:
         elif 0xFF00 <= i < 0xFF4C:  # I/O ports
             if i == 0xFF00:
                 self.ram.io_ports[i - 0xFF00] = self.interaction.pull(value)
-            elif i == 0xFF01:
-                self.serialbuffer[self.serialbuffer_count] = value
-                self.serialbuffer_count += 1
-                self.serialbuffer_count &= 0x3FF
-                self.ram.io_ports[i - 0xFF00] = value
+            elif 0xFF01 <= i <= 0xFF02:
+                if self.serial.tick(self.cpu.cycles):
+                    self.cpu.set_interruptflag(INTR_SERIAL)
+                if i == 0xFF01:
+                    self.serialbuffer[self.serialbuffer_count] = value
+                    self.serialbuffer_count += 1
+                    self.serialbuffer_count &= 0x3FF
+                    self.serial.set_SB(value)
+                elif i == 0xFF02:
+                    self.serial.set_SC(value)
             elif 0xFF04 <= i <= 0xFF07:
                 if self.timer.tick(self.cpu.cycles):
                     self.cpu.set_interruptflag(INTR_TIMER)

{pyboy-2.5.3 → pyboy-2.6.0}/pyboy/core/ram.pxd

@@ -4,11 +4,12 @@
 #
 
 cimport cython
-from libc.stdint cimport uint8_t
+from libc.stdint cimport uint8_t, uint16_t
 
 from pyboy.logging.logging cimport Logger
 from pyboy.utils cimport IntIOInterface
 
+cdef uint16_t INTERNAL_RAM0, INTERNAL_RAM0_CGB, NON_IO_INTERNAL_RAM0, IO_PORTS, NON_IO_INTERNAL_RAM1, INTERNAL_RAM1
 
 cdef Logger logger
 

pyboy-2.6.0/pyboy/core/serial.pxd

@@ -0,0 +1,29 @@
+#
+# License: See LICENSE.md file
+# GitHub: https://github.com/Baekalfen/PyBoy
+#
+
+from libc.stdint cimport int64_t, uint8_t, uint16_t, uint32_t, uint64_t
+
+from pyboy.utils cimport IntIOInterface
+
+import cython
+
+from pyboy.logging.logging cimport Logger
+
+cdef uint64_t MAX_CYCLES, CYCLES_8192HZ
+cdef Logger logger
+
+cdef class Serial:
+    cdef uint64_t SB, SC
+    cdef int64_t _cycles_to_interrupt
+    cdef uint64_t last_cycles, clock, clock_target
+    cdef bint transfer_enabled, double_speed, internal_clock
+
+    cdef bint tick(self, uint64_t) noexcept nogil
+
+    cdef void set_SB(self, uint8_t) noexcept nogil
+    cdef void set_SC(self, uint8_t) noexcept nogil
+
+    cdef int save_state(self, IntIOInterface) except -1
+    cdef int load_state(self, IntIOInterface, int) except -1

pyboy-2.6.0/pyboy/core/serial.py

@@ -0,0 +1,78 @@
+#
+# License: See LICENSE.md file
+# GitHub: https://github.com/Baekalfen/PyBoy
+#
+
+from pyboy.utils import MAX_CYCLES
+
+CYCLES_8192HZ = 128
+
+
+class Serial:
+    def __init__(self):
+        self.SB = 0xFF  # Always 0xFF for a disconnected link cable
+        self.SC = 0
+        self.transfer_enabled = 0
+        self.internal_clock = 0
+        self._cycles_to_interrupt = 0
+        self.last_cycles = 0
+        self.clock = 0
+        self.clock_target = MAX_CYCLES
+
+    def set_SB(self, value):
+        # Always 0xFF when cable is disconnected. Connecting is not implemented yet.
+        self.SB = 0xFF
+
+    def set_SC(self, value):  # cgb, double_speed
+        self.SC = value
+        self.transfer_enabled = self.SC & 0x80
+        # TODO:
+        # if cgb and (self.SC & 0b10): # High speed transfer
+        #     self.double_speed = ...
+        self.internal_clock = self.SC & 1  # 0: external, 1: internal
+        if self.internal_clock:
+            self.clock_target = self.clock + 8 * CYCLES_8192HZ
+        else:
+            # Will never complete, as there is no connection
+            self.transfer_enabled = 0  # Technically it is enabled, but no reason to track it.
+            self.clock_target = MAX_CYCLES
+        self._cycles_to_interrupt = self.clock_target - self.clock
+
+    def tick(self, _cycles):
+        cycles = _cycles - self.last_cycles
+        if cycles == 0:
+            return False
+        self.last_cycles = _cycles
+
+        self.clock += cycles
+
+        interrupt = False
+        if self.transfer_enabled and self.clock >= self.clock_target:
+            self.SC &= 0x80
+            self.transfer_enabled = 0
+            # self._cycles_to_interrupt = MAX_CYCLES
+            self.clock_target = MAX_CYCLES
+            interrupt = True
+
+        self._cycles_to_interrupt = self.clock_target - self.clock
+        return interrupt
+
+    def save_state(self, f):
+        f.write(self.SB)
+        f.write(self.SC)
+        f.write(self.transfer_enabled)
+        f.write(self.internal_clock)
+        f.write_64bit(self.last_cycles)
+        f.write_64bit(self._cycles_to_interrupt)
+        f.write_64bit(self.clock)
+        f.write_64bit(self.clock_target)
+
+    def load_state(self, f, state_version):
+        self.SB = f.read()
+        self.SC = f.read()
+        self.transfer_enabled = f.read()
+        self.internal_clock = f.read()
+        self.last_cycles = f.read_64bit()
+        self._cycles_to_interrupt = f.read_64bit()
+        self.clock = f.read_64bit()
+        self.clock_target = f.read_64bit()

{pyboy-2.5.3 → pyboy-2.6.0}/pyboy/core/sound.pxd

@@ -10,7 +10,7 @@ from pyboy.logging.logging cimport Logger
 from pyboy.utils cimport IntIOInterface, double_to_uint64_ceil
 
 cdef int FRAME_CYCLES
-
+cdef uint64_t MAX_CYCLES
 
 cdef Logger logger
 
@@ -59,7 +59,7 @@ cdef class Sound:
     cdef uint8_t get(self, uint8_t) noexcept nogil
     cdef void set(self, uint8_t, uint8_t) noexcept nogil
 
-    @cython.locals(cycles=uint64_t)
+    @cython.locals(cycles=uint64_t, _cycles=uint64_t)
     cdef void tick(self, uint64_t) noexcept nogil
     cdef void sample(self) noexcept nogil
     cdef uint8_t pcm12(self) noexcept nogil