Create a Procedural Jigsaw Puzzle Mobile Game from Scratch

Learn to create procedural jigsaw puzzles by splitting an image into a 3x3 grid using tiling and offset, then implement the grid in Unity for a mobile Android puzzle.

Introduce a grid scale parameter and adjust the start position to scale the grid and spheres. Apply the grid scale to spawned spheres and plan tiling with quads and textures.

Switch from spheres to quads, add a texture, and create an unlit material to control tiling and offset, with wrap mode set to repeat for a seamless puzzle grid.

Create a Unity input manager to handle single and two-finger touches and map to world via screen-to-world point. Configure the puzzle controller with the grid scale to detect nearby pieces.

Learn to detect and manage puzzle pieces by integrating a puzzle generator, storing pieces, and computing the closest piece within a detection radius to enable piece movement on the grid.

Learn to move puzzle pieces with touch input by implementing start/move/stop logic, world-space drag, delta tracking, and smooth interpolation for proper z-order.

Implement z sorting for puzzle pieces by offsetting each piece’s z position, ensuring the selected piece stays above others while the rest move back, avoiding visibility issues.

Add z sorting to keep the selected puzzle piece on top by moving its z position using a central z offset and a constants class for cleaner code.

Learn to select the top piece in a procedural jigsaw puzzle game by filtering nearby pieces, sorting by z position, and keeping placed pieces fixed.

Set up puzzle bounds and a four-piece grid, assign each piece a correct position, and validate placement by measuring distance to its target, locking pieces once correctly placed.

Set the puzzle world size with a new constant, compute grid scale from world size and grid size, and initialize it at startup to fix piece detection and bounds.

Implement camera panning for a procedural jigsaw puzzle mobile game by building a camera controller and input manager that enables single-touch drag using screen coordinates and a configurable move speed.

Learn to implement two-finger zoom in Unity using Unity Remote, a two-touch input workflow, and an orthographic camera, including calculating the zoom center and adjusting the camera size.

Store four neighbors for each puzzle piece (right, bottom, left, and top) then move within bounds, check the correct position, and merge or remove groups.

Configure and store puzzle piece neighbors by linking right, bottom, left, and top references, derive x and y from index, validate grid positions, and wire into the generator.

Check all four neighbors, validate and compute each neighbor’s correct local and world position, then snap puzzle pieces together within a minimum distance while handling grouping scenarios.

Implement a snapping system that pairs puzzle pieces as neighbors and forms a group. Then align the group to each piece's correct world position and manage reparenting in Unity.

Validate all pieces in a group for a procedural jigsaw game by iterating through the group and validating each piece, while using a non-recursive flag to prevent infinite loops.

Learn to implement two-finger rotation of puzzle pieces in a procedural jigsaw game, using the input manager and puzzle controller to rotate single pieces or groups.

Learn rotation-aware snapping and neighbor alignment for a procedural jigsaw game. Validate orientation using identity rotation checks, rotate groups to match neighbors, fix z-order, and randomize initial piece rotation.

Discover procedural mesh techniques to generate square puzzle pieces and transform them into non-square shapes with holes and knobs. Learn ear clipping triangulation and clockwise vertex ordering for clean geometry.

Learn to build the first procedural puzzle piece mesh by defining vertices and triangles, then assign it to a Unity mesh and visualize with gizmos.

Leverage the ear clipping algorithm with a mesh triangulator to convert 3d vertices to a 2d array, generate triangles, and prep splines using dream text planes in Unity.

Integrate dream text planes to create knobs and holes for puzzle pieces, configure a spline, and prototype top-edge knobs with prefabs for future shapes.

Add knobs on the right, bottom, and the left edges by calculating edge midpoints and rotating splines. Use -90, -180, and -270 degree rotations and preview results in unity.

Learn to create a procedural hole by duplicating a knob spline into a whole spline, apply it to puzzle edges, and implement a random asset selection in Unity.

Generate random procedural puzzle pieces by selecting edge types (flat, knob, hole) and computing edge vertices, then expose a Unity inspector button to re-randomize without playing.

Configure puzzle piece traits from the generator and convert splines to prefabs to enable updates; use a configure method with an int array [right, bottom, left, top] to generate pieces.

Create a fully procedural puzzle by configuring piece neighbors and edge treats, randomizing knobs and holes for each edge, and validating grid positions to assemble a 2D puzzle in Unity.

Add and propagate edge offsets for a puzzle piece using a float array and configure method to position knobs and holes along edges, with min and max asset offsets.

Implement random float offsets in the puzzle generator and compute right, top, bottom, and left edge offsets. Prepare to fix UVs to display the texture on each piece.

Add uvs to the procedurally generated puzzle pieces, remap vertices from -0.5 to 0.5 into 0 to 1, and assign them to the mesh to map textures.

Implement a core loop by randomizing puzzle pieces in a 2x2 grid, validating each piece via events, and reloading the scene when all pieces are valid.