hlockey 6 → 7

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

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

data/lib/hlockey/game/fight.rb

@@ -1,5 +1,6 @@
 require("hlockey/actions")
 require("hlockey/message")
+require("hlockey/mod/punchy")
 
 module Hlockey
   class Game
@@ -8,21 +9,20 @@ 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
+      # @param starting_player [Team::Player] the player that started the fight, if any
       def initialize(game, starting_player = nil)
-        @home = game.home
-        @away = game.away
-        @prng = game.prng
+        @game = game
         @actions = 0
         @players = { home: [], away: [] }
         @players.each_key do |team|
-          add_player(if send(team).roster.value?(starting_player)
+          add_player(if @game.send(team).roster.value?(starting_player)
                        starting_player
                      else
                        get_joining_player(team)
@@ -33,11 +33,19 @@ module Hlockey
         @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
@@ -47,52 +55,93 @@ 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
 
           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)
-
-        blocked = action_succeeds?(defending_player.stats[:defense],
-                                   attacking_player.stats[:offense])
-
-        @score[attacking_team] += 1 unless blocked
+        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
 
-        Message.FightAttack(attacking_player, defending_player, blocked)
+        # Punch lands
+        @game.stream << Message.new(:fight_hit, player: defending_player)
+        @score[attacking_team] += 1
+        player_withdraws?(defending_player, defending_team)
       end
 
       # @param team [:home, :away]
       # @return [Team::Player, nil]
       def get_joining_player(team) =
-        (send(team).roster.values - @players[team]).sample(random: @prng)
+        (@game.send(team).roster.values - @players[team]).sample(random: @game.prng)
 
       # @param player [Team::Player]
       # @param team [:home, :away]
-      # @return [Message] the join message
       def add_player(player, team)
+        @game.stream << Message.new(:fight_player_join, player:, team: player.team)
+
         mods_res = player.mods_do(:on_join_fight)
-        player = mods_res if mods_res
+        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
 
         @players[team] << player
+      end
+
+      # @param player [Team::Player]
+      # @param team [:home, :away]
+      # @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
 
-        Message.PlayerJoinedFight(player)
+        true
       end
 
       # @return [:home, :away] randomly selected based on amount of players in fight
@@ -104,10 +153,10 @@ module Hlockey
 
       # @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/chicken.rb

@@ -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,9 +9,7 @@ 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

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

@@ -17,15 +17,13 @@ module Hlockey
 
           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))
-          )
+          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

@@ -33,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<Team::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)
 
@@ -49,10 +49,10 @@ module Hlockey
             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.mods_do(:on_swap, false, shadows_idx, pos)
+          next_player.mods_do(:on_swap, true, pos, shadows_idx)
 
-          [prev_player, next_player]
+          { prev_player:, next_player: }
         end
 
         # @return [:home, :away]