Crypt Rider

01Technical progression and contributions

• Designed and configured custom GameMode logic to control game rules and player flow.
• Implemented the Enhanced Input system, transitioning from basic input handling to modular, scalable input actions.
• Developed gameplay logic using Actors, focusing on lifecycle management and clear ownership via GetOwner().
• Applied pointer usage and safe references to manage interactions between gameplay objects.
• Implemented vector math for movement, orientation, and gameplay calculations.
• Used logical operators and conditional flows to manage gameplay states and interactions.
• Built and tested collision systems, including overlap and hit events, to drive gameplay responses.
• Managed gameplay data using TArray, reinforcing understanding of Unreal's container types and memory behavior.

02The process to the level design

For this project, I built out a set of gameplay mechanics in Unreal Engine, mixing Blueprints and C++ depending on what made sense for each piece. The video shows the whole process — I start off testing everything in a simple sandbox scene, just making sure each mechanic works on its own, and then jump into a real level where those mechanics come together to power a puzzle-solving experience.

One of the first things I set up was a custom GameMode, so I could actually control how the game runs and how the player moves through it. I also switched over to the Enhanced Input system instead of sticking with basic input — it made everything way more flexible and easier to expand as I kept adding new mechanics.

Most of the actual gameplay logic lives inside custom Actors, so I spent a good chunk of time thinking about how objects are created, owned, and cleaned up, using GetOwner() to keep track of who's responsible for what. I also had to get comfortable working with pointers and safe references, especially when different objects needed to talk to each other without things breaking or crashing randomly.

There's a lot of vector math going on under the hood too — movement, orientation, all that — plus logical conditions to handle different game states depending on what the player was doing. On top of that, I built and tested collision systems using overlap and hit events, which basically became the backbone for how the puzzles actually respond to the player.

And finally, I used TArray to handle gameplay data throughout the project, which honestly taught me a lot about how Unreal handles memory and containers behind the scenes.

03Gallery