tic_tac_toes 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 18a1a5f19c58b04046be154ce6371a79b5c613f2
+  data.tar.gz: d856bf4e9b49e86407f173c5a303c0d920202938
+SHA512:
+  metadata.gz: 0424458bf16942f7728584c4b4ec040164ce468f8c7a5fb31a0c671c871de601b2d945d46912cce466ab646afce7503dd0ad1d43350e427aa33a0fd4b0fba158
+  data.tar.gz: ce07f69665def752ea0f74c959764bab06fdf683bcbe984d4971693df77ad8ce741b48651d728ce3be3382cc1a0a78f13a1433e12accf5c1d41d4f7ce8a54ee6

data/.gitignore

@@ -0,0 +1,23 @@
+*.gem
+*.rbc
+.bundle
+.DS_Store
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/Gemfile

@@ -0,0 +1,6 @@
+source 'https://rubygems.org'
+ruby '2.1.1'
+#ruby-gemset=tic_tac_toe
+
+# Specify your gem's dependencies in tic_tac_toe.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 bspatafora
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,8 @@
+# TicTacToes
+
+The game Tic-tac-toe, featuring an unbeatable AI.
+
+## Usage
+
+1. Install the gem: `gem install tic_tac_toes`
+2. Launch the game: `tic_tac_toes`

data/Rakefile

@@ -0,0 +1,25 @@
+require "bundler/gem_tasks"
+require 'pg'
+
+task :create_tables do
+  connection = establish_connection
+  connection.exec("CREATE TABLE games (
+    id serial primary key,
+    board_size integer,
+    winner varchar)")
+  connection.exec("CREATE TABLE moves (
+    game integer REFERENCES games (id),
+    number integer,
+    token varchar,
+    space integer)")
+end
+
+task :destroy_tables do
+  connection = establish_connection
+  connection.exec("DROP TABLE moves")
+  connection.exec("DROP TABLE games")
+end
+
+def establish_connection
+  PG.connect(dbname: "tic_tac_toes")
+end

data/bin/tic_tac_toes

@@ -0,0 +1,23 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH << File.expand_path(File.dirname(__FILE__) + '/../lib')
+
+require 'command_line/io'
+require 'command_line/menu'
+require 'database/pg_wrapper'
+require 'tic_tac_toes/io_interface'
+require 'tic_tac_toes/rules'
+require 'tic_tac_toes/history'
+
+require 'command_line/runner'
+
+database = "tic_tac_toes"
+
+io = CommandLine::IO
+io_interface = TicTacToes::IOInterface.new(io)
+menu = CommandLine::Menu.new(io_interface)
+rules = TicTacToes::Rules
+database_interface = Database::PGWrapper.new(database)
+history = TicTacToes::History.new(database_interface)
+
+CommandLine::Runner.new(io_interface, menu, rules, history).run

data/lib/command_line/io.rb

@@ -0,0 +1,27 @@
+module CommandLine
+  module IO
+    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

data/lib/command_line/menu.rb

