For this assignment, you will create a Ruby source file
`connect4.rb` containing a Ruby function(s) implementing each
of the problems described below. If you find it useful for any of the
problems in this assignment, you may define additional helper functions
that your primary function for that problem calls to solve a sub-problem.
Definitions for these helper functions should be included in the same
Ruby source file. You should store `connect4.rb` in a folder
named pa11.

Note: *You are responsible for protecting your solutions to these
problems from being seen by other students* either physically (e.g., by
looking over your shoulder) or electronically.
(More information can be found in the instructions
for Programming Assignment 2.)

In this assignment, you will complete a program to allow two players to play a game of Connect Four.

The vertical game board consists of 7 columns that can hold up to 6 discs. Two players (Red and Black) alternate dropping a colored disc (red and black, respectively) into one of the columns, with each disc falling as far as it can go. The first player to get four of the same color in a row (vertically, horizontally or diagonally) wins the game. If neither player can do this after all disc locations are filled, then the game ends in a tie.

In this game, the players are represented with the numbers `0`

(Red)
and `1`

(Black). The game board is represented using a
two-dimensional
array with 6 rows and 7 columns. In each cell of this array, we store
a `0`

if there is a red disc in that position, a
`1`

if there is a black
disc in that position, or nil if there is no disc in that position.
(Initially, this array consists of only `nil`

values.)
Rows are numbered from 0 to 5 from top to bottom, and columns
are numbered from 0 to 6 from left to right.

To display the board, we will use the Canvas to create a window with a width of 175 pixels and a height of 150 pixels. The window is broken up into 42 square regions of size 25 X 25, forming 6 rows and 7 columns. In each square region, we draw a circle centered in the square region with a radius of 10 pixels, filled in with either red, black, or white, depending on the value stored in the equivalent position of the two-dimensional array for the game board.

To draw a circle with center (`x`,`y`) and
radius of 10 pixels, you can use the following method call:

Canvas::Circle.new(x, y, 10, :fill => :red, :outline => :black, :width => 2)

As an example, here is the two-dimensional array for a game board in this game along with the corresponding display in the Canvas.

[ [nil, nil, nil, nil, nil, nil, nil], [nil, nil, nil, nil, nil, nil, nil], [nil, nil, nil, nil, nil, 1, nil], [nil, 1, nil, nil, 1, 0, nil], [nil, 0, nil, nil, 0, 0, nil], [0, 1, 1, nil, 1, 0, nil] ]

Complete the problems below to complete this game in Ruby.

In this assignment, you should start by downloading a copy
of the file connect4.rb into your
`pa11` folder. **Read through the first two functions
we give you to see how they work. You are responsible for
understanding all of the code we've given you.** The main function
that you run to play the game is called `play()`.

You will see that the file we give you
has all of the functions represented as "stubs". This means
that each function is written so that it returns something
so that the entire program will run without crashing
if you haven't completed all of the functions.
**
As you complete each function, replace the code we give
you for the function in question with your own code, but
leave the subsequent stubs in place until you have tested
your current function completely.
**

[1 point] Complete the function

`new_board()`(in the file`connect4.rb`). This function should create and return a two-dimensional array with 6 rows and 7 columns with all array values set to nil.[2 points] Complete the function

`display_board(board)`(in the file`connect4.rb`). This function has one parameter which is the two-dimensional array`board`that holds the position of each disc in the game as described above.General Algorithm:

- For each
*row*and*column*, do the following:- Compute the
*x*and*y*location of the center of the corresponding square region of the Canvas for that row and column. - If
*board[row][column]*is equal to`0`

, then draw a circle with a center of (*x,y*), a radius of 10, and a fill color of red and a black outline of width 2 pixels. - If
*board[row][column]*is equal to`1`

, then draw a circle with a center of (*x,y*), a radius of 10, and a fill color of black and a black outline of width 2 pixels. - If
*board[row][column]*is equal to`nil`

, then draw a circle with a center of (*x,y*), a radius of 10, and a fill color of white and a black outline of width 2 pixels.

- Compute the

**Testing your work:**Once you finish this function, when you run the program by calling the function`play()`within`irb`, you should see an empty board with 42 white circles.- For each
[2 points] Complete the function

