MINOR PROJECT ON: CAR RACING

GAME DEVELOPMENT

Minor Project Submitted in Partial Fulfillment of the Requirements

for the degree of

Master of Computer Application

By:
Debopriyo Paul 13071023011

Kuyasha Mandal 13071023019

Varun Sinha 13071023051

Hrithik Bajpai 13071023054

Under the guidance of

Dr. Shiladitya Chowdhury

Techno Main Salt Lake

EM 4/ Salt Lake City, Sector V
KOLKATA – 700091
2023-25
 Maulana Abul Kalam Azad University of Technology

Techno Main Salt Lake

FACULTY OF MCA DEPARTMENT

Certificate of Recommendation

This is to certify that they have completed their Minor project (MCAN-381) work titled
“Minor project on: CAR RACING GAME DEVELOPMENT”, under the direct
supervision and guidance of Dr. Shiladitya Chowdhury. We are satisfied with his work,
which is being presented for the partial fulfillment of the degree of Master of Computer
Application (MCA), Maulana Abul Kalam Azad University of Technology, Kolkata–
700064.

Dr. Shiladitya Chowdhury

Assistant Professor, Dept. of MCA

Techno Main Salt Lake

Kolkata 700091

Dr. Shiladitya Chowdhury

HOD, Dept. of MCA

Techno Main Salt Lake

Kolkata 700091

I
 Maulana Abul Kalam Azad University of Technology

Techno Main Salt Lake

FACULTY OF MCA DEPARTMENT

Certificate of Approval *

The foregoing Minor project is hereby approved as a creditable study of Master of Computer
Application (MCA) and presented in a manner satisfactory to warrant its acceptance as a pre-
requisite to the degree for which it has been submitted. It is understood that by this approval
the undersigned do not necessarily endorse or any statement made, opinion expressed or
conclusion therein but approve this Minor project only for the purpose for which it is
submitted.

Signature of the examiners

Final Examination for Evaluation of the Project

* Only in case the Minor project is approved

II
 PREFACE

Goal of the Minor Project

The goal of this minor project is to develop a game as part of the Software Project (MCAN-381),
focusing on enhancing the understanding and application of the complete development cycle. This
includes improving skills in game development, graphics design, scripting, animation, and
adopting new technologies.

Additionally, the project aims to create a comprehensive product that extends beyond software
development to encompass essential game components such as environment design, story creation,
character development, gameplay mechanics, and artwork, ensuring an enjoyable and immersive
gaming experience. The success of the project will be measured by the quality of the resulting
game and its ability to integrate these diverse aspects effectively.

III
 Organization of the Minor Project

I. Project Planning and Requirement Analysis

• Define the scope and objectives of the game.

• Identify requirements for game design, including software tools, technologies, and
resources needed for development.
• Create a timeline and allocate tasks among team members.

II. Conceptualization and Game Design

• Develop the game concept, including the storyline, characters, gameplay mechanics, and
environment design.
• Create initial sketches or prototypes of characters, levels, and UI elements.
• Prepare a detailed Game Design Document (GDD) outlining all aspects of the game.

III. Development Phase

• Scripting and Programming: Implement the core functionality of the game, including
player mechanics, interactions, and AI behaviors.
• Graphics and Animation: Design and animate characters, backgrounds, and other visual
elements using appropriate tools.
• Technology Integration: Integrate new technologies or frameworks for enhanced
performance and features.

IV. Testing and Debugging

• Conduct functional and user testing to identify and resolve bugs.

• Ensure compatibility across different platforms, if applicable.
• Test the gameplay experience to refine the balance and enjoyment.

IV
 V. Content Creation and Integration

• Develop and integrate artwork, sound effects, and music into the game.
• Finalize the story and dialogues to enhance engagement.
• Optimize the environment and gameplay elements for consistency.

VI. Evaluation and Iteration

• Collect feedback from testers and stakeholders.

• Refine the game based on feedback to improve performance, aesthetics, and user
experience.

VII. Documentation and Finalization

• Document the development process, challenges faced, and solutions implemented.

• Finalize the project for presentation, ensuring all components work cohesively.

VIII. Presentation and Submission

• Present the completed game and demonstrate its features, storyline, and functionality.
• Submit the project along with necessary reports, design documents, and source code.

V
Table Information and Purpose
Here is a tabular representation of the organization and purpose of the minor project:

Stage Description Purpose

Define objectives, requirements, and To establish clear goals, allocate resources,

1. Planning
timeline. and ensure a structured development process.

To design the core structure and creative

Create game concepts, story, characters,
2. Design aspects of the game for an engaging
and gameplay mechanics.
experience.

3. Development Implement scripts, graphics, animations, To build the technical foundation and visual
and integrate technology. elements of the game.

To identify and fix bugs, ensuring

4. Testing Conduct debugging and gameplay functionality and an enjoyable user
testing.
experience.

5. Content Add final artwork, sound, story, and To enhance the game with cohesive aesthetics
Integration gameplay elements. and engaging narratives.

To improve the game based on user input and

6. Evaluation Gather feedback and make refinements.
ensure it meets quality standards.

7. Documentation
Record processes, challenges, and To maintain a clear record of development and
create user guides. provide guidance for future developers.

8. Presentation Showcase the final game and submit To demonstrate the project’s outcomes and
deliverables. highlight its features and achievements.

VI
Image Information and Purpose

Fig 1: Game mode Selection

Fig 2: Car Selection

VII
Fig 3: Game Starting

VIII
 ACKNOWLEDGMENT

I would like to express our sincere gratitude to everyone who contributed to the successful completion of
this project.

First and foremost, we thank our project guide Dr. Shiladitya Chowdhury, for his valuable guidance,
encouragement, and constructive feedback throughout the development process. This expertise and
mentorship have been instrumental in shaping this project.

I extend our thanks to the Techno Main Salt Lake and the faculty of the Department of MCA for providing
us with the resources and platform to work on this project as part of the Software Project MCAN-381.

I’m also grateful to my team mates for their support, ideas, and honest feedback, which helped refine and
improve the project.

Lastly, we acknowledge the contributions of various online resources, forums, and tools that provided
valuable insights and technical assistance, enabling us to overcome challenges and learn throughout this
journey.

This project is the result of collaborative effort, dedication, and a shared passion for learning and innovation.
Thank you to all who made this endeavor possible.

Signature of the student

IX
 CONTENTS

1. Scope of the Project ........................................................................................... 1

2. Concepts and Problem Analysis ......................................................................... 2
2.1 Cost Analysis & Time Analysis .............................................................4
2.2 Team Structure ...................................................................................... 7
2.3 Software Configuration Management ................................................... 8
2.4 Quality Assurance Plan ......................................................................... 9
2.5 Risk Management… ............................................................................. 12
3. Literature Survey… .......................................................................................... 14
4. Theoretical Background .................................................................................. 15
5. Software Requirement Specifications… ......................................................... 17
6. Design/Solution/Methodology… .................................................................... 20
6.1 Data Design.............................................................................................20
6.2 Architectural Design… ....................................................................... 20
6.3 Interface Design…...............................................................................20
6.4 Procedural Design...............................................................................21
7. Coding Standard Followed and Assumptions................................................. 22
8. Result Set Analysis.........................................................................................46
9. Testing................................................................................................................ 47
10. Future Scope of the Project ............................................................................48
11. Conclusion .........................................................................................................50
12. References and Bibliography ......................................................................... 51
13. Appendix ........................................................................................................ 52
13.1 Appendix-I ............................................................................................................52
13.2 Appendix-II ........................................................................................ 95
13.3 Appendix-III… .................................................................................. 104
13.4 Appendix-IV......................................................................................106
13.5 Appendix-V ....................................................................................... 111

X
1. Scope of the Project:

The scope of the car racing game development project involves creating an exciting and immersive
gaming experience that caters to a diverse audience, from casual gamers to competitive enthusiasts.
The game will feature a variety of gameplay modes, including single-player campaigns,
multiplayer racing (both online and offline), time trials, and competitive tournaments. Players will
have access to a wide range of vehicles, each with unique specifications such as speed, handling,
and acceleration, along with customization options for appearance and performance upgrades.

The game will include multiple tracks, each set-in diverse environment like urban streets, desert
dunes, mountain passes, and professional racing circuits, offering dynamic challenges such as
weather effects (rain, fog, or snow) and obstacles. Advanced physics engines will be used to create
realistic car dynamics, including drifting, acceleration, braking, and collision responses, enhancing
the sense of realism.

High-quality graphics and sound effects will complement the immersive gameplay, with dynamic
lighting, detailed textures, and environmental audio such as engine roars, tire squeals, and ambient
sounds. Social features like leaderboards, achievements, and the ability to share scores or invite
friends through social media integration will foster player engagement.

The development will target platforms such as PCs, consoles (e.g., PlayStation, Xbox), and mobile
devices, with a focus on optimization to ensure smooth performance across devices. The project
will utilize a robust game engine like Unity or Unreal Engine for development, employing
programming languages like C++ or C#. The development phases will include pre-production
planning, asset creation, gameplay mechanics coding, AI integration, thorough testing for bugs
and performance issues, and post-launch updates.

While the project will aim to deliver a high-quality game, it will operate within defined constraints
such as budget, available resources, and timeframes, ensuring a polished and functional product is
delivered on schedule.

1|Page
2. Concepts and Problem Analysis

Concepts for the Car Racing Game Development

1. Game Idea:
• Develop an immersive car racing game where players compete on diverse tracks, either against AI
opponents or other players, with customization options for vehicles and gameplay modes.

2. Gameplay Mechanics:
• Realistic physics for car movement (drifting, acceleration, collisions).
• Interactive environments with dynamic weather and track conditions.
• Power-ups and penalties for enhanced engagement.

3. Player Interaction:
• Multiplayer modes for online and local competition.
• Social media integration for sharing achievements and challenges.

4. Aesthetics:
• High-quality graphics with detailed cars and environments.
• Dynamic soundscapes including engine sounds, environmental noises, and background music.

Problem Analysis

1. Technical Challenges
• Physics Engine: Developing or integrating a physics system to simulate realistic car
behaviour, including handling and collisions.
• Performance Optimization: Ensuring the game runs smoothly on devices with varying
hardware capabilities.
• Graphics Rendering: Achieving visually appealing graphics while maintaining performance,

2|Page
 especially for mobile platforms.

2. Gameplay Design Issues

• Balance and Difficulty: Designing AI opponents and gameplay mechanics that are challenging
yet fair.
• Track Variety: Creating diverse and engaging tracks to keep players interested.
• Replicability: Providing content, such as unlockable vehicles, tracks, and achievements,
to encourage repeated play.

3. User Experience Concerns

• Intuitive Controls: Ensuring the game’s controls are responsive and easy to learn, especially
across different input methods (keyboard, gamepad, touch).
• Immersion: Maintaining player engagement with high-quality visuals, sound effects, and
smooth transitions between actions.

4. Resource Constraints
• Development Resources: Limited time, budget, and team expertise for building high-quality
assets and features.
• Platform Constraints: Adapting the game for multiple platforms with varying
performance capabilities.

5. Market Challenges
• Competition: Standing out in a crowded market of car racing games.
• Player Retention: Designing features that ensure long-term player engagement, such as
updates or seasonal content.

3|Page
2.1 Cost Analysis [use COCOMO model] and Time Analysis
The Constructive Cost Model (COCOMO) is a framework to estimate the cost, effort, and time
required for software development. We'll use the Basic COCOMO formula to calculate
the effort, development time, and team productivity based on the given inputs:
Inputs:

• Lines of Code (LOC) = 1328

• Team Strength = 4
• Time (T) = 4 months

Basic COCOMO Effort Formula:

Effort (Person-Months) =a⋅(KLOC)^b Where:
• KLOC=LOC/1000 (Thousands of Lines of Code)
• Constants a and b depend on the project type:
Organic: a = 2.4, b = 1.05 (small, simple projects)
Semi-Detached: a = 3.0, b = 1.12 (medium complexity)
Embedded: a = 3.6, b = 1.20 (highly complex)

Development Time:
Time (T)=c⋅(Effort)^d Where:
• Constants c and d also depend on the project type:
Organic: c = 2.5, d = 0.38
Semi-Detached: c = 2.5, d = 0.35
Embedded: c = 2.5, d = 0.32

Team Productivity:
Productivity=LOC/Effort
Let's compute for the Organic project type (suitable for small/simple projects like this one).
1. Convert LOC to KLOC:
KLOC=1328/1000=1.328

4|Page
2. Calculate Effort:
Effort=2.4⋅ (1.328) ^1.05
3. Calculate Time (Development Duration):

Time=2.5⋅(Effort)^0.38
4. Calculate Team Productivity:
Productivity=1328/Effort

Final Results:

Effort= 3.25 Person-Months

Time =3.43 Months
Productivity= 408.62 LOC/Person-Month

If the project timeline is 4 months, the team seems well within the required schedule. To estimate
the cost of the project, we need to consider the effort (in person-months), the cost per person-
month, and the number of people on the team.

Steps to calculate the cost:

1. Effort: We've already calculated the effort as 3.25 Person-Months.

2. Cost per Person-Month: This is typically the salary or rate per person per month. For this
calculation, we need an assumed value for the cost per person-month (e.g., the salary of each team
member).
The formula for cost is: Cost Effort x Cost per Person-Month x Team Size

