Added World, WorldData, using std list and vector.

include/World.h

@@ -0,0 +1,194 @@
+/*!
+ * \file include/World.h
+ * \brief The game world (model)
+ *
+ * \author Mongoose
+ * \author xythobuz
+ */
+
+#ifndef _WORLD_H_
+#define _WORLD_H_
+
+#include <list>
+#include <vector>
+
+#define BAD_BLOOD  //!< \todo For temp rendering use
+
+#ifdef BAD_BLOOD
+#include "SkeletalModel.h"
+#endif
+
+#include "WorldData.h"
+
+/*!
+ * \brief The game world (model)
+ */
+class World {
+public:
+
+    enum WorldFlag {
+        fEnableHopping = 1
+    };
+
+    /*!
+     * \brief Constructs an object of World
+     */
+    World();
+
+    /*!
+     * \brief Deconstructs an object of World
+     */
+    ~World();
+
+    /*!
+     * \brief Find room a location is in.
+     *
+     * If it fails to be in a room it gives closest overlapping room.
+     * \param index Guessed room index
+     * \param x X coordinate
+     * \param y Y coordinate
+     * \param z Z coordinate
+     * \returns correct room index or -1 for unknown
+     */
+    int getRoomByLocation(int index, float x, float y, float z);
+
+    /*!
+     * \brief Find room a location is in.
+     *
+     * If it fails to be in a room it gives closest overlapping room.
+     * \param x X coordinate
+     * \param y Y coordinate
+     * \param z Z coordinate
+     * \returns correct room index or -1 for unknown
+     */
+    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
+     * \returns true if position is in a room
+     */
+    bool getHeightAtPosition(int index, float x, float *y, float z);
+
+#ifdef BAD_BLOOD
+    //! \todo Temp methods for rendering use until more refactoring is done
+    model_mesh_t *getMesh(int index);
+    skeletal_model_t *getModel(int index);
+    room_mesh_t *getRoom(int index);
+    std::vector<entity_t *> *getEntities();
+    std::vector<sprite_seq_t *> *getSprites();
+    std::vector<room_mesh_t *> *getRooms();
+#endif
+
+    /*!
+     * \brief Set an option flag
+     * \param flag flag to set
+     */
+    void setFlag(WorldFlag flag);
+
+    /*!
+     * \brief Clear an option flag
+     * \param flag flag to clear
+     */
+    void clearFlag(WorldFlag flag);
+
+    /*!
+     * \brief Clears all data in world
+     * \todo in future will check if data is in use before clearing
+     */
+    void destroy();
+
+    /*!
+     * \brief Adds room to world
+     * \param room room to add
+     */
+    void addRoom(room_mesh_t *room);
+
+    /*!
+     * \brief ADds mesh to world
+     * \param model mesh to add
+     */
+    void addMesh(model_mesh_t *model);
+
+    /*!
+     * \brief Adds entity to world
+     * \param e entity to add
+     */
+    void addEntity(entity_t *e);
+
+    /*!
+     * \brief Adds model to world.
+     * \param model model to add
+     * \returns next model ID or -1 on error
+     */
+    int addModel(skeletal_model_t *model);
+
+    /*!
+     * \brief Adds sprite to world
+     * \param sprite sprite to add
+     */
+    void addSprite(sprite_seq_t *sprite);
+
+    /*!
+     * \brief Move entity in given direction unless collision occurs
+     * \param e entity to move
+     * \param movement direction of movement ('f', 'b', 'l' or 'r')
+     */
+    void moveEntity(entity_t *e, char movement);
+
+private:
+
+    /*!
+     * \brief Clears all data in world
+     */
+    void clear();
+
+    bool mClearLock;
+    unsigned int mFlags;                //!< World flags
+    std::vector<entity_t *> mEntities;       //!< World entities
+    std::vector<room_mesh_t *> mRooms;       //!< Map data and meshes
+    std::vector<model_mesh_t *> mMeshes;     //!< Unanimated meshes
+    std::vector<sprite_seq_t *> mSprites;    //!< Sprites
+    std::vector<skeletal_model_t *> mModels; //!< Skeletal animation models
+};
+
+#endif

include/WorldData.h

