conway_deathmatch 0.4.1.1 → 0.5.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4c99458e1f16832079d5dec01f15b43b05d0062e
-  data.tar.gz: d99447fcdf8a6ef51f8078e5c9783dabd44a5649
+  metadata.gz: 95413f3557aa8dcb568065213eb0e296c951aac2
+  data.tar.gz: 7640ea076629eaab5134bed4f11288155916de58
 SHA512:
-  metadata.gz: 8528c9fcb640e4291b7d1adeb50c68fe0e555af1000f201322f0c0174ef5de4f7cb36bc49d8ffb680214d35b25e84b1b451ed56c3c22ee39e74df02528ba3fef
-  data.tar.gz: 8da6e47b4acd9b7fa42fa391875e642661437aceaa3d841e3fad91456de294f235abe2aeafa85145b6536d4cf2bb1ef47a5a8cfa7a572c1add1f68a92763d6e7
+  metadata.gz: 0ce56f027fdcf40ed302a65a928c22b9b7e3677c3c755505941a3546d1391bfb5af6810f9e092e19845d55d3d3cfd533954930e815d9f8d676305fc09b714e10
+  data.tar.gz: abdedab43e2091b6a3f150e909685a90acaafe59022d73a6ce9003eb9d5b31a88fc2be44209238dd4a9339175c4043539ad85369a77106cc77bc489fa85ec33d

data/README.md

@@ -28,6 +28,17 @@ 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).
 
+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 (e.g. 2 red, 1 blue)
+  - 2 neighbors: coin flip (e.g. 1 red, 1 blue)
+* Friendly: Just count friendlies
+  - Enemies don't count, party on! (e.g. 3 red, 2 blue)
+
 Usage
 ===
 
