spy_alley_application 0.3.0

data/lib/spy_alley_application/results/process_move_options.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require 'dry-initializer'
+
+module SpyAlleyApplication
+  module Results
+    class ProcessMoveOptions
+      include Dry::Initializer.define -> do
+        option :move_options, type: ::Types::Callable, reader: :private
+        option :process_landing_on_space, type: ::Types::Callable, reader: :private
+        option :process_next_turn_options, type: ::Types::Callable, reader: :private
+      end
+
+      def call(game_board:, change_orders:, board_space:, spaces_remaining:)
+        space_id_list = [board_space.branch_space, board_space.next_space]
+          .map{|space| space_id(space, game_board, spaces_remaining - 1)}
+          .reject(&:nil?)
+          .freeze
+
+        if space_id_list.length.eql?(1)
+          process_landing_on_space.(
+            game_board: game_board,
+            change_orders: change_orders,
+            space_id: space_id_list.first)
+        else
+          game_board = move_options.(game_board: game_board, options: space_id_list)
+          process_next_turn_options.(game_board: game_board, change_orders: change_orders)
+        end
+      end
+
+      # player cannot land on border crossing if cannot pay the toll ($5) to cross the border
+      def handle_border_crossing(space, game_board:)
+        if game_board.current_player.money < 5
+          nil
+        else
+          space.id
+        end
+      end
+
+      # no other such restriction from landing on any other space on the board
+      def handle_embassy(space, game_board:)
+        space.id
+      end
+      alias_method :handle_move_back, :handle_embassy
+      alias_method :handle_buy_password, :handle_embassy
+      alias_method :handle_buy_equipment, :handle_embassy
+      alias_method :handle_draw_move_card, :handle_embassy
+      alias_method :handle_sold_top_secret_information, :handle_embassy
+      alias_method :handle_spy_eliminator, :handle_embassy
+      alias_method :handle_confiscate_materials, :handle_embassy
+      alias_method :handle_take_another_turn, :handle_embassy
+      alias_method :handle_draw_free_gift, :handle_embassy
+      alias_method :handle_start, :handle_embassy
+      alias_method :handle_black_market, :handle_embassy
+      alias_method :handle_spy_alley_entrance, :handle_embassy
+
+      private
+      def space_id(space, game_board, spaces_remaining)
+        spaces_remaining.times{space = space.next_space}
+        space.accept(self, game_board: game_board)
+      end
+    end
+  end
+end
+

data/lib/spy_alley_application/results/process_next_turn_options.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require 'dry-initializer'
+
+module SpyAlleyApplication
+  module Results
+    class ProcessNextTurnOptions
+      include Dry::Initializer.define -> do
+        option :get_buy_equipment_option_node, type: ::Types::Callable, reader: :private
+        option :get_choose_new_spy_identity_option_node, type: ::Types::Callable, reader: :private
+        option :get_confiscate_materials_option_node, type: ::Types::Callable, reader: :private
+        option :get_make_accusation_option_node, type: ::Types::Callable, reader: :private
+        option :get_move_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
+        option :get_roll_die_option_node, type: ::Types::Callable, reader: :private
+        option :get_use_move_card_option_node, type: ::Types::Callable, reader: :private
+      end
+      def call(game_board:, change_orders:, **args)
+        game_board.game_state.accept(self, game_board: game_board, change_orders: change_orders)
+      end
+
+      def handle_buy_equipment(game_state, game_board:, change_orders:)
+        next_player = game_board.current_player
+        change_orders.push(get_next_player_node.(player_id: next_player.id))
+          .push(get_buy_equipment_option_node.(
+            options: game_state.options,
+            limit: game_state.limit))
+          .push(get_pass_option_node.())
+      end
+
+      def handle_choose_new_spy_identity(game_state, game_board:, change_orders:)
+        next_player = game_board.current_player
+        change_orders.push(get_next_player_node.(player_id: next_player.id))
+          .push(get_choose_new_spy_identity_option_node.(options: game_state.options))
+      end
+
+      def handle_confiscate_materials(game_state, game_board:, change_orders:)
+        next_player = game_board.current_player
+        game_state.targets.each do |t|
+          change_orders = change_orders.push(get_confiscate_materials_option_node.(
+            target_player_id: game_board.players.find{|p| p.seat.eql?(t.seat)}.id,
+            targetable_equipment: t.equipment))
+        end
+        change_orders.push(get_pass_option_node.())
+      end
+
+      def handle_game_over(game_state, game_board:, change_orders:)
+        change_orders
+      end
+
+      def handle_move_option(game_state, game_board:, change_orders:)
+        next_player = game_board.current_player
+        change_orders.push(get_next_player_node.(player_id: next_player.id))
+          .push(get_move_option_node.(options: game_state.options))
+      end
+
+      def handle_spy_eliminator(game_state, game_board:, change_orders:)
+        next_player = game_board.current_player
+        target_ids = game_board.players
+          .select{|p| game_state.targetable_seats.include?(p.seat)}
+          .map(&:id)
+          .sort
+        change_orders.push(get_next_player_node.(player_id: next_player.id))
+          .push(get_make_accusation_option_node.(player_id_list: target_ids))
+          .push(get_pass_option_node.())
+      end
+
+      def handle_start_of_turn(game_state, game_board:, change_orders:)
+        next_player = game_board.current_player
+        move_cards = next_player.move_cards.map(&:value).sort.uniq
+        target_ids = game_board.players.reject{|p| p.id.eql?(next_player.id)}.map(&:id).sort
+
+        change_orders = change_orders.push(get_next_player_node.(player_id: next_player.id))
+          .push(get_roll_die_option_node.())
+          .push(get_make_accusation_option_node.(player_id_list: target_ids))
+
+        if !move_cards.empty?
+          change_orders = change_orders.push(get_use_move_card_option_node.(card_list:move_cards))
+        end
+
+        change_orders
+      end
+    end
+  end
+end
+

