Add omaha cash

Author: DogLooksGood

Cargo.lock

@@ -6,6 +6,7 @@ members = [
   "mtt-table",
   "mtt-base",
   "cash",
+  "omaha-cash",
   "ltmtt",
 ]
 

Cargo.toml

@@ -0,0 +1,14 @@
+.PHONY: release-all build-race-omaha-cash
+
+CRATES = race-omaha-cash race-holdem-cash race-holdem-mtt-table race-holdem-mtt
+
+all: $(CRATES)
+
+define BUILD_template
+.PHONY: $(1)
+$(1):
+	cargo build -r --target wasm32-unknown-unknown -p $(1)
+	wasm-opt -Oz target/wasm32-unknown-unknown/release/$$(subst -,_,$(1)).wasm -o target/$$(subst -,_,$(1)).wasm
+endef
+
+$(foreach crate,$(CRATES), $(eval $(call BUILD_template,$(crate))))

Justfile

@@ -1,5 +1,5 @@
 [package]
-name = "race-holdem-base"
+name = "race-poker-base"
 version = "0.1.0"
 edition = "2021"
 

Makefile

@@ -33,8 +33,10 @@ custom_err!(not_the_acting_player_to_call);
 custom_err!(not_the_acting_player);
 custom_err!(player_cant_bet);
 custom_err!(player_cant_call);
-custom_err!(bet_amonut_is_too_small);
+custom_err!(bet_amount_is_too_small);
 custom_err!(raise_amount_is_too_small);
+custom_err!(raise_exceeds_pot_limit);
+custom_err!(bet_exceeds_pot_limit);
 custom_err!(player_already_betted);
 custom_err!(player_cant_check);
 custom_err!(player_cant_raise);

base/Cargo.toml

