COVER PAGE

Submitted by,
MADHAV SURESH

1
INDEX
S.No CONTENTS PAGE
No.

1 ABSTRACT 4

2 INTRODUCTION 5

3 STRUCTURED ANALYSIS AND DESIGN 6

3.1 EXISTING SYSTEM 6

3.2 PROPOSED SYSTEM 6

3.3 FEASIBILITY STUDY 7-9

3.4 SYSTEM REQUIREMENTS 10-11

3.5 JAVA 11-12

3.5.1 Java Development Kit (JDK) 13

3.5.2 Other Technologies used 13-14

3.6 DATA FLOW DIAGRAM 14-17

3.6.1 Types of DFD 15

3.6.2 Basic Notations 16

3.7 DECISION TREE 18

4 SYSTEM DESIGN 19-20

2
5 CODING 21-45

6 SCREEN SHOTS 46-47

7 SYSTEM TESTING AND IMPLEMENTATION 48

7.1 SYSTEM TESTING 48-49

7.2 SYSTEM IMPLEMENTATION 50-51

8 SYSTEM MAINTENANCE 51-52

9 CONCLUSION 53

10 BIBLIOGRAPHY 54

3
1. ABSTRACT
Racing are always been one of the most popular type of project that
attracts students we have selected car race has our project as car race
are interesting and drag us to learn more about the subject. CAR RACE
is the game Played between the one or more cars. Racing is a
competition of a speed, against an objective criterion, usually a clock or
to a specific point. The competition in car race tries to complete a given
task in the shortest amount of time. The game is not to defeat a
The human player but to provide the player with a challenging and
enjoyable experience. This game is controlled in a two-dimension
environment. Our project has following tasks entry mode, car
movements, score, lives of players, action after collusions/dashing a car
and side walls.

4
2. INTRODUCTION

When it comes to building gaming applications, we always

think of racing games as we loved playing these types of games in our
childhood. So today in this article we will develop a Car Race Game
in Java with Swing.

This game needs no explanation, but still has a bit of context

for the game. The player’s car needs to race with the opponent’s cars
without hitting any one of them and maintaining a high speed. With
stunning graphics, and intuitive controls, this game promises to
deliver an immersive racing experience like no other.

5
3. STRUCTURE ANALYSIS AND DESIGN

3.1 EXISTING SYSTEM

The car race game in Java code provides a basic simulation of

a race between multiple cars on a track. The game consists of a track
with a fixed length and multiple cars participating in the race. There is
a nested class which represents each car in the race. Each car object
has a position on the track and methods to move forward randomly
and display its position. The main method initializes an array of cars
and starts the race simulation. In each round, each car moves forward
a random number of steps.

3.2 PROPOSED SYSTEM

The car race game in Java aims to enhance the existing

simulation with additional features and improvements. The proposed
system will include features for user interaction, allowing players to
control their cars or make strategic decisions during the race. The
game will incorporate graphical elements and visual effects to provide
a more immersive and engaging racing experience. This may include
animated cars, dynamic backgrounds etc. Overall aims to create a
more dynamic and immersive car racing experience, catering to both
casual players and enthusiasts alike.

6
3.3 FEASIBILITY STUDY
A feasibility study is an evaluation of a proposal designed
to determine the difficulty in carrying out a designated task.
Generally, a feasibility study precedes technical development
and project implementation. In other words, a feasibility study
is an evaluation or analysis of the potential impact of a proposed
project .

Technology and system feasibility

The assessment is based on an outline design of system

requirements in terms of Input, Processes, Output, Fields,
Programs, and Procedures. This can be quantified in terms of
volumes of data, trends, frequency of updating, etc. in order to
estimate whether the new system will perform adequately or not.
Technological feasibility is carried out to determine whether the
company has the capability, in terms of software, hardware,
personnel and expertise, to handle the completion of the project.

Economic feasibility

Economic analysis is the most frequently used method for

