tic_tac_toe_ecastillo 1.0.0

data/README.md

@@ -0,0 +1,9 @@
+Erick Castillo, Ian Barnor
+
+TicTacToe in Ruby v.2.0.0
+
+To run:
+
+  Open project directory and type:
+
+    bin/tic_tac_toe

data/bin/tic_tac_toe

@@ -0,0 +1,5 @@
+#!/usr/bin/ruby
+
+require_relative '../lib/tic_tac_toe'
+
+TicTacToe::Start.new.start

data/lib/tic_tac_toe.rb

@@ -0,0 +1,9 @@
+require_relative 'tic_tac_toe/cell'
+require_relative 'tic_tac_toe/board'
+require_relative 'tic_tac_toe/display'
+require_relative 'tic_tac_toe/start'
+require_relative 'tic_tac_toe/checker'
+require_relative 'tic_tac_toe/gameplay'
+require_relative 'tic_tac_toe/player'
+require_relative 'tic_tac_toe/input'
+require_relative 'tic_tac_toe/console'

data/lib/tic_tac_toe/board.rb

@@ -0,0 +1,42 @@
+module TicTacToe
+  class Board
+
+    attr_reader :board
+
+    def initialize
+      @board = empty_board
+      super()
+    end
+
+    def fill_board_space(position, player)
+      cell = cell_from_position(position)
+      cell.owner = player
+    end
+
+    def position_empty?(position)
+      cell = cell_from_position(position)
+      cell.empty?
+    end
+
+    def get_empty_positions
+      @board.each.reduce([]) { |positions, row| positions + row.select(&:empty?) }
+    end
+
+    def self.valid_position_string?(selection)
+      selection.downcase.gsub(" ","").match(/^[abc],[123]$/)
+    end
+
+    private
+    def cell_from_position(position)
+      @board.flatten.find { |cell| cell.position == position.downcase }
+    end
+
+    def empty_board
+      [1,2,3].each.reduce([]) do |board, number| 
+        board << ['a','b','c'].each.reduce([]) do |row, letter|
+          row << Cell.new("#{letter},#{number}")
+        end
+      end
+    end
+  end
+end

data/lib/tic_tac_toe/cell.rb

@@ -0,0 +1,25 @@
+module TicTacToe
+  class Cell
+
+    EMPTY_SYMBOL = ' '
+
+    attr_accessor :owner, :position
+
+    def initialize(position, owner = nil)
+      @position = position
+      @owner = owner
+    end
+
+    def owner?(owner)
+      owner == @owner
+    end
+
+    def empty?
+      @owner.nil?
+    end
+
+    def content
+      empty? ? EMPTY_SYMBOL : @owner.symbol
+    end
+  end
+end

data/lib/tic_tac_toe/checker.rb

@@ -0,0 +1,66 @@
+module TicTacToe
+  class Checker
+
+    def initialize
+      @win = false
+      @draw = false
+    end
+
+    def update(args)
+      gameplay = args[:gameplay]
+      @board = gameplay.board.board
+      @win = win?(args[:player])
+  		@draw = draw? unless @win
+      gameplay.finish_game if (@win || @draw)
+      gameplay.finished_turn_status(win: @win, draw: @draw)
+    end
+
+    private
+    def draw?
+  		@board.all? {|row| row.all? { |element| !element.empty? }}
+    end
+	
+  	def win? (player)
+  		vertical_win?(player) || horizontal_win?(player) || diagonal_win?(player)
+  	end
+
+    def vertical_win?(player)
+  		3.times.any? { |count| win_vertical_line?(player, count) }
+    end
+	
+  	def win_vertical_line?(player, col)
+  	  rows = [0, 1, 2]
+  	  rows.all? do |row_index|
+  	    @board[row_index][col].owner?(player)
+	    end
+  	end
+	
+  	def horizontal_win?(player)
+  		3.times.any? { |count| win_horizontal_line?(player,count)}
+  	end
+	
+  	def win_horizontal_line?(player, row)
+  	  cols = [0, 1, 2]
+  	  cols.all? do |col_index|
+  	    @board[row][col_index].owner?(player)
+	    end
+  	end
+	
+  	def diagonal_win?(player)
+  		left_to_right_diagonal_win?(player) || right_to_left_diagonal_win?(player)
+  	end
+	
+  	def left_to_right_diagonal_win?(player)
+  		@board[0][0].owner?(player) &&
+  		@board[1][1].owner?(player) &&
+  		@board[2][2].owner?(player)
+  	end
+	
+  	def right_to_left_diagonal_win?(player)
+  		@board[0][2].owner?(player) &&
+  		@board[1][1].owner?(player) &&
+  		@board[2][0].owner?(player)
+  	end
+
+  end
+end

