0.5 Parcheesi Assignment

Overview

An Online Turn

In earlier Parcheesi assignments, activity diagrams showed what happened during a process. In this assignment, you will add one important idea: who is responsible for each action.

You will model a very small online Parcheesi turn using two activity partitions, sometimes called swimlanes. One partition represents the player's browser/client. The other represents the game server. The finished diagram will show a request moving to the server and updated game information returning to the client.

Pictograph of a player browser on the left and a game server on the right connected across the Internet with lightning-bolt communication symbols
Web architecture for this assignment: the player's browser communicates with the game server across the Internet.

User Story

As an online Parcheesi player, I want my move to be sent to the game server and the updated board returned so that both sides of the game use the same game state.

Acceptance Criteria

Task List

  1. Identify the Client and Server
  2. Follow a Request and Response
  3. Read Activity Partitions
  4. Plan the Client Actions
  5. Plan the Server Actions
  6. Create the Online-Turn Diagram in Violet
  7. Trace Responsibility Across the Diagram
  8. Save, Submit, and Revise the Diagram
One Turn, Two Responsibilities

The goal is not to model networking in detail. The important question is: Which actions happen on the player's side, and which actions happen on the server's side?

  1. 1. Identify the Client and Server

    An online game involves more than one system. For this assignment, you only need two roles.

    Step 1 — Identify the player's side

    The player's browser/client is responsible for actions the player performs and for displaying information returned by the game server.

    • group roll the die, choose a pawn, and send the move request into one client request activity
    • group receive the updated board and display the updated board into one client response activity

    Step 2 — Identify the server's side

    The game server receives the move, applies the game rule, changes the shared game state, and returns the updated information.

    • group receive the move request, apply the game rule, update the game state, and return the updated board into one server activity
    What to Notice

    The client and server participate in the same turn, but they are responsible for different actions.

    Go to top

  2. 2. Follow a Request and Response

    Before adding partitions, review the basic flow of information.

    Step 1 — Read the process as one simple sequence

    Simple grouped activity flow with one client request-work box, one server-work box, and one client response-work box.
    The detailed actions are grouped into three responsibility phases.

    Step 2 — Identify the request

    1. The player chooses what to do
    2. The client sends a move request
    3. The request goes to the system responsible for processing the move

    Step 3 — Identify the response

    1. The server processes the request
    2. The server returns updated game information
    3. The client receives and displays the result
    A Sequence Alone Does Not Show Responsibility

    The diagram above tells you what happens in order, but it does not clearly show which system performs each action. Activity partitions solve that problem.

    Go to top

  3. 3. Read Activity Partitions

    An activity partition groups actions by the person or system responsible for them.

    Step 1 — Read a generic two-partition example

    Activity diagram with three stacked partition boxes: Client, Server, then Client again. Each partition contains one grouped multiline activity.
    Three stacked responsibility packages: Client request → Server work → Client response.

    Step 2 — Read each partition

    1. Actions inside Client belong to the client
    2. Actions inside Server belong to the server
    3. An arrow crossing into another partition shows that responsibility has moved

    Step 3 — Apply the idea to Parcheesi

    Parcheesi activity diagram with three stacked partition boxes. Player Browser or Client contains one grouped request activity, Game Server contains one grouped server activity, and Player Browser or Client contains one grouped response activity.
    One online turn shown as three stacked responsibility packages.
    Use Three Stacked Responsibility Boxes

    For this assignment, draw the flow as three sequential partition boxes: Player Browser / Client → Game Server → Player Browser / Client. Each partition contains one grouped activity describing that participant's work.

    Do Not Add Extra Systems

    You only need two partitions: Player Browser / Client and Game Server. Do not add Internet, database, router, cloud, or other partitions.

    Go to top

  4. 4. Plan the Client Actions

    Start with the actions that happen on the player's side.

    Step 1 — Read the client-only example

    Player Browser or Client partition with one grouped activity containing Roll the die, Choose a pawn, and Send move request.
    The client's request-side actions are kept together in one activity package.

    Step 2 — Group the client request work

    Use one activity box containing these lines:

    • Roll the die
    • Choose a pawn
    • Send move request

    Step 3 — Identify the handoff

    After Send move request, the flow must leave the client partition because the next action belongs to the server.

    The Partition Does Not Mean the Process Stops

    The activity flow continues across partitions. The change in partition only shows that responsibility has moved to another participant.

    Go to top

  5. 5. Plan the Server Actions

    Once the server receives the request, the server becomes responsible for the next part of the turn.

    Step 1 — Read the server-only example

    Game Server partition with one grouped activity containing Receive move request, Apply the game rule, Update game state, and Return updated board.
    The server's processing actions are kept together in one activity package.

    Step 2 — Group the server work

    Use one activity box containing these lines:

    • Receive move request
    • Apply the game rule
    • Update game state
    • Return updated board

    Step 3 — Identify the second handoff

    After Return updated board, the flow crosses back to the client. The client is responsible for receiving and displaying the returned information.

    Request → Processing → Response

    The client requests a move. The server processes it. The server returns updated information. The client displays it.

    Go to top

  6. 6. Create the Online-Turn Diagram in Violet

    Now combine the client and server responsibilities into one UML activity diagram.

    Step 1 — Create the two partitions

    1. Open Violet and create a new activity diagram
    2. Create one partition named Player Browser / Client
    3. Create one partition named Game Server

    Step 2 — Use this partial diagram as a starting scaffold

    Partial Parcheesi activity diagram with three stacked partition boxes: Player Browser or Client, Game Server, then Player Browser or Client. The server and response packages are left for the learner to complete.
    Use this three-box structure for your Violet diagram.

    Step 3 — Complete the grouped server activity

    In the single server activity box, include Receive move request, Apply the game rule, Update game state, and Return updated board.

    Step 4 — Complete the grouped client response activity

    Back in Player Browser / Client, use one activity box containing Receive updated board and Display updated board, then add a clear end node.

    Check Your Work

    • There are exactly two partitions
    • The client request actions are grouped into one client activity
    • The server actions are grouped into one server activity
    • The returned-board actions are grouped into one client response activity
    • The request crosses from client to server
    • The response crosses from server to client
    • The flow ends after the client displays the updated board
    • The diagram contains only the actions needed for one simple online turn
    Go to top

  7. 7. Trace Responsibility Across the Diagram

    Before submitting, follow your finished activity diagram from start to end and name the responsible system at each step.

    Step 1 — Trace the client-to-server handoff

    1. Begin in Player Browser / Client
    2. Follow the actions until Send move request
    3. Verify the next action is in Game Server

    Step 2 — Trace the server-to-client handoff

    1. Follow the server actions through Return updated board
    2. Verify the next action moves back to Player Browser / Client
    3. Verify the client receives and displays the updated board

    Step 3 — Explain what the partitions add

    Your diagram should make it possible to answer both questions:

    • What happens next?
    • Who is responsible for that action?
    Checkpoint Summary

    You modeled one online Parcheesi turn as a request and response shared between a client and server. The activity flow shows the sequence; the partitions show responsibility.

    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