@@ -0,0 +1,214 @@
+/*!
+ * \file include/World.h
+ * \brief The game world (model)
+ *
+ * \author Mongoose
+ * \author xythobuz
+ */
+
+#ifndef _WORLDDATA_H_
+#define _WORLDDATA_H_
+
+#include "math/math.h"
+
+// Mirrors TombRaider class' room flags really
+typedef enum {
+    roomFlag_underWater    = 0x0001
+} room_flags_t;
+
+typedef enum {
+    worldMoveType_walkNoSwim   = -1,
+    worldMoveType_walk         = 0,
+    worldMoveType_noClipping   = 1,
+    worldMoveType_fly          = 2,
+    worldMoveType_swim         = 3
+} worldMoveType;
+
+typedef struct {
+    vec3_t pos;
+} vertex_t;
+
+/*
+typedef struct {
+    vec2_t uv;
+} uv_t;
+
+typedef struct {
+    vec4_t rgba;
+} color_t;
+*/
+
+typedef struct {
+    vec2_t st;
+} texel_t;
+
+typedef struct {
+    int num_verts;      //!< 4 == Quad, 3 == Triangle, rendered as triangles
+    vertex_t vertex[4];
+    texel_t texel[4];
+    float pos[3];
+    float radius;       //!< \fixme yeah, I know
+    int texture;
+} sprite_t;
+
+typedef struct {
+    int num_sprites;
+    sprite_t *sprite;
+} sprite_seq_t;
+
+/*! \fixme For now shaders are textures on tex objects
+ * and materials on color objects. If -1
+ * then it doesn't have that information yet.
+ */
+typedef struct {
+    int index[3];
+    vec_t st[6];
+    int texture;
+    unsigned short transparency;
+} texture_tri_t;
+
+typedef struct {
+    std::vector<texture_tri_t *> texturedTriangles;
+    std::vector<texture_tri_t *> coloredTriangles;
+    std::vector<texture_tri_t *> texturedRectangles;
+    std::vector<texture_tri_t *> coloredRectangles;
+
+    vec3_t center;
+    float radius;
+
+    unsigned int vertexCount;
+    vec_t *vertices;
+
+    unsigned int colorCount;
+    vec_t *colors;
+
+    unsigned int normalCount;
+    vec_t *normals;
+} model_mesh_t;
+
+typedef struct entity_s {
+    int id;                  //!< Unique identifier
+    float pos[3];            //!< World position
+    float angles[3];         //!< Euler angles (pitch, yaw, roll)
+    int type;                //!< {(0x00, item), (0x01, ai), (0x02, player)}
+    int room;                //!< Current room entity is in
+    worldMoveType moveType;  //!< Type of motion/clipping
+    bool moving;             //!< In motion?
+    struct entity_s *master; //!< Part of entity chain?
+
+    int state;               //!< State of the Player, AI, or object
+    int objectId;            //!< What kind of entity?
+
+    int modelId;             //!< Animation model
+    void *tmpHook;
+    bool animate;
+
+    /*
+    float time, lastTime;
+    int state, lastState;
+    int event, lastEvent;
+    int goal;
+    */
+} entity_t;
+
+typedef struct {
+    int index;    //!< model_mesh index
+    float yaw;    //!< angle of rotation on Y
+    float pos[3]; //!< position
+
+    //vec3_t bboxMax;
+    //vec3_t bboxMin;
+} static_model_t;
+
+typedef struct {
+    float vertices[4][3];
+    float normal[3];
+    int adjoining_room;
+} portal_t;
+
+typedef struct {
+    vertex_t a;
+    vertex_t b;
+    vertex_t c;
+    vertex_t d;
+} box_t;
+
+typedef struct {
+    vec_t floor;
+    vec_t ceiling;
+
+    bool wall;
+} sector_t;
+
+//! \fixme No room mesh list or sprites and etc
+typedef struct {
+    std::vector<int> adjacentRooms;
+    std::vector<portal_t *> portals;
+    std::vector<static_model_t *> models;
+    std::vector<sprite_t *> sprites;
+    std::vector<box_t *> boxes;
+    std::vector<sector_t *> sectors;
+
+    int id;
+    unsigned int flags;
+    unsigned int numXSectors;
+    unsigned int numZSectors;
+    float pos[3];
+    vec3_t bbox_min;
+    vec3_t bbox_max;
+} room_mesh_t;
+
+// Workout generic entity and a client class from these entities
+typedef struct world_entity_s {
+    vec3_t pos;
+    vec3_t lastPos;
+    vec3_t angle;
+    vec_t ttl;
+
+    int type;
+    int state;
+
+    //struct world_entity_s *master;
+
+} world_entity_t;
+
+typedef struct {
+    vec3_t pos;
+    vec3_t lastPos;
+    vec3_t angle;
+    char clipping;
+    float time, eventTime, eventTimer;
+    int state, nextState;
+    float health;
+
+    // Client
+    unsigned int uid;
+    char name[32];
+    int actor, enemy;
+
+    // Render
+    unsigned int model;
+    unsigned int skin;
+    unsigned int animFrame;
+
+} actor_entity_t;
+
+enum OpenRaiderEvent {
+    eNone = 0,
+    eWeaponDischarge,
+    eDying,
+    eDead,
+    eWounded,
+    eRunForward,
+    eRunBackward,
+    eJump,
+    eCrouchWalk,
+    eIdle,
+    eTaunt,
+    eTurn,
+    eRespawn,
+    eLand
+};
+
+#endif
+

