Unity: From Master To Pro By Building 6 Games

Experience the pin the circle game preview, featuring a rotating circle, shooting needles to attach around it, speed controls, levels, and game over when needles collide.

Organize a Unity 2D project, import and slice sprites from a sprite sheet, configure circle and needle with colliders and prefabs, and apply import settings.

Learn to set up prefabs in a scene, position and scale objects, and build a Unity needle movement script that fires via a serialized needle body and rigidbody velocity.

Detects collision between the needle and the circle with a 2D trigger collider, using tag checks to stop and pin the needle on contact.

Apply a circle rotation script with a serialized rotation speed and delta time to rotate around the z axis, and set the needle as a child to rotate with it.

Add ui elements to a canvas in Unity, configure render mode and canvas scaler for multiple resolutions, and wire a game manager with a shoot button and needles.

Make the game manager a reachable instance and wire the shoot button to call shoot needle function. Instantiate needles and position them, tracking with an index to finish the game.

Create a main menu with a background image, set up the main camera and screen size, add play, leaderboard, share, and raid buttons, and link a controller to load gameplay.

learn to add a score system in unity by creating a score canvas and text, then update the score with a score manager as you shoot.

Add finishing touches by creating needle obstacles around the circle with prefabs and a needle head tag. Use coroutines and random ranges to vary rotation and levels.

Preview the jump hero game built from scratch, featuring platform-to-platform jumps, a power bar for jump force, game over and restart flows, and dynamic camera on newly created platforms.

Import assets in Unity, slice the player sprites, and build idle and jump animations with an animator parameter jump, creating transitions between idle and jump.

Add a box collider and rigidbody to the player, resize and position it, then build a platform with a collider and a trigger; set mass and drag, and save prefab.

Configure a jump system by creating and positioning UI elements, attaching a player jump script with a rigidbody and animator, and implementing pointer down/up handlers to control jump power.

Learn to implement a unity jump by calculating and clamping horizontal and vertical forces, updating them each frame, and using a jump flag with platform detection to trigger landing.

Learn to build a game manager that initializes the player and platforms, spawns the initial platforms with a random range, and sets up camera movement for jumps to new platforms.

Spawn a new platform as the player jumps, and smoothly lerp the camera to the next position using a 1.5 second lerp with random x and y placement.

Create and configure the main menu scene with a canvas background image, centered title text, and a play button, then attach a main menu controller to load the gameplay scene.

Create a game over panel with a canvas, score text, and back and restart buttons, plus a fade-in animation to reveal it when the player dies.

Build a game over manager to control the game over panel, wire up play again and back to menu buttons, and display the final score when the player dies.

Add a text UI below the canvas and a ScoreManager singleton to increment and display the score, then show the final score on game over.

Build a power bar by adding a slider to the canvas, configure the background and fill images, set max value to 10, and update its value using time delta time.

Preview a Unity basketball shooter game called street shoot, demonstrating a main menu, ball selection, drag-to-aim with a predicted projectile path, and ball-count management via scoring and sound effects.

Configure a basketball shooter project by importing sprites, slicing assets, and building ball prefabs. Set up colliders, rigidbody physics, ramps, nets, and tag objects to finalize reusable prefabs for gameplay.

Set up the gameplay scene in Unity by configuring canvas to screen space camera, adding a background, ground collider, left and right walls, and a material for ball bouncing.

Create a Unity main menu by building a scene with a canvas and buttons, arrange UI with grid layout, and add fade in and fade out animations via menu controller.

Create and wire a main menu controller in Unity, using an animator to fade the ball panel, wire up play, select ball, and back to menu actions for smooth navigation.

Build a Unity ball select script to collect button references, tag balls, assign click listeners, determine the selected ball index, and inform the game manager to spawn it.

Create and manage balls in a Unity game by implementing a singleton game manager, a ball creator, and ball images, then instantiate balls on gameplay load.

Set up a shoot script in Unity by defining power, life, and drag thresholds; initialize components, create dots for projectiles, and prepare for dragging to shoot.

Unity: build a shoot script that initializes dot markers for a projectile path and toggles the ball's kinematic state. Update aim on drag and compute shooting force from mouse input.

Calculate and visualize a projectile path with start position, velocity, and time; launch by applying force on release, using dead zone and release zone, and respawn after ground hit.

Finish shoot script in Unity by fading ball via color alpha, destroying it when life expires, and spawning a ball via game manager with gravity -30, friction 1, bounciness 0.5.

