GBRb 0.1.0 → 0.2.0

data/lib/gbrb/instruction_set/rst.rb

@@ -0,0 +1,16 @@
+require_relative 'instruction'
+
+module GBRb::InstructionSet
+  class Rst < Instruction
+    def initialize offset
+      @offset = offset
+      super 1, 16
+    end
+
+    def call r, mem
+      r.sp.store r.sp.read - 2
+      mem.write_word r.sp.read, r.pc.read
+      r.pc.store 0x0000 + @offset
+    end
+  end
+end

data/lib/gbrb/instruction_set/special.rb

@@ -0,0 +1,37 @@
+require_relative 'instruction'
+require_relative '../../gbrb'
+
+module GBRb::InstructionSet
+  class Stop < Instruction; end
+
+  class EnableInterrupts < Instruction
+    def initialize
+      super 1, 4, -1
+    end
+
+    def call cpu
+      cpu.interrupts = :enabled
+    end
+  end
+
+  class DisableInterrupts < Instruction
+    def initialize
+      super 1, 4, -1
+    end
+
+    def call cpu
+      cpu.interrupts = :disabled
+    end
+  end
+
+  class Halt < Instruction
+    def initialize
+      super 1, 4, -1
+    end
+
+    def call cpu
+      cpu.interrupt_before_halt = cpu.mmu.read_byte GBRb::INTERRUPT_FLAG_ADDR
+      cpu.halted = true
+    end
+  end
+end

data/lib/gbrb/instruction_set/stack.rb

@@ -0,0 +1,34 @@
+require_relative '../cpu'
+require_relative 'instruction'
+
+module GBRb::InstructionSet
+  class Pop < Instruction
+    def initialize target, m=3, t=12
+      super m, t
+      @targets = target.to_s.chars.map{|a| a.to_sym}.reverse
+    end
+
+    def call r, mem
+      @targets.each do |target|
+        r.public_send(target).store mem.read_byte(r.sp.read)
+        r.sp.store r.sp.read + 1
+      end
+
+      r.f.store r.f.read & 0xf0 if @targets.include? :f
+    end
+  end
+
+  class Push < Instruction
+    def initialize target, m=4, t=16
+      super m, t
+      @targets = target.to_s.chars.map{|a| a.to_sym}
+    end
+
+    def call r, mem
+      @targets.each do |target|
+        r.sp.store r.sp.read - 1
+        mem.write_byte(r.sp.read, r.public_send(target).read)
+      end
+    end
+  end
+end

data/lib/gbrb/instruction_set/swap.rb

@@ -0,0 +1,32 @@
+require_relative '../cpu'
+require_relative 'instruction'
+
+module GBRb::InstructionSet
+  class Swap < Instruction
+    def initialize target, m=2, t=8, indirect=false
+      @target = target
+      @indirect = indirect
+      super m, t
+    end
+
+    def call r, mem
+      initial = r.public_send(@target).read
+      initial = mem.read_byte(initial) if @indirect
+      high = initial >> 4
+      low = initial & ((1 << 4) - 1)
+
+      result = (low << 4) + high
+
+      if @indirect
+        mem.write_byte r.public_send(@target).read, result
+        mem.read_byte(r.public_send(@target).read) == 0 ? r.set_zero_flag : r.clear_zero_flag
+      else
+        r.public_send(@target).store result
+        r.public_send(@target).read == 0 ? r.set_zero_flag : r.clear_zero_flag
+      end
+      r.clear_add_sub_flag
+      r.clear_half_carry_flag
+      r.clear_carry_flag
+    end
+  end
+end

data/lib/gbrb/mmu.rb

@@ -9,19 +9,23 @@ module GBRb
     WORKING_RAM_SHADOW_LENGTH = 0x1e00
     ROM_BANK_0_ADDRESS = 0x0000
     ROM_BANK_1_ADDRESS = 0x4000
-    GPU_START = 0x8000
-    GPU_END   = 0x9fff
+    BIOS_STATUS_ADDRESS = 0xff50
 
-    def initialize bios=[], cartridge=:none, gpu=nil
-      @storage = Array.new SIZE, 0
-      load_cartridge cartridge unless cartridge == :none
+    def initialize bios=[]
+      @storage     = Array.new SIZE, 0
+      @peripherals = Array.new SIZE, nil
       load_bios bios