data/lib/spy_alley_application/results/process_passing_spaces.rb

@@ -0,0 +1,68 @@
+require 'dry-initializer'
+require 'spy_alley_application/models/game_state/buy_equipment'
+
+module SpyAlleyApplication
+  module Results
+    class ProcessPassingSpaces
+      include Dry::Initializer.define -> do
+        option :get_money_gained_node, type: ::Types::Callable, reader: :private
+        option :money_gained_or_lost, type: ::Types::Callable, reader: :private
+        option :process_landing_on_space, type: ::Types::Callable, reader: :private
+        option :process_move_options, type: ::Types::Callable, reader: :private
+      end
+
+      def call(game_board:, change_orders:, board_space:, spaces_remaining:)
+        board_space = board_space.next_space
+        if spaces_remaining.eql?(1)
+          process_landing_on_space.(
+            game_board: game_board,
+            change_orders: change_orders,
+            space_id: board_space.id)
+        else
+          board_space.accept(self,
+            game_board: game_board,
+            change_orders: change_orders,
+            spaces_remaining: spaces_remaining)
+        end
+      end
+
+      def handle_start(board_space, game_board:, change_orders:, spaces_remaining:)
+        call(game_board: money_gained_or_lost.(game_board: game_board, money_adjustment: 15),
+          board_space: board_space,
+          spaces_remaining: spaces_remaining - 1,
+          change_orders: change_orders.push(get_money_gained_node.(
+            player_id: game_board.players.find{|p| p.seat.eql?(game_board.game_state.seat)}.id,
+            money_gained: 15,
+            reason: {name: 'by_passing_start'})))
+      end
+
+      def handle_spy_alley_entrance(board_space, game_board:, change_orders:, spaces_remaining:)
+        process_move_options.(
+          game_board: game_board,
+          change_orders: change_orders,
+          board_space: board_space,
+          spaces_remaining: spaces_remaining - 1)
+      end
+
+      def handle_buy_password(board_space, game_board:, change_orders:, spaces_remaining:)
+        # no special action, go to the next space
+        call(game_board: game_board,
+          change_orders: change_orders,
+          board_space: board_space,
+          spaces_remaining: spaces_remaining - 1)
+      end
+      alias_method :handle_buy_equipment, :handle_buy_password
+      alias_method :handle_black_market, :handle_buy_password
+      alias_method :handle_border_crossing, :handle_buy_password
+      alias_method :handle_confiscate_materials, :handle_buy_password
+      alias_method :handle_draw_free_gift, :handle_buy_password
+      alias_method :handle_draw_move_card, :handle_buy_password
+      alias_method :handle_embassy, :handle_buy_password
+      alias_method :handle_move_back, :handle_buy_password
+      alias_method :handle_sold_top_secret_information, :handle_buy_password
+      alias_method :handle_spy_eliminator, :handle_buy_password
+      alias_method :handle_take_another_turn, :handle_buy_password
+    end
+  end
+end
+

