GBRb 0.1.0

data/lib/gbrb/mmu.rb

@@ -0,0 +1,96 @@
+require_relative '../gbrb'
+
+module GBRb
+  class MMU
+    SIZE = 0x10000
+    WORKING_RAM_ADDRESS = 0xc000
+    WORKING_RAM_LENGTH = 0x2000
+    WORKING_RAM_SHADOW_ADDRESS = 0xe000
+    WORKING_RAM_SHADOW_LENGTH = 0x1e00
+    ROM_BANK_0_ADDRESS = 0x0000
+    ROM_BANK_1_ADDRESS = 0x4000
+    GPU_START = 0x8000
+    GPU_END   = 0x9fff
+
+    def initialize bios=[], cartridge=:none, gpu=nil
+      @storage = Array.new SIZE, 0
+      load_cartridge cartridge unless cartridge == :none
+      load_bios bios
+      @gpu = gpu
+    end
+
+    def read_byte addr
+      raise unless (0..SIZE).cover? addr
+      @storage[addr]
+    end
+
+    def read_word addr
+      (read_byte(addr+1) << 8) + read_byte(addr)
+    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
+      end
+      if (GPU_START..GPU_END).cover? addr and @gpu
+        @gpu.push [:mmu, addr]
+      end
+    end
+
+    def write_word addr, value
+      write_byte addr, value
+      write_byte addr+1, value >> 8
+    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 debug_indicies start, stop
+      (start...stop).step(0x10)
+                    .map{|el| el.to_s 16 }
+                    .map{|el| el.rjust(4, "0")}
+    end
+
+    def debug_hex start, stop
+      @storage[start..stop].map do |cell|
+        cell.to_s(16)
+            .rjust(2, "0")
+      end.each_slice(0x08).map{|el| el.join(" ")}
+         .each_slice(0x02).map{|el| el.join("  ")}
+    end
+
+    def debug_ascii start, stop
+      @storage[start..stop].map{|el| (0x20..0x7e).cover?(el) ? el.chr : "."}
+                           .each_slice(0x10).map{|el| el.join}
+                           .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/version.rb

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

data/misc/parse_tiles

@@ -0,0 +1,27 @@
+#!/usr/bin/env ruby
+
+require 'pathname'
+
+input = ARGV.first
+
+data = File.read input
+
+t = data.chomp + "]"
+
+t = eval t
+
+formatted_tiles = t.map do |tile|
+  s = "P6  8 8 3 "
+  tile.each do |row|
+    row.each do |pixel|
+      s << pixel.chr * 3
+    end
+  end
+  s << "\n"
+end
+
+out_path = Pathname.new "tile_set"
+out_path.mkpath
+formatted_tiles.each_with_index do |tile, i|
+  (out_path + "#{i}.ppm").open("w:utf-8") {|f| f.write tile }
+end

data/perf/cpu_perf_spec.rb

@@ -0,0 +1,23 @@
+require_relative '../lib/gbrb/cpu/z80.rb'
+require 'benchmark'
+
+module GBRb::CPU
+  describe Z80 do
+    xit "full speed" do
+      n = 1_000_000
+      class Z80
+        def fetch
+          0x3c
+        end
+      end
+
+
+      @cpu = Z80.new
+      elapsed_time = Benchmark.realtime do
+        n.times { @cpu.run }
+      end
+
+      elapsed_time.should be < 1.0
+    end
+  end
+end

data/spec/gbrb/cartridge_spec.rb

@@ -0,0 +1,19 @@
+require_relative '../spec_helper.rb'
+
+require_relative '../../lib/gbrb/cartridge.rb'
+
+module GBRb
+  describe Cartridge do
+    it "is initialized with an IO object" do
+      c = Cartridge.new StringIO.new ""
+    end
+
+    it "separates data into banks" do
+      raw_data = StringIO.new(0x01.chr * MEMORY_BANK_SIZE + 0x02.chr * MEMORY_BANK_SIZE)
+      c = Cartridge.new raw_data
+      c.bank(0).each {|b| b.should eq 0x01}
+      c.bank(1).each {|b| b.should eq 0x02}
+    end
+  end
+end
+

data/spec/gbrb/cpu/concatenated_register_spec.rb

