Implemented core AstroBot movement systems in C++, including movement, jumping, and hovering mechanics.

Developed the AstroBot dash ability using Blueprint Actor Components.

Created the Appa transport system using Blueprints, where the character follows a spline-based flight path to allow level designers to easily create level transitions. Implemented distance-based spawning/despawning and created wind trail VFX for the flight sequence.

Implemented an ability UI system allowing players to switch abilities and view unlocked abilities.

Assisted in improving the rock pull gameplay mechanic.

Created a launchpad system in Blueprints with adjustable launch velocity and directional control, defined using an arrow component for easy placement by designers.

Added animations for destructible dropping platforms.

Refactored the weather system to make it more modular and customizable, improving flexibility for designers.

Created destructible props using UE5 Chaos Fracture (e.g., destructible vases).

Implemented physics-enabled vines to add environmental interactivity.

Built PCG graphs to allow designers to quickly generate bridges using splines.

Created a PCG graph for generating ice rinks that follow spline paths for level layout.

Modeled basalt column formations using Blender Geometry Nodes, generating a high-poly mesh and baking it down for game use.

Created a custom grass material with wind-driven sway animation.

Developed Niagara particle systems for falling leaves that accumulate on the ground, adding environmental ambience.

Built a water shader based on UE5's Single Layer Water, extending it with waves, shoreline foam, sea foam, and mesh distance field interactions.

Created a dynamic ice material simulating slowly shifting ice sheets across water.

Developed a procedural snow material for the ice island environment.

Created procedural materials for the grass island allowing moss, grass, and wetness blending.

Modeled cliff assets and basalt formations used in the ice island environment.

Created lava textures and basalt column assets.

Refreshed the checkpoint system visual, creating a new hologram material and custom model based on AstroBot's head, including custom eye animations and bounce animations when activated.

Helped design and build the layout and level design of the grass island.

Developed fully networked core RTS gameplay systems using Mirror Networking.

Implemented a networked building system allowing players to construct and place structures during multiplayer matches.

Built a networked unit system for spawning, controlling, and synchronizing units across clients.

Created a unit formation system enabling groups of units to move and position strategically.

Implemented a networked player controller for issuing commands and interacting with the game world.

Developed multiplayer infrastructure systems including a lobby system, authentication system, and in-game chat.

Built the main menu and UI flow for accessing multiplayer features and starting matches.

Base building system allowing players to construct structures such as factories and generators.

Direct unit control and targeting, enabling players to command units and choose specific enemy targets.

Map control mechanics centered around capturing and maintaining power sources.

1v1 domination-style multiplayer matches focused on strategic expansion and base destruction.

Fully networked multiplayer gameplay using Mirror Networking.

Integrated multiplayer lobby system for creating and joining matches.

Online in-game chat system for player communication during matches.

Developed a Souls-like character controller, including dodge rolling, light and heavy attacks, jumping, and combat movement.

Implemented enemy AI systems to drive combat encounters and gameplay challenges.

Created the game menu and UI systems for navigation and game flow.

Built a save and progression system to persist player progress.

Implemented additional gameplay systems supporting exploration, combat, and player progression.

Modeled and textured the majority of the game’s 3D assets and environment props, excluding the character model, trees, and bushes.

Developed a full first-person character controller handling movement, camera control, and player input.

Implemented a world interaction system allowing players to interact with environmental objects.

Created Half-Life–style physics object manipulation, enabling players to pick up, carry, and move physics-based objects.

Designed and implemented the weapon system, supporting shooting mechanics and combat interactions.

Modeled most of the game's 3D assets and environment props, contributing to the visual identity of the project.

Integrated externally sourced assets including the Thompson weapon model and enemy character models.

Developed core VR gameplay systems, including player interaction and weapon handling.

Implemented a modular weapon system supporting different firearms and combat mechanics.

Created a weapon attachment system allowing upgrades and customization during gameplay.

Built a wall-buy system inspired by classic wave shooters, enabling players to purchase weapons during rounds.

Implemented enemy AI and spawning systems to support escalating wave-based combat.

Developed a sanity system that gradually affects the player while trapped in the elevator, increasing tension and psychological pressure.

Created a dynamic in-game events system to trigger supernatural occurrences and environmental changes during gameplay.

Implemented a first-person character controller for player movement and interaction within the confined elevator environment.

Managed the project and coordinated the team, helping organize tasks and guide development progress.

Created 3D models and visual assets used within the game environment.

Implemented car physics and a custom vehicle controller using Unity’s physics system for acceleration, steering, and handling.

Developed a lap timing and lap counting system to track player progress and race completion.

Created a main menu UI system for starting races and navigating the game.

Designed a simple arcade-style racing experience focused on responsive driving and quick gameplay.

Created the game flow and user interface layout to keep the experience intuitive and accessible.

Designed and implemented a modular C++ OpenGL rendering framework built with CMake for cross-platform builds.

Developed a lightweight Entity System to manage scene objects.

Implemented a custom shader pipeline supporting user-defined GLSL vertex and fragment shaders.

Built a model loading pipeline using TinyOBJLoader for importing .obj meshes.

Created a texture and image loading system to support material and asset management.

Implemented hierarchical transformation systems for scene graph style parent–child object relationships.

Developed a lighting system supporting directional lights, spotlights, and specular shading.

Integrated cubemap skybox rendering for environment backgrounds and scene immersion.

Implemented windowing and input systems using GLFW.

Built editor/debug tooling using Dear ImGui for runtime inspection and engine controls.

Created demo scenes showcasing lighting, skyboxes, and model rendering.

Developed visual debugging tools via ImGui to make rendering systems easier to test and iterate on.

Designed and implemented a lightweight Entity–Component System (ECS) architecture for flexible game object composition.

Built a scene management system for loading, switching, and organizing game scenes.

Implemented a serialization-based save/load system using Cereal.

Developed the rendering system using SFML for drawing sprites, UI, and other game objects.

Created a sound system for playing and managing in-game audio.

Implemented an asset manager to handle loading and caching of textures, audio, and other resources.

Built core ECS components, including Entity, Transform, Physics Actor, and Script components.

Developed an advanced camera system featuring position smoothing, zoom smoothing, rotation smoothing, and camera shake, alongside a raw camera component for lower-level control.

Implemented sprite rendering with animation support.

Created basic UI systems, including UIButton, UILabel, and serializable text data components.

Built a demo platformer game called SpriteBound to showcase the framework and demonstrate how to build games using SpriteBox.

Implemented face culling to avoid rendering hidden voxel faces and reduce mesh complexity.

Built a level-of-detail (LOD) system to efficiently render distant terrain at lower resolutions.

Implemented vertex packing, compressing voxel vertex data into 4 bytes per vertex (position, normal, UV, and atlas index) to significantly reduce memory usage and improve performance.

Created a custom shader capable of decoding and rendering the packed voxel vertex format.

Implemented multithreaded world generation and meshing using the Unity Job System and Burst Compiler to improve performance.

Developed noise-based procedural terrain generation for creating dynamic voxel landscapes.

Designed and implemented a custom client–server networking architecture using Java and LibGDX.

Built a custom packet system for handling gameplay messages and state synchronization.

Implemented TCP and UDP communication, using reliable messaging for critical events and low-latency updates for gameplay data.

Developed multiplayer player synchronization systems for movement, actions, and combat interactions.

Created a server management console with terminal commands (e.g., list_players) to monitor connections and active players.

Implemented player connection and session handling, allowing multiple clients to join matches hosted on a dedicated server.

Built core gameplay systems, including player combat and elimination mechanics.

Implemented the 2D game systems and logic using LibGDX.