Reworked the lobby parsing. Read comment in utils.py

Author: Prillan

sc2reader/constants.py

@@ -74,14 +74,14 @@
     '50ct': "Yellow",
     '60ct': "Orange",
     '70ct': "Green",
-    '80ct': "Pink",
-    '90ct': "??",
-    '01ct': "??",
-    '11ct': "??",
-    '21ct': "??",
-    '31ct': "??",
-    '41ct': "??",
-    '51ct': "??",
+    '80ct': "Light Pink",
+    '90ct': "Violet",
+    '01ct': "Light Grey",
+    '11ct': "Dark Green",
+    '21ct': "Brown",
+    '31ct': "Light Green",
+    '41ct': "Dark Grey",
+    '51ct': "Pink",
     '61ct': "??",
 }
 DIFFICULTY_CODES = {

sc2reader/objects.py

@@ -267,6 +267,9 @@ class PlayerSummary():
     #: If the player is a computer
     is_ai = False
 
+    #: If the player won the game
+    is_winner = False
+
     #: Battle.Net id of the player
     bnetid = int()
 

sc2reader/resources.py

@@ -424,6 +424,7 @@ class GameSummary(Resource):
         1001 : ('unknown3', {'sey':'yes', 'on':'no'}), #yes/no
         1000 : ('unknown4', {'tlfD':'Default'}), #Dflt
         2000 : ('unknown5', {'2t':'t2', '3t':'t3', 'AFF':'FFA', 'tsuC':'Custom'}), #t2/t3/FFA/Cust
+        3007 : ('unknown6', {'traP':'Part'}),
         3009 : ('lobby_type', GAME_TYPE_CODES) #Priv/Pub/Amm (Auto MatchMaking)
         }
     lobby_player_keys = {
@@ -432,7 +433,12 @@ class GameSummary(Resource):
         3003 : ('energy', {'05':'50','06':'60','07':'70','08':'80','09':'90','001':'100'}),
         3002 : ('color', TEAM_COLOR_CODES),
         3004 : ('difficulty', DIFFICULTY_CODES),
-        3008 : ('nonplayer_mode', {'sbO':'Observer','feR':'Ref'}) #Obs/Ref        
+        3008 : ('nonplayer_mode', {'sbO':'Observer','feR':'Ref'}), #Obs/Ref        
+        
+        #Team properties
+        2012 : ('team_t3', {'1T':'T1', '2T':'T2', '3T':'T3'}),
+        
+        
         }
 
     #: Game speed
@@ -446,6 +452,9 @@ class GameSummary(Resource):
 
     #: Lobby properties
     lobby_properties = dict()
+    
+    #: Lobby player properties
+    lobby_player_properties = dict()
 
     #: Game completion time
     time = int()
@@ -456,6 +465,9 @@ class GameSummary(Resource):
     #: Teams, a dict of pids
     teams = dict()
 
+    #: Winners, a list of the pids of the winning players
+    winners = list()
+
     #: Build orders, a dict of build orders indexed by player id
     build_orders = dict()
 
@@ -473,7 +485,9 @@ def __init__(self, summary_file, filename=None, **options):
         self.image_urls = list()
         self.localization_urls = dict()
         self.lobby_properties = dict()
+        self.lobby_player_properties = dict()
         self.teams = dict()
+        self.winners = list()
 
         self.data = zlib.decompress(summary_file.read()[16:])
         self.parts = list()
@@ -497,24 +511,7 @@ def __init__(self, summary_file, filename=None, **options):
         self.game_length = self.game_length_ingame / GAME_SPEED_FACTOR[self.game_speed]
 
         # parse lobby properties
-        lobby_template = dict()
-        for prop in self.parts[0][5]:
-            if not prop[0][1] in self.lobby_keys:
-                continue
-            lobby_template[prop[0][1]] = [o[0].strip('\x00') for o in prop[1]]
-        for prop in self.parts[0][6][6]:
-            if not prop[0][1] in lobby_template:
-                continue
-            key = self.lobby_keys[prop[0][1]][0]
-            val = lobby_template[prop[0][1]][prop[1][0]]
-            self.lobby_properties[key] = self.lobby_keys[prop[0][1]][1][utils.reverse_str(val)]
-
-        # Prepare player lobby properties
-        lobby_player_template =  dict()
-        for prop in self.parts[0][5]:
-            if not prop[0][1] in self.lobby_player_keys:
-                continue
-            lobby_player_template[prop[0][1]] = [o[0].strip().strip('\x00') for o in prop[1]]
+        (self.lobby_properties, self.lobby_player_properties) = utils.get_lobby_properties(self.parts)
 
         # Parse player structs, 16 is the maximum amount of players
         for i in range(16):
@@ -526,7 +523,11 @@ def __init__(self, summary_file, filename=None, **options):
 
             player = PlayerSummary(player_struct[0][0])
             player.race = RACE_CODES[''.join(reversed(player_struct[2]))]
-            player.teamid = player_struct[1][0]
+            # I haven't found how to get the teams yet
+            player.teamid = 0
+            player.is_winner = (player_struct[1][0] == 0)
+            if player.is_winner:
+                self.winners.append(player.pid)
 
             # Is the player an ai?
             if type(player_struct[0][1]) == type(int()):
@@ -544,21 +545,11 @@ def __init__(self, summary_file, filename=None, **options):
                 # { 0: 3405691582L, 1: 11402158793782460416L}
                 player.unknown2 = player_struct[0][1][1]
 
