Don't crash the ContextLoader if we are missing a datapack.

Author: GraylinKim

sc2reader/engine/plugins/context.py

@@ -10,9 +10,6 @@
 class ContextLoader(object):
 
     def handleInitGame(self, event, replay):
-        if not replay.datapack:
-            raise ValueError("ContextLoader requires a datapack to run")
-
         replay.units = set()
         replay.unit = dict()
 
@@ -23,6 +20,9 @@ def handleMessageEvent(self, event, replay):
         self.load_message_game_player(event, replay)
 
     def handleAbilityEvent(self, event, replay):
+        if not replay.datapack:
+            return
+
         if event.ability_id not in replay.datapack.abilities:
             if not getattr(replay, 'marked_error', None):
                 replay.marked_error = True
@@ -43,6 +43,9 @@ def handleAbilityEvent(self, event, replay):
             self.logger.error("Other unit {0} not found".format(event.other_unit_id))
 
     def handleTargetAbilityEvent(self, event, replay):
+        if not replay.datapack:
+            return
+
         if event.target_unit_id in replay.objects:
             event.target = replay.objects[event.target_unit_id]
             if not event.target.is_type(event.target_unit_type):
@@ -53,6 +56,9 @@ def handleTargetAbilityEvent(self, event, replay):
             replay.objects[event.target_unit_id] = unit
 
     def handleSelectionEvent(self, event, replay):
+        if not replay.datapack:
+            return
+
         units = list()
         for (unit_id, unit_type, subgroup, intra_subgroup) in event.new_unit_info:
             # If we don't have access to tracker events, use selection events to create
@@ -92,6 +98,9 @@ def handleUnitBornEvent(self, event, replay):
         self.load_tracker_upkeeper(event, replay)
         self.load_tracker_controller(event, replay)
 
+        if not replay.datapack:
+            return
+
         if event.unit_id in replay.objects:
             # This can happen because game events are done first
             event.unit = replay.objects[event.unit_id]
@@ -120,37 +129,33 @@ def handleUnitDiedEvent(self, event, replay):
             if event.unit_id_index in replay.active_units:
                 del replay.active_units[event.unit_id_index]
             else:
-                pass  # print("Unable to delete unit, not index not active: {0}".format(event.unit_id_index))
+                self.logger.error("Unable to delete unit index {0} at {1} [{2}], index not active.".format(event.killer_pid, Length(seconds=event.second), event.frame))
         else:
-            pass  # print("Unit died before it was born!")
+            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.unit:
                 event.unit.killed_by = event.killer
                 event.killer.killed_units.append(event.unit)
         elif event.killer_pid:
-            pass  # print("Unknown killer pid: {0}".format(event.killer_pid))
+            self.logger.error("Unknown killer pid {0} at {1} [{2}]".format(event.killer_pid, Length(seconds=event.second), event.frame))
 
     def handleUnitOwnerChangeEvent(self, event, replay):
-        if event.control_pid in replay.player:
-            event.unit_controller = replay.player[event.control_pid]
-        elif event.control_pid != 0:
-            pass  # print("Unknown controller pid: {0}".format(event.control_pid))
+        self.load_tracker_controller(event, replay)
+        self.load_tracker_upkeeper(event, replay)
 
-        if event.upkeep_pid in replay.player:
-            event.unit_upkeeper = replay.player[event.upkeep_pid]
-        elif event.upkeep_pid != 0:
-            pass  # print("Unknown upkeep pid: {0}".format(event.upkeep_pid))
+        if not replay.datapack:
+            return
 
         if event.unit_id in replay.objects:
             event.unit = replay.objects[event.unit_id]
         else:
-            pass  # print("Unit owner changed before it was born!")
+            self.logger.error("Unit {0} owner changed at {1} [{2}] before it was born!".format(event.unit_id, Length(seconds=event.second), event.frame))
 
         if event.unit_upkeeper:
             if event.unit.owner:
-                event.unit.owner.units.remove(unit)
+                event.unit.owner.units.remove(event.unit)
             event.unit.owner = event.unit_upkeeper
             event.unit_upkeeper.units.append(event.unit)
 
@@ -162,7 +167,7 @@ def handleUnitTypeChangeEvent(self, event, replay):
             event.unit = replay.objects[event.unit_id]
             replay.datapack.change_type(event.unit, event.unit_type_name, event.frame)
         else:
-            pass  # print("Unit type changed before it was born!")
+            self.logger.error("Unit {0} type changed at {1} [{2}] before it was born!".format(event.unit_id, Length(seconds=event.second)))
 
     def handleUpgradeCompleteEvent(self, event, replay):
         self.load_tracker_player(event, replay)
