tf2_line_parser 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 154268d4f08d4e2884a89fa90b3a18b901c6cafbd846fa58636e84fb2b59822f
-  data.tar.gz: 4056b354a1d1b3f98b1920250a80b7dc9541042588319510e48d9378bfa7422a
+  metadata.gz: 5c1d38c81d58d2ecb10aa612b2602de4abf47b540ec3caf003273a87cdcdb5ba
+  data.tar.gz: 7993c5640a38063e5082780475881b1faca2898a5f6555ac4040ff612f341f2c
 SHA512:
-  metadata.gz: e154de1385eb0fd25814f087f53578590af635aaff826d6a9a9df822e288359254834c14b0a99170c25dc61bdea57b8712b22913bfe38998fccc07d172b22c8b
-  data.tar.gz: f8d7bcd26fb42e81b4de558d302e3574754542e0e1d65593bb925b92749453a64f706a41253df9a4eced5579fed7230f75b6aeb31db03615bbc5877f7e1ae1ea
+  metadata.gz: 41f0d0adece361d3e97a3ec48466dd8123fdc95d8ea26f5616f57f125426225a36f6dfc2d1a5611115993863980d2d18e08d49f46397bba71dbe8775f0c7ef65
+  data.tar.gz: 872376b6810e9d6031cbd0d6cf38156ef99fba2dbf91174761c354a44fa040f9d7809bb5736518406bccdecbfb1f3a3f1314f6c54be14000a88af223a2287ee0

data/Gemfile.lock

@@ -1,30 +1,12 @@
 PATH
   remote: .
   specs:
-    tf2_line_parser (0.4.0)
-      activesupport
+    tf2_line_parser (0.5.0)
 
 GEM
   remote: https://rubygems.org/
   specs:
-    activesupport (8.0.2)
-      base64
-      benchmark (>= 0.3)
-      bigdecimal
-      concurrent-ruby (~> 1.0, >= 1.3.1)
-      connection_pool (>= 2.2.5)
-      drb
-      i18n (>= 1.6, < 2)
-      logger (>= 1.4.2)
-      minitest (>= 5.1)
-      securerandom (>= 0.3)
-      tzinfo (~> 2.0, >= 2.0.5)
-      uri (>= 0.13.1)
-    base64 (0.3.0)
-    benchmark (0.4.1)
-    bigdecimal (3.2.2)
-    concurrent-ruby (1.3.5)
-    connection_pool (2.5.3)
+    bigdecimal (4.0.1)
     coveralls_reborn (0.29.0)
       simplecov (~> 0.22.0)
       term-ansicolor (~> 1.7)
@@ -32,42 +14,41 @@ GEM
       tins (~> 1.32)
     diff-lcs (1.6.2)
     docile (1.4.1)
-    drb (2.2.3)
-    i18n (1.14.7)
-      concurrent-ruby (~> 1.0)
-    json (2.12.2)
-    logger (1.7.0)
-    minitest (5.25.5)
-    rspec (3.13.1)
+    io-console (0.8.2)
+    json (2.18.0)
+    mize (0.6.1)
+    readline (0.0.4)
+      reline
+    reline (0.6.3)
+      io-console (~> 0.5)
+    rspec (3.13.2)
       rspec-core (~> 3.13.0)
       rspec-expectations (~> 3.13.0)
       rspec-mocks (~> 3.13.0)
-    rspec-core (3.13.4)
+    rspec-core (3.13.6)
       rspec-support (~> 3.13.0)
     rspec-expectations (3.13.5)
       diff-lcs (>= 1.2.0, < 2.0)
       rspec-support (~> 3.13.0)
-    rspec-mocks (3.13.5)
+    rspec-mocks (3.13.7)
       diff-lcs (>= 1.2.0, < 2.0)
       rspec-support (~> 3.13.0)
-    rspec-support (3.13.4)
-    securerandom (0.4.1)
+    rspec-support (3.13.6)
     simplecov (0.22.0)
       docile (~> 1.1)
       simplecov-html (~> 0.11)
       simplecov_json_formatter (~> 0.1)
-    simplecov-html (0.13.1)
+    simplecov-html (0.13.2)
     simplecov_json_formatter (0.1.4)
     sync (0.5.0)
-    term-ansicolor (1.11.2)
-      tins (~> 1.0)
-    thor (1.3.2)
-    tins (1.38.0)
+    term-ansicolor (1.11.3)
+      tins (~> 1)
+    thor (1.4.0)
+    tins (1.51.0)
       bigdecimal
