From 18fecaec1a64db22cf12607b306cdd1b7d241025 Mon Sep 17 00:00:00 2001
From: becfang13 <fangruihan2021@gmail.com>
Date: Fri, 2 May 2025 18:23:01 +1000
Subject: [PATCH 1/6] new comment

---
 submission/mybot.py | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/submission/mybot.py b/submission/mybot.py
index f3678d1..79506ff 100644
--- a/submission/mybot.py
+++ b/submission/mybot.py
@@ -1,6 +1,8 @@
 import random
 from pypokerengine.players import BasePokerPlayer
 
+# hi - rebecca 
+
 # Notes
 # All cards follow this format: Suit + Rank : 4 of Hearts = 4H, 10 of Spades = ST [2,3,4,5,6,7,8,9,T,J,Q,K,A] [S,C,D,H]
 

From f8b7f0be0bc024a6684cc88eb1f61a7d6fb3fc76 Mon Sep 17 00:00:00 2001
From: Dhruv Gupta <dhruv6upt4@gmail.com>
Date: Sat, 3 May 2025 11:26:46 +1000
Subject: [PATCH 2/6] Update player_game.html

---
 pypokergui/server/templates/player_game.html | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pypokergui/server/templates/player_game.html b/pypokergui/server/templates/player_game.html
index 8417aa1..f0e4bb7 100644
--- a/pypokergui/server/templates/player_game.html
+++ b/pypokergui/server/templates/player_game.html
@@ -7,7 +7,7 @@
   <div>
     <span class="round-state-table-text player-name">{{player["name"]}}</span></br>
     <span class="round-state-table-text player-stack">${{player["stack"]}}</span></br>
-    {% if round_state["dealer_btn"]==int(player['uuid']) %}
+    {% if round_state["dealer_btn"]==(player['uuid']) %}
       <span class="label label-warning">Dealer</span>
     {% end %}
     <!--

From d3887c26759340f881e3a7825c272cdaba7195f7 Mon Sep 17 00:00:00 2001
From: becfang13 <fangruihan2021@gmail.com>
Date: Sat, 3 May 2025 11:50:30 +1000
Subject: [PATCH 3/6] Update mybot.py

---
 submission/mybot.py | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/submission/mybot.py b/submission/mybot.py
index 79506ff..09287a7 100644
--- a/submission/mybot.py
+++ b/submission/mybot.py
@@ -1,8 +1,6 @@
 import random
 from pypokerengine.players import BasePokerPlayer
 
-# hi - rebecca 
-
 # Notes
 # All cards follow this format: Suit + Rank : 4 of Hearts = 4H, 10 of Spades = ST [2,3,4,5,6,7,8,9,T,J,Q,K,A] [S,C,D,H]
 
@@ -98,4 +96,3 @@ def do_all_in(self,  valid_actions):
         return action_info['action'], amount
 
 
-

From 69679f8063ff3b6c7a4984bfe64ab91b014e373f Mon Sep 17 00:00:00 2001
From: becfang13 <fangruihan2021@gmail.com>
Date: Sat, 3 May 2025 11:56:53 +1000
Subject: [PATCH 4/6] change speed

---
 pypokergui/server/message_manager.py |   4 +-
 submission/mybot.py                  | 192 ++++++++++++++++++---------
 2 files changed, 132 insertions(+), 64 deletions(-)

diff --git a/pypokergui/server/message_manager.py b/pypokergui/server/message_manager.py
index 0a39fc9..c23322f 100644
--- a/pypokergui/server/message_manager.py
+++ b/pypokergui/server/message_manager.py
@@ -292,9 +292,9 @@ def _calc_wait_interval(mode, update):
 
 FAST_WAIT_INTERVAL = {
     'round_start_message': 1,
-    'street_start_message': 0.5,
+    'street_start_message': 0.1,
     'ask_message': 0,
-    'game_update_message': 0.5,
+    'game_update_message': 0.1,
     'round_result_message': 15,
     'game_result_message': 0
 }
\ No newline at end of file
diff --git a/submission/mybot.py b/submission/mybot.py
index 09287a7..deb1c66 100644
--- a/submission/mybot.py
+++ b/submission/mybot.py
@@ -1,65 +1,139 @@
-import random
 from pypokerengine.players import BasePokerPlayer
-
-# Notes
-# All cards follow this format: Suit + Rank : 4 of Hearts = 4H, 10 of Spades = ST [2,3,4,5,6,7,8,9,T,J,Q,K,A] [S,C,D,H]
+from pypokerengine.utils.card_utils import gen_cards, estimate_hole_card_win_rate
+import random
 
 def setup_ai():
