Designing a Wallrun That Survives Real Geometry

The arc was the point

I first built the mechanic in Unreal, then rebuilt and expanded it in Godot for Zero Protocol. I was chasing the wallrun from Prince of Persia: The Sands of Time. What made it memorable wasn't just moving sideways along a wall. The character rose and fell through a clear arc, turning the wall into a short extension of the jump.

A flat wallrun worked, but it looked like sliding. The arc made it feel like momentum. The player catches the wall in mid-air, rises, crests and drops into the exit. There's no separate wallrun button or special mode: jump toward a valid wall while moving along it and the system picks it up.

The first success created the real problem

Once the arc felt right, it started breaking against real levels. Under a roof, the curve drove the player into the ceiling. Near the top of a wall, the upper-body samples lost the surface and ended the run at exactly the moment the player expected to flow onto the ledge. Segmented walls produced false detachments, while corners and curved surfaces could redirect or strand the player.

I didn't want to throw the arc away, because that was the whole feel. Instead, I kept the curve as the ideal path and checked the real wall around it every frame.

Reliable on awkward walls

The component can run only on tagged walls or on any wall that passes the checks. Zero Protocol uses tagged walls so the level designer decides where wallrunning is allowed. Switching between the two is one Inspector option, not a different script.

Curved-wall support can also be switched on or off. With it on, the system checks the wall direction fifteen times per second and follows the changing surface. Convex tanks, concave barriers and round industrial structures all become usable. The system also gently closes the gap to the wall, holding the player to the surface without a sudden yank on the first frame.

One component does the hard work

In Godot, one WallRunComponent handles detection, the arc, surface safety, wall-jump maths and the reason each run ends. Small state-machine states handle animation and the move into and out of wallrun for both unarmed and melee stances. Every airborne state quietly checks for a runnable wall, so the player can catch one naturally without pressing a special button.

The component sends start, end and wall-jump signals to audio, VFX, camera, scoring and progression. Those systems can react without being built into the movement code.

A designer tool, not a hard-coded move

The system started as one very specific wallrun and grew into something designers can reshape. They can make a short, flat combat run, a long rising set piece, a sprint-gated skill check or a route that chains forever without touching the script.

Every exit has its own answer

The component doesn't have one generic way to let go. A wall jump keeps full control and can catch the next wall. Reaching the end kicks the player up and away. Reaching the top pushes onto the surface and hands over to the mantle system. A blocker ahead causes a clear rebound, a ceiling clamps the rise, and touching the floor moves straight back into grounded movement.

Because each ending has its own result, animation, sound and the next state always know what happened. More importantly, the player keeps their momentum even when the level changes the ideal path.

What I can build with it

The wallrun now sits alongside dash and mantle as one of Zero Protocol's three main movement tools. The M1S1 critical path uses it when the player jumps from a vehicle roof, runs across a billboard and lands beyond a blockade. It also supports alternate routes, climbs, curved industrial set pieces, combat flanks and arenas where the floor becomes dangerous.

The important thing is that it works reliably. The move started as an attempt to recreate one specific arc. It became a flexible component that keeps that feel across real level geometry and lets designers decide where wallrunning works and what each run asks of the player.