hlockey 5 → 7

data/lib/hlockey/mod/moddable.rb

@@ -0,0 +1,70 @@
+require("hlockey/message")
+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)
+
+      attr_writer(:game)
+
+      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) end
+
+      def on_action() end
+
+      # May return truthy value to signal that hitting player should not try to take puck
+      def on_got_hit(hitting_player) end
+
+      # May return a different player to join the fight instead of this one
+      def on_join_fight() end
+
+      private
+
+      # Makes a new message from params, adds it to the game stream if there is a game
+      def send_game_message(...)
+        @game.stream << Message.new(...) unless @game.nil?
+      end
+
+      # Handles the on_swap event for Fencebuilder, Fencedestroyer mods
+      # @param into_roster [Boolean]
+      # @param pos [Symbol]
+      # @param prev_pos [Symbol]
+      # @param type [:builder | :destroyer]
+      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?
+
+        swap_player = @team.roster[new_pos]
+        @team.roster[pos] = @team.shadows[prev_pos]
+        @team.shadows[prev_pos] = swap_player
+        @team.roster[new_pos] = @player
+
+        send_game_message(:mod_fence_event, type:, player: @player, swap_player:)
+      end
+
+      # @return [Utils::Rng, Random] the object to use for RNG
+      def prng = @game&.prng || Random.new
+    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,50 @@
+require("hlockey/mod/moddable")
+require("hlockey/actions")
+
+module Hlockey
+  module Mod
+    ##
+    # Player has James stats added to their own at random for 5 actions
+    # These 5 actions carry over between games
+    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
+        if @currently_boosted_for.negative?
+          return unless random_event_occurs?(prng:)
+
+          change_stats
+        end
+        @currently_boosted_for += 1
+        return if @currently_boosted_for < 5
+
+        change_stats(reset: true)
+        @currently_boosted_for = -1
+      end
+
+      private
+
+      def change_stats(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
+
+        send_game_message(reset ? :mod_powernap_end : :mod_powernap_start,
+                          player: @player)
+      end
+    end
+  end
+end

data/lib/hlockey/mod/punchy.rb

@@ -0,0 +1,21 @@
+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
+        return unless random_event_occurs?(prng:)
+
+        send_game_message(:mod_punchy_event, player: @player)
+        @game.start_fight(@player)
+      end
+    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,7 @@
+module Hlockey
+  ##
+  # For things that name themselves by class name
+  module SelfDescribable
+    def to_s = self.class.to_s.split("::").last
+  end
+end

data/lib/hlockey/team/player.rb

@@ -1,3 +1,4 @@
+require("hlockey/mod")
 require("hlockey/utils")
 
 module Hlockey
@@ -5,74 +6,55 @@ module Hlockey
     ##
     # A player on a team
     class Player
-      attr_accessor(:team, :stats)
-      attr_reader(:to_s)
+      attr_accessor(:team, :mods, :stats)
+      attr_reader(:name)
 
-      @@cached_chain = nil # Must be class var to avoid getting dumped to YAML
+      alias to_s name
 
+      # @param name [String]
       # @param team [Team]
-      # @param prng [#rand]
-      def initialize(team, prng = Random)
-        @to_s = make_name(prng)
+      # @param stats [Hash<:offense, :defense, :agility => Numeric>]
+      # @param mods [Array]
+      def initialize(name:, team:, stats:, mods: [])
+        @name = name
         @team = team
-        # Generate stats
-        @stats = {}
-        %i[offense defense agility].each { |stat| @stats[stat] = prng.rand * 5 }
-      end
-
-      # @return [Hash<String => String>] #stats but better for displaying
-      def stat_display
-        Utils.hash_display_keys(
-          @stats.transform_values { |stat| stat.round(2).to_s.ljust(4, "0") }
-        )
+        @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
 
-      private
-
-      def make_name(prng)
-        Array.new(2) do
-          combination = "__"
-          next_letter = ""
-          result = ""
-
-          10.times do
-            next_letters = name_chain[combination]
-            break if next_letters.nil?
+      # @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?
 
-            cumulative_weights = []
-            next_letters.each_value do |v|
-              cumulative_weights << v + (cumulative_weights.last or 0)
-            end
-
-            next_letter = Utils.weighted_random(next_letters, prng)
-            break if next_letter == "_"
-
-            result += next_letter
-            combination = combination[1] + next_letter
-          end
-
-          result
-        end.join(" ")
+        res
       end
 
-      def name_chain
-        if @@cached_chain.nil?
-          @@cached_chain = {}
-          File.open(
-            File.expand_path("../../data/external/names.txt", __dir__)
-          ).each do |n|
-            name = "__#{n.chomp}__"
-            (name.length - 3).times do |i|
-              combination = name[i, 2]
-              next_letter = name[i + 2]
-              @@cached_chain[combination] ||= {}
-              @@cached_chain[combination][next_letter] ||= 0
-              @@cached_chain[combination][next_letter] += 1
-            end
-          end
-        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") }
+        )
 
