A

MAJOR PROJECT REPORT

ON

ENDLESS RUNNER GAME

By
SHRADDHA (2102150100080)
SHARMA
NIKHIL KUMAR (2102150100061)
MOHIT KUMAR (2102150100056)
MOHD.ABUZAR (2102150100055)

Submitted to
The Department of Computer Science & Engineering in
partial fulfillment of the requirement
for the degree of
BACHELOR OF TECHNOLOGY
In
COMPUTER SCIENCE &
ENGINEERING
Sanskar College of Engineering & Technology
(Affiliated to Dr. A.P. J Abdul Kalam Technical University, Lucknow)
(Session 2024-25)
 A MAJOR PROJECT REPORT
ON
ENDLESS RUNNER GAME

BY
SHRADDHA (2102150100080)
SHARMA
NIKHIL KUMAR (2102150100061)
MOHIT KUMAR (2102150100056)
MOHD.ABUZAR (2102150100055)

Submitted to the Department of Computer Science & Engineering In partial

fulfillment of the requirement
for the degree of

BACHELOR OF TECHNOLOGY
In
COMPUTER SCIENCE & ENGINEERING

UNDER GUIDENCE OF SUBMITTED TO

MR. AMARENDRA PRATAP SINGH MR.MAHESH SHARMA
ASST.PROFESSOR (C.S.E DEPARTMENT)
(C.S.E DEPARTMENT)

Sanskar College of Engineering & Technology

(Affiliated to Dr. A.P. J Abdul Kalam University, Lucknow)
(Session 2024-25)

(II)
 TABLE OF CONTENTS
LIST OF FIGURES.......................................................................................................................... V

DECLARATION .......................................................................................................................... VI

CERTIFICATE ............................................................................................................................. VII

ACKNOWLEDGEMENT ............................................................................................................ VIII

ABSTRACT .................................................................................................................................. IX

CHAPTER 1: INTRODUCTION

1.1 INTRODUCTION .............................................................................................................. 01

1.2 OBJECTIVES OF THE GAME .......................................................................................... 03
1.3 ADVANTAGE OF THE GAME ......................................................................................... 05
1.4 PROJECT CATEGORY .................................................................................................... 07
1.5 SOFTWARE INTERFACE ................................................................................................. 08

CHAPTER 2: DEVELOPMENT OF THE GAME

2.1 SOFTWARE REQUIREMENTS ............................................................................................ 12

2.2 HARDWARE REQUIREMENTS ........................................................................................... 14
2.3 GAME HUD (Heads-up Display) ........................................................................................... 17
2.4 TECHNOLOGY USED .......................................................................................................... 20
2.5 KEY FEATURES.................................................................................................................. 25

CHAPTER 3: IMPLEMENTATION & CODING ............................................................................ 28

CHAPTER 4: TESTING & TESTING RESULTS ........................................................................... 37

CHAPTER 5: CONCLUSION & FUTURE WORK

5.1 CONCLUSION ...................................................................................................................... 40
5.2 FUTURE WORK ................................................................................................................... 41
5.3 REFERENCES ....................................................................................................................... 46
 LIST OF FIGURES
FIGURES TITLE PAGE NO.

I. SOFTWARE INTERFACE 22

II. MAIN MENU 28

III. PAUSE MENU 28

IV. CHARACTER DESIGN 29

V. HIGH SCORE 29

VI. SLIDING 30

VII. MAGNET 30
 DECLARATION

We hereby declare that this submission titled “Endless Runner Game” is our
original work carried out collaboratively by the undersigned, and that, to the
best of our knowledge and belief, it contains no material previously published
or written by any other person, nor material which has been accepted for the
award of any degree or diploma at any university or institution of higher
learning, except where proper acknowledgment has been made in the text.
This project has been completed in partial fulfillment of the requirements for
the award of the Bachelor of Technology (B.Tech) in Computer Science
and Engineering at Sanskar College of Engineering and Technology,
Ghaziabad, under Dr. A.P.J. Abdul Kalam Technical University (AKTU),
Lucknow.

SIGNATURE: SIGNATURE:
NAME: SHRADDHA SHARMA NAME: NIKHIL KUMAR
ROLL NO :2102150100080 ROLL NO:2102150100061
DATE: DATE:

SIGNATURE: SIGNATURE:
NAME: MOHIT KUMAR NAME: MOHD.ABUZAR
ROLL NO: 2102150100056 ROLL NO: 2102150100055

DATE: DATE:
 CERTIFICATE

This is to certify that the dissertation entitled “ENDLESS RUNNER GAME”,

submitted in partial fulfillment of the requirements for the award of the Bachelor of
Technology (B.Tech) in Computer Science and Engineering at Sanskar College of
Engineering and Technology, Ghaziabad, under Dr. A.P.J. Abdul Kalam
Technical University (AKTU), Lucknow, is a record of bona fide work carried out
by us under the guidance and supervision of Asst. Prof. Mr. Amarendra Pratap
Singh The results embodied in this dissertation have not been submitted to any other
university or institution for the award of any degree or diploma.

Internal Guide HEAD OF

DEPARTMENT: - DEPARTMENT: -
Asst. Prof. Mr. A.P Singh Mr. Mahesh Sharma

(Department of CSE.) (Department of CSE)

 ACKNOWLEDGMENT
It is indeed with a great pleasure and immense sense of gratitude that we
acknowledge the help of these individuals. We are highly indebted to
our Director Dr. Dharmendra Singh, Sanskar College of Engineering
and Technology, for the facilities provided to accomplish this main
project.
We would like to thank our Asst. Prof. Mahesh Sharma, Head of the
Department of Computer Science and Engineering, Sanskar College of
Engineering and Technology, for this constructive criticism throughout
our project.
We feel elated in manifesting our sense of gratitude to our internal
project guide, Department of Computer Science and Engineering,
Sanskar College of Engineering and Technology. He has been a
constant source of inspiration for us and we are deeply thankful to him
for his support and valuable advice.
We are extremely grateful to our Departmental staff members, Lab

