The Complete Unity C# Game Developer Bootcamp Part 2 of 2

Create a new Unity project in Unity Hub, using the 2019.3 3d template, for a 2.5 d platformer. Build a physics character controller and essential platform elements from scratch.

Set up a simple 2.5d platformer level by creating a scalable platform, using prefabs, and organizing the environment; enable basic movement, jumping, double jumping, and moving platforms.

Set up a capsule as the player, name and tag it, and add a rigidbody for gravity, then remove it to implement a custom gravity and a physics-based controller.

Create a collectible item by turning a zero z-position sphere named collectible into a prefab, place several in the environment, set isTrigger true, and add a rigidbody with gravity off.

Script a custom Unity character controller from scratch, using the move method to translate horizontal input into direction and velocity while managing gravity in a 2.5d platformer.

Capture horizontal input from the axis mapped to a, d, and left-right arrows. Define a direction vector on x axis and move the character controller by that vector times time.

Define velocity as direction times speed using a new vector, with speed adjustable in the inspector. Update the controller move to use this velocity for about five meters per second.

Define a private serialized speed, compute a velocity vector as direction times speed, and move the player by velocity at five meters per second in Unity, without using physics.

Apply gravity to the character by subtracting gravity from vertical velocity when not grounded. Then use the controller's move method to simulate falling, with jumping explored in the next video.

Learn how to implement jumping in a Unity C# game. Update logic applies gravity and velocity per frame, and pressing space sets the y velocity to a defined jump height.

Implement jump by detecting space with input.getKeyDown, ensure grounded, and set y velocity to jump height in Unity; observe bunny hop when spamming, to fix later.

Fix and optimize a Unity character controller's jumping by caching the y velocity to prevent snapping. Use controlled jump height and gravity to achieve smooth, responsive jumps.

Master the double jump mechanic in Unity C# by using space input and a can double jump flag, updating y velocity with jump height, and test gravity and platform setups.

Learn to set up coin collectibles, track player coins with a variable, and update a top-left UI display via a UI manager using OnTriggerEnter.

Create a coin collection system by detecting player collisions, incrementing coins, and updating the UI on the canvas with safe, null-checked component access.

Create a moving platform in Unity by using point A and point B as targets and move between them with Vector3.MoveTowards to achieve a ping-pong back-and-forth motion.

Explore a moving platform challenge by implementing a bidirectional patrol between target A and target B using a switching boolean, moving toward targets with Vector3.MoveTowards and time.deltaTime.

Tag the player and parent it to the moving platform on collision, then unparent on exit to move with the platform.

Modularize moving platforms by grouping them under a moving platform parent, using a materials folder with a green albedo, zeroing points A and B, and prefabs for clean duplication.

Add a lives system with a UI counter, start with three lives, respawn at the top when you fall off the map, and restart the game when lives run out.

Remove a life and respawn the player at a saved spawn point when colliding with a dead zone, update the UI, and restart the scene if lives reach zero.

Download the environment pack to access a Unity project with your progress, adding elevator triggers, wall jumping, a moving platform, and a pressure pad for continued puzzle development.

Call the elevator by collecting eight coins and pressing the e key inside the elevator panel’s trigger collider, turning the light blue and using ontriggerenter/stay/exit to detect the player.

Use on trigger stay to detect the player in range, then press E to turn the elevator call button blue via the mesh renderer.

Enforce the eight-coin requirement to call the elevator, querying the player's coin count on collision, playing an error sound if incomplete, and making the required coin count modular.

Expose a designer-friendly required coins field, use player coin count to gate the elevator, and implement triggering of the elevator when coins meet the target.

Create a two-stop elevator using a moving platform with target A and target B. Use a trigger to call the elevator and move toward the current target.

Learn to move an elevator by communicating with the call box, using a trigger collider to detect riders, and toggle going up and down with a bool in Unity C#.

Explore toggling the elevator direction with a bool, moving up via Vector3 move towards origin, and toggling the call button color with elevator called to switch between red and green.

Learn wall jumping in unity by detecting wall hits, using surface normals to bounce off, and locking direction and velocity while grounded for consistent wall jumps.

Implement wall jumping by detecting wall contact when not grounded, using the wall's surface normal to rebound, and controlling a can wall jump flag with input in update.

Learn to implement wall jumping by detecting wall contact in mid-air, using the wall surface normal to push off, and applying a jump boost and gravity to govern bounce.

Push a movable box with a rigidbody along the x axis using on controller collider hit, applying velocity with push power to land on pressure pad turning green or blue.

Detect the moving box by tag, verify a rigidbody exists, compute push direction from the character controller's move direction on the x axis, and apply velocity with push power.

Learn to fix a moving box in Unity by freezing the Rigidbody rotation so it can be pushed without rotating, then push it onto a trigger pad and disable pushing.

Learn to detect when a box sits on a pressure pad using a center proximity check, then disable movement by making the rigidbody kinematic and trigger color changes or events.

Develop a dynamic, modular ledge grab system for the 2.5d certification by building a scene, importing characters from Firebase, and implementing an animation-tree driven climb with the e key.

Create a Unity project to meet the 2.5D certification, download the 2.5D starter files from File Base, and import them; upgrade to the Universal Render Pipeline in the next video.

Install the universal render pipeline via window package manager. Create and assign a URP asset in project settings, and upgrade project materials to URP for correct visuals.

Build a grounded character controller that uses horizontal input to set direction, applies gravity, and enables jumping with space, with speed, gravity, and jump height configurable.

select a humanoid character from filebase and configure its animation workflow in Unity, enabling walk, run, and jump animations through the animator and organizing a model child under the player.

Create and apply a humanoid idle animation for the player using Mixamo, import as FBX, and set up an animator controller in Unity to loop the idle.

Create a run animation in Unity from Mixamo, wire idle-to-run transitions with a speed parameter, disable root motion, and drive animation via C# code using absolute value of horizontal input.

Learn to set up a jumping animation for the player by creating a trigger, importing a running jump from Mixamo, and wiring transitions from idle or running to the jump.

Flip your character when moving left by rotating 180 degrees on the y axis to prevent moonwalking, and ensure forward movement aligns with the right direction using the D key.

Flip a two-and-a-half-d character in Unity by adjusting the y rotation based on horizontal input and z movement, using a temp vector to modify only facing direction.

Implement a ledge grab system in Unity using a ledge grab checker and gravity control to snap and climb, with Mixamo hanging idle animation and prefabs for accuracy.

