bitpoker 0.1.1

data/lib/bitpoker/croupier.rb

@@ -0,0 +1,99 @@
+module BitPoker
+   
+      
+   #
+   #
+   # @author Mckomo
+   class Croupier 
+      
+      attr_reader :rules
+      
+      include GameLogic
+      
+      def initialize( custom_rules = {} )
+         setup_with( custom_rules )
+         @prng = Random.new
+      end
+      
+      def call( bot, action, args = [] )
+      
+         raise ArgumentError, "Croupier plays only with BotProxy." unless bot.kind_of? BotProxyInterface
+      
+         begin
+            # Get bot response within timeout
+            bot_response = timeout( @rules[:timeout] ) do
+                bot.trigger( action, args )
+            end
+         rescue Timeout::Error
+            raise BitPoker::BotError.new(  bot, "Bot exceeded timeout" )
+         rescue NotImplementedError
+            raise BitPoker::BotError.new(  bot, "Bot does not implement '#{action}' action" )
+         rescue => e
+            raise BitPoker::BotError.new(  bot, "Bot failed during '#{action}' action execution." )
+         end
+         
+         # Validate response if yield given
+         if block_given?
+            raise BitPoker::BotError.new( bot, "Bot response '#{bot_response}' after '#{action}' action is invalid" ) unless yield( bot_response )
+         end
+         
+         bot_response
+
+      end
+   
+      #
+      #
+      #
+      #
+      #
+      def parallel_call( bots, action, *args_list )
+         
+         Parallel.map_with_index( bots, { :in_threads => 2 } ) do |b, i|
+            # Get args 
+            args = args_list[i] || args_list[0]
+            # Call bot with or without yield
+            if block_given?
+               call( b, action, args ) do |result| 
+                  yield( result )
+               end
+            else
+               call( b, action, args )
+            end
+         end
+         
+      end
+      
+      #
+      #
+      #
+      def round_rules
+         {
+            "min_card"  => @rules[:card_range].min,
+            "max_card"  => @rules[:card_range].max,
+            "max_stake" => @rules[:max_stake],
+            "timeout"   => @rules[:timeout]
+         }
+      end
+      
+      def deal_cards
+         [ @prng.rand( Rules::CARD_RANGE ), @prng.rand( Rules::CARD_RANGE ) ]
+      end
+      
+      def rules=( custom_rules )
+         setup( custom_rules )
+      end
+      
+      def setup_with( rules )
+         @rules = {
+             rounds:       rules[:rounds]     || Rules::ROUNDS,
+             min_stake:    rules[:min_stake]  || Rules::MIN_STAKE,
+             max_stake:    rules[:max_stake]  || Rules::MAX_STAKE,
+             timeout:      rules[:timeout]    || Rules::TIMEOUT,
+             card_range:   rules[:card_range] || Rules::CARD_RANGE,
+         }
+      end
+   
+   end
+
+   
+end

data/lib/bitpoker/duel.rb

@@ -0,0 +1,71 @@
+module BitPoker
+   
+   # Basic element of the BitPoker game 
+   # - poker duel between two bots
+   # 
+   # @author Mckomo
+   class Duel
+               
+      attr_reader :options, :total_score
+      
+      # Constructor of a duel object
+      #
+      # @parma    [Croupier]           croupier Croupier that will perform duel
+      # @param    [BotProxyInterface]  bot_one  First bot to participate the duel
+      # @param    [BotProxyInterface]  bot_two  Second bot to participate the duel
+      # @return   [Duel]
+      def initialize( croupier, bot_one, bot_two )
+         
+         # Check if interfaces are implemented
+         raise ArgumentError, "Proxy one does not implement ProxyInterface." unless bot_one.kind_of?( BitPoker::BotProxyInterface )
+         raise ArgumentError, "Proxy two does not implement ProxyInterface." unless bot_two.kind_of?( BitPoker::BotProxyInterface )
+         
+         # Set dependencies
+         @croupier = croupier
+         @bots = [bot_one, bot_two]
+         
+         # Set properties
+         @round_counter = 0
+         @finished = false            # Note: look on 'finished?' method
+
+         # Init score table with 0
+         @total_score = [0, 0]
+         
+      end
+
+      # Play one round of the BitPoker
+      #
+      # @return [Duel]
+      def play_round
+
+         # Don't perform deal if a game is finished
+         return nil if finished?
+ 
+         @round_counter += 1
+          
+         # Init new round
+         round = Round.new( @bots )
+         
+         # Proceed round process until it is finished
+         until round.state == Round::STATE_FINISHED do
+            @croupier.perform_next_step( round )
+         end
+         
+         # Update total score
+         @total_score[0] += round.score[0]
+         @total_score[1] += round.score[1]
+         
+         self
+
+      end
+      
+      # Return state of the duel
+      #
+      # @return   [Mixed]  True of false
+      def finished?
+         @round_counter >= @croupier.rules[:rounds]
+      end
+   
+   end
+   
+end

