pyboy 2.3.0__tar.gz → 2.4.1__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pyboy
-Version: 2.3.0
+Version: 2.4.1
 Summary: Game Boy emulator written in Python
 Author-email: Mads Ynddal <mads@ynddal.dk>
 License: GNU Lesser General Public License
@@ -354,14 +354,14 @@ for _ in range(target):
 
 ```python
 for _ in range(target//15):
-    pyboy.tick(15, True)
+    pyboy.tick(15)
 
 ```
 </td>
 <td >
 
 ```python
-pyboy.tick(target)
+pyboy.tick(target, False)
 
 ```
 </td>

{pyboy-2.3.0 → pyboy-2.4.1}/README.md

@@ -163,14 +163,14 @@ for _ in range(target):
 
 ```python
 for _ in range(target//15):
-    pyboy.tick(15, True)
+    pyboy.tick(15)
 
 ```
 </td>
 <td >
 
 ```python
-pyboy.tick(target)
+pyboy.tick(target, False)
 
 ```
 </td>

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

@@ -169,7 +169,7 @@ See "pyboy --help" for how to enable rewind and other awesome features!
             pyboy.load_state(f)
 
     render = not argv.no_renderer
-    while pyboy._tick(render):
+    while pyboy.tick():
         pass
 
     pyboy.stop()

{pyboy-2.3.0 → pyboy-2.4.1}/pyboy/api/gameshark.py

@@ -7,6 +7,10 @@ from pyboy.logging import get_logger
 
 logger = get_logger(__name__)
 
+__pdoc__ = {
+    "GameShark.tick": False,
+}
+
 
 class GameShark:
     def __init__(self, memory):

{pyboy-2.3.0 → pyboy-2.4.1}/pyboy/core/cpu.pxd

@@ -4,7 +4,7 @@
 #
 
 
-from libc.stdint cimport int16_t, uint8_t, uint16_t, uint32_t, uint64_t
+from libc.stdint cimport int16_t, int64_t, uint8_t, uint16_t, int64_t
 
 cimport pyboy.core.mb
 from pyboy.utils cimport IntIOInterface
@@ -26,17 +26,20 @@ cdef uint8_t INTR_VBLANK, INTR_LCDC, INTR_TIMER, INTR_SERIAL, INTR_HIGHTOLOW
 
 cdef class CPU:
     cdef bint is_stuck
-    cdef bint interrupt_master_enable, interrupt_queued, halted, stopped
+    cdef bint interrupt_master_enable, interrupt_queued, halted, stopped, bail
 
     cdef uint8_t interrupts_flag, interrupts_enabled, interrupts_flag_register, interrupts_enabled_register
 
+    cdef int64_t cycles
+
     cdef inline int check_interrupts(self) noexcept nogil
     cdef void set_interruptflag(self, int) noexcept nogil
     cdef bint handle_interrupt(self, uint8_t, uint16_t) noexcept nogil
 
     @cython.locals(opcode=uint16_t)
     cdef inline uint8_t fetch_and_execute(self) noexcept nogil
-    cdef int tick(self) noexcept nogil
+    @cython.locals(_cycles0=int64_t)
+    cdef int tick(self, int64_t) noexcept nogil
     cdef void save_state(self, IntIOInterface) noexcept
     cdef void load_state(self, IntIOInterface, int) noexcept
 

{pyboy-2.3.0 → pyboy-2.4.1}/pyboy/core/cpu.py

@@ -39,6 +39,7 @@ class CPU:
         self.halted = False
         self.stopped = False
         self.is_stuck = False
+        self.cycles = 0
 
     def save_state(self, f):
         for n in [self.A, self.F, self.B, self.C, self.D, self.E]:
@@ -53,6 +54,7 @@ class CPU:
         f.write(self.interrupts_enabled_register)
         f.write(self.interrupt_queued)
         f.write(self.interrupts_flag_register)
+        f.write_64bit(self.cycles)
 
     def load_state(self, f, state_version):
         self.A, self.F, self.B, self.C, self.D, self.E = [f.read() for _ in range(6)]
@@ -69,6 +71,8 @@ class CPU:
         if state_version >= 8:
             self.interrupt_queued = f.read()
             self.interrupts_flag_register = f.read()
+        if state_version >= 12:
+            self.cycles = f.read_64bit()
         logger.debug("State loaded: %s", self.dump_state(""))
 
     def dump_state(self, sym_label):