@@ -79,34 +90,9 @@ There is [another yaml file](https://github.com/rickhull/conway_deathmatch/blob/
 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 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.
+Just one file, aside from shape loading: [Have a look-see](https://github.com/rickhull/conway_deathmatch/blob/master/lib/conway_deathmatch.rb)
 
-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!
+Boundaries are toroidal, meaning that cells "wrap" at the edges, such that the left edge is adjacent to the right edge, and likewise with top and bottom. Thus, the grid has the topography of a torus (i.e. doughnut).
 
 Inspiration
 ---

data/VERSION

@@ -1 +1 @@
-0.4.1.1
+0.5.0.3

data/bin/conway_deathmatch

@@ -1,7 +1,9 @@
 #!/usr/bin/env ruby
 
+gem 'slop', '~> 3'
 require 'slop'
 require 'conway_deathmatch'
+require 'conway_deathmatch/shapes'
 
 # process cmdline options
 #
@@ -11,8 +13,8 @@ opts = Slop.parse(help: true,
                   optional_arguments: true) do
   banner 'Usage: conway_deathmatch [options]'
 
-  on 'x', 'width=',      '[int] Board width', as: Integer
-  on 'y', 'height=',     '[int] Board height', as: Integer
+  on 'x', 'width=',      '[int] Grid width', as: Integer
+  on 'y', 'height=',     '[int] Grid 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
@@ -43,18 +45,17 @@ deathmatch = case opts[:deathmatch].to_s.downcase
 
 # create game
 #
-include ConwayDeathmatch
-b = BoardState.new(width, height)
+b = ConwayDeathmatch.new(width, height)
 
 # 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]
+  ConwayDeathmatch::Shapes.add(b, opts[:one], 1) if opts[:one]
+  ConwayDeathmatch::Shapes.add(b, opts[:two], 2) if opts[:two]
+  ConwayDeathmatch::Shapes.add(b, opts[:three], 3) if opts[:three]
 else
   b.deathmatch = deathmatch
-  Shapes.add(b, shapes)
+  ConwayDeathmatch::Shapes.add(b, shapes)
 end
 
 # play game

data/bin/proving_ground

@@ -1,8 +1,10 @@
 #!/usr/bin/env ruby
 
 require 'set'
+gem 'slop', '~> 3'
 require 'slop'
 require 'conway_deathmatch'
+require 'conway_deathmatch/shapes'
 
 # process cmdline options
 #
@@ -12,8 +14,8 @@ opts = Slop.parse(help: true,
 		  optional_arguments: true) do
   banner 'Usage: proving_ground [options]'
 
-  on 'w', 'width=',      '[int] Board width', as: Integer
-  on      'height=',     '[int] Board height', as: Integer
+  on 'w', 'width=',      '[int] Grid width', as: Integer
+  on      'height=',     '[int] Grid height', as: Integer
   on 'n', 'num_ticks=',  '[int] Max number of ticks to generate', as: Integer
   on 'p', 'num_points=', '[int] Number of points to generate', as: Integer
   on 'm', 'max_collisions=', '[int] Max number of collisions', as: Integer
@@ -64,14 +66,11 @@ def conclude!(results, w, h)
     puts "shape_str: #{shape_str(res[1])}"
     puts
   }
-  puts "Board: #{w}x#{h}"
+  puts "Grid: #{w}x#{h}"
 
   exit 0
 end
 
-include ConwayDeathmatch
-ALIVE = BoardState::ALIVE
-
 results = { final: [0], peak: [0], score: [0], }
 seen = Set.new
 collisions = 0
@@ -92,24 +91,24 @@ loop {
   end
   seen << hsh
 
-  # initialize board with generated shape
-  b = BoardState.new(width, height)
+  # initialize grid with generated shape
+  b = ConwayDeathmatch.new(width, height)
   b.add_points(points)
 
   current = peak = score = 0     # track population (results)
-  static_count = 0               # detect a stabilized board
+  static_count = 0               # detect a stabilized grid
 
   # iterate the game of life
   num_ticks.times { |i|
     b.tick
 
-    # evaluate board
+    # evaluate grid
     last = current
-    current = b.population[ALIVE]
+    current = b.population[ConwayDeathmatch::ALIVE]
     peak = current if current > peak
     score += current * i
 
-    # cease ticks for static or (soon-to-be) empty boards
+    # cease ticks for static or (soon-to-be) empty grids
     break if current < 3
     static_count = (current == last ? static_count + 1 : 0)
     break if static_count > 3

data/conway_deathmatch.gemspec

@@ -12,15 +12,14 @@ Gem::Specification.new do |s|
     'Rakefile',
     'README.md',
     'lib/conway_deathmatch.rb',
-    'lib/conway_deathmatch/board_state.rb',
     'lib/conway_deathmatch/shapes.rb',
     'lib/conway_deathmatch/shapes/classic.yaml',
     'lib/conway_deathmatch/shapes/discovered.yaml',
     'bin/conway_deathmatch',
     'bin/proving_ground',
-    'test/bench_board_state.rb',
+    'test/bench_grid.rb',
     'test/spec_helper.rb',
-    'test/test_board_state.rb',
+    'test/test_grid.rb',
     'test/test_shapes.rb',
   ]
   s.executables = ['conway_deathmatch']
@@ -28,6 +27,10 @@ Gem::Specification.new do |s|
   s.add_development_dependency "buildar", "~> 2"
   s.add_development_dependency "minitest", "~> 5"
   s.add_development_dependency "ruby-prof", "~> 0"
+  s.add_development_dependency "flog", "~> 4.0"
+  s.add_development_dependency "flay", "~> 2.0"
+  s.add_development_dependency "roodi", "~> 4.0"
+
   # uncomment and set ENV['CODE_COVERAGE']
   # s.add_development_dependency "simplecov", "~> 0.9.0"
   s.required_ruby_version = "~> 2"

data/lib/conway_deathmatch.rb

@@ -1,2 +1,145 @@
-require 'conway_deathmatch/board_state'
-require 'conway_deathmatch/shapes'
+#require 'conway_deathmatch/shapes'
+#require 'lager'
+
+# Provides a 2d array for the grid
+# Implements standard and deathmatch evaluation rules
+# Boundaries are toroidal: they wrap in each direction
+#
+class ConwayDeathmatch
+  #extend Lager
+  #log_to $stderr
+  class BoundsError < RuntimeError; end
+
+  DEAD = '.'
+  ALIVE = '0'
+
+  def self.new_grid(width, height)
+    grid = []
+    width.times { grid << Array.new(height, DEAD) }
+    grid
+  end
+
+  # nil for traditional, otherwise :aggressive, :defensive, or :friendly
+  attr_accessor :deathmatch
+
+  def initialize(width, height, deathmatch = nil)
+    @width = width
+    @height = height
+    @grid = self.class.new_grid(width, height)
+    @deathmatch = deathmatch
+    #@lager = self.class.lager
+  end
+
+  # Conway's Game of Life transition rules
+  def next_value(x, y)
+    # don't bother toroidaling, only called by #tick
+    n, birthright = neighbor_stats(x, y)
+    if @grid[x][y] != DEAD
+      (n == 2 or n == 3) ? birthright : DEAD
+    else
+      (n == 3) ? birthright : DEAD
+    end
+  end
+
+  def value(x, y)
+    @grid[x % @width][y % @height]
+  end
+
+  # total (alive) neighbor count and birthright
+  def neighbor_stats(x, y)
+    x = x % @width
+    y = y % @height
+    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 = (@grid[x][y] == DEAD or @deathmatch == :aggressive)
+      total = 0
+      largest = 0
+      birthrights = []
+      npop.each { |sym, cnt|
+        total += cnt
+        return [0, DEAD] if total > 3   # [optimization]
+        if determine_majority
+          if cnt > largest
+            largest = cnt
+            birthrights = [sym]
+          elsif cnt == largest
+            birthrights << sym
+          end
+        end
+      }
+      [total, determine_majority ? (birthrights.sample || DEAD) : @grid[x][y]]
+
+    when :friendly
+      # [optimization] 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 @grid[x][y] == DEAD
+                   npop.reduce([]) { |memo, (sym,cnt)|
+                     cnt == 3 ? memo + [sym] : memo
+                   }.sample || DEAD
+                 else
+                   @grid[x][y]
+                 end
+      # return [0, DEAD] if no one qualifies
+      [npop[cell_val] || 0, cell_val]
+    else
+      raise "unknown: #{@deathmatch.inspect}"
+    end
+  end
+
+  # population of every neighboring entity, including DEAD
+  def neighbor_population(x, y)
+    x = x % @width
+    y = y % @height
+    neighbors = Hash.new(0)
+    (x-1).upto(x+1) { |xn|
+      (y-1).upto(y+1) { |yn|
+        xn = xn % @width
+        yn = yn % @height
+        neighbors[@grid[xn][yn]] += 1 unless (xn == x and yn == y)
+      }
+    }
+    neighbors
+  end
+
+  # generate the next grid table
+  def tick
+    new_grid = self.class.new_grid(@width, @height)
+    @width.times { |x|
+      @height.times { |y| new_grid[x][y] = next_value(x, y) }
+    }
+    @grid = new_grid
+    self
+  end
+
+  # set a single point
+  def populate(x, y, val = ALIVE)
+    @grid[x % @width][y % @height] = val
+  end
+
+  # set several points (2d array)
+  def add_points(points, x_off = 0, y_off = 0, val = ALIVE)
+    points.each { |point| populate(point[0] + x_off, point[1] + y_off, val) }
+    self
+  end
+
+  # for line-based text output, iterate over y-values first (i.e. per row)
+  def render_text
+    @grid.transpose.map { |row| row.join }.join("\n")
+  end
+  alias_method :render, :render_text
+
+  # full grid scan
+  def population
+    population = Hash.new(0)
+    @grid.each { |col| col.each { |val|  population[val] += 1  } }
+    population
+  end
+end

data/lib/conway_deathmatch/shapes.rb

@@ -1,11 +1,11 @@
-require 'conway_deathmatch/board_state'
+require 'conway_deathmatch'
 require 'yaml'
 
 module ConwayDeathmatch::Shapes
   def self.load_yaml(filename)
     YAML.load_file(File.join(__dir__, 'shapes', filename))
   end
-  
+
   # memoize shapes/classic.yaml
   def self.classic
     @@classic ||= self.load_yaml('classic.yaml')
@@ -15,10 +15,10 @@ module ConwayDeathmatch::Shapes
   def self.discovered
     @@disovered ||= self.load_yaml('discovered.yaml')
   end
-  
+
   # parse a string like "acorn 12 22 block 5 0 p 1 2 p 3 4 p 56 78"
   # add known shapes
-  def self.add(board, str, val = BoardState::ALIVE)
+  def self.add(grid, str, val = ConwayDeathmatch::ALIVE)
     tokens = str.split
     points = []
     classic = self.classic
@@ -33,9 +33,9 @@ module ConwayDeathmatch::Shapes
         points << [x, y]
       else
         found = classic[shape] || self.discovered.fetch(shape)
-        board.add_points(found, x, y, val)
+        grid.add_points(found, x, y, val)
       end
     end
-    board.add_points(points, 0, 0, val)
+    grid.add_points(points, 0, 0, val)
   end
 end

data/test/{bench_board_state.rb → bench_grid.rb}

@@ -1,37 +1,36 @@
 require 'minitest/autorun'
 require 'minitest/benchmark'
-
 require 'conway_deathmatch'
-
-include ConwayDeathmatch
+require 'conway_deathmatch/shapes'
 
 BENCH_NEW_THRESH = (ENV['BENCH_NEW_THRESH'] || 0.9).to_f
 BENCH_TICK_THRESH = (ENV['BENCH_TICK_THRESH'] || 0.9995).to_f
+Shapes = ConwayDeathmatch::Shapes
 
-describe "BoardState.new Benchmark" do
+describe "ConwayDeathmatch.new Benchmark" do
   bench_range do
     bench_exp 9, 9999, 3
   end
 
   bench_performance_linear "width*height", BENCH_NEW_THRESH do |n|
-    BoardState.new(n, n)
+    ConwayDeathmatch.new(n, n)
   end
 end
 
-describe "BoardState#tick Benchmark" do
+describe "ConwayDeathmatch#tick Benchmark" do
   bench_range do
     bench_exp 1, 100, 3
   end
 
   bench_performance_linear "acorn demo", BENCH_TICK_THRESH do |n|
-    b = BoardState.new(70, 40)
+    b = ConwayDeathmatch.new(70, 40)
     Shapes.add(b, "acorn 50 18")
     n.times { b.tick }
   end
 
   bench_performance_linear "aggressive deathmatch demo",
                            BENCH_TICK_THRESH do |n|
-    b = BoardState.new(70, 40)
+    b = ConwayDeathmatch.new(70, 40)
     b.deathmatch = :aggressive
     Shapes.add(b, "acorn 30 30", "1")
     Shapes.add(b, "diehard 20 10", "2")
@@ -40,7 +39,7 @@ describe "BoardState#tick Benchmark" do
 
   bench_performance_linear "defensive deathmatch demo",
                            BENCH_TICK_THRESH do |n|
-    b = BoardState.new(70, 40)
+    b = ConwayDeathmatch.new(70, 40)
     b.deathmatch = :defensive
     Shapes.add(b, "acorn 30 30", "1")
     Shapes.add(b, "diehard 20 10", "2")
@@ -49,7 +48,7 @@ describe "BoardState#tick Benchmark" do
 
   bench_performance_linear "friendly deathmatch demo",
                            BENCH_TICK_THRESH do |n|
-    b = BoardState.new(70, 40)
+    b = ConwayDeathmatch.new(70, 40)
     b.deathmatch = :friendly
     Shapes.add(b, "acorn 30 30", "1")
     Shapes.add(b, "diehard 20 10", "2")

data/test/spec_helper.rb

@@ -6,22 +6,8 @@ end
 require 'minitest/spec'
 require 'minitest/autorun'
 require 'conway_deathmatch'
+require 'conway_deathmatch/shapes'
 
-include ConwayDeathmatch
-
-DEAD = BoardState::DEAD
-ALIVE = BoardState::ALIVE
-
-SHAPE = "acorn"
-SHAPE_STR = "#{SHAPE} 0 0"
-POINTS_COUNT = 7
-SHAPE_TICK_POINTS = [
-  [0, 1],
-  [1, 1],
-  [2, 1],
-  [4, 1],
-  [4, 2],
-  [5, 1],
-  [5, 2],
-  [5, 3],
-]
+ALIVE = ConwayDeathmatch::ALIVE
+DEAD = ConwayDeathmatch::DEAD
+Shapes = ConwayDeathmatch::Shapes

data/test/test_grid.rb

@@ -0,0 +1,141 @@
+require_relative './spec_helper'
+
+describe ConwayDeathmatch do
+  describe "an empty grid" do
+    before do
+      @x = 5
+      @y = 5
+      @grid = ConwayDeathmatch.new(@x, @y)
+    end
+
+    it "must have dead population" do
+      @grid.population[DEAD].must_equal @x * @y
+      @grid.population.keys.length.must_equal 1
+    end
+
+    it "must still be dead after a tick" do
+      @grid.tick.population[DEAD].must_equal @x*@y
+      @grid.population.keys.length.must_equal 1
+    end
+
+    it "must accept a block" do
+      @grid.populate 1,1
+      @grid.populate 1,2
+      @grid.populate 2,1
+      @grid.populate 2,2
+
+      @grid.population[DEAD].must_equal @x * @y - 4
+      @grid.population[ALIVE].must_equal 4
+
+      0.upto(4) { |x|
+        0.upto(4) { |y|
+          if x.between?(1, 2) and y.between?(1, 2)
+            @grid.value(x, y).must_equal ALIVE
+          else
+            @grid.value(x, y).must_equal DEAD
+          end
+        }
+      }
+    end
+  end
+
+  describe "adding shapes" do
+    before do
+      @grid = ConwayDeathmatch.new(40, 40)
+      Shapes.add(@grid, "acorn 0 0")
+    end
+
+    it "must recognize \"acorn 0 0\"" do
+      Shapes.classic.fetch("acorn").each { |xy_ary|
+        @grid.value(*xy_ary).must_equal ALIVE
+      }
+      @grid.population.fetch(ALIVE).must_equal 7
+    end
+
+    it "must tick correctly" do
+      @grid.tick
+      new_points = [
+        [0, 1],
+        [1, 1],
+        [2, 1],
+        [4, 1],
+        [4, 2],
+        [5, 1],
+        [5, 2],
+        [5, 3],
+      ].each { |xy_ary|
+        @grid.value(*xy_ary).must_equal ALIVE
+      }
+      @grid.population.fetch(ALIVE).must_equal new_points.length
+    end
+  end
+
+  describe "aggressive deathmatch" do
+    it "must allow survivors to switch sides" do
+      32.times {
+        @grid = ConwayDeathmatch.new(5, 3, :aggressive)
+        @grid.populate(1, 1, '1') # friendly
+        @grid.populate(2, 1, '1') # survivor
+        @grid.populate(3, 1, '2') # enemy
+
+        @grid.tick
+        break if @grid.value(2, 1) == '2'
+      }
+
+      @grid.population.fetch('1').must_equal 2
+      @grid.population.fetch('2').must_equal 1
+      0.upto(4) { |x|
+        0.upto(2) { |y|
+          if x == 2 and y.between?(0, 2)
+            @grid.value(x, y).must_equal(y == 1 ? '2' : '1')
+          else
+            @grid.value(x, y).must_equal DEAD
+          end
+        }
+      }
+    end
+  end
+
+  describe "defensive deathmatch" do
+    it "must not allow survivors to switch sides" do
+      16.times {
+        @grid = ConwayDeathmatch.new(5, 3, :defensive)
+        @grid.populate(1, 1, '1') # friendly
+        @grid.populate(2, 1, '1') # survivor
+        @grid.populate(3, 1, '2') # enemy
+        @grid.tick
+
+        @grid.population.fetch('1').must_equal 3
+        0.upto(4) { |x|
+          0.upto(2) { |y|
+            if x == 2 and y.between?(0, 2)
+              @grid.value(x, y).must_equal '1'
+            else
+              @grid.value(x, y).must_equal DEAD
+            end
+          }
+        }
+      }
+    end
+  end
+
+  describe "friendly deathmatch" do
+    it "must allow survivors with excess hostiles nearby" do
+      @grid = ConwayDeathmatch.new(5, 5, :friendly)
+      @grid.populate(1, 2, '1') # friendly
+      @grid.populate(2, 2, '1') # survivor
+      @grid.populate(3, 2, '1') # friendly
+      @grid.populate(2, 1, '2') # enemy
+      @grid.populate(2, 3, '2') # enemy
+      @grid.tick
+
+      @grid.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|
+          @grid.value(x, y).must_equal (x == 2 && y == 2 ? '1' : DEAD)
+        }
+      }
+    end
+  end
+end