evaluating the effectiveness of anew system. More commonly
known as cost/benefit analysis, the procedure is to determine the
benefits and savings that are expected from a candidate

7
system and compare them with costs. If benefits outweigh costs,
then the decision is made to design and implement the system. An
entrepreneur must accurately weigh the cost versus benefits
before taking an action.

Cost Based Study: It is important to identify cost and benefit

factors, which can be categorized as follows:

1. Development costs

2. Operating costs. This is an analysis of the costs to be in the

system and the benefits derivable out of the system.

Time Based Study: This is an analysis of the time required to

achieve are turn on investments. The benefits derived from the
system. The future value of a project is also a factor.

Legal feasibility

Determines whether the proposed system conflicts with

legal requirements, e.g. a data processing system must comply
with the local Data Protection Acts.

8
Operational feasibility

Is a measure of how well a proposed system solves the

problems, and takes advantage of thein the requirements analysis
phase of system development .

Schedule feasibility

A project will fail if it takes too long to be completed before

it is useful. Typically this means estimating how long the system
will take to develop, and if it can be completed in a given time
period using some methods like payback period. Schedule
feasibility is a measure of how reasonable the project time table
is. Some projects are initiated with specific deadlines. You need
to determine whether the deadlines are mandatory or desirable.

9
3.4 SYSTEM REQUIREMENT

Hardware and Software requirements

Hardware Specification:

▪ IBMPC/AT Computer or above

▪ Processor

▪ Intel Pentium Core2Duo or above

▪ Memory

▪ RAM 1GB or above

▪ HDD 80.0GB or above

Software Specifications:

• Front end: Eclipse 2022-06(4.24.0)

• Back end: Eclipse 2022-06(4.24.0)

10
 • Operating system: windows NT/98/XP/2000

3.5 JAVA

Java is a programming language used for creating software that

makes it compatible with many different operating environments. It is
a two- stage programming language, meaning that it is a compiled
language and an interpreted one. However, it differs from most other
compiled languages because it does not compile directly to an
executable file.

In Java, the code is first compiled and then translated into a binary
form called Java Byte Code. Finally, the JBC gets compiled and
interpreted into the native language needed to run in the target operating
environment. This contrasting behaviour is a significant benefit for
developers as it means they can write code once and run it anywhere.

The important thing about Java that differentiates it from many

other technologies is that it is designed such that code written in Java
can be run on any system that a Java virtual machine(JVM) can run on.
This concept of write once, run anywhere was used as a slogan to
promote Java’s cross- platform abilities. Java environments can be
found on all sorts of devices, large and small, and therefore a Java
developer has more flexibility when it comes to being able to treat code
as agnostic to the system on which it runs.

11
 Java is still very popular and has expanded its reach into several
industries. Today Java issued for programming complex technologies
from mobile applications to AI programming and more.

Features of Java:

 Simple

 Secure

 Portable

 Object-Oriented

 Robust

 Multi-threaded

 Architecture-Neutral

 Interpreted

 High performance

 Distributed

 Dynamic

12
3.5.1 Java Development Kit (JDK):

The Java Development Kit (JDK) is across-platformed software

development environment that offers a collection of tools and libraries
necessary for developing Java-based software applications and
applets. It is a core package used in Java, along with the JVM (Java
Virtual Machine) and the JRE (Java Runtime Environment).

3.5.2 Other technologies used

Java Swing:

Java Swing is a GUI (graphical user Interface) widget toolkit for

Java. Java Swing is a part of Oracle’s Java foundation classes. Java
Swing is an API for providing graphical user interface elements to Java
Programs. Swing was created to provide more powerful and flexible
components than Java AWT (Abstract Window Toolkit).

Methods used:

✓ add(Component c):adds component to container.

13
 ✓ Add Action Listener Listener(ActionListener d) : add action