+      mize (~> 0.6)
+      readline
       sync
-    tzinfo (2.0.6)
-      concurrent-ruby (~> 1.0)
-    uri (1.0.3)
 
 PLATFORMS
   ruby

data/lib/tf2_line_parser/events/airshot.rb

@@ -4,11 +4,16 @@ module TF2LineParser
   module Events
     class Airshot < Damage
       def self.regex
-        @regex ||= /#{regex_time} #{regex_player} triggered "damage" #{regex_damage_against}\(damage "(?'value'\d+)"\)#{regex_realdamage}#{regex_weapon}#{regex_healing}#{regex_crit}#{regex_headshot} #{regex_airshot}$/.freeze
+        # Airshot can appear after weapon, with optional height at the end
+        @regex ||= /#{regex_time} #{regex_player} triggered "damage" #{regex_damage_against}\(damage "(?'value'\d+)"\)#{regex_realdamage}#{regex_weapon}#{regex_airshot}#{regex_height}/.freeze
       end
 
       def self.regex_airshot
-        @regex_airshot ||= '\(airshot "(?\'airshot\'\w*)"\)'
+        @regex_airshot ||= / \(airshot "(?'airshot'\w*)"\)/
+      end
+
+      def self.regex_height
+        @regex_height ||= /(?: \(height "(?'height'\d*)"\))?/
       end
 
       def self.attributes
@@ -40,7 +45,11 @@ module TF2LineParser
         @player = Player.new(player_name, player_uid, player_steamid, player_team)
         @target = Player.new(target_name, target_uid, target_steamid, target_team) if target_name
         @value = value.to_i
+        @damage = @value
         @weapon = weapon
+        @healing = nil
+        @crit = nil
+        @headshot = nil
         @airshot = (airshot.to_i == 1)
       end
     end

data/lib/tf2_line_parser/events/airshot_heal.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module TF2LineParser
+  module Events
+    class AirshotHeal < Heal
+      attr_reader :airshot
+
+      def self.regex
+        @regex ||= /#{regex_time} #{regex_player} triggered "healed" against #{regex_target} \(healing "(?'value'\d+)"\)#{regex_airshot}#{regex_height}/.freeze
+      end
+
+      def self.regex_airshot
+        @regex_airshot ||= / \(airshot "(?'airshot'\w*)"\)/
+      end
+
+      def self.regex_height
+        @regex_height ||= /(?: \(height "(?'height'\d*)"\))?/
+      end
+
+      def self.attributes
+        @attributes ||= %i[time player_section target_section value airshot]
+      end
+
+      def initialize(time, player_name, player_uid, player_steam_id, player_team, target_name, target_uid, target_steam_id, target_team, value, airshot)
+        @time = parse_time(time)
+        @player = Player.new(player_name, player_uid, player_steam_id, player_team)
+        @target = Player.new(target_name, target_uid, target_steam_id, target_team)
+        @value = value.to_i
+        @healing = @value
+        @airshot = (airshot.to_i == 1)
+      end
+    end
+  end
+end

data/lib/tf2_line_parser/events/built_object.rb

@@ -4,7 +4,7 @@ module TF2LineParser
       attr_reader :time, :player, :object
 
       def self.regex
-        @regex ||= /#{regex_time} #{regex_player} triggered "builtobject" #{regex_object_info}#{regex_position}?/.freeze
+        @regex ||= /#{regex_time} #{regex_player} triggered "(?:player_)?builtobject" #{regex_object_info}#{regex_position}?/.freeze
       end
 
       def self.regex_object_info

data/lib/tf2_line_parser/events/damage.rb

@@ -3,7 +3,7 @@
 module TF2LineParser
   module Events
     class Damage < Event
-      attr_reader :crit, :headshot, :healing
+      attr_reader :damage, :crit, :headshot, :healing
 
       def self.regex
         @regex ||= /#{regex_time} #{regex_player} triggered "damage" #{regex_damage_against}\(damage "(?'value'\d+)"\)#{regex_realdamage}#{regex_weapon}#{regex_healing}#{regex_crit}#{regex_headshot}/.freeze
@@ -64,6 +64,7 @@ module TF2LineParser
         @player = Player.new(player_name, player_uid, player_steamid, player_team)
         @target = Player.new(target_name, target_uid, target_steamid, target_team) if target_name
         @value = value.to_i
