Unity Mobile Game Development - Exterminator

Build a mobile joystick in Unity by creating a touch-driven user interface prefab, wiring drag and pointer events with old input system, and testing via Unity Remote on a phone.

Move the thumbstick by mapping touch position to the thumbstick rect transform, clamp its offset within the background circle, and reset to center on release.

Implement joystick-driven movement by wiring input to a character controller, normalize inputs via an event-driven value update, and move the player with time-based speed while accounting for the camera orientation.

Make movement camera-independent by using the main camera to derive a flat right direction and a forward direction via cross product with world up, then apply input x and y.

Make the camera follow the player using a camera arm and prefab, rotate with player input, and adjust distance for dynamic, intuitive movement in a Unity mobile game.

Turn the player to face the movement direction using a move direction vector and quaternion rotation, then smooth with lerp and prepare for a separate right thumbstick for aiming.

Learn to add an aiming control with a second thumbstick, convert two-dimensional input to world direction, and separate aim from move inputs while preparing a cleaner update function through refactoring.

Refactor the update loop by extracting move, rotate towards, and update camera into dedicated methods and refine aiming logic so the camera turns only when not aiming.

Add animations to Unity project using Mixamo to import a humanoid avatar, download walk forward and other motions at 60 fps, and configure the animation controller with a blend tree.

Download and import locomotion animations, convert them to humanoid rigs, and configure a 2D freeform directional blend tree in Unity to smoothly blend idle, forward, backward, left, and right motions.

Use dot product to split move direction into forward and right speeds, feed them to the animator as forward and right speed parameters, and refine a blend tree for locomotion.

Learn how to compute and smooth turning speed using quaternion rotation deltas, dot products for direction, and lerp-based smoothing to drive animator turn speed in Unity.

Create a base weapon class in Unity and implement owner, equip/unequip, and attachment logic, using rifle prefabs and attach slots to connect weapons to the player's hands.

Create a c sharp inventory class attached to the player, instantiate initial weapon prefabs, attach them to correct slots, and implement next weapon switching with a current weapon index.

Create and import a pistol asset in Unity, attach a pistol script and prefab, and explore animation layers, avatar masks, and override controllers for weapon poses.

Create an upper body animation layer with an avatar mask and animation override to play weapon-specific idle and firing animations while keeping the lower body motion intact.

Learn to switch weapons by tapping or dragging the red aim stick, detecting drags with a boolean, and wiring a tab event to the inventory's next weapon in Unity.

Add the pistol firing animation, configure a humanoid attack state with an attacking boolean to trigger firing while aiming, and override rifle and pistol animations for correct playback.

Add weapon switching animations using a Mixamo rifle pull-away, configure animator transitions from any state with a switch weapon trigger, and synchronize code, animation events, and clipping for smooth gameplay.

Create an aim component that determines what the weapon points at from the muzzle via a raycast with range and layer mask.

Implement attack mechanics in Unity mobile game development by defining an abstract attack, creating pistol and rifle classes, and triggering attacks via animation events with an aim component.

Implement a reusable health component with current and max health, events for health changes and death, and damage handling for enemies or players.

Create an enemy class in Unity that uses a health component and animator to trigger death and destroy the enemy, and plan a floating health bar UI.

Create a health bar UI for a game object using a slider, instantiate it under the game UI, and attach it to the target so it follows above the head.

Connect the health bar to the enemy health via delegates, update the slider with health over max, and destroy the bar when the enemy dies, while keeping code modular.

Create a bullet hit effect in Unity using a sub emitter with collision to burst particles on impact with walls or enemies, and destroy them afterward.

Develop a flexible perceptual system in Unity by implementing a base sense component and perception stimuli with registered stimuli, plus an always-aware sensor and gizmo visualization.

Implement the sight sense for enemies by checking distance, angle, and line-of-sight with raycasts, with eye height adjustment and a forgetting timer.

Set up a forgetting routine for perceived stimuli with a coroutine and a dictionary, and build a perception component that counts senses, tracks forgetting time, and updates perception events.

Explore building a perception component in Unity that aggregates sensor stimuli to identify the earliest target, and compare data structures like dictionaries, lists, and linked lists.

