hlockey 5 → 6

data/lib/hlockey/league.rb

@@ -1,6 +1,7 @@
 require("hlockey/constants")
 require("hlockey/data")
 require("hlockey/game")
+require("hlockey/team")
 require("hlockey/utils")
 require("hlockey/version")
 
@@ -31,32 +32,69 @@ module Hlockey
     # @return [Array<Team>]
     attr_reader(:teams, :playoff_teams)
 
-    def initialize
-      @start_time, @divisions = Data.league
+    # @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
+
+      @divisions = divisions.transform_values { |teams| teams.map { Team.new(**_1) } }
+
       @day = 0
+
       @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.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
+      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 = 3
-      @matchup_game_amt = 3
+      @game_in_matchup = @matchup_game_amt = 3
+    end
+
+    # @return [Hash]
+    def to_h(simple: false)
+      res = {
+        start_time: @start_time.getutc.to_a.first(6).reverse,
+        divisions: @divisions.transform_values { |d| d.map { |t| t.to_h(simple:) } }
+      }
+
+      unless simple
+        # At this point, we don't need to pass simple to any of the to_h calls,
+        # because we know it is false
+        res[:last_update_time] = @last_update_time.getutc.to_a.first(6).reverse
+        res[:day] = @day
+        res[:games] = @games.map(&:to_h)
+        res[:games_in_progress] = @games_in_progress.map(&:to_h)
+        res[:alerts] = @alerts
+        res[:champion_team] = @champion_team&.name
+        res[:teams] = @teams.map(&:to_h)
+        res[:playoff_teams] = @playoff_teams.map(&:to_h)
+      end
+
+      res
     end
 
-    ##
     # Updates the league to the current state
     # This should be called whenever you need the current state of the league
     def update_state
@@ -94,12 +132,12 @@ module Hlockey
       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 }
+        (@teams - @playoff_teams).each { |team| team.status = :partying }
         return
       end
 
       set_to_qualify = playoff_qualifiers
-      @teams[...-1].each_with_index do |team, i|
+      @teams.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
 
@@ -123,7 +161,7 @@ module Hlockey
     def new_games
       if @game_in_matchup != @matchup_game_amt
         # New game in matchups
-        @games.map! { |game| new_game(game.away, game.home) }
+        @games.map! { new_game(_1.away, _1.home) }
         @game_in_matchup += 1
         return
       end
@@ -135,7 +173,7 @@ module Hlockey
 
       case @day
       when 1..27
-        @shuffled_division_pairs.each { |p| new_matchups(p, reverse: @day.even?) }
+        @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?)
@@ -143,62 +181,29 @@ module Hlockey
         @shuffled_division_pairs.first.rotate!
       when 38
         @matchup_game_amt = 5
-        @playoff_teams = sort_teams_by_wins(playoff_qualifiers).map do |team|
-          cloned_team = team.clone
+        @playoff_teams = sort_teams_by_wins(playoff_qualifiers).map do
+          cloned_team = _1.clone
           cloned_team.status = :playoffs
           cloned_team
         end
         new_playoff_matchups
       when 39, 40
-        @playoff_teams.select! { |team| team.wins > team.losses }
+        @playoff_teams.select!(&:positive_record?)
         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 @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
-
-        @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
+        @champion_team = @playoff_teams.find(&:positive_record?)
+        @alerts << Message.SeasonChampion(@champion_team)
       end
     end
 
     def update_games
       @games_in_progress.each(&:update)
-      @games_in_progress = @games.select(&:in_progress)
+      @games_in_progress = @games.select(&:in_progress?)
       @divisions.transform_values!(&method(:sort_teams_by_wins))
     end
 
     def new_playoff_matchups
-      @playoff_teams.each do |team|
-        team.wins = 0
-        team.losses = 0
-      end
+      @playoff_teams.each { _1.wins = _1.losses = 0 }
 
       new_matchups(@playoff_teams, rotate: false)
     end
@@ -208,7 +213,7 @@ module Hlockey
     # @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)
+        @games << new_game(matchup_teams[i], matchup_teams[-i - 1], reverse:)
       end
       matchup_teams.insert(1, matchup_teams.pop) if rotate
     end
