spy_alley_application 0.3.0

data/lib/spy_alley_application/results/nodes/money_gained_node.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require 'dry-struct'
+require 'spy_alley_application/models/acquisition_method/by_passing_start'
+require 'spy_alley_application/models/acquisition_method/by_selling_top_secret_information'
+
+module SpyAlleyApplication
+  module Results
+    module Nodes
+      class MoneyGainedNode < Dry::Struct
+        @@can_handle_money_gained = ::Types.Interface(:handle_money_gained)
+        attribute :player_id, ::Types::Coercible::Integer
+        attribute :money_gained, ::Types::CoercibleNonnegativeInteger
+        attribute :reason, SpyAlleyApplication::Models::AcquisitionMethod::ByPassingStart |
+          SpyAlleyApplication::Models::AcquisitionMethod::BySellingTopSecretInformation
+
+        def accept(visitor, **args)
+          @can_handle_money_gained.(visitor)
+          visitor.handle_money_gained(self, args)
+        end
+      end
+    end
+  end
+end
+

data/lib/spy_alley_application/results/nodes/money_lost_node.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require 'dry-struct'
+
+module SpyAlleyApplication
+  module Results
+    module Nodes
+      class MoneyLostNode < Dry::Struct
+        @@can_handle_money_lost = ::Types.Interface(:handle_money_lost)
+        attribute :player_id, ::Types::Coercible::Integer
+        attribute :money_lost, ::Types::CoercibleNonnegativeInteger
+
+        def accept(visitor, **args)
+          @can_handle_money_lost.(visitor)
+          visitor.handle_money_lost(self, args)
+        end
+      end
+    end
+  end
+end
+

data/lib/spy_alley_application/results/nodes/move_back_node.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require 'dry-struct'
+
+module SpyAlleyApplication
+  module Results
+    module Nodes
+      class MoveBackNode < Dry::Struct
+        @@can_handle_money_gained = ::Types.Interface(:handle_move_back)
+        attribute :player_id, ::Types::Coercible::Integer
+        attribute :player_moved, ::Types.Interface(:accept)
+
+        def accept(visitor, **args)
+          @can_handle_move_back.(visitor)
+          visitor.handle_move_back(self, args)
+        end
+      end
+    end
+  end
+end
+

data/lib/spy_alley_application/results/nodes/move_card_drawn_node.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'dry-struct'
+require 'spy_alley_application/types/coercible_integer_one_to_six'
+
+module SpyAlleyApplication
+  module Results
+    module Nodes
+      class MoveCardDrawnNode < Dry::Struct
+        @@can_handle_move_card_drawn = ::Types.Interface(:handle_move_card_drawn)
+        attribute :player_id, ::Types::Coercible::Integer
+        attribute :card, SpyAlleyApplication::Types::CoercibleIntegerOneToSix
+
+        def accept(visitor, **args)
+          @can_handle_move_card_drawn.(visitor)
+          visitor.handle_card_card_drawn(self, args)
+        end
+      end
+    end
+  end
+end
+

data/lib/spy_alley_application/results/nodes/move_card_used_node.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'dry-struct'
+require 'spy_alley_application/types/coercible_integer_one_to_six'
+
+module SpyAlleyApplication
+  module Results
+    module Nodes
+      class MoveCardUsedNode < Dry::Struct
+        @@can_handle_move_card_used = ::Types.Interface(:handle_move_card_used)
+        attribute :player_id, ::Types::Coercible::Integer
+        attribute :card, SpyAlleyApplication::Types::CoercibleIntegerOneToSix
+
+        def accept(visitor, **args)
+          @can_handle_move_card_used.(visitor)
+          visitor.handle_card_card_used(self, args)
+        end
+      end
+    end
+  end
+end
+

data/lib/spy_alley_application/results/nodes/move_option_node.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'dry-struct'
+
+module SpyAlleyApplication
+  module Results
+    module Nodes
+      class MoveOptionNode < Dry::Struct
+        @@can_handle_move_option = ::Types.Interface(:handle_move_option)
+        attribute :options, ::Types::ArrayOfStrictInteger
+
+        def accept(visitor, **args)
+          @can_handle_move_option.(visitor)
+          visitor.handle_move_option(self, args)
+        end
+      end
+    end
+  end
+end
+

