hlockey 4 → 6

data/data/links.json

@@ -0,0 +1,5 @@
+{
+  "Website": "https://hlockey.gay",
+  "Source Code": "https://codeberg.org/LavenderPerry/hlockey",
+  "Discord": "https://discord.gg/2N8VN8Q69E"
+}

data/data/previous_election_results.json

@@ -0,0 +1,98 @@
+{
+  "vote_amt": 159,
+  "categories": {
+    "Bribery (49 votes)": {
+      "Winning bribe": {
+        "winner": "Mods Help (23 votes)"
+      }
+    },
+    "Treasure (83 votes)": {
+      "Dave": {
+        "winner": "Pica Acid (2 votes / 21 total)",
+        "most_votes": "Sydney Thinkers (6 votes)"
+      },
+      "Nice": {
+        "winner": "Nice Backflippers (2 votes / 15 total)",
+        "most_votes": "Dawson City Impostors (7 votes)"
+      },
+      "Vengabus": {
+        "winner": "Antalya Pirates (2 votes / 22 total)",
+        "most_votes": "Stony Brook Reapers (11 votes)"
+      },
+      "Unvengabus": {
+        "winner": "Rio de Janeiro Directors (Dry Warm) (0 votes / 0 total)"
+      },
+      "Shared Training": {
+        "winner": "Pompei Eruptions (Dry Warm) (4 votes / 16 total)"
+      },
+      "Theft": {
+        "winner": "Sydney Thinkers (8 votes / 9 total)"
+      },
+      "Hidden Treasure - Evolve": {
+        "winner": "Baden Hallucinations (0 votes / 0 total)"
+      }
+    },
+    "Coaching (27 votes)": {
+      "Antalya Pirates": {
+        "winner": "Draft (1 vote / 1 total)"
+      },
+      "Baden Hallucinations": {
+        "winner": "Draft (0 votes / 0 total)"
+      },
+      "Kópavogur Seals": {
+        "winner": "Big Gamble (0 votes / 0 total)"
+      },
+      "Lagos Soup": {
+        "winner": "Small Gamble (0 votes / 0 total)"
+      },
+      "Pica Acid": {
+        "winner": "Please Block Shots (2 votes / 2 total)"
+      },
+      "Dawson City Impostors": {
+        "winner": "Draft (4 votes / 4 total)"
+      },
+      "Erlangen Ohms": {
+        "winner": "Please Win Faceoffs (1 vote / 2 total)"
+      },
+      "Pompei Eruptions": {
+        "winner": "Please Win Faceoffs (0 votes / 0 total)"
+      },
+      "Rio de Janeiro Directors": {
+        "winner": "Please Win Faceoffs (1 vote / 1 total)"
+      },
+      "Wyrzysk Rockets": {
+        "winner": "Big Gamble (0 votes / 0 total)"
+      },
+      "Cape Town Transplants": {
+        "winner": "Draft (1 vote / 2 total)"
+      },
+      "Manbij Fish": {
+        "winner": "Draft (1 vote / 1 total)"
+      },
+      "Nagqu Paint": {
+        "winner": "Draft (1 vote / 1 total)"
+      },
+      "Nice Backflippers": {
+        "winner": "Draft (1 vote / 1 total)"
+      },
+      "Orcadas Base Fog": {
+        "winner": "Draft (2 votes / 2 total)"
+      },
+      "Baghdad Abacuses": {
+        "winner": "Clock Unwise (0 votes / 0 total)"
+      },
+      "Jakarta Architects": {
+        "winner": "Clock Wise (0 votes / 0 total)"
+      },
+      "Kyoto Payphones": {
+        "winner": "Small Gamble (1 vote / 2 total)"
+      },
+      "Stony Brook Reapers": {
+        "winner": "Please Win Faceoffs (1 vote / 1 total)"
+      },
+      "Sydney Thinkers": {
+        "winner": "Clock Wise (7 votes / 7 total)"
+      }
+    }
+  }
+}

data/lib/hlockey/actions.rb

