hlockey 6 → 7

data/lib/hlockey/game.rb

@@ -14,7 +14,7 @@ module Hlockey
     # @return [Team] the teams in the game
     attr_reader(:home, :away)
 
-    # @return [Random] should be the same as the league's
+    # @return [Utils::Rng] the RNG the game is getting numbers from
     attr_reader(:prng)
 
     # @return [Hash<Symbol => Integer>] the score of each team
@@ -31,6 +31,7 @@ module Hlockey
 
     # @return [Boolean] if the game is still in progress
     attr_reader(:in_progress)
+    alias in_progress? in_progress
 
     # @return [Integer] what period the game is in
     attr_reader(:period)
@@ -41,26 +42,28 @@ module Hlockey
     # @return [Hash<Player => Hash<Symbol => Number>>] stats of players before changes
     attr_reader(:pre_tmp_change_stats)
 
-    alias in_progress? in_progress
-
     # @param home [Team]
     # @param away [Team]
-    # @param prng [Random] should be League#prng
+    # @param rng_seed [Integer] number to seed the game's RNG with
     # @param weather [Class<Weatherable>]
-    def initialize(home, away, prng, weather = nil)
+    def initialize(home, away, rng_seed, weather = nil)
       @home = home
       @away = away
-      @prng = prng
+      @prng = Utils::Rng.new(rng_seed)
 
       @stadium = @home.stadium
 
-      weather ||= Weather::WEATHERS.sample(random: prng)
+      if weather.nil?
+        weather = Weather::WEATHERS.sample(random: prng)
+        @rng_seed = @prng.state
+      end
+
       @weather = weather.new(self)
       @score = { home: 0, away: 0 }
       @in_progress = true
       @actions = 0
       @period = 1
-      @stream = [Message.StartOfGame]
+      @stream = [Message.new(:game_start)]
       @faceoff = true
       @faceoff_won = false
       @team_with_puck = nil
@@ -71,55 +74,138 @@ module Hlockey
       @fight_chance = 0
       @pre_tmp_change_stats = {}
       @partying_teams = [@home, @away].select { _1.status == :partying }
+      @do_final_cleanup = false
 
+      set_mods_game
       @weather.on_game_start
     end
 
     # @return [Hash]
-    def to_h = {
-      home: @home.name,
-      away: @away.name,
-      stadium: @stadium.to_s,
-      weather: @weather.to_s,
-      score: @score,
-      in_progress?: @in_progress,
-      period: @period,
-      stream: @stream.map { _1.to_s(do_color: false) }
-    }
+    def to_h(simple: false, stream_start_idx: 0, show_events: true, do_color: false)
+      res = {
+        home: @home.name,
+        away: @away.name,
+        stadium: @stadium.to_s,
+        weather: @weather.to_s,
+        score: @score,
+        in_progress: @in_progress,
+        period: @period
+      }
+      unless simple
+        if show_events
+          res[:events] = @stream[stream_start_idx..]&.map(&:event)
+        else
+          res[:stream] = @stream[stream_start_idx..]&.map { _1.to_s(do_color:) }
+        end
+
+        res[:team_with_puck] = @team_with_puck&.name
+        res[:shooting_chance] = @shooting_chance
+      end
+
+      res
+    end
 
     # @return [String]
-    def to_s = "#{Message.color(@home)} vs #{Message.color(@away)}"
+    def to_s(do_color: true) =
+      "#{Message.color(@home, do_color:)} vs #{Message.color(@away, do_color:)}"
 
     # Update the game state by one action
     def update
-      return unless @in_progress
+      if @do_final_cleanup
+        @in_progress = false
+        set_mods_game(unset: true)
+        return
+      end
 
       do_action
       handle_parties
     end
 