Trigger a ledge grab at the right jump moment by snapping the player to a ledge checker on a lip-edged platform set as a trigger, raising arms.

Learn to trigger a ledge grab by detecting the ledge, triggering the animation, and freezing gravity so the player pauses mid-air with hands up.

Build a ledge check system that detects collisions with a rigid body, freezes the player via the character controller, and triggers a ledge grab and hanging idle animation.

Snap hands to the proper position by creating a private Vector3 hand pose, serialize it for the inspector, and pass it to the player to update the ledge grab position.

Trigger the climb up animation with the e key, address root motion vs non-root motion, and snap the player to pose after climb via on state exit to idle.

Implement a climb up animation triggered by the E key on a ledge, snapping the player to the stand pose and resetting grab ledge to enable idle after climbing.

Develop a ledge grab system using control animation rather than root motion, with a character controller, a ledge checker trigger, and snap-to-ledge animation, while masking with smoke and mirrors.

Create and manage a platform prefab, ensure consistent spacing, and update hand and stand poses using a target game object for a modular 2.5 d ledge system.

Explore how interactables drive immersive gameplay across input-based, environment, combat, puzzle, dialogue, multiplayer, and metagame contexts, shaping player actions, strategies, and story outcomes.

Create a simple collectible in Unity using a generalized C# interactable script. Implement OnTriggerEnter to modify a player stat, destroy the item, and plan for a future refactor if needed.

Learn to create a simple collectible in Unity using OnTriggerEnter and tag comparison. The item destroys on player collision with a trigger and logs a health action.

Block out the interaction system using trigger stay to show a world space UI when near an item, wait for a button press, and hide the UI on exit.

Demonstrates showing and hiding UI for an interactable item via trigger stay and trigger exit, a UI container, a player tag check, and an E key interaction.

Rotate the UI to face the camera by adding a UI lookat script to UI container, using late update to align orientation on the y axis and avoid race conditions.

Use transform.LookAt to make the UI face the main camera, caching the camera reference and applying the script to the UI transform to correct orientation.

Learn to render a world space UI with camera stacking, configuring an overlay camera atop a base camera, and applying culling masks and event camera settings for reliable interactions.

Perform a code review to simplify UI setup with a prefab container and reduce on-trigger calls; convert to a collectible class and show UI only once on player entry.

Refactor the interactable system by adding a collectible class, refining show UI logic to trigger once on player contact, add health, and destroy the item.

Create interactions in Unity using an IInteractable interface to define a common interact method, then implement specific behaviors for pickup items, doors, and lights triggered by the E key.

Review how to create interactions using interfaces in Unity by adding an interactable component, a UI transform, and a trigger collider, then test the E key prompt.

Improve door interaction by moving the E key input from the fixed time step to the update method and using a private is_interactable flag set via trigger enter and exit.

Create a light interactable as a prefab, add a sphere collider trigger, an interactable script, and UI container, manage overrides, and use a script to detect the main camera.

Removes the serialized field and uses a private main camera reference via camera.main in start to auto assign the ui transform. Also demonstrates inspector overrides for designer-driven setups.

Learn to toggle a light in Unity using an emissive material. Create a script to access the mesh renderer's material instance, set the start state, and respond to interaction.

Learn to build a toggleable light in Unity by scripting an emissive material, using a mesh renderer's materials, and exposing a serializable is on toggle via an interactable interface.

Extend door behavior with lock and unlock mechanics triggered by inventory items or a console, integrated into the interact system to provide feedback and open when unlocked.

Learn to implement door locking and unlocking in Unity by using an isLocked flag, updating interaction logic, and providing feedback via logs, while exposing a public serialized field for designers.

Finish the terminal system by exposing targets and a public interact method using try get component for IInteractable. Test powered state, UI prefab setup, and door interactions.

Extend the interactable interface to trigger a separate activation on a target object when the player interacts. Implement activate methods across all interactables to handle preemptive checks and unlocking flows.

Create a door control panel system that uses locked and open models to reflect locked state, updates doors via prefab, and lets designers check locked state while the terminal unlocks.

Build a physics-based pressure pad using a spring or configurable joint in Unity, with a base and pad that depresses under heavy objects and resets via a trigger.

Set up a physics based pressure plate in Unity using a spring joint between a movable pad and a kinematic base; lock axes to move only along y.

Plan and script a pressure pad in Unity to unlock a target when pressed, using on trigger enter to activate and on trigger exit to deactivate via a bool.

Implement pressure pad logic in Unity by wiring an array of targets and using on trigger enter and on trigger exit to unlock and lock targets.

Finish implementing pressure pad functionality by activating the target's iinteractable when objects enter or exit the pad, passing a bool isActivated to unlock the door and update the control panel.

Learn to implement a chest interactable: set up the components, create a chest script with open state and animator, and activate to open, with optional key checks.

Create a chest interactable in Unity with isOpen and isLocked flags, an animator, and IInteractable interface to toggle open/close via the E key.

Learn to spawn loot from a chest with a spawn loot script, a range of items, a spawn point, and a coroutine that spawns items one after another.

Learn to spawn loot from a chest by defining a loot list, a min-max spawn range, and a spawn point, with update logic and debug logging to test loot creation.

Explore implementing loot drop by applying a randomized impulse to loot items using a Rigidbody, with a configurable spawn strength and spin, and ensuring proper components on the loot prefab.

Create a singleton-style inventory manager with a public static instance and awake setup, define an all items enum with keycards A through D, and implement add and remove methods.

Create a loot item script wired to the inventory manager to add the item on interaction, then destroy the loot object; replace the cube with the key card model.

Demonstrate a loot item system by wiring an inventory manager, adding items on interact, and testing the activate method with a bool is activated to unlock a door.

Build item spawning in Unity by adding an inventory manager, spawning key cards from chests with randomized contents, and collecting them with the E interaction to unlock doors.

Implement a key card unlock system that checks for a required item and unlocks via activate when present, while distinguishing interactive doors from non-interactive props and handling broken states.

Configure a keycard-based door with a requires item flag and inventory manager reference. Unlock the door when the correct item is present and interact with E to spawn the keycard.

break down the puzzle by having the player pick up and drop the power core, which gains power from chargers and activates the elevator when placed on the correct receiver.

Develop a power core script to make the core physically based with a rigid body, enabling pick up and drop, gravity off when held, and parented to the player.

Match the power core's position and rotation to the power base via the collision object's transform, test in Unity, and apply overrides to snap the core into place.