@@ -0,0 +1,22 @@
+require("hlockey/constants")
+
+module Hlockey
+  ##
+  # For classes that deal with actions within a Hlockey game.
+  module Actions
+    private
+
+    # For an event that should happen randomly about a certain amount of times per game,
+    # returns if the event should happen or not. Should be called once per action.
+    # @param times [Integer] the approximate amount of times the event should occur
+    # @return [Boolean] if the event should occur
+    def random_event_occurs?(times = 1, prng: @prng) =
+      prng.rand(NON_OT_ACTIONS / times).zero?
+
+    # @param succeed_boost [Numeric] increases chance of action succeeding
+    # @param fail_boost [Numeric] decreases chance of action succeeding
+    # @return [Boolean] if the action succeeded
+    def action_succeeds?(succeed_boost, fail_boost, prng: @prng) =
+      prng.rand(20) + (succeed_boost - fail_boost) > 9
+  end
+end

data/lib/hlockey/constants.rb

@@ -1,4 +1,10 @@
 module Hlockey
   UPDATE_FREQUENCY_SECONDS = 5
   UPDATES_PER_HOUR = 3600 / UPDATE_FREQUENCY_SECONDS
+
+  ACTIONS_PER_PERIOD = 60
+  NON_OT_PERIODS = 3
+  NON_OT_ACTIONS = ACTIONS_PER_PERIOD * NON_OT_PERIODS
+  TOTAL_ACTIONS = UPDATES_PER_HOUR - ACTIONS_PER_PERIOD
+  TOTAL_PERIODS = TOTAL_ACTIONS / ACTIONS_PER_PERIOD
 end

data/lib/hlockey/data.rb

@@ -1,5 +1,4 @@
-require("hlockey/team") # Class stored in league data
-require("yaml")
+require("json")
 
 module Hlockey
   ##
@@ -8,9 +7,11 @@ module Hlockey
     class << self
       data_dir = File.expand_path("../../data", __dir__)
 
-      Dir.glob("*.yaml", base: data_dir).each do |data_file|
-        category = File.basename(data_file, ".yaml")
-        define_method(category) { YAML.unsafe_load_file("#{data_dir}/#{data_file}") }
+      Dir.glob("*.json", base: data_dir).each do |data_file|
+        # @return [Hash] loaded data
+        define_method(File.basename(data_file, ".json")) do
+          JSON.parse(File.read("#{data_dir}/#{data_file}"), symbolize_names: true)
+        end
       end
     end
   end

data/lib/hlockey/game/fight.rb

@@ -1,4 +1,4 @@
-require("hlockey/game/actions")
+require("hlockey/actions")
 require("hlockey/message")
 
 module Hlockey
@@ -11,18 +11,26 @@ module Hlockey
       # @return [Hash<Symbol => Array<Player>>] the players in the fight
       attr_reader(:players)
 
+      # @return [Hash<Symbol => Integer>] the amount of successful punches for each team
+      attr_reader(:score)
+
       # @param game [Game] the game the fight is a part of
-      def initialize(game)
+      def initialize(game, starting_player = nil)
         @home = game.home
         @away = game.away
         @prng = game.prng
         @actions = 0
-        @players = {
-          home: [@home.roster.values.sample(random: @prng)],
-          away: [@away.roster.values.sample(random: @prng)]
-        }
+        @players = { home: [], away: [] }
+        @players.each_key do |team|
+          add_player(if send(team).roster.value?(starting_player)
+                       starting_player
+                     else
+                       get_joining_player(team)
+                     end,
+                     team)
+        end
+
         @score = { home: 0, away: 0 }
-        @in_progress = true
       end
 
       # @return [Message] the message to add to the game stream
@@ -42,18 +50,18 @@ module Hlockey
             return attack if player_joining.nil?
           end
 
-          @players[team_joining] << player_joining
-
-          Message.PlayerJoinedFight(send(team_joining), player_joining)
+          add_player(player_joining, team_joining)
         else # fight ends
-          @in_progress = false
-
           Message.FightEnded
         end
       end
 
       private
 
+      # private readers so #send works
+      # @return [Team] a team in the fight
+      attr_reader(:home, :away)
+
       # @return [Message] returned by #next_action for same purpose
       def attack
         attacking_team = rand_team
@@ -71,21 +79,28 @@ module Hlockey
       end
 
       # @param team [:home, :away]
-      # @return [Player, nil]
-      def get_joining_player(team)
+      # @return [Team::Player, nil]
+      def get_joining_player(team) =
         (send(team).roster.values - @players[team]).sample(random: @prng)
