Rework the pid assignment and event mapping (again).

Author: GraylinKim

sc2reader/events.py

@@ -16,12 +16,22 @@ def __init__(self, frame, pid):
         # self.time = Length(seconds=self.second)
 
     def load_context(self, replay):
-        if self.pid < len(replay.people):
-            self.player = replay.people[self.pid]
-        elif self.pid != 16:
-            self.logger.error("Bad pid ({0}) for event {1} at {2}.".format(self.pid, self.__class__, Length(seconds=self.second)))
-        else:
-            pass # This is a global event
+        if replay.expansion == 'WoL' or replay.build < 24247:
+            if self.pid <= len(replay.people):
+                self.player = replay.person[self.pid]
+            elif self.pid != 16:
+                self.logger.error("Bad pid ({0}) for event {1} at {2}.".format(self.pid, self.__class__, Length(seconds=self.second)))
+            else:
+                pass # This is a global event
+
+        elif replay.expansion == 'HotS':
+            if self.pid < len(replay.clients):
+                self.player = replay.client[self.pid]
+            elif self.pid != 16:
+                self.logger.error("Bad pid ({0}) for event {1} at {2}.".format(self.pid, self.__class__, Length(seconds=self.second)))
+            else:
+                pass # This is a global event
+
 
     def _str_prefix(self):
         player_name = self.player.name if getattr(self,'pid', 16)!=16 else "Global"

sc2reader/readers.py

@@ -105,9 +105,6 @@ def __call__(self, data, replay):
                     data.read_byte(),
                     data.read(4).strip('\00 ')[::-1]
                 ]
-
-            if info[2]!=16: info[2]-=1 # Convert from 1-offset to 0-offset
-            #print hex(info[1]), "P"+str(info[2]), info[3]
             attribute_events.append(Attribute(info))
 
         return attribute_events
@@ -196,7 +193,6 @@ class DetailsReader_Beta_24764(DetailsReader_Beta):
     PlayerData = namedtuple('PlayerData',['name','bnet','race','color','unknown1','unknown2','handicap','unknown3','result','unknown4'])
 
 class MessageEventsReader_Base(Reader):
-    POFFSET=-1
     TARGET_BITS=3
     def __call__(self, data, replay):
         # The replay.message.events file is a single long list containing three
@@ -211,7 +207,6 @@ def __call__(self, data, replay):
             # All the element types share the same time, pid, flags header.
             frame += data.read_timestamp()
             pid = data.read_bits(5)
-            if pid != 16: pid+=self.POFFSET
             t = data.read_bits(3)
             flags = data.read_byte()
 
@@ -237,7 +232,6 @@ def __call__(self, data, replay):
         return AttributeDict(pings=pings, messages=messages, packets=packets)
 
 class MessageEventsReader_Beta_24247(MessageEventsReader_Base):
-    POFFSET=0
     TARGET_BITS=4
 
 class GameEventsReader_Base(object):
@@ -246,7 +240,6 @@ class GameEventsReader_Base(object):
     ABILITY_TEAM_FLAG = False
     UNIT_INDEX_BITS = 8
     HOTKEY_OVERLAY = 0
