conway_deathmatch 0.3.3.1 → 0.4.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 37240d180a9787a7ded00f4eaed8fb4e76ae3e39
-  data.tar.gz: 382b541b24dfac1f0a2cbd4ba76a576922ed7aa8
+  metadata.gz: 975e5f0b1449157c3a456fda6dca9bb11178bfa5
+  data.tar.gz: 4967c6a3e77b3933a087f3e15d87cf68664b12dc
 SHA512:
-  metadata.gz: 294b292a4b0442a39e213ee17661c5247969b334da9851999f4b5a770c1a95e68f22f800702950cb5da706def0082c0358ebf34ef6d180262c27ea0261ceb3fc
-  data.tar.gz: 3cf35cc4f6490da0d3f6dfaf55f05ad626bc9906e8533960056a049a158801310bb9df1ccc0665107a7b9d6590ade13b27e38bfb80457370142d106b95542e97
+  metadata.gz: 30eef27982bdb7c347def54e5b67cb1aea43d96545621254e55ecc57551f88b3c7071b5813cf2213f56ff337d508ffa9017732d9b5f9bc3f195a7930fb58f4d2
+  data.tar.gz: 3ab5fbced55739d812ae429d607202eda538c466789610be07a7235904c950ede14aaa891c4de9f21bc2ce98a9e417c212bb6c7b833cd0c7c31ba138267cb928

data/README.md

@@ -15,15 +15,18 @@ a 2 dimensional board are populated, and the rules of the game determine the
 next state, generating interesting, unpredictable, and ultimately lifelike
 patterns over time.
 
-This project was inspired by http://gameoflifetotalwar.com/ (hereafter CGOLTW).
-You should check it out.  It updates the classic set of rules, which support
-only a single population, for multiple populations which are able to compete
-for space and population.
+Rules
+---
+Cells die or stay dead, unless:
+* Birth rule: 3 neighboring cells turn dead to alive
+* Survival rule: 2 or 3 neighboring cells prevent a live cell from dying
 
-This project exists not to compete with CGOLTW but as a supplementary
-project for exploration and learning.  My initial motivation was to make a
-"proving ground" for searching for simple shapes and patterns with high birth
-rates for determining successful CGOLTW strategies.
+On "Deathmatch"
+---
+The traditional set of rules tracks a single population, even though it may
+form several distinct islands and disjointed groups.  For this project,
+*deathmatch* refers to multiple populations with respective identities over
+time (e.g. red vs blue).
 
 Usage
 ===
@@ -45,13 +48,13 @@ Demo
     # defaults to 70x40 board and an acorn shape
     conway_deathmatch
 
-    # multiplayer
-    conway_deathmatch --one "acorn 30 30" --two "die_hard 20 10"
+    # deathmatch triggered by several populations
+    conway_deathmatch --one "acorn 30 30" --two "diehard 20 10"
 
 Available Shapes
 ---
 
