Undergraduate Final Year Project Handbook

Contents

List of Figures .................................................................................................................................. 4

Chapter 1 Introduction ...................................................................................................................... 5

1.1 3D Graphics ....................................................................................................................... 5

1.2 Impressive Result ............................................................................................................... 5

1.3 Graphical Effects ............................................................................................................... 6

1.4 Car Racing 3D ................................................................................................................... 6

1.5 Game Design and Concepts................................................................................................ 6

1.6 Relevance to Course Modules ............................................................................................ 6

1.7 Project Background ............................................................................................................ 7

1.8 Literature Review .............................................................................................................. 7

1.8.1 Analysis from Literature Review (in the context of your project) ................................ 9

1.9 Rationale behind Selected Methodology........................................................................... 11

1.10 Scope ............................................................................................................................... 11

Chapter 2........................................................................................................................................ 12

2.1 Requirement Analysis ...................................................................................................... 12

2.2 Nonfunctional Requirements ............................................................................................ 14

2.3 Functional Requirements.................................................................................................. 14

2.4 USE CASE DIGRAM. ..................................................................................................... 16

1
Undergraduate Final Year Project Handbook

2.5 USE CASE DISCRIPTION. ............................................................................................ 16

Chapter 3 Design and Architecture ................................................................................................. 18

3.1 System Architecture ......................................................................................................... 18

3.1.1 Process Flow/Representation .................................................................................... 19

3.1.2 DFD Level 0 ............................................................................................................. 20

3.1.3 DFD Level 1 ............................................................................................................. 20

Chapter 4 Implementation .............................................................................................................. 21

4.1 Algorithm ........................................................................................................................ 21

4.2 User Interface .................................................................................................................. 23

 Setting menu .................................................................................................................... 23

Chapter 5........................................................................................................................................ 25

Testing and Evaluation ................................................................................................................... 25

5.1 Manual Testing ................................................................................................................ 25

5.1.1 System testing ........................................................................................................... 25

5.1.2 Unit Testing .............................................................................................................. 25

5.2 Functional Testing ........................................................................................................... 27

5.3 Integration Testing ........................................................................................................... 28

Chapter 6........................................................................................................................................ 29

6.1 Conclusion ....................................................................................................................... 29

6.2 Future Work..................................................................................................................... 29

2
Undergraduate Final Year Project Handbook

References .................................................................................................................................. 31

3
Undergraduate Final Year Project Handbook

List of Figures
Fig 1.1 Block Diagram ................................................................................................................. 8

Fig 2.1 Use Case Diagram ........................................................................................................... 9

4
Undergraduate Final Year Project Handbook

Chapter 1
Introduction
Developing software applications is a time-consuming process, and with time-consuming
processes come high costs. During the last years, several software development methodologies,
often known as agile software development, have become widely used by software developers to
address this issue. Many different development methodologies can be more or less good, depending
of the task and application type. One of the software development methodologies is the evolutionary
software method, which, as the name hints, takes on an evolutionary approach to the problem, and
allows the project to evolve through different stages of the project. Our case study will show how
well this evolutionary approach worked on our project where we choose to develop a 3D graphic
computer game. Some requirements for the computer game were given from the beginning, such
as:

1.1 3D Graphics
The game must contain 3D models and render these in the game. 3D environments were never a
requirement, and platform games with 2D environment could still open up for 3D objects.

1.2 Impressive Result

The game result must impress whoever plays the game. It should last long, and make the players
come back and play it repeatedly.

5
Undergraduate Final Year Project Handbook

1.3 Graphical Effects

To achieve an impressive result, we would need to add modern graphical effects, such as real-time
rendered soft shadows, motion blur, and ambient occlusion.
Working with these requirements, we decided to use Unity Software as our platform to develop
our 3D game with. This decision was made about that the platform had many in-built tools and
provided a good framework for us to get started with the development as fast as possible. The fact
that UNITY also used C# as development language was also in consideration, since we wanted to
learn this newly developed C-based object-oriented language. The requirement for the game to
contain 3D graphics introduced an interesting challenge for the project group, since all had none
or little experience in 3D modelling. Spending time learning how to model proper 3D models for
our game was therefore necessary. During the research to find out what 3D modelling program to
use, we found that we could use different studios to create models that we could later import to our
game project. The complete game contains models made in both Blender and 3D Studio MAX.

