Unity 2D Dungeon Gunner Roguelike Development Course

In this lecture we'll cover Unity installation, and ensure that the correct version of Unity is installed for the course.  We'll also cover how to install the Microsoft Visual Studio IDE for code editing.  We'll also download the completed Unity project for the course that you can use as your reference for every lecture.

In this lecture we'll cover how you can install a GIT client called Sourcetree. We'll show you how you can use Sourcetree to load the 'GIT' branches that correspond to every lecture.  Every GIT branch corresponds to the Unity project saved at the end of the lecture - so you can review the completed course lecture by lecture.  We'll also suggest how you can use the supplied completed project alongside your project that you create for the course, including using file comparison tools such as DiffMerge.

In this lecture we'll review the architecture and structure for the whole game.  This will give you a good overview of all the components in the game, and an understanding of how they all fit together.

The objective for this lecture is to create an empty Unity project from scratch to use in the course, make sure we have the required Unity packages installed, and also to import the CourseAssets into the project ready for use throughout the course.

The purpose of this lecture is to walk through and review the CourseAssets that you imported in the previous lecture. 

The purpose of this lecture is to explain at a high level how dungeons will be constructed in the game, and how we'll implement a room node editor to support this.

In this lecture we are going to start by creating a simple editor window.  The editor won’t do anything at this stage apart from display 2 ‘dummy’ nodes drawn by the editor.  Once we are comfortable with the basics, we’ll start extending the editor step by step until we get the functionality for a complete room node editor.

In this lecture we are going to create the scriptable object classes that will be used to store Room Node Graphs and Room Nodes. We’ll also create a scriptable object class to store the room node types in, and a class to store a list of these room node types.

In addition we’ll create a helper class that we’ll start adding validation checking methods to, to help us make sure that serialised data, like in scriptable objects, is populated correctly.  As we add more scriptable object assets to hold data, having some validation to alert us of missing data becomes more and more important.  If we don’t do this, and forget to populate required data then our code is likely to error.  This results in time wasted trying to track down why.

In this lecture we are going to continue building our room node editor, step by step.  We’ll also create a central repository for game resources so that different classes that need to access these resources can do so easily.

The purpose of this lecture is to allow the room nodes to be repositioned by dragging them in our new room node editor.

In this lecture we are going to add connecting lines between the room nodes in our room node editor.  We’ll start by adding the ability to drag connections between one node and another, we’ll create parent and child relationships between room nodes, and we’ll draw connection lines between room nodes that have already been connected.

In this lecture we are going to automatically create the entrance room node when the first node is created on the room node graph.  Nodes that have been connected will be ‘locked’ so they can’t be changed. We are also going to create another GuiStyle to use when a room node is selected.

In this lecture we are going to add validation when we connect together room nodes.  This validation will prevent invalid connections – like connecting the same child node to a parent more than once.  We’ll also add validation that supports our dungeon room layout design constraint of only having one parent for every child.

The purpose of this lecture is to allow all room nodes to be selected on the graph using the right click context menu.

In this lecture we are going to add the functionality to allow the connections between selected room nodes to be deleted, and to allow selected room nodes themselves to be deleted.  This will allow us to better maintain and amend the dungeon room node graphs that we create.

The purpose of this lecture is to add functionality to allow the canvas to be repositioned by dragging it.  This is needed if we have a large dungeon room node graph that won’t easily fit on one screen.  We’ll also add a grid background to the canvas to give some visual context when we drag the graph.

In this lecture we are going to put the room node graph editor to good use.  The game will have 6 levels, so we are going to create multiple room node graphs for each level. In the future the dungeon algorithm will randomly select a room node graph for the level, and then use it to layout the dungeon rooms.

In this lecture we are going to talk about some components and concepts that we’ll come across during setting up the main game scene, namely, the cinemachine component, the pixel perfect component, and orthographic size.

So up until now we have been working on our dungeon room node graph editor, which is an essential part of our dungeon building, and we have also created room node graphs for our 6 game levels.

In this lecture we are going to move onto setting up the empty main game scene and change some of the project settings in preparation for the next steps in developing the game.

The purpose of this lecture in to look at layers and sorting layers and using them in 2D games.

In this lecture we are going to create a base  dungeon room template, using the tilemap layers that we talked about in the previous lecture.  We’ll then use this template to make it easier to create our dungeon rooms.

The purpose of this lecture is look in more detail at tilemaps and the tools Unity provides to work with tilemaps. We’ll look at how to create tilemap palettes and tiles, and how tiles are painted onto tilemaps. We’ll take a look at the co-ordinate brush and the random brush that’s supplied as part of the tilemap extras package we installed. We’ll then explore the tiles and palettes that are supplied with the course assets.

In this lecture we are going to create our first dungeon room using the prefab room template that we created in a previous lecture.