+    # Makes a player pass in the game, regardless of if it would normally occur
+    def pass
+      sender = puck_holder
+      receiver_pos = pass_reciever_pos
+      interceptor_pos = defensive_pos
+
+      @stream << Message.new(:game_pass,
+                             sender:,
+                             receiver: @team_with_puck.roster[receiver_pos])
+
+      if !@faceoff && try_take_puck(interceptor_pos, dis: 10 - @shooting_chance)
+        @stream << Message.new(:game_pass_intercept,
+                               sender:,
+                               receiver: @puckless_team.roster[receiver_pos],
+                               interceptor: @team_with_puck.roster[interceptor_pos])
+        return
+      end
+
+      @puck_holder_pos = receiver_pos
+      @shooting_chance += 1
+    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.new(:game_hit, defender:, puck_holder:)
+      if !puck_holder.mods_do(:on_got_hit, defender) &&
+         try_take_puck(defender_pos, stat: :defense)
+        @stream << Message.new(:game_possession_change,
+                               player: defender, new_puck_team: defender.team)
+      end
+
+      @fight_chance += 0.1
+    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?
+
+      shooter = puck_holder
+
+      @stream << Message.new(audacity ? :game_shot_audacious : :game_shot, shooter:)
+
+      blocking_pos = @prng.rand(2).zero? ? :ldef : :rdef
+      return if try_block_shot(blocking_pos) || try_block_shot(:goalie)
+
+      # Goal scored
+
+      scoring_team = @team_with_puck == @home ? :home : :away
+      @score[scoring_team] += 1
+      weather.on_goal(scoring_team)
+
+      @stream << Message.new(:game_shot_scored, shooter:)
+
+      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
+
     # Starts a fight in the game
     # @param starting_player [Player, nil] the player that started the fight (optional)
     def start_fight(starting_player = nil)
       @fight = Fight.new(self, starting_player)
-      @stream << Message.FightStarted(@fight.players[:home].first,
-                                      @fight.players[:away].first)
+      @stream << Message.new(:fight_start,
+                             home_player: @fight.players[:home].first,
+                             away_player: @fight.players[:away].first)
     end
 
     private
 
     # Does an action in the game
     def do_action
-      @stream << Message.StartOfPeriod(@period) if @actions.zero?
+      @stream << Message.new(:game_period_start, period: @period) if @actions.zero?
       @actions += 1
 
       @weather.on_action
-      (@home.roster.values + @away.roster.values).each { _1.mods_do(:on_action, self) }
+      (@home.roster.values + @away.roster.values).each { _1.mods_do(:on_action) }
 
       unless @fight.nil?
-        fight_message = @fight.next_action
-        @stream << fight_message
-        return unless fight_message.event == :FightEnded
+        @fight.next_action
+        return unless @stream.last.event == :fight_end
 
         morale_change_amount = (@fight.score[:home] - @fight.score[:away]) / 10.0
         change_morale(@home, morale_change_amount)
@@ -156,92 +242,30 @@ module Hlockey
         player = team.roster.values.sample(random: @prng)
         stat = player.stats.keys.sample(random: @prng)
         player.stats[stat] += 0.1
-        @stream << Message.Partying(player)
+        @stream << Message.new(:game_partying, player:)
         next if @pre_tmp_change_stats[player].nil?
 
         @pre_tmp_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]
-
-      mods_messages = puck_holder.mods.map { _1.on_got_hit(self, defender) }.compact
-
-      @stream << Message.Hit(puck_holder,
-                             defender,
-                             mods_messages.empty? && try_take_puck(defender_pos),
-                             @team_with_puck,
-                             @shooting_chance)
-      @stream.concat(mods_messages)
-      @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:)
-        return
-      end
-      return if try_block_shot(:goalie, 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)
+      @stream << Message.new(:game_period_end, period: @period)
       @actions = 0
       @period += 1
       start_faceoff
 
       if @period > NON_OT_PERIODS &&
-         !(@score[:home] == @score[:away] && @period <= TOTAL_PERIODS)
+         (@score[:home] != @score[:away] || @period > TOTAL_PERIODS)
         # Game is over
         @pre_tmp_change_stats.each { |player, stats| player.stats = stats }
         @weather.on_game_end
-        @in_progress = false
         winner, loser = @score[:away] > @score[:home] ? [@away, @home] : [@home, @away]
-        @stream << Message.EndOfGame(winner)
+        @stream << Message.new(:game_end, winning_team: winner)
         winner.wins += 1
         loser.losses += 1
+        @do_final_cleanup = true
       end
     end
 
@@ -271,7 +295,7 @@ module Hlockey
       @shooting_chance = 2
       @puck_holder_pos = :center
       @faceoff_won = true
-      @stream << Message.FaceOff(puck_holder, @team_with_puck)
+      @stream << Message.new(:game_faceoff, winning_player: puck_holder)
     end
 
     def switch_team_with_puck(team_with_puck = @team_with_puck)
@@ -288,7 +312,7 @@ module Hlockey
     # @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(pos, dis = 0, stat = :defense)
