Try out the SA Tool Manager! Patreons get extra free tools!
Collectible Card Game with Multiplayer
NOW PATREON EXCLUSIVE
Let's create a collectible card game, covering tops ranging from simple interactions / multiplayer and databases.
Course contains 63 lessons.
Let's see how our cards will look
Let's see where our cards will shed blood!
Let's see the architecture for our cards
Now let's do the card setup the proper way, with dynamic card elements
Let's see how to have different card types and doing it dynamically so we can add or remove types without hassle
In this world dominated by clicks, we need to know what is actually clickable and how to encapsulate all that logic.
Let's encapsulate further with the strategy pattern thus making different context for the same scripts
Let's write the logic for assigning our current card
We need multiple sub states on the current state of the player, let's make a finite state machine (though without visualizing it for now)
Let's create drop areas with different contexts
Let's build the architecture for holding player data and usage
Let's create the architecture for our game Turns and their phases.
Let's take some time and visualize the current phase for our own sanity.
Let's create the "resource card" type where it's going to be our virtual coin for the match.
Let's start stacking our resource cards
Let's start building rules for our game. First off, every card will have a cost which when played consumes a resource card for this turn.
Let's create logic for switching player holders and ending turns / phases
Let's create a console to log events
Let's add more logic to our phases to know if we can skip them or not
We need to wait a turn to use cards we just dropped, thus we need to create the logic for "flatfooted" cards and resetting them
Let's select which cards are able to attack this turn
Let's setup the stats for each player and how we load/visualize them
Let's battle it out with our enemy, #1
Let's battle it out with our enemy, #2
Let's multiplay with our selves locally
Let's make the logic that will allow us to pick a new card from our deck
Let's make a place to put our dead cards
Let's prepare a few things to start working on our multiplayer
Can't have a match without an opponent.
Let's start syncing references and creating the setup for an actual match to start
Let's synchronize the turns for all players across the network
Let's sync card operations on our network, this is a major step forward for building the multiplayer parts of the game. We also have authoritative card instances and operations
Let's sync using our creature cards over the network
To battle! Which is now also synced across clients
Let's sync our battle resolve phase across clients
Let's sync our block logic for the attacking cards
Set phases to auto, we need to do some fixing!
Let's refactor how we handle our turns
It's not a Star Wars title, it's actually a new refactor! I explain my reasons in the video :D
Let's see how we are going to be picking up cards
Let's start building our game logic
Let's see how to handle the interactions with the game area and our cards and change our approach from object based references to Id ones
Let's start building our turn system around operations
Let's setup our cards and their different behaviors by type
Let's bring back our combat mechanics!
Let's try and fix our mouse issues #1
Let's setup a better framework for battle instances
Let's create some artificial intelligence for our game
Let's create the block phase now!
Let's see the first steps into having a multiplayer game and create our first RPCs
Let's send messaged via the network
So let's see how to make a deck builder for the game
Let's sync our decks across the network
Let's fix the deadlock that's happening when two players are starting combat and one can block
Let's synchronize our block over the network