Why Single-Shot LLM Games Tunnel Through Walls: Swept-AABB, Coyote Time, and Spatial Hashing

Ask any frontier language model to generate a playable 3D action game, platformer, or racing simulation in a single prompt, and the resulting code almost always fails in the first ten seconds of gameplay. The character falls through the floor when walking up a hill, tunnels straight through thin walls during a frame-rate dip, or feels unresponsive when jumping off a ledge. In our side-by-side comparison studio (compare.baltor.ai/games) and standalone 3D worlds (demos.baltor.ai/foxglade), we tested raw single-shot LLM game outputs against games assembled from verified open-source physics and controller components harvested from Godot, Bevy, and Three.js repositories.

The failure of single-shot LLM games is not an aesthetic problem. It is a mathematical failure caused by three shortcuts that appear in nearly every tutorial snippet in a language model's pretraining corpus: unclamped discrete Euler integration, missing swept Time-of-Impact (TOI) collision resolution, and frame-dependent jump state machines without coyote time or input buffering.

Shortcut 1: Unclamped Discrete Euler Step and Wall Tunneling

When a language model writes a requestAnimationFrame loop from scratch, it almost universally writes discrete position integration coupled with a post-step overlap check:

// Typical raw LLM movement loop (BROKEN on frame spikes or fast projectiles)
player.position.x += player.velocity.x * deltaTime;
player.position.z += player.velocity.z * deltaTime;
if (boxIntersectsWall(player.box, wall.box)) {
    player.position.x -= player.velocity.x * deltaTime;
}

Why does this break immediately in a real browser? Suppose your character or projectile moves at 18.0 units/s toward a wall or fence that is 0.25 units thick. At a smooth 60 FPS (deltaTime = 0.0166s), the displacement per frame is 0.30 units. If a garbage-collection pause or shader compilation causes a single frame to take 0.045s, the displacement jumps to 0.81 units. On frame t_0, the player's bounding box is completely in front of the wall; on frame t_1, it is completely behind the wall. The discrete post-step check boxIntersectsWall evaluates to false on both frames, and the player tunnels out of the arena.

Even when the discrete check catches an overlap, reversing the full displacement (position -= velocity * dt) leaves a visible gap in front of the wall and prevents the player from sliding smoothly along diagonal obstacles. If the player presses W+D into a 45-degree canyon wall, raw LLM physics glues the player in place.

Shortcut 2: Flat Y=0 Ground Clamping Instead of Barycentric Heightfields

In 3D outdoor environments like our woodland survival benchmark (demos.baltor.ai/foxglade), unassisted models generate visual hills by displacing vertex heights in a plane mesh, but then write character grounding as if (fox.position.y < 0) fox.position.y = 0;. As a result, the character walks horizontally through the middle of every hill and floats above every valley. Furthermore, the character mesh stays rigidly horizontal (rotation.x = 0) on 30-degree slopes instead of pitching to match the surface normal.

Shortcut 3: Exact-Frame Ground Booleans vs. Coyote Time & Jump Buffering

In human-playable platformers and parkour games, players press the jump key slightly before touching the ground (within 80–120 ms of landing) or slightly after running off a ledge (within 80–110 ms of leaving the platform). Raw LLM games gate jumping on a brittle instantaneous boolean: if (keys.Space && isGrounded) velocity.y = JUMP_IMPULSE;. Because isGrounded flips to false on the exact millisecond the player's center crosses the ledge edge, 35% to 50% of human jump inputs are silently dropped, making the game feel broken.

How the Baltor Physics Slot Solves All Three Problems

Instead of letting the LLM improvise collision math inline, our physics_controller_3d engine slot injects a verified 4-stage kinematic solver adapted from production Godot CharacterBody3D.move_and_slide() and Bevy spatial-hash patterns:

1. Fixed Sub-Stepping with Delta Clamping: Frame deltas are clamped to max_dt = 0.05s and subdivided into fixed 1 / 120s physics sub-steps so high-velocity motion never skips thin colliders.
2. Swept-AABB Continuous Collision Detection (Minkowski Sum Raycast): For each sub-step, we expand static obstacle AABBs by the moving character's half-extents and intersect the movement ray against the expanded box to compute exact entry time t_entry in [0, 1] and contact normal n.
3. Tangent-Plane Velocity Projection (Slide Response): When a collision occurs at t_entry, the character advances to t_entry - epsilon, and the remaining velocity vector is projected onto the contact tangent plane (v_slide = v - dot(v, n) * n) for up to 3 slide iterations.
4. Barycentric Terrain Normal Alignment + 110ms Coyote / Buffer Timers: Terrain height and surface normals are sampled analytically across triangle barycentrics, while a 0.11s coyote timer and 0.11s jump-input buffer guarantee crisp responsiveness.

Empirical Comparison Across Six Playable 3D Game Worlds

We ran automated 600-frame adversarial stress tests (including simulated 25 FPS frame spikes, diagonal wall-sliding, and ledge-edge jump inputs) across all six game worlds in compare.baltor.ai/games, holding the model fixed at qwen3-coder:30b / gemma4:31b:

Concrete Implementation: Swept-AABB Time-of-Impact & Tangent Slide

Below is the core continuous collision and slide resolver from our verified physics_controller_3d component slot that powers our browser worlds:

export function sweptAABBTimeOfImpact(movingBox, vel, staticBox) {
  // Minkowski sum: expand staticBox by movingBox half-extents
  const hx = (movingBox.maxX - movingBox.minX) * 0.5;
  const hz = (movingBox.maxZ - movingBox.minZ) * 0.5;
  const cx = (movingBox.minX + movingBox.maxX) * 0.5;
  const cz = (movingBox.minZ + movingBox.maxZ) * 0.5;

  const minX = staticBox.minX - hx, maxX = staticBox.maxX + hx;
  const minZ = staticBox.minZ - hz, maxZ = staticBox.maxZ + hz;

  const invVx = Math.abs(vel.x) > 1e-6 ? 1.0 / vel.x : Infinity;
  const invVz = Math.abs(vel.z) > 1e-6 ? 1.0 / vel.z : Infinity;

  const tx1 = (minX - cx) * invVx, tx2 = (maxX - cx) * invVx;
  const tz1 = (minZ - cz) * invVz, tz2 = (maxZ - cz) * invVz;

  const tEntryX = Math.min(tx1, tx2), tExitX = Math.max(tx1, tx2);
  const tEntryZ = Math.min(tz1, tz2), tExitZ = Math.max(tz1, tz2);

  const tEntry = Math.max(tEntryX, tEntryZ);
  const tExit = Math.min(tExitX, tExitZ);

  if (tEntry > tExit || tEntry < 0.0 || tEntry > 1.0) {
    return { hit: false, toi: 1.0, nx: 0, nz: 0 };
  }
  const nx = tEntryX > tEntryZ ? (vel.x > 0 ? -1 : 1) : 0;
  const nz = tEntryZ >= tEntryX ? (vel.z > 0 ? -1 : 1) : 0;
  return { hit: true, toi: Math.max(0.0, tEntry - 1e-3), nx, nz };
}

Try the Side-by-Side Physics Comparison Live

You can toggle between the raw single-shot LLM builds and the Baltor-harnessed builds across all six playable 3D worlds at compare.baltor.ai/games, or launch the full-bleed woodland world directly at demos.baltor.ai/foxglade.