Cript rider – Unreal Engine

A first-person puzzle project built in Unreal Engine with Blueprints and C++, featuring custom GameMode logic, Enhanced Input, and Actor-based gameplay systems. Includes collision-driven interactions, vector-based movement calculations, and data management through TArray, all demonstrated across a test scene and a fully playable puzzle level.

Haruyoshie Ecima, Solo Developer – Unreal Engine (C++)

2/10/20262 min read

Technical 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

The process to the level desing

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.