All event.apply functions except the AbilityEvent one are working. Its almost safe to say that obslib has been successfully digested

Author: GraylinKim

sc2reader/data.py

@@ -154,7 +154,7 @@ def visit(self, timestamp, player, object_type=None):
             # TODO siege tanks should not auto-assign
             self.morph_to(object_type, timestamp)
 
-        if not player.is_observer and not self.player:
+        if not player.is_obs and not self.player:
             self.player = player
 
     def morph_to(self, cls, timestamp):

sc2reader/objects.py

@@ -1,7 +1,10 @@
 from constants import races
 from collections import defaultdict
-from sc2reader.utils import PersonDict
+
 from sc2reader.constants import *
+from sc2reader.data import GameObject, ABILITIES
+from sc2reader.utils import PersonDict,Selection
+
 
 class Replay(object):
 
@@ -38,7 +41,7 @@ def __init__(self, filename, release, frames=0):
         self.messages = list()
         self.recorder = None # Player object
         self.winner_known = False
-
+        
         # Set in parsers.DetailParser.load, should we hide this?
         self.file_time = None # Probably number milliseconds since EPOCH
 
@@ -49,6 +52,9 @@ def __init__(self, filename, release, frames=0):
         self.date = None # Date when the game was played in local time
         self.utc_date = None # Date when the game was played in UTC
 
+        #from obslib
+        self.objects = {}
+        
 class Attribute(object):
 
     def __init__(self, data):
@@ -133,28 +139,63 @@ def __repr__(self):
 
 # Actor is a base class for Observer and Player
 class Person(object):
-    def __init__(self, pid, name):
+    def __init__(self, pid, name, replay):
         self.pid = pid
         self.name = name
         self.is_obs = None
         self.messages = list()
         self.events = list()
         self.recorder = False # Actual recorder will be determined using the replay.message.events file
 
+        #From obslib
+        self.selections = {}
+        self.hotkeys = {}
+        self.replay = replay
+        
+    def get_selection(self, number=10):
+        """ Get selection buffer by number """
+        if number < 10:
+            return self.get_hotkey(number)
+        else:
+            selection = self.selections.get(number, Selection())
+            self.selections[number] = selection
+            return selection
+
+    def get_hotkey(self, number):
+        """ Get hotkey buffer by number (does not load it) """
+        hotkey = self.hotkeys.get(number, Selection())
+        self.hotkeys[number] = hotkey
+        return hotkey
+
+    def load_hotkey(self, number, timestamp):
+        """ Push hotkey to current selection (10) """
+        hotkey = self.hotkeys.get(number, Selection())
+        self.hotkeys[number] = hotkey
+        selection = self.get_selection(10) # get user bank
+        selection.deselect_all(timestamp)
+        selection.select(hotkey.current(), timestamp)
+
+    def army_composition_at(self, frame):
+        return [object for object in self.game.objects.values() if object.alive_at(frame) and object.player == self and issubclass(object.object_types[frame], Army)]
+
+    def production_structures_at(self, frame):
+        return [object for object in self.game.objects.values() if object.alive_at(frame) and object.player == self and issubclass(object.object_types[frame], Production)]
+  
+  
 class Observer(Person):
-    def __init__(self, pid, name):
-        super(Observer,self).__init__(pid,name)
+    def __init__(self, pid, name, replay):
+        super(Observer,self).__init__(pid, name, replay)
         self.is_obs = True
 
 class Player(Person):
 
     url_template = "http://%s.battle.net/sc2/en/profile/%s/%s/%s/"
 
-    def __init__(self, pid, data, realm="us"):
+    def __init__(self, pid, data, replay):
         # TODO: get a map of realm,subregion => region in here
-        super(Player,self).__init__(pid,data[0])
+        super(Player,self).__init__(pid, data[0], replay)
         self.is_obs = False
-        self.realm = realm
+        self.realm = replay.realm
         self.uid = data[1][4]
         self.subregion = data[1][2]
         self.url = self.url_template % (self.realm, self.uid, self.subregion, self.name)
