Guide

Game slope, friction and ice surface movement systems explained

Harbor Peaks’ glacier descent was a 12-room gauntlet of steep ramps and frictionless ice. Playtesters died 38% of the time on the third slide — not because the jumps were hard, but because the controller treated ice as “normal ground with lower max speed.” Players could not brake, could not read where they would stop, and blamed the game when they slid into spike pits. Rebuilding the room around separate friction, slope acceleration, and momentum carry — with visible slide-stop markers and a short counter-brake window — lifted glacier completion from 29% to 73% while keeping the intended speed fantasy intact.

Slope and friction systems govern how grounded characters accelerate, decelerate, and slide on hills, ice, mud, oil, and factory floors. They sit between raw jump and gravity physics and level verbs like conveyor belts and wind zones. This guide covers friction coefficients, gravity projection on slopes, ice slide momentum, input scaling on slippery surfaces, slope entry and exit coupling, level authoring, the Harbor Peaks glacier refactor, a technique decision table, common pitfalls, and a production checklist.

What slope and friction systems are

Every grounded movement tick resolves three forces: player input acceleration, surface friction (deceleration), and slope gravity (acceleration along the ground plane). On flat normal ground, friction dominates and the player stops quickly when input releases. On ice, friction is near zero so velocity persists. On downhill slopes, gravity adds a downhill component even with no input.

Production platformers rarely simulate full rigid-body friction. Instead they expose tunable parameters per surface tag:

mu_ground — kinetic friction scale (0 = frictionless, 1 = default tile)
slope_accel — gravity projected onto the walk tangent, usually g * sin(theta)
max_slide_speed — cap on passive downhill slide (prevents runaway on long ramps)
brake_strength — how fast counter-input bleeds velocity on slippery surfaces
input_scale — scales horizontal control while on low-friction ground

Treating ice as “walk speed *= 0.5” breaks stop distance prediction. Players need consistent physics: velocity integrates each frame, friction and slope terms add or subtract, and release-of-input does not instantly zero speed.

Friction models that feel fair

Exponential decay (arcade default)

Each grounded frame: v = v * (1 - mu * dt) + input_accel * dt. Low mu on ice means velocity decays slowly — slides feel long but predictable. Pair with a minimum velocity threshold below which you snap to zero to avoid infinite micro-slides.

Directional friction

Apply stronger friction against motion than along it. Mud might resist direction changes (high lateral friction) while preserving forward slide momentum. Ice uses near-uniform low friction in all horizontal axes. Directional friction makes carving turns on slopes readable without killing speed fantasy.

Static vs kinetic transition

When input magnitude drops below a dead zone and speed is low, switch to “static hold” with higher friction so players can stand still on gentle ice patches. Without a static band, characters slowly drift on any non-zero slope — fine for puzzle ice, frustrating for checkpoint rooms.

Surface blending at tile edges

Lerp mu over 1–2 pixels when transitioning ice to stone. Hard edges cause one-frame velocity spikes when raycasts flicker between tags. Harbor Peaks added a 40 ms blend zone and cut “random slide” bug reports by 47%.

Slope acceleration and gravity projection

On a ramp with angle theta from horizontal, gravity pulls the player downhill with a_slope = g * sin(theta) along the surface tangent. Uphill input must overcome both friction and a_slope; downhill passive slides add a_slope even when the player releases the stick.

Walkable angle limits

Most platformers cap walkable slope at 45–55 degrees. Beyond that, switch to slide-only state: player cannot walk uphill, only jump or use anchors. Document max angle in your level style guide so artists do not author unrunnable geometry.

Slope entry and exit velocity

When a player runs from flat ground onto a downhill ramp, preserve horizontal speed and add slope acceleration — do not project velocity instantly to the ramp tangent (that feels like a magnet yank). Over 80–120 ms, blend velocity direction toward the ramp tangent while magnitude follows friction rules. On uphill exits, merge remaining slide speed into walk speed or apply a soft clamp so players do not launch off the lip.

Jumping on slopes

Jump takeoff should use velocity at the moment of leave-ground, including slope slide speed. Forgetting downhill momentum produces short jumps that fail gap puzzles. Vertical jump impulse still applies along world up; horizontal carry follows platformer convention for the genre (some games zero horizontal on jump, most preserve it).

Ice slides, mud and specialty surfaces

Ice rooms

Design ice sections around stop distance, not walk speed. Place obstacles, gaps, and collectibles where a full-speed slide from the previous commit point lands with 0.3–0.5 s reaction margin. Use floor decals or particle trails to show last-frame velocity direction in debug builds.

Counter-brake and pivot windows

Give players a short tap opposite to motion that applies brake_strength > mu for 150–250 ms. Fighting games call this a brake cancel; platformers use it so ice stays skillful without full precision platforming on every tile. Telegraph brake availability with a subtle skid SFX on direction reversal.

