hlockey 3 → 5

data/lib/hlockey/game.rb

@@ -1,7 +1,9 @@
 require("hlockey/game/actions")
 require("hlockey/game/fight")
+require("hlockey/game/weather")
 require("hlockey/constants")
 require("hlockey/message")
+require("hlockey/utils")
 
 module Hlockey
   ##
@@ -9,93 +11,185 @@ 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 [Array<Message>]
-    attr_reader(:stream)
+    # @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]
+    # @return [Weather::Weatherable] the weather effecting the game
     attr_reader(:weather)
 
+    # @return [Array<Message>] messages about game events
+    attr_reader(:stream)
+
+    # @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] 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
       @actions = 0
       @period = 1
       @faceoff = true
+      @faceoff_won = false
       @team_with_puck = nil
       @puckless_team = nil
-      @puck_holder = nil
+      @puck_holder_pos = nil
       @shooting_chance = 0
       @fight = nil
       @fight_chance = 0
-      @total_fight_actions = 0
       @pre_morale_change_stats = {}
+      @partying_teams = [@home, @away].select { |t| t.status == :partying }
 
       @weather.on_game_start
     end
 
     # @return [String]
     def to_s
-      "#{@home} vs #{@away}"
+      "#{Message.color(@home)} vs #{Message.color(@away)}"
     end
 
+    # 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
-          @total_fight_actions += @fight.actions
+        fight_message = @fight.next_action
+        @stream << fight_message
+        return unless fight_message.event == :FightEnded
 
-          morale_change_amount = (@fight.score[:home] - @fight.score[:away]) * 0.05
-          boost_morale(@home, morale_change_amount)
-          boost_morale(@away, -morale_change_amount)
+        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
-        end
+        @fight = nil
         return
       end
 
-      @stream << Message.StartOfPeriod(@period) if @actions.zero?
-      @actions += 1
-
       if @actions >= ACTIONS_PER_PERIOD
         end_period
         return
       end
-
       if @faceoff
         do_faceoff
         return
       end
 
-      @weather.on_action
-
       case @prng.rand(5 + @shooting_chance)
       when 0..4
         pass
-      when 5..6
+      when 5, 6
         check
       else
         shoot
       end
     end
 
-    private
+    # 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)
+        stat = player.stats.keys.sample(random: @prng)
+        player.stats[stat] += 0.1
+        @stream << Message.Partying(player)
+        next if @pre_morale_change_stats[player].nil?
+
+        @pre_morale_change_stats[player][stat] += 0.1
+      end
+    end
+
+    # Makes a player pass in the game, regardless of if it would normally occur
+    def pass
+      sender = puck_holder
+      receiver = pass_reciever
+      interceptor = defensive_pos
+
+      if !@faceoff && try_take_puck(interceptor, 7 - @shooting_chance, :agility)
+        @stream << Message.Pass(sender,
+                                @puckless_team.roster[receiver],
+                                @shooting_chance,
+                                @team_with_puck.roster[interceptor],
+                                @team_with_puck)
+        return
+      end
+
+      @puck_holder_pos = receiver
+      @shooting_chance += 1
+      @stream << Message.Pass(sender, @team_with_puck.roster[receiver], @shooting_chance)
+    end
+
+    # Makes a player check in the game, regardless of if it would normally occur
+    def check
+      defender_pos = defensive_pos
+      defender = @puckless_team.roster[defender_pos]
+      @stream << Message.Hit(puck_holder, defender,
+                             try_take_puck(defender_pos), @team_with_puck,
+                             @shooting_chance)
+      @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
@@ -104,9 +198,8 @@ module Hlockey
       @period += 1
       start_faceoff
 
-      if @period >= NON_OT_PERIODS &&
-         !(@score[:home] == @score[:away] &&
-           @period <= TOTAL_PERIODS - (@total_fight_actions / ACTIONS_PER_PERIOD))
+      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 }
         @weather.on_game_end
