tundengine 0.0.1

data/lib/tundengine/stages/base.rb

@@ -0,0 +1,74 @@
+module Tundengine
+  module Stages
+    class Base
+
+      attr_reader :parent, :children, :child_in_play
+
+      def initialize(parent = Null.instance)
+        @parent   = parent
+        @children = []
+        @rewinded = []
+        new_child_in_play!
+        @locked = false
+      end
+
+      def declare!(declaration = Declarations::Null.instance)
+        child_in_play.declare!(declaration)
+      end
+
+      def play!(card = Cards::Null.instance)
+        completed = completed?
+        until completed or @locked
+          child_in_play.play!(card)
+          card = Cards::Null.instance
+          completed = completed?
+          completed ? on_completed! : new_child_in_play!
+        end
+        @locked = false
+        block_given? ? (yield self) : self
+      end
+
+      def on_complete_child!
+        children << child_in_play
+      end
+
+      def lock!
+        @locked = true
+        parent.lock!
+      end
+
+      def rewind!(n)
+        [n, children.length].min.times { @rewinded.unshift(children.pop) }
+      end
+
+      def fast_forward!(n)
+        [n, @rewinded.length].min.times { children.push(@rewinded.shift) }
+      end
+
+      def as_hash
+        summary.merge(
+          children_key_name => children.map(&:as_hash)
+        )
+      end
+
+      protected
+
+      def new_child_in_play!
+        @child_in_play = new_child
+      end
+
+      def summary
+        {}
+      end
+
+      def children_key_name
+        "#{child_class_name}s".to_sym
+      end
+
+      def child_class_name
+        children.first.class.name.split('::').last.downcase
+      end
+
+    end
+  end
+end

data/lib/tundengine/stages/match.rb

@@ -0,0 +1,80 @@
+module Tundengine
+  module Stages
+    class Match < Base
+
+      SETTINGS_KEYS = %i(max_points tute_value losing_position)
+
+      attr_reader :settings
+
+      def initialize(tournament, players, settings)
+        @players  = players
+        @settings = settings
+        @trumps   = Deck::SUITS.dup
+        @result   = @players.each_with_object({}) { |k, h| h[k] = 0 }
+        super(tournament)
+      end
+
+      alias_method :tournament, :parent
+      alias_method :rounds, :children
+      alias_method :current_round, :child_in_play
+
+      SETTINGS_KEYS.each do |key|
+        define_method key do
+          settings.fetch key
+        end
+      end
+
+      def on_complete_child!(result)
+        update_result!(result)
+        rotate_trumps_and_players!
+        super()
+      end
+
+      def on_completed!
+        tournament.on_complete_child!(@result)
+      end
+
+      def summary
+        {
+          settings: settings.each_with_object({}) { |(k,v),h| h[k.to_s] = v.to_s },
+          players: @players.map(&:name),
+          result:  @result.each_with_object({}) { |(k,v),h| h[k.to_s] = v }
+        }
+      end
+
+      protected
+
+      def new_child
+        Round.new(self, players_for_new_round, trump_for_new_round)
+      end
+
+      def players_for_new_round
+        @players.map(&:in_new_round)
+      end
+
+      def trump_for_new_round
+        @trumps.first
+      end
+
+      def update_result!(round_result)
+        # these are all match scores, not round points
+        @result.merge!(round_result) do |_, acum_score, last_round_score|
+          acum_score + last_round_score
+        end
+      end
+
+      def rotate_trumps_and_players!
+        [@trumps, @players].each { |a| a.rotate! 1 }
+      end
+
+      def completed?
+        not losers.empty?
+      end
+
+      def losers
+        @result.select { |_, points| points >= max_points }
+      end
+
+    end
+  end
+end

data/lib/tundengine/stages/null.rb

@@ -0,0 +1,13 @@
+module Tundengine
+  module Stages
+    class Null
+
+      include Singleton
+
+      def lock!
+        # do nothing
+      end
+
+    end
+  end
+end

data/lib/tundengine/stages/round.rb

@@ -0,0 +1,85 @@
+module Tundengine
+  module Stages
+    class Round < Base
+
+      extend Forwardable
+      def_delegator  :@parent, :max_points, :max_match_points
+      def_delegators :@parent, :tute_value, :losing_position
+
+      attr_reader :players, :trump_suit, :last_declaration
+
+      LAST_TRICK_BONUS_POINTS = 10
+
+      def initialize(match, players_in_round, trump_suit)
+        @players = players_in_round
+        @players.each { |p| p.round = self }
+        @trump_suit = trump_suit.freeze
+        @last_declaration = Declarations::Null.instance
+        super(match)
+        Dealer.instance.deal!(players, trump_suit)
+      end
+
+      alias_method :match, :parent
+      alias_method :tricks, :children
+      alias_method :current_trick, :child_in_play
+
+      def declare!(declaration = Declarations::Null.instance)
+        last_winner_player.declare!(declaration)
+      end
+
+      def on_complete_child! # when the current trick is completed
+        super
+        rotate_players!
+      end
+
+      def on_completed!
+        last_winner_player.bonus_points = LAST_TRICK_BONUS_POINTS
+        parent.on_complete_child!(result)
+      end
+
+      def after_declaring!(declaration)
+        current_trick.after_declaring!(declaration)
+        @last_declaration = declaration
+      end
+
+      def summary
+        {
+          trump_suit: trump_suit.to_s,
+          players: players.map(&:summary)
+        }
+      end
+
+      protected
+
+      def new_child
+        Trick.new(self)
+      end
+
+      def rotate_players!
+        players.rotate!(players.index next_first_player)
+      end
+
+      def last_winner_player
+        last_trick.winner_player
+      end
+      alias_method :next_first_player, :last_winner_player
+
+      def last_trick
+        tricks.last || :no_trick
+      end
+
+      def completed?
+        any_player.has_empty_hand? or @last_declaration.finishes_round?(tute_value)
+      end
+
+      def any_player
+        players.first
+      end
+
+      def result
+        RoundAnalyzer.new(self).result
+      end
+
+    end
+  end
+end

