converted if sequences to case instructions

graph.cpp

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

polygons.cpp

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