Merge branch 'master' into pathfinding

34 files changed, 3404 insertions, 99 deletions

diff --git a/README b/README
index 57da257..fa3410e 100644
--- a/README
+++ b/README
@@ -3,9 +3,13 @@ prerequisites: python3, pygame and websocket-client
 git submodule update --init
 python3 main.py
 
-move mouse  = move
-left click, space  = split
-right click, w = eject some mass
+space  = split
+w = eject some mass
 r = respawn
-s = lock input. cycles through: user lock -> user and bot lock -> bot lock -> no lock
+s = lock input. toggle between "user controls" and "bot controls". hold shift for "nobody controls"
+move mouse  = move
+mouse left/mid/right click: set markers (currently unused)
 esc = quit
+
+the stats.py module automatically creates/overwrites the stats.pickle file (roughly 1MB per 5 minutes currently)
+which can be loaded using Stats.load() and analyzed using the Stats.analyze_* functions, or using analyze.py
diff --git a/analyze.py b/analyze.py
new file mode 100644
index 0000000..c9c3ac8
--- /dev/null
+++ b/analyze.py
@@ -0,0 +1,24 @@
+from stats import *
+import sys
+
+if len(sys.argv) >= 2:
+    files = sys.argv[1:]
+else:
+    files = ["stats.pickle"]
+
+
+s = Stats.load(files[0])
+for f in files[1:]:
+    s.merge(f)
+
+s.analyze_speed()
+print("\n" + "-"*40 + "\n")
+s.analyze_visible_window(False)
+for i in ["split cell", "ejected mass", "virus", "virus2", "virus3"]:
+    s.analyze_deviations(i)
+print("")
+for i in ["split cell", "ejected mass", "virus"]:
+    s.analyze_distances(i)
+
+s.analyze_virus_sizes()
+s.analyze_remerge()
diff --git a/geometry.py b/geometry.py
new file mode 100644
index 0000000..d69add8
--- /dev/null
+++ b/geometry.py
@@ -0,0 +1,27 @@
+import math
+def distance_point_line(p, l1, l2):
+    # (x - l1.x) * (l2.y-l1.y)/(l2.x-l1.x)   +  l1.y   =  y
+    # x * (l2.y-l1.y)/(l2.x-l1.x) - l1.x * (l2.y-l1.y)/(l2.x-l1.x) + l1.y - y = 0
+    # x * (l2.y-l1.y) - l1.x * (l2.y-l1.y) + l1.y * (l2.x-l1.x) - y * (l2.x-l1.x) = 0
+    # ax + by + c = 0
+    # with a = (l2.y-l1.y), b = -(l2.x-l1.x), c = l1.y * (l2.x-l1.x) - l1.x * (l2.y-l1.y)
+    a = (l2.y-l1.y)
+    b = -(l2.x-l1.x)
+    c = l1.y * (l2.x-l1.x) - l1.x * (l2.y-l1.y)
+
+    d = math.sqrt(a**2 + b**2)
+    a/=d
+    b/=d
+    c/=d
+
+    assert (abs(a*l1.x + b*l1.y + c) < 0.001)
+    assert (abs(a*l2.x + b*l2.y + c) < 0.001)
+
+    return abs(a*p.x + b*p.y + c)
+
+def is_colinear(points, epsilon=1):
+    for point in points:
+        if distance_point_line(point, points[0], points[-1]) > epsilon:
+            return False
+    return True
+
diff --git a/gui.py b/gui.py
index 68aa48e..2a8460c 100644
--- a/gui.py
+++ b/gui.py
@@ -6,6 +6,10 @@ from pygame.locals import *
 import sys
 import math
 import time
+import mechanics
+from agarnet.agarnet.vec import Vec
+
+running = True
 
 font_fallback = False
 try:
@@ -28,13 +32,47 @@ marker_updated = [True, True, True]
 
 screensize=(1280, 800)
 screen=pygame.display.set_mode(screensize,HWSURFACE|DOUBLEBUF|RESIZABLE)
