Guide

Game one-way platform and drop-through systems explained

Harbor Peaks' Act 2 vertical slice looked generous on paper: three stacked routes, collectible caches on mid-tier ledges, and a speedrun skip through the attic. Playtesters never found the skip. Every mid-level floor was a solid tilemap collider — jump up once, and you could not drop back down without a three-screen detour. Completion time on the optional upper path averaged 4:12 versus a 2:40 design target; 68% of players abandoned the route after the first dead-end descent. Level designers widened gaps until the stage felt hollow. The fix was not bigger jumps — it was one-way platforms with reliable drop-through input on 23 interior floors.

After the refactor, optional-path completion rose from 32% to 71% and median vertical traversal time fell 41%. Players described the level as “more open” even though collision geometry changed more than art. One-way platforms are the invisible scaffolding of platformer verticality: they let designers stack routes without trapping players on the wrong floor. This guide explains soft collision rules, drop-through input, layer masks and physics queries, moving-platform edge cases, the Harbor Peaks refactor, a technique decision table, pitfalls, and a production checklist.

What one-way platforms are

A one-way platform (pass-through platform, soft platform) behaves differently depending on approach direction:

From below — the player passes through; no landing collision until feet cross the platform's top surface.
From above — the player lands and stands normally, subject to friction and moving-platform rules.
While standing — optional drop-through input lets the player intentionally fall through to a lower route.

This asymmetry is what enables stacked level geometry in puzzle platformers, metroidvania backtracking, and dense combat arenas without invisible warp tiles. Solid platforms only work when every floor has a designed exit; one-way tiles forgive imprecise routing and reward exploration.

One-way behavior is not the same as coyote time or jump buffering — those are input leniency timers. One-way collision is a physics contract between character capsule and platform collider.

Collision implementation patterns

Engines implement one-way platforms with different primitives, but the logic converges on three checks each physics frame:

Directional collision test

On contact resolution, compare the player's vertical velocity and foot position relative to the platform top:

If velocity.y <= 0 and feet are above the platform top (within a small epsilon), resolve landing.
If velocity.y > 0 (moving upward) or the capsule center is below the top edge, ignore the collision.
If the player is inside the platform volume from the side, push out horizontally — one-way does not mean phasing through walls.

Epsilon matters: 2–4 pixels prevents hover-snag when the player barely clips the underside on a full jump arc. Too large an epsilon and players land early on the underside edge case.

Layer masks and collision matrix

Tag platforms on a dedicated physics layer (e.g. OneWay). The character collides with that layer only when the directional test passes. Alternative: keep one layer but mark colliders with a component flag isOneWay checked in your custom character controller.

Document the matrix for level designers: which layers interact with projectiles, enemies, and drop-through volumes. A common bug is enemies walking on air because their layer ignores one-way tiles entirely.

Drop-through input

Standing drop-through needs an explicit affordance so players do not fall accidentally:

Down + jump — industry default (Celeste, Hollow Knight, many Unity tutorials). Buffer the down press 6–10 frames per input buffering policy.
Hold down + release jump — reduces accidental drops on analog sticks; slightly harder to discover.
Crouch on platform — some retro platformers use down alone after a half-second standstill gate.

On drop-through request, disable collision with the current platform for 150–300 ms or until the player's feet clear the bottom edge. Re-enable when the capsule no longer overlaps the platform AABB. Without a cooldown, the player can snap back onto the same tile mid-fall.

Moving and disappearing platforms

Parent the player to the platform transform while grounded (or accumulate platform velocity each frame). On drop-through, unparent immediately before disabling collision. If the platform moves upward into the player from below, decide policy: lift-through (ignore collision) vs crush (damage). Most platformers lift-through on one-way tiles.

Level design implications

One-way platforms change how you teach vertical space:

Teach drop-through early — first instance should be low stakes: a single collectible below, no hazards, visible landing.
Readable silhouettes — use distinct art (thinner planks, dashed edges, lower opacity) so players predict pass-through behavior.
Route readability — stack routes so upper paths are visible from below; one-way tiles connect loops without mandatory backtracking.
Speedrun and skip tech — expect players to chain double jumps through one-way layers; validate collision cooldown does not enable infinite hover on the underside.

