Aaron Goodwin
Gameplay Systems Developer
Unreal Engine 5 · C++ | Blueprint
Combat · AI Behavior · Technical Design
I build player-facing gameplay systems with an emphasis on responsive interaction, maintainable architecture, and rapid iteration. My recent work spans Unreal Engine combat and VR interaction, C++ gameplay architecture, enemy AI and encounter systems, and third-person shooter mechanics.
Featured Work
VR Combat Prototype
- Unreal Engine 5.7
- Blueprint · Niagara
- VR · Meta Quest
- Private Contract
Real-time projectile combat and tracked-hand deflection.
Chess-plosion
- Unreal Engine 5.7
- C++ · Paper2D
- Nxt Dev Studios
- In Development
Data-driven strategy game built around authoritative C++ gameplay state, legal-move simulation, and an evolving health/explosion combat system.
3rd Person Shooter
- Unreal Engine 5.4
- C++ · Blueprint
- Full Sail University
- Academic Portfolio
Shooter prototype combining projectile combat, damage, animation-driven firing, ranged enemy AI, spawning, and Blueprint/C++ integration.
Unreal Engine Gameplay Developer
Unreal Engine 5 · Blueprint · Niagara
Private Contract Prototype · In Development
VR Combat Prototype
This VR prototype is built around a simple physical combat challenge: a Djinn launches a sequence of fireballs at the player, who must track and deflect each incoming attack using stone deflectors attached to their VR hands.
I own the Unreal Engine development of the prototype, taking the gameplay from initial project setup through a complete playable loop with projectile targeting, collision, deflection, win/loss handling, attack variation, VFX, and runtime debugging.
Designing the
Core Interaction
The first goal was establishing a complete and reliable gameplay loop before adding polish. The Djinn needed to launch attacks sequentially, each projectile needed to track the player correctly, and the game needed to distinguish between successful deflections, environmental impacts, and player hits.The resulting system supports the project's full 111-projectile survival sequence and registers each projectile outcome with the central game-state logic.
Projectile Outcome Flow — Each fireball resolves independently against the player, deflectors, or environment before reporting its result to the game-state system.
Making Attacks
Less Predictable
Anticipating that straight-line targeting produced shots that were visually repetitive and difficult to read, I instead designed four curved trajectory profiles—High Left, High Right, Low Left, and Low Right—while preserving the player's position as the final target.This system also tracks the previous attack profile and prevents immediate repetition. Additional midpoint variation changes the shape of individual arcs, providing controlled randomness without making attacks feel arbitrary.
Controlled Attack Variation — Randomized trajectory selection increases spatial variety while repeat-prevention keeps consecutive attacks from following the same profile.
VR Deflection & Collision
Player interaction relies on dedicated stone deflectors attached to the tracked hands. I iterated on collider size, ownership, and collision settings to make blocking responsive without requiring unrealistically precise hand placement.During development, projectile interaction was changed from overlap-based behavior to blocking collision where appropriate, and destruction logic was moved into the collision-resolution path so projectile outcomes remained consistent.
VFX & Feedback
I replaced the original visible projectile mesh with a Niagara-based fireball and created separate effects for the traveling projectile, Djinn fire plume, and impacts.Projectile visuals are separated from gameplay collision through a dedicated visual root, allowing the effect to rotate along curved trajectories without interfering with movement or collision behavior. Impact VFX spawn independently so they can finish playing after the projectile actor has been destroyed.
Debugging & Iteration
Notable problems I have addressed include collision events not resolving correctly; projectiles being destroyed at the wrong stage; missing GameManager initialization; invalid runtime references; projectile VFX remaining vertically oriented; impact effects disappearing when the projectile was destroyed.
Current State
The current prototype has a complete VR combat loop, tracked-hand deflection, randomized curved projectile attacks, gameplay-state handling, and Niagara-based projectile and impact feedback. Remaining work is primarily presentation, final client-asset integration, audio, and polish.
Chess-plosion
Gameplay Systems Engineer · Technical Designer
Unreal Engine 5 · C++
2-Person Team · Nxt Dev Studios
Android · In Development
Chess-Plosion reworks traditional chess by giving pieces health and turning conventional captures into combat interactions capable of producing damage, explosions, and eventually chained board-state changes.I own the core gameplay, C++ architecture, rules, combat design, AI design, animation/assets, testing, and project management.
The Design Problem
Traditional chess assumes that a legal attack on an occupied square produces a capture. Chess-Plosion breaks that assumption.A defender may survive an attack. A defeated piece may explode. That explosion may damage nearby pieces, potentially creating additional outcomes.Because of that, the architecture cannot treat move, attack, and capture as interchangeable concepts.
Gameplay Architecture
The solution is to ensure runtime gameplay state is intentionally independent from actors, animation, UI, VFX, and cosmetic assets. This makes the same logical data usable for rule simulation, AI, testing, save/load reconstruction, and future multiplayer authority.
Authoritative Systems — I structured the project around explicit system ownership
Stateless Rules Evaluation
FChessRulesEngine operates on a logical position snapshot rather than live world actors.The current move-generation implementation, i.e. TryAddMoveToDestination(), supports Knight movement and rejects invalid candidates based on board boundaries, friendly occupancy, and invalid targets.
As a validation checkpoint, the Black Knight at g8 correctly returns only h6 and f6 from the standard starting position.
Move Candidate Validation — The stateless rules layer classifies candidate destinations as moves or attacks while rejecting invalid board positions, friendly occupancy, and illegal targets.
CommitStandardChessMove()
This function efficiently scaffolds the architecture by:- Distinguishing attack vs. normal move
- Verifying target occupancy and target piece state
- Rejecting friendly targets / King capture
- Completing all validation before mutation
- Updating source/destination occupancy
- Updating runtime piece state
- Removing captured piece state, actor, and definition
- Syncing the surviving visual actor
- Validating the board
Authoritative Move Commit — After a move has been approved, BoardManager applies board occupancy and runtime-state changes as a single logical transaction, removes captured state, then synchronizes presentation.
Data-driven design
Gameplay identity, mutable runtime state, and visual presentation are stored separately. This allows piece balance and combat tuning to change without duplicating gameplay definitions for colors, skins, or presentation variants.
Scope & Production
I also maintain project milestones, feature prioritization, testing strategy, and technical documentation. Features are explicitly classified as Implement, Proposed, Revisit, or Cut so scope decisions remain visible rather than accumulating indefinitely.
Current State
The current build supports authoritative board generation, 32 starting pieces, piece registries and occupancy, native gameplay foundations, position snapshots, Paper2D visuals, and legal-move generation.The next milestone is a fully playable standard-chess loop featuring Chess-Plosion-specific combat resolution.
Implemented
The current Unreal C++ foundation includes native GameMode and PlayerController classes, shared coordinate and piece-state contracts, authoritative board occupancy, position snapshots, a complete starting position, and the foundation of a stateless rules engine.
In Development
The Chess-Plosion-specific combat layer is the next major systems milestone.The design separates action intent from resolved outcomes so an attack can produce survival, defeat, explosions, ricochet, or secondary board changes without forcing those rules into the movement system.
3rd Person Shooter
Unreal Engine Gameplay Programmer
Unreal Engine 5.4 · C++ | Blueprint
Full Sail University
Academic Portfolio
This Unreal Engine project focused on building the interconnected gameplay systems required for functional third-person ranged combat: firing, projectiles, damage, animation, enemy behavior, spawning, and player feedback.The project also gave me practical experience prototyping systems in Blueprint and moving appropriate gameplay responsibility into C++ while retaining designer-facing controls.
Combat Pipeline
Projectile firing is connected to a modular damage path rather than handled as an isolated weapon event.
PerformAttack()
This function demonstrates that the weapon owns its firing constraints and efficiently manages a variety of responsibilities:- Resolves controller/camera aim
- Creates the projectile with ownership/instigator information
- Initializes projectile direction
- Consumes ammunition
- Enforces fire cadence with a timer
- Broadcasts the firing event for other gameplay/presentation systems
Weapon Firing Pipeline — The C++ weapon validates firing state, resolves controller-based aim, spawns and initializes the projectile, updates ammunition, enforces fire cadence, and broadcasts the attack event for dependent gameplay and presentation systems.
Animation-Driven Gameplay
Animation montages and animation notifies synchronize gameplay events with firing, hit reactions, and death behaviors.This allowed visual timing to remain connected to actual gameplay state rather than relying on arbitrary delays.
ExecuteTask()
This function has more robust capabilities than a conventional Behavior Tree task that simply calls and returns success:- Obtains its controlled pawn
- Validates the expected agent/interface
- Binds to an action-completion delegate before starting the action
- Invokes combat through IEnemyInterface
- Completes the latent Behavior Tree task when the weapon finishes firing
- Explicitly removes its delegate binding during completion / abort / cleanup
Action Completion & Cleanup
Event-Driven AI Combat Task — The Behavior Tree attack task remains latent while the weapon action executes, then completes through a delegate callback rather than relying on arbitrary delays. Delegate bindings are explicitly removed on completion and abort.
Spawning & Encounter Control
I also built configurable spawning actors with limits, cooldowns, and destruction behavior, providing basic control over how enemies enter the combat encounter.
SpawnAgent()
This method concisely manages enemy spawn points by:- Creating the agent and validating its controller
- Notifies GameMode so runtime enemy counts remain authoritative
- Decrements the spawn budget
- Schedules the next spawn using SpawnInterval
Enemy behavior supports player detection, pursuit, and ranged combat through combined C++ and Blueprint logic.
Runtime Encounter Spawning — The spawner controls a finite enemy budget and spawn cadence, initializes newly created AI, registers runtime enemies with GameMode, and schedules subsequent spawns without per-frame polling.
Blueprint → C++
Several mechanics began as rapid Blueprint prototypes and were later translated into C++ implementations to improve structure and control while preserving Blueprint-facing parameters for iteration.That workflow became an important part of how I approach Unreal development: prototype quickly, identify stable system boundaries, move appropriate authority into C++, and preserve tuning access for designers.
RETURN TO FEATURED WHEN COMPLETE
Earth Untamed
- Unity 6
- C# · Blender
- Full Sail University
- Academic Portfolio
Horror-survival prototype featuring perception-driven enemy AI, systemic encounter pacing, enemy combat, and custom debugging tools.
Earth Untamed
Gameplay Systems Developer / Project Manager
Unity · C#
Academic Project
Enemy AI · Encounter Systems
Show player/AI doing something meaningful
Earth Untamed is a horror-survival project where enemy behavior and encounter pacing are used to reinforce uncertainty and psychological pressure.My responsibilities included enemy AI, enemy combat, animation-supporting systems, encounter pacing, project management, the game's 3D skybox, and portions of level design.
AI & Encounter Design
I developed perception-driven enemy behavior around detection, pursuit, aggression, and combat.Enemy spawning and concurrent entity limits were also used as pacing tools rather than simply as content-generation systems.
Show AI transitioning thru behavior
Tuning the encounter
A major part of the work was iterative tuning rather than initial implementation.I adjusted spawn rates, aggression thresholds, combat timing, and concurrent enemy counts to shape how quickly pressure escalated and how much information the player had time to process.
Show a representative encounter
Combat Feedback
Enemy attacks were integrated with animation-driven feedback, player damage, and UI response so combat outcomes were clearly communicated to the player.
Show hit-reaction clip
Developer Tools
To speed iteration, I built custom Unity editor controls and scene gizmos for AI validation and gameplay tuning.These tools made behavior easier to inspect directly in the editor and reduced the need to repeatedly alter code just to test parameter changes.
Show editor w/ gizmos & inspector tuning controls
Cross-Disciplinary Ownership
Alongside gameplay implementation, I coordinated project workflow and contributed to animation, environmental presentation, and portions of the level layout. The project required regularly moving between programming, design, debugging, and production responsibilities.
Result
The finished academic prototype demonstrates a complete enemy loop from perception through pursuit and combat, along with systemic spawn and aggression controls and editor-facing tools for iteration.
Sanity-Driven Encounter System
As players move away from safe zones such as campfires, their sanity gradually declines, increasing environmental danger. At critical thresholds, hostile entities known as Shadow Children begin to emerge and pursue the player.
During early testing, encounters lacked urgency, as enemies failed to meaningfully pressure the player. To address this, I implemented perception-driven behavior rules where enemies freeze under direct observation but aggressively advance when outside the player’s view.
Player Experience Outcome
This created a continuous tension loop:
- Maintaining visual contact provides safety but limits movement
- Looking away enables progress but increases vulnerability
The system forces players to make constant trade-offs between awareness and navigation, reinforcing anxiety and sustained engagement without relying on scripted events.
This work emphasized using simple systemic rules to produce emergent psychological pressure, aligning gameplay mechanics directly with player emotion and moment-to-moment decision-making.
Custom Debugging Tools Development
In addition to gameplay systems engineering, I am familiar custom debug tools development. I wrote visual and data-driven debugging scripts for the enemy AI systems
Ghostlight
Unity | C#
3 Person Team
Ghostlight is a survival-focused gameplay prototype built around exploration, preparation, and environmental tension. Players alternate between foraging for herbs in a hostile environment while being pursued by a persistent enemy before returning to the safety of home to craft potions and prepare for the next expedition.
Potion crafting involves setting up the recipe book at the crafting station and processing ingredients in the right ways based on the chosen recipe.
This structure emphasizes player vulnerability and preparation, encouraging careful resource management while navigating an unpredictable environment.
Jupiter Skybox
Blender | Krita | Unity
Data sourced from NASA Cosmic Imagery Database
This project involved creating a high-resolution skybox of Jupiter using publicly available imagery captured by NASA’s Hubble Space Telescope.
The goal was to transform real astronomical imagery into an environment background suitable for use within a real-time game engine.
To achieve this, I processed and arranged the source images to produce a seamless skybox texture that could wrap correctly around the game environment. A 3D model of Jupiter was also created in Blender to provide an accurate planetary reference within the scene.
The project served as an exercise in asset pipeline development, including texture preparation, 3D modeling integration, and environment rendering within a real-time engine.
Technical Skills
Languages & Engines
C#
Unity (URP)
C++, Blueprints
Unreal Engine 5
GD Script
Godot 4
Gameplay Systems
Data-Driven Programming
Event-Driven Architecture
Modular Combat & Damage Pipelines
AI Systems
Behavior Architecture & State Logic
Spawn Management Systems
Debugging
Building Custom Data-Driven & Visual Debugging Tools
Utilization of Industry-Standard Debugging Methods & Features
Project Management Tools
Git
Perforce
Jira
Confluence
About ME
I am a gameplay systems developer with a B.S. in Game Development from Full Sail University. I primarily work in Unreal Engine 5, C++, and Blueprint, with additional professional and project experience in Unity and C#.My work focuses on the systems that define moment-to-moment play: combat interactions, projectiles, AI behavior, game state, encounter pacing, rules systems, and the tools needed to tune and debug them.On small teams, I regularly straddle the boundary between engineering and design -- taking gameplay problems from technical design and prototyping through implementation, testing, tuning, feedback integration, and documentation.
Storytelling
I have been telling stories as long as anyone has been around to listen.My path into game development began in the online communities of the early 2000’s, experimenting through the collaborative role-playing forums of various fandoms like Star Wars and Lord of the Rings, wading through oceans of both in- and out-of-character relationships.Without realizing it, I was tinkering with narrative design, exploring character-driven interactions, navigating complex relationship dynamics, building detailed canonical lore and structured narrative planning.Those experiences became part of the process with which I build gameplay mechanics and systems today, telling stories to players through systems and interactions rather than words alone.
Exploring emotionally complex characters through my own art is one of my favorite ways to build narrative moments.
I love participating in the entire production pipeline, from concept through asset creation and gameplay programming.
I have often used manga to establish the most essential elements of my stories.
I enjoy developing narrative cornerstones and mechanics by detailing my character's personalities.
This provides opportunities to explore design and development that preserve a focus on the player's connection to the story.
Feel free to contact me via email or phone at any time.
706.575.5553