hlockey 5 → 7

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/messages.json

@@ -0,0 +1,46 @@
+{
+  "season_day": "Season %{season} day %{day}",
+  "season_starts": "Season %{season} starts at %{time}.",
+  "season_champion": "Your season %{season} champions are the %{team}!",
+  "season_off": "no games right now. it is the offseason. join the Hlockey Discord for updates.",
+
+  "game_start": "Hocky!",
+  "game_end": "Game over.\n%{winning_team} win!",
+  "game_score": "%{home} %{home_score}, %{away} %{away_score}",
+  "game_period_start": "Start of period %{period}.",
+  "game_period_end": "End of period %{period}.",
+  "game_faceoff": "%{winning_player} wins the faceoff!",
+  "game_pass": "%{sender} passes to %{receiver}.",
+  "game_pass_intercept": "%{sender}'s pass to %{receiver} is intercepted by %{interceptor}!",
+  "game_hit": "%{defender} hits %{puck_holder}.",
+  "game_shot": "%{shooter} takes a shot...",
+  "game_shot_audacious": "%{shooter} takes an audacious shot...",
+  "game_shot_scored": "%{shooter} scores!",
+  "game_shot_blocked": "%{blocker} blocks the shot.",
+  "game_partying": "%{player} is partying!",
+  "game_possession_change": "%{player} takes the puck!\n%{new_puck_team} have possession.",
+
+  "fight_start": "%{home_player} and %{away_player} start fighting!",
+  "fight_player_join": "%{player} from %{team} joins the fight!",
+  "fight_player_withdraw": "%{player} withdraws from the fight!",
+  "fight_attack": "%{player} is going for a punch...",
+  "fight_hit": "The punch lands to hit %{player}!",
+  "fight_block": "%{player} blocks the punch!",
+  "fight_dodge": "%{player} dodges the punch!",
+  "fight_end": "The fight has ended.",
+  "fight_end_morale_gain": "%{team} gains %{num} morale.",
+  "fight_end_morale_loss": "%{team} loses %{num} morale.",
+
+  "weather_chicken_event": "%{prev_player} chickened out!\nReplaced by %{next_player} for the game.",
+  "weather_incline_event": "The incline favors %{team}.",
+  "weather_stars_event": "The stars align for %{team}. They get half a goal.",
+  "weather_waves_event": "%{prev_player} is washed away by the waves...\nReplaced by %{next_player} for the season.",
+
+  "mod_immaterial_event": "%{hitting_player} goes right through %{player}!",
+  "mod_fence_event": "%{player} is a fence%{type}.\n%{player} swaps with %{swap_player} instead.",
+  "mod_handholding_event": "%{player} is holding %{other_player}'s hand.\n%{other_player} follows %{player} by swapping with %{swap_player}.",
+  "mod_locked_event": "%{player} is locked and does not get swapped with %{swap_player}",
+  "mod_powernap_start": "%{player} gets a boost from powernapping!",
+  "mod_powernap_end": "%{player}'s powernap boost has ended.",
+  "mod_punchy_event": "%{player} is looking for a fight..."
+}

data/data/previous_election_results.json

