tictactoe-core 0.1.1 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0c6951ba1348109e58534d413b08206c18b0fa94
-  data.tar.gz: 8c33ce5f64a2e0215f41f6c682d8773509002e19
+  metadata.gz: 6dee06d505fa1667d90e59b321748404c70e84c7
+  data.tar.gz: 22b34d8ea0156dbc37d4d22762877ed4ba092454
 SHA512:
-  metadata.gz: 31b53621e6afa8e9aaf7f2bcd57d667ac10056f7c1d5944a6359e646a9e7a9404b0af2b11dbb23db04040a4caf17d9c3080eb252cd4c1552259f2098d0b864f5
-  data.tar.gz: a275b3c67c86b11195fe1e86baf70c4fdbf944c036a67e61b6976e32c0a9ae5e3bf2e6adbb14274718c83490e8a6e1c1f1830964af669c6ff9a9242f11285f7c
+  metadata.gz: cb5318ea5259cedc41caf36ab1fc5d2be5d31265b85eb65a8042f8e421275d2338db1d3cddf9b5d8fd9f88176ecd546a93e94eed8c5474471dd5303eac2f3e92
+  data.tar.gz: 6649004de7c777e0c34e1c8dafd55f3dda18a5ff289d13f4a127675e5b093c7a7f5dd1411a0e35c01404172c7ae9cd437e9353aa221af7b4d49217bafd098da4

data/Gemfile

@@ -1,3 +1,6 @@
 source :rubygems
-gem "rspec" , "~> 3.1.0", :group => :test
-gem "codeclimate-test-reporter", :group => :test, :require => nil
+
+group :test do
+  gem "rspec" , "~> 3.1.0"
+  gem "codeclimate-test-reporter", :require => nil
+end

data/Rakefile

@@ -27,8 +27,12 @@ task :profile do
 
   RubyProf.start
 
-  TestRun.new(4).game_winner 
+  TestRun.new(4).game_winner
 
   result = RubyProf.stop
   RubyProf::GraphHtmlPrinter.new(result).print(STDOUT)
 end
+
+task :build do
+  sh 'gem build tictactoe-core.gemspec'
+end

data/lib/tictactoe/boards/square.rb

@@ -0,0 +1,39 @@
+module Tictactoe
+  module Boards
+    class Square
+      def initialize(side_size)
+        self.side_size = side_size
+      end
+
+      def locations
+        @locations ||= (0..(side_size * side_size) -1).to_a
+      end
+
+      def lines
+        @lines ||= horizontal_lines + vertical_lines + diagonal_lines
+      end
+
+      private
+      attr_accessor :side_size
+
+      def horizontal_lines
+        locations.each_slice(side_size).to_a
+      end
+
+      def vertical_lines
+        horizontal_lines.transpose
+      end
+
+      def diagonal_lines
+        descending = (0..side_size - 1).map do |column|
+          column * (side_size + 1)
+        end
+        ascending = (1..side_size).map do |column|
+          column * (side_size - 1)
+        end
+
+        [descending, ascending]
+      end
+    end
+  end
+end

data/lib/tictactoe/game.rb

@@ -1,26 +1,17 @@
 require 'tictactoe/state'
 require 'tictactoe/sequence'
-require 'tictactoe/boards/board_type_factory'
-require 'tictactoe/ai/perfect_intelligence'
-require 'tictactoe/ai/random_chooser'
-
-require 'tictactoe/players/factory'
-require 'tictactoe/players/computer'
+require 'tictactoe/boards/square'
 
 module Tictactoe
   class Game
-    attr_accessor :board_size, :x_type, :o_type, :random
     attr_accessor :current_player, :state
+    attr_accessor :board_size, :x_type, :o_type
 
-    def initialize(board_size, x_type, o_type, random=Random.new)
-      @board_size = board_size
-      @x_type = x_type
-      @o_type = o_type
-      @random = random
-    end
-
-    def register_human_factory(factory)
-      players_factory.register(:human, factory)
+    def initialize(players_factory, board_size, x_type, o_type)
+      self.players_factory = players_factory
+      self.board_size = board_size
+      self.x_type = x_type
+      self.o_type = o_type
       reset
     end
 