+    def try_take_puck(pos, dis: 0, stat: :agility)
       return false unless action_succeeds?(@puckless_team.roster[pos].stats[stat] - dis,
                                            puck_holder.stats[stat])
 
@@ -299,20 +323,38 @@ module Hlockey
     end
 
     # @return [Boolean] if blocking the shot succeeded
-    def try_block_shot(pos, audacity: false)
+    def try_block_shot(pos)
       blocker = @puckless_team.roster[pos]
 
-      return false unless action_succeeds?(blocker.stats[:defense],
-                                           puck_holder.stats[:offense])
+      defense = if pos == :goalie
+                  blocker.stats[:defense] * 2
+                else
+                  blocker.stats[:defense] - @shooting_chance
+                end
+      return false unless action_succeeds?(defense, puck_holder.stats[:offense])
 
       @shooting_chance += 1
-      @stream << Message.ShootBlock(puck_holder, blocker,
-                                    try_take_puck(pos), @team_with_puck,
-                                    @shooting_chance, audacity)
+      @stream << Message.new(:game_shot_blocked, blocker:)
+
+      if action_succeeds?(defense, 0)
+        # blocker takes puck
+        switch_team_with_puck
+        @puck_holder_pos = pos
+      else
+        @puck_holder_pos = Utils.weighted_random(weights(true), @prng)
+        try_take_puck(Utils.weighted_random(weights(false).tap { _1.delete(pos) }, @prng))
+      end
+
+      @stream << Message.new(:game_possession_change,
+                             player: puck_holder, new_puck_team: @team_with_puck)
 
       true
     end
 
+    # @param unset [Boolean] if the game should be set to nil (done when game is over)
+    def set_mods_game(unset: false) =
+      (@home.players + @away.players).each { _1.mods_do(:game=, unset ? nil : self) }
+
     # Add amount to each stat of each player of team until the end of the game
     # @param team [Team]
     # @param amount [Numeric]
@@ -320,21 +362,22 @@ module Hlockey
       return if amount.zero?
 
       team.roster.each_value do |player|
-        if @pre_tmp_change_stats[player].nil?
-          @pre_tmp_change_stats[player] = player.stats.clone
-        end
-
-        player.stats.transform_values! { |stat| stat + amount }
+        @pre_tmp_change_stats[player] ||= player.stats.clone
+        player.stats.transform_values! { _1 + amount }
       end
 
-      @stream << Message.MoraleChange(team, amount)
+      @stream << if amount.positive?
+                   Message.new(:fight_end_morale_gain, team:, num: amount)
+                 else
+                   Message.new(:fight_end_morale_loss, team:, num: -amount)
+                 end
     end
 
-    # @return [Player]
+    # @return [Team::Player]
     def puck_holder = @team_with_puck.roster[@puck_holder_pos]
 
     # @return [Symbol]
-    def pass_reciever
+    def pass_reciever_pos
       w = weights(@shooting_chance > 3)
       w.delete(@puck_holder_pos)
       Utils.weighted_random(w, @prng)
@@ -345,11 +388,9 @@ module Hlockey
 
     # @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
+      return { lwing: 2, center: 2, rwing: 2, ldef: 1, rdef: 1 } if offensive
+
+      { lwing: 1, center: 1, rwing: 1, ldef: 3, rdef: 3 }
     end
   end
 end

data/lib/hlockey/league.rb

@@ -11,6 +11,10 @@ module Hlockey
   class League
     GAMES_IN_REGULAR_SEASON = 111
 
+    # @return [Boolean]
+    attr_reader(:infinite)
+    alias infinite? infinite
+
     # @return [Time]
     attr_reader(:start_time)
 
@@ -20,6 +24,9 @@ module Hlockey
     # @return [Integer]
     attr_reader(:day)
 
+    # @return [String]
+    attr_reader(:season)
+
     # @return [Array<Game>]
     attr_reader(:games, :games_in_progress)
 
@@ -32,21 +39,16 @@ module Hlockey
     # @return [Array<Team>]
     attr_reader(:teams, :playoff_teams)
 