data/lib/tundengine/stages/tournament.rb

@@ -0,0 +1,72 @@
+module Tundengine
+  module Stages
+    class Tournament < Base
+
+      SETTINGS_KEYS = %i(max_matches match_settings)
+      # TODO: Add a setting to run matches on multiple threads.
+
+      attr_reader :players, :settings
+
+      def initialize(players, settings)
+        @players  = players
+        @settings = settings
+        @result   = initial_result
+        super()
+      end
+
+      alias_method :matches, :children
+      alias_method :current_match, :child_in_play
+
+      SETTINGS_KEYS.each do |key|
+        define_method key do
+          settings.fetch key
+        end
+      end
+
+      def on_complete_child!(result)
+        update_result!(result)
+        super()
+      end
+
+      def summary
+        {
+          players: players.map(&:name),
+          result: @result.each_with_object({}) { |(k,v),h| h[k.to_s] = v }
+        }
+      end
+
+      protected
+
+      def initial_result
+        @players.each_with_object({}) { |p, h| h[p] = 0 }
+      end
+
+      def new_child
+        Match.new(self, @players, match_settings)
+      end
+
+      # TODO: Implement different ways to accumulate match results.
+      def update_result!(match_result)
+        @result.merge! match_result do |_, tournament_score, match_score|
+          tournament_score + match_score
+        end
+      end
+
+      # TODO: Implement different criteria for finishing tournaments.
+      def completed?
+        matches.length == max_matches
+      end
+
+      def on_completed!
+        # for debugging purposes
+        # puts 'Tournament completed. As hash:'
+        # p as_hash
+      end
+
+      def children_key_name
+        :matches
+      end
+
+    end
+  end
+end

data/lib/tundengine/stages/trick.rb

@@ -0,0 +1,90 @@
+module Tundengine
+  module Stages
+    class Trick < Base
+
+      extend Forwardable
+      def_delegator  :@winner_turn, :player_in_round, :winner_player
+      def_delegator  :@winner_turn, :card,            :winner_card
+      def_delegators :@parent, :players, :trump_suit
+
+      include CardPercolator
+
+      attr_reader :declaration
+
+      def initialize(round)
+        @next_player_index = 0
+        super
+        @winner_turn = current_turn
+        @declaration = :no_declaration
+      end
+
+      alias_method :round, :parent
+      alias_method :turns, :children
+      alias_method :current_turn, :child_in_play
+
+      def on_complete_child!(beats) # when the current turn is completed
+        @winner_turn = current_turn if beats
+        super()
+      end
+
+      def after_declaring!(declaration)
+        @declaration = declaration
+        on_completed_with_declaration!
+      end
+
+      def first_suit
+        cards.fetch(0, Cards::Null.instance).suit
+      end
+
+      def points
+        cards.reduce(0) { |acum, card| acum + card.round_points }
+      end
+
+      def cards
+        turns.map(&:card)
+      end
+
+      def next_player # in round
+        players.fetch(@next_player_index - 1)
+      end
+
+      def summary
+        {
+          cards: cards.map(&:to_s),
+          winner_player: winner_player.name,
+          winner_card:   winner_card.to_s,
+          declaration:   declaration.to_s,
+        }
+      end
+
+      protected
+
+      def new_child
+        Turn.new(self)
+      end
+
+      def new_child_in_play! # before starting a new turn
+        @next_player_index += 1
+        super
+      end
+
+      def completed?
+        turns.length == players.length
+      end
+
+      def on_completed!
+        winner_player.on_winning_trick!(self)
+      end
+
+      def on_completed_with_declaration!
+        round.on_complete_child!
+      end
+
+      def is_taken_by?(card)
+        card.beats? winner_card, trump_suit
+      end
+      alias_method :passes_card_percolator?, :is_taken_by?
+
+    end
+  end
+end

data/lib/tundengine/stages/turn.rb

@@ -0,0 +1,44 @@
+module Tundengine
+  module Stages
+    class Turn < Base
+
+      attr_reader :card
+
+      def initialize(trick)
+        @card = Cards::Null.instance
+        super
+      end
+
+      alias_method :trick,  :parent
+      alias_method :player, :child_in_play
+
+      def player_in_round
+        player.in_round
+      end
+
+      def play!(card = Cards::Null.instance)
+        player.play!(card)
+      end
+
+      def on_completed!(card, beats)
+        @card = card
+        trick.on_complete_child!(beats)
+      end
+
+      def as_hash
+        { player: player.name, card: card.to_s }
+      end
+
+      protected
+
+      def new_child
+        Player::InTurn.new(self, trick.next_player)
+      end
+
+      def completed?
+        card.exists?
+      end
+
+    end
+  end
+end