Implement a ball count system with a ball text component, 10 initial balls, and a game manager that updates the display, decrements on shoot, and handles ram and net touches.

Preview a Unity puzzle game prototype with a main menu and pieces, and learn to store puzzle pieces in a 1D array, convert to 2D, and check for solved state.

Define a public weapons enum for none, pistol, rifle, and sword in Unity, and use it to compare values with single pipe sign and single and sign.

Learn to declare and populate two-dimensional arrays with rows and columns in Unity, using nested loops to fill with random numbers and access elements via numbers[row, column], noting index bounds.

Encapsulate data by making fields private and exposing them with get and set accessors via a public property. Demonstrate reading power through a public Power property in a player class.

Import assets into a new Unity puzzle project, use the sprite editor to slice images by grid with a top-left pivot, and name each piece for a 2D puzzle.

Create a main menu and puzzle select screens in Unity by adding scenes, setting background images, and configuring play and back buttons with anchors and native sizes.

Create and wire menu controllers to load levels, switch between main menu, select puzzle, and gameplay, using button events, event system, and puzzle naming conventions to identify the chosen puzzle.

Define a public static game variables class in Unity to store max throws, max columns, and max size for a 4x4 puzzle, then implement puzzle pieces and a game manager.

Learn to implement a singleton game manager in Unity, keep a single instance across scenes, and route the puzzle index and puzzle images to drive the puzzle gameplay.

Load puzzle images from a resources folder using a generic type, assign them to puzzle pieces, and arrange a 4x4 grid with an empty space using viewport to world coordinates.

Learn to implement a shuffle function that randomizes puzzle pieces in a matrix, swap elements, and reposition game objects using viewport coordinates for a playableUnity puzzle game.

Check input detects mouse clicks, casts a ray from the main camera to identify touched puzzle pieces, parses piece indices, updates the puzzle matrix, and initiates animation.

Wraps up the puzzle game by implementing animate movement for puzzle pieces, checking victory, and managing game state (playing and animating) in update, plus wiring colliders and testing the level.

Preview a Unity Angry Birds style game with a main and level menu, a slingshot, birds and piggies, drag-to-aim, trajectory lines, trail rendering, and parallax background.

Import assets and set up a gameplay scene in Unity for Angry Birds style game, configuring birds with colliders, rigidbodies, trails, and prefabs; tag pigs and blocks and sorting layers.

Create a multi-layer level by configuring background, trees, ground, and foreground with sorting layers and pixels per unit, then assemble a fortress of bricks and piggies around a bird.

Slice the sling shot sprite into left and right parts, create a sling shot holder with empty left and right objects, and set up line renders and trajectory material.

Develop a brick script that handles collisions, calculating damage from the colliding rigidbody velocity, playing a smash sound through an audio source, and reducing health until destruction.

Define and manage game variables and states for the bird slingshot, including collider radii and minimum velocity, and implement idle, pulling, fly states plus start, playing, won, and lost.

Initialize the bird script by wiring components, setting the line renderer, collider, and rigidbody; enable throwing behavior, play audio, then destroy after a delay once velocity falls below a threshold.

Implement a Unity camera follow script that clamps the camera x position between 0 and 14 while following a bird, with initialization in Awake and updates in Update.

Create the sling shot script with left and right origin transforms and middle vector. Configure line renderers, trajectory visuals, and bird throw with speed, timing, and a bird thrown event.

initialize the sling shot by positioning the bird and enabling trajectory visualization, then compute and render the trajectory using velocity, gravity, and segment-based calculations to throw the bird.

Finish the sling shot script by handling idle and pulling states, initializing the bird, rendering slingshot lines and trajectory, mapping screen to world coordinates, and throwing.

Learn to build a Unity game manager that coordinates the slingshot mechanic, initializes lists of bricks, birds, and pigs, and controls game states, camera movement, and win or lose logic.

Finish the game manager by implementing the update function: switch on game state, handle input to restart or proceed, and manage the bird, slingshot, bricks, pigs, and end-level prompts.

Implement a Unity camera move script that lets players drag the camera during play, using drag speed and clamped deltas to view pig targets before launch.

Implement destroyer and parallax scroller scripts in Unity to destroy targets on trigger enter (birds, pigs, bricks) and apply parallax using delta camera movement and a parallax factor.

Create interactive menus in Unity by building a main menu and a level menu with canvases, background images, and buttons that load levels and navigate back.

Develop a pig script that manages health, plays hit audio, shows a hurt sprite, and applies collision damage from birds and bricks, destroying the pig at zero health.

