GBRb 0.1.0 → 0.2.0

data/spec/gbrb/instruction_set/boolean_spec.rb

@@ -0,0 +1,50 @@
+require_relative '../../spec_helper'
+require_relative '../../../lib/gbrb/instruction_set/boolean.rb'
+require_relative '../../../lib/gbrb/cpu/register.rb'
+
+module GBRb::InstructionSet
+  describe And do
+    it "sets the correct flags" do
+      a = GBRb::CPU::Register.new 0x73
+      b = GBRb::CPU::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 = GBRb::CPU::Register.new 0x81
+      b = GBRb::CPU::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 = GBRb::CPU::Register.new 0x81
+      b = GBRb::CPU::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

data/spec/gbrb/instruction_set/instruction_spec.rb

@@ -0,0 +1,22 @@
+require_relative '../../spec_helper'
+require_relative '../../../lib/gbrb/instruction_set/instruction.rb'
+
+module GBRb::InstructionSet
+  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
+end

data/spec/gbrb/instruction_set/ld_spec.rb

@@ -0,0 +1,21 @@
+require_relative '../../spec_helper'
+require_relative '../../../lib/gbrb/instruction_set/ld.rb'
+require_relative '../../../lib/gbrb/cpu/register.rb'
+
+module GBRb::InstructionSet
+  describe Ld do
+    it "does not set any flags" do
+      b = GBRb::CPU::Register.new
+      c = GBRb::CPU::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
+end

data/spec/gbrb/instruction_set/special_spec.rb

@@ -0,0 +1,22 @@
+require_relative '../../spec_helper'
+require_relative '../../../lib/gbrb/instruction_set/special.rb'
+
+module GBRb::InstructionSet
+  describe EnableInterrupts do
+    it "sets interrupts to enabled" do
+      c = double
+      c.should_receive(:interrupts=).with(:enabled).once
+      ei = EnableInterrupts.new
+      ei.call c
+    end
+  end
+
+  describe DisableInterrupts do
+    it "sets interrupts to disabled" do
+      c = double
+      c.should_receive(:interrupts=).with(:disabled).once
+      di = DisableInterrupts.new
+      di.call c
+    end
+  end
+end

data/spec/gbrb/mmu_spec.rb

@@ -46,7 +46,7 @@ module GBRb
     end
 
     context "bios" do
-      let(:m) { MMU.new (0..0xff).to_a, :none}
+      let(:m) { MMU.new (0..0xff).to_a }
 
       it "is loaded on initialize" do
         (0..0xff).each {|i| m.read_byte(i).should eq i}

data/spec/gbrb/timer_spec.rb

@@ -0,0 +1,26 @@
+require_relative '../spec_helper'
+require_relative '../../lib/gbrb/timer'
+
+module GBRb
+  describe Timer do
+    let(:t) { Timer.new }
+
+    context "registers" do
+      it "has a div counter" do
+        t.div
+      end
+
+      it "has a counter counter" do
+        t.tima
+      end
+
+      it "has a modulo register" do
+        t.tma
+      end
+
+      it "has a control register" do
+        t.tac
+      end
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: GBRb
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Casey Robinson
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-09-01 00:00:00.000000000 Z
+date: 2013-10-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -83,15 +83,29 @@ files:
 - Rakefile
 - bin/display
 - bin/gbrb
+- doc/images/blargg_cpu.png
+- doc/images/cpu_01.png
+- doc/images/cpu_03.png
+- doc/images/cpu_04.png
+- doc/images/cpu_05.png
+- doc/images/cpu_06.png
+- doc/images/cpu_07.png
+- doc/images/cpu_08.png
+- doc/images/cpu_09.png
+- doc/images/cpu_10.png
+- doc/images/cpu_11.png
 - doc/images/nintendo_logo.png
+- doc/images/opus5.png
+- doc/images/test.gb.png
+- doc/images/ttt.png
 - gbrb.gemspec
 - lib/gbrb.rb
 - lib/gbrb/bios
 - lib/gbrb/cartridge.rb
