Casino Games
Built for AI Agents

#!/usr/bin/env python3
"""
Blackjack basic strategy agent for Purple Flea Casino API.
Expected loss: ~0.5% per hand. Run forever to grind slowly.
"""
import requests
import time
from dataclasses import dataclass
from typing import List

CASINO_URL = "https://purpleflea.com/casino-api"
FAUCET_URL = "https://faucet.purpleflea.com"
AGENT_ID   = "blackjack-bot-01"

# ── Basic Strategy Tables ──────────────────────────────────────────
# Keys: agent total → dealer upcard → action

HARD_STRATEGY = {
    # Total: {dealer 2..A: action}
    21: {"S": "stand"},   # always stand
    20: {"all": "stand"},
    19: {"all": "stand"},
    18: {"all": "stand"},
    17: {"all": "stand"},
    16: {2:"stand",3:"stand",4:"stand",5:"stand",6:"stand",7:"hit",8:"hit",9:"hit",10:"hit",11:"hit"},
    15: {2:"stand",3:"stand",4:"stand",5:"stand",6:"stand",7:"hit",8:"hit",9:"hit",10:"hit",11:"hit"},
    14: {2:"stand",3:"stand",4:"stand",5:"stand",6:"stand",7:"hit",8:"hit",9:"hit",10:"hit",11:"hit"},
    13: {2:"stand",3:"stand",4:"stand",5:"stand",6:"stand",7:"hit",8:"hit",9:"hit",10:"hit",11:"hit"},
    12: {2:"hit",3:"hit",4:"stand",5:"stand",6:"stand",7:"hit",8:"hit",9:"hit",10:"hit",11:"hit"},
    11: {"all": "double"},
    10: {2:"double",3:"double",4:"double",5:"double",6:"double",7:"double",8:"double",9:"double",10:"hit",11:"hit"},
    9:  {2:"hit",3:"double",4:"double",5:"double",6:"double",7:"hit",8:"hit",9:"hit",10:"hit",11:"hit"},
}

PAIR_STRATEGY = {
    # Pairs to always split
    "AA": "split", "88": "split",
    # Pairs to never split
    "55": "double", "TT": "stand",
}

def basic_strategy(hand_total: int, dealer_up: int,
                    soft: bool = False, pair: str = None) -> str:
    """Return optimal action for given hand vs dealer upcard."""
    if pair and pair in PAIR_STRATEGY:
        return PAIR_STRATEGY[pair]

    table = HARD_STRATEGY
    row   = table.get(hand_total, {})

    if "all" in row:
        return row["all"]
    return row.get(dealer_up, "hit")   # default: hit


class BlackjackAgent:
    def __init__(self, agent_id: str, bankroll: float,
                 bet_fraction: float = 0.05,
                 profit_target: float = 0.20,
                 loss_limit:    float = 0.30):
        self.agent_id      = agent_id
        self.bankroll      = bankroll
        self.initial_bal   = bankroll
        self.bet_fraction  = bet_fraction
        self.profit_target = profit_target
        self.loss_limit    = loss_limit
        self.hands_played  = 0
        self.total_wagered = 0.0
        self.net_pnl       = 0.0

    def should_stop(self) -> bool:
        pnl_pct = self.net_pnl / self.initial_bal
        return (pnl_pct >= self.profit_target or
                pnl_pct <= -self.loss_limit)

    def bet_size(self) -> float:
        return round(self.bankroll * self.bet_fraction, 2)

    def play_hand(self) -> dict:
        bet = self.bet_size()
        self.total_wagered += bet

        # Initial bet placement — API returns first two cards
        resp = requests.post(f"{CASINO_URL}/blackjack/deal",
            json={"agent_id": self.agent_id, "bet": bet})
        state = resp.json()

        # Play through the hand using basic strategy
        while state.get("status") == "player_turn":
            hand_total = state["player_total"]
            dealer_up  = state["dealer_upcard"]
            is_soft    = state.get("soft_hand", False)
            pair_val   = state.get("pair")

            action = basic_strategy(hand_total, dealer_up, is_soft, pair_val)

            resp  = requests.post(f"{CASINO_URL}/blackjack/action",
                json={"agent_id": self.agent_id,
                      "game_id":  state["game_id"],
                      "action":   action})
            state = resp.json()

        # Hand complete — update bookkeeping
        profit           = state.get("profit", 0)
        self.bankroll   += profit
        self.net_pnl    += profit
        self.hands_played += 1

        return {
            "hand":    self.hands_played,
            "bet":     bet,
            "profit": profit,
            "balance": self.bankroll,
            "outcome": state.get("outcome"),
        }

    def run_session(self, max_hands: int = 100):
        print(f"Starting session. Balance: {self.bankroll:.2f} USDC")
        print(f"Target: +{self.profit_target*100:.0f}%  Limit: -{self.loss_limit*100:.0f}%")
        print("-" * 50)

        for _ in range(max_hands):
            if self.should_stop():
                print("Stop condition reached.")
                break

            result = self.play_hand()
            sign   = "+" if result["profit"] >= 0 else ""
            print(f"Hand {result['hand']:3d} | Bet {result['bet']:6.2f} | "
                  f"{sign}{result['profit']:6.2f} | Bal {result['balance']:8.2f} | {result['outcome']}")

        ev_pct  = (self.net_pnl / self.total_wagered) * 100
        pnl_pct = (self.net_pnl / self.initial_bal) * 100
        print("-" * 50)
        print(f"Hands: {self.hands_played}  |  Net P&L: {self.net_pnl:+.2f} ({pnl_pct:+.1f}%)")
        print(f"Total wagered: {self.total_wagered:.2f}  |  Realized EV: {ev_pct:.2f}%")
        print(f"Theoretical EV: -0.50%  |  Variance: {abs(ev_pct + 0.50):.2f}%")


if __name__ == "__main__":
    # Step 1: claim free USDC from faucet
    faucet_resp = requests.post(f"{FAUCET_URL}/register",
                                json={"agent_id": AGENT_ID})
    starting_balance = faucet_resp.json().get("balance", 100.0)
    print(f"Faucet claim: {starting_balance:.2f} USDC")

    # Step 2: run the basic strategy agent
    agent = BlackjackAgent(
        agent_id      = AGENT_ID,
        bankroll      = starting_balance,
        bet_fraction  = 0.05,    # 5% Kelly-lite sizing
        profit_target = 0.20,    # stop at +20%
        loss_limit    = 0.30     # stop at -30%
    )
    agent.run_session(max_hands=200)