Learning Unity and C# for Complete Beginners

Learn the basics of Unity by downloading and installing the software, navigating the interface, and using windows like hierarchy, project, and inspector, while exploring materials, prefabs, components, and parent-child relationships.

Open Unity Hub, create a new project, pick a version, choose 2D or 3D templates, set the project name and location, and explore HDRP and URP render pipelines.

Explore a quick overview of the Unity editor, covering the project and scene, hierarchy, scene and game views, inspector, console, and essential navigation shortcuts for beginners.

Master Unity custom layouts by resizing and docking windows, undocking the game view, and saving layouts to switch between defaults and saved custom layouts.

Explore how scenes act as separate levels in your Unity project, create them via right-click create scene or file > new scene, and switch between saved scenes.

Master Unity game objects and their transform to position, rotate, and scale using move and scale tools, axis constraints, and inspector-managed components.

Create a materials folder, make a ground material with gray albedo, then duplicate materials to color axes green, red, blue, and the cube purple.

Explore parent and child game objects in Unity and how rotation works using the rotate tool, with world space vs local space, and practical transform examples for beginners.

Learn how to create, use, and edit prefabs in Unity, including master templates, instances, and prefab mode, with practical steps to apply changes across all copies.

Explore Unity components—from transform to box colliders and meshes—that drive physics, visibility, and solid objects, and learn to inspect, enable, or disable them via the inspector and reference documentation.

Learn the basics of the C-sharp language used in Unity to control your game. Build your first script and explore variables, if statements, loops, and methods through slow, example-driven explanations.

Learn to create your first C# script in Unity, attach it to a game object, and use Debug.Log in Start and Update to display console messages.

Explore variables in Unity and C#; declare int, float, bool, and string types, learn naming conventions, perform arithmetic, and use debugging to print the average of three ages.

Explore methods in Unity and C# by creating, naming, and calling functions, passing integer parameters, debugging outputs, and understanding scope, sums, and averages with practical examples.

Master if-else statements by evaluating conditions with boolean values and comparison operators, use else and else if, and apply them to health and key examples in Unity C#.

Explore for loops and while loops in Unity using C#, learn loop conditions, index i, and increments, and apply to health, is alive, and total calculations.

Create a simple prototype to test core gameplay with basic shapes, ensure playability, then replace with higher quality assets and animations as you set up levels, players, and enemies.

Upgrade to Unity 2021 via Unity Hub, then upgrading may rebuild scripts and project library; back up first and archive the library folder, or use version control for safe rollback.

Create a red capsule player, attach a controller, and use transform.translate to move by x, y, z, adding to the current position rather than a target.

Use time.deltaTime to convert movement from meters per frame to meters per second in Unity, by multiplying each axis of transform.Translate by deltaTime for frame-rate independent speed.

Set up and expose move speed variable in Unity using serialize field, then add separate x, y, z move speeds to control how fast the player moves in the inspector.

Explore how play mode tint visually marks when you are in play mode and how to copy and paste component values to preserve desired runtime changes.

Learn to read keyboard input in Unity using the input class, get key and key code, and move a player with W A S D via translate with delta time.

Create a basic Unity level using primitive shapes, apply materials, and convert objects into prefabs while mastering grid and object snapping for precise placement and level iteration.

Align the main camera with the scene view using look at scene view or control-shift-F, then adjust its angle to a top-down isometric view.

Learn how collisions prevent the player from walking through walls by adding a rigid body and colliders, control gravity and rotation, and test to ensure correct movement.

Learn to organize a Unity project by cleaning the hierarchy, creating empty game objects, and sorting assets into materials, prefabs, and scripts with keyboard shortcuts.

Learn how vectors define object positions in Unity, using Vector2 and Vector3, setting transform.position, and moving a game object by adding vectors with delta time.

Learn how to refactor Unity and C# code by extracting movement logic from update into a dedicated movement method, improving readability, debugging, and future troubleshooting.

Apply rigidbody velocity to move the player in unity, replacing transform-based positioning, to prevent collision jitter and improve physics interactions.

Cache a component by storing a rigid body reference in start to avoid get component calls every frame. Use the cached reference to set velocity and rename variables with refactor.

Learn to create a bomb object in Unity, structure it as a prefab with a separate model, and use keyCode to log a bomb planted message on space press.

