Unreal FPS MADE WITH BLUEPRINT THEN C++

Project Origin: This project originated as a series of assignments completed across two separate courses during Terms 4 and 5 of my Video Game Design and Development diploma program. The work was designed to progressively develop foundational and intermediate skills in Unreal Engine development, with a focus on both visual scripting and C++ integration.

Purpose: While both assignments shared the goal of expanding Unreal Engine knowledge, each term focused on different areas of technical growth. The objective of the Term 4 assignment was to familiarize students with the Unreal Editor, Blueprint visual scripting, and core gameplay system development. The Term 5 assignment expanded on these foundations by introducing Unreal Engine C++ development. This included configuring a development environment with Visual Studio, compiling Unreal Engine projects, and gaining a stronger understanding of how C++ systems integrate with Blueprint workflows.

Key Learning Outcomes:
- Built gameplay systems using Blueprint visual scripting in Unreal Engine.
- Developed an understanding of Unreal Engine workflows, editor tools, and gameplay architecture.
- Configured and integrated Visual Studio for Unreal Engine C++ development.
- Gained experience compiling, debugging, and troubleshooting Unreal Engine projects.
- Learned how C++ and Blueprints interact to create scalable gameplay systems.
- Strengthened technical problem-solving through iterative development and debugging.
- Improved understanding of gameplay programming and system design principles.

Technology Used
- Unreal Engine 5.7
- Blueprints
- Visual Studio
- C++
- GitHub (Version Control)

NOTICE

Both projects are currently in active development and remain works in progress. While the content shown represents an unfinished state, each project is being continuously revised and refined toward a polished, completed experience. These projects are not abandoned but are part of an ongoing iterative development process.

FPS IN UNREAL USING BLUEPRINTS

FPS Gameplay Systems & Shooting Range Implementation

This prototype showcases a first-person shooter range experience developed in Unreal Engine, with a primary focus on gameplay systems, player interaction, and FPS mechanics. The project was designed to simulate a tactical training course in which players select a weapon and progress through an environment, eliminating targets while being evaluated on speed and performance. The gameplay experience incorporates various linked systems, including first-person player movement, weapon interaction, shooting mechanics, target detection, scoring systems, and timed gameplay objectives. Players are able to engage with in-world weapon stations before making their way through the course and eliminating targets throughout the environment. A timer system and score tracking interface were implemented to reinforce the competitive, challenge-driven nature of the experience. From a technical perspective, the project supplied valuable experience in developing FPS gameplay architecture, including weapon firing logic, hit detection, UI integration, game state management, and player response systems. The implementation of menus, scoring logic, and end-state functionality additionally deepened understanding of player progression flow and gameplay loop design. This prototype served as an opportunity to strengthen my knowledge of gameplay programming, technical system integration, and iterative FPS development workflows, while laying the groundwork for future refinement into a noticeably more polished and complete experience.

Weapon Spawn & Equip System Overview

BP_FirstPersonCharacter-EventGraph_10_ed

BP_FirstPersonCharacter-EventGraph_11_ed

This Blueprint manages the player weapon spawning, destruction of previous equipped weapons, attachment to the first-person mesh, and weapon state updates.

Weapon Spawn & Initialization

BP_FirstPersonCharacter-EventGraph_3_edi

Responsible for spawning the selected weapon class and initializing the player's active weapon state.

Weapon Equip & Attachment System

BP_FirstPersonCharacter-EventGraph_4_edi

Handles attaching the selected weapon to the player mesh through socket-based attachment and updates the equipped weapon reference.

Weapon Switching Workflow

BP_FirstPersonCharacter-EventGraph_5_edi

Ensures only one active weapon exists by destroying the previously equipped instance before spawning and attaching the newly selected weapon.

Interaction / Weapon Pickup System

BP_FirstPersonCharacter-EventGraph_6_edi