@@ -121,28 +214,30 @@ module Hlockey
     def start_faceoff
       @shooting_chance = 0
       @faceoff = true
-      @puck_holder = nil
+      @faceoff_won = false
     end
 
     def do_faceoff
-      if @puck_holder.nil?
-        # Pass opposite team to who wins the puck to switch_team_with_puck,
-        # so @team_with_puck & @puckless_team are set to the correct values.
-        switch_team_with_puck(
-          if action_succeeds?(@home.roster[:center].stats[:offense],
-                              @away.roster[:center].stats[:offense])
-            @away
-          else
-            @home
-          end
-        )
-
-        @puck_holder = @team_with_puck.roster[:center]
-        @stream << Message.FaceOff(@puck_holder, @team_with_puck)
-      else
+      if @faceoff_won
         pass
         @faceoff = false
+        return
       end
+
+      # Pass opposite team to who wins the puck to switch_team_with_puck,
+      # so @team_with_puck & @puckless_team are set to the correct values.
+      switch_team_with_puck(
+        if action_succeeds?(@home.roster[:center].stats[:offense],
+                            @away.roster[:center].stats[:offense])
+          @away
+        else
+          @home
+        end
+      )
+      @shooting_chance = 2
+      @puck_holder_pos = :center
+      @faceoff_won = true
+      @stream << Message.FaceOff(puck_holder, @team_with_puck)
     end
 
     def switch_team_with_puck(team_with_puck = @team_with_puck)
@@ -151,74 +246,35 @@ module Hlockey
                                         else
                                           [@home, @away]
                                         end
-      @shooting_chance = 0
-    end
-
-    def pass
-      sender = @puck_holder
-      receiver = random_puckless_non_goalie(@team_with_puck)
-      interceptor = random_puckless_non_goalie(@puckless_team)
-
-      if !@faceoff && try_take_puck(interceptor, 4) # Pass intercepted
-        @stream << Message.Pass(sender, receiver, interceptor, @team_with_puck)
-        return
-      end
-
-      @stream << Message.Pass(sender, receiver)
-      @puck_holder = receiver
-      @shooting_chance += 1
-    end
-
-    def check
-      defender = random_puckless_non_goalie(@puckless_team)
-      @stream << Message.Hit(@puck_holder, defender,
-                             try_take_puck(defender, 0, :defense), @team_with_puck)
-      @fight_chance += 0.1
-    end
-
-    def shoot
-      if @shooting_chance < 5 &&
-         try_block_shot(@puckless_team.roster[@prng.rand(2).zero? ? :ldef : :rdef])
-        return
-      end
-      return if try_block_shot(@puckless_team.roster[:goalie])
-
-      # 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)
-
-      if @prng.rand(3 + @fight_chance) > 5 &&
-         @total_fight_actions < TOTAL_ACTIONS - NON_OT_ACTIONS
-        start_fight
-      end
-
-      start_faceoff
-      @actions = ACTIONS_PER_PERIOD - 1 if @period >= NON_OT_PERIODS # Sudden death OT
+      @shooting_chance = 3 - @shooting_chance
+      @shooting_chance = 0 if @shooting_chance.negative?
     end
 
+    # @param pos [Symbol] position on puckless team that tries to take the puck
+    # @param dis [Integer] disadvantage against taking puck
+    # @param stat [Symbol] stat compared to change the odds of success/failure
     # @return [Boolean] if taking the puck succeeded
-    def try_take_puck(player, disadvantage = 0, stat = :agility)
-      return false unless action_succeeds?(player.stats[stat] - disadvantage,
-                                           @puck_holder.stats[stat])
+    def try_take_puck(pos, dis = 0, stat = :defense)
+      return false unless action_succeeds?(@puckless_team.roster[pos].stats[stat] - dis,
+                                           puck_holder.stats[stat])
 
       switch_team_with_puck
