rubyboy 1.5.1 → 1.6.0

data/lib/rubyboy/emulator_wasm.rb

@@ -19,7 +19,7 @@ module Rubyboy
 
     def initialize(rom_data)
       rom = Rom.new(rom_data)
-      ram = Ram.new
+      ram = Ram.new(rom)
       mbc = Cartridge::Factory.create(rom, ram)
       interrupt = Interrupt.new
       @ppu = Ppu.new(interrupt)

data/lib/rubyboy/hardware_state.rb

@@ -0,0 +1,449 @@
+# frozen_string_literal: true
+
+module Rubyboy
+  class Registers
+    def hardware_state
+      { af:, bc:, de:, hl: }
+    end
+
+    def restore_hardware_state(state)
+      self.af = state.fetch(:af)
+      self.bc = state.fetch(:bc)
+      self.de = state.fetch(:de)
+      self.hl = state.fetch(:hl)
+    end
+  end
+
+  class Cpu
+    def hardware_state
+      {
+        registers: @registers.hardware_state,
+        pc: @pc,
+        sp: @sp,
+        ime: @ime,
+        ime_delay: @ime_delay,
+        halted: @halted
+      }
+    end
+
+    def restore_hardware_state(state)
+      @registers.restore_hardware_state(state.fetch(:registers))
+      @pc = state.fetch(:pc)
+      @sp = state.fetch(:sp)
+      @ime = state.fetch(:ime)
+      @ime_delay = state.fetch(:ime_delay)
+      @halted = state.fetch(:halted)
+    end
+  end
+
+  class Timer
+    def hardware_state
+      {
+        div: @div,
+        tima: @tima,
+        tma: @tma,
+        tac: @tac,
+        divider_phase: @cycles
+      }
+    end
+
+    def restore_hardware_state(state)
+      @div = state.fetch(:div)
+      @tima = state.fetch(:tima)
+      @tma = state.fetch(:tma)
+      @tac = state.fetch(:tac)
+      @cycles = state.fetch(:divider_phase)
+    end
+  end
+
+  class Interrupt
+    def hardware_state
+      { ie: @ie, if: @if }
+    end
+
+    def restore_hardware_state(state)
+      @ie = state.fetch(:ie)
+      @if = state.fetch(:if)
+    end
+  end
+
+  class Joypad
+    def hardware_state
+      {
+        p1_select: @mode,
+        action_buttons: @action,
+        direction_buttons: @direction
+      }
+    end
+
+    def restore_hardware_state(state)
+      @mode = state.fetch(:p1_select)
+      @action = state.fetch(:action_buttons)
+      @direction = state.fetch(:direction_buttons)
+    end
+  end
+
+  class Ram
+    def hardware_state
+      {
+        eram: @eram.dup,
+        wram1: @wram1.dup,
+        wram2: @wram2.dup,
+        hram: @hram.dup
+      }
+    end
+
+    def restore_hardware_state(state)
+      @eram = state.fetch(:eram).dup
+      @wram1 = state.fetch(:wram1).dup
+      @wram2 = state.fetch(:wram2).dup
+      @hram = state.fetch(:hram).dup
+    end
+  end
+
+  class Ppu
+    def hardware_state
+      {
+        registers: {
+          lcdc: @lcdc,
+          stat: @stat,
+          scy: @scy,
+          scx: @scx,
+          ly: @ly,
+          lyc: @lyc,
+          obp0: @obp0,
+          obp1: @obp1,
+          wy: @wy,
+          wx: @wx,
+          bgp: @bgp
+        },
+        vram: @vram.dup,
+        oam: @oam.dup,
+        mode: @mode,
+        dot_phase: @cycles,
+        window_line: @wly
+      }
+    end
+
+    def restore_hardware_state(state)
+      registers = state.fetch(:registers)
+      @lcdc = registers.fetch(:lcdc)
+      @stat = registers.fetch(:stat)
+      @scy = registers.fetch(:scy)
+      @scx = registers.fetch(:scx)
+      @ly = registers.fetch(:ly)
+      @lyc = registers.fetch(:lyc)
+      @obp0 = registers.fetch(:obp0)
+      @obp1 = registers.fetch(:obp1)
+      @wy = registers.fetch(:wy)
+      @wx = registers.fetch(:wx)
+      @bgp = registers.fetch(:bgp)
+      @vram = state.fetch(:vram).dup
+      @oam = state.fetch(:oam).dup
+      @mode = state.fetch(:mode)
+      @cycles = state.fetch(:dot_phase)
+      @wly = state.fetch(:window_line)
+      rebuild_render_caches
+    end
+
+    private
+
+    def rebuild_render_caches
+      @buffer = Array.new(144 * 160, 0xffffffff)
+      @bg_pixels = Array.new(LCD_WIDTH, 0x00)
+      @tile_cache = Array.new(384) { Array.new(64, 0) }
+      @tile_map_cache = Array.new(2048, 0)
+      @bgp_cache = Array.new(4, 0xffffffff)
+      @obp0_cache = Array.new(4, 0xffffffff)
+      @obp1_cache = Array.new(4, 0xffffffff)
+      @sprite_cache = Array.new(40) { { y: 0xff, x: 0xff, tile_index: 0, flags: 0 } }
+
+      (0...0x1800).step(2) { |addr| update_tile_cache(addr) }
+      refresh_tile_map_cache
+      refresh_palette_cache(@bgp_cache, @bgp)
+      refresh_palette_cache(@obp0_cache, @obp0)
+      refresh_palette_cache(@obp1_cache, @obp1)
+      40.times do |sprite_index|
+        base = sprite_index << 2
+        @sprite_cache[sprite_index][:y] = (@oam[base] - 16) & 0xff
+        @sprite_cache[sprite_index][:x] = (@oam[base + 1] - 8) & 0xff
+        @sprite_cache[sprite_index][:tile_index] = @oam[base + 2]
+        @sprite_cache[sprite_index][:flags] = @oam[base + 3]
+      end
+    end
+  end
+
+  module ApuChannels
+    class Channel1
+      def hardware_state
+        {
+          cycles: @cycles,
+          frequency: @frequency,
+          frequency_timer: @frequency_timer,
+          wave_duty_position: @wave_duty_position,
+          enabled: @enabled,
+          dac_enabled: @dac_enabled,
+          length_enabled: @length_enabled,
+          is_upwards: @is_upwards,
+          is_decrementing: @is_decrementing,
+          sweep_enabled: @sweep_enabled,
+          sweep_period: @sweep_period,
+          sweep_shift: @sweep_shift,
+          period: @period,
+          period_timer: @period_timer,
+          current_volume: @current_volume,
+          initial_volume: @initial_volume,
+          shadow_frequency: @shadow_frequency,
+          sweep_timer: @sweep_timer,
+          length_timer: @length_timer,
+          wave_duty_pattern: @wave_duty_pattern
+        }
+      end
+
+      def restore_hardware_state(state)
+        @cycles = state.fetch(:cycles)
+        @frequency = state.fetch(:frequency)
+        @frequency_timer = state.fetch(:frequency_timer)
+        @wave_duty_position = state.fetch(:wave_duty_position)
+        @enabled = state.fetch(:enabled)
+        @dac_enabled = state.fetch(:dac_enabled)
+        @length_enabled = state.fetch(:length_enabled)
+        @is_upwards = state.fetch(:is_upwards)
+        @is_decrementing = state.fetch(:is_decrementing)
+        @sweep_enabled = state.fetch(:sweep_enabled)
+        @sweep_period = state.fetch(:sweep_period)
+        @sweep_shift = state.fetch(:sweep_shift)
+        @period = state.fetch(:period)
+        @period_timer = state.fetch(:period_timer)
+        @current_volume = state.fetch(:current_volume)
+        @initial_volume = state.fetch(:initial_volume)
+        @shadow_frequency = state.fetch(:shadow_frequency)
+        @sweep_timer = state.fetch(:sweep_timer)
+        @length_timer = state.fetch(:length_timer)
+        @wave_duty_pattern = state.fetch(:wave_duty_pattern)
+      end
+    end
+
+    class Channel2
+      def hardware_state
+        {
+          cycles: @cycles,
+          frequency: @frequency,
+          frequency_timer: @frequency_timer,
+          wave_duty_position: @wave_duty_position,
+          enabled: @enabled,
+          dac_enabled: @dac_enabled,
+          length_enabled: @length_enabled,
+          is_upwards: @is_upwards,
+          is_decrementing: @is_decrementing,
+          period: @period,
+          period_timer: @period_timer,
+          current_volume: @current_volume,
+          initial_volume: @initial_volume,
+          shadow_frequency: @shadow_frequency,
+          length_timer: @length_timer,
+          wave_duty_pattern: @wave_duty_pattern
+        }
+      end
+
+      def restore_hardware_state(state)
+        @cycles = state.fetch(:cycles)
+        @frequency = state.fetch(:frequency)
+        @frequency_timer = state.fetch(:frequency_timer)
+        @wave_duty_position = state.fetch(:wave_duty_position)
+        @enabled = state.fetch(:enabled)
+        @dac_enabled = state.fetch(:dac_enabled)
+        @length_enabled = state.fetch(:length_enabled)
+        @is_upwards = state.fetch(:is_upwards)
+        @is_decrementing = state.fetch(:is_decrementing)
+        @period = state.fetch(:period)
+        @period_timer = state.fetch(:period_timer)
+        @current_volume = state.fetch(:current_volume)
+        @initial_volume = state.fetch(:initial_volume)
+        @shadow_frequency = state.fetch(:shadow_frequency)
+        @length_timer = state.fetch(:length_timer)
+        @wave_duty_pattern = state.fetch(:wave_duty_pattern)
+      end
+    end
+
+    class Channel3
+      def hardware_state
+        {
+          cycles: @cycles,
+          frequency: @frequency,
+          frequency_timer: @frequency_timer,
+          wave_duty_position: @wave_duty_position,
+          enabled: @enabled,
+          dac_enabled: @dac_enabled,
+          length_enabled: @length_enabled,
+          is_upwards: @is_upwards,
+          is_decrementing: @is_decrementing,
+          sweep_enabled: @sweep_enabled,
+          sweep_period: @sweep_period,
+          sweep_shift: @sweep_shift,
+          period: @period,
+          period_timer: @period_timer,
+          current_volume: @current_volume,
+          initial_volume: @initial_volume,
+          shadow_frequency: @shadow_frequency,
+          sweep_timer: @sweep_timer,
+          length_timer: @length_timer,
+          wave_duty_pattern: @wave_duty_pattern,
+          output_level: @output_level,
+          volume_shift: @volume_shift,
+          wave_ram: @wave_ram.dup
+        }
+      end
+
+      def restore_hardware_state(state)
+        @cycles = state.fetch(:cycles)
+        @frequency = state.fetch(:frequency)
+        @frequency_timer = state.fetch(:frequency_timer)
+        @wave_duty_position = state.fetch(:wave_duty_position)
+        @enabled = state.fetch(:enabled)
+        @dac_enabled = state.fetch(:dac_enabled)
+        @length_enabled = state.fetch(:length_enabled)
+        @is_upwards = state.fetch(:is_upwards)
+        @is_decrementing = state.fetch(:is_decrementing)
+        @sweep_enabled = state.fetch(:sweep_enabled)
+        @sweep_period = state.fetch(:sweep_period)
+        @sweep_shift = state.fetch(:sweep_shift)
+        @period = state.fetch(:period)
+        @period_timer = state.fetch(:period_timer)
+        @current_volume = state.fetch(:current_volume)
+        @initial_volume = state.fetch(:initial_volume)
+        @shadow_frequency = state.fetch(:shadow_frequency)
+        @sweep_timer = state.fetch(:sweep_timer)
+        @length_timer = state.fetch(:length_timer)
+        @wave_duty_pattern = state.fetch(:wave_duty_pattern)
+        @output_level = state.fetch(:output_level)
+        @volume_shift = state.fetch(:volume_shift)
+        @wave_ram = state.fetch(:wave_ram).dup
+      end
+    end
+
+    class Channel4
+      def hardware_state
+        {
+          cycles: @cycles,
+          frequency: @frequency,
+          frequency_timer: @frequency_timer,
+          wave_duty_position: @wave_duty_position,
+          enabled: @enabled,
+          dac_enabled: @dac_enabled,
+          length_enabled: @length_enabled,
+          is_upwards: @is_upwards,
+          is_decrementing: @is_decrementing,
+          sweep_enabled: @sweep_enabled,
+          sweep_period: @sweep_period,
+          sweep_shift: @sweep_shift,
+          period: @period,
+          period_timer: @period_timer,
+          current_volume: @current_volume,
+          initial_volume: @initial_volume,
+          shadow_frequency: @shadow_frequency,
+          sweep_timer: @sweep_timer,
+          length_timer: @length_timer,
+          wave_duty_pattern: @wave_duty_pattern,
+          lfsr: @lfsr,
+          width_mode: @width_mode,
+          shift_amount: @shift_amount,
+          divisor_code: @divisor_code
+        }
+      end
+
+      def restore_hardware_state(state)
+        @cycles = state.fetch(:cycles)
+        @frequency = state.fetch(:frequency)
+        @frequency_timer = state.fetch(:frequency_timer)
+        @wave_duty_position = state.fetch(:wave_duty_position)
+        @enabled = state.fetch(:enabled)
+        @dac_enabled = state.fetch(:dac_enabled)
+        @length_enabled = state.fetch(:length_enabled)
+        @is_upwards = state.fetch(:is_upwards)
+        @is_decrementing = state.fetch(:is_decrementing)
+        @sweep_enabled = state.fetch(:sweep_enabled)
+        @sweep_period = state.fetch(:sweep_period)
+        @sweep_shift = state.fetch(:sweep_shift)
+        @period = state.fetch(:period)
+        @period_timer = state.fetch(:period_timer)
+        @current_volume = state.fetch(:current_volume)
+        @initial_volume = state.fetch(:initial_volume)
+        @shadow_frequency = state.fetch(:shadow_frequency)
+        @sweep_timer = state.fetch(:sweep_timer)
+        @length_timer = state.fetch(:length_timer)
+        @wave_duty_pattern = state.fetch(:wave_duty_pattern)
+        @lfsr = state.fetch(:lfsr)
+        @width_mode = state.fetch(:width_mode)
+        @shift_amount = state.fetch(:shift_amount)
+        @divisor_code = state.fetch(:divisor_code)
+      end
+    end
+  end
+
+  class Apu
+    def hardware_state
+      {
+        nr50: @nr50,
+        nr51: @nr51,
+        frame_sequencer_phase: @cycles,
+        sample_phase: @sampling_accumulator,
+        frame_sequencer_step: @fs,
+        enabled: @enabled,
+        channels: {
+          channel1: @channel1.hardware_state,
+          channel2: @channel2.hardware_state,
+          channel3: @channel3.hardware_state,
+          channel4: @channel4.hardware_state
+        }
+      }
+    end
+
+    def restore_hardware_state(state)
+      @nr50 = state.fetch(:nr50)
+      @nr51 = state.fetch(:nr51)
+      @cycles = state.fetch(:frame_sequencer_phase)
+      @sampling_accumulator = state.fetch(:sample_phase)
+      @fs = state.fetch(:frame_sequencer_step)
+      @enabled = state.fetch(:enabled)
+      channels = state.fetch(:channels)
+      @channel1.restore_hardware_state(channels.fetch(:channel1))
+      @channel2.restore_hardware_state(channels.fetch(:channel2))
+      @channel3.restore_hardware_state(channels.fetch(:channel3))
+      @channel4.restore_hardware_state(channels.fetch(:channel4))
+      @samples = Array.new(1024, 0.0)
+      @sample_idx = 0
+    end
+  end
+
+  module Cartridge
+    class Mbc1
+      def hardware_state
+        {
+          type: 'mbc1',
+          rom_bank_low: @rom_bank,
+          ram_bank_high: @ram_bank,
+          ram_enabled: @ram_enable,
+          banking_mode: @ram_banking_mode
+        }
+      end
+
+      def restore_hardware_state(state)
+        @rom_bank = state.fetch(:rom_bank_low)
+        @ram_bank = state.fetch(:ram_bank_high)
+        @ram_enable = state.fetch(:ram_enabled)
+        @ram_banking_mode = state.fetch(:banking_mode)
+      end
+    end
+
+    class Nombc
+      def hardware_state
+        { type: 'nombc' }
+      end
+
+      def restore_hardware_state(_state)
+        true
+      end
+    end
+  end
+end

