poker-engine 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: bc329a00c9421d0689395ca15d79839d8f7141f7
+  data.tar.gz: f5b4b1d27ee2fcc6dd929587a2336832f73c6037
+SHA512:
+  metadata.gz: cbdc36361e03f6919bdbb3cfa729131a893741942afa915a20851482c1f7ca2b44cf2dc90cc2a843f75b97b47541db732d7a8c53ac0f993bd80d963943847ffe
+  data.tar.gz: 52b87a7f764f916f2b0a035c72c6687212f46001c98dc8131a7b9cab4a0d0b78de53f77e9cbc6070578ee9cf71ffa9f04056841a9fd42c57a03cff577786d687

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2017 Kamen Kanev
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,24 @@
+# poker-engine
+Poker library written in Ruby :heart:
+
+![The price](the_price.jpg)
+
+## Try it
+
+Currently there is simple 74% working console interface `./examples/console-ui`
+
+## TODOs
+
+- [ ] Adding validators
+
+  Currently, the user moves are not validated and that can result in breaking the game logic.
+- [ ] Rethink the concept of aggressor
+- [ ] Plug-in the hand evaluation logic in to the game cycle
+
+## Test~~s~~
+
+Run `rspec`
+
+## Resources
+
+- https://www.pokernews.com/pokerterms

data/bin/console

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+
+require 'irb'
+require 'irb/completion'
+require 'bundler/setup'
+
+Bundler.require(:default, :development)
+
+IRB.start

data/lib/poker-engine.rb

@@ -0,0 +1 @@
+require_relative 'poker_engine'

data/lib/poker_engine.rb

@@ -0,0 +1,9 @@
+require 'hamster'
+require 'ostruct'
+require 'poker_engine/game'
+require 'poker_engine/next_actions'
+require 'poker_engine/state_operations'
+require 'poker_engine/card'
+require 'poker_engine/cards'
+require 'poker_engine/hand_evaluator'
+require 'poker_engine/version'

data/lib/poker_engine/card.rb

@@ -0,0 +1,27 @@
+module PokerEngine
+  class Card
+    COLORS = { spade: :spade, club: :club, heart: :heart, diamond: :diamond }.freeze
+    RANKS = (2..10).to_a.map(&:to_s) + %w(J Q K A)
+
+    def self.french_deck
+      Card::RANKS
+        .product(Card::COLORS.values)
+        .map { |rank, color| Card.new rank, color }
+    end
+
+    attr_reader :rank, :color
+
+    def initialize(rank, color)
+      @rank = rank
+      @color = color
+    end
+
+    def value
+      @value ||= RANKS.index rank
+    end
+
+    def to_s
+      "#{@rank}#{@color[0]}"
+    end
+  end
+end

data/lib/poker_engine/cards.rb

@@ -0,0 +1,64 @@
+module PokerEngine
+  class Cards
+    include Enumerable
+
+    COLOR_BY_FIRST_LETTER = {
+      's' => Card::COLORS[:spade],
+      'c' => Card::COLORS[:club],
+      'h' => Card::COLORS[:heart],
+      'd' => Card::COLORS[:diamond],
+    }.freeze
+
+    def self.parse(str_cards)
+      cards = str_cards
+              .split(',')
+              .map do |str|
+                Card.new str.to_i, COLOR_BY_FIRST_LETTER.fetch(str[-1])
+              end
+
+      new(cards)
+    end
+
+    attr_reader :cards
+
+    def initialize(cards)
+      @cards = cards
+    end
+
+    def to_s
+      cards.map(&:to_s).join(', ')
+    end
+
+    def each(&block)
+      cards.each(&block)
+    end
+
+    def +(other)
+      Cards.new(cards + other.cards)
+    end
+
+    # TODO: Make it work with block, too
+    def sort
+      cards.sort_by(&:value)
+    end
+
+    def sorted_values
+      cards.map(&:value).sort
+    end
+
+    def combination(x)
+      cards.combination(x).map { |c| Cards.new(c) }
+    end
+
+    # Make descending order primary by occurency and secondary by value
+    def values_desc_by_occurency
+      values = cards.map(&:value)
+
+      values.sort do |a, b|
+        coefficient_occurency = (values.count(a) <=> values.count(b))
+
+        coefficient_occurency.zero? ? -(a <=> b) : -coefficient_occurency
+      end
+    end
+  end
+end

