Merge branch 'v0.6.5' of http://github.com/GraylinKim/sc2reader into upstream

Conflicts:
	CHANGELOG.rst
	sc2reader/data/__init__.py
	sc2reader/engine/plugins/__init__.py
	sc2reader/engine/plugins/context.py
	sc2reader/events/tracker.py
	test_replays/test_all.py

Author: GraylinKim

CHANGELOG.rst

@@ -5,6 +5,13 @@ CHANGELOG
 0.6.5 - December ?? 2013
 ---------------------------
 
+* Deprecated unit.killed_by in favor of unit.killing_player
+* Added unit.killed_units
+* Added unit.killing_unit
+* Added UnitDiedEvent.killing_player
+* Added UnitDiedEvent.killing_unit
+* Deprecated UnitDiedEvent.killer_pid in favor of UnitDiedEvent.killing_player_id
+* Deprecated UnitDiedEvent.killer in favor of UnitDiedEvent.killing_player
 * Use generic UnitType and Ability classes for data. This means no more unit._type_class.__class__.__name__. But hopefully people were not doing that anyway.
 * Now a CorruptTrackerFileError is raised when the tracker file is corrupted (generally only older resume_from_replay replays)
 * Removed the defunct replay.player_names attribute.

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
         #: TargetAbilityEvents will create a new unit with id zero when a unit

sc2reader/engine/plugins/context.py

@@ -141,13 +141,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

@@ -319,12 +319,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]
@@ -337,24 +343,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)

test_replays/test_all.py

@@ -443,5 +443,6 @@ def test_plugin1(self):
         self.assertEqual(replay.plugin_result['TestPlugin2'], (0, dict()))
 
 
+
 if __name__ == '__main__':
     unittest.main()