The same rules apply as with Project 1: this project is to be your own work.

The Assignment:

• Implement the children's game Chutes and Ladders. (Your program will pretend to be one person playing this game.)
• Find the shortest length game that goes down exactly two chutes.
• Use paint in an applet to draw a picture of the board, of the chutes and ladders, and of the moves of a game.

Hand-in Requirements:

• Part I: Hard-copy source for:
  • The files Board.java, Chutes.java, Dice.java, and ChutesDemo.java that create a Java application (that is, a Java program with a main function) to play the Chutes and Ladders game.
  • The file Chutes.java that searches for the shortest game that goes down exactly two chutes.
  • Program output demonstrating that your program works by showing the moves of a game.
  • Program output showing the results of your search for the shortest game that goes down exactly two chutes.

• Part I: Hard-copy source for:
  • Board.java, Chutes.java, and Dice.java files that create a Java applet to play the Chutes and Ladders game and to paint the board, showing the locations of the various ladders and chutes, as well as the moves that are made.

The Game.

• Description: This assignment simulates the play of a popular children's game known as Chutes and Ladders, with a board as shown in the picture above and the diagram below. The board has 100 squares, numbered 1 through 100. Players start just before the first square and roll a single die (1 through 6 spots, all 6 equally likely) at each play. A player's token is moved forward by the number of spots on the die. After moving, the new square is examined for a ladder (green line in the diagram below) leading up to a higher-numbered square, and if one is present the player proceeds up the ladder to the new square. A square might also have the top of a chute (blue line in the diagram below) in it, leading to a lower-numbered square, and in this case the player "slides" down the chute after arriving at the square. Arriving either at the top of a ladder or at the bottom of a chute has no significance. The game ends when a player first reaches space 100. Players are not permitted to move to square 100 if the current position plus the number of spots is greater than 100. (In that case you lose a turn.)

• Diagram Showing Ladders (green) and Chutes (blue):
  

• Applet Showing One Person Playing the Chutes and Ladders Game:
    Applet
    2nd version
    2-person version
    Fancy 2-person version

• Part I has four parts:
  • A class Chutes.java that pretends to be one person playing the Chutes and Ladders Game one time.
  • A class Board.java that will provide information about locations of individual chutes and ladders on the board used to play the game, and that will draw the board in an applet window.
  • A class Dice.java that will roll a single die. (This is already written.)
  • A class ChutesDemo.java (with a main function) that creates the Chutes class and calls a method to play the game.

• Details about the class Board.java:

  A simple way to keep track of the locations of chutes and ladders is to use the following array:

  
     private int[] cLArray =
        {-1, 38,  0,  0, 14,  0,  0,  0,  0, 31,  0,
              0,  0,  0,  0,  0,  6,  0,  0,  0,  0,
             42,  0,  0,  0,  0,  0,  0, 84,  0,  0,
              0,  0,  0,  0,  0, 44,  0,  0,  0,  0,
              0,  0,  0,  0,  0,  0, 26,  0, 11,  0,
             67,  0,  0,  0,  0, 53,  0,  0,  0,  0,
              0, 19,  0, 60,  0,  0,  0,  0,  0,  0,
             91,  0,  0,  0,  0,  0,  0,  0,  0, 100,
              0,  0,  0,  0,  0,  0, 24,  0,  0,  0,
              0,  0, 73,  0, 75,  0,  0, 78,  0,  0};
  

  Here the array index i goes from 0 to 100 inclusive. Position 0 has no meaning, but otherwise if position i is not zero, it gives the far end of a chute or ladder starting at i. A ladder will have cLArray[i] greater than i and a chute will have cLArray[i] less than i. For example, cLArray[4] is a 14, meaning that there is a ladder from 4 to 4. Similarly cLArray[16] is a 6, meaning that there is a chute from 16 to 6.

• Getting Started:

  To start the project, you just need a Board class with the array cLArray in it as above and with a method public int getEnd(int position) that will return the value of cLArray[position].

• Playing the Game:

  Back in a Chute class, you can keep track of the position of the piece on the board using a variable position, initially 0. Use the Dice class to roll one die, and update position to position + die. Then use getEnd in Board to check if the new position is at the start of a chute or ladder. If it is, change position to the far end of the chute or ladder. You also have to worry about position 100, since the board piece can't go beyond that position, and if you reach position 100 the game is over.

  Here are several sample runs of the game: Sample runs.

• Searching for the Shortest Game Going Down Two Chutes:

  Add a loop to your program that will repeatedly play the game looking for the following special configuration: the shortest possible sequence of dice throws that will finish a game and go down two chutes. Do not search for this answer by hand, since the only interest is in what you can program.

  Hints about this part: Each time you play another game, record the sequence of dice rolls in a String. If the new game is shorter than any you've had before, print this string, but otherwise just discard the string and go on to the next trial game. Here is a sample partial run of a program carrying out the search, though the final results of the search are not included (no games shorter than 14 moves): Sample run.

• Part II has three distinct parts:
  • An applet (with a paint function) Chutes.java that pretends to be one person playing the Chutes and Ladders Game. (You can incorporate most of the code from the file Chutes.java of Part I into this new class without changing it.)
  • A class Board.java that will
    • provide information about locations of individual chutes and ladders on the board used to play the game (already in Part I),
    • draw the board in an applet window, including the numbers of the squares, and the chutes and ladders, roughly as shown above (new feature), and
    • draw circles for moves of the game, again roughly as shown above (new feature).
  • The same Dice.java class that was used before.

• About Drawing the Board:
  • This is done in a way similar to that or Recitation 4, where you drew pictures of dice. As you did then, you need to pass the Graphics class to the methods that will do the drawing.

• About Mapping a Board Number to an Actual Square on the Board:
  • In some ways, this may be the hardest part. Suppose rowNum denotes the rows of the board, with row 1, then row 2, and so on to row 10, going from top to bottom. Suppose further that colNum denotes the columns of the board, with column 1, then column 2, and so on to column 10 (going from left to right). Then the following function takes the number of a square on the board as input and sets the rowNum and colNum values properly:

    
       private void getCoords(int boardNum) {  
          int rowNum = 10 - (boardNum - 1)/10;
          int colNum;
          if (((boardNum - 1)/10)%2 == 0) colNum = (boardNum - 1)%10 + 1;
          else colNum = 10 - (boardNum - 1)%10;
       }
    

    You can use data fields in the class to retrieve these values of rowNum and colNum. Later in class we will talk about returning two numbers at once from a function.

  • The previous part gets a row and column number. To get Java x and y coordinates, you could use declarations like the following:

    
       private final int X_CORNER = 30; // upper left corner of board (x coord)
       private final int Y_CORNER = 50; // upper left corner of board (y coord)
       private final int SIDE = 40;     // length of a side of a board square
      

    The get the center of board postion 42, for example, the above function gives rowNum equal 6 and colNum equal 2. So to get xy coordinates of the center of this board square, in the y direction one goes Y_CORNER amount, then skips over rowNum - 1 squares (of size SIZE) and the goes an additional amount SIZE/2. The calculation for the x direction is similar.