Split events.py into a series of files in the events package.

Author: GraylinKim

sc2reader/events/__init__.py

@@ -0,0 +1,39 @@
+# -*- coding: utf-8 -*-
+from __future__ import absolute_import
+
+from sc2reader.log_utils import loggable
+
+@loggable
+class Event(object):
+    name = 'Event'
+
+    def __init__(self, frame, pid):
+        self.pid = pid
+        self.frame = frame
+        self.second = frame >> 4
+        # This is sorta expensive considering no one uses it
+        # self.time = Length(seconds=self.second)
+
+    def load_context(self, replay):
+        if replay.versions[1]==1 or (replay.versions[1]==2 and replay.build < 24247):
+            if self.pid <= len(replay.people):
+                self.player = replay.person[self.pid]
+            elif self.pid != 16:
+                self.logger.error("Bad pid ({0}) for event {1} at {2}.".format(self.pid, self.__class__, Length(seconds=self.second)))
+            else:
+                pass # This is a global event
+
+        else:
+            if self.pid < len(replay.clients):
+                self.player = replay.client[self.pid]
+            elif self.pid != 16:
+                self.logger.error("Bad pid ({0}) for event {1} at {2}.".format(self.pid, self.__class__, Length(seconds=self.second)))
+            else:
+                pass # This is a global event
+
+    def _str_prefix(self):
+        player_name = self.player.name if getattr(self,'pid', 16)!=16 else "Global"
+        return "%s\t%-15s " % (Length(seconds=int(self.frame/16)), player_name)
+
+    def __str__(self):
+        return self._str_prefix() + self.name

sc2reader/events/base.py

@@ -1,45 +1,9 @@
 # -*- coding: utf-8 -*-
 from __future__ import absolute_import
 
-from sc2reader.utils import Length
-from sc2reader.data import Unit
+from sc2reader.events.base import Event
 from sc2reader.log_utils import loggable
 
-@loggable
-class Event(object):
-    name = 'Event'
-
-    def __init__(self, frame, pid):
-        self.pid = pid
-        self.frame = frame
-        self.second = frame >> 4
-        # This is sorta expensive considering no one uses it
-        # self.time = Length(seconds=self.second)
-
-    def load_context(self, replay):
-        if replay.versions[1]==1 or (replay.versions[1]==2 and replay.build < 24247):
-            if self.pid <= len(replay.people):
-                self.player = replay.person[self.pid]
-            elif self.pid != 16:
-                self.logger.error("Bad pid ({0}) for event {1} at {2}.".format(self.pid, self.__class__, Length(seconds=self.second)))
-            else:
-                pass # This is a global event
-
-        else:
-            if self.pid < len(replay.clients):
-                self.player = replay.client[self.pid]
-            elif self.pid != 16:
-                self.logger.error("Bad pid ({0}) for event {1} at {2}.".format(self.pid, self.__class__, Length(seconds=self.second)))
-            else:
-                pass # This is a global event
-
-    def _str_prefix(self):
-        player_name = self.player.name if getattr(self,'pid', 16)!=16 else "Global"
-        return "%s\t%-15s " % (Length(seconds=int(self.frame/16)), player_name)
-
-    def __str__(self):
-        return self._str_prefix() + self.name
-
 @loggable
 class GameEvent(Event):
     name = 'GameEvent'
@@ -55,51 +19,6 @@ def __init__(self, frame, pid, event_type):
         self.is_player_action = (event_class == 1)
         self.is_camera_movement = (event_class == 3)
 
-#############################################3
-# Message Events
-#########################
-
-@loggable
-class MessageEvent(Event):
-    name = 'MessageEvent'
-
-    def __init__(self, frame, pid, flags):
-        super(MessageEvent, self).__init__(frame, pid)
-        self.flags=flags
-
-@loggable
-class ChatEvent(MessageEvent):
-    name = 'ChatEvent'
-
-    def __init__(self, frame, pid, flags, target, text, extension):
-        super(ChatEvent, self).__init__(frame, pid, flags)
-        self.target = target
-        self.extension = extension
-        self.text = text
-        self.to_all = (self.target == 0)
-        self.to_allies = (self.target == 2)
-        self.to_observers = (self.target == 4)
-
-@loggable
-class PacketEvent(MessageEvent):
-    name = 'PacketEvent'
-
-    def __init__(self, frame, pid, flags, info):
-        super(PacketEvent, self).__init__(frame, pid, flags)
-        self.info = info
-
-@loggable
-class PingEvent(MessageEvent):
-    name = 'PingEvent'
-
-    def __init__(self, frame, pid, flags, x, y):
-        super(PingEvent, self).__init__(frame, pid, flags)
-        self.x, self.y = x, y
-
-
-#############################################3
-# Game Events
-#########################
 
 class UnknownEvent(GameEvent):
     name = 'UnknownEvent'
@@ -168,8 +87,11 @@ def __str__(self):
 
     def load_context(self, replay):
         super(SendResourceEvent, self).load_context(replay)
-        self.sender = self.player
-        self.reciever = replay.players[self.reciever]
+        # DJ disabled this on 20130222 because GGTracker doesnt use this event
+        # and it is currently broken for a replay thats now in the test suite.
+        #
+        # self.sender = replay.player[self.sender]
+        # self.reciever = replay.players[self.reciever]
 
 @loggable
 class RequestResourceEvent(PlayerActionEvent):
@@ -252,21 +174,21 @@ def load_context(self, replay):
         if not replay.datapack:
             return
 
