# BlackjackDealer

### Overview

The `BlackjackDealer` component defines the **server logic** for a Blackjack table.\
It controls the game flow by sequencing timed **phases**, updating **network-synced states**, and communicating all visible game events (such as dealing cards) to connected clients.

It ensures fair gameplay and consistent synchronization between players by enforcing server-side rules and managing all card draws via the shared shoe.

***

### Core Responsibilities

* **Round Lifecycle Management** - Handles the sequence of all game phases (betting, dealing, player turns, dealer turn, resolution).
* **Card Dealing & Visibility** - Deals cards to each seated player and to the dealer, ensuring hidden cards are correctly represented on clients.
* **Server-Authoritative Control** - The dealer runs exclusively on the server; all actions, timers, and transitions are verified and executed there.
* **Table Integration** - Accesses `BaseTable` to draw cards from the shoe, read seat data, and update `TableState` and `SeatState` objects.
* **Rule Enforcement** - Uses `BlackjackRules` to validate blackjacks, busts, and payouts (including multipliers).
* **Client Synchronization** - Sends targeted Mirror RPCs to update each player’s hand, reveal cards, and synchronize visual states.

***

### Phase Lifecycle

The `BlackjackDealer` progresses through several **timed phases** during a round.\
Each phase is server-controlled, using coroutines to manage durations and automatic transitions.

| Phase                | Enum                            | Description                                                                          |
| -------------------- | ------------------------------- | ------------------------------------------------------------------------------------ |
| **Idle**             | `BlackjackState.Idle`           | Table is inactive; no players or game running.                                       |
| **Waiting for Bets** | `BlackjackState.WaitingForBets` | Players can place their bets before the round begins.                                |
| **Dealing**          | `BlackjackState.Dealing`        | Dealer distributes two cards to each betting player and to themselves.               |
| **Evaluate**         | `BlackjackState.Evaluate`       | Checks for natural Blackjacks before player turns begin.                             |
| **Player Turn**      | `BlackjackState.PlayerTurn`     | Each player makes decisions (hit, stand, double, split).                             |
| **Dealer Turn**      | `BlackjackState.DealerTurn`     | Dealer plays automatically according to rules (hit until 17, etc.).                  |
| **Resolution**       | `BlackjackState.Resolution`     | Winnings and losses are calculated, balances are updated, and the next round begins. |

The phase system uses the `StartPhase()` method to initialize a new state, paired with a coroutine countdown for its duration. When a timer expires, the dealer transitions automatically using `NextPhase()`.

***

### Example Flow

1. **Init** - The dealer shuffles the shoe and waits in idle mode.
2. **Betting Phase** - Once at least one player joins, the dealer starts the betting phase.
3. **Dealing Phase** - Dealer distributes two cards to each betting player and to themselves (one card hidden).
4. **Evaluation Phase** - Natural Blackjacks are detected; immediate payouts or pushes occur.
5. **Player Turns** - Each player acts within a fixed time window (hit/stand logic to be implemented).
6. **Dealer Turn** - Dealer reveals hidden card and plays according to house rules.
7. **Resolution Phase** - All hands are compared, results paid out, and the table resets for the next round.

***

### Server Integration

The dealer depends on the `BlackjackTable` for data access and state synchronization:

```csharp
[SerializeField] private BaseTable table;
```

This gives access to:

* The `Shoe` for card draws.
* The list of active `Seat` objects (each representing a player).
* The networked `TableState` for synchronized updates.
* `BlackjackRules` for rule logic (via `table.Rules`).

***

### Communication with Clients

Mirror’s **TargetRPC** calls are used to send card information and reset events to players:

* `TargetAddCardToHand()` – Adds a card to a specific player's hand.
* `TargetAddCardToDealer()` – Updates the client’s dealer hand view.
* `TargetResetPlayer()` – Resets a player’s state for the next round.

Cards are sent as network-safe `Card` structs; hidden cards are represented with\
`Suit.Hidden` and `Rank.None` until they are revealed later.

***

### Summary

The **BlackjackDealer** is the **state machine** and **execution engine** of the Blackjack game.\
By keeping all logic on the **server**, and using **network-synced DTOs** for communication, it guarantees fairness and scalability across multiplayer environments.

It is designed to be **modular**, **expandable**, and reusable for other dealer-based card games (like Baccarat or Three Card Poker), by following the same `BaseTable` and `IDealer` interfaces.


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.uvegas.online/games/blackjack/components/blackjackdealer.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.