“SNAKE GAME”

A JAVA PROJECT REPORT

Submitted by

ANUSHKA JAIN [Reg.No:RA2211026030006],

PARTH SINGH [Reg.No:RA2211026030016],

MOHAK KANSAL [Reg.No:RA22110026020039],

ANSHUL SHARMA [Reg.No.:RA2211026030050],

DIVYANSH BHARDWAJ [Reg.No.:RA2211026030052]

Under the guidance of

Ms. Shubhangi Sharma

(Assistant Professor, Department of Computer Science & Engineering)

In partial fulfillment for the award of the degree of

BACHELOR OF TECHNOLOGY

In

COMPUTER SCIENCE AND ENGINEERING

SRM Institute of Science and Technology, NCR Campus

 BONAFIDE CERTIFICATE

Certified that this project report titled “SNAKE GAME” is the bonafide work of ANUSHKA JAIN
[Reg.No.:RA2211026030006], PARTH SINGH[Reg.No.:RA2211026030016], MOHAK
KANSAL[Reg.No.:RA2211026030039], ANSHUL SHARMA[Reg.No.:RA2211026030050],
DIVYANSH BHARDWAJ[Reg.No:RA2211026030052], who carried out the project work under my
supervision. Certified further, that to the best of my knowledge the work reported herein does not form
any other project report or dissertation on the basis of which a degree or award was conferred on an
earlier occasion on this or any other candidate.

SIGNATURE SIGNATURE

(Ms. Shubangi Sharma) (Dr. Akash Punhani)

Assistant Professor APP (Mentor) Associate Professor

Head of CSE-Department

Signature of Internal Examiner Signature of External Examiner

 INDEX

S-No. Topic Page No. Signature

1. Acknowledgements 5

2. Declaration 6

3. Abstract 7

4. Introduction 8 - 10

5. Objectives 11

6. Hardware Requirements 12

7. Software Requirements 13

8. Advantages 14

9. Disadvantages 15

9. Procedure 16 - 17

10. Flowchart 18 - 20
9. Output Snapshots 21 - 24

10. Conclusion 25

11. References 26
 ACKNOWLEDGEMENTS

We would like to express our heartfelt appreciation to Ms. Shubhangi Sharma, our Project Supervisor

at SRM Institute of Science and Technology, Delhi-NCR Campus, Modinagar, for her invaluable

insights and expertise in the subject matter, which motivated us to work diligently.

We would like to extend our sincere thanks to Dr. S. Vishwanathan, Director of SRM Institute of Science

and Technology, Delhi-NCR Campus, Modinagar, for his unwavering support that enabled us to

undertake and complete our project work. Our special thanks go to Dr. R. P. Mahapatra, Dean

Computer Science and Engineering at SRM Institute of Science and Technology, Delhi-NCR

Campus, Modinagar, for his valuable guidance and unconditional support.

We would like to express our gratitude to Dr. Akash Punhani, HOD CSE 2 nd year at SRM Institute of

Science and Technology, Delhi-NCR Campus, Modinagar, for his suggestions and encouragement in

completing this project.

Finally, we would like to express our sincere appreciation to our parents, family members, and friends

for their unwavering support and encouragement, and to all our well-wishers.

ANUSHKA JAIN [RA2211026030006] PARTH SINGH [RA2211026030016]

MOHAK KANSAL [RA2211026030039] ANSHUL SHARMA [RA2211026030050]

DIVYANSH BHARDWAJ [RA2211026030052]

 DECLARATION

We, ANUSHKA JAIN [Reg.No.:RA2211026030006], PARTH SINGH[Reg.No.:RA2211026030027], MOHAK

KANSAL[Reg.No.:RA2211026030039], ANSHUL SINGH[Reg.No.:RA2211026030050], DIVYANSH

BHARDWAJ[Reg.No:RA2211026030052], hereby declare that the work which is being presented in the project

