hlockey 4 → 5

data/data/previous_election_results.yaml

@@ -1,59 +1,65 @@
 ---
-:vote_amt: 182
+:vote_amt: 239
 :categories:
-  :Bribery (77 votes):
+  :Bribery (73 votes):
     :Winning bribe:
-      :winner: Flavor Text (39 votes)
-  :Treasure (65 votes):
-    :Vengabus:
-      :winner: Pompei Eruptions (1 vote / 16 total)
-      :most_votes: Stony Brook Reapers (4 votes)
+      :winner: Stadiums (42 votes)
+  :Treasure (124 votes):
     :Dave:
-      :winner: Orcadas Base Fog (1 vote / 29 total)
-      :most_votes: Pompei Eruptions (9 votes)
+      :winner: Dawson City Impostors (16 votes / 38 total)
     :Nice:
-      :winner: Kópavogur Seals (1 vote / 15 total)
-      :most_votes: Pica Acid (3 votes)
-    :Convenient Math Error:
-      :winner: Jakarta Architects (1 vote / 5 total)
-  :Coaching (40 votes):
+      :winner: Nice Backflippers (7 votes / 15 total)
+    :Vengabus:
+      :winner: Kyoto Payphones (1 vote / 46 total)
+      :most_votes: Sydney Thinkers (31 votes)
+    :Unvengabus:
+      :winner: Antalya Pirates (Wet Warm) (0 votes / 0 total)
+    :Shared Training:
+      :winner: Antalya Pirates (Wet Warm) (2 votes / 20 total)
+      :most_votes: Orcadas Base Fog (5 votes)
+    :Theft:
+      :winner: Manbij Fish (1 vote / 5 total)
+      :most_votes: Pica Acid (2 votes)
+    :Hidden Treasure - Evolve:
+      :winner: Sleepersz (0 votes / 0 total)
+  :Coaching (42 votes):
     :Antalya Pirates:
-      :winner: Please Win Faceoffs (1 vote / 1 total)
+      :winner: Please Block Shots (3 votes / 3 total)
     :Baden Hallucinations:
-      :winner: Small Gamble (1 vote / 2 total)
+      :winner: Clock Unwise (1 vote / 1 total)
     :Kópavogur Seals:
-      :winner: Please Block Shots (1 vote / 4 total)
+      :winner: Big Gamble (0 votes / 0 total)
     :Lagos Soup:
-      :winner: Big Gamble (4 votes / 8 total)
+      :winner: Please Win Faceoffs (1 vote / 1 total)
     :Pica Acid:
-      :winner: Please Block Shots (1 vote / 2 total)
+      :winner: Big Gamble (0 votes / 0 total)
     :Dawson City Impostors:
-      :winner: Please Win Faceoffs (3 votes / 5 total)
+      :winner: Draft (2 votes / 3 total)
     :Erlangen Ohms:
-      :winner: Draft (1 vote / 1 total)
+      :winner: Please Win Faceoffs (2 votes / 2 total)
     :Pompei Eruptions:
-      :winner: Please Block Shots (1 vote / 1 total)
+      :winner: Please Win Faceoffs (2 votes / 2 total)
     :Rio de Janeiro Directors:
-      :winner: Please Block Shots (1 vote / 1 total)
+      :winner: Clock Wise (1 vote / 1 total)
     :Wyrzysk Rockets:
-      :winner: Please Win Faceoffs (1 vote / 1 total)
+      :winner: Please Win Faceoffs (0 votes / 0 total)
     :Cape Town Transplants:
-      :winner: Small Gamble (1 vote / 1 total)
+      :winner: Please Block Shots (1 vote / 2 total)
     :Manbij Fish:
-      :winner: Big Gamble (0 votes / 0 total)
+      :winner: Please Block Shots (1 vote / 2 total)
     :Nagqu Paint:
