hlockey 1 → 3

data/data/links.yaml

@@ -0,0 +1,2 @@
+:GitHub: https://github.com/Hlockey
+:Discord: https://discord.gg/hQMRZyexUB

data/lib/hlockey/constants.rb

@@ -0,0 +1,4 @@
+module Hlockey
+  UPDATE_FREQUENCY_SECONDS = 5
+  UPDATES_PER_HOUR = 3600 / UPDATE_FREQUENCY_SECONDS
+end

data/lib/hlockey/data.rb

@@ -0,0 +1,17 @@
+require("hlockey/team") # Class stored in league data
+require("yaml")
+
+module Hlockey
+  ##
+  # Module containing methods to load Hlockey data
+  module Data
+    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}") }
+      end
+    end
+  end
+end

data/lib/hlockey/game/actions.rb

@@ -0,0 +1,30 @@
+module Hlockey
+  class Game
+    ##
+    # For classes that deal with actions within a Hlockey game.
+    # Any class including this must have instance variables indicated by the readers
+    module Actions
+      # @return [Team] the teams in the game
+      attr_reader(:home, :away)
+
+      # @return [Random] should be the same as the league's
+      attr_reader(:prng)
+
+      # @return [Integer] how many actions have passed
+      attr_reader(:actions)
+
+      # @return [Hash<Symbol => Integer>] the score of each team
+      attr_reader(:score)
+
+      # @return [Boolean] if the sequence of actions is still in progress
+      attr_reader(:in_progress)
+
+      # @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.rand(10) + succeed_boost - fail_boost > 4
+      end
+    end
+  end
+end

data/lib/hlockey/game/fight.rb

@@ -0,0 +1,83 @@
+require("hlockey/game/actions")
+require("hlockey/message")
+
+module Hlockey
+  class Game
+    ##
+    # A fight within a Hlockey game
+    class Fight
+      include(Actions)
+
+      # @return [Hash<Symbol => Array<Player>>] the players in the fight
+      attr_reader(:players)
+
+      # @param game [Game] the game the fight is a part of
+      def initialize(game)
+        @home = game.home
+        @away = game.away
+        @prng = game.prng
+        @actions = 0
+        @players = {
+          home: [@home.random_player(@prng)],
+          away: [@away.random_player(@prng)]
+        }
+        @score = { home: 0, away: 0 }
+        @in_progress = true
+      end
+
+      # @return [Message] the message to add to the game stream
+      def next_action
+        @actions += 1
+
+        case @prng.rand(@actions)
+        when 0..3 # attack
+          if rand_is_home?
+            attack(:home, :away)
+          else
+            attack(:away, :home)
+          end
+        when 4..7 # player joins
+          team_joining_sym = rand_is_home? ? :away : :home
+          team_joining = send(team_joining_sym)
+
+          player_joining = team_joining.random_player(
+            @prng,
+            proc { |player| !@players[team_joining_sym].include?(player) }
+          )
+          @players[team_joining_sym] << player_joining
+
+          Message.PlayerJoinedFight(team_joining, player_joining)
+        else # fight ends
+          @in_progress = false
+
+          Message.FightEnded
+        end
+      end
+
+      private
+
+      # @param attacking_team [Team]
+      # @param defending_team [Team]
+      # @return [Message] returned by #next_action for same purpose
+      def attack(attacking_team, defending_team)
+        attacking_player = @players[attacking_team].sample(random: @prng)
+        defending_player = @players[defending_team].sample(random: @prng)
+
+        blocked = !action_succeeds?(attacking_player.stats[:offense],
+                                    defending_player.stats[:defense])
+
+        @score[attacking_team] += 1 unless blocked
+
+        Message.FightAttack(attacking_player, defending_player, blocked)
+      end
+
+      # @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
+
+        @prng.rand(home_player_amount + away_player_amount) < home_player_amount
+      end
+    end
+  end
+end

data/lib/hlockey/game.rb