+        @damage = @value
         @weapon = weapon
         @healing = healing.to_i if healing
         @crit = crit

data/lib/tf2_line_parser/events/event.rb

@@ -11,7 +11,7 @@ module TF2LineParser
       end
 
       def self.regex_time
-        @regex_time ||= 'L (?\'time\'.*):'
+        @regex_time ||= 'L (?\'time\'\\d{2}/\\d{2}/\\d{4} - \\d{2}:\\d{2}:\\d{2}):'
       end
 
       def self.regex_player
@@ -36,7 +36,7 @@ module TF2LineParser
 
       def self.types
         # ordered by how common the messages are
-        @types ||= [HeadshotDamage, Airshot, Damage, Heal, PickupItem, Assist, Kill, CaptureBlock, PointCapture, ChargeDeployed,
+        @types ||= [ShotFired, ShotHit, PositionReport, HeadshotDamage, Airshot, Damage, AirshotHeal, Heal, PickupItem, Assist, Kill, CaptureBlock, PointCapture, ChargeDeployed,
                     MedicDeath, MedicDeathEx, EmptyUber, ChargeReady, ChargeEnded, FirstHealAfterSpawn, LostUberAdvantage, BuiltObject, PlayerExtinguished, JoinedTeam, EnteredGame, RoleChange, Spawn, Suicide, KilledObject, Say, TeamSay, Domination, Revenge, RoundWin, CurrentScore,
                     RoundLength, RoundStart, RoundSetupBegin, RoundSetupEnd, MiniRoundStart, MiniRoundSelected, IntermissionWinLimit, Connect, Disconnect, RconCommand, ConsoleSay, MatchEnd, FinalScore,
                     RoundStalemate, Unknown].freeze

data/lib/tf2_line_parser/events/headshot_damage.rb

@@ -12,7 +12,7 @@ module TF2LineParser
       end
 
       def self.attributes
-        @attributes ||= %i[time player_section target_section value weapon]
+        @attributes ||= %i[time player_section target_section value weapon healing crit headshot]
       end
 
       def self.regex_results(matched_line)
@@ -21,6 +21,9 @@ module TF2LineParser
         target_section = matched_line['target_section']
         value = matched_line['value']
         weapon = matched_line['weapon']
+        healing = matched_line['healing']
+        crit = matched_line['crit']
+        headshot = matched_line['headshot']
 
         # Parse player section
         player_name, player_uid, player_steamid, player_team = parse_player_section(player_section)
@@ -31,15 +34,19 @@ module TF2LineParser
           target_name, target_uid, target_steamid, target_team = parse_target_section(target_section)
         end
 
-        [time, player_name, player_uid, player_steamid, player_team, target_name, target_uid, target_steamid, target_team, value, weapon]
+        [time, player_name, player_uid, player_steamid, player_team, target_name, target_uid, target_steamid, target_team, value, weapon, healing, crit, headshot]
       end
 
-      def initialize(time, player_name, player_uid, player_steamid, player_team, target_name, target_uid, target_steamid, target_team, value, weapon)
+      def initialize(time, player_name, player_uid, player_steamid, player_team, target_name, target_uid, target_steamid, target_team, value, weapon, healing, crit, headshot)
         @time = parse_time(time)
         @player = Player.new(player_name, player_uid, player_steamid, player_team)
         @target = Player.new(target_name, target_uid, target_steamid, target_team) if target_name
         @value = value.to_i
+        @damage = @value
         @weapon = weapon
+        @healing = healing.to_i if healing
+        @crit = crit
+        @headshot = true  # Always true for HeadshotDamage events
       end
     end
   end

data/lib/tf2_line_parser/events/joined_team.rb

@@ -16,6 +16,10 @@ module TF2LineParser
       def self.attributes
         @attributes ||= %i[time player_section team_name]
       end
+
+      def team
+        @team_name
+      end
     end
   end
 end

data/lib/tf2_line_parser/events/position_report.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module TF2LineParser
+  module Events
+    class PositionReport < Event
+      attr_reader :time, :player, :position
+
+      def self.regex
+        @regex ||= /#{regex_time} #{regex_player} position_report \(position "(?'position'[^"]+)"\)/.freeze
+      end
+
+      def self.attributes
+        @attributes ||= %i[time player_section position]
+      end
+
+      def initialize(time, name, uid, steam_id, team, position)
+        @time = parse_time(time)
+        @player = Player.new(name, uid, steam_id, team)
+        @position = position
+      end
+    end
+  end
+end

data/lib/tf2_line_parser/events/shot_fired.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module TF2LineParser
+  module Events
+    class ShotFired < PlayerActionEvent
+      def self.action_text
+        @action_text ||= 'triggered "shot_fired"'
+      end
+
+      def self.regex_action
+        @regex_action ||= '\(weapon "(?\'weapon\'[^\"]+)"\)'
+      end
+
+      def self.item
+        :weapon
+      end
+
+      def self.attributes
+        @attributes ||= %i[time player_section weapon]
+      end
+
+      def initialize(time, player_name, player_uid, player_steam_id, player_team, weapon)
+        @time = parse_time(time)
+        @player = Player.new(player_name, player_uid, player_steam_id, player_team)
+        @weapon = weapon
+      end
+    end
+  end
+end

data/lib/tf2_line_parser/events/shot_hit.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module TF2LineParser
+  module Events
+    class ShotHit < PlayerActionEvent
+      def self.action_text
+        @action_text ||= 'triggered "shot_hit"'
+      end
+
+      def self.regex_action
+        @regex_action ||= '\(weapon "(?\'weapon\'[^\"]+)"\)'
+      end
+
+      def self.item
+        :weapon
+      end
+
+      def self.attributes
+        @attributes ||= %i[time player_section weapon]
+      end
+
+      def initialize(time, player_name, player_uid, player_steam_id, player_team, weapon)
+        @time = parse_time(time)
+        @player = Player.new(player_name, player_uid, player_steam_id, player_team)
+        @weapon = weapon
+      end
+    end
+  end
+end

data/lib/tf2_line_parser/line.rb

@@ -1,31 +1,138 @@
 # frozen_string_literal: true
 
 require 'time'
-require 'active_support/multibyte/chars'
-require 'active_support/multibyte/unicode'
 
 module TF2LineParser
   class Line
     attr_accessor :line
 
+    # Keyword to event types mapping (order matters for subtypes!)
+    KEYWORD_DISPATCH = {
+      'shot_fired' => [Events::ShotFired],
+      'shot_hit' => [Events::ShotHit],
+      'damage' => [Events::HeadshotDamage, Events::Airshot, Events::Damage],
+      'healed' => [Events::AirshotHeal, Events::Heal],
+      'picked up' => [Events::PickupItem],
+      'kill assist' => [Events::Assist],
+      'killed' => [Events::Kill],
+      'killedobject' => [Events::KilledObject],
+      'captureblocked' => [Events::CaptureBlock],
+      'pointcaptured' => [Events::PointCapture],
+      'chargedeployed' => [Events::ChargeDeployed],
+      'medic_death_ex' => [Events::MedicDeathEx],
+      'medic_death' => [Events::MedicDeath],
+      'empty_uber' => [Events::EmptyUber],
+      'chargeready' => [Events::ChargeReady],
+      'chargeended' => [Events::ChargeEnded],
+      'first_heal_after_spawn' => [Events::FirstHealAfterSpawn],
+      'lost_uber_advantage' => [Events::LostUberAdvantage],
+      'builtobject' => [Events::BuiltObject],
+      'player_builtobject' => [Events::BuiltObject],
+      'player_extinguished' => [Events::PlayerExtinguished],
+      'joined team' => [Events::JoinedTeam],
+      'entered the game' => [Events::EnteredGame],
+      'changed role' => [Events::RoleChange],
+      'spawned as' => [Events::Spawn],
+      'committed suicide' => [Events::Suicide],
+      'domination' => [Events::Domination],
+      'revenge' => [Events::Revenge],
+      'Round_Win' => [Events::RoundWin],
+      'Round_Length' => [Events::RoundLength],
+      'Round_Start' => [Events::RoundStart],
+      'Round_Setup_Begin' => [Events::RoundSetupBegin],
+      'Round_Setup_End' => [Events::RoundSetupEnd],
+      'Mini_Round_Start' => [Events::MiniRoundStart],
+      'Mini_Round_Selected' => [Events::MiniRoundSelected],
+      'Intermission_Win_Limit' => [Events::IntermissionWinLimit],
+      'Round_Stalemate' => [Events::RoundStalemate],
+      'Game_Over' => [Events::MatchEnd],
+      'connected, address' => [Events::Connect],
+      'disconnected' => [Events::Disconnect],
+      'say_team' => [Events::TeamSay],
+      'say "' => [Events::Say],
+      'position_report' => [Events::PositionReport],
+    }.freeze
+
+    # Fallback types when no keyword matches
+    FALLBACK_TYPES = [
+      Events::CurrentScore, Events::FinalScore, Events::RconCommand,
+      Events::ConsoleSay, Events::Unknown
+    ].freeze
+
     def initialize(line)
       @line = line
     end
 
     def parse
-      Events::Event.types.each do |type|
-        begin
-          match = line.match(type.regex)
-        rescue ArgumentError
-          tidied_line = ActiveSupport::Multibyte::Chars.new(line).tidy_bytes
-          match = tidied_line.match(type.regex)
+      self.class.parse(@line)
+    end
+
+    # Class method to parse without object allocation
+    def self.parse(line)
+      types = find_candidate_types(line)
+      try_parse_types(line, types)
+    end
+
+    class << self
+      private
+
+      def find_candidate_types(line)
+        # Fast path: check for "triggered" which covers most events
+        if line.include?('triggered "')
+          start_idx = line.index('triggered "')
+          if start_idx
+            end_idx = line.index('"', start_idx + 11)
+            if end_idx
+              keyword = line[start_idx + 11...end_idx]
+              types = KEYWORD_DISPATCH[keyword]
+              return types if types
+            end
+          end
+        end
+
+        # Check other common patterns with simple string operations
+        if line.include?('" killed "')
+          [Events::Kill]
+        elsif line.include?('position_report')
+          [Events::PositionReport]
+        elsif line.include?('" say_team "')
+          [Events::TeamSay]
+        elsif line.include?('" say "')
+          [Events::Say]
+        elsif line.include?('picked up item')
+          [Events::PickupItem]
+        elsif line.include?('joined team "')
+          [Events::JoinedTeam]
+        elsif line.include?('entered the game')
+          [Events::EnteredGame]
+        elsif line.include?('changed role to')
+          [Events::RoleChange]
+        elsif line.include?('spawned as "')
+          [Events::Spawn]
+        elsif line.include?('committed suicide')
+          [Events::Suicide]
+        elsif line.include?('connected, address')
+          [Events::Connect]
+        elsif line.include?('disconnected (reason')
+          [Events::Disconnect]
+        else
+          FALLBACK_TYPES
         end
-        if match
-          @match ||= type.new(*type.regex_results(match))
-          break
+      end
+
+      def try_parse_types(line, types)
+        types.each do |type|
+          begin
+            match = line.match(type.regex)
+          rescue ArgumentError
+            # Handle invalid byte sequences by forcing UTF-8 encoding
+            tidied_line = line.encode('UTF-8', 'UTF-8', invalid: :replace, undef: :replace, replace: '')
+            match = tidied_line.match(type.regex)
+          end
+          return type.new(*type.regex_results(match)) if match
         end
+        nil
       end
-      @match
     end
   end
 end

data/lib/tf2_line_parser/parser.rb

@@ -11,5 +11,10 @@ module TF2LineParser
     def parse
       line.parse
     end
+
+    # Class method to parse without object allocation overhead
+    def self.parse(line)
+      Line.parse(line.to_s)
+    end
   end
 end

data/lib/tf2_line_parser/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module TF2LineParser
-  VERSION = '0.4.0'
+  VERSION = '0.5.0'
 end

data/lib/tf2_line_parser.rb

@@ -13,6 +13,7 @@ require 'tf2_line_parser/events/connect'
 require 'tf2_line_parser/events/score'
 require 'tf2_line_parser/events/role_change'
 require 'tf2_line_parser/events/damage'
+require 'tf2_line_parser/events/heal'
 Dir["#{File.dirname(__FILE__)}/tf2_line_parser/events/*.rb"].sort.each { |file| require file }
 require 'tf2_line_parser/line'
 

data/spec/fixtures/logs/airshot.log

@@ -1 +1,7 @@
 L 05/15/2014 - 18:22:27: "super sanic<5><STEAM_0:0:64268661><Red>" triggered "damage" against "kerrieebOb<11><STEAM_0:0:11431287><Blue>" (damage "47") (weapon "tf_projectile_rocket") (airshot "1")
+L 12/18/2025 - 22:06:01: "tantwo<17><[U:1:191375689]><Blue>" triggered "damage" against "ryftomania(big/guy)<8><[U:1:468872526]><Red>" (damage "105") (realdamage "88") (weapon "quake_rl") (airshot "1") (height "353")
+L 12/18/2025 - 22:07:05: "merkules<11><[U:1:86331856]><Blue>" triggered "healed" against "fy<14><[U:1:442791013]><Blue>" (healing "82") (airshot "1") (height "261")
+L 12/18/2025 - 22:10:55: "fy<14><[U:1:442791013]><Blue>" triggered "damage" against "keicam<9><[U:1:163231154]><Red>" (damage "50") (realdamage "26") (weapon "tf_projectile_rocket") (airshot "1") (height "292")
+L 12/18/2025 - 22:12:57: "tantwo<17><[U:1:191375689]><Blue>" triggered "damage" against "keicam<9><[U:1:163231154]><Red>" (damage "105") (weapon "quake_rl") (airshot "1") (height "318")
+L 12/18/2025 - 22:12:58: "tantwo<17><[U:1:191375689]><Blue>" triggered "damage" against "keicam<9><[U:1:163231154]><Red>" (damage "99") (realdamage "9") (weapon "quake_rl") (airshot "1") (height "427")
+L 12/18/2025 - 22:15:21: "fy<14><[U:1:442791013]><Blue>" triggered "damage" against "gibusmain<19><[U:1:258908204]><Red>" (damage "109") (realdamage "66") (weapon "tf_projectile_rocket") (airshot "1") (height "228")

data/spec/lib/tf2_line_parser/parser_spec.rb

@@ -96,11 +96,71 @@ module TF2LineParser
         parse(line).inspect
       end
 
+      it 'recognizes airshots with realdamage and height' do
+        line = airshot_log_lines[1]
+        result = parse(line)
+        expect(result).to be_a(Events::Airshot)
+        expect(result.player.name).to eq('tantwo')
+        expect(result.player.steam_id).to eq('[U:1:191375689]')
+        expect(result.player.team).to eq('Blue')
+        expect(result.target.name).to eq('ryftomania(big/guy)')
+        expect(result.target.steam_id).to eq('[U:1:468872526]')
+        expect(result.target.team).to eq('Red')
+        expect(result.damage).to eq(105)
+        expect(result.weapon).to eq('quake_rl')
+        expect(result.airshot).to eq(true)
+      end
+
+      it 'recognizes airshots without realdamage' do
+        line = airshot_log_lines[4]
+        result = parse(line)
+        expect(result).to be_a(Events::Airshot)
+        expect(result.player.name).to eq('tantwo')
+        expect(result.damage).to eq(105)
+        expect(result.weapon).to eq('quake_rl')
+        expect(result.airshot).to eq(true)
+      end
+
+      it 'recognizes airshot heals (Crusader Crossbow mid-air)' do
+        line = airshot_log_lines[2]
+        result = parse(line)
+        expect(result).to be_a(Events::AirshotHeal)
+        expect(result.player.name).to eq('merkules')
+        expect(result.player.steam_id).to eq('[U:1:86331856]')
+        expect(result.player.team).to eq('Blue')
+        expect(result.target.name).to eq('fy')
+        expect(result.target.steam_id).to eq('[U:1:442791013]')
+        expect(result.target.team).to eq('Blue')
+        expect(result.healing).to eq(82)
+        expect(result.airshot).to eq(true)
+      end
+
+      it 'parses all damage airshot log lines correctly' do
+        damage_airshot_lines = airshot_log_lines.reject { |l| l.include?('healed') }
+        damage_airshot_lines.each do |line|
+          result = parse(line)
+          expect(result).to be_a(Events::Airshot), "Expected Airshot for: #{line}"
+          expect(result.airshot).to eq(true)
+        end
+      end
+
+      it 'parses all heal airshot log lines correctly' do
+        heal_airshot_lines = airshot_log_lines.select { |l| l.include?('healed') }
+        heal_airshot_lines.each do |line|
+          result = parse(line)
+          expect(result).to be_a(Events::AirshotHeal), "Expected AirshotHeal for: #{line}"
+          expect(result.airshot).to eq(true)
+        end
+      end
+
       it 'recognizes sniper headshot damage' do
         line = detailed_log_lines[3645]
         weapon = 'sniperrifle'
+        healing = nil
+        crit = nil
+        headshot = '1'
         expect(Events::HeadshotDamage).to receive(:new).with(anything, anything, anything, anything, anything, anything,
-                                                             anything, anything, anything, anything, weapon)
+                                                             anything, anything, anything, anything, weapon, healing, crit, headshot)
         parse(line).inspect
       end
 
