Game Development: Basic Games with C# and Unity 3D

Explore component oriented programming in Unity by composing game objects with multiple components, using add component, drag-and-drop, and inspector to instantiate and initialize objects via start and update.

Learn how Unity uses MonoBehaviour to drive script execution, attach components to game objects with add component, and manage events like enable, disable, and start.

Learn how awake runs first, on enable occurs when enabled, and start runs after, guiding script initialization and the lifecycle of game objects in Unity.

Learn how Update, FixedUpdate, and LateUpdate drive every frame and physics in Unity, with practical guidance on when to use each to ensure smooth gameplay.

Explore basic Unity 3D objects like sphere, capsule, and plane as placeholders to test mechanics, then import final art later.

Explore Unity lighting basics, including directional, point, spot, and area lights, and learn baked versus real-time illumination, static versus dynamic objects, and color and intensity effects.

Switch the main camera from orthographic to perspective to compare 2d sprite lighting with 3d objects, and explore area and point lights and how sprite materials differ from full materials.

Create and assign materials in Unity, adjust color and albedo, apply textures, and switch between standard and unlit shaders, while understanding shared versus instantiated materials during play mode.

Learn how the inspector exposes variables using public fields or serialize field, assign a material to a mesh renderer, and understand per-instance material changes versus editing the shared asset.

Learn how game objects and prefabs in Unity relate through parent-child hierarchies, local versus world transforms, and prefab workflows with overrides.

Celebrate nearing completion of your project and receive congratulations while being invited to leave or update your review.

Create a new scene and build a pong-like background using cubes for the ceiling, floor, and net, then apply an unlit white material and set the camera background to black.

Remove the 3D box colliders from game objects, create a taller player, and implement a simple player controller that moves with W using transform, speed, and delta time.

Set up two players in Unity, configure controls (WASD and arrows), add box colliders and rigidbodies, disable gravity, and explore collisions with walls through quick testing.

Experiment with Unity's physics by adjusting mass, applying rigidbody constraints, and observing how weight differences affect collisions and objects' movement.

Retrieve the Rigidbody component on the player object and implement physics-based movement in FixedUpdate, using a Vector3 for input and MovePosition with speed and Time.deltaTime.

Set up a white ball with a rigidbody and box collider in Unity, randomize its initial direction, and implement collision handling to invert movement when hitting walls or the player.

Create and configure bounce triggers in Unity using box colliders, differentiating collision and trigger events. Implement basic score detection and ball reset for a Pong-style game.

Build a Unity UI score panel using a canvas and panel in screen space, and update scores with text components. Understand scaling, anchoring, and aspect ratio for responsive UI.

Learn to make Unity UI responsive with scale with screen size and the anchor system, positioning elements relative to anchors, and using min and max values to stretch banners.

Implement sound effects in Unity by configuring audio clips, audio listeners, and audio sources, and trigger playback on collisions by calling play after obtaining components with GetComponent.

Create a playable Unity build by configuring build settings and exporting the scene to the target platform, optimize player settings and icons, and explore particle systems for hands-on learning.

Celebrate nearing project completion in game development with C# and Unity 3D. Invite learners to leave or update their review after watching the video.

Explore the particle system fundamentals, learning how duration, lifetime, speed, color variation, and bursts shape emission in cones or spheres, with performance tips for collisions, lighting, and gravity.

Create a new Space Invaders project, set up the camera, import and slice a sprite atlas to extract ship frames, and generate a basic animation with a clip and controller.

Learn how the animator's state machine drives transitions between animation clips and uses an entry state. Understand how exit time, triggers, and transitions control when to switch animations.

Slice and trim sprites in the Unity sprite editor to build transparent atlases for a space invaders game. Use automatic slicing and manual tweaks to create and animate enemies.

Program a player ship with axis-based movement using horizontal and vertical inputs via get axis in the Unity input manager. Map controls in a player controller script, avoiding hardcoded keys.

Learn to use get button down for shooting input, rename fire to shoot, implement three input states (down, held, up), and resize sprites globally by adjusting pixels per unit.