-    # @param start_time [Array<Integer>, nil] args to Time.utc
-    # @param divisions [Hash<Symbol => Array<Hash>, nil]
-    def initialize(start_time: nil, divisions: nil)
-      if start_time.nil? || divisions.nil?
-        league_hash = Data.league
-        start_time ||= league_hash[:start_time]
-        divisions ||= league_hash[:divisions]
-      end
-
-      @start_time = Time.utc(*start_time)
-      @start_time.localtime
-
+    # @param start_time [Array<Integer>] parameters passed to Time.new
+    # @param divisions [Hash<Symbol => Array<Hash>>] division data
+    # @param infinite [Boolean] if the league is infinite, rather than a single season
+    def initialize(infinite:, start_time:, divisions:)
+      @infinite = infinite
+      @start_time = Time.utc(*start_time).localtime
       @divisions = divisions.transform_values { |teams| teams.map { Team.new(**_1) } }
 
       @day = 0
+      @season = infinite ? "?" : VERSION
 
       @games = []
       @games_in_progress = []
@@ -57,24 +59,27 @@ module Hlockey
       @last_update_time = @start_time
       @passed_updates = 0
 
-      @prng = Random.new(@start_time.to_i)
+      @prng = Utils::Rng.new(@start_time.to_i)
 
       @teams = @divisions.values.flatten
       @sorted_teams_by_wins = @teams.shuffle(random: @prng)
       @playoff_teams = []
 
+      @game_in_matchup = @matchup_game_amt = 3
+
+      return if @infinite
+
       # warm vs warm / cool vs cool
       rotated_divisions = @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 = @matchup_game_amt = 3
     end
 
     # @return [Hash]
     def to_h(simple: false)
       res = {
+        infinite: @infinite,
         start_time: @start_time.getutc.to_a.first(6).reverse,
         divisions: @divisions.transform_values { |d| d.map { |t| t.to_h(simple:) } }
       }
@@ -107,13 +112,16 @@ module Hlockey
       return unless intervals.positive?
 
       intervals.times do |i|
-        if ((i + @passed_updates) % UPDATES_PER_HOUR).zero?
+        if !@infinite && ((i + @passed_updates) % UPDATES_PER_HOUR).zero?
           update_teams
           new_games
-        else
-          update_games
+          next
         end
 
+        update_games
+
+        new_games if @infinite && @games_in_progress.empty?
+
         break if @champion_team
       end
 
@@ -161,7 +169,9 @@ module Hlockey
     def new_games
       if @game_in_matchup != @matchup_game_amt
         # New game in matchups
-        @games.map! { new_game(_1.away, _1.home) }
+        prev_games = @games
+        @games = []
+        prev_games.each { new_game(_1.away, _1.home) }
         @game_in_matchup += 1
         return
       end
@@ -171,12 +181,17 @@ module Hlockey
       @game_in_matchup = 1
       @day += 1
 
+      if @infinite
+        new_matchups(@teams)
+        return
+      end
+
       case @day
       when 1..27
         @shuffled_division_pairs.each { new_matchups(_1, reverse: @day.even?) }
       when 28..37
         @shuffled_division_pairs.transpose.each_with_index do |pair, i|
-          @games << new_game(*pair, reverse: i.even?)
+          new_game(*pair, reverse: i.even?)
         end
         @shuffled_division_pairs.first.rotate!
       when 38
@@ -192,13 +207,17 @@ module Hlockey
         new_playoff_matchups
       when 41
         @champion_team = @playoff_teams.find(&:positive_record?)
-        @alerts << Message.SeasonChampion(@champion_team)
+        @alerts << Message.new(:season_champion, season: @season, team: @champion_team)
       end
     end
 
     def update_games
       @games_in_progress.each(&:update)
-      @games_in_progress = @games.select(&:in_progress?)
+
+      prev_in_progress_amt = @games_in_progress.length
+      @games_in_progress.select!(&:in_progress?)
+      return if @games_in_progress.length == prev_in_progress_amt
+
       @divisions.transform_values!(&method(:sort_teams_by_wins))
     end
 
@@ -208,12 +227,12 @@ module Hlockey
       new_matchups(@playoff_teams, rotate: false)
     end
 
-    # @param matchup_teams[Array<Team>]
+    # @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:)
+        new_game(matchup_teams[i], matchup_teams[-i - 1], reverse:)
       end
       matchup_teams.insert(1, matchup_teams.pop) if rotate
     end
@@ -222,10 +241,11 @@ module Hlockey
     # @param away [Team]
     # @param reverse [Boolean]
     def new_game(home, away, reverse: false)
-      teams = [home, away]
-      teams.reverse! if reverse
+      teams = reverse ? [away, home] : [home, away]
 
-      Game.new(*teams, @prng)
+      game = Game.new(*teams, @prng.rand)
+      @games << game
+      @games_in_progress << game
     end
 
     # @return [Array<Team>]