INDUSTRIAL TRAINING REPORT

ON
Java

SUBMITTED IN PARTIAL FULFILMENT OF THE

REQUIREMENTS FOR THE AWARD OF

Degree of Bachelor of Technology in Computer Science & Engineering

Submitted By
Name: Jatin
University Roll No :- 2221280

Department of Computer Science & Technology

CGC COLLEGE OF ENGINEERING, LANDRAN
CERTIFICATE

1
 ACKNOWLEDGMENT

I take this opportunity to express my sincere gratitude to the principal CGC College
of Engineering Landran for providing this opportunity to carry out the present work.
I am highly grateful to the Dr. Anuj Kumar Gupta HOD CSE, CGC College of
Engineering, Landran (Mohali), for providing this opportunity to carry out the six
weeks industrial training at Solitaire Infosys. I would like to expresses my gratitude
to other faculty members of Computer Science & Engineering department of CGC
COLLEGE OF ENGINEERING, Landran for providing academic inputs, guidance &
Encouragement throughout the training period. I would like to express a deep sense
of gratitude and thank Department Of CGC College of Engineering, without whose
permission, wise counsel and able guidance, it would have not been possible to
pursue my training in this manner. Finally, I express my indebtedness to all who have
directly or indirectly contributed to the successful completion of my industrial
training.

2
 TABLE OF CONTENT

1. Introduction
 Overview of the Quiz Application
 Purpose of the Project
 Tools and Technologies Used

2. Quiz Application: An Introduction

 What is Quiz Application?
 Key Features of Quiz Application
 Quiz Application Role in the Project

3. Application Mechanics
 Hardware and software
 Description of Application
 Physics and Mechanics of the Quiz Application
 Scoring System

4. Code Structure and Implementation

 Main Components of the Code
 Flow of the Program
 User Interaction Handling

5. Detailed Explanation of Methods and Functions

 welcome screen()
 mainApplication()
 isCollide()
 getRandomPipe()
 gameOver()
 main()

6. Application Functions and Methods Used

 app.init()
 app.display.set_mode()
 Event Handling with app
 Blitting: Displaying Images
 Sound Playback with app
7. Application Assets and Resources
 Images and Sprites
 Sound Effects
 Game Background
8. Quiz Snapshots
 Source Code
 Snapshots
9. Conclusion
 Summary of the Project
 Achievements and Learning
3
 Introduction

Overview of Quiz Application :

A quiz application is a software or web-based platform designed to facilitate
quizzes, tests, or assessments. These applications are used for a variety of
purposes, including education, entertainment, and employee training. Here's an
overview of the components and functionalities typically found in a quiz
application.

Purpose of the Project:

Quiz applications serve various purposes across different domains. Here are some
common purposes of quiz applications:

Education and Learning:

Reinforce Learning: Quiz apps are used in education to reinforce the material
covered in class. They provide a structured way for students to review and practice
what they've learned.
Assess Knowledge: Teachers can use quizzes to assess students' understanding of a
subject, identify areas of weakness, and tailor future lessons accordingly.
Test Preparation: Students preparing for exams, such as standardized tests or , use
quiz applications to practice and gauge their readiness.

Tools and Technologies Used:

Java Programming Language: Java is a versatile programming

language, and it can be used in various ways to develop different
components of a quiz application. Here are some common areas where
Java might be used in a quiz application

4
 Quiz Appliation: AN INTRODUCTION
What is Quiz Application?
A quiz application is a software or web-based platform designed to facilitate
quizzes, tests, or assessments. These applications are used for a variety of
purposes, including education, entertainment, and employee training. Here's an
overview of the components and functionalities typically found in a quiz
application.

Key Features of Quiz Application

Key features of a quiz application can greatly influence its usability, engagement,
and effectiveness. Here are some important features that a quiz application should
typically have:

User Authentication and Registration:

Allows users to create accounts, log in, and manage their profiles. This helps in
tracking progress and maintaining personalized data.
Quiz Creation and Management:

Admins can create quizzes, specifying details like title, description, duration,
passing score, and difficulty level. They can add questions with options and correct
answers.

Various Question Types:

Supports different question formats, such as Multiple Choice Questions (MCQs),
True/False, Fill in the Blanks, Matching, Short Answer, and Essay.

Quiz Taking Interface:

Provides a user-friendly interface for users to select quizzes and answer questions.
Questions are presented one at a time with answer options.

Timer and Time Limits:

Optionally includes a timer for quizzes with time limits, creating a sense of urgency
and enhancing the challenge..

Application Role in the Project

In a quiz application project, there are several key roles that individuals or team
members may take on to ensure the successful development and deployment of the
application. Here are the main roles and their responsibilities:

Project Manager:
Responsible for overseeing the entire project and ensuring it meets its objectives
within the specified time frame and budget.
5
Plans and schedules tasks, allocates resources, and manages risks.
Acts as the main point of contact between stakeholders and the development team.
System Architect/Designer:

Designs the overall architecture and structure of the quiz application.

Defines the technology stack, databases, and system components needed for the
application.

Ensures that the system is scalable, secure, and capable of handling expected user
loads.

Backend Developer:
Responsible for building the server-side logic, databases, and APIs required for the
quiz application.

Implements features like user authentication, quiz creation, score calculation, and
database management.
Frontend Developer:

Focuses on building the user interface (UI) of the quiz application.

interactive and user-friendly interfaces for quiz taking, registration, authentication,
and profile management.
Database Administrator (DBA):

Designs, implements, and manages the database system that stores quiz data, user
Information, and scores.
Ensures data integrity, security, and optimal performance.

Quality Assurance (QA) Tester:

Conducts testing to identify and report bugs, errors, and usability issues in the
application.
Performs unit testing, integration testing, and user acceptance testing (UAT) to
validate the functionality.

UX/UI Designer:
Designs the user experience (UX) and user interface (UI) of the application.
Focuses on creating an intuitive and visually appealing layout for the quiz app.

Content Creator/Subject Matter Expert:

Creates user manuals, documentation, and guides for the quiz application to help
users understand and navigate the platform.
Support and Maintenance Team:

Provides ongoing support for users, addresses technical issues, and performs
maintenance tasks such as updates, patches, and bug fixes.
These roles may vary depending on the size and complexity of the project,.
6
 HARDWARE AND SOFTWARE

Hardware:
1. System Requirements:
 List the minimum system requirements for running the game, such
as:
 Operating System(Windows / MacOS)
 Processor (i5 or more ryzen 5 or more)
 RAM(8 GB)
2. Input Devices:
 Any input devices required to interact with the Application, suchas:
 Keyboard
3. Display:
 Any display device with resolution 1080 x 420 or more
4. Sound Output:
 Any audio devices such as inbuilt laptop speaker or external
speakers

Software:

1. Programming Language:
 Specify the programming language used to develop the game. In this
case, it's likely Python.
2. Game Engine or Framework:
 If applicable, mention any game engine or framework used to build
the game. If you used a game development library like Pygame,
explain its role in simplifying game development tasks.
3. Version Control:
 If you used version control tools like Git, mention how they were
utilized to track changes and collaborate on the project.
4. IDE or Text Editor:
 Indicate the integrated development environment
NETBEANS(IDE) or text editor used for coding the game.

7
 Application Mechanics

Description of Quiz Application

A quiz application is a software platform designed to facilitate quizzes, tests, or
assessments. It provides a structured environment for users to answer questions on
various topics, with the application automatically scoring their responses. These
applications are used in a wide range of contexts, including education, training,
entertainment, and market research

Physics and Mechanics of the Game

Object-Oriented Design:
Identify the key components of your quiz application, such as quizzes, questions,
answers, users, and scores. Create corresponding classes to represent these entities.

User Authentication and Registration:

Implement a system for users to create accounts and log in. This might involve
creating a User class with attributes like username, password, and email.