-        @@cached_chain
+      # Calls a method on every mod this player has
+      # @param action [Symbol] method to call on each mod
+      # @param *args [Object] any arguments to pass to the mods
+      # @return [Object] the first non-nil return value given from a mod, if any
+      def mods_do(action, *args)
+        res = nil
+        @mods.each { res ||= _1.send(action, *args) }
+        res
       end
     end
   end

data/lib/hlockey/team/stadium.rb

@@ -17,7 +17,8 @@ module Hlockey
       # @param nickname [String, nil]
       # @param description [String, nil]
       # @param team [Team, nil]
-      def initialize(full_name, hlockey_type, nickname: nil, description: nil, team: nil)
+      def initialize(full_name:, hlockey_type:,
+                     nickname: nil, description: nil, team: nil)
         @full_name = full_name
         @hlockey_type = hlockey_type
         @nickname = nickname
@@ -25,17 +26,19 @@ module Hlockey
         @team = team
       end
 
-      # The Stadium as a Hash.
-      # nil properties are removed, as well as #team
-      # Intended to be used as an easy way to get all relevant stadium info at once.
       # @return [Hash]
-      def to_h
-        {
+      def to_h(simple: false)
+        res = {
           nickname: @nickname,
           full_name: @full_name,
           description: @description,
           hlockey_type: @hlockey_type
-        }.compact
+        }
+        return res.compact if simple
+
+        res[:team] = @team.to_s
+
+        res
       end
 
       # The name (and nickname, if it exists) of the stadium

data/lib/hlockey/team.rb

@@ -6,61 +6,77 @@ module Hlockey
   # A team in the league
   # Created by League when data is loaded
   class Team
-    attr_accessor(:wins, :losses, :roster, :shadows, :status, :to_s)
-    attr_reader(:emoji, :color, :motto, :stadium)
+    attr_accessor(:wins, :losses, :roster, :shadows, :status)
+    attr_reader(:name, :emoji, :color, :motto, :stadium, :evolutions)
 
-    # random is only used if roster or shadows is nil
-    def initialize(name, color, emoji,
-                   stadium: nil, roster: nil, shadows: nil, random: Random)
-      @to_s = name
+    alias to_s name
+
+    # @param name [String]
+    # @param color [String]
+    # @param emoji [String]
+    # @param motto [String]
+    # @param stadium [Hash<:full_name, :hlockey_type, :nickname, :description => String>]
+    # @param roster [Hash<:lwing, :center, :rwing, :ldef, :goalie, :rdef => Hash>]
+    # @param shadows [Array<Hash>]
+    def initialize(name:, color:, emoji:, motto:, stadium:, roster:, shadows:,
+                   evolutions: 0)
+      @name = name
       @color = color
       @emoji = emoji
+      @motto = motto
+      @evolutions = evolutions
 
-      if stadium.nil?
-        # default stadium
-        @stadium = Stadium.new(
-          "Hlockey General Stadium", "Ice",
-          description: "A stadium for teams with no home stadium to use.",
-          team: self
-        )
-      else
-        @stadium = stadium.dup
-        @stadium.team = self
+      @stadium = Stadium.new(team: self, **stadium)
+
+      @roster = roster.transform_values { Player.new(**_1, team: self) }
+      @shadows = shadows.map { Player.new(**_1, team: self) }
+
+      @status = :in_contention
+      @wins = @losses = 0
+    end
+
+    # @return [Hash]
+    def to_h(simple: false)
+      res = {
+        name: @name,
+        color: @color,
+        emoji: @emoji,
+        motto: @motto,
+        evolutions: @evolutions,
+        stadium: @stadium.to_h(simple:),
+        roster: @roster.transform_values { _1.to_h(simple:) },
+        shadows: @shadows.map { _1.to_h(simple:) }
+      }
+
+      res.delete(:evolutions) if simple && res[:evolutions].zero?
+
+      unless simple
+        res[:status] = @status
+        res[:wins] = @wins
+        res[:losses] = @losses
       end
 
