love_letter_application 0.1.0

data/lib/love_letter_application/models/card.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require 'dry-struct'
+
+module LoveLetterApplication
+  module Models
+    class Card
+      include Dry::Initializer.define -> do
+        option :id, ::Types::Coercible::Integer
+        option :rank, ::Types::Coercible::Integer
+        option :targetable?, as: :targetable, type: ::Types::Strict::Bool, reader: false
+      end
+      def targetable?;@targetable;end
+      def inspect
+        "#<#{self.class} id=#{id}, rank=#{rank} targetable?=#{targetable?}>"
+      end
+      def to_h
+        {id: id, rank: rank, targetable?: targetable?}
+      end
+    end
+  end
+end
+

data/lib/love_letter_application/models/effects/discard_and_draw.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require 'dry-initializer'
+require 'love_letter_application/models/game_board'
+require 'love_letter_application/models/player'
+
+module LoveLetterApplication
+  module Models
+    class Effects
+      class DiscardAndDraw
+        include Dry::Initializer.define -> do
+          option :null_card, type: LoveLetterApplication::Types::Card
+        end
+
+        def call(game_board:, player_id:)
+          draw_pile = game_board.draw_pile
+          sac = game_board.set_aside_card
+          player_replacement = get_replacement(game_board.players, player_id, draw_pile, sac)
+          players = game_board
+            .players
+            .reject{|player| player.id.to_i.eql?(player_id.to_i)}
+            .push(player_replacement)
+            .freeze
+
+          draw_pile = game_board.draw_pile
+          draw_pile = game_board.draw_pile[1..-1].map(&:itself).freeze unless draw_pile.empty?
+
+          LoveLetterApplication::Models::GameBoard::new(
+            players: players,
+            draw_pile: draw_pile,
+            set_aside_card: (game_board.draw_pile.empty? ? null_card : game_board.set_aside_card),
+            current_player_id: game_board.current_player_id.to_i,
+            game_state: game_board.game_state)
+        end
+
+        private
+        def get_replacement(players, player_id, draw_pile, set_aside_card)
+          player = players.find{|player| player.id.eql?(player_id.to_i)}
+          LoveLetterApplication::Models::Player::new(
+            id: player.id.to_i,
+            seat: player.seat.to_i,
+            played_cards: (player.played_cards + player.hand).freeze,
+            hand: [draw_pile.first || set_aside_card].freeze,
+            active?: player.active?,
+            targetable?: player.targetable?)
+        end
+      end
+    end
+  end
+end
+

data/lib/love_letter_application/models/effects/eliminate_player.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require 'love_letter_application/models/game_board'
+require 'love_letter_application/models/player'
+
+module LoveLetterApplication
+  module Models
+    class Effects
+      class EliminatePlayer
+        def call(game_board:, player_id:)
+          eliminated_player_replacement = get_replacement(game_board.players, player_id)
+
+          players = game_board
+            .players
+            .reject{|player| player.id.to_i.eql?(player_id.to_i)}
+            .push(eliminated_player_replacement)
+            .freeze
+
+          LoveLetterApplication::Models::GameBoard::new(
+            players: players,
+            draw_pile: game_board.draw_pile.map(&:itself).freeze,
+            set_aside_card: game_board.set_aside_card,
+            current_player_id: game_board.current_player_id.to_i,
+            game_state: game_board.game_state)
+        end
+
+        private
+        def get_replacement(players, player_id)
+          eliminated_player = players
+            .find{|player| player.id.to_i.eql?(player_id.to_i)}
+          LoveLetterApplication::Models::Player::new(
+            id: eliminated_player.id.to_i,
+            seat: eliminated_player.id.to_i,
+            played_cards: (eliminated_player.played_cards + eliminated_player.hand).freeze,
+            hand: [].freeze,
+            active?: false,
+            targetable?: false)
+        end
+      end
+    end
+  end
+end
+

data/lib/love_letter_application/models/effects/make_player_not_targetable.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require 'dry-initializer'
+require 'love_letter_application/models/game_board'
+require 'love_letter_application/models/player'
+
+module LoveLetterApplication
+  module Models
+    class Effects
+      class MakePlayerNotTargetable
+        def call(game_board:, player_id:)
+          player_replacement = get_replacement(game_board.players, player_id)
+
+          players = game_board
+            .players
+            .reject{|player| player.id.to_i.eql?(player_id.to_i)}
+            .push(player_replacement)
+
+          LoveLetterApplication::Models::GameBoard::new(
+            players: players,
+            draw_pile: game_board.draw_pile,
+            set_aside_card: game_board.set_aside_card,
+            current_player_id: game_board.current_player_id,
+            game_state: game_board.game_state)
+        end
+
+        private
+        def get_replacement(players, player_id)
+          modified_player = players
+            .find{|player| player.id.to_i.eql?(player_id.to_i)}
+
+          LoveLetterApplication::Models::Player::new(
+            id: modified_player.id.to_i,
+            seat: modified_player.id.to_i,
+            played_cards: modified_player.played_cards,
+            hand: modified_player.hand,
+            active?: modified_player.active?,
+            targetable?: false)
+        end
+      end
+    end
+  end
+end
+