data/lib/rubyboy/lcd.rb

@@ -7,8 +7,9 @@ module Rubyboy
     SCREEN_WIDTH = 160
     SCREEN_HEIGHT = 144
     SCALE = 3
+    SDL_EVENT_SIZE = 56
 
-    def initialize
+    def initialize(vsync: nil)
       raise SDL.GetError() if SDL.InitSubSystem(SDL::INIT_VIDEO) != 0
 
       @buffer = FFI::MemoryPointer.new(:uint32, SCREEN_WIDTH * SCREEN_HEIGHT)
@@ -16,11 +17,19 @@ module Rubyboy
 
       raise SDL.GetError() if @window.null?
 
-      @renderer = SDL.CreateRenderer(@window, -1, 0)
+      begin
+        @renderer = SDL.CreateRenderer(@window, -1, 0)
+        raise SDL.GetError() if @renderer.null?
+        raise SDL.GetError() if !vsync.nil? && SDL.RenderSetVSync(@renderer, vsync ? 1 : 0) != 0
+      rescue StandardError
+        close_window
+        raise
+      end
+
       SDL.SetHint('SDL_HINT_RENDER_SCALE_QUALITY', '2')
       SDL.RenderSetLogicalSize(@renderer, SCREEN_WIDTH * SCALE, SCREEN_HEIGHT * SCALE)
       @texture = SDL.CreateTexture(@renderer, SDL::PIXELFORMAT_ABGR8888, 1, SCREEN_WIDTH, SCREEN_HEIGHT)