@@ -0,0 +1,54 @@
+require 'tic_tac_toes/board'
+require 'tic_tac_toes/player_factory'
+require 'tic_tac_toes/rules'
+
+module CommandLine
+  class Menu
+    def initialize(io_interface)
+      @io_interface = io_interface
+      @player_factory = TicTacToes::PlayerFactory.new(io_interface)
+    end
+
+    def get_board
+      TicTacToes::Board.new(row_size: 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_interface.get_row_size
+        break row_size if TicTacToes::Rules.row_size_valid?(row_size)
+        @io_interface.invalid_row_size_error
+      end
+    end
+
+    def get_token(player, taken_tokens)
+      loop do
+        token = @io_interface.get_token(player)
+        break token if TicTacToes::Rules.token_valid?(token, taken_tokens)
+        @io_interface.invalid_token_error
+      end
+    end
+
+    def get_difficulty
+      loop do
+        difficulty = @io_interface.get_difficulty
+        break difficulty if TicTacToes::Rules.difficulty_valid?(difficulty)
+        @io_interface.invalid_difficulty_error
+      end
+    end
+  end
+end

data/lib/command_line/runner.rb

@@ -0,0 +1,37 @@
+module CommandLine
+  class Runner
+    def initialize(io_interface, menu, rules, history)
+      @io_interface = io_interface
+      @menu = menu
+      @rules = rules
+      @history = history
+    end
+
+    def run
+      board, players = @menu.get_board, @menu.get_players
+      @history.record_board_size(board.size)
+
+      take_turn(board, players) until @rules.game_over?(board, players)
+      end_game(board, players)
+    end
+
+    def take_turn(board, players)
+      @io_interface.draw_board(board)
+      @io_interface.thinking_notification if players.first.needs_to_think
+
+      move = players.first.make_move(board, players)
+      @history.record_move(move)
+      players.rotate!
+    end
+
+    def end_game(board, players)
+      @io_interface.draw_board(board)
+
+      winner = @rules.determine_winner(board, players)
+
+      @history.record_winner(winner)
+      @history.persist
+      @io_interface.game_over_notification(winner)
+    end
+  end
+end

data/lib/database/pg_wrapper.rb

@@ -0,0 +1,72 @@
+require 'pg'
+require 'tic_tac_toes/history'
+
+module Database
+  class PGWrapper
+    def initialize(database)
+      @database = database
+    end
+
+    def record_game_history(history)
+      connection = establish_connection
+      record_board_size_and_winner(history, connection)
+      record_moves(history, connection)
+    end
+
+    def read_game_histories
+      connection = establish_connection
+      games_result = connection.exec("SELECT * FROM games")
+      games = []
+
+      games_result.each_row do |row|
+        game_id = row[0]
+        board_size = row[1].to_i
+        winner = row[2]
+        moves_result = connection.exec("SELECT * FROM moves WHERE game = #{game_id}")
+
+        history = TicTacToes::History.new(self)
+
+        moves_result.each_row do |row|
+          token, space = row[2], row[3].to_i
+          history.record_move([token, space])
+        end
+        history.record_board_size(board_size)
+        history.record_winner(winner)
+
+        games << history
+      end
+
+      games
+    end
+
+    private
+
+    def establish_connection
+      PG.connect(dbname: @database)
+    end
+
+    def record_board_size_and_winner(history, connection)
+      connection.exec("INSERT INTO games (board_size, winner) VALUES (
+        #{history.board_size},
+        '#{history.winner}')")
+    end
+
+    def record_moves(history, connection)
+      game_id = read_game_id(connection)
+
+      history.moves.each_with_index do |move, index|
+        move_number = index + 1
+        connection.exec("INSERT INTO moves (game, number, token, space) VALUES (
+          #{game_id},
+          #{move_number},
+          '#{move.first}',
+          #{move.last})")
+      end
+    end
+
+    def read_game_id(connection)
+      result = connection.exec("SELECT currval(pg_get_serial_sequence('games','id'))")
+      result.getvalue(0,0)
+    end
+  end
+end

data/lib/tic_tac_toes/board.rb

@@ -0,0 +1,62 @@
+module TicTacToes
+  class Board
+    attr_reader :row_size, :size
+
+    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

data/lib/tic_tac_toes/easy_ai.rb

@@ -0,0 +1,9 @@
+require 'tic_tac_toes/board'
+
+module TicTacToes
+  module EasyAI
+    def self.make_move(board, _players)
+      board.open_spaces.sample
+    end
+  end
+end

data/lib/tic_tac_toes/hard_ai.rb

@@ -0,0 +1,57 @@
+require 'tic_tac_toes/rules'
+
+module TicTacToes
+  module HardAI
+    def self.make_move(board, players)
+      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
+
+    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
+  end
+end

data/lib/tic_tac_toes/history.rb

@@ -0,0 +1,27 @@
+module TicTacToes
+  class History
+    attr_reader :board_size, :moves, :winner
+
+    def initialize(database_interface)
+      @database_interface = database_interface
+    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_interface.record_game_history(self)
+    end
+  end
+end

data/lib/tic_tac_toes/io_interface.rb

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

data/lib/tic_tac_toes/medium_ai.rb

@@ -0,0 +1,11 @@
+require 'tic_tac_toes/easy_ai'
+require 'tic_tac_toes/hard_ai'
+
+module TicTacToes
+  module MediumAI
+    def self.make_move(board, players)
+      ai = [EasyAI, HardAI, HardAI].sample
+      ai.make_move(board, players)
+    end
+  end
+end

data/lib/tic_tac_toes/player.rb

@@ -0,0 +1,20 @@
+module TicTacToes
+  class Player
+    attr_reader :decider, :token, :needs_to_think
+
+    def initialize(decider, token, needs_to_think, io_interface)
+      @decider = decider
+      @token = token
+      @needs_to_think = needs_to_think
+      @io_interface = io_interface
+    end
+
+    def make_move(board, players)
+      loop do
+        space = @decider.make_move(board, players)
+        break [@token, space] if board.place(self, space)
+        @io_interface.invalid_move_error
+      end
+    end
+  end
+end

data/lib/tic_tac_toes/player_factory.rb

@@ -0,0 +1,24 @@
+require 'tic_tac_toes/easy_ai'
+require 'tic_tac_toes/hard_ai'
+require 'tic_tac_toes/medium_ai'
+require 'tic_tac_toes/player'
+
+module TicTacToes
+  class PlayerFactory
+    AI_DIFFICULTIES = { easy: EasyAI, medium: MediumAI, hard: HardAI }
+
+    def initialize(io_interface)
+      @io_interface = io_interface
+    end
+
+    def generate_human_player(token)
+      needs_to_think = false
+      Player.new(@io_interface, token, needs_to_think, @io_interface)
+    end
+
+    def generate_computer_player(token, difficulty)
+      needs_to_think = true
+      Player.new(AI_DIFFICULTIES[difficulty], token, needs_to_think, @io_interface)
+    end
+  end
+end

data/lib/tic_tac_toes/rules.rb

@@ -0,0 +1,64 @@
+require 'tic_tac_toes/player_factory'
+
+module TicTacToes
+  module Rules
+    ROW_SIZE_RANGE = (2..10)
+
+    def self.row_size_valid?(row_size)
+      row_size.between?(ROW_SIZE_RANGE.min, ROW_SIZE_RANGE.max)
+    end
+
+    def self.token_valid?(token, taken_tokens)
+      correct_length = token.length == 1
+      untaken = !taken_tokens.include?(token)
+
+      correct_length && untaken
+    end
+
+    def self.difficulty_valid?(difficulty)
+      PlayerFactory::AI_DIFFICULTIES.include? difficulty
+    end
+
+    def self.game_over?(board, players)
+      winner = !determine_winner(board, players).nil?
+      tie = board.full?
+
+      winner || tie
+    end
+
+    def self.determine_winner(board, players)
+      winner = nil
+
+      players.each do |player|
+        player_has_won = win?(board, player)
+        winner = player.token if player_has_won
+      end
+
+      winner
+    end
+
+    def self.win?(board, player)
+      diagonal_win?(board, player) ||
+      horizontal_win?(board, player) ||
+      vertical_win?(board, player)
+    end
+
+    private
+
+    def self.diagonal_win?(board, player)
+      set_win?(board.diagonals, player)
+    end
+
+    def self.horizontal_win?(board, player)
+      set_win?(board.rows, player)
+    end
+
+    def self.vertical_win?(board, player)
+      set_win?(board.columns, player)
+    end
+
+    def self.set_win?(sets, player)
+      sets.any? { |set| set.all? { |space| space.token == player.token unless space.nil?  } }
+    end
+  end
+end