+- lib/gbrb/cartridge/cartridge.rb
 - lib/gbrb/cpu.rb
 - lib/gbrb/cpu/concatenated_register.rb
 - lib/gbrb/cpu/flags_register.rb
-- lib/gbrb/cpu/instruction.rb
 - lib/gbrb/cpu/register.rb
 - lib/gbrb/cpu/register_ensemble.rb
 - lib/gbrb/cpu/z80.rb
@@ -101,19 +115,44 @@ files:
 - lib/gbrb/graphics/mode_clock.rb
 - lib/gbrb/graphics/screen_client.rb
 - lib/gbrb/graphics/screen_server.rb
+- lib/gbrb/instruction_set.rb
+- lib/gbrb/instruction_set/arithmetic.rb
+- lib/gbrb/instruction_set/bitwise.rb
+- lib/gbrb/instruction_set/boolean.rb
+- lib/gbrb/instruction_set/call.rb
+- lib/gbrb/instruction_set/carry.rb
+- lib/gbrb/instruction_set/cpl.rb
+- lib/gbrb/instruction_set/daa.rb
+- lib/gbrb/instruction_set/instruction.rb
+- lib/gbrb/instruction_set/jump.rb
+- lib/gbrb/instruction_set/ld.rb
+- lib/gbrb/instruction_set/return.rb
+- lib/gbrb/instruction_set/rotate.rb
+- lib/gbrb/instruction_set/rst.rb
+- lib/gbrb/instruction_set/special.rb
+- lib/gbrb/instruction_set/stack.rb
+- lib/gbrb/instruction_set/swap.rb
 - lib/gbrb/mmu.rb
+- lib/gbrb/options.rb
+- lib/gbrb/timer.rb
 - lib/gbrb/version.rb
+- misc/dump_diff
 - misc/parse_tiles
 - perf/cpu_perf_spec.rb
-- spec/gbrb/cartridge_spec.rb
+- spec/gbrb/cartridge/cartridge_spec.rb
+- spec/gbrb/cartridge/mbc1_spec.rb
 - spec/gbrb/cpu/concatenated_register_spec.rb
 - spec/gbrb/cpu/flags_register_spec.rb
-- spec/gbrb/cpu/instruction_spec.rb
 - spec/gbrb/cpu/register_ensemble_spec.rb
 - spec/gbrb/cpu/register_spec.rb
 - spec/gbrb/cpu/z80_spec.rb
-- spec/gbrb/graphics/mode_clock_spec.rb
+- spec/gbrb/instruction_set/arithmetic_spec.rb
+- spec/gbrb/instruction_set/boolean_spec.rb
+- spec/gbrb/instruction_set/instruction_spec.rb
+- spec/gbrb/instruction_set/ld_spec.rb
+- spec/gbrb/instruction_set/special_spec.rb
 - spec/gbrb/mmu_spec.rb
+- spec/gbrb/timer_spec.rb
 - spec/gbrb/version_spec.rb
 - spec/spec_helper.rb
 homepage: http://rampantmonkey.github.io/GBRb
@@ -141,14 +180,19 @@ signing_key:
 specification_version: 4
 summary: Nintendo Game Boy Emulator
 test_files:
-- spec/gbrb/cartridge_spec.rb
+- spec/gbrb/cartridge/cartridge_spec.rb
+- spec/gbrb/cartridge/mbc1_spec.rb
 - spec/gbrb/cpu/concatenated_register_spec.rb
 - spec/gbrb/cpu/flags_register_spec.rb
-- spec/gbrb/cpu/instruction_spec.rb
 - spec/gbrb/cpu/register_ensemble_spec.rb
 - spec/gbrb/cpu/register_spec.rb
 - spec/gbrb/cpu/z80_spec.rb