technicians and Non-teaching staff members for their extreme help

throughout our project.

Project Associates:
Shraddha Sharma
(2102150100080)
Nikhil Kumar
(2102150100061)
Mohit Kumar
(2102150100056)
Mohd. Abuzar
(2102150100055)
 ABSTRACT

This project report details the development of an Endless Runner Game using Unreal
Engine, integrating both C++ programming and Blueprint Visual Scripting while
applying the principles of Object-Oriented Programming (OOP). The objective of this
project is to deliver a functional and engaging game that demonstrates technical
proficiency in game development, modular code design, and real-time interactive
systems.

The game is designed in the popular endless runner style, where the player character
moves automatically through a dynamically generated environment. The gameplay
challenges the player to survive by jumping, dodging, and collecting in-game items while
avoiding obstacles. Features include procedural obstacle spawning, a scoring and high-
score tracking system, increasing difficulty levels, and responsive input handling.

The architecture of the game is grounded in OOP principles. C++ classes form the
backbone of the game logic, such as character movement, collision detection, and game
state transitions. Inheritance and polymorphism were applied to create base classes for
actors like Obstacles, Pickups, and UI Components, making the code reusable and
extensible. Encapsulation ensures clean separation of concerns and maintainability.

Blueprints were strategically used for visual scripting tasks such as animation control,
particle effects, and HUD (Head-Up Display) design. This hybrid approach allowed for
efficient iteration and real-time testing, bridging the gap between visual design and low-
level code logic.
 CHAPTER:1.1 INTRODUCTION

The gaming industry has grown exponentially over the past decade, with real-time 3D
engines like Unreal Engine revolutionizing the way games are developed and experienced.
This project, titled “Endless Runner Game using Unreal Engine with C++ and
Blueprints,” aims to explore the process of designing and developing a complete,
interactive game using modern game development tools and programming paradigms. The
primary focus is on building a simple yet engaging endless runner game, which not only
entertains but also demonstrates the practical application of core software development
principles.

An endless runner game is a subgenre of platform games where the player character is in
constant motion, typically moving forward through a procedurally generated environment.
The objective is to survive as long as possible while collecting points and avoiding
obstacles. Due to its fast-paced and reflex-based nature, this genre is popular on both
mobile and PC platforms, making it an ideal model for a major project that balances
creativity and technical implementation.

Unreal Engine, developed by Epic Games, was chosen as the development platform for
this project because of its powerful rendering system, flexible Blueprint visual scripting
language, and seamless integration with C++. This engine allows developers to prototype
and build complex, interactive systems rapidly. By combining C++ with Blueprints, this
project benefits from both the performance and control of traditional code, as well as the
speed and clarity of visual scripting.

The game is structured using Object-Oriented Programming (OOP) principles, which help
ensure modularity, maintainability, and scalability. Major gameplay elements—such as the
player character, obstacles, pickups, game UI, and scoring system—are implemented using
base and derived classes. This design approach promotes code reuse and simplifies the
addition of new features.

In addition to gameplay mechanics, the project also covers aspects of user interface design,
game physics, animation, and sound integration, offering a holistic view of game
development. The development workflow involved iterative testing, debugging,
performance optimization, and gameplay balancing to ensure a smooth and enjoyable
player experience.

This report outlines the planning, design, implementation, and testing phases of the project,
supported by diagrams, code snippets, and screen captures. Through this project, the
developer has gained practical experience in using industry-standard tools, applying
theoretical programming concepts, and solving real-world challenges in game
development.
 1.2 OBJECTIVE OF THE GAME:

The primary objective of this project is to design and develop a fully functional Endless
Runner Game using Unreal Engine, leveraging the combined strengths of C++
programming and Blueprint Visual Scripting, while adhering to Object-Oriented
Programming (OOP) principles. This project aims to demonstrate an understanding of
both game design and software development, offering an opportunity to apply theoretical
concepts in a practical, interactive environment.

The detailed objectives of this project are as follows:

1. To Build an Engaging Gameplay Experience

The game should offer intuitive controls, smooth animations, and progressively
challenging mechanics to keep the player engaged. The player character will
automatically move forward, requiring the user to react to obstacles, jump, or dodge,
creating a reflex-based gameplay loop.

2. To Apply OOP Concepts in Game Development

By using inheritance, encapsulation, abstraction, and polymorphism, the game’s
architecture will be designed in a modular and scalable way. Core gameplay components
such as characters, obstacles, pickups, and UI elements will be structured using reusable
classes.

3. To Integrate C++ and Blueprints Efficiently

The project will use C++ for core logic such as character movement, obstacle spawning,
scoring, and collision handling, while Blueprints will manage visual scripting tasks like
HUD design, particle effects, and animation events. The integration aims to leverage the
performance of C++ and the rapid prototyping ability of Blueprints.

4. To Implement a Dynamic and Procedurally Generated Environment

One of the core challenges is to create an infinite scrolling environment with randomly
generated obstacles and pickups. This ensures each gameplay session feels unique and
unpredictable, increasing replay value.

5. To Develop a Functional and Interactive User Interface (UI)

The game will include user interface components such as a main menu, score display,
game over screen, and pause functionality, ensuring an accessible and complete player
experience.

6. To Learn and Apply Game Design Best Practices

Through this project, the developer aims to gain hands-on experience in balancing
difficulty, optimizing performance, organizing assets, and using Unreal Engine’s toolset
efficiently.

7. To Prepare for Real-World Game Development Scenarios

The project simulates a mini production pipeline, incorporating planning, design,
development, debugging, and testing. It prepares the developer for real-world industry
practices by emphasizing time management, version control, and structured coding.

In summary, the project is not just about creating a game, but about understanding the
principles and practices of game development from the ground up, using modern tools
and languages in a professional workflow.
 1.3 ADVANTAGES OF THE GAME:

The Endless Runner Game developed using Unreal Engine, with a hybrid approach of
C++ programming and Blueprint Visual Scripting, offers several advantages both from a
development and gameplay perspective. These advantages are outlined below:

1. Interactive and Engaging Gameplay

The endless runner format provides fast-paced, reflex-based gameplay that is easy to
understand yet difficult to master. This keeps players engaged and encourages repeated
playthroughs, enhancing replayability.

2. Modular and Scalable Architecture

Built with Object-Oriented Programming (OOP) principles, the game's structure allows
for easy extension and maintenance. New features like power-ups, additional obstacles,
or new levels can be added with minimal changes to the existing codebase.

3. Efficient Use of Unreal Engine Tools

The game takes full advantage of Unreal Engine’s powerful features, including its visual
scripting system (Blueprints), physics engine, rendering pipeline, and asset management
tools. This results in a visually polished and high-performance game.

4. Real-Time Procedural Generation

The game world is generated dynamically as the player progresses, ensuring that each
session presents a unique challenge. This procedural design significantly enhances the
game's longevity and variety.

5. Balanced Use of C++ and Blueprints

By combining the performance efficiency of C++ with the visual intuitiveness of
Blueprints, the development process becomes more flexible. Developers can prototype
ideas quickly using Blueprints and then optimize performance-critical sections with C++.
6. Cross-Platform Compatibility
As Unreal Engine supports multiple platforms (Windows, Android, iOS, etc.), this game
can be easily exported to different devices with minimal adjustments, increasing its
accessibility and reach.

7. Educational Value
For developers and learners, this project serves as a comprehensive learning tool. It
covers important aspects such as game mechanics, UI development, physics interactions,
optimization, and gameplay balancing.

8. User-Friendly Interface and Design

The game features a clean and intuitive user interface, allowing players to easily navigate
menus, view scores, and control the game with minimal instructions. This improves the
overall user experience.

9. Improved Performance through Code Optimization

The game’s performance is optimized by handling core logic in C++, reducing lag, and
ensuring smooth gameplay even during complex operations like multiple obstacle spawns
and real-time collisions.

10. Potential for Future Expansion

Thanks to the modular design, the game can serve as a base for future enhancements,
such as multiplayer support, character customization, level themes, or AI-controlled
enemies.
 1.4 PROJECT CATEGORY

Game Development and Interactive Multimedia Application

This project falls under the category of Game Development, specifically focusing on the
design and implementation of an interactive 3D endless runner game. It incorporates
elements of software development, real-time graphics rendering, object-oriented
programming, and user interaction design within the domain of interactive multimedia
applications.

The project utilizes Unreal Engine, a professional-grade game engine, to develop a

playable game that integrates both visual scripting (Blueprints) and low-level
programming (C++). As such, it also fits into the subcategories of:

Software Engineering – due to the application of structured programming practices and

system design.

Simulation and Real-Time Systems – due to the game’s real-time interaction, physics,
and procedural generation.

Entertainment Technology – as the game is designed primarily for user enjoyment and
engagement.

Computer Graphics and Animation – due to the implementation of 3D models,

animations, particle effects, and visual assets.

This categorization reflects the multidisciplinary nature of the project, combining

technical, artistic, and interactive design skills.
 1.5 SOFTWARE INTERFACE:

The Software Interface of the Endless Runner Game refers to the interaction between the
user and the system through a well-structured and intuitive graphical interface. Designed
using Unreal Engine's UI framework and Blueprints, the interface offers a responsive and
visually appealing experience that enhances the overall gameplay.

The major components of the software interface include:

1. Main Menu Screen

Options Available:

Start Game – Begins the gameplay session.

Instructions – Displays control instructions and gameplay tips.

Exit – Closes the game application.

Designed with button widgets and smooth transitions using Unreal Engine’s UMG
(Unreal Motion Graphics) system.

2. Gameplay Screen (HUD - Head-Up Display)

Score Display: Shows the current score in real time.

High Score: Displays the highest score achieved in previous sessions.

Game Speed Indicator (if implemented): Shows the increasing game speed.

Player Health / Status (optional, based on feature scope)

All elements are dynamically updated during gameplay using Blueprint bindings and
C++ logic.
3. Pause Menu

Triggered during gameplay to pause the session.

Options include:

Resume

Restart

Main Menu

This interface is layered over the gameplay screen and freezes in-game logic until
resumed.

4. Game Over Screen

Displays when the player fails (e.g., hits an obstacle).

Shows:

Final score

High score

Buttons to Retry, Return to Main Menu, or Exit

Provides feedback to encourage replay.

5. Instruction Panel / Help Section

Provides an overview of controls, objectives, and scoring rules.

Displayed with simple icons and brief text for easy comprehension.

6. Visual Design Elements

Consistent theme using background music, buttons, fonts, and visual effects.

Interactive buttons respond to hover and click events with animations.

Designed for accessibility and ease of use across various devices.

7. Input Handling

Supports keyboard or touch input depending on the platform.

Input is managed using Unreal Engine's Input Mapping system in both Blueprints and
C++.

The interface has been designed to be minimalistic yet functional, offering players a
smooth and distraction-free experience. All screens are optimized for performance and
aesthetic consistency across different screen resolutions.
Software Interface
 CHAPTER 2: DEVELOPMENT OF THE GAME
2.1 SOFTWARE REQUIREMENTS

The software requirements for both the development and execution of the Endless Runner
Game are outlined below:

1. Development Software Requirements

Unreal Engine 5.x (or Unreal Engine 4.27+): The game engine used for creating and
running the game.

C++ Programming Language: Unreal Engine supports C++ for core game logic and
performance-critical tasks.

Unreal Engine Blueprints: Visual scripting system for rapid prototyping and gameplay
logic, offering flexibility in game development.

Visual Studio 2019 or later (with C++ tools): Required for writing and compiling C++
code for Unreal Engine.

Graphics Software (Optional): Tools like Adobe Photoshop, GIMP, or similar for
designing and editing textures, sprites, and UI elements.

3D Modeling Software (Optional): Blender, Maya, or 3ds Max to create custom 3D

models, if necessary for game assets.