@@ -225,7 +230,7 @@ module Hlockey
 
     # @return [Array<Team>]
     def playoff_qualifiers
-      top_divs = game_divisions.values.map { |teams| sort_teams_by_wins(teams).first }
+      top_divs = @divisions.values.map { sort_teams_by_wins(_1).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)
@@ -233,17 +238,9 @@ module Hlockey
       top_divs + rest
     end
 
+    # A stable sort of the teams in the array by their wins
     # @param teams [Array<Team>]
     # @return [Array<Team>]
-    def sort_teams_by_wins(teams)
-      # 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
+    def sort_teams_by_wins(teams) = teams.sort_by.with_index { |t, i| [-t.wins, i] }
   end
 end

data/lib/hlockey/message.rb

@@ -33,12 +33,12 @@ module Hlockey
       # To control how this colors things, see #colorize=
       # @param obj [Team, Team::Player, Team::Stadium]
       # @return String
-      def color(obj)
+      def color(obj) =
         @colorize.call(obj.instance_of?(Team) ? obj.color : obj.team.color, obj.to_s)
-      end
 
-      # These are messages logged to game streams
+      # These are messages logged to game streams / league alerts
       [
+        # Game stream messages
         %i[StartOfGame],
         %i[EndOfGame winning_team],
         %i[StartOfPeriod period],
@@ -51,93 +51,96 @@ module Hlockey
         %i[Partying player],
         %i[FightStarted home_player away_player],
         %i[FightAttack attacking_player defending_player blocked],
-        %i[PlayerJoinedFight team player],
+        %i[PlayerJoinedFight player],
         %i[FightEnded],
         %i[MoraleChange team amount],
         %i[ChickenedOut prev_player next_player],
         %i[InclineFavors team],
         %i[StarsAlign team],
-        %i[WavesWashedAway prev_player next_player]
+        %i[WavesWashedAway prev_player next_player],
+        %i[ImmaterialDodge player hitting_player],
+        # League alert messages
+        %i[SeasonChampion team]
       ].each do |event, *fields|
         define_method(event) { |*data| new(event, fields, data) }
       end
 
       # These are messages used elsewhere
 
-      def SeasonDay(day)
-        "Season #{VERSION} day #{day}"
-      end
+      def SeasonDay(day) = "Season #{VERSION} day #{day}"
 
-      def SeasonStarts(time)
+      def SeasonStarts(time) =
         time.strftime("Season #{VERSION} starts at %H:%M, %A, %B %d (%Z).")
-      end
 
-      def SeasonChampion(team)
-        "Your season #{VERSION} champions are the #{team}!"
-      end
-
-      def NoGames
+      def NoGames =
         "no games right now. it is the offseason. join the Hlockey Discord for updates"
-      end
     end
 
-    def to_s
+    def to_s(do_color: true)
+      c = -> { color(_1, do_color:) }
+
       case @event
       when :StartOfGame
         "Hocky!"
       when :EndOfGame
-        "Game over.\n#{color(@winning_team)} win!"
+        "Game over.\n#{c.call(@winning_team)} win!"
       when :StartOfPeriod
         "Start#{of_period}"
       when :EndOfPeriod
-        "End#{of_period}#{score}"
+        "End#{of_period}#{score(do_color:)}"
       when :FaceOff
-        "#{color(@winning_player)} wins the faceoff!#{possession_change}"
+        "#{c.call(@winning_player)} wins the faceoff!#{possession_change(do_color:)}"
       when :Hit
-        str = "#{color(@defender)} hits #{color(@puck_holder)}"
-        str += takes + score_chance if @puck_taken
+        str = "#{c.call(@defender)} hits #{c.call(@puck_holder)}"
+        str += takes(do_color:) + score_chance if @puck_taken
         str
       when :Pass
-        str = "#{color(@sender)} passes to #{color(@receiver)}."
+        str = "#{c.call(@sender)} passes to #{c.call(@receiver)}."
         unless @interceptor.nil?
-          str += "..\nIntercepted by #{color(@interceptor)}!#{possession_change}"
+          str += "..\nIntercepted by #{c.call(@interceptor)}!" +
+                 possession_change(do_color:)
         end
         str += score_chance
         str
       when :ShootScore
