Added observers support, currently doesn't work with teams

Author: alexhanh

sc2reader/objects.py

@@ -105,6 +105,7 @@ def __init__(self, elapsed_time, event_type, event_code, global_flag, player_id,
         self.player = player_id
         self.location = location
         self.bytes = bytes
+        self.abilitystr = ""
 
         # Added for convenience
         self.is_init = (event_type == 0x00)
@@ -137,6 +138,7 @@ def __str__(self):
     def __repr__(self):
         return str(self)
 
+# TODO: Refactor message.player to message.sender
 class Message(object):
 
     def __init__(self, time, player, target, text):
@@ -152,13 +154,30 @@ def __str__(self):
     def __repr__(self):
         return str(self)
 
+# Actor is a base class for Observer and Player
+class Actor(object):
+    def __init__(self, is_obs):
+        self.pid = None
+        self.name = None
+        self.team = None
+        self.is_obs = is_obs
+        self.messages = list()
+        self.events = list()
+        self.recorder = True # Actual recorder will be determined using the replay.message.events file
 
+class Observer(Actor):
+    def __init__(self, pid, name):
+        Actor.__init__(self, True)
+        self.pid = pid
+        self.name = name
+        self.team = 0 # Observers share the fictitious team 0
 
-class Player(object):
+class Player(Actor):
 
     url_template = "http://%s.battle.net/sc2/en/profile/%s/%s/%s/"
 
     def __init__(self, pid, data, realm="us"):
+        Actor.__init__(self, False)
         # TODO: get a map of realm,subregion => region in here
         self.pid = pid
         self.realm = realm
@@ -176,11 +195,9 @@ def __init__(self, pid, data, realm="us"):
             ])
         self.color_hex = "%02X%02X%02X" % (data[3][1], data[3][2], data[3][3])
         self.color_text = "" # The text of the player color (Red, Blue, etc) to be supplied later
-        self.recorder = True # Actual recorder will be determined using the replay.message.events file
         self.handicap = data[6]
         self.team = None # A number to be supplied later
         self.type = "" # Human or Computer
-        self.events = list()
         self.avg_apm = 0
         self.aps = dict() # Doesn't contain seconds with zero actions
         self.apm = dict() # Doesn't contain minutes with zero actions

sc2reader/parsers.py

@@ -2,7 +2,7 @@
 from datetime import datetime
 from collections import defaultdict
 
-from objects import Attribute, Message, Player, Event
+from objects import Attribute, Message, Player, Observer, Event
 from eventparsers import *
 from utils import ByteStream
 from exceptions import ParseError
@@ -41,12 +41,17 @@ def get_initdata_parser(build):
     return InitdataParser()
 
 class InitdataParser(object):
-    def load(self,replay,filecontents):
+    def load(self, replay, filecontents):
         bytes = ByteStream(filecontents)
         num_players = bytes.get_big_8()
-        for p in range(0,num_players):
+        for p in range(0, num_players):
             name_length = bytes.get_big_8()
             name = bytes.get_string(name_length)
+            
+            # Add every player as observer for now
+            if name_length > 0:
+                replay.observers.append(Observer(p+1, name))
+                
             bytes.skip(5)
 
         bytes.skip(5) # Unknown
@@ -107,10 +112,10 @@ def load(self, replay, filecontents):
 
         replay.type = data[16]['Game Type']
 
-        #Set player attributes as available,  requires already populated player list
+        #Set player attributes as available, requires already populated player list
         for pid, attributes in data.iteritems():
             if pid == 16: continue
-            player = replay.player[pid]
+            player = replay.actor[pid]
             player.color_text = attributes['Color']
             player.team = attributes['Teams'+replay.type]
             player.choosen_race = attributes['Race']
@@ -131,10 +136,17 @@ def load_header(self, replay, bytes):
 class DetailParser(object):
     def load(self, replay, filecontents):
         data =  ByteStream(filecontents).parse_serialized_data()
-        
+
+        pids = []
         for pid, pdata in enumerate(data[0]):
-            replay.add_player(Player(pid+1, pdata, replay.realm)) #shift the id to start @ 1
-            
+            pids.append(pid+1)
+            replay.add_actor(Player(pid+1, pdata, replay.realm)) #shift the id to start @ 1
+        
+        # Remove actual players from the observers we saved during parsing of initdata.
+        replay.observers = [obs for obs in replay.observers if not obs.pid in pids]
+        for observer in replay.observers:
+            replay.add_actor(observer)
+        
         replay.map = data[1].decode("hex")
         replay.file_time = data[5]
 
