Unity | C# - The complete game development beginners course

Managing the things we need to do to have a game and prioritizing accordingly based on how each task influences the experience of our game. Identifying the key elements of the game early on is vital when designing games and this lecture provides a guide to follow when creating a new game in order to be organized and has clear targets of what the game should feel and look like.

To start off, we need a game idea/design. During this lecture, we will be discussing techniques to come up with unique ideas for your games and create our own game design.

Combining colours appropriately can hugely assist in the creation of nice-looking level designs for your game. I will be showing you ways I choose my colours to achieve different aesthetics and tools to use to create nice colouring combinations.

Running over the necessary installations to follow the course, discussing what tools we will be used during lectures, and creating a new project in Unity.

A tour around the unity interface and features that the game engine offers for us to use, looking at what are game objects and how to create one, as well as ways to personalize the interface to your preferences. By the end of the lecture, we will have a game object in our scene that we created with a C# script attached to it.

An introduction to the programming side of things. We will be creating a new C# (pronounced C sharp) script and we will be having a look at visual studio, the integrated development environment that is widely used across the industry to write and compile code. We will be looking at the different types of programming variables available and how to use them in our programming journey.

While classes can be a tough subject to get a grasp on initially, it's vital to comprehend what they are and how they work. This lecture will give a small introduction to classes and the context of code.

In order to compare different values and variables in our script, we will be using the if statement. During this lecture, we will have a look at the syntax, the limitations and how to properly use the if statement.

Having a look at the three most common types of operators available in programming languages which are the arithmetic operators and the comparison operators.

We will take a deeper look at if statements and how to use them using multiple conditions, allowing us to create more complex conditions in our scripts. Additionally, we will be having a look at the else keyword and how to use it.

Declaring a variable in different parts of your code can lead to different results. During this lecture, we will be having a look at different scenarios of declaring variables in different areas and how each one affects our code.

Through our scripting, we will be using the transform component to change the position, rotation and scale of our game object during run time. By the end of this lecture, our game object will be able to move around our scene/game.

The variables discussed in the previous lecture should have an access modifier to determine the accessibility of the variable to other scripts. This lecture will look in detail at each access modifier used and what's the differences and advantages of each one.

The MonoBehaviour Base Class offers many functionalities that allow us to communicate with unity and make our lives easier. This lecture briefly takes a look at the main functions that this class offers and how to use each one, with further lectures investigating deeper for each one mentioned.

Rigidbodies allow us to connect characters to Unity's physics engine, making our character react with gravity, have acceleration and velocity that will allow us to move our character.

Through a few lines of code and the help of the rigidbody added in the previous lecture, we will be able to add horizontal moment to our character and game. Using rigidbodies is a much more efficient approach for movement as it allows collision detection and has a much smoother result in comparison to manually changing the position of the transform component.