-            # Parse lobby properties
-            player.lobby_properties = dict()
-            for prop in self.parts[0][6][6]:
-                if not prop[0][1] in lobby_player_template:
-                    continue
-                key = self.lobby_player_keys[prop[0][1]][0]
-                val = lobby_player_template[prop[0][1]][prop[1][player.pid][0]]
-                player.lobby_properties[key] = self.lobby_player_keys[prop[0][1]][1][utils.reverse_str(val)]
-
             self.players[player.pid] = player
             if not player.teamid in self.teams:
                 self.teams[player.teamid] = list()
             self.teams[player.teamid].append(player.pid)
 
-
         # Parse graph and stats stucts, for each player
         for pid in self.players:
             p = self.players[pid]
@@ -631,7 +622,9 @@ def __str__(self):
                                          int(self.game_length)/3600,
                                          (int(self.game_length)%3600)/60,
                                          (int(self.game_length)%3600)%60,
-                                         ''.join(self.players[p].race[0] for p in self.players))
+                                         'v'.join(''.join(self.players[p].race[0] for p in self.teams[tid]) for tid in self.teams))
+
+    
 
 class MapInfo(Resource):
     url_template = 'http://{0}.depot.battle.net:1119/{1}.s2mi'

sc2reader/utils.py

@@ -10,6 +10,7 @@
 import mpyq
 from itertools import groupby
 from datetime import timedelta
+from collections import deque
 
 from sc2reader import exceptions
 from sc2reader.constants import COLOR_CODES, BUILD_ORDER_UPGRADES
@@ -813,3 +814,129 @@ def __str__(self):
             return "{0:0>2}.{1:0>2}.{2:0>2}".format(self.hours,self.mins,self.secs)
         else:
             return "{0:0>2}.{1:0>2}".format(self.mins,self.secs)
+
+
+#Monster function used to parse lobby properties in GameSummary
+def get_lobby_properties(data):
+    ###
+    # The definition of each lobby property is in data[0][5] with the structure
+    # 
+    # id = def[0][1] # The unique property id  
+    # vals = def[1]  # A list with the values the property can be
+    # reqs = def[3]  # A list of requirements the property has
+    # dflt = def[8]  # The default value(s) of the property
+    #                this is a single entry for a global property
+    #                and a list() of entries for a player property
+    
+    # The def-values is structured like this
+    #
+    # id = `the index in the vals list`
+    # name = v[0]    # The name of the value
+    
+    # The requirement structure looks like this
+    # 
+    # id = r[0][1][1] # The property id of this requirement
+    # vals = r[1]     # A list of names of valid values for this requirement
+    
+    ###
+    # The values of each property is in data[0][6][6] with the structure
+    #
+    # id = v[0][1]  # The property id of this value
+    # vals = v[1]   # The value(s) of this property
+    #                this is a single entry for a global property
+    #                and a list() of entries for a player property
+
+    ###
+    # A value-entry looks like this
+    #
+    # index = v[0]  # The index in the def.vals array representing the value
+    # unknown = v[1] 
+
+    # First get the definitions in data[0][5]
+    defs = dict()
+    for d in data[0][5]:
+        k = d[0][1]
+        defs[k] = {
+            'id':k,
+            'vals':d[1],
+            'reqs':d[3],
+            'dflt':d[8],
+            'lobby_prop':type(d[8]) == type(dict()) 
+            }
+    vals = dict()
+
+    # Get the values in data[0][6][6]
+    for v in data[0][6][6]:
+        k = v[0][1]
+        vals[k] = {
+            'id':k,
+            'vals':v[1]
+            }
+    
+    lobby_ids = [k for k in defs if defs[k]['lobby_prop']]
+    player_ids = [k for k in defs if not defs[k]['lobby_prop']]
+    
+    left_lobby = deque([k for k in defs if defs[k]['lobby_prop']])
+    
+    lobby_props = dict()
+    # We cycle through all property values 'til we're done
+    while len(left_lobby) > 0:
+        propid = left_lobby.popleft()
+        can_be_parsed = True
+        active = True
+        # Check the requirements
+        for req in defs[propid]['reqs']:
+            can_be_parsed = can_be_parsed and (req[0][1][1] in lobby_props)
+            # Have we parsed all req-fields?
+            if not can_be_parsed:
+                break
+            # Is this requirement fullfilled?
+            active = active and (lobby_props[req[0][1][1]] in req[1])
+            
+        if not can_be_parsed:
+            # Try parse this later
+            left_lobby.append(propid)
+            continue
+        if not active:
+            # Ok, so the reqs weren't fullfilled, don't use this property
+            continue
+        # Nice! We've parsed a property
+        lobby_props[propid] = defs[propid]['vals'][vals[propid]['vals'][0]][0]
+
+    player_props = [dict() for pid in range(16)]
+    # Parse each player separately (this is required :( )
+    for pid in range(16):
+        # The most required value, 500, is in the back, change this
+        left_players = deque(reversed([a for a in player_ids]))
+        player = dict()
+        
+        # Use this to avoid an infinite loop
+        last_success = 0
+        max = len(left_players)
+        while len(left_players) > 0 and not (last_success > max+1):
+            last_success += 1
+            propid = left_players.popleft()
+            can_be_parsed = True
+            active = True
+            for req in defs[propid]['reqs']:
+                #req is a lobby prop
+                if req[0][1][1] in lobby_ids:
+                    active = active and (req[0][1][1] in lobby_props) and (lobby_props[req[0][1][1]] in req[1])
+                #req is a player prop
+                else:
+                    can_be_parsed = can_be_parsed and (req[0][1][1] in player)
+                    if not can_be_parsed:
+                        break
+                    active = active and (player[req[0][1][1]] in req[1])
+                
+            if not can_be_parsed:
+                left_players.append(propid)
+                continue
+            last_success = 0
+            if not active:
+                continue
+            player[propid] = defs[propid]['vals'][vals[propid]['vals'][pid][0]][0]
+
+        player_props[pid] = player
+
+    return (lobby_props, player_props)