Fixes #160 with non back compatible changes.

Renames all ability events as following:

* AbilityEvent -> CommandEvent
* AbilityEvent -> BasicCommandEvent
* TargetAbilityEvent -> TargetUnitCommandEvent
* LocationAbilityEvent -> TargetPointCommandEvent

As such, all references to these classes, statements that check the event name,
and engine plugin event handlers need to be renamed. Its not ideal but it is
much better than being wrong.

sc2reader/data/__init__.py

@@ -62,7 +62,7 @@ def __init__(self, unit_id):
         self.killed_by = None
 
         #: 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
+        #: TargetUnitCommandEvents will create a new unit with id zero when a unit
         #: behind the fog of war is targetted.
         self.id = unit_id
 

sc2reader/engine/engine.py

@@ -18,14 +18,14 @@ class GameEngine(object):
         Example Usage::
 
             class Plugin1():
-                def handleAbilityEvent(self, event, replay):
+                def handleCommandEvent(self, event, replay):
                     pass
 
             class Plugin2():
                 def handleEvent(self, event, replay):
                     pass
 
-                def handleTargetAbilityEvent(self, event, replay):
+                def handleTargetUnitCommandEvent(self, event, replay):
                     pass
 
             ...
@@ -35,11 +35,11 @@ def handleTargetAbilityEvent(self, event, replay):
             engine.reigster_plugin(Plugin(5))
             engine.run(replay)
 
-        Calls functions in the following order for a ``TargetAbilityEvent``::
+        Calls functions in the following order for a ``TargetUnitCommandEvent``::
 
-            Plugin1.handleAbilityEvent(event, replay)
+            Plugin1.handleCommandEvent(event, replay)
             Plugin2.handleEvent(event, replay)
-            Plugin2.handleTargetAbilityEvent(event, replay)
+            Plugin2.handleTargetUnitCommandEvent(event, replay)
 
 
         Plugin Specification
@@ -57,7 +57,7 @@ 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
-            * handleAbilityEvent - called for all types of ability events
+            * handleCommandEvent - called for all types of command events
             * handleControlGroupEvent - called for all player control group events
 
         Plugins may also handle optional ``InitGame`` and ``EndGame`` events generated
@@ -90,7 +90,7 @@ def handleEvent(self, event, replay):
                     return
                 ...
 
-            def handleAbilityEvent(self, event, replay):
+            def handleCommandEvent(self, event, replay):
                 try:
                     possibly_throwing_error()
                 catch Error as e:
@@ -204,8 +204,8 @@ def _get_plugin_event_handlers(self, plugin, event):
             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, CommandEvent) and hasattr(plugin, 'handleCommandEvent'):
+            handlers.append(getattr(plugin, 'handleCommandEvent', None))
         if isinstance(event, ControlGroupEvent) and hasattr(plugin, 'handleControlGroupEvent'):
             handlers.append(getattr(plugin, 'handleControlGroupEvent', None))
         if hasattr(plugin, 'handle'+event.name):

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, ControlGroup, or Ability event.
+    any Selection, ControlGroup, or Command 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
@@ -31,7 +31,7 @@ def handleSelectionEvent(self, event, replay):
         event.player.aps[event.second] += 1
         event.player.apm[int(event.second/60)] += 1
 
-    def handleAbilityEvent(self, event, replay):
+    def handleCommandEvent(self, event, replay):
         event.player.aps[event.second] += 1
         event.player.apm[int(event.second/60)] += 1
 

sc2reader/engine/plugins/context.py

@@ -20,7 +20,7 @@ def handleGameEvent(self, event, replay):
     def handleMessageEvent(self, event, replay):
         self.load_message_game_player(event, replay)
 
-    def handleAbilityEvent(self, event, replay):
+    def handleCommandEvent(self, event, replay):
         if not replay.datapack:
             return
 
@@ -43,7 +43,7 @@ def handleAbilityEvent(self, event, replay):
         elif event.other_unit_id is not None:
             self.logger.error("Other unit {0} not found".format(event.other_unit_id))
 
-    def handleTargetAbilityEvent(self, event, replay):
+    def handleTargetUnitCommandEvent(self, event, replay):
         if not replay.datapack:
             return
 

sc2reader/events/game.py

@@ -105,31 +105,31 @@ def __init__(self, frame, pid, data):
 def create_command_event(frame, pid, data):
     ability_type = data['data'][0]
     if ability_type == 'None':
-        return AbilityEvent(frame, pid, data)
+        return BasicCommandEvent(frame, pid, data)
 
     elif ability_type == 'TargetUnit':