`add_piece(board, player, column)`(in the file`connect4.rb`). This function has three parameters which are the two-dimensional array`board`that holds the position of each disc in the game, the number of the current`player`who is dropping a disc (0 or 1), and the`column`where the disc is being dropped (an integer between 0 and 6, inclusive). This function should update the board to the state it would be in after the disc has been dropped down the given column (if possible).The basic idea is to scan the column from the bottom to the top for the first empty (nil) cell. You will then "drop" the disc into that cell by storing the player's number in that location. If the entire column is full, then you will return

`nil`

and not change the game board.General algorithm:

- For each
*row*in the given*column*from 5 down to 0, do the following:- If
*board[row][column]*is`nil`

, then do the following:- Store the player's number in
*board[row][column]*. - Return the
*row*where the disc stopped in that column.

- Store the player's number in

- If
- Return
`nil`

(since the entire column is full if you get to this step).

**Testing your work:**Once you finish this function, you should be able to play the game, dropping discs (alternating red and black), but the game will not test to see if anyone wins.- For each
[1 point] Complete the function

`check_win_vertical(board, row, column)`(in the file`connect4.rb`). This function has three parameters which are the two-dimensional array`board`that holds the position of each disc in the game, and the`row`and`column`where the most recent disc was placed. This function should return`true`

if the player who placed this disc has won vertically, or false otherwise.To test if the player wins vertically, you only have to count the number of discs of the same player below the newly placed disc until you either find a different player, or the bottom of the game board. (None of the locations below the newly placed disc can be empty.)

General algorithm:

- Set
*player*equal to*board[row][column]*. - Set
*count*equal to 1. (That is, count the newly dropped disc.) - Set
*r*equal to \(\textit{row} + 1\). (That is, start with the next row.) - While
*r*is less than or equal to`5`

and*board[r][column]*is equal to player, do the following:- Add 1 to
*count*. - Add 1 to
*r*.

- Add 1 to
- If
*count*is greater than or equal to`4`

, then return`true`

. Otherwise, return`false`

.

**Testing your work:**Once you complete this function, you should be able to play and test for a player winning with 4-in-a-row vertically.- Set
[2 points] Complete the function

`check_win_horizontal(board, row, column)`(in the file`connect4.rb`). This function has three parameters which are the two-dimensional array`board`that holds the position of each disc in the game, and the`row`and`column`where the most recent disc was placed. This function should return`true`

if the player who placed this disc has won horizontally, or`false`

otherwise.This function works similarly to the previous function, except that you have to count the number of adjacent discs of the same color both left

**and**right to see if the complete total is at least 4.General algorithm:

- Set
*player*equal to*board[row][column]*. - Set
*count*equal to 1. (That is, count the newly dropped disc.) - Set
*c*equal to \(\textit{column} + 1\). (That is, start with the next column to the right.) - While
*c*is less than or equal to 6 and*board[row][c]*is equal to*player*, do the following:- Add 1 to
*count*. - Add 1 to
*c*.

- Add 1 to
- Set
*c*equal to \(\textit{column} - 1\). (Now, start with the first column to the left of the newly placed disc.) - While
*c*is greater than or equal to 0 and*board[row][c]*is equal to*player*, do the following:- Add 1 to
*count*. - Subtract 1 from
*c*.

- Add 1 to
- If
*count*is greater than or equal to 4, then return`true`

. Otherwise, return`false`

.

**Testing your work:**Once you complete this function, you should be able to play and test for a player winning with 4-in-a-row vertically or horizontally.- Set
[2 points] Complete the functions

`check_win_diagonal1(board, row, column)`and`check_win_diagonal2(board, row, column)`(in the file`connect4.rb`). These functions have three parameters which are the two-dimensional array`board`that holds the position of each disc in the game, and the`row`and`column`where the most recent disc was placed. These functions should return`true`

if the player who placed this disc has won diagonally, or`false`

otherwise. There are two functions since there are two diagonal lines to test.**Hint:**These functions are similar to the ones you wrote previously. Use those functions are a guide for these functions.**Testing your work:**Once you complete this function, you should be able to play a complete game of Connect Four.

You should now have a `pa11` directory
that contains the required file,
`connect4.rb`
containing the corresponding functions.
Zip up your directory and upload it using the handin system. (The handin system
will accept submissions beginning on Friday until the deadline
Tuesday night. Submissions after the deadline but before the late
deadline will be marked on our system as "late".)