Unity 6 & C# Programming Crash Course For Complete Beginners

Being good at programming, like with any skill, requires to have the right mindset before jumping in. This will give you an edge and help you manage your expectations. Being a good programmer is not as hard as you may think, and not as easy either.

When learning programming, you're doing so with the aim of creating programs. Let's discover what a program is under the hood.

Learn how programs are organized and the difference between a simple program and a game.

Let's understand variables, and let's talk about some common C# variable types like int, float, string, and bool.

Learn why official documentation matters and how to use it alongside courses, tutorials, and AI tools.

Let's understand object-oriented programming, and the differences between classes and objects, and why the C# language uses these concepts.

Let's discover what actually happens to our C# code on the Windows platform and on Unity, and let's install Visual Studio so we can get started applying what we previously learned.

Let's create our first program in C#!

Let's take a closer look at the if else statement and how it can be used to allow our program to make decisions.

Let's use methods to organize our code and discover how to define and call them.

Manipulating a variable with a single value is great, but sometimes we want to store a lot of values in that variable, and the way to do it is to use arrays and lists, this opens a whole new universe of possibilities for implementing lists of enemies, inventory systems and so on.

Let's solidify everything we've learned so far by creating a calculator app. This is an important exercise where you're asked to write your own solution. Watching the videos in a passive way is not going to help you learn much, it's only by doing that true learning can happen.

In this video we're going to see one way to making the calculator app, this is not the only way and you're invited to come up with your own improved solutions.

Let's see how to create classes and instantiate objects, this lecture comes after discovering these concepts in a theoritical way, now let's apply that knowledge and actually start creating our own types!

Let's understand the two main ways with which classes can be related to each other: inheritance and composition.

Let's understand the importance of access modifiers, not only in game dev or software dev but in modern day technology as well. This powerful concept will allow you to create incredibly complex systems while keeping these systems working properly as they should.

Let's discover properties, which are a powerful combination of simple fields and methods.

Let's create our project in Unity and discover more about the editor.

Let's import some 3D models into our project and use them to create a small level where we'll make our first gameplay mechanics.

Let's apply the abstract concepts that we learned in the previous lecture to a real example inside of Unity.

Let's apply what we learned to animate a coin with a C# script.

Handling keyboard, mouse, gamepad and touch input using the input system (also called input package) in Unity.

We'll learn how to handle movement in a basic way, then how to use the CharacterController and leverage its power to make our character move.

Let's animate our character using the Mecanim animation system in Unity.

So far the camera has not been following our player character, let's fix that with the help of Cinemachine.

Answering your questions about the CharacterController's step offset, the input system's PlayerInput, how to use the source files and how to build your project to create an executable file.

Let's make our character collect coins and discover the concept of triggers in Unity.

Let's see how we can play sound effects in Unity, we'll play a sound effect when we land and when we collect a coin.

Let's use the Unity Shuriken system to create some eye-catching visual effects. We don't have to create them from scratch, we're going to download Unity's official particle pack and customize it to our liking.

Let's detect when the player lands and display a visual effect accompanied with a sound effect.

Let's make the game more challenging by adding a spike trap that hurts the player when they step on it. We will make a basic version and improve it later in the course. The same knowledge that we apply to create this trap can be used as a foundation to create other traps in your game.

What's a good adventure game without a health system? Now traps are going to be more dangerous because they can actually hurt you.

Let's handle our health points dropping below zero, since the player isn't a zombie, they shouldn't be allowed to walk after they die.

Let's kill our player character when they fall below the ground surface.

When our player dies, we're kind of stuck. Let's add a nice game over screen with a restart button to keep the game going.

The camera shouldn't follow the player when they fall through a bottomless pit, it doesn't look great, let's fix that.

Let's display hearts on the UI like in Zelda games or in the Binding of Isaac

Let's keep track of how many coins the player has collected and how many coins are left.

We have a nice gate model in Kenney's model pack, let's open it and allow the player to exit when they've collected all the coins in the level.

Our spike trap is basic and a bit unfair, it hurts the player as soon as they touch it. Let's add a delay to give the player a small window to walk away, let's also create another kind of spike traps: continuous tracks activated with a timer.

Let's add a big pole with blades poking out of it, it spins all the time and sometimes blocks corridors, enough to make the player sweat. This traps will add more tension (and fun challenges) to our levels!

A pause menu is important to have, especially in action adventure games where a lot is going on, let's give our players the chance to pause the game to go grab a sandwich or some orange juice.

Let's add a main menu, where our character is dramatically bending the knee in front of a trophy and let's have a burning forest in the background. Because why not! What we're actually doing is building a framework to turn our level scenes into a coherent and complete game, now you can keep adding more levels and content, and they'll all be part of the bigger game where the player is going to play one level after the other.

Let's discover the power of coroutine, who look, feel and behave like regular methods, but with some extra capabilities.

Loading a scene may look instantaneous, but that's just because the content in our scenes is light and easy to load, as we add more objects and scripts, loading will take longer, and to the player, it may seem like the game is frozen, let's fix that by using coroutines and creating a loading screen.

Let's add a sprinting mechanic to allow the player to run away from traps and enemies, and move faster overall.

We reached the limits of our follow camera now that the player can sprint, the stiff camera movement doesn't feel good, let's fix it by using a different camera from Cinemachine.

The player character goes from a speed of 0 to the walking speed instantaneously, let's add acceleration and deceleration to make the movement smoother.

Let's limit the duration of our sprint mechanic by introducing a stamina bar and displaying it on the HUD.

Let's show some post-processing effects and make our screen black and white when stamina is low. This element of feedback will further warn the player that their stamina is low, therefore they cannot perform the tasks that rely on stamina like sprinting.

Let's create a rolling animation with Unity's animation tools.

Let's make our character lunge forward and roll, this is going to be useful to dodge enemy projectiles and traps.

Let's make the player invincible while rolling, this opens new possibilities in evading traps and puzzle solving. We're also going to flesh out the stamina bar and make it more polished thanks to an intermediate bar.

Before we dive deeper into our game mechanics, let's learn the concepts of inheritance and polymorphism, which are at the heart of object-oriented programming.

Let's create a system that allows us to implement various pickup objects starting with our coin as a reference. This lecture is an overview of what we're going to accomplish in this section.

Let's discover Unity's physics engine and build some objects that we can use later as pickups.

Let's create a base class that we can use for all our pickups, with methods to express whether an object can be picked up or not, and what happens when the player picks up the object.

Let's create scripts to spawn VFX and play sounds whenever a pickup is collected by the player.

When a pickup cannot be collected, it would be nice to have the player push it aside. Let's discover how to achieve that, and also fine tune our collisions thanks to layers and the collision matrix.

In most top-down platforming games such as the Super Mario 3D World series, the game casts shadows from an overhead light, this allows the player to easily read the level, and guess where they should jump using shadows as a reference. Let's achieve that and fix some issues with the lighting.

Let's create an inventory system to store some of our picked up objects.

Let's display the items in our inventory on the HUD. We'll also make sure our keys are drawn first since they are an important part of gameplay.

Let's upgrade the icons of our HUD for more clarity and animate the health UI to add more personality to our game.

Closing thoughts about the previous lectures and where to go next.