data/lib/tic_tac_toe/console.rb

@@ -0,0 +1,38 @@
+require 'singleton'
+
+module TicTacToe
+  class Console
+    include Singleton
+
+    def clear_console
+      STDOUT.puts `clear`
+    end
+
+    def respond_to?(method, include_private = false)
+      super || respond_to_console?(method)
+    end
+
+    private
+    def method_missing(name, *args)
+      method = name.to_s
+      return Display.instance.send(name, *args) if display_action?(method)
+      return Input.instance.send(name, *args) if input_action?(method)
+      super
+    end
+
+    def respond_to_console?(method)
+      name = method.to_s
+      return Display.instance.respond_to?(method) if display_action?(name)
+      return Input.instance.respond_to?(method) if input_action?(name)
+      false
+    end
+
+    def input_action?(name)
+      name =~ /^input_/
+    end
+
+    def display_action?(name)
+      name =~ /^display_/
+    end
+  end
+end

data/lib/tic_tac_toe/display.rb

@@ -0,0 +1,88 @@
+require 'yaml'
+require 'singleton'
+
+module TicTacToe
+  class Display
+    include Singleton
+
+    MESSAGES_FILE = File.join(File.dirname(__FILE__), '../../res/messages.yaml')
+
+    attr_accessor :output
+
+    def display_board(args)
+      board = args[:board]
+      Console.instance.clear_console
+      STDOUT.puts "\t   A     B     C"
+      STDOUT.puts board.board.map.with_index{ |row, index| row_message(row, index) }.join
+    end
+
+    def display(msg_name, *args)
+      STDOUT.puts YAML.load_file(MESSAGES_FILE)[msg_name]
+      STDIN.gets if instructions?(msg_name)
+    end
+
+    def display_turn_status(args)
+      player_name = args[:player_name]
+      display_board(args)
+      STDOUT.puts "\n\n #{player_name} turn"
+    end
+
+    def display_msg_ask_for_player_name(args)
+      player_number = args[:player_number]
+      STDOUT.puts "Enter player #{player_number + 1} name"
+    end
+
+    def display_msg_win(args)
+      player_name = args[:player_name]
+      STDOUT.puts "#{player_name} won"
+    end
+
+    def display_msg_computer_thinking
+      STDOUT.print "Thinking."
+      2.times do
+        Kernel.sleep(1)
+        STDOUT.print "."
+      end
+    end
+
+    def respond_to?(method, include_private = false)
+      super || respond_to_display?(method)
+    end
+
+    private
+    def instructions?(msg_name)
+      msg_name.end_with?('_instructions')
+    end
+
+    def respond_to_display?(method)
+      name = method.to_s
+      return false unless name =~ /^display_/
+      name.gsub!(/^display_/,'')
+      msg_in_yml_file?(name)
+    end
+
+    def msg_in_yml_file?(msg)
+      YAML.load_file(MESSAGES_FILE).has_key?(msg)
+    end
+
+    def row_message(row, row_index)
+      message = "\t#{row_index + 1}"
+      row.each_with_index do |cell, index| 
+        message << "  #{cell.content}  " 
+        separator = (index == row.size - 1)  ? "\n" : "|"
+        message << separator
+      end
+      message << "\t -----------------\n" unless row_index == 2
+      message
+    end
+
+    def method_missing(name, *args)
+      name = name.to_s
+      super unless name =~ /^display_/
+      name.gsub!(/^display_/,'')
+      display(name, *args)
+    end
+
+
+  end
+end

