hlockey 2 → 3

data/lib/hlockey/league.rb

@@ -1,115 +1,150 @@
-# 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
+    REGULAR_SEASON_DAY_AMT = 38
+
+    # @return [Time]
+    attr_reader(:start_time)
+
+    # @return [Hash<Symbol => Array<Team>>]
+    attr_reader(:divisions)
+
+    # @return [Array<Team>]
+    attr_reader(:teams, :playoff_teams)
+
+    # @return [Integer]
+    attr_reader(:day)
+
+    # @return [Array<Game>]
+    attr_reader(:games, :games_in_progress)
+
+    # @return [Team, nil]
+    attr_reader(:champion_team)
+
+    def initialize
+      @start_time, @divisions = 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(@start_time.to_i)
+      @teams = @divisions.values.reduce(:+)
+      @shuffled_teams = @teams.shuffle(random: @prng)
+      @playoff_teams = []
+      @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?
+          new_games
+        else
+          update_games
+        end
+
+        break if @champion_team
+      end
+
+      @last_update_time = now
+      @passed_updates += intervals
+    end
+
+    private
+
+    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 <=> REGULAR_SEASON_DAY_AMT + 1
+      when -1 # In regular season
+        (@shuffled_teams.length / 2).times do |i|
+          pair = [@shuffled_teams[i], @shuffled_teams[-i - 1]]
+          pair.reverse! if @day > REGULAR_SEASON_DAY_AMT / 2
+          @games << new_game(*pair)
+        end
+
+        @shuffled_teams.insert(1, @shuffled_teams.pop)
+      when 0 # Playoffs about to start
+        @matchup_game_amt = 5
+
+        # get teams that qualified for playoffs, put in @playoff_teams
+        two_best_teams_each_division = @divisions.values.map do |teams|
+          sort_teams_by_wins(teams).first(2)
+        end.reduce(:+)
+        @playoff_teams = sort_teams_by_wins(two_best_teams_each_division).map(&:clone)
+
+        new_playoff_matchups
+      when 1 # Playoffs started
+        @playoff_teams.select! { |team| team.wins > team.losses }
+
+        if @playoff_teams.length == 1
+          @champion_team = @playoff_teams.first
+          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 << new_game(@playoff_teams[i], @playoff_teams[-i - 1])
+      end
+    end
+
+    # @param home [Team]
+    # @param away [Team]
+    # @return [Game]
+    def new_game(home, away)
+      Game.new(home, away, @prng, Utils.weighted_random(Weather::WEIGHTS, @prng))
+    end
+
+    # @param teams [Array<Team>]
+    # @return [Array<Team>]
+    def sort_teams_by_wins(teams)
+      teams.sort { |a, b| b.wins <=> a.wins }
+    end
+  end
+end

data/lib/hlockey/message.rb