-    return MyBot()
+    return SmartPokerBot()
+
+class SmartPokerBot(BasePokerPlayer):
 
-class MyBot(BasePokerPlayer):  # Do not forget to make parent class as "BasePokerPlayer"
+    def __init__(self):
+        super().__init__()
+        self.aggression_factor = 1.3  # Controls how aggressive the bot is
+        self.bluff_frequency = 0.15   # 15% chance to bluff in appropriate situations
+        self.last_action = None
 
-    #  we define the logic to make an action through this method. (so this method would be the core of your AI)
     def declare_action(self, valid_actions, hole_card, round_state):
-        # For your convenience:
-        community_card = round_state['community_card']                  # array, starting from [] to [] of 5 elems
-        street = round_state['street']                                  # preflop, flop, turn, river
-        pot = round_state['pot']                                        # dict : {'main': {'amount': int}, 'side': {'amount': int}}
-        dealer_btn = round_state['dealer_btn']                          # int : user id of the player acting as the dealer
-        next_player = round_state['next_player']                        # int : user id of next player
-        small_blind_pos = round_state['small_blind_pos']                # int : user id of player with small blind (next player is big blind)
-        big_blind_pos = round_state['big_blind_pos']                    # int : user id of player with big blind
-        round_count = round_state['round_count']                        # int : round number
-        small_blind_amount = round_state['small_blind_amount']          # int : amount of starting small blind
-        seats = round_state['seats']                                    # {'name' : the AI name, 'uuid': their user id, 'stack': their stack/remaining money, 'state': participating/folded}
-                                                                        # we recommend if you're going to try to find your own user id, name your own class name and ai name the same
-        action_histories = round_state['action_histories']              # {'preflop': [{'action': 'SMALLBLIND', 'amount': 10, 'add_amount': 10, 'uuid': '1'}, {'action': 'BIGBLIND', 'amount': 20, 'add_amount': 10, 'uuid': '2'},
-                                                                        #   {'action': 'CALL', 'amount': 20, 'paid': 20, 'uuid': '3'}, {'action': 'CALL', 'amount': 20, 'paid': 20, 'uuid': '0'}, 
-                                                                        #   {'action': 'CALL', 'amount': 20, 'paid': 10, 'uuid': '1'}, {'action': 'FOLD', 'uuid': '2'}]}   -- sample action history for preflop
-                                                                        # {'flop': [{'action': 'CALL', 'amount': 0, 'paid': 0, 'uuid': '1'}]}  -- sample for flop
-
-        # Minimum and maximum raise values (max raise ==> all in)
-        min_raise = valid_actions[2]['amount']['min']
-        max_raise = valid_actions[2]['amount']['max']
-
-
-        # --------------------------------------------------------------------------------------------------------#
+        # Extract game information
+        community_cards = round_state['community_card']
+        street = round_state['street']
+        pot_size = round_state['pot']['main']['amount']
+        action_history = round_state['action_histories'].get(street, [])
+        
+        # Calculate hand strength
+        win_rate = self.evaluate_hand(hole_card, community_cards, round_state)
+        hand_strength = self.classify_hand_strength(win_rate)
+        
+        # Get position information
+        position = self.get_position(round_state)
+        
+        # Determine action based on strategy
+        action, amount = self.determine_action(
+            valid_actions, 
+            hand_strength, 
+            position, 
+            pot_size, 
+            street, 
+            action_history
+        )
+        
+        self.last_action = action
+        return action, amount
+
+    def evaluate_hand(self, hole_card, community_cards, round_state):
+        # Convert cards to pypokerengine format
+        hole = gen_cards(hole_card)
+        community = gen_cards(community_cards)
+        
+        # Estimate win probability (monte carlo simulation)
+        win_rate = estimate_hole_card_win_rate(
+            nb_simulation=1000,
+            nb_player=self.count_active_players(round_state),
+            hole_card=hole,
+            community_card=community
+        )
+        return win_rate
+
+    def count_active_players(self, round_state):
+        return len([seat for seat in round_state['seats'] if seat['state'] == 'participating'])
+
+    def classify_hand_strength(self, win_rate):
+        if win_rate > 0.85: return "VERY_STRONG"
+        if win_rate > 0.65: return "STRONG"
+        if win_rate > 0.45: return "MEDIUM"
+        if win_rate > 0.25: return "WEAK"
+        return "VERY_WEAK"
+
+    def get_position(self, round_state):
+        btn_pos = round_state['dealer_btn']
+        my_pos = [i for i, seat in enumerate(round_state['seats']) if seat['uuid'] == self.uuid][0]
+        relative_pos = (my_pos - btn_pos) % len(round_state['seats'])
+        return "early" if relative_pos < 2 else "late" if relative_pos > 3 else "middle"
+
+    def determine_action(self, valid_actions, hand_strength, position, pot_size, street, action_history):
+        # Basic strategy implementation
+        can_raise = valid_actions[2]['amount']['min'] != -1
+        min_raise = valid_actions[2]['amount']['min'] if can_raise else 0
+        max_raise = valid_actions[2]['amount']['max'] if can_raise else 0
+        call_amount = valid_actions[1]['amount']
+        
+        # Adjust strategy based on position
+        position_factor = 1.2 if position == "late" else 0.8 if position == "early" else 1.0
+        
+        # Consider previous actions
+        opponents_aggressive = any(
+            act['action'] in ['raise', 'allin'] 
+            for act in action_history 
+            if act['uuid'] != self.uuid
+        )
+        
+        # Bluff opportunity detection
+        should_bluff = (random.random() < self.bluff_frequency and 
+                       street != 'preflop' and 
+                       len(action_history) < 3 and 
+                       not opponents_aggressive)
         