Learn to instantiate a bomb prefab in Unity by pressing space, creating a copy at the player's position, and using position with rotation identity for simple placement.

Explore how collisions work in Unity by using colliders and rigidbodies, and learn to handle on collision enter, stay, and exit to detect and respond to hits in code.

Learn how triggers differ from collisions in Unity, enable isTrigger on a collider, and handle OnTriggerEnter, OnTriggerStay, and OnTriggerExit to detect objects entering, staying, and exiting.

Learn how to use tags in Unity to find the player at runtime. Assign and apply tags to prefabs, then retrieve the player controller with GetComponent.

Learn to use triggers and collisions in Unity by turning a bomb from a trigger into a solid object after the player exits, using the sphere collider component.

Create your first enemy as a capsule with a kinematic rigidbody, controlled by an enemy controller script, and use a waypoint patrol moving towards targets via move towards.

Learn how is kinematic rigidbodies affect collisions, fix enemy bomb interactions by adding a rigidbody to the bomb, and use the collision action matrix and is moving.

Learn how to use arrays to move an enemy between multiple waypoints by storing transforms in an array, initializing size, and accessing positions with zero-based indices in Unity.

Implement a basic enemy patrol in Unity using C# by measuring distance to waypoints with Vector3.Distance, cycling through a waypoint array, and guarding against index out of bounds.

Learn to create a Unity waypoint system with C#, where an enemy traverses and reverses at the end. Handle forward and backward movement through the waypoint array.

Create a game manager that tracks lives and spawns the player from a prefab at the origin. Organize the scene by parenting the spawned player under a parent transform.

Learn how to locate the game manager from the player script using tag-based lookup and the find object of type method, including serialized fields and get component usage.

Learn how private and public variables and methods control access between scripts in Unity, illustrated with a game manager and player controller managing lives and death events.

Learn to implement a bomb timer in Unity by adding a delay and an explosion timer, updating with time.deltaTime, logging the explosion, and destroying the bomb object.

Implement a four-direction bomb explosion in Unity by instantiating explosion prefabs from a bomb, moving each explosion with a rigidbody in fixed update using direction, speed, and range.

Implement a bomb blast range by storing the explosion start position, using Vector3.distance to measure movement, and destroying the explosion when it travels the set range.

Use Unity trigger colliders to detect explosion hits and log each hit object's name and tag in the console via OnTriggerEnter.

Learn to stop explosions from passing through walls by tagging wall blocks with a Block tag and destroying the explosion on hit in Unity using C#.

enable bombs to chain react in Unity by refactoring the explode method and triggering bombs from explosions, then test with adjusted delay and range.

This lecture teaches you to snap bombs to the nearest grid center by rounding the player's current x and z positions with Mathf.Round and setting y to zero.

Add trail effects to explosions with a Trail Renderer, assign an orange material, adjust width and taper over time, and preview the prototype in the scene.

Implement a max bombs limit, track current bombs placed, and use and operator to enforce limits; update on explosion and wire the bomb script to the player controller.

Wire explosions to call die on player and enemy controllers, expose private methods, and print a debug player death message in the console.

Disable user input with a has control flag when the player dies, then respawn after a delay by invoking spawnPlayer with destroy's delay, gated by lives.

Replace hard coded spawn timing with dynamic values by adding a public method on the player to return the destroy time, and fetch it from the game manager.

Create destructible blocks that break on a bomb blast by duplicating a block prefab, tagging it destructible, and updating the explosion script to destroy the block.

Adjust the player collider in Unity by resizing the capsule collider radius to improve movement and corner navigation during prototype playtesting, with notes on clipping and future improvements.

Implement a one-second pause for the enemy at each waypoint by creating private increase and decrease waypoint destination methods, replacing direct calls, and using invoke to delay movement between waypoints.

Update enemy waypoint delays to a random float between a minimum and maximum value, exposed as serialized fields in Unity, and use Random.Range when calling Invoke.

Learn to modify the enemy controller so when an enemy hits a bomb it waits a random delay like a waypoint, then reverses direction toward the previous waypoint and continues.

Learn to prevent Unity enemy prefab errors by checking for missing waypoints, initialize targets to zero, and use log warnings to surface issues without crashing.

Build a bigger prototype level by adding destructible and non-destructible blocks, enemies with waypoint paths, and prefab-based organization, while aligning the scene with the game view.

