CharacterBody.h

/* ScummVM - Graphic Adventure Engine
 *
 * ScummVM is the legal property of its developers, whose names
 * are too numerous to list here. Please refer to the COPYRIGHT
 * file distributed with this source distribution.
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 */
 
/*
 * Copyright (C) 2006-2010 - Frictional Games
 *
 * This file is part of HPL1 Engine.
 */
 
#ifndef HPL_CHARACTER_BODY_H
#define HPL_CHARACTER_BODY_H
 
#include "hpl1/engine/math/MathTypes.h"
#include "hpl1/engine/physics/PhysicsWorld.h"
 
namespace hpl {
 
class iPhysicsWorld;
class iCollideShape;
class iPhysicsBody;
class cCamera3D;
class iCharacterBody;
class iEntity3D;
 
enum eCharDir {
    eCharDir_Forward = 0,
    eCharDir_Right = 1,
    eCharDir_LastEnum = 2
};
 
class iCharacterBodyCallback {
public:
    virtual ~iCharacterBodyCallback() = default;
    virtual void OnHitGround(iCharacterBody *apCharBody, const cVector3f &avVel) = 0;
    virtual void OnGravityCollide(iCharacterBody *apCharBody, iPhysicsBody *apCollideBody,
                                  cCollideData *apCollideData) = 0;
};
 
//------------------------------------------------
 
class cCharacterBodyRay : public iPhysicsRayCallback {
public:
    cCharacterBodyRay();
 
    void Clear();
    bool OnIntersect(iPhysicsBody *pBody, cPhysicsRayParams *apParams);
 
    float mfMinDist;
    bool mbCollide;
};
 
//------------------------------------------------
 
class cCharacterBodyCollideGravity : public iPhysicsWorldCollisionCallback {
public:
    cCharacterBodyCollideGravity();
 
    void OnCollision(iPhysicsBody *apBody, cCollideData *apCollideData);
 
    iCharacterBody *mpCharBody;
};
 
//------------------------------------------------
 
class cCharacterBodyCollidePush : public iPhysicsWorldCollisionCallback {
public:
    cCharacterBodyCollidePush();
 
    void OnCollision(iPhysicsBody *apBody, cCollideData *apCollideData);
 
    iCharacterBody *mpCharBody;
};
 
//-----------------------------------
 
kSaveData_BaseClass(iCharacterBody) {
    kSaveData_ClassInit(iCharacterBody) public : tString msName;
 
    float mfMass;
    bool mbGravityActive;
    float mfMaxGravitySpeed;
 
    bool mbActive;
 
    bool mbCollideCharacter;
 
    cVector3f mvPosition;
    cVector3f mvLastPosition;
    float mfMaxPosMoveSpeed[2];
    float mfMaxNegMoveSpeed[2];
    float mfMoveSpeed[2];
    float mfMoveAcc[2];
    float mfMoveDeacc[2];
    bool mbMoving[2];
 
    float mfPitch;
    float mfYaw;
 
    bool mbOnGround;
 
    float mfMaxPushMass;
    float mfPushForce;
    bool mbPushIn2D;
 
    cVector3f mvForce;
    cVector3f mvVelolcity;
 
    cVector3f mvSize;
 
    cMatrixf m_mtxMove;
 
    int mlEntityId;
    cMatrixf m_mtxEntityOffset;
    int mlEntitySmoothPosNum;
 
    float mfMaxStepHeight;
    float mfStepClimbSpeed;
    float mfClimbForwardMul;
    float mfClimbHeightAdd;
    bool mbClimbing;
 
    float mfGroundFriction;
    float mfAirFriction;
 
    int mlBodyId;
 
    cContainerList<int> mvExtraBodyIds;
 
    virtual iSaveObject *CreateSaveObject(cSaveObjectHandler * apSaveObjectHandler, cGame * apGame);
    virtual int GetSaveCreatePrio();
};
 
//------------------------------------------------
 
class iCharacterBody : public iSaveObject {
    typedef iSaveObject super;
    friend class cSaveData_iCharacterBody;
    friend class cCharacterBodyCollideGravity;
 
public:
    iCharacterBody(const tString &asName, iPhysicsWorld *apWorld, const cVector3f avSize);
    virtual ~iCharacterBody();
 
    const tString &GetName() { return msName; }
 
    // Properties
 
    float GetMass();
    void SetMass(float afMass);
 
    void SetActive(bool abX);
    bool IsActive() { return mbActive; }
 
    cVector3f GetSize();
 
