Roleplaying Open World Prototype

Gameplay Systems Overview

This project focuses on building a responsive third-person traversal and combat experience inspired by parkour-based action games. The systems were implemented in Unreal Engine using Blueprints and designed to interact with one another to create fluid movement and coordinated enemy encounters.

The following gameplay systems were designed and implemented for this project.

Enemy AI Systems

Enemy behavior was built around coordinated combat and dynamic player detection.

Systems Implemented

  • AI Detection & Suspicion System – Enemies gradually detect the player through a suspicion meter that increases when the player is visible.

  • AI Combat Coordinator – Manages multiple enemies engaging the player, allowing only one attacker at a time while others circle and wait for their turn.

These systems create enemy encounters that feel organized and readable rather than chaotic.

Combat Systems

The combat mechanics were designed to create responsive melee combat that reacts to player input and positioning.

Systems Implemented

  • Directional Attack System – Determines attack animations based on player movement input, allowing forward, backward, and side attacks.

  • Animation-Based Combat Flow – Uses animation montages and state transitions to maintain smooth attack sequences.

These systems allow combat to feel reactive to the player's movement and positioning.

Traversal Systems

The traversal mechanics allow the player to move through the environment using parkour-style movement.

Systems Implemented

  • Vaulting System – Dynamically detects low obstacles and triggers traversal animations to maintain movement flow.

  • Wall Climbing & Mantling – Allows the player to climb vertical surfaces and mantle over ledges using surface detection and animation transitions.

  • Grapple Hook Traversal – Enables the player to quickly reach elevated positions by grappling to valid environmental targets.

These traversal systems were built to support fluid movement across the environment and reduce interruptions to player momentum.

AI Combat Coordinator System

System Summary

Implemented a centralized AI combat coordination system that manages multiple enemies engaging the player simultaneously. Instead of all enemies attacking at once, the system evaluates nearby AI, grants attack permission to one attacker at a time, and organizes other enemies into surrounding positions while they wait for their turn.

This creates controlled combat encounters that maintain pressure on the player while avoiding chaotic crowd attacks.

Design Goals

  • Prevent enemies from overwhelming the player

  • Maintain constant combat pressure

  • Ensure combat encounters remain readable

  • Create the illusion of coordinated enemy tactics

What I Built

Responsibilities

  • Designed and implemented a centralized AI Combat Coordinator

  • Created an attack permission system that selects which AI can attack

  • Implemented an AI queue system for managing waiting enemies

  • Built a suspicion meter that determines when enemies join combat

  • Integrated the coordinator with Unreal Behavior Trees and Blackboards

  • Developed circling behavior for waiting enemies

  • Implemented logic for attack completion and next attacker selection

Enemy Detects Player

↓

Suspicion Meter Fills

↓

AI Registers With Combat Coordinator

↓

Coordinator Adds AI To Attack Queue

↓

Coordinator Selects Current Attacker

↓

Selected AI Executes Attack Behavior

↓

Attack Finishes

↓

Coordinator Selects Next AI

Technical Breakdown

The AI Combat Coordinator acts as a central decision manager for enemies in combat.

When an enemy detects the player and reaches a suspicion threshold, it registers itself with the coordinator. The coordinator evaluates the list of active enemies and grants attack permission to one AI at a time.

Other enemies remain active but are placed in a waiting state, where they circle the player and maintain pressure until the coordinator grants them permission to attack.

This approach prevents enemy overlap while maintaining the illusion of coordinated group combat.

Blueprint Logic

Enemy Registration

When an AI's suspicion meter exceeds a threshold:

  1. AI sends a RequestAttackPermission call to the Combat Coordinator.

  2. The coordinator stores the AI reference in an Active Enemy Array.

  3. If no attacker is currently active, the coordinator selects one.

Attack Selection

The coordinator:

  • Checks if CurrentAttacker is empty

  • Selects an AI from the registered enemies

  • Sets that AI as CurrentAttacker

  • Updates its CanAttack flag

This flag is read by the AI’s Behavior Tree to enter the attack state.

Behavior Tree Integration

AI behavior trees reference the coordinator through blackboard variables.

Typical flow:

Selector
 ├── Attack Player (if HasAttackPermission)
 ├── Circle Player (if WaitingForTurn)
 └── Investigate / Chase Player