If we assume the cost per person-month (say, for simplicity, let's assume it is $5000), and there are
4 team members, we can calculate the cost as
Cost =3.25 Person-Months x 5000 x 4 Let me
Compute that for you manually.
Cost =3.25 x 5000x4=65,000

5|Page
Final Cost:

Cost of the project= 65,000/-

This is the estimated cost based on the assumptions of 4 team members and a 5000/- cost per
person-month. If the cost per person-month or team size differs, you can adjust the calculation
accordingly.

6|Page
2.2 Team Structure

Each team member brings unique strengths, whether technical, creative, or managerial, ensuring
all aspects of the project are covered effectively.
With a team, tasks can be divided based on expertise, reducing individual workloads and
increasing productivity.

Fig 4: Team

7|Page
2.3 Software Configuration Management (SCM) for Car Racing
Game Development

SCM ensures systematic control of changes, version management, and integrity of the car racing
game throughout development. It involves:

1. Objectives:
• Manage source code, assets, and documentation changes.
• Enable collaboration, maintain version control, and automate builds.
• Ensure quality and stability across versions.

2. Processes:
• Configuration Identification: Track and version source code, assets, and documents.
• Control: Use branching strategies (main, feature, hotfix) and a change request system.
• Status Accounting: Log changes and generate progress reports.
• Audits: Periodic reviews to ensure compliance and quality.

3. Tools:
• Git (with GitHub/GitLab) for version control.
• Jenkins or GitHub Actions for automated builds.
• Jira or Trello for issue tracking and task management.

4. Best Practices:
• Define branching and committing policies.
• Automate builds and testing.
• Maintain backups and track release milestones.

SCM ensures collaboration, traceability, reduced errors, and efficient development, supporting
high-quality game delivery.

8|Page
 2.4 Quality Assurance (QA) Plan for the Car Racing Game

The QA plan for the Unity-based car racing game ensures the game meets defined
quality standards in terms of functionality, performance, user experience, and platform
compatibility.

1. Objectives

• Ensure the game is free from critical bugs and errors.

• Validate gameplay mechanics, physics, and AI behaviour.
• Test performance across target platforms (PC, consoles, mobile).
• Confirm the game meets user expectations in terms of graphics, sound, and controls.

2. QA Process

A. Test Planning
• Define testing goals, scope, and schedules.
• Identify required tools, resources, and test environments.
• Specify roles and responsibilities of the QA team.

B. Test Design

• Functional Testing:
o Verify core gameplay features (racing, collision mechanics, power-ups).
o Check UI/UX elements, menus, and settings.

• Performance Testing:
o Evaluate frame rates, load times, and memory usage.
o Stress-test multiplayer modes for latency and stability.

9|Page
• Compatibility Testing:
o Test on multiple devices, screen resolutions, and operating systems.

• Usability Testing:
o Ensure controls are intuitive and responsive.
o Assess user satisfaction with visual and audio elements.

• Regression Testing:
o Re-test previously fixed bugs to ensure new changes don’t introduce issues.

• Security Testing:
o Validate protection against unauthorized access in multiplayer modes.

• Localization Testing (if applicable):

o Check text and audio support for multiple languages.

C. Test Execution
• Execute planned test cases, logging all bugs and issues.
• Use test automation tools (e.g., Unity Test Framework, NUnit) for repetitive tasks like regression tests.

D. Bug Tracking and Reporting

• Document bugs using tools like Jira, Bugzilla, or Trello.
• Categorize bugs by severity (critical, major, minor) and assign them to developers.

E. Validation and Retesting

• Validate bug fixes through retesting.
• Ensure all acceptance criteria are met before release.

F. Final Acceptance Testing

• Conduct testing of the game in its production environment to confirm readiness for release.

10 | P a g e
3. Tools for QA

• Testing Tools: Unity Test Framework, NUnit, and Selenium (for UI testing).
• Performance Tools: Unity Profiler, FPS Monitor.
• Bug Tracking Tools: Jira, Trello, Bugzilla.
• Version Control: Git (to track bug fixes and updates).

4. QA Schedule

• Pre-Alpha: Initial functional testing of gameplay mechanics and assets.

• Alpha: Detailed testing of core features, performance, and early multiplayer modes.
• Beta: Broad testing by external testers for usability and compatibility issues.
• Release: Final acceptance testing and post-launch monitoring.

5. Key Metrics

• Bug severity and frequency.

• Average time to resolve bugs.
• Performance metrics (FPS, load times).
• Player satisfaction scores from usability tests.

6. Post-Release QA

• Monitor user feedback and crash reports.

• Release regular patches and updates to address issues and add improvements.

By following this QA plan, the car racing game can achieve a polished, bug-free, and enjoyable
experience for players while maintaining high quality across platforms.

11 | P a g e
2.5 Risk management plan

A. Development Risks

• Technical Complexity: Difficulty in implementing realistic physics, AI, or multiplayer

features.
• Performance Issues: Low frame rates or crashes on certain platforms.
• Tool/Software Issues: Bugs in Unity or other development tools.

B. Resource Risks

• Team Constraints: Lack of expertise or personnel turnover.

• Budget Overruns: Additional costs due to unplanned features or delays.
• Time Constraints: Inadequate time to complete testing or optimizations.

C. Operational Risks

• Data Loss: Accidental deletion or corruption of source files.

• Version Control Conflicts: Merge conflicts due to simultaneous changes by multiple
developers.
• Third-Party Dependencies: Issues with third-party libraries, plugins, or assets.

D. Market Risks

• Competitor Releases: Similar games launching around the same time.

• User Expectations: Failing to meet player demands for graphics, gameplay, or features.

12 | P a g e
E. Risk Assessment

Each risk is analysed based on:

• Likelihood: Probability of occurrence (Low, Medium, High).
• Impact: Effect on the project (Low, Medium, High).
• Priority: Combine likelihood and impact to determine the risk's urgency.

Risk Likelihood Impact Priority

Technical
High High Critical
Complexity
Performance Issues Medium High High
Budget Overruns Medium Medium Medium
Team Constraints Medium High High
Data Loss Low High High

13 | P a g e
3. Literature Survey

The literature survey for car racing game development focuses on analyzing existing games,
technologies, and methodologies to identify best practices and opportunities for innovation. Car
racing games have evolved significantly, from early arcade-style mechanics to modern titles
incorporating realistic physics, high-quality graphics, and immersive experiences. Studies
highlight the importance of gameplay mechanics, such as realistic vehicle dynamics, challenging
AI, and diverse tracks, in enhancing user engagement. Tools like Unity and Unreal Engine are
widely used for their flexibility and advanced features, while optimization techniques ensure
smooth performance across platforms. Research on multiplayer systems emphasizes low-latency
networking and effective matchmaking algorithms to maintain balanced and engaging gameplay.
Emerging trends such as procedural track generation, VR/AR integration, and cloud gaming are
shaping the future of the genre. Despite advancements, challenges like balancing realism with fun,
ensuring cross-platform compatibility, and sustaining user engagement remain. Addressing gaps
in AI innovation and sustainable asset creation will pave the way for developing a competitive and
immersive car racing game.

Fig 5: Bar Graph

14 | P a g e
4. Theoretical Background

Car racing games combine various elements of game design, physics, artificial intelligence (AI),
graphics, and user experience to create an engaging and immersive experience for players. At the
core of these games are the gameplay mechanics, which govern how players interact with the
game. These include vehicle control, such as steering, acceleration, and braking, as well as the
player’s interactions with the track and environment. Depending on the game's style, the design
can range from highly realistic simulations, where the physics of vehicle dynamics closely mimic
real-world behavior, to arcade-style games that prioritize fast-paced action and fun, often at the
cost of realism.

A significant aspect of car racing games is vehicle dynamics and physics, which are crucial for
creating a believable driving experience. In simulation-based games like Gran Turismo or Forza
Motorsport, advanced physics engines are used to replicate tire friction, aerodynamics, suspension
systems, and more. These games often simulate how vehicles behave in different conditions, such
as on wet or rough terrain, to provide an experience akin to real-world racing. On the other hand,
arcade-style games tend to simplify these elements, focusing more on speed and accessibility than
on precise vehicle handling.

The role of AI in car racing games is also pivotal, particularly when players race against computer-
controlled opponents. AI opponents use various decision-making algorithms to navigate the track,
respond to the player's actions, and present a competitive challenge. More advanced systems
employ behavior trees or machine learning techniques, allowing AI to adapt to player strategies
over time, creating a dynamic and engaging experience.

The graphics of car racing games have become increasingly important in enhancing player
immersion. High-quality textures, realistic vehicle models, and intricate track designs all
contribute to the visual appeal. Rendering techniques like ray tracing are used to simulate realistic
lighting, reflections, and shadows, particularly on car surfaces or wet tracks. Furthermore,
performance optimization is essential, ensuring smooth gameplay even in high-speed situations,
by utilizing techniques such as level-of-detail (LOD) rendering and other performance-enhancing
algorithms.

15 | P a g e
User experience plays a vital role in car racing games, especially in terms of control schemes and
feedback mechanisms. Most games offer multiple control options, from keyboard and mouse
setups to game controllers and specialized racing wheels. These controllers allow for varying
degrees of precision, which is important in both simulation and arcade-style games. Additionally,
many racing games integrate haptic feedback through controllers or racing wheels to simulate
sensations like road vibrations, engine rumblings, and collision impacts, enhancing immersion.
Virtual reality (VR) setups further elevate the experience by offering 360-degree views and even
more realistic feedback for players who seek a truly immersive experience.

The sound design is another key element, with realistic engine sounds, tire screeches, and
environmental noises contributing to the sense of speed and excitement. The sound dynamically
changes based on the player’s actions, such as the increase in engine noise as the car accelerates
or the high-pitched screech of tires when drifting. This auditory feedback adds depth to the player’s
experience, allowing them to better perceive their vehicle’s performance and the environment
around them.

Ultimately, car racing games are a fusion of several technologies and design principles, all working
together to offer players a compelling experience. The balance between realistic simulation and
engaging, fast-paced gameplay, alongside the continuous development of AI, physics, graphics,
and user feedback systems, ensures that car racing games remain a popular and evolving genre in
the gaming world. Through these complex systems, developers are able to create games that are
both fun and immersive, whether the goal is to experience real-world.

16 | P a g e
5. Software Requirement Specifications

The Software Requirements Specification (SRS) document outlines the functional and non-
functional requirements for a car racing game, defining what the game should do and how it
should behave. It serves as a guide for developers, testers, and stakeholders.

1. Introduction

Purpose: The SRS document provides a clear understanding of the game’s features,
functionalities, and behavior.
Scope: The game will be a racing simulation with single-player and multiplayer modes, offering
customizable vehicles, tracks, and difficulty levels.
Definitions: Terms like car models, tracks, AI, and multiplayer features will be defined.

2. System Overview

The car racing game will simulate car races with various vehicles and tracks. Players can
compete against AI opponents or other players in real-time. It will feature realistic car physics,
customizable cars, and multiple race modes.

3. Functional Requirements

3.1 Game Modes

Single-Player: Race against AI opponents.
Time Trial: Complete a track in the fastest time.
Career Mode: Unlock cars and tracks by progressing through levels.

3.2 Vehicle Control

Steering: Control the car with a controller or keyboard.
Acceleration/Braking: Accelerate and brake with assigned buttons.
Camera Views: Switch between different camera angles (first-person, third-person).

17 | P a g e
3.3 Tracks
Track Types: Roads, off-road, city streets.
Track Obstacles: Dynamic obstacles, weather changes, or traffic.
Unlockable Tracks: New tracks are unlocked as the player progresses.

3.4 AI Opponents
AI-controlled cars with different difficulty levels.

3.5 Physics Engine

Realistic car handling, including friction, acceleration, and collisions.

3.6 Multiplayer Features

Online Lobby: Create or join online races.
Matchmaking: Players are matched based on skill.

3.7 UI
Main menu, race information, car selection, and settings.

3.8 Car Customization

Players can upgrade and personalize cars.

4. Non-Functional Requirements

4.1 Performance
The game must run smoothly at 30 FPS for regular systems, 60 FPS for high-end systems.

4.2 Usability
Easy controls, various difficulty levels, and accessibility options.

18 | P a g e
4.3 Reliability
The game should recover from errors without losing progress.

4.4 Security
Protect player data and prevent cheating.

4.5 Compatibility
Initially for PC, with possible console support.

5. External Interface Requirements

Hardware Interfaces: Support for controllers, racing wheels, and VR.

Software Interfaces: Integration with Unity or Unreal Engine.
Communication Interfaces: Multiplayer races using the internet.

6. System Features

6.1 Audio
Engine sounds, tire screeches, environmental sounds.

6.2 Visuals
High-quality graphics, dynamic weather, and detailed car models.

7. Constraints

Development should be completed within 4 months and within a $65,000budget.

19 | P a g e
6. Design/Solution/Methodology

6.1 Data Design

Data design in game development is a crucial aspect of creating efficient, maintainable, and
scalable systems for your game. It involves structuring how data is stored, accessed, and
manipulated to support the mechanics, features, and gameplay you’re building. Below is an
overview of the key concepts and practices involved in data design for game development is in
Appendix-I.

6.2 Architectural Design

The architectural design outlines the major components and how they interact in the system. For
the car racing game, a layered architecture (also known as tiered architecture) is appropriate,
consisting of four main layers: presentation, logic, data, and infrastructure.

The UML diagram is shown in APPENDIX -II

6.3 Interface Design

The interfaces design defines the interaction between the player and the game system.

User Interface (UI) Design: The game should have a clean, intuitive user interface that allows
players to interact with the game easily.

Main Menu: Options to start the game, load saved progress, access settings, and view high
scores.

Race HUD: Displays essential race information such as lap times, current position, speed, and
mini-map.

Settings Menu: Allows players to adjust graphics, sound, controls, and difficulty settings.

20 | P a g e
6.4 Procedural Design

• Game Flow

Initialize Game: Load the main menu and settings.

Start Race: Load selected track and cars.

Initialize AI opponents.

Start the race countdown.

Begin race and update UI elements in real-time.

Monitor race progress (laps, times, position).

End race and display results.

• Key Procedures

Race Logic: A procedure for simulating each lap, updating the player’s position, and checking for
collisions or performance issues.

AI Behavior: Procedures to control the AI’s movement on the track using pathfinding algorithms,
adjusting based on the player’s position and speed.

Physics Updates: Procedures for updating the vehicle’s state each frame, including velocity,
acceleration, and collision detection.

• Event Handling

User Input: Handle user input from devices (keyboard, controller, racing wheel) to control the
car’s movements.

Collision Detection: Detect collisions with other cars, objects, or track boundaries, and adjust the
car’s position accordingly.

21 | P a g e
7. Coding Standard Followed and Assumptions

• [Link]

using [Link];

using [Link];

using UnityEngine;

public class CameraViewScript : MonoBehaviour

public Camera mainCamera;

public float viewDuration = 10f;

private bool isViewing;

private float timer;

private void Start()

{ // Disable the main camera initially

[Link] = false;

// Start the timer

timer = viewDuration;

isViewing = true;

private void Update()

if (isViewing)

{ // Update the timer

timer -= [Link];

22 | P a g e
 if (timer <= 0f)

{// Enable the main camera and start the game

[Link] = true;

isViewing = false;

Destroy(this);

}}

• [Link]

using [Link];

using [Link];

using UnityEngine;

using [Link];

using [Link];

public class CarSelection : MonoBehaviour

[Header("Buttons and Canvas")]

public Button nextButton;

public Button previousButton;

[Header("Cameras")]

public GameObject cam1;

public GameObject cam2;

[Header("Buttons and Canvas")]

public GameObject SelectionCanvas;

23 | P a g e
 public GameObject SkipButton;

public GameObject PlayButton;

public GameObject MapUI; // Reference to the MapUI object

private int currentCar;

private GameObject[] carList;

private void Awake()

[Link](false);

[Link](false);

[Link](false);

chooseCar(0);

private void Start()

currentCar = [Link]("CarSelected");

carList = new GameObject[[Link]];

for(int i = 0; i < [Link]; i++)

carList[i] = [Link](i).gameObject;

foreach (GameObject go in carList)

[Link](false);

if(carList[currentCar])

carList[currentCar].SetActive(true);

24 | P a g e
 private void chooseCar(int index)

[Link] = (currentCar !=0);

[Link] = (currentCar != [Link] - 1);

for(int i = 0; i < [Link]; i++)

[Link](i).[Link](i == index);

public void switchCar(int switchCars)

{ currentCar += switchCars;

chooseCar(currentCar);

} public void playGame()

[Link]("CarSelected", currentCar);

[Link](true); // Show the MapUI instead of loading the scene

[Link](false);

public void skipButton()

[Link](true);

[Link](true);

25 | P a g e
 [Link](false);

[Link](false);

[Link](true); }}