Implement the hit sense to react to damage by recording hits through the health component and instigator, updating perception stimuli, and using a hit memory with a forgetting coroutine.

Explore how behavior trees drive Unity AI, with patrolling and attack targets prioritized left to right, and learn core concepts like nodes, composites, decorators, and updates.

Develop a behavior tree node class in Unity, supporting one-off and time-based tasks, with an abstract base and overridable execute, update, and end methods.

Develop a Unity behavior tree system with a root node, construct tree method, and an abstract base class, then implement a wait task for timed updates and logging in Chomper.

Implement a compositor that groups tasks into a linked list of children and explore selector and sequencer flavors for left-to-right behavior tree execution and outcomes of success, failure, or in-progress.

Learn to implement a Unity C# behavior tree sequencer and selector based on a compositor, running children left to right until all succeed or one fails.

Create a dictionary-based blackboard to store ai data for decisions. Expose set and get interfaces, support removal, and broadcast value changes for targets via a delegate used by behavior tree.

Implement a move to target task with Unity nav mesh agent and behavior tree, baking a nav mesh and using a blackboard target key and acceptable distance.

Implement the patrolling mechanic by creating patrol points and a patrolling component, then drive a behavior-tree sequence that updates the blackboard, moves to points, and waits between them.

learn to create a decorator for a behavior tree that interrupts a running task using a blackboard key, run conditions, notify rules, and abort strategies.

Implement the check condition by querying the blackboard for a key's existence and value, then trigger notifications based on rank condition change or key value change.

Sorts the behavior tree's priority across root, decorators, and composites, enabling correct execution order and aborting lower-priority nodes when conditions change.

Implement abort lower priority in the blackboard decorator to cancel running lower-priority tasks when the current node changes, using a recursive get to reach the leaf.

Add last seen location memory for the AI by storing the target position in the blackboard, moving to it when lost, waiting briefly, and clearing data.

refactor rotation into a reusable movement component and enable both player and enemy to rotate towards targets, then introduce a behavior tree interface to invoke rotate towards across AI.

Implement a rotate toward target task within a behavior tree, using a target interface and blackboard data, and distinguish moving to a target from moving to a location.

Refactor enemy architecture in Unity by creating a base enemy prefab with shared components, then derive a jumper variant to support distinct attack and patrolling behavior.

Extend the enemy base class with a virtual attack target and add a behavior tree task to issue the attack target, triggering the animator's attack and playing the chomp animation.

Learn to implement a locomotion blend tree driven by a speed parameter, wiring jumper and run motions, and calculate speed from position delta.

Define a team system with a team interface and team relation (friendly, enemy, neutral) to determine when damage applies. Implement team ID and compare IDs to identify friend or foe.

Implement a damage system with an abstract damage component, a trigger damage component, and team-based relation checks to apply damage to health components during trigger events.

Finish the chomper melee attack by wiring a trigger damage component to the jumper, triggering it on attack start and end, and linking it to the player's health component.

Create a player health bar in Unity by replacing the enemy progress bar with UI images, enabling horizontal fill, and updating a heart icon and text mesh pro health display.

Create a damage visualizer that makes the player blink by pulsing the emission color when damaged, using a dynamic material tied to the mesh, with configurable blink speed.

Develop a damage visualizer material in Unity with a shader graph, using albedo, metallic, normal, occlusion, and emission textures, plus an addition parameter to drive emission during damage.

Learn to create a reusable shaker that shakes the camera with adjustable magnitude and duration, using a camera arm. Extend it to the damage visualizer so damage triggers the shake.

Alter the enemy shader by adding an emission property and a new addition parameter, then implement a Damage Visualizer component to drive blinking with color and blink speed.

Add a death animation to the player by wiring a health empty event to trigger the death animation in Unity mobile game development, with layered animator control on the ground.

Implement a UI manager in Unity to toggle the gameplay and menu UI via canvas group controls, enabling or disabling interactivity and raycast blocking when the player dies.

Create a reusable behavior tree task group for the spitter, combining attack, last location, and patrolling into a sub behavior tree with proper initialize and compose logic.

This video refactors the chomper's behavior into reusable task groups within a behavior tree, adding attack target and patrolling groups with configurable move and rotation parameters.