data/lib/spy_alley_application/results/process_proceeding_to_next_state.rb

@@ -0,0 +1,23 @@
+# require 'dry-initializer'
+
+module SpyAlleyApplication
+  module Results
+    class ProcessProceedingToNextState
+      include Dry::Initializer.define -> do
+        option :get_result_game_board_node, type: ::Types::Callable, reader: :private
+        option :next_game_state, type: ::Types::Callable, reader: :private
+        option :process_next_turn_options, type: ::Types::Callable, reader: :private
+      end
+
+      def call(game_board:, change_orders:, target_player_id: nil, **args)
+        game_board = next_game_state.(
+          game_board: game_board,
+          target_player_id: target_player_id)
+        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/types/array_of_equipment.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require 'spy_alley_application/types/equipment'
+
+SpyAlleyApplication::Types::ArrayOfEquipment =
+  Types::Array::of(SpyAlleyApplication::Types::Equipment)
+

data/lib/spy_alley_application/types/array_of_free_gifts.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require 'spy_alley_application/types/free_gift'
+
+SpyAlleyApplication::Types::ArrayOfFreeGifts =
+  Types::Array::of(SpyAlleyApplication::Types::FreeGift)
+

data/lib/spy_alley_application/types/array_of_move_cards.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+require 'spy_alley_application/types/move_card'
+
+SpyAlleyApplication::Types::ArrayOfMoveCards =
+  ::Types::Array::of(SpyAlleyApplication::Types::MoveCard)

data/lib/spy_alley_application/types/array_of_players.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+require 'spy_alley_application/models/player'
+
+SpyAlleyApplication::Types::ArrayOfPlayers =
+  Types::Array::of(SpyAlleyApplication::Models::Player)

data/lib/spy_alley_application/types/board_space.rb

@@ -0,0 +1,4 @@
+# frozen string literal: true
+
+SpyAlleyApplication::Types::BoardSpace =
+  ::Types.Interface(:id, :next_space, :accept, :in_spy_alley?)

data/lib/spy_alley_application/types/coercible_integer_one_to_six.rb

@@ -0,0 +1,9 @@
+# frozen string literal: true
+
+module SpyAlleyApplication
+  module Types
+  end
+end
+
+SpyAlleyApplication::Types::CoercibleIntegerOneToSix =
+  ::Types::Coercible::Integer.constrained(included_in: (1..6))

data/lib/spy_alley_application/types/equipment.rb

@@ -0,0 +1,32 @@
+# frozen string_literal: true
+
+require 'dry-types'
+require 'spy_alley_application/models/equipment'
+require 'spy_alley_application/types/equipment_type'
+require 'spy_alley_application/types/nationality'
+
+get_equipment = Hash.new do |h, k|
+  nationality, type = k.split(' ')
+  h[k] = SpyAlleyApplication::Models::Equipment::new(nationality: nationality, type: type)
+end
+
+i = Class.new do
+  def initialize(get_equipment)
+    @get_equipment = get_equipment
+  end
+
+  def call(equipment)
+    if !equipment.to_s.count(' ').eql?(1) || !equipment.to_s.split(' ').count.eql?(2)
+      raise Dry::Types::ConstraintError::new(
+        'Equipment string is ill formed', equipment.to_s)
+    end
+    nationality, type = equipment.to_s.split(' ')
+    SpyAlleyApplication::Types::Nationality.call(nationality)
+    SpyAlleyApplication::Types::EquipmentType.call(type)
+    @get_equipment[equipment.to_s]
+  end
+end.new(get_equipment)
+
+SpyAlleyApplication::Types::Equipment =
+  Types::Constructor(SpyAlleyApplication::Models::Equipment){|value| i.call(value)}
+

data/lib/spy_alley_application/types/equipment_type.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module SpyAlleyApplication
+  module Types
+  end
+end
+
+SpyAlleyApplication::Types::EquipmentType =
+  ::Types::String::enum('password', 'disguise', 'codebook', 'key')

data/lib/spy_alley_application/types/free_gift.rb