-      @roster = if roster.nil?
-                  # randomly generate roster
-                  %i[lwing center rwing ldef goalie rdef].each_with_object({}) do |pos, h|
-                    h[pos] = Player.new(self, random)
-                  end
-                else
-                  roster
-                end
-      @shadows = shadows.nil? ? Array.new(3) { Player.new(self, random) } : shadows
-
-      @wins = 0
-      @losses = 0
+      res
     end
 
     # @return [String] wins/losses in string representation
-    def w_l
-      "#{@wins}-#{@losses}"
-    end
+    def w_l = "#{@wins}-#{@losses}"
+
+    # @return [Boolean]
+    def positive_record? = @wins > @losses
+
+    # @return [Array<Player>]
+    def players = @roster.values + @shadows
 
     # @return [Symbol] the position of the worst player on the roster
-    def worst_player_pos
-      @roster.transform_values { |p| p.stats.values.reduce(:+) }
-             .min_by { |_, v| v }
-             .first
-    end
+    def worst_player_pos =
+      @roster.transform_values { |v| v.stats.values.sum }.min_by { |_, v| v }.first
 
     # @return [Hash<String => Player>] #roster, but with keys better for displaying
-    def roster_display
-      @roster.transform_keys(&Hlockey::Team.method(:pos_name))
-    end
+    def roster_display = @roster.transform_keys(&self.class.method(:pos_name))
 
     # Takes symbol from Team roster & converts it to full position name
-    def self.pos_name(pos)
+    def self.pos_name(pos) =
       case pos
       when :lwing
         "Left wing"
@@ -73,6 +89,5 @@ module Hlockey
       else
         pos.capitalize.to_s
       end
-    end
   end
 end

data/lib/hlockey/utils.rb

@@ -1,13 +1,45 @@
 module Hlockey
   ##
-  # Utility methods to help with various Hlockey related tasks
+  # Utilities to help with various Hlockey related tasks
   module Utils
+    ##
+    # Lehmer random number generator,
+    # to avoid incompatabilities in RNG between Ruby implementations.
+    # From https://en.wikipedia.org/wiki/Lehmer_random_number_generator#Sample_C99_code.
+    class Rng
+      MOD_VAL = 0x7fffffff
+
+      # @return [Integer]
+      attr_reader(:state)
+
+      # @param seed [Integer]
+      def initialize(seed)
+        seed = seed.zero? ? 1 : seed.abs
+        seed %= MOD_VAL if seed >= MOD_VAL
+
+        @state = seed
+      end
+
+      # @param upper_bound [Numeric, Range, nil] max value from RNG
+      # @return [Numeric]
+      def rand(bound = nil)
+        if bound.is_a?(Range)
+          start = bound.begin || 0
+          return rand(bound.end.nil? ? nil : bound.end - start) + start
+        end
+
+        @state = @state * 48_271 % MOD_VAL
+        return @state if bound.nil? || bound.zero?
+
+        @state % bound
+      end
+    end
+
     # Transforms hash keys to be better for displaying the information in the hash
     # @param hash [Hash<#to_s => Object>]
     # @return [Hash<String => Object>] the new hash
-    def self.hash_display_keys(hash)
-      hash.transform_keys { |key| key.to_s.capitalize.gsub("_", " ") }
-    end
+    def self.hash_display_keys(hash) =
+      hash.transform_keys { |key| key.to_s.capitalize.gsub("_", " ") }.compact
 
     # Does a weighted random with a hash,
     # where the keys are elements being randomly selected and the values are the weights

data/lib/hlockey/version.rb

@@ -1,3 +1,3 @@
 module Hlockey
-  VERSION = "5".freeze
+  VERSION = "7".freeze
 end

data/lib/hlockey.rb

@@ -1 +1,16 @@
 require("hlockey/league")