report ”SNAKE GAME” is the record of authentic work carried out by us during the period from August’23 to

October’23 and submitted by us in partial fulfillment for the award of the degree “Bachelor of Technology in

Computer Science and Engineering” to SRM IST, NCR Campus, Ghaziabad (U.P.). This work has not been

submitted to any other University or Institute for the award of any Degree/Diploma.

ANUSHKA JAIN [Reg.No:RA2211026030006]

PARTH SINGH [Reg.No:RA2211026030016]

MOHAK KANSAL [Reg.No:RA22110026020039]

ANSHUL SHARMA [Reg.No.:RA2211026030050]

DIVYANSH BHARDWAJ [Reg.No.:RA2211026030052]

 ABSTRACT

This project delves into implementing the classic game "Snake" using Java programming language
and the javax.swing.*; package. The main focus lies in understanding swing class components,
specifically exploring the interaction between JPanel and JFrame. Key areas of investigation
include game logic, frame creation through the redraw() function, function overriding, and
handling key events. Two distinct approaches were considered, with the swing method standing
out for its straightforward implementation. The resulting Snake game, while simple, forms a solid
foundation for future enhancements and feature additions, offering numerous avenues for
further development. This project serves as a valuable exploration into game development and
Swing's capabilities, showcasing the potential for enhancing gameplay and user experience.
Through this endeavor, insights into the intricate aspects of swing components and their role in
creating interactive games have been gained, laying the groundwork for more complex and
engaging projects in the future.
 INTRODUCTION

Snake, a sub-genre within action video games, revolves around a player

maneuvering the end of an elongating line, typically depicted as a snake. The
primary objective is to prevent the snake from colliding with obstacles and itself,
presenting a heightened challenge as the snake's length increases. Originating from
the 1976 two-player arcade video game "Blockade" by Gremlin Industries, the initial
aim was to outlast the opponent. Over time, this concept evolved into a single-
player variant, where the snake extends with every consumed piece of food, often
portrayed as apples or eggs.

The enduring appeal of snake games lies in their simplicity and modest technical
requirements, resulting in a plethora of versions. These iterations encompass
diverse platforms and often include the terms "snake" or "worm" in their titles. The
captivating gameplay, coupled with the fundamental mechanics of maneuvering a
growing snake and avoiding collisions, has led to the widespread popularity and
continuous evolution of snake games, offering entertainment and engagement
across a broad spectrum of gaming enthusiasts.

The inception of this project, centered around recreating the iconic Snake game,
can be attributed to a compelling discovery: a video shared by the prominent
YouTuber, CodeBullet. In the video, CodeBullet demonstrated a program designed
to achieve the maximum possible snake size within the game. Intrigued and inspired
by this demonstration, we embarked on the journey to replicate the game and
integrate his algorithm into our implementation.

To undertake this challenge, we recognized the need to construct the entire game
from scratch. This encompassed developing the game mechanics, graphical user
interface, and the logic necessary to bring the Snake game to life. Coincidentally,
our decision to utilize the Java programming language for this project stemmed
from its suitability for game development. Java provided a robust foundation and
an array of tools and libraries, making it an ideal choice to execute this endeavor.

This project delves into not only the recreation of the Snake game but also the
exploration of algorithmic strategies to optimize the snake's growth within the
game environment. Through this process, we aim to gain valuable insights into
game programming, algorithm design, and the practical application of code in
enhancing gameplay and achieving specific objectives within the game.
What was left was to find out what all we had to learn to implement it. This included
of the following:
1. Swing Package:
 javax.swing: This package provides classes for creating the graphical
user interface (GUI) components required for your game, such as
JFrame, JPanel, and JButton.
2. Graphics Class:
 java.awt.Graphics: This class is used for drawing shapes, images, and
text on the game screen.
3. Key Events:
 java.awt.event.KeyListener: Implement this interface to handle
keyboard input for controlling the snake's movement.
4. Timer Class:
 javax.swing.Timer: This class allows you to schedule a periodic action,
