Moved methods from World into Room.

Also changed some strange old delete-guards.

ChangeLog.md

 
 ## OpenRaider (0.1.3) xythobuz <xythobuz@xythobuz.de>
 
+    [ 20140613 ]
+    * Changed strange delete-guards
+    * Moved some methods from World into the proper classes
+
     [ 20140605 ]
     * Split Font/Text-Rendering Subsystem from Windowing System
     * Slight improvements on Window Interface/Implementation differences

include/Render.h

     void buildRoomRenderList(Room &room);
 
     /*!
-     * \brief Renders visible world object.
-     *
-     * Texture must be initialized.
-     */
-    void drawObjects();
-
-    /*!
      * \brief Renders Sky domes/boxes/etc by scaling factor.
      *
      * Texture must be initialized.
     void drawSkyMesh(float scale);
 
     /*!
-     * \brief Renders a skeletal model.
-     *
-     * Texture must be initialized!
-     * \param model model to render
-     */
-    void drawModel(SkeletalModel *model);
-
-    /*!
      * \brief Updates View Volume. Call once per render frame.
      */
     void updateViewVolume();

include/Room.h

     Mesh &getMesh();
     void display(bool alpha);
 
+    bool isWall(unsigned int sector);
+    int getSector(float x, float z, float *floor, float *ceiling);
+    int getSector(float x, float z);
+    void getHeightAtPosition(float x, float *y, float z);
+    int getAdjoiningRoom(float x, float y, float z,
+        float x2, float y2, float z2);
+
     unsigned int getNumXSectors();
     unsigned int getNumZSectors();
     void getPos(vec3_t p);

include/TombRaider.h

 
     void printDebug(const char *methodName, const char *s, ...) __attribute__((format(printf, 3, 4)));
 
-    bool mReset;                           //!< Guard multiple calls to reset()
     bool mDebug;                           //!< Debug output toggle
     unsigned int mPakVersion;              //!< TombRaider pak file header version
     tr2_version_type mEngineVersion;       //!< TombRaider engine version

include/World.h

      */
     int getRoomByLocation(float x, float y, float z);
 
-    /*!
-     * \brief Looks for portal crossings from xyz to xyz2 segment
-     * from room[index]
-     * \param index valid room index
-     * \param x X coordinate of first point
-     * \param y Y coordinate of first point
-     * \param z Z coordinate of first point
-     * \param x2 X coordinate of second point
-     * \param y2 Y coordinate of second point
-     * \param z2 Z coordinate of second point
-     * \returns index of adjoined room or -1
-     */
-    int getAdjoiningRoom(int index,
-                            float x, float y, float z,
-                            float x2, float y2, float z2);
-
-    /*!
-     * \brief Gets the sector index of the position in room
-     * \param room valid room index
-     * \param x X coordinate in room
-     * \param z Z coordinate in room
-     * \returns sector index of position in room
-     */
-    int getSector(int room, float x, float z);
-
-    int getSector(int room, float x, float z, float *floor, float *ceiling);
-
-    unsigned int getRoomInfo(int room);
-
-    /*!
-     * \brief Check if sector is a wall
-     * \param room valid room index
-     * \param sector valid sector index
-     * \returns true if this sector is a wall
-     */
-    bool isWall(int room, int sector);
-
-    /*!
-     * \brief Get the world height at a position
-     * \param index valid room index
-     * \param x X coordinate
-     * \param y will be set to world height in that room
-     * \param z Z coordinate
-     */
-    void getHeightAtPosition(int index, float x, float *y, float z);
-
 private:
 
     // Old World

include/WorldData.h

 #define _WORLDDATA_H_
 
 #include "math/math.h"