@@ -0,0 +1,254 @@
+require("hlockey/game/actions")
+require("hlockey/game/fight")
+require("hlockey/constants")
+require("hlockey/message")
+
+module Hlockey
+  ##
+  # A single game of Hlockey
+  class Game
+    include(Actions)
+
+    ACTIONS_PER_PERIOD = 60
+    NON_OT_PERIODS = 4
+    NON_OT_ACTIONS = ACTIONS_PER_PERIOD * NON_OT_PERIODS
+    TOTAL_ACTIONS = UPDATES_PER_HOUR - ACTIONS_PER_PERIOD
+    TOTAL_PERIODS = TOTAL_ACTIONS / ACTIONS_PER_PERIOD
+
+    # @return [Array<Message>]
+    attr_reader(:stream)
+
+    # @return [Weather]
+    attr_reader(:weather)
+
+    # @param home [Team]
+    # @param away [Team]
+    # @param prng [Random] should be League#prng
+    # @param weather [Class<Weather>]
+    def initialize(home, away, prng, weather)
+      @home = home
+      @away = away
+      @prng = prng
+      @weather = weather.new(self)
+      @stream = [Message.StartOfGame]
+      @score = { home: 0, away: 0 }
+      @in_progress = true
+      @actions = 0
+      @period = 1
+      @faceoff = true
+      @team_with_puck = nil
+      @puckless_team = nil
+      @puck_holder = nil
+      @shooting_chance = 0
+      @fight = nil
+      @fight_chance = 0
+      @total_fight_actions = 0
+      @pre_morale_change_stats = {}
+
+      @weather.on_game_start
+    end
+
+    # @return [String]
+    def to_s
+      "#{@home} vs #{@away}"
+    end
+
+    def update
+      return unless @in_progress
+
+      unless @fight.nil?
+        @stream << @fight.next_action
+        if @stream.last.event == :FightEnded
+          @total_fight_actions += @fight.actions
+
+          morale_change_amount = (@fight.score[:home] - @fight.score[:away]) * 0.05
+          boost_morale(@home, morale_change_amount)
+          boost_morale(@away, -morale_change_amount)
+
+          @fight = nil
+        end
+        return
+      end
+
+      @stream << Message.StartOfPeriod(@period) if @actions.zero?
+      @actions += 1
+
+      if @actions >= ACTIONS_PER_PERIOD
+        end_period
+        return
+      end
+
+      if @faceoff
+        do_faceoff
+        return
+      end
+
+      @weather.on_action
+
+      case @prng.rand(5 + @shooting_chance)
+      when 0..4
+        pass
+      when 5..6
+        check
+      else
+        shoot
+      end
+    end
+
+    private
+
+    def end_period
+      @weather.on_period_end
+      @stream << Message.EndOfPeriod(@period, @home, @away, *@score.values)
+      @actions = 0
+      @period += 1
+      start_faceoff
+
+      if @period >= NON_OT_PERIODS &&
+         !(@score[:home] == @score[:away] &&
+           @period <= TOTAL_PERIODS - (@total_fight_actions / ACTIONS_PER_PERIOD))
+        # Game is over
+        @pre_morale_change_stats.each { |player, stats| player.stats = stats }
+        @weather.on_game_end
+        @in_progress = false
+        winner, loser = @score[:away] > @score[:home] ? [@away, @home] : [@home, @away]
+        @stream << Message.EndOfGame(winner)
+        winner.wins += 1
+        loser.losses += 1
+      end
+    end
+
+    def start_faceoff
+      @shooting_chance = 0
+      @faceoff = true
+      @puck_holder = nil
+    end
+
+    def do_faceoff
+      if @puck_holder.nil?
+        # Pass opposite team to who wins the puck to switch_team_with_puck,
+        # so @team_with_puck & @puckless_team are set to the correct values.
+        switch_team_with_puck(
+          if action_succeeds?(@home.roster[:center].stats[:offense],
+                              @away.roster[:center].stats[:offense])
+            @away
+          else
+            @home
+          end
+        )
+
+        @puck_holder = @team_with_puck.roster[:center]
+        @stream << Message.FaceOff(@puck_holder, @team_with_puck)
+      else
+        pass
+        @faceoff = false
+      end
+    end
+
+    def switch_team_with_puck(team_with_puck = @team_with_puck)
+      @team_with_puck, @puckless_team = if team_with_puck == @home
+                                          [@away, @home]
+                                        else
+                                          [@home, @away]
+                                        end
+      @shooting_chance = 0
+    end
+
+    def pass
+      sender = @puck_holder
+      receiver = random_puckless_non_goalie(@team_with_puck)
+      interceptor = random_puckless_non_goalie(@puckless_team)
+
+      if !@faceoff && try_take_puck(interceptor, 4) # Pass intercepted
+        @stream << Message.Pass(sender, receiver, interceptor, @team_with_puck)
+        return
+      end
+
+      @stream << Message.Pass(sender, receiver)
+      @puck_holder = receiver
+      @shooting_chance += 1
+    end
+
+    def check
+      defender = random_puckless_non_goalie(@puckless_team)
+      @stream << Message.Hit(@puck_holder, defender,
+                             try_take_puck(defender, 0, :defense), @team_with_puck)
+      @fight_chance += 0.1
+    end
+
+    def shoot
+      if @shooting_chance < 5 &&
+         try_block_shot(@puckless_team.roster[@prng.rand(2).zero? ? :ldef : :rdef])
+        return
+      end
+      return if try_block_shot(@puckless_team.roster[:goalie])
+
+      # Goal scored
+
+      scoring_team = @team_with_puck == @home ? :home : :away
+      @score[scoring_team] += 1
+      weather.on_goal(scoring_team)
+
+      @stream << Message.ShootScore(@puck_holder, @home, @away, *@score.values)
+
+      if @prng.rand(3 + @fight_chance) > 5 &&
+         @total_fight_actions < TOTAL_ACTIONS - NON_OT_ACTIONS
+        start_fight
+      end
+
+      start_faceoff
+      @actions = ACTIONS_PER_PERIOD - 1 if @period >= NON_OT_PERIODS # Sudden death OT
+    end
+
+    # @return [Boolean] if taking the puck succeeded
+    def try_take_puck(player, disadvantage = 0, stat = :agility)
+      return false unless action_succeeds?(player.stats[stat] - disadvantage,
+                                           @puck_holder.stats[stat])
+
+      switch_team_with_puck
+      @puck_holder = player
+
+      true
+    end
+
+    # @return [Boolean] if blocking the shot succeeded
+    def try_block_shot(blocker)
+      return false unless action_succeeds?(blocker.stats[:defense],
+                                           @puck_holder.stats[:offense])
+
+      @shooting_chance += 1
+      @stream << Message.ShootBlock(@puck_holder, blocker,
+                                    try_take_puck(blocker), @team_with_puck)
+
+      true
+    end
+
+    def start_fight
+      @fight = Fight.new(self)
+      @stream << Message.FightStarted(@fight.players[:home].first,
+                                      @fight.players[:away].first)
+    end
+
+    # @param team [Team]
+    # @param amount [Numeric]
+    def boost_morale(team, amount)
+      return if amount.zero?
+
+      team.roster.each_value do |player|
+        if @pre_morale_change_stats[player].nil?
+          @pre_morale_change_stats[player] = player.stats.clone
+        end
+
+        player.stats.transform_values! { |stat| stat + amount }
+      end
+    end
+
+    # @return [Player]
+    def random_puckless_non_goalie(team)
+      team.random_player(
+        @prng,
+        proc { |player| player != team.roster[:goalie] and player != @puck_holder }
+      )
+    end
+  end
+end

data/lib/hlockey/league.rb

@@ -0,0 +1,150 @@
+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