ttt-core 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 592a2b99d813d6eff7554da5722ef2ce5f960470
+  data.tar.gz: 65262df5515d534718ed484cab124e32f847fb22
+SHA512:
+  metadata.gz: e1eb6b836b09ba27c3c944a4ae5064242f8595e20955dbb0516405ad22bccebec1247e3a1a32c2999b32a06050cb7bbf3dc1a88bdedb059da668643bf9596f99
+  data.tar.gz: ce091661e1f82bd04dca7b1fa02a128a63361cba5fdb90bfd35b477aab073d85a475fddf55fb58ff0776de7001cf9ddb7f9771f3a872a455fe0ffa3c46184fca

data/.gitignore

@@ -0,0 +1,36 @@
+*.gem
+*.rbc
+/.config
+/coverage/
+/InstalledFiles
+/pkg/
+/spec/reports/
+/test/tmp/
+/test/version_tmp/
+/tmp/
+.coveralls.yml
+
+## Specific to RubyMotion:
+.dat*
+.repl_history
+build/
+
+## Documentation cache and generated files:
+/.yardoc/
+/_yardoc/
+/doc/
+/rdoc/
+
+## Environment normalisation:
+/.bundle/
+/vendor/bundle
+/lib/bundler/man/
+
+# for a library or gem, you might want to ignore these files since the code is
+# intended to run in multiple environments; otherwise, check them in:
+Gemfile.lock
+# .ruby-version
+# .ruby-gemset
+
+# unless supporting rvm < 1.11.0 or doing something fancy, ignore this:
+.rvmrc

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--require spec_helper

data/.ruby-gemset

@@ -0,0 +1 @@
+ttt

data/.ruby-version

@@ -0,0 +1 @@
+2.2.1

data/.travis.yml

@@ -0,0 +1,2 @@
+language: ruby
+

data/Gemfile

@@ -0,0 +1,8 @@
+source 'https://rubygems.org'
+
+group :test do
+  gem 'rake', '10.5.0'
+    gem 'simplecov', '0.11.1'
+    gem 'coveralls', '0.8.10', :require => false
+    gem 'rspec', '3.4.0', :require => 'spec'
+end

data/Gemfile.lock