-      :winner: Pleaase Win Faceoffs (1 vote / 1 total)
+      :winner: Revolution (1 vote / 1 total)
     :Nice Backflippers:
-      :winner: Draft (1 vote / 1 total)
+      :winner: Please Block Shots (7 votes / 7 total)
     :Orcadas Base Fog:
-      :winner: Big Gamble (1 vote / 1 total)
+      :winner: Please Win Faceoffs (2 votes / 2 total)
     :Baghdad Abacuses:
-      :winner: Small Gamble (0 votes / 0 total)
+      :winner: Please Win Faceoffs (0 votes / 0 total)
     :Jakarta Architects:
-      :winner: Big Gamble (1 vote / 1 total)
+      :winner: Big Gamble (0 votes / 0 total)
     :Kyoto Payphones:
-      :winner: Please Win Faceoffs (1 vote / 2 total)
+      :winner: Clock Unwise (3 votes / 5 total)
     :Stony Brook Reapers:
-      :winner: Draft (5 votes / 7 total)
+      :winner: Please Block Shots (1 vote / 2 total)
     :Sydney Thinkers:
-      :winner: Please Block Shots (1 vote / 1 total)
+      :winner: Draft (6 votes / 7 total)

data/lib/hlockey/constants.rb

@@ -1,4 +1,10 @@
 module Hlockey
   UPDATE_FREQUENCY_SECONDS = 5
   UPDATES_PER_HOUR = 3600 / UPDATE_FREQUENCY_SECONDS
+
+  ACTIONS_PER_PERIOD = 60
+  NON_OT_PERIODS = 3
+  NON_OT_ACTIONS = ACTIONS_PER_PERIOD * NON_OT_PERIODS
+  TOTAL_ACTIONS = UPDATES_PER_HOUR - ACTIONS_PER_PERIOD
+  TOTAL_PERIODS = TOTAL_ACTIONS / ACTIONS_PER_PERIOD
 end

data/lib/hlockey/data.rb

@@ -1,4 +1,4 @@
-require("hlockey/team") # Class stored in league data
+require("hlockey/team") # Classes stored in league data
 require("yaml")
 
 module Hlockey

data/lib/hlockey/game/actions.rb

@@ -2,19 +2,16 @@ module Hlockey
   class Game
     ##
     # For classes that deal with actions within a Hlockey game.
-    # Any class including this must have instance variables indicated by the readers
     module Actions
-      # @return [Team] the teams in the game
-      attr_reader(:home, :away)
+      private
 
-      # @return [Random] should be the same as the league's
-      attr_reader(:prng)
-
-      # @return [Hash<Symbol => Integer>] the score of each team
-      attr_reader(:score)
-
-      # @return [Boolean] if the sequence of actions is still in progress
-      attr_reader(:in_progress)
+      # For an event that should happen randomly about a certain amount of times per game,
+      # returns if the event should happen or not. Should be called once per action.
+      # @param times [Integer] the approximate amount of times the event should occur
+      # @return [Boolean] if the event should occur
+      def random_event_occurs?(times = 1)
+        @prng.rand(NON_OT_ACTIONS / times).zero?
+      end
 
       # @param succeed_boost [Numeric] increases chance of action succeeding
       # @param fail_boost [Numeric] decreases chance of action succeeding

data/lib/hlockey/game/fight.rb

@@ -11,6 +11,9 @@ module Hlockey
       # @return [Hash<Symbol => Array<Player>>] the players in the fight
       attr_reader(:players)
 
+      # @return [Hash<Symbol => Integer>] the amount of successful punches for each team
+      attr_reader(:score)
+
       # @param game [Game] the game the fight is a part of
       def initialize(game)
         @home = game.home
@@ -22,7 +25,6 @@ module Hlockey
           away: [@away.roster.values.sample(random: @prng)]
         }
         @score = { home: 0, away: 0 }
-        @in_progress = true
       end
 
       # @return [Message] the message to add to the game stream