1.4 Car Racing 3D

Car racing 3D is a thrilling and exciting super car racing simulation game. Be the best driver of
some of the fastest cars on the city streets in a collection of some of the world's most exciting sports
cars.

1.5 Game Design and Concepts

In this project, we were left free to decide what type of game we wanted to develop. The suggestion
Was that a racing game would be suitable, since such a game usually do not depend on advanced
assets, e.g. animated models. After some brainstorming, it was decided that a racing game should
be developed.

1.6 Relevance to Course Modules

Car racing 3D project is the combination of multiple courses which we study in our BSE program.
It consists on SE1, C#, AI, Computer Graphics and Human Computer Interaction. Setting of screen
resolution, pixels setting, and environment design concept take from the computer graphics course.
The competitors use AI to take turn and make decisions this concept is from artificial intelligence
course. Functional and non-functional requirements, software model and process of making
software concepts take from software engineering courses. The whole scripting of our project done
6
Undergraduate Final Year Project Handbook

in C# language. User interface (UI) and design of the game is built on the concepts of human
computer Interaction course.

1.7 Project Background

This project is creation and implementation of game using the UNITY tool and it is our Final year
project. The reasons for creating the game on the UNITY tool are many like we can convert it on
different platforms later on, we can easily control many mechanisms through graphics rather than
repetitive and redundant codes.

1.8 Literature Review

There has been substantial research work that focuses on developing AI-controlled components of
game systems, which can approximate or emulate human game playing styles. These components
are often referred to as “bots.” The motivation for developing the “bots” is that a human player’s
enjoyment in the gaming experience will be higher if he or she can be led to believe that the
opponents in the game are other human players. An example of this type of game is the popular
multiplayer first-person shooter game Counter- Strike, in which the objective is to eliminate all
players on the enemy or opponent team.
Similar AI-controlled components or “bots” also appear in the early video game of PacMan; the
computer-controlled ghosts in the maze can move towards the player- controlled characters
because the former incorporated some path finding algorithms. Other AI algorithms that were
adopted by games include finite state machines, fuzzy state machines, and decision trees. Decision
trees are used to represent the decision-making process involved in games like Checkers or Chess.
A decision tree can specify several possible game states given a current state and support a search
process for a goal state,

7
Undergraduate Final Year Project Handbook

where the human player is defeated provided the AI-controlled game can identify the path to the
goal state more efficiently than the human player.
In addition to decision trees, other AI techniques are also used for building bots so that they would
mimic or emulate human behavior. Khoo and Zubek discussed their use of a behavior-based action
selection technique in the software development kit (SDK) of Flexbot for developing an AI-
controlled bot, called Groo. Based on Groo, 32 bots were developed and can run simultaneously
on a single machine, and human players who played against the bots believed the bots effectively
emulated human behavior. Similarly, Tatai and Gudwin discussed the use of semiotics in their
development of a bot, which can assist or attack the human player in the game of Counter-Strike.
The objective of their work was to design the AI system so that the bot can entertain and challenge
the human player and not simply to defeat him or her. Therefore, the performance of the bot is
measured not by its efficiency in killing its opponents, but by its “capability to emulate as close as
possible all the activities commonly performed by a human player”. This consideration also means
that the bot cannot be seen to be waiting because human players expect bots to be continuously
working. Hence, the bot’s reaction time was one of the criteria in measuring its performance.
Similarly, in driving and racing games, human players expect to control their cars by making small
adjustments to the car’s direction while driving, just like how they would

8
Undergraduate Final Year Project Handbook

control a car in real life. Therefore, the race car bot must make continuous adjustments to its car’s
direction as opposed to simply driving in a straight line and turning only when a curve in the road
approaches. To ensure the race car bot can mimic human behavior in this manner, some AI
techniques were used for implementing the bots in Racer.

