tic_tac_toes 0.0.7 → 0.0.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 46bd6a4b98b10769789684336cfc57eca3541e20
-  data.tar.gz: 95409188361e77e87b4eb687748dfeb34f7d2dc2
+  metadata.gz: 085e4d7d1fd5316dd0a28ca154203ae9411e3c2f
+  data.tar.gz: ef98016568277620377b83e02aa0ea58827a379b
 SHA512:
-  metadata.gz: 52ed4db96736d0fcc5ab1ce93d81acad04244aa77a7bdec19fd88021aaac87a76db638027419a5332a7aee59f2abe2f4734b5d6f5c66d2666b3f8d1f637f2a7c
-  data.tar.gz: 8c127e6cdec642f082c17f87f2626125343d2dafd66d0d5436fca4ceb088a8e0c198326339237387bec3589a3513945fd8ed7852dd67059ffbdb20c5df1d98cf
+  metadata.gz: 688112f80e57889cbd0cf27e190f3f2a7a8e41dc6823ef9ee1d47bf622cd5f554c52b8684c4332c97d838ea923c5b32cb2f0687f92f9a2d3ff9169c5730ba308
+  data.tar.gz: ccf022fc972444762499b6ac6a9450dc91ae27be064d24692c11cbdfe232814ff6ad18425e98f56c052c6649aa8de7a0a3c56b1f664fea422ec3aee2db4af24a

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    tic_tac_toes (0.0.7)
+    tic_tac_toes (0.0.8)
       pg
 
 GEM

data/Rakefile

@@ -1,4 +1,4 @@
 require 'bundler/gem_tasks'
 
-load './lib/tasks/set_up_databases.rake'
-load './lib/tasks/destroy_databases.rake'
+load './lib/tic_tac_toes/tasks/set_up_databases.rake'
+load './lib/tic_tac_toes/tasks/destroy_databases.rake'

data/bin/tic_tac_toes

@@ -2,34 +2,30 @@
 
 $LOAD_PATH << File.expand_path(File.dirname(__FILE__) + '/../lib')
 
-require 'command_line/prompt'
-require 'tic_tac_toes/io'
+require 'tic_tac_toes/command_line/prompt'
+require 'tic_tac_toes/core/io'
 
-require 'tic_tac_toes/board_factory'
-require 'tic_tac_toes/player_factory'
-require 'command_line/menu'
+require 'tic_tac_toes/core/board_factory'
+require 'tic_tac_toes/core/player_factory'
+require 'tic_tac_toes/command_line/menu'
 
-require 'tic_tac_toes/rules'
+require 'tic_tac_toes/database/pg_wrapper'
+require 'tic_tac_toes/core/history'
+require 'tic_tac_toes/core/game_state_factory'
 
-require 'database/pg_wrapper'
-require 'tic_tac_toes/history'
-require 'tic_tac_toes/game_state_factory'
-
-require 'command_line/runner'
+require 'tic_tac_toes/command_line/runner'
 
 database = "tic_tac_toes"
 
-prompt = CommandLine::Prompt
-io = TicTacToes::IO.new(prompt)
-
-board_factory = TicTacToes::BoardFactory.new
-player_factory = TicTacToes::PlayerFactory.new(io)
-menu = CommandLine::Menu.new(io, board_factory, player_factory)
+prompt = TicTacToes::CommandLine::Prompt
+io = TicTacToes::Core::IO.new(prompt)
 
-database_wrapper = Database::PGWrapper.new(database)
-history = TicTacToes::History.new(database_wrapper)
-game_state_factory = TicTacToes::GameStateFactory.new(history)
+board_factory = TicTacToes::Core::BoardFactory.new
+player_factory = TicTacToes::Core::PlayerFactory.new(io)
+menu = TicTacToes::CommandLine::Menu.new(io, board_factory, player_factory)
 
-rules = TicTacToes::Rules
+database_wrapper = TicTacToes::Database::PGWrapper.new(database)
+history = TicTacToes::Core::History.new(database_wrapper)
+game_state_factory = TicTacToes::Core::GameStateFactory.new(history)
 
-CommandLine::Runner.new(io, menu, game_state_factory, rules).run
+TicTacToes::CommandLine::Runner.new(io, menu, game_state_factory).run

data/lib/tic_tac_toes/command_line/menu.rb

