Build a Poker Game in Unity: Complete Development Course

Plan and implement a poker playfield layout in Unity by splitting the canvas into left and right sides, using horizontal and vertical layout groups with subimages for responsive sizing.

Split the poker ui into top, bottom, and sides, create five card slots per hand with a horizontal layout, and center a money pool with a text box.

Create the left side of the poker UI by placing a text box and money pool side by side with horizontal and vertical layout groups, ensuring responsive alignment and stretching.

Explore how to import fonts and create Text Mesh Pro font assets in Unity, tune autosize and font sizes, and test readability in full-screen play for a poker game.

Configure the right side of the poker UI with vertical and horizontal layout groups to organize images, text, and buttons, then refine sizing and colors for 16:9 or 16:10 displays.

Create poker chip buttons on the bottom right in Unity using a horizontal layout, preserve aspect ratio, and add clickable buttons with hover tint and text labels.

Learn to construct the poker UI in Unity by laying out a deal button, left money pool, and right bet amount using horizontal and vertical layout groups, sprites, and text.

Shows building a right-side poker layout with fixed left panel of 240 and flexible right area using horizontal layout groups, anchors, and 16:9 and 16:10 aspect ratios for responsive UI.

Build a two-panel poker UI in Unity by arranging left and right panels with vertical layout groups, fixed and flexible sizes, a money frame, and responsive action buttons.

Create a reusable poker card prefab in Unity by assembling top, middle, and bottom sprites with text fields, enabling click via a button, and saving as a prefab in assets/prefabs.

Create a poker card script in Unity that displays the correct suit and rank using serialized fields, sprites for spades, clubs, diamonds, and hearts, and text fields for rank.

Connect the card script to the card prefab, configure sprites, images, and text components, and organize with headers to ensure consistent prefab updates across duplicates.

Create a poker game flow in Unity by building a deck manager and game manager, initializing a 52-card deck from ranks and suits, and preparing to deal.

Implement the Fisher-Yates shuffle in the game manager to randomize a 52-card deck using a backward for loop and a random index, ensuring correct initialization and testing in Unity.

Add a hand out cards function in the Game Manager to deal five cards to both player and AI from a shuffled deck, using dynamic lists, and test in Unity.

Visualize poker hands in unity by renaming slots, linking card slots to hands, and dynamically instantiating card prefabs through the game manager, using serialized lists and set card visuals.

Visualize dealt cards by adding the card prefab in game manager, rotate suits as needed, test in Unity, and verify eye hand and player hand display in correct order.

Learn to hide AI hands in Unity by showing only the card back, using front and back game objects in a card prefab and a toggle script.

Revise the card prefab in a unity poker game to enable hover and click highlights using tinted overlays, with a transparent card back (card back two) and properly centered visuals.

Wire a public flip function on the card script to toggle between front and back visuals using an isShowingCard flag, enabling click to flip, and disable AI card interaction.

Kick off a poker round by cleaning up the last round, initializing the money pool, ai money and player money, dealing cards with timed delays and message box updates.

Initialize start money to 1000 for all players at the start of each round, then update the AI money, player money, pool, and bet amount text fields.

Implement a poker game state machine in Unity using an enum to define states like round start, hand out cards, betting rounds, and check winner, switching with a switch statement.

Initialize a new deck and clear hands at round start. Deduct ante from each player, update the money pool, and prepare to deal cards as the game proceeds.

You modify the poker ante state to use the ante money variable instead of a fixed value, updating the money pool by twice the ante via the game manager.

Initialize and shuffle the deck, then hand out cards to the player and AI one by one using a coroutine with time delays, updating visuals and transitioning game states.

Recap the poker game's time-based state machine: start rounds, wait three seconds with a timer, then ante, deal cards, and enter betting states with AI and player input.

Explore betting state logic and implement an AI-driven hand evaluation that scores hands and supports decisions, including high card, two pairs, and other poker hand rankings.

Continue hand evaluation by building booleans for straight, flush, four of a kind, and full house, then implement is_straight and rank values retrieval.

Learn to implement poker hand evaluation in Unity, ranking from high card to royal flush. Use rank counts to detect one pair, two pairs, straights, and flushes.