1.8.1 Analysis from Literature Review (in the context of your project)
After reviewing the games, we now must identify all the features that we would implement. We
have gained a lot of knowledge from our research; despite being an enthusiastic racing gamer, all
the games we tested were final products and due to the timescale, we will not be able to achieve a
project that is finished and can be put out to the general public to play without any hiccups. From
all the applications we tested, we identified the following core functions which we will implement:

1.8.2 Attractive user interface

The interfaces of the games tested are very appealing; each one also has a head up display showing
various in-game parameters.

1.8.3 Graphics
This is very important to make the game more appealing. Whole game is made by using HDR
pipeline or has HD visual effects.

1.8.4 Camera
Many virtual “cinema chine” cameras were placed in different locations for making many short
scenes or films in the game. But basically single main camera was used with the character which

9
Undergraduate Final Year Project Handbook

rotates around him to give the users 3D view experience and this was achieved by rotating the
mouse on the mouse pad.

1.8.5 Methodology and Software Lifecycle for This Project

In this software project the spiral model is used for development. The spiral model combines the
iterative nature of prototyping with the controlled and systematic aspects of the waterfall model,
there in providing the potential for rapid development of incremental versions of the software. In
this model the software is developed in a series of incremental releases with the early stages being
either paper models or prototypes. Later iterations become increasingly more complete versions of
the product.

10
 Undergraduate Final Year Project Handbook

1.9 Rationale behind Selected Methodology

Following reasons to select spiral model methodology.
The spiral model is a realistic approach to the development of large-scale software products because the
software evolves as the process progresses. In addition, the developer and the client better understand
and react to risks at each evolutionary level. The model uses prototyping as a risk reduction mechanism
and allows for the development of prototypes at any stage of the evolutionary development.
It maintains a systematic stepwise approach, like the classic life cycle model, but incorporates it into
an iterative framework that more reflects the real world. If employed correctly, this model will reduce
risks before they become problematic, as consideration of technical risks are considered at all stages.

1.10 Scope
 Project is run on windows.
 Requires at least 2GB GPU specification of device to play.
 Further update it and make it multiplayer game.

11
Undergraduate Final Year Project Handbook

Chapter 2
Software Requirement Specification (SRS)
2.1 Requirement Analysis
Requirements Analysis is a technique that translates the needs of the customer into technical
requirements for software/game. It concentrates on maximizing customer satisfaction from the
Software engineering process. With respect to our project the following requirements are identified
By a requirements analysis.
Normal Requirements.
Expected Requirements
Functional Requirements
Non-Functional Requirements
Technical requirements
Software Requirements.
2.1.1 Normal Requirements
Normal requirements consist of objectives and goals that are stated during the meeting with the
actor/gamer/relevant people.
Normal requirements of our project are as follows
User friendly efficient and lucrative system.
Minimum maintenance cost (may be graphics definition).
Availability of expected requirements within the PC configuration.

12
Undergraduate Final Year Project Handbook

Easy to operate.
They observe our game as this is built with professional manner.
The game with measured coding, professional thinking.
2.1.2 Expected Requirements
These requirements are implicit to the system and may be so fundamental that the actor/gamer/
relevant people do not explicitly state them. Their absence will be a cause for dissatisfaction.
Develop system within limited cost.
Maximum high definition.
Minimum hardware requirements which is relevant for this game.
Design whole system with efficient manner.
2.1.3 Technical Requirements
Technologies used- C#
Tools- Unity game engine
2.1.4 Software Requirements
Windows 8 and above
Adobe Photoshop CC 2017
Unity
Mono Developer
Adobe Fuse
Maya 2019
Visual-Studio 2017

13
 Undergraduate Final Year Project Handbook

2.2 Nonfunctional Requirements