Block out power charger capabilities by inheriting from the power base and applying a scriptable object power level to the power core in Unity via collision detection.

Inherit the power base to enable docking and undocking for the power charger, override on collision enter, and apply a power level scriptable object to the power core.

Implement a scriptable object based power level system in Unity, create assets and menus, configure large, medium, and small charges, and test charge transfer across chargers.

Learn to create a power receiver in Unity by inheriting from the power base, inputting a required power level, and powering an elevator via the power core.

change power core color to reflect its power level with a ratio-based emission: magenta, blue, CN, and green map to levels; red signals danger, sufficient, insufficient, or too much power.

Create and implement the base elevator functionality in Unity: enable multi-level movement, control speed, and activate via the receiver; develop an interactable elevator that moves up, then cycles down.

Build a base elevator in Unity by implementing IInteractable, handling interact and activate, and moving between elevator levels with a speed and power state driven by next level index.

Set up the elevator in Unity by configuring a trigger sphere collider, an interactable with a ui panel, and level objects to define stops and enable e key movement.

Attach a change-parent script to the elevator, parent the player on enter, detach on exit, and adjust the follow camera damping to reduce jitter.

Learn to stabilize the camera inside an elevator by switching Cinemachine damping to zero and lowering the camera distance when parented to the elevator, then revert on exit.

Extend the starter inputs with the new input system to support interact actions and UI navigation, binding E and gamepad West for elevator interactions and updating the input script.

Extend the starter assets inputs by creating an interact input extension that triggers interact on button press and resets to false, enabling keyboard and controller use.

Create a UI action map to navigate menus with a 2D vector using keyboard (WASD, arrows) and gamepad left stick, add submit and cancel actions, and wire them into scripts.

Configure a ui action map for keyboard and gamepad, adding submit and cancel actions with bindings, then save the asset and test exclusive keyboard and gamepad controls.

Hook up the action map to the player and event system with Unity's new input system, configuring the player input component and starter assets input actions for UI navigation.

Show how to implement a Unity elevator UI by wiring onClick buttons to pass floor indices, display the UI, and swap between UI and player action maps.

Implement swapping between player and UI action maps, toggle the elevator UI, and handle floor selection via choose floor with the UI button onclick, returning control to the player afterward.

Finalize the elevator system by gating ui interactions with power state to prevent midflight level changes, and update the power receiver to reset targets on collision exit.

Learn to call an elevator from a terminal in Unity C# by passing the terminal floor to the elevator's choose floor, ensuring the power receiver powers terminal and elevator.

Power up the terminal and use it to call the elevator in Unity by setting the terminal floor index, checking power status, and interacting with the elevator via terminal input.

Play through the level to test pickups, doors, terminals, and the elevator, using scriptable objects for health and power core values and emphasizing context sensitive, decoupled interfaces.

Learn to build interactive Unity UI with the canvas system, using buttons, sliders, health bars, main menus, a mini map, and sprite swaps, while syncing UI with gameplay.

Import a sprite sheet into Unity and convert it into multiple sprites with the 2D Sprite package. Slice automatically, preview sprites, and set native size for correct scaling.

Create sprite sheets from art using free tools like Inkscape or a Photoshop-like program, or paid Adobe workflows with Illustrator and Photoshop, ensuring alpha transparency and Unity-ready PNG export.

Explore the three Unity UI canvases: screen space overlay, screen space camera, and world space, showing how each renders UI, interacts with objects, and leverages depth.

Explore and compare screen space and world space canvases in Unity, set canvases to main camera, align UI with scene, and experiment with 3D world placement and plane distance.

Explains Unity's canvas scaler and its UI scale modes—constant pixel size, scale with screen size, and constant physical size—and recommends scale with screen size for UI in screen space overlay.

Master the rect transform tool to position and resize UI elements, and set anchors for adaptive layouts, ensuring UI stays on screen across aspect ratios.

Learn to mask UI objects in Unity by making the image a child of a mask, adding a mask component, and using a Rect 2D mask with adjustable softness.

Explore the differences between a 2d sprite and a ui sprite in Unity, including their placement, visibility, and masking on a canvas, and how to attach and mask sprites.

Discover Text Mesh Pro and its advanced text features, including gradient fills, outlines, underlays, bevels, glow, and overflow-linked text for richer UI typography in Unity.

Create a system where a player's name hovers above them and faces the camera, while a health menu uses screen-space and world-space canvases with text on capsules and buttons.

Set up multiple canvases in Unity by combining a screen-space overlay for UI with a world-space canvas that uses a lookat constraint to face the main camera.

Build a live minimap in Unity using the UI system, tracking player and enemy positions. Update the map with local positions on the x and z axes using Vector3.

Design a simple main menu UI in Unity, ensuring text and images align and buttons stay on screen across different aspect ratios.

Design a main menu UI in Unity, featuring a top-right close button, a sprite sheet background, a centered title, and interactive buttons, with anchors and native size for responsive layouts.

Learn to add a button in Unity, adjust its size and text with the nine panel edge, and wire a Button Manager to log presses.

Wire ui buttons in unity to a script that plays a piano audio clip via an audio source, creating a virtual piano with five keys at unique pitches.

Create multiple UI buttons in Unity and assign normal, highlighted, and selected colors. Use the event system to set first selected button for keyboard navigation with up, down, and enter.

Learn how to configure Unity UI button navigation, compare automatic versus explicit setups, and create loops to control horizontal and vertical movement using keyboard inputs for precise navigation.

Learn to swap button sprites in Unity using a sprite sheet to create attractive buttons, set native size, hide text, and swap to a selected sprite for a polished interface.

Create one button prefab with an animation controller that defines normal, highlighted, pressed, selected, and disabled states, with scale changes, then duplicate it for other buttons and adjust positions.

Animate the active button for non-mouse navigation and switch between two menus using up, down, and enter, starting with the first selection at the top.

Design a Unity menu manager that toggles two menus without a mouse, binds serialized menus, enables first-selected button, and handles button press to swap screens.

Install a bullet sphere at the turret's instantiation point with a rigidbody prefab, instantiate and apply relative force on space, and rotate the turret with the A button.

Learn to build a Unity cannon by instantiating a bullet prefab at the turret's instantiation point, applying rigidbody physics, and wiring UI buttons to fire and rotate the gun.

Learn to implement a toggle button in Unity, serialize a field for a Toggle, and use sprite swaps to show on/off states in play mode.