-#include "SkeletalModel.h"
 
 /*! \fixme For now shaders are textures on tex objects
  * and materials on color objects. If -1

src/Console.cpp

 }
 
 Console::~Console() {
-    if (mInputBuffer)
-        delete [] mInputBuffer;
+    delete [] mInputBuffer;
+    mInputBuffer = NULL;
 
-    if (mPartialInput)
-        delete [] mPartialInput;
+    delete [] mPartialInput;
+    mPartialInput = NULL;
 
-    if (mUnfinishedInput)
-        delete [] mUnfinishedInput;
+    delete [] mUnfinishedInput;
+    mUnfinishedInput = NULL;
 
     while (mHistory.size() > 0) {
-        char *tmp = mHistory.back();
-        if (tmp != NULL)
-            delete [] tmp;
+        delete [] mHistory.back();
         mHistory.pop_back();
     }
 
     while (mCommandHistory.size() > 0) {
-        char *tmp = mCommandHistory.back();
-        if (tmp != NULL)
-            delete [] tmp;
+        delete [] mCommandHistory.back();
         mCommandHistory.pop_back();
     }
 }

src/Entity.cpp

     roomNew = getWorld().getRoomByLocation(room, x, y, z);
 
     if (roomNew == -1) { // Will we hit a portal?
-        roomNew = getWorld().getAdjoiningRoom(room,
-                pos[0],  pos[1], pos[2],
+        roomNew = getWorld().getRoom(room).getAdjoiningRoom(pos[0], pos[1], pos[2],
                 x, y, z);
 
         if (roomNew > -1)
             return;
     }
 
-    roomFlags = getWorld().getRoomInfo(roomNew);
-    sector = getWorld().getSector(roomNew, x, z, &floor, &ceiling);
-    wall = getWorld().isWall(roomNew, sector);
+    roomFlags = getWorld().getRoom(roomNew).getFlags();
+    sector = getWorld().getRoom(roomNew).getSector(x, z, &floor, &ceiling);
+    wall = getWorld().getRoom(roomNew).isWall(sector);
 
     // If you're underwater you may want to swim  =)
     // ...if you're worldMoveType_walkNoSwim, you better hope it's shallow
          */
 
         h = y;
-        getWorld().getHeightAtPosition(room, x, &h, z);
+        getWorld().getRoom(room).getHeightAtPosition(x, &h, z);
 
         switch (moveType) {
             case MoveTypeFly:
 
 void Entity::print() {
     getConsole().print("Entity %d:", objectId);
-    getConsole().print("  Room %i (0x%X)", room, getWorld().getRoomInfo(room));
+    getConsole().print("  Room %i (0x%X)", room, getWorld().getRoom(room).getFlags());
     getConsole().print("  %.1fx %.1fy %.1fz", pos[0], pos[1], pos[2]);
     getConsole().print("  %.1f Yaw", OR_RAD_TO_DEG(angles[1]));
 }

src/Font.cpp

 #include "Font.h"
 
 Font::~Font() {
-    if (mFontName)
-        delete [] mFontName;
+    delete [] mFontName;
+    mFontName = NULL;
 }
 
 void Font::setFont(const char *font) {

src/FontSDL.cpp

     if (mFontInit)
         TTF_Quit();
 
-    if (tempText.text)
-        delete [] tempText.text;
+    delete [] tempText.text;
+    tempText.text = NULL;
 }
 
 int FontSDL::initialize() {

src/Game.cpp

 }
 
 void Game::destroy() {
-    if (mName)
-        delete [] mName;
+    delete [] mName;
     mName = NULL;
+
     mLoaded = false;
     mLara = -1;
     getRender().setMode(Render::modeDisabled);
             getLara().move('l');
         } else if (action == rightAction) {
             getLara().move('r');
+        } else if (action == jumpAction) {
+
+        } else if (action == crouchAction) {
+
+        } else if (action == useAction) {
+
+        } else if (action == holsterAction) {
+
+        } else if (action == walkAction) {
+
         }
     }
 }

