Skystrike - Aidan Ko

Game Project - Skystrike

2026 Aidan Ko

Software: Unreal Engine, Maya, Substance 3D

I began this solo project during my final year at Gnomon to bridge my skills between the 3D art pipeline and in-engine game development. Built using Unreal Blueprints, this game project takes my experience in rigging, animation, and object-oriented programming into dynamic locomotion, free-aim & precise shooting, spatial grid-based inventory and more. The following is a breakdown of some of these.

Character Motion

The base locomotion that most animations overlay on top of is a standard but finely tweaked blendspace that goes into the Idle/Walk/Run state machine. A lot of the details such as physics come from tweaks to bones, special inverse kinematics, and performant AnimDynamics nodes in the animation blueprint.

The hair is a simple but effective cloth simulation running on an extremely low poly proxy mesh that the hair cards then follow by weight.

Although there is some clipping in both the body and hair because it isn’t true simulation, the result is extremely light-weight character dynamics that brings more life to the player’s character.

Decoupled Aiming System

Traditional third-person cameras usually lock the character’s orientation to the viewport. For this project, I developed an option for a decoupled aiming system to provide a more tactical, methodical combat style. This allows the player to maintain a stable camera angle while aiming freely, which may be advantageous in tight corridors and similar environments where camera collisions might become disorienting.

Goal: Upon activation, mouse and controller inputs drive a free-moving crosshair. The character and weapon procedurally track this target in world space, rather than relying on a fixed screen center.

Method:

Animation Layering: I implemented a custom skeleton branch with specific weighting to allow the upper body to procedurally track the aim target. This is layered additively over the base locomotion blendspace.
Procedural Aiming: While the primary aim target is updated via raw input, the weapon hand rotation is driven by a separate deprojected screen-to-world vector (which also feeds into the two-step line trace system).
Architecture: To ensure future-proofing for multiplayer compatibility, the player character handles the inputs and values (where it can be replicated) which is then passed to the Animation Blueprint for execution.

Two-step Line Trace for Hit Location

With a free-aim system where the player can be shooting at different parts of the screen, and shoulder swapping that would flip the horizontal aim location, I need to ensure that the hit locations are also precise and do not allow for shooting through obstacles/collision.

Goal: Line trace (raycast) to the precise hit location of the player’s cursor accounting for muzzle location.

Method:

Trace #1: This overlaps with the previous decoupled aiming system. I used a deproject-to-world-space node multiplied down the camera direction for the aiming, however, for the hit it needs an accurate location which comes from a line trace in the exact same direction. The hit result is what I need for the next trace.
Trace #2: The second trace comes from the muzzle location, taken from a locator actor (an Arrow) that each ranged weapon has, and extends to the hit location of the first trace. This will stop when it hits a valid collision.

Inventory (spatial, grid based)

I want my inventory system to exist in a true grid-based, 2D spatial context rather than as a simple list of stored items. That meant each item needed meaningful position, size, and orientation within a bounded inventory space. To support this in Unreal, the system relies on two main parts: a player-parented inventory component that handles the underlying data, logic, and placement rules, and the UMG widget system, which visually represents that data in an interactive interface. This separation kept the gameplay logic independent from the UI while still letting the player intuitively move, rotate, place, and manage items inside the grid.

Goal: A modular spatial inventory that handles items of varying grid dimensions (e.g., 1×1, 1×2, 2×3) with drag-and-drop functionality. Using UMG (Unreal Motion Graphics).

Data-Driven Architecture: Item properties such as name, ID, 2D thumbnails, 3D meshes, and gameplay stats are organized using custom item structs.
Blueprint Inheritance: These Structs feed directly into my master item blueprint for all items to use for their data. By utilizing parent-to-child inheritance, I can rapidly generate and tweak new items without ever having to duplicate backend logic, all within blueprints.
Interaction & Collection Framework: To ensure clean communication between blueprints without creating hard references, I utilize Blueprint Interfaces. When the trace hits an interactable object, the Interface safely takes the item’s Struct data, destroys the world mesh, and accurately populates the 2D inventory grid with a replicated exact copy.
User Interface: Then I utilize Unreal’s drag operation

For the initial pickup of items, I use a sphere trace to simply capture the item in front of the character which works great for now as I build on the inventory.

In the future when the inventory is expanded upon more, this will be converted to sphere collider around the player which will target the closest item that contains the matching interface for items, which will allow for an interaction button to pick it up instead.