@@ -176,10 +217,10 @@ def __init__(self, pid, data, realm="us"):
 
         self.choosen_race = "" # Populated from the replay.attribute.events file
         self.color_rgba = dict([
-                ['r', data[3][1]], 
-                ['g', data[3][2]], 
-                ['b', data[3][3]], 
-                ['a', data[3][0]], 
+                ['r', data[3][1]],
+                ['g', data[3][2]],
+                ['b', data[3][3]],
+                ['a', data[3][0]],
             ])
 
         self.result = None
@@ -191,7 +232,7 @@ def __init__(self, pid, data, realm="us"):
         self.avg_apm = 0
         self.aps = dict() # Doesn't contain seconds with zero actions
         self.apm = dict() # Doesn't contain minutes with zero actions
-        
+
     def __str__(self):
         return "Player %s - %s (%s)" % (self.pid, self.name, self.actual_race)
 
@@ -211,7 +252,7 @@ def __init__(self, timestamp, player_id, event_type, event_code):
         self.type = event_type
         self.code = event_code
         self.is_local = (player_id != 16)
-        self.player = player_id
+        self.pid = player_id
         self.bytes = bytes
         self.abilitystr = ""
 
@@ -258,15 +299,17 @@ def __init__(self, timestamp, player, type, code, ability):
         self.ability = ability
 
     def apply(self):
+        
         if self.ability:
             if self.ability not in ABILITIES:
-                raise ValueError("Unknown ability (%s)" % (hex(self.ability)),)
+                print "Unknown ability (%s) in at %s" % (hex(self.ability),self.timestr)
+                #raise ValueError("Unknown ability (%s)" % (hex(self.ability)),)
             self.ability = ABILITIES[self.ability]
             able = self.get_able_selection()
             if able:
                 object = able[0]
                 ability = getattr(object, self.ability)
-                ability(self.timestamp)
+                ability(self.time)
 
         # claim units
         for obj in self.player.get_selection().current:
@@ -294,14 +337,14 @@ def apply(self):
             create_obj = not GameObject.has_type(obj_type & 0xfffffc | 0x2)
 
             obj = None
-            if obj_id in self.player.game.objects:
-                obj = self.player.game.objects[obj_id]
+            if obj_id in self.player.replay.objects:
+                obj = self.player.replay.objects[obj_id]
             elif create_obj:
-                obj = type_class(obj_id, self.timestamp)
-                self.player.game.objects[obj_id] = obj
+                obj = type_class(obj_id, self.time)
+                self.player.replay.objects[obj_id] = obj
 
             if obj:
-                obj.visit(self.timestamp, self.player, type_class)
+                obj.visit(self.time, self.player, type_class)
             self.target = obj
 
         super(TargetAbilityEvent, self).apply()
@@ -324,11 +367,11 @@ class SetToHotkeyEvent(HotkeyEvent):
     def apply(self):
         hotkey = self.player.get_hotkey(self.hotkey)
         selection = self.player.get_selection()
-        hotkey[self.timestamp] = selection.current
+        hotkey[self.time] = selection.current
 
         # They are alive!
-        for obj in selection[self.timestamp]:
-            obj.visit(self.timestamp, self.player)
+        for obj in selection[self.time]:
+            obj.visit(self.time, self.player)
 
 class AddToHotkeyEvent(HotkeyEvent):
     name = 'AddToHotkeyEvent'
@@ -340,13 +383,13 @@ def apply(self):
         if self.overlay:
             hotkeyed = self.overlay(hotkeyed)
 
-        hotkeyed.extend(self.player.get_selection()[self.timestamp])
+        hotkeyed.extend(self.player.get_selection()[self.time])
         hotkeyed = list(set(hotkeyed)) # remove dups
-        hotkey[self.timestamp] = hotkeyed
+        hotkey[self.time] = hotkeyed
 
         # They are alive!
         for obj in hotkeyed:
-            obj.visit(self.timestamp, self.player)
+            obj.visit(self.time, self.player)
 
 class GetHotkeyEvent(HotkeyEvent):
     name = 'GetHotkeyEvent'
@@ -358,11 +401,11 @@ def apply(self):
             hotkeyed = self.overlay(hotkeyed)
 
         selection = self.player.get_selection()