data/lib/love_letter_application/models/effects/next_player_draw_card.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require 'dry-initializer'
+require 'love_letter_application/models/game_board'
+require 'love_letter_application/types/player'
+require 'love_letter_application/types/game_board'
+
+module LoveLetterApplication
+  module Models
+    class Effects
+      class NextPlayerDrawCard
+        def call(game_board:, next_player_id:)
+          draw_pile = game_board.draw_pile
+          player_replacement = get_replacement(game_board.players, next_player_id, draw_pile)
+          players = game_board
+            .players
+            .reject{|player| player.id.to_i.eql?(next_player_id.to_i)}
+            .push(player_replacement)
+            .freeze
+
+          draw_pile = game_board.draw_pile[1..-1].map(&:itself).freeze
+
+          LoveLetterApplication::Models::GameBoard::new(
+            players: players,
+            draw_pile: draw_pile,
+            set_aside_card: game_board.set_aside_card,
+            current_player_id: next_player_id,
+            game_state: LoveLetterApplication::Types::GameStateEnum.call('card_drawn'))
+        end
+
+        private
+        def get_replacement(players, player_id, draw_pile)
+          next_player = players.find{|player| player.id.eql?(player_id.to_i)}
+          LoveLetterApplication::Models::Player::new(
+            id: next_player.id.to_i,
+            seat: next_player.seat.to_i,
+            played_cards: next_player.played_cards.map(&:itself).freeze,
+            hand: next_player.hand.map(&:itself).push(draw_pile.first).freeze,
+            active?: next_player.active?,
+            targetable?: true) # limitations on being targeted expire when player's turn again
+        end
+      end
+    end
+  end
+end

data/lib/love_letter_application/models/effects/play_card.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require 'love_letter_application/models/game_board'
+require 'love_letter_application/models/player'
+
+module LoveLetterApplication
+  module Models
+    class Effects
+      class PlayCard
+        def call(game_board:, card_id:)
+          player_id = game_board.current_player_id.to_i
+          player_replacement = get_replacement(game_board.players, player_id, card_id)
+
+          players = game_board
+            .players
+            .reject{|player| player.id.to_i.eql?(player_id.to_i)}
+            .push(player_replacement)
+
+          LoveLetterApplication::Models::GameBoard::new(
+            players: players,
+            draw_pile: game_board.draw_pile,
+            set_aside_card: game_board.set_aside_card,
+            current_player_id: game_board.current_player_id,
+            game_state: game_board.game_state)
+        end
+
+        private
+        def get_replacement(players, player_id, card_id)
+          modified_player = players
+            .find{|player| player.id.to_i.eql?(player_id.to_i)}
+          played_card = modified_player.hand.find{|card| card.id.to_i.eql?(card_id.to_i)}
+          new_hand = modified_player.hand.map(&:itself)
+          new_hand.slice!(new_hand.index{|card| card.id.to_i.eql?(card_id.to_i)}).freeze
+          new_played_cards = ([played_card] + modified_player.played_cards.map(&:itself)).freeze
+
+          LoveLetterApplication::Models::Player::new(
+            id: modified_player.id.to_i,
+            seat: modified_player.id.to_i,
+            played_cards: new_played_cards,
+            hand: new_hand,
+            active?: modified_player.active?,
+            targetable?: modified_player.targetable?)
+        end
+      end
+    end
+  end
+end
+

data/lib/love_letter_application/models/effects/round_complete.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'love_letter_application/models/game_board'
+require 'love_letter_application/types/game_board'
+
+module LoveLetterApplication
+  module Models
+    class Effects
+      class RoundComplete
+        def call(game_board:, victorious_player_id:)
+          victorious_player_id = ::Types::Array::of(::Types::Strict::Integer)
+            .call(victorious_player_id)
+          next_player_id = game_board.players
+            .select{|player| victorious_player_id.include?(player.id.to_i)}
+            .max{|p, q| p.id.to_i <=> q.id.to_i}
+            .id
+
+          LoveLetterApplication::Models::GameBoard::new(
+            players: game_board.players,
+            draw_pile: game_board.draw_pile,
+            set_aside_card: game_board.set_aside_card,
+            current_player_id: next_player_id,
+            game_state: LoveLetterApplication::Types::GameStateEnum.call('round_complete'))
+        end
+      end
+    end
+  end
+end
+