data/lib/spy_alley_application/results/nodes/new_spy_identity_chosen_node.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require 'dry-struct'
+require 'spy_alley_application/types/nationality'
+
+module SpyAlleyApplication
+  module Results
+    module Nodes
+      class NewSpyIdentityChosenNode < Dry::Struct
+        @@can_handle_move_option = ::Types.Interface(:handle_new_spy_identity_chosen)
+        attribute :nationality, SpyAlleyApplication::Types::Nationality
+
+        def accept(visitor, **args)
+          @can_handle_new_spy_identity_chosen.(visitor)
+          visitor.handle_new_spy_identity_chosen(self, args)
+        end
+      end
+    end
+  end
+end
+

data/lib/spy_alley_application/results/nodes/next_player_node.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'dry-struct'
+
+module SpyAlleyApplication
+  module Results
+    module Nodes
+      class NextPlayerNode < Dry::Struct
+        @@can_handle_next_player = ::Types.Interface(:handle_next_player)
+        attribute :player_id, ::Types::Strict::Integer
+
+        def accept(visitor, **args)
+          @@can_handle_next_player.(visitor)
+          visitor.handle_next_player(self, args)
+        end
+      end
+    end
+  end
+end
+

data/lib/spy_alley_application/results/nodes/pass_option_node.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module SpyAlleyApplication
+  module Results
+    module Nodes
+      class PassOptionNode
+        @@can_handle_roll_die_option = ::Types.Interface(:handle_roll_die_option)
+        def accept(visitor, **args)
+          @@can_handle_roll_die_option.(visitor)
+          visitor.handle_roll_die_option(self, args)
+        end
+      end
+    end
+  end
+end
+

data/lib/spy_alley_application/results/nodes/player_movement_node.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require 'dry-struct'
+
+module SpyAlleyApplication
+  module Results
+    module Nodes
+      class PlayerMovementNode < Dry::Struct
+        @@can_handle_player_movement = ::Types.Interface(:handle_player_movement)
+        attribute :player_id, ::Types::Strict::Integer
+        attribute :space_id, ::Types::Strict::Integer
+
+        def accept(visitor, **args)
+          @can_handle_player_movement.(visitor)
+          visitor.handle_player_movement(self, args)
+        end
+      end
+    end
+  end
+end
+

data/lib/spy_alley_application/results/nodes/player_passed_node.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'dry-struct'
+
+module SpyAlleyApplication
+  module Results
+    module Nodes
+      class PlayerPassedNode < Dry::Struct
+        @@can_handle_player_passed = ::Types.Interface(:handle_player_passed)
+
+        def accept(visitor, **args)
+          @can_handle_player_passed.(visitor)
+          visitor.handle_player_passed(self, args)
+        end
+      end
+    end
+  end
+end
+

data/lib/spy_alley_application/results/nodes/reached_embassy_with_all_equipment_node.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'dry-struct'
+
+module SpyAlleyApplication
+  module Results
+    module Nodes
+      class ReachedEmbassyWithAllEquipmentNode < Dry::Struct
+        @@can_handle_reaced_embassy_with_all_equipment =
+          ::Types.Interface(:handle_reaced_embassy_with_all_equipment)
+
+        def accept(visitor, **args)
+          @can_handle_reached_embassy_with_all_equipment.(visitor)
+          visitor.handle_reached_embassy_with_all_equipment(self, args)
+        end
+      end
+    end
+  end
+end
+

data/lib/spy_alley_application/results/nodes/result_game_board_node.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require 'dry-struct'
+require 'spy_alley_application/models/game_board'
+
+module SpyAlleyApplication
+  module Results
+    module Nodes
+      class ResultGameBoardNode < Dry::Struct
+        @@can_handle_result_game_board = ::Types.Interface(:handle_result_game_board)
+        attribute :game_board, SpyAlleyApplication::Models::GameBoard
+
+        def accept(visitor, **args)
+          @@can_handle_result_game_board.(visitor)
+          visitor.handle_result_game_board(self, args)
+        end
+      end
+    end
+  end
+end
+

data/lib/spy_alley_application/results/nodes/roll_die_option_node.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module SpyAlleyApplication
+  module Results
+    module Nodes
+      class RollDieOptionNode
+        @@can_handle_roll_die_option = ::Types.Interface(:handle_roll_die_option)
+        def accept(visitor, **args)
+          @@can_handle_roll_die_option.(visitor)
+          visitor.handle_roll_die_option(self, args)
+        end
+      end
+    end
+  end
+end
+