@@ -0,0 +1,61 @@
+GEM
+  remote: https://rubygems.org/
+  specs:
+    coveralls (0.8.10)
+      json (~> 1.8)
+      rest-client (>= 1.6.8, < 2)
+      simplecov (~> 0.11.0)
+      term-ansicolor (~> 1.3)
+      thor (~> 0.19.1)
+      tins (~> 1.6.0)
+    diff-lcs (1.2.5)
+    docile (1.1.5)
+    domain_name (0.5.25)
+      unf (>= 0.0.5, < 1.0.0)
+    http-cookie (1.0.2)
+      domain_name (~> 0.5)
+    json (1.8.3)
+    mime-types (2.99)
+    netrc (0.11.0)
+    rake (10.5.0)
+    rest-client (1.8.0)
+      http-cookie (>= 1.0.2, < 2.0)
+      mime-types (>= 1.16, < 3.0)
+      netrc (~> 0.7)
+    rspec (3.4.0)
+      rspec-core (~> 3.4.0)
+      rspec-expectations (~> 3.4.0)
+      rspec-mocks (~> 3.4.0)
+    rspec-core (3.4.1)
+      rspec-support (~> 3.4.0)
+    rspec-expectations (3.4.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.4.0)
+    rspec-mocks (3.4.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.4.0)
+    rspec-support (3.4.1)
+    simplecov (0.11.1)
+      docile (~> 1.1.0)
+      json (~> 1.8)
+      simplecov-html (~> 0.10.0)
+    simplecov-html (0.10.0)
+    term-ansicolor (1.3.2)
+      tins (~> 1.0)
+    thor (0.19.1)
+    tins (1.6.0)
+    unf (0.1.4)
+      unf_ext
+    unf_ext (0.0.7.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  coveralls (= 0.8.10)
+  rake (= 10.5.0)
+  rspec (= 3.4.0)
+  simplecov (= 0.11.1)
+
+BUNDLED WITH
+   1.11.2

data/README.md

@@ -0,0 +1,29 @@
+# Apprenticeship-RubyTicTacToe
+
+Tic Tac Toe Core Game implemented in Ruby
+
+[![Master Build Status](https://travis-ci.org/gemcfadyen/Apprenticeship-RubyTicTacToe.svg?branch=master)](https://travis-ci.org/gemcfadyen/Apprenticeship-RubyTicTacToe)   [![Master Coverage Status](https://coveralls.io/repos/gemcfadyen/Apprenticeship-RubyTicTacToe/badge.svg?branch=master&service=github)](https://coveralls.io/github/gemcfadyen/Apprenticeship-RubyTicTacToe?branch=master)
+
+To run the application clone the project into a folder
+
+>> git clone git@github.com:gemcfadyen/Apprenticeship-RubyTicTacToe.git
+
+To recreate the gem, do
+>> gem build ttt-core.gemspec
+
+To install locally, do
+>> gem install ./ttt-core-0.0.1.gem
+
+This will install the gem to the ttt gemset.
+To use this gem, add the following to your Gemfile:
+
+`gem ttt-core, '0.0.1'`
+
+(update the version as appropriate)
+
+Ensure your project will look at the ttt gemset path. Run `gem env` and check if the ttt gemset is listed under GEM PATHS.
+
+If it is not, you can configure it by running
+>> rvm 2.2.1@ttt
+
+Run `gem env` again, and check that the gemset is listed under the GEM PATH.

data/Rakefile

@@ -0,0 +1,8 @@
+begin
+  require "bundler/gem_tasks"
+  require 'rspec/core/rake_task'
+  RSpec::Core::RakeTask.new(:spec)
+rescue LoadError
+end
+
+task :default => :spec

data/bin/run.sh

@@ -0,0 +1,21 @@
+#!/usr/bin/env ruby
+
+##Setup Load Path
+$LOAD_PATH << File.expand_path("../../lib", __FILE__)
+
+require 'command_line_app'
+require 'command_line_ui'
+require 'board_factory'
+require 'command_line_player_factory'
+require 'prompt_writer'
+require 'prompt_reader'
+
+writer = PromptWriter.new($stdout)
+reader = PromptReader.new($stdin)
+command_line_ui = CommandLineUI.new(writer, reader)
+
+board_factory = BoardFactory.new
+player_factory = CommandLinePlayerFactory.new
+
+command_line_app = CommandLineApp.new(command_line_ui, board_factory, player_factory)
+command_line_app.start

data/lib/ai_player.rb

@@ -0,0 +1,117 @@
+require 'player_symbols'
+require 'player'
+
+class AiPlayer
+  include Player
+
+  def initialize(symbol)
+    super(symbol)
+  end
+
+  def choose_move(board)
+    minimax(board, true, board.vacant_indices.size, ALPHA, BETA).first[1]
+  end
+
+  def ready?
+    true
+  end
+
+  def minimax(board, is_max_player, depth, alpha, beta)
+    best_score_so_far = initial_score(is_max_player)
+
+    if round_is_over(board, depth)
+      return score(board, depth)
+    end
+
+    board.vacant_indices.each do |i|
+      new_board = board.make_move(i, current_players_symbol(is_max_player))
+      result = minimax(new_board, !is_max_player, depth - 1, alpha, beta)
+      best_score_so_far = update_score(is_max_player, i, best_score_so_far, score_from(result))
+
+      alpha = update_alpha(is_max_player, best_score_so_far, alpha)
+      beta = update_beta(is_max_player, best_score_so_far, beta)
+
+      if alpha > beta
+        break
+      end
+    end
+
+    best_score_so_far
+  end
+
+
+  private
+
+  ALPHA = -2
+  BETA = 2
+
+  def update_alpha(is_max_player, best_score_so_far, alpha)
+    if is_max_player && score_from(best_score_so_far) > alpha
+      alpha = score_from(best_score_so_far)
+    end
+    alpha
+  end
+
+  def score_from(score)
+    score.first.first
+  end
+
+  def update_beta(is_max_player, best_score_so_far, beta)
+    if !is_max_player && score_from(best_score_so_far) < beta
+        beta = score_from(best_score_so_far)
+    end
+    beta
+  end
+
+  def round_is_over(board, depth)
+    @winner = board.winning_symbol
+    !@winner.nil? || depth == 0
+  end
+
+  def score(board, depth)
+    if @winner.nil?
+      return {0 => nil}
+    end
+
+    if maximizing_player_won?(@winner)
+      return {(1 + depth) => nil}
+    end
+
+    if minimizing_player_won?(@winner)
+      return {(-1 - depth) => nil}
+    end
+  end
+
+  def maximizing_player_won?(winners_symbol)
+    symbols_are_equal?(winners_symbol, game_symbol)
+  end
+
+  def minimizing_player_won?(winners_symbol)
+    symbols_are_equal?(winners_symbol, PlayerSymbols::opponent(game_symbol))
+  end
+
+  def symbols_are_equal?(symbol1, symbol2)
+    symbol1 == symbol2
+  end
+
+  def initial_score(is_max_player)
+    if is_max_player
+      best_score_so_far = {ALPHA => nil}
+    else
+      best_score_so_far = {BETA => nil}
+    end
+  end
+
+  def current_players_symbol(is_max_player)
+    is_max_player == true ? game_symbol : PlayerSymbols::opponent(game_symbol)
+  end
+
+  def update_score(is_max_player, move, score, result_score)
+    if is_max_player && (result_score >= score_from(score))
+      return {result_score => move}
+    elsif !is_max_player && (result_score < score_from(score))
+      return {result_score => move}
+    end
+    return score
+  end
+end

data/lib/board.rb

@@ -0,0 +1,87 @@
+class Board
+
+  def initialize(symbols = Array.new(9))
+    @grid = symbols
+  end
+
+  def empty?
+    grid.all?(&:nil?)
+  end
+
+  def make_move(index, symbol)
+    copy_of_grid = grid.dup
+    copy_of_grid[index] = symbol
+    Board.new(copy_of_grid)
+  end
+
+  def free_spaces?
+    grid.include?(nil)
+  end
+
+  def get_symbol_at(position)
+    grid.at(position)
+  end
+
+  def winning_combination?
+    not_nil_row(find_winning_row_from(all_rows))
+  end
+
+  def winning_symbol
+    @winning_row = find_winning_row_from(all_rows)
+    @winning_row.nil? ? nil : @winning_row.first
+  end
+
+  def vacant_indices
+    grid.each_index.select{|v| grid[v].nil?}
+  end
+
+  def grid_for_display
+    rows
+  end
+
+  private
+
+  attr_reader :grid
+
+  def find_winning_row_from(rows)
+    @all_rows ||= rows.find do |row|
+           all_cells_match = row.all? {|cell| cell == row.first}
+           all_cells_match && not_nil_symbol(row.first)
+        end
+  end
+
+  def not_nil_row(row)
+    !row.nil?
+  end
+
+  def all_rows
+    @all ||= rows + columns + diagonals
+  end
+
+  def not_nil_symbol(cell)
+    !cell.nil?
+  end
+
+  def rows
+    [
+      [grid.at(0), grid.at(1), grid.at(2)],
+      [grid.at(3), grid.at(4), grid.at(5)],
+      [grid.at(6), grid.at(7), grid.at(8)]
+    ]
+  end
+
+  def columns
+    [
+      [grid.at(0), grid.at(3), grid.at(6)],
+      [grid.at(1), grid.at(4), grid.at(7)],
+      [grid.at(2), grid.at(5), grid.at(8)]
+    ]
+  end
+
+  def diagonals
+    [
+      [grid.at(0),grid.at(4), grid.at(8)],
+      [grid.at(2), grid.at(4), grid.at(6)]
+    ]
+  end
+end

data/lib/board_factory.rb

@@ -0,0 +1,8 @@
+require 'board'
+
+class BoardFactory
+
+  def create_board
+    Board.new
+  end
+end

data/lib/game.rb

@@ -0,0 +1,27 @@
+class Game
+
+  def initialize(board, players)
+    @board = board
+    @players = players
+  end
+
+  def play
+    while game_in_progress?
+      @board = board.make_move(current_player.choose_move(board), current_player.game_symbol)
+      players.reverse!
+    end
+    board
+  end
+
+  private
+
+  attr_reader :board, :players
+
+  def game_in_progress?
+    current_player.ready? && board.free_spaces? && !board.winning_combination?
+  end
+
+  def current_player
+    players.first
+  end
+end

data/lib/player.rb

@@ -0,0 +1,16 @@
+module Player
+
+  def initialize(symbol)
+    @symbol = symbol
+  end
+
+  def game_symbol
+    symbol
+  end
+
+  private
+
+  attr_reader :symbol
+
+end
+

data/lib/player_factory.rb

@@ -0,0 +1,38 @@
+require 'player_symbols'
+require 'player_options'
+require 'ai_player'
+
+class PlayerFactory
+  def create_players(player_option, command_line_ui)
+    if player_option == PlayerOptions::HUMAN_VS_HUMAN
+      human_vs_human(command_line_ui)
+    elsif player_option == PlayerOptions::HUMAN_VS_AI
+      human_vs_ai(command_line_ui)
+    else
+      ai_vs_human(command_line_ui)
+    end
+  end
+
+  private
+
+  def human_vs_human(command_line_ui)
+    [
+      create_human(command_line_ui, PlayerSymbols::X),
+      create_human(command_line_ui, PlayerSymbols::O)
+    ]
+  end
+
+  def human_vs_ai(command_line_ui)
+    [
+      create_human(command_line_ui, PlayerSymbols::X),
+      AiPlayer.new(PlayerSymbols::O)
+    ]
+  end
+
+  def ai_vs_human(command_line_ui)
+    [
+      AiPlayer.new(PlayerSymbols::X),
+      create_human(command_line_ui, PlayerSymbols::O)
+    ]
+  end
+end

data/lib/player_options.rb

@@ -0,0 +1,48 @@
+class PlayerOptions
+  HUMAN_VS_HUMAN = "Human vs Human"
+  HUMAN_VS_AI = "Human vs Ai"
+  AI_VS_HUMAN = "Ai vs Human"
+
+  ID_TO_PLAYER_TYPE = {
+    1 => HUMAN_VS_HUMAN,
+    2 => HUMAN_VS_AI,
+    3 => AI_VS_HUMAN
+  }
+
+  def self.valid_ids
+    ID_TO_PLAYER_TYPE.keys
+  end
+
+  def self.get_player_type_for_id(id)
+    game_value_of_player = ID_TO_PLAYER_TYPE.fetch(id)
+  end
+
+  def self.display_player_options
+    player_options_for_display = ID_TO_PLAYER_TYPE.each_pair.map do |id, option|
+      open_bracket + id.to_s + close_bracket + space + option
+    end
+    player_options_for_display.join(comma + space)
+  end
+
+  def self.all
+    ID_TO_PLAYER_TYPE
+  end
+
+  private
+
+  def self.open_bracket
+    "("
+  end
+
+  def self.close_bracket
+    ")"
+  end
+
+  def self.space
+    " "
+  end
+
+  def self.comma
+    ","
+  end
+end

data/lib/player_symbols.rb

@@ -0,0 +1,16 @@
+class PlayerSymbols
+  X = :X
+  O = :O
+
+  def self.opponent(symbol)
+    symbol == X ? O : X
+  end
+
+  def self.all
+    [X.to_s, O.to_s]
+  end
+
+  def self.to_symbol(value)
+    value == X.to_s ? X : O
+  end
+end

data/lib/replay_option.rb

@@ -0,0 +1,3 @@
+class ReplayOption
+  Y = "Y"
+end

data/lib/ttt-core/version.rb

@@ -0,0 +1,3 @@
+module TTTCore
+  VERSION = "1.0.0"
+end