which can be used to update the game state and repaint the screen at
regular intervals.
5. ArrayList Class:
 java.util.ArrayList: Use this class to manage the snake's body segments
efficiently.
6. Random Class:
  java.util.Random: Use this class to generate random positions for
placing food in the game.
7. Colors:
 java.awt.Color: Utilize this class to set colors for the snake, food,
background, etc.
8. Event Handling:
 Understand how to handle events, such as keyboard input, using event
listeners like ActionListener and KeyListener.
9. Game Logic:
 Implement game logic for controlling the snake's movement, detecting
collisions, growing the snake, and managing the game state.
10.Main Game Loop:
 Design a main game loop that updates the game state, handles user
input, and repaints the screen continuously.
11.Game Objects:
 Create classes to represent game objects such as the snake, food, and
other elements within the game.
 Objectives

1. Understanding Game Development Basics:

 By recreating the Snake game, individuals can gain a foundational
understanding of game development principles, including concepts
like game loops, rendering, user input, and collision detection.
2. Learning Java Swing and GUI Components:
 Developing the Snake game involves using Java Swing components
like JPanel and JFrame, providing a hands-on opportunity to learn
how to design and manage graphical user interfaces (GUIs) in Java.
3. Exploring Algorithmic Logic:
 The game's logic, including snake movement, collision handling, and
food generation, presents a chance to delve into algorithmic
problem-solving and implement different strategies to optimize
gameplay.
4. Practicing Object-Oriented Programming (OOP):
 Recreating the Snake game encourages the practice of OOP concepts,
such as creating classes for game objects (snake, food) and using
inheritance, encapsulation, and polymorphism for efficient and
organized code.
5. Experimenting with Game Design and Enhancement:
 The Snake game provides a canvas for experimentation and creativity,
allowing learners to modify game features, design new levels, add
sound effects, or implement additional functionalities, enhancing
their understanding of game design and development.
 HARDWARE REQUIREMENTS

• Processor: Any modern processor with at least 1 GHz speed.

• RAM: 512 MB RAM or higher
• Graphics: Integrated graphics card or dedicated graphics card with basic
capabilities.
• Storage: A few megabytes of available storage space for the game
installation.
• Operating System: Compatible with Windows
• Display: Any monitor or screen with a resolution of 800x600 pixels or higher.
• Sound: Basic sound card for in-game sounds and effects (optional).
• Input Devices: Keyboard for user input during gameplay and development.
 SOFTWARE REQUIREMENTS

1. Java Development Kit (JDK):

- Latest version of JDK to compile and run Java code. JDK includes the Java
Runtime Environment (JRE), which is necessary to execute Java applications.

2. Integrated Development Environment (IDE):

- Popular choices include:
- IntelliJ IDEA
- Eclipse
- NetBeans

3. Java Libraries:
- Swing or JavaFX: For creating the graphical user interface (GUI) of the game.
- AWT (Abstract Window Toolkit): For basic graphics and event handling.
 ADVANTAGES

1. Simplicity and Readability:

 The code is relatively simple and easy to understand, making it
accessible for beginners and facilitating faster comprehension.
2. Modularity with Inner Classes:
 The use of inner classes enhances code modularity and organization,
allowing for logical grouping of related functionalities.
3. Appropriate Usage of Swing for GUI:
 Utilizing Swing for GUI components ensures a responsive and
interactive user interface, essential for a game like Snake.
4. Real-time Rendering and Interactivity:
 The implementation leverages real-time rendering and user
interactivity, providing an engaging gaming experience for the player.
5. Effective Collision Handling:
 The collision detection and handling mechanisms are effectively
implemented, ensuring accurate detection of collisions between the
snake and other elements.
 DISADVANTAGES
1. Limited Error Handling:

 The code does not contain comprehensive error handling

mechanisms, potentially leading to unexpected behavior or
crashes if errors occur during execution.

