diff --git a/3d-models.cpp b/3d-models.cpp
index 5bc741f5..4345c10f 100644
--- a/3d-models.cpp
+++ b/3d-models.cpp
@@ -1135,7 +1135,7 @@ void geometry_information::make_3d_models() {
     }
 
   shift_shape(shBoatOuter, FLOOR);
-  shift_shape(shBoatInner, (FLOOR+LAKE)/2);
+  shift_shape(shBoatInner, (FLOOR+WATERLEVEL)/2);
   
   for(int i=0; i<14; i++)
     shift_shape(shTriheptaSpecial[i], FLOOR);
diff --git a/celldrawer.cpp b/celldrawer.cpp
index c8e5c7dd..f4c3a7b2 100644
--- a/celldrawer.cpp
+++ b/celldrawer.cpp
@@ -4,6 +4,11 @@ namespace hr {
 #if HDR
 int coastvalEdge(cell *c);
 
+struct spatial_info {
+  SIDE top, deep;
+  int levels;
+  };
+
 struct celldrawer {
   cell *c;
   shiftmatrix V;
@@ -14,7 +19,6 @@ struct celldrawer {
   color_t asciicol;
   color_t aura_color;
   int fd;
-  int chasmg;
   int ct6;
   bool error;
   bool onradar;
@@ -22,6 +26,7 @@ struct celldrawer {
   shiftmatrix Vboat;
   shiftmatrix Vd;
   int sl;
+  spatial_info sha;
   color_t asciiborder;
   color_t asciicol1;
   char asciichar1;
@@ -730,18 +735,9 @@ void celldrawer::draw_wall() {
       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::WALL3A:PPR::WALL);
+      queuepolyat(V * ddspin180(c, hdir), cgi.shPalaceGate, darkena(wcol, 0, 0xFF), wmspatial?PPR::WALL_DECO:PPR::WALL);
       return;
       }
-    color_t wcol0 = wcol_star;
-    color_t wcol2 = gradient(0, wcol0, 0, .8, 1);
-    color_t wcol1 = wcol2;
-    if(geometry == gEuclidSquare) wcol1 = gradient(0, wcol0, 0, .9, 1);
-    draw_shapevec(c, V, qfi.fshape->levels[SIDE_WALL], darkena(wcol_star, 0, 0xFF), PPR::WALL);
-    forCellIdEx(c2, i, c) 
-      if(!highwall(c2) || conegraph(c2) || c2->wall == waClosedGate || fake::split())
-        placeSidewall(c, i, SIDE_WALL, V, darkena((i&1)?wcol1:wcol2, fd, 255));
-
     draw_wallshadow();
     return;
     }
@@ -752,14 +748,12 @@ void celldrawer::draw_wall() {
   if(c->wall == waWarpGate) starcol = 0;
   if(c->wall == waVinePlant) starcol = 0x60C000;
 
-  color_t wcol2 = gradient(0, wcol0, 0, .8, 1);
-
   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::WALL3A:PPR::WALL);
+    queuepolyat(V2, cgi.shPalaceGate, darkena(wcol, 0, 0xFF), wmspatial?PPR::WALL_DECO:PPR::WALL);
     starcol = 0;
     }
   
@@ -776,7 +770,7 @@ void celldrawer::draw_wall() {
     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::WALL3+z-layers+2);
+        darkena(gradient(0, wcol_star, -layers, z, layers), 0, 0xFF), PPR::WALL_SIDE);
       }
     floorShadow(c, V, SHADOW_WALL);
     }
@@ -792,31 +786,10 @@ void celldrawer::draw_wall() {
         alpha = 0xC0;
 
       if(starcol && !(wmescher && c->wall == waPlatform)) 
-        queuepolyat(Vdepth, shThisWall, darkena(starcol, 0, 0xFF), PPR::WALL3A);
+        queuepolyat(Vdepth, shThisWall, darkena(starcol, 0, 0xFF), PPR::WALL_DECO);
 
-      draw_qfi(c, Vdepth, darkena(wcol0, fd, alpha), PPR::WALL3);
+      draw_qfi(c, Vdepth, darkena(wcol0, fd, alpha), PPR::WALL_TOP);
       floorShadow(c, V, SHADOW_WALL);
-      
-      if(c->wall == waCamelot) {
-        forCellIdEx(c2, i, c) {
-          if(placeSidewall(c, i, SIDE_SLEV, V, darkena(wcol2, fd, alpha))) break;
-          }
-        forCellIdEx(c2, i, c) {
-          if(placeSidewall(c, i, SIDE_SLEV+1, V, darkena(wcol2, fd, alpha))) break;
-          }
-        forCellIdEx(c2, i, c) {
-          if(placeSidewall(c, i, SIDE_SLEV+2, V, darkena(wcol2, fd, alpha))) break;
-          }
-        forCellIdEx(c2, i, c) {
-          if(placeSidewall(c, i, SIDE_WTS3, V, darkena(wcol2, fd, alpha))) break;
-          }
-        }
-      else {
-        forCellIdEx(c2, i, c) 
-          if(!highwall(c2) || conegraph(c2) || neon_mode == eNeon::illustration) {
-          if(placeSidewall(c, i, SIDE_WALL, V, darkena(wcol2, fd, alpha))) break;
-          }
-        }
       }
     }
   }
@@ -856,7 +829,7 @@ void celldrawer::draw_boat() {
       animations[LAYER_SMALL][c].footphase = 0;
     }
   if(wmspatial && GDIM == 2)
-    queuepolyat(orthogonal_move_fol(Vboat, (cgi.LAKE+1)/2), cgi.shBoatOuter, outcol, PPR::BOATLEV2);
+    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);
@@ -995,8 +968,8 @@ void celldrawer::draw_halfvine() {
     set_floor(cgi.shSemiFeatherFloor[0]);
     int dk = 1;
     int vcol = winf[waVinePlant].color;
-    draw_qfi(c, orthogonal_move_fol(V2, cgi.WALL), darkena(vcol, dk, 0xFF), PPR::WALL3A);
-    escherSidewall(c, SIDE_WALL, V2, darkena(gradient(0, vcol, 0, .8, 1), dk, 0xFF));
+    draw_qfi(c, orthogonal_move_fol(V2, cgi.WALL), darkena(vcol, dk, 0xFF), PPR::WALL_DECO);
+    escherSidewall(c, SIDE::WALL, V2, darkena(gradient(0, vcol, 0, .8, 1), dk, 0xFF));
     queuepoly(V2, cgi.shSemiFeatherFloor[1], darkena(fcol, dk, 0xFF));
     set_floor(cgi.shFeatherFloor);
     }
