mirror of
https://github.com/zenorogue/hyperrogue.git
synced 2025-01-11 09:50:34 +00:00
more work on new geometries
This commit is contained in:
Zeno Rogue
parent
06295fd90d
commit
ac37df87a5
181
cell.cpp
181
cell.cpp
@ -5,8 +5,8 @@
|
||||
|
||||
#define DEBMEM(x) // { x fflush(stdout); }
|
||||
|
||||
int fix6(int a) { return (a+96)% 6; }
|
||||
int fix7(int a) { return (a+420)%S7; }
|
||||
int fix6(int a) { return (a+MODFIXER)%S6; }
|
||||
int fix7(int a) { return (a+MODFIXER)%S7; }
|
||||
|
||||
int dirdiff(int dd, int t) {
|
||||
dd %= t;
|
||||
@ -564,84 +564,7 @@ struct hrmap_quotient : hrmap {
|
||||
|
||||
// --- general ---
|
||||
|
||||
// very similar to createMove in heptagon.cpp
|
||||
cell *createMov(cell *c, int d) {
|
||||
|
||||
if(euclid && !c->mov[d]) {
|
||||
eucoord x, y;
|
||||
decodeMaster(c->master, x, y);
|
||||
for(int dx=-1; dx<=1; dx++)
|
||||
for(int dy=-1; dy<=1; dy++)
|
||||
euclideanAtCreate(x+dx, y+dy);
|
||||
if(!c->mov[d]) { printf("fail!\n"); }
|
||||
}
|
||||
|
||||
if(c->mov[d]) return c->mov[d];
|
||||
else if(purehepta) {
|
||||
heptagon *h2 = createStep(c->master, d);
|
||||
merge(c,d,h2->c7,c->master->spin(d),false);
|
||||
}
|
||||
else if(c->type != 6) {
|
||||
cell *n = newCell(6, c->master);
|
||||
|
||||
merge(c,d,n,0,false);
|
||||
|
||||
heptspin hs; hs.h = c->master; hs.spin = d; hs.mirrored = false;
|
||||
|
||||
int a3 = c->type/2;
|
||||
int a4 = a3+1;
|
||||
|
||||
heptspin hs2 = hsstep(hsspin(hs, a3), -a4);
|
||||
merge(hs2.h->c7, hs2.spin, n, 2, hs2.mirrored);
|
||||
|
||||
heptspin hs3 = hsstep(hsspin(hs, a4), -a3);
|
||||
merge(hs3.h->c7, hs3.spin, n, 4, hs3.mirrored);
|
||||
|
||||
extern void verifycell(cell *c);
|
||||
verifycell(n);
|
||||
}
|
||||
|
||||
else if(d == 5) {
|
||||
int di = fixrot(c->spin(0)+1);
|
||||
cell *c2 = createMov(c->mov[0], di);
|
||||
bool mirr = c->mov[0]->mirror(di);
|
||||
merge(c, 5, c2, fix6(c->mov[0]->spn(di) + (mirr?-1:1)), mirr);
|
||||
|
||||
// c->mov[5] = c->mov[0]->mov[fixrot(c->spn[0]+1)];
|
||||
// c->spn[5] = fix6(c->mov[0]->spn[fixrot(c->spn[0]+1)] + 1);
|
||||
}
|
||||
|
||||
else if(d == 1) {
|
||||
int di = fixrot(c->spn(0)-1);
|
||||
cell *c2 = createMov(c->mov[0], di);
|
||||
bool mirr = c->mov[0]->mirror(di);
|
||||
merge(c, 1, c2, fix6(c->mov[0]->spn(di) - (mirr?-1:1)), mirr);
|
||||
|
||||
// c->mov[1] = c->mov[0]->mov[fixrot(c->spn[0]-1)];
|
||||
// c->spn[1] = fix6(c->mov[0]->spn[fixrot(c->spn[0]-1)] - 1);
|
||||
}
|
||||
|
||||
else if(d == 3) {
|
||||
bool mirr = c->mirror(2);
|
||||
int di = fixrot(c->spn(2)-(mirr?-1:1));
|
||||
cell *c2 = createMov(c->mov[2], di);
|
||||
bool nmirr = mirr ^ c->mov[2]->mirror(di);
|
||||
merge(c, 3, c2, fix6(c->mov[2]->spn(di) - (nmirr?-1:1)), nmirr);
|
||||
// c->mov[3] = c->mov[2]->mov[fixrot(c->spn[2]-1)];
|
||||
// c->spn[3] = fix6(c->mov[2]->spn[fixrot(c->spn[2]-1)] - 1);
|
||||
}
|
||||
return c->mov[d];
|
||||
}
|
||||
|
||||
cell *createMovR(cell *c, int d) {
|
||||
d %= MODFIXER; d += MODFIXER; d %= c->type;
|
||||
return createMov(c, d);
|
||||
}
|
||||
|
||||
cell *getMovR(cell *c, int d) {
|
||||
d %= MODFIXER; d += MODFIXER; d %= c->type;
|
||||
return c->mov[d];
|
||||
}
|
||||
cell *createMov(cell *c, int d);
|
||||
|
||||
// similar to heptspin from heptagon.cpp
|
||||
struct cellwalker {
|
||||
@ -685,6 +608,96 @@ void cwrevstep(cellwalker& cw) {
|
||||
cwrev(cw); cwstep(cw);
|
||||
}
|
||||
|
||||
// very similar to createMove in heptagon.cpp
|
||||
cell *createMov(cell *c, int d) {
|
||||
|
||||
if(euclid && !c->mov[d]) {
|
||||
eucoord x, y;
|
||||
decodeMaster(c->master, x, y);
|
||||
for(int dx=-1; dx<=1; dx++)
|
||||
for(int dy=-1; dy<=1; dy++)
|
||||
euclideanAtCreate(x+dx, y+dy);
|
||||
if(!c->mov[d]) { printf("fail!\n"); }
|
||||
}
|
||||
|
||||
if(c->mov[d]) return c->mov[d];
|
||||
else if(purehepta) {
|
||||
heptagon *h2 = createStep(c->master, d);
|
||||
merge(c,d,h2->c7,c->master->spin(d),false);
|
||||
}
|
||||
else if(c == c->master->c7) {
|
||||
|
||||
cell *n = newCell(S6, c->master);
|
||||
|
||||
merge(c,d,n,0,false);
|
||||
|
||||
heptspin hs; hs.h = c->master; hs.spin = d; hs.mirrored = false;
|
||||
|
||||
int a3 = c->type/2;
|
||||
int a4 = a3+1;
|
||||
|
||||
/*
|
||||
heptspin hs2 = hsstep(hsspin(hs, a3), -a4);
|
||||
merge(hs2.h->c7, hs2.spin, n, 2, hs2.mirrored);
|
||||
|
||||
heptspin hs3 = hsstep(hsspin(hs, a4), -a3);
|
||||
merge(hs3.h->c7, hs3.spin, n, S6-2, hs3.mirrored);
|
||||
*/
|
||||
|
||||
for(int u=2; u<S6; u+=2) {
|
||||
hs = hsstep(hsspin(hs, a3), -a4);
|
||||
merge(hs.h->c7, hs.spin, n, u, hs.mirrored);
|
||||
}
|
||||
|
||||
extern void verifycell(cell *c);
|
||||
verifycell(n);
|
||||
}
|
||||
|
||||
/*
|
||||
else if(d == S6-1) {
|
||||
int di = fixrot(c->spin(0)+1);
|
||||
cell *c2 = createMov(c->mov[0], di);
|
||||
bool mirr = c->mov[0]->mirror(di);
|
||||
merge(c, S6-1, c2, fix6(c->mov[0]->spn(di) + (mirr?-1:1)), mirr);
|
||||
|
||||
// c->mov[5] = c->mov[0]->mov[fixrot(c->spn[0]+1)];
|
||||
// c->spn[5] = fix6(c->mov[0]->spn[fixrot(c->spn[0]+1)] + 1);
|
||||
}
|
||||
|
||||
else if(d == 1) {
|
||||
int di = fixrot(c->spn(0)-1);
|
||||
cell *c2 = createMov(c->mov[0], di);
|
||||
bool mirr = c->mov[0]->mirror(di);
|
||||
merge(c, 1, c2, fix6(c->mov[0]->spn(di) - (mirr?-1:1)), mirr);
|
||||
|
||||
// c->mov[1] = c->mov[0]->mov[fixrot(c->spn[0]-1)];
|
||||
// c->spn[1] = fix6(c->mov[0]->spn[fixrot(c->spn[0]-1)] - 1);
|
||||
}
|
||||
|
||||
else if(d == 3 || d == 5) { */
|
||||
|
||||
else {
|
||||
bool mirr = c->mirror(d-1);
|
||||
int di = fixrot(c->spn(d-1)-(mirr?-1:1));
|
||||
cell *c2 = createMov(c->mov[d-1], di);
|
||||
bool nmirr = mirr ^ c->mov[d-1]->mirror(di);
|
||||
merge(c, d, c2, fix6(c->mov[d-1]->spn(di) - (nmirr?-1:1)), nmirr);
|
||||
// c->mov[3] = c->mov[2]->mov[fixrot(c->spn[2]-1)];
|
||||
// c->spn[3] = fix6(c->mov[2]->spn[fixrot(c->spn[2]-1)] - 1);
|
||||
}
|
||||
return c->mov[d];
|
||||
}
|
||||
|
||||
cell *createMovR(cell *c, int d) {
|
||||
d %= MODFIXER; d += MODFIXER; d %= c->type;
|
||||
return createMov(c, d);
|
||||
}
|
||||
|
||||
cell *getMovR(cell *c, int d) {
|
||||
d %= MODFIXER; d += MODFIXER; d %= c->type;
|
||||
return c->mov[d];
|
||||
}
|
||||
|
||||
void eumerge(cell* c1, cell *c2, int s1, int s2) {
|
||||
if(!c2) return;
|
||||
c1->mov[s1] = c2; tsetspin(c1->spintable, s1, s2);
|
||||
@ -727,7 +740,7 @@ void initcells() {
|
||||
|
||||
allmaps.push_back(currentmap);
|
||||
|
||||
if(!AT8) windmap::create();
|
||||
if(!AT8 && !AT456) windmap::create();
|
||||
|
||||
// origin->emeraldval =
|
||||
}
|
||||
@ -792,7 +805,7 @@ void verifycell(cell *c) {
|
||||
for(int i=0; i<t; i++) {
|
||||
cell *c2 = c->mov[i];
|
||||
if(c2) {
|
||||
if(t != 6 && !purehepta) verifycell(c2);
|
||||
if(!euclid && !purehepta && c == c->master->c7) verifycell(c2);
|
||||
if(c2->mov[c->spn(i)] && c2->mov[c->spn(i)] != c) {
|
||||
printf("cell error %p:%d [%d] %p:%d [%d]\n", c, i, c->type, c2, c->spn(i), c2->type);
|
||||
exit(1);
|
||||
@ -825,13 +838,13 @@ int eupattern(cell *c) {
|
||||
bool ishept(cell *c) {
|
||||
// EUCLIDEAN
|
||||
if(euclid) return eupattern(c) == 0;
|
||||
else return c->type != 6;
|
||||
else return c->type != S6;
|
||||
}
|
||||
|
||||
bool ishex1(cell *c) {
|
||||
// EUCLIDEAN
|
||||
if(euclid) return eupattern(c) == 1;
|
||||
else return c->type != 6;
|
||||
else return c->type != S6;
|
||||
}
|
||||
|
||||
int emeraldval(cell *c) {
|
||||
|
||||
64
geometry.cpp
64
geometry.cpp
@ -8,6 +8,7 @@ ld tessf, crossf, hexf, hcrossf, hexhexdist;
|
||||
|
||||
// tessf: distance from heptagon center to another heptagon center
|
||||
// hexf: distance from heptagon center to heptagon vertex
|
||||
// hcrossf: distance from heptagon center to big heptagon vertex
|
||||
// crossf: distance from heptagon center to adjacent hexagon center
|
||||
// hexhexdist: distance between adjacent hexagon vertices
|
||||
|
||||
@ -18,7 +19,7 @@ hyperpoint Crad[6*MAX_EDGE];
|
||||
transmatrix heptmove[MAX_EDGE], hexmove[MAX_EDGE];
|
||||
transmatrix invheptmove[MAX_EDGE], invhexmove[MAX_EDGE];
|
||||
|
||||
transmatrix spinmatrix[MAX_EDGE*12];
|
||||
transmatrix spinmatrix[MAX_S84];
|
||||
|
||||
ld hexshift;
|
||||
|
||||
@ -33,6 +34,7 @@ const transmatrix& getspinmatrix(int id) {
|
||||
// hexhexdist = 0.566256
|
||||
|
||||
ld hcrossf7 = 0.620672;
|
||||
ld hexf7 = 0.378077;
|
||||
|
||||
// the distance between two hexagon centers
|
||||
|
||||
@ -42,30 +44,50 @@ void precalc() {
|
||||
|
||||
hexshift = 0;
|
||||
|
||||
int vertexdegree = S6/2;
|
||||
ld fmin, fmax;
|
||||
|
||||
if(euclid) {
|
||||
dynamicval<eGeometry> g(geometry, gNormal);
|
||||
precalc();
|
||||
return;
|
||||
// dynamicval<eGeometry> g(geometry, gNormal);
|
||||
// precalc(); }
|
||||
// for(int i=0; i<S84; i++) spinmatrix[i] = spin(i * M_PI / S42);
|
||||
hcrossf = hexhexdist = hexf = hexf7;
|
||||
tessf = hexf * sqrt(3);
|
||||
goto finish;
|
||||
}
|
||||
|
||||
ld fmin = 1, fmax = 2;
|
||||
fmin = AT456 ? 0 : 1, fmax = 2;
|
||||
|
||||
for(int p=0; p<100; p++) {
|
||||
ld f = (fmin+fmax) / 2;
|
||||
hyperpoint H = xpush(f) * C0;
|
||||
ld v1 = intval(H, C0), v2 = intval(H, spin(2*M_PI/S7)*H);
|
||||
ld v1, v2;
|
||||
if(vertexdegree == 3) {
|
||||
hyperpoint H = xpush(f) * C0;
|
||||
v1 = intval(H, C0), v2 = intval(H, spin(2*M_PI/S7)*H);
|
||||
}
|
||||
else if(vertexdegree == 4) {
|
||||
hyperpoint H = xpush(f) * C0;
|
||||
ld opposite = hdist(H, spin(2*M_PI/S7)*H);
|
||||
hyperpoint Hopposite = spin(M_PI/S7) * xpush(opposite) * C0;
|
||||
v2 = intval(H, Hopposite), v1 = intval(H, C0);
|
||||
}
|
||||
if(sphere ? v1 < v2 : v1 > v2) fmin = f; else fmax = f;
|
||||
}
|
||||
tessf = fmin;
|
||||
|
||||
fmin = 0, fmax = sphere ? M_PI / 2 : 2;
|
||||
for(int p=0; p<100; p++) {
|
||||
ld f = (fmin+fmax) / 2;
|
||||
hyperpoint H = spin(M_PI/S7) * xpush(f) * C0;
|
||||
ld v1 = intval(H, C0), v2 = intval(H, xpush(tessf) * C0);
|
||||
if(v1 < v2) fmin = f; else fmax = f;
|
||||
if(vertexdegree == 3) {
|
||||
fmin = 0, fmax = sphere ? M_PI / 2 : 2;
|
||||
for(int p=0; p<100; p++) {
|
||||
ld f = (fmin+fmax) / 2;
|
||||
hyperpoint H = spin(M_PI/S7) * xpush(f) * C0;
|
||||
ld v1 = intval(H, C0), v2 = intval(H, xpush(tessf) * C0);
|
||||
if(v1 < v2) fmin = f; else fmax = f;
|
||||
}
|
||||
hcrossf = fmin;
|
||||
}
|
||||
else {
|
||||
hcrossf = hdist(xpush(tessf) * C0, spin(2*M_PI/S7) * xpush(tessf) * C0) / 2;
|
||||
}
|
||||
hcrossf = fmin;
|
||||
crossf = purehepta ? tessf : hcrossf;
|
||||
|
||||
fmin = 0, fmax = tessf;
|
||||
@ -79,17 +101,21 @@ void precalc() {
|
||||
}
|
||||
hexf = fmin;
|
||||
|
||||
// printf("hexf = %.6Lf cross = %.6Lf tessf = %.6Lf\n", hexf, crossf, tessf);
|
||||
if(AT8 && !purehepta)
|
||||
hexshift = ALPHA/2 + ALPHA * ((S7-1)/2) + M_PI;
|
||||
|
||||
if(AT46 && !purehepta)
|
||||
hexshift = ALPHA/2 + ALPHA * ((S7-1)/2) + M_PI;
|
||||
|
||||
finish:
|
||||
|
||||
printf("hexf = " LDF" hcross = " LDF" tessf = " LDF"\n", hexf, hcrossf, tessf);
|
||||
|
||||
for(int i=0; i<S42; i++)
|
||||
Crad[i] = spin(2*M_PI*i/S42) * xpush(.4) * C0;
|
||||
for(int d=0; d<S7; d++)
|
||||
heptmove[d] = spin(-d * ALPHA) * xpush(tessf) * spin(M_PI);
|
||||
|
||||
hexshift = 0;
|
||||
if(AT8 && !purehepta)
|
||||
hexshift = ALPHA/2 + ALPHA * ((S7-1)/2) + M_PI;
|
||||
|
||||
for(int d=0; d<S7; d++)
|
||||
hexmove[d] = spin(hexshift-d * ALPHA) * xpush(-crossf)* spin(M_PI);
|
||||
|
||||
|
||||
81
graph.cpp
81
graph.cpp
@ -20,8 +20,6 @@ purehookset hooks_frame;
|
||||
#define BTOFF 0x404040
|
||||
#define BTON 0xC0C000
|
||||
|
||||
#define K(c) (c->type==6?0:1)
|
||||
|
||||
// #define PANDORA
|
||||
|
||||
int colorbar;
|
||||
@ -154,6 +152,17 @@ void drawSpeed(const transmatrix& V) {
|
||||
}
|
||||
}
|
||||
|
||||
int ctof(cell *c) {
|
||||
if(purehepta) return 1;
|
||||
// if(euclid) return 0;
|
||||
return ishept(c) ? 1 : 0;
|
||||
// c->type == 6 ? 0 : 1;
|
||||
}
|
||||
|
||||
int ctof012(cell *c) {
|
||||
return ishept(c)?1:ishex1(c)?0:2;
|
||||
}
|
||||
|
||||
void drawSafety(const transmatrix& V, int ct) {
|
||||
ld ds = ticks / 50.;
|
||||
int col = darkena(iinf[itOrbSafety].color, 0, 0xFF);
|
||||
@ -211,7 +220,7 @@ int displaydir(cell *c, int d) {
|
||||
if(euclid)
|
||||
return - d * S84 / c->type;
|
||||
else
|
||||
return (c->type != 6 ? -hexshift:0) + S42 - d * S84 / c->type;
|
||||
return (ctof(c) ? -hexshift:0) + S42 - d * S84 / c->type;
|
||||
}
|
||||
|
||||
transmatrix ddspin(cell *c, int d, int bonus) {
|
||||
@ -231,8 +240,6 @@ void drawPlayerEffects(const transmatrix& V, cell *c, bool onplayer) {
|
||||
|
||||
if(items[itOrbSpeed]) drawSpeed(V);
|
||||
|
||||
int ct = c->type;
|
||||
|
||||
if(onplayer && (items[itOrbSword] || items[itOrbSword2])) {
|
||||
using namespace sword;
|
||||
|
||||
@ -270,7 +277,7 @@ void drawPlayerEffects(const transmatrix& V, cell *c, bool onplayer) {
|
||||
}
|
||||
}
|
||||
|
||||
if(onplayer && items[itOrbSafety]) drawSafety(V, ct);
|
||||
if(onplayer && items[itOrbSafety]) drawSafety(V, c->type);
|
||||
|
||||
if(onplayer && items[itOrbFlash]) drawFlash(V);
|
||||
if(onplayer && items[itOrbLove]) drawLove(V, 0); // displaydir(c, cwt.spin));
|
||||
@ -500,7 +507,7 @@ bool drawstar(cell *c) {
|
||||
|
||||
bool drawItemType(eItem it, cell *c, const transmatrix& V, int icol, int ticks, bool hidden) {
|
||||
char xch = iinf[it].glyph;
|
||||
int ct6 = c ? c->type != 6 : 1;
|
||||
int ct6 = c ? ctof(c) : 1;
|
||||
hpcshape *xsh =
|
||||
(it == itPirate || it == itKraken) ? &shPirateX :
|
||||
(it == itBuggy || it == itBuggy2) ? &shPirateX :
|
||||
@ -1706,8 +1713,8 @@ bool drawMonster(const transmatrix& Vparam, int ct, cell *c, int col) {
|
||||
|
||||
if(mmmon) {
|
||||
if(isIvy(c) || isMutantIvy(c) || c->monst == moFriendlyIvy) {
|
||||
queuepoly(mmscale(Vb, geom3::ABODY), shILeaf[K(c)], darkena(col, 0, 0xFF));
|
||||
ShadowV(Vb, shILeaf[K(c)], PPR_GIANTSHADOW);
|
||||
queuepoly(mmscale(Vb, geom3::ABODY), shILeaf[ctof(c)], darkena(col, 0, 0xFF));
|
||||
ShadowV(Vb, shILeaf[ctof(c)], PPR_GIANTSHADOW);
|
||||
}
|
||||
else if(m == moWorm || m == moWormwait || m == moHexSnake) {
|
||||
Vb = Vb * pispin;
|
||||
@ -2150,7 +2157,7 @@ void drawTowerFloor(const transmatrix& V, cell *c, int col, cellfunction *cf = c
|
||||
if(j >= 0)
|
||||
qfloor(c, V, applyDowndir(c, cf), shTower[j], col);
|
||||
else if(c->wall != waLadder)
|
||||
qfloor(c, V, shMFloor[K(c)], col);
|
||||
qfloor(c, V, shMFloor[ctof(c)], col);
|
||||
}
|
||||
|
||||
void drawZebraFloor(const transmatrix& V, cell *c, int col) {
|
||||
@ -2226,7 +2233,7 @@ void drawReptileFloor(const transmatrix& V, cell *c, int col, bool usefloor) {
|
||||
if(wmescher)
|
||||
queuepoly(V2, shReptile[j][1], dcol);
|
||||
else
|
||||
queuepoly(V2, shMFloor[c->type!=6], dcol);
|
||||
queuepoly(V2, shMFloor[ctof(c)], dcol);
|
||||
}
|
||||
|
||||
if(ecol != -1) {
|
||||
@ -2253,7 +2260,7 @@ void drawEmeraldFloor(const transmatrix& V, cell *c, int col) {
|
||||
if(j >= 0)
|
||||
qfloor(c, V, applyPatterndir(c, 'f'), shEmeraldFloor[j], col);
|
||||
else
|
||||
qfloor(c, V, shCaveFloor[euclid?2:K(c)], col);
|
||||
qfloor(c, V, shCaveFloor[euclid?2:ctof(c)], col);
|
||||
}
|
||||
|
||||
double fanframe;
|
||||
@ -2790,13 +2797,13 @@ void floorShadow(cell *c, const transmatrix& V, int col, bool warp) {
|
||||
if(ishex1(c))
|
||||
queuepolyat(V * pispin * applyPatterndir(c), shTriheptaEucShadow[0], col, PPR_WALLSHADOW);
|
||||
else
|
||||
queuepolyat(V * applyPatterndir(c), shTriheptaEucShadow[ishept(c)?1:0], col, PPR_WALLSHADOW);
|
||||
queuepolyat(V * applyPatterndir(c), shTriheptaEucShadow[ctof(c)], col, PPR_WALLSHADOW);
|
||||
}
|
||||
else
|
||||
queuepolyat(V * applyPatterndir(c), shTriheptaFloorShadow[ishept(c)?1:0], col, PPR_WALLSHADOW);
|
||||
queuepolyat(V * applyPatterndir(c), shTriheptaFloorShadow[ctof(c)], col, PPR_WALLSHADOW);
|
||||
}
|
||||
else {
|
||||
queuepolyat(V, shFloorShadow[c->type==6?0:1], col, PPR_WALLSHADOW);
|
||||
queuepolyat(V, shFloorShadow[ctof(c)], col, PPR_WALLSHADOW);
|
||||
}
|
||||
}
|
||||
|
||||
@ -2806,13 +2813,13 @@ void plainfloor(cell *c, bool warp, const transmatrix &V, int col, int prio) {
|
||||
if(ishex1(c))
|
||||
queuepolyat(V * pispin * applyPatterndir(c), shTriheptaEuc[0], col, prio);
|
||||
else
|
||||
queuepolyat(V * applyPatterndir(c), shTriheptaEuc[ishept(c)?1:0], col, prio);
|
||||
queuepolyat(V * applyPatterndir(c), shTriheptaEuc[ctof(c)], col, prio);
|
||||
}
|
||||
else
|
||||
queuepolyat(V * applyPatterndir(c), shTriheptaFloor[sphere ? 6-c->type : mapeditor::nopattern(c)], col, prio);
|
||||
queuepolyat(V * applyPatterndir(c), shTriheptaFloor[sphere ? ctof(c) : mapeditor::nopattern(c)], col, prio);
|
||||
}
|
||||
else {
|
||||
queuepolyat(V, shFloor[c->type==6?0:1], col, prio);
|
||||
queuepolyat(V, shFloor[ctof(c)], col, prio);
|
||||
}
|
||||
}
|
||||
|
||||
@ -2822,13 +2829,13 @@ void fullplainfloor(cell *c, bool warp, const transmatrix &V, int col, int prio)
|
||||
if(ishex1(c))
|
||||
queuepolyat(V * pispin * applyPatterndir(c), shTriheptaEuc[0], col, prio);
|
||||
else
|
||||
queuepolyat(V * applyPatterndir(c), shTriheptaEuc[ishept(c)?1:0], col, prio);
|
||||
queuepolyat(V * applyPatterndir(c), shTriheptaEuc[ctof(c)], col, prio);
|
||||
}
|
||||
else
|
||||
queuepolyat(V * applyPatterndir(c), shTriheptaFloor[sphere ? 6-c->type : mapeditor::nopattern(c)], col, prio);
|
||||
queuepolyat(V * applyPatterndir(c), shTriheptaFloor[sphere ? ctof(c) : mapeditor::nopattern(c)], col, prio);
|
||||
}
|
||||
else {
|
||||
queuepolyat(V, shFullFloor[c->type==6?0:1], col, prio);
|
||||
queuepolyat(V, shFullFloor[ctof(c)], col, prio);
|
||||
}
|
||||
}
|
||||
|
||||
@ -2838,13 +2845,13 @@ void qplainfloor(cell *c, bool warp, const transmatrix &V, int col) {
|
||||
if(ishex1(c))
|
||||
qfloor(c, V, pispin * applyPatterndir(c), shTriheptaEuc[0], col);
|
||||
else
|
||||
qfloor(c, V, applyPatterndir(c), shTriheptaEuc[ishept(c)?1:0], col);
|
||||
qfloor(c, V, applyPatterndir(c), shTriheptaEuc[ctof(c)], col);
|
||||
}
|
||||
else
|
||||
qfloor(c, V, applyPatterndir(c), shTriheptaFloor[sphere ? 6-c->type : mapeditor::nopattern(c)], col);
|
||||
qfloor(c, V, applyPatterndir(c), shTriheptaFloor[sphere ? ctof(c) : mapeditor::nopattern(c)], col);
|
||||
}
|
||||
else {
|
||||
qfloor(c, V, shFloor[c->type==6?0:1], col);
|
||||
qfloor(c, V, shFloor[ctof(c)], col);
|
||||
}
|
||||
}
|
||||
|
||||
@ -2919,7 +2926,7 @@ void placeSidewall(cell *c, int i, int sidepar, const transmatrix& V, bool warp,
|
||||
// prio += c->cpdist - c->mov[i]->cpdist;
|
||||
|
||||
queuepolyat(V2,
|
||||
(mirr?shMFloorSide:warp?shTriheptaSide:shFloorSide)[sidepar][c->type==6?0:1], col, prio);
|
||||
(mirr?shMFloorSide:warp?shTriheptaSide:shFloorSide)[sidepar][ctof(c)], col, prio);
|
||||
}
|
||||
|
||||
bool openorsafe(cell *c) {
|
||||
@ -3353,8 +3360,8 @@ void drawcell(cell *c, transmatrix V, int spinv, bool mirrored) {
|
||||
}
|
||||
}
|
||||
|
||||
int ct = c->type;
|
||||
int ct6 = K(c);
|
||||
int ctype = c->type;
|
||||
int ct6 = ctof(c);
|
||||
|
||||
bool error = false;
|
||||
|
||||
@ -3419,9 +3426,9 @@ void drawcell(cell *c, transmatrix V, int spinv, bool mirrored) {
|
||||
|
||||
else if(mapeditor::whichShape == '8') {
|
||||
if(euclid)
|
||||
qfloor(c, Vf, shTriheptaEuc[ishept(c) ? 1 : ishex1(c) ? 0 : 2], darkena(fcol, fd, 0xFF));
|
||||
qfloor(c, Vf, shTriheptaEuc[ctof012(c)], darkena(fcol, fd, 0xFF));
|
||||
else
|
||||
qfloor(c, Vf, shTriheptaFloor[ishept(c) ? 1 : 0], darkena(fcol, fd, 0xFF));
|
||||
qfloor(c, Vf, shTriheptaFloor[ctof(c)], darkena(fcol, fd, 0xFF));
|
||||
}
|
||||
|
||||
else if(mapeditor::whichShape == '6') {
|
||||
@ -3558,7 +3565,7 @@ void drawcell(cell *c, transmatrix V, int spinv, bool mirrored) {
|
||||
}
|
||||
|
||||
else if(isWarped(c) && euclid)
|
||||
qfloor(c, Vf, shTriheptaEuc[ishept(c)?1:ishex1(c)?0:2], darkena(fcol, fd, 0xFF));
|
||||
qfloor(c, Vf, shTriheptaEuc[ctof012(c)], darkena(fcol, fd, 0xFF));
|
||||
|
||||
else if(isWarped(c) && !purehepta && !shmup::on) {
|
||||
int np = mapeditor::nopattern(c);
|
||||
@ -3597,7 +3604,7 @@ void drawcell(cell *c, transmatrix V, int spinv, bool mirrored) {
|
||||
case 11: qfloor(c, Vf, shPowerFloor[ct6], dfcol); break;
|
||||
case 12: qfloor(c, Vf, shDesertFloor[ct6], dfcol); break;
|
||||
case 13: qfloor(c, Vf, purehepta ? shChargedFloor[3] : shChargedFloor[ct6], dfcol); break;
|
||||
case 14: qfloor(c, Vf, ct==6?shChargedFloor[2]:shFloor[1], dfcol); break;
|
||||
case 14: qfloor(c, Vf, ct6?shFloor[1]:shChargedFloor[2], dfcol); break;
|
||||
}
|
||||
}
|
||||
|
||||
@ -3636,9 +3643,11 @@ void drawcell(cell *c, transmatrix V, int spinv, bool mirrored) {
|
||||
|
||||
else if(c->land == laRlyeh)
|
||||
qfloor(c, Vf, (eoh ? shFloor: shTriFloor)[ct6], darkena(fcol, fd, 0xFF));
|
||||
// qfloor(c, Vf, shTriFloor[ct6], darkena(fcol, fd, 0xFF));
|
||||
|
||||
else if(c->land == laTemple)
|
||||
qfloor(c, Vf, (eoh ? shFloor: shTriFloor)[ct6], darkena(fcol, fd, 0xFF));
|
||||
// qfloor(c, Vf, (eoh ? shFloor: shTriFloor)[ct6], darkena(fcol, fd, 0xFF));
|
||||
qfloor(c, Vf, shTriFloor[ct6], darkena(fcol, fd, 0xFF));
|
||||
|
||||
/* else if(c->land == laAlchemist)
|
||||
qfloor(c, Vf, shCloudFloor[ct6], darkena(fcol, fd, 0xFF)); */
|
||||
@ -3707,7 +3716,7 @@ void drawcell(cell *c, transmatrix V, int spinv, bool mirrored) {
|
||||
qfloor(c, ishex1(c) ? V*pispin : Vf,
|
||||
ishept(c) ? shFloor[0] : shChargedFloor[2], darkena(fcol, fd, 0xFF));
|
||||
else
|
||||
qfloor(c, Vf, (purehepta ? shChargedFloor[3] : ct==6 ? shChargedFloor[2] : shFloor[1]), darkena(fcol, fd, 0xFF));
|
||||
qfloor(c, Vf, (purehepta ? shChargedFloor[3] : ct6 ? shFloor[1] : shChargedFloor[2]), darkena(fcol, fd, 0xFF));
|
||||
}
|
||||
|
||||
else if(c->land == laWildWest)
|
||||
@ -3957,7 +3966,7 @@ void drawcell(cell *c, transmatrix V, int spinv, bool mirrored) {
|
||||
|
||||
else if(c->wall == waClosePlate || c->wall == waOpenPlate || (c->wall == waTrapdoor && c->land != laZebra)) {
|
||||
transmatrix V2 = V;
|
||||
if(ct != 6 && wmescher) V2 = V * pispin;
|
||||
if((ctype&1) && wmescher) V2 = V * pispin;
|
||||
queuepoly(V2, shMFloor[ct6], darkena(winf[c->wall].color, 0, 0xFF));
|
||||
queuepoly(V2, shMFloor2[ct6], (!wmblack) ? darkena(fcol, 1, 0xFF) : darkena(0,1,0xFF));
|
||||
}
|
||||
@ -4303,7 +4312,7 @@ void drawcell(cell *c, transmatrix V, int spinv, bool mirrored) {
|
||||
|
||||
if(true) {
|
||||
int q = ptds.size();
|
||||
error |= drawMonster(V, ct, c, moncol);
|
||||
error |= drawMonster(V, ctype, c, moncol);
|
||||
if(Vboat != &V && Vboat != &Vboat0 && q != size(ptds))
|
||||
pushdown(c, q, V, -geom3::factor_to_lev(zlevel(tC0((*Vboat)))),
|
||||
!isMultitile(c->monst), false);
|
||||
@ -4475,7 +4484,7 @@ void drawcell(cell *c, transmatrix V, int spinv, bool mirrored) {
|
||||
queuecircle(V, .78, 0x00FFFFFF);
|
||||
}
|
||||
|
||||
mapeditor::drawGhosts(c, V, ct);
|
||||
mapeditor::drawGhosts(c, V, ctype);
|
||||
#endif
|
||||
}
|
||||
|
||||
|
||||
107
heptagon.cpp
107
heptagon.cpp
@ -88,6 +88,13 @@ hstate transition(hstate s, int dir) {
|
||||
if(s == hsB0 && dir == S7-2) return hsC;
|
||||
return hsError;
|
||||
}
|
||||
else if(AT456) {
|
||||
if(s == hsOrigin) return hsA;
|
||||
if(s == hsA && (dir >= 2 && dir < S7-1)) return hsA;
|
||||
if(s == hsA && (dir == S7-1)) return hsB;
|
||||
if(s == hsB && (dir >= 2 && dir < S7-2)) return hsA;
|
||||
if(s == hsB && (dir == S7-2)) return hsB;
|
||||
}
|
||||
else {
|
||||
if(s == hsOrigin) return hsA;
|
||||
if(s == hsA && dir >= 3 && dir <= S7-3) return hsA;
|
||||
@ -125,7 +132,7 @@ heptagon *buildHeptagon(heptagon *parent, int d, hstate s, int pard = 0) {
|
||||
if(parent->c7) {
|
||||
h->c7 = newCell(S7, h);
|
||||
h->rval0 = h->rval1 = 0; h->cdata = NULL;
|
||||
if(!AT8) {
|
||||
if(!AT8 && !AT456) {
|
||||
h->emeraldval = emerald_heptagon(parent->emeraldval, d);
|
||||
h->zebraval = zebra_heptagon(parent->zebraval, d);
|
||||
h->fieldval = fp43.connections[fieldpattern::btspin(parent->fieldval, d)];
|
||||
@ -159,45 +166,28 @@ heptagon *buildHeptagon(heptagon *parent, int d, hstate s, int pard = 0) {
|
||||
return h;
|
||||
}
|
||||
|
||||
void connectHeptagons(heptagon *h1, int d1, heptagon *h2, int d2) {
|
||||
h1->move[d1] = h2;
|
||||
h1->setspin(d1, d2);
|
||||
h2->move[d2] = h1;
|
||||
h2->setspin(d2, d1);
|
||||
}
|
||||
|
||||
void addSpin(heptagon *h, int d, heptagon *from, int rot, int spin) {
|
||||
rot = fixrot(rot);
|
||||
createStep(from, rot);
|
||||
h->move[d] = from->move[rot];
|
||||
h->setspin(d, fixrot(from->spin(rot) + spin));
|
||||
h->move[d]->move[fixrot(from->spin(rot) + spin)] = h;
|
||||
h->move[d]->setspin(fixrot(from->spin(rot) + spin), d);
|
||||
int fr = fixrot(from->spin(rot) + spin);
|
||||
connectHeptagons(h, d, from->move[rot], fr);
|
||||
/* h->move[d] = from->move[rot];
|
||||
h->setspin(d, fr);
|
||||
h->move[d]->move[fr] = h;
|
||||
h->move[d]->setspin(fr, d); */
|
||||
//generateEmeraldval(h->move[d]); generateEmeraldval(h);
|
||||
}
|
||||
|
||||
extern int hrand(int);
|
||||
|
||||
heptagon *createStep(heptagon *h, int d) {
|
||||
d = fixrot(d);
|
||||
if(!h->move[0] && h->s != hsOrigin) {
|
||||
buildHeptagon(h, 0, hsA, 3 + hrand(2));
|
||||
}
|
||||
if(h->move[d]) return h->move[d];
|
||||
if(h->s == hsOrigin) {
|
||||
buildHeptagon(h, d, hsA);
|
||||
}
|
||||
else if(d == 1) {
|
||||
addSpin(h, d, h->move[0], h->spin(0)-1, -1);
|
||||
}
|
||||
else if(d == S7-1) {
|
||||
addSpin(h, d, h->move[0], h->spin(0)+1, +1);
|
||||
}
|
||||
else if(d == 2) {
|
||||
createStep(h->move[0], h->spin(0)-1);
|
||||
addSpin(h, d, h->move[0]->modmove(h->spin(0)-1), S7-2 + h->move[0]->gspin(h->spin(0)-1), -1);
|
||||
}
|
||||
else if(d == S7-2 && h->s == hsB) {
|
||||
createStep(h->move[0], h->spin(0)+1);
|
||||
addSpin(h, d, h->move[0]->modmove(h->spin(0)+1), 2 + h->move[0]->gspin(h->spin(0)+1), +1);
|
||||
}
|
||||
else
|
||||
buildHeptagon(h, d, (d == S7-2 || (h->s == hsB && d == S7-3)) ? hsB : hsA);
|
||||
return h->move[d];
|
||||
}
|
||||
heptagon *createStep(heptagon *h, int d);
|
||||
|
||||
// a structure used to walk on the heptagonal tesselation
|
||||
// (remembers not only the heptagon, but also direction)
|
||||
@ -225,6 +215,58 @@ heptspin hsspin(const heptspin &hs, int val) {
|
||||
return res;
|
||||
}
|
||||
|
||||
heptagon *createStep(heptagon *h, int d) {
|
||||
d = fixrot(d);
|
||||
if(!h->move[0] && h->s != hsOrigin) {
|
||||
buildHeptagon(h, 0, hsA, 3 + hrand(2));
|
||||
}
|
||||
if(h->move[d]) return h->move[d];
|
||||
if(h->s == hsOrigin) {
|
||||
buildHeptagon(h, d, hsA);
|
||||
}
|
||||
else if(AT456) {
|
||||
if(d == 1) {
|
||||
heptspin hs;
|
||||
hs.h = h;
|
||||
hs.spin = 0;
|
||||
hs.mirrored = false;
|
||||
hs = hsstep(hs, -1);
|
||||
hs = hsstep(hs, -1);
|
||||
hs = hsstep(hs, -1);
|
||||
connectHeptagons(h, d, hs.h, hs.spin);
|
||||
}
|
||||
else if(h->s == hsB && d == S7-1) {
|
||||
heptspin hs;
|
||||
hs.h = h;
|
||||
hs.spin = 0;
|
||||
hs.mirrored = false;
|
||||
hs = hsstep(hs, 1);
|
||||
hs = hsstep(hs, 1);
|
||||
hs = hsstep(hs, 1);
|
||||
connectHeptagons(h, d, hs.h, hs.spin);
|
||||
}
|
||||
else
|
||||
buildHeptagon(h, d, transition(h->s, d));
|
||||
}
|
||||
else if(d == 1) {
|
||||
addSpin(h, d, h->move[0], h->spin(0)-1, -1);
|
||||
}
|
||||
else if(d == S7-1) {
|
||||
addSpin(h, d, h->move[0], h->spin(0)+1, +1);
|
||||
}
|
||||
else if(d == 2) {
|
||||
createStep(h->move[0], h->spin(0)-1);
|
||||
addSpin(h, d, h->move[0]->modmove(h->spin(0)-1), S7-2 + h->move[0]->gspin(h->spin(0)-1), -1);
|
||||
}
|
||||
else if(d == S7-2 && h->s == hsB) {
|
||||
createStep(h->move[0], h->spin(0)+1);
|
||||
addSpin(h, d, h->move[0]->modmove(h->spin(0)+1), 2 + h->move[0]->gspin(h->spin(0)+1), +1);
|
||||
}
|
||||
else
|
||||
buildHeptagon(h, d, (d == S7-2 || (h->s == hsB && d == S7-3)) ? hsB : hsA);
|
||||
return h->move[d];
|
||||
}
|
||||
|
||||
// display the coordinates of the heptagon
|
||||
void backtrace(heptagon *pos) {
|
||||
if(pos->s == hsOrigin) return;
|
||||
@ -236,3 +278,4 @@ void hsshow(const heptspin& t) {
|
||||
printf("ORIGIN"); backtrace(t.h); printf(" (spin %d)\n", t.spin);
|
||||
}
|
||||
|
||||
|
||||
@ -1,7 +1,7 @@
|
||||
// Hyperbolic Rogue
|
||||
// Copyright (C) 2011-2012 Zeno Rogue, see 'hyper.cpp' for details
|
||||
|
||||
enum eGeometry {gNormal, gEuclid, gSphere, gElliptic, gQuotient, gQuotient2, gTorus, gOctagon, gGUARD};
|
||||
enum eGeometry {gNormal, gEuclid, gSphere, gElliptic, gQuotient, gQuotient2, gTorus, gOctagon, g45, g46, gGUARD};
|
||||
eGeometry geometry, targetgeometry = gEuclid;
|
||||
#define euclid (geometry == gEuclid || geometry == gTorus)
|
||||
#define sphere (geometry == gSphere || geometry == gElliptic)
|
||||
|
||||
14
init.cpp
14
init.cpp
@ -326,14 +326,22 @@ const char *loadlevel = NULL;
|
||||
#endif
|
||||
|
||||
#define AT8 (geometry == gOctagon ? 1 : 0)
|
||||
#define AT45 (geometry == g45 ? 1 : 0)
|
||||
#define AT46 (geometry == g46 ? 1 : 0)
|
||||
#define AT456 (AT45 | AT46)
|
||||
#define AT4568 (AT45 | AT46 | AT8)
|
||||
|
||||
#define S7 (sphere?5:AT8?8:7)
|
||||
#define S42 (S7*6)
|
||||
#define S7 (sphere?5:AT45?5:AT46?6:AT8?8:euclid?6:7)
|
||||
#define S6 (AT456 ? 8 : 6)
|
||||
#define S42 (S7*S6)
|
||||
#define S12 (S6*2)
|
||||
#define S14 (S7*2)
|
||||
#define S21 (S7*3)
|
||||
#define S28 (S7*4)
|
||||
#define S84 (S7*12)
|
||||
#define S36 (S6*6)
|
||||
#define S84 (S7*S6*2)
|
||||
#define MAX_EDGE 8
|
||||
#define MAX_S84 240
|
||||
|
||||
#include "util.cpp"
|
||||
#include "hyperpoint.cpp"
|
||||
|
||||
@ -555,17 +555,18 @@ void showChangeMode() {
|
||||
int eupage = 0;
|
||||
int euperpage = 21;
|
||||
|
||||
#define LAND_SPHEUC ((targetgeometry == gOctagon) ? LAND_OCT : (targetgeometry > 1) ? LAND_SPH : LAND_EUC)
|
||||
#define land_spheuc ((targetgeometry == gOctagon) ? land_oct : (targetgeometry > 1) ? land_sph : land_euc)
|
||||
#define LAND_SPHEUC ((AT4568) ? LAND_OCT : (targetgeometry > 1) ? LAND_SPH : LAND_EUC)
|
||||
#define land_spheuc ((AT4568) ? land_oct : (targetgeometry > 1) ? land_sph : land_euc)
|
||||
|
||||
const char* geometrynames[gGUARD] = {
|
||||
"hyperbolic", "Euclidean", "spherical", "elliptic",
|
||||
"Zebra quotient", "field quotient", "torus", "octagons"
|
||||
"Zebra quotient", "field quotient", "torus", "octagons",
|
||||
"four pentagons", "four hexagons"
|
||||
};
|
||||
|
||||
const char* geometrynames_short[gGUARD] = {
|
||||
"hyper", "Euclid", "sphere", "elliptic",
|
||||
"Zebra", "field", "torus", "oct"
|
||||
"Zebra", "field", "torus", "oct", "4,5", "4,6"
|
||||
};
|
||||
|
||||
void showEuclideanMenu() {
|
||||
|
||||
84
polygons.cpp
84
polygons.cpp
@ -881,18 +881,23 @@ void buildpolys() {
|
||||
|
||||
// scales
|
||||
scalef = purehepta ? crossf / hcrossf7 : hcrossf / hcrossf7;
|
||||
double scalef2 = purehepta ? crossf / hcrossf7 * .88 : hcrossf / hcrossf7;
|
||||
double scalef2 = purehepta ? crossf / hcrossf7 * .88 : euclid ? 1 : hcrossf / hcrossf7;
|
||||
|
||||
double spzoom = sphere ? 1.4375 : 1;
|
||||
|
||||
double spzoom6 = sphere ? 1.2375 : 1;
|
||||
double spzoom7 = sphere ? .8 : 1;
|
||||
double spzoomd7 = (purehepta && sphere) ? 1 : spzoom7;
|
||||
|
||||
double fac80 = AT45 ? 1.4 : AT46 ? 1.2 : .8;
|
||||
double fac94 = euclid ? .8 : AT456 ? (purehepta ? 1.1 : .9) : .94;
|
||||
|
||||
auto MF = [] (double f, int i) { return (f*i)/8; };
|
||||
|
||||
#define SHADMUL 1.3
|
||||
|
||||
// procedural floors
|
||||
double shexf = purehepta ? crossf* .55 : hexf;
|
||||
double shexf = purehepta ? crossf* .55 : hexf;
|
||||
|
||||
double p = -.006;
|
||||
|
||||
@ -917,16 +922,18 @@ void buildpolys() {
|
||||
for(int t=0; t<=S7; t++) hpcpush(ddi(t*12, x) * C0);
|
||||
}
|
||||
|
||||
int td = (AT8 && purehepta) ? S42+6 : 0;
|
||||
int td = ((purehepta || euclid) && !(S7&1)) ? S42+S6 : 0;
|
||||
|
||||
bool strict = false;
|
||||
|
||||
bshape(shFloor[0], PPR_FLOOR);
|
||||
for(int t=0; t<=6; t++) hpcpush(ddi(S7 + t*S14, shexf*.8*spzoom) * C0);
|
||||
for(int t=0; t<=S6; t++) hpcpush(ddi(S7 + t*S14, shexf*fac80*spzoom) * C0);
|
||||
|
||||
bshape(shCircleFloor, PPR_FLOOR);
|
||||
for(int t=0; t<=84; t+=2) hpcpush(ddi(t, shexf*.7*spzoom) * C0);
|
||||
|
||||
bshape(shFloor[1], PPR_FLOOR);
|
||||
for(int t=0; t<=S7; t++) hpcpush(ddi(t*12 + td, shexf*.94) * C0);
|
||||
for(int t=0; t<=S7; t++) hpcpush(ddi(t*S12 + td, strict ? hcrossf : euclid ? shexf*fac80*spzoom : shexf*fac94) * C0);
|
||||
|
||||
for(int i=0; i<3; i++) for(int j=0; j<3; j++) shadowmulmatrix[i][j] =
|
||||
i==2&&j==2 ? 1:
|
||||
@ -934,10 +941,10 @@ void buildpolys() {
|
||||
0;
|
||||
|
||||
bshape(shFloorShadow[0], PPR_FLOOR);
|
||||
for(int t=0; t<=6; t++) hpcpush(ddi(S7 + t*S14, shexf*.8*spzoom*SHADMUL) * C0);
|
||||
for(int t=0; t<=6; t++) hpcpush(ddi(S7 + t*S14, shexf*fac80*spzoom*SHADMUL) * C0);
|
||||
|
||||
bshape(shFloorShadow[1], PPR_FLOOR);
|
||||
for(int t=0; t<=S7; t++) hpcpush(ddi(t*12, shexf*.94*SHADMUL) * C0);
|
||||
for(int t=0; t<=S7; t++) hpcpush(ddi(t*12, shexf*fac94*SHADMUL) * C0);
|
||||
|
||||
// sidewalls for the 3D mode
|
||||
for(int k=0; k<SIDEPARS; k++) {
|
||||
@ -952,15 +959,15 @@ void buildpolys() {
|
||||
validsidepar[k] = (dlow > 0 && dhi > 0) || (dlow < 0 && dhi < 0);
|
||||
|
||||
bshape(shFloorSide[k][0], PPR_LAKEWALL);
|
||||
for(int t=0; t<=1; t++) hpcpush(ddi(t*S14-S7, shexf*.8*spzoom) * C0);
|
||||
for(int t=0; t<=1; t++) hpcpush(ddi(t*S14-S7, shexf*fac80*spzoom) * C0);
|
||||
chasmifyPoly(dlow, dhi, k);
|
||||
|
||||
bshape(shFloorSide[k][1], PPR_LAKEWALL);
|
||||
for(int t=0; t<=1; t++) hpcpush(ddi(t*12-6, shexf*.94) * C0);
|
||||
for(int t=0; t<=1; t++) hpcpush(ddi(t*12-6, shexf*fac94) * C0);
|
||||
chasmifyPoly(dlow, dhi, k);
|
||||
|
||||
bshape(shSemiFloorSide[k], PPR_LAKEWALL);
|
||||
for(int t=0; t<=3; t+=3) hpcpush(ddi(S7 + (3+t)*S14, shexf*.8*spzoom) * C0);
|
||||
for(int t=0; t<=3; t+=3) hpcpush(ddi(S7 + (3+t)*S14, shexf*fac80*spzoom) * C0);
|
||||
chasmifyPoly(dlow, dhi, k);
|
||||
|
||||
bshape(shTriheptaSide[k][0], PPR_LAKEWALL);
|
||||
@ -972,42 +979,42 @@ void buildpolys() {
|
||||
chasmifyPoly(dlow, dhi, k);
|
||||
|
||||
bshape(shMFloorSide[k][0], PPR_LAKEWALL);
|
||||
for(int t=0; t<=1; t++) hpcpush(ddi(t*S14-S7, shexf*.7*spzoom) * C0);
|
||||
for(int t=0; t<=1; t++) hpcpush(ddi(t*S14-S7, shexf*MF(fac80,7)*spzoom) * C0);
|
||||
chasmifyPoly(dlow, dhi, k);
|
||||
|
||||
bshape(shMFloorSide[k][1], PPR_LAKEWALL);
|
||||
for(int t=0; t<=1; t++) hpcpush(ddi(t*12-6, shexf*.8) * C0);
|
||||
for(int t=0; t<=1; t++) hpcpush(ddi(t*12-6, shexf*MF(fac94,7)) * C0);
|
||||
chasmifyPoly(dlow, dhi, k);
|
||||
}
|
||||
|
||||
for(int d=0; d<2; d++) {
|
||||
bshape(shSemiFloor[d], PPR_FLOOR);
|
||||
for(int t=0; t<=4; t++) hpcpush(ddi(S7 + (3+3*d+t%4)*S14, shexf*.8*spzoom) * C0);
|
||||
for(int t=0; t<=4; t++) hpcpush(ddi(S7 + (3+3*d+t%4)*S14, shexf*fac80*spzoom) * C0);
|
||||
}
|
||||
|
||||
bshape(shMFloor[0], PPR_FLOORa);
|
||||
for(int t=0; t<=6; t++) hpcpush(ddi(S7 + t*S14, shexf*.7*spzoom) * C0);
|
||||
for(int t=0; t<=6; t++) hpcpush(ddi(S7 + t*S14, shexf*MF(fac80,7)*spzoom) * C0);
|
||||
|
||||
bshape(shMFloor[1], PPR_FLOORa);
|
||||
for(int t=0; t<=S7; t++) hpcpush(ddi(t*12, shexf*.8) * C0);
|
||||
for(int t=0; t<=S7; t++) hpcpush(ddi(t*12, shexf*MF(fac94,7)) * C0);
|
||||
|
||||
bshape(shMFloor2[0], PPR_FLOORb);
|
||||
for(int t=0; t<=6; t++) hpcpush(ddi(S7 + t*S14, shexf*.6*spzoom) * C0);
|
||||
bshape(shMFloor2[0], PPR_FLOORb);
|
||||
for(int t=0; t<=6; t++) hpcpush(ddi(S7 + t*S14, shexf*MF(fac80,6)*spzoom) * C0);
|
||||
|
||||
bshape(shMFloor2[1], PPR_FLOORb);
|
||||
for(int t=0; t<=S7; t++) hpcpush(ddi(t*12, shexf*.7) * C0);
|
||||
for(int t=0; t<=S7; t++) hpcpush(ddi(t*12, shexf*MF(fac94,6)) * C0);
|
||||
|
||||
bshape(shMFloor3[0], PPR_FLOORc);
|
||||
for(int t=0; t<=6; t++) hpcpush(ddi(S7 + t*S14, shexf*.5*spzoom) * C0);
|
||||
for(int t=0; t<=6; t++) hpcpush(ddi(S7 + t*S14, shexf*MF(fac80,5)*spzoom) * C0);
|
||||
|
||||
bshape(shMFloor3[1], PPR_FLOORc);
|
||||
for(int t=0; t<=S7; t++) hpcpush(ddi(t*12, shexf*.6) * C0);
|
||||
for(int t=0; t<=S7; t++) hpcpush(ddi(t*12, shexf*MF(fac94,5)) * C0);
|
||||
|
||||
bshape(shMFloor4[0], PPR_FLOORd);
|
||||
for(int t=0; t<=6; t++) hpcpush(ddi(S7 + t*S14, shexf*.4*spzoom) * C0);
|
||||
for(int t=0; t<=6; t++) hpcpush(ddi(S7 + t*S14, shexf*MF(fac80,4)*spzoom) * C0);
|
||||
|
||||
bshape(shMFloor4[1], PPR_FLOORd);
|
||||
for(int t=0; t<=S7; t++) hpcpush(ddi(t*12, shexf*.5) * C0);
|
||||
for(int t=0; t<=S7; t++) hpcpush(ddi(t*12, shexf*MF(fac94,4)) * C0);
|
||||
|
||||
bshape(shBigCarpet1, PPR_GFLOORa);
|
||||
//for(int t=0; t<=7; t++) hpcpush(ddi(t*12, -shexf*3.5) * C0);
|
||||
@ -1052,20 +1059,27 @@ void buildpolys() {
|
||||
|
||||
bshape(shMirror, PPR_WALL);
|
||||
if(purehepta) {
|
||||
for(int t=0; t<=S7; t++) hpcpush(ddi(t*12, shexf*.8) * C0);
|
||||
for(int t=0; t<=S7; t++) hpcpush(ddi(t*12, shexf*MF(fac80,7)) * C0);
|
||||
}
|
||||
else {
|
||||
for(int t=0; t<=6; t++) hpcpush(ddi(S7 + t*S14, shexf*.7) * C0);
|
||||
for(int t=0; t<=6; t++) hpcpush(ddi(S7 + t*S14, shexf*MF(fac94,7)) * C0);
|
||||
}
|
||||
|
||||
bshape(shWall[0], PPR_WALL);
|
||||
for(int t=0; t<=6; t++) {
|
||||
hpcpush(ddi(S7 + t*S14, shexf*.8) * C0);
|
||||
for(int t=0; t<=S6; t++) {
|
||||
hpcpush(ddi(S7 + t*S14, shexf*fac80) * C0);
|
||||
hpcpush(ddi(S14 + t*S14, shexf*.2) * C0);
|
||||
}
|
||||
|
||||
bshape(shWall[1], PPR_WALL);
|
||||
for(int t=0; t<=S7; t++) hpcpush(ddi(t*36+td, shexf*.94) * C0);
|
||||
if(S7 == 6) {
|
||||
for(int t=0; t<=S6; t++) {
|
||||
hpcpush(ddi(S7 + t*S14, shexf*fac80) * C0);
|
||||
hpcpush(ddi(S14 + t*S14, shexf*.2) * C0);
|
||||
}
|
||||
}
|
||||
else
|
||||
for(int t=0; t<=S7; t++) hpcpush(ddi(t*S36+td, shexf*fac94) * C0);
|
||||
|
||||
bshape(shCross, PPR_WALL);
|
||||
for(int i=0; i<=S84; i+=S7)
|
||||
@ -1074,13 +1088,20 @@ void buildpolys() {
|
||||
// items
|
||||
|
||||
bshape(shGem[0], PPR_ITEM);
|
||||
for(int t=0; t<=6; t++) {
|
||||
for(int t=0; t<=S6; t++) {
|
||||
hpcpush(ddi(S7 + t*S14, shexf*.4) * C0);
|
||||
hpcpush(ddi(S14 + t*S14, shexf*.1) * C0);
|
||||
}
|
||||
|
||||
bshape(shGem[1], PPR_ITEM);
|
||||
for(int t=0; t<=S7; t++) hpcpush(ddi(t*36, shexf*.5) * C0);
|
||||
if(S7 == 6) {
|
||||
for(int t=0; t<=S6; t++) {
|
||||
hpcpush(ddi(S7 + t*S14, shexf*.4) * C0);
|
||||
hpcpush(ddi(S14 + t*S14, shexf*.1) * C0);
|
||||
}
|
||||
}
|
||||
else
|
||||
for(int t=0; t<=S7; t++) hpcpush(ddi(t*S36, shexf*.5) * C0);
|
||||
|
||||
bshape(shStar, PPR_ITEM);
|
||||
for(int t=0; t<S84; t+=6) {
|
||||
@ -1292,7 +1313,10 @@ void buildpolys() {
|
||||
|
||||
// floors:
|
||||
bshape(shStarFloor[0], PPR_FLOOR, scalef2*spzoom6, 1);
|
||||
bshape(shStarFloor[1], PPR_FLOOR, scalef2*spzoomd7, 2, .9);
|
||||
if(euclid)
|
||||
bshape(shStarFloor[1], PPR_FLOOR, scalef2*spzoom6, 1);
|
||||
else
|
||||
bshape(shStarFloor[1], PPR_FLOOR, scalef2*spzoomd7, 2, .9);
|
||||
bshape(shCloudFloor[0], PPR_FLOOR, scalef2*spzoom6, 3);
|
||||
bshape(shCloudFloor[1], PPR_FLOOR, scalef2*spzoomd7, 4, .17);
|
||||
|
||||
|
||||
@ -103,7 +103,7 @@ void initgame() {
|
||||
if(isGravityLand(firstland) && !tactic::on) firstland = laCrossroads;
|
||||
|
||||
cwt.c = currentmap->gamestart(); cwt.spin = 0; cwt.mirrored = false;
|
||||
cwt.c->land = (euclid || sphere || AT8) ? specialland : firstland;
|
||||
cwt.c->land = (euclid || sphere || AT4568) ? specialland : firstland;
|
||||
|
||||
chaosAchieved = false;
|
||||
|
||||
|
||||
Loading…
Reference in New Issue
Block a user