CSSE 120 Final Python Project—Winter 2010–11

Project Requirements

The final project for the Python part of this course is to implement the Game of Pig. Rules for the game are given below.

Your project must satisfy these core requirements:

1. You must design and implement a fully functional Game of Pig including:
   1. proper alternation of turns
   2. scoring according to the game's rules
   3. detecting who won the game
2. Your project must use a GUI for game play. Your game's window should be no larger than 1024 x 768 pixels, so it can be easily displayed to the class using the projector. zellegraphics should suffice for developing the GUI, but you are welcome to explore and use a different library like pygame if you wish.
3. We strongly encourage you to use top-down design, define some kind of new objects (using dictionaries or instances of classes you create), or consult with your instructor on alternative design choices.
4. For full credit, you must implement some of the enhancements as discussed below.
5. All team members must contribute to and understand their project. Exam 2 will include questions about your project.

Most of the work on your project will be translating the rules provided into a functional design and implementation. There are not many requirements on how specifically you do this. This can be a double edged sword. On the one hand you have a great deal of freedom in designing your solution; on the other hand we are giving very little specific guidance. If you are having trouble planning or getting started, get help. It is much better (and easier) to get help early and start off with a good plan than to try to hack a poor design into a semi-functional program in the final days before the project is due.

Project Teams

I've posted your project teams and repository information here. Each member of your team should checkout your team repository at the start of the project. To minimize SVN conflicts, follow this routine with each editing session:

• update your local copy from SVN
• make a small number of edits to complete a single task
• update your local copy from SVN again, in case a teammate committed while you were working, and
• finally, commit your work back to your repository.

Using this cycle will minimize conflicts. If you get a conflict, get help from a member of the course staff to resolve it.

Remember to provide appropriate commit messages. We’ll be grading your proper use of SVN.

Milestones

To make sure that you are on-track to complete your project, you must meet the following milestones. Each milestone will contribute to your overall project grade. Each milestone must be done before the specified class session.

• Before Session 17 — Top Level Structure Diagram: A neatly drawn structure diagram showing the top-level functions that you plan to use in your program including a few formal parameters and return values. You should start thinking about the objects (dictionary types or instances of classes) you will need. This does not have to be your final design, just your initial plan.

  Consider the subsequent milestones in your design! In particular, the next milestone has specific requirements for top-level functions.

  The diagram can be hand-drawn or you may use a program to draw it. We strongly suggest that you draw your initial design on a whiteboard, first. Regardless of the way you choose to draw the diagram, you must turn in a single plain white 8½ × 11 inch sheet of paper showing your final design. This format is non-negotiable as we will be scanning the designs, and may share it with other teams.

• Before Session 18 — Program Allows Console-Only Play: To support testing and encourage separate development of your model and view, your game must initially support two human players using console-only game play (similar to Blackjack, but with human input for both players).

  You will be asked to demo this to your instructor or TA at the start of session 18.

  You must include the following two top-level functions (i.e., not inside a class, if you chose to use object-oriented design), printScore(game) and makeNewGame(numberOfPlayers). The printScore(game) function must print the state of the given game to the console. The makeNewGame(numberOfPlayers) function takes a number of players. It must return a game initialized to the given state. The game might be represented as a dictionary, an object of a custom class, or some combination. For example, to create a two player game we could call the function like this:

  g = makeNewGame(2)
  

  After creating that game, a call to printScore(g) would output something like:

  Player 1 score: 0
  Player 2 score: 0
  
  Player 1's turn.
  Turn score: 0
  

  Note that you have to design and implement some data structure (like a custom object, list, or dictionary) to track the game state. If you are using an object-oriented design, your makeNewGame() function will probably call a constructor and your printScore() function will probably call a method. Again, this is not a requirement—just a suggestion.

• Before Session 19 — Basic GUI Implemented: By the start of this session, your program should allow two human players to play a standard Game of Pig against each other using an entirely graphical interface. That is, they should not need to read or type in the console to play the game.