data/lib/poker_engine/game.rb

@@ -0,0 +1,81 @@
+require_relative 'reducer'
+
+module PokerEngine
+  module Game
+    POSITIONS_ORDER = {
+      preflop: %i(UTG MP CO D SB BB).freeze,
+      postflop: %i(SB BB UTG MP CO D).freeze,
+    }.freeze
+
+    module_function
+
+    def start(*args, &handler)
+      state = initial_state(*args)
+      run(state, &handler)
+    end
+
+    def next(state, player_action, &handler)
+      state = Reducer.call state, player_action
+
+      run(state, &handler)
+    end
+
+    def run(state, &handler)
+      subscribed_reducer = lambda do |old_state, action|
+        new_state = Reducer.call old_state, action
+        handler&.call [old_state, action], new_state
+
+        new_state
+      end
+
+      loop do
+        break state if state[:pending_request] || state[:game_ended]
+
+        actions = NextActions.call(state)
+        state = actions.reduce(state, &subscribed_reducer)
+      end
+    end
+
+    # TODO: remove blinds defaults
+    def initial_state(players, small_blind: 10, big_blind: 20, deck_seed: 1)
+      reversed_position_order = POSITIONS_ORDER[:preflop].reverse
+      positions = players.map.with_index do |player, index|
+        last_index = players.count - 1
+
+        [player[:id], reversed_position_order[last_index - index]]
+      end.to_h
+
+      normalized_players = players.map do |id:, balance:, **|
+        [
+          id,
+          {
+            id: id,
+            active: true,
+            balance: balance,
+            money_in_pot: 0,
+            position: positions[id],
+            cards: [],
+            last_move: {},
+          },
+        ]
+      end.to_h
+
+      Hamster.from(
+        players: normalized_players,
+        aggressor_id: nil,
+        board: [],
+        small_blind: small_blind,
+        big_blind: big_blind,
+        pot: 0,
+        pending_request: false,
+        winner_ids: [],
+        top_hands: {},
+        game_ended: false,
+        last_action: { type: :game_start },
+        current_stage: nil,
+        current_player_id: nil,
+        deck: Card.french_deck.shuffle(random: Random.new(deck_seed))
+      )
+    end
+  end
+end

data/lib/poker_engine/hand_evaluator.rb

@@ -0,0 +1,32 @@
+require_relative 'hand_index'
+
+module PokerEngine
+  module HandEvaluator
+    module_function
+
+    def find_top_hands(players, board)
+      players
+        .map do |id:, cards:, **|
+          cards = board + cards
+          player_top_hand = cards.combination(5)
+                                 .map do |five_cards|
+                                   HandIndex.new(Cards.new(five_cards))
+                                 end
+                                 .max
+
+          [id, player_top_hand]
+        end
+        .to_h
+    end
+
+    def find_winners(players, board)
+      top_hand_per_player_id = find_top_hands(players, board)
+
+      best_hand = top_hand_per_player_id.values.max
+
+      top_hand_per_player_id
+        .map { |player_id, hand| hand == best_hand ? player_id : nil }
+        .compact
+    end
+  end
+end

data/lib/poker_engine/hand_index.rb

@@ -0,0 +1,36 @@
+require_relative 'hand_levels'
+
+module PokerEngine
+  class HandIndex
+    # The index is equivalent to the level strength
+    RANK_TABLE = [HandLevels::HighCard, HandLevels::OnePair,
+                  HandLevels::TwoPairs, HandLevels::ThreeOfAKind,
+                  HandLevels::Straight, HandLevels::Flush,
+                  HandLevels::FullHouse, HandLevels::FourOfAKind,
+                  HandLevels::StraightFlush].freeze
+
+    attr_reader :cards
+
+    def initialize(cards)
+      @cards = cards
+    end
+
+    def <=>(other)
+      outer_level_compare =
+        (RANK_TABLE.index(level) <=> RANK_TABLE.index(other.level))
+
+      return outer_level_compare unless outer_level_compare.zero?
+
+      level <=> other.level
+    end
+
+    def >(other)
+      level <=> other.level
+    end
+
+    def level
+      @level ||=
+        RANK_TABLE.reverse_each.find { |level| level.owns?(cards) }
+    end
+  end
+end

