rubyboy 1.6.0 → 1.7.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '09e12943a26b3089da7e75f3a26a0994dd71c1a748b63c840c49c3772502b625'
-  data.tar.gz: c37fdfa6182bb28cbca6ffe5438670860e0e6c10e32b581509dbfca28e12f70d
+  metadata.gz: 5b4b18354440d4cb9fdfe8d35a4d84414b76d806119167d52e16dfb2b039624b
+  data.tar.gz: a6d24e7a4f369e5628c25cc64c51a266454aa94e21ffaccb3e178941ed08e248
 SHA512:
-  metadata.gz: 35c057be65b5b1143d870d6db5d8a0b769074e42c10281680b411e1d348f2b8b5109ff12dcddae3ca3b803b6a379fff4f7343fd0e16b111e25686d25d5468861
-  data.tar.gz: 900d258e730fdd03f23b508d1ff4cfd3e80b738ebf0c9ce49e6a064faeb0456a01be84bab269d62f59bcb7895d25b1dfeb08d41a2d39c0fabce4b52427d63a91
+  metadata.gz: 2cf41bc728ebde97dff695479aa1b451a68a24f0562cf79d3d630589b78dc2ca7496d605b88edb708f5c402396be7599d41b99a7c51b8a07977cbb461f5ae79b
+  data.tar.gz: 5405ed2472b2f53f62c57c01958536dc44bb0859f246d621792f5aeb48b7bb6ae7bcd75075932871ab919eb7931d0dea8114a9ea1e8d0705aa87b82f3ce03bb8

data/CHANGELOG.md

@@ -1,3 +1,20 @@
+## [1.7.1] - 2026-10-11
+
+- Fix RLC and RRC on memory writing values over a byte, which could stop the Spinel browser build
+
+## [1.7.0] - 2026-10-10
+
+- Require Ruby 4.0 or higher
+- Keep audio output with --unlimited by dropping audio that cannot be played in time
+- Remove the --no-audio player option
+- Remove rubyboy-bench --render and --json, and the SDL 2.0.18 requirement
+- Print a checksum of the final frame from rubyboy-bench to check that a runtime emulated correctly
+- Run rubyboy-bench without loading SDL
+- Run the bundled Tobu Tobu Girl ROM when rubyboy or rubyboy-bench gets no ROM path, from any directory
+- Read ROM files in binary mode, which fixes loading them on Windows
+- Make the APU duty tables shareable between Ractors
+- Ship only the runtime code, the default ROM and documents in the gem, without the rubyboy-wasm command or test ROMs
+
 ## [1.6.0] - 2026-10-04
 
 - Add battery-backed saves and hardware-oriented save states

data/README.md

@@ -6,7 +6,9 @@
 
 A Game Boy emulator written in Ruby
 