data/lib/bitpoker/game_logic.rb

@@ -0,0 +1,186 @@
+module BitPoker
+   
+   module GameLogic
+      
+      def perform_next_step( round )
+         
+         case round.state
+         when Round::STATE_RULES_INTRODUCTION
+            perform_rules_introduction( round )
+         when Round::STATE_CARD_DEAL
+            perform_card_deal( round )
+         when Round::STATE_FIRST_BETTING
+            perform_first_betting( round )
+         when Round::STATE_FIRST_CALL
+            perform_first_call( round )
+         when Round::STATE_FIRST_CALLED
+            perform_first_called( round )
+         when Round::STATE_SECOND_BETTING
+            perform_second_betting( round )
+         when Round::STATE_SECOND_CALL
+            perform_second_call( round )
+         when Round::STATE_SECOND_CALLED
+            perform_second_called( round )
+         when Round::STATE_FOLDED
+            perform_folded( round )
+         when Round::STATE_SHOWDOWN
+            perform_showdown( round )
+         when Round::STATE_POINTS_DISTRIBUTION
+            perform_points_distributions( round )
+         else
+            raise "Unsupported state"
+         end
+         
+      end
+      
+      private
+      
+      def perform_rules_introduction( round )
+         
+         # Inform bots about rules
+         parallel_call( round.bots, :introduce, [round_rules] )
+         # Change round.state to first round of betting
+         round.state = Round::STATE_CARD_DEAL
+
+      end
+      
+      def perform_card_deal( round )
+         
+         # Set random cards
+         round.cards = deal_cards
+         # Give bots cards
+         parallel_call( round.bots, :get_card, round.cards[0], round.cards[1] )
+         # Change round.state to first round of betting
+         round.state = Round::STATE_FIRST_BETTING
+
+      end
+   
+      def perform_first_betting( round )
+         
+         min_stake = @rules[:min_stake]        # Just shortcuts, no rocket science!
+         max_stake = @rules[:max_stake]
+         
+         # Ask bots for bets
+         round.bets = parallel_call( round.bots, :bet_one, min_stake ) do |bet|
+            ( min_stake .. max_stake ).include?( bet )
+         end
+                  
+         if round.bets_even?
+            # If bets are even go to second betting at once
+            round.state = Round::STATE_SECOND_BETTING
+         else
+            # Otherwise perform first call
+            round.state = Round::STATE_FIRST_CALL
+         end
+         
+      end
+   
+      def perform_first_call( round )
+         
+         # Ask lower bidder if calls the stake
+         has_called = call( round.lower_bidder, :agree_one, round.stake )
+         
+         if has_called
+            # Continue with second betting
+            round.state = Round::STATE_FIRST_CALLED
+         else
+            # Lower bidder has folded
+            round.state = Round::STATE_FOLDED
+         end
+         
+      end
+      
+      def perform_first_called( round )
+         
+         # Lower bidder calls the stake, now bets should be leveled
+         round.bets[round.lower_bidder_index] = round.higher_bid
+         # Now second betting round can be preformed
+         round.state = Round::STATE_SECOND_BETTING
+         
+      end
+      
+      def perform_second_betting( round )
+                  
+         min_stake = round.stake
+         max_stake = @rules[:max_stake]
+         
+         # If bots already bet the max stake, go to showdown at once
+         if round.stake == max_stake
+            round.state = Round::STATE_SHOWDOWN; return
+         end
+         
+         # Ask bots for bets
+         round.bets = parallel_call( round.bots, :bet_two, min_stake ) do |bet|
+            ( min_stake .. max_stake ).include?( bet )
+         end
+         
+         if round.bets_even?
+            # If bets are even go to showdown right away
+            round.state = Round::STATE_SHOWDOWN
+         else
+            # otherwise second call is required
+            round.state = Round::STATE_SECOND_CALL
+         end
+         
+      end
+      
+      def perform_second_call( round )
+          
+         # Ask lower bidder if calls the stake
+         has_called = call( round.lower_bidder, :agree_two, round.stake )
+         
+         if has_called
+            # Bot accepted the challenge!
+            round.state = Round::STATE_SECOND_CALLED
+         else
+            # Bot has folded
+            round.state = Round::STATE_FOLDED
+         end
+         
+      end
+      
+      def perform_second_called( round )
+         
+         # Lower bidder calls the stake, now bets should be leveled
+         round.bets[round.lower_bidder_index] = round.higher_bid
+         # Time for showdown!
+         round.state = Round::STATE_SHOWDOWN
+         
+      end
+      
+      def perform_folded( round )
+         
+         # Change the score
+         round.score[round.lower_bidder_index] -= round.lower_bid
+         round.score[round.higher_bidder_index] += round.lower_bid
+         
+         # Round is over
+         round.state = Round::STATE_POINTS_DISTRIBUTION
+         
+      end
+   
+      def perform_showdown( round )
+         
+         # Set score unless it is a draw
+         unless round.draw?
+            round.score[round.winner_index] += round.stake
+            round.score[round.loser_index] -= round.stake 
+         end
+            
+         # After showdown round it's time to distribute points
+         round.state = Round::STATE_POINTS_DISTRIBUTION
+         
+      end
+      
+      def perform_points_distributions( round )
+         
+         # Send info to bots about their results
+         parallel_call( round.bots, :end_of_round, round.score[0], round.score[1] )
+         # Round if over
+         round.state = Round::STATE_FINISHED
+         
+      end
+      
+   end
+   
+end