Quiz Creation and Management:

Design a system for admins to create quizzes. This could involve a Quiz class with
attributes like title, description, duration, passing score, and difficulty level.

Questions and Answers:

Create a Question class and an Answer class. A Question object should have
attributes like the actual question text and a list of possible answers. Each Answer
object should have a boolean attribute indicating whether it's correct or not.

Quiz Taking Interface:

Design the user interface for taking quizzes. This could involve presenting questions
one at a time and allowing the user to select an answer.

Scoring System
A scoring system in a quiz application is crucial for evaluating a user's performance
after completing a quiz. It assigns points or scores based on the correctness of their
answers.
Main Components of the Code
The Quiz Application code is organized into several key components, each
serving a specific purpose in creating a cohesive and interactive gameplay
experience. These components include:

Importing Necessary Libraries: The code begins by importing essential

libraries required for the game's functionality. The `random` and `sys` libraries
are imported for generating random numbers and system-related functions. The
`pygame` library is the heart of the project, providing tools for graphics rendering,
8
 event handling, and sound playback.

Global Variables: The code defines several global variables that determine
crucial aspects of the game, such as frame rate, screen dimensions, sprite paths,
and gameplay constants. These variables ensure consistency and ease of
customization throughout the code.

Functions: The code comprises a series of functions responsible for different

aspects of the game. These functions include `welcomeScreen()`, `mainGame()`,
`isCollide()`, and `getRandomPipe()`. They encapsulate specific functionalities
and contribute to the overall gameplay flow.

Pygame Initialization: The App library is initialized using the

` app.init()` function. This step prepares app modules for use and sets the stage
for creating the game environment.

Game Asset Loading: The code loads various game assets, such as images,
sound effects, and background graphics, using the `pygame.image.load()` and
`app.mixer.Sound()` functions. These assets are essential for creating the visual
and auditory components of the game.

Game Loop and Execution: The main execution of the game occurs within a
loop. The `welcomeScreen()` function is called first to display the game's
welcome screen and instructions. Once the player initiates the game by pressing
a key, the `mainGame()` function is executed, driving the core gameplay loop.
This loop handles user inputs, updates the positions of game elements, detects
collisions, and manages the display.

Flow of the Program

The flow of the program can be summarized as follows:

1. Library Import: The necessary libraries (`random`, `sys`, and `App `) are
imported to provide essential functionalities for the game.
2. Global Variable Definitions: Global variables are defined, including screen
dimensions, sprite paths, and gameplay constants, to ensure consistency and
modularity.

3. Function Definitions: The functions `welcomeScreen()`, `mainGame()`,

`isCollide()`, and `getRandomPipe()` are defined to encapsulate specific aspects
of the game logic.

4. Application Initialization: The Pygame library is

initialized using
`pygame.init()`, setting the stage for graphical and audio operations.

9
5. Game Asset Loading: Game assets, such as images and sound effects, are
loaded using appropriate Pygame functions. These assets contribute to the game's
visual and auditory experience.

6. Welcome Screen Display: The `welcomeScreen()` function is called to

display the welcome screen and instructions. The game waits for the player to
initiate the game by pressing a key.

7. Main Gameplay Loop: The `mainGame()` function is called to start the core
gameplay loop. This loop continuously updates the positions of game elements,
checks for collisions, handles user inputs, and manages the display.

8. Loop Continuation: The main gameplay loop continues until a collision

occurs or the player exits the game. Upon collision or game exit, the loop
terminates, and the game execution concludes.

User Interaction Handling

The game interacts with the player through various means:

Welcome Screen: The welcome screen prompts the player to start the game by
pressing a key (space or up arrow). The `welcomeScreen()` function waits for the
player's input to proceed.

Main Gameplay Loop: The `mainGame()` function captures user inputs during
the gameplay loop. The player's use of the spacebar or up arrow key causes the
bird to flap and alter its vertical motion.

Event Handling: Pygame's event handling mechanism is crucial for capturing