Version Control (Optional): Git, with platforms like GitHub or Bitbucket, to manage
project versions and collaboration.

Operating System: Windows 10 (64-bit) or later for development and running Unreal
Engine. Audio Editing Software (Optional): Tools like Audacity for editing and
producing sound effects and background music.
2. Execution Software Requirements

Operating System: Windows 10 (64-bit) or later is required to run the game.

Graphics API: Unreal Engine supports DirectX 11/12 and Vulkan for rendering. DirectX
12 is recommended for the best performance.

Runtime Libraries: DirectX 11/12 and the Visual C++ Redistributable packages, which
are required to run the compiled game.

Game Engine Files: Unreal Engine must package the game into an executable for
distribution, which can be played on any supported platform.

3. Optional Platform Support (for future deployment)

Android: Unreal Engine allows deployment to mobile platforms, requiring the installation
of Android Studio and the Android SDK.

iOS/macOS: These platforms can also be targeted with additional configuration for
Unreal Engine, but they are optional for the project’s scope.
 2.2 HARDWARE REQUIREMENTS

The hardware requirements for both development and execution of the Endless Runner
Game are outlined below:

1. Development Hardware Requirements

Processor (CPU):

Minimum: Quad-core processor (Intel i5 or equivalent).

Recommended: 6-core or higher (Intel i7 or equivalent) for faster compiling and

development processes.

Memory (RAM):

Minimum: 8 GB RAM.

Recommended: 16 GB RAM or higher to ensure smooth operation of Unreal

Engine and other development tools, especially during large asset loads or real-
time debugging.

Graphics Card (GPU):

Minimum: DirectX 11 compatible graphics card (NVIDIA GTX 660 or equivalent).

Recommended: NVIDIA GTX 1060 or higher, or an AMD equivalent for better

rendering performance and visual fidelity during development and gameplay
testing.

Storage:

Minimum: 50 GB of free disk space (preferably on a Solid-State Drive).

Recommended: 100 GB or more of free disk space on an SSD to store Unreal

 Engine assets, game files, and project backups, ensuring faster load times and
better performance.

Operating System:

Minimum: Windows 10 (64-bit).

Recommended: Windows 10 or 11 (64-bit) for better performance and

compatibility with Unreal Engine and other development tools.

2. Execution Hardware Requirements

Processor (CPU):

Minimum: Dual-core processor (Intel Core i3 or equivalent).

Recommended: Quad-core processor (Intel i5 or higher) for smooth game

execution.

Memory (RAM):

Minimum: 4 GB RAM.

Recommended: 8 GB RAM or higher to ensure smooth gameplay experience

without lag, especially when running on higher graphics settings.

Graphics Card (GPU):

Minimum: DirectX 11 compatible GPU (NVIDIA GTX 660 or equivalent).

Recommended: NVIDIA GTX 1060 or higher, or an AMD equivalent, for better

game performance and graphical quality during gameplay.
 Storage:

Minimum: 5 GB free disk space to install and run the game.

Recommended: SSD with at least 10 GB free space for faster load times and
improved gameplay performance.

Operating System:

Minimum: Windows 10 (64-bit).

Recommended: Windows 10 or 11 (64-bit) for optimal performance and

compatibility.

These hardware specifications ensure that the game will run smoothly during
development and on target machines, with an optimal experience provided by the
recommended hardware.
 2.3 GAME
HUD(Heads-up Display)

Main Menu

Pause Menu
Character Design

High Score
Sliding

Magnet
 2.4 TECHNOLOGY USED

The development of the Endless Runner Game utilized a combination of advanced game
development tools, programming languages, and software technologies. These
technologies provided the necessary resources for creating a visually appealing,
performant, and interactive game. Below are the key technologies used in the project:

1. Unreal Engine

Unreal Engine is a powerful, professional-grade game engine developed by Epic Games.

It is known for its high-quality rendering capabilities, robust toolset, and flexibility in
handling complex game mechanics.

Version: Unreal Engine 5.x (or Unreal Engine 4.27+)

Usage: Unreal Engine was the core platform for the entire game development process. It
was used for environment creation, asset management, physics simulation, AI behavior,
and game logic implementation. The game engine’s built-in features, such as Blueprints
and C++ integration, made it possible to create the gameplay mechanics efficiently.

2. C++ Programming

C++ is the primary programming language used for the development of the game’s core
functionality. Known for its high performance and control over system resources, C++
was used to write the game’s logic for key systems such as character movement, collision
detection, and procedural generation of the environment.

Usage:

Implementing core game systems like movement, scoring, and obstacle spawning.

Handling performance-critical tasks that benefit from lower-level access to memory and
processor functions.

Ensuring the game’s logic runs efficiently, allowing smooth gameplay without lag or
stutter.
3. Unreal Engine Blueprints

Blueprints is Unreal Engine’s visual scripting system, allowing developers to create game
mechanics without writing code manually. It provides a node-based interface where you
can drag and drop elements to define the game’s behavior.

Usage:

Visual scripting of non-performance-critical systems like UI elements, animations,

particle effects, and transitions between menus.

Building gameplay features such as interactions between the player character and
obstacles.

Streamlining the rapid prototyping process by allowing immediate testing and iteration
without needing to write C++ code for every element.

4. Visual Studio

Visual Studio is the integrated development environment (IDE) used to write, compile,
and debug C++ code for Unreal Engine projects.

Usage:

Writing and editing C++ code for core game systems.

Debugging and compiling the code to ensure error-free execution.

Integration with Unreal Engine for managing and building the project.

5. Unreal Motion Graphics (UMG)

UMG is Unreal Engine’s user interface framework, used for creating menus, HUDs, and
other interactive UI components.
Usage:

Designing and implementing the game’s main menu, pause screen, game over screen, and
HUD.

Creating interactive elements such as buttons, sliders, and score displays.

Ensuring that the UI is responsive and intuitive for the player.

6. 3D Modeling and Asset Creation Tools (Optional)