@@ -0,0 +1,55 @@
+require 'tic_tac_toes/core/rules'
+
+module TicTacToes
+  module CommandLine
+    class Menu
+      def initialize(io, board_factory, player_factory)
+        @io = io
+        @board_factory = board_factory
+        @player_factory = player_factory
+      end
+
+      def get_board
+        @board_factory.generate_board(get_row_size)
+      end
+
+      def get_players
+        taken_tokens = []
+        human_token = get_token(:human, taken_tokens)
+        taken_tokens << human_token
+        computer_token = get_token(:computer, taken_tokens)
+        difficulty = get_difficulty
+
+        human_player = @player_factory.generate_human_player(human_token)
+        computer_player = @player_factory.generate_computer_player(computer_token, difficulty)
+        [human_player, computer_player]
+      end
+
+      private
+
+      def get_row_size
+        loop do
+          row_size = @io.get_row_size
+          break row_size if Core::Rules.row_size_valid?(row_size)
+          @io.invalid_row_size_error
+        end
+      end
+
+      def get_token(player, taken_tokens)
+        loop do
+          token = @io.get_token(player)
+          break token if Core::Rules.token_valid?(token, taken_tokens)
+          @io.invalid_token_error
+        end
+      end
+
+      def get_difficulty
+        loop do
+          difficulty = @io.get_difficulty
+          break difficulty if Core::Rules.difficulty_valid?(difficulty)
+          @io.invalid_difficulty_error
+        end
+      end
+    end
+  end
+end

data/lib/tic_tac_toes/command_line/prompt.rb

@@ -0,0 +1,29 @@
+module TicTacToes
+  module CommandLine
+    module Prompt
+      def self.solicit_input
+        gets.chomp
+      end
+
+      def self.display(message)
+        puts message
+      end
+
+      def self.display_red(message)
+        puts red(message)
+      end
+
+      def self.red(message)
+        colorize(message, 31)
+      end
+
+      def self.blue(message)
+        colorize(message, 34)
+      end
+
+      def self.colorize(message, color_code)
+        "\e[#{color_code}m#{message}\e[0m"
+      end
+    end
+  end
+end

data/lib/tic_tac_toes/command_line/runner.rb

@@ -0,0 +1,38 @@
+module TicTacToes
+  module CommandLine
+    class Runner
+      def initialize(io, menu, game_state_factory)
+        @io = io
+        @menu = menu
+        @game_state_factory = game_state_factory
+      end
+
+      def run
+        board, players = @menu.get_board, @menu.get_players
+        game_state = @game_state_factory.generate_game_state(board, players)
+
+        take_turn(game_state) until game_state.game_over?
+        end_game(game_state)
+      end
+
+      private
+
+      def take_turn(game_state)
+        @io.draw_board(game_state.board)
+        @io.thinking_notification if game_state.current_player.needs_to_think
+
+        move = game_state.current_player.place_and_return_move(game_state.board, game_state.players)
+        game_state.turn_over(move)
+      end
+
+      def end_game(game_state)
+        @io.draw_board(game_state.board)
+
+        winner = game_state.determine_winner
+        game_state.game_over(winner)
+
+        @io.game_over_notification(winner)
+      end
+    end
+  end
+end

data/lib/tic_tac_toes/core/board.rb

@@ -0,0 +1,64 @@
+module TicTacToes
+  module Core
+    class Board
+      attr_reader :row_size, :size, :spaces
+
+      def initialize(row_size: 3)
+        @row_size = row_size
+        @size = @row_size**2
+        @spaces = Array.new(@size)
+      end
+
+      def place(player, space)
+        @spaces[space] = player if valid?(space)
+      end
+
+      def space(space)
+        @spaces[space]
+      end
+
+      def open_spaces
+        open_spaces = []
+
+        @spaces.each_with_index do |space, index|
+          open_spaces << index if space.nil?
+        end
+
+        open_spaces
+      end
+
+      def rows
+        @spaces.each_slice(@row_size).to_a
+      end
+
+      def columns
+        rows.transpose
+      end
+
+      def diagonals
+        back_diagonal, front_diagonal = [], []
+
+        rows.each_with_index do |row, index|
+          back_diagonal << row[index]
+          front_diagonal << row[@row_size - (index + 1)]
+        end
+
+        [back_diagonal, front_diagonal]
+      end
+
+      def full?
+        @spaces.all? { |space| !space.nil? }
+      end
+
+      private
+
+      def valid?(space)
+        space_empty = @spaces[space].nil?
+        board_range = 0..(@size - 1)
+        on_the_board = board_range.include? space
+
+        space_empty && on_the_board
+      end
+    end
+  end
+end

data/lib/tic_tac_toes/core/board_factory.rb

@@ -0,0 +1,11 @@
+require 'tic_tac_toes/core/board'
+
+module TicTacToes
+  module Core
+    class BoardFactory
+      def generate_board(row_size)
+        Board.new(row_size: row_size)
+      end
+    end
+  end
+end

data/lib/tic_tac_toes/core/game_state.rb

