Added walk action. No longer crashes in World::isWall()

ChangeLog.md

 
 ## OpenRaider (0.1.3) xythobuz <xythobuz@xythobuz.de>
 
+    [ 20140519 ]
+    * No longer crashes simply by walking in the wrong place
+    * Added walk Action, supposed to switch to slow walking/sidesteps
+    * Removed unused Camera functionality (side and up vector)
+
     [ 20140517 ]
     * Wrote new assert() implementation for Unix that prints a call stack
     * Service provider methods (getCamera(), etc...) are now prototyped

data/OpenRaider.ini

 bind crouch   "leftctrl"
 bind use      "leftmouse"
 bind holster  "rightmouse"
+bind walk     "leftshift"

include/Camera.h

 #define _CAMERA_H_
 
 #include "math/math.h"
-#include "math/Matrix.h"
 #include "math/Quaternion.h"
 
 /*!
     Camera();
 
     /*!
-     * \brief Returns the current position
-     * \param pos where the position will be stored
-     */
-    void getPosition(vec3_t pos);
-
-    /*!
      * \brief Get the target currently looked at
      * \param target where the target will be stored
      */
     void command(enum camera_command cmd);
 
 private:
-    Quaternion mQ;                //!< Quaternion for rotation
-    vec_t mPos[4];                //!< Location in 3 space (aka eye)
-    vec_t mTarget[4];             //!< Postition we're looking at
-    vec_t mUp[4];                 //!< Up vector
-    vec_t mSide[4];               //!< Side vector
-    vec_t mViewDistance;          //!< Distance from target
-    vec_t mTheta;                 //!< View angle Y
-    vec_t mTheta2;                //!< View angle Z
-    vec_t mRotationDeltaX;
-    vec_t mRotationDeltaY;
+    Quaternion mQ;         //!< Quaternion for rotation
+    vec4_t mPos;           //!< Location in 3 space (aka eye)
+    vec4_t mTarget;        //!< Postition we're looking at
+    vec_t mViewDistance;   //!< Distance from target
+    vec_t mTheta;          //!< View angle Y
+    vec_t mTheta2;         //!< View angle Z
+    vec_t mRotationDeltaX; //!< Horizontal mouse sensitivity
+    vec_t mRotationDeltaY; //!< Vertical mouse sensitivity
 };
 
 Camera &getCamera();

include/global.h

     crouchAction,
     useAction,
     holsterAction,
+    walkAction,
 
     ActionEventCount // Should always be at the end
 } ActionEvents;

include/math/math.h

  * \author xythobuz
  */
 
-#include <math.h>
+#include <cmath>
 
 #ifndef _MATH_MATH_H
 #define _MATH_MATH_H

src/Camera.cpp

  * \author xythobuz
  */
 
-#include <stdio.h>
-#include <math.h>
-
 #include "global.h"
+#include "math/Matrix.h"
 #include "Camera.h"
 
 Camera::Camera() {
     mTarget[1] = 0.0f;
     mTarget[2] = mViewDistance;
 
-    mSide[0] = 1.0f;
-    mSide[1] = 0.0f;
-    mSide[2] = 0.0f;
-
-    mUp[0] = 0.0f;
-    mUp[1] = -1.0f; // 1.0f
-    mUp[2] = 0.0f;
-
     mQ.setIdentity();
 }
 
-void Camera::getPosition(vec3_t pos) {
-    pos[0] = mPos[0];
-    pos[1] = mPos[1];
-    pos[2] = mPos[2];
-}
-
 void Camera::getTarget(vec3_t target) {
     target[0] = mTarget[0];
     target[1] = mTarget[1];
 }
 
 void Camera::update() {
-    mTarget[2] = (mViewDistance * cosf(mTheta)) + mPos[2];
-    mTarget[0] = (mViewDistance * sinf(mTheta)) + mPos[0];
-    mTarget[1] = (mViewDistance * sinf(mTheta2)) + mPos[1]; // + height_offset;
+    mTarget[0] = (mViewDistance * std::sin(mTheta)) + mPos[0];
+    mTarget[1] = (mViewDistance * std::sin(mTheta2)) + mPos[1]; // + height_offset;
+    mTarget[2] = (mViewDistance * std::cos(mTheta)) + mPos[2];
 }
 
 void Camera::rotate(float angle, float x, float y, float z) {
     Quaternion t, n;
-    Matrix matrix;
-    vec_t side[4] = { 1.0f, 0.0f,  0.0f, 1.0f };
-    vec_t up[4] =   { 0.0f, 1.0f,  0.0f, 1.0f };
     vec_t look[4] = { 0.0f, 0.0f, -1.0f, 1.0f };
-    matrix_t m;
 
     t.set(angle, x, y, z);
     n = mQ * t;
     n.normalize();
 
-    n.getMatrix(m);
-    matrix.setMatrix(m);
-    matrix.multiply4v(side, mSide);
+    Matrix matrix(n);
     matrix.multiply4v(look, mTarget);
-    matrix.multiply4v(up, mUp);
 
-    for (int i = 0; i < 3; ++i) {
-        mSide[i] += mPos[i];
+    for (int i = 0; i < 3; ++i)
         mTarget[i] += mPos[i];
-        mUp[i] += mPos[i];
-    }
 
     mQ = n;
 }
 void Camera::command(enum camera_command cmd) {
     switch (cmd) {
         case CAMERA_ROTATE_UP:
-            if (mTheta2 < (M_PI / 2)) {
+            if (mTheta2 < (OR_PI / 2)) {
                 mTheta2 += mRotationDeltaY;
                 rotate(mTheta2, 1.0f, 0.0f, 0.0f);
             }
             break;
 
         case CAMERA_ROTATE_DOWN:
-            if (mTheta2 > -(M_PI / 2)) {
+            if (mTheta2 > -(OR_PI / 2)) {
                 mTheta2 -= mRotationDeltaY;
                 rotate(mTheta2, 1.0f, 0.0f, 0.0f);
             }

src/OpenRaider.cpp

         return bind(useAction, key);
     } else if (strcmp(tmp, "holster") == 0) {
         return bind(holsterAction, key);
+    } else if (strcmp(tmp, "walk") == 0) {
+        return bind(walkAction, key);
     } else {
         getConsole().print("bind-Error: Unknown action (%s --> %s)", key, action);
         return -1;

src/Render.cpp

         case Entity::MoveTypeFly:
         case Entity::MoveTypeNoClipping:
         case Entity::MoveTypeSwim:
-            camOffsetH = 64.0f;
+            //camOffsetH = 64.0f;
+            camOffsetH = 512.0f;
             break;
         case Entity::MoveTypeWalk:
         case Entity::MoveTypeWalkNoSwim:
     int sector = getWorld().getSector(index, camPos[0], camPos[2]);
 
     // Handle camera out of world
-    if (sector < 0 || getWorld().isWall(index, sector)) {
+    if ((sector < 0) ||
+            ((unsigned int)sector >= getWorld().getRoom(index).sizeSectors()) ||
+            getWorld().isWall(index, sector)) {
         camPos[0] = curPos[0] + (64.0f * sinf(yaw));
         camPos[1] -= 64.0f;
         camPos[2] = curPos[2] + (64.0f * cosf(yaw));