Install the new unity input system, create input actions, and map movement and shoot using vector composites and unity events.

Combine a box collider trigger and rigidbody, using the new player input system to map button presses to a movement vector and move the player with fixed update.

Build a Unity weapon system in C# to shoot bullets by wiring the shoot callback to instantiate bullet prefabs at the weapon, with a bullet holder organizing the hierarchy.

Learn to create and move bullets with a rigid body and trigger collider in Unity, spawn bullets from weapon using direction and speed, and destroy or limit them on contact.

This lecture introduces an I shootable interface to mark shootable objects, uses teams via an enum, and demonstrates how bullets detect friendly fire, call onShot, and self-destruct.

Adjust alien animations to a slower frame rate, create a prefab with a trigger box collider, and use prefab variants for orange, purple, and yellow aliens.

Attach the weapon as a child of the alien and use get components in children. Implement a shooting coroutine using yield wait for seconds and Random.Range to vary bullets.

Create alien bullets by duplicating the player bullet, set up a single animator with overrides for bullet alien and bullet player variants, and trigger explosions on hit.

Get the bullet's animator and set its trigger when it hits a target, then destroy the bullet after the on state exit animation ends.

Override each character's animator to swap in orange, purple, and yellow alien animations, create bullet finish triggers, and manage transitions to prevent flashing by refining exit time.

Create a dedicated player animator, implement a life-based HP system with an integer lives parameter, trigger death on zero lives, and handle bullet collisions.

Learn how to implement invincibility frames by temporarily disabling colliders on bullets and players, then re-enabling them after a delay using invoke in Unity C#.

Set up barriers around the play area to block shots in Space Invaders, and make them destructible after a set number of hits with shootable logic.

Position aliens in a grid by creating an aliens holder and a matrix controller, mapping each alien to matrix coordinates from local positions with an offset.

Learn how to implement alien shooting in Unity by setting initial shooting positions, managing matrix coordinates, and using a singleton to access the alien controller for reliable firing behavior.

Implement alien movement in Unity by configuring a movement enumerator, calculating a direction vector, applying speed with a movement delay, and using rigidbody MovePosition to move aliens in a loop.

Implement wall detection in Unity 3D to flip alien movement when contacts walls, using triggers, a direction variable and a singleton, and a movement change script that inverts direction.

Learn to move a movement change detector between alien objects in Unity, handle column-based shifts with walls, and prevent infinite loops by using Unity events and careful instantiation logic.

Fix island controller bugs by checking lives before destruction to prevent null references, preserve death animation and movement, and implement a cue-based direction queue to move aliens down at edge.

Begin with forty aliens and reduce the movement delay slightly as each dies to speed up, then use a move trigger and duplicated animations to sync movement with speed.

Limit vertical movement and lock horizontal movement to shape player controls. Implement a cooldown by tracking last shot time to regulate firing.

Create a score UI panel in Unity, anchor it to the screen corners, display white on black score and high score texts, and update them with a score system.

Add a small red ship that travels along the top in a Space Invaders style game, creating a prefab variant and adjusting its animation to two frames per second.

Refactor alien behavior in Unity by using an abstract base alien, protected virtual overrides, and sprite flipping, while the controller spawns aliens at random intervals within wall boundaries.

Create a game over UI with a singleton game over controller, pause the game with time scale, wait via Task.Delay, and reload the scene using SceneManager while DontDestroyOnLoad prevents duplicates.

Explore implementing defeat conditions and a reliable game over flow in Unity using a player controller, triggers and barriers, ensuring a single game over event even when multiple objects collide.

Implement a win condition by tracking remaining aliens; the game ends when all aliens are gone, with game over handling and UI updates.

Save and load the high score using Unity's PlayerPrefs; store the score under a high score key, compare on game over, and persist across sessions.

Create a BGM controller and master mixer in Unity to manage background music, exposing the pitch parameter for the master pitch shifter to adjust speed without distortion.

