Zombie Escape: A Point & Click 3D Game using Unity's NavMesh

In this lecture we'll spend a little more time fine-tuning the NavMesh Agent's settings

In this lecture you'll learn how to place a target decal on the ground every time you click to move the player.

In this lecture we'll configure the Player and create a prefab for it.

In this lecture we'll configure the Enemy and create a prefab for it.

In this lecture we'll start writing a Finite State Machine by setting up the conditions for each state.

In this lecture we'll use a Swtich statement to handle instructions for the Enemy State enum that was determined in the conditional statement previously.

In this lecture we'll write instructions for the Patrol State

In this lecture we'll write instructions for the Chase State which allows enemies to chase the player when within range.

In this lecture we'll learn how to have the player drop breadcrumbs on the ground to allow enemies to follow the player around corners

In this lecture we'll learn how to toggle the NavMesh Agent on and off while turnning the NavMesh Obstacle on or off in it's place.

In this lecture we'll setup a priority system allowing enemies who arrive first to attack first, while other enemies standby awaiting their turn to attack. We can use a priority bonus modifier to allow some enemies to get first dibs on the player.

In this lecture we'll write instructions for the Standby State allowing enemies to have a place to go when they do not have attack priority.

In this lecture we'll setup two animations for the Attack and Standby Enemy States. Both animations will be added to the Locomotion Animator Controller with instructions to trigger the animation when in the appropriate state.

In this lecture we'll write instructions for the enemy's combat.  This allows the enemy to attack and check to see if the player is standing within combat range before causing damage to the player.

In this lecture we'll write instructions for the player's combat, allowing the player to attack the enemy while the player hold's in on the attack button and check for collisions the enemies within range before causing damage to them.

In this lecture we'll write instructions for maintaining both the player and enemy's health system and if the health drops to zero, we'll handle the death within a Coroutine before either destroying the enemy or otherwise disabling the player.

In this lecture we'll download a dozen different death animations from Mixamo and add them to our Locomotion Animator Controller in a Sub State then choose 1 of the 12 death animations randomly each time and enemy or player dies.

In this lecture we'll construct a blood puddle prefab from a simple sprite graphic

In this lecture we'll design a particle system that bursts blood splats into the air while gravity brings them back down to the ground.

In this lecture we'll create a health feedback system that displays the amount of health taken or received during combat over the enemy or player's head.

In this lecture we'll design a regeneration system that can be used for both the player and enemies.

In this lecture we'll design a healthbar gui using Unity's UI Images that accurately displays the player's percentage of health with a text overlay revealing the actual health and max health values.

In this lecture we'll design a world space canvas healthbar for enemies that uses Unity's UI Images with a radial fill to display a circular shaped health system below the enemy's feet while accurately displaying their percentage of health.

In this lecture we'll design a UI Panel that completely covers the screen with a semi-transparent black panel and an animated message that lets the player know that their character has died and the game has ended. The death screen overlay will also allow the player to push any key to retry the game.

In this lecture we'll use the built-in Reset Method to fully configure the EnemyAI script to automatically add components and configure them to help make the process of creating a new enemy much faster than doing it manually.

In this lecture we'll put our work from the last lecture to good use by creating several groups of enemy types. Now it's possible to create entire groups of enemies at once just by adding the EnemyAI script with multiple enemies selected at once.

In this lecture we'll start the process of creating Spawn Nests that will be used to generate enemies in the game.

In this lecture we'll add a mesh to our existing Spawn Nest prefab which will give the object a visual presence in the world, also making it possible for the player to see it.

In this lecture we'll take the time to design two particle systems, one for smoke puffs, and the other for 3D debris which will be used as a visualization tool for Spawn Nests as they either spawn new enemies or take damage from the player.

In this lecture we'll make the Spawn Nests destructible, allowing the player to attack and cause damage to the nest until it is destroyed.

In this lecture we'll fix a few problematic areas of the game project so far. We'll prevent the enemy from leaning towards the player when attacking. We'll also fix issues with the blood puddles covering up the enemy healthbar and a few other minor problems while we're at it too.

In this lecture we'll learn how to write a script using the Singleton Pattern, thus allowing our script to stay running even when switching scenes, and only allowing one instance of the script to run at a time. We'll also learn how to create a ScriptableObject which I'll call Depot, which will be used for storing objects with greater efficiency and for easier access.

