X-Git-Url: https://git.jsancho.org/?a=blobdiff_plain;f=Source%2FEnvironment%2FTerrain.cpp;h=4874e337bcd1fa5e532597a414afa67a48fc5283;hb=0aab437dc560d2afa982e61cc2547756ad7b0761;hp=164dce38fd6a02739d221c4e5282204584d6283a;hpb=ed3662c0852c4312a612b4fc35bd03aba8d13db7;p=lugaru.git

diff --git a/Source/Environment/Terrain.cpp b/Source/Environment/Terrain.cpp
index 164dce3..4874e33 100644
--- a/Source/Environment/Terrain.cpp
+++ b/Source/Environment/Terrain.cpp
@@ -1,6 +1,6 @@
 /*
 Copyright (C) 2003, 2010 - Wolfire Games
-Copyright (C) 2010-2016 - Lugaru contributors (see AUTHORS file)
+Copyright (C) 2010-2017 - Lugaru contributors (see AUTHORS file)
 
 This file is part of Lugaru.
 
@@ -21,7 +21,8 @@ along with Lugaru.  If not, see <http://www.gnu.org/licenses/>.
 #include "Environment/Terrain.hpp"
 
 #include "Game.hpp"
-#include "Objects/Objects.hpp"
+#include "Objects/Object.hpp"
+#include "Tutorial.hpp"
 #include "Utils/Folders.hpp"
 
 extern XYZ viewer;
@@ -34,17 +35,14 @@ extern float multiplier;
 extern FRUSTUM frustum;
 extern float texdetail;
 extern int detail;
-extern bool decals;
+extern bool decalstoggle;
 extern float blurness;
 extern float targetblurness;
-extern Objects objects;
-extern bool visibleloading;
 extern bool skyboxtexture;
-extern int tutoriallevel;
 
 //Functions
 
-int Terrain::lineTerrain(XYZ p1, XYZ p2, XYZ *p)
+int Terrain::lineTerrain(XYZ p1, XYZ p2, XYZ* p)
 {
     static int i, j, k;
     static float distance;
@@ -81,28 +79,36 @@ int Terrain::lineTerrain(XYZ p1, XYZ p2, XYZ *p)
         starty = i;
     }
 
-    if (startx < 0)
+    if (startx < 0) {
         startx = 0;
-    if (starty < 0)
+    }
+    if (starty < 0) {
         starty = 0;
-    if (endx > size - 1)
+    }
+    if (endx > size - 1) {
         endx = size - 1;
-    if (endy > size - 1)
+    }
+    if (endy > size - 1) {
         endy = size - 1;
+    }
 
     for (i = startx; i <= endx; i++) {
         for (j = starty; j <= endy; j++) {
             highest = -1000;
             lowest = 1000;
             for (k = 0; k < 2; k++) {
-                if (heightmap[i + k][j] > highest)
+                if (heightmap[i + k][j] > highest) {
                     highest = heightmap[i + k][j];
-                if (heightmap[i + k][j] < lowest)
+                }
+                if (heightmap[i + k][j] < lowest) {
                     lowest = heightmap[i + k][j];
-                if (heightmap[i + k][j + 1] > highest)
+                }
+                if (heightmap[i + k][j + 1] > highest) {
                     highest = heightmap[i + k][j + 1];
-                if (heightmap[i + k][j + 1] < lowest)
+                }
+                if (heightmap[i + k][j + 1] < lowest) {
                     lowest = heightmap[i + k][j + 1];
+                }
             }
             if ((p1.y <= highest || p2.y <= highest) && (p1.y >= lowest || p2.y >= lowest)) {
                 triangles[0].x = i;
@@ -171,8 +177,9 @@ void Terrain::UpdateTransparency(int whichx, int whichy)
                 vertex.z = j * scale;
                 vertex.y = heightmap[i][j] * scale;
                 distance = distsq(&viewer, &vertex);
-                if (distance > viewdistsquared)
+                if (distance > viewdistsquared) {
                     distance = viewdistsquared;
+                }
                 colors[i][j][3] = (viewdistsquared - (distance - (viewdistsquared * fadestart)) * (1 / (1 - fadestart))) / viewdistsquared;
             }
         }
@@ -248,8 +255,9 @@ void Terrain::UpdateTransparencyotherother(int whichx, int whichy)
                 vertex.z = j * scale;
                 vertex.y = heightmap[i][j] * scale;
                 distance = distsq(&viewer, &vertex);
-                if (distance > viewdistsquared)
+                if (distance > viewdistsquared) {
                     distance = viewdistsquared;
+                }
                 colors[i][j][3] = (viewdistsquared - (distance - (viewdistsquared * fadestart)) * (1 / (1 - fadestart))) / viewdistsquared;
             }
         }
@@ -279,7 +287,6 @@ void Terrain::UpdateVertexArray(int whichx, int whichy)
 {
     static int i, j, a, b, c, patch_size, stepsize;
 
-
     numtris[whichx][whichy] = 0;
 
     patch_size = size / subdivision;
@@ -357,19 +364,22 @@ void Terrain::UpdateVertexArray(int whichx, int whichy)
     minypatch[whichx][whichy] = 10000;
     for (a = 0; a < size / subdivision; a++) {
         for (b = 0; b < size / subdivision; b++) {
-            if (heightmap[(size / subdivision)*whichx + a][(size / subdivision)*whichy + b]*scale > maxypatch[whichx][whichy])
+            if (heightmap[(size / subdivision) * whichx + a][(size / subdivision) * whichy + b] * scale > maxypatch[whichx][whichy]) {
                 maxypatch[whichx][whichy] = heightmap[(size / subdivision) * whichx + a][(size / subdivision) * whichy + b] * scale;
-            if (heightmap[(size / subdivision)*whichx + a][(size / subdivision)*whichy + b]*scale < minypatch[whichx][whichy])
+            }
+            if (heightmap[(size / subdivision) * whichx + a][(size / subdivision) * whichy + b] * scale < minypatch[whichx][whichy]) {
                 minypatch[whichx][whichy] = heightmap[(size / subdivision) * whichx + a][(size / subdivision) * whichy + b] * scale;
+            }
         }
     }
     heightypatch[whichx][whichy] = (maxypatch[whichx][whichy] - minypatch[whichx][whichy]);
-    if (heightypatch[whichx][whichy] < size / subdivision * scale)
+    if (heightypatch[whichx][whichy] < size / subdivision * scale) {
         heightypatch[whichx][whichy] = size / subdivision * scale;
+    }
     avgypatch[whichx][whichy] = (minypatch[whichx][whichy] + maxypatch[whichx][whichy]) / 2;
 
-    for (i = whichx * size / subdivision; i < (whichx + 1)*size / subdivision - 1; i++) {
-        for (j = whichy * size / subdivision; j < (whichy + 1)*size / subdivision - 1; j++) {
+    for (i = whichx * size / subdivision; i < (whichx + 1) * size / subdivision - 1; i++) {
+        for (j = whichy * size / subdivision; j < (whichy + 1) * size / subdivision - 1; j++) {
             triangles[(i * (size - 1) * 2) + (j * 2)][0].x = i * scale;
             triangles[(i * (size - 1) * 2) + (j * 2)][0].y = heightmap[i][j] * scale;
             triangles[(i * (size - 1) * 2) + (j * 2)][0].z = j * scale;
@@ -395,10 +405,8 @@ void Terrain::UpdateVertexArray(int whichx, int whichy)
             triangles[(i * (size - 1) * 2) + (j * 2) + 1][2].z = j * scale + 1 * scale;
         }
     }
-
 }
 
-
 bool Terrain::load(const std::string& fileName)
 {
     static long i, j;
@@ -427,8 +435,7 @@ bool Terrain::load(const std::string& fileName)
         }
     }
     texture.bpp = 24;
-    if (visibleloading)
-        Game::LoadingScreen();
+    Game::LoadingScreen();
 
     texdetail = temptexdetail;
 
@@ -440,8 +447,7 @@ bool Terrain::load(const std::string& fileName)
         }
     }
 
-    if (visibleloading)
-        Game::LoadingScreen();
+    Game::LoadingScreen();
 
     float slopeness;
 
@@ -450,9 +456,7 @@ bool Terrain::load(const std::string& fileName)
             textureness[i][j] = -1;
         }
     }
-    if (visibleloading)
-        Game::LoadingScreen();
-
+    Game::LoadingScreen();
 
     for (i = 0; i < size; i++) {
         for (j = 0; j < size; j++) {
@@ -467,8 +471,9 @@ bool Terrain::load(const std::string& fileName)
                     slopeness = heightmap[i][j] - heightmap[i][j - 1];
                 }
                 opacityother[i][j] = slopeness * slopeness * 2;
-                if (opacityother[i][j] > 1)
+                if (opacityother[i][j] > 1) {
                     opacityother[i][j] = 1;
+                }
                 opacityother[i][j] -= (float)abs(Random() % 100) / 300;
             }
             if (environment == desertenvironment) {
@@ -476,8 +481,9 @@ bool Terrain::load(const std::string& fileName)
                     slopeness = heightmap[i][j] - heightmap[i][j - 1];
                 }
                 opacityother[i][j] = slopeness * slopeness * 2;
-                if (opacityother[i][j] > 1)
+                if (opacityother[i][j] > 1) {
                     opacityother[i][j] = 1;
+                }
                 opacityother[i][j] -= (float)abs(Random() % 100) / 300;
             }
             if (environment == grassyenvironment) {
@@ -494,14 +500,14 @@ bool Terrain::load(const std::string& fileName)
                     slopeness = heightmap[i][j] - heightmap[i][j + 1];
                 }
                 opacityother[i][j] = slopeness * slopeness * 10;
-                if (opacityother[i][j] > 1)
+                if (opacityother[i][j] > 1) {
                     opacityother[i][j] = 1;
+                }
                 opacityother[i][j] -= (float)abs(Random() % 100) / 100;
             }
         }
     }
-    if (visibleloading)
-        Game::LoadingScreen();
+    Game::LoadingScreen();
 
     for (i = 0; i < size; i++) {
         for (j = 0; j < size; j++) {
@@ -513,60 +519,76 @@ bool Terrain::load(const std::string& fileName)
             }
         }
     }
-    if (visibleloading)
-        Game::LoadingScreen();
+    Game::LoadingScreen();
 
     for (i = 0; i < size; i++) {
         for (j = 0; j < size; j++) {
-            if (opacityother[i][j] < .1)
+            if (opacityother[i][j] < .1) {
                 opacityother[i][j] = 0;
+            }
             if (textureness[(int)(i * subdivision / size)][(int)(j * subdivision / size)] == -1) {
-                if (!opacityother[i][j])
+                if (!opacityother[i][j]) {
                     textureness[(int)(i * subdivision / size)][(int)(j * subdivision / size)] = allfirst;
-                if (opacityother[i][j] == 1)
+                }
+                if (opacityother[i][j] == 1) {
                     textureness[(int)(i * subdivision / size)][(int)(j * subdivision / size)] = allsecond;
+                }
             }
-            if (opacityother[i][j] && textureness[(int)(i * subdivision / size)][(int)(j * subdivision / size)] == allfirst)
+            if (opacityother[i][j] && textureness[(int)(i * subdivision / size)][(int)(j * subdivision / size)] == allfirst) {
                 textureness[(int)(i * subdivision / size)][(int)(j * subdivision / size)] = mixed;
-            if (opacityother[i][j] != 1 && textureness[(int)(i * subdivision / size)][(int)(j * subdivision / size)] == allsecond)
+            }
+            if (opacityother[i][j] != 1 && textureness[(int)(i * subdivision / size)][(int)(j * subdivision / size)] == allsecond) {
                 textureness[(int)(i * subdivision / size)][(int)(j * subdivision / size)] = mixed;
+            }
 
             x = i;
             y = j;
             if (i > 0) {
                 i--;
-                if (opacityother[x][y] && textureness[(int)(i * subdivision / size)][(int)(j * subdivision / size)] == allfirst)
+                if (opacityother[x][y] && textureness[(int)(i * subdivision / size)][(int)(j * subdivision / size)] == allfirst) {
                     textureness[(int)(i * subdivision / size)][(int)(j * subdivision / size)] = mixed;
-                if (opacityother[x][y] != 1 && textureness[(int)(i * subdivision / size)][(int)(j * subdivision / size)] == allsecond)
+                }
+                if (opacityother[x][y] != 1 && textureness[(int)(i * subdivision / size)][(int)(j * subdivision / size)] == allsecond) {
                     textureness[(int)(i * subdivision / size)][(int)(j * subdivision / size)] = mixed;
-                if (opacityother[i][j] && textureness[(int)(x * subdivision / size)][(int)(y * subdivision / size)] == allfirst)
+                }
+                if (opacityother[i][j] && textureness[(int)(x * subdivision / size)][(int)(y * subdivision / size)] == allfirst) {
                     textureness[(int)(x * subdivision / size)][(int)(y * subdivision / size)] = mixed;
-                if (opacityother[i][j] != 1 && textureness[(int)(x * subdivision / size)][(int)(y * subdivision / size)] == allsecond)
+                }
+                if (opacityother[i][j] != 1 && textureness[(int)(x * subdivision / size)][(int)(y * subdivision / size)] == allsecond) {
                     textureness[(int)(x * subdivision / size)][(int)(y * subdivision / size)] = mixed;
+                }
 
                 if (j > 0) {
                     j--;
-                    if (opacityother[x][y] && textureness[(int)(i * subdivision / size)][(int)(j * subdivision / size)] == allfirst)
+                    if (opacityother[x][y] && textureness[(int)(i * subdivision / size)][(int)(j * subdivision / size)] == allfirst) {
                         textureness[(int)(i * subdivision / size)][(int)(j * subdivision / size)] = mixed;
-                    if (opacityother[x][y] != 1 && textureness[(int)(i * subdivision / size)][(int)(j * subdivision / size)] == allsecond)
+                    }
+                    if (opacityother[x][y] != 1 && textureness[(int)(i * subdivision / size)][(int)(j * subdivision / size)] == allsecond) {
                         textureness[(int)(i * subdivision / size)][(int)(j * subdivision / size)] = mixed;
-                    if (opacityother[i][j] && textureness[(int)(x * subdivision / size)][(int)(y * subdivision / size)] == allfirst)
+                    }
+                    if (opacityother[i][j] && textureness[(int)(x * subdivision / size)][(int)(y * subdivision / size)] == allfirst) {
                         textureness[(int)(x * subdivision / size)][(int)(y * subdivision / size)] = mixed;
-                    if (opacityother[i][j] != 1 && textureness[(int)(x * subdivision / size)][(int)(y * subdivision / size)] == allsecond)
+                    }
+                    if (opacityother[i][j] != 1 && textureness[(int)(x * subdivision / size)][(int)(y * subdivision / size)] == allsecond) {
                         textureness[(int)(x * subdivision / size)][(int)(y * subdivision / size)] = mixed;
+                    }
                     j++;
                 }
 
                 if (j < size - 1) {
                     j++;
-                    if (opacityother[x][y] && textureness[(int)(i * subdivision / size)][(int)(j * subdivision / size)] == allfirst)
+                    if (opacityother[x][y] && textureness[(int)(i * subdivision / size)][(int)(j * subdivision / size)] == allfirst) {
                         textureness[(int)(i * subdivision / size)][(int)(j * subdivision / size)] = mixed;
-                    if (opacityother[x][y] != 1 && textureness[(int)(i * subdivision / size)][(int)(j * subdivision / size)] == allsecond)
+                    }
+                    if (opacityother[x][y] != 1 && textureness[(int)(i * subdivision / size)][(int)(j * subdivision / size)] == allsecond) {
                         textureness[(int)(i * subdivision / size)][(int)(j * subdivision / size)] = mixed;
-                    if (opacityother[i][j] && textureness[(int)(x * subdivision / size)][(int)(y * subdivision / size)] == allfirst)
+                    }
+                    if (opacityother[i][j] && textureness[(int)(x * subdivision / size)][(int)(y * subdivision / size)] == allfirst) {
                         textureness[(int)(x * subdivision / size)][(int)(y * subdivision / size)] = mixed;
-                    if (opacityother[i][j] != 1 && textureness[(int)(x * subdivision / size)][(int)(y * subdivision / size)] == allsecond)
+                    }
+                    if (opacityother[i][j] != 1 && textureness[(int)(x * subdivision / size)][(int)(y * subdivision / size)] == allsecond) {
                         textureness[(int)(x * subdivision / size)][(int)(y * subdivision / size)] = mixed;
+                    }
                     j--;
                 }
                 i++;
@@ -574,38 +596,50 @@ bool Terrain::load(const std::string& fileName)
 
             if (i < size - 1) {
                 i++;
-                if (opacityother[x][y] && textureness[(int)(i * subdivision / size)][(int)(j * subdivision / size)] == allfirst)
+                if (opacityother[x][y] && textureness[(int)(i * subdivision / size)][(int)(j * subdivision / size)] == allfirst) {
                     textureness[(int)(i * subdivision / size)][(int)(j * subdivision / size)] = mixed;
-                if (opacityother[x][y] != 1 && textureness[(int)(i * subdivision / size)][(int)(j * subdivision / size)] == allsecond)
+                }
+                if (opacityother[x][y] != 1 && textureness[(int)(i * subdivision / size)][(int)(j * subdivision / size)] == allsecond) {
                     textureness[(int)(i * subdivision / size)][(int)(j * subdivision / size)] = mixed;
-                if (opacityother[i][j] && textureness[(int)(x * subdivision / size)][(int)(y * subdivision / size)] == allfirst)
+                }
+                if (opacityother[i][j] && textureness[(int)(x * subdivision / size)][(int)(y * subdivision / size)] == allfirst) {
                     textureness[(int)(x * subdivision / size)][(int)(y * subdivision / size)] = mixed;
-                if (opacityother[i][j] != 1 && textureness[(int)(x * subdivision / size)][(int)(y * subdivision / size)] == allsecond)
+                }
+                if (opacityother[i][j] != 1 && textureness[(int)(x * subdivision / size)][(int)(y * subdivision / size)] == allsecond) {
                     textureness[(int)(x * subdivision / size)][(int)(y * subdivision / size)] = mixed;
+                }
 
                 if (j > 0) {
                     j--;
-                    if (opacityother[x][y] && textureness[(int)(i * subdivision / size)][(int)(j * subdivision / size)] == allfirst)
+                    if (opacityother[x][y] && textureness[(int)(i * subdivision / size)][(int)(j * subdivision / size)] == allfirst) {
                         textureness[(int)(i * subdivision / size)][(int)(j * subdivision / size)] = mixed;
-                    if (opacityother[x][y] != 1 && textureness[(int)(i * subdivision / size)][(int)(j * subdivision / size)] == allsecond)
+                    }
+                    if (opacityother[x][y] != 1 && textureness[(int)(i * subdivision / size)][(int)(j * subdivision / size)] == allsecond) {
                         textureness[(int)(i * subdivision / size)][(int)(j * subdivision / size)] = mixed;
-                    if (opacityother[i][j] && textureness[(int)(x * subdivision / size)][(int)(y * subdivision / size)] == allfirst)
+                    }
+                    if (opacityother[i][j] && textureness[(int)(x * subdivision / size)][(int)(y * subdivision / size)] == allfirst) {
                         textureness[(int)(x * subdivision / size)][(int)(y * subdivision / size)] = mixed;
-                    if (opacityother[i][j] != 1 && textureness[(int)(x * subdivision / size)][(int)(y * subdivision / size)] == allsecond)
+                    }
+                    if (opacityother[i][j] != 1 && textureness[(int)(x * subdivision / size)][(int)(y * subdivision / size)] == allsecond) {
                         textureness[(int)(x * subdivision / size)][(int)(y * subdivision / size)] = mixed;
+                    }
                     j++;
                 }
 
                 if (j < size - 1) {
                     j++;
-                    if (opacityother[x][y] && textureness[(int)(i * subdivision / size)][(int)(j * subdivision / size)] == allfirst)
+                    if (opacityother[x][y] && textureness[(int)(i * subdivision / size)][(int)(j * subdivision / size)] == allfirst) {
                         textureness[(int)(i * subdivision / size)][(int)(j * subdivision / size)] = mixed;
-                    if (opacityother[x][y] != 1 && textureness[(int)(i * subdivision / size)][(int)(j * subdivision / size)] == allsecond)
+                    }
+                    if (opacityother[x][y] != 1 && textureness[(int)(i * subdivision / size)][(int)(j * subdivision / size)] == allsecond) {
                         textureness[(int)(i * subdivision / size)][(int)(j * subdivision / size)] = mixed;
-                    if (opacityother[i][j] && textureness[(int)(x * subdivision / size)][(int)(y * subdivision / size)] == allfirst)
+                    }
+                    if (opacityother[i][j] && textureness[(int)(x * subdivision / size)][(int)(y * subdivision / size)] == allfirst) {
                         textureness[(int)(x * subdivision / size)][(int)(y * subdivision / size)] = mixed;
-                    if (opacityother[i][j] != 1 && textureness[(int)(x * subdivision / size)][(int)(y * subdivision / size)] == allsecond)
+                    }
+                    if (opacityother[i][j] != 1 && textureness[(int)(x * subdivision / size)][(int)(y * subdivision / size)] == allsecond) {
                         textureness[(int)(x * subdivision / size)][(int)(y * subdivision / size)] = mixed;
+                    }
                     j--;
                 }
                 i--;
@@ -613,37 +647,43 @@ bool Terrain::load(const std::string& fileName)
 
             if (j > 0) {
                 j--;
-                if (opacityother[x][y] && textureness[(int)(i * subdivision / size)][(int)(j * subdivision / size)] == allfirst)
+                if (opacityother[x][y] && textureness[(int)(i * subdivision / size)][(int)(j * subdivision / size)] == allfirst) {
                     textureness[(int)(i * subdivision / size)][(int)(j * subdivision / size)] = mixed;
-                if (opacityother[x][y] != 1 && textureness[(int)(i * subdivision / size)][(int)(j * subdivision / size)] == allsecond)
+                }
+                if (opacityother[x][y] != 1 && textureness[(int)(i * subdivision / size)][(int)(j * subdivision / size)] == allsecond) {
                     textureness[(int)(i * subdivision / size)][(int)(j * subdivision / size)] = mixed;
-                if (opacityother[i][j] && textureness[(int)(x * subdivision / size)][(int)(y * subdivision / size)] == allfirst)
+                }
+                if (opacityother[i][j] && textureness[(int)(x * subdivision / size)][(int)(y * subdivision / size)] == allfirst) {
                     textureness[(int)(x * subdivision / size)][(int)(y * subdivision / size)] = mixed;
-                if (opacityother[i][j] != 1 && textureness[(int)(x * subdivision / size)][(int)(y * subdivision / size)] == allsecond)
+                }
+                if (opacityother[i][j] != 1 && textureness[(int)(x * subdivision / size)][(int)(y * subdivision / size)] == allsecond) {
                     textureness[(int)(x * subdivision / size)][(int)(y * subdivision / size)] = mixed;
+                }
                 j++;
             }
 
             if (j < size - 1) {
                 j++;
-                if (opacityother[x][y] && textureness[(int)(i * subdivision / size)][(int)(j * subdivision / size)] == allfirst)
+                if (opacityother[x][y] && textureness[(int)(i * subdivision / size)][(int)(j * subdivision / size)] == allfirst) {
                     textureness[(int)(i * subdivision / size)][(int)(j * subdivision / size)] = mixed;
-                if (opacityother[x][y] != 1 && textureness[(int)(i * subdivision / size)][(int)(j * subdivision / size)] == allsecond)
+                }
+                if (opacityother[x][y] != 1 && textureness[(int)(i * subdivision / size)][(int)(j * subdivision / size)] == allsecond) {
                     textureness[(int)(i * subdivision / size)][(int)(j * subdivision / size)] = mixed;
-                if (opacityother[i][j] && textureness[(int)(x * subdivision / size)][(int)(y * subdivision / size)] == allfirst)
+                }
+                if (opacityother[i][j] && textureness[(int)(x * subdivision / size)][(int)(y * subdivision / size)] == allfirst) {
                     textureness[(int)(x * subdivision / size)][(int)(y * subdivision / size)] = mixed;
-                if (opacityother[i][j] != 1 && textureness[(int)(x * subdivision / size)][(int)(y * subdivision / size)] == allsecond)
+                }
+                if (opacityother[i][j] != 1 && textureness[(int)(x * subdivision / size)][(int)(y * subdivision / size)] == allsecond) {
                     textureness[(int)(x * subdivision / size)][(int)(y * subdivision / size)] = mixed;
+                }
                 j--;
-
             }
         }
     }
-    if (visibleloading)
-        Game::LoadingScreen();
+    Game::LoadingScreen();
 
     patch_size = size / subdivision;
-    patch_elements = (patch_size) * (patch_size) * 54;
+    patch_elements = patch_size * patch_size * 54;
     CalculateNormals();
 
     return true;
@@ -690,7 +730,6 @@ void Terrain::CalculateNormals()
             normals[i][j + 1] = normals[i][j + 1] + facenormal;
             normals[i + 1][j] = normals[i + 1][j] + facenormal;
 
-
             a.x = i + 1;
             a.y = heightmap[i + 1][j];
             a.z = j;
@@ -727,13 +766,16 @@ void Terrain::CalculateNormals()
 
 void Terrain::drawpatch(int whichx, int whichy, float opacity)
 {
-    if (opacity >= 1)
+    if (opacity >= 1) {
         glDisable(GL_BLEND);
+    }
     if (opacity < 1) {
         glEnable(GL_BLEND);
         UpdateTransparency(whichx, whichy);
     }
+
     glColor4f(1, 1, 1, 1);
+
     //Set up vertex array
     glEnableClientState(GL_VERTEX_ARRAY);
     glEnableClientState(GL_COLOR_ARRAY);
@@ -757,7 +799,9 @@ void Terrain::drawpatchother(int whichx, int whichy, float opacity)
         UpdateTransparency(whichx, whichy);
     }
     UpdateTransparencyother(whichx, whichy);
+
     glColor4f(1, 1, 1, 1);
+
     //Set up vertex array
     glEnableClientState(GL_VERTEX_ARRAY);
     glEnableClientState(GL_COLOR_ARRAY);
@@ -774,7 +818,7 @@ void Terrain::drawpatchother(int whichx, int whichy, float opacity)
     glDisableClientState(GL_TEXTURE_COORD_ARRAY);
 }
 
-void Terrain::drawpatchotherother(int whichx, int whichy, float opacity)
+void Terrain::drawpatchotherother(int whichx, int whichy)
 {
     glEnable(GL_BLEND);
     UpdateTransparencyotherother(whichx, whichy);
@@ -804,7 +848,6 @@ void Terrain::drawpatchotherother(int whichx, int whichy, float opacity)
     glMatrixMode(GL_MODELVIEW);
 }
 
-
 float Terrain::getHeight(float pointx, float pointz)
 {
     static int tilex, tiley;
@@ -813,8 +856,9 @@ float Terrain::getHeight(float pointx, float pointz)
     pointx /= scale;
     pointz /= scale;
 
-    if (pointx >= size - 1 || pointz >= size - 1 || pointx <= 0 || pointz <= 0)
+    if (pointx >= size - 1 || pointz >= size - 1 || pointx <= 0 || pointz <= 0) {
         return 0;
+    }
 
     startpoint.x = pointx;
     startpoint.y = -1000;
@@ -863,8 +907,9 @@ float Terrain::getOpacity(float pointx, float pointz)
     pointx /= scale;
     pointz /= scale;
 
-    if (pointx >= size - 1 || pointz >= size - 1 || pointx <= 0 || pointz <= 0)
+    if (pointx >= size - 1 || pointz >= size - 1 || pointx <= 0 || pointz <= 0) {
         return 0;
+    }
 
     tilex = pointx;
     tiley = pointz;
@@ -884,8 +929,9 @@ XYZ Terrain::getNormal(float pointx, float pointz)
     pointz /= scale;
 
     height1 = 0;
-    if (pointx >= size - 1 || pointz >= size - 1 || pointx <= 0 || pointz <= 0)
+    if (pointx >= size - 1 || pointz >= size - 1 || pointx <= 0 || pointz <= 0) {
         return height1;
+    }
     tilex = pointx;
     tiley = pointz;
 
@@ -905,8 +951,9 @@ XYZ Terrain::getLighting(float pointx, float pointz)
     pointz /= scale;
 
     height1 = 0;
-    if (pointx >= size - 1 || pointz >= size - 1 || pointx <= 0 || pointz <= 0)
+    if (pointx >= size - 1 || pointz >= size - 1 || pointx <= 0 || pointz <= 0) {
         return height1;
+    }
     tilex = pointx;
     tiley = pointz;
 
@@ -936,19 +983,23 @@ void Terrain::draw(int layer)
     viewdistsquared = viewdistance * viewdistance;
 
     //Only nearby blocks
-    beginx = (viewer.x - viewdistance) / (patch_size) - 1;
-    if (beginx < 0)
+    beginx = ((viewer.x - viewdistance) / patch_size) - 1;
+    if (beginx < 0) {
         beginx = 0;
-    beginz = (viewer.z - viewdistance) / (patch_size) - 1;
-    if (beginz < 0)
+    }
+    beginz = ((viewer.z - viewdistance) / patch_size) - 1;
+    if (beginz < 0) {
         beginz = 0;
+    }
 
-    endx = (viewer.x + viewdistance) / (patch_size) + 1;
-    if (endx > subdivision)
+    endx = ((viewer.x + viewdistance) / patch_size) + 1;
+    if (endx > subdivision) {
         endx = subdivision;
-    endz = (viewer.z + viewdistance) / (patch_size) + 1;
-    if (endz > subdivision)
+    }
+    endz = ((viewer.z + viewdistance) / patch_size) + 1;
+    if (endz > subdivision) {
         endz = subdivision;
+    }
 
     if (!layer) {
         for (i = beginx; i < endx; i++) {
@@ -964,43 +1015,54 @@ void Terrain::draw(int layer)
         for (j = beginz; j < endz; j++) {
             if (distance[i][j] < (viewdistance + patch_size) * (viewdistance + patch_size)) {
                 opacity = 1;
-                if (distance[i][j] > viewdistsquared * fadestart - viewdistsquared)
+                if (distance[i][j] > viewdistsquared * fadestart - viewdistsquared) {
                     opacity = 0;
-                if (opacity == 1 && i != subdivision)
-                    if (distance[i + 1][j] > viewdistsquared * fadestart - viewdistsquared)
+                }
+                if (opacity == 1 && i != subdivision) {
+                    if (distance[i + 1][j] > viewdistsquared * fadestart - viewdistsquared) {
                         opacity = 0;
-                if (opacity == 1 && j != subdivision)
-                    if (distance[i][j + 1] > viewdistsquared * fadestart - viewdistsquared)
+                    }
+                }
+                if (opacity == 1 && j != subdivision) {
+                    if (distance[i][j + 1] > viewdistsquared * fadestart - viewdistsquared) {
                         opacity = 0;
-                if (opacity == 1 && j != subdivision && i != subdivision)
-                    if (distance[i + 1][j + 1] > viewdistsquared * fadestart - viewdistsquared)
+                    }
+                }
+                if (opacity == 1 && j != subdivision && i != subdivision) {
+                    if (distance[i + 1][j + 1] > viewdistsquared * fadestart - viewdistsquared) {
                         opacity = 0;
+                    }
+                }
                 glMatrixMode(GL_MODELVIEW);
                 glPushMatrix();
                 if (frustum.CubeInFrustum(i * patch_size + patch_size * .5, avgypatch[i][j], j * patch_size + patch_size * .5, heightypatch[i][j] / 2)) {
-                    if (environment == desertenvironment && distance[i][j] > viewdistsquared / 4)
-                        glTexEnvf( GL_TEXTURE_FILTER_CONTROL_EXT, GL_TEXTURE_LOD_BIAS_EXT, blurness);
-                    else if (environment == desertenvironment)
-                        glTexEnvf( GL_TEXTURE_FILTER_CONTROL_EXT, GL_TEXTURE_LOD_BIAS_EXT, 0 );
-                    if (!layer && textureness[i][j] != allsecond)
+                    if (environment == desertenvironment && distance[i][j] > viewdistsquared / 4) {
+                        glTexEnvf(GL_TEXTURE_FILTER_CONTROL_EXT, GL_TEXTURE_LOD_BIAS_EXT, blurness);
+                    } else if (environment == desertenvironment) {
+                        glTexEnvf(GL_TEXTURE_FILTER_CONTROL_EXT, GL_TEXTURE_LOD_BIAS_EXT, 0);
+                    }
+                    if (!layer && textureness[i][j] != allsecond) {
                         drawpatch(i, j, opacity);
-                    if (layer == 1 && textureness[i][j] != allfirst)
+                    }
+                    if (layer == 1 && textureness[i][j] != allfirst) {
                         drawpatchother(i, j, opacity);
-                    if (layer == 2 && textureness[i][j] != allfirst)
-                        drawpatchotherother(i, j, opacity);
+                    }
+                    if (layer == 2 && textureness[i][j] != allfirst) {
+                        drawpatchotherother(i, j);
+                    }
                 }
                 glPopMatrix();
             }
         }
     }
-    if (environment == desertenvironment)
-        glTexEnvf( GL_TEXTURE_FILTER_CONTROL_EXT, GL_TEXTURE_LOD_BIAS_EXT, 0 );
+    if (environment == desertenvironment) {
+        glTexEnvf(GL_TEXTURE_FILTER_CONTROL_EXT, GL_TEXTURE_LOD_BIAS_EXT, 0);
+    }
 }
 
 void Terrain::drawdecals()
 {
-    if (decals) {
-        static int i;
+    if (decalstoggle) {
         static float distancemult;
         static int lasttype;
 
@@ -1016,87 +1078,98 @@ void Terrain::drawdecals()
         glDisable(GL_CULL_FACE);
         glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
         glDepthMask(0);
-        for (i = 0; i < numdecals; i++) {
-            if (decaltype[i] == blooddecalfast && decalalivetime[i] < 2)
-                decalalivetime[i] = 2;
-            if ((decaltype[i] == shadowdecal || decaltype[i] == shadowdecalpermanent) && decaltype[i] != lasttype) {
-                shadowtexture.bind();
-                if (!blend) {
-                    blend = 1;
-                    glAlphaFunc(GL_GREATER, 0.0001);
-                    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
-                }
+        for (unsigned int i = 0; i < decals.size(); i++) {
+            if (decals[i].type == blooddecalfast && decals[i].alivetime < 2) {
+                decals[i].alivetime = 2;
             }
-            if (decaltype[i] == footprintdecal && decaltype[i] != lasttype) {
-                footprinttexture.bind();
-                if (!blend) {
-                    blend = 1;
-                    glAlphaFunc(GL_GREATER, 0.0001);
-                    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+            if (decals[i].type != lasttype) {
+                if (decals[i].type == shadowdecal || decals[i].type == shadowdecalpermanent) {
+                    shadowtexture.bind();
+                    if (!blend) {
+                        blend = 1;
+                        glAlphaFunc(GL_GREATER, 0.0001);
+                        glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+                    }
                 }
-            }
-            if (decaltype[i] == bodyprintdecal && decaltype[i] != lasttype) {
-                bodyprinttexture.bind();
-                if (!blend) {
-                    blend = 1;
-                    glAlphaFunc(GL_GREATER, 0.0001);
-                    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+                if (decals[i].type == footprintdecal) {
+                    footprinttexture.bind();
+                    if (!blend) {
+                        blend = 1;
+                        glAlphaFunc(GL_GREATER, 0.0001);
+                        glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+                    }
                 }
-            }
-            if ((decaltype[i] == blooddecal || decaltype[i] == blooddecalslow) && decaltype[i] != lasttype) {
-                bloodtexture.bind();
-                if (blend) {
-                    blend = 0;
-                    glAlphaFunc(GL_GREATER, 0.15);
-                    glBlendFunc(GL_ONE, GL_ZERO);
+                if (decals[i].type == bodyprintdecal) {
+                    bodyprinttexture.bind();
+                    if (!blend) {
+                        blend = 1;
+                        glAlphaFunc(GL_GREATER, 0.0001);
+                        glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+                    }
                 }
-            }
-            if ((decaltype[i] == blooddecalfast) && decaltype[i] != lasttype) {
-                bloodtexture2.bind();
-                if (blend) {
-                    blend = 0;
-                    glAlphaFunc(GL_GREATER, 0.15);
-                    glBlendFunc(GL_ONE, GL_ZERO);
+                if (decals[i].type == blooddecal || decals[i].type == blooddecalslow) {
+                    bloodtexture.bind();
+                    if (blend) {
+                        blend = 0;
+                        glAlphaFunc(GL_GREATER, 0.15);
+                        glBlendFunc(GL_ONE, GL_ZERO);
+                    }
+                }
+                if (decals[i].type == blooddecalfast) {
+                    bloodtexture2.bind();
+                    if (blend) {
+                        blend = 0;
+                        glAlphaFunc(GL_GREATER, 0.15);
+                        glBlendFunc(GL_ONE, GL_ZERO);
+                    }
                 }
             }
-            if (decaltype[i] == shadowdecal || decaltype[i] == shadowdecalpermanent) {
-                distancemult = (viewdistsquared - (distsq(&viewer, &decalposition[i]) - (viewdistsquared * fadestart)) * (1 / (1 - fadestart))) / viewdistsquared;
-                if (distancemult >= 1)
-                    glColor4f(1, 1, 1, decalopacity[i]);
-                if (distancemult < 1)
-                    glColor4f(1, 1, 1, decalopacity[i]*distancemult);
+            if (decals[i].type == shadowdecal || decals[i].type == shadowdecalpermanent) {
+                distancemult = (viewdistsquared - (distsq(&viewer, &decals[i].position) - (viewdistsquared * fadestart)) * (1 / (1 - fadestart))) / viewdistsquared;
+                if (distancemult >= 1) {
+                    glColor4f(1, 1, 1, decals[i].opacity);
+                }
+                if (distancemult < 1) {
+                    glColor4f(1, 1, 1, decals[i].opacity * distancemult);
+                }
             }
-            if (decaltype[i] == footprintdecal || decaltype[i] == bodyprintdecal) {
-                distancemult = (viewdistsquared - (distsq(&viewer, &decalposition[i]) - (viewdistsquared * fadestart)) * (1 / (1 - fadestart))) / viewdistsquared;
+            if (decals[i].type == footprintdecal || decals[i].type == bodyprintdecal) {
+                distancemult = (viewdistsquared - (distsq(&viewer, &decals[i].position) - (viewdistsquared * fadestart)) * (1 / (1 - fadestart))) / viewdistsquared;
                 if (distancemult >= 1) {
-                    glColor4f(1, 1, 1, decalopacity[i]);
-                    if (decalalivetime[i] > 3)
-                        glColor4f(1, 1, 1, decalopacity[i] * (5 - decalalivetime[i]) / 2);
+                    glColor4f(1, 1, 1, decals[i].opacity);
+                    if (decals[i].alivetime > 3) {
+                        glColor4f(1, 1, 1, decals[i].opacity * (5 - decals[i].alivetime) / 2);
+                    }
                 }
                 if (distancemult < 1) {
-                    glColor4f(1, 1, 1, decalopacity[i]*distancemult);
-                    if (decalalivetime[i] > 3)
-                        glColor4f(1, 1, 1, decalopacity[i] * (5 - decalalivetime[i]) / 2 * distancemult);
+                    glColor4f(1, 1, 1, decals[i].opacity * distancemult);
+                    if (decals[i].alivetime > 3) {
+                        glColor4f(1, 1, 1, decals[i].opacity * (5 - decals[i].alivetime) / 2 * distancemult);
+                    }
                 }
             }
-            if ((decaltype[i] == blooddecal || decaltype[i] == blooddecalfast || decaltype[i] == blooddecalslow)) {
-                distancemult = (viewdistsquared - (distsq(&viewer, &decalposition[i]) - (viewdistsquared * fadestart)) * (1 / (1 - fadestart))) / viewdistsquared;
+            if ((decals[i].type == blooddecal || decals[i].type == blooddecalfast || decals[i].type == blooddecalslow)) {
+                distancemult = (viewdistsquared - (distsq(&viewer, &decals[i].position) - (viewdistsquared * fadestart)) * (1 / (1 - fadestart))) / viewdistsquared;
                 if (distancemult >= 1) {
-                    glColor4f(decalbrightness[i], decalbrightness[i], decalbrightness[i], decalopacity[i]);
-                    if (decalalivetime[i] < 4)
-                        glColor4f(decalbrightness[i], decalbrightness[i], decalbrightness[i], decalopacity[i]*decalalivetime[i]*.25);
-                    if (decalalivetime[i] > 58)
-                        glColor4f(decalbrightness[i], decalbrightness[i], decalbrightness[i], decalopacity[i] * (60 - decalalivetime[i]) / 2);
+                    glColor4f(decals[i].brightness, decals[i].brightness, decals[i].brightness, decals[i].opacity);
+                    if (decals[i].alivetime < 4) {
+                        glColor4f(decals[i].brightness, decals[i].brightness, decals[i].brightness, decals[i].opacity * decals[i].alivetime * .25);
+                    }
+                    if (decals[i].alivetime > 58) {
+                        glColor4f(decals[i].brightness, decals[i].brightness, decals[i].brightness, decals[i].opacity * (60 - decals[i].alivetime) / 2);
+                    }
                 }
                 if (distancemult < 1) {
-                    glColor4f(decalbrightness[i], decalbrightness[i], decalbrightness[i], decalopacity[i]*distancemult);
-                    if (decalalivetime[i] < 4)
-                        glColor4f(decalbrightness[i], decalbrightness[i], decalbrightness[i], decalopacity[i]*decalalivetime[i]*distancemult * .25);
-                    if (decalalivetime[i] > 58)
-                        glColor4f(decalbrightness[i], decalbrightness[i], decalbrightness[i], decalopacity[i] * (60 - decalalivetime[i]) / 2 * distancemult);
+                    glColor4f(decals[i].brightness, decals[i].brightness, decals[i].brightness, decals[i].opacity * distancemult);
+                    if (decals[i].alivetime < 4) {
+                        glColor4f(decals[i].brightness, decals[i].brightness, decals[i].brightness, decals[i].opacity * decals[i].alivetime * distancemult * .25);
+                    }
+                    if (decals[i].alivetime > 58) {
+                        glColor4f(decals[i].brightness, decals[i].brightness, decals[i].brightness, decals[i].opacity * (60 - decals[i].alivetime) / 2 * distancemult);
+                    }
                 }
             }
-            lasttype = decaltype[i];
+            lasttype = decals[i].type;
             glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
             glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
 
@@ -1104,95 +1177,84 @@ void Terrain::drawdecals()
             glPushMatrix();
             glBegin(GL_TRIANGLES);
             for (int j = 0; j < 3; j++) {
-                glTexCoord2f(decaltexcoords[i][j][0], decaltexcoords[i][j][1]);
-                glVertex3f(decalvertex[i][j].x, decalvertex[i][j].y, decalvertex[i][j].z);
+                glTexCoord2f(decals[i].texcoords[j][0], decals[i].texcoords[j][1]);
+                glVertex3f(decals[i].vertex[j].x, decals[i].vertex[j].y, decals[i].vertex[j].z);
             }
             glEnd();
             glPopMatrix();
         }
-        for (i = numdecals - 1; i >= 0; i--) {
-            decalalivetime[i] += multiplier;
-            if (decaltype[i] == blooddecalslow)
-                decalalivetime[i] -= multiplier * 2 / 3;
-            if (decaltype[i] == blooddecalfast)
-                decalalivetime[i] += multiplier * 4;
-            if (decaltype[i] == shadowdecal)
+        for (int i = decals.size() - 1; i >= 0; i--) {
+            decals[i].alivetime += multiplier;
+            if (decals[i].type == blooddecalslow) {
+                decals[i].alivetime -= multiplier * 2 / 3;
+            }
+            if (decals[i].type == blooddecalfast) {
+                decals[i].alivetime += multiplier * 4;
+            }
+            if (decals[i].type == shadowdecal) {
                 DeleteDecal(i);
-            if (decaltype[i] == footprintdecal && decalalivetime[i] >= 5)
+            }
+            if (decals[i].type == footprintdecal && decals[i].alivetime >= 5) {
                 DeleteDecal(i);
-            if (decaltype[i] == bodyprintdecal && decalalivetime[i] >= 5)
+            }
+            if (decals[i].type == bodyprintdecal && decals[i].alivetime >= 5) {
                 DeleteDecal(i);
-            if ((decaltype[i] == blooddecal || decaltype[i] == blooddecalfast || decaltype[i] == blooddecalslow) && decalalivetime[i] >= 60)
+            }
+            if ((decals[i].type == blooddecal || decals[i].type == blooddecalfast || decals[i].type == blooddecalslow) && decals[i].alivetime >= 60) {
                 DeleteDecal(i);
+            }
         }
         glAlphaFunc(GL_GREATER, 0.0001);
     }
 }
 
+void Terrain::deleteDeadDecals()
+{
+    for (int i = decals.size() - 1; i >= 0; i--) {
+        if ((decals[i].type == blooddecal || decals[i].type == blooddecalslow) && decals[i].alivetime < 2) {
+            DeleteDecal(i);
+        }
+    }
+}
+
 void Terrain::AddObject(XYZ where, float radius, int id)
 {
-    bool done;
-    int i, j;
-    XYZ points[4];
-    if (id >= 0 && id < 10000)
-        for (i = 0; i < subdivision; i++) {
-            for (j = 0; j < subdivision; j++) {
-                if (patchobjectnum[i][j] < 300 - 1) {
-                    done = 0;
+    XYZ points[2];
+    if (id >= 0 && id < 10000) {
+        for (int i = 0; i < subdivision; i++) {
+            for (int j = 0; j < subdivision; j++) {
+                if (patchobjects[i][j].size() < 300 - 1) {
                     points[0].x = (size / subdivision) * i;
                     points[0].z = (size / subdivision) * j;
                     points[0].y = heightmap[(int)points[0].x][(int)points[0].z];
                     points[1].x = (size / subdivision) * (i + 1);
-                    points[1].z = (size / subdivision) * j;
+                    points[1].z = (size / subdivision) * (j + 1);
                     points[1].y = heightmap[(int)points[1].x][(int)points[1].z];
-                    points[2].x = (size / subdivision) * (i + 1);
-                    points[2].z = (size / subdivision) * (j + 1);
-                    points[2].y = heightmap[(int)points[2].x][(int)points[2].z];
-                    points[3].x = (size / subdivision) * i;
-                    points[3].z = (size / subdivision) * (j + 1);
-                    points[3].y = heightmap[(int)points[3].x][(int)points[3].z];
                     points[0] *= scale;
                     points[1] *= scale;
-                    points[2] *= scale;
-                    points[3] *= scale;
-                    if (!done && where.x + radius > points[0].x && where.x - radius < points[2].x && where.z + radius > points[0].z && where.z - radius < points[2].z) {
-                        patchobjects[i][j][patchobjectnum[i][j]] = id;
-                        patchobjectnum[i][j]++;
-                        done = 1;
+                    if (where.x + radius > points[0].x && where.x - radius < points[1].x && where.z + radius > points[0].z && where.z - radius < points[1].z) {
+                        patchobjects[i][j].push_back(id);
                     }
                 }
             }
         }
+    }
 }
 
 void Terrain::DeleteDecal(int which)
 {
-    if (decals) {
-        decaltype[which] = decaltype[numdecals - 1];
-        decalposition[which] = decalposition[numdecals - 1];
-        for (int i = 0; i < 3; i++) {
-            decalvertex[which][i] = decalvertex[numdecals - 1][i];
-            decaltexcoords[which][i][0] = decaltexcoords[numdecals - 1][i][0];
-            decaltexcoords[which][i][1] = decaltexcoords[numdecals - 1][i][1];
-        }
-        decalrotation[which] = decalrotation[numdecals - 1];
-        decalalivetime[which] = decalalivetime[numdecals - 1];
-        decalopacity[which] = decalopacity[numdecals - 1];
-        decalbrightness[which] = decalbrightness[numdecals - 1];
-        numdecals--;
+    if (decalstoggle) {
+        decals.erase(decals.begin() + which);
     }
 }
 
-void Terrain::MakeDecal(int type, XYZ where, float size, float opacity, float rotation)
+void Terrain::MakeDecal(decal_type type, XYZ where, float size, float opacity, float rotation)
 {
-    if (decals) {
+    if (decalstoggle) {
         if (opacity > 0 && size > 0) {
             static int patchx[4];
             static int patchy[4];
 
-            decaltexcoords[numdecals][0][0] = 1;
-            decaltexcoords[numdecals][0][1] = 0;
-
             patchx[0] = (where.x + size) / scale;
             patchx[1] = (where.x - size) / scale;
             patchx[2] = (where.x - size) / scale;
@@ -1214,160 +1276,69 @@ void Terrain::MakeDecal(int type, XYZ where, float size, float opacity, float ro
             if ((patchx[2] != patchx[3] || patchy[2] != patchy[3])) {
                 MakeDecalLock(type, where, patchx[2], patchy[2], size, opacity, rotation);
             }
+
             MakeDecalLock(type, where, patchx[3], patchy[3], size, opacity, rotation);
         }
     }
-    //}
 }
 
-void Terrain::MakeDecalLock(int type, XYZ where, int whichx, int whichy, float size, float opacity, float rotation)
+void Terrain::MakeDecalLock(decal_type type, XYZ where, int whichx, int whichy, float size, float opacity, float rotation)
 {
-    if (decals) {
-        static float placex, placez;
-        static XYZ rot;
+    if (decalstoggle) {
+        XYZ rot = getLighting(where.x, where.z);
+        float decalbright = (rot.x + rot.y + rot.z) / 3;
 
-        float decalbright;
-
-        rot = getLighting(where.x, where.z);
-        decalbrightness[numdecals] = (rot.x + rot.y + rot.z) / 3;
-        if (decalbrightness[numdecals] < .4)
-            decalbrightness[numdecals] = .4;
+        if (decalbright < .4) {
+            decalbright = .4;
+        }
 
         if (environment == grassyenvironment) {
-            decalbrightness[numdecals] *= .6;
+            decalbright *= .6;
         }
 
-        if (decalbrightness[numdecals] > 1)
-            decalbrightness[numdecals] = 1;
-        decalbright = decalbrightness[numdecals];
-
-        decalposition[numdecals] = where;
-        decaltype[numdecals] = type;
-        decalopacity[numdecals] = opacity;
-        decalrotation[numdecals] = rotation;
-        decalalivetime[numdecals] = 0;
-
-        placex = (float)whichx * scale + scale;
-        placez = (float)whichy * scale;
-
-        decaltexcoords[numdecals][0][0] = (placex - where.x) / size / 2 + .5;
-        decaltexcoords[numdecals][0][1] = (placez - where.z) / size / 2 + .5;
-
-        decalvertex[numdecals][0].x = placex;
-        decalvertex[numdecals][0].z = placez;
-        decalvertex[numdecals][0].y = heightmap[whichx + 1][whichy] * scale + .01;
-
-
-        placex = (float)whichx * scale + scale;
-        placez = (float)whichy * scale + scale;
-
-        decaltexcoords[numdecals][1][0] = (placex - where.x) / size / 2 + .5;
-        decaltexcoords[numdecals][1][1] = (placez - where.z) / size / 2 + .5;
-
-        decalvertex[numdecals][1].x = placex;
-        decalvertex[numdecals][1].z = placez;
-        decalvertex[numdecals][1].y = heightmap[whichx + 1][whichy + 1] * scale + .01;
-
-
-        placex = (float)whichx * scale;
-        placez = (float)whichy * scale + scale;
-
-        decaltexcoords[numdecals][2][0] = (placex - where.x) / size / 2 + .5;
-        decaltexcoords[numdecals][2][1] = (placez - where.z) / size / 2 + .5;
+        if (decalbright > 1) {
+            decalbright = 1;
+        }
 
-        decalvertex[numdecals][2].x = placex;
-        decalvertex[numdecals][2].z = placez;
-        decalvertex[numdecals][2].y = heightmap[whichx][whichy + 1] * scale + .01;
+        Decal decal(where, type, opacity, rotation, decalbright, whichx, whichy, size, *this, true);
 
-        if (decalrotation[numdecals]) {
-            for (int i = 0; i < 3; i++) {
-                rot.y = 0;
-                rot.x = decaltexcoords[numdecals][i][0] - .5;
-                rot.z = decaltexcoords[numdecals][i][1] - .5;
-                rot = DoRotation(rot, 0, -decalrotation[numdecals], 0);
-                decaltexcoords[numdecals][i][0] = rot.x + .5;
-                decaltexcoords[numdecals][i][1] = rot.z + .5;
+        if (!(decal.texcoords[0][0] < 0 && decal.texcoords[1][0] < 0 && decal.texcoords[2][0] < 0)) {
+            if (!(decal.texcoords[0][1] < 0 && decal.texcoords[1][1] < 0 && decal.texcoords[2][1] < 0)) {
+                if (!(decal.texcoords[0][0] > 1 && decal.texcoords[1][0] > 1 && decal.texcoords[2][0] > 1)) {
+                    if (!(decal.texcoords[0][1] > 1 && decal.texcoords[1][1] > 1 && decal.texcoords[2][1] > 1)) {
+                        if (decals.size() < max_decals - 1) {
+                            decals.push_back(decal);
+                        }
+                    }
+                }
             }
         }
 
-        if (!(decaltexcoords[numdecals][0][0] < 0 && decaltexcoords[numdecals][1][0] < 0 && decaltexcoords[numdecals][2][0] < 0))
-            if (!(decaltexcoords[numdecals][0][1] < 0 && decaltexcoords[numdecals][1][1] < 0 && decaltexcoords[numdecals][2][1] < 0))
-                if (!(decaltexcoords[numdecals][0][0] > 1 && decaltexcoords[numdecals][1][0] > 1 && decaltexcoords[numdecals][2][0] > 1))
-                    if (!(decaltexcoords[numdecals][0][1] > 1 && decaltexcoords[numdecals][1][1] > 1 && decaltexcoords[numdecals][2][1] > 1))
-                        if (numdecals < max_decals - 1)
-                            numdecals++;
-
-        decalbrightness[numdecals] = decalbright;
-
-        decalposition[numdecals] = where;
-        decaltype[numdecals] = type;
-        decalopacity[numdecals] = opacity;
-        decalrotation[numdecals] = rotation;
-        decalalivetime[numdecals] = 0;
-
-        placex = (float)whichx * scale + scale;
-        placez = (float)whichy * scale;
-
-        decaltexcoords[numdecals][0][0] = (placex - where.x) / size / 2 + .5;
-        decaltexcoords[numdecals][0][1] = (placez - where.z) / size / 2 + .5;
-
-        decalvertex[numdecals][0].x = placex;
-        decalvertex[numdecals][0].z = placez;
-        decalvertex[numdecals][0].y = heightmap[whichx + 1][whichy] * scale + .01;
+        Decal decal2(where, type, opacity, rotation, decalbright, whichx, whichy, size, *this, false);
 
-
-        placex = (float)whichx * scale;
-        placez = (float)whichy * scale;
-
-        decaltexcoords[numdecals][1][0] = (placex - where.x) / size / 2 + .5;
-        decaltexcoords[numdecals][1][1] = (placez - where.z) / size / 2 + .5;
-
-        decalvertex[numdecals][1].x = placex;
-        decalvertex[numdecals][1].z = placez;
-        decalvertex[numdecals][1].y = heightmap[whichx][whichy] * scale + .01;
-
-
-        placex = (float)whichx * scale;
-        placez = (float)whichy * scale + scale;
-
-        decaltexcoords[numdecals][2][0] = (placex - where.x) / size / 2 + .5;
-        decaltexcoords[numdecals][2][1] = (placez - where.z) / size / 2 + .5;
-
-        decalvertex[numdecals][2].x = placex;
-        decalvertex[numdecals][2].z = placez;
-        decalvertex[numdecals][2].y = heightmap[whichx][whichy + 1] * scale + .01;
-
-        if (decalrotation[numdecals]) {
-            for (int i = 0; i < 3; i++) {
-                rot.y = 0;
-                rot.x = decaltexcoords[numdecals][i][0] - .5;
-                rot.z = decaltexcoords[numdecals][i][1] - .5;
-                rot = DoRotation(rot, 0, -decalrotation[numdecals], 0);
-                decaltexcoords[numdecals][i][0] = rot.x + .5;
-                decaltexcoords[numdecals][i][1] = rot.z + .5;
+        if (!(decal2.texcoords[0][0] < 0 && decal2.texcoords[1][0] < 0 && decal2.texcoords[2][0] < 0)) {
+            if (!(decal2.texcoords[0][1] < 0 && decal2.texcoords[1][1] < 0 && decal2.texcoords[2][1] < 0)) {
+                if (!(decal2.texcoords[0][0] > 1 && decal2.texcoords[1][0] > 1 && decal2.texcoords[2][0] > 1)) {
+                    if (!(decal2.texcoords[0][1] > 1 && decal2.texcoords[1][1] > 1 && decal2.texcoords[2][1] > 1)) {
+                        if (decals.size() < max_decals - 1) {
+                            decals.push_back(decal2);
+                        }
+                    }
+                }
             }
         }
-
-        if (!(decaltexcoords[numdecals][0][0] < 0 && decaltexcoords[numdecals][1][0] < 0 && decaltexcoords[numdecals][2][0] < 0))
-            if (!(decaltexcoords[numdecals][0][1] < 0 && decaltexcoords[numdecals][1][1] < 0 && decaltexcoords[numdecals][2][1] < 0))
-                if (!(decaltexcoords[numdecals][0][0] > 1 && decaltexcoords[numdecals][1][0] > 1 && decaltexcoords[numdecals][2][0] > 1))
-                    if (!(decaltexcoords[numdecals][0][1] > 1 && decaltexcoords[numdecals][1][1] > 1 && decaltexcoords[numdecals][2][1] > 1))
-                        if (numdecals < max_decals - 1)
-                            numdecals++;
     }
 }
 
 void Terrain::DoShadows()
 {
-    static int i, j, k, l, todivide;
-    static float brightness, total;
     static XYZ testpoint, testpoint2, terrainpoint, lightloc, col;
     lightloc = light.location;
     if (!skyboxtexture) {
         lightloc.x = 0;
         lightloc.z = 0;
     }
-    if (skyboxtexture && tutoriallevel) {
+    if (skyboxtexture && Tutorial::active) {
         lightloc.x *= .4;
         lightloc.z *= .4;
     }
@@ -1375,60 +1346,73 @@ void Terrain::DoShadows()
     float shadowed;
     Normalise(&lightloc);
     //Calculate shadows
-    for (i = 0; i < size; i++) {
-        for (j = 0; j < size; j++) {
-            terrainpoint.x = (float)(i) * scale;
-            terrainpoint.z = (float)(j) * scale;
+    for (short int i = 0; i < size; i++) {
+        for (short int j = 0; j < size; j++) {
+            terrainpoint.x = (float)i * scale;
+            terrainpoint.z = (float)j * scale;
             terrainpoint.y = heightmap[i][j] * scale;
 
             shadowed = 0;
-            patchx = (float)(i) * subdivision / size;
-            patchz = (float)(j) * subdivision / size;
-            if (patchobjectnum[patchx][patchz]) {
-                for (k = 0; k < patchobjectnum[patchx][patchz]; k++) {
-                    l = patchobjects[patchx][patchz][k];
-                    if (objects.type[l] != treetrunktype) {
+            patchx = (float)i * subdivision / size;
+            patchz = (float)j * subdivision / size;
+            if (patchobjects[patchx][patchz].size()) {
+                for (unsigned int k = 0; k < patchobjects[patchx][patchz].size(); k++) {
+                    unsigned int l = patchobjects[patchx][patchz][k];
+                    if (Object::objects[l]->type != treetrunktype) {
                         testpoint = terrainpoint;
                         testpoint2 = terrainpoint + lightloc * 50 * (1 - shadowed);
-                        if (objects.model[l].LineCheck(&testpoint, &testpoint2, &col, &objects.position[l], &objects.yaw[l]) != -1) {
+                        if (Object::objects[l]->model.LineCheck(&testpoint, &testpoint2, &col, &Object::objects[l]->position, &Object::objects[l]->yaw) != -1) {
                             shadowed = 1 - (findDistance(&terrainpoint, &col) / 50);
                         }
                     }
                 }
-                if (visibleloading)
-                    Game::LoadingScreen();
+                Game::LoadingScreen();
             }
-            brightness = dotproduct(&lightloc, &normals[i][j]);
-            if (shadowed)
+            float brightness = dotproduct(&lightloc, &normals[i][j]);
+            if (shadowed) {
                 brightness *= 1 - shadowed;
+            }
 
-            if (brightness > 1)
+            if (brightness > 1) {
                 brightness = 1;
-            if (brightness < 0)
+            }
+            if (brightness < 0) {
                 brightness = 0;
+            }
 
             colors[i][j][0] = light.color[0] * brightness + light.ambient[0];
             colors[i][j][1] = light.color[1] * brightness + light.ambient[1];
             colors[i][j][2] = light.color[2] * brightness + light.ambient[2];
 
-            if (colors[i][j][0] > 1) colors[i][j][0] = 1;
-            if (colors[i][j][1] > 1) colors[i][j][1] = 1;
-            if (colors[i][j][2] > 1) colors[i][j][2] = 1;
-            if (colors[i][j][0] < 0) colors[i][j][0] = 0;
-            if (colors[i][j][1] < 0) colors[i][j][1] = 0;
-            if (colors[i][j][2] < 0) colors[i][j][2] = 0;
+            if (colors[i][j][0] > 1) {
+                colors[i][j][0] = 1;
+            }
+            if (colors[i][j][1] > 1) {
+                colors[i][j][1] = 1;
+            }
+            if (colors[i][j][2] > 1) {
+                colors[i][j][2] = 1;
+            }
+            if (colors[i][j][0] < 0) {
+                colors[i][j][0] = 0;
+            }
+            if (colors[i][j][1] < 0) {
+                colors[i][j][1] = 0;
+            }
+            if (colors[i][j][2] < 0) {
+                colors[i][j][2] = 0;
+            }
         }
     }
 
-    if (visibleloading)
-        Game::LoadingScreen();
+    Game::LoadingScreen();
 
     //Smooth shadows
-    for (i = 0; i < size; i++) {
-        for (j = 0; j < size; j++) {
-            for (k = 0; k < 3; k++) {
-                total = 0;
-                todivide = 0;
+    for (short int i = 0; i < size; i++) {
+        for (short int j = 0; j < size; j++) {
+            for (short int k = 0; k < 3; k++) {
+                float total = 0;
+                unsigned int todivide = 0;
                 if (i != 0) {
                     total += colors[j][i - 1][k];
                     todivide++;
@@ -1469,8 +1453,8 @@ void Terrain::DoShadows()
         }
     }
 
-    for (i = 0; i < subdivision; i++) {
-        for (j = 0; j < subdivision; j++) {
+    for (unsigned int i = 0; i < subdivision; i++) {
+        for (unsigned int j = 0; j < subdivision; j++) {
             UpdateVertexArray(i, j);
         }
     }
@@ -1480,9 +1464,6 @@ Terrain::Terrain()
 {
     size = 0;
 
-    memset(patchobjectnum, 0, sizeof(patchobjectnum));
-    memset(patchobjects, 0, sizeof(patchobjects));
-
     scale = 1.0f;
     type = 0;
     memset(heightmap, 0, sizeof(heightmap));
@@ -1505,25 +1486,4 @@ Terrain::Terrain()
     memset(heightypatch, 0, sizeof(heightypatch));
 
     patch_elements = 0;
-
-    memset(decaltexcoords, 0, sizeof(decaltexcoords));
-    memset(decalvertex, 0, sizeof(decalvertex));
-    memset(decaltype, 0, sizeof(decaltype));
-    memset(decalopacity, 0, sizeof(decalopacity));
-    memset(decalrotation, 0, sizeof(decalrotation));
-    memset(decalalivetime, 0, sizeof(decalalivetime));
-    memset(decalbrightness, 0, sizeof(decalbrightness));
-    memset(decalposition, 0, sizeof(decalposition));
-    numdecals = 0;
 }
-Terrain::~Terrain()
-{
-    terraintexture.destroy();
-    shadowtexture.destroy();
-    bodyprinttexture.destroy();
-    footprinttexture.destroy();
-    bloodtexture.destroy();
-    bloodtexture2.destroy();
-    breaktexture.destroy();
-}
-