-        # Sample code: feel free to rewrite
-        action = random.choice(valid_actions)["action"]
-        if action == "raise":
-            action_info = valid_actions[2]
-            amount = random.randint(action_info["amount"]["min"], action_info["amount"]["max"])
-            if amount == -1: action = "call"
-        if action == "call":
+        # Action decision logic
+        if hand_strength == "VERY_STRONG":
+            if can_raise:
+                raise_amount = min(max_raise, int(pot_size * 0.75 * self.aggression_factor * position_factor))
+                return self.do_raise(valid_actions, raise_amount)
             return self.do_call(valid_actions)
-        if action == "fold":
+            
+        elif hand_strength == "STRONG":
+            if can_raise and (position == "late" or not opponents_aggressive):
+                raise_amount = min(max_raise, int(pot_size * 0.5 * self.aggression_factor * position_factor))
+                return self.do_raise(valid_actions, raise_amount)
+            return self.do_call(valid_actions)
+            
+        elif hand_strength == "MEDIUM":
+            if should_bluff and can_raise:
+                return self.do_raise(valid_actions, min_raise)
+            if call_amount == 0 or (position == "late" and not opponents_aggressive):
+                return self.do_call(valid_actions)
+            if opponents_aggressive and call_amount > pot_size * 0.3:
+                return self.do_fold(valid_actions)
+            return self.do_call(valid_actions)
+            
+        elif hand_strength == "WEAK":
+            if should_bluff and can_raise and position == "late":
+                return self.do_raise(valid_actions, min_raise)
+            if call_amount == 0:
+                return self.do_call(valid_actions)
+            if call_amount > pot_size * 0.15 or opponents_aggressive:
+                return self.do_fold(valid_actions)
+            return self.do_call(valid_actions)
+            
+        else:  # VERY_WEAK
+            if should_bluff and can_raise and position == "late" and len(action_history) == 0:
+                return self.do_raise(valid_actions, min_raise)
+            if call_amount == 0:
+                return self.do_call(valid_actions)
             return self.do_fold(valid_actions)
-        return self.do_raise(valid_actions, amount)   # action returned here is sent to the poker engine
-    
-        # -------------------------------------------------------------------------------------------------------#
-        # Make sure that you call one of the actions (self.do_fold, self.do_call, self.do_raise, self.do_all_in)
-        # All in is defined as raise using all of your remaining stack (chips)
-
-
 
+    # The following methods are unchanged from the original
     def receive_game_start_message(self, game_info):
-        # Predefined variables for various game information --  feel free to use them however you like
-        player_num = game_info["player_num"]
-        max_round = game_info["rule"]["max_round"]
-        small_blind_amount = game_info["rule"]["small_blind_amount"]
-        ante_amount = game_info["rule"]["ante"]
-        blind_structure = game_info["rule"]["blind_structure"]
+        pass
 
     def receive_round_start_message(self, round_count, hole_card, seats):
         pass
@@ -73,26 +147,20 @@ def receive_game_update_message(self, action, round_state):
     def receive_round_result_message(self, winners, hand_info, round_state):
         pass
 
-
-    # Helper functions  -- call these in the declare_action function to declare your move
     def do_fold(self, valid_actions):
         action_info = valid_actions[0]
-        amount = action_info["amount"]
-        return action_info['action'], amount
+        return action_info['action'], action_info["amount"]
 
     def do_call(self, valid_actions):
         action_info = valid_actions[1]