data/lib/poker_engine/hand_levels.rb

@@ -0,0 +1,107 @@
+require_relative 'cards'
+
+module PokerEngine
+  module HandLevels
+    # Abstract class for Hand level
+    class BaseLevel
+      attr_reader :cards
+
+      def initialize(cards)
+        @cards = cards
+      end
+
+      def <=>(other)
+        unless other.instance_of?(self.class)
+          fail "Can't detail detail hands of different level"
+        end
+
+        detail_compare(other)
+      end
+
+      def detail_compare(other)
+        cards.values_desc_by_occurency <=>
+          other.cards.values_desc_by_occurency
+      end
+    end
+
+    #============================= Levels ======================================
+
+    HighCard = Class.new(BaseLevel) do
+      def self.owns?(_cards)
+        true
+      end
+    end
+
+    OnePair = Class.new(BaseLevel) do
+      def self.owns?(cards)
+        cards.sorted_values
+             .group_by(&:itself)
+             .any? { |_, group| group.size == 2 }
+      end
+    end
+
+    TwoPairs = Class.new(BaseLevel) do
+      def self.owns?(cards)
+        cards.sorted_values
+             .group_by(&:itself)
+             .select { |_, group| group.size == 2 }
+             .count
+             .eql?(2)
+      end
+    end
+
+    ThreeOfAKind = Class.new(BaseLevel) do
+      def self.owns?(cards)
+        cards.sorted_values
+             .group_by(&:itself)
+             .one? { |_, group| group.size == 3 }
+      end
+    end
+
+    Straight = Class.new(BaseLevel) do
+      def self.owns?(cards)
+        cards.sorted_values
+             .each_cons(2)
+             .map { |a, b| a - b }
+             .uniq
+             .one?
+      end
+
+      def detail_compare(other)
+        cards.sorted_values.first <=> other.cards.sorted_values.first
+      end
+    end
+
+    Flush = Class.new(BaseLevel) do
+      def self.owns?(cards)
+        cards.map(&:color).uniq.one?
+      end
+    end
+
+    FullHouse = Class.new(BaseLevel) do
+      def self.owns?(cards)
+        cards.map(&:value).uniq.count > 1 &&
+          OnePair.owns?(cards) &&
+          ThreeOfAKind.owns?(cards)
+      end
+    end
+
+    FourOfAKind = Class.new(BaseLevel) do
+      def self.owns?(cards)
+        cards.sorted_values
+             .group_by(&:itself)
+             .one? { |_, group| group.size == 4 }
+      end
+    end
+
+    StraightFlush = Class.new(BaseLevel) do
+      def self.owns?(cards)
+        Straight.owns?(cards) && Flush.owns?(cards)
+      end
+
+      def detail_compare(other)
+        cards.sorted_values.first <=> other.cards.sorted_values.first
+      end
+    end
+  end
+end

data/lib/poker_engine/next_actions.rb

@@ -0,0 +1,44 @@
+module PokerEngine
+  module NextActions
+    def self.call(state)
+      state_operations = StateOperations.new state
+
+      case state.dig :last_action, :type
+      when :game_start
+        [
+          { type: :next_stage, stage: :preflop },
+          { type: :take_small_blind, player_id: state_operations.player_id_by(position: :SB) },
+          { type: :take_big_blind, player_id: state_operations.player_id_by(position: :BB) },
+        ]
+      when :take_big_blind
+        state_operations.ordered_player_ids.map do |id|
+          { type: :distribute_to_player, player_id: id }
+        end
+      when :distribute_to_player, :distribute_to_board
+        [{ type: :move_request, player_id: state_operations.first_player_id }]
+      when :check, :call, :raise, :fold
+        player_id = state_operations.next_player_id
+
+        if player_id == state[:current_player_id]
+          [{ type: :game_end, winner_ids: [player_id] }]
+        elsif player_id == state[:aggressor_id] && !state_operations.next_stage?
+          players = Hamster.to_ruby state[:players].values
+
+          [{
+            type: :game_end,
+            top_hands: HandEvaluator.find_top_hands(players, state[:board].to_a),
+            winner_ids: HandEvaluator.find_winners(players, state[:board].to_a),
+          }]
+        elsif player_id == state[:aggressor_id]
+          [{ type: :next_stage, stage: state_operations.next_stage }]
+        else
+          [{ type: :move_request, player_id: player_id }]
+        end
+      when :next_stage
+        [{ type: :distribute_to_board, cards_count: state_operations.stage_cards_count }]
+      else
+        raise 'error'
+      end
+    end
+  end
+end