-        "#{shot} and scores!#{score}"
+        "#{shot(do_color:)} and scores!#{score(do_color:)}"
       when :ShootBlock
-        "#{shot}...\n#{color(@blocker)} blocks the shot#{takes}#{score_chance}"
+        "#{shot(do_color:)}...\n#{c.call(@blocker)} blocks the shot" +
+          takes(do_color:) + score_chance
       when :Partying
-        "#{color(@player)} is partying!"
+        "#{c.call(@player)} is partying!"
       when :FightStarted
-        "#{color(@home_player)} and #{color(@away_player)} start fighting!"
+        "#{c.call(@home_player)} and #{c.call(@away_player)} " \
+          "start fighting!"
       when :FightAttack
-        str = "#{color(@attacking_player)} punches #{color(@defending_player)}!"
-        str += "\n#{color(@defending_player)} blocks the punch!" if @blocked
+        def_player = c.call(@defending_player)
+        str = "#{c.call(@attacking_player)} punches #{def_player}!"
+        str += "\n#{def_player} blocks the punch!" if @blocked
         str
       when :PlayerJoinedFight
-        "#{color(@player)} from #{color(@team)} joins the fight!"
+        "#{c.call(@player)} from #{c.call(@player.team)} joins the fight!"
       when :FightEnded
         "The fight has ended."
       when :MoraleChange
-        "#{color(@team)} #{@amount.negative? ? "loses" : "gains"} #{@amount.abs} morale."
+        "#{c.call(@team)} #{@amount.negative? ? "loses" : "gains"} #{@amount.abs} morale."
       when :ChickenedOut
-        "#{color(@prev_player)} chickened out!#{replaces("game")}"
+        "#{c.call(@prev_player)} chickened out!#{replaces("game", do_color:)}"
       when :InclineFavors
-        "The incline favors #{color(@team)}."
+        "The incline favors #{c.call(@team)}."
       when :StarsAlign
-        "The stars align for #{color(@team)}. They get half a goal."
+        "The stars align for #{c.call(@team)}. They get half a goal."
       when :WavesWashedAway
-        "#{color(@prev_player)} is washed away by the waves...#{replaces}"
+        "#{c.call(@prev_player)} is washed away by the waves...#{replaces(do_color:)}"
+      when :ImmaterialDodge
+        "#{c.call(@hitting_player)} goes right through #{c.call(@player)}!"
+      when :SeasonChampion
+        "Your season #{VERSION} champions are the #{c.call(@team)}!"
       end
     end
 
     private
 
-    def color(obj)
-      self.class.color(obj)
-    end
+    def color(obj, do_color: true) = do_color ? self.class.color(obj) : obj.to_s
 
     def score_chance
       return "" if @shooting_chance.nil?
@@ -155,28 +158,23 @@ module Hlockey
       "\nChance of scoring: #{chance_str} (#{@shooting_chance})"
     end
 
-    def of_period
-      " of period #{@period}."
-    end
+    def of_period = " of period #{@period}."
 
-    def score
-      "\n#{color(@home)} #{@home_score.round(2)}, #{color(@away)} #{@away_score.round(2)}"
-    end
+    def score(do_color: true) =
+      "\n#{color(@home, do_color:)} #{@home_score.round(2)}, " \
+      "#{color(@away, do_color:)} #{@away_score.round(2)}"
 
-    def shot
-      "#{color(@shooter)} takes a#{"n audacious" if @audacity} shot"
-    end
+    def shot(do_color: true) =
+      "#{color(@shooter, do_color:)} takes a#{"n audacious" if @audacity} shot"
 
-    def takes
-      @puck_taken ? " and takes the puck!#{possession_change}" : "!"
-    end
+    def takes(do_color: true) =
+      @puck_taken ? " and takes the puck!#{possession_change(do_color:)}" : "!"
 
-    def possession_change
-      "\n#{color(@new_puck_team)} have possession."
-    end
+    def possession_change(do_color: true) =
+      "\n#{color(@new_puck_team, do_color:)} have possession."
 
-    def replaces(period = nil)
-      str = "\n#{color(@next_player)} replaces them"
+    def replaces(period = nil, do_color: true)
+      str = "\n#{color(@next_player, do_color:)} replaces them"
       str += " for the rest of the #{period}." unless period.nil?
       str
     end