Explore how to create a toggle group in Unity UI with exclusive toggles (easy, medium, hard), assign them to a shared group, and manage their states via a button manager.

Slice a sprite sheet into four sprites and create toggle-driven playtime rules for a friendly dinosaur park. Swap the sprite and text with each toggle to update the rules.

Create a playtime rules area with three toggles linked to a single toggle group. Add a background image, image box, and a four-slice dinosaur sprite using the sprite editor.

Explore how to add and customize sliders in Unity's UI system, including min/max values, orientation, background and fill colors, and the interactable settings for health bar style.

Connect a UI slider to a text field in Unity by scripting a slider value to update the text in real time, using a serialized reference to UI elements.

Create a health bar in Unity that changes health by 20-point increments, locks input, updates health text, and fixes slider buffer by zeroing the fill area so it reaches max.

Create a Unity health bar using a UI slider and health text, updated by Player Health script, with A and D keys adjust by 20 and clamp 0 to 100.

Learn to build a Unity loading screen that uses a coroutine for an async scene load, updating a slider and text as the next scene appears.

Create a loading screen in Unity by wiring a slider and text to an asynchronous level load, controlled by a level manager and coroutine, showing progress for the next scene.

Learn to add and configure vertical and horizontal scroll bars in Unity UI using a scroll rect, mask or rect mask 2D, and content viewport to create a scrollable area.

Create a horizontal slideshow image gallery using image groups with no text, apply the sprite sheet to change the bar’s appearance, and prevent scrolling past the designated area.

Learn to assemble a Unity slideshow with a background, four images, a horizontal layout group, a scroll rect and mask, and a customizable scroll bar to navigate left and right.

Demonstrate setting up Unity UI input fields and text output, wiring on value change and end edit to display typed input and a final you entered message.

Learn to add and configure input fields in Unity, including placeholders, text, and character limits, plus content types like email, password, and pin, with validation and value changed events.

build a pin verification system in unity by creating create pin and enter pin fields, enforcing four digits, parsing inputs, and validating the pin with debug messages.

Set up a Unity scene for a math game by creating ui elements: two number fields, plus and equal signs, an input field, debug text, and a next button.

Create a Unity C# math game that generates two random numbers, displays them in UI text fields, parses user input, checks the answer, and advances to new questions.

Learn to build a simple username and password login in Unity, with input fields, create account and login flows, string comparison, and variable storage for a single user.

Create a login and create account UI in Unity with username and password fields, a create and login button, and a cancel option. Add red debug text to surface errors.

Create and attach a login script in Unity, manage multiple input fields with serialized arrays, toggle login and create account panels, and implement basic username/password validation with debug feedback.

Explore how to add and customize drop down menus in Unity UI, adjust colors, item backgrounds, captions, labels, and images, and manage options A, B, C with a scrollbar.

Build a difficulty level system from a drop-down menu with easy, medium, and hard options and display the selected difficulty when starting play.

Build a multi-digit pin pad in Unity that collects a digit sequence into a password and submits it for verification, using a two-part setup for environment and logic.

Set up a multi-digit pin pad in Unity using a button manager, UI buttons, a text display, and a pin number script; connect serialized button values to the pin logic.

Create a multi-digit pin pad in Unity, using a private secret pin and entered pin string, updating the UI with digits and validating on submit, displaying pin accepted or invalid.

Explore how to build an in-game pause menu in Unity that adjusts volume and brightness using the UI system.

Create a Unity settings menu with a background image, music and brightness sliders, and a cancel button, plus a pause system using time scale and audio mixer.

Learn to implement a pause system in Unity by toggling the settings menu, controlling time with Time.timeScale, and using the escape key to pause and resume gameplay.

Create a looping music source, route it through an audio mixer with a background music group, and adjust volume in real time via a UI slider and exposed parameters.

Learn to adjust brightness in Unity using post-processing gamma, lift, or gain parameters, or a black overlay controlled by a brightness slider on a canvas.

Explore horizontal, vertical, and grid layout groups in Unity, adjusting padding, spacing, and child sizes; compare how grid fixes image sizes versus flexible horizontal and vertical layouts.

Build a randomized 15x15 grid UI tile game in Unity, with two lightning bolt tiles (+1) and one bomb (-1); reveal on click, track score, restart with a new order.

Learn to build a 3x5 UI grid in Unity using a grid layout group, create item prefabs with background, icon, name text, and a score display.

Create interactive UI tiles by wiring buttons to a game manager, sending score updates, turning covers off on click, and spawning randomized items in a grid.

Introduce Unity's UI event system with five pointer interfaces: enter, exit, down, up, and click. Attach and implement these interfaces on a button to capture interactive events beyond simple clicks.

Learn to implement a Unity charge bar by handling pointer down and up events, wiring a slider and text field, and updating charge with delta time and an animator-driven blink.

Drag items in Unity using the draggable system. Wire on initialize potential drag, begin drag, drag, and drop handlers to update position via event data and adjust image alpha.

Learn to build a snap-to-slot drag and drop inventory in Unity by creating drop zones, disabling raycasts during drag, and snapping items to slots based on pointer position.

Learn to build a draggable item system in Unity using C#. Implement drag and drop mechanics, raycast handling, and drop validation to snap items back to their original positions.

Master a drag-and-drop puzzle by building a drop zone with three items that snap back when incorrect and let the bomb snap into place using drag data and pointer drag.

Import the dummy assets for the tile map overview by downloading the dummy sprites, unzipping, and dragging them into Unity to follow along.

Create a tile map grid, paint on the ground layer, set up ground items palette, slice the ground sprite into 128 by 128 tiles, and use 128 pixels per unit.

Paint game environments with tile maps using the paintbrush to create walkable ground. Use box filler, fill, and erase tools to shape craters, edges, and spikes, and to plan layers.

Create a cavern tile palette in Unity, slice cavern sprites into 128 by 128 tiles, convert to tile assets, and paint using caverns in the tile map.

Slice up the vegetation assets and create a new vegetation pallet to extend the pallet organization from ground items and the cavern pallet. See you in the challenge review.

Create a vegetation palette, set sprite mode to multiple, slice at 256 by 256, convert sprites to tile assets, save under vegetation tiles, and begin painting vegetation.

Create a midground tile map layer to paint caverns behind the ground. Use the focus to paint only the active midground layer.

Create far ground caverns by adding a new tile map layer, order the layers for depth (foreground, midground, background), and paint cavern tiles to build depth and enable parallax.