This Blueprint implements an interaction-based pickup system, allowing the player to detect nearby overlapping interactable objects and trigger contextual interactions through an interface-driven workflow. The system was designed to support modular gameplay interactions, enabling scalable object pickup and weapon selection functionality within the FPS shooting range experience.

Exterior BSP Blockout

The environment for this shooting range was constructed using Unreal Engine’s BSP (Geometry Brush) system as a primary level design workflow. The objective was to create a functional, modular indoor firing range while developing a stronger understanding of spatial design and blockout techniques in Unreal Engine. To build the structure, I applied a combination of basic geometric shapes alongside both additive and subtractive brush types. Additive brushes were used to establish the primary architectural forms of the environment, including the building structure, interior walls, and floor layouts. Subtractive brushes were then used to carve out functional spaces, such as doorways, hallways, windows, and interior openings, enabling a more controlled, iterative approach to environment construction. This workflow enabled rapid prototyping of the level layout while continuing flexibility for testing player movement, sightlines, and gameplay flow throughout the shooting range. The process also delivered valuable experience in understanding how early-stage environment blockouts contribute to gameplay readability, navigation, and level composition before transitioning into a more polished art pass.

Interior Environment & Spatial Layout Design

The interior layout of the shooting range was developed using Unreal Engine’s Geometry Brush (BSP) workflow to create a functional and modular training environment while strengthening core principles of level blockout and environmental composition. Using a combination of additive and subtractive brush techniques, I designed the facility's interior architecture, including room segmentation, lane separation, walls, floors, shooting booths, and structural openings. Subtractive brushes were specifically used to carve out doorways, shooting windows, interior sightlines, and transitional spaces, supporting rapid iteration and experimentation with gameplay flow. The interior was intentionally designed to support the core gameplay loop by emphasizing visibility, player navigation, weapon selection flow, and target engagement spaces. Environmental decisions such as lane placement, cover positioning, and room spacing were considered to improve readability and maintain a clear sense of progression throughout the shooting course. This process provided useful hands-on experience in environmental blockout, modular spatial planning, gameplay-driven architecture, and iterative level design workflows, prior to transitioning to a more refined, polished visual pass.

Interior Environment & Spatial Layout Design

This section of the shooting range environment was designed to emphasize player movement, target engagement, and positional awareness through a gameplay-driven level design approach. Built using Unreal Engine’s Geometry Brush (BSP) system, the environment was constructed using a combination of additive and subtractive brushes to establish the architectural layout and navigable combat spaces. The space was intentionally structured to simulate a tactical engagement area, incorporating cover objects, elevation variation, window openings, and transitional pathways to encourage movement and line-of-sight management. Interior architectural elements such as walls, openings, windows, and room segmentation were created through subtractive brush workflows, supporting rapid iteration and testing of environmental readability and player flow. Environmental props and cover placement were introduced to explore how spatial composition impacts gameplay pacing, player positioning, and combat decision-making throughout an FPS environment. Particular attention was given to creating clear sightlines while also introducing opportunities for cover usage and movement through the space. This process improved my understanding of blockout workflows, gameplay-first environment design, player navigation, and iterative level composition, while establishing a functional prototype environment intended for further refinement and visual polish.

Weapon Selection & Interactive Gameplay Design

The weapon selection system for the shooting range was designed to support the core gameplay loop by supplying players with a clear, interactive way to choose their firearm before entering the course. This area serves as a preparation and loadout selection space, allowing players to practice with different weapon types and approaches before starting the timed challenge. Weapon cases were intentionally integrated into the environment to create a significantly more immersive and grounded experience while strengthening the tactical training range aesthetic. Each station was designed to serve as an interactive gaming element, allowing players to visually identify, approach, and select a weapon through an in-world interaction system rather than relying solely on menu-based selection. From a technical and design perspective, this system provided an opportunity to explore player interaction mechanics, object-based gameplay systems, and environmental storytelling using functional prop placement. Consideration was also given to readability and player flow, guaranteeing the weapon stations were clearly visible and naturally guiding players toward the beginning of the shooting experience. This process contributed to a stronger understanding of gameplay-driven environmental design, interactive object systems, player onboarding, and FPS progression flow within Unreal Engine.