-      @event = FFI::MemoryPointer.new(:pointer)
+      @event = FFI::MemoryPointer.new(:uint8, SDL_EVENT_SIZE)
     end
 
     def draw(framebuffer)

data/lib/rubyboy/ram.rb

@@ -4,8 +4,8 @@ module Rubyboy
   class Ram
     attr_accessor :eram, :wram1, :wram2, :hram
 
-    def initialize
-      @eram = Array.new(0x2000, 0)
+    def initialize(rom)
+      @eram = Array.new(rom.ram_size_bytes, 0)
       @wram1 = Array.new(0x1000, 0)
       @wram2 = Array.new(0x1000, 0)
       @hram = Array.new(0x80, 0)

data/lib/rubyboy/rom.rb

@@ -10,11 +10,34 @@ module Rubyboy
       BB BB 67 63 6E 0E EC CC DD DC 99 9F BB B9 33 3E
     ].map(&:hex).freeze
 
+    RAM_SIZE_BYTES = {
+      0x00 => 0,
+      0x01 => 2 * 1024,
+      0x02 => 8 * 1024,
+      0x03 => 32 * 1024,
+      0x04 => 128 * 1024,
+      0x05 => 64 * 1024
+    }.freeze
+
+    BATTERY_CARTRIDGE_TYPES = [0x03, 0x06, 0x09, 0x0d, 0x0f, 0x10, 0x13, 0x1b, 0x1e, 0x22, 0xff].freeze
+
     def initialize(data)
       @data = data
       load_data
     end
 
