Mobile Game Collision System Development

Mobile Game Collision System Development

You launch a runner on Android, and the character falls through a platform at level 60. FPS drops from 30 to 20 on a Galaxy A10. Tunneling and false positives are symptoms of unoptimized physics. Standard Unity and Godot colliders work on desktop, but on mobile devices with fluctuating FPS and CPU throttling, the collision system fails. Over the years, we have optimized collision detection for various game genres—from runners to platformers. With over 40 projects featuring custom physics, we guarantee quality at every stage. Budget savings on testing and rework can reach 40%. Implementation cost for custom physics is reduced by up to 50%.

Problems with Built-in Colliders on Mobile Devices

Tunneling — a fast-moving object passes through another between two physics steps. CollisionDetectionMode.Continuous in Unity solves this but costs about 2x more CPU than Discrete. On budget Android devices, this is noticeable — we recorded FPS drops of up to 15% when using Continuous extensively.

False positives at seams. PolygonCollider2D with multiple vertices at tile joints often generates phantom collisions — the character stumbles on flat ground. In Unity, this is solved with CompositeCollider2D, which merges neighboring tile colliders into one polygonal shape. In Godot, the equivalent is TileMap with automatic collision shape merging.

Expensive MeshCollider. MeshCollider with Convex = false in Unity does not participate in dynamic-to-dynamic collisions — only static. If arbitrary shapes are needed for dynamic objects, approximate with primitives: several BoxCollider/CapsuleCollider instead of one MeshCollider. This is manual work but reduces broadphase load dramatically.

How to Configure the Layer Collision Matrix for Mobile Games?

The first thing we set up is the Layer Collision Matrix. A typical mistake is leaving all layers interacting. In a game with 5 object types, that's 25 collision pairs instead of 6-8 actually needed. For a mobile project, this directly impacts broadphase. Fewer active pairs mean less work per physics step.

Optimizing the layer matrix yields up to 84% reduction in checks with no accuracy loss. CPU load reduction of up to 84% is a real gain on weak devices.

When to Use Trigger vs Collision?

Collision is a physical contact with impulse; trigger is a logical overlap without physics. A common mistake: using Collision where only Trigger is needed, adding unnecessary Rigidbodies and loading the solver. In Godot 4, the equivalent is Area2D for triggers and CharacterBody2D.move_and_collide() for physical interactions. move_and_slide() automatically slides along slopes — something you'd need to implement manually in Unity via surface normals.

When Engine Physics Is Overkill: Custom Raycast

For some genres, engine physics is overkill. Example: a runner where only collision with ground and obstacles is needed. Instead of Rigidbody + Collider — a raycast-based system:

void CheckGround() { RaycastHit2D hit = Physics2D.Raycast( transform.position, Vector2.down, groundCheckDistance, groundLayer ); isGrounded = hit.collider != null; if (isGrounded) groundNormal = hit.normal; } void CheckObstacles() { RaycastHit2D hit = Physics2D.BoxCast( transform.position, colliderSize, 0f, Vector2.right, obstacleCheckDistance, obstacleLayer ); if (hit.collider != null) OnObstacleHit(hit); } 

This is lighter, fully deterministic, and gives direct control. No random jitter from solver iterations. On weak devices, such a system is 2-3 times faster than standard Rigidbody physics. On a recent runner project, we replaced standard physics with a raycast-based system, reducing CPU usage by 2.5x and eliminating tunneling at high speeds.

How We Optimize Collision Detection: Step-by-Step Plan

1. Profiling on target device. Use Unity Profiler (Deep Profile), focus on Physics.Processing and Physics2D.Processing. Identify bottlenecks: too small Fixed Timestep, interpolate on dozens of objects, dynamic CompositeCollider2D.
2. Configure the layer matrix. Remove unnecessary pairs, define only required interactions. This reduces broadphase load by up to 80%.
3. Select detector type. Enable Continuous for fast objects, keep Discrete for others. If full determinism is needed, implement a raycast-based system.
4. Approximate colliders. Replace MeshCollider with primitive combinations. Optimize PolygonCollider2D via CompositeCollider2D or TileMap.
5. Test on 10+ devices. Check on flagship and budget Android devices. Record FPS and CPU usage.

What's Included in the Work

• Analysis of current physics — profiling on real devices, identifying bottlenecks.
• Collision layer design — matrix configuration, pair optimization.
• Implementation of custom detectors — raycast, sweep, AABB when required.
• Testing — on 10+ device models from flagship to budget.
• Documentation — detailed system description, setup recommendations.
• Team training — walkthrough of component usage.

Timelines: Simple mechanics — from 3 to 5 days; complex (with multi-layer geometry and custom detector) — from 1 to 3 weeks. Cost starts at $1500 for a simple runner system. Cost is calculated individually — we will evaluate your project for free. Contact us for a consultation. Order collision detection optimization — get a free project evaluation.

Our solutions pass App Store Review Guidelines and Google Play Console without issues. 8+ years of experience in mobile gamedev, over 40 completed projects with custom physics, quality guarantee, and post-delivery support. For deeper understanding, see Collision detection.