src/Menu.cpp

 
 Menu::~Menu() {
     delete [] mainText.text;
+    mainText.text = NULL;
 
     while (mMapList.size() > 0) {
         delete [] mMapList.back();

src/Mesh.cpp

 
 Mesh::~Mesh()
 {
-    unsigned int i;
+    delete [] mVertices;
+    mVertices = NULL;
 
+    delete [] mNormals;
+    mNormals = NULL;
 
-    if (mVertices)
-    {
-        delete [] mVertices;
-    }
-
-    if (mNormals)
-    {
-        delete [] mNormals;
-    }
-
-    if (mColors)
-    {
-        delete [] mColors;
-    }
+    delete [] mColors;
+    mColors = NULL;
 
     if (mTris)
     {
-        for (i = 0; i < mNumTris; ++i)
+        for (unsigned int i = 0; i < mNumTris; ++i)
         {
-            if (mTris[i].triangles)
-                delete [] mTris[i].triangles;
-
-            if (mTris[i].alpha_triangles)
-                delete [] mTris[i].alpha_triangles;
-
-            if (mTris[i].texcoors)
-                delete [] mTris[i].texcoors;
-
-            if (mTris[i].texcoors2)
-                delete [] mTris[i].texcoors2;
+            delete [] mTris[i].triangles;
+            delete [] mTris[i].alpha_triangles;
+            delete [] mTris[i].texcoors;
+            delete [] mTris[i].texcoors2;
         }
 
         delete [] mTris;
+        mTris = NULL;
     }
 
     if (mQuads)
     {
-        for (i = 0; i < mNumQuads; ++i)
+        for (unsigned int i = 0; i < mNumQuads; ++i)
         {
-            if (mQuads[i].quads)
-                delete [] mQuads[i].quads;
-
-            if (mQuads[i].alpha_quads)
-                delete [] mQuads[i].alpha_quads;
-
-            if (mQuads[i].texcoors)
-                delete [] mQuads[i].texcoors;
-
-            if (mQuads[i].texcoors2)
-                delete [] mQuads[i].texcoors2;
+            delete [] mQuads[i].quads;
+            delete [] mQuads[i].alpha_quads;
+            delete [] mQuads[i].texcoors;
+            delete [] mQuads[i].texcoors2;
         }
 
         delete [] mQuads;
+        mQuads = NULL;
     }
 
-    if (mVertexArray)
-    {
-        delete [] mVertexArray;
-    }
+    delete [] mVertexArray;
+    mVertexArray = NULL;
 
-    if (mNormalArray)
-    {
-        delete [] mNormalArray;
-    }
+    delete [] mNormalArray;
+    mNormalArray = NULL;
 
-    if (mColorArray)
-    {
-        delete [] mColorArray;
-    }
+    delete [] mColorArray;
+    mColorArray = NULL;
 
-    if (mTriangleTextures)
-    {
-        delete [] mTriangleTextures;
-    }
+    delete [] mTriangleTextures;
+    mTriangleTextures = NULL;
 
-    if (mTriangleIndices)
-    {
-        delete [] mTriangleIndices;
-    }
+    delete [] mTriangleIndices;
+    mTriangleIndices = NULL;
 
-    if (mTriangleFlags)
-    {
-        delete [] mTriangleFlags;
-    }
+    delete [] mTriangleFlags;
+    mTriangleFlags = NULL;
 
-    if (mTriangleTexCoordArray)
-    {
-        delete [] mTriangleTexCoordArray;
-    }
+    delete [] mTriangleTexCoordArray;
+    mTriangleTexCoordArray = NULL;
 }
 
 

src/OpenRaider.cpp

 }
 
 OpenRaider::~OpenRaider() {
-    if (mBaseDir)
-        delete mBaseDir;
+    delete mBaseDir;
+    mBaseDir = NULL;
 
-    if (mPakDir)
-        delete mPakDir;
+    delete mPakDir;
+    mPakDir = NULL;
 
-    if (mAudioDir)
-        delete mAudioDir;
+    delete mAudioDir;
+    mAudioDir = NULL;
 
-    if (mDataDir)
-        delete mDataDir;
+    delete mDataDir;
+    mDataDir = NULL;
 }
 
 int OpenRaider::initialize() {

src/Render.cpp

     ClearWorld();
 }
 
+void Render::ClearWorld() {
+    mRoomRenderList.clear();
+}
+
 
 void Render::screenShot(char *filenameBase)
 {
 }
 
 
-void Render::ClearWorld() {
-    mRoomRenderList.clear();
-}
-
-
 // Texture must be set to WHITE solid color texture
 void renderTrace(int color, vec3_t start, vec3_t end)
 {
     camPos[2] = curPos[2] - (1024.0f * cosf(yaw));
 
     int index = getGame().getLara().getRoom();
-    int sector = getWorld().getSector(index, camPos[0], camPos[2]);
+    int sector = getWorld().getRoom(index).getSector(camPos[0], camPos[2]);
 
     // Handle camera out of world
     if ((sector < 0) ||
             ((unsigned int)sector >= getWorld().getRoom(index).sizeSectors()) ||
-            getWorld().isWall(index, sector)) {
+            getWorld().getRoom(index).isWall(sector)) {
         camPos[0] = curPos[0] + (64.0f * sinf(yaw));
         camPos[1] -= 64.0f;
         camPos[2] = curPos[2] + (64.0f * cosf(yaw));
 
         // Draw objects not tied to rooms
         glPushMatrix();
-        drawObjects();
+
+        // Draw lara or other player model ( move to entity rendering method )
+        if (mFlags & Render::fViewModel)
+            getGame().getLara().display();
+
+        // Draw sprites after player to handle alpha
+        for (unsigned int i = 0; i < getWorld().sizeSprite(); i++) {
+            SpriteSequence &sprite = getWorld().getSprite(i);
+            for (unsigned int j = 0; j < sprite.size(); j++)
+                sprite.get(j).display();
+        }
+
         glPopMatrix();
 
         // Depth sort entityRenderList with qsort
 void Render::drawLoadScreen()
 {
     float x = 0.0f, y = 0.0f, z = -160.0f;
-    float w, h;
-
-    if (getWindow().getWidth() < getWindow().getHeight())
-        w = h = (float)getWindow().getWidth();
-    else
-        w = h = (float)getWindow().getHeight();
-
+    float w = getWindow().getWidth(), h = getWindow().getHeight();
 
     if (mTexture.getTextureCount() <= 0)
         return;
     glPushMatrix();
 
     if (mSkyMeshRotation)
-    {
         glRotated(90.0, 1, 0, 0);
-    }
 
     glTranslated(0.0, 1000.0, 0.0);
     glScaled(scale, scale, scale);
 }
 
 
-void Render::drawObjects() {
-    // Draw lara or other player model ( move to entity rendering method )
-    if (mFlags & Render::fViewModel)
-        getGame().getLara().display();
-
-    // Draw sprites after player to handle alpha
-    for (unsigned int i = 0; i < getWorld().sizeSprite(); i++) {
-        SpriteSequence &sprite = getWorld().getSprite(i);
-        for (unsigned int j = 0; j < sprite.size(); j++)
-            sprite.get(j).display();
-    }
-}
-
-
 void Render::tmpRenderModelMesh(model_mesh_t *r_mesh, texture_tri_t *ttri)
 {
     glBegin(GL_TRIANGLES);

src/Room.cpp

     }
 }
 
+bool Room::isWall(unsigned int sector) {
+    assert(sector >= 0);
+    assert(sector < sectors.size());
+
+    //! \fixme is (sector > 0) correct??
+    return ((sector > 0) && sectors.at(sector)->isWall());
+}
+
+int Room::getSector(float x, float z, float *floor, float *ceiling) {
+    assert(floor != NULL);
+    assert(ceiling != NULL);
+
+    int sector = getSector(x, z);
+
+    if ((sector >= 0) && (sector < (int)sectors.size())) {
+        *floor = sectors.at(sector)->getFloor();
+        *ceiling = sectors.at(sector)->getCeiling();
+    }
+
+    return sector;
+}
+
+int Room::getSector(float x, float z) {
+    int sector = (((((int)x - (int)pos[0]) / 1024) *
+        numZSectors) + (((int)z - (int)pos[2]) / 1024));
+
+    if (sector < 0)
+        return -1;
+
+    return sector;
+}
+
+void Room::getHeightAtPosition(float x, float *y, float z) {
+    int sector = getSector(x, z);
+    if ((sector >= 0) && (sector < (int)sectors.size()))
+        *y = sectors.at(sector)->getFloor();
+}
+
+int Room::getAdjoiningRoom(float x, float y, float z,
+        float x2, float y2, float z2) {
+    vec3_t intersect, p1, p2;
+    vec3_t vertices[4];
+
+    p1[0] = x;  p1[1] = y;  p1[2] = z;
+    p2[0] = x2; p2[1] = y2; p2[2] = z2;
+
+    for (unsigned int i = 0; i < portals.size(); i++) {
+        portals.at(i)->getVertices(vertices);
+        if (intersectionLinePolygon(intersect, p1, p2, //4,
+                    vertices))
+            return portals.at(i)->getAdjoiningRoom();
+    }
+
+    return -1;
+}
+
 unsigned int Room::getFlags() {
     return flags;
 }

src/RoomData.cpp

 
 #include "global.h"
 #include "Render.h"
-#include "RoomData.h"
+#include "SkeletalModel.h"
 #include "World.h"
+#include "RoomData.h"
 
 BoundingBox::BoundingBox() {
     a[0] = a[1] = a[2] = 0;

src/TombRaider.cpp

     flyByCamerasTR5 = 0x0;
 
     mNumTR4Samples = 0;
-    mReset = false;
     mDebug = false;
     mRiffAlternateLoaded = false;
     mRoomVertexLightingFactor = 50.0f;
     }
 
 
-    mReset = false;
-
     Fread(&mPakVersion, sizeof(mPakVersion), 1, f);
     //! \fixme endian
 
 
 void TombRaider::reset()
 {
-    unsigned int i;
-
-
-    // Mongoose 2003.05.13, Don't let some jackass reset over and over
-    if (mReset)
-    {
-        return;
-    }
-
-    //! \fixme Palettes aren't the same size anymore
-    //memset(_palette8, 0, 256);
-    //memset(_palette16, 0, 256);
-
-    if (_anim_dispatches)
-        delete [] _anim_dispatches;
+    delete [] _anim_dispatches;
+    _anim_dispatches = NULL;
 
-    if (_anim_commands)
-        delete [] _anim_commands;
+    delete [] _anim_commands;
+    _anim_commands = NULL;
 
-    if (_mesh_trees)
-        delete [] _mesh_trees;
+    delete [] _mesh_trees;
+    _mesh_trees = NULL;
 
-    if (_frames)
-        delete [] _frames;
+    delete [] _frames;
+    _frames = NULL;
 
-    if (_moveables)
-        delete [] _moveables;
+    delete [] _moveables;
+    _moveables = NULL;
 
-    if (_static_meshes)
-        delete [] _static_meshes;
+    delete [] _static_meshes;
+    _static_meshes = NULL;
 
-    if (_object_textures)
-        delete [] _object_textures;
+    delete [] _object_textures;
+    _object_textures = NULL;
 
-    if (_sprite_textures)
-        delete [] _sprite_textures;
+    delete [] _sprite_textures;
+    _sprite_textures = NULL;
 
-    if (_sprite_sequences)
-        delete [] _sprite_sequences;
+    delete [] _sprite_sequences;
+    _sprite_sequences = NULL;
 
-    if (_cameras)
-        delete [] _cameras;
+    delete [] _cameras;
+    _cameras = NULL;
 
-    if (_sound_sources)
-        delete [] _sound_sources;
+    delete [] _sound_sources;
+    _sound_sources = NULL;
 
-    if (_boxes)
-        delete [] _boxes;
+    delete [] _boxes;
+    _boxes = NULL;
 
-    if (_overlaps)
-        delete [] _overlaps;
+    delete [] _overlaps;
+    _overlaps = NULL;
 
-    if (_zones)
-        delete [] _zones;
+    delete [] _zones;
+    _zones = NULL;
 
-    if (_animated_textures)
-        delete [] _animated_textures;
+    delete [] _animated_textures;
+    _animated_textures = NULL;
 
-    if (_items)
-        delete [] _items;
+    delete [] _items;
+    _items = NULL;
 
-    if (_light_map)
-        delete [] _light_map;
+    delete [] _light_map;
+    _light_map = NULL;
 
-    if (_cinematic_frames)
-        delete [] _cinematic_frames;
+    delete [] _cinematic_frames;
+    _cinematic_frames = NULL;
 
-    if (_demo_data)
-        delete [] _demo_data;
+    delete [] _demo_data;
+    _demo_data = NULL;
 
-    if (mRiffAlternateOffsets)
-        delete [] mRiffAlternateOffsets;
+    delete [] mRiffAlternateOffsets;
+    mRiffAlternateOffsets = NULL;
 
-    if (mSoundMap)
-        delete [] mSoundMap;
+    delete [] mSoundMap;
+    mSoundMap = NULL;
 
-    if (mSoundDetails)
-        delete [] mSoundDetails;
+    delete [] mSoundDetails;
+    mSoundDetails = NULL;
 
-    if (mSampleIndices)
-        delete [] mSampleIndices;
+    delete [] mSampleIndices;
+    mSampleIndices = NULL;
 
-    if (mRiffData)
-        delete [] mRiffData;
+    delete [] mRiffData;
+    mRiffData = NULL;
 
-    if (mTR4Samples)
-    {
-        for (i = 0; i < mNumTR4Samples; ++i)
-        {
-            if (mTR4SamplesSz[i])
-                delete [] mTR4Samples[i];
+    if (mTR4Samples) {
+        for (unsigned int i = 0; i < mNumTR4Samples; ++i) {
+            delete [] mTR4Samples[i];
+            mTR4Samples[i] = NULL;
         }
 
         delete [] mTR4Samples;
+        mTR4Samples = NULL;
     }
 
-    if (mTR4SamplesSz)
-        delete [] mTR4SamplesSz;
+    delete [] mTR4SamplesSz;
+    mTR4SamplesSz = NULL;
 
-    if (_rooms)
-    {
-        for (i = 0; i < _num_rooms; ++i)
-        {
+    if (_rooms) {
+        for (unsigned int i = 0; i < _num_rooms; ++i) {
             if (_rooms[i].room_data.num_vertices > 0)
                 delete [] _rooms[i].room_data.vertices;
 
                 delete [] _rooms[i].room_data.sprites;
 
             if (_rooms[i].num_portals > 0)
-                delete []_rooms[i].portals;
-
-            if (_rooms[i].sector_list)
-                delete [] _rooms[i].sector_list;
-
-            if (_rooms[i].lights)
-                delete [] _rooms[i].lights;
+                delete [] _rooms[i].portals;
 
-            if (_rooms[i].tr4Lights)
-                delete [] _rooms[i].tr4Lights;
-
-            if (_rooms[i].static_meshes)
-                delete [] _rooms[i].static_meshes;
+            delete [] _rooms[i].sector_list;
+            delete [] _rooms[i].lights;
+            delete [] _rooms[i].tr4Lights;
+            delete [] _rooms[i].static_meshes;
         }
 
         delete [] _rooms;
+        _rooms = NULL;
     }
 
-    if (_floor_data)
-    {
-        delete [] _floor_data;
-    }
-
-    if (mMeshes)
-    {
-        for (i = 0; (int)i < mMeshCount; ++i)
-        {
-            if (mMeshes[i].vertices)
-                delete [] mMeshes[i].vertices;
-
-            if (mMeshes[i].mesh_lights)
-                delete [] mMeshes[i].mesh_lights;
-
-            if (mMeshes[i].normals)
-                delete [] mMeshes[i].normals;
-
-            if (mMeshes[i].textured_rectangles)
-                delete [] mMeshes[i].textured_rectangles;
-
-            if (mMeshes[i].textured_triangles)
-                delete [] mMeshes[i].textured_triangles;
-
-            if (mMeshes[i].coloured_rectangles)
-                delete [] mMeshes[i].coloured_rectangles;
+    delete [] _floor_data;
+    _floor_data = NULL;
 
-            if (mMeshes[i].coloured_triangles)
-                delete [] mMeshes[i].coloured_triangles;
+    if (mMeshes) {
+        for (unsigned int i = 0; (int)i < mMeshCount; ++i) {
+            delete [] mMeshes[i].vertices;
+            delete [] mMeshes[i].mesh_lights;
+            delete [] mMeshes[i].normals;
+            delete [] mMeshes[i].textured_rectangles;
+            delete [] mMeshes[i].textured_triangles;
+            delete [] mMeshes[i].coloured_rectangles;
+            delete [] mMeshes[i].coloured_triangles;
         }
 
         delete [] mMeshes;
+        mMeshes = NULL;
     }
 
-    if (_animations)
-        delete [] _animations;
+    delete [] _animations;
+    _animations = NULL;
 
-    if (_state_changes)
-        delete _state_changes;
-    //delete [] _state_changes;
+    delete [] _state_changes;
+    _state_changes = NULL;
 
     numMoveablesTR5 = 0;
-    if (moveablesTR5)
-        delete [] moveablesTR5;
+    delete [] moveablesTR5;
+    moveablesTR5 = NULL;
 
     numAnimationsTR5 = 0;
-    if (animationsTR5)
-        delete [] animationsTR5;
+    delete [] animationsTR5;
+    animationsTR5 = NULL;
 
     numObjectTexturesTR5 = 0;
-    if (objectTexturesTR5)
-        delete [] objectTexturesTR5;
+    delete [] objectTexturesTR5;
+    objectTexturesTR5 = NULL;
 
     numCinematicFramesTR5 = 0;
-    if (cinematicFramesTR5)
-        delete [] cinematicFramesTR5;
+    delete [] cinematicFramesTR5;
+    cinematicFramesTR5 = NULL;
 
     numFlyByCamerasTR5 = 0;
-    if (flyByCamerasTR5)
-        delete [] flyByCamerasTR5;
+    delete [] flyByCamerasTR5;
+    flyByCamerasTR5 = NULL;
 
     // Texture use
-    if (_tex_special)
-        delete [] _tex_special;
-
-    if (_textile8)
-        delete [] _textile8;
-
-    if (_textile16)
-        delete [] _textile16;
-
-    if (_textile32)
-        delete [] _textile32;
-
-    //! \fixme Damaged memory causes delete to not set pointer to NULL?
+    delete [] _tex_special;
     _tex_special = NULL;
+
+    delete [] _textile8;
     _textile8 = NULL;
+
+    delete [] _textile16;
     _textile16 = NULL;
+
+    delete [] _textile32;
     _textile32 = NULL;
 
     // Compressed level use
-    if (mCompressedLevelData)
-        delete [] mCompressedLevelData;
+    delete [] mCompressedLevelData;
+    mCompressedLevelData = NULL;
 
     mCompressedLevelDataOffset  = 0;
     mCompressedLevelSize = 0;
     _num_sprite_textures = 0;
     _num_sprite_sequences = 0;
     _num_overlaps = 0;
-
-    mReset = true;
 }
 
 

src/World.cpp

         mMeshes.push_back(mesh);
 }
 
+
 void World::addRoom(Room &room) {
     mRooms.push_back(&room);
 }
 }
 
 
-int World::getAdjoiningRoom(int index,
-        float x, float y, float z,
-        float x2, float y2, float z2) {
-    assert(index >= 0);
-    assert(index < (int)mRooms.size());
-    Room &room = *mRooms.at(index);
-    vec3_t intersect, p1, p2;
-    vec3_t vertices[4];
-
-    p1[0] = x;  p1[1] = y;  p1[2] = z;
-    p2[0] = x2; p2[1] = y2; p2[2] = z2;
-
-    for (unsigned int i = 0; i < room.sizePortals(); i++) {
-        room.getPortal(i).getVertices(vertices);
-        if (intersectionLinePolygon(intersect, p1, p2, //4,
-                    vertices))
-            return room.getPortal(i).getAdjoiningRoom();
-    }
-
-    return -1;
-}
-
-
-int World::getSector(int room, float x, float z, float *floor, float *ceiling) {
-    assert(room >= 0);
-    assert(room < (int)mRooms.size());
-    assert(floor != NULL);
-    assert(ceiling != NULL);
-
-    int sector = getSector(room, x, z);
-
-    if ((sector >= 0) && (sector < (int)mRooms.at(room)->sizeSectors())) {
-        *floor = mRooms.at(room)->getSector(sector).getFloor();
-        *ceiling = mRooms.at(room)->getSector(sector).getCeiling();
-    }
-
-    return sector;
-}
-
-
-int World::getSector(int room, float x, float z) {
-    assert(room >= 0);
-    assert(room < (int)mRooms.size());
-
-    vec3_t pos;
-    mRooms.at(room)->getPos(pos);
-    int sector = (((((int)x - (int)pos[0]) / 1024) *
-        mRooms.at(room)->getNumZSectors()) + (((int)z - (int)pos[2]) / 1024));
-
-    if (sector < 0)
-        return -1;
-
-    return sector;
-}
-
-
-unsigned int World::getRoomInfo(int room) {
-    assert(room >= 0);
-    assert(room < (int)mRooms.size());
-
-    return mRooms.at(room)->getFlags();
-}
-
-
-bool World::isWall(int room, int sector) {
-    assert(room >= 0);
-    assert(room < (int)mRooms.size());
-    assert(sector >= 0);
-    assert(sector < (int)mRooms.at(room)->sizeSectors());
-
-    //! \fixme is (sector > 0) correct??
-    return ((sector > 0) && mRooms.at(room)->getSector(sector).isWall());
-}
-
-
-void World::getHeightAtPosition(int index, float x, float *y, float z) {
-    assert(index >= 0);
-    assert(index < (int)mRooms.size());
-
-    int sector = getSector(index, x, z);
-    if ((sector >= 0) && (sector < (int)mRooms.at(index)->sizeSectors()))
-        *y = mRooms.at(index)->getSector(sector).getFloor();
-}
-
-
 void World::destroy() {
     for (unsigned int i = 0; i != mRooms.size(); i++)
         delete mRooms[i];