@@ -32,6 +23,10 @@ module Tictactoe
       end
     end
 
+    def ready_to_tick?
+      !is_finished? && current_player.value.ready_to_move?
+    end
+
     def is_finished?
       state.is_finished?
     end
@@ -49,6 +44,8 @@ module Tictactoe
     end
 
     private
+    attr_accessor :players_factory
+
     def is_valid?(move)
       move && state.available_moves.include?(move)
     end
@@ -72,31 +69,15 @@ module Tictactoe
 
     def reset_players
       first_mark = Sequence.new([:x, :o]).first
+      players = [first_mark, first_mark.next].zip([x_type, o_type]).map do |mark, type|
+        players_factory.create(type, mark)
+      end
 
-      x_player = players_factory.create(x_type, first_mark)
-      o_player = players_factory.create(o_type, first_mark.next)
-
-      self.current_player = Sequence.new([x_player, o_player]).first
-    end
-
-    def players_factory
-      @players_factory ||= create_players_factory
-    end
-
-    def create_players_factory
-      factory = Players::Factory.new()
-      factory.register(:computer, computer_factory)
-      factory
-    end
-
-    def computer_factory
-      intelligence = Ai::PerfectIntelligence.new
-      chooser = Ai::RandomChooser.new(random)
-      lambda {|mark| Players::Computer.new(mark, intelligence, chooser)}
+      self.current_player = Sequence.new(players).first
     end
 
     def reset_state
-      self.state = State.new(Boards::BoardTypeFactory.new.create(board_size))
+      self.state = State.new(Boards::Square.new(board_size))
     end
   end
 end

data/lib/tictactoe/players/computer.rb

@@ -14,6 +14,10 @@ module Tictactoe
         chooser.choose_one(moves)
       end
 
+      def ready_to_move?
+        true
+      end
+
       private
       attr_reader :intelligence, :chooser
     end

data/lib/tictactoe/players/perfect_computer.rb

@@ -0,0 +1,30 @@
+require 'tictactoe/players/computer'
+require 'tictactoe/ai/perfect_intelligence'
+require 'tictactoe/ai/random_chooser'
+
+module Tictactoe
+  module Players
+    class PerfectComputer
+      def initialize(mark, random = Random.new)
+        intelligence = Tictactoe::Ai::PerfectIntelligence.new
+        chooser = Tictactoe::Ai::RandomChooser.new(random)
+        self.player = Tictactoe::Players::Computer.new(mark, intelligence, chooser)
+      end
+
+      def get_move(state)
+        player.get_move(state)
+      end
+
+      def mark
+        player.mark
+      end
+
+      def ready_to_move?
+        player.ready_to_move?
+      end
+
+      private
+      attr_accessor :player
+    end
+  end
+end

data/lib/tictactoe/state.rb

@@ -21,10 +21,6 @@ module Tictactoe
       self.class.new(board, new_marks)
     end
 
-    def when_finished(&block)
-      yield winner if is_finished?
-    end
-
     def is_finished?
       is_full? || has_winner?
     end
@@ -43,19 +39,9 @@ module Tictactoe
     end
 
     def find_winner
-      for line in board.lines
-        first_mark_in_line = nil
-        is_winner = true
-
-        for location in line
-          mark = marks[location]
-          first_mark_in_line ||= mark
-
-          is_winner = mark && mark == first_mark_in_line
-          break if !is_winner
-        end
-
-        return first_mark_in_line if is_winner
+      board.lines.each do |line|
+        line_marks = line.map{|location| marks[location]}
+        return line_marks.first if line_marks.all?{|mark| mark && mark == line_marks.first}
       end
 
       nil

data/spec/test_run.rb

@@ -2,18 +2,24 @@ dirname = File.expand_path(File.dirname(File.dirname(__FILE__))) + "/lib"
 $LOAD_PATH.unshift(dirname) unless $LOAD_PATH.include?(dirname)
 
 require 'tictactoe/game'
+require 'tictactoe/players/factory'
+require 'tictactoe/players/perfect_computer'
 
 class TestRun
   attr_reader :board_size, :random
