Unity Parkour & Climbing System

Build a basic third-person controller from scratch to understand its mechanics and customize it for your own Unity parkour and climbing projects.

Create a new Unity project in Unity Hub with the universal render pipeline, then set up a scene with a scaled plane and checker material. Begin building the character controller.

Develop a third-person camera controller in Unity that follows the player at a configurable distance, rotates around the target with mouse input, and clamps vertical angle.

Implement third-person character movement in Unity by mapping player input to the camera's direction on the horizontal plane. Use LookRotation and RotateTowards for smooth, camera-relative rotation.

Set up and retarget animations in Unity using humanoid avatars; map bones for cross-model compatibility with Mixamo animations, and enforce in-place motion by adjusting root motion and transforms.

Create and assign an animator controller, blend idle, walk, and run animations based on a speed parameter, and apply damping and clamping for smooth transitions in a third-person parkour setup.

Add a character controller to handle collisions and gravity in unity, perform manual ground checks with physics overlap sphere, and fine-tune collider properties and gravity for stable player movement.

Configure joystick input to move the player with the left stick and rotate the camera with the right stick by adding camera x and camera y axes in input manager.

Implement an environment scanner to detect obstacles ahead and trigger height-based actions like step up, jump up, and climate action, using target matching to reuse animations across heights.

Architect a Unity parkour and climbing system by building an environment scanner and park controller that detect obstacles in front of the player using the recast function.

Explore obstacle height detection in a Unity parkour system by casting a height recast from five meters above the forward hit point, downward to measure obstacle height and guide actions.

Trigger a step up parkour action in Unity when an obstacle is in front and the jump button is pressed, using animator crossfade and temporary player control.

The buckle controller selects parkour actions by obstacle height using mean height and max height thresholds, enabling step up or jump up actions, with scriptable actions and an asset menu.

Learn to rotate the player toward the obstacle during jump up action, computing a target rotation from obstacle normal and smoothing with quaternions and rotate towards using delta time.

Use target matching to align parkour animations with obstacle height, adjusting the right foot during step up and jump up actions via normalized start and target times.

Learn to implement a climb up action for large obstacles by combining crouch to stand and climb up animations, configuring target matching, and tightening transitions to avoid sliding.

Implement the vault action by tagging obstacles to select the correct action, import the vault fence animation, and configure target matching and transitions for smooth gravity-driven landings.

Learn to implement custom parkour actions by inheriting from the base action, overriding checks, and mirroring vault animations based on whether you approach from the left or right side.

The section demonstrates an extensible parkour action system in Unity, letting you add actions from a menu, enter details, and assign animations, with a challenge to add more from maximal.

Implement ledge movement in Unity parkour, stopping forward motion at a ledge while allowing side and backward movement, and enable jumping from the ledge with the jump input.

Detect ledges during movement with a downward recast from a higher origin, use a ledge height threshold to decide when to jump off obstacles, and test via visualization.

Learn how to implement jumping from ledges in Unity using three animations—jump down, looping in air, and landing—and coordinate them with animator transitions and grounded checks.

This lecture improves ledge jumping in parkour by cutting jumps at high angles using the angle between the player's forward vector and ledge normal, and adds obstacle checks.

Implement ledge movement by limiting forward input using the angle between the ledge normal and move direction, and allow side and back movement while enabling jumps only when pressed.

Enhance ledge movement by allowing horizontal sliding between 60 and 90 degrees using ledge normal and cross product to determine direction, and rotate toward input when the angle is high.

Improve ledge movement by using three recasts to check the ledge width, preventing feet from leaving the ledge, and introducing a reusable three-recast physics utility with origin and visualization.

Learn how to stop player input during the landing animation using a state machine behavior to toggle has control, and adjust jump down timing to prevent double jumps off ledges.

Enable auto jumps in a Unity parkour system by using a ledge height threshold and a drop height limit to auto jump low ledges; high ledges still require jump input.

Complete the village movement and ledge jumping implementation, with the player automatically stopping near ledges and jumping onto them when the jump button is pressed.

Design a simplified climbing system with a network of ledges, enabling jumps between ledges and shimmying on longer ledges. Learn how to implement this Assassin's Creed–style mechanic.

Refactor the action logic into a single generic function in the player controller to reuse taco and climbing actions, parameterizing animation, rotation, target matching, and post-action delay.

Create climbing ledges and detect them with a multi-raycast system, using a client controller and environment scanner to enable climbing when in front of the player.

Learn to implement jump to ledge by importing humanoid climbing animations, setting up a sub-state machine, and using target matching to anchor the hands on the ledge.

Build and visualize the climbing network by implementing a client point system with neighbor connections, two-way and one-way types, auto back-connection creation, and forward-vector visualization for outward ledges.

Implement ledge-to-ledge jumps in a Unity parkour system by importing hop animations (up, down, left, right) and configuring offsets. Map input directions to neighboring ledges for seamless transitions.

Implement the shimmy action by setting up long ledges with multiple climb points, adding client points, and integrating left and right shimmy animations and precise hand offsets.

Implement jump back from hanging and mount to obstacles in Unity using animations, animator transitions, and input actions for drop and up.

Implement a drop to hang mechanic by importing and refining a drop-to-ledge animation, wiring it into the animator, and adding a raycast-based ledge check that finds the nearest climb point.