spy_alley_application 0.3.0

data/lib/spy_alley_application/models/board_spaces/start.rb

@@ -0,0 +1,36 @@
+# frozen string_literal: true
+
+require 'dry-struct'
+require 'spy_alley_application/types/board_space'
+
+module SpyAlleyApplication
+  module Models
+    module BoardSpaces
+      class Start < Dry::Struct
+        @@can_handle_start = ::Types.Interface(:handle_start)
+        def self.new(id:, next_space: nil, &block)
+          o = Start.allocate
+          next_space ||= yield(o)
+          o.send(:initialize, **{id: id, next_space: next_space})
+          o
+        end
+
+        def initialize(id:, next_space: nil, &block)
+          @id = ::Types::Coercible::Integer.call(id)
+          @next_space = SpyAlleyApplication::Types::BoardSpace.call(next_space)
+        end
+
+        def id;@id;end
+        def next_space;@next_space;end
+        def in_spy_alley?;false;end
+        def to_h;{id: id};end
+
+        def accept(visitor, **args)
+          @@can_handle_start.(visitor)
+          visitor.handle_start(self, args)
+        end
+      end
+    end
+  end
+end
+

data/lib/spy_alley_application/models/board_spaces/take_another_turn.rb

@@ -0,0 +1,24 @@
+# frozen string_literal: true
+
+require 'dry-struct'
+require 'spy_alley_application/types/board_space'
+
+module SpyAlleyApplication
+  module Models
+    module BoardSpaces
+      class TakeAnotherTurn < Dry::Struct
+        @@can_handle_take_another_turn = ::Types.Interface(:handle_take_another_turn)
+        attribute :id, ::Types::Coercible::Integer
+        attribute :next_space, ::SpyAlleyApplication::Types::BoardSpace
+
+        def accept(visitor, **args)
+          @@can_handle_take_another_turn.(visitor)
+          visitor.handle_take_another_turn(self, args)
+        end
+
+        def in_spy_alley?;false;end
+      end
+    end
+  end
+end
+

data/lib/spy_alley_application/models/equipment.rb

@@ -0,0 +1,42 @@
+# frozen string literal: true
+
+require 'dry-struct'
+require 'spy_alley_application/types/equipment_type'
+require 'spy_alley_application/types/nationality'
+
+module SpyAlleyApplication
+  module Models
+    class Equipment < Dry::Struct
+      @@can_handle_equipment = ::Types.Interface(:handle_equipment)
+
+      attribute :nationality, SpyAlleyApplication::Types::Nationality
+      attribute :type, SpyAlleyApplication::Types::EquipmentType
+
+      def accept(visitor, **args)
+        @@can_handle_equipment.(visitor)
+        visitor.handle_equipment(self, args)
+      end
+
+      def wild_card?
+        false
+      end
+
+      def to_h
+        self
+      end
+
+      def to_s
+        "#{nationality} #{type}"
+      end
+      alias_method :transform_values, :to_s
+
+      def <=>(other)
+        return nil if !other.is_a?(self.class)
+        result = self.nationality <=> other.nationality
+        result = self.type <=> other.type if result.eql?(0)
+        result
+      end
+    end
+  end
+end
+

data/lib/spy_alley_application/models/game_board.rb

@@ -0,0 +1,23 @@
+# frozen string_literal: true
+
+require 'dry-struct'
+require 'spy_alley_application/types/array_of_players'
+require 'spy_alley_application/types/array_of_free_gifts'
+require 'spy_alley_application/types/array_of_move_cards'
+require 'spy_alley_application/types/game_state'
+
+module SpyAlleyApplication
+  module Models
+    class GameBoard < Dry::Struct
+      attribute :players, Types::ArrayOfPlayers
+      attribute :move_card_pile, Types::ArrayOfMoveCards
+      attribute :free_gift_pile, Types::ArrayOfFreeGifts
+      attribute :game_state, Types::GameState
+
+      def current_player
+        players.find{|p| p.seat.eql?(game_state.seat)}
+      end
+    end
+  end
+end
+

data/lib/spy_alley_application/models/game_board/black_market_option_state.rb

