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.