    void SetCollideCharacter(bool abX);
    bool GetCollideCharacter() { return mbCollideCharacter; }
 
    void SetTestCollision(bool abX) { mbTestCollision = abX; }
    bool GetTestCollision() { return mbTestCollision; }
 
    void SetMaxPositiveMoveSpeed(eCharDir aDir, float afX);
    float GetMaxPositiveMoveSpeed(eCharDir aDir);
    void SetMaxNegativeMoveSpeed(eCharDir aDir, float afX);
    float GetMaxNegativeMoveSpeed(eCharDir aDir);
 
    void SetMoveSpeed(eCharDir aDir, float afX);
    float GetMoveSpeed(eCharDir aDir);
    void SetMoveAcc(eCharDir aDir, float afX);
    float GetMoveAcc(eCharDir aDir);
    void SetMoveDeacc(eCharDir aDir, float afX);
    float GetMoveDeacc(eCharDir aDir);
 
    cVector3f GetVelocity(float afFrameTime);
 
    void SetPosition(const cVector3f &avPos, bool abSmooth = false);
    const cVector3f &GetPosition();
    const cVector3f &GetLastPosition();
    void SetFeetPosition(const cVector3f &avPos, bool abSmooth = false);
    cVector3f GetFeetPosition();
 
    void SetYaw(float afX);
    void AddYaw(float afX);
    float GetYaw();
    void SetPitch(float afX);
    void AddPitch(float afX);
    float GetPitch();
 
    cVector3f GetForward();
    cVector3f GetRight();
    cVector3f GetUp();
 
    cMatrixf &GetMoveMatrix();
 
    void SetGravityActive(bool abX);
    bool GravityIsActive();
    void SetMaxGravitySpeed(float afX);
    float GetMaxGravitySpeed();
 
    bool GetCustomGravityActive();
    void SetCustomGravityActive(bool abX);
    void SetCustomGravity(const cVector3f &avCustomGravity);
    cVector3f GetCustomGravity();
 
    void SetMaxPushMass(float afX) { mfMaxPushMass = afX; }
    void SetPushForce(float afX) { mfPushForce = afX; }
    float GetMaxPushMass() { return mfMaxPushMass; }
    float GetPushForce() { return mfPushForce; }
 
    bool GetPushIn2D() { return mbPushIn2D; }
    void SetPushIn2D(bool abX) { mbPushIn2D = abX; }
 
    void AddForceVelocity(const cVector3f &avVel) { mvVelolcity += avVel; }
    void SetForceVelocity(const cVector3f &avVel) { mvVelolcity = avVel; }
    cVector3f GetForceVelocity() { return mvVelolcity; }
 
    int AddExtraSize(const cVector3f &avSize);
    void SetActiveSize(int alNum);
 
    // Actions
    void SetForce(const cVector3f &avForce);
    void AddForce(const cVector3f &avForce);
    cVector3f GetForce();
 
    void Move(eCharDir aDir, float afMul, float afTimeStep);
 
    void Update(float afTimeStep);
 
    // Other
    void SetCamera(cCamera3D *apCam);
    cCamera3D *GetCamera();
    void SetCameraPosAdd(const cVector3f &avAdd);
    cVector3f GetCameraPosAdd();
    void SetCameraSmoothPosNum(int alNum) { mlCameraSmoothPosNum = alNum; }
    int GetCameraSmoothPosNum() { return mlCameraSmoothPosNum; }
 
    void SetEntity(iEntity3D *apEntity);
    iEntity3D *GetEntity();
 
    void SetEntityOffset(const cMatrixf &a_mtxOffset);
    const cMatrixf &GetEntityOffset();
 
    void SetEntityPostOffset(const cMatrixf &a_mtxOffset);
    const cMatrixf &GetEntityPostOffset();
 
    void SetEntitySmoothPosNum(int alNum) { mlEntitySmoothPosNum = alNum; }
    int GetEntitySmoothPosNum() { return mlEntitySmoothPosNum; }
 
    void SetUserData(void *apUserData) { mpUserData = apUserData; }
    void *GetUserData() { return mpUserData; }
 
    void SetCallback(iCharacterBodyCallback *apCallback) { mpCallback = apCallback; }
 
    void SetEnableNearbyBodies(bool abX) { mbEnableNearbyBodies = abX; }
    bool GetEnableNearbyBodies() { return mbEnableNearbyBodies; }
 
    iPhysicsBody *GetBody() { return mpBody; }
    iCollideShape *GetShape();
 