data/lib/love_letter_application/models/effects/switch_hands.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require 'love_letter_application/models/game_board'
+require 'love_letter_application/models/player'
+
+module LoveLetterApplication
+  module Models
+    class Effects
+      class SwitchHands
+        def call(game_board:, player_id:, target_player_id:)
+          player_replacement = get_replacement(game_board.players, player_id, target_player_id)
+          target_replacement = get_replacement(game_board.players, target_player_id, player_id)
+
+          players = game_board
+            .players
+            .reject{|player| [player_id.to_i, target_player_id.to_i].include?(player.id.to_i)}
+            .push(player_replacement)
+            .push(target_replacement)
+            .freeze
+
+          LoveLetterApplication::Models::GameBoard::new(
+            players: players,
+            draw_pile: game_board.draw_pile.map(&:itself).freeze,
+            set_aside_card: game_board.set_aside_card,
+            current_player_id: game_board.current_player_id.to_i,
+            game_state: game_board.game_state)
+        end
+
+        private
+        def get_replacement(players, player_id, target_player_id)
+          player_to_replace = players
+            .find{|player| player.id.to_i.eql?(player_id.to_i)}
+          hand_to_replace_with = players
+            .find{|player| player.id.to_i.eql?(target_player_id.to_i)}
+            .hand
+            .map(&:itself)
+            .freeze
+          LoveLetterApplication::Models::Player::new(
+            id: player_to_replace.id.to_i,
+            seat: player_to_replace.id.to_i,
+            played_cards: player_to_replace.played_cards.map(&:itself).freeze,
+            hand: hand_to_replace_with,
+            active?: player_to_replace.active?,
+            targetable?: player_to_replace.targetable?)
+        end
+      end
+    end
+  end
+end
+

data/lib/love_letter_application/models/game_board.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'dry-struct'
+require 'love_letter_application/types/game_board'
+require 'love_letter_application/types/card'
+require 'love_letter_application/types/player'
+
+module LoveLetterApplication
+  module Models
+    class GameBoard < Dry::Struct
+      attribute :players, ::Types::Array::of(LoveLetterApplication::Types::Player)
+      attribute :draw_pile, ::Types::Array::of(LoveLetterApplication::Types::Card)
+      attribute :set_aside_card, LoveLetterApplication::Types::Card
+      attribute :current_player_id, ::Types::Coercible::Integer
+      attribute :game_state, LoveLetterApplication::Types::GameStateEnum
+      def to_h
+        {
+          players: players.map(&:to_h),
+          draw_pile: draw_pile.map(&:to_h),
+          set_aside_card: set_aside_card.to_h,
+          current_player_id: current_player_id,
+          game_state: game_state
+        }
+      end
+    end
+  end
+end
+

data/lib/love_letter_application/models/player.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require 'dry-initializer'
+require 'love_letter_application/types/card'
+
+module LoveLetterApplication
+  module Models
+    class Player
+      include Dry::Initializer.define -> do
+        option :id, type: ::Types::Coercible::Integer
+        option :seat, type: ::Types::Coercible::Integer
+        option :played_cards, type: ::Types::Array::of(LoveLetterApplication::Types::Card)
+        option :hand, type: ::Types::Array::of(LoveLetterApplication::Types::Card)
+        option :active?, as: :active, type: ::Types::Strict::Bool, reader: false
+        option :targetable?, as: :targetable, type: ::Types::Strict::Bool, reader: false
+      end
+      def active?;@active;end
+      def targetable?;@targetable;end
+      def inspect
+        "#<#{self.class} id=#{id}, seat=#{seat} played_cards=#{played_cards} hand=#{hand} " +
+          "targetable?=#{targetable?} active?=#{active?}>"
+      end
+      def to_h
+        { 
+          id: id,
+          seat: seat,
+          played_cards: played_cards.map(&:to_h),
+          hand: hand.map(&:to_h),
+          targetable?: targetable?,
+          active?: active?
+        }
+      end
+    end
+  end
+end
+

data/lib/love_letter_application/results/eliminate_player.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require 'dry-initializer'
+
+module LoveLetterApplication
+  module Results
+    class EliminatePlayer
+      extend Dry::Initializer
+      option :process_round_complete_by_elimination, type: ::Types::Callable
+      option :eliminate_player_from_game_board, ::Types::Callable
+      option :process_next_player_turn, type: ::Types::Callable
+      option :get_eliminated_player_node, type: ::Types::Callable
+
+      def call(target_player_id:, game_board:, change_orders:)
+        change_orders = change_orders
+          .push(get_eliminated_player_node.(player_id: target_player_id))
+        game_board = eliminate_player_from_game_board.(
+          game_board: game_board,
+          player_id: target_player_id)
+        if one_player_remaining?(game_board)
+          process_round_complete_by_elimination.(
+            game_board: game_board,
+            change_orders: change_orders,
+            player: game_board
+              .players
+              .find(&:active?))
+        else
+          process_next_player_turn.(game_board: game_board, change_orders: change_orders)
+        end
+      end
+
+      private
+      def one_player_remaining?(game_board)
+        game_board
+          .players
+          .select(&:active?)
+          .length
+          .eql?(1)
+      end
+    end
+  end
+end
+