love_letter_application 0.1.0

data/lib/love_letter_application/results/process_incorrect_guess.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'dry-initializer'
+
+module LoveLetterApplication
+  module Results
+    class ProcessIncorrectGuess
+      extend Dry::Initializer
+      option :log_incorrect_guess_node, type: ::Types.Interface(:accept)
+      option :process_next_player_turn, type: ::Types::Callable
+
+      def call(game_board:, change_orders:)
+        process_next_player_turn.(
+          game_board: game_board,
+          change_orders: change_orders.push(log_incorrect_guess_node))
+      end
+    end
+  end
+end
+

data/lib/love_letter_application/results/process_knight_showdown.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require 'dry-initializer'
+
+module LoveLetterApplication
+  module Results
+    class ProcessKnightShowdown
+      @@execute = [
+        ->(pks, cid, tid, gb, co){pks.send(:do_victory, tid, cid, gb, co)},
+        ->(pks, cid, tid, gb, co){pks.send(:do_draw, cid, tid, gb, co)},
+        ->(pks, cid, tid, gb, co){pks.send(:do_victory, cid, tid, gb, co)}]
+
+      include Dry::Initializer.define -> do
+        option :knight_drawn_node, type: ::Types.Interface(:accept)
+        option :get_knight_victory_node, type: ::Types::Callable
+        option :eliminate_player, type: ::Types::Callable
+        option :process_next_player_turn, type: ::Types::Callable
+      end
+
+      def call(target_player_id:, game_board:, change_orders:)
+        current_player_id = game_board.current_player_id.to_i
+        result = get_result(current_player_id, target_player_id, game_board)
+        @@execute[result].(self, current_player_id, target_player_id, game_board, change_orders)
+      end
+
+      private
+      def get_result(current_player_id, target_player_id, game_board)
+        current_player = game_board.players.find{|player| player.id.to_i.eql?(current_player_id)}
+        target_player = game_board.players.find{|player| player.id.to_i.eql?(target_player_id)}
+        #<=> returns -1, 0, or 1.  I add 1 at the end so I can use the result as an array index
+        (current_player.hand.first.rank.to_i <=> target_player.hand.first.rank.to_i) + 1
+      end
+
+      def do_draw(current_player_id, target_player_id, game_board, change_orders)
+        process_next_player_turn.(
+          game_board: game_board,
+          change_orders: change_orders.push(knight_drawn_node))
+      end
+
+      def do_victory(winning_player_id, losing_player_id, game_board, change_orders)
+        eliminate_player.(
+          target_player_id: losing_player_id,
+          game_board: game_board,
+          change_orders: change_orders.push(get_knight_victory_node.(
+            winning_player_id: winning_player_id,
+            losing_player_id: losing_player_id)))
+      end
+    end
+  end
+end

data/lib/love_letter_application/results/process_next_player_turn.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true:q
+
+require 'dry-initializer'
+
+module LoveLetterApplication
+  module Results
+    class ProcessNextPlayerTurn
+      include Dry::Initializer.define -> do
+        option :process_round_complete_by_depleted_deck, type: ::Types::Callable
+        option :get_next_player_node, type: ::Types::Callable
+        option :get_drawn_card_node, type: ::Types::Callable
+        option :next_player_draw_card, type: ::Types::Callable
+        option :get_result_game_board_node, type: ::Types::Callable
+        option :process_next_turn_options, type: ::Types::Callable
+      end
+
+      def call(game_board:, change_orders:)
+        if game_board.draw_pile.empty?
+          return process_round_complete_by_depleted_deck.(
+            game_board: game_board,
+            change_orders: change_orders)
+        end
+        next_player_id = get_next_player_id_from(game_board)
+        card_id = game_board.draw_pile.first.id.to_i
+        game_board = next_player_draw_card.(
+          game_board: game_board,
+          next_player_id: next_player_id)
+        process_next_turn_options.(
+          game_board: game_board,
+          change_orders: change_orders
+            .push(get_next_player_node.(player_id: next_player_id))
+            .push(get_drawn_card_node.(player_id: next_player_id, card_id: card_id))
+            .push(get_result_game_board_node.(game_board: game_board)))
+      end
+
+      private
+      def get_next_player_id_from(game_board)
+        current_player_id = game_board.current_player_id.to_i
+        current_player = game_board.players.find{|player| player.id.to_i.eql?(current_player_id)}
+        possible_players = game_board
+          .players
+          .select(&:active?)
+          .sort{|p, q| p.seat.to_i <=> q.seat.to_i}
+          .reject{|player| player.id.to_i.eql?(current_player_id)}
+        #get first active player with higher seat number than current player
+        next_player = possible_players
+          .select{|player| player.seat.to_i > current_player_id.to_i}
+          .first
+        #if no such player, "wrap around" and get active player with lowest seat number
+        next_player || possible_players.first
+
+        next_player.id.to_i
+      end
+    end
+  end
+end
+