• [Link]

using [Link];

using [Link];

using UnityEngine;

using [Link];

using [Link];

public class CarSelection : MonoBehaviour

[Header("Buttons and Canvas")]

public Button nextButton;

public Button previousButton;

[Header("Cameras")]

public GameObject cam1;

public GameObject cam2;

[Header("Buttons and Canvas")]

public GameObject SelectionCanvas;

public GameObject SkipButton;

public GameObject PlayButton;

public GameObject MapUI; // Reference to the MapUI object

private int currentCar;

private GameObject[] carList;

26 | P a g e
 private void Awake()

[Link](false);

[Link](false);

[Link](false);

chooseCar(0);

private void Start()

currentCar = [Link]("CarSelected");

carList = new GameObject[[Link]];

for(int i = 0; i < [Link]; i++)

carList[i] = [Link](i).gameObject;

foreach (GameObject go in carList)

[Link](false);

if(carList[currentCar])

carList[currentCar].SetActive(true);

private void chooseCar(int index)

[Link] = (currentCar !=0);

[Link] = (currentCar != [Link] - 1);

for(int i = 0; i < [Link]; i++)

27 | P a g e
 {

[Link](i).[Link](i == index);

public void switchCar(int switchCars)

currentCar += switchCars;

chooseCar(currentCar);

} public void playGame()

{ [Link]("CarSelected", currentCar);

[Link](true); // Show the MapUI instead of loading the scene

[Link](false);

} public void skipButton()

{ [Link](true);

[Link](true);

[Link](false);

[Link](false);

[Link](true);

• [Link]

using [Link];

using [Link];

using UnityEngine;

28 | P a g e
using [Link];

public class Menu : MonoBehaviour

[Header("All Menu's")]

public GameObject pauseMenuUI;

public GameObject Speedometer;

public static bool GameIsStopped = false;

public void Resume()

[Link](false);

[Link](true);

[Link] = 1f;

GameIsStopped = false;

public void Pause()

[Link](true);

[Link](false);

[Link] = 0f;

GameIsStopped = true;

public void Day()

[Link]("scene_day");

29 | P a g e
 [Link] = 1f;

public void LoadMenu()

[Link]("Garage");

[Link] = 1f;

public void QuitGame()

[Link]("Quitting Game...");

[Link]();

public void night()

[Link]("scene_night");

[Link] = 1f;

public void Rainy()

[Link]("scene_overcast");

[Link] = 1f;

30 | P a g e
 public void Restartday()

[Link]("scene_day");

[Link] = 1f;

public void Restartnight()

[Link]("scene_night");

[Link] = 1f;

public void Resatartraining()

[Link]("scene_overcast");

[Link] = 1f;

• [Link]

using [Link];

using [Link];

using UnityEngine;

public class OpponentCar : MonoBehaviour

[Header("Car Engine")]

public float movingSpeed;

31 | P a g e
 public float turningSpeed = 50f;

public float breakSpeed = 12f;

[Header("Destination Var")]

public Vector3 destination;

public bool destinationReached;

private void Update()

{ Drive();

public void Drive()

if ([Link] != destination)

{ Vector3 destinationDirection = destination - [Link];

destinationDirection.y = 0;

float destinationDistance = [Link];

if (destinationDistance >= breakSpeed)

{ destinationReached = false;

Quaternion targetRotation = [Link](destinationDirection);

[Link] = [Link]([Link], targetRotation,

turningSpeed * [Link]);

[Link]([Link] * movingSpeed * [Link]);

} else

{ destinationReached = true;

} }}

public void LocateDestination(Vector3 destination)

32 | P a g e
 { [Link] = destination;

destinationReached = false; }}

• [Link]

using [Link];

using [Link];

using UnityEngine;

public class OpponentCarWaypoints : MonoBehaviour

[Header("Opponent Car")]

public OpponentCar opponentCar;

public Waypoint currentWayPoint;

private void Awake()

opponentCar = GetComponent<OpponentCar>();

private void Start()

[Link]([Link]());

private void Update()

33 | P a g e
 {

if([Link])

currentWayPoint = [Link];

[Link]([Link]());

• [Link]

using [Link];

using [Link];

using UnityEngine;

public class PlayerCarController : MonoBehaviour

[Header("Wheels collider")]

public WheelCollider frontLeftWheelCollider;

public WheelCollider frontRightWheelCollider;

public WheelCollider backLeftWheelCollider;

public WheelCollider backRightWheelCollider;

[Header("Wheels Transform")]

public Transform frontLeftWheelTransform;

public Transform frontRightWheelTransform;

public Transform backLeftWheelTransform;

public Transform backRightWheelTransform;

34 | P a g e
 [Header("Car Engine")]

public float accelerationForce = 300f;

public float maxSpeed = 100f;

public float brakingForce = 5000f;

private float presentAcceleration = 0f;

[Header("Car Steering")]

public float maxSteerAngle = 40f;

public float steerSpeed = 10f;

private float presentSteerAngle = 0f;

[Header("Car Sounds")]

public AudioSource audioSource;

public AudioClip accelerationSound;

public AudioClip slowAccelerationSound;

public AudioClip stopSound;

public AudioClip brakeSound; // New brake sound clip

private bool isDrifting = false;

private float driftAngle = 40f;

private void Update()

MoveCar();

CarSteering();

ApplyBrakes();

private void MoveCar()

35 | P a g e
 {

float verticalInput = [Link]("Vertical");

presentAcceleration = verticalInput * accelerationForce;

if (presentAcceleration > 0)

if (![Link] || [Link] != accelerationSound)

[Link]();

[Link] = accelerationSound;

[Link]();

else if (presentAcceleration < 0)

if (![Link] || [Link] != slowAccelerationSound)

[Link]();

[Link] = slowAccelerationSound;

[Link]();

} }

else

if (![Link] || [Link] != stopSound)

36 | P a g e
 [Link]();

[Link] = stopSound;

[Link]();

[Link] = presentAcceleration;

[Link] = presentAcceleration;

[Link] = presentAcceleration;

[Link] = presentAcceleration;

if (GetComponent<Rigidbody>().[Link] > maxSpeed)

GetComponent<Rigidbody>().velocity =
GetComponent<Rigidbody>().[Link] * maxSpeed;

private void CarSteering()

float horizontalInput = [Link]("Horizontal");

presentSteerAngle = horizontalInput * maxSteerAngle;

// Apply additional steer angle during drifting

if (isDrifting)

[Link] = [Link]([Link],

37 | P a g e
presentSteerAngle + driftAngle, [Link] * steerSpeed);

[Link] = [Link]([Link],
presentSteerAngle - driftAngle, [Link] * steerSpeed);

else

// Apply regular steering

[Link] = [Link]([Link],
presentSteerAngle, [Link] * steerSpeed);

[Link] = [Link]([Link],
presentSteerAngle, [Link] * steerSpeed);

SteeringWheels(frontLeftWheelCollider, frontLeftWheelTransform);

SteeringWheels(frontRightWheelCollider, frontRightWheelTransform);

SteeringWheels(backLeftWheelCollider, backLeftWheelTransform);

SteeringWheels(backRightWheelCollider, backRightWheelTransform);

private void SteeringWheels(WheelCollider WC, Transform WT)

Vector3 position;

Quaternion rotation;

[Link](out position, out rotation);

[Link] = position;

[Link] = rotation;

}private void ApplyBrakes()

38 | P a g e
 { if ([Link]([Link]))

{ [Link] = brakingForce;

[Link] = brakingForce;

[Link] = brakingForce;

[Link] = brakingForce;

if (![Link] || [Link] != brakeSound)

[Link]();

[Link] = brakeSound;

[Link]();

// Check for shift key press to toggle drifting

if ([Link]([Link]) || [Link]([Link]))

{ isDrifting = !isDrifting;

} }

else

[Link] = 0f;

[Link] = 0f;

[Link] = 0f;

[Link] = 0f; // Stop brake sound when brakes are

released

if ([Link] && [Link] == brakeSound)

{ [Link](); }

39 | P a g e
 }}}

• [Link]

using UnityEngine;

public class SkipButton : MonoBehaviour

public AudioSource audioSource;

private void Start()

// Get the AudioSource component attached to the same GameObject

audioSource = GetComponent<AudioSource>();

public void OnSkipButtonClick()

// Play the sound effect

[Link]();

• [Link]

using [Link];

using [Link];

40 | P a g e
using UnityEngine;

using [Link];

public class Speedometer : MonoBehaviour

public Rigidbody[] targets; // Array of Rigidbody targets

public float maxSpeed = 0.0f; // The maximum speed of the targets ** IN KM/H **

public float minSpeedArrowAngle;

public float maxSpeedArrowAngle;

[Header("UI")]

public Text speedLabel; // The label that displays the speed;

public RectTransform arrow; // The arrow in the speedometer

private float speed = 0.0f;

private void Update()

// Calculate the maximum speed among all targets

float maxTargetSpeed = 0.0f;

foreach (Rigidbody target in targets)

{ float targetSpeed = [Link] * 3.6f;

if (targetSpeed > maxTargetSpeed)

maxTargetSpeed = targetSpeed;

} // Use the maximum speed as the current speed

speed = maxTargetSpeed;

if (speedLabel != null)

41 | P a g e
 [Link] = ((int)speed) + " km/h";

if (arrow != null)

[Link] =

new Vector3(0, 0, [Link](minSpeedArrowAngle, maxSpeedArrowAngle, speed /

maxSpeed));

}}

• [Link]

using [Link];

using [Link];

using UnityEngine;

using [Link];

public class Timer : MonoBehaviour

[Header("Timer")]

public float countDownTimer = 5f;

[Header("Things to stop")]

public PlayerCarController playerCarController;

public PlayerCarController playerCarController1;

public PlayerCarController playerCarController2;

public OpponentCar opponentCar;

public OpponentCar opponentCar1;

public OpponentCar opponentCar2;

public OpponentCar opponentCar3;

public OpponentCar opponentCar4;

42 | P a g e
 public Text countDownText;

// Start is called before the first frame update

void Start()

StartCoroutine(TimeCount());

// Update is called once per frame

void Update()

if (countDownTimer > 1)

[Link] = 0f;

[Link] = 0f;

[Link] = 0f;

[Link] = 0f;

[Link] = 0f;

[Link] = 0f;

[Link] = 0f;

[Link] = 0f;

else if (countDownTimer == 0)

[Link] = 300f;

[Link] = 300f;

43 | P a g e
 [Link] = 300f;

[Link] = 12f;

[Link] = 13f;

[Link] = 14f;

[Link] = 9f;

[Link] = 8f;

IEnumerator TimeCount()

while (countDownTimer > 0)

[Link] = [Link]();

yield return new WaitForSeconds(1f);

countDownTimer--;

[Link] = "60";

yield return new WaitForSeconds(1f);

[Link](false);

44 | P a g e
• [Link]

using [Link];

using [Link];

using UnityEngine;

public class Waypoint : MonoBehaviour

[Header("Waypoint Status")]

public Waypoint previousWaypoint;

public Waypoint nextWaypoint;

[Range(0f, 5f)]

public float waypointWidth = 1f;

public Vector3 GetPosition()

Vector3 minBound = [Link] + [Link] * waypointWidth / 2f;

Vector3 maxBound = [Link] - [Link] * waypointWidth / 2f;

return [Link](minBound, maxBound, [Link](0f, 1f));

45 | P a g e
8. Result Set Analysis

Player Win

Fig 6: Player Win

Player Loss

Fig 7: Player Loss

46 | P a g e
9. Testing

