Learn to Build a 3D Puzzle Game with Unity

Begin a comprehensive course to build a 3d box-pushing puzzle game in Unity for mobile. Explore level design, lighting, inverse kinematics, and load/save; then dive into humanoid animation.

Explore a rigged character mesh in Unity, including its skeletal animation data, a box mesh reference, and how to configure scale for proper in-scene size in a box-pushing puzzle game.

Rig a character by revealing its underlying bone structure and hierarchy in Unity, then switch the animation type from generic to humanoid to auto-detect bones and create an avatar.

Explore how Unity uses avatars to map bones onto a character mesh, enabling skinning, retargeting across characters, and bone-based posing and animation.

Learn how muscles map bones to vertices to deform a character, letting the same skeleton fit tall or fat bodies via muscle ranges. Explore neck tilt and head pose extremes.

Split the single animation timeline into four clips (idle, walk, push, cheer) in the animations tab. Map frames 0–143 for idle, enable loop time, then apply changes.

Configure the remaining animation clips for the character mesh, creating a cheer clip from frame 44 to 192 that plays once, and is not looped, as shown in the inspector.

Create and configure walk and push animation clips in Unity, define start and end frames, enable looped walk timing and grounding, to animate a character pushing a box.

Attach an animation controller to the character, set idle, walk, and push states on the state machine, and disable root motion so the character walks in place.

Control character animation in Unity by using an integer parameter to switch from idle to walk or push via transitions in the animation graph.

Configure an animation graph in Unity to manage idle and walk transitions with a state variable, switching to walk when idle state equals one and looping the walk otherwise.

Learn to complete the state machine by configuring walk and box-pushing states, adding transitions driven by the state parameter, and adjusting the animation offset to keep the character's feet grounded.

A script links keyboard input to the animation graph by updating a state parameter (idle, walk, push, cheer) through a move type enum, controlling character movement.

Implement grid-based movement in Unity with discrete forward steps, limiting motion to four directions. Use forward vectors, move distance, and move time to push tiles tile by tile.

Import an fbx animated character into Unity, map bones, set animation clips and a simple graph for idle, walk, and push, and switch states with a controller script.

Develop a 3-D puzzle game in Unity by exploring level design, lighting, collision, and rigid body physics, while applying inverse kinematics for pushing motion, save/load functionality, and a chase camera.

Explore implementing player input and movement in Unity: use W to move the character, constrain movement to floor tiles, rotate with D, and keep camera as a child to follow.

Rotate the player in 90-degree increments around the y axis to align with grid, using a rotate routine and a 90-degree increment, with 4.5 seconds rotation and 0.8 seconds movement.

Learn to implement player movement in a 3D puzzle game with Unity, including rotating on the y-axis and moving forward. Snap movement to 2x2 grid and prepare for collision detection.

Drag crate meshes from the props folder into the level, apply textures, remove the animated component, and size it as a prefab for pushing gameplay with proper physics and collisions.

Add collider components to walls and crates using box colliders for optimized collision detection in Unity. Prepare for manual collision detection instead of the physics system.

Plan manual collision detection for a Unity 3D puzzle game by testing the next space and crates, supporting one-at-a-time pushes, and begin point testing colliders to mark walkable areas.

Learn to test points with colliders in a Unity 3D scene to determine space states—empty, crate, or collider—using a point state function and crate tagging.

Implement a validate walk function using the forward direction to test the next space and return a move type (walk, push, idle), then integrate with the handle input function.

Learn how inverse kinematics enables realistic hand placement when pushing boxes in a Unity 3D puzzle game, by aligning hands with the box and understanding the skeletal hierarchy.

Learn how inverse kinematics in Unity lets you pose a leg by moving the foot while the rest auto-bends, with a note that IK scripting is a pro feature.

Use inverse kinematics by creating empty objects as left and right hand destinations under the player character, then use them as targets to guide the hands when pushing a box.

Inverse kinematics in Unity by wiring left and right hand destination objects to a character, enabling IK in the animation graph and integrating with box-pushing behavior.

Implement the IK rig to make the character's hands push the box, blending between push and idle states for smooth motion in Unity.

Set up destination points for boxes by adding a target sprite with a transparent material on the floor, then create trigger colliders tagged end and duplicate endpoints for four boxes.

Develop Unity 3D puzzle game logic to detect when all boxes reach destinations using a box script with a destination flag, trigger events, and a game manager.

Create a smooth chase camera in Unity by applying a C# camera follow script, setting the target to the player, and tuning distance, height, and damping.

