Creating Game Mechanics with Unity

We'll start creating the game by breaking down its mechanics. This would help guide us in what we need to do to complete the game.

Our first code! We will be programming our plane's movement in our 2D screen and also handling how to clamp its movement to the viewport.

This is an additional lecture, a lecture that only provides additional information. You can skip this lecture because anything inside this lecture will not be used in our game. In this additional lecture, we'll learn another way to move our plane (with physics).

We'll continue with creating our first bullet in the game. We'll see how to implement the bullet movement in regards to its rotation and also destroying it on leaving the screen.

We'll incorporate our bullet to a shooting logic in this lecture. We'll learn how to use Object Pool to manage our spawned and destroyed bullets.

We'll now see how we can deal damage with our bullets. We'll learn how to handle collision trigger in this lecture. We'll also see Coroutine used for the first time.

We'll dive a little inside Coroutine that we learnt before. Just a little more if you are interested in it.

We'll see how to adjust our Plane Movement script to create the movement for our enemy in this lecture.

We'll fix the weakness of our previous clamping logic in this lecture.

The most exciting part about bullet hell, "Bullet Pattern". We'll see how to implement Bullet Pattern for our enemy in this lecture.

We'll fix my mistake in our enemy movement code in this lecture.

In this lecture, we'll see how to implement 3 more bullet patterns with different shapes.

Our first UI! We'll implement a simple health bar for our player in this lecture.

We'll try to solve a bug with bullet objects not being destroyed when our enemy dies.

We'll implement state machine for our enemy so they can adjust to the current state of the battle.

Enemies will have body parts that can be destroyed individually. This lecture will go through how to create those body parts.

Player can also have body parts too with each body part has their own attack logic.

Defeating enemies will grant us scrap, the currency in this game to buy more body parts. We'll see our first Singleton in this lecture.

Now we will encapsulate our battle in what's called "Stage", with each stage having its own enemy.

In between stages player can now see a UI that tells the next stage. Another UI implementation in this lecture.

We'll see how we can implement levels for our body part so player can upgrade it between stages.

This is where player will be able to craft and upgrade their Body Parts. We'll learn how to create another UI in this lecture.

This is a short lecture to give information about how to replace our scripts. This will be useful in the next lecture where we will reorganize our scripts.

We will tidy up our project in this lecture and also add some polishing to our game. Good job for making it this far!

We'll start again by breaking down the mechanics for our Ninja Flappy Bird.

We'll try to replicate a simply physics for our Flappy Bird Jump Movement in this lecture.

We'll start managing our game flow early for this once, instead of doing it in the back like we did in Space Invader.

A little polishing to our jump movement!

We'll create a way to manage classes that we use a lot in our game.

Our bird will be able to move horizontally in this lecture as it goes through infinite amount of rooms. We'll also implement obstacles here.

We'll add another logic to control the speed of our room movement in this lecture.

Now's the fun part! We will try to create a slash attack for our bird.

We will utilize the slash attack from the previous lecture to allow our bird to slash the obstacles in our game.

We will try to create more obstacles with different movement and logic in our game.

We'll try to implement a layer on top of Unity's input system to manage our own input.

We'll create a custom timescale system to control the timescale of our Flappy Bird game.

We'll create another UI now, this one is more unique, a radial menu that we'll use for our power-ups.

We'll lay down the foundation for using our Power-ups in this code. No Power-ups yet, but this would make creating and testing Power-ups easier.

Finally! We'll create our Power-ups. One more game done!

Let's again, break down this game's mechanic. This breakdown is longer because I'll also explain how Gwent works.

Card Games need Card Data, we'll use Scriptable Object to implement our cards!

This will be a long one! We'll create our deck and also our deck creation UI in this lecture.

We'll prepare for the implementation of Gwent Gameplay by creating the data structures that we're gonna use in our game.

We'll utilize our data structures to create the UI for our game. Little more to the gameplay!

Finally! We're gonna start implementing our Gwent Gameplay by implementing the flow of sessions.

We'll implement more mechanics for our Gwent in this lecture and more UI!

We'll prepare ourselves to implement weather card by implementing strength modifier for each of our unit cards.

We'll see how we can incorporate weather cards into our Gwent gameplay through previously created strength modifier.

Card Games rely on the abilities of their cards! We'll implement a few card abilities for our unit cards.

Last missing piece for our Gwent Gameplay, leader card. Let's implement it!

To end our lectures and our course, we'll top our game off with an AI. We'll learn how to create an AI that can fight with us in the game.

Thank you for your hardwork until now! See you in other places!