World now also service

include/Game.h

 #ifndef _GAME_H_
 #define _GAME_H_
 
-#include <list>
+#include <vector>
 
 #include "Camera.h"
 #include "global.h"
 #include "TombRaider.h"
 #include "World.h"
 
-typedef enum {
-    Flag_DebugModel = (1 << 0)
-} GameFlags;
-
 /*!
  * \brief Game abstraction
  */
     int command(std::vector<char *> *args);
 
     //! \fixme should be private
-    World mWorld;
     entity_t *mLara;
     Render *mRender;
     Camera *mCamera;
 
     bool mLoaded;
     char *mName;
-    unsigned int mFlags;
     TombRaider mTombRaider;
 
     unsigned int mTextureStart;

include/OpenRaider.h

 
     int command(const char *command);
 
-    int initialize();
-
     void run();
 
     void handleKeyboard(KeyboardButton key, bool pressed);

include/main.h

 /*!
  * \file include/main.h
- * \brief Where main() is
+ * \brief Service locator
  *
  * \author xythobuz
  */
 #include "OpenRaider.h"
 #include "Sound.h"
 #include "Window.h"
+#include "World.h"
+
+Console &getConsole();
+
+Game &getGame();
+
+Menu &getMenu();
 
-Console    &getConsole();
-Game       &getGame();
-Menu       &getMenu();
 OpenRaider &getOpenRaider();