The HasAttackPermission value is controlled by the coordinator.

Circling System

Enemies waiting for their attack turn move around the player instead of standing still.

The circling position is calculated by:

  • Getting the player location

  • Generating an offset position around the player

  • Using vector rotation to distribute enemies around the player

This ensures enemies maintain spacing while remaining threatening.

Challenges & Solutions

Multiple AI Attacking at Once

Initially, enemies would attack simultaneously when they detected the player.

Solution

Implemented a centralized attack permission system that ensures only one AI can enter the attack state at a time.

Idle AI Standing Still

Enemies waiting for their turn felt unnatural when standing still.

Solution

Added a circling behavior that generates dynamic positions around the player, allowing enemies to reposition while waiting.

Combat Flow

Without coordination, combat encounters felt chaotic and overwhelming.

Solution

The coordinator system regulates attack timing and enemy positioning, creating combat that feels intentional and readable for the player.

⭐Featured Gameplay Systems⭐

Directional Attack System

System Summary

Implemented a directional melee attack system that selects different attack animations based on the player's movement input at the moment the attack is triggered. This allows the player to perform forward, backward, and side attacks, creating a more responsive and varied combat system similar to directional melee combat found in modern action games.

The system reads the player's movement input relative to the character's facing direction and determines the correct attack animation to play.

What I Built

Responsibilities

  • Designed and implemented a directional attack detection system in Unreal Engine Blueprints

  • Created logic to determine attack direction based on player input and character orientation

  • Implemented animation selection logic for directional attacks

  • Integrated directional attacks with the existing combat and animation systems

  • Built a combo-compatible system that supports branching attacks based on input direction

  • Ensured smooth transitions between directional attack animations

Attack Input Pressed

↓

Get Player Movement Input

↓

Convert Input To Direction

↓

Determine Attack Direction

↓

Select Corresponding Attack Animation

↓

Play Attack Montage

Technical Breakdown

The directional attack system determines which attack animation should play by evaluating the player's movement input relative to the character's forward direction.

When the player presses the attack input, the system analyzes the current movement input and determines the direction the player intends to attack. This direction is then used to select the corresponding animation.

Directional inputs are interpreted relative to the character's orientation rather than world direction, ensuring the attacks always match the player's movement relative to their character.

Blueprint Logic

Detecting Player Input Direction

When the player presses the attack button, the system reads the current movement input values.

  1. Retrieve the player's movement input vector

  2. Normalize the vector to determine direction

  3. Compare the direction relative to the character's forward vector

This allows the system to determine whether the player is attacking:

  • Forward

  • Backward

  • Left

  • Right

Determining Attack Direction

The system compares the movement direction against the character’s orientation.

Example logic:

  • Forward input → Forward attack

  • Backward input → Back attack

  • Left input → Left attack

  • Right input → Right attack

This allows the attack system to dynamically select different animations based on player intent.

Animation Selection

Once the direction is determined, the system selects the correct attack animation.

Each attack direction corresponds to a specific animation montage section. The system plays the appropriate animation based on the detected direction.

This allows attacks to feel more responsive and varied during combat.

Behavior During Combat

The directional system integrates with the overall combat logic.

  • If the player attacks while moving forward → forward strike

  • If the player attacks while strafing → side strike

  • If the player attacks while retreating → backward strike

This allows the player to control the type of attack they perform through movement input.

Challenges & Solutions

Determining Direction Relative to Character Orientation

Early versions of the system used world direction, which caused attacks to trigger incorrectly when the player rotated.

Solution

The system evaluates movement input relative to the character’s forward direction, ensuring attacks always align with the character’s orientation.

Maintaining Smooth Combat Flow

Directional attacks initially caused abrupt animation transitions.

Solution

Directional attack animations were integrated into the combat animation system to ensure transitions remained smooth and responsive.

🛠Support Gameplay Systems🛠

AI Detection System

System Summary

Implemented an AI detection system that allows enemies to gradually detect the player through a suspicion meter rather than instantly entering combat. The system evaluates whether the player is within the enemy's field of view and unobstructed by environment geometry. When the player is detected, the enemy’s suspicion value increases over time until a threshold is reached.

Once the suspicion threshold is exceeded, the AI transitions from an idle or patrol state into combat behavior.

