tundengine 0.0.1

data/lib/tundengine/declarations/tute.rb

@@ -0,0 +1,23 @@
+module Tundengine
+  module Declarations
+    class Tute < Base
+
+      include Singleton
+
+      ROUND_POINTS = :no_round_points
+
+      def is_declarable?(hand, trump_suit)
+        [Ranks::Once, Ranks::Doce].any? { |rank| hand.has_all_of? rank.instance }
+      end
+
+      def has_tute_effect?(tute_value)
+        tute_value.has_effect?
+      end
+
+      def finishes_round?(tute_value)
+        tute_value.finishes_round?
+      end
+
+    end
+  end
+end

data/lib/tundengine/declarations/void.rb

@@ -0,0 +1,15 @@
+module Tundengine
+  module Declarations
+    class Void < Base
+
+      include Singleton
+
+      ROUND_POINTS = 0
+
+      def is_declarable?(hand, trump_suit)
+        true
+      end
+
+    end
+  end
+end

data/lib/tundengine/hand.rb

@@ -0,0 +1,35 @@
+module Tundengine
+  class Hand < SimpleDelegator
+
+    # returns the playable cards and whether any of them would beat the current trick
+    def playable_cards(trick)
+
+      suit_followers = trick.first_suit.percolate(self)
+      trick_beaters  = trick           .percolate(self)
+
+      suit_followers_trick_beaters = suit_followers & trick_beaters
+
+      [
+        [suit_followers_trick_beaters, true ],
+        [suit_followers,               false],
+        [trick_beaters,                true ],
+        [self,                         false]
+      ]
+      .find { |cards_subset, _| not cards_subset.empty? }
+
+    end
+
+    def has_knight_and_king_of?(suit)
+      has_all_of?([Ranks::Once, Ranks::Doce].map(&:instance), suit)
+    end
+
+    def has_all_of?(ranks = Deck::RANKS, suits = Deck::SUITS)
+      Deck.cards_of(Array(ranks), Array(suits)).all? { |c| self.include? c }
+    end
+
+    def to_s
+      "[#{map(&:to_s).join(', ')}]"
+    end
+
+  end
+end

data/lib/tundengine/move.rb

@@ -0,0 +1,13 @@
+module Tundengine
+  module Move
+
+    def yield_self_or_lock!(node)
+      yield self
+    end
+
+    def self_or_yield
+      self
+    end
+
+  end
+end

data/lib/tundengine/null_move.rb

@@ -0,0 +1,13 @@
+module Tundengine
+  module NullMove
+
+    def yield_self_or_lock!(node)
+      node.lock!
+    end
+
+    def self_or_yield
+      yield
+    end
+
+  end
+end

data/lib/tundengine/player/in_match.rb

@@ -0,0 +1,29 @@
+module Tundengine
+  module Player
+    class InMatch
+
+      include AlgebraicDataType
+
+      attr_reader :name, :strategy
+
+      def initialize(name, strategy)
+        @name         = name
+        @strategy     = strategy
+        @match_points = 0
+      end
+
+      def to_s
+        @name
+      end
+
+      def identifier
+        [@name]
+      end
+
+      def in_new_round
+        InRound.new(self)
+      end
+
+    end
+  end
+end

data/lib/tundengine/player/in_round.rb