+    def ram_size_bytes
+      RAM_SIZE_BYTES.fetch(@ram_size, 0)
+    end
+
+    def battery?
+      BATTERY_CARTRIDGE_TYPES.include?(@cartridge_type)
+    end
+
+    def global_checksum_value
+      (@global_checksum[0] << 8) | @global_checksum[1]
+    end
+
     private
 
     def load_data

data/lib/rubyboy/save_file.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Rubyboy
+  class SaveFile
+    attr_reader :path
+
+    def initialize(path)
+      @path = path
+    end
+
+    def read(expected_size)
+      return nil unless File.exist?(@path)
+
+      bytes = File.binread(@path).bytes
+      if bytes.size != expected_size
+        warn "[rubyboy] save file size mismatch (expected #{expected_size} bytes, got #{bytes.size}); ignoring #{@path}"
+        return nil
+      end
+
+      bytes
+    rescue StandardError => e
+      warn "[rubyboy] failed to read save file #{@path}: #{e.message}"
+      nil
+    end
+
+    def write(bytes)
+      tmp_path = "#{@path}.tmp"
+      File.binwrite(tmp_path, bytes.pack('C*'))
+      File.rename(tmp_path, @path)
+      true
+    rescue StandardError => e
+      warn "[rubyboy] failed to write save file #{@path}: #{e.message}"
+      false
+    end
+  end
+end