user inputs. Events, such as key presses and window close events, are retrieved
using `app.event.get()`. These events are processed within the game loop to
trigger specific actions, such as bird flapping or game termination.
This well-structured code design ensures that the game's functionalities are
modular, making it easier to maintain, debug, and extend in the future. By
breaking down the game logic into functions and following a clear flow of
execution, the code promotes readability and efficient development.

10
11
 Detailed Explanation of Methods and Functions

1. welcomeScreen()
The welcomeScreen() function serves as the initial interaction point between the
player and the game. When the game is launched, this function displays the
welcome screen with relevant graphics and instructions. The primary purpose of
this function is to provide the player with information about the game and prompt
them to start playing.
Inside the welcomeScreen() function:
 The screen is cleared and filled with the background image using
SCREEN.blit().
 The bird and the game's message are positioned on the screen.
 A loop is used to continuously update the screen until the player initiates
the game by pressing the spacebar or up arrow key.
 During this loop, the function waits for the player to either start the game
or exit by clicking the cross button or pressing the escape key.
 The function handles all relevant events using pygame.event.get() and
event.type checks.

2. mainGame()
The mainGame() function is the core of the Flappy Bird gameplay. It controls the
entire gameplay loop, managing the bird's motion, pipe generation, collision
detection, scoring, and the overall display. This function is executed once the
player starts the game from the welcome screen.
Inside the mainGame() function:
 The player's input is processed to make the bird flap when the spacebar or
up arrow key is pressed.
 The game continuously updates the positions of the bird and pipes based
on their velocities and movements.
 Collision detection is performed using the isCollide() function to check for
collisions between the bird and pipes or the ground.
 The game keeps track of the player's score, which is incremented each time
the bird successfully passes through a pair of pipes.
 New pipes are generated and added to the game as existing pipes move off
the screen.
 The game screen is updated with the latest positions of the bird, pipes, and
score.
 The game loop continues to run until a collision is detected, at which point
the gameOver() function is called.

3. isCollide()
The isCollide() function is responsible for detecting collisions between the bird
and the game environment, including pipes and the ground. It returns True if a
collision is detected and False otherwise.
Inside the isCollide() function:
12
 • The function checks whether the bird has hit the ground or has collided
with either an upper or lower pipe.
 If the bird's position is outside the allowed vertical range or if its
coordinates overlap with those of a pipe, a collision is considered to have
occurred.

4. getRandomPipe()
The getRandomPipe() function generates the positions of upper and lower pipes
for the game. It ensures that the pipes are positioned at random heights, creating
the challenging gaps that the player must navigate through.
Inside the getRandomPipe() function:
 The function calculates the height of the gap between pipes based on the
screen height and a predefined offset.
 Random values are used to determine the vertical positions of the upper
and lower pipes, ensuring variety and unpredictability.

5. gameOver()
The gameOver() function handles the transition from active gameplay to the
game over state. It displays the final score to the player and provides the option
to restart the game.
Inside the gameOver() function:
 The screen is cleared and the background is displayed.
 The player's score is shown on the screen.
 The function waits for the player to press the spacebar or up arrow key to
restart the game or exit.

6. main()
The main() function serves as the entry point of the program. It initializes
Pygame, loads game assets, and manages the flow of the game by calling the
welcomeScreen() and mainGame() functions.
Inside the main() function:
 Pygame is initialized using pygame.init().
 Game assets, including images and sound effects, are loaded.
 The welcomeScreen() function is called to display the welcome screen and
instructions.
 Once the player initiates the game, the mainGame() function is executed
to start the core gameplay loop.
Overall, these functions collectively create a cohesive and engaging Flappy Bird
game experience, managing interactions, gameplay mechanics, and user interface
elements. The modular design and clear separation of concerns contribute to code
readability, maintainability, and efficient development.

13
 Quiz Application Functions and Methods Used