Build a 3d box-pushing puzzle game in Unity, covering level design, lighting, inverse kinematics, and animation. Create a game manager for music, level switching, save/load, particle system, and bloom.

Implement a singleton game manager in a Unity puzzle game to track crates on destination points and trigger level progression when all crates reach targets.

Implement a singleton game manager in Unity by using a static instance, guarding with Awake to destroy duplicates, and expose a globally accessible GameManager.instance for other scripts.

Implement level switching in the game manager singleton by assigning unique level numbers, configuring the next level, and displaying a level complete graphic before loading the subsequent level.

Learn how the game manager detects win conditions by scanning all crates for destinations each frame and triggering level completion and a transition to the next level.

Explore how the game manager handles level completion and transitions, including moving to the next level, a wait interval, and drawing the level complete texture before loading the next level.

Explore real time lighting in a Unity 3D puzzle game, using light probes to illuminate moving characters and dynamic objects with indirect lighting and bounce effects, while considering ambient light.

place light probes at key positions to sample lighting, bake with light mapping by probes, and enable light probes on objects and the character.

Attach an audio source to the level root, assign the 2d prince music clip, enable play on awake, and loop to play background music throughout the level.

Import the particle package, attach a shuriken particle system to a torch mesh, and tweak materials and lighting to create a fiery torch prop in Unity.

Enable the particle system's prewarm to show flames from level start, then select a fire texture from the standard assets textures and tweak the particle behavior to improve realism.

Refine the fire particle system in Unity by adjusting the emitter cone, base radius, angle, emission rate, and particle lifetime and speed for the 3D puzzle game.

Discover how to finalize a fire particle system in Unity by adjusting size over lifetime, color over lifetime, transparency, and rotation to create a tapering, believable flame.

Create a prefab from the torch, place multiple instances across the level, and propagate prefab edits to all instances, or break the prefab to modify selected ones.

Apply camera post production in Unity with the image effects package, adding blue and bloom and a subtle vignette, then tune threshold, intensity, and blur for live preview.

Test your game across resolutions and aspect ratios with the game view, add custom resolutions like 800x600, and note these testing settings don't affect final resolution.

Configure Unity's build and player settings to set your game name and company, choose target desktop resolutions, and manage fullscreen, native resolution, and aspect ratios before final builds.

Explore a Unity-based 3D puzzle game that features box pushing, win conditions, torch lighting, light probes, and image effects, and plan the save and load functionality for the next module.

Explore building a 3D box-pushing puzzle game in Unity, covering level design, lighting, inverse kinematics, and a load-and-save system using player preferences and the Mono project framework.

Review the Unity 3D puzzle game's progression from level 0-0 to 0-1, including light-mapped environments and torch particle effects. Plan load and save functionality with PlayerPrefs and XML serialization.

Learn to store and retrieve the last played level using the Unity Player Preferences class, enabling persistent level loading across sessions and simple options storage.

Implement level loading and saving in a Unity 3d puzzle game using the player preferences to remember the last level, and test with Windows registry edits.

Explore saving and restoring level state in Unity using an XML save file. Inspect a sample XML to understand game, box, and player data, including position, rotation, and scale.

Begin deserialization in Unity by creating a data manager to save and later load box positions. Explore serialization basics and the limits on which data types can be serialized.

Refactor a Unity class by removing mono behavior and create a serializable transform data structure to store position, rotation (Euler angles), and scale for crates and the player.

Extend the data manager with box and player data classes, track position, rotation, and scale, wrap everything in a game data class for XML serialization, and prepare save and load functionality.

Implement save and load in the data manager for a Unity 3D puzzle game by serializing the game data with the X amount Serializer to a file and back.

Revise the game manager to connect with the data manager and player controller, initializing them in Awake. Create a function to transfer level data into serializable structures for saving.

Implement save game functionality in the game manager by collecting level box data and player transform data into a serializable structure and writing it to a persistent data path.

implement a restore game function in the game manager by loading saved xml data via the data manager and reconstituting box positions, rotations, scales, and the planet transform.

Learn how to locate Unity's persistent data path on any system by using Debug.Log to print the full application path and access saved game data in the console.

Learn how to save and load game state in Unity using player preferences, on application quit events, and a restore function to load levels and position the player and boxes.

The lecture highlights a bug where restarting the level reloads saved game data, yielding an unwinnable state and guiding use of the default initial state instead.

Use a persistent level counter with don't destroy on load to restore to the initial state on the first launch, while subsequent plays load from the preserved level data.

concluding the course, this lecture recaps building a box-pushing game in unity with level design, light probes, skeletal animation, inverse kinematics, particle systems, chase cameras, and load/save functionality.