FPS IN UNREAL USING C++

This project showcases the development of a first-person shooter prototype in Unreal Engine using C++, with a focus on gameplay programming, combat systems, and technical implementation. Players engage enemy targets within a timed combat scenario while interacting with systems such as weapon firing, hit detection, scoring, health tracking, UI feedback, timer management, and game state progression, culminating in a win/game-over state upon successful completion. Unlike the Blueprint-focused FPS prototype, this project stresses transitioning to Unreal Engine C++ development, reinforcing essential programming concepts such as gameplay architecture, system communication, debugging, and integrating code-driven functionality into Unreal Engine workflows.

These snippets showcase the implementation of core gameplay systems in FPSCharacter.cpp in Unreal Engine C++, which serve as the foundation for player interaction and first-person gameplay. Systems demonstrated include Enhanced Input integration, first-person camera and mesh configuration, equippable tools and inventory management, HUD initialization, pause/menu state handling, health and damage systems, and gameplay-driven player engagement. A key focus of this implementation was designing a modular, scalable player architecture that transitioned gameplay functionality from Blueprint scripting into reusable C++ systems. Through object-oriented design and Unreal Engine’s gameplay framework, this work improved my understanding of system communication, player state management, input mapping contexts, UI integration, and maintainable gameplay programming workflows.

This header file defines the core structure of the AFPSCharacter class, establishing the player character’s major systems before their functionality is implemented in the corresponding C++ source file. It organizes key gameplay components such as the first-person camera, first-person mesh, Enhanced Input actions, inventory component, equipped tool reference, HUD widgets, pause/main menu classes, and health variables into a clean Unreal Engine gameplay framework. The structure demonstrates how the player character was designed to support modular FPS gameplay through Blueprint-exposed properties, callable health functions, input bindings, tool interaction functions, UI control methods, and Unreal’s damage override system. This helped create a scalable foundation where movement, camera control, tool equipping, UI states, and player health could be expanded while keeping the character class organized and readable.

This code showcases the implementation of game flow and progression logic within FPSGameModeBase, responsible for tracking enemy states and determining match completion conditions in the FPS prototype. Upon level initialization, the system dynamically counts active enemy actors, tracks remaining enemies throughout gameplay, and triggers the game-over state once all enemies have been eliminated. A key focus of this implementation was designing a centralized gameplay management system that controls progression and communicates with the player controller to display end-state UI and performance information. Through Unreal Engine’s Game Mode framework, this system reinforced concepts such as actor iteration, gameplay state tracking, controller communication, win-condition handling, and modular game flow architecture.

This code showcases the implementation of game flow and progression logic within FPSGameModeBase, which tracks enemy states and determines match completion conditions in the FPS prototype. Upon level initialization, the system dynamically counts active enemy actors, tracks remaining enemies throughout gameplay, and triggers the game-over state once all enemies have been eliminated. A key focus of this implementation was designing a centralized gameplay management system that controls progression and communicates with the player controller to display end-state UI and performance information. Through Unreal Engine’s Game Mode framework, this system reinforced concepts such as actor iteration, gameplay state tracking, controller communication, win-condition handling, and modular game flow architecture.

This code shows how AFPSPlayerController works. It manages player-facing systems, including HUD updates, menu flow, score tracking, health display, timers, pause, and game-over states, in the Unreal Engine C++ FPS prototype. The system smoothly handles switching between gameplay and the UI, ensuring player response is quick and clear throughout the game. A key focus was separating user interface (UI) and game state logic from the player character. The controller manages input contexts (ways of interpreting different inputs), menu navigation, cursor behavior, and gameplay state changes through Unreal Engine’s Enhanced Input system and Player Controller framework. This reinforced my understanding of modular architecture, UI integration, and scalable system design in C++.

