top of page

SYSTEMS & FEATURE DESIGN SUMMARY

Boat Mechanic (Buoyancy System & Player Interaction)

I implemented a dynamic boat system that realistically floats on Unreal Engine’s default water body using the built-in Buoyancy system.
I set up multiple buoyancy points across the hull of the boat to ensure stable floating and responsive physics. The system calculates buoyant forces per-point, keeping the boat level with water waves in real-time.
The player can enter and control the boat, steering it forward, backward, and turning left or right through applied physics forces and torque.
Additionally, I created a speed-based foam effect using Niagara particles that emit and scale according to the boat’s movement velocity, enhancing visual feedback and realism.

Key aspects:

  • Used Unreal’s Water Plugin and Buoyancy Components

  • Physics-based steering and floatation

  • Niagara foam system linked to boat speed

  • Player mounting & control system integrated via Blueprints

Dash Ability (GAS + C++)

I designed a dash mechanic using Unreal’s Gameplay Ability System (GAS).
The ability triggers a rapid forward movement while consuming stamina, which is managed through a GAS Attribute Set and Gameplay Effect.
The ability has a cooldown and resource constraint, both implemented and replicated in C++ for precision and performance.
The stamina regenerates over time using a timer-driven regeneration function, with the values clamped to ensure they stay within defined limits.

Key aspects:

  • Built with GAS (Abilities, Effects, AttributeSets)

  • Stamina depletion and regeneration logic in C++

  • Custom cooldown system handled in C++

  • Integrated animation & input triggering

Health System (Depletion & Regeneration)

The health system is entirely built with GAS, featuring attribute replication and clamping.
Health values decrease when damage Gameplay Effects are applied, and gradually regenerate over time through a regeneration Gameplay Effect or timed logic.
All calculations are clamped in C++ to prevent values from exceeding max health or dropping below zero, ensuring stable and bug-free gameplay.

Key aspects:

  • Health AttributeSet managed through GAS

  • Regeneration handled via Gameplay Effects

  • Value clamping and validation in C++

  • Fully network-safe attribute replication

Train, Helicopter, and Cannon System (AI & Combat – Fully C++)

I developed an interactive system involving a train-mounted cannon and an AI-controlled helicopter, all implemented purely in C++.
The player can aim and shoot the cannon at the helicopter. Projectile trajectories and impact effects are handled through physics simulation.
The helicopter uses a custom AI behavior that allows it to hover in a radius and detect the player. Upon spotting the player, it enters a banking pursuit mode, maintaining altitude while circling or closing distance dynamically.

Key aspects:

  • Fully coded in C++ (no Blueprints)

  • Custom AI movement & detection logic

  • Player-controlled cannon aiming and shooting

  • Physics-based projectile and hit detection system

Bow and Arrow System with Niagara Firework Effect

I created a bow and arrow system where arrows can be fired with trajectory control and impact detection.
When an arrow hits a target, a Niagara firework effect is triggered at the point of impact, which I designed and tuned for timing and color variation.
The system handles arrow spawning, flight physics, and impact detection using Blueprint scripting and projectile components.

Key aspects:

  • Custom bow firing system

  • Projectile physics and hit event handling

  • Niagara effect integration for impact visuals

  • Adjustable draw strength and aiming controls

Riding System (Blueprint Interface Based)

The riding mechanic allows the player to mount and control an animal dynamically.
When the player approaches a rideable creature and presses the interaction key, a Blueprint Interface handles the communication between the player and the animal actor.
The player character attaches to the mount via a socket and transfers movement input control to the animal’s movement system.

Key aspects:

  • Blueprint Interface for clean player–mount communication

  • Attach/Detach logic for riding state transitions

  • Input redirection from player to animal

  • Smooth blend animations between on-foot and riding states

Floating Inventory (C++ Implementation)

I implemented a floating 3D inventory UI system above the player’s head entirely in C++.
The system spawns a world-space widget component that updates dynamically with item information.
All interactions (adding, removing, equipping items) are handled through custom C++ inventory logic, ensuring high performance and clean integration with gameplay systems.

Key aspects:

  • Fully coded in C++ (no Blueprint dependencies)

  • Dynamic world-space widget above player

  • Real-time inventory updates and synchronization

  • Modular, extensible design

Flying System (Modified Purchased Asset)

For the flying system, I integrated a third-party flight movement asset and customized it for my player character.
I replaced the default pawn with my own custom character while adapting input bindings, animation blueprints, and camera behavior to match my setup.
This process involved understanding the asset’s codebase, identifying key functions, and extending them for my gameplay context.

Key aspects:

  • Integrated purchased flight system

  • Customized for custom character and input logic

  • Adjusted camera and animation blueprints

  • Extended existing code for smoother control

bottom of page