-      @gpu = gpu
     end
 
     def read_byte addr
       raise unless (0..SIZE).cover? addr
-      @storage[addr]
+      return @bios[addr] if addr < @bios.length and @in_bios
+
+      if (p = @peripherals[addr])
+        p.read_byte addr
+      else
+        @storage[addr]
+      end
     end
 
     def read_word addr
@@ -29,13 +33,19 @@ module GBRb
     end
 
     def write_byte addr, value
-      @storage[addr] = value & 0xff
-      if (WORKING_RAM_ADDRESS..WORKING_RAM_ADDRESS + WORKING_RAM_SHADOW_LENGTH).cover? addr
-        copy_address = addr + WORKING_RAM_SHADOW_ADDRESS - WORKING_RAM_ADDRESS
-        @storage[copy_address] = value & 0xff
+      if BIOS_STATUS_ADDRESS == addr
+        value == 0x00 ? load_bios(@bios) : unload_bios
+        return
       end
-      if (GPU_START..GPU_END).cover? addr and @gpu
-        @gpu.push [:mmu, addr]
+
+      if (p = @peripherals[addr])
+        p.write_byte addr, value
+      else
+        @storage[addr] = value & 0xff
+        if (WORKING_RAM_ADDRESS..WORKING_RAM_ADDRESS + WORKING_RAM_SHADOW_LENGTH).cover? addr
+          copy_address = addr + WORKING_RAM_SHADOW_ADDRESS - WORKING_RAM_ADDRESS
+          @storage[copy_address] = value & 0xff
+        end
       end
     end
 
@@ -44,12 +54,49 @@ module GBRb
       write_byte addr+1, value >> 8
     end
 
+    def connect peripheral, *locations
+      locations.map! do |location|
+        if location.class == Range
+          STDOUT.puts "Connecting #{peripheral.class.to_s.split('::').last} at [#{location.first.to_s 16}, #{location.last.to_s 16}]..."
+          location.to_a
+        else
+          STDOUT.puts "Connecting #{peripheral.class.to_s.split('::').last} at #{Array(location).map{|l| l.to_s 16}.join ", "}..."
+          Array(location).map &:to_i
+        end
+      end
+
+      locations.flatten.each do |l|
+        @peripherals[l.to_i] = peripheral
+      end
+    end
+
     def dump start=0, stop=SIZE
       debug_indicies(start, stop).zip(debug_hex(start, stop), debug_ascii(start, stop))
                     .map{|row| row.join("  ")}
                     .join("\n")
     end
 
+    def reset
+    end
+
+    def unload_bios
+      @in_bios = false
+    end
+
+    def irq i
+      old_value = read_byte INTERRUPT_FLAG_ADDR
+      case i
+      when TIMER_OVERFLOW_IRQ
+        write_byte INTERRUPT_FLAG_ADDR, old_value | TIMER_OVERFLOW_IRQ
+      end
+    end
+
+    private
+    def load_bios commands
+      @bios = commands
+      @in_bios = commands.length > 0
+    end
+
     def debug_indicies start, stop
       (start...stop).step(0x10)
                     .map{|el| el.to_s 16 }
@@ -70,27 +117,5 @@ module GBRb
                            .map{|el| "|" + el + "|"}
     end
 
-    def reset
-    end
-
-    def unload_bios
-      @storage[0..(ROM_BANK_0_ADDRESS + MEMORY_BANK_SIZE)] = if @cartridge
-        @cartridge.bank
-      else
-        Array.new(ROM_BANK_0_ADDRESS + MEMORY_BANK_SIZE){0}
-      end
-    end
-
-    private
-    def load_cartridge cartridge
-      @cartridge = cartridge
-      @storage[0...(ROM_BANK_0_ADDRESS + MEMORY_BANK_SIZE)] = cartridge.bank 0
-      @storage[ROM_BANK_1_ADDRESS...(ROM_BANK_1_ADDRESS + MEMORY_BANK_SIZE)] = cartridge.bank 1
-    end
-
-    def load_bios commands
-      @bios = commands
-      @storage[0..commands.length-1] = commands
-    end
   end
 end

