Fix up event names and hierarchy.

* PacketEvent is now ProgressEvent.
* SetToHotkeyEvent is now SetControlGroupEvent.
* AddToHotkeyEvent is now AddToControlGroupEvent.
* GetFromHotkeyEvent is now GetControlGroupEvent.
* PlayerAbilityEvent is no longer part of the event hierarchy.
* event.name is no longer a class property; it can only be accessed from an event instance.

CHANGELOG.rst

@@ -1,11 +1,23 @@
 CHANGELOG
 ============
 
+0.7.0 -
+---------------------------
+
+* PacketEvent is now ProgressEvent.
+* SetToHotkeyEvent is now SetControlGroupEvent.
+* AddToHotkeyEvent is now AddToControlGroupEvent.
+* GetFromHotkeyEvent is now GetControlGroupEvent.
+* PlayerAbilityEvent is no longer part of the event hierarchy.
+* event.name is no longer a class property; it can only be accessed from an event instance.
+
+
+
 0.6.4 - September 22nd 2013
 ---------------------------
 
 * Fix bug in code for logging errors.
-* Fix siege tank supply count
+* Fix siege tank supply count.
 * Small improvements to message.events parsing.
 
 0.6.3 - September 15th 2013

sc2reader/engine/engine.py

@@ -5,6 +5,7 @@
 from sc2reader.events import *
 from sc2reader.engine.events import InitGameEvent, EndGameEvent, PluginExit
 
+
 class GameEngine(object):
     """ GameEngine Specification
         --------------------------
@@ -56,9 +57,8 @@ def handleEventName(self, event, replay)
             * handleMessageEvent - called for events in replay.message.events
             * handleGameEvent - called for events in replay.game.events
             * handleTrackerEvent - called for events in replay.tracker.events
-            * handlePlayerActionEvent - called for all game events indicating player actions
             * handleAbilityEvent - called for all types of ability events
-            * handleHotkeyEvent - called for all player hotkey events
+            * handleControlGroupEvent - called for all player control group events
 
         Plugins may also handle optional ``InitGame`` and ``EndGame`` events generated
         by the GameEngine before and after processing all the events:
@@ -196,26 +196,18 @@ def _get_event_handlers(self, event, plugins):
 
     def _get_plugin_event_handlers(self, plugin, event):
         handlers = list()
-        if isinstance(event, Event) and self._has_event_handler(plugin, Event):
-            handlers.append(self._get_event_handler(plugin, Event))
-        if isinstance(event, MessageEvent) and self._has_event_handler(plugin, MessageEvent):
-            handlers.append(self._get_event_handler(plugin, MessageEvent))
-        if isinstance(event, GameEvent) and self._has_event_handler(plugin, GameEvent):
-            handlers.append(self._get_event_handler(plugin, GameEvent))
-        if isinstance(event, TrackerEvent) and self._has_event_handler(plugin, TrackerEvent):
-            handlers.append(self._get_event_handler(plugin, TrackerEvent))
-        if isinstance(event, PlayerActionEvent) and self._has_event_handler(plugin, PlayerActionEvent):
-            handlers.append(self._get_event_handler(plugin, PlayerActionEvent))
-        if isinstance(event, AbilityEvent) and self._has_event_handler(plugin, AbilityEvent):
-            handlers.append(self._get_event_handler(plugin, AbilityEvent))
-        if isinstance(event, HotkeyEvent) and self._has_event_handler(plugin, HotkeyEvent):
-            handlers.append(self._get_event_handler(plugin, HotkeyEvent))
-        if self._has_event_handler(plugin, event):
-            handlers.append(self._get_event_handler(plugin, event))
+        if isinstance(event, Event) and hasattr(plugin, 'handleEvent'):
+            handlers.append(getattr(plugin, 'handleEvent', None))
+        if isinstance(event, MessageEvent) and hasattr(plugin, 'handleMessageEvent'):
+            handlers.append(getattr(plugin, 'handleMessageEvent', None))
+        if isinstance(event, GameEvent) and hasattr(plugin, 'handleGameEvent'):
+            handlers.append(getattr(plugin, 'handleGameEvent', None))
+        if isinstance(event, TrackerEvent) and hasattr(plugin, 'handleTrackerEvent'):
+            handlers.append(getattr(plugin, 'handleTrackerEvent', None))
+        if isinstance(event, AbilityEvent) and hasattr(plugin, 'handleAbilityEvent'):
+            handlers.append(getattr(plugin, 'handleAbilityEvent', None))
+        if isinstance(event, ControlGroupEvent) and hasattr(plugin, 'handleControlGroupEvent'):
+            handlers.append(getattr(plugin, 'handleControlGroupEvent', None))
+        if hasattr(plugin, 'handle'+event.name):
+            handlers.append(getattr(plugin, 'handle'+event.name, None))
         return handlers
-
-    def _has_event_handler(self, plugin, event):
-        return hasattr(plugin, 'handle'+event.name)
-
-    def _get_event_handler(self, plugin, event):
-        return getattr(plugin, 'handle'+event.name, None)

sc2reader/engine/plugins/apm.py

@@ -7,7 +7,7 @@
 class APMTracker(object):
     """
     Builds ``player.aps`` and ``player.apm`` dictionaries where an action is
