From 453c06f9f93e0a1c8b275d83f9416caafff7c6b7 Mon Sep 17 00:00:00 2001
From: Zeno Rogue <zeno@attnam.com>
Date: Sun, 19 Aug 2018 15:52:39 +0200
Subject: [PATCH] functions with rotation parameters in S84-degree system have
 been removed or replaced in radian versions

---
 floorshapes.cpp           |  12 ++--
 geometry.cpp              |  22 +------
 geometry2.cpp             |  10 +--
 graph.cpp                 | 128 ++++++++++++++++++--------------------
 hyper.h                   |   8 +--
 netgen.cpp                |  12 ++--
 orbs.cpp                  |   2 +-
 pattern2.cpp              |  16 ++---
 polygons.cpp              |   2 +
 rogueviz-banachtarski.cpp |   4 +-
 10 files changed, 95 insertions(+), 121 deletions(-)

diff --git a/floorshapes.cpp b/floorshapes.cpp
index 9fea4d0e..598d7d13 100644
--- a/floorshapes.cpp
+++ b/floorshapes.cpp
@@ -35,10 +35,6 @@ escher_floorshape shStarFloor(1,2),
   shRedRockFloor[3] = {{55, 56}, {55, 56}, {55, 56}}, // 1 - .1 * i   
   shDragonFloor(181, 182, 2, 183); /* dragon */
 
