hlockey 2 → 3

data/{lib/hlockey/data → data}/links.yaml

@@ -1,2 +1,2 @@
-:GitHub: https://github.com/Hlockey
-:Discord: https://discord.gg/hQMRZyexUB
+: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

@@ -1,13 +1,17 @@
-# frozen_string_literal: true
-
-require('yaml')
-
-module Hlockey
-  # Loads data for the current Hlockey season.
-  # +category+ can be 'league', 'election', 'information', or 'links'.
-  # If it is anything else, there will be an error.
-  def Hlockey.load_data(category)
-    # If this is only used on data included with the gem, it should be safe
-    YAML.unsafe_load_file(File.expand_path("data/#{category}.yaml", __dir__))
-  end
-end
+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

@@ -1,159 +1,254 @@
-# frozen_string_literal: true
-
-require('hlockey/messages')
-
-module Hlockey
-  class Game
-    attr_reader(:home, :away, :stream, :score, :in_progress)
-
-    def initialize(home, away, prng)
-      @home = home
-      @away = away
-      @prng = prng
-      @stream = [Messages.StartOfGame]
-      @score = { home: 0, away: 0 }
-      @in_progress = true
-      @actions = 0
-      @period = 1
-      @face_off = true
-      @team_with_puck = nil
-      @puckless_team = nil
-      @puck_holder = nil
-      @shooting_chance = 0
-    end
-
-    def to_s
-      "#{@home} vs #{@away}"
-    end
-
-    def update
-      return unless @in_progress
-
-      @stream << Messages.StartOfPeriod(@period) if @actions.zero?
-      @actions += 1
-
-      if @actions == 60
-        @stream << Messages.EndOfPeriod(@period, @home, @away, *@score.values)
-        @actions = 0
-        @period += 1
-        start_faceoff
-
-        if @period > 3 && !(@score[:home] == @score[:away] && @period < 12)
-          # Game is over
-          @in_progress = false
-
-          winner, loser = @score[:away] > @score[:home] ?
-            [@away, @home] : [@home, @away]
-
-          @stream << Messages.EndOfGame(winner)
-          winner.wins += 1
-          loser.losses += 1
-        end
-        return
-      end
-
-      if @face_off
-        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(
-            action_succeeds?(@home.roster[:center].stats[:offense],
-                             @away.roster[:center].stats[:offense]) ? @away : @home
-          )
-
-          @puck_holder = @team_with_puck.roster[:center]
-          @stream << Messages.FaceOff(@puck_holder, @team_with_puck)
-        else
-          pass
-          @face_off = false
-        end
-        return
-      end
-
-      case @prng.rand 5 + @shooting_chance
-      when 0..4
-        pass
-      when 5..6 # Check
-        check
-      else      # Shoot
-        unless @shooting_chance < 5 &&
-            try_block_shot(@puckless_team.roster[@prng.rand(2).zero? ?
-                                                 :ldef : :rdef]) ||
-            try_block_shot(@puckless_team.roster[:goalie])
-          @score[@team_with_puck == @home ? :home : :away] += 1
-
-          @stream << Messages.ShootScore(@puck_holder, @home, @away, *@score.values)
-
-          start_faceoff
-          @actions = 59 if @period > 3 # Sudden death overtime
-        end
-      end
-    end
-
-    private
-
-    def action_succeeds?(helping_stat, hindering_stat)
-      @prng.rand(10) + helping_stat - hindering_stat > 4
-    end
-
-    def start_faceoff
-      @shooting_chance = 0
-      @face_off = true
-      @puck_holder = nil
-    end
-
-    def switch_team_with_puck(team_with_puck = @team_with_puck)
-      @team_with_puck, @puckless_team = team_with_puck == @home ?
-                                        [@away, @home] : [@home, @away]
-      @shooting_chance = 0
-    end
-
-    def pass
-      sender = @puck_holder
-      receiver = puckless_non_goalie(@team_with_puck)
-      interceptor = puckless_non_goalie
-
-      if !@face_off && try_take_puck(interceptor, 4) # Pass intercepted
-        @stream << Messages.Pass(sender, receiver, interceptor, @team_with_puck)
-        return
-      end
-
-      @stream << Messages.Pass(sender, receiver)
-      @puck_holder = receiver
-      @shooting_chance += 1
-    end
-
-    def check
-      defender = puckless_non_goalie
-      @stream << Messages.Hit(@puck_holder, defender,
-                              try_take_puck(defender, 0, :defense), @team_with_puck)
-    end
-
-    def try_take_puck(player, dis = 0, stat = :agility)
-      return false unless action_succeeds?(player.stats[stat] - dis,
-                                           @puck_holder.stats[stat])
-
-      switch_team_with_puck
-      @puck_holder = player
-
-      true
-    end
-
-    def try_block_shot(blocker)
-      return false unless action_succeeds?(blocker.stats[:defense],
-                                           @puck_holder.stats[:offense])
-
-      @shooting_chance += 1
-      @stream << Messages.ShootBlock(@puck_holder, blocker,
-                                     try_take_puck(blocker), @team_with_puck)
-
-      true
-    end
-
-    def puckless_non_goalie(team = @puckless_team)
-      team.roster.values.select do |p|
-        p != team.roster[:goalie] and p != @puck_holder
-      end.sample(random: @prng)
-    end
-  end
-end
+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