Souls-like


In this advanced series we will make a Souls-like game like no other! Hold on to your keyboards, sharpen your mouse clicks and prepare to code...

This series is a "from scratch" series. We will develop the entire game and write all scripts together in the video.

 

For cosmetic purposes, the series uses the following assets:

Amplify Color

Amplify LUT

Low Poly Caves

 

*No promoted assets are used, I use them because I like them, your mileage may vary

 


Course Lessons
Course contains 111 lessons.
In the first part we will learn the ins and outs of Unity's mecanim system to be comfortable working with large volumes of animations

In this part we will create the third person controller which will serve as a base for future features.

To make our animations appear more fluid, we will implement a system that will automatically switch between root motion attacks & non root motion system.

No Souls-like would be missing a quintessence feature, rolling to safety #1

No Souls-like would be missing a quintessence feature, rolling to safety #2

In this part we will start creating the structure for our weapons to make them an item centric action system

Continuing from the previous part, we will work more the structure for our item centric system

In this part we will see a few examples of how our weapons can start affecting enemies.

What's better than one sharp sword? Two sharp swords! In this part we will see how we can reuse the same animations to have a dual wielded arsenal.

Legends say that it engenders passivity but regardless of that, let's see how can we make a shield to protect our player.

For the warrior that feels brave before his doom! Let's see how we can make a parry ability.

Pro tip: In a fight, never turn your back to the opponent. Let's see how we can make the reason for that.

Let's make a tool to be able to create icons right here in the editor.

In this part we will build the UI the player's will see while on the game

This part we will rework slightly our inputs, do some cosmetic touch ups on the animations and build a manager for our enemies

Bringing the Rpg part to the A-Rpg. In this part we will build the base for our player's stats.

In this part we will make the structure for having unique references per item & weapons when it's required. This is a technique to save memory by instancing our items.

In this part we will learn how to use XML to both save and load our inventory. This is an example case, in a later video we deprecate the shown code for something more intuitive.

Continuing from last part, we will see how to make a database using XML.

In this part we will switch from XML to unity's own way of serializing objects, the class Scriptable Object

In this part we will literally do magic! Plus, making the logic to be able to switch items

It's going to get hot in here! Let's utilize the spellcasting system we created last part and see how we can throw fireballs!

Let's see how we can make our spells to have different effects while still being based off of the same logic.

This part is more of "working with what you have" type of video. So™ we will see how we can fix problems into our animations without ever leaving the editor.

Every action has an equal and opposite reaction, although in this case, every action will have a cost and reflect on our player's stats.

In the first of this two parts... part we will create a combo system for our actions so™ that we can attack, right after we attack.

Second part of our combos... part. We finish with the system that allows us to have consecutive attacks.

In this part we will focus on polishing and adding a few extra bits of features on our controller.

In this part we will refactor the base system for our weapons. This way it will allows us to have unarmed actions, so™ if a weapon doesn't have an action assigned, it will revert to the unarmed one.

In this part we will implement one of life's pleasures, consuming items.

In this part we will build the infamous "Kick" feature, plus the ability to make our character do a taunt/gesture. Both quintessential for our Souls-like.

In this part we will build the UI that will later host our equipment and inventory screens. No scripting in this part.

In this multiple parts... part we will build the entire logic for our UI inventory & equipment.

In this multiple parts... part we will build the entire logic for our UI inventory & equipment.

In this multiple parts... part we will build the entire logic for our UI inventory & equipment.

In this multiple parts... part we will build the entire logic for our UI inventory & equipment.

In this multiple parts... part we will build the entire logic for our UI inventory & equipment.

It's not Deja-vu, we did do this already but now we will refactor the logic to include our inventory UI.

It's not Deja-vu, we did do this already but now we will refactor the logic to include our inventory UI.

It's not Deja-vu, we did do this already but now we will refactor the logic to include our inventory UI.

In this part we will make instances of our items so we can only use one per inventory.

In this part we will make instances of our items so we can only use one per inventory.

It's dangerous to go alone, we have swords but what about armor! Let's see what we need to be able to change armor on our player and make the structure for it.

We made the system to change armor, now let's make the infrastructure that will host them as items so we are able to use them in our inventory.

This part we mainly fix previously left bugs concerning our inventory and weapons.