Testing is an essential phase in car racing game development to ensure that all features and
functionalities work as intended. It involves several types of testing, including unit testing,
integration testing, functional testing, performance testing, usability testing, compatibility
testing, and regression testing. Unit testing focuses on testing individual components, such as car
movement, AI behavior, and collision detection. Integration testing checks the interaction
between components, such as the game engine and physics. Functional testing verifies the
game’s core features, including menus, game modes, and car customization. Performance testing
ensures the game runs smoothly across different hardware configurations and meets frame rate
requirements. Usability testing assesses the player experience, ensuring intuitive controls and an
accessible UI. Compatibility testing ensures the game works on various platforms and input
devices. Regression testing ensures that new updates or fixes don’t break existing features. Test
cases and scenarios are created for each function, such as verifying car movement and
multiplayer connectivity. Tools like Unity Test Framework, Selenium, and performance profilers
are used for automated and manual testing. Testing occurs in phases, starting with alpha testing
by the development team, followed by beta testing with external players to gather valuable
feedback. This structured approach ensures the game meets high standards of quality, usability,
and performance. Explained in APPENDIX – V

47 | P a g e
10. Future Scope of the Project

1. Virtual Reality (VR) and Augmented Reality (AR) Integration

• Implement VR and AR features to create an immersive, lifelike racing experience for

players.

2. Cross-Platform Compatibility

• Enable players to race together across different platforms, such as PC, consoles, and mobile
devices.

3. Enhanced AI Capabilities

• Improve AI opponents with advanced behaviour, making them more challenging and
dynamic during races.

4. Dynamic Weather and Track Conditions

• Introduce changing weather patterns and track conditions (e.g., rain, fog, snow) that affect
car performance and strategy.

5. Multiplayer Features

• Implement online leaderboards, competitive multiplayer modes, and eSports integration to

build a racing community.

48 | P a g e
 6. AI-Driven Car Customization

• Allow the game’s AI to suggest or create personalized car upgrades based on player
performance or preferences.

7. Procedural Track Generation

• Develop algorithms to generate unique tracks for each race, offering endless variety and
replay ability.

8. Story-Driven Career Mode

• Create a narrative-driven career mode where players progress through a storyline,

unlocking new tracks, cars, and challenges.

9. Open-World Racing Environments

• Expand the game into an open-world environment where players can explore freely before
racing, adding more depth and realism.

10. Enhanced Graphics and Physics

• Continuously upgrade the graphics engine and physics simulation to stay at the cutting edge
of realism, offering players a visually stunning experience.

49 | P a g e
11. Conclusion
In conclusion, the development of the car racing game represents a comprehensive and
multifaceted project that merges advanced game mechanics, user engagement strategies, and
realistic simulation techniques. By meticulously designing key features such as car physics, AI-
driven opponents, diverse track environments, and an intuitive user interface, the game aims to
deliver a highly immersive and competitive racing experience. The integration of multiplayer
capabilities and customizable gameplay ensures broad appeal, catering to both casual players and
those seeking a more strategic, skill-based environment. Looking forward, the scope for
enhancement is substantial, with opportunities to incorporate cutting-edge technologies such as
virtual reality (VR), augmented reality (AR), dynamic weather systems, and cross-platform play,
further enriching player interaction. Additionally, procedural track generation, AI-based car
customization, and expanded career modes are key areas for future development. These
innovations will position the game for long-term success, ensuring it remains relevant in a
rapidly evolving gaming landscape. Ultimately, the project is designed to not only meet but
exceed player expectations, fostering an engaging, competitive, and continuously evolving
gaming experience.

50 | P a g e
12. References/Bibliography

1) The Little Book of C# Programming: Learn to Program C-Sharp For Beginners

(Little Programming Books) by Huw Collingbroune

2) Learning C# Programming with Unity 3D second edition by Alex Okita

3) Unity 3D Game Development: Designed for passionate game developers—Engineered

to build professional games by Anthony Davis

51 | P a g e
 APPENDIX - I

ABSTRACT

[Link]:

1.1. Purpose of Game Development as a Project:

A. Developer’s Aspects:

Skill Development:

Enhance technical skills in programming, animation, graphics design, and integration of

new technologies.
Foster creative thinking, problem-solving, and teamwork.

Application of Knowledge:

Provide hands-on experience in applying software engineering concepts like development

cycles, debugging, and testing.
Bridge theoretical learning with real-world implementation.

Innovation and Creativity:

Encourage innovation in gameplay mechanics, storytelling, and user experience.

Explore new technologies and tools to push boundaries in game development.

Portfolio Building:

Offer a tangible project to showcase skills and creativity to future employers or

52 | P a g e
collaborators.

B. Social Aspects:

Entertainment and Engagement:

Games provide entertainment, stress relief, and mental stimulation to users of all ages.
They foster social interaction through multiplayer modes and online communities.

Educational Value:

Games can be used as educational tools to teach concepts in science, math, history, and
more through gamified learning.
They improve cognitive skills like decision-making, strategic thinking, and hand-eye
coordination.

Awareness and Advocacy:

Games can raise awareness about societal issues, including mental health, environmental
conservation, and cultural diversity.
Interactive storytelling can inspire empathy and understanding of different perspectives.

Economic Contribution:

The gaming industry contributes significantly to the economy by generating jobs and
promoting technological advancements.

Innovation in Technology:

Game development often leads to breakthroughs in graphics, AI, and interactive

technologies, influencing other industries like healthcare and education.

53 | P a g e
By combining technical excellence with societal benefits, game development projects
contribute meaningfully to both personal growth and community engagement.

1.2. Scope:

In the fast-growing field of software engineering and development and even more rapidly
growing sector of game development the future is hard to predict. We are working with
this game as our software project, part of our degree we choose this type of work for doing
better with development cycle, development period, graphics, scripting, adopting new
technology, animation.
In general software project is a project focusing on the creation of software. Consequently,
Success can be measured by taking a look at the resulting software.
In a game project, the product is a game. But and here comes the point: A game is much
more than just its software. It has to provide content to become enjoyable. Just like a web
server: without content the server is useless, and the quality cannot be measured. This has
an Important effect on the game project as a whole. The software part of the project is not
the only one, and it must be considered in connection to all other parts: The environment of
the game, the story, characters, game plays, the artwork, and so on.

1.3 Definitions, Acronyms, Abbreviations:

Definitions

• Game Engine: A software framework designed for the creation and development of
video games. Example: Unity, Unreal Engine.
• Gameplay: The specific way in which players interact with a game, including rules,
challenges, and rewards.
• AI (Artificial Intelligence): Algorithms that enable non-player characters (NPCs) to act
intelligently and dynamically during the game.
• Assets: Pre-designed or created elements, such as graphics, sound effects, or

54 | P a g e
 animations, used in the game.
• HUD (Heads-Up Display): On-screen interface elements like speedometers, maps, and
scores that provide information to the player.
• Physics Engine: A module of the game engine that simulates real-world physics like
gravity, collision, and vehicle dynamics.
• Rendering: The process of generating a visual representation of the game’s scenes in
real-time.

Acronyms

• AI: Artificial Intelligence

• NPC: Non-Player Character
• HUD: Heads-Up Display
• FPS: Frames Per Second (rate at which images are rendered per second)
o SDK: Software Development Kit
o UI/UX: User Interface/User Experience

Abbreviations

• RNG: Random Number Generator (used for procedural elements or randomness in

games).
• VFX: Visual Effects
• LOD: Level of Detail (optimizing the graphics quality based on the distance to the
camera).
• FPS (Gameplay): First-Person Shooter (not relevant if it’s strictly a car racing game,
but used for hybrid or action-racing types).

1.4. Reference:

A. Forza Horizon 5 is a 2021 racing video game developed by Playground Games and
published by Xbox Game Studios. It is the fifth Forza Horizon title and twelfth main

55 | P a g e
 instalment in the Forza series.
B. Need for Speed Heat is a 2019 racing video game developed by Ghost Games and
published by Electronic Arts for PlayStation 4, Windows, and Xbox One.
C. Asphalt 8 Airborne is a 2013 racing video game developed by Gameloft Barcelona and
published by Gameloft. It is the tenth major game of the Asphalt series.

1.5 Developers’ responsibility overview

A. Project Manager / Lead Developer (Kuyasha Mandal)

Responsibilities:

• Oversee the entire development process, ensuring that the project stays on schedule and
meets milestones.
• Coordinate between team members, ensuring smooth communication and
collaboration.
• Define project scope, objectives, and requirements, aligning with stakeholders.
• Manage risk, resolve issues, and make decisions regarding game mechanics, design,
and technology.
• Ensure that the project follows the game development cycle, from conceptualization to
final release.
• Lead playtesting, gather feedback, and drive improvements.

B. Game Developer / Programmer (Hrithik Bajpai)

Responsibilities:

• Develop the core game mechanics and functionality (e.g., player controls, physics
engine, AI).
• Code the car behavior, handling dynamics, collision detection, and in-game physics.
• Implement AI for enemy cars, traffic, and non-player characters.

56 | P a g e
• Integrate game engine features, ensuring that everything functions smoothly in real-
time.
• Debug and optimize code for performance and efficiency.
• Work with the UI/UX designer to integrate user interface elements like score,
speedometer, and lap timers.

C. Game Designer / Level Designer (Debopriyo Paul)

Responsibilities:

• Create the game’s concept, including storylines, race types, and level design (e.g.,
tracks, environments).
• Design challenges, objectives, and progression systems for the player.
• Develop maps, locations, and checkpoints for racing tracks and environments.
• Focus on balancing difficulty levels and ensuring the gameplay is both challenging and
enjoyable.
• Collaborate with other team members to integrate assets (e.g., 3D models, textures) and
ensure consistency with game design.
• Conduct playtests to refine the game flow, adjust level difficulty, and improve user
experience.

D. Artist / Graphic Designer(Varun Sinha)

Responsibilities:

• Design and create visual assets for the game, including car models, tracks,
environments, and other in-game objects.
• Create 2D and 3D assets such as textures, lighting, and backgrounds that match the
game’s aesthetic.
• Develop and implement visual effects (VFX) to enhance gameplay, such as explosions,
dust trails, and weather effects.

57 | P a g e
• Design the user interface (UI) elements such as buttons, menus, and HUD components.
• Work closely with the game programmer to integrate graphics into the game engine.
• Ensure that the art aligns with the overall theme and style of the game.

2. General Description

2.1. Product Function overview

In game development, a Product Function Overview provides a comprehensive breakdown of the

core functions and features that a game offers, from a gameplay and technical perspective. It
defines the main purpose of the game and the functionality it needs to fulfill the design goals,
providing clarity to developers, designers, and stakeholders. Here’s an overview of key product
functions that might be included in a game development project.

A. Gameplay Mechanics

Core Gameplay Loop: The central gameplay activity that players will engage in repeatedly
throughout the game, such as shooting enemies, solving puzzles, or exploring the world.
Player Controls: The input mechanisms that allow players to interact with the game (e.g.,
keyboard, mouse, gamepad, touch controls).
Progression: How the player advances through the game, including levels, skills, items, or story
progression.
Difficulty Scaling: A system that adjusts the challenge level based on player progress or skill,
ensuring the game is neither too easy nor too difficult.
Rewards System: How players are rewarded for completing tasks, defeating enemies, or
achieving goals, including points, achievements, or in-game currency.

B. Player Interaction

Multiplayer Functionality: Features allowing players to interact with one another, such as
cooperative play, competitive modes, matchmaking, and online leaderboards.

58 | P a g e
AI Interaction: Non-player characters (NPCs) that respond intelligently to the player's actions,
whether as enemies, allies, or bystanders.
Social Features: Integration with social platforms (like Facebook or Twitter), player profiles, or
in-game messaging.
Chat and Communication: Systems for players to communicate, such as voice chat, text chat, or
emotes in multiplayer games.

C. User Interface (UI) and User Experience (UX)

HUD (Heads-Up Display): Displays that show the player’s current status (e.g., health, ammo,
score).
Menus and Navigation: The main and in-game menus, including options for starting a new game,
loading a game, and adjusting settings.
Inventory System: A system for managing the player's collected items, weapons, equipment, or
abilities.
Feedback and Notifications: Visual, auditory, or haptic feedback to inform players of actions like
achievements, level-ups, or item pickups.
Tutorials and Onboarding: Systems to guide new players through the game mechanics, including
pop-up instructions, tooltips, or short interactive tutorials.

D. Game World Design

Environment and Level Design: The creation of game worlds, including landscapes, structures,
and points of interest. It may include open-world, linear, or procedurally generated
environments.
Day/Night Cycle and Weather: Dynamic systems that affect the environment, such as realistic
time-of-day systems or weather effects like rain or fog.
World Interaction: How the player interacts with the environment (e.g., destructible objects,
interactive NPCs, or items).

59 | P a g e
E. Story and Narrative

Story Progression: The unfolding narrative throughout the game, which can be linear or branch
based on player choices.
Dialogue and Cutscenes: Narrative delivery through character interactions, voice acting, and
scripted cinematics or in-game conversations.

Character Development: Development of player characters and NPCs, including backstory,

personality, motivations, and relationships.
Choices and Consequences: Systems that allow players to make decisions that influence the
storyline or world, creating a dynamic experience.

F. Audio and Visuals

Graphics and Art Style: The overall visual style of the game, including textures, lighting,
character models, and animations.
Sound Effects and Music: Background music, sound effects for actions (e.g., footsteps,
gunshots), and ambient sounds that create immersion.

Voice Acting: If applicable, voiceovers for characters, narration, or in-game dialogue.

Accessibility Options: Features to accommodate players with disabilities, such as subtitles,
colorblind modes, or customizable controls.

G. Monetization and Economy

In-App Purchases (IAP): The ability for players to purchase additional content, such as skins,
currency, or power-ups.
Ads: Integration of advertisements, either as banners, interstitials, or video ads, for free-to-play
games.
Game Economy: The systems governing in-game currency, items, and progression (e.g., how
players earn and spend money or points).

60 | P a g e
H. Technical Functions

Game Engine: The underlying technology powering the game, such as Unity or Unreal Engine,
which provides tools for rendering, physics, audio, and scripting.
Cross-Platform Support: Enabling the game to run on multiple platforms, such as PC, console,
mobile, or VR.
Save/Load Systems: The ability to save progress and load previous game sessions, including
cloud saves.
Multithreading and Optimization: Ensuring smooth performance by leveraging multiple cores
and optimizing rendering and processing to run efficiently.