Listener for specified component
✓ Set Background(Color c): sets the background color of the
specified container
✓ Set Size(int a, int b): sets the size of container to specified
dimensions.
✓ setText(Strings): sets the text of the label to s.
✓ getText(): returns the text of the label.
Java AWT:

AWT (Abstract Window Toolkit) is an API that helps in building

GUI (Graphical User Interface) based java applications. GUI helps in
user interactions using some graphics. It primarily consists of a set of
classes and methods that are required for creating and managing the
GUI in a simplified manner such as buttons, windows, frame, text field,
Radio Button.

3.6 DATA FLOW DIAGRAM

A Data Flow Diagram (DFD) is a traditional visual representation

of the information flows within a system. A neat and clear DFD can
depict the right amount of the system requirement graphically. It can be
manual, automated, or a combination of both. It shows how data enters
and leaves the system, what changes the information, and where data is
14
stored. The objective of a DFD is to show the scope and boundaries of
a system as a whole. It may be used as a communication tool between
a system analyst and any person who plays a part in the order that acts
as a starting point for redesigning a system. The DFD is also called as
a data flow graph or bubble chart.

3.6.1 Types of DFD

Data Flow Diagrams are of two types:

• Physical DFD– This type of DFD depicts how the system will be
implemented or how the current system operates. The processes
represent the programs, program modules, and manual
procedures. The data stores represent the physical files and
databases, manual files.

• Logical DFD– Logical DFDS are the model of the proposed

system. They clearly should show the requirements on which the
new system should be built later during design activity this is
taken as the basis for drawing the system’s structure charts.

15
3.6.2 Basic Notations:

Data Flow

Process

Source

Data store

Decision

Input/output

16
DATA FLOW DIAGRAM

Use Case

17
3.7 DECISION TREE

Decision trees are a method for defining complex relationships

by describing decisions and avoiding the problems in communication.
A decision tree is a diagram that shows alternative actions and
conditions within horizontal tree framework. Thus, it depicts which
conditions to consider first, second, and soon.

18
4. SYSTEM DESIGN

The input module mainly describes the playing arena, speed of

the car and the score board of the game. The player will be able to
move the car left and right by pressing the left and right key. The
Score and Speed of the car are updated continuously as the car moves
ahead. If the car hits another car then the game is over and the player
can restart the game by pressing Enter Key.

19
5. CODING

import java.awt.Color;

import java.awt.Font;

import java.awt.Graphics;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import java.awt.event.KeyEvent;

import java.awt.event.KeyListener;

import java.io.IOException;

import java.util.Random;

import java.util.concurrent.TimeUnit;

import javax.imageio.ImageIO;

import javax.swing.ImageIcon;

import javax.swing.JFrame;

import javax.swing.Timer;

// this class is used to build the graphics and the game logic

class CarGame extends JFrame implements

KeyListener,ActionListener

20
{

private int xpos=300; // x position of the car

private int ypos=700; // y position of the car

private ImageIcon car; // car image

private Timer timer; // timer to update the screen

Random random=new Random(); // random number generator

private int num1=400,num2=0,num3=0; // x position of the

obstacles

private int tree1ypos=400,tree2ypos=-200,tree3ypos=-

500,tree4ypos=100,tree5ypos=-300,tree6ypos=500; // y position of
the obstacles

private int roadmove=0; // y position of the road

private int carxpos[]={100,200,300,400,500}; // x position of

the car

private int carypos[]= {-240,-480,-720,-960,-1200}; // y position

of the car

private int cxpos1=0,cxpos2=2,cxpos3=4; // x position of the car

21
 private int
cypos1=random.nextInt(5),cypos2=random.nextInt(5),cypos3=rando
m.nextInt(5); // y position of the car

int
y1pos=carypos[cypos1],y2pos=carypos[cypos2],y3pos=carypos[cypo
s3]; // y position of the car

private ImageIcon car1,car2,car3; // car image

private int score=0,delay=100,speed=90; // score,delay and

speed of the game

private ImageIcon tree1,tree2,tree3; // tree image

private boolean rightrotate=false,gameover=false,paint=false; //

boolean variables to control the game logic and the graphics

// constructor to initialize the game

public CarGame(String title)

super(title); // call the constructor of the parent class

JFrame

setBounds(300,10,700,700); // set the position and size of

the frame

setVisible(true); // make the frame visible

22
 setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); //