@@ -0,0 +1,22 @@
+# frozen string_literal: true
+
+require 'spy_alley_application/types/equipment'
+require 'spy_alley_application/models/wild_card'
+
+cached_wild_card = SpyAlleyApplication::Models::WildCard::new
+
+i = Class.new do
+  def initialize(cached_wild_card)
+    @cached_wild_card = cached_wild_card
+  end
+
+  def call(free_gift)
+    result = nil
+    if free_gift.to_s.eql?('wild card')
+      result = @cached_wild_card
+    end
+    result || SpyAlleyApplication::Types::Equipment.call(free_gift)
+  end
+end.new(cached_wild_card)
+
+SpyAlleyApplication::Types::FreeGift = Types::Constructor(Class){|value| i.call(value)}

data/lib/spy_alley_application/types/game_board.rb

@@ -0,0 +1,52 @@
+# frozen string_literal: true
+
+require 'dry-types'
+require 'spy_alley_application/models/game_board'
+require 'spy_alley_application/types/player'
+
+i = Class.new do
+  def call(game_board)
+    game_board[:players] = game_board[:players]&.map do |player|
+      SpyAlleyApplication::Types::Player.call(player.to_h)
+    end
+    game_board = SpyAlleyApplication::Models::GameBoard.call(game_board)
+    players = game_board.players
+    all_players_have_different_ids_seats_and_spy_identities(players)
+    verify_current_seat_is_valid(players, game_board.game_state.seat)
+    game_board
+  end
+
+  def all_players_have_different_ids_seats_and_spy_identities(players)
+    id_list = []
+    seat_list = []
+    spy_list = []
+    players.each do |player|
+      if id_list.include?(player.id)
+        raise Dry::Types::ConstraintError::new(
+          'All players have distinct ids', players.map(&:id))
+      end
+      if seat_list.include?(player.seat)
+        raise Dry::Types::ConstraintError::new(
+          'All players have distinct seats', players.map(&:seat))
+      end
+      if spy_list.include?(player.spy_identity)
+        raise Dry::Types::ConstraintError::new(
+          'All players have distinct spy_identities', players.map(&:spy_identity))
+      end
+      id_list.push player.id
+      seat_list.push player.seat
+      spy_list.push player.spy_identity
+    end
+  end
+
+  def verify_current_seat_is_valid(players, seat)
+    seat_list = players.map(&:seat)
+    if !seat_list.include?(seat)
+      raise Dry::Types::ConstraintError::new(
+        "The seat whose turn it is not in the player list (#{seat_list})", seat)
+    end
+  end
+end.new
+
+SpyAlleyApplication::Types::GameBoard = Types::Constructor(Class){|value| i.call(value)}
+

data/lib/spy_alley_application/types/game_state.rb

@@ -0,0 +1,19 @@
+# frozen string literal: true
+
+require 'spy_alley_application/models/game_state/buy_equipment'
+require 'spy_alley_application/models/game_state/choose_new_spy_identity'
+require 'spy_alley_application/models/game_state/confiscate_materials'
+require 'spy_alley_application/models/game_state/game_over'
+require 'spy_alley_application/models/game_state/move_option'
+require 'spy_alley_application/models/game_state/spy_eliminator'
+require 'spy_alley_application/models/game_state/start_of_turn'
+
+SpyAlleyApplication::Types::GameState =
+  SpyAlleyApplication::Models::GameState::BuyEquipment |
+  SpyAlleyApplication::Models::GameState::ChooseNewSpyIdentity |
+  SpyAlleyApplication::Models::GameState::ConfiscateMaterials |
+  SpyAlleyApplication::Models::GameState::GameOver |
+  SpyAlleyApplication::Models::GameState::MoveOption |
+  SpyAlleyApplication::Models::GameState::SpyEliminator |
+  SpyAlleyApplication::Models::GameState::StartOfTurn
+

data/lib/spy_alley_application/types/move_card.rb

@@ -0,0 +1,21 @@
+# frozen string_literal: true
+
+require 'dry-types'
+require 'spy_alley_application/models/move_card'
+require 'spy_alley_application/types/coercible_integer_one_to_six'
+
+get_move_card = Hash.new{|h, k| h[k] = SpyAlleyApplication::Models::MoveCard::new(value: k)}
+
+i = Class.new do
+  def initialize(get_move_card)
+    @get_move_card = get_move_card
+  end
+
+  def call(value)
+    value = SpyAlleyApplication::Types::CoercibleIntegerOneToSix.call(value)
+    @get_move_card[value]
+  end
+end.new(get_move_card)
+
+SpyAlleyApplication::Types::MoveCard = ::Types::Constructor(Class){|value| i.call(value)}
+