@@ -170,10 +182,7 @@ def load(self, replay, filecontents):
                 #some sort of header code
                 elif flags & 0x0F == 0:
                     bytes.skip(4)
-                    if player_id <= len(replay.players):
-                        replay.player[player_id].recorder = False
-                    else:
-                        pass #This "player" is an observer or something
+                    replay.actor[player_id].recorder = False
 
             elif flags & 0x80 == 0:
                 target = flags & 0x03
@@ -187,20 +196,20 @@ def load(self, replay, filecontents):
 
                 text = bytes.get_string(length)
                 try:
-                    replay.messages.append(Message(time, replay.player[player_id], target, text))
+                    replay.messages.append(Message(time, replay.actor[player_id], target, text))
                 except KeyError:
                     # This was added because some replay sites added their own tampered
                     # messages to replays with non-existent player_id.
                     #
                     # This will simply ignore and fail silently if such message is 
                     # found.
                     pass
-                
-        recorders = [player for player in replay.players if player and player.recorder==True]
+        
+        recorders = [actor for actor in replay.actors if actor and actor.recorder==True]
         if len(recorders) > 1:
             raise ValueError("There should be 1 and only 1 recorder; %s were found" % len(recorders))
         elif len(recorders) == 0:
-            #If there are no recorders,  then the recorder must not be a player,  spectator or referee then
+            #If there are no recorders, then the recorder must not be a player, spectator or referee then
             replay.recorder = None
         else:
             replay.recorder = recorders[0]

sc2reader/replay.py

@@ -4,7 +4,7 @@
 from mpyq import MPQArchive
 
 import parsers
-from utils import ByteStream, PlayerDict
+from utils import ByteStream, ActorDict
 
 class Replay(object):
 
@@ -22,8 +22,10 @@ def __init__(self, replay, partial_parse=True, full_parse=True):
         self.events = list()
         self.results = dict()
         self.teams = defaultdict(list)
+        self.observers = list() #Unordered list of Observer
         self.players = list() #Unordered list of Player
-        self.player = PlayerDict() #Maps pid to Player
+        self.actors = list() #Unordered list of Players+Observers
+        self.actor = ActorDict() #Maps pid to Player/Observer
         self.events_by_type = dict()
         self.attributes = list()
         self.length = None # (minutes, seconds) tuple
@@ -78,9 +80,14 @@ def __init__(self, replay, partial_parse=True, full_parse=True):
         if full_parse:
             self._parse_events()
 
-    def add_player(self,player):
-        self.players.append(player)
-        self.player[player.pid] = player
+    def add_actor(self, actor):
+        # Observers were added to self.observers already
+        
+        if not actor.is_obs:
+            self.players.append(actor)
+            
+        self.actor[actor.pid] = actor
+        self.actors.append(actor)
 
     def _parse_header(self):
         #Open up a ByteStream for its contents
@@ -151,27 +158,25 @@ def _parse_events(self):
             self.events_by_type[event.name].append(event)
 
             if event.is_local:
-                # TODO: This will probably break with observers because events
-                # are recorded for observers but they are not added to self.players
-                player = self.player[event.player]
-                player.events.append(event)
+                actor = self.actor[event.player]
+                actor.events.append(event)
 
                 # Calculate APS, APM and average
-                if event.is_player_action:
-                    if event.seconds in player.aps:
-                        player.aps[event.seconds] += 1
+                if not actor.is_obs and event.is_player_action:
+                    if event.seconds in actor.aps:
+                        actor.aps[event.seconds] += 1
                     else:
-                        player.aps[event.seconds] = 1
+                        actor.aps[event.seconds] = 1
 
                     minute = event.seconds/60
-                    if minute in player.apm:
-                        player.apm[minute] += 1
+                    if minute in actor.apm:
+                        actor.apm[minute] += 1
                     else:
-                        player.apm[minute] = 1
+                        actor.apm[minute] = 1
 
-                    player.avg_apm += 1
+                    actor.avg_apm += 1
 
-        # Average the APM
+        # Average the APM for actual players
         for player in self.players:
             player.avg_apm /= player.events[-1].seconds/60.0
 
@@ -187,7 +192,7 @@ def _process_results(self):
         for event in self.events_by_type['leave']:
             #Some spectator actions seem to be recorded, they aren't on teams anyway
             if event.player <= len(self.players):
