Members:

Aguda, Andre Marc

Cantillion, Azien Syleux
Gudoy, John Vincent
Reyes, Johnnie
Umali, Emmanuelle

FLOWAGE: A TYCOON GAME FOR MANAGING WASTEWATER TEAMS

Project Life Cycle

Initiation Phase
Objective: Define project goals and gather requirements..
Key Activities:
Project Scope Definition: Establish high-level project objectives and scope, focusing on human resource
management, operations, and problem-solving mechanics.

Project Charter Development: Draft a project charter that outlines the game’s goals, objectives, and project
timeline.

Product Backlog:
Define the main theme (Sewage company management). Research manpower and operational challenges
in wastewater management. Establish user stories (e.g., hiring staff, managing crises, balancing budgets).
Responsibility:
Project Manager: Lead and approve the initiation phase.
Game Designer & Consultants: Collaborate with industry experts for realistic game scenarios.

Planning Phase
Objective: Develop a detailed project plan, finalize the game design, and establish the timeline and
resource allocation.

Key Activities:
Create a Work Breakdown Structure or WBS

Resource Allocation: Identify the team and tools needed for development, testing, and release.

Product Backlog:
Finalize the core gameplay mechanics.
Define detailed features like training programs and worker morale systems.
Create a game asset list (art, animations, audio).

Responsibility:
Project Manager: Create project schedule and assign roles.
Lead Designer: Define technical requirements and feasibility.

Execution Phase
Objective: Build the game based on the defined requirements, developing all features and core gameplay
elements.

Key Activities:
Game Development : Develop and implement core game mechanics. Asset creation and integration (art,
animation, sound). Initial bug fixing.

Alpha Testing : Release the first playable build. Internal playtesting and debugging.
Beta Build : Gather feedback from testers. Fix bugs and optimize performance.

Product Backlog:
Finalize hiring mechanics, including different job roles and skill sets.
Incorporate training programs for skill enhancement.

Responsibility:
Lead Developer & Development Team: Code and build the game.
Art and Design Team: Complete visual assets and UI design.
Quality Assurance Team: Begin initial testing for the alpha and beta builds.

Monitoring and Controlling Phase

Objective: Continuously monitor development progress, track deadlines, and ensure quality control
through testing.

Key Activities:
Weekly check-ins on project progress and backlog updates.

Testing : Internal playtests after alpha release. External playtests during beta. Identify and fix bugs,
glitches, and balancing issues.

Risk Management: Ensure any issues (technical, design, budget) are identified and mitigated quickly.

Feedback Integration: Adjust game mechanics based on tester feedback.

Final Testing and Polishing: Polish the game, ensuring all features are working as expected, and the user
experience is smooth.

Product Backlog:
Ongoing bug fixes and feature updates.
Polish art and UI elements.
Performance optimization for smooth gameplay.

Responsibility:
Project Manager: Track progress, conduct reviews.
Quality Assurance Lead: Oversee testing and bug tracking.
Development Team: Ensure timely fixes and feature updates.

Closing Phase
Objective: Finalize and release the game, followed by a project retrospective and post-launch support.
Key Activities:
Final Game Release : Distribute the game to players.
Post-Launch Support : Address any post-launch bugs or issues. Monitor user feedback and prepare for
possible updates or patches.
Documentation & Archiving : Store final project files, including GDD, code, and reports for future use or
updates.

Product Backlog:
Provide support for any post-launch issues.

Responsibility:
Project Manager: Conduct post-project review.
Development Team: Handle user queries and feedback post-launch.

1. Data Flow Diagram (DFD):

The DFD will model how data flows through the system in the game. Here’s an outline of the major entities
and processes:

High-Level DFD (Level 0):

● Entities:
○ Player: Inputs commands to manage resources, workers, and operations.
○ Game System: The backend system handles player commands, tracks game states, and
provides feedback to the player.
○ Database: Stores information about employees, tasks, system status, etc.

Processes:

● Recruit Workers: The player requests to hire new workers.

○ Data flows to the HR Database, which returns available workers.
○ Updated information on recruitment success or failure is reflected to the player.
● Assign Tasks: The player assigns tasks to available workers.
○ Data flows to the Operations Management Module, which updates task assignments.
● Manage Operations: The player monitors and adjusts ongoing tasks, including emergencies and
maintenance.
 ○ The game system sends updates to the Game Database, which stores task statuses.
○ Feedback, including system breakdowns and completion times, is sent back to the player.

Data Stores:

● HR Database: Stores employee data (skills, morale, status).

● Operations Database: Stores current task assignments, progress, and breakdowns.
● Game State Database: Stores game progress, player performance metrics, etc.

2. Context Flow Diagram

The CFD is simpler and highlights the interaction between the system and external entities (players).

Entities:

● Player: This is the main entity interacting with the game.

External System:

● Game Server: The backend system responsible for processing the player's inputs and updating the game
world.

Flows:
 1. Player Inputs: The player interacts with the game via a UI to hire workers, assign tasks, manage crises,
etc.
2. Game Server Processes: The server processes these inputs, updates the game state, and manages the
backend data.
3. Feedback Loop: The player receives feedback on their actions, including updates on employee morale,
task completion, and emergencies.

Database Interaction:

The Game Server interacts with internal databases (HR, Operations, Game State) to retrieve and update data as
needed.

3. Database Schema:

A relational database schema would manage game elements such as workers, tasks, crises, and
resources. Here’s a possible structure for the FLOWAGE game:

Tables:

1. Employee Table:
○ Employee_ID (Primary Key)
○ Name
○ Skill_Level
○ Morale
○ Assigned_Task_ID (Foreign Key to Task Table)
2. Task Table:
○ Task_ID (Primary Key)
○ Description (e.g., "Repair pipeline", "Handle overflow")
○ Assigned_Employee_ID (Foreign Key to Employee Table)
○ Status (Pending, In Progress, Completed)
○ Estimated_Completion_Time
3. Crisis Table:
○ Crisis_ID (Primary Key)
○ Description (e.g., "Storm causing overflow")
○ Severity_Level
○ Assigned_Workers_Count
○ Status (Active, Resolved)
4. Game_State Table:
○ Game_ID (Primary Key)
○ Player_Name
○ Financial_Health
○ System_Maintenance_Level
○ Overall_Score
5. Resource Table:
○ Resource_ID (Primary Key)
○ Resource_Type (e.g., "Pipeline", "Treatment Plant")
○ Status (Operational, Under Maintenance)
○ Location