-Sound      &getSound();
-Window     &getWindow();
+
+Sound &getSound();
+
+Window &getWindow();
+
+World &getWorld();
 
 /*!
  * \brief Program entry point

src/Game.cpp

 
 #include <algorithm>
 #include <map>
-#include <vector>
 #include <cstdlib>
 
 #include "main.h"
     mLoaded = false;
     mName = NULL;
     mLara = NULL;
-    mFlags = 0;
 
     mTextureStart = 0;
     mTextureLevelOffset = 0;
     mRender->setMode(Render::modeLoadScreen);
 
     // Enable World Hopping
-    mWorld.setFlag(World::fEnableHopping);
+    getWorld().setFlag(World::fEnableHopping);
 
     return 0;
 }
     mLoaded = false;
     mRender->setMode(Render::modeDisabled);
 
-    mWorld.destroy();
+    getWorld().destroy();
     mRender->ClearWorld();
     getSound().clear(); // Remove all previously loaded sounds
 }
 void Game::handleAction(ActionEvents action, bool isFinished) {
     if (mLoaded) {
         if (action == forwardAction) {
-            mWorld.moveEntity(mLara, 'f');
+            getWorld().moveEntity(mLara, 'f');
         } else if (action == backwardAction) {
-            mWorld.moveEntity(mLara, 'b');
+            getWorld().moveEntity(mLara, 'b');
         } else if (action == leftAction) {
-            mWorld.moveEntity(mLara, 'l');
+            getWorld().moveEntity(mLara, 'l');
         } else if (action == rightAction) {
-            mWorld.moveEntity(mLara, 'r');
+            getWorld().moveEntity(mLara, 'r');
         }
     }
 }
                 s_index = sprite_sequence[j].offset;
 
                 r_mesh = new sprite_seq_t;
-                mWorld.addSprite(r_mesh);
+                getWorld().addSprite(r_mesh);
                 r_mesh->num_sprites = -sprite_sequence[j].negative_length;
                 r_mesh->sprite = new sprite_t[r_mesh->num_sprites];
 
     }
 
     //! \fixme Check here and see if we already have one for object_id later
-    // if (mWorld.isCachedSkeletalModel(moveable[index].object_id))
+    // if (getWorld().isCachedSkeletalModel(moveable[index].object_id))
     // {
     //   thing->modelId = mRender->add(sModel);
     //   return;
     if (!found)
     {
         sModel->model = r_model;
-        mWorld.addEntity(thing);
+        getWorld().addEntity(thing);
 
-        k = mWorld.addModel(r_model);
+        k = getWorld().addModel(r_model);
 
         cache.push_back(j);
         cache2.push_back(r_model);
         delete r_model;
         c_model = cache2[foundIndex];
         sModel->model = c_model;
-        mWorld.addEntity(thing);
-        mWorld.addModel(c_model);
+        getWorld().addEntity(thing);
+        getWorld().addModel(c_model);
         printf("c");
         return;
     }
 
     int aloop = mTombRaider.getNumAnimsForMoveable(index);
 
-#ifdef DEBUG
-    if (mFlags & Flag_DebugModel)
-    {
-        printf("\nanimation = %i, num_animations = %i\n",
-                moveable[index].animation, aloop);
-        printf("\nitem[%i].flags = %i\nentity[%i]\n",
-                i, item[i].flags, thing->id);
-    }
+#ifdef DEBUG_MOVEABLE
+    printf("\nanimation = %i, num_animations = %i\n",
+            moveable[index].animation, aloop);
+    printf("\nitem[%i].flags = %i\nentity[%i]\n",
+            i, item[i].flags, thing->id);
 #endif
 
     //a = moveable[index].animation;
         frame_count = (animation[a].frame_end - animation[a].frame_start) + 1;
         animation_frame->rate = animation[a].frame_rate;
 
-#ifdef DEBUG
-        if (mFlags & Flag_DebugModel)
-        {
-            printf("animation[%i] state and unknowns = %i, %i, %i, %i, %i\n",
-                    a, animation[a].state_id, animation[a].unknown1,
-                    animation[a].unknown2, animation[a].unknown3,
-                    animation[a].unknown4);
-            printf("animation[%i].frame_rate = %i\n",
-                    a, animation[a].frame_rate);
-            printf("animation[%i].next_animation = %i\n",
-                    a, animation[a].next_animation);
-            printf("animation[%i].frame_offset = %u\n",
-                    a, animation[a].frame_offset);
-            printf("animation[%i].anim_command = %i\n",
-                    a, animation[a].anim_command);
-            printf("animation[%i].num_anim_commands = %i\n",
-                    a, animation[a].num_anim_commands);
-            printf("animation[%i].state_change_offset = %i\n",
-                    a, animation[a].state_change_offset);
-            printf("              frame_offset = %u\n",
-                    frame_offset);
-        }
+#ifdef DEBUG_MOVEABLE
+        printf("animation[%i] state and unknowns = %i, %i, %i, %i, %i\n",
+                a, animation[a].state_id, animation[a].unknown1,
+                animation[a].unknown2, animation[a].unknown3,
+                animation[a].unknown4);
+        printf("animation[%i].frame_rate = %i\n",
+                a, animation[a].frame_rate);
+        printf("animation[%i].next_animation = %i\n",
+                a, animation[a].next_animation);
+        printf("animation[%i].frame_offset = %u\n",
+                a, animation[a].frame_offset);
+        printf("animation[%i].anim_command = %i\n",
+                a, animation[a].anim_command);
+        printf("animation[%i].num_anim_commands = %i\n",
+                a, animation[a].num_anim_commands);
+        printf("animation[%i].state_change_offset = %i\n",
+                a, animation[a].state_change_offset);
+        printf("              frame_offset = %u\n",
+                frame_offset);
 #endif
 
         // Get all the frames for aniamtion
                 }
             }
 
-#ifdef DEBUG
-            if (mFlags & Flag_DebugModel)
-            {
-                printf("animation[%i].boneframe[%u] = offset %u, step %i\n",
-                        a, f, frame_offset, frame_step);
-            }
+#ifdef DEBUG_MOVEABLE
+            printf("animation[%i].boneframe[%u] = offset %u, step %i\n",
+                    a, f, frame_offset, frame_step);
 #endif
 
             // Mongoose 2002.08.15, Was
         if (index < 0 || !mTombRaider.isMeshValid(index))
         {
             //! \fixme allow sparse lists with matching ids instead?
-            mWorld.addMesh(NULL); // Filler, to make meshes array ids align
+            getWorld().addMesh(NULL); // Filler, to make meshes array ids align
             //printf("x");
             //fflush(stdout);
             return;
         std::sort(mesh->texturedRectangles.begin(), mesh->texturedRectangles.end(), compareFaceTextureId);
         std::sort(mesh->coloredRectangles.begin(), mesh->coloredRectangles.end(), compareFaceTextureId);
 
-        mWorld.addMesh(mesh);
+        getWorld().addMesh(mesh);
         //printf(".");
         //fflush(stdout);
     }
         if (!mTombRaider.isRoomValid(index))
         {
             getConsole().print("WARNING: Handling invalid vertex array in room");
-            mWorld.addRoom(0x0);
+            getWorld().addRoom(0x0);
             mRender->addRoom(0x0);
 
             //printf("x");
             r_mesh->sprites.push_back(sprite);
         }
 
-        mWorld.addRoom(r_mesh);
+        getWorld().addRoom(r_mesh);
 
         rRoom->room = r_mesh;
         mRender->addRoom(rRoom);

src/Render.cpp

         camPos[0] -= (1024.0f * sinf(yaw));
         camPos[2] -= (1024.0f * cosf(yaw));
 
-        sector = getGame().mWorld.getSector(index, camPos[0], camPos[2]);
+        sector = getWorld().getSector(index, camPos[0], camPos[2]);
 
         // Handle camera out of world
-        if (sector < 0 || getGame().mWorld.isWall(index, sector))
+        if (sector < 0 || getWorld().isWall(index, sector))
         {
             camPos[0] = curPos[0] + (64.0f * sinf(yaw));
             camPos[1] -= 64.0f;
     {
         entity_t *e;
         std::vector<entity_t *> entityRenderList;
-        std::vector<entity_t *> *entities = getGame().mWorld.getEntities();
+        std::vector<entity_t *> *entities = getWorld().getEntities();
 
         for (unsigned int i = 0; i < entities->size(); i++)
         {
 
 void Render::drawSkyMesh(float scale)
 {
-    skeletal_model_t *model = getGame().mWorld.getModel(mSkyMesh);
+    skeletal_model_t *model = getWorld().getModel(mSkyMesh);
 
 
     if (!model)
     glTranslated(0.0, 1000.0, 0.0);
     glScaled(scale, scale, scale);
     //drawModel(model);
-    //drawModelMesh(getGame().mWorld.getMesh(mSkyMesh), );
+    //drawModelMesh(getWorld().getMesh(mSkyMesh), );
     glPopMatrix();
     glEnable(GL_DEPTH_TEST);
 }
     {
         std::vector<sprite_seq_t *> *sprites;
 
-        sprites = getGame().mWorld.getSprites();
+        sprites = getWorld().getSprites();
 
         for (unsigned int i = 0; i < sprites->size(); i++)
         {
 
                 if (tag2)
                 {
-                    drawModelMesh(getGame().mWorld.getMesh(tag2->mesh), Render::skeletalMesh);
+                    drawModelMesh(getWorld().getMesh(tag2->mesh), Render::skeletalMesh);
                 }
             }
         }
                     {
                         glPushMatrix();
                         glTranslatef(mdl->ponyOff2, 0.0, 0.0);
-                        drawModelMesh(getGame().mWorld.getMesh(mdl->ponytailMeshId + i),
+                        drawModelMesh(getWorld().getMesh(mdl->ponytailMeshId + i),
                                 Render::skeletalMesh);
                         glPopMatrix();
 
                         glPushMatrix();
                         glTranslatef(-mdl->ponyOff2, 0.0, 0.0);
-                        drawModelMesh(getGame().mWorld.getMesh(mdl->ponytailMeshId + i),
+                        drawModelMesh(getWorld().getMesh(mdl->ponytailMeshId + i),
                                 Render::skeletalMesh);
                         glPopMatrix();
                     }
                     else
                     {
-                        drawModelMesh(getGame().mWorld.getMesh(mdl->ponytailMeshId + i),
+                        drawModelMesh(getWorld().getMesh(mdl->ponytailMeshId + i),
                                 Render::skeletalMesh);
                     }
                 }
             }
         }
 
-        drawModelMesh(getGame().mWorld.getMesh(tag->mesh), Render::skeletalMesh);
+        drawModelMesh(getWorld().getMesh(tag->mesh), Render::skeletalMesh);
     }
 
     // Cycle frames ( cheap hack from old ent state based system )
     if (!mesh)
         return;
 
-    r_mesh = getGame().mWorld.getMesh(mesh->index);
+    r_mesh = getWorld().getMesh(mesh->index);
 
     if (!r_mesh)
         return;
         return;
     }
 
-    model = getGame().mWorld.getModel(index);
+    model = getWorld().getModel(index);
 
     if (model)
     {

src/main.cpp

 #include <cstdlib>
 #include <cstdio>
 #include <cstring>
+#include <assert.h>
 
 #include "config.h"
 #include "main.h"
 OpenRaider *gOpenRaider = NULL;
 Sound *gSound = NULL;
 Window *gWindow = NULL;
+World *gWorld = NULL;
 
 Console &getConsole() {
+    assert(gConsole != NULL);
     return *gConsole;
 }
 
 Game &getGame() {
+    assert(gGame != NULL);
     return *gGame;
 }
 
 Menu &getMenu() {
+    assert(gMenu != NULL);
     return *gMenu;
 }
 
 OpenRaider &getOpenRaider() {
+    assert(gOpenRaider != NULL);
     return *gOpenRaider;
 }
 
 Sound &getSound() {
+    assert(gSound != NULL);
     return *gSound;
 }
 
 Window &getWindow() {
+    assert(gWindow != NULL);
     return *gWindow;
 }
 
+World &getWorld() {
+    assert(gWorld != NULL);
+    return *gWorld;
+}
+
 void cleanupHandler(void) {
     if (gConsole)
         delete gConsole;
     if (gMenu)
         delete gMenu;
 
+    if (gWorld)
+        delete gWorld;
+
     if (gOpenRaider)
         delete gOpenRaider;
 
     gOpenRaider = new OpenRaider();
     gWindow = new WindowSDL();
     gSound = new Sound();
+    gWorld = new World();
     gConsole = new Console();
     gMenu = new Menu();
     gGame = new Game();