Programming and Game Design for DeckBuilding Games

Create the roguelike deck builder project by organizing folders and importing open game art, then slice sprites to fix transparency for card art and card frames.

Create a card prefab by assembling a canvas with a card, back, and front, adding a ui image, art, and name and description text, then save as a base prefab.

Create and manage prefab variants from a base card to build strike and defend cards, with changes on the base propagating to all variants, while variants stay independent.

Learn to solve the image order problem by using separate back and front card transforms and last-sibling updates based on rotation, within Unity’s canvas and camera setup.

Organize your hand with a horizontal layout group to evenly space cards, using the anchor and pivot to stay aligned as the screen changes.

Create a Unity card holder that manages a cards list with add and remove functions, updates the card count text, and uses tester script with a context menu for testing.

Create and position the deck by attaching cards to the holder via set parent, adjust anchors and pivots, and use tweening with on complete callbacks for smooth movement and stacking.

Learn to move cards between hand, deck, and discard using anchors and pivots, temporarily setting the rect parent to control position, and prepare for future card rotation.

Set and animate card rotations in a deck-building game by initializing each card's rotation, then rotating around the local Y axis as cards move between deck, discard, and hand.

Create a cards controller to manage the deck, hand, and discard pile, and implement drawing by moving the last deck card to the hand, then discarding to the discard pile.

Learn to shuffle the discard pile back into the deck by ordering the discard by a random value, creating a shuffled card list, then moving cards to the deck.

Define interfaces for card effects and implement a damage effect that applies when a card is played. Use get components in children to invoke all effects on play.

Explore implementing a discard-after-playing card effect in a deck-building game, wiring after-play effects to specific cards and testing with a tester simulation.

Implement the new Unity input system to enable player input by creating an input action asset, defining action maps, and wiring actions to a player controller.

Refine the input system UI module to make cards selectable by removing raycast targets from text and frames, enabling click-to-play card selection.

Integrate the input system with pointer down and up handlers to enable dragging a card in the foreground, wiring events to update the dragged transform based on mouse position.

Implement an offset-based card drag that preserves pivot and allows corner grabbing, then use the event system to deselect by setting the selected object and manage movement and rotation twins.

The lecture explains implementing a drag-to-play mechanic for cards: release above a height threshold to play the card, otherwise return it to its saved position, with rotation and movement handled.

Explore adding a delay between card movements in a deckbuilding game using int IDs, a coroutine with waitforseconds, and improved draw and shuffle timing to produce smoother visuals.

Learn to implement automatic shuffling by moving the discard into the deck when empty, wait for the shuffle routine to finish, and correctly handle drawing.

Explore how a card’s effect triggers in a deck-building flow, drawing cards, applying turn effects like poison, and playing cards before enemy attacks, with future state-machine turns.

Develop a unit system with max hp, block, strength, and dexterity using an enum stat type, a serializable stat class, and a dynamic stats list for combat in a deck-building game.

Find unit sprites, remove white backgrounds to transparent, then slice and adjust shadows in the sprite editor, creating a base unit and a variant with correct positioning.

Explore a flexible targets system for deck-building games, converting generic objects into units and handling non-unit targets, with error checks for prefab setup and damage application.

Develop and wire a targeting system for deck-building cards by creating a targeting interface, pairing effects with targets, and managing a targets list for self, player, and card casts.

Implement a targeting system that uses a public targets list and get component to identify the player and enemies, enabling card effects to target the player for powers and heals.

Create a new cleave card that deals eight damage to all enemies and implement a targeting system for enemies, then add the card to the deck and test damage.

Implement a state machine to sequence events in a deck-building game, define a base state with enter and exit coroutines, and manage the current state via a singleton machine.

Add load state functionality by initializing the deck from a cards list, instantiating cards, starting a coroutine to set initial rotation, and drawing five cards.

Initialize a distinct player unit class with max energy, current energy, and draw amount, and set up a turn order queue to manage who plays in a deck-building game.

Implement a turn begin state to decide which unit plays next in a deck-building game, by managing a units queue and using coroutines for safe state transitions.

Explore the recovery state in a deck-building game, where status effects affect enemies and the player's energy resets and cards draw each turn, with coroutine-driven state transitions.

The state machine enforces that cards can be played only in the play card state and on the player's turn.

Add an end turn button wired to the state machine, transitioning from play card to turn begin, recovery, and then the next unit, using Unity UI for interactivity.

Add 2D box colliders to the units and the player, adjust collider sizes to fit sprites, and enable a physics raycaster for click detection in Unity.

Implement a cards-to-play queue and a card sequencer coroutine to ensure cards are played in sequence under a play card state machine with proper targeting and timing.

Introduce a card sequencer that supports multiple effects per card, each with configurable targets, using enumerators and coroutines to sequence effects and manage targets.

Implement a target unit system that allows clicking a unit to set it as the target, using on unit clicked events, a state machine, and yield return targets for selection.

Fix a bug caused by the horizontal layout group that returns cards to hand after playing, and implement selectable unit feedback with pointer enter highlighting to clearly show target units.

design and implement a playability system to determine if a card can be played by evaluating energy requirements against the player's current energy, using a playability interface and component checks.

Implement energy costs in deck-building games by adding a visual energy cost on cards and a change energy effect to deduct energy from the player, with the bash at -2.

Design and implement an energy meter UI for a deck-building game, update the energy display via a controlled property, and encapsulate unit stats with a serialized current energy field.

Learn to implement get stat and set stat methods, safely modify stats, and clamp health with max(0, current HP - amount) while updating play card loops with continue.

Learn to implement a block effect in a deck-building game by adapting the damage logic, applying five block to a defend card, and clearing it at turn start.

Learn how the block system absorbs damage, computes leftover damage, and updates HP and block values in practice within deck-building game design.

Implement victory and loss conditions by monitoring unit hp, handling unit death, and switching to end battle or recovery states when only one side remains.

Create status effects system featuring inflict effects with duration and stacking. Develop an abstract status effect and a stat change effect to modify strength via on inflicted and on removed.

Implement a duration countdown for status effects on the unit game object, handling zero duration, updating on each unit take turn, and removing effects when the duration ends.

Create a flexible damage modifier system using a damage and block enum, a tag modifier delegate, and tests showing base versus modified values in Unity.

Create a reference type modified values with a base and final value, apply it in the damage effect, and adapt modifier tags to use a void delegate receiving modified values.

Apply a percentage status effect by updating the tag system to modify int values with an amount divided by 100, demonstrating a 50% damage increase on a strike.

Separates do attack damage and take attack damage to implement the weak status effect, applying a -25% damage when attacking and managing damage rounding in combat.

Apply the same modifier structure from damage system to block effect, rename to game block, implement modified values, and create a frail prefab that reduces gained block by 25%.

Explore converting stat changes from percentage status effects to tag modifier status effects, implement dexterity and block gains, and refine status effects without durations for deck-building game design.

Change iCardEffect from an interface to a public abstract class, ensure it inherits from Monobehaviour with overrides, and align it with the tag modifier system.

Instantiate status effects, apply vulnerable to targets, and ensure correct effect order so inflict doesn’t preempt direct damage; refactor to use a foreach for card effects.

Explore stacking rules for status effects in deck-building games, designing intensity and duration stacks, and implementing apply logic for bash and vulnerable to ensure correct damage scaling.

Learn to implement a unit death and disable system in deckbuilding games with a dedicated death tag and status effect. Also learn how sprites, colliders, and target list is managed.