Solid platforms still win for load-bearing setpieces, boss arenas, and floors where drop-through would break puzzle state (pressure plates, escort AI).

Harbor Peaks refactor: 32% to 71% optional-path completion

Act 2 shipped with 41 interior floors as solid tilemap colliders. Problems:

Vertical traps — players who jumped to a collectible could not return without the long outer loop.
Oversized gaps — designers widened holes to 5-tile spans to avoid traps, breaking jump tuning for short-hop characters.
Accidental falls — early playtests on prototype one-way tiles used down-alone drop; 22% of deaths were self-inflicted drops into spike pits.

The refactor:

Converted 23 interior floors to one-way colliders; kept 18 perimeter floors solid for arena boundaries.
Standardized down + jump drop-through with 8-frame down buffer and 200 ms ignore window.
Added 2-pixel landing epsilon and underside raycast to prevent ceiling snag.
First tutorial room: down+jump through a highlighted plank to a coin cache.
Telemetry on drop_through_used and optional_path_completed per session.

Results after two weeks: optional-path completion 32% → 71%; accidental drop deaths 22% → 4%; median Act 2 time 4:12 → 2:47. Level geometry tile count unchanged — only collision flags and one tutorial room.

Technique decision table

Approach	Best when	Risk
Solid platforms only	Linear stages, strict puzzle gates, single-floor arenas	Vertical density requires huge gaps or long detours
One-way platforms (passive)	Stacked routes, exploration loops, optional upper paths	Players may not know they can drop without tutorial
One-way + down+jump drop-through	Metroidvania, dense interior floors, speedrun skips	Input must be taught; buffer tuning required
Timed disappearing platforms	Puzzle timing challenges, rhythm sections	Replaces routing flexibility with execution pressure
Elevator / warp only vertical links	Narrative gating, hub worlds with locked floors	Slower pacing; breaks flow state in action platformers
Semisolid only for player (layer exception)	Enemies should not use player routes	AI pathfinding must respect different collision rules

Common pitfalls

Snagging on the underside — upward jump clips the bottom edge; fix epsilon and upward-ignore rules.
Re-landing mid-drop — ignore window too short; player snaps back to the same platform.
Accidental drop-through — down-alone on analog sticks; require jump confirm or standstill gate.
Moving platform desync — forgetting to unparent on drop causes velocity spikes or invisible tethers.
Network rollback mismatch — one-way state must be deterministic; log platform ignore timers in sync tests.
Projectile collision inconsistency — bullets passing through floors players can stand on reads as broken hit detection.
Invisible one-way tiles — art must telegraph behavior; otherwise deaths feel unfair.
Enemy layer confusion — enemies falling through floors or floating because layer matrix copied from player doc incorrectly.

Production checklist

Define one-way collision test (velocity, foot position, epsilon) in a single module.
Document physics layer matrix for player, enemies, projectiles, and one-way tiles.
Implement drop-through with buffered down+jump and timed ignore window.
Teach drop-through in a safe first room with visible reward below.
Distinct art pass for one-way vs solid platforms.
Test underside jump approach from every approach angle and jump height.
Validate moving-platform parent/unparent on drop and land.
Log drop-through usage and optional-route completion in telemetry.
Run edge cases: damage knockback through platform, spawn inside platform volume.
Regression-test with double-jump and fast-fall if your game supports them.

Key takeaways

One-way platforms let players land from above and pass through from below — they are what make stacked level geometry playable.
Drop-through input (usually down+jump) must be deliberate, buffered, and taught early or players trap themselves on upper routes.
Implementation is a directional collision test plus a short ignore window, not a separate jump type.
Harbor Peaks shows that converting interior floors to one-way collision can nearly double optional-path completion without new art.
Pair one-way tiles with readable silhouettes and solid perimeter boundaries so openness does not read as accidental.