Learn to create smoother, multi-directional player movement in Unity by using separate if statements and plus-equals for velocity. Understand collider size and friction basics as you fix corner navigation.

Create and apply a physics material to control dynamic and static friction and bounce, then assign it to the player, blocks, destructible blocks, and enemies for smoother movement.

Learn to implement a camera controller that follows the player with an offset, using late update to avoid jitter, handling player respawns and null checks for robustness.

build a score system in Unity with a game manager, a private current score, and a public update score method to add points when enemies die, plus debug logs.

Learn to build a user interface in Unity, displaying lives and stats on a canvas, and create windows for pause, win, and lose screens.

Create a Unity UI by adding a canvas with a score text, optionally using text mesh pro, and anchor it to the top-left with scale with screen size.

Connect game manager to ui score text via Unity engine ui namespace, expose a serialized text field, and update the score by converting integers to strings with d formatting.

Learn to display player lives in Unity using C# by duplicating the score UI, creating lives text and an update lives text method called from start and on life changes.

Display and persist the player's max bomb count via the game manager, initialize the player with that value, and update the UI text to show bombs in play.

Display the bomb explode range on the UI by refactoring to use the game manager for the range, switching from float to integer, and updating the UI text accordingly.

Create a pause button in Unity by using time.timeScale to pause and unpause the game, controlled with a public pause method in the game manager.

Fix a bug that allows planting bombs when paused by adding a paused flag on the player, a set paused method, and updating the game manager's input check.

Create a pause panel as a centered UI container in Unity, with a title and resume button, and toggle its active state using the game manager's setActive calls.

Implement a game over panel in Unity by showing it when the player runs out of lives, wired through the game manager using the pause panel pattern.

Create a game over panel with a main menu button, and implement a public load main menu method that uses scene management to load the game scene by name.

Build a main menu in Unity by creating a scene with a canvas and TextMesh Pro, then wire a start button to load the game scene using build settings.

Learn to create a second level by duplicating the level object or building a new scene, save as level zero two, and refine layout using grid snapping for precise placement.

Attach the game manager to a prefab with its canvas and main camera, then drag the prefab across levels to ensure the references and event system are correctly applied.

Implement a win condition by using the game manager to count level enemies via the enemy tag, update the count when enemies die, and trigger level complete when zero.

Implement seamless level progression in Unity by loading the next scene using the build index, updating the main menu and game manager, and ensuring level transitions handle missing next levels.

Create a win game panel in prefab edit mode, show it on the last level via the game manager's is last level flag, and load the next level otherwise.

Learn to troubleshoot and fix bugs in your Unity game, from minor cosmetics to game-breaking issues, by identifying causes and applying fixes before they escalate.

Fix an index out of bounds error in enemy waypoint navigation by adding bounds checks in waypoint increment and decrement, keeping destination within zero and array length.

Identify and fix an early win trigger in a Unity game by tracing enemy death calls and preventing multiple explosions from counting as multiple deaths with an is dead guard.

Debug and fix a Unity C# game over bug by adding an isDead boolean guard in the die method to prevent multiple deaths when collisions with bombs and enemies occur.

Fix two minor bugs in the Unity project: zero the player's rigidbody velocity on death to stop sliding, and set isKinematic to ignore collisions so enemies stop pushing during death.

Fix a bug where enemies walk through bombs in Unity by adding on trigger enter checks, aligning with on collision enter, and shrinking scales to prevent 1-unit grid overlap.

Explore for each loop and how to prevent bomb placement on existing bombs, while learning about layers and layer masks to manage game elements in Unity and C# for beginners.

Learn to use foreach loops in Unity and C# by iterating over arrays of numbers and strings, printing each value with debug.log, and understanding collections.

Limit bomb placement to one per grid space using a Unity overlap sphere to detect an existing bomb and block new placements.

Discover how to use layers in Unity to group objects, control camera visibility, and manage collisions via layer collision matrix, including creating a bombs layer and assigning it to prefabs.

Learn to use layer masks with overlap sphere in Unity to filter collisions so only bomb layers are checked, optimizing bomb placement and preventing multiple bombs.

Begin creating multiple power-ups for the game, enabling player collision and collection, implement a power-up spotter, and learn the switch statement concepts.

Create power ups in Unity using a C# enum to differentiate types like max bombs, range, and speed, then assign each type via a dropdown and color the prefabs.

Enable power ups as triggers, detect the player with on trigger enter, and branch by an enum for max bombs, range, and speed power ups.

