0.6 Parcheesi Assignment

Overview

Structured Game Data

Structured data repeats the same kinds of fields from record to record. UML class diagrams can describe that reusable structure, while object diagrams can show particular records and their current values.

You will first use a small Parcheesi high-score table as a concrete bridge between rows of structured data, classes, and objects. Then you will apply the same idea to the larger Parcheesi game model by creating a class diagram containing Game, Player, Piece, and Turn.

User Story

As a Parcheesi player, I want game information organized into consistent types and relationships so that the same structure can represent many games, players, pieces, and turns.

Acceptance Criteria

Task List

  1. Read a Structured High-Score Table
  2. Connect a Record to a Class
  3. Connect Rows to Object Instances
  4. Transfer the Pattern to the Game Model
  5. Plan the Four Classes
  6. Create the Parcheesi Class Diagram in Violet
  7. Compare Structured Data and UML
  8. Save, Submit, and Revise the Diagram
Structure Repeats

A spreadsheet row, an object instance, and a class definition are not the same thing. The useful connection is that repeated records often follow the same reusable structure.

  1. 1. Read a Structured High-Score Table

    Begin with a familiar structured-data form: a table in which every row uses the same columns.

    Step 1 — Read the five records

    PlayerNameWinsScore
    Mia12840
    Jamal10760
    Elena9710
    Noah8675
    Priya7630

    Step 2 — Identify records and fields

    1. Each row represents one record
    2. Each column represents a field that every record follows
    3. The values differ from row to row, but the field structure stays consistent
    What Repeats?

    The values do not repeat, but the shape of the information does: every record has PlayerName, Wins, and Score.

    Go to top

  2. 2. Connect a Record to a Class

    A class can describe the reusable structure shared by many records.

    Step 1 — Read the HighScore class

    UML class diagram containing HighScore with PlayerName string, Wins int, and Score int.
    The HighScore class describes the reusable field structure shared by the high-score records.

    Step 2 — Match each column to an attribute

    Table fieldClass attribute
    PlayerNamePlayerName : string
    WinsWins : int
    ScoreScore : int
    Class = Reusable Structure

    The class does not say Mia or 840 because those are particular values. It describes the kind and type of information a HighScore record can contain.

    Go to top

  3. 3. Connect Rows to Object Instances

    An object diagram can show a particular record using actual values from the table.

    Step 1 — Read one record as an object

    Object diagram showing score1 of type HighScore with PlayerName Mia, Wins 12, and Score 840.
    One table row can be represented as one particular HighScore object.

    Step 2 — Add collection context

    A parent object can represent the collection that contains the records.

    Object diagram showing highScoreTable of type HighScoreTable containing score1 and score2 HighScore objects. score1 has Mia, 12 wins, score 840. score2 has Jamal, 10 wins, score 760.
    A collection object can provide context for several record objects.

    Step 3 — Compare the three views

    • Table: many records in rows
    • Class diagram: reusable record structure
    • Object diagram: particular records and current values
    Do Not Confuse the Class With the Records

    The class is not another row in the table. The class describes the structure that many record objects can follow.

    Go to top

  4. 4. Transfer the Pattern to the Game Model

    The high-score example used one class to describe repeated records. The same abstraction idea can describe larger parts of the Parcheesi game.

    Step 1 — Read the first two classes

    Partial UML class diagram showing Game with GameId int and Player with PlayerId int and Name string. One Game has many Players.
    Start of the larger Parcheesi model: a Game can be associated with many Player instances.

    Step 2 — Read the two classes you will add

    Two separate UML classes shown as components: Piece with Number int and Turn with TurnNumber int.
    Two additional reusable types are needed: Piece and Turn.

    Step 3 — Identify the shift in scale

    The high-score example described one repeated record type. The game model uses several related types because a complete game contains different kinds of information.

    Go to top

  5. 5. Plan the Four Classes

    Use the following small specification. Do not add extra classes or attributes.

    Step 1 — Use these class definitions

    ClassRequired attributes
    GameGameId : int
    PlayerPlayerId : int
    Name : string
    PieceNumber : int
    TurnTurnNumber : int

    Step 2 — Use these relationships

    • Game has Player — one Game can have many Players
    • Player controls Piece — one Player controls four Pieces
    • Game records Turn — one Game can record many Turns
    • Player takes Turn — one Player can take many Turns
    Use Multiplicity to Avoid Repeating Boxes

    You do not draw four Piece classes or many Turn classes. One reusable class represents the type; multiplicity describes how many instances may participate in the relationship.

    Go to top

  6. 6. Create the Parcheesi Class Diagram in Violet

    This is the main diagram you will submit.

    Step 1 — Create the four classes

    1. Create Game with GameId : int
    2. Create Player with PlayerId : int and Name : string
    3. Create Piece with Number : int
    4. Create Turn with TurnNumber : int

    Step 2 — Use this partial model as a scaffold

    Partial Parcheesi class diagram containing Game, Player, Piece, and Turn. Game has many Players and Player controls four Pieces. The Turn relationships are intentionally missing.
    The scaffold includes the classes and two relationships. You must complete the Turn relationships.

    Step 3 — Add the remaining relationships

    1. Add Game records Turn
    2. Show multiplicity 1 at Game and * at Turn
    3. Add Player takes Turn
    4. Show multiplicity 1 at Player and * at Turn

    Check Your Work

    • Exactly four classes are present: Game, Player, Piece, Turn
    • Every required attribute and data type is present
    • Game → Player is labeled has with 1-to-many multiplicity
    • Player → Piece is labeled controls with 1-to-4 multiplicity
    • Game → Turn is labeled records with 1-to-many multiplicity
    • Player → Turn is labeled takes with 1-to-many multiplicity
    • No object values, high-score records, or extra classes appear in the submitted class diagram
    Go to top

  7. 7. Compare Structured Data and UML

    Step 1 — Compare what each representation emphasizes

    RepresentationMain emphasis
    Spreadsheet/tableRows of structured records and their field values
    Object diagramParticular instances, values, and object relationships
    UML class diagramReusable types, attributes, data types, relationships, and multiplicity
    ERDStructured-data entities, attributes, identifiers, and relationships

    Step 2 — State what your Parcheesi class diagram communicates

    Your finished diagram should communicate a reusable structure that could describe many different games. It should not depend on one player's current name, one current score, or one current turn value.

    Checkpoint Summary

    You connected repeated structured records to reusable class definitions, distinguished classes from object instances, and created a Parcheesi class model containing Game, Player, Piece, and Turn.

    Go to top

  8. 8. Save, Submit, and Revise the Diagram

    Use the same concise submission process you practiced in the earlier Parcheesi assignments.

    © 2026 Northcentral Technical College

    Go to top