Create a vegetation tile map layer, paint grass with the paint tool, and place rocks, barrels, and spikes as foreground items to build a walkable level.

Create animated waterfall tiles by slicing 256 by 256 sprites, building animated tiles for left, center, and right, assembling a waterfall palette, and painting them on a tile map.

Paint waterfalls in a 2D level by editing the foreground and ground tile maps, adjust transparency to reveal spikes, and layer midground for depth and water effects.

Create a diamond prefab brush to paint collectibles across your map, turning the diamond prefab into a paintable tile and organizing with a dedicated diamond tile map.

Add colliders to a tilemap using tile map collider 2D and composite collider 2D. Configure a static rigidbody 2D and enable used by composite to map surface colliders.

Master Unity's 2D tile map features, from painting levels and creating palettes to organizing tiles in layers, with scriptable assets like animated tiles and the prefab brush.

Review the imported assets in a finished Unity scene—cavern level, shopkeeper, platforms, water slide, and door—while implementing parallax, perspective mode, and Android mobile setup on a Galaxy S5.

Set up Android development by installing the Java Development Kit 8, switching Unity to Android in build settings, and configuring a 16:9 fixed aspect ratio for mobile and PC compatibility.

Switch the main camera to perspective to zoom in, then create parallax by moving it so foreground, midground, and background shift, with grid depths set to 0, 1, and 3.

Set up the player by slicing sprites into frames with the sprite editor set to automatic multi-frame slicing, and prepare idle and death animations by placing individual sprite tiles.

Set up a 2d physics based character controller using rigidbody 2d velocity, reading left and right input to adjust horizontal velocity, and add a collider to keep the player grounded.

Learn to implement 2D player movement by accessing the Rigidbody2D, reading horizontal input, updating velocity with Vector2, freezing z rotation, and using Input.GetAxisRaw for responsive control.

Implement jumping by listening for the space key, using ground detection with 2D raycasting, and applying a jump force to the character's velocity.

Learn two Unity jump implementations using a jump force and a grounded flag driven by a 2D raycast, with inspector modifiers and layer masks to detect ground robustly.

Learn how to fix a frame-level grounded state in Unity by using a cooldown coroutine to reset jump detection after 0.1 seconds, preventing rapid re-jumps and keeping grounded stability.

Adopt a modular, clean jump system by isolating movement and grounded checks into dedicated methods, using a return type isGrounded function with raycasting and rigidbody velocity.

Create a private speed variable exposed to the inspector, set it to 3 to 5 m/s (up from about one meter per second), and apply it to the player's velocity.

Configure player speed in Unity C# using a serialized private speed variable, default 5, and apply it to the rigidbody velocity for real-time inspector tuning.

Create an idle animation for the player by building a clip from zero through 33 frames in sprites/characters/animations and set it to loop in the animator controller.

Separate player animation logic into an animation script that uses a move parameter from horizontal input to transition between idle and run via the animator.

Script the player to transition between idle and run using the animator move parameter and absolute value. Remove exit time and set transition duration to zero for instant, responsive movement.

Flip the sprite by setting the sprite renderer's flipX based on input.getAxisHorizontal; true when moving left, false when moving right, while idle animation remains unaffected.

Learn to flip a sprite with the sprite renderer by setting flip X based on move, retrieve the component, and organize logic into a flip method.

Set up the jump animation in Unity by slicing sprites to 256 by 256, creating a jump clip, and wiring an idle-to-jump transition driven by a jumping parameter.

Trigger the jump animation by signaling the animator on space key press when grounded. Set the jump parameter to true to start, then reset it to false when grounded.

Learn to implement a jump animation by wiring the player script to the animator, using a jumping bool and grounded checks, adjusting transitions, and debugging with raycasts.

Create run/jump transitions in Unity: idle to jump when speed is near zero, and jumping to running when not jumping and moving; set exit time off and duration zero.

Fix a Unity jump animation by trimming frames to 6, 8–10, 12–15 and holding the final pose for two seconds for a smoother jump.

fix the player sprite by centering the raycast and adjusting the sprite's x and y positions (approx 0.09 and 0.18) to keep the character grounded and jumping.

Set up swing attack animation by creating an attack clip, slicing sprites to 256 by 256, dragging frames 0-34, and triggering attack from idle back to idle with no fade.

Implement attack behavior by triggering the attack animation when the player left-clicks and is grounded. Call the attack method in update after movement, using the existing animator and player animation.

Create an attack method that triggers the animator’s attack parameter and returns to idle after exit time, activated by left-click when grounded.

Create transitions from run to attack and back to run in the Unity animator to enable running while attacking and keep the animator organized.

Open the sprite editor to slice the sword particle sprite into 512x512 frames, build an animation clip and controller, and adjust rotation for a smooth sword arc swing.

Set the sword arc to not loop, create a null default state, and trigger the sword animation via a parameter to play the arc and return to none when finished.

Trim frames and use selected sprites at 25 fps to speed the attack animation, then adjust the sword arc to 1.01, -0.09, -0.25 and rotation to 66, 48, -80.

Flip the sword arc dynamically in Unity by adjusting the sprite renderer based on facing direction. Flip X and Y when turning left, reset when turning right for correct animation.

Fix the arc sprite flip in the Unity player script by using the first child’s sprite renderer, then adjust flip and local position based on facing direction.

Learn how to make the main camera follow the player using Cinemachine imported via the Unity package manager, with a virtual camera to control motion.

Create a Cinemachine virtual cam to follow your player, set the follow target, and observe the main camera driven by the Cinemachine brain.

Slice the 512 by 512 moss giant idle animation sprites, create a moss giant enemy with a sprite and animator, place it, and scale to 4x4.

Slice the moss giant's 512 by 512 sprite grid and create a walk animation. Set up an idle-to-walk transition in the animator with an idle trigger and waypoint-driven movement.

Consolidate shared data, speed, health, gems, and attack, into a base enemy class that Moss Giant, skeleton, and spider inherit, using an I damageable interface for unified damage.

Learn how abstract classes, virtual methods, and overrides let enemies share a base attack and update structure while allowing moss giant, spider, and skeleton to implement unique behaviors.

Implement moss giant movement from point A to point B with an AI that switches targets by position. Use Vector3.MoveTowards to move toward the current target at a speed.

Solve moss giant movement using a waypoint system between point a and point b, moving with Vector3.MoveTowards, speed, and delta time, then refactor to a current target for cleaner movement.