@@ -585,6 +645,39 @@ module TF2LineParser
         parse(line)
       end
 
+      it 'recognizes shot_fired' do
+        line = 'L 12/30/2025 - 18:34:19: "Jib<34><[U:1:367944796]><Blue>" triggered "shot_fired" (weapon "tf_projectile_rocket")'
+        result = parse(line)
+        expect(result).to be_a(Events::ShotFired)
+        expect(result.player.name).to eq('Jib')
+        expect(result.player.uid).to eq('34')
+        expect(result.player.steam_id).to eq('[U:1:367944796]')
+        expect(result.player.team).to eq('Blue')
+        expect(result.weapon).to eq('tf_projectile_rocket')
+      end
+
+      it 'recognizes shot_hit' do
+        line = 'L 12/30/2025 - 18:34:19: "Jib<34><[U:1:367944796]><Blue>" triggered "shot_hit" (weapon "tf_projectile_rocket")'
+        result = parse(line)
+        expect(result).to be_a(Events::ShotHit)
+        expect(result.player.name).to eq('Jib')
+        expect(result.player.uid).to eq('34')
+        expect(result.player.steam_id).to eq('[U:1:367944796]')
+        expect(result.player.team).to eq('Blue')
+        expect(result.weapon).to eq('tf_projectile_rocket')
+      end
+
+      it 'recognizes position_report' do
+        line = 'L 12/30/2025 - 18:34:19: "Jib<34><[U:1:367944796]><Blue>" position_report (position "306 -1464 -237")'
+        result = parse(line)
+        expect(result).to be_a(Events::PositionReport)
+        expect(result.player.name).to eq('Jib')
+        expect(result.player.uid).to eq('34')
+        expect(result.player.steam_id).to eq('[U:1:367944796]')
+        expect(result.player.team).to eq('Blue')
+        expect(result.position).to eq('306 -1464 -237')
+      end
+
       it 'recognizes suicides' do
         line = log_lines[76]
         name = '.schocky'