+
   def initialize(board_size, random = Random.new)
     @board_size = board_size
     @random = random
   end
 
   def game_winner
-    game = Tictactoe::Game.new(board_size, :computer, :computer, random)
-    game.register_human_factory(nil)
-    game.tick() until game.is_finished?()
+    factory = Tictactoe::Players::Factory.new
+    factory.register(:computer, lambda { |mark| Tictactoe::Players::PerfectComputer.new(mark, random) })
+
+    game = Tictactoe::Game.new(factory, board_size, :computer, :computer)
+
+    game.tick until game.is_finished?
     game.winner
   end
 end

data/spec/tictactoe/ai/perfect_intelligence_spec.rb

@@ -2,12 +2,11 @@ require 'spec_helper'
 require 'tictactoe/ai/perfect_intelligence'
 require 'tictactoe/state'
 require 'tictactoe/sequence'
-require 'tictactoe/boards/three_by_three_board'
-require 'tictactoe/boards/four_by_four_board'
+require 'tictactoe/boards/square'
 
 RSpec.describe Tictactoe::Ai::PerfectIntelligence do
   def board(*marks)
-    state = Tictactoe::State.new(Tictactoe::Boards::ThreeByThreeBoard.new)
+    state = Tictactoe::State.new(Tictactoe::Boards::Square.new(3))
     marks.each_with_index do |mark, location|
       state = state.make_move(location, mark)
     end
@@ -36,7 +35,7 @@ RSpec.describe Tictactoe::Ai::PerfectIntelligence do
     )
     expect(play(state)).to eq [4]
   end