@@ -0,0 +1,71 @@
+module Tundengine
+  module Player
+    class InRound
+
+      extend Forwardable
+      def_delegators :@in_match, :name, :strategy
+
+      attr_reader   :in_match, :hand, :declarations
+      attr_writer   :bonus_points
+      attr_accessor :round
+
+      def initialize(player_in_match)
+        @in_match     = player_in_match
+        @round        = :no_round_set
+        @hand         = Hand.new([])
+        @baza         = []
+        @declarations = []
+        @round_points = 0
+        @bonus_points = 0
+      end
+
+      def take_card!(card)
+        hand << card
+      end
+
+      def declare!(declaration = Declarations::Null.instance)
+        strategy.declare!(self, declaration)
+      end
+
+      def after_declaring!(declaration)
+        if declaration.is_declarable?(hand, round.trump_suit)
+          declarations << declaration
+          round.after_declaring!(declaration)
+        else
+          raise "cannot declare #{declaration} after trick #{round.current_trick.summary} with hand #{hand}"
+        end
+      end
+
+      def on_winning_trick!(trick)
+        take! trick
+        declare!
+      end
+
+      def take!(trick)
+        @baza = @baza.concat trick.cards
+        @round_points += trick.points
+      end
+
+      def has_empty_hand?
+        hand.empty?
+      end
+
+      def has_empty_baza?
+        @baza.empty?
+      end
+
+      def total_round_points
+        @round_points + @bonus_points
+      end
+
+      def summary
+        {
+          name: name,
+          hand: hand.map(&:to_s),
+          baza: @baza.map(&:to_s)
+        }
+      end
+
+    end
+  end
+end

data/lib/tundengine/player/in_turn.rb

@@ -0,0 +1,31 @@
+module Tundengine
+  module Player
+    class InTurn
+
+      extend Forwardable
+      def_delegators :@in_round, :name, :strategy, :hand
+
+      attr_reader :turn, :in_round
+
+      def initialize(turn, player_in_round)
+        @turn     = turn
+        @in_round = player_in_round
+      end
+
+      def play!(card = Cards::Null.instance)
+        strategy.play!(self, card)
+      end
+
+      def after_playing!(card)
+        playable_cards, beats = hand.playable_cards(turn.trick)
+        if playable_cards.include? card
+          hand.delete card
+          turn.on_completed!(card, beats)
+        else
+          raise "cannot play card #{card} in trick with cards #{turn.trick.cards.map(&:to_s)} when your hand is #{@hand.map(&:to_s)}"
+        end
+      end
+
+    end
+  end
+end

data/lib/tundengine/ranks/base.rb

@@ -0,0 +1,31 @@
+module Tundengine
+  module Ranks
+    class Base
+
+      include Singleton
+      include StringifiableByClass
+      include Comparable
+
+      attr_reader :round_points, :power
+
+      def self.de(suit)
+        instance.de(suit)
+      end
+
+      def de(suit)
+        s = suit.is_a?(Suits::Base) ? suit : suit.instance
+        Cards::Card.new(self, s)
+      end
+
+      def <=>(other_rank)
+        @power <=> other_rank.power
+      end
+
+      def initialize
+        @round_points = self.class::ROUND_POINTS
+        @power        = self.class::POWER
+      end
+
+    end
+  end
+end

data/lib/tundengine/ranks/cinco.rb

@@ -0,0 +1,10 @@
+module Tundengine
+  module Ranks
+    class Cinco < Base
+
+      include White
+      POWER = 3
+
+    end
+  end
+end

data/lib/tundengine/ranks/cuatro.rb

@@ -0,0 +1,10 @@
+module Tundengine
+  module Ranks
+    class Cuatro < Base
+
+      include White
+      POWER = 2
+
+    end
+  end
+end

data/lib/tundengine/ranks/diez.rb

@@ -0,0 +1,10 @@
+module Tundengine
+  module Ranks
+    class Diez < Base
+
+      ROUND_POINTS = 2
+      POWER        = 6
+
+    end
+  end
+end

data/lib/tundengine/ranks/doce.rb

@@ -0,0 +1,10 @@
+module Tundengine
+  module Ranks
+    class Doce < Base
+
+      ROUND_POINTS = 4
+      POWER        = 8
+
+    end
+  end
+end

data/lib/tundengine/ranks/dos.rb

@@ -0,0 +1,10 @@
+module Tundengine
+  module Ranks
+    class Dos < Base
+
+      include White
+      POWER = 1
+
+    end
+  end
+end

data/lib/tundengine/ranks/null.rb

