CWE-ou-minkata/MOULOpenSourceClientPlugin/Plasma20/Sources/Plasma/PubUtilLib/plAvatar/plPhysicalControllerCore.h

/*==LICENSE==*

CyanWorlds.com Engine - MMOG client, server and tools
Copyright (C) 2011  Cyan Worlds, Inc.

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/>.

You can contact Cyan Worlds, Inc. by email legal@cyan.com
 or by snail mail at:
      Cyan Worlds, Inc.
      14617 N Newport Hwy
      Mead, WA   99021

*==LICENSE==*/
#ifndef PLPHYSICALCONTROLLERCORE_H
#define PLPHYSICALCONTROLLERCORE_H
#include "hsGeometry3.h"
#include "hsMatrix44.h"
#include "hsTemplates.h"
#include "../pnKeyedObject/plKey.h"
#include "../plPhysical/plSimDefs.h"
#include "../pnMessage/plMessage.h"

#include "hsQuat.h"
#define PHYSX_ONLY_TRIGGER_FROM_KINEMATIC 1
#define kSLOPELIMIT (cosf(hsScalarDegToRad(55.f)))

class plCoordinateInterface;
class plPhysical;
class plPXPhysical;
class plSwimRegionInterface;
//Replacement for for plPhysicalController stripped out some walk specific code
//plPhysicalControllerCore needs to have movement strategies registered to it these will then
//be called by the controller during the simulation steps. The Strategies need to at least have an
// Apply and Update definition. Everything else should be movement specific. I hope to come back  and 
//and refactor when I have time this in the future. 
enum plControllerCollisionFlags
{	
	kSides=1,
	kTop= (1<<1),
	kBottom=(1<<2),
};

class plMovementStrategySimulationInterface
{
public:

	virtual void Apply(hsScalar delSecs)=0;
	virtual void Update(hsScalar delSecs)=0;
	//most strategies don't require this. Only the ones that require behavior like a physical or need
	//something after the sim step. this used to be taken care of by Update, but this was moved to take care of
	//some of the frame lag
	virtual void PostStep(hsScalar delSecs){};
	virtual void IAddContactNormals(hsVector3& vec){fContactNormals.Append(vec);}
	virtual void AddOnTopOfObject(plPhysical* phys){ fOnTopOf.Append(phys);}
	virtual void LeaveAge()
	{
		fContactNormals.SetCount(0);
		fOnTopOf.SetCount(0);
	}
protected:
	hsTArray<hsVector3> fContactNormals;
	hsTArray<plPhysical* > fOnTopOf;
};

class plControllerSweepRecord
{
public:
	plPhysical *ObjHit;
	hsPoint3 locHit;//World space
	hsScalar TimeHit;//Normalized between 0 and 1
	hsVector3 Norm;
};
bool operator<(const plControllerSweepRecord left, const plControllerSweepRecord right);
class plPhysicalControllerCore
{
public:
	virtual ~plPhysicalControllerCore();
	virtual void Move(hsVector3 displacement, unsigned int collideWith, unsigned int &collisionResults)=0;
	virtual void SetMovementSimulationInterface(plMovementStrategySimulationInterface* strat){fMovementInterface=strat;}
	virtual void Apply(hsScalar delSecs);
	virtual void Update(hsScalar delSecs);
	virtual void PostStep(hsScalar delSecs);
	// A disabled avatar doesn't move or accumulate air time if he's off the ground.
	virtual void Enable(bool enable) = 0;
	virtual bool IsEnabled() {return fEnabled;}
	virtual plKey GetSubworld() {return fWorldKey;}
	virtual void SetSubworld(plKey world) = 0;
	virtual const plCoordinateInterface* GetSubworldCI() const = 0;
	// For the avatar SDL only
	virtual void GetState(hsPoint3& pos, float& zRot) = 0;
	virtual void SetState(const hsPoint3& pos, float zRot) = 0;
	// kinematic stuff .... should be just for when playing a behavior...
	virtual void Kinematic(bool state) = 0;
	virtual bool IsKinematic() = 0;
	virtual void GetKinematicPosition(hsPoint3& pos) = 0;
	virtual const hsMatrix44& GetPrevSubworldW2L() = 0;
	//when seeking no longer want to interact with exclusion regions
	virtual void SetSeek(bool seek){fSeeking=seek;}
	virtual bool IsSeeking(){return fSeeking;}
	static plPhysicalControllerCore* Create(plKey ownerSO, hsScalar height, hsScalar radius);
	virtual plMovementStrategySimulationInterface* GetMovementInterface(){return fMovementInterface;}
	plPhysicalControllerCore(plKey ownerSceneObject, hsScalar height, hsScalar radius);
	virtual plKey GetOwner(){return fOwner;};
	// Set the LOS DB this avatar will be in (only one)
	virtual void SetLOSDB(plSimDefs::plLOSDB losDB) { fLOSDB = losDB; } ;
	virtual plSimDefs::plLOSDB GetLOSDB() {return fLOSDB ; } 
	virtual const hsMatrix44& GetLastGlobalLoc()=0;
	virtual void SetKinematicLoc(const hsMatrix44& l2w)=0;
	virtual void SetGlobalLoc(const hsMatrix44& l2w)=0;
	virtual bool IsEnabledChanged(){return fEnableChanged;}
	virtual void HandleEnableChanged()=0;
	virtual bool IsKinematicChanged(){return fKinematicChanged;}
	virtual void GetPositionSim(hsPoint3& pos)=0;
	virtual void HandleKinematicChanged()=0;
	virtual bool IsKinematicEnableNextUpdate(){return fKinematicEnableNextUpdate;}
	virtual void HandleKinematicEnableNextUpdate()=0;
	virtual void MoveKinematicToController(hsPoint3& pos)=0;
	virtual void UpdateControllerAndPhysicalRep()=0;
	virtual void CheckAndHandleAnyStateChanges();
	virtual void UpdateSubstepNonPhysical();
	virtual const hsPoint3& GetLocalPosition()=0;
	virtual void MoveActorToSim();
	