-        return TargetAbilityEvent(frame, pid, data)
+        return TargetUnitCommandEvent(frame, pid, data)
 
     elif ability_type == 'TargetPoint':
-        return LocationAbilityEvent(frame, pid, data)
+        return TargetPointCommandEvent(frame, pid, data)
 
     elif ability_type == 'Data':
-        return SelfAbilityEvent(frame, pid, data)
+        return DataCommandEvent(frame, pid, data)
 
 
 @loggable
-class AbilityEvent(GameEvent):
+class CommandEvent(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,
     each with their own set of associated data. The attributes listed below are
     shared across all ability event types.
 
-    See :class:`LocationAbilityEvent`, :class:`TargetAbilityEvent`, and :class:`SelfAbilityEvent`
-    for individual details.
+    See :class:`TargetPointCommandEvent`, :class:`TargetUnitCommandEvent`, and
+    :class:`DataCommandEvent` for individual details.
     """
     def __init__(self, frame, pid, data):
-        super(AbilityEvent, self).__init__(frame, pid)
+        super(CommandEvent, self).__init__(frame, pid)
 
         #: Flags on the command???
         self.flags = data['flags']
@@ -235,25 +235,38 @@ def __str__(self):
         return string
 
 
-class LocationAbilityEvent(AbilityEvent):
+class BasicCommandEvent(CommandEvent):
     """
-    Extends :class:`AbilityEvent`
+    Extends :class:`CommandEvent`
+
+    This event is recorded for events that have no extra information recorded.
+
+    Note that like all CommandEvents, the event will be recorded regardless
+    of whether or not the command was successful.
+    """
+    def __init__(self, frame, pid, data):
+        super(TargetPointCommandEvent, self).__init__(frame, pid, data)
+
+
+class TargetPointCommandEvent(CommandEvent):
+    """
+    Extends :class:`CommandEvent`
 
     This event is recorded when ever a player issues a command that targets a location
     and NOT a unit. Commands like Psistorm, Attack Move, Fungal Growth, and EMP fall
     under this category.
 
-    Note that like all AbilityEvents, the event will be recorded regardless
+    Note that like all CommandEvents, the event will be recorded regardless
     of whether or not the command was successful.
     """
     def __init__(self, frame, pid, data):
-        super(LocationAbilityEvent, self).__init__(frame, pid, data)
+        super(TargetPointCommandEvent, self).__init__(frame, pid, data)
 
         #: The x coordinate of the target. Available for TargetPoint and TargetUnit type events.
-        self.x = self.ability_type_data['point'].get('x', 0)/4096.0
+        self.x = self.ability_type_data['point'].get('x', 0) / 4096.0
 
         #: The y coordinate of the target. Available for TargetPoint and TargetUnit type events.
-        self.y = self.ability_type_data['point'].get('y', 0)/4096.0
+        self.y = self.ability_type_data['point'].get('y', 0) / 4096.0
 
         #: The z coordinate of the target. Available for TargetPoint and TargetUnit type events.
         self.z = self.ability_type_data['point'].get('z', 0)
@@ -262,18 +275,19 @@ def __init__(self, frame, pid, data):
         self.location = (self.x, self.y, self.z)
 
 
-class TargetAbilityEvent(AbilityEvent):
+class TargetUnitCommandEvent(CommandEvent):
     """
-    Extends :class:`AbilityEvent`
+    Extends :class:`CommandEvent`
 
-    TargetAbilityEvents are recorded when ever a player issues a command that targets a unit.
+    This event is recorded when ever a player issues a command that targets a unit.
     The location of the target unit at the time of the command is also recorded. Commands like
     Chronoboost, Transfuse, and Snipe fall under this category.
 
-    Note that all AbilityEvents are recorded regardless of whether or not the command was successful.
+    Note that like all CommandEvents, the event will be recorded regardless
+    of whether or not the command was successful.
     """
     def __init__(self, frame, pid, data):
-        super(TargetAbilityEvent, self).__init__(frame, pid, data)
+        super(TargetUnitCommandEvent, self).__init__(frame, pid, data)
 
         #: Flags set on the target unit. Available for TargetUnit type events
         self.target_flags = self.ability_type_data.get('flags', None)
@@ -301,10 +315,10 @@ def __init__(self, frame, pid, data):
         self.upkeep_player_id = self.ability_type_data.get('upkeep_player_id', None)
 
         #: The x coordinate of the target. Available for TargetPoint and TargetUnit type events.
-        self.x = self.ability_type_data['point'].get('x', 0)/4096.0
+        self.x = self.ability_type_data['point'].get('x', 0) / 4096.0
 
         #: The y coordinate of the target. Available for TargetPoint and TargetUnit type events.
-        self.y = self.ability_type_data['point'].get('y', 0)/4096.0
+        self.y = self.ability_type_data['point'].get('y', 0) / 4096.0
 
         #: The z coordinate of the target. Available for TargetPoint and TargetUnit type events.
         self.z = self.ability_type_data['point'].get('z', 0)
@@ -313,17 +327,18 @@ def __init__(self, frame, pid, data):
         self.location = (self.x, self.y, self.z)
 
 
-class SelfAbilityEvent(AbilityEvent):
+class DataCommandEvent(CommandEvent):
     """
-    Extends :class:`AbilityEvent`
+    Extends :class:`CommandEvent`
 
-    SelfAbilityEvents are recorded when ever a player issues a command that has no target. Commands
+    DataCommandEvent are recorded when ever a player issues a command that has no target. Commands
     like Burrow, SeigeMode, Train XYZ, and Stop fall under this category.
 
-    Note that all AbilityEvents are recorded regardless of whether or not the command was successful.
+    Note that like all CommandEvents, the event will be recorded regardless
+    of whether or not the command was successful.
     """
     def __init__(self, frame, pid, data):
-        super(SelfAbilityEvent, self).__init__(frame, pid, data)
+        super(DataCommandEvent, self).__init__(frame, pid, data)
 
         #: Other target data. Available for Data type events.
         self.target_data = self.ability_type_data.get('data', None)

sc2reader/events/tracker.py

@@ -222,7 +222,7 @@ class UnitBornEvent(TrackerEvent):
 
     Unfortunately, units that are born do not have events marking their beginnings like
     :class:`UnitInitEvent` and :class:`UnitDoneEvent` do. The closest thing to it are the
-    :class:`~sc2reader.event.game.AbilityEvent` game events where the ability is a train unit
+    :class:`~sc2reader.event.game.CommandEvent` game events where the command is a train unit
     command.
     """
     def __init__(self, frames, data, build):

sc2reader/factories/plugins/replay.py

@@ -94,7 +94,7 @@ def toDict(replay):
 def APMTracker(replay):
     """
     Builds ``player.aps`` and ``player.apm`` dictionaries where an action is
-    any Selection, Hotkey, or Ability event.
+    any Selection, Hotkey, or Command 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
@@ -106,7 +106,7 @@ def APMTracker(replay):
         player.seconds_played = replay.length.seconds
 
         for event in player.events:
-            if event.name == 'SelectionEvent' or 'AbilityEvent' in event.name or 'ControlGroup' in event.name:
+            if event.name == 'SelectionEvent' or 'CommandEvent' in event.name or 'ControlGroup' in event.name:
                 player.aps[event.second] += 1
                 player.apm[int(event.second/60)] += 1
 

sc2reader/scripts/sc2parse.py

@@ -48,7 +48,7 @@ def main():
                         human.pids = set([human.pid for human in replay.humans])
                         event_pids = set([event.player.pid for event in replay.events if getattr(event, 'player', None)])
                         player_pids = set([player.pid for player in replay.players if player.is_human])
-                        ability_pids = set([event.player.pid for event in replay.events if 'AbilityEvent' in event.name])
+                        ability_pids = set([event.player.pid for event in replay.events if 'CommandEvent' in event.name])
                         if human.pids != event_pids:
                             print('Event Pid problem!  pids={pids} but event pids={event_pids}'.format(pids=human.pids, event_pids=event_pids))
                             print(' with {path}: {build} - {real_type} on {map_name} - Played {start_time}'.format(path=path, **replay.__dict__))

sc2reader/scripts/sc2replayer.py

@@ -45,7 +45,7 @@ def getch():
 def main():
     parser = argparse.ArgumentParser(
         description="""Step by step replay of game events; shows only the
-        Initialization, Ability, and Selection events by default. Press any
+        Initialization, Command, and Selection events by default. Press any
         key to advance through the events in sequential order."""
     )
 
@@ -77,7 +77,7 @@ def main():
         # Loop through the events
         for event in events:
 
-            if isinstance(event, AbilityEvent) or \
+            if isinstance(event, CommandEvent) or \
                     isinstance(event, SelectionEvent) or \
                     isinstance(event, PlayerLeaveEvent) or \
                     isinstance(event, GameStartEvent) or \