-        amount = action_info["amount"]
-        return action_info['action'], amount
+        return action_info['action'], action_info["amount"]
     
-    def do_raise(self,  valid_actions, raise_amount):
+    def do_raise(self, valid_actions, raise_amount):
         action_info = valid_actions[2]
         amount = max(action_info['amount']['min'], raise_amount)
         return action_info['action'], amount
     
-    def do_all_in(self,  valid_actions):
+    def do_all_in(self, valid_actions):
         action_info = valid_actions[2]
         amount = action_info['amount']['max']
-        return action_info['action'], amount
-
-
+        return action_info['action'], amount
\ No newline at end of file

From cf5a9563e4b49213693dc25e61146efef91867f1 Mon Sep 17 00:00:00 2001
From: becfang13 <fangruihan2021@gmail.com>
Date: Sat, 3 May 2025 12:02:04 +1000
Subject: [PATCH 5/6] speed

---
 pypokergui/server/message_manager.py | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/pypokergui/server/message_manager.py b/pypokergui/server/message_manager.py
index c23322f..11832d6 100644
--- a/pypokergui/server/message_manager.py
+++ b/pypokergui/server/message_manager.py
@@ -291,10 +291,10 @@ def _calc_wait_interval(mode, update):
 }
 
 FAST_WAIT_INTERVAL = {
-    'round_start_message': 1,
-    'street_start_message': 0.1,
+    'round_start_message': 0,
+    'street_start_message': 0,
     'ask_message': 0,
-    'game_update_message': 0.1,
-    'round_result_message': 15,
+    'game_update_message': 0,
+    'round_result_message': 5,
     'game_result_message': 0
 }
\ No newline at end of file

From fae3873978c3780383e4945a71eae9172ea6d5da Mon Sep 17 00:00:00 2001
From: becfang13 <fangruihan2021@gmail.com>
Date: Sat, 3 May 2025 18:19:58 +1000
Subject: [PATCH 6/6] all in bot

---
 submission/mybot.py | 148 ++++----------------------------------------
 1 file changed, 11 insertions(+), 137 deletions(-)

diff --git a/submission/mybot.py b/submission/mybot.py
index deb1c66..6439ce0 100644
--- a/submission/mybot.py
+++ b/submission/mybot.py
@@ -1,137 +1,19 @@
 from pypokerengine.players import BasePokerPlayer
-from pypokerengine.utils.card_utils import gen_cards, estimate_hole_card_win_rate
-import random
 
 def setup_ai():
-    return SmartPokerBot()
-
-class SmartPokerBot(BasePokerPlayer):
+    return AllInBot()
 
+class AllInBot(BasePokerPlayer):
     def __init__(self):
         super().__init__()
-        self.aggression_factor = 1.3  # Controls how aggressive the bot is
-        self.bluff_frequency = 0.15   # 15% chance to bluff in appropriate situations
-        self.last_action = None
 
     def declare_action(self, valid_actions, hole_card, round_state):