    iPhysicsBody *GetExtraBody(size_t alIdx) { return mvExtraBodies[alIdx]; }
 
    bool IsOnGround();
 
    float GetMaxStepSize() { return mfMaxStepHeight; }
    void SetMaxStepSize(float afSize) { mfMaxStepHeight = afSize; }
 
    void SetStepClimbSpeed(float afX) { mfStepClimbSpeed = afX; }
    float GetStepClimbSpeed() { return mfStepClimbSpeed; }
 
    void SetAccurateClimbing(bool abX) { mbAccurateClimbing = abX; }
    bool GetAccurateClimbing() { return mbAccurateClimbing; }
 
    void SetClimbForwardMul(float afX) { mfClimbForwardMul = afX; }
    float GetClimbForwardMul() { return mfClimbForwardMul; }
 
    void SetClimbHeightAdd(float afX) { mfClimbHeightAdd = afX; }
    float GetClimbHeightAdd() { return mfClimbHeightAdd; }
 
    void SetGroundFriction(float afX) { mfGroundFriction = afX; }
    float GetGroundFriction() { return mfGroundFriction; }
 
    void SetAirFriction(float afX) { mfAirFriction = afX; }
    float GetAirFriction() { return mfAirFriction; }
 
    bool IsClimbing() { return mbClimbing; }
 
    void SetAttachedBody(iPhysicsBody *apBody);
    iPhysicsBody *GetAttachedBody() { return mpAttachedBody; }
 
    // O=nly sue when you know what you are doing, Update calls these
    void UpdateMoveMarix();
 
    void UpdateCamera();
    void UpdateEntity();
 
    void UpdateAttachment();
 
    // SaveObject implementation
    virtual iSaveData *CreateSaveData();
    virtual void SaveToSaveData(iSaveData *apSaveData);
    virtual void LoadFromSaveData(iSaveData *apSaveData);
    virtual void SaveDataSetup(cSaveObjectHandler *apSaveObjectHandler, cGame *apGame);
 
protected:
    tString msName;
 
    float mfMass;
 
    bool mbActive;
 
    bool mbCollideCharacter;
 
    bool mbTestCollision;
 
    bool mbGravityActive;
    float mfMaxGravitySpeed;
    bool mbCustomGravity;
    cVector3f mvCustomGravity;
 
    cVector3f mvPosition;
    cVector3f mvLastPosition;
 
    float mfMaxPosMoveSpeed[2];
    float mfMaxNegMoveSpeed[2];
 
    float mfMoveSpeed[2];
    float mfMoveAcc[2];
    float mfMoveDeacc[2];
    bool mbMoving[2];
 
    float mfPitch;
    float mfYaw;
 
    bool mbOnGround;
 
    float mfMaxPushMass;
    float mfPushForce;
    bool mbPushIn2D;
 
    float mfCheckStepClimbCount;
    float mfCheckStepClimbInterval;
 
    cVector3f mvForce;
    cVector3f mvVelolcity;
 
    cVector3f mvSize;
 
    cMatrixf m_mtxMove;
 
    cCamera3D *mpCamera;
    cVector3f mvCameraPosAdd;
    int mlCameraSmoothPosNum;
    tVector3fList mlstCameraPos;
 
    iEntity3D *mpEntity;
    cMatrixf m_mtxEntityOffset;
    cMatrixf m_mtxEntityPostOffset;
    int mlEntitySmoothPosNum;
    tVector3fList mlstEntityPos;
 
    float mfGroundFriction;
    float mfAirFriction;
 
    void *mpUserData;
 
    iPhysicsBody *mpAttachedBody;
    cMatrixf m_mtxAttachedPrevMatrix;
    bool mbAttachmentJustAdded;
 
    iCharacterBodyCallback *mpCallback;
 
    cCharacterBodyRay *mpRayCallback;
 
    cCharacterBodyCollideGravity *mpCollideCallbackGravity;
    cCharacterBodyCollidePush *mpCollideCallbackPush;
 
    float mfMaxStepHeight;
    float mfStepClimbSpeed;
    float mfClimbForwardMul;
    float mfClimbHeightAdd;
    bool mbClimbing;
    bool mbAccurateClimbing;
 
    bool mbEnableNearbyBodies;
 
    iPhysicsBody *mpBody;
    iPhysicsWorld *mpWorld;
 
    Common::Array<iPhysicsBody *> mvExtraBodies;
};
 
} // namespace hpl
 
#endif // HPL_CHARACTER_BODY_H