data/lib/poker_engine/reducer.rb

@@ -0,0 +1,127 @@
+require 'ostruct'
+
+module PokerEngine
+  module Reducer
+    def self.call(state, action)
+      raise "Unknown action #{action[:type]}" unless allowed_actions.include? action[:type]
+
+      Actions
+        .public_send(action[:type], state, action)
+        .put(:last_action, action)
+    end
+
+    def self.allowed_actions
+      @allowed_actions ||= Actions.methods(false)
+    end
+
+    module Actions
+      module_function
+
+      def game_start(state, **_action)
+        state
+      end
+
+      def take_small_blind(state, **action)
+        take_blind state, action.merge(blind_kind: :small_blind)
+      end
+
+      def take_big_blind(state, **action)
+        take_blind state, action.merge(blind_kind: :big_blind)
+      end
+
+      def distribute_to_player(state, player_id:, **_action)
+        new_deck, poped_cards =
+          state[:deck].partition.with_index { |_, i| i + 1 <= state[:deck].count - 2 }
+
+        state
+          .put(:deck, new_deck)
+          .update_in(:players, player_id, :cards) { poped_cards }
+      end
+
+      def distribute_to_board(state, cards_count:, **_action)
+        new_deck, poped_cards =
+          state[:deck].partition.with_index { |_, i| i + 1 <= state[:deck].count - cards_count }
+
+        state
+          .put(:deck, new_deck)
+          .put(:board) { |board| board + poped_cards }
+      end
+
+      def move_request(state, player_id:, **_action)
+        state
+          .put(:current_player_id, player_id)
+          .put(:pending_request, true)
+      end
+
+      def call(state, **action)
+        bet = state.dig(:players, state[:aggressor_id], :last_move, :bet) || state[:big_blind]
+        money_to_give = bet - state.dig(:players, action[:player_id], :money_in_pot)
+
+        pay(state, action.merge(money_to_give: money_to_give))
+          .put(:aggressor_id) { |id| id || action[:player_id] } # HACK: try to get rid of it.
+      end
+
+      def raise(state, **action)
+        money_to_give = action[:bet] - state.dig(:players, action[:player_id], :money_in_pot)
+
+        pay(state, action.merge(money_to_give: money_to_give))
+          .put(:aggressor_id, action[:player_id])
+      end
+
+      def check(state, player_id:, **_action)
+        state
+          .put(:pending_request, false)
+          .put(:aggressor_id) { |id| id || player_id } # HACK: try to get rid of it.
+      end
+
+      def fold(state, **action)
+        state
+          .update_in(:players, action[:player_id]) do |player|
+            player.put(:active, false).put(:last_move, action)
+          end
+          .put(:pending_request, false)
+      end
+
+      def next_stage(state, stage:, **_action)
+        state
+          .update_in(:players) do |players|
+            players.map { |id, player| [id, player.put(:money_in_pot, 0)] }
+          end
+          .put(:current_stage, stage)
+          .put(:aggressor_id, nil)
+      end
+
+      def game_end(state, top_hands:, winner_ids:, **_action)
+        state
+          .put(:top_hands, top_hands)
+          .put(:winner_ids, winner_ids)
+          .put(:game_ended, true)
+      end
+
+      private_class_method def take_blind(state, player_id:, blind_kind:, **_action)
+        blind_size = state.fetch blind_kind
+
+        state
+          .update_in(:players, player_id) do |player|
+            player
+              .put(:balance) { |b| b - blind_size }
+              .put(:money_in_pot) { |mip| mip + blind_size }
+          end
+          .put(:pot) { |pot| pot + blind_size }
+      end
+
+      # TODO: handle the case when the bet is higher then the current balance
+      private_class_method def pay(state, money_to_give:, **action)
+        state
+          .update_in(:players, action[:player_id]) do |player|
+            player
+              .put(:balance) { |b| b - money_to_give }
+              .put(:money_in_pot) { |mip| mip + money_to_give }
+              .put(:last_move, action)
+          end
+          .put(:pot) { |pot| pot + money_to_give }
+          .put(:pending_request, false)
+      end
+    end
+  end
+end