As we create the room I’m going to describe how you should use the different tilemap layers that we have created, and also point out some of the constraints that you should follow when creating dungeon rooms to ensure they will work with the dungeon building algorithm that we are going to create.

In this lecture we are going to create some corridors to connect together dungeon rooms, using the same principles we used to create dungeon rooms.

In this lecture we are going to create a scriptable object class and corresponding scriptable object assets to store information about the dungeon rooms and corridors that we have created.

In this lecture we are going to import some new assets. There are 68 dungeon rooms and corridors supplied in the resources for the lecture that we are going to use in the course to build our game. We’ll import these dungeon room assets in this lecture and review them.

In this lecture we are going to create the RoomTemplateSO scriptable object assets for the rooms that we previously created and review the dungeon room assets that we imported in the previous lecture.

In this lecture we are going to tidy-up a few of the dungeon room tilemaps and assets that we imported in the previous lecture.

In this lecture we are going to demonstrate the working dungeon builder

In this lecture we are going to discuss the main concepts for the dungeon builder and the algorithm that will be used.

In this lecture we are going to create the DungeonLevelSO scriptable object class to enable us to define what room node graphs and what room templates should be available when generating a particular dungeon level.

The purpose of this lecture is to create a Singleton Abstract class that can be used to easily create singleton instances that we can use for our game managers.

In this lecture we are going to create our game manager and we’ll initially set up the game manager to call the dungeon builder that will build the dungeon.

In this lecture we are going to create the Room class, and create an empty InstantiatedRoom class to populate in a later lecture.

In this lecture we are going to explore how you can use Unity shader graph to create shaders. 

In this lecture we are going to create the dungeon builder class. The dungeon builder will select a random room node graph, and process each of the room nodes. For each room node it will select a random room template, and then it will create a room object which it will try and place without overlapping any other rooms to build our complete dungeon level.

In this lecture we’re going to pull together all of the hard work that we’ve done in the previous lectures. We are going to take the dungeon room objects that we laid out in the previous lecture and for each one we are going to instantiate the corresponding dungeon room tilemap prefab. By doing this we will create the complete dungeon level in our scene of connected dungeon rooms.

In this lecture we are going to add some new methods to the InstantiatedRoom class to block off doorways that are not connected.

In this lecture we'll create the initial player classes.

In this lecture we are going to create the base player prefab. The player prefab will be structured to allow the player to use a weapon and to support the various animations that we will implement for the player. As we develop the player capabilities in this course we’ll add more components to the player prefab to provide the required functionality.

In this lecture we are going to create a prefab variant for a new player character, which we are going to call The Thief. We’ll import the sprites that we need for the thief character and we’ll set up the animator controller for the character from scratch, ready to create the character animations.

In this lecture we’re going to create the animations for the thief player character, using the Sprite sheets that we imported in a previous lecture and the empty animation clips that we created and added to the animator controller. By the end of this lecture will have all the animations set up for the thief player character.

In the previous lectures we set-up the animator controller and animations from scratch for The Thief character. We have another two playable characters for this game which we will set-up in the next two lectures. Rather than set-up these characters from scratch we are going to use the animator controllers and animations supplied with the course assets, so the set-up process is going to be very quick. In this lecture we are going to focus on setting up The General character prefab variant.

In the previous lecture we set-up The General character prefab variant. In this lecture we are going to follow exactly the same process and set-up The Scientist character prefab variant using the animator controller and animation clips supplied with the course assets.

In this lecture we are going to make sure that the weapon isn’t active during The Thief roll animations.

In this lecture we are going to create the player details scriptable object assets for the Thief, the General, and the Scientist, and we are also going to create the current player scriptable object asset to reference the active player character.

We’ll also create a script to populate the cinemachine target group with the player position so that the camera follows the player. We’ll instantiate the current player prefab in the dungeon entrance room, and then check the cinemachine camera now follows the player.

In this lecture we explain the Publisher Subscriber Design Pattern and how we are going to use it in the game.

The purpose of this lecture is to enable the player to aim a weapon while idle in the direction of the mouse cursor.

The purpose of this lecture is to implement a custom screen cursor to replace the default mouse cursor.

The purpose of this lecture is to add up, down, left and right movement for the player using the keyboard.

In this lecture we are going to add the player dodge roll move and animation when the right mouse button is held down while one of the movement keys is pressed.

In this lecture we are going to improve the way that Cinemachine tracks our gameplay. At the moment Cinemachine only tracks the player – when we move the player on the screen, the cinemachine camera will follow. But this isn’t ideal for a dungeon shooter game – we want to be able to look around the dungeon surrounding the player to see if any enemies are approaching. So we are going to do this by extending the cinemachine target group that we created in a previous lecture to include the screen cursor as well as the player.

The dungeon doors will be added to the room doorways, and they will start off closed and will open when the player approaches them, allowing them to enter a room.