data/lib/tic_tac_toe/gameplay.rb

@@ -0,0 +1,78 @@
+require 'observer'
+
+module TicTacToe
+  class Gameplay
+    include Observable
+
+    attr_reader :board
+
+    def initialize(checker, ui, players_name)
+      create_players(players_name)
+      @ui = ui
+      prepare_initial_conditions
+      add_observer(checker)
+    end
+
+    def play
+      player_turn while !@game_finished
+    end
+
+    def finish_game
+      @game_finished = true
+    end
+
+    def finished_turn_status(args = { win: false, draw: false })
+      @ui.display_board(board: @board)
+      @ui.display_msg_draw if args[:draw]
+      @ui.display_msg_win(player_name: @players[@turn].name) if args[:win]
+    end
+
+    private
+    def create_players(players_name)
+      @players = players_name.map { |name| Player.new(name) }
+      @players << Player.new('Computer', computer: true) if @players.size == 1
+    end
+
+    def prepare_initial_conditions
+      @game_finished = false
+      @board = Board.new
+      @turn = Kernel.rand(2)
+      set_players_symbols
+    end
+
+    def set_players_symbols
+      @players[@turn].symbol = "X" 
+      @players[(@turn + 1) % 2].symbol = "O"
+    end
+
+    def player_turn
+      @ui.display_turn_status(board: @board, player_name: @players[@turn].name)
+      input = @ui.input_player_action(@players[@turn], @board)
+      input_action(input)
+    end
+
+    def input_action(option)
+      case option
+      when 'help' then @ui.display_gameplay_instructions
+      when 'quit' then finish_game
+      when 'reset' then reset
+      else completed_player_move(option)
+      end
+    end
+
+    def reset
+      prepare_initial_conditions
+    end
+
+    def completed_player_move(input)
+      @board.fill_board_space(input, @players[@turn])
+      changed
+      notify_observers(gameplay: self, player: @players[@turn])
+      change_turn unless @game_finished
+    end
+
+    def change_turn
+      @turn = (@turn + 1) % 2
+    end
+  end
+end

data/lib/tic_tac_toe/input.rb

@@ -0,0 +1,104 @@
+require 'singleton'
+
+module TicTacToe
+  class Input
+    include Singleton
+
+    ONE_PLAYER_MODE = 1
+    TWO_PLAYER_MODE = 2
+    VALID_INPUT = 0
+    NOT_VALID_INPUT = 1
+    NOT_EMPTY_INPUT_POSITION = 2
+
+    def input_mode
+      display.display_modes_options
+      enter_mode
+    end
+
+    def input_name(args)
+      display.display_msg_ask_for_player_name(args)
+      input_line
+    end
+
+    def input_replay
+      display.display_msg_replay
+      input_line.downcase
+    end
+
+    def input_player_action(player, board)
+      begin
+        input = select_position(player, board.get_empty_positions)
+        validated_input = input_validation(input, board)
+        input_error_message(validated_input)
+      end while !valid?(validated_input)
+      input.downcase
+    end
+
+    def input_line
+      STDIN.gets.chomp
+    end
+
+    private
+    def display
+      Display.instance
+    end
+
+    def select_position(player, posible_positions)
+      if player.computer?
+        select_random_position(posible_positions)
+      else
+        receive_player_input
+      end
+    end
+
+    def input_validation(input, board)
+      return VALID_INPUT if quit_reset_option?(input)
+      if(Board.valid_position_string?(input))
+        board.position_empty?(input) ? VALID_INPUT : NOT_EMPTY_INPUT_POSITION
+      else
+        NOT_VALID_INPUT
+      end
+    end
+
+    def select_random_position(posible_positions)
+      index = Kernel.rand(posible_positions.size)
+      display.display_msg_computer_thinking
+      posible_positions[index].position
+    end
+
+    def receive_player_input
+      display.display_msg_select_position
+      input_line
+    end
+
+    def valid?(validated_input)
+      validated_input == VALID_INPUT
+    end
+
+    def input_error_message(validated_input)
+     case validated_input
+     when NOT_VALID_INPUT
+       display.display_msg_not_valid_input
+     when NOT_EMPTY_INPUT_POSITION
+       display.display_msg_not_empty_position
+     end 
+    end
+
+    def quit_reset_option?(option)
+      ['help','quit','reset'].include?(option)
+    end
+
+    def enter_mode
+      mode = input_line
+      while !valid_mode?(mode.to_i)
+        display.display_error_msg_mode
+        mode = input_line
+      end
+      mode.to_i
+    end
+
+    def valid_mode?(mode)
+      [ONE_PLAYER_MODE, TWO_PLAYER_MODE].include?(mode)
+    end
+  end
+end