data/tf2_line_parser.gemspec

@@ -15,7 +15,6 @@ Gem::Specification.new do |gem|
   gem.require_paths = ['lib']
   gem.homepage      = 'http://github.com/Arie/tf2_line_parser'
 
-  gem.add_dependency 'activesupport'
   gem.add_development_dependency 'coveralls_reborn'
   gem.add_development_dependency 'rspec'
   gem.add_development_dependency 'simplecov'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: tf2_line_parser
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.0
 platform: ruby
 authors:
 - Arie
@@ -10,20 +10,6 @@ bindir: bin
 cert_chain: []
 date: 2025-12-31 00:00:00.000000000 Z
 dependencies:
-- !ruby/object:Gem::Dependency
-  name: activesupport
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
 - !ruby/object:Gem::Dependency
   name: coveralls_reborn
   requirement: !ruby/object:Gem::Requirement
@@ -95,6 +81,7 @@ files:
 - README.md
 - lib/tf2_line_parser.rb
 - lib/tf2_line_parser/events/airshot.rb
+- lib/tf2_line_parser/events/airshot_heal.rb
 - lib/tf2_line_parser/events/assist.rb
 - lib/tf2_line_parser/events/built_object.rb
 - lib/tf2_line_parser/events/capture_block.rb
@@ -129,6 +116,7 @@ files:
 - lib/tf2_line_parser/events/player_action_event.rb
 - lib/tf2_line_parser/events/player_extinguished.rb
 - lib/tf2_line_parser/events/point_capture.rb
+- lib/tf2_line_parser/events/position_report.rb
 - lib/tf2_line_parser/events/pvp_event.rb
 - lib/tf2_line_parser/events/rcon_command.rb
 - lib/tf2_line_parser/events/revenge.rb
@@ -142,6 +130,8 @@ files:
 - lib/tf2_line_parser/events/round_start.rb
 - lib/tf2_line_parser/events/round_win.rb
 - lib/tf2_line_parser/events/score.rb
+- lib/tf2_line_parser/events/shot_fired.rb
+- lib/tf2_line_parser/events/shot_hit.rb
 - lib/tf2_line_parser/events/spawn.rb
 - lib/tf2_line_parser/events/suicide.rb
 - lib/tf2_line_parser/events/unknown.rb