-**[Try the demo in your browser!](https://sacckey.github.io/rubyboy/)** - Powered by WebAssembly
+**Try it in your browser:**
+[ruby.wasm version](https://sacckey.github.io/rubyboy/) (CRuby compiled to WebAssembly) /
+[Spinel version](https://sacckey.github.io/rubyboy/spinel/) (the same Ruby code compiled to C by Spinel, then to WebAssembly)
 
 ## Screenshots
 <div align="center">
@@ -14,103 +16,57 @@ A Game Boy emulator written in Ruby
   <img src="/resource/screenshots/puyopuyo.png" width="400px"/>
 </div>
 
-## Requirements
-[SDL2](https://wiki.libsdl.org/SDL2/Installation) 2.0.18 or higher.
-
 ## Installation
 
-This project requires Ruby 3.2.0 or higher.
+Rubyboy requires Ruby 4.0 or higher and [SDL2](https://wiki.libsdl.org/SDL2/Installation).
+
+    $ gem install rubyboy
 
 > [!TIP]
-> To enhance performance, it is highly recommended to use Ruby 3.3.x with YJIT.
+> Run with YJIT (`RUBYOPT=--yjit`) for better performance.
+
+## Usage
 
-Install the gem and add to the application's Gemfile by executing:
+    $ RUBYOPT=--yjit rubyboy [rom_path]
 
-    $ bundle add rubyboy
+Without a ROM path, it runs the bundled [Tobu Tobu Girl](https://tangramgames.dk/tobutobugirl/).
 
-If bundler is not being used to manage dependencies, install the gem by executing:
+### Controls
 
-    $ gem install ffi rubyboy
+| Key | Button |
+| :---: | :---: |
+| `W` `A` `S` `D` | ↑ ← ↓ → |
+| `K` | A |
+| `J` | B |
+| `U` | Select |
+| `I` | Start |
+| `1`–`0` | Save state to slot 1–9, 0 |
+| Left `Shift` + `1`–`0` | Load state from that slot |
 
-## Usage
+Battery-backed games save to `<rom>.sav`, and save states go to `<rom>.state<N>`,
+next to the ROM file.
+
+### Options
 
-    $ RUBYOPT=--yjit rubyboy <rom_path>
-
-| Key   | Button |
-| :---: | :----: |
-| `W`   | ↑      |
-| `A`   | ←      |
-| `S`   | ↓      |
-| `D`   | →      |
-| `J`   | A      |
-| `K`   | B      |
-| `U`   | Select |
-| `I`   | Start  |
-
-## Bounded execution
-
-The player accepts `--frames N` to stop after N completed frames, `--no-audio`
-to disable audio output while continuing APU emulation, and `--unlimited` to
-disable real-time synchronization:
-
-```sh
-bundle exec ruby --yjit -Ilib exe/rubyboy --frames 600 --unlimited --no-audio lib/roms/tobu.gb
-```
-
-Normal playback remains synchronized to real time with audio enabled.
-`--unlimited` alone still permits audio queue backpressure; use `--no-audio`
-for maximum speed. These player options retain keyboard input and battery save
-loading/writing. Use the benchmark below for comparisons with a fixed start state.
-
-## Benchmarking
-
-Run a headless benchmark with an explicit warmup before each measured trial:
-
-```sh
-bundle exec ruby --yjit -Ilib exe/rubyboy-bench \
-  --rom-path lib/roms/tobu.gb --frames 1500 --warmup-frames 1500 --count 5 --json
-```
-
-Add `--render` to include SDL drawing, with audio output and VSync disabled.
-No environment variable is required; the benchmark overrides the VSync setting
-for its renderer, including `SDL_RENDER_VSYNC=1`:
-
-```sh
-bundle exec ruby --yjit -Ilib exe/rubyboy-bench \
-  --rom-path lib/roms/tobu.gb --frames 1500 --warmup-frames 1500 --count 5 --render --json
-```
-
-Both modes run the same CPU, timer, PPU and APU frame processing. Each trial
-starts with a fresh emulator, ignores battery saves, accepts no game input and
-runs without real-time synchronization or audio output. Initialization, warmup
-and display cleanup are excluded from the measured duration. Warmup advances
-the machine state by the requested number of frames in both modes. The defaults
-are 3 trials, 1500 measured frames and no warmup; counts and measured frames must
-be positive, and warmup frames may be zero.
-
-Without `--json`, the command prints each trial's duration and aggregate FPS.
-With `--json`, stdout contains one JSON document with individual durations/FPS,
-aggregate FPS, runtime identity and execution conditions. Aggregate FPS is the
-total measured frame count divided by the sum of measured durations. Closing
-the window before a trial finishes aborts the benchmark with a nonzero exit
-status instead of reporting a result for that incomplete trial.
-
-For comparisons, use the same source revision, ROM, frame counts, warmup,
-window/display settings and SDL render driver. Normal playback retains its
-existing VSync setting. Rendered FPS measures frame
-processing and SDL drawing calls; it does not count distinct frames visible on
-the monitor. Measure performance without recording, then use a separate
-`--render --count 1` run for a reference recording. Preserve elapsed real time
-when converting the recording to GIF so that speed differences remain visible.
+| Option | Effect |
+| --- | --- |
+| `--frames N` | Exit after N frames |
+| `--unlimited` | Run as fast as possible; audio that cannot be played in time is dropped |
+
+## Benchmark
+
+On an Apple M4, Rubyboy runs at about 110 FPS on CRuby, 290 FPS with YJIT and
+800 FPS when compiled with Spinel. See [BENCHMARK.md](BENCHMARK.md) for the method and details.
+
+## Other ways to run
+
+- [WebAssembly builds](wasm/README.md): the browser versions (ruby.wasm and Spinel)
+- [Spinel](spinel/README.md): compile Rubyboy to a native executable
 
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/sacckey/rubyboy. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/sacckey/rubyboy/blob/main/CODE_OF_CONDUCT.md).
+Bug reports and pull requests are welcome on GitHub at https://github.com/sacckey/rubyboy. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](CODE_OF_CONDUCT.md).
 
 ## License
 
 The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
-
-## Code of Conduct
-
-Everyone interacting in the Rubyboy project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/sacckey/rubyboy/blob/main/CODE_OF_CONDUCT.md).

data/exe/rubyboy

@@ -6,11 +6,10 @@ require 'optparse'
 
 frames = nil
 realtime = true
-audio = true
 
 begin
   OptionParser.new do |opts|
-    opts.banner = "Usage: #{File.basename($PROGRAM_NAME)} ROM_PATH"
+    opts.banner = "Usage: #{File.basename($PROGRAM_NAME)} [ROM_PATH]"
 
     opts.on('--frames N', 'Exit after N frames (positive integer)') do |value|
       value = Integer(value)
@@ -18,8 +17,7 @@ begin
 
       frames = value
     end
-    opts.on('--unlimited', 'Disable real-time synchronization') { realtime = false }
-    opts.on('--no-audio', 'Disable audio output while keeping APU emulation') { audio = false }
+    opts.on('--unlimited', 'Disable real-time synchronization; excess audio is dropped') { realtime = false }
 
     opts.on('-h', '--help', 'Displays this help') do
       puts opts
@@ -28,11 +26,11 @@ begin
   end.parse!
 rescue OptionParser::ParseError, ArgumentError => e
   puts e.message
-  puts "Usage: #{File.basename($PROGRAM_NAME)} ROM_PATH"
+  puts "Usage: #{File.basename($PROGRAM_NAME)} [ROM_PATH]"
   exit 1
 end
 
-rom_path = ARGV.shift || 'lib/roms/tobu.gb'
+rom_path = ARGV.shift || Rubyboy::Rom::DEFAULT_PATH
 
 puts "Ruby: #{RUBY_VERSION}"
 if defined?(RubyVM::YJIT)
@@ -41,4 +39,4 @@ else
   puts 'YJIT is not available in this environment.'
 end
 
-Rubyboy::Emulator.new(rom_path, audio:).start(frames:, realtime:)
+Rubyboy::Emulator.new(rom_path).start(frames:, realtime:)

data/exe/rubyboy-bench

@@ -1,7 +1,6 @@
 #!/usr/bin/env ruby
 # frozen_string_literal: true
 
-require 'rubyboy'
 require 'bench'
 require 'optparse'
 
@@ -11,23 +10,15 @@ begin
     opts.banner = "Usage: #{File.basename($PROGRAM_NAME)} [options]"
 
     opts.on('--count COUNT', Integer, 'Number of trials for the benchmark') do |count|
-      options[:count] = Integer(count)
+      options[:count] = count
     end
 
     opts.on('--frames FRAMES', Integer, 'Number of measured frames per trial') do |frames|
-      options[:frames] = Integer(frames)
+      options[:frames] = frames
     end
 
     opts.on('--warmup-frames FRAMES', Integer, 'Number of unmeasured warmup frames per trial (default: 0)') do |frames|
-      options[:warmup_frames] = Integer(frames)
-    end
-
-    opts.on('--render', 'Draw each frame without audio output or realtime synchronization') do
-      options[:render] = true
-    end
-
-    opts.on('--json', 'Output benchmark results and runtime information as JSON') do
-      options[:json] = true
+      options[:warmup_frames] = frames
     end
 
     opts.on('--rom-path ROM_PATH', String, 'Path to the ROM file') do |rom_path|
@@ -45,18 +36,16 @@ rescue OptionParser::ParseError, ArgumentError => e
   exit 1
 end
 
-unless options[:json]
-  puts "Ruby: #{RUBY_VERSION}"
-  if defined?(RubyVM::YJIT)
-    puts "YJIT: #{RubyVM::YJIT.enabled?}"
-  else
-    puts 'YJIT is not available in this environment.'
-  end
+puts "Ruby: #{RUBY_VERSION}"
+if defined?(RubyVM::YJIT)
+  puts "YJIT: #{RubyVM::YJIT.enabled?}"
+else
+  puts 'YJIT is not available in this environment.'
 end
 
 begin
   Rubyboy::Bench.new.run(**options)
-rescue ArgumentError, Rubyboy::Bench::WindowClosed => e
+rescue ArgumentError => e
   warn e.message
   exit 1
 end

data/lib/bench.rb

@@ -1,44 +1,31 @@
 # frozen_string_literal: true
 
-require 'json'
 require_relative 'rubyboy/emulator_headless'
 
 module Rubyboy
   class Bench
-    class WindowClosed < StandardError; end
-
-    def run(count: 3, frames: 1500, rom_path: 'lib/roms/tobu.gb', warmup_frames: 0, render: false, json: false)
+    def run(count: 3, frames: 1500, rom_path: Rom::DEFAULT_PATH, warmup_frames: 0)
       validate_integer(:count, count, 1)
       validate_integer(:frames, frames, 1)
       validate_integer(:warmup_frames, warmup_frames, 0)
-      require_relative 'rubyboy/lcd' if render
 
-      trials = []
       time_sum = 0
+      frame_checksum = 0
       count.times do |i|
-        time = run_trial(rom_path, frames, warmup_frames, render)
-        elapsed_seconds = time / 1_000_000_000.0
-        trials << { trial: i + 1, frames:, elapsed_seconds:, fps: frames / elapsed_seconds }
-        puts "#{i + 1}: #{elapsed_seconds} sec" unless json
+        emulator = Rubyboy::EmulatorHeadless.new(rom_path)
+        run_frames(emulator, warmup_frames)
+        start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC, :nanosecond)
+        run_frames(emulator, frames)
+        time = Process.clock_gettime(Process::CLOCK_MONOTONIC, :nanosecond) - start_time
+        puts "#{i + 1}: #{time / 1_000_000_000.0} sec"
+
         time_sum += time
+        frame_checksum = checksum(emulator.framebuffer)
       end
 
-      result = {
-        schema_version: 1,
-        rom_path: File.expand_path(rom_path),
-        count:,
-        frames:,
-        warmup_frames:,
-        render:,
-        runtime:,
-        conditions: { apu: true, audio_output: false, realtime_sync: false, vsync: render ? false : nil, input: false, save: false },
-        trials:,
-        total_frames: frames * count,
-        elapsed_seconds: time_sum / 1_000_000_000.0,
-        fps: frames * count * 1_000_000_000.0 / time_sum
-      }
-      puts(json ? JSON.generate(result) : "FPS: #{result[:fps]}")
-      result
+      puts "FPS: #{frames * count * 1_000_000_000.0 / time_sum}"
+      # Every trial ends on the same frame. A different value on another runtime means it emulated incorrectly.
+      puts "Checksum: #{frame_checksum}"
     end
 
     private
@@ -50,33 +37,17 @@ module Rubyboy
       raise ArgumentError, "#{name} must be #{requirement}"
     end
 
-    def run_trial(rom_path, frames, warmup_frames, render)
-      emulator = Rubyboy::EmulatorHeadless.new(rom_path)
-      lcd = Rubyboy::Lcd.new(vsync: false) if render
-      begin
-        run_frames(emulator, lcd, warmup_frames)
-        start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC, :nanosecond)
-        run_frames(emulator, lcd, frames)
-        Process.clock_gettime(Process::CLOCK_MONOTONIC, :nanosecond) - start_time
-      ensure
-        lcd&.close_window
-      end
+    # Integer arithmetic only, so CRuby and ahead-of-time compilers such as Spinel produce the same value.
+    def checksum(framebuffer)
+      framebuffer.reduce(0) { |hash, pixel| ((hash * 31) + pixel) & 0xffffffff }
     end
 
-    def run_frames(emulator, lcd, frames)
+    def run_frames(emulator, frames)
       frame_count = 0
       while frame_count < frames
-        raise WindowClosed, 'Benchmark stopped because the window was closed.' if lcd&.window_should_close?
-
         emulator.step
-        lcd&.draw(emulator.framebuffer)
         frame_count += 1
       end
     end
-
-    def runtime
-      yjit_enabled = defined?(RubyVM::YJIT) ? RubyVM::YJIT.enabled? : false
-      { engine: RUBY_ENGINE, version: RUBY_VERSION, description: RUBY_DESCRIPTION, platform: RUBY_PLATFORM, yjit_enabled: }
-    end
   end
 end

data/lib/executor.rb

@@ -1,36 +1,45 @@
 # frozen_string_literal: true
 
-require 'js'
-require 'json'
-
 require_relative 'rubyboy/emulator_wasm'
 
 class Executor
   ALLOWED_ROMS = ['tobu.gb', 'bgbtest.gb'].freeze
 
-  def initialize
-    rom_data = File.open('lib/roms/tobu.gb', 'r') { _1.read.bytes }
+  def initialize(rom_path = '/lib/roms/tobu.gb')
+    rom_data = File.binread(rom_path).bytes
     @emulator = Rubyboy::EmulatorWasm.new(rom_data)
   end
 
   def exec(direction_key = 0b1111, action_key = 0b1111)
-    bin = @emulator.step(direction_key, action_key).pack('V*')
-    File.binwrite('/video.data', bin)
+    @emulator.step(direction_key, action_key)
+    write_framebuffer
+    write_audio
   end
 
   def read_rom_from_virtual_fs
     rom_path = '/rom.data'
     raise "ROM file not found in virtual filesystem at #{rom_path}" unless File.exist?(rom_path)
 
-    rom_data = File.open(rom_path, 'rb') { |file| file.read.bytes }
+    rom_data = File.binread(rom_path).bytes
     @emulator = Rubyboy::EmulatorWasm.new(rom_data)
   end
 
   def read_pre_installed_rom(rom_name)
     raise 'ROM not found in allowed ROMs' unless ALLOWED_ROMS.include?(rom_name)
 
-    rom_path = File.join('lib/roms', rom_name)
-    rom_data = File.open(rom_path, 'r') { _1.read.bytes }
+    rom_path = File.join('/lib/roms', rom_name)
+    rom_data = File.binread(rom_path).bytes
     @emulator = Rubyboy::EmulatorWasm.new(rom_data)
   end
+
+  private
+
+  def write_framebuffer
+    File.binwrite('/video.data', @emulator.framebuffer.pack('V*'))
+  end
+
+  def write_audio
+    samples = @emulator.audio_samples
+    File.binwrite('/audio.data', samples.pack('e*')) unless samples.empty?
+  end
 end

data/lib/rubyboy/apu_channels/channel1.rb

@@ -6,10 +6,10 @@ module Rubyboy
       attr_accessor :enabled, :wave_duty_position
 
       WAVE_DUTY = [
-        [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0], # 12.5%
-        [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 1.0], # 25%
-        [0.0, 0.0, 0.0, 0.0, 1.0, 1.0, 1.0, 1.0], # 50%
-        [0.0, 0.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0]  # 75%
+        [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0].freeze, # 12.5%
+        [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 1.0].freeze, # 25%
+        [0.0, 0.0, 0.0, 0.0, 1.0, 1.0, 1.0, 1.0].freeze, # 50%
+        [0.0, 0.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0].freeze  # 75%
       ].freeze
 
       def initialize

data/lib/rubyboy/apu_channels/channel2.rb

@@ -6,10 +6,10 @@ module Rubyboy
       attr_accessor :enabled, :wave_duty_position
 
       WAVE_DUTY = [
-        [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0], # 12.5%
-        [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 1.0], # 25%
-        [0.0, 0.0, 0.0, 0.0, 1.0, 1.0, 1.0, 1.0], # 50%
-        [0.0, 0.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0]  # 75%
+        [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0].freeze, # 12.5%
+        [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 1.0].freeze, # 25%
+        [0.0, 0.0, 0.0, 0.0, 1.0, 1.0, 1.0, 1.0].freeze, # 50%
+        [0.0, 0.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0].freeze  # 75%
       ].freeze
 
       def initialize

data/lib/rubyboy/apu_channels/channel3.rb

@@ -5,13 +5,6 @@ module Rubyboy
     class Channel3
       attr_accessor :enabled, :wave_duty_position, :wave_ram
 
-      WAVE_DUTY = [
-        [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0], # 12.5%
-        [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 1.0], # 25%
-        [0.0, 0.0, 0.0, 0.0, 1.0, 1.0, 1.0, 1.0], # 50%
-        [0.0, 0.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0]  # 75%
-      ].freeze
-
       def initialize
         @cycles = 0
         @frequency = 0
@@ -76,9 +69,9 @@ module Rubyboy
       def dac_output
         return 0.0 unless @dac_enabled && @enabled
 
-        ret = ((0xf & (
+        ret = (0xf & (
           @wave_ram[@wave_duty_position >> 1] >> ((@wave_duty_position & 0x01) << 2)
-        ))) >> @volume_shift
+        )) >> @volume_shift
 
         (ret / 7.5) - 1.0
       end

data/lib/rubyboy/apu_channels/channel4.rb

@@ -5,13 +5,6 @@ module Rubyboy
     class Channel4
       attr_accessor :enabled, :wave_duty_position
 
-      WAVE_DUTY = [
-        [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0], # 12.5%
-        [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 1.0], # 25%
-        [0.0, 0.0, 0.0, 0.0, 1.0, 1.0, 1.0, 1.0], # 50%
-        [0.0, 0.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0]  # 75%
-      ].freeze
-
       def initialize
         @cycles = 0
         @frequency = 0

data/lib/rubyboy/audio.rb

@@ -21,14 +21,19 @@ module Rubyboy
       SDL.PauseAudioDevice(@device, 0)
     end
 
-    def queue(buffer)
+    def queue(buffer, wait: true)
       # Block until the SDL audio queue has drained enough to accept another
       # buffer. The previous implementation called SDL.ClearQueuedAudio here
       # instead, which dropped the entire queue whenever the emulator ran ahead
       # of real time — that produced audible pops/gaps in BGM (most noticeable
       # in Pokemon-style tracks). Blocking here costs a tiny bit of frame
       # budget but keeps audio continuous.
-      sleep(0.001) while SDL.GetQueuedAudioSize(@device) > 8192
+      # Unlimited playback drops this buffer instead, so audio never slows it down.
+      while SDL.GetQueuedAudioSize(@device) > 8192
+        return unless wait
+
+        sleep(0.001)
+      end
 
       buf_ptr = FFI::MemoryPointer.new(:float, buffer.size)
       buf_ptr.put_array_of_float(0, buffer)

data/lib/rubyboy/cpu.rb

@@ -1071,7 +1071,7 @@ module Rubyboy
 
     def rlc8(x, cycles:)
       value = get_value(x)
-      value = (value << 1) | (value >> 7)
+      value = ((value << 1) | (value >> 7)) & 0xff
       set_value(x, value)
       update_flags(
         z: value == 0,
@@ -1085,7 +1085,7 @@ module Rubyboy
 
     def rrc8(x, cycles:)
       value = get_value(x)
-      value = (value >> 1) | (value << 7)
+      value = ((value >> 1) | (value << 7)) & 0xff
       set_value(x, value)
       update_flags(
         z: value == 0,

data/lib/rubyboy/emulator.rb

@@ -17,9 +17,9 @@ module Rubyboy
       SDL::SDL_SCANCODE_0
     ].freeze
 
-    def initialize(rom_path, audio: true)
+    def initialize(rom_path)
       @rom_path = rom_path
-      rom_data = File.open(rom_path, 'r') { _1.read.bytes }
+      rom_data = File.binread(rom_path).bytes
       @rom = Rom.new(rom_data)
       @ram = Ram.new(@rom)
       @mbc = Cartridge::Factory.create(@rom, @ram)
@@ -31,7 +31,7 @@ module Rubyboy
       @bus = Bus.new(@ppu, @rom, @ram, @mbc, @timer, @interrupt, @joypad, @apu)
       @cpu = Cpu.new(@bus, @interrupt)
       @lcd = Lcd.new
-      @audio = audio ? Audio.new : nil
+      @audio = Audio.new
       @prev_save_state_keys = Array.new(SAVE_STATE_KEYS.size, 0)
       @save_file = @rom.battery? ? SaveFile.new(default_save_path(rom_path)) : nil
       load_save_file
@@ -52,7 +52,7 @@ module Rubyboy
             while !realtime || elapsed_real_time > elapsed_machine_time
               cycles = @cpu.exec
               @timer.step(cycles)
-              @audio.queue(@apu.samples) if @apu.step(cycles) && @audio
+              @audio.queue(@apu.samples, wait: realtime) if @apu.step(cycles)
               if @ppu.step(cycles)
                 @lcd.draw(@ppu.buffer)
                 key_input_check
@@ -74,22 +74,6 @@ module Rubyboy
       end
     end
 
-    def bench(frames)
-      @lcd.close_window
-      frame_count = 0
-      start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC, :nanosecond)
-      while frame_count < frames
-        cycles = @cpu.exec
-        @timer.step(cycles)
-        if @ppu.step(cycles)
-          key_input_check
-          frame_count += 1
-        end
-      end
-
-      Process.clock_gettime(Process::CLOCK_MONOTONIC, :nanosecond) - start_time
-    end
-
     def save_state(slot: nil, path: nil)
       state_path = path || slot_path(slot)
       return false unless StateFile.write(state_path, rom: @rom) { hardware_state }
@@ -102,7 +86,7 @@ module Rubyboy
       state_path = path || slot_path(slot)
       return false unless StateFile.read(state_path, rom: @rom) { |state| restore_hardware_state(state) }
 
-      @audio&.clear_queue
+      @audio.clear_queue
       puts "Loaded state from #{state_path}"
       true
     end
@@ -173,8 +157,8 @@ module Rubyboy
       keyboard_state = keyboard.read_array_of_uint8(229)
 
       check_state_save_keys(keyboard_state)
-      direction = (keyboard_state[SDL::SDL_SCANCODE_D]) | (keyboard_state[SDL::SDL_SCANCODE_A] << 1) | (keyboard_state[SDL::SDL_SCANCODE_W] << 2) | (keyboard_state[SDL::SDL_SCANCODE_S] << 3)
-      action = (keyboard_state[SDL::SDL_SCANCODE_K]) | (keyboard_state[SDL::SDL_SCANCODE_J] << 1) | (keyboard_state[SDL::SDL_SCANCODE_U] << 2) | (keyboard_state[SDL::SDL_SCANCODE_I] << 3)
+      direction = keyboard_state[SDL::SDL_SCANCODE_D] | (keyboard_state[SDL::SDL_SCANCODE_A] << 1) | (keyboard_state[SDL::SDL_SCANCODE_W] << 2) | (keyboard_state[SDL::SDL_SCANCODE_S] << 3)
+      action = keyboard_state[SDL::SDL_SCANCODE_K] | (keyboard_state[SDL::SDL_SCANCODE_J] << 1) | (keyboard_state[SDL::SDL_SCANCODE_U] << 2) | (keyboard_state[SDL::SDL_SCANCODE_I] << 3)
       @joypad.direction_button(15 - direction)
       @joypad.action_button(15 - action)
     end

data/lib/rubyboy/emulator_headless.rb

@@ -14,7 +14,7 @@ require_relative 'cartridge/factory'
 module Rubyboy
   class EmulatorHeadless
     def initialize(rom_path)
-      rom_data = File.open(rom_path, 'r') { _1.read.bytes }
+      rom_data = File.binread(rom_path).bytes
       rom = Rom.new(rom_data)
       ram = Ram.new(rom)
       mbc = Cartridge::Factory.create(rom, ram)