@@ -0,0 +1,133 @@
+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)
+
+    # @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)
+      @event = event
+      fields.zip(data) { |f, d| instance_variable_set("@#{f}", d) }
+    end
+
+    class << self
+      # 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],
+        %i[Pass sender receiver interceptor new_puck_team],
+        %i[ShootScore shooter home away home_score away_score],
+        %i[ShootBlock shooter blocker puck_taken new_puck_team],
+        %i[FightStarted home_player away_player],
+        %i[FightAttack attacking_player defending_player blocked],
+        %i[PlayerJoinedFight team player],
+        %i[FightEnded],
+        %i[ChickenedOut prev_player next_player],
+        %i[InclineFavors team],
+        %i[StarsPity 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#{@winning_team} win!"
+      when :StartOfPeriod
+        "Start#{of_period}"
+      when :EndOfPeriod
+        "End#{of_period}#{score}"
+      when :FaceOff
+        "#{@winning_player} wins the faceoff!#{possession_change}"
+      when :Hit
+        "#{@defender} hits #{@puck_holder}#{takes}"
+      when :Pass
+        str = "#{@sender} passes to #{@receiver}."
+        str += "..\nIntercepted by #{@interceptor}!#{possession_change}" if @interceptor
+        str
+      when :ShootScore
+        "#{shot} and scores!#{score}"
+      when :ShootBlock
+        "#{shot}...\n#{@blocker} blocks the shot#{takes}"
+      when :FightStarted
+        "#{@home_player} and #{@away_player} start fighting!"
+      when :FightAttack
+        str = "#{@attacking_player} punches #{@defending_player}!"
+        str += "\n#{@defending_player} blocks the punch!" if @blocked
+        str
+      when :PlayerJoinedFight
+        "#{@player} from #{@team} joins the fight!"
+      when :FightEnded
+        "The fight has ended."
+      when :ChickenedOut
+        "#{@prev_player} chickened out!#{replaces_for("game")}"
+      when :InclineFavors
+        "The incline favors #{@team}."
+      when :StarsPity
+        "The stars take pity on #{@team} and give them half a goal."
+      when :WavesWashedAway
+        "#{@prev_player} is washed away by the waves...#{replaces_for("season")}"
+      end
+    end
+
+    private
+
+    def of_period
+      " of period #{@period}."
+    end
+
+    def score
+      "\n#{@home} #{@home_score.round(1)}, #{@away} #{@away_score.round(1)}"
+    end
+
+    def shot
+      "#{@shooter} takes a shot"
+    end
+
+    def takes
+      @puck_taken ? " and takes the puck!#{possession_change}" : "!"
+    end
+
+    def possession_change
+      "\n#{@new_puck_team} have possession."
+    end
+
+    def replaces_for(period)
+      "\n#{@next_player} replaces them for the rest of the #{period}."
+    end
+  end
+end

data/lib/hlockey/player.rb

@@ -0,0 +1,63 @@
+require("hlockey/utils")
+
+module Hlockey
+  class Player
+    attr_accessor(:stats)
+    attr_reader(:to_s)
+
+    @@cached_chain = nil
+
+    def initialize(prng = Random)
+      @to_s = make_name(prng)
+      # Generate stats
+      @stats = {}
+      %i[offense defense agility].each { |stat| @stats[stat] = prng.rand * 5 }
+    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

data/lib/hlockey/team.rb

@@ -1,35 +1,59 @@
-# frozen_string_literal: true
-
-module Hlockey
-  # Created by League when data is loaded
-  class Team
-    private_class_method(:new)
-    attr_accessor(:wins, :losses, :roster)
-    attr_reader(:to_s, :emoji)
-
-    def w_l
-      "#{@wins}-#{@losses}"
-    end
-
-    # Created by League when data is loaded
-    class Player
-      attr_accessor(:stats, :to_s)
-    end
-  end
-
-  # Takes symbol from Team roster & converts it to full position name
-  def Hlockey.pos_name(pos)
-    case pos
-    when :lwing
-      'Left wing'
-    when :rwing
-      'Right wing'
-    when :ldef
-      'Left defender'
-    when :rdef
-      'Right defender'
-    else
-      pos.capitalize.to_s
-    end
-  end
-end
+require("hlockey/player")
+
+module Hlockey
+  # Created by League when data is loaded
+  class Team
+    attr_accessor(:wins, :losses, :roster)
+    attr_reader(:to_s, :emoji)
+
+    # rand is only used if roster is nil
+    def initialize(name, emoji, roster: nil, random: Random)
+      @to_s = name
+      @emoji = emoji
+
+      if roster.nil?
+        @roster = {}
+        %i[lwing center rwing ldef goalie rdef].each do |pos|
+          @roster[pos] = Player.new(random)
+        end
+      else
+        @roster = roster
+      end
+
+      @wins = 0
+      @losses = 0
+    end
+
+    def random_player(random, filter_predicate = nil)
+      players = @roster.values
+      players.select!(&filter_predicate) unless filter_predicate.nil?
+      players.sample(random: random)
+    end
+
+    def w_l
+      "#{@wins}-#{@losses}"
+    end
+
+    def worst_player_pos
+      @roster.transform_values do |player|
+        player.stats.values.reduce(:+)
+      end.min_by { |k, v| v }.first
+    end
+
+    # Takes symbol from Team roster & converts it to full position name
+    def self.pos_name(pos)
+      case pos
+      when :lwing
+        "Left wing"
+      when :rwing
+        "Right wing"
+      when :ldef
+        "Left defender"
+      when :rdef
+        "Right defender"
+      else
+        pos.capitalize.to_s
+      end
+    end
+  end
+end

data/lib/hlockey/utils.rb

@@ -0,0 +1,12 @@
+module Hlockey
+  module Utils
+    # Does a weighted random with a hash,
+    # where the keys are elements being randomly selected,
+    # and the values are the weights
+    def self.weighted_random(hash, prng = Random)
+      cumulative_weights = []
+      hash.each_value { |v| cumulative_weights << v + (cumulative_weights.last or 0) }
+      hash.keys[cumulative_weights.index { |n| prng.rand(cumulative_weights.last) < n }]
+    end
+  end
+end

data/lib/hlockey/version.rb

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
-module Hlockey
-  VERSION = '2'
-end
+module Hlockey
+  VERSION = "3"
+end