I. Analytics and Reporting

Player Data Tracking: Collecting data on player behavior, preferences, and in-game actions to
improve gameplay, optimize performance, or gather metrics for marketing.
Bug Reporting: Systems for tracking and reporting bugs, errors, and performance issues, both
internally and for players.

J. Testing and Debugging

Automated Testing: Tools and scripts that automate the testing of core game features to ensure
reliability.
Debugging Tools: Features that help developers track down issues in the game, such as logging,
performance profilers, and in-game debugging consoles.
Quality Assurance (QA): The testing process that ensures the game is free of critical bugs and
delivers a smooth player experience.

K. Post-Launch Support and Updates

Patches and Updates: Regular updates that fix bugs, balance gameplay, add new content, or
improve the game’s performance.

61 | P a g e
Community Support: Channels for community interaction, such as forums, social media, or
customer service support.
DLCs and Expansions: Additional content, such as downloadable content (DLC) packs,
expansion missions, or seasonal updates.

2.2. User Characteristics

A. Demographics

Age: Different age groups often have different gaming preferences. For example, younger
players may prefer action-packed games, while older players might enjoy strategy or
simulation games.
Gender: While gaming is increasingly popular across all genders, certain games or genres
may attract different gender groups. Understanding this can help in tailoring experiences
(e.g., character design, storylines).
Location: Players’ geographical location can influence the types of games they play due to
cultural preferences, language, and access to gaming platforms.
Income Level: Income can determine the platforms players use (e.g., PC vs. mobile) and
whether they are likely to spend money on in-game purchases.
Education Level: The complexity of the game, including its narrative depth or strategy
elements, may depend on the education level and cognitive abilities of the target audience.

B. Gaming Experience

Skill Level: Players can vary from beginners (novice players) to advanced or expert
players. Games should be designed to accommodate these differences, through difficulty
settings, tutorials, and adaptive gameplay.
Game Preferences: Players have different genre preferences, such as RPGs, FPS, puzzles,
platformers, or strategy games. Understanding these preferences helps developers create
targeted experiences.
Platform Familiarity: Some players prefer console gaming, others prefer PC or mobile

62 | P a g e
gaming. The input method (keyboard, mouse, touchscreen, controller) also varies across
platforms.
Frequency of Play: Casual gamers play less frequently and may prefer short, accessible
sessions, while hardcore gamers may play longer and seek more in-depth experiences.
Community Engagement: Some players are more engaged with the gaming community
(through social media, forums, or in-game chat), while others prefer a solitary experience.

C. Behavioral Characteristics

Play Style: Players may be completionists, preferring to finish every aspect of the game
(collecting all items, achieving 100% completion), or they might prefer to focus on key
objectives and move on.
Competitiveness: Competitive players enjoy challenges, leaderboards, and PvP elements.
Casual players may prefer non-competitive or cooperative gameplay.
Exploration vs. Achievement: Some players love exploring open-world games and
discovering new locations, while others focus on completing missions or unlocking
achievements and rewards.
In-Game Economy Preferences: Users might prefer earning in-game rewards through
gameplay, or they may be inclined to purchase in-game items or currency.
Social Interaction: Some users are highly social, engaging in multiplayer modes, while
others prefer single-player games where they can immerse themselves without external
interactions.

D. Psychographics

Motivations: Players are motivated by different factors, including:

Escapism: Using games as a means to escape from real life.
Storytelling: Enjoying immersive narratives and complex plots.
Challenge: Seeking games that push their skills and provide intellectual stimulation.
Social Interaction: Enjoying multiplayer modes and connecting with other players.
Creativity: Enjoying games that allow for creation, such as sandbox games or

63 | P a g e
customization features.
Emotions: Games that evoke specific emotional responses, such as excitement, fear, joy, or
nostalgia, can greatly influence user satisfaction.
Personality: Users' personalities may impact how they interact with a game. For example:
Introverts may prefer single-player or story-driven experiences.
Extroverts may gravitate toward multiplayer or competitive games.

E. Cognitive Characteristics

Problem-Solving Skills: Players may vary in their ability and desire to engage in complex
puzzles or strategies. Some players may prefer fast-paced action, while others enjoy deep
problem-solving.
Attention Span: Casual gamers may have shorter attention spans and prefer games that can
be enjoyed in short bursts, while hardcore players may engage in long, immersive sessions.
Learning Style: Some players may learn best through explicit tutorials and instructions,
while others may prefer to figure things out on their own or learn through trial and error.
Decision-Making Speed: Players can be fast decision-makers or more deliberate, affecting
the pace of the game. Games can be designed to accommodate both playstyles with
adjustable speeds or difficulty levels.

F. Accessibility Needs

Physical Disabilities: Games must consider players with physical disabilities, such as
providing options for colorblind players, or offering remappable controls for players with
limited mobility.
Cognitive and Learning Disabilities: Some players may need features like slower game
speeds, clearer instructions, or simplified mechanics to enjoy the game fully.
Hearing Impairments: Providing subtitles, visual cues, or haptic feedback can ensure
players with hearing impairments can still engage with the game.
Visual Impairments: Colorblind modes, adjustable text sizes, and high-contrast modes can
help players with visual impairments play comfortably.

64 | P a g e
G. Technological Familiarity

Tech-Savviness: Players may have varying levels of understanding and comfort with
technology. Some might easily understand complex controls or systems (like modding or
customizing game files), while others may require more intuitive interfaces.
Device Familiarity: Players' experience with certain devices (e.g., gaming consoles, VR
headsets, mobile phones) will impact how they interact with the game. Developers should
account for different screen sizes, touch interfaces, or motion controls based on the target
platform.

H. Social and Cultural Characteristics

Cultural Preferences: Different regions may have unique cultural influences that affect the
type of content players enjoy, such as preferences for story types, character representations,
or even specific genres of games.
Language: Players’ language preferences should be considered, with support for localized
translations or subtitling for players in different countries.

I. Motivational Drivers and Frustrations

Motivations: Understanding why players play certain games can help tailor content:
Escapism, competition, relaxation, or skill development.
Frustrations: Recognizing potential sources of player frustration, such as overly difficult
challenges, intrusive monetization, or poor control mechanics, helps improve game design
and user satisfaction.

65 | P a g e
2.3. General constraints and Assumptions

General Constraints in Game Development

A. Technical Constraints

Hardware Limitations: The game must run on specific hardware platforms (e.g., PC, console,
mobile). Each platform has its own limitations in terms of processing power, memory, storage,
and graphics rendering.

Example: A mobile game may have limited processing power and memory compared to a PC or
console game, requiring optimization for performance.
Frame Rate and Resolution: The game must be designed to support specific frame rates (e.g.,
30fps or 60fps) and resolutions (e.g., 1080p, 4K) depending on the target platform.
Network Limitations: For online multiplayer games, the game’s architecture needs to account for
latency, bandwidth, and server capacity, ensuring a smooth online experience.

B. Time Constraints

Development Schedule: Game projects often have fixed deadlines, such as a planned release
date, requiring careful time management for design, prototyping, coding, testing, and
finalization.
Example: A game may need to be completed in time for a holiday season or to coincide with a
major console launch.
Resource Availability: The availability of personnel (designers, artists, developers) and other
resources (software tools, technology) may be limited, affecting the pace of development.

C. Budget Constraints

Financial Budget: The development of the game needs to adhere to a fixed budget, which will

66 | P a g e
dictate the scale of the game, the scope of features, and the size of the development team.
Operational Costs: Ongoing costs for servers, cloud storage, or distribution (e.g., through
platforms like Steam or PlayStation Store) may impact the budget.

D. Design Constraints

Gameplay Design Limitations: The game mechanics and user experience must adhere to certain
principles, such as accessibility, fairness, and clarity. This includes designing intuitive controls,
ensuring a balanced difficulty curve, and avoiding repetitive gameplay.
Genre and Platform-Specific Constraints: Different genres or platforms come with specific
expectations. For example, a mobile game may need to prioritize quick play sessions and easy-
to-learn mechanics, while an open-world RPG might require complex quest systems and
expansive environments.

E. Legal and Regulatory Constraints

Copyright and Intellectual Property: The game must avoid infringing on existing IPs, trademarks,
or copyrighted materials. Developers must create original content or secure licenses for third-
party assets (e.g., music, characters, logos).
Rating and Age Restrictions: The game must comply with regional age ratings (e.g., ESRB,
PEGI) and content regulations (e.g., preventing inappropriate content for younger audiences).
Data Privacy and Security: For games that collect player data (especially personal data), they
must comply with privacy laws (e.g., GDPR, CCPA).

F. Performance Constraints

Optimization for Different Devices: The game must run efficiently on a variety of devices, from
high-end PCs and consoles to low-powered mobile devices. This requires balancing performance
with visual quality, ensuring smooth gameplay.
Load Times and Asset Streaming: Large games must manage how assets are loaded and
streamed (e.g., in open-world games) to ensure that loading times are minimized and players do

67 | P a g e
not encounter disruptions.

G. Cultural and Regional Constraints

Localization: The game may need to be localized to different languages, requiring translation of
in-game text, voiceovers, and cultural adaptation of content to suit different regions.
Cultural Sensitivity: Some content may need to be adjusted to respect cultural norms and values
(e.g., avoiding offensive imagery, symbols, or themes in certain regions).

H. User Experience Constraints

Accessibility: The game should be accessible to players with disabilities, requiring features like
subtitles, colorblind modes, or customizable controls.
Player Preferences: The game needs to balance various player preferences, such as offering
different difficulty levels, game modes, or playstyles to accommodate a broad audience.

General Assumptions in Game Development

A. Target Audience

Player Demographics: The game is being developed for a specific group of players, such as
casual gamers, hardcore gamers, children, or adults. This assumption influences design choices
like gameplay complexity, theme, and difficulty level.
Platform Preferences: The assumption may be that players are using specific gaming platforms
(e.g., consoles, PC, mobile) and that the game will be optimized for those platforms.

B. Technological Assumptions

Standard Hardware and Software: Developers assume that players will have access to a certain
level of hardware and software, such as a specific version of a gaming console or operating
system.

68 | P a g e
Example: Assuming that players will use graphics cards that support DirectX 12 on PC or that
the mobile game will run on iOS or Android devices with certain specs.
Stable Internet Access: For multiplayer or online games, it is often assumed that players will
have stable internet connections to engage in gameplay without major latency or disconnect
issues.

C. Market Trends and Consumer Behavior

Popularity of Game Genres: The development team may assume that certain genres (e.g., battle
royale, platformers, RPGs) will continue to be popular based on current market trends and player
interest.
Monetization Strategy: The assumption may be that players are willing to engage with
microtransactions, subscriptions, or ads, depending on the game’s monetization model.

D. Gameplay Balance

Skill Progression and Player Growth: It is often assumed that players will gradually improve
their skills, and that the game will offer systems for skill progression (e.g., leveling, upgrading,
gaining new abilities).
Engagement through Rewards: The assumption is made that players will be motivated by the
rewards and progression systems implemented in the game (e.g., unlocking new levels, earning
achievements, collecting items).

E. Player Behavior and Social Interaction

Multiplayer Interaction: For multiplayer games, developers assume that players will engage
socially with others, either cooperatively or competitively, and that community features like
voice chat or social media integration will enhance the experience.
Community Feedback: It is assumed that players will provide feedback that can be used to
improve the game post-launch, through reviews, forums, or direct communication with the
development team.

69 | P a g e
F. External Dependencies

Third-Party Tools and Services: Game development may depend on third-party tools, libraries,
or services such as game engines (e.g., Unity, Unreal), cloud storage, analytics platforms, and
payment gateways. Developers assume that these tools will be reliable and supported throughout
the development cycle.
Licensing: If the game relies on licensed content (e.g., music, characters), the assumption is
made that the necessary licenses will be obtained before the game is released.

G. Post-Launch Support

Patches and Updates: The assumption is often made that the game will require ongoing patches
and updates to fix bugs, improve gameplay, or introduce new content after release.
Server Maintenance: For online games, it is assumed that the necessary server infrastructure will
be in place and maintained to support player connections.

3. Functional Requirements

3.1. General Description of Inputs and Outputs

Inputs in Game Development

Inputs refer to the data or signals that come from the player or external devices, allowing them to
interact with the game. These can include actions, choices, and commands that alter the game
state.

A. Player Controls (User Inputs)

Keyboard/Mouse (PC Games):

Keyboard: The keys on a keyboard are mapped to various actions (e.g., moving a character,

70 | P a g e
using items, pausing the game).
Example: The "WASD" keys for movement, "Space" for jumping, "E" for interacting with
objects.
Mouse: Used for pointing, selecting, clicking, or moving the camera.
Example: Left-click for shooting, right-click for aiming, and mouse movement to look around.
Gamepad/Controller (Console Games):
Buttons and Joysticks: Analog and digital controls on a gamepad allow the player to move
characters, attack, or interact with the environment.
Example: Left joystick for movement, right joystick for camera control, "X" for action, and "B"
for dodging.
Touchscreen (Mobile Games):
Taps, Swipes, Pinches: Players interact directly with the screen to move, select, and execute
actions in mobile games.
Example: Tap to jump, swipe to move, pinch to zoom.
Motion Sensing (VR/AR Games):
Movement Tracking: In virtual or augmented reality games, motion sensors detect the player's
movements or gestures to control the game.
Example: The player may physically swing their hand to simulate sword fighting or tilt their
head to look around in VR.

B. External Inputs

Voice Commands: Players can issue commands using voice input (for games with voice
recognition support).
Example: Saying “Attack” to trigger an in-game action.
Sensors/Devices: For some games, external devices like motion trackers or environmental
sensors can act as inputs.
Example: A fitness game may use a fitness tracker or motion-sensing device to measure player
movement and adjust gameplay accordingly.

71 | P a g e
Outputs in Game Development

