From ac37b6df99ccff194cc5e13055969b8afffdabb3 Mon Sep 17 00:00:00 2001
From: Zeno Rogue <zeno@attnam.com>
Date: Sat, 24 Mar 2018 12:59:01 +0100
Subject: [PATCH] more elegant cellwalkers

---
 barriers.cpp   | 267 ++++++++++++++++++++-----------------------------
 bigstuff.cpp   |   7 +-
 cell.cpp       |  85 ++++++++++------
 complex.cpp    | 101 +++++++------------
 debug.cpp      |   2 +-
 game.cpp       |  42 ++++----
 graph.cpp      |   6 +-
 heptagon.cpp   |  27 +++--
 hyper.h        |  59 +++++++++--
 hyperpoint.cpp |  43 --------
 hypgraph.cpp   |   5 +-
 kohonen.cpp    |   7 +-
 landgen.cpp    |  21 ++--
 mapeditor.cpp  |   6 +-
 orbs.cpp       |  11 +-
 patterngen.cpp | 118 ++++++++++------------
 rogueviz.cpp   |   8 +-
 rug.cpp        |   4 +-
 shmup.cpp      |  11 +-
 yendor.cpp     |   8 +-
 20 files changed, 371 insertions(+), 467 deletions(-)

diff --git a/barriers.cpp b/barriers.cpp
index 16f18406..687e3b05 100644
--- a/barriers.cpp
+++ b/barriers.cpp
@@ -13,17 +13,16 @@ bool checkBarriersFront(cellwalker bb, int q, bool cross) {
   if(bb.spin == (nonbitrunc ? 3 : 0)) {q--; if(!q) return true; }
 
   if(!cross) for(int i=0; i<7; i++) {
-    cellwalker bb2 = bb;
-    cwspin(bb2, i); cwstep(bb2); 
+    cellwalker bb2 = bb + i + wstep;
     if(bb2.c->bardir != NODIR) return false; 
     if(!nonbitrunc) { 
-      cwspin(bb2, 4); cwstep(bb2);
+      bb2 = bb2 + 4 + wstep;
       if(bb2.c->bardir != NODIR) return false;
       }
     }
 
-  cwstep(bb); 
-  if(!nonbitrunc) { cwspin(bb, 3); cwstep(bb); cwspin(bb, 3); cwstep(bb); }
+  bb += wstep;
+  if(!nonbitrunc) { bb = bb + 3 + wstep + 3 + wstep; }
   return checkBarriersBack(bb, q);
   }
 
@@ -47,19 +46,15 @@ bool checkBarriersBack(cellwalker bb, int q, bool cross) {
   // if(bb.spin == 0 && bb.c->mpdist == INFD) return true;
   
   if(!cross) for(int i=0; i<7; i++) {
-    cellwalker bb2 = bb;
-    cwspin(bb2, i); cwstep(bb2); 
+    cellwalker bb2 = bb + i + wstep;
     if(bb2.c->bardir != NODIR) return false;
     if(!nonbitrunc) {
-      cwspin(bb2, 4); cwstep(bb2);
+      bb2 = bb2 + 4 + wstep;
       if(bb2.c->bardir != NODIR) return false;
       }
     }
 
-  cwspin(bb, 3); cwstep(bb); cwspin(bb, nonbitrunc ? 5 : 4); 
-  // bool create = cwstepcreates(bb);
-  cwstep(bb); cwspin(bb, 3); 
-  // if(create && bb.spin == 0) return true;
+  bb = bb + 3 + wstep + (nonbitrunc ? 5 : 4) + wstep + 3;
   return checkBarriersFront(bb, q);
   }
 
@@ -90,20 +85,13 @@ bool checkBarriersNowall(cellwalker bb, int q, int dir, eLand l1=laNone, eLand l
     }
   
   if(nonbitrunc && S3==4) {
-    cwspin(bb, dir);
-    cwstep(bb);
-    cwspin(bb, dir);
+    bb = bb + dir + wstep + dir;
     }
   else if(nonbitrunc) {
-    cwspin(bb, 3*dir);
-    cwstep(bb);
-    cwspin(bb, -3*dir);
+    bb = bb + (3*dir) + wstep - (3*dir);
     }
   else {
-    cwstep(bb);
-    cwspin(bb, 2*dir);
-    cwstep(bb);
-    cwspin(bb, dir);
+    bb = bb + wstep + (2*dir) + wstep + dir;
     }
   return checkBarriersNowall(bb, q+1, -dir, l2, l1);
   }
