Team Project -- Monopoly Game

Subject to Change (last modified September 6, 2016)

This is an iterative project. There will be four deliverables scheduled at various points in the semester. The deliverables correspond to assignments A2--A5.

Students will work on the project in teams of 4 (a couple of teams may have 5 members because of the nature of course enrollment).

1. Problem Statement: Monopoly Game

In this project you will develop a Monopoly Game implementation. For a quick intro to Monopoly, take a look at the article on Wikipedia.

1.1. Version 1

You will develop this version in A2, A3, and A4. A2 will involve the analysis of requirements for version 1 with the help of use case models. A3 involves the creation of a domain model that describes the concepts in the monopoly game. A4 involves implementation of the requirements for version 1 with a simple Graphical User Interface.

We don't expect you to implement the whole game in this version. We do expect you to implement the following items (please refer to the "Equipment" section on Wikipedia") :

  1. Deeds: You will implement the positions on the board for all of the twenty-two streets divided into eight color groups, four railroads, and two utilities, with all their ownership rules as described on wikipedia. You can create a CSU version or any fictitious version of your choice.

  2. Dice: A pair of normal six-sided dice.

  3. Houses and hotels: Choose simple displays (color icons will suffice).

  4. Money: Standard US currency as described.

  5. Tokens: Represent a player using an icon (your choice). At least two and up to four players can play.

The following items are not required.

  1. While there will be positions on the monopoly board for Chance and Community Chest, you do not need to implement the corresponding cards.

Follow the rules as described for taking turns, income tax, luxury tax, Jail (except for the go-to-jail card), Landing on properties, and mortgaging properties. There is no need to handle bankruptcies, house rules, etc. For simplicity, let us assume that there will be a configurable time limit in the game. When the time is up, the game will be over. The player with the most amount of cash and properties at that time is considered to be the winner.

1.2. Version 2

In version 2, you will choose to implement any two of the following three items:

  1. Implement the cards for Chance and Community Chest, including the "Go-To-Jail" and "Get Out of Jail Free" cards.
  2. Implement an AI player so that humans can play with the computer.
  3. Implement a distributed version of the game so that humans can play from remote sites on the same game. The server keeps track of the game state and also controls the player's turn.

2. Deliverables

The project will be submitted in stages. Submit an electronic copy of the deliverables at each stage. For A2 and A3, the deliverable will be a PDF document each. For A4, you will submit both a PDF document and code as a jar file. For A5, you will turn in code as a single jar file.

You must embed all the images (i.e. jpg, bmp, etc.) in the PDF file as your submission. Any tool specific model files will NOT be accepted. Do not submit images as separate files. Please make sure that you include your name on the front page of all submitted documents.

A2. Use Case Analysis

  • Due: Monday, September 19, 2016, 11:59 PM via Canvas assignment submission.
  • 20 points.
  • Tasks

    1. In your team meetings, flesh out the requirements listed under version 1 above. Identify the actor(s). Discuss scenarios involved during startup, playing the game, buying properties, selling properties, paying rent, etc, and come up with use cases. Think about alternative scenarios (e.g., what if I don't have enough cash on hand)? Use cases must cover all general kinds of end-to-end uses. Follow the format used in Larman's text when you write them up.

    2. Prepare a PDF document containing the following:
      1. Use case diagram showing the actors and the use cases. (5 points)
      2. All use cases in fully-dressed essential form. (15 points)

A3. Domain Modeling

  • Due: Tuesday, September 26, 2016, 11:59 PM via Canvas assignment submission.
  • 20 points.
  • Tasks
    1. Based on the use cases identified in the previous assignment, model the domain concepts and their relationships.
    2. Express a Domain Model as a UML class diagram. Follow the format used in the text. This is worth 15 points. The Domain Model should:
      • Be expressed at the problem domain level of abstraction; it should focus on the abstract concepts and not include design or implementation classes.
      • Include relevant and necessary associations and other links.
      • Attributes should be simple or "pure data elements" such as scalars. State that is complex should be represented as associations to concepts that represent the complex entity.
      • Do not include the direction (arrows) of the associations.
      • Include multiplicity if appropriate.
      • Use Generalization/Specialization (inheritance) sparingly, and only for true "is-a" relationships.
      • Do not include operations or methods in your conceptual model.
    3. Include a brief glossary that defines each concept. This is worth 5 points.
    4. The document should be in PDF format.
    5. Include the previous use case document after completing required updates. You may fix errors in them, but the previous documents will not be re-graded. The current document must be consistent with the previous document, i.e., your domain model must support the requirements and use cases that you listed or were asked to list in A2.

A4. Design and Implement Version 1

  • Due: Thursday, October 27, 2016, 11:59 PM via Canvas assignment submission.
  • 50 points.
  • Tasks
    1. Use Subversion/GitHub/any repository based version control system. for all types of documents (design diagrams, tests, implementation code).
    2. Prepare sequence diagrams as part of the design process. Submit three key/difficult/interesting ones.
    3. Prepare a design class diagram.
    4. Make a list of system test cases.
    5. Write JUnit test cases.
    6. Implement the system for version 1. You must use the GRASP patterns that you studied in the class. Use Swing or JavaFX for the user interface.
    7. Test your system.
  • Submission:
    1. Submit a document containing the following:
      1. Three sequence diagrams (9 points)
      2. Class diagram (5 points)
      3. System test cases (4 points)
      4. Commit log showing checkins, checkouts, etc from your repository based version control system (3 points). This log will help us determine a number of things, such as (1) level of individual participation, (2) adequate use of a version control system. If the document shows an inadequate amount of checkin and checkout, the team may lose points. If an individual has no corresponding entry in the log, this individual may lose a lot of points for not participating in the project (i.e., the penalty is not limited to the 3 points for submitting the commit log).
    2. Submit the following code in a single jar file (the test and implementation should be in separate Java packages). Note that the code must implement the design you provided above. Points will be deducted if it doesn't.
      1. JUnit test code (4 points)
      2. System implementation and document describing how to run the system (25 points). This is broken down as follows:
        • Features: 20 points
        • Design quality: 3 points
        • Programming style: 2 points

A5. Design and Implement Version 2

  • Due: Friday, November 18, 2015, 11:59 PM via Canvas assignment submission.
  • 60 points.
  • Tasks
    1. After A4 is graded, you must browse the wrapup message for assignment A4 on the main discussion board, where we will post some suggestions for core functionality and user interface.
    2. Refactor the code from iteration 1 to cleanly separate the user interface layer from the application and domain layers.
    3. Use design patterns (e.g., Facade, Strategy and so on).
  • Submit the following in a single jar file.
    1. System implementation Java source files. (56 points)
      You can name subpackages as you like: test, ui, view, model, core, etc., but all code and data files should reside under the package cs414.a5.groupname. and the source files must be in the folder hierarchy cs414/a5/groupname/.
      • Features: 40 points
      • Design quality: 10 points
      • Programming style: 4 points
    2. A text file named README, that 1) lists the external .jar file dependencies, if any, (database, user interface, logging, etc.), 2) shows how to run from command line, or eclipse run configurations 3) gives user names and passwords if necessary, and 4) discusses what is especially strong, weak, or missing from the assignment, 5) what patterns and refactorings were used. (4 points)
    3. Commit log (3 points). This log will help us determine a number of things, such as (1) level of individual participation, (2) adequate use of a version control system. If the document shows an inadequate amount of checkin and checkout, the team may lose points. If an individual has no corresponding entry in the log, this individual may lose a lot of points for not participating in the project (i.e., the penalty is not limited to the 3 points for submitting the commit log).