• Before Session 20 — Game Finished with Enhancements
• During Session 20 — Final Presentation in class

Grading

Project grades will be based on both individual and group results. We may grade each project milestone, plus the final project program and presentation. Grading will include both the proper functioning of your program and an evaluation of your design, coding style, documentation, teamwork, and proper use of SVN.

Each team will be responsible for presenting and demonstrating their work to the class.

Each team member will be required to complete an evaluation survey about his or her own performance and that of each of his or her teammates. We will use these surveys and our own observations to assign individual project grades.

About the Game of Pig

Rules

In its basic form, Pig is just a race between two players to reach 100 points. Players alternate turns. During a player's turn they repeatedly roll a single die, adding the value rolled to their turn total. At any point they may hold, adding their turn total to their game total. During a turn, if the player rolls a one, then they forfeit their turn total; however, their game total is always safe. Play passes to the other player after the first player holds or rolls a one.

Other Resources

The Wikipedia article on Pig is a good resource, as is the on-line version of Pig at Gettysburg College.

Suggestions

• Plan first! Use top-down design and possibly other design strategies (one example is object-oriented design). Get help early if you need it!
• You may want to follow the model-view approach that Zelle uses in section 12.3
• Chapter 10 of Zelle include some code for modeling a die.
• When designing your GUI, think about how your users will perceive your game. Try to make it as easy as possible for them to understand the rules.

Enhancements

Once you are done with the basic version, you should add some enhancements. A game with no enhancements will earn no better than a C grade. You will earn a higher grade for doing more challenging ones, and the more, the better, including extra credit. Be creative. What's cool and challenges you? Below are some ideas. Feel free to discuss other ideas with your instructor. Have fun with this!

• Animate rolling dice
• Allow more than two players
• Track game history, such as number of wins for each player
• Pig Races! Instead of showing the players' scores as numbers, show pigs racing down a track.
• Add a line chart that updates during the game showing how each player's score varies through the game
• Add sound effects using the winsound Python library

• Implement a computer player. Here are some ideas for doing that from Todd Neller:

  Let i be the player's score, j be the opponent's score, and k be the current turn total.

  • Hold at 25 or goal - Hold at the lesser of 25 and 100 - i.
  • 4 Scoring Turns - Let t be the number of turns in which a player has held so far. Hold at floor((100 - i)/(4 - t)).
  • Score Base, Keep Pace, and End Race - If i >= 69 or j >= 69, roll for the goal. Otherwise, hold at the greater of 19 and j - 14.
  • Keep Pace and End Race - If i >= 71 or j >= 71, roll for the goal. Otherwise, hold at 21 + round((j - i) / 8).

• Add game variants like these, again thanks to Todd Heller:

  • Two-Dice Pig - This variation is the same as Pig, except:
    • Two standard dice are rolled. If neither shows a 1, their sum is added to the turn total.
    • If a single 1 is rolled, the player scores nothing and the turn ends.
    • If two 1s are rolled, the player's entire score is lost, and the turn ends.
  • Big Pig - This variation is the same as Two-Dice Pig, except:
    • If two 1s are rolled, the player adds 25 to the turn total.
    • If other doubles are rolled, the player adds twice the value of the dice to the turn total.
  • Pass the Pigs® - This commercial game, originally called PigMania®, uses small rubber pigs as dice. Rolls are scored depending on whether pigs land on their feet, sides, backs, etc. in various combinations. Data for relative frequencies of these combinations are available from the statistical analysis External Links of the Pass the Pigs® Wikipedia article.
  • Hog - Hog is played as Pig where, at the beginning of a turn, the player decides how many dice to roll and rolls them all at once. If any 1s ("hogs") are rolled, there is no score for the turn. Otherwise, the sum of the dice are scored. In either case, it becomes the next player's turn.

Thanks to Todd Neller at Gettysburg College for his Nifty Assignment from SIGCSE 2010!