+
+vignette = 1.
+
+def enable_vignette(factor=0.15):
+    global vignette
+    if factor:
+        vignette = 1+factor
+    else:
+        vignette = 1
+
+def draw_bar(rect, val, thresh=None, min=0, max=1, color=(0,0,0), barcolor=None, exceedcolor=(255,0,0), threshcolor=None):
+    v = (val-min)/(max-min)
+    t = (thresh-min)/(max-min)
+    
+    if barcolor == None:
+        barcolor_=color
+    else:
+        barcolor_=barcolor
+    if thresh != None and threshcolor==None:
+        threshcolor_ = ((128+color[0])//2, (128+color[1])//2, (128+color[2])//2)
+    else:
+        threshcolor_ = threshcolor
+
+    for i in range(0, 1 if v<t else 3):
+        draw_box(  ((rect[0][0]-i,rect[0][1]-i),(rect[1][0]+2*i, rect[1][1]+2*i)) , color if v<t or exceedcolor==None else exceedcolor, False, False)
+    
+    draw_box(((rect[0][0]+2,rect[0][1]+2), ((rect[1][0]-4)*v, rect[1][1]-4)), barcolor_, True, False)
     
+    if thresh != None:
+        if exceedcolor != None and v >= t:
+            draw_box(((rect[0][0]+2  +  (rect[1][0]-4)*t   ,    rect[0][1]+2)            ,        ((rect[1][0]-4)*(v-t)  ,   rect[1][1]-4)), exceedcolor, True, False)
+        
+        draw_line((rect[0][0]+2+(rect[1][0]-4)*t, rect[0][1]+1), (rect[0][0]+2+(rect[1][0]-4)*t, rect[0][1]+rect[1][1]-1), threshcolor_, False)
+
+
 def draw_line(p1, p2, color, global_coords=True):
     if global_coords:
         p1 = world_to_win_pt(p1, c.player.center)
         p2 = world_to_win_pt(p2, c.player.center)
 
-    gfxdraw.line(screen, p1[0], p1[1], p2[0], p2[1], color)
+    gfxdraw.line(screen, int(p1[0]), int(p1[1]), int(p2[0]), int(p2[1]), color)
 
 def draw_box(rect, color, filled=False, global_coords=True):
     if global_coords:
@@ -60,6 +98,11 @@ def draw_circle(pos, r, color, filled=False, global_coords=True):
         gfxdraw.circle(screen, pos[0], pos[1], r, color)
     gfxdraw.aacircle(screen, pos[0], pos[1], r, color)
 
+def hilight_cell(cell, color_inner, color_outer, r=20):
+    draw_circle(cell.pos, cell.size+r, color_outer, True)
+    draw_circle(cell.pos, cell.size+r/2, color_inner, True)
+    draw_cell(cell)
+
 def draw_polygon(polygon, color, filled=False, global_coords=True):
     if len(polygon) > 2:
         if global_coords:
@@ -103,12 +146,31 @@ def draw_text(pos, text, color, font_size=16, global_coords=True, draw_centered=
 def update():
     pygame.display.update()
 
-def calc_zoom():
-    zoom1 = screensize[0] / 2051.
-    zoom2 = screensize[1] / 1216.
-    return max(zoom1,zoom2)
+def update_zoom():
+    global zoom
+    global calculated_visible_width, calculated_visible_height
+
+    ratio = 1.7 # reverse engineered value.
+
+    size = sum(map(lambda cell : cell.size, c.player.own_cells))
+
+    # reverse engineered formula
+    diag_server = mechanics.viewport_diag(size) if size > 0 else 10000
+
+    # calculate screen diag, if we would have a screen with our width, but correct ratio
+    diag1 = math.sqrt(screensize[0]**2 * (1 + 1/1.7**2))
+    # calculate screen diag, if we would have a screen with our height, but correct ratio
+    diag2 = math.sqrt(screensize[1]**2 * (1 + 1.7**2))
+
+    # what we expect to be visible from server
+    calculated_visible_width  = diag_server / math.sqrt(1+1/ratio**2)
+    calculated_visible_height = diag_server / math.sqrt(1+  ratio**2)
+
+    zoom1 = screensize[0] / calculated_visible_width
+    zoom2 = screensize[1] / calculated_visible_height
+    
+    zoom = min(zoom1,zoom2) / vignette
 
-zoom = calc_zoom()
     
 def world_to_win_length(l):
     return int(l*zoom)
@@ -141,7 +203,21 @@ def generate_virus(spikes, spike_length, radius, global_coords):
     return points
 
 def draw_cell(cell):
+    font_size = 16
+    virus_sizes = {100:1, 106:2, 113:3, 119:4, 125:5, 131:6, 136:7}
+
     cx,cy = world_to_win_pt(cell.pos,c.player.center)
+    try:
+        mov_ang = cell.movement_angle
+        p2 = cell.pos + Vec( math.cos(mov_ang + mechanics.eject_delta*math.pi/180), math.sin(mov_ang + mechanics.eject_delta*math.pi/180) ) * (cell.size+700)
+        p3 = cell.pos + Vec( math.cos(mov_ang - mechanics.eject_delta*math.pi/180), math.sin(mov_ang - mechanics.eject_delta*math.pi/180) ) * (cell.size+700)
+
+        cx2,cy2 = world_to_win_pt(p2,c.player.center)
+        cx3,cy3 = world_to_win_pt(p3,c.player.center)
+    except (AttributeError, TypeError):
+        cx2,cy2=cx,cy
+        cx3,cy3=cx,cy
+
     radius = world_to_win_length(cell.size)
 
     if cell.is_virus:
@@ -156,19 +232,24 @@ def draw_cell(cell):
             
             gfxdraw.filled_polygon(screen, polygon2, color)
             gfxdraw.aapolygon(screen, polygon2, color)
+            
+            draw_text((cx, cy), "%s / 7" % virus_sizes.get(cell.size, "?"), (64,0,0), font_size*2, False, True)
+            draw_text((cx, cy + radius + 10), str(cell.cid), (0,0,0), font_size, False, True)
     else:
         color=(int(cell.color[0]*255), int(cell.color[1]*255), int(cell.color[2]*255))
+
         
         if not (cell.is_ejected_mass or cell.is_food):
+            gfxdraw.aapolygon(screen, [(cx,cy),(cx2,cy2),(cx3,cy3),(cx,cy)] ,(255,127,127))
+            
             gfxdraw.filled_circle(screen, cx, cy, radius, color)
             gfxdraw.aacircle(screen, cx, cy, radius, (0,0,0))
             
             gfxdraw.aacircle(screen, cx, cy, int(radius/2), (255,255,255))
             gfxdraw.circle(screen, cx, cy, int(radius/2), (255,255,255))
             
-            font_size = 16
-            
             draw_text((cx, cy + radius + 10), cell.name, (0, 0, 0), font_size, False, True)
+            draw_text((cx, cy + radius + 10 + font_size), str(cell.cid), (0,0,0), font_size, False, True)
             # surface = draw_text(cell.name, (0, 0, 0), font_size)
             # screen.blit(surface, (cx - (surface.get_width()/2), cy + radius + 5))
             
@@ -191,6 +272,19 @@ def draw_leaderboard():
         # screen.blit(surface, (5, next_y))
         next_y += surface.get_height()+5
 
+def draw_visible_window_borders():
+    global screen
+    
+    vignette_color=(192,192,192)
+    vignette_width = int(max(0, (screensize[0]-world_to_win_length(calculated_visible_width))/2))
+    vignette_height = int(max(0, (screensize[1]-world_to_win_length(calculated_visible_height))/2))
+
+    screen.fill(vignette_color, rect=((0,0),(vignette_width,screensize[1])))
+    screen.fill(vignette_color, rect=((screensize[0]-vignette_width,0),(vignette_width,screensize[1])))
+    screen.fill(vignette_color, rect=((0,0),(screensize[0],vignette_height)))
+    screen.fill(vignette_color, rect=((0,screensize[1]-vignette_height),(screensize[0],vignette_height)))
+
+
 def draw_world_borders():
     top = int((c.world.top_left[0] - c.player.center[1])*zoom + screensize[1]/2)
     left = int((c.world.top_left[1] - c.player.center[0])*zoom + screensize[0]/2)
@@ -226,13 +320,37 @@ def draw_markers():
     for i in [0, 1, 2]:
         draw_marker(marker[i], colors[i], marker_updated[i])
 
+def draw_debug():
+    for cell in c.world.cells.values():
+        parent = None
+        shoot_vec = None
+        settled = None
+        try:
+            parent = cell.parent
+            shoot_vec = cell.shoot_vec
+            settled = cell.calmed_down
+        except AttributeError:
+            pass
+
+        if parent != None:
+            draw_line(cell.pos, parent.pos,(255,0,0))
+            draw_circle(parent.pos,3,(255,0,0),True)
+
+
+        if shoot_vec != None and settled != True:
+            shoot_vec = 400 * shoot_vec / shoot_vec.len()
+            draw_line(cell.pos, cell.pos+shoot_vec, (0,255,255))
+
+
 def draw_frame():
-    global screen, movement, zoom, screensize, input, bot_input, marker, marker_updated
+    global screen, movement, zoom, screensize, input, bot_input, marker, marker_updated, running
 
     pygame.event.pump()
     clock.tick()
+    update_zoom()
  
     clear_screen()
+    draw_visible_window_borders()
     draw_world_borders() 
     
     food = list(filter(lambda x: x.is_food, c.world.cells.values()))
@@ -267,23 +385,23 @@ def draw_frame():
         if event.type == VIDEORESIZE:
             screensize = event.dict['size']
             screen=pygame.display.set_mode(screensize, HWSURFACE|DOUBLEBUF|RESIZABLE)
-            zoom = calc_zoom()
+            update_zoom()
             pygame.display.update()
         if event.type == QUIT: 
             pygame.display.quit()
         if event.type == KEYDOWN:
             if event.key == K_s:
-                if not input and bot_input:
+                if event.mod & KMOD_SHIFT and (input or bot_input):
                     input = False
                     bot_input = False
-                elif not input and not bot_input:
+                elif not input and bot_input:
                     input = True
                     bot_input = False
                 else:
                     input = False
                     bot_input = True
             if event.key == K_ESCAPE:
-                pygame.quit()
+                running = False
             if event.key == K_r:
                 c.send_respawn()
         if event.type == MOUSEBUTTONDOWN:
@@ -291,11 +409,11 @@ def draw_frame():
                 marker[event.button-1] = win_to_world_pt(event.pos, c.player.center)
                 marker_updated[event.button-1] = True
                 print("set marker "+str(event.button-1)+" to "+str(event.pos))
+        if event.type == KEYDOWN:
+            if event.key == K_w:
+                c.send_shoot()
+            if event.key == K_SPACE:
+                c.send_split()
         if input:
-            if event.type == KEYDOWN:
-                if event.key == K_w:
-                    c.send_shoot()
-                if event.key == K_SPACE:
-                    c.send_split()
             if event.type == MOUSEMOTION:
                     c.send_target(*win_to_world_pt(event.pos, c.player.center))
diff --git a/interval_utils.py b/interval_utils.py
index 0095c06..7123893 100644
--- a/interval_utils.py
+++ b/interval_utils.py
@@ -70,13 +70,37 @@ def intervals_intersect(int1_, int2_):
 
     return False
 
-def check_cell_in_interval(origin, cell, interval):
+def intersection(int1s, int2s):
+    #expects merged, canonicalized intervals, returns overlap-free canonicalized intervals
+
+    result = []
+
+    for int1 in int1s:
+        for int2 in int2s:
+            if (max(int1[0],int2[0]) <= min(int1[1],int2[1])):
+                result += [(max(int1[0],int2[0]), min(int1[1],int2[1]))]
+
+    return result
+
+def interval_area(ints):
+    result = 0
+    for i in merge_intervals(ints):
+        result += i[1]-i[0]
+    return result
+
+def interval_occupied_by_cell(origin, cell):
     ang = get_point_angle(origin, cell.pos)
 
     dist = math.sqrt( (cell.pos[0]-origin[0])**2 + (cell.pos[1]-origin[1])**2 )
-    corridor_halfwidth = math.asin(cell.size / dist)
+    if cell.size >= dist:
+        corridor_halfwidth = math.pi/2
+    else:
+        corridor_halfwidth = math.asin(cell.size / dist)
+
+    return (ang-corridor_halfwidth, ang+corridor_halfwidth)
 
-    return intervals_intersect(interval, (ang-corridor_halfwidth, ang+corridor_halfwidth))
+def check_cell_in_interval(origin, cell, interval):
+    return intervals_intersect(interval, interval_occupied_by_cell(origin,cell))
 
 def get_cells_in_interval(origin, interval, cells):
     return list(filter(lambda x: check_point_in_interval(origin, x.pos, interval), cells))
diff --git a/main.py b/main.py
index a74f5b4..e980fb3 100644
--- a/main.py
+++ b/main.py
@@ -7,16 +7,79 @@ import sys
 import math
 import time
 import random
-import gui
+import nogui as gui # might be overridden later.
 import stats
-from subscriber import DummySubscriber
+from subscriber import EnhancingSubscriber
 from interval_utils import *
 from pathfinding import PathfindingTesterStrategy
+import time
+
+class Clock:
+    def __init__(self):
+        self.t = time.time()
+        self.fps_t = time.time()
+        self.fps = 27
+        self.cnt = 0
+        self.newfps = False
+
+    def tic(self):
+        t = time.time()
+        result = t-self.t
+        self.t=t
+        return result
+
+    def getfps(self):
+        self.cnt+=1
+        if time.time() > self.fps_t + 1:
+            self.fps_t += 1
+            self.fps = self.cnt
+            self.cnt = 0
+            self.newfps = True
+        else:
+            self.newfps = False
+        return self.fps
+
+class ProblemException(BaseException):
+    pass
+
+class ProblemManager:
+    def __init__(self, setup):
+        self.setup = setup
+        self.problems = {}
+        for t in setup:
+            self.problems[t] = []
+
+    def report(self, prob):
+        self.problems[prob] += [time.time()]
+        self.problems[prob] = list(filter(lambda t : time.time() < t + self.setup[prob][1], self.problems[prob]))
+
+        if len(self.problems[prob]) > self.setup[prob][0]:
+            print("PROBLEM: "+prob)
+            if self.setup[prob][2]:
+                raise ProblemException
+
+probs = ProblemManager({"network lag":(100,5,True), "strategy lag":(5,2,False), "gui lag":(5,2,False), "high fps":(5,6,True), "low fps":(5,6,True)})
+
+
+if "--nogui" in sys.argv:
+    sys.argv.remove("--nogui")
+else:
+    try:
+        import gui
+    except:
+        print("ERROR: could not import gui... running without gui.")
+
 
 # global vars
-sub = DummySubscriber()
+sub = EnhancingSubscriber()
 c = client.Client(sub)
-stats = stats.Stats()
+sub.set_client(c)
+stats = stats.Stats(c)
+            
+try:
+    nick = sys.argv[2]
+except:
+    nick = ""
 
 for i in range(1,10): # 10 connection attempts
     print("trying to connect, attempt "+str(i))
@@ -25,8 +88,11 @@ for i in range(1,10): # 10 connection attempts
         try:
             token = sys.argv[1]
             addr, *_ = utils.get_party_address(token)
+            print("using party token")
+
         except:
             addr, token, *_ = utils.find_server()
+            print("joining random game")
 
         # connect
         c.connect(addr,token)
@@ -37,27 +103,64 @@ for i in range(1,10): # 10 connection attempts
         c.disconnect()
 
 
-c.player.nick="test cell pls ignore"
+c.player.nick=nick
 
 
 # initialize GUI
 gui.set_client(c)
 
 # initialize strategy
-strategy = PathfindingTesterStrategy(c)
-
-# main loop
-while True:
-    c.on_message()
-    
-    gui.draw_frame()
-    
-    if len(list(c.player.own_cells)) > 0:
-        target = strategy.process_frame()
-
-        if gui.bot_input and target != None:
-            c.send_target(target[0], target[1])
-
-        stats.log_pos(c.player.center)
-        stats.log_mass(c.player.total_mass)
-    gui.update()
+strategy = PathfindingTesterStrategy(c, gui)
+
+autorespawn_counter = 60
+
+clock = Clock()
+
+try:
+    # main loop
+    while gui.running:
+        c.on_message()
+        if clock.tic() > 1./20:
+            print("NETWORK LAG")
+            probs.report("network lag")
+        
+        gui.draw_frame()
+        if clock.tic() > 1./40:
+            print("GUI SLOW")
+            probs.report("gui lag")
+        
+        if len(list(c.player.own_cells)) > 0:
+            target = strategy.process_frame()
+
+            if gui.bot_input:
+                c.send_target(target[0], target[1])
+
+            stats.process_frame()
+
+        if clock.tic() > 1./25.:
+            print("STRATEGY LAG")
+            probs.report("strategy lag")
+
+        gui.draw_debug()
+        gui.update()
+
+        if not c.player.is_alive:
+            if autorespawn_counter == 0:
+                c.send_respawn()
+                autorespawn_counter = 60
+            else:
+                autorespawn_counter-=1
+
+        fps = clock.getfps()
+        if clock.newfps:
+            print("FPS: %3d" % fps)
+            if fps < 24:
+                probs.report("low fps")
+            if fps > 50:
+                probs.report("high fps")
+except ProblemException:
+    print("Exiting due to a problem such as low/high fps, network lags etc")
+
+stats.save("stats.pickle")
+
+print("bye")
diff --git a/mechanics.py b/mechanics.py
new file mode 100644
index 0000000..3aaa405
--- /dev/null
+++ b/mechanics.py
@@ -0,0 +1,15 @@
+from agarnet.agarnet.world import Cell
+
+def speed(size_or_cell):
+    if isinstance(size_or_cell, Cell):
+        if size_or_cell.is_virus or size_or_cell.is_ejected_mass or size_or_cell.is_food:
+            return 0
+        else:
+            return speed(size_or_cell.size)
+    else:
+        return 86 / (size_or_cell**0.45)
+
+def viewport_diag(sizesum):
+    return 370 * max(sizesum,70)**0.431776
+
+eject_delta = 22 # how many degrees do ejects deviate from the original direction (maximum)
diff --git a/nogui.py b/nogui.py
new file mode 100644
index 0000000..b2989de
--- /dev/null
+++ b/nogui.py
@@ -0,0 +1,41 @@
+running = True
+bot_input = True
+
+def draw_bar(rect, val, thresh=None, min=0, max=1, color=(0,0,0), barcolor=None, exceedcolor=(255,0,0), threshcolor=None):
+    pass
+
+def draw_line(p1, p2, color, global_coords=True):
+    pass
+
+def draw_box(rect, color, filled=False, global_coords=True):
+    pass
+
+def draw_circle(pos, r, color, filled=False, global_coords=True):
+    pass
+
+def hilight_cell(cell, color_inner, color_outer, r=20):
+    pass
+
+def draw_polygon(polygon, color, filled=False, global_coords=True):
+    pass
+
+def draw_path(path, color, global_coords=True):
+    pass
+
+def draw_arc(pos, r, bounds, color, global_coords=True):
+    pass
+
+def draw_text(pos, text, color, font_size=16, global_coords=True, draw_centered=False):
+    pass
+    
+def update():
+    pass
+
+def set_client(cl):
+    pass
+
+def draw_debug():
+    pass
+
+def draw_frame():
+    pass
diff --git a/pathfinding.py b/pathfinding.py
index beec89a..9386275 100644
--- a/pathfinding.py
+++ b/pathfinding.py
@@ -1,5 +1,3 @@
-from gui import marker, marker_updated
-import gui
 import math
 
 
@@ -75,9 +73,10 @@ grid_radius=int(1100/30)*30
 grid_density=30
 
 class PathfindingTesterStrategy:
-    def __init__(self, c):
+    def __init__(self, c, gui):
         self.c = c
         self.path = None
+        self.gui = gui
 
     def build_grid(self):
         grid = [[0 for x in range(int(2*grid_radius//grid_density+1))] for x in range(int(2*grid_radius//grid_density+1))]
@@ -110,8 +109,8 @@ class PathfindingTesterStrategy:
         return grid
 
     def plan_path(self):
-        goalx = int((marker[0][0] - self.c.player.center[0] + grid_radius)/grid_density)
-        goaly = int((marker[0][1] - self.c.player.center[1] + grid_radius)/grid_density)
+        goalx = int((self.gui.marker[0][0] - self.c.player.center[0] + grid_radius)/grid_density)
+        goaly = int((self.gui.marker[0][1] - self.c.player.center[1] + grid_radius)/grid_density)
         
         grid = self.build_grid()
 
@@ -130,8 +129,8 @@ class PathfindingTesterStrategy:
         return True
 
     def process_frame(self):
-        if marker_updated[0]:
-            marker_updated[0]=False
+        if self.gui.marker_updated[0]:
+            self.gui.marker_updated[0]=False
             
             self.path = self.plan_path()
             for node in self.path:
@@ -140,7 +139,7 @@ class PathfindingTesterStrategy:
 
 
         for (node1,node2) in zip(self.path,self.path[1:]):
-            gui.draw_line(node1.point, node2.point, (0,0,0))
+            self.gui.draw_line(node1.point, node2.point, (0,0,0))
 
         if self.path:
             relx, rely = self.path[0].point[0]-self.c.player.center.x, self.path[0].point[1]-self.c.player.center.y
@@ -153,4 +152,4 @@ class PathfindingTesterStrategy:
 
         if self.path:
             return self.path[0].point
-        return marker[0]
+        return self.gui.marker[0]
diff --git a/reversing_game_mechanics/game_mechanics.txt b/reversing_game_mechanics/game_mechanics.txt
new file mode 100644
index 0000000..2488481
--- /dev/null
+++ b/reversing_game_mechanics/game_mechanics.txt
@@ -0,0 +1,54 @@
+Created 2015-09-01, with data between 0 and 2 weeks old.
+
+Units used:
+	distances, sizes are measured in raw agar.io coordinates.
+	times are measured in frames. The game ran at 27-28 FPS at the time
+		where this document was created
+	speeds are measured in distance / number of frames
+
+
+
+cellspeed = 86.05 / cellsize**0.45
+
+zoom level is 369.399 * sum(own_cells.size) ** 0.431776
+
+ejecting mass:
+	prerequisite: size >= 60, i.e. mass >= 35
+	you will lose 16 mass, but only gain 12 mass if you eat the blob
+	one can eat ejected mass if mass >= 18 i.e. size >= 43
+
+	75% of the ejects had a deviation smaller than 0.39 rad = 22.16 deg
+	from the original moving direction of the shooting cell
+
+	they fly 44-45px, starting from shooting cell's border.
+
+splitting:
+	75% of the splits had a deviation smaller than 0.02 rad = 1.19 deg
+	from the original moving direction of the parent
+
+	flight distance: unknown, somewhere between 100 - 650, max = 1205
+
+	re-union will usually become possible somewhere after 745 - 790 frames
+		this means that your cells are possible to glide into each
+		other. depending on your movement pattern they will actually
+		merge sooner or later.
+
+feeding viruses:
+	75% of the splits had a deviation smaller than 0.00 rad = 0.11 deg
+	from the ejected mass movement vector.
+
+	maximum distance is 580 from the midpoint of the parent virus.
+	not sure about the minimum (too few data), but probably also 580?
+
+	Viruses can have the following sizes:
+		100, 106, 113, 119, 125, 131, 136.
+		Sometimes 141 is also observed, but those viruses will split
+		almost instantly (bug in the server software?)
+	i.e., feed a virus with size 100 6 times to maximum size, and one more
+	time to make it duplicate.
+
+eating:
+	a cell can eat us, if their size/mass(??) is at least 1.25* our size/mass
+	a cell eats another, if the smaller one's midpoint is within the
+	larger one's circle (with radius = size)
+
diff --git a/reversing_game_mechanics/splits_and_ejects/README b/reversing_game_mechanics/splits_and_ejects/README
new file mode 100644
index 0000000..14fa5ad
--- /dev/null
+++ b/reversing_game_mechanics/splits_and_ejects/README
@@ -0,0 +1,50 @@
+Data collected with revision 165dd41, four parallel instances, 30-45 minutes each, on
+2015-08-28. Analyzed with analyze.py
+
+split cell eject/split direction deviations: mean = -0.04179961392956227, stddev=0.4556678701725402, ndata=159
+	75% of the splits had a deviation smaller than 0.02 rad = 1.31 deg
+
+ejected mass eject/split direction deviations: mean = -0.0016847086620534303, stddev=0.872858965604425, ndata=352
+	75% of the splits had a deviation smaller than 0.46 rad = 26.47 deg
+
+
+split cell eject/split distances: mean = 388.2279635920042, stddev=222.71465106976927, ndata=314
+	75% of the values lie in the interval 381.25 plusminus 225.53
+
+ejected mass eject/split distances: mean = 442.90229450857305, stddev=189.2221703217239, ndata=252
+	75% of the values lie in the interval 535.71 plusminus 8.61
+
+distances are measured between "spawn point of cell" and "end point of movement".
+Spawnpoint is usually near "parentcell.midpoint + parentcell.size".
+
+
+
+Now if we measure distances between "midpoint of parent cell" and "end point of movement" by
+applying the following patch:
+
+diff --git a/stats.py b/stats.py
+index bb88c3e..1c0a196 100644
+--- a/stats.py
++++ b/stats.py
+@@ -338,7 +338,7 @@ class Stats:
+         #    print(str(n) + "\t" + str(x))
+ 
+     def analyze_distances(self, celltype):
+-        ds = [v[0] for v in self.data.eject_distlogs[celltype]]
++        ds = [v[1] for v in self.data.eject_distlogs[celltype]]
+ 
+         try:
+             mean, stddev = fit_gaussian(ds)
+
+we get this:
+
+split cell eject/split distances: mean = 560.4528176561469, stddev=276.25260008531626, ndata=314
+	75% of the values lie in the interval 556.62 plusminus 322.76
+
+ejected mass eject/split distances: mean = 767.2502438544719, stddev=168.80422060053823, ndata=252
+	75% of the values lie in the interval 732.30 plusminus 86.28
+
+
+As one can see, the "plusminus" values are much larger than above. So measuring between "spawnpoint" and
+"endpoint" is more appropriate.
+
diff --git a/reversing_game_mechanics/stuff.txt b/reversing_game_mechanics/stuff.txt
new file mode 100644
index 0000000..fbbddc4
--- /dev/null
+++ b/reversing_game_mechanics/stuff.txt
@@ -0,0 +1,117 @@
+as of 2015-08-30
+
+CELL SIZE VS SPEED
+
+	size**0.45 * speed = 86.05616001328154
+
+
+
+
+SIZE VS VIEWPORT
+
+	with 1 cells, depending on sum(size)
+	median ratio = 1.7025611175785798
+	diag / size**0.33 = 608.971483054539
+
+	with 2 cells, depending on sum(size)
+	median ratio = 1.6963503649635037
+	diag / size**0.33 = 585.5509541758322
+
+	with 3 cells, depending on sum(size)
+	median ratio = 1.6898326898326899
+	diag / size**0.58 = 170.29929514108093
+
+	with 4 cells, depending on sum(size)
+	median ratio = 1.650784427658338
+	diag / size**0.0 = 3158.567553889486
+
+	with 1 cells, depending on sum(mass)
+	median ratio = 1.7025611175785798
+	diag / size**0.17 = 1270.6199859482824
+
+	with 2 cells, depending on sum(mass)
+	median ratio = 1.6972934472934473
+	diag / size**0.16 = 1407.4522241811242
+
+	with 3 cells, depending on sum(mass)
+	median ratio = 1.6975546975546976
+	diag / size**0.28 = 910.623966202271
+
+	with 4 cells, depending on sum(mass)
+	median ratio = 1.6625734116390818
+	diag / size**0.0 = 3141.1700855829763
+
+
+
+
+EJECT/SPLIT DIRECTIONS
+
+	split cell eject/split direction deviations: mean = 0.0009390500296252917, stddev=0.31212271930689983, ndata=621
+		75% of the splits had a deviation smaller than 0.02 rad = 1.19 deg
+
+	ejected mass eject/split direction deviations: mean = -0.021378484138331356, stddev=0.730695490707546, ndata=1585
+		75% of the splits had a deviation smaller than 0.39 rad = 22.16 deg
+
+	virus eject/split direction deviations: mean = -0.16497762078310707, stddev=0.07294211158929148, ndata=5
+		75% of the splits had a deviation smaller than 0.25 rad = 14.41 deg
+		(wrt "emitted mass begin -- parent virus")
+
+	virus2 eject/split direction deviations: mean = -0.001211356391619578, stddev=0.0038334565337591105, ndata=5
+		75% of the splits had a deviation smaller than 0.00 rad = 0.11 deg
+		(wrt "emitted mass flight direction")
+
+	virus3 eject/split direction deviations: mean = -0.13739240722341658, stddev=0.056773374975376475, ndata=5
+		75% of the splits had a deviation smaller than 0.21 rad = 11.82 deg
+		(wrt "emitter of the mass -- parent virus")
+
+
+
+
+EJECT/SPLIT DISTANCES
+
+	split cell eject/split distances: mean  = 378.6264099585539, stddev  =214.15995855502896, ndata=1226
+	split cell                        meann = 23.37846655791191, stddevn =17.23260859398865
+		75% of the distances lie in the interval 370.30 plusminus 218.60
+		80% of the distances lie in the interval 370.30 plusminus 262.32
+		max = 1205.46
+		75% of the flight lengths lie in the interval 20.00 plusminus 9.00
+		78% of the flight lengths lie in the interval 20.00 plusminus 10.80
+
+	ejected mass eject/split distances: mean  = 473.3307839719213, stddev  =159.4625848157587, ndata=1121
+	ejected mass                        meann = 42.015165031222125, stddevn =8.5656796143937
+		75% of the distances lie in the interval 534.64 plusminus 2.10
+		77% of the distances lie in the interval 534.64 plusminus 2.52
+		max = 637.28
+		75% of the flight lengths lie in the interval 44.00 plusminus 1.00
+		79% of the flight lengths lie in the interval 44.00 plusminus 1.20
+
+	virus eject/split distances: mean  = 396.47928995805, stddev  =219.79929069475193, ndata=9
+	virus                        meann = 42.666666666666664, stddevn =6.879922480183431
+		75% of the distances lie in the interval 510.53 plusminus 363.80
+		88% of the distances lie in the interval 510.53 plusminus 436.56
+		max = 580.08 (ndata = 13)
+		75% of the flight lengths lie in the interval 45.00 plusminus 10.00
+		77% of the flight lengths lie in the interval 45.00 plusminus 12.00
+
+
+
+
+VIRUS SIZES
+
+	I've seen the following 7 virus sizes:
+		 100:  386018 times
+		 106:  124015 times
+		 113:   72084 times
+		 119:   41825 times
+		 125:   24954 times
+		 131:  373398 times
+		 136:   11550 times
+
+
+
+
+REMERGES
+
+	75% of the remerge durations lie at 32.00 plusminus 30.00 frames
+	75% of the remerges were started after 767.00 plusminus 20.00 frames
+
diff --git a/reversing_game_mechanics/zoomlevel/README b/reversing_game_mechanics/zoomlevel/README
new file mode 100644
index 0000000..a2acc90
--- /dev/null
+++ b/reversing_game_mechanics/zoomlevel/README
@@ -0,0 +1,32 @@
+The goal is to find out the formula to calculate the appropriate zoom level,
+or equivalent: to calculate the size of the world viewport depending on, well,
+dunno.
+
+Data collected using bea9a124317, on 2015-08-25 *iirc*. (-> stats.pickle.xz)
+
+Data analyzed using ea4515d0516, with:
+
+	python analyze.py stats.pickle > temp
+
+then manually, create win.{size,mass}.{1,2,3,4,5,6} by cutting the
+analyze.py output into pieces (depending on number of cells).
+
+view with
+
+	gnuplot win.{size,mass}.gnuplot
+
+the gray lines in win.size.gnuplot denote the filtering conditions of
+filter_data.py
+
+Then merge and filter the data using
+
+	cat win.size.[123456] | python filter_data.py > win.size.all.filtered
+
+win.size.gnuplot will automatically fit a "a * size**b" - like function.
+
+Result: visible diagonal = 369.399 * sum(sizes)**0.431776
+
+Also, analyze.py tells us that the viewport ratio is 1.7 : 1
+
+Additionally, if size<70, then the value 70 instead of "size" is used (found
+out by tinkering around manually)
diff --git a/reversing_game_mechanics/zoomlevel/filter_data.py b/reversing_game_mechanics/zoomlevel/filter_data.py
new file mode 100644
index 0000000..e801d78
--- /dev/null
+++ b/reversing_game_mechanics/zoomlevel/filter_data.py
@@ -0,0 +1,10 @@
+import sys
+
+for line in sys.stdin:
+    line = line.split()
+    size, diag = int(line[0]), float(line[1])
+    upper = size**0.4 * 460   +   50
+    lower = size**0.407 * 460   -   400
+    if lower < diag and diag < upper:
+        print(str(size) + "\t" + str(diag) + "\t\t" + line[2])
+
diff --git a/reversing_game_mechanics/zoomlevel/stats.pickle.xz b/reversing_game_mechanics/zoomlevel/stats.pickle.xz
new file mode 100644
index 0000000..c915674
--- /dev/null
+++ b/reversing_game_mechanics/zoomlevel/stats.pickle.xz
diff --git a/reversing_game_mechanics/zoomlevel/win.mass.1 b/reversing_game_mechanics/zoomlevel/win.mass.1
new file mode 100644
index 0000000..1bac0fb
--- /dev/null
+++ b/reversing_game_mechanics/zoomlevel/win.mass.1
@@ -0,0 +1,116 @@
+0.0	9957.478596512272		16
+24.01	2120.5192760265113		245
+25.0	1969.829688069504		88
+26.01	1907.5106814904077		196
+27.04	1652.2645066695586		49
+28.09	1860.7818249327352		96
+29.16	1851.8933554608375		58
+30.25	1468.638825579659		70
+31.36	2251.943604977709		106
+32.49	2004.575765592311		166
+33.64	2109.127781809343		362
+34.81	2126.4564420650613		137
+36.0	1994.1740144731602		91
+37.21	2173.5730951592127		58
+38.44	1940.5630626186824		52
+39.69	2232.8013794334684		39
+40.96	2133.3471353720192		71
+42.25	2239.5713875650404		100
+43.56	2259.5827048373335		868
+44.89	2240.224319125208		818
+46.24	2307.553032976707		443
+47.61	2226.5634956138124		579
+49.0	2356.425258734085		336
+50.41	2293.2538019155227		397
+51.84	2249.2098612623945		273
+53.29	2331.4519081465096		451
+54.76	2392.639755583778		300
+56.25	2404.2996901384818		277
+57.76	2403.8011565019265		161
+59.29	2357.5313359529287		262
+60.84	2377.4242364374095		157
+62.41	2339.8472172344927		145
+64.0	2438.0258407162137		228
+65.61	2488.3331770484433		301
+67.24	2489.7003835803216		352
+68.89	2499.0544211761376		291
+70.56	2455.6426857342253		304
+72.25	2498.9455776386967		154
+73.96	2378.6727391551785		346
+75.69	2474.5797623030867		702
+77.44	2366.7634017788937		727
+79.21	2442.546417163858		373
+81.0	2515.553616999646		238
+82.81	2614.3163542310635		207
+84.64	2594.101771326638		66
+86.49	2544.643000501249		67
+88.36	2651.225377066235		95
+90.25	2681.96290056369		148
+92.16	2685.0344504307577		170
+94.09	2679.5546271722096		426
+96.04	2693.4938277263605		569
+98.01	2726.821592990638		54
+100.0	2696.036349903317		53
+102.01	2704.8558187082726		56
+104.04	2754.743726737571		88
+106.09	2719.114010114324		180
+108.16	2791.1581825471662		122
+110.25	2794.8023185907086		84
+112.36	2803.209767391659		133
+114.49	2805.824121358999		90
+116.64	2796.2517769328283		250
+118.81	2803.5384784232942		261
+121.0	2837.5144052497776		142
+123.21	2835.092414719492		107
+125.44	2846.737255174773		63
+127.69	2877.452345391666		63
+129.96	2851.5078467365297		53
+132.25	2780.2778638114573		113
+134.56	2891.1260781916794		242
+136.89	2870.733878296628		69
+139.24	2892.3390188565377		88
+141.61	2730.286798122131		145
+144.0	2715.363695713707		389
+146.41	2238.8311682661556		281
+148.84	2913.41998345587		61
+151.29	2955.795155283938		28
+153.76	2385.1079640133694		322
+156.25	3029.202205201891		67
+158.76	3015.162516349658		39
+161.29	3024.4353191959653		64
+163.84	3046.6238691377707		139
+166.41	3020.514029101669		40
+169.0	3015.3225366451265		112
+171.61	3021.6586504765887		92
+174.24	3040.8763539479864		73
+176.89	3065.0941257977706		58
+179.56	2976.10500486794		66
+182.25	3026.624522467232		98
+184.96	3013.2540550043236		84
+187.69	2927.263910206936		80
+190.44	2981.869380103696		80
+193.21	2977.177354475208		52
+196.0	3049.6730972351775		42
+198.81	2354.0403564934904		65
+201.64	2332.625130620006		4
+219.04	3144.616033794905		7
+222.01	3228.400223020684		11
+225.0	3220.1863300125974		71
+228.01	3248.3468103021264		119
+231.04	3253.712494981694		66
+234.09	3238.846245192877		57
+237.16	3176.819950831334		43
+240.25	3301.4617974467005		36
+243.36	3296.8477368541		132
+246.49	3316.3596005258537		113
+249.64	3286.2537942161434		155
+252.81	3083.007946794818		110
+256.0	2909.176000175995		64
+259.21	2641.6837433727756		35
+262.44	2646.5972492995606		65
+265.69	2727.742106578259		49
+268.96	2692.4384858339845		44
+272.25	2498.7140692764347		49
+275.56	2352.3938870860893		36
+278.89	2375.1743093928917		57
+282.24	2304.796954180563		121
diff --git a/reversing_game_mechanics/zoomlevel/win.mass.2 b/reversing_game_mechanics/zoomlevel/win.mass.2
new file mode 100644
index 0000000..8c08b58
--- /dev/null
+++ b/reversing_game_mechanics/zoomlevel/win.mass.2
@@ -0,0 +1,455 @@
+40.5	2459.633306003153		36
+40.96	7513.947364734464		1
+41.41	2471.8181567421175		53
+42.34	2602.3854441646417		92
+43.25	2635.398451847462		1
+43.29	2641.4407053727327		15
+43.56	8967.320224013414		2
+44.18	2311.2580989582275		2
+44.2	2693.2903668189956		8
+44.260000000000005	2490.116463139827		12
+45.129999999999995	2369.7818464997995		3
+45.17	2718.7594597536577		30
+45.25	2628.344345781199		17
+46.08	2604.0188171363125		7
+46.1	2714.2109350601327		145
+46.16	2705.3711390491326		30
+46.24	9047.885167264227		3
+46.260000000000005	2529.635546872316		4
+47.05	2559.953905835025		100
+47.09	2748.116627801666		7
+47.29	2672.3012554725187		14
+48.04	2696.738771182704		64
+48.2	2656.4521452493736		2
+49.010000000000005	2747.4096891435756		35
+49.05	1728.9814920929605		28
+49.129999999999995	2674.728023556788		33
+50.0	2718.0345840331024		25
+50.02	1517.5836056046467		115
+50.18	2718.969290006785		29
+50.41	5962.59423405618		1
+51.010000000000005	2762.8052772499186		111
+51.25	2680.7913010900347		24
+52.02	2694.0736812492714		74
+52.04	2728.1513887612614		26
+52.2	2111.7618236912986		65
+52.34	2760.7872065771385		4
+53.05	2689.30344141378		18
+53.09	2777.4263266556686		37
+53.29	2745.1777720213313		68
+54.08	2724.0163362212056		132
+54.1	2821.2488369514663		28
+54.16	2788.0634856473407		51
+54.4	2800.803456153252		243
+54.76	9453.725720582335		1
+55.129999999999995	2814.639586163742		45
+55.17	2818.2379246614364		28
+55.25	2750.93911237599		213
+55.370000000000005	2803.9293857014304		140
+55.53	2788.3961339809666		16
+56.18	2337.0556262100395		51
+56.2	2843.388295678239		34
+56.25	9562.746467411964		1
+56.260000000000005	2824.395333518309		23
+56.36	2756.9746099665117		22
+56.68	2844.9411241711136		10
+57.25	2762.5328957317415		12
+57.29	2829.027394706527		12
+57.370000000000005	2757.496328193385		54
+57.49	2056.103110254931		16
+57.650000000000006	2840.9859204156573		76
+58.34	2798.28965620073		189
+58.5	2573.206948537175		148
+58.82000000000001	2401.801199100375		7
+59.41	2654.4522975559385		20
+59.45	2790.700270541428		8
+59.53	2643.41162137114		5
+59.650000000000006	2746.3783424721364		20
+59.81	2307.9033775268845		17
+60.5	2822.01009920234		2
+60.519999999999996	2569.880347409194		21
+60.68	2517.190894628375		44
+60.82000000000001	2588.53163009456		46
+60.84	4983.02087091756		1
+61.61	2886.1119174418723		20
+61.650000000000006	2569.880347409194		15
+61.85	2246.855580583674		57
+62.010000000000005	2406.397514958823		14
+62.120000000000005	2831.1287501630864		138
+62.72	2905.0335626288384		16
+62.8	2513.3963077875324		18
+63.04	1903.5934439895511		3
+63.05	2840.752893160544		44
+63.22	2224.2942701000693		34
+63.7	2887.0635600900787		158
+63.81	2721.133771059409		9
+63.85	2906.4015551881334		10
+63.97	2513.3963077875324		8
+64.0	2783.724483493293		31
+64.25	2190.683226758264		40
+64.45	2511.4816344142355		32
+64.97	2819.3029280302603		91
+65.0	2905.691828119424		50
+65.16	2769.544727929123		26
+65.3	2769.2159540201988		110
+65.7	2169.302652927894		1
+66.13	2917.1830590485747		32
+66.17	1978.7786637216402		36
+66.37	2866.9461104108673		26
+66.53	2828.3638379812455		176
+66.97	2169.302652927894		2
+67.28	2914.5826459374935		4
+67.30000000000001	1456.4751971798216		33
+67.6	2892.723630075988		18
+68.26	2169.302652927894		1
+68.45	2870.029442357691		68
+68.49000000000001	1493.238427043719		9
+68.56	3071.149133467797		1
+68.85	2876.960201323612		40
+68.89	8841.674502038626		2
+69.62	2759.3203873417815		37
+69.64	2934.570667065286		37
+69.7	1503.1999201703013		20
+70.12	2944.063178669914		15
+70.56	6246.4982190023875		1
+70.81	2861.632051819381		66
+70.85	2948.546930269213		16
+70.93	1951.1483798009826		158
+71.21000000000001	2883.3539498299547		18
+72.0	2895.3979001166663		37
+72.02000000000001	2944.6481963046112		6
+72.08	2900.384802056444		30
+72.18	2046.8927670984624		2
+72.32	2937.0192372539886		65
+73.21000000000001	2890.895017118401		34
+73.25	2878.285079695894		36
+73.45	2660.3768530041		49
+74.42	2244.9518925803286		5
+74.44	2922.8884686214083		47
+74.6	2709.7276615925816		7
+74.74000000000001	2194.8769897194693		16
+75.65	2959.984628338465		37
+75.69	2994.2386344444894		15
+75.77000000000001	2779.7426139842514		10
+76.05000000000001	2211.8340805765697		4
+76.88	2980.0191274553927		13
+76.9	2640.6423460968736		21
+76.96000000000001	3009.2705096085997		39
+77.12	2918.4278301852864		123
+77.38	2188.1373357264392		6
+77.6	2235.5270072177614		9
+78.00999999999999	2934.982112381607		84
+78.13	2953.3900859859336		45
+78.17	2975.29695996887		29
+78.73	2162.7568055609026		8
+78.97	2329.121937555009		16
+79.21	9939.87610586772		1
+79.38	2913.7070889161114		56
+79.4	3010.1975018260846		33
+79.46000000000001	2199.218497557712		8
+79.53999999999999	2982.9921220144047		45
+80.1	2333.552227827781		6
+80.45	2793.836072499602		9
+80.65	2684.162811753415		43
+80.69	2939.1537897837193		6
+81.25	2526.8612941750484		23
+81.92	3014.607768848213		4
+81.94	2141.8881856903736		105
+82.0	2930.1754213698537		36
+82.42	2628.9505510754666		21
+82.81	6944.246107389916		1
+82.93	2891.7330443870505		17
+83.21000000000001	2881.0282886497316		60
+83.25	2973.785466371103		36
+83.3	2722.2448457109804		21
+83.81	2954.6356797412436		40
+83.88	2832.668000313485		2
+84.5	3021.231536972961		13
+84.52000000000001	2897.546720934798		92
+84.58	3001.166606504877		12
+84.85000000000001	2906.164654660847		113
+85.0	3019.600139091267		2
+85.00999999999999	2457.3501988931084		1
+85.81	3025.457651331448		112
+85.93	3023.894178042611		27
+86.05	2289.4422901658822		17
+86.21000000000001	3080.046265886277		21
+86.42	2991.139080684815		148
+87.12	2650.2371591991537		58
+87.14	3061.160890903972		40
+87.2	2986.7247948212434		14
+87.3	2296.176386952884		65
+87.41	2866.022505145415		36
+88.01	2712.7950530771764		36
+88.45	3071.8894836891513		42
+88.49000000000001	3028.9313296936925		21
+88.57	3061.068114237251		33
+88.69	3102.4778806624877		32
+89.78	3057.227829259704		10
+89.80000000000001	3014.607768848213		61
+89.86	2269.5003855474447		32
+89.96000000000001	3097.339826367136		48
+91.13	2865.656120332654		23
+91.17	3106.295060035347		30
+91.25	3075.8616678908043		57
+91.37	3118.5017235845808		22
+92.48	2388.5782381994522		258
+92.56	3017.995692508523		37
+92.66	3129.7420021465027		8
+92.80000000000001	3128.0374038684386		8
+92.97999999999999	3120.59817983668		1
+93.85	2621.0017169013836		65
+93.89	3152.9827148273425		16
+93.97	3112.9114989025948		81
+94.09	9051.577210630201		1
+94.25	3144.593614443685		7
+94.44999999999999	3136.026307287616		39
+95.22	2358.5930127938564		67
+95.24000000000001	2628.2302030073392		75
+95.3	3157.6879199819605		6
+95.4	3069.05881338237		46
+95.72	3148.735619260531		4
+96.61	3138.517643729281		30
+96.65	3154.2341384240963		35
+96.73	3104.341637126945		3
+96.85	2934.527219161547		16
+97.00999999999999	3145.1621579816833		4
+98.0	3169.7397369500227		12
+98.02	3173.4405619138356		51
+98.08000000000001	2803.5762875299115		29
+98.18	3156.589456993101		6
+98.32	2872.565578015583		43
+99.41	3167.053520229805		51
+99.53	2792.167616745098		19
+99.65	3192.3842187305713		50
+99.81	2941.8161057414854		13
+100.82	3106.0143270757785		4
+100.84	3196.712842905975		42
+101.0	2792.6850878679465		45
+101.14	3075.295758134492		67
+101.32	2934.527219161547		73
+102.25	3169.335577057122		11
+102.28999999999999	3064.378077196089		1
+102.37	2867.3070990042206		13
+102.49000000000001	2972.5687544613666		78
+102.65	2899.1883346895556		9
+103.69999999999999	3107.673084479769		14
+103.75999999999999	3107.5662502994205		20
+103.86	3207.86486623112		147
+104.89	3004.323051870421		19
+105.16999999999999	3062.840674929076		13
+105.25	3115.385208926819		37
+105.37	3124.894398215722		47
+105.85	2480.4487497225173		1
+106.58	2407.431203586096		4
+106.6	3050.954276943527		19
+106.66	3204.720580643498		57
+106.9	2971.6609833559414		9
+107.68	2869.1868185951225		90
+108.05	2715.207542711975		40
+108.09	3034.582837887277		35
+108.16	8923.322083170595		1
+108.16999999999999	3132.7657109972333		42
+108.45	3206.7556813701913		41
+108.65	2434.9080064758095		21
+109.52	2983.3921968122127		42
+109.53999999999999	3021.7852339304327		68
+109.6	3228.6035681080452		52
+109.69999999999999	2382.238443145438		26
+110.02	3201.5621187164243		16
+110.65	2278.747462971709		143
+111.00999999999999	3198.4935516583428		24
+111.13	3270.7872141122234		2
+111.25	2250.734324614969		1
+111.41	2266.3973614527526		19
+111.61	3248.176873262908		16
+112.5	3209.6263022351995		52
+112.52	3236.8775077225273		21
+112.58	3265.214388060913		9
+112.68	3261.2028455770733		27
+112.82	2247.8979069343873		12
+113.0	3248.630788501519		44
+114.00999999999999	3246.263698469365		7
+114.05	3283.7113149605584		11
+114.13	3138.9547623372973		9
+114.25	3212.693107036525		19
+114.61	3167.6016163652903		14
+115.53999999999999	3279.512158843141		30
+115.69999999999999	3252.1334535962696		27
+116.02	3175.914986267737		15
+117.09	3308.273416753821		12
+117.16999999999999	3253.6510261550793		13
+117.28999999999999	3282.2183047445214		52
+117.45	3194.5548985735086		48
+118.58	3271.134359820764		28
+118.6	3166.3411060718017		2
+118.66	3274.657997409806		12
+118.75999999999999	3276.1114144668522		71
+118.81	8069.929987304723		2
+118.9	3058.5586474677907		6
+119.08	3124.7374289690324		33
+120.13	3299.07865926231		7
+120.25	3283.969549188908		169
+120.37	3282.865364281636		18
+120.53	3209.4538476195603		85
+121.75999999999999	3202.652026055906		19
+122.0	3247.845439672276		63
+123.28999999999999	2896.068024062971		10
+123.49	3257.744618597351		2
+123.65	3335.6368207585188		17
+124.82	3061.1470072507136		3
+124.84	2652.874101799782		137
+125.32	3291.808317627258		3
+125.44	7472.861366304074		1
+126.41	3291.879098630446		96
+126.45	2954.865309959153		30
+126.81	3347.0017926496544		16
+128.0	2969.6642907911323		30
+128.01999999999998	3156.169355405378		113
+128.5	3339.6354591481986		10
+129.61	3133.040216786245		36
+130.01	3337.7336622325033		8
+131.22	3179.471811480643		3
+131.24	3020.9197275002193		42
+131.72	3079.234482789513		4
+132.25	5694.3046107492355		1
+132.85	3265.6763464862834		6
+132.89	2765.289315785963		54
+133.25	3299.167319188283		1
+133.45	3240.6210824470054		39
+134.5	3285.5763573534555		75
+135.2	3389.542299485286		8
+135.49	2913.1991006451995		84
+136.17000000000002	3337.108329077736		61
+136.97	3390.6201497661164		15
+137.86	2278.6425783786276		15
+138.5	3412.359887233467		24
+139.49	2278.6425783786276		7
+139.57	3314.6464366505215		12
+140.05	3394.3603226528558		10
+141.2	2268.637696945019		37
+141.3	3211.592906954429		16
+141.62	3412.2980526325655		9
+142.93	2764.389625215664		104
+143.20999999999998	3397.420492079248		31
+144.57999999999998	3046.709700644287		25
+144.82	3239.8902759198495		12
+145.0	3390.017846560693		4
+146.20999999999998	3388.321118194083		1
+146.25	3230.394712724747		5
+146.41	6656.233319227925		1
+146.45	3202.770831639379		19
+147.65	3406.1809993011234		1
+147.92	2490.0461843106445		65
+147.94	3282.4850342385416		38
+148.1	3091.0713353140204		13
+148.84	8177.841524509998		1
+149.64999999999998	3420.9264826944177		59
+149.89	2971.110398487407		7
+151.38	3450.2268041391135		48
+151.39999999999998	3435.114699686169		27
+151.56	2916.207468613987		33
+153.13	3376.8393506354428		53
+153.25	2747.6792025271075		6
+154.89999999999998	3029.6093807618167		19
+156.64999999999998	3184.1678661779124		13
+156.69	2963.002024973996		6
+158.44	3278.1976755528335		43
+158.5	2984.3982643072286		41
+160.32999999999998	2929.2353951159334		19
+161.3	3395.699927849927		140
+162.18	2900.2127508167396		26
+164.05	2828.9547539683276		18
+165.94	2834.0869781995048		17
+167.85	2761.479675825987		42
+169.78	2820.7943916563645		30
+182.25	9562.855274446016		1
+182.41	3317.3273881243617		4
+184.34	3322.925969683947		1
+186.29000000000002	3360.9024085801716		3
+188.26	3392.7009888877624		14
+192.08	3491.7183448840774		81
+192.16	3420.003654968807		17
+193.21	9577.942211143269		1
+194.05	3640.672602693079		29
+194.09	3480.2909361143934		84
+198.01	3485.7327780539918		20
+198.25	2896.212181453562		2
+200.0	3494.622726418404		38
+200.18	2942.880901429754		38
+201.64	9784.782930653086		1
+202.01	3437.9077939933177		13
+202.25	2967.623291457324		18
+204.04000000000002	3296.5171014268985		26
+204.2	2866.873035207524		20
+204.34	2955.8289869341224		7
+206.09	3148.6176331844426		31
+206.17000000000002	2744.5052377432257		80
+208.16	3158.060955713173		41
+208.26	2737.0440259520856		26
+210.17000000000002	2736.23335993113		43
+210.25	2968.037904070634		10
+212.26	2868.054567123854		99
+212.36	2936.9548855915373		9
+214.29000000000002	3114.007867684345		21
+214.49	2857.8037021461078		22
+216.4	3288.7281736257864		22
+216.64	2758.698424982332		10
+218.53	3553.019701605945		81
+218.81	2711.7280468365557		27
+220.68	3634.7426318791818		43
+221.0	2744.636952312637		21
+221.22	2778.7531376500506		16
+222.73000000000002	3435.003639008262		25
+223.20999999999998	2813.6142237343056		32
+225.44	2884.218091615126		33
+227.45	2920.3643608289703		13
+229.48000000000002	2901.059806346639		1
+229.7	2872.4863794281077		1
+231.04	4566.623698094688		1
+231.13	3745.4198696541353		4
+231.97000000000003	2805.2536427211		23
+233.3	3798.324367402026		6
+234.26	2917.5335473649657		54
+235.49	3780.4034176262194		43
+236.29000000000002	3127.261581639758		26
+237.7	3790.5283272915926		21
+238.34	3509.404507890192		65
+239.93	3780.8000476089715		23
+240.41	3691.2167370665193		62
+242.18	3810.5668869605215		12
+242.5	3690.6977660057723		7
+242.72	3783.2076337415056		103
+244.45	3796.823145736446		88
+244.61	3815.123720143293		18
+245.04999999999998	3808.475941895918		66
+246.74	3792.3610060225014		23
+248.89	3815.631009413777		26
+249.64	7526.270258235482		1
+250.88	3824.0011767780616		2
+251.06	3777.8631526300683		14
+253.13	3826.4825884877614		43
+253.25	3750.3314520186077		26
+255.38	3834.963624338567		11
+255.45999999999998	3795.2923471058193		13
+257.65	3861.3113057612954		13
+257.69	3831.301214992108		83
+259.88	3807.41697217418		30
+259.94	3846.839351987551		55
+260.0	3830.0822445477593		38
+262.25	3857.996630376963		115
+262.33	3867.2832841673235		26
+262.45	3831.658257204053		60
+264.42	3542.066346075409		27
+264.52	3801.982772186113		32
+264.68	3832.571069138836		36
+264.82	3437.7121752700587		18
+266.81	3789.4339946751943		30
+267.05	3784.653220573848		128
+269.12	3747.1441125208944		93
+269.44	3049.4078113627243		51
+269.62	2788.9302608706444		40
+271.85	2863.6000069842157		18
+272.05	2737.5529218628817		19
+278.48	2678.195287875774		32
+278.89	9754.961199307765		1
diff --git a/reversing_game_mechanics/zoomlevel/win.mass.3 b/reversing_game_mechanics/zoomlevel/win.mass.3
new file mode 100644
index 0000000..ba343eb
--- /dev/null
+++ b/reversing_game_mechanics/zoomlevel/win.mass.3
@@ -0,0 +1,126 @@
+60.769999999999996	2830.58244889634		7
+65.46000000000001	3420.4585949840116		1
+66.53	7887.098642720275		1
+66.81	2838.9575551599924		6
+67.7	3143.764145097402		42
+68.26	9958.89833264704		1
+68.33	2134.831609284442		24
+68.59	3184.6464481948383		18
+69.26	1980.0426763077608		8
+69.66	3112.852389690202		14
+70.17	1914.7461972804647		7
+70.75	3137.9294128453557		3
+71.10000000000001	1793.7293552818942		4
+71.18	1948.351354350647		3
+71.86	3120.9783722416278		17
+72.99000000000001	3145.5927899205262		21
+73.14	1833.039006677163		12
+73.9	3145.5927899205262		4
+74.13	1833.8105136572863		8
+74.83	3056.016361212747		21
+75.14	1914.4221060152852		8
+75.78	2881.213980252074		7
+76.16999999999999	1943.2395632036726		13
+76.75	2829.041180329477		6
+76.96000000000001	5461.392679527814		1
+77.14	2411.4835682624916		11
+77.22	2287.895102490497		30
+77.9	2809.5213115404554		26
+78.0	3147.2827963181194		58
+78.17	2468.258090232867		21
+79.24	2355.969651757		20
+79.4	8508.168428046074		1
+80.21	2702.4124407647328		32
+81.2	2982.131452501717		24
+82.25	3122.2384598233366		19
+83.32	3265.692269642074		28
+84.33	3261.3567728784287		5
+84.97	3468.918707609044		1
+85.42	3261.3567728784287		5
+86.45	3274.0054978573266		11
+87.53999999999999	3332.2054258403696		15
+88.65	3361.016661666526		3
+89.78	3355.109089135553		14
+90.83	3373.971102425153		20
+91.98	3259.075482402947		7
+93.05	3265.9854561831717		10
+95.31	3411.079741079062		17
+96.38	2931.623611584543		7
+96.42	3402.4616088943603		17
+96.75999999999999	3406.882592635091		13
+97.61	3376.63575175055		7
+97.85	3455.7640255086862		3
+98.74000000000001	3323.912303295621		14
+98.94	3456.7860795831725		45
+99.65	6587.192725281385		1
+99.89	3373.551392820332		8
+101.06	3336.6609057559326		7
+101.14	7665.473892721832		1
+103.30000000000001	3425.875800434102		11
+104.45	3329.9831831407196		10
+104.75	3409.622413112631		38
+104.89	4313.037096988617		1
+105.30000000000001	3410.078298221318		28
+105.62	3299.869694397038		6
+105.66	3416.254235269969		37
+105.69999999999999	3447.78842158274		23
+106.59	3479.379973501026		105
+106.61000000000001	3463.3119986510023		47
+106.81	3258.0682927157927		5
+106.85000000000001	3271.244564382186		8
+106.97	3457.1297343316464		86
+107.00999999999999	3471.528913893704		33
+107.9	3448.322055725074		8
+107.94	3347.817946065765		4
+108.02000000000001	3247.0983970308016		1
+108.06	3240.0327158842083		8
+108.36000000000001	3461.478441359992		20
+109.29	3211.9752489706393		6
+110.51	2842.601801167374		8
+110.81	3206.3019196575983		20
+111.41	9875.263895208067		1
+111.82000000000001	3040.0726964992136		77
+112.04999999999998	2418.4798944791746		26
+112.5	7247.468592550091		1
+113.04	3227.447288492873		11
+115.4	3130.8784709726438		1
+116.61000000000001	3295.738460497131		2
+117.84	3356.7450007410453		26
+118.6	7029.594867415903		1
+119.09	3271.6653251822686		40
+119.13	3291.6629535844036		39
+120.38	3236.8164915546263		19
+121.63	3177.624899197512		3
+122.9	3060.851025450275		21
+122.99	3527.7692668313784		35
+123.49	7155.990497478319		1
+124.14	3476.978573416868		10
+124.19	2975.672697055239		40
+124.73	2989.411982313579		27
+125.5	3051.0473611532157		4
+125.9	2898.4592458752977		3
+126.41	7350.145372712025		1
+126.83	3049.9652457036295		25
+127.01	2860.5029278083252		25
+128.2	2748.142099673887		18
+129.41	2691.989970263634		1
+130.98	2670.9842755059417		25
+134.3	2809.3913931668544		10
+135.17000000000002	2945.6654596202875		13
+136.98000000000002	2946.8554426710516		4
+137.87	3046.0080433249022		11
+139.7	3122.5574454283465		14
+139.71	3321.6188824126107		59
+140.37	3465.600669436685		28
+140.61	3162.9835598687514		22
+141.32	3303.806289720994		4
+141.54000000000002	3590.769416155819		43
+141.63	3137.2424197055607		2
+142.49	3182.529968437061		1
+143.46	3185.424932406978		15
+168.81	2838.9635432671553		12
+202.01	9721.27075026717		1
+216.49	3464.951947718756		23
+216.91000000000003	3738.3038934789665		3
+218.3	3524.6476419636615		4
+264.42	9773.704773523703		1
diff --git a/reversing_game_mechanics/zoomlevel/win.mass.4 b/reversing_game_mechanics/zoomlevel/win.mass.4
new file mode 100644
index 0000000..aa0de62
--- /dev/null
+++ b/reversing_game_mechanics/zoomlevel/win.mass.4
@@ -0,0 +1,130 @@
+75.78	3431.546152975361		6
+76.63	3497.8764986774477		14
+76.96000000000001	5461.392679527814		1
+77.5	3311.0096647397454		23
+78.35	3389.6768282536905		36
+79.24	3468.8963662813567		13
+79.4	8508.168428046074		1
+80.13	3486.8789769649306		21
+80.14999999999999	3507.4472198452254		16
+81.03999999999999	3426.4974828533		11
+81.08	3490.3886603070437		102
+81.93	3354.6057890607653		35
+82.03	3519.1081256477473		63
+82.86	3395.7847399386196		11
+83.0	3404.603501143709		4
+83.87	3419.91418020979		18
+84.78	3187.2913265028033		64
+85.71000000000001	3413.126719007075		8
+85.77	3115.806476660577		49
+96.38999999999999	3615.2654121101536		87
+97.25999999999999	3652.2186407716613		3
+97.47999999999999	3627.734279133465		58
+98.26	3649.020964587625		1
+98.36999999999999	3593.768078215399		9
+98.58999999999999	3627.231726813163		147
+98.94	5135.193180397404		1
+99.21000000000001	3664.0061408245483		74
+99.24	3584.0772871131003		3
+99.65	6587.192725281385		1
+100.13	3584.0772871131003		2
+100.18	3573.493808585654		1
+100.38	2493.193935497197		1
+101.02	3677.116261420082		10
+101.14	7665.473892721832		1
+101.17	3670.228875696991		45
+101.32999999999998	2823.253796597111		33
+101.42999999999999	2493.193935497197		53
+102.12	3707.9920442201596		9
+102.15	3654.805603585504		14
+102.26	2755.466203748469		1
+103.06	3683.1563909234155		43
+103.09	3675.8706451669377		16
+103.33	2441.627530971913		36
+103.99000000000001	3684.5929218843157		4
+105.09	3716.556605246313		8
+106.10000000000001	3684.0620244507286		15
+107.13	3732.4611183507322		7
+107.15	3715.699799499416		23
+109.23	3690.992549437075		16
+110.3	3509.5711988788603		21
+110.5	2476.2915821849415		5
+110.98	3468.918707609044		5
+111.32999999999998	3555.6774319389547		25
+111.41	9875.263895208067		1
+111.51	2465.023326461638		1
+112.41999999999999	3459.260036481791		17
+112.53999999999999	2540.530850039023		35
+113.52999999999999	3586.7179983935175		15
+114.66	3585.6561463698663		10
+115.80999999999999	3670.9509667114867		23
+115.85000000000001	3782.2038548973005		17
+116.86	3734.5910083970375		112
+116.88000000000001	3796.5963704349715		139
+116.97999999999999	3743.2312244904133		16
+117.92999999999999	3784.865915722775		12
+117.97	3800.631526470305		29
+118.03	3744.2478550437872		29
+118.6	7029.594867415903		1
+118.82	3733.0740683784993		1
+119.02	3689.460258628625		9
+119.91	3723.439404636525		3
+120.13	3625.2627490983327		4
+121.2	3526.8682992139074		20
+122.13	3630.5692391138887		8
+122.33	3313.4086678223075		20
+123.26	3661.392221546334		13
+123.46000000000001	3634.4388837893534		11
+123.49	7155.990497478319		1
+124.41	3814.323662197533		12
+124.57000000000001	3220.6027386189685		5
+124.63000000000001	3634.4388837893534		40
+125.53999999999999	3831.4364147144606		11
+125.60000000000001	3827.5533961004385		69
+126.41	7350.145372712025		1
+126.63000000000001	3590.791834679365		5
+126.71000000000001	3812.6926180850196		47
+126.77	3832.2616038052515		5
+126.77000000000001	3832.5211023554716		6
+126.83	9346.260482139367		1
+127.70000000000002	3814.195852338996		13
+127.72	3636.3681056790715		28
+127.80000000000001	3813.7278350716115		66
+127.86	3826.231827790888		3
+127.96000000000001	3856.772873789692		16
+128.85000000000002	3768.2490628938		180
+128.95	3838.2737005065183		19
+129.13	3854.4753209743085		28
+130.34	3835.5570651471216		1
+130.98	7269.414075425887		1
+131.57	3876.429542762257		43
+132.76	3793.3906996248093		27
+135.07	2951.3117422597024		5
+202.01	9721.27075026717		1
+204.5	3049.217932519747		3
+205.93	2999.563301549077		1
+207.38	2918.4139528175233		2
+208.85	2928.8649678672455		1
+210.34	2923.3942601024582		1
+211.79	2926.6731966517887		1
+213.29999999999998	2921.918034442445		3
+213.39999999999998	3027.5617252171755		7
+213.42	3092.014553652683		2
+214.82999999999998	3092.7083599977545		25
+214.86999999999998	3098.9601481787404		28
+216.29999999999998	3112.9012191201955		7
+216.35999999999999	2853.4514188960707		21
+217.86999999999998	2832.8236796525125		40
+219.29999999999998	2666.3600657075553		5
+220.82999999999998	2658.3432810681165		14
+222.27999999999997	2840.7354681490497		2
+223.74999999999997	2840.7354681490497		9
+225.17999999999998	2840.7354681490497		2
+226.63	2840.7354681490497		4
+228.1	2840.7354681490497		63
+264.42	9773.704773523703		1
+264.52	3771.882951524344		154
+265.45	3702.6188029555515		4
+266.39	3661.2525179233403		51
+267.3	3601.816902620121		2
+269.17	3550.685708423093		49
diff --git a/reversing_game_mechanics/zoomlevel/win.mass.5 b/reversing_game_mechanics/zoomlevel/win.mass.5
new file mode 100644
index 0000000..f4b686e
--- /dev/null
+++ b/reversing_game_mechanics/zoomlevel/win.mass.5
@@ -0,0 +1,8 @@
+126.83	9346.260482139367		1
+129.32999999999998	3926.380139517823		7
+130.22	3995.193362028927		19
+130.98	7269.414075425887		1
+131.06	2999.2432378851836		13
+131.23000000000002	3979.0382003695313		11
+133.33999999999997	3046.871510254412		16
+134.51	3030.115674359644		1
diff --git a/reversing_game_mechanics/zoomlevel/win.mass.6 b/reversing_game_mechanics/zoomlevel/win.mass.6
new file mode 100644
index 0000000..7994d85
--- /dev/null
+++ b/reversing_game_mechanics/zoomlevel/win.mass.6
@@ -0,0 +1,4 @@
+126.83	9346.260482139367		1
+127.14	3564.1046561513876		2
+128.13	3713.46266980025		16
+129.01999999999998	3981.4374288691265		52
diff --git a/reversing_game_mechanics/zoomlevel/win.mass.gnuplot b/reversing_game_mechanics/zoomlevel/win.mass.gnuplot
new file mode 100644
index 0000000..a948115
--- /dev/null
+++ b/reversing_game_mechanics/zoomlevel/win.mass.gnuplot
@@ -0,0 +1,9 @@
+min(a,b)=(a<b)?a:b
+max(a,b)=(a>b)?a:b
+plot "win.mass.1" using 1:2:(min(1,$3/100)) lt rgb "red" pt 2 ps variable, \
+     "win.mass.2" using 1:2:(min(1,$3/100)) lt rgb "blue" pt 2 ps variable, \
+     "win.mass.3" using 1:2:(min(1,$3/100)) lt rgb "green" pt 2 ps variable, \
+     "win.mass.4" using 1:2:(1) lt rgb "purple" pt 2 ps variable, \
+     "win.mass.5" using 1:2:(1) lt rgb "cyan" pt 2 ps variable, \
+     "win.mass.6" using 1:2:(1) lt rgb "orange" pt 2 ps variable
+pause -1
diff --git a/reversing_game_mechanics/zoomlevel/win.size.1 b/reversing_game_mechanics/zoomlevel/win.size.1
new file mode 100644
index 0000000..8357f6a
--- /dev/null
+++ b/reversing_game_mechanics/zoomlevel/win.size.1
@@ -0,0 +1,116 @@
+0	9957.478596512272		16
+49	2120.5192760265113		245
+50	1969.829688069504		88
+51	1907.5106814904077		196
+52	1652.2645066695586		49
+53	1860.7818249327352		96
+54	1851.8933554608375		58
+55	1468.638825579659		70
+56	2251.943604977709		106
+57	2004.575765592311		166
+58	2109.127781809343		362
+59	2126.4564420650613		137
+60	1994.1740144731602		91
+61	2173.5730951592127		58
+62	1940.5630626186824		52
+63	2232.8013794334684		39
+64	2133.3471353720192		71
+65	2239.5713875650404		100
+66	2259.5827048373335		868
+67	2240.224319125208		818
+68	2307.553032976707		443
+69	2226.5634956138124		579
+70	2356.425258734085		336
+71	2293.2538019155227		397
+72	2249.2098612623945		273
+73	2331.4519081465096		451
+74	2392.639755583778		300
+75	2404.2996901384818		277
+76	2403.8011565019265		161
+77	2357.5313359529287		262
+78	2377.4242364374095		157
+79	2339.8472172344927		145
+80	2438.0258407162137		228
+81	2488.3331770484433		301
+82	2489.7003835803216		352
+83	2499.0544211761376		291
+84	2455.6426857342253		304
+85	2498.9455776386967		154
+86	2378.6727391551785		346
+87	2474.5797623030867		702
+88	2366.7634017788937		727
+89	2442.546417163858		373
+90	2515.553616999646		238
+91	2614.3163542310635		207
+92	2594.101771326638		66
+93	2544.643000501249		67
+94	2651.225377066235		95
+95	2681.96290056369		148
+96	2685.0344504307577		170
+97	2679.5546271722096		426
+98	2693.4938277263605		569
+99	2726.821592990638		54
+100	2696.036349903317		53
+101	2704.8558187082726		56
+102	2754.743726737571		88
+103	2719.114010114324		180
+104	2791.1581825471662		122
+105	2794.8023185907086		84
+106	2803.209767391659		133
+107	2805.824121358999		90
+108	2796.2517769328283		250
+109	2803.5384784232942		261
+110	2837.5144052497776		142
+111	2835.092414719492		107
+112	2846.737255174773		63
+113	2877.452345391666		63
+114	2851.5078467365297		53
+115	2780.2778638114573		113
+116	2891.1260781916794		242
+117	2870.733878296628		69
+118	2892.3390188565377		88
+119	2730.286798122131		145
+120	2715.363695713707		389
+121	2238.8311682661556		281
+122	2913.41998345587		61
+123	2955.795155283938		28
+124	2385.1079640133694		322
+125	3029.202205201891		67
+126	3015.162516349658		39
+127	3024.4353191959653		64
+128	3046.6238691377707		139
+129	3020.514029101669		40
+130	3015.3225366451265		112
+131	3021.6586504765887		92
+132	3040.8763539479864		73
+133	3065.0941257977706		58
+134	2976.10500486794		66
+135	3026.624522467232		98
+136	3013.2540550043236		84
+137	2927.263910206936		80
+138	2981.869380103696		80
+139	2977.177354475208		52
+140	3049.6730972351775		42
+141	2354.0403564934904		65
+142	2332.625130620006		4
+148	3144.616033794905		7
+149	3228.400223020684		11
+150	3220.1863300125974		71
+151	3248.3468103021264		119
+152	3253.712494981694		66
+153	3238.846245192877		57
+154	3176.819950831334		43
+155	3301.4617974467005		36
+156	3296.8477368541		132
+157	3316.3596005258537		113
+158	3286.2537942161434		155
+159	3083.007946794818		110
+160	2909.176000175995		64
+161	2641.6837433727756		35
+162	2646.5972492995606		65
+163	2727.742106578259		49
+164	2692.4384858339845		44
+165	2498.7140692764347		49
+166	2352.3938870860893		36
+167	2375.1743093928917		57
+168	2304.796954180563		121
diff --git a/reversing_game_mechanics/zoomlevel/win.size.2 b/reversing_game_mechanics/zoomlevel/win.size.2
new file mode 100644
index 0000000..6168704
--- /dev/null
+++ b/reversing_game_mechanics/zoomlevel/win.size.2
@@ -0,0 +1,150 @@
+64	7513.947364734464		1
+66	8967.320224013414		2
+68	9047.885167264227		3
+71	5962.59423405618		1
+73	6812.90341924792		1
+74	9453.725720582335		1
+75	9562.746467411964		1
+78	4983.02087091756		1
+80	7724.4858728591125		1
+83	8841.674502038626		2
+84	6246.4982190023875		1
+87	9393.411414390408		1
+89	9939.87610586772		1
+90	2459.633306003153		36
+91	2476.9733547214432		54
+92	2602.3854441646417		92
+93	2641.4407053727327		16
+94	2490.116463139827		22
+95	2708.966592632696		50
+96	2712.70344859146		186
+97	2601.976556389392		122
+98	2696.738771182704		66
+99	2717.4488035655795		96
+100	2664.1535241047955		169
+101	2756.752618571351		135
+102	2690.486944774124		169
+103	2757.303936819443		122
+104	2788.0634856473407		455
+105	2799.2456126606685		442
+106	2824.3450568229086		140
+107	2810.7694676013543		170
+108	2763.8178304656767		344
+109	2737.670725269933		72
+110	2784.720632307665		251
+111	2785.9047004519016		159
+112	2875.0377388827437		260
+113	2811.6308434785674		181
+114	2870.785606763417		187
+115	2835.5659047181393		273
+116	2866.9461104108673		57
+117	2881.5004771819836		117
+118	2909.6427615774414		109
+119	2619.34037497993		258
+120	2939.450458844306		263
+121	2906.4929038275664		204
+122	2948.7314221542797		121
+123	2953.9094434325502		74
+124	2985.440838469254		88
+125	2975.29695996887		115
+126	2954.414493601059		126
+127	2896.9544352647317		185
+128	2949.3024599047144		314
+129	2910.3683615652503		209
+130	2979.817444072707		119
+131	3028.992076582572		177
+132	2808.3669632012125		177
+133	3073.615623333536		128
+134	3060.4393475447278		151
+135	3086.498663534459		133
+136	2561.4052783579564		312
+137	3126.1601046651467		227
+138	2979.8711381534604		198
+139	3155.1700429612347		90
+140	3151.571195451564		231
+141	3164.168927222439		154
+142	3129.1259162903625		232
+143	2847.00140498736		255
+144	3187.418077378617		219
+145	3138.7672739468912		97
+146	3195.2003067100504		89
+147	3194.6325297285757		158
+148	3195.955099809758		204
+149	3237.0166820700815		62
+150	3255.597180242052		127
+151	3254.93502239292		60
+152	3281.352160314403		73
+153	3279.3377380196753		125
+154	3255.6776560341473		152
+155	3271.2471627805808		279
+156	3247.845439672276		82
+157	3326.7739628655268		29
+158	2729.1090121136604		144
+159	3286.8233904485955		142
+160	3261.8871838247255		153
+161	3328.385344277312		44
+162	3046.827366294323		49
+163	3154.2986542177646		184
+164	3295.002427920198		83
+165	3357.799874918099		76
+166	3378.6307877600357		39
+167	3370.5692397575813		30
+168	3195.0414707793702		62
+169	2902.5402667318845		135
+170	3258.0098219618676		41
+171	3262.259952854769		26
+172	3422.502739224616		116
+173	3417.901402907931		66
+174	3439.523368142743		108
+175	3349.7058079777694		59
+176	3029.6093807618167		19
+177	3441.201679646225		19
+178	3409.1941863144143		224
+179	2929.2353951159334		19
+180	2900.2127508167396		26
+181	2828.9547539683276		18
+182	2834.0869781995048		17
+183	2761.479675825987		42
+184	2820.7943916563645		30
+191	3317.3273881243617		4
+192	3322.925969683947		1
+193	3360.9024085801716		3
+194	3392.7009888877624		14
+196	3491.7183448840774		98
+197	3560.370767209505		113
+199	3481.1977823731877		22
+200	3588.148547649609		76
+201	3452.222617387239		31
+202	3451.376536977674		53
+203	3230.5573822484566		111
+204	3113.641758455844		67
+205	2726.8489140397933		53
+206	2873.5044805950797		108
+207	3104.405418111494		43
+208	3249.613515481495		32
+209	3475.2795571004067		108
+210	3639.9057680110345		80
+211	3325.2151810070877		57
+212	2884.218091615126		33
+213	2920.3643608289703		13
+214	2906.8321244956683		2
+215	2813.3490718359144		27
+216	2939.36336644519		60
+217	3755.401043830073		69
+218	3585.3395933997663		86
+219	3758.964219036941		85
+220	3790.129945001886		122
+221	3810.992521640524		172
+222	3792.3610060225014		23
+223	3815.631009413777		26
+224	3795.2923471058193		16
+225	3826.4825884877614		69
+226	3831.510668130783		54
+227	3832.1638795855274		156
+228	3833.123269606653		120
+229	3859.508388383163		141
+230	3830.84912258366		86
+231	3783.793995449541		158
+232	3746.1261324199963		184
+233	2863.6000069842157		37
+236	2678.195287875774		32
diff --git a/reversing_game_mechanics/zoomlevel/win.size.3 b/reversing_game_mechanics/zoomlevel/win.size.3
new file mode 100644
index 0000000..564d37c
--- /dev/null
+++ b/reversing_game_mechanics/zoomlevel/win.size.3
@@ -0,0 +1,69 @@
+115	7887.098642720275		1
+116	9958.89833264704		1
+124	5461.392679527814		1
+126	8508.168428046074		1
+135	2830.58244889634		7
+137	4313.037096988617		1
+140	3420.4585949840116		1
+141	3163.25923692637		7
+142	3149.401212929213		43
+143	3176.547339486695		42
+144	3058.668010752393		23
+145	3126.600230282087		10
+146	3120.9783722416278		24
+147	3145.5927899205262		21
+148	3099.849351178215		16
+149	3050.773016794268		30
+150	2843.040801676965		15
+151	2624.4180307260503		19
+152	3056.6098867863398		125
+153	2468.258090232867		21
+154	2355.969651757		21
+155	2702.4124407647328		32
+156	2982.131452501717		24
+157	3142.504256162591		21
+158	3265.692269642074		28
+159	3282.8310952590905		6
+160	3261.3567728784287		5
+161	3274.0054978573266		11
+162	3332.2054258403696		15
+163	3361.016661666526		3
+164	3355.109089135553		14
+165	3373.971102425153		20
+166	3259.075482402947		7
+167	3265.9854561831717		10
+169	3411.079741079062		17
+170	3398.256611852613		37
+171	3409.9420816195693		33
+172	3456.7860795831725		82
+173	3373.551392820332		8
+174	3336.6609057559326		7
+175	3430.284244782056		15
+176	3437.843510109208		76
+177	3458.1489268104115		281
+178	3477.0933263287598		38
+179	3252.7631330916183		13
+180	3240.0327158842083		9
+181	3159.548227199579		60
+182	3040.0726964992136		77
+184	3227.447288492873		11
+186	3130.8784709726438		1
+187	3295.738460497131		2
+188	3356.7450007410453		26
+189	3489.3794577259723		114
+190	3467.191514756576		29
+191	3003.702382061179		30
+192	3060.0434637436115		34
+193	2897.203134058777		78
+194	2949.2990692705275		26
+195	3061.7589715717336		37
+196	3085.414720908682		39
+197	3373.3670123483453		109
+198	3590.769416155819		47
+199	3188.3251088933825		3
+200	3185.424932406978		15
+201	9721.27075026717		1
+225	2838.9635432671553		12
+228	9773.704773523703		1
+253	3503.388645297578		26
+254	3524.6476419636615		4
diff --git a/reversing_game_mechanics/zoomlevel/win.size.4 b/reversing_game_mechanics/zoomlevel/win.size.4
new file mode 100644
index 0000000..69a1ad2
--- /dev/null
+++ b/reversing_game_mechanics/zoomlevel/win.size.4
@@ -0,0 +1,77 @@
+124	5461.392679527814		1
+126	8508.168428046074		1
+141	6587.192725281385		1
+142	7665.473892721832		1
+149	9875.263895208067		1
+154	7029.594867415903		1
+157	7155.990497478319		1
+159	7350.145372712025		1
+172	5135.193180397404		1
+174	3431.546152975361		6
+175	3497.8764986774477		14
+176	3311.0096647397454		23
+177	3389.6768282536905		36
+178	3468.8963662813567		13
+179	3485.865889560297		37
+180	3490.3886603070437		113
+181	3515.5905620535505		98
+182	3499.1920496023076		15
+183	3419.91418020979		18
+184	3187.2913265028033		64
+185	3123.9286163419292		57
+195	3615.2654121101536		88
+196	3637.733635108541		62
+197	3628.236210612534		156
+198	3661.8806643581383		4
+199	3664.0061408245483		76
+200	3677.116261420082		12
+201	3637.3748775731106		146
+202	3685.892700554372		53
+203	3635.77777098656		56
+205	3716.556605246313		8
+206	3684.0620244507286		15
+207	3715.699799499416		30
+208	3468.918707609044		5
+209	3690.992549437075		16
+210	3509.5711988788603		26
+211	3555.6774319389547		26
+212	3433.242199437727		52
+213	3586.7179983935175		15
+214	3585.6561463698663		10
+215	3746.0168179013826		40
+216	3784.0027748404204		267
+217	3786.887112127849		70
+218	3689.460258628625		10
+219	3681.7335590724106		7
+220	3526.8682992139074		20
+221	3674.9727890149065		28
+222	3664.5142925086266		24
+223	3634.4388837893534		57
+224	3824.525199289449		80
+225	3828.2075440080307		63
+226	3813.7278350716115		126
+227	3816.3041021386125		227
+228	9773.704773523703		2
+229	3870.390807140798		48
+230	3793.3906996248093		27
+286	3049.217932519747		3
+287	2999.563301549077		1
+288	2918.4139528175233		2
+289	2928.8649678672455		1
+290	2923.3942601024582		1
+291	2926.6731966517887		1
+292	3092.7083599977545		12
+293	3092.7083599977545		53
+294	3101.7430583463874		28
+295	2832.8236796525125		40
+296	2666.3600657075553		5
+297	2658.3432810681165		14
+298	2840.7354681490497		2
+299	2840.7354681490497		9
+300	2840.7354681490497		2
+301	2840.7354681490497		4
+302	2840.7354681490497		63
+322	3771.882951524344		154
+323	3668.3926998073694		55
+324	3601.816902620121		2
+325	3550.685708423093		49
diff --git a/reversing_game_mechanics/zoomlevel/win.size.5 b/reversing_game_mechanics/zoomlevel/win.size.5
new file mode 100644
index 0000000..537d012
--- /dev/null
+++ b/reversing_game_mechanics/zoomlevel/win.size.5
@@ -0,0 +1,8 @@
+195	9346.260482139367		1
+196	7269.414075425887		1
+251	3926.380139517823		7
+252	3995.193362028927		19
+253	3979.0382003695313		11
+254	2999.2432378851836		13
+256	3046.871510254412		16
+257	3030.115674359644		1
diff --git a/reversing_game_mechanics/zoomlevel/win.size.6 b/reversing_game_mechanics/zoomlevel/win.size.6
new file mode 100644
index 0000000..1e93f8a
--- /dev/null
+++ b/reversing_game_mechanics/zoomlevel/win.size.6
@@ -0,0 +1,4 @@
+195	9346.260482139367		1
+276	3564.1046561513876		2
+277	3713.46266980025		16
+278	3981.4374288691265		52
diff --git a/reversing_game_mechanics/zoomlevel/win.size.all b/reversing_game_mechanics/zoomlevel/win.size.all
new file mode 100644
index 0000000..e4520ab
--- /dev/null
+++ b/reversing_game_mechanics/zoomlevel/win.size.all
@@ -0,0 +1,424 @@
+0	9957.478596512272		16
+49	2120.5192760265113		245
+50	1969.829688069504		88
+51	1907.5106814904077		196
+52	1652.2645066695586		49
+53	1860.7818249327352		96
+54	1851.8933554608375		58
+55	1468.638825579659		70
+56	2251.943604977709		106
+57	2004.575765592311		166
+58	2109.127781809343		362
+59	2126.4564420650613		137
+60	1994.1740144731602		91
+61	2173.5730951592127		58
+62	1940.5630626186824		52
+63	2232.8013794334684		39
+64	2133.3471353720192		71
+65	2239.5713875650404		100
+66	2259.5827048373335		868
+67	2240.224319125208		818
+68	2307.553032976707		443
+69	2226.5634956138124		579
+70	2356.425258734085		336
+71	2293.2538019155227		397
+72	2249.2098612623945		273
+73	2331.4519081465096		451
+74	2392.639755583778		300
+75	2404.2996901384818		277
+76	2403.8011565019265		161
+77	2357.5313359529287		262
+78	2377.4242364374095		157
+79	2339.8472172344927		145
+80	2438.0258407162137		228
+81	2488.3331770484433		301
+82	2489.7003835803216		352
+83	2499.0544211761376		291
+84	2455.6426857342253		304
+85	2498.9455776386967		154
+86	2378.6727391551785		346
+87	2474.5797623030867		702
+88	2366.7634017788937		727
+89	2442.546417163858		373
+90	2515.553616999646		238
+91	2614.3163542310635		207
+92	2594.101771326638		66
+93	2544.643000501249		67
+94	2651.225377066235		95
+95	2681.96290056369		148
+96	2685.0344504307577		170
+97	2679.5546271722096		426
+98	2693.4938277263605		569
+99	2726.821592990638		54
+100	2696.036349903317		53
+101	2704.8558187082726		56
+102	2754.743726737571		88
+103	2719.114010114324		180
+104	2791.1581825471662		122
+105	2794.8023185907086		84
+106	2803.209767391659		133
+107	2805.824121358999		90
+108	2796.2517769328283		250
+109	2803.5384784232942		261
+110	2837.5144052497776		142
+111	2835.092414719492		107
+112	2846.737255174773		63
+113	2877.452345391666		63
+114	2851.5078467365297		53
+115	2780.2778638114573		113
+116	2891.1260781916794		242
+117	2870.733878296628		69
+118	2892.3390188565377		88
+119	2730.286798122131		145
+120	2715.363695713707		389
+121	2238.8311682661556		281
+122	2913.41998345587		61
+123	2955.795155283938		28
+124	2385.1079640133694		322
+125	3029.202205201891		67
+126	3015.162516349658		39
+127	3024.4353191959653		64
+128	3046.6238691377707		139
+129	3020.514029101669		40
+130	3015.3225366451265		112
+131	3021.6586504765887		92
+132	3040.8763539479864		73
+133	3065.0941257977706		58
+134	2976.10500486794		66
+135	3026.624522467232		98
+136	3013.2540550043236		84
+137	2927.263910206936		80
+138	2981.869380103696		80
+139	2977.177354475208		52
+140	3049.6730972351775		42
+141	2354.0403564934904		65
+142	2332.625130620006		4
+148	3144.616033794905		7
+149	3228.400223020684		11
+150	3220.1863300125974		71
+151	3248.3468103021264		119
+152	3253.712494981694		66
+153	3238.846245192877		57
+154	3176.819950831334		43
+155	3301.4617974467005		36
+156	3296.8477368541		132
+157	3316.3596005258537		113
+158	3286.2537942161434		155
+159	3083.007946794818		110
+160	2909.176000175995		64
+161	2641.6837433727756		35
+162	2646.5972492995606		65
+163	2727.742106578259		49
+164	2692.4384858339845		44
+165	2498.7140692764347		49
+166	2352.3938870860893		36
+167	2375.1743093928917		57
+168	2304.796954180563		121
+64	7513.947364734464		1
+66	8967.320224013414		2
+68	9047.885167264227		3
+71	5962.59423405618		1
+73	6812.90341924792		1
+74	9453.725720582335		1
+75	9562.746467411964		1
+78	4983.02087091756		1
+80	7724.4858728591125		1
+83	8841.674502038626		2
+84	6246.4982190023875		1
+87	9393.411414390408		1
+89	9939.87610586772		1
+90	2459.633306003153		36
+91	2476.9733547214432		54
+92	2602.3854441646417		92
+93	2641.4407053727327		16
+94	2490.116463139827		22
+95	2708.966592632696		50
+96	2712.70344859146		186
+97	2601.976556389392		122
+98	2696.738771182704		66
+99	2717.4488035655795		96
+100	2664.1535241047955		169
+101	2756.752618571351		135
+102	2690.486944774124		169
+103	2757.303936819443		122
+104	2788.0634856473407		455
+105	2799.2456126606685		442
+106	2824.3450568229086		140
+107	2810.7694676013543		170
+108	2763.8178304656767		344
+109	2737.670725269933		72
+110	2784.720632307665		251
+111	2785.9047004519016		159
+112	2875.0377388827437		260
+113	2811.6308434785674		181
+114	2870.785606763417		187
+115	2835.5659047181393		273
+116	2866.9461104108673		57
+117	2881.5004771819836		117
+118	2909.6427615774414		109
+119	2619.34037497993		258
+120	2939.450458844306		263
+121	2906.4929038275664		204
+122	2948.7314221542797		121
+123	2953.9094434325502		74
+124	2985.440838469254		88
+125	2975.29695996887		115
+126	2954.414493601059		126
+127	2896.9544352647317		185
+128	2949.3024599047144		314
+129	2910.3683615652503		209
+130	2979.817444072707		119
+131	3028.992076582572		177
+132	2808.3669632012125		177
+133	3073.615623333536		128
+134	3060.4393475447278		151
+135	3086.498663534459		133
+136	2561.4052783579564		312
+137	3126.1601046651467		227
+138	2979.8711381534604		198
+139	3155.1700429612347		90
+140	3151.571195451564		231
+141	3164.168927222439		154
+142	3129.1259162903625		232
+143	2847.00140498736		255
+144	3187.418077378617		219
+145	3138.7672739468912		97
+146	3195.2003067100504		89
+147	3194.6325297285757		158
+148	3195.955099809758		204
+149	3237.0166820700815		62
+150	3255.597180242052		127
+151	3254.93502239292		60
+152	3281.352160314403		73
+153	3279.3377380196753		125
+154	3255.6776560341473		152
+155	3271.2471627805808		279
+156	3247.845439672276		82
+157	3326.7739628655268		29
+158	2729.1090121136604		144
+159	3286.8233904485955		142
+160	3261.8871838247255		153
+161	3328.385344277312		44
+162	3046.827366294323		49
+163	3154.2986542177646		184
+164	3295.002427920198		83
+165	3357.799874918099		76
+166	3378.6307877600357		39
+167	3370.5692397575813		30
+168	3195.0414707793702		62
+169	2902.5402667318845		135
+170	3258.0098219618676		41
+171	3262.259952854769		26
+172	3422.502739224616		116
+173	3417.901402907931		66
+174	3439.523368142743		108
+175	3349.7058079777694		59
+176	3029.6093807618167		19
+177	3441.201679646225		19
+178	3409.1941863144143		224
+179	2929.2353951159334		19
+180	2900.2127508167396		26
+181	2828.9547539683276		18
+182	2834.0869781995048		17
+183	2761.479675825987		42
+184	2820.7943916563645		30
+191	3317.3273881243617		4
+192	3322.925969683947		1
+193	3360.9024085801716		3
+194	3392.7009888877624		14
+196	3491.7183448840774		98
+197	3560.370767209505		113
+199	3481.1977823731877		22
+200	3588.148547649609		76
+201	3452.222617387239		31
+202	3451.376536977674		53
+203	3230.5573822484566		111
+204	3113.641758455844		67
+205	2726.8489140397933		53
+206	2873.5044805950797		108
+207	3104.405418111494		43
+208	3249.613515481495		32
+209	3475.2795571004067		108
+210	3639.9057680110345		80
+211	3325.2151810070877		57
+212	2884.218091615126		33
+213	2920.3643608289703		13
+214	2906.8321244956683		2
+215	2813.3490718359144		27
+216	2939.36336644519		60
+217	3755.401043830073		69
+218	3585.3395933997663		86
+219	3758.964219036941		85
+220	3790.129945001886		122
+221	3810.992521640524		172
+222	3792.3610060225014		23
+223	3815.631009413777		26
+224	3795.2923471058193		16
+225	3826.4825884877614		69
+226	3831.510668130783		54
+227	3832.1638795855274		156
+228	3833.123269606653		120
+229	3859.508388383163		141
+230	3830.84912258366		86
+231	3783.793995449541		158
+232	3746.1261324199963		184
+233	2863.6000069842157		37
+236	2678.195287875774		32
+115	7887.098642720275		1
+116	9958.89833264704		1
+124	5461.392679527814		1
+126	8508.168428046074		1
+135	2830.58244889634		7
+137	4313.037096988617		1
+140	3420.4585949840116		1
+141	3163.25923692637		7
+142	3149.401212929213		43
+143	3176.547339486695		42
+144	3058.668010752393		23
+145	3126.600230282087		10
+146	3120.9783722416278		24
+147	3145.5927899205262		21
+148	3099.849351178215		16
+149	3050.773016794268		30
+150	2843.040801676965		15
+151	2624.4180307260503		19
+152	3056.6098867863398		125
+153	2468.258090232867		21
+154	2355.969651757		21
+155	2702.4124407647328		32
+156	2982.131452501717		24
+157	3142.504256162591		21
+158	3265.692269642074		28
+159	3282.8310952590905		6
+160	3261.3567728784287		5
+161	3274.0054978573266		11
+162	3332.2054258403696		15
+163	3361.016661666526		3
+164	3355.109089135553		14
+165	3373.971102425153		20
+166	3259.075482402947		7
+167	3265.9854561831717		10
+169	3411.079741079062		17
+170	3398.256611852613		37
+171	3409.9420816195693		33
+172	3456.7860795831725		82
+173	3373.551392820332		8
+174	3336.6609057559326		7
+175	3430.284244782056		15
+176	3437.843510109208		76
+177	3458.1489268104115		281
+178	3477.0933263287598		38
+179	3252.7631330916183		13
+180	3240.0327158842083		9
+181	3159.548227199579		60
+182	3040.0726964992136		77
+184	3227.447288492873		11
+186	3130.8784709726438		1
+187	3295.738460497131		2
+188	3356.7450007410453		26
+189	3489.3794577259723		114
+190	3467.191514756576		29
+191	3003.702382061179		30
+192	3060.0434637436115		34
+193	2897.203134058777		78
+194	2949.2990692705275		26
+195	3061.7589715717336		37
+196	3085.414720908682		39
+197	3373.3670123483453		109
+198	3590.769416155819		47
+199	3188.3251088933825		3
+200	3185.424932406978		15
+201	9721.27075026717		1
+225	2838.9635432671553		12
+228	9773.704773523703		1
+253	3503.388645297578		26
+254	3524.6476419636615		4
+124	5461.392679527814		1
+126	8508.168428046074		1
+141	6587.192725281385		1
+142	7665.473892721832		1
+149	9875.263895208067		1
+154	7029.594867415903		1
+157	7155.990497478319		1
+159	7350.145372712025		1
+172	5135.193180397404		1
+174	3431.546152975361		6
+175	3497.8764986774477		14
+176	3311.0096647397454		23
+177	3389.6768282536905		36
+178	3468.8963662813567		13
+179	3485.865889560297		37
+180	3490.3886603070437		113
+181	3515.5905620535505		98
+182	3499.1920496023076		15
+183	3419.91418020979		18
+184	3187.2913265028033		64
+185	3123.9286163419292		57
+195	3615.2654121101536		88
+196	3637.733635108541		62
+197	3628.236210612534		156
+198	3661.8806643581383		4
+199	3664.0061408245483		76
+200	3677.116261420082		12
+201	3637.3748775731106		146
+202	3685.892700554372		53
+203	3635.77777098656		56
+205	3716.556605246313		8
+206	3684.0620244507286		15
+207	3715.699799499416		30
+208	3468.918707609044		5
+209	3690.992549437075		16
+210	3509.5711988788603		26
+211	3555.6774319389547		26
+212	3433.242199437727		52
+213	3586.7179983935175		15
+214	3585.6561463698663		10
+215	3746.0168179013826		40
+216	3784.0027748404204		267
+217	3786.887112127849		70
+218	3689.460258628625		10
+219	3681.7335590724106		7
+220	3526.8682992139074		20
+221	3674.9727890149065		28
+222	3664.5142925086266		24
+223	3634.4388837893534		57
+224	3824.525199289449		80
+225	3828.2075440080307		63
+226	3813.7278350716115		126
+227	3816.3041021386125		227
+228	9773.704773523703		2
+229	3870.390807140798		48
+230	3793.3906996248093		27
+286	3049.217932519747		3
+287	2999.563301549077		1
+288	2918.4139528175233		2
+289	2928.8649678672455		1
+290	2923.3942601024582		1
+291	2926.6731966517887		1
+292	3092.7083599977545		12
+293	3092.7083599977545		53
+294	3101.7430583463874		28
+295	2832.8236796525125		40
+296	2666.3600657075553		5
+297	2658.3432810681165		14
+298	2840.7354681490497		2
+299	2840.7354681490497		9
+300	2840.7354681490497		2
+301	2840.7354681490497		4
+302	2840.7354681490497		63
+322	3771.882951524344		154
+323	3668.3926998073694		55
+324	3601.816902620121		2
+325	3550.685708423093		49
+195	9346.260482139367		1
+196	7269.414075425887		1
+251	3926.380139517823		7
+252	3995.193362028927		19
+253	3979.0382003695313		11
+254	2999.2432378851836		13
+256	3046.871510254412		16
+257	3030.115674359644		1
+195	9346.260482139367		1
+276	3564.1046561513876		2
+277	3713.46266980025		16
+278	3981.4374288691265		52
diff --git a/reversing_game_mechanics/zoomlevel/win.size.all.filtered b/reversing_game_mechanics/zoomlevel/win.size.all.filtered
new file mode 100644
index 0000000..b1abb5b
--- /dev/null
+++ b/reversing_game_mechanics/zoomlevel/win.size.all.filtered
@@ -0,0 +1,227 @@
+49	2120.5192760265113		245
+50	1969.829688069504		88
+51	1907.5106814904077		196
+56	2251.943604977709		106
+57	2004.575765592311		166
+58	2109.127781809343		362
+59	2126.4564420650613		137
+61	2173.5730951592127		58
+63	2232.8013794334684		39
+64	2133.3471353720192		71
+65	2239.5713875650404		100
+66	2259.5827048373335		868
+67	2240.224319125208		818
+68	2307.553032976707		443
+69	2226.5634956138124		579
+70	2356.425258734085		336
+71	2293.2538019155227		397
+72	2249.2098612623945		273
+73	2331.4519081465096		451
+74	2392.639755583778		300
+75	2404.2996901384818		277
+76	2403.8011565019265		161
+77	2357.5313359529287		262
+78	2377.4242364374095		157
+79	2339.8472172344927		145
+80	2438.0258407162137		228
+81	2488.3331770484433		301
+82	2489.7003835803216		352
+83	2499.0544211761376		291
+84	2455.6426857342253		304
+85	2498.9455776386967		154
+87	2474.5797623030867		702
+90	2515.553616999646		238
+91	2614.3163542310635		207
+92	2594.101771326638		66
+93	2544.643000501249		67
+94	2651.225377066235		95
+95	2681.96290056369		148
+96	2685.0344504307577		170
+97	2679.5546271722096		426
+98	2693.4938277263605		569
+99	2726.821592990638		54
+100	2696.036349903317		53
+101	2704.8558187082726		56
+102	2754.743726737571		88
+103	2719.114010114324		180
+104	2791.1581825471662		122
+105	2794.8023185907086		84
+106	2803.209767391659		133
+107	2805.824121358999		90
+108	2796.2517769328283		250
+109	2803.5384784232942		261
+110	2837.5144052497776		142
+111	2835.092414719492		107
+112	2846.737255174773		63
+113	2877.452345391666		63
+114	2851.5078467365297		53
+115	2780.2778638114573		113
+116	2891.1260781916794		242
+117	2870.733878296628		69
+118	2892.3390188565377		88
+122	2913.41998345587		61
+123	2955.795155283938		28
+125	3029.202205201891		67
+126	3015.162516349658		39
+127	3024.4353191959653		64
+128	3046.6238691377707		139
+129	3020.514029101669		40
+130	3015.3225366451265		112
+131	3021.6586504765887		92
+132	3040.8763539479864		73
+133	3065.0941257977706		58
+135	3026.624522467232		98
+136	3013.2540550043236		84
+140	3049.6730972351775		42
+148	3144.616033794905		7
+149	3228.400223020684		11
+150	3220.1863300125974		71
+151	3248.3468103021264		119
+152	3253.712494981694		66
+153	3238.846245192877		57
+154	3176.819950831334		43
+155	3301.4617974467005		36
+156	3296.8477368541		132
+157	3316.3596005258537		113
+158	3286.2537942161434		155
+92	2602.3854441646417		92
+93	2641.4407053727327		16
+95	2708.966592632696		50
+96	2712.70344859146		186
+97	2601.976556389392		122
+98	2696.738771182704		66
+99	2717.4488035655795		96
+100	2664.1535241047955		169
+101	2756.752618571351		135
+102	2690.486944774124		169
+103	2757.303936819443		122
+104	2788.0634856473407		455
+105	2799.2456126606685		442
+106	2824.3450568229086		140
+107	2810.7694676013543		170
+108	2763.8178304656767		344
+109	2737.670725269933		72
+110	2784.720632307665		251
+111	2785.9047004519016		159
+112	2875.0377388827437		260
+113	2811.6308434785674		181
+114	2870.785606763417		187
+115	2835.5659047181393		273
+116	2866.9461104108673		57
+117	2881.5004771819836		117
+118	2909.6427615774414		109
+120	2939.450458844306		263
+121	2906.4929038275664		204
+122	2948.7314221542797		121
+123	2953.9094434325502		74
+124	2985.440838469254		88
+125	2975.29695996887		115
+126	2954.414493601059		126
+128	2949.3024599047144		314
+130	2979.817444072707		119
+131	3028.992076582572		177
+133	3073.615623333536		128
+134	3060.4393475447278		151
+135	3086.498663534459		133
+137	3126.1601046651467		227
+139	3155.1700429612347		90
+140	3151.571195451564		231
+141	3164.168927222439		154
+142	3129.1259162903625		232
+144	3187.418077378617		219
+145	3138.7672739468912		97
+146	3195.2003067100504		89
+147	3194.6325297285757		158
+148	3195.955099809758		204
+149	3237.0166820700815		62
+150	3255.597180242052		127
+151	3254.93502239292		60
+152	3281.352160314403		73
+153	3279.3377380196753		125
+154	3255.6776560341473		152
+155	3271.2471627805808		279
+156	3247.845439672276		82
+157	3326.7739628655268		29
+159	3286.8233904485955		142
+160	3261.8871838247255		153
+161	3328.385344277312		44
+164	3295.002427920198		83
+165	3357.799874918099		76
+166	3378.6307877600357		39
+167	3370.5692397575813		30
+172	3422.502739224616		116
+173	3417.901402907931		66
+174	3439.523368142743		108
+177	3441.201679646225		19
+178	3409.1941863144143		224
+197	3560.370767209505		113
+200	3588.148547649609		76
+217	3755.401043830073		69
+219	3758.964219036941		85
+220	3790.129945001886		122
+221	3810.992521640524		172
+222	3792.3610060225014		23
+223	3815.631009413777		26
+224	3795.2923471058193		16
+225	3826.4825884877614		69
+226	3831.510668130783		54
+227	3832.1638795855274		156
+228	3833.123269606653		120
+229	3859.508388383163		141
+230	3830.84912258366		86
+141	3163.25923692637		7
+142	3149.401212929213		43
+143	3176.547339486695		42
+145	3126.600230282087		10
+146	3120.9783722416278		24
+147	3145.5927899205262		21
+158	3265.692269642074		28
+159	3282.8310952590905		6
+160	3261.3567728784287		5
+161	3274.0054978573266		11
+162	3332.2054258403696		15
+163	3361.016661666526		3
+164	3355.109089135553		14
+165	3373.971102425153		20
+169	3411.079741079062		17
+170	3398.256611852613		37
+171	3409.9420816195693		33
+172	3456.7860795831725		82
+173	3373.551392820332		8
+175	3430.284244782056		15
+176	3437.843510109208		76
+177	3458.1489268104115		281
+178	3477.0933263287598		38
+189	3489.3794577259723		114
+198	3590.769416155819		47
+174	3431.546152975361		6
+175	3497.8764986774477		14
+177	3389.6768282536905		36
+178	3468.8963662813567		13
+179	3485.865889560297		37
+180	3490.3886603070437		113
+181	3515.5905620535505		98
+182	3499.1920496023076		15
+195	3615.2654121101536		88
+196	3637.733635108541		62
+197	3628.236210612534		156
+198	3661.8806643581383		4
+199	3664.0061408245483		76
+200	3677.116261420082		12
+201	3637.3748775731106		146
+202	3685.892700554372		53
+203	3635.77777098656		56
+205	3716.556605246313		8
+206	3684.0620244507286		15
+207	3715.699799499416		30
+209	3690.992549437075		16
+215	3746.0168179013826		40
+216	3784.0027748404204		267
+217	3786.887112127849		70
+224	3824.525199289449		80
+225	3828.2075440080307		63
+226	3813.7278350716115		126
+227	3816.3041021386125		227
+229	3870.390807140798		48
+252	3995.193362028927		19
+253	3979.0382003695313		11
diff --git a/reversing_game_mechanics/zoomlevel/win.size.gnuplot b/reversing_game_mechanics/zoomlevel/win.size.gnuplot
new file mode 100644
index 0000000..aa5499c
--- /dev/null
+++ b/reversing_game_mechanics/zoomlevel/win.size.gnuplot
@@ -0,0 +1,19 @@
+min(a,b)=(a<b)?a:b
+max(a,b)=(a>b)?a:b
+
+f(x) = a* x**b
+g(x) = aa* x**bb + cc
+fit f(x) "win.size.all.filtered" using 1:2 via a,b
+fit g(x) "win.size.all.filtered" using 1:2 via aa,bb,cc
+
+plot "win.size.1" using 1:2:(min(1,$3/100)) lt rgb "red" pt 2 ps variable, \
+     "win.size.2" using 1:2:(min(1,$3/100)) lt rgb "blue" pt 2 ps variable, \
+     "win.size.3" using 1:2:(min(1,$3/100)) lt rgb "green" pt 2 ps variable, \
+     "win.size.4" using 1:2:(1) lt rgb "purple" pt 2 ps variable, \
+     "win.size.5" using 1:2:(1) lt rgb "cyan" pt 2 ps variable, \
+     "win.size.6" using 1:2:(1) lt rgb "orange" pt 2 ps variable, \
+     x**0.4*460+50 lt rgb "gray", \
+     x**0.407*460-400 lt rgb "gray", \
+     f(x) lt rgb "black", \
+     g(x) lt rgb "black"
+pause -1
diff --git a/stats.py b/stats.py
index f850339..b263f01 100644
--- a/stats.py
+++ b/stats.py
@@ -1,36 +1,475 @@
 import time
+import math
+import random
+from collections import defaultdict
+import pickle
+from functools import reduce
+import mechanics
+import geometry
+#import numpy
+
+def fit_gaussian(l):
+    mean = sum(l) / len(l)
+    stddev = math.sqrt(sum(map(lambda v : (v-mean)**2, l)) / len(l))
+    return mean, stddev
+
+def flatten(l):
+    return reduce(lambda a,b:a+b, l)
+
+def quantile(values, q):
+    if isinstance(values, dict):
+        return quantile(flatten(map(lambda x : [x[0]]*x[1], sorted(values.items(),key=lambda x:x[0]))), q)
+    else:
+        try:
+            return sorted(values)[ int(len(values)*q) ]
+        except:
+            return 0
+
+def find_smallest_q_confidence_area(values, q):
+    """Calculates the (mid, delta) with the smallest delta, such that at least q * len(values)
+       lie within the interval [mid-delta, mid+delta]."""
+    try:
+        mid = min(values, key = lambda value : quantile(list(map(lambda x : abs(x-value), values)), q))
+        deviation = quantile(list(map(lambda x : abs(x-mid), values)),q)
+        #print(list(map(lambda x : abs(x-mid), values)))
+        return mid,deviation
+    except:
+        return 0,0
+
+def get_delta_confidence(values, mid, delta):
+    #"""Calculates which fraction of the values lie within [mid-delta, mid+delta]"""
+    #try:
+        return len(list(filter(lambda v : (mid-delta <= v and v <= mid+delta), values))) / len(values)
+    #except:
+    #    raise
+    #    return 0
+
+def avg(values):
+    if not isinstance(values, dict):
+        return sum(values)/len(values)
+    else:
+        return int(sum(map( lambda x : x[0]*x[1], values.items() )) / sum(map(lambda x : x[1], values.items())))
+
+def stddev(values):
+    a=avg(values)
+    return avg(list(map(lambda v : (v-a)**2, values)))
+
+def normalize(values):
+    a=avg(values)
+    return [x/a for x in values]
+
+class StatData():
+    pass
+
+def return_empty_list():
+    return []
+
+def return_defaultdict_with_empty_list():
+    return defaultdict(return_empty_list)
+
+def return_zero():
+    return 0
+
+def return_defaultdict_with_zeros():
+    return defaultdict(return_zero)
+
+class ReMerging:
+    def __init__(self, size1, size2, birth1, birth2, is_parent_child, begin_time):
+        self.size1 = size1
+        self.size2 = size2
+        self.birth1 = birth1
+        self.birth2 = birth2
+        self.is_parent_child = is_parent_child
+        self.begin_time = begin_time
+        self.end_time = None
 
 class Stats:
-    def __init__(self):
-        self.min_mass = 0
-        self.max_mass = 0
-        self.current_mass = 0
+    def __init__(self,c,data=None):
+        self.c = c
+
+        self.countdown = 27*20
+
+        if data == None:
+            self.data = StatData()
+            self.data.version = 4
+
+            self.data.min_mass = 0
+            self.data.max_mass = 0
+            self.data.current_mass = 0
+            
+            self.data.mass_history = []
+            self.data.pos_history = []
+            self.data.cell_aggressivity = {}
+            self.data.cell_split_frequency = {}
+            self.data.cell_defensiveness = {}
+
+            self.data.size_vs_speed = defaultdict(return_defaultdict_with_zeros)
+            self.data.size_vs_visible_window = defaultdict(return_defaultdict_with_empty_list)
+            self.data.mass_vs_visible_window = defaultdict(return_defaultdict_with_empty_list)
+
+            self.data.eject_distlogs = {"virus" : [], "split cell" : [], "ejected mass" : []}
+            self.data.eject_deviations = {"virus" : [], "virus2" : [], "virus3" : [], "split cell" : [], "ejected mass" : []}
+
+            self.data.observed_virus_sizes = defaultdict(return_zero)
+            self.data.remerging = {}
+        else:
+            self.data = data
         
-        self.mass_history = []
-        self.pos_history = []
-        self.cell_aggressivity = {}
-        self.cell_split_frequency = {}
-        self.cell_defensiveness = {}
+    def save(self,filename):
+        pickle.dump(self.data, open(filename,"wb"))
+
+    def load(filename):
+        return Stats(None, pickle.load(open(filename,"rb")))
+
+    def merge(self, filename):
+        data2 = pickle.load(open(filename,"rb"))
+        self.data.min_mass = min(self.data.min_mass, data2.min_mass)
+        self.data.max_mass = max(self.data.max_mass, data2.max_mass)
         
+        for i in data2.size_vs_visible_window:
+            for j in data2.size_vs_visible_window[i]:
+                self.data.size_vs_visible_window[i][j] += data2.size_vs_visible_window[i][j]
+        for i in data2.mass_vs_visible_window:
+            for j in data2.mass_vs_visible_window[i]:
+                self.data.mass_vs_visible_window[i][j] += data2.mass_vs_visible_window[i][j]
+
+        for i in data2.size_vs_speed:
+            for j in data2.size_vs_speed[i]:
+                self.data.size_vs_speed[i][j] += data2.size_vs_speed[i][j]
+
+        for i in data2.eject_deviations:
+            self.data.eject_deviations[i] += data2.eject_deviations[i]
+
+        for i in data2.eject_distlogs:
+            self.data.eject_distlogs[i] += data2.eject_distlogs[i]
+
+        for i in self.data.observed_virus_sizes:
+            self.data.observed_virus_sizes[i] += data2.observed_virus_sizes[i]
+
+        self.data.remerging.update(data2.remerging)
+
     def log_mass(self, mass):
-        self.mass_history.append((time.time(), mass))
-        self.current_mass = mass
-        if mass > self.max_mass:
-            self.max_mass = mass
-        if mass < self.min_mass:
-            self.min_mass = mass
+        self.data.mass_history.append((time.time(), mass))
+        self.data.current_mass = mass
+        if mass > self.data.max_mass:
+            self.data.max_mass = mass
+        if mass < self.data.min_mass:
+            self.data.min_mass = mass
     
     def log_pos(self, pos):
-        self.pos_history.append((time.time(), (pos[0], pos[1])))
+        self.data.pos_history.append((time.time(), (pos[0], pos[1])))
         
     def update_cell_aggressivity(self, cell, value):
-        self.cell_aggressivity[cell] = value
+        self.data.cell_aggressivity[cell] = value
         
     def update_cell_split_frequency(self, cell, value):
-        self.cell_split_frequency[cell] = value
+        self.data.cell_split_frequency[cell] = value
     
     def update_cell_defensiveness(self, cell, value):
-        self.cell_defensiveness[cell] = value
+        self.data.cell_defensiveness[cell] = value
         
     def get_last_steps(self, list, steps = 10):
-        return list[-steps:]
\ No newline at end of file
+        return list[-steps:]
+
+    def process_frame(self):
+        self.countdown -= 1
+        if False and (self.countdown <= 0):
+            quick_followup = (random.random() < 0.1)
+            
+            if quick_followup:
+                self.countdown = 7
+            else:
+                self.countdown = int(27* (random.random() * 15))
+
+            what_to_do = random.random()
+            if what_to_do < 0.2:
+                self.c.send_split()
+            else:
+                self.c.send_shoot()
+
+        self.log_pos(self.c.player.center)
+        self.log_mass(self.c.player.total_mass)
+        
+        cells = self.c.world.cells.values()
+        own_cells = list(self.c.player.own_cells)
+
+        own_total_size = sum( map(lambda cell : cell.size, own_cells) )
+        own_total_mass = sum( map(lambda cell : cell.mass, own_cells) )
+        n_own_cells = len(own_cells)
+
+        n = 3
+        for cell in filter(lambda cell : not cell.is_food and not cell.is_virus and not cell.is_ejected_mass, cells):
+            if hasattr(cell,'poslog') and len(cell.poslog) > n+1:
+                cellspeed = 0
+                for i in range(1,n+1):
+                    cellspeed += (cell.poslog[-i] - cell.poslog[-i-1]).len() / n
+                
+                cellspeed = int(cellspeed*10)/10
+                self.data.size_vs_speed[cell.size][cellspeed] += 1
+
+        visible_width = max( map(lambda cell : cell.pos.x - cell.size, cells) ) - min( map(lambda cell : cell.pos.x + cell.size, cells) )
+        visible_height = max( map(lambda cell : cell.pos.y - cell.size, cells) ) - min( map(lambda cell : cell.pos.y + cell.size, cells) )
+
+        self.data.size_vs_visible_window[n_own_cells][own_total_size].append((visible_width,visible_height))
+        self.data.mass_vs_visible_window[n_own_cells][own_total_mass].append((visible_width,visible_height))
+
+
+        # log virus sizes
+        for cell in cells:
+            if cell.is_virus:
+                self.data.observed_virus_sizes[cell.size] += 1
+        
+        # detect re-merging cells
+        for cell in own_cells:
+            for cell2 in own_cells:
+                if cell2 != cell:
+                    dist = (cell.pos - cell2.pos).len()
+                    expected_dist = cell.size + cell2.size
+                    min_dist = max(cell.size, cell2.size)
+
+                    if (dist < (0.9 * expected_dist + 0.1 * min_dist)):
+                        is_parent_child = (cell == cell2.parent or cell2 == cell.parent)
+                        print("cells seem to be merging! they are "+ ("" if is_parent_child else "NOT ") + "parent and child")
+                        pair_id = (min(cell.cid,cell2.cid), max(cell.cid,cell2.cid))
+                        
+                        if pair_id not in self.data.remerging:
+                            self.data.remerging[pair_id] = ReMerging(cell.size, cell2.size, cell.spawntime, cell2.spawntime, is_parent_child, self.c.world.time)
+                        else:
+                            self.data.remerging[pair_id].end_time = self.c.world.time
+                
+
+
+        # find ejected mass, split cells or viruses that have come to rest
+        for cell in cells:
+            if hasattr(cell,"parent") and cell.parent != None and not cell.calmed_down:
+                # we're only interested in cells with a parent set, because
+                # this also implies that we have tracked them since their
+                # creation.
+                # also, we're only interested in cells that are still flying
+                # as a result of being ejected/split.
+                
+                if not cell.is_food and not cell.is_ejected_mass and not cell.is_virus:
+                    expected_speed = mechanics.speed(cell.size)
+                    celltype = "split cell"
+                elif cell.is_virus:
+                    expected_speed = 1
+                    celltype = "virus"
+                elif cell.is_ejected_mass:
+                    expected_speed = 1
+                    celltype = "ejected mass"
+
+
+                if cell.movement.len() < expected_speed * 1.1:
+                    print(celltype+" has come to rest, nframes="+str(len(cell.poslog)))
+                    cell.calmed_down = True
+                    # TODO: speed log
+
+                    # distance is calculated naively
+                    distance = (cell.spawnpoint - cell.pos).len()
+
+                    # distance2 is calculated along the cell's path (will differ if the flight was not colinear)
+                    poslog = list(cell.poslog)
+                    speeds = list(map(lambda vecs : (vecs[0]-vecs[1]).len(), zip(poslog, poslog[1:])))
+                    distance2 = sum(speeds)
+
+                    distance_from_parent = (cell.parentpos_when_spawned - cell.pos).len()
+
+                    self.data.eject_distlogs[celltype] += [(distance, distance2, distance_from_parent, cell.parentsize_when_spawned, len(cell.poslog), speeds)]
+                    print("  flown distance = %.2f / %.2f"%(distance,distance2))
+
+                if len(cell.poslog) == 5:
+                    # calculate movement direction from the first 5 samples
+
+                    # first check whether they're on a straight line
+                    if geometry.is_colinear(cell.poslog) and cell.shoot_vec != None:
+                        print(celltype+" direction available!")
+                        fly_direction = cell.poslog[-1] - cell.poslog[0]
+                        fly_angle = math.atan2(fly_direction.y, fly_direction.x)
+
+                        shoot_angle = math.atan2(cell.shoot_vec.y, cell.shoot_vec.x)
+
+
+                        deviation = (fly_angle - shoot_angle) % (2*math.pi)
+                        if deviation > math.pi: deviation -= 2*math.pi
+                        print("  deviation = "+str(deviation*180/math.pi))
+
+                        self.data.eject_deviations[celltype] += [deviation]
+
+                        if (celltype == 'virus'):
+                            # FIXME so ugly
+                            try:
+                                shoot_angle = math.atan2(cell.shoot_vec2.y, cell.shoot_vec2.x)
+
+                                deviation = (fly_angle - shoot_angle) % (2*math.pi)
+                                if deviation > math.pi: deviation -= 2*math.pi
+                                print("  deviation2= "+str(deviation*180/math.pi))
+
+                                self.data.eject_deviations['virus2'] += [deviation]
+                            except AttributeError:
+                                print("virus2 not available, wtf?!")
+
+                            try:
+                                shoot_angle = math.atan2(cell.shoot_vec3.y, cell.shoot_vec3.x)
+
+                                deviation = (fly_angle - shoot_angle) % (2*math.pi)
+                                if deviation > math.pi: deviation -= 2*math.pi
+                                print("  deviation3= "+str(deviation*180/math.pi))
+
+                                self.data.eject_deviations['virus3'] += [deviation]
+                            except AttributeError:
+                                print("virus3 not available")
+
+                    else:
+                        print(celltype+" did NOT fly in a straight line, ignoring...")
+
+
+    
+    def analyze_speed(self):
+        results=[]
+        for size, values in sorted(self.data.size_vs_speed.items(), key=lambda x : x[0]):
+            minimum = quantile(values, 0.2)
+            average = quantile(values, 0.5)
+            maximum = quantile(values, 0.8)
+
+            results += [(size,maximum,average,minimum,False,False,False,sum(values.values()))]
+      
+        # mark outliers
+        for i in range(1, len(results)-1):
+            for j in range(1,4):
+                if abs(results[i][j] - results[i-1][j]) > 2 and abs(results[i][j] - results[i+1][j]) > 2:
+                    tmp = list(results[i])
+                    tmp[j+3] = True
+                    results[i] = tuple(tmp)
+
+        coeff_vs_stddev = []
+        for coeff in [x/100 for x in range(10,100,1)]:
+            products = []
+            for size, maximum, average, minimum, maxoutlier, avgoutlier, minoutlier, ndata in results:
+                if not maxoutlier:
+                    products += [size**coeff * maximum]
+            
+            coeff_vs_stddev += [(coeff, avg(products), stddev(normalize(products)))]
+
+        best = min(coeff_vs_stddev, key=lambda v:v[2])
+
+        print("size\tcalc\tmax\tavg\tmin\t\tndata")
+        for size, maximum, average, minimum, maxoutlier, avgoutlier, minoutlier, ndata in results:
+            print(str(size) + ":\t" + "%.1f" % (best[1] / size**best[0]) + "\t" + ("*" if maxoutlier else "") + str(maximum) + "\t" + ("*" if avgoutlier else "") + str(average) + "\t" + ("*" if minoutlier else "") + str(minimum) + "\t\t" + str(ndata))
+        
+        print("size**"+str(best[0])+" * speed = "+str(best[1])  )
+
+    def analyze_visible_window_helper(self, foo_vs_visible_window, verbose=False):
+        svw = {}
+        ratios = []
+        if verbose: print("size\tdiag")
+        for size, rects in sorted(foo_vs_visible_window.items(), key=lambda x:x[0]):
+            maxwidth = quantile(sorted(map(lambda x:x[0], rects)), 0.75)
+            maxheight = quantile(sorted(map(lambda x:x[1], rects)), 0.75)
+            
+            if math.sqrt(maxwidth**2+maxheight**2) < 4000:
+                # TODO FIXME
+                svw[size] = (maxwidth,maxheight)
+            ratios += [maxwidth/maxheight]
+        
+            if verbose: print(str(size)+"\t"+str(math.sqrt(maxwidth**2+maxheight**2))+"\t\t"+str(len(rects)))
+        
+        print ("median ratio = "+str(quantile(sorted(ratios),0.5)))
+
+        coeff_vs_stddev=[]
+        for coeff in [x/100 for x in range(0,100,1)]:
+            quotients = []
+            for size, rect in svw.items():
+                if size != 0:
+                    diag = math.sqrt(rect[0]**2+rect[1]**2)
+                    quotients += [diag / size**coeff]
+            
+            coeff_vs_stddev += [(coeff, avg(quotients), stddev(normalize(quotients)))]
+
+        best = min(coeff_vs_stddev, key=lambda v:v[2])
+
+        print("diag / size**"+str(best[0])+" = "+str(best[1]))
+
+    def analyze_visible_window(self, verbose=False):
+        for ncells in sorted(self.data.size_vs_visible_window.keys()):
+            if len(self.data.size_vs_visible_window[ncells]) > 0:
+                print("\nwith "+str(ncells)+" cells, depending on sum(size)")
+                try:
+                    self.analyze_visible_window_helper(self.data.size_vs_visible_window[ncells], verbose)
+                except ZeroDivisionError:
+                    print("\toops.")
+        for ncells in sorted(self.data.mass_vs_visible_window.keys()):
+            if len(self.data.mass_vs_visible_window[ncells]) > 0:
+                print("\nwith "+str(ncells)+" cells, depending on sum(mass)")
+                try:
+                    self.analyze_visible_window_helper(self.data.mass_vs_visible_window[ncells], verbose)
+                except ZeroDivisionError:
+                    print("\toops.")
+
+    def analyze_deviations(self, celltype):
+        ds = self.data.eject_deviations[celltype]
+
+        try:
+            mean, stddev = fit_gaussian(ds)
+        except:
+            mean, stddev = "???", "???"
+
+
+        quant = quantile(list(map(abs, ds)), 0.75)
+
+        print(celltype+" eject/split direction deviations: mean = "+str(mean)+", stddev="+str(stddev)+", ndata="+str(len(ds)))
+        print("\t75%% of the splits had a deviation smaller than %.2f rad = %.2f deg" % (quant, quant*180/math.pi))
+        print("")
+        
+
+        #a,b = numpy.histogram(ds, bins=100)
+        #midpoints = map(lambda x : (x[0]+x[1])/2, zip(b, b[1:]))
+        #for n,x in zip(a,midpoints):
+        #    print(str(n) + "\t" + str(x))
+
+    def analyze_distances(self, celltype):
+        ds = [v[0] for v in self.data.eject_distlogs[celltype]]
+        ns = [v[4] for v in self.data.eject_distlogs[celltype]]
+
+        try:
+            mean, stddev = fit_gaussian(ds)
+            meann, stddevn = fit_gaussian(ns)
+        except:
+            mean, stddev = "???", "???"
+            meann, stddevn = "???", "???"
+
+        print(celltype+" eject/split distances: mean  = "+str(mean) +", stddev  ="+str(stddev) +", ndata="+str(len(ds)))
+        print(celltype+"                        meann = "+str(meann)+", stddevn ="+str(stddevn))
+        
+        #a,b = numpy.histogram(ds, bins=100)
+        #midpoints = list(map(lambda x : (x[0]+x[1])/2, zip(b, b[1:])))
+        #for n,x in zip(a,midpoints):
+        #    print(str(n) + "\t" + str(x))
+
+        #maxidx = max(range(0,len(a)), key = lambda i : a[i])
+        #print("\tmaximum at "+str(midpoints[maxidx]))
+
+        #q = 75 if celltype == "ejected mass" else 75
+        #quant = quantile(list(map(lambda v : abs(v-midpoints[maxidx]), ds)), q/100)
+        #print("\t"+str(q)+"% of values lie have a distance of at most "+str(quant)+" from the maximum")
+        
+        mid, delta = find_smallest_q_confidence_area(ds, 0.75)
+        print("\t75%% of the distances lie in the interval %.2f plusminus %.2f" % (mid,delta))
+        print("\t%2d%% of the distances lie in the interval %.2f plusminus %.2f" % (100*get_delta_confidence(ds, mid, delta*1.2), mid, delta*1.2) )
+        print("\tmax = %.2f" % (max(ds)))
+        mid, delta = find_smallest_q_confidence_area(ns, 0.75)
+        print("\t75%% of the flight lengths lie in the interval %.2f plusminus %.2f" % (mid,delta))
+        print("\t%2d%% of the flight lengths lie in the interval %.2f plusminus %.2f" % (100*get_delta_confidence(ns,mid,delta*1.2),mid,delta*1.2))
+        print("")
+
+    def analyze_virus_sizes(self):
+        print("\nI've seen the following %d virus sizes:" % len(self.data.observed_virus_sizes))
+        for size, ndata in sorted(self.data.observed_virus_sizes.items(), key=lambda x:x[0]):
+            print("\t%4d: %7d times" % (size, ndata))
+
+    def analyze_remerge(self):
+        relevant = list(filter(lambda r : r.is_parent_child, self.data.remerging.values()))
+        durations = list(map(lambda r : r.end_time - r.begin_time, relevant))
+        print("75%% of the remerge durations lie at %.2f plusminus %.2f frames" % find_smallest_q_confidence_area(durations,0.75))
+        waittimes = list(map(lambda r : r.begin_time - max(r.birth1, r.birth2), relevant))
+        print("75%% of the remerges were started after %.2f plusminus %.2f frames" % find_smallest_q_confidence_area(waittimes,0.75))
+        
diff --git a/strategy.py b/strategy.py
index 0d2d8f0..3d5721a 100644
--- a/strategy.py
+++ b/strategy.py
@@ -1,15 +1,25 @@
 import math
 from interval_utils import *
-import gui
 import random
+import nogui
+import mechanics
+
+friendly_players=["Windfisch","windfisch","Cyanide","cyanide"] +\
+    ["Midna","Nayru","Farore","Din","Ezelo","Navi","Zelda","Tetra","Link","Ciela","Linebeck","Salia","Epona","Shiek"] +\
+    ["Vaati","Ganon","Ganondorf","Ghirahim","Agahnim"]
 
 class Strategy:
-    def __init__(self, c):
+    def __init__(self, c, gui=None):
         self.target = (0,0)
         self.has_target = False
         self.target_cell = None
         self.color = (0,0,0)
         self.c = c
+        self.do_approach_friends = True
+        if gui != None:
+            self.gui = gui
+        else:
+            self.gui = nogui
     
     def get_my_smallest(self):
         return sorted(self.c.player.own_cells, key = lambda x: x.mass)[0]
@@ -43,9 +53,12 @@ class Strategy:
     def nonsplitkiller(self, cell):
         return not cell.is_virus and not cell.is_food and 1.20*self.get_my_smallest().mass < cell.mass and cell.mass < 1.25*2*self.get_my_smallest().mass
     
-    def quality(self, cell):
+    def quality(self, cell, myspeed):
         dd_sq = max((cell.pos[0]-self.c.player.center[0])**2 + (cell.pos[1]-self.c.player.center[1])**2,0.001)
-        sigma = 500
+        sigma = 500 * max(cell.mass,1) # TODO FIXME don't try to eat running away cells
+        if mechanics.speed(cell) - myspeed >= 0:
+            sigma = sigma / 3 / math.exp((mechanics.speed(cell)-myspeed)/10)
+
         dist_score = -math.exp(-dd_sq/(2*sigma**2))
 
         rivals = filter(lambda r : self.rival(r,cell), self.c.world.cells.values())
@@ -105,21 +118,123 @@ class Strategy:
     def process_frame(self):
         runaway = False
         
-        my_smallest = min(map(lambda cell : cell.mass, self.c.player.own_cells))
-        my_largest = max(map(lambda cell : cell.mass, self.c.player.own_cells))
+        my_smallest = min(self.c.player.own_cells, key=lambda cell : cell.mass)
+        my_largest =  max(self.c.player.own_cells, key=lambda cell : cell.mass)
+
+        friendly_cells = list(filter(lambda c : c.is_virus or c.name in friendly_players, self.c.world.cells.values()))
+
+        if friendly_cells:
+            dist_to_friend = min(map(lambda c : (self.c.player.center-c.pos).len() - max(my_largest.size, c.size), friendly_cells))
+        else:
+            dist_to_friend = float('inf')
+
+        if dist_to_friend < 20 or my_largest.mass < 36:
+            if self.do_approach_friends: print("not approaching friends")
+            self.do_approach_friends = False
+        elif dist_to_friend > 200 and my_largest.mass > 36 + 10*16:
+            if not self.do_approach_friends: print("approaching friends")
+            self.do_approach_friends = True
+
+        if friendly_cells and self.do_approach_friends:
+            friend_to_feed = max(friendly_cells, key=lambda c:c.mass)
+            if friend_to_feed.mass < 1.25 * my_largest.mass:
+                print("friend too small")
+                friend_to_feed = None
+            if friend_to_feed:
+                self.gui.hilight_cell(friend_to_feed, (255,255,255),(255,127,127),30)
+
+                self.target_cell = friend_to_feed
+                self.has_target = True
+        
+        if self.do_approach_friends:
+            for c in self.c.player.own_cells:
+                self.gui.hilight_cell(c, (255,255,255), (255,127,127), 20)
+        
+        # can this cell feed that cell?
+        # "False" means "No, definitely not"
+        # "True" means "Maybe"
+        def can_feed(this, that):
+            if that.is_food or that.is_ejected_mass or that.size < 43: # too small cells cannot eat the ejected mass
+                return False
+
+            relpos = this.pos-that.pos
+            dist = relpos.len()
+            if dist == 0 or dist >= 700 + this.size + that.size:
+                return False
+            
+            return check_cell_in_interval(this.pos, that, (this.movement_angle - 10*math.pi/180, this.movement_angle + 10*math.pi/180))
+
+
+        success_rate = 0
+        for my_cell in self.c.player.own_cells:
+            try:
+                my_cell.movement_angle
+            except AttributeError:
+                print("cannot calculate shoot angle, too few backlog")
+                continue
+            # check if ejecting mass would feed a friend
+            possibly_feedable_cells = list(filter(lambda c : can_feed(my_cell, c), self.c.world.cells.values()))
+            possibly_feedable_cells.sort(key = lambda c : (my_cell.pos - c.pos).len())
 
+            good_intervals = []
+            for feedable in possibly_feedable_cells:
+                self.gui.hilight_cell(feedable, (255,192,127), (127,127,255))
+                if feedable not in friendly_cells:
+                    break
 
-        # enemy/virus avoidance
+                good_intervals += canonicalize_angle_interval( interval_occupied_by_cell(my_cell.pos, feedable) )
+
+            good_intervals = merge_intervals(good_intervals)
+            area = interval_area( intersection(good_intervals, canonicalize_angle_interval((my_cell.movement_angle - mechanics.eject_delta*math.pi/180, my_cell.movement_angle + mechanics.eject_delta*math.pi/180))) )
+            success_rate += area / (2*mechanics.eject_delta*math.pi/180) / len(list(self.c.player.own_cells))
+
+
+        self.gui.draw_bar(((100,40),(500,24)), success_rate, thresh=.80, color=(0,0,127))
+        if success_rate >= 0.80:
+            self.c.send_shoot()
+                
+                
+
+        # enemy/virus/friend-we-would-kill avoidance
         forbidden_intervals = []
         for cell in self.c.world.cells.values():
             relpos = ((cell.pos[0]-self.c.player.center[0]),(cell.pos[1]-self.c.player.center[1]))
             dist = math.sqrt(relpos[0]**2+relpos[1]**2)
 
-            if (not cell.is_virus and dist < ((500+2*cell.size) if cell.mass > 1.25*my_smallest*2 else (300+cell.size)) and  cell.mass > 1.25 * my_smallest) or (cell.is_virus and dist < my_largest and cell.mass < my_largest):
-                angle = math.atan2(relpos[1],relpos[0])
-                corridor_halfwidth = math.asin(cell.size / dist)
-                forbidden_intervals += canonicalize_angle_interval((angle-corridor_halfwidth, angle+corridor_halfwidth))
-                runaway = True
+            # find out the allowed minimum distance
+            allowed_dist = None
+            
+            if cell.is_virus:
+                if cell.mass < my_largest.mass:
+                    allowed_dist = cell.size+2
+                else:
+                    allowed_dist = "don't care"
+            elif cell in friendly_cells:
+                if 1.25 * my_largest.mass > cell.mass: # we're dangerous to our friends
+                    allowed_dist = my_largest.size + 40
+            elif (cell not in self.c.player.own_cells and not cell.is_virus and not cell.is_ejected_mass and not cell.is_food) and cell.mass + 20 > 1.25 * my_smallest.mass: # our enemy is, or will be dangerous to us
+                if (cell.mass + 20) / 2 < 1.25 * my_smallest.mass:
+                    # they can't splitkill us (soon)
+                    allowed_dist = cell.size + 75
+                elif cell.mass / 15. < self.c.player.total_mass:
+                    # they can and they will splitkill us
+                    allowed_dist = 650 + cell.size
+                else:
+                    # we're too small, not worth a splitkill. they have absolutely no
+                    # chance to chase us
+                    allowed_dist = cell.size + 10
+            else:
+                allowed_dist = "don't care"
+
+            if allowed_dist != "don't care" and dist < allowed_dist:
+                try:
+                    angle = math.atan2(relpos[1],relpos[0])
+                    corridor_halfwidth = math.asin(min(1, cell.size / dist))
+                    forbidden_intervals += canonicalize_angle_interval((angle-corridor_halfwidth, angle+corridor_halfwidth))
+                    runaway = True
+                except:
+                    print("TODO FIXME: need to handle enemy cell which is in our centerpoint!")
+                    print("dist=%.2f, allowed_dist=%.2f" % (dist, allowed_dist))
         
         # wall avoidance
         if self.c.player.center[0] < self.c.world.top_left[1]+(self.c.player.total_size*2):
@@ -138,8 +253,13 @@ class Strategy:
             forbidden_intervals = merge_intervals(forbidden_intervals)
 
             allowed_intervals = invert_angle_intervals(forbidden_intervals)
+            
+            try:
+                (a,b) = find_largest_angle_interval(allowed_intervals)
+            except:
+                print("TODO FIXME: need to handle no runaway direction being available!")
+                (a,b) = (0,0)
 
-            (a,b) = find_largest_angle_interval(allowed_intervals)
             runaway_angle = (a+b)/2
             runaway_x, runaway_y = (self.c.player.center[0]+int(100*math.cos(runaway_angle))), (self.c.player.center[1]+int(100*math.sin(runaway_angle)))
             
@@ -148,27 +268,25 @@ class Strategy:
             self.target_cell = None
             
             self.color = (255,0,0)
-            print ("Running away: " + str((runaway_x-self.c.player.center[0], runaway_y-self.c.player.center[1])))
             
             # a bit of debugging information
             for i in forbidden_intervals:
-                gui.draw_arc(self.c.player.center, self.c.player.total_size+10, i, (255,0,255))
+                self.gui.draw_arc(self.c.player.center, self.c.player.total_size+10, i, (255,0,255))
 
-        # if however there's no enemy to avoid, chase food or jizz randomly around
-        else:          
+        # if however there's no enemy to avoid, try to feed a friend. or chase food or jizz randomly around
+        else:
             if self.target_cell != None:
                 self.target = tuple(self.target_cell.pos)
-                if self.target_cell not in self.c.world.cells.values() or not self.edible(self.target_cell):
+                if self.target_cell not in self.c.world.cells.values() or (not self.edible(self.target_cell) and not self.target_cell in friendly_cells):
                     self.target_cell = None
                     self.has_target = False
-                    print("target_cell does not exist any more")
             elif self.target == tuple(self.c.player.center):
                 self.has_target = False
                 print("Reached random destination")
             
             if not self.has_target:
                 food = list(filter(self.edible, self.c.world.cells.values()))
-                food = sorted(food, key = self.quality)
+                food = sorted(food, key = lambda c : self.quality(c, mechanics.speed(my_largest)))
                 
                 if len(food) > 0:
                     self.target = (food[0].pos[0], food[0].pos[1])
@@ -176,8 +294,6 @@ class Strategy:
                     
                     self.has_target = True
                     self.color = (0,0,255)
-                    print("weight: ", self.weight_cell(self.target_cell))
-                    print("Found food at: " + str(food[0].pos))
                 else:
                     rx = self.c.player.center[0] + random.randrange(-400, 401)
                     ry = self.c.player.center[1] + random.randrange(-400, 401)
@@ -188,6 +304,6 @@ class Strategy:
         
 
         # more debugging
-        gui.draw_line(self.c.player.center, self.target, self.color)
+        self.gui.draw_line(self.c.player.center, self.target, self.color)
         
         return self.target
diff --git a/subscriber.py b/subscriber.py
index a637e67..b89a6a9 100644
--- a/subscriber.py
+++ b/subscriber.py
@@ -1,5 +1,7 @@
 from log import log
+from collections import deque
 import sys
+import mechanics
 
 class DummySubscriber:
     def on_connect_error(self,s):
@@ -65,3 +67,191 @@ class DummySubscriber:
     def on_debug_line(self,x,y):
         log("debug line")
 
+class CellHistory:
+    def __init__(self):
+        self.poslog = deque(maxlen=300)
+        self.stale = False
+
+class OtherPlayer:
+    def __init__(self, playerid):
+        self.playerid = playerid
+        self.cells = set()
+
+class EnhancingSubscriber(DummySubscriber):
+    def __init__(self):
+        self.c = None
+        self.history = {}
+        self.time = 0
+        self.victims = {}
+
+    def set_client(self,c):
+        self.c = c
+
+    def cleanup_victims(self):
+        delete = []
+
+        for eater in self.victims:
+            self.victims[eater] = list(filter(lambda v : v[1] < self.time - 100, self.victims[eater]))
+            if len(self.victims[eater]) == 0:
+                delete += [eater]
+
+        for eater in delete:
+            del self.victims[eater]
+    
+    def on_cell_eaten(self, eater_id, eaten_id):
+        if eater_id in self.c.world.cells and self.c.world.cells[eater_id].is_virus:
+            print("virus ate something!")
+        
+        if eater_id not in self.victims:
+            self.victims[eater_id] = []
+
+        self.victims[eater_id] += [(self.c.world.cells[eaten_id], self.time)]
+
+    def on_world_update_post(self):
+        self.c.world.time = self.time
+        self.time += 1
+
+        if self.time % 100 == 0:
+            self.cleanup_victims()
+
+        # create and purge poslog history, movement and movement_angle
+        for cid in self.history:
+            self.history[cid].stale = True
+
+        for cid in self.c.world.cells:
+            if cid not in self.history:
+                self.history[cid] = CellHistory()
+            
+            self.history[cid].poslog.append(self.c.world.cells[cid].pos.copy())
+            self.c.world.cells[cid].poslog = self.history[cid].poslog
+            
+            self.history[cid].stale = False
+
+        self.history = {k: v for k, v in self.history.items() if v.stale == False}
+        
+
+        for cid in self.c.world.cells:
+            cell = self.c.world.cells[cid]
+
+            if not hasattr(cell, "spawntime"):
+                cell.spawntime = self.c.world.time
+
+            try:
+                oldpos = cell.poslog[-3-1]
+                cell.movement = (cell.pos - oldpos)/3
+                cell.movement_angle = cell.movement.angle()
+            except (AttributeError, IndexError):
+                pass
+
+
+        # create OtherPlayer entries
+        otherplayers = {}
+        for cell in self.c.world.cells.values():
+            playerid = None
+            if not cell.is_food and not cell.is_ejected_mass and not cell.is_virus:
+                playerid = (cell.name, cell.color)
+            elif cell.is_virus:
+                playerid = "virus"
+            elif cell.is_food:
+                playerid = "food"
+            elif cell.is_ejected_mass:
+                playerid = "ejected mass"
+            else:
+                playerid = "???"
+
+            if playerid not in otherplayers:
+                otherplayers[playerid] = OtherPlayer(playerid)
+
+            cell.player = otherplayers[playerid]
+            cell.player.cells.add(cell)
+
+        # detect split cells and clean up obsolete parent references
+        for cell in self.c.world.cells.values():
+            # create attribute if not already there
+            try:
+                cell.parent = cell.parent
+            except:
+                cell.parent = None
+                cell.calmed_down = True
+
+            # clean up obsolete parent references
+            if cell.parent and cell.parent.cid not in self.c.world.cells:
+                cell.parent = None
+
+            # find split cells
+            is_split = False
+            if not cell.is_food and not cell.is_ejected_mass and not cell.is_virus:
+                try:
+                    if cell.parent == None and cell.movement.len() > 2 * mechanics.speed(cell.size):
+                            print("looks like a split!"+str(cell.movement.len() / mechanics.speed(cell.size)))
+                            is_split = True
+                except AttributeError:
+                    pass
+
+                if is_split:
+                    history_len = len(cell.poslog)
+                    cell.parent = min(cell.player.cells, key=lambda c : (c.poslog[-history_len] - cell.poslog[-history_len]).len() if c != cell and len(c.poslog) >= history_len else float('inf'))
+                    try:
+                        cell.shoot_vec = cell.parent.movement.copy()
+                    except:
+                        cell.shoot_vec = None
+                    cell.calmed_down = False
+
+            elif cell.is_virus:
+                try:
+                    if cell.parent == None and cell.movement.len() > 0:
+                            print("split virus!")
+                            is_split = True
+                except AttributeError:
+                    pass
+
+                if is_split:
+                    cell.parent = min(cell.player.cells, key=lambda c : (c.pos - cell.poslog[0]).len() if c != cell else float('inf'))
+                    try:
+                        last_feed = self.victims[cell.parent.cid][-1][0]
+                        if not last_feed.is_ejected_mass:
+                            print("wtf, last virus feed was not ejected mass?!")
+                            raise KeyError
+                        else:
+                            cell.shoot_vec  = cell.parent.pos - last_feed.poslog[0]
+                            cell.shoot_vec2 = last_feed.poslog[-1] - last_feed.poslog[0]
+                            try:
+                                pos_when_shot = last_feed.parent.poslog[-len(last_feed.poslog)]
+                                cell.shoot_vec3 = cell.parent.pos - pos_when_shot
+                            except:
+                                print("MOAAAHH")
+                                cell.shoot_vec3 = None
+                    except KeyError:
+                        print("wtf, no last virus feed?!")
+                        cell.shoot_vec  = None
+                        cell.shoot_vec2 = None
+                        cell.shoot_vec3 = None
+                        
+                    cell.calmed_down = False
+                
+            elif cell.is_ejected_mass:
+                try:
+                    if cell.parent == None and cell.movement.len() > 0:
+                            print("ejected mass!")
+                            is_split = True
+                except AttributeError:
+                    pass
+
+                if is_split:
+                    history_len = len(cell.poslog)
+                    try:
+                        cell.parent = min(filter(lambda c : not c.is_ejected_mass and not c.is_food and not c.is_virus and c.color == cell.color, self.c.world.cells.values()), key=lambda c : (c.poslog[-history_len] - cell.poslog[-history_len]).len() if len(c.poslog) >= history_len else float('inf'))
+                        try:
+                            cell.shoot_vec = cell.parent.movement.copy()
+                        except:
+                            cell.shoot_vec = None
+                        cell.calmed_down = False
+                    except ValueError:
+                        # if no possible parents are found, min will raise a ValueError. ignore that.
+                        pass
+
+            if is_split:
+                cell.spawnpoint = cell.pos.copy()
+                cell.parentsize_when_spawned = cell.parent.size if cell.parent != None else None
+                cell.parentpos_when_spawned = cell.parent.pos.copy() if cell.parent != None else None
+