Outputs refer to the data or signals generated by the game that are presented to the player or used
for internal processing. Outputs can include visual feedback, audio cues, and haptic responses
that help immerse the player and guide gameplay.

A. Visual Outputs

Graphics and Animation: The most obvious output, the game displays visual elements such as
characters, environments, UI elements, animations, and effects.
Example: A player’s character moves through an environment, and enemies react to the player’s
presence with animations like attacking or fleeing.
HUD (Heads-Up Display): The HUD displays essential information, such as health, score, ammo
count, time remaining, and other gameplay data.
Example: A shooter game may display the player's health, ammo count, and minimap in the
corners of the screen.
Cutscenes and Cinematics: Certain story-driven games use pre-rendered videos or in-game
cinematics to progress the story.
Example: A story mission in an RPG might include a cutscene that shows a character’s
conversation with an NPC.

B. Audio Outputs

Sound Effects: The game provides feedback to the player through sound effects that correspond
to in-game actions, such as movement, combat, and interactions.
Example: A character shooting a weapon generates a gunshot sound, and a door opening might
produce a creaking sound.
Background Music: The game often includes dynamic music that changes based on the game's
state or environment to evoke mood or tension.
Example: A calm, serene piece of music when exploring a safe area and dramatic, intense music
when facing enemies or in a boss fight.

72 | P a g e
Voice Acting: Many games include voice dialogue from characters, narrators, or NPCs to help
build the story and character development.
Example: An NPC might speak to the player, offering quest information or background story.

C. Haptic Feedback

Vibration and Force Feedback: Many games, especially those with action or combat mechanics,
use haptic feedback to simulate sensations like impacts or movements.
Example: When the player’s character is hit by an enemy, the controller might vibrate, or in VR,
there may be force feedback to simulate touch or impact.
Adaptive Triggers (e.g., PlayStation 5 controllers): Newer controllers provide more nuanced
feedback with adjustable resistance based on in-game actions.
Example: Pulling a bowstring might feel different from pressing a button, with the trigger
resistance increasing as the string is drawn back.

D. Textual Outputs

Dialog Boxes and Text Pop-ups: In many games, players will receive information through text,
such as quest objectives, messages from NPCs, or system alerts.
Example: An RPG might display dialogue options when speaking to an NPC, or a message may
pop up with instructions during a tutorial.
Notifications: Games often display pop-up notifications to alert the player of events, updates, or
game changes.
Example: A notification might appear when a player receives a new achievement or unlocks a
new item.
Subtitles and Captions: Many games provide text subtitles for spoken dialogue, especially to
support accessibility needs or players in noisy environments.
Example: Subtitles appear on-screen when characters speak during a cutscene.

73 | P a g e
E. Game State and Progression Outputs

Save/Load Data: The game tracks and outputs the player’s progress, such as levels, items
collected, or unlocked achievements. This is usually stored in game files and loaded as needed.
Example: When a player returns to the game, their saved progress is loaded, including levels
completed and items collected.
Progress Indicators: The game often provides outputs showing progress toward goals, such as
completing missions, leveling up, or reaching certain checkpoints.
Example: A quest progress bar might show how much of a mission has been completed, or a "XP
bar" may show how close the player is to leveling up.

F. External Outputs

Network Communication: For online games, the output might include data sent to or received
from a server, such as multiplayer matchmaking information, player stats, or real-time game
updates.
Example: An online multiplayer game sends player data to the server to update scores and
rankings in real-time.
Streaming and Cloud Integration: Some games may integrate with cloud services to allow
players to stream gameplay, transfer save data, or play across multiple devices.
Example: A player logs into the game on a different device, and their save file is automatically
synced via the cloud.

3.2. Functional Requirements

A. Gameplay Mechanics

Game Flow: The game must provide a clear progression of gameplay, including start, middle,
and end phases. This could include levels, missions, or checkpoints.
Example: The game must allow players to advance through levels, unlocking new challenges or
areas after completing specific objectives.

74 | P a g e
Player Controls: The game should allow the player to interact with the game world using specific
input devices (e.g., mouse, keyboard, controller, touchscreen).
Example: The player should be able to move the character with arrow keys or analog sticks,
jump with the “A” button, and attack with the “X” button.
Combat Mechanics: The game must have specific combat systems, whether turn-based, real-
time, or strategy-based, defining how players attack, defend, and use abilities.
Example: In a fighting game, the system should include combinations of attacks, defensive
maneuvers, and counters.
Inventory System: Players must be able to collect, equip, use, and manage items within the
game.
Example: The player can collect health potions, weapons, or armor and store them in an
inventory, then use them during gameplay.

B. Player Interaction

Multiplayer Functionality: The game should support multiplayer modes, either online or local,
allowing multiple players to interact within the game environment.
Example: A shooter game must allow players to join servers, team up with other players, and
compete against enemy players in real-time.
Chat and Communication: For multiplayer games, players should be able to communicate
through text or voice chat.
Example: The game must support in-game text chat for players to communicate and strategize.
Co-op or PvP Modes: The game may include various modes where players either collaborate in
cooperative gameplay or compete against each other in competitive modes.
Example: In an RPG, players can choose between solo play or joining others in a co-op mode to
defeat larger enemies.

C. Character and NPC (Non-Player Character) Interaction

Character Creation/Customization: The game should allow players to create and customize their
own characters, adjusting appearance, abilities, or traits.

75 | P a g e
Example: The player can select gender, clothing, and accessories, or assign points to strength,
agility, and intelligence in an RPG.
NPC Behavior: NPCs must have predefined behaviors, including reacting to player actions,
providing quests, or offering items or information.
Example: In an adventure game, NPCs give quests, provide dialogue options, or sell items to the
player.

D. Audio and Visual Effects

Graphics: The game should render 3D or 2D environments, characters, and objects according to
the game’s artistic style and platform limitations.
Example: A fantasy game should have richly detailed landscapes, with castles, forests, and
mystical creatures.
Sound Effects and Music: The game should have dynamic audio, including background music,
sound effects for actions, and ambient sounds.
Example: A fighting game may have sound effects for punches, kicks, and explosions, with
background music adjusting to the intensity of the battle.

E. Progression and Reward Systems

Leveling System: The game must allow characters or players to level up based on experience
points or achievements, unlocking new abilities, weapons, or areas.
Example: In an RPG, the character gains experience points from defeating enemies, which then
contribute to leveling up and acquiring new skills.
Achievements and Trophies: The game should feature a system to reward players for reaching
certain milestones, completing challenges, or achieving rare feats.
Example: Earning an achievement like “First Victory” after completing the first mission or
“Explorer” for discovering hidden areas in the game.

76 | P a g e
F. UI/UX (User Interface/User Experience)

Main Menu: The game should have an intuitive main menu that allows players to start the game,
access settings, load a saved game, or quit.
Example: The main menu should have options such as "New Game," "Load Game," "Settings,"
and "Exit."
HUD (Heads-Up Display): The game should display important information on-screen during
gameplay, such as health, score, ammo, or time remaining.
Example: A shooter game should display the player’s health bar, ammunition count, and a
minimap for navigation.
Pause/Save Game: Players must be able to pause the game at any point, and the game should
have a system for saving progress.
Example: The game should allow the player to pause, view the menu, and save or load progress
from multiple save slots.

G. AI (Artificial Intelligence)

Enemy AI: The game must have AI for enemies, ensuring that they react to the player’s actions,
follow tactics, and provide challenging encounters.
Example: In a strategy game, enemy units must exhibit intelligent behavior, such as attacking the
player’s weak points or defending key resources.
Friendly NPC AI: AI-controlled allies should assist the player in combat or missions, supporting
them effectively.
Example: In a co-op game, NPCs should help the player fight enemies or provide healing when
needed.

H. World and Environment

Open World/Level Design: The game should feature an environment or levels for players to
explore, either in an open-world format or with linear progression.
Example: An open-world game should allow players to explore cities, forests, and mountains,

77 | P a g e
with side quests and hidden treasures scattered across the map.
Environmental Interactions: The game should allow players to interact with the environment,
such as picking up objects, opening doors, or manipulating objects to solve puzzles.
Example: In a puzzle game, the player should be able to move blocks to clear paths or activate
switches to open doors.

I. Multiplayer and Online Features

Multiplayer Lobby: The game must have a system for players to join multiplayer matches, either
by hosting or joining a game server.
Example: A competitive game should allow players to create custom lobbies, join existing ones,
or use matchmaking to play with others online.
Leaderboards and Rankings: A competitive game should feature online leaderboards, showing
player rankings based on scores or win rates.
Example: The game must display the top players based on points, and also allow players to see
their own ranking compared to others.

J. Security and Data Management

Player Authentication: The game should allow players to sign in securely, using methods like
username/password, social media accounts, or single sign-on (SSO).
Example: The game should authenticate users via a secure login process, linking accounts with
email addresses or social media profiles.
Data Storage and Cloud Sync: Players’ progress, achievements, and preferences should be
stored, with options for cloud synchronization across devices.
Example: A game should allow players to save their progress in the cloud, enabling them to pick
up where they left off on another device.

K. Testing and Debugging

Error Handling and Debugging: The game must have systems in place for reporting and handling

78 | P a g e
errors, crashes, or bugs that occur during gameplay.
Example: The game should log errors and provide detailed feedback to the developer to fix any
issues before release.

L. Post-Launch Features

Patches and Updates: The game must be able to receive patches, updates, and downloadable
content (DLC) after launch.
Example: A game should allow automatic updates for bug fixes, content expansions, or new
features.
Community Features: Post-launch, the game may include features like player feedback, forums,
and updates based on community suggestions.
Example: The game should include a feedback system for players to report bugs or suggest new
features, which can be incorporated into future updates.

4. External Interface requirements

External Interface Requirements in game development refer to the interactions and dependencies
between the game and external systems, devices, or platforms. These interfaces are crucial for
the game to function correctly in its environment, ensuring that the game can communicate with
other software, hardware, and services. The external interfaces can include hardware
components, network services, third-party software, and platform-specific requirements.

4.1. User Interface

Creating user interface (UI) requirements for a game development project involves
understanding the game's genre, target audience, platform, and overall design goals. Here’s a
structured approach to defining UI requirements:

79 | P a g e
A. Platform Compatibility
Ensure the UI works seamlessly on the target platform (PC, mobile, console).

B. Responsive Design
Adapt to various screen resolutions and aspect ratios.

C. Ease of Navigation
Provide intuitive menus and navigation paths for users.

D. Readability
Use clear fonts, appropriately sized text, and high contrast.

E. Accessibility Features
Include colorblind modes, subtitles, and text-to-speech options.

F. Main Menu Options

Include Start, Settings, and Quit options.

G. In-Game UI
Display essential information like health, objectives, and a minimap.

H. Settings Menu
Provide options for audio, graphics, and controls customization.

I. Pause Menu
Allow access to settings, save/load, and quit options during gameplay.

J. Consistent Aesthetic
Match UI design with the game’s art style and theme.

80 | P a g e
K. Feedback
Add visual/auditory feedback for user actions (e.g., button clicks).

L. Performance Optimization
Ensure the UI is lightweight and doesn’t affect game performance.

M. Error Handling
Display clear error messages for invalid actions.

N. User Testing
Collect feedback from players and iterate based on insights.

O. Customizable UI (Optional)
Allow players to adjust HUD elements or layouts if needed.

4.2. Error Messages

A. Gameplay Errors

These error messages are typically displayed during the gameplay experience and relate to
issues or failures that affect the player’s progression or experience.

[Link] Input

Example Message: "Invalid input detected. Please press a valid key or button to continue."
Description: This message appears when a player tries to perform an invalid action, such as
pressing an unsupported key or input combination.
Solution: The game may show which inputs are acceptable, either by suggesting
alternatives or highlighting the correct control.

81 | P a g e
[Link] Conflict

Example Message: "Action cannot be performed while in combat. Try again after the
fight."
Description: The player attempts to perform an action that conflicts with the game’s
current state (e.g., trying to open an inventory during combat).
Solution: Provide information on how to resolve the conflict or what the player should do
next (e.g., wait until the combat ends).

B. Connectivity Errors

These errors are common in online games, where issues arise related to the network,
server, or player’s internet connection.

B.1. Server Connectivity Issues

Example Message: "Unable to connect to the server. Please check your internet connection
and try again."
Description: The game fails to establish a connection to the game server, either due to
server issues or network problems.
Solution: Advise the player to check their internet connection, try reconnecting, or wait for
server maintenance to complete.

B.2. Timeout Errors

Example Message: "Connection timed out. Please try again later."

Description: The game was unable to establish or maintain a connection to the server
within a reasonable time.
Solution: Inform the player to try again after a short period, and recommend checking for
known server outages or maintenance.

82 | P a g e
B.3. Server Maintenance

Example Message: "The servers are currently undergoing maintenance. Please check back
later."
Description: The servers are temporarily unavailable due to scheduled maintenance or an
unexpected issue.
Solution: Let players know when they can expect servers to be available again or offer an
alternative, like playing offline (if applicable).

C. System Errors

These errors are related to the game’s internal system, such as bugs, missing files, or
hardware compatibility issues.

C.1. Missing or Corrupt Files

Example Message: "Error: Missing game files. Please verify the integrity of your game
files."
Description: The game cannot run properly due to missing, corrupted, or improperly
installed files.
Solution: Suggest verifying or reinstalling the game, or restoring files from a backup.

C.2. Hardware Incompatibility

Example Message: "Your system does not meet the minimum requirements to run this
game. Please upgrade your hardware."
Description: The game detects that the player’s system does not meet the minimum
hardware specifications required to run the game.
Solution: Provide the minimum hardware requirements and suggest actions the player can
take (e.g., upgrading graphics card, increasing RAM).

83 | P a g e
C.3. Insufficient Storage Space

Example Message: "Not enough storage space. Please free up some space and try again."
Description: The player’s device does not have enough storage available to install or
update the game.
Solution: Suggest deleting unnecessary files or apps to free up space.

5. Performance Constraints