+
+      # @param player [Team::Player]
+      # @param team [:home, :away]
+      # @return [Message] the join message
+      def add_player(player, team)
+        mods_res = player.mods_do(:on_join_fight)
+        player = mods_res if mods_res
+
+        @players[team] << player
+
+        Message.PlayerJoinedFight(player)
       end
 
       # @return [:home, :away] randomly selected based on amount of players in fight
-      def rand_team
-        rand_is_home? ? :home : :away
-      end
+      def rand_team = rand_is_home? ? :home : :away
 
       # @param team [:home, :away]
       # @return [:home, :away] :away if `team` is :home, :home if `team` is :away
-      def opposite(team)
-        team == :home ? :away : :home
-      end
+      def opposite(team) = team == :home ? :away : :home
 
       # @return [Boolean] if randomly selected team is home team
       def rand_is_home?

data/lib/hlockey/game/weather/audacity.rb

@@ -0,0 +1,20 @@
+require("hlockey/game/weather/weatherable")
+require("hlockey/actions")
+
+module Hlockey
+  class Game
+    module Weather
+      ##
+      # Audacity weather
+      # Causes players to take shots regardless of the state of the game
+      class Audacity
+        include(Weatherable)
+        include(Actions)
+
+        def on_action
+          @game.send(:shoot, audacity: true) if random_event_occurs?(10)
+        end
+      end
+    end
+  end
+end

data/lib/hlockey/game/weather/chicken.rb

@@ -0,0 +1,57 @@
+require("hlockey/game/weather/weatherable")
+require("hlockey/actions")
+require("hlockey/message")
+
+module Hlockey
+  class Game
+    module Weather
+      ##
+      # Chicken weather
+      # Swaps a random roster player with a random shadow player for the rest of the game
+      class Chicken
+        include(Weatherable)
+        include(Actions)
+
+        def on_game_start
+          @chickened_out = { home: {}, away: {} }
+        end
+
+        def on_action
+          return unless random_event_occurs?(5)
+
+          team = rand_team
+          pos, shadows_idx = get_swap(team)
+          if pos.nil? || shadows_idx.nil?
+            team = team == :home ? :away : :home
+            pos, shadows_idx = get_swap(team)
+            return if pos.nil? || shadows_idx.nil?
+          end
+
+          @chickened_out[team][pos] = shadows_idx
+
+          @game.stream << Message.ChickenedOut(*swap(team, pos, shadows_idx))
+        end
+
+        def on_game_end
+          @chickened_out.each do |team, swaps|
+            swaps.each { |pos, shadows_idx| swap(team, pos, shadows_idx) }
+          end
+        end
+
+        private
+
+        # @param team_sym [:home, :away]
+        # @return [Array<Symbol, Integer>]
+        def get_swap(team_sym)
+          team = @game.send(team_sym)
+
+          [
+            (team.roster.keys - @chickened_out[team_sym].keys).sample(random: @prng),
+            (team.shadows.each_index.to_a - @chickened_out[team_sym].values)
+              .sample(random: @prng)
+          ]
+        end
+      end
+    end
+  end
+end

data/lib/hlockey/game/weather/incline.rb

@@ -0,0 +1,43 @@
+require("hlockey/game/weather/weatherable")
+require("hlockey/message")
+
+module Hlockey
+  class Game
+    module Weather
+      ##
+      # Incline weather
+      # Adds a random amount of score to a favored team's goals
+      class Incline
+        include(Weatherable)
+
+        def on_game_start
+          make_incline
+        end
+
+        def on_goal(scoring_team)
+          return unless scoring_team == @favored_team
+
+          @game.score[scoring_team] += @prng.rand(0.1..0.5)
+          make_incline
+        end
+
+        def on_action
+          return unless @incline_changed
+
+          @game.stream << Message.InclineFavors(@game.send(@favored_team))
+          @incline_changed = false
+        end
+
+        private
+
+        def make_incline
+          new_favored_team = rand_team
+          return if new_favored_team == @favored_team
+
+          @favored_team = new_favored_team
+          @incline_changed = true
+        end
+      end
+    end
+  end
+end

data/lib/hlockey/game/weather/stars.rb

@@ -0,0 +1,23 @@
+require("hlockey/game/weather/weatherable")
+require("hlockey/message")
+
+module Hlockey
+  class Game
+    module Weather
+      ##
+      # Stars weather
+      # Gives the losing team +0.5 score at the end of each period
+      class Stars
+        include(Weatherable)
+
+        def on_period_end
+          return if @game.score[:home] == @game.score[:away]
+
+          team = @game.score.min_by { |_, v| v }.first
+          @game.score[team] += 0.5
+          @game.stream << Message.StarsAlign(@game.send(team))
+        end
+      end
+    end
+  end
+end

