mirror of
https://github.com/zenorogue/hyperrogue.git
synced 2024-11-27 06:27:17 +00:00
cleanup in Euclidean
This commit is contained in:
Zeno Rogue
parent
fe180cb6c3
commit
ddb5d07ff6
14
bigstuff.cpp
14
bigstuff.cpp
@ -59,6 +59,8 @@ EX int celldistAltRelative(cell *c) {
|
||||
return celldistAlt(c) - roundTableRadius(c);
|
||||
}
|
||||
|
||||
EX gp::loc camelot_coords() { return gp::loc(a4 ? 21 : 20, 10); }
|
||||
|
||||
EX int euclidAlt(short x, short y) {
|
||||
if(among(specialland, laTemple, laClearing, laCanvas)) {
|
||||
if(euclid6)
|
||||
@ -82,20 +84,20 @@ EX int euclidAlt(short x, short y) {
|
||||
return 3 - min(abs(x), abs(y));
|
||||
}
|
||||
else if(specialland == laPrincessQuest)
|
||||
return eudist(x-EPX, y-EPY);
|
||||
else return eudist(x-(a4 ? 21 : 20), y-10);
|
||||
return euc::dist(gp::loc(x,y), princess::coords());
|
||||
else return euc::dist(gp::loc(x,y), camelot_coords());
|
||||
}
|
||||
|
||||
EX int cylinder_alt(cell *c) {
|
||||
if(specialland == laPrincessQuest)
|
||||
return celldistance(c, at_euc2_coordinates({EPX, EPY}));
|
||||
return celldistance(c, euc::at(princess::coords()));
|
||||
if(specialland == laCamelot)
|
||||
return celldistance(c, at_euc2_coordinates({21, 10}));
|
||||
return celldistance(c, euc::at(camelot_coords()));
|
||||
|
||||
int maxmul = 0;
|
||||
for(int d = 0; d < SG6; d++)
|
||||
maxmul = max(maxmul, dcross(sdxy(), gp::eudir(d)));
|
||||
return 5-abs(gdiv(dcross(sdxy(), euc2_coordinates(c)), maxmul));
|
||||
maxmul = max(maxmul, euc::dcross(euc::sdxy(), gp::eudir(d)));
|
||||
return 5-abs(gdiv(euc::dcross(euc::sdxy(), euc2_coordinates(c)), maxmul));
|
||||
}
|
||||
|
||||
const int NOCOMPASS = 1000000;
|
||||
|
||||
@ -914,7 +914,7 @@ EX int celldistance3_hex(heptagon *c1, heptagon *c2) {
|
||||
int sx = int(floor(h[0] - h[1] / sqrt(3) + .5)) / 3;
|
||||
int sy = int(floor(h[1] * 2 / sqrt(3) + .5)) / 3;
|
||||
|
||||
int ysteps = xsteps + eudist(sx, sy);
|
||||
int ysteps = xsteps + euc::dist(sx, sy);
|
||||
if(ysteps < steps) steps = ysteps;
|
||||
if(sx >= 8 || sx <= -8 || sy >= 8 || sy <= -8) break;
|
||||
}
|
||||
|
||||
4
cell.cpp
4
cell.cpp
@ -796,7 +796,7 @@ cdata *getHeptagonCdata(heptagon *h) {
|
||||
cdata *getEuclidCdata(gp::loc h) {
|
||||
|
||||
int x = h.first, y = h.second;
|
||||
auto& data = archimedean ? arcm::get_cdata() : get_cdata();
|
||||
auto& data = archimedean ? arcm::get_cdata() : euc::get_cdata();
|
||||
|
||||
// hrmap_euclidean* euc = dynamic_cast<hrmap_euclidean*> (currentmap);
|
||||
if(data.count(h)) return &(data[h]);
|
||||
@ -1013,7 +1013,7 @@ EX int celldistance(cell *c1, cell *c2) {
|
||||
#endif
|
||||
|
||||
if(euclid && WDIM == 2 && !penrose && !archimedean) {
|
||||
return cyldist(euc2_coordinates(c1), euc2_coordinates(c2));
|
||||
return euc::cyldist(euc2_coordinates(c1), euc2_coordinates(c2));
|
||||
}
|
||||
|
||||
if(archimedean || quotient || solnih || (penrose && euclid) || experimental || sl2 || nil) {
|
||||
|
||||
@ -1782,7 +1782,7 @@ void celldrawer::draw_cellstat() {
|
||||
}
|
||||
|
||||
if(cmode & sm::TORUSCONFIG) {
|
||||
auto p = coord_display(V, c);
|
||||
auto p = euc::coord_display(V, c);
|
||||
if(p.second != "")
|
||||
queuestr(V, p.first ? .2 : .6, p.second, p.first ? 0xFFFFFFD0 : 0xFFFF0040, 1);
|
||||
}
|
||||
|
||||
@ -479,9 +479,6 @@ EX namespace elec {
|
||||
EX namespace princess {
|
||||
|
||||
#if HDR
|
||||
#define EPX 39
|
||||
#define EPY 21
|
||||
|
||||
#define OUT_OF_PRISON 200
|
||||
#define OUT_OF_PALACE 250
|
||||
#define PRADIUS0 (141)
|
||||
@ -499,6 +496,8 @@ struct info {
|
||||
|
||||
#endif
|
||||
|
||||
EX gp::loc coords() { return gp::loc(39, 21); }
|
||||
|
||||
EX bool generating = false;
|
||||
EX bool challenge = false;
|
||||
EX bool saved = false;
|
||||
|
||||
398
euclid.cpp
398
euclid.cpp
@ -8,9 +8,7 @@
|
||||
#include "hyper.h"
|
||||
namespace hr {
|
||||
|
||||
// 3D Euclidean space
|
||||
|
||||
EX namespace euclid3 {
|
||||
EX namespace euc {
|
||||
|
||||
#if HDR
|
||||
struct coord : array<int, 3> {
|
||||
@ -73,10 +71,54 @@ EX namespace euclid3 {
|
||||
}
|
||||
|
||||
EX coord canonicalize(coord x);
|
||||
EX int twisted;
|
||||
EX intmatrix T0;
|
||||
EX gp::loc twisted_vec, ortho_vec;
|
||||
|
||||
#if HDR
|
||||
struct canonical_t {
|
||||
unordered_map<coord, int> hash;
|
||||
vector<coord> seq;
|
||||
int index;
|
||||
|
||||
canonical_t() { index = 0; }
|
||||
|
||||
void reset() { index = 0; }
|
||||
|
||||
void add(coord val);
|
||||
|
||||
coord get(coord x);
|
||||
};
|
||||
|
||||
struct torus_config {
|
||||
/** periods entered by the user */
|
||||
intmatrix user_axes;
|
||||
/** OR'ed flags: 1 -- flip X in 3D, 2 -- flip Y in 3D, 4 -- flip X/Y in 3D, 8 -- Klein bottle in 2D, 16 -- third turn in 3D */
|
||||
int twisted;
|
||||
|
||||
torus_config() {}
|
||||
torus_config(intmatrix user_axes, int twisted) : user_axes(user_axes), twisted(twisted) {}
|
||||
};
|
||||
|
||||
struct torus_config_full : torus_config {
|
||||
/** optimal representation of the periods */
|
||||
intmatrix optimal_axes;
|
||||
/** regular axes (?) */
|
||||
intmatrix regular_axes;
|
||||
/** in 2D: the period vector which is reflected */
|
||||
gp::loc twisted_vec;
|
||||
/** in 2D: a vector orthogonal to twisted_vec */
|
||||
gp::loc ortho_vec;
|
||||
/** determinant */
|
||||
int det;
|
||||
/** the number of infinite dimensions */
|
||||
int infinite_dims;
|
||||
/** ? */
|
||||
intmatrix inverse_axes;
|
||||
/** struct for canonicalization */
|
||||
canonical_t canonical;
|
||||
};
|
||||
#endif
|
||||
EX torus_config eu_input, eu_edit;
|
||||
EX torus_config_full eu;
|
||||
|
||||
struct hrmap_euclid3 : hrmap_standard {
|
||||
vector<coord> shifttable;
|
||||
vector<transmatrix> tmatrix;
|
||||
@ -138,7 +180,7 @@ EX namespace euclid3 {
|
||||
auto h = get_at(at);
|
||||
int d1 = (d+S7/2)%S7;
|
||||
bool mirr = false;
|
||||
if(twisted) {
|
||||
if(eu.twisted) {
|
||||
transmatrix I;
|
||||
auto st = shifttable[d1];
|
||||
twist(ispacemap[parent] + shifttable[d], st, I, mirr);
|
||||
@ -153,7 +195,7 @@ EX namespace euclid3 {
|
||||
}
|
||||
|
||||
transmatrix adj(heptagon *h, int i) override {
|
||||
if(!twisted) return tmatrix[i];
|
||||
if(!eu.twisted) return tmatrix[i];
|
||||
transmatrix res = tmatrix[i];
|
||||
coord id = ispacemap[h];
|
||||
id += shifttable[i];
|
||||
@ -187,7 +229,7 @@ EX namespace euclid3 {
|
||||
}
|
||||
|
||||
transmatrix relative_matrix(heptagon *h2, heptagon *h1, const hyperpoint& hint) override {
|
||||
if(twisted) {
|
||||
if(eu.twisted) {
|
||||
if(h1 == h2) return Id;
|
||||
for(int s=0; s<S7; s++) if(h2 == h1->move(s)) return adj(h1, s);
|
||||
coord c1 = ispacemap[h1];
|
||||
@ -200,11 +242,11 @@ EX namespace euclid3 {
|
||||
for(int a=-1; a<=1; a++)
|
||||
for(int b=-1; b<=1; b++) {
|
||||
if(b && WDIM == 2) continue;
|
||||
transmatrix T1 = I * eumove((c2 - cs) + a*T0[0] + b*T0[1]);
|
||||
transmatrix T1 = I * eumove((c2 - cs) + a*eu.user_axes[0] + b*eu.user_axes[1]);
|
||||
if(hdist(tC0(T1), hint) < hdist(tC0(T), hint))
|
||||
T = T1;
|
||||
}
|
||||
auto co = T0[WDIM-1];
|
||||
auto co = eu.user_axes[WDIM-1];
|
||||
cs += co;
|
||||
I = I * eumove(co);
|
||||
auto dummy = euzero;
|
||||
@ -378,59 +420,38 @@ EX namespace euclid3 {
|
||||
return T2;
|
||||
}
|
||||
|
||||
intmatrix user_axes;
|
||||
intmatrix optimal_axes;
|
||||
intmatrix regular_axes;
|
||||
|
||||
intmatrix T, T2, T_edit;
|
||||
EX int det;
|
||||
int infinite_dims;
|
||||
EX int twisted0;
|
||||
int twisted_edit;
|
||||
|
||||
EX void set_torus3(int x, int y, int z) {
|
||||
for(int i=0; i<3; i++) for(int j=0; j<3; j++) T0[i][j] = 0;
|
||||
EX torus_config torus3(int x, int y, int z) {
|
||||
intmatrix T0 = euzeroall;
|
||||
tie(T0[0][0], T0[1][1], T0[2][2]) = make_tuple(x, y, z);
|
||||
twisted = 0;
|
||||
return {T0, 0};
|
||||
}
|
||||
|
||||
EX void clear_torus3() {
|
||||
set_torus3(0, 0, 0);
|
||||
EX torus_config clear_torus3() {
|
||||
return {euzeroall, 0};
|
||||
}
|
||||
|
||||
unordered_map<coord, int> canonical_hash;
|
||||
vector<coord> canonical_seq;
|
||||
int canonical_index;
|
||||
|
||||
coord compute_cat(coord coo) {
|
||||
EX coord compute_cat(coord coo) {
|
||||
coord cat = euzero;
|
||||
auto& T2 = eu.inverse_axes;
|
||||
for(int i=0; i<3; i++) {
|
||||
int val = T2[0][i] * coo[0] + T2[1][i] * coo[1] + T2[2][i] * coo[2];
|
||||
if(i < WDIM - infinite_dims) val = gmod(val, det);
|
||||
if(i < WDIM - eu.infinite_dims) val = gmod(val, eu.det);
|
||||
cat += val * main_axes[i];
|
||||
}
|
||||
return cat;
|
||||
};
|
||||
|
||||
|
||||
void add_canonical(coord val) {
|
||||
auto cat = compute_cat(val);
|
||||
if(canonical_hash.count(cat)) return;
|
||||
canonical_hash[cat] = isize(canonical_seq);
|
||||
canonical_seq.push_back(val);
|
||||
}
|
||||
|
||||
|
||||
EX bool valid_third_turn(const intmatrix& m) {
|
||||
if(T0[0][2] != -T0[0][0]-T0[0][1]) return false;
|
||||
if(T0[1][0] != T0[0][1]) return false;
|
||||
if(T0[1][1] != T0[0][2]) return false;
|
||||
if(T0[1][2] != T0[0][0]) return false;
|
||||
if(T0[2][0] != T0[2][1]) return false;
|
||||
if(T0[2][0] != T0[2][2]) return false;
|
||||
if(m[0][2] != -m[0][0]-m[0][1]) return false;
|
||||
if(m[1][0] != m[0][1]) return false;
|
||||
if(m[1][1] != m[0][2]) return false;
|
||||
if(m[1][2] != m[0][0]) return false;
|
||||
if(m[2][0] != m[2][1]) return false;
|
||||
if(m[2][0] != m[2][2]) return false;
|
||||
return true;
|
||||
}
|
||||
|
||||
EX intmatrix make_third_turn(int a, int b, int c) {
|
||||
EX torus_config make_third_turn(int a, int b, int c) {
|
||||
intmatrix T0;
|
||||
T0[0][0] = a;
|
||||
T0[0][1] = b;
|
||||
@ -440,58 +461,72 @@ EX namespace euclid3 {
|
||||
T0[1][1] = T0[0][2];
|
||||
T0[1][2] = T0[0][0];
|
||||
T0[2][1] = T0[2][2] = c;
|
||||
return T0;
|
||||
return {T0, 8};
|
||||
}
|
||||
|
||||
EX intmatrix make_quarter_turn(int a, int b, int c) {
|
||||
EX torus_config make_quarter_turn(int a, int b, int c) {
|
||||
intmatrix T0 = euzeroall;
|
||||
T0[0][0] = a;
|
||||
T0[0][1] = b;
|
||||
T0[2][0] = c;
|
||||
return T0;
|
||||
return {T0, 5};
|
||||
}
|
||||
|
||||
void canonical_t::add(coord val) {
|
||||
auto cat = compute_cat(val); if(hash.count(cat)) return; hash[cat] = isize(seq); seq.push_back(val);
|
||||
}
|
||||
|
||||
coord canonical_t::get(coord x) {
|
||||
auto cat = compute_cat(x);
|
||||
auto& st = cubemap()->shifttable;
|
||||
while(!hash.count(cat)) {
|
||||
if(index == isize(seq)) throw hr_exception();
|
||||
auto v = seq[index++];
|
||||
for(auto s: st) add(v + s);
|
||||
}
|
||||
return seq[hash[cat]];
|
||||
}
|
||||
|
||||
EX void build_torus3(eGeometry g) {
|
||||
|
||||
int dim = ginf[g].g.gameplay_dimension;
|
||||
|
||||
if(IRREGULAR) T0 = irr::base_periods, twisted0 = irr::base_twisted;
|
||||
// if(IRREGULAR) T0 = irr::base_periods, twisted0 = irr::base_twisted;
|
||||
|
||||
user_axes = T0;
|
||||
if(dim == 2) user_axes[2] = euzero;
|
||||
eu.user_axes = eu_input.user_axes;
|
||||
if(dim == 2) eu.user_axes[2] = euzero;
|
||||
|
||||
optimal_axes = user_axes;
|
||||
eu.optimal_axes = eu.user_axes;
|
||||
|
||||
again:
|
||||
for(int i=0; i<dim; i++) if(optimal_axes[i] < euzero) optimal_axes[i] = -optimal_axes[i];
|
||||
if(optimal_axes[0] < optimal_axes[1]) swap(optimal_axes[0], optimal_axes[1]);
|
||||
if(optimal_axes[1] < optimal_axes[dim-1]) swap(optimal_axes[1], optimal_axes[dim-1]);
|
||||
if(optimal_axes[0] < optimal_axes[1]) swap(optimal_axes[0], optimal_axes[1]);
|
||||
for(int i=0; i<dim; i++) if(eu.optimal_axes[i] < euzero) eu.optimal_axes[i] = -eu.optimal_axes[i];
|
||||
if(eu.optimal_axes[0] < eu.optimal_axes[1]) swap(eu.optimal_axes[0], eu.optimal_axes[1]);
|
||||
if(eu.optimal_axes[1] < eu.optimal_axes[dim-1]) swap(eu.optimal_axes[1], eu.optimal_axes[dim-1]);
|
||||
if(eu.optimal_axes[0] < eu.optimal_axes[1]) swap(eu.optimal_axes[0], eu.optimal_axes[1]);
|
||||
for(int i=0; i<3; i++) {
|
||||
int i1 = (i+1) % 3;
|
||||
int i2 = (i+2) % 3;
|
||||
for(int a=-10; a<=10; a++)
|
||||
for(int b=-10; b<=10; b++) {
|
||||
coord cand = optimal_axes[i] + optimal_axes[i1] * a + optimal_axes[i2] * b;
|
||||
if(celldistance(cand) < celldistance(optimal_axes[i])) {
|
||||
optimal_axes[i] = cand;
|
||||
coord cand = eu.optimal_axes[i] + eu.optimal_axes[i1] * a + eu.optimal_axes[i2] * b;
|
||||
if(celldistance(cand) < celldistance(eu.optimal_axes[i])) {
|
||||
eu.optimal_axes[i] = cand;
|
||||
goto again;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
regular_axes = optimal_axes;
|
||||
infinite_dims = dim;
|
||||
for(int i=0; i<dim; i++) if(optimal_axes[i] != euzero) infinite_dims--;
|
||||
eu.regular_axes = eu.optimal_axes;
|
||||
eu.infinite_dims = dim;
|
||||
for(int i=0; i<dim; i++) if(eu.optimal_axes[i] != euzero) eu.infinite_dims--;
|
||||
|
||||
int attempt = 0;
|
||||
next_attempt:
|
||||
for(int i=dim-infinite_dims; i<3; i++)
|
||||
regular_axes[i] = main_axes[(attempt+i)%3];
|
||||
for(int i=dim-eu.infinite_dims; i<3; i++)
|
||||
eu.regular_axes[i] = main_axes[(attempt+i)%3];
|
||||
|
||||
T = regular_axes;
|
||||
det = determinant(T);
|
||||
if(det == 0) {
|
||||
eu.det = determinant(eu.regular_axes);
|
||||
if(eu.det == 0) {
|
||||
attempt++;
|
||||
if(attempt == 3) {
|
||||
println(hlog, "weird singular!\n");
|
||||
@ -500,50 +535,49 @@ EX namespace euclid3 {
|
||||
goto next_attempt;
|
||||
}
|
||||
|
||||
if(det < 0) det = -det;
|
||||
if(eu.det < 0) eu.det = -eu.det;
|
||||
|
||||
T2 = scaled_inverse(T);
|
||||
canonical_hash.clear();
|
||||
canonical_seq.clear();
|
||||
canonical_index = 0;
|
||||
add_canonical(euzero);
|
||||
eu.inverse_axes = scaled_inverse(eu.regular_axes);
|
||||
eu.canonical.reset();
|
||||
eu.canonical.add(euzero);
|
||||
|
||||
twisted = twisted0;
|
||||
eu.twisted = eu_input.twisted;
|
||||
if(dim == 3) {
|
||||
if(valid_third_turn(T0)) {
|
||||
twisted &= 16;
|
||||
if(g == gRhombic3 && (T0[2][2]&1)) twisted = 0;
|
||||
if(g == gBitrunc3 && (T0[0][0]&1)) twisted = 0;
|
||||
if(g == gBitrunc3 && (T0[1][1]&1)) twisted = 0;
|
||||
auto &T0 = eu.user_axes;
|
||||
if(valid_third_turn(eu.user_axes)) {
|
||||
eu.twisted &= 16;
|
||||
if(g == gRhombic3 && (T0[2][2]&1)) eu.twisted = 0;
|
||||
if(g == gBitrunc3 && (T0[0][0]&1)) eu.twisted = 0;
|
||||
if(g == gBitrunc3 && (T0[1][1]&1)) eu.twisted = 0;
|
||||
}
|
||||
else {
|
||||
twisted &= 7;
|
||||
if(g != gCubeTiling && ((T0[0][0]+T0[2][2]) & 1)) twisted &=~ 1;
|
||||
if(g != gCubeTiling && ((T0[1][1]+T0[2][2]) & 1)) twisted &=~ 2;
|
||||
eu.twisted &= 7;
|
||||
if(g != gCubeTiling && ((T0[0][0]+T0[2][2]) & 1)) eu.twisted &=~ 1;
|
||||
if(g != gCubeTiling && ((T0[1][1]+T0[2][2]) & 1)) eu.twisted &=~ 2;
|
||||
for(int i=0; i<3; i++) for(int j=0; j<3; j++)
|
||||
if(i != j && T0[i][j]) twisted = 0;
|
||||
if(T0[2][2] == 0) twisted = 0;
|
||||
if(T0[0][0] != T0[1][1]) twisted &= 3;
|
||||
if(i != j && T0[i][j]) eu.twisted = 0;
|
||||
if(T0[2][2] == 0) eu.twisted = 0;
|
||||
if(T0[0][0] != T0[1][1]) eu.twisted &= 3;
|
||||
}
|
||||
}
|
||||
else {
|
||||
twisted &= 8;
|
||||
twisted_vec = to_loc(T0[1]);
|
||||
ortho_vec = to_loc(T0[0]);
|
||||
if(twisted_vec == gp::loc{0,0}) twisted = 0;
|
||||
if(chiral(twisted_vec)) twisted = 0;
|
||||
if(dscalar(twisted_vec, ortho_vec))
|
||||
twisted = 0;
|
||||
eu.twisted &= 8;
|
||||
eu.twisted_vec = to_loc(eu.user_axes[1]);
|
||||
eu.ortho_vec = to_loc(eu.user_axes[0]);
|
||||
if(eu.twisted_vec == gp::loc{0,0}) eu.twisted = 0;
|
||||
if(chiral(eu.twisted_vec)) eu.twisted = 0;
|
||||
if(dscalar(eu.twisted_vec, eu.ortho_vec))
|
||||
eu.twisted = 0;
|
||||
}
|
||||
|
||||
set_flag(ginf[g].flags, qANYQ, infinite_dims < dim);
|
||||
set_flag(ginf[g].flags, qBOUNDED, infinite_dims == 0);
|
||||
set_flag(ginf[g].flags, qSMALL, infinite_dims == 0 && det <= 4096);
|
||||
set_flag(ginf[g].flags, qANYQ, eu.infinite_dims < dim);
|
||||
set_flag(ginf[g].flags, qBOUNDED, eu.infinite_dims == 0);
|
||||
set_flag(ginf[g].flags, qSMALL, eu.infinite_dims == 0 && eu.det <= 4096);
|
||||
bool nonori = false;
|
||||
if(twisted&1) nonori = !nonori;
|
||||
if(twisted&2) nonori = !nonori;
|
||||
if(twisted&4) nonori = !nonori;
|
||||
if(twisted&8) nonori = !nonori;
|
||||
if(eu.twisted&1) nonori = !nonori;
|
||||
if(eu.twisted&2) nonori = !nonori;
|
||||
if(eu.twisted&4) nonori = !nonori;
|
||||
if(eu.twisted&8) nonori = !nonori;
|
||||
set_flag(ginf[g].flags, qNONORIENTABLE, nonori);
|
||||
}
|
||||
|
||||
@ -564,8 +598,9 @@ EX namespace euclid3 {
|
||||
};
|
||||
|
||||
EX coord twist(coord x, coord& d, transmatrix& M, bool& mirr) {
|
||||
if(!twisted) return x;
|
||||
if(twisted & 16) {
|
||||
if(!eu.twisted) return x;
|
||||
auto& T0 = eu.user_axes;
|
||||
if(eu.twisted & 16) {
|
||||
int period = T0[2][2];
|
||||
transmatrix RotYZX = Zero;
|
||||
RotYZX[1][0] = 1;
|
||||
@ -601,15 +636,15 @@ EX namespace euclid3 {
|
||||
auto& coo = x;
|
||||
while(coo[2] >= T0[2][2]) {
|
||||
coo[2] -= T0[2][2];
|
||||
if(twisted & 1) coo[0] *= -1, d[0] *= -1, M = M * MirrorX;
|
||||
if(twisted & 2) coo[1] *= -1, d[1] *= -1, M = M * MirrorY;
|
||||
if(twisted & 4) swap(coo[0], coo[1]), swap01(M), swap(d[0], d[1]);
|
||||
if(eu.twisted & 1) coo[0] *= -1, d[0] *= -1, M = M * MirrorX;
|
||||
if(eu.twisted & 2) coo[1] *= -1, d[1] *= -1, M = M * MirrorY;
|
||||
if(eu.twisted & 4) swap(coo[0], coo[1]), swap01(M), swap(d[0], d[1]);
|
||||
}
|
||||
while(coo[2] < 0) {
|
||||
coo[2] += T0[2][2];
|
||||
if(twisted & 4) swap(coo[0], coo[1]), swap(d[0], d[1]), swap01(M);
|
||||
if(twisted & 1) coo[0] *= -1, d[0] *= -1, M = M * MirrorX;
|
||||
if(twisted & 2) coo[1] *= -1, d[1] *= -1, M = M * MirrorY;
|
||||
if(eu.twisted & 4) swap(coo[0], coo[1]), swap(d[0], d[1]), swap01(M);
|
||||
if(eu.twisted & 1) coo[0] *= -1, d[0] *= -1, M = M * MirrorX;
|
||||
if(eu.twisted & 2) coo[1] *= -1, d[1] *= -1, M = M * MirrorY;
|
||||
}
|
||||
for(int i: {0,1})
|
||||
if(T0[i][i]) coo[i] = gmod(coo[i], T0[i][i]);
|
||||
@ -617,14 +652,14 @@ EX namespace euclid3 {
|
||||
}
|
||||
else {
|
||||
gp::loc coo = to_loc(x);
|
||||
gp::loc ort = ort1() * twisted_vec;
|
||||
int dsc = dscalar(twisted_vec, twisted_vec);
|
||||
gp::loc ort = ort1() * eu.twisted_vec;
|
||||
int dsc = dscalar(eu.twisted_vec, eu.twisted_vec);
|
||||
gp::loc d0 (d[0], d[1]);
|
||||
hyperpoint h = eumove(to_coord(twisted_vec)) * C0;
|
||||
hyperpoint h = eumove(to_coord(eu.twisted_vec)) * C0;
|
||||
while(true) {
|
||||
int dsx = dscalar(coo, twisted_vec);
|
||||
if(dsx >= dsc) coo = coo - twisted_vec;
|
||||
else if (dsx < 0) coo = coo + twisted_vec;
|
||||
int dsx = dscalar(coo, eu.twisted_vec);
|
||||
if(dsx >= dsc) coo = coo - eu.twisted_vec;
|
||||
else if (dsx < 0) coo = coo + eu.twisted_vec;
|
||||
else break;
|
||||
M = M * spintox(h) * MirrorY * rspintox(h);
|
||||
auto s = ort * dscalar(d0, ort) * 2;
|
||||
@ -638,12 +673,12 @@ EX namespace euclid3 {
|
||||
coo = coo - s;
|
||||
mirr = !mirr;
|
||||
}
|
||||
if(ortho_vec != gp::loc{0,0}) {
|
||||
int osc = dscalar(ortho_vec, ortho_vec);
|
||||
if(eu.ortho_vec != gp::loc{0,0}) {
|
||||
int osc = dscalar(eu.ortho_vec, eu.ortho_vec);
|
||||
while(true) {
|
||||
int dsx = dscalar(coo, ortho_vec);
|
||||
if(dsx >= osc) coo = coo - ortho_vec;
|
||||
else if(dsx < 0) coo = coo + ortho_vec;
|
||||
int dsx = dscalar(coo, eu.ortho_vec);
|
||||
if(dsx >= osc) coo = coo - eu.ortho_vec;
|
||||
else if(dsx < 0) coo = coo + eu.ortho_vec;
|
||||
else break;
|
||||
}
|
||||
}
|
||||
@ -653,37 +688,31 @@ EX namespace euclid3 {
|
||||
}
|
||||
|
||||
coord canonicalize(coord x) {
|
||||
if(twisted) {
|
||||
if(eu.twisted) {
|
||||
transmatrix M = Id;
|
||||
auto dummy = euzero;
|
||||
bool dm = false;
|
||||
return twist(x, dummy, M, dm);
|
||||
}
|
||||
if(infinite_dims == WDIM) return x;
|
||||
if(infinite_dims == WDIM-1) {
|
||||
while(celldistance(x + optimal_axes[0]) <= celldistance(x)) x += optimal_axes[0];
|
||||
while(celldistance(x - optimal_axes[0]) < celldistance(x)) x -= optimal_axes[0];
|
||||
if(eu.infinite_dims == WDIM) return x;
|
||||
if(eu.infinite_dims == WDIM-1) {
|
||||
auto& o = eu.optimal_axes;
|
||||
while(celldistance(x + o[0]) <= celldistance(x)) x += o[0];
|
||||
while(celldistance(x - o[0]) < celldistance(x)) x -= o[0];
|
||||
return x;
|
||||
}
|
||||
auto cat = compute_cat(x);
|
||||
auto& st = cubemap()->shifttable;
|
||||
while(!canonical_hash.count(cat)) {
|
||||
if(canonical_index == isize(canonical_seq)) throw hr_exception();
|
||||
auto v = canonical_seq[canonical_index++];
|
||||
for(auto s: st) add_canonical(v + s);
|
||||
}
|
||||
return canonical_seq[canonical_hash[cat]];
|
||||
return eu.canonical.get(x);
|
||||
}
|
||||
|
||||
EX void prepare_torus3() {
|
||||
T_edit = T0;
|
||||
twisted_edit = twisted0;
|
||||
eu_edit = eu_input;
|
||||
}
|
||||
|
||||
EX void show_fundamental() {
|
||||
initquickqueue();
|
||||
transmatrix M = ggmatrix(cwt.at);
|
||||
hyperpoint h0 = M*C0;
|
||||
auto& T_edit = eu_edit.user_axes;
|
||||
hyperpoint ha = M*(eumove(T_edit[0]) * C0 - C0) / 2;
|
||||
hyperpoint hb = M*(eumove(T_edit[1]) * C0 - C0) / 2;
|
||||
if(WDIM == 3) {
|
||||
@ -704,12 +733,8 @@ EX namespace euclid3 {
|
||||
quickqueue();
|
||||
}
|
||||
|
||||
#if HDR
|
||||
typedef pair<euclid3::intmatrix, int> torus_config;
|
||||
#endif
|
||||
|
||||
euclid3::intmatrix on_periods(gp::loc a, gp::loc b) {
|
||||
euclid3::intmatrix res;
|
||||
intmatrix on_periods(gp::loc a, gp::loc b) {
|
||||
intmatrix res;
|
||||
for(int i=0; i<3; i++) for(int j=0; j<3; j++) res[i][j] = 0;
|
||||
res[0][0] = a.first;
|
||||
res[0][1] = a.second;
|
||||
@ -720,24 +745,23 @@ EX namespace euclid3 {
|
||||
}
|
||||
|
||||
torus_config single_row_torus(int qty, int dy) {
|
||||
return { on_periods(gp::loc{dy, -1}, gp::loc{qty, 0}), false };
|
||||
return { on_periods(gp::loc{dy, -1}, gp::loc{qty, 0}), 0 };
|
||||
}
|
||||
|
||||
torus_config regular_torus(gp::loc p) {
|
||||
return { on_periods(p, gp::loc(0,1) * p), false };
|
||||
return { on_periods(p, gp::loc(0,1) * p), 0 };
|
||||
}
|
||||
|
||||
EX torus_config rectangular_torus(int x, int y, bool klein) {
|
||||
if(S3 == 3) y /= 2;
|
||||
return { on_periods(euclid3::ort1() * gp::loc(y,0), gp::loc(x,0)), klein?8:0 };
|
||||
return { on_periods(ort1() * gp::loc(y,0), gp::loc(x,0)), klein?8:0 };
|
||||
}
|
||||
|
||||
void torus_config_option(string name, char key, torus_config tc) {
|
||||
dialog::addBoolItem(name, make_pair(T_edit, twisted_edit) == tc && PURE, key);
|
||||
dialog::addBoolItem(name, eu_edit.user_axes == tc.user_axes && eu_edit.twisted == tc.twisted && PURE, key);
|
||||
dialog::add_action([tc] {
|
||||
stop_game();
|
||||
tie(euclid3::T0, euclid3::twisted0) = tc;
|
||||
tie(T_edit, twisted_edit) = tc;
|
||||
eu_input = eu_edit = tc;
|
||||
set_variation(eVariation::pure);
|
||||
start_game();
|
||||
});
|
||||
@ -745,6 +769,8 @@ EX namespace euclid3 {
|
||||
|
||||
EX void show_torus3() {
|
||||
int dim = WDIM;
|
||||
auto& T_edit = eu_edit.user_axes;
|
||||
auto& twisted_edit = eu_edit.twisted;
|
||||
cmode = sm::SIDE | sm::MAYDARK | sm::TORUSCONFIG;
|
||||
gamescreen(1);
|
||||
dialog::init(XLAT("Euclidean quotient spaces"));
|
||||
@ -806,8 +832,8 @@ EX namespace euclid3 {
|
||||
dialog::add_action([] { twisted_edit ^= 4; });
|
||||
}
|
||||
dialog::addBreak(50);
|
||||
torus_config_option(XLAT("third-turn space"), 'A', {make_third_turn(2,0,2), 16});
|
||||
torus_config_option(XLAT("quarter-turn space"), 'B', {make_quarter_turn(2, 0, 2), 5});
|
||||
torus_config_option(XLAT("third-turn space"), 'A', make_third_turn(2,0,2));
|
||||
torus_config_option(XLAT("quarter-turn space"), 'B', make_quarter_turn(2, 0, 2));
|
||||
}
|
||||
else {
|
||||
if(T_edit[1][0] == 0 && T_edit[1][1] == 0)
|
||||
@ -855,8 +881,7 @@ EX namespace euclid3 {
|
||||
dialog::add_action([g] {
|
||||
stop_game();
|
||||
set_geometry(g);
|
||||
T0 = T_edit;
|
||||
twisted0 = twisted_edit;
|
||||
eu_input = eu_edit;
|
||||
start_game();
|
||||
});
|
||||
if(dim == 2) break;
|
||||
@ -873,7 +898,7 @@ EX namespace euclid3 {
|
||||
char ch = 'a' + i * 3 + j;
|
||||
if(displayfr(dialog::dcenter + dialog::dfspace * 4 * (j-(dim-1.)/2), v.position, 2, dialog::dfsize, its(T_edit[j][i]), 0xFFFFFF, 8))
|
||||
getcstat = ch;
|
||||
dialog::add_key_action(ch, [=] {
|
||||
dialog::add_key_action(ch, [&T_edit, i, j] {
|
||||
dialog::editNumber(T_edit[j][i], -10, +10, 1, 0, "", XLAT(
|
||||
"This matrix lets you play on the quotient spaces of three-dimensional. "
|
||||
"Euclidean space. Every column specifies a translation vector which "
|
||||
@ -903,6 +928,7 @@ EX namespace euclid3 {
|
||||
else if(argis("-t3")) {
|
||||
PHASEFROM(2);
|
||||
stop_game();
|
||||
auto& T0 = eu_input.user_axes;
|
||||
for(int i=0; i<3; i++)
|
||||
for(int j=0; j<3; j++) {
|
||||
shift(); T0[i][j] = argi();
|
||||
@ -912,11 +938,12 @@ EX namespace euclid3 {
|
||||
else if(argis("-t2")) {
|
||||
PHASEFROM(2);
|
||||
stop_game();
|
||||
auto& T0 = eu_input.user_axes;
|
||||
for(int i=0; i<2; i++)
|
||||
for(int j=0; j<2; j++) {
|
||||
shift(); T0[i][j] = argi();
|
||||
}
|
||||
shift(); twisted0 = argi();
|
||||
shift(); eu_input.twisted = argi();
|
||||
build_torus3();
|
||||
}
|
||||
else if(argis("-twistthird")) {
|
||||
@ -925,20 +952,20 @@ EX namespace euclid3 {
|
||||
shift(); int a = argi();
|
||||
shift(); int b = argi();
|
||||
shift(); int c = argi();
|
||||
T0 = make_third_turn(a, b, c);
|
||||
twisted0 = 16;
|
||||
eu_input = make_third_turn(a, b, c);
|
||||
build_torus3();
|
||||
}
|
||||
else if(argis("-twist3")) {
|
||||
PHASEFROM(2);
|
||||
stop_game();
|
||||
auto& T0 = eu_input.user_axes;
|
||||
for(int i=0; i<3; i++)
|
||||
for(int j=0; j<3; j++) T0[i][j] = 0;
|
||||
|
||||
for(int i=0; i<3; i++) {
|
||||
shift(); T0[i][i] = argi();
|
||||
}
|
||||
shift(); twisted0 = argi();
|
||||
shift(); eu_input.twisted = argi();
|
||||
build_torus3();
|
||||
}
|
||||
else if(argis("-twisttest")) {
|
||||
@ -967,7 +994,6 @@ EX namespace euclid3 {
|
||||
|
||||
auto euhook = addHook(hooks_args, 100, euArgs);
|
||||
#endif
|
||||
EX }
|
||||
|
||||
EX int dscalar(gp::loc e1, gp::loc e2) {
|
||||
return 2 * (e1.first * e2.first + e1.second*e2.second) + (S3 == 3 ? e1.first*e2.second + e2.first * e1.second : 0);
|
||||
@ -979,8 +1005,8 @@ EX int dcross(gp::loc e1, gp::loc e2) {
|
||||
return e1.first * e2.second - e1.second*e2.first;
|
||||
}
|
||||
|
||||
EX gp::loc euc2_coordinates(cell *c) {
|
||||
auto ans = euclid3::eucmap()->ispacemap[c->master];
|
||||
EX gp::loc full_coords2(cell *c) {
|
||||
auto ans = eucmap()->ispacemap[c->master];
|
||||
if(BITRUNCATED)
|
||||
return to_loc(ans) * gp::loc(1,1) + (c == c->master->c7 ? gp::loc(0,0) : gp::eudir((c->c.spin(0)+4)%6));
|
||||
if(GOLDBERG) {
|
||||
@ -993,7 +1019,7 @@ EX gp::loc euc2_coordinates(cell *c) {
|
||||
}
|
||||
|
||||
/** this is slow, but we use it only for small p's */
|
||||
EX cell* at_euc2_coordinates(gp::loc p) {
|
||||
EX cell* at(gp::loc p) {
|
||||
cellwalker cw(currentmap->gamestart());
|
||||
while(p.first--) cw += revstep;
|
||||
cw ++;
|
||||
@ -1001,15 +1027,15 @@ EX cell* at_euc2_coordinates(gp::loc p) {
|
||||
return cw.at;
|
||||
}
|
||||
|
||||
EX euclid3::coord to_coord(gp::loc p) { return euclid3::coord(p.first, p.second, 0); }
|
||||
EX coord to_coord(gp::loc p) { return coord(p.first, p.second, 0); }
|
||||
|
||||
EX gp::loc sdxy() { return to_loc(euclid3::T[1]) * gp::univ_param(); }
|
||||
EX gp::loc sdxy() { return to_loc(eu.user_axes[1]) * gp::univ_param(); }
|
||||
|
||||
EX pair<bool, string> coord_display(const transmatrix& V, cell *c) {
|
||||
if(c != c->master->c7) return {false, ""};
|
||||
hyperpoint hx = eumove(euclid3::main_axes[0]) * C0;
|
||||
hyperpoint hy = eumove(euclid3::main_axes[1]) * C0;
|
||||
hyperpoint hz = WDIM == 2 ? C0 : eumove(euclid3::main_axes[2]) * C0;
|
||||
hyperpoint hx = eumove(main_axes[0]) * C0;
|
||||
hyperpoint hy = eumove(main_axes[1]) * C0;
|
||||
hyperpoint hz = WDIM == 2 ? C0 : eumove(main_axes[2]) * C0;
|
||||
hyperpoint h = kz(inverse(build_matrix(hx, hy, hz, C03)) * inverse(ggmatrix(cwt.at->master->c7)) * V * C0);
|
||||
|
||||
if(WDIM == 3)
|
||||
@ -1018,11 +1044,11 @@ EX pair<bool, string> coord_display(const transmatrix& V, cell *c) {
|
||||
return {true, fts(h[0]) + "," + fts(h[1]) };
|
||||
}
|
||||
|
||||
EX gp::loc to_loc(const euclid3::coord& v) { return gp::loc(v[0], v[1]); }
|
||||
EX gp::loc to_loc(const coord& v) { return gp::loc(v[0], v[1]); }
|
||||
|
||||
EX map<gp::loc, cdata>& get_cdata() { return euclid3::eucmap()->eucdata; }
|
||||
EX map<gp::loc, cdata>& get_cdata() { return eucmap()->eucdata; }
|
||||
|
||||
EX transmatrix eumove(euclid3::coord co) {
|
||||
EX transmatrix eumove(coord co) {
|
||||
const double q3 = sqrt(double(3));
|
||||
if(WDIM == 3) {
|
||||
return eupush3(co[0], co[1], co[2]);
|
||||
@ -1039,6 +1065,8 @@ EX transmatrix eumove(euclid3::coord co) {
|
||||
return Mat;
|
||||
}
|
||||
|
||||
EX transmatrix eumove(gp::loc co) { return eumove(to_coord(co)); }
|
||||
|
||||
EX bool chiral(gp::loc g) {
|
||||
int x = g.first;
|
||||
int y = g.second;
|
||||
@ -1052,9 +1080,9 @@ EX bool chiral(gp::loc g) {
|
||||
}
|
||||
|
||||
EX void twist_once(gp::loc coo) {
|
||||
coo = coo - euclid3::twisted_vec * gp::univ_param();
|
||||
if(euclid3::twisted&8) {
|
||||
gp::loc ort = euclid3::ort1() * euclid3::twisted_vec * gp::univ_param();
|
||||
coo = coo - eu.twisted_vec * gp::univ_param();
|
||||
if(eu.twisted&8) {
|
||||
gp::loc ort = ort1() * eu.twisted_vec * gp::univ_param();
|
||||
auto s = ort * dscalar(coo, ort) * 2;
|
||||
auto v = dscalar(ort, ort);
|
||||
s.first /= v;
|
||||
@ -1063,7 +1091,7 @@ EX void twist_once(gp::loc coo) {
|
||||
}
|
||||
}
|
||||
|
||||
EX int eudist(int sx, int sy, bool reduce IS(true)) {
|
||||
EX int dist(int sx, int sy, bool reduce IS(true)) {
|
||||
int z0 = abs(sx);
|
||||
int z1 = abs(sy);
|
||||
if(a4 && BITRUNCATED)
|
||||
@ -1073,28 +1101,36 @@ EX int eudist(int sx, int sy, bool reduce IS(true)) {
|
||||
return max(max(z0,z1), z2);
|
||||
}
|
||||
|
||||
EX int eudist(gp::loc a, gp::loc b) {
|
||||
return eudist(a.first-b.first, a.second-b.second, (a.first ^ a.second)&1);
|
||||
EX int dist(gp::loc a, gp::loc b) {
|
||||
return dist(a.first-b.first, a.second-b.second, (a.first ^ a.second)&1);
|
||||
}
|
||||
|
||||
EX int cyldist(gp::loc a, gp::loc b) {
|
||||
a = to_loc(euclid3::canonicalize(to_coord(a)));
|
||||
b = to_loc(euclid3::canonicalize(to_coord(b)));
|
||||
a = to_loc(canonicalize(to_coord(a)));
|
||||
b = to_loc(canonicalize(to_coord(b)));
|
||||
|
||||
if(!quotient) return eudist(a, b);
|
||||
if(!quotient) return dist(a, b);
|
||||
|
||||
int best = 0;
|
||||
for(int sa=0; sa<16; sa++) {
|
||||
auto _a = a, _b = b;
|
||||
if(sa&1) twist_once(_a);
|
||||
if(sa&2) twist_once(_b);
|
||||
if(sa&4) _a = _a + euclid3::ortho_vec * gp::univ_param();
|
||||
if(sa&8) _b = _b + euclid3::ortho_vec * gp::univ_param();
|
||||
int val = eudist(_a, _b);
|
||||
if(sa&4) _a = _a + eu.ortho_vec * gp::univ_param();
|
||||
if(sa&8) _b = _b + eu.ortho_vec * gp::univ_param();
|
||||
int val = dist(_a, _b);
|
||||
if(sa == 0 || val < best) best = val;
|
||||
}
|
||||
|
||||
return best;
|
||||
}
|
||||
|
||||
EX }
|
||||
|
||||
#if HDR
|
||||
namespace euclid3 { using namespace euc; }
|
||||
#endif
|
||||
|
||||
EX gp::loc euc2_coordinates(cell *c) { return euc::full_coords2(c); }
|
||||
|
||||
}
|
||||
|
||||
@ -585,7 +585,7 @@ EX void showEuclideanMenu() {
|
||||
}
|
||||
|
||||
if(euclid && bounded) {
|
||||
worldsize = euclid3::det;
|
||||
worldsize = euclid3::eu.det;
|
||||
if(BITRUNCATED) worldsize *= (a4 ? 2 : 3);
|
||||
if(GOLDBERG) worldsize *= cgi.gpdata->area;
|
||||
if(IRREGULAR) worldsize *= isize(irr::cells) / isize(irr::cells_of_heptagon);
|
||||
|
||||
@ -69,7 +69,7 @@ EX namespace gp {
|
||||
}
|
||||
|
||||
EX int length(loc p) {
|
||||
return eudist(p.first, p.second);
|
||||
return euc::dist(p.first, p.second);
|
||||
}
|
||||
|
||||
#if CAP_GP
|
||||
|
||||
@ -121,8 +121,7 @@ string status[5];
|
||||
|
||||
EX hrmap *base;
|
||||
|
||||
EX euclid3::intmatrix base_periods;
|
||||
EX int base_twisted;
|
||||
EX euc::torus_config_full base_config;
|
||||
|
||||
bool gridmaking;
|
||||
|
||||
@ -1031,8 +1030,7 @@ EX void visual_creator() {
|
||||
start_game();
|
||||
if(base) delete base;
|
||||
base = currentmap;
|
||||
base_periods = euclid3::T0;
|
||||
base_twisted = euclid3::twisted0;
|
||||
base_config = euc::eu;
|
||||
drawthemap();
|
||||
cellcount = int(isize(base->allcells()) * density + .5);
|
||||
pushScreen(show_gridmaker);
|
||||
|
||||
@ -1286,10 +1286,10 @@ EX void giantLandSwitch(cell *c, int d, cell *from) {
|
||||
if(fargen) {
|
||||
|
||||
if(euclid && smallbounded && WDIM == 2) {
|
||||
auto s = sdxy();
|
||||
auto s = euc::sdxy();
|
||||
gp::loc st {s.first/3, s.second/3};
|
||||
if(c == at_euc2_coordinates(st)) c->wall = waCharged;
|
||||
if(c == at_euc2_coordinates(s-st)) c->wall = waGrounded;
|
||||
if(c == euc::at(st)) c->wall = waCharged;
|
||||
if(c == euc::at(s-st)) c->wall = waGrounded;
|
||||
}
|
||||
else if(euclid && WDIM == 2) {
|
||||
auto co = euc2_coordinates(c);
|
||||
|
||||
@ -1126,10 +1126,10 @@ EX land_validity_t& land_validity(eLand l) {
|
||||
if(sol && l == laCamelot)
|
||||
return not_implemented;
|
||||
|
||||
if(euclid && quotient && !bounded && l == laCrossroads && sdxy().second == -2 * sdxy().first)
|
||||
if(euclid && quotient && !bounded && l == laCrossroads && euc::sdxy().second == -2 * euc::sdxy().first)
|
||||
return full_game;
|
||||
|
||||
if(euclid && quotient && !bounded && l == laCrossroads4 && sdxy().second == 0)
|
||||
if(euclid && quotient && !bounded && l == laCrossroads4 && euc::sdxy().second == 0)
|
||||
return full_game;
|
||||
|
||||
// highlight Zebra-based lands on Zebra Quotient!
|
||||
|
||||
@ -168,8 +168,8 @@ namespace mapstream {
|
||||
if(binarytiling && VERNUM_HEX >= 0xA80C)
|
||||
f.write(vid.binary_width);
|
||||
if(euclid && !penrose && !archimedean) {
|
||||
f.write(euclid3::T0);
|
||||
f.write(euclid3::twisted);
|
||||
f.write(euc::eu_input.user_axes);
|
||||
f.write(euc::eu_input.twisted);
|
||||
}
|
||||
}
|
||||
|
||||
@ -254,8 +254,8 @@ namespace mapstream {
|
||||
if(binarytiling && VERNUM_HEX >= 0xA80C)
|
||||
f.read(vid.binary_width);
|
||||
if(euclid && !penrose && !archimedean && VERNUM_HEX >= 0xA80D) {
|
||||
f.read(euclid3::T0);
|
||||
f.read(euclid3::twisted);
|
||||
f.read(euc::eu_input.user_axes);
|
||||
f.read(euc::eu_input.twisted);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@ -192,7 +192,7 @@ EX namespace models {
|
||||
if(euclid) {
|
||||
euclidean_spin = pispin * inverse(cview() * master_relative(centerover, true));
|
||||
euclidean_spin = gpushxto0(euclidean_spin * C0) * euclidean_spin;
|
||||
hyperpoint h = inverse(euclidean_spin) * (C0 + (eumove(to_coord(gp::loc{1,0}))*C0 - C0) * spiral_x + (eumove(to_coord(gp::loc{0,1}))*C0 - C0) * spiral_y);
|
||||
hyperpoint h = inverse(euclidean_spin) * (C0 + (euc::eumove(gp::loc{1,0})*C0 - C0) * spiral_x + (euc::eumove(gp::loc{0,1})*C0 - C0) * spiral_y);
|
||||
spiral_multiplier = cld(0, 2 * M_PI) / cld(h[0], h[1]);
|
||||
}
|
||||
|
||||
@ -267,13 +267,13 @@ EX namespace models {
|
||||
for(int y=0; y<=200; y++)
|
||||
for(int x=-200; x<=200; x++) {
|
||||
if(y == 0 && x <= 0) continue;
|
||||
auto zero = euclid3::canonicalize(to_coord(gp::loc{x, y}));
|
||||
auto zero = euc::canonicalize(euc::to_coord(gp::loc{x, y}));
|
||||
if(zero == euclid3::euzero)
|
||||
torus_zeros.emplace_back(x, y);
|
||||
}
|
||||
sort(torus_zeros.begin(), torus_zeros.end(), [] (const gp::loc p1, const gp::loc p2) {
|
||||
ld d1 = hdist0(tC0(eumove(to_coord(p1))));
|
||||
ld d2 = hdist0(tC0(eumove(to_coord(p2))));
|
||||
ld d1 = hdist0(tC0(euc::eumove(p1)));
|
||||
ld d2 = hdist0(tC0(euc::eumove(p2)));
|
||||
if(d1 < d2 - 1e-6) return true;
|
||||
if(d1 > d2 + 1e-6) return false;
|
||||
return p1 < p2;
|
||||
|
||||
12
pattern2.cpp
12
pattern2.cpp
@ -2443,12 +2443,12 @@ EX namespace linepatterns {
|
||||
case patZebraTriangles:
|
||||
if(euclid6) {
|
||||
if(c != c->master->c7 || patterns::sevenval(c)) break;
|
||||
gridline(V, C0, tC0(eumove(to_coord({-1, +3}))), col, 3 + vid.linequality);
|
||||
gridline(V, C0, tC0(eumove(to_coord({-3, +2}))), col, 3 + vid.linequality);
|
||||
gridline(V, C0, tC0(eumove(to_coord({-2, -1}))), col, 3 + vid.linequality);
|
||||
gridline(V, C0, tC0(eumove(to_coord({+1, -3}))), col, 3 + vid.linequality);
|
||||
gridline(V, C0, tC0(eumove(to_coord({+3, -2}))), col, 3 + vid.linequality);
|
||||
gridline(V, C0, tC0(eumove(to_coord({+2, +1}))), col, 3 + vid.linequality);
|
||||
gridline(V, C0, tC0(euc::eumove(gp::loc(-1, +3))), col, 3 + vid.linequality);
|
||||
gridline(V, C0, tC0(euc::eumove(gp::loc(-3, +2))), col, 3 + vid.linequality);
|
||||
gridline(V, C0, tC0(euc::eumove(gp::loc(-2, -1))), col, 3 + vid.linequality);
|
||||
gridline(V, C0, tC0(euc::eumove(gp::loc(+1, -3))), col, 3 + vid.linequality);
|
||||
gridline(V, C0, tC0(euc::eumove(gp::loc(+3, -2))), col, 3 + vid.linequality);
|
||||
gridline(V, C0, tC0(euc::eumove(gp::loc(+2, +1))), col, 3 + vid.linequality);
|
||||
break;
|
||||
}
|
||||
if(zebra40(c) / 4 == 10) {
|
||||
|
||||
@ -1095,7 +1095,7 @@ void race_projection() {
|
||||
add_thurston_race(XLAT("stretched Solv"), [] { set_geometry(gSolN); solnihv::solrange_xy = 10; solnihv::solrange_z = 3; vid.texture_step = 4; });
|
||||
add_thurston_race(XLAT("periodic Solv"), [] { stop_game(); solnihv::solrange_xy = 5; solnihv::solrange_z = 2; asonov::period_xy = 8; asonov::period_z = 0; asonov::set_flags(); set_geometry(gArnoldCat); });
|
||||
add_thurston_race(XLAT("hyperbolic crystal"), [] { set_geometry(gCrystal344); vid.texture_step = 4; });
|
||||
add_thurston_race(XLAT("torus x E"), [] { stop_game(); euclid3::set_torus3(4, 4, 0); set_geometry(gCubeTiling); });
|
||||
add_thurston_race(XLAT("torus x E"), [] { stop_game(); euc::eu_input = euc::torus3(4, 4, 0); set_geometry(gCubeTiling); });
|
||||
add_thurston_race(XLAT("hyperbolic regular"), [] { set_geometry(gSpace534); });
|
||||
add_thurston_race(XLAT("S2xE regular"), [] { set_geometry(gSphere); set_variation(eVariation::pure); set_geometry(gProduct); });
|
||||
add_thurston_race(XLAT("H2xE regular"), [] { set_geometry(gNormal); set_variation(eVariation::pure); set_geometry(gProduct); });
|
||||
|
||||
12
rug.cpp
12
rug.cpp
@ -253,7 +253,7 @@ EX rugpoint *addRugpoint(hyperpoint h, double dist) {
|
||||
m->valid = false;
|
||||
|
||||
if(euclid && quotient && !bounded) {
|
||||
hyperpoint h1 = inverse(models::euclidean_spin) * eumove(euclid3::T0[1]) * C0;
|
||||
hyperpoint h1 = inverse(models::euclidean_spin) * eumove(euc::eu.user_axes[1]) * C0;
|
||||
h1 /= sqhypot_d(2, h1);
|
||||
if(nonorientable) h1 /= 2;
|
||||
m->valid = good_shape = true;
|
||||
@ -432,11 +432,11 @@ EX void buildTorusRug() {
|
||||
calcparam_rug();
|
||||
models::configure();
|
||||
|
||||
auto p1 = to_loc(euclid3::T0[0]);
|
||||
auto p2 = to_loc(euclid3::T0[1]);
|
||||
auto p1 = to_loc(euc::eu.user_axes[0]);
|
||||
auto p2 = to_loc(euc::eu.user_axes[1]);
|
||||
|
||||
hyperpoint xh = eumove(to_coord(p1))*C0-C0;
|
||||
hyperpoint yh = eumove(to_coord(p2))*C0-C0;
|
||||
hyperpoint xh = euc::eumove(p1)*C0-C0;
|
||||
hyperpoint yh = euc::eumove(p2)*C0-C0;
|
||||
if(nonorientable) yh *= 2;
|
||||
|
||||
bool flipped = sqhypot_d(2, xh) < sqhypot_d(2, yh);
|
||||
@ -597,7 +597,7 @@ EX void buildRug() {
|
||||
for(int j=0; j<c->type; j++) addTriangle(v, p[j], p[(j+1) % c->type]);
|
||||
|
||||
if((euclid && quotient) && nonorientable) {
|
||||
transmatrix T = ggmatrix(c) * eumove(euclid3::T0[1]);
|
||||
transmatrix T = ggmatrix(c) * eumove(euc::eu.user_axes[1]);
|
||||
rugpoint *Tv = addRugpoint(T * C0, 0);
|
||||
for(int j=0; j<c->type; j++) p[j] = findOrAddRugpoint(T * get_corner_position(c, j), v->dist);
|
||||
for(int j=0; j<c->type; j++) addTriangle(Tv, p[j], p[(j+1) % c->type]);
|
||||
|
||||
@ -242,7 +242,7 @@ EX void initgame() {
|
||||
if(gamegen_failure) return;
|
||||
|
||||
if(euclid && specialland == laPrincessQuest) {
|
||||
cell *c = at_euc2_coordinates({EPX, EPY});
|
||||
cell *c = euc::at(princess::coords());
|
||||
princess::generating = true;
|
||||
c->land = laPalace;
|
||||
setdist(c, 7 - getDistLimit() - genrange_bonus, NULL);
|
||||
|
||||
Loading…
Reference in New Issue
Block a user