Building a first game in Unreal Engine 5: character movement tuning, platform mechanics, level design, and post-process environment design in a first-person platformer.
This project is a first-person platformer built entirely in Blueprints with Unreal Engine 5, developed following this Udemy beginner course — the starting point of this entire series of Unreal projects. The game loop is simple: navigate each level avoiding spike hazards, collect all gems, and reach the exit to advance. Its value isn’t in system complexity but in what it teaches about building a complete game from scratch in Unreal: how the engine’s default template is extended, how levels are designed and iterated, and how a game loop with a clear win condition is assembled from basic building blocks.
You can watch the prototype in action here: YouTube
Starting from the First Person Template
Unreal’s First Person template provides a starting point: a character with a capsule collider, a camera attached at head height, basic WASD movement, and a jump. For a first-person shooter this is a reasonable baseline; for a platformer it needs adjustment. The default jump height, air control, and gravity scale are tuned for a shooter context where jumping is a utility rather than a primary mechanic.
Platformer character movement requires deliberate tuning of several UCharacterMovementComponent parameters:
Jump Z velocity controls how high the character jumps. Too low and platforms feel unreachable; too high and the game loses tension. Air control determines how much the player can steer while airborne — zero air control makes jumps fully committed (once you jump, you go where you were pointed); full air control makes the character feel floaty and imprecise. A value around 0.3–0.5 gives responsive but not-too-forgiving aerial steering. Gravity scale affects how fast the character falls — higher gravity produces snappier, more satisfying jumps that arc up quickly and come down decisively, which is typically preferred in platformers over a slow, floaty arc.
Getting these three parameters balanced is the core feel work of a platformer. The same level can feel fair or impossible depending entirely on these values.
Platform Mechanics
The level introduces three interactive platform types beyond static geometry:
Moving platforms translate between two points on a looping timeline — a simple lerp between a start and end position driven by a Timeline node in Blueprint. The key design consideration is whether the platform’s movement is predictable (constant speed, visible path) or requires the player to time their approach. For a beginner-friendly platformer, predictable movement with a clearly readable path is the right choice. The platform carries the player with it when they stand on it, which requires the player character to inherit the platform’s velocity — handled automatically by Unreal’s CharacterMovementComponent when the character is standing on a moving actor.
Pressure plates activate when the player steps on them and deactivate when the player leaves. They trigger connected actors — typically opening a door or activating a platform — while the player remains on them. The connection between plate and triggered actor uses Blueprint’s Interface or direct actor reference pattern. For a beginner project, a direct reference (the plate holds a reference to the door it controls) is the pragmatic choice; the interface approach scales better as the number of interactive objects grows.
Spike hazards kill the player on contact, respawning them at the last checkpoint. Spikes use an overlap volume that triggers on player contact and calls a damage or respawn function on the player character. The design challenge is placement — spikes should feel threatening and teach the player to read the space carefully, but shouldn’t feel arbitrary or unfair.
Gem Collection and Win Condition
Gems are collectible actors placed throughout each level. Each gem has an overlap sphere that detects player contact, increments a gem counter on the player character or game mode, plays a pickup effect, and destroys itself. The level exit is locked until the gem count reaches the level’s required total — forcing the player to explore the full space before advancing.
This gem-gate mechanic does two things simultaneously: it defines the win condition with a clear metric (collect all gems), and it ensures the player engages with the level’s full design rather than rushing straight to the exit. The HUD displays the current gem count and total, giving the player constant visibility into their progress.
The level progression — advancing to the next level when the exit is reached — uses UGameplayStatics::OpenLevel to load the next level by name. A simple level sequence (Level 1 → Level 2 → Level 3) hard-coded in the game mode is sufficient for a beginner project; a more scalable approach would use a level data table or a progression manager.
Level Design with Template Levels
The levels are built using Unreal’s modular geometry — BSP brushes or static mesh blocks assembled in the editor. The design process follows a gray-box approach: rough geometry first to establish the layout and test the feel, visual dressing second once the layout proves fun to navigate.
A first-person platformer level has a specific design constraint that differs from third-person: the player has no spatial awareness of their own character’s body. They can’t see their feet, which makes judging the edge of platforms more difficult. This requires level geometry to be slightly more generous than a third-person platformer of equivalent difficulty — platforms need to be wide enough that the player can confidently identify their position on them from a first-person view.
The post-process volume contributes to the level’s readability by controlling ambient occlusion, color grading, and bloom — making the environment feel cohesive rather than a collection of grey boxes. A warm color grade for the early levels, a cooler tone for later ones, creates a sense of progression through the environment even when the geometry style is consistent.
Post-Process Volume and Environment Design
The Post-Process Volume is one of Unreal’s most accessible tools for establishing visual mood without custom shaders. In this project it controls:
Ambient occlusion — darkening crevices and corners to emphasize depth and make geometry more readable. In a first-person platformer where reading platform edges is critical, well-tuned AO improves gameplay legibility directly.
Bloom — the glow around bright light sources that makes emissive materials and lights feel physically present. Modest bloom adds atmosphere without looking unrealistic.
Color grading — shifting the overall color balance of the scene via a LUT (Look-Up Table) or direct color controls. A subtle grade unifies the lighting across the level and establishes a consistent visual identity.
These post-process effects are non-destructive and easily reversible, making them the right tool for a first project where the art direction is still being discovered through iteration.
Reflection
The first-person platformer is deliberately simple — that’s appropriate for where it sits in the learning sequence. Its value is in building the complete mental model of an Unreal game project: how the engine template is extended, how a level is built and tested, how gameplay systems (collection, hazards, progression) are wired together from basic Blueprint nodes, and how a game loop with a start, middle, and end is assembled.
Every more complex project in this series builds on foundations established here. The pressure plate pattern appears in the door systems project. The gem counter pattern appears in every collection mechanic across the series. The character movement tuning that makes the platformer feel right is the same process applied to every character in every subsequent project — just with more parameters and more nuance. Starting here, with a project simple enough to hold entirely in your head, is the right way to build toward the complexity that follows.
Nicolás Bertoa 
Leave a comment