renamed 'syntetic' to 'archimedean' (enums/files/marcos/namespaces)

2025-10-29 04:47:41 +00:00 · 2018-08-19 23:06:32 +02:00
parent 1c8f0e7e37
commit 4d31e5a544
18 changed files with 147 additions and 146 deletions
--- a/archimedean.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"), '-');
--- 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() {
--- 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)];
--- 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 };
--- 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"
--- 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);
--- 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);
--- 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();
--- 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) {
--- 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);
--- 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();
--- 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) {
--- 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 *);
--- 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;
--- 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);
--- 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;
--- 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,
--- 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);