data/lib/love_letter_application/results/process_next_turn_options.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require 'dry-initializer'
+
+module LoveLetterApplication
+  module Results
+    class ProcessNextTurnOptions
+      extend Dry::Initializer
+      option :get_legal_card_ids, type: ::Types::Callable
+      option :all_card_validator_builders, type: ::Types::ArrayOfCallable
+      option :get_play_card_with_no_options_node, ::Types::Callable
+      option :get_play_card_with_player_id_option_node, type: ::Types::Callable
+      option :get_play_card_with_player_id_and_card_id_option_node, type: ::Types::Callable
+      
+      def call(game_board:, change_orders:)
+        current_player_id = game_board.current_player_id.to_i
+        hand = game_board.players
+          .find{|player| player.id.to_i.eql?(current_player_id)}
+          .hand
+        card_ids = get_legal_card_ids.(card_list: hand)
+        card_ids.each do |card_id|
+          change_orders = change_orders.push(get_node_for(game_board, card_id))
+        end
+        change_orders
+      end
+
+      def get_node_for(game_board, card_id)
+        build_validator = all_card_validator_builders[card_id]
+        validator = build_validator.(game_board)
+        # a handler will be called by validator#accept based on the type of the validator found
+        validator.accept(self, card_id: card_id)
+      end
+
+      def handle_no_options_validator(validator, card_id:)
+        get_play_card_with_no_options_node.(card_id: card_id)
+      end
+
+      def handle_select_player_id_validator(validator, card_id:)
+        get_play_card_with_player_id_option_node.(
+          card_id: card_id,
+          player_id_list: validator.legal_target_player_ids)
+      end
+
+      def handle_soldier_validator(validator, card_id:)
+        get_play_card_with_player_id_and_card_id_option_node.(
+          card_id: card_id,
+          player_id_list: validator.legal_target_player_ids,
+          card_id_list: validator.legal_target_card_ids)
+      end
+    end
+  end
+end
+

data/lib/love_letter_application/results/process_princess_discarded.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require 'dry-initializer'
+
+module LoveLetterApplication
+  module Results
+    class ProcessPrincessDiscarded
+      include Dry::Initializer.define -> do
+        option :get_princess_discarded_node, type: ::Types::Callable
+        option :eliminate_player, type: ::Types::Callable
+      end
+
+      def call(target_player_id:, game_board:, change_orders:)
+        eliminate_player.(
+          target_player_id: target_player_id,
+          game_board: game_board,
+          change_orders: change_orders.push(
+            get_princess_discarded_node.(player_id: target_player_id)))
+      end
+    end
+  end
+end
+

data/lib/love_letter_application/results/process_resolve_wizard.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require 'dry-initializer'
+
+module LoveLetterApplication
+  module Results
+    class ProcessResolveWizard
+      include Dry::Initializer.define -> do
+        option :get_discard_card_node, type: ::Types::Callable
+        option :process_discard_passive_result, type: ::Types::ArrayOfCallable
+        option :process_draw_after_discard, type: ::Types::Callable
+      end
+
+      def call(target_player_id:, game_board:, change_orders:)
+        card_id = card_id_for(game_board, target_player_id)
+        process_discard_passive_result[card_id].(
+          target_player_id: target_player_id,
+          game_board: game_board,
+          change_orders: change_orders
+            .push(get_discard_card_node.(player_id: target_player_id, card_id: card_id)),
+          &process_draw_after_discard.method(:call))
+      end
+
+      private
+      def card_id_for(game_board, player_id)
+        game_board.players
+          .find{|player| player.id.to_i.eql?(player_id.to_i)}
+          .hand
+          .first
+          .id
+          .to_i
+      end
+    end
+  end
+end
+

