Compiles up to Render

include/Entity.h

 #define _ENTITY_H_
 
 #include "math/math.h"
+#include "SkeletalModel.h"
 #include "TombRaider.h"
 
 class Entity {
 
     bool operator<(Entity &o);
     void display();
+    void move(char movement);
+    void print();
 
+    SkeletalModel &getModel();
     void setSkeletalModel(unsigned int model);
+    void setMoveType(MoveType m);
+    int getObjectId();
+    void setAngles(vec_t yaw, vec_t pitch);
+    vec_t getPos(unsigned int i);
+    vec_t getAngle(unsigned int i);
 
     // Animation State
-    unsigned int getAnimationFrame();
-    void setAnimationFrame(unsigned int index);
+    unsigned int getAnimation();
+    void setAnimation(unsigned int index);
     unsigned int getBoneFrame();
     void setBoneFrame(unsigned int index);
     unsigned int getIdleAnimation();

include/Render.h

 #include "math/Matrix.h"
 #include "ViewVolume.h"
 #include "World.h"
-#include "SkeletalModel.h"
 #include "Mesh.h"
 #include "Texture.h"
 #include "Camera.h"
 
     void setSkyMesh(int index, bool rot);
 
-    void addSkeletalModel(SkeletalModel *mdl);
-
     unsigned int getFlags();
 
     /*!
     //! \fixme should be private
 
     ViewVolume mViewVolume; //!< View Volume for frustum culling
-    std::vector<SkeletalModel *> mModels;
-    Texture mTexture;                     //!< Texture subsystem
+    Texture mTexture; //!< Texture subsystem
 
 private:
 

include/SkeletalModel.h

 
 class SkeletalModel {
 public:
-    SkeletalModel(TombRaider &tr, unsigned int index);
+    SkeletalModel(TombRaider &tr, unsigned int index, unsigned int i, int objectId);
     ~SkeletalModel();
     int getId();
+    void setPigTail(bool b);
+    void setPonyPos(vec_t x, vec_t y, vec_t z, vec_t angle);
 
     unsigned int size();
     AnimationFrame &get(unsigned int i);

include/World.h

     model_mesh_t *getMesh(int index);
 
     /*!
-     * \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);
-
-    /*!
      * \brief Find room a location is in.
      *
      * If it fails to be in a room it gives closest overlapping room.

src/Command.cpp

 
 #include "config.h"
 #include "Console.h"
+#include "Entity.h"
 #include "Game.h"
 #include "main.h"
 #include "math/math.h"
             if (getGame().isLoaded()) {
                 char *move = args->at(0);
                 if (strcmp(move, "walk") == 0) {
-                    getGame().mLara->moveType = worldMoveType_walk;
+                    getGame().getLara().setMoveType(Entity::MoveTypeWalk);
                     getConsole().print("Lara is walking...");
                 } else if (strcmp(move, "fly") == 0) {
-                    getGame().mLara->moveType = worldMoveType_fly;
+                    getGame().getLara().setMoveType(Entity::MoveTypeFly);
                     getConsole().print("Lara is flying...");
                 } else if (strcmp(move, "noclip") == 0) {
-                    getGame().mLara->moveType = worldMoveType_noClipping;
+                    getGame().getLara().setMoveType(Entity::MoveTypeNoClipping);
                     getConsole().print("Lara is noclipping...");
                 } else {
                     getConsole().print("Invalid use of move command (%s)!", move);
             if (c == 'n') {
                 // Step all skeletal models to their next animation
                 if (getRender().getFlags() & Render::fAnimateAllModels) {
-                    for (unsigned int i = 0; i < getRender().mModels.size(); i++) {
-                        SkeletalModel *m = getRender().mModels[i];
-                        if (m->getAnimation() < ((int)m->model->animation.size() - 1))
-                            m->setAnimation(m->getAnimation() + 1);
+                    for (unsigned int i = 0; i < getWorld().sizeEntity(); i++) {
+                        Entity &e = getWorld().getEntity(i);
+                        SkeletalModel &m = e.getModel();
+                        if (e.getAnimation() < (m.size() - 1))
+                            e.setAnimation(e.getAnimation() + 1);
                         else
-                            if (m->getAnimation() != 0)
-                                m->setAnimation(0);
+                            e.setAnimation(0);
                     }
                 } else {
                     getConsole().print("Animations need to be enabled!");
             } else if (c == 'p') {
                 // Step all skeletal models to their previous animation
                 if (getRender().getFlags() & Render::fAnimateAllModels) {
-                    for (unsigned int i = 0; i < getRender().mModels.size(); i++) {
-                        SkeletalModel *m = getRender().mModels[i];
-                        if (m->getAnimation() > 0)
-                            m->setAnimation(m->getAnimation() - 1);
+                    for (unsigned int i = 0; i < getWorld().sizeEntity(); i++) {
+                        Entity &e = getWorld().getEntity(i);
+                        SkeletalModel &m = e.getModel();
+                        if (e.getAnimation() > 0)
+                            e.setAnimation(e.getAnimation() - 1);
                         else
-                            if (m->model->animation.size() > 0)
-                                m->setAnimation(m->model->animation.size() - 1);
+                            if (m.size() > 0)
+                                e.setAnimation(m.size() - 1);
                     }
                 } else {
                     getConsole().print("Animations need to be enabled!");
             getConsole().print("Use viewmodel command interactively!");
             return -999;
         }
-        if (getGame().mLara) {
-            skeletal_model_t *mdl = getWorld().getModel(atoi(args->at(0)));
-            if (getGame().mLara->tmpHook)
-                getGame().mLara->tmpHook->setModel(mdl);
+        unsigned int n = atoi(args->at(0));
+        if (n < getWorld().sizeSkeletalModel())
+            getGame().getLara().setSkeletalModel(n);
+        else {
+            getConsole().print("Invalid SkeletalModel index!");
+            return -66;
         }
-        //m_render.ViewModel(LARA, atoi(cmd));
     } else if (strcmp(command, "pos") == 0) {
-        if (getGame().mLara) {
-            getConsole().print("Position:");
-            getConsole().print("  Room %i (0x%X)", getGame().mLara->room, getWorld().getRoomInfo(getGame().mLara->room));
-            getConsole().print("  %.1fx %.1fy %.1fz", getGame().mLara->pos[0], getGame().mLara->pos[1], getGame().mLara->pos[2]);
-            getConsole().print("  %.1f Yaw %.1f Pitch", OR_RAD_TO_DEG(getGame().mLara->angles[1]), OR_RAD_TO_DEG(getGame().mLara->angles[2]));
-        } else {
-            getConsole().print("Load a level to get Laras position!");
+        if ((!mRunning) || (!getGame().isLoaded())) {
+            getConsole().print("Use pos command interactively!");
             return -21;
         }
+        getGame().getLara().print();
     } else if (strcmp(command, "vmodel") == 0) {
         if (args->size() > 0) {
             bool b;
                 getConsole().print("Pass BOOL to pigtail command!");
                 return -46;
             }
-            SkeletalModel *tmp = getGame().mLara->tmpHook;
-            tmp->model->pigtails = b;
-            if (b) {
-                tmp->model->ponyOff -= 20;
-                tmp->model->ponytail[1] -= 32;
-            } else {
-                tmp->model->ponyOff += 20;
-                tmp->model->ponytail[1] += 32;
-            }
+            SkeletalModel &tmp = getGame().getLara().getModel();
+            tmp.setPigTail(b);
             getConsole().print("Pigtail is now %s", b ? "on" : "off");
         } else {
             getConsole().print("Invalid use of pigtail-command!");
             return -999;
         }
         if (args->size() > 3) {
-            SkeletalModel *tmp = getGame().mLara->tmpHook;
-            tmp->model->ponytail[0] = (float)atof(args->at(0));
-            tmp->model->ponytail[1] = (float)atof(args->at(1));
-            tmp->model->ponytail[2] = (float)atof(args->at(2));
-            tmp->model->ponytailAngle = (float)atof(args->at(3));
+            SkeletalModel &tmp = getGame().getLara().getModel();
+            tmp.setPonyPos((float)atof(args->at(0)), (float)atof(args->at(1)),
+                    (float)atof(args->at(2)), (float)atof(args->at(3)));
         } else {
             getConsole().print("Invalid use of ponypos-command!");
             return -48;

src/Entity.cpp

 #include "Entity.h"
 #include "main.h"
 
+#include "games/TombRaider1.h"
+
 Entity::Entity(TombRaider &tr, unsigned int index, unsigned int i, unsigned int model) {
     tr2_moveable_t *moveable = tr.Moveable();
     tr2_item_t *item = tr.Item();
     */
 }
 
