This is poker environment for RL/etc:
```
// This project simulates a simplified version of a poker game environment including
// player actions, card dealings, and hand evaluation. The simulation is set up to support
// reinforcement learning agents by providing a detailed game state observation.

// Imports for randomness and formatting
use rand::prelude::*;
use std::fmt;

// Constants for the game
const NUM_PLAYERS: usize = 9;       // Number of players in the game
const NUM_CARDS: usize = 52;        // Number of cards in a standard deck
const NUM_RANKS: usize = 13;        // Number of ranks in a standard deck
const NUM_SUITS: usize = 4;         // Number of suits in a standard deck
const MAX_STACK: u32 = 10000;       // Initial stack size for each player
const SMALL_BLIND: u32 = 50;        // Small blind bet
const BIG_BLIND: u32 = 100;         // Big blind bet

// Enumeration for player actions
#[derive(Clone, Copy, Debug)]
enum Action {
    Fold,   // Player gives up their hand
    Call,   // Player matches the current bet
    Raise,  // Player increases the current bet
}

// Structure to represent a playing card with rank and suit
#[derive(Clone, Copy, Debug)]
struct Card {
    rank: usize,
    suit: usize,
}

impl Card {
    // Creates a new Card based on an integer ID
    fn new(id: usize) -> Card {
        Card {
            suit: id / NUM_RANKS,
            rank: id % NUM_RANKS,
        }
    }
}

// Display formatting for Card, allowing cards to be printed as strings
impl fmt::Display for Card {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        let rank_strings = ["2", "3", "4", "5", "6", "7", "8", "9", "T", "J", "Q", "K", "A"];
        let suit_strings = ["h", "d", "c", "s"];
        write!(f, "{}{}", rank_strings[self.rank], suit_strings[self.suit])
    }
}

// Deck of cards management (shuffling and dealing)
struct Deck {
    cards: Vec<Card>,
    rng: ThreadRng,
}

impl Deck {
    // Creates a new shuffled deck
    fn new() -> Deck {
        let mut deck = Deck {
            cards: Vec::with_capacity(NUM_CARDS),
            rng: thread_rng(),
        };
        deck.generate_deck();
        deck.shuffle();
        deck
    }

    // Generates a standard deck of 52 cards
    fn generate_deck(&mut self) {
        self.cards.clear();
        for i in 0..NUM_CARDS {
            self.cards.push(Card::new(i));
        }
    }

    // Shuffles the deck
    fn shuffle(&mut self) {
        self.cards.shuffle(&mut self.rng);
    }

    // Deals a single card from the deck
    fn deal(&mut self) -> Card {
        self.cards.pop().expect("No more cards in the deck")
    }

    // Resets the deck to a shuffled full deck
    fn reset(&mut self) {
        self.generate_deck();
        self.shuffle();
    }
}

// Hand evaluation using quinary method
struct HandEvaluator {
    combinations: [[u32; 8]; 14], // Combination table using u32 for compatibility
}

impl HandEvaluator {
    // Initializes a hand evaluator with precomputed combinations
    fn new() -> Self {
        let combinations = Self::precompute_combinations();
        HandEvaluator { combinations }
    }

    // Precomputes combination table for hand evaluation
    fn precompute_combinations() -> [[u32; 8]; 14] {
        let mut combinations = [[0; 8]; 14];
        for i in 0..14 {
            for j in 0..=i.min(7) {
                if j == 0 || j == i {
                    combinations[i][j] = 1;
                } else {
                    combinations[i][j] = combinations[i - 1][j] + combinations[i - 1][j - 1];
                }
            }
        }
        combinations
    }

    // Converts a hand into a quinary representation
    fn quinary_from_hand(cards: &[Card]) -> [u8; NUM_RANKS] {
        let mut quinary = [0u8; NUM_RANKS];
        for card in cards {
            quinary[card.rank] += 1;
        }
        quinary
    }

    // Evaluates a hand using its quinary representation
    fn evaluate_hand(&self, hand: &[Card], community_cards: &[Card]) -> u32 {
        let mut all_cards = hand.to_vec();
        all_cards.extend_from_slice(community_cards);
        let quinary = Self::quinary_from_hand(&all_cards);
        self.hash_quinary(&quinary)
    }

    // Computes the hash for a quinary representation
    fn hash_quinary(&self, quinary: &[u8; NUM_RANKS]) -> u32 {
    let mut hash = 0;
    let mut remaining_k = 7; // Use usize for the number of cards in the hand

    for (i, &count) in quinary.iter().enumerate() {
        if remaining_k >= i {
            hash += self.combinations[NUM_RANKS - 1 - i][remaining_k];
        }
        remaining_k = remaining_k.saturating_sub(count as usize); // Use saturating_sub
    }
    hash
}
}

// Representation of a Player in the game
struct Player {
    stack: u32,        // Player's current stack
    bet: u32,          // Player's current bet in the round
    active: bool,      // Is the player still active in the round
    all_in: bool,      // Is the player all-in
    hand: Vec<Card>,   // Player's hand (2 cards)
}

impl Player {
    // Creates a new player with an initial stack
    fn new(stack: u32) -> Player {
        Player {
            stack,
            bet: 0,
            active: true,
            all_in: false,
            hand: Vec::with_capacity(2),
        }
    }

    // Resets the player's state for a new round
    fn reset(&mut self) {
        self.bet = 0;
        self.active = true;
        self.all_in = false;
        self.hand.clear();
    }
}

// Comprehensive game state for RL agents
#[derive(Debug, Clone)]
struct GameState {
    player_hands: Vec<Vec<Card>>, // Each player's hole cards
    community_cards: Vec<Card>,   // The shared community cards
    player_stacks: Vec<u32>,      // Each player's current stack
    player_bets: Vec<u32>,        // Each player's current bet
    pot: u32,                     // Current size of the pot
    current_player: usize,        // Index of the current player
    phase: Phase,                 // Current phase of the game
}

// RL-compatible observation structure
struct RLObservation {
    state: GameState, // Detailed game state
    min_call: u32,    // Minimum amount needed to call
}

// The core environment managing the game state and progression
struct PokerEnvironment<F>
where
    F: Fn(usize, &RLObservation) -> Action,
{
    num_players: usize,   // Number of players in the game
    players: Vec<Player>, // Vector of players
    deck: Deck,           // Deck of cards
    pot: u32,             // Total pot size
    min_call: u32,        // Minimum amount to call in the current bet
    last_raise: u32,      // Last raised amount
    current_player: usize,// The index of the current player in action
    dealer_position: usize, // The index of the dealer
    phase: Phase,         // Current phase of the game
    betting_round_over: bool, // Is the current betting round over?
    community_cards: Vec<Card>, // Community cards visible to all players
    last_aggressor: Option<usize>, // Last player to make an aggressive action
    agent_function: F,    // Function determining player actions
    evaluator: HandEvaluator, // Hand evaluator with precomputed combinations
}

// Enumeration of possible game phases
#[derive(Clone, Copy, Debug, PartialEq)]
enum Phase {
    PreFlop,
    Flop,
    Turn,
    River,
    Showdown,
}

impl<F> PokerEnvironment<F>
where
    F: Fn(usize, &RLObservation) -> Action,
{
    // Initializes a new poker game environment
    fn new(num_players: usize, agent_function: F) -> PokerEnvironment<F> {
        let evaluator = HandEvaluator::new(); // Create evaluator with precomputed values
        let mut env = PokerEnvironment {
            num_players,
            players: Vec::with_capacity(num_players),
            deck: Deck::new(),
            pot: 0,
            min_call: 0,
            last_raise: 0,
            current_player: 0,
            dealer_position: 0,
            phase: Phase::PreFlop,
            betting_round_over: false,
            community_cards: Vec::new(),
            last_aggressor: None,
            agent_function,
            evaluator,
        };
        env.initialize_game();
        env
    }

    // Sets up a new game with initial states and conditions
    fn initialize_game(&mut self) {
        self.players.clear();
        for _ in 0..self.num_players {
            self.players.push(Player::new(MAX_STACK));
        }

        self.deck.reset();

        for player in &mut self.players {
            player.reset();
            player.hand.push(self.deck.deal());
            player.hand.push(self.deck.deal());
        }

        self.pot = 0;
        self.min_call = BIG_BLIND;
        self.last_raise = BIG_BLIND;
        self.current_player = (self.dealer_position + 3) % self.num_players;
        self.phase = Phase::PreFlop;
        self.betting_round_over = false;
        self.community_cards.clear();
        self.last_aggressor = None;

        let small_blind_position = (self.dealer_position + 1) % self.num_players;
        let big_blind_position = (self.dealer_position + 2) % self.num_players;
        self.post_blind(small_blind_position, SMALL_BLIND);
        self.post_blind(big_blind_position, BIG_BLIND);
    }

    // Runs a single hand of poker, progressing through rounds and phases
    fn play_single_hand(&mut self) {
        while !self.is_terminal() {
            let player_id = self.current_player;
            let player = &self.players[player_id];
            if player.active && !player.all_in {
                let observation = self.get_rl_observation();
                let action = (self.agent_function)(player_id, &observation);
                self.step(action);
            } else {
                self.next_player();
            }
        }
        self.resolve_hand();
    }

    // Generates a detailed observation for RL agents
    fn get_rl_observation(&self) -> RLObservation {
        RLObservation {
            state: GameState {
                player_hands: self.players.iter().map(|p| p.hand.clone()).collect(),
                community_cards: self.community_cards.clone(),
                player_stacks: self.players.iter().map(|p| p.stack).collect(),
                player_bets: self.players.iter().map(|p| p.bet).collect(),
                pot: self.pot,
                current_player: self.current_player,
                phase: self.phase,
            },
            min_call: self.min_call,
        }
    }

    // Processes a player's action and updates the game state
    fn step(&mut self, action: Action) {
        let player_id = self.current_player;
        let player = &mut self.players[player_id];
        if !player.active || player.all_in {
            self.next_player();
            return;
        }

        match action {
            Action::Fold => self.handle_fold(player_id),
            Action::Call => self.handle_call(player_id),
            Action::Raise => self.handle_raise(player_id),
        }

        if self.betting_round_over {
            self.advance_phase();
        }

        if !self.is_terminal() {
            self.next_player();
        }
    }

    // Checks if the hand is at a terminal state (finished)
    fn is_terminal(&self) -> bool {
        let active_count = self.players.iter().filter(|p| p.active || p.all_in).count();
        active_count <= 1 || self.phase == Phase::Showdown
    }

    // Handles the fold action by a player
    fn handle_fold(&mut self, player_id: usize) {
        let player = &mut self.players[player_id];
        player.active = false;
        self.pot += player.bet;
        player.bet = 0;
    }

    // Handles the call action, matching a player's bet to the minimum call
    fn handle_call(&mut self, player_id: usize) {
        let player = &mut self.players[player_id];
        let call_amount = self.min_call - player.bet;
        let amount = std::cmp::min(call_amount, player.stack);
        player.bet += amount;
        player.stack -= amount;
        if player.stack == 0 {
            player.all_in = true;
        }
    }

    // Handles the raise action, increasing a player's bet
    fn handle_raise(&mut self, player_id: usize) {
        let player = &mut self.players[player_id];
        let raise_amount = std::cmp::max(self.last_raise * 2, self.min_call * 2);
        let amount = std::cmp::min(raise_amount, player.stack);
        player.bet += amount;
        player.stack -= amount;
        self.min_call = player.bet;
        self.last_raise = amount;
        self.last_aggressor = Some(player_id);
        if player.stack == 0 {
            player.all_in = true;
        }
    }

    // Advances the current player to the next one in line
    fn next_player(&mut self) {
        let start_player = self.current_player;
        loop {
            self.current_player = (self.current_player + 1) % self.num_players;
            if self.current_player == start_player {
                self.betting_round_over = true;
                break;
            }
            let player = &self.players[self.current_player];
            if player.active && !player.all_in {
                break;
            }
        }

        if let Some(last_aggressor) = self.last_aggressor {
            if self.current_player == last_aggressor {
                self.betting_round_over = true;
            }
        }
    }

    // Progresses the game to the next phase
    fn advance_phase(&mut self) {
        for player in &mut self.players {
            self.pot += player.bet;
            player.bet = 0;
        }
        self.min_call = 0;
        self.last_raise = 0;
        self.betting_round_over = false;
        self.last_aggressor = None;

        self.phase = match self.phase {
            Phase::PreFlop => {
                self.community_cards.push(self.deck.deal());
                self.community_cards.push(self.deck.deal());
                self.community_cards.push(self.deck.deal());
                Phase::Flop
            }
            Phase::Flop => {
                self.community_cards.push(self.deck.deal());
                Phase::Turn
            }
            Phase::Turn => {
                self.community_cards.push(self.deck.deal());
                Phase::River
            }
            Phase::River => Phase::Showdown,
            Phase::Showdown => Phase::Showdown,
        };

        self.current_player = (self.dealer_position + 1) % self.num_players;
        while {
            let player = &self.players[self.current_player];
            (!player.active || player.all_in) && self.current_player != self.dealer_position
        } {
            self.current_player = (self.current_player + 1) % self.num_players;
        }
    }

    // Resolves the end of a hand, determining winners and distributing the pot
    fn resolve_hand(&mut self) {
        let active_players: Vec<_> = self
            .players
            .iter()
            .enumerate()
            .filter(|(_, p)| p.active || p.all_in)
            .collect();

        if active_players.len() == 1 {
            let (winner_id, _) = active_players[0];
            let winner = &mut self.players[winner_id];
            winner.stack += self.pot;
            println!(
                "Player {} wins the pot of {} by default.",
                winner_id, self.pot
            );
            return;
        }

        let mut best_rank: Option<u32> = None;
        let mut winners = vec![];
        for (player_id, player) in active_players {
            let rank = self.evaluator.evaluate_hand(&player.hand, &self.community_cards);
            if best_rank.is_none() || rank < best_rank.unwrap() {
                best_rank = Some(rank);
                winners.clear();
                winners.push(player_id);
            } else if rank == best_rank.unwrap() {
                winners.push(player_id);
            }
        }

        let split_pot = self.pot / winners.len() as u32;
        for &winner_id in &winners {
            let winner = &mut self.players[winner_id];
            winner.stack += split_pot;
            println!(
                "Player {} wins {} with hand rank {}.",
                winner_id,
                split_pot,
                best_rank.unwrap()
            );
        }
    }

    // Posts a blind bet for a specified player
    fn post_blind(&mut self, player_id: usize, amount: u32) {
        let player = &mut self.players[player_id];
        let blind_amount = std::cmp::min(amount, player.stack);
        player.bet += blind_amount;
        player.stack -= blind_amount;
        self.pot += blind_amount;
        self.min_call = std::cmp::max(self.min_call, player.bet);
        if player.stack == 0 {
            player.all_in = true;
        }
    }
}

// Function defining a random player action
fn random_agent_function(_player_id: usize, _observation: &RLObservation) -> Action {
    let mut rng = thread_rng();
    match rng.gen_range(0..3) {
        0 => Action::Fold,
        1 => Action::Call,
        _ => Action::Raise,
    }
}

// Main function initializes the game and triggers the simulation
fn main() {
    // Use the random agent function
    let agent_function = random_agent_function;
    let mut env = PokerEnvironment::new(NUM_PLAYERS, agent_function);
    env.play_single_hand();
    println!("Hand simulation completed.");
}
```

Now I want to train an AI with selfplay using it