Implement and test a BGM system that ramps up tempo as aliens die, updating the BGM controller on enemy death and validating pitch changes via the audio mixer.

Implement a simple sound effects system for explosions and weapon fire, reuse weapon components across alien and player prefabs, and trigger audio via the audio service during gameplay.

Congratulate yourself on finishing your project and leave or update your review to reflect your progress in game development with C# and Unity 3D.

Learn to build a dictionary and queue-backed pooling system in Unity to reuse bullets by turning objects off and on, improving performance.

Learn saving with scriptable objects in Unity, including creating the object and wiring it to the score system. Discover that scriptable objects are not persistent across sessions.

Learn to save and load game data in Unity using json serialization and the streaming assets folder. Use serializable classes and Unity's json utility for persistent saves.

Create a Galaga-inspired arcade game with a spaceship shooting aliens by setting up folders, importing sprites, and implementing lives, high scores, stages, and varied weapons, using transparency and Unity.

Create a moving star background map that fools players into thinking the ship moves, using multiple backgrounds and a script that translates downward with delta time.

Copy and adapt Unity scripts from the Alien Invaders Project to practice scripting, input mapping, and ship movement with the new input system for space shooting.

Drag and drop scripts to build a Unity 3D shooter with a pooling system reusing bullets, and a weapon that injects direction and speed into each bullet.

Select an alien prefab, animate it, and add a rigidbody with a trigger collider. Implement bullets with an async 10-second destruction and explore a polling system for cleanup.

Fix the housing system with a task completion service and countdown, trigger explosions for alien and player, and wire animators with a death trigger to destroy objects.

Use cancellation tokens to cancel async bullet shooting when objects disable or quit, and implement a variant-based alien shooting system with a base shooting behavior.

Adjust explosion and ship animation speeds, set all physics to triggers, orient bullets to face their direction with look rotation, and implement a ship animator with death and empty states.

Build a bottom-left lives UI in Unity that scales with screen size using a panel and life images, and a singleton lives system to update lost lives and trigger animations.

Manage player lives with a dot-count system and images, replacing the public lives variable, and implement a persistent game over flow across scenes that pauses time.

Build a car system in Unity and implement serializable json save data with streaming assets, enabling high score persistence and a UI display.

Develop a flexible pickup system in Unity that grants power-ups and enables weapon changes, using sprites, box colliders, and trigger detection.

Continue the pick up system by creating a weapon pickup that inherits from an abstract base class, enabling activation and deactivation of weapons and a delegate-driven fire weapons workflow.

Decouple weapons from the player and implement a shared ammo system that tracks current ammo, spends ammo on fire, and disables weapons when depleted, with event-driven firing and cooldown.

Deprecate the double shot and configure new weapons on the ship, adjusting their positions and directions. Implement life pickups and a live system that instantiates life images at anchor-based positions.

Extend the forward bullet to create a chaser bullet, implement target search with a physics overlapped circle, and chase by moving toward and facing the target.

Explore perfect and limited chaser bullets in Unity, implementing rotation speed, direction toward the target, and frame-by-frame rotation to create dodgable projectiles.

Improve the chaser system by adding a shooting behavior to the third alien, implementing continuous target searching, balanced bullet speed and cooldown, and robust target handling to dodge mechanics.

Design and implement a loot drop system using a loot table, random chance, and pickups in Unity 3D, enabling reusable loot assets and configurable drop behavior.

Explore tweening with a free asset to animate alien movements in a Unity 3D top-down game, using waypoints, duration, and easing like linear and in-out.

Learn to create smooth paths using linear, Cattermole curves, and Bezier curves, and implement a look-at system that orients characters along the path with forward vectors.

Execute dynamic control point computation for catmull-rom and bezier curves by calculating distance between origin and target, the direction, the middle point, and a normalized offset.

Learn to add directional randomness to movement using a random range to switch between left and right, and refactor path types to support linear, bezier, and catmull with configurable easing.

Refine the player dive and tractor beam behavior: rename curve distance divider, implement a dive to the target then to the control point, and pull aliens into a mothership-like formation.