X-Git-Url: https://git.jsancho.org/?a=blobdiff_plain;f=Source%2FGameTick.cpp;h=0690acd3da0158fe9c327fd74ba61d5017ea1fd9;hb=fa4037412902fd926281cd9b06d0f00db680138f;hp=3b47a602470a4f399824c5ff306466c70e55e66f;hpb=11fc7bb36280c27d231753a9b3b3e95210351144;p=lugaru.git

diff --git a/Source/GameTick.cpp b/Source/GameTick.cpp
index 3b47a60..0690acd 100644
--- a/Source/GameTick.cpp
+++ b/Source/GameTick.cpp
@@ -68,7 +68,6 @@ extern float screenwidth, screenheight;
 extern float gravity;
 extern int detail;
 extern float texdetail;
-extern Objects objects;
 extern int slomo;
 extern float slomodelay;
 extern bool floatjump;
@@ -318,8 +317,8 @@ static int findClosestObject()
     int closest = -1;
     float closestdist = std::numeric_limits<float>::max();
 
-    for (int i = 0; i < objects.numobjects; i++) {
-        float distance = distsq(&objects.position[i], &Person::players[0]->coords);
+    for (int i = 0; i < Object::objects.size(); i++) {
+        float distance = distsq(&Object::objects[i]->position, &Person::players[0]->coords);
         if (distance < closestdist) {
             closestdist = distance;
             closest = i;
@@ -419,78 +418,6 @@ int findPathDist(int start, int end)
     return smallestcount;
 }
 
-int Game::checkcollide(XYZ startpoint, XYZ endpoint)
-{
-    static XYZ colpoint, colviewer, coltarget;
-    static float minx, minz, maxx, maxz, miny, maxy;
-
-    minx = min(startpoint.x, endpoint.x) - 1;
-    miny = min(startpoint.y, endpoint.y) - 1;
-    minz = min(startpoint.z, endpoint.z) - 1;
-    maxx = max(startpoint.x, endpoint.x) + 1;
-    maxy = max(startpoint.y, endpoint.y) + 1;
-    maxz = max(startpoint.z, endpoint.z) + 1;
-
-    for (int i = 0; i < objects.numobjects; i++) {
-        if (     objects.position[i].x > minx - objects.model[i].boundingsphereradius &&
-                 objects.position[i].x < maxx + objects.model[i].boundingsphereradius &&
-                 objects.position[i].y > miny - objects.model[i].boundingsphereradius &&
-                 objects.position[i].y < maxy + objects.model[i].boundingsphereradius &&
-                 objects.position[i].z > minz - objects.model[i].boundingsphereradius &&
-                 objects.position[i].z < maxz + objects.model[i].boundingsphereradius) {
-            if (     objects.type[i] != treeleavestype &&
-                     objects.type[i] != bushtype &&
-                     objects.type[i] != firetype) {
-                colviewer = startpoint;
-                coltarget = endpoint;
-                if (objects.model[i].LineCheck(&colviewer, &coltarget, &colpoint, &objects.position[i], &objects.yaw[i]) != -1)
-                    return i;
-            }
-        }
-    }
-
-    return -1;
-}
-
-int Game::checkcollide(XYZ startpoint, XYZ endpoint, int what)
-{
-    static XYZ colpoint, colviewer, coltarget;
-    static float minx, minz, maxx, maxz, miny, maxy;
-    static int i; //FIXME: see below
-
-    minx = min(startpoint.x, endpoint.x) - 1;
-    miny = min(startpoint.y, endpoint.y) - 1;
-    minz = min(startpoint.z, endpoint.z) - 1;
-    maxx = max(startpoint.x, endpoint.x) + 1;
-    maxy = max(startpoint.y, endpoint.y) + 1;
-    maxz = max(startpoint.z, endpoint.z) + 1;
-
-    if (what != 1000) {
-        if (     objects.position[what].x > minx - objects.model[what].boundingsphereradius &&
-                 objects.position[what].x < maxx + objects.model[what].boundingsphereradius &&
-                 objects.position[what].y > miny - objects.model[what].boundingsphereradius &&
-                 objects.position[what].y < maxy + objects.model[what].boundingsphereradius &&
-                 objects.position[what].z > minz - objects.model[what].boundingsphereradius &&
-                 objects.position[what].z < maxz + objects.model[what].boundingsphereradius) {
-            if (     objects.type[what] != treeleavestype &&
-                     objects.type[what] != bushtype &&
-                     objects.type[what] != firetype) {
-                colviewer = startpoint;
-                coltarget = endpoint;
-                //FIXME: i/what
-                if (objects.model[what].LineCheck(&colviewer, &coltarget, &colpoint, &objects.position[what], &objects.yaw[what]) != -1)
-                    return i;
-            }
-        }
-    }
-
-    if (what == 1000)
-        if (terrain.lineTerrain(startpoint, endpoint, &colpoint) != -1)
-            return 1000;
-
-    return -1;
-}
-
 void Setenvironment(int which)
 {
     LOGFUNC;
@@ -513,10 +440,10 @@ void Setenvironment(int which)
         if (ambientsound)
             emit_stream_np(stream_wind);
 
-        objects.treetextureptr.load("Textures/SnowTree.png", 0);
-        objects.bushtextureptr.load("Textures/BushSnow.png", 0);
-        objects.rocktextureptr.load("Textures/BoulderSnow.jpg", 1);
-        objects.boxtextureptr.load("Textures/SnowBox.jpg", 1);
+        Object::treetextureptr.load("Textures/SnowTree.png", 0);
+        Object::bushtextureptr.load("Textures/BushSnow.png", 0);
+        Object::rocktextureptr.load("Textures/BoulderSnow.jpg", 1);
+        Object::boxtextureptr.load("Textures/SnowBox.jpg", 1);
 
         footstepsound = footstepsn1;
         footstepsound2 = footstepsn2;
@@ -544,10 +471,10 @@ void Setenvironment(int which)
     } else if (environment == desertenvironment) {
         windvector = 0;
         windvector.z = 2;
-        objects.treetextureptr.load("Textures/DesertTree.png", 0);
-        objects.bushtextureptr.load("Textures/BushDesert.png", 0);
-        objects.rocktextureptr.load("Textures/BoulderDesert.jpg", 1);
-        objects.boxtextureptr.load("Textures/DesertBox.jpg", 1);
+        Object::treetextureptr.load("Textures/DesertTree.png", 0);
+        Object::bushtextureptr.load("Textures/BushDesert.png", 0);
+        Object::rocktextureptr.load("Textures/BoulderDesert.jpg", 1);
+        Object::boxtextureptr.load("Textures/DesertBox.jpg", 1);
 
 
         if (ambientsound)
@@ -579,10 +506,10 @@ void Setenvironment(int which)
     } else if (environment == grassyenvironment) {
         windvector = 0;
         windvector.z = 2;
-        objects.treetextureptr.load("Textures/Tree.png", 0);
-        objects.bushtextureptr.load("Textures/Bush.png", 0);
-        objects.rocktextureptr.load("Textures/Boulder.jpg", 1);
-        objects.boxtextureptr.load("Textures/GrassBox.jpg", 1);
+        Object::treetextureptr.load("Textures/Tree.png", 0);
+        Object::bushtextureptr.load("Textures/Bush.png", 0);
+        Object::rocktextureptr.load("Textures/Boulder.jpg", 1);
+        Object::boxtextureptr.load("Textures/GrassBox.jpg", 1);
 
         if (ambientsound)
             emit_stream_np(stream_wind, 100.);
@@ -737,19 +664,12 @@ void Game::Loadlevel(const std::string& name)
     if (!stealthloading) {
         terrain.numdecals = 0;
         Sprite::deleteSprites();
-        for (int i = 0; i < objects.numobjects; i++)
-            objects.model[i].numdecals = 0;
-
-        int j = objects.numobjects;
-        for (int i = 0; i < j; i++) {
-            objects.DeleteObject(0);
-            if (visibleloading)
-                LoadingScreen();
-        }
 
-        for (int i = 0; i < subdivision; i++)
-            for (int j = 0; j < subdivision; j++)
+        for (int i = 0; i < subdivision; i++) {
+            for (int j = 0; j < subdivision; j++) {
                 terrain.patchobjectnum[i][j] = 0;
+            }
+        }
         if (visibleloading)
             LoadingScreen();
     }
@@ -844,12 +764,7 @@ void Game::Loadlevel(const std::string& name)
 
     funpackf(tfile, "Bi", &environment);
 
-    funpackf(tfile, "Bi", &objects.numobjects);
-    for (int i = 0; i < objects.numobjects; i++) {
-        funpackf(tfile, "Bi Bf Bf Bf Bf Bf Bf", &objects.type[i], &objects.yaw[i], &objects.pitch[i], &objects.position[i].x, &objects.position[i].y, &objects.position[i].z, &objects.scale[i]);
-        if (objects.type[i] == treeleavestype)
-            objects.scale[i] = objects.scale[i - 1];
-    }
+    Object::LoadObjectsFromFile(tfile, stealthloading);
 
     if (mapvers >= 7) {
         int numhotspots;
@@ -877,24 +792,12 @@ void Game::Loadlevel(const std::string& name)
         LoadingScreen();
 
     if (!stealthloading) {
-        objects.center = 0;
-        for (int i = 0; i < objects.numobjects; i++)
-            objects.center += objects.position[i];
-        objects.center /= objects.numobjects;
-
+        Object::ComputeCenter();
 
         if (visibleloading)
             LoadingScreen();
 
-        float maxdistance = 0;
-        float tempdist;
-        for (int i = 0; i < objects.numobjects; i++) {
-            tempdist = distsq(&objects.center, &objects.position[i]);
-            if (tempdist > maxdistance) {
-                maxdistance = tempdist;
-            }
-        }
-        objects.radius = fast_sqrt(maxdistance);
+        Object::ComputeRadius();
     }
 
     if (visibleloading)
@@ -937,18 +840,11 @@ void Game::Loadlevel(const std::string& name)
     oldenvironment = environment;
 
     if (!stealthloading) {
-        int j = objects.numobjects;
-        objects.numobjects = 0;
-        for (int i = 0; i < j; i++) {
-            objects.MakeObject(objects.type[i], objects.position[i], objects.yaw[i], objects.pitch[i], objects.scale[i]);
-            if (visibleloading)
-                LoadingScreen();
-        }
-
+        Object::AddObjectsToTerrain();
         terrain.DoShadows();
         if (visibleloading)
             LoadingScreen();
-        objects.DoShadows();
+        Object::DoShadows();
         if (visibleloading)
             LoadingScreen();
     }
@@ -1681,9 +1577,9 @@ void doDevKeys()
 
         /* Grow tree leaves?? */
         if (Input::isKeyPressed(SDL_SCANCODE_Y)) {
-            for (int i = 0; i < objects.numobjects; i++) {
-                if (objects.type[i] == treeleavestype) {
-                    objects.scale[i] *= .9;
+            for (int i = 0; i < Object::objects.size(); i++) {
+                if (Object::objects[i]->type == treeleavestype) {
+                    Object::objects[i]->scale *= .9;
                 }
             }
         }
@@ -2024,12 +1920,13 @@ void doDevKeys()
 
         if (Input::isKeyPressed(SDL_SCANCODE_DELETE) && Input::isKeyDown(SDL_SCANCODE_LCTRL)) {
             int closest = findClosestObject();
-            if (closest >= 0)
-                objects.position[closest].y -= 500;
+            if (closest >= 0) {
+                Object::objects[closest]->position.y -= 500;
+            }
         }
 
         if (Input::isKeyPressed(SDL_SCANCODE_M) && Input::isKeyDown(SDL_SCANCODE_LSHIFT)) {
-            if (objects.numobjects < max_objects - 1) {
+            if (Object::objects.size() < max_objects - 1) {
                 XYZ scenecoords;
                 scenecoords.x = Person::players[0]->coords.x;
                 scenecoords.z = Person::players[0]->coords.z;
@@ -2038,7 +1935,6 @@ void doDevKeys()
                     scenecoords.y = Person::players[0]->coords.y - .5;
                 if (editortype == firetype)
                     scenecoords.y = Person::players[0]->coords.y - .5;
-                //objects.MakeObject(abs(Random()%3),scenecoords,Random()%360);
                 float temprotat, temprotat2;
                 temprotat = editoryaw;
                 temprotat2 = editorpitch;
@@ -2047,9 +1943,9 @@ void doDevKeys()
                 if (temprotat2 < 0)
                     temprotat2 = Random() % 360;
 
-                objects.MakeObject(editortype, scenecoords, (int)temprotat - ((int)temprotat) % 30, (int)temprotat2, editorsize);
+                Object::MakeObject(editortype, scenecoords, (int)temprotat - ((int)temprotat) % 30, (int)temprotat2, editorsize);
                 if (editortype == treetrunktype)
-                    objects.MakeObject(treeleavestype, scenecoords, Random() % 360 * (temprotat2 < 2) + (int)editoryaw - ((int)editoryaw) % 30, editorpitch, editorsize);
+                    Object::MakeObject(treeleavestype, scenecoords, Random() % 360 * (temprotat2 < 2) + (int)editoryaw - ((int)editoryaw) % 30, editorpitch, editorsize);
             }
         }
 
@@ -2194,11 +2090,13 @@ void doDevKeys()
             if (pathpointselected >= numpathpoints)
                 pathpointselected = -1;
         }
+
         if (Input::isKeyPressed(SDL_SCANCODE_COMMA) && !Input::isKeyDown(SDL_SCANCODE_LSHIFT)) {
             pathpointselected--;
             if (pathpointselected <= -2)
                 pathpointselected = numpathpoints - 1;
         }
+
         if (Input::isKeyPressed(SDL_SCANCODE_COMMA) && Input::isKeyDown(SDL_SCANCODE_LSHIFT)) {
             if (pathpointselected != -1) {
                 numpathpoints--;
@@ -2266,6 +2164,7 @@ void doDevKeys()
         if (Input::isKeyPressed(SDL_SCANCODE_RIGHT) && Input::isKeyDown(SDL_SCANCODE_LSHIFT) && Input::isKeyDown(SDL_SCANCODE_LCTRL)) {
             mapradius += multiplier * 10;
         }
+
         if (Input::isKeyDown(SDL_SCANCODE_UP) && Input::isKeyDown(SDL_SCANCODE_LCTRL)) {
             editorpitch += multiplier * 100;
         }
@@ -2275,10 +2174,12 @@ void doDevKeys()
             if (editorpitch < -.01)
                 editorpitch = -.01;
         }
-        if (Input::isKeyPressed(SDL_SCANCODE_DELETE) && objects.numobjects && Input::isKeyDown(SDL_SCANCODE_LSHIFT)) {
+
+        if (Input::isKeyPressed(SDL_SCANCODE_DELETE) && Object::objects.size() && Input::isKeyDown(SDL_SCANCODE_LSHIFT)) {
             int closest = findClosestObject();
-            if (closest >= 0)
-                objects.DeleteObject(closest);
+            if (closest >= 0) {
+                Object::DeleteObject(closest);
+            }
         }
     }
 }
@@ -2445,9 +2346,9 @@ void doAerialAcrobatics()
 
             for (int l = 0; l < terrain.patchobjectnum[Person::players[k]->whichpatchx][Person::players[k]->whichpatchz]; l++) {
                 int i = terrain.patchobjects[Person::players[k]->whichpatchx][Person::players[k]->whichpatchz][l];
-                if (objects.type[i] != rocktype ||
-                        objects.scale[i] > .5 && Person::players[k]->aitype == playercontrolled ||
-                        objects.position[i].y > Person::players[k]->coords.y) {
+                if (Object::objects[i]->type != rocktype ||
+                        Object::objects[i]->scale > .5 && Person::players[k]->aitype == playercontrolled ||
+                        Object::objects[i]->position.y > Person::players[k]->coords.y) {
                     lowpoint = Person::players[k]->coords;
                     if (Person::players[k]->animTarget != jumpupanim &&
                             Person::players[k]->animTarget != jumpdownanim &&
@@ -2458,7 +2359,7 @@ void doAerialAcrobatics()
                     if (     Person::players[k]->coords.y < terrain.getHeight(Person::players[k]->coords.x, Person::players[k]->coords.z) &&
                              Person::players[k]->coords.y > terrain.getHeight(Person::players[k]->coords.x, Person::players[k]->coords.z) - .1)
                         Person::players[k]->coords.y = terrain.getHeight(Person::players[k]->coords.x, Person::players[k]->coords.z);
-                    if (Person::players[k]->SphereCheck(&lowpoint, 1.3, &colpoint, &objects.position[i], &objects.yaw[i], &objects.model[i]) != -1) {
+                    if (Person::players[k]->SphereCheck(&lowpoint, 1.3, &colpoint, &Object::objects[i]->position, &Object::objects[i]->yaw, &Object::objects[i]->model) != -1) {
                         flatfacing = lowpoint - Person::players[k]->coords;
                         Person::players[k]->coords = lowpoint;
                         Person::players[k]->coords.y -= 1.3;
@@ -2474,14 +2375,14 @@ void doAerialAcrobatics()
                                 Person::players[k]->jumpkeydown) {
                             lowpointtarget = lowpoint + DoRotation(Person::players[k]->facing, 0, -90, 0) * 1.5;
                             XYZ tempcoords1 = lowpoint;
-                            whichhit = objects.model[i].LineCheck(&lowpoint, &lowpointtarget, &colpoint, &objects.position[i], &objects.yaw[i]);
-                            if (whichhit != -1 && fabs(objects.model[i].facenormals[whichhit].y) < .3) {
+                            whichhit = Object::objects[i]->model.LineCheck(&lowpoint, &lowpointtarget, &colpoint, &Object::objects[i]->position, &Object::objects[i]->yaw);
+                            if (whichhit != -1 && fabs(Object::objects[i]->model.facenormals[whichhit].y) < .3) {
                                 Person::players[k]->setAnimation(walljumpleftanim);
                                 emit_sound_at(movewhooshsound, Person::players[k]->coords);
                                 if (k == 0)
                                     pause_sound(whooshsound);
 
-                                lowpointtarget = DoRotation(objects.model[i].facenormals[whichhit], 0, objects.yaw[i], 0);
+                                lowpointtarget = DoRotation(Object::objects[i]->model.facenormals[whichhit], 0, Object::objects[i]->yaw, 0);
                                 Person::players[k]->yaw = -asin(0 - lowpointtarget.x) * 180 / M_PI;
                                 if (lowpointtarget.z < 0)
                                     Person::players[k]->yaw = 180 - Person::players[k]->yaw;
@@ -2492,14 +2393,14 @@ void doAerialAcrobatics()
                             } else {
                                 lowpoint = tempcoords1;
                                 lowpointtarget = lowpoint + DoRotation(Person::players[k]->facing, 0, 90, 0) * 1.5;
-                                whichhit = objects.model[i].LineCheck(&lowpoint, &lowpointtarget, &colpoint, &objects.position[i], &objects.yaw[i]);
-                                if (whichhit != -1 && fabs(objects.model[i].facenormals[whichhit].y) < .3) {
+                                whichhit = Object::objects[i]->model.LineCheck(&lowpoint, &lowpointtarget, &colpoint, &Object::objects[i]->position, &Object::objects[i]->yaw);
+                                if (whichhit != -1 && fabs(Object::objects[i]->model.facenormals[whichhit].y) < .3) {
                                     Person::players[k]->setAnimation(walljumprightanim);
                                     emit_sound_at(movewhooshsound, Person::players[k]->coords);
                                     if (k == 0)
                                         pause_sound(whooshsound);
 
-                                    lowpointtarget = DoRotation(objects.model[i].facenormals[whichhit], 0, objects.yaw[i], 0);
+                                    lowpointtarget = DoRotation(Object::objects[i]->model.facenormals[whichhit], 0, Object::objects[i]->yaw, 0);
                                     Person::players[k]->yaw = -asin(0 - lowpointtarget.x) * 180 / M_PI;
                                     if (lowpointtarget.z < 0)
                                         Person::players[k]->yaw = 180 - Person::players[k]->yaw;
@@ -2510,14 +2411,14 @@ void doAerialAcrobatics()
                                 } else {
                                     lowpoint = tempcoords1;
                                     lowpointtarget = lowpoint + Person::players[k]->facing * 2;
-                                    whichhit = objects.model[i].LineCheck(&lowpoint, &lowpointtarget, &colpoint, &objects.position[i], &objects.yaw[i]);
-                                    if (whichhit != -1 && fabs(objects.model[i].facenormals[whichhit].y) < .3) {
+                                    whichhit = Object::objects[i]->model.LineCheck(&lowpoint, &lowpointtarget, &colpoint, &Object::objects[i]->position, &Object::objects[i]->yaw);
+                                    if (whichhit != -1 && fabs(Object::objects[i]->model.facenormals[whichhit].y) < .3) {
                                         Person::players[k]->setAnimation(walljumpbackanim);
                                         emit_sound_at(movewhooshsound, Person::players[k]->coords);
                                         if (k == 0)
                                             pause_sound(whooshsound);
 
-                                        lowpointtarget = DoRotation(objects.model[i].facenormals[whichhit], 0, objects.yaw[i], 0);
+                                        lowpointtarget = DoRotation(Object::objects[i]->model.facenormals[whichhit], 0, Object::objects[i]->yaw, 0);
                                         Person::players[k]->yaw = -asin(0 - lowpointtarget.x) * 180 / M_PI;
                                         if (lowpointtarget.z < 0)
                                             Person::players[k]->yaw = 180 - Person::players[k]->yaw;
@@ -2528,14 +2429,14 @@ void doAerialAcrobatics()
                                     } else {
                                         lowpoint = tempcoords1;
                                         lowpointtarget = lowpoint - Person::players[k]->facing * 2;
-                                        whichhit = objects.model[i].LineCheck(&lowpoint, &lowpointtarget, &colpoint, &objects.position[i], &objects.yaw[i]);
-                                        if (whichhit != -1 && fabs(objects.model[i].facenormals[whichhit].y) < .3) {
+                                        whichhit = Object::objects[i]->model.LineCheck(&lowpoint, &lowpointtarget, &colpoint, &Object::objects[i]->position, &Object::objects[i]->yaw);
+                                        if (whichhit != -1 && fabs(Object::objects[i]->model.facenormals[whichhit].y) < .3) {
                                             Person::players[k]->setAnimation(walljumpfrontanim);
                                             emit_sound_at(movewhooshsound, Person::players[k]->coords);
                                             if (k == 0)
                                                 pause_sound(whooshsound);
 
-                                            lowpointtarget = DoRotation(objects.model[i].facenormals[whichhit], 0, objects.yaw[i], 0);
+                                            lowpointtarget = DoRotation(Object::objects[i]->model.facenormals[whichhit], 0, Object::objects[i]->yaw, 0);
                                             Person::players[k]->yaw = -asin(0 - lowpointtarget.x) * 180 / M_PI;
                                             if (lowpointtarget.z < 0)
                                                 Person::players[k]->yaw = 180 - Person::players[k]->yaw;
@@ -2550,11 +2451,11 @@ void doAerialAcrobatics()
                             }
                         }
                     }
-                } else if (objects.type[i] == rocktype) {
+                } else if (Object::objects[i]->type == rocktype) {
                     lowpoint2 = Person::players[k]->coords;
                     lowpoint = Person::players[k]->coords;
                     lowpoint.y += 2;
-                    if (objects.model[i].LineCheck(&lowpoint, &lowpoint2, &colpoint, &objects.position[i], &objects.yaw[i]) != -1) {
+                    if (Object::objects[i]->model.LineCheck(&lowpoint, &lowpoint2, &colpoint, &Object::objects[i]->position, &Object::objects[i]->yaw) != -1) {
                         Person::players[k]->coords = colpoint;
                         Person::players[k]->collide = 1;
                         tempcollide = 1;
@@ -2597,8 +2498,8 @@ void doAerialAcrobatics()
                     int i = terrain.patchobjects[Person::players[k]->whichpatchx][Person::players[k]->whichpatchz][l];
                     lowpoint = Person::players[k]->coords;
                     lowpoint.y += 1.35;
-                    if (objects.type[i] != rocktype)
-                        if (Person::players[k]->SphereCheck(&lowpoint, 1.33, &colpoint, &objects.position[i], &objects.yaw[i], &objects.model[i]) != -1) {
+                    if (Object::objects[i]->type != rocktype)
+                        if (Person::players[k]->SphereCheck(&lowpoint, 1.33, &colpoint, &Object::objects[i]->position, &Object::objects[i]->yaw, &Object::objects[i]->model) != -1) {
                             if (Person::players[k]->animTarget != jumpupanim &&
                                     Person::players[k]->animTarget != jumpdownanim &&
                                     Person::players[k]->onterrain)
@@ -2614,14 +2515,14 @@ void doAerialAcrobatics()
                                      Person::players[k]->animTarget == jumpupanim ||
                                      Person::players[k]->animTarget == jumpdownanim)) {
                                 lowpoint = Person::players[k]->coords;
-                                objects.model[i].SphereCheckPossible(&lowpoint, 1.5, &objects.position[i], &objects.yaw[i]);
+                                Object::objects[i]->model.SphereCheckPossible(&lowpoint, 1.5, &Object::objects[i]->position, &Object::objects[i]->yaw);
                                 lowpoint = Person::players[k]->coords;
                                 lowpoint.y += .05;
                                 facing = 0;
                                 facing.z = -1;
                                 facing = DoRotation(facing, 0, Person::players[k]->targetyaw + 180, 0);
                                 lowpointtarget = lowpoint + facing * 1.4;
-                                whichhit = objects.model[i].LineCheckPossible(&lowpoint, &lowpointtarget, &colpoint, &objects.position[i], &objects.yaw[i]);
+                                whichhit = Object::objects[i]->model.LineCheckPossible(&lowpoint, &lowpointtarget, &colpoint, &Object::objects[i]->position, &Object::objects[i]->yaw);
                                 if (whichhit != -1) {
                                     lowpoint = Person::players[k]->coords;
                                     lowpoint.y += .1;
@@ -2650,27 +2551,27 @@ void doAerialAcrobatics()
                                     lowpointtarget6.y += 45 / 13;
                                     lowpointtarget6 += facing * .6;
                                     lowpointtarget7.y += 90 / 13;
-                                    whichhit = objects.model[i].LineCheckPossible(&lowpoint, &lowpointtarget, &colpoint, &objects.position[i], &objects.yaw[i]);
-                                    if (objects.friction[i] > .5)
+                                    whichhit = Object::objects[i]->model.LineCheckPossible(&lowpoint, &lowpointtarget, &colpoint, &Object::objects[i]->position, &Object::objects[i]->yaw);
+                                    if (Object::objects[i]->friction > .5)
                                         if (whichhit != -1) {
                                             if (whichhit != -1 && Person::players[k]->animTarget != jumpupanim && Person::players[k]->animTarget != jumpdownanim)
                                                 Person::players[k]->collided = 1;
-                                            if (checkcollide(lowpoint7, lowpointtarget7) == -1)
-                                                if (checkcollide(lowpoint6, lowpointtarget6) == -1)
-                                                    if (     objects.model[i].LineCheckPossible(&lowpoint2, &lowpointtarget2,
-                                                             &colpoint, &objects.position[i], &objects.yaw[i]) != -1 &&
-                                                             objects.model[i].LineCheckPossible(&lowpoint3, &lowpointtarget3,
-                                                                     &colpoint, &objects.position[i], &objects.yaw[i]) != -1 &&
-                                                             objects.model[i].LineCheckPossible(&lowpoint4, &lowpointtarget4,
-                                                                     &colpoint, &objects.position[i], &objects.yaw[i]) != -1 &&
-                                                             objects.model[i].LineCheckPossible(&lowpoint5, &lowpointtarget5,
-                                                                     &colpoint, &objects.position[i], &objects.yaw[i]) != -1)
+                                            if (Object::checkcollide(lowpoint7, lowpointtarget7) == -1)
+                                                if (Object::checkcollide(lowpoint6, lowpointtarget6) == -1)
+                                                    if (     Object::objects[i]->model.LineCheckPossible(&lowpoint2, &lowpointtarget2,
+                                                             &colpoint, &Object::objects[i]->position, &Object::objects[i]->yaw) != -1 &&
+                                                             Object::objects[i]->model.LineCheckPossible(&lowpoint3, &lowpointtarget3,
+                                                                     &colpoint, &Object::objects[i]->position, &Object::objects[i]->yaw) != -1 &&
+                                                             Object::objects[i]->model.LineCheckPossible(&lowpoint4, &lowpointtarget4,
+                                                                     &colpoint, &Object::objects[i]->position, &Object::objects[i]->yaw) != -1 &&
+                                                             Object::objects[i]->model.LineCheckPossible(&lowpoint5, &lowpointtarget5,
+                                                                     &colpoint, &Object::objects[i]->position, &Object::objects[i]->yaw) != -1)
                                                         for (int j = 0; j < 45; j++) {
                                                             lowpoint = Person::players[k]->coords;
                                                             lowpoint.y += (float)j / 13;
                                                             lowpointtarget = lowpoint + facing * 1.4;
-                                                            if (objects.model[i].LineCheckPossible(&lowpoint, &lowpointtarget,
-                                                                                                   &colpoint2, &objects.position[i], &objects.yaw[i]) == -1) {
+                                                            if (Object::objects[i]->model.LineCheckPossible(&lowpoint, &lowpointtarget,
+                                                                                                   &colpoint2, &Object::objects[i]->position, &Object::objects[i]->yaw) == -1) {
                                                                 if (j <= 6 || j <= 25 && Person::players[k]->animTarget == jumpdownanim)
                                                                     break;
                                                                 if (Person::players[k]->animTarget == jumpupanim || Person::players[k]->animTarget == jumpdownanim) {
@@ -2678,7 +2579,7 @@ void doAerialAcrobatics()
                                                                     lowpoint.y += (float)j / 13;
                                                                     lowpointtarget = lowpoint + facing * 1.3;
                                                                     flatfacing = Person::players[k]->coords;
-                                                                    Person::players[k]->coords = colpoint - DoRotation(objects.model[i].facenormals[whichhit], 0, objects.yaw[k], 0) * .01;
+                                                                    Person::players[k]->coords = colpoint - DoRotation(Object::objects[i]->model.facenormals[whichhit], 0, Object::objects[k]->yaw, 0) * .01;
                                                                     Person::players[k]->coords.y = lowpointtarget.y - .07;
                                                                     Person::players[k]->currentoffset = (flatfacing - Person::players[k]->coords) / Person::players[k]->scale;
 
@@ -2689,7 +2590,7 @@ void doAerialAcrobatics()
                                                                         }
                                                                         emit_sound_at(jumpsound, Person::players[k]->coords, 128.);
 
-                                                                        lowpointtarget = DoRotation(objects.model[i].facenormals[whichhit], 0, objects.yaw[i], 0);
+                                                                        lowpointtarget = DoRotation(Object::objects[i]->model.facenormals[whichhit], 0, Object::objects[i]->yaw, 0);
                                                                         Person::players[k]->yaw = -asin(0 - lowpointtarget.x) * 180 / M_PI;
                                                                         if (lowpointtarget.z < 0)
                                                                             Person::players[k]->yaw = 180 - Person::players[k]->yaw;
@@ -3164,13 +3065,13 @@ void doAttacks()
                                                             terrain.decalalivetime[j] < 2)
                                                         terrain.DeleteDecal(j);
                                                 }
-                                                for (int l = 0; l < objects.numobjects; l++) {
-                                                    if (objects.model[l].type == decalstype)
-                                                        for (int j = 0; j < objects.model[l].numdecals; j++) {
-                                                            if ((objects.model[l].decaltype[j] == blooddecal ||
-                                                                    objects.model[l].decaltype[j] == blooddecalslow) &&
-                                                                    objects.model[l].decalalivetime[j] < 2)
-                                                                objects.model[l].DeleteDecal(j);
+                                                for (int l = 0; l < Object::objects.size(); l++) {
+                                                    if (Object::objects[l]->model.type == decalstype)
+                                                        for (int j = 0; j < Object::objects[l]->model.numdecals; j++) {
+                                                            if ((Object::objects[l]->model.decaltype[j] == blooddecal ||
+                                                                    Object::objects[l]->model.decaltype[j] == blooddecalslow) &&
+                                                                    Object::objects[l]->model.decalalivetime[j] < 2)
+                                                                Object::objects[l]->model.DeleteDecal(j);
                                                         }
                                                 }
                                             }
@@ -3190,13 +3091,13 @@ void doAttacks()
                                                             terrain.DeleteDecal(j);
                                                         }
                                                     }
-                                                    for (int l = 0; l < objects.numobjects; l++) {
-                                                        if (objects.model[l].type == decalstype)
-                                                            for (int j = 0; j < objects.model[l].numdecals; j++) {
-                                                                if ((objects.model[l].decaltype[j] == blooddecal ||
-                                                                        objects.model[l].decaltype[j] == blooddecalslow) &&
-                                                                        objects.model[l].decalalivetime[j] < 2) {
-                                                                    objects.model[l].DeleteDecal(j);
+                                                    for (int l = 0; l < Object::objects.size(); l++) {
+                                                        if (Object::objects[l]->model.type == decalstype)
+                                                            for (int j = 0; j < Object::objects[l]->model.numdecals; j++) {
+                                                                if ((Object::objects[l]->model.decaltype[j] == blooddecal ||
+                                                                        Object::objects[l]->model.decaltype[j] == blooddecalslow) &&
+                                                                        Object::objects[l]->model.decalalivetime[j] < 2) {
+                                                                    Object::objects[l]->model.DeleteDecal(j);
                                                                 }
                                                             }
                                                     }
@@ -3674,7 +3575,7 @@ void doAI(unsigned i)
                                 if (distsq(&Person::players[i]->coords, &Person::players[j]->coords) < 400)
                                     if (normaldotproduct(Person::players[i]->facing, Person::players[j]->coords - Person::players[i]->coords) > 0)
                                         if (Person::players[j]->coords.y < Person::players[i]->coords.y + 5 || Person::players[j]->onterrain)
-                                            if (!Person::players[j]->isWallJump() && -1 == checkcollide(
+                                            if (!Person::players[j]->isWallJump() && -1 == Object::checkcollide(
                                                         DoRotation(Person::players[i]->jointPos(head), 0, Person::players[i]->yaw, 0)
                                                         *Person::players[i]->scale + Person::players[i]->coords,
                                                         DoRotation(Person::players[j]->jointPos(head), 0, Person::players[j]->yaw, 0)
@@ -3817,7 +3718,7 @@ void doAI(unsigned i)
                             if (abs(Random() % 2) || Animation::animations[Person::players[j]->animTarget].height != lowheight || j != 0)
                                 if (distsq(&Person::players[i]->coords, &Person::players[j]->coords) < 400)
                                     if (normaldotproduct(Person::players[i]->facing, Person::players[j]->coords - Person::players[i]->coords) > 0)
-                                        if ((-1 == checkcollide(
+                                        if ((-1 == Object::checkcollide(
                                                     DoRotation(Person::players[i]->jointPos(head), 0, Person::players[i]->yaw, 0)*
                                                     Person::players[i]->scale + Person::players[i]->coords,
                                                     DoRotation(Person::players[j]->jointPos(head), 0, Person::players[j]->yaw, 0)*
@@ -3870,9 +3771,9 @@ void doAI(unsigned i)
                     test2.y += 5;
                     XYZ test = Person::players[i]->coords + Person::players[i]->facing;
                     test.y -= 10;
-                    j = checkcollide(test2, test, Person::players[i]->laststanding);
+                    j = Object::checkcollide(test2, test, Person::players[i]->laststanding);
                     if (j == -1)
-                        j = checkcollide(test2, test);
+                        j = Object::checkcollide(test2, test);
                     if (j == -1) {
                         Person::players[i]->velocity = 0;
                         Person::players[i]->setAnimation(Person::players[i]->getStop());
@@ -3956,7 +3857,7 @@ void doAI(unsigned i)
                     //TODO: factor out canSeePlayer()
                     if (distsq(&Person::players[i]->coords, &Person::players[0]->coords) < 400)
                         if (normaldotproduct(Person::players[i]->facing, Person::players[0]->coords - Person::players[i]->coords) > 0)
-                            if ((checkcollide(
+                            if ((Object::checkcollide(
                                         DoRotation(Person::players[i]->jointPos(head), 0, Person::players[i]->yaw, 0)*
                                         Person::players[i]->scale + Person::players[i]->coords,
                                         DoRotation(Person::players[0]->jointPos(head), 0, Person::players[0]->yaw, 0)*
@@ -4030,7 +3931,7 @@ void doAI(unsigned i)
                 XYZ flatfacing = Person::players[Person::players[i]->ally]->coords;
                 facing.y += Person::players[i]->jointPos(head).y * Person::players[i]->scale;
                 flatfacing.y += Person::players[Person::players[i]->ally]->jointPos(head).y * Person::players[Person::players[i]->ally]->scale;
-                if (-1 != checkcollide(facing, flatfacing))
+                if (-1 != Object::checkcollide(facing, flatfacing))
                     Person::players[i]->lastseentime -= .1;
 
                 //no available ally, run back to player
@@ -4247,9 +4148,9 @@ void doAI(unsigned i)
                     test2.y += 5;
                     XYZ test = Person::players[i]->coords + Person::players[i]->facing;
                     test.y -= 10;
-                    j = checkcollide(test2, test, Person::players[i]->laststanding);
+                    j = Object::checkcollide(test2, test, Person::players[i]->laststanding);
                     if (j == -1)
-                        j = checkcollide(test2, test);
+                        j = Object::checkcollide(test2, test);
                     if (j == -1) {
                         Person::players[i]->velocity = 0;
                         Person::players[i]->setAnimation(Person::players[i]->getStop());
@@ -4415,7 +4316,7 @@ void doAI(unsigned i)
                 facing.y += Person::players[i]->jointPos(head).y * Person::players[i]->scale;
                 flatfacing.y += Person::players[0]->jointPos(head).y * Person::players[0]->scale;
                 if (Person::players[i]->occluded >= 2)
-                    if (-1 != checkcollide(facing, flatfacing)) {
+                    if (-1 != Object::checkcollide(facing, flatfacing)) {
                         if (!Person::players[i]->pause)
                             Person::players[i]->lastseentime -= .2;
                         if (Person::players[i]->lastseentime <= 0 &&
@@ -4436,7 +4337,7 @@ void doAI(unsigned i)
             if (Person::players[0]->coords.y > terrain.getHeight(Person::players[0]->coords.x, Person::players[0]->coords.z) + 10) {
                 XYZ test = Person::players[0]->coords;
                 test.y -= 40;
-                if (-1 == checkcollide(Person::players[0]->coords, test))
+                if (-1 == Object::checkcollide(Person::players[0]->coords, test))
                     Person::players[i]->stunned = 1;
             }
         //stunned
@@ -5084,17 +4985,17 @@ void Game::Tick()
                     Person::players[i]->avoidsomething = 0;
 
                     //avoid flaming things
-                    for (int j = 0; j < objects.numobjects; j++)
-                        if (objects.onfire[j])
-                            if (distsq(&Person::players[i]->coords, &objects.position[j]) < sq(objects.scale[j]) * 200)
-                                if (     distsq(&Person::players[i]->coords, &objects.position[j]) <
+                    for (int j = 0; j < Object::objects.size(); j++)
+                        if (Object::objects[j]->onfire)
+                            if (distsq(&Person::players[i]->coords, &Object::objects[j]->position) < sq(Object::objects[j]->scale) * 200)
+                                if (     distsq(&Person::players[i]->coords, &Object::objects[j]->position) <
                                          distsq(&Person::players[i]->coords, &Person::players[0]->coords)) {
                                     Person::players[i]->collided = 0;
                                     Person::players[i]->avoidcollided = 1;
                                     if (Person::players[i]->avoidsomething == 0 ||
-                                            distsq(&Person::players[i]->coords, &objects.position[j]) <
+                                            distsq(&Person::players[i]->coords, &Object::objects[j]->position) <
                                             distsq(&Person::players[i]->coords, &Person::players[i]->avoidwhere)) {
-                                        Person::players[i]->avoidwhere = objects.position[j];
+                                        Person::players[i]->avoidwhere = Object::objects[j]->position;
                                         Person::players[i]->avoidsomething = 1;
                                     }
                                 }
@@ -5364,7 +5265,7 @@ void Game::Tick()
                                                                 distsq(&Person::players[i]->coords, &Person::players[j]->coords) < 100 &&
                                                                 distsq(&Person::players[i]->coords, &Person::players[j]->coords) > 1.5 &&
                                                                 !Person::players[j]->skeleton.free &&
-                                                                -1 == checkcollide(DoRotation(Person::players[j]->jointPos(head), 0, Person::players[j]->yaw, 0)*Person::players[j]->scale + Person::players[j]->coords, DoRotation(Person::players[i]->jointPos(head), 0, Person::players[i]->yaw, 0)*Person::players[i]->scale + Person::players[i]->coords)) {
+                                                                -1 == Object::checkcollide(DoRotation(Person::players[j]->jointPos(head), 0, Person::players[j]->yaw, 0)*Person::players[j]->scale + Person::players[j]->coords, DoRotation(Person::players[i]->jointPos(head), 0, Person::players[i]->yaw, 0)*Person::players[i]->scale + Person::players[i]->coords)) {
                                                             if (!Person::players[i]->isFlip()) {
                                                                 Person::players[i]->throwtogglekeydown = 1;
                                                                 Person::players[i]->victim = Person::players[j];
@@ -5876,7 +5777,7 @@ void Game::Tick()
             }
 
             //do stuff
-            objects.DoStuff();
+            Object::DoStuff();
 
             for (int j = numenvsounds - 1; j >= 0; j--) {
                 envsoundlife[j] -= multiplier;
@@ -6388,20 +6289,20 @@ void Game::TickOnceAfter()
             viewer = cameraloc - facing * cameradist;
             colviewer = viewer;
             coltarget = cameraloc;
-            objects.SphereCheckPossible(&colviewer, findDistance(&colviewer, &coltarget));
+            Object::SphereCheckPossible(&colviewer, findDistance(&colviewer, &coltarget));
             if (terrain.patchobjectnum[Person::players[0]->whichpatchx][Person::players[0]->whichpatchz])
                 for (int j = 0; j < terrain.patchobjectnum[Person::players[0]->whichpatchx][Person::players[0]->whichpatchz]; j++) {
                     int i = terrain.patchobjects[Person::players[0]->whichpatchx][Person::players[0]->whichpatchz][j];
                     colviewer = viewer;
                     coltarget = cameraloc;
-                    if (objects.model[i].LineCheckPossible(&colviewer, &coltarget, &col, &objects.position[i], &objects.yaw[i]) != -1)
+                    if (Object::objects[i]->model.LineCheckPossible(&colviewer, &coltarget, &col, &Object::objects[i]->position, &Object::objects[i]->yaw) != -1)
                         viewer = col;
                 }
             if (terrain.patchobjectnum[Person::players[0]->whichpatchx][Person::players[0]->whichpatchz])
                 for (int j = 0; j < terrain.patchobjectnum[Person::players[0]->whichpatchx][Person::players[0]->whichpatchz]; j++) {
                     int i = terrain.patchobjects[Person::players[0]->whichpatchx][Person::players[0]->whichpatchz][j];
                     colviewer = viewer;
-                    if (objects.model[i].SphereCheck(&colviewer, .15, &col, &objects.position[i], &objects.yaw[i]) != -1) {
+                    if (Object::objects[i]->model.SphereCheck(&colviewer, .15, &col, &Object::objects[i]->position, &Object::objects[i]->yaw) != -1) {
                         viewer = colviewer;
                     }
                 }