Evaluate poker hands and compare player and AI scores to inform betting decisions. Debug hand evaluation, visualize results, and decide raise, call, or fold based on the score.

Learn to manage poker user interface in Unity by activating and deactivating action and bet buttons (round start to betting state) using serialized fields and click handlers in Game Manager.

Wire up poker user interface by linking raise, call, fold, deal, and chip buttons to the game manager, set onClick events, and toggle button states based on game phase.

Implement the fold button to deactivate inputs, transfer the money pool to the player, clear cards, and start a new round with updated pool UI.

Enable poker raise buttons in Unity by checking player funds against bet amounts (5, 10, 25, 50) in the Game Manager, guiding AI decisions.

Create a function to pass bet amounts and wire up five, ten, twenty-five, and fifty dollar chips in Unity, updating the bet amount pool and deducting from player money.

Implement an AI decision function that evaluates the AI hand, factors the player bet, and decides to fold, call, or raise, updating the money pool and bets accordingly.

Implement and test the deal and call logic to drive AI decisions, update money pools and bets, and disable actions to prevent multiple moves.

Update AI decisions in the poker game by tuning hand-value based logic, leveraging player bets to adjust raises and calls, with debugging notes and state-driven actions in the game manager.

Uncover how the Unity poker module integrates player bets with AI decisions, implementing call, raise, and fold logic, updating the money pool and player balance after each deal.

Implement the player discard and draw flow, flip non-face cards, use the deal button to confirm discards, and enable AI to re-evaluate and discard cards.

Implement the discard phase by removing selected cards from the player hand using discarded indices, destroying their game objects, and updating the deal button and game state.

Draw new cards for the player after discards by computing cards needed from discarded indices, drawing from the deck, and updating the player hand and slots.

Implement the AI discard logic in a Unity poker game by evaluating the AI hand and returning the indices of cards to discard during the draw phase.

Learn AI decision making for discarding poker hands in Unity. Update the game manager to identify cards to keep or discard, targeting three of a kind and two pairs.

Implement and test the AI discard and draw flow in the discarding state, sorting discarded indices and updating the AI hand with new cards in Unity.

Implement and manage betting rounds in a Unity poker game, including discarding, AI decisions, and dynamic button states for raise, call, fold, and deal.

Learn to transition from discarding to betting round two in a Unity poker game, manage button interactivity, trigger state changes, and determine winners through the check winner state.

Fix a bug in a Unity poker game where bets aren’t returned when the AI folds, by updating the money pool before the AI decision and then resetting the pool.

Evaluate both players' hands, determine the winner by score or high-card tiebreakers, reveal all cards, then pass the pot to the winner and update the pool and UI.

Deactivate all buttons and reveal the AI hand to determine the winner. Compare hand ranks, resolve draws, and finalize the pot through bets, raises, calls, and discards.

Learn to start new poker rounds in Unity by updating the deal button text, enabling controls, and guiding the game state machine to determine the winner and handle game over.

Develop a break-tie function to determine the winner between two poker hands by ranking royal flush to high card, sorting card ranks, and comparing groups for pairs and multiples.

Learn to implement a dynamic info message system in a Unity poker game, including a serialized text box, a set-info function, and round-by-round AI and player updates.

Implement a robust game over flow in a Unity poker game, enforcing ante payments and bankrupt checks, and presenting a panel with retry and back to menu options.

Design a Unity poker game main menu by building a scalable two-dimensional UI with background, title, and button panel, using vertical layout, content size fitter, and responsive cards.

Create a Unity menu buttons script to load scenes, restart the current scene, exit the game, and open URLs, while wiring UI elements for menu navigation.

Fixes for the Unity poker AI: correctly update money and money pool on raises, and prevent game over when AI has zero funds by adding conditional calls.

Clean up the poker project by removing debug logs, verify buttons and menu, and test gameplay against the AI. Add visual polish with shadows and tinting before web build.

Create a web build of your poker game by enabling WebGL build support in Unity Hub, configuring build settings, and packaging as a web-ready HTML/zip for itch.io.

Recaps building a Unity poker game with UI layouts, card prefabs, and data binding; implements a state machine, deck handling, and AI decision rules, plus sounds and extended graphics.