Source code in the ruby programming language

def game_of_life(name, size, generations, initial_life=nil)
  board = new_board size
  seed board, size, initial_life
  print_board board, name, 0
  reason = generations.times do |gen|
    new = evolve board, size
    print_board new, name, gen+1
    break :all_dead if barren? new, size
    break :static   if board == new
    board = new
  end
  if    reason == :all_dead then puts "no more life."
  elsif reason == :static   then puts "no movement"
  else                           puts "specified lifetime ended"
  end
  puts
end

def new_board(n)
  Array.new(n) {Array.new(n, 0)}
end

def seed(board, n, points=nil)
  if points.nil?
    # randomly seed board
    indices = []
    n.times {|x| n.times {|y| indices << [x,y] }}
    indices.shuffle[0,10].each {|x,y| board[y][x] = 1}
  else
    points.each {|x, y| board[y][x] = 1}
  end
end

def evolve(board, n)
  new = new_board n
  n.times {|i| n.times {|j| new[i][j] = fate board, i, j, n}}
  new
end

def fate(board, i, j, n)
  i1 = [0, i-1].max; i2 = [i+1, n-1].min
  j1 = [0, j-1].max; j2 = [j+1, n-1].min
  sum = 0
  for ii in (i1..i2)
    for jj in (j1..j2)
      sum += board[ii][jj] if not (ii == i and jj == j)
    end
  end
  (sum == 3 or (sum == 2 and board[i][j] == 1)) ? 1 : 0
end

def barren?(board, n)
  n.times {|i| n.times {|j| return false if board[i][j] == 1}}
  true
end

def print_board(m, name, generation)
  puts "#{name}: generation #{generation}"
  m.each {|row| row.each {|val| print "#{val == 1 ? '#' : '.'} "}; puts}
end

game_of_life "blinker", 3, 2, [[1,0],[1,1],[1,2]]
game_of_life "glider", 4, 4, [[1,0],[2,1],[0,2],[1,2],[2,2]]
game_of_life "random", 5, 10

class Game
  def initialize(name, size, generations, initial_life=nil)
    @size = size
    @board = GameBoard.new size, initial_life
    @board.display name, 0
    
    reason = generations.times do |gen|
      new_board = evolve
      new_board.display name, gen+1
      break :all_dead if new_board.barren?
      break :static   if @board == new_board
      @board = new_board
    end
    
    case reason
    when :all_dead  then puts "No more life."
    when :static    then puts "No movement."
    else                 puts "Specified lifetime ended."
    end
    puts
  end
  
  def evolve
    life = @board.each_index.select {|i,j| cell_fate(i,j)}
    GameBoard.new @size, life
  end
  
  def cell_fate(i, j)
    left_right = [0, i-1].max .. [i+1, @size-1].min
    top_bottom = [0, j-1].max .. [j+1, @size-1].min
    sum = 0
    for x in left_right
      for y in top_bottom
        sum += @board[x,y].value if x != i or y != j
      end
    end
    sum == 3 or (sum == 2 and @board[i,j].alive?)
  end
end

class GameBoard
  include Enumerable
  
  def initialize(size, initial_life=nil)
    @size = size
    @board = Array.new(size) {Array.new(size) {Cell.new false}}
    seed_board initial_life
  end
  
  def seed_board(life)
    if life.nil?
      # randomly seed board
      each_index.to_a.sample(10).each {|x,y| @board[y][x].live}
    else
      life.each {|x,y| @board[y][x].live}
    end
  end
  
  def each
    @size.times {|x| @size.times {|y| yield @board[y][x] }}
  end
  
  def each_index
    return to_enum(__method__) unless block_given?
    @size.times {|x| @size.times {|y| yield x,y }}
  end
  
  def [](x, y)
    @board[y][x]
  end
  
  def ==(board)
    self.life == board.life
  end
  
  def barren?
    none? {|cell| cell.alive?}
  end
  
  def life
    each_index.select {|x,y| @board[y][x].alive?}
  end
  
  def display(name, generation)
    puts "#{name}: generation #{generation}"
    puts @board.map {|row| row.map {|cell| cell.alive? ? '#' : '.'}.join(' ')}
  end
  
  def apocalypse
    # utility function to entirely clear the game board
    each {|cell| cell.die}
  end
end

class Cell
  def initialize(alive) @alive = alive  end
  def alive?;           @alive          end
  def value;            @alive ? 1 : 0  end
  def live;             @alive = true   end
  def die;              @alive = false  end
end

Game.new "blinker", 3, 2, [[1,0],[1,1],[1,2]]
Game.new "glider", 4, 4, [[1,0],[2,1],[0,2],[1,2],[2,2]]
Game.new "random", 5, 10