data/lib/hlockey/mod/fencebuilder.rb

@@ -0,0 +1,16 @@
+require("hlockey/mod/moddable")
+
+module Hlockey
+  module Mod
+    ##
+    # The player this mod is applied to only gets swapped into offense
+    class Fencebuilder
+      include(Moddable)
+
+      DESCRIPTION = "This player can only play offense.".freeze
+
+      def on_swap(into_roster, pos, prev_pos, _prng) =
+        fence_swap(into_roster, pos, prev_pos)
+    end
+  end
+end

data/lib/hlockey/mod/fencedestroyer.rb

@@ -0,0 +1,16 @@
+require("hlockey/mod/moddable")
+
+module Hlockey
+  module Mod
+    ##
+    # The player this mod is applied to only gets swapped into defense
+    class Fencedestroyer
+      include(Moddable)
+
+      DESCRIPTION = "This player can only play defense.".freeze
+
+      def on_swap(into_roster, pos, prev_pos, _prng) =
+        fence_swap(into_roster, pos, prev_pos, type: :destroyer)
+    end
+  end
+end

data/lib/hlockey/mod/handholding.rb

@@ -0,0 +1,55 @@
+require("hlockey/mod/moddable")
+
+module Hlockey
+  module Mod
+    ##
+    # Specified player follows the player this mod is applied to
+    # when they are swapped in/out
+    class Handholding
+      include(Moddable)
+
+      DESCRIPTION = "This player is holding another player's hand.".freeze
+
+      # @param other_player [String] name of other player
+      def initialize(player, other_player)
+        super(player)
+        @other_player = other_player
+      end
+
+      def to_data = [to_s, @other_player.to_s]
+
+      def on_swap(into_roster, pos, _prev_pos, prng)
+        unless @other_player.is_a?(Team::Player)
+          @other_player = @team.players.find { _1.name == @other_player }
+        end
+
+        if into_roster
+          prev_pos = @team.shadows.index(@other_player)
+          return if prev_pos.nil?
+
+          other_pos = with_deleted(@team.roster.keys, pos).sample(random: prng)
+
+          @team.shadows[prev_pos] = @team.roster[other_pos]
+          @team.roster[other_pos] = @other_player
+          return
+        end
+
+        prev_pos = @team.roster.key(@other_player)
+        return if prev_pos.nil?
+
+        other_pos = with_deleted(@team.shadows.each_index.to_a, pos).sample(random: prng)
+
+        @team.roster[prev_pos] = @team.shadows[other_pos]
+        @team.shadows[other_pos] = @other_player
+      end
+
+      private
+
+      # For `on_swap`, because array.delete doesn't return the array for no reason
+      def with_deleted(array, object)
+        array.delete(object)
+        array
+      end
+    end
+  end
+end

data/lib/hlockey/mod/immaterial.rb

@@ -0,0 +1,26 @@
+require("hlockey/message")
+require("hlockey/mod/moddable")
+
+module Hlockey
+  module Mod
+    ##
+    # The player this mod is applied to has a chance of avoiding hits
+    # by temporarily losing their physical form
+    class Immaterial
+      include(Moddable)
+
+      DESCRIPTION = "This player may be a hallucination.".freeze
+
+      def on_got_hit(game, hitting_player)
+        return if game.prng.rand(3).zero?
+
+        if game.pre_tmp_change_stats[@player].nil?
+          game.pre_tmp_change_stats[@player] = @player.stats.clone
+        end
+        @player.stats[:defense] += 0.5
+
+        Message.ImmaterialDodge(@player, hitting_player)
+      end
+    end
+  end
+end

data/lib/hlockey/mod/locked.rb

@@ -0,0 +1,22 @@
+require("hlockey/mod/moddable")
+
+module Hlockey
+  module Mod
+    ##
+    # This player can not swap positions.
+    class Locked
+      include(Moddable)
+
+      DESCRIPTION = "This player can not swap positions.".freeze
+
+      def on_swap(into_roster, pos, prev_pos, _prng) =
+        if into_roster
+          @team.roster[pos] = @team.shadows[prev_pos]
+          @team.shadows[prev_pos] = @player
+        else
+          @team.shadows[pos] = @team.roster[prev_pos]
+          @team.roster[prev_pos] = @player
+        end
+    end
+  end
+end