@@ -93,8 +97,8 @@ class CPU:
             f"Interrupts - IME: {self.mb.cpu.interrupt_master_enable}, "
             f"IE: {self.mb.cpu.interrupts_enabled_register:08b}, "
             f"IF: {self.mb.cpu.interrupts_flag_register:08b}\n"
-            f"LCD Intr.: {self.mb.lcd.cycles_to_interrupt()}, LY:{self.mb.lcd.LY}, LYC:{self.mb.lcd.LYC}\n"
-            f"Timer Intr.: {self.mb.timer.cycles_to_interrupt()}\n"
+            f"LCD Intr.: {self.mb.lcd._cycles_to_interrupt}, LY:{self.mb.lcd.LY}, LYC:{self.mb.lcd.LYC}\n"
+            f"Timer Intr.: {self.mb.timer._cycles_to_interrupt}\n"
             f"halted:{self.halted}, "
             f"interrupt_queued:{self.interrupt_queued}, "
             f"stopped:{self.stopped}\n"
@@ -103,11 +107,13 @@ class CPU:
     def set_interruptflag(self, flag):
         self.interrupts_flag_register |= flag
 
-    def tick(self):
+    def tick(self, cycles_target):
+        _cycles0 = self.cycles
+        _target = _cycles0 + cycles_target
+
         if self.check_interrupts():
             self.halted = False
-            # TODO: We return with the cycles it took to handle the interrupt
-            return 0
+            # TODO: Cycles it took to handle the interrupt
 
         if self.halted and self.interrupt_queued:
             # GBCPUman.pdf page 20
@@ -117,62 +123,55 @@ class CPU:
             self.PC += 1
             self.PC &= 0xFFFF
         elif self.halted:
-            return 4 # TODO: Number of cycles for a HALT in effect?
-
-        old_pc = self.PC # If the PC doesn't change, we're likely stuck
-        old_sp = self.SP # Sometimes a RET can go to the same PC, so we check the SP too.
-        cycles = self.fetch_and_execute()
-        if not self.halted and old_pc == self.PC and old_sp == self.SP and not self.is_stuck and not self.mb.breakpoint_singlestep:
-            logger.debug("CPU is stuck: %s", self.dump_state(""))
-            self.is_stuck = True
+            self.cycles += cycles_target # TODO: Number of cycles for a HALT in effect?
         self.interrupt_queued = False
-        return cycles
+
+        self.bail = False
+        while self.cycles < _target:
+            # TODO: cpu-stuck check for blargg tests?
+            self.fetch_and_execute()
+            if self.bail: # Possible cycles-target changes
+                break
 
     def check_interrupts(self):
         if self.interrupt_queued:
             # Interrupt already queued. This happens only when using a debugger.
             return False
 
-        if (self.interrupts_flag_register & 0b11111) & (self.interrupts_enabled_register & 0b11111):
-            if self.handle_interrupt(INTR_VBLANK, 0x0040):
-                self.interrupt_queued = True
-            elif self.handle_interrupt(INTR_LCDC, 0x0048):
-                self.interrupt_queued = True
-            elif self.handle_interrupt(INTR_TIMER, 0x0050):
-                self.interrupt_queued = True
-            elif self.handle_interrupt(INTR_SERIAL, 0x0058):
-                self.interrupt_queued = True
-            elif self.handle_interrupt(INTR_HIGHTOLOW, 0x0060):
-                self.interrupt_queued = True
-            else:
-                logger.error("No interrupt triggered, but it should!")
-                self.interrupt_queued = False
-            return True
-        else:
-            self.interrupt_queued = False
-        return False
-
-    def handle_interrupt(self, flag, addr):
-        if (self.interrupts_enabled_register & flag) and (self.interrupts_flag_register & flag):
+        raised_and_enabled = (self.interrupts_flag_register & 0b11111) & (self.interrupts_enabled_register & 0b11111)
+        if raised_and_enabled:
             # Clear interrupt flag
             if self.halted:
                 self.PC += 1 # Escape HALT on return
                 self.PC &= 0xFFFF
 
-            # Handle interrupt vectors
             if self.interrupt_master_enable:
-                self.interrupts_flag_register ^= flag # Remove flag
-                self.mb.setitem((self.SP - 1) & 0xFFFF, self.PC >> 8) # High
-                self.mb.setitem((self.SP - 2) & 0xFFFF, self.PC & 0xFF) # Low
-                self.SP -= 2
-                self.SP &= 0xFFFF
-
-                self.PC = addr
-                self.interrupt_master_enable = False
-
+                if raised_and_enabled & INTR_VBLANK:
+                    self.handle_interrupt(INTR_VBLANK, 0x0040)
+                elif raised_and_enabled & INTR_LCDC:
+                    self.handle_interrupt(INTR_LCDC, 0x0048)
+                elif raised_and_enabled & INTR_TIMER:
+                    self.handle_interrupt(INTR_TIMER, 0x0050)
+                elif raised_and_enabled & INTR_SERIAL:
+                    self.handle_interrupt(INTR_SERIAL, 0x0058)
+                elif raised_and_enabled & INTR_HIGHTOLOW:
+                    self.handle_interrupt(INTR_HIGHTOLOW, 0x0060)
+            self.interrupt_queued = True
             return True
+        else:
+            self.interrupt_queued = False
         return False
 
+    def handle_interrupt(self, flag, addr):
+        self.interrupts_flag_register ^= flag # Remove flag
+        self.mb.setitem((self.SP - 1) & 0xFFFF, self.PC >> 8) # High
+        self.mb.setitem((self.SP - 2) & 0xFFFF, self.PC & 0xFF) # Low
+        self.SP -= 2
+        self.SP &= 0xFFFF
+
+        self.PC = addr
+        self.interrupt_master_enable = False
+
     def fetch_and_execute(self):
         opcode = self.mb.getitem(self.PC)
         if opcode == 0xCB: # Extension code

{pyboy-2.3.0 → pyboy-2.4.1}/pyboy/core/lcd.pxd

@@ -48,10 +48,11 @@ cdef class LCD:
     cdef PaletteRegister OBP1
     cdef Renderer renderer
     cdef uint8_t[144][5] _scanlineparameters
+    cdef uint64_t last_cycles
+    cdef int64_t _cycles_to_interrupt, _cycles_to_frame
 
     @cython.locals(interrupt_flag=uint8_t,bx=int,by=int,wx=int,wy=int)
     cdef uint8_t tick(self, int) noexcept nogil
-    cdef int64_t cycles_to_interrupt(self) noexcept nogil
 
     cdef void set_lcdc(self, uint8_t) noexcept nogil
     cdef uint8_t get_lcdc(self) noexcept nogil

{pyboy-2.3.0 → pyboy-2.4.1}/pyboy/core/lcd.py

@@ -58,6 +58,9 @@ class LCD:
         self.double_speed = False
         self.cgb = cgb
         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
 
         if self.cgb:
             # Setting for both modes, even though CGB is ignoring them. BGP[0] used in scanline_blank.
@@ -103,9 +106,6 @@ class LCD:
     def set_stat(self, value):
         self._STAT.set(value)
 
-    def cycles_to_interrupt(self):
-        return self.clock_target - self.clock
-
     def cycles_to_mode0(self):
         multiplier = 2 if self.double_speed else 1
         mode2 = 80 * multiplier
@@ -130,7 +130,12 @@ class LCD:
         #     logger.critical("Unsupported STAT mode: %d", mode)
         #     return 0
 
-    def tick(self, cycles):
+    def tick(self, _cycles):
+        cycles = _cycles - self.last_cycles
+        if cycles == 0:
+            return False
+        self.last_cycles = _cycles
+
         interrupt_flag = 0
         self.clock += cycles
 
@@ -205,6 +210,8 @@ class LCD:
                 # Renderer
                 self.renderer.blank_screen(self)
 
+        self._cycles_to_interrupt = self.clock_target - self.clock
+        self._cycles_to_frame = self.clock - FRAME_CYCLES
         return interrupt_flag
 
     def save_state(self, f):
@@ -239,6 +246,7 @@ class LCD:
         # CGB
         f.write(self.cgb)
         f.write(self.double_speed)
+        f.write_64bit(self.last_cycles)
         f.write_64bit(self.clock)
         f.write_64bit(self.clock_target)
         f.write(self.next_stat_mode)
@@ -293,8 +301,11 @@ class LCD:
             self.cgb = _cgb
             self.double_speed = f.read()
 