Performance constraints are often defined by the hardware specifications, software requirements,
and gameplay demands. These constraints must be carefully managed to ensure the game runs
efficiently and meets the expectations of the players, particularly when the game is targeting
multiple platforms (e.g., PC, console, mobile). Below are some of the most common
performance constraints in game development:

A. Frame Rate (FPS) Constraints

Target Frame Rate: Games typically target a specific frame rate (e.g., 30 FPS, 60 FPS, or 120
FPS) to ensure smooth gameplay. Frame rate directly affects the visual fluidity of the game and
the overall experience.
Example: "The game should target 60 FPS on PC and 30 FPS on mobile devices."
Challenge: Maintaining a high frame rate can be resource-intensive, especially for graphically
demanding games, so performance must be optimized to avoid drops below the target frame rate.
Frame Time: Frame time is the amount of time required to render one frame. A lower frame time
results in a higher frame rate. For example, to achieve 60 FPS, each frame must be rendered in
16.67 milliseconds.

Example: "The game must maintain a maximum frame time of 16.67 ms for a consistent 60
FPS."

84 | P a g e
B. Load Times (Startup Time & Level Loading)

Startup Time: The time it takes for the game to launch from the moment the player starts the
application until the main menu appears. Long load times can negatively impact user experience.

Example: "The game should start within 10 seconds on a standard PC configuration."

Level Loading Time: The time required to load new levels or areas in the game. This is
especially important for open-world games or those with large, dynamic environments.

Example: "Loading times between levels should not exceed 30 seconds on consoles and 20
seconds on PCs."
Challenge: Optimizing asset loading (e.g., textures, models, sound files) while balancing visual
quality and performance can be a complex task. Streaming or asynchronous loading techniques
can be used to address long load times.

C. Memory Usage Constraints

RAM Usage: The amount of random access memory (RAM) the game requires to run
effectively. Too much memory usage can cause the game to run slowly or crash, particularly on
devices with limited resources like mobile phones or consoles.

Example: "The game must not exceed 4 GB of RAM usage on PC and 1 GB on mobile devices."
VRAM Usage: Video RAM (VRAM) is used by the GPU to store textures, models, and other
graphical assets. High VRAM usage impact performance lead to graphical glitches or stuttering.

Example: "The game should not exceed 2 GB of VRAM usage on a mid-range gaming PC."
Memory Leaks: The game must be optimized to prevent memory leaks, where memory is
allocated but never released, leading to gradual performance degradation.

Challenge: Tracking and fixing memory leaks through proper testing and profiling tools.

85 | P a g e
D. CPU and GPU Performance Constraints

CPU Usage: The game must be optimized to use the CPU efficiently, especially in physics
simulations, AI calculations, and logic processing. Overuse of the CPU can cause the game to lag
or stutter.

Example: "The game should not consume more than 80% of the CPU on average during
gameplay."
GPU Usage: Graphics-intensive games need to optimize GPU performance to maintain high-
quality visuals while ensuring the game runs at the target frame rate.

Example: "The game should not exceed 90% GPU usage on high settings for a 60 FPS target."
Multithreading: For better performance, especially in complex games, the game should be
optimized to use multiple CPU cores efficiently, taking advantage of modern multi-core
processors.

Challenge: Ensuring proper synchronization and avoiding race conditions when using multiple
threads.

E. Network Performance Constraints (for Online/Multiplayer Games)

Latency (Ping): In multiplayer games, latency refers to the delay between a player's input and the
game’s response. High latency can cause lag and an unpleasant experience.

Example: "The game should target a latency of less than 100 ms for competitive multiplayer
matches."
Bandwidth: The amount of data transmitted between the client and server can impact network
performance. The game must be optimized to minimize data usage, especially for mobile
platforms with limited bandwidth.

86 | P a g e
Example: "The game should limit network traffic to no more than 100 KB per second for
multiplayer game play."
Packet Loss: Loss of data packets during transmission can lead to dropped frames,
desynchronization, and unresponsive gameplay. Ensuring reliable communication between the
server and client is essential for multiplayer games.

Example: "Packet loss should be below 1% to avoid disrupting multiplayer sessions."

F. Visual Quality Constraints

Resolution and Texture Quality: The game should support a range of screen resolutions and
adjust texture quality to maintain performance on lower-end hardware. It’s essential to find a
balance between visual fidelity and performance.
Example: "The game should support resolutions from 720p to 4K, with texture quality
dynamically adjusting based on the available GPU resources."
Anti-Aliasing and Post-Processing Effects: Features like anti-aliasing, motion blur, and depth of
field can enhance visuals but also add significant computational overhead.
Example: "The game should allow users to toggle anti-aliasing and post-processing effects to
optimize performance on lower-end systems."
Draw Calls and Assets Optimization: Minimizing draw calls (the number of times the CPU asks
the GPU to render a frame) and optimizing assets (e.g., reducing the number of polygons) can
improve performance.
Challenge: Balancing asset quality with performance to maintain a visually appealing game
without overwhelming system resources.

G. Battery Life (for Mobile Games)

Battery Consumption: For mobile games, it’s important to ensure that the game does not
consume excessive battery power, especially for prolonged gameplay sessions.
Example: "The game should optimize power consumption to prevent battery drain of more than

87 | P a g e
10% per hour of gameplay on a mid-range smartphone."
Thermal Management: Games should be optimized to prevent excessive heating of mobile
devices, which can lead to thermal throttling and performance degradation.
Challenge: Minimizing resource usage and managing background processes to ensure consistent
performance without overheating.

H. Compatibility Constraints

Cross-Platform Performance: The game should be optimized to run efficiently on all target
platforms (e.g., PC, console, mobile) without significant performance differences.

Example: "The game should maintain consistent performance across PC, PlayStation, and Xbox,
with a target of 60 FPS on all platforms."
Platform-Specific Limitations: Each platform (e.g., mobile, console, PC) has unique constraints
in terms of memory, processing power, and input methods. The game must be optimized to run
within the limits of each platform.

Example: "The game should adjust its graphics settings based on the platform’s capabilities, such
as reduced texture resolution on mobile devices."

I. Stability and Reliability Constraints

Crash-Free Operation: The game should be designed to avoid crashes, memory errors, and bugs
that may disrupt gameplay. Rigorous testing and debugging are essential to achieve this.
Example: "The game should run for at least 4 hours continuously without crashing, even under
heavy load."
Consistent Performance: Performance should remain stable during gameplay, without sudden
drops or performance spikes that would impact the user experience.
Challenge: Profiling and optimizing the game to ensure it runs consistently without sudden
performance hitches.

88 | P a g e
6. Design Constraints

6.1. Software Constraints

Software constraints in game development refer to the limitations imposed by the game engine,
third-party libraries, platforms, and the underlying software architecture. These constraints shape
how the game is designed, developed, and optimized. Understanding these constraints is crucial
to ensure the game runs efficiently across different environments and platforms.

Key Software Constraints:

Game Engine Limitations:

Example: A game engine like Unity or Unreal has built-in functionalities, APIs, and systems that
developers must work within. There may be limitations in terms of what the engine can handle
regarding physics, rendering, AI, and multiplayer.
Impact: Some complex features or highly optimized custom solutions might not be easily
achievable with the out-of-the-box features of the game engine.
Solution: Developers may need to extend or modify the engine, create custom plugins, or use
alternative tools to achieve desired results.

Platform-Specific APIs:

Example: Different platforms (PC, consoles, mobile) provide unique software APIs for things
like graphics rendering, input handling, networking, etc.
Impact: The game must be developed to support these APIs, and limitations like platform-
specific features or deprecated support can constrain the development process.
Solution: Use cross-platform game development tools or develop platform-specific code where
necessary.

89 | P a g e
Third-Party Libraries and SDKs:

Example: Games often rely on third-party libraries for sound, AI, physics, multiplayer, or social
features.
Impact: These libraries may not be optimized for all platforms, may have bugs, or may not
support new features you want to implement.
Solution: Evaluate the suitability and performance of third-party libraries and ensure
compatibility with your game's needs. Custom solutions may be needed for specific features.

Operating System Restrictions:

Example: The game might be limited by the operating system (Windows, macOS, Android, etc.)
in terms of multitasking, system calls, file system access, or memory management.
Impact: Certain features like background tasks or custom file management may be limited or
behave differently across different operating systems.
Solution: Tailor the game to handle operating system-specific constraints and use cross-platform
frameworks to minimize differences in behavior.

Version Compatibility:

Example: Different versions of a game engine or development software may introduce breaking
changes, deprecate certain features, or require updates to work correctly.
Impact: The game might not work on certain versions of the development tools, or it may require
significant refactoring to support newer versions.
Solution: Ensure backward compatibility with older software versions or keep the game updated
to work with the latest versions of the tools.

Multithreading and Concurrency:

Example: In modern game development, utilizing multithreading is crucial for performance,

90 | P a g e
especially in CPU-intensive games. However, working with multithreading can introduce
complexities, like deadlocks, race conditions, and synchronization issues.
Impact: Ensuring the game runs efficiently across multiple cores without crashing can be
challenging and require careful handling of concurrency.
Solution: Use thread-safe programming practices and synchronize resources properly to ensure
smooth multithreaded performance.

Software Dependencies:

Example: Some games rely on specific libraries or middleware for things like AI, physics, or
network communication.
Impact: These dependencies may have licensing restrictions, performance overheads, or version
conflicts that limit the game's capabilities or cross-platform compatibility.
Solution: Carefully manage and update dependencies, or create custom solutions where
necessary to avoid reliance on unsupported or inefficient libraries.

6.2. Hardware Constraints

Hardware constraints are limitations based on the target hardware devices for the game,
including processing power, memory, storage, and graphical capabilities. These constraints
directly impact how the game is optimized, and determining the target hardware is essential
during the design phase of the game.

Key Hardware Constraints:

CPU Performance:

Example: The performance of the central processing unit (CPU) affects the processing of game
logic, AI, physics simulations, and background tasks.
Impact: Low-end CPUs might not be able to handle complex calculations or large numbers of in-
game entities, resulting in slowdowns or lag.

91 | P a g e
Solution: Optimize CPU usage by reducing the number of calculations per frame, simplifying AI
logic, or offloading tasks to other components like the GPU.

GPU Performance:

Example: The graphics processing unit (GPU) is responsible for rendering images, videos, and
animations. The GPU’s processing power limits the complexity of visual effects, texture
resolution, and frame rate.
Impact: Games with high-end graphics (e.g., 4K resolution, advanced shaders, real-time lighting)
may not perform well on devices with lower-end GPUs.
Solution: Adjust graphical settings dynamically based on the hardware (e.g., lowering texture
quality, turning off advanced effects like ray tracing on lower-end systems) and use techniques
like level of detail (LOD) to optimize performance.

RAM and VRAM:

Example: The amount of random access memory (RAM) and video RAM (VRAM) can limit the
size of the game world, texture quality, and the number of assets loaded simultaneously.
Impact: Insufficient RAM may lead to crashes or slowdowns due to memory swapping, while
insufficient VRAM can lead to lower resolution textures or stuttering during gameplay.
Solution: Optimize asset management by using lower-quality textures, streaming assets in and
out of memory, and using memory pools to manage resources more efficiently.
Storage Space and I/O Speed:

Example: Storage constraints affect how much data (game assets, textures, audio files, etc.) can
be stored and accessed. Loading times may be affected by slow storage devices like HDDs.
Impact: Slow read/write speeds can significantly impact the game’s load times, especially when
accessing large levels or assets.
Solution: Use compression techniques to reduce file sizes, optimize the game to load assets
asynchronously, and consider implementing fast storage requirements like SSDs for improved
load times.

92 | P a g e
Network Hardware (for Multiplayer Games):

Example: The quality of the network hardware (e.g., Wi-Fi or Ethernet connections) impacts the
speed and reliability of online multiplayer games.
Impact: Slow or unreliable connections can lead to lag, packet loss, or desynchronization in
multiplayer games.
Solution: Implement lag compensation techniques, predictive algorithms, and optimize network
traffic to ensure smoother gameplay even with limited bandwidth or high latency.

Input Devices and Peripherals:

Example: The game may need to support different input devices like keyboards, mice, game
controllers, touchscreens, and motion sensors.
Impact: Variations in input device quality (e.g., latency, sensitivity) can affect gameplay,
particularly in fast-paced or precision-required genres like fighting games or first-person
shooters.
Solution: Support customizable controls, allow for input device calibration, and ensure
compatibility across a wide range of devices.

Battery Life (for Mobile Devices):

Example: Mobile games must operate efficiently within the power constraints of the device's
battery.
Impact: Games that consume excessive battery can lead to poor user experience, particularly on
long sessions.
Solution: Optimize game code to minimize CPU and GPU usage, reduce background processes,
and offer power-saving modes for lower device power consumption.

Platform-Specific Hardware:

93 | P a g e
Example: Different platforms (PC, PlayStation, Xbox, mobile) may have unique hardware
features and performance profiles.
Impact: The game must be optimized to leverage the capabilities of each platform (e.g., graphics
capabilities of a PS5 vs. an Xbox Series X) while ensuring that it runs well on lower-end models
as well.
Solution: Implement platform-specific settings and optimizations (e.g., resolution adjustments,
texture settings, support for unique input devices) to ensure the best possible experience on each
platform.

94 | P a g e
 APPENDIX -II

Architectural Design

Fig 8: Use Case Diagram

Actors

User: Represents the player interacting with the game.

System

The rectangle labeled "Game" represents the game system, containing all the functionalities
(use cases).

95 | P a g e
Use Cases (Functionalities)

1. Start Game: The functionality to start the game.

2. Switch Car: Allows the user to choose a different car for the race.
3. Choose Track: Lets the user select the track for the race.
4. Play Game: Begins the gameplay, including controlling the player's car.
5. Pause Game: Pauses the game at any point during gameplay.
6. Resume Game: Resumes the game from a paused state.
7. Skip Countdown: Skips the countdown before the race begins.
8. Show Speedometer: Displays the player's car speed on the screen.
9. Track Timer: Starts a timer to monitor the race duration.
10. Opponent Pathfinding: Manages the opponent's car movement along the track.
11. Show Win/Lose Display: Displays the outcome of the race (win or lose).