This header file defines the AFPSPlayerController structure. It organizes the project’s player-facing systems for UI management, Enhanced Input, HUD communication, scoring, timer tracking, pause control, and game-over flow. By exposing menu classes, input mapping contexts, and HUD functions to Unreal’s Blueprint system, the controller bridges C++ gameplay logic and designer-facing UI. A key focus of this structure was separating high-level game state and interface logic from the character class. This lets the player character focus on gameplay. The Player Controller manages menu transitions, input mode switching, score and time updates, health display, player death checks, and win or loss presentation. This results in a cleaner, more scalable design.

This code shows a C++ projectile actor for an FPS prototype. It manages movement, collision detection, hit detection, damage, and physics effects. The projectile uses Unreal Engine’s ProjectileMovementComponent and a sphere collision setup. These handle travel speed, collision responses, owner or instigator ignoring, and lifespan control. A key focus was building a reusable projectile system. This supports reliable combat through point damage, hit data, bone detection, and physics impulses. Projectile hits now provide key combat information, including impact direction and hit location. This supports systems like enemy damage, headshots, and responsive reactions.

This header file defines the structure of AFirstPersonProjectile. It organizes the projectile’s core gameplay properties and components for an Unreal Engine C++ FPS prototype. Configurable values for damage, lifespan, physics force, projectile mesh, collision, and movement are exposed. This modular design permits easy tuning and reuse of projectile behavior. A key focus was to create a clean foundation for projectile-based combat, usable in C++ and Blueprint. Configurable projectile data are separated from collision and movement components. This structure allows scalable combat features, including hit detection, point damage, physics-based impact feedback, and future weapon-specific variations.

This code shows a custom game-over UI for the Unreal Engine C++ FPS prototype. It presents end-of-match gamer feedback. The system formats and displays completion time and match results. It converts elapsed gameplay time to a readable format and updates the UI to indicate whether the player succeeded or failed. A main goal was making a lightweight, reusable interface for end-state feedback. The system separates result formatting from UI updates into their own functions. This allows scalable game-over logic and supports concepts such as UI communication, runtime text updates, and clean separation of logic.

This header file defines the UGameOverMenu widget structure. It operates as the foundation for end-of-match player feedback in the Unreal Engine C++ FPS prototype. The system exposes functions to display formatted completion durations and dynamic result messages. It also binds UI text elements to Unreal’s UMG framework for runtime updates. The structure focuses on a modular and reusable game-over interface. It separates the presentation of gameplay outcomes from logic. Callable UI functions and widget bindings allow scalable gamer feedback. The design demonstrates UMG integration, runtime UI updates, Blueprint-to-C++ communication, and clean interface architecture.

This code presents a C++ patrol enemy system for the Unreal Engine FPS prototype, integrating enemy perception, ranged combat, damage management, and scoring logic in a single gameplay actor. The enemy uses Pawn Sensing to detect the player, switches to an engaged state, fires projectiles from the weapon's muzzle, and reverts to an inactive state when the player is no longer visible. A central goal of this design was to create an enemy that interacts with various gameplay systems, including projectile combat, player scoring, headshot detection, health monitoring, and Game Mode win-condition evaluation. Through leveraging point damage, bone-name checks, timers, and controller/Game Mode communication, this system reinforces core principles in AI behavior, combat feedback, gameplay state management, and modular C++ gameplay architecture.

This header file defines the APatrolEnemy class structure. It organizes the systems for weapon setup, projectile firing, player sensing, patrol behavior, health, damage response, and score rewards for the Unreal Engine C++ FPS prototype. The file exposes key values like fire rate, projectile damage, patrol waypoints, sight loss timing, health, headshot score rewards, and weapon socket configuration. These values are adjustable through Unreal’s editor and Blueprint workflow. A main goal was to create a modular enemy foundation that enables independent updates to AI behavior and combat communication. By separating patrol data, sensing components, combat timers, projectile references, damage overrides, and scoring variables, developers can extend or modify these systems without affecting others. This approach forms a scalable base: enemies built on it can detect the player, engage in ranged combat, award score, support headshot detection, and notify the Game Mode when eliminated.