Tune moss giant behavior by preventing movement during idle animation using the return keyword, isolating move toward logic, and stopping the animation with the Unity animation system.

Prevent the moss giant from moving during idle by obtaining the animator component in children and checking the current state info on layer zero for the idle state name.

Trigger the idle animation when the moss giant reaches its target destinations, ensuring he idles for a full cycle before transitioning back to movement.

Flip the moss giant sprite at positions a and b to reflect idle and movement. Ensure the sprite renderer keeps flip X false when he moves to the right.

Implement the moss flip by obtaining the moss sprite's sprite renderer via getcomponent in children, then flip after the idle animation finishes when moving between point A and B.

Configure the spider enemy by setting idle and walk animations with 256 by 256 sprite slices, place it in the left corner as a 3 by 3 scaled, parented object.

Create idle and walk spider animations in Unity by recording sprite frames 0–30, using 20 fps for idle and 25 fps for walk, then move toward the animation behavior tree.

Set up the spider behavior tree by configuring idle to walk transitions with exit time and zero transition duration, using an idle trigger and corresponding code logic.

Set up a spider enemy to move between two waypoints using a dedicated AI script, refactoring with abstract inheritance and preparing for interfaces while keeping focus on individual implementations.

Design a spider AI that moves between two waypoints, pauses for idle, and flips the sprite, mirroring the moss giant's left-right movement while emphasizing iteration testing and incremental implementation.

Review the spider AI challenge: implement two-waypoint chasing with Vector3.MoveTowards, switch targets, trigger idle via the animator, and flip the sprite using a child sprite renderer.

Explains building shared enemy behavior in Unity by using a base enemy class, virtual init and movement methods, and derived moss giant and spider scripts to prepare for class inheritance.

Inherit from base enemy class, attach the skeleton script, slice sprites by 256x256 with pixels per unit 256, and set a skeleton enemy parent at order 50 for waypoint animations.

Set up the skeleton animation for an enemy by creating an animations folder, building idle and walk clips from sprites, and configuring zero duration transitions with an idle trigger.

Students implement skeleton AI by extending the base enemy class in Unity, defining init, setting speed and waypoints, and leveraging a modular inheritance system to rapidly create new enemies.

Set up a sword hitbox collider attached to the player, animate it across the attack frames, and test collision detection in Unity 2D.

Set up the player attack by turning the hitbox into a trigger with a 2D rigidbody, and detect hits via OnTriggerEnter2D while the collider is active only during the swing.

Set up a sword hitbox on its own physics layer and create a separate player layer, then configure Unity 2D to prevent sword–player collisions.

Slice a 256 by 256 hit sprite, create a non looping 20 fps hit animation, and set an any-state transition with a 'hit' trigger to drive damage and death animation.

Define an I damageable interface with a health property and a damage method to create a reusable damage system, then implement it on enemies in Unity.

Implement a damage system by detecting hits with an interface Damageable, having the sword call hit.damage on any object hit, enabling scalable enemies and future expansion.

Implement skeleton damage logic by syncing health with inspector values, subtracting one on each hit, and destroying the skeleton when health falls below one, while noting hit-detection issues.

Limit damage calls to one per swing by using a can damage flag and a 0.5-second cooldown reset via a coroutine, with options state machine behaviors and animation events.

Implement a 0.5 second damage cooldown in Unity using a canDamage flag and a reset damage coroutine, ensuring only one hit registers per attack.

Add a hit animation to the skeleton by creating a hit clip from sliced sprites, trigger it with the animator on damage, and transition to idle while stopping movement.

Add an isHit flag to the enemy and pause movement during hit animation. Set isHit on damage and only call movement when isHit is false, freezing the enemy in combat.

Implement skeleton combat state by adding an in combat boolean to the animator, switch to idle on hit, and fall back to walking when not in range.

Implement a distance check between the player and the skeleton after an attack. If the distance exceeds two units, reset is_hit and is_in_combat to resume walking and reenable movement.

Solve the resume skeleton challenge by obtaining a player reference via tag, computing distance between enemy and player using local positions, and controlling combat state with animator parameters.

Set up the skeleton enemy attack animation by slicing sprites, creating an attack clip, integrating it into the behavior tree with combat mode, and testing transitions and hitboxes.

Learn to make a skeleton enemy face the player by using a direction vector from enemy to player, determine direction.x (positive means right, negative left), and flip the enemy accordingly.

Implement skeleton sprite flipping in combat by checking direction dot x and the in combat state, flipping the sprite left or right, and triggering attack.

Create a skeleton hitbox by adding a box collider 2D and rigid body 2D with gravity off, then align the hitbox to animation frame and set as trigger for detection.

Enable enemy hitbox on the frame of the animation, with the 2D box collider disabled at start, and configure the 2D collision matrix to ignore enemy and enemy attack layers.

Set up a skeleton attack script using the AI damageable contract to apply damage to the player. Have the player implement health and a damage method with damage call logs.

Develop the moss giant attack animation and implement a modular attack system by preparing assets, slicing sprites, and creating an attack clip to be merged into the enemy class.

Add the moss giant attack animation to the animator controller, create an in combat boolean parameter, and configure transitions from idle to attack and back based on in combat.

Implement a moss giant attack system by adding a box collider 2D as a trigger, implementing the IDamageable interface with health, damage, and a hit animation for combat.

Merge shared enemy logic into a modular base class, apply unified distance-based movement and flipping for skeleton and moss giant, and customize damage using a separate I damageable contract.

Create a moss giant hitbox with a 2D sprite and trigger box collider; animate it through attack frames, attach an attack script, set layers to ignore collisions, and save scene.

Set up a spider enemy with idle-to-attack behavior, create a dedicated attack animation and acid effect, override movement, and trigger acid projectiles via animation events and prefabs.

Create an animation event to trigger the spider's fire action at a specific frame, using a delegator script on the animator's object to call a public fire method.

Learn to implement a spider attack that fires an acid asset with an effect script, moving left at three m/s, destroying after five seconds, and damages the player via IDamageable.

Set up death animations by adding a death trigger in the animator, route any-state transitions to death with zero duration, and trigger it from code for enemies and the player.

Create a loot system by implementing a diamond behavior that lets players collect diamonds dropped by enemies and add their value to the player's gems for shop purchases.

Animate the diamond with a 0–29 frame animation, add a circle collider as a trigger, make a rigidbody with gravity scale zero, and increment the player's diamonds by gems.