@@ -0,0 +1,40 @@
+require 'tic_tac_toes/core/rules'
+
+module TicTacToes
+  module Core
+    class GameState
+      attr_reader :board, :players
+
+      def initialize(board, players, history)
+        @board = board
+        @players = players
+        @history = history
+        @rules = Rules
+
+        @history.record_board_size(@board.size)
+      end
+
+      def current_player
+        @players.first
+      end
+
+      def turn_over(move)
+        @history.record_move(move)
+        @players.rotate!
+      end
+
+      def game_over(winner)
+        @history.record_winner(winner)
+        @history.persist
+      end
+
+      def game_over?
+        @rules.game_over?(@board, @players)
+      end
+
+      def determine_winner
+        @rules.determine_winner(@board, @players)
+      end
+    end
+  end
+end

data/lib/tic_tac_toes/core/game_state_factory.rb

@@ -0,0 +1,15 @@
+require 'tic_tac_toes/core/game_state'
+
+module TicTacToes
+  module Core
+    class GameStateFactory
+      def initialize(history)
+        @history = history
+      end
+
+      def generate_game_state(board, players)
+        GameState.new(board, players, @history)
+      end
+    end
+  end
+end

data/lib/tic_tac_toes/core/history.rb

@@ -0,0 +1,29 @@
+module TicTacToes
+  module Core
+    class History
+      attr_reader :board_size, :moves, :winner
+
+      def initialize(database_wrapper)
+        @database_wrapper = database_wrapper
+      end
+
+      def record_board_size(size)
+        @board_size = size
+      end
+
+      def record_move(move)
+        @moves ||= []
+        @moves << move
+      end
+
+      def record_winner(winner)
+        winner = "Draw" if winner.nil?
+        @winner = winner
+      end
+
+      def persist
+        @database_wrapper.record_game_history(self)
+      end
+    end
+  end
+end

data/lib/tic_tac_toes/core/io.rb

@@ -0,0 +1,93 @@
+require 'tic_tac_toes/core/strings'
+
+module TicTacToes
+  module Core
+    class IO
+      def initialize(io_strategy)
+        @io_strategy = io_strategy
+      end
+
+      def get_row_size
+        row_size_solicitation
+
+        Integer(@io_strategy.solicit_input)
+        rescue ArgumentError
+          not_an_integer_error
+          get_row_size
+      end
+
+      def get_token(player)
+        token_solicitation(player)
+        @io_strategy.solicit_input
+      end
+
+      def get_difficulty
+        difficulty_solicitation
+        @io_strategy.solicit_input.downcase.to_sym
+      end
+
+      def draw_board(board)
+        @io_strategy.display(Strings.board(board))
+      end
+
+      def invalid_row_size_error
+        @io_strategy.display_red(Strings::INVALID_ROW_SIZE)
+      end
+
+      def invalid_token_error
+        @io_strategy.display_red(Strings::INVALID_TOKEN)
+      end
+
+      def invalid_difficulty_error
+        @io_strategy.display_red(Strings::INVALID_DIFFICULTY)
+      end
+
+      def invalid_move_error
+        @io_strategy.display_red(Strings::INVALID_MOVE)
+      end
+
+      def thinking_notification
+        @io_strategy.display_red(Strings::THINKING)
+      end
+
+      def game_over_notification(winner)
+        winner = "Nobody" if winner.nil?
+        @io_strategy.display(Strings.game_over_notification(winner))
+      end
+
+      def move_solicitation
+        @io_strategy.display(Strings::MOVE_SOLICITATION)
+      end
+
+      def not_an_integer_error
+        @io_strategy.display_red(Strings::NOT_AN_INTEGER)
+      end
+
+      def solicit_input
+        @io_strategy.solicit_input
+      end
+
+      def red(message)
+        @io_strategy.red(message)
+      end
+
+      def blue(message)
+        @io_strategy.blue(message)
+      end
+
+      private
+
+      def row_size_solicitation
+        @io_strategy.display(Strings::ROW_SIZE_SOLICITATION)
+      end
+
+      def token_solicitation(player)
+        @io_strategy.display(Strings.token_solicitation(player))
+      end
+
+      def difficulty_solicitation
+        @io_strategy.display(Strings::DIFFICULTY_SOLICITATION)
+      end
+    end
+  end
+end

data/lib/tic_tac_toes/core/move_strategies/easy_ai.rb

@@ -0,0 +1,13 @@
+require 'tic_tac_toes/core/board'
+
+module TicTacToes
+  module Core
+    module MoveStrategies
+      module EasyAI
+        def self.move(board, players)
+          board.open_spaces.sample
+        end
+      end
+    end
+  end
+end

data/lib/tic_tac_toes/core/move_strategies/hard_ai.rb