-hyperpoint adist(ld a, ld x) {
-  return spin(a) * xpush(x) * C0;
-  }
-
 typedef pair<transmatrix, array<transmatrix, MAX_EDGE>> matrixitem;
 
 struct mesher {
@@ -59,10 +55,10 @@ mesher msh(eGeometry g, int sym, ld main, ld v0, ld v1, ld bspi, ld scale) {
   hyperpoint bnlfar = xpush(v0) * spin(M_PI) * rspintox(rot) * rspintox(rot) * rspintox(rot) * xpush(hdist0(rot)) * C0;
   hyperpoint bnrfar = xpush(v0) * spin(M_PI) * spintox(rot) * spintox(rot) * spintox(rot) * xpush(hdist0(rot)) * C0;
 
-  m.lcorner = adist (bspi-M_PI/sym, main);
-  m.rcorner = adist (bspi+M_PI/sym, main);
-  m.mfar[0] = adist (bspi, v0);
-  m.mfar[1] = adist (bspi, v1);
+  m.lcorner = xspinpush0 (bspi-M_PI/sym, main);
+  m.rcorner = xspinpush0 (bspi+M_PI/sym, main);
+  m.mfar[0] = xspinpush0 (bspi, v0);
+  m.mfar[1] = xspinpush0 (bspi, v1);
   m.vfar[0] = spin(bspi) * bnlfar;
   m.vfar[2] = spin(bspi) * bnrfar;
   m.vfar[1] = spin(-2*M_PI/sym) * m.vfar[2];
diff --git a/geometry.cpp b/geometry.cpp
index 9a2f492f..a4865375 100644
--- a/geometry.cpp
+++ b/geometry.cpp
@@ -25,15 +25,8 @@ hyperpoint Crad[MAX_S84];
 transmatrix heptmove[MAX_EDGE], hexmove[MAX_EDGE];
 transmatrix invheptmove[MAX_EDGE], invhexmove[MAX_EDGE];
 
-transmatrix spinmatrix[MAX_S84];
-
 ld hexshift;
 
-const transmatrix& getspinmatrix(int id) {
-  id = (id + MODFIXER) % S84;
-  return spinmatrix[id];
-  }
-
 // the results are:
 // hexf = 0.378077 hcrossf = 0.620672 tessf = 1.090550
 // hexhexdist = 0.566256
@@ -167,8 +160,6 @@ void precalc() {
   printf("S7=%d S6=%d hexf = " LDF" hcross = " LDF" tessf = " LDF" hexshift = " LDF " hexhex = " LDF " hexv = " LDF "\n", S7, S6, hexf, hcrossf, tessf, hexshift, 
     hexhexdist, hexvdist);  
   
-  for(int i=0; i<S84; i++) spinmatrix[i] = spin(i * M_PI / S42);
-
   base_distlimit = ginf[geometry].distlimit[nonbitrunc];
   
   gp::compute_geometry();  
@@ -176,18 +167,11 @@ void precalc() {
   if(syntetic) synt::prepare();
   }
 
-transmatrix ddi(ld dir, ld dist) {
+transmatrix xspinpush(ld dir, ld dist) {
   if(euclid)
-    return eupush(cos(M_PI*dir/S42) * dist, -sin(M_PI*dir/S42) * dist);
+    return eupush(cos(dir) * dist, -sin(dir) * dist);
   else
-    return spin(M_PI*dir/S42) * xpush(dist) * spin(-M_PI*dir/S42);
-  }
-
-hyperpoint ddi0(ld dir, ld dist) {
-  if(euclid)
-    return hpxy(cos(M_PI*dir/S42) * dist, -sin(M_PI*dir/S42) * dist);
-  else
-    return xspinpush0(M_PI*dir/S42, dist);
+    return spin(dir) * xpush(dist) * spin(-dir);
   }
 
 namespace geom3 {
diff --git a/geometry2.cpp b/geometry2.cpp
index 6a7df083..984762a7 100644
--- a/geometry2.cpp
+++ b/geometry2.cpp
@@ -350,7 +350,7 @@ double cellgfxdist(cell *c, int i) {
 transmatrix cellrelmatrix(cell *c, int i) {
   if(gp::on) return calc_relative_matrix(c->move(i), c, i);
   double d = cellgfxdist(c, i);
-  return ddspin(c, i) * xpush(d) * iddspin(c->move(i), c->c.spin(i), euclid ? 0 : S42);
+  return ddspin(c, i) * xpush(d) * iddspin(c->move(i), c->c.spin(i), euclid ? 0 : M_PI);
   }
 
 double randd() { return (rand() + .5) / (RAND_MAX + 1.); }
@@ -395,13 +395,13 @@ hyperpoint get_corner_position(cell *c, int cid, ld cf) {
     return spin(-t.first) * xpush(t.second * 3 / cf) * C0;
     }
   if(nonbitrunc) {
-    return ddspin(c,cid,S6) * xpush0(hcrossf * 3 / cf);
+    return ddspin(c,cid,M_PI/S7) * xpush0(hcrossf * 3 / cf);
     }
   if(!nonbitrunc) {
     if(!ishept(c))
-      return ddspin(c,cid,S7) * xpush0(hexvdist * 3 / cf);
+      return ddspin(c,cid,M_PI/S6) * xpush0(hexvdist * 3 / cf);
     else
-      return ddspin(c,cid,S6) * xpush0(rhexf * 3 / cf);
+      return ddspin(c,cid,M_PI/S7) * xpush0(rhexf * 3 / cf);
     }
   return C0;
   }
@@ -517,7 +517,7 @@ hyperpoint farcorner(cell *c, int i, int which) {
 hyperpoint get_warp_corner(cell *c, int cid) {
   if(gp::on) return gp::get_corner_position(c, cid, 2);
   if(irr::on) return midcorner(c, cid, .5);
-  return ddspin(c,cid,S6) * xpush0(tessf/2);
+  return ddspin(c,cid,M_PI/S7) * xpush0(tessf/2);
   }
   
   }
diff --git a/graph.cpp b/graph.cpp
index ad4dfe24..22f7ff61 100644
--- a/graph.cpp
+++ b/graph.cpp
@@ -140,7 +140,7 @@ void drawShield(const transmatrix& V, eItem it) {
   double d = it == itOrbShield ? hexf : hexf - .1;
   int mt = sphere ? 7 : 5;
   for(ld a=0; a<=S84*mt+1e-6; a+=pow(.5, vid.linequality))
-    curvepoint(V*ddi0(a, d + sin(ds + M_PI*2*a/4/mt)*.1));
+    curvepoint(V*xspinpush0(a * M_PI/S42, d + sin(ds + M_PI*2*a/4/mt)*.1));
   queuecurve(darkena(col, 0, 0xFF), 0x8080808, PPR_LINE);
 #endif
   }
@@ -151,7 +151,7 @@ void drawSpeed(const transmatrix& V) {
   int col = darkena(iinf[itOrbSpeed].color, 0, 0xFF);
   for(int b=0; b<S84; b+=S14) {
     PRING(a)
-      curvepoint(V*ddi0(ds+b+a, hexf*a/S84));
+      curvepoint(V*xspinpush0((ds+b+a) * M_PI/S42, hexf*a/S84));
     queuecurve(col, 0x8080808, PPR_LINE);
     }
 #endif
@@ -176,7 +176,7 @@ void drawSafety(const transmatrix& V, int ct) {
   ld ds = ticks / 50.;
   int col = darkena(iinf[itOrbSafety].color, 0, 0xFF);
   for(int a=0; a<ct; a++)
-    queueline(V*ddi0(ds+a*S84/ct, 2*hexf), V*ddi0(ds+(a+(ct-1)/2)*S84/ct, 2*hexf), col, vid.linequality);
+    queueline(V*xspinpush0((ds+a*S84/ct) * M_PI/S42, 2*hexf), V*xspinpush0((ds+(a+(ct-1)/2)*S84/ct) * M_PI / S42, 2*hexf), col, vid.linequality);
 #endif
   }
 
@@ -187,7 +187,7 @@ void drawFlash(const transmatrix& V) {
   col &= ~1;
   for(int u=0; u<5; u++) {
     ld rad = hexf * (2.5 + .5 * sin(ds+u*.3));
-    PRING(a) curvepoint(V*ddi0(a, rad));
+    PRING(a) curvepoint(V*xspinpush0(a * M_PI / S42, rad));
     queuecurve(col, 0x8080808, PPR_LINE);
     }
 #endif
@@ -205,20 +205,20 @@ void drawLove(const transmatrix& V, int hdir) {
       if(z <= 10) d += (10-z) * (10-z) * (10-z) / 3000.;
 
       ld rad = hexf * (2.5 + .5 * sin(ds+u*.3)) * d;
-      curvepoint(V*ddi0(S42+hdir+a-1, rad));
+      curvepoint(V*xspinpush0((S42+hdir+a-1) * M_PI/S42, rad));
       }
     queuecurve(col, 0x8080808, PPR_LINE);
     }
 #endif
   }
 
-void drawWinter(const transmatrix& V, int hdir) {
+void drawWinter(const transmatrix& V, ld hdir) {
 #if CAP_QUEUE
   float ds = ticks / 300.;
   int col = darkena(iinf[itOrbWinter].color, 0, 0xFF);
   for(int u=0; u<20; u++) {
-    ld rad = 6 * sin(ds+u * 2 * M_PI / 20);
-    queueline(V*ddi0(S42+hdir+rad, hexf*.5), V*ddi0(S42+hdir+rad, hexf*3), col, 2 + vid.linequality);
+    ld rad = sin(ds+u * 2 * M_PI / 20) * M_PI / S7;
+    queueline(V*xspinpush0(M_PI+hdir+rad, hexf*.5), V*xspinpush0(M_PI+hdir+rad, hexf*3), col, 2 + vid.linequality);
     }
 #endif
   }
@@ -228,35 +228,34 @@ void drawLightning(const transmatrix& V) {
   int col = darkena(iinf[itOrbLightning].color, 0, 0xFF);
   for(int u=0; u<20; u++) {
     ld leng = 0.5 / (0.1 + (rand() % 100) / 100.0);
-    ld rad = rand() % S84;
-    queueline(V*ddi0(rad, hexf*0.3), V*ddi0(rad, hexf*leng), col, 2 + vid.linequality);
+    ld rad = rand() % 1000;
+    queueline(V*xspinpush0(rad, hexf*0.3), V*xspinpush0(rad, hexf*leng), col, 2 + vid.linequality);
     }
 #endif
   }
 
-int displaydir(cell *c, int d) {
+ld displayspin(cell *c, int d) {
   if(syntetic) {
     auto& t1 = synt::get_triangle(c->master, d);
-    auto p = spin(-t1.first + M_PI / c->type) * xpush(t1.second) * C0;
-    return -int(atan2(p[1], p[0]) * S84 / 2 / M_PI + .5);
+    return t1.first + M_PI / c->type;
     }
   else if(irr::on) {
     auto id = irr::cellindex[c];
     auto& vs = irr::cells[id];
     if(d < 0 || d >= c->type) return 0;
     auto& p = vs.jpoints[vs.neid[d]];
-    return -int(atan2(p[1], p[0]) * S84 / 2 / M_PI + .5);
+    return -atan2(p[1], p[0]);
     }
   else if(binarytiling) {
     if(d == NODIR) return 0;
     if(d == c->type-1) d++;
     int dirs[8] = {0, 11, 21, 31, 42, 53, 63, 73};
-    return -21-dirs[d];
+    return (-21-dirs[d]) * 42 / M_PI;
     }
   else if(masterless)
-    return - d * S84 / c->type;
+    return - d * 2 * M_PI / c->type;
   else
-    return S42 - d * S84 / c->type;
+    return M_PI - d * 2 * M_PI / c->type;
   }
 
 double hexshiftat(cell *c) {
@@ -267,18 +266,12 @@ double hexshiftat(cell *c) {
   return 0;
   }
 
-transmatrix ddspin(cell *c, int d, int bonus) {
-  int hdir = displaydir(c, d) + bonus;
-  double ha = hexshiftat(c);
-  if(ha) return spin(-ha) * getspinmatrix(hdir);
-  return getspinmatrix(hdir);
+transmatrix ddspin(cell *c, int d, ld bonus) {
+  return spin(displayspin(c, d) + bonus - hexshiftat(c));
   }
 
-transmatrix iddspin(cell *c, int d, int bonus) {
-  int hdir = displaydir(c, d) + bonus;
-  double ha = hexshiftat(c);
-  if(ha) return spin(ha) * getspinmatrix(-hdir);
-  return getspinmatrix(-hdir);
+transmatrix iddspin(cell *c, int d, ld bonus) {
+  return spin(hexshiftat(c) - displayspin(c, d) + bonus);
   }
 
 void drawPlayerEffects(const transmatrix& V, cell *c, bool onplayer) {
@@ -307,7 +300,7 @@ void drawPlayerEffects(const transmatrix& V, cell *c, bool onplayer) {
       int& ang = angle[multi::cpid];
       ang %= S42;
       
-      transmatrix Vnow = gmatrix[c] * rgpushxto0(inverse(gmatrix[c]) * tC0(V)) * (irr::on ? ddspin(c,0,S42) : spin(-hexshiftat(c)));
+      transmatrix Vnow = gmatrix[c] * rgpushxto0(inverse(gmatrix[c]) * tC0(V)) * (irr::on ? ddspin(c,0,M_PI) : spin(-hexshiftat(c)));
       
 #if CAP_QUEUE
       if(!masterless) for(int a=0; a<S42; a++) {
@@ -317,7 +310,7 @@ void drawPlayerEffects(const transmatrix& V, cell *c, bool onplayer) {
         if((a+S21)%S42 == ang && items[itOrbSword2]) continue;
         bool longer = sword::pos(cwt.at, a-1) != sword::pos(cwt.at, a+1);
         int col = darkena(0xC0C0C0, 0, 0xFF);
-        queueline(Vnow*ddi0(dda, nonbitrunc ? 0.6 * gp::scale : longer ? 0.36 : 0.4), Vnow*ddi0(dda, nonbitrunc ? 0.7 * gp::scale : longer ? 0.44 : 0.42), col, 1);
+        queueline(Vnow*xspinpush0(dda * M_PI / S42, nonbitrunc ? 0.6 * gp::scale : longer ? 0.36 : 0.4), Vnow*xspinpush0(dda * M_PI/S42, nonbitrunc ? 0.7 * gp::scale : longer ? 0.44 : 0.42), col, 1);
         }
 #endif
 
@@ -349,7 +342,7 @@ void drawPlayerEffects(const transmatrix& V, cell *c, bool onplayer) {
       ld rad = hexf * u / 250;
       int col = darkena(iinf[itOrbSafety].color, 0, 0xFF);
       PRING(a)
-        curvepoint(V*ddi0(a, rad));
+        curvepoint(V*xspinpush0(a * M_PI / S42, rad));
       queuecurve(col, 0, PPR_LINE);
       }
     }
@@ -1762,9 +1755,9 @@ double chainAngle(cell *c, transmatrix& V, cell *c2, double dft, const transmatr
   }
 
 // equivalent to V = V * spin(-chainAngle(c,V,c2,dft));
-bool chainAnimation(cell *c, transmatrix& V, cell *c2, int i, int b, const transmatrix &Vwhere, ld& length) {
+bool chainAnimation(cell *c, transmatrix& V, cell *c2, int i, ld bonus, const transmatrix &Vwhere, ld& length) {
   if(!gmatrix0.count(c2)) {
-    V = V * ddspin(c,i,b);
+    V = V * ddspin(c,i,bonus);
     length = cellgfxdist(c,i);
     return false;
     }
@@ -1935,10 +1928,10 @@ bool drawMonster(const transmatrix& Vparam, int ct, cell *c, int col) {
         }
         
       else {
-        int hdir = displaydir(c, c->mondir);
+        int hdir = displayspin(c, c->mondir);
         int col = darkena(0x606020, 0, 0xFF);
         for(int u=-1; u<=1; u++)
-          queueline(Vparam*ddi0(hdir+S21, u*crossf/5), Vparam*ddi(hdir, crossf)*ddi0(hdir+S21, u*crossf/5), col, 2 + vid.linequality);
+          queueline(Vparam*xspinpush0(hdir+M_PI/2, u*crossf/5), Vparam*xspinpush(hdir, crossf)*xspinpush0(hdir+M_PI/2, u*crossf/5), col, 2 + vid.linequality);
         }
       }
 
@@ -1984,7 +1977,7 @@ bool drawMonster(const transmatrix& Vparam, int ct, cell *c, int col) {
             Vb = Vb * pispin;
             }
           else {
-            Vb = Vb0 * ddspin(c, nd, S42);
+            Vb = Vb0 * ddspin(c, nd, M_PI);
             }
           transmatrix Vbb = mmscale(Vb, geom3::ABODY);
           queuepoly(Vbb, shDragonTail, darkena(col, c->hitpoints?0:1, 0xFF));
@@ -1995,16 +1988,16 @@ bool drawMonster(const transmatrix& Vparam, int ct, cell *c, int col) {
             ld length;
             chainAnimation(c, Vb, c2, nd, 0, Vparam, length);
             Vb = Vb * pispin;
-            double ang = chainAngle(c, Vb, c->move(c->mondir), (displaydir(c, c->mondir) - displaydir(c, nd)) * M_PI / S42, Vparam);
+            double ang = chainAngle(c, Vb, c->move(c->mondir), displayspin(c, c->mondir) - displayspin(c, nd), Vparam);
             ang /= 2;
             Vb = Vb * spin(M_PI-ang);
             }
           else {
-            int hdir0 = displaydir(c, nd) + S42;
-            int hdir1 = displaydir(c, c->mondir);
-            while(hdir1 > hdir0 + S42) hdir1 -= S84;
-            while(hdir1 < hdir0 - S42) hdir1 += S84;
-            Vb = Vb0 * spin((hdir0 + hdir1)/2 * M_PI / S42 + M_PI);
+            ld hdir0 = displayspin(c, nd) + M_PI;
+            ld hdir1 = displayspin(c, c->mondir);
+            while(hdir1 > hdir0 + M_PI) hdir1 -= 2*M_PI;
+            while(hdir1 < hdir0 - M_PI) hdir1 += 2*M_PI;
+            Vb = Vb0 * spin((hdir0 + hdir1)/2 + M_PI);
             }
           transmatrix Vbb = mmscale(Vb, geom3::ABODY);
           if(part == 'l' || part == '2') {
@@ -2030,7 +2023,7 @@ bool drawMonster(const transmatrix& Vparam, int ct, cell *c, int col) {
             Vb = Vb * pispin;
             }
           else {
-            Vb = Vb0 * ddspin(c, nd, S42);
+            Vb = Vb0 * ddspin(c, nd, M_PI);
             }
           transmatrix Vbb = mmscale(Vb, geom3::ABODY) * pispin;
           hpcshape& sh = hexsnake ? shWormTail : shSmallWormTail;
@@ -2119,7 +2112,7 @@ bool drawMonster(const transmatrix& Vparam, int ct, cell *c, int col) {
       Vb = Vb * T * rspintox(tC0(inverse(T))) * xpush(tentacle_length);
       }
     else {
-      Vb = Vb * ddspin(c, c->mondir, S42);
+      Vb = Vb * ddspin(c, c->mondir, M_PI);
       Vb = Vb * xpush(tentacle_length - cellgfxdist(c, c->mondir));
       }
       
@@ -2134,7 +2127,7 @@ bool drawMonster(const transmatrix& Vparam, int ct, cell *c, int col) {
   else if(isFriendly(c) || isBug(c) || (c->monst && conformal::on) || c->monst == moKrakenH || (isBull(c->monst) && c->mondir != NODIR) || c->monst == moButterfly || isMagneticPole(c->monst) ||
     isSwitch(c->monst) || c->monst == moPair || (c->monst && (quotient || torus || dont_face_pc))) {
     if(c->monst == moKrakenH) Vs = Vb, nospins = nospinb;
-    if(!nospins) Vs = Vs * ddspin(c, c->mondir, S42);
+    if(!nospins) Vs = Vs * ddspin(c, c->mondir, M_PI);
     if(c->monst == moPair) Vs = Vs * xpush(-.12);
     if(isFriendly(c)) drawPlayerEffects(Vs, c, false);
     return drawMonsterTypeDH(m, c, Vs, col, darkhistory, footphase);
@@ -2396,14 +2389,14 @@ int countMinesAround(cell *c) {
 
 transmatrix applyPatterndir(cell *c, const patterns::patterninfo& si) {
   if(gp::on || irr::on || binarytiling) return Id;
-  transmatrix V = ddspin(c, si.dir, S42);  
+  transmatrix V = ddspin(c, si.dir, M_PI);
   if(si.reflect) return V * Mirror;
-  if(syntetic) return V * iddspin(c, 0, S42);
+  if(syntetic) return V * iddspin(c, 0, M_PI);
   return V;
   }
 
 transmatrix applyDowndir(cell *c, cellfunction *cf) {
-  return ddspin(c, patterns::downdir(c, cf), S42);
+  return ddspin(c, patterns::downdir(c, cf), M_PI);
   }
 
 void set_towerfloor(cell *c, cellfunction *cf = coastvalEdge) {
@@ -3399,7 +3392,7 @@ void draw_wall(cell *c, const transmatrix& V, int wcol, int& zcol, int ct6, int
     int hdir = 0;
     for(int i=0; i<c->type; i++) if(c->move(i)->wall == waClosedGate)
       hdir = i;
-    transmatrix V2 = mscale(V, wmspatial?geom3::WALL:1) * ddspin(c, hdir, S42);
+    transmatrix V2 = mscale(V, wmspatial?geom3::WALL:1) * ddspin(c, hdir, M_PI);
     queuepolyat(V2, shPalaceGate, darkena(wcol, 0, 0xFF), wmspatial?PPR_WALL3A:PPR_WALL);
     starcol = 0;
     }
@@ -3522,7 +3515,6 @@ void drawcell(cell *c, transmatrix V, int spinv, bool mirrored) {
       }
     else {
       playerV = V * ddspin(c, cwt.spin);
-      //  playerV = V * spin(displaydir(c, cwt.spin) * M_PI/S42);
       if(cwt.mirrored) playerV = playerV * Mirror;
       if(orig) cwtV = playerV;
       }
@@ -3665,7 +3657,7 @@ void drawcell(cell *c, transmatrix V, int spinv, bool mirrored) {
         ld rad = hexf * (.3 * u + (ds%1000) * .0003);
         int tcol = darkena(gradient(forecolor, backcolor, 0, rad, 1.5 * hexf), 0, 0xFF);
         PRING(a)
-          curvepoint(V*ddi0(a, rad));
+          curvepoint(V*xspinpush0(a * M_PI / S42, rad));
         queuecurve(tcol, 0, PPR_LINE);
         }
       }
@@ -3732,9 +3724,9 @@ void drawcell(cell *c, transmatrix V, int spinv, bool mirrored) {
       if(tim > 1000) tim = 800;
       if(elec::havecharge && tim > 400) tim = 400;
       for(int t=0; t<c->type; t++) if(c->move(t) && c->move(t)->ligon) {
-        int hdir = displaydir(c, t);
+        ld hdir = displayspin(c, t);
         int lcol = darkena(gradient(iinf[itOrbLightning].color, 0, 0, tim, 1100), 0, 0xFF);
-        queueline(V*ddi0(ticks, hexf/2), V*ddi0(hdir, crossf), lcol, 2 + vid.linequality);
+        queueline(V*xspinpush0(ticks * M_PI / S42, hexf/2), V*xspinpush0(hdir, crossf), lcol, 2 + vid.linequality);
         }
       }
     
@@ -3843,7 +3835,7 @@ void drawcell(cell *c, transmatrix V, int spinv, bool mirrored) {
             queuepolyat(V2, shHalfMirror[2], 0xC0C0C080, PPR_WALL3);
           }
         else {
-          qfi.spin = ddspin(c, d, S42);
+          qfi.spin = ddspin(c, d, M_PI);
           transmatrix V2 = V * qfi.spin;
           if(!wmblack) {
             inmirrorcount++;
@@ -3868,7 +3860,7 @@ void drawcell(cell *c, transmatrix V, int spinv, bool mirrored) {
         for(int t=0;t<6; t++) if(c->move(t) && c->move(t)->wall == c->wall)
           i = t;
 
-        qfi.spin = ddspin(c, i, S14);
+        qfi.spin = ddspin(c, i, M_PI/S3);
         transmatrix V2 = V * qfi.spin;
         
         if(wmspatial && wmescher) {
@@ -4048,8 +4040,8 @@ void drawcell(cell *c, transmatrix V, int spinv, bool mirrored) {
         
         case laSwitch:
           set_floor(shSwitchFloor);
-          if(ctof(c) && !gp::on && !irr::on) for(int i=0; i<c->type; i++)
-            queuepoly(Vf * ddspin(c, i, S6) * xpush(rhexf), shSwitchDisk, darkena(minf[active_switch()].color, fd, 0xFF));
+          if(ctof(c) && !gp::on && !irr::on && !syntetic && !binarytiling) for(int i=0; i<c->type; i++)
+            queuepoly(Vf * ddspin(c, i, M_PI/S7) * xpush(rhexf), shSwitchDisk, darkena(minf[active_switch()].color, fd, 0xFF));
           break;
 
         case laStorms:
@@ -4314,7 +4306,7 @@ void drawcell(cell *c, transmatrix V, int spinv, bool mirrored) {
           Vboat = &(Vboat0 = *Vboat); 
           if(wmspatial && c->wall == waBoat) {
             nospin = c->wall == waBoat && applyAnimation(c, Vboat0, footphase, LAYER_BOAT);
-            if(!nospin) Vboat0 = Vboat0 * ddspin(c, c->mondir, S42);
+            if(!nospin) Vboat0 = Vboat0 * ddspin(c, c->mondir, M_PI);
             queuepolyat(Vboat0, shBoatOuter, outcol, PPR_BOATLEV);
             Vboat = &(Vboat0 = V);
             }
@@ -4322,7 +4314,7 @@ void drawcell(cell *c, transmatrix V, int spinv, bool mirrored) {
             nospin = applyAnimation(c, Vboat0, footphase, LAYER_BOAT);
             }
           if(!nospin) 
-            Vboat0 = Vboat0 * ddspin(c, c->mondir, S42);
+            Vboat0 = Vboat0 * ddspin(c, c->mondir, M_PI);
           else {
             transmatrix Vx;
             if(applyAnimation(c, Vx, footphase, LAYER_SMALL))
@@ -4665,7 +4657,7 @@ void drawcell(cell *c, transmatrix V, int spinv, bool mirrored) {
        cell *c2 = c->move(i); 
        if(airdist(c2) < airdist(c)) {
          calcAirdir(c2); // printf("airdir = %d\n", airdir);
-         transmatrix V0 = ddspin(c, i, S42);
+         transmatrix V0 = ddspin(c, i, M_PI);
          
          double ph = ticks / (nonbitrunc?150:75.0) + airdir * M_PI / (S21+.0);
          
@@ -4696,8 +4688,8 @@ void drawcell(cell *c, transmatrix V, int spinv, bool mirrored) {
       whirlwind::calcdirs(c);
       
       for(int i=0; i<whirlwind::qdirs; i++) {
-        int hdir0 = displaydir(c, whirlwind::dfrom[i]) + S42;
-        int hdir1 = displaydir(c, whirlwind::dto[i]);
+        ld hdir0 = displayspin(c, whirlwind::dfrom[i]) + M_PI;
+        ld hdir1 = displayspin(c, whirlwind::dto[i]);
  
         double ph1 = fanframe;
         
@@ -4705,12 +4697,12 @@ void drawcell(cell *c, transmatrix V, int spinv, bool mirrored) {
         
         ph1 -= floor(ph1);
         
-        if(hdir1 < hdir0-S42) hdir1 += S84;
-        if(hdir1 >= hdir0+S42) hdir1 -= S84;
+        if(hdir1 < hdir0-M_PI) hdir1 += 2 * M_PI;
+        if(hdir1 >= hdir0+M_PI) hdir1 -= 2 * M_PI;
         
         int hdir = (hdir1*ph1+hdir0*(1-ph1));
  
-        transmatrix V0 = spin((hdir) * M_PI / S42);
+        transmatrix V0 = spin(hdir);
         
         double ldist = nonbitrunc ? crossf : c->type == 6 ? .2840 : 0.3399;
  
@@ -5090,7 +5082,7 @@ void drawFlashes() {
         int flashcol = f.color;
         if(u > 500) flashcol = gradient(flashcol, 0, 500, u, 1100);
         flashcol = darkena(flashcol, 0, 0xFF);
-        PRING(a) curvepoint(V*ddi0(a, rad));
+        PRING(a) curvepoint(V*xspinpush0(a * M_PI / S42, rad));
         queuecurve(flashcol, 0x8080808, PPR_LINE);
         }
       }
@@ -5104,7 +5096,7 @@ void drawFlashes() {
         int flashcol = f.color;
         if(u > 1000) flashcol = gradient(flashcol, 0, 1000, u, 2200);
         flashcol = darkena(flashcol, 0, 0xFF);
-        PRING(a) curvepoint(V*ddi0(a, rad));
+        PRING(a) curvepoint(V*xspinpush0(a * M_PI / S42, rad));
         queuecurve(flashcol, 0x8080808, PPR_LINE);
         }
       }
@@ -5338,7 +5330,7 @@ void drawmovestar(double dx, double dy) {
 
 #if CAP_QUEUE
     if(euclid)
-      queueline(tC0(Centered), Centered * ddi0(d * 10.5, 0.5) , col, vid.linequality);
+      queueline(tC0(Centered), Centered * xspinpush0(d * M_PI / 4, 0.5) , col, vid.linequality);
     else
 //    queueline(tC0(Centered), Centered * spin(M_PI*d/4)* xpush(d==0?.7:d==2?.6:.5) * C0, col >> darken);
       queueline(tC0(Centered), Centered * xspinpush0(M_PI*d/4, d==0?.7:d==2?.5:.2), col, 3 + vid.linequality);
@@ -5870,7 +5862,7 @@ void drawBug(const cellwalker& cw, int col) {
 #if CAP_POLY
   initquickqueue();
   transmatrix V = ggmatrix(cw.at);
-  if(cw.spin) V = V * ddspin(cw.at, cw.spin, S42);
+  if(cw.spin) V = V * ddspin(cw.at, cw.spin, M_PI);
   queuepoly(V, shBugBody, col);
   quickqueue();
 #endif
diff --git a/hyper.h b/hyper.h
index 1823fb10..3ccef65a 100644
--- a/hyper.h
+++ b/hyper.h
@@ -852,7 +852,7 @@ bool outofmap(hyperpoint h);
 void applymodel(hyperpoint H, hyperpoint& Hscr);
 void drawCircle(int x, int y, int size, int color);
 void fixcolor(int& col);
-int displaydir(cell *c, int d);
+ld displayspin(cell *c, int d);
 hyperpoint gethyper(ld x, ld y);
 void resetview(); extern heptspin viewctr; extern cellwalker centerover;
 void drawthemap();
@@ -2070,8 +2070,8 @@ namespace linepatterns {
   void switchAlpha(ePattern id, int col);
   };
 
-transmatrix ddspin(cell *c, int d, int bonus = 0);
-transmatrix iddspin(cell *c, int d, int bonus = 0);
+transmatrix ddspin(cell *c, int d, ld bonus = 0);
+transmatrix iddspin(cell *c, int d, ld bonus = 0);
 bool doexiton(int sym, int uni);
 void switchFullscreen();
 string turnstring(int i);
@@ -2994,7 +2994,6 @@ namespace texture {
 void queueline(const hyperpoint& H1, const hyperpoint& H2, int col, int prf = 0, int prio = PPR_LINE);
 void queuelink(const string *link, int prio);
 
-hyperpoint ddi0(ld dir, ld dist);
 extern ld tessf, crossf, hexf, hcrossf, hexhexdist, hexvdist, hepvdist, rhexf;
 unsigned char& part(int& col, int i);
 unsigned char& part(unsigned& col, int i);
@@ -3154,6 +3153,7 @@ extern int lastsize;
 extern int noiseuntil;
 inline hyperpoint xpush0(ld x);
 extern eGeometry targetgeometry;
+transmatrix xspinpush(ld alpha, ld x);
 inline hyperpoint xspinpush0(ld alpha, ld x);
 
 #define DF_INIT              0 // always display these
diff --git a/netgen.cpp b/netgen.cpp
index 7eb2a024..7d6d618f 100644
--- a/netgen.cpp
+++ b/netgen.cpp
@@ -74,24 +74,24 @@ namespace hr { namespace netgen {
     
       hcenter[ii][MAX_EDGE] = V * C0;
 
-      if(c->type == 7) {
+      if(c->type == S7) {
         for(int i=0; i<c->type; i++) {
   
-          int hdir = displaydir(c, i) + 6;
+          int hdir = displayspin(c, i) + M_PI / S7;
         
-          transmatrix V2 = V * spin(hdir * M_PI / 42) * xpush(hexf);
+          transmatrix V2 = V * spin(hdir) * xpush(hexf);
           
           hcenter[ii][i] = V2 * C0;
           }
         }
   
-      if(c->type == 6) {
+      if(c->type == S6) {
         for(int i=0; i<c->type; i++) {
   
-          int hdir = displaydir(c, i);
+          int hdir = displayspin(c, i);
         
           transmatrix V2 = 
-            V * spin(hdir * M_PI / 42) * xpush(crossf) * spin(M_PI*8/7) * xpush(hexf);
+            V * spin(hdir) * xpush(crossf) * spin(M_PI+M_PI/S7) * xpush(hexf);
           
           hcenter[ii][i] = V2 * C0;
           }
diff --git a/orbs.cpp b/orbs.cpp
index ab8469da..e480295e 100644
--- a/orbs.cpp
+++ b/orbs.cpp
@@ -306,7 +306,7 @@ bool reflectingBarrierAt(cell *c) {
 bool reflectingBarrierAt(cellwalker& c, int d) {
   if(d >= 3) return true;
   if(d <= -3) return true;
-  d = c.spin + d + 42;
+  d = c.spin + d + MODFIXER;
   d%=c.at->type;
   if(!c.at->move(d)) return true;
   
diff --git a/pattern2.cpp b/pattern2.cpp
index a6eb593c..389d5bc3 100644
--- a/pattern2.cpp
+++ b/pattern2.cpp
@@ -1941,8 +1941,8 @@ namespace linepatterns {
           
           double x = hexhexdist / 2; // sphere?.3651:euclid?.2611:.2849;
           
-          queuelinef(V * ddspin(c,i,-S14) * xpush0(x), 
-            V * ddspin(c,i,+S14) * xpush0(x), 
+          queuelinef(V * ddspin(c,i,-M_PI/S3) * xpush0(x), 
+            V * ddspin(c,i,M_PI/S3) * xpush0(x), 
             col, 1 + vid.linequality);
           }
         break;
@@ -1993,8 +1993,8 @@ namespace linepatterns {
             cell *c1 = createMov(c, (i+3) % 7);
             cell *c2 = createMov(c, (i+4) % 7);
             if(polarb50(c1) != a && polarb50(c2) != a)
-                queuelinef(V * ddspin(c,i,84*5/14) * xpush0(tessf/2),
-                          V * ddspin(c,i,84*9/14) * xpush0(tessf/2),
+                queuelinef(V * ddspin(c,i,M_PI*5/7) * xpush0(tessf/2),
+                          V * ddspin(c,i,M_PI*9/7) * xpush0(tessf/2),
                                     col, 1 + vid.linequality);
             }
         break;
@@ -2002,8 +2002,8 @@ namespace linepatterns {
       
       case patPalacelike:
         if(pseudohept(c)) for(int i=0; i<7; i++) 
-          queuelinef(V * ddspin(c,i,84*5/14) * xpush0(tessf/2),
-                    V * ddspin(c,i,84*9/14) * xpush0(tessf/2),
+          queuelinef(V * ddspin(c,i,M_PI*5/7) * xpush0(tessf/2),
+                    V * ddspin(c,i,M_PI*9/7) * xpush0(tessf/2),
                               col, 1 + vid.linequality);
         break;
       
@@ -2095,8 +2095,8 @@ namespace linepatterns {
               heptagon *h2 = c->master->modmove(i-1);
               if(!h1 || !h2) continue;
               if(emeraldval(h1->c7)/4 == 8 && emeraldval(h2->c7)/4 == 8)
-                  queuelinef(V * ddspin(c,i,84*5/14) * xpush0(tessf/2),
-                            V * ddspin(c,i,84*9/14) * xpush0(tessf/2),
+                  queuelinef(V * ddspin(c,i,M_PI*5/7) * xpush0(tessf/2),
+                            V * ddspin(c,i,M_PI*9/7) * xpush0(tessf/2),
                                       col, 1 + vid.linequality);
               }
           }
diff --git a/polygons.cpp b/polygons.cpp
index feedd6ae..b46dc1df 100644
--- a/polygons.cpp
+++ b/polygons.cpp
@@ -1324,6 +1324,8 @@ struct usershape {
 
 usershape *usershapes[USERSHAPEGROUPS][USERSHAPEIDS];
 
+transmatrix ddi(int a, ld x) { return xspinpush(a * M_PI / S42, x); }
+
 void drawTentacle(hpcshape &h, ld rad, ld var, ld divby) {
   double tlength = max(crossf, hexhexdist * gp::scale * irr::scale);
   if(syntetic) tlength = synt::edgelength;
diff --git a/rogueviz-banachtarski.cpp b/rogueviz-banachtarski.cpp
index d57c24d1..0a827edd 100644
--- a/rogueviz-banachtarski.cpp
+++ b/rogueviz-banachtarski.cpp
@@ -457,8 +457,8 @@ bool bantar_stats() {
     for(auto gm: gmatrix) for(cell *c: {gm.first})
     if(euclid || !pseudohept(c)) for(int t=0; t<c->type; t++) if(infos.count(c) && infos.count(c->move(t)) && c->move(t) && infos[c].gid != infos[c->move(t)].gid)
       if(euclid ? c->move(t)<c : (((t^1)&1) || c->move(t) < c))
-        queueline(gm.second * ddspin(c,t,-S7) * xpush(x) * C0, 
-          gm.second * ddspin(c,t,+S7) * xpush(x) * C0, 
+        queueline(gm.second * ddspin(c,t,-M_PI/S6) * xpush(x) * C0, 
+          gm.second * ddspin(c,t,+M_PI/S6) * xpush(x) * C0, 
           0xFF0000FF, 1);
     vid.linewidth /= (inHighQual ? 10 : 2);
     drawqueue();