-      @puck_holder = player
+      @puck_holder_pos = pos
 
       true
     end
 
     # @return [Boolean] if blocking the shot succeeded
-    def try_block_shot(blocker)
+    def try_block_shot(pos, audacity: false)
+      blocker = @puckless_team.roster[pos]
+
       return false unless action_succeeds?(blocker.stats[:defense],
-                                           @puck_holder.stats[:offense])
+                                           puck_holder.stats[:offense])
 
       @shooting_chance += 1
-      @stream << Message.ShootBlock(@puck_holder, blocker,
-                                    try_take_puck(blocker), @team_with_puck)
+      @stream << Message.ShootBlock(puck_holder, blocker,
+                                    try_take_puck(pos), @team_with_puck,
+                                    @shooting_chance, audacity)
 
       true
     end
@@ -231,7 +287,7 @@ module Hlockey
 
     # @param team [Team]
     # @param amount [Numeric]
-    def boost_morale(team, amount)
+    def change_morale(team, amount)
       return if amount.zero?
 
       team.roster.each_value do |player|
@@ -241,14 +297,34 @@ module Hlockey
 
         player.stats.transform_values! { |stat| stat + amount }
       end
+
+      @stream << Message.MoraleChange(team, amount)
     end
 
     # @return [Player]
-    def random_puckless_non_goalie(team)
-      team.random_player(
-        @prng,
-        proc { |player| player != team.roster[:goalie] and player != @puck_holder }
-      )
+    def puck_holder
+      @team_with_puck.roster[@puck_holder_pos]
+    end
+
+    # @return [Symbol]
+    def pass_reciever
+      w = weights(@shooting_chance > 3)
+      w.delete(@puck_holder_pos)
+      Utils.weighted_random(w, @prng)
+    end
+
+    # @return [Symbol]
+    def defensive_pos
+      Utils.weighted_random(weights(@shooting_chance < 3), @prng)
+    end
+
+    # @return [Hash<Symbol => Integer>]
+    def weights(offensive)
+      if offensive
+        { lwing: 2, center: 2, rwing: 2, ldef: 1, rdef: 1 }
+      else
+        { lwing: 1, center: 1, rwing: 1, ldef: 3, rdef: 3 }
+      end
     end
   end
 end

data/lib/hlockey/league.rb

@@ -3,13 +3,12 @@ require("hlockey/data")
 require("hlockey/game")
 require("hlockey/utils")
 require("hlockey/version")
-require("hlockey/weather")
 
 module Hlockey
   ##
   # The Hlockey League
   class League
-    REGULAR_SEASON_DAY_AMT = 38
+    GAMES_IN_REGULAR_SEASON = 111
 
     # @return [Time]
     attr_reader(:start_time)
@@ -17,31 +16,42 @@ module Hlockey
     # @return [Hash<Symbol => Array<Team>>]
     attr_reader(:divisions)
 
-    # @return [Array<Team>]
-    attr_reader(:teams, :playoff_teams)
-
     # @return [Integer]
     attr_reader(:day)
 
     # @return [Array<Game>]
     attr_reader(:games, :games_in_progress)
 
+    # @return [Array<String>]
+    attr_reader(:alerts)
+
     # @return [Team, nil]
     attr_reader(:champion_team)
 
+    # @return [Array<Team>]
+    attr_reader(:teams, :playoff_teams)
+
     def initialize
       @start_time, @divisions = Data.league
       @start_time.localtime
       @day = 0
-      @games_in_progress = []
       @games = []
+      @games_in_progress = []
+      @alerts = []
       @champion_team = nil
       @last_update_time = @start_time
       @passed_updates = 0
       @prng = Random.new(@start_time.to_i)
-      @teams = @divisions.values.reduce(:+)
-      @shuffled_teams = @teams.shuffle(random: @prng)
+      @teams = @divisions.values.flatten
+      @sorted_teams_by_wins = @teams.shuffle(random: @prng)
       @playoff_teams = []