data/lib/gbrb/options.rb

@@ -0,0 +1,54 @@
+require 'optparse'
+
+module GBRb
+  class Options
+    def initialize argv
+      if argv.length < 1
+        STDERR.puts "No game cartridge specified. See `gbrb -h` for usage."
+        exit 1
+      end
+
+      @config = { skip_boot:      false,
+                  debug:          false,
+                  cartridge_path: argv.pop
+      }
+
+      if @config[:cartridge_path] =~ /^-/
+        argv.push @config[:cartridge_path]
+        @config[:cartridge_path] = ''
+      end
+
+      parse argv
+    end
+
+    def method_missing m, *a, &b
+      @config.fetch(m) { super }
+    end
+
+    private
+    def parse argv
+      OptionParser.new do |opts|
+        opts.on("-d", "--debug", "Enable interactive debugger") do
+          @config[:debug] = :interactive
+        end
+        opts.on("-D", "--dump", "Dump the state of the registers after each instruction.") do
+          @config[:debug] = :dump
+        end
+        opts.on("-h", "--help", "Show this help screen") do
+          puts opts
+          exit
+        end
+        opts.on("-s", "--skip-boot", "Skip the Nintendo logo scroll") do
+          @config[:skip_boot] = true
+        end
+
+        begin
+          opts.parse! argv
+        rescue OptionParser::ParseError => e
+          STDERR.puts e.message, "\n", opts
+          exit 2
+        end
+      end
+    end
+  end
+end

data/lib/gbrb/timer.rb

@@ -0,0 +1,114 @@
+require_relative '../gbrb'
+
+module GBRb
+  class Timer
+    DIV_ADDRESS  = 0xff04
+    TIMA_ADDRESS = 0xff05
+    TMA_ADDRESS  = 0xff06
+    TAC_ADDRESS  = 0xff07
+    ADDRESSES = [DIV_ADDRESS, TIMA_ADDRESS, TMA_ADDRESS, TAC_ADDRESS]
+
+    Frequency = Struct.new :string, :cycles
+    FREQUENCIES = { freq4096:   Frequency.new('4096 Hz', 256),
+                    freq16384:  Frequency.new('16384 Hz', 64),
+                    freq65536:  Frequency.new('65536 Hz', 16),
+                    freq262144: Frequency.new('262144 Hz', 4)
+                  }
+
+    attr_reader :div, :tima, :tma, :tac
+    attr_writer :irq_handler
+
+    def initialize
+      @div  = Counter.new 'DIV',  :freq16384
+      @tima = Counter.new 'TIMA', :freq4096
+      @tac  = 0x00
+      @tma  = 0x00
+    end
+
+    def step cycles
+      if @tac & 0x04 == 0x04 and @tima.step cycles
+        @irq_handler.irq TIMER_OVERFLOW_IRQ
+        @tima.value = @tma
+      end
+      @div.step cycles
+    end
+
+    def read_byte addr
+      case addr
+      when DIV_ADDRESS
+        @div.value
+      when TIMA_ADDRESS
+        @tima.value
+      when TMA_ADDRESS
+        @tma
+      when TAC_ADDRESS
+        @tac
+      end
+    end
+
+    def write_byte addr, value
+      case addr
+      when DIV_ADDRESS
+        @div.value = 0
+      when TIMA_ADDRESS
+        @tima.value = value
+      when TMA_ADDRESS
+        @tma = value
+      when TAC_ADDRESS
+        old_freq = get_frequency(@tac  & 0x03)
+        new_freq = get_frequency(value & 0x03)
+        @tima.set_frequency new_freq unless old_freq == new_freq
+        @tac = value
+      end
+    end
+
+    def get_frequency id
+      case id
+      when 0
+        :freq4096
+      when 1
+        :freq262144
+      when 2
+        :freq65536
+      when 3
+        :freq16384
+      end
+    end
+
+    private
+    class Counter
+      attr_accessor :value
+
+      def initialize name, initial_frequency
+        reset
+        @name = name
+        set_frequency initial_frequency
+      end
+
+      def reset
+        @frequency = FREQUENCIES[:freq4096]
+        @value = 0
+      end
+
+      def set_frequency frequency
+        @frequency = FREQUENCIES[frequency] if FREQUENCIES.has_key? frequency
+        @clock_counter = @frequency.cycles
+      end
+
+      def to_s
+        "#{@name}: Frequency: #{@frequency.string} (#{@frequency.cycles} cycles) | Current Counter: #{@clock_counter} | Value: #{@value}"
+      end
+
+      def step cycles
+        @clock_counter -= cycles
+
+        while @clock_counter <= 0
+          @value = (@value + 1) & 0xff
+          @clock_counter += @frequency.cycles
+          return true if @value == 0
+        end
+        false
+      end
+    end
+  end
+end