data/lib/love_letter_application/results/process_round_complete_by_depleted_deck.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require 'dry-initializer'
+
+module LoveLetterApplication
+  module Results
+    class ProcessRoundCompleteByDepletedDeck
+      extend Dry::Initializer
+      option :log_deck_depleted_node, type: ::Types.Interface(:accept), reader: :private
+      option :get_players_and_scores_node, type: ::Types::Callable, reader: :private
+      option :get_player_victory_node, type: ::Types::Callable, reader: :private
+      option :round_complete, type: ::Types::Callable, reader: :private
+      option :get_result_game_board_node, type: ::Types::Callable, reader: :private
+
+      def call(game_board:, change_orders:)
+        players_and_scores = get_players_and_scores(game_board)
+        victorious_player_id = get_victorious_player_id(game_board, players_and_scores)
+        game_board = round_complete.call(
+          game_board: game_board,
+          victorious_player_id: victorious_player_id)
+        change_orders
+          .push(get_players_and_scores_node.(players_and_scores: players_and_scores))
+          .push(get_player_victory_node.(player_id: victorious_player_id))
+          .push(get_result_game_board.(game_board: game_board))
+      end
+
+      private
+      def get_players_and_scores(game_board)
+        game_board.players
+          .select(&:active?)
+          .map{|player| [player.id, point_value_of(player)]}
+          .to_h
+      end
+
+      def point_value_of(player)
+        hand_card_value = hand_card.reduce{|c,d| c.rank.to_i + d.rank.to_i} * 100
+        played_cards_value = player.played_cards.reduce{|c, d| c.rank.to_i + d.rank.to_i}
+        hand_card_value + played_cards_value
+      end
+
+      def get_victorious_player_id(game_board, players_and_scores)
+        winning_score = players_and_scores.to_a.map(&:last).max
+        players_and_scores.map{|k, v| v.eql?(winning_score)}
+          .map(&:id)
+          .map(&:to_i)
+      end
+    end
+  end
+end
+

data/lib/love_letter_application/results/process_round_complete_by_elimination.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require 'dry-initializer'
+
+module LoveLetterApplication
+  module Results
+    class ProcessRoundCompleteByElimination
+      extend Dry::Initializer
+      option :log_all_opponents_eliminated_node, type: ::Types.Interface(:accept), reader: :private
+      option :get_player_victory_node, type: ::Types::Callable, reader: :private
+      option :round_complete, type: ::Types::Callable, reader: :private
+      option :get_result_game_board_node, type: ::Types::Callable, reader: :private
+
+      def call(game_board:, player:, change_orders:)
+        game_board = round_complete.call(
+          game_board: game_board,
+          victorious_player_id: [player.id.to_i])
+        change_orders
+          .push(log_all_opponents_eliminated_node)
+          .push(get_player_victory_node.(player_id: [player.id]))
+          .push(get_result_game_board_node.(game_board: game_board))
+      end
+    end
+  end
+end
+

