A Conway's Game of Life implementation

conways-life.rb

class Grid
  # dynamic, auto-adjusting grid size
  class << self
    attr_accessor :min_x, :max_x, :min_y, :max_y
  end

  attr_accessor :hash
  
  def initialize
    self.hash = {}
  end

  def add_cell(x, y)
    Grid.min_x = x if Grid.min_x.nil? || x < Grid.min_x
    Grid.max_x = x if Grid.max_x.nil? || x > Grid.max_x
    Grid.min_y = y if Grid.min_y.nil? || y < Grid.min_y
    Grid.max_y = y if Grid.max_y.nil? || y > Grid.max_y
    self.hash[hash_x_y(x,y)] = true
  end
  
  def x_y str
    str.split('x').map { |v| v.to_i }
  end
  
  def hash_x_y x, y
    "#{x}x#{y}"
  end
  
  def next_grid
    grid = Grid.new
    self.hash.each_key do |k|
      x, y = x_y k
      if neighbors(x, y) == 2 || neighbors(x, y) == 3
        grid.add_cell(x, y)
      end
      ((x-1)..(x+1)).each do |xx|
        ((y-1)..(y+1)).each do |yy|
          grid.add_cell(xx, yy) if self.hash[hash_x_y(xx, yy)].nil? && neighbors(xx, yy) == 3
        end
      end
    end
    
    grid
  end

  def neighbors(x, y)
    counter = 0
    ((x-1)..(x+1)).each do |xx|
      ((y-1)..(y+1)).each do |yy|
        counter +=1 unless (x == xx && y == yy) || self.hash[hash_x_y(xx, yy)].nil?
      end
    end
    counter
  end

  def prt
    ((Grid.min_x)..(Grid.max_x)).each do |x|
      s = ''
      ((Grid.min_y)..(Grid.max_y)).each do |y|
        s += self.hash[hash_x_y(x, y)] ? 'X' : ' '
      end
      puts '|' + s + '|'
    end
    puts '-' * (Grid.max_x - Grid.min_x + 2)
  end
end

grid = Grid.new
# blinker
# grid.add_cell(0,1)
# grid.add_cell(1,1)
# grid.add_cell(2,1)

# toad
# grid.add_cell(1,2)
# grid.add_cell(1,3)
# grid.add_cell(1,4)
# grid.add_cell(2,1)
# grid.add_cell(2,2)
# grid.add_cell(2,3)


# glider
grid.add_cell(0, 0)
grid.add_cell(1, 1)
grid.add_cell(1, 2)
grid.add_cell(2, 0)
grid.add_cell(2, 1)

count = 0
while count < 100
  grid.prt
  count += 1
  grid = grid.next_grid
  sleep 1
end