cMapMover.h

Go to the documentation of this file.

//
 
#ifndef _INC_CMapMover_H
#define _INC_CMapMover_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "GrayMapData.h"
#include "GrayLib/include/Math/cVector.h"
#include "GrayCore/include/cRefPtr.h"
 
namespace GrayMapData
{
        class cMapBase;
 
#define MAP_DIST_MIN                            0.0001f // smallest delta distance it is important to track. smaller would have lots of rounding error.
#define MAP_GRAVITY_ACCEL                       9.81f   // acceleration of gravity (Earth=9.8m/sec) (m/sec)
#define MAP_GRAVITY_TERMINAL            300.0f  // terminal velocity. TV of humans is about 55 instead of 40?
 
        enum MAPMOVER_TYPE
        {
 
                MAPMOVER_PlayerMove = -2,       
                MAPMOVER_PlayerTurn = -1,       
 
#define CMapMoverMode(a,b,c) MAPMOVER_##a,
#include "CMapMoverModes.tbl"
#undef CMapMoverMode
 
                MAPMOVER_QTY,
        };
 
        class GRAYMAPDATA_LINK CMapMovable
        {
 
        public:
                // m_bFlagCollide = do i collide with others. NOT exactly same as ! m_bFlagInsubstantial. similar but reverse perspective.
                // WHY is an object in motion blocking different from object at rest ?  m_bFlagCollide 
 
                bool                    m_bFlagCollide;                 // Test do i collide with world objects if i move. Not the same as !m_bFlagInsubstantial
 
                cVector3f               m_vEllipsoidRadius;             // x,y,z radius of the ellipsoid used for collision. may change as i move.
 
                bool                    m_bFlagTraction;                // Am i connected to the ground? (or my parent, other multi object, ship, building, etc) more than 'air' traction.
                float                   m_fTractionRatio;               // how efficiently you can apply your force to your current parent/surface to move. 1=perfect, 0=none.
 
                float                   m_fGravity;                             // how strong will gravity act on this? MAP_GRAVITY_ACCEL
 
        public:
                CMapMovable()
                        : m_bFlagCollide(false)
                        , m_vEllipsoidRadius(1.0f, 1.0f, 1.0f)
                        , m_bFlagTraction(false)
                        , m_fTractionRatio(1.0f) // 1 = non movable. 0 = non friction move. NOTE: 'in air' has some traction but very little.
                        , m_fGravity(MAP_GRAVITY_ACCEL)
                {
                        // NOTE: slow drop = add some m_fTractionRatio2
                }
 
                bool get_CanCollide() const
                {
                        // When i am in motion do i collide with others ?
                        return m_bFlagCollide;  // Can this collide into other things? when i move.
                }
                void put_CanCollide(bool bCanCollide)
                {
                        m_bFlagCollide = bCanCollide;
                }
        };
 
        class CMapMover : public cRefBase
        {
                //
                friend class cMapEntity;
        public:
                cVector3f               m_vPositionPrev;                
        private:
                cVector3f               m_vVelocity;                    
        public:
                // Collision system data
                TIMESYS_t               m_tGravitySkip;                 
 
                                                                                                // a force is acting on this entity. what type ?
                MAPMOVER_TYPE   m_eMoveMode;
                static const char* k_szModeNames[MAPMOVER_QTY + 1];     // name the mover modes for debug use.
 
                                                                                                                        // MAPMOVER_TYPE mode specific params:
                                                                                                                        // We MUST use continuous position calculated from hard time! NOT differential changes!
                float                   m_fMoveAngleOffset;             // offset moving by percentage of the loop cycle
                float                   m_fMoveSpeed;           // (Meters/sec)
                cVector3f               m_vMoveTarget;          // if MAPMOVER_Target or MAPMOVER_Circle center
                cVector3f               m_vMoveTargetStart;     // Beginning point of a loop, filled in only if we have an end
                cVector3f               m_vMoveTargetEnd;       // in the case of MAPMOVER_Circle, ending point of the center if you want it to move
                float                   m_fMoveTargetOffset;// offset the starting progress point of the radius (0.0 to 0.99)
                cVector3f               m_vMoveOrientation;     // vector rate of spin ? (radians/sec) i.e. the earth spins on its axis. (particle systems)
                float                   m_fMoveLoopTimeCur;             // amount of time i have been moving. (sec)
                float                   m_fMoveLoopTimeSpan;    // length of the stride. (seconds) (depends on current anim, Scale and move speed?)
 
                                                                                                //Note: these are public to allow access through scp files, but should use set functions to maintain correct values
                float                   m_fMoveRadius;                  // try to maintain this distance.
                float                   m_fMoveRadiusEnd;               // if entered, change to this distance and back over the defined loop time
                float                   m_fMoveRadiusOffset;    // starting progress offset for progression between radii (0.0 to 0.99)
                float                   m_fMoveCircumference;   // distance around the current loop
 
        public:
                CMapMover();
                ~CMapMover();
 
                void Mover_PushForce(const cVector3f& vForce);
                void Mover_TargetArbitrary(const cVector3f& vTarget, float fSpeed);
                void Mover_CircleArbitrary(const cVector3f& vCenter, float fSpeed, float fRadius);
 
                virtual bool FrameMoveMover(bool bRelative, float fElapsedTime); // call before physics
                virtual bool FrameMovePhysics(bool bRelative, float fTimeDelta);        // act on physics.
 
                void UpdateMoverParams(cMapEntity* pEntity);
 
                void put_MoverRadius(float fRadius)
                {
                        m_fMoveRadius = fRadius;
                        m_fMoveCircumference = cTypeF<float>::k_PI2*m_fMoveRadius;
                }
                void put_MoverCircumference(float fCirc)
                {
                        m_fMoveCircumference = fCirc;
                        m_fMoveRadius = m_fMoveCircumference / cTypeF<float>::k_PI2;
                }
                void check_Circumference()
                {
                        m_fMoveCircumference = cTypeF<float>::k_PI2*m_fMoveRadius;
                }
                float get_MoverRadius() const
                {
                        return m_fMoveRadius;
                }
                float get_MoverCircumference() const
                {
                        return m_fMoveCircumference;
                }
 
                const cVector3f& get_Velocity() const
                {
                        return m_vVelocity;
                }
                float get_VelX() const
                {
                        return m_vVelocity.get_X();
                }
                float get_VelY() const
                {
                        return m_vVelocity.get_Y();
                }
                float get_VelZ() const
                {
                        return m_vVelocity.get_Z();
                }
 
                void put_Velocity(const cVector3f& vVelocity)
                {
#ifdef _DEBUG
                        if (m_vVelocity == vVelocity)
                                return;
#endif
                        m_vVelocity = vVelocity;
                }
                void put_VelY(const float fVelY)
                {
#ifdef _DEBUG
                        if (m_vVelocity.y == fVelY)
                                return;
#endif
                        m_vVelocity.y = fVelY;
                }
                void Velocity_Clear()
                {
#ifdef _DEBUG
                        if (m_vVelocity.x == 0 && m_vVelocity.y == 0 && m_vVelocity.z == 0)
                                return;
#endif
                        m_vVelocity.SetZero();
                }
 
        };
 
        typedef cRefPtr<CMapMover> CMapMoverPtr;
};
 
#endif // _INC_CMapMover_H