@@ -46,14 +48,16 @@ module Hlockey
 
           Message.PlayerJoinedFight(send(team_joining), player_joining)
         else # fight ends
-          @in_progress = false
-
           Message.FightEnded
         end
       end
 
       private
 
+      # private readers so #send works
+      # @return [Team] a team in the fight
+      attr_reader(:home, :away)
+
       # @return [Message] returned by #next_action for same purpose
       def attack
         attacking_team = rand_team

data/lib/hlockey/game/weather/audacity.rb

@@ -0,0 +1,20 @@
+require("hlockey/game/weather/weatherable")
+require("hlockey/game/actions")
+
+module Hlockey
+  class Game
+    module Weather
+      ##
+      # Audacity weather
+      # Causes players to take shots regardless of the state of the game
+      class Audacity
+        include(Weatherable)
+        include(Actions)
+
+        def on_action
+          @game.send(:shoot, audacity: true) if random_event_occurs?(10)
+        end
+      end
+    end
+  end
+end

data/lib/hlockey/game/weather/chicken.rb

@@ -0,0 +1,57 @@
+require("hlockey/game/weather/weatherable")
+require("hlockey/game/actions")
+require("hlockey/message")
+
+module Hlockey
+  class Game
+    module Weather
+      ##
+      # Chicken weather
+      # Swaps a random roster player with a random shadow player for the rest of the game
+      class Chicken
+        include(Weatherable)
+        include(Actions)
+
+        def on_game_start
+          @chickened_out = { home: {}, away: {} }
+        end
+
+        def on_action
+          return unless random_event_occurs?(5)
+
+          team = rand_team
+          pos, shadows_idx = get_swap(team)
+          if pos.nil? || shadows_idx.nil?
+            team = team == :home ? :away : :home
+            pos, shadows_idx = get_swap(team)
+            return if pos.nil? || shadows_idx.nil?
+          end
+
+          @chickened_out[team][pos] = shadows_idx
+
+          @game.stream << Message.ChickenedOut(*swap(team, pos, shadows_idx))
+        end
+
+        def on_game_end
+          @chickened_out.each do |team, swaps|
+            swaps.each { |pos, shadows_idx| swap(team, pos, shadows_idx) }
+          end
+        end
+
+        private
+
+        # @param team_sym [:home, :away]
+        # @return [Array<Symbol, Integer>]
+        def get_swap(team_sym)
+          team = @game.send(team_sym)
+
+          [
+            (team.roster.keys - @chickened_out[team_sym].keys).sample(random: @prng),
+            (team.shadows.each_index.to_a - @chickened_out[team_sym].values)
+              .sample(random: @prng)
+          ]
+        end
+      end
+    end
+  end
+end

data/lib/hlockey/game/weather/incline.rb

@@ -0,0 +1,43 @@
+require("hlockey/game/weather/weatherable")
+require("hlockey/message")
+
+module Hlockey
+  class Game
+    module Weather
+      ##
+      # Incline weather
+      # Adds a random amount of score to a favored team's goals
+      class Incline
+        include(Weatherable)
+
+        def on_game_start
+          make_incline
+        end
+
+        def on_goal(scoring_team)
+          return unless scoring_team == @favored_team
+
+          @game.score[scoring_team] += @prng.rand(0.1..0.5)
+          make_incline
+        end
+
+        def on_action
+          return unless @incline_changed
+
+          @game.stream << Message.InclineFavors(@game.send(@favored_team))
+          @incline_changed = false
+        end
+
+        private
+
+        def make_incline
+          new_favored_team = rand_team
+          return if new_favored_team == @favored_team
+
+          @favored_team = new_favored_team
+          @incline_changed = true
+        end
+      end
+    end
+  end
+end

data/lib/hlockey/game/weather/stars.rb