close the frame when the close button is clicked

setLayout(null); // set the layout of the frame to null

addKeyListener(this); // add the key listener to the frame

setFocusable(true); // set the focus to the frame

setResizable(false); // set the frame to be non resizable

// this method is used to paint the graphics on the screen

public void paint(Graphics g)

g.setColor(new Color(0X82CD47)); // set the color of the

grass

g.fillRect(0, 0, 700, 700); // draw the grass

g.setColor(new Color(0X9F8772)); // set the color of the

road

g.fillRect(90,0,10,700); // draw the road

g.fillRect(600, 0, 10, 700);

g.fillRect(100, 0, 500, 700);

23
// draw the road lines

if(roadmove==0)

for(int i=0; i<=700; i+=100)

{ // draw the road lines

g.setColor(Color.white);

g.fillRect(350, i,10, 70); //

roadmove=1; // set the roadmove to 1

else if(roadmove==1)

{ // draw the road lines again for the next frame

for(int i=50; i<=700; i+=100)

g.setColor(Color.white);

g.fillRect(350, i,10, 70);

roadmove=0; // set the roadmove to 0

24
 }

try {

tree1=new
ImageIcon(ImageIO.read(getClass().getResource("tree.png"))); // load
the tree image

} catch (IOException e) {

e.printStackTrace();

try {

tree2=new
ImageIcon(ImageIO.read(getClass().getResource("tree.png"))); // load
the tree image

} catch (IOException e) {

e.printStackTrace();

try {

25
 tree3=new
ImageIcon(ImageIO.read(getClass().getResource("tree.png"))); // load
the tree image

} catch (IOException e) {

e.printStackTrace();

tree1.paintIcon(this, g, 0, tree1ypos); // draw the tree image on

the screen

num1=random.nextInt(500); // generate a random number

tree1ypos+=50; // increment the y position of the tree

tree2.paintIcon(this, g, 0,tree2ypos ); // draw the tree image on

the screen

tree2ypos+=50; // increment the y position of the tree

tree3.paintIcon(this,g,0,tree3ypos); // draw the tree image on the

screen

tree3ypos+=50; // increment the y position of the tree

tree1.paintIcon(this,g,600,tree4ypos);

tree4ypos+=50;

26
tree3.paintIcon(this, g,600,tree5ypos);

tree5ypos+=50;

tree2.paintIcon(this, g,600,tree6ypos);

tree6ypos+=50;

if(tree1ypos>700)

{ // if the tree goes out of the screen then reset the tree

num1=random.nextInt(500); // generate a random number

tree1ypos=-num1; // reset the y position of the tree

if(tree2ypos>700)

num1=random.nextInt(500);

tree2ypos=-num1;

if(tree3ypos>700)

num1=random.nextInt(500);

tree3ypos=-num1;
27
}

if(tree4ypos>700)

{ // if the tree goes out of the screen then reset the tree

num1=random.nextInt(500);

tree4ypos=-num1;

if(tree5ypos>700)

num1=random.nextInt(500);

tree5ypos=-num1;

if(tree6ypos>700)

{ // if the tree goes out of the screen then reset the tree

num1=random.nextInt(500);

tree6ypos=-num1;

// load image for car

try {
28
 car=new
ImageIcon(ImageIO.read(getClass().getResource("gamecar3.png")));
// load the car image

} catch (IOException e) {

e.printStackTrace();

// car=new ImageIcon("gamecar1.png");

car.paintIcon(this,g,xpos,ypos); // draw the car image on

the screen

ypos-=40;

if(ypos<500)

ypos=500;

// load the opponent image for car

try {

29
 car1=new
ImageIcon(ImageIO.read(getClass().getResource("gamecar1.png")));

} catch (IOException e) {

e.printStackTrace();

// load the opponent image for car

try {

car2=new
ImageIcon(ImageIO.read(getClass().getResource("gamecar2.png")));

} catch (IOException e) {

e.printStackTrace();

// load the opponent image for car

try {

car3=new
ImageIcon(ImageIO.read(getClass().getResource("gamecar4.png")));

} catch (IOException e) {

e.printStackTrace();

30
 car1.paintIcon(this, g, carxpos[cxpos1], y1pos); // draw the
opponent car image on the screen

car2.paintIcon(this, g, carxpos[cxpos2], y2pos);

car3.paintIcon(this, g, carxpos[cxpos3], y3pos);

y1pos+=50; // increment the y position of the opponent car

y2pos+=50;

y3pos+=50;

if(y1pos>700)

{ // if the opponent car goes out of the screen then reset the
opponent car

cxpos1=random.nextInt(5); // generate a random

number

cypos1=random.nextInt(5);

y1pos=carypos[cypos1]; // reset the y position of the

opponent car

if(y2pos>700)

{ // if the opponent car goes out of the screen then reset the
opponent car

cxpos2++;

31
 if(cxpos2>4)

cxpos2=0;

cxpos2=random.nextInt(5);

cypos2=random.nextInt(5);

y2pos=carypos[cypos2];

if(y3pos>700)

cxpos3++;

if(cxpos3>4)

cxpos3=0;

cxpos3=random.nextInt(5);

cypos3=random.nextInt(5);

y3pos=carypos[cypos3];
32
}

if(cxpos1==cxpos2 && cypos1>-100 && cypos2>-100)

cxpos1-=1;

if(cxpos1<0)

cxpos1+=2;

if(cxpos1==cxpos3&& cypos1>-100 && cypos3>-100)

cxpos3-=1;

if(cxpos3<0)

cxpos3+=2;

if(cxpos2==cxpos3&& cypos3>-100 && cypos2>-100)

{
33
 cxpos2-=1;

if(cxpos2<0)

cxpos2+=2;

if(cxpos1<2 && cxpos2<2 && cxpos3<2)

if(cxpos1==0 && cxpos2==0 && cxpos3==1)

cxpos3++;

cxpos2++;

else if(cxpos1==0 && cxpos2==1 && cxpos3==0)

cxpos3++;

cxpos2++;

else if(cxpos1==1 && cxpos2==0 && cxpos3==0)

{
34
 cxpos1++;

cxpos2++;

// if the opponent car hits the player car then reset the
game

if(y1pos<ypos && y1pos+175>ypos &&

carxpos[cxpos1]==xpos)

gameover=true;

if(y2pos<ypos && y2pos+175>ypos &&

carxpos[cxpos2]==xpos)

gameover=true;

if(y3pos<ypos && y3pos+175>ypos &&

carxpos[cxpos3]==xpos)

35
 gameover=true;

if(ypos<y1pos && ypos+175>y1pos &&

carxpos[cxpos1]==xpos)

gameover=true;

if(ypos<y2pos && ypos+175>y2pos &&

carxpos[cxpos2]==xpos)

gameover=true;

if(ypos<y3pos && ypos+175>y3pos &&

carxpos[cxpos3]==xpos)

gameover=true;

//score

g.setColor(Color.red);

36
g.fillRect(120,35,220,50);

g.setColor(Color.black);

g.fillRect(125,40, 210, 40);

g.setColor(Color.red);

g.fillRect(385,35,180,50);

g.setColor(Color.black);

g.fillRect(390,40, 170, 40);

g.setColor(Color.white);

g.setFont(new Font("MV Boli",Font.BOLD,30));

g.drawString("Score : "+score, 130, 67);

g.drawString(speed+" Km/h", 400, 67);

score++; // increment the score

speed++; // increment the speed

if(speed>140)

{ // if the speed is greater than 140 then reset the speed

speed=240-delay;

if(score%50==0)

{ // if the score is divisible by 50 then increase the delay

37
 delay-=10;

if(delay<60)

delay=60; // set the delay to 60

//delay

try

TimeUnit.MILLISECONDS.sleep(delay); // delay
the game

catch (InterruptedException e) {

e.printStackTrace();

if(y1pos<ypos && y1pos+175>ypos &&

carxpos[cxpos1]==xpos)

gameover=true;

38
 }

if(y2pos<ypos && y2pos+175>ypos &&

carxpos[cxpos2]==xpos)

gameover=true;

if(y3pos<ypos && y3pos+175>ypos &&

carxpos[cxpos3]==xpos)

gameover=true;

if(gameover)

g.setColor(Color.gray);

g.fillRect(120, 210, 460, 200);

g.setColor(Color.DARK_GRAY);

g.fillRect(130, 220, 440, 180);

g.setFont(new Font("MV Boli",Font.BOLD,50));

g.setColor(Color.red);

39
 g.drawString("Game Over !",210, 270);

g.setColor(Color.white);

g.setFont(new Font("MV Boli",Font.BOLD,30));

g.drawString("Press Enter to Restart", 190, 340);

if(!paint)

repaint();

paint=true;

else

repaint();

public static void main(String args[])

CarGame c=new CarGame("Car Racing Game");

}
40
 @Override

public void keyPressed(KeyEvent e) {

if(e.getKeyCode()==KeyEvent.VK_LEFT && !gameover)

{ // if the left key is pressed then move the car to the left

xpos-=100;

if(xpos<100)

xpos=100; // set the car to the left most position

if(e.getKeyCode()==KeyEvent.VK_RIGHT&&!gameover)

{ // if the right key is pressed then move the car to the

right

xpos+=100;

if(xpos>500)

41
 xpos=500; // if the car is at the right most
position then don't move it

if(e.getKeyCode()==KeyEvent.VK_ENTER &&
gameover)

{ // if the game is over and the enter key is pressed then

restart the game

gameover=false;

paint=false;

cxpos1=0;

cxpos2=2;

cxpos3=4;

cypos1=random.nextInt(5); // randomize the position

of the opponent cars

cypos2=random.nextInt(5);

cypos3=random.nextInt(5);

y1pos=carypos[cypos1]; // set the position of the

opponent cars

y2pos=carypos[cypos2];

y3pos=carypos[cypos3];

42
 speed=90; // set the speed to 90

score=0; // set the score to 0

delay=100; // set the delay to 100

xpos=300; // set the position of the player car to the

center

ypos=700; // set the position of the player car to the

bottom

@Override

public void keyReleased(KeyEvent arg0) {

// TODO Auto-generated method stub

@Override

public void keyTyped(KeyEvent e) {

if(e.getKeyChar()=='a'&&!gameover)

{ // if the key pressed is 'a' then move the car left

xpos-=100; // decrement the xpos by 100

43
 if(e.getKeyChar()=='s'&&!gameover)

{ // if the key pressed is 's' then move the car right

xpos+=100; // increment the xpos by 100

repaint();

@Override

public void actionPerformed(ActionEvent arg0) {}

44
6. SCREEN SHOTS

45
46
7. SYSTEM TESTING AND IMPEMENTATION

7.1 SYSTEM TESTING

Testing is a set of activities that can be planned in advance and

conducted systematically. The proposed system is tested in parallel
with the software that consists of its own phases of analysis,
implementation, testing and maintenance. Following are the tests
conducted on the system.

❖ BlackBox Testing: Black Box Testing is a software testing method

in which the functionalities of software applications are tested without
having knowledge of internal code structure, implementation details
and internal paths. It is also known as Behavioral Testing.

❖ WhiteBox Testing: WhiteBox Testing is a testing technique in

which software’s internal structure, design, and coding are tested to
verify input-output flow and improve design, usability, and security. It
is also known as transparent testing or open box testing

❖ Unit Testing: Unit testing is a type of software testing where

individual units or components of software are tested. The purpose is
to validate that each unit of the software code performs as expected.

47
Testing is done during the development (coding phase) of an
application by the developers.

❖ Integration Testing: Integration testing is a level of software testing

where individual units/components are combined and tested as a group.
The purpose of this level of testing is to expose faults in the interaction
between integrated units. It occurs after unit testing and before system
testing.

❖ System Testing: System Testing is a level of testing that validates

the complete and fully integrated software product. The purpose of a
system test is to evaluate the end-to-end system specifications. It is end- to-
end testing where the testing environment is similar to the production
environment.

48
7.2 SYSTEM IMPLEMENTATION

The implementation is the final and important phase. It involves

user training, system testing in order to ensure successful running of
the proposed system. Once the system phase is over, the next stage is
to implement and monitors the operation of the system to ensure that it
continues the work effectively and efficiently.

There are three types of implementations:

i. Implementation of a computer system to replace a manual system.

The problems encountered are converting files, training users, creating
accurate files.

ii. Implementation of a new computer system to replace an existing one.

This is usually a different conversion. If not properly planned, there can
be many problems. Some large computer systems have taken as long as
a year to convert.

iii. Implementation of a modified application to replace the existing

one, using the same computer. This type of conversion is relatively easy
to handle, provided there are major changes in the files. Every system
requires periodic evaluation after implementation.

49
 This is to review the performance of the system and to
evaluate against established standard or criteria. A study is conducted
for measuring the performance of the system against pre-defined
requirements. This study results a post- implementation review that
determines how well the system continues to meet the performance
specification.

8. SYSTEM MAINTENANCE

Maintenance means restoring something to its original

conditions. Enhancement means adding, modifying the code to support
the changes in the user specification. System maintenance conforms the
system to its original requirements and enhancement adds to system
capability by incorporating new requirements.

Thus, maintenance changes the existing system, enhancement

adds featurest to the existing system, and development replaces the
existing system. It is an important part of system development that
includes the activities which corrects errors in system design and
implementation, updates the documents, and tests the data.

50
Maintenance Types:

System maintenance can be classified into three types:

• Corrective Maintenance: Enables user to carry out the repairing

and correcting the left over problems
• Adaptive Maintenance: Enables user to replace the functions of
the programs.
• Perfective Maintenance: Enables user to modify or enhance the
programs according to the user’s requirements and changing
needs.

51
 9. CONCLUSION

It was a wonderful learning experience for me working on this

project. This project took me through various phase of android
development and gave real insight into the world of software
engineering. The joy of working and the thrill involved while tackling
the various problems and challenges gave me feel of the developer’s
industry.

The car race game project has been a rewarding journey,

offering valuable learning opportunities and insights into software
development. It serves as a testament to our skills and creativity in
creating interactive and enjoyable gaming experiences using Java
programming. As we continue to refine and expand upon this project,
we look forward to further challenges and opportunities in the field of
game development. The development of the car race game in Java has
been an enriching experience, providing valuable insights into game
development concepts and Java programming techniques. This project
aimed to create a simple yet engaging racing game that demonstrates
fundamental game mechanics such as player control, collision
detection, scoring, and dynamic difficulty scaling.

52
10. BIBLIOGRAPHY

https://www.coursehero.com/file/158595623/car-racing-gamedocx/

https://www.hindawi.com/journals/ijcgt/2015/839721/

https://www.coursehero.com/file/84928377/Synopsis-For-Car-
Racing-Gamedocx/

https://copyassignment.com/simple-car-race-game-in-java/

https://www.slideshare.net/ravijotsingh4/report-on-car-racing-game-
for-android

https://code-projects.org/car-racing-game-in-java-with-source-code/

53