+
+##
+# All Hlockey library code lives here.
+module Hlockey
+  # @return [League]
+  def self.new_current_league
+    league_hash = Data.league
+    league_start_time = Time.utc(*league_hash[:start_time])
+    one_week = 604_800 # In seconds, to add/subtract with Time objects
+
+    return League.new(**Data.infinileague) if Time.now < league_start_time - one_week
+
+    League.new(**league_hash)
+  end
+end

metadata

@@ -1,46 +1,47 @@
 --- !ruby/object:Gem::Specification
 name: hlockey
 version: !ruby/object:Gem::Version
-  version: '5'
+  version: '7'
 platform: ruby
 authors:
 - Lavender Perry
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-08-27 00:00:00.000000000 Z
+date: 2024-05-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: psych
+  name: json
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '5'
+        version: '2.6'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '5'
+        version: '2.6'
 description: Hlockey library.
-email: endie2@protonmail.com
+email: lavender.perry@outlook.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- data/election.yaml
-- data/external/names.txt
-- data/information.yaml
-- data/league.yaml
-- data/links.yaml
-- data/previous_election_results.yaml
+- data/election.json
+- data/infinileague.json
+- data/information.json
+- data/league.json
+- data/links.json
+- data/messages.json
+- data/previous_election_results.json
 - lib/hlockey.rb
+- lib/hlockey/actions.rb
 - lib/hlockey/constants.rb
 - lib/hlockey/data.rb
 - lib/hlockey/game.rb
-- lib/hlockey/game/actions.rb
 - lib/hlockey/game/fight.rb
 - lib/hlockey/game/weather.rb
 - lib/hlockey/game/weather/audacity.rb
@@ -52,16 +53,27 @@ files:
 - lib/hlockey/game/weather/weatherable.rb
 - lib/hlockey/league.rb
 - lib/hlockey/message.rb
+- lib/hlockey/mod.rb
+- lib/hlockey/mod/fencebuilder.rb
+- lib/hlockey/mod/fencedestroyer.rb
+- lib/hlockey/mod/handholding.rb
+- lib/hlockey/mod/immaterial.rb
+- lib/hlockey/mod/locked.rb
+- lib/hlockey/mod/moddable.rb
+- lib/hlockey/mod/nonconfrontational.rb
+- lib/hlockey/mod/powernapper.rb
+- lib/hlockey/mod/punchy.rb
+- lib/hlockey/selfdescribable.rb
 - lib/hlockey/team.rb
 - lib/hlockey/team/player.rb
 - lib/hlockey/team/stadium.rb
 - lib/hlockey/utils.rb
 - lib/hlockey/version.rb
-homepage: https://github.com/Hlockey/lib
+homepage: https://hlockey.gay
 licenses:
 - LicenseRef-LICENSE.md
 metadata:
-  source_code_uri: https://github.com/Hlockey/lib
+  source_code_uri: https://codeberg.org/LavenderPerry/hlockey
 post_install_message:
 rdoc_options: []
 require_paths:
@@ -70,15 +82,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 3.1.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.10
+rubygems_version: 3.5.9
 signing_key:
 specification_version: 4
-summary: Hlockey season 5.
+summary: Hlockey season 7.
 test_files: []

data/data/election.yaml

@@ -1,21 +0,0 @@
----
-:Bribery:
-  :Mods Help: Add player modifications.
-  :Lootboxes: Allow gambling for votes.
-  :We Do A Little Losing: Recognize the losingest teams with an Underbracket.
-:Treasure:
-  :Dave: The worst stat on your team is set to 4.5.
-  :Nice: Boost your worst player by 0.69 in every stat.
-  :Vengabus: All your team's stats are boosted by your team's losses * 0.005.
-  :Unvengabus: Your division's top team has all their stats reduced by their wins * 0.005.
-  :Shared Training: All teams in your division get +0.3 in each stat on each player.
-  :Theft: Your worst player steals 0.3 in every stat from the champion team's best player.
-:Coaching:
-  :Please Block Shots: Move your team's best defensive player to goalie.
-  :Please Win Faceoffs: Move your team's player best offensive player to center.
-  :Draft: Add a new random player to your shadows.
-  :Small Gamble: All your team's stats go up or down by 0.5 at random.
-  :Big Gamble: All your team's stats go up or down by 1.0 at random.
-  :Revolution: Your team's best player and worst player split their stats evenly.
-  :Clock Wise: Rotate each player on the roster to the position clockwise of them.
-  :Clock Unwise: Rotate each player on the roster to the position counterclockwise of them.