+void Entity::move(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 roomNew, sector;
+    bool wall;
+    unsigned int roomFlags;
+
+    switch (moveType) {
+        case MoveTypeWalkNoSwim:
+        case MoveTypeWalk:
+            pitch = 0.0f; // in the future pitch could control jump up blocks here
+            break;
+
+        case MoveTypeNoClipping:
+        case MoveTypeFly:
+        case MoveTypeSwim:
+            pitch = angles[2];
+            break;
+    }
+
+    switch (movement) {
+        case 'f':
+            x = pos[0] + (testd * sinf(angles[1]));
+            y = pos[1] + (testd * sinf(pitch));
+            z = pos[2] + (testd * cosf(angles[1]));
+            break;
+        case 'b':
+            x = pos[0] - (testd * sinf(angles[1]));
+            y = pos[1] - (testd * sinf(pitch));
+            z = pos[2] - (testd * cosf(angles[1]));
+            break;
+        case 'l':
+            x = pos[0] - (testd * sinf(angles[1] + 90.0f));
+            y = pos[1];
+            z = pos[2] - (testd * cosf(angles[1] + 90.0f));
+            break;
+        case 'r':
+            x = pos[0] + (testd * sinf(angles[1] + 90.0f));
+            y = pos[1];
+            z = pos[2] + (testd * cosf(angles[1] + 90.0f));
+            break;
+        default:
+            return;
+    }
+
+    //room = getRoomByLocation(x, y, z);
+    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],
+                x, y, z);
+
+        if (roomNew > -1)
+            printf("Crossing from room %i to %i\n", room, roomNew);
+        else
+            //! \fixme mRooms, sectors, ... are now std::vector, but often upper bound checks are missing
+            return;
+    }
+
+    roomFlags = getWorld().getRoomInfo(roomNew);
+    sector = getWorld().getSector(roomNew, x, z, &floor, &ceiling);
+    wall = getWorld().isWall(roomNew, sector);
+
+    // If you're underwater you may want to swim  =)
+    // ...if you're worldMoveType_walkNoSwim, you better hope it's shallow
+    if ((roomFlags & RoomFlagUnderWater) && (moveType == MoveTypeWalk))
+        moveType = MoveTypeSwim;
+
+    // Don't swim on land
+    if (!(roomFlags & RoomFlagUnderWater) && (moveType == MoveTypeSwim))
+        moveType = MoveTypeWalk;
+
+    // Mongoose 2002.09.02, Add check for room -> room transition
+    // (Only allow by movement between rooms by using portals)
+    if (((moveType == MoveTypeNoClipping) ||
+                (moveType == MoveTypeFly) ||
+                (moveType == MoveTypeSwim)) ||
+            ((roomNew > -1) && (!wall))) {
+        room = roomNew;
+
+        switch (movement) {
+            case 'f':
+                x = pos[0] + (moved * sinf(angles[1]));
+                y = pos[1] + (moved * sinf(pitch));
+                z = pos[2] + (moved * cosf(angles[1]));
+                break;
+            case 'b':
+                x = pos[0] - (moved * sinf(angles[1]));
+                y = pos[1] - (moved * sinf(pitch));
+                z = pos[2] - (moved * cosf(angles[1]));
+                break;
+            case 'l':
+                x = pos[0] - (moved * sinf(angles[1] + 90.0f));
+                z = pos[2] - (moved * cosf(angles[1] + 90.0f));
+                break;
+            case 'r':
+                x = pos[0] + (moved * sinf(angles[1] + 90.0f));
+                z = pos[2] + (moved * cosf(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;
+        getWorld().getHeightAtPosition(room, x, &h, z);
+
+        switch (moveType) {
+            case MoveTypeFly:
+            case MoveTypeSwim:
+                // Don't fall out of world, avoid a movement that does
+                if (h > y - camHeight) {
+                    pos[0] = x;
+                    pos[1] = y;
+                    pos[2] = z;
+                }
+                break;
+
+            case MoveTypeWalk:
+            case MoveTypeWalkNoSwim:
+                y = 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 - pos[1];
+
+                // This is to force false gravity, by making camera stay on ground
+                pos[1] = h; //roomFloor->bbox_min[1];
+
+                // Check for camera below terrian and correct
+                if (pos[1] < h - camHeight)
+                    pos[1] = h - camHeight;
+
+                pos[0] = x;
+                pos[2] = z;
+                break;
+
+            case MoveTypeNoClipping:
+                pos[0] = x;
+                pos[1] = y;
+                pos[2] = z;
+                break;
+        }
+    }
+}
+
+void Entity::print() {
+    getConsole().print("Entity %d:", objectId);
+    getConsole().print("  Room %i (0x%X)", room, getWorld().getRoomInfo(room));
+    getConsole().print("  %.1fx %.1fy %.1fz", pos[0], pos[1], pos[2]);
+    getConsole().print("  %.1f Yaw %.1f Pitch", OR_RAD_TO_DEG(angles[1]), OR_RAD_TO_DEG(angles[2]));
+}
+
 void Entity::setSkeletalModel(unsigned int model) {
     skeletalModel = model;
     animationFrame = 0;
     idleAnimation = 0;
 }
 
-unsigned int Entity::getAnimationFrame() {
+unsigned int Entity::getAnimation() {
     return animationFrame;
 }
 
-void Entity::setAnimationFrame(unsigned int index) {
+void Entity::setAnimation(unsigned int index) {
     animationFrame = index;
     boneFrame = 0;
 }

src/Game.cpp

 #include <algorithm>
 #include <map>
 #include <cstdlib>
+#include <assert.h>
 
 #include "main.h"
 #include "Console.h"
 void Game::destroy() {
     if (mName)
         delete [] mName;
-
+    mName = NULL;
     mLoaded = false;
-    mLara = NULL;
+    mLara = -1;
     getRender().setMode(Render::modeDisabled);
 
     getWorld().destroy();
     mTombRaider.reset();
 
     // Check if the level contains Lara
-    if (mLara == NULL) {
+    if (mLara == -1) {
         getConsole().print("Can't find Lara entity in level pak!");
         return -1;
     }
 void Game::handleAction(ActionEvents action, bool isFinished) {
     if (mLoaded) {
         if (action == forwardAction) {
-            getWorld().moveEntity(mLara, 'f');
+            getLara().move('f');
         } else if (action == backwardAction) {
-            getWorld().moveEntity(mLara, 'b');
+            getLara().move('b');
         } else if (action == leftAction) {
-            getWorld().moveEntity(mLara, 'l');
+            getLara().move('l');
         } else if (action == rightAction) {
-            getWorld().moveEntity(mLara, 'r');
+            getLara().move('r');
         }
     }
 }
                 getCamera().command(CAMERA_ROTATE_DOWN);
 
         // Fix Laras rotation
-        mLara->angles[1] = getCamera().getRadianYaw();
-        mLara->angles[2] = getCamera().getRadianPitch();
+        getLara().setAngles(getCamera().getRadianYaw(), getCamera().getRadianPitch());
     }
 }
 
 Entity &Game::getLara() {
-    assert(mLara < getWorld().sizeEntity());
+    assert(mLara >= 0);
+    assert(mLara < (int)getWorld().sizeEntity());
     return getWorld().getEntity(mLara);
 }
 
     bool cached = false;
     unsigned int mod = 0;
     for (; mod < getWorld().sizeSkeletalModel(); mod++) {
-        if (getWorld().getSkeletalModel(mod).getId() == moveable[index].object_id) {
+        if (getWorld().getSkeletalModel(mod).getId() == object_id) {
             cached = true;
             break;
         }
     }
 
     if (!cached) {
-        getWorld().addSkeletalModel(*new SkeletalModel(mTombRaider, index, i));
+        getWorld().addSkeletalModel(*new SkeletalModel(mTombRaider, index, i, object_id));
     }
 
     getWorld().addEntity(*new Entity(mTombRaider, index, i, mod));

src/OpenRaider.cpp

     if (getGame().isLoaded()) {
         for (int i = 0; i < 3; i++) {
             getWindow().drawText(10, getWindow().mHeight - ((4 - i) * 20), 0.5f, OR_BLUE, "%.2f (%.2f)",
-                getGame().mLara->pos[i] / 256.0f, getGame().mLara->angles[i]);
+                getGame().getLara().getPos(i) / 256.0f, getGame().getLara().getAngle(i));
         }
     }
 #endif

src/SkeletalModel.cpp

     frame.push_back(&b);
 }
 
-SkeletalModel::SkeletalModel(TombRaider &tr, unsigned int index, unsigned int i) {
+SkeletalModel::SkeletalModel(TombRaider &tr, unsigned int index, unsigned int i, int objectId) {
     tr2_moveable_t *moveable = mTombRaider.Moveable();
     tr2_animation_t *anim = mTombRaider.Animation();
 
-    id = moveable[index].object_id;
+    id = objectId;
 
     // Gather more info if this is lara
     if (id == 0) {
     return id;
 }
 
+void SkeletalModel::setPigTail(bool b) {
+    pigtails = b;
+    if (b) {
+        ponyOff -= 20;
+        ponytail[1] -= 32;
+    } else {
+        ponyOff += 20;
+        ponytail[1] += 32;
+    }
+}
+
 unsigned int SkeletalModel::size() {
     return animation.size();
 }

src/World.cpp

         mMeshes.push_back(mesh);
 }
 
-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?
-    {
-        room = getAdjoiningRoom(e->room,
-                e->pos[0],  e->pos[1], e->pos[2],
-                x, y, z);
-
-        if (room > -1)
-        {
-            printf("Crossing from room %i to %i\n", e->room, room);
-        } else {
-            //! \fixme mRooms, sectors, ... are now std::vector, but often upper bound checks are missing
-            return;
-        }
-    }
-
-    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 & RoomFlagUnderWater && e->moveType == worldMoveType_walk)
-        e->moveType = worldMoveType_swim;
-
-    // Don't swim on land
-    if (!(roomFlags & RoomFlagUnderWater) && 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:
-                // 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;
-        }
-    }
-    else
-    {
-        return;
-    }
-
-    e->room = room;
-}
-
-
 void World::addRoom(Room &room) {
     mRooms.push_back(&room);
 }