Analytics and Reporting:
generateQuizReport(quizID): Creates a report summarizing the performance of
users in a quiz.
Customization and Branding:
customizeTheme(themeAttributes): Applies custom themes and styling to the
application.

Accessibility and Multilingual Support:

setLanguagePreference(userID, language): Allows users to choose their preferred
language for the application.

Security and Privacy:

encryptPassword(password): Encrypts a password before storing it in the database.
checkPermissions(userID, action): Verifies if a user has the necessary permissions
for a specific action.

Notifications:
sendNotification(userID, message): Sends a notification to a specific user.

Content Management:
addContent(contentType, contentDetails): Adds new content (e.g., questions,
quizzes) to the database.

Help and Support:

getFAQs(): Retrieves a list of frequently asked questions for user support.
submitSupportTicket(userID, issueDescription): Allows users to report problems or
request assistance.

Gamification Elements:
awardBadge(userID, badgeType): Grants badges or achievements to users for
specific accomplishments.

Integration with Other Platforms:

shareQuizResults(userID, quizID, platform): Integrates with social media platforms
for result sharing.

Feedback and Reviews:

submitFeedback(userID, feedbackDetails): Allows users to provide feedback on the
application or specific quizzes

14
 QUIZ APPLICATION ASSESTS AND
RESOURCES
A quiz application typically involves a variety of functions and methods to
handle different aspects of the application. Below are some common functions
and methods used in a quiz application:

User Authentication and Registration:

registerUser(username, password, email): Registers a new user with the given
credentials.
loginUser(username, password): Authenticates a user based on their username
and password.

Quiz Creation and Management:

createQuiz(title, description, duration, passingScore, difficultyLevel): Creates a
new quiz with specified attributes.
editQuiz(quizID, newAttributes): Modifies the attributes of an existing quiz.

Question Management:
addQuestion(quizID, questionText, options, correctAnswer): Adds a new
question to a specific quiz.
editQuestion(questionID, newAttributes): Modifies the attributes of an existing
question.

Quiz Taking Interface:

startQuiz(userID, quizID): Initiates a quiz for a specific user.
getQuestion(quizID, questionNumber): Retrieves a specific question from a
quiz.

Scoring and Feedback:

calculateScore(userAnswers): Computes the score based on the user's answers.
provideFeedback(score, userAnswers): Offers feedback on the user's
performance.

Leaderboard and Rankings:

getTopScores(quizID, numScores): Retrieves the top scores for a specific quiz.
getUserRank(userID, quizID):

15
Determines the user's rank in a particular quiz.
In a quiz application, assets and resources refer to various types of content,
files, or data that are used to enhance the user experience and functionality.
These elements can include images, audio files, video clips, fonts, question
databases, and more. Here's a breakdown of some common assets and resources
used in a quiz application:

Question Database:
A structured collection of questions, along with their answer options and correct
answers, organized by category or topic.

Images:
Icons, logos, background images, or any visual elements used in the user
interface to enhance the application's aesthetics.

Audio Files:
Background music, sound effects, or voiceovers that may be used in the
application, especially for multimedia questions.

Video Clips:
Short video clips or animations that could be used as part of the questions,
hints, or explanations.

Fonts:
Different fonts or typefaces used for text elements to give a distinct look and
feel to the application.

CSS Stylesheets:
Cascading Style Sheets (CSS) define the visual presentation of the application,
including layout, colors, fonts, and other design elements.

JavaScript Files:
JavaScript files may be used to add interactivity to the application, such as
timer functionality, dynamic content loading, or animations.

HTML Templates:
Templates define the structure of the web pages in the application, including the
layout, elements, and placeholders for dynamic content.

16
 Localization Files:
If the application supports multiple languages, localization files contain
translations of text elements for different language options.

Configuration Files:
These files may include settings or parameters that can be customized, such as
quiz duration, passing scores, or application theme.

Icons and Graphics:

Small visual elements used for buttons, navigation, or indicators within the
application.

Animations and GIFs:

Animated images or GIFs can be used to add dynamic elements to the
application, such as loading indicators or interactive elements.
motion and interactivity.

Conclusion
In this section, we have explored the extensive use of images, sprites, and sound
effects as fundamental building blocks in the creation of the quiz game. These
game assets not only contribute to the game's visual and auditory appeal but also
play a functional role in conveying crucial information to the player. The
thoughtful selection and integration of assets are essential in delivering an
enjoyable and captivating gaming experience. The interplay between visual and
auditory elements ensures that players are fully immersed in the virtual world of
jmaking it a memorable and engaging gameplay journey.

17
 GAME SNAPSHOTS

Source Code:

20
21
22
STARTING INTERFACE

23
GAMEPLAY

24
 Achievements and Learning

The completion of this project yielded several key achievements and valuable
learning outcomes:
1. Hands-on Experience with App Development: The project provided an
immersive introduction to the world of game development. We gained
practical experience in designing gameplay mechanics, handling user
interactions, and managing game assets.
2. Quiz Application Proficiency: Through the utilization of the app library,
we honed our skills in utilizing its features, functions, and methods. We
became proficient in graphics rendering, event handling, sound playback,
and more.
3. Understanding Game Physics: By implementing the bird's motion,
gravity, and collision detection, we deepened our understanding of basic
physics principles in the context of a game environment.
4. Problem-Solving and Debugging: The process of developing the game
exposed us to various challenges, such as managing pipe generation,
optimizing performance, and ensuring smooth gameplay. We enhanced our
problem-solving and debugging skills while addressing these issues.
5. Documentation and Code Structure: The project emphasized the
importance of well-organized code structure and comprehensive
documentation. Properly commented and structured code ensures
readability, maintainability, and collaborative development.
6. Project Planning and Iteration: We experienced the iterative nature of
software development, from initial concept to implementation and
refinement. The project taught us the value of planning, adapting, and
refining our approach based on feedback and testing
.

25
 Future Directions

While the current implementation successfully recreates the core App game
play, there are several avenues for future development and enhancements:
1. Advanced Graphics and Animation: Implement more intricate visual
effects, smoother animations, and dynamic backgrounds to enhance the
game's visual appeal.
2. Level Design: Introduce progressive difficulty levels, additional obstacles,
and diverse environments to create a more engaging and challenging
experience for players.
3. User Interface (UI) Enhancements: Improve the UI by adding features
such as a main menu, game over screen, and high-score tracking to enhance
user engagement.
4. Multiplatform Deployment: Extend the game's reach by optimizing it for
various platforms, including mobile devices and web browsers, to cater to
a broader audience.
5. Multiplayer or Social Features: Integrate multiplayer functionality or
social sharing options to allow players to compete with friends or share
their scores online.

26
 CONCLUSION

Summary of the Project

The GUI-based Quiz Application project has been successfully developed using
the Python programming language and the java library. The project aimed to
recreate the iconic Application experience in a desktop environment, offering
users an opportunity to relive the addictive gameplay that made the original
game a sensation.
Throughout the project, we meticulously examined various aspects of game
development, including graphics rendering, user input handling, collision
detection, and sound integration. By dissecting and understanding the code, we
gained insights into the inner workings of a simple yet engaging game, which
provided an excellent platform for learning and exploration.

Conclusion
In conclusion, the GUI-based Quiz Applicatoin project provided an exciting and
educational journey into the world of game development. By utilizing the Java
library and Java programming language, we successfully recreated the addictive
Flappy Bird experience, offering players a chance to relive the classic gameplay
on their desktops. The project's achievements, insights gained, and potential
future directions underscore the versatility and creativity that can be harnessed
through game development. As we conclude this project, we reflect on the
valuable skills acquired, the joy of bringing a game to life, and the boundless
opportunities for further exploration in the dynamic realm of game development.

27
 BILBOGRAPHY

1. https://www.java.org/

2. https://www.quizApp.org/docs/

3. https://stackoverflow.com/

28
29
30