-    any Selection, Hotkey, or Ability event.
+    any Selection, ControlGroup, or Ability event.
 
     Also provides ``player.avg_apm`` which is defined as the sum of all the
     above actions divided by the number of seconds played by the player (not
@@ -23,7 +23,15 @@ def handleInitGame(self, event, replay):
             human.aps = defaultdict(int)
             human.seconds_played = replay.length.seconds
 
-    def handlePlayerActionEvent(self, event, replay):
+    def handleControlGroupEvent(self, event, replay):
+        event.player.aps[event.second] += 1
+        event.player.apm[int(event.second/60)] += 1
+
+    def handleSelectionEvent(self, event, replay):
+        event.player.aps[event.second] += 1
+        event.player.apm[int(event.second/60)] += 1
+
+    def handleAbilityEvent(self, event, replay):
         event.player.aps[event.second] += 1
         event.player.apm[int(event.second/60)] += 1
 

sc2reader/events/game.py

@@ -13,8 +13,6 @@ class GameEvent(Event):
     """
     This is the base class for all game events. The attributes below are universally available.
     """
-    name = 'GameEvent'
-
     def __init__(self, frame, pid):
         #: The id of the player generating the event. This is 16 for global non-player events.
         #: Prior to Heart of the Swarm this was the player id. Since HotS it is
@@ -34,6 +32,9 @@ def __init__(self, frame, pid):
         #: A flag indicating if it is a local or global event.
         self.is_local = (pid != 16)
 
+        #: Short cut string for event class name
+        self.name = self.__class__.__name__
+
     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)
@@ -47,9 +48,6 @@ class GameStartEvent(GameEvent):
     Recorded when the game starts and the frames start to roll. This is a global non-player
     event.
     """
-
-    name = 'GameStartEvent'
-
     def __init__(self, frame, pid, data):
         super(GameStartEvent, self).__init__(frame, pid)
 
@@ -58,9 +56,6 @@ class PlayerLeaveEvent(GameEvent):
     """
     Recorded when a player leaves the game.
     """
-
-    name = 'PlayerLeaveEvent'
-
     def __init__(self, frame, pid, data):
         super(PlayerLeaveEvent, self).__init__(frame, pid)
 
@@ -70,9 +65,6 @@ class UserOptionsEvent(GameEvent):
     This event is recorded for each player at the very beginning of the game before the
     :class:`GameStartEvent`.
     """
-
-    name = 'UserOptionsEvent'
-
     def __init__(self, frame, pid, data):
         super(UserOptionsEvent, self).__init__(frame, pid)
         #:
@@ -118,12 +110,8 @@ def create_command_event(frame, pid, data):
         return SelfAbilityEvent(frame, pid, data)
 
 
-class PlayerActionEvent(GameEvent):
-    name = 'PlayerActionEvent'
-
-
 @loggable
