bitruncated irregular tilings
This commit is contained in:
parent
188c591453
commit
253c2d8b9b
|
@ -493,19 +493,21 @@ namespace irr {
|
||||||
void generate_floorshapes() {
|
void generate_floorshapes() {
|
||||||
|
|
||||||
if(irr::cells.empty()) return;
|
if(irr::cells.empty()) return;
|
||||||
|
|
||||||
|
int cc = isize(irr::cells);
|
||||||
|
|
||||||
for(auto pfsh: all_escher_floorshapes) {
|
for(auto pfsh: all_escher_floorshapes) {
|
||||||
auto& fsh = *pfsh;
|
auto& fsh = *pfsh;
|
||||||
generate_matrices_scale(1, fsh.noftype);
|
generate_matrices_scale(1, fsh.noftype);
|
||||||
auto& m = hept_matrices;
|
|
||||||
|
|
||||||
/* if(siid == 0)
|
/* if(siid == 0)
|
||||||
for(auto& ma: m.v) ma.first = ma.first * pispin; */
|
for(auto& ma: m.v) ma.first = ma.first * pispin; */
|
||||||
|
|
||||||
fsh.b.resize(irr::cellcount);
|
fsh.b.resize(cc);
|
||||||
|
|
||||||
for(int id=0; id<irr::cellcount; id++) {
|
for(int id=0; id<cc; id++) {
|
||||||
auto& vs = irr::cells[id];
|
auto& vs = irr::cells[id];
|
||||||
|
auto& m = (geosupport_graveyard() == 2 && !vs.is_pseudohept) ? hex_matrices : hept_matrices;
|
||||||
|
|
||||||
int cor = isize(vs.vertices);
|
int cor = isize(vs.vertices);
|
||||||
m.n.sym = cor;
|
m.n.sym = cor;
|
||||||
|
@ -519,9 +521,14 @@ namespace irr {
|
||||||
hyperpoint nlcorner = vs.vertices[(d+c+1) % cor];
|
hyperpoint nlcorner = vs.vertices[(d+c+1) % cor];
|
||||||
hyperpoint nrcorner = vs.vertices[(d+c+2) % cor];
|
hyperpoint nrcorner = vs.vertices[(d+c+2) % cor];
|
||||||
|
|
||||||
hyperpoint nfar = vs.jpoints[vs.neid[(d+c+1) % cor]];
|
int neid = vs.neid[(d+c+1) % cor];
|
||||||
hyperpoint nlfar = nfar;
|
int spin = vs.spin[(d+c+1) % cor];
|
||||||
hyperpoint nrfar = nfar;
|
auto &vs2 = irr::cells[neid];
|
||||||
|
int cor2 = isize(vs2.vertices);
|
||||||
|
hyperpoint nfar = vs.jpoints[neid];
|
||||||
|
transmatrix rel = vs.rpusher * vs.relmatrices[vs2.owner] * vs2.pusher;
|
||||||
|
hyperpoint nlfar = rel * vs2.vertices[(spin+2)%cor2];
|
||||||
|
hyperpoint nrfar = rel * vs2.vertices[(spin+cor2-1)%cor2];
|
||||||
m.v[i].second[c] = build_matrix(center, nlcorner, nrcorner);
|
m.v[i].second[c] = build_matrix(center, nlcorner, nrcorner);
|
||||||
m.v[i+1].second[c] = build_matrix(nfar, nlcorner, nrcorner);
|
m.v[i+1].second[c] = build_matrix(nfar, nlcorner, nrcorner);
|
||||||
m.v[i+2].second[c] = build_matrix(nfar, nlcorner, nlfar);
|
m.v[i+2].second[c] = build_matrix(nfar, nlcorner, nlfar);
|
||||||
|
@ -534,7 +541,7 @@ namespace irr {
|
||||||
usedml[id] = m;
|
usedml[id] = m;
|
||||||
|
|
||||||
m.n.sym = cor;
|
m.n.sym = cor;
|
||||||
bshape2(fsh.b[id], fsh.prio, fsh.shapeid2 ? fsh.shapeid2 : fsh.shapeid1, m);
|
bshape2(fsh.b[id], fsh.prio, (fsh.shapeid2 && geosupport_graveyard() < 2) ? fsh.shapeid2 : !vs.is_pseudohept?fsh.shapeid0:fsh.shapeid1, m);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -543,16 +550,59 @@ namespace irr {
|
||||||
|
|
||||||
ld sca = fsh.rad0 / shFullFloor.rad0;
|
ld sca = fsh.rad0 / shFullFloor.rad0;
|
||||||
|
|
||||||
fsh.b.resize(irr::cellcount);
|
fsh.b.resize(cc);
|
||||||
fsh.shadow.resize(irr::cellcount);
|
fsh.shadow.resize(cc);
|
||||||
|
|
||||||
for(int i=0; i<irr::cellcount; i++) {
|
for(int i=0; i<cc; i++) {
|
||||||
auto& vs = irr::cells[i];
|
auto& vs = irr::cells[i];
|
||||||
vector<hyperpoint> cornerlist;
|
vector<hyperpoint> cornerlist;
|
||||||
|
|
||||||
int cor = isize(vs.vertices);
|
int cor = isize(vs.vertices);
|
||||||
for(int j=0; j<cor; j++)
|
|
||||||
cornerlist.push_back(rspintox(vs.vertices[j]) * xpush(hdist0(vs.vertices[j]) * sca) * C0);
|
if(&fsh == &shBigTriangle) {
|
||||||
|
if(vs.is_pseudohept) {
|
||||||
|
for(int i=0; i<cor; i++) cornerlist.push_back(hpxy(0,0));
|
||||||
|
}
|
||||||
|
else for(int i=0; i<cor; i++) {
|
||||||
|
int ri = i;
|
||||||
|
if(!irr::cells[vs.neid[i]].is_pseudohept) ri--;
|
||||||
|
if(ri<0) ri += cor;
|
||||||
|
hyperpoint nc = vs.jpoints[vs.neid[ri]];
|
||||||
|
cornerlist.push_back(mid_at(C0, nc, .94));
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
else if(&fsh == &shBigHepta) {
|
||||||
|
if(vs.is_pseudohept) {
|
||||||
|
for(int i=0; i<cor; i++) {
|
||||||
|
cornerlist.push_back(mid_at(hpxy(0,0), vs.jpoints[vs.neid[i]], .94));
|
||||||
|
}
|
||||||
|
}
|
||||||
|
else {
|
||||||
|
for(int i=0; i<cor; i++) cornerlist.push_back(hpxy(0,0));
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
else if(&fsh == &shTriheptaFloor) {
|
||||||
|
if(vs.is_pseudohept) {
|
||||||
|
for(int i=0; i<cor; i++) {
|
||||||
|
hyperpoint next = vs.jpoints[vs.neid[i]];
|
||||||
|
hyperpoint last = vs.jpoints[vs.neid[(i+cor-1)%cor]];
|
||||||
|
cornerlist.push_back(mid_at(C0, mid(next, last), .98));
|
||||||
|
}
|
||||||
|
}
|
||||||
|
else {
|
||||||
|
for(int i=0; i<cor; i++) {
|
||||||
|
int ri = i;
|
||||||
|
if(irr::cells[vs.neid[i]].is_pseudohept) ri--;
|
||||||
|
if(ri<0) ri += cor;
|
||||||
|
cornerlist.push_back(mid_at(C0, mid(vs.vertices[ri], vs.vertices[(ri+1)%cor]), .97));
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
else for(int j=0; j<cor; j++)
|
||||||
|
cornerlist.push_back(mid_at_actual(vs.vertices[j], sca));
|
||||||
|
|
||||||
bshape(fsh.b[i], fsh.prio);
|
bshape(fsh.b[i], fsh.prio);
|
||||||
for(int j=0; j<=cor; j++) hpcpush(cornerlist[j%cor]);
|
for(int j=0; j<=cor; j++) hpcpush(cornerlist[j%cor]);
|
||||||
|
@ -569,7 +619,7 @@ namespace irr {
|
||||||
|
|
||||||
for(int k=0; k<SIDEPARS; k++)
|
for(int k=0; k<SIDEPARS; k++)
|
||||||
for(int c=0; c<cor; c++) {
|
for(int c=0; c<cor; c++) {
|
||||||
fsh.gpside[k][c].resize(irr::cellcount);
|
fsh.gpside[k][c].resize(cc);
|
||||||
bshape(fsh.gpside[k][c][i], fsh.prio);
|
bshape(fsh.gpside[k][c][i], fsh.prio);
|
||||||
hpcpush(iddspin(&fc, c) * cornerlist[c]);
|
hpcpush(iddspin(&fc, c) * cornerlist[c]);
|
||||||
hpcpush(iddspin(&fc, c) * cornerlist[(c+1)%cor]);
|
hpcpush(iddspin(&fc, c) * cornerlist[(c+1)%cor]);
|
||||||
|
|
|
@ -703,7 +703,7 @@ namespace hr { namespace gp {
|
||||||
|
|
||||||
bool show_nonthree = !(texture_remap && (S7&1));
|
bool show_nonthree = !(texture_remap && (S7&1));
|
||||||
bool show_bitrunc = !(texture_remap && !(S7&1));
|
bool show_bitrunc = !(texture_remap && !(S7&1));
|
||||||
bool show_irregular = !texture_remap;
|
bool show_irregular = true;
|
||||||
if(texture_remap) {
|
if(texture_remap) {
|
||||||
if(patterns::cgroup == cpSingle)
|
if(patterns::cgroup == cpSingle)
|
||||||
show_nonthree = true, show_bitrunc = false, show_irregular = true;
|
show_nonthree = true, show_bitrunc = false, show_irregular = true;
|
||||||
|
@ -749,7 +749,10 @@ namespace hr { namespace gp {
|
||||||
|
|
||||||
if(show_irregular && irr::supports(geometry)) {
|
if(show_irregular && irr::supports(geometry)) {
|
||||||
dialog::addBoolItem(XLAT("irregular"), irr::on, 'i');
|
dialog::addBoolItem(XLAT("irregular"), irr::on, 'i');
|
||||||
dialog::add_action([] () { if(!irr::on) irr::visual_creator(); });
|
dialog::add_action([=] () {
|
||||||
|
if(texture_remap && !show_nonthree && !irr::bitruncations_requested) irr::bitruncations_requested++;
|
||||||
|
if(!irr::on) irr::visual_creator();
|
||||||
|
});
|
||||||
}
|
}
|
||||||
|
|
||||||
dialog::addBreak(100);
|
dialog::addBreak(100);
|
||||||
|
|
|
@ -3085,7 +3085,7 @@ bool noAdjacentChasms(cell *c) {
|
||||||
|
|
||||||
// does the current geometry allow nice duals
|
// does the current geometry allow nice duals
|
||||||
bool has_nice_dual() {
|
bool has_nice_dual() {
|
||||||
if(irr::on) return false;
|
if(irr::on) return irr::bitruncations_performed > 0;
|
||||||
if(!nonbitrunc) return true;
|
if(!nonbitrunc) return true;
|
||||||
if((S7 & 1) == 0) return true;
|
if((S7 & 1) == 0) return true;
|
||||||
if(!gp::on) return false;
|
if(!gp::on) return false;
|
||||||
|
|
1
hyper.h
1
hyper.h
|
@ -2602,6 +2602,7 @@ namespace irr {
|
||||||
void visual_creator();
|
void visual_creator();
|
||||||
unsigned char density_code();
|
unsigned char density_code();
|
||||||
int celldist(cell *c, bool alts);
|
int celldist(cell *c, bool alts);
|
||||||
|
extern int bitruncations_requested, bitruncations_performed;
|
||||||
}
|
}
|
||||||
|
|
||||||
extern hrmap *currentmap;
|
extern hrmap *currentmap;
|
||||||
|
|
|
@ -615,4 +615,9 @@ hyperpoint mid_at(hyperpoint h1, hyperpoint h2, ld v) {
|
||||||
return mid(h, h);
|
return mid(h, h);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
hyperpoint mid_at_actual(hyperpoint h, ld v) {
|
||||||
|
using namespace hyperpoint_vec;
|
||||||
|
return rspintox(h) * xpush(hdist0(h) * v) * C0;
|
||||||
|
}
|
||||||
|
|
||||||
}
|
}
|
||||||
|
|
247
irregular.cpp
247
irregular.cpp
|
@ -97,6 +97,130 @@ bool gridmaking;
|
||||||
|
|
||||||
int rearrange_index;
|
int rearrange_index;
|
||||||
|
|
||||||
|
bool cell_sorting;
|
||||||
|
|
||||||
|
int bitruncations_requested = 1, bitruncations_performed = 0;
|
||||||
|
|
||||||
|
int black_adjacent, white_three;
|
||||||
|
|
||||||
|
void set_relmatrices(cellinfo& ci) {
|
||||||
|
auto& all = base->allcells();
|
||||||
|
ci.relmatrices.clear();
|
||||||
|
for(auto c0: all) ci.relmatrices[c0] = shmup::calc_relative_matrix(c0, ci.owner, ci.p);
|
||||||
|
}
|
||||||
|
|
||||||
|
void rebase(cellinfo& ci) {
|
||||||
|
cell *cx = ci.owner;
|
||||||
|
shmup::virtualRebase(ci.owner, ci.p, false);
|
||||||
|
if(ci.owner != cx) {
|
||||||
|
printf("rebased %p to %p\n", cx, ci.owner);
|
||||||
|
set_relmatrices(ci);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
void compute_jpoints() {
|
||||||
|
for(int i=0; i<isize(cells); i++) {
|
||||||
|
auto &ci = cells[i];
|
||||||
|
|
||||||
|
ci.pusher = rgpushxto0(ci.p);
|
||||||
|
ci.rpusher = gpushxto0(ci.p);
|
||||||
|
|
||||||
|
ci.jpoints.clear();
|
||||||
|
|
||||||
|
for(int j=0; j<isize(cells); j++) {
|
||||||
|
auto &cj = cells[j];
|
||||||
|
ci.jpoints.push_back(ci.rpusher * ci.relmatrices[cj.owner] * cj.p);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
void bitruncate() {
|
||||||
|
int cc = isize(cells);
|
||||||
|
map<pair<int, int>, int> bitruncated_id;
|
||||||
|
for(int i=0; i<cc; i++) {
|
||||||
|
int v = isize(cells[i].vertices);
|
||||||
|
for(int j=0; j<v; j++) {
|
||||||
|
int last = cells[i].neid[(j+v-1)%v];
|
||||||
|
int next = cells[i].neid[j];
|
||||||
|
if(!bitruncated_id.count(make_pair(i, last))) {
|
||||||
|
bitruncated_id[make_pair(i, last)] =
|
||||||
|
bitruncated_id[make_pair(last, next)] =
|
||||||
|
bitruncated_id[make_pair(next, i)] =
|
||||||
|
isize(cells);
|
||||||
|
cells.emplace_back();
|
||||||
|
cellinfo& s = cells.back();
|
||||||
|
s.patterndir = -1;
|
||||||
|
s.owner = cells[i].owner;
|
||||||
|
s.p = cells[i].pusher * cells[i].vertices[j];
|
||||||
|
s.neid.push_back(i);
|
||||||
|
s.neid.push_back(-1);
|
||||||
|
s.neid.push_back(last);
|
||||||
|
s.neid.push_back(-1);
|
||||||
|
s.neid.push_back(next);
|
||||||
|
s.neid.push_back(-1);
|
||||||
|
shmup::virtualRebase(s.owner, s.p, false);
|
||||||
|
set_relmatrices(s);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
for(int i=0; i<cc; i++) {
|
||||||
|
int v = isize(cells[i].vertices);
|
||||||
|
vector<int> newnei;
|
||||||
|
for(int j=0; j<v; j++) {
|
||||||
|
int last = cells[i].neid[(j+v-1)%v];
|
||||||
|
int next = cells[i].neid[j];
|
||||||
|
auto id = bitruncated_id[make_pair(i, last)];
|
||||||
|
newnei.push_back(id);
|
||||||
|
for(int k=0; k<6; k++)
|
||||||
|
if(cells[id].neid[k] == i) {
|
||||||
|
cells[id].neid[(k+5)%6] = bitruncated_id[make_pair(i, next)];
|
||||||
|
}
|
||||||
|
}
|
||||||
|
cells[i].neid = move(newnei);
|
||||||
|
}
|
||||||
|
make_cells_of_heptagon();
|
||||||
|
compute_jpoints();
|
||||||
|
for(int i=0; i<isize(cells); i++) {
|
||||||
|
auto &ci = cells[i];
|
||||||
|
ci.vertices.clear();
|
||||||
|
|
||||||
|
ci.pusher = rgpushxto0(ci.p);
|
||||||
|
ci.rpusher = gpushxto0(ci.p);
|
||||||
|
|
||||||
|
int v = isize(ci.neid);
|
||||||
|
for(int j=0; j<v; j++) {
|
||||||
|
int last = ci.neid[(j+v-1)%v];
|
||||||
|
int next = ci.neid[j];
|
||||||
|
hyperpoint h1 = ci.rpusher * ci.relmatrices[cells[last].owner] * cells[last].p;
|
||||||
|
hyperpoint h2 = ci.rpusher * ci.relmatrices[cells[next].owner] * cells[next].p;
|
||||||
|
ci.vertices.push_back(mid3(C0, h1, h2));
|
||||||
|
}
|
||||||
|
}
|
||||||
|
bitruncations_performed++;
|
||||||
|
cell_sorting = false;
|
||||||
|
}
|
||||||
|
|
||||||
|
int rearrange(bool total, ld minedge) {
|
||||||
|
int tooshort = 0;
|
||||||
|
for(int i=0; i<isize(cells); i++) {
|
||||||
|
auto& p1 = cells[i];
|
||||||
|
using namespace hyperpoint_vec;
|
||||||
|
hyperpoint h = hpxyz(0, 0, 0);
|
||||||
|
for(auto v: p1.vertices) h = h + v;
|
||||||
|
|
||||||
|
bool changed = total;
|
||||||
|
|
||||||
|
for(int j=0; j<isize(p1.vertices); j++)
|
||||||
|
if(hdist(p1.vertices[j], p1.vertices[(j+1) % isize(p1.vertices)]) < minedge) {
|
||||||
|
tooshort++; changed = true;
|
||||||
|
h = h + p1.vertices[j] + p1.vertices[(j+1) % isize(p1.vertices)];
|
||||||
|
}
|
||||||
|
if(changed)
|
||||||
|
cells[i].p = p1.pusher * normalize(h);
|
||||||
|
}
|
||||||
|
return tooshort;
|
||||||
|
}
|
||||||
|
|
||||||
bool step(int delta) {
|
bool step(int delta) {
|
||||||
|
|
||||||
if(!gridmaking) return false;
|
if(!gridmaking) return false;
|
||||||
|
@ -119,7 +243,7 @@ bool step(int delta) {
|
||||||
cellinfo& s = cells.back();
|
cellinfo& s = cells.back();
|
||||||
s.patterndir = -1;
|
s.patterndir = -1;
|
||||||
s.owner = h, s.p = spin(hrand(1000)) * xpush(.01) * C0;
|
s.owner = h, s.p = spin(hrand(1000)) * xpush(.01) * C0;
|
||||||
for(auto c0: all) s.relmatrices[c0] = shmup::calc_relative_matrix(c0, s.owner, s.p);
|
set_relmatrices(s);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
runlevel++;
|
runlevel++;
|
||||||
|
@ -150,6 +274,7 @@ bool step(int delta) {
|
||||||
// printf("%lf %p %s\n", bestval, s.owner, display(s.p));
|
// printf("%lf %p %s\n", bestval, s.owner, display(s.p));
|
||||||
}
|
}
|
||||||
make_cells_of_heptagon();
|
make_cells_of_heptagon();
|
||||||
|
cell_sorting = true; bitruncations_performed = 0;
|
||||||
runlevel++;
|
runlevel++;
|
||||||
status[0] = "all " + its(isize(cells)) + " cells";
|
status[0] = "all " + its(isize(cells)) + " cells";
|
||||||
break;
|
break;
|
||||||
|
@ -157,7 +282,8 @@ bool step(int delta) {
|
||||||
|
|
||||||
case 2: {
|
case 2: {
|
||||||
|
|
||||||
sort(cells.begin(), cells.end(), [] (const cellinfo &s1, const cellinfo &s2) { return hdist0(s1.p) < hdist0(s2.p); });
|
if(cell_sorting)
|
||||||
|
sort(cells.begin(), cells.end(), [] (const cellinfo &s1, const cellinfo &s2) { return hdist0(s1.p) < hdist0(s2.p); });
|
||||||
make_cells_of_heptagon();
|
make_cells_of_heptagon();
|
||||||
|
|
||||||
edgelens.clear();
|
edgelens.clear();
|
||||||
|
@ -166,25 +292,18 @@ bool step(int delta) {
|
||||||
int stats[16];
|
int stats[16];
|
||||||
for(int k=0; k<16; k++) stats[k] = 0;
|
for(int k=0; k<16; k++) stats[k] = 0;
|
||||||
|
|
||||||
for(int i=0; i<cellcount; i++) {
|
compute_jpoints();
|
||||||
|
|
||||||
|
for(int i=0; i<isize(cells); i++) {
|
||||||
auto &p1 = cells[i];
|
auto &p1 = cells[i];
|
||||||
|
|
||||||
p1.vertices.clear();
|
p1.vertices.clear();
|
||||||
p1.neid.clear();
|
p1.neid.clear();
|
||||||
|
|
||||||
p1.pusher = rgpushxto0(p1.p);
|
|
||||||
p1.rpusher = gpushxto0(p1.p);
|
|
||||||
|
|
||||||
p1.jpoints.clear();
|
|
||||||
|
|
||||||
for(int j=0; j<cellcount; j++) {
|
|
||||||
auto &p2 = cells[j];
|
|
||||||
p1.jpoints.push_back(p1.rpusher * p1.relmatrices[p2.owner] * p2.p);
|
|
||||||
}
|
|
||||||
|
|
||||||
int j = 0;
|
int j = 0;
|
||||||
if(j == i) j = 1;
|
if(j == i) j = 1;
|
||||||
|
|
||||||
for(int k=0; k<cellcount; k++) if(k != i) {
|
for(int k=0; k<isize(cells); k++) if(k != i) {
|
||||||
if(hdist(p1.jpoints[k], C0) < hdist(p1.jpoints[j], C0))
|
if(hdist(p1.jpoints[k], C0) < hdist(p1.jpoints[j], C0))
|
||||||
j = k;
|
j = k;
|
||||||
}
|
}
|
||||||
|
@ -196,7 +315,7 @@ bool step(int delta) {
|
||||||
do {
|
do {
|
||||||
int best_k = -1;
|
int best_k = -1;
|
||||||
hyperpoint best_h;
|
hyperpoint best_h;
|
||||||
for(int k=0; k<cellcount; k++) if(k != i && k != j && k != oldj) {
|
for(int k=0; k<isize(cells); k++) if(k != i && k != j && k != oldj) {
|
||||||
hyperpoint h = circumscribe(C0, p1.jpoints[j], p1.jpoints[k]);
|
hyperpoint h = circumscribe(C0, p1.jpoints[j], p1.jpoints[k]);
|
||||||
if(h[2] < 0) continue;
|
if(h[2] < 0) continue;
|
||||||
if(!clockwise(t, h)) continue;
|
if(!clockwise(t, h)) continue;
|
||||||
|
@ -264,27 +383,12 @@ bool step(int delta) {
|
||||||
ld median = edgelens[isize(edgelens) / 2];
|
ld median = edgelens[isize(edgelens) / 2];
|
||||||
ld minedge = median * quality;
|
ld minedge = median * quality;
|
||||||
status[3] = XLAT("median edge: %1 minimum: %2", fts4(median), fts4(edgelens[0]));
|
status[3] = XLAT("median edge: %1 minimum: %2", fts4(median), fts4(edgelens[0]));
|
||||||
if(edgelens[0] < minedge) {
|
if(!bitruncations_performed && edgelens[0] < minedge) {
|
||||||
if(rearrange_index >= rearrange_max_attempts) {
|
if(rearrange_index >= rearrange_max_attempts) {
|
||||||
runlevel = 0; break;
|
runlevel = 0; break;
|
||||||
}
|
}
|
||||||
int tooshort = 0;
|
int tooshort = rearrange(rearrange_index < rearrange_less, minedge);
|
||||||
for(int i=0; i<isize(cells); i++) {
|
|
||||||
auto& p1 = cells[i];
|
|
||||||
using namespace hyperpoint_vec;
|
|
||||||
hyperpoint h = hpxyz(0, 0, 0);
|
|
||||||
for(auto v: p1.vertices) h = h + v;
|
|
||||||
|
|
||||||
bool changed = rearrange_index < rearrange_less;
|
|
||||||
|
|
||||||
for(int j=0; j<isize(p1.vertices); j++)
|
|
||||||
if(hdist(p1.vertices[j], p1.vertices[(j+1) % isize(p1.vertices)]) < minedge) {
|
|
||||||
tooshort++; changed = true;
|
|
||||||
h = h + p1.vertices[j] + p1.vertices[(j+1) % isize(p1.vertices)];
|
|
||||||
}
|
|
||||||
if(changed)
|
|
||||||
cells[i].p = p1.pusher * normalize(h);
|
|
||||||
}
|
|
||||||
status[3] += XLAT(" (edges too short: %1)", its(tooshort));
|
status[3] += XLAT(" (edges too short: %1)", its(tooshort));
|
||||||
runlevel = 2;
|
runlevel = 2;
|
||||||
rearrange_index++;
|
rearrange_index++;
|
||||||
|
@ -293,12 +397,20 @@ bool step(int delta) {
|
||||||
runlevel++;
|
runlevel++;
|
||||||
break;
|
break;
|
||||||
}
|
}
|
||||||
|
|
||||||
case 5: {
|
case 5: {
|
||||||
|
if(bitruncations_performed < bitruncations_requested)
|
||||||
|
bitruncate();
|
||||||
|
else
|
||||||
|
runlevel = 6;
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
|
||||||
|
case 6: {
|
||||||
|
|
||||||
int notfound = 0;
|
int notfound = 0;
|
||||||
|
|
||||||
for(int i=0; i<cellcount; i++) {
|
for(int i=0; i<isize(cells); i++) {
|
||||||
auto &p1 = cells[i];
|
auto &p1 = cells[i];
|
||||||
int N = isize(p1.vertices);
|
int N = isize(p1.vertices);
|
||||||
p1.spin.resize(N);
|
p1.spin.resize(N);
|
||||||
|
@ -327,7 +439,7 @@ bool step(int delta) {
|
||||||
}
|
}
|
||||||
|
|
||||||
int faredge = 0;
|
int faredge = 0;
|
||||||
for(int i=0; i<cellcount; i++) {
|
for(int i=0; i<isize(cells); i++) {
|
||||||
auto &p1 = cells[i];
|
auto &p1 = cells[i];
|
||||||
for(int j: p1.neid) {
|
for(int j: p1.neid) {
|
||||||
auto &p2 = cells[j];
|
auto &p2 = cells[j];
|
||||||
|
@ -340,6 +452,24 @@ bool step(int delta) {
|
||||||
status[4] = XLAT("adjacent cells from nonadjacent heptagons: %1", its(faredge));
|
status[4] = XLAT("adjacent cells from nonadjacent heptagons: %1", its(faredge));
|
||||||
runlevel = 0; return false;
|
runlevel = 0; return false;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
/*
|
||||||
|
black_adjacent = 0;
|
||||||
|
white_three = 0;
|
||||||
|
for(int i=0; i<isize(cells); i++) {
|
||||||
|
if(!cells[i].by_bitruncation) {
|
||||||
|
for(int j: cells[i].neid) if(!cells[j].by_bitruncation) black_adjacent++;
|
||||||
|
}
|
||||||
|
else {
|
||||||
|
int v = isize(cells[i].neid);
|
||||||
|
for(int j=0; j<v; j++)
|
||||||
|
if(cells[cells[i].neid[j]].by_bitruncation)
|
||||||
|
if(cells[cells[i].neid[(j+1)%v]].by_bitruncation)
|
||||||
|
white_three++;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
printf("black_adjacent = %d, white_three = %d\n", black_adjacent, white_three);
|
||||||
|
*/
|
||||||
|
|
||||||
status[4] = XLAT("OK");
|
status[4] = XLAT("OK");
|
||||||
runlevel = 10;
|
runlevel = 10;
|
||||||
|
@ -380,7 +510,7 @@ ld scale;
|
||||||
|
|
||||||
void compute_geometry() {
|
void compute_geometry() {
|
||||||
if(irr::on) {
|
if(irr::on) {
|
||||||
scale = sqrt(isize(cells_of_heptagon) * 1. / cellcount);
|
scale = sqrt(isize(cells_of_heptagon) * 1. / isize(cells));
|
||||||
crossf *= scale;
|
crossf *= scale;
|
||||||
hepvdist *= scale;
|
hepvdist *= scale;
|
||||||
rhexf *= scale;
|
rhexf *= scale;
|
||||||
|
@ -695,7 +825,7 @@ bool save_map(const string& fname) {
|
||||||
FILE *f = fopen(fname.c_str(), "wt");
|
FILE *f = fopen(fname.c_str(), "wt");
|
||||||
if(!f) return false;
|
if(!f) return false;
|
||||||
auto& all = base->allcells();
|
auto& all = base->allcells();
|
||||||
fprintf(f, "%d %d %d\n", geometry, isize(all), cellcount);
|
fprintf(f, "%d %d %d\n", geometry, isize(all), isize(cells));
|
||||||
|
|
||||||
for(auto h: all) {
|
for(auto h: all) {
|
||||||
fprintf(f, "%d\n", isize(cells_of_heptagon[h->master]));
|
fprintf(f, "%d\n", isize(cells_of_heptagon[h->master]));
|
||||||
|
@ -752,13 +882,20 @@ void cancel_map_creation() {
|
||||||
|
|
||||||
string irrmapfile = "irregularmap.txt";
|
string irrmapfile = "irregularmap.txt";
|
||||||
|
|
||||||
|
string irrhelp =
|
||||||
|
"This option creates irregular grids to play the game on. "
|
||||||
|
"Currently rather slow algorithms are used, "
|
||||||
|
"so not recommended with too high density or "
|
||||||
|
"with too large periodic base geometry. "
|
||||||
|
"For technical reasons, the density cannot be too small.";
|
||||||
|
|
||||||
void show_gridmaker() {
|
void show_gridmaker() {
|
||||||
cmode = sm::SIDE;
|
cmode = sm::SIDE;
|
||||||
gamescreen(0);
|
gamescreen(0);
|
||||||
dialog::init(XLAT("irregular grid"));
|
dialog::init(XLAT("irregular grid"));
|
||||||
dialog::addSelItem(XLAT("density"), fts(density), 'd');
|
dialog::addSelItem(XLAT("density"), fts(density), 'd');
|
||||||
dialog::add_action([] {
|
dialog::add_action([] {
|
||||||
dialog::editNumber(density, 1, 10, .1, 4, "density", "");
|
dialog::editNumber(density, 1, 10, .1, 4, XLAT("density"), XLAT(irrhelp));
|
||||||
dialog::reaction = [] () {
|
dialog::reaction = [] () {
|
||||||
int s = cellcount;
|
int s = cellcount;
|
||||||
if(density < 1) density = 1;
|
if(density < 1) density = 1;
|
||||||
|
@ -770,7 +907,10 @@ void show_gridmaker() {
|
||||||
});
|
});
|
||||||
dialog::addSelItem(XLAT("min edge to median"), fts(quality), 'q');
|
dialog::addSelItem(XLAT("min edge to median"), fts(quality), 'q');
|
||||||
dialog::add_action([] {
|
dialog::add_action([] {
|
||||||
dialog::editNumber(quality, 0, 1, .1, 4, XLAT("quality"), "");
|
dialog::editNumber(quality, 0, 1, .05, .2, XLAT("quality"), XLAT(
|
||||||
|
"The smallest allowed ratio of edge length to median edge length. "
|
||||||
|
"Tilings with low values are easier to generate, but tend to be more ugly."
|
||||||
|
));
|
||||||
dialog::reaction = [] () {
|
dialog::reaction = [] () {
|
||||||
printf("quality = %lf\n", double(density));
|
printf("quality = %lf\n", double(density));
|
||||||
if(runlevel > 4) runlevel = 4;
|
if(runlevel > 4) runlevel = 4;
|
||||||
|
@ -810,18 +950,22 @@ void show_gridmaker() {
|
||||||
}
|
}
|
||||||
});
|
});
|
||||||
});
|
});
|
||||||
|
dialog::addSelItem(XLAT("bitruncation count"), its(bitruncations_requested), 'b');
|
||||||
|
dialog::add_action([] () {
|
||||||
|
dialog::editNumber(bitruncations_requested, 0, 5, 1, 1, XLAT("bitruncation const"),
|
||||||
|
XLAT("Bitruncation introduces some regularity, allowing more sophisiticated floor tilings and textures."));
|
||||||
|
dialog::reaction = [] () {
|
||||||
|
if(bitruncations_requested > bitruncations_performed && runlevel > 5) runlevel = 5;
|
||||||
|
if(bitruncations_requested < bitruncations_performed) runlevel = 0;
|
||||||
|
};
|
||||||
|
});
|
||||||
dialog::addItem(XLAT("reset"), 'r');
|
dialog::addItem(XLAT("reset"), 'r');
|
||||||
dialog::add_action([] () { runlevel = 0; });
|
dialog::add_action([] () { runlevel = 0; });
|
||||||
dialog::addHelp();
|
dialog::addHelp();
|
||||||
dialog::display();
|
dialog::display();
|
||||||
keyhandler = [] (int sym, int uni) {
|
keyhandler = [] (int sym, int uni) {
|
||||||
if(uni == 'h' || sym == SDLK_F1) gotoHelp(XLAT(
|
handlePanning(sym, uni);
|
||||||
"This option creates irregular grids to play the game on. "
|
if(uni == 'h' || sym == SDLK_F1) gotoHelp(XLAT(irrhelp));
|
||||||
"Currently rather slow algorithms are used, "
|
|
||||||
"so not recommended with too high density or "
|
|
||||||
"with too large periodic base geometry. "
|
|
||||||
"For technical reasons, the density cannot be too small."
|
|
||||||
));
|
|
||||||
dialog::handleNavigation(sym, uni);
|
dialog::handleNavigation(sym, uni);
|
||||||
// no exit
|
// no exit
|
||||||
};
|
};
|
||||||
|
@ -859,6 +1003,7 @@ void visual_creator() {
|
||||||
void auto_creator() {
|
void auto_creator() {
|
||||||
irr::on = false;
|
irr::on = false;
|
||||||
int cc = cellcount;
|
int cc = cellcount;
|
||||||
|
bitruncations_requested = bitruncations_performed;
|
||||||
visual_creator();
|
visual_creator();
|
||||||
cellcount = cc; density = cc * 1. / isize(base->allcells());
|
cellcount = cc; density = cc * 1. / isize(base->allcells());
|
||||||
printf("Creating the irregular map automatically...\n");
|
printf("Creating the irregular map automatically...\n");
|
||||||
|
@ -877,6 +1022,10 @@ int readArgs() {
|
||||||
visual_creator();
|
visual_creator();
|
||||||
showstartmenu = false;
|
showstartmenu = false;
|
||||||
}
|
}
|
||||||
|
else if(argis("-irrdens")) {
|
||||||
|
PHASE(2);
|
||||||
|
shift(); density = argf();
|
||||||
|
}
|
||||||
else if(argis("-irrload")) {
|
else if(argis("-irrload")) {
|
||||||
PHASE(3);
|
PHASE(3);
|
||||||
restart_game();
|
restart_game();
|
||||||
|
@ -893,9 +1042,9 @@ int readArgs() {
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
unsigned char density_code() {
|
unsigned char density_code() {
|
||||||
if(cellcount < 128) return cellcount;
|
if(isize(cells) < 128) return isize(cells);
|
||||||
else {
|
else {
|
||||||
int t = 127, a = cellcount;
|
int t = 127, a = isize(cells);
|
||||||
while(a > 127) a = a * 9/10, t++;
|
while(a > 127) a = a * 9/10, t++;
|
||||||
return t;
|
return t;
|
||||||
}
|
}
|
||||||
|
|
|
@ -1159,7 +1159,7 @@ land_validity_t& land_validity(eLand l) {
|
||||||
if(isWarped(l) && a4 && gp::on)
|
if(isWarped(l) && a4 && gp::on)
|
||||||
return dont_work;
|
return dont_work;
|
||||||
|
|
||||||
if((isWarped(l) || l == laDual) && irr::on)
|
if((isWarped(l) || l == laDual) && irr::on && !irr::bitruncations_performed)
|
||||||
return dont_work;
|
return dont_work;
|
||||||
|
|
||||||
if(irr::on && among(l, laPrairie, laBlizzard, laVolcano, laMirror, laMirrorOld))
|
if(irr::on && among(l, laPrairie, laBlizzard, laVolcano, laMirror, laMirrorOld))
|
||||||
|
|
|
@ -1042,7 +1042,7 @@ int geosupport_threecolor() {
|
||||||
int geosupport_graveyard() {
|
int geosupport_graveyard() {
|
||||||
// always works in bitrunc geometries
|
// always works in bitrunc geometries
|
||||||
if(!nonbitrunc) return 2;
|
if(!nonbitrunc) return 2;
|
||||||
if(irr::on) return 0;
|
if(irr::on) return irr::bitruncations_performed ? 2 : 1;
|
||||||
|
|
||||||
// always works in patterns supporting three-color
|
// always works in patterns supporting three-color
|
||||||
int tc = max(geosupport_threecolor(), gp_threecolor());
|
int tc = max(geosupport_threecolor(), gp_threecolor());
|
||||||
|
@ -1182,7 +1182,7 @@ bool warptype(cell *c) {
|
||||||
else
|
else
|
||||||
return c->master->distance & 1;
|
return c->master->distance & 1;
|
||||||
}
|
}
|
||||||
else if(gp::on)
|
else if(gp::on || irr::on)
|
||||||
return pseudohept(c);
|
return pseudohept(c);
|
||||||
else
|
else
|
||||||
return pattern_threecolor(c) == 0;
|
return pattern_threecolor(c) == 0;
|
||||||
|
|
|
@ -300,7 +300,7 @@ bool havesave = true;
|
||||||
|
|
||||||
#if CAP_SAVE
|
#if CAP_SAVE
|
||||||
#define MAXBOX 500
|
#define MAXBOX 500
|
||||||
#define POSSCORE 354 // update this when new boxes are added!
|
#define POSSCORE 355 // update this when new boxes are added!
|
||||||
|
|
||||||
struct score {
|
struct score {
|
||||||
string ver;
|
string ver;
|
||||||
|
@ -699,6 +699,8 @@ void applyBoxes() {
|
||||||
|
|
||||||
list_invorb();
|
list_invorb();
|
||||||
|
|
||||||
|
applyBox(irr::bitruncations_performed);
|
||||||
|
|
||||||
if(POSSCORE != boxid) printf("ERROR: %d boxes\n", boxid);
|
if(POSSCORE != boxid) printf("ERROR: %d boxes\n", boxid);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
Loading…
Reference in New Issue