1 个不稳定版本

0.1.0	2023年10月31日

#290 在游戏中

Zlib OR Apache-2.0 OR MIT

150KB
3K SLoC

AyaPoker

AyaPoker 是一个基于 OMPEval C++ 手牌评估器（https://github.com/zekyll/OMPEval）的 Rust 库，支持大多数流行的扑克变体。

功能

可用于对标准扑克、五点低牌、七点低牌、六或更好（短牌）、奥马哈、奥马哈高低、Badugi 或 Baduci 的手牌进行排名。
可评估 0 到 7 张牌的手牌，缺失的牌计为最差的踢子，允许在 Stud 游戏中使用。
使用编译时生成的完美哈希函数查找表，以实现出色的运行时性能和快速初始化。
拥有全面的测试套件，以确保每个变体的手牌排名规则的正确实现。

标志

此 crate 具有以下 Cargo 功能

std：默认情况下，aya_poker 是一个 !#[no_std] crate，但可以通过 std 功能进行编译，以允许使用系统生成的随机种子初始化 Deck。
colored：使用 colored 以颜色显示牌和手牌。
colored-4color：与 colored 相同，但使用四色牌组。

示例

use std::cmp::Ordering;

use aya_poker::{base::*, deck::Deck, poker_rank};

const SEED: u64 = 42;
const SAMPLE_SIZE: usize = 100_000;

fn main() -> Result<(), ParseError> {
    // We can initialize cards by specifying the rank and suit,
    // and then use collect to combine the cards into a Hand
    let player = [
        Card::new(Rank::King, Suit::Hearts),
        Card::new(Rank::King, Suit::Clubs),
    ]
    .iter()
    .collect();

    // Or, first parse the cards from strings
    let opponent = ["Js".parse::<Card>(), "Qs".parse::<Card>()]
        .iter()
        .copied()
        .collect::<Result<Hand, ParseError>>()?;

    // Or, parse a space-separated string of cards as a Hand
    let board = "Ah 5s Ts".parse()?;

    let equity = equity_calculator(&player, &opponent, &board);
    println!(
        "{} has {:.1}% equity on {} against {}.",
        player,
        100.0 * equity,
        board,
        opponent
    );

    Ok(())

}

fn equity_calculator(
    player: &Hand,
    opponent: &Hand,
    board: &Hand,
) -> f64 {
    // To simulate board run-outs, we begin by preparing a deck
    // that doesn't contain the already dealt-out cards
    let available_cards = CARDS
        .iter()
        .filter(|c| !player.contains(c))
        .filter(|c| !opponent.contains(c))
        .filter(|c| !board.contains(c));
    let mut deck = Deck::with_seed(available_cards, SEED);

    let mut pots_won = 0.0;
    for _ in 0..SAMPLE_SIZE {
        // Then, for each run we draw cards to complete the board
        deck.reset();
        let missing = 5 - board.len();
        let complete_board = board
            .iter()
            .chain(deck.deal(missing).unwrap().iter())
            .collect::<Hand>();

        // Evaluate the player's hand given the completed board
        let mut player_hand = *player;
        player_hand.extend(complete_board.iter());
        let player_rank = poker_rank(&player_hand);

        // Evaluate the opponent's hand
        let mut opponent_hand = *opponent;
        opponent_hand.extend(complete_board.iter());
        let opponent_rank = poker_rank(&opponent_hand);

        // And record the player's share of the pot for the run
        match player_rank.cmp(&opponent_rank) {
            Ordering::Greater => pots_won += 1.0,
            Ordering::Less => {}
            Ordering::Equal => pots_won += 0.5,
        };
    }

    pots_won / SAMPLE_SIZE as f64
}