From 4d31e5a544e545b7872e64292d4cf3f2fc53380a Mon Sep 17 00:00:00 2001
From: Zeno Rogue <zeno@attnam.com>
Date: Sun, 19 Aug 2018 23:06:32 +0200
Subject: [PATCH] renamed 'syntetic' to 'archimedean'
 (enums/files/marcos/namespaces)

---
 syntetic.cpp => archimedean.cpp | 65 +++++++++++++++++----------------
 bigstuff.cpp                    |  2 +-
 cell.cpp                        | 16 ++++----
 classes.h                       |  2 +-
 compileunits.h                  |  2 +-
 debug.cpp                       |  4 +-
 floorshapes.cpp                 | 20 +++++-----
 geom-exp.cpp                    | 14 +++----
 geometry.cpp                    |  6 +--
 geometry2.cpp                   | 34 ++++++++---------
 graph.cpp                       | 14 +++----
 heptagon.cpp                    |  6 +--
 hyper.h                         | 12 +++---
 hypgraph.cpp                    | 10 ++---
 landgen.cpp                     | 20 +++++-----
 monstergen.cpp                  |  4 +-
 pattern2.cpp                    | 46 +++++++++++------------
 polygons.cpp                    | 16 ++++----
 18 files changed, 147 insertions(+), 146 deletions(-)
 rename syntetic.cpp => archimedean.cpp (90%)