Nonfunctional Requirements (NFRs) define system attributes such as security, reliability,
performance, maintainability, scalability and usability
o Compatibility
Compatible for windows 8 and above platform
o Compatible to requirements
Whole game features would be dependent on above functional requirements.
o Scalability
The scope of this game will be depended on time limit so our main focus would be
completing above functional requirements and each and every module.
o Fault-Tolerance
Different checks are included to resolve unaccepted errors during the game.
o Usability
It will be easy for targeted user to handle and master the controls of this game.
o Interoperability
Different tools (like Maya, unity, blender, photoshop, adobe fuse etc.) components are
integrated and operates simultaneously on unity 3D.
o Legal
All credit for models, animations, graphics, pictures etc. will be given to their original
creators at the end of this game.
o Reliability
This game will be reliable until all the conditions for system are met in users hardware.

2.3 Functional Requirements

1. You need to setup up a racing environment and place player car over it. For this purpose, you can
use free assets from asset store but only to avoid graphic designing.

14
Undergraduate Final Year Project Handbook

2. Must move player car by using Tilt or UI Buttons (Left, and Right).
3. There must be a forward button to speed up the car as well as a backward button which will
slow down the car.
4. Our game will contain some enemy cars which will move using Artificial Intelligence
(Automatically).
5. There must be a destination like house when car reaches to the destination, we will
display Game Over (In case if competitor reach to the destination) Or Wining Message (In case if
player reach to destination before competitor).
6. When game start player car will start from zero and speed will increase gradually (On
Forward button press) otherwise move with continuous velocity.
7. When Player car tries to reach near to the enemy (enemy car will speed it up).
8. You must prevent any enemy or player car from drop in space
9. Must move enemy cars different position not only in straight line.
10. You must use latest technology for building Graphical User Interface e.g. Canvas.

15
 Undergraduate Final Year Project Handbook

2.4 USE CASE DIGRAM.

2.5 USE CASE DISCRIPTION.

2.5.1 Use Case Description
 Game player wants to play the game.
2.5.2 Actors
 Game Player.

16
Undergraduate Final Year Project Handbook

2.5.3 Pre-conditions
o The machine should meet all the requirements of the game
o The player should start the game
o The player should select the desired car of his choice
o The player should also meet the other requirements of level if he wants to play the
level
o The player should also select the color of car as well
o After doing all the settings of a game the player should stat he game
2.5.4 Post conditions
 The selected car should be available for player in race
 The car should be of chosen color
 The controls should be active for the controlling of car directions
 The competitors’ cars should also be there for racing of game
 The counter to start the game should be there to indication of game play to the user.
 The other cars should be running when counter displays GO.

2.5.5 FLOW
 Go to the
garage.
 Select
the car.
 Start the
game.

17
Undergraduate Final Year Project Handbook

Chapter 3
Design and Architecture
3.1 System Architecture

18
 Undergraduate Final Year Project Handbook

3.1.1 Process Flow/Representation

19
 Undergraduate Final Year Project Handbook

3.1.2 DFD Level 0

3.1.3 DFD Level 1

20
Undergraduate Final Year Project Handbook

Chapter 4
Implementation
This chapter will discuss implementation details supported by UML diagrams (if applicable). You
will not put your source code here. Any of the following sections may be included based on your
project.

4.1 Algorithm
In this project we are using AI algorithm for the opponent car to race with player:

21
Undergraduate Final Year Project Handbook

22
Undergraduate Final Year Project Handbook

4.2 User Interface

 Main Menu

 Setting menu

23
Undergraduate Final Year Project Handbook

 Level selection

 Level 1

24
 Undergraduate Final Year Project Handbook

Chapter 5
Testing and Evaluation
5.1 Manual Testing
5.1.1 System testing
Entire system a testes as per the requirements black box testing that is based on over all
requirements specification, covers all combine parts of a system.

5.1.2 Unit Testing

Testing of individual software components or modules. Typically done by the programmer and or
by tester, as it requires detailed knowledge of the internal program design and code.
[Link] Testing Objective: Input Result

No. Test ID Test case Attribute and Expected result Result

value
1. 01 Verify user must User must Successfully Successfully
have install the install game in installed.
game on his have the machine
machine. machine that
full fills the
game
requirements.

25
Undergraduate Final Year Project Handbook

2. 02 Load main menu User click the After loading Main menu
game icon. game resources displayed to
main menu the user.
should be
displayed to user.

