hlockey 2 → 4

data/lib/hlockey/league.rb

@@ -1,115 +1,254 @@
-# frozen_string_literal: true
-
-require('hlockey/data')
-require('hlockey/game')
-require('hlockey/team')
-require('hlockey/version')
-
-module Hlockey
-  class League
-    attr_reader(:start_time, :divisions, :teams, :day,
-                :games, :games_in_progress, :playoff_teams, :champion_team)
-
-    def initialize
-      @start_time, @divisions = Hlockey.load_data('league')
-      @start_time.localtime
-      @day = 0
-      @games_in_progress = []
-      @games = []
-      @champion_team = nil
-      @last_update_time = @start_time
-      @passed_updates = 0
-      @prng = Random.new(69_420 * VERSION.to_i)
-      @teams = @divisions.values.reduce(:+)
-      @shuffled_teams = teams.shuffle(random: @prng)
-      @playoff_teams = nil
-      @game_in_matchup = 3
-    end
-
-    def update_state
-      return if @champion_team
-
-      now = Time.at(Time.now.to_i)
-      five_sec_intervals = (now - @last_update_time).div(5)
-
-      return unless five_sec_intervals.positive?
-
-      five_sec_intervals.times do |i|
-        if ((i + @passed_updates) % 720).zero?
-          new_games
-        else
-          update_games
-        end
-
-        break if @champion_team
-      end
-
-      @last_update_time = now
-      @passed_updates += five_sec_intervals
-    end
-
-    private
-
-    def new_games
-      if @game_in_matchup != (@day > 38 ? 5 : 3)
-        # New game in matchups
-        @games.map! { |game| Game.new(game.away, game.home, @prng) }
-        @game_in_matchup += 1
-        return
-      end
-
-      # New matchups
-      @games.clear
-      @game_in_matchup = 1
-      @day += 1
-
-      case @day <=> 39
-      when -1
-        (@shuffled_teams.length / 2).times do |i|
-          pair = [@shuffled_teams[i], @shuffled_teams[-i - 1]]
-          @games << Game.new(*(@day > 19 ? pair : pair.reverse), @prng)
-        end
-
-        @shuffled_teams.insert 1, @shuffled_teams.pop
-      when 0
-        @playoff_teams = sort_teams_by_wins(
-          @divisions.values.map do |teams|
-            sort_teams_by_wins(teams).first(2)
-          end.reduce(:+)
-        ).map(&:clone)
-
-        new_playoff_matchups
-      when 1
-        @playoff_teams.select! { |team| team.wins > team.losses }
-
-        if @playoff_teams.length == 1
-          @champion_team = @playoff_teams[0]
-          return
-        end
-
-        new_playoff_matchups
-      end
-    end
-
-    def update_games
-      @games_in_progress.each(&:update)
-      @games_in_progress = @games.select(&:in_progress)
-      @divisions.transform_values!(&method(:sort_teams_by_wins))
-    end
-
-    def new_playoff_matchups
-      @playoff_teams.each do |team|
-        team.wins = 0
-        team.losses = 0
-      end
-
-      (@playoff_teams.length / 2).times do |i|
-        @games << Game.new(@playoff_teams[i], @playoff_teams[-i - 1], @prng)
-      end
-    end
-
-    def sort_teams_by_wins(teams)
-      teams.sort { |a, b| b.wins <=> a.wins }
-    end
-  end
-end
+require("hlockey/constants")
+require("hlockey/data")
+require("hlockey/game")
+require("hlockey/utils")
+require("hlockey/version")
+require("hlockey/weather")
+
+module Hlockey
+  ##
+  # The Hlockey League
+  class League
+    GAMES_IN_REGULAR_SEASON = 114
+
+    # @return [Time]
+    attr_reader(:start_time)
+
+    # @return [Hash<Symbol => Array<Team>>]
+    attr_reader(:divisions)
+
+    # @return [Integer]
+    attr_reader(:day)
+
+    # @return [Array<Game>]
+    attr_reader(:games, :games_in_progress)
+
+    # @return [Array<String>]
+    attr_reader(:alerts)
+
+    # @return [Team, nil]
+    attr_reader(:champion_team)
+
+    # @return [Array<Team>]
+    attr_reader(:teams, :playoff_teams)
+
+    def initialize
+      @start_time, @divisions = Data.league
+      @start_time.localtime
+      @day = 0
+      @games = []
+      @games_in_progress = []
+      @alerts = []
+      @champion_team = nil
+      @last_update_time = @start_time
+      @passed_updates = 0
+      @prng = Random.new(@start_time.to_i)
+      @teams = @divisions.values.flatten
+      @sorted_teams_by_wins = @teams.shuffle(random: @prng)
+      @playoff_teams = []
+      # warm vs warm / cool vs cool
+      rotated_divisions = game_divisions.values.rotate
+      @shuffled_division_pairs = Array.new(2) do |i|
+        (rotated_divisions[i] + rotated_divisions[-i - 1]).shuffle(random: @prng)
+      end
+
+      @game_in_matchup = 3
+      @matchup_game_amt = 3
+    end
+
+    ##
+    # Updates the league to the current state
+    # This should be called whenever you need the current state of the league
+    def update_state
+      return if @champion_team
+
+      now = Time.at(Time.now.to_i)
+      intervals = (now - @last_update_time).div(UPDATE_FREQUENCY_SECONDS)
+
+      return unless intervals.positive?
+
+      intervals.times do |i|
+        if ((i + @passed_updates) % UPDATES_PER_HOUR).zero?
+          update_teams
+          new_games
+        else
+          update_games
+        end
+
+        break if @champion_team
+      end
+
+      @last_update_time = now
+      @passed_updates += intervals
+    end
+
+    private
+
+    def update_teams
+      return if @day.zero?
+
+      # Boost Sleepers roster
+      unless @day > 41 # Unless Sleepers are playing
+        @teams.last.roster.each_value do |player|
+          stat_change_amount = (10 - player.stats.values.reduce(:+)) / 129
+          player.stats.transform_values! { |stat| stat + stat_change_amount }
+        end
+      end
+
+      # Update team statuses
+      games_remaining = GAMES_IN_REGULAR_SEASON - ((@day - 1) * 3 + @game_in_matchup)
+      return if games_remaining.negative?
+
+      if games_remaining.zero?
+        @playoff_teams = sort_teams_by_wins(playoff_qualifiers)
+        @playoff_teams.each { |team| team.status = :qualified }
+        (@teams[...-1] - @playoff_teams).each { |team| team.status = :partying }
+        return
+      end
+
+      set_to_qualify = playoff_qualifiers
+      @teams[...-1].each_with_index do |team, i|
+        next unless games_remaining < set_to_qualify[i / 5].wins - team.wins &&
+                    games_remaining < set_to_qualify.last.wins - team.wins
+
+        team.status = :partying
+      end
+
+      threat_wins = sort_teams_by_wins(@teams - set_to_qualify).first.wins
+      set_to_qualify.each_with_index do |team, i|
+        division_threat_wins = if i < 4
+                                 sort_teams_by_wins(@divisions.values[i])[1].wins
+                               else # Team is not a division leader, so use itself
+                                 team.wins
+                               end
+        next unless games_remaining < team.wins - threat_wins ||
+                    games_remaining < team.wins - division_threat_wins
+
+        team.status = :qualified
+      end
+    end
+
+    def new_games
+      if @game_in_matchup != @matchup_game_amt
+        # New game in matchups
+        @games.map! { |game| new_game(game.away, game.home) }
+        @game_in_matchup += 1
+        return
+      end
+
+      # New matchups
+      @games.clear
+      @game_in_matchup = 1
+      @day += 1
+
+      case @day
+      when 1..27
+        @shuffled_division_pairs.each { |p| new_matchups(p, reverse: @day.even?) }
+      when 28..38
+        @shuffled_division_pairs.transpose.each_with_index do |pair, i|
+          @games << new_game(*pair, reverse: i.even?)
+        end
+        @shuffled_division_pairs.first.rotate!
+      when 39
+        @matchup_game_amt = 5
+        @playoff_teams = sort_teams_by_wins(playoff_qualifiers).map do |team|
+          cloned_team = team.clone
+          cloned_team.status = :playoffs
+          cloned_team
+        end
+        new_playoff_matchups
+      when 40, 41
+        @playoff_teams.select! { |team| team.wins > team.losses }
+        new_playoff_matchups
+      when 42
+        @matchup_game_amt = 1
+        champion = @playoff_teams.find { |team| team.wins > team.losses }
+        champion.wins = 0
+        champion.losses = 0
+        @playoff_teams = [@teams.last, champion]
+        @alerts = ["The Sleepers have awoken..."]
+        @games = [Game.new(*@playoff_teams, @prng, Stars)]
+      when 43, 44
+        @games = [Game.new(*@playoff_teams, @prng, Stars)]
+      when 45
+        return unless @champion_team.nil?
+
+        sleepers, @champion_team = @playoff_teams
+        @alerts = []
+
+        if sleepers.wins > @champion_team.wins
+          @alerts << "The Sleepers have beat your champions."
+          @alerts << "The Sleepers are evolving!"
+          sleepers.to_s = "Sleepersz"
+          @alerts << "Sleepers -> Sleepersz"
+          return
+        end
+
+        @alerts << "The Sleepers have lost."
+        sleepers.roster.values.zip([18, 4, 13, 19, 6, 0]) do |player, team_idx|
+          player.team = @teams[team_idx]
+          player.team.shadows << player
+          @alerts << "#{player} has adventured into the #{player.team} shadows."
+        end
+      end
+    end
+
+    def update_games
+      @games_in_progress.each(&:update)
+      @games_in_progress = @games.select(&:in_progress)
+      @divisions.transform_values!(&method(:sort_teams_by_wins))
+    end
+
+    def new_playoff_matchups
+      @playoff_teams.each do |team|
+        team.wins = 0
+        team.losses = 0
+      end
+
+      new_matchups(@playoff_teams, rotate: false)
+    end
+
+    # @param matchup_teams[Array<Team>]
+    # @param rotate [Boolean]
+    # @param reverse [Boolean]
+    def new_matchups(matchup_teams, rotate: true, reverse: false)
+      (matchup_teams.length / 2).times do |i|
+        @games << new_game(matchup_teams[i], matchup_teams[-i - 1], reverse: reverse)
+      end
+      matchup_teams.insert(1, matchup_teams.pop) if rotate
+    end
+
+    # @param home [Team]
+    # @param away [Team]
+    # @param reverse [Boolean]
+    def new_game(home, away, reverse: false)
+      teams = [home, away]
+      teams.reverse! if reverse
+
+      Game.new(*teams, @prng, Weather::WEATHERS.sample(random: @prng))
+    end
+
+    # @return [Array<Team>]
+    def playoff_qualifiers
+      top_divs = game_divisions.values.map { |teams| sort_teams_by_wins(teams).first }
+      # Prevents tied teams from being unfairly decided by which division they're in
+      @sorted_teams_by_wins = sort_teams_by_wins(@sorted_teams_by_wins)
+      rest = (@sorted_teams_by_wins - top_divs).first(4)
+
+      top_divs + rest
+    end
+
+    # @param teams [Array<Team>]
+    # @return [Array<Team>]
+    def sort_teams_by_wins(teams)
+      # A stable sort (Ruby's normal sort isn't always stable)
+      # t.wins is negative because it sorts the opposite way than I want otherwise
+      teams.sort_by.with_index { |t, i| [-t.wins, i] }
+    end
+
+    # @return [Hash<Symbol => Array<Team>]
+    def game_divisions
+      @divisions.except(:"Sleepy Tired")
+    end
+  end
+end

