spy_alley_application 0.3.0

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

@@ -0,0 +1,23 @@
+# frozen string_literal: true
+
+require 'dry-initializer'
+require 'spy_alley_application/types/game_board'
+
+module SpyAlleyApplication
+  module Models
+    class GameBoard < Dry::Struct
+      class EmbassyVictory
+        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)}
+
+          game_state = {name: 'game_over', reason: {name: 'by_embassy'}, seat: player.seat}
+
+          SpyAlleyApplication::Types::GameBoard.call(
+            game_board.to_h.tap{|g| g[:game_state] = game_state})
+        end
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,42 @@
+# frozen string_literal: true
+
+require 'dry-initializer'
+require 'dry-struct'
+require 'spy_alley_application/types/equipment'
+require 'spy_alley_application/types/game_board'
+
+module SpyAlleyApplication
+  module Models
+    class GameBoard < Dry::Struct
+      class EquipmentBought
+        include Dry::Initializer.define -> do
+          option :equipment_cost,
+            default: ->{{password: 1, disguise: 5, codebook: 15, key: 30}},
+            type: ::Types::Hash.schema(
+              password: ::Types::CoercibleNonnegativeInteger,
+              disguise: ::Types::CoercibleNonnegativeInteger,
+              codebook: ::Types::CoercibleNonnegativeInteger,
+              key: ::Types::CoercibleNonnegativeInteger)
+        end
+
+        def call(game_board:, equipment_bought:)
+          player = game_board.current_player
+          total_cost = 0
+          equipment_bought = equipment_bought
+            .map{|equipment| SpyAlleyApplication::Types::Equipment.call(equipment)}
+          equipment_bought.each{|equipment| total_cost += equipment_cost[equipment.type.to_sym]}
+
+          unaffected_players = game_board.players.reject{|p| p.equal?(player)}
+          player = player.to_h.tap do |p|
+            p[:equipment] = (p[:equipment] + equipment_bought).sort
+            p[:money] = p[:money] - total_cost
+          end
+          players = unaffected_players.push(player).sort_by{|p| p[:seat]}
+          SpyAlleyApplication::Types::GameBoard.call(
+            game_board.to_h.tap{|g| g[:players] = players})
+        end
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,67 @@
+# frozen string_literal: true
+
+require 'dry-initializer'
+require 'dry-struct'
+require 'spy_alley_application/types/game_board'
+
+module SpyAlleyApplication
+  module Models
+    class GameBoard < Dry::Struct
+      class EquipmentConfiscated
+        include Dry::Initializer.define -> do
+          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:, target_player:, equipment:)
+          player = game_board.current_player
+          unaffected_players = game_board
+            .players
+            .reject{|player| [player, target_player].include?(player)}
+          wild_card = equipment.accept(self).eql?(:wild_card)
+          cost = equipment_cost[equipment.accept(self)]
+
+          player_equipment = player.equipment.map(&:itself)
+          player_equipment = (player_equipment + [equipment]).sort unless wild_card
+          target_equipment = target_player.equipment.map(&:itself)
+          target_equipment = (target_equipment - [equipment]).sort unless wild_card
+
+          player = player.to_h
+          player[:money] -= cost
+          player[:equipment] = player_equipment.freeze
+          player[:wild_cards] += 1 if wild_card
+
+          target = target_player.to_h
+          target[:money] += cost
+          target[:equipment] = target_equipment.freeze
+          target[:wild_cards] -= 1 if wild_card
+
+          players = unaffected_players
+            .push(player)
+            .push(target)
+            .sort_by{|p| p[:seat]}
+            .freeze
+
+          SpyAlleyApplication::Types::GameBoard.call(
+            game_board.to_h.tap{|g| g[:players] = players})
+        end
+
+        def handle_equipment(equipment, **args)
+          equipment.type.to_sym
+        end
+
+        def handle_wild_card(*args)
+          :wild_card
+        end
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,39 @@
+# frozen string_literal: true
+
+require 'dry-struct'
+require 'spy_alley_application/types/game_board'
+
+module SpyAlleyApplication
+  module Models
+    class GameBoard < Dry::Struct
+      class FreeGiftDrawn
+        def call(game_board:)
+          player = game_board.players.find{|p| p.seat.eql?(game_board.game_state.seat)}
+          unaffected_players = game_board.players.reject{|p| p.equal?(player)}
+          free_gift_pile = game_board.free_gift_pile
+          top_free_gift = free_gift_pile.first
+          if top_free_gift.wild_card?
+            player = player.to_h.tap{|p| p[:wild_cards] += 1}.to_h
+            free_gift_pile = free_gift_pile[1..-1]
+          else
+            player = add_equipment(player, top_free_gift)
+            free_gift_pile = free_gift_pile[1..-1].push(top_free_gift).freeze
+          end
+          players = unaffected_players.push(player).sort{|p, q| p[:seat] <=> q[:seat]}
+          SpyAlleyApplication::Types::GameBoard.call(
+            game_board.to_h.tap{|g| g[:players] = players; g[:free_gift_pile] = free_gift_pile})
+        end
+
+        private
+        def add_equipment(player, equipment)
+          if player.equipment.none?{|e| e.equal?(equipment)}
+            player.to_h.tap{|p| p[:equipment] = p[:equipment].push(equipment).sort}
+          else
+            player
+          end
+        end
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,22 @@
+# frozen string_literal: true
+
+require 'dry-struct'
+require 'spy_alley_application/types/game_board'
+
+module SpyAlleyApplication
+  module Models
+    class GameBoard < Dry::Struct
+      class MoneyGainedOrLost
+        def call(game_board:, money_adjustment:)
+          player = game_board.players.find{|p| p.seat.eql?(game_board.game_state.seat)}
+          unaffected_players = game_board.players.reject{|p| p.equal?(player)}
+          player = player.to_h.tap{|p| p[:money] = p[:money] + money_adjustment}
+          players = unaffected_players.push(player).sort{|p, q| p[:seat] <=> q[:seat]}
+          SpyAlleyApplication::Types::GameBoard.call(
+            game_board.to_h.tap{|g| g[:players] = players})
+        end
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,31 @@
+# frozen string_literal: true
+
+require 'dry-initializer'
+require 'dry-struct'
+require 'spy_alley_application/types/game_board'
+
+module SpyAlleyApplication
+  module Models
+    class GameBoard < Dry::Struct
+      class MoveCardDrawn
+        def call(game_board:)
+          player = game_board.current_player
+          unaffected_players = game_board.players.reject{|p| p.equal?(player)}
+          move_card_pile = game_board.move_card_pile
+          # put the first card in the player's move card hand
+          player = player.to_h.tap do |p|
+            move_cards = (p[:move_cards] + [move_card_pile.first.value]).sort
+            p[:move_cards] = move_cards
+          end
+          # and remove it from the move card pile
+          move_card_pile = move_card_pile[1..-1].freeze
+          players = unaffected_players.push(player).sort{|p, q| p[:seat] <=> q[:seat]}
+
+          SpyAlleyApplication::Types::GameBoard.call(
+            game_board.to_h.tap{|g| g[:players] = players; g[:move_card_pile] = move_card_pile})
+        end
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,30 @@
+# frozen string_literal: true
+
+require 'dry-struct'
+require 'spy_alley_application/types/game_board'
+
+module SpyAlleyApplication
+  module Models
+    class GameBoard < Dry::Struct
+      class MoveCardUsed
+        def call(game_board:, move_card_used:)
+          player = game_board.current_player
+          unaffected_players = game_board.players.reject{|p| p.equal?(player)}
+          move_card_pile = game_board.move_card_pile
+          # remove one copyof the move_card_used from the player's move card hand
+          player = player.to_h.tap do |p|
+            p[:move_cards].delete_at(p[:move_cards].index(move_card_used))
+            p[:move_cards] = p[:move_cards].sort
+          end
+          # and place at the bottom (end) of the move card pile
+          move_card_pile = (move_card_pile + [move_card_used]).freeze
+          players = unaffected_players.push(player).sort{|p, q| p[:seat] <=> q[:seat]}
+
+          SpyAlleyApplication::Types::GameBoard.call(
+            game_board.to_h.tap{|g| g[:players] = players; g[:move_card_pile] = move_card_pile})
+        end
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,23 @@
+# frozen string_literal: true
+
+require 'dry-struct'
+require 'spy_alley_application/types/game_board'
+
+module SpyAlleyApplication
+  module Models
+    class GameBoard < Dry::Struct
+      class MoveOptions
+        def call(game_board:, options:)
+          game_state = {
+            name: 'move_option',
+            seat: game_board.game_state.seat,
+            options: options
+          }
+          SpyAlleyApplication::Types::GameBoard.call(
+            game_board.to_h.tap{|g| g[:game_state] = game_state})
+        end
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,37 @@
+# frozen string_literal: true
+
+require 'dry-initializer'
+require 'dry-struct'
+require 'spy_alley_application/types/game_board'
+
+module SpyAlleyApplication
+  module Models
+    class GameBoard < Dry::Struct
+      class NewSpyIdentityChosen
+        def call(game_board:, new_spy_identity:)
+          player = game_board.current_player
+          if !player.spy_identity.eql?(new_spy_identity)
+            eliminated_player = game_board.players.find{|p| p.spy_identity.eql?(new_spy_identity)}
+            unaffected_players = game_board
+              .players
+              .reject{|p| [player, eliminated_player].include?(p)}
+
+            eliminated_player =
+              eliminated_player.to_h.tap{|p| p[:spy_identity] = player.spy_identity}
+            player = player.to_h.tap{|p| p[:spy_identity] = new_spy_identity}
+
+            players = unaffected_players
+            players.push(player)
+            players.push(eliminated_player)
+            players = players.sort_by{|p| p[:seat]}
+
+            game_board = SpyAlleyApplication::Types::GameBoard.call(
+              game_board.to_h.tap{|b| b[:players] = players})
+          end
+          game_board
+        end
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,70 @@
+# frozen string_literal: true
+
+require 'dry-struct'
+require 'spy_alley_application/models/game_board'
+require 'spy_alley_application/types/game_state'
+
+module SpyAlleyApplication
+  module Models
+    class GameBoard < Dry::Struct
+      class NextGameState
+        def call(game_board:, target_player_id: nil)
+          args = {game_board: game_board}
+          args[:target_player_id] = target_player_id if target_player_id
+          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: game_board.game_state.accept(self, args))
+        end
+
+        def handle_start_of_turn(node, game_board:)
+          all_seats = game_board
+            .players
+            .select(&:active?)
+            .map(&:seat)
+            .reject{|seat| seat.eql?(node.seat)}
+
+          next_seat = all_seats.select{|seat| seat > node.seat}.min || all_seats.min
+
+          SpyAlleyApplication::Types::GameState.call(
+            name: 'start_of_turn',
+            seat: next_seat)
+        end
+        alias_method :handle_buy_equipment, :handle_start_of_turn
+        alias_method :handle_move_action, :handle_start_of_turn
+        alias_method :handle_confiscate_materials, :handle_start_of_turn
+
+        def handle_choose_new_spy_identity(node, game_board:)
+          node.parent.accept(self, game_board: game_board)
+        end
+
+        def handle_spy_eliminator(node, game_board:, target_player_id: nil)
+          targeted_player_id = game_board
+            .players
+            .map(&:id)
+            .select{|id| id.eql?(target_player_id)}
+
+          remaining_seats = game_board
+            .players
+            .select(&:active?)
+            .reject{|p| p.id.eql?(target_player_id)}
+            .map(&:seat)
+            .select{|seat| node.targetable_seats.include?(seat)}
+            .sort
+
+          if remaining_seats.empty?
+            node.parent.accept(self, game_board: game_board)
+          else
+            SpyAlleyApplication::Types::GameState.call(
+              name: 'spy_eliminator',
+              seat: node.seat,
+              targetable_seats: remaining_seats,
+              parent: node.parent)
+          end
+        end
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,24 @@
+# frozen string_literal: true
+
+require 'dry-struct'
+require 'spy_alley_application/types/game_board'
+
+module SpyAlleyApplication
+  module Models
+    class GameBoard < Dry::Struct
+      class PlayerMoved
+        def call(game_board:, new_location:)
+          player = game_board.players.find{|p| p.seat.eql?(game_board.game_state.seat)}
+          unaffected_players = game_board.players.reject{|p| p.equal?(player)}
+          player = player.to_h.tap{|p| p[:location] = new_location}
+          players = unaffected_players.push(player).sort{|p, q| p[:seat] <=> q[:seat]}
+          game_board = SpyAlleyApplication::Types::GameBoard.call(
+            game_board.to_h.tap{|g| g[:players] = players})
+          game_board = yield(game_board: game_board) if block_given?
+          game_board
+        end
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,41 @@
+# frozen string_literal: true
+
+require 'dry-initializer'
+require 'dry-struct'
+require 'spy_alley_application/types/game_board'
+
+module SpyAlleyApplication
+  module Models
+    class GameBoard < Dry::Struct
+      class SpyEliminatorOptions
+        include Dry::Initializer.define -> do
+          option :next_game_state, type: ::Types::Callable, reader: :private
+        end
+
+        def call(game_board:)
+          player = game_board.players.find{|p| p.seat.eql?(game_board.game_state.seat)}
+          targetable_seats = game_board.players
+            .select(&:in_spy_alley?)
+            .reject{|p| p.equal?(player)}
+            .map(&:seat)
+            .sort
+            .freeze
+
+          if targetable_seats.empty?
+            return next_game_state.(game_board: game_board)
+          end
+
+          game_state = {
+            name: 'spy_eliminator',
+            seat: game_board.game_state.seat,
+            targetable_seats: targetable_seats,
+            parent: game_board.game_state
+          }
+          SpyAlleyApplication::Types::GameBoard.call(
+            game_board.to_h.tap{|g| g[:game_state] = game_state})
+        end
+      end
+    end
+  end
+end
+