Attach physics materials, scripts, and parallax settings to finalize the scene; test slingshot mechanics, line renders, and enemy health, then configure the game manager and restart flow.

Build a beans crusher candy-crush style game from scratch, featuring a main menu, grid-based gameplay, potential matches, bonuses, and row or column destruction.

Import assets, set sprite resolution to 128 and true color, create and save beans, explosions, and swirls as prefabs, then assemble scenes with colliders and six explosion animations for scripting.

Create a bonus utilities script to manage bonuses and game states, define bonus type and game state enums, and implement a checker for destroy whole row or column.

Define a public static game variables class to centralize grid settings, animation timings, minimum matches, bonus thresholds, and scoring for matches and row or column destruction.

Create and attach a candy script to each candy in a Unity scene, storing row, column, bonus type, and color, with initialize, compare, and swap functions for candy matching.

Create a match checker script in Unity to animate potential matches with a coroutine, checking horizontal and vertical neighbors and fading colors of involved sprites.

Create a dedicated candy array class to manage a 2D game grid of candy objects, offering an indexer, swap logic, and undo via backups to support grid-based gameplay in Unity.

Build horizontal and vertical candy match detection in Unity by implementing a generic get matches function that scans neighbors, checks candy types, and returns non-duplicate matches when three are found.

Create boolean checks for destroy whole row or column bonuses, and implement get entire row and get column functions to collect matched candies; remove items when minimum matches are met.

Create an altered candy info class in Unity to manage a private candy game object list, expose max distance, and return a distinct candy list while avoiding duplicates.

Explain how to collapse specified columns by building altered candy info, moving non-null candies into null slots, and get empty items on column with CandyInfo.

Build a candy cascade system in Unity by creating a candy matches info class and managing bonuses. Learn to compute horizontal and vertical matches to destroy rows and columns.

Learn to extend the match checker by creating a public static function that returns potential matches from a candy array of game objects, checking horizontal triples to crush candies.

Implement check horizontal two and horizontal three in the magic tracker class, validating matching candies across adjacent columns and returning matching game objects.

Demonstrate vertical matches by checking candies above and below the starter in a grid, verifying same type with get components, and returning the matching game objects.

Finish the vertical and horizontal match checker by validating candy positions in a grid, handling multiple scenarios, and returning the matched candy objects.

Build a candy manager class to oversee the game, create candies, spawn positions, manage score via a score text, and wire candy, explosion, and bonus prefabs with a sound manager.

Unity candy manager part two initializes candy and bonus types on prefabs, enabling type-based matches and instantiating new candies at calculated bottom-right positions using candy size.

Create and initialize the candy manager by setting up spawn positions, generating initial candies, and implementing horizontal and vertical match checks to drive gameplay and scoring.

Create a private check for potential matches in the candy manager, waiting for seconds, detecting matches horizontally and vertically, and start and stop coroutines to animate and reset opacity.

Advance the candy manager by refining sorting layers during candy animation, handle matches with explosions, remove matched candies, and spawn bonuses by parsing candy type to select prefab.

Spawn new candies in columns with missing items by creating a private function that generates candy info for missing columns, instantiates candies, initializes type, row, and column, and animates movement.

Learn how to implement candy match logic in Unity: swap two candies, detect and resolve matches, undo invalid swaps, trigger cascades, bonuses, scoring, and update the board.

Wrap up by implementing the update function to detect candy selections and initiate the selection state, then check for matches and trigger the find matches, collapse, and bonus candies.

Create a main menu scene with a background image and a play button that loads the gameplay scene; include a back button and a gameplay controller to return to menu.

Load scenes in Unity using scene management to switch between two scenes by name, add open scenes to build, and attach scene manager scripts to navigation buttons.

Migrate from the deprecated onlevelwasloaded to scene management, subscribe in enable while unsubscribing in disable, and detect the loaded scene by name.

Explore Unity 5.5 sprite compression and set textures to true color, then override per platform formats like RGBA 32-bit or 24-bit to balance graphics RAM and visuals.

Switch from the is kinematic checkbox to the body type option in Unity 5.5, and learn how dynamic, kinematic, and static rigidbodies differ in gravity, forces, velocity, and collisions.

Explore Unity's Rigidbody simulated property by selecting dynamic, kinematic, or static body types, and learn how the simulate checkbox enables gravity-driven physics in your game.

Learn how to avoid a common Unity animation mistake by not recording object position, and remove the animation's position property to let the rigidbody fall naturally.