3 03 Garage button User click on Garage screen Screen with

garage button Should be car revolving
displayed with all and with
its working other options
functionality. visible to user

4 04 Setting button User click on Setting popup Setting popup

setting button window window
displayed to user. displayed to
user
5 05 exit button User click on Quit popup popup
exit button window displayed window with
to user 2 option
displayed to
user.

26
Undergraduate Final Year Project Handbook

5.2 Functional Testing

The functional testing will take place after the unit testing. In this functional testing, the
functionality of each of the module is tested. This is to ensure that the system produced meets the
specifications and requirements.
No. Test case/Test script Attribute and Expected result Result
value

1. Change color of car. Pick any color of The color of car Color changed
your choice should be changed respectively.
provide in game according to
menu. chosen color.

2. Confirmation dialogue If input of Game should exit. Successfully

of quit menu. confirmation Exit.
dialogue is yes.
3 Brake Control. Click on brake Speed of car is Slow down car.
button. reduced
immediately.

27
Undergraduate Final Year Project Handbook

4 Left or Right Control. Click on left or Car turn on right or Direction of car
right control. left. change directly
or easily.

5.3 Integration Testing

No. Test case/Test Attribute Prerequisites Expected result Result
script
and

value
1. Select Car Color. Click on garage. Game When click on Car color

Should be respective color. change

properly Car color should successfully.

installed on be selected

your accordingly.

machine.

2. Unlocked car. Click on If you have Car available. Now that’s

particular car. sufficient unlocked car

coins for that is available.

car.

28
Undergraduate Final Year Project Handbook

Chapter 6
Conclusion and Future Work
This chapter concludes the project and highlights future work.

6.1 Conclusion
The Speedo Car is a Unity 3D game that is a single player game and especially made for those who
love to play racing games such as car racing. This game is divided into 10 stages and each stage
has its laps. Players have to complete the race in order to complete the level. There are different
Cars do race with player and try to win the race. The Game will divide into 10 stages where every
stage has its own environment. After completing the race, the level will be completed and you can
jump to other level. The player’s car that run towards finish line, defeat the opponent cars and reach
the ending point. The player will start the game by selecting car and level. The car will have to race
to get high stars in the race and it comes when player get 1st position in the race and car can simply
beat the Artificial intelligence cars or defeat them. Every time Player gets some position and reward
according to its position Project is run on multiple platform like windows, android and iOS. Require
minimum specification of device to play. Further update it and make it multiplayer game

6.2 Future Work

Everything have a room for the improvement. The improvement can be done by making the current
features of the system more useful or by adding some new features to the system to facilitate the
users. In future, we move on this game into APK for mobile game would be added. Another future

29
Undergraduate Final Year Project Handbook

work is under consideration, that a live recording module will be added though which a user can
play in dual mode with other competitor. One more feature to be add is that we invite a friend to
play a game through social media. There are some other important features that counts as the part
of future work. Every time Player gets some position and reward according to its position Project
is run on multiple platform like windows, android and iOS. Require minimum specification of
device to play. Further update it and make it multiplayer game

30
Undergraduate Final Year Project Handbook

References
References to any book, journal paper or website should properly be acknowledged. Please

consistently follow the style. The following are few examples of different resources i.e. journal

article, book, and website.

1. Lyda M.S. Lau, Jayne Curson, Richard Drew, Peter Dew and Christine Leigh,

(1999), Use Of VSP Resource Rooms to Support Group Work in a Learning Environment,

ACM 99, pp-2. (Journal paper example)

2. Hideyuki Nakanishi, Chikara Yoshida, Toshikazu Nishmora and TuruIshada,

(1996), FreeWalk: Supporting Casual Meetings in a Network, pp 308-314 (paper on web)

[Link]

3. Ali Behforooz& Frederick [Link], (1996), Software Engineering Fundamentals,

Oxford University Press. Chapter 8, pp255-235. (book reference example)

4. Page Author, Page Title, [Link] Last date accessed.

(website)

31
Undergraduate Final Year Project Handbook

32