CSc 110 - Mancala

Ever seen a game board like this one? This is one variant of a Mancala board. According to the Mancala Wikipedia page, “Mancala is one of the oldest games played.” The game’s origins have been traced back to eastern Africa around the 6th century AD. In this PA, you will be implementing a variant of a Mancala game.

Like I mentioned earlier, Mancala is actually a family of games, not a specific one. The Wikipedia page lists some of the games within this family, but not all versions of the game have the same rules. Generally, the variants of the game have a similar board and rules that resemble others.

Rules

For our Mancala variant, we will use the board and rules described in this section.

Mancala is played on a mancala board. The board is arranged like so:

• There are two rows of 5 holes, each player owning one row. Each hole begins with three chips in it.
• Each player has a mancala store, beginning with zero chips. The mancala stores are on either size of the rows of holes.
• Player 1 owns the bottom row of holes and the mancala store on the left.
• Player 2 owns the top row of holes and the mancala store on the right.

The game is played as follows:

• Players alternate turns, starting with player 1.
• Each turn, the current player selects one hole from their row to sow from.
• When you “sow” from a hole, the following takes place:
  • All chips from the selected hole are removed.
  • The removed chips should be dispersed to the other holes and the currentl player’s mancala store in a round-robin way, counter-clockwise.
  • The opponents mancala store is skipped
• The goal of the game is to get 3 chips into your own mancala store. The first player to get this wins.
• Chips can be added to your mancala store in two ways:
  • By the usual sowing process. If you sow from a hole that has sufficient chips in it to make it all the way to your mancala store, then they will score a point.
  • If, when sowing, the last chip that it placed is to be placed in an empty hole, this chip is placed into the mancala store instead of the empty hole.

Gameplay

This interface for this program will be a combination of graphical (with the graphics module) and command-line. You will use graphics to display the board and the location of all of the chips. You will use the command-line to prompt the user for their move. When the game begins, the graphical component should look like this:

The canvas should be 700 pixels wide and 300 pixels tall. You should display all of the same components that this screen-shot shows, such as the game label, holes, mancala stores, player labels, and chip counts. The numbers in each of the holes and mancala stores represents the number of chips in them.

While this is displaying, the program will prompt the first player (player 1) for their move like so:

Player 1: Enter position to start moving chips at:

The program should continue to ask player 1 and player two for their moves until the game is over. An example will be shown later in this spec. Each player should enter a number between 1 and 5. If the player does not enter a valid input, the program will continue to ask the same player until a valid number is entered. The numbers 1-5 correspond to the various holes for each player, as shown in the diagram below. Also, the light-blue arrow represents the direction of play (counter-clockwise).

Game-play Demo

Below is a video showing an example of a game-play sequence. This shows a sequence of turns that leads to player 1 wining. You can use this as a check to ensure that your version of the program is working. You can pause the video at various points if you need to. NOTE: In the videos, the input is typed on the same line as the prompt. In your program, it should be read in on the next line.

Notice how the chip counts update based on each move of that is entered into the command-line.

Below is another video showing another sequence of turns that leads to player 2 winning.

You should study the video closely, and pause if you need to, and make sure you understand what happens (and why) for each move that is made).

Development Strategy

I recommend that you tackle this program with the following steps:

• Create a new folder for your project, and create a new mancala.py file. Also, download graphics.py from the class website and put it in the same directory. Finally, import the module as we talked about in class.
• Next, create some variables / data-structures to represent the state of the Mancala board. You will want to use one (or more) lists to represent the rows of holes. You may use either a list or two separate variables to represent the values for the Mancala stores.
• Next, work on getting the graphical display showing up. At this point, don’t worry about the user input, turns, game updates, etc. Just draw all of the rectangles and text labels with the appropriate values and in the correct places. All of the drawing should be based on the values in your variables and lists that you created in the previous step. This will help you get more familiar with the graphics module, too.
• Now, work on getting the user input for the turns. Make sure to alternate asking players 1 and 2 for their moves.
• Once you have the input values, write one or more functions to handle updating the board based on the moves.
• Finally, get the winning logic implemented.

Restrictions

You must use lists to represent the pits. You may not use the exit function.

Due Date

This PA is due Friday, October 12, at 5:00pm. Turn in the program via Gradescope. You should try your best to get all of the test cases passing.