-        selection[self.timestamp] = hotkeyed
+        selection[self.time] = hotkeyed
 
         # selection is alive!
         for obj in hotkeyed:
-            obj.visit(self.timestamp, self.player)
+            obj.visit(self.time, self.player)
 
 class SelectionEvent(Event):
     name = 'SelectionEvent'
@@ -378,20 +421,20 @@ def apply(self):
 
         selected = selection.current[:]
         for obj in selected: # visit all old units
-            obj.visit(self.timestamp, self.player)
+            obj.visit(self.time, self.player)
 
         if self.deselect:
             selected = self.deselect(selected)
 
         # Add new selection
         for (obj_id, obj_type) in self.objects:
             type_class = GameObject.get_type(obj_type)
-            if obj_id not in self.player.game.objects:
-                obj = type_class(obj_id, self.timestamp)
-                self.player.game.objects[obj_id] = obj
+            if obj_id not in self.player.replay.objects:
+                obj = type_class(obj_id, self.time)
+                self.player.replay.objects[obj_id] = obj
             else:
-                obj = self.player.game.objects[obj_id]
-            obj.visit(self.timestamp, self.player, type_class)
+                obj = self.player.replay.objects[obj_id]
+            obj.visit(self.time, self.player, type_class)
             selected.append(obj)
 
-        selection[self.timestamp] = selected
+        selection[self.time] = selected

sc2reader/processors.py

@@ -27,14 +27,13 @@ class Processor(object):
 #####################################################
 
 class PeopleProcessor(Processor):
-
     def process(self, replay):
         obs_players = list(replay.player_names)
         for player in replay.players:
             obs_players.remove(player.name)
 
         for pid,name in enumerate(obs_players):
-            replay.observers.append(Observer(pid+len(replay.players)+1,name))
+            replay.observers.append(Observer(pid+len(replay.players)+1,name,replay))
 
         for person in replay.observers+replay.players:
             replay.people.append(person)
@@ -116,12 +115,14 @@ class EventProcessor(Processor):
     def process(self, replay):
         replay.events_by_type = defaultdict(list)
         for event in replay.events:
-            #event.apply()
-            replay.events_by_type[event.name].append(event)    
             if event.is_local:
-                person = replay.person[event.player]
+                person = replay.person[event.pid]
+                event.player = person
                 person.events.append(event)
 
+            event.apply()
+            replay.events_by_type[event.name].append(event)    
+
         return replay
 
 #####################################################
@@ -130,7 +131,7 @@ class ApmProcessor(Processor):
     def process(self, replay):
         for event in replay.events:
             if event.is_local and event.is_player_action:
-                person = replay.person[event.player]
+                person = event.player
                 if not person.is_obs:
                     # Calculate APS, APM and average
                     if event.seconds in person.aps:
@@ -157,15 +158,21 @@ def process(self, replay):
 class ResultsProcessor(Processor):
     def process(self, replay):
         #Remove players from the teams as they drop out of the game   
+        print replay.teams
+        print replay.players
         replay.results = dict([team, len(players)] for team, players in replay.teams.iteritems())
 
+        print replay.results
+        
         for event in replay.events_by_type['PlayerLeave']:
             #Some observer actions seem to be recorded, they aren't on teams anyway
             #Their pid will always be higher than the players
-            if event.player <= len(replay.players):
-                team = replay.person[event.player].team
+            print "Player %s has left" % event.pid
+            if event.pid <= len(replay.players):
+                team = replay.person[event.pid].team
                 replay.results[team] -= 1 
 
+        print replay.results
         #mark all teams with no players left as losing, save the rest of the teams
         remaining = set()
         for team, count in replay.results.iteritems():

sc2reader/readers.py

@@ -98,7 +98,7 @@ def read(self, filecontents, replay):
         data =  ReplayBuffer(filecontents).read_data_struct()
 
         for pid, pdata in enumerate(data[0]):
-            replay.players.append(Player(pid+1, pdata, replay.realm)) #pid's start @ 1
+            replay.players.append(Player(pid+1, pdata, replay)) #pid's start @ 1
 
         replay.map = data[1]
         replay.file_time = data[5]