+            if state_version >= 12:
+                self.last_cycles = f.read_64bit()
             self.clock = f.read_64bit()
             self.clock_target = f.read_64bit()
+            self._cycles_to_frame = self.clock - FRAME_CYCLES
             self.next_stat_mode = f.read()
 
             if self.cgb:

{pyboy-2.3.0 → pyboy-2.4.1}/pyboy/core/mb.pxd

@@ -21,6 +21,7 @@ from pyboy.utils cimport IntIOInterface, WindowEvent
 
 cdef Logger logger
 
+cdef int64_t MAX_CYCLES
 cdef uint16_t STAT, LY, LYC
 cdef short VBLANK, LCDC, TIMER, SERIAL, HIGHTOLOW
 cdef int INTR_VBLANK, INTR_LCDC, INTR_TIMER, INTR_SERIAL, INTR_HIGHTOLOW
@@ -59,7 +60,7 @@ cdef class Motherboard:
 
     cdef void buttonevent(self, WindowEvent) noexcept
     cdef void stop(self, bint) noexcept
-    @cython.locals(cycles=int64_t, mode0_cycles=int64_t, breakpoint_index=int64_t)
+    @cython.locals(cycles=int64_t, cycles_target=int64_t, mode0_cycles=int64_t, breakpoint_index=int64_t)
     cdef bint tick(self) noexcept nogil
 
     cdef void switch_speed(self) noexcept nogil

{pyboy-2.3.0 → pyboy-2.4.1}/pyboy/core/mb.py

@@ -15,6 +15,8 @@ import pyboy
 
 logger = pyboy.logging.get_logger(__name__)
 