data/test/test_shapes.rb

@@ -1,15 +1,15 @@
 require_relative './spec_helper'
 
 describe Shapes do
-  it "must recognize #{SHAPE}" do
-    Shapes.classic.fetch(SHAPE).must_be_instance_of Array
+  it "must recognize acorn" do
+    Shapes.classic.fetch("acorn").must_be_instance_of Array
   end
 
-  it "must confirm #{SHAPE} on the board" do
-    @board = BoardState.new(20, 20)
-    Shapes.add(@board, SHAPE_STR)
-    Shapes.classic.fetch(SHAPE).each { |xy_ary|
-      @board.value(*xy_ary).must_equal ALIVE
+  it "must confirm acorn on the grid" do
+    @grid = ConwayDeathmatch.new(20, 20)
+    Shapes.add(@grid, "acorn 0 0")
+    Shapes.classic.fetch("acorn").each { |xy_ary|
+      @grid.value(*xy_ary).must_equal ALIVE
     }
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: conway_deathmatch
 version: !ruby/object:Gem::Version
-  version: 0.4.1.1
+  version: 0.5.0.3
 platform: ruby
 authors:
 - Rick Hull
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-12-27 00:00:00.000000000 Z
+date: 2017-01-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: slop
@@ -66,6 +66,48 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: flog
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+- !ruby/object:Gem::Dependency
+  name: flay
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: roodi
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
 description: Deathmatch
 email: 
 executables:
@@ -80,13 +122,12 @@ files:
 - bin/proving_ground
 - conway_deathmatch.gemspec
 - lib/conway_deathmatch.rb
-- lib/conway_deathmatch/board_state.rb
 - lib/conway_deathmatch/shapes.rb
 - lib/conway_deathmatch/shapes/classic.yaml
 - lib/conway_deathmatch/shapes/discovered.yaml
-- test/bench_board_state.rb
+- test/bench_grid.rb
 - test/spec_helper.rb
-- test/test_board_state.rb
+- test/test_grid.rb
 - test/test_shapes.rb
 homepage: https://github.com/rickhull/conway_deathmatch
 licenses:
@@ -108,7 +149,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5
+rubygems_version: 2.5.2
 signing_key: 
 specification_version: 4
 summary: Conway's Game of Life

data/lib/conway_deathmatch/board_state.rb

@@ -1,153 +0,0 @@
-#require 'lager'
-module ConwayDeathmatch; end         # create namespace
-
-# data structure for the board - 2d array
-# 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
-
-  # 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)
-    @deathmatch = deathmatch
-#    @lager = self.class.lager
-  end
-
-  # Conway's Game of Life transition rules
-  def next_value(x, y)
-    # don't bother toroidaling, only called by #tick
-    n, birthright = neighbor_stats(x, y)
-    if @state[x][y] != DEAD
-      (n == 2 or n == 3) ? birthright : DEAD
-    else
-      (n == 3) ? birthright : DEAD
-    end
-  end
-
-  def value(x, y)
-    x = x % @x_len
-    y = y % @y_len
-    @state[x][y]
-  end
-
-  # total (alive) neighbor count and birthright
-  def neighbor_stats(x, y)
-    x = x % @x_len
-    y = y % @y_len
-    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
-
-  # population of every neighboring entity, including DEAD
-  def neighbor_population(x, y)
-    x = x % @x_len
-    y = y % @y_len
-    neighbors = Hash.new(0)
-    (x-1).upto(x+1) { |xn|
-      (y-1).upto(y+1) { |yn|
-        xn = xn % @x_len
-        yn = yn % @y_len
-        neighbors[@state[xn][yn]] += 1 unless (xn == x and yn == y)
-      }
-    }
-    neighbors
-  end
-
-  # generate the next state table
-  def tick
-    new_state = self.class.new_state(@x_len, @y_len)
-    @x_len.times { |x|
-      @y_len.times { |y| new_state[x][y] = next_value(x, y) }
-    }
-    @state = new_state
-    self
-  end
-
-  # set a single point
-  def populate(x, y, val = ALIVE)
-    x = x % @x_len
-    y = y % @y_len
-    @state[x][y] = val
-  end
-
-  # set several points (2d array)
-  def add_points(points, x_off = 0, y_off = 0, val = ALIVE)
-    points.each { |point|
-      x = (point[0] + x_off) % @x_len
-      y = (point[1] + y_off) % @y_len
-      @state[x][y] = val
-    }
-    self
-  end
-
-  # for line-based text output, iterate over y-values first (i.e. per row)
-  def render_text
-    @state.transpose.map { |row| row.join }.join("\n")
-  end
-  alias_method :render, :render_text
-
-  # full board scan
-  def population
-    population = Hash.new(0)
-    @state.each { |col| col.each { |val|  population[val] += 1  } }
-    population
-  end
-end

data/test/test_board_state.rb

@@ -1,132 +0,0 @@
-require_relative './spec_helper'
-
-describe BoardState do
-  describe "an empty board" do
-    before do
-      @x = 5
-      @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
-    end
-
-    it "must still be dead after a tick" do
-      @board.tick.population[DEAD].must_equal @x*@y
-      @board.population.keys.length.must_equal 1
-    end
-
-    it "must accept a block" do
-      @board.populate 1,1
-      @board.populate 1,2
-      @board.populate 2,1
-      @board.populate 2,2
-
-      @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
-
-  describe "adding shapes" do
-    before do
-      @board = BoardState.new(40, 40)
-      Shapes.add(@board, SHAPE_STR)
-    end
-
-    it "must recognize \"#{SHAPE_STR}\"" do
-      Shapes.classic.fetch(SHAPE).each { |xy_ary|
-        @board.value(*xy_ary).must_equal ALIVE
-      }
-      @board.population.fetch(ALIVE).must_equal POINTS_COUNT
-    end
-
-    it "must tick correctly" do
-      @board.tick
-      SHAPE_TICK_POINTS.each { |xy_ary|
-        @board.value(*xy_ary).must_equal ALIVE
-      }
-      @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