zombie-chaser 0.0.3 → 0.1.0

data/lib/zombie-chaser/test_unit_handler.rb

@@ -0,0 +1,78 @@
+require "test/unit/collector/objectspace"
+require "test/unit/ui/testrunnermediator"
+
+require "thread"
+
+class TestUnitHandler
+  attr_reader :test_suite_size, :result_queue
+
+  def initialize(test_pattern)
+    raise "Error: can't detect any files in test pattern #{test_pattern.inspect} (Don't forget to use forward slashes even in Windows)" if Dir.glob(test_pattern).empty?
+    Dir.glob(test_pattern).each {|test| require test} #In heckle, this is separated out
+    obj_sp = Test::Unit::Collector::ObjectSpace.new
+    test_suite = Test::Unit::TestSuite.new("Mutation slayer test suite")
+    test_suite << obj_sp.collect
+    @test_suite_size = test_suite.size
+    @test_runner_mediator =  Test::Unit::UI::TestRunnerMediator.new(test_suite)
+    @test_runner_mediator.add_listener(Test::Unit::TestResult::FAULT) {test_failed}
+    @test_runner_mediator.add_listener(Test::Unit::TestCase::FINISHED) {test_finished}
+    @result_queue = Queue.new
+    @failure_encountered = false
+  end
+
+  def run
+    begin
+      catch(:stop_test_runner) do
+        @test_runner_mediator.run_suite
+      end
+    rescue Chaser::Timeout
+      @result_queue.enq(:failure)
+      raise
+    ensure
+      @result_queue.enq(:end_of_work)
+    end
+    not @failure_encountered
+  end
+
+  def test_failed
+    @result_queue.enq(:failure)
+    @failure_encountered = true
+    throw :stop_test_runner
+  end
+
+  def test_finished
+    @result_queue.enq(:pass)
+  end
+
+end
+
+class MockTestHandler
+  attr_reader :result_queue
+
+  def initialize(results)
+    @results = results
+    @result_queue = Queue.new
+    @failure_encountered = false
+  end
+
+  def test_suite_size
+    @results.size
+  end
+
+  def run
+    begin
+      @results.each do |result|
+        raise Timeout::Error, "Out of time" if result == :timeout
+        @result_queue.enq(result)
+        if result == :failure
+          @failure_encountered = true
+          break
+        end
+      end
+    ensure
+      @result_queue.enq(:end_of_work)
+    end
+    not @failure_encountered
+  end
+
+end

data/{ui → lib/zombie-chaser}/ui.rb