Mud, oil and status effects

Temporary friction debuffs (oil splash, slow spell) should stack multiplicatively on mu with a floor (never true zero unless designed). Show visual state on the character — players forgive slippery feet when the avatar looks coated.

Ice plus conveyors and wind

When ice overlaps conveyor surface velocity, add belt vector and slope acceleration before friction integration. Wind zones that apply force while grounded should use the same velocity accumulator as slope terms to avoid order-dependent bugs.

Level design and readability

Commit points — safe ledges before each slide chain where players can stop and plan
Stop markers — wall pads, snow banks, or soft collision that bleed speed without damage
Speed gates — narrow passages that only fit a capped slide speed; teaches max velocity
Optional skill routes — faster ice lines with tighter margins; reward mastery without blocking main path
Camera lookahead — offset camera downhill during slides so players see pits early

Pair difficult ice with generous coyote time on ramp lips — players often jump late when speed is high. Telemetry: track death cause tags (missed jump vs slide into hazard vs uphill stall) separately; they imply different fixes.

Harbor Peaks glacier refactor (case study)

Before: Ice used walk_speed * 0.45; slopes reused flat-ground friction; no slide cap; spike pits at arbitrary distances. Completion 29%; 61% of glacier deaths on slide into hazards.

Changes:

Replaced speed multiplier with mu_ice = 0.06 and exponential decay integration.
Added a_slope = g * sin(theta) per ramp collider normal.
max_slide_speed = 14 m/s on longest ramp; brake window on opposite input.
Snow bank stop volumes at each commit point (bleed 80% speed in 200 ms).
Repositioned spikes using simulated slide distance from prior commit.
40 ms friction blend at ice-to-rock transitions.
Camera lookahead +0.8 tiles downhill when slide speed > 8 m/s.

After: 73% completion, slide deaths down 58%, “ice is unfair” survey score improved 34 points. Geometry moved 11 hazards; physics refactor accounted for ~52 points of the gain.

Technique decision table

Design goal	Best approach	Weak when
Fast downhill thrill	Low `mu` + `a_slope` + slide speed cap	Level has no commit points or stop markers
Puzzle ice (stop on exact tile)	Higher `mu`, static hold band, short slides only	You want Sonic-style speed fantasy
Uphill struggle fantasy	High `a_slope` uphill, normal friction, stamina optional	Backtracking is frequent — players hate slow uphill
Factory floor lubricant	Temporary `mu` debuff + visual coat	Debuff stacks to true zero everywhere
External forced motion	Conveyor surface velocity	You only need passive downhill — slopes are simpler
Vertical lift without walking	Wind updraft or moving platform	Player should feel weight and slide
Fix ice by lowering walk speed	Never as sole lever	Always — stop distance and slope accel drive feel

Common pitfalls

Speed multiplier instead of friction — stop distance does not match player intuition; slides feel random.
Ignoring slope acceleration — ice on flat floor plays differently than ice on 30-degree ramp; reuse parameters per surface tag pair.
Instant velocity zero on surface change — snagging at ice-to-rock edges; use blend zones.
No slide speed cap — long ramps exceed jump and reaction budgets; players cannot recover.
Jump takeoff strips downhill speed — gap puzzles fail despite “correct” timing.
Frictionless without brake option — pure ice mazes read as luck unless stop markers are generous.
Netcode integrates friction on clients only — desync on slope exit; authoritative grounded velocity on server or rollback state.

Production checklist

Define mu_ground, slope_accel, and max_slide_speed per surface tag in data.
Integrate velocity each tick: input + slope + friction decay; never only scale walk speed.
Blend friction parameters at tile boundaries over 1–2 pixels or 40 ms.
Cap passive downhill slide speed on long ramps.
Implement counter-brake or static hold band for stand-still on gentle ice.
Preserve horizontal velocity on jump takeoff from slopes.
Simulate slide distance from commit points when placing hazards.
Add snow banks or soft stops before mandatory direction changes.
Offset camera downhill during high-speed slides.
Tag deaths: slide hazard vs jump fail vs uphill stall.
Test conveyor + ice + slope triple overlaps in one test room.
Validate rollback determinism on friction state transitions.

Key takeaways

Friction controls stop distance; slope acceleration controls passive speed gain — they are separate knobs.
Ice implemented as walk-speed multiplier breaks predictability; use velocity integration with low mu.
Harbor Peaks glacier completion rose from 29% to 73% after physics refactor and hazard repositioning from simulated slides.
Commit points, stop markers, and brake windows make ice skillful instead of punitive.
Blend surface parameters at edges and preserve momentum on jump takeoff from ramps.