Through out these lessons, we'll learn how to utilize Unity's Pathfinding system to create quick and efficient AI. Then we'll move on by discussing the new particle system interface called Shuriken where we'll create a pillar of fire. After that, we'll get into working with the HDR capabilities and create a stunning composition in real time. Then we'll finish this course up by discussing light probes and occlusion culling. Both are great ways to create a beautiful game but also keep our performance costs low.

In this series of lessons we discuss our processes for bringing our final game build together. We'll start off by discussing the process of collaborating all of the project files created for this project. Then we'll discuss how the player, GUI, Enemy AI, and Game State need to be hooked up in order for the game to work properly. We'll also discuss how to create our Main menu and then we'll end with publishing our final game. Now this course is not meant to cover every single step to hook up your game but to be more of a guide to help with the finalization process and to give you some insight on the process we used here at Digital-Tutors.

Having a computer understand our level is one of the most pertinent problems facing any game developer. Waypoints are a quick and powerful way to create a simple model of a level that an AI can understand. Once we have our waypoints set-up and working, we'll create an enemy AI that can find and attack the player.

To begin we need to bake our animations into separate animation clips and loop them correctly. Next we'll connect the left joystick position into our script to drive the base character movement animation. From there we will use If Else conditionals to drive which animation plays. Next we'll layer other animations together to easily have our character run while getting hit or swapping weapons. We'll finish our character animation script by freezing the animations while paused and correctly dealing with a game over condition.

Throughout these tutorials, we'll learn how to create a melee system that you would see in most hack and slash video games today. Although this course does not cover extremely advanced techniques, you will learn enough to customize this system for your very own projects. We'll start off by talking about a few key tips we need to know before we import a rig into Unity. Then we'll begin scripting a simple user interface to give our user damage feedback. Following that we'll create the script that will handle how to deliver damage and how to limit the range of our attacks. Then we'll create a basic enemy AI that will watch and listen for our player. Then we'll wrap it up with applying physics to our melee combat system.

Throughout these lessons, we'll add all of the audio used in this game. We'll start out by adding the weapon firing and reload sound effects to our game weapons. Then we'll add the necessary audio to our character like footsteps, groans of pain, and his death sound effect. After that we'll get into adding audio to the enemies. We'll create their ambient crawling sound, their splatter and death scream. Then we'll wrap it all up by adding our music track to play while we are playing our game.

Through these lessons, we’ll examine our game design doc and build game-play functionality. We'll begin with creating a simple count-down timer and how to let other scripts cleanly access it. Then we'll learn how to start and end our game with a splash screen to hide the level. Next we'll create functions for the various parts of a game, like winning a round, pausing the game, killing an enemy, saving our data, resetting our game, and game over. Finally we'll take a quick look at randomly spawning our player. A game's internal logic is one of the most important parts of any game's development. By learning how to deal with many common game states, we can extend them to fit our own game's needs.

We'll look at several of the terms and techniques that are found when scripting in Unity such as creating and manipulating variables, understanding the different types of operators, and how we can create instructions for our game objects using functions. We'll also jump into creating logic with conditional statements, and loops. We'll even learn how to use basic arrays. Finally, we'll take what we've learned and apply it to creating a movement and animation script.

Throughout the tutorial, we'll learn how to manipulate Unity's Player Relative Control prefab to give us our third person view and then we'll learn how to create the desired player movement based off of those scripts. After that, we'll get into creating weapon functionality for our assault rifle and our shotgun using our own custom scripts. Finally, we'll end the course by applying our weapon damage to affect an enemy's health and make them explode when that health reaches zero.

We will start by talking about some steps for starting your UV layout process as well as some important concepts that you should keep in mind whenever preparing your UVs and your textures for use inside of Unity. We will talk about the importance of hiding UV seams on your geometry, planning texture layouts on your objects to maximize efficiency, you will learn UV layout and geometry modification tricks that can dramatically enhance the use of your UV texture space, and we will spend time in Photoshop learning how the textures in our level were created.

We will start by using a simple scene to demonstrate topics such as realtime shadows and lighting, we will also explore the process of lightmapping inside of Unity, allowing us to bake indirect illumination, shadows and ambient occlusion directly into our texture maps. While discussing lightmaps, we will show you a number of methods for getting a proper lightmapping result based on your object's UVs. We will also discuss how lights and shadows play a critically important role in conveying a certain mood or an atmosphere within our environments.

Through these lessons we’ll learn how we can use the GUI class to draw various text and images on our screen. From there, we will examine time-saving techniques for placing our GUI elements with the inspector accurately. We'll learn how we can use arrays to store multiple pieces of data and how we can display lists using for loops. Then we'll refactor our array into a highscore class. With our display set up, we will learn the commands to access our player prefs and the logic we need to sort and store our data. Finally we'll see how we can use mobile keyboards and examine a faster method of saving data for mobile platforms. From basic preferences like display settings to more complex structures like high scores, it's important to understand how to save data after we close our game.

Through out these lessons, we'll create our own custom scripts to create the exact behavior we want from our user interface and how we implement those to work with our Android tablet. We'll create buttons that will allow us to fire, reload, and swap our weapons. We'll also create the functionality to give the player feedback on how much ammo, time, and health they have during the game.

Throughout the tutorial we will learn how to assemble the core of our game level and then we will advance through the stages of set dressing by blocking in major details. After we've blocked in our details, we'll become more intentional with our design by adding, taking away, or rearranging our props for the betterment of our overall design.

We'll begin the tutorial by learning about all the built-in methods Unity gives us to talk between scripts and between objects. We'll learn the how to find and access scripts on any game object using either direct connections, finding the object or the physics system. Finally we'll examine how a script can call methods on many other scripts using the messaging system in Unity. Each of these methods has limitations, so next we'll introduce the 3rd party script 'Notification Center' which acts as a central hub for easily communicating between multiple scripts. We'll learn how to post a new notification, how to observe a notification and how to pass data through the Notification Center. We'll wrap everything up by examining each of these methods and discuss which we should use in various situations. Understanding how our scripts will talk to each other lets us break our game into many script components, while still creating the functionality we need with the least amount of effort.

Over the tutorial, we will learn how to use the Unity editor interface as well as how to navigate in the scene view. From there, we will learn how to import assets and how to create prefabs. Then we will shape our level even more by adding character controllers, colliders, lights, materials and physics. We will then finish the tutorial by learning how to use scripting in order to make our level interactive.

To begin we'll break down what Unity is, what it can do, and what it cannot do. From there, we will examine the parts of a game in Unity and learn how they interact to create a game. Next we will open a partially completed project and scene to navigate the Unity interface and Scene view. Next we will import a model from a 3D application and place it into our level. We will also learn how to transform and edit objects and components to customize our game. Next we will learn how to run around our game using the two built-in character controllers. From there will we learn a an easy way to create interactions using triggers. We finish off the tutorial by creating a small script to track our player's health and build our game to be run on PC or Mac platforms.