Blender: An open-source 3D modeling software that was used (if applicable) for creating
game assets such as obstacles, characters, and props. Blender is an ideal tool for creating
and exporting assets for Unreal Engine.

Usage:

Designing 3D models and animations for game elements.

Exporting models into Unreal Engine using compatible formats like FBX.

(Alternative tools like Maya or 3ds Max could be used, depending on the project's
requirements.)

7. Version Control Systems (Optional)

Git is a version control system that allows tracking and managing changes in the project’s
codebase and assets. Platforms like GitHub or Bitbucket were used to host the repository
and collaborate on the project.

Usage:

Managing and tracking changes made to the codebase, ensuring that each update can be
rolled back if necessary.

Collaborating with other team members (if applicable) and maintaining project
organization.
8. Procedural Generation Algorithms (Custom C++ Code)

Procedural Generation is a technique used to create game content algorithmically rather

than manually. In the Endless Runner Game, procedural generation was used to spawn
obstacles, pickups, and environment elements dynamically as the player progresses.

Usage:

Creating a randomly generated game environment that changes each time the player starts
a new session.

Ensuring a consistent flow of obstacles and challenges, adapting to the player’s

performance.

9. Physics Engine (Built-in Unreal Engine)

Unreal Engine comes with a robust physics engine that simulates realistic movements,
collisions, and interactions between game objects.

Usage:

Handling player character collisions with obstacles and pickups.

Simulating the environment’s physics, including gravity, movement, and object

interaction in the game world.

Conclusion

The combination of Unreal Engine, C++, Blueprints, and additional development tools
allowed for the creation of a dynamic, interactive, and optimized endless runner game.
These technologies enabled the project to meet both performance and gameplay
requirements while ensuring ease of development through a hybrid approach of low-level
programming and visual scripting.
 2.5 KEY FEATURES
The Endless Runner Game developed using Unreal Engine leverages both C++
programming and Blueprints to provide an engaging and immersive gaming experience.
Below are the key features of the game:

1. Endless Gameplay

The core mechanic of the game is that it’s an endless runner, meaning the player
increasing over time. This keeps the game engaging and encourages players to
aim for high scores by surviving as long as possible.

2. Procedural Generation of Obstacles and Environment

The game world is generated dynamically as the player progresses. Procedural

generation algorithms ensure that obstacles, pickups, and the environment
change with each new run. This results in a unique experience every time the
player plays, offering high replayability.

3. Player Character Control and Movement

The player controls a character that continuously runs forward. The gameplay
focuses on dodging, jumping over, or sliding under obstacles in the path.

Smooth and responsive character controls are achieved using C++ programming
for physics-based movement and Blueprints for intuitive control mechanics.

4. Increasing Difficulty

As the player progresses, the game becomes more challenging. Obstacle

frequency, speed, and variety increase to keep the player engaged and push them
to improve their skills with each attempt.
5. Score System

The game keeps track of the player’s score, which increases the longer the
player survives. The score is displayed in real-time on the HUD (Head-Up
Display), with the highest score recorded across sessions.

High score tracking encourages players to beat their previous best scores, adding
to the game's competitive element.

6. Collectible Power-Ups (Optional)

Throughout the game, the player can collect power-ups that provide temporary
advantages such as magnet, which boost the collecting power of coins, where
magnet collect all coins which is inside the magnetic field.

7. Dynamic Difficulty Adjustment

The game features an adaptive difficulty system, where the game automatically
increases the difficulty based on how long the player survives. This prevents the
game from becoming too easy or too difficult at any point, maintaining a
challenging but rewarding experience.

8. Engaging User Interface (UI)

The game includes a clean and intuitive user interface that displays the score,
high score, and game status.

The main menu, pause menu, and game over screen are easy to navigate, offering
options such as Start Game, Restart, and Exit.

9. Smooth Animations and Visuals

The game features fluid character animations for actions like running, jumping,
 and sliding. These animations are created using Unreal Engine’s built-in
animation blueprint system.

Visually appealing environments and dynamic backgrounds, enhanced by

particle effects and lighting, provide an immersive experience for players.

10. Audio Feedback

Sound effects are used such as Collecting power-ups and from collecting coins
inside the game. which is responsible to enhance the sound experience.

11. Pause and Game Over Menus

Players can pause the game at any time and access a pause menu with options
like resume, restart, or exit to the main menu.

Upon losing, the game over screen displays the final score, allowing players to
see how they performed and encouraging them to try again.

Conclusion

The Endless Runner Game integrates these key features to provide a dynamic,
engaging, and challenging experience for players. By combining procedural
generation, increasing difficulty, power-ups, and smooth player controls, the game
keeps players coming back for more, aiming to break their high scores.
 Chapter 3: IMPLEMENTATION

The Endless Runner Game was implemented using Unreal Engine 5, combining the
strengths of C++ and Blueprints. The implementation process was structured into several
stages: setting up the project, creating the core game mechanics, developing the game
environment, implementing AI and obstacles, and optimizing the gameplay experience.
The following sections outline the step-by-step implementation process.

1. Project Setup and Initial Configuration

Unreal Engine Setup: The project was initiated using Unreal Engine 5 (or Unreal
Engine 4 if specified). A new blank project was created with a Third-Person template,
which provided the basic structure and control schemes for the player character.

File Organization: The project was structured with organized folders for assets (textures,
models, sounds), blueprints, C++ classes, and UI components. This helped maintain
clarity during development and made the project easier to manage.

2. Player Character Development

Character Model and Animation: The player character was either imported from a 3D
modeling tool (such as Blender) or chosen from Unreal Engine’s default assets. The
character model was rigged and animated for movements like running, jumping, and
sliding.

C++ Implementation: The character’s movement was implemented using C++,

leveraging Unreal Engine’s Character class. This class enabled control over movement,
physics, and collision.

Blueprints Implementation: The animations were handled via Unreal Engine’s

Animation Blueprint to blend between different states (e.g., idle, running, jumping) based
on user input.

The player movement was controlled by:

Forward Running: Automatically moving forward with the ability to control lateral
movement (left/right).
Sliding: A low-crouching animation that could be triggered to pass under obstacles.