+MAX_CYCLES = 1 << 16
+
 
 class Motherboard:
     def __init__(
@@ -276,11 +278,8 @@ class Motherboard:
     def tick(self):
         while self.processing_frame():
             if self.cgb and self.hdma.transfer_active and self.lcd._STAT._mode & 0b11 == 0:
-                cycles = self.hdma.tick(self)
+                self.cpu.cycles = self.cpu.cycles + self.hdma.tick(self)
             else:
-                cycles = self.cpu.tick()
-
-            if self.cpu.halted:
                 # Fast-forward to next interrupt:
                 # As we are halted, we are guaranteed, that our state
                 # cannot be altered by other factors than time.
@@ -288,35 +287,32 @@ class Motherboard:
                 # it gets triggered mid-frame or by next frame
                 # Serial is not implemented, so this isn't a concern
 
-                # Help Cython with types
-                mode0_cycles = 1 << 32
+                mode0_cycles = MAX_CYCLES
                 if self.cgb and self.hdma.transfer_active:
                     mode0_cycles = self.lcd.cycles_to_mode0()
 
-                cycles = max(
-                    0,
+                cycles_target = max(
+                    4,
                     min(
-                        self.lcd.cycles_to_interrupt(),
-                        self.timer.cycles_to_interrupt(),
+                        self.timer._cycles_to_interrupt,
+                        self.lcd._cycles_to_interrupt, # TODO: Be more agreesive. Only if actual interrupt enabled.
+                        self.lcd._cycles_to_frame,
+                        self.sound._cycles_to_interrupt, # TODO: Not implemented
                         # self.serial.cycles_to_interrupt(),
                         mode0_cycles
                     )
                 )
+                self.cpu.tick(cycles_target)
 
             #TODO: Support General Purpose DMA
             # https://gbdev.io/pandocs/CGB_Registers.html#bit-7--0---general-purpose-dma
 
-            # TODO: Unify interface
-            sclock = self.sound.clock
-            if self.cgb and self.double_speed:
-                self.sound.clock = sclock + cycles//2
-            else:
-                self.sound.clock = sclock + cycles
+            self.sound.tick(self.cpu.cycles, self.double_speed)
 
-            if self.timer.tick(cycles):
+            if self.timer.tick(self.cpu.cycles):
                 self.cpu.set_interruptflag(INTR_TIMER)
 
-            lcd_interrupt = self.lcd.tick(cycles)
+            lcd_interrupt = self.lcd.tick(self.cpu.cycles)
             if lcd_interrupt:
                 self.cpu.set_interruptflag(lcd_interrupt)
 
@@ -350,8 +346,7 @@ class Motherboard:
             bank_offset = 0
             if self.cgb and 0xD000 <= i:
                 # Find which bank to read from at FF70
-                bank = self.getitem(0xFF70)
-                bank &= 0b111
+                bank = self.ram.non_io_internal_ram1[0xFF70 - 0xFF4C] & 0b111
                 if bank == 0x0:
                     bank = 0x01
                 bank_offset = (bank-1) * 0x1000
@@ -364,6 +359,10 @@ 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
+            # NOTE: A bit ad-hoc, but interrupts can occur right between writes
+            if self.timer.tick(self.cpu.cycles):
+                self.cpu.set_interruptflag(INTR_TIMER)
+
             if i == 0xFF04:
                 return self.timer.DIV
             elif i == 0xFF05:
@@ -375,6 +374,7 @@ class Motherboard:
             elif i == 0xFF0F:
                 return self.cpu.interrupts_flag_register
             elif 0xFF10 <= i < 0xFF40:
+                self.sound.tick(self.cpu.cycles, self.double_speed)
                 return self.sound.get(i - 0xFF10)
             elif i == 0xFF40:
                 return self.lcd.get_lcdc()
@@ -442,9 +442,11 @@ class Motherboard:
         if 0x0000 <= i < 0x4000: # 16kB ROM bank #0
             # Doesn't change the data. This is for MBC commands
             self.cartridge.setitem(i, value)
+            self.cpu.bail = True
         elif 0x4000 <= i < 0x8000: # 16kB switchable ROM bank
             # Doesn't change the data. This is for MBC commands
             self.cartridge.setitem(i, value)
+            self.cpu.bail = True
         elif 0x8000 <= i < 0xA000: # 8kB Video RAM
             if not self.cgb or self.lcd.vbk.active_bank == 0:
                 self.lcd.VRAM0[i - 0x8000] = value
@@ -475,6 +477,10 @@ class Motherboard:
         elif 0xFEA0 <= i < 0xFF00: # Empty but unusable for I/O
             self.ram.non_io_internal_ram0[i - 0xFEA0] = value
         elif 0xFF00 <= i < 0xFF4C: # I/O ports
+            # NOTE: A bit ad-hoc, but interrupts can occur right between writes
+            if self.timer.tick(self.cpu.cycles):
+                self.cpu.set_interruptflag(INTR_TIMER)
+
             if i == 0xFF00:
                 self.ram.io_ports[i - 0xFF00] = self.interaction.pull(value)
             elif i == 0xFF01:
@@ -493,6 +499,7 @@ class Motherboard:
             elif i == 0xFF0F:
                 self.cpu.interrupts_flag_register = value
             elif 0xFF10 <= i < 0xFF40:
+                self.sound.tick(self.cpu.cycles, self.double_speed)
                 self.sound.set(i - 0xFF10, value)
             elif i == 0xFF40:
                 self.lcd.set_lcdc(value)
@@ -526,13 +533,16 @@ class Motherboard:
                 self.lcd.WX = value
             else:
                 self.ram.io_ports[i - 0xFF00] = value
+            self.cpu.bail = True
         elif 0xFF4C <= i < 0xFF80: # Empty but unusable for I/O
             if self.bootrom_enabled and i == 0xFF50 and (value == 0x1 or value == 0x11):
                 logger.debug("Bootrom disabled!")
                 self.bootrom_enabled = False
+                self.cpu.bail = True
             # CGB registers
             elif self.cgb and i == 0xFF4D:
                 self.key1 = value
+                self.cpu.bail = True
             elif self.cgb and i == 0xFF4F:
                 self.lcd.vbk.set(value)
             elif self.cgb and i == 0xFF51:
@@ -545,6 +555,7 @@ class Motherboard:
                 self.hdma.hdma4 = value # & 0xF0
             elif self.cgb and i == 0xFF55:
                 self.hdma.set_hdma5(value, self)
+                self.cpu.bail = True
             elif self.cgb and i == 0xFF68:
                 self.lcd.bcps.set(value)
             elif self.cgb and i == 0xFF69:
@@ -563,6 +574,7 @@ class Motherboard:
             self.ram.internal_ram1[i - 0xFF80] = value
         elif i == 0xFFFF: # Interrupt Enable Register
             self.cpu.interrupts_enabled_register = value
+            self.cpu.bail = True
         # else:
         #     logger.critical("Memory access violation. Tried to write: 0x%0.2x to 0x%0.4x", value, i)