+      @sleepers_changes = @teams.last.roster.values.zip([18, 4, 13, 19, 6, 0])
+      # warm vs warm / cool vs cool
+      rotated_divisions = game_divisions.values.rotate
+      @shuffled_division_pairs = Array.new(2) do |i|
+        (rotated_divisions[i] + rotated_divisions[-i - 1]).shuffle(random: @prng)
+      end
+
       @game_in_matchup = 3
       @matchup_game_amt = 3
     end
@@ -52,13 +62,15 @@ module Hlockey
     def update_state
       return if @champion_team
 
-      now = Time.at(Time.now.to_i)
+      now_i = Time.now.to_i
+      now = Time.at(now_i - (now_i % UPDATE_FREQUENCY_SECONDS))
       intervals = (now - @last_update_time).div(UPDATE_FREQUENCY_SECONDS)
 
       return unless intervals.positive?
 
       intervals.times do |i|
         if ((i + @passed_updates) % UPDATES_PER_HOUR).zero?
+          update_teams
           new_games
         else
           update_games
@@ -73,6 +85,41 @@ module Hlockey
 
     private
 
+    def update_teams
+      return if @day.zero?
+
+      games_remaining = GAMES_IN_REGULAR_SEASON - ((@day - 1) * 3 + @game_in_matchup)
+      return if games_remaining.negative?
+
+      if games_remaining.zero?
+        @playoff_teams = sort_teams_by_wins(playoff_qualifiers)
+        @playoff_teams.each { |team| team.status = :qualified }
+        (@teams[...-1] - @playoff_teams).each { |team| team.status = :partying }
+        return
+      end
+
+      set_to_qualify = playoff_qualifiers
+      @teams[...-1].each_with_index do |team, i|
+        next unless games_remaining < set_to_qualify[i / 5].wins - team.wins &&
+                    games_remaining < set_to_qualify.last.wins - team.wins
+
+        team.status = :partying
+      end
+
+      threat_wins = sort_teams_by_wins(@teams - set_to_qualify).first.wins
+      set_to_qualify.each_with_index do |team, i|
+        division_threat_wins = if i < 4
+                                 sort_teams_by_wins(@divisions.values[i])[1].wins
+                               else # Team is not a division leader, so use itself
+                                 team.wins
+                               end
+        next unless games_remaining < team.wins - threat_wins ||
+                    games_remaining < team.wins - division_threat_wins
+
+        team.status = :qualified
+      end
+    end
+
     def new_games
       if @game_in_matchup != @matchup_game_amt
         # New game in matchups
@@ -86,34 +133,58 @@ module Hlockey
       @game_in_matchup = 1
       @day += 1
 
-      case @day <=> REGULAR_SEASON_DAY_AMT + 1
-      when -1 # In regular season
-        (@shuffled_teams.length / 2).times do |i|
-          pair = [@shuffled_teams[i], @shuffled_teams[-i - 1]]
-          pair.reverse! if @day > REGULAR_SEASON_DAY_AMT / 2
-          @games << new_game(*pair)
+      case @day
+      when 1..27
+        @shuffled_division_pairs.each { |p| new_matchups(p, reverse: @day.even?) }
+      when 28..37
+        @shuffled_division_pairs.transpose.each_with_index do |pair, i|
+          @games << new_game(*pair, reverse: i.even?)
         end
-
-        @shuffled_teams.insert(1, @shuffled_teams.pop)
-      when 0 # Playoffs about to start
+        @shuffled_division_pairs.first.rotate!
+      when 38
         @matchup_game_amt = 5
-
-        # get teams that qualified for playoffs, put in @playoff_teams
-        two_best_teams_each_division = @divisions.values.map do |teams|
-          sort_teams_by_wins(teams).first(2)
-        end.reduce(:+)
-        @playoff_teams = sort_teams_by_wins(two_best_teams_each_division).map(&:clone)
-
+        @playoff_teams = sort_teams_by_wins(playoff_qualifiers).map do |team|
+          cloned_team = team.clone
+          cloned_team.status = :playoffs
+          cloned_team
+        end
         new_playoff_matchups