src/CMakeLists.txt

@@ -46,6 +46,7 @@ set (SRCS ${SRCS} "Texture.cpp")
 set (SRCS ${SRCS} "TombRaider.cpp")
 set (SRCS ${SRCS} "ViewVolume.cpp")
 set (SRCS ${SRCS} "Window.cpp")
+set (SRCS ${SRCS} "World.cpp")
 
 # Select available Windowing library
 if (SDL2_FOUND AND SDL2TTF_FOUND)

src/World.cpp

@@ -0,0 +1,767 @@
+/*!
+ * \file src/World.cpp
+ * \brief The game world (model)
+ *
+ * \author Mongoose
+ */
+
+#include <math.h>
+
+#include "World.h"
+
+
+////////////////////////////////////////////////////////////
+// Constructors
+////////////////////////////////////////////////////////////
+
+World::World()
+{
+    mClearLock = false;
+    mFlags = 0;
+}
+
+
+World::~World()
+{
+    destroy();
+}
+
+
+////////////////////////////////////////////////////////////
+// Public Accessors
+////////////////////////////////////////////////////////////
+
+int World::getRoomByLocation(int index, float x, float y, float z)
+{
+    room_mesh_t *room = mRooms[index];
+
+    if (room)
+    {
+        if (x > room->bbox_min[0] && x < room->bbox_max[0] &&
+                z > room->bbox_min[2] && z < room->bbox_max[2])
+        {
+            if (y > room->bbox_min[1] && y < room->bbox_max[1])
+                return index;
+        }
+    }
+
+    return getRoomByLocation(x, y, z);
+}
+
+
+int World::getRoomByLocation(float x, float y, float z)
+{
+    room_mesh_t *room;
+    int hop = -1;
+
+
+    for(std::vector<int>::size_type i = 0; i != mRooms.size(); i++)
+    {
+        room = mRooms[i];
+
+        if (!room)
+            continue;
+
+        if (x > room->bbox_min[0] && x < room->bbox_max[0] &&
+                z > room->bbox_min[2] && z < room->bbox_max[2])
+        {
+            // This room contains current position
+            if (y > room->bbox_min[1] && y < room->bbox_max[1])
+                return i;
+
+            // This room is above or below current position
+            hop = i;
+        }
+    }
+
+    // Room is -1?  Must be in void, try to hop to room with same X,Z
+    if (mFlags & fEnableHopping)
+        return hop;
+
+    return -1;
+}
+
+
+int World::getAdjoiningRoom(int index,
+        float x, float y, float z,
+        float x2, float y2, float z2)
+{
+    room_mesh_t *room = mRooms[index];
+    portal_t * portal;
+    vec3_t intersect, p1, p2;
+
+
+    p1[0] = x;  p1[1] = y;  p1[2] = z;
+    p2[0] = x2; p2[1] = y2; p2[2] = z2;
+
+    if (room)
+    {
+        for(std::vector<int>::size_type i = 0; i != room->portals.size(); i++)
+        {
+            portal = room->portals[i];
+
+            if (!portal)
+                continue;
+
+            if (intersectionLinePolygon(intersect, p1, p2, // 4,
+                        portal->vertices))
+            {
+                return portal->adjoining_room;
+            }
+        }
+    }
+
+    return -1;
+}
+
+
+int World::getSector(int room, float x, float z, float *floor, float *ceiling)
+{
+    room_mesh_t *r;
+    sector_t * s;
+    int sector;
+
+
+    r = mRooms[room];
+
+    if (!r)
+        return -1;
+
+    sector = (((((int)x - (int)r->pos[0]) / 1024) * r->numZSectors) +
+            (((int)z - (int)r->pos[2]) / 1024));
+
+    if (sector > -1)
+    {
+        s = r->sectors[sector];
+
+        if (!s)
+            return -1;
+
+        *floor = s->floor;
+        *ceiling = s->ceiling;
+    }
+
+    return sector;
+}
+
+
+int World::getSector(int room, float x, float z)
+{
+    int sector;
+    room_mesh_t *r;
+
+
+    r = mRooms[room];
+
+    if (!r)
+    {
+        return -1;
+    }
+
+    sector = (((((int)x - (int)r->pos[0]) / 1024) * r->numZSectors) +
+            (((int)z - (int)r->pos[2]) / 1024));
+
+    if (sector < 0)
+    {
+        return -1;
+    }
+
+    return sector;
+}
+
+
+unsigned int World::getRoomInfo(int room)
+{
+    room_mesh_t *r;
+
+
+    r = mRooms[room];
+
+    if (!r)
+    {
+        return 0;
+    }
+
+    return r->flags;
+}
+
+
+bool World::isWall(int room, int sector)
+{
+    room_mesh_t *r;
+    sector_t *sect;
+
+
+    r = mRooms[room];
+
+    if (!r)
+    {
+        return true;
+    }
+
+    sect = r->sectors[sector];
+
+    if (!sect)
+    {
+        return true;
+    }
+
+    return (sector > 0 && sect->wall);
+}
+
+
+bool World::getHeightAtPosition(int index, float x, float *y, float z)
+{
+    room_mesh_t *room = mRooms[index];
+
+#ifdef OBSOLETE_USING_BOXES
+    unsigned int i;
+    float zmax, xmax, zmin, xmin;
+
+
+    if (!room)
+    {
+        return false;
+    }
+
+    // Mongoose 2002.08.14, It's 0302 - give me a fucking break --
+    //   this works albeit poorly  =)
+    for (i = 0; (int)i < room->num_boxes; ++i)
+    {
+        xmax = room->boxes[i].c.pos[0];
+        xmin = room->boxes[i].a.pos[0];
+        zmax = room->boxes[i].c.pos[2];
+        zmin = room->boxes[i].a.pos[2];
+
+        if (x < xmax && x > xmin && z < zmax && z > zmin)
+        {
+            //printf("%f %f %f %f\n", xmax, xmin, zmax, zmin);
+
+            *y =  room->boxes[i].a.pos[1]; // hhmm...room->pos[1] +
+            return true;
+        }
+    }
+
+    return false;
+#else
+    int sector;
+    sector_t *sect;
+
+
+    if (!room)
+    {
+        return false;
+    }
+
+    // Mongoose 2002.08.14, Remember sector_z is width of sector array
+    sector = getSector(index, x, z);
+
+    sect = room->sectors[sector];
+
+    if (!sect)
+    {
+        return true;
+    }
+
+    *y = sect->floor;
+
+    return true;
+#endif
+}
+
+
+// Temp methods for rendering use until more refactoring is done
+#ifdef BAD_BLOOD
+model_mesh_t *World::getMesh(int index)
+{
+    return mMeshes[index];
+}
+
+skeletal_model_t *World::getModel(int index)
+{
+    return mModels[index];
+}
+
+room_mesh_t *World::getRoom(int index)
+{
+    return mRooms[index];
+}
+
+std::vector<entity_t *> *World::getEntities()
+{
+    return &mEntities;
+}
+
+std::vector<sprite_seq_t *> *World::getSprites()
+{
+    return &mSprites;
+}
+
+std::vector<room_mesh_t *> *World::getRooms()
+{
+    return &mRooms;
+}
+#endif
+
+
+////////////////////////////////////////////////////////////
+// Public Mutators
+////////////////////////////////////////////////////////////
+
+void World::setFlag(WorldFlag flag)
+{
+    mFlags |= flag;
+}
+
+
+
+void World::clearFlag(WorldFlag flag)
+{
+    mFlags |= flag;
+    mFlags ^= flag;
+}
+
+
+void World::destroy()
+{
+    // Add some locking to check use state first
+    if (!mClearLock)
+    {
+        clear();
+    }
+}
+
+
+void World::addRoom(room_mesh_t *room)
+{
+    mClearLock = false;
+    mRooms.push_back(room);
+}
+
+
+void World::addMesh(model_mesh_t *mesh)
+{
+    if (mesh)
+    {
+        mClearLock = false;
+        mMeshes.push_back(mesh);
+    }
+}
+
+
+void World::addEntity(entity_t *e)
+{
+    if (e)
+    {
+        mClearLock = false;
+        e->master = 0x0;
+        e->moveType = worldMoveType_walk; // Walk
+        e->room = getRoomByLocation(e->pos[0], e->pos[1], e->pos[2]);
+        mEntities.push_back(e);
+    }
+}
+
+
+int World::addModel(skeletal_model_t *model)
+{
+    if (model)
+    {
+        mClearLock = false;
+        mModels.push_back(model);
+        return mModels.size() - 1;
+    }
+
+    return -1;
+}
+
+
+void World::addSprite(sprite_seq_t *sprite)
+{
+    if (sprite)
+    {
+        mClearLock = false;
+        mSprites.push_back(sprite);
+    }
+}
+
+
+void World::moveEntity(entity_t *e, char movement)
+{
+    const float moved = 180.0f;
+    const float testd = 220.0f;
+    const float camHeight = 8.0f;
+    float x, y, z, pitch, h, floor, ceiling;
+    int room, sector;
+    bool wall;
+    unsigned int roomFlags;
+
+
+    if (!e)
+    {
+        return;
+    }
+
+    switch (e->moveType)
+    {
+        case worldMoveType_walkNoSwim:
+        case worldMoveType_walk:
+            pitch = 0.0f;  // in the future pitch could control jump up blocks here
+            break;
+
+        case worldMoveType_noClipping:
+        case worldMoveType_fly:
+        case worldMoveType_swim:
+            pitch = e->angles[2];
+            break;
+    }
+
+    switch (movement)
+    {
+        case 'f':
+            x = e->pos[0] + (testd * sinf(e->angles[1]));
+            y = e->pos[1] + (testd * sinf(pitch));
+            z = e->pos[2] + (testd * cosf(e->angles[1]));
+            break;
+        case 'b':
+            x = e->pos[0] - (testd * sinf(e->angles[1]));
+            y = e->pos[1] - (testd * sinf(pitch));
+            z = e->pos[2] - (testd * cosf(e->angles[1]));
+            break;
+        case 'l':
+            x = e->pos[0] - (testd * sinf(e->angles[1] + 90.0f));
+            y = e->pos[1];
+            z = e->pos[2] - (testd * cosf(e->angles[1] + 90.0f));
+            break;
+        case 'r':
+            x = e->pos[0] + (testd * sinf(e->angles[1] + 90.0f));
+            y = e->pos[1];
+            z = e->pos[2] + (testd * cosf(e->angles[1] + 90.0f));
+            break;
+        default:
+            return;
+    }
+
+    //room = getRoomByLocation(x, y, z);
+    room = getRoomByLocation(e->room, x, y, z);
+
+    if (room == -1) // Will we hit a portal?
+    {
+#define ADJ_ROOM_CHECK
+#ifdef ADJ_ROOM_CHECK
+        room = getAdjoiningRoom(e->room,
+                e->pos[0],  e->pos[1], e->pos[2],
+                x, y, z);
+#else
+        if (!mFlags & fEnableHopping)
+        {
+            mFlags |= fEnableHopping;
+            room = getRoomByLocation(e->room, x, y, z);
+            printf("Hopped\n");
+            mFlags ^= fEnableHopping;
+        }
+
+        //room = getRoomByLocation(x, y, z);
+#endif
+
+        if (room > -1)
+        {
+            printf("Crossing from room %i to %i\n", e->room, room);
+        }
+    }
+
+    roomFlags = getRoomInfo(room);
+    sector = getSector(room, x, z, &floor, &ceiling);
+    wall = isWall(room, sector);
+
+    // If you're underwater you may want to swim  =)
+    // ...if you're worldMoveType_walkNoSwim, you better hope it's shallow
+    if (roomFlags & roomFlag_underWater && e->moveType == worldMoveType_walk)
+    {
+        e->moveType = worldMoveType_swim;
+    }
+
+    // Don't swim on land
+    if (!(roomFlags & roomFlag_underWater) && e->moveType == worldMoveType_swim)
+    {
+        e->moveType = worldMoveType_walk;
+    }
+
+    // Mongoose 2002.09.02, Add check for room -> room transition
+    //   ( Only allow by movement between rooms by using portals )
+    if (((e->moveType == worldMoveType_noClipping) ||
+                (e->moveType == worldMoveType_fly) ||
+                (e->moveType == worldMoveType_swim)) ||
+            ((room > -1) && (!wall)))
+    {
+        e->room = room;
+
+        switch (movement)
+        {
+            case 'f':
+                x = e->pos[0] + (moved * sinf(e->angles[1]));
+                y = e->pos[1] + (moved * sinf(pitch));
+                z = e->pos[2] + (moved * cosf(e->angles[1]));
+                break;
+            case 'b':
+                x = e->pos[0] - (moved * sinf(e->angles[1]));
+                y = e->pos[1] - (moved * sinf(pitch));
+                z = e->pos[2] - (moved * cosf(e->angles[1]));
+                break;
+            case 'l':
+                x = e->pos[0] - (moved * sinf(e->angles[1] + 90.0f));
+                z = e->pos[2] - (moved * cosf(e->angles[1] + 90.0f));
+                break;
+            case 'r':
+                x = e->pos[0] + (moved * sinf(e->angles[1] + 90.0f));
+                z = e->pos[2] + (moved * cosf(e->angles[1] + 90.0f));
+                break;
+        }
+
+        /*! \fixme Test for vector (move vector) / plane (portal) collision here
+         * to see if we need to switch rooms... man...
+         */
+
+        h = y;
+        getHeightAtPosition(room, x, &h, z);
+
+        switch (e->moveType)
+        {
+            case worldMoveType_fly:
+            case worldMoveType_swim:
+#ifdef DIVE_GAP
+                // Clips to top of water, waiting for DIVE event
+                if (h < floor)
+                    e->pos[1] = floor;
+                else if (h > ceiling)
+                    e->pos[1] = ceiling;
+                else
+                    e->pos[1] = y;
+#endif
+
+                // Don't fall out of world, avoid a movement that does
+                if (h > y - camHeight)
+                {
+                    e->pos[0] = x;
+                    e->pos[1] = y;
+                    e->pos[2] = z;
+                }
+                break;
+            case worldMoveType_walk:
+            case worldMoveType_walkNoSwim:
+                y = e->pos[1];  // Override vector movement walking ( er, not pretty )
+
+                // Now fake gravity
+                // Mongoose 2002.08.14, Remember TR is upside down ( you fall 'up' )
+
+                //ddist = h - e->pos[1];
+
+                // This is to force false gravity, by making camera stay on ground
+                e->pos[1] = h; //roomFloor->bbox_min[1];
+
+                // Check for camera below terrian and correct
+                if (e->pos[1] < h - camHeight)
+                {
+                    e->pos[1] = h - camHeight;
+                }
+
+                e->pos[0] = x;
+                e->pos[2] = z;
+                break;
+            case worldMoveType_noClipping:
+                e->pos[0] = x;
+                e->pos[1] = y;
+                e->pos[2] = z;
+        }
+
+#ifdef OBSOLETE
+        m_text->SetString(1,"Room %2i  Sector %2i %sPos %.0f %.0f %.0f Yaw %.0f",
+                room, sector,
+                wall ? " Wall " : " ",
+                e->pos[0], e->pos[1], e->pos[2], e->angles[1]);
+#endif
+    }
+    else
+    {
+        e->moving = false;
+        return;
+    }
+
+    e->room = room;
+    e->moving = true;
+}
+
+
+////////////////////////////////////////////////////////////
+// Private Accessors
+////////////////////////////////////////////////////////////
+
+
+////////////////////////////////////////////////////////////
+// Private Mutators
+////////////////////////////////////////////////////////////
+
+void World::clear()
+{
+    room_mesh_t *room;
+    model_mesh_t *mesh;
+    sprite_seq_t *sprite;
+    skeletal_model_t *model;
+    bone_frame_t *boneframe;
+    bone_tag_t *tag;
+    animation_frame_t *animation;
+    std::list<skeletal_model_t *> cache;
+
+    mClearLock = true;
+
+    for (std::vector<int>::size_type i = 0; i != mEntities.size(); i++)
+        delete mEntities[i];
+    mEntities.clear();
+
+    for (std::vector<int>::size_type i = 0; i != mRooms.size(); i++) {
+        room = mRooms[i];
+
+        if (room) {
+            for (std::vector<int>::size_type j = 0; j != room->portals.size(); j++)
+                delete room->portals[i];
+            room->portals.clear();
+
+            for (std::vector<int>::size_type j = 0; j != room->models.size(); j++)
+                delete room->models[i];
+            room->models.clear();
+
+            for (std::vector<int>::size_type j = 0; j != room->sprites.size(); j++)
+                delete room->sprites[i];
+            room->sprites.clear();
+
+            for (std::vector<int>::size_type j = 0; j != room->sectors.size(); j++)
+                delete room->sectors[i];
+            room->sectors.clear();
+
+            for (std::vector<int>::size_type j = 0; j != room->boxes.size(); j++)
+                delete room->boxes[i];
+            room->boxes.clear();
+
+            delete room;
+        }
+    }
+
+    for (std::vector<int>::size_type i = 0; i != mMeshes.size(); i++) {
+        mesh = mMeshes[i];
+
+        if (!mesh)
+            continue;
+
+        for (std::vector<int>::size_type j = 0; j != mesh->texturedTriangles.size(); j++)
+        {
+            if (mesh->texturedTriangles[j])
+                delete mesh->texturedTriangles[j];
+        }
+
+        for (std::vector<int>::size_type j = 0; j != mesh->coloredTriangles.size(); j++)
+        {
+            if (mesh->coloredTriangles[j])
+                delete mesh->coloredTriangles[j];
+        }
+
+        for (std::vector<int>::size_type j = 0; j != mesh->texturedRectangles.size(); j++)
+        {
+            if (mesh->texturedRectangles[j])
+                delete mesh->texturedRectangles[j];
+        }
+
+        for (std::vector<int>::size_type j = 0; j != mesh->coloredRectangles.size(); j++)
+        {
+            if (mesh->coloredRectangles[j])
+                delete mesh->coloredRectangles[j];
+        }
+
+        if (mesh->vertices)
+            delete [] mesh->vertices;
+
+        if (mesh->colors)
+            delete [] mesh->colors;
+
+        if (mesh->normals)
+            delete [] mesh->normals;
+
+        delete mesh;
+    }
+
+    mMeshes.clear();
+
+    for (std::vector<int>::size_type i = 0; i != mSprites.size(); i++)
+    {
+        sprite = mSprites[i];
+
+        if (!sprite)
+            continue;
+
+        if (sprite->sprite)
+            delete [] sprite->sprite;
+
+        delete sprite;
+    }
+
+    mSprites.clear();
+
+    for (std::vector<int>::size_type i = 0; i != mModels.size(); i++)
+    {
+        model = mModels[i];
+
+        if (!model)
+            continue;
+
+        // No smart pointers, so skip if deleted once  =)
+        bool found = false;
+        for (std::list<skeletal_model_t *>::const_iterator iterator = cache.begin(), end = cache.end(); iterator != end; ++iterator) {
+            if (model == *iterator) {
+                found = true;
+                break;
+            }
+        }
+
+        if (!found)
+        {
+            cache.push_back(model);
+        }
+        else
+        {
+            continue;
+        }
+
+        for (std::vector<int>::size_type j = 0; j != model->animation.size(); j++)
+        {
+            animation  = model->animation[j];
+
+            if (!animation)
+                continue;
+
+            for (std::vector<int>::size_type k = 0; k != animation->frame.size(); k++)
+            {
+                boneframe = animation->frame[k];
+
+                if (!boneframe)
+                    continue;
+
+                for (std::vector<int>::size_type l = 0; l != boneframe->tag.size(); l++)
+                {
+                    tag = boneframe->tag[l];
+
+                    if (!tag)
+                        continue;
+
+                    delete tag;
+                }
+
+                delete boneframe;
+            }
+
+            delete animation;
+        }
+
+        delete model;
+    }
+
+    mModels.clear();
+}
+