@@ -0,0 +1,59 @@
+# frozen string_literal: true
+
+require 'dry-initializer'
+require 'dry-struct'
+require 'spy_alley_application/models/game_board'
+require 'spy_alley_application/types/equipment'
+require 'spy_alley_application/types/equipment_type'
+require 'spy_alley_application/types/game_state'
+require 'spy_alley_application/types/nationality'
+
+module SpyAlleyApplication
+  module Models
+    class GameBoard < Dry::Struct
+      class BlackMarketOptionState
+        include Dry::Initializer.define -> do
+          option :next_game_state, type: ::Types::Callable, reader: :private
+          option :equipment_cost,
+            default: ->{{password: 1, disguise: 5, codebook: 15, key: 30}},
+            reader: :private,
+            type: ::Types::Hash.schema(
+              password: ::Types::CoercibleNonnegativeInteger,
+              disguise: ::Types::CoercibleNonnegativeInteger,
+              codebook: ::Types::CoercibleNonnegativeInteger,
+              key: ::Types::CoercibleNonnegativeInteger)
+        end
+
+        def call(game_board:)
+          player = game_board.players.find{|p| p.seat.eql?(game_board.game_state.seat)}
+          affordable_equipment = SpyAlleyApplication::Types::EquipmentType.values.select do |t|
+            player.money >= equipment_cost[t.to_sym]
+          end
+
+          equipment = affordable_equipment.map do |equipment_type|
+            SpyAlleyApplication::Types::Nationality.values.map do |nationality|
+              SpyAlleyApplication::Types::Equipment.call("#{nationality} #{equipment_type}")
+            end
+          end.flatten.sort.freeze
+
+          options = equipment - player.equipment
+
+          # only give buy option if player both has enough money and does not already all equipment
+          if options.empty?
+            return next_game_state.(game_board: game_board)
+          end
+          SpyAlleyApplication::Models::GameBoard::new(
+            players: game_board.players,
+            move_card_pile: game_board.move_card_pile,
+            free_gift_pile: game_board.free_gift_pile,
+            game_state: SpyAlleyApplication::Types::GameState.call(
+              name: 'buy_equipment',
+              seat: game_board.game_state.seat,
+              options: options,
+              limit: 1))
+        end
+      end
+    end
+  end
+end
+

data/lib/spy_alley_application/models/game_board/buy_equipment_option_state.rb

@@ -0,0 +1,52 @@
+# frozen string_literal: true
+
+require 'dry-initializer'
+require 'dry-struct'
+require 'spy_alley_application/models/game_board'
+require 'spy_alley_application/types/equipment'
+require 'spy_alley_application/types/game_state'
+require 'spy_alley_application/types/nationality'
+
+module SpyAlleyApplication
+  module Models
+    class GameBoard < Dry::Struct
+      class BuyEquipmentOptionState
+        include Dry::Initializer.define -> do
+          option :next_game_state, type: ::Types::Callable, reader: :private
+          option :equipment_cost,
+            default: ->{{disguise: 5, codebook: 15, key: 30}},
+            reader: :private,
+            type: ::Types::Hash.schema(
+              disguise: ::Types::CoercibleNonnegativeInteger,
+              codebook: ::Types::CoercibleNonnegativeInteger,
+              key: ::Types::CoercibleNonnegativeInteger)
+        end
+
+        def call(game_board:, equipment_type:)
+          player = game_board.current_player
+          unit_cost = equipment_cost[equipment_type.to_sym]
+          equipment = SpyAlleyApplication::Types::Nationality.values.map do |nationality|
+            SpyAlleyApplication::Types::Equipment.call("#{nationality} #{equipment_type}")
+          end
+          options = (equipment - player.equipment).sort.freeze
+          limit = [player.money / unit_cost, options.length].min
+
+          # only give buy option if player both has enough money and does not already all equipment
+          if limit.eql?(0)
+            return next_game_state.(game_board: game_board)
+          end
+          SpyAlleyApplication::Models::GameBoard::new(
+            players: game_board.players,
+            move_card_pile: game_board.move_card_pile,
+            free_gift_pile: game_board.free_gift_pile,
+            game_state: SpyAlleyApplication::Types::GameState.call(
+              name: 'buy_equipment',
+              seat: game_board.game_state.seat,
+              options: options,
+              limit: limit))
+        end
+      end
+    end
+  end
+end
+