@@ -0,0 +1,36 @@
+require_relative '../../spec_helper'
+require_relative '../../../lib/gbrb/cpu/concatenated_register'
+require_relative '../../../lib/gbrb/cpu/register'
+
+module GBRb::CPU
+  describe ConcatenatedRegister do
+    let(:b) { Register.new }
+    let(:c) { Register.new }
+    let(:bc) { ConcatenatedRegister.new b, c}
+
+    it "#store" do
+      bc.store 0x3456
+      b.read.should eq 0x34
+      c.read.should eq 0x56
+    end
+
+    it "#read" do
+      b.store 0xab
+      c.store 0x81
+      bc.read.should eq 0xab81
+    end
+
+    it "#zero?" do
+      bc.zero?.should be_true
+      b.store 0x01
+      bc.zero?.should be_false
+    end
+
+    it "#==" do
+      a = Register.new 0x5839, 16
+      bc.should_not eq a
+      bc.store 0x5839
+      bc.should eq a
+    end
+  end
+end

data/spec/gbrb/cpu/flags_register_spec.rb

@@ -0,0 +1,91 @@
+require_relative '../../spec_helper.rb'
+require_relative '../../../lib/gbrb/cpu/flags_register.rb'
+
+module GBRb::CPU
+  describe FlagsRegister do
+    let(:f) { FlagsRegister.new }
+    context "zero flag" do
+      it "has a zero flag" do
+        f.zero_flag?.should be_false
+      end
+
+      it "can set the zero flag" do
+        f.set_zero_flag
+      end
+
+      it "correctly sets the zero flag" do
+        f.set_zero_flag
+        f.zero_flag?.should be_true
+      end
+
+      it "clears the zero flag" do
+        f.set_zero_flag
+        f.clear_zero_flag
+        f.zero_flag?.should be_false
+      end
+    end
+
+    context "add/sub flag" do
+      it "has a add_sub flag" do
+        f.add_sub_flag?.should be_false
+      end
+
+      it "can set the add_sub flag" do
+        f.set_add_sub_flag
+      end
+
+      it "correctly sets the add_sub_flag" do
+        f.set_add_sub_flag
+        f.add_sub_flag?.should be_true
+      end
+
+      it "clears the add_sub flag" do
+        f.set_add_sub_flag
+        f.clear_add_sub_flag
+        f.add_sub_flag?.should be_false
+      end
+    end
+
+    context "half carry flag" do
+      it "has a half_carry flag" do
+        f.half_carry_flag?.should be_false
+      end
+
+      it "can set the half_carry flag" do
+        f.set_half_carry_flag
+      end
+
+      it "correctly sets the half_carry flag" do
+        f.set_half_carry_flag
+        f.half_carry_flag?.should be_true
+      end
+
+      it "clears the half_carry flag" do
+        f.set_half_carry_flag
+        f.clear_half_carry_flag
+        f.half_carry_flag?.should be_false
+      end
+    end
+
+    context "carry flag" do
+      it "has a carry flag" do
+        f.carry_flag?.should be_false
+      end
+
+      it "can set the carry flag" do
+        f.set_carry_flag
+      end
+
+      it "correctly sets the carry flag" do
+        f.set_carry_flag
+        f.carry_flag?.should be_true
+      end
+
+      it "clears the carry flag" do
+        f.set_carry_flag
+        f.clear_carry_flag
+        f.carry_flag?.should be_false
+      end
+    end
+  end
+end

data/spec/gbrb/cpu/instruction_spec.rb

