If you are having trouble accessing the site, change your pledge currency to USD

Collectible Card Game with Multiplayer


Let's create a collectible card game, covering tops ranging from simple interactions / multiplayer and databases.

Course Lessons
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 block our attacker

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