What I Built

Responsibilities

  • Designed and implemented an AI detection and suspicion system in Unreal Engine Blueprints

  • Built player visibility detection using line traces

  • Created a suspicion meter that increases and decreases based on player visibility

  • Implemented field-of-view checks to determine if the player is within the enemy’s vision cone

  • Integrated detection logic with Behavior Trees and Blackboard variables

  • Built logic for state transitions between patrol, investigate, and combat behaviors

Player Enters Vision Range

↓

Check Field of View

↓

Line Trace Confirms Visibility

↓

Increase Suspicion Meter

↓

Suspicion Reaches Threshold

↓

AI Enters Combat State

Technical Breakdown

The detection system evaluates whether the player is visible to the enemy through a combination of distance checks, field-of-view validation, and line-of-sight tracing.

When the player enters the enemy’s vision range and is within the field of view, a line trace is used to confirm that no objects are blocking visibility.

If the player remains visible, the AI’s suspicion value increases gradually. When the suspicion value exceeds a defined threshold, the enemy transitions into combat behavior.

If the player leaves the enemy’s vision, suspicion decreases over time until the enemy returns to its idle state.

This creates more believable enemy awareness by allowing detection to build gradually instead of triggering instantly.

Challenges & Solutions

Maintaining Believable AI Behavior

Enemies instantly returning to idle after losing sight of the player felt unnatural.

Solution

Suspicion gradually decreases over time, allowing enemies to remain alert briefly before returning to patrol behavior.

Wall Climbing & Mantling Mechanic

System Summary

Implemented a traversal system that allows the player to climb vertical surfaces and mantle over ledges. The system detects climbable walls, aligns the character to the surface, and transitions into a climbing state where the player can move vertically along the wall.

When the player reaches the top of a climbable surface, the system detects the ledge and triggers a mantling animation that moves the character smoothly onto the platform.

What I Built

Responsibilities

  • Designed and implemented a wall climbing traversal system in Unreal Engine Blueprints

  • Built surface detection logic using traces to identify climbable walls

  • Implemented character alignment to wall surfaces using surface normals

  • Created a climb state system that transitions between locomotion and climbing

  • Developed ledge detection logic to determine when mantling should occur

  • Integrated mantle animations for transitioning from climbing to standing on top of surfaces

  • Connected traversal logic with the animation system and character movement

Climb Input

↓

Forward Wall Detection

↓

Validate Climbable Surface

↓

Align Character To Wall

↓

Enter Climb State

↓

Move Along Wall Surface

↓

Check For Ledge Above

↓

Trigger Mantle Animation

↓

Return To Normal Movement

Technical Breakdown

The traversal system begins by detecting climbable surfaces in front of the player using a forward trace. If a valid surface is detected, the system evaluates the surface normal and rotates the character so they align with the wall.

Once aligned, the player enters a climbing state where movement is restricted to vertical motion along the wall surface.

While climbing, the system continuously checks for the presence of a ledge above the player. If a valid ledge is detected, the character transitions into a mantling state where an animation montage pulls the character up onto the surface.

This creates a smooth transition from climbing to standing on top of the obstacle.

Challenges & Solutions

Detecting Valid Mantle Positions

Determining when a ledge was valid for mantling required distinguishing between a wall surface and an actual ledge.

Solution

The system uses a secondary trace above the player to confirm that there is empty space beyond the wall. This ensures mantling only occurs when the player is near the top of a climbable surface.

Vaulting Mechanic

System Summary

Implemented a vaulting traversal system that allows the player to dynamically move over low obstacles during movement. The system detects vaultable objects in front of the character and triggers an animation that moves the player smoothly over the obstacle.

What I Built

Responsibilities

  • Designed and implemented a dynamic vaulting traversal system in Unreal Engine Blueprints

  • Created forward obstacle detection using traces to identify vaultable objects

  • Implemented height validation logic to determine whether an obstacle can be vaulted

  • Integrated vaulting with the character movement and animation systems

  • Ensured vaulting transitions smoothly back into normal locomotion

Player Moving Forward

↓

Forward Obstacle Detection

↓

Validate Obstacle Height

↓

Confirm Vault Conditions

↓

Trigger Vault Animation

↓

Character Moves Over Obstacle