Implement a loot system where enemies drop diamonds on death, spawning diamonds at their position with values assigned from the enemy's gem count, enabling varied gem drops.

Implement an anti-dupe safeguard in a Unity C# loot system by adding a dead check to all damage methods, preventing coin drops after death and setting up the shop system.

Set up the shop system by placing the shopkeeper's user interface in the scene and positioning it beside the map. Test triggering the shop's user interface menu to buy items.

Learn to build a shop UI in Unity C# bootcamp part 2, with a merchant, item list (flame sword, boots of flight, key to the castle), and a gem counter.

Enable the shop panel when the player collides with the shop keeper, allow object selection, and highlight the chosen item with a selection tool, building basic shop interaction.

Enable the shop by adding a box collider 2D as a trigger with a rigidbody 2D, then use a OnTriggerEnter2D script to activate the shop panel when the player enters.

Implement a UI manager singleton to update the shop UI and the player's gem count while trigger enter and exit show or hide the shop panel.

Learn to implement a shop selection in Unity by adding a selection image, wiring onClick events to a shop script, and updating the UI manager to highlight the chosen item.

Select an item from the shop by passing item id to the selection script; map 0,1,2 to flame sword, boots of flight, and key to castle, then update the interface.

Learn to implement a shop transaction by tracking the current item, checking gems against item cost, awarding the item and subtracting gems, or closing the shop when unaffordable.

Build a shop system in Unity to buy items, track the current selection and item costs, verify player gems, deduct currency, and close the shop.

Create a game manager singleton to track the win condition, including a has key to castle flag updated when purchasing the key in the shop with diamonds.

Paint diamonds as collectible gems across a 2d tile map using a diamond brush prefab, then collect them and unlock shop items by watching a Unity ad that rewards gems.

Design a unity hud featuring a life bar, joystick, and a/b buttons, with gem count, life units, and a custom font for a polished ui.

Collect gems and update the gem count in the UI by wiring the UI manager to the player's gem gains, and refresh shop text accordingly.

Begin Android development testing by building an APK in Unity, ensuring Android platform and SDK and JDK setup, then test on a Galaxy S5 with joystick and A/B controls.

Set up mobile touch controls using Unity's cross platform input, importing the standard assets and configuring a mobile joystick and A and B buttons for on-screen input.

Hook up cross platform input to drive the player with a mobile joystick. Map on-screen A and B buttons for attack and jump, and test on Android.

Learn to test a Unity game in the editor while preserving mobile build support by using the cross-platform input manager, enabling space to jump and A/B for actions.

Learn to integrate Unity Ads, create a shop button that offers 100 gems after a successful video ad, and disable the old buy button while setting up the shop.

Create a Unity ads manager to display a rewarded video ad, check readiness, and award 100 gems when the ad finishes, via a show options callback linked to shop button.

Implement a reward flow that grants 100 gems after watching a video ad by wiring button to callback, obtaining a player reference, and updating the user interface and shop.

Refactor reward flow by moving gem awarding to the game manager, grant 100 gems after a rewarded ad, and synchronize the character profile and shop UI via the UI manager.

Disable test mode, build and install the APK to run Unity ads on your device, then track impressions and gems in the dashboard.

Create a main menu scene, configure a canvas that scales with screen size, add a background and title, then place a joystick symbol and start, menu, and quick buttons.

Build a Unity main menu by scripting start and quit buttons, using the scene management namespace to load the game scene and to quit the application.

Create and wire the main menu in Unity by loading the game scene via SceneManager and quitting with Application.Quit, using onClick events on the canvas.

Test the menu by adding the main menu to build settings, setting the scene order, and building or running the APK to deploy on a device, ensuring a smooth start.

Register a Google Play developer account by signing into the Play Console and paying the 25 dollar fee; then set up apk and keystore in Unity before submitting your app.

Publish your game to Google Play by uploading a signed APK, configuring the store listing with description, graphics, and screenshots, and rolling out the production release while monitoring performance.

Create a 3D Unity project for a third-person survival shooter using Unity Hub and the latest version, naming it accordingly, then upgrade to the lightweight render pipeline for certification assets.

Learn to set up a Unity scene with a floor and capsule player, use fps navigation on the xy plane, prototype with a character controller, and adjust lighting for mood.

Design and implement a third-person character controller in Unity, handling movement with the input system, calculating direction and velocity, applying gravity, and grounding checks.

Build a Unity character controller from scratch using the character controller API for collision-constrained movement, grounded checks, velocity, gravity, and jump height, then refactor to private serialized fields.

Create a third-person camera system in Unity that follows the player and uses mouse input to look left-right and up-down, with a clamp from 0 to 15 degrees, over-the-shoulder.

Implement a player and camera look system by mapping mouse x to yaw on the player and mouse y to pitch on the camera, with vertical rotation clamped.

Transform local space to world space to move in the direction your character is facing, using transform.direction to convert the camera's local forward into world space and apply velocity.

Add a mouse sensitivity option in the inspector to adjust camera rotation by multiplying rotation with a sensitivity value, and refactor the logic into a modular camera controller method.

Tune camera sensitivity in Unity by exposing a serialized camera sensitivity field and applying it to mouse input; organize the inspector with headers for controller and camera settings.

Lock and hide mouse cursor at game start in a third-person shooter, and unlock with escape key to reveal the cursor; implement this in the player script using Unity C#.

Hide and lock the cursor in Unity, center it with cursor.lockState and lock mode, then press escape to unlock and reveal it.

Create a center crosshair by using a UI image as the reticule, centered on screen for shooting. Import a Firebase reticule package and set it to 64 by 64.

Practice clamping the main camera's vertical rotation between 13 and 26 degrees to prevent self-shooting, using Unity's clamp concept while keeping the crosshair aligned near the head.

Learn to implement raycast shooting in Unity by casting a ray from screen center through the reticule to hit targets and print the hit object's name with a shoot script.

Clean up and modularize the code by creating a shoot method, moving code into it, and preparing for future features like destructibles, interfaces, and enemies.

build and deploy enemy AI that targets the player and pursues it with a character controller, calculating direction, velocity, gravity, and normalizing the direction vector for steady movement.

Build enemy AI by linking the character controller, computing the direction to the player, and applying velocity, gravity, and look rotation so the enemy chases and faces the player.

Review the universal health damage system by implementing a public damage method that subtracts a damage amount from current health, checks min health, and destroys the game object when dead.