-class AbilityEvent(PlayerActionEvent):
+class AbilityEvent(GameEvent):
     """
     Ability events are generated when ever a player in the game issues a command
     to a unit or group of units. They are split into three subclasses of ability,
@@ -133,11 +121,6 @@ class AbilityEvent(PlayerActionEvent):
     See :class:`LocationAbilityEvent`, :class:`TargetAbilityEvent`, and :class:`SelfAbilityEvent`
     for individual details.
     """
-
-    name = 'AbilityEvent'
-
-    is_player_action = True
-
     def __init__(self, frame, pid, data):
         super(AbilityEvent, self).__init__(frame, pid)
 
@@ -236,9 +219,6 @@ class LocationAbilityEvent(AbilityEvent):
     Note that like all AbilityEvents, the event will be recorded regardless
     of whether or not the command was successful.
     """
-
-    name = 'LocationAbilityEvent'
-
     def __init__(self, frame, pid, data):
         super(LocationAbilityEvent, self).__init__(frame, pid, data)
 
@@ -265,9 +245,6 @@ class TargetAbilityEvent(AbilityEvent):
 
     Note that all AbilityEvents are recorded regardless of whether or not the command was successful.
     """
-
-    name = 'TargetAbilityEvent'
-
     def __init__(self, frame, pid, data):
         super(TargetAbilityEvent, self).__init__(frame, pid, data)
 
@@ -318,9 +295,6 @@ class SelfAbilityEvent(AbilityEvent):
 
     Note that all AbilityEvents are recorded regardless of whether or not the command was successful.
     """
-
-    name = 'SelfAbilityEvent'
-
     def __init__(self, frame, pid, data):
         super(SelfAbilityEvent, self).__init__(frame, pid, data)
 
@@ -329,7 +303,7 @@ def __init__(self, frame, pid, data):
 
 
 @loggable
-class SelectionEvent(PlayerActionEvent):
+class SelectionEvent(GameEvent):
     """
     Selection events are generated when ever the active selection of the
     player is updated. Unlike other game events, these events can also be
@@ -340,10 +314,6 @@ class SelectionEvent(PlayerActionEvent):
     by non-player actions. When a player action updates a control group
     a :class:`HotkeyEvent` is generated.
     """
-
-    name = 'SelectionEvent'
-    is_player_action = True
-
     def __init__(self, frame, pid, data):
         super(SelectionEvent, self).__init__(frame, pid)
 
@@ -392,39 +362,32 @@ def __str__(self):
 def create_control_group_event(frame, pid, data):
     update_type = data['control_group_update']
     if update_type == 0:
-        return SetToHotkeyEvent(frame, pid, data)
+        return SetControlGroupEvent(frame, pid, data)
     elif update_type == 1:
-        return AddToHotkeyEvent(frame, pid, data)
+        return AddToControlGroupEvent(frame, pid, data)
     elif update_type == 2:
-        return GetFromHotkeyEvent(frame, pid, data)
+        return GetControlGroupEvent(frame, pid, data)
     elif update_type == 3:
         # TODO: What could this be?!?
-        return HotkeyEvent(frame, pid, data)
+        return ControlGroupEvent(frame, pid, data)
 
 
 @loggable
-class HotkeyEvent(PlayerActionEvent):
+class ControlGroupEvent(GameEvent):
     """
-    Hotkey events are recorded when ever a player action modifies a control
-    group. I know that calling control group events hotkey events doesn't make
-    sense but for backwards compatibility I haven't changed it yet. Sorry.
-
-    There are three kinds of hotkey events, generated by each of the possible
+    ControlGroup events are recorded when ever a player action modifies or accesses a control
+    group. There are three kinds of events, generated by each of the possible
     player actions:
 