This code shows a custom AI controller system for enemy patrol and waypoint movement in Unreal Engine C++. By automating enemy management, the controller enables intelligent patrol behaviors, seamless movement between points, and dynamic combat-state handling, thereby improving gameplay and reducing manual intervention. This system creates a modular navigation setup that separates enemy movement from the actor. Using Unreal Engine’s AIController, callbacks, timers, and waypoint systems, the controller allows scalable patrols. It reinforces AI navigation, async movement, state awareness, and gameplay-driven design.

This header file defines the APatrolEnemyController class for enemy navigation and patrol behavior in an Unreal Engine C++ FPS prototype. It offers mechanisms for possession, movement completion, waypoint transitions, and timed patrols, with a focus on AI-driven navigation. The structure separates navigation logic from combat and character routines, letting the enemy actor handle sensing and engagement while the AI controller manages movement. Centralized waypoint navigation, timer coordination, and path-completion callbacks in the controller create a modular, scalable AI architecture.

Techincal Reflection

Developing both a Blueprint-driven first-person shooter (FPS) prototype and a C++ gameplay framework in Unreal Engine gave valuable insight into the way different implementation approaches influence factors such as scalability (the ability to support increased complexity or size), workflow (development process), debugging (identifying and fixing code errors), and system architecture (structure and organization of code and game systems). The Blueprint FPS project enabled rapid prototyping of gameplay systems, including weapon interactions, target scoring, UI, timed gameplay, and first-person combat flow. Visual scripting deepened my understanding of event-driven workflows, quick iteration, and Unreal’s gameplay structure while providing hands-on visual debugging experience. In C++, the emphasis shifted to modular architecture, maintainability, performance, and system design. Core elements—player controllers, projectile combat, AI patrols, scoring logic, HUD communication, health, and state management—were rebuilt with reusable code, reinforcing object-oriented programming, class separation, gameplay messaging, timer handling, AI, and scalable design. Blueprint vs C++: Key Differences Blueprint Advantages * Rapid gameplay prototyping and iteration. * Faster implementation for testing mechanics. * Visual debugging and easier gameplay flow tracking. * Strong designer-friendly workflow. Blueprint Limitations * Blueprint projects can become visually complex, often called “Blueprint spaghetti,” as systems grow or interact, making the node-based graphs tangled and difficult to follow. * Harder to maintain larger gameplay architectures. * Increased difficulty debugging deeply interconnected systems. * Less reusable for larger modular frameworks. C++ Advantages * Cleaner separation of gameplay responsibilities. * Greater modularity and maintainability. * Stronger scalability towards larger gameplay systems. * More direct control over gameplay architecture and optimization. C++ Challenges * Longer implementation and debugging time. * Increased upfront complexity. * Requires a greater understanding of Unreal’s gameplay framework and memory management. Key Takeaway Working through both implementations clarified when to use Blueprints for rapid iteration and designer accessibility, and when C++ is necessary for scalability and maintainability. Choosing the right approach depends on project scope, technical needs, and long-term goals.

Unreal FPS MADE WITH BLUEPRINT THEN C++

NOTICE

FPS IN UNREAL USING BLUEPRINTS

FPS Gameplay Systems & Shooting Range Implementation

Weapon Spawn & Equip System Overview

Weapon Spawn & Initialization

Weapon Equip & Attachment System

Weapon Switching Workflow

Aim Down Sights (ADS) State Logic

Target Hit Detection & Scoring System

Score Management & Progression Logic

Interaction / Weapon Pickup System

Exterior BSP Blockout

Interior Environment & Spatial Layout Design

Interior Environment & Spatial Layout Design

Weapon Selection & Interactive Gameplay Design

FPS IN UNREAL USING C++

Techincal Reflection

B