seems to work OK

Author: dsjoerg

sc2reader/engine/__init__.py

@@ -13,6 +13,7 @@
 def setGameEngine(engine):
     module = sys.modules[__name__]
     module.run = engine.run
+    module.plugins = engine.plugins
     module.register_plugin = engine.register_plugin
     module.register_plugins = engine.register_plugins
 

sc2reader/engine/engine.py

@@ -94,6 +94,9 @@ def register_plugins(self, *plugins):
         for plugin in plugins:
             self.register_plugin(plugin)
 
+    def plugins(self):
+      return self._plugins
+
     def run(self, replay):
         # A map of [event.name] => event handlers in plugin registration order
         # ranked from most generic to most specific

sc2reader/engine/plugins/creeptracker.py

@@ -1,12 +1,12 @@
 # -*- coding: utf-8 -*-
 from __future__ import absolute_import, print_function, unicode_literals, division
 
-from itertools import dropwhile
 from sets import Set
 from Image import open as PIL_open
 from Image import ANTIALIAS 
 from StringIO import StringIO
 from collections import defaultdict
+from itertools import tee
 
 # The creep tracker plugin
 class CreepTracker(object):
@@ -16,40 +16,62 @@ class CreepTracker(object):
     This uses the creep_tracker class to calculate the features
     '''
     def handleInitGame(self, event, replay):
+      try:
         if len( replay.tracker_events) ==0 :
             return
         if replay.map is None:
             replay.load_map()
         self.creepTracker  = creep_tracker(replay)
         for player in replay.players:
+          if player.play_race[0] == 'Z':
             self.creepTracker.init_cgu_lists(player.pid)
+      except Exception as e:
+        print("Whoa! {}".format(e))
+        pass
 
     def handleUnitDiedEvent(self, event, replay):
+      try:
         self.creepTracker.remove_from_list(event.unit_id,event.second)
+      except Exception as e:
+        print("Whoa! {}".format(e))
+        pass
+        
 
     def handleUnitInitEvent(self,event,replay):
+      try:
         if event.unit_type_name in ["CreepTumor", "Hatchery","NydusCanal"] :
             self.creepTracker.add_to_list(event.control_pid,event.unit_id,\
                             (event.x, event.y), event.unit_type_name,event.second)
+      except Exception as e:
+        print("Whoa! {}".format(e))
+        pass
 
     def handleUnitBornEvent(self,event,replay):
+      try:
          if event.unit_type_name== "Hatchery":
              self.creepTracker.add_to_list(event.control_pid, event.unit_id,\
                                 (event.x,event.y),event.unit_type_name,event.second)
+      except Exception as e:
+        print("Whoa! {}".format(e))
+        pass
 
     def handleEndGame(self, event, replay):
+      try:
         if len( replay.tracker_events) ==0 :
             return
-        for player_id in replay.player:
-            self.creepTracker.reduce_cgu_per_minute(player_id)
         for player in replay.players:
+          if player.play_race[0] == 'Z':
+            self.creepTracker.reduce_cgu_per_minute(player.pid)
             player.creep_spread_by_minute = self.creepTracker.get_creep_spread_area(player.pid)
-        for player in replay.players:
             if player.creep_spread_by_minute:
                 player.max_creep_spread  = max(player.creep_spread_by_minute.items(),key=lambda x:x[1])
             else:
                 ## Else statement is for players with no creep spread(ie: not Zerg)
                 player.max_creep_spread  =0
+      except Exception as e:
+        print("Whoa! {}".format(e))
+        pass
+
 
 ## The class used to used to calculate the creep spread 
 class creep_tracker():
@@ -76,7 +98,6 @@ def __init__(self,replay):
         for x in self.unit_name_to_radius:
             self.radius_to_coordinates[self.unit_name_to_radius[x]] =\
                   self.radius_to_map_positions(self.unit_name_to_radius[x])
-        
         #Get map information
         replayMap = replay.map
         # extract image from replay package
@@ -95,7 +116,7 @@ def __init__(self,replay):
         self.minimap_image = cropped.resize(minimapSize, ANTIALIAS)
         mapOffsetX= replayMap.map_info.camera_left
         mapOffsetY = replayMap.map_info.camera_bottom
-        mapCenter = [mapOffsetX + cropsize[0]/2.0, mapOffsetY + cropsize[1]/2.0]
+        mapCenter = [mapOffsetX+ cropsize[0]/2.0, mapOffsetY + cropsize[1]/2.0]
         # this is the center of the minimap image, in pixel coordinates
         imageCenter = [(self.map_width/2), self.map_height/2]
         # this is the scaling factor to go from the SC2 coordinate
@@ -148,40 +169,42 @@ def remove_from_list(self,unit_id,time_frame):
             length_cgu_list = len(self.creep_gen_units[player_id])
             if length_cgu_list ==0:
                     break
-            cgu_per_player = self.creep_gen_units[player_id]\
-                                                   [length_cgu_list-1]
-            creep_generating_died = dropwhile(lambda x: x[0] != \
-                                                  unit_id, cgu_per_player)
+            cgu_per_player = self.creep_gen_units[player_id] [length_cgu_list-1]
+            creep_generating_died =filter(lambda x:x[0]==unit_id,cgu_per_player)
             for creep_generating_died_unit in creep_generating_died:
-                cgu_per_player.remove(creep_generating_died_unit)
-                self.creep_gen_units[player_id].append(cgu_per_player)
+                new_cgu_per_player = filter(lambda x:x != creep_generating_died_unit, cgu_per_player )
+                self.creep_gen_units[player_id].append(new_cgu_per_player)
                 self.creep_gen_units_times[player_id].append(time_frame)
 
+    def cgu_gen_times_to_chunks(self,cgu_time_list):
+        ## this function returns the index and value of every cgu time 
+        maximum_cgu_time = max(cgu_time_list)
+        for i in range(0, maximum_cgu_time):
+            a = filter(lambda (x,y): int(y/60)==i, enumerate(cgu_time_list))
+            if len(a)>0:
+                yield a
+
+    def cgu_in_min_to_cgu_units(self,player_id,cgu_in_minutes):
+    ## this function takes index and value of CGU times and returns
+    ## the cgu units with the maximum length
+        for cgu_per_minute in cgu_in_minutes:
+            indexes = map(lambda x:x[0], cgu_per_minute)
+            cgu_units = list()
+            for index in indexes:
+                cgu_units.append(self.creep_gen_units[player_id][index])
+            cgu_max_in_minute = max(cgu_units,key = len)
+            yield cgu_max_in_minute
+    
     def reduce_cgu_per_minute(self,player_id):
     #the creep_gen_units_lists contains every single time frame
     #where a CGU is added,
     #To reduce the calculations required, the time frame containing
     #the most cgus every minute will be used to represent that minute
-        last_minute_found = 0
-        cgu_per_player_new = list()
-        cgu_time_per_player_new = list()
-        cgu_last_minute_list = list()
-        for index,cgu_time in enumerate(self.creep_gen_units_times[player_id]):
-            cgu_last_minute_list.append(self.creep_gen_units[player_id][index])
-            if (cgu_time/60) ==0:
-                cgu_per_player_new.append(self.creep_gen_units[player_id][0])
-                cgu_time_per_player_new.append(0)
-                cgu_last_minute_list = list()
-            if (cgu_time/60)>last_minute_found:
-                cgu_max_in_min = max(cgu_last_minute_list,key = len)
-                cgu_per_player_new.append(cgu_max_in_min)
-                cgu_max_in_min_index = self.creep_gen_units[player_id].index(cgu_max_in_min)
-                cgu_time_per_player_new.append(self.creep_gen_units_times[player_id][cgu_max_in_min_index])
-                last_minute_found = cgu_time/60
-                cgu_last_minute_list=list()
-                
-        self.creep_gen_units[player_id] = cgu_per_player_new
-        self.creep_gen_units_times[player_id] = cgu_time_per_player_new
+       cgu_per_minute1, cgu_per_minute2 =  tee (self.cgu_gen_times_to_chunks(self.creep_gen_units_times[player_id]))
+       cgu_unit_max_per_minute = self.cgu_in_min_to_cgu_units(player_id,cgu_per_minute1)
+       minutes = map(lambda x:int(x[0][1]/60)*60, cgu_per_minute2)
+       self.creep_gen_units[player_id] = list(cgu_unit_max_per_minute)
+       self.creep_gen_units_times[player_id] = list(minutes)
 
     def get_creep_spread_area(self,player_id):
         ## iterates through all cgus and and calculate the area 
@@ -192,12 +215,14 @@ def get_creep_spread_area(self,player_id):
             # convert event coords to minimap coords
             cgu_radius = self.convert_cgu_radius_event_to_map_coord(cgu_radius)
             creep_area_positions = self.cgu_radius_to_map_positions(cgu_radius,self.radius_to_coordinates)
-            cgu_last_event_time = self.creep_gen_units_times[player_id][index]/60
+            cgu_event_time = self.creep_gen_units_times[player_id][index]
+            cgu_event_time_str=str(int(cgu_event_time/60))+":"+str(cgu_event_time%60)
             if self.debug: 
-                self.print_image(creep_area_positions,player_id,cgu_last_event_time)
+                self.print_image(creep_area_positions,player_id,cgu_event_time_str)
             creep_area = len(creep_area_positions)
-            self.creep_spread_by_minute[player_id][cgu_last_event_time]=\
+            self.creep_spread_by_minute[player_id][cgu_event_time]=\
                                                     float(creep_area)/self.mapSize*100
+
         return self.creep_spread_by_minute[player_id]
 
     def cgu_radius_to_map_positions(self,cgu_radius,radius_to_coordinates):
@@ -229,7 +254,7 @@ def print_image(self,total_points_on_map,player_id,time_stamp):
         creeped_image.save(creeped_imageIO, "png")
         self.creep_spread_image_by_minute[player_id][time_stamp]=creeped_imageIO
         ##debug for print out the images
-        f = open(str(player_id)+'image'+str(time_stamp)+'.png','w')
+        f = open(str(player_id)+'image'+time_stamp+'.png','w')
         f.write(creeped_imageIO.getvalue())
         creeped_imageIO.close()
         f.close()
@@ -256,6 +281,3 @@ def convert_event_coord_to_map_coord(self,x,y):
         imageX = int(self.map_height - self.transX + self.image_scale * x)
         imageY = int(self.transY - self.image_scale * y)
         return imageX, imageY
-
-
-