EdgeCounter²

Part I — The Game

Blackjack, from scratch

Before understanding what this codebase does, you need to understand the game it models. Blackjack is played between each player and a dealer (the house). The goal: get as close to 21 points as possible without going over — and beat the dealer's total.

Part II — Card Counting

Why remaining cards change everything

A blackjack shoe starts with 8 decks = 416 cards. As the game progresses, the composition of remaining cards shifts — and so do the probabilities. Card counting is simply tracking that shift.

The key insight: high cards (10s, Aces) favor the player. When the remaining shoe is rich in high cards, blackjacks (paying 3:2) are more frequent, doubles are more profitable, and the dealer busts more often because they must hit to 17. Low cards (2–6) favor the dealer.

The Wong Halves System

EdgeCounter2 uses Wong Halves — one of the most accurate card counting systems ever developed. Each dealt card updates a running total. The higher the count, the richer the remaining shoe in high cards, and the better for the player.

// Every dealt card calls this
pub fn wong_halves(rank: usize) -> f64 {
  match rank {
    0  =>  0.5,  // 2  — low card out → good
    1  =>  1.0,  // 3
    2  =>  1.0,  // 4
    3  =>  1.5,  // 5  — best low card
    4  =>  1.0,  // 6
    5  =>  0.5,  // 7
    6  =>  0.0,  // 8  — neutral
    7  => -0.5,  // 9
    8..=11 => -1.0, // T, J, Q, K
    12 => -1.0,  // A  — ace out → bad
  }
}

// Normalize for shoe depth
pub fn true_count(rc: f64, cards: u32) -> f64 {
  // Guard: near-empty shoe = ¼ deck minimum
  // (avoids explosive values at end-of-shoe)
  let decks = (cards as f64 / 52.0).max(0.25);
  (rc / decks * 100.0).round() / 100.0
}

// Example:
// RC = +8, cards remaining = 156 (3 decks)
// TC = 8 / 3 = +2.67

Part III — The EV Engine

Computing exact expected value

Expected Value (EV) answers: "If I bet $1 on the next round, how much do I expect to win or lose?" A fresh 8-deck shoe gives roughly −0.534% — you lose about half a cent per dollar bet. The engine's job is to compute this precisely from the exact cards remaining, not from a rough formula.

The Four-Stage Pipeline

The code lives in src/sim/ev_engine/. Each module is independently validated against published probability tables.

struct RoundEv {
  round_ev: f64,          // e.g. -0.00534  (−0.534%)
  round_ev_no_cashout: f64,
  cashout_uplift: f64,    // bonus value of the cashout option
  p_player_bj: f64,       // probability of player blackjack
  p_dealer_bust: f64,     // probability dealer busts
  insurance_ev: f64,      // EV of insurance side bet
}

Part IV — Architecture

How the server is built

A single Rust binary built on Axum (async web framework on top of Tokio). The prime directive is wire fidelity — every JSON field name, type, array ordering, and value must exactly match what the captured original JavaScript frontend expects.

// Three placeholders, replaced at serve time:
__EC_ROLE__   → "admin" or "user"
__EC_USER__   → username from session
__EC_TABLE_ID__ → table ID from URL

// Adding a new dynamic value means:
// 1. Add placeholder to template HTML
// 2. Add .replace() call in main.rs

The Phase State Machine

Each of the 378 tables independently cycles through a fixed 8-phase round loop. Phases have randomized tick-durations to desynchronize the tables and make the lobby feel alive. Speed tables use half the normal duration.

The Split-Borrow Trick

One of the most interesting Rust-specific patterns in the codebase. The tick loop needs &mut self.rng while iterating over &mut self.tables. A for t in &mut self.tables loop takes a mutable borrow of all of self.tables which conflicts with borrowing self.rng. Indexed access lets the borrow checker see two distinct fields:

// ❌ Won't compile — two borrows of self:
for t in &mut self.tables {
  t.advance(&mut self.rng);
  //         ^^^ borrow conflict
}

// ✅ Works — borrows two distinct fields:
for idx in 0..self.tables.len() {
  self.tables[idx].advance(
    &mut self.rng
  ); // compiler tracks field paths
}

Part V — The Codebase

Every file, explained

Data Generators (src/gen/)

Non-table data (users, proxies, bots, analytics) is generated once at boot from a random seed, then served verbatim on every request. The goal is internal coherence — e.g., insights totals always sum correctly across all partitions.

What's Real vs. Simulated