@@ -701,7 +701,7 @@ impl<V: GameVariant> PokerGame<V> {
 
     /// Reveal community cards according to current street
     pub fn update_board(&mut self, effect: &mut Effect) -> Result<(), HandleError> {
-        let players_cnt = self.count_ingame_players() * 2;
+        let players_cnt = self.count_ingame_players() * self.variant.hole_card_count();
         match self.street {
             Street::Flop => {
                 effect.reveal(
@@ -1081,7 +1081,7 @@ impl<V: GameVariant> PokerGame<V> {
                 }
             }
 
-            let board_start = self.hand_index_map.len() * 2;
+            let board_start = self.count_ingame_players() * self.variant.hole_card_count();
             effect.reveal(
                 self.deck_random_id,
                 (board_start..(board_start + 5)).collect(),
@@ -1212,10 +1212,12 @@ impl<V: GameVariant> PokerGame<V> {
                     return Err(errors::player_cant_bet());
                 }
 
-                // When bet amount is less than 1BB, only allin is allowed.
-                if self.bb > amount && player.chips != amount {
-                    return Err(errors::bet_amonut_is_too_small());
-                }
+                self.variant.validate_bet_amount(
+                    amount,
+                    self.bb,
+                    player.chips,
+                    &self.pots,
+                )?;
 
                 let (allin, real_bet_amount) = self.take_bet(sender.clone(), amount)?;
                 self.set_player_acted(sender, allin)?;
@@ -1284,12 +1286,18 @@ impl<V: GameVariant> PokerGame<V> {
 
                 let betted = self.get_player_bet(sender);
 
+                let bet_sum_of_all_players = self.bet_map.values().sum::<u64>();
+
+                effect.info(format!("player.chips = {}, betted = {}, amount = {}, self.street_bet = {}, self.min_raise = {}, bet_sum_of_all_players = {}, pots = {}",
+                    player.chips, betted, amount, self.street_bet, self.min_raise, bet_sum_of_all_players, self.pots.iter().map(|p| p.amount).sum::<u64>()));
+
                 self.variant.validate_raise_amount(
+                    amount,
                     player.chips,
                     betted,
-                    amount,
                     self.street_bet,
                     self.min_raise,
+                    bet_sum_of_all_players,
                     &self.pots,
                 )?;
 
@@ -1767,17 +1775,24 @@ impl<V: GameVariant> GameHandler for PokerGame<V> {
             }
 
             Event::RandomnessReady { .. } => {
+                let hole_card_count = self.variant.hole_card_count();
+
                 for (idx, id) in self.player_order.iter().enumerate() {
-                    effect.assign(self.deck_random_id, *id, vec![idx * 2, idx * 2 + 1])?;
-                    self.hand_index_map.insert(*id, vec![idx * 2, idx * 2 + 1]);
+                    let mut indices: Vec<usize> = Vec::with_capacity(hole_card_count);
+                    for i in 0..hole_card_count {
+                        indices.push(idx * hole_card_count + i);
+                    }
+
+                    effect.assign(self.deck_random_id, *id, indices.clone())?;
+                    self.hand_index_map.insert(*id, indices);
                 }
 
                 Ok(())
             }
 
             Event::SecretsReady { .. } => match self.stage {
                 HoldemStage::ShareKey => {
-                    let players_cnt = self.count_ingame_players() * 2;
+                    let players_cnt = self.count_ingame_players() * self.variant.hole_card_count();
                     let board_prev_cnt = self.board.len();
                     self.stage = HoldemStage::Play;
 

base/src/errors.rs

@@ -1,8 +1,11 @@
 // Holdem implementation for GameVariant
 
+use std::collections::{BTreeMap, HashMap};
 use crate::hand_history::Showdown;
 use crate::variant::{EvaluateHandsOutput, GameVariant};
-use crate::evaluator::evaluate_cards;
+use crate::holdem_evaluator::{PlayerHand, evaluate_cards, create_cards, compare_hands};
+use crate::essential::Pot;
+use crate::errors;
 use race_api::prelude::*;
 
 #[derive(BorshSerialize, BorshDeserialize, Default, Debug, PartialEq, Clone)]
@@ -17,8 +20,9 @@ impl GameVariant for HoldemVariant {
 
     fn evaluate_hands(
         &self,
-        board: &[&str],
-        hole_cards: &[&str],
+        board: &[String],
+        hand_index_map: &BTreeMap<u64, Vec<usize>>,
+        revealed_cards: &HashMap<usize, String>,
     ) -> HandleResult<EvaluateHandsOutput> {
         // A temporary struct to hold all evaluation results before sorting
         struct EvalResult {
@@ -32,19 +36,20 @@ impl GameVariant for HoldemVariant {
 
         // Step 1: Evaluate each player's hand and build the Showdown struct.
         for (&player_id, indices) in hand_index_map.iter() {
-            let card1 = revealed.get(&indices[0]).ok_or_else(errors::first_hole_card_error)?;
-            let card2 = revealed.get(&indices[1]).ok_or_else(errors::second_hole_card_error)?;
+            let card1 = revealed_cards.get(&indices[0]).ok_or_else(errors::first_hole_card_error)?;
+            let card2 = revealed_cards.get(&indices[1]).ok_or_else(errors::second_hole_card_error)?;
             let hole_cards = vec![card1.clone(), card2.clone()];
 
-            let all_cards = create_cards(board, &[card1.as_str(), card2.as_str()]);
+            let board_cards: Vec<&str> = board.into_iter().map(|x| x.as_ref()).collect();
+            let all_cards = create_cards(&board_cards, &[card1.as_str(), card2.as_str()]);
 
             // The evaluator now returns a richer PlayerHand struct
             let hand = evaluate_cards(all_cards);
 
             let showdown = Showdown {
                 hole_cards,
                 category: hand.category.clone(),
-                picks: hand.picks.clone(),
+                picks: hand.picks.iter().map(|x| x.to_string()).collect(),
             };
             results.push(EvalResult { player_id, hand, showdown });
         }
@@ -75,16 +80,33 @@ impl GameVariant for HoldemVariant {
         })
     }
 
+    /// Validates a bet amount
+    fn validate_bet_amount(
+        &self,
+        bet_amount: u64,
+        bb: u64,
+        player_chips: u64,
+        _pots: &[Pot],
+    ) -> HandleResult<()> {
+        // The bet must meet the minimum bet requirement(1BB), unless it's an all-in.
+        if bet_amount < bb && bet_amount != player_chips {
+            return Err(errors::bet_amount_is_too_small());
+        }
+
+        Ok(())
+    }
+
     fn validate_raise_amount(
         &self,
         player_chips: u64,
         betted: u64,
         raise_amount: u64,
         street_bet: u64,
         min_raise: u64,
-        pots: &[Pot],
+        _bet_sum_of_all_players: u64,
+        _pots: &[Pot],
     ) -> HandleResult<()> {
-        let total_new_bet = player_bet + raise_amount;
+        let total_new_bet = betted + raise_amount;
 
         // An all-in is always a valid raise amount, even if it's less than a min-raise.
         if raise_amount == player_chips {