SIDE top, deep;

int levels;

int sl; /* snake level */

cell *c;

shiftmatrix V;

color_t fcol;

color_t wcol;

color_t wcol_star;

color_t asciicol;

color_t aura_color;

int fd;

int ct6;

bool error;

bool onradar;

char asciichar;

shiftmatrix Vboat;

shiftmatrix Vd;

spatial_info sha;

color_t asciiborder;

color_t asciicol1;

char asciichar1;

void addaura();

void setcolors();

void tune_colors();

int getSnakelevColor(int i, int last);

void draw_wall();

void draw_boat();

void draw_grid();

void draw_grid_edge(int t, color_t col, int prec);

void draw_ceiling();

void draw_halfvine();

void draw_mirrorwall();

bool set_randompattern_floor();

void draw_features();

void draw_features_and_walls_3d();

void check_rotations();

void drawcell_in_radar();

void bookkeeping();

void draw_cellstat();

void draw_wall_full();

void draw_wallshadow();

void draw_item_full();

void draw_monster_full();

void add_map_effects();

void draw();

bool cell_clipped();

void draw_fallanims();

bool draw_shmup_monster();

void draw_gravity_particles();

void set_land_floor(const shiftmatrix& Vf);

void set_towerfloor(const cellfunction& cf = coastvalEdge);

void set_zebrafloor();

void set_maywarp_floor();

void set_reptile_floor(const shiftmatrix& V, color_t col, bool nodetails = false);

void set_emeraldfloor();

void shmup_gravity_floor();

void draw_reptile(color_t col);

void radar_grid();

void do_viewdist();

void draw_bowpath();

celldrawer dd;

dd.c = c;

dd.V = V;

dd.draw();

if (!higher_contrast) {

part(col, 0) = part(col, 2) * 3 / 4;

} else {

auto v = part(col, 0) + part(col, 1) + part(col, 2);

auto t = part(col, 0);

part(col, 0) = part(col, 1);

part(col, 1) = part(col, 2);

part(col, 2) = t + v/3;

}

#if CAP_COMPLEX2

if(mine::marked_safe(c))

return gradient(wcol, 0x40FF40, 0, 0.2, 1);

if(mine::marked_mine(c))

return gradient(wcol, 0xFF4040, -1, vid.ispeed ? sintick(100) : 1, 1);

#endif

return wcol;

wcol = fcol = winf[c->wall].color;

if(c->wall == waMineMine)

wcol = fcol = winf[waMineUnknown].color;

// water colors