data/lib/rubyboy/sdl.rb

@@ -25,6 +25,17 @@ module Rubyboy
     SDL_SCANCODE_K = 14
     SDL_SCANCODE_U = 24
     SDL_SCANCODE_I = 12
+    SDL_SCANCODE_1 = 30
+    SDL_SCANCODE_2 = 31
+    SDL_SCANCODE_3 = 32
+    SDL_SCANCODE_4 = 33
+    SDL_SCANCODE_5 = 34
+    SDL_SCANCODE_6 = 35
+    SDL_SCANCODE_7 = 36
+    SDL_SCANCODE_8 = 37
+    SDL_SCANCODE_9 = 38
+    SDL_SCANCODE_0 = 39
+    SDL_SCANCODE_LSHIFT = 225
 
     attach_function :Init, 'SDL_Init', [:uint32], :int
     attach_function :InitSubSystem, 'SDL_InitSubSystem', [:uint32], :int
@@ -42,6 +53,7 @@ module Rubyboy
     attach_function :GetKeyboardState, 'SDL_GetKeyboardState', [:pointer], :pointer
     attach_function :SetHint, 'SDL_SetHint', %i[string string], :int
     attach_function :RenderSetLogicalSize, 'SDL_RenderSetLogicalSize', %i[pointer int int], :int