data/lib/tic_tac_toe/player.rb

@@ -0,0 +1,15 @@
+module TicTacToe
+  class Player
+
+    attr_accessor :name, :symbol
+
+    def initialize(name, options = { computer: false })
+      @name = name
+      @is_computer = options[:computer]
+    end
+
+    def computer?
+      @is_computer
+    end
+  end
+end

data/lib/tic_tac_toe/start.rb

@@ -0,0 +1,43 @@
+module TicTacToe  
+  class Start
+
+    def initialize
+      @players_name_number = 1
+      @players_name = []
+    end
+
+    def start
+      console.display_beginning_instructions
+      @players_name_number = console.input_mode
+      enter_players_name
+      play_until_no_more_replay
+    end
+
+    private
+    def console
+      Console.instance
+    end
+
+    def play_until_no_more_replay
+      replay = true
+      while replay
+        start_game
+        replay = replay? 
+      end
+    end
+
+    def replay?
+      console.input_replay.eql?('y')
+    end
+
+    def enter_players_name
+      @players_name_number.times { |count| @players_name[count] = console.input_name(player_number: count) }
+    end
+
+    def start_game
+      console.clear_console
+      Gameplay.new(Checker.new, console, @players_name).play
+    end
+  end
+end
+

data/lib/tic_tac_toe_ecastillo/version.rb

@@ -0,0 +1,3 @@
+module TicTacToeEcastillo
+  VERSION = '1.0.0'
+end

data/res/messages.yaml

@@ -0,0 +1,33 @@
+msg_not_valid_input : "Not a valid selection, select another one"
+msg_not_empty_position : "Not an empty position select another one"
+msg_replay : "Do you want to play again [Y/N]"
+modes_options : "Select a mode:
+                     \n\t1) 1 player
+                     \n\t2) 2 players"
+error_msg_mode : "Enter a valid mode"
+msg_select_position : "Select the position"
+msg_draw : "Game drawn"
+beginning_instructions : "\n\n\t\t Welcome to Tic Tac Toe 
+
+  The extremely fun experience of playing such an amazing game as Tic Tac Toe. This game is really popular
+  and we do not want to delay you more but here are some instructions for using this game.
+  First you will be asked to select a mode here you could have:
+       \n\t1 player: Play against the hardest computer you will ever play
+       \n\t2 player: Play with another friend
+
+  \n\n Then, the player/players names are asked, feel free to be honest.
+  After that the game will start here you have to select a position to make your move, the format
+  of this input should be A,1 as an example, with letters going from A to C and numbers from 1 to 3. Also, you
+  have three another options quit, reset and help.'Quit' just quit the games, 'reset' restarts the game and
+  'help' shows you another game help.
+
+  \n\nEnjoy your game (hit enter to continue)"
+gameplay_instructions : "
+  Select a position to make your move, the format
+  of this input should be A,1 as an example, with letters going from A to C and numbers from 1 to 3. Also, you
+  have three another options quit, reset and help.'Quit' just quit the games, 'reset' restarts the game and
+  'help' shows you another game help.
+
+ \n\n (hit enter to continue)"
+
+

