diff --git a/chameleonic.p8 b/chameleonic.p8
index fb75cbe..68be32d 100644
--- a/chameleonic.p8
+++ b/chameleonic.p8
@@ -93,13 +93,13 @@ function _apply(x,ts,a)
  local t=deli(ts,1)
  for k,v in pairs(t) do
   if k=="update" then
-   if not v(x,a) then
-    add(ts,t,1)
-   end
+   --
   else
    x[k]=v
   end
  end
+
+ if (t and t.update and not t.update(x,a)) add(ts,t,1)
 end
 
 function sgn0(x)
@@ -112,29 +112,6 @@ function _mnmx(x,y)
  return x,y
 end
 
-function _rastn(
- x0,y0,x1,y1,dx,dy
-)
- -- todo: more optimized implementation?
- local iter=_rast(x0,y0,x1,y1)
- local prevx,prevy=nil,nil
-
- local done=false
- return function() 
-  while not done do
-   local x,y=iter()
-
-   if (x==nil) done=true return x1, y1
-
-   local x8 = x\dx
-   local y8 = y\dy
-   if not (x8==prevx and y8==prevy) then 
-    prevx,prevy=x8,y8
-    return x,y
-   end
-  end
- end
-end
 
 function _rast(
  x0,y0,x1,y1
@@ -157,7 +134,7 @@ function _rast(
    if (x==x1) done=true return x1,y1
    local oldx,oldy=x,y
    err-=dy
-   if (err<0) y+=sy err+=dx+dy return oldx,y
+   if (err<0) y+=sy err+=dx
    x+=sx
    return oldx,oldy
   end
@@ -168,17 +145,13 @@ function _rast(
    if (y==y1) done=true return x1,y1
    local oldx,oldy=x,y
    err-=dx
-   if (err<0) x+=sx err+=dy+dx return x,oldy
+   if (err<0) x+=sx err+=dy 
    y+=sy
    return oldx,oldy
   end
  end
 end
 
-function _point_eq(p1,p2)
- return p1.x==p2.x and p1.y==p2.y
-end
-
 -->8
 -- input
 kbd={}
@@ -228,6 +201,33 @@ function kbd:release(i)
  self.down&=~(1<<i)
 end
 
+function tostring(any)
+ if type(any)=="function" then 
+     return "function" 
+ end
+ if any==nil then 
+     return "nil" 
+ end
+ if type(any)=="string" then
+     return any
+ end
+ if type(any)=="boolean" then
+     if any then return "true" end
+     return "false"
+ end
+ if type(any)=="table" then
+     local str = "{ "
+     for k,v in pairs(any) do
+         str=str..tostring(k).."->"..tostring(v).." "
+     end
+     return str.."}"
+ end
+ if type(any)=="number" then
+     return ""..any
+ end
+  return "unknown" -- should never show
+end
+
 -->8
 -- title screen
 title={}
@@ -289,7 +289,7 @@ function level:reinit(n)
  self.todo={}
  self.bigx=(n%8)
  self.bigy=(n\8)
- self.cache_can_stretch=dcache:new()
+ self.next_crate_id=1
 
  self:load_dynobjs()
  self:recollide()
@@ -322,16 +322,16 @@ function level:draw()
    spr(pit.contents,pit.px,pit.py)
    pal()
    pal(1,0)
+  end
  end
  for _,crate in pairs(self._crates) do
   spr(crate.s,crate.px,crate.py)
-  end
  end
  pal()
 end
 
 function level:busy()
- for _,crate in pairs(self.crates) do
+ for _,crate in pairs(self._crates) do
   if (#crate.todo>0) return true 
  end
  return false
@@ -375,10 +375,12 @@ function level:load_dynobjs()
    if def then
     self._crates[mxy]={
      s=s,def=def,
+     id=self.next_crate_id,
      mx=mx,my=my,
      px=px,py=py,
      todo={}
     }
+    self.next_crate_id+=1
    end
 
    if s==28 then -- pit
@@ -403,67 +405,74 @@ function level:recollide()
     self._crates[mxy]!=nil
   end
  end
- self.cache_can_stretch:clear()
 end
 
-function add_adjacent_anchors(tbl,mx,my)
- for ax in all{mx*2-1,mx*2+2} do
-  for ay in all{my*2-1,my*2+2} do
-   local px,py=level:a2p(ax,ay)
-   tbl[_amix(ax,ay)]={ax=ax0,ay=ay0,x=px,y=py}
-  end
- end
-end
+function level:reanchor()
+ local anch_new={}
+ for dxy in all{{-1,-1},{1,-1},{-1,1},{1,1}} do
+  local dx,dy=unpack(dxy)
+  assert(dx!=0 and dy!=0)
+  for mx0=0,15 do
+   for my0=0,15 do
+    local mx1,my1=mx0+dx,my0+dy
 
-function level:reanchor(remove)
- if remove or not self._anch then
-  self._anch={}
- end
-
- for ax0=0,31 do
-  local ax1 = ax0-1+2*(ax0%2)
-  local mx0,mx1 = ax0\2,ax1\2
-  for ay0=0,31 do
-   local ay1=ay0-1+2*(ay0%2)
-   local my0,my1=ay0\2,ay1\2
-
-   if (
-    not self:mcoll(mx0,my0) and
-    not self:mcoll(mx0,my1) and
-    not self:mcoll(mx1,my0) and
-    self:mcoll(mx1,my1)
-   ) then
-    local px0,py0=level:a2p(ax0,ay0)
-    self._anch[_amix(ax0,ay0)]={ax=ax0,ay=ay0,x=px0,y=py0}
+    if (
+     self:mcoll(mx0,my0) and not self:get_crate(mx0,my0) and
+     not self:mcoll(mx0,my1) and
+     not self:mcoll(mx1,my0) and
+     not self:mcoll(mx1,my1)
+    ) then
+     local key="GEOM"..mx0..","..my0..","..dx..","..dy
+     anch_new[key]= {
+      ax=max(mx0,mx1),ay=max(my0,my1),adx=-dx,ady=-dy
+     }
+    end
    end
   end
+
+  for _,cr in pairs(self._crates) do
+   local key="CRATE"..cr.id..","..dx..","..dy
+   local mx0,my0=cr.mx,cr.my
+   local mx1,my1=mx0+dx,my0+dy
+   anch_new[key]={
+    ax=max(mx0,mx1),ay=max(my0,my1),adx=-dx,ady=-dy
+   }
+  end
  end
 
- for _,cr in pairs(self._crates) do
-  add_adjacent_anchors(self._anch,cr.mx,cr.my)
+ local anch_old=self._anch
+ if (anch_old==nil) anch_old={}
+ for _,old in pairs(anch_old) do
+  old.dropped=true
  end
 
- if (player.rope!=nil) player.rope:make_dirty()
+ for k,new in pairs(anch_new) do
+  local old=anch_old[k]
+  if old then
+   anch_new[k]=old
+   old.ax,old.ay,old.adx,old.ady=new.ax,new.ay,new.adx,new.ady
+   old.dropped=nil
+  end
+ end
+ self._anch=anch_new
+ self._anch_keys={}
+ for k,_ in pairs(self._anch) do
+  add(self._anch_keys,{key=k})
+ end
+
+ if (player.rope!=nil) player.rope:relax()
 end
 
 function level:win_at(mx,my)
  return self._wins[_mix(mx,my)]
 end
-function level:anchor_points()
- return pairs(self._anch)
-end
 
-function level:anchors_in(px0,py0,px1,py1)
- local anch,ax,xlim,sy,ylim=self._anch,px0\4,(px1+3)\4,py0\4,(py1+3)\4
- local ay=sy-1
- return function()
-  while true do
-   ay+=1
-   if(ay>ylim)ay,ax=sy,ax+1
-   if(ax>xlim)return nil
-   local anc=anch[_amix(ax,ay)]
-   if (anc) return anc
-  end
+function level:anchor_points()
+ keys=all(self._anch_keys)
+ return function() 
+  local k=keys()
+  if (k==nil) return nil
+  return self._anch[k.key]
  end
 end
 
@@ -472,12 +481,6 @@ function level:get_open_pit(mx,my)
  if (pit and pit.contents==nil) return pit
 end
 
-function level:point_anchor(px,py)
- local ax,ay=self:p2a(px,py)
- local anc=self._anch[_amix(ax,ay)]
- return anc
-end
-
 function level:spawn_exit()
  self._wins={}
  local spawned=false
@@ -491,9 +494,11 @@ function level:spawn_exit()
  end
  local win_at=function(x,y)
   if (self:_mget(x,y)!=18) return
-  for n in all(neighbors{x=x,y=y}) do
-   if n.x<0 or n.y<0 or n.x>15 or n.y>15 then
-    self._wins[_mix(n.x,n.y)]=true
+  for nx=x-1,x+1 do
+   for ny=y-1,y+1 do
+    if nx<0 or ny<0 or nx>15 or ny>15 then
+     self._wins[_mix(nx,ny)]=true
+    end
    end
   end
  end
@@ -504,16 +509,6 @@ function level:spawn_exit()
  assert(spawned)
 end
 
-function level:p2a(px,py)
- return px\4,py\4
-end
-
-function level:a2p(ax,ay)
- local px=ax*4+3*(ax%2)
- local py=ay*4+3*(ay%2)
- return px,py
-end
-
 function level:mcoll(mx,my)
  return self._coll[_mix(mx,my)]!=false
 end
@@ -574,8 +569,8 @@ function level:get_latch(dx,dy,px,py)
    return {
     el="crate",
     dx=dx1,dy=dy1,
-    px_offset=px-crate.px+dx1,
-    py_offset=py-crate.py+dy1,
+    ax_offset=dx1*0.5,
+    ay_offset=dy1*0.5,
     rec=crate
    }
   end
@@ -592,7 +587,9 @@ function level:get_latch(dx,dy,px,py)
 	 return {
 	  el="eyehook",
    dx=dx1,dy=dy1,
-	  mx=mx,my=my
+   ax_offset=dx1*0.5,
+   ay_offset=dy1*0.5,
+   rec={mx=mx,my=my,px=mx*8,py=my*8},
 	 }
 	end
 end
@@ -615,16 +612,15 @@ function level:can_move(
  
  -- todo: check tongue collision
  if player.rope then
-  local px,py=mx0*8,my0*8
   local chk=false
   if dmx==0 and dmy==-1 then
-   chk=player.rope:collide_rect(px+3,py-5,px+4,py+5,exclude_src,exclude_dst)
+   chk=player.rope:collide_mrect(mx0,my0-1,1,2,exclude_src,exclude_dst)
   elseif dmx==0 and dmy==1 then
-   chk=player.rope:collide_rect(px+3,py+3,px+4,py+13,exclude_src,exclude_dst)
+   chk=player.rope:collide_mrect(mx0,my0,1,2,exclude_src,exclude_dst)
   elseif dmx==-1 and dmy==0 then
-   chk=player.rope:collide_rect(px-5,py+3,px+5,py+4,exclude_src,exclude_dst)
+   chk=player.rope:collide_mrect(mx0-1,my0,2,1,exclude_src,exclude_dst)
   elseif dmx==1 and dmy==0 then
-   chk=player.rope:collide_rect(px+3,py+3,px+13,py+4,exclude_src,exclude_dst)
+   chk=player.rope:collide_mrect(mx0,my0,2,1,exclude_src,exclude_dst)
   end
 
   if (chk) return false
@@ -642,88 +638,16 @@ function level:tug_crate(mx0,my0,dmx,dmy)
 
  local mx1,my1=mx0+dmx,my0+dmy
  local mxy1=_mix(mx1,my1) 
- existing.mx=mx1
- existing.my=my1
  existing.todo={
-  {px=mx0*8+dmx*2,py=my0*8+dmy*2},
-  {px=mx0*8+dmx*7,py=my0*8+dmy*7},
-  {px=mx1*8,py=my1*8,update=function()
-   self:reanchor(true)
+  {px=mx1*8+dmx,py=my1*8+dmy,mx=mx1,my=my1,update=function()
+   self:recollide()
+   self:reanchor()
    return true
-  end}
+  end},
+  {px=mx1*8,py=my1*8}
  }
 
  self._crates[mxy1]=existing
- self:recollide()
- self:reanchor(false)
-end
--->8
--- collision checks
-function level:can_stretch(
- p1,p2
-)
- local key=p1.x..","..p1.y..","..p2.x..","..p2.y
- return self.cache_can_stretch:wrap(key,function()
-  return self:_can_stretch(p1,p2)
- end)
-end
-
-function level:_can_stretch(
- p1,p2
-)
- -- faster implementation for straight lines
- if p1.y\8==p2.y\8 then
-  local my=p2.y\8
-  for mx=p1.x\8,p2.x\8 do
-   if (level:mcoll(mx,my)) return false
-  end
- end
-
- if p1.x\8==p2.x\8 then
-  local mx=p2.x\8
-  for my=p1.y\8,p2.y\8 do
-   if (level:mcoll(mx,my)) return false
-  end
- end
-
- if (level:pcoll(p1.x,p1.y)) return false
- if (level:pcoll(p2.x,p2.y)) return false
-
- local res=true
- for x,y in _rastn(p1.x,p1.y,p2.x,p2.y,8,8) do
-  if level:pcoll(x,y) then
-   res=false
-   break
-  end
- end
- 
- return res
-end
-
--->8
---cache impl for collision checks
-dcache={}
-dcache.__index=dcache
-
-function dcache:new()
- local d={}
- setmetatable(d,dcache)
- d:clear()
- return d
-end
-function dcache:clear()
- self.old,self.new,self.new_n={},{},0
-end
-
-function dcache:wrap(key,f)
- local el=self.new[key]
- if (el!=nil) return el
- local el=self.old[key]
- if (el==nil) el=f()
- self.new[key]=el 
- self.new_n+=1 
- if (self.new_n>1000) self.old,self.new,self.new_n=self.new,{},0
- return el
 end
 
 -->8
@@ -758,7 +682,6 @@ end
 function player:any_busy()
  if (#self.todo>0) return true
  if (level:busy()) return true
- if (self.rope!=nil and self.rope:busy()) return true
  return false
 end
 
@@ -826,10 +749,17 @@ function player:update()
      self.todo=f4({{orienty=1,py=2},{py=7},{y=self.y+1}})
     else wrongbleep:bleep() end
    elseif self.rope==nil and kbd:btnr(4) then
-    local rx,ry,rx2,ry2=self:_rope_pos()
-    local dx,dy=12*self.orientx,12*self.orienty
+    local dx,dy=self.orientx,self.orienty
     if (dy!=0) dx=0
-    self.rope=rope:new(rx,ry,rx2,ry2,dx,dy)
+
+    local x,y=self.x,self.y
+    while not level:mcoll(x,y) do x+=dx y+=dy end
+
+    self.rope=rope:new(
+     x+0.5-dx*0.5,y+0.5-dy*0.5,
+     self.x+0.5,self.y+0.1,
+     level:get_latch(dx,dy,x*8,y*8)
+    )
     
     self.todo={{
      update=function()
@@ -848,8 +778,7 @@ function player:update()
 
  if self.rope then
   self.rope:update()
-  local rx,ry=self:_rope_pos()
-  self.rope:drag_dst(rx,ry)
+  self.rope:drag_dst(self.x+self.px/8+0.5,self.y+self.py/8+0.1)
 
   local tdx,tdy=self.rope:tug_orientxy()
   if (tdx!=0) self.orientx=tdx
@@ -866,6 +795,7 @@ function player:_vanish_if_requested()
   self.vanish_frame+=1
 
   if (self.fall_frame>0 or self.vanish_frame>20) then
+   self.rope=nil
    level:restart()
    kbd:release(5)
    self.vanish_frame=20
@@ -881,14 +811,6 @@ function player:_fall()
  if (self.fall_frame<10) self.fall_frame+=1
 end
 
-function player:_rope_pos()
- local px=self.x*8+self.px+4
- local px2=px
- local py=self.y*8+self.py+3
- local py2=py
- return px,py,px2,py2
-end
-
 function player:draw()
  local px=self.x*8+self.px
  local py=self.y*8+self.py
@@ -956,18 +878,21 @@ rope={}
 rope.__index=rope
 
 function rope:new(
- x,y,src_x,src_y,dx,dy
+ src_ax,src_ay,dst_ax,dst_ay,latch
 )
  local r={
   id=0,
-  src={x=src_x,y=src_y,todo={}},
-  ancs={},
-  dst={x=x,y=y,todo={}},
-  state={name="cast",dx=dx,dy=dy},
-  dirty=true,
-  latch=nil,
-  latch_frame=0,
+  anchors={
+   {ax=src_ax,ay=src_ay,prev=nil,next=nil},
+   {ax=dst_ax,ay=dst_ay,prev=nil,next=nil}
+  },
+  state={name="cast",frame=0},
+  latch=latch,
  }
+ r.src=r.anchors[1]
+ r.dst=r.anchors[2]
+ r.src.next=r.dst
+ r.dst.prev=r.src
  setmetatable(r,rope)
  return r
 end
@@ -980,30 +905,12 @@ function rope:done()
  return self.state.name=="done"
 end
 
-function rope:busy()
- for i=0,#self.ancs+1 do
-  if (#(self:_anc(i).todo)>0) return true
- end
- return false
-end
-
 function rope:update()
- local was_busy=self:busy()
- for i=0,#self.ancs+1 do
-  local anc=self:_anc(i)
-  _apply(anc,anc.todo,i)
- end
- local is_busy=self:busy()
- if (was_busy and not is_busy) self.dirty=true
-
  if self.state.name=="cast" then
-  self:continue_cast()
- elseif self.state.name=="latched" then
-  self.latch_frame+=1
-  if self.latch_frame>=10 then
-   self.latch_frame=10
-  end
+  self.state.frame+=1
+  if (self.state.frame>=3) self.state={name="latched"}
 
+ elseif self.state.name=="latched" then
   if (self.latch==nil) wrongbleep:bleep(3) self:destroy() return
 
   if 
@@ -1011,18 +918,17 @@ function rope:update()
    self.latch.rec!=nil 
   then
    self:drag_src(
-    self.latch.rec.px+self.latch.px_offset,
-    self.latch.rec.py+self.latch.py_offset
+    self.latch.rec.mx+0.5+self.latch.ax_offset,
+    self.latch.rec.my+0.5+self.latch.ay_offset
    )
 
-   if #self.latch.rec.todo==0 then
-    if self.latch.rec.dead==true then 
-     self:destroy()
-    end
+   if self.latch.rec.dead==true then 
+    self:destroy()
    end
   end
 
-  if (not is_busy) self:_tidy_up_gen()
+  if (not self:_check_sane()) self:destroy()
+
  elseif self.state.name=="destroy" then -- destroy
   self.state.frame+=1
   if (self.state.frame>=5) self.state={name="done"}
@@ -1036,41 +942,11 @@ function rope:destroy()
  self.state={name="destroy",frame=0}
 end
 
-function rope:continue_cast()
- local dx,dy=self.state.dx,self.state.dy
- local x0=self.src.x
- local y0=self.src.y
- local x1=x0+dx
- local y1=y0+dy
- 
- for x,y in _rast(
-  x0,y0,x1,y1
- ) do
-  local latch=
-   level:get_latch(dx,dy,x,y)
-
-  if latch!=nil or level:pcoll(x,y) then
-   self.latch=latch
-   self.state={name="latched"}
-   break
-  end
-  self.src={x=x,y=y,todo={},dirty=true}
- end
-end
-
-function rope:_reindex()
- self.src.ix=0
- self.dst.ix=#self.ancs
- for i,anc in ipairs(self.ancs) do
-  anc.ix=i
- end
-end
-
 function rope:draw(artificial_dx,artificial_dy)
  local points,highlight=self:_tug(true)
- if (self:busy()) highlight=nil
  if (self.state.name=="done") return
  local perc_to_show=1.0
+ if (self.state.name=="cast") perc_to_show=self.state.frame/2
  if (self.state.name=="destroy") perc_to_show=(1.0-self.state.frame/5)^2
 
  points[#points]={x=points[#points].x+artificial_dx,y=points[#points].y+artificial_dy}
@@ -1108,294 +984,347 @@ function rope:draw(artificial_dx,artificial_dy)
  end
 
  -- draw latch
- if self.latch!=nil and perc_to_show>=1.0 then
-  local x,y=points[1].x,points[1].y
+ if self.latch!=nil and self.latch.rec and perc_to_show>=1.0 then
+  local x,y=self.latch.rec.px,self.latch.rec.py
   local ldx,ldy=self.latch.dx,self.latch.dy
   local color=8
   if (highlight==0) color=12
   if self.latch.dx==-1 and self.latch.dy==0 then
-   rectfill(x+1,y,x+3,y+1,color)
+   rectfill(x,y+3,x+2,y+4,color)
   elseif self.latch.dx==1 and self.latch.dy==0 then
-   rectfill(x-1,y,x-3,y+1,color)
+   rectfill(x+5,y+3,x+7,y+4,color)
   elseif self.latch.dx==0 and self.latch.dy==-1 then
-   rectfill(x,y+1,x-1,y+3,color)
+   rectfill(x+3,y,x+4,y+2,color)
   elseif self.latch.dx==0 and self.latch.dy==1 then
-   rectfill(x,y-1,x-1,y-3,color)
+   rectfill(x+3,y+5,x+4,y+7,color)
   end
  end
 
- for i=0,#self.ancs+1 do
-  p=self:_anc(i)
-  local c=12
-  if (p.dirty) c=13
-  rectfill(p.x-1,p.y-1,p.x+1,p.y+1,c)
-  print(tostr(p.id)..":"..p.x..","..p.y..","..#p.todo,0,i*8,12)
- end
+ -- debug
  --[[
- for _,p in pairs(level._anch) do
-	 pset(p.x,p.y,11)
-	end
- print("dirty:"..tostr(self.dirty),32,0,9)
- print("busy:"..tostr(self:busy()),32,7,9)
- print("state:"..tostr(self.state.name),32,14,9)
-	if self.all_ops!=nil then
-	 for i,o in ipairs(self.all_ops) do
-	  rect(o.mx*8,o.my*8,o.mx*8+7,o.my*8+7,4)
-	  --print(o.mx..","..o.my,0,i*8,3)
-	 end
-	end
- ]]--
-end
+ local n1=self.src
+ local sy=0
+ while true do
+  if (n1==nil) break
+  local x=n1.ax*8
+  local y=n1.ay*8
+  if n1.associated_with then
+   if (n1.associated_with.adx>0) x-=1
+   if (n1.associated_with.ady>0) y-=1
+  end
+  rectfill(x-1,y-1,x+1,y+1,12)
+  print("ax="..n1.ax..",ay="..n1.ay,0,sy)
+  sy+=7
 
-function rope:_anc(i)
- if (i==0) return self.src
- if (i==#self.ancs+1) return self.dst
- return self.ancs[i]
+  local n0=n1.prev
+  local n2=n1.next
+  if n0!=nil and n2!=nil then
+   if n1.associated_with then
+    local _,_,_,adx,ady=would_stick(n0.ax,n0.ay,n1.associated_with,n2.ax,n2.ay)
+    assert(adx==-1 or adx==0 or adx==1)
+    assert(ady==-1 or ady==0 or ady==1)
+    --assert(not (adx==0 and ady==0))
+
+    local c=3
+    if (n1.associated_with.dropped) c=8
+    rectfill(x+2,y+2,x+4,y+4,c)
+    pset(x+adx*2,y,9)
+    pset(x,y+ady*2,9)
+   else
+   rectfill(x+2,y+2,x+4,y+4,2)
+   end
+  else
+   rectfill(x+2,y+2,x+4,y+4,4)
+  end
+
+  n1=n1.next
+ end
+
+ for _,p in pairs(level._anch) do
+  local x,y=p.ax*8,p.ay*8
+  if (p.adx>0) x-=1
+  if (p.ady>0) y-=1
+	 pset(x,y,11)
+	 pset(x+p.adx,y,11)
+	 pset(x,y+p.ady,11)
+	end
+ ]]
 end
 
 function rope:drag_dst(x,y)
- self:drag(function() return #self.ancs+1 end,x,y)
+ self:drag(self.dst,x,y)
 end
 
 function rope:drag_src(x,y)
- self:drag(function() return 0 end,x,y)
+ self:drag(self.src,x,y)
 end
 
-function rope:drag(
- i,x,y
-)
- local anc=self:_anc(i())
- local busy=self:busy()
-
- for x,y in _rast(
-  anc.x,anc.y,x,y
- ) do
-  local a=self:_anc(i())
-  if not (_point_eq(a,{x=x,y=y})) then
-   a.x=x
-   a.y=y
-   a.dirty=true
-   self.dirty=true
-   if (not busy) self:_tidy_up_gen()
-  end
- end
+function rope:drag(n1,ax_new,ay_new)
+ self:relax()
+ self:_drag(n1,ax_new,n1.ay)
+ self:_drag(n1,ax_new,ay_new)
+ self:relax()
 end
 
-function rope:make_dirty(only_if_invalid)
- local invalid=false
- for a=0,#self.ancs do
-  local a0=self:_anc(a)
-  local a1=self:_anc(a+1)
-  if not level:can_stretch(a0,a1) then
-   a0.dirty=true
-   a1.dirty=true
-   invalid=true
-  end
- end
- if (invalid or not only_if_invalid) self.dirty=true
-end
-
-function rope:_tidy_up_gen()
- self:make_dirty(true) 
-
- local busy=self:busy()
- if (not self:latched()) return
- if (not self.dirty) return
-
- local settled=true
- local loop=function(f)
-  local a=0
-  while a<=#self.ancs+1 do
-   local anc=self:_anc(a)
-   if anc.dirty then
-    anc.seen=true
-    if self[f](self,a,busy) then
-     settled=false anc.changed=true 
-     a=0
-    end
-   end
-   a+=1
-  end
- end
-
- local mark_unseen=function()
-  touched={}
-  for a=0,#self.ancs+1,1 do
-   local anc=self:_anc(a)
-   anc.seen=false
-   anc.changed=false
-  end
- end
-
- local propagate_dirty=function(f)
-  for a=0,#self.ancs+1,1 do
-   local a1=self:_anc(a)
-   if a1.dirty then
-    local a0=self:_anc(a-1)
-    if (a0!=nil) a0.dirty=true
-
-    local a2=self:_anc(a+1)
-    if (a2!=nil) a2.dirty=true
-   end
-  end
- end
+function rope:relax()
+ local n=self.src
 
  while true do
-  settled=true
+  if (n==nil) break
 
-  mark_unseen()
-  propagate_dirty()
-
-  loop("_find_needed_anchors")
-  loop("_find_touched_anchors")
-  loop("_elide_point")
-
-  for a=0,#self.ancs+1,1 do
-   local anc=self:_anc(a)
-   if (anc.seen) anc.dirty=anc.changed
-   if (anc.dirty) settled=false
+  if (n.associated_with) then 
+   self:_drag(n,n.associated_with.ax,n.associated_with.ay)
   end
 
-  if (settled) break
+  n=n.next
  end
 
- if (self:busy()) return
+ local n0=self.src
+ while true do
+  if (n0==nil) return
+  local n1=n0.next
+  if (n1==nil) return
+  local n2=n1.next
+  if (n2==nil) return
 
- for i=0,#self.ancs do
-  local a0=self:_anc(i)
-  local a1=self:_anc(i+1)
-  if not level:can_stretch(a0,a1) then
-   self:destroy()
-  end
- end
+  if n1.associated_with!=nil then
 
- self.dirty=false
-end
+   local x0,y0=n0.ax,n0.ay
+   local x1,y1=n1.ax,n1.ay
+   local x2,y2=n2.ax,n2.ay
 
-function rope:_find_needed_anchors(i,busy)
- if (i<=0) return false
- if (#self.ancs+1<i) return false
-
- local a0=self:_anc(i-1)
- local a2=self:_anc(i)
-
- if (level:pcoll(a2.x,a2.y)) return false
- if (level:pcoll(a0.x,a0.y)) return false 
- if (level:can_stretch(a0,a2)) return false
-
- local anchors_bydist={}
- local x0,x2=_mnmx(a0.x,a2.x)
- local y0,y2=_mnmx(a0.y,a2.y)
- for a1 in level:anchors_in(x0-1,y0-1,x2+1,y2+1) do
-  add(anchors_bydist,{el=a1,key=_linedist(a0,a1,a2)})
- end
- shellsort(anchors_bydist)
-
- for a1 in all(anchors_bydist) do
-  a1=a1.el
-  if level:can_stretch(a0,a1) and
-   level:can_stretch(a1,a2)
-  then
-   local id=self.id
-   add(self.ancs,{id=id,x=a1.x,y=a1.y,dirty=true,todo={}},i)
-   self.id+=1
-
-   return true
-  end
+   local would,x1_new,y1_new=would_stick(x0,y0,n1.associated_with,x2,y2)
+   if not would and not (n1.ax==x1_new and n1.ay==y1_new) then
+    --printh("relaxing: "..tostring(n0.associated_with).."->"..tostring(n1.associated_with).."->"..tostring(n2.associated_with))
+    self:_drag(n1,x1_new,y1_new)
+    n0=n1.prev
+    n2=n1.next
+    n0.next=n2
+    n2.prev=n0
+    n1.next=nil
+    n1.prev=nil
+   else n0=n0.next end
+  else n0=n0.next end
  end
 end
 
-local ELIDE_POINT=0.01
-function rope:_find_touched_anchors(i)
- if (i<=0) return false
- if (#self.ancs<i) return false
+function rope:_check_sane()
+ if (self.state.name!="latched") return true
+ if (level:busy()) return true
 
- local a0=self:_anc(i-1)
- local a2=self:_anc(i)
+ local n0=self.src
 
- if (level:pcoll(a0.x,a0.y)) return false
- if (level:pcoll(a2.x,a2.y)) return false
+ local qxs,qys={},{}
+ while true do 
+  local n1=n0.next
+  if (n1==nil) break 
 
- for bx,by in _rast(a0.x,a0.y,a2.x,a2.y) do
-  local a1=level:point_anchor(bx,by)
-  if 
-   a1!=nil and not _point_eq(a0,a1) and not _point_eq(a1,a2)
-   and _linedist(a0,a1,a2)<ELIDE_POINT
-  then
-   local id=self.id
-   add(self.ancs,{id=id,x=a1.x,y=a1.y,dirty=true,todo={}},i)
-   self.id+=1
+  for qx,qy in _rast(flr(n0.ax*2),flr(n0.ay*2),flr(n1.ax*2),flr(n1.ay*2)) do
+   if not (qx==qxs[#qxs] and qy==qys[#qys]) then
+    add(qxs,qx)
+    add(qys,qy)
+   end
+  end
+  n0=n1
+ end
 
-   return true
+ local function _possible_tiles(qx,qy)
+  local mx0=(qx-1)\2
+  local mx1=qx\2
+  local my0=(qy-1)\2
+  local my1=qy\2
+
+  local poss={}
+  for mx=mx0,mx1 do
+   for my=my0,my1 do
+    add(poss,{mx=mx,my=my})
+   end
+  end
+  return poss
+ end
+ local function _blocked(qx,qy)
+  for i in all(_possible_tiles(qx,qy)) do
+   if (not level:mcoll(i.mx,i.my)) return false
+  end
+  return true
+ end
+
+ -- find cases where i move through an impassable zone
+ for i=1,#qxs do
+  if (_blocked(qxs[i],qys[i])) return false
+ end
+
+ -- find cases where i am cut off diagonally
+ for i=3,#qxs do
+  local qx1,qy1=qxs[i-1],qys[i-1]
+  if qx1%2==0 and qy1%2==0 then
+   local ok=false
+   for m0 in all(_possible_tiles(qxs[i-2],qys[i-2])) do
+    for m2 in all(_possible_tiles(qxs[i],qys[i])) do
+     local mx0,my0=m0.mx,m0.my
+     local mx2,my2=m2.mx,m2.my
+     if not (level:mcoll(mx0,my0) or level:mcoll(mx2,my2)) then
+      local dmx,dmy=abs(mx2-mx0),abs(my2-my0)
+
+      if dmx==1 and dmy==1 and level:mcoll(mx0,my2) and level:mcoll(mx2,my0) then
+      else
+       --printh("ok! "..tostring({qxs[i-2],qys[i-2]})..tostring({qxs[i],qys[i]})..tostring(m0)..tostring(m2))
+       ok=true
+      end
+     end
+    end
+   end
+
+   if (not ok) return false
   end
  end
- return false
+ return true
 end
 
-function rope:_elide_point(i,busy)
- if (i<=0) return false
- if (#self.ancs<i) return false
+function would_stick(x0,y0,anchor,x2,y2)
+ local x1,y1=anchor.ax,anchor.ay
+ if (x0>x2) x0,y0,x2,y2=x2,y2,x0,y0
 
- local a0=self:_anc(i-1)
- local a1=self:_anc(i)
- local a2=self:_anc(i+1)
+ local dx=x2-x0
+ local dy=y2-y0
 
- local level_anc=level:point_anchor(a1.x,a1.y)
- if _point_eq(a0,a1) or _point_eq(a1,a2) or (not busy and level_anc==nil) then
-  -- do it unconditionally
+ local adx,ady
+ local x1_new,y1_new
+ if abs(dx)>abs(dy) then
+  local dprop=(x1-x0)/dx
+  x1_new,y1_new=x1,y0+dprop*(y2-y0)
+  ady=sgn0(y1_new-y1)
+  adx=0
+  if (y0>y2) adx=ady
+  if (y0<y2) adx=-ady
  else
-  if _linedist(a0,a1,a2) < ELIDE_POINT then
-   return false
-  end
-
-  if not level:can_stretch(a0,a2) then
-   return false
-  end
-  
-  local midpoint={
-   x=(a0.x+a2.x)\2,
-   y=(a0.y+a2.y)\2
-  }
-
-  if not self:_can_move_midpoint(a0,a1,midpoint,a2) then
-   return false
-  end
+  local dprop=(y1-y0)/dy
+  x1_new,y1_new=x0+dprop*(x2-x0),y1
+  adx=sgn0(x1_new-x1)
+  ady=0
+  if (y0>y2) ady=adx
+  if (y0<y2) ady=-adx
  end
- 
- deli(self.ancs,i)
- a0.dirty=true a0.changed=true
- a2.dirty=true a2.changed=true
- return true
+
+ local wouldnt=anchor.dropped or (anchor.adx==-adx or anchor.ady==-ady)
+
+ return not wouldnt,x1_new,y1_new,adx,ady
 end
 
-function rope:_can_move_midpoint(a0,a1_0,a1_1,a2)
- if not level:can_stretch(a1_0, a1_1) then
-  return false
- end
- if not level:can_stretch(a0,a1_1) then
-  return false
- end
- if not level:can_stretch(a1_1,a2) then
-  return false
- end
- for x,y in _rastn(a1_0.x,a1_0.y,a1_1.x,a1_1.y,8,8) do
-  local tm={x=x,y=y}
-  if not level:can_stretch(a0,tm) then
-   return false
+function rope:_drag(n1,ax1_new,ay1_new)
+ local function _sweep_radar(ax_pivot,ay_pivot,ax_far0,ay_far0,ax_far1,ay_far1)
+  if (ax_far0==ax_far1 and ay_far0==ay_far1) return nil
+  local function crossed(x,y)
+   return x!=y
   end
-  if not level:can_stretch(tm,a2) then
-   return false
+
+  if ax_far0==ax_far1 then
+   local ax_far=ax_far0
+   local ax0,ax1=_mnmx(ax_pivot,ax_far)
+
+   ay_far_old=ay_far0
+   for ay_far_new in _stepfrom(ay_far0,ay_far1) do
+    for anchor in level:anchor_points() do
+     if 
+      not (anchor.ax==ax_pivot and anchor.ay==ay_pivot) and
+      not (anchor.ax==ax_far0 and anchor.ay==ay_far0) and
+      not (anchor.ax==ax_far1 and anchor.ay==ay_far1) and
+      (ax0<=anchor.ax and anchor.ax<=ax1) and 
+      would_stick(ax_pivot,ay_pivot,anchor,ax_far,ay_far_new) and
+      crossed(
+        _which_side(anchor.ax,anchor.ay,ax_pivot,ay_pivot,ax_far,ay_far_old),
+        _which_side(anchor.ax,anchor.ay,ax_pivot,ay_pivot,ax_far,ay_far_new)
+      )
+     then
+      return anchor
+     end
+    end
+    ay_far_old=ay_far_new
+   end
+  elseif ay_far0==ay_far1 then
+   local ay_far=ay_far0
+   local ay0,ay1=_mnmx(ay_pivot,ay_far)
+
+   ax_far_old=ax_far0
+   for ax_far_new in _stepfrom(ax_far0,ax_far1) do
+    for anchor in level:anchor_points() do
+     if 
+      not (anchor.ax==ax_pivot and anchor.ay==ay_pivot) and
+      not (anchor.ax==ax_far0 and anchor.ay==ay_far0) and
+      not (anchor.ax==ax_far1 and anchor.ay==ay_far1) and
+      would_stick(ax_pivot,ay_pivot,anchor,ax_far_new,ay_far) and
+      (ay0<=anchor.ay and anchor.ay<=ay1) and 
+      crossed(
+        _which_side(anchor.ax,anchor.ay,ax_pivot,ay_pivot,ax_far_old,ay_far),
+        _which_side(anchor.ax,anchor.ay,ax_pivot,ay_pivot,ax_far_new,ay_far)
+      )
+     then
+      return anchor
+     end
+    end
+    ax_far_old=ax_far_new
+   end
   end
  end
- return true
+
+ local ax1_old,ay1_old=n1.ax,n1.ay
+ n1.ax=ax1_new
+ n1.ay=ay1_new
+
+ local n0=n1.prev
+ while true do
+  if (n0==nil) break
+  local anch=_sweep_radar(n0.ax,n0.ay,ax1_old,ay1_old,ax1_new,ay1_new)
+  if (anch==nil) break
+  local n05={ax=anch.ax,ay=anch.ay,associated_with=anch,prev=n0,next=n1}
+  --printh("creating post: "..tostring(n0.associated_with).."->"..tostring(n05.associated_with).."->"..tostring(n1.associated_with))
+  n0.next=n05
+  n1.prev=n05
+  n0=n05
+ end
+
+ local n2=n1.next
+ while true do
+  if (n2==nil) break
+  local anch=_sweep_radar(n2.ax,n2.ay,ax1_old,ay1_old,ax1_new,ay1_new)
+  if (anch==nil) break
+  local n15={ax=anch.ax,ay=anch.ay,associated_with=anch,prev=n1,next=n2}
+  --printh("creating post: "..tostring(n1.associated_with).."->"..tostring(n15.associated_with).."->"..tostring(n2.associated_with))
+  n1.next=n15
+  n2.prev=n15
+  n2=n15
+ end
 end
 
-function _linedist(x0,v,x1)
- return 100 * (sum_distance(x0,v,x1)-distance(x0,x1))/distance(x0,x1)
+function _stepfrom(x0,x1)
+ local done=false
+ if x0==x1 then
+  return function() 
+   if (done) return nil
+   done=true return x0
+  end
+ end
+
+ local mul=0.5
+ x0*=2
+ x1*=2
+ if (x0>x1) x0,x1,mul=-x0,-x1,-mul
+ local i=flr(x0)
+ local top=flr(x1)
+ return function()
+  if (done) return nil
+  i+=1
+  if i>top then 
+   done = true
+   if (x1!=flr(x1)) return mul*x1
+   return nil
+  end
+  return mul*i
+ end
 end
 
-function sum_distance(x,y,z)
- return distance(x,y) + distance(y,z)
+function _which_side(x,y,x0,y0,x1,y1)
+ return sgn0((x1-x0)*(y-y0) - (y1-y0)*(x-x0))
 end
 
 function distance_dxy(dx,dy)
@@ -1408,17 +1337,34 @@ function distance(p1,p2)
  return sqrt(dx*dx+dy*dy)
 end
 
-function rope:collide_rect(x1,y1,x2,y2,exclude_src,exclude_dst)
- local last=#self.ancs-exclude_dst
- for i=exclude_src,last,1 do
-  local a0=self:_anc(i)
-  local a1=self:_anc(i+1)
-  if (_line_line(a0.x,a0.y,a1.x,a1.y,x1,y1,x2,y1)) return true
-  if (_line_line(a0.x,a0.y,a1.x,a1.y,x1,y1,x1,y2)) return true
-  if (_line_line(a0.x,a0.y,a1.x,a1.y,x1,y2,x2,y2)) return true
-  if (_line_line(a0.x,a0.y,a1.x,a1.y,x2,y1,x2,y2)) return true
+function rope:collide_mrect(mx0,my0,mw,mh,exclude_src,exclude_dst)
+ local mx1,my1=mx0+mw,my0+mh
+ local n0=self.src
+
+ mx0+=0.4
+ my0+=0.4
+ mx1-=0.4
+ my1-=0.4
+
+ while true do
+  local n1=n0.next
+  if (n1==nil) return false
+
+  local nd=n0
+  for i=1,exclude_dst do 
+   nd=nd.next
+   if (nd==nil) return false
+  end
+
+  if exclude_src<=0 then
+   if (_line_line(n0.ax,n0.ay,n1.ax,n1.ay,mx0,my0,mx1,my0)) return true
+   if (_line_line(n0.ax,n0.ay,n1.ax,n1.ay,mx0,my0,mx0,my1)) return true
+   if (_line_line(n0.ax,n0.ay,n1.ax,n1.ay,mx0,my1,mx1,my1)) return true
+   if (_line_line(n0.ax,n0.ay,n1.ax,n1.ay,mx1,my0,mx1,my1)) return true
+  end
+  exclude_src-=1
+  n0=n1
  end
- return false
 end
 
 function _line_line(x1,y1,x2,y2,x3,y3,x4,y4)
@@ -1435,44 +1381,29 @@ function _line_line(x1,y1,x2,y2,x3,y3,x4,y4)
  return true
 end
 
-function neighbors(p)
- local r={}
- for dx=-1,1,1 do
-  for dy=-1,1,1 do
-   if dx!=0 or dy!=0 then
-    add(r,{x=p.x+dx,y=p.y+dy})
-   end
-  end
- end
- return r
-end
-
 -->8
 -- moved here because it's complicated
 
 function rope:tug_orientxy()
- local a1=self:_anc(#self.ancs+1)
- local a0=self:_anc(#self.ancs)
- local dx=a0.x-a1.x
+ local a1=self.dst
+ local a0=self.dst.prev
+ local dx=a0.ax-a1.ax
  local tdx=0
- if (dx>3) tdx=1
- if (dx<-3) tdx=-1
+ if (dx>3/8) tdx=1
+ if (dx<-3/8) tdx=-1
 
- local dy=a0.y-a1.y
+ local dy=a0.ay-a1.ay
  local tdy=0
  if abs(dy)>abs(dx)/2 then 
-  if (dy>3) tdy=1
-  if (dy<-3) tdy=-1
+  if (dy>3/8) tdy=1
+  if (dy<-3/8) tdy=-1
  end
  return tdx,tdy
 end
 
 function rope:tug()
- self:_tidy_up_gen()
  if (not self:latched()) return
- local rc=self:_tug()
- self:_tidy_up_gen()
- return rc
+ return self:_tug()
 end
 
 function rope:_tug(hypothetically)
@@ -1480,12 +1411,12 @@ function rope:_tug(hypothetically)
  local touched={}
 
  for i=#ancs-1,2,-1 do
-  local ops_before_trash,hit_end1=self:_calc_push(ancs[i+1],ancs[i],ancs[i-1],ancs[i-2])
+  local ops_before_trash=self:_calc_push(ancs[i+1],ancs[i],ancs[i-1],ancs[i-2])
   local ops_to_do,corners={}
   if #ops_before_trash>0 then 
    ops_to_do=ops_before_trash 
   else 
-   local ops_after_trash,hit_end2=self:_calc_push(ancs[i-2],ancs[i-1],ancs[i],ancs[i+1])
+   local ops_after_trash=self:_calc_push(ancs[i-2],ancs[i-1],ancs[i],ancs[i+1])
    ops_to_do=ops_after_trash
   end
 
@@ -1495,39 +1426,9 @@ function rope:_tug(hypothetically)
    if (hypothetically) return ancs,i-1
 
    local dmx,dmy=ops[1].dmx,ops[1].dmy
-   local adjacent_ancs={}
    for o in all(ops) do
-    add_adjacent_anchors(adjacent_ancs,o.mx,o.my)
     level:tug_crate(o.mx,o.my,o.dmx,o.dmy)
    end
-   for node=ancs[i-1].ix,ancs[i].ix do
-    local anc=self:_anc(node)
-    local x0,y0=anc.x,anc.y
-
-    local upd=function(x,y,force)
-     return {update=function(s,i)
-      if force or not level:pcoll(x,y) then
-       s.x=x
-       s.y=y
-      end
-      s.dirty=true
-      self.dirty=true
-      return true
-     end}
-    end
-    local dmxh,dmyh=dmx,dmy
-    local ax,ay=level:p2a(x0,y0)
-    if (adjacent_ancs[_amix(ax,ay)]==nil) dmxh,dmyh=0,0
-    anc.todo={
-     {},
-     upd(x0+dmxh*2,y0+dmyh*2),
-     upd(x0+dmxh*7,y0+dmyh*7),
-     upd(x0+dmxh*8,y0+dmyh*8),
-    }
-   end 
-   for node=ancs[i-1].ix-1,ancs[i].ix+1 do
-    local anc=self:_anc(node)
-   end
    return true
   end
  end
@@ -1568,12 +1469,7 @@ function rope:_tug(hypothetically)
   then
    if (hypothetically) return ancs,0
 
-   level:tug_crate(
-    mx0,my0,
-    dmx,dmy
-   ) 
-   -- be busy for 4 ticks while the crate moves
-   self:_anc(0).todo={{},{},{},{},{}}
+   level:tug_crate(mx0,my0,dmx,dmy) 
    return true
   end
  end
@@ -1642,7 +1538,6 @@ function rope:_calc_push(
   end
  end
 
- local hit_end=true
  local ops2={}
  for o in all(ops) do
   if not level:mcoll(o.mx,o.my) then
@@ -1650,42 +1545,50 @@ function rope:_calc_push(
   else
    local crate=level:get_crate(o.mx,o.my)
    if crate==nil then
-    hit_end=false
     break
    else
     if not level:can_move(false,o.mx,o.my,o.dmx,o.dmy,0,0) then
-     hit_end=false
      break
     end
    end
    add(ops2,o)
   end
  end
- return ops2,hit_end
+ return ops2
 end
 
 function rope:_anchors_simplified()
  -- todo: cache this
- self:_reindex()
-
  local points={}
  local _slope = function(p0,p1)
   return atan2(p1.y-p0.y,p1.x-p0.x)
  end
- for i=0,#self.ancs+1,1 do
-  local anc=self:_anc(i)
+ a=self.src
+ while a!=nil do
+  local point={
+   x=flr(a.ax*8+0.5),y=flr(a.ay*8+0.5),
+   ax=a.ax,ay=a.ay
+  }
+  if a.associated_with then
+   if (a.associated_with.adx==1) point.x-=1
+   if (a.associated_with.ady==1) point.y-=1
+  elseif a.prev==nil and self.latch then
+   if (self.latch.ax_offset<0) point.x-=1
+   if (self.latch.ay_offset<0) point.y-=1
+  end
+
   if #points<=1 then 
-   add(points,anc)
+   add(points,point)
   elseif abs(
    _slope(points[#points-1],points[#points])-
-   _slope(points[#points],anc)
+   _slope(points[#points],point)
   )==0 then  -- epsilon?
-   points[#points]=anc
+   points[#points]=point
   else
-   add(points,anc)
+   add(points,point)
   end
+  a=a.next
  end
- 
  return points
 end