2. No Separation of Concerns:

 The code lacks a clear separation of concerns, resulting in some

logic (e.g., game over conditions) being mixed within the move()
method.
3. Minimal Code Reusability:

 The code does not emphasize code reusability or the creation of

reusable functions, limiting its potential for use in other projects
without significant modifications.

4. Tight Coupling with Swing:

 The code is tightly coupled with Swing components, making it
harder to switch to alternative GUI libraries or frameworks in the
future if needed.
 PROCEDURE

Sure, here are the steps for creating a snake game in Java along with a one-line
description for each step:

1. Create Game Panel and Frame:

- Set up the panel and frame to display the game.

2. Define Panel Width, Panel Height, and Tile Size:

- Establish dimensions and size of the game panel for accurate rendering.

3. Draw Snake Head:

- Develop a method to draw the snake head on the game panel.

4. Draw Food:
- Create a method to draw the food item on the game panel.

5. Generate New Food:

- Implement a method to create new food at a random position.
6. Define Snake Velocity (X and Y axis):
- Set the snake's velocity in both the X and Y directions.

7. Implement Velocity on Key Presses:

 - Link key presses to adjust the snake's movement speed and direction.

8. Redraw Method for Frame Update:

- Implement a method to update frames for smooth gameplay.

9. Handle Snake-Food Interaction:

- Manage the interaction between the snake's head and the food items.

10. Handle Snake-Body Interaction:

- Define how the snake's head interacts with its body.

11. Handle Collision with Borders:

- Implement collision detection to handle interactions with the game borders.

12. Display and Update Score:

- Create a method to show and update the player's score.

13. Implement Restart Game Loop:

- Establish a game loop to enable restarting the game after it ends.
FLOWCHART
OUTPUT SNAPSHOTS
 CONCLUSION

In the realm of game development, the Snake Game project in Java represents a
fusion of nostalgia, creativity, and skillful programming. By revisiting this iconic
arcade classic, we ventured into the world of Java, a language renowned for its
versatility and robustness. Through the lens of object-oriented programming and
leveraging Java’s graphical capabilities, we have successfully reimagined the Snake
Game, keeping true to its fundamental mechanics while introducing modern
enhancements.

The journey of this project encompassed more than just recreating a game; it
encapsulated the essence of learning and skill development. Delving into the
intricacies of Java’s libraries, designing a captivating user interface, and optimizing
game performance all contributed to an enriched understanding of software
engineering principles and paradigms involved.
As we navigated through the development process, we embraced the challenge of
striking a balance between simplicity and engagement. The game’s intuitive
gameplay beckons both seasoned gamers and newcomers, inviting them to relish
in its retro charm. Yet, we recognized the need for modernization and
customization, incorporating features to enhance the overall gaming experience
and showcase our creativity.
While the project encountered certain challenges, such as graphics design and code
scalability, they served as valuable lessons. Through these hurdles, we fortified our
coding process, instilling the importance of streamlined development practices and
efficient project management in the realm of game dev.
In conclusion, the Snake Game project in Java serves as a testament to the fusion
of tradition and innovation in the world of game development. It stands as a vibrant
example of how classic games can be revitalized, appealing to a diverse audience
while instilling a sense of nostalgia and excitement. As we look ahead, we aspire to
further evolve this project, embracing advancements and opportunities.-
 REFERENCES

 https://www.youtube.com/watch?v=tjQIO1rqTBE&t=973s [CodeBullet] <--

youtube channel
 https://www.javatpoint.com/java-swing
 https://www.youtube.com/watch?v=6zm8c6QFmjo
 https://www.geeksforgeeks.org/introduction-to-java-swing/
 Github references : https://github.com/topics/snake-game?
 Game Development Forums:
- Platforms like Stack Overflow,
https://stackoverflow.com/questions/30050194/snake-game-in-python-
using-turtle-graphics
 GameDev Stack Exchange, and Java-specific forums.