+    attach_function :RenderSetVSync, 'SDL_RenderSetVSync', %i[pointer int], :int
     attach_function :SetWindowTitle, 'SDL_SetWindowTitle', %i[pointer string], :void
     attach_function :RaiseWindow, 'SDL_RaiseWindow', [:pointer], :void
     attach_function :GetError, 'SDL_GetError', [], :string

data/lib/rubyboy/state_file.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Rubyboy
+  class StateFile
+    MAGIC = 'RBYSTATE'
+    FORMAT_VERSION = 1
+    HEADER_SIZE = 16
+
+    def self.write(path, rom:)
+      payload = Marshal.dump(yield)
+      header = MAGIC.b + [FORMAT_VERSION, rom.global_checksum_value, 0].pack('L<S<S<')
+      tmp_path = "#{path}.tmp"
+      File.binwrite(tmp_path, header + payload)
+      File.rename(tmp_path, path)
+      true
+    rescue StandardError => e
+      warn "[rubyboy] failed to write state file #{path}: #{e.message}"
+      false
+    end
+
+    def self.read(path, rom:)
+      return warn_and_false("state file does not exist: #{path}") unless File.exist?(path)
+
+      data = File.binread(path)
+      return warn_and_false("state file is too small: #{path}") if data.bytesize < HEADER_SIZE
+
+      magic = data.byteslice(0, MAGIC.bytesize)
+      return warn_and_false("invalid state file magic: #{path}") unless magic == MAGIC
+
+      version, checksum = data.byteslice(8, 6).unpack('L<S<')
+      return warn_and_false("unsupported state file version #{version} (expected #{FORMAT_VERSION})") unless version == FORMAT_VERSION
+      return warn_and_false("ROM checksum mismatch for state file #{path}") unless checksum == rom.global_checksum_value
+
+      # State files are local emulator snapshots written by this process.
+      # rubocop:disable Security/MarshalLoad
+      yield Marshal.load(data.byteslice(HEADER_SIZE..))
+      # rubocop:enable Security/MarshalLoad
+      true
+    rescue StandardError => e
+      warn "[rubyboy] failed to read state file #{path}: #{e.message}"
+      false
+    end
+
+    def self.warn_and_false(message)
+      warn "[rubyboy] #{message}"
+      false
+    end
+    private_class_method :warn_and_false
+  end
+end

data/lib/rubyboy/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Rubyboy
-  VERSION = '1.5.1'
+  VERSION = '1.6.0'
 end

data/lib/rubyboy.rb

@@ -9,8 +9,11 @@ require_relative 'rubyboy/emulator'
 require_relative 'rubyboy/ppu'
 require_relative 'rubyboy/rom'
 require_relative 'rubyboy/ram'
+require_relative 'rubyboy/save_file'
+require_relative 'rubyboy/state_file'
 require_relative 'rubyboy/timer'
 require_relative 'rubyboy/lcd'
 require_relative 'rubyboy/joypad'
 require_relative 'rubyboy/interrupt'
 require_relative 'rubyboy/cartridge/factory'
+require_relative 'rubyboy/hardware_state'