Continued to work on s2gs files

Can now parse:
* Player
** id
** race
** stats (everything on the score screen)
** graphs
* Game
** speed

Author: Prillan

sc2reader/objects.py

@@ -208,10 +208,50 @@ def format(self, format_string):
     def __repr__(self):
         return str(self)
 
+class Graph():
+    """
+    A class to represent a graph on the score screen
+    """
+    #: Times in seconds on the x-axis of the graph
+    times = list()
+
+    #: Values on the y-axis of the graph
+    values = list()
+
+    def __init__(self, x, y, xy_list=None):
+        if xy_list:
+            for x, y in xy_list:
+                self.times.append(x)
+                self.values.append(y)
+        else:
+            self.times = x
+            self.values = y
+
+    def as_points(self):
+        """ Get the graph as a list of (x, y) tuples """
+        return zip(self.times, self.values)
+
+    def __str__(self):
+        return "Graph with {0} values".format(len(self.times))
+
 class PlayerSummary():
     """
     A class to represent a player in the game summary (.s2gs)
     """
+    stats_pretty_names = {
+        'R' : 'Resources',
+        'U' : 'Units',
+        'S' : 'Structures',
+        'O' : 'Overview',
+        'AUR' : 'Average Unspent Resources',
+        'RCR' : 'Resource Collection Rate',
+        'WC' : 'Workers Created',
+        'UT' : 'Units Trained',
+        'KUC' : 'Killed Unit Count',
+        'SB' : 'Structures Built',
+        'SRC' : 'Structures Razed Count'
+        }
+
     #: The index of the player in the game
     pid = int()
 
@@ -230,8 +270,23 @@ class PlayerSummary():
     #: unknown2
     unknown2 = dict()
 
+    #: :class:`Graph` of player army values over time (seconds)
+    army_graph = None
+    
+    #: :class:`Graph` of player income over time (seconds)
+    income_graph = None
+
+    #: Stats from the game in a dictionary
+    stats = dict()
+
     def __init__(self, pid):
         self.pid = pid
 
     def __str__(self):
         return '{} - {}/{}/'.format(self.race, self.subregion, self.bnetid)
+
+    def get_stats(self):
+        s = ''
+        for k in self.stats:
+            s += '{}: {}\n'.format(self.stats_pretty_names[k], self.stats[k])
+        return s.strip()

sc2reader/resources.py

@@ -11,8 +11,8 @@
 
 from sc2reader import utils
 from sc2reader import log_utils
-from sc2reader.objects import Player, Observer, Team, PlayerSummary
-from sc2reader.constants import REGIONS, LOCALIZED_RACES, GAME_SPEED_FACTOR
+from sc2reader.objects import Player, Observer, Team, PlayerSummary, Graph
+from sc2reader.constants import REGIONS, LOCALIZED_RACES, GAME_SPEED_FACTOR, GAME_SPEED_CODES, RACE_CODES
 
 
 class Resource(object):
@@ -397,24 +397,26 @@ def read_game_strings(self):
             elif parts[0] == 'DocInfo/DescLong':
                 self.description = parts[1]
 
-s2gsmap = [[4, "Average Unspent Resources"],
-           [5, "Resource Collection Rate"],
-           [6, "Workers Created"],
-           [7, "Units Trained"],
-           [8, "Killed Unit Count"],
-           [9, "Structure Built"],
-          ]
 
 class GameSummary(Resource):
     url_template = 'http://{0}.depot.battle.net:1119/{1}.s2gs'
 
-    race_map = {
-        'Zerg' : 'Zerg',
-        'Terr' : 'Terran',
-        'Prot' : 'Protoss',
-        'RAND' : 'Random'
-        }
-
+    stats_keys = [
+        'R',
+        'U',
+        'S',
+        'O',
+        'AUR',
+        'RCR',
+        'WC',
+        'UT',
+        'KUC',
+        'SB',
+        'SRC',
+        ]
+    
+    #: Game speed
+    game_speed = str()
 
     #: Players, a list of :class`PlayerSummary` from the game
     players = list()
@@ -428,22 +430,50 @@ def __init__(self, summary_file, filename=None, **options):
             part = buffer.read_data_struct()
             self.parts.append(part)
 
-        #Parse players, 16 is the maximum amount of players
+        # Parse basic info
+        self.game_speed = GAME_SPEED_CODES[''.join(reversed(self.parts[0][0][1]))]
+
+        # Parse player structs, 16 is the maximum amount of players
         for i in range(16):
             player = None
             # Check if player, break if not
             if self.parts[0][3][i][2] == '\x00\x00\x00\x00':
                 break
             player_struct = self.parts[0][3][i]
 
-            player = PlayerSummary(i)
-            player.race = self.race_map[player_struct[2]]
+            player = PlayerSummary(player_struct[0][0])
+            player.race = RACE_CODES[''.join(reversed(player_struct[2]))]
             player.bnetid = player_struct[0][1][0][3]
             player.subregion = player_struct[0][1][0][2]
 
+            # int
+            player.unknown1 = player_struct[0][1][0]
+            # {0:long1, 1:long2}
+            # Example:
+            # { 0: 3405691582L, 1: 11402158793782460416L}
+            player.unknown2 = player_struct[0][1][1]
+
             self.players.append(player)
 
-
+        # Parse graph and stats stucts, for each player
+        for p in self.players:
+
+            # Graph stuff
+            xy = [(o[2], o[0]) for o in self.parts[4][0][2][1][p.pid]]
+            p.army_graph = Graph([], [], xy_list=xy)
+
+            xy = [(o[2], o[0]) for o in self.parts[4][0][1][1][p.pid]]
+            p.income_graph = Graph([], [], xy_list=xy)
+            
+            # Stats stuff
+            stats_struct = self.parts[3][0]
+            # The first group of stats is located in parts[3][0]
+            for i in range(len(stats_struct)):
+                p.stats[self.stats_keys[i]] = stats_struct[i][1][p.pid][0][0]
+            # The last piece of stats is in parts[4][0][0][1]
+            p.stats[self.stats_keys[len(stats_struct)]] = self.parts[4][0][0][1][p.pid][0][0]
+            
+                    
 class MapInfo(Resource):
     url_template = 'http://{0}.depot.battle.net:1119/{1}.s2mi'