diff --git a/syntetic.cpp b/archimedean.cpp
similarity index 90%
rename from syntetic.cpp
rename to archimedean.cpp
index 02c8d152..ed0aacd1 100644
--- a/syntetic.cpp
+++ b/archimedean.cpp
@@ -1,6 +1,6 @@
 namespace hr {
 
-namespace synt {
+namespace arcm {
 
 #define SDEBUG(x) if(debug_geometry) { doindent(); x; fflush(stdout); }
 
@@ -28,7 +28,7 @@ vector<vector<pair<int, int>>> adjacent;
 
 vector<vector<pair<ld, ld>>> triangles;
 
-// id of vertex in the syntetic tiling
+// id of vertex in the archimedean tiling
 // odd numbers = reflected tiles
 // 0, 2, ..., 2(N-1) = as in the symbol
 // 2N = bitruncated tile
@@ -244,13 +244,13 @@ void prepare() {
 
   euclidean_angle_sum = 0;
   for(int f: faces) euclidean_angle_sum += (f-2.) / f;
-  if(euclidean_angle_sum < 1.999999) ginf[gSyntetic].cclass = gcSphere;
-  else if(euclidean_angle_sum > 2.000001) ginf[gSyntetic].cclass = gcHyperbolic;
-  else ginf[gSyntetic].cclass = gcEuclid;
+  if(euclidean_angle_sum < 1.999999) ginf[gArchimedean].cclass = gcSphere;
+  else if(euclidean_angle_sum > 2.000001) ginf[gArchimedean].cclass = gcHyperbolic;
+  else ginf[gArchimedean].cclass = gcEuclid;
   
   SDEBUG( printf("euclidean_angle_sum = %lf\n", double(euclidean_angle_sum)); )
   
-  dynamicval<eGeometry> dv(geometry, gSyntetic);
+  dynamicval<eGeometry> dv(geometry, gArchimedean);
   
   /* compute the geometry */
   inradius.resize(N);
@@ -315,15 +315,15 @@ void prepare() {
 
 map<heptagon*, vector<pair<heptagon*, transmatrix> > > altmap;
 
-map<heptagon*, pair<heptagon*, transmatrix>> syntetic_gmatrix;
+map<heptagon*, pair<heptagon*, transmatrix>> archimedean_gmatrix;
 
 hrmap *current_altmap;
 
-struct hrmap_syntetic : hrmap {
+struct hrmap_archimedean : hrmap {
   heptagon *origin;
   heptagon *getOrigin() { return origin; }
 
-  hrmap_syntetic() {
+  hrmap_archimedean() {
     origin = new heptagon;
     origin->s = hsOrigin;
     origin->emeraldval = 0;
@@ -357,7 +357,7 @@ struct hrmap_syntetic : hrmap {
       }
   
     transmatrix T = xpush(.01241) * spin(1.4117) * xpush(0.1241) * Id;
-    syntetic_gmatrix[origin] = make_pair(alt, T);
+    archimedean_gmatrix[origin] = make_pair(alt, T);
     altmap[alt].emplace_back(origin, T);
     
     base_distlimit = 0;
@@ -366,10 +366,10 @@ struct hrmap_syntetic : hrmap {
     if(sphere) base_distlimit = 15;
     }
 
-  ~hrmap_syntetic() {
+  ~hrmap_archimedean() {
     clearfrom(origin);
     altmap.clear();
-    syntetic_gmatrix.clear();
+    archimedean_gmatrix.clear();
     if(current_altmap) {
       dynamicval<eGeometry> g(geometry, gNormal);       
       delete current_altmap;
@@ -379,7 +379,7 @@ struct hrmap_syntetic : hrmap {
   void verify() { }
   };
 
-hrmap *new_map() { return new hrmap_syntetic; }
+hrmap *new_map() { return new hrmap_archimedean; }
 
 transmatrix adjcell_matrix(heptagon *h, int d);
 
@@ -425,7 +425,7 @@ void create_adjacent(heptagon *h, int d) {
 
   // * spin(-tri[id][pi+i].first) * xpush(t.second) * pispin * spin(tri[id'][p'+d'].first)
   
-  auto& p = syntetic_gmatrix[h];
+  auto& p = archimedean_gmatrix[h];
   
   heptagon *alt = p.first;
 
@@ -462,7 +462,7 @@ void create_adjacent(heptagon *h, int d) {
 
   heptagon *hnew = build_child(h, d, get_adj(h, d).first, get_adj(h, d).second);
   altmap[alt].emplace_back(hnew, T1);
-  syntetic_gmatrix[hnew] = make_pair(alt, T1);
+  archimedean_gmatrix[hnew] = make_pair(alt, T1);
   }
 
 set<heptagon*> visited;
@@ -601,7 +601,7 @@ int readArgs() {
            
   if(0) ;
   else if(argis("-symbol")) {
-    targetgeometry = gSyntetic;
+    targetgeometry = gArchimedean;
     if(targetgeometry != geometry)
       stop_game_and_switch_mode(rg::geometry);
     showstartmenu = false;
@@ -631,8 +631,8 @@ int support_threecolor() {
 int support_graveyard() {
   if(!nonbitrunc) return 2;
   return 
-    isize(synt::faces) == 3 && synt::faces[0] % 2 == 0 ? 2 :
-    synt::have_ph ? 1 :
+    isize(arcm::faces) == 3 && arcm::faces[0] % 2 == 0 ? 2 :
+    arcm::have_ph ? 1 :
     0;
   }
 
@@ -641,15 +641,15 @@ bool support_chessboard() {
   }
 
 bool pseudohept(int id) {
-  return flags[id] & synt::sfPH;
+  return flags[id] & arcm::sfPH;
   }
 
 bool chessvalue(cell *c) {
-  return flags[id_of(c->master)] & synt::sfCHESS;
+  return flags[id_of(c->master)] & arcm::sfCHESS;
   }
 
 bool linespattern(cell *c) {
-  return flags[id_of(c->master)] & synt::sfLINE;
+  return flags[id_of(c->master)] & arcm::sfLINE;
   }
 
 int threecolor(int id) {
@@ -745,8 +745,16 @@ string active_symbol;
 
 bool manual_edit;
 
+void enable() {
+  stop_game();
+  if(geometry != gArchimedean) targetgeometry = gArchimedean, stop_game_and_switch_mode(rg::geometry);
+  nonbitrunc = true; need_reset_geometry = true;
+  parse_symbol(current_symbol);
+  start_game();
+  }
+
 void show() {
-  if(lastsample < isize(samples) && geometry != gSyntetic) {
+  if(lastsample < isize(samples) && geometry != gArchimedean) {
     string s = samples[lastsample++];
     parse_symbol(s);
     if(errors) {
@@ -782,11 +790,8 @@ void show() {
       parse_symbol(current_symbol);
       if(errors) parse_symbol(current_symbol = active_symbol);
       else {
-        stop_game();
-        need_reset_geometry = true;
-        if(geometry != gSyntetic) targetgeometry = gSyntetic, stop_game_and_switch_mode(rg::geometry);
-        nonbitrunc = true; need_reset_geometry = true;
-        start_game();
+        parse_symbol(active_symbol);
+        enable();
         }
       }
     });
@@ -798,12 +803,8 @@ void show() {
       auto &ps = prepsamples[j];
       dialog::addSelItem(ps.s, fts(ps.angle_sum) + "°", 'a' + i);
       dialog::add_action([&] () {
-        stop_game();
         current_symbol = ps.s;
-        if(geometry != gSyntetic) targetgeometry = gSyntetic, stop_game_and_switch_mode(rg::geometry);
-        nonbitrunc = true; need_reset_geometry = true;
-        parse_symbol(current_symbol);
-        start_game();
+        enable();
         });
       }
     dialog::addItem(XLAT("next page"), '-');
diff --git a/bigstuff.cpp b/bigstuff.cpp
index 7f8552db..1766ee01 100644
--- a/bigstuff.cpp
+++ b/bigstuff.cpp
@@ -976,7 +976,7 @@ int wallchance(cell *c, bool deepOcean) {
 
 bool horo_ok() {
   // do the horocycles work in the current geometry?
-  return hyperbolic && !binarytiling && !syntetic;
+  return hyperbolic && !binarytiling && !archimedean;
   }
 
 bool gp_wall_test() {
diff --git a/cell.cpp b/cell.cpp
index ac1e0179..d2851995 100644
--- a/cell.cpp
+++ b/cell.cpp
@@ -798,14 +798,14 @@ cell *createMov(cell *c, int d) {
       exit(1);
       }
     }
-  else if(nonbitrunc && syntetic) {
-    if(synt::id_of(c->master) <= synt::N * 2) {
+  else if(nonbitrunc && archimedean) {
+    if(arcm::id_of(c->master) <= arcm::N * 2) {
       heptspin hs = heptspin(c->master, d) + wstep + 2 + wstep + 1;
       c->c.connect(d, hs.at->c7, hs.spin, hs.mirrored);
       }
     else c->c.connect(d, c, d, false);
     }
-  else if(nonbitrunc || syntetic) {
+  else if(nonbitrunc || archimedean) {
     heptagon *h2 = createStep(c->master, d);
     c->c.connect(d, h2->c7,c->master->c.spin(d),false);
     }
@@ -874,7 +874,7 @@ cell*& euclideanAtCreate(int vec) {
 void initcells() {
   DEBB(DF_INIT, (debugfile,"initcells\n"));
   
-  if(syntetic) currentmap = synt::new_map();
+  if(archimedean) currentmap = arcm::new_map();
   else if(torus) currentmap = new hrmap_torus;
   else if(euclid) currentmap = new hrmap_euclidean;
   else if(sphere) currentmap = new hrmap_spherical;
@@ -913,7 +913,7 @@ template<class T> void subcell(cell *c, const T& t) {
       subcell(c2, t);
       }
     }
-  else if(!nonbitrunc && !syntetic && !binarytiling)
+  else if(!nonbitrunc && !archimedean && !binarytiling)
     forCellEx(c2, c) t(c2);
   t(c);
   }
@@ -992,7 +992,7 @@ void verifycell(cell *c) {
   }
 
 void verifycells(heptagon *at) {
-  if(gp::on || irr::on || syntetic) return;
+  if(gp::on || irr::on || archimedean) return;
   for(int i=0; i<S7; i++) if(at->move(i) && at->move(i)->move(at->c.spin(i)) && at->move(i)->move(at->c.spin(i)) != at) {
     printf("hexmix error %p [%d s=%d] %p %p\n", at, i, at->c.spin(i), at->move(i), at->move(i)->move(at->c.spin(i)));
     }
@@ -1039,7 +1039,7 @@ int celldist(cell *c) {
     return eudist(decodeId(c->master));
   if(sphere) return celldistance(c, currentmap->gamestart());
   if(irr::on) return irr::celldist(c, false);
-  if(binarytiling || syntetic || ctof(c)) return c->master->distance;
+  if(binarytiling || archimedean || ctof(c)) return c->master->distance;
   if(gp::on) return gp::compute_dist(c, celldist);
   int dx[MAX_S3];
   for(int u=0; u<S3; u++)
@@ -1452,7 +1452,7 @@ int celldistance(cell *c1, cell *c2) {
     return 64;
     }
   
-  if(gp::on || masterless || irr::on || syntetic || binarytiling) {
+  if(gp::on || masterless || irr::on || archimedean || binarytiling) {
     
     if(saved_distances.count(make_pair(c1,c2)))
       return saved_distances[make_pair(c1,c2)];
diff --git a/classes.h b/classes.h
index 6199fa3b..3490ab2a 100644
--- a/classes.h
+++ b/classes.h
@@ -198,7 +198,7 @@ enum eLand { laNone, laBarrier, laCrossroads, laDesert, laIce, laCaves, laJungle
 
 enum eGeometry {
   gNormal, gEuclid, gSphere, gElliptic, gZebraQuotient, gFieldQuotient, gTorus, gOctagon, g45, g46, g47, gSmallSphere, gTinySphere, gEuclidSquare, gSmallElliptic, 
-  gKleinQuartic, gBolza, gBolza2, gMinimal, gBinaryTiling, gSyntetic,
+  gKleinQuartic, gBolza, gBolza2, gMinimal, gBinaryTiling, gArchimedean,
   gGUARD};
 
 enum eGeometryClass { gcHyperbolic, gcEuclid, gcSphere };
diff --git a/compileunits.h b/compileunits.h
index ca1bc672..5ff4f942 100644
--- a/compileunits.h
+++ b/compileunits.h
@@ -30,7 +30,7 @@
 #include "fieldpattern.cpp"
 #include "heptagon.cpp"
 #include "binary-tiling.cpp"
-#include "syntetic.cpp"
+#include "archimedean.cpp"
 #include "language.cpp"
 #include "cell.cpp"
 #include "goldberg.cpp"
diff --git a/debug.cpp b/debug.cpp
index 156a785a..877bdc53 100644
--- a/debug.cpp
+++ b/debug.cpp
@@ -336,8 +336,8 @@ void debugScreen() {
     dialog::addSelItem("temporary", its(mouseover->listindex), 0);
     if(gp::on)
       dialog::addSelItem("whirl", gp::disp(gp::get_local_info(mouseover).relative), 0);
-    if(syntetic)
-      dialog::addSelItem("ID", its(synt::id_of(mouseover->master)), 0);
+    if(archimedean)
+      dialog::addSelItem("ID", its(arcm::id_of(mouseover->master)), 0);
     dialog::addBreak(50);
     dialog::addSelItem("monster", dnameof2(mouseover->monst, mouseover->mondir), 0);
     dialog::addSelItem("stuntime/hitpoints", its(mouseover->stuntime)+"/"+its(mouseover->hitpoints), 0);
diff --git a/floorshapes.cpp b/floorshapes.cpp
index b7fada66..e731668b 100644
--- a/floorshapes.cpp
+++ b/floorshapes.cpp
@@ -281,7 +281,7 @@ void generate_floorshapes_for(int id, cell *c, int siid, int sidir) {
   for(auto pfsh: all_plain_floorshapes) {
     auto& fsh = *pfsh;
 
-    if(!gp::on && !irr::on && !syntetic) {
+    if(!gp::on && !irr::on && !archimedean) {
 
       // standard and binary
       ld hexside = fsh.rad0, heptside = fsh.rad1;
@@ -397,7 +397,7 @@ void generate_floorshapes_for(int id, cell *c, int siid, int sidir) {
     sizeto(fsh.b, id);
     sizeto(fsh.shadow, id);
     
-    if(!gp::on && !irr::on && !binarytiling && !syntetic) {
+    if(!gp::on && !irr::on && !binarytiling && !archimedean) {
       generate_matrices_scale(fsh.scale, fsh.noftype);
       if(nonbitrunc && geosupport_graveyard() < 2 && fsh.shapeid2) {
         if(id == 0) bshape2(fsh.b[0], fsh.prio, fsh.shapeid2, hept_matrices);
@@ -481,16 +481,16 @@ void generate_floorshapes() {
     
   else if(gp::on) { /* will be generated on the fly */ }
   
-  else if(syntetic) {
+  else if(archimedean) {
     heptagon master;
     cell model;
     model.master = &master;
-    synt::parent_index_of(&master) = 0;
-    for(int i=0; i<2*synt::N + (nonbitrunc ? 0 : 2); i++) {
-      synt::id_of(&master) = i;
-      model.type = isize(synt::triangles[i]);
+    arcm::parent_index_of(&master) = 0;
+    for(int i=0; i<2*arcm::N + (nonbitrunc ? 0 : 2); i++) {
+      arcm::id_of(&master) = i;
+      model.type = isize(arcm::triangles[i]);
       if(geosupport_graveyard() == 2)
-        generate_floorshapes_for(i, &model, !synt::pseudohept(i), i/2);
+        generate_floorshapes_for(i, &model, !arcm::pseudohept(i), i/2);
       else
         generate_floorshapes_for(i, &model, 0, 0);
       }
@@ -599,8 +599,8 @@ void draw_shapevec(cell *c, const transmatrix& V, const vector<hpcshape> &shv, i
       }
     queuepolyat(V, shv[id], col, prio);
     }
-  else if(syntetic) {
-    queuepolyat(V, shv[synt::id_of(c->master)], col, prio);
+  else if(archimedean) {
+    queuepolyat(V, shv[arcm::id_of(c->master)], col, prio);
     }
   else if((euclid || gp::on) && ishex1(c)) 
     queuepolyat(V * pispin, shv[0], col, prio);
diff --git a/geom-exp.cpp b/geom-exp.cpp
index da44bc25..a7f9d519 100644
--- a/geom-exp.cpp
+++ b/geom-exp.cpp
@@ -336,8 +336,8 @@ void showEuclideanMenu() {
         break;
       }
   
-    dialog::addSelItem(XLAT("sides per face"), syntetic ? "?" : its(ts), 0);
-    dialog::addSelItem(XLAT("faces per vertex"), syntetic ? "?" : its(tv), 0);
+    dialog::addSelItem(XLAT("sides per face"), archimedean ? "?" : its(ts), 0);
+    dialog::addSelItem(XLAT("faces per vertex"), archimedean ? "?" : its(tv), 0);
   
     string qstring = "none";
     if(tq & qZEBRA) qstring = "zebra";
@@ -353,9 +353,9 @@ void showEuclideanMenu() {
     dialog::addSelItem(XLAT("quotient space"), XLAT(qstring), 0);
   
     dialog::addSelItem(XLAT("size of the world"), 
-      (syntetic && euclid) ? "∞" :
-      (syntetic && sphere) ? its(isize(currentmap->allcells())) :
-      (syntetic && hyperbolic) ? "exp(∞)*?" :
+      (archimedean && euclid) ? "∞" :
+      (archimedean && sphere) ? its(isize(currentmap->allcells())) :
+      (archimedean && hyperbolic) ? "exp(∞)*?" :
       worldsize < 0 ? "exp(∞)*" + (nom%denom ? its(nom)+"/"+its(-denom) : its(-worldsize)): 
       worldsize == 0 ? "∞" :
       its(worldsize),
@@ -389,8 +389,8 @@ void showEuclideanMenu() {
       dialog::handleNavigation(sym, uni);
       if(uni >= 'a' && uni < 'a'+gGUARD) {
         targetgeometry = eGeometry(uni - 'a');
-        if(targetgeometry == gSyntetic)
-          pushScreen(synt::show);
+        if(targetgeometry == gArchimedean)
+          pushScreen(arcm::show);
         else {
           stop_game_and_switch_mode(geometry == targetgeometry ? rg::nothing : rg::geometry);
           start_game();
diff --git a/geometry.cpp b/geometry.cpp
index 3d7da3e5..71a31283 100644
--- a/geometry.cpp
+++ b/geometry.cpp
@@ -45,8 +45,8 @@ void precalc() {
   int vertexdegree = S6/2;
   ld fmin, fmax;  
 
-  if(syntetic) 
-    ginf[gSyntetic].cclass = gcHyperbolic;
+  if(archimedean) 
+    ginf[gArchimedean].cclass = gcHyperbolic;
 
   if(euclid) {
     // dynamicval<eGeometry> g(geometry, gNormal);
@@ -164,7 +164,7 @@ void precalc() {
   
   gp::compute_geometry();  
   irr::compute_geometry();
-  if(syntetic) synt::prepare();
+  if(archimedean) arcm::prepare();
   }
 
 transmatrix xspinpush(ld dir, ld dist) {
diff --git a/geometry2.cpp b/geometry2.cpp
index e26fbc5a..80b1d824 100644
--- a/geometry2.cpp
+++ b/geometry2.cpp
@@ -55,7 +55,7 @@ namespace gp { extern gp::local_info draw_li; }
 
 transmatrix calc_relative_matrix(cell *c2, cell *c1, const hyperpoint& point_hint) {
 
-  if(stdsphere) {
+  if(sphere_narcm) {
     if(!gmatrix0.count(c2) || !gmatrix0.count(c1)) {
       printf("building gmatrix0 (size=%d)\n", isize(gmatrix0));
       auto bak = gp::draw_li;
@@ -79,7 +79,7 @@ transmatrix calc_relative_matrix(cell *c2, cell *c1, const hyperpoint& point_hin
     }
   
   if(binarytiling) return binary::relative_matrix(c2->master, c1->master);
-  if(syntetic) return synt::relative_matrix(c2->master, c1->master);
+  if(archimedean) return arcm::relative_matrix(c2->master, c1->master);
   
   if(torus) {
     transmatrix t = Id;
@@ -389,9 +389,9 @@ hyperpoint get_corner_position(cell *c, int cid, ld cf) {
     vertices[6] = get_horopoint(-yy, 0);
     return mid_at_actual(vertices[cid], 3/cf);
     }
-  if(syntetic) {
-    if(synt::id_of(c->master) >= synt::N*2) return C0;
-    auto& t = synt::get_triangle(c->master, cid);
+  if(archimedean) {
+    if(arcm::id_of(c->master) >= arcm::N*2) return C0;
+    auto& t = arcm::get_triangle(c->master, cid);
     return xspinpush0(-t.first, t.second * 3 / cf);
     }
   if(nonbitrunc) {
@@ -432,7 +432,7 @@ hyperpoint midcorner(cell *c, int i, ld v) {
     hyperpoint nlfar = rel * vs2.vertices[(spin+2)%cor2];
     return mid_at(nfar, nlfar, .49);
     }
-  if(syntetic) return C0;
+  if(archimedean) return C0;
   printf("midcorner not handled\n");
   exit(1);
   }
@@ -450,11 +450,11 @@ hyperpoint nearcorner(cell *c, int i) {
     hyperpoint nc = vs.jpoints[vs.neid[i]];
     return mid_at(C0, nc, .94);
     }
-  if(syntetic) {
-    auto& t = synt::get_triangle(c->master, i);
-    int id = synt::id_of(c->master);
-    int id1 = synt::get_adj(synt::get_adj(c->master, i), -2).first;
-    return xspinpush0(-t.first - M_PI / c->type, synt::inradius[id/2] + synt::inradius[id1/2]);
+  if(archimedean) {
+    auto& t = arcm::get_triangle(c->master, i);
+    int id = arcm::id_of(c->master);
+    int id1 = arcm::get_adj(arcm::get_adj(c->master, i), -2).first;
+    return xspinpush0(-t.first - M_PI / c->type, arcm::inradius[id/2] + arcm::inradius[id1/2]);
     }
   if(binarytiling) {
     ld yx = log(2) / 2;
@@ -503,12 +503,12 @@ hyperpoint farcorner(cell *c, int i, int which) {
     }
   if(binarytiling)
     return nearcorner(c, (i+which) % c->type); // lazy
-  if(syntetic) {
-    auto& t = synt::get_triangle(c->master, i);
-    int id = synt::id_of(c->master);
-    auto id1 = synt::get_adj(synt::get_adj(c->master, i), -2).first;
-    int n1 = isize(synt::adjacent[id1]);
-    return spin(-t.first - M_PI / c->type) * xpush(synt::inradius[id/2] + synt::inradius[id1/2]) * xspinpush0(M_PI + M_PI/n1*(which?3:-3), synt::circumradius[id1/2]);
+  if(archimedean) {
+    auto& t = arcm::get_triangle(c->master, i);
+    int id = arcm::id_of(c->master);
+    auto id1 = arcm::get_adj(arcm::get_adj(c->master, i), -2).first;
+    int n1 = isize(arcm::adjacent[id1]);
+    return spin(-t.first - M_PI / c->type) * xpush(arcm::inradius[id/2] + arcm::inradius[id1/2]) * xspinpush0(M_PI + M_PI/n1*(which?3:-3), arcm::circumradius[id1/2]);
     }
   
   return cellrelmatrix(c, i) * get_corner_position(c->move(i), (cellwalker(c, i) + wstep + (which?2:-1)).spin);
diff --git a/graph.cpp b/graph.cpp
index be6d1051..6e3a10c3 100644
--- a/graph.cpp
+++ b/graph.cpp
@@ -235,8 +235,8 @@ void drawLightning(const transmatrix& V) {
   }
 
 ld displayspin(cell *c, int d) {
-  if(syntetic) {
-    auto& t1 = synt::get_triangle(c->master, d);
+  if(archimedean) {
+    auto& t1 = arcm::get_triangle(c->master, d);
     return -(t1.first + M_PI / c->type);
     }
   else if(irr::on) {
@@ -2391,7 +2391,7 @@ transmatrix applyPatterndir(cell *c, const patterns::patterninfo& si) {
   if(gp::on || irr::on || binarytiling) return Id;
   transmatrix V = ddspin(c, si.dir, M_PI);
   if(si.reflect) return V * Mirror;
-  if(syntetic) return V * iddspin(c, 0, M_PI);
+  if(archimedean) return V * iddspin(c, 0, M_PI);
   return V;
   }
 
@@ -3188,7 +3188,7 @@ bool placeSidewall(cell *c, int i, int sidepar, const transmatrix& V, int col) {
   
   transmatrix V2 = V * ddspin(c, i);
  
-  if(gp::on || irr::on || binarytiling || syntetic) {
+  if(gp::on || irr::on || binarytiling || archimedean) {
     draw_shapevec(c, V2, qfi.fshape->gpside[sidepar][i], col, prio);
     return false;
     }
@@ -4040,7 +4040,7 @@ void drawcell(cell *c, transmatrix V, int spinv, bool mirrored) {
         
         case laSwitch:
           set_floor(shSwitchFloor);
-          if(ctof(c) && !gp::on && !irr::on && !syntetic && !binarytiling) for(int i=0; i<c->type; i++)
+          if(ctof(c) && !gp::on && !irr::on && !archimedean && !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;
 
@@ -5238,8 +5238,8 @@ void drawthemap() {
     drawEuclidean();
   else if(binarytiling)
     binary::draw();
-  else if(syntetic)
-    synt::draw();
+  else if(archimedean)
+    arcm::draw();
   else
     drawrec(viewctr, hsOrigin, cview());
   drawWormSegments();
diff --git a/heptagon.cpp b/heptagon.cpp
index c9eb3dd7..a2a62dc7 100644
--- a/heptagon.cpp
+++ b/heptagon.cpp
@@ -77,7 +77,7 @@ heptagon *buildHeptagon1(heptagon *h, heptagon *parent, int d, hstate s, int par
   
 heptagon *buildHeptagon(heptagon *parent, int d, hstate s, int pard = 0, int fixdistance = COMPUTE) {
   heptagon *h = buildHeptagon1(new heptagon, parent, d, s, pard, fixdistance);
-  if(binarytiling || syntetic) return h;
+  if(binarytiling || archimedean) return h;
   if(parent->c7) {
     if(irr::on)
       irr::link_next(parent, d);
@@ -214,8 +214,8 @@ heptagon *createStep(heptagon *h, int d) {
   d = h->c.fix(d);
   if(!h->move(d) && binarytiling) 
     return binary::createStep(h, d);
-  if(!h->move(d) && syntetic) {
-    synt::create_adjacent(h, d); 
+  if(!h->move(d) && archimedean) {
+    arcm::create_adjacent(h, d); 
     return h->move(d);
     }
   if(!h->move(0) && h->s != hsOrigin && !binarytiling) {
diff --git a/hyper.h b/hyper.h
index 3ccef65a..7140bb88 100644
--- a/hyper.h
+++ b/hyper.h
@@ -84,11 +84,11 @@ void addMessage(string s, char spamtype = 0);
 #define S3 ginf[geometry].vertex
 #define hyperbolic_37 (S7 == 7 && S3 == 3 && !binarytiling)
 #define hyperbolic_not37 ((S7 > 7 || S3 > 3 || binarytiling) && hyperbolic)
-#define weirdhyperbolic ((S7 > 7 || S3 > 3 || gp::on || irr::on || binarytiling || syntetic) && hyperbolic)
-#define stdhyperbolic (S7 == 7 && S3 == 3 && !gp::on && !irr::on && !binarytiling && !syntetic)
+#define weirdhyperbolic ((S7 > 7 || S3 > 3 || gp::on || irr::on || binarytiling || archimedean) && hyperbolic)
+#define stdhyperbolic (S7 == 7 && S3 == 3 && !gp::on && !irr::on && !binarytiling && !archimedean)
 
 #define binarytiling (geometry == gBinaryTiling)
-#define syntetic (geometry == gSyntetic)
+#define archimedean (geometry == gArchimedean)
 #define eubinary (euclid || binarytiling)
 
 #define cgclass (ginf[geometry].cclass)
@@ -104,7 +104,7 @@ void addMessage(string s, char spamtype = 0);
 #define bounded (sphere || quotient || torus)
 
 #define masterless among(geometry, gEuclid, gEuclidSquare, gTorus)
-#define stdsphere (sphere && !syntetic)
+#define sphere_narcm (sphere && !archimedean)
 
 #define a4 (S3 == 4)
 #define a45 (S3 == 4 && S7 == 5)
@@ -472,7 +472,7 @@ struct cell : gcell {
   cell* cmove(int d) { return createMov(this, d); }
   };
 
-int heptagon::degree() { if(syntetic) return c7->type; else return S7; }
+int heptagon::degree() { if(archimedean) return c7->type; else return S7; }
 
 using heptspin = walker<heptagon>;
 using cellwalker = walker<cell>;
@@ -3828,7 +3828,7 @@ namespace binary {
   heptagon *createStep(heptagon *parent, int d);
   }
 
-namespace synt {
+namespace arcm {
   void initialize(heptagon *root);
   transmatrix relative_matrix(heptagon *h1, heptagon *h2);
   short& id_of(heptagon *);
diff --git a/hypgraph.cpp b/hypgraph.cpp
index 44de4d27..d1b1a641 100644
--- a/hypgraph.cpp
+++ b/hypgraph.cpp
@@ -499,20 +499,20 @@ bool confusingGeometry() {
   }
 
 ld master_to_c7_angle() {
-  return (nonbitrunc && !binarytiling && !syntetic) ? M_PI + gp::alpha : 0;
+  return (nonbitrunc && !binarytiling && !archimedean) ? M_PI + gp::alpha : 0;
   }
 
 transmatrix actualV(const heptspin& hs, const transmatrix& V) {
   if(irr::on)
     return V * spin(M_PI + 2 * M_PI / S7 * (hs.spin + irr::periodmap[hs.at].base.spin));
-  if(syntetic) return V * spin(-synt::triangles[synt::id_of(hs.at)][hs.spin].first);
+  if(archimedean) return V * spin(-arcm::triangles[arcm::id_of(hs.at)][hs.spin].first);
   if(binarytiling) return V;
   return (hs.spin || nonbitrunc) ? V * spin(hs.spin*2*M_PI/S7 + master_to_c7_angle()) : V;
   }
 
 transmatrix applyspin(const heptspin& hs, const transmatrix& V) {
   if(binarytiling) return V;
-  if(syntetic) return V * spin(synt::triangles[synt::id_of(hs.at)][hs.spin].first);
+  if(archimedean) return V * spin(arcm::triangles[arcm::id_of(hs.at)][hs.spin].first);
   return hs.spin ? V * spin(hs.spin*2*M_PI/S7) : V;
   }
 
@@ -804,11 +804,11 @@ void optimizeview() {
   
   transmatrix TB = Id;
   
-  if(binarytiling || syntetic) {
+  if(binarytiling || archimedean) {
     turn = -1, best = View[2][2];
     for(int i=0; i<viewctr.at->c7->type; i++) {
       heptagon *h2 = createStep(viewctr.at, i);
-      transmatrix T = (binarytiling) ? binary::relative_matrix(h2, viewctr.at) : synt::relative_matrix(h2, viewctr.at);
+      transmatrix T = (binarytiling) ? binary::relative_matrix(h2, viewctr.at) : arcm::relative_matrix(h2, viewctr.at);
       hyperpoint H = View * tC0(T);
       ld quality = euclid ? hdist0(H) : H[2];
       if(quality < best) best = quality, turn = i, TB = T;
diff --git a/landgen.cpp b/landgen.cpp
index f28b24c8..9f586a1d 100644
--- a/landgen.cpp
+++ b/landgen.cpp
@@ -480,9 +480,9 @@ void giantLandSwitch(cell *c, int d, cell *from) {
           else
             v = 6;
           }
-        else if(syntetic && synt::have_line)
-          v = synt::linespattern(c) ? 24 : 16;
-        else if(torus || hyperbolic_not37 || quotient || syntetic) {
+        else if(archimedean && arcm::have_line)
+          v = arcm::linespattern(c) ? 24 : 16;
+        else if(torus || hyperbolic_not37 || quotient || archimedean) {
           v = hrand(100) < 25 ? 24 : 16;
           }
         else if(euclid) {
@@ -543,9 +543,9 @@ void giantLandSwitch(cell *c, int d, cell *from) {
     case laZebra:
       if(d==8) {
         if(torus) ;
-        else if(syntetic && synt::have_line)
-          c->wall = synt::linespattern(c) ? waTrapdoor : waNone;        
-        else if(euclid && !syntetic) {
+        else if(archimedean && arcm::have_line)
+          c->wall = arcm::linespattern(c) ? waTrapdoor : waNone;        
+        else if(euclid && !archimedean) {
           int x,y;
           tie(x,y) = cell_to_pair(c);
           if(y&1) c->wall = waTrapdoor;
@@ -565,15 +565,15 @@ void giantLandSwitch(cell *c, int d, cell *from) {
     case laWineyard:
       if(d==8) {
         if(torus) ;
-        else if(syntetic && synt::have_line)
-          c->wall = synt::linespattern(c) ? waVinePlant : waNone;
-        else if(euclid && !syntetic) {
+        else if(archimedean && arcm::have_line)
+          c->wall = arcm::linespattern(c) ? waVinePlant : waNone;
+        else if(euclid && !archimedean) {
           int x,y;
           tie(x,y) = cell_to_pair(c);
           int dy = gmod(y, 3);
           if(dy == 1) c->wall = waVinePlant;
           }
-        else if(a4 || sphere || syntetic)
+        else if(a4 || sphere || archimedean)
           c->wall = hrand(100) < 50 ? waNone : waVinePlant;
         else {
           int v = emeraldval(c);
diff --git a/monstergen.cpp b/monstergen.cpp
index 0a341221..339d6995 100644
--- a/monstergen.cpp
+++ b/monstergen.cpp
@@ -264,7 +264,7 @@ bool haveOrbPower() {
     cell *c = dcal[i];
     if(itemclass(c->item) == IC_ORB) return true;
     }
-  else if(stdsphere) for(int i=0; i<spherecells(); i++) {
+  else if(sphere_narcm) for(int i=0; i<spherecells(); i++) {
     cell *c = getDodecahedron(i)->c7;
     if(itemclass(c->item) == IC_ORB) return true;
     forCellEx(c2, c) if(itemclass(c2->item) == IC_ORB) return true;
@@ -446,7 +446,7 @@ void wandering() {
         }
       if(!peace::on && c->land == laKraken && ((sphere && !hrand(15)) || wchance(items[itKraken], 240)) && !kraken_pseudohept(c)) {
         bool b = sphere || canReachPlayer(c, moKrakenH);
-        if(stdsphere && (haveKraken() || !items[itOrbFish])) { 
+        if(sphere_narcm && (haveKraken() || !items[itOrbFish])) { 
           c->monst = moViking; c->wall = waBoat; c->item = itOrbFish; 
           playSeenSound(c);
           continue;
diff --git a/pattern2.cpp b/pattern2.cpp
index 878a5c69..dec833d7 100644
--- a/pattern2.cpp
+++ b/pattern2.cpp
@@ -50,8 +50,8 @@ bool ishex2(cell *c) {
   }
 
 int chessvalue(cell *c) {
-  if(syntetic) 
-    return synt::chessvalue(c);
+  if(archimedean) 
+    return arcm::chessvalue(c);
   else
     return celldist(c) & 1;
   }
@@ -350,7 +350,7 @@ int fieldval_uniq(cell *c) {
     auto p = cell_to_pair(c);
     return gmod(p.first * torusconfig::dx + p.second * torusconfig::dy, torusconfig::qty);
     }
-  else if(binarytiling || syntetic) return 0;
+  else if(binarytiling || archimedean) return 0;
   if(ctof(c) || gp::on || irr::on) return c->master->fieldval/S7;
   else {
     int z = 0;
@@ -730,7 +730,7 @@ namespace patterns {
     }
 
   void val_all(cell *c, patterninfo &si, int sub, int pat) {
-    if(irr::on || syntetic || binarytiling) si.symmetries = 1;
+    if(irr::on || archimedean || binarytiling) si.symmetries = 1;
     else if(a46) val46(c, si, sub, pat);
     else if(a38) val38(c, si, sub, pat);
     else if(sphere) valSibling(c, si, sub, pat);
@@ -893,13 +893,13 @@ namespace patterns {
       return si;
       }
     
-    if(syntetic && pat == PAT_SIBLING) {
-      int id = synt::id_of(c->master);
-      si.id = synt::tilegroup[id];
-      si.symmetries = synt::periods[si.id];
-      si.dir = synt::groupoffset[id];
-      if((sub & SPF_EXTRASYM) && synt::have_symmetry && synt::tilegroup[id^1] < synt::tilegroup[id])
-        si.id = synt::tilegroup[id^1],
+    if(archimedean && pat == PAT_SIBLING) {
+      int id = arcm::id_of(c->master);
+      si.id = arcm::tilegroup[id];
+      si.symmetries = arcm::periods[si.id];
+      si.dir = arcm::groupoffset[id];
+      if((sub & SPF_EXTRASYM) && arcm::have_symmetry && arcm::tilegroup[id^1] < arcm::tilegroup[id])
+        si.id = arcm::tilegroup[id^1],
         si.reflect = true;
       return si;
       }
@@ -1066,7 +1066,7 @@ int geosupport_threecolor() {
     return 2;
   if(a46 && nonbitrunc)
     return 1;
-  if(syntetic) return synt::support_threecolor();
+  if(archimedean) return arcm::support_threecolor();
   return 0;
   }
 
@@ -1074,7 +1074,7 @@ int geosupport_graveyard() {
   // always works in bitrunc geometries
   if(!nonbitrunc) return 2;
 
-  if(syntetic) return synt::support_graveyard();
+  if(archimedean) return arcm::support_graveyard();
 
   if(irr::on) return irr::bitruncations_performed ? 2 : 1;
   
@@ -1090,7 +1090,7 @@ int geosupport_graveyard() {
   }
 
 int pattern_threecolor(cell *c) {
-  if(syntetic) return synt::threecolor(synt::id_of(c->master));
+  if(archimedean) return arcm::threecolor(arcm::id_of(c->master));
   if(S3 == 3 && !(S7&1) && gp_threecolor() == 1 && c->master->c7 != c) {
     auto li = gp::get_local_info(c);
     int rel = (li.relative.first - li.relative.second + MODFIXER) % 3;
@@ -1191,7 +1191,7 @@ int pattern_threecolor(cell *c) {
 bool pseudohept(cell *c) {
   if(irr::on) return irr::pseudohept(c);
   if(binarytiling) return c->type & c->master->distance & 1;
-  if(syntetic) return synt::pseudohept(synt::id_of(c->master));
+  if(archimedean) return arcm::pseudohept(arcm::id_of(c->master));
   if(gp::on && gp_threecolor() == 2)
     return gp::pseudohept_val(c) == 0;
   if(gp::on && gp_threecolor() == 1 && (S7&1) && (S3 == 3))
@@ -1233,8 +1233,8 @@ namespace patterns {
   char whichCanvas = 0;
 
   int generateCanvas(cell *c) {
-    if(whichCanvas == 'A' && syntetic)
-      return distcolors[synt::tilegroup[synt::id_of(c->master)] & 7];
+    if(whichCanvas == 'A' && archimedean)
+      return distcolors[arcm::tilegroup[arcm::id_of(c->master)] & 7];
     if(whichCanvas == 'C' && hyperbolic) {
       using namespace fieldpattern;
       int z = currfp.getdist(fieldval(c), make_pair(0,false));
@@ -1410,7 +1410,7 @@ namespace patterns {
       dialog::addSelItem(XLAT("field pattern S"), "field", 'S');
       }
     
-    if(syntetic)
+    if(archimedean)
       dialog::addSelItem(XLAT("Archimedean"), "Archimedean", 'A');
 
     dialog::addBreak(100);
@@ -1481,7 +1481,7 @@ namespace patterns {
     if(stdhyperbolic || euclid)
       dialog::addBoolItem(XLAT("Palace Pattern"), (whichPattern == PAT_PALACE), PAT_PALACE);
     
-    if((nonbitrunc && S3 == 4) || (syntetic && synt::support_chessboard()))
+    if((nonbitrunc && S3 == 4) || (archimedean && arcm::support_chessboard()))
       dialog::addBoolItem(XLAT("chessboard"), (whichPattern == PAT_CHESS), PAT_CHESS);
 
     if(a38 || a46 || euclid || S3 == 4 || S7 == 4)
@@ -1490,7 +1490,7 @@ namespace patterns {
     if(sphere)
       dialog::addBoolItem(XLAT("siblings"), (whichPattern == PAT_SIBLING), PAT_SIBLING);
     
-    if(syntetic)
+    if(archimedean)
       dialog::addBoolItem(XLAT("Archimedean"), (whichPattern == PAT_SIBLING), PAT_SIBLING);
 
     if(euclid)
@@ -1536,10 +1536,10 @@ namespace patterns {
       dialog::addBoolItem(XLAT("symmetry 0-2"), subpattern_flags & SPF_SYM02, '2');
       dialog::addBoolItem(XLAT("symmetry 0-3"), subpattern_flags & SPF_SYM03, '3');
       }
-    if(euclid && among(whichPattern, PAT_COLORING, 0) && !syntetic)
+    if(euclid && among(whichPattern, PAT_COLORING, 0) && !archimedean)
       dialog::addBoolItem(XLAT("extra symmetries"), subpattern_flags & SPF_EXTRASYM, '=');
     
-    if(syntetic && synt::have_symmetry && whichPattern == PAT_SIBLING)
+    if(archimedean && arcm::have_symmetry && whichPattern == PAT_SIBLING)
       dialog::addBoolItem(XLAT("extra symmetries"), subpattern_flags & SPF_EXTRASYM, '=');
 
     if(whichPattern == PAT_SINGLETYPE) {
@@ -2089,7 +2089,7 @@ namespace linepatterns {
               col,
               1 + vid.linequality);
           }
-        else if(syntetic) {
+        else if(archimedean) {
           if(!pseudohept(c)) for(int i=0; i<c->type; i++) if(c->move(i) && c < c->move(i) && !pseudohept(c->move(i)) && gmatrix.count(c->move(i))) 
             queuelinef(tC0(V), gmatrix[c->move(i)]*C0, 
               col,
diff --git a/polygons.cpp b/polygons.cpp
index 62392a09..8be6b4d8 100644
--- a/polygons.cpp
+++ b/polygons.cpp
@@ -1328,7 +1328,7 @@ 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;
+  if(archimedean) tlength = arcm::edgelength;
   int max = int(20 * pow(2, vid.linequality));
   for(ld i=0; i<=max; i++)
     hpcpush(ddi(S21, rad + var * sin(i * M_PI/divby)) * ddi(0, tlength * i/max) * C0);
@@ -1432,7 +1432,7 @@ void bshape(hpcshape& sh, int p, double shzoom, int shapeid, double bonus = 0, f
   while(polydata[whereis + 2*qty] != NEWSHAPE) qty++;
   double shzoomx = shzoom;
   double shzoomy = shzoom;
-  if(shzoom == WOLF) shzoomx = 1.5 * (nonbitrunc && !syntetic ? crossf / hcrossf : 1), shzoomy = 1.6 * (nonbitrunc && !syntetic ? crossf / hcrossf : 1);
+  if(shzoom == WOLF) shzoomx = 1.5 * (nonbitrunc && !archimedean ? crossf / hcrossf : 1), shzoomy = 1.6 * (nonbitrunc && !archimedean ? crossf / hcrossf : 1);
   int rots2 = rots;
   // shapes 368..370 are specially designed
   if(!(shapeid >= 368 && shapeid <= 370)) {
@@ -1631,12 +1631,12 @@ void buildpolys() {
       floorrad1 = rhexf * .8;
     }
 
-  if(syntetic) {
-    triangleside = synt::edgelength;
+  if(archimedean) {
+    triangleside = arcm::edgelength;
     goldbf = 1;
-    scalef = synt::edgelength / hcrossf7;
+    scalef = arcm::edgelength / hcrossf7;
     floorrad0 = floorrad1 = triangleside * .45;
-    xcrossf = synt::edgelength;
+    xcrossf = arcm::edgelength;
     zhexf = xcrossf * .55;
     }
 
@@ -1994,8 +1994,8 @@ void buildpolys() {
   if(a46 && !nonbitrunc) spzoom6 *= .9;
   if(a47 && !nonbitrunc) spzoom6 *= .85;
   
-  if(syntetic)
-    shFullFloor.configure(synt::edgelength/2, synt::edgelength/2);
+  if(archimedean)
+    shFullFloor.configure(arcm::edgelength/2, arcm::edgelength/2);
   else
     shFullFloor.configure(hexvdist, rhexf);
   shFloor.configure(floorrad0, floorrad1);