@@ -174,7 +162,7 @@ void extendBarrierFront(cell *c) {
   extendcheck(c);
 
   cellwalker bb(c, c->bardir); setbarrier(bb.c);
-  cwstep(bb); 
+  bb += wstep;
   
   if(!nonbitrunc) {
     bb.c->barleft = c->barleft;
@@ -183,19 +171,19 @@ void extendBarrierFront(cell *c) {
     if(!mirrorwall(bb.c)) 
       bb.c->landparam = (ht-4);
   //printf("[A heat %d]\n", ht-4);
-
-    cwspin(bb, 2); cwstep(bb); setland(bb.c, c->barleft); cwstep(bb);
-    cwspin(bb, 2); cwstep(bb); setland(bb.c, c->barright); cwstep(bb);
-    cwspin(bb, 2); 
+  
+    setland((bb + 2 + wstep).c, c->barleft);
+    setland((bb + 4 + wstep).c, c->barright);
     
-    cwspin(bb, 3); cwstep(bb); 
+    bb = bb + 3 + wstep; 
     bb.c->barleft = c->barright;
     bb.c->barright = c->barleft;
     setbarrier(bb.c);
     if(!mirrorwall(bb.c)) 
       bb.c->landparam = (ht-4)^2;
   //printf("[B heat %d]\n", (ht-4)^2);
-    cwspin(bb, 3); cwstep(bb);
+    
+    bb = bb + 3 + wstep;
     
     bb.c->barleft = c->barleft;
     bb.c->barright = c->barright;
@@ -212,7 +200,7 @@ void extendBarrierFront(cell *c) {
   extendBarrier(bb.c);
   
   for(int a=-3; a<=3; a++) if(a) {
-    bb.c = c; bb.spin = c->bardir; cwspin(bb, nonbitrunc?-a:a); cwstep(bb); 
+    bb.c = c; bb.spin = c->bardir; bb += (nonbitrunc?-a:a); bb += wstep; 
     setland(bb.c, a > 0 ? c->barright : c->barleft);
     }
   }
@@ -224,9 +212,9 @@ void extendBarrierBack(cell *c) {
   extendcheck(c);
 
   cellwalker bb(c, c->bardir); setbarrier(bb.c);
-  cwspin(bb, 3); cwstep(bb); cwspin(bb, nonbitrunc?5:4); 
+  bb = bb + 3 + wstep + (nonbitrunc?5:4); 
   setland(bb.c, nonbitrunc ? c->barleft : c->barright); 
-  cwstep(bb); cwspin(bb, 3);
+  bb = bb + wstep + 3;
   bb.c->bardir = bb.spin;
   bb.c->barleft = c->barright;
   bb.c->barright = c->barleft;
@@ -237,12 +225,11 @@ void extendBarrierBack(cell *c) {
 
   // needed for CR2 to work
   if(!nonbitrunc) { 
-    cwstep(bb); 
-    bb.c->barleft = c->barright;
-    bb.c->barright = c->barleft;
-    if(!mirrorwall(bb.c)) 
-      bb.c->landparam = (ht^11)-4;
-    cwstep(bb);
+    auto bb2 = bb + wstep;
+    bb2.c->barleft = c->barright;
+    bb2.c->barright = c->barleft;
+    if(!mirrorwall(bb2.c)) 
+      bb2.c->landparam = (ht^11)-4;
     }
 //printf("[E heat %d]\n", (ht^11));
 
@@ -256,68 +243,49 @@ void extendNowall(cell *c) {
   cellwalker cw(c, c->bardir);
   
   if(!nonbitrunc) {
-    cwstep(cw);
+    cw += wstep;
     setland(cw.c, c->barright);
     }
   
   if(nonbitrunc && S3 == 4) {
-    cwstep(cw);
-    setland(cw.c, c->barright);
-    cw.c->barleft = NOWALLSEP_USED;
-    cw.c->barright = c->land;
-    cw.c->bardir = cw.spin;
-    cwstep(cw);
+    auto cw2 = cw + wstep;
+    setland(cw2.c, c->barright);
+    cw2.c->barleft = NOWALLSEP_USED;
+    cw2.c->barright = c->land;
+    cw2.c->bardir = cw2.spin;
     }
   
   for(int i=-1; i<2; i+=2) {  
+    cellwalker cw0;
     if(nonbitrunc && S3==4) {
-      cwspin(cw, i);
-      cwstep(cw);
-      cwspin(cw, i);
+      cw0 = cw + i + wstep + i; 
       }
     else if(nonbitrunc) {
-      cwspin(cw, 3*i);
-      cwstep(cw);
-      cwspin(cw, -3*i);
+      cw0 = cw + (3*i) + wstep - (3*i);
       }
     else {
-      cwspin(cw, 2*i);
-      cwstep(cw);
+      cw0 = cw + (2*i) + wstep;
       }
-    if(cw.c->barleft != NOWALLSEP_USED) {
-      cw.c->barleft = NOWALLSEP;
+    if(cw0.c->barleft != NOWALLSEP_USED) {
+      cw0.c->barleft = NOWALLSEP;
       if(S3 == 4 && nonbitrunc) {
-        cw.c->barright = c->barright;
-        cw.c->bardir = cw.spin;
-        setland(cw.c, c->land);
+        cw0.c->barright = c->barright;
+        cw0.c->bardir = cw0.spin;
+        setland(cw0.c, c->land);
         }
       else {
-        setland(cw.c, c->barright);
-        cw.c->barright = c->land;
+        setland(cw0.c, c->barright);
+        cw0.c->barright = c->land;
         if(c->barright == laNone) { 
           printf("barright\n"); 
           }// NONEDEBUG
-        setland(cw.c, c->barright);
-        if(!nonbitrunc) cwspin(cw, i);
-        cw.c->bardir = cw.spin;
-        if(!nonbitrunc) cwspin(cw, -i);
+        setland(cw0.c, c->barright);
+        if(!nonbitrunc) cw0 += i;
+        cw0.c->bardir = cw0.spin;
+        if(!nonbitrunc) cw0 -= i;
         }
-      extendcheck(cw.c);
-      extendBarrier(cw.c);
-      }
-    if(nonbitrunc && S3==4) {
-      cwspin(cw, -i);
-      cwstep(cw);
-      cwspin(cw, -i);
-      }
-    else if(nonbitrunc) {
-      cwspin(cw, 3*i);
-      cwstep(cw);
-      cwspin(cw, -3*i);
-      }
-    else {
-      cwstep(cw);
-      cwspin(cw, -2*i);
+      extendcheck(cw0.c);
+      extendBarrier(cw0.c);
       }
     }
   }
@@ -332,11 +300,7 @@ void extendCR5(cell *c) {
   cellwalker cw(c, c->bardir);
   for(int u=0; u<2; u++) {
     // if(gotit) break;
-    cwspin(cw, 2);
-    cwstep(cw);
-    cwspin(cw, 2);
-    cwstep(cw);
-    cwspin(cw, 5);
+    cw = cw + 2 + wstep + 2 + wstep + 5;
     if(cw.c->bardir == NODIR) {
       cw.c->landparam = 40;
       cw.c->bardir = cw.spin;
@@ -391,7 +355,7 @@ void extendBarrier(cell *c) {
   
   if(firstmirror && c->barleft == laMirror && hrand(100) < 60) {
     cellwalker cw(c, c->bardir);
-    if(!nonbitrunc) cwstep(cw);
+    if(!nonbitrunc) cw += wstep;
     if(cw.c->land != laMirrorWall)
       if(buildBarrier6(cw, 1)) return;
     }
@@ -399,11 +363,10 @@ void extendBarrier(cell *c) {
   if(firstmirror && (nonbitrunc?c->barleft == laMirror : c->barright == laMirror) && hrand(100) < 60) {
     cellwalker cw(c, c->bardir);
     if(nonbitrunc) {
-      cwspin(cw, -3); cwstep(cw); cwspin(cw, -3);
-//    cwspin(cw, 3); cwstep(cw); cwspin(cw, -2); cwstep(cw); cwspin(cw, 3);
+      cw = cw - 3 + wstep - 3;
       }
     else {
-      cwstep(cw); cwspin(cw, 3); cwstep(cw); cwspin(cw, -1); // check this
+      cw = cw + wstep + 3 + wstep - 1; // check this
       }
     if(buildBarrier6(cw, 2)) return;    
     }
@@ -415,9 +378,9 @@ void extendBarrier(cell *c) {
     
     cellwalker cw(c, c->bardir);
     if(nonbitrunc) {
-      cwstep(cw); 
+      cw += wstep;
       if(isbar4(cw.c)) {
-        cwstep(cw); cwspin(cw, 3); cwstep(cw); cwspin(cw, -1); cwstep(cw);
+        cw = cw + wstep + 3 + wstep - 1 + wstep;
         bool b = buildBarrier4(cw.c, cw.spin, 2, oppositeElement(c->barleft, c->barright), c->barright);
         if(b) return;
         }
@@ -427,10 +390,10 @@ void extendBarrier(cell *c) {
         }
       }
     else {
-      cwspin(cw, 3); cwstep(cw); 
-      cell *cp = cwpeek(cw, 4);
+      cw = cw + 3 + wstep;
+      cell *cp = (cw + 4 + wstep).c;
       if(!isbar4(cp)) {
-        cwspin(cw, 2);  cwstep(cw);
+        cw = cw + 2 + wstep;
         bool b = buildBarrier4(cw.c, cw.spin, 2, oppositeElement(c->barleft, c->barright), c->barright);
         if(b) return;
         }
@@ -474,22 +437,23 @@ bool buildBarrier6(cellwalker cw, int type) {
   limitgen("build6 %p/%d (%d)\n", cw.c, cw.spin, type); 
   
   cellwalker b[4];
-  for(int i=0; i<4; i++) b[i] = cw;
   
   if(buggyGeneration) return true;
 
   if(!nonbitrunc) {
-    cwstep(b[0]);
-    cwspin(b[1], 1); cwstep(b[1]); cwspin(b[1], 3); cwstep(b[1]); 
-    cwspin(b[2], 4); cwstep(b[2]);
-    cwspin(b[3], 3); cwstep(b[3]); cwspin(b[3], 3); cwstep(b[3]);
+    b[0] = cw + wstep;
+    b[1] = cw + 1 + wstep + 3 + wstep;
+    b[2] = cw + 4 + wstep;
+    b[3] = cw + 3 + wstep + 3 + wstep;
     }
   else {
-    cwspin(b[1], 3); cwstep(b[1]); cwspin(b[1], 3);
-    cwspin(b[2], -2); cwstep(b[2]); cwspin(b[2], -3);
-    cwspin(b[3], -3); cwstep(b[3]); cwspin(b[3], 2); cwstep(b[3]); cwspin(b[3],-3);
+    b[0] = cw;
+    b[1] = cw + 3 + wstep + 3;
+    b[2] = cw - 2 + wstep - 3;
+    b[3] = cw - 3 + wstep + 2 + wstep - 3;
+
     if(type == 1 && b[3].c->land != laMirrorWall) return false;
-    if(type == 2 && cwpeek(b[1], 0)->land != laMirrorWall) return false;
+    if(type == 2 && (b[1] + wstep).c->land != laMirrorWall) return false;
     // if(type == 2 && b[2].c->land != laMirrorWall) return false;
     }
   
@@ -537,49 +501,44 @@ bool buildBarrier6(cellwalker cw, int type) {
     for(int z=0; z<4; z++)
       b[z].c->item = eItem(1+z+4*type);
     for(int a=0; a<4; a++) 
-      extendBarrierBack(cwpeek(b[a],0));
+      extendBarrierBack((b[a]+wstep).c);
     }
 
   if(!nonbitrunc) {
-    setland(cwpeek(cw, 1), laMirrorWall);
-    setland(cwpeek(cw, 2), laMirrored);
-    setland(cwpeek(cw, 3), laMirrorWall2);
-    setland(cwpeek(cw, 4), laMirrorWall2);
-    setland(cwpeek(cw, 5), laMirrored);
-    setland(cwpeek(cw, 0), laMirrorWall);
-    setland(cwpeek(b[0], 2), laMirrored);
-    setland(cwpeek(b[3], 6), laMirrored2);
-    setland(cwpeek(b[3], 5), laMirrored2);
-    setland(cwpeek(b[1], -1), laMirrored);
-    setland(cwpeek(b[2], -2), laMirrored);
-    setland(cwpeek(b[1], -2), laMirrored);
-    setland(cwpeek(b[0], -2), laMirror);
+    setland((cw+1+wstep).c, laMirrorWall);
+    setland((cw+2+wstep).c, laMirrored);
+    setland((cw+3+wstep).c, laMirrorWall2);
+    setland((cw+4+wstep).c, laMirrorWall2);
+    setland((cw+5+wstep).c, laMirrored);
+    setland((cw+0+wstep).c, laMirrorWall);
+    setland((b[0]+2+wstep).c, laMirrored);
+    setland((b[3]+6+wstep).c, laMirrored2);
+    setland((b[3]+5+wstep).c, laMirrored2);
+    setland((b[1]-1+wstep).c, laMirrored);
+    setland((b[2]-2+wstep).c, laMirrored);
+    setland((b[1]-2+wstep).c, laMirrored);
+    setland((b[0]-2+wstep).c, laMirror);
     cw.c->land = laMirrorWall;
     cw.c->wall = waMirrorWall;
     cw.c->landparam = 1;
     }
   else {
     setland(cw.c, laMirrorWall2);
-    setland(cwpeek(cw, 0), laMirrorWall2);
-    setland(cwpeek(cw, 1), laMirrored);
-    setland(cwpeek(cw, 2), laMirrored);
-    setland(cwpeek(cw, 3), laMirrorWall);
-    setland(cwpeek(cw, 4), laMirrored);
-    setland(cwpeek(cw, 5), laMirrorWall2);
-    setland(cwpeek(cw, 6), laMirrored2);
+    setland((cw+0+wstep).c, laMirrorWall2);
+    setland((cw+1+wstep).c, laMirrored);
+    setland((cw+2+wstep).c, laMirrored);
+    setland((cw+3+wstep).c, laMirrorWall);
+    setland((cw+4+wstep).c, laMirrored);
+    setland((cw+5+wstep).c, laMirrorWall2);
+    setland((cw+6+wstep).c, laMirrored2);
 
-    setland(cwpeek(b[1], 0), laMirrorWall);
-    setland(cwpeek(b[1], 1), laMirror);
-    setland(cwpeek(b[1], 2), laMirrorWall);
-    setland(cwpeek(b[1], 6), laMirrored);
+    setland((b[1]+wstep).c, laMirrorWall);
+    setland((b[1]+1+wstep).c, laMirror);
+    setland((b[1]+2+wstep).c, laMirrorWall);
+    setland((b[1]+6+wstep).c, laMirrored);
 
-    cellwalker cf = b[0];
-    cwstep(cf);
-    setland(cwpeek(cf, -2), laMirrored);
-
-    cf = b[3];
-    cwstep(cf);
-    setland(cwpeek(cf, -2), laMirrored);
+    setland((b[0] + wstep - 2 + wstep).c, laMirrored);
+    setland((b[3] + wstep - 2 + wstep).c, laMirrored);
     }
 
   return true;
@@ -591,27 +550,13 @@ bool buildBarrier4(cell *c, int d, int mode, eLand ll, eLand lr) {
   limitgen("build4 %p\n", c); 
   if(buggyGeneration) return true;
   d %= 7;
-  cellwalker b1(c, d);
-
-  cellwalker b2(c, d);
-  if(nonbitrunc) cwstep(b2);
-  else { cwstep(b2); cwspin(b2, 3); cwstep(b2); cwspin(b2, 3); cwstep(b2); }
   
-  cellwalker b3(c, d);
-  if(nonbitrunc) {
-    cwspin(b3, -1); cwstep(b3); cwspin(b3, 3);
-    }
-  else {
-    cwstep(b3); cwspin(b3, 4); cwstep(b3); cwspin(b3, 4);
-    }
-
-  cellwalker b4(c, d);
-  if(nonbitrunc) {
-    cwspin(b4, 1); cwstep(b4); cwspin(b4, -3);
-    }
-  else {
-    cwstep(b4); cwspin(b4, -4); cwstep(b4); cwspin(b4, -4);
-    }
+  cellwalker cd(c, d);
+  
+  cellwalker b1 = cd;
+  cellwalker b2 = nonbitrunc ? cd + wstep : cd + wstep + 3 + wstep + 3 + wstep;  
+  cellwalker b3 = nonbitrunc ? cd - 1 + wstep + 3 : cd + wstep + 4 + wstep + 4;
+  cellwalker b4 = nonbitrunc ? cd + 1 + wstep - 3 : cd + wstep - 4 + wstep - 4;
   
   if(mode == 0) {
     if(!((checkBarriersBack(b1) && checkBarriersBack(b2)))) return false;
@@ -643,19 +588,19 @@ bool buildBarrier4(cell *c, int d, int mode, eLand ll, eLand lr) {
   c->bardir = d, c->barleft = ll, c->barright = xr; extendBarrierFront(c);
   
   if(!nonbitrunc) for(int a=-3; a<=3; a++) if(a) {
-    setland(cwpeek(b1, a), a > 0 ? lr : ll);
-    setland(cwpeek(b2, a), a > 0 ? xr : xl);
-    setland(cwpeek(b3, a), a > 0 ? lr : xl);
-    setland(cwpeek(b4, a), a > 0 ? xr : ll);
+    setland((b1+a+wstep).c, a > 0 ? lr : ll);
+    setland((b2+a+wstep).c, a > 0 ? xr : xl);
+    setland((b3+a+wstep).c, a > 0 ? lr : xl);
+    setland((b4+a+wstep).c, a > 0 ? xr : ll);
     }
   
   if(nonbitrunc) setbarrier(b1.c), setbarrier(b2.c), setbarrier(b3.c), setbarrier(b4.c);
 
   if(!nonbitrunc) {
     cell *cp;
-    cp = cwpeek(b1, 0);
+    cp = (b1+wstep).c;
     cp->barleft = ll; cp->barright = lr; setbarrier(cp);
-    cp = cwpeek(b2, 0);
+    cp = (b2+wstep).c;
     cp->barleft = xl; cp->barright = xr; setbarrier(cp);
     }
   
diff --git a/bigstuff.cpp b/bigstuff.cpp
index 098186a6..ba4cafb8 100644
--- a/bigstuff.cpp
+++ b/bigstuff.cpp
@@ -175,8 +175,7 @@ heptagon *createAlternateMap(cell *c, int rad, hstate firststate, int special) {
   cell *cx[rad+1];
   for(int i=0; i<rad; i++) {
     cx[i] = bf.c;
-    cwrev(bf);
-    cwstep(bf);
+    bf += revstep;
     }
   cx[rad] = bf.c;
   heptagon *h = bf.c->master;
@@ -331,8 +330,8 @@ cell *buildAnotherEquidistant(cell *c, int radius) {
       for(int i=0; i<size(coastpath); i++) coastpath[i]->item = itPirate;
       return NULL;
       }
-    cwstep(cw); cwspin(cw, 3); 
-    if(ctof(cw.c) && hrand(2) == 0) cwspin(cw, 1);
+    cw = cw + wstep + 3;
+    if(ctof(cw.c) && hrand(2) == 0) cw++;
     }
   coastpath.push_back(cw.c);
   // printf("setdists\n");
diff --git a/cell.cpp b/cell.cpp
index 905f3a1c..feac765b 100644
--- a/cell.cpp
+++ b/cell.cpp
@@ -172,12 +172,7 @@ struct hrmap_spherical : hrmap {
       heptspin hs;
       hs.h = dodecahedron[i];
       hs.spin = k;
-      hs = hsstep(hs, 0);
-      hs = hsspin(hs, S7-1);
-      hs = hsstep(hs, 0);
-      hs = hsspin(hs, S7-1);
-      hs = hsstep(hs, 0);
-      hs = hsspin(hs, S7-1);
+      hs = hs + wstep + (S7-1) + wstep + (S7-1) + wstep + (S7-1);
       if(hs.h != dodecahedron[i]) printf("error %d,%d\n", i, k);
       }
     for(int i=0; i<spherecells(); i++) verifycells(dodecahedron[i]);
@@ -558,8 +553,8 @@ namespace quotientspace {
     code res;
     res.c[0] = cod(hs.h);
     for(int i=1; i<=S7; i++) {
-      res.c[i] = cod(hsstep(hs, 0).h);
-      hs = hsspin(hs, 1);
+      res.c[i] = cod((hs + wstep).h);
+      hs += 1;
       }
     return res;
     }
@@ -586,7 +581,7 @@ struct hrmap_quotient : hrmap {
     if(!reachable.count(g)) {
       reachable[g] = bfsq.size();
       bfsq.push_back(hs);
-      add(hsspin(hs, 1));
+      add(hs + 1);
       }
     }
 
@@ -605,7 +600,7 @@ struct hrmap_quotient : hrmap {
       add(hs);
 
       for(int i=0; i<(int)bfsq.size(); i++) {
-        hs = hsstep(bfsq[i], 0);
+        hs = bfsq[i] + wstep;
         add(hs);
         connections.push_back(reachable[get(hs)]);
         }
@@ -674,37 +669,59 @@ struct hrmap_quotient : hrmap {
 
 cell *createMov(cell *c, int d);
 
-void cwspin(cellwalker& cw, int d) {
-  cw.spin = (cw.spin+(MIRR(cw)?-d:d) + MODFIXER) % cw.c->type;
+cellwalker& operator += (cellwalker& cw, int spin) {
+  cw.spin = (cw.spin+(MIRR(cw)?-spin:spin) + MODFIXER) % cw.c->type;
+  return cw;
   }
 
+cellwalker& operator += (cellwalker& cw, wstep_t) {
+  createMov(cw.c, cw.spin);
+  int nspin = cw.c->spn(cw.spin);
+  if(cw.c->mirror(cw.spin)) cw.mirrored = !cw.mirrored;
+  cw.c = cw.c->mov[cw.spin];
+  cw.spin = nspin;
+  return cw;
+  }
+
+cellwalker& operator -= (cellwalker& cw, int i) { return cw += (-i); }
+
+cellwalker& operator += (cellwalker& cw, wmirror_t) {
+  cw.mirrored = !cw.mirrored;
+  return cw;
+  }
+
+template <class T> cellwalker operator + (cellwalker h, T t) { return h += t; }
+template <class T> cellwalker operator - (cellwalker h, T t) { return h += (-t); }
+
+cellwalker& operator ++ (cellwalker& h, int) { return h += 1; }
+cellwalker& operator -- (cellwalker& h, int) { return h -= 1; }
+
 bool cwstepcreates(cellwalker& cw) {
   return cw.c->mov[cw.spin] == NULL;
   }
 
+/*
 cell *cwpeek(cellwalker cw, int dir) {
-  return createMov(cw.c, (cw.spin+MODFIXER+(MIRR(cw)?-dir:dir)) % cw.c->type);
-  }
+  return (cw+dir+wstep).c;.
+  // return createMov(cw.c, (cw.spin+MODFIXER+(MIRR(cw)?-dir:dir)) % cw.c->type);
+  } */
 
 void cwmirrorat(cellwalker& cw, int d) {
   cw.spin = (d+d - cw.spin + MODFIXER) % cw.c->type;
   cw.mirrored = !cw.mirrored;
   }
 
-void cwstep(cellwalker& cw) {
-  createMov(cw.c, cw.spin);
-  int nspin = cw.c->spn(cw.spin);
-  if(cw.c->mirror(cw.spin)) cw.mirrored = !cw.mirrored;
-  cw.c = cw.c->mov[cw.spin];
-  cw.spin = nspin;
+static const struct rev_t { } rev;
+
+cellwalker& operator += (cellwalker& cw, rev_t) {
+  cw += cw.c->type/2 + ((cw.c->type&1)?hrand(2):0);
+  return cw;
   }
 
-void cwrev(cellwalker& cw) {
-  cwspin(cw, cw.c->type/2 + ((cw.c->type&1)?hrand(2):0));
-  }
+static const struct revstep_t { } revstep;
 
-void cwrevstep(cellwalker& cw) {
-  cwrev(cw); cwstep(cw);
+cellwalker& operator += (cellwalker& cw, revstep_t) {
+  cw += rev; cw += wstep; return cw;
   }
 
 // very similar to createMove in heptagon.cpp
@@ -746,7 +763,7 @@ cell *createMov(cell *c, int d) {
     */
     
     for(int u=2; u<S6; u+=2) {
-      hs = hsstep(hsspin(hs, alt3), -alt4);
+      hs = hs + alt3 + wstep - alt4;
       merge(hs.h->c7, hs.spin, n, u, hs.mirrored);
       }
     
@@ -1171,15 +1188,17 @@ cdata *getHeptagonCdata(heptagon *h) {
       hstab[7] = hs;
       
       for(int i=8; i<12; i++) {
-        hstab[i] = hsspin(hstab[i-1], (i&1) ? 4 : 3);
-        hstab[i] = hsstep(hstab[i], 0);
-        hstab[i] = hsspin(hstab[i], (i&1) ? 3 : 4);
+        hstab[i] = hstab[i-1];
+        hstab[i] += ((i&1) ? 4 : 3);
+        hstab[i] += wstep;
+        hstab[i] += ((i&1) ? 3 : 4);
         }
 
       for(int i=6; i>=3; i--) {
-        hstab[i] = hsspin(hstab[i+1], (i&1) ? 3 : 4);
-        hstab[i] = hsstep(hstab[i], 0);
-        hstab[i] = hsspin(hstab[i], (i&1) ? 4 : 3);
+        hstab[i] = hstab[i+1];
+        hstab[i] += ((i&1) ? 3 : 4);
+        hstab[i] += wstep;
+        hstab[i] += ((i&1) ? 4 : 3);
         }
       
       if(hstab[3].h->distance < hstab[7].h->distance) {
@@ -1205,7 +1224,7 @@ cdata *getHeptagonCdata(heptagon *h) {
       
       break;
       }
-    hs = hsstep(hsspin(hs, 3), 0);
+    hs = hs + 3 + wstep;
     setHeptagonRval(hs.h);
     
     affect(mydata, hs.spin ? hs.h->rval0 : hs.h->rval1, signum);
diff --git a/complex.cpp b/complex.cpp
index a5ba7739..ce84db87 100644
--- a/complex.cpp
+++ b/complex.cpp
@@ -1101,52 +1101,25 @@ namespace mirror {
     cell *c = cw.c;
     
     for(int i=0; i<cw.c->type; i++) {
-      cwstep(cw);
-      if(cw.c->type == c->type) {
-        cwspin(cw, i);
-        createMirror(cw, cpid);
-        cwspin(cw, -i);
-        }
-      cwstep(cw);
-      cwspin(cw, 1);
+      auto cws = cw + wstep;
+      if(cws.c->type == c->type) 
+        createMirror(cws+i, cpid);
+      cw += 1;
       }
     }
   
   void createMirages(cellwalker cw, int cpid) {
     if(nonbitrunc) {
-      for(int i=0; i<cw.c->type; i++) {
-        cellwalker C2 = cw;
-        cwstep(C2);
-        cwspin(C2, 3);
-        cwstep(C2);
-        cwspin(C2, 5);
-        cwstep(C2);
-        cwspin(C2, 3);
-        cwspin(C2, -i);
-        createMirror(C2, cpid);
-        cwspin(cw, 1);
-        }
+      for(int i=0; i<cw.c->type; i++)
+        createMirror(cw + i + wstep + 3 + wstep + 5 + wstep + 3 - i, cpid);
       return;
       }
     for(int i=0; i<S6; i++) {
-      cwstep(cw);
-      if(!ctof(cw.c)) {
-        cwspin(cw, 2);
-        cwstep(cw);
-        cwspin(cw, S6-2-i);
-        createMirror(cw, cpid);
-        cwspin(cw, 2+i);
-        cwstep(cw);
-        cwspin(cw, S6-4);
-        cwstep(cw);
-        cwspin(cw, 2-i);
-        createMirror(cw, cpid);
-        cwspin(cw, S6-2+i);
-        cwstep(cw);
-        cwspin(cw, 2);
+      auto cw0 = cw + i + wstep;
+      if(!ctof(cw0.c)) {
+        createMirror(cw0 + 2 + wstep - (2+i), cpid);
+        createMirror(cw0 - 2 + wstep + (2-i), cpid);
         }
-      cwstep(cw);
-      cwspin(cw, 1);
       }
     }
 
@@ -1174,7 +1147,7 @@ namespace mirror {
   
   bool isKilledByMirror(cell *c) {
     for(auto& m: mirrors) {
-      cell *c1 = cwpeek(m.second, 0);
+      cell *c1 = (m.second + wstep).c;
       if(inmirror(c1)) c1 = reflect(cellwalker(c1, 0, false)).c;
       if(c1 == c && canAttack(m.second.c, moMimic, c, c->monst, 0))
         return true;
@@ -1193,8 +1166,7 @@ namespace mirror {
       if(m.first == multi::cpid) {
         cell *c = m.second.c;
         if(!m.second.mirrored) nummirage++;
-        auto cw2 = m.second;
-        cwstep(cw2);
+        auto cw2 = m.second + wstep;
         if(inmirror(cw2)) cw2 = reflect(cw2);
         cell *c2 = cw2.c;
         if(c2->monst) {
@@ -1241,7 +1213,7 @@ namespace mirror {
     if(spinning && d) {
       for(auto& m: mirrors)
         if(m.first == multi::cpid)
-          cwspin(m.second, d);
+          m.second += d;
       }
     if(flags & ATTACK)
       go(flags & GO);
@@ -1281,9 +1253,9 @@ namespace mirror {
   pair<bool, cellwalker> traceback(vector<int>& v, cellwalker cw) {
     bool goout = false;
     for(int i=size(v)-1; i>=0; i--) {
-      if(v[i]) cwspin(cw, -v[i]);
+      if(v[i]) cw -= v[i];
       else { 
-        cwstep(cw);
+        cw += wstep;
         if(cw.c->land == laMirrorWall || cw.c->land == laMirror) goout = true;
         }
       }
@@ -1302,67 +1274,67 @@ namespace mirror {
       stepcount++; if(stepcount > 10000) {
          return cw; 
          }
-      cell *c0 = cwpeek(cw, 0);
+      cell *c0 = (cw+wstep).c;
       int go = 0;
       if(!inmirror(c0)) go = 2;
       else if(depth(c0) && depth(c0) < depth(cw.c)) go = 1;
       if(go) {
         v.push_back(0);
-        cwstep(cw);
+        cw += wstep;
         if(go == 2) break;
         }
       else {
         v.push_back(1);
-        cwspin(cw, 1);
+        cw += 1;
         }        
       }
     if(cw.c->land == laMirrorWall || cw.c->land == laMirrorWall2) {
       if(cw.c->type == 7) {
         while(cw.spin != cw.c->bardir) {
-          cwspin(cw, 1);
+          cw += 1;
           v.push_back(1);
           stepcount++; if(stepcount > 10000) { printf("failhep\n"); return cw; }
           }
-        if(nonbitrunc && cwpeek(cw,0) == cwcopy.c)
+        if(nonbitrunc && (cw+wstep).c == cwcopy.c)
           v.pop_back();
-        if(nonbitrunc && cwpeek(cw,3)->land == laMirrored && cwpeek(cw,2)->land == laMirrorWall) {
-          cw.mirrored = !cw.mirrored;
+        if(nonbitrunc && (cw+3+wstep).c->land == laMirrored && (cw+2+wstep).c->land == laMirrorWall) {
+          cw += wmirror;
           auto p = traceback(v, cw);
           if(p.first) return p.second;
-          cwspin(cw, 2); 
+          cw += 2;
           v.push_back(2);
-          cwstep(cw); 
+          cw += wstep;
           v.push_back(0);
-          cwspin(cw, 3); 
+          cw += 3;
           v.push_back(3);
           }
         }
       else {
-        while(cwpeek(cw,0)->type != 7) {
-          cwspin(cw, 1);
+        while((cw+wstep).c->type != 7) {
+          cw ++;
           v.push_back(1);
           }
         int icount = 0;
         for(int i=0; i<3; i++) {
-          if(cwpeek(cw, 0)->bardir == cw.c->spin(cw.spin))
+          if((cw+wstep).c->bardir == cw.c->spin(cw.spin))
             icount++;
-          cwspin(cw, 2);
+          cw += 2;
           }
         if(icount >= 2) {
           cellwalker cwcopy = cw;
           for(int a=0; a<3; a++) for(int m=0; m<2; m++) {
             cellwalker cw = cwcopy;
             if(m) cw.mirrored = !cw.mirrored;
-            cwspin(cw, a*2);
+            cw += (a*2);
             auto p = traceback(v,cw);
             if(p.first) return p.second;
             }
           printf("icount >= 2 but failed\n");
           return cw;
           }
-        while(cwpeek(cw, 0)->bardir != cw.c->spin(cw.spin)) {
+        while((cw+wstep).c->bardir != cw.c->spin(cw.spin)) {
           stepcount++; if(stepcount > 10000) { printf("fail2\n"); return cw; }
-          cwspin(cw, 2);
+          cw += 2;
           v.push_back(1);
           v.push_back(1);
           }
@@ -1405,8 +1377,7 @@ namespace mirror {
       while(inmirror(cache[cid].second.c) && tries--)
         cache[cid].second = reflect0(cache[cid].second);
       }
-    cellwalker res = cache[cid].second;
-    cwspin(res, cw.spin);
+    cellwalker res = cache[cid].second + cw.spin;
     if(cw.mirrored) res.mirrored = !res.mirrored;
     return res;
     }
@@ -1733,10 +1704,10 @@ namespace hive {
 
     for(int i=2; i<radius; i++) {
       if(bf.c->type == 6)
-        cwspin(bf, 3);
+        bf += 3;
       else
-        cwspin(bf, 3 + hrand(2));
-      cwstep(bf);
+        bf += 3 + hrand(2);
+      bf += wstep;
       }
     cell *citycenter = bf.c;
     buginfo.clear();
diff --git a/debug.cpp b/debug.cpp
index 9f5dd8b9..9e48d538 100644
--- a/debug.cpp
+++ b/debug.cpp
@@ -198,7 +198,7 @@ bool applyCheat(char u, cell *c = NULL) {
   if(u == 'Z') {
     flipplayer = false;
     mirror::act(1, mirror::SPINSINGLE);
-    cwspin(cwt, 1);
+    cwt++;
     wavephase = (1+wavephase) & 7;
     return true;
     }
diff --git a/game.cpp b/game.cpp
index 471d53d0..393881c6 100644
--- a/game.cpp
+++ b/game.cpp
@@ -3176,12 +3176,12 @@ array<cell*, 5> traplimits(cell *c) {
   res[2] = c;
   for(int d=0; d<c->type; d++) {
     cellwalker cw(c, d);
-    cwstep(cw);
+    cw += wstep;
     if(cw.c->wall != waArrowTrap) continue;
     res[1+q*2] = cw.c;
-    cwspin(cw, cw.c->type/2);
-    if((cw.c->type&1) && cwpeek(cw, 0)->wall != waStone) cwspin(cw, 1);
-    cwstep(cw);
+    cw += (cw.c->type/2);
+    if((cw.c->type&1) && (cw+wstep).c->wall != waStone) cw += 1;
+    cw += wstep;
     res[(q++)*4] = cw.c;
     }
   while(q<2) { res[q*4] = res[1+q*2] = NULL; q++; }
@@ -3790,12 +3790,12 @@ void determinizeBull(cell *c, int *posdir, int& nc) {
 int determinizeBullPush(cellwalker bull) {
   int nc = 2;
   int dirs[2], positive;
-  cwstep(bull);
+  bull += wstep;
   cell *c2 = bull.c;
   if(!(c2->type & 1)) return 1; // irrelevant
   int d = c2->type / 2;
-  cwspin(bull, d); dirs[0] = positive = bull.spin;
-  cwspin(bull, -2*d); dirs[1] = bull.spin;
+  bull += d; dirs[0] = positive = bull.spin;
+  bull -= 2*d; dirs[1] = bull.spin;
   determinizeBull(c2, dirs, nc);
   if(dirs[0] == positive) return -1;
   return 1;
@@ -3854,24 +3854,22 @@ cell *determinePush(cellwalker who, cell *c2, int subdir, T valid) {
       addMessage("bad push: " + its(subdir));
     }
   cellwalker push = who;
-  cwstep(push);
+  push += wstep;
   int pd = push.c->type/2;
-  cwspin(push, pd * -subdir);
-  cwstep(push);
+  push += pd * -subdir;
+  push += wstep;
   if(valid(push.c)) return push.c;
   if(c2->type&1) {
-    cwstep(push);
-    cwspin(push, 1 * -subdir);
-    cwstep(push);
+    push = push + wstep - subdir + wstep;
     if(valid(push.c)) return push.c;
     }
   if(gravityLevel(push.c) < gravityLevel(c2)) {
-    cwstep(push); cwspin(push, 1); cwstep(push);
+    push = push + wstep + 1 + wstep;
     if(gravityLevel(push.c) < gravityLevel(c2)) {
-      cwstep(push); cwspin(push, -2); cwstep(push);
+      push = push + wstep - 2 + wstep;
       }
     if(gravityLevel(push.c) < gravityLevel(c2)) {
-      cwstep(push); cwspin(push, 1); cwstep(push);
+      push = push + wstep + 1 + wstep;
       }
     if(valid(push.c)) return push.c;
     }
@@ -4290,21 +4288,21 @@ void ivynext(cell *c) {
   cw.c->monst = moIvyWait;
   bool findleaf = false;
   while(true) {
-    cwspin(cw, 1);
+    cw += 1;
     if(cw.spin == signed(cw.c->mondir)) {
       if(findleaf) { 
         cw.c->monst = moIvyHead; break;
         }
       cw.c->monst = moIvyWait;
-      cwstep(cw);
+      cw += wstep;
       continue;
       }
-    cwstep(cw);
+    cw += wstep;
     if(cw.c->monst == moIvyWait && signed(cw.c->mondir) == cw.spin) {
       cw.c->monst = moIvyBranch;
       findleaf = true; continue;
       }
-    cwstep(cw);
+    cw += wstep;
     }
   }
 
@@ -7259,7 +7257,7 @@ bool movepcto(int d, int subdir, bool checkonly) {
   if(!checkonly) { DEBB(DF_TURN, (debugfile,"movepc\n")); }
   int origd = d;
   if(d >= 0) {
-    cwspin(cwt, d);
+    cwt += d;
     mirror::act(d, mirror::SPINSINGLE);
     d = cwt.spin;
     }
@@ -7775,7 +7773,7 @@ bool movepcto(int d, int subdir, bool checkonly) {
 
       stabbingAttack(cwt.c, c2, moPlayer);
       cell *c1 = cwt.c;
-      cwstep(cwt);
+      cwt += wstep;
       if(switchplaces)
         animateReplacement(c1, cwt.c, LAYER_SMALL);
       else
diff --git a/graph.cpp b/graph.cpp
index f4f80e9d..2f70ac7f 100644
--- a/graph.cpp
+++ b/graph.cpp
@@ -2029,8 +2029,8 @@ bool drawMonster(const transmatrix& Vparam, int ct, cell *c, int col) {
       multi::cpid = m.first;
       auto cw = m.second;
       if(d&1) cwmirrorat(cw, xdir);
-      if(d>=2) cwspin(cw, 2);
-      if(d>=4) cwspin(cw, 2);
+      if(d>=2) cw += 2;
+      if(d>=4) cw += 2;
       transmatrix Vs = Vparam;
       bool mirr = cw.mirrored;
       Vs = Vs * ddspin(c, cw.spin-cwt.spin, euclid ? 0 : S42);
@@ -2538,7 +2538,7 @@ void drawMovementArrows(cell *c, transmatrix V) {
   
     movedir md = vectodir(spin(-d * M_PI/4) * tC0(pushone()));
     int u = md.d;
-    cellwalker xc = cwt; cwspin(xc, u); cwstep(xc);
+    cellwalker xc = cwt + u + wstep;
     if(xc.c == c) {
       transmatrix fixrot = rgpushxto0(tC0(V));
       // make it more transparent
diff --git a/heptagon.cpp b/heptagon.cpp
index 5b47fad2..65fad1f3 100644
--- a/heptagon.cpp
+++ b/heptagon.cpp
@@ -171,22 +171,23 @@ extern int hrand(int);
 // a structure used to walk on the heptagonal tesselation
 // (remembers not only the heptagon, but also direction)
 
-heptspin hsstep(const heptspin &hs, int spin) {
+heptspin& operator += (heptspin& hs, int spin) {
+  hs.spin = fixrot(hs.spin + (MIRR(hs)?-spin:spin));
+  return hs;
+  }
+
+heptspin operator + (const heptspin& hs, wstep_t) {
   createStep(hs.h, hs.spin);
   heptspin res;
   res.h = hs.h->move[hs.spin];
   res.mirrored = hs.mirrored ^ hs.h->mirror(hs.spin);
-  res.spin = fixrot(hs.h->spin(hs.spin) + (MIRR(res)?-spin:spin));
+  res.spin = hs.h->spin(hs.spin);
   return res;
   }
 
-heptspin hsspin(const heptspin &hs, int val) {
-  heptspin res;
-  res.h = hs.h;
-  res.spin = fixrot(hs.spin + (MIRR(hs)?-val:val));
-  res.mirrored = hs.mirrored;
-  return res;
-  }
+heptspin operator + (heptspin h, int spin) { return h += spin; }
+heptspin operator - (heptspin h, int spin) { return h += -spin; }
+heptspin& operator += (heptspin& h, wstep_t) { h = h + wstep; return h; }
 
 heptagon *createStep(heptagon *h, int d) {
   d = fixrot(d);
@@ -211,9 +212,7 @@ heptagon *createStep(heptagon *h, int d) {
      hs.h = h;
       hs.spin = 0;
       hs.mirrored = false;
-      hs = hsstep(hs, -1);
-      hs = hsstep(hs, -1);
-      hs = hsstep(hs, -1);
+      hs = hs + wstep - 1 + wstep - 1 + wstep - 1;
       connectHeptagons(h, d, hs.h, hs.spin);
       }
     else if(h->s == hsB && d == S7-1) {
@@ -221,9 +220,7 @@ heptagon *createStep(heptagon *h, int d) {
       hs.h = h;
       hs.spin = 0;
       hs.mirrored = false;
-      hs = hsstep(hs, 1);
-      hs = hsstep(hs, 1);
-      hs = hsstep(hs, 1);
+      hs = hs + wstep + 1 + wstep + 1 + wstep + 1;
       connectHeptagons(h, d, hs.h, hs.spin);    
       }
     else 
diff --git a/hyper.h b/hyper.h
index e81eb8bb..a22516aa 100644
--- a/hyper.h
+++ b/hyper.h
@@ -56,6 +56,52 @@ inline transmatrix operator * (const transmatrix& T, const transmatrix& U) {
   return R;
   }
 
+hyperpoint hpxyz(ld x, ld y, ld z);
+
+namespace hyperpoint_vec {
+
+  inline hyperpoint& operator *= (hyperpoint& h, ld d) {
+    h[0] *= d; h[1] *= d; h[2] *= d;
+    return h;
+    }
+  
+  inline hyperpoint& operator /= (hyperpoint& h, ld d) { 
+    h[0] /= d; h[1] /= d; h[2] /= d;
+    return h;
+    }
+  
+  inline hyperpoint operator += (hyperpoint& h, hyperpoint h2) { 
+    for(int i: {0,1,2}) h[i] += h2[i];
+    return h;
+    }
+
+  inline hyperpoint operator -= (hyperpoint& h, hyperpoint h2) { 
+    for(int i: {0,1,2}) h[i] -= h2[i];
+    return h;
+    }
+
+  inline hyperpoint operator * (ld d, hyperpoint h) { return h *= d; }  
+  inline hyperpoint operator * (hyperpoint h, ld d) { return h *= d; }  
+  inline hyperpoint operator / (hyperpoint h, ld d) { return h /= d; }  
+  inline hyperpoint operator + (hyperpoint h, hyperpoint h2) { return h += h2; }
+  inline hyperpoint operator - (hyperpoint h, hyperpoint h2) { return h -= h2; }
+
+  // cross product  
+  inline hyperpoint operator ^ (hyperpoint h1, hyperpoint h2) {
+    return hpxyz(
+      h1[1] * h2[2] - h1[2] * h2[1],
+      h1[2] * h2[0] - h1[0] * h2[2],
+      h1[0] * h2[1] - h1[1] * h2[0]
+      );
+    }
+
+  // inner product
+  inline ld operator | (hyperpoint h1, hyperpoint h2) {
+    return h1[0] * h2[0] + h1[1] * h2[1] + h1[2] * h2[2];
+    }    
+  }
+
+
 extern int cellcount, heptacount;
 
 // cell information for the game
@@ -2083,11 +2129,7 @@ struct polytodraw {
 
 extern int emeraldtable[100][7];
 
-extern void cwspin(cellwalker& cw, int d);
-extern cell *cwpeek(cellwalker cw, int dir);
-extern void cwstep(cellwalker& cw);
-extern void cwrevstep(cellwalker& cw);
-extern void cwrev(cellwalker& cw);
+// extern cell *cwpeek(cellwalker cw, int dir);
 
 const eLand NOWALLSEP = laNone;
 const eLand NOWALLSEP_USED = laWhirlpool;
@@ -2384,7 +2426,12 @@ extern int startseed;
 extern transmatrix heptmove[MAX_EDGE], hexmove[MAX_EDGE];
 extern transmatrix invheptmove[MAX_EDGE], invhexmove[MAX_EDGE];
 
-heptspin hsstep(const heptspin &hs, int spin);
+static const struct wstep_t { } wstep;
+static const struct wmirror_t { } wmirror;
+
+// heptspin hsstep(const heptspin &hs, int spin);
+
+template<class T> 
 
 extern void fixmatrix(transmatrix&);
 void display(const transmatrix& T);
diff --git a/hyperpoint.cpp b/hyperpoint.cpp
index cb579a80..8c1cb9b6 100644
--- a/hyperpoint.cpp
+++ b/hyperpoint.cpp
@@ -450,49 +450,6 @@ double hdist(const hyperpoint& h1, const hyperpoint& h2) {
     }
   }
 
-namespace hyperpoint_vec {
-
-  hyperpoint& operator *= (hyperpoint& h, ld d) {
-    h[0] *= d; h[1] *= d; h[2] *= d;
-    return h;
-    }
-  
-  hyperpoint& operator /= (hyperpoint& h, ld d) { 
-    h[0] /= d; h[1] /= d; h[2] /= d;
-    return h;
-    }
-  
-  hyperpoint operator += (hyperpoint& h, hyperpoint h2) { 
-    for(int i: {0,1,2}) h[i] += h2[i];
-    return h;
-    }
-
-  hyperpoint operator -= (hyperpoint& h, hyperpoint h2) { 
-    for(int i: {0,1,2}) h[i] -= h2[i];
-    return h;
-    }
-
-  hyperpoint operator * (ld d, hyperpoint h) { return h *= d; }  
-  hyperpoint operator * (hyperpoint h, ld d) { return h *= d; }  
-  hyperpoint operator / (hyperpoint h, ld d) { return h /= d; }  
-  hyperpoint operator + (hyperpoint h, hyperpoint h2) { return h += h2; }
-  hyperpoint operator - (hyperpoint h, hyperpoint h2) { return h -= h2; }
-
-  // cross product  
-  hyperpoint operator ^ (hyperpoint h1, hyperpoint h2) {
-    return hpxyz(
-      h1[1] * h2[2] - h1[2] * h2[1],
-      h1[2] * h2[0] - h1[0] * h2[2],
-      h1[0] * h2[1] - h1[1] * h2[0]
-      );
-    }
-
-  // inner product
-  ld operator | (hyperpoint h1, hyperpoint h2) {
-    return h1[0] * h2[0] + h1[1] * h2[1] + h1[2] * h2[2];
-    }    
-  }
-
 hyperpoint mscale(const hyperpoint& t, double fac) {
   hyperpoint res;
   for(int i=0; i<3; i++) 
diff --git a/hypgraph.cpp b/hypgraph.cpp
index 812af14d..1f8e02aa 100644
--- a/hypgraph.cpp
+++ b/hypgraph.cpp
@@ -378,7 +378,7 @@ void drawrec(const heptspin& hs, int lev, hstate s, const transmatrix& V) {
   for(int d=0; d<S7; d++) {
     hstate s2 = transition(s, d);
     if(s2 == hsError) continue;
-    heptspin hs2 = hsstep(hsspin(hs, d), 0);
+    heptspin hs2 = hs + d + wstep;
     drawrec(hs2, lev-2, s2, V * heptmove[d]);
     }
   
@@ -566,8 +566,7 @@ void optimizeview() {
   if(turn >= 0) {
     View = View * TB;
     fixmatrix(View);
-    viewctr = hsspin(viewctr, turn);
-    viewctr = hsstep(viewctr, 0);
+    viewctr = viewctr + turn + wstep;
     }
   }
 
diff --git a/kohonen.cpp b/kohonen.cpp
index fd1a9a29..8c60fede 100644
--- a/kohonen.cpp
+++ b/kohonen.cpp
@@ -300,8 +300,7 @@ struct cellcrawler {
     for(int i=0; i<size(data); i++) {
       cellwalker cw0 = data[i].orig;
       for(int j=0; j<cw0.c->type; j++) {
-        cellwalker cw = cw0;
-        cwspin(cw, j); cwstep(cw);
+        cellwalker cw = cw0 + j + wstep;
         if(!getNeuron(cw.c)) continue;
         store(cw, i, j);
         }
@@ -317,9 +316,9 @@ struct cellcrawler {
       cellcrawlerdata& s = data[i];
       s.target = data[s.from].target;
       if(!s.target.c) continue;
-      cwspin(s.target, s.spin);
+      s.target += s.spin;
       if(cwstepcreates(s.target)) s.target.c = NULL;
-      else cwstep(s.target);
+      else s.target += wstep;
       }
     }
   };
diff --git a/landgen.cpp b/landgen.cpp
index 6b12a737..f5a0070a 100644
--- a/landgen.cpp
+++ b/landgen.cpp
@@ -274,15 +274,7 @@ void giantLandSwitch(cell *c, int d, cell *from) {
           cell *c2 = NULL;
           for(int i=0; i<c->type; i++) {
             cellwalker cw(c, i);
-            cwstep(cw);
-            cwspin(cw, 4);
-            cwstep(cw);
-            cwspin(cw, 2);
-            cwstep(cw);
-            cwspin(cw, 4);
-            cwstep(cw);
-            cwspin(cw, 2 + hrand(3));
-            cwstep(cw);
+            cw = cw + wstep + 4 + wstep + 2 + wstep + 4 + wstep + (2 + hrand(3)) + wstep;
             if(!c2) c2 = cw.c;
             else if(celldist(cw.c) > celldist(c2)) c2 = cw.c;
             cw.c->monst = moMouse;
@@ -904,8 +896,8 @@ void giantLandSwitch(cell *c, int d, cell *from) {
           cell* cc[5];
           cc[2] = c;
           cellwalker cw2 = cw;
-          cwstep(cw); cc[3] = cw.c; cwrevstep(cw); cc[4] = cw.c;
-          cwrevstep(cw2); cc[1] = cw2.c; cwrevstep(cw2); cc[0] = cw2.c;
+          cw += wstep; cc[3] = cw.c; cw += revstep; cc[4] = cw.c;
+          cw2 += revstep; cc[1] = cw2.c; cw2 += revstep; cc[0] = cw2.c;
           bool ok = true;
           for(int i=0; i<5; i++) {
             if(cc[i]->land != laNone && cc[i]->land != laTerracotta) ok = false;
@@ -1681,10 +1673,9 @@ void giantLandSwitch(cell *c, int d, cell *from) {
                 vector<pair<cell*, cell*>> next;
                 int bonus = c->type - 4;
                 for(int i=0; i<c->type; i++) {
-                  cellwalker cw0(c, i);
-                  cwstep(cw0); cwrevstep(cw0);
-                  cellwalker cw1(c, i+bonus);
-                  cwspin(cw1, 0); cwstep(cw1); cwrevstep(cw1);
+                  cellwalker ci(c, i);
+                  cellwalker cw0 = ci + wstep + revstep;
+                  cellwalker cw1 = ci + bonus + wstep + revstep;
                   if(cw0.c->mpdist > 7)
                   if(cw1.c->mpdist > 7)
                     next.emplace_back(cw0.c, cw1.c);
diff --git a/mapeditor.cpp b/mapeditor.cpp
index a854a3f2..f0288be6 100644
--- a/mapeditor.cpp
+++ b/mapeditor.cpp
@@ -621,11 +621,11 @@ namespace mapeditor {
       auto sd = spill_list[i];
       for(int i=0; i<sd.first.c->type; i++) {
         auto sd2 = sd;
-        cwspin(sd2.first, i); cwstep(sd2.first);
+        sd2.first = sd2.first + i + wstep;
         if(eq(sd2.first.c->aitmp, sval)) continue; 
         sd2.first.c->aitmp = sval;
         if(sd2.second.c) {
-          cwspin(sd2.second, i); cwstep(sd2.second);
+          sd2.second = sd2.second + i + wstep;
           if(sd2.second.c->land == laNone) continue;
           }
         spill_list.push_back(sd2);
@@ -663,7 +663,7 @@ namespace mapeditor {
       if(where.c->type != copysource.c->type) return;
       if(where.spin<0) where.spin=0;
       if(!nonbitrunc && !ctof(mouseover) && ((where.spin&1) != (copysource.spin&1)))
-        cwspin(where, 1);
+        where += 1;
       }
     if(painttype != 4) copysource.c = NULL;
     list_spill(where, copysource);
diff --git a/orbs.cpp b/orbs.cpp
index 9b73e7c7..bc9db9ab 100644
--- a/orbs.cpp
+++ b/orbs.cpp
@@ -353,7 +353,7 @@ void castLightningBolt(cellwalker lig) {
     
     if(lig.c->mov[lig.spin] == NULL) break;
 
-    cwstep(lig);
+    lig += wstep;
     if(inmirror(lig)) lig = mirror::reflect(lig);
     
     cell *c = lig.c;
@@ -440,7 +440,7 @@ void castLightningBolt(cellwalker lig) {
       drawParticles(c, winf[ow].color, 16);
 
     if(c == cwt.c)             {bnc++; if(bnc > 10) break; }
-    if(spin) cwspin(lig, hrand(lig.c->type));
+    if(spin) lig += hrand(lig.c->type);
     
     if(brk) break;
     
@@ -449,14 +449,13 @@ void castLightningBolt(cellwalker lig) {
       int right = 1;
       while(!reflectingBarrierAt(lig, left)) left--;
       while(!reflectingBarrierAt(lig, right)) right++;
-      cwspin(lig, right + left);
+      lig += right + left;
       if(c->wall == waBarrowWall) c->wall = waBarrowDig;
       else if(c->wall == waBarrowDig) c->wall = waNone;
       bnc++; if(bnc > 10) break;
       }
-    else {
-      cwrev(lig);
-      }
+    else 
+      lig += rev;
     
     if(lig.c->wall == waCloud) {
       lig.c->wall = waNone;
diff --git a/patterngen.cpp b/patterngen.cpp
index e1758416..cb8a9284 100644
--- a/patterngen.cpp
+++ b/patterngen.cpp
@@ -131,13 +131,9 @@ void patternFiftyAt(cell *c) {
 
       for(int i=0; i<c->type; i++) {
         cellwalker cw(c, i);
-        cwstep(cw); // cw.c->item = itSilver;
-        cwspin(cw, 4); // 6
-        cwstep(cw); // cw.c->item = itSilver;
-        cwspin(cw, 3); // 6
-        cwstep(cw); cw.c->wall = waFloorA; cwstep(cw);
-        cwspin(cw, 1);
-        cwstep(cw); cw.c->wall = waFloorA; cwstep(cw);
+        cellwalker cw1 = cw + wstep + 4 + wstep;
+        (cw1+3+wstep).c->wall = waFloorA;
+        (cw1+4+wstep).c->wall = waFloorA;
         }
       }
    
@@ -183,23 +179,13 @@ void patternFiftyAt(cell *c) {
     }  
 
   for(int i=0; i<c->type; i++) {
-    cellwalker cw(c, sw);
-    cwspin(cw, sgn1 * i);
-    cwstep(cw);
-    cwspin(cw, sgn*4);
-    cwstep(cw); 
+    auto cw = cellwalker(c, sw) + (sgn1 * i) + wstep + (sgn * 4) + wstep;
     if(cw.spin < 0 || cw.spin >= 7 || cw.c->type != 7) exit(1);
     encode(cw.c, s, 1+i, cw.spin);
     }
   
   for(int i=0; i<c->type; i++) {
-    cellwalker cw(c, sw);
-    cwspin(cw, sgn1 * i);
-    cwstep(cw);
-    cwspin(cw, 3);
-    cwstep(cw);
-    cwspin(cw, 3);
-    cwstep(cw);
+    auto cw = cellwalker(c, sw) + (sgn1 * i) + wstep + 3 + wstep + 3 + wstep;
     if(cw.spin < 0 || cw.spin >= 7 || cw.c->type != 7) exit(1);
     encode(cw.c, s, 8+i, cw.spin);
     }
@@ -208,28 +194,28 @@ void patternFiftyAt(cell *c) {
     
   for(int i=0; i<c->type; i++) {
     cellwalker cw(c, s.wc2);
-    cwspin(cw, sgn1 * i);
-    cwstep(cw); 
+    cw += (sgn1 * i);
+    cw += wstep;
     if(style == 0) cw.c->wall = waCamelot;
     // cw.c->item = itSilver;
-    cwspin(cw, sgn*4); //6
-    cwstep(cw); if(style == 0) cw.c->wall = waFloorA;
+    cw += (sgn*4); //6
+    cw += wstep; if(style == 0) cw.c->wall = waFloorA;
 
     // cw.c->item = itSilver;
-    cwspin(cw, sgn*4); //7
-    cwstep(cw); if(style == 0) cw.c->wall = waFloorA;
+    cw += (sgn*4); //7
+    cw += wstep; if(style == 0) cw.c->wall = waFloorA;
     // cw.c->item = itSilver;
-    cwspin(cw, 3); //6
-    cwstep(cw); if(style == 0) cw.c->wall = waFloorA;
+    cw += (3); //6
+    cw += wstep; if(style == 0) cw.c->wall = waFloorA;
     // cw.c->item = itSilver;
-    cwspin(cw, 3); //6
-    cwstep(cw); if(style == 0) cw.c->wall = waFloorA;
+    cw += (3); //6
+    cw += wstep; if(style == 0) cw.c->wall = waFloorA;
     // cw.c->item = itSilver;
-    cwspin(cw, sgn*3); //7
-    cwstep(cw); if(style == 0) cw.c->wall = waCamelot;
+    cw += (sgn*3); //7
+    cw += wstep; if(style == 0) cw.c->wall = waCamelot;
     // cw.c->item = itSilver;
-    cwspin(cw, sgn*2); //6
-    cwstep(cw); // cw.c->item = itGold;
+    cw += (sgn*2); //6
+    cw += wstep; // cw.c->item = itGold;
     // setdist(cw.c, 8, NULL);
     state50 s2 = s; s2.polarity1 = !s.polarity1;
     s2.wc2 = (cw.spin + sgn1 * i + sgn + 42) % 7;
@@ -243,26 +229,26 @@ void patternFiftyAt(cell *c) {
   
   for(int i=0; i<c->type; i++) {
     cellwalker cw(c, s.wc2);
-    cwspin(cw, sgn1 * i);
-    cwstep(cw); // cw.c->item = itSilver;
+    cw += (sgn1 * i);
+    cw += wstep; // cw.c->item = itSilver;
 //  cw.c->item = itDiamond;
-    cwspin(cw, 3); // 6
-    cwstep(cw); // cw.c->item = itSilver;
+    cw += (3); // 6
+    cw += wstep; // cw.c->item = itSilver;
 //  cw.c->item = itDiamond;
-    cwspin(cw, sgn*4); // 6
-    cwstep(cw); // cw.c->item = itSilver;
+    cw += (sgn*4); // 6
+    cw += wstep; // cw.c->item = itSilver;
 //  cw.c->item = itDiamond;
-    cwspin(cw, sgn*2); // 6
-    cwstep(cw); // cw.c->item = itSilver;
+    cw += (sgn*2); // 6
+    cw += wstep; // cw.c->item = itSilver;
 //  cw.c->item = itDiamond;
-    cwspin(cw, 3); // 6
-    cwstep(cw); // cw.c->item = itSilver;
+    cw += (3); // 6
+    cw += wstep; // cw.c->item = itSilver;
 //  cw.c->item = itDiamond;
-    cwspin(cw, sgn*3); // 7
-    cwstep(cw); // cw.c->item = itSilver;
+    cw += (sgn*3); // 7
+    cw += wstep; // cw.c->item = itSilver;
 //  cw.c->item = itDiamond;
-    cwspin(cw, sgn*4); // 6
-    cwstep(cw); // cw.c->item = itSilver;
+    cw += (sgn*4); // 6
+    cw += wstep; // cw.c->item = itSilver;
     // setdist(cw.c, 8, NULL);
     state50 s2 = s; 
     s2.polarity2 = !s.polarity2;
@@ -343,28 +329,28 @@ void zebra(cellwalker cwb, int it, int type, string pathcode, int xmods) {
   cwb.c->wall = w;
   for(int i=0; i<6; i+=2) {
     cellwalker cw = cwb;
-    cwspin(cw, i);
+    cw += (i);
     cw.c->heat = 4 + type + 4 * 9;
-    cwstep(cw); cwspin(cw, 3); cw.c->wall = w;
+    cw += wstep; cw += (3); cw.c->wall = w;
     int i0 = i; if(type&2 && i0) i0 = 6-i0; i0 /= 2;
     cw.c->heat = 4 + type + 4 * (3+i0);
-    cwstep(cw); cwspin(cw, 3); cw.c->wall = w;
+    cw += wstep; cw += (3); cw.c->wall = w;
     cw.c->heat = 4 + type + 4 * i0;
-    cwstep(cw); cwspin(cw, 3); cw.c->wall = w;
+    cw += wstep; cw += (3); cw.c->wall = w;
     cw.c->heat = 4 + type + 4 * (6+i0);
-    cwstep(cw); cwspin(cw, -3); 
-    cwstep(cw); cwspin(cw, -3); 
-    cwstep(cw); cwspin(cw, -3); 
-    cwstep(cw); cwspin(cw, -i);
-    cwspin(cw, 0);
+    cw += wstep; cw += (-3); 
+    cw += wstep; cw += (-3); 
+    cw += wstep; cw += (-3); 
+    cw += wstep; cw += (-i);
+    cw += (0);
     setzebra(cw, it-1, type ^ 1, pathcode +'+'+char('A'+i)+char('0'+type), xmods*2); 
     }
 
   for(int i=0; i<6; i+=2) {
     cellwalker cw = cwb;
-    cwspin(cw, (type&2)?-i:i);
-    cwstep(cw); cwspin(cw, 3); 
-    cwstep(cw); cwspin(cw, 5); 
+    cw += ((type&2)?-i:i);
+    cw += wstep; cw += (3); 
+    cw += wstep; cw += (5); 
     if(xmods < 2) {
       if(cw.c->item && cw.c->item != (1+i) && redraw && i==0) {
         qconflict++;
@@ -375,15 +361,15 @@ void zebra(cellwalker cwb, int it, int type, string pathcode, int xmods) {
       // cw.c->item = eItem(1 + i);
       // cw.c->heat = 4 + type + 4 * (i/2);
       }
-    cwstep(cw); cwspin(cw, 1); 
+    cw += wstep; cw += (1); 
     if(type < 2) {
-      // cwspin(cw, i);
-      cwspin(cw, i); 
+      // cw += (i);
+      cw += (i); 
       }
     else {
-      cwspin(cw, -i); 
+      cw += (-i); 
       }
-    // cwspin(cw, ((Q >> (4*type)) & 12));
+    // cw += (((Q >> (4*type)) & 12));
     setzebra(cw, it-1, 2^type, pathcode + '+'+char('a'+i)+char('0'+type), xmods+1);
     }
   }
@@ -395,7 +381,7 @@ void zebraPattern() {
     if((Q & (Q>>1)) & 0x5555) continue;
     qconflict = false;
     cellwalker cw(cwt);
-    cwstep(cw); cwspin(cw, 1);
+    cw += wstep; cw += (1);
     qconflict = 0;
     allconflict = "";
     zebra(cw, 3, 0, "");
@@ -407,7 +393,7 @@ void zebraPattern() {
   Q = 0xFFFB; */
   
   cellwalker cw(cwt);
-  cwstep(cw); cwspin(cw, 1);
+  cw += wstep; cw += (1);
   setzebra(cw, 7, 0, "", -999);
   // cw.c->
   // printf("Conflicts: %d\n", qconflict);
diff --git a/rogueviz.cpp b/rogueviz.cpp
index eeece02d..7f7d378f 100644
--- a/rogueviz.cpp
+++ b/rogueviz.cpp
@@ -537,18 +537,18 @@ namespace sag {
     else {
       cellwalker cw = cwt;
       setsnake(cw, 0);
-      cwstep(cw);
+      cw += wstep;
       setsnake(cw, 1);
       for(int i=2; i<=numsnake; i++) {
         if(i == numsnake && sphere) break;
-        cwstep(cw);
+        cw += wstep;
         snakefirst[i-1] = cw.c->landparam;
         while(cw.c->wparam == INSNAKE) {
           snakelast[i-1] = cw.c->landparam;
-          cwstep(cw); cwspin(cw, 1); cwstep(cw);
+          cw = cw + wstep + 1 + wstep;
           }
         if(i == numsnake) break;
-        setsnake(cw, i); cwspin(cw, 1);
+        setsnake(cw, i); cw += 1;
         }
       }
     int stab = min(numsnake, MAXSNAKETAB);
diff --git a/rug.cpp b/rug.cpp
index 745b0b55..d3343562 100644
--- a/rug.cpp
+++ b/rug.cpp
@@ -602,9 +602,7 @@ void buildRug() {
       rugpoint *w2 = vptr.at(c3);
       
       if(a4) {
-        cellwalker cw(c, j);
-        cwstep(cw); cwspin(cw, -1); cwstep(cw);
-        cell *c4 = cw.c;
+        cell *c4 = (cellwalker(c,j) + wstep - 1 + wstep).c;
         cell *cm = c; comp(cm, c); comp(cm, c2); comp(cm, c3); comp(cm, c4);
         if(cm == c || cm == c4)
           addTriangle(v, w, w2);
diff --git a/shmup.cpp b/shmup.cpp
index dcc0bb80..06c687ba 100644
--- a/shmup.cpp
+++ b/shmup.cpp
@@ -720,7 +720,8 @@ void handleInput(int delta) {
     int dir = multi::whereto[i].d;
     if(dir == MD_UNDECIDED) return NULL;
     if(dir == MD_USE_ORB) return multi::whereto[i].tgt;
-    if(dir >= 0) { cwspin(cwti, dir); cwstep(cwti); }
+    if(dir >= 0) 
+      cwti = cwti + dir + wstep;
     return cwti.c;
     }
   
@@ -1653,11 +1654,9 @@ void movePlayer(monster *m, int delta) {
           }
         visibleFor(300);
         cellwalker push(c2, dirfromto(c2, m->base));
-        cwspin(push, 3 * -subdir); cwstep(push);
+        push = push + 3 * (-subdir) + wstep;
         if(!canPushThumperOn(push.c, c2, m->base) && c2->type == 7) {
-          cwstep(push);
-          cwspin(push, 1 * -subdir);
-          cwstep(push);
+          push = push + wstep - subdir + wstep;
           }
         if(!canPushThumperOn(push.c, c2, m->base)) {
           go = false;
@@ -3457,7 +3456,7 @@ void virtualRebase(cell*& base, transmatrix& at, bool tohex) {
       heptspin hs;
       hs.h = h;
       hs.spin = d;
-      heptspin hs2 = hsstep(hs, 0);
+      heptspin hs2 = hs + wstep;
       transmatrix V2 = spin((nonbitrunc?M_PI:0)-hs2.spin*2*M_PI/S7) * invheptmove[d];
       if(nonbitrunc) V2 = V2 * spin(M_PI);
       double newz = (V2 * at * C0) [2];
diff --git a/yendor.cpp b/yendor.cpp
index ab865b82..0feeec62 100644
--- a/yendor.cpp
+++ b/yendor.cpp
@@ -189,17 +189,17 @@ namespace yendor {
             in_endorian = false;
           nyi.path[i] = lig.c;
           
-          cwstep(lig);
+          lig += wstep;
           if(inmirror(lig)) lig = mirror::reflect(lig);
-          cwspin(lig, 3);
+          lig += 3;
           if(lig.c->type == 7) {
             if(in_endorian && endorian_change && i >= YDIST - 20) {
               // make the last leg a bit more difficult
-              cwspin(lig, hrand(2)*3-1);
+              lig += (hrand(2)*3-1);
               endorian_change = false;
               }
             else
-              cwspin(lig, hrand(2));
+              lig += hrand(2);
             }
           }
         nyi.path[YDIST-1] = lig.c;