@@ -0,0 +1,91 @@
+{
+  "vote_amt": 91,
+  "categories": {
+    "Treasure (64 votes)": {
+      "Dave": {
+        "winner": "Cape Town Transplants (2 votes / 7 total)"
+      },
+      "Nice": {
+        "winner": "Stony Brook Reapers (1 vote / 15 total)",
+        "most_votes": "Dawson City Impostors (9 votes)"
+      },
+      "Vengabus": {
+        "winner": "Stony Brook Reapers (1 vote / 11 total)",
+        "most_votes": "Rio de Janeiro Directors (4 votes)"
+      },
+      "Shared Training": {
+        "winner": "Pompei Eruptions (Dry Warm) (1 votes / 15 total)",
+        "most_votes": "Kyoto Payphones (3 votes)"
+      },
+      "Theft": {
+        "winner": "Baden Hallucinations (1 vote / 14 total)",
+        "most_votes": "Rio de Janeiro Directors (3 votes)"
+      },
+      "Shadow Lock": {
+        "winner": "Nagqu Paint (2 votes / 2 total)"
+      }
+    },
+    "Coaching (27 votes)": {
+      "Antalya Pirates": {
+        "winner": "Draft (1 vote / 1 total)"
+      },
+      "Baden Hallucinations": {
+        "winner": "Draft (2 votes / 2 total)"
+      },
+      "Kópavogur Seals": {
+        "winner": "Please Block Shots (0 votes / 0 total)"
+      },
+      "Lagos Soup": {
+        "winner": "Small Gamble (0 votes / 0 total)"
+      },
+      "Pica Acid": {
+        "winner": "Big Gamble (0 votes / 0 total)"
+      },
+      "Dawson City Impostors": {
+        "winner": "Please Block Shots (2 votes / 5 total)"
+      },
+      "Erlangen Ohms": {
+        "winner": "Clock Wise (1 vote / 1 total)"
+      },
+      "Pompei Eruptions": {
+        "winner": "Please Win Faceoffs (1 vote / 1 total)"
+      },
+      "Rio de Janeiro Directors": {
+        "winner": "Please Win Faceoffs (3 votes / 3 total)"
+      },
+      "Wyrzysk Rockets": {
+        "winner": "Revolution (0 votes / 0 total)"
+      },
+      "Cape Town Transplants": {
+        "winner": "Small Gamble (0 votes / 0 total)"
+      },
+      "Manbij Fish": {
+        "winner": "Clock Wise (0 votes / 0 total)"
+      },
+      "Nagqu Paint": {
+        "winner": "Please Win Faceoffs (1 vote / 1 total)"
+      },
+      "Nice Backflippers": {
+        "winner": "Please Block Shots (1 vote / 1 total)"
+      },
+      "Orcadas Base Fog": {
+        "winner": "Small Gamble (1 vote / 1 total)"
+      },
+      "Baghdad Abacuses": {
+        "winner": "Please Win Faceoffs (0 votes / 0 total)"
+      },
+      "Jakarta Architects": {
+        "winner": "Please Win Faceoffs (0 votes / 0 total)"
+      },
+      "Kyoto Payphones": {
+        "winner": "Big Gamble (6 votes / 6 total)"
+      },
+      "Stony Brook Reapers": {
+        "winner": "Clock Unwise (1 vote / 1 total)"
+      },
+      "Sydney Thinkers": {
+        "winner": "Draft (3 votes / 4 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/data.rb

@@ -1,5 +1,4 @@
-require("hlockey/team") # Classes 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,5 +1,6 @@
-require("hlockey/game/actions")
+require("hlockey/actions")
 require("hlockey/message")
+require("hlockey/mod/punchy")
 
 module Hlockey
   class Game
@@ -8,30 +9,43 @@ module Hlockey
     class Fight
       include(Actions)
 
-      # @return [Hash<Symbol => Array<Player>>] the players in the fight
+      # @return [Hash<Symbol => Array<Team::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)
-        @home = game.home
-        @away = game.away
-        @prng = game.prng
+      # @param starting_player [Team::Player] the player that started the fight, if any
+      def initialize(game, starting_player = nil)
+        @game = game
         @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 @game.send(team).roster.value?(starting_player)
+                       starting_player
+                     else
+                       get_joining_player(team)
+                     end,
+                     team)
+        end
+
         @score = { home: 0, away: 0 }
       end
 
-      # @return [Message] the message to add to the game stream
       def next_action
         @actions += 1
 
-        case @prng.rand(@actions)
+        # If fight has a single player on one side who is outnumbered,
+        # there is a chance that player will withdraw, ending the fight.
+        if @players[:home].length == 1
+          return if @players[:away].length > 1 && player_withdraws?(@players[:home].first,
+                                                                    :home)
+        elsif @players[:away].length == 1
+          return if player_withdraws?(@players[:away].first, :away)
+        end
+
+        case @game.prng.rand(@actions)
         when 0..3 # attack
           attack
         when 4..7 # player joins
@@ -41,62 +55,108 @@ module Hlockey
           if player_joining.nil?
             team_joining = opposite(team_joining)
             player_joining = get_joining_player(team_joining)
-            return attack if player_joining.nil?
+            if player_joining.nil?
+              attack
+              return
+            end
           end
 
-          @players[team_joining] << player_joining
-
-          Message.PlayerJoinedFight(send(team_joining), player_joining)
+          add_player(player_joining, team_joining)
         else # fight ends
-          Message.FightEnded
+          @game.stream << Message.new(:fight_end)
         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
         defending_team = opposite(attacking_team)
 
-        attacking_player = @players[attacking_team].sample(random: @prng)
-        defending_player = @players[defending_team].sample(random: @prng)
+        attacking_player = @players[attacking_team].sample(random: @game.prng)
+        @game.stream << Message.new(:fight_attack, player: attacking_player)
+
+        defending_player = @players[defending_team].sample(random: @game.prng)
+
+        if action_succeeds?(defending_player.stats[:defense],
+                            defending_player.stats[:agility],
+                            prng: @game.prng)
+          # Try to block the punch
+          if action_succeeds?(defending_player.stats[:defense],
+                              attacking_player.stats[:offense],
+                              prng: @game.prng)
+            # Punch sucessfully blocked
+            @game.stream << Message.new(:fight_block, player: defending_player)
+            return
+          end
+        # Try to dodge the punch
+        elsif action_succeeds?(defending_player.stats[:agility],
+                               attacking_player.stats[:offense],
+                               prng: @game.prng)
+          # Punch sucessfully dodged
+          @game.stream << Message.new(:fight_dodge, player: defending_player)
+          return
+        end
 
-        blocked = action_succeeds?(defending_player.stats[:defense],
-                                   attacking_player.stats[:offense])
+        # Punch lands
+        @game.stream << Message.new(:fight_hit, player: defending_player)
+        @score[attacking_team] += 1
+        player_withdraws?(defending_player, defending_team)
+      end
 
-        @score[attacking_team] += 1 unless blocked
+      # @param team [:home, :away]
+      # @return [Team::Player, nil]
+      def get_joining_player(team) =
+        (@game.send(team).roster.values - @players[team]).sample(random: @game.prng)
+
+      # @param player [Team::Player]
+      # @param team [:home, :away]
+      def add_player(player, team)
+        @game.stream << Message.new(:fight_player_join, player:, team: player.team)
+
+        mods_res = player.mods_do(:on_join_fight)
+        if mods_res # Mod would return a joining player to replace them
+          @game.stream << Message.new(:fight_player_withdraw, player:)
+          player = mods_res
+          @game.stream << Message.new(:fight_player_join, player:, team: player.team)
+        end
 
-        Message.FightAttack(attacking_player, defending_player, blocked)
+        @players[team] << player
       end
 
+      # @param player [Team::Player]
       # @param team [:home, :away]
-      # @return [Player, nil]
-      def get_joining_player(team)
-        (send(team).roster.values - @players[team]).sample(random: @prng)
+      # @return [Boolean] if the player withdrew
+      def player_withdraws?(player, team)
+        return false unless player.mods.none? { _1.is_a?(Mod::Punchy) } &&
+                            @game.prng.rand(50).zero?
+
+        # Player withdraws
+        @game.stream << Message.new(:fight_player_withdraw, player:)
+        @players[team].delete(player)
+
+        if @players[team].empty?
+          @game.stream << Message.new(:fight_end)
+          @score[team] = 0
+          @score[opposite(team)] = 10
+        end
+
+        true
       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?
-        home_player_amount = @home.roster.values.length
-        away_player_amount = @away.roster.values.length
+        home_player_amount = @game.home.roster.values.length
+        away_player_amount = @game.away.roster.values.length
 
-        @prng.rand(home_player_amount + away_player_amount) < home_player_amount
+        @game.prng.rand(home_player_amount + away_player_amount) < home_player_amount
       end
     end
   end

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

@@ -1,5 +1,5 @@
 require("hlockey/game/weather/weatherable")
-require("hlockey/game/actions")
+require("hlockey/actions")
 
 module Hlockey
   class Game

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

@@ -1,5 +1,5 @@
 require("hlockey/game/weather/weatherable")
-require("hlockey/game/actions")
+require("hlockey/actions")
 require("hlockey/message")
 
 module Hlockey
@@ -29,7 +29,8 @@ module Hlockey
 
           @chickened_out[team][pos] = shadows_idx
 
-          @game.stream << Message.ChickenedOut(*swap(team, pos, shadows_idx))
+          @game.stream << Message.new(:weather_chicken_event,
+                                      **swap(team, pos, shadows_idx))
         end
 
         def on_game_end

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

@@ -24,7 +24,8 @@ module Hlockey
         def on_action
           return unless @incline_changed
 
-          @game.stream << Message.InclineFavors(@game.send(@favored_team))
+          @game.stream << Message.new(:weather_incline_event,
+                                      team: @game.send(@favored_team))
           @incline_changed = false
         end
 

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

@@ -15,7 +15,7 @@ module Hlockey
 
           team = @game.score.min_by { |_, v| v }.first
           @game.score[team] += 0.5
-          @game.stream << Message.StarsAlign(@game.send(team))
+          @game.stream << Message.new(:weather_stars_event, team: @game.send(team))
         end
       end
     end

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

@@ -9,13 +9,11 @@ module Hlockey
       class Sunset
         include(Weatherable)
 
-        def on_game_start
-          @score_amt = { home: 0, away: 0 }
-        end
+        def on_game_start = @score_amt = { home: 0, away: 0 }
 
         def on_goal(scoring_team)
           @score_amt[scoring_team] += 1
-          @game.score[scoring_team] -= @score_amt[scoring_team] * 0.2
+          @game.score[scoring_team] -= @score_amt[scoring_team] * 0.3
         end
       end
     end

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

@@ -1,5 +1,5 @@
 require("hlockey/game/weather/weatherable")
-require("hlockey/game/actions")
+require("hlockey/actions")
 require("hlockey/message")
 
 module Hlockey
@@ -7,7 +7,7 @@ module Hlockey
     module Weather
       ##
       # Waves weather
-      # Swaps the worst roster player with a random shadow player permanently
+      # Swaps a roster player (worst most likely) with a random shadow player permanently
       class Waves
         include(Weatherable)
         include(Actions)
@@ -17,9 +17,13 @@ module Hlockey
 
           team_sym = rand_team
           team = @game.send(team_sym)
-          @game.stream << Message.WavesWashedAway(*swap(team_sym,
-                                                        team.worst_player_pos,
-                                                        @prng.rand(team.shadows.length)))
+          player_leaving_pos = if @prng.rand(5).zero?
+                                 team.roster.keys.sample(random: @prng)
+                               else
+                                 team.worst_player_pos
+                               end
+          swap_res = swap(team_sym, player_leaving_pos, @prng.rand(team.shadows.length))
+          @game.stream << Message.new(:weather_waves_event, **swap_res)
         end
       end
     end

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

@@ -1,4 +1,5 @@
 require("hlockey/constants")
+require("hlockey/selfdescribable")
 
 module Hlockey
   class Game
@@ -7,6 +8,8 @@ module Hlockey
       # 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
@@ -14,10 +17,6 @@ module Hlockey
           @prng = @game.prng
         end
 
-        def to_s
-          self.class.to_s.split("::").last
-        end
-
         def on_game_start() end
 
         def on_game_end() end
@@ -34,7 +33,7 @@ module Hlockey
         # @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<Player>] the players that were swapped
+        # @return [Hash<[:prev_player, :next_player] => Team::Player>] the swapped players
         def swap(team_sym, pos, shadows_idx)
           team = @game.send(team_sym)
 
@@ -50,13 +49,14 @@ module Hlockey
             player_array[player_idx] = next_player unless player_idx.nil?
           end
 
-          [prev_player, next_player]
+          prev_player.mods_do(:on_swap, false, shadows_idx, pos)
+          next_player.mods_do(:on_swap, true, pos, shadows_idx)
+
+          { prev_player:, next_player: }
         end
 
         # @return [:home, :away]
-        def rand_team
-          @prng.rand(2).zero? ? :home : :away
-        end
+        def rand_team = @prng.rand(2).zero? ? :home : :away
       end
     end
   end