Create an Auto Battler Card Game on the Flow Blockchain

Set up a new Unity project, configure universal 2d core, organize folders for scripts, images, prefabs, and scriptable objects, and create a menu scene with a scalable background UI.

Design a reusable UI container on the canvas in Unity, create prefab buttons, and manage scenes with a scriptable object-driven load scene flow from menu to draft to battle.

Add and configure buttons using prefabs, place a quit button in the container and a draw button in the draft scene, wiring quit and draw actions with debug logs.

Set up a bottom-anchored hand using a horizontal layout to display draft cards. Build each card with background, outline, character image, name and description, plus health and attack indicators.

Create a Unity UI card script to update name, description, stats, and the character image using serialized fields, a character class, and a scriptable object with a sprite library.

Implement a draw feature by modeling game state (hand, turn, tier) and a static game data class that loads local characters via resources for tier-based randomness and name lookup.

Demonstrates building a static game manager in C# that draws cards to a hand from a tier-aware pool, using string interpolation and Unity resources for game data.

draw ui demonstrates instantiating card prefabs into the hand and setting each ui card from character data on game state updates.

Learn how to implement draggable cards in Unity by wiring a drag handler and pointer events, calculating an offset, and snapping cards back to their hand when released.

Implement a five-slot battlefield with a card controller that tracks the current card being dragged, supports drag-and-drop, and highlights slots on overlap.

Create a character prefab by unpacking and renaming the card prefab, removing backgrounds, and wiring up health, attack, and tier with a dedicated UI character script in Unity.

Explore game architecture with a central game manager that drives the UI through the game state, and consider refactoring toward a model-view-controller design.

Refactor the game state handling by introducing a public hand property that invokes on game state updated when the hand changes, and updates UI to listen to the game state.

End the drag when the pointer is released, then update game state using the hand index and field index by calling play from hand to field, leveraging the sibling index.

Drag cards from your hand to battlefield slots and manage a dictionary mapping slots to characters. Create and update the battlefield state while reflecting changes in the user interface.

Render the battlefield by creating a UI field and instantiating character prefabs for each slot, updating on game state changes and positioning via the card controller.

Fix bug preventing dropping onto occupied battlefield slots and enable character drag to move between slots, using start and end indices, and swap logic in the game manager.

Implement a mana system to play from hand and draw, starting at 11 mana and spending 1 for draws and 3 for plays, with turn and tier derived from formula.

Create a battle field layout by building a battle canvas with player and enemy zones, arranging UI images, pivots, and alignment for clear combat visuals.

Unpack the character prefab to create a battle character and disable dragging. Attach a UI battle character script with a unique id and core fields like attack and health.

Build a two-team battle system with named teams and character lists, a battle state that renders user interface updates via an observer pattern using uid-based battle characters.

Create a battle manager in unity to render battle states, test battles via editor context menus, manage player and enemy teams, and implement clone and flip mechanics for dynamic combat.

Orchestrate a two-team battle simulation in the battle auto class, pitting front battle characters, ordering attacks by highest attack, applying damage, and removing defeated characters.

Add a clone constructor to the team class to duplicate a team and its battle characters, and implement a battle states system that logs actions and updates states during play.

convert the action delegate to an event for safer event handling in battle auto, initialize via constructor, and log initial and defeated battle states while rendering the battle outcomes.

Create a battle over screen using a UI panel and TextMesh Pro to display win, loss, or draw, while tracking lives and victories in game state.

Create an auto battle playback by building a battle coroutine that renders each state, waits between steps, and loops for smooth, debuggable play.

Convert characters to battle characters in the draft scene and seed teams to the database. Create a script that draws on start and seeds turn-one teams named from battle characters.

Execute a battle within the game manager, assemble player and enemy teams, and update the game state with the final battle state (won, lost, or drawn) via battle auto.

Implement a proper battle method in the battle manager using a coroutine to synchronize battle state with UI. Fix rendering timing with end-of-frame waits and reset mana each turn.

Begin Flow blockchain development by installing the Flow CLI, scaffolding a TypeScript web app with Next.js, and running a local emulator to deploy and query a hello world contract.

Define a minion struct in a Flow smart contract to model game characters with name, description, tier, attack, and health, and provide an initializer and a public array of minions.

Display minions on the on-chain minions array by querying the Flow smart contract and rendering a table with name, description, attack, and health.

Deploy your hello world contract to Flow testnet, create a testnet account, update deployments in flow.json, and connect a testnet wallet like Flipper to fund and use it in Unity.

Install the Flow Unity SDK, import samples, and fetch minions from a Flow smart contract on testnet using cadence scripts, then load characters asynchronously into Unity for gameplay.

Demonstrate end-game flow by simulating turns, tracking lives and victories, and loading the main menu or draft scene. Implement a reset when lives are zero or victories reach three.

Complete a challenging course on building an auto battler for the Flow blockchain; this lecture highlights security improvements for the Flow smart contract and a cloud-based team database.

Install Unity Hub and the editor on macOS and Windows, set Visual Studio Code as the editor, and enable WebGL build support with the Universal Render Pipeline.

Design the Unity editor setup by creating a 2D URP project in Unity Hub, choosing a two-by-three layout, docking the console, and organizing assets into scenes and scripts.

Learn to create a 2D ball in Unity, add Rigidbody 2D and colliders, configure gravity and a physics material, and build a simple level with walls for bouncing gameplay.

Attach a Unity script to a ball, set an initial velocity on Rigidbody2D, and adjust the bouncy material to zero friction so the ball bounces off walls.

Explore how a scene organizes game objects using transform, camera, and sprite components, with a main scene containing a ball, level, and a simple ui overlay.

Explore how to control a 2D ball in Unity using a Rigidbody 2D, velocity vectors, and serialized fields to expose variables in the editor, making initial velocity easy to tweak.

Complete your Unity basics and begin a real project to build an auto battler card game on the Flow blockchain.