gol 0.2

data/bin/gol

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+
+begin
+  require 'gol'
+rescue LoadError
+  require 'rubygems'
+  require 'gol'
+end

data/lib/cell.rb

@@ -0,0 +1,27 @@
+module Gol
+  class Cell
+    attr_accessor :alive, :will_live, :x, :y
+
+    def initialize
+      @alive = false
+      @will_live = false
+    end
+
+    def alive?
+      @alive
+    end
+
+    def kill
+      @alive = false
+    end
+
+    def set_alive
+      @alive = true
+    end
+
+    def will_live?
+      @will_live
+    end
+
+  end
+end

data/lib/game.rb

@@ -0,0 +1,73 @@
+require_relative 'grid'
+
+module Gol
+  class Game
+    attr_accessor :grid, :pause
+
+    def initialize(size, pause)
+      @pause = pause
+      @grid = Grid.new(size)
+    end
+
+
+    def print_game
+      puts
+      str = ""
+      @grid.each do |cell|
+        if cell.x == 1 and cell.alive?
+          str += "|O|"
+        elsif cell.x == 1 and !cell.alive?
+          str += "|_|"
+        elsif cell.x == grid.size and cell.alive?
+          str += "O|\n"
+        elsif cell.x == grid.size and !cell.alive?
+          str += "_|\n"
+        elsif cell.alive?
+          str += "O|"
+        else
+          str += "_|"
+        end
+      end
+      puts str
+    end
+
+
+    def step
+      print_game
+      @grid.cells.each do |cell|
+        @grid.check_survival(cell)
+      end
+      @grid.cells.each do |cell|
+        if cell.will_live?
+          cell.set_alive
+        else
+          cell.kill
+        end
+      end
+      print_game
+      sleep @pause
+    end
+
+
+
+    def turn_alive_random_cells
+      max_cells = rand(@grid.cells.size)
+      cells_to_live = []
+      max_cells.times do
+        cells_to_live << @grid.cells.sample
+      end
+      cells_to_live.each do |c|
+        c.set_alive
+      end
+    end
+
+    def glider
+      @grid.get_cell(6, 5).set_alive
+      @grid.get_cell(7, 6).set_alive
+      @grid.get_cell(5, 7).set_alive
+      @grid.get_cell(6, 7).set_alive
+      @grid.get_cell(7, 7).set_alive
+    end
+
+  end
+end

data/lib/gol.rb