@@ -0,0 +1,23 @@
+require("hlockey/game/weather/weatherable")
+require("hlockey/message")
+
+module Hlockey
+  class Game
+    module Weather
+      ##
+      # Stars weather
+      # Gives the losing team +0.5 score at the end of each period
+      class Stars
+        include(Weatherable)
+
+        def on_period_end
+          return if @game.score[:home] == @game.score[:away]
+
+          team = @game.score.min_by { |_, v| v }.first
+          @game.score[team] += 0.5
+          @game.stream << Message.StarsAlign(@game.send(team))
+        end
+      end
+    end
+  end
+end

data/lib/hlockey/game/weather/sunset.rb

@@ -0,0 +1,23 @@
+require("hlockey/game/weather/weatherable")
+
+module Hlockey
+  class Game
+    module Weather
+      ##
+      # Sunset weather
+      # Makes each team's goals worth less the more the team scores
+      class Sunset
+        include(Weatherable)
+
+        def on_game_start
+          @score_amt = { home: 0, away: 0 }
+        end
+
+        def on_goal(scoring_team)
+          @score_amt[scoring_team] += 1
+          @game.score[scoring_team] -= @score_amt[scoring_team] * 0.2
+        end
+      end
+    end
+  end
+end

data/lib/hlockey/game/weather/waves.rb

@@ -0,0 +1,27 @@
+require("hlockey/game/weather/weatherable")
+require("hlockey/game/actions")
+require("hlockey/message")
+
+module Hlockey
+  class Game
+    module Weather
+      ##
+      # Waves weather
+      # Swaps the worst roster player with a random shadow player permanently
+      class Waves
+        include(Weatherable)
+        include(Actions)
+
+        def on_action
+          return unless random_event_occurs?
+
+          team_sym = rand_team
+          team = @game.send(team_sym)
+          @game.stream << Message.WavesWashedAway(*swap(team_sym,
+                                                        team.worst_player_pos,
+                                                        @prng.rand(team.shadows.length)))
+        end
+      end
+    end
+  end
+end

data/lib/hlockey/game/weather/weatherable.rb

@@ -0,0 +1,63 @@
+require("hlockey/constants")
+
+module Hlockey
+  class Game
+    module Weather
+      ##
+      # Module with needed methods for weathers, that every weather includes
+      # All methods starting with "on" represent game events weathers may respond to
+      module Weatherable
+        def initialize(game)
+          @game = game
+          @home = @game.home
+          @away = @game.away
+          @prng = @game.prng
+        end
+
+        def to_s
+          self.class.to_s.split("::").last
+        end
+
+        def on_game_start() end
+
+        def on_game_end() end
+
+        def on_period_end() end
+
+        def on_action() end
+
+        def on_goal(scoring_team) end
+
+        private
+
+        # Swaps a roster player with a shadows player
+        # @param team_sym [:home, :away]
+        # @param pos [Symbol] position of roster player swapped out
+        # @param shadows_idx [Integer] index of shadows player swapped in
+        # @return [Array<Player>] the players that were swapped
+        def swap(team_sym, pos, shadows_idx)
+          team = @game.send(team_sym)
+
+          prev_player = team.roster[pos]
+          next_player = team.shadows[shadows_idx]
+          team.roster[pos] = next_player
+          team.shadows[shadows_idx] = prev_player
+
+          unless @game.fight.nil?
+            player_array = @game.fight.players[team_sym]
+            player_idx = player_array.index(prev_player)
+
+            player_array[player_idx] = next_player unless player_idx.nil?
+          end
+
+          [prev_player, next_player]
+        end
+
+        # @return [:home, :away]
+        def rand_team
+          @prng.rand(2).zero? ? :home : :away
+        end
+      end
+    end
+  end
+end

data/lib/hlockey/game/weather.rb