-    POFFSET = -1
 
     def __init__(self):
         self.EVENT_DISPATCH = {
@@ -281,7 +274,6 @@ def __call__(self, data, replay):
             while event_start != data_length:
                 fstamp += read_timestamp()
                 pid = read_bits(5)
-                if pid != 16: pid+= self.POFFSET
                 event_type = read_bits(7)
 
                 # Check for a lookup
@@ -598,6 +590,3 @@ def player_selection_event(self, data, fstamp, pid, event_type):
 
 class GameEventsReader_Beta_23925(GameEventsReader_Beta):
     PLAYER_JOIN_FLAGS = 32
-
-class GameEventsReader_Beta_24247(GameEventsReader_Beta_23925):
-    POFFSET = 0

sc2reader/resources.py

@@ -335,27 +335,22 @@ def load_players(self):
         if 'replay.initData' not in self.raw_data:
             return
 
-        # 1. pids are in lobby join order, use initData.player_names
-        # 2. use the name to get the player_data index
-        # 2a. if observer, save pid+name for later
-        # 3. use the player_data index as the attrib_data index...?
-        # 4. use the player_data and attribute_data to load the player
-        # 5. after loop, load the computer players and (optionally) their attributes
-        # 6. then load the observer pid,name using attributes if available
+        self.clients = list()
+        self.client = dict()
+
+        def createObserver(pid, name, attributes):
+            # TODO: Make use of that attributes, new in HotS
+            observer = Observer(pid, name)
+            return observer
+
         def createPlayer(pid, pdata, attributes):
-            # General information re: each player comes from the following files
-            #   * replay.initData
-            #   * replay.details
-            #   * replay.attribute.events
-            #
-            # TODO: recognize current locale and use that instead of western
-            # TODO: fill in the LOCALIZED_RACES table
-            player = Player(pid,pdata.name)
-
-            # Cross reference the player and team lookups
-            # TODO: Players without attribute events, where do we get the team info?
-            # print pdata.name, attributes, pdata
-            team_number = attributes.get('Teams'+self.type,0)
+            # make sure to strip the clan tag out of the name
+            name = pdata.name.split("]")[-1]
+            player = Player(pid, name)
+
+            # In some beta patches attribute information is missing
+            # Just assign them to team 2 to keep the issue from being fatal
+            team_number = attributes.get('Teams'+self.type,2)
             if not team_number in self.team:
                 self.team[team_number] = Team(team_number)
                 self.teams.append(self.team[team_number])
@@ -368,70 +363,50 @@ def createPlayer(pid, pdata, attributes):
                 self.winner = player.team
             elif pdata.result == 2:
                 player.team.result = "Loss"
+            else:
+                pass # We don't need to do anything here?
 
             player.pick_race = attributes.get('Race','Unknown')
             player.play_race = LOCALIZED_RACES.get(pdata.race, pdata.race)
             player.difficulty = attributes.get('Difficulty','Unknown')
             player.is_human = (attributes.get('Player Type','Computer') == 'Human')
             player.uid = pdata.bnet.uid
             player.subregion = pdata.bnet.subregion
+            player.gateway = {0:'', 1:'us',2:'eu',3:'kr',6:'sea', 98:'xx'}[pdata.bnet.unknown1] # actually is gateway!!!
             player.handicap = pdata.handicap
-
-            # We need initData for the gateway portion of the url!
-            if self.gateway:
-                player.gateway = self.gateway
-                if player.is_human and player.subregion:
-                    player.region = REGIONS[self.gateway].get(player.subregion, 'Unknown')
-
-            # Conversion instructions to the new color object:
-            #   color_rgba is the color object itself
-            #   color_hex is color.hex
-            #   color is str(color)
             player.color = utils.Color(**pdata.color._asdict())
+            return player
 
-            # Each player can be referenced in a number of different ways,
-            # primarily for convenience of access in any given situation.
-            self.people.append(player)
+
+        pid = 0
+        clients = self.raw_data['replay.initData'].player_names
+        for index, pdata in enumerate(self.raw_data['replay.details'].players):
+            pid += 1
+            attributes = self.attributes.get(pid, dict())
+            player = createPlayer(pid, pdata, attributes)
+            self.player[pid] = player
             self.players.append(player)
             self.player[pid] = player
+            self.people.append(player)
             self.person[pid] = player
 
-        def createObserver(pid, name, attributes):
-            observer = Observer(pid,name)
-            self.observers.append(observer)
-            self.people.append(observer)
-            self.person[pid] = observer
-
-        observer_data = list()
-        unassigned_player_data = collections.OrderedDict((p.name, (idx,p)) for idx, p in enumerate(self.raw_data['replay.details'].players))
-        try:
-            for pid, name in enumerate(self.raw_data['replay.initData'].player_names):
-                if name in unassigned_player_data:
-                    idx, pdata = unassigned_player_data[name]
-                    attributes = self.attributes.get(idx,dict())
-                    createPlayer(pid, pdata, attributes)
-                    del unassigned_player_data[name]
-                else:
-                    observer_data.append((pid,name))
-
-            comp_start_id = len(self.raw_data['replay.initData'].player_names)
-            for name, (idx,pdata) in unassigned_player_data.items():
-                attributes = self.attributes.get(idx,dict())
-                createPlayer(comp_start_id, pdata, attributes)
-                comp_start_id+=1
-
-            obs_start_idx = len(self.raw_data['replay.details'].players)
-            for pid, name in observer_data:
-                attributes = self.attributes.get(obs_start_idx,dict())
-                createObserver(pid, name, attributes)
-                obs_start_idx+=1
-        except:
-            print unassigned_player_data
-            print self.raw_data['replay.initData'].player_names
-            raise
+        for cid, name in enumerate(clients):
+            if name not in self.player._key_map:
+                pid += 1
+                attributes = self.attributes.get(pid, dict())
+                client = createObserver(pid, name, attributes)
+                self.observers.append(client)
+                self.people.append(client)
+                self.person[pid] = client
+            else:
+                client = self.player.name(name)
 
+            client.cid = cid
+            self.clients.append(client)
+            self.client[cid] = client
 
-        self.humans = filter(lambda p: p.is_human, self.people)
+        # replay.clients replaces replay.humans
+        self.humans = self.clients
 
         #Create an store an ordered lineup string
         for team in self.teams:
@@ -573,8 +548,7 @@ def register_default_readers(self):
         self.register_reader('replay.game.events', readers.GameEventsReader_19595(), lambda r: 19595 <= r.build < 22612)
         self.register_reader('replay.game.events', readers.GameEventsReader_22612(), lambda r: 22612 <= r.build and r.expansion=='WoL')
         self.register_reader('replay.game.events', readers.GameEventsReader_Beta(), lambda r: r.expansion=='HotS' and r.build < 23925)
-        self.register_reader('replay.game.events', readers.GameEventsReader_Beta_23925(), lambda r: r.expansion=='HotS' and 23925 <= r.build < 24247)
-        self.register_reader('replay.game.events', readers.GameEventsReader_Beta_24247(), lambda r: r.expansion=='HotS' and 24247 <= r.build )
+        self.register_reader('replay.game.events', readers.GameEventsReader_Beta_23925(), lambda r: r.expansion=='HotS' and 23925 <= r.build)
 
 
     def register_default_datapacks(self):