Test to ensure players cannot modify the board

Write a test to confirm that the cloning of the board insulates the game
board from modification by players.
Make #generate_solutions work for board size 4

Method #generate_solutions should take no arguments and return no value.
The method should fill the 'solutions' attribute with a two-dimensional
array holding integers. Each integer array should represent a list of
board spaces which are a winning solution for the board.

This method should create a full list of horizontal, vertical, and
diagonal solutions for board sizes of 3 and 4. The length of each
solution array should be equal to the size of the board.
Test #initialize for board space initialization

Method #initialize should store an array of blank marks of length equal
to the square of the board size.
 - (e.g. board size 3 = 9 blank spaces)
 - (e.g. board size 4 = 16 blank spaces)
Change spacing to use more padding
Adjust #available_spaces_to_ascii for size 4 board

Boards of size 4 have space indices up to two digits in length, to
maintain consistent display of these values, they should be displayed
with a constant padding.

Change #available_spaces_to_ascii to apply a simple string formatting
with padding before storing the index in the result array.
Make #display_board always pad using five spaces

Output from #display_board currently squeezes output into ten spaces,
aligned to the right. Using the same alignment, output should use a
constant of five spaces to pad.
Make #display_board_choices pad using five spaces

Output from #display_board_choices currently squeezes output into ten
spaces, aligned to the right. Using the same alignment, output should use a
constant of five spaces to pad.
Add method #prompt_board_size to get board size

Method #prompt_board_size should take no arguments and return an integer
representing the desired size of the board. The console prompter should
be set with valid_inputs of '3x3' and '4x4' for the accepted board
sizes. A request should be issued with a clear message requesting board
size from the user. The input should then be converted to an integer
appropriate to construct a board of the requested dimensions.
Make Configuration hold an array of board sizes

Configuration should have the responsibility of knowing which board
sizes may be used in a game. These values should be stored in a class
attribute array.
Add method #choose_board to create a board

Method #choose_board should take no arguments and return no value. It
should call console method #prompt_board_size, instantiate a board of
the requested size, and store that board in the 'board' reader
attribute.

This method should be placed in the #setup sequence after #choose_player
and #choose_opponent methods.
Make #initialize store the Configuration board

The Configuration object should have the responsibility of initializing
the board used by the game. Method #initialize in the Game class should
store a reference to the Configuration's board.
Make #prompt_player_mark use an array argument

Method #prompt_player_mark should receive an array as an argument, and
return an integer result. The array passed to the method should be a
list of the BLANK spaces on the game board. The resulting integer should
be one of these indices as designated by the player/user.

Each value in the array argument should be incremented for the sake of
presentation and converted to a String form. These values should be
stored in the 'valid_input' attribute of the console's Prompter object.
This part is necessary to ensure that input to the prompter is matched
to a String.

When input is supplied to and returned from the prompter, it is
converted back to an integer and decremented to account for the
original increment for presentation.

Use of the method #prompt_player_mark by the Human class should account
for the change in arguments.
Indicate winner using mark instead of number

With the way that the Configuration class handles player ordering, first
and second player are indistinguishable. This is also true for during
gameplay. It is clearer and more appropriate to make the distinction
using the marks assigned to the players.

To accomplish this, Game method #display_game_results should pass the
winning symbol to the console method #display_game_winner, which will
display a message using the ascii character associated with that symbol.
Make #initialize receive a depth limit value

The minimax algorithm will be limited to a set number of levels of
recursion. The limit should be set at instantiation and remain
unmodified. For testing, this attribute should be a reader.
Make #initialize set current depth to zero

Reader attribute current_depth should be set to zero upon instantiation.
Limit minimax recursion using depth limit

The Minimax algorithm performs a rescursive pattern measurable by the
factorial of the number of board spaces. Limiting the depth will divide
the calculations by another factorial on the difference of the spaces and
the limit.
Add accessor attribute :symbol to Player classes

Players should be aware of the way they are represented in the game.
Make #assign_symbols store symbols in players
Swap use of player references for player symbols

Player symbols should be used on the board, not references.
Merge branch 'master' of https://github.com/jneander/tic-tac-toe-ruby

Conflicts:
	spec/game_spec.rb