@@ -0,0 +1,78 @@
+require 'optparse'
+require_relative 'game'
+
+module Gol
+  class Starter
+
+    attr_accessor :options
+    def initialize
+      @objects = [:glider] # TODO: more to come
+      @options = {}
+    end
+
+    def parse_options
+      optparse = OptionParser.new do |opts|
+        opts.banner = "Usage: gol [pause] [object] [size] [generations]"
+
+        @options[:pause] = 0.5
+        opts.on('-p', '--pause PAUSE', "Sets the sleep time in seconds each step
+                                     will take after printing out the game.
+                                     Default are 0.5 seconds.") do |time|
+                 @options[:pause] = time.to_f
+               end
+
+
+        @options[:object] = nil
+        opts.on('-o', '--object OBJECT', "Sets a starting object to begin with.
+                                     It will appear on the Screen with no
+                                     additional living cells. Options are:
+                                        glider"
+               ) do |ob|
+                 @options[:object] = ob.to_sym
+               end
+
+
+        @options[:size] = 10
+        opts.on('-s', '--size SIZE', "Sets the size of the quadratic grid.
+                                     Default is a 10x10 grid."
+               ) do |s|
+                 @options[:size] = s.to_i
+               end
+
+
+        @options[:generations] = 10
+        opts.on('-g', '--generations GENERATIONS', "Sets the number of generations to
+                                     play with. Default are 10 generations."
+               ) do |g|
+                 @options[:generations] = g.to_i
+               end
+
+        opts.on('-h', '--help', 'Print this help screen') do
+          puts opts
+          exit
+        end
+      end # end of option parsing
+
+      optparse.parse!
+
+    end # end parse options
+
+
+    def main_script
+      parse_options
+      g = Game.new(@options[:size], @options[:pause])
+      if @options[:object].eql? :glider
+        g.glider
+      else
+        g.turn_alive_random_cells
+      end
+      @options[:generations].times do
+        g.step
+      end
+    end
+
+  end
+end
+
+s = Gol::Starter.new
+s.main_script

data/lib/grid.rb

@@ -0,0 +1,159 @@
+require_relative 'cell'
+
+module Gol
+  class Grid
+    attr_accessor :cells, :size
+
+    def initialize(size)
+      @size = size
+      @cells = Array.new
+      # gives us something like [[1, 1], [1, 2], [1, 3], ...]
+      coordinates = (1..size).to_a.product((1..size).to_a)
+      coordinates.each do |co|
+        c = Cell.new
+        # we want the rows first, better for printing
+        c.x = co[1]
+        c.y = co[0]
+        @cells << c
+      end
+    end
+
+    def each
+      @cells.each do |c|
+        yield c
+      end
+    end
+
+    def get_cell(x, y)
+      correct_cell = []
+      @cells.select do |cell|
+        correct_cell << cell if (cell.x == x and cell.y == y)
+      end
+      correct_cell.first
+    end
+
+    def get_neighbours(cell)
+      x = cell.x
+      y = cell.y
+      neighbours = []
+      neighbours << get_cell_left_above(x, y)
+      neighbours << get_cell_above(x, y)
+      neighbours << get_cell_right_above(x, y)
+      neighbours << get_left_cell(x, y)
+      neighbours << get_right_cell(x, y)
+      neighbours << get_cell_left_below(x, y)
+      neighbours << get_cell_below(x, y)
+      neighbours << get_cell_right_below(x, y)
+    end
+
+    def count_living_neighbours(cell)
+      neighbours = get_neighbours(cell)
+      count = 0
+      neighbours.each do |cell|
+        count += 1 if cell.alive?
+      end
+      count
+    end
+
+    def check_survival(cell)
+      c = count_living_neighbours(cell)
+      if !cell.alive? and c == 3
+        cell.will_live = true
+      elsif cell.alive? and c < 2
+        cell.will_live = false
+      elsif cell.alive? and (c == 2 or c == 3)
+         cell.will_live = true
+      elsif cell.alive? and c > 3
+        cell.will_live = false
+      end
+    end
+
+
+
+    def get_cell_above(x, y)
+      if y == 1
+        get_cell(x, @size)
+      else
+        get_cell(x, y - 1)
+      end
+    end
+
+    def get_cell_left_above(x, y)
+      if x == 1 and y == 1
+        get_cell(@size, @size)
+      elsif x == 1
+        get_cell(@size, y - 1)
+      elsif y == 1
+        get_cell(x - 1, @size)
+      else
+        get_cell(x - 1, y - 1)
+      end
+    end
+
+    def get_cell_right_above(x, y)
+      if x == @size and y == 1
+        get_cell(1, @size)
+      elsif y == 1
+        get_cell(x + 1, @size)
+      elsif x == @size
+        get_cell(1, y - 1)
+      else
+        get_cell(x + 1, y - 1)
+      end
+    end
+
+
+    def get_left_cell(x, y)
+      if x == 1
+        get_cell(@size, y)
+      else
+        get_cell(x - 1, y)
+      end
+    end
+
+    def get_right_cell(x, y)
+      if x == @size
+        get_cell(1, y)
+      else
+        get_cell(x + 1, y)
+      end
+    end
+
+
+    def get_cell_left_below(x, y)
+      if x == 1 and y == @size
+        get_cell(@size, 1)
+      elsif x == 1
+        get_cell(@size, y + 1)
+      elsif y == @size
+        get_cell(x - 1, 1)
+      else
+        get_cell(x - 1, y + 1)
+      end
+    end
+
+
+    def get_cell_below(x, y)
+      if y == @size
+        get_cell(x, 1)
+      else
+        get_cell(x, y + 1)
+      end
+    end
+
+
+    def get_cell_right_below(x, y)
+      if x == @size and y == @size
+        get_cell(1, 1)
+      elsif y == @size
+        get_cell(x + 1, 1)
+      elsif x == @size
+        get_cell(1, y + 1)
+      else
+        get_cell(x + 1, y + 1)
+      end
+    end
+
+
+  end
+end

data/lib/spec/cell_spec.rb

@@ -0,0 +1,52 @@
+require_relative '../cell'
+
+describe Gol::Cell do
+  let(:cell) { Gol::Cell.new }
+
+  it "should know if its alive" do
+    (cell.respond_to? :alive?).should be true
+  end
+
+  it "should be killable" do
+    (cell.respond_to? :kill).should be true
+  end
+
+  it "has a x-coordinate" do
+    (cell.respond_to? :x).should be true
+  end
+
+  it "has a y-coordinate" do
+    (cell.respond_to? :y).should be true
+  end
+
+  it "should know wheter it will live in the next generation" do
+    (cell.respond_to? :will_live).should be true
+  end
+
+  it "should be able to be turned alive" do
+    (cell.respond_to? :set_alive).should be true
+  end
+
+  it "should be dead after creation" do
+    cell.alive?.should be false
+  end
+
+  it "shouldn't be marked as survivor on creation" do
+    cell.will_live?.should be false
+  end
+
+  it "should be alive after turned alive" do
+    cell.alive?.should be false
+    cell.set_alive
+    cell.alive?.should be true
+  end
+
+  it "should be dead after killing" do
+    cell.alive?.should be false
+    cell.set_alive
+    cell.alive?.should be true
+    cell.kill
+    cell.alive?.should be false
+  end
+
+end

data/lib/spec/game_spec.rb

@@ -0,0 +1,32 @@
+require_relative '../game'
+
+describe Gol::Game do
+  let(:game) { Gol::Game.new(5, 1) }
+  it "has a grid" do
+    (game.respond_to? :grid).should be true
+  end
+
+  it "should have a print method" do
+    (game.respond_to? :print_game).should be true
+  end
+
+
+  it "should be able to turn random cells alive" do
+    (game.respond_to? :turn_alive_random_cells).should be true
+  end
+
+
+  it "should be able to produce a glider" do
+    (game.respond_to? :glider).should be true
+  end
+
+
+  it "should be able to perform a step and apply the rules" do
+    (game.respond_to? :step).should be true
+    game.grid.get_cell(2, 2).alive = true
+    game.step
+    game.grid.get_cell(2, 2).alive?.should be false
+  end
+
+
+end

data/lib/spec/grid_spec.rb

@@ -0,0 +1,399 @@
+require_relative '../grid'
+
+describe Gol::Grid do
+  let(:grid) { Gol::Grid.new(5) }
+
+  it "has cells" do
+    (grid.respond_to? :cells).should be true
+  end
+
+
+  its "cells should be an Array" do
+    grid.cells.class.should be Array
+  end
+
+  its "number of cells should be size x size" do
+    grid.cells.size.should be 25
+  end
+
+  it "should be able to yield cells" do
+    (grid.respond_to? :each).should be true
+  end
+
+  it "should be able to return a specific cell" do
+    (grid.respond_to? :get_cell).should be true
+    cell = grid.get_cell(2, 2)
+    cell.x.should be 2
+    cell.y.should be 2
+  end
+
+  it "should be able to return the cell above a cell" do
+    (grid.respond_to? :get_cell_above).should be true
+    cell = grid.get_cell_above(2, 2)
+    cell.x.should be 2
+    cell.y.should be 1
+  end
+
+  it "should be able to return the cell above a cell in an unlimited grid" do
+    cell = grid.get_cell_above(3, 1)
+    cell.x.should be 3
+    cell.y.should be 5
+  end
+
+  it "should be able to return the cell left above a cell" do
+    (grid.respond_to? :get_cell_left_above).should be true
+    cell = grid.get_cell_left_above(2, 2)
+    cell.x.should be 1
+    cell.y.should be 1
+
+    cell = grid.get_cell_left_above(5, 5)
+    cell.x.should be 4
+    cell.y.should be 4
+
+    cell = grid.get_cell_left_above(2, 4)
+    cell.x.should be 1
+    cell.y.should be 3
+  end
+
+
+  it "should be able to return the cell left above a cell on an unlimited grid" do
+    cell = grid.get_cell_left_above(1, 1)
+    cell.x.should be 5
+    cell.y.should be 5
+    cell = grid.get_cell_left_above(2, 1)
+    cell.x.should be 1
+    cell.y.should be 5
+    cell = grid.get_cell_left_above(3, 1)
+    cell.x.should be 2
+    cell.y.should be 5
+    cell = grid.get_cell_left_above(4, 1)
+    cell.x.should be 3
+    cell.y.should be 5
+    cell = grid.get_cell_left_above(5, 1)
+    cell.x.should be 4
+    cell.y.should be 5
+
+    cell = grid.get_cell_left_above(1, 2)
+    cell.x.should be 5
+    cell.y.should be 1
+    cell = grid.get_cell_left_above(1, 3)
+    cell.x.should be 5
+    cell.y.should be 2
+    cell = grid.get_cell_left_above(1, 4)
+    cell.x.should be 5
+    cell.y.should be 3
+    cell = grid.get_cell_left_above(1, 5)
+    cell.x.should be 5
+    cell.y.should be 4
+  end
+
+
+  it "should be able to return the cell right above a cell" do
+    (grid.respond_to? :get_cell_right_above).should be true
+    cell = grid.get_cell_right_above(2, 2)
+    cell.x.should be 3
+    cell.y.should be 1
+
+    cell = grid.get_cell_right_above(4, 4)
+    cell.x.should be 5
+    cell.y.should be 3
+
+    cell = grid.get_cell_right_above(2, 4)
+    cell.x.should be 3
+    cell.y.should be 3
+  end
+
+
+
+  it "should be able to return the cell left above a cell on an unlimited grid" do
+    cell = grid.get_cell_right_above(5, 1)
+    cell.x.should be 1
+    cell.y.should be 5
+    cell = grid.get_cell_right_above(4, 1)
+    cell.x.should be 5
+    cell.y.should be 5
+    cell = grid.get_cell_right_above(3, 1)
+    cell.x.should be 4
+    cell.y.should be 5
+    cell = grid.get_cell_right_above(2, 1)
+    cell.x.should be 3
+    cell.y.should be 5
+    cell = grid.get_cell_right_above(1, 1)
+    cell.x.should be 2
+    cell.y.should be 5
+
+    cell = grid.get_cell_right_above(5, 2)
+    cell.x.should be 1
+    cell.y.should be 1
+    cell = grid.get_cell_right_above(5, 3)
+    cell.x.should be 1
+    cell.y.should be 2
+    cell = grid.get_cell_right_above(5, 4)
+    cell.x.should be 1
+    cell.y.should be 3
+    cell = grid.get_cell_right_above(5, 5)
+    cell.x.should be 1
+    cell.y.should be 4
+  end
+
+
+  it "should be able to return the cell left of a cell" do
+    (grid.respond_to? :get_left_cell).should be true
+    cell = grid.get_left_cell(2, 2)
+    cell.x.should be 1
+    cell.y.should be 2
+  end
+
+  it "should be able to return the cell left of a cell in an unlimited grid" do
+    cell = grid.get_left_cell(1, 4)
+    cell.x.should be 5
+    cell.y.should be 4
+  end
+
+
+  it "should be able to return the cell right of a cell" do
+    (grid.respond_to? :get_right_cell).should be true
+    cell = grid.get_right_cell(2, 2)
+    cell.x.should be 3
+    cell.y.should be 2
+  end
+
+  it "should be able to return the cell right of a cell in an unlimited grid" do
+    cell = grid.get_right_cell(5, 2)
+    cell.x.should be 1
+    cell.y.should be 2
+  end
+
+
+  it "should be able to return the cell left below a cell" do
+    (grid.respond_to? :get_cell_left_below).should be true
+    cell = grid.get_cell_left_below(2, 2)
+    cell.x.should be 1
+    cell.y.should be 3
+
+    cell = grid.get_cell_left_below(4, 4)
+    cell.x.should be 3
+    cell.y.should be 5
+
+    cell = grid.get_cell_left_below(2, 4)
+    cell.x.should be 1
+    cell.y.should be 5
+  end
+
+  it "should be able to return the cell left below a cell on an unlimited grid" do
+    cell = grid.get_cell_left_below(1, 5)
+    cell.x.should be 5
+    cell.y.should be 1
+    cell = grid.get_cell_left_below(1, 4)
+    cell.x.should be 5
+    cell.y.should be 5
+    cell = grid.get_cell_left_below(1, 3)
+    cell.x.should be 5
+    cell.y.should be 4
+    cell = grid.get_cell_left_below(1, 2)
+    cell.x.should be 5
+    cell.y.should be 3
+    cell = grid.get_cell_left_below(1, 1)
+    cell.x.should be 5
+    cell.y.should be 2
+
+    cell = grid.get_cell_left_below(2, 5)
+    cell.x.should be 1
+    cell.y.should be 1
+    cell = grid.get_cell_left_below(3, 5)
+    cell.x.should be 2
+    cell.y.should be 1
+    cell = grid.get_cell_left_below(4, 5)
+    cell.x.should be 3
+    cell.y.should be 1
+    cell = grid.get_cell_left_below(5, 5)
+    cell.x.should be 4
+    cell.y.should be 1
+  end
+
+
+  it "should be able to return the cell below a cell" do
+    (grid.respond_to? :get_cell_below).should be true
+    cell = grid.get_cell_below(2, 2)
+    cell.x.should be 2
+    cell.y.should be 3
+  end
+
+  it "should be able to return the cell below a cell in an unlimited grid" do
+    cell = grid.get_cell_below(3, 5)
+    cell.x.should be 3
+    cell.y.should be 1
+  end
+
+
+  it "should be able to return the cell right below a cell" do
+    (grid.respond_to? :get_cell_right_below).should be true
+    cell = grid.get_cell_right_below(2, 2)
+    cell.x.should be 3
+    cell.y.should be 3
+
+    cell = grid.get_cell_right_below(4, 4)
+    cell.x.should be 5
+    cell.y.should be 5
+
+    cell = grid.get_cell_right_below(2, 4)
+    cell.x.should be 3
+    cell.y.should be 5
+  end
+
+  it "should be able to return the cell right below a cell on an unlimited grid" do
+    cell = grid.get_cell_right_below(5, 5)
+    cell.x.should be 1
+    cell.y.should be 1
+    cell = grid.get_cell_right_below(4, 5)
+    cell.x.should be 5
+    cell.y.should be 1
+    cell = grid.get_cell_right_below(3, 5)
+    cell.x.should be 4
+    cell.y.should be 1
+    cell = grid.get_cell_right_below(2, 5)
+    cell.x.should be 3
+    cell.y.should be 1
+    cell = grid.get_cell_right_below(1, 5)
+    cell.x.should be 2
+    cell.y.should be 1
+
+    cell = grid.get_cell_right_below(5, 4)
+    cell.x.should be 1
+    cell.y.should be 5
+    cell = grid.get_cell_right_below(5, 3)
+    cell.x.should be 1
+    cell.y.should be 4
+    cell = grid.get_cell_right_below(5, 2)
+    cell.x.should be 1
+    cell.y.should be 3
+    cell = grid.get_cell_right_below(5, 1)
+    cell.x.should be 1
+    cell.y.should be 2
+  end
+
+  it "should be able to get all neighbours of a cell" do
+    (grid.respond_to? :get_neighbours).should be true
+    cell = grid.get_cell(2, 2)
+    neighbours = grid.get_neighbours(cell)
+    neighbours.size.should be 8
+    neighbours.first.x.should be 1
+    neighbours.first.y.should be 1
+
+    neighbours[1].x.should be 2
+    neighbours[1].y.should be 1
+
+    neighbours[2].x.should be 3
+    neighbours[2].y.should be 1
+
+    neighbours[3].x.should be 1
+    neighbours[3].y.should be 2
+
+    neighbours[4].x.should be 3
+    neighbours[4].y.should be 2
+
+    neighbours[5].x.should be 1
+    neighbours[5].y.should be 3
+
+    neighbours[6].x.should be 2
+    neighbours[6].y.should be 3
+
+    neighbours[7].x.should be 3
+    neighbours[7].y.should be 3
+  end
+
+
+  it "should be able to get all neighbours of a cell on an unlimited grid" do
+    cell = grid.get_cell(5, 5)
+    neighbours = grid.get_neighbours(cell)
+    neighbours.size.should be 8
+    # upper left
+    neighbours.first.x.should be 4
+    neighbours.first.y.should be 4
+
+    # upper
+    neighbours[1].x.should be 5
+    neighbours[1].y.should be 4
+
+    # upper right
+    neighbours[2].x.should be 1
+    neighbours[2].y.should be 4
+
+    # left
+    neighbours[3].x.should be 4
+    neighbours[3].y.should be 5
+
+    # right
+    neighbours[4].x.should be 1
+    neighbours[4].y.should be 5
+
+    # lower left
+    neighbours[5].x.should be 4
+    neighbours[5].y.should be 1
+
+    # below
+    neighbours[6].x.should be 5
+    neighbours[6].y.should be 1
+
+    # lower right
+    neighbours[7].x.should be 1
+    neighbours[7].y.should be 1
+  end
+
+  it "should be able to count living neighbours of a cell" do
+    (grid.respond_to? :count_living_neighbours).should be true
+    cell = grid.get_cell(2, 2)
+    grid.get_cell(1, 1).alive = true
+    grid.get_cell(2, 1).alive = true
+    grid.get_cell(3, 3).alive = true
+    grid.count_living_neighbours(cell).should be 3
+  end
+
+  it "should be able to check whether a cell will survive" do
+    (grid.respond_to? :check_survival).should be true
+  end
+
+  it "should apply rule one (3 living neighbours == will be alive)" do
+    cell = grid.get_cell(2, 2)
+    grid.get_cell(1, 1).alive = true
+    grid.get_cell(2, 1).alive = true
+    grid.get_cell(3, 3).alive = true
+    grid.check_survival(cell)
+    cell.will_live?.should be true
+  end
+
+  it "should apply rule two (less than 2 living neighbours == will die)" do
+    cell = grid.get_cell(2, 2)
+    cell.alive = true
+    grid.get_cell(1, 1).alive = true
+    grid.check_survival(cell)
+    cell.will_live?.should be false
+  end
+
+  it "should apply rule three (2 or 3 living neighbours == will live)" do
+    cell = grid.get_cell(2, 2)
+    cell.alive = true
+    grid.get_cell(1, 1).alive = true
+    grid.get_cell(2, 1).alive = true
+    grid.check_survival(cell)
+    cell.will_live?.should be true
+
+    grid.get_cell(3, 3).alive = true
+    grid.check_survival(cell)
+    cell.will_live?.should be true
+  end
+
+  it "should apply rule four (more than 3 neighbours == will die)" do
+    cell = grid.get_cell(2, 2)
+    grid.get_cell(1, 1).alive = true
+    grid.get_cell(2, 1).alive = true
+    grid.get_cell(3, 3).alive = true
+    grid.get_cell(1, 2).alive = true
+    grid.check_survival(cell)
+    cell.will_live?.should be false
+  end
+
+
+
+
+end

metadata

@@ -0,0 +1,54 @@
+--- !ruby/object:Gem::Specification
+name: gol
+version: !ruby/object:Gem::Version
+  version: '0.2'
+  prerelease: 
+platform: ruby
+authors:
+- Alexander Huber
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-08-03 00:00:00.000000000 Z
+dependencies: []
+description: gol lets one start random games of Game of Life with choosebale params
+  like grid size, speed, duration and objects.
+email: alih83@gmx.de
+executables:
+- gol
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/spec/cell_spec.rb
+- lib/spec/game_spec.rb
+- lib/spec/grid_spec.rb
+- lib/game.rb
+- lib/cell.rb
+- lib/grid.rb
+- lib/gol.rb
+- bin/gol
+homepage: https://github.com/alihuber
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: An implementation of Conway's Game of Life
+test_files: []