@@ -0,0 +1,89 @@
+require 'tic_tac_toes/core/rules'
+
+module TicTacToes
+  module Core
+    module MoveStrategies
+      module HardAI
+        def self.move(board, players)
+          return second_move(board) if nine_board_second_move?(board)
+
+          open_spaces = Hash[board.open_spaces.map { |space| [space, nil] }]
+
+          open_spaces.each do |space, score|
+            score = minimax(generate_board(players.first, space, board), :min, players)
+            open_spaces[space] = score
+          end
+
+          best_score = open_spaces.values.max
+          open_spaces.each { |space, score| return space if score == best_score }
+        end
+
+        private
+
+        def self.minimax(board, current_player, players)
+          return score(board, players) if Rules.game_over?(board, players)
+
+          if current_player == :max
+            best_score = -1
+            board.open_spaces.each do |space|
+              score = minimax(generate_board(players.first, space, board), :min, players)
+              best_score = [best_score, score].max
+            end
+            best_score
+
+          elsif current_player == :min
+            best_score = 1
+            board.open_spaces.each do |space|
+              score = minimax(generate_board(players.last, space, board), :max, players)
+              best_score = [best_score, score].min
+            end
+            best_score
+          end
+        end
+
+        def self.generate_board(player, space, board)
+          new_board = Marshal.load(Marshal.dump(board))
+          new_board.place(player, space)
+          new_board
+        end
+
+        def self.score(board, players)
+          own_token, opponent_token = players.first.token, players.last.token
+
+          case Rules.determine_winner(board, players)
+          when own_token
+            1
+          when opponent_token
+            -1
+          else
+            0
+          end
+        end
+
+        def self.nine_board_second_move?(board)
+          board.size == 9 && board.open_spaces.count == 8
+        end
+
+        def self.second_move(board)
+          if nine_board_corner_occupied(board) || nine_board_side_occupied(board)
+            4
+          elsif nine_board_center_occupied(board)
+            0
+          end
+        end
+
+        def self.nine_board_corner_occupied(board)
+          board.space(0) || board.space(2) || board.space(6) || board.space(8)
+        end
+
+        def self.nine_board_side_occupied(board)
+          board.space(1) || board.space(3) || board.space(5) || board.space(7)
+        end
+
+        def self.nine_board_center_occupied(board)
+          board.space(4) ? true : false
+        end
+      end
+    end
+  end
+end

data/lib/tic_tac_toes/core/move_strategies/human.rb

@@ -0,0 +1,20 @@
+module TicTacToes
+  module Core
+    module MoveStrategies
+      class Human
+        def initialize(io)
+          @io = io
+        end
+
+        def move(board, players)
+          @io.move_solicitation
+
+          Integer(@io.solicit_input)
+          rescue ArgumentError
+            @io.not_an_integer_error
+            move(board, players)
+        end
+      end
+    end
+  end
+end

data/lib/tic_tac_toes/core/move_strategies/medium_ai.rb

@@ -0,0 +1,15 @@
+require 'tic_tac_toes/core/move_strategies/easy_ai'
+require 'tic_tac_toes/core/move_strategies/hard_ai'
+
+module TicTacToes
+  module Core
+    module MoveStrategies
+      module MediumAI
+        def self.move(board, players)
+          move_strategy = [EasyAI, HardAI, HardAI].sample
+          move_strategy.move(board, players)
+        end
+      end
+    end
+  end
+end

data/lib/tic_tac_toes/core/player.rb

@@ -0,0 +1,22 @@
+module TicTacToes
+  module Core
+    class Player
+      attr_reader :move_strategy, :token, :needs_to_think
+
+      def initialize(move_strategy, token, needs_to_think, io)
+        @move_strategy = move_strategy
+        @token = token
+        @needs_to_think = needs_to_think
+        @io = io
+      end
+
+      def place_and_return_move(board, players)
+        loop do
+          space = @move_strategy.move(board, players)
+          break [@token, space] if board.place(self, space)
+          @io.invalid_move_error
+        end
+      end
+    end
+  end
+end

data/lib/tic_tac_toes/core/player_factory.rb

@@ -0,0 +1,30 @@
+require 'tic_tac_toes/core/move_strategies/human'
+require 'tic_tac_toes/core/move_strategies/easy_ai'
+require 'tic_tac_toes/core/move_strategies/medium_ai'
+require 'tic_tac_toes/core/move_strategies/hard_ai'
+require 'tic_tac_toes/core/player'
+
+module TicTacToes
+  module Core
+    class PlayerFactory
+      def initialize(io)
+        @io = io
+      end
+
+      AIS = {
+        easy:    ::TicTacToes::Core::MoveStrategies::EasyAI,
+        medium:  ::TicTacToes::Core::MoveStrategies::MediumAI,
+        hard:    ::TicTacToes::Core::MoveStrategies::HardAI }
+
+      def generate_human_player(token)
+        needs_to_think = false
+        Player.new(TicTacToes::Core::MoveStrategies::Human.new(@io), token, needs_to_think, @io)
+      end
+
+      def generate_computer_player(token, difficulty)
+        needs_to_think = true
+        Player.new(AIS[difficulty], token, needs_to_think, @io)
+      end
+    end
+  end
+end