-    * :class:`SetToHotkeyEvent` - Recorded when a user sets a control group (ctrl+#).
-    * :class:`GetFromHotkeyEvent` - Recorded when a user retrieves a control group (#).
-    * :class:`AddToHotkeyEvent` - Recorded when a user adds to a control group (shift+ctrl+#)
+    * :class:`SetControlGroup` - Recorded when a user sets a control group (ctrl+#).
+    * :class:`GetControlGroup` - Recorded when a user retrieves a control group (#).
+    * :class:`AddToControlGroup` - Recorded when a user adds to a control group (shift+ctrl+#)
 
     All three events have the same set of data (shown below) but are interpretted differently.
     See the class entry for details.
     """
-
-    name = 'HotkeyEvent'
-    is_player_action = True
-
     def __init__(self, frame, pid, data):
-        super(HotkeyEvent, self).__init__(frame, pid)
+        super(ControlGroupEvent, self).__init__(frame, pid)
 
         #: Index to the control group being modified
         self.control_group = data['control_group_index']
@@ -445,38 +408,33 @@ def __init__(self, frame, pid, data):
         self.mask_data = data['remove_mask'][1]
 
 
-class SetToHotkeyEvent(HotkeyEvent):
+class SetControlGroupEvent(ControlGroupEvent):
     """
-    Extends :class:`HotkeyEvent`
+    Extends :class:`ControlGroupEvent`
 
     This event does a straight forward replace of the current control group contents
     with the player's current selection. This event doesn't have masks set.
     """
 
-    name = 'SetToHotkeyEvent'
 
-
-class AddToHotkeyEvent(HotkeyEvent):
+class AddToControlGroupEvent(SetControlGroupEvent):
     """
-    Extends :class:`HotkeyEvent`
+    Extends :class:`ControlGroupEvent`
 
     This event adds the current selection to the control group.
     """
 
-    name = 'AddToHotkeyEvent'
-
 
-class GetFromHotkeyEvent(HotkeyEvent):
+class GetControlGroupEvent(ControlGroupEvent):
     """
-    Extends :class:`HotkeyEvent`
+    Extends :class:`ControlGroupEvent`
+
     This event replaces the current selection with the contents of the control group.
     The mask data is used to limit that selection to units that are currently selectable.
     You might have 1 medivac and 8 marines on the control group but if the 8 marines are
     inside the medivac they cannot be part of your selection.
     """
 
-    name = 'GetFromHotkeyEvent'
-
 
 @loggable
 class CameraEvent(GameEvent):
@@ -485,9 +443,6 @@ class CameraEvent(GameEvent):
     It does not matter why the camera changed, this event simply records the current
     state of the camera after changing.
     """
-
-    name = 'CameraEvent'
-
     def __init__(self, frame, pid, data):
         super(CameraEvent, self).__init__(frame, pid)
 
@@ -515,8 +470,10 @@ def __str__(self):
 
 @loggable
 class ResourceTradeEvent(GameEvent):
-    name = 'ResourceTradeEvent'
-
+    """
+    Generated when a player trades resources with another player. But not when fullfulling
+    resource requests.
+    """
     def __init__(self, frame, pid, data):
         super(ResourceTradeEvent, self).__init__(frame, pid)
 
@@ -552,8 +509,9 @@ def __str__(self):
 
 
 class ResourceRequestEvent(GameEvent):
-    name = 'ResourceRequestEvent'
-
+    """
+    Generated when a player creates a resource request.
+    """
     def __init__(self, frame, pid, data):
         super(ResourceRequestEvent, self).__init__(frame, pid)
 
@@ -577,8 +535,9 @@ def __str__(self):
 
 
 class ResourceRequestFulfillEvent(GameEvent):
-    name = 'ResourceRequestFulfillEvent'
-
+    """
+    Generated when a player accepts a resource request.
+    """
     def __init__(self, frame, pid, data):
         super(ResourceRequestFulfillEvent, self).__init__(frame, pid)
 
@@ -587,8 +546,9 @@ def __init__(self, frame, pid, data):
 
 
 class ResourceRequestCancelEvent(GameEvent):
-    name = 'ResourceRequestCancelEvent'
-
+    """
+    Generated when a player cancels their resource request.
+    """
     def __init__(self, frame, pid, data):
         super(ResourceRequestCancelEvent, self).__init__(frame, pid)