-        if self.target_id in replay.objects:
-            self.target = replay.objects[self.target_id]
-            if not self.target.is_type(self.target_type):
-                replay.datapack.change_type(self.target, self.target_type, self.frame)
+        uid = (self.target_id, self.target_type)
+        if uid in replay.objects:
+            self.target = replay.objects[uid]
 
         else:
             if self.target_type not in replay.datapack.units:
                 self.logger.error("{0}\t{1}\tMissing unit {2} from {3}".format(self.frame, self.player.name, hex(self.target_type), replay.datapack.id))
                 unit = Unit(self.target_id, 0x00)
 
             else:
-                unit = replay.datapack.create_unit(self.target_id, self.target_type, 0x00, self.frame)
+                unit_class = replay.datapack.units[self.target_type]
+                unit = unit_class(self.target_id, 0x00)
 
             self.target = unit
-            replay.objects[self.target_id] = unit
+            replay.objects[uid] = unit
 
     def __str__(self):
         if self.target:
@@ -332,26 +254,29 @@ def load_context(self, replay):
         if not replay.datapack:
             return
 
-        units = list()
-        for (unit_id, unit_type, unit_flags) in self.raw_objects:
-            if unit_id in replay.objects:
-                unit = replay.objects[unit_id]
-                if not unit.is_type(unit_type):
-                    replay.datapack.change_type(unit, unit_type, self.frame)
+        objects = list()
+        data = replay.datapack
+        for (obj_id, obj_type, obj_flags) in self.raw_objects:
+            # Hack that defaults viking selection to fighter mode instead of assault
+            if replay.versions[1] == 2 and replay.build >= 23925 and obj_type == 71:
+                obj_type = 72
+
+            if (obj_id, obj_type) in replay.objects:
+                obj = replay.objects[(obj_id,obj_type)]
             else:
-                if unit_type in replay.datapack.units:
-                    unit = replay.datapack.create_unit(unit_id, unit_type, unit_flags, self.frame)
+                if obj_type in data.units:
+                    obj = data.units[obj_type](obj_id, obj_flags)
                 else:
                     msg = "Unit Type {0} not found in {1}"
-                    self.logger.error(msg.format(hex(unit_type), replay.datapack.__class__.__name__))
-                    unit = Unit(unit_id, unit_flags)
+                    self.logger.error(msg.format(hex(obj_type), data.__class__.__name__))
+                    obj = Unit(obj_id, obj_flags)
 
-                replay.objects[unit_id] = unit
+                replay.objects[(obj_id,obj_type)] = obj
 
-            units.append(unit)
+            objects.append(obj)
 
 
-        self.units = self.objects = units
+        self.objects = objects
 
     def __str__(self):
-        return GameEvent.__str__(self)+str([str(u) for u in self.units])
+        return GameEvent.__str__(self)+str([str(u) for u in self.objects])

sc2reader/events.py sc2reader/events/game.pysc2reader/events.py renamed to sc2reader/events/game.py

@@ -0,0 +1,42 @@
+# -*- coding: utf-8 -*-
+from __future__ import absolute_import
+
+from sc2reader.events.base import Event
+from sc2reader.log_utils import loggable
+
+@loggable
+class MessageEvent(Event):
+    name = 'MessageEvent'
+
+    def __init__(self, frame, pid, flags):
+        super(MessageEvent, self).__init__(frame, pid)
+        self.flags=flags
+
+@loggable
+class ChatEvent(MessageEvent):
+    name = 'ChatEvent'
+
+    def __init__(self, frame, pid, flags, target, text, extension):
+        super(ChatEvent, self).__init__(frame, pid, flags)
+        self.target = target
+        self.extension = extension
+        self.text = text
+        self.to_all = (self.target == 0)
+        self.to_allies = (self.target == 2)
+        self.to_observers = (self.target == 4)
+
+@loggable
+class PacketEvent(MessageEvent):
+    name = 'PacketEvent'
+
+    def __init__(self, frame, pid, flags, info):
+        super(PacketEvent, self).__init__(frame, pid, flags)
+        self.info = info
+
+@loggable
+class PingEvent(MessageEvent):
+    name = 'PingEvent'
+
+    def __init__(self, frame, pid, flags, x, y):
+        super(PingEvent, self).__init__(frame, pid, flags)
+        self.x, self.y = x, y

sc2reader/events/message.py

@@ -8,7 +8,8 @@
 
 from sc2reader.exceptions import ParseError, ReadError
 from sc2reader.objects import *
-from sc2reader.events import *
+from sc2reader.events.game import *
+from sc2reader.events.message import *
 from sc2reader.utils import AttributeDict
 from sc2reader.decoders import BitPackedDecoder, ByteDecoder
 

sc2reader/readers.py

@@ -23,7 +23,7 @@
 from sc2reader import readers
 from sc2reader import exceptions
 from sc2reader.data import builds as datapacks
-from sc2reader.events import AbilityEvent, CameraEvent, HotkeyEvent, SelectionEvent
+from sc2reader.events.game import AbilityEvent, CameraEvent, HotkeyEvent, SelectionEvent
 from sc2reader.exceptions import SC2ReaderLocalizationError
 from sc2reader.objects import Player, Observer, Team, PlayerSummary, Graph, DepotFile, BuildEntry
 from sc2reader.constants import REGIONS, LOCALIZED_RACES, GAME_SPEED_FACTOR, LOBBY_PROPERTIES, GATEWAY_LOOKUP