In this lecture we'll open up the Models.fbx file provided in the Resources lecture in Section 1 of the course and create prefabs for each of the available objects included in that fbx file.

In this lecture we'll design a playable level using the prefabs created in the previous lecture.

In this lecture we'll write a simple camera rig script that controls the movement of the camera allowing it to follow the player while continuously pointing downward from the sky. We'll also include the ability for the player to zoom in and out by using the Mousewheel.

In this lecture we'll make it possible to pickup objects on the ground as the player walks over them. These objects are referred to as Pickups and are responsible for both temporary and permanent upgrades to the player's abilities and stats such as health, maximum health, attack speed and damage boost.

In this lecture we'll create a visualization that allows the player to know which upgrades they have received when picking up items from the ground as well as providing a countdown timer for when the temporary pickups will expire.

In this lecture we'll allow the player to pickup keys from the ground and add to the number of keys currently held by the player.

In this lecture the total number of keys in a player's possession will be displayed on the screen and updated each time a key is used to open a locked door.

In this lecture we'll design a very simple level exit prefab that allows the player to walk into the trigger of the exit and reload a new scene.

In this lecture we'll create a new puddle prefab and assign it as a new NavMesh Area Type.

In this lecture we'll write instructions for handling the speed of an agent when walking over special NavMesh Area Types such as the Puddle created in the last lecture.

In this lecture we'll create a collection of geomorphic tile sets that will allow us to design levels much faster by using templated sections of level and piecing them together seamlessly.

In this lecture we'll write a very simple level generator that takes advantage of our newly designed geomorphic tilesets.

In this lecture we'll place wall boundaries around the entire perimeter of our generate level to prevent the player from walking (or even seeing) outside of the level bounds.

In this lecture we'll design a special script that serves as a way of visualizing the objects that we wish to spawn (before they actually get spawned) and simultaneously flagging specific floor tiles to spawn particular types of objects.

In this lecture we'll work out a series of lists for each different type of spawn making it possible for the generator to choose from the list while considering how many objects to spawn and where to spawn them.

In this lecture we'll place keys and upgrade pickups in designated areas throughout the generated level.

In this lecture we'll place spawn nests and level exits in designated areas throughout the generated level.

In this lecture we'll download and import the NavMesh Surface Component which will allow us to bake Unity Navigation at runtime.

In this lecture we'll bake the NavMesh at runtime allowing players and enemies to traverse the level after generating a random level.

In this lecture we'll create a special Modifier component used by NavMesh Surface for all Area Types other than Walkable (since it is already baked by default)

In this lecture we'll create a new Agent Type for larger enemies. You'll learn not only how to do this, but also when and why!

In this lecture we'll create new spawn nests to accommodate the new enemies that have been added to the game.

In this lecture we'll add a sound effects section to the Depot which will allow us to store all of our sound clips in one organized place.

In this lecture we'll create an Audio prefab that simply contains a preconfigured AudioSource which we can use to add to the player and enemies, as well as any other objects that might need to make sound.

In this lecture we'll use the PlayOneShot method for playing back audio clips all on the same AudioSource, rather than creating individual AudioSources for each and every clip that is played throughout the game.

In this lecture we'll sync footstep impacts to footstep audio clips and then use this technique to synchronize other sound effects without animations.

In this lecture we'll create a new ScriptableObject which I will call a Guise file. These guise files are used to store information about a specific player or creature in the game. This could include audio clips as well as other abstract ideas such as blood color for example.

In this lecture we'll design a series of level setting files which can store preferred options for each individual level of the game.

In this lecture we'll design a system that allows the player to advance through each of the levels in sequence until they reach the last level and then finish the game by going straight to the Credits scene once the levels are all completed.

In this lecture we'll setup a place to store statistics for game progress, such as number of enemies killed, number of spawn nests destroyed, number of pickups collected, and so on.

In this lecture we'll write instructions for displaying the resulting score on the screen allowing the player to see their progress before pressing any key to continue

In this lecture we'll create some text credits and animate them to roll down the screen and then loop until the player presses any key to return back to the game again.

In this lecture we'll design an Escape Menu that can be toggled on or off using the Escape Key. When the menu is visible, our script will simultaneously pause the game.

Bonus Lecture