Add killer logic to ContextLoader, refine the API.

sc2reader/data/__init__.py

@@ -53,10 +53,24 @@ def __init__(self, unit_id):
         #: Specifically, it is the frame that the :class:`~sc2reader.events.tracker.UnitDiedEvent` is received.
         self.died_at = None
 
+        #: Deprecated, see :attr:`self.killing_player`
+        self.killed_by = None
+
         #: A reference to the player that killed this unit. Only available for 2.0.8+ replays.
         #: This value is not set if the killer is unknown or not relevant (morphed into a
         #: different unit or used to create a building, etc)
-        self.killed_by = None
+        self.killing_player = None
+
+        #: A reference to the unit that killed this unit. Only available for 2.1+ replays.
+        #: This value is not set if the killer is unknown or not relevant (morphed into a
+        #: different unit or used to create a building, etc). If the killing unit dies before
+        #: the killed unit dies, a bug may cause the killing unit to be None. This can occur
+        #: due because of projectile speeds.
+        self.killing_unit = None
+
+        #: A list of units that this unit has killed. Only available for 2.1+ replays.
+        #: The unit only gets credit for the kills that it gets the final blow on.
+        self.killed_units = list()
 
         #: The unique in-game id for this unit. The id can sometimes be zero because
         #: TargetUnitCommandEvents will create a new unit with id zero when a unit

sc2reader/engine/plugins/context.py

@@ -146,13 +146,21 @@ def handleUnitDiedEvent(self, event, replay):
         else:
             self.logger.error("Unit {0} died at {1} [{2}] before it was born!".format(event.unit_id, Length(seconds=event.second), event.frame))
 
-        if event.killer_pid in replay.player:
-            event.killer = replay.player[event.killer_pid]
+        if event.killing_player_id in replay.player:
+            event.killing_player = event.killer = replay.player[event.killing_player_id]
             if event.unit:
-                event.unit.killed_by = event.killer
-                event.killer.killed_units.append(event.unit)
-        elif event.killer_pid:
-            self.logger.error("Unknown killer pid {0} at {1} [{2}]".format(event.killer_pid, Length(seconds=event.second), event.frame))
+                event.unit.killing_player = event.unit.killed_by = event.killing_player
+                event.killing_player.killed_units.append(event.unit)
+        elif event.killing_player_id:
+            self.logger.error("Unknown killing player id {0} at {1} [{2}]".format(event.killing_player_id, Length(seconds=event.second), event.frame))
+
+        if event.killing_unit_id in replay.objects:
+            event.killing_unit = replay.objects[event.killing_unit_id]
+            if event.unit:
+                event.unit.killing_unit = event.killing_unit
+                event.killing_unit.killed_units.append(event.unit)
+        elif event.killing_unit_id:
+            self.logger.error("Unknown killing unit id {0} at {1} [{2}]".format(event.killing_unit_id, Length(seconds=event.second), event.frame))
 
     def handleUnitOwnerChangeEvent(self, event, replay):
         self.load_tracker_controller(event, replay)

sc2reader/events/tracker.py

@@ -313,12 +313,18 @@ def __init__(self, frames, data, build):
         #: The unit object that died
         self.unit = None
 
-        #: The id of the player that killed this unit. None when not available.
+        #: Deprecated, see :attr:`killing_player_id`
         self.killer_pid = data[2]
 
-        #: The player object of the that killed the unit. Not always available.
+        #: Deprecated, see :attr:`killing_player`
         self.killer = None
 
+        #: The id of the player that killed this unit. None when not available.
+        self.killing_player_id = data[2]
+
+        #: The player object of the that killed the unit. Not always available.
+        self.killing_player = None
+
         #: The x coordinate of the center of the dying unit's footprint. Only 4 point resolution
         #: prior to Starcraft Patch 2.1.
         self.x = data[3]
@@ -331,24 +337,27 @@ def __init__(self, frames, data, build):
         self.location = (self.x, self.y)
 
         #: The index portion of the killing unit's id. Available for build 27950+
-        self.killer_unit_index = None
+        self.killing_unit_index = None
 
         #: The recycle portion of the killing unit's id. Available for build 27950+
-        self.killer_unit_recycle = None
+        self.killing_unit_recycle = None
 
         #: The unique id of the unit doing the killing. Available for build 27950+
-        self.killer_unit_id = None
+        self.killing_unit_id = None
+
+        #: A reference to the :class:`Unit` that killed this :class:`Unit`
+        self.killing_unit = None
 
         if build < 27950:
             self.x = self.x * 4
             self.y = self.y * 4
             self.location = (self.x, self.y)
         else:
             # Starcraft patch 2.1 introduced killer unit indexes
-            self.killer_unit_index = data[5]
-            self.killer_unit_recycle = data[6]
-            if self.killer_unit_index:
-                self.killer_unit_id = self.killer_unit_index << 18 | self.killer_unit_recycle
+            self.killing_unit_index = data[5]
+            self.killing_unit_recycle = data[6]
+            if self.killing_unit_index:
+                self.killing_unit_id = self.killing_unit_index << 18 | self.killing_unit_recycle
 
     def __str__(self):
         return self._str_prefix() + "{0: >15} - Unit died {1}.".format(self.unit.owner, self.unit)