hlockey 5 → 7

data/lib/hlockey/game.rb

@@ -1,6 +1,6 @@
-require("hlockey/game/actions")
 require("hlockey/game/fight")
 require("hlockey/game/weather")
+require("hlockey/actions")
 require("hlockey/constants")
 require("hlockey/message")
 require("hlockey/utils")
@@ -14,9 +14,12 @@ 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
+    attr_reader(:score)
+
     # @return [Team::Stadium] the stadium this game is located at
     attr_reader(:stadium)
 
@@ -26,11 +29,9 @@ module Hlockey
     # @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)
+    alias in_progress? in_progress
 
     # @return [Integer] what period the game is in
     attr_reader(:period)
@@ -38,20 +39,31 @@ module Hlockey
     # @return [Fight, nil] the current fight, if there is any
     attr_reader(:fight)
 
+    # @return [Hash<Player => Hash<Symbol => Number>>] stats of players before changes
+    attr_reader(:pre_tmp_change_stats)
+
     # @param home [Team]
     # @param away [Team]
-    # @param prng [Random] should be League#prng
-    def initialize(home, away, prng)
+    # @param rng_seed [Integer] number to seed the game's RNG with
+    # @param weather [Class<Weatherable>]
+    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).new(self)
-      @stream = [Message.StartOfGame]
+
+      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.new(:game_start)]
       @faceoff = true
       @faceoff_won = false
       @team_with_puck = nil
@@ -60,38 +72,140 @@ module Hlockey
       @shooting_chance = 0
       @fight = nil
       @fight_chance = 0
-      @pre_morale_change_stats = {}
-      @partying_teams = [@home, @away].select { |t| t.status == :partying }
+      @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 [String]
-    def to_s
-      "#{Message.color(@home)} vs #{Message.color(@away)}"
+    # @return [Hash]
+    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(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.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) }
 
       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)
@@ -128,86 +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)
-        next if @pre_morale_change_stats[player].nil?
+        @stream << Message.new(:game_partying, player:)
+        next if @pre_tmp_change_stats[player].nil?
 
-        @pre_morale_change_stats[player][stat] += 0.1
+        @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]
-      @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
-      @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_morale_change_stats.each { |player, stats| player.stats = stats }
+        @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
 
@@ -237,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)
@@ -254,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])
 
@@ -265,66 +323,74 @@ 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
 
-    def start_fight
-      @fight = Fight.new(self)
-      @stream << Message.FightStarted(@fight.players[:home].first,
-                                      @fight.players[:away].first)
-    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]
     def change_morale(team, amount)
       return if amount.zero?
 
       team.roster.each_value do |player|
-        if @pre_morale_change_stats[player].nil?
-          @pre_morale_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]
-    def puck_holder
-      @team_with_puck.roster[@puck_holder_pos]
-    end
+    # @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)
     end
 
     # @return [Symbol]
-    def defensive_pos
-      Utils.weighted_random(weights(@shooting_chance < 3), @prng)
-    end
+    def defensive_pos = Utils.weighted_random(weights(@shooting_chance < 3), @prng)
 
     # @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