-- spec/gbrb/graphics/mode_clock_spec.rb
+- spec/gbrb/instruction_set/arithmetic_spec.rb
+- spec/gbrb/instruction_set/boolean_spec.rb
+- spec/gbrb/instruction_set/instruction_spec.rb
+- spec/gbrb/instruction_set/ld_spec.rb
+- spec/gbrb/instruction_set/special_spec.rb
 - spec/gbrb/mmu_spec.rb
+- spec/gbrb/timer_spec.rb
 - spec/gbrb/version_spec.rb
 - spec/spec_helper.rb

data/lib/gbrb/cpu/instruction.rb

@@ -1,648 +0,0 @@
-require_relative '../cpu'
-
-module GBRb::CPU
-  class Instruction
-    attr_reader :i, :m, :t
-
-    def initialize m=1, t=4, immediates=0, *extra
-      @m = m
-      @t = t
-      @immediates = immediates
-    end
-
-    def immediate_count
-      @immediates
-    end
-
-    def call r, mem
-      nil
-    end
-
-    def carry? left, right, mask
-      (mask-1 & left).public_send(@op, mask-1 & right) & mask == mask
-    end
-  end
-
-  class Stop < Instruction; end
-
-  class Scf < Instruction
-    def call r, mem
-      r.clear_half_carry_flag
-      r.clear_add_sub_flag
-      r.set_carry_flag
-    end
-  end
-
-  class Cpl < Instruction
-    def call r, mem
-      r.set_add_sub_flag
-      r.set_half_carry_flag
-      r.a.store r.a.read ^ 0xff
-    end
-  end
-
-  class Ccf < Instruction
-    def call r, mem
-      if r.carry_flag?
-        r.clear_carry_flag
-      else
-        r.set_carry_flag
-      end
-      r.clear_add_sub_flag
-      r.clear_half_carry_flag
-    end
-  end
-
-  class Inc < Instruction
-    def initialize register, m=1, t=4, flags=true, indirect=false
-      super m, t
-
-      @register = register
-      @flags = flags
-      @op = :+
-      @indirect = indirect
-    end
-
-    def call r, mem
-      reg = r.public_send(@register.to_sym)
-      tmp = reg.read
-      if @indirect
-        v = mem.read_byte(tmp) + 1
-        mem.write_byte(tmp, v)
-      else
-        reg.store tmp + 1
-      end
-      if @flags
-        r.clear_add_sub_flag
-        reg.zero? ? r.set_zero_flag : r.clear_zero_flag
-        if carry? tmp, 0x01, reg.half_mask
-          r.set_half_carry_flag
-        else
-          r.clear_half_carry_flag
-        end
-      end
-    end
-  end
-
-  class Dec < Instruction
-    def initialize register, m=1, t=4, flags=true, indirect=false
-      super m, t
-
-      @register = register
-      @flags = flags
-      @op = :-
-      @indirect = indirect
-    end
-
-    def call r, mem
-      reg = r.public_send(@register.to_sym)
-      tmp = reg.read
-      if @indirect
-        v = mem.read_byte(tmp) - 1
-        mem.write_byte(tmp, v)
-      else
-        reg.store tmp - 0x01
-      end
-      if @flags
-        r.set_add_sub_flag
-        if reg.zero?
-          r.set_zero_flag
-        else
-          r.clear_zero_flag
-        end
-        if carry? tmp, 0x01, reg.half_mask
-          r.set_half_carry_flag
-        else
-          r.clear_half_carry_flag
-        end
-      end
-    end
-  end
-
-  class Ld < Instruction
-    def initialize destination, target, m=1, t=4, indirect_dest=false, indirect_target=false, immediates=0, offset=0x00
-      super m, t, immediates
-
-      @destination = destination
-      @target = target
-      @indirect_dest = indirect_dest
-      @indirect_target = indirect_target
-      @offset = offset
-    end
-
-    def call r, mem, v=nil
-      if not v
-        v = r.public_send(@target.to_sym).read
-      end
-
-      if @indirect_target
-        v = mem.read_byte(v + @offset)
-        target_reg = r.public_send(@destination.to_sym)
-        if @indirect_target == :increment
-          target_reg.store target_reg.read + 1
-        elsif @indirect_target == :decrement
-          target_reg.store target_reg.read - 1
-        end
-      end
-
-
-      if @indirect_dest
-        if @indirect_dest == :immediate
-          if @target.to_s.chars.length == 2
-            mem.write_word(v + @offset, r.public_send(@target.to_sym).read)
-          else
-            mem.write_byte(v + @offset, r.public_send(@target.to_sym).read)
-          end
-        else
-          reg = r.public_send(@destination.to_sym)
-          mem.write_byte(reg.read + @offset, v)
-          if @indirect_dest == :increment
-            reg.store reg.read + 1
-          elsif @indirect_dest == :decrement
-            reg.store reg.read - 1
-          end
-        end
-      else
-        r.public_send(@destination.to_sym).store v
-      end
-    end
-  end
-
-  class Ldh < Ld
-    def call r, mem, address
-      if @indirect_dest
-        value = r.public_send(@target.to_sym).read
-        mem.write_byte address + @offset, value
-      elsif @indirect_target
-        value = mem.read_byte address + @offset
-        r.public_send(@destination.to_sym).store value
-      end
-    end
-  end
-
-  class Ldhlsp < Instruction
-    def initialize m=2, t=12, immediates=1
-      super
-      @op = :+
-    end
-
-    def call r, mem, offset
-      sign = (offset >> 7 == 1) ? :- : :+
-      offset = ((offset ^ 0xff) + 1) & 0xff
-      value = r.sp.read.public_send(sign, offset)
-      r.hl.store value
-      r.clear_zero_flag
-      r.clear_add_sub_flag
-      carry?(value, 0x00, r.hl.mask) ? r.set_carry_flag : r.clear_carry_flag
-      carry?(value, 0x00, r.hl.half_mask) ? r.set_half_carry_flag : r.clear_half_carry_flag
-    end
-  end
-
-  class Jump < Instruction
-    def initialize condition, m=2, t_high=12, t_low=8, immediates=1
-      super m, t_low, immediates
-      @t_high = t_high
-      @condition = condition.downcase.to_sym
-    end
-
-    def call r, mem, offset
-      do_it = case @condition
-              when :c
-                r.carry_flag?
-              when :none
-                true
-              when :nc
-                not r.carry_flag?
-              when :nz
-                not r.zero_flag?
-              when :z
-                r.zero_flag?
-              else
-                false
-              end
-
-      if do_it
-        @t = @t_high
-        if @immediates == 1
-          sign = (offset >> 7 == 1) ? :- : :+
-          offset = ((offset ^ 0xff) + 1) & 0xff if sign == :-
-          r.pc.store r.pc.read.public_send(sign, offset)
-        else
-          r.pc.store offset
-        end
-      end
-    end
-  end
-
-  class Rl < Instruction
-    def initialize target, carry=false, indirect=false, m=2, t=8
-      super m, t
-      @target = target.to_sym
-      @carry = carry
-      @indirect = indirect
-    end
-
-    def call r, mem
-      if @indirect
-        address = r.public_send(@target).read
-        v = mem.read_byte(address) << 1
-      else
-        v = r.public_send(@target).read << 1
-      end
-
-      carry_in = if @carry
-                   v & 0x100 == 0x100 ? 1 : 0
-                 else
-                   r.carry_flag? ? 1 : 0
-                 end
-
-      v += carry_in
-
-      if @indirect
-        mem.write_byte(address, v)
-      else
-        r.public_send(@target).store v
-      end
-
-      r.clear_add_sub_flag
-      r.clear_half_carry_flag
-      v & 0xff == 0 ? r.set_zero_flag : r.clear_zero_flag
-      carry_out = v >> 8
-      carry_out == 1 ? r.set_carry_flag : r.clear_carry_flag
-    end
-  end
-
-  class Rr < Instruction
-    def initialize target, carry=false, indirect=false, m=2, t=8
-      super m, t
-      @target = target.to_sym
-      @carry = carry
-      @indirect = indirect
-    end
-
-    def call r, mem
-      if @indirect
-        address = r.public_send(@target).read
-        v = mem.read_byte(address)
-      else
-        v = r.public_send(@target).read
-      end
-
-      carry_out = v & 0x01
-
-      carry_in = if @carry
-                   carry_out
-                 else
-                   r.carry_flag? ? 1 : 0
-                 end
-
-      v >>= 1
-
-      v += carry_in << 7
-
-      if @indirect
-        original = mem.read_byte address
-        mem.write_byte(address, v)
-      else
-        r.public_send(@target).store v
-      end
-
-      r.clear_add_sub_flag
-      r.clear_half_carry_flag
-      v & 0xff == 0 ? r.set_zero_flag : r.clear_zero_flag
-      carry_out == 1 ? r.set_carry_flag : r.clear_carry_flag
-    end
-  end
-
-  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
-
-  class Arithmetic < Instruction
-    def initialize target, m, t, indirect, immediates=0
-      super m, t, immediates
-      @target = target
-      @indirect = indirect
-    end
-
-    def carry? left, right, mask
-      (mask-1 & left).public_send(@op, mask-1 & right) & mask == mask
-    end
-
-    def call r, mem, right_value
-      right_value ||= r.public_send(@target.to_sym).read
-      right_value = mem.read_byte(right_value) if @indirect
-      a_value = r.a.read
-      if carry? a_value, right_value, r.a.half_mask
-        r.set_half_carry_flag
-      else
-        r.clear_half_carry_flag
-      end
-      if carry? a_value, right_value, r.a.mask
-          r.set_carry_flag
-      else
-        r.clear_carry_flag
-      end
-      a_value = a_value.public_send(@op, right_value) & 0xff
-      r.a.store a_value unless @skip_store
-      a_value == 0x00 ? r.set_zero_flag : r.clear_zero_flag
-    end
-  end
-
-  class Add < Arithmetic
-    def initialize target, m=1, t=4, indirect=false, immediates=0
-      super
-      @op = :+
-    end
-
-    def call r, mem, right_value=nil
-      super
-      r.clear_add_sub_flag
-    end
-  end
-
-  class AddHl < Instruction
-    def initialize target, m=1, t=8
-      super m, t
-      @target = target.to_sym
-      @op = :+
-    end
-
-    def call r, mem
-      left = r.hl.read
-      right = r.public_send(@target).read
-      r.hl.store left + right
-      r.set_carry_flag if carry? left, right, r.hl.mask
-      r.set_half_carry_flag if carry? left, right, r.hl.half_mask
-    end
-  end
-
-  class Sub < Arithmetic
-    def initialize target, m=1, t=4, indirect=false, immediates=0
-      super
-      @op = :-
-    end
-
-    def call r, mem, right_value=nil
-      super
-      r.set_add_sub_flag
-    end
-  end
-
-  class Cp < Sub
-    def initialize *args
-      super
-      @skip_store = true
-    end
-  end
-
-  class Adc < Add
-    def call r, mem, right_value=nil
-      carry = r.carry_flag? ? 1 : 0
-      super r, mem, r.public_send(@target.to_sym).read + carry
-    end
-  end
-
-  class Sbc < Sub
-    def call r, mem, right_value=nil
-      carry = r.carry_flag? ? 1 : 0
-      super r, mem, r.public_send(@target.to_sym).read + carry
-    end
-  end
-
-  class Boolean < Instruction
-    def initialize target, m, t, indirect, immediates=0
-      @target = target
-      @indirect = indirect
-      super m, t, immediates
-    end
-
-    def call r, mem, v=nil
-      if v
-        value = v
-      else
-        value = r.public_send(@target.to_sym).read
-        value = mem.read_byte value if @indirect
-      end
-      r.a.store r.a.read.public_send(@op, value)
-      r.a.zero? ? r.set_zero_flag : r.clear_zero_flag
-      r.clear_carry_flag
-      r.clear_add_sub_flag
-    end
-  end
-
-  class And < Boolean
-    def initialize target, m=1, t=4, indirect=false, immediates=0
-      @op = :&
-      super
-    end
-
-    def call r, mem, v=nil
-      super
-      r.set_half_carry_flag
-    end
-  end
-
-  class Or < Boolean
-    def initialize target, m=1, t=4, indirect=false
-      @op = :|
-      super
-    end
-
-    def call r, mem
-      super
-      r.clear_half_carry_flag
-    end
-  end
-
-  class Xor < Boolean
-    def initialize target, m=1, t=4, indirect=false, immediates=0
-      @op = :^
-      super
-    end
-
-    def call r, mem, right_value=nil
-      super
-      r.clear_half_carry_flag
-    end
-  end
-
-  class Pop < Instruction
-    def initialize target, m=1, 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
-    end
-  end
-
-  class Push < Instruction
-    def initialize target, m=1, 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
-
-  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
-
-  class Call < Instruction
-    def initialize m=3, t=24, immediates=2, condition=:none
-      @condition = condition
-      super
-    end
-
-    def call r, mem, addr
-      condition_met = case @condition
-                      when :Z
-                        r.zero_flag?
-                      when :none
-                        true
-                      else
-                        false
-                      end
-      if condition_met
-        r.sp.store r.sp.read - 2
-        mem.write_word(r.sp.read, r.pc.read)
-        r.pc.store addr
-      end
-    end
-  end
-
-  class Ret < Instruction
-    def initialize m=1, t=16, t_high=16, condition=:none
-      @condition = condition
-      @t_high = t_high
-      super m, t, 0
-    end
-
-    def call r, mem
-      condition_met = case @condition
-                      when :NZ
-                        not r.zero_flag?
-                      when :none
-                        true
-                      else
-                        false
-                      end
-      if condition_met
-        @t = @t_high
-        low = mem.read_byte(r.sp.read)
-        r.sp.store r.sp.read + 1
-        high = mem.read_byte(r.sp.read)
-        r.sp.store r.sp.read + 1
-
-        r.pc.store (high << 8) + low
-      end
-    end
-  end
-
-  class EnableInterrupts < Instruction; end
-  class DisableInterrupts < Instruction; end
-
-  class Res < Instruction
-    def initialize bit, target, indirect=false, m=2, t=16
-      super m, t
-      @bit = bit
-      @mask = 0xff - 0b10 ** bit
-      @target = target.to_sym
-      @indirect = indirect
-    end
-
-    def call r, mem
-      if @indirect
-        addr = r.public_send(@target).read
-        mem.write_byte(addr, mem.read_byte(addr) & @mask)
-      else
-        r.public_send(@target).store r.public_send(@target).read & @mask
-      end
-    end
-  end
-
-  class Set < Instruction
-    def initialize bit, target, indirect=false, m=2, t=16
-      super m, t
-      @bit = bit
-      @mask = 0b10 ** bit
-      @target = target.to_sym
-      @indirect = indirect
-    end
-
-    def call r, mem
-      if @indirect
-        addr = r.public_send(@target).read
-        mem.write_byte(addr, mem.read_byte(addr) | @mask)
-      else
-        r.public_send(@target).store r.public_send(@target).read | @mask
-      end
-    end
-  end
-
-  class Bit < Instruction
-    def initialize bit, target, indirect=false, m=2, t=8
-      super m,t
-      @target = target
-      @bit = bit
-      @indirect = indirect
-      @mask = 1 << @bit
-    end
-
-    def call r, mem
-      if @indirect
-        v = mem.read_byte r.public_send(@target).read
-      else
-        v = r.public_send(@target).read
-      end
-
-      v & @mask != @mask ? r.set_zero_flag : r.clear_zero_flag
-      r.set_half_carry_flag
-      r.clear_add_sub_flag
-    end
-  end
-end