-[Definitions](https://github.com/rickhull/conway_deathmatch/blob/master/lib/conway_deathmatch/shapes/classic.yaml)
+A shape is simply a set of points.  Classic shapes are [defined in a yaml file](https://github.com/rickhull/conway_deathmatch/blob/master/lib/conway_deathmatch/shapes/classic.yaml):
 
 * acorn
 * beacon
@@ -62,7 +65,7 @@ Available Shapes
 * block_engine_space (block engine, minimal footprint)
 * block_engine_stripe (block engine, 1 point tall)
 * boat
-* die_hard
+* diehard
 * glider
 * loaf
 * lwss (lightweight spaceship)
@@ -70,45 +73,58 @@ Available Shapes
 * swastika
 * toad
 
+There is [another yaml file](https://github.com/rickhull/conway_deathmatch/blob/master/lib/conway_deathmatch/shapes/discovered.yaml) with shapes discovered via [proving_ground](https://github.com/rickhull/conway_deathmatch/blob/master/bin/proving_ground).
+
+
 Implementation
 ===
 
 Just one file, aside from shape loading: [Have a look-see](https://github.com/rickhull/conway_deathmatch/blob/master/lib/conway_deathmatch/board_state.rb)
 
 This implementation emphasizes simplicity and ease of understanding.  Currently
-there are no performance optimizations.  I would like to use this project
-to demonstrate the process of optimization, ideally adding optimization on
-an optional, parallel, or otherwise non-permanent basis -- i.e. maintain the
-simple, naive implementation for reference and correctness.
+there are minimal performance optimizations -- relating to avoiding unnecessary
+bounds checking.
+
+I would like to use this project to demonstrate the process of optimization,
+ideally adding optimization on an optional, parallel, or otherwise
+non-permanent basis -- i.e. maintain the simple, naive implementation for
+reference and correctness.
+
+Boundaries
+---
+Currently:
+
+* Boundaries are static and fixed
+* Points out of bounds are treated as always-dead and unable-to-be-populated.
+
+Deathmatch rules
+---
+Choose:
+* Defensive: Alive cells never switch sides
+  - This is the rule followed by the *Immigration* variant of CGoL, I believe
+* Aggressive: Alive cells survive with majority
+  - 3 neighbors: clear majority
+  - 2 neighbors: coin flip
+* Friendly: Just count friendlies
+  - Enemies don't count, party on!
 
 Inspiration
 ---
+This project was inspired by http://gameoflifetotalwar.com/ (hereafter CGOLTW).
+You should check it out.  It updates the classic set of rules, which support
+only a single population, for multiple populations which are able to compete
+for space and population.
+
+This project exists not to compete with CGOLTW but as a supplementary
+project for exploration and learning.  My initial motivation was to make a
+"[proving ground](https://github.com/rickhull/conway_deathmatch/blob/master/bin/proving_ground)" for searching for simple shapes and patterns with high birth
+rates for determining successful CGOLTW strategies.
+
 Coming into this project, I had significant background knowledge concerning
 Conway's Game of Life, but I could not have recited the basic rules in any
 form. After being inspired by competing in CGOLTW, I read their [one background
 page](http://gameoflifetotalwar.com/how-to-play) and then the
 [wikipedia page](http://en.wikipedia.org/wiki/Conway%27s_Game_of_Life).  I
 deliberately avoided any knowledge of any other implementations,
-considering this project's implementation as of November 24 (2014) to be the
+considering this project's implementation as of December 5 (2014) to be the
 naive, simple approach.
-
-Researched optimizations are now an immediate priority.
-
-Caveats
----
-
-### Boundaries
-
-As currently implemented, this project uses fixed boundaries, and boundary
-behavior is not standardized to my knowledge.  For this project, points out of
-bounds are treated as always-dead and unable-to-be-populated.
-
-### Multiplayer
-
-The rules for multiplayer are not standardized.  I read about the CGOLTW
-approach, and this project's approach is similar but different.  In CGOLTW,
-there are always 3 populations, and one population (civilians) is special, in
-that civilians are born where there is birthright contention.  Birthright
-contention happens when a new cell must be generated, but none of the
-neighboring parents have a unique plurality.  For this project, birthright
-contention is resolved with a random selection (TODO).

data/Rakefile

@@ -3,9 +3,11 @@ require 'buildar'
 Buildar.new do |b|
   b.gemspec_file = 'conway_deathmatch.gemspec'
   b.version_file = 'VERSION'
+  b.use_git = true
 end
 
 task default: %w[test bench]
+task travis: %w[test bench ruby-prof]
 
 require 'rake/testtask'
 desc "Run tests"
@@ -21,3 +23,32 @@ Rake::TestTask.new do |t|
   t.pattern = "test/bench_*.rb"
   # t.warning = true
 end
+
+desc "Generate code metrics reports"
+task :code_metrics => [:flog, :flay, :roodi] do
+end
+
+desc "Run flog on lib/"
+task :flog do
+  puts
+  sh "flog lib | tee metrics/flog"
+end
+
+desc "Run flay on lib/"
+task :flay do
+  puts
+  sh "flay lib | tee metrics/flay"
+end
+
+desc "Run roodi on lib/"
+task :roodi do
+  puts
+  sh "roodi -config=.roodi.yml lib | tee metrics/roodi"
+end
+
+# this runs against the installed gem lib, not git / filesystem
+desc "Run ruby-prof on bin/conway_deathmatch (100 ticks)"
+task "ruby-prof" do
+  sh ["ruby-prof -m1 bin/conway_deathmatch -- -n100 -s0 --renderfinal",
+      "| tee metrics/ruby-prof"].join(' ')
+end

data/VERSION

@@ -1 +1 @@
-0.3.3.1
+0.4.0.1

data/bin/conway_deathmatch

@@ -11,38 +11,51 @@ opts = Slop.parse(help: true,
                   optional_arguments: true) do
   banner 'Usage: conway_deathmatch [options]'
 
-  on 'w', 'width=',      '[int] Board width', as: Integer
-  on      'height=',     '[int] Board height', as: Integer
-  on 'n', 'num_ticks=',  '[int] Max number of ticks to generate', as: Integer
+  on 'x', 'width=',      '[int] Board width', as: Integer
+  on 'y', 'height=',     '[int] Board height', as: Integer
+  # on 'D', 'dimensions=', '[str] width x height', as: String
+  on 'n', 'ticks=',  '[int] Max number of ticks to generate', as: Integer
   on 's', 'sleep=',      '[flt] Sleep duration', as: Float
   on 'p', 'points=',     '[str] e.g. "acorn 50 18 p 1 2 p 3 4"', as: String
-  on 'S', 'step',        'Hold ticks for user input'
-  on      'silent',      'Only render the final state'
-  on 'm', 'multiplayer', 'Use multiplayer evaluation'
-  on      'one=',        '[str] points for population "1"'
-  on      'two=',        '[str] points for population "2"'
-  on      'three=',      '[str] points for population "3"'
+  on 'g', 'step',        'Hold ticks for user input'
+  on 'r', 'renderfinal', 'Only render the final state'
+  on 'd', 'deathmatch',
+     '[str] single|aggressive|defensive|friendly', as: String
+  on      'one=',        '[str] points for population "1"', as: String
+  on      'two=',        '[str] points for population "2"', as: String
+  on      'three=',      '[str] points for population "3"', as: String
 end
 
 width = opts[:width] || 70
 height = opts[:height] || 40
 shapes = opts[:points] || "acorn 50 18"
 slp = opts[:sleep] || 0.02
-n = opts[:num_ticks]
-render_continuous = (n.nil? or !opts.silent?)
+n = opts[:ticks]
+render_continuous = (n.nil? or !opts.renderfinal?)
+deathmatch = case opts[:deathmatch].to_s.downcase
+             when '', 's', 'standard', 'single', 't', 'traditional' then nil
+             when 'a', 'aggressive' then :aggressive
+             when 'd', 'defensive' then :defensive
+             when 'f', 'friendly' then :friendly
+             else
+               raise "unknown: #{opts[:deathmatch]}"
+             end
 
 # create game
 #
 include ConwayDeathmatch
 b = BoardState.new(width, height)
-if opts.multiplayer? or opts[:one] or opts[:two] or opts[:three]
-  b.multiplayer = true
-end
 
-Shapes.add(b, opts[:one], 1) if opts[:one]
-Shapes.add(b, opts[:two], 2) if opts[:two]
-Shapes.add(b, opts[:three], 3) if opts[:three]
-Shapes.add(b, shapes) unless b.multiplayer
+# Multiple populations or not
+if opts[:one] or opts[:two] or opts[:three]
+  b.deathmatch = deathmatch || :aggressive
+  Shapes.add(b, opts[:one], 1) if opts[:one]
+  Shapes.add(b, opts[:two], 2) if opts[:two]
+  Shapes.add(b, opts[:three], 3) if opts[:three]
+else
+  b.deathmatch = deathmatch
+  Shapes.add(b, shapes)
+end
 
 # play game
 #
@@ -55,7 +68,7 @@ while n.nil? or count <= n
   end
 
   b.tick
-  
+
   if opts.step?
     gets
   else
@@ -66,7 +79,7 @@ end
 
 # finish
 #
-if n and opts.silent?
+if n and opts.renderfinal?
   puts
   puts count
   puts b.render

data/bin/proving_ground

@@ -1,5 +1,6 @@
 #!/usr/bin/env ruby
 
+require 'set'
 require 'slop'
 require 'conway_deathmatch'
 
@@ -14,44 +15,15 @@ opts = Slop.parse(help: true,
   on 'w', 'width=',      '[int] Board width', as: Integer
   on      'height=',     '[int] Board height', as: Integer
   on 'n', 'num_ticks=',  '[int] Max number of ticks to generate', as: Integer
-  on      'silent',      'Only render the final state'
   on 'p', 'num_points=', '[int] Number of points to generate', as: Integer
   on 'm', 'max_collisions=', '[int] Max number of collisions', as: Integer
 end
 
-width = opts[:width] || 40
-height = opts[:height] || 40
-n = opts[:num_ticks] || 40
-p = opts[:num_points] || 5
-max_c = opts[:max_collisions] || p ** 2
-
-# answers / output
-pop_final = 0
-pop_final_points = []
-pop_peak = 0
-pop_peak_points = []
-top_score = 0
-top_score_points = []
-
-def conclude!(final, final_points,
-              peak, peak_points,
-              score, score_points,
-              w, h)
-  puts
-  puts "final: #{final}"
-  puts "final_points: #{final_points}"
-  puts "shape_str: #{shape_str(final_points)}"
-  puts
-  puts "peak: #{peak}"
-  puts "peak_points: #{peak_points}"
-  puts "shape_str: #{shape_str(peak_points)}"
-  puts
-  puts "score: #{score}"
-  puts "score_points: #{score_points}"
-  puts "shape_str: #{shape_str(score_points)}"
-
-  exit 0
-end
+num_points = opts[:num_points] || 5
+width = opts[:width] || num_points * 5
+height = opts[:height] || num_points * 5
+num_ticks = opts[:num_ticks] || num_points * 5
+max_c = opts[:max_collisions] || num_points ** 2
 
 # choose center point
 # choose next point within 2 units randomly
@@ -86,88 +58,80 @@ def shape_str(points)
   points.map { |point| "p #{point[0]} #{point[1]}" }.join(' ')
 end
 
-Signal.trap("INT") do
-  conclude!(pop_final, pop_final_points,
-            pop_peak, pop_peak_points,
-            top_score, top_score_points,
-            width, height)
+def conclude!(results, w, h)
+  results.each { |k, res|
+    puts "#{k} population: #{res[0]}"
+    puts "shape_str: #{shape_str(res[1])}"
+    puts
+  }
+  puts "Board: #{w}x#{h}"
+
+  exit 0
 end
 
 include ConwayDeathmatch
 ALIVE = BoardState::ALIVE
-SEEN = {}
+
+results = { final: [0], peak: [0], score: [0], }
+seen = Set.new
 collisions = 0
 
+Signal.trap("INT") { conclude!(results, width, height) }
+
 loop {
-  # populate new board with random points
-  #
-  b = BoardState.new(width, height)
-  points = generate_points(p, width, height)
+  # generate a random shape
+  points = generate_points(num_points, width, height)
 
   # have we seen these points before?
-  #
-  if SEEN[points]
+  if seen.member?(points.hash)
     collisions += 1
     puts "X" * collisions
-    break if collisions > max_c
+    break if collisions > max_c # exit the loop, stop generating points
     next
-  else
-    SEEN[points] = true
   end
+  seen << points.hash
+
+  # initialize board with generated shape
+  b = BoardState.new(width, height)
   b.add_points(points)
 
-  # establish vars outside block
-  #
-  pop = nil
-  peak = 0
-  static_cnt = 0
-  score = 0
-  ticks = 0
+  current = peak = score = 0     # track population (results)
+  static_count = 0               # detect a stabilized board
 
-  # tick and track population
-  #
-  n.times { |i|
+  # iterate the game of life
+  num_ticks.times { |i|
     b.tick
-    ticks += 1
 
     # evaluate board
-    #
-    last_pop = pop
-    pop = b.population[ALIVE] || 0
-    score += ticks * pop
-    peak = pop if pop > peak
-
-    # short-circuit static or (soon-to-be) empty boards
-    #
-    break if pop < 3
-    static_cnt = (pop == last_pop ? static_cnt + 1 : 0)
-    break if static_cnt > 3
+    last = current
+    current = b.population[ALIVE]
+    peak = current if current > peak
+    score += current * i
+
+    # cease ticks for static or (soon-to-be) empty boards
+    break if current < 3
+    static_count = (current == last ? static_count + 1 : 0)
+    break if static_count > 3
   }
 
-  puts "#{pop} (#{peak}) [#{score}]"
+  puts "#{current} (#{peak}) [#{score}]"
 
   # track the highest populators
   #
-  if pop > pop_final
-    pop_final = pop
-    pop_final_points = points
-    puts "\tLargest final: #{pop_final}"
+  if current > results[:final][0]
+    results[:final] = [current, points]
+    puts "\tLargest final: #{current}"
   end
 
-  if peak > pop_peak
-    pop_peak = peak
-    pop_peak_points = points
-    puts "\tLargest peak: #{pop_peak}"
+  if peak > results[:peak][0]
+    results[:peak] = [peak, points]
+    puts "\tLargest peak: #{peak}"
   end
 
-  if score > top_score
-    top_score = score
-    top_score_points = points
-    puts "\tLargest score: #{top_score}"
+  if score > results[:score][0]
+    results[:score] = [score, points]
+    puts "\tLargest score: #{score}"
   end
 }
 
-conclude!(pop_final, pop_final_points,
-          pop_peak, pop_peak_points,
-          top_score, top_score_points,
-          width, height)
+conclude!(results, width, height)

data/conway_deathmatch.gemspec

@@ -26,5 +26,7 @@ Gem::Specification.new do |s|
   s.executables = ['conway_deathmatch']
   s.add_development_dependency "buildar", "~> 2"
   s.add_development_dependency "minitest", "~> 5"
+  # uncomment and set ENV['CODE_COVERAGE']
+  # s.add_development_dependency "simplecov", "~> 0.9.0"
   s.required_ruby_version = "~> 2"
 end

data/lib/conway_deathmatch/board_state.rb

@@ -1,30 +1,35 @@
+# require 'lager'
 module ConwayDeathmatch; end         # create namespace
 
 # data structure for the board - 2d array
-# implements standard and multiplayer evaluation
+# implements standard and deathmatch evaluation
 # static boundaries are treated as dead
 #
 class ConwayDeathmatch::BoardState
+#  extend Lager
+#  log_to $stderr
   class BoundsError < RuntimeError; end
 
   DEAD = '.'
   ALIVE = '0'
-  
+
   def self.new_state(x_len, y_len)
     state = []
     x_len.times { state << Array.new(y_len, DEAD) }
     state
   end
 
-  attr_accessor :multiplayer
-  
-  def initialize(x_len, y_len)
+  # nil for traditional, otherwise :aggressive, :defensive, or :friendly
+  attr_accessor :deathmatch
+
+  def initialize(x_len, y_len, deathmatch = nil)
     @x_len = x_len
     @y_len = y_len
     @state = self.class.new_state(x_len, y_len)
-    @multiplayer = false
+    @deathmatch = deathmatch
+#    @lager = self.class.lager
   end
-  
+
   # Conway's Game of Life transition rules
   def next_value(x, y)
     n, birthright = neighbor_stats(x, y)
@@ -35,6 +40,53 @@ class ConwayDeathmatch::BoardState
     end
   end
 
+  # total (alive) neighbor count and birthright
+  def neighbor_stats(x, y)
+    npop = neighbor_population(x, y).tap { |h| h.delete(DEAD) }
+
+    case @deathmatch
+    when nil
+      [npop.values.reduce(0, :+), ALIVE]
+
+    when :aggressive, :defensive
+      # dead: determine majority (always 3, no need to sample for tie)
+      # alive: agg: determine majority (may tie at 2); def: cell_val
+      determine_majority = (@state[x][y] == DEAD or @deathmatch == :aggressive)
+      total = 0
+      largest = 0
+      birthrights = []
+      npop.each { |sym, cnt|
+        total += cnt
+        return [0, DEAD] if total >= 4  # [optimization]
+        if determine_majority
+          if cnt > largest
+            largest = cnt
+            birthrights = [sym]
+          elsif cnt == largest
+            birthrights << sym
+          end
+        end
+      }
+      [total, determine_majority ? (birthrights.sample || DEAD) : @state[x][y]]
+
+    when :friendly
+      # [optimized] with knowledge of conway rules
+      # if DEAD, need 3 friendlies to qualify for birth sampling
+      # if ALIVE, npop simply has the friendly count
+      cell_val = if @state[x][y] == DEAD
+                   npop.reduce([]) { |memo, (sym,cnt)|
+                     cnt == 3 ? memo + [sym] : memo
+                   }.sample || DEAD
+                 else
+                   @state[x][y]
+                 end
+      # return [0, DEAD] if no one qualifies
+      [npop[cell_val] || 0, cell_val]
+    else
+      raise "unknown: #{@deathmatch.inspect}"
+    end
+  end
+
   def value(x, y)
     in_bounds!(x,y)
     @state[x][y].dup
@@ -43,54 +95,27 @@ class ConwayDeathmatch::BoardState
   def in_bounds?(x, y)
     x.between?(0, @x_len - 1) and y.between?(0, @y_len - 1)
   end
-  
+
   def in_bounds!(x, y)
     raise(BoundsError, "(#{x}, #{y})") unless in_bounds?(x, y)
   end
-  
+
   # out of bounds considered dead
   def alive?(x, y)
     @state[x][y] != DEAD rescue false
   end
-  
+
   # population of every neighboring entity, including DEAD
   def neighbor_population(x, y)
-    outer_ring = (x == 0 or y == 0 or x == @x_len - 1 or y == @y_len - 1)
     neighbors = Hash.new(0)
-    (x-1..x+1).each { |xn|
-      next if outer_ring and !xn.between?(0, @x_len - 1)
-      (y-1..y+1).each { |yn|
-        next if (outer_ring and !yn.between?(0, @y_len - 1)) or
-          (xn == x and yn == y)
-        neighbors[@state[xn][yn]] += 1
+    (x-1 > 0 ? x-1 : 0).upto(x+1 < @x_len ? x+1 : @x_len - 1) { |xn|
+      (y-1 > 0 ? y-1 : 0).upto(y+1 < @y_len ? y+1 : @y_len - 1) { |yn|
+        neighbors[@state[xn][yn]] += 1 unless (xn == x and yn == y)
       }
     }
     neighbors
   end
 
-  # total (alive) neighbor count and birthright
-  def neighbor_stats(x, y)
-    if @multiplayer
-      total = 0
-      largest = 0
-      birthright = nil
-      neighbor_population(x, y).each { |sym, cnt|
-        total += cnt
-        if cnt > largest
-          largest = cnt
-          birthright = sym
-        end
-      }
-      [total, birthright]
-    else
-      count = 0
-      neighbor_population(x, y).each { |sym, cnt|
-        count += cnt unless sym == DEAD
-      }
-      [count, ALIVE]
-    end
-  end
-  
   # generate the next state table
   def tick
     new_state = self.class.new_state(@x_len, @y_len)
@@ -106,7 +131,7 @@ class ConwayDeathmatch::BoardState
     in_bounds!(x, y)
     @state[x][y] = val
   end
-  
+
   # set several points (2d array), ignore OOB
   def add_points(points, x_off = 0, y_off = 0, val = ALIVE)
     points.each { |point|

data/lib/conway_deathmatch/shapes/classic.yaml

@@ -97,7 +97,7 @@ boat:
   - [1, 2]
   - [2, 1]
 
-die_hard:
+diehard:
   - [0, 1]
   - [1, 1]
   - [1, 2]

data/lib/conway_deathmatch/shapes/discovered.yaml

@@ -57,6 +57,14 @@ b6: # trinary
   - [3, 2]
   - [4, 0]
 
+c6: # cardioid
+  - [0, 0]
+  - [0, 1]
+  - [1, 1]
+  - [1, 2]
+  - [2, 0]
+  - [2, 1]
+
 a7:
   - [0, 3]
   - [1, 4]
@@ -83,3 +91,13 @@ c7: # urawizardarry
   - [4, 3]
   - [5, 4]
   - [5, 5]
+
+a8: # A
+  - [0, 2]
+  - [1, 1]
+  - [1, 2]
+  - [2, 0]
+  - [2, 1]
+  - [3, 1]
+  - [3, 2]
+  - [4, 2]

data/test/bench_board_state.rb

@@ -29,11 +29,30 @@ describe "BoardState#tick Benchmark" do
     n.times { b.tick }
   end
 
-  bench_performance_linear "multiplayer demo", BENCH_TICK_THRESH do |n|
+  bench_performance_linear "aggressive deathmatch demo",
+                           BENCH_TICK_THRESH do |n|
     b = BoardState.new(70, 40)
-    b.multiplayer = true
+    b.deathmatch = :aggressive
     Shapes.add(b, "acorn 30 30", "1")
-    Shapes.add(b, "die_hard 20 10", "2")
+    Shapes.add(b, "diehard 20 10", "2")
+    n.times { b.tick }
+  end
+
+  bench_performance_linear "defensive deathmatch demo",
+                           BENCH_TICK_THRESH do |n|
+    b = BoardState.new(70, 40)
+    b.deathmatch = :defensive
+    Shapes.add(b, "acorn 30 30", "1")
+    Shapes.add(b, "diehard 20 10", "2")
+    n.times { b.tick }
+  end
+
+  bench_performance_linear "friendly deathmatch demo",
+                           BENCH_TICK_THRESH do |n|
+    b = BoardState.new(70, 40)
+    b.deathmatch = :friendly
+    Shapes.add(b, "acorn 30 30", "1")
+    Shapes.add(b, "diehard 20 10", "2")
     n.times { b.tick }
   end
 end

data/test/spec_helper.rb

@@ -1,3 +1,8 @@
+if ENV['CODE_COVERAGE']
+  require 'simplecov'
+  SimpleCov.start
+end
+
 require 'minitest/spec'
 require 'minitest/autorun'
 require 'conway_deathmatch'

data/test/test_board_state.rb

@@ -7,7 +7,7 @@ describe BoardState do
       @y = 5
       @board = BoardState.new(@x, @y)
     end
-    
+
     it "must have dead population" do
       @board.population[DEAD].must_equal @x * @y
       @board.population.keys.length.must_equal 1
@@ -26,6 +26,16 @@ describe BoardState do
 
       @board.population[DEAD].must_equal @x * @y - 4
       @board.population[ALIVE].must_equal 4
+
+      0.upto(4) { |x|
+        0.upto(4) { |y|
+          if x.between?(1, 2) and y.between?(1, 2)
+            @board.value(x, y).must_equal ALIVE
+          else
+            @board.value(x, y).must_equal DEAD
+          end
+        }
+      }
     end
   end
 
@@ -50,4 +60,73 @@ describe BoardState do
       @board.population.fetch(ALIVE).must_equal SHAPE_TICK_POINTS.length
     end
   end
+
+  describe "aggressive deathmatch" do
+    it "must allow survivors to switch sides" do
+      32.times {
+        @board = BoardState.new(5, 3, :aggressive)
+        @board.populate(1, 1, '1') # friendly
+        @board.populate(2, 1, '1') # survivor
+        @board.populate(3, 1, '2') # enemy
+
+        @board.tick
+        break if @board.value(2, 1) == '2'
+      }
+
+      @board.population.fetch('1').must_equal 2
+      @board.population.fetch('2').must_equal 1
+      0.upto(4) { |x|
+        0.upto(2) { |y|
+          if x == 2 and y.between?(0, 2)
+            @board.value(x, y).must_equal(y == 1 ? '2' : '1')
+          else
+            @board.value(x, y).must_equal DEAD
+          end
+        }
+      }
+    end
+  end
+
+  describe "defensive deathmatch" do
+    it "must not allow survivors to switch sides" do
+      16.times {
+        @board = BoardState.new(5, 3, :defensive)
+        @board.populate(1, 1, '1') # friendly
+        @board.populate(2, 1, '1') # survivor
+        @board.populate(3, 1, '2') # enemy
+        @board.tick
+
+        @board.population.fetch('1').must_equal 3
+        0.upto(4) { |x|
+          0.upto(2) { |y|
+            if x == 2 and y.between?(0, 2)
+              @board.value(x, y).must_equal '1'
+            else
+              @board.value(x, y).must_equal DEAD
+            end
+          }
+        }
+      }
+    end
+  end
+
+  describe "friendly deathmatch" do
+    it "must allow survivors with excess hostiles nearby" do
+      @board = BoardState.new(5, 5, :friendly)
+      @board.populate(1, 2, '1') # friendly
+      @board.populate(2, 2, '1') # survivor
+      @board.populate(3, 2, '1') # friendly
+      @board.populate(2, 1, '2') # enemy
+      @board.populate(2, 3, '2') # enemy
+      @board.tick
+
+      @board.population.fetch('1').must_equal 1
+      # (2,2) alive despite 4 neighbors, only 2 friendly; all else DEAD
+      0.upto(4) { |x|
+        0.upto(4) { |y|
+          @board.value(x, y).must_equal (x == 2 && y == 2 ? '1' : DEAD)
+        }
+      }
+    end
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: conway_deathmatch
 version: !ruby/object:Gem::Version
-  version: 0.3.3.1
+  version: 0.4.0.1
 platform: ruby
 authors:
 - Rick Hull
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-12-05 00:00:00.000000000 Z
+date: 2014-12-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: buildar