data/lib/gbrb/version.rb

@@ -1,3 +1,3 @@
 module GBRb
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/misc/dump_diff

@@ -0,0 +1,133 @@
+#!/usr/bin/env ruby
+
+REGISTERS = %i[pc sp a b c d e h l f opcode]
+
+class Cpu
+  attr_accessor :registers
+
+  def initialize values=nil
+    if values
+      @registers = values
+    else
+      @registers = {}
+      REGISTERS.each {|r| @registers[r.to_sym] = 0}
+    end
+  end
+
+  def to_s
+    @registers.inspect
+  end
+
+  def == other
+    @registers == other.registers
+  end
+end
+
+class Parser
+  include Enumerable
+
+  def initialize input, separator="\n"
+    @input = input
+    @separator = separator
+    skip_preamble
+  end
+
+  def skip_preamble
+    raise StandardError
+  end
+
+  def succ
+    raise StopIteration if @input.eof?
+    @current_raw_value = @input.gets(@separator).chomp(@separator)
+  end
+  alias :next :succ
+
+  def rewind
+    @input.rewind
+  end
+
+  def destroy
+    @input.close
+  end
+
+  def each &block
+    return self.dup unless block
+    loop { block.call succ }
+  end
+end
+
+class GBRbParser < Parser
+  def current
+    Cpu.new Hash[
+                 REGISTERS.zip( @current_raw_value.split('|')
+                                                  .tap{|el| el.delete_at(10)} # Remove CB prefix
+                                                  .map{|el| el.to_i(16)}
+                              )
+                ]
+  end
+
+  def skip_preamble
+    separator_count = 0
+    loop do
+      c = @input.getc
+      if /\*/.match c
+        separator_count += 1
+        c = @input.getc until c == "\n"
+      end
+      if separator_count == 2
+        self.next
+        break
+      end
+    end
+  end
+end
+
+class GomeboyParser < Parser
+  def current
+    tmp = @current_raw_value.split('  ')
+                      .map{|el| el.split(': ') }
+                      .take(11)
+                      .map{|el| el.length == 2 ? el : el.first.split(' ').first}
+
+    tmp[-1] = ["OPCODE", tmp[-1]]
+    tmp[-2] = ["F", "0x" + tmp[-2].chars.each_with_index.map{|el, i| el == '-' ? 0 : 0b1 << (7-i)}.inject(0, &:+).to_s(16)]
+    Cpu.new Hash[ tmp.map{|el| [el.first.downcase.to_sym, el.last.to_i(16)]} ]
+  end
+
+  def skip_preamble
+    self.next
+    separator_count = 0
+    loop do
+      c = @input.getc
+      if /\-/.match c
+        separator_count += 1
+        c = @input.getc until c == "\n"
+      end
+      break if separator_count == 2
+    end
+    self.next
+  end
+end
+
+if ARGV.length != 2
+  puts "Two dumps required"
+  exit 1
+end
+
+gbrb    = GBRbParser.new    File.open ARGV[0]
+gomeboy = GomeboyParser.new File.open ARGV[1]
+
+steps_matched = 0
+different = false
+while !different do
+  gomeboy.next
+  gbrb.next
+  if gomeboy.current != gbrb.current
+    puts "Gomeboy: #{gomeboy.current}"
+    puts "GBRb:    #{gbrb.current}"
+    different = true
+  end
+  steps_matched += 1
+end
+
+puts "Steps Matched: #{steps_matched}"