@@ -1,127 +1,165 @@
-require 'gosu'
-
-class ZIndex
-  LAYERS = [:world, :dead, :human, :zombie, :overlay]
-
-  def self.for(type); LAYERS.index(type) end
-end
-
-class Actor
-
-  def self.window=(window); @window = window end
-  def self.window; @window end
-
-  def self.sprites
-    @sprites ||=  Dir[File.join(File.dirname(__FILE__),'sprites/*.png')].inject({}) do |sprites,f|
-      sprite = File.basename(f,'.*').split('-')
-      sprites[sprite.first] ||= {}
-      sprites[sprite.first][sprite.last] = Gosu::Image.new(window, f, false)
-      sprites
-    end
-  end
-
-  def image
-    #self.class.sprites['robot']['idle'] #FIXME adjust this to indicate human versus zombie, and status of alive, dying or dead
-    self.class.sprites[actor_type][actor_state]
-  end
-
-  def actor_type
-    raise NotImplementedError
-  end
-
-  def draw
-    image.draw_rot(x, y, z, actor_direction)
-  end
-
-  def x
-    max_position = Window.width - 10
-    left_offset = 10
-    left_offset + ((@successful_step_count * 10) * (max_position - left_offset) / [test_suite_size * 10 + 10, (max_position - left_offset)].max).round
-  end
-
-  def y
-    100
-  end
-
-  def z
-    #(data['state'] == 'dead') ? ZIndex.for(:dead) : ZIndex.for(data['type'].to_sym)
-    ZIndex.for(:human)
-  end
-
-  def window
-    self.class.window
-  end
-end
-
-class Window < Gosu::Window
-  @width = 400
-  @height = 300
-
-  def self.width=(width); @width = width end
-  def self.width; @width end
-
-  def self.height=(height); @height = height end
-  def self.height; @height end
-
-  attr_accessor :grid
-  attr_writer :human, :current_zombie
-
-  def initialize
-    super(self.class.width, self.class.height, false)
-
-    self.caption = 'Zombie-chaser'
-    self.grid = 1
-
-    @grass     = Gosu::Image.new(self, File.join(File.dirname(__FILE__),'tiles/grass.png'), true)
-    @shrubbery = Gosu::Image.new(self, File.join(File.dirname(__FILE__),'tiles/shrubbery.png'), true)
-  end
-
-  def draw
-    draw_scenery
-    draw_human
-    draw_zombie
-  end
-
-  def button_down(id)
-    close if id == Gosu::Button::KbEscape
-  end
-
-# private
-
-  def tile_positions
-    w, h = @grass.width, @grass.height
-    @tile_positions ||= {
-      :x => (0...width).to_a.inject([]) {|a,x| a << x if x % w == 0; a},
-      :y => (0...height).to_a.inject([]) {|a,y| a << y if y % h == 0; a}
-    }
-  end
-
-  def map
-    @map ||= tile_positions[:y].map do |y|
-      tile_positions[:x].map do |x|
-        {
-          :x => x,
-          :y => y,
-          :tile => (rand(32) % 32 == 0) ? @shrubbery : @grass
-        }
-      end
-    end
-  end
-
-  def draw_scenery
-    map.each do |row|
-      row.each do |col|
-        col[:tile].draw(col[:x], col[:y], ZIndex.for(:world))
-      end
-    end
-  end
-
-  def draw_human
-    @human.draw
-  end
-
-  def draw_zombie
-    @current_zombie.draw if defined?(@current_zombie)
-  end
-
-end
+begin
+  require 'gosu'
+rescue LoadError => e
+  require 'ostruct'
+  module Gosu
+    class Window
+      attr_accessor :caption, :grid
+      def initialize(one, two, three)
+        abort "Gosu not installed. Please use the --console option, or install gosu"
+      end
+    end
+
+    class Image
+      def initialize(*args)
+      end
+    end
+  end
+end
+
+class ZIndex
+  LAYERS = [:world, :dead, :actor, :attacking, :overlay]
+
+  def self.for(type); LAYERS.index(type) end
+end
+
+class Actor
+
+  def self.window=(window); @window = window end
+  def self.window; @window end
+
+  def self.sprites
+    @sprites ||=  Dir[File.join(File.dirname(__FILE__),'sprites/*.png')].inject({}) do |sprites,f|
+      sprite = File.basename(f,'.*').split('-')
+      sprites[sprite.first] ||= {}
+      sprites[sprite.first][sprite.last] = Gosu::Image.new(window, f, false)
+      sprites
+    end
+  end
+
+  def image
+    #self.class.sprites['robot']['idle'] #FIXME adjust this to indicate human versus zombie, and status of alive, dying or dead
+    self.class.sprites[actor_type][actor_state]
+  end
+
+  def actor_type
+    raise NotImplementedError
+  end
+
+  def draw
+    raise "actor is off the screen" unless (x > 0 and x < self.class.window.width and y > 0 and y < self.class.window.height)
+    image.draw_rot(x, y, z, actor_direction)
+  end
+
+  def calculate_x(successful_step_count)
+    preferred_step_size = 10
+    max_distance = ([Window.width, Window.height].min / 2) - preferred_step_size
+    (Window.width / 2) + Math::sin(@angle) * ((test_suite_size - successful_step_count) * preferred_step_size) * [1, max_distance * 1.0 / (test_suite_size * preferred_step_size)].min
+  end
+
+  def calculate_y(successful_step_count)
+    preferred_step_size = 10
+    max_distance = ([Window.width, Window.height].min / 2) - preferred_step_size
+    ((Window.height / 2) + Math::cos(@angle) * ((test_suite_size - successful_step_count) * preferred_step_size) * [1, max_distance * 1.0 / (test_suite_size * preferred_step_size)].min)
+  end
+
+  def x
+    calculate_x(@successful_step_count)
+  end
+
+  def y
+    calculate_y(@successful_step_count)
+  end
+
+  def z
+    case actor_state
+    when "dead" then ZIndex.for(:dead)
+    when "attacking" then ZIndex.for(:attacking)
+    when "moving" then ZIndex.for(:actor)
+    when "dying" then ZIndex.for(:actor)
+    else raise "Unknown state"
+    end
+  end
+
+  def window
+    self.class.window
+  end
+end
+
+class Window < Gosu::Window
+  @width = 400
+  @height = 300
+
+  def self.width=(width); @width = width end
+  def self.width; @width end
+
+  def self.height=(height); @height = height end
+  def self.height; @height end
+
+  attr_accessor :grid
+  attr_writer :human, :zombie_list
+
+  def initialize
+    super(self.class.width, self.class.height, false)
+
+    self.caption = 'Zombie-chaser'
+    self.grid = 1
+
+    @grass     = Gosu::Image.new(self, File.join(File.dirname(__FILE__),'tiles/grass.png'), true)
+    @shrubbery = Gosu::Image.new(self, File.join(File.dirname(__FILE__),'tiles/shrubbery.png'), true)
+  end
+
+  def draw
+    draw_scenery
+    draw_human
+    draw_zombies
+  end
+
+  def button_down(id)
+    close if id == Gosu::Button::KbEscape
+  end
+
+# private
+
+  def tile_positions
+    w, h = @grass.width, @grass.height
+    @tile_positions ||= {
+      :x => (0...width).to_a.inject([]) {|a,x| a << x if x % w == 0; a},
+      :y => (0...height).to_a.inject([]) {|a,y| a << y if y % h == 0; a}
+    }
+  end
+
+  def map
+    @map ||= tile_positions[:y].map do |y|
+      tile_positions[:x].map do |x|
+        {
+          :x => x,
+          :y => y,
+          :tile => (rand(32) % 32 == 0) ? @shrubbery : @grass
+        }
+      end
+    end
+  end
+
+  def draw_scenery
+    map.each do |row|
+      row.each do |col|
+        col[:tile].draw(col[:x], col[:y], ZIndex.for(:world))
+      end
+    end
+  end
+
+  def draw_human
+    @human.draw if defined?(@human)
+  end
+
+  def draw_zombies
+    @zombie_list.draw_zombies if defined?(@zombie_list)
+  end
+
+  #No longer a major issue now zombies approach from all directions in GUI mode
+  def no_living_zombies_apart_from_me?(desired_step_count, actor)
+    true
+  end
+
+end