data/res/messages.yaml~

@@ -0,0 +1,10 @@
+msg_not_valid_input : "Not a valid selection, select another one"
+msg_not_empty_position : "Not an empty position select another one"
+msg_replay : "Do you want to play again [Y/N]"
+modes_options : "Select a mode:
+                     1) 1 player
+                     2) 2 players"
+error_msg_mode : "Enter a valid mode"
+msg_select_position : "Select the position"
+msg_draw : "Game drawn"
+

data/spec/boards.rb

@@ -0,0 +1,84 @@
+require 'tic_tac_toe'
+require 'constants'
+
+module Boards
+
+  def Boards.draw_board
+    board = TicTacToe::Board.new
+    Boards.fill_positions(board, PLAYER_1_DRAW_POSITIONS, player_1)
+    Boards.fill_positions(board, PLAYER_2_DRAW_POSITIONS, player_2)
+    board
+  end
+
+  def Boards.first_vertical_win_board
+    board = TicTacToe::Board.new
+    Boards.fill_positions(board, FIRST_COL_WIN_POSITIONS, player_1)
+    board
+  end
+
+  def Boards.second_vertical_win_board
+    board = TicTacToe::Board.new
+    Boards.fill_positions(board, SECOND_COL_WIN_POSITIONS, player_1)
+    board
+  end
+
+  def Boards.third_vertical_win_board
+    board = TicTacToe::Board.new
+    Boards.fill_positions(board, THIRD_COL_WIN_POSITIONS, player_1)
+    board
+  end
+
+  def Boards.first_horizontal_win_board
+    board = TicTacToe::Board.new
+    Boards.fill_positions(board, FIRST_ROW_WIN_POSITIONS, player_1)
+    board
+  end
+
+  def Boards.second_horizontal_win_board
+    board = TicTacToe::Board.new
+    Boards.fill_positions(board, SECOND_ROW_WIN_POSITIONS, player_1)
+    board
+  end
+
+  def Boards.third_horizontal_win_board
+    board = TicTacToe::Board.new
+    Boards.fill_positions(board, THIRD_ROW_WIN_POSITIONS, player_1)
+    board
+  end
+
+  def Boards.up_diagonal_win_board
+    board = TicTacToe::Board.new
+    Boards.fill_positions(board, DIAGONAL_UP_WIN_POSITIONS, player_1)
+    board
+  end
+
+  def Boards.down_diagonal_win_board
+    board = TicTacToe::Board.new
+    Boards.fill_positions(board, DIAGONAL_DOWN_WIN_POSITIONS, player_1)
+    board
+  end
+
+  def Boards.no_win_nor_draw_board
+    board = TicTacToe::Board.new
+    Boards.fill_positions(board, SOME_POSITIONS, player_1)
+    board
+  end
+
+  def Boards.player_1
+    @@player_1 ||= Boards.player(PLAYER_1, PLAYER_1_SYMBOL)
+  end
+
+  def Boards.player_2
+    @@player_2 ||= Boards.player(PLAYER_2, PLAYER_2_SYMBOL)
+  end
+
+  def Boards.fill_positions(board, positions, player)
+    positions.each { |position| board.fill_board_space(position, player) }
+  end
+
+  def Boards.player(name, symbol)
+    player = TicTacToe::Player.new(name)
+    player.symbol = symbol
+    player
+  end
+end

data/spec/constants.rb