-      when 1 # Playoffs started
+      when 39, 40
         @playoff_teams.select! { |team| team.wins > team.losses }
+        new_playoff_matchups
+      when 41
+        champion = @playoff_teams.find { |team| team.wins > team.losses }
+        champion.wins = 0
+        champion.losses = 0
+        @playoff_teams = [@teams.last, champion]
+        @alerts = ["The #{@teams.last} have awoken..."]
+        new_playoff_matchups
+      when 42
+        return unless @champion_team.nil?
+
+        sleepers, @champion_team = @playoff_teams
+        @alerts = []
 
-        if @playoff_teams.length == 1
-          @champion_team = @playoff_teams.first
+        if @champion_team.to_s == "Baden Hallucinations"
+          @alerts << "The Baden Hallucinations have reached 5 championships."
+          @alerts << "They will evolve soon."
+        end
+
+        if sleepers.wins > @champion_team.wins
+          @alerts << "The #{sleepers} have beat your champions."
+          @alerts << "The #{sleepers} are evolving!"
+          old_name = sleepers.to_s
+          sleepers.to_s = "#{old_name}z"
+          @alerts << "#{old_name} -> #{sleepers}"
           return
         end
 
-        new_playoff_matchups
+        @alerts << "The #{sleepers} have lost."
+        @sleepers_changes.each do |(player, team_idx)|
+          player.team = @teams[team_idx]
+          player.team.shadows << player
+          @alerts << "#{player} has adventured into the #{player.team} shadows."
+        end
       end
     end
 
@@ -129,22 +200,50 @@ module Hlockey
         team.losses = 0
       end
 
-      (@playoff_teams.length / 2).times do |i|
-        @games << new_game(@playoff_teams[i], @playoff_teams[-i - 1])
+      new_matchups(@playoff_teams, rotate: false)
+    end
+
+    # @param matchup_teams[Array<Team>]
+    # @param rotate [Boolean]
+    # @param reverse [Boolean]
+    def new_matchups(matchup_teams, rotate: true, reverse: false)
+      (matchup_teams.length / 2).times do |i|
+        @games << new_game(matchup_teams[i], matchup_teams[-i - 1], reverse: reverse)
       end
+      matchup_teams.insert(1, matchup_teams.pop) if rotate
     end
 
     # @param home [Team]
     # @param away [Team]
-    # @return [Game]
-    def new_game(home, away)
-      Game.new(home, away, @prng, Utils.weighted_random(Weather::WEIGHTS, @prng))
+    # @param reverse [Boolean]
+    def new_game(home, away, reverse: false)
+      teams = [home, away]
+      teams.reverse! if reverse
+
+      Game.new(*teams, @prng)
+    end
+
+    # @return [Array<Team>]
+    def playoff_qualifiers
+      top_divs = game_divisions.values.map { |teams| sort_teams_by_wins(teams).first }
+      # Prevents tied teams from being unfairly decided by which division they're in
+      @sorted_teams_by_wins = sort_teams_by_wins(@sorted_teams_by_wins)
+      rest = (@sorted_teams_by_wins - top_divs).first(4)
+
+      top_divs + rest
     end
 
     # @param teams [Array<Team>]
     # @return [Array<Team>]
     def sort_teams_by_wins(teams)
-      teams.sort { |a, b| b.wins <=> a.wins }
+      # A stable sort (Ruby's normal sort isn't always stable)
+      # t.wins is negative because it sorts the opposite way than I want otherwise
+      teams.sort_by.with_index { |t, i| [-t.wins, i] }
+    end
+
+    # @return [Hash<Symbol => Array<Team>]
+    def game_divisions
+      @divisions.except(:"Sleepy Tired")
     end
   end
 end