Clean up the details reader. Use the Color object.

Mostly cosmetic changes with two primary exceptions:

* The race is now purely determined by a lookup in the LOCALIZED_RACES dict
  and not by a quick check on the first character. This lowers the quality
  of recognition in the short run, but should set us up better for localization
  in the future after the LOCALIZED_RACES dict has been more fully populated.

* A player's color related fields are now encapsulated by the Color object. Old
  code can be converted with no side effects by applying the following changes:

    - the .color_rgba is now the .color object it self:
        player.color_rgba -> player.color

    - the .color string is the str() conversion of the .color object:
        player.color -> str(player.color)

    - the .color_hex string is now a property of the .color object:
        player.color_hex -> player.color.hex

Author: GraylinKim

sc2reader/constants.py

@@ -7,7 +7,11 @@
 LOCALIZED_RACES = {
 
     # deDE
+    'Terraner': 'Terran',
     # enUS
+    'Terran': 'Terran',
+    'Protoss': 'Protoss',
+    'Zerg': 'Zerg',
     # esES
     # esMX
     # frFR

sc2reader/processors.py

@@ -139,9 +139,9 @@ def process_results(replay):
     # Check if replay file has recorded the winner
     remaining = set()
     for player in replay.players:
-        if player.outcome == 1:
+        if player.result == 1:
             replay.results[player.team] = "Won"
-        elif player.outcome == 2:
+        elif player.result == 2:
             replay.results[player.team] = "Lost"
         else:
             remaining.add(player.team)

sc2reader/readers.py

@@ -3,7 +3,7 @@
 from sc2reader.parsers import *
 from sc2reader.objects import *
 from sc2reader.utils import LITTLE_ENDIAN, BIG_ENDIAN
-from sc2reader.utils import timestamp_from_windows_time
+from sc2reader.utils import timestamp_from_windows_time, AttributeDict
 
 #################################################
 
@@ -55,51 +55,43 @@ def load_header(self, replay, buffer):
 ##################################################
 
 class DetailsReader(object):
+    color_fields = ('a','r','g','b',)
+    player_fields = ('name','bnet','race','color','?','?','handicap','?','result')
+
     def read(self, buffer, replay):
         data = buffer.read_data_struct()
 
         for pid, pdata in enumerate(data[0]):
-            fields = ('name','battlenet','race','color','??','??','handicap','??','outcome',)
-            pdata = dict(zip(fields, [pdata[i] for i in sorted(pdata.keys())]))
-
-            # TODO?: get a map of realm,subregion => region in here
-            player = Player(pid+1, pdata['name'], replay)
-            player.uid = pdata['battlenet'][4]
-            player.subregion = pdata['battlenet'][2]
-            player.handicap = pdata['handicap']
+            values = [v for k,v in sorted(pdata.iteritems())]
+            pdata = AttributeDict(zip(self.player_fields, values))
+
+            #Handle the basic player attributes
+            player = Player(pid+1, pdata.name, replay)
+            player.uid = pdata.bnet[4]
+            player.subregion = pdata.bnet[2]
+            player.handicap = pdata.handicap
             player.realm = replay.realm
+            player.result = pdata.result
+            # TODO?: get a map of realm,subregion => region in here
 
-            # Some European language, like DE will have races written slightly differently (ie. Terraner).
-            # To avoid these differences, only examine the first letter, which seem to be consistent across languages.
-            race = pdata['race']
-            if race[0] == 'T':
-                race = "Terran"
-            if race[0] == 'P':
-                race = "Protoss"
-            if race[0] == 'Z':
-                race = "Zerg"
-            # Check against non-western localised races
-            player.actual_race = LOCALIZED_RACES.get(race, race)
-
-            color = [pdata['color'][i] for i in sorted(pdata['color'].keys())]
-            color = dict(zip(('a','r','g','b',), color))
-            player.color_hex = "%(r)02X%(g)02X%(b)02X" % color
-            player.color = COLOR_CODES.get(player.color_hex, player.color_hex)
-            player.color_rgba = color
-
-            player.outcome = pdata['outcome']
+            # Now convert all different localizations to western if we can
+            # TODO: recognize current locale and use that instead of western
+            # TODO: fill in the LOCALIZED_RACES table
+            player.actual_race = LOCALIZED_RACES.get(pdata.race, pdata.race)
+
+            ''' Conversion to the new color object:
+                    color_rgba is the color object itself
+                    color_hex is color.hex
+                    color is str(color)'''
+            values = [v for k,v in sorted(pdata.color.iteritems())]
+            player.color = Color(zip(self.color_fields, values))
 
             # Add player to replay
             replay.players.append(player)
-            
+
+        #Non-player details
         replay.map = data[1]
         replay.file_time = data[5]
-
-        # TODO: This doesn't seem to produce exactly correct results, ie. often off by one
-        # second compared to file timestamps reported by Windows.
-        # This might be due to wrong value of the magic constant 116444735995904000
-        # or rounding errors. Ceiling or Rounding the result didn't produce consistent
-        # results either.
         unix_timestamp = timestamp_from_windows_time(replay.file_time)
         replay.date = datetime.fromtimestamp(unix_timestamp)
         replay.utc_date = datetime.utcfromtimestamp(unix_timestamp)