@@ -1011,25 +984,25 @@ void celldrawer::draw_halfvine() {
     
     shiftmatrix Vdepth = orthogonal_move_fol(V2, cgi.WALL);
 
-    queuepolyat(GDIM == 2 ? Vdepth : V2, cgi.shSemiFloor[0], darkena(vcol, fd, 0xFF), PPR::WALL3A);
+    queuepolyat(GDIM == 2 ? Vdepth : V2, cgi.shSemiFloor[0], darkena(vcol, fd, 0xFF), PPR::WALL_DECO);
     if(!noshadow) {
       dynamicval<color_t> p(poly_outline, OUTLINE_TRANS);
       queuepolyat(V2 * spin(120._deg), cgi.shSemiFloorShadow, SHADOW_WALL, GDIM == 2 ? PPR::WALLSHADOW : PPR::TRANSPARENT_SHADOW);
       }
     #if MAXMDIM >= 4
     if(GDIM == 3 && qfi.fshape) {
-      auto& side = queuepolyat(V2, cgi.shSemiFloorSide[SIDE_WALL], darkena(vcol, fd, 0xFF), PPR::WALL3A-2+away(V2.T));
+      auto& side = queuepolyat(V2, cgi.shSemiFloorSide[SIDE::WALL], darkena(vcol, fd, 0xFF), PPR::WALL_DECO-2+away(V2.T));
       side.tinf = &floor_texture_vertices[shar.id];
       ensure_vertex_number(*side.tinf, side.cnt);
       }
     #endif
 
-    if(cgi.validsidepar[SIDE_WALL]) forCellIdEx(c2, j, c) {
+    if(cgi.validsidepar[SIDE::WALL]) forCellIdEx(c2, j, c) {
       int dis = i-j;
       dis %= 6;
       if(dis<0) dis += 6;
       if(dis != 1 && dis != 5) continue;
-      if(placeSidewall(c, j, SIDE_WALL, V, darkena(vcol2, fd, 0xFF))) break;
+      if(placeSidewall(c, j, SIDE::WALL, V, darkena(vcol2, fd, 0xFF))) break;
       }
     }
   
@@ -1076,10 +1049,10 @@ void celldrawer::draw_mirrorwall() {
     else if(wmspatial) {
       const int layers = 2 << detaillevel;
       for(int z=1; z<layers; z++) 
-        queuepolyat(orthogonal_move_fol(V2, zgrad0(0, geom3::actual_wall_height(), z, layers)), cgi.shHalfMirror[2], 0xC0C0C080, PPR::WALL3+z-layers);
+        queuepolyat(orthogonal_move_fol(V2, zgrad0(0, geom3::actual_wall_height(), z, layers)), cgi.shHalfMirror[2], 0xC0C0C080, PPR::WALL_SIDE);
       }
     else
-      queuepolyat(V2, cgi.shHalfMirror[2], 0xC0C0C080, PPR::WALL3);
+      queuepolyat(V2, cgi.shHalfMirror[2], 0xC0C0C080, PPR::WALL_TOP);
     }
   else {
     qfi.spin = ddspin180(c, d);
@@ -1104,10 +1077,10 @@ void celldrawer::draw_mirrorwall() {
     else if(wmspatial) {
       const int layers = 2 << detaillevel;
       for(int z=1; z<layers; z++) 
-        queuepolyat(orthogonal_move_fol(V2, zgrad0(0, geom3::actual_wall_height(), z, layers)), cgi.shHalfMirror[ct6], 0xC0C0C080, PPR::WALL3+z-layers);
+        queuepolyat(orthogonal_move_fol(V2, zgrad0(0, geom3::actual_wall_height(), z, layers)), cgi.shHalfMirror[ct6], 0xC0C0C080, PPR::WALL_SIDE);
       }
     else 
-      queuepolyat(V2, cgi.shHalfMirror[ct6], 0xC0C0C080, PPR::WALL3);
+      queuepolyat(V2, cgi.shHalfMirror[ct6], 0xC0C0C080, PPR::WALL_TOP);
     }
   }
 
@@ -1143,7 +1116,7 @@ void celldrawer::set_land_floor(const shiftmatrix& Vf) {
         case caflDragon: set_floor(cgi.shDragonFloor); break;
         case caflReptile: set_reptile_floor(V, fcol); break;
         case caflHive:
-          if(c->wall != waFloorB && c->wall != waFloorA && c->wall != waMirror && c->wall != waCloud && !chasmgraph(c)) {
+          if(c->wall != waFloorB && c->wall != waFloorA && c->wall != waMirror && c->wall != waCloud && sha.top == SIDE::FLOOR) {
             set_floor(cgi.shFloor);
             if(GDIM == 2) {
               draw_floorshape(c, V, cgi.shMFloor, darkena(fcol, fd + 1, 0xFF), PPR::FLOORa);
@@ -1155,7 +1128,7 @@ void celldrawer::set_land_floor(const shiftmatrix& Vf) {
           break;
         case caflSwitch:
           set_floor(cgi.shSwitchFloor);
-          if(!chasmgraph(c) && ctof(c) && STDVAR && !arcm::in() && !bt::in() && GDIM == 2) for(int i=0; i<c->type; i++)
+          if(sha.top == SIDE::FLOOR && ctof(c) && STDVAR && !arcm::in() && !bt::in() && GDIM == 2) for(int i=0; i<c->type; i++)
             queuepoly(Vf * ddspin(c, i, M_PI/S7) * xpush(cgi.rhexf), cgi.shSwitchDisk, darkena(fcol, fd, 0xFF));
           break;
         case caflTower: set_towerfloor(celldist); break;
@@ -1329,8 +1302,8 @@ void celldrawer::set_land_floor(const shiftmatrix& Vf) {
             shiftmatrix Vbspin = Vf * bspin;
             queuepoly(Vbspin, cgi.shMercuryBridge[1], darkena(fcol, fd+1, 0xFF));
             if(wmspatial) {
-              queuepolyat(orthogonal_move_fol(Vbspin, cgi.LAKE), cgi.shMercuryBridge[1], darkena(gradient(0, winf[waMercury].color, 0, 0.8,1), 0, 0x80), PPR::LAKELEV);
-              queuepolyat(orthogonal_move_fol(Vbspin, cgi.BOTTOM), cgi.shMercuryBridge[1], darkena(0x202020, 0, 0xFF), PPR::LAKEBOTTOM);
+              queuepolyat(orthogonal_move_fol(Vbspin, cgi.WATERLEVEL), cgi.shMercuryBridge[1], darkena(gradient(0, winf[waMercury].color, 0, 0.8,1), 0, 0x80), PPR::WATERLEVEL_TOP);
+              queuepolyat(orthogonal_move_fol(Vbspin, cgi.DEEP), cgi.shMercuryBridge[1], darkena(0x202020, 0, 0xFF), PPR::DEEP_TOP);
               }
             }
           }
@@ -1458,22 +1431,22 @@ void celldrawer::draw_features() {
   
     case waBigBush:
       if(detaillevel >= 2)
-        queuepolyat(at_smart_lof(V, zgrad0(0, cgi.slev, 1, 2)), cgi.shHeptaMarker, darkena(wcol, 0, 0xFF), PPR::REDWALL);
+        queuepolyat(at_smart_lof(V, zgrad0(0, cgi.slev, 1, 2)), cgi.shHeptaMarker, darkena(wcol, 0, 0xFF), PPR::RED1_TOP);
       if(detaillevel >= 1)
-        queuepolyat(at_smart_lof(V, cgi.SLEV[1]) * lpispin(), cgi.shWeakBranch, darkena(wcol, 0, 0xFF), PPR::REDWALL+1);
+        queuepolyat(at_smart_lof(V, cgi.RED[1]) * lpispin(), cgi.shWeakBranch, darkena(wcol, 0, 0xFF), PPR::RED1_TOP+1);
       if(detaillevel >= 2)
-        queuepolyat(at_smart_lof(V, zgrad0(0, cgi.slev, 3, 2)), cgi.shHeptaMarker, darkena(wcol, 0, 0xFF), PPR::REDWALL+2);
-      queuepolyat(at_smart_lof(V, cgi.SLEV[2]), cgi.shSolidBranch, darkena(wcol, 0, 0xFF), PPR::REDWALL+3);
+        queuepolyat(at_smart_lof(V, zgrad0(0, cgi.slev, 3, 2)), cgi.shHeptaMarker, darkena(wcol, 0, 0xFF), PPR::RED1_TOP+2);
+      queuepolyat(at_smart_lof(V, cgi.RED[2]), cgi.shSolidBranch, darkena(wcol, 0, 0xFF), PPR::RED1_TOP+3);
       break;
     
     case waSmallBush:
       if(detaillevel >= 2)
-        queuepolyat(at_smart_lof(V, zgrad0(0, cgi.slev, 1, 2)), cgi.shHeptaMarker, darkena(wcol, 0, 0xFF), PPR::REDWALL);
+        queuepolyat(at_smart_lof(V, zgrad0(0, cgi.slev, 1, 2)), cgi.shHeptaMarker, darkena(wcol, 0, 0xFF), PPR::RED1_TOP);
       if(detaillevel >= 1)
-        queuepolyat(at_smart_lof(V, cgi.SLEV[1]) * lpispin(), cgi.shWeakBranch, darkena(wcol, 0, 0xFF), PPR::REDWALL+1);
+        queuepolyat(at_smart_lof(V, cgi.RED[1]) * lpispin(), cgi.shWeakBranch, darkena(wcol, 0, 0xFF), PPR::RED1_TOP+1);
       if(detaillevel >= 2)
-        queuepolyat(at_smart_lof(V, zgrad0(0, cgi.slev, 3, 2)), cgi.shHeptaMarker, darkena(wcol, 0, 0xFF), PPR::REDWALL+2);
-      queuepolyat(at_smart_lof(V, cgi.SLEV[2]), cgi.shWeakBranch, darkena(wcol, 0, 0xFF), PPR::REDWALL+3);
+        queuepolyat(at_smart_lof(V, zgrad0(0, cgi.slev, 3, 2)), cgi.shHeptaMarker, darkena(wcol, 0, 0xFF), PPR::RED1_TOP+2);
+      queuepolyat(at_smart_lof(V, cgi.RED[2]), cgi.shWeakBranch, darkena(wcol, 0, 0xFF), PPR::RED1_TOP+3);
       break;
   
     case waSolidBranch:
@@ -1487,7 +1460,7 @@ void celldrawer::draw_features() {
     case waLadder:
       if(GDIM == 3) {
         #if MAXMDIM >= 4
-        draw_shapevec(c, V * lzpush(-cgi.human_height/20), cgi.shMFloor.levels[0], 0x804000FF, PPR::FLOOR+1);
+        draw_shapevec(c, V * lzpush(-cgi.human_height/20), cgi.shMFloor.levels[SIDE::FLOOR], 0x804000FF, PPR::FLOOR+1);
         #endif
         }
       else if(euclid) {
@@ -1504,12 +1477,8 @@ void celldrawer::draw_features() {
       Vboat = V;
       dynamicval<qfloorinfo> qfi2(qfi, qfi);
       color_t col = reptilecolor(c);
-      chasmg = 0;
       set_reptile_floor(V, col);
       draw_qfi(c, V, col);
-      forCellIdEx(c2, i, c) if(chasmgraph(c2)) 
-        if(placeSidewall(c, i, SIDE_LAKE, V, darkena(gradient(0, col, 0, .8, 1), fd, 0xFF))) break;
-      chasmg = 1;
       break;
       }
     
@@ -1555,8 +1524,8 @@ void celldrawer::draw_features() {
       if(wmescher && geosupport_football() == 2 && pseudohept(c) && c->land == laPalace) V2 = V * spin(M_PI / c->type);
       if(GDIM == 3) {
         #if MAXMDIM >= 4
-        draw_shapevec(c, V2 * lzpush(-cgi.human_height/40), cgi.shMFloor.levels[0], darkena(winf[c->wall].color, 0, 0xFF));
-        draw_shapevec(c, V2 * lzpush(-cgi.human_height/35), cgi.shMFloor2.levels[0], (!wmblack) ? darkena(fcol, 1, 0xFF) : darkena(0,1,0xFF));
+        draw_shapevec(c, V2 * lzpush(-cgi.human_height/40), cgi.shMFloor.levels[SIDE::FLOOR], darkena(winf[c->wall].color, 0, 0xFF));
+        draw_shapevec(c, V2 * lzpush(-cgi.human_height/35), cgi.shMFloor2.levels[SIDE::FLOOR], (!wmblack) ? darkena(fcol, 1, 0xFF) : darkena(0,1,0xFF));
         #endif
         }
       else {
@@ -1577,11 +1546,11 @@ void celldrawer::draw_features() {
           const int layers = 2 << detaillevel;
           for(int z=1; z<=layers; z++) {
             double zg = zgrad0(0, geom3::actual_wall_height(), z, layers);
-            queuepolyat(xyzscale(V, zg, zg), cgi.shBarrel, darkena((z&1) ? 0xFF0000 : 0xC00000, 0, 0xFF), PPR(PPR::REDWALLm+z));
+            queuepolyat(xyzscale(V, zg, zg), cgi.shBarrel, darkena((z&1) ? 0xFF0000 : 0xC00000, 0, 0xFF), PPR(PPR::RED1_SIDE));
             }
           }
         else {
-          queuepolyat(V, cgi.shBarrel, darkena(0xC00000, 0, 0xFF), PPR(PPR::REDWALLm));
+          queuepolyat(V, cgi.shBarrel, darkena(0xC00000, 0, 0xFF), PPR(PPR::RED1_TOP));
           }
         }
       break;
@@ -1626,13 +1595,13 @@ void celldrawer::draw_features() {
         int dcol = darkena(col, 0, 0x80);
         shiftmatrix Vdepth = orthogonal_move_fol(Vd, cgi.WALL);
         if(GDIM == 3) 
-          draw_shapevec(c, V, cgi.shMFloor.levels[SIDE_WALL], dcol, PPR::WALL);
+          draw_shapevec(c, V, cgi.shMFloor.levels[SIDE::WALL], dcol, PPR::WALL);
         else
           draw_floorshape(c, Vdepth, cgi.shMFloor, dcol, PPR::WALL); // GLASS
         dynamicval<qfloorinfo> dq(qfi, qfi);
         set_floor(cgi.shMFloor);
-        if(cgi.validsidepar[SIDE_WALL]) forCellIdEx(c2, i, c) 
-          if(placeSidewall(c, i, SIDE_WALL, Vd, dcol)) break;
+        if(cgi.validsidepar[SIDE::WALL]) forCellIdEx(c2, i, c)
+          if(placeSidewall(c, i, SIDE::WALL, Vd, dcol)) break;
         }
       break;
     
@@ -1656,8 +1625,8 @@ void celldrawer::draw_features() {
 
       if(GDIM == 3) {
         #if MAXMDIM >= 4
-        draw_shapevec(c, V * lzpush(-cgi.human_height/40), cgi.shMFloor.levels[0], darkena(0xC00000, 0, 0xFF));
-        draw_shapevec(c, V * lzpush(-cgi.human_height/20), cgi.shMFloor2.levels[0], darkena(0x600000, 0, 0xFF));
+        draw_shapevec(c, V * lzpush(-cgi.human_height/40), cgi.shMFloor.levels[SIDE::FLOOR], darkena(0xC00000, 0, 0xFF));
+        draw_shapevec(c, V * lzpush(-cgi.human_height/20), cgi.shMFloor2.levels[SIDE::FLOOR], darkena(0x600000, 0, 0xFF));
         #endif
         }
       else {
@@ -1687,7 +1656,7 @@ void celldrawer::draw_features() {
        for(int z=1; z<layers; z++) {
          double zg = zgrad0(-vid.lake_top, geom3::actual_wall_height(), z, layers);
          draw_qfi(c, xyzscale(V, zg*(layers-z)/layers, zg),
-           darkena(gradient(0, wcol, -layers, z, layers), 0, 0xFF), PPR::WALL3+z-layers+2);
+           darkena(gradient(0, wcol, -layers, z, layers), 0, 0xFF), PPR::WALL_SIDE);
          }
         }
       else goto wa_default;
@@ -1711,21 +1680,11 @@ void celldrawer::draw_features() {
   
     default: {
       wa_default:
+
       if(sl && wmspatial) {
-  
-        if(GDIM == 3 && qfi.fshape)
-          draw_shapevec(c, V, qfi.fshape->levels[sl], darkena(wcol, fd, 0xFF), PPR::REDWALL-4+4*sl);
-        else
-          draw_qfi(c, Vd, darkena(wcol, fd, 0xFF), PPR::REDWALL-4+4*sl);
         floorShadow(c, V, SHADOW_SL * sl);
-        for(int s=0; s<sl; s++) 
-        forCellIdEx(c2, i, c) {
-          int sl_2 = snakelevel(c2);
-          if(s >= sl_2)
-            if(placeSidewall(c, i, SIDE_SLEV+s, V, getSnakelevColor(s, sl))) break;
-          }
         }
-      
+
       else if(highwall(c)) draw_wall();
 
       else if(xch == '%') {
@@ -1737,13 +1696,13 @@ void celldrawer::draw_features() {
           int dcol = darkena(col, 0, 0xC0);
           shiftmatrix Vdepth = orthogonal_move_fol(Vd, cgi.WALL);
           if(GDIM == 3)
-            draw_shapevec(c, V, cgi.shMFloor.levels[SIDE_WALL], dcol, PPR::WALL);
+            draw_shapevec(c, V, cgi.shMFloor.levels[SIDE::WALL], dcol, PPR::WALL);
           else
             draw_floorshape(c, Vdepth, cgi.shMFloor, dcol, PPR::WALL); // GLASS
           dynamicval<qfloorinfo> dq(qfi, qfi);
           set_floor(cgi.shMFloor);
-          if(cgi.validsidepar[SIDE_WALL]) forCellIdEx(c2, i, c) 
-            if(placeSidewall(c, i, SIDE_WALL, Vd, dcol)) break;
+          if(cgi.validsidepar[SIDE::WALL]) forCellIdEx(c2, i, c)
+            if(placeSidewall(c, i, SIDE::WALL, Vd, dcol)) break;
           }
         else {
           queuepoly(V, cgi.shMirror, darkena(wcol, 0, 0xC0));
@@ -1770,14 +1729,14 @@ void celldrawer::draw_features() {
       
       else if(c->wall == waExplosiveBarrel) {
         if(GDIM == 3 && qfi.fshape) {
-          draw_shapevec(c, V, qfi.fshape->cone[1], 0xD00000FF, PPR::REDWALL);
+          draw_shapevec(c, V, qfi.fshape->cone[1], 0xD00000FF, PPR::RED1_TOP);
           draw_wallshadow();
           break;
           }
         const int layers = 2 << detaillevel;
         for(int z=1; z<=layers; z++) {
           double zg = zgrad0(0, geom3::actual_wall_height(), z, layers);
-          queuepolyat(xyzscale(V, zg, zg), cgi.shBarrel, darkena((z&1) ? 0xFF0000 : 0xC00000, 0, 0xFF), PPR(PPR::REDWALLm+z));
+          queuepolyat(xyzscale(V, zg, zg), cgi.shBarrel, darkena((z&1) ? 0xFF0000 : 0xC00000, 0, 0xFF), PPR(PPR::RED1_SIDE));
           }
         }
       
@@ -1949,13 +1908,13 @@ void celldrawer::draw_features_and_walls_3d() {
     else if(winf[c->wall].glyph == '.' || among(c->wall, waFloorA, waFloorB, waChasm, waLadder, waCanopy, waRed1, waRed2, waRed3, waRubble, waDeadfloor2) || isWatery(c) || isSulphuric(c->wall)) ;
     
     else if(c->wall == waBigBush || c->wall == waSolidBranch)
-      queuepolyat(face_the_player(V), cgi.shSolidBranch, darkena(wcol, 0, 0xFF), PPR::REDWALL+3);
+      queuepolyat(face_the_player(V), cgi.shSolidBranch, darkena(wcol, 0, 0xFF), PPR::RED3_TOP);
 
     else if(c->wall == waSmallBush || c->wall == waWeakBranch)
-      queuepolyat(face_the_player(V), cgi.shWeakBranch, darkena(wcol, 0, 0xFF), PPR::REDWALL+3);
+      queuepolyat(face_the_player(V), cgi.shWeakBranch, darkena(wcol, 0, 0xFF), PPR::RED2_TOP);
     
     else
-      queuepoly(face_the_player(V), chasmgraph(c) ? cgi.shSawRing : cgi.shRing, darkena(wcol, 0, 0xFF));
+      queuepoly(face_the_player(V), sha.deep < SIDE::SHALLOW ? cgi.shSawRing : cgi.shRing, darkena(wcol, 0, 0xFF));
     }
 
   after_walls:
@@ -2216,7 +2175,7 @@ EX int default_flooralpha = 255;
 void celldrawer::draw_wall_full() {
 
   shiftmatrix Vf0;
-  const shiftmatrix& Vf = (chasmg && wmspatial) ? (Vf0=orthogonal_move_fol(V, cgi.BOTTOM)) : V;
+  const shiftmatrix& Vf = (sha.top != SIDE::FLOOR) ? (Vf0=orthogonal_move_fol(V, cgi.dhi_table[sha.top])) : V;
 
   #if CAP_SHAPES
   int flooralpha = default_flooralpha;
@@ -2243,9 +2202,9 @@ void celldrawer::draw_wall_full() {
     if(GDIM == 2 && (c->land != laRose || ls::any_chaos())) {
       int rd = rosedist(c);
       if(rd == 1) 
-        draw_floorshape(c, at_smart_lof(V, cgi.SLEV[2]), cgi.shRoseFloor, 0x80406040, PPR::LIZEYE);
+        draw_floorshape(c, at_smart_lof(V, cgi.RED[2]), cgi.shRoseFloor, 0x80406040, PPR::LIZEYE);
       if(rd == 2)
-        draw_floorshape(c, at_smart_lof(V, cgi.SLEV[2]), cgi.shRoseFloor, 0x80406080, PPR::LIZEYE);
+        draw_floorshape(c, at_smart_lof(V, cgi.RED[2]), cgi.shRoseFloor, 0x80406080, PPR::LIZEYE);
       }
 
     if(c->wall == waChasm) {
@@ -2259,11 +2218,11 @@ void celldrawer::draw_wall_full() {
         }
       if(c->land == laZebra) fd++;
       if(c->land == laHalloween && !wmblack) {
-        shiftmatrix Vdepth = wmspatial ? orthogonal_move_fol(V, cgi.BOTTOM) : V;
+        shiftmatrix Vdepth = wmspatial ? orthogonal_move_fol(V, cgi.DEEP) : V;
         if(GDIM == 3)
-          draw_shapevec(c, V, cgi.shFullFloor.levels[SIDE_LAKE], darkena(firecolor(0, 10), 0, 0xDF), PPR::TRANSPARENT_LAKE);
+          draw_shapevec(c, V, cgi.shFullFloor.levels[SIDE::WATERLEVEL], darkena(firecolor(0, 10), 0, 0xDF), PPR::TRANSPARENT_LAKE);
         else
-          draw_floorshape(c, Vdepth, cgi.shFullFloor, darkena(firecolor(0, 10), 0, 0xDF), PPR::LAKEBOTTOM);
+          draw_floorshape(c, Vdepth, cgi.shFullFloor, darkena(firecolor(0, 10), 0, 0xDF), PPR::DEEP_TOP);
         }
       }
 
@@ -2338,14 +2297,7 @@ void celldrawer::draw_wall_full() {
 
     // actually draw the floor
 
-    if(chasmg == 2) ;
-    else if(chasmg && wmspatial && detaillevel == 0) {
-      if(WDIM == 2 && GDIM == 3 && qfi.fshape)
-        draw_shapevec(c, V, qfi.fshape->levels[SIDE_LAKE], darkena3(fcol, fd, 0x80), PPR::LAKELEV);
-      else
-        draw_qfi(c, Vd, darkena(fcol, fd, 0x80), PPR::LAKELEV);
-      }
-    else if(chasmg && wmspatial) {
+    if((sha.top != sha.deep) && wmspatial && detaillevel) {
     
       color_t col = c->land == laCocytus ? 0x080808FF : 0x101010FF;
 
@@ -2358,27 +2310,32 @@ void celldrawer::draw_wall_full() {
       else if(qfi.fshape == &cgi.shCaveFloor)
         set_floor(cgi.shCaveSeabed);
       
-      int sid = SIDE_LTOB;
-      if(c->wall == waShallow) sid = SIDE_ASHA;
-      
       if(WDIM == 2 && GDIM == 3 && qfi.fshape)
-        draw_shapevec(c, V, qfi.fshape->levels[sid], col, PPR::LAKEBOTTOM);
+        draw_shapevec(c, V, qfi.fshape->levels[sha.deep], col, side_to_prio_top[sha.deep]);
       else
-        draw_qfi(c, orthogonal_move_fol(V, cgi.BOTTOM), col, PPR::LAKEBOTTOM);
+        draw_qfi(c, orthogonal_move_fol(V, cgi.dhi_table[sha.deep]), col, side_to_prio_top[sha.deep]);
 
-      int fd0 = fd ? fd-1 : 0;      
+      int fd0 = fd ? fd-1 : 0;
       if(WDIM == 2 && GDIM == 3 && qfi.fshape)
-        draw_shapevec(c, V, qfi.fshape->levels[SIDE_LAKE], darkena3(fcol, fd0, 0x80), PPR::TRANSPARENT_LAKE);
+        draw_shapevec(c, V, qfi.fshape->levels[sha.top], darkena3(fcol, fd0, 0x80), PPR::TRANSPARENT_LAKE);
       else
-        draw_qfi(c, Vd, darkena(fcol, fd0, 0x80), PPR::LAKELEV);
+        draw_qfi(c, Vd, darkena(fcol, fd0, 0x80), PPR::WATERLEVEL_TOP);
       }
-    else {
+
+    else if(sha.top != SIDE::INFDEEP) {
+      auto col = fcol;
       if(patterns::whichShape == '^') poly_outline = darkena(fcol, fd, flooralpha);
+      if(sha.top == SIDE::WALL) col = wcol_star;
+      else if(sha.top >= SIDE::RED1) col = wcol;
+
+      auto sf = sha.top; if(!wmspatial) sf = SIDE::FLOOR;
+
       if(WDIM == 2 && GDIM == 3 && qfi.fshape && !draw_plain_floors)
-        draw_shapevec(c, V, qfi.fshape->levels[0], darkena(fcol, fd, 255), PPR::FLOOR);
-      else {
-        draw_qfi(c, V, darkena3(fcol, fd, flooralpha));
-        }
+        draw_shapevec(c, V, qfi.fshape->levels[sf], darkena(col, fd, 255), side_to_prio_top[sha.top]);
+      else if(sf == SIDE::FLOOR)
+        draw_qfi(c, V, darkena3(col, fd, flooralpha), PPR::FLOOR);
+      else
+        draw_qfi(c, orthogonal_move_fol(V, cgi.dhi_table[sf]), darkena3(col, fd, flooralpha), side_to_prio_top[sha.top]);
       }
     
     #if MAXMDIM >= 4
@@ -2398,7 +2355,7 @@ void celldrawer::draw_wall_full() {
         if(rd == 2) rcol = 0x80406080;
         forCellIdEx(c2, i, c)
           if(rosedist(c2) < rd)
-            placeSidewall(c, i, SIDE_WALL, V, rcol);
+            placeSidewall(c, i, SIDE::WALL, V, rcol);
         for(int i=t; i<isize(ptds); i++) {
           auto p = ptds[i]->as_poly();
           if(p) p->prio = PPR::TRANSPARENT_WALL;
@@ -2472,63 +2429,59 @@ void celldrawer::draw_wall_full() {
     if(wmascii && !((c->item && !itemHiddenFromSight(c)) || c->monst || c->cpdist == 0)) error = true;
     asciiborder = bordcolor;
     }
-  
+
 #if CAP_SHAPES
-  int sha = shallow(c);
+  if(wmspatial) {
+
+    color_t col = (highwall(c) || c->wall == waTower) ? wcol : fcol;
+
+    auto shab = sha.levels;
+    forCellIdEx(c1, i, c) {
+      auto fsha1 = get_spatial_info(c1);
+      auto& sha1 = fsha1.levels;
+      auto sha0 = shab;
+
+      constexpr int w = Flag((int) SIDE::WALL);
+      constexpr int r = ((Flag((int) SIDE::RED1)) | (Flag((int) SIDE::RED2)) | (Flag((int) SIDE::RED3)));
+      constexpr int r4 = r | (Flag((int) SIDE::RED4));
+
+      if(fake::split()) sha1 ^= (w | r | r4);
+
+      if(c->land == laCamelot || ((sha0 & w) && (sha1 & r))) {
+        sha0 ^= (w | r | r4);
+        }
+
+      auto shad = sha0 &~ sha1; shad = shad & ((1<<28)-1);
+
+      while(shad) {
+        int lev = __builtin_ctz(shad);
+        shad ^= (1<<lev);
+        auto col1 = darkena(col, fd, 0xFF);
 
 #define D(v) darkena(gradient(0, col, 0, v * (sphere ? spherity(V.T * currentmap->adj(c,i)) : 1), 1), fd, 0xFF)
-  if(wmspatial && c->wall == waShallow && WDIM == 2) {
-    color_t col = (highwall(c) || c->wall == waTower) ? wcol : fcol;
-    forCellIdEx(c2, i, c) if(chasmgraph(c2) && c2->wall != waShallow)
-      if(placeSidewall(c, i, SIDE_BSHA, V, D(.6))) break;
-    forCellIdEx(c2, i, c) if(chasmgraph(c2) == 2) {
-      dynamicval<qfloorinfo> qfib(qfi, qfi);
-      set_floor(cgi.shFullFloor);
-      placeSidewall(c, i, SIDE_LAKE, V, 0x202030FF);
-      // placeSidewall(c, i, SIDE_LTOB, V, 0x181820FF);
-      placeSidewall(c, i, SIDE_BTOI, V, 0x101010FF);
-      }
-    }
-
-  else if(wmspatial && sha && WDIM == 2) {
-    color_t col = (highwall(c) || c->wall == waTower) ? wcol : fcol;
-    if(!chasmg) {
-
-// #define D(v) darkena(col, fd, 0xFF)
-
-      if(sha & 1) {
-        forCellIdEx(c2, i, c) if(chasmgraph(c2)) 
-          if(placeSidewall(c, i, SIDE_LAKE, V, D(.8))) break;
-        }
-      if(sha & 2) {
-        forCellIdEx(c2, i, c) {
-          if(chasmgraph(c2)) {
-            if(placeSidewall(c, i, c2->wall == waShallow ? SIDE_ASHA : SIDE_LTOB, V, D(.7))) break;
-            }
-          }
-        }
-      if(sha & 4) {
-        bool dbot = true;
-        forCellIdEx(c2, i, c) if(chasmgraph(c2) == 2) {
-          if(dbot) {
-            dbot = false;
-            if(GDIM == 2)
-              draw_qfi(c, orthogonal_move_fol(V, cgi.BOTTOM), 0x080808FF, PPR::LAKEBOTTOM);
-            else if(qfi.fshape)
-              draw_shapevec(c, V, qfi.fshape->levels[SIDE_BTOI], 0x0F0808FF, PPR::LAKEBOTTOM);
-            }
-          if(placeSidewall(c, i, SIDE_BTOI, V, D(.6))) break;
-          }
+        if(SIDE(lev) == SIDE::FLOOR) col1 = D(0.8);
+        if(SIDE(lev) == SIDE::WATERLEVEL) col1 = D(0.75);
+        if(SIDE(lev) == SIDE::SHALLOW) col1 = D(0.7);
 #undef D
+        if(SIDE(lev) == SIDE::DEEP) col1 = 0x101010FF;
+        if(SIDE(lev) == SIDE::WALL) {
+          col1 = (geometry == gEuclidSquare && (i&1)) ? gradient(0, wcol_star, 0, .9, 1) : gradient(0, wcol_star, 0, .8, 1);
+          col1 = darkena(col1, fd, 255);
+          }
+
+        if(lev >= int(SIDE::RED1) && lev <= int(SIDE::RED3) && sl) {
+          col1 = getSnakelevColor(lev - int(SIDE::RED1), sl);
+          }
+
+        if(placeSidewall(c, i, SIDE(lev), V, col1)) shab &= ~(1<<lev);
+        }
+
+      if(sha.top == SIDE::WATERLEVEL && fsha1.top == SIDE::INFDEEP) {
+        dynamicval<qfloorinfo> qfib(qfi, qfi);
+        set_floor(cgi.shFullFloor);
+        placeSidewall(c, i, SIDE::WATERLEVEL, V, 0x202030FF);
+        if(sha.deep == SIDE::DEEP) placeSidewall(c, i, SIDE::SHALLOW, V, 0x181820FF);
         }
-      }
-    // wall between lake and chasm -- no Escher here
-    if(chasmg == 1) forCellIdEx(c2, i, c) if(chasmgraph(c2) == 2) {
-      dynamicval<qfloorinfo> qfib(qfi, qfi);
-      set_floor(cgi.shFullFloor);
-      placeSidewall(c, i, SIDE_LAKE, V, 0x202030FF);
-      placeSidewall(c, i, SIDE_LTOB, V, 0x181820FF);
-      placeSidewall(c, i, SIDE_BTOI, V, 0x101010FF);
       }
     }
   }
@@ -2640,8 +2593,8 @@ void celldrawer::draw_monster_full() {
   if(dm) onradar = false; 
   #if CAP_SHAPES
   if(isize(ptds) != q && !(c == lmouseover_distant && isDie(c->monst))) {
-    if(WDIM == 2 && GDIM == 3 && abs(cgi.SLEV[sl] - cgi.FLOOR) > 1e-6)
-      pushdown(c, q, V, cgi.SLEV[sl] - cgi.FLOOR, false, false);
+    if(WDIM == 2 && GDIM == 3 && abs(cgi.RED[sl] - cgi.FLOOR) > 1e-6)
+      pushdown(c, q, V, cgi.RED[sl] - cgi.FLOOR, false, false);
     if(GDIM ==2 && abs(geom3::factor_to_lev(zlevel(tC0(Vboat.T)))) > 1e-6)
       pushdown(c, q, V, -geom3::factor_to_lev(zlevel(tC0(Vboat.T))), !isMultitile(c->monst), false);
     }
@@ -2650,7 +2603,7 @@ void celldrawer::draw_monster_full() {
 
 void celldrawer::add_map_effects() {
 
-  if(chasmg) draw_fallanims();
+  if(get_spatial_info(c).top < SIDE::FLOOR) draw_fallanims();
 
   if(!shmup::on && sword::at(c)) {
     queuepolyat(V, cgi.shDisk, 0xC0404040, PPR::SWORDMARK);
@@ -2965,23 +2918,21 @@ void celldrawer::draw() {
     
     onradar = true;
     
-    #if CAP_SHAPES
-    chasmg = chasmgraph(c);
-    #endif
+    sha = get_spatial_info(c);
     
     if(c->wall == waMagma) fd = 0;
     
     poly_outline = OUTLINE_DEFAULT;
-    
+
     sl = snakelevel(c);
     
     Vd =
       WDIM == 3 ? V:
       !wmspatial ? V : 
-      sl ? orthogonal_move_fol(V, GDIM == 3 ? cgi.SLEV[sl] - cgi.FLOOR : cgi.SLEV[sl]) :
+      sl ? orthogonal_move_fol(V, GDIM == 3 ? cgi.RED[sl] - cgi.FLOOR : cgi.RED[sl]) :
       (highwall(c) && GDIM == 2) ? orthogonal_move_fol(V, (1+cgi.WALL)/2) :
 #if CAP_SHAPES
-      (chasmg==1) ? orthogonal_move_fol(V, GDIM == 3 ? cgi.LAKE - cgi.FLOOR : cgi.LAKE) :
+      (sha.top < SIDE::FLOOR) ? orthogonal_move_fol(V, GDIM == 3 ? cgi.WATERLEVEL - cgi.FLOOR : cgi.WATERLEVEL) :
 #endif
       V;
     
@@ -3047,16 +2998,12 @@ void celldrawer::draw() {
         for(int z=0; z<sl*4; z++) if(z%4 == 0)
           queuestrn(orthogonal_move_fol(V, zgrad0(0, cgi.slev * sl, z, sl*4)), mapfontscale / 100, s1, darkenedby(gradient(bordcolor, asciicol1, -sl, z, sl*4), darken), 1);
         poly_outline = asciiborder << 8;
-        queuestrn(orthogonal_move_fol(V, cgi.SLEV[sl]), mapfontscale / 100, s, darkenedby(asciicol, darken), 2);
+        queuestrn(orthogonal_move_fol(V, cgi.RED[sl]), mapfontscale / 100, s, darkenedby(asciicol, darken), 2);
         }
-//      else if(c->wall == waChasm) {
-//        const int layers = 1 << detaillevel;
-//        queuestr(orthogonal_move_fol(V, BOTTOM), zgrad0(0, -vid.lake_bottom, z, layers)), 1, s, darkenedby(gradient(asciicol, 0, 0, z, layers+1), darken), z==0?2:1);
-//        }
-      else if(chasmgraph(c)) {
+      else if(sha.top < SIDE::FLOOR) {
         string s1 = s0+asciichar1;
         poly_outline = bordcolor << 8;
-        queuestrn(orthogonal_move_fol(V, cgi.BOTTOM), mapfontscale / 100, s1, darkenedby(gradient(bordcolor, asciicol1, 0, 0.3, 1), darken), 2);
+        queuestrn(orthogonal_move_fol(V, cgi.DEEP), mapfontscale / 100, s1, darkenedby(gradient(bordcolor, asciicol1, 0, 0.3, 1), darken), 2);
         poly_outline = asciiborder << 8;
         queuestrn(V, mapfontscale / 100, s, darkenedby(asciicol, darken), 2);
         }
@@ -3202,7 +3149,7 @@ void celldrawer::set_reptile_floor(const shiftmatrix& V, color_t col, bool nodet
   dynamicval<color_t> p(poly_outline, 
     doHighlight() && ecol != -1 && ecol != 0 ? OUTLINE_ENEMY : OUTLINE_DEFAULT);
 
-  if(!chasmg) {
+  if(sha.top != SIDE::INFDEEP) {
     if(wmescher)
       queuepoly(V*D, cgi.shReptile[j][1], dcol);
     else
@@ -3246,7 +3193,7 @@ void celldrawer::shmup_gravity_floor() {
 
 void celldrawer::draw_reptile(color_t col) {
   auto qfib = qfi;
-  set_reptile_floor(V, col, chasmg == 2);
+  set_reptile_floor(V, col, sha.top == SIDE::INFDEEP);
   draw_qfi(c, V, col);
   qfi = qfib;
   }      
diff --git a/config.cpp b/config.cpp
index 747cbe27..d7655d5e 100644
--- a/config.cpp
+++ b/config.cpp
@@ -3020,7 +3020,7 @@ EX void show3D_height_details() {
     dialog::addBreak(100);
     dialog::addHelp(lalign(0, "absolute altitudes:\n\n"
       "depth ", cgi.INFDEEP,
-      " water ", tie(cgi.BOTTOM, cgi.SHALLOW, cgi.LAKE),
+      " water ", tie(cgi.DEEP, cgi.SHALLOW, cgi.WATERLEVEL),
       " floor ", cgi.FLOOR,
       " eye ", vid.eye,
       " walls ", tie(cgi.WALL, cgi.HIGH, cgi.HIGH2),
diff --git a/drawing.cpp b/drawing.cpp
index c50b4404..e04bd10b 100644
--- a/drawing.cpp
+++ b/drawing.cpp
@@ -2387,9 +2387,12 @@ EX void reverse_priority(PPR p) {
   reverse(ptds.begin()+qp0[int(p)], ptds.begin()+qp[int(p)]);
   }
 
+constexpr PPR all_side_prios[] = {
+  PPR::DEEP_SIDE, PPR::SHALLOW_SIDE, PPR::WATERLEVEL_SIDE, PPR::FLOOR_SIDE, PPR::RED1_SIDE, PPR::RED2_SIDE, PPR::RED3_SIDE, PPR::WALL_SIDE
+  };
+
 EX void reverse_side_priorities() {
-  for(PPR p: {PPR::REDWALLs, PPR::REDWALLs2, PPR::REDWALLs3, PPR::WALL3s,
-    PPR::LAKEWALL, PPR::INLAKEWALL, PPR::BELOWBOTTOM, PPR::BSHALLOW, PPR::ASHALLOW})
+  for(PPR p: all_side_prios)
       reverse_priority(p);
   }
 
@@ -2609,9 +2612,8 @@ EX void drawqueue() {
 
   DEBB(DF_GRAPH, ("sort walls"));
   
-  if(GDIM == 2) 
-  for(PPR p: {PPR::REDWALLs, PPR::REDWALLs2, PPR::REDWALLs3, PPR::WALL3s,
-    PPR::LAKEWALL, PPR::INLAKEWALL, PPR::BELOWBOTTOM, PPR::ASHALLOW, PPR::BSHALLOW}) {
+  if(GDIM == 2)
+  for(PPR p: all_side_prios) {
     int pp = int(p);
     if(qp0[pp] == qp[pp]) continue;
     for(int i=qp0[pp]; i<qp[pp]; i++) {
diff --git a/flags.cpp b/flags.cpp
index 9a67b271..2184d328 100644
--- a/flags.cpp
+++ b/flags.cpp
@@ -345,14 +345,33 @@ EX bool highwall(cell *c) {
   return winf[c->wall].glyph == '#' || c->wall == waClosedGate;
   }
 
-EX int chasmgraph(cell *c) {
-  if(c->wall == waChasm || c->wall == waInvisibleFloor) return 2;
-  if(isChasmy(c)) return 1;
-  if(isWateryOrBoat(c)) return 1;
-  if(c->wall == waShallow) return 1;
-  if(wmescher && c->wall == waBarrier && c->land == laOceanWall) return 1;
-  if(c->wall == waReptileBridge) return 1;
-  return 0;
+EX spatial_info get_spatial_info(cell *c) {
+  #define F(x) Flag((int) SIDE::x)
+  if(cellUnstable(c))
+    return spatial_info{SIDE::INFDEEP, SIDE::INFDEEP, 0};
+  if(c->wall == waChasm || c->wall == waInvisibleFloor)
+    return spatial_info{SIDE::INFDEEP, SIDE::INFDEEP, 0};
+  if(c->wall == waBarrier && wmescher && c->land == laOceanWall)
+    return spatial_info{SIDE::WATERLEVEL, SIDE::DEEP, F(DEEP)};
+  if(c->wall == waReptile)
+    return spatial_info{SIDE::FLOOR, SIDE::FLOOR, F(FLOOR) | F(DEEP)};
+  if(c->wall == waShallow)
+    return spatial_info{SIDE::WATERLEVEL, SIDE::SHALLOW, F(SHALLOW) | F(DEEP)};
+  if(isWateryOrBoat(c) || isChasmy(c))
+    return spatial_info{SIDE::WATERLEVEL, SIDE::DEEP, F(DEEP)};
+  if(among(c->wall, waReptileBridge, waGargoyleFloor, waGargoyleBridge, waTempFloor, waTempBridge, waPetrifiedBridge, waFrozenLake))
+    return spatial_info{SIDE::WATERLEVEL, SIDE::DEEP, F(WATERLEVEL) | F(DEEP)};
+  int slev = snakelevel(c);
+  if(slev == 1)
+    return spatial_info{SIDE::RED1, SIDE::RED1, F(RED1) | F(FLOOR) | F(WATERLEVEL) | F(SHALLOW) | F(DEEP)};
+  if(slev == 2)
+    return spatial_info{SIDE::RED2, SIDE::RED2, F(RED1) | F(RED2) | F(FLOOR) | F(WATERLEVEL) | F(SHALLOW) | F(DEEP)};
+  if(slev == 3)
+    return spatial_info{SIDE::RED3, SIDE::RED3, F(RED1) | F(RED2) | F(RED3) | F(FLOOR) | F(WATERLEVEL) | F(SHALLOW) | F(DEEP)};
+  if(highwall(c))
+    return spatial_info{SIDE::WALL, SIDE::WALL, F(WALL) | F(FLOOR) | F(WATERLEVEL) | F(SHALLOW) | F(DEEP)};
+  return spatial_info{SIDE::FLOOR, SIDE::FLOOR, F(FLOOR) | F(WATERLEVEL) | F(SHALLOW) | F(DEEP)};
+  #undef F
   }
 
 EX bool conegraph(cell *c) {
diff --git a/floorshapes.cpp b/floorshapes.cpp
index 9041bc60..547c94c7 100644
--- a/floorshapes.cpp
+++ b/floorshapes.cpp
@@ -319,18 +319,18 @@ void geometry_information::bshape_regular(floorshape &fsh, int id, int sides, ld
       hpcpush(hpc[last->s]);
       }
     
-    for(int k=0; k<SIDEPARS; k++) {
-      if(isize(fsh.gpside[k]) < c->type)
-        fsh.gpside[k].resize(c->type);
+    for(auto p: allsides) {
+      if(isize(fsh.gpside[p]) < c->type)
+        fsh.gpside[p].resize(c->type);
       for(int i=0; i<c->type; i++) {
-        sizeto(fsh.gpside[k][i], id);
-        bshape(fsh.gpside[k][i][id], PPR::LAKEWALL); 
+        sizeto(fsh.gpside[p][i], id);
+        bshape(fsh.gpside[p][i][id], PPR::FLOOR_SIDE);
         hyperpoint h0 = bt::get_corner_horo_coordinates(c, i) * size;
         hyperpoint h1 = bt::get_corner_horo_coordinates(c, i+1) * size;
         hyperpoint hd = (h1 - h0) / STEP;
         for(int j=0; j<=STEP; j++)
           hpcpush(iddspin_side(c, i) * bt::get_horopoint(h0 + hd * j));
-        chasmifyPoly(dlow_table[k], dhi_table[k], k);
+        chasmifyPoly(dlow_table[p], dhi_table[p], p);
         }
       }
 
@@ -346,21 +346,21 @@ void geometry_information::bshape_regular(floorshape &fsh, int id, int sides, ld
   for(int t=0; t<=sides; t++)
     hpcpush(xspinpush0(t * TAU / sides + shift * S_step, size * SHADMUL));
 
-  for(int k=0; k<SIDEPARS; k++) {
-    fsh.side[k].resize(2);
-    bshape(fsh.side[k][id], PPR::LAKEWALL);
+  for(auto p: allsides) {
+    fsh.side[p].resize(2);
+    bshape(fsh.side[p][id], PPR::FLOOR_SIDE);
     hpcpush(xspinpush0(+M_PI/sides, size));
     hpcpush(xspinpush0(-M_PI/sides, size));
-    chasmifyPoly(dlow_table[k], dhi_table[k], k);
+    chasmifyPoly(dlow_table[p], dhi_table[p], p);
 
     if(cgi.emb->is_euc_in_noniso()) {
-      fsh.gpside[k].resize(c->type);
+      fsh.gpside[p].resize(c->type);
       for(int i=0; i<c->type; i++) {
-        sizeto(fsh.gpside[k][i], id);
-        bshape(fsh.gpside[k][i][id], PPR::LAKEWALL);
+        sizeto(fsh.gpside[p][i], id);
+        bshape(fsh.gpside[p][i][id], PPR::FLOOR_SIDE);
         hpcpush(xspinpush0(M_PI - i * TAU / sides + shift * S_step, size));
         hpcpush(xspinpush0(M_PI - (i + 1) * TAU / sides + shift * S_step, size));
-        chasmifyPoly(dlow_table[k], dhi_table[k], k);
+        chasmifyPoly(dlow_table[p], dhi_table[p], p);
         }
       }
     }
@@ -416,7 +416,7 @@ void geometry_information::generate_floorshapes_for(int id, cell *c, int siid, i
 
       ld hexside = fsh.rad0, heptside = fsh.rad1;
       
-      for(int k=0; k<SIDEPARS; k++) sizeto(fsh.side[k], id);
+      for(auto p: allsides) sizeto(fsh.side[p], id);
       
       ld td = (PURE && !(S7&1)) ? S42+S6 : 0;
       if(&fsh == &shBigHepta) td += S6;
@@ -594,15 +594,15 @@ void geometry_information::generate_floorshapes_for(int id, cell *c, int siid, i
     for(int i=0; i<=cor; i++)
       hpcpush(mid_at(hpxy(0,0), cornerlist[i%cor], SHADMUL));
     
-    for(int k=0; k<SIDEPARS; k++) {
-      if(isize(fsh.gpside[k]) < cor)
-        fsh.gpside[k].resize(cor);
+    for(auto p: allsides) {
+      if(isize(fsh.gpside[p]) < cor)
+        fsh.gpside[p].resize(cor);
       for(int cid=0; cid<cor; cid++) {
-        sizeto(fsh.gpside[k][cid], id);
-        bshape(fsh.gpside[k][cid][id], fsh.prio);
+        sizeto(fsh.gpside[p][cid], id);
+        bshape(fsh.gpside[p][cid][id], fsh.prio);
         hpcpush(iddspin_side(c, cid) * cornerlist[cid]);
         hpcpush(iddspin_side(c, cid) * cornerlist[(cid+1)%cor]);
-        chasmifyPoly(dlow_table[k], dhi_table[k], k);
+        chasmifyPoly(dlow_table[p], dhi_table[p], p);
         }
       }
     }
@@ -702,9 +702,9 @@ void geometry_information::generate_floorshapes_for(int id, cell *c, int siid, i
       for(int i=fsh.shadow[id].s; i<fsh.shadow[id].e; i++)
         hpc[i] = orthogonal_move(hpc[i], FLOOR - human_height / 100);
 
-      for(int k=0; k<SIDEPARS; k++) {
-        sizeto(fsh.levels[k], id);
-        bshape(fsh.levels[k][id], fsh.prio);    
+      for(auto p: allsides) {
+        sizeto(fsh.levels[p], id);
+        bshape(fsh.levels[p][id], fsh.prio);
         last->flags |= POLY_TRIANGLES;
         last->tinf = get_floor_texture_vertices(fsh.id);
         last->texture_offset = 0;
@@ -716,12 +716,12 @@ void geometry_information::generate_floorshapes_for(int id, cell *c, int siid, i
           if(vid.pseudohedral == phInscribed) {
             hyperpoint ctr = Hypc;
             for(int t=0; t<e-s; t++)
-              ctr += kleinize(cgi.emb->orthogonal_move(hpc[s+t], dfloor_table[k]));
+              ctr += kleinize(cgi.emb->orthogonal_move(hpc[s+t], dhi_table[p]));
             ctr = normalize(ctr);
 
             for(int t=0; t<e-s; t++) {
-              hyperpoint v1 = kleinize(cgi.emb->orthogonal_move(hpc[s+t], dfloor_table[k])) - ctr;
-              hyperpoint v2 = kleinize(cgi.emb->orthogonal_move(hpc[s+t+1], dfloor_table[k])) - ctr;
+              hyperpoint v1 = kleinize(cgi.emb->orthogonal_move(hpc[s+t], dhi_table[p])) - ctr;
+              hyperpoint v2 = kleinize(cgi.emb->orthogonal_move(hpc[s+t+1], dhi_table[p])) - ctr;
               texture_order([&] (ld x, ld y) {
                 hpcpush(normalize(ctr + v1 * x + v2 * y));
                 });
@@ -730,7 +730,7 @@ void geometry_information::generate_floorshapes_for(int id, cell *c, int siid, i
           if(vid.pseudohedral == phCircumscribed) {
 
             vector<hyperpoint> hs(c->type);
-            hyperpoint z = Hypc; z[2] = dfloor_table[k];
+            hyperpoint z = Hypc; z[2] = dhi_table[p];
             hyperpoint ctr = cgi.emb->logical_to_actual(z);
             for(int t=0; t<c->type; t++) hs[t] = get_circumscribed_corner(c, t, ctr);
             // for(int t=0; t<c->type; t++) hs[t] = xspinpush0(t * TAU / c->type, 0.2); //  kleinize(get_circumscribed_corner(c, t, ctr));
@@ -754,7 +754,7 @@ void geometry_information::generate_floorshapes_for(int id, cell *c, int siid, i
 
             texture_order([&] (ld x, ld y) { 
               hyperpoint a = v1 * x + v2 * y;
-              a[2] = dfloor_table[k];
+              a[2] = dhi_table[p];
               auto c = cgi.emb->logical_to_actual(a);
               cgi.hpcpush(c);
               });
@@ -762,7 +762,7 @@ void geometry_information::generate_floorshapes_for(int id, cell *c, int siid, i
           }
 
         finishshape();
-        ensure_vertex_number(fsh.levels[k][id]);
+        ensure_vertex_number(fsh.levels[p][id]);
         }
       
       for(int co=0; co<2; co++) {
@@ -790,12 +790,12 @@ void geometry_information::generate_floorshapes_for(int id, cell *c, int siid, i
         ensure_vertex_number(fsh.cone[co][id]);
         }
 
-      for(int l=0; l<SIDEPARS; l++) {
-        for(auto& li: fsh.side[l]) 
+      for(auto p: allsides) {
+        for(auto& li: fsh.side[p]) 
           bind_floor_texture(li, fsh.id);
-        if(isize(fsh.gpside[l]) < c->type)
-          fsh.gpside[l].resize(c->type);
-        for(auto& gs: fsh.gpside[l]) {
+        if(isize(fsh.gpside[p]) < c->type)
+          fsh.gpside[p].resize(c->type);
+        for(auto& gs: fsh.gpside[p]) {
           for(auto& li: gs) 
             bind_floor_texture(li, fsh.id);
           }
@@ -805,17 +805,17 @@ void geometry_information::generate_floorshapes_for(int id, cell *c, int siid, i
     for(auto pfsh: all_escher_floorshapes) {
       auto& fsh = *pfsh;
       
-      for(int l=0; l<SIDEPARS; l++) {
-        fsh.levels[l] = shFullFloor.levels[l];
+      for(auto p: allsides) {
+        fsh.levels[p] = shFullFloor.levels[p];
         fsh.shadow = shFullFloor.shadow;
-        for(auto& li: fsh.levels[l]) bind_floor_texture(li, fsh.id);
-        fsh.side[l] = shFullFloor.side[l];
-        for(auto& li: fsh.side[l]) bind_floor_texture(li, fsh.id);
-        if(isize(fsh.gpside[l]) < c->type)
-          fsh.gpside[l].resize(c->type);
+        for(auto& li: fsh.levels[p]) bind_floor_texture(li, fsh.id);
+        fsh.side[p] = shFullFloor.side[p];
+        for(auto& li: fsh.side[p]) bind_floor_texture(li, fsh.id);
+        if(isize(fsh.gpside[p]) < c->type)
+          fsh.gpside[p].resize(c->type);
         for(int e=0; e<c->type; e++) {
-          fsh.gpside[l][e] = shFullFloor.gpside[l][e];
-          for(auto& li: fsh.gpside[l][e]) 
+          fsh.gpside[p][e] = shFullFloor.gpside[p][e];
+          for(auto& li: fsh.gpside[p][e])
             bind_floor_texture(li, fsh.id);
           }
         fsh.cone[0] = shFullFloor.cone[0];
@@ -1390,7 +1390,7 @@ void draw_shape_for_texture(floorshape* sh) {
     curvepoint(eupush(gx-s1, gy-s1) * C0);
     curvepoint(eupush(gx+s1, gy-s1) * C0);
 
-    queuecurve(shiftless(Id), 0x000000FF, brightalpha(255 - sh->pstrength * tp.escher_strength, 255), PPR::LAKELEV);
+    queuecurve(shiftless(Id), 0x000000FF, brightalpha(255 - sh->pstrength * tp.escher_strength, 255), PPR::WATERLEVEL_TOP);
     }
 
   vid.linewidth = tp.escher_width;
diff --git a/geometry.cpp b/geometry.cpp
index b015f641..204ccc4b 100644
--- a/geometry.cpp
+++ b/geometry.cpp
@@ -38,18 +38,32 @@ struct hpcshape {
   hpcshape() { clear(); }
   };
 
-#define SIDE_SLEV 0
-#define SIDE_WTS3 3
-#define SIDE_WALL 4
-#define SIDE_LAKE 5
-#define SIDE_LTOB 6
-#define SIDE_BTOI 7
-#define SIDE_SKY  8
-#define SIDE_HIGH 9
-#define SIDE_HIGH2 10
-#define SIDE_ASHA 11
-#define SIDE_BSHA 12
-#define SIDEPARS  13
+enum class SIDE {
+  INFDEEP, DEEP, SHALLOW, WATERLEVEL, FLOOR, RED1, RED2, RED3, RED4, WALL, HIGH, HIGH2, SKY, GUARD
+  };
+
+constexpr SIDE allsides[] = {
+  SIDE::INFDEEP, SIDE::DEEP, SIDE::SHALLOW, SIDE::WATERLEVEL, SIDE::FLOOR, SIDE::RED1, SIDE::RED2, SIDE::RED3, SIDE::RED4, SIDE::WALL, SIDE::HIGH, SIDE::HIGH2, SIDE::SKY
+  };
+
+constexpr int SIDEPARS = int(SIDE::GUARD);
+
+template<class T> struct sidearray : array<T, SIDEPARS> {
+  T& operator [] (SIDE s) { return array<T, SIDEPARS>::operator[] ((int) s); };
+  const T& operator [] (SIDE s) const { return array<T, SIDEPARS>::operator[] ((int) s); };
+  };
+
+constexpr sidearray<PPR> side_to_prio = {
+  PPR::DEEP_SIDE, PPR::DEEP_SIDE, PPR::SHALLOW_SIDE, PPR::WATERLEVEL_SIDE, PPR::FLOOR_SIDE, PPR::RED1_SIDE, PPR::RED2_SIDE, PPR::RED3_SIDE,
+  PPR::WALL_SIDE, PPR::WALL_SIDE,
+  PPR::DEFAULT, PPR::DEFAULT, PPR::DEFAULT
+  };
+
+constexpr sidearray<PPR> side_to_prio_top = {
+  PPR::DEEP_TOP, PPR::DEEP_TOP, PPR::SHALLOW_TOP, PPR::WATERLEVEL_TOP, PPR::FLOOR, PPR::RED1_TOP, PPR::RED2_TOP, PPR::RED3_TOP,
+  PPR::WALL_TOP, PPR::WALL_TOP,
+  PPR::DEFAULT, PPR::DEFAULT, PPR::DEFAULT
+  };
 
 /** GOLDBERG_BITS controls the size of tables for Goldberg. see gp::check_limits */
 
@@ -79,8 +93,9 @@ struct floorshape {
   int pstrength; // pattern strength in 3D
   int fstrength; // frame strength in 3D
   PPR prio;
-  vector<hpcshape> b, shadow, side[SIDEPARS], levels[SIDEPARS], cone[2];
-  vector<vector<hpcshape>> gpside[SIDEPARS];
+  vector<hpcshape> b, shadow, cone[2];
+  sidearray<vector<hpcshape>> side, levels;
+  sidearray<vector<vector<hpcshape>>> gpside;
   floorshape() { prio = PPR::FLOOR; pstrength = fstrength = 10; }
   };
 
@@ -231,20 +246,22 @@ struct geometry_information {
   int use_direct;
   
   /** various parameters related to the 3D view */
-  ld INFDEEP, BOTTOM, HELLSPIKE, LAKE, WALL, FLOOR, STUFF,
-    SLEV[4], FLATEYE,
+  ld INFDEEP, HELL, DEEP, HELLSPIKE, SHALLOW, WATERLEVEL, FLOOR, RED[4], WALL, HIGH, HIGH2, LOWSKY, SKY, STAR,
+    STUFF, FLATEYE,
     LEG0, LEG1, LEG, LEG3, GROIN, GROIN1, GHOST,
     BODY, BODY1, BODY2, BODY3,
     NECK1, NECK, NECK3, HEAD, HEAD1, HEAD2, HEAD3,
-    ALEG0, ALEG, ABODY, AHEAD, BIRD, LOWSKY, SKY, HIGH, HIGH2,
-    HELL, STAR, SHALLOW;
+    ALEG0, ALEG, ABODY, AHEAD, BIRD;
+
   ld human_height, slev;
 
   ld eyelevel_familiar, eyelevel_human, eyelevel_dog;
 
 #if CAP_SHAPES
+
+sidearray<hpcshape> shSemiFloorSide;
+
 hpcshape 
-  shSemiFloorSide[SIDEPARS],
   shBFloor[2],
   shWave[8][2],  
   shCircleFloor,
@@ -397,7 +414,7 @@ hpcshape
     shDesertFloor, shPowerFloor, shRoseFloor, shSwitchFloor,
     shTurtleFloor, shRedRockFloor[3], shDragonFloor;
 
-  ld dlow_table[SIDEPARS], dhi_table[SIDEPARS], dfloor_table[SIDEPARS];
+  sidearray<ld> dlow_table, dhi_table;
 
   int prehpc;
   /** list of points in all shapes */
@@ -415,7 +432,7 @@ hpcshape
   /** last ideal point of the current shape */
   hyperpoint last_ideal;
 
-  bool validsidepar[SIDEPARS];
+  sidearray<bool> validsidepar;
 
   vector<glvertex> ourshape;
 #endif
@@ -456,7 +473,7 @@ hpcshape
   void hpcpush(hyperpoint h);
   void hpc_connect_ideal(hyperpoint a, hyperpoint b);
   void hpcsquare(hyperpoint h1, hyperpoint h2, hyperpoint h3, hyperpoint h4);
-  void chasmifyPoly(double fac, double fac2, int k);
+  void chasmifyPoly(double fac, double fac2, SIDE p);
   void shift(hpcshape& sh, double dx, double dy, double dz);
   void initPolyForGL();
   void extra_vertices();
@@ -1027,15 +1044,17 @@ EX namespace geom3 {
   
     if(invalid != "") {
       INFDEEP = .7;
-      BOTTOM = .8;
+      DEEP = .8;
       HELLSPIKE = .85;
-      LAKE = .9;
+      SHALLOW = .9;
+      WATERLEVEL = .95;
       FLOOR = 1;
+      RED[0] = 1;
+      RED[1] = 1.08;
+      RED[2] = 1.16;
+      RED[3] = 1.24;
       WALL = 1.25;
-      SLEV[0] = 1;
-      SLEV[1] = 1.08;
-      SLEV[2] = 1.16;
-      SLEV[3] = 1.24;
+
       FLATEYE = 1.03;
       LEG1 = 1.025;
       LEG = 1.05;
@@ -1057,7 +1076,6 @@ EX namespace geom3 {
       ABODY = 1.08;
       AHEAD = 1.12;
       BIRD = 1.20;
-      SHALLOW = .95;
       STUFF = 1;
       LOWSKY = SKY = HIGH = HIGH2 = STAR = 1;
       }
@@ -1107,11 +1125,11 @@ EX namespace geom3 {
       
       slev = vid.rock_wall_ratio * wh / 3;
       for(int s=0; s<=3; s++)
-        SLEV[s] = lev_to_factor(vid.rock_wall_ratio * wh * s/3);
-      LAKE = lev_to_factor(wh * -vid.lake_top);
+        RED[s] = lev_to_factor(vid.rock_wall_ratio * wh * s/3);
+      WATERLEVEL = lev_to_factor(wh * -vid.lake_top);
       SHALLOW = lev_to_factor(wh * -vid.lake_shallow);
       HELLSPIKE = lev_to_factor(wh * -(vid.lake_top+vid.lake_bottom)/2);
-      BOTTOM = lev_to_factor(wh * -vid.lake_bottom);
+      DEEP = lev_to_factor(wh * -vid.lake_bottom);
       LOWSKY = lev_to_factor(vid.lowsky_height * wh);
       HIGH = lev_to_factor(vid.wall_height2 * wh);
       HIGH2 = lev_to_factor(vid.wall_height3 * wh);
@@ -1138,9 +1156,9 @@ EX namespace geom3 {
         adjust(HIGH2, HIGH, 0.5);
         adjust(SKY, FLOOR, 1);
         adjust(STAR, FLOOR, 0.9);
-        adjust(LAKE, FLOOR, 0.8);
-        adjust(SHALLOW, LAKE, 0.9);
-        adjust(BOTTOM, SHALLOW, 0.5);
+        adjust(WATERLEVEL, FLOOR, 0.8);
+        adjust(SHALLOW, WATERLEVEL, 0.9);
+        adjust(DEEP, SHALLOW, 0.5);
         adjust(INFDEEP, FLOOR, 1);
         }
       }
diff --git a/graph.cpp b/graph.cpp
index ede3c600..2b0a3860 100644
--- a/graph.cpp
+++ b/graph.cpp
@@ -1046,13 +1046,13 @@ EX bool drawItemType(eItem it, cell *c, const shiftmatrix& V, color_t icol, int
       shiftmatrix V2 = V * spin(pticks * vid.ispeed / 1500.);
       /* divisors should be higher than in plate renderer */
       qfi.fshape = &cgi.shMFloor2;
-      draw_shapevec(c, V2 * lzpush(-h/30), qfi.fshape->levels[0], 0xFFD500FF, PPR::WALL);
+      draw_shapevec(c, V2 * lzpush(-h/30), qfi.fshape->levels[SIDE::FLOOR], 0xFFD500FF, PPR::WALL);
 
       qfi.fshape = &cgi.shMFloor3;
-      draw_shapevec(c, V2 * lzpush(-h/25), qfi.fshape->levels[0], darkena(icol, 0, 0xFF), PPR::WALL);
+      draw_shapevec(c, V2 * lzpush(-h/25), qfi.fshape->levels[SIDE::FLOOR], darkena(icol, 0, 0xFF), PPR::WALL);
 
       qfi.fshape = &cgi.shMFloor4;
-      draw_shapevec(c, V2 * lzpush(-h/20), qfi.fshape->levels[0], 0xFFD500FF, PPR::WALL);
+      draw_shapevec(c, V2 * lzpush(-h/20), qfi.fshape->levels[SIDE::FLOOR], 0xFFD500FF, PPR::WALL);
       }
     else if(WDIM == 3 && c) {
       ld h = cgi.human_height;
@@ -3881,38 +3881,47 @@ EX bool use_warp_graphics() {
   return true;
   }
 
-EX void escherSidewall(cell *c, int sidepar, const shiftmatrix& V, color_t col) {
-  if(sidepar >= SIDE_SLEV && sidepar <= SIDE_SLEV+2) {
-    int sl = sidepar - SIDE_SLEV;
+EX void escherSidewall(cell *c, SIDE sidepar, const shiftmatrix& V, color_t col) {
+  if(sidepar >= SIDE::RED1 && sidepar <= SIDE::RED3) {
+    int sl = int(sidepar) - int(SIDE::RED1);
     for(int z=1; z<=4; z++) if(z == 1 || (z == 4 && detaillevel == 2))
-      draw_qfi(c, orthogonal_move_fol(V, zgrad0(cgi.slev * sl, cgi.slev * (sl+1), z, 4)), col, PPR::REDWALL-4+z+4*sl);
+      draw_qfi(c, orthogonal_move_fol(V, zgrad0(cgi.slev * sl, cgi.slev * (sl+1), z, 4)), col, PPR::RED1_ESCHER+3*sl);
     }
-  else if(sidepar == SIDE_WALL) {
+  else if(sidepar == SIDE::WALL) {
     const int layers = 2 << detaillevel;
     for(int z=1; z<layers; z++) 
-      draw_qfi(c, orthogonal_move_fol(V, zgrad0(0, geom3::actual_wall_height(), z, layers)), col, PPR::WALL3+z-layers);
+      draw_qfi(c, orthogonal_move_fol(V, zgrad0(0, geom3::actual_wall_height(), z, layers)), col, PPR::WALL_ESCHER);
     }
-  else if(sidepar == SIDE_LAKE) {
+  else if(sidepar == SIDE::FLOOR) {
     const int layers = 1 << (detaillevel-1);
-    if(detaillevel) for(int z=0; z<layers; z++) 
-      draw_qfi(c, orthogonal_move_fol(V, zgrad0(-vid.lake_top, 0, z, layers)), col, PPR::FLOOR+z-layers);
+    if(detaillevel) for(int z=0; z<layers; z++)
+      draw_qfi(c, orthogonal_move_fol(V, zgrad0(-vid.lake_top, 0, z, layers)), col, PPR::FLOOR_ESCHER);
     }
-  else if(sidepar == SIDE_LTOB) {
+  else if(sidepar == SIDE::WATERLEVEL) {
     const int layers = 1 << (detaillevel-1);
-    if(detaillevel) for(int z=0; z<layers; z++) 
-      draw_qfi(c, orthogonal_move_fol(V, zgrad0(-vid.lake_bottom, -vid.lake_top, z, layers)), col, PPR::INLAKEWALL+z-layers);
+    if(detaillevel) for(int z=0; z<layers; z++)
+      draw_qfi(c, orthogonal_move_fol(V, zgrad0(-vid.lake_shallow, -vid.lake_top, z, layers)), col, PPR::WATERLEVEL_ESCHER);
     }
-  else if(sidepar == SIDE_BTOI) {
+  else if(sidepar == SIDE::SHALLOW) {
+    const int layers = 1 << (detaillevel-1);
+    if(detaillevel) for(int z=0; z<layers; z++)
+      draw_qfi(c, orthogonal_move_fol(V, zgrad0(-vid.lake_bottom, -vid.lake_shallow, z, layers)), col, PPR::SHALLOW_ESCHER);
+    }
+  else if(sidepar == SIDE::DEEP) {
     const int layers = 1 << detaillevel;
     draw_qfi(c, orthogonal_move_fol(V, cgi.INFDEEP), col, PPR::MINUSINF);
-    for(int z=1; z<layers; z++) 
-      draw_qfi(c, orthogonal_move_fol(V, zgrad0(-vid.lake_bottom, -vid.lake_top, -z, 1)), col, PPR::LAKEBOTTOM+z-layers);
+    for(int z=layers-1; z>1; z--)
+      draw_qfi(c, orthogonal_move_fol(V, zgrad0(-vid.lake_bottom, -vid.lake_top, -z, 1)), col, PPR::DEEP_ESCHER);
     }
   }
 
-EX bool placeSidewall(cell *c, int i, int sidepar, const shiftmatrix& V, color_t col) {
+EX bool use_escher(SIDE sidepar) {
+  return (!qfi.fshape || !qfi.fshape->is_plain || !cgi.validsidepar[sidepar] || qfi.usershape >= 0) && (GDIM == 2);
+  }
 
-  if(!qfi.fshape || !qfi.fshape->is_plain || !cgi.validsidepar[sidepar] || qfi.usershape >= 0) if(GDIM == 2) {
+EX bool placeSidewall(cell *c, int i, SIDE sidepar, const shiftmatrix& V, color_t col) {
+
+  if(use_escher(sidepar)) {
     escherSidewall(c, sidepar, V, col);
     return true;
     }
@@ -3921,16 +3930,7 @@ EX bool placeSidewall(cell *c, int i, int sidepar, const shiftmatrix& V, color_t
   if(qfi.fshape == &cgi.shBigTriangle && pseudohept(c->move(i))) return false;
   if(qfi.fshape == &cgi.shTriheptaFloor && !pseudohept(c) && !pseudohept(c->move(i))) return false;
 
-  PPR prio;
-  /* if(mirr) prio = PPR::GLASS - 2;
-  else */ if(sidepar == SIDE_WALL) prio = PPR::WALL3 - 2;
-  else if(sidepar == SIDE_WTS3) prio = PPR::WALL3 - 2;
-  else if(sidepar == SIDE_LAKE) prio = PPR::LAKEWALL;
-  else if(sidepar == SIDE_LTOB) prio = PPR::INLAKEWALL;
-  else if(sidepar == SIDE_BTOI) prio = PPR::BELOWBOTTOM;
-  else if(sidepar == SIDE_ASHA) prio = PPR::ASHALLOW;
-  else if(sidepar == SIDE_BSHA) prio = PPR::BSHALLOW;
-  else prio = PPR::REDWALL-2+4*(sidepar-SIDE_SLEV);
+  PPR prio = side_to_prio[sidepar];
 
   if((col & 255) < 255) prio = PPR::TRANSPARENT_WALL;
   
@@ -3950,12 +3950,12 @@ EX bool placeSidewall(cell *c, int i, int sidepar, const shiftmatrix& V, color_t
     if(currentmap->strict_tree_rules()) {
       i = rulegen::get_arb_dir(c, i);
       }
-    if(sidepar >= SIDEPARS) {
-      println(hlog, "ERROR: sidepar >= SIDEPARS", make_pair(sidepar, SIDEPARS));
+    if(int(sidepar) >= SIDEPARS) {
+      println(hlog, "ERROR: sidepar >= SIDEPARS: ", make_pair(int(sidepar), SIDEPARS));
       return false;
       }
     if(i >= isize(qfi.fshape->gpside[sidepar])) {
-      println(hlog, "ERROR: i >= gpside[sidepar]", make_tuple(sidepar, i, isize(qfi.fshape->gpside[sidepar])));
+      println(hlog, "ERROR: i >= gpside[sidepar]", make_tuple(int(sidepar), i, isize(qfi.fshape->gpside[sidepar])));
       return false;
       }
     draw_shapevec(c, V2, qfi.fshape->gpside[sidepar][i], col, prio);
@@ -3990,7 +3990,7 @@ EX int gridcolor(cell *c1, cell *c2) {
     if(r == 3) return Dark(0xC02020);
     if(r == 2) return Dark(0xF02020);
     }
-  if(chasmgraph(c1) != chasmgraph(c2) && c1->land != laAsteroids && c2->land != laAsteroids)
+  if((get_spatial_info(c1).deep<SIDE::SHALLOW) != (get_spatial_info(c2).deep<SIDE::SHALLOW) && c1->land != laAsteroids && c2->land != laAsteroids)
     return Dark(0x808080);
   if(c1->land == laAlchemist && c2->land == laAlchemist && c1->wall != c2->wall && !c1->item && !c2->item)
     return Dark(0xC020C0);
@@ -4050,35 +4050,18 @@ EX void pushdown(cell *c, int& q, const shiftmatrix &V, double down, bool rezoom
       
     if(!repriority) ;
     else if(nlev < -vid.lake_bottom-1e-3) {
-      ptd.prio = PPR::BELOWBOTTOM_FALLANIM;
+      ptd.prio = PPR::DEEP_FALLANIM;
       if(c->wall != waChasm)
         ptd.color = 0; // disappear!
       }
     else if(nlev < -vid.lake_top-1e-3)
-      ptd.prio = PPR::INLAKEWALL_FALLANIM;
+      ptd.prio = PPR::SHALLOW_FALLANIM;
     else if(nlev < 0)
-      ptd.prio = PPR::LAKEWALL_FALLANIM;
+      ptd.prio = PPR::FLOOR_FALLANIM;
     }
   }
 #endif
 
-// 1 : (floor, water); 2 : (water, bottom); 4 : (bottom, inf)
-
-EX int shallow(cell *c) {
-  if(cellUnstable(c)) return 0;
-  else if(
-    c->wall == waReptile) return 1;
-  else if(c->wall == waReptileBridge ||
-    c->wall == waGargoyleFloor ||
-    c->wall == waGargoyleBridge ||
-    c->wall == waTempFloor ||
-    c->wall == waTempBridge ||
-    c->wall == waPetrifiedBridge ||
-    c->wall == waFrozenLake)
-    return 5;
-  return 7;
-  }
-
 bool allemptynear(cell *c) {
   if(c->wall) return false;
   forCellEx(c2, c) if(c2->wall) return false;
@@ -4202,10 +4185,10 @@ EX color_t transcolor(cell *c, cell *c2, color_t wcol) {
   if(among(c->wall, waCanopy, waSolidBranch, waWeakBranch) && !among(c2->wall, waCanopy, waSolidBranch, waWeakBranch)) return 0x00C00060;
   if(c->wall == waFloorA && c2->wall == waFloorB && !c->item && !c2->item) return darkena3(0xFF00FF, 0, 0x80);
   if(realred(c->wall) || realred(c2->wall)) {
-    int l = snakelevel(c) - snakelevel(c2);
+    int l = int(get_spatial_info(c).top) - int(get_spatial_info(c2).top);
     if(l > 0) return darkena3(floorcolors[laRedRock], 0, 0x30 * l);
     }
-  if(among(c->wall, waRubble, waDeadfloor2) && !snakelevel(c2)) return darkena3(winf[c->wall].color, 0, 0x40);
+  if(among(c->wall, waRubble, waDeadfloor2) && !among(get_spatial_info(c2).top, SIDE::RED1, SIDE::RED2, SIDE::RED3)) return darkena3(winf[c->wall].color, 0, 0x40);
   if(c->wall == waMagma && c2->wall != waMagma) return darkena3(magma_color(lavatide(c, -1)/4), 0, 0x80);
   if(among(c->wall, waMineUnknown, waMineMine) && !among(c2->wall, waMineMine, waMineUnknown) && mine_opacity > 0 && mine_opacity < 255) 
     return 0xFFFFFF00 | mine_opacity;
@@ -4781,7 +4764,7 @@ void celldrawer::draw_fallanims() {
        if(t <= maxtime) {
          erase = false;
          if(GDIM == 3)
-           draw_shapevec(c, V, qfi.fshape->levels[0], darkena(fcol, fd, 0xFF), PPR::WALL);
+           draw_shapevec(c, V, qfi.fshape->levels[SIDE::FLOOR], darkena(fcol, fd, 0xFF), PPR::WALL);
          else if(fa.walltype == waNone) {
            draw_qfi(c, V, darkena(fcol, fd, 0xFF), PPR::FLOOR);
            }
@@ -4793,10 +4776,10 @@ void celldrawer::draw_fallanims() {
            ddalt.setcolors();
            int starcol = c->wall == waVinePlant ? 0x60C000 : ddalt.wcol;
            c->wall = w; c->wparam = p;
-           draw_qfi(c, orthogonal_move_fol(V, cgi.WALL), darkena(starcol, fd, 0xFF), PPR::WALL3);
-           queuepolyat(orthogonal_move_fol(V, cgi.WALL), cgi.shWall[ct6], darkena(ddalt.wcol, 0, 0xFF), PPR::WALL3A);
+           draw_qfi(c, orthogonal_move_fol(V, cgi.WALL), darkena(starcol, fd, 0xFF), PPR::WALL_TOP);
+           queuepolyat(orthogonal_move_fol(V, cgi.WALL), cgi.shWall[ct6], darkena(ddalt.wcol, 0, 0xFF), PPR::WALL_DECO);
            forCellIdEx(c2, i, c)
-             if(placeSidewall(c, i, SIDE_WALL, V, darkena(ddalt.wcol, 1, 0xFF))) break;
+             if(placeSidewall(c, i, SIDE::WALL, V, darkena(ddalt.wcol, 1, 0xFF))) break;
            }
          pushdown(c, q, V, t*t / 1000000. + t / 1000., true, true);
          }
@@ -4848,14 +4831,17 @@ EX void queuecircleat1(cell *c, const shiftmatrix& V, double rad, color_t col) {
   #endif
   queuecircle(V, rad, col);  
   if(!wmspatial) return;
-  if(highwall(c))
+  auto si = get_spatial_info(c);
+  if(si.top == SIDE::WALL)
     queuecircle(orthogonal_move_fol(V, cgi.WALL), rad, col);
-  int sl;
-  if((sl = snakelevel(c))) {
-    queuecircle(orthogonal_move_fol(V, cgi.SLEV[sl]), rad, col);
-    }
-  if(chasmgraph(c))
-    queuecircle(orthogonal_move_fol(V, cgi.LAKE), rad, col);
+  if(si.top == SIDE::RED1)
+    queuecircle(orthogonal_move_fol(V, cgi.RED[1]), rad, col);
+  if(si.top == SIDE::RED2)
+    queuecircle(orthogonal_move_fol(V, cgi.RED[2]), rad, col);
+  if(si.top == SIDE::RED3)
+    queuecircle(orthogonal_move_fol(V, cgi.RED[3]), rad, col);
+  if(si.top <= SIDE::WATERLEVEL)
+    queuecircle(orthogonal_move_fol(V, cgi.WATERLEVEL), rad, col);
   }
 
 EX void queuecircleat(cell *c, double rad, color_t col) {
diff --git a/hyper.h b/hyper.h
index da6915f5..89e42cc7 100644
--- a/hyper.h
+++ b/hyper.h
@@ -687,18 +687,10 @@ static constexpr int MAXPLAYER = 7;
 enum class PPR {
   ZERO, EUCLIDEAN_SKY, OUTCIRCLE, MOVESTAR,
   MINUSINF,
-  BELOWBOTTOM,
-  BELOWBOTTOM_FALLANIM,
-  LAKEBOTTOM, HELLSPIKE,
-  INLAKEWALL,
-  INLAKEWALL_FALLANIM,
-  BSHALLOW, SHALLOW, ASHALLOW,
-  SUBLAKELEV, LAKELEV, BOATLEV, BOATLEV2, BOATLEV3,
-  LAKEWALL,
-  LAKEWALL_FALLANIM,
-  FLOOR_TOWER,
-  FLOOR,
-  FLOOR_DRAGON,
+  DEEP_ESCHER, DEEP_SIDE, DEEP_FALLANIM, DEEP_TOP, HELLSPIKE,
+  SHALLOW_ESCHER, SHALLOW_SIDE, SHALLOW_FALLANIM, SHALLOW_TOP,
+  WATERLEVEL_ESCHER, WATERLEVEL_SIDE, WATERLEVEL_TOP, BOATLEV, BOATLEV2, BOATLEV3,
+  FLOOR_ESCHER, FLOOR_SIDE, FLOOR_FALLANIM, FLOOR_TOWER, FLOOR, FLOOR_DRAGON,
   FLOORa, FLOORb, FLOORc, FLOORd,
   LIZEYE,
   BFLOOR,
@@ -706,17 +698,16 @@ enum class PPR {
   WALLSHADOW,
   STRUCT0, STRUCT1, STRUCT2, STRUCT3,
   THORNS, WALL,
-  REDWALLs, REDWALL,
-  REDWALLs2, REDWALLt2,
-  REDWALLs3, REDWALLt3,
+  RED1_ESCHER, RED1_SIDE, RED1_TOP,
+  RED2_ESCHER, RED2_SIDE, RED2_TOP,
+  RED3_ESCHER, RED3_SIDE, RED3_TOP,
   HEPTAMARK,
   ITEM_BELOW,
   ITEM, ITEMa, ITEMb,
   BIGSTATUE,
 
-  WALL3s, WALL3, WALL3A,
+  WALL_ESCHER, WALL_SIDE, WALL_TOP, WALL_DECO,
 
-// WALL3m, WALL3s, WALL3p, WALL3, WALL3A,
   HIDDEN, GIANTSHADOW,
   TENTACLE0, TENTACLE1,
   ONTENTACLE, ONTENTACLE_EYES, ONTENTACLE_EYES2,
diff --git a/hypgraph.cpp b/hypgraph.cpp
index a863be8a..cb483814 100644
--- a/hypgraph.cpp
+++ b/hypgraph.cpp
@@ -2227,7 +2227,7 @@ EX void adjust_eye(transmatrix& T, cell *c, ld sign) {
   if(isWorm(c->monst) && sl < 3) sl++;
   ld i = cgi.emb->center_z();
   if(sl || vid.eye || i)
-    T = T * lzpush(sign * (cgi.SLEV[sl] - cgi.FLOOR - vid.eye + i));
+    T = T * lzpush(sign * (cgi.RED[sl] - cgi.FLOOR - vid.eye + i));
   }
 
 EX bool shmup_inverted() {
diff --git a/polygons.cpp b/polygons.cpp
index 2598bcd8..2395b18d 100644
--- a/polygons.cpp
+++ b/polygons.cpp
@@ -90,7 +90,7 @@ void geometry_information::hpcpush(hyperpoint h) {
     }
   }
 
-void geometry_information::chasmifyPoly(double fol, double fol2, int k) {
+void geometry_information::chasmifyPoly(double fol, double fol2, SIDE p) {
   if(GDIM == 2) {
      for(int i=isize(hpc)-1; i >= last->s; i--) {
        hpc.push_back(orthogonal_move_fol(hpc[i], fol));
@@ -375,39 +375,31 @@ template<class... T> ld grot(bool geometry, ld factor, T... t) {
 #endif
 
 void geometry_information::make_sidewalls() {
-  for(int i=0; i<=3; i++)
-    dfloor_table[i] = SLEV[i];
-  dfloor_table[SIDE_WALL] = WALL;
-  dfloor_table[SIDE_LAKE] = LAKE;
-  dfloor_table[SIDE_LTOB] = BOTTOM;
-  dfloor_table[SIDE_BTOI] = INFDEEP;
-  dfloor_table[SIDE_HIGH] = HIGH;
-  dfloor_table[SIDE_HIGH2] = HIGH2;
-  dfloor_table[SIDE_SKY ] = SKY;
-  dfloor_table[SIDE_ASHA] = SHALLOW;
-
   // sidewall parameters for the 3D mode
   for(int k=0; k<SIDEPARS; k++) {
     double dlow=FLOOR, dhi=FLOOR;
-    if(k==SIDE_WALL) dhi = WALL;
-    else if(k==SIDE_LAKE) dlow = LAKE;
-    else if(k==SIDE_LTOB) dlow = BOTTOM, dhi = LAKE;
-    else if(k==SIDE_BTOI) dlow = INFDEEP, dhi = BOTTOM;
-    else if(k==SIDE_WTS3) dlow = SLEV[3], dhi = WALL;
-    else if(k==SIDE_HIGH) dlow = WALL, dhi = HIGH;
-    else if(k==SIDE_HIGH2) dlow = HIGH, dhi = HIGH2;
-    else if(k==SIDE_SKY) dlow = HIGH2, dhi = SKY;
-    else if(k==SIDE_BSHA) dlow = BOTTOM, dhi = SHALLOW;
-    else if(k==SIDE_ASHA) dlow = SHALLOW, dhi = LAKE;
-    else dlow = SLEV[k-SIDE_SLEV], dhi = SLEV[k-SIDE_SLEV+1];
-    dlow_table[k] = dlow;
-    dhi_table[k] = dhi;
+    auto p = SIDE(k);
+    if(p==SIDE::INFDEEP) dlow = INFDEEP, dhi = INFDEEP;
+    else if(p==SIDE::DEEP) dlow = INFDEEP, dhi = DEEP;
+    else if(p==SIDE::SHALLOW) dlow = DEEP, dhi = SHALLOW;
+    else if(p==SIDE::WATERLEVEL) dlow = SHALLOW, dhi = WATERLEVEL;
+    else if(p==SIDE::FLOOR) dlow = WATERLEVEL, dhi = FLOOR;
+    else if(p==SIDE::RED1) dlow = RED[0], dhi = RED[1];
+    else if(p==SIDE::RED2) dlow = RED[1], dhi = RED[2];
+    else if(p==SIDE::RED3) dlow = RED[2], dhi = RED[3];
+    else if(p==SIDE::RED4) dlow = RED[3], dhi = WALL;
+    else if(p==SIDE::WALL) dlow = FLOOR, dhi = WALL;
+    else if(p==SIDE::HIGH) dlow = WALL, dhi = HIGH;
+    else if(p==SIDE::HIGH2) dlow = HIGH, dhi = HIGH2;
+    else if(p==SIDE::SKY) dlow = HIGH2, dhi = SKY;
+    dlow_table[p] = dlow;
+    dhi_table[p] = dhi;
 
-    validsidepar[k] = (dlow > 0 && dhi > 0) || (dlow < 0 && dhi < 0) || GDIM == 3;
+    validsidepar[p] = (dlow > 0 && dhi > 0) || (dlow < 0 && dhi < 0) || GDIM == 3;
 
-    bshape(shSemiFloorSide[k], PPR::LAKEWALL);
+    bshape(shSemiFloorSide[p], PPR::FLOOR_SIDE);
     for(int t=0; t<=3; t+=3) hpcpush(ddi(S7 + (3+t)*S14, floorrad0) * C0);
-    chasmifyPoly(dlow, dhi, k);
+    chasmifyPoly(dlow, dhi, p);
     }
   }
 
@@ -1241,16 +1233,16 @@ void geometry_information::prepare_shapes() {
     ld hlenx = hdist(xpush0(hcrossf), spin(TAU/S7) * xpush0(hcrossf));
 
     bshape(shHalfMirror[2], PPR::WALL);
-    hpcpush(C0); hpcpush(xpush0(-len6*scalefactor));  chasmifyPoly(FLOOR, WALL, 0);
+    hpcpush(C0); hpcpush(xpush0(-len6*scalefactor));  chasmifyPoly(FLOOR, WALL, SIDE::FLOOR);
     bshape(shHalfMirror[1], PPR::WALL);
     if(PURE) {
-      hpcpush(xpush0(-hlen7)); hpcpush(xpush0(hcrossf+hlenx/2));  chasmifyPoly(FLOOR, WALL, 0);
+      hpcpush(xpush0(-hlen7)); hpcpush(xpush0(hcrossf+hlenx/2));  chasmifyPoly(FLOOR, WALL, SIDE::FLOOR);
       }
     else {
-      hpcpush(xpush0(-len7*scalefactor)); hpcpush(xpush0((hexf+lenx/2)*scalefactor));  chasmifyPoly(FLOOR, WALL, 0);
+      hpcpush(xpush0(-len7*scalefactor)); hpcpush(xpush0((hexf+lenx/2)*scalefactor));  chasmifyPoly(FLOOR, WALL, SIDE::FLOOR);
       }
     bshape(shHalfMirror[0], PPR::WALL);
-    hpcpush(xpush0(len6)); hpcpush(xpush0(-len6));  chasmifyPoly(FLOOR, WALL, 0);
+    hpcpush(xpush0(len6)); hpcpush(xpush0(-len6));  chasmifyPoly(FLOOR, WALL, SIDE::FLOOR);
     }
 
   bshape(shAsymmetric, PPR::TEXT, scalefactor, 374);
diff --git a/rogueviz/embedded-chess.cpp b/rogueviz/embedded-chess.cpp
index 03bb2c3d..98a8a208 100644
--- a/rogueviz/embedded-chess.cpp
+++ b/rogueviz/embedded-chess.cpp
@@ -465,7 +465,7 @@ struct lilymodel : public model {
     h[0] += 0.67; h[1] -= 0.36; 
     h[0] *= 5;
     h[1] *= 5;
-    h[2] = lerp(cgi.LAKE, cgi.FLOOR, ilerp(0.018, -0.0496, h[2]) * hmul);
+    h[2] = lerp(cgi.WATERLEVEL, cgi.FLOOR, ilerp(0.018, -0.0496, h[2]) * hmul);
     if(GDIM == 3) h = cgi.emb->logical_to_actual(h);
     else h[2] = 1;
     return h;
@@ -479,7 +479,7 @@ struct duckmodel : public model {
   hyperpoint transform(hyperpoint h) override { 
     h = cspin90(1, 2) * h;
     h[0] += 3.8; h[1] -= 2;
-    h[2] = lerp(cgi.LAKE, cgi.FLOOR, ilerp(0.056, -0.408, h[2]) * hmul * 1.5);
+    h[2] = lerp(cgi.WATERLEVEL, cgi.FLOOR, ilerp(0.056, -0.408, h[2]) * hmul * 1.5);
     if(GDIM == 3) h = cgi.emb->logical_to_actual(h);
     else h[2] = 1;
     return h;
@@ -1030,16 +1030,16 @@ bool chess_ceiling(celldrawer *cw) {
     color_t wcol1 = (gradient(0, domcol, 0, .9, 1) << 8) | 0xFF;
     color_t wcol2 = (gradient(0, domcol, 0, .8, 1) << 8) | 0xFF;
     if(house1.count(cw->c)) forCellIdEx(c2, i, cw->c) if(!house1.count(c2)) {
-      placeSidewall(cw->c, i, SIDE_HIGH, cw->V, (i&1)?wcol1:wcol2); 
-      placeSidewall(cw->c, i, SIDE_HIGH2, cw->V, (i&1)?wcol1:wcol2); 
+      placeSidewall(cw->c, i, SIDE::HIGH, cw->V, (i&1)?wcol1:wcol2);
+      placeSidewall(cw->c, i, SIDE::HIGH2, cw->V, (i&1)?wcol1:wcol2);
       }
     forCellIdEx(c2, i, cw->c) if(!house2.count(c2)) {
-      placeSidewall(cw->c, i, SIDE_HIGH2, cw->V, (i&1)?wcol1:wcol2); 
+      placeSidewall(cw->c, i, SIDE::HIGH2, cw->V, (i&1)?wcol1:wcol2);
       }
     if(house1.count(cw->c) != house2.count(cw->c))
-      draw_shapevec(cw->c, cw->V, qfi.fshape->levels[SIDE_HIGH], col, PPR::REDWALL);
+      draw_shapevec(cw->c, cw->V, qfi.fshape->levels[SIDE::HIGH], col, PPR::RED1_TOP);
     if(house2.count(cw->c))
-      draw_shapevec(cw->c, cw->V, qfi.fshape->levels[SIDE_HIGH2], (domroof << 8) | 0xFF, PPR::REDWALL);
+      draw_shapevec(cw->c, cw->V, qfi.fshape->levels[SIDE::HIGH2], (domroof << 8) | 0xFF, PPR::RED1_TOP);
 
     auto co = euc::full_coords2(cw->c);
     int x = gmod(co.first, 20);
@@ -1047,7 +1047,7 @@ bool chess_ceiling(celldrawer *cw) {
     char ch = xmap[y][x];
 
     if(ch == 'O') {
-      placeSidewall(cw->c, 1, SIDE_HIGH, cw->V, 0xC0E0FFC0);
+      placeSidewall(cw->c, 1, SIDE::HIGH, cw->V, 0xC0E0FFC0);
       ((dqi_poly&)(*ptds.back())).tinf = nullptr;
       }
     }
diff --git a/rogueviz/fifteen.cpp b/rogueviz/fifteen.cpp
index 004d3962..1796a634 100644
--- a/rogueviz/fifteen.cpp
+++ b/rogueviz/fifteen.cpp
@@ -190,9 +190,9 @@ bool draw_fifteen(cell *c, const shiftmatrix& V) {
       ensure_floorshape_generated(shvid(c), c);
       for(int i=0; i<c->type; i++)
         if(!fif.count(c->move(i)) || (showing ? fif[c->move(i)].target : fif[c->move(i)].current) == Empty)
-          placeSidewall(c, i, SIDE_SLEV, V, 0xFFFFFFFF);
-      auto V1 = orthogonal_move_fol(V, cgi.SLEV[1]);
-      draw_qfi(c, V1, 0xFFFFFFFF, PPR::WALL3A);
+          placeSidewall(c, i, SIDE::RED1, V, 0xFFFFFFFF);
+      auto V1 = orthogonal_move_fol(V, cgi.RED[1]);
+      draw_qfi(c, V1, 0xFFFFFFFF, PPR::WALL_DECO);
       write_in_space(V1 * ddspin(c,cdir,0) * (cmir ? MirrorX: Id), 72, 1, dotted(cur), 0xFF, 0, 8);
       return true;
       }
diff --git a/rogueviz/seuphorica.cpp b/rogueviz/seuphorica.cpp
index eba46ac3..7f3d231d 100644
--- a/rogueviz/seuphorica.cpp
+++ b/rogueviz/seuphorica.cpp
@@ -417,20 +417,20 @@ void render_tile(shiftmatrix V, tile& t, cell *c, vector<tile>* origbox, int box
     set_floor(cgi.shFullFloor);
     ensure_floorshape_generated(shvid(c), c);
     for(int i=0; i<c->type; i++)
-      if(!board.count(c->move(i))) placeSidewall(c, i, SIDE_SLEV, V, back);
-    V1 = orthogonal_move_fol(V, cgi.SLEV[1]);
-    if(!gig || !euclid_only()) draw_qfi(c, V1, back, PPR::WALL3A);
+      if(!board.count(c->move(i))) placeSidewall(c, i, SIDE::RED1, V, back);
+    V1 = orthogonal_move_fol(V, cgi.RED[1]);
+    if(!gig || !euclid_only()) draw_qfi(c, V1, back, PPR::WALL_DECO);
     }
   else if(get_gigantic(c) == c) {
     wider w(wide);
     for(int i=0; i<=corners; i++) curvepoint(pt(i, 3));
-    queuecurve(V, lines, backd, PPR::WALL3A);
+    queuecurve(V, lines, backd, PPR::WALL_DECO);
     }
 
   if(c && gig) {
     if(gigants.at(c) != c) return;
     if(euclid_only())
-      draw_qfi(c, V1 * euscalexx(3), back, PPR::WALL3A);
+      draw_qfi(c, V1 * euscalexx(3), back, PPR::WALL_DECO);
     }
 
   const ld nearco = 4;
@@ -441,7 +441,7 @@ void render_tile(shiftmatrix V, tile& t, cell *c, vector<tile>* origbox, int box
     a = floor(a) + 1;
     while(a < b) curvepoint(pt(a++, 3));
     curvepoint(pt(b, 3));
-    queuecurve(V1, 0, darkena(col, 0, 0xFF), PPR::WALL3A);
+    queuecurve(V1, 0, darkena(col, 0, 0xFF), PPR::WALL_DECO);
     };
 
   if(has_power(t, sp::polski)) {
@@ -466,14 +466,14 @@ void render_tile(shiftmatrix V, tile& t, cell *c, vector<tile>* origbox, int box
 
   if(has_power(t, sp::english)) {
     vid.linewidth *= 3;
-    for(int i=0; i<corners; i++) queueline(V1 * pt(i/2., 3), V1 * pt((i+corners)/2., 3), darkena(0xFFFFFF, 0, 0xFF), 2, PPR::WALL3A);
+    for(int i=0; i<corners; i++) queueline(V1 * pt(i/2., 3), V1 * pt((i+corners)/2., 3), darkena(0xFFFFFF, 0, 0xFF), 2, PPR::WALL_DECO);
     vid.linewidth /= 3;
     // for simplicity, and less confusion with the letter, we do not add the red cross on top
     }
 
   if(has_power(t, sp::portugues_br)) {
     for(int i=0; i<=corners; i++) curvepoint(pt(i+.5, 3));
-    queuecurve(V1, 0, darkena(0xFEDD00, 0, 0xFF), PPR::WALL3A);
+    queuecurve(V1, 0, darkena(0xFEDD00, 0, 0xFF), PPR::WALL_DECO);
     }
 
   if(has_power(t, sp::bending)) {
@@ -592,8 +592,8 @@ bool draw(cell *c, const shiftmatrix& V) {
       queueline(V * pt0(cw, j), V1 * pt0(cw1, j), 0x0000FF80, 5);
 
       if(tiles3) {
-        auto high_V = orthogonal_move_fol(V, cgi.SLEV[1]);
-        auto high_V1 = orthogonal_move_fol(V1, cgi.SLEV[1]);
+        auto high_V = orthogonal_move_fol(V, cgi.RED[1]);
+        auto high_V1 = orthogonal_move_fol(V1, cgi.RED[1]);
         queueline(high_V * pt0(cw, 1), high_V1 * pt0(cw1, 1), 0xFF800080, 5);
         queueline(high_V * pt0(cw, j), high_V1 * pt0(cw1, j), 0x0000FF80, 5);
         }
diff --git a/sky.cpp b/sky.cpp
index 58846d7d..7ab1a860 100644
--- a/sky.cpp
+++ b/sky.cpp
@@ -406,7 +406,7 @@ void celldrawer::draw_ceiling() {
         if(star_for(fieldpattern::fieldval_uniq(c) ^ 0x5555))
           draw_star(V, cgi.shNightStar, 0xFFFFFFFF, true);
         int sk = get_skybrightness(-1);
-        auto sky = draw_shapevec(c, V * MirrorZ, cgi.shFullFloor.levels[SIDE_SKY], 0x000000FF + 0x100 * (sk/17), PPR::SKY);
+        auto sky = draw_shapevec(c, V * MirrorZ, cgi.shFullFloor.levels[SIDE::SKY], 0x000000FF + 0x100 * (sk/17), PPR::SKY);
         if(sky) sky->tinf = NULL, sky->flags |= POLY_INTENSE;
         }
       return;
@@ -491,13 +491,13 @@ void celldrawer::draw_ceiling() {
       add_to_sky(0, 0);
       if(camera_over(cgi.WALL)) return;
       if(c->land == laMercuryRiver) fcol = linf[laTerracotta].color, fd = 1;
-      if(qfi.fshape) draw_shapevec(c, V, qfi.fshape->levels[SIDE_WALL], darkena(fcol, fd, 0xFF), PPR::WALL);
+      if(qfi.fshape) draw_shapevec(c, V, qfi.fshape->levels[SIDE::WALL], darkena(fcol, fd, 0xFF), PPR::WALL);
       forCellIdEx(c2, i, c) 
         if(ceiling_category(c2) != 3) {
           color_t wcol2 = gradient(0, wcol, 0, .8, 1);
-          placeSidewall(c, i, SIDE_HIGH, V, darkena(wcol2, fd, 0xFF));
-          placeSidewall(c, i, SIDE_HIGH2, V, darkena(wcol2, fd, 0xFF));
-          placeSidewall(c, i, SIDE_SKY, V, darkena(wcol2, fd, 0xFF));
+          placeSidewall(c, i, SIDE::HIGH, V, darkena(wcol2, fd, 0xFF));
+          placeSidewall(c, i, SIDE::HIGH2, V, darkena(wcol2, fd, 0xFF));
+          placeSidewall(c, i, SIDE::SKY, V, darkena(wcol2, fd, 0xFF));
           }
       return;
       }
@@ -509,17 +509,17 @@ void celldrawer::draw_ceiling() {
       color_t wcol2 = 0xFFD500;
       if(ispal(c)) {
         forCellIdEx(c2, i, c) if(!ispal(c2))
-          placeSidewall(c, i, SIDE_HIGH, V, darkena(wcol2, fd, 0xFF));
+          placeSidewall(c, i, SIDE::HIGH, V, darkena(wcol2, fd, 0xFF));
         }
       else {
         bool window = false;
         forCellIdEx(c2, i, c) if(c2->wall == waPalace && ispal(c->cmodmove(i+1)) && ispal(c->cmodmove(i-1))) window = true;        
-        if(qfi.fshape && !window) draw_shapevec(c, V, qfi.fshape->levels[SIDE_HIGH], darkena(fcol, fd, 0xFF), PPR::WALL);
+        if(qfi.fshape && !window) draw_shapevec(c, V, qfi.fshape->levels[SIDE::HIGH], darkena(fcol, fd, 0xFF), PPR::WALL);
         if(window) 
           forCellIdEx(c2, i, c) 
-            placeSidewall(c, i, SIDE_HIGH2, V, darkena(wcol2, fd, 0xFF));
+            placeSidewall(c, i, SIDE::HIGH2, V, darkena(wcol2, fd, 0xFF));
         }
-      if(among(c->wall, waClosedGate, waOpenGate) && qfi.fshape) draw_shapevec(c, V, qfi.fshape->levels[SIDE_WALL], 0x202020FF, PPR::WALL);
+      if(among(c->wall, waClosedGate, waOpenGate) && qfi.fshape) draw_shapevec(c, V, qfi.fshape->levels[SIDE::WALL], 0x202020FF, PPR::WALL);
 
       draw_star(V, cgi.shNightStar, 0xFFFFFFFF);
       break;
@@ -531,14 +531,14 @@ void celldrawer::draw_ceiling() {
       color_t wcol2 = winf[waRuinWall].color;
       if(c->landparam == 1)
         forCellIdEx(c2, i, c) if(c2->landparam != 1)
-          placeSidewall(c, i, SIDE_HIGH, V, darkena(wcol2, fd, 0xFF));
+          placeSidewall(c, i, SIDE::HIGH, V, darkena(wcol2, fd, 0xFF));
       if(c->landparam != 2)
         forCellIdEx(c2, i, c) if(c2->landparam == 2)
-          placeSidewall(c, i, SIDE_HIGH2, V, darkena(wcol2, fd, 0xFF));
+          placeSidewall(c, i, SIDE::HIGH2, V, darkena(wcol2, fd, 0xFF));
       /* if(c->landparam == 0)
-        if(qfi.fshape) draw_shapevec(c, V, qfi.fshape->levels[SIDE_HIGH], darkena(wcol2, fd, 0xFF), PPR::WALL); */
+        if(qfi.fshape) draw_shapevec(c, V, qfi.fshape->levels[SIDE::HIGH], darkena(wcol2, fd, 0xFF), PPR::WALL); */
       if(c->landparam == 1)
-        if(qfi.fshape) draw_shapevec(c, V, qfi.fshape->levels[SIDE_WALL], darkena(wcol2, fd, 0xFF), PPR::WALL);
+        if(qfi.fshape) draw_shapevec(c, V, qfi.fshape->levels[SIDE::WALL], darkena(wcol2, fd, 0xFF), PPR::WALL);
       break;
       }
     
@@ -550,14 +550,14 @@ void celldrawer::draw_ceiling() {
       color_t wcol2 = winf[waColumn].color;
       if(c->landparam == 1)
         forCellIdEx(c2, i, c) if(c2->landparam != 1)
-          placeSidewall(c, i, SIDE_HIGH, V, darkena(wcol2, fd, 0xFF));
+          placeSidewall(c, i, SIDE::HIGH, V, darkena(wcol2, fd, 0xFF));
       if(c->landparam != 2)
         forCellIdEx(c2, i, c) if(c2->landparam == 2)
-          placeSidewall(c, i, SIDE_HIGH2, V, darkena(wcol2, fd, 0xFF));
+          placeSidewall(c, i, SIDE::HIGH2, V, darkena(wcol2, fd, 0xFF));
       if(c->landparam == 0)
-        if(qfi.fshape) draw_shapevec(c, V, qfi.fshape->levels[SIDE_HIGH], darkena(wcol2, fd, 0xFF), PPR::WALL);
+        if(qfi.fshape) draw_shapevec(c, V, qfi.fshape->levels[SIDE::HIGH], darkena(wcol2, fd, 0xFF), PPR::WALL);
       if(c->landparam == 1)
-        if(qfi.fshape) draw_shapevec(c, V, qfi.fshape->levels[SIDE_WALL], darkena(wcol2, fd, 0xFF), PPR::WALL);
+        if(qfi.fshape) draw_shapevec(c, V, qfi.fshape->levels[SIDE::WALL], darkena(wcol2, fd, 0xFF), PPR::WALL);
       break;
       }
     
@@ -567,10 +567,10 @@ void celldrawer::draw_ceiling() {
     
       if(pseudohept(c)) {
         forCellIdEx(c2, i, c) 
-          placeSidewall(c, i, SIDE_HIGH, V, darkena(fcol, fd, 0xFF));
+          placeSidewall(c, i, SIDE::HIGH, V, darkena(fcol, fd, 0xFF));
         }
       else if(qfi.fshape)
-        draw_shapevec(c, V, qfi.fshape->levels[SIDE_WALL], darkena(fcol, fd, 0xFF), PPR::WALL);
+        draw_shapevec(c, V, qfi.fshape->levels[SIDE::WALL], darkena(fcol, fd, 0xFF), PPR::WALL);
 
       draw_star(V, cgi.shNightStar, 0xFFFFFFFF);
       break;