-                team = self.player[event.player].team
+                team = self.actor[event.player].team
                 self.results[team] -= 1 
 
         #mark all teams with no players left as losing, save the rest of the teams

sc2reader/utils.py

@@ -1,4 +1,4 @@
-class PlayerDict(dict):
+class ActorDict(dict):
     """Delete is supported on the pid index only"""
     def __init__(self, *args, **kwargs):
         self._key_map = dict()
@@ -17,7 +17,7 @@ def __getitem__(self, key):
         if isinstance(key, str):
             key = self._key_map[key]
 
-        return super(PlayerDict, self).__getitem__(key)
+        return super(ActorDict, self).__getitem__(key)
 
     def __setitem__(self, key, value):
         if isinstance(key, str):
@@ -26,7 +26,7 @@ def __setitem__(self, key, value):
         elif isinstance(key, int):
             self._key_map[value.name] = key
 
-        super(PlayerDict, self).__setitem__(value.pid, value)
+        super(ActorDict, self).__setitem__(value.pid, value)
 
 
 from cStringIO import StringIO

test_replays/test_all.py

@@ -34,15 +34,15 @@ def test_standard_1v1():
     assert replay.is_private == False
 
     assert len(replay.players) == 2
-    assert replay.player[1].name == "Emperor"
-    assert replay.player[2].name == "Boom"
-    emperor = replay.player['Emperor']
+    assert replay.actor[1].name == "Emperor"
+    assert replay.actor[2].name == "Boom"
+    emperor = replay.actor['Emperor']
     assert emperor.team == 1
     assert emperor.choosen_race == "Protoss"
     assert emperor.actual_race == "Protoss"
     assert emperor.recorder == False
 
-    boom = replay.player['Boom']
+    boom = replay.actor['Boom']
     assert boom.team == 2
     assert boom.choosen_race == "Terran"
     assert boom.actual_race == "Terran"
@@ -126,27 +126,27 @@ def test_unknown_winner():
 def test_random_player():
     replay = Replay("test_replays/build17811/3.SC2Replay")
 
-    gogeta = replay.player['Gogeta']
+    gogeta = replay.actor['Gogeta']
     assert gogeta.choosen_race == "Random"
     assert gogeta.actual_race == "Terran"
 
 def test_random_player2():
     replay = Replay("test_replays/build17811/6.SC2Replay")
-    permafrost = replay.player["Permafrost"]
+    permafrost = replay.actor["Permafrost"]
     assert permafrost.choosen_race == "Random"
     assert permafrost.actual_race == "Protoss"
 
 def test_us_realm():
     replay = Replay("test_replays/build17811/5.SC2Replay")
-    assert replay.player['ShadesofGray'].url == "http://us.battle.net/sc2/en/profile/2358439/1/ShadesofGray/"
-    assert replay.player['reddawn'].url == "http://us.battle.net/sc2/en/profile/2198663/1/reddawn/"
+    assert replay.actor['ShadesofGray'].url == "http://us.battle.net/sc2/en/profile/2358439/1/ShadesofGray/"
+    assert replay.actor['reddawn'].url == "http://us.battle.net/sc2/en/profile/2198663/1/reddawn/"
 
 # TODO: Current problem.. both players are set as the recording players
 # Waiting for response https://github.com/arkx/mpyq/issues/closed#issue/7
 def test_kr_realm_and_tampered_messages():
     replay = Replay("test_replays/build17811/11.SC2Replay")
-    assert replay.player['명지대학교'].url == "http://kr.battle.net/sc2/en/profile/258945/1/명지대학교/"
-    assert replay.player['티에스엘사기수'].url == "http://kr.battle.net/sc2/en/profile/102472/1/티에스엘사기수/"
+    assert replay.actor['명지대학교'].url == "http://kr.battle.net/sc2/en/profile/258945/1/명지대학교/"
+    assert replay.actor['티에스엘사기수'].url == "http://kr.battle.net/sc2/en/profile/102472/1/티에스엘사기수/"
 
     assert replay.messages[0].text == "sc2.replays.net"
     assert replay.messages[5].text == "sc2.replays.net"
@@ -159,7 +159,6 @@ def test_footmen():
 def test_encrypted():
     replay = Replay("test_replays/build17811/4.SC2Replay")
 
-# TODO: Failing
 def test_observers():
     replay = Replay("test_replays/build17811/13.SC2Replay")