jbcden_ttt 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: e190a50dcf6cc00e3708c46d1791dc622fef6a9b
+  data.tar.gz: a08f60ed3d99e4c6ff5d83b27647aa27aa0b5e72
+SHA512:
+  metadata.gz: 7c56cf50cb4451678ee89256caa65089662b524c5477e3d9017f121706fdebc948ab5f4e7657e833433ec0c027dfb1dfb172704aba7e2aa059cef14eb441e59f
+  data.tar.gz: dda78fbd248ed911730650a91dd0df111dfefeef76621f090a09a9d6ba3a8c526cf292fb459f0facde66e8334d797c46b57e28dda9c010d884da5a42ed3adaff

data/.gitignore

@@ -0,0 +1,22 @@
+*.gem
+*.rbc
+.bundle
+.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,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in jbcden_ttt.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Jacob Chae
+
+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,31 @@
+# JbcdenTtt
+
+## An unbeatable game of tic-tac-toe!
+
+## Installation
+
+- Simply run:
+```bash
+gem install jbcden_ttt
+```
+
+- And then play!:
+```bash
+ttt
+```
+
+## Usage
+
+Please note that this gem does require Ruby 1.9 or later.
+
+Also note that this gem is based on the repo:
+
+https://github.com/jbcden/tic-tac-toe
+
+## Contributing
+
+1. Fork it ( https://github.com/jbcden/jbcden_ttt/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,12 @@
+require "bundler/gem_tasks"
+require 'rake/testtask'
+
+$:.unshift(File.expand_path('./lib', __FILE__))
+
+Rake::TestTask.new do |t|
+  t.libs << "jbcden_ttt"
+  t.test_files = FileList['test/*_test.rb']
+  t.verbose = true
+end
+
+task default: :test

data/bin/ttt

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require 'jbcden_ttt'
+
+JbcdenTtt::TicTacToe.start

data/jbcden_ttt.gemspec

@@ -0,0 +1,23 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'jbcden_ttt/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "jbcden_ttt"
+  spec.version       = JbcdenTtt::VERSION
+  spec.date          = %q{2014-11-18}
+  spec.authors       = ["Jacob Chae"]
+  spec.email         = ["jbcden@gmail.com"]
+  spec.summary       = %q{A basic command line based game of tic tac toe.}
+  spec.homepage      = "https://github.com/jbcden/tic-tac-toe"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = ["ttt"]
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "rake"
+end

data/lib/jbcden_ttt.rb

@@ -0,0 +1,148 @@
+require "jbcden_ttt/version"
+require 'jbcden_ttt/board'
+require 'jbcden_ttt/board_mapper'
+require 'jbcden_ttt/computer'
+require 'jbcden_ttt/display_board'
+require 'jbcden_ttt/game_state'
+require 'jbcden_ttt/player'
+require 'jbcden_ttt/tile'
+
+module JbcdenTtt
+  class TicTacToe
+    attr_reader :board, :turn_num, :players, :computer, :player, :game
+
+    def self.start
+      new.play
+    end
+
+    def initialize
+      @board = Board.new(3,3)
+      @turn_num = 0
+      @players = []
+    end
+
+    def play
+      trap('INT') do
+        puts 'exiting!'
+        exit!
+      end
+      print_intro
+      choose_human
+      set_players_order
+      initialize_game_state
+      game_loop
+    end
+
+
+    def print_intro
+      clear_screen
+
+      print "Welcome to my Tic Tac Toe game!"
+    end
+
+    def choose_human
+      error = ""
+      while 1
+        begin
+          clear_screen
+          puts "Which player would you like to be? (\"x\" or \"o\"): "
+          puts error unless error.empty?
+          human_symbol = gets.chomp
+          @player = Player.new(human_symbol)
+          break
+        rescue Player::InvalidCharacterError => e
+          error = e.message
+          retry
+        end
+      end
+      @computer = Computer.new(choose_computer(human_symbol))
+    end
+
+    def set_players_order
+      if player.symbol == "x"
+        @players << @player
+        @players << @computer
+      else
+        @players << @computer
+        @players << @player
+      end
+    end
+
+    def initialize_game_state
+      @game = GameState.new(@board, @turn_num, @players.first)
+    end
+
+    def game_loop
+      while !@game.end_state?
+        clear_board
+
+        current_player = @players[@turn_num % 2]
+
+        take_turn(current_player)
+
+        @turn_num += 1
+        @game = GameState.new(@board, @turn_num, @players[@turn_num % 2])
+      end
+
+      clear_board
+
+      puts "The winner is: #{game.end_state?}"
+    end
+
+    private
+
+    def take_turn(current_player)
+      if current_player.human?
+        human_move(current_player)
+      else
+        move = current_player.calculate_best_move(@board, @game)
+        computer.make_move(@board, move)
+      end
+    end
+
+    def human_move(current_player)
+      puts
+      error = ""
+      while 1
+        begin
+          clear_board
+          print_message
+          puts error unless error.empty?
+
+          move = gets.chomp
+          current_player.make_move(@board, move)
+          break
+        rescue BoardMapper::InvalidCoordinateError => e
+          error = e.message
+        rescue Tile::InvalidActionError => e
+          error = e.message
+        end
+      end
+    end
+
+    def choose_computer(human)
+      if human == "x"
+        return "o"
+      else
+        return "x"
+      end
+    end
+
+    def clear_screen
+      puts "\033c"
+    end
+
+    def print_board
+      puts DisplayBoard.call(@board)
+    end
+
+    def clear_board
+      clear_screen
+      print_board
+    end
+
+    def print_message
+      puts "Please choose a square to mark."
+    end
+  end
+end

data/lib/jbcden_ttt/board.rb

@@ -0,0 +1,51 @@
+require_relative 'tile'
+require 'forwardable'
+
+module JbcdenTtt
+  class Board
+    extend Forwardable
+    attr_reader :width, :height, :board
+    attr_writer :board
+    def initialize(width, height)
+      @width = width
+      @height = height
+      @board = Array.new(height)
+
+      init_board_array
+      init_board
+    end
+
+    def display
+      DisplayBoard.call(board)
+    end
+
+    def_delegators :@board, :[], :[]=, :each, :first, :size, :last
+    private
+
+    def init_board_array
+      board.each_with_index do |row, index|
+        board[index] = Array.new(width)
+      end
+    end
+
+    def init_board
+      board.each_with_index do |row, rownum|
+        row.each_with_index do |column, index|
+          set_rows(row, rownum, index)
+        end
+      end
+    end
+
+    def set_rows(row, rownum, index)
+      if rownum != board.size - 1
+        set_tile(row, rownum, index, '_')
+      else
+        set_tile(row, rownum, index, ' ')
+      end
+    end
+
+    def set_tile(row, rownum, index, tile_char)
+      row[index] = Tile.new(tile_char, rownum, index)
+    end
+  end
+end

data/lib/jbcden_ttt/board_mapper.rb

@@ -0,0 +1,64 @@
+module JbcdenTtt
+  class BoardMapper
+    class InvalidCoordinateError < StandardError
+      def initialize(msg="An invalid coordinate was passed in, please try again")
+        super
+      end
+    end
+
+    ROW_MAPPER = {
+      "a" => 0, "b" => 1, "c" => 2, "d" => 3, "e" => 4, "f" => 5, "g" => 6, "h" => 7,
+      "i" => 8, "j" => 9, "k" => 10, "l" => 11, "m" => 12, "n" => 13, "o" => 14, "p" => 15,
+      "q" => 16, "r" => 17, "s" => 18, "t" => 19, "u" => 20, "v" => 21, "w" => 22, "x" => 23,
+      "y" => 24, "z" => 25
+    }
+
+    def self.map_coordinate(x, y)
+      str = ""
+      str << ROW_MAPPER.key(x)
+      str << (y+1).to_s
+
+      str
+    end
+
+    def self.map_string(board, location)
+
+      row = extract_row(location)
+      col = extract_column(location)
+
+      if is_valid?(board, row, col)
+        board[ROW_MAPPER[row]][col]
+      else
+        raise InvalidCoordinateError
+      end
+    end
+
+    private
+    def self.extract_column(location)
+      column = location.scan(/\d+\Z/).first
+      raise InvalidCoordinateError if column.nil?
+      get_col(
+        Integer(column)
+      )
+    end
+
+    def self.extract_row(location)
+      row = location.scan(/\A[a-z]+/).first
+      raise InvalidCoordinateError if row.nil?
+      raise InvalidCoordinateError unless ROW_MAPPER.has_key?(row)
+      row
+    end
+
+    def self.get_col(col_num)
+      col_num - 1
+    end
+
+    def self.is_valid?(board, row, col)
+      (board.height) > ROW_MAPPER[row] && (board.width) > col
+    end
+
+    def self.row_size
+      @row_size ||= board.first.size
+    end
+  end
+end

data/lib/jbcden_ttt/computer.rb

@@ -0,0 +1,124 @@
+module JbcdenTtt
+  class Computer
+    attr_reader :symbol
+
+    def initialize(symbol)
+      @symbol = symbol
+    end
+
+    def calculate_best_move(board, game)
+      unless new_board?(game.board)
+        mini_max(game, symbol, 0)
+        BoardMapper.map_coordinate(@move.xval, @move.yval)
+      else
+        tile = corners(board).sample
+        BoardMapper.map_coordinate(tile.xval, tile.yval)
+      end
+    end
+
+    def make_move(board, coordinate)
+      tile = BoardMapper.map_string(board, coordinate)
+      tile.mark(symbol)
+    end
+
+    def mini_max(game, current_player, depth)
+      return evaluate(game, depth) if game.end_state?
+      scores = []
+      moves = []
+      depth += 1
+
+      available_moves(game.board).each do |tile|
+        new_state = get_new_state(tile, game, current_player)
+
+        # I got this idea from the post mentioned in the README
+        scores << mini_max(new_state, next_player(current_player), depth)
+        moves << tile
+      end
+      return choose_move(current_player, scores, moves)
+    end
+
+    def available_moves(board)
+      unmarked_tiles(board)
+    end
+
+    def human?
+      false
+    end
+
+    private
+    def new_board?(board)
+      unmarked_tiles(board).size == (board.width*board.height)
+    end
+
+    def corners(board)
+      corners = []
+
+      corners << board.first[0]
+      corners << board.first.last
+
+      corners << board.last.first
+      corners << board.last.last
+    end
+
+    def initial_game_state(board, turn_num, symbol)
+      GameState.new(board, turn_num, symbol)
+    end
+
+    def choose_move(current_player, scores, moves)
+      if current_player == symbol
+        max_index = scores.each_with_index.max[1]
+        @move = moves[max_index]
+        return scores[max_index]
+      else
+        min_index = scores.each_with_index.min[1]
+        @move = moves[min_index]
+        return scores[min_index]
+      end
+    end
+
+    def evaluate(game, depth)
+      if game.end_state? == symbol
+        return 10 - depth
+      elsif game.end_state? == opponent
+        return depth - 10
+      else
+        return 0
+      end
+    end
+
+    def get_new_state(tile, game, current_player)
+      # copy board class and deep copy the inner board array
+      # Marshal is necessary b/c board array does not contain
+      # Plain Old Ruby Objects
+      temp_board = game.board.dup
+      board_array = Marshal.load(Marshal.dump(game.board.board))
+      temp_board.board = board_array
+
+      temp_board[tile.xval][tile.yval].mark(current_player)
+
+      GameState.new(temp_board, game.turn_num+1, current_player)
+    end
+
+    def next_player(current_player)
+      if current_player == "x"
+        "o"
+      else
+        "x"
+      end
+    end
+
+    def opponent
+      next_player(symbol)
+    end
+
+    def unmarked_tiles(board)
+      unmarked = []
+      board.each do |row|
+        row.each do |tile|
+          unmarked << tile unless tile.marked?
+        end
+      end
+      unmarked
+    end
+  end
+end

data/lib/jbcden_ttt/display_board.rb

@@ -0,0 +1,46 @@
+module JbcdenTtt
+  class DisplayBoard
+
+    ROW_NAMES = [
+      "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m",
+      "n", "o", "p", "q", "r", "t", "u", "v", "w", "x", "y", "z"
+    ]
+
+    def self.call(board)
+      str = ""
+      row_num = 0
+      str << print_column_numbers(board.first.size)
+
+      board.each do |row|
+        str << print_row(row, row_num)
+        row_num += 1
+      end
+      str
+    end
+
+    private
+    def self.print_column_numbers(row_size)
+      str = "  "
+      col = 1
+      count = row_size
+
+      row_size.times do
+        str << col.to_s << " "
+        col += 1
+      end
+      str << "\n"
+      str
+    end
+
+    def self.print_row(row, row_num)
+      str = ""
+      str << ROW_NAMES[row_num] << " "
+      row.each_with_index do |column, index|
+        str << column.symbol
+        str << "|" unless index == row.size-1
+      end
+      str << "\n"
+      str
+    end
+  end
+end

data/lib/jbcden_ttt/game_state.rb

@@ -0,0 +1,114 @@
+module JbcdenTtt
+  class GameState
+    attr_reader :board, :turn_num, :current_player
+    def initialize(board, turn_num, current_player)
+      @board = board
+      @turn_num = turn_num
+      @player = current_player
+    end
+
+    def end_state?
+      if turn_num >= min_turns
+        row_win(board) || column_win(board) || diagonal_win(board) || full_board(board)
+      else
+        false
+      end
+    end
+
+    private
+    def full_board(board)
+      marked = []
+      board.each do |row|
+        row.each do |tile|
+          marked << tile if tile.marked?
+        end
+      end
+      if marked.size == (board.width*board.height)
+        "cat"
+      else
+        false
+      end
+    end
+
+    def winner(xcount, ocount, board, method)
+      win_num = board.public_method(method.to_sym).call
+      cat = (board.width*board.height)/2 + 1
+
+      if xcount == win_num
+        "x"
+      elsif ocount == win_num
+        "o"
+      elsif ocount == cat || xcount == cat
+        "cat"
+      else
+        false
+      end
+    end
+
+    def diagonal_iterator(board, col_num, iterator)
+      xcount = 0
+      ocount = 0
+
+      board.each do |row|
+        xcount += 1 if row[col_num].symbol == "x"
+        ocount += 1 if row[col_num].symbol == "o"
+        col_num += iterator
+      end
+      winner(xcount, ocount, board, "height")
+    end
+
+    def right_diagonal(board)
+      diagonal_iterator(board, board.width - 1, -1)
+    end
+
+    def left_diagonal(board)
+      diagonal_iterator(board, 0, 1)
+    end
+
+    def diagonal_win(board)
+      left_diagonal(board) ||
+        right_diagonal(board)
+    end
+
+    def column_win(board)
+      xcount = 0
+      ocount = 0
+      col_num = 0
+
+      board.width.times do
+        board.each do |row|
+          xcount += 1 if row[col_num].symbol == "x"
+          ocount += 1 if row[col_num].symbol == "o"
+        end
+        if w = winner(xcount, ocount, board, "height")
+          return w
+        end
+        xcount = 0
+        ocount = 0
+        col_num += 1
+      end
+      false
+    end
+
+    def row_win(board)
+      xcount = 0
+      ocount = 0
+      board.each do |row|
+        row.each do |col|
+          xcount += 1 if col.symbol == "x"
+          ocount += 1 if col.symbol == "o"
+        end
+        if w = winner(xcount, ocount, board, "width")
+          return w
+        end
+        xcount = 0
+        ocount = 0
+      end
+      false
+    end
+
+    def min_turns
+      5
+    end
+  end
+end

data/lib/jbcden_ttt/player.rb

@@ -0,0 +1,26 @@
+module JbcdenTtt
+  class Player
+    class InvalidCharacterError < StandardError
+      def initialize(msg='Only "x" and "o" are valid character choices.')
+        super
+      end
+    end
+    attr_reader :symbol
+    def initialize(symbol)
+      if symbol == "x" || symbol == "o"
+        @symbol = symbol
+      else
+        raise InvalidCharacterError
+      end
+    end
+
+    def make_move(board, coordinate)
+      tile = BoardMapper.map_string(board, coordinate)
+      tile.mark(symbol)
+    end
+
+    def human?
+      true
+    end
+  end
+end

data/lib/jbcden_ttt/tile.rb

@@ -0,0 +1,37 @@
+module JbcdenTtt
+  class Tile
+    class InvalidActionError < StandardError
+      def initialize(msg="This tile has already been marked")
+        super
+      end
+    end
+    attr_reader :symbol, :xval, :yval
+    attr_writer :marked, :symbol
+
+    def initialize(symbol, xval, yval)
+      @symbol = symbol
+      @xval = xval
+      @yval = yval
+    end
+
+    def marked?
+      @marked ||= false
+    end
+
+    def mark(new_symbol)
+      if markable?
+        @symbol = new_symbol
+        @marked = true
+      else
+        raise InvalidActionError
+      end
+    end
+
+    private
+    def markable?
+      # we need to accept the ' ' because the symbol for the bottom left and right
+      # corners of the board is ' '. Must remember to look at this again later.
+      @symbol == '_' || @symbol == ' '
+    end
+  end
+end

data/lib/jbcden_ttt/version.rb

@@ -0,0 +1,3 @@
+module JbcdenTtt
+  VERSION = "0.0.1"
+end

data/test/board_mapper_test.rb

@@ -0,0 +1,38 @@
+require_relative './test_helper'
+require 'board'
+require 'board_mapper'
+
+module JbcdenTtt
+  class BoardMapperTest < MiniTest::Test
+    def setup
+      @board = Board.new(3,3)
+    end
+
+    def test_coordinate_strings_are_mapped_correctly
+      expected = @board[0][0]
+      actual = BoardMapper.map_string(@board, "a1")
+
+      assert_equal expected, actual
+    end
+
+    def test_it_throws_an_error_for_invalid_column
+      assert_raises(BoardMapper::InvalidCoordinateError) {
+        BoardMapper.map_string(@board, "a4")
+      }
+    end
+
+    def test_it_throws_an_error_for_invalid_row
+      assert_raises(BoardMapper::InvalidCoordinateError) {
+        BoardMapper.map_string(@board, "d3")
+      }
+    end
+
+    def test_coordinates_can_be_mapped_into_strings
+      actual = BoardMapper.map_coordinate(2,2)
+      actual2 = BoardMapper.map_coordinate(6, 7)
+
+      assert_equal "c3", actual
+      assert_equal "g8", actual2
+    end
+  end
+end

data/test/board_test.rb

@@ -0,0 +1,32 @@
+require_relative './test_helper'
+require 'board'
+
+module JbcdenTtt
+  class BoardTest < MiniTest::Test
+    def test_board_takes_a_height_and_length
+      board = Board.new(3,3)
+      assert_equal board.height, 3
+      assert_equal board.width, 3
+    end
+
+    def test_internal_board_array_dimensions
+      actual = Board.new(4,5)
+      assert_equal 4, actual[0].size
+      assert_equal 5, actual.size
+    end
+
+    def test_board_is_set_correctly
+      actual = Board.new(5,6)
+
+      assert_equal '_', actual[0][0].symbol
+      assert_equal '_', actual[1][1].symbol
+      assert_equal '_', actual[2][2].symbol
+      assert_equal '_', actual[3][3].symbol
+      assert_equal '_', actual[4][4].symbol
+
+      assert_equal ' ', actual[5][0].symbol
+      assert_equal ' ', actual[5][2].symbol
+      assert_equal ' ', actual[5][4].symbol
+    end
+  end
+end

data/test/computer_test.rb

@@ -0,0 +1,89 @@
+require_relative './test_helper'
+require 'computer'
+require 'board'
+require 'game_state'
+
+module JbcdenTtt
+  class ComputerTest < MiniTest::Test
+    def setup
+      @board = Board.new(3,3)
+    end
+
+    def test_can_get_list_of_available_moves
+      computer = Computer.new("x")
+
+      @board[0][1].mark("x")
+      @board[1][2].mark("x")
+      @board[2][1].mark("x")
+
+      available_moves = computer.available_moves(@board)
+
+      refute_includes available_moves, @board[0][1]
+      refute_includes available_moves, @board[1][2]
+      refute_includes available_moves, @board[2][1]
+
+      assert_includes available_moves, @board[0][0]
+      assert_includes available_moves, @board[0][2]
+      assert_includes available_moves, @board[1][0]
+      assert_includes available_moves, @board[1][1]
+      assert_includes available_moves, @board[2][0]
+      assert_includes available_moves, @board[2][2]
+    end
+
+    def test_select_winning_move
+      computer = Computer.new("x")
+
+      @board[0][0].mark("o")
+      @board[2][1].mark("o")
+      @board[2][2].mark("o")
+
+      @board[0][2].mark("x")
+      @board[1][0].mark("x")
+      @board[2][0].mark("x")
+
+      game = GameState.new(@board, 7, computer.symbol)
+
+      move = computer.calculate_best_move(@board, game)
+
+      assert_equal "b2", move
+    end
+
+    def test_select_winning_move_depth
+      computer = Computer.new("o")
+
+      @board[2][0].mark("x")
+      @board[2][1].mark("x")
+
+      @board[0][1].mark("o")
+      @board[1][2].mark("o")
+      @board[2][2].mark("o")
+
+      game = GameState.new(@board, 7, computer.symbol)
+
+      move = computer.calculate_best_move(@board, game)
+
+      assert_equal "a3", move
+    end
+
+    def test_computer_marks_best_move
+      computer = Computer.new("o")
+
+      @board[2][0].mark("x")
+      @board[2][1].mark("x")
+
+      @board[0][1].mark("o")
+      @board[1][2].mark("o")
+      @board[2][2].mark("o")
+
+      game = GameState.new(@board, 7, computer.symbol)
+
+      move = computer.calculate_best_move(@board, game)
+      computer.make_move(@board, move)
+
+      tile = BoardMapper.map_string(@board, move)
+
+      assert_equal true, @board[tile.xval][tile.yval].marked?
+      assert_equal "o", @board[tile.xval][tile.yval].symbol
+    end
+  end
+end

data/test/display_board_test.rb

@@ -0,0 +1,19 @@
+require_relative './test_helper'
+require 'board'
+require 'display_board'
+
+module JbcdenTtt
+  class DisplayBoardTest < MiniTest::Test
+    def test_board_display
+      actual = Board.new(3,3).display
+      result = <<'BOARD'
+  1 2 3 
+a _|_|_
+b _|_|_
+c  | | 
+BOARD
+
+      assert_equal result, actual
+    end
+  end
+end

data/test/game_state_test.rb

@@ -0,0 +1,61 @@
+require_relative './test_helper'
+require 'game_state'
+
+module JbcdenTtt
+  class GameStateTest < MiniTest::Test
+    def setup
+      @board = Board.new(3,3)
+    end
+
+    def test_will_always_return_false_if_min_turns_is_not_met
+      @board[1][0].mark("x")
+      @board[1][1].mark("x")
+      @board[1][2].mark("x")
+      game1 = GameState.new(@board, 1, "x")
+      game2 = GameState.new(@board, 2, "x")
+      game3 = GameState.new(@board, 3, "x")
+      game4 = GameState.new(@board, 4, "x")
+
+      assert_equal false, game1.end_state?
+      assert_equal false, game2.end_state?
+      assert_equal false, game3.end_state?
+      assert_equal false, game4.end_state?
+    end
+
+    def test_will_end_when_a_row_win_condition_is_met
+      @board[1][0].mark("x")
+      @board[1][1].mark("x")
+      @board[1][2].mark("x")
+      game = GameState.new(@board, 5, "x")
+
+      assert_equal "x", game.end_state?
+    end
+
+    def test_will_end_when_a_column_win_condition_is_met
+      @board[0][2].mark("x")
+      @board[1][2].mark("x")
+      @board[2][2].mark("x")
+      game = GameState.new(@board, 5, "x")
+
+      assert_equal "x", game.end_state?
+    end
+
+    def test_will_end_when_a_left_diagonal_win_condition_is_met
+      @board[0][0].mark("x")
+      @board[1][1].mark("x")
+      @board[2][2].mark("x")
+      game = GameState.new(@board, 5, "x")
+
+      assert_equal "x", game.end_state?
+    end
+
+    def test_will_end_when_a_right_diagonal_win_condition_is_met
+      @board[0][2].mark("x")
+      @board[1][1].mark("x")
+      @board[2][0].mark("x")
+      game = GameState.new(@board, 5, "x")
+
+      assert_equal "x", game.end_state?
+    end
+  end
+end

data/test/player_test.rb

@@ -0,0 +1,22 @@
+require 'player'
+
+module JbcdenTtt
+  class PlayerTest < MiniTest::Test
+    def test_a_player_has_a_symbol
+      player = Player.new("x")
+
+      assert_equal "x", player.symbol
+    end
+
+    def test_a_player_has_a_turn_and_can_pick_a_move
+      board = Board.new(3,3)
+      player = Player.new("x")
+
+      assert_equal false, board[0][1].marked?
+
+      player.make_move(board, "a2")
+      assert_equal true, board[0][1].marked?
+      assert_equal player.symbol, board[0][1].symbol
+    end
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,4 @@
+$:.unshift File.expand_path('../../lib/jbcden_ttt', __FILE__)
+
+require 'minitest/autorun'
+require 'minitest/pride'

data/test/tile_test.rb

@@ -0,0 +1,52 @@
+require_relative './test_helper'
+require 'tile'
+
+module JbcdenTtt
+  class TileTest < MiniTest::Test
+    def test_it_has_a_character
+      actual = Tile.new('|', 0, 0)
+      assert_equal '|', actual.symbol
+    end
+
+    def test_it_initially_is_marked
+      actual = Tile.new('|', 0, 0)
+      assert_equal false, actual.marked?
+    end
+
+    def test_can_mark_a_tile
+      tile = Tile.new('_', 0, 0)
+      tile.mark("x")
+
+      assert_equal "x", tile.symbol
+      refute_equal '_', tile.symbol
+    end
+
+    def test_marking_a_tile_marks_it
+      tile = Tile.new('_', 0, 0)
+      assert_equal false, tile.marked?
+
+      tile.mark("x")
+      assert_equal true, tile.marked?
+    end
+
+    def test_cannot_mark_pipe_tiles
+      tile = Tile.new('|', 0, 0)
+
+      assert_raises(Tile::InvalidActionError) {
+        tile.mark("x")
+      }
+    end
+
+    def test_tile_knows_its_xcoordinate
+      tile = Tile.new('_', 5, 0)
+
+      assert_equal 5, tile.xval
+    end
+
+    def test_tile_knows_its_ycoordinate
+      tile = Tile.new('_', 5, 0)
+
+      assert_equal 0, tile.yval
+    end
+  end
+end

metadata

@@ -0,0 +1,105 @@
+--- !ruby/object:Gem::Specification
+name: jbcden_ttt
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Jacob Chae
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-11-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 
+email:
+- jbcden@gmail.com
+executables:
+- ttt
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/ttt
+- jbcden_ttt.gemspec
+- lib/jbcden_ttt.rb
+- lib/jbcden_ttt/board.rb
+- lib/jbcden_ttt/board_mapper.rb
+- lib/jbcden_ttt/computer.rb
+- lib/jbcden_ttt/display_board.rb
+- lib/jbcden_ttt/game_state.rb
+- lib/jbcden_ttt/player.rb
+- lib/jbcden_ttt/tile.rb
+- lib/jbcden_ttt/version.rb
+- test/board_mapper_test.rb
+- test/board_test.rb
+- test/computer_test.rb
+- test/display_board_test.rb
+- test/game_state_test.rb
+- test/player_test.rb
+- test/test_helper.rb
+- test/tile_test.rb
+homepage: https://github.com/jbcden/tic-tac-toe
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: A basic command line based game of tic tac toe.
+test_files:
+- test/board_mapper_test.rb
+- test/board_test.rb
+- test/computer_test.rb
+- test/display_board_test.rb
+- test/game_state_test.rb
+- test/player_test.rb
+- test/test_helper.rb
+- test/tile_test.rb