data/lib/bitpoker/round.rb

@@ -0,0 +1,111 @@
+module BitPoker
+   
+   # Model of a BitPoker round
+   # @author Mckomo
+   class Round
+      
+      STATE_RULES_INTRODUCTION   = 0   # Bots are sent rules of duel 
+      STATE_CARD_DEAL            = 1   # Bots receive random cards
+      STATE_FIRST_BETTING        = 2   # Bots set first bet
+      STATE_FIRST_CALL           = 3   # Lower bidder is ask to call a stake after first betting round
+      STATE_FIRST_CALLED         = 4   # Lower bidder called the stake
+      STATE_SECOND_BETTING       = 5   # Bots set second bet
+      STATE_SECOND_CALL          = 6   # Lower bidder is ask to call a stake after second betting round
+      STATE_SECOND_CALLED        = 7   # Lower bidder called the stake
+      STATE_FOLDED               = 8   # Lower bidder folded 
+      STATE_SHOWDOWN             = 9   # Result of the round is determined
+      STATE_POINTS_DISTRIBUTION  = 10  # Bots receive their results after the round
+      STATE_FINISHED             = -1  # Round is over
+      
+      attr_accessor :bets, :cards, :score, :state
+      attr_reader :bots
+      
+      # Contractor of a round object
+      #
+      # @param    [Array]  Array with two bots that participate in the round
+      # @return   [Round]  
+      def initialize( bots )
+         @bots = bots               # Bind bots to the round
+         @score = [0, 0]            # Init with clear score table
+         @state = STATE_RULES_INTRODUCTION   # Start with card deal
+      end
+      
+      # Value of a stake
+      # 
+      # @return   [Integer]
+      def stake
+         higher_bid
+      end
+      
+      # Whether bets are even
+      #
+      # @return   [Mixed]  True of false
+      def bets_even?
+         @bets[0] == @bets[1]
+      end
+      
+      # Return higher bid
+      #
+      # @return   [Integer]
+      def higher_bid
+         @bets.max
+      end
+      
+      # Return lower bid
+      #
+      # @return   [Integer]
+      def lower_bid
+         @bets.min
+      end
+      
+      # Return index of higher bidder
+      #
+      # @return   [Integer]   0 or 1
+      def higher_bidder_index
+         @bets.index( higher_bid )
+      end
+      
+      # Return index of lower bidder
+      #
+      # @return   [Integer]   0 or 1
+      def lower_bidder_index
+         @bets.index( lower_bid )
+      end
+      
+      # Return higher bidder
+      #
+      # @return   [BotInterface]
+      def higher_bidder
+         @bots[higher_bidder_index]
+      end
+      
+      # Return lower bidder
+      #
+      # @return   [BotInterface]
+      def lower_bidder
+         @bots[lower_bidder_index]
+      end
+      
+      # Whether it is a draw
+      #
+      # @return   [Mixed]  True of false
+      def draw?
+         @cards[0] == @cards[1]
+      end
+      
+      # Return index of the round winner
+      #
+      # @return   [Integer]   0 or 1
+      def winner_index
+         draw? ? nil : @cards.index( @cards.max )
+      end
+      
+      # Return index of the round loser
+      #
+      # @return   [Integer]   0 or 1
+      def loser_index
+         draw? ? nil : @cards.index( @cards.min )
+      end
+      
+   end
+end