if(isWateryOrBoat(c) || c->wall == waReptileBridge) {

if(c->land == laOcean)

fcol =

#if CAP_FIELD

(c->landparam > 25 && !ls::any_chaos()) ? (

0x90 + 8 * sintick(1000, windmap::windcodes[windmap::getId(c)] / 256.)

) :

#endif

0x1010C0 + int(32 * sintick(500, (ls::any_chaos() ? c->CHAOSPARAM : c->landparam)*spinspeed));

else if(c->land == laOceanWall)

fcol = 0x2020FF;

else if(c->land == laVariant)

fcol = 0x002090 + 15 * sintick(300, 0);

else if(c->land == laKraken) {

fcol = 0x0000A0;

int mafcol = (kraken_pseudohept(c) ? 64 : 8);

/* bool nearshore = false;

fcol = fcol + mafcol * (4+sintick(500, ((eubinary||c->master->alt) ? celldistAlt(c) : 0)*spinspeed))/5;

}

else if(c->land == laDocks) {

fcol = 0x0000A0;

}

else if(c->land == laAlchemist)

fcol = 0x900090;

else if(c->land == laWhirlpool)

fcol = 0x0000C0 + int(32 * sintick(200, ((eubinary||c->master->alt) ? celldistAlt(c) : 0)*spinspeed));

else if(c->land == laLivefjord)

fcol = 0x000080;

else if(isWarpedType(c->land))

fcol = 0x0000C0 + int((warptype(c)?30:-30) * sintick(600));

else

fcol = wcol;

}

else if(c->wall == waShallow)

fcol = 0x40C0C0;

// floor colors for all the lands

else switch(c->land) {

case laBurial: case laTrollheim: case laBarrier: case laOceanWall:

case laCrossroads2: case laCrossroads3: case laCrossroads4: case laCrossroads5: case laCrossroads6: case laMasterCrossroads:

case laRose: case laPower: case laWildWest: case laHalloween: case laRedRock:

case laDragon: case laStorms: case laTerracotta: case laMercuryRiver:

case laDesert: case laKraken: case laDocks:

case laMotion: case laGraveyard: case laWineyard: case laLivefjord:

case laRlyeh: case laHell: case laCrossroads: case laJungle:

case laAlchemist: case laFrog: case laCursed: case laDice:

fcol = floorcolors[c->land]; break;

case laCA:

fcol = floorcolors[c->land];

if(geosupport_chessboard()) {

if(chessvalue(c)) fcol += 0x202020;

}

else if(geosupport_threecolor()) {

fcol += 0x202020 * pattern_threecolor(c);

}

break;

case laWet:

fcol = 0x40FF40; break;

#if CAP_COMPLEX2

case laVariant: {

int b = getBits(c);

fcol = 0x404040;

for(int a=0; a<21; a++)

if((b >> a) & 1)

fcol += variant::features[a].color_change;

if(!higher_contrast) {

if(c->wall == waAncientGrave)

wcol = 0x080808;

else if(c->wall == waFreshGrave)

wcol = 0x202020;

}

break;

}

#endif

case laRuins:

fcol = pseudohept(c) ? 0xC0E0C0 : 0x40A040;

break;

case laDual:

fcol = floorcolors[c->land];

if(c->landparam == 2) fcol = 0x40FF00;

if(c->landparam == 3) fcol = 0xC0FF00;

break;

#if CAP_COMPLEX2

case laBrownian: {

if (c->wall == waNone)

fcol = wcol = brownian::get_color(c->landparam);

break;

}

#endif

#if CAP_FIELD

case laVolcano: {

int id = lavatide(c, -1)/4;

if(c->wall == waMagma)

fcol = wcol = magma_color(id);

else if(c->wall == waNone) {

fcol = wcol = 0x404040;

if(id == 255/4) fcol = 0xA0A040;

if(id == 255/4-1) fcol = 0x606040;

}

/* {

break;

}

#endif

case laMinefield:

fcol = floorcolors[c->land];

if(c->wall == waMineMine && ((cmode & sm::MAP) || !canmove))

fcol = wcol = 0xFF4040;

break;

case laCaribbean:

if(c->wall != waCIsland && c->wall != waCIsland2)

fcol = floorcolors[c->land];

else if(shadingcheat)

fcol = celldistAlt(c) % 2 ? winf[waCIsland].color : winf[waCIsland2].color;

break;

case laReptile:

fcol = reptilecolor(c);

break;

case laCaves: case laEmerald: case laDeadCaves:

fcol = 0x202020;

if(c->land == laEmerald)

if(c->wall == waCavefloor || c->wall == waCavewall) {

fcol = wcol = gradient(winf[waCavefloor].color, 0xFF00, 0, 0.5, 1);

if(c->wall == waCavewall) wcol = 0xC0FFC0;

}

break;

case laMirror: case laMirrorWall: case laMirrorOld:

if(c->land == laMirrorWall) fcol = floorcolors[laMirror];

else fcol = floorcolors[c->land];

break;

case laDryForest:

fcol = gradient(0x008000, 0x800000, 0, c->landparam, 10);

break;

case laMountain:

if(eubinary || sphere || c->master->alt)

fcol = get_color_auto3(celldistAlt(c), mountain_colors);

else fcol = 0;

if(c->wall == waPlatform) wcol = 0xF0F0A0;

break;

case laCanvas:

fcol = c->landparam;

if(c->wall == waWaxWall) wcol = c->landparam;

break;

case laPalace:

fcol = floorcolors[c->land];

if(c->wall == waClosedGate || c->wall == waOpenGate)

fcol = wcol;

break;

case laElementalWall:

fcol = (linf[c->barleft].color>>1) + (linf[c->barright].color>>1);

break;

case laZebra:

fcol = floorcolors[c->land];

if(c->wall == waTrapdoor) fcol = 0x808080;

break;

case laHive:

fcol = linf[c->land].color;

if(c->wall == waWaxWall) wcol = c->landparam;

if(items[itOrbInvis] && c->wall == waNone && c->landparam)

fcol = gradient(fcol, 0xFF0000, 0, c->landparam, 100);

if(among(int(c->bardir), NOBARRIERS, NOBARRIERS2) && c->barleft)

fcol = minf[moBug0+c->barright].color;

break;

case laSwitch:

fcol = minf[passive_switch].color;

break;

case laTortoise:

fcol = tortoise::getMatchColor(getBits(c));

if(c->wall == waBigTree) wcol = 0x709000;

else if(c->wall == waSmallTree) wcol = 0x905000;

break;

case laOvergrown: case laClearing:

fcol = floorcolors[c->land];

if(c->wall == waSmallTree) wcol = 0x008060;

else if(c->wall == waBigTree) wcol = 0x0080C0;

break;

case laTemple: {

int d = (eubinary||c->master->alt) ? celldistAlt(c) : 99;

if(ls::any_chaos())

fcol = 0x405090;

else if(d % temple_layer_size() == 0)

fcol = gradient(0x304080, winf[waColumn].color, 0, 0.5, 1);

// else if(c->type == 7)

// wcol = 0x707070;

else if(d% 2 == -1)

fcol = 0x304080;

else

fcol = 0x405090;

break;

}

case laWhirlwind:

if(c->land == laWhirlwind) {

color_t whirlcolors[4] = {0x404040, 0x404080, 0x2050A0, 0x5050C0};

fcol = whirlcolors[whirlwind::fzebra3(c)];

}

break;

case laHunting:

fcol = floorcolors[c->land];

if(pseudohept(c)) fcol = fcol * 3/4;

break;

case laIvoryTower:

fcol = get_color_auto3(c->landparam, tower_colors);

break;

case laWestWall:

fcol = get_color_auto3(c->landparam, westwall_colors);

break;

case laDungeon: {

int lp = c->landparam % 5;

// xcol = (c->landparam&1) ? 0xD00000 : 0x00D000;

int lps[5] = { 0x402000, 0x302000, 0x202000, 0x282000, 0x382000 };

fcol = lps[lp];

if(c->wall == waClosedGate)

fcol = wcol = 0xC0C0C0;

if(c->wall == waOpenGate)

fcol = wcol = 0x404040;

if(c->wall == waPlatform)

fcol = wcol = 0xDFB520;

break;

}

case laEndorian: {

int clev = pd_from->land == laEndorian ? edgeDepth(pd_from) : 0;

// xcol = (c->landparam&1) ? 0xD00000 : 0x00D000;

fcol = get_color_auto3(c->landparam, endorian_colors, 1);

int ed = edgeDepth(c);

int sr = get_sightrange_ambush();

if(clev == UNKNOWN || ed == UNKNOWN)

fcol = endorian_colors.back();

else {

while(ed > clev + sr) ed -= 2;

while(ed < clev - sr) ed += 2;

fcol = gradient(fcol, endorian_colors.back(), clev-sr, ed, clev+sr);

}

if(c->wall == waTrunk) fcol = winf[waTrunk].color;

if(c->wall == waCanopy || c->wall == waSolidBranch || c->wall == waWeakBranch) {

fcol = get_color_auto3(c->landparam, canopy_colors);

}

break;

}

#if CAP_FIELD

case laPrairie:

if(prairie::isriver(c)) {

fcol = get_color_auto3(prairie::get_val(c),

higher_contrast ? prairie_colors_high_cont : prairie_colors);

}

else {

fcol = 0x004000 + 0x001000 * c->LHU.fi.walldist;

fcol += 0x10000 * (255 - 511 / (1 + max((int) c->LHU.fi.flowerdist, 1)));

if(ls::hv_structure()) fcol = prairie::nearriver(c) ? 0x40FF00 : 0x40D000;

// fcol += 0x1 * (511 / (1 + max((int) c->LHU.fi.walldist2, 1)));

}

break;

#endif

case laCamelot: {

int d = ((eubinary||c->master->alt) ? celldistAltRelative(c) : 0);

#if CAP_TOUR

if(!tour::on) camelotcheat = false;

#endif

if(camelotcheat || shadingcheat)

fcol = get_color_auto3(d, camelot_cheat_colors);

else if(d < 0) {

fcol = floorcolors[c->land];

}

else {

// a nice floor pattern

int v = emeraldval(c);

int v0 = (v&~3);

bool sw = (v&1);

if(v0 == 8 || v0 == 12 || v0 == 20 || v0 == 40 || v0 == 36 || v0 == 24)

sw = !sw;

if(sw)

fcol = 0xC0C0C0;

else

fcol = 0xA0A0A0;

}

break;

}

case laIce: case laCocytus: case laBlizzard: case laEclectic:

if(useHeatColoring(c)) {

float h = HEAT(c);

eLand l = c->land;

color_t colorN04 = l == laCocytus ? 0x4080FF : 0x4040FF;

color_t colorN10 = 0x0000FF;

color_t color0 = floorcolors[c->land];

color_t color02 = 0xFFFFFF;

color_t color06 = 0xFF0000;

color_t color08 = 0xFFFF00;

if(h < -1)

wcol = colorN10;

else if(h < -0.4)

wcol = gradient(colorN04, colorN10 , -0.4, h, -1);

else if(h < 0)

wcol = gradient(color0, colorN04, 0, h, -0.4);

else if(h < 0.2)

wcol = gradient(color0, color02, 0, h, 0.2);

// else if(h < 0.4)

// wcol = gradient(0xFFFFFF, 0xFFFF00, 0.2, h, 0.4);

else if(h < 0.6)

wcol = gradient(color02, color06, 0.2, h, 0.6);

else if(h < 0.8)

wcol = gradient(color06, color08, 0.6, h, 0.8);

else

wcol = color08;

if(c->wall == waFrozenLake)

fcol = wcol;

else

fcol = (wcol & 0xFEFEFE) >> 1;

if(c->wall == waLake)

fcol = wcol = (wcol & 0xFCFCFC) >> 2;

}

if(realred(c))

eclectic_red(wcol);

break;

case laOcean:

if(ls::any_chaos())

fcol = gradient(0xD0A090, 0xD0D020, 0, c->CHAOSPARAM, 30);

else

fcol = gradient(0xD0D090, 0xD0D020, -1, sin((double) c->landparam), 1);

break;

case laSnakeNest: {

int fv = pattern_threecolor(c);

fcol = nestcolors[fv&7];

if(realred(c->wall))

wcol = fcol * (4 + snakelevel(c)) / 4;

break;

}

default:

if(isElemental(c->land)) fcol = linf[c->land].color;

if(isWarpedType(c->land)) {

fcol = warptype(c) ? 0x80C080 : 0xA06020;

if(c->wall == waSmallTree) wcol = 0x608000;

}

if(isHaunted(c->land)) {

if(shadingcheat) {

int d = getHauntedDepth(c);

if(d == 0) fcol = haunted_cheat_colors[2];

else fcol = get_color_auto3(d, haunted_cheat_colors, 1);

} else {

int itcolor = 0;

for(int i=0; i<c->type; i++) if(c->move(i) && c->move(i)->item)

itcolor = 1;

if(c->item) itcolor |= 2;

fcol = floorcolors[laHaunted] + 0x202020 * itcolor;

forCellEx(c2, c) if(c2->monst == moFriendlyGhost)

fcol = gradient(fcol, fghostcolor(c2), 0, .25, 1);

if(c->monst == moFriendlyGhost)

fcol = gradient(fcol, fghostcolor(c), 0, .5, 1);

}

if (!higher_contrast) {

if(c->wall == waSmallTree) wcol = 0x004000;

else if(c->wall == waBigTree) wcol = 0x008000;

}

}

}

/* if(c->land == laCaribbean && (c->wall == waCIsland || c->wall == waCIsland2))

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: case waExplosiveBarrel:

// floors become fcol

fcol = wcol;

break;

case waCrateCrate: case waCrateTarget: case waCrateOnTarget:

fcol = c->landparam;

break;

case waDeadTroll2: case waPetrifiedBridge: case waPetrified: {

eMonster m = eMonster((unsigned char)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

wcol = winf[conditional_flip_slime(det(V.T) < 0, c->wall)].color;

if(c->item && !(history::includeHistory && history::infindhistory.count(c)))

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 CAP_COMPLEX2

if(!mine_markers) fcol = wcol = apply_mine_knowledge(wcol, c);

goto fallthrough;

#endif

case waMineOpen: fallthrough:

if(wmblack || wmascii) {

wcol &= 0xFEFEFE;

wcol >>= 1;

}

fcol = wcol;

break;

case waCavewall:

if(c->land != laEmerald) fcol = winf[waCavefloor].color;

break;

case waEditStatue:

if(c->land == laCanvas) wcol = c->landparam;

else wcol = (0x125628 * c->wparam) & 0xFFFFFF;

default:

break;

}

/* if(false && isAlch2(c, true)) {

if(WDIM == 2) {

int rd = rosedist(c);

if(rd == 1)

wcol = gradient(0x804060, wcol, 0,1,3),

fcol = gradient(0x804060, fcol, 0,1,3);

if(rd == 2)

wcol = gradient(0x804060, wcol, 0,2,3),

fcol = gradient(0x804060, fcol, 0,2,3);

}

if(items[itRevolver] && !shmup::on) {

bool inrange = c->mpdist <= GUNRANGE;

if(inrange) {

inrange = false;

for(cell *pc: player_positions())

for(cell *c1: gun_targets(pc)) if(c1 == c)

inrange = true;

}

if(!inrange)

fcol = gradient(fcol, 0, 0, 25, 100),

wcol = gradient(wcol, 0, 0, 25, 100);

}

if(highwall(c) && !wmspatial)

fcol = wcol;

if(wmascii && (c->wall == waNone || isWatery(c))) wcol = fcol;

if(!wmspatial && snakelevel(c) && !realred(c->wall)) fcol = wcol;

if(c->wall == waGlass && !wmspatial) fcol = wcol;

wcol_star = wcol;

if(festive) {

if(auto *at = at_or_null(old_shines, c)) {

fcol = darkenedby(fcol, fd);

wcol = darkenedby(wcol, fd);

fd = 0;

for(int p=0; p<3; p++) {

part(fcol, p) = min(255, part(fcol, p) + (*at)[p] / 4);

part(wcol, p) = min(255, part(wcol, p) + (*at)[p] / 8);

}

}

}

if(neon_mode == eNeon::illustration) {

fcol = highwall(c) ? w_monochromatize(fcol, 0) : w_monochromatize(fcol, 1);

wcol = w_monochromatize(wcol, 0);

if(c->land == laWarpCoast && !pseudohept(c) && c->wall == waNone) fcol = 0x707070;

}

int c = part(x,2) + part(x,1) + part(x, 0) + 1;

c /= 3;

if(d != 0) c = (c + 2 * 255) / 3;

return c * 0x10101;

if(inmirror(c)) {

// for debugging

if(c->land == laMirrored) fcol = 0x008000;

if(c->land == laMirrorWall2) fcol = 0x800000;

if(c->land == laMirrored2) fcol = 0x000080;

}

for(int k=0; k<inmirrorcount; k++)

wcol = gradient(wcol, 0xC0C0FF, 0, 0.2, 1),

fcol = gradient(fcol, 0xC0C0FF, 0, 0.2, 1);

aura_color = fcol;

if(peace::on && peace::hint && (c->land != laTortoise || !tortoise::shading_on())) {

int d =

(c->land == laCamelot || (c->land == laCaribbean && celldistAlt(c) <= 0) || (c->land == laPalace && celldistAlt(c))) ? celldistAlt(c):

celldist(c);

int dc =

0x10101 * (127 + int(127 * sintick(200, d*spinspeed)));

wcol = gradient(wcol, dc, 0, .3, 1);

fcol = gradient(fcol, dc, 0, .3, 1);

}

color_t col;

if(c->wall == waTower)

col = 0xD0D0D0-i*0x101010;

else if(c->land == laSnakeNest)

return darkena(nestcolors[pattern_threecolor(c)] * (5 + i) / 4, 0, 0xFF);

#if CAP_COMPLEX2

else if(c->land == laBrownian)

col = brownian::get_color(c->landparam % brownian::level + (i+1) * brownian::level);

#endif

else if(i == last-1)

col = wcol;

else {

col = winf[waRed1+i].color;

if(c->land == laEclectic)

eclectic_red(col);

if(!noshadow && qfi.fshape) {

dynamicval<color_t> p(poly_outline, OUTLINE_TRANS);

draw_shapevec(c, V, qfi.fshape->shadow, SHADOW_WALL, GDIM == 3 ? PPR::TRANSPARENT_SHADOW : PPR::WALLSHADOW);

}

if(no_wall_rendering) return;

if(GDIM == 3 && WDIM == 2) {

if(!qfi.fshape) qfi.fshape = &cgi.shFullFloor;

if(conegraph(c)) {

draw_shapevec(c, V, qfi.fshape->cone[0], darkena(wcol_star, 0, 0xFF), PPR::WALL);

draw_wallshadow();

return;

}

if(c->wall == waClosedGate) {

int hdir = 0;

for(int i=0; i<c->type; i++) if(c->move(i)->wall == waClosedGate)

hdir = i;

queuepolyat(V * ddspin180(c, hdir), cgi.shPalaceGate, darkena(wcol, 0, 0xFF), wmspatial?PPR::WALL_DECO:PPR::WALL);

return;

}

draw_wallshadow();

return;

}

aura_color = wcol;

color_t wcol0 = wcol;

int starcol = wcol_star;

if(c->wall == waWarpGate) starcol = 0;

if(c->wall == waVinePlant) starcol = 0x60C000;

if(c->wall == waClosedGate) {

int hdir = 0;

for(int i=0; i<c->type; i++) if(c->move(i) && c->move(i)->wall == waClosedGate)

hdir = i;

shiftmatrix V2 = orthogonal_move_fol(V, wmspatial?cgi.WALL:1) * ddspin180(c, hdir); // to test

queuepolyat(V2, cgi.shPalaceGate, darkena(wcol, 0, 0xFF), wmspatial?PPR::WALL_DECO:PPR::WALL);

starcol = 0;

}

hpcshape& shThisWall = isGrave(c->wall) ? cgi.shCross : cgi.shWall[ct6];

shiftmatrix V1 = V;

if(&shThisWall == &cgi.shCross) {

auto si = patterns::getpatterninfo(c, patterns::PAT_ZEBRA, patterns::SPF_SYM0123);

V1 = V * applyPatterndir(c, si);

}

if(conegraph(c)) {

const int layers = 2 << detaillevel;

for(int z=1; z<layers; z++) {

double zg = zgrad0(0, geom3::actual_wall_height(), z, layers);

draw_qfi(c, xyzscale(V, zg*(layers-z)/layers, zg),

darkena(gradient(0, wcol_star, -layers, z, layers), 0, 0xFF), PPR::WALL_DECO);

}

floorShadow(c, V, SHADOW_WALL);

}

else if(true) {

if(!wmspatial) {

if(starcol) queuepoly(V1, shThisWall, darkena(starcol, 0, 0xFF));

}

else {

shiftmatrix Vdepth = orthogonal_move_fol(V1, cgi.WALL);

int alpha = 0xFF;

if(c->wall == waIcewall)

alpha = 0xC0;

if(starcol && !(wmescher && c->wall == waPlatform))

queuepolyat(Vdepth, shThisWall, darkena(starcol, 0, 0xFF), PPR::WALL_DECO);

draw_qfi(c, Vdepth, darkena(wcol0, fd, alpha), PPR::WALL_TOP);

floorShadow(c, V, SHADOW_WALL);

}

}

double footphase;

if(WDIM == 3 && c == cwt.at && hide_player()) return;

bool magical = items[itOrbWater] && (isPlayerOn(c) || (isFriendly(c) && items[itOrbEmpathy]));

int outcol = magical ? watercolor(0) : 0xC06000FF;

int incol = magical ? 0x0060C0FF : 0x804000FF;

bool nospin = false;

if(WDIM == 3) {

Vboat = V;

nospin = c->wall == waBoat && applyAnimation(c, Vboat, footphase, LAYER_BOAT);

if(!nospin) Vboat = face_the_player(V);

else Vboat = Vboat * cspin180(0, 2);

queuepolyat(orthogonal_move(Vboat, cgi.scalefactor/2), cgi.shBoatOuter, outcol, PPR::BOATLEV2);

queuepolyat(orthogonal_move(Vboat, cgi.scalefactor/2-0.01), cgi.shBoatInner, incol, PPR::BOATLEV2);

return;

}

if(wmspatial && c->wall == waBoat) {

nospin = c->wall == waBoat && applyAnimation(c, Vboat, footphase, LAYER_BOAT);

if(!nospin && c->mondir != NODIR) Vboat = Vboat * ddspin180(c, c->mondir);

queuepolyat(Vboat, cgi.shBoatOuter, outcol, PPR::BOATLEV);

Vboat = V;

}

if(c->wall == waBoat) {

nospin = applyAnimation(c, Vboat, footphase, LAYER_BOAT);

}

if(!nospin && c->mondir != NODIR)

Vboat = Vboat * ddspin180(c, c->mondir);

else {

shiftmatrix Vx;

if(applyAnimation(c, Vx, footphase, LAYER_SMALL))

animations[LAYER_SMALL][c].footphase = 0;

}

if(wmspatial && GDIM == 2)

queuepolyat(orthogonal_move_fol(Vboat, (cgi.WATERLEVEL+cgi.FLOOR)/2), cgi.shBoatOuter, outcol, PPR::BOATLEV2);

if(GDIM == 3) {

queuepoly(orthogonal_move(Vboat, -0.004), cgi.shBoatOuter, outcol);

queuepoly(orthogonal_move(Vboat, -0.008), cgi.shBoatInner, incol);

}

else {

queuepoly(Vboat, cgi.shBoatOuter, outcol);

queuepoly(Vboat, cgi.shBoatInner, incol);

}

int prec = sphere ? 3 : 1;

prec += vid.linequality;

return prec;

cell *c1 = c->move(t);

if(!c1) return false;

// removed: if(WDIM == 3 && bt::in() && !sn::in()) return !among(t, 5, 6, 8);

if(c == c1 && t <= c->c.spin(t)) return true;

bool order = c < c1;

if(disksize) order = disk_index(c) < disk_index(c1);

return order || isWarped(c->move(t)) || fake::split();

int prec = grid_prec();

if(inmirrorcount) return;

if(vid.grid || (c->land == laAsteroids && !(WDIM == 2 && GDIM == 3))) ; else return;

dynamicval<ld> lw(vid.linewidth, vid.linewidth);

vid.linewidth *= vid.multiplier_grid;

vid.linewidth *= cgi.scalefactor;

int maxt = c->type;

if(arb::apeirogon_hide_grid_edges && arb::is_apeirogonal(c)) maxt -= 2;

if(isWarped(c) && has_nice_dual()) {

if(pseudohept(c)) for(int t=0; t<c->type; t++) if(isWarped(c->move(t)))

gridline(V, get_warp_corner(c, t%c->type), get_warp_corner(c, (t+1)%c->type), gridcolor(c, c->move(t)), prec);

return;

}

for(int t=0; t<maxt; t++)

if(pick_for_grid(c, t))

draw_grid_edge(t, gridcolor(c, c->move(t)), prec);

#if MAXMDIM == 4

if(WDIM == 3) {

int ofs = currentmap->wall_offset(c);

// if(bt::in() && !sn::in() && !among(t, 5, 6, 8)) continue;

// if(!bt::in() && c->move(t) < c) continue;

dynamicval<color_t> g(poly_outline, col);

bool use_fat = fat_edges && (reg3::in() || euc::in(3));

if(!use_fat) {

queuepoly(V, cgi.shWireframe3D[ofs + t], 0);

return;

}

auto& ss = currentmap->get_cellshape(c);

auto& fa = ss.faces[t];

int face = isize(fa);

for(int j=0; j<face; j++) {

int jj = j == face-1 ? 0 : j+1;

int jjj = jj == face-1 ? 0 : jj+1;

hyperpoint a = fa[j];

hyperpoint b = fa[jj];

if(cgflags & qIDEAL) {

ld mm = cgi.ultra_mirror_part;

if((cgflags & qULTRA) && !reg3::ultra_mirror_in())

mm = lerp(1-cgi.ultra_material_part, cgi.ultra_material_part, .99);

tie(a, b) = make_pair(normalize(lerp(a, b, mm)), normalize(lerp(b, a, mm)));

}

else {

a = normalize(a);

b = normalize(b);

}

gridline(V, a, b, col, prec);

if(reg3::ultra_mirror_in()) {

hyperpoint a = fa[j];

hyperpoint b = fa[jj];

hyperpoint d = fa[jjj];

auto& mm = cgi.ultra_mirror_part;

tie(a, d) = make_pair(normalize(lerp(a, b, mm)), normalize(lerp(d, b, mm)));

gridline(V, a, d, stdgridcolor, prec);

}

}

return;

}

#endif

#if CAP_BT

if(bt::in() && WDIM == 2) {

auto h0 = bt::get_corner_horo_coordinates(c, t);

auto h1 = bt::get_corner_horo_coordinates(c, t+1);

int steps = 12 * abs(h0[1] - h1[1]);

if(!steps) {

gridline(V, bt::get_horopoint(h0), bt::get_horopoint(h1), col, prec);

}

else {

if(vid.linequality > 0) steps <<= vid.linequality;

if(vid.linequality < 0) steps >>= -vid.linequality;

auto step = (h1 - h0) / steps;

if(GDIM == 3) {

for(int i=0; i<=steps; i++) gridline(V, bt::get_horopoint(h0 + i * step), V, bt::get_horopoint(h0 + (i+1) * step), gridcolor(c, c->move(t)), prec-2);

}

else {

for(int i=0; i<=steps; i++) curvepoint(bt::get_horopoint(h0 + i * step));

queuecurve(V, col, 0, PPR::LINE);

}

}

return;

}

#endif

gridline(V, get_corner_position(c, t%c->type), get_corner_position(c, (t+1)%c->type), col, prec);

int i =-1;

for(int t=0;t<6; t++) if(c->move(t) && c->move(t)->wall == c->wall)

i = t;

qfi.spin = ddspin(c, i, M_PI/S3);

shiftmatrix V2 = V * qfi.spin;

if(wmspatial && wmescher && GDIM == 2) {

set_floor(cgi.shSemiFeatherFloor[0]);

int dk = 1;