mirrors/hyperrogue
1
0
Fork 0
mirror of https://github.com/zenorogue/hyperrogue.git synced 2024-06-27 07:33:19 +00:00
Code Issues Releases Wiki Activity

converted if sequences to case instructions

Browse Source
This commit is contained in:
Zeno Rogue 2018-02-05 01:17:11 +01:00
parent 6cc3177524
commit 6c5ce655bb
2 changed files with 673 additions and 597 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

687
graph.cpp
View File

@ -2938,15 +2938,71 @@ void setcolors(cell *c, int& wcol, int &fcol) {
/* if(c->land == laCaribbean && (c->wall == waCIsland || c->wall == waCIsland2))
fcol = wcol = winf[c->wall].color; */
switch(c->wall) {
case waSulphur: case waSulphurC: case waPlatform: case waMercury: case waDock:
case waAncientGrave: case waFreshGrave: case waThumperOn: case waThumperOff: case waBonfireOff:
case waRoundTable:
// floors become fcol
if(c->wall == waSulphur || c->wall == waSulphurC || c->wall == waPlatform || c->wall == waMercury || c->wall == waDock)
fcol = wcol;
break;
if(isAlch(c)) {
case waDeadTroll2: case waPetrifiedBridge: case waPetrified: {
eMonster m = eMonster(c->wparam);
if(c->wall == waPetrified || c->wall == waPetrifiedBridge)
wcol = gradient(wcol, minf[m].color, 0, .2, 1);
if(c->wall == waPetrified || isTroll(m)) if(!(m == moForestTroll && c->land == laOvergrown))
wcol = gradient(wcol, minf[m].color, 0, .4, 1);
break;
}
case waFloorA: case waFloorB: // isAlch
if(c->item && !(conformal::includeHistory && eq(c->aitmp, sval)))
fcol = wcol = iinf[c->item].color;
else
fcol = wcol;
break;
case waBoat:
if(wmascii) wcol = 0xC06000;
break;
case waEternalFire:
fcol = wcol = weakfirecolor(1500);
break;
case waFire: case waPartialFire: case waBurningDock:
fcol = wcol = firecolor(100);
break;
case waDeadfloor: case waCavefloor:
fcol = wcol;
break;
case waNone:
if(c->land == laNone)
wcol = fcol = 0x101010;
if(c->land == laHive)
wcol = fcol;
break;
case waMineUnknown: case waMineMine:
if(mineMarkedSafe(c))
fcol = wcol = gradient(wcol, 0x40FF40, 0, 0.2, 1);
else if(mineMarked(c))
fcol = wcol = gradient(wcol, 0xFF4040, -1, sin(ticks/100.0), 1);
// fallthrough
case waMineOpen:
fcol = wcol;
if(wmblack || wmascii) fcol >>= 1, wcol >>= 1;
break;
case waCavewall:
if(c->land != laEmerald) fcol = winf[waCavefloor].color;
break;
default:
break;
}
/* if(false && isAlch2(c, true)) {
@ -2958,38 +3014,6 @@ void setcolors(cell *c, int& wcol, int &fcol) {
fcol = wcol;
} */
if(c->wall == waDeadTroll2 || c->wall == waPetrified || c->wall == waPetrifiedBridge) {
eMonster m = eMonster(c->wparam);
if(c->wall == waPetrified || c->wall == waPetrifiedBridge)
wcol = gradient(wcol, minf[m].color, 0, .2, 1);
if(c->wall == waPetrified || isTroll(m)) if(!(m == moForestTroll && c->land == laOvergrown))
wcol = gradient(wcol, minf[m].color, 0, .4, 1);
}
if(c->land == laNone && c->wall == waNone)
wcol = fcol = 0x101010;
if(isFire(c))
fcol = wcol = c->wall == waEternalFire ? weakfirecolor(1500) : firecolor(100);
if(c->wall == waBoat && wmascii) {
wcol = 0xC06000;
}
if(mightBeMine(c) || c->wall == waMineOpen) {
fcol = wcol;
if(wmblack || wmascii) fcol >>= 1, wcol >>= 1;
}
if(c->wall == waAncientGrave || c->wall == waFreshGrave || c->wall == waThumperOn || c->wall == waThumperOff || c->wall == waBonfireOff)
fcol = wcol;
if(mightBeMine(c) && mineMarkedSafe(c))
fcol = wcol = gradient(wcol, 0x40FF40, 0, 0.2, 1);
if(mightBeMine(c) && mineMarked(c))
fcol = wcol = gradient(wcol, 0xFF4040, -1, sin(ticks/100.0), 1);
int rd = rosedist(c);
if(rd == 1)
wcol = gradient(0x804060, wcol, 0,1,3),
@ -3002,23 +3026,14 @@ void setcolors(cell *c, int& wcol, int &fcol) {
fcol = gradient(fcol, 0, 0, 25, 100),
wcol = gradient(wcol, 0, 0, 25, 100);
if(c->wall == waDeadfloor || c->wall == waCavefloor) fcol = wcol;
if(c->wall == waDeadwall) fcol = winf[waDeadfloor].color;
if(c->wall == waCavewall && c->land != laEmerald) fcol = winf[waCavefloor].color;
if(highwall(c) && !wmspatial)
fcol = wcol;
if(wmascii && (c->wall == waNone || isWatery(c))) wcol = fcol;
if(c->wall == waNone && c->land == laHive) wcol = fcol;
if(!wmspatial && snakelevel(c) && !realred(c->wall)) fcol = wcol;
if(c->wall == waGlass && !wmspatial) fcol = wcol;
if(c->wall == waRoundTable) fcol = wcol;
}
bool noAdjacentChasms(cell *c) {
@ -3373,6 +3388,78 @@ int getSnakelevColor(cell *c, int i, int last, int fd, int wcol) {
return darkena(col, fd, 0xFF);
}
void draw_wall(cell *c, const transmatrix& V, int wcol, int& zcol, int ct6, int fd) {
zcol = wcol;
int wcol0 = wcol;
int starcol = wcol;
if(c->wall == waWarpGate) starcol = 0;
if(c->wall == waVinePlant) starcol = 0x60C000;
int wcol2 = gradient(0, wcol0, 0, .8, 1);
if(c->wall == waClosedGate) {
int hdir = 0;
for(int i=0; i<c->type; i++) if(c->mov[i]->wall == waClosedGate)
hdir = i;
transmatrix V2 = mscale(V, wmspatial?geom3::WALL:1) * ddspin(c, hdir, S42);
queuepolyat(V2, shPalaceGate, darkena(wcol, 0, 0xFF), wmspatial?PPR_WALL3A:PPR_WALL);
starcol = 0;
}
hpcshape& shThisWall = isGrave(c->wall) ? shCross : shWall[ct6];
if(conegraph(c)) {
const int layers = 2 << detaillevel;
for(int z=1; z<layers; z++) {
double zg = zgrad0(0, geom3::wall_height, z, layers);
warpfloor(c, xyzscale(V, zg*(layers-z)/layers, zg),
darkena(gradient(0, wcol, -layers, z, layers), 0, 0xFF), PPR_WALL3+z-layers+2, isWarped(c));
}
floorShadow(c, V, SHADOW_WALL, isWarped(c));
}
else if(true) {
if(!wmspatial) {
if(starcol) queuepoly(V, shThisWall, darkena(starcol, 0, 0xFF));
}
else {
transmatrix Vdepth = mscale(V, geom3::WALL);
int alpha = 0xFF;
if(c->wall == waIcewall)
alpha = 0xC0;
bool warp = isWarped(c);
if(starcol && !(wmescher && c->wall == waPlatform))
queuepolyat(Vdepth, shThisWall, darkena(starcol, 0, 0xFF), PPR_WALL3A);
warpfloor(c, Vdepth, darkena(wcol0, fd, alpha), PPR_WALL3, warp);
floorShadow(c, V, SHADOW_WALL, warp);
if(c->wall == waCamelot) {
forCellIdEx(c2, i, c) {
placeSidewallX(c, i, SIDE_SLEV, V, warp, false, darkena(wcol2, fd, alpha));
}
forCellIdEx(c2, i, c) {
placeSidewallX(c, i, SIDE_SLEV+1, V, warp, false, darkena(wcol2, fd, alpha));
}
forCellIdEx(c2, i, c) {
placeSidewallX(c, i, SIDE_SLEV+2, V, warp, false, darkena(wcol2, fd, alpha));
}
forCellIdEx(c2, i, c) {
placeSidewallX(c, i, SIDE_WTS3, V, warp, false, darkena(wcol2, fd, alpha));
}
}
else {
forCellIdEx(c2, i, c)
if(!highwall(c2) || conegraph(c2)) {
placeSidewallX(c, i, SIDE_WALL, V, warp, false, darkena(wcol2, fd, alpha));
}
}
}
}
}
void drawcell(cell *c, transmatrix V, int spinv, bool mirrored) {
#if CAP_TEXTURE
@ -3424,12 +3511,6 @@ void drawcell(cell *c, transmatrix V, int spinv, bool mirrored) {
if(isPlayerOn(c) && !shmup::on) {
playerfound = true;
/* if(euclid)
return d * S84 / c->type;
else
return S42 - d * S84 / c->type;
cwtV = V * spin(-cwt.spin * 2*M_PI/c->type) * pispin; */
if(multi::players > 1) {
for(int i=0; i<numplayers(); i++)
if(playerpos(i) == c) {
@ -3447,13 +3528,6 @@ void drawcell(cell *c, transmatrix V, int spinv, bool mirrored) {
}
}
/* if(cwt.c->land == laEdge) {
if(c == chosenDown(cwt.c, 1, 0))
playerfoundL = c, cwtVL = V;
if(c == chosenDown(cwt.c, -1, 0))
playerfoundR = c, cwtVR = V;
} */
if(1) {
hyperpoint VC0 = tC0(V);
@ -3708,6 +3782,12 @@ void drawcell(cell *c, transmatrix V, int spinv, bool mirrored) {
bool eoh = euclid || nonbitrunc;
if(c->wall == waChasm) {
zcol = 0;
int rd = rosedist(c);
if(rd == 1)
queuepoly(V, shRoseFloor[ct6], 0x80406020);
if(rd == 2)
queuepoly(V, shRoseFloor[ct6], 0x80406040);
if(c->land == laZebra) fd++;
if(c->land == laHalloween && !wmblack) {
transmatrix Vdepth = wmspatial ? mscale(V, geom3::BOTTOM) : V;
@ -3717,7 +3797,7 @@ void drawcell(cell *c, transmatrix V, int spinv, bool mirrored) {
}
#if CAP_EDIT
if(mapeditor::drawUserShape(V * applyPatterndir(c, si), 3, si.id,
else if(mapeditor::drawUserShape(V * applyPatterndir(c, si), 3, si.id,
darkena(fcol, fd, (cmode & sm::DRAW) ? 0xC0 : 0xFF), c));
else if(patterns::whichShape == '7') {
@ -3924,159 +4004,158 @@ void drawcell(cell *c, transmatrix V, int spinv, bool mirrored) {
drawTowerFloor(Vf, c, darkena(fcol, fd, 0xFF),
prairie::isleft(c) ? river::towerleft : river::towerright); */
else if(c->land == laPrairie)
else switch(c->land) {
case laPrairie:
qfloor(c, Vf, CLOUDFLOOR, darkena(fcol, fd, 0xFF));
break;
else if(c->land == laWineyard) {
case laWineyard:
qfloor(c, Vf, FEATHERFLOOR, darkena(fcol, fd, 0xFF));
}
break;
else if(c->land == laZebra)
case laZebra:
drawZebraFloor(Vf, c, darkena(fcol, fd, 0xFF));
break;
else if(c->wall == waTrunk)
qfloor(c, Vf, PLAINFLOOR, darkena(fcol, fd, 0xFF));
else if(c->wall == waCanopy || c->wall == waSolidBranch || c->wall == waWeakBranch)
qfloor(c, Vf, FEATHERFLOOR, darkena(fcol, fd, 0xFF));
else if(c->land == laMountain)
case laMountain:
drawTowerFloor(Vf, c, darkena(fcol, fd, 0xFF),
euclid ? celldist : c->master->alt ? celldistAltPlus : celldist);
break;
else if(isGravityLand(c->land))
drawTowerFloor(Vf, c, darkena(fcol, fd, 0xFF));
else if(c->land == laEmerald)
case laEmerald:
drawEmeraldFloor(Vf, c, darkena(fcol, fd, 0xFF));
break;
else if(c->land == laRlyeh)
case laRlyeh:
qfloor_eswap(c, Vf, TRIFLOOR, darkena(fcol, fd, 0xFF));
// qfloor(c, Vf, shTriFloor[ct6], darkena(fcol, fd, 0xFF));
break;
else if(c->land == laTemple)
// qfloor(c, Vf, (eoh ? shFloor: shTriFloor)[ct6], darkena(fcol, fd, 0xFF));
case laTemple:
qfloor_eswap(c, Vf, TRIFLOOR, darkena(fcol, fd, 0xFF));
break;
else if(c->land == laAlchemist)
case laAlchemist:
qfloor(c, Vf, CLOUDFLOOR, darkena(fcol, fd, 0xFF));
break;
else if(c->land == laVolcano)
case laVolcano:
qfloor_eswap(c, Vf, LAVAFLOOR, darkena(fcol, fd, 0xFF));
break;
else if(c->land == laRose)
case laRose:
qfloor_eswap(c, Vf, ROSEFLOOR, darkena(fcol, fd, 0xFF));
break;
else if(c->land == laTortoise)
case laTortoise:
qfloor_eswap(c, Vf, TURTLEFLOOR, darkena(fcol, fd, 0xFF));
break;
else if(c->land == laDragon && !nonbitrunc) {
/* if(!wmspatial || noAdjacentChasms(c)) */
qfloor(c, Vf, DRAGONFLOOR, darkena(fcol, fd, 0xFF));
/* if(wmspatial)
qfloor(c, Vf, shFloor[euclid?2:ct6], darkena(fcol, fd, 0xFF)); */
}
else if(isElemental(c->land) || c->land == laElementalWall)
qfloor_eswap(c, Vf, NEWFLOOR, darkena(fcol, fd, 0xFF));
else if(c->land == laBurial || c->land == laRuins)
case laBurial: case laRuins:
qfloor(c, Vf, BARROWFLOOR, darkena(fcol, fd, 0xFF));
break;
else if(c->land == laTrollheim && !eoh)
case laTrollheim:
if(!eoh)
qfloor_eswap(c, Vf, TROLLFLOOR, darkena(fcol, fd, 0xFF));
else if(c->land == laTrollheim)
else
qfloor(c, Vf, CAVEFLOOR, darkena(fcol, fd, 0xFF));
break;
else if(c->land == laJungle)
case laJungle:
qfloor(c, Vf, FEATHERFLOOR, darkena(fcol, fd, 0xFF));
break;
else if(c->land == laMountain)
/*case laMountain:
qfloor(c, Vf, FEATHERFLOOR, darkena(fcol, fd, 0xFF));
break; */
else if(c->land == laGraveyard)
case laGraveyard:
qfloor_eswap(c, Vf, CROSSFLOOR, darkena(fcol, fd, 0xFF));
break;
else if(c->land == laDeadCaves) {
case laDeadCaves:
qfloor(c, Vf, CAVEFLOOR, darkena(fcol, fd, 0xFF));
}
break;
else if(c->land == laMotion)
case laMotion:
qfloor(c, Vf, MFLOOR1, darkena(fcol, fd, 0xFF));
break;
else if(c->land == laWhirlwind)
case laWhirlwind:
qfloor_eswap(c, Vf, NEWFLOOR, darkena(fcol, fd, 0xFF));
break;
else if(c->land == laHell)
case laHell:
qfloor_eswap(c, Vf, DEMONFLOOR, darkena(fcol, fd, 0xFF));
break;
else if(c->land == laIce || c->land == laBlizzard)
case laIce: case laBlizzard:
qfloor(c, Vf, STARFLOOR, darkena(fcol, fd, 0xFF));
break;
else if(c->land == laCocytus)
case laCocytus:
qfloor_eswap(c, Vf, DESERTFLOOR, darkena(fcol, fd, 0xFF));
break;
else if(c->land == laSwitch) {
case laSwitch:
qfloor_eswap(c, Vf, SWITCHFLOOR, darkena(fcol, fd, 0xFF));
if(ctof(c)) for(int i=0; i<c->type; i++)
queuepoly(Vf * ddspin(c, i, S6) * xpush(rhexf), shSwitchDisk, darkena(minf[active_switch()].color, fd, 0xFF));
}
break;
else if(c->land == laStorms)
case laStorms:
qfloor_eswap(c, Vf, CHARGEDFLOOR, darkena(fcol, fd, 0xFF));
break;
else if(c->land == laWildWest)
case laWildWest:
qfloor_eswap(c, Vf, SSTARFLOOR, darkena(fcol, fd, 0xFF));
break;
else if(c->land == laPower)
case laPower:
qfloor_eswap(c, Vf, POWERFLOOR, darkena(fcol, fd, 0xFF));
break;
else if(c->land == laHive && c->wall != waFloorB && c->wall != waFloorA && c->wall != waMirror && c->wall != waCloud) {
qfloor(c, Vf, PLAINFLOOR, darkena(fcol, 1, 0xFF));
if(c->wall != waMirror && c->wall != waCloud)
qfloor(c, Vf, MFLOOR1, darkena(fcol, 2, 0xFF));
if(c->wall != waMirror && c->wall != waCloud)
qfloor(c, Vf, MFLOOR2, darkena(fcol, fcol==wcol ? 1 : 2, 0xFF));
}
else if(c->land == laCaves)
case laCaves:
qfloor(c, Vf, CAVEFLOOR, darkena(fcol, fd, 0xFF));
break;
else if(c->land == laDesert)
case laDesert:
qfloor_eswap(c, Vf, DESERTFLOOR, darkena(fcol, fd, 0xFF));
break;
else if(c->land == laOvergrown || c->land == laClearing || isHaunted(c->land))
qfloor(c, Vf, OVERFLOOR, darkena(fcol, fd, 0xFF));
else if(c->land == laBull)
case laBull:
qfloor_eswap(c, Vf, BUTTERFLYFLOOR, darkena(fcol, fd, 0xFF));
break;
else if(c->land == laDryForest)
case laDryForest:
qfloor_eswap(c, Vf, DESERTFLOOR, darkena(fcol, fd, 0xFF));
break;
// else if(c->land == laOcean && c->landparam > 25)
// qfloor(c, Vf, shWave[wavephase][ct6], darkena(fcol, fd, 0xFF));
else if((c->land == laCaribbean || c->land == laOcean || c->land == laOceanWall || c->land == laWhirlpool))
case laCaribbean: case laOcean: case laOceanWall: case laWhirlpool:
qfloor(c, Vf, CLOUDFLOOR, darkena(fcol, fd, 0xFF));
break;
else if(c->land == laKraken)
case laKraken:
qfloor(c, Vf, FULLFLOOR, darkena(fcol, fd, 0xFF));
break;
else if(c->land == laDocks)
case laDocks:
qfloor(c, Vf, FULLFLOOR, darkena(fcol, fd, 0xFF));
break;
else if(c->land == laLivefjord)
case laLivefjord:
qfloor(c, Vf, CAVEFLOOR, darkena(fcol, fd, 0xFF));
break;
else if(c->land == laRedRock || c->land == laSnakeNest)
case laRedRock: case laSnakeNest:
qfloor_eswap(c, Vf, DESERTFLOOR, darkena(fcol, fd, 0xFF));
break;
else if(c->land == laPalace || c->land == laTerracotta)
case laPalace: case laTerracotta:
qfloor_eswap(c, Vf, PALACEFLOOR, darkena(fcol, fd, 0xFF));
break;
else if(c->land == laMercuryRiver) {
case laMercuryRiver: {
if(eoh)
qfloor(c, Vf, PLAINFLOOR, darkena(fcol, fd, 0xFF));
else {
@ -4105,9 +4184,52 @@ void drawcell(cell *c, transmatrix V, int spinv, bool mirrored) {
}
}
else {
case laOvergrown: case laClearing: case laHauntedWall: case laHaunted: case laHauntedBorder:
qfloor(c, Vf, OVERFLOOR, darkena(fcol, fd, 0xFF));
break;
case laHive:
if(c->wall != waFloorB && c->wall != waFloorA && c->wall != waMirror && c->wall != waCloud) {
qfloor(c, Vf, PLAINFLOOR, darkena(fcol, 1, 0xFF));
if(c->wall != waMirror && c->wall != waCloud)
qfloor(c, Vf, MFLOOR1, darkena(fcol, 2, 0xFF));
if(c->wall != waMirror && c->wall != waCloud)
qfloor(c, Vf, MFLOOR2, darkena(fcol, fcol==wcol ? 1 : 2, 0xFF));
}
else
qfloor(c, Vf, PLAINFLOOR, darkena(fcol, fd, 0xFF));
break;
case laEndorian:
if(c->wall == waTrunk)
qfloor(c, Vf, PLAINFLOOR, darkena(fcol, fd, 0xFF));
else if(c->wall == waCanopy || c->wall == waSolidBranch || c->wall == waWeakBranch)
qfloor(c, Vf, FEATHERFLOOR, darkena(fcol, fd, 0xFF));
else
drawTowerFloor(Vf, c, darkena(fcol, fd, 0xFF));
break;
case laDragon:
if(nonbitrunc)
qfloor(c, Vf, PLAINFLOOR, darkena(fcol, fd, 0xFF));
else
qfloor(c, Vf, DRAGONFLOOR, darkena(fcol, fd, 0xFF));
break;
case laEFire: case laEAir: case laEWater: case laEEarth: case laElementalWall:
qfloor_eswap(c, Vf, NEWFLOOR, darkena(fcol, fd, 0xFF));
break;
case laIvoryTower: case laDungeon:
drawTowerFloor(Vf, c, darkena(fcol, fd, 0xFF));
break;
default:
qfloor(c, Vf, PLAINFLOOR, darkena(fcol, fd, 0xFF));
}
// walls
#if CAP_EDIT
@ -4168,7 +4290,9 @@ void drawcell(cell *c, transmatrix V, int spinv, bool mirrored) {
char xch = winf[c->wall].glyph;
if(c->wall == waBigBush) {
switch(c->wall) {
case waBigBush:
if(detaillevel >= 2)
queuepolyat(mmscale(V, zgrad0(0, geom3::slev, 1, 2)), shHeptaMarker, darkena(wcol, 0, 0xFF), PPR_REDWALL);
if(detaillevel >= 1)
@ -4176,9 +4300,9 @@ void drawcell(cell *c, transmatrix V, int spinv, bool mirrored) {
if(detaillevel >= 2)
queuepolyat(mmscale(V, zgrad0(0, geom3::slev, 3, 2)), shHeptaMarker, darkena(wcol, 0, 0xFF), PPR_REDWALL+2);
queuepolyat(mmscale(V, geom3::SLEV[2]), shSolidBranch, darkena(wcol, 0, 0xFF), PPR_REDWALL+3);
}
break;
else if(c->wall == waSmallBush) {
case waSmallBush:
if(detaillevel >= 2)
queuepolyat(mmscale(V, zgrad0(0, geom3::slev, 1, 2)), shHeptaMarker, darkena(wcol, 0, 0xFF), PPR_REDWALL);
if(detaillevel >= 1)
@ -4186,17 +4310,17 @@ void drawcell(cell *c, transmatrix V, int spinv, bool mirrored) {
if(detaillevel >= 2)
queuepolyat(mmscale(V, zgrad0(0, geom3::slev, 3, 2)), shHeptaMarker, darkena(wcol, 0, 0xFF), PPR_REDWALL+2);
queuepolyat(mmscale(V, geom3::SLEV[2]), shWeakBranch, darkena(wcol, 0, 0xFF), PPR_REDWALL+3);
}
break;
else if(c->wall == waSolidBranch) {
case waSolidBranch:
queuepoly(V, shSolidBranch, darkena(wcol, 0, 0xFF));
}
break;
else if(c->wall == waWeakBranch) {
case waWeakBranch:
queuepoly(V, shWeakBranch, darkena(wcol, 0, 0xFF));
}
break;
else if(c->wall == waLadder) {
case waLadder:
if(euclid) {
queuepoly(V, shMFloor[ct6], 0x804000FF);
queuepoly(V, shMFloor2[ct6], 0x000000FF);
@ -4205,9 +4329,9 @@ void drawcell(cell *c, transmatrix V, int spinv, bool mirrored) {
queuepolyat(V, shFloor[ct6], 0x804000FF, PPR_FLOOR+1);
queuepolyat(V, shMFloor[ct6], 0x000000FF, PPR_FLOOR+2);
}
}
break;
if(c->wall == waReptileBridge) {
case waReptileBridge: {
Vboat = &(Vboat0 = V);
dynamicval<qfloorinfo> qfi2(qfi, qfi);
int col = reptilecolor(c);
@ -4216,12 +4340,14 @@ void drawcell(cell *c, transmatrix V, int spinv, bool mirrored) {
forCellIdEx(c2, i, c) if(chasmgraph(c2))
placeSidewallX(c, i, SIDE_LAKE, V, isWarped(c), false, darkena(gradient(0, col, 0, .8, 1), fd, 0xFF));
chasmg = 1;
break;
}
if(c->wall == waTerraWarrior)
case waTerraWarrior:
drawTerraWarrior(V, randterra ? (c->landparam & 7) : (5 - (c->landparam & 7)), 7, 0);
break;
else if(c->wall == waBoat || c->wall == waStrandedBoat) {
case waBoat: case waStrandedBoat: {
double footphase;
bool magical = items[itOrbWater] && (isPlayerOn(c) || (isFriendly(c) && items[itOrbEmpathy]));
int outcol = magical ? watercolor(0) : 0xC06000FF;
@ -4249,9 +4375,10 @@ void drawcell(cell *c, transmatrix V, int spinv, bool mirrored) {
queuepolyat(mscale(Vboat0, (geom3::LAKE+1)/2), shBoatOuter, outcol, PPR_BOATLEV2);
queuepoly(Vboat0, shBoatOuter, outcol);
queuepoly(Vboat0, shBoatInner, incol);
break;
}
else if(c->wall == waBigStatue) {
case waBigStatue: {
transmatrix V2 = V;
double footphase;
applyAnimation(c, V2, footphase, LAYER_BOAT);
@ -4260,9 +4387,10 @@ void drawcell(cell *c, transmatrix V, int spinv, bool mirrored) {
darkena(winf[c->wall].color, 0, 0xFF),
PPR_BIGSTATUE
);
break;
}
else if(c->wall == waSulphurC) {
case waSulphurC: {
if(drawstar(c)) {
zcol = wcol;
if(wmspatial)
@ -4270,21 +4398,27 @@ void drawcell(cell *c, transmatrix V, int spinv, bool mirrored) {
else
queuepoly(V, shGiantStar[ct6], darkena(wcol, 0, 0xFF));
}
break;
}
else if(c->wall == waClosePlate || c->wall == waOpenPlate || (c->wall == waTrapdoor && c->land != laZebra)) {
case waTrapdoor:
if(c->land == laZebra) break;
/* fallthrough */
case waClosePlate: case waOpenPlate: {
transmatrix V2 = V;
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));
break;
}
else if(c->wall == waFrozenLake || c->wall == waLake || c->wall == waCamelotMoat ||
c->wall == waSea || c->wall == waClosePlate || c->wall == waOpenPlate ||
c->wall == waOpenGate || c->wall == waTrapdoor || c->wall == waBubble)
;
case waFrozenLake: case waLake: case waCamelotMoat:
case waSea: case waOpenGate: case waBubble: case waDock:
case waNone: case waSulphur: case waMercury:
break;
else if(c->wall == waRose) {
case waRose: {
zcol = wcol;
wcol <<= 1;
if(c->cpdist > 5)
@ -4297,9 +4431,72 @@ void drawcell(cell *c, transmatrix V, int spinv, bool mirrored) {
for(int u=0; u<4; u+=2)
queuepoly(V * spin(2*M_PI / 3 / 4 * u), shRose, darkena(wcol, 0, 0xC0));
break;
}
else if(sl && wmspatial) {
case waRoundTable:
if(wmspatial) goto wa_default;
break;
case waMirrorWall:
break;
case waGlass:
if(wmspatial) {
int col = winf[waGlass].color;
int dcol = darkena(col, 0, 0x80);
transmatrix Vdepth = mscale((*Vdp), geom3::WALL);
queuepolyat(Vdepth, shMFloor[ct6], dcol, PPR_WALL); // GLASS
if(validsidepar[SIDE_WALL]) forCellIdEx(c2, i, c)
placeSidewall(c, i, SIDE_WALL, (*Vdp), false, true, dcol);
}
break;
case waFan:
queuepoly(V * spin(M_PI/6 - fanframe * M_PI / 3), shFan, darkena(wcol, 0, 0xFF));
break;
case waArrowTrap:
if(c->wparam >= 1)
queuepoly(V, shDisk, darkena(trapcol[c->wparam&3], 0, 0xFF));
if(isCentralTrap(c)) arrowtraps.push_back(c);
break;
case waFreshGrave: case waAncientGrave:
zcol = wcol;
queuepoly(V, shCross, darkena(wcol, 0, 0xFF));
break;
case waGiantRug:
queuepoly(V, shBigCarpet1, darkena(0xC09F00, 0, 0xFF));
queuepoly(V, shBigCarpet2, darkena(0x600000, 0, 0xFF));
queuepoly(V, shBigCarpet3, darkena(0xC09F00, 0, 0xFF));
break;
case waBarrier:
if(c->land == laOceanWall && wmescher && wmspatial) {
const int layers = 2 << detaillevel;
dynamicval<const hpcshape*> ds(qfi.shape, &shCircleFloor);
dynamicval<bool> db(qfi.special, true);
for(int z=1; z<layers; z++) {
double zg = zgrad0(-geom3::lake_top, geom3::wall_height, z, layers);
warpfloor(c, xyzscale(V, zg*(layers-z)/layers, zg),
darkena(gradient(0, wcol, -layers, z, layers), 0, 0xFF), PPR_WALL3+z-layers+2, isWarped(c));
}
}
else goto wa_default;
break;
case waMineOpen: {
int mines = countMinesAround(c);
if(mines)
queuepoly(V, shMineMark[ct6], (minecolors[mines] << 8) | 0xFF);
break;
}
default: {
wa_default:
if(sl && wmspatial) {
bool w = isWarped(c);
warpfloor(c, (*Vdp), darkena(wcol, fd, 0xFF), PPR_REDWALL-4+4*sl, w);
@ -4312,114 +4509,8 @@ void drawcell(cell *c, transmatrix V, int spinv, bool mirrored) {
}
}
else if(c->wall == waRoundTable) ;
else if(c->wall == waGlass && wmspatial) {
int col = winf[waGlass].color;
int dcol = darkena(col, 0, 0x80);
transmatrix Vdepth = mscale((*Vdp), geom3::WALL);
queuepolyat(Vdepth, shMFloor[ct6], dcol, PPR_WALL); // GLASS
if(validsidepar[SIDE_WALL]) forCellIdEx(c2, i, c)
placeSidewall(c, i, SIDE_WALL, (*Vdp), false, true, dcol);
}
else if(c->wall == waGlass && !wmspatial) ;
else if(wmescher && wmspatial && c->wall == waBarrier && c->land == laOceanWall) {
const int layers = 2 << detaillevel;
dynamicval<const hpcshape*> ds(qfi.shape, &shCircleFloor);
dynamicval<bool> db(qfi.special, true);
for(int z=1; z<layers; z++) {
double zg = zgrad0(-geom3::lake_top, geom3::wall_height, z, layers);
warpfloor(c, xyzscale(V, zg*(layers-z)/layers, zg),
darkena(gradient(0, wcol, -layers, z, layers), 0, 0xFF), PPR_WALL3+z-layers+2, isWarped(c));
}
}
else if(c->wall == waMirrorWall) ;
else if(highwall(c)) {
zcol = wcol;
int wcol0 = wcol;
int starcol = wcol;
if(c->wall == waWarpGate) starcol = 0;
if(c->wall == waVinePlant) starcol = 0x60C000;
int wcol2 = gradient(0, wcol0, 0, .8, 1);
if(c->wall == waClosedGate) {
int hdir = 0;
for(int i=0; i<c->type; i++) if(c->mov[i]->wall == waClosedGate)
hdir = i;
transmatrix V2 = mscale(V, wmspatial?geom3::WALL:1) * ddspin(c, hdir, S42);
queuepolyat(V2, shPalaceGate, darkena(wcol, 0, 0xFF), wmspatial?PPR_WALL3A:PPR_WALL);
starcol = 0;
}
hpcshape& shThisWall = isGrave(c->wall) ? shCross : shWall[ct6];
if(conegraph(c)) {
const int layers = 2 << detaillevel;
for(int z=1; z<layers; z++) {
double zg = zgrad0(0, geom3::wall_height, z, layers);
warpfloor(c, xyzscale(V, zg*(layers-z)/layers, zg),
darkena(gradient(0, wcol, -layers, z, layers), 0, 0xFF), PPR_WALL3+z-layers+2, isWarped(c));
}
floorShadow(c, V, SHADOW_WALL, isWarped(c));
}
else if(true) {
if(!wmspatial) {
if(starcol) queuepoly(V, shThisWall, darkena(starcol, 0, 0xFF));
}
else {
transmatrix Vdepth = mscale(V, geom3::WALL);
int alpha = 0xFF;
if(c->wall == waIcewall)
alpha = 0xC0;
bool warp = isWarped(c);
if(starcol && !(wmescher && c->wall == waPlatform))
queuepolyat(Vdepth, shThisWall, darkena(starcol, 0, 0xFF), PPR_WALL3A);
warpfloor(c, Vdepth, darkena(wcol0, fd, alpha), PPR_WALL3, warp);
floorShadow(c, V, SHADOW_WALL, warp);
if(c->wall == waCamelot) {
forCellIdEx(c2, i, c) {
placeSidewallX(c, i, SIDE_SLEV, V, warp, false, darkena(wcol2, fd, alpha));
}
forCellIdEx(c2, i, c) {
placeSidewallX(c, i, SIDE_SLEV+1, V, warp, false, darkena(wcol2, fd, alpha));
}
forCellIdEx(c2, i, c) {
placeSidewallX(c, i, SIDE_SLEV+2, V, warp, false, darkena(wcol2, fd, alpha));
}
forCellIdEx(c2, i, c) {
placeSidewallX(c, i, SIDE_WTS3, V, warp, false, darkena(wcol2, fd, alpha));
}
}
else {
forCellIdEx(c2, i, c)
if(!highwall(c2) || conegraph(c2)) {
placeSidewallX(c, i, SIDE_WALL, V, warp, false, darkena(wcol2, fd, alpha));
}
}
}
}
}
else if(c->wall == waFan) {
queuepoly(V * spin(M_PI/6 - fanframe * M_PI / 3), shFan, darkena(wcol, 0, 0xFF));
}
else if(c->wall == waArrowTrap) {
if(c->wparam >= 1)
queuepoly(V, shDisk, darkena(trapcol[c->wparam&3], 0, 0xFF));
if(isCentralTrap(c)) arrowtraps.push_back(c);
}
else if(highwall(c))
draw_wall(c, V, wcol, zcol, ct6, fd);
else if(xch == '%') {
if(doHighlight())
@ -4447,28 +4538,26 @@ void drawcell(cell *c, transmatrix V, int spinv, bool mirrored) {
drawParticle(c, wcol, 75);
}
else if(c->wall == waFreshGrave || c->wall == waAncientGrave) {
zcol = wcol;
queuepoly(V, shCross, darkena(wcol, 0, 0xFF));
}
else if(xch == '+' && c->wall == waGiantRug) {
queuepoly(V, shBigCarpet1, darkena(0xC09F00, 0, 0xFF));
queuepoly(V, shBigCarpet2, darkena(0x600000, 0, 0xFF));
queuepoly(V, shBigCarpet3, darkena(0xC09F00, 0, 0xFF));
}
else if(c->wall == waDock) ;
else if(xch != '.' && xch != '+' && xch != '>' && xch != ':'&& xch != '-' && xch != ';' && c->wall != waSulphur && c->wall != waMercury && xch != ',' && xch != '&')
else if(xch != '.' && xch != '+' && xch != '>' && xch != ':'&& xch != '-' && xch != ';' && xch != ',' && xch != '&')
error = true;
}
}
}
else {
if(c->wall == waArrowTrap)
asciicol = trapcol[c->wparam & 3];
if(c->wall == waTerraWarrior)
asciicol = terracol[c->landparam & 7];
if(c->wall == waMineOpen) {
int mines = countMinesAround(c);
if(ch == '.') {
if(mines == 0) ch = ' ';
else ch = '0' + mines, asciicol = minecolors[mines];
}
else if(ch == '@') asciicol = minecolors[mines];
}
if(!(it || c->monst || c->cpdist == 0)) error = true;
}
@ -4580,27 +4669,6 @@ void drawcell(cell *c, transmatrix V, int spinv, bool mirrored) {
}
}
if(c->wall == waMineOpen) {
int mines = countMinesAround(c);
if(wmascii) {
if(ch == '.') {
if(mines == 0) ch = ' ';
else ch = '0' + mines, asciicol = minecolors[mines];
}
else if(ch == '@') asciicol = minecolors[mines];
}
else if(mines > 0)
queuepoly(V, shMineMark[ct6], (minecolors[mines] << 8) | 0xFF);
}
// treasure
if(c->land == laWhirlwind && c->wall != waBoat) {
double footphase = 0;
Vboat = &(Vboat0 = *Vboat);
applyAnimation(c, Vboat0, footphase, LAYER_BOAT);
}
#if CAP_EDIT
if(c == mapeditor::drawcell) {
if(mapeditor::drawcellShapeGroup() == 2) {
@ -4610,7 +4678,14 @@ void drawcell(cell *c, transmatrix V, int spinv, bool mirrored) {
}
#endif
if(it && cellHalfvine(c)) {
if(it) {
if(c->land == laWhirlwind && c->wall != waBoat) {
double footphase = 0;
Vboat = &(Vboat0 = *Vboat);
applyAnimation(c, Vboat0, footphase, LAYER_BOAT);
}
if(cellHalfvine(c)) {
int i =-1;
for(int t=0;t<6; t++) if(c->mov[t] && c->mov[t]->wall == c->wall)
i = t;
@ -4619,6 +4694,7 @@ void drawcell(cell *c, transmatrix V, int spinv, bool mirrored) {
}
error |= drawItemType(it, c, *Vboat, icol, ticks, hidden);
}
if(true) {
int q = ptds.size();
@ -4632,17 +4708,8 @@ void drawcell(cell *c, transmatrix V, int spinv, bool mirrored) {
queuepolyat(V, shDisk, 0xC0404040, PPR_SWORDMARK);
}
if(c->wall == waChasm) zcol = 0;
addaura(tC0(V), zcol, fd);
if(c->wall == waChasm) {
int rd = rosedist(c);
if(rd == 1)
queuepoly(V, shRoseFloor[ct6], 0x80406020);
if(rd == 2)
queuepoly(V, shRoseFloor[ct6], 0x80406040);
}
int ad = airdist(c);
if(ad == 1 || ad == 2) {

39
polygons.cpp
View File

@ -770,44 +770,53 @@ void drawqueueitem(polytodraw& ptd) {
// if(ptd.prio == 46) printf("eye size %d\n", polyi);
if(ptd.kind == pkSpecial) {
switch(ptd.kind) {
case pkSpecial:
callhooks(hooks_specialdraw, ptd);
}
break;
if(ptd.kind == pkResetModel) {
case pkResetModel:
pmodel = eModel(ptd.col);
return;
}
break;
if(ptd.kind == pkPoly) {
case pkPoly:
if(ptd.u.poly.curveindex >= 0)
ptd.u.poly.tab = &curvedata[ptd.u.poly.curveindex];
drawpolyline(ptd);
}
else if(ptd.kind == pkLine) {
break;
case pkLine: {
dynamicval<ld> d(vid.linewidth, ptd.u.line.width);
prettyline(ptd.u.line.H1, ptd.u.line.H2, ptd.col, ptd.u.line.prf);
break;
}
else if(ptd.kind == pkString) {
case pkString: {
qchr& q(ptd.u.chr);
#if ISMOBILE==0
#if ISMOBILE==0
if(svg::in)
svg::text(q.x, q.y, q.size, q.str, q.frame, ptd.col, q.align);
else {
int fr = q.frame & 255;
displayfrSP(q.x, q.y, q.shift, fr, q.size, q.str, ptd.col, q.align, q.frame >> 8);
}
#else
#else
displayfr(q.x, q.y, q.frame, q.size, q.str, ptd.col, q.align);
#endif
#endif
break;
}
else if(ptd.kind == pkCircle) {
#if ISMOBILE==0
case pkCircle: {
#if ISMOBILE==0
if(svg::in)
svg::circle(ptd.u.cir.x, ptd.u.cir.y, ptd.u.cir.size, ptd.col);
else
#endif
#endif
drawCircle(ptd.u.cir.x, ptd.u.cir.y, ptd.u.cir.size, ptd.col);
break;
}
case pkShape: ;
}
}