3. Procedural Generation of Obstacles and Environment

Procedural Level Design: The core gameplay experience in the Endless Runner Game is
powered by procedural generation, which dynamically generates obstacles, environments,
and pickups as the player advances.

Obstacle Spawning: The game generates obstacles at random intervals using a random
number generator. These obstacles are placed in the path of the player, with varying
sizes, shapes, and types (e.g., walls, pits, and moving obstacles).

Environment Layout: The background environment (e.g., forest, city, etc.) is

procedurally generated, creating a unique experience each time the game is played.

Blueprints and C++ Integration: Procedural spawning logic was handled in C++ for
performance-critical tasks, while Blueprints were used for simple object placement,
visual design, and testing.

4. Collision Detection and Physics

Collision Handling: Unreal Engine’s Physics Engine was utilized to handle collision
detection between the player character and obstacles. The Character Movement
Component ensured that the player’s movements responded to physical interactions, like
running into walls or jumping over obstacles.

C++ Implementation: Collision logic was written in C++ to detect when the player
character collides with an obstacle. When a collision occurs, the player’s health is
decreased or the game ends.

Trigger Zones: Specific areas (e.g., near obstacles or collectible items) used trigger
volumes to detect player interactions and initiate events, such as increasing the score or
activating power-ups.
5. Scoring System and Difficulty Scaling

Score Mechanism: The player’s score is calculated based on the distance traveled in the
game. The score is incremented every few seconds or every time the player overcomes an
obstacle.

Score Display: The score is displayed in the HUD (head-up display) as the game
progresses. This feature was implemented using Unreal Motion Graphics (UMG).

Increasing Difficulty: As the player’s score increases, the game gradually increases the
difficulty by:

Increasing the speed of the obstacles.

Adding more complex obstacle patterns.

Adjusting the frequency of obstacles to create more challenging gameplay.

6. Power-Ups and Collectibles

Power-Up Implementation: Power-ups are scattered throughout the environment and

can be collected by the player. These power-ups include items such as:

Invincibility: Grants temporary invulnerability to obstacles.

Speed Boost: Temporarily increases the player’s movement speed.

Score Multiplier: Doubles the score for a limited period.

Power-ups were implemented using Blueprints for object placement and logic (e.g.,
timers and activation effects).

7. User Interface (UI)

Main Menu and Game Over Screen:

Unreal Motion Graphics (UMG) was used to design and implement the Main Menu,
Pause Menu, and Game Over Screen.
The Main Menu allows the player to start the game, view high scores, or adjust settings.

The Game Over Screen displays the player’s final score, with the option to restart the
game or return to the main menu.

HUD Design: The HUD displays real-time information like the player’s score, current
speed, and collected power-ups. This was done using UMG Widgets that update every
frame during gameplay.

8. Testing and Debugging

Unit Testing: C++ classes for movement, collision, and game logic were extensively
unit-tested. Unreal Engine’s built-in testing tools were used to simulate different in-game
situations (e.g., obstacle collisions, power-up usage).

Playtesting: The game was regularly playtested to ensure that the difficulty curve was
balanced and that no critical bugs were present. Changes were made to tweak the
gameplay, remove bugs, and adjust player controls based on test feedback.

10. Optimization and Performance

Object Pooling: To improve performance, object pooling techniques were used to

manage obstacles and power-ups, reducing the number of objects being created and
destroyed during gameplay.

Memory Management: Assets such as textures, sounds, and models were optimized for
low memory usage. Unreal Engine’s Level of Detail (LOD) system was used for models
to reduce the complexity of objects rendered at a distance.

Performance Testing: The game was tested on various hardware configurations

(desktop, mobile) to ensure that it ran smoothly across devices.
Conclusion of Implementation

The Endless Runner Game was successfully developed by integrating core game
mechanics, procedural generation, and a fluid player experience. By utilizing C++
programming for high-performance systems and Blueprints for rapid iteration and
gameplay logic, the project achieved a balance between performance and flexibility. The
game’s dynamic difficulty, engaging obstacles, and polished UI offer a challenging and
rewarding experience for players, while optimizations ensure smooth performance across
platforms.
 SOURCE CODE:
_BP_FLOOR( Header Code )

/** Please add a class description */

UCLASS(Blueprintable, BlueprintType)
class ABP_Floor : public AActor
{
GENERATED_BODY()
public:
/** Please add a function description */
UFUNCTION(BlueprintCallable)
FTransform Get AttachPoint();

/** Please add a function description */

UFUNCTION(BlueprintCallable)
void Setup Spawn Points();

/** Please add a function description */

UFUNCTION(BlueprintCallable)
void Spawn Obstacles(TArray<FTransform> Random Spawn Points);

/** Please add a function description */

UFUNCTION(BlueprintCallable)
void Coin Spawn Points();

/** Please add a function description */

UFUNCTION(BlueprintCallable)
void Spawn Coins(TArray<FTransform> NewLocalVar, TArray<FTransform>
Random Spawn Points);

/** Please add a function description */

UFUNCTION(BlueprintCallable)
void Powerup Spawn Points();

/** Please add a function description */

UFUNCTION(BlueprintCallable)
void Spawn Powerups(TArray<FTransform> NewLocalVar, TArray<FTransform>
Random Spawn Points);
public:
 /** Please add a variable description */
UPROPERTY(BlueprintReadOnly, VisibleAnywhere, Category="Default")
TObjectPtr<UBoxComponent> Box;

/** Please add a variable description */

UPROPERTY(BlueprintReadOnly, VisibleAnywhere, Category="Default")
TObjectPtr<UArrowComponent> Arrow;

/** Please add a variable description */

UPROPERTY(BlueprintReadOnly, VisibleAnywhere, Category="Default")
TObjectPtr<UStaticMeshComponent> floor;

/** Please add a variable description */

UPROPERTY(BlueprintReadOnly, VisibleAnywhere, Category="Default")
TObjectPtr<USceneComponent> DefaultSceneRoot;

/** Please add a variable description */

UPROPERTY(BlueprintReadWrite, EditDefaultsOnly, Category="Default")
TArray<double> Lane Position;

/** Please add a variable description */

UPROPERTY(BlueprintReadWrite, EditDefaultsOnly, Category="Default")
TArray<FTransform> Spawn Points;

/** Please add a variable description */

UPROPERTY(BlueprintReadWrite, EditDefaultsOnly, Category="Default")
TArray<FTransform> Spawn Points_0;

/** Please add a variable description */

UPROPERTY(BlueprintReadWrite, EditDefaultsOnly, Category="Default")
TArray<FTransform> CSpawnPoints;

/** Please add a variable description */

UPROPERTY(BlueprintReadWrite, EditDefaultsOnly, Category="Default")
TArray<FTransform> PSpawn Points;
};
BP_Runnercharacter (Header Code )