	virtual void OverrideAchievedVelocity(hsVector3 newAchievedVel)
	{//because of things like superjumps this is needed I'd rather not, but can't help it
		fAchievedLinearVelocity=newAchievedVel;
	}
	//any clean up for the controller should go here
	virtual void LeaveAge()=0;
	hsVector3  DisplacementLastStep(){return fDisplacementThisStep;}
	hsVector3  MeanVelocityForLastStep()
	{
		hsVector3 vel=fDisplacementThisStep;
		return vel/fSimLength;
	}
	void SendCorrectionMessages();
	void IncrementAngle(hsScalar deltaAngle);
	void UpdateWorldRelativePos();
	virtual void SetLinearVelocity(const hsVector3& linearVel){fLinearVelocity=linearVel;}
	//should actually be a 3 vector but everywhere else it is assumed to be just around  Z 
	virtual void SetAngularVelocity(const hsScalar angvel){	fAngularVelocity=angvel;}
	virtual void SetVelocities(const hsVector3& linearVel, hsScalar angVel)
	{
		fLinearVelocity=linearVel;
		fAngularVelocity=angVel;
	}
	
	virtual const hsVector3& GetLinearVelocity()  ;
	virtual hsScalar GetAngularVelocity(){return fAngularVelocity;}
	virtual const hsVector3& GetAchievedLinearVelocity()const {return fAchievedLinearVelocity;}
	plPhysical* GetPushingPhysical();
	bool GetFacingPushingPhysical();
	virtual void SetPushingPhysical(plPhysical* pl){fPushingPhysical=pl;}
	virtual void SetFacingPushingPhysical(bool ans){fFacingPushingPhysical=ans;}
	//To be Used during runtime conversions, say to switch a tall controller to a ball for swimming
	virtual void SetControllerDimensions(hsScalar radius, hsScalar height)=0;
	virtual hsScalar GetControllerWidth(){return fRadius;}
	virtual hsScalar GetControllerHeight(){return fHeight;}
	virtual void ResetAchievedLinearVelocity()
	{
		fAchievedLinearVelocity.Set(0.f,0.f,0.f);
	}
	virtual int SweepControllerPath(const hsPoint3& startPos,const hsPoint3& endPos, hsBool vsDynamics, hsBool vsStatics, UInt32& vsSimGroups, std::multiset< plControllerSweepRecord >& WhatWasHitOut)=0;
	//this should only be used to force a move it could place your head into a wall and that would be good
	virtual hsScalar GetHeight() {return fHeight;}
	virtual hsScalar GetRadius() {return fRadius;}
	//Wether the avatar thing has mass and forces things down or not, and changes the way things move
	//This is an attempt fix things like riding on an animated physical
	virtual void BehaveLikeAnimatedPhysical(hsBool actLikeAnAnimatedPhys)=0;
	virtual hsBool BehavingLikeAnAnimatedPhysical()=0;
protected:
	
	plKey fOwner;
	hsScalar fHeight;
	hsScalar fRadius;
	plKey fWorldKey;
	plSimDefs::plLOSDB fLOSDB;
	bool fSeeking;
	bool fEnabled;
    bool fEnableChanged;
	bool fKinematic;
	bool fKinematicEnableNextUpdate;
	bool fKinematicChanged;
	plMovementStrategySimulationInterface* fMovementInterface;
	hsMatrix44 fLastGlobalLoc;
	hsPoint3 fLocalPosition;
	hsQuat fLocalRotation;
	hsMatrix44 fPrevSubworldW2L;
	hsVector3 fDisplacementThisStep;
	hsScalar fSimLength;
	
	//physical properties
	hsVector3 fLinearVelocity;
	hsScalar fAngularVelocity;
	hsVector3 fAchievedLinearVelocity;
	plPhysical* fPushingPhysical;
	bool fFacingPushingPhysical;
	bool fNeedsResize;
};