@@ -0,0 +1,283 @@
+require_relative '../../spec_helper'
+require_relative '../../../lib/gbrb/cpu/instruction.rb'
+require_relative '../../../lib/gbrb/cpu/register.rb'
+
+module GBRb::CPU
+  describe Instruction do
+    it "has a m time" do
+      i = Instruction.new
+      i.m.should be_true
+    end
+
+    it "has a t time" do
+      i = Instruction.new
+      i.t.should be_true
+    end
+
+    it "is callable" do
+      i = Instruction.new
+      world = double
+      i.call world, nil
+    end
+  end
+
+  describe Inc do
+    it "clears the add sub flag" do
+      fake_register = double.as_null_object
+      fake_register.stub(:store)
+      fake_register.stub(:read).and_return(1)
+      world = double.as_null_object
+      world.should_receive(:clear_add_sub_flag)
+      world.should_receive(:a).at_least(1).times.and_return(fake_register)
+      i = Inc.new :a
+      i.call world, nil
+    end
+
+    it "sets the zero flag when zero" do
+      a = Register.new 0xff
+      world = double.as_null_object
+      world.should_receive(:a).at_least(1).times.and_return(a)
+      world.should_receive(:set_zero_flag)
+      i = Inc.new :a
+      i.call world, nil
+    end
+
+    it "does not set the carry flag when value overflows register" do
+      a = Register.new 0xff
+      world = double.as_null_object
+      world.should_receive(:a).at_least(1).times.and_return(a)
+      world.should_not_receive(:set_carry_flag)
+      i = Inc.new :a
+      i.call world, nil
+    end
+
+    it "sets the half carry flag when low nibble overflows" do
+      a = Register.new 0x0f
+      world = double.as_null_object
+      world.should_receive(:a).at_least(1).times.and_return(a)
+      world.should_receive(:set_half_carry_flag)
+      world.should_not_receive(:set_carry_flag)
+      i = Inc.new :a
+      i.call world, nil
+    end
+
+    it "does not touch the flags if initialized with false" do
+      a = Register.new 0xff
+      world = double.as_null_object
+      world.should_receive(:a).at_least(1).times.and_return(a)
+      world.should_not_receive(:set_carry_flag)
+      world.should_not_receive(:set_half_carry_flag)
+      world.should_not_receive(:set_zero_flag)
+      i = Inc.new :a, 1, 4, false
+      i.call world, nil
+    end
+  end
+
+  describe Dec do
+    it "sets the add sub flag" do
+      fake_register = double.as_null_object
+      fake_register.stub(:store)
+      fake_register.stub(:read).and_return(1)
+      world = double.as_null_object
+      world.should_receive(:set_add_sub_flag)
+      world.should_receive(:a).at_least(1).times.and_return(fake_register)
+      i = Dec.new :a
+      i.call world, nil
+    end
+
+    it "sets the zero flag when zero" do
+      a = Register.new 0x01
+      world = double.as_null_object
+      world.should_receive(:a).at_least(1).times.and_return(a)
+      world.should_not_receive(:set_half_carry_flag)
+      world.should_receive(:set_zero_flag)
+      i = Dec.new :a
+      i.call world, nil
+    end
+
+    it "does not set the carry flag when value underflows register" do
+      a = Register.new 0x00
+      world = double.as_null_object
+      world.should_receive(:a).at_least(1).times.and_return(a)
+      world.should_not_receive(:set_carry_flag)
+      i = Dec.new :a
+      i.call world, nil
+    end
+
+    it "sets the half carry flag when borrowing from high nibble" do
+      a = Register.new 0x10
+      world = double.as_null_object
+      world.should_receive(:a).at_least(1).times.and_return(a)
+      world.should_receive(:set_half_carry_flag)
+      world.should_not_receive(:set_carry_flag)
+      i = Dec.new :a
+      i.call world, nil
+    end
+
+    it "does not touch the flags if initialized with false" do
+      a = Register.new 0xff
+      world = double.as_null_object
+      world.should_receive(:a).at_least(1).times.and_return(a)
+      world.should_not_receive(:set_half_carry_flag)
+      world.should_not_receive(:set_zero_flag)
+      i = Dec.new :a, 1, 4, false
+      i.call world, nil
+    end
+  end
+
+  describe Ld do
+    it "does not set any flags" do
+      b = Register.new
+      c = Register.new 0x34
+      world = double.as_null_object
+      world.should_receive(:b).at_least(1).times.and_return(b)
+      world.should_receive(:c).at_least(1).times.and_return(c)
+      world.should_not_receive(:set_half_carry_flag)
+      world.should_not_receive(:set_carry_flag)
+      world.should_not_receive(:set_add_sub_flag)
+      world.should_not_receive(:set_zero_flag)
+      i = Ld.new :b, :c
+      i.call world, nil
+    end
+  end
+
+  describe Add do
+    it "clears the add sub flag" do
+      a = Register.new 0x34
+      world = double.as_null_object
+      world.should_receive(:clear_add_sub_flag)
+      world.should_receive(:a).at_least(1).times.and_return(a)
+      i = Add.new :a
+      i.call world, nil
+    end
+
+    it "sets the zero flag when zero" do
+      a = Register.new 0x80
+      world = double.as_null_object
+      world.should_receive(:a).at_least(1).times.and_return(a)
+      world.should_receive(:set_zero_flag)
+      i = Add.new :a
+      i.call world, nil
+      i.call world, nil
+    end
+
+    it "sets the carry flag when value overflows register" do
+      a = Register.new 0xff
+      world = double.as_null_object
+      world.should_receive(:a).at_least(1).times.and_return(a)
+      i = Add.new :a
+      i.call world, nil
+      i.call world, nil
+    end
+
+    it "sets the half carry flag when low nibble overflows" do
+      a = Register.new 0x0d
+      world = double.as_null_object
+      world.should_receive(:a).at_least(1).times.and_return(a)
+      world.should_receive(:set_half_carry_flag)
+      world.should_not_receive(:set_carry_flag)
+      i = Add.new :a
+      i.call world, nil
+    end
+  end
+
+  describe Sub do
+    it "sets the add sub flag" do
+      a = Register.new 0x34
+      world = double.as_null_object
+      world.should_receive(:set_add_sub_flag)
+      world.should_receive(:a).at_least(1).times.and_return(a)
+      i = Sub.new :a
+      i.call world, nil
+    end
+
+    it "sets the zero flag when zero" do
+      a = Register.new 0x80
+      world = double.as_null_object
+      world.should_receive(:a).at_least(1).times.and_return(a)
+      world.should_receive(:set_zero_flag)
+      i = Sub.new :a
+      i.call world, nil
+      i.call world, nil
+    end
+
+    it "sets the carry flag when value underflows register" do
+      a = Register.new 0x00
+      world = double.as_null_object
+      world.should_receive(:a).at_least(1).times.and_return(a)
+      i = Sub.new :a
+      i.call world, nil
+    end
+
+    it "sets the half carry flag when borrowing from high nibble" do
+      a = Register.new 0x10
+      b = Register.new 0x01
+      world = double.as_null_object
+      world.should_receive(:a).at_least(1).times.and_return(a)
+      world.should_receive(:b).at_least(1).times.and_return(b)
+      world.should_receive(:set_half_carry_flag)
+      world.should_not_receive(:set_carry_flag)
+      i = Sub.new :b
+      i.call world, nil
+    end
+  end
+
+  describe Cp do
+    it "does not modify the accumulator" do
+      a = Register.new 0x1f
+      b = Register.new 0x3b
+      world = double.as_null_object
+      world.stub(a: a)
+      world.stub(b: b)
+      a.should_not_receive(:store)
+      b.should_not_receive(:store)
+      i = Cp.new :b
+      i.call world, nil
+    end
+  end
+
+  describe And do
+    it "sets the correct flags" do
+      a = Register.new 0x73
+      b = Register.new 0xd2
+      world = double.as_null_object
+      world.stub(:a).and_return(a)
+      world.stub(:b).and_return(b)
+      world.should_receive :clear_add_sub_flag
+      world.should_receive :set_half_carry_flag
+      world.should_receive :clear_carry_flag
+      i = And.new :a, :b
+      i.call world, nil
+    end
+  end
+
+  describe Or do
+    it "sets the correct flags" do
+      a = Register.new 0x81
+      b = Register.new 0xaf
+      world = double.as_null_object
+      world.stub(:a).and_return(a)
+      world.stub(:b).and_return(b)
+      world.should_receive :clear_add_sub_flag
+      world.should_receive :clear_half_carry_flag
+      world.should_receive :clear_carry_flag
+      i= Or.new :a, :b
+      i.call world, nil
+    end
+  end
+
+  describe Xor do
+    it "sets the correct flags" do
+      a = Register.new 0x81
+      b = Register.new 0xaf
+      world = double.as_null_object
+      world.stub(:a).and_return(a)
+      world.stub(:b).and_return(b)
+      world.should_receive :clear_add_sub_flag
+      world.should_receive :clear_half_carry_flag
+      world.should_receive :clear_carry_flag
+      i= Xor.new :a, :b
+      i.call world, nil
+    end
+  end
+end