client/server
This commit is contained in:
@@ -0,0 +1,8 @@
|
||||
[package]
|
||||
name = "audiopoker_core"
|
||||
version = "0.1.0"
|
||||
edition = "2021"
|
||||
|
||||
[dependencies]
|
||||
serde = { version = "1.0", features = ["derive"] }
|
||||
rand = "0.8.5"
|
||||
@@ -0,0 +1,409 @@
|
||||
//! Spielzustand und Betting-Logik (siehe PLAN.md, Phase 1 & 3).
|
||||
//!
|
||||
//! Vereinfachtes Rundenmodell: Pro Straße (Pre-Flop/Flop/Turn/River) agiert
|
||||
//! jeder noch aktive Spieler genau einmal (kein erneutes Nachziehen bei
|
||||
//! Re-Raises). Das reicht für eine barrierefreie MVP-Demo, ist aber keine
|
||||
//! vollständige Tournament-taugliche Poker-Regelimplementierung.
|
||||
|
||||
use crate::logic::card::Card;
|
||||
use crate::logic::hand::Hand;
|
||||
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
||||
pub enum Round {
|
||||
PreFlop,
|
||||
Flop,
|
||||
Turn,
|
||||
River,
|
||||
Showdown,
|
||||
}
|
||||
|
||||
impl Round {
|
||||
/// Wie viele Community Cards bei dieser Straße aufgedeckt sind.
|
||||
pub fn revealed_community_count(&self) -> usize {
|
||||
match self {
|
||||
Round::PreFlop => 0,
|
||||
Round::Flop => 3,
|
||||
Round::Turn => 4,
|
||||
Round::River | Round::Showdown => 5,
|
||||
}
|
||||
}
|
||||
|
||||
/// Deutschsprachige Bezeichnung für Ansagen.
|
||||
pub fn label(&self) -> &'static str {
|
||||
match self {
|
||||
Round::PreFlop => "Pre-Flop",
|
||||
Round::Flop => "Flop",
|
||||
Round::Turn => "Turn",
|
||||
Round::River => "River",
|
||||
Round::Showdown => "Showdown",
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
||||
pub enum PlayerStatus {
|
||||
Active,
|
||||
Folded,
|
||||
AllIn,
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone)]
|
||||
pub struct Player {
|
||||
pub id: u32,
|
||||
pub name: String,
|
||||
pub stack: u64,
|
||||
pub hole_cards: Vec<Card>,
|
||||
pub current_bet: u64,
|
||||
pub status: PlayerStatus,
|
||||
}
|
||||
|
||||
impl Player {
|
||||
/// Startguthaben ist vorerst fest verdrahtet; sollte später
|
||||
/// über die Tisch-/Lobby-Konfiguration (Phase 2) einstellbar sein.
|
||||
const STARTING_STACK: u64 = 1000;
|
||||
|
||||
pub fn new(id: u32, name: &str) -> Self {
|
||||
Self {
|
||||
id,
|
||||
name: name.to_string(),
|
||||
stack: Self::STARTING_STACK,
|
||||
hole_cards: Vec::new(),
|
||||
current_bet: 0,
|
||||
status: PlayerStatus::Active,
|
||||
}
|
||||
}
|
||||
|
||||
pub fn fold(&mut self) {
|
||||
self.status = PlayerStatus::Folded;
|
||||
}
|
||||
|
||||
/// Setzt `amount`, gedeckelt durch den verbleibenden Stack.
|
||||
/// Gibt den tatsächlich gesetzten Betrag zurück (relevant bei All-In).
|
||||
pub fn bet(&mut self, amount: u64) -> u64 {
|
||||
let actual = amount.min(self.stack);
|
||||
self.stack -= actual;
|
||||
self.current_bet += actual;
|
||||
if self.stack == 0 {
|
||||
self.status = PlayerStatus::AllIn;
|
||||
}
|
||||
actual
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone)]
|
||||
pub struct GameState {
|
||||
pub players: Vec<Player>,
|
||||
pub pot: u64,
|
||||
pub dealer_idx: usize,
|
||||
pub community_cards: Vec<Card>,
|
||||
pub current_round: Round,
|
||||
/// Index des Spielers, der als Nächstes agieren muss.
|
||||
pub to_act: usize,
|
||||
/// Wie viele Spieler auf der aktuellen Straße noch agieren müssen,
|
||||
/// bevor automatisch zur nächsten Straße übergegangen wird.
|
||||
pub players_to_act_this_street: usize,
|
||||
}
|
||||
|
||||
impl GameState {
|
||||
/// Anzahl der Spieler, die weder gefoldet noch (endgültig) ausgeschieden sind.
|
||||
pub fn active_player_count(&self) -> usize {
|
||||
self.players
|
||||
.iter()
|
||||
.filter(|p| p.status != PlayerStatus::Folded)
|
||||
.count()
|
||||
}
|
||||
|
||||
/// Nächster Spieler nach `from`, der noch aktiv (nicht gefoldet, nicht
|
||||
/// All-In) handeln kann. `None`, falls niemand mehr agieren kann.
|
||||
pub fn next_to_act(&self, from: usize) -> Option<usize> {
|
||||
let n = self.players.len();
|
||||
if n == 0 {
|
||||
return None;
|
||||
}
|
||||
(1..=n)
|
||||
.map(|step| (from + step) % n)
|
||||
.find(|&idx| self.players[idx].status == PlayerStatus::Active)
|
||||
}
|
||||
}
|
||||
|
||||
/// Fester Erhöhungsbetrag für "Raise" (vereinfachtes Modell, kein Pot-Limit/No-Limit-Sizing).
|
||||
/// Zentral definiert, damit Client und Server garantiert denselben Wert verwenden.
|
||||
pub const RAISE_INCREMENT: u64 = 20;
|
||||
|
||||
/// Wett-Aktionen, wie sie über `core::network` vom Client kommen (Deal/Bet/Fold, siehe PLAN.md).
|
||||
#[derive(Debug, Clone, Copy)]
|
||||
pub enum BettingAction {
|
||||
Fold,
|
||||
Check,
|
||||
Call(u64),
|
||||
Raise(u64),
|
||||
}
|
||||
|
||||
/// Ergebnis einer Aktion, aufbereitet für die Audio-Ausgabe: eine Liste von
|
||||
/// Ansagen (TTS) und Soundeffekt-IDs, in der Reihenfolge, in der sie
|
||||
/// passiert sind (Aktion -> ggf. Straßenwechsel -> ggf. Showdown).
|
||||
#[derive(Debug, Clone, Default)]
|
||||
pub struct ActionOutcome {
|
||||
pub announcements: Vec<String>,
|
||||
pub sfx_cues: Vec<&'static str>,
|
||||
}
|
||||
|
||||
pub struct GameManager;
|
||||
|
||||
impl GameManager {
|
||||
pub fn start_new_game(player_names: Vec<String>) -> GameState {
|
||||
let players: Vec<Player> = player_names
|
||||
.into_iter()
|
||||
.enumerate()
|
||||
.map(|(i, name)| Player::new(i as u32, &name))
|
||||
.collect();
|
||||
let player_count = players.len();
|
||||
|
||||
GameState {
|
||||
players,
|
||||
pot: 0,
|
||||
dealer_idx: 0,
|
||||
community_cards: Vec::new(),
|
||||
current_round: Round::PreFlop,
|
||||
to_act: 0,
|
||||
players_to_act_this_street: player_count,
|
||||
}
|
||||
}
|
||||
|
||||
/// Betrag, den `player_idx` mindestens setzen müsste, um zum höchsten
|
||||
/// aktuellen Einsatz aufzuschließen (0, wenn Checken möglich ist).
|
||||
pub fn amount_to_call(state: &GameState, player_idx: usize) -> u64 {
|
||||
let highest = state.players.iter().map(|p| p.current_bet).max().unwrap_or(0);
|
||||
highest.saturating_sub(state.players[player_idx].current_bet)
|
||||
}
|
||||
|
||||
/// Wendet die Aktion eines Spielers auf den Spielzustand an und
|
||||
/// aktualisiert den Pot entsprechend. Enthält keine Ansage-/Turn-Logik;
|
||||
/// dafür siehe [`GameManager::take_action`].
|
||||
pub fn apply_action(state: &mut GameState, player_idx: usize, action: BettingAction) {
|
||||
let player = &mut state.players[player_idx];
|
||||
match action {
|
||||
BettingAction::Fold => player.fold(),
|
||||
BettingAction::Check => {}
|
||||
BettingAction::Call(amount) | BettingAction::Raise(amount) => {
|
||||
let actual = player.bet(amount);
|
||||
state.pot += actual;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Schaltet in die nächste Wettrunde (Pre-Flop -> Flop -> Turn -> River -> Showdown).
|
||||
pub fn advance_round(state: &mut GameState) {
|
||||
state.current_round = match state.current_round {
|
||||
Round::PreFlop => Round::Flop,
|
||||
Round::Flop => Round::Turn,
|
||||
Round::Turn => Round::River,
|
||||
Round::River => Round::Showdown,
|
||||
Round::Showdown => Round::Showdown,
|
||||
};
|
||||
}
|
||||
|
||||
/// Führt die Aktion eines Spielers komplett aus: wendet sie an, lässt bei
|
||||
/// Bedarf automatisch die Wettrunde bzw. die Hand weiterlaufen, und gibt
|
||||
/// alle dabei entstandenen Ansagen/Soundcues zurück (für `audio::tts`/`audio::sfx`).
|
||||
pub fn take_action(state: &mut GameState, player_idx: usize, action: BettingAction) -> ActionOutcome {
|
||||
let mut out = ActionOutcome::default();
|
||||
let player_name = state.players[player_idx].name.clone();
|
||||
|
||||
match action {
|
||||
BettingAction::Fold => {
|
||||
out.announcements.push(format!("{player_name} foldet."));
|
||||
out.sfx_cues.push("fold");
|
||||
}
|
||||
BettingAction::Check => {
|
||||
out.announcements.push(format!("{player_name} checkt."));
|
||||
}
|
||||
BettingAction::Call(amount) => {
|
||||
out.announcements.push(format!("{player_name} callt {amount}."));
|
||||
out.sfx_cues.push("chip");
|
||||
}
|
||||
BettingAction::Raise(amount) => {
|
||||
out.announcements.push(format!("{player_name} erhöht auf {amount}."));
|
||||
out.sfx_cues.push("chip");
|
||||
}
|
||||
}
|
||||
|
||||
Self::apply_action(state, player_idx, action);
|
||||
state.players_to_act_this_street = state.players_to_act_this_street.saturating_sub(1);
|
||||
|
||||
if state.active_player_count() <= 1 {
|
||||
Self::finish_hand(state, &mut out);
|
||||
} else if state.players_to_act_this_street == 0 {
|
||||
Self::advance_round(state);
|
||||
out.announcements.push(format!("Runde: {}.", state.current_round.label()));
|
||||
out.sfx_cues.push("flip");
|
||||
|
||||
if state.current_round == Round::Showdown {
|
||||
Self::finish_hand(state, &mut out);
|
||||
} else {
|
||||
for p in state.players.iter_mut() {
|
||||
p.current_bet = 0;
|
||||
}
|
||||
state.players_to_act_this_street = state.active_player_count();
|
||||
state.to_act = state.next_to_act(state.dealer_idx).unwrap_or(state.dealer_idx);
|
||||
|
||||
let revealed_count = state.current_round.revealed_community_count();
|
||||
let revealed: Vec<String> = state.community_cards[..revealed_count]
|
||||
.iter()
|
||||
.map(|c| c.to_string())
|
||||
.collect();
|
||||
if !revealed.is_empty() {
|
||||
out.announcements.push(format!("Community Cards: {}.", revealed.join(", ")));
|
||||
}
|
||||
out.announcements.push(format!("{} ist am Zug.", state.players[state.to_act].name));
|
||||
}
|
||||
} else if let Some(next_idx) = state.next_to_act(player_idx) {
|
||||
state.to_act = next_idx;
|
||||
out.announcements.push(format!("{} ist am Zug.", state.players[next_idx].name));
|
||||
}
|
||||
|
||||
out
|
||||
}
|
||||
|
||||
/// Wertet am Showdown alle nicht gefoldeten Hände aus (bzw. beendet die
|
||||
/// Hand sofort, wenn nur noch ein Spieler übrig ist) und schreibt Pot
|
||||
/// und Sieger-Ansage in `out`.
|
||||
fn finish_hand(state: &mut GameState, out: &mut ActionOutcome) {
|
||||
let non_folded: Vec<usize> = state
|
||||
.players
|
||||
.iter()
|
||||
.enumerate()
|
||||
.filter(|(_, p)| p.status != PlayerStatus::Folded)
|
||||
.map(|(idx, _)| idx)
|
||||
.collect();
|
||||
|
||||
// Alle anderen haben gefoldet: Sieger steht ohne Kartenvergleich fest,
|
||||
// unabhängig davon, wie viele Community Cards schon aufgedeckt waren.
|
||||
if non_folded.len() == 1 {
|
||||
let winner_idx = non_folded[0];
|
||||
let pot = state.pot;
|
||||
let winner_name = state.players[winner_idx].name.clone();
|
||||
state.players[winner_idx].stack += pot;
|
||||
state.pot = 0;
|
||||
out.announcements.push(format!(
|
||||
"{winner_name} gewinnt den Pot von {pot}, da alle anderen Spieler gefoldet haben."
|
||||
));
|
||||
out.sfx_cues.push("chip");
|
||||
state.current_round = Round::Showdown;
|
||||
return;
|
||||
}
|
||||
|
||||
let community = state.community_cards.clone();
|
||||
let mut scores = Vec::new();
|
||||
for &idx in &non_folded {
|
||||
let mut cards = state.players[idx].hole_cards.clone();
|
||||
cards.extend(community.iter().copied());
|
||||
if cards.len() >= 5 {
|
||||
scores.push((idx, Hand::new(cards).evaluate()));
|
||||
}
|
||||
}
|
||||
|
||||
let winner = scores.iter().max_by_key(|(_, score)| *score).copied();
|
||||
|
||||
if let Some((winner_idx, score)) = winner {
|
||||
let pot = state.pot;
|
||||
let winner_name = state.players[winner_idx].name.clone();
|
||||
state.players[winner_idx].stack += pot;
|
||||
state.pot = 0;
|
||||
out.announcements.push(format!(
|
||||
"{winner_name} gewinnt den Pot von {pot} mit {}.",
|
||||
score.category.label()
|
||||
));
|
||||
out.sfx_cues.push("chip");
|
||||
} else {
|
||||
out.announcements
|
||||
.push("Kein Gewinner konnte ermittelt werden.".to_string());
|
||||
}
|
||||
|
||||
state.current_round = Round::Showdown;
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn startet_spiel_mit_korrekten_startwerten() {
|
||||
let state = GameManager::start_new_game(vec!["Anna".into(), "Ben".into()]);
|
||||
assert_eq!(state.players.len(), 2);
|
||||
assert_eq!(state.pot, 0);
|
||||
assert_eq!(state.current_round, Round::PreFlop);
|
||||
assert!(state.players.iter().all(|p| p.stack == Player::STARTING_STACK));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn fold_reduziert_aktive_spielerzahl_und_beendet_zwei_spieler_hand_sofort() {
|
||||
let mut state = GameManager::start_new_game(vec!["Anna".into(), "Ben".into()]);
|
||||
let outcome = GameManager::take_action(&mut state, 0, BettingAction::Fold);
|
||||
assert_eq!(state.active_player_count(), 1);
|
||||
assert_eq!(state.current_round, Round::Showdown);
|
||||
assert!(outcome.announcements.iter().any(|a| a.contains("Ben")));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn bet_erhoeht_pot_und_reduziert_stack() {
|
||||
let mut state = GameManager::start_new_game(vec!["Anna".into(), "Ben".into()]);
|
||||
GameManager::apply_action(&mut state, 0, BettingAction::Raise(100));
|
||||
assert_eq!(state.pot, 100);
|
||||
assert_eq!(state.players[0].stack, Player::STARTING_STACK - 100);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn all_in_deckelt_den_einsatz_auf_den_verbleibenden_stack() {
|
||||
let mut player = Player::new(0, "Anna");
|
||||
let actual = player.bet(10_000); // mehr als der Stack
|
||||
assert_eq!(actual, Player::STARTING_STACK);
|
||||
assert_eq!(player.stack, 0);
|
||||
assert_eq!(player.status, PlayerStatus::AllIn);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn volle_strasse_lässt_runde_automatisch_weiterlaufen() {
|
||||
let mut state = GameManager::start_new_game(vec!["Anna".into(), "Ben".into(), "Cara".into()]);
|
||||
state.community_cards = vec![
|
||||
Card::new(crate::logic::card::Suit::Hearts, 2),
|
||||
Card::new(crate::logic::card::Suit::Hearts, 3),
|
||||
Card::new(crate::logic::card::Suit::Hearts, 4),
|
||||
Card::new(crate::logic::card::Suit::Hearts, 5),
|
||||
Card::new(crate::logic::card::Suit::Hearts, 9),
|
||||
];
|
||||
|
||||
GameManager::take_action(&mut state, 0, BettingAction::Check);
|
||||
GameManager::take_action(&mut state, 1, BettingAction::Check);
|
||||
assert_eq!(state.current_round, Round::PreFlop); // noch nicht alle dran gewesen
|
||||
GameManager::take_action(&mut state, 2, BettingAction::Check);
|
||||
assert_eq!(state.current_round, Round::Flop); // jetzt automatisch weitergeschaltet
|
||||
assert_eq!(state.players_to_act_this_street, 3);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn showdown_kuert_besseren_spieler_zum_gewinner() {
|
||||
use crate::logic::card::Suit;
|
||||
let mut state = GameManager::start_new_game(vec!["Anna".into(), "Ben".into()]);
|
||||
state.current_round = Round::River;
|
||||
state.pot = 200;
|
||||
state.community_cards = vec![
|
||||
Card::new(Suit::Clubs, 2),
|
||||
Card::new(Suit::Clubs, 5),
|
||||
Card::new(Suit::Diamonds, 9),
|
||||
Card::new(Suit::Spades, 11),
|
||||
Card::new(Suit::Hearts, 4),
|
||||
];
|
||||
// Anna hat ein Paar Asse, Ben nur High Card.
|
||||
state.players[0].hole_cards = vec![Card::new(Suit::Hearts, 14), Card::new(Suit::Spades, 14)];
|
||||
state.players[1].hole_cards = vec![Card::new(Suit::Diamonds, 7), Card::new(Suit::Clubs, 8)];
|
||||
|
||||
let mut out = ActionOutcome::default();
|
||||
GameManager::finish_hand(&mut state, &mut out);
|
||||
|
||||
assert_eq!(state.players[0].stack, Player::STARTING_STACK + 200);
|
||||
assert_eq!(state.pot, 0);
|
||||
assert!(out.announcements[0].contains("Anna"));
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,6 @@
|
||||
//! `audiopoker_core`: reine, engine-unabhängige Spiellogik (siehe PLAN.md).
|
||||
//! Wird sowohl vom Bevy/Wasm-`client` als auch vom nativen `server` genutzt.
|
||||
|
||||
pub mod logic;
|
||||
pub mod game;
|
||||
pub mod network;
|
||||
@@ -0,0 +1,59 @@
|
||||
use serde::{Deserialize, Serialize};
|
||||
use std::fmt;
|
||||
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
|
||||
pub enum Suit {
|
||||
Spades,
|
||||
Hearts,
|
||||
Diamonds,
|
||||
Clubs,
|
||||
}
|
||||
|
||||
impl fmt::Display for Suit {
|
||||
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
||||
let name = match self {
|
||||
Suit::Spades => "Pik",
|
||||
Suit::Hearts => "Herz",
|
||||
Suit::Diamonds => "Karo",
|
||||
Suit::Clubs => "Kreuz",
|
||||
};
|
||||
write!(f, "{name}")
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
|
||||
pub struct Rank(pub u8); // 2-14 (11=J, 12=Q, 13=K, 14=A)
|
||||
|
||||
impl Rank {
|
||||
pub fn new(value: u8) -> Self {
|
||||
Self(value)
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
|
||||
pub struct Card {
|
||||
pub suit: Suit,
|
||||
pub rank: Rank,
|
||||
}
|
||||
|
||||
impl Card {
|
||||
pub fn new(suit: Suit, rank_val: u8) -> Self {
|
||||
Self {
|
||||
suit,
|
||||
rank: Rank::new(rank_val),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl fmt::Display for Card {
|
||||
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
||||
let rank_name = match self.rank.0 {
|
||||
11 => "Bube".to_string(),
|
||||
12 => "Dame".to_string(),
|
||||
13 => "König".to_string(),
|
||||
14 => "Ass".to_string(),
|
||||
n => n.to_string(),
|
||||
};
|
||||
write!(f, "{rank_name} {}", self.suit)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,234 @@
|
||||
use std::collections::HashMap;
|
||||
|
||||
use crate::logic::card::Card;
|
||||
|
||||
/// Kategorie einer Poker-Hand, aufsteigend nach Stärke sortiert.
|
||||
/// Die Reihenfolge der Varianten wird für den Vergleich (`Ord`) genutzt.
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
|
||||
pub enum HandCategory {
|
||||
HighCard,
|
||||
Pair,
|
||||
TwoPair,
|
||||
ThreeOfAKind,
|
||||
Straight,
|
||||
Flush,
|
||||
FullHouse,
|
||||
FourOfAKind,
|
||||
StraightFlush,
|
||||
}
|
||||
|
||||
impl HandCategory {
|
||||
/// Deutschsprachige Beschreibung für Sprachausgabe/Ansagen.
|
||||
pub fn label(&self) -> &'static str {
|
||||
match self {
|
||||
HandCategory::HighCard => "High Card",
|
||||
HandCategory::Pair => "einem Paar",
|
||||
HandCategory::TwoPair => "zwei Paaren",
|
||||
HandCategory::ThreeOfAKind => "einem Drilling",
|
||||
HandCategory::Straight => "einer Straße",
|
||||
HandCategory::Flush => "einem Flush",
|
||||
HandCategory::FullHouse => "einem Full House",
|
||||
HandCategory::FourOfAKind => "einem Vierling",
|
||||
HandCategory::StraightFlush => "einem Straight Flush",
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Vollständig vergleichbare Bewertung einer 5-Karten-Hand:
|
||||
/// zuerst die Kategorie, danach die Kicker/Tiebreaker in absteigender
|
||||
/// Relevanz. Zwei `HandScore`-Werte lassen sich direkt per `>`/`<` vergleichen.
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
|
||||
pub struct HandScore {
|
||||
pub category: HandCategory,
|
||||
pub tiebreakers: [u8; 5],
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone)]
|
||||
pub struct Hand {
|
||||
pub cards: Vec<Card>,
|
||||
}
|
||||
|
||||
impl Hand {
|
||||
pub fn new(cards: Vec<Card>) -> Self {
|
||||
Self { cards }
|
||||
}
|
||||
|
||||
/// Bewertet die Hand und gibt die bestmögliche 5-Karten-Kombination
|
||||
/// als `HandScore` zurück. Unterstützt 5 bis 7 Karten (z. B. 2 Hole
|
||||
/// Cards + bis zu 5 Community Cards beim Texas Hold'em).
|
||||
pub fn evaluate(&self) -> HandScore {
|
||||
assert!(
|
||||
self.cards.len() >= 5,
|
||||
"Zur Bewertung werden mindestens 5 Karten benötigt"
|
||||
);
|
||||
|
||||
combinations_of_5(&self.cards)
|
||||
.into_iter()
|
||||
.map(|combo| score_five(&combo))
|
||||
.max()
|
||||
.expect("mindestens eine 5-Karten-Kombination muss existieren")
|
||||
}
|
||||
}
|
||||
|
||||
/// Erzeugt alle 5-elementigen Teilmengen der übergebenen Karten
|
||||
/// (bei genau 5 Karten trivial, bei 6/7 Karten alle C(n,5) Kombinationen).
|
||||
fn combinations_of_5(cards: &[Card]) -> Vec<[Card; 5]> {
|
||||
let mut result = Vec::new();
|
||||
let mut indices = [0usize; 5];
|
||||
|
||||
fn recurse(
|
||||
cards: &[Card],
|
||||
start: usize,
|
||||
depth: usize,
|
||||
indices: &mut [usize; 5],
|
||||
result: &mut Vec<[Card; 5]>,
|
||||
) {
|
||||
if depth == 5 {
|
||||
result.push([
|
||||
cards[indices[0]],
|
||||
cards[indices[1]],
|
||||
cards[indices[2]],
|
||||
cards[indices[3]],
|
||||
cards[indices[4]],
|
||||
]);
|
||||
return;
|
||||
}
|
||||
for i in start..cards.len() {
|
||||
indices[depth] = i;
|
||||
recurse(cards, i + 1, depth + 1, indices, result);
|
||||
}
|
||||
}
|
||||
|
||||
recurse(cards, 0, 0, &mut indices, &mut result);
|
||||
result
|
||||
}
|
||||
|
||||
/// Bewertet genau 5 Karten nach den Standard-Poker-Regeln.
|
||||
fn score_five(cards: &[Card; 5]) -> HandScore {
|
||||
let mut ranks: Vec<u8> = cards.iter().map(|c| c.rank.0).collect();
|
||||
ranks.sort_unstable_by(|a, b| b.cmp(a)); // absteigend
|
||||
|
||||
let is_flush = cards.iter().all(|c| c.suit == cards[0].suit);
|
||||
|
||||
let mut unique_ranks = ranks.clone();
|
||||
unique_ranks.dedup();
|
||||
|
||||
// Straße A-2-3-4-5 ("Wheel") ist ein Sonderfall: Ass zählt hier als 1.
|
||||
let is_wheel = unique_ranks == vec![14, 5, 4, 3, 2];
|
||||
let is_straight_normal =
|
||||
unique_ranks.len() == 5 && (unique_ranks[0] - unique_ranks[4] == 4);
|
||||
let is_straight = is_straight_normal || is_wheel;
|
||||
let straight_high = if is_wheel { 5 } else { *unique_ranks.first().unwrap_or(&0) };
|
||||
|
||||
// Häufigkeiten pro Rang zählen, dann nach (Anzahl, Rang) absteigend sortieren,
|
||||
// damit z. B. bei Full House das Drilling-Rank vor dem Paar-Rank steht.
|
||||
let mut counts: HashMap<u8, u8> = HashMap::new();
|
||||
for &r in &ranks {
|
||||
*counts.entry(r).or_insert(0) += 1;
|
||||
}
|
||||
let mut count_groups: Vec<(u8, u8)> = counts.into_iter().collect(); // (rang, anzahl)
|
||||
count_groups.sort_unstable_by(|a, b| b.1.cmp(&a.1).then(b.0.cmp(&a.0)));
|
||||
|
||||
let category = if is_straight && is_flush {
|
||||
HandCategory::StraightFlush
|
||||
} else if count_groups[0].1 == 4 {
|
||||
HandCategory::FourOfAKind
|
||||
} else if count_groups[0].1 == 3 && count_groups.get(1).map_or(false, |g| g.1 == 2) {
|
||||
HandCategory::FullHouse
|
||||
} else if is_flush {
|
||||
HandCategory::Flush
|
||||
} else if is_straight {
|
||||
HandCategory::Straight
|
||||
} else if count_groups[0].1 == 3 {
|
||||
HandCategory::ThreeOfAKind
|
||||
} else if count_groups[0].1 == 2 && count_groups.get(1).map_or(false, |g| g.1 == 2) {
|
||||
HandCategory::TwoPair
|
||||
} else if count_groups[0].1 == 2 {
|
||||
HandCategory::Pair
|
||||
} else {
|
||||
HandCategory::HighCard
|
||||
};
|
||||
|
||||
let tiebreakers: [u8; 5] = match category {
|
||||
HandCategory::StraightFlush | HandCategory::Straight => [straight_high, 0, 0, 0, 0],
|
||||
_ => {
|
||||
let mut tb = [0u8; 5];
|
||||
for (i, (rank, _)) in count_groups.iter().enumerate().take(5) {
|
||||
tb[i] = *rank;
|
||||
}
|
||||
tb
|
||||
}
|
||||
};
|
||||
|
||||
HandScore { category, tiebreakers }
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use crate::logic::card::Suit;
|
||||
|
||||
fn c(suit: Suit, rank: u8) -> Card {
|
||||
Card::new(suit, rank)
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn erkennt_flush() {
|
||||
let hand = Hand::new(vec![
|
||||
c(Suit::Hearts, 2),
|
||||
c(Suit::Hearts, 5),
|
||||
c(Suit::Hearts, 9),
|
||||
c(Suit::Hearts, 11),
|
||||
c(Suit::Hearts, 13),
|
||||
]);
|
||||
assert_eq!(hand.evaluate().category, HandCategory::Flush);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn erkennt_straight_inklusive_wheel() {
|
||||
let hand = Hand::new(vec![
|
||||
c(Suit::Hearts, 14),
|
||||
c(Suit::Spades, 2),
|
||||
c(Suit::Clubs, 3),
|
||||
c(Suit::Diamonds, 4),
|
||||
c(Suit::Hearts, 5),
|
||||
]);
|
||||
let score = hand.evaluate();
|
||||
assert_eq!(score.category, HandCategory::Straight);
|
||||
assert_eq!(score.tiebreakers[0], 5); // Wheel: Ass zählt als 1, höchste Karte ist 5
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn full_house_schlaegt_flush() {
|
||||
let full_house = Hand::new(vec![
|
||||
c(Suit::Hearts, 7),
|
||||
c(Suit::Spades, 7),
|
||||
c(Suit::Clubs, 7),
|
||||
c(Suit::Diamonds, 3),
|
||||
c(Suit::Hearts, 3),
|
||||
]);
|
||||
let flush = Hand::new(vec![
|
||||
c(Suit::Hearts, 2),
|
||||
c(Suit::Hearts, 5),
|
||||
c(Suit::Hearts, 9),
|
||||
c(Suit::Hearts, 11),
|
||||
c(Suit::Hearts, 13),
|
||||
]);
|
||||
assert!(full_house.evaluate() > flush.evaluate());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn waehlt_beste_kombination_aus_sieben_karten() {
|
||||
// 2 Hole Cards + 5 Community Cards, enthält ein verstecktes Vierling.
|
||||
let hand = Hand::new(vec![
|
||||
c(Suit::Hearts, 9),
|
||||
c(Suit::Spades, 9),
|
||||
c(Suit::Clubs, 9),
|
||||
c(Suit::Diamonds, 9),
|
||||
c(Suit::Hearts, 2),
|
||||
c(Suit::Spades, 5),
|
||||
c(Suit::Clubs, 13),
|
||||
]);
|
||||
assert_eq!(hand.evaluate().category, HandCategory::FourOfAKind);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,39 @@
|
||||
pub mod card;
|
||||
pub mod hand;
|
||||
|
||||
use card::Card;
|
||||
use rand::seq::SliceRandom;
|
||||
use rand::thread_rng;
|
||||
|
||||
pub struct Deck {
|
||||
pub cards: Vec<Card>,
|
||||
}
|
||||
|
||||
impl Deck {
|
||||
pub fn new() -> Self {
|
||||
let mut cards = Vec::new();
|
||||
let suits = [card::Suit::Spades, card::Suit::Hearts, card::Suit::Diamonds, card::Suit::Clubs];
|
||||
for suit in suits.iter() {
|
||||
for rank in 2..=14 {
|
||||
cards.push(Card::new(*suit, rank));
|
||||
}
|
||||
}
|
||||
Self { cards }
|
||||
}
|
||||
|
||||
pub fn shuffle(&mut self) {
|
||||
let mut rng = thread_rng();
|
||||
self.cards.shuffle(&mut rng);
|
||||
}
|
||||
|
||||
/// Zieht eine einzelne Karte vom Ende des (gemischten) Decks.
|
||||
pub fn draw(&mut self) -> Option<Card> {
|
||||
self.cards.pop()
|
||||
}
|
||||
|
||||
/// Zieht `count` Karten. Ist das Deck vorher erschöpft, wird
|
||||
/// entsprechend weniger Karten zurückgegeben.
|
||||
pub fn deal_hand(&mut self, count: usize) -> Vec<Card> {
|
||||
(0..count).filter_map(|_| self.draw()).collect()
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,49 @@
|
||||
//! Netzwerkprotokoll für die Multiplayer-Synchronisation (siehe PLAN.md, Phase 2).
|
||||
//!
|
||||
//! Design-Entscheidung: Der Server ist die einzige Quelle der Wahrheit
|
||||
//! (führt `GameManager::take_action` autoritativ aus) und schickt dieselben
|
||||
//! "Announce"/"PlaySfx"-Häppchen an die Clients, die der lokale
|
||||
//! `game_plugin`-Code bereits als `Announce`/`PlaySfx`-Bevy-Messages kennt.
|
||||
//! Der Client muss also keine eigene Spiellogik nachbilden, sondern reicht
|
||||
//! ankommende `ServerMessage`s nur an TTS/SFX weiter (bzw. zeigt Fehler an).
|
||||
//!
|
||||
//! Sicherheitsaspekt: `Raise` enthält bewusst keinen vom Client gewählten
|
||||
//! Betrag - der Server bestimmt die Höhe selbst (`RAISE_INCREMENT`), damit
|
||||
//! ein Client nicht durch manipulierte Nachrichten beliebige Beträge setzen kann.
|
||||
|
||||
use serde::{Deserialize, Serialize};
|
||||
|
||||
use crate::logic::card::Card;
|
||||
|
||||
/// Nachrichten, die ein Client an den Server schickt.
|
||||
#[derive(Debug, Clone, Serialize, Deserialize)]
|
||||
pub enum ClientMessage {
|
||||
/// Tritt einem (ggf. neu anzulegenden) Tisch bei. `table_name` ermöglicht
|
||||
/// die einfache "Tischsuche" aus PLAN.md: bekannte Namen treffen auf
|
||||
/// denselben Tisch, unbekannte legen einen neuen an.
|
||||
JoinTable { table_name: String, player_name: String },
|
||||
Fold,
|
||||
Check,
|
||||
Call,
|
||||
Raise,
|
||||
}
|
||||
|
||||
/// Nachrichten, die der Server an (einen oder alle) Clients eines Tisches sendet.
|
||||
#[derive(Debug, Clone, Serialize, Deserialize)]
|
||||
pub enum ServerMessage {
|
||||
/// Antwort auf `JoinTable`: dem Client wurde diese Spieler-ID zugewiesen.
|
||||
Welcome { player_id: u32 },
|
||||
/// Textansage fürs TTS - identisch zum lokalen `Announce` in `game_plugin`.
|
||||
Announce(String),
|
||||
/// Soundeffekt-Cue fürs SFX - identisch zum lokalen `PlaySfx`.
|
||||
PlaySfx(String),
|
||||
/// Private Hole Cards; wird nur an den jeweiligen Spieler geschickt, nie gebroadcastet.
|
||||
HoleCards(Vec<Card>),
|
||||
/// Aktuell aufgedeckte Community Cards (kumulativ je nach Runde).
|
||||
CommunityCards(Vec<Card>),
|
||||
/// Wer als Nächstes agieren muss.
|
||||
TurnToAct { player_id: u32 },
|
||||
/// Aktion war ungültig (z. B. nicht am Zug, Tisch schon voll) oder ein
|
||||
/// sonstiger Fehler ist aufgetreten.
|
||||
Error(String),
|
||||
}
|
||||
Reference in New Issue
Block a user