- Build a CLI
- Create a domain model with multiple relating and collaborating objects.
The goal of this project is to build a version of Tic Tac Toe with 0, 1, and 2 player modes. What is the point of Tic Tac Toe with zero players? Let me explain more.
- A 0 player game has two computer players playing against each other with no interaction from the user.
- A 1 player game has a human playing against a computer.
- A 2 player game has two human players.
You'll be implementing Tic Tac Toe using multiple objects that relate and collaborate, including separate classes for Human players and Computer players. The computer player class will have some sort of artificial intelligence or logic to make move decisions. Finally, you'll wrap all of this up in a Command Line Interface.
Instructions for how to work on a Group Project with Learn
Working on a software project with another person is not something to be taken lightly. While you are a fantastic coder solo, software development is a collaborative activity. Just like anything else, there is skill in collaborating on code. In the end, collaborating with another person boils down to three different styles:
- Pair - Pair the entire time working linearly together
- Pass - Each person completes 1 requirement and then passes the project to the other person
- Parallel - work on different parts at the same time by agreeing on interfaces and stubs and meeting in the middle
- Person A codes the board and the human player class
- Person B creates the game engine, expecting a working board and player with stubs
- Person A creates the computer player
- Work together on the AI (It's hard)
Remember! The goal at The Flatiron School is not to do, it is to learn. Make sure you have worked in all three styles of collaboration. We want you to learn how the different styles works, and make sure that together you and your partner understand every part of the code.
- Passing Unit Tests
- 0, 1 or 2 player Tic Tac Toe.
- Command Line Interface
- Computer AI
├── Gemfile
├── Gemfile.lock
├── README.md
├── Rakefile
├── bin
│ └── tictactoe
├── config
│ └── environment.rb
├── lib
├── players
├── computer.rb
└── human.rb
├── board.rb
├── game.rb
└── player.rb
└── spec
├── 01_board_spec.rb
├── 02_player_spec.rb
├── 03_human_player_spec.rb
├── 04_game_spec.rb
├── 05_computer_player_spec.rb
└── spec_helper.rb
This project is supported by Bundler and includes a Gemfile
.
Run bundle install
before getting started on the project.
As this project has quite a few files, an environment.rb
is included that loads all the code in your project along with Bundler. You do not ever need to edit this file. When you see require_relative '../config/environment'
, as in bin/tictactoe
, that is how your environment and code are loaded.
You will be implementing Tic Tac Toe through a domain model that uses multiple classes to encapsulate the different logical components and units in Tic Tac Toe.
The Board
class represents the data and logic of a Tic Tac Toe game board. It has a property, cells
, that stores the data of the state of the board in an array. The #reset!
method can reset the state of the cells to what a board should look like at the start of a game, an array with 9 " "
elements.
When a board is initialized, it should start with cells for a new game of Tic Tac Toe. You can and should use #reset!
.
A board can print its current state with the #display
method.
You'll also build a #position
method that takes in the user's input in the form of 1-9 strings like "2" or "9" and looks up the value of the cells at the correct index from the array's perspective. All other methods will take input in the user's perspective of 1-9 strings and use #position
to look up the value according to the cells' array index.
Similarly, you're going to build an #update
method that represents updating the board when a player makes a move. This method will take two arguments, the first will be the position the user wants to occupy in the form of 1-9 strings that you will need to convert to the board cells' array index, along with the player object making the move. When you update the appropriate index in the cells, you will set it equal to the token of the player object by calling the #token
method on the player.
Finally, a board can return values based on its state such as #full?
when entirely occupied with "X" and "O"s and a #turn_count
based on how many positions in the cells array are filled. #taken?
will return true or false for an individual position. #valid_move?
will ensure that moves are between 1-9 and not taken.
The Player
class is not actually a valid player of Tic Tac Toe but rather a root class that will act as an inheritance point for actual player classes such as Human < Player
and Computer < Player
. The Player
root class will define only the most basic properties of a player, that they have a token
property that can be set upon initialization.
Every player subclass will implement a #move
method that represents how that type of player makes a move in Tic Tac Toe.
Define a class Human
that inherits from Player
. This class should be namespaced inside the module Players
because the human.rb
file is inside the players/
directory. This keeps our code nice and tidy.
The human player must implement a #move
method that takes in a board
argument and allows a human player to enter a move via the CLI. The method should return the value the user enters. Even though the method accepts a board
argument, it does not need to use it.
Note on name spacing: You'll notice here that we do
Players::Human < Player
does not work because thePlayers
module is not yet defined. So to do this, we'll need to do:
module Players
class Human < Player
# your code here
end
end
Now when you call your Human class, you'll have to call it inside it's name space with Players::Human
.
The Game
class is the main model of the application and represents a singular instance of a Tic Tac Toe session.
- A game has one
Board
through itsboard
property. - A game has two
Player
s stored in aplayer_1
andplayer_2
property.
Board
and Player
do not directly relate to the Game
but do collaborate with each other through arguments.
Beyond providing relationships with players and a board, the Game
instance must also provide the basic game runtime and logic. These methods relate to the state of the game such as #current_player
, #won?
, and #winner
. The other methods relate to managing a game, like #start
, #play
, and #turn
. The test suite describes the method requirements.
Define a class Players::Computer
that represents a computer player of Tic Tac Toe. Implement a #move
method that accepts a board and returns the move the computer wants to make in the form of a 1-9 string. How the computer decides to make that move is up to you but it must be capable of returning a valid move at some point.
def move(board)
"1"
end
Returns a valid move for the first move but after that your program will go into an infinite loop because the computer will constantly try to occupy the "1"
position in the board even though it is already occupied. So don't do that.
Think about the levels of intelligence you can build into this method. Start with the simplest level of intelligence, and get more and more complicated. Each step of the way you should have a working computer player though.
Remember, Tic Tac Toe when played perfectly is unwinnable. You should strive to build computer logic that when the computer plays, the game is unwinnable. You can hardcode your logic, things like "On turn 1 always try to go in the middle if you can" and if not "try to go in a corner" or any logic tree you can think of - there is an algorithm called Min/Max, but it's going to be hard to implement given our current implementation of a Game, so we recommend building something that's a more colloquial or condition-based algorithm.
The requirements of your CLI are as follows, free for you to implement however you see fit as we provide no tests against the CLI.
- Greet the user with a message.
- Prompt the user for what kind of game they want to play, 0,1, or 2 player.
- Ask the user for who should go first and be "X".
- Use the input to correctly initialize a
Game
with the appropriate player types and token values. - When the game is over, the CLI should prompt the user if they would like to play again and allow them to choose a new configuration for the game as described above. If the user doesn't want to play again, exit the program.
You can implement this logic within the bin/tictactoe
directly or encapsulate it within Game
via a method like #start
and simply evoke that method in the CLI. There is no wrong way to implement code that works.
If you'd like, implement a "wargames" game type. When asked what kind of game they want to play or for the number of players, if the user types in "wargames", have the computer play itself 100 times and report how many times the game was won. This is not a requirement, it would just be fun. A perfect computer AI should never be able to win, like in the case of thermonuclear war.
The rest is up to you and your team. Have fun, implement the spirit of the project, meet the requirements as you interpret them, be creative, and don't worry, there are no wrong answers with code.
View Tic-Tac-Toe with AI on Learn.co and start learning to code for free.