@@ -0,0 +1,17 @@
+require("hlockey/game/weather/audacity")
+require("hlockey/game/weather/chicken")
+require("hlockey/game/weather/incline")
+require("hlockey/game/weather/stars")
+require("hlockey/game/weather/sunset")
+require("hlockey/game/weather/waves")
+
+module Hlockey
+  class Game
+    ##
+    # Weathers modify the mechanics of a Game
+    module Weather
+      # Every weather class
+      WEATHERS = [Audacity, Chicken, Incline, Stars, Sunset, Waves].freeze
+    end
+  end
+end

data/lib/hlockey/game.rb

@@ -1,5 +1,6 @@
 require("hlockey/game/actions")
 require("hlockey/game/fight")
+require("hlockey/game/weather")
 require("hlockey/constants")
 require("hlockey/message")
 require("hlockey/utils")
@@ -10,33 +11,42 @@ module Hlockey
   class Game
     include(Actions)
 
-    ACTIONS_PER_PERIOD = 60
-    NON_OT_PERIODS = 4
-    NON_OT_ACTIONS = ACTIONS_PER_PERIOD * NON_OT_PERIODS
-    TOTAL_ACTIONS = UPDATES_PER_HOUR - ACTIONS_PER_PERIOD
-    TOTAL_PERIODS = TOTAL_ACTIONS / ACTIONS_PER_PERIOD
+    # @return [Team] the teams in the game
+    attr_reader(:home, :away)
 
-    # @return [Weather]
+    # @return [Random] should be the same as the league's
+    attr_reader(:prng)
+
+    # @return [Team::Stadium] the stadium this game is located at
+    attr_reader(:stadium)
+
+    # @return [Weather::Weatherable] the weather effecting the game
     attr_reader(:weather)
 
-    # @return [Array<Message>]
+    # @return [Array<Message>] messages about game events
     attr_reader(:stream)
 
-    # @return [Integer]
-    attr_reader(:actions, :shooting_chance)
+    # @return [Hash<Symbol => Integer>] the score of each team
+    attr_reader(:score)
+
+    # @return [Boolean] if the game is still in progress
+    attr_reader(:in_progress)
+
+    # @return [Integer] what period the game is in
+    attr_reader(:period)
 
-    # @return [Fight, nil]
+    # @return [Fight, nil] the current fight, if there is any
     attr_reader(:fight)
 
     # @param home [Team]
     # @param away [Team]
     # @param prng [Random] should be League#prng
-    # @param weather [Class<Weather>]
-    def initialize(home, away, prng, weather)
+    def initialize(home, away, prng)
       @home = home
       @away = away
       @prng = prng
-      @weather = weather.new(self)
+      @stadium = @home.stadium
+      @weather = Weather::WEATHERS.sample(random: prng).new(self)
       @stream = [Message.StartOfGame]
       @score = { home: 0, away: 0 }
       @in_progress = true
@@ -61,24 +71,33 @@ module Hlockey
       "#{Message.color(@home)} vs #{Message.color(@away)}"
     end
 
-    # Does an action in the game
+    # Update the game state by one action
     def update
       return unless @in_progress
 
+      do_action
+      handle_parties
+    end
+
+    private
+
+    # Does an action in the game
+    def do_action
       @stream << Message.StartOfPeriod(@period) if @actions.zero?
       @actions += 1
 
       @weather.on_action
 
       unless @fight.nil?
-        @stream << @fight.next_action
-        if @stream.last.event == :FightEnded
-          morale_change_amount = (@fight.score[:home] - @fight.score[:away]) / 10.0
-          change_morale(@home, morale_change_amount)
-          change_morale(@away, -morale_change_amount)
+        fight_message = @fight.next_action
+        @stream << fight_message
+        return unless fight_message.event == :FightEnded
 
-          @fight = nil
-        end
+        morale_change_amount = (@fight.score[:home] - @fight.score[:away]) / 10.0
+        change_morale(@home, morale_change_amount)
+        change_morale(@away, -morale_change_amount)
+
+        @fight = nil
         return
       end
 