class plMovementStrategy: public plMovementStrategySimulationInterface
{
public:
	virtual void SetControllerCore(plPhysicalControllerCore* core)
	{
		fCore=core;
		fCore->SetMovementSimulationInterface(this);
	}
	virtual void RefreshConnectionToControllerCore()
	{
		fCore->SetMovementSimulationInterface(this);
		//fCore->SetControllerDimensions(fPreferedControllerWidth,fPreferedControllerHeight);
		fCore->BehaveLikeAnimatedPhysical(this->IRequireBehaviourLikeAnAnimatedPhysical());
	}
	plMovementStrategy(plPhysicalControllerCore* core);
	//should actually be a 3 vector but everywhere else it is assumed to be just around  Z 
	virtual void SetLinearAcceleration(const hsVector3& accel){fLinearAcceleration=accel;}
	virtual const hsVector3& GetLinearAcceleration()const{return fLinearAcceleration;}
	//should actually be a 3 vector but everywhere else it is assumed to be just around  Z 
	virtual void ResetAchievedLinearVelocity()
	{
		hsVector3 AchievedLinearVelocity(0.f,0.f,0.f);
		if(fCore)fCore->OverrideAchievedVelocity(AchievedLinearVelocity);
	}
//proxy functions for Controller Core
	virtual hsScalar GetAirTime() const { return fTimeInAir; }
	virtual void ResetAirTime() { fTimeInAir = 0.f; }	
	
protected:
	virtual hsBool IRequireBehaviourLikeAnAnimatedPhysical()=0;
	virtual void IApplyKinematic();
	plPhysicalControllerCore* fCore;
	hsVector3 fLinearAcceleration;
	hsScalar fAngularAcceleration;
	plKey fOwner;
	static const hsScalar kAirTimeThreshold;
	hsScalar fTimeInAir;
	hsScalar fPreferedControllerWidth;
	hsScalar fPreferedControllerHeight;
	

};

class plWalkingStrategy: public plMovementStrategy
{
public:
	plWalkingStrategy(plPhysicalControllerCore* core):plMovementStrategy(core)
	{
		fGroundHit=false;
		fFalseGround=false;
		fHitHead=false;
		fCore->SetMovementSimulationInterface(this);
		fPreferedControllerWidth=core->GetControllerWidth();
		fPreferedControllerHeight=core->GetControllerHeight();
		fOnTopOfAnimatedPhysLastFrame=false;
	}
	virtual ~plWalkingStrategy(){};
	virtual void Apply(hsScalar delSecs);
	virtual void Update(hsScalar delSecs);		

	bool IsOnGround() const { return fTimeInAir < kAirTimeThreshold || fFalseGround; }
	bool IsOnFalseGround() const { return fFalseGround && !fGroundHit; }
	void GroundHit() { fGroundHit = true; }
	virtual void IAddContactNormals(hsVector3& vec);
	virtual void StartJump(){};
	

protected:
	
	void ICheckForFalseGround();
	bool fGroundHit;
	bool fFalseGround;
	bool fHitHead;
	bool fOnTopOfAnimatedPhysLastFrame;
	hsTArray<hsVector3> fPrevSlidingNormals;
	virtual hsBool IRequireBehaviourLikeAnAnimatedPhysical(){return true;}

};
class plSwimStrategy: public plMovementStrategy
{
public:
	plSwimStrategy(plPhysicalControllerCore *core);
	virtual ~plSwimStrategy(){};
	void SetSurface(plSwimRegionInterface *region, hsScalar surfaceHeight);
	virtual void Apply(hsScalar delSecs);
	virtual void Update(hsScalar delSecs);		
	hsScalar GetBuoyancy() { return fBuoyancy; }
	hsBool IsOnGround() { return fOnGround; }
	hsBool HadContacts() { return fHadContacts; }
	virtual void IAddContactNormals(hsVector3& vec);
protected:
	virtual hsBool IRequireBehaviourLikeAnAnimatedPhysical(){return true;}
private:
	void IAdjustBuoyancy();
	hsScalar fBuoyancy;
	hsBool fOnGround;
	hsBool fHadContacts;
	hsScalar fSurfaceHeight;
	plSwimRegionInterface *fCurrentRegion;
};
class plRidingAnimatedPhysicalStrategy : public plWalkingStrategy
{
public:
	plRidingAnimatedPhysicalStrategy(plPhysicalControllerCore *core ) : 
		fNeedVelocityOverride(false),fStartJump(false),plWalkingStrategy(core){};
	virtual ~plRidingAnimatedPhysicalStrategy(){};
	virtual void Apply(hsScalar delSecs);
	virtual void Update(hsScalar delSecs);	
	virtual void PostStep(hsScalar delSecs);
	bool IsOnGround() const { return fTimeInAir < kAirTimeThreshold || fFalseGround; }
	bool IsOnFalseGround() const { return fFalseGround && !fGroundHit; }
	void GroundHit() { fGroundHit = true; }
	virtual void StartJump(){fStartJump = true;}
protected:
	virtual hsBool IRequireBehaviourLikeAnAnimatedPhysical(){return false;}
	bool ICheckMove(const hsPoint3& startPos, const hsPoint3& desiredPos);
	hsBool fNeedVelocityOverride;
	hsVector3 fOverrideVelocity;
	bool fStartJump;
};
#endif// PLPHYSICALCONTROLLERCORE_H