In this part we will fix a few issues on our controller while seeing how to make logic for picking up items. Plus a bit more UI building.

In this part we are going to build the jump logic for our controller and see how we can make our character interact with specific points in our world.

It's a lonely world to go without NPCs. Let's see how we can build the logic for interacting with them, plus their dialogues, plus dialogue branches for quests etc.

In this part we are going to research the AI of a Souls-like.

After we researched a bit how the AI works in a Souls game, we are ready to start developing our own interpretation.

In this part we will introduce an enviroment, add camera collisions to avoid clipping and work a bit further on our enemy AI.

Let's expand our AI to include non humanoid enemies as well.

Let's refactor our code to fix a few bugs that sneaked up on us on the previous versions and also talk a bit about a better structure for our code.

In this part we will create the structure for our project that is going to handle loading and unloading our scenes based on where we currently are.

In this part we will get acquainted with Photon networking and see how we can move around our players via multiplayer.

Let's see how we can do the "traditional" way of doing multiplayer with a lobby and rooms before going to the more specialized Souls networking.

In this part we are going to sync the startup armor and weapons through the instances of players across the network.

Let's pass the weapons and any changes on to our equipment over the network, essentially syncing the entire character!

In this part we will sync everything concerning the controller, plus we would make our players fight each other.

Sit back and relax, this video is mostly showcasing how the structure we have right now is not the best for what we want to achieve. It is still good for traditional multiplayer games but not for a Souls-like.

In this part we are going to refactor the structure for our Multiplayer.

In this part we are going to refactor the structure for our Multiplayer part 2.

This is were our multiplayer room structure starts to become souls-like wink wink

We have level base rooms but we still need to separate what player invades who from the regular phantoms. Let's see how we can do that.

In this part we will write our own prediction for smooth movement over clients, fix a few sync issues we had and tweak our "ghosts"

~You can start from this part as well, however a lot of the things will do will make more sense if you start from part 1~ On this part we will rework the entire architecture to make it cleaner and more efficient

On this part we will rewrite our controller.

In this part we are bringing back our root motion attacks.

In this part we bring back our weapon visualization and action handling

Let's play dress up with our characters again! This time, without dependencies.

In this part we are going to see a better and far simpler way handling our items and loading inventory sets.

Let's make a decoupled lock on system

Let's roll our way to safety yet again

Let's make our Game UI again, but this time from our decoupled data.

Let's put the magic back into our lifes

Let's add the damage logic back to our weapons, plus reaction animations.

Let's get things to the next level. We're going to refactor yet again but this time we are going to introduce a design pattern.

In this part we are going to decouple our input handling and showcase how we can move around

Let's rotate our camera with our new decoupled way.

In this part we are going to clean up a bit more our scripts with more decoupling.

Let's trigger animations on inputs, aka as attack animations

Let's add root motion movement to our attacks

Let's create the logic that will monitor our attack inputs

On this part we are going to clean up a bit our scripts and remove any unnecessary scripts we left pre-refactoring

Let's see how to decouple our rolling #1

Rolling 2 : Rolling harder

Let's bring back our weapons and item handling

Let's see a more streamlined way of handling our resources

Let's bring back our weapons with the new way of handling them.

In this part we are going to refactor the way we handle our attacks for more flexibility and modularity

Let's see creating a new way of handling our attacks without needing to have a destructive workflow with our scripts

Let's make the structure for easily switching actions on our weapons and actions

Let's add a flag for if we want to use power posing on our items or not

Let's enhance our input handling via injections for controller triggers

Let's see how to add set weapons to our UI slots and also create the setup for further more decoupled references

Let's see how to manage Stats in a way that scales.

Everybody was parry fighting...

Those kids were fast as lightning...

It was a little bit frightening...

But they fought with expert timing...

Let's bring back our wearables, this time decoupled

Let's setup the actual wearing of the items now.

Let's import the grounding logic from the ATPC series

Let's bring the movement with angle prediction we created on our ATPC into our Soulslike

Let's fix the kinematic bool when in root motion (a bug) and add some frame independent rotation

Let's see a more modular and highly flexible way to create spells

Let's create our first spell, part one

Let's finalize casting the spells.

Let's finalize our spell casting so we can move on to the spell examples

Let's get pyro-ing

Let's tweak our logic for the spells so each spell is responsible for handling it's own particles