Increase the player's max bombs by one when the blue power-up is picked up, update via the game manager, reinitialize the player, and destroy the power-up.

Create reliable backups of your Unity project by copying the project folder from Unity Hub, naming backups with dates, and using version control to revert changes when needed.

Enable explosion range upgrades by adding an increase explode range method in the game manager and wiring it to the range power up, so bombs explode farther with each pickup.

Refactor movement to a single move speed, pass it from the game manager to the player, and implement speed upgrades via power ups.

Update the user interface to reflect power-up upgrades (bombs, range, speed) by wiring UI texts to the game manager and calling update methods after increases.

Learn to replace chained if statements with a switch in C# by refactoring a power-up handler; the lesson covers cases, break, default, and handling max bombs, range, and speed.

Create a power up spawner that randomly spawns power up prefabs when a block is destroyed, using a serialized prefab array and Unity's instantiate method.

Learn how to cap power-up limits in Unity by using clamp on max bombs, explode range, and move speed within the game manager.

Replace placeholder art with real 3D models by importing and integrating assets for your player, enemies, and power-ups, then apply materials and textures to create brick and ground visuals.

Learn where to find free 3D assets for Unity, understand licensing like the Unity Asset Store license and CC0, and explore Kenny.nl and CourtneyAsk.com for CC0 packs.

Import assets and models by dragging the downloaded folder into the Unity project. Replace the green block with a crate from Ultimate Modular Rooms Pack and save as a prefab.

Modify materials on imported models in Unity by duplicating remapped materials, creating crate materials, and applying custom colors to dark wood and wood textures for varied crate appearances.

Select and modify a prefab block to resemble brick, resize and align a floor standard texture, then use the color picker to customize the brick material in the game view.

Import CC0 brick textures from Open Game Art into Unity, create a ground material, tile the texture, and apply a normal map for depth.

Import player models from the ultimate animated characters pack using CC0 assets, place them in a models folder, adjust scale and collider, and modify skin materials for color customization.

Import a cute animated monsters pack, extract and apply textures to enemy models in Unity, remap materials, and adjust scale for proper placement in the scene.

Import a bomb model into Unity, extract and customize bomb and wick materials, assign them to the bomb prefab, and test the scene with the game camera angle.

Duplicate the bomb model to create a distinct bomb power up, then create and apply new power up materials with color and glow to distinguish it from the regular bomb.

Import a target model from a 3D asset pack to use as the range power up in Unity, then place it in the range power up prefab and adjust scale.

Import and swap a speed power-up model in your Unity project, scale and color it, then add spin and particle effects using a prefab setup that keeps replacement easy.

Discover how to use prefab variants in Unity to create multiple enemies from a single walk enemy, customize models like crab or penguin, and configure shared waypoint behavior.

Demonstrates prefab variants: edits to the master propagate to all derived variants, while overrides affect individual variants; avoid applying changes to the base and use previews carefully.

Start learning how to work with animations in Unity and C# for complete beginners, including the player, enemies, blocks, and power-ups, plus using pre-existing animations and creating new ones.

Create your first bomb animation in Unity using an animator and animation clip, keyframes, and the dope sheet to control frames and sample rate.

Create a block destruction animation in Unity by defining a block destroyed clip, an idle clip, then use a trigger to transition from idle to destroyed.

Trigger the block's destroyed animation by retrieving the block's animator on trigger enter, setting the is destroyed trigger, and delaying the block's destruction to let the animation play.

Create custom power-up animations in Unity by keyframing scale and rotation for bomb, range, and speed power-ups, experimenting with pulsate and spin, and organizing clips and animator settings for looping.

Create idle and walking animations for the player in Unity by configuring an animator controller, applying imported model animations, and assigning the avatar on the player prefab.

Create a walk enemy animator and assign a cactus avatar for idle and walk. Drive transitions with is walking and override crab and penguin avatars in variants; update enemy controller.

Learn to implement a death animation for enemies in Unity and C# by delaying destruction, flagging isDead, disabling colliders, and triggering animator transitions to a non looping death state.

Trigger the player defeat animation from the pack when the player dies, using the is dead boolean parameter to drive idle and walk transitions to defeat.

Learn to trigger a victory animation and display a delayed win panel in Unity. Disable player control during victory and add delays before loading the next level for smooth gameplay.