-  
+
   it 'given the possibility to lose, should block, not matter if there is a fork comming' do
     state = board(
       :x, nil, nil,
@@ -50,7 +49,7 @@ RSpec.describe Tictactoe::Ai::PerfectIntelligence do
     state = board(
       :x,  :o,  :x,
       :o,  :x,  :o,
-      nil, nil, :o 
+      nil, nil, :o
     )
     expect(play(state)).to eq [6]
   end
@@ -103,7 +102,7 @@ RSpec.describe Tictactoe::Ai::PerfectIntelligence do
   end
 
   def board4(*marks)
-    state = Tictactoe::State.new(Tictactoe::Boards::FourByFourBoard.new)
+    state = Tictactoe::State.new(Tictactoe::Boards::Square.new(4))
     marks.each_with_index do |mark, location|
       state = state.make_move(location, mark)
     end

data/spec/tictactoe/boards/board_type_factory_spec.rb

@@ -1,16 +1,64 @@
 require 'spec_helper'
-require 'tictactoe/boards/board_type_factory'
+require 'tictactoe/boards/square'
 
-RSpec.describe Tictactoe::Boards::BoardTypeFactory do
+RSpec.describe Tictactoe::Boards::Square do
   def create(side_size)
-    described_class.new.create(side_size)
+    described_class.new(side_size)
   end
 
-  it 'given 3 returns a ThreeByThreeBoard' do
-    expect(create(3)).to be_an_instance_of(Tictactoe::Boards::ThreeByThreeBoard)
+  describe 'given size 3' do
+    let(:board) { create(3) }
+
+    it "should know the available locations" do
+      expect(board.locations).to eq([0, 1, 2, 3, 4, 5, 6, 7, 8])
+    end
+
+    it "should know the lines" do
+      expected_lines = [
+        [0, 1, 2],
+        [3, 4, 5],
+        [6, 7, 8],
+
+        [0, 3, 6],
+        [1, 4, 7],
+        [2, 5, 8],
+
+        [0, 4, 8],
+        [2, 4, 6],
+      ]
+      actual_lines = board.lines
+
+      expect(actual_lines).to match_array(expected_lines)
+    end
   end
-  
-  it 'given 4 returns a FourByFourBoard' do
-    expect(create(4)).to be_an_instance_of(Tictactoe::Boards::FourByFourBoard)
+
+  describe 'given size 4' do
+    let(:board) { create(4) }
+
+    it 'has the possible locations' do
+      expect(board.locations).to eq([
+        0, 1, 2, 3,
+        4, 5, 6, 7,
+        8, 9, 10, 11,
+        12, 13, 14, 15
+      ])
+    end
+
+    it 'should know the lines' do
+      expect(board.lines).to eq([
+        [0, 1, 2, 3],
+        [4, 5, 6, 7],
+        [8, 9, 10, 11],
+        [12, 13, 14, 15],
+
+        [0, 4, 8, 12],
+        [1, 5, 9, 13],
+        [2, 6, 10, 14],
+        [3, 7, 11, 15],
+
+        [0, 5, 10, 15],
+        [3, 6, 9, 12]
+      ])
+    end
   end
 end

data/spec/tictactoe/game_spec.rb

@@ -1,34 +1,51 @@
 require 'tictactoe/game'
+require 'tictactoe/players/factory'
+require 'tictactoe/players/perfect_computer'
 
 RSpec.describe Tictactoe::Game do
   class Human
     attr_reader :mark
 
     def initialize(mark, moves)
-      @mark = mark 
+      @mark = mark
       @moves = moves
     end
 
     def get_move(state)
       @moves.pop
     end
+
+    def ready_to_move?
+      !@moves.empty?
+    end
+  end
+
+  class FixedRandom
+    def rand
+      0.0
+    end
   end
 
-  let(:moves){[]}
+  let(:moves) { [] }
 
   def create(board_size, x_type, o_type)
-    game = described_class.new(board_size, x_type, o_type)
-    game.register_human_factory(lambda{|mark| Human.new(mark, moves)})
-    game
+    computer_factory = lambda { |mark| Tictactoe::Players::PerfectComputer.new(mark, FixedRandom.new) }
+    human_factory = lambda { |mark| Human.new(mark, moves) }
+
+    factory = Tictactoe::Players::Factory.new
+    factory.register(:computer, computer_factory)
+    factory.register(:human, human_factory)
+
+    described_class.new(factory, board_size, x_type, o_type)
   end
 
   def human_tick_playing_to(game, loc)
     moves << loc
-    game.tick()
+    game.tick
   end
-  
+
   def computer_tick(game)
-    game.tick()
+    game.tick
   end
 
   def expect_amount_of_marks(game, mark, expected_count)
@@ -41,6 +58,32 @@ RSpec.describe Tictactoe::Game do
     expect(game.is_finished?).to eq(false)
   end
 
+  it 'is not ready to tick when the player is not ready to move' do
+    game = create(3, :human, :human)
+    expect(game.ready_to_tick?).to eq false
+  end
+
+  it 'is ready to tick when the player is ready to move' do
+    game = create(3, :human, :human)
+    moves << 0
+    expect(game.ready_to_tick?).to eq true
+  end
+
+  it 'is not ready to tick when the player is ready to move but the game has finished' do
+    game = create(3, :human, :human)
+    human_tick_playing_to(game, 0)
+    human_tick_playing_to(game, 1)
+    human_tick_playing_to(game, 2)
+    human_tick_playing_to(game, 5)
+    human_tick_playing_to(game, 3)
+    human_tick_playing_to(game, 6)
+    human_tick_playing_to(game, 4)
+    human_tick_playing_to(game, 8)
+    human_tick_playing_to(game, 7)
+    moves << 0
+    expect(game.ready_to_tick?).to eq false
+  end
+
   describe 'can be observed' do
     it 'initial game size 3' do
       game = create(3, :human, :human)
@@ -70,7 +113,7 @@ RSpec.describe Tictactoe::Game do
         nil, nil, nil
       ])
     end
-    
+
     it 'first play of o on size 3' do
       game = create(3, :human, :human)
       human_tick_playing_to(game, 0)
@@ -126,7 +169,7 @@ RSpec.describe Tictactoe::Game do
       human_tick_playing_to(game, 6)
       expect(game.is_finished?).to eq(false)
     end
-    
+
     it do
       game = create(3, :human, :human)
       human_tick_playing_to(game, 0)

data/spec/tictactoe/players/computer_spec.rb