data/lib/spy_alley_application/models/game_board/buy_password_option_state.rb

@@ -0,0 +1,39 @@
+# frozen string_literal: true
+
+require 'dry-struct'
+require 'spy_alley_application/models/game_board'
+require 'spy_alley_application/types/equipment'
+require 'spy_alley_application/types/game_state'
+
+module SpyAlleyApplication
+  module Models
+    class GameBoard < Dry::Struct
+      class BuyPasswordOptionState
+        include Dry::Initializer.define -> do
+          option :next_game_state, type: ::Types::Callable, reader: :private
+          option :password_cost, type: ::Types::CoercibleNonnegativeInteger, reader: :private,
+            default: ->{1}
+        end
+
+        def call(game_board:, nationality:)
+          equipment_to_add = SpyAlleyApplication::Types::Equipment.call("#{nationality} password")
+          player = game_board.players.find{|p| p.seat.eql?(game_board.game_state.seat)}
+          # only give buy option if player both has money and does not already have the password
+          if player.money < password_cost || player.equipment.any?{|e| e.eql?(equipment_to_add)}
+            return next_game_state.(game_board: game_board)
+          end
+          SpyAlleyApplication::Models::GameBoard::new(
+            players: game_board.players,
+            move_card_pile: game_board.move_card_pile,
+            free_gift_pile: game_board.free_gift_pile,
+            game_state: SpyAlleyApplication::Types::GameState.call(
+              name: 'buy_equipment',
+              seat: game_board.game_state.seat,
+              options: [equipment_to_add],
+              limit: 1))
+        end
+      end
+    end
+  end
+end
+

data/lib/spy_alley_application/models/game_board/confiscate_materials_option_state.rb

@@ -0,0 +1,68 @@
+# frozen string_literal: true
+
+require 'dry-initializer'
+require 'dry-struct'
+require 'spy_alley_application/models/game_board'
+require 'spy_alley_application/types/equipment'
+require 'spy_alley_application/types/equipment_type'
+require 'spy_alley_application/types/game_state'
+require 'spy_alley_application/types/nationality'
+
+module SpyAlleyApplication
+  module Models
+    class GameBoard < Dry::Struct
+      class ConfiscateMaterialsOptionState
+        include Dry::Initializer.define -> do
+          option :next_game_state, type: ::Types::Callable, reader: :private
+          option :equipment_cost,
+            default: ->{{password: 5, disguise: 5, codebook: 10, key: 25, wild_card: 50}},
+            reader: :private,
+            type: ::Types::Hash.schema(
+              password: ::Types::CoercibleNonnegativeInteger,
+              disguise: ::Types::CoercibleNonnegativeInteger,
+              codebook: ::Types::CoercibleNonnegativeInteger,
+              key: ::Types::CoercibleNonnegativeInteger,
+              wild_card: ::Types::CoercibleNonnegativeInteger)
+        end
+
+        def call(game_board:)
+          player = game_board.players.find{|p| p.seat.eql?(game_board.game_state.seat)}
+          other_players = game_board.players.reject{|p| p.seat.eql?(game_board.game_state.seat)}
+
+          affordable_types = SpyAlleyApplication::Types::EquipmentType.values.select do |t|
+            player.money >= equipment_cost[t.to_sym]
+          end
+          can_afford_wild_card = (player.money > equipment_cost[:wild_card])
+
+          all_affordable_equipment = affordable_types.map do |equipment_type|
+            SpyAlleyApplication::Types::Nationality.values.map do |nationality|
+              SpyAlleyApplication::Types::Equipment.call("#{nationality} #{equipment_type}")
+            end
+          end.flatten.sort
+
+          targets = other_players.map do |p|
+            equipment = all_affordable_equipment.select{|e| p.equipment.include?(e)}
+            equipment.push('wild card') if p.wild_cards > 0 && can_afford_wild_card
+            [p.seat, equipment.freeze]
+          end.reject{|seat, equipment| equipment.empty?}.map do |seat, equipment|
+            {seat: seat, equipment: equipment}
+          end.freeze
+
+          # only give confiscation option if there are targets
+          if targets.empty?
+            return next_game_state.(game_board: game_board)
+          end
+          SpyAlleyApplication::Models::GameBoard::new(
+            players: game_board.players,
+            move_card_pile: game_board.move_card_pile,
+            free_gift_pile: game_board.free_gift_pile,
+            game_state: SpyAlleyApplication::Types::GameState.call(
+              name: 'confiscate_materials',
+              seat: game_board.game_state.seat,
+              targets: targets))
+        end
+      end
+    end
+  end
+end
+

