If you are having trouble accessing the site, change your pledge currency to USD
Souls-like Archive
Course Lessons
Course contains 164 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 tweak our logic for the spells so each spell is responsible for handling it's own particles
Let's create a more optimized way to lock on to targets
Let's create a more optimized way to lock on to targets
Let's create a more optimized way to lock on to targets
Let's add the final touches into our lock on mechanic
Let's make our rotation and movement smooth as butter
Let's polish a bit our lock on mechanic, adding custom transform lock and fixing a few issues
Tired of holding your weapon with one hand? Try using both! ™
Let's change weapons from our quickslots part 1
Let's change weapons from our quickslots part 2
In this part I'm going to show you how to convert our project to utilize the ECS. Keep in mind that on some aspects we're not utilizing all the advantages of the ECS but because of our previous design pattern we can convert from updating inside MonoBehaviour to ECS. ALSO, they are still in preview mode so a lot (or nothing) might change in the near future.
Let's quickly bring back our damage colliders
Let's fix an error we had with multiple weapons being spawned when we were changing our equiped weapon and create a special damage collider for our unarmed attacks
Let's enable being able to rotate after the warmup and before the impact frames of our attacks, just like dark souls
Let's bring back being able to hit enemies
Let's move the responsibility of what to do when attacking from the item to the item actions
Let's manage how we open/close our inventory screen
Let's see our new item slots setup
Let's start loading references and our items
Let's bring back our combos #1
Let's simplify our combos
Let's setup our BNE to welcome our AI framework next part
Let's create our modular framework for our AI
Let's implement Utility Theory on our AI Framework
Let's see an example of how we can calculate a score for FOV. All of course under Utility Theory
Let's make different AI "states" that worry about (and calculate) different actions. Plus, an optimization example for filtering actions by distance from the player
Let's make a template for our basic attack scores
Let's simplify our AI setup
Let's see the two ways we can aggro enemies as in Dark Souls
Making our enemies being able to hurt us
Let's setup our project's architecture so we can start working on the multiplayer part
Let's make sure we have a game loop for multiplayer etc.
Let's make our connection to the master server
Let's join a room and create our network print and controller instance
Let's start syncing 90% of what we are going to need
Let's handle disconnections
Let's sync the enemies across the network
Let's fix the dreaded AI bug that was making it not move across the network
Let's setup our network loop properly
Let's make sure our rooms get properly cleaned up when joining/leaving
Let's handle room creation, souls style
Let's continue work for our inventory UI
Let's assign items to our equipment slots
Let's add our items back to the controller
Let's fix up our inventory logic that creates multiple instances of items
Let's put the items we select back to our controller
Let's wrap up our inventory for now
This is an optional part, I'll be switching from the paid assets to our beloved boxman
Let's fix our root motion problems
~Technically you can start from this part as well but we are not going to be diving deep into all of the state actions~
Let's rewrite our architecture