In future sections of the course, when we add enemies to the game, the doors will lock the player in a room until all the enemies in that room are defeated. Doors to Boss Rooms will stay locked until all the other rooms in the level have been cleared of enemies.

In this lecture we are going to create the door prefabs that can be instantiated in the dungeon rooms. The Door prefabs will have animations for the doors opening and closing. We’ll have 2 door prefabs – one for north / south doorways, and one for east / west doorways.

In this lecture we are going to use the door prefabs that we created in the previous lecture. We are going to automatically instantiate the doors in the dungeon rooms when we generate the dungeon.

In this lecture we’ll create a new door class that will control the opening, locking and unlocking of the dungeon doors.

In this lecture we are going to implement functionality to fade in the dungeon doors and rooms. Apart from the entrance room where the player starts, all other dungeon rooms and their dungeon doors will start off by not being visible to the player. Instead the doors and rooms will fade in to become visible as the player approaches them. By doing this we give the sense that rooms are initially unexplored, and only allow the player to see dungeon rooms once they have been visited.

In this lecture we are going to start setting up the 2D collision matrix in the project settings, and we are also going to update the player animator to vary the player animation speed based on the player movement speed.

In this lecture we are going to look at the concepts behind Object Pooling, and explain why it's a useful technique to help improve performance for some games.

In this lecture we are going to take the concepts of Object pooling and talk about how we are going to implement an object pool manager in the game using queues for the object pools, and a dictionary to hold all the object pool queues that we define so that they can be accessed easily.

In this lecture we are going to implement the Pool Manager functionality in our game, so that we can use it to manage any prefabs that we want to create an object pool for in the rest of the course.

In this lecture we are going to demo the Pool Manager by creating some test code that places enemy prefabs that are created in the object pool in the dungeon.

In this lecture we are going to talk about Weapon and Ammo Classes we'll be using to support the player shooting functionality, and how they fit together.

In this lecture we are going to review the emission shader that has been provided in the course assets and look at how it is being used to create materials used for the ammo that enable the HDR intensity to be increased to cause the ammo to glow.

In this lecture we are going to create weapon details for the Pistol which is the starter weapon for the General.

In this lecture we are going to create ammo details for the Pistol which is the starter weapon for the General.

In this lecture we are going to update some incorrect values in the Dungeon Room scriptable object assets.

In this lecture we are going to set the pistol as the starting weapon for the General and the Thief characters.

In this lecture we are going to implement the core functionality to allow the player to actually fire the Pistol starter weapon. 

In this lecture we are going to implement the functionality to allow the player to reload weapons.

In this lecture we are going to create a new revolver weapon and ammo for the player.

So for some weapons – like the plasma blaster and laser blaster we are going to have the weapons ‘precharge’ before firing – this means there will be a small delay between the fire button being held down and the weapon firing. 

So in this lecture we are going to implement this precharge functionality.

The purpose of this lecture is to create the Plasma Blaster Weapon And Ammo for the Scientist to use as their starter weapon.  We will also implement an ammo trail to give the plasma ammo a laser like effect.

The purpose of this lecture is to create a weapon status UI that displays the current weapon sprite and name, the total remaining ammo, the ammo remaining in the ammo clip, and the weapon reload status including a weapon reload progress bar.

The purpose of this lecture is to add the functionality to allow the player to switch between the weapons that are in their weapons list.  They can do this by either using the mouse scroll wheel, or by pressing a number key on the keyboard.  The player will also be able to move the selected weapon to the front of the weapons list.

The purpose of this lecture is to create the Sniper Rifle and Sniper Rifle ammo. 

The purpose of this lecture is to create the MP7 sub machine gun weapon and amoo.

The purpose of this lecture is to create the Laser Blaster weapon and ammo.

The purpose of this lecture is to create the SMG weapon and ammo.

The purpose of this lecture is to review the Shader Graph Flame Shader provided in the course assets to understand how it works and is created. This will be used in the next lecture to create a flame trail for the rocket propelled grenade ammo.

The purpose of this lecture is to create the rocket launcher and the rocket launcher ammo.  For the rocket ammo we'll use the flame shader material to give the rocket a flame trail.

The purpose of this lecture is to add the functionality to be able to spawn multiple ammo simultaneously - to use with weapons such as a shotgun.

The purpose of this lecture is to create the shotgun and the shotgun ammo which will use the multiple shot functionality created in the previous lecture.

The purpose of this lecture is to discuss how Unity handles sounds and audio.  We'll also look at how we'll implement these concepts in our game to play sound effects.

The purpose of this lecture is to create the core classes that we need to be able to create and play sound effects in our game.

The purpose of this lecture is to create the SoundEffect prefab and add it to our object pool.  These objects will be enabled through the SoundEffectManager to play our sound effects.