mirror of
https://github.com/zenorogue/hyperrogue.git
synced 2025-02-02 12:19:18 +00:00
renamed 'syntetic' to 'archimedean' (enums/files/marcos/namespaces)
This commit is contained in:
Zeno Rogue
parent
1c8f0e7e37
commit
4d31e5a544
@ -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"), '-');
|
||||
@ -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() {
|
||||
|
||||
16
cell.cpp
16
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)];
|
||||
|
||||
@ -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 };
|
||||
|
||||
@ -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"
|
||||
|
||||
@ -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);
|
||||
|
||||
@ -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);
|
||||
|
||||
14
geom-exp.cpp
14
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();
|
||||
|
||||
@ -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) {
|
||||
|
||||
@ -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);
|
||||
|
||||
14
graph.cpp
14
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();
|
||||
|
||||
@ -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) {
|
||||
|
||||
12
hyper.h
12
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 *);
|
||||
|
||||
10
hypgraph.cpp
10
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;
|
||||
|
||||
20
landgen.cpp
20
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);
|
||||
|
||||
@ -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;
|
||||
|
||||
46
pattern2.cpp
46
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,
|
||||
|
||||
16
polygons.cpp
16
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);
|
||||
|
||||
Loading…
Reference in New Issue
Block a user