Merge branch 's2gs' of git://github.com/Prillan/sc2reader into s2gs

Author: GraylinKim

sc2reader/__init__.py

@@ -28,11 +28,11 @@
 load_map = __defaultSC2Reader.load_map
 load_game_summaries = __defaultSC2Reader.load_game_summaries
 load_game_summary = __defaultSC2Reader.load_game_summary
-load_match_infos = __defaultSC2Reader.load_match_infos
-load_match_info = __defaultSC2Reader.load_match_info
-load_match_histories = __defaultSC2Reader.load_match_histories
-load_match_history = __defaultSC2Reader.load_match_history
+load_map_infos = __defaultSC2Reader.load_map_infos
+load_map_info = __defaultSC2Reader.load_map_info
+load_map_histories = __defaultSC2Reader.load_map_headers
+load_map_history = __defaultSC2Reader.load_map_header
 
 
 configure = __defaultSC2Reader.configure
-reset = __defaultSC2Reader.reset
+reset = __defaultSC2Reader.reset

sc2reader/factories.py

@@ -14,7 +14,7 @@
 from sc2reader import exceptions
 from sc2reader import utils
 from sc2reader import log_utils
-from sc2reader.resources import Replay, Map, GameSummary, MatchInfo, MatchHistory
+from sc2reader.resources import Replay, Map, GameSummary, MapInfo, MapHeader
 
 class SC2Factory(object):
     """
@@ -214,19 +214,19 @@ def load_game_summary(self, summary_file, options=None, **new_options):
 
         return s2gs
 
-    def load_match_infos(self, infos, options=None, **new_options):
+    def load_map_infos(self, infos, options=None, **new_options):
         """
-        Loads a collection of MatchInfos. See load_resources for detailed
+        Loads a collection of MapInfos. See load_resources for detailed
         parameter documentation.
 
-        :rtype: generator(:class:`MatchInfo`)
+        :rtype: generator(:class:`MapInfo`)
         """
-        for s2mi in self.load_resources(infos, self.load_match_info, options=options, extensions=['.s2mi'], **new_options):
+        for s2mi in self.load_resources(infos, self.load_map_info, options=options, extensions=['.s2mi'], **new_options):
             yield s2mi
 
-    def load_match_info(self, info_file, options=None, **new_options):
+    def load_map_info(self, info_file, options=None, **new_options):
         """
-        Loads the specified match info using the current factory settings with
+        Loads the specified map info using the current factory settings with
         the specified overrides.
 
         :param info_file: An open file object or path/url to a single file
@@ -238,33 +238,33 @@ def load_match_info(self, info_file, options=None, **new_options):
         :param new_options: Options values to override current factory settings
             while loading this map.
 
-        :rtype: :class:`MatchInfo`
+        :rtype: :class:`MapInfo`
         """
         options = options or utils.merged_dict(self.options, new_options)
         resource, name = self.load_resource(info_file, options=options)
-        s2mi = MatchInfo(resource, name, **options)
+        s2mi = MapInfo(resource, name, **options)
 
         # Load summary procedure here!
         #
 
         return s2mi
 
-    def load_match_histories(self, histories, options=None, **new_options):
+    def load_map_headers(self, headers, options=None, **new_options):
         """
-        Loads a collection of match history files. See load_resources for
+        Loads a collection of map header files. See load_resources for
         detailed parameter documentation.
 
-        :rtype: generator(:class:`MatchHistory`)
+        :rtype: generator(:class:`MapHeader`)
         """
-        for s2mh in self.load_resources(histories, self.load_match_history, options=options, extensions=['.s2mh'], **new_options):
+        for s2mh in self.load_resources(headers, self.load_map_header, options=options, extensions=['.s2mh'], **new_options):
             yield s2mh
 
-    def load_match_history(self, history_file, options=None, **new_options):
+    def load_map_header(self, header_file, options=None, **new_options):
         """
         Loads the specified match info using the current factory settings with
         the specified overrides.
 