Making our own functions/methods can provide huge flexibility to your code, as well as appearing cleaner. Functions are important to get a good grasp of so we will delve in different examples to fully understand why and how to use them appropriately. (In c#, functions are also called methods as they are within a class)

A simple left and right movement seems kinda boring on its own. Lets some extra jumps to help out with that and make our character feel more energetic and interesting. We will be creating a function that will be our basic jump action that we will build on top of during the next lectures.

This lecture focuses now how unity handles collisions between objects, as well as the functionalities it offers for use to utilize in our code. During this lecture, we will be having a look at how unity uses collisions and how to detect them in our scripts.

Currently, we have created a simple jump function in our game. Using the same function, we will modify it to allow side jumps which would work as a double jump to our existing vertical jump.

Having scripts communicate and use data of one another is a common sight in game development, so using appropriate techniques to do so is vital. This lecture will highlight some of the ways we can achieve this, showing ways to find game objects, or get references to components/scripts.

Good usage of lighting can massively improve the aesthetic of your scene and make it appear much more polished. During this lecture, we will be adding light to our game and exploring the different lights available to us in Unity.

Object Parenting is an essential tool for games and we will be having look at how to use them through the hierarchy panel, and through a script.

Create a camera that smoothly follows our character without appearing "stuck" on the character. Instead, our camera will smoothly move based on the character's location on the screen. (A part of this video was cut out and some footage is not included. The footage basically changes the player sprite from square to circle using the icon next to the sprite property)

Implementing a new object that will we build upon to create a colouring swap mechanic when our player collides with them. By the end of the lecture, we will have a gem created that allows players to swap colours with it.

Comparing the OnTrigger and OnCollision functions, analyzing how each works, the differences between them, the advantages each one offers, and when is appropriate to use each one.

During this lecture, we will check out what are prefabs, why to use them, and how. Through the use of prefabs, we will add different variations of our existing gem and populate our gem folder with different colour gems to use.

Loops are a useful feature in programming languages that is used to iterate over specific blocks of code. During this lecture, we will have a look at how and when to utilize the for loops with examples.

In order to maintain a balance of our movement script, we will use collision calls and checks to keep our character from going faster than intended.

Currently, our gems are static without any animation applied to them making them just boring and uninteresting. During this lecture, we will have a look at how to create animations in unity by making an animation for our gems.

During this lecture, we will be having a look at data structures and arrays in particular. We will have a look at different examples of arrays and how to use their different functionalities.

During this lecture we will be exploring a different type of loop which is called foreach loop. The foreach loop is similar to the for loop but is more commonly used for data structures. We will have a look at how to use the foreach loop and when using examples in our script.

This lecture will have a look at how to ignore collision by adding coloured gates that will only allow our character to pass through them if the characters have the same colour as the gate, otherwise the gate will collide and block the character from passing through them.

During this lecture we will be discussing a very important aspect of game development which is map designs. We will be making our own level and have a look at ways to come up with unique ideas that will make your game stand out.

Lists are another data structure that can contain many variables all at once similar to arrays but work in a different way than arrays. During this lecture, we will have a look at lists, how and why to use them.

To make our levels seem more interactive and less stationary, we will introduce some movement to our gates which we will use in our level designs. Starting off, we will make our gates move between fixed positions.

Now that our gates are moving, we need to make our players move along with them, making our gates work as a platform. We will also be improving our existing code to make it more scalable.

Our gates will be able to rotate around themselves based on time and will rotate every certain amount of time. This will force the users to time their movement when interacting with them, adding more tools for our puzzle designs.

Now that we have multiple levels to work with, we need a way to connect them. During this lecture, we will be creating a level transition for our levels through the use of the scene manager class.

During this lecture, we will be creating a collectible game object. In order for the user to be aware of the amount of collectibles they have gathered throughout the game, we will create a text user interface (UI) which will be displayed at the corner of their screen. A brief introduction to UI will be done which we will build upon at further lectures.

For this lecture, we will discuss a special keyword when declaring a variable called static, with scenarios of where to use it, when and how.

While usually collectibles don't serve any other purpose other than collecting them, I like to give a little boost to encourage players to look aroudn for them. During this lecture, we will add an extra functionality to our collectible items to increase our character's light radius to help them look around in the dark.

Playtesting is a crucial part of the development of a game. Through playtesting, you can find errors/bugs that exist in your game, identify if your game is meeting its goals set in the game design stage, and also be a source of inspiration for future map designs. During this lecture, we will be discussing the importance of frequent playtesting.

We will be creating a main menu that users will see when opening our game. With this, the lecture will discuss various UI elements and how to use them in order to create a main menu and end menu scenes for our game.

Now its time to build our game and unleash it to the world. This is a short video on how to build our game, what you should expect by building your game, and the differences between the build version and the game panel version of your game.

A recap of everything we did thus far in one lecture. Take a moment to ensure that you understand the material taught up to this point. If you haven't grasped a certain topic, have a look at the resources available for that lecture, or have a look at examples available for that topic to full comprehend it.

During this lecture, we will create our initial game design idea for our game and break down the tasks we need to complete, and create an order of completion, prioritizing the most vital tasks to create our game.

A quick lecture in that we will be discussing the available project templates in Unity and creating our new 3D project.

Explaining what is source code and why it is vital to do it. I will be using GitHub, an industry-standard tool for version control.

The way we captured input for our 2D game was through the classic approach which has been the traditional way for player input for the years. The traditional Input class offers a simple, yet still effective way of getting input from the player. Unity recently introduced a new way of capturing input which provides a more flexible and effective way of capturing input from our players and we will be implementing this way for the second game of the course. Through the Input system, we will be implementing a movement script for our character.

To improve our movement, we need to dive into the properties available in rigidbodies and manipulate them to find a balance in the player's movement.

To make our movement feel more realistic, we will be using physic materials to reduce the friction on our played from collisions to avoid deceleration and make our player slide around the floor.

Make visual studio and your coding experience feel better by using custom colouring themes over the default ones.

Through user input, we will rotate our player and camera around the Y-axis and allow the player to move around more easily. We will a basic setup which we will later build upon to create a UI menu that will allow us to change the sensitivity of rotating our camera and player later in the lectures.

Adding some colours to our game through the use of materials. This lecture will give a small introduction to how to use materials.

During this lecture, we will be implementing the shooting ability of our player. This will be a starting point upon which we will build at later lectures.

Having a look into the While loop, how to use it and create some examples of how it can be used in a program.

Create a starting point for our enemy script which we will build upon at later lectures. This lecture will introduce the simplest way of making enemies chase our player, which will then be modified to be more sophisticated and clever.

In order to randomly spawn our enemies around our map, we will create spawn points and through a spawning script, we will spawn enemies at random spawn locations every second. During this lecture, we will also be covering ways to debug our code and find errors more easily through.

Making our enemies smarter and allowing Unity's AI to handle the navigation of our enemies based on a Navigation Mesh (NavMesh) we set for it. We will explore the various options available for NavMesh and NavMeshAgents and how to use them.

Now that our enemies can cleverly hunt down our players, it's time to make them have an effect on our players. We will be implementing a way for the enemies to damage our character, as well as the bullets dealing damage to the enemies.

Create a wave system that will be spawning enemies in waves instead of spawning endlessly.

Through the cursor class, we will be setting our cursor to be locked and invisible while running our game in order to prevent the uncomfortable camera movement we saw last lecture.

Extending our mechanics with the addition of various powerups, starting off with the triple shooter which will allow the player to shoot 3 bullets at once for a short period of time.

During this lecture, we will have a look at a loop type similar to the while loop learned earlier called the do while loop, and discuss how and when to use the while loop.

Adding interactions in our game with the addition of portals that the player can use to get out of sticky situations, as well as make our map seem more interesting and interactive. (Apologies for the long lecture :( )

Building up from the previous lecture where we added portals fixed on the map, now we will be making portals that the player can spawn at will anywhere they like.

During this lecture, we will explore a useful feature called raycast, and how we can use it. We will be using raycast to improve our spawning portals to avoid spawning portals in unintended areas.

Currently, our portals feel snappy and very rough to use. During this lecture, we will be resolving this by creating a transition state that will smoothly open and close portals instead of instantly deleting them.

This lecture focuses on coroutines and how we to utilize them for create events in later frames based on time. Through coroutines, we will finalize the portals and have smooth transitions between them.

Adding some much needed sound effects to our game, such as walking on snow, background music, shooting effects etc.

To give our players a purpose and motive to keep on going, we are going to implement a scoring system that will reward players for each kill they make. We will also create a user interface to allow players to track their scores.

Time to move on from simple shapes to a more polished representation of our character using cool-looking models.

The animator component allows us to use multiple animation clips and transition from one another with ease. During this lecture, we will be using the existing animation clips imported with the player and enemy assets to animate both.

During this lecture, we will be creating a script that will randomly spawn pickups around our map using the bounds of our floor in order to spawn them within our map.

During this lecture, we will be having a look at the switch statement, how to use it and when.

Adding more assets to our game to make our pickups glow. By the end of this lecture, our existing pickup will be looking much better than what we had before and we will have everything we need to create more powerups.

Using the assets imported during the last lecture, we create 2 new pickups which will look just as stylish as the existing one.

Modifying our existing code to accommodate the newly created pickups. By the end of this lecture, our pickups will be functioning as expected and be spawned through the pickup generator.

Particle systems are a cool way of adding detail to your games and make them appear more polished. During this lecture we will be discussing what are particle systems and going through the main properties.

Using a particle system, we will be creating a snow effect for our game to create a cold weather aesthetic.

Making our shooting feel more interesting and unique through the use of a trail renderer, with as a result our bullets feeling more polished and refined.

For this lecture, we will be replacing our simple plane floor with a more detailed approach using unity's build-in terrain object.

During this lecture, we will start building our user interface. By the end of the lecture, we will have a health bar UI on our screen to inform our player of their health status.

During this lecture, we will be creating a smooth transition between the main menu and the actual game.

During this lecture, we will be creating an options menu which will be included in our main and pause menu, which will allow users to change various game setting such as the camera sensitivity.

Storing data such as high scores, player settings, preferences, etc. is vital for many games, as if that is not included in a game, players would need to redo their settings every time they played or their high-scores would get erased. During this lecture, we will be looking at ways to store such data on a user's machine.

Implementing the finishing touches for pickups. By the end of this lecture, the pickups will have a visual effect on the enemies (for the freeze power-up) and our player (for the other two).

Replacing the last remaining placeholders which are the enemy spawners and the portals with more interesting models that we will create from scratch.

In order for our spawn portal mechanic to be balanced, we will restrict the player from spamming it endlessly by adding a cooldown timer between each usage of the portal. We will visually represent the cooldown on our user interface along with the health bar implemented in the previous lecture.

An overview of what are post-processing effects, how to get them, and how to use them to improve the visual quality and aesthetic of our scene.

Through the post-processing package, we will apply several post processing effects that will help our game stand out and be more polished.

During this lecture, we will be adding additional enemy variations that will randomly be spawned from our portals along with our existing ones.

Some general final thoughts for our game and discussing more on playtesting.

While in most cases, whenever you are working and finishing up tasks in your game, you would push all changes to the git repo to keep it updated. In our case, we will just upload what we got up to this point and discuss some more available features of git.

A final lecture with some final thoughts. I just want to congratulate you all for reaching the end of this course, thank you for trusting me as your learning instructor and I wish you the best in your future chapters!