@@ -0,0 +1,43 @@
+A_POSITION = 1
+A_VALID_MODE = 1
+AN_INVALID_MODE = 3
+AN_OWNER = 1
+NOT_AN_OWNER = 2
+A_SYMBOL = 3
+EMPTY_SYMBOL = ' '
+A_ROW_NUMBER = 1
+A_COL_NUMBER = 2
+A_POSITION_STRING = 'b,2'
+POSITION_STRING_COL = 1
+POSITION_STRING_ROW = 1
+NOT_A_POSITION_STRING = 'Z,4'
+A_PLAYER = 'PLAYER'
+A_PLAYER_NAME = 'PLAYER'
+A_COMPUTER_NAME = 'COMPUTER'
+A_PLAYER_NUMBER = 1
+AN_OUTPUT = 1
+AN_INPUT = "INPUT"
+CELL_CONTENT = 1
+BOARD_MESSAGE = "\t1  #{CELL_CONTENT}  |  #{CELL_CONTENT}  \n" +
+                "\t -----------------\n" +
+                "\t2  #{CELL_CONTENT}  |  #{CELL_CONTENT}  \n" +
+                "\t -----------------\n" +
+                "\t3  #{CELL_CONTENT}  |  #{CELL_CONTENT}  \n"
+ALL_POSITIONS = ['A,1', 'B,1', 'C,1', 'A,2', 'B,2', 'C,2', 'A,3', 'B,3', 'C,3']
+SOME_POSITIONS = ['B,1', 'A,3', 'C,2']
+ALL_EXCEPT_SOME_POSITIONS = ['A,1', 'C,1', 'A,2', 'B,2', 'B,3', 'C,3']
+PLAYER_1 = '1'
+PLAYER_1_SYMBOL = 'X'
+PLAYER_2 = '2'
+PLAYER_2_SYMBOL = 'O'
+PLAYER_1_DRAW_POSITIONS = ['A,1', 'A,3', 'B,2', 'C,2']
+PLAYER_2_DRAW_POSITIONS = ['A,2', 'B,1', 'B,3', 'C,1', 'C,3']
+FIRST_ROW_WIN_POSITIONS = ['A,1', 'B,1', 'C,1']
+SECOND_ROW_WIN_POSITIONS = ['A,2', 'B,2', 'C,2']
+THIRD_ROW_WIN_POSITIONS = ['A,3', 'B,3', 'C,3']
+FIRST_COL_WIN_POSITIONS = ['A,1', 'A,2', 'A,3']
+SECOND_COL_WIN_POSITIONS = ['B,1', 'B,2', 'B,3']
+THIRD_COL_WIN_POSITIONS = ['C,1', 'C,2', 'C,3']
+DIAGONAL_UP_WIN_POSITIONS = ['A,1', 'B,2', 'C,3']
+DIAGONAL_DOWN_WIN_POSITIONS = ['A,3', 'B,2', 'C,1']
+INVALID_INPUT_POSITION = 'asdasd'

metadata

@@ -0,0 +1,65 @@
+--- !ruby/object:Gem::Specification
+name: tic_tac_toe_ecastillo
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+  prerelease: 
+platform: ruby
+authors:
+- Erick Castillo
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-01-31 00:00:00.000000000 Z
+dependencies: []
+description: Play a simple TicTacToe game
+email: ecastillo@pernix-solutions.com
+executables:
+- tic_tac_toe
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/tic_tac_toe
+- lib/tic_tac_toe/start.rb
+- lib/tic_tac_toe/display.rb
+- lib/tic_tac_toe/checker.rb
+- lib/tic_tac_toe/gameplay.rb
+- lib/tic_tac_toe/cell.rb
+- lib/tic_tac_toe/input.rb
+- lib/tic_tac_toe/console.rb
+- lib/tic_tac_toe/player.rb
+- lib/tic_tac_toe/board.rb
+- lib/tic_tac_toe_ecastillo/version.rb
+- lib/tic_tac_toe.rb
+- res/messages.yaml~
+- res/messages.yaml
+- README.md
+- spec/constants.rb
+- spec/boards.rb
+homepage: http://github.com/erickcsh/TicTacToe
+licenses:
+- MIT
+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.23
+signing_key: 
+specification_version: 3
+summary: TicTacToe!
+test_files:
+- spec/constants.rb
+- spec/boards.rb