About

Maze-solving is a graph traversal problem with direct applications in robotics path planning, VLSI routing, and network topology. This tool generates perfect mazes using a Depth-First Search recursive backtracker, guaranteeing exactly one solution path between any two cells. The ball obeys simplified Newtonian mechanics: acceleration a is applied from user input, velocity v accumulates with a friction coefficient μ ≈ 0.92 per frame, and position updates via Euler integration. Wall collisions use axis-aligned bounding box checks against the grid. The maze grid scales from 7×7 at level 1 to 25×25 at level 20. Solving time is tracked per level. Note: device tilt controls require a gyroscope-equipped device and HTTPS context. Desktop users rely on arrow keys or WASD.

Formulas

The ball position is updated each frame using Euler integration. User input (arrow keys or device tilt) provides an acceleration vector that is scaled and added to velocity. Friction decays velocity each frame to prevent infinite sliding.

v_new = (v_old + a ⋅ dt) ⋅ μ

x_new = x_old + v_new ⋅ dt

Where v is velocity (px/frame), a is acceleration from input (0.5 px/frame²), dt is the time step (normalized to 1 at 60fps), and μ is the friction coefficient (0.92). A lower μ makes the ball stop faster. Collision detection checks the ball’s bounding circle against each wall cell in the grid. If the ball center enters a wall cell, it is projected back to the nearest edge and the velocity component normal to that wall is zeroed.

Grid size = 7 + (level − 1)

The maze is generated via recursive backtracking (randomized DFS). Starting from cell (0,0), the algorithm visits random unvisited neighbors, carving passages. This produces a perfect maze: every cell is reachable, and there is exactly one path between any two cells. The start is placed at the top-left and the exit at the bottom-right.

Reference Data

Level	Grid Size	Cell Count	Est. Path Length	Target Time (s)	Difficulty
1	7×7	49	15 - 25	15	Beginner
2	8×8	64	20 - 30	20	Beginner
3	9×9	81	25 - 40	25	Beginner
4	10×10	100	30 - 50	30	Easy
5	11×11	121	35 - 60	35	Easy
6	12×12	144	40 - 70	40	Easy
7	13×13	169	50 - 85	45	Medium
8	14×14	196	55 - 95	50	Medium
9	15×15	225	60 - 110	55	Medium
10	16×16	256	70 - 125	60	Medium
11	17×17	289	80 - 140	70	Hard
12	18×18	324	85 - 155	75	Hard
13	19×19	361	95 - 170	80	Hard
14	20×20	400	100 - 190	90	Hard
15	21×21	441	110 - 210	95	Expert
16	22×22	484	120 - 230	100	Expert
17	23×23	529	130 - 250	110	Expert
18	24×24	576	140 - 270	115	Expert
19	25×25	625	150 - 300	120	Master
20	25×25	625	160 - 320	130	Master

Frequently Asked Questions

The algorithm starts from a single cell and uses depth-first search to visit every cell exactly once, carving passages between adjacent cells. Because every cell is visited, the resulting maze is a spanning tree of the grid graph - meaning exactly one path exists between any two cells. The start and exit are always connected.

Each frame, velocity is multiplied by the friction coefficient μ ≈ 0.92. This exponential decay means the ball retains 92% of its speed per frame. At 60fps, the ball loses about 99.5% of its velocity within 1 second of releasing input. Reducing μ to 0.85 would make the ball feel "grippier" but less realistic for a rolling ball on a smooth surface.

Device tilt requires the DeviceOrientation API with a gyroscope sensor. Most modern smartphones support this. iOS 13+ requires explicit user permission via a button tap (cannot auto-request). Some tablets and older Android devices may lack gyroscope hardware. The game always provides on-screen directional buttons as a fallback.

Velocity is clamped to a maximum of 5 pixels per frame to prevent tunneling (passing through thin walls). Additionally, the collision check tests the ball's projected position against all neighboring grid cells within a 2-cell radius, resolving overlaps by axis-aligned projection. This is sufficient for the cell sizes used (minimum ~16px at level 20).

Target times are estimated from the average BFS shortest-path length for each grid size, multiplied by an empirical factor of approximately 0.4 seconds per cell traversed. This assumes a skilled player who knows the path. First-time solvers typically take 2-4× the target time due to dead-end exploration.