data/lib/spy_alley_application/results/nodes/use_move_card_option_node.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'dry-struct'
+
+module SpyAlleyApplication
+  module Results
+    module Nodes
+      class UseMoveCardOptionNode < Dry::Struct
+        @@can_handle_use_move_card = ::Types.Interface(:handle_use_move_card)
+        attribute :card_list, ::Types::ArrayOfStrictInteger
+
+        def accept(visitor, **args)
+          @@can_handle_use_move_card.(visitor)
+          visitor.handle_use_move_card(self, args)
+        end
+      end
+    end
+  end
+end
+

data/lib/spy_alley_application/results/nodes/wild_card_gained_node.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'dry-struct'
+require 'spy_alley_application/models/acquisition_method/by_confiscation'
+require 'spy_alley_application/models/acquisition_method/by_free_gift'
+require 'spy_alley_application/models/acquisition_method/by_purchase'
+
+module SpyAlleyApplication
+  module Results
+    module Nodes
+      class WildCardGainedNode < Dry::Struct
+        @@can_handle_wild_card_gained = ::Types.Interface(:handle_wild_card_gained)
+        attribute :player_id, ::Types::Coercible::Integer
+        attribute :number_gained, ::Types::CoercibleNonnegativeInteger
+        attribute :reason, SpyAlleyApplication::Models::AcquisitionMethod::ByConfiscation |
+          SpyAlleyApplication::Models::AcquisitionMethod::ByFreeGift |
+          SpyAlleyApplication::Models::AcquisitionMethod::ByPurchase
+
+        def accept(visitor, **args)
+          @can_handle_wild_card_gained.(visitor)
+          visitor.handle_wild_card_gained(self, args)
+        end
+      end
+    end
+  end
+end
+

data/lib/spy_alley_application/results/process_buy_equipment_options.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require 'dry-initializer'
+require 'spy_alley_application/models/game_state/buy_equipment'
+
+module SpyAlleyApplication
+  module Results
+    class ProcessBuyEquipmentOptions
+      include Dry::Initializer.define -> do
+        option :get_buy_equipment_option_node, type: ::Types::Callable, reader: :private
+        option :get_next_player_node, type: ::Types::Callable, reader: :private
+        option :get_pass_option_node, type: ::Types::Callable, reader: :private
+      end
+
+      def call(game_board:, change_orders:)
+        next_player = game_board.players.find{|p| p.seat.eql?(game_board.game_state.seat)}
+        node = SpyAlleyApplication::Models::GameState::BuyEquipment.call(game_board.game_state)
+        change_orders.push(get_next_player_node.(player_id: next_player.id))
+          .push(get_buy_equipment_node.(options: node.options, limit: node.limit))
+          .push(get_pass_option_node.())
+      end
+    end
+  end
+end
+

data/lib/spy_alley_application/results/process_eliminating_player.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require 'dry-initializer'
+
+module SpyAlleyApplication
+  module Results
+    class ProcessEliminatingPlayer
+      include Dry::Initializer.define -> do
+        option :get_eliminated_player_node, type: ::Types::Callable, reader: :private
+        option :get_game_over_node, type: ::Types::Callable, reader: :private
+        option :get_result_game_board_node, type: ::Types::Callable, reader: :private
+        option :eliminate_player, type: ::Types::Callable, reader: :private
+        option :process_next_turn_options, type: ::Types::Callable, reader: :private
+      end
+
+      def call(game_board:, change_orders:, eliminating_player:, eliminated_player:)
+        change_orders = change_orders.push(get_eliminated_player_node.(
+          eliminating_player: eliminating_player,
+          eliminated_player: eliminated_player))
+        game_board = eliminate_player.(
+          game_board: game_board,
+          eliminating_player: eliminating_player,
+          eliminated_player: eliminated_player)
+        if game_board.players.count(&:active) < 2
+          change_orders = change_orders.push(get_game_over_node.(
+            winning_player_id: eliminating_player.id,
+            reason: {name: 'by_elimination'}))
+        end
+        process_next_turn_options.(
+          game_board: game_board,
+          change_orders: change_orders.push(get_result_game_board_node.(game_board: game_board)))
+      end
+    end
+  end
+end
+

data/lib/spy_alley_application/results/process_landing_on_space.rb