data/lib/poker_engine/state_operations.rb

@@ -0,0 +1,66 @@
+module PokerEngine
+  class StateOperations
+    CARDS_COUNT_PER_STAGE_START = { flop: 3, turn: 1, river: 1 }.freeze
+    STAGES = %i(preflop flop turn river).freeze
+
+    attr_reader :state
+
+    def initialize(state)
+      @state = state
+    end
+
+    def player_id_by(position:)
+      players.find { |_id, player| player[:position] == position }.first
+    end
+
+    def next_stage?
+      state[:current_stage] != :river
+    end
+
+    def next_stage
+      STAGES.fetch STAGES.index(state[:current_stage]) + 1
+    end
+
+    def stage_cards_count
+      StateOperations::CARDS_COUNT_PER_STAGE_START.fetch state[:current_stage]
+    end
+
+    def next_player_id
+      ordered_player_ids.cycle.each_with_index.find do |id, order_index|
+        order_index > ordered_player_ids.index(state[:current_player_id]) &&
+          players[id][:active]
+      end.first
+    end
+
+    def one_player_left?
+      players.count { |_, player| player[:active] } == 1
+    end
+
+    def active_players
+      players.select { |_, player| player[:active] }
+    end
+
+    NO_ACTIVE_FILTER = Object.new
+    def ordered_player_ids(active: NO_ACTIVE_FILTER)
+      raise 'Unexpected state' unless state[:current_stage]
+
+      positions = Game::POSITIONS_ORDER[state[:current_stage] == :preflop ? :preflop : :postflop]
+
+      players.each_with_object(Array.new(players.count)) do |(id, player), ordered|
+        next if active != NO_ACTIVE_FILTER && active != player[:active]
+
+        ordered[positions.index player[:position]] = id
+      end.compact
+    end
+
+    def first_player_id
+      ordered_player_ids(active: true).first
+    end
+
+    private
+
+    def players
+      state[:players]
+    end
+  end
+end

data/lib/poker_engine/version.rb

@@ -0,0 +1,3 @@
+module PokerEngine
+  VERSION = '1.0.0'.freeze
+end

metadata

@@ -0,0 +1,145 @@
+--- !ruby/object:Gem::Specification
+name: poker-engine
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Kamen Kanev
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-01-31 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: hamster
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: pry-byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.4'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.48'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.48'
+description: "    Poker library introducing the game logic with a simple interface.
+  Currently offering only 6-max Holdem games.\n"
+email: kamen.e.kanev@gmail.com
+executables:
+- console
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- bin/console
+- lib/poker-engine.rb
+- lib/poker_engine.rb
+- lib/poker_engine/card.rb
+- lib/poker_engine/cards.rb
+- lib/poker_engine/game.rb
+- lib/poker_engine/hand_evaluator.rb
+- lib/poker_engine/hand_index.rb
+- lib/poker_engine/hand_levels.rb
+- lib/poker_engine/next_actions.rb
+- lib/poker_engine/reducer.rb
+- lib/poker_engine/state_operations.rb
+- lib/poker_engine/version.rb
+homepage: https://github.com/kekanev/poker-engine
+licenses:
+- MIT
+metadata:
+  github: https://github.com/kekanev/poker-engine
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.2
+signing_key: 
+specification_version: 4
+summary: Poker library introducing the game logic into a simple interface.
+test_files: []