data/lib/hlockey/game/weather/sunset.rb

@@ -0,0 +1,23 @@
+require("hlockey/game/weather/weatherable")
+
+module Hlockey
+  class Game
+    module Weather
+      ##
+      # Sunset weather
+      # Makes each team's goals worth less the more the team scores
+      class Sunset
+        include(Weatherable)
+
+        def on_game_start
+          @score_amt = { home: 0, away: 0 }
+        end
+
+        def on_goal(scoring_team)
+          @score_amt[scoring_team] += 1
+          @game.score[scoring_team] -= @score_amt[scoring_team] * 0.3
+        end
+      end
+    end
+  end
+end

data/lib/hlockey/game/weather/waves.rb

@@ -0,0 +1,33 @@
+require("hlockey/game/weather/weatherable")
+require("hlockey/actions")
+require("hlockey/message")
+
+module Hlockey
+  class Game
+    module Weather
+      ##
+      # Waves weather
+      # Swaps a roster player (worst most likely) with a random shadow player permanently
+      class Waves
+        include(Weatherable)
+        include(Actions)
+
+        def on_action
+          return unless random_event_occurs?
+
+          team_sym = rand_team
+          team = @game.send(team_sym)
+          @game.stream << Message.WavesWashedAway(
+            *swap(team_sym,
+                  if @prng.rand(5).zero?
+                    team.roster.keys.sample(random: @prng)
+                  else
+                    team.worst_player_pos
+                  end,
+                  @prng.rand(team.shadows.length))
+          )
+        end
+      end
+    end
+  end
+end

data/lib/hlockey/game/weather/weatherable.rb

@@ -0,0 +1,63 @@
+require("hlockey/constants")
+require("hlockey/selfdescribable")
+
+module Hlockey
+  class Game
+    module Weather
+      ##
+      # Module with needed methods for weathers, that every weather includes
+      # All methods starting with "on" represent game events weathers may respond to
+      module Weatherable
+        include(SelfDescribable)
+
+        def initialize(game)
+          @game = game
+          @home = @game.home
+          @away = @game.away
+          @prng = @game.prng
+        end
+
+        def on_game_start() end
+
+        def on_game_end() end
+
+        def on_period_end() end
+
+        def on_action() end
+
+        def on_goal(scoring_team) end
+
+        private
+
+        # Swaps a roster player with a shadows player
+        # @param team_sym [:home, :away]
+        # @param pos [Symbol] position of roster player swapped out
+        # @param shadows_idx [Integer] index of shadows player swapped in
+        # @return [Array<Team::Player>] the players that were swapped
+        def swap(team_sym, pos, shadows_idx)
+          team = @game.send(team_sym)
+
+          prev_player = team.roster[pos]
+          next_player = team.shadows[shadows_idx]
+          team.roster[pos] = next_player
+          team.shadows[shadows_idx] = prev_player
+
+          unless @game.fight.nil?
+            player_array = @game.fight.players[team_sym]
+            player_idx = player_array.index(prev_player)
+
+            player_array[player_idx] = next_player unless player_idx.nil?
+          end
+
+          prev_player.mods_do(:on_swap, false, shadows_idx, pos, @prng)
+          next_player.mods_do(:on_swap, true, pos, shadows_idx, @prng)
+
+          [prev_player, next_player]
+        end
+
+        # @return [:home, :away]
+        def rand_team = @prng.rand(2).zero? ? :home : :away
+      end
+    end
+  end
+end

data/lib/hlockey/game/weather.rb

@@ -0,0 +1,17 @@
+require("hlockey/game/weather/audacity")
+require("hlockey/game/weather/chicken")
+require("hlockey/game/weather/incline")
+require("hlockey/game/weather/stars")
+require("hlockey/game/weather/sunset")
+require("hlockey/game/weather/waves")
+
+module Hlockey
+  class Game
+    ##
+    # Weathers modify the mechanics of a Game
+    module Weather
+      # Every weather class
+      WEATHERS = [Audacity, Chicken, Incline, Stars, Sunset, Waves].freeze
+    end
+  end
+end