@@ -173,11 +178,11 @@ def handleUnitInitEvent(self, event, replay):
         self.load_tracker_upkeeper(event, replay)
         self.load_tracker_controller(event, replay)
 
+        if not replay.datapack:
+            return
+
         if event.unit_id in replay.objects:
-            # This can happen because game events are done first
             event.unit = replay.objects[event.unit_id]
-            if not event.unit.is_type(event.unit_type_name):
-                pass  # print("CONFLICT {0} <-_-> {1}".format(event.unit._type_class.str_id, event.unit_type_name))
         else:
             # TODO: How to tell if something is hallucination?
             event.unit = replay.datapack.create_unit(event.unit_id, event.unit_type_name, 0, event.frame)
@@ -192,54 +197,60 @@ def handleUnitInitEvent(self, event, replay):
             event.unit.owner.units.append(event.unit)
 
     def handleUnitDoneEvent(self, event, replay):
+        if not replay.datapack:
+            return
+
         if event.unit_id in replay.objects:
             event.unit = replay.objects[event.unit_id]
             event.unit.finished_at = event.frame
         else:
-            pass  # print("Unit done before it was started!")
+            self.logger.error("Unit {0} done at {1} [{2}] before it was started!".format(event.killer_pid, Length(seconds=event.second), event.frame))
 
     def handleUnitPositionsEvent(self, event, replay):
+        if not replay.datapack:
+            return
+
         for unit_index, (x, y) in event.positions:
             if unit_index in replay.active_units:
                 unit = replay.active_units[unit_index]
                 unit.location = (x, y)
                 event.units[unit] = unit.location
             else:
-                pass  # print("Unit moved that doesn't exist!")
+                self.logger.error("Unit at active_unit index {0} moved at {1} [{2}] but it doesn't exist!".format(event.killer_pid, Length(seconds=event.second), event.frame))
 
     def load_message_game_player(self, event, replay):
         if replay.versions[1] == 1 or (replay.versions[1] == 2 and replay.build < 24247):
-            if event.pid <= len(replay.people):
-                event.player = replay.person[event.pid]
+            if event.pid in replay.entity:
+                event.player = replay.entity[event.pid]
                 event.player.events.append(event)
             elif event.pid != 16:
-                self.logger.error("Bad pid ({0}) for event {1} at {2}.".format(event.pid, event.__class__, Length(seconds=event.second)))
+                self.logger.error("Bad pid ({0}) for event {1} at {2} [{3}].".format(event.pid, event.__class__, Length(seconds=event.second), event.frame))
             else:
                 pass  # This is a global event
 
-        else:
-            if event.pid < len(replay.clients):
-                event.player = replay.client[event.pid]
+        else:  # Now event.pid is actually a user id for human entities
+            if event.pid < len(replay.humans):
+                event.player = replay.human[event.pid]
                 event.player.events.append(event)
             elif event.pid != 16:
-                self.logger.error("Bad pid ({0}) for event {1} at {2}.".format(event.pid, event.__class__, Length(seconds=event.second)))
+                self.logger.error("Bad pid ({0}) for event {1} at {2} [{3}].".format(event.pid, event.__class__, Length(seconds=event.second), event.frames))
             else:
                 pass  # This is a global event
 
     def load_tracker_player(self, event, replay):
         if event.pid in replay.player:
             event.player = replay.player[event.pid]
         else:
-            pass  # print("Unknown upgrade pid: {0}".format(event.pid))
+            self.logger.error("Bad pid ({0}) for event {1} at {2} [{3}].".format(event.pid, event.__class__, Length(seconds=event.second), event.frame))
 
     def load_tracker_upkeeper(self, event, replay):
         if event.upkeep_pid in replay.player:
             event.unit_upkeeper = replay.player[event.upkeep_pid]
         elif event.upkeep_pid != 0:
-            pass  # print("Unknown upkeep pid: {0}".format(event.upkeep_pid))
+            self.logger.error("Bad upkeep_pid ({0}) for event {1} at {2} [{3}].".format(event.upkeep_pid, event.__class__, Length(seconds=event.second), event.frame))
 
     def load_tracker_controller(self, event, replay):
         if event.control_pid in replay.player:
             event.unit_controller = replay.player[event.control_pid]
         elif event.control_pid != 0:
-            pass  # print("Unknown controller pid: {0}".format(event.control_pid))
+            self.logger.error("Bad control_pid ({0}) for event {1} at {2} [{3}].".format(event.control_pid, event.__class__, Length(seconds=event.second), event.frame))

sc2reader/events/tracker.py

@@ -13,6 +13,7 @@ class TrackerEvent(Event):
     def __init__(self, frames):
         #: The frame of the game this event was applied
         self.frame = frames
+        self.second = frames >> 4
 
     def load_context(self, replay):
         pass