data/lib/spy_alley_application/models/game_board/eliminate_player.rb

@@ -0,0 +1,91 @@
+# frozen string_literal: true
+
+require 'dry-initializer'
+require 'dry-struct'
+require 'spy_alley_application/models/game_board'
+require 'spy_alley_application/types/equipment'
+require 'spy_alley_application/types/game_state'
+
+module SpyAlleyApplication
+  module Models
+    class GameBoard < Dry::Struct
+      class EliminatePlayer
+        def call(game_board:, eliminating_player:, eliminated_player:)
+          unaffected_players = game_board
+            .players
+            .reject{|player| [eliminating_player, eliminated_player].include?(player)}
+
+          game_state = get_game_state(unaffected_players, eliminating_player)
+
+          eliminating_player = get_eliminating_player(eliminating_player, eliminated_player)
+
+          eliminated_player = get_eliminated_player(eliminated_player)
+
+          players = unaffected_players
+            .push(eliminating_player)
+            .push(eliminated_player)
+            .sort{|p, q| p.seat <=> q.seat}
+            .freeze
+
+          get_new_game_board(game_board, players, game_state)
+        end
+
+        private
+        def get_game_state(unaffected_players, eliminating_player)
+          # If none of the other players are in the game, then the game must be over
+          if unaffected_players.none?(&:active?)
+            {name: 'game_over', reason: {name: 'by_elimination'}, seat: eliminating_player.seat}
+          else
+            {
+              name: 'choose_new_spy_identity',
+              seat: eliminating_player.seat,
+              options: [eliminating_player.spy_identity, eliminated_player.spy_identity].freeze,
+              parent: game_board.game_state
+            }
+          end
+        end
+
+        def get_eliminating_player(eliminating_player, eliminated_player)
+          new_equipment = eliminating_player.equipment.map(&:to_s)
+          new_equipment = new_equipment + (eliminated_player.equipment.map(&:to_s))
+          new_equipment = new_equipment.uniq.sort
+          new_move_cards = eliminating_player.move_cards.map(&:value)
+          new_move_cards = new_move_cards + (eliminated_player.move_cards.map(&:value))
+          new_move_cards = new_move_cards.sort
+          new_money = eliminating_player.money + eliminated_player.money
+          new_wild_cards = eliminating_player.wild_cards + eliminated_player.wild_cards
+
+          new_values = eliminating_player.to_h
+          new_values[:equipment] = new_equipment
+          new_values[:money] = new_money
+          new_values[:move_cards] = new_move_cards
+          new_values[:wild_cards] = new_wild_cards
+
+          SpyAlleyApplication::Types::Player.call(new_values)
+        end
+
+        def get_eliminated_player(eliminated_player)
+          SpyAlleyApplication::Types::Player.call(
+            id: eliminated_player.id,
+            seat: eliminated_player.seat,
+            location: eliminated_player.location,
+            spy_identity: eliminated_player.spy_identity,
+            money: 0,
+            move_cards: [].freeze,
+            equipment: [].freeze,
+            wild_cards: 0,
+            active?: false)
+        end
+
+        def get_new_game_board(game_board, players, game_state)
+          SpyAlleyApplication::Models::GameBoard::new(
+            players: players,
+            move_card_pile: game_board.move_card_pile,
+            free_gift_pile: game_board.free_gift_pile,
+            game_state: game_state)
+        end
+      end
+    end
+  end
+end
+