data/lib/hlockey/mod/moddable.rb

@@ -0,0 +1,49 @@
+require("hlockey/selfdescribable")
+
+module Hlockey
+  module Mod
+    ##
+    # Module with needed methods for mods, that every mod includes
+    # All methods starting with "on" represent player events
+    module Moddable
+      include(SelfDescribable)
+
+      DESCRIPTION = "A mod with no description.".freeze # Default description
+
+      # If the mod has no extra parameters, same as #to_s
+      # If it has extra parameters, returns an array with #to_s as the first element,
+      # and the other parameters as the rest of the elements.
+      # Mods that accept parameters should implement the array version themselves,
+      # as in the module here it is simply an alias.
+      alias to_data to_s
+
+      def initialize(player)
+        @player = player
+        @team = player.team
+      end
+
+      def on_swap(into_roster, pos, prev_pos, prng) end
+
+      def on_action(game) end
+
+      def on_got_hit(game, hitting_player) end
+
+      def on_join_fight() end
+
+      private
+
+      def fence_swap(into_roster, pos, prev_pos, type: :builder)
+        return unless into_roster
+
+        new_pos_hash = { ldef: :lwing, goalie: :center, rdef: :rwing }
+        new_pos_hash = new_pos_hash.invert unless type == :builder
+        new_pos = new_pos_hash[pos]
+        return if new_pos.nil?
+
+        @team.roster[pos] = @team.shadows[prev_pos]
+        @team.shadows[prev_pos] = @team.roster[new_pos]
+        @team.roster[new_pos] = @player
+      end
+    end
+  end
+end

data/lib/hlockey/mod/nonconfrontational.rb

@@ -0,0 +1,17 @@
+require("hlockey/mod/moddable")
+
+module Hlockey
+  module Mod
+    ##
+    # The first player in the shadows will join fights instead of this player,
+    # if they do not also have the mod.
+    class Nonconfrontational
+      include(Moddable)
+
+      DESCRIPTION = "This player tries to avoid fights.".freeze
+
+      def on_join_fight =
+        @team.shadows.select { |player| player.mods.none? { _1.is_a?(self.class) } }.first
+    end
+  end
+end

data/lib/hlockey/mod/powernapper.rb

@@ -0,0 +1,46 @@
+require("hlockey/mod/moddable")
+require("hlockey/actions")
+
+module Hlockey
+  module Mod
+    ##
+    # Player has James stats added to their own at random
+    class Powernapper
+      include(Moddable)
+      include(Actions)
+
+      DESCRIPTION = "This player gets temporary stat boosts by powernapping.".freeze
+
+      def initialize(player)
+        super
+        @currently_boosted_for = -1
+      end
+
+      def on_action(game)
+        if @currently_boosted_for.negative?
+          return unless random_event_occurs?(prng: game.prng)
+
+          change_stats(game)
+        end
+        @currently_boosted_for += 1
+        return if @currently_boosted_for < 5
+
+        change_stats(game, reset: true)
+        @currently_boosted_for = -1
+      end
+
+      private
+
+      def change_stats(game, reset: false)
+        stat_change = { offense: 0.5, defense: 1.0 } # James stats (excluding 0 agility)
+        stat_change.transform_values!(&:-@) if reset
+
+        pre_tmp_change_stats = game.pre_tmp_change_stats[@player]
+        stat_change.each do |stat, change|
+          @player.stats[stat] += change
+          pre_tmp_change_stats[stat] += change unless pre_tmp_change_stats.nil?
+        end
+      end
+    end
+  end
+end

data/lib/hlockey/mod/punchy.rb

@@ -0,0 +1,17 @@
+require("hlockey/mod/moddable")
+
+module Hlockey
+  module Mod
+    ##
+    # Player can get into a fight at any time
+    class Punchy
+      include(Moddable)
+      include(Actions)
+
+      DESCRIPTION = "This player may randomly start fights.".freeze
+
+      def on_action(game) =
+        random_event_occurs?(prng: game.prng) && game.start_fight(@player)
+    end
+  end
+end