@@ -0,0 +1,232 @@
+# require 'dry-initializer'
+
+module SpyAlleyApplication
+  module Results
+    class ProcessLandingOnSpace
+      include Dry::Initializer.define -> do
+        option :black_market_option_state, type: ::Types::Callable, reader: :private
+        option :buy_equipment_option_state, type: ::Types::Callable, reader: :private
+        option :buy_password_option_state, type: ::Types::Callable, reader: :private
+        option :confiscate_materials_option_state, type: ::Types::Callable, reader: :private
+        option :embassy_victory, type: ::Types::Callable, reader: :private
+        option :free_gift_drawn, type: ::Types::Callable, reader: :private
+        option :get_equipment_gained_node, type: ::Types::Callable, reader: :private
+        option :get_game_over_node, type: ::Types::Callable, reader: :private
+        option :get_money_gained_node, type: ::Types::Callable, reader: :private
+        option :get_money_lost_node, type: ::Types::Callable, reader: :private
+        option :get_move_card_drawn_node, type: ::Types::Callable, reader: :private
+        option :get_player_movement_node, type: ::Types::Callable, reader: :private
+        option :get_result_game_board_node, type: ::Types::Callable, reader: :private
+        option :get_wild_card_gained_node, type: ::Types::Callable, reader: :private
+        option :money_gained_or_lost, type: ::Types::Callable, reader: :private
+        option :move_card_drawn, type: ::Types::Callable, reader: :private
+        option :next_game_state, type: ::Types::Callable, reader: :private
+        option :player_moved, type: ::Types::Callable, reader: :private
+        option :process_next_turn_options, type: ::Types::Callable, reader: :private
+        option :process_proceeding_to_next_state, type: ::Types::Callable, reader: :private
+        option :spy_eliminator_options, type: ::Types::Callable, reader: :private
+      end
+
+      def call(game_board:, change_orders:, space_id:)
+        player = game_board.current_player
+        change_orders = change_orders.push(get_player_movement_node.(
+          player_id: player.id,
+          space_id: space_id))
+        game_board = player_moved.(game_board: game_board, new_location: {id: space_id})
+        board_space = game_board.current_player.location
+        board_space.accept(self, game_board: game_board, change_orders: change_orders)
+      end
+
+      # ///////////////
+
+      def handle_black_market(board_space, game_board:, change_orders:)
+        game_board = black_market_option_state.(game_board: game_board)
+        process_next_turn_options.(
+          game_board: game_board,
+          change_orders: change_orders.push(get_result_game_board_node.(game_board: game_board)))
+      end
+
+      # ///////////////
+
+      def handle_border_crossing(board_space, game_board:, change_orders:)
+        change_orders = change_orders.push(get_money_lost_node.(
+          player_id: game_board.current_player.id,
+          money_lost: 5))
+        game_board = money_gained_or_lost.(
+          game_board: game_board,
+          money_adjustment: -5)
+        process_proceeding_to_next_state.(
+          game_board: game_board,
+          change_orders: change_orders)
+      end
+
+      # ///////////////
+
+      def handle_buy_equipment(board_space, game_board:, change_orders:)
+        game_board = buy_equipment_option_state.(
+          game_board: game_board,
+          equipment_type: board_space.equipment_type)
+        process_next_turn_options.(
+          game_board: game_board,
+          change_orders: change_orders.push(get_result_game_board_node.(game_board: game_board)))
+      end
+
+      # ///////////////
+
+      def handle_buy_password(board_space, game_board:, change_orders:)
+        game_board = buy_password_option_state.(
+          game_board: game_board,
+          nationality: board_space.nationality)
+        process_next_turn_options.(
+          game_board: game_board,
+          change_orders: change_orders.push(get_result_game_board_node.(game_board: game_board)))
+      end
+
+      # ///////////////
+
+      def handle_confiscate_materials(board_space, game_board:, change_orders:)
+        game_board = confiscate_materials_option_state.(game_board: game_board)
+        process_next_turn_options.(
+          game_board: game_board,
+          change_orders: change_orders.push(get_result_game_board_node.(game_board: game_board)))
+      end
+
+      # ///////////////
+
+      def handle_draw_free_gift(board_space, game_board:, change_orders:)
+        change_orders = game_board.free_gift_pile.first.accept(self,
+          change_orders: change_orders,
+          player_id: game_board.current_player.id)
+        game_board = free_gift_drawn.(game_board: game_board)
+        process_proceeding_to_next_state.(
+          game_board: game_board,
+          change_orders: change_orders)
+      end
+
+      def handle_equipment(equipment, change_orders:, player_id:)
+        change_orders.push(get_equipment_gained_node.(
+          player_id: player_id,
+          equipment: [equipment],
+          reason: {name: 'by_free_gift'}))
+      end
+
+      def handle_wild_card(wild_card, change_orders:, player_id:)
+        change_orders.push(get_wild_card_gained_node.(
+          player_id: player_id,
+          number_gained: 1,
+          reason: {name: 'by_free_gift'}))
+      end
+
+      # ///////////////
+
+      def handle_draw_move_card(board_space, game_board:, change_orders:)
+        change_orders = change_orders.push(get_move_card_drawn_node.(
+          player_id: game_board.current_player.id,
+          card: game_board.move_card_pile.first.value))
+        game_board = move_card_drawn.(game_board: game_board)
+        process_proceeding_to_next_state.(
+          game_board: game_board,
+          change_orders: change_orders)
+      end
+
+      # ///////////////
+
+      def handle_embassy(board_space, game_board:, change_orders:)
+        player = game_board.current_player
+        spy_identity = player.spy_identity
+        equipment_total = player.equipment.select{|e| e.nationality.eql?(spy_identity)}.size
+        equipment_total += player.wild_cards
+        if equipment_total >= 4
+          change_orders
+            .push(get_game_over_node.(winning_player_id: player.id, reason: {name: 'by_embassy'}))
+            .push(get_result_game_board_node.(
+              game_board: embassy_victory.(game_board: game_board)))
+        else
+          process_proceeding_to_next_state.(
+            game_board: game_board,
+            change_orders: change_orders)
+        end
+      end
+
+      # ///////////////
+
+      def handle_move_back(board_space, game_board:, change_orders:)
+        game_board = game_board = player_moved.(
+          game_board: game_board,
+          new_location: board_space.move_back_space)
+        change_orders = change_orders.push(get_player_movement_node.(
+          player_id: game_board.current_player.id,
+          space_id: board_space.move_back_space.id))
+        game_board = game_board = player_moved.(game_board: game_board, new_location: board_space)
+        process_proceeding_to_next_state.(
+          game_board: game_board,
+          change_orders: change_orders)
+      end
+
+      # ///////////////
+
+      def handle_sold_top_secret_information(board_space, game_board:, change_orders:)
+        current_player = game_board.current_player
+
+        game_board = money_gained_or_lost.(
+          game_board: game_board,
+          money_adjustment: board_space.money_gained)
+
+        process_proceeding_to_next-state.(
+          game_board: game_board,
+          change_orders: change_orders
+            .push(get_money_gained_node.(
+              player_id: current_player.id,
+              money_gained: board_space.money_gained,
+              reason: {name: 'by_selling_top_secret_information'})))
+      end
+
+      # ///////////////
+
+      def handle_spy_alley_entrance(board_space, game_board:, change_orders:)
+        process_proceeding_to_next_state.(
+          game_board: game_board,
+          change_orders: change_orders)
+      end
+
+      # ///////////////
+
+      def handle_spy_eliminator(board_space, game_board:, change_orders:)
+        game_board = spy_eliminator_options.(game_board: game_board)
+
+        process_next_turn_options.(
+          game_board: next_game_state.(game_board: game_board),
+          change_orders: change_orders.push(get_result_game_board_node.(game_board: game_board)))
+      end
+
+      # ///////////////
+
+      def handle_start(board_space, game_board:, change_orders:)
+        current_player = game_board.current_player
+
+        game_board = money_gained_or_lost.(
+          game_board: game_board,
+          money_adjustment: 15,
+          &next_game_state)
+
+        process_next_turn_options.(
+          game_board: game_board,
+          change_orders: change_orders
+            .push(get_money_gained_node.(
+              player_id: current_player.id,
+              money_gained: 15,
+              reason: {name: 'by_passing_start'}))
+            .push(get_result_game_board_node.(game_board: game_board)))
+      end
+
+      # ///////////////
+
+      def handle_take_another_turn(board_space, game_board:, change_orders:)
+        process_next_turn_options.(
+          game_board: game_board,
+          change_orders: change_orders.push(get_result_game_board_node.(game_board: game_board)))
+      end
+    end
+  end
+end
+