Develop a functional weapon system by casting a center-screen ray, obtaining the health component with a null check, and calling damage to reduce current health until the enemy dies.

Develop a simple enemy attack system in Unity using a sphere collider to detect the player, apply damage, and pause movement while attacking with trigger events and coroutines.

Switch from if statements to a state machine pattern with a null health check. Encapsulate attack in a method and use calculate movement for chase.

Debug and fix a jumping bug in a Unity first-person controller by isolating the camera, comparing with a working FPS controller, and iterating movement and camera code.

Collaborate with a community member to fix a broken character controller by moving the local-to-world space conversion before jumping, ensuring consistent up and forward directions for reliable jumps.

Instantiate a blood splatter prefab at the raycast hit position and rotate it to the surface normal while applying 50 damage.

Demonstrate instantiating a blood splat at the hit point and orient it using the hit normal with quaternion look rotation to map splats to the target surface.

Learn to tell Unity to ignore a specific collision by raycast, separating colliders on the same game object, and ignoring the sphere collider for the attack radius.

Isolate the enemy attack radius into an object and attach an attack trigger script wired to enemy AI. Utilize raycasting with layer masks to ignore trigger while preserving attack behavior.

Increase the attack radius and collider to display blood splats correctly, and implement a cleanup system to remove particle effects after they play.

Clean up blood effects using object pooling for optimization, or delete each blood splat after 1.5 seconds with a simple blood splat script that destroys its game object.

Explore character creation by setting up a first-person controller, importing a rigged man oh eight from Filebase, and implementing basic animations and a gun.

Configure the man as a humanoid rig with unity's animation rigging, move assets to the humanoid root, and copy the first-person controller for proper animation.

Use Mixamo to rig characters and import a pistol idle animation, convert to humanoid, loop it, and adjust root transform so the character faces forward in a first person game.

Load a Glock from 3D props, attach the gun to the player in the first-person view, and tune its position, clipping plane, and disable head bob in the controller.

Learn how to weight a character per vertex and drive dynamic IK with animation rigging in Unity, then install the animation rigging package and explore constraint samples.

Master unity animation rigging by setting up a rig builder at the animator root, creating an ik rig for arms and hands, and using pole vectors to guide elbow bending.

Create two empty hand-position anchors, then use a lerp-based smooth damp script to drive each hand toward its target, so hands follow the gun with IK while staying independent.

In play mode, enable update when off screen on the right arm to prevent hand clipping and improve the IK rig alignment, then adjust the hands to fit the character.

Position the right and left hands to fit the weapon, copy and paste component values, and align hand movement with the gun to drive aiming in first-person view.

Learn to sync hand and gun positions by making the gun inherit the gun position and rotation from the main camera, then apply a smooth damp script for delay-free movement.

Create and integrate a reload animation in Unity, attach it to the gun, and configure a trigger in the animator to play from idle to reload when triggered.

In Unity, grab the gun’s initial rotation and position, record the reload animation to two seconds, and use animation rigging to have the hands follow as the clip ejects.

Learn to animate gun reload by ejecting and dropping the clip, adjust hand position, align transforms, and keyframe the clip's ejection and reloading sequence.

Enhance the Unity reload animation by adjusting hand positions, adding gun recoil, and syncing the slide and clip ejection for a more organic, believable reload.

Wire the reload action to the R key in a Unity C# pistol script by triggering the reload animation via the animator, ensuring script and class names match.

Identify performance bottlenecks in a Unity tower defense game using the Unity profiler to spot issues. Learn practical optimization techniques, reduce memory allocation, and master big-O notation.

Open the Unity profiler from window analysis and dock it below the game view. Enable deep profiler, then read CPU usage, rendering, memory, and audio; switch timeline to hierarchy.

Use the Unity profiler to diagnose performance spikes, separate editor and player loop impact, and monitor garbage collection allocation, render pipeline behavior, and on trigger stay events.

Use the Unity profiler to pinpoint a 42kB garbage collection spike caused by debug logs in AI behavior on enable during spawn enemy coroutine, and replace prints with lighter logging.

Leverage the profiler to pinpoint allocations in the player loop, fix fixed update hotspots, resolve UI manager null references, and optimize coroutines by caching wait for seconds.

Optimize Unity coroutines by caching waitforseconds to reduce garbage allocation, using private waitforseconds variables for death delay and death routine offset, and yield return cached delays for better performance.

Learn how to build a standalone development profile in Unity, connect the profiler automatically, and analyze CPU usage, GC allocations, and render pipeline behavior to optimize performance.

Use the Unity profiler to identify frame spikes and drops below 60 fps, and reduce garbage collection by caching WaitForSeconds in coroutines.

Use the profiler to monitor frame rate, garbage collection, and coroutine allocations while iterating gameplay. Note UI spikes and the recommended separation of active and static UI for future optimizations.

explains how the new keyword affects value types versus reference types in Unity, showing Vector3 and Color as structs that avoid garbage collection, and the benefit of reusing them.

Use the Unity profiler to pinpoint performance issues by wrapping code blocks with profile begin sample and end sample and labeling them, such as creating game object, to isolate allocations.

The lecture demonstrates caching WaitForSeconds to reduce allocations in coroutines, comparing slow versus fast routines and showing how cached wait times cut byte allocations in Unity's coroutine delays.

Use raycast non alloc methods and cache the main camera to reduce allocations. Prefer lists over arrays and structs over classes to optimize performance in ECS.

Explore Unity UI optimization by dividing canvases into active and static groups, reduce redraws, and use profiling to compare performance, while disabling canvas components and raycast targets when appropriate.

Explore big O notation across linear searches: compare O(1) best case and O(n) worst case in arrays, using for each loops, and preview binary search as the next topic.

Explore how binary search on a sorted list delivers O(log n) time, contrasting it with O(n) and O(1), and see how divide and conquer speeds up lookups.

Master binary search on sorted arrays by comparing the target to the middle element. Halve the search space and learn its logarithmic time behavior.

Explore the differences between linear and binary search by analyzing O(n) vs O(log n) performance on arrays, and determine when to favor binary search for larger data sets.

Explore merge sort through divide and conquer, splitting and merging arrays to achieve O(n log n). Compare it with bubble sort’s O(n^2) and recall the five big O notations.

explore a merge sort implementation in C#, covering divide and conquer, recursion, and merging left and right sublists; compare to bubble sort with big O notation and memory considerations.

Explore how merge is invoked multiple times during divide-and-conquer sorting in Unity, as incremental merges build the final list based on data size.