Interactions

User Interactions

The User interacts directly with the following functionalities:

• Start Game: To initiate the game.

• Switch Car: To select a car.
• Choose Track: To pick a racing track.
• Play Game: To start the race.
• Skip Countdown: To bypass the pre-race countdown.
• Pause Game: To pause the race.
• Resume Game: To resume a paused race.

Relationships Between Functionalities

1. Start Game:

o Connects to Switch Car with the note "Select Car," meaning the user selects a car after
starting the game.
o Connects to Choose Track with the note "Select Track," meaning the user selects a track
after starting the game.

2. Play Game:

o Triggers Track Timer to start tracking the race time.

o Triggers Show Speedometer to display the car's current speed.
o Triggers Opponent Pathfinding to manage the opponent's car movement.

96 | P a g e
o Links to Show Win/Lose Display with the note "Finish Race," indicating the race ends.

3. Pause Game:

o Links to Resume Game with the note "Continue," allowing the user to continue the game
after pausing.

4. Track Timer:

o Links to Show Win/Lose Display with the note "Time Expired," indicating the race ends
when the timer runs out.

5. Show Speedometer:

o Links to Show Win/Lose Display with the note "Race Complete," indicating the
speedometer contributes to finishing the race.

Purpose of the Diagram

The diagram shows how the player interacts with different parts of the game and how the
functionalities are related to each other. It demonstrates the flow:

• From starting the game to selecting options (cars and tracks).

• From playing the game to pausing, resuming, or finishing the race.

This helps developers and stakeholders understand the game’s features and their dependencies.

97 | P a g e
 Fig 9: Sequence Diagram

This diagram represents the sequence of interactions between the user, game components, and
other parts of a car racing game system. Here's an explanation based on the entities and their
actions:

Actors and Participants

1. User: The player interacting with the game.

2. Camera View Script: Manages camera behavior in the game.
3. Car Selection: Handles car selection and track setup.
4. Finish: Handles end-of-race actions.
5. Menu: Manages the pause and resume functionality and navigation between game scenes.
6. Player Car Controller: Controls the player's car during gameplay.

98 | P a g e
7. Opponent Car: Represents an opponent's car and its behavior.
8. Opponent Car Waypoints: Manages waypoints for the opponent's pathfinding.
9. Skip Button: Allows skipping certain actions, such as a countdown.
10. Speedometer: Displays the car's speed.
11. Timer: Tracks and controls time-dependent events in the game.
12. Waypoint: Represents positions on the track for navigation.

Interactions

Camera View Script

• Disables the main camera at the start.

• Starts the countdown by interacting with the Timer.
• The Timer then:

o Sets the Player Car Controller's acceleration force.

o Sets the Opponent Car's moving speed.

Car Selection

• Disables specific cameras (cam1 and cam2).

• Populates the list of cars.
• Updates the selection when the user interacts with next button or previous button.
• The user can:

o Switch cars by interacting with the car selection system.

o Play the game, which hides the Selection Canvas and enables the Map UI.

Skip Button

• When the user clicks the skip button, it triggers the Audio Source to play a sound.

99 | P a g e
Player Car Controller

• Updates the car's speed, which is reflected on the Speedometer.

Opponent Car

• Interacts with the Opponent Car Waypoints to get the next waypoint for navigation.
• Drives to the destination based on the waypoint.

Finish

• Disables the player's UI and enables the finish UI at the end of the race.
• Freezes the game by interacting with the Timer.

Menu

• Loads different scenes via the Scene Manager.

• The user can pause the game, which shows the Pause Menu UI.
• Resuming the game hides the Pause Menu UI.

Waypoint

• Randomizes and fetches paths for navigation when required.

Purpose of the Diagram

This sequence diagram illustrates:

1. User interactions: Actions like selecting a car, starting the game, pausing, and resuming.
2. Component behaviors: How game entities (like Timer, Opponent Cars, and Finish)
coordinate to implement game logic.
3. Flow of events: From preparation (car selection) to gameplay and race completion.

100 | P a g e
 Fig 10: Activity Diagram

In the context of your racing game, the activity diagram would depict the sequence of actions
that players and various game components undergo from start to finish, covering actions like

101 | P a g e
selecting cars, starting the game, racing, and handling game completion. Here’s a breakdown of
each major part of the activity diagram:

1. Game Initialization

• The game starts with the user entering the Car Selection phase.
• Car Selection: Here, the player can browse through available cars. The Car Selection
component loads the list of cars and enables options for the player to switch cars by clicking
a button.
• The player selects their desired car, and when ready, clicks the "Play" button to proceed to
the race.

2. Transition to Race Setup

• Selection Canvas UI is disabled, and the Map UI is enabled, indicating the switch from the
selection screen to the race screen.
• Camera View Script is triggered to disable the main camera and set up the race camera
view.
• The Timer component initiates a countdown, giving the player a few seconds before the race
begins. During this countdown, the Player Car Controller and Opponent Car components
are activated to allow movement, with specific speeds assigned to them for the race start.

3. Gameplay and Player Actions

• Once the countdown reaches zero, the race officially starts, and both Player Car Controller
and Opponent Car components control car movement.
• Player Car Controller: Updates each frame to control the player’s car acceleration and
steering. The Speedometer component is updated based on the player’s current speed to
reflect real-time racing data.
• Opponent Car: Operates based on waypoints provided by Opponent Car Waypoints. Each
opponent car is directed to the next waypoint, creating a path-following behavior for AI-
controlled cars.

102 | P a g e
• Skip Button: During the countdown or other transitional phases, the player may choose to
skip by clicking the Skip Button, which plays a sound effect and possibly skips the
countdown.

4. Race End and Result Display

• When a car reaches the finish line, the Finish component detects this through an
OnTriggerEnter event.
• Once the race ends:

o The player UI is hidden, and the finish UI is displayed to show the end-of-race results.
o The Finish component displays a win or lose message based on the player's performance.
o Timer component sets the game’s time scale to zero, effectively freezing the game and
signaling the end of the race.

5. Pause and Resume (Optional)

• During gameplay, the player has the option to pause by accessing the Menu.
• When paused, the Menu UI appears, and specific game elements like the Speedometer are
disabled.
• The player can resume the game from the Menu, which re-enables the speedometer and
hides the pause UI.

6. Scene Management

• In some cases, the Menu allows players to load different scenes (like day, night, or rainy
environments), enhancing the visual experience.
• SceneManager handles the transition between different scenes when selected.

103 | P a g e
 APPENDIX – III

DESIGN LAYOUT CONSTRAINTS:

Screen Design Layout Constraints for Racing Game

Type of
Component Background Size (Max Font Font Purpose of the
Validation
Type Color/Image Size) Type Size Component
Included

Solid green On Click event

Start Button 150x50 px Arial 16 px Starts the game.
color validation

Updates based
Transparent Displays current lap
Lap Counter 100x30 px Roboto 14 px on lap
background number.
completion

Image of speed 200x200 Real-time speed Shows the current

Speedometer NA NA
dial px validation speed.

Semi- Validates
Countdown Displays race
transparent 150x40 px Verdana 18 px countdown
Timer countdown.
overlay progression

Icon with dark OnClick pause

Pause Button 50x50 px NA NA Pauses the game.
background validation

Gradient 400x600 Sort and update Shows player

Leaderboard Helvetica 14 px
background px validation rankings.

How to Use This Design

1. Unity Components: Use Unity’s Canvas System to design UI elements. For example:
• Buttons: Use Unity's built-in Button component with On Click handlers.
• Text Elements: Use TextMeshPro for better font rendering.
• Images: Assign the required sprites for backgrounds or icons.
2. Validation Logic: Implement validation in scripts:

104 | P a g e
 • Use Unity Events (OnClick, OnValueChanged) for UI interactivity.
• Validate race data (e.g., laps, speed) using custom scripts.
3. Sizing and Placement:
• Design for adaptive UI using anchors and canvas scaling to support various screen
resolutions.
4. Purpose Documentation:
• Clearly outline the role of each component in your game's documentation to aid
collaboration.

105 | P a g e
 APPENDIX -- IV

Procedural Design Format:

Fig 11: Class Diagram

The class diagram code defines a system for a car game, with several classes representing
different components of the game. Here's a breakdown:

Classes and Their Members

1. Camera View Script

Methods:
+Start(): Public method to initialize the camera.
-DisableMainCamera(): Private method to disable the main camera.
-EnableCameraView(): Private method to enable a specific camera view.

106 | P a g e
2. Car Selection

Attributes:
-carList: List<Car>: Private list of cars available for selection.
Methods:
+Awake(): Public method triggered when the script is initialized.
+Start(): Public method called during the start of the game.
+PopulateCarList(): Public method to fill the car list.
+UpdateSelectedCar(): Public method to update the current selected car.
+SwitchCar(): Public method to switch between cars.

3. Player Car Controller

Attributes:
-accelerationForce: float: Private acceleration force applied to the car.
-maxSpeed: float: Private maximum speed of the car.
Methods:
+Update(): Public method called every frame.
+MoveCar(): Public method for moving the car forward/backward.
+CarSteering(): Public method for steering the car.

4. Opponent Car

Attributes:
-movingSpeed: float: Private speed of the opponent car.
-currentWaypoint: Waypoint: Private waypoint currently targeted by the car.
Methods:
+DriveToDestination(): Public method for driving towards a destination.

107 | P a g e
5. Opponent Car Waypoints

Attributes:
-waypoints: List<Waypoint>: Private list of waypoints.
Methods:
+LocateDestination(): Public method to locate a target destination.
+GetNextWaypoint(): Waypoint: Public method to get the next waypoint.

6. Waypoint

Methods:
+GetPosition(): Vector3: Public method to get the waypoint's position.

7. Timer

Attributes:
-currentTime: float: Private time counter.
Methods:
+StartCountdown(): Public method to start the countdown.
+SetAccelerationForce(float): Public method to adjust car acceleration.
+SetMovingSpeed(float): Public method to adjust opponent speed.

8. Finish

Attributes:
-status: string: Private status of the finish line.
Methods:
+OnTriggerEnter(): Public method triggered when an object enters the finish zone.
+DisplayEndScreen(): Public method to display the game-over screen.

108 | P a g e
9. Menu

Methods:
+LoadScene(scene: String): Public method to load a game scene.
+PauseGame(): Public method to pause the game.
+ResumeGame(): Public method to resume the game.

[Link]

Attributes:
-currentSpeed: float: Private speed value to display.
Methods:
+UpdateSpeedLabel(): Public method to update the speed text.
+UpdateArrowPosition(): Public method to move the speedometer arrow.

[Link]

Attributes:
-soundEffect: AudioSource: Private audio effect for the button.
Methods:
+OnClick(): Public method to handle button clicks.

[Link] Canvas

Methods:
+SetActive(status: bool): Public method to toggle canvas visibility.

[Link] UI

Methods:
+SetActive(status: bool): Public method to toggle map visibility.

109 | P a g e
Relationships Between Classes

• Camera View Script → Timer: The camera uses the timer functionality (uses >).
• Car Selection → Selection Canvas: Updates the selection canvas visibility (updates >).
• Car Selection → Map UI: Toggles the map's visibility (toggles >).
• Player Car Controller → Speedometer: Updates the speedometer based on the player's car speed (updates
>).

• Opponent Car → Opponent Car Waypoints: Gets path data from waypoints system (gets path from >).
• Finish → Timer: Controls the timer (e.g., stops it upon finishing) (controls >).
• Finish → Map UI: Toggles the visibility of the map (toggles >).

Explanation

• Camera View Script: Controls the camera views, enabling or disabling based on the game phase.
• Car Selection: Manages car selection, populates car options, and updates selected cars.
• Player Car Controller: Controls the player's car, including movement and steering.
• Opponent Car and Waypoints: Represents the opponent car's behavior and pathing system using
waypoints.
• Waypoint: Holds position data for each waypoint.
• Timer: Manages countdown and timing for acceleration and speed controls.
• Finish: Detects when the race finishes and displays end-game UI.
• Menu: Handles scene loading and pausing/resuming functionality.
• Speedometer: Updates the speed display based on player car speed.
• Skip Button: Manages the skip countdown action and plays a sound effect.
• Selection Canvas and Map UI: UI elements toggled by various actions in the game.

This structure gives a clear view of how classes interact and encapsulate functionality for different game
aspects.

110 | P a g e
 APPENDIX – V

DOCUMENTATION FOR TESTING:

[Link] Testing / Unit Testing

Test Cases Expected Results Pass Fail

Launch the game Game starts without errors ✓
Navigate menu All menu options are functional ✓
Start new game Game begins and loads the first level ✓
Car movement Car can move using wasd/ arrows ✓
Car speed control Break maintains the proper physics ✓
Car selection 3 cars can be selected as per choice ✓
Game mode section City,night,rainy modes can be selected ✓
Sound and music Audio plays correctly ✓

[Link] Testing Using Unity Test Frame Work And Nunit

Steps:

A. Navigate window tab>package manager> unity registry.

B. Download UTF (Unity Test Framework).
C. Go to project tab. right click. click on testing.
D. Create [Link] file and a [Link] file.

[Link]

using [Link];
using [Link];
using [Link];
using UnityEngine;

111 | P a g e
using [Link];
public class NewTestScript
{
// A Test behaves as an ordinary method
[Test]
public void NewTestScriptSimplePasses()
{
// Use the Assert class to test conditions
}
// A UnityTest behaves like a coroutine in Play Mode. In Edit Mode you can use
// `yield return null;` to skip a frame.
[UnityTest]
public IEnumerator NewTestScriptWithEnumeratorPasses()
{
// Use the Assert class to test conditions.
// Use yield to skip a frame.
yield return null;
}
}

Applied for all version for exe file

Fig 12: Check Box Select for all Devices

112 | P a g e
 Expected Results Pass/Fail
Compatible for all devices Pass

Fig 13: Automation Test Result

113 | P a g e