↓

Return To Normal Movement

Technical Breakdown

The vault system begins by detecting obstacles in front of the player while they are moving forward. When a potential obstacle is detected, the system evaluates whether the object is low enough to be vaulted.

If the obstacle meets the height and distance requirements, the vault sequence is triggered.

During the vault animation, the character temporarily enters a traversal state where normal movement is paused and the animation handles the movement across the obstacle. Once the vault animation completes, the character returns to standard locomotion.

Challenges & Solutions

Traversal Conflicts

Since the project also includes climbing and mantling systems, vaulting needed to avoid triggering when those systems should take priority.

Solution

Traversal conditions were ordered so that vaulting only triggers for low obstacles, while taller surfaces trigger climbing or mantling systems.

Grapple Hook Mechanic

System Summary

Implemented a grapple hook traversal mechanic that allows the player to quickly move to elevated locations by targeting grapple points in the environment. When the player activates the grapple input, the system identifies a valid grapple target and launches the character toward it.

The mechanic provides fast vertical mobility and expands traversal options, allowing players to access rooftops and elevated structures during exploration or combat.

What I Built

Responsibilities

  • Designed and implemented a grapple hook traversal system in Unreal Engine Blueprints

  • Created logic for detecting valid grapple targets in the environment

  • Implemented target validation checks to ensure grapple points are reachable

  • Built the logic for launching the player toward the grapple location

  • Integrated grapple traversal with the character movement and animation systems

  • Ensured smooth transitions between grappling and normal locomotion

Grapple Input

↓

Detect Grapple Target

↓

Validate Target Distance

↓

Calculate Direction To Target

↓

Launch Character Toward Target

↓

Reach Grapple Location

↓

Return To Normal Movement

Technical Breakdown

The grapple system begins by identifying valid grapple points in front of the player. When the grapple input is pressed, the system searches for a valid target within range.

If a grapple point is detected, the system calculates the direction from the player to the target and launches the character toward that position. During this movement, the character temporarily enters a traversal state until the grapple movement finishes.

Once the character reaches the grapple point, control is returned to the player and normal movement resumes.

This allows the player to quickly traverse vertical spaces and reach elevated areas.

Challenges & Solutions

Maintaining Smooth Movement

Directly teleporting the player to the grapple point felt unnatural and removed the sense of movement.

Solution

Implemented movement toward the grapple location instead of teleportation, creating a smoother and more dynamic traversal experience.

Quest & Objective Tracking System

System Summary

Implemented a quest objective tracking system that allows multiple objectives to be active simultaneously. Instead of progressing through objectives one at a time, all objectives for a quest are displayed in the quest HUD and can be completed in any order.

Gameplay events update the status of each objective, and the quest is completed once all objectives have been fulfilled.

This structure allows players to approach objectives freely while still tracking overall quest progress.

What I Built

Responsibilities

  • Designed and implemented a quest objective tracking system in Unreal Engine Blueprints

  • Built logic for tracking multiple active objectives simultaneously

  • Created a system that allows objectives to be completed in any order

  • Implemented communication between gameplay events and the quest system

  • Integrated objective updates with the quest HUD

  • Built logic for quest completion once all objectives are finished

Quest Activated

↓

Initialize All Objectives

↓

Display Objectives In Quest HUD

↓

Player Performs Gameplay Actions

↓

Quest System Checks Objective Conditions

↓

Matching Objective Marked Complete

↓

HUD Updates Objective Status

↓

All Objectives Completed

↓

Quest Completed

Technical Breakdown

The quest system manages a list of objectives associated with a quest. When the quest begins, all objectives are initialized and displayed in the quest HUD.

Each objective listens for specific gameplay events such as reaching locations, interacting with objects, or completing tasks.

When the player completes one of these actions, the system checks whether the action corresponds to an active objective. If it does, the objective is marked as completed and the HUD updates to reflect the progress.

The quest is completed when every objective in the objective list has been marked as finished.

This approach allows players to complete objectives in any order while still tracking overall quest completion.

Challenges & Solutions

Managing Multiple Objectives Simultaneously

Allowing objectives to be completed in any order required a flexible tracking system.

Solution

Objectives are stored in a list and tracked individually. Each objective maintains its own completion state, allowing the system to update them independently.