hlockey 4 → 6

data/lib/hlockey/message.rb

@@ -22,21 +22,23 @@ module Hlockey
     end
 
     class << self
-      # Variable/method controlling how coloring players/teams is done
+      # Variable controlling how coloring players/teams is done
+      # Set this to a Proc that takes params `color` and `string`,
+      # and returns the colorized string.
+      # `color` will be in hex format, for example "#ffffff"
       # The default is to not color things at all
-
       attr_writer(:colorize)
 
-      # @param obj [Team, Player]
+      # Colors Team/associated classes in their team color
+      # To control how this colors things, see #colorize=
+      # @param obj [Team, Team::Player, Team::Stadium]
       # @return String
-      def color(obj)
-        col = obj.instance_of?(Team) ? obj.color : obj.team.color
-
-        @colorize.call(col, obj.to_s)
-      end
+      def color(obj) =
+        @colorize.call(obj.instance_of?(Team) ? obj.color : obj.team.color, obj.to_s)
 
-      # 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],
@@ -49,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?
@@ -153,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

data/lib/hlockey/mod.rb

@@ -0,0 +1,25 @@
+require("hlockey/mod/fencebuilder")
+require("hlockey/mod/fencedestroyer")
+require("hlockey/mod/handholding")
+require("hlockey/mod/immaterial")
+require("hlockey/mod/locked")
+require("hlockey/mod/powernapper")
+require("hlockey/mod/punchy")
+require("hlockey/mod/nonconfrontational")
+
+module Hlockey
+  ##
+  # A mod changes how a Player interacts with/responds to events
+  module Mod
+    MODS = [
+      Fencebuilder,
+      Fencedestroyer,
+      Handholding,
+      Immaterial,
+      Locked,
+      Powernapper,
+      Punchy,
+      Nonconfrontational
+    ].freeze
+  end
+end

data/lib/hlockey/selfdescribable.rb

@@ -0,0 +1,9 @@
+module Hlockey
+  ##
+  # For things that name themselves by class name
+  module SelfDescribable
+    def to_s
+      self.class.to_s.split("::").last
+    end
+  end
+end

data/lib/hlockey/team/player.rb

@@ -0,0 +1,58 @@
+require("hlockey/mod")
+require("hlockey/utils")
+
+module Hlockey
+  class Team
+    ##
+    # A player on a team
+    class Player
+      attr_accessor(:team, :mods, :stats)
+      attr_reader(:name)
+
+      alias to_s name
+
+      # @param name [String]
+      # @param team [Team]
+      # @param stats [Hash<:offense, :defense, :agility => Numeric>]
+      # @param mods [Array]
+      def initialize(name:, team:, stats:, mods: [])
+        @name = name
+        @team = team
+        @stats = stats
+        @mods = mods.map do |mod|
+          if mod.is_a?(Array)
+            Mod::MODS.find { _1.to_s == "Hlockey::Mod::#{mod.first}" }.new(self,
+                                                                           *mod[1..])
+          else
+            Mod::MODS.find { _1.to_s == "Hlockey::Mod::#{mod}" }.new(self)
+          end
+        end
+      end
+
+      # @return [Hash]
+      def to_h(simple: false)
+        res = {
+          name: @name,
+          stats: @stats
+        }
+        res[:team] = @team.to_s unless simple
+        res[:mods] = @mods.map(&:to_data) unless simple && @mods.empty?
+
+        res
+      end
+
+      # @return [Hash<String => String>] #stats but better for displaying
+      def stat_display =
+        Utils.hash_display_keys(
+          @stats.transform_values { _1.round(2).to_s.ljust(4, "0") }
+        )
+
+      # @param action [Symbol] method to call on each mod
+      def mods_do(action, *args)
+        res = nil
+        @mods.each { res ||= _1.send(action, *args) }
+        res
+      end
+    end
+  end
+end

data/lib/hlockey/team/stadium.rb

@@ -0,0 +1,52 @@
+module Hlockey
+  class Team
+    ##
+    # A Team's stadium
+    class Stadium
+      # @return [String]
+      attr_reader(:full_name, :hlockey_type)
+
+      # @return [String, nil]
+      attr_reader(:nickname, :description)
+
+      # @return [Team]
+      attr_accessor(:team)
+
+      # @param full_name [String]
+      # @param hlockey_type [String]
+      # @param nickname [String, nil]
+      # @param description [String, nil]
+      # @param team [Team, nil]
+      def initialize(full_name:, hlockey_type:,
+                     nickname: nil, description: nil, team: nil)
+        @full_name = full_name
+        @hlockey_type = hlockey_type
+        @nickname = nickname
+        @description = description
+        @team = team
+      end
+
+      # @return [Hash]
+      def to_h(simple: false)
+        res = {
+          nickname: @nickname,
+          full_name: @full_name,
+          description: @description,
+          hlockey_type: @hlockey_type
+        }
+        return res.compact if simple
+
+        res[:team] = @team.to_s
+
+        res
+      end
+
+      # The name (and nickname, if it exists) of the stadium
+      # Used for quickly showing which Stadium a Game is taking place at
+      # @return [String]
+      def to_s
+        @nickname.nil? ? @full_name : "#{@full_name} (\"#{@nickname}\")"
+      end
+    end
+  end
+end