-        :param history_file: An open file object or path/url to a single file
+        :param header_file: An open file object or path/url to a single file
 
         :param None options: When options are passed directly into the options
             parameter the current factory settings are ignored and only the
@@ -273,12 +273,12 @@ def load_match_history(self, history_file, options=None, **new_options):
         :param new_options: Options values to override current factory settings
             while loading this map.
 
-        :rtype: :class:`MatchHistory`
+        :rtype: :class:`MapHeader`
         """
         options = options or utils.merged_dict(self.options, new_options)
-        resource, name = self.load_resource(history_file, options=options)
+        resource, name = self.load_resource(header_file, options=options)
         print name
-        s2mh = MatchHistory(resource, name, **options)
+        s2mh = MapHeader(resource, name, **options)
 
         # Load summary procedure here!
         #
@@ -509,4 +509,4 @@ def load_replay(self, replay_file, options=None, **new_options):
         else:
             replay = super(SC2Cache, self).load_replay(replay_file, options=options)
             self.cache.set(replay_file, replay)
-            return replay
+            return replay

sc2reader/objects.py

@@ -207,3 +207,86 @@ 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()
+
+    #: The race the player used
+    race = str()
+
+    #: Battle.Net id of the player
+    bnetid = int()
+
+    #: Subregion id of player
+    subregion = int()
+
+    #: unknown1
+    unknown1 = int()
+    
+    #: 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
-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,40 +397,105 @@ 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'
+
+    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()
+
     def __init__(self, summary_file, filename=None, **options):
         super(GameSummary, self).__init__(summary_file, filename,**options)
         self.data = zlib.decompress(summary_file.read()[16:])
         self.parts = list()
         buffer = utils.ReplayBuffer(self.data)
         while buffer.left:
             part = buffer.read_data_struct()
-#            print str(part)+"\n\n\n"
             self.parts.append(part)
-#        print len(self.parts)
-#        pprint.PrettyPrinter(indent=2).pprint(self.parts)
-        for index, name in s2gsmap:
-            for player in [0, 1]:
-                print "Player", player, name, self.parts[3][0][index][1][player][0][0]
 
-class MatchInfo(Resource):
-    url_template = 'http://{0}.depot.battle.net:1119/{1}.s2ma'
-    def __init__(self, info_file, filename=None, **options):
-        super(MatchInfo, self).__init__(info_file, filename,**options)
-        self.data = utils.ReplayBuffer(info_file).read_data_struct()
+        # 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(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'
+
+    #: Name of the Map
+    map_name = str()
+
+    #: Hash of referenced s2mh file
+    s2mh_hash = str()
+
+    #: URL of referenced s2mh file
+    s2mh_url = str()
 
-class MatchHistory(Resource):
-    url_template = 'http://{0}.depot.battle.net:1119/{1}.s2ma'
-    def __init__(self, history_file, filename=None, **options):
-        super(MatchHistory, self).__init__(history_file, filename,**options)
-        self.data = utils.ReplayBuffer(history_file).read_data_struct()
+    def __init__(self, info_file, filename=None, **options):
+        super(MapInfo, self).__init__(info_file, filename,**options)
+        self.data = utils.ReplayBuffer(info_file).read_data_struct()
+        self.map_name = self.data[0][7]
+        self.language = self.data[0][13]
+        self.s2mh_hash = ''.join([hex(ord(x))[2:] for x in self.data[0][1][8:]])
+        self.s2mh_url = MapHeader.url_template.format(self.data[0][1][6:8], self.s2mh_hash)
+
+class MapHeader(Resource):
+    url_template = 'http://{0}.depot.battle.net:1119/{1}.s2mh'
+    def __init__(self, header_file, filename=None, **options):
+        super(MapHeader, self).__init__(header_file, filename,**options)
+        self.data = utils.ReplayBuffer(header_file).read_data_struct()