-        # Extract game information
-        community_cards = round_state['community_card']
-        street = round_state['street']
-        pot_size = round_state['pot']['main']['amount']
-        action_history = round_state['action_histories'].get(street, [])
-        
-        # Calculate hand strength
-        win_rate = self.evaluate_hand(hole_card, community_cards, round_state)
-        hand_strength = self.classify_hand_strength(win_rate)
-        
-        # Get position information
-        position = self.get_position(round_state)
-        
-        # Determine action based on strategy
-        action, amount = self.determine_action(
-            valid_actions, 
-            hand_strength, 
-            position, 
-            pot_size, 
-            street, 
-            action_history
-        )
-        
-        self.last_action = action
-        return action, amount
-
-    def evaluate_hand(self, hole_card, community_cards, round_state):
-        # Convert cards to pypokerengine format
-        hole = gen_cards(hole_card)
-        community = gen_cards(community_cards)
-        
-        # Estimate win probability (monte carlo simulation)
-        win_rate = estimate_hole_card_win_rate(
-            nb_simulation=1000,
-            nb_player=self.count_active_players(round_state),
-            hole_card=hole,
-            community_card=community
-        )
-        return win_rate
-
-    def count_active_players(self, round_state):
-        return len([seat for seat in round_state['seats'] if seat['state'] == 'participating'])
-
-    def classify_hand_strength(self, win_rate):
-        if win_rate > 0.85: return "VERY_STRONG"
-        if win_rate > 0.65: return "STRONG"
-        if win_rate > 0.45: return "MEDIUM"
-        if win_rate > 0.25: return "WEAK"
-        return "VERY_WEAK"
-
-    def get_position(self, round_state):
-        btn_pos = round_state['dealer_btn']
-        my_pos = [i for i, seat in enumerate(round_state['seats']) if seat['uuid'] == self.uuid][0]
-        relative_pos = (my_pos - btn_pos) % len(round_state['seats'])
-        return "early" if relative_pos < 2 else "late" if relative_pos > 3 else "middle"
-
-    def determine_action(self, valid_actions, hand_strength, position, pot_size, street, action_history):
-        # Basic strategy implementation
-        can_raise = valid_actions[2]['amount']['min'] != -1
-        min_raise = valid_actions[2]['amount']['min'] if can_raise else 0
-        max_raise = valid_actions[2]['amount']['max'] if can_raise else 0
-        call_amount = valid_actions[1]['amount']
-        
-        # Adjust strategy based on position
-        position_factor = 1.2 if position == "late" else 0.8 if position == "early" else 1.0
-        
-        # Consider previous actions
-        opponents_aggressive = any(
-            act['action'] in ['raise', 'allin'] 
-            for act in action_history 
-            if act['uuid'] != self.uuid
-        )
-        
-        # Bluff opportunity detection
-        should_bluff = (random.random() < self.bluff_frequency and 
-                       street != 'preflop' and 
-                       len(action_history) < 3 and 
-                       not opponents_aggressive)
-        
-        # Action decision logic
-        if hand_strength == "VERY_STRONG":
-            if can_raise:
-                raise_amount = min(max_raise, int(pot_size * 0.75 * self.aggression_factor * position_factor))
-                return self.do_raise(valid_actions, raise_amount)
-            return self.do_call(valid_actions)
-            
-        elif hand_strength == "STRONG":
-            if can_raise and (position == "late" or not opponents_aggressive):
-                raise_amount = min(max_raise, int(pot_size * 0.5 * self.aggression_factor * position_factor))
-                return self.do_raise(valid_actions, raise_amount)
-            return self.do_call(valid_actions)
-            
-        elif hand_strength == "MEDIUM":
-            if should_bluff and can_raise:
-                return self.do_raise(valid_actions, min_raise)
-            if call_amount == 0 or (position == "late" and not opponents_aggressive):
-                return self.do_call(valid_actions)
-            if opponents_aggressive and call_amount > pot_size * 0.3:
-                return self.do_fold(valid_actions)
-            return self.do_call(valid_actions)
-            
-        elif hand_strength == "WEAK":
-            if should_bluff and can_raise and position == "late":
-                return self.do_raise(valid_actions, min_raise)
-            if call_amount == 0:
-                return self.do_call(valid_actions)
-            if call_amount > pot_size * 0.15 or opponents_aggressive:
-                return self.do_fold(valid_actions)
-            return self.do_call(valid_actions)
-            
-        else:  # VERY_WEAK
-            if should_bluff and can_raise and position == "late" and len(action_history) == 0:
-                return self.do_raise(valid_actions, min_raise)
-            if call_amount == 0:
-                return self.do_call(valid_actions)
+        # Always go all-in if possible
+        my_stack = next((seat['stack'] for seat in round_state['seats'] if seat['uuid'] == self.uuid), 0)
+        if my_stack == 0:
             return self.do_fold(valid_actions)
+        return self.do_all_in(valid_actions)
 
-    # The following methods are unchanged from the original
     def receive_game_start_message(self, game_info):
         pass
 
@@ -147,20 +29,12 @@ def receive_game_update_message(self, action, round_state):
     def receive_round_result_message(self, winners, hand_info, round_state):
         pass
 
+    # Helper functions
     def do_fold(self, valid_actions):
-        action_info = valid_actions[0]
-        return action_info['action'], action_info["amount"]
+        action_info = next((act for act in valid_actions if act['action'] == 'fold'), valid_actions[0])
+        return action_info['action'], action_info['amount']
 
-    def do_call(self, valid_actions):
-        action_info = valid_actions[1]
-        return action_info['action'], action_info["amount"]
-    
-    def do_raise(self, valid_actions, raise_amount):
-        action_info = valid_actions[2]
-        amount = max(action_info['amount']['min'], raise_amount)
-        return action_info['action'], amount
-    
     def do_all_in(self, valid_actions):
-        action_info = valid_actions[2]
+        action_info = next((act for act in valid_actions if act['action'] == 'raise'), valid_actions[2])
         amount = action_info['amount']['max']
-        return action_info['action'], amount
\ No newline at end of file
+        return action_info['action'], amount