data/lib/{world.rb → zombie-chaser/world.rb}

@@ -1,98 +1,105 @@
-require "human"
-require "interface"
-
-class World
-  @interface_type = :gui_interface
-
-  def self.interface_type=(interface_type); @interface_type = interface_type end
-  def self.interface_type; @interface_type end
-
-  attr_reader :interface
-
-  def self.new_using_results(human_results, zombies_results)
-    world = new(:no_interface)
-    human = MockHuman.new_using_results(human_results, world)
-    zombie_list = MockZombieList.new_using_results(zombies_results, world)
-    world.set_human(human)
-    world.set_zombie_list(zombie_list)
-    world
-  end
-
-  def self.new_using_test_unit_handler(test_pattern)
-    world = new(self.interface_type)
-    human = Human.new_using_test_unit_handler(test_pattern, world)
-    zombie_list = MockZombieList.new_using_results([], world) #Fixme
-    world.set_human(human)
-    world.set_zombie_list(zombie_list)
-    world.set_test_pattern(test_pattern)
-    world
-  end
-
-  def initialize(interface_type)
-    @human = nil
-    @current_zombie = nil
-    @zombie_list = nil
-    @test_pattern = nil
-    @interface = case interface_type
-      when :console_interface then ConsoleInterface.new
-      when :no_interface then NoInterface.new
-      when :gui_interface then GuiInterface.new
-    end
-  end
-
-  def set_human(human)
-    raise "Already set" unless @human.nil?
-    @human = human
-    interface.human = human
-  end
-
-  def set_zombie_list(zombie_list)
-    raise "Already set" unless @zombie_list.nil?
-    @zombie_list = zombie_list
-  end
-
-  def set_test_pattern(test_pattern)
-    raise "Already set" unless @test_pattern.nil?
-    @test_pattern = test_pattern
-  end
-
-  #FIXME currently only used by the unit tests. It is equivalent to ZombieTestChaser.validate
-  def run
-    run_human
-    until (@human.dead? or @zombie_list.all_slain?)
-      run_zombie(@zombie_list.supply_next_zombie)
-    end
-    @interface.finish
-  end
-
-  def run_human
-    @human.run
-    @human.finish_dying if @human.dying?
-    ! @human.dead?
-  end
-
-  def create_zombie_using_test_unit_handler
-    raise "@test_pattern not defined?" if @test_pattern.nil?
-    zombie = Zombie.new_using_test_unit_handler(@test_pattern, self)
-  end
-
-  def run_zombie(zombie)
-    @current_zombie = zombie
-    @interface.current_zombie = zombie
-    sleep 0.2
-    @current_zombie.run
-    if @current_zombie.dying?
-      @current_zombie.finish_dying
-    else
-      @current_zombie.eat(@human)
-      sleep 1
-    end
-    ! @current_zombie.dead?
-  end
-
-  def something_happened
-    @interface.something_happened
-  end
-
-end
-
+require "zombie-chaser/human"
+require "zombie-chaser/interface"
+
+class World
+  @interface_type = :gui_interface
+
+  def self.interface_type=(interface_type); @interface_type = interface_type end
+  def self.interface_type; @interface_type end
+
+  attr_reader :interface
+
+  def self.new_using_results(human_results, zombies_results)
+    world = new(:no_interface)
+    human = MockHuman.new_using_results(human_results, world)
+    zombie_list = MockZombieList.new_using_results(zombies_results, world)
+    world.set_human(human)
+    world.set_zombie_list(zombie_list)
+    world
+  end
+
+  def self.new_using_test_unit_handler(test_pattern)
+    world = new(self.interface_type)
+    human = Human.new_using_test_unit_handler(test_pattern, world)
+    zombie_list = ZombieList.new_using_test_unit_handler(test_pattern, world)
+    world.set_human(human)
+    world.set_zombie_list(zombie_list)
+    world
+  end
+
+  def initialize(interface_type)
+    @human = nil
+    @zombie_list = nil
+    @interface = case interface_type
+      when :console_interface then ConsoleInterface.new
+      when :no_interface then NoInterface.new
+      when :gui_interface then GuiInterface.new
+    end
+    @view_update_threads = nil
+    @collision_detection_lock = Monitor.new
+  end
+
+  def set_human(human)
+    raise "Already set" unless @human.nil?
+    @human = human
+    interface.human = human
+  end
+
+  def set_zombie_list(zombie_list)
+    raise "Already set" unless @zombie_list.nil?
+    @zombie_list = zombie_list
+    @interface.zombie_list = zombie_list
+  end
+
+  def while_world_running
+    @view_update_threads = Queue.new
+    yield
+    @view_update_threads.enq(:end_of_work)
+    thread = @view_update_threads.deq
+    until thread == :end_of_work
+      thread.join
+      thread = @view_update_threads.deq
+    end
+    @interface.finish_if_neccessary
+  end
+
+  def run_human
+    @human.run
+    ! @human.dead?
+  end
+
+  def run_next_zombie
+    # Since zombies can come from multiple directions, rather than queueing against each other,
+    # separating out when they appear isn't required
+    zombie = @zombie_list.supply_next_zombie
+    @view_update_threads.enq(Thread.new{zombie.build_view_queue})
+    @view_update_threads.enq(Thread.new{zombie.update_view})
+    zombie.run_tests
+  end
+
+  def synchronize_for_collision_detection
+    @collision_detection_lock.synchronize {yield}
+  end
+
+  def something_happened
+    @interface.something_happened
+  end
+
+  def sleep(duration)
+    @interface.sleep(duration)
+  end
+
+  def notify_human_eaten
+    @human.get_eaten
+  end
+
+  #Assumption: this is called after human is in a valid state
+  def human_dead?
+    @human.dead?
+  end
+
+  def no_living_zombies_apart_from_me?(desired_step_count, actor)
+    @interface.no_living_zombies_apart_from_me?(desired_step_count, actor)
+  end
+end
+