@@ -99,8 +118,11 @@ module Hlockey
       else
         shoot
       end
+    end
 
-      return unless @partying_teams.any? && @prng.rand(NON_OT_ACTIONS / 5).zero?
+    # Does the random chance of partying for teams in party time
+    def handle_parties
+      return unless @partying_teams.any? && random_event_occurs?(5)
 
       @partying_teams.each do |team|
         player = team.roster.values.sample(random: @prng)
@@ -113,33 +135,6 @@ module Hlockey
       end
     end
 
-    # Makes a player shoot in the game, regardless of if it would normally occur
-    # @param audacity [Boolean] if the function was called by Audacity weather
-    def shoot(audacity: false)
-      return if @puck_holder_pos.nil?
-
-      if @shooting_chance < 5 &&
-         try_block_shot(@prng.rand(2).zero? ? :ldef : :rdef, audacity: audacity)
-        return
-      end
-      return if try_block_shot(:goalie, audacity: audacity)
-
-      # Goal scored
-
-      scoring_team = @team_with_puck == @home ? :home : :away
-      @score[scoring_team] += 1
-      weather.on_goal(scoring_team)
-
-      @stream << Message.ShootScore(puck_holder, @home, @away, *@score.values, audacity)
-
-      start_fight if @prng.rand(3 + @fight_chance) > 3
-
-      start_faceoff
-      @actions = ACTIONS_PER_PERIOD - 1 if @period >= NON_OT_PERIODS # Sudden death OT
-    end
-
-    private
-
     # Makes a player pass in the game, regardless of if it would normally occur
     def pass
       sender = puck_holder
@@ -170,6 +165,32 @@ module Hlockey
       @fight_chance += 0.1
     end
 
+    # Makes a player shoot in the game, regardless of if it would normally occur
+    # This is called outside of the class by Audacity weather (using #send)
+    # @param audacity [Boolean] if the function was called by Audacity weather
+    def shoot(audacity: false)
+      return if @puck_holder_pos.nil?
+
+      if @shooting_chance < 5 &&
+         try_block_shot(@prng.rand(2).zero? ? :ldef : :rdef, audacity: audacity)
+        return
+      end
+      return if try_block_shot(:goalie, audacity: audacity)
+
+      # Goal scored
+
+      scoring_team = @team_with_puck == @home ? :home : :away
+      @score[scoring_team] += 1
+      weather.on_goal(scoring_team)
+
+      @stream << Message.ShootScore(puck_holder, @home, @away, *@score.values, audacity)
+
+      start_fight if @prng.rand(3 + @fight_chance) > 3
+
+      start_faceoff
+      @actions = ACTIONS_PER_PERIOD - 1 if @period > NON_OT_PERIODS # Sudden death OT
+    end
+
     def end_period
       @weather.on_period_end
       @stream << Message.EndOfPeriod(@period, @home, @away, *@score.values)
@@ -177,7 +198,7 @@ module Hlockey
       @period += 1
       start_faceoff
 
-      if @period >= NON_OT_PERIODS &&
+      if @period > NON_OT_PERIODS &&
          !(@score[:home] == @score[:away] && @period <= TOTAL_PERIODS)
         # Game is over
         @pre_morale_change_stats.each { |player, stats| player.stats = stats }
@@ -300,21 +321,9 @@ module Hlockey
     # @return [Hash<Symbol => Integer>]
     def weights(offensive)
       if offensive
-        {
-          lwing: 2,
-          center: 2,
-          rwing: 2,
-          ldef: 1,
-          rdef: 1
-        }
+        { lwing: 2, center: 2, rwing: 2, ldef: 1, rdef: 1 }
       else
-        {
-          lwing: 1,
-          center: 1,
-          rwing: 1,
-          ldef: 3,
-          rdef: 3
-        }
+        { lwing: 1, center: 1, rwing: 1, ldef: 3, rdef: 3 }
       end
     end
   end