data/lib/hlockey/message.rb

@@ -0,0 +1,182 @@
+require("hlockey/version")
+
+module Hlockey
+  ##
+  # Can be sent by a Game (in Game#stream) or a commonly used text
+  class Message
+    private_class_method(:new)
+
+    @colorize = ->(_color, string) { string }
+
+    # @return [Symbol] an action or event the message represents
+    attr_reader(:event)
+
+    # @param event [Symbol]
+    # @param fields [Array<Symbol>] fields used in string interpolation in #to_s
+    # @param data [Array<Object>] data corresponding to the fields
+    def initialize(event, fields, data)
+      self.class.attr_reader(*fields)
+
+      @event = event
+      fields.zip(data) { |f, d| instance_variable_set("@#{f}", d) }
+    end
+
+    class << self
+      # Variable/method controlling how coloring players/teams is done
+      # The default is to not color things at all
+
+      attr_writer(:colorize)
+
+      # @param obj [Team, Player]
+      # @return String
+      def color(obj)
+        col = obj.instance_of?(Team) ? obj.color : obj.team.color
+
+        @colorize.call(col, obj.to_s)
+      end
+
+      # These are messages logged to game streams
+      [
+        %i[StartOfGame],
+        %i[EndOfGame winning_team],
+        %i[StartOfPeriod period],
+        %i[EndOfPeriod period home away home_score away_score],
+        %i[FaceOff winning_player new_puck_team],
+        %i[Hit puck_holder defender puck_taken new_puck_team shooting_chance],
+        %i[Pass sender receiver shooting_chance interceptor new_puck_team],
+        %i[ShootScore shooter home away home_score away_score audacity],
+        %i[ShootBlock shooter blocker puck_taken new_puck_team shooting_chance audacity],
+        %i[Partying player],
+        %i[FightStarted home_player away_player],
+        %i[FightAttack attacking_player defending_player blocked],
+        %i[PlayerJoinedFight team 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]
+      ].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 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
+        "no games right now. it is the offseason. join the Hlockey Discord for updates"
+      end
+    end
+
+    def to_s
+      case @event
+      when :StartOfGame
+        "Hocky!"
+      when :EndOfGame
+        "Game over.\n#{color(@winning_team)} win!"
+      when :StartOfPeriod
+        "Start#{of_period}"
+      when :EndOfPeriod
+        "End#{of_period}#{score}"
+      when :FaceOff
+        "#{color(@winning_player)} wins the faceoff!#{possession_change}"
+      when :Hit
+        str = "#{color(@defender)} hits #{color(@puck_holder)}"
+        str += takes + score_chance if @puck_taken
+        str
+      when :Pass
+        str = "#{color(@sender)} passes to #{color(@receiver)}."
+        unless @interceptor.nil?
+          str += "..\nIntercepted by #{color(@interceptor)}!#{possession_change}"
+        end
+        str += score_chance
+        str
+      when :ShootScore
+        "#{shot} and scores!#{score}"
+      when :ShootBlock
+        "#{shot}...\n#{color(@blocker)} blocks the shot#{takes}#{score_chance}"
+      when :Partying
+        "#{color(@player)} is partying!"
+      when :FightStarted
+        "#{color(@home_player)} and #{color(@away_player)} start fighting!"
+      when :FightAttack
+        str = "#{color(@attacking_player)} punches #{color(@defending_player)}!"
+        str += "\n#{color(@defending_player)} blocks the punch!" if @blocked
+        str
+      when :PlayerJoinedFight
+        "#{color(@player)} from #{color(@team)} joins the fight!"
+      when :FightEnded
+        "The fight has ended."
+      when :MoraleChange
+        "#{color(@team)} #{@amount.negative? ? "loses" : "gains"} #{@amount.abs} morale."
+      when :ChickenedOut
+        "#{color(@prev_player)} chickened out!#{replaces("game")}"
+      when :InclineFavors
+        "The incline favors #{color(@team)}."
+      when :StarsAlign
+        "The stars align for #{color(@team)}. They get half a goal."
+      when :WavesWashedAway
+        "#{color(@prev_player)} is washed away by the waves...#{replaces}"
+      end
+    end
+
+    private
+
+    def color(obj)
+      self.class.color(obj)
+    end
+
+    def score_chance
+      return "" if @shooting_chance.nil?
+
+      chance_str = case @shooting_chance
+                   when 0..2
+                     "none"
+                   when 3, 4
+                     "low"
+                   when 5, 6
+                     "medium"
+                   else
+                     "high"
+                   end
+      "\nChance of scoring: #{chance_str} (#{@shooting_chance})"
+    end
+
+    def of_period
+      " of period #{@period}."
+    end
+
+    def score
+      "\n#{color(@home)} #{@home_score.round(2)}, #{color(@away)} #{@away_score.round(2)}"
+    end
+
+    def shot
+      "#{color(@shooter)} takes a#{"n audacious" if @audacity} shot"
+    end
+
+    def takes
+      @puck_taken ? " and takes the puck!#{possession_change}" : "!"
+    end
+
+    def possession_change
+      "\n#{color(@new_puck_team)} have possession."
+    end
+
+    def replaces(period = nil)
+      str = "\n#{color(@next_player)} replaces them"
+      str += " for the rest of the #{period}." unless period.nil?
+      str
+    end
+  end
+end

data/lib/hlockey/player.rb

@@ -0,0 +1,73 @@
+require("hlockey/utils")
+
+module Hlockey
+  class Player
+    attr_accessor(:team, :stats)
+    attr_reader(:to_s)
+
+    @cached_chain = nil
+
+    # @param team [Team]
+    # @param prng [#rand]
+    def initialize(team, prng = Random)
+      @to_s = make_name(prng)
+      @team = team
+      # Generate stats
+      @stats = {}
+      %i[offense defense agility].each { |stat| @stats[stat] = prng.rand * 5 }
+    end
+
+    # @return [Hash<Symbol => String>]
+    def stat_strings
+      @stats.transform_values do |stat|
+        stat.instance_of?(String) ? stat : stat.round(2).to_s.ljust(4, "0")
+      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?
+
+          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(" ")
+    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
+
+      @cached_chain
+    end
+  end
+end