@@ -27,8 +27,12 @@ RSpec.describe Tictactoe::Players::Computer do
 
   it 'has a mark' do
     computer = create(:x)
-    expect(computer.mark).to eq(:x)   
+    expect(computer.mark).to eq(:x)
+  end
 
+  it 'is ready to move' do
+    computer = create(:x)
+    expect(computer.ready_to_move?).to eq(true)
   end
 
   it 'can make a move' do

data/spec/tictactoe/state_spec.rb

@@ -1,6 +1,5 @@
 require 'spec_helper'
 require 'tictactoe/state'
-require 'tictactoe/boards/three_by_three_board'
 
 RSpec.describe Tictactoe::State do
   def look_at(state, location)
@@ -12,18 +11,16 @@ RSpec.describe Tictactoe::State do
   end
 
   def expect_finished(expected)
-    finished = @state.when_finished{true} || false
-    expect(finished).to eq(expected)
+    expect(@state.is_finished?).to eq(expected)
   end
 
   def expect_winner(expected)
-    actual_winner = @state.when_finished{|winner| winner}
-    expect(actual_winner).to eq(expected)
+    expect(@state.winner).to eq(expected)
   end
 
   describe "given a 3x3 board" do
     before(:each) do
-      @board = Tictactoe::Boards::ThreeByThreeBoard.new
+      @board = Tictactoe::Boards::Square.new(3)
       @state = described_class.new(@board)
     end
 
@@ -73,7 +70,7 @@ RSpec.describe Tictactoe::State do
       end
     end
 
-    Tictactoe::Boards::ThreeByThreeBoard.new.lines.each do |line|
+    Tictactoe::Boards::Square.new(3).lines.each do |line|
       describe "with a line for player a" do
         before(:each) do
           line.each do |l|

data/tictactoe-core.gemspec

@@ -1,7 +1,7 @@
 Gem::Specification.new do |s|
   s.name = "tictactoe-core"
-  s.version = "0.1.1"
-  s.date = %q{2015-05-21}
+  s.version = "0.1.2"
+  s.date = %q{2015-06-11}
 
   s.summary = "The core logic of a tic-tac-toe implementation"
   s.description = "The core logic of a tic-tac-toe implementation written as part of 8th Light's apprenticeship"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tictactoe-core
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors:
 - Mateu Adsuara
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-05-21 00:00:00.000000000 Z
+date: 2015-06-11 00:00:00.000000000 Z
 dependencies: []
 description: The core logic of a tic-tac-toe implementation written as part of 8th
   Light's apprenticeship
@@ -27,12 +27,11 @@ files:
 - lib/tictactoe/ai/perfect_intelligence.rb
 - lib/tictactoe/ai/random_chooser.rb
 - lib/tictactoe/ai/tree.rb
-- lib/tictactoe/boards/board_type_factory.rb
-- lib/tictactoe/boards/four_by_four_board.rb
-- lib/tictactoe/boards/three_by_three_board.rb
+- lib/tictactoe/boards/square.rb
 - lib/tictactoe/game.rb
 - lib/tictactoe/players/computer.rb
 - lib/tictactoe/players/factory.rb
+- lib/tictactoe/players/perfect_computer.rb
 - lib/tictactoe/sequence.rb
 - lib/tictactoe/state.rb
 - runtests.sh
@@ -48,14 +47,11 @@ files:
 - spec/tictactoe/ai/perfect_intelligence_spec.rb
 - spec/tictactoe/ai/random_choser_spec.rb
 - spec/tictactoe/boards/board_type_factory_spec.rb
-- spec/tictactoe/boards/four_by_four_board_spec.rb
-- spec/tictactoe/boards/three_by_three_board_spec.rb
 - spec/tictactoe/game_spec.rb
 - spec/tictactoe/players/computer_spec.rb
 - spec/tictactoe/players/factory_spec.rb
 - spec/tictactoe/sequence_spec.rb
 - spec/tictactoe/state_spec.rb
-- tictactoe-core-0.1.0.gem
 - tictactoe-core.gemspec
 homepage: https://github.com/demonh3x/tictactoe-core.rb
 licenses:

data/lib/tictactoe/boards/board_type_factory.rb

@@ -1,15 +0,0 @@
-require 'tictactoe/boards/three_by_three_board'
-require 'tictactoe/boards/four_by_four_board'
-
-module Tictactoe
-  module Boards
-    class BoardTypeFactory
-      def create(side_size)
-        case side_size
-        when 3 then ThreeByThreeBoard.new
-        when 4 then FourByFourBoard.new
-        end
-      end
-    end
-  end
-end

data/lib/tictactoe/boards/four_by_four_board.rb

@@ -1,28 +0,0 @@
-module Tictactoe
-  module Boards
-    class FourByFourBoard
-      LOCATIONS = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]
-
-      HORIZONTAL_LINES = [
-        [0, 1, 2, 3],
-        [4, 5, 6, 7],
-        [8, 9, 10, 11],
-        [12, 13, 14, 15],
-      ]
-      VERTICAL_LINES = HORIZONTAL_LINES.transpose
-      DIAGONALS = [
-        [0, 5, 10, 15],
-        [3, 6, 9, 12],
-      ]
-      LINES = HORIZONTAL_LINES + VERTICAL_LINES + DIAGONALS
-
-      def locations
-        LOCATIONS
-      end
-
-      def lines
-        LINES
-      end
-    end
-  end
-end

data/lib/tictactoe/boards/three_by_three_board.rb

@@ -1,27 +0,0 @@
-module Tictactoe
-  module Boards
-    class ThreeByThreeBoard
-      LOCATIONS = [0, 1, 2, 3, 4, 5, 6, 7, 8]
-
-      HORIZONTAL_LINES = [
-        [0, 1, 2],
-        [3, 4, 5],
-        [6, 7, 8],
-      ]
-      VERTICAL_LINES = HORIZONTAL_LINES.transpose
-      DIAGONALS = [
-        [0, 4, 8],
-        [2, 4, 6],
-      ]
-      LINES = HORIZONTAL_LINES + VERTICAL_LINES + DIAGONALS
-
-      def locations
-        LOCATIONS
-      end
-
-      def lines
-        LINES
-      end
-    end
-  end
-end

data/spec/tictactoe/boards/four_by_four_board_spec.rb

@@ -1,30 +0,0 @@
-require 'spec_helper'
-require 'tictactoe/boards/four_by_four_board'
-
-RSpec.describe Tictactoe::Boards::FourByFourBoard do
-   it 'has the possible locations' do
-     expect(described_class.new.locations).to eq([
-       0, 1, 2, 3,
-       4, 5, 6, 7,
-       8, 9, 10, 11,
-       12, 13, 14, 15
-     ])
-   end
-
-   it 'should know the lines' do
-     expect(described_class.new.lines).to eq([
-       [0, 1, 2, 3],
-       [4, 5, 6, 7],
-       [8, 9, 10, 11],
-       [12, 13, 14, 15],
-
-       [0, 4, 8, 12],
-       [1, 5, 9, 13],
-       [2, 6, 10, 14],
-       [3, 7, 11, 15],
-
-       [0, 5, 10, 15],
-       [3, 6, 9, 12]
-     ])
-   end
-end

data/spec/tictactoe/boards/three_by_three_board_spec.rb

@@ -1,30 +0,0 @@
-require 'spec_helper'
-require 'tictactoe/boards/three_by_three_board'
-
-RSpec.describe Tictactoe::Boards::ThreeByThreeBoard do
-  before(:each) do
-    @board = described_class.new
-  end
-
-  it "should know the available locations" do
-    expect(@board.locations).to eq([0, 1, 2, 3, 4, 5, 6, 7, 8])
-  end
-
-  it "should know the lines" do
-    expected_lines = [
-      [0, 1, 2],
-      [3, 4, 5],
-      [6, 7, 8],
-
-      [0, 3, 6],
-      [1, 4, 7],
-      [2, 5, 8],
-
-      [0, 4, 8],
-      [2, 4, 6],
-    ]
-    actual_lines = @board.lines
-
-    expect(actual_lines).to match_array(expected_lines)
-  end
-end