Tristan Anglin
Software Engineer | Systems & UI Architect
Actively seeking opportunities
|
Growing up surrounded by complex systems and an extensive collection of tabletop games gave me an intuitive grasp of data architecture, balancing, and rigorous logic design long before writing my first line of code.
My programming journey began in 2016 with Python, quickly expanding into self-taught Java development with projects like "Your Dark Side." This foundation evolved into a formal passion for robust software architecture, high-performance computing, and clean code principles.
A 2026 Honors Graduate in Game Development with a 3.86 GPA, I specialize in building modular systems, dynamic UI architectures with a highly efficient, and AI-accelerated workflow.
|
Programming
Workflow & Version Control
Development Environments & Engines
Art, Audio & UI Design
|
Game Vault
An AI-accelerated full-stack web application built via Google AI Studio to organize, track, and filter a 300+ item board game collection. Featuring vision-based box detection prompts and custom vault management, it enables users to seamlessly filter by player count, duration, and mechanics.
Technical Features
- Round Transition Automation: Programmed a centralized Game Director manager using an state-driven architecture to dynamically control round scaling curves, grace periods, and clear conditions.
- Decoupled ScriptableObject Databases: Created data-driven configuration arrays for items, enemy scaling variations, and progressive round modifiers to maximize code reusability.
- Robust Input Management: Implemented smooth mechanics built natively around the updated Unity Input System for modular control handling profiles.
Technical Post-Mortem
Architecting a 4-player co-op Musou game introduced severe replication challenges. Systems that performed flawlessly in standalone environments suffered from client-side race conditions and severe tracking variance during high-density enemy swarms.
Enforced strict server-sided logic for vital game state (loot, damage, spell tracking) and decoupled local client-side UI visual execution completely from back-end replicated states to secure stability.
In future multiplayer titles, I adopt a network-first prototyping rule. No gameplay component profile is built in isolation; systems are integrated with replication parameters and network emulation layers from day one to neutralize latency margins.
- Dynamic TileView Inventory Architecture: Built the core inventory framework utilizing a high-performance
UTileViewlist widget, enabling seamless, stutter-free dynamic adding, removing, and sorting of items across inventory grids with automated data-bound updates. - Event-Driven Attribute Bindings: Built responsive UI event delegates triggered by state changes (e.g., intelligence attributes dynamically recalculating spell cost displays and actual mana consumption in real time) to eliminate expensive tick-based UMG evaluations.
- 3D Skeletal Preview Integration: Embedded a real-time 3D skeletal mesh preview inside the inventory interface that dynamically updates based on the player's class selection and equipped gear.
Phase 1: Screen Wireframe & Core Functional Grid
Phase 2: Vector Asset Pipeline Integration
Phase 3: Responsive HUD State & Drag Contexts
Engineered a fully replicated pre-game match lobby supporting seamless 4-player coordination, real-time class selection syncing, host-restricted authority settings, and local area network (LAN) session discovery.
Interactive character selection buttons instantly query and display class-specific attributes, previewing passive bonuses, health pools, and offensive scaling factors dynamically upon selection.
Difficulty configuration toggles restrict write permissions strictly to the lobby host via network RPCs, broadcasting updated difficulty parameters to all connected clients in real time.
Integrated a session search pipeline allowing players to scan for active local servers, parse ping data, and populate open lobby slots instantly upon query execution.
🔍 Click to expand Networked Lobby Interface
Designed and implemented a meta-progression architecture linking accumulated player leveling metrics directly to account-wide stat bonuses, empowering players to spend earned progression currency to permanently enhance character performance between runs. The system hooks into the modular save management framework to guarantee atomic writes of purchased milestone nodes.
🔍 Click to expand Meta-Progression Menu
Built a robust settings interface featuring a dedicated keybindings subsystem driven by a scrollable UTileView list widget. Players can instantly select actions, bind custom keys through real-time input listening events, and handle conflict validation seamlessly.
🔍 Click to expand Keybinds Remapper Interface
Designed responsive, arcade-style feedback loops utilizing custom UMG widgets, motion graphics sequences, and state-driven mouse events for seamless player engagement.
Unexamined "New Item" indicators trigger subtle hover-shake animations and rarity glow borders, pairing with replicated structs that display detailed tooltips on hover.
Engineered cinematic milestone notifications triggered by player progression events, featuring scale-in transitions, glowing typography overlays, and particle bursts.
Implemented interactive upgrade motion sequences within the Forge interface, synchronizing material consumption animations with audio cues and stat output preview renders.
Engineered custom visual payloads by subclassing UDragDropOperation in C++. This allows items to fluidly pass raw FItemData memory frames across completely decoupled interface viewports—enabling smooth dragging between the player inventory, equipment armory, and crafting forge windows with zero tight coupling.
Beyond the core HUD and inventory, considerable systems engineering was dedicated to foundational architectural loops—including the responsive Main Menu, a robust Save File Management suite, and proactive UI lifecycle safety routines. World destruction without proactive UI tracking causes fatal engine null-pointer references during level transitions. This cleanup routine systematically unbinds input frames, culls active viewports, and marks non-viewport/3D widgets directly for clean garbage collection before map streams clear.
🔍 Click to expand C++ Routine
- Architected Core Separation: Refactored codebase into a clean model splitting responsibilities across Character Class (movement, combat, and damage logic), Player Controller (UI management and networked interactions), and Player State (persistent multiplayer variables).
- Engineered Seamless Travel Persistence: Overrode
APlayerState::CopyPropertiesto intercept tear-down loops and safely carry player data, stats, inventory, and meta-progression across seamless travel level transitions. - Implemented Server Authority: Developed secure server-sided logic for synchronized loot drops, currency pools, bulk armory transactions, and 4-player lobby state management.
- Class-Locked Signature Weapons: Designed a scaling weapon system unique to each class (Nemesis, Ares, Aphrodite, Artemis) that grows with the player to ensure continuous combat viability and eliminate soft-locks.
During seamless travel transitions, the engine destroys and regenerates Actor states. To prevent loss of progress, CopyProperties intercepts the tear-down to manually pass player statistics, currencies, and deeply copied inventory outer arrays over to the newly instantiated world state.
🔍 Click to expand
- Modular Inventory Optimization: Programmed a decoupled Inventory Component separating item processing into a light, flat replication struct data block (
FItemData) inside a singleUItemObjectwrapper to protect network bandwidth. - Cross-Item Forging Suite: Created an algebraic upgrading engine allowing any two items to be merged regardless of type, level, or rarity, utilizing secure server-side weighted probability tables to determine output stats and rarity tiers.
- Secure Global Shop Loop: Enforced strict server validation across the Armory vendor pool, supporting bulk sell features ("Sell All by Rarity") while blocking unauthorized state manipulation.
By separating the lightweight primitive data array matrix (FItemData) from the higher-level wrapper (UItemObject), the architecture minimizes RPC signature size during bulk trades.
🔍 Click to expand
The item combination system compresses dual inputs down to upward-tier elements. All logic resolves deterministically via random probability weighting algorithms locked behind authority barriers.
🔍 Click to expand
- Multi-Phase Encounter Architecture: Programmed the full multi-tiered Hades boss sequence, integrating custom animation blends, cinematic opening introductions for the Obelisk mechanics, and phase transition logic.
- Networked Telegraph Prediction: Engineered an original approach generating synchronized visual telegraph projections locally across clients instantly, keeping high-frequency fireball volleys and shockwave phases tight under latency.
- Adaptive Difficulty Scaling: Constructed real-time algorithmic triggers adapting sweep speeds, rotation frequencies, and projectile damage attributes tied directly to lobby difficulty tiers (Boar, Bull, Lion, Hydra, Cerberus).
Core Contributions
- Developed a lightweight 2D rendering engine from the ground up using Modern C++ and OpenGL.
- Implemented a dynamic Top-Down Depth Sorting (Y-sorting) system to manage draw call ordering.
- Optimized visual layering to ensure foreground structures naturally overlap background entities.
- Engineered a tile-based grid system utilizing the A* Search Algorithm for enemy navigation.
- Implemented real-time path recalculation, allowing AI to adapt instantly as players place walls.
- Integrated validation logic to ensure a valid path to the objective is maintained at all times.
- Created a hover-state system for real-time range visualization and player feedback.
- Built a kill-based progression system that triggers dynamic stat scaling for towers.
- Programmed visual transformations via automated sprite swaps to reflect tower "level up" states.
- Developed a robust snapping and validation system for tile-based structure placement.
- Architected interaction logic between player-built obstacles and the underlying navigation mesh.
- Managed collision detection to ensure accurate interactions with enemy hitboxes.
Technical Post-Mortem
Building an engine from scratch meant handling raw matrices. I encountered geometric complications getting vertex shaders to accurately rotate projectiles toward target headings, alongside performance bottlenecks when multiple active entities computed A* path calculations on a mutable grid simultaneously.
Resolved sprite transformation defects by normalizing directional vectors and feeding precise arctangent orientations directly into the shader pipeline. Optimized navigation data by caching computed paths, only forcing an A* re-evaluation when structural map changes invalidated the current grid node layout.
To maximize lower-level execution efficiency, I would swap out standard pathfinding references for a Flow Field / Vector Field navigation model. This would allow an infinite number of swarm entities to share a single directional vector grid, completely eliminating per-unit CPU overhead.
Core Contributions
- Engineered a multi-class selection system as the foundation for character state management.
- Implemented attribute scaling logic to handle unique progression paths for different classes.
- Developed a robust inventory system and NPC interaction framework for merchant economies.
- Programmed complex item valuation and transactional logic for buying/selling mechanics.
- Integrated advanced A* pathfinding algorithms to ensure intelligent enemy AI navigation.
- Optimized path calculation for complex, tile-based fantasy environments.
- Designed an extensible spell architecture for easy integration of new combat mechanics and effects.
- Developed a real-time minimap system featuring entity tracking and dynamic zoom capabilities.
Technical Post-Mortem
As an early project, the initial vision over-scoped heavily on content scale. Trying to build multiple sweeping features simultaneously without a concrete framework threatened to leave the project completely unplayable and fractured.
Halted wide-scale asset development and shifted focus to isolating core modular data. Successfully targeted and polished the underlying mechanics: creating an extensible inventory loop, working out class selection persistence, and stabilizing the mathematical equations governing RPG stat scaling.
This project taught me the vital importance of producing a Minimum Viable Product (MVP). I would now implement a strict milestone pipeline, ensuring the core transactional loop and gameplay states are rock-solid before mapping out extensive horizontal mechanics or game content blocks.
Core Contributions
- Designed a multi-class selection system featuring 8 unique character classes.
- Implemented discrete starting attribute sets to differentiate class-based gameplay.
- Developed a real-time combat engine supporting 8-directional movement and hit detection.
- Programmed enemy homing logic to dynamically track and engage the player.
- Scripted a dynamic reward system that triggers randomized XP, gold, and item drops upon enemy defeat.
- Engineered a persistent inventory and leveling framework to track character progression.
- Architected a multi-scene menu flow, including dungeon selection and inventory management interfaces.
- Integrated functional UI elements to bridge technical systems with user feedback.
Technical Post-Mortem
Attempting a sprawling, feature-heavy classic RPG while coding entirely on an iPad environment led to immediate scope management and technical hurdles. The feature set grew faster than the architectural framework could support.
Stripped out secondary systemic systems to safeguard production. Focused purely on establishing working architectural baselines: locking down the database structures for player inventories, debugging enemy AI detection states, and deploying a functional numerical prototype.
This project served as my early wake-up call regarding design constraints. Today, I approach pre-production by establishing a formal Technical Design Document (TDD), using functional mockups to isolate systemic bottlenecks and protect scope limits before writing execution code.
Core Contributions
- Engineered an integrated economy system featuring a Stat Shop and a Spell Shop for mid-run power scaling.
- Implemented transactional logic for purchasing new magical abilities and upgrading multi-tier spell profiles.
- Programmed attribute modification systems that dynamically recalculate core player stats, including Haste (attack speed), Armor (flat damage reduction), and Dodge (percentage-based avoidance).
- Developed a dynamic Mana resource loop to regulate spell casting, complete with passive regeneration states and casting thresholds.
- Designed an extensible framework for diverse spell behaviors, linking ability cooldowns, area-of-effect parameters, and damage logic directly to player stats.
- Architected a round-based survival system with automated wave progression and escalating difficulty curves.
- Scripted dynamic AI spawning algorithms that increase enemy crowd density, scale base movement speed, and augment health pools as rounds progress.
- Optimized 2D collision handling to smoothly process a high volume of simultaneous enemy hitboxes.
Technical Post-Mortem
The prototype was initially structured around a traditional side-scrolling engine with a moving ground plane. This architecture generated persistent visual artifacting, tracking tearing, and logic bugs where collision boundaries routinely misaligned.
Instead of getting bogged down in cosmetic background scrolling, I flipped the layout vector. I clamped the player viewport to a clean, stationary backdrop and transferred the kinetic motion logic directly onto the incoming enemy swarm objects.
This taught me that player perception dictates mechanical design. Knowing what I know now, I would solve the original problem by running a parallax texture shader offset on a single static quad mesh, giving the perfect optical illusion of distance travel at zero performance or collision cost.