Create and integrate the spitter enemy in Unity by adding a spitter variant, importing the asset and animations, and wiring a behavior tree-based ranged attack into the existing enemy framework.

Create a spitter projectile class that launches an arcing projectile via a rigidbody. Compute flight height, velocity, and horizontal speed from instigator to destination using a prefab and launch point.

Debug the projectile damage by wiring the damage component to the instigator via the team interface, ensure correct damage on trigger enter, and destroy the projectile on impact.

Learn to add VFX to a projectile using placeholder assets, import a cartoon VFX pack, assign a fireball visual and explosion VFX, and consider performance, collision, and camera shake.

Implement the cooldown decorator to control attack timing by tracking last execution time and cooldown duration, wrapping the attack target in the behavior tree.

Import spawner assets, assign textures and a normal map, and assemble a spawner prefab with health, animator, and perception components for Unity mobile game development.

Learn to implement a reusable spawn component for a Unity spawner, spawn via animator or immediately, select random objects to spawn, and integrate with a behavior tree and cooldown decorators.

Create a flexible spawn interface for any object, let spawned enemies perceive targets via perception stimuli, and initialize in awake to guarantee perception updates are subscribed before spawning.

Finish the spawner death logic by wiring the death animation trigger, overriding the on-death finished function, and spawning configurable VFX at death to explode the spawner.

Builds a flexible ability system by introducing an ability component and scriptable object definitions. Initializes and instantiates abilities, assigns owners, and exposes events for UI and stamina cooldown handling.

Create a speed boost ability that increases the player's movement speed for a set duration, with cooldown managed by a coroutine via the ability component and scriptable object.

Create the ability UI widget by importing assets, building an icon and cooldown bar prefab, and organizing them with a vertical layout for dynamic instantiation.

Add and wire the ability doc and UI class to instantiate ability UIs from a prefab, populate icons, and display cooldowns within a vertical layout group for the Exterminator game.

Implement touch input in Unity to cast abilities using pointer down and up handlers, detect what's under the fingertip, and activate the ability with a cooldown managed by a coroutine.

This lecture demonstrates adding a mac dock-like scaling effect to the ability UI in a Unity mobile game, using highlight size, scale speed, and lerp-based updates.

Implement a health regeneration ability by creating a health region script, retrieving the health component, regenerating health over time with a coroutine, and updating the UI.

Fix projectile collisions by adding a team interface to the damage component. Build a fire ability with a scanner to detect and burn nearby enemies using VFX.

assemble the scanner prefab with a kinematic rigidbody and pivot trigger, add test sphere for debugging, set up fire vfx, and create a fire ability with icon, cost, and detection.

Detect enemies and apply damage with the fire ability by running a timed damage routine for three seconds, computing a damage rate, and triggering fire VFX.

Rename the health bar to a value gauge for reuse and connect it to the player via the ability component. Update and broadcast stamina changes and outline a shop system.

Develop a modular shop system in Unity using scriptable objects for shop items and the shop system, with a credit-based purchase flow and a listener-based broadcast to apply bought atoms.

Test the shop system by adding a rifle item, wiring the inventory and credit components to handle purchases, and confirm purchases deduct credits and add the weapon.

Test the shop system by purchasing the fire ability and verify the ability component adds it, with UI updating. Observe a decoupled design using events that maintains clean dependencies.

Create a shop item UI prefab in Unity, including icon, title, price, description, and grayed-out states, with a script to refresh visuals based on available credits.

Compose and test a scrollable shop UI using a rect scroll rect viewport, mask, and dynamic shop item prefabs driven by the shop system and credits.

Learn to build a credit button and a shop toggle by implementing a UI manager that switches between canvas groups, enabling smooth transitions between gameplay and shop interfaces.

Implement a shop UI with a back button, display and update credits using a credit component and text mesh pro, and switch between gameplay and shop via a UI manager.

Implement the purchase flow by wiring the buy button to a try purchase and tracking the item with delegates. Refresh items as credits change and pause the game during shopping.

Convert all weapons and abilities to shop items, updating descriptions with attack rate and damage, equipping purchased gear and refining shop interface for progression with credits.

Implement a decoupled reward system in Unity by broadcasting rewards from a killer to reward listeners. Configure rewards (health, credits, stamina) via a serializable reward class and reward listener interface.