/** Please add a class description */

UCLASS(Blueprintable, BlueprintType)
class ABP_RUNNERCHARACTER : public ACharacter
{
GENERATED_BODY()
public:
/** Please add a function description */
UFUNCTION(BlueprintCallable)
void Death();

/** Please add a function description */

UFUNCTION(BlueprintCallable)
void Save High Score();

/** Please add a function description */

UFUNCTION(BlueprintCallable)
void Update Coins();
public:
/** Please add a variable description */
UPROPERTY(BlueprintReadOnly, VisibleAnywhere, Category="Default")
TObjectPtr<UCameraComponent> FollowCamera;

/** Please add a variable description */

UPROPERTY(BlueprintReadOnly, VisibleAnywhere, Category="Default")
TObjectPtr<USpringArmComponent> Camera Boom;

/** Please add a variable description */

UPROPERTY(BlueprintReadOnly, VisibleAnywhere,
Category="BP_RUNNERCHARACTER")
TObjectPtr<UTimelineComponent> Transition;

/** Please add a variable description */

UPROPERTY(BlueprintReadWrite, EditDefaultsOnly, Category="Default")
bool Is sliding;

/** Please add a variable description */

UPROPERTY(BlueprintReadWrite, EditDefaultsOnly, Category="Default")
 int32 Current Lane Index;

/** Please add a variable description */

UPROPERTY(BlueprintReadWrite, EditDefaultsOnly, Category="Default")
int32 Target Lane Index;

/** Please add a variable description */

UPROPERTY(BlueprintReadWrite, EditDefaultsOnly, Category="Default")
double Current Y Position;

/** Please add a variable description */

UPROPERTY(BlueprintReadWrite, EditDefaultsOnly, Category="Default")
TArray<double> Lane Position;

/** Please add a variable description */

UPROPERTY(BlueprintReadWrite, EditDefaultsOnly, Category="Default")
TObjectPtr<USaveGame> Saver Sub Class;

/** Please add a variable description */

UPROPERTY(BlueprintReadWrite, EditDefaultsOnly, Category="Default")
bool Is Magnet Active;

/** Please add a variable description */

UPROPERTY(BlueprintReadWrite, EditDefaultsOnly, Category="Default")
bool Is triggered;

/** Please add a variable description */

UPROPERTY(BlueprintReadWrite, EditDefaultsOnly, Category="Default")
FVector2D Touch Start 2D;

/** Please add a variable description */

UPROPERTY(BlueprintReadWrite, EditDefaultsOnly, Category="Default")
FVector2D Touch End 2D;

/** Please add a variable description */

UPROPERTY(BlueprintReadWrite, EditDefaultsOnly, Category="Default",
meta=(EditInline="true"))
TObjectPtr<UPauseMenu_UI_C> PauseMenu_UI;
};
 CHAPTER 4:
TESTING:

Testing for the Endless Runner Game was carried out at various stages of development to
ensure that the game mechanics, performance, and overall user experience met the
project’s requirements. The following types of testing were performed:

1. Unit Testing

C++ Classes: Unit tests were written for critical C++ classes, including the player
character's movement, collision detection, scoring system, and obstacle generation. These
tests helped ensure the logic was working as expected.

Automated Testing: Unreal Engine's built-in testing tools were used to automate the
testing of these systems, especially for complex game mechanics like the procedural
environment generation.

2. Functional Testing

Core Mechanics: The core gameplay mechanics, such as player movement, obstacle
interactions, and power-up collection, were manually tested to ensure they functioned
smoothly and without errors.

UI Testing: The main menu, in-game HUD, and game over screens were tested to verify
proper transitions, score display, and button functionality.

Level Design: The procedural generation of obstacles and environment layouts was
tested to ensure a balanced gameplay experience with no visual glitches or unplayable
configurations.

3. Performance Testing

Frame Rate: The game was tested on different hardware configurations to ensure it
maintained a stable frame rate. Optimizations like object pooling and asset compression
were validated.

Memory Usage: The game was tested for memory leaks and performance drops,
especially on lower-end hardware, ensuring smooth performance during extended
gameplay sessions.

4. Playtesting

Gameplay Balance: Multiple rounds of playtesting were conducted to adjust the

difficulty curve, ensuring that the game is challenging but not frustrating. Feedback from
testers was incorporated to refine the gameplay experience.

Bug Identification: Various playtests helped identify and fix bugs related to collision
detection, animation blending, and scoring logic.

5. Cross-Platform Testing

Mobile and Desktop Testing: The game was tested on both mobile (iOS/Android) and
desktop (Windows) platforms to ensure compatibility, proper controls, and performance
on different devices.
Conclusion of Testing

The game was thoroughly tested to ensure that the core mechanics were stable, the
performance was optimized, and the player experience was engaging. The issues
identified during testing were promptly fixed, resulting in a polished and well-functioning
final product.
 CHAPTER 5: CONCLUSION AND FUTURE
WORK
5.1Conclusion
The Endless Runner Game, developed using Unreal Engine and leveraging both C++
programming and Blueprints, successfully meets the objectives of delivering an
engaging, dynamic, and performance-optimized gaming experience. By implementing
key features like procedural generation, increasing difficulty, a robust scoring system,
and fluid player controls, the game offers a highly interactive and replayable experience
for players.