@@ -0,0 +1,10 @@
+module Tundengine
+  module Ranks
+    class Null < Base
+
+      ROUND_POINTS = :no_round_points
+      POWER        = 0
+
+    end
+  end
+end

data/lib/tundengine/ranks/once.rb

@@ -0,0 +1,10 @@
+module Tundengine
+  module Ranks
+    class Once < Base
+
+      ROUND_POINTS = 3
+      POWER        = 7
+
+    end
+  end
+end

data/lib/tundengine/ranks/seis.rb

@@ -0,0 +1,10 @@
+module Tundengine
+  module Ranks
+    class Seis < Base
+
+      include White
+      POWER = 4
+
+    end
+  end
+end

data/lib/tundengine/ranks/siete.rb

@@ -0,0 +1,10 @@
+module Tundengine
+  module Ranks
+    class Siete < Base
+
+      include White
+      POWER = 5
+
+    end
+  end
+end

data/lib/tundengine/ranks/tres.rb

@@ -0,0 +1,10 @@
+module Tundengine
+  module Ranks
+    class Tres < Base
+
+      ROUND_POINTS = 10
+      POWER        = 9
+
+    end
+  end
+end

data/lib/tundengine/ranks/uno.rb

@@ -0,0 +1,10 @@
+module Tundengine
+  module Ranks
+    class Uno < Base
+
+      ROUND_POINTS = 11
+      POWER        = 10
+
+    end
+  end
+end

data/lib/tundengine/ranks/white.rb

@@ -0,0 +1,9 @@
+module Tundengine
+  module Ranks
+    module White
+
+      ROUND_POINTS = 0
+
+    end
+  end
+end

data/lib/tundengine/round_analyzer.rb

@@ -0,0 +1,67 @@
+module Tundengine
+  class RoundAnalyzer < SimpleDelegator
+
+    def result
+      if last_declaration.has_tute_effect?(tute_value)
+        losers_in_round_by_tute = players - last_winner_player
+        losers_by_tute = in_match(losers_in_round_by_tute)
+        losers_by_tute.each_with_object({}) do |k, h|
+          h[k] = tute_value.points_for_loser(k, max_match_points)
+        end
+      else
+        points_for_losers = 1
+        losers = in_match(losers_in_round)
+        losers.each_with_object({}) do |k, h|
+          h[k] = points_for_losers
+        end
+      end
+    end
+
+    protected
+
+    def in_match(players_in_round)
+      players_in_round.map(&:in_match)
+    end
+
+    def losers_in_round
+      capote_result = all_tricks_winner.map do |p|
+        p.made_declarations? ? [p] : players - [p]
+      end
+
+      capote_result.empty? ? losers_in_round_by_points : capote_result.first
+    end
+
+    def all_tricks_winner
+      players.select { |pl| (players - [pl]).all?(&:has_empty_baza?) }
+    end
+
+    def losers_in_round_by_points
+      scores = players.each_with_object(Hash.new(:empty_baza)) do |p, h|
+        h[p] = p.total_round_points unless p.has_empty_baza?
+      end
+
+      highest_score = scores.values.sort.last
+
+      first_place, not_first_place = scores
+        .partition { |_, s| s == highest_score }
+        .map       { |pairs| Hash[pairs] }
+
+      scores_without_highest = not_first_place.values.sort
+
+      case losing_position
+      when :second
+        second_highest_score = scores_without_highest.last
+        in_loser_place = scores.select { |_, s| s == second_highest_score }
+      when :not_first_or_last
+        lowest_score = scores_without_highest.first
+        in_loser_place = scores.reject { |_, s| [highest_score, lowest_score].include? s }
+      else
+        raise "invalid match option: losing_position '#{losing_position}' (:second, :not_first_or_last)"
+      end
+      ret = [in_loser_place, first_place].map(&:keys).find { |ps| not ps.empty? }
+      ret = [] if ret.length == players.length
+      ret
+    end
+
+  end
+end