data/lib/love_letter_application/results/process_switch_hands.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require 'dry-initializer'
+
+module LoveLetterApplication
+  module Results
+    class ProcessSwitchHands
+      include Dry::Initializer.define -> do
+        option :get_hands_switched_node, type: ::Types::Callable
+        option :switch_hands, type: ::Types::Callable
+        option :process_next_player_turn, type: ::Types::Callable
+      end
+
+      def call(target_player_id:, game_board:, change_orders:)
+        player_id = game_board.current_player_id.to_i
+        old_card_id, new_card_id = get_cards_held_by(player_id, target_player_id.to_i, game_board)
+        game_board = switch_hands.(
+          player_id: player_id,
+          target_player_id: target_player_id,
+          game_board: game_board)
+        process_next_player_turn.(
+          game_board: game_board,
+          change_orders: change_orders.push(get_hands_switched_node.(
+            player_id: player_id,
+            target_player_id: target_player_id,
+            card_id_given: old_card_id,
+            card_id_taken: new_card_id)))
+      end
+
+      private
+      def get_cards_held_by(player_id, target_player_id, game_board)
+        old_card_id = game_board.players
+          .find{|player| player.id.to_i.eql?(player_id)}
+          .hand
+          .first
+          .id
+          .to_i
+
+        new_card_id = game_board.players
+          .find{|player| player.id.to_i.eql?(target_player_id)}
+          .hand
+          .first
+          .id
+          .to_i
+
+        [old_card_id, new_card_id]
+      end
+    end
+  end
+end
+

data/lib/love_letter_application/results/yield_to_block.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module LoveLetterApplication
+  module Results
+    class YieldToBlock
+      def call(**args, &block)
+        yield(**args) if block_given?
+      end
+    end
+  end
+end
+

data/lib/love_letter_application/types/card.rb

@@ -0,0 +1,20 @@
+#frozen string_literal: true
+
+module LoveLetterApplication
+  module Types
+    i = Class::new do
+      @@has_card_methods = ::Types.Interface(:id, :rank, :targetable?)
+
+      def call(card)
+        @@has_card_methods.call(card)
+        ::Types::Coercible::Integer.call(card.id)
+        ::Types::Coercible::Integer.call(card.rank)
+        ::Types::Strict::Bool.call(card.targetable?)
+        card
+      end
+    end.new
+
+    LoveLetterApplication::Types::Card = ::Types::Constructor(Class){|value| i.call(value)}
+  end
+end
+

data/lib/love_letter_application/types/game_board.rb

@@ -0,0 +1,59 @@
+#frozen string_literal: true 
+ 
+require 'dry-initializer'
+require 'dry-types'
+require 'love_letter_application/types/card'
+require 'love_letter_application/types/player'
+
+module LoveLetterApplication
+  module Types
+    i = Class::new do
+      @@has_game_board_methods =
+        ::Types.Interface(:players, :draw_pile, :set_aside_card, :current_player_id, :game_state)
+      def call(game_board)
+        @@has_game_board_methods.(game_board)
+        ::Types::Array::of(LoveLetterApplication::Types::Player).call(game_board.players)
+        ::Types::Array::of(LoveLetterApplication::Types::Card).call(game_board.draw_pile)
+        LoveLetterApplication::Types::Card.call(game_board.set_aside_card)
+        ::Types::Coercible::Integer.call(game_board.current_player_id)
+        LoveLetterApplication::Types::GameStateEnum.call(game_board.game_state)
+        all_players_have_different_ids_and_seats(game_board.players)
+        verify_current_player_id_is_valid(game_board)
+        game_board
+      end
+
+      private
+      def all_players_have_different_ids_and_seats(players)
+        id_list = []
+        seat_list = []
+        players.each do |player|
+          if id_list.include?(player.id.to_i)
+            raise Dry::Types::ConstraintError::new(
+              'All players have distinct ids', players.map(&:id))
+          end
+          if seat_list.include?(player.seat.to_i)
+            raise Dry::Types::ConstraintError::new(
+              'All players have distinct seats', players.map(&:seat))
+          end
+          id_list.push player.id.to_i
+          seat_list.push player.seat.to_i
+        end
+      end
+
+      def verify_current_player_id_is_valid(game_board)
+        id_list = game_board.players.map{|player| player.id.to_i}
+        if !id_list.include?(game_board.current_player_id.to_i)
+          raise Dry::Types::ConstraintError::new(
+            "The player id whose turn it is not in the player list (#{id_list})",
+            game_board.current_player_id)
+        end
+      end
+    end.new
+
+    LoveLetterApplication::Types::GameBoard = ::Types::Constructor(Class){|value| i.call(value)}
+
+    LoveLetterApplication::Types::GameStateEnum =
+      ::Types::String::enum('card_drawn', 'round_complete')
+  end
+end
+