Throughout the development process, we utilized a combination of advanced

technologies that allowed us to create not only a visually appealing game but also one
that runs efficiently across various platforms. The hybrid approach of utilizing both C++
for performance-critical elements and Blueprints for rapid prototyping ensured flexibility,
while Unreal Engine’s physics engine and AI behavior enabled realistic interactions
within the game world.

The procedural generation of obstacles and environments keeps the gameplay fresh and
exciting, offering players a unique experience with every run. The dynamic difficulty
curve adds an additional layer of challenge, making the game rewarding as players
improve their skills and aim for higher scores.

Overall, this project has served as a valuable learning experience, showcasing the
capabilities of Unreal Engine and providing insight into game design, development, and
optimization techniques. It also demonstrates the integration of object-oriented
programming principles in the development of interactive applications. The game stands
as an example of how creative and technical skills can come together to produce an
entertaining and engaging product.

Moving forward, there are numerous opportunities for further enhancement, such as
adding new game modes, improving the AI, and expanding the game world with
additional assets and features. The game’s modular design allows for easy updates and
improvements, which could potentially expand its scope to reach a larger audience.
 5 . 2 FUTURE WORK

While the Endless Runner Game has successfully met the initial objectives of providing

an engaging and challenging gameplay experience, there are several avenues for

improvement and expansion. In the future, the game can be enhanced with additional

features, optimizations, and platform support to further enrich the player experience.

Some possible directions for future work include:

1. Enhanced Game Features

New Game Modes: Introducing new game modes such as Time Attack, Survival Mode,

or Challenge Rounds can add variety to the gameplay and offer different experiences to

players.

Multiplayer Mode: Adding a multiplayer feature would allow players to compete

against friends or other online players in real-time, increasing engagement and

replayability.

Leaderboards and Achievements: Implementing online leaderboards and achievement

systems would give players a sense of progression and competition, encouraging them to

beat high scores and unlock rewards.

More Power-Ups and Abilities: Introducing new power-ups (e.g., double score,

invulnerability for a limited time, slow-motion) and player abilities (e.g., double jumps,

dash moves) can make gameplay more dynamic and give players more strategies to

employ.

2. Improved Graphics and Visuals

Enhanced Visual Effects: Improving particle effects, lighting, and environment textures

can make the game visually more appealing. Adding day-night cycles, weather effects, or

more complex environmental settings could enhance immersion.

Character Customization: Allowing players to customize their characters (e.g., through

skins, outfits, or accessories) could add a fun element and increase player investment in

the game.

3. Audio and Music Enhancements

Dynamic Music: Implementing dynamic music that changes based on the player’s

progress, such as faster tempo or more intense music as the difficulty increases, can

create a more immersive atmosphere.

More Sound Effects: Additional sound effects, such as unique sounds for each power-

up, new obstacles, and more ambient background sounds, would further enrich the
auditory experience.

4. Cross-Platform Development

Mobile Support: Expanding the game to mobile platforms (iOS and Android) is a

potential future enhancement. This would require adapting the controls for touch-based

devices and optimizing performance for lower-end mobile hardware.

Console Support: The game can also be adapted for consoles such as PlayStation and

Xbox, requiring controller support and optimizations for console performance.

5. Artificial Intelligence (AI) Enhancements

Smarter AI Obstacles: Adding AI-controlled obstacles or enemies that dynamically

react to the player's actions (e.g., chasing the player, predicting their movements) could

increase the challenge and make the game feel more alive.

AI Difficulty Scaling: Implementing an AI-driven difficulty scaling system that not only

adjusts the obstacles' frequency but also their intelligence and behavior based on the

player’s performance could make the game more adaptive and engaging.

6. Game Analytics and Player Feedback

Analytics Integration: Implementing an analytics system to track player behaviors, such

as the most common failures, popular power-ups, or common high-score ranges, could

provide valuable insights for further game balancing and feature development.
Player Feedback Integration: Regularly gathering and integrating player feedback

could help identify areas for improvement and ensure that the game aligns with player

expectations and desires.

7. Optimization for Performance

Frame Rate Optimization: Further performance optimizations, particularly for lower-

end devices or systems, will ensure that the game runs smoothly across a wider range of

hardware.

Memory and Asset Optimization: Reducing memory usage and optimizing assets, such

as textures and models, will ensure faster loading times and prevent performance issues,

especially for mobile and console platforms.

8. Marketing and Distribution

Game Launch: Once the game is fully developed and polished, a planned launch

strategy on platforms like Steam, Google Play, or the App Store will be necessary to

reach a broader audience.

Community Building: Building a community around the game through social media,

gaming forums, and content creators can drive engagement and attract a loyal player

base.
Conclusion for Future Work

The Endless Runner Game is a solid foundation for further development, and there are

numerous possibilities to enhance its features, gameplay, and reach. By continuing to

iterate on the game based on player feedback and industry trends, future versions can

provide a more engaging and dynamic experience for a broader audience.

 5.3 REFERENCES

 https://dev.epicgames.com/documentation/en-us/unreal-engine/unreal-engine-5-5-
documentation

 https://store.epicgames.com/en-US/download

 www.youtube.com

 https://youtube.com/playlist?list=PLKWcO-
53OuH71Oo_sCNjNOKP1GmBcD6cI&si=wUw19IG-6mnFJLc_

 https://youtube.com/playlist?list=PLNTm9yU0zou4qQh33nqojMPTUSo-
RuVCJ&si=x4a6WUb31_hJJ4if

 https://youtu.be/gfleby2BLGo?si=S2g95j0KXebxM9HO

 https://youtu.be/1cfPiofNy-U?si=5l1atTfwdZTFjpIS

 https://youtu.be/aaLqEHXGiww?si=TOHRWqjbQKmJQJUu

 https://youtu.be/k-zMkzmduqI?si=cgoVPHRssptbuB2L