scummvm/engines/hpl1/penumbra-overture/Player.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 Penumbra Overture.
 */

#ifndef GAME_PLAYER_H
#define GAME_PLAYER_H

#include "hpl1/engine/engine.h"

using namespace hpl;

#include "hpl1/penumbra-overture/GameTypes.h"

class cInit;
class iPlayerMoveState;
class iPlayerState;
class cPlayer;

class iPlayerWeaponCallback;
class cPlayerGroundRayCallback;
class cPlayerPickRayCallback;
class cPlayerHeadMove;
class cPlayerHealth;
class cPlayerEarRing;
class cPlayerLean;
class cPlayerDamage;
class cPlayerDeath;
class cPlayerFlashLight;
class cPlayerGlowStick;
class cPlayerFlare;
class cPlayerNoiseFilter;
class cPlayerFearFilter;
class cPlayerLookAt;
class cPlayerHidden;
class cPlayerAmbientLight;

class cPlayerBodyCallback;

typedef Common::Array<iPlayerState *> tPlayerStateVec;
typedef tPlayerStateVec::iterator tPlayerStateVecIt;

typedef Common::Array<iPlayerMoveState *> tPlayerMoveStateVec;
typedef tPlayerMoveStateVec::iterator tPlayerMoveStateVecIt;

class cInventoryItem;
class cPlayer_GlobalSave;
class cSavedWorld;

//---------------------------------------------

kSaveData_BaseClass(cPlayer) {
	kSaveData_ClassInit(cPlayer) public :

		int mlStat_NumOfSaves;

	cContainerList<cSaveGame_cGameCollideScript> mlstCollideCallbacks;

	virtual iSaveObject *CreateSaveObject(cSaveObjectHandler * apSaveObjectHandler, cGame * apGame);
	virtual int GetSaveCreatePrio();
};

//---------------------------------------------

class iPlayerMoveState {
public:
	iPlayerMoveState(cPlayer *apPlayer, cInit *apInit);
	virtual ~iPlayerMoveState() = default;

	void SetupBody();

	void InitState(iPlayerMoveState *apPrevState);

	void Update(float afTimeStep);

	void Stop();

	void Start();

	virtual void EnterState(iPlayerMoveState *apPrevState) {}
	virtual void LeaveState(iPlayerMoveState *apNextState) {}

	virtual void OnUpdate(float afTimeStep) {}

	bool mbActive;

	float mfForwardSpeed;
	float mfBackwardSpeed;
	float mfSidewaySpeed;

	float mfForwardAcc;
	float mfForwardDeacc;
	float mfSidewayAcc;
	float mfSidewayDeacc;

	float mfMaxHeadMove;
	float mfMinHeadMove;
	float mfHeadMoveSpeed;
	float mfHeadMoveBackSpeed;

	float mfFootStepMul;

	tString msStepType;

	float mfSpeedMul;

	float mfHeightAddCount;
	float mfHeightAdd;
	float mfHeightAddSpeed;

	cPlayer *mpPlayer;
	cPlayerHeadMove *mpHeadMove;

	cInit *mpInit;
	cConfigFile *mpGameConfig;

	ePlayerMoveState mPrevMoveState;

	ePlayerMoveState mType;
};
//---------------------------------------------

class cPlayer : public iUpdateable {
	friend class cSaveData_cPlayer;

public:
	cPlayer(cInit *apInit);
	~cPlayer();

	////////////////////////////////////////
	// Interaction

	void MoveForwards(float afMul, float afTimeStep);
	void MoveSideways(float afMul, float afTimeStep);
	void AddYaw(float afVal);
	void AddPitch(float afVal);
	void Lean(float afMul, float afTimeStep);

	void StartInteract();
	void StopInteract();
	void StartExamine();
	void StopExamine();
	void StartHolster();

	void Jump();

	void StartRun();
	void StopRun();

	void StartCrouch();
	void StopCrouch();

	void StartInteractMode();

	void StartInventory();

	void StartInventoryShortCut(int alNum);

	void StartFlashLightButton();

	void StartGlowStickButton();

	////////////////////////////////
	// Actions
	void SetStartPos(const tString &asName);

	void FootStep(float afMul, const tString &asType = "", bool abSkipCount = false);

	void ChangeState(ePlayerState aState);
	void ChangeMoveState(ePlayerMoveState aState, bool abSetHeadHeightDirectly = false);

	void AddCollideScript(eGameCollideScriptType aType, const tString &asFunc, const tString &asEntity);
	void RemoveCollideScript(eGameCollideScriptType aType, const tString &asFunc);
	void RemoveCollideScriptWithChildEntity(iGameEntity *apEntity);
	void ClearCollideScripts();

	void SetHealth(float afX);
	void AddHealth(float afX);
	float GetHealth() { return mfHealth; }
	void Damage(float afDamage, ePlayerDamageType aType);

	void DestroyWorldObjects();

	iSaveData *CreateSaveData();

	/////////////////////////////////////////
	// Events
	void OnWorldLoad();
	void OnWorldExit();
	void OnStart();
	void Update(float afTimeStep);
	void Reset();
	void OnDraw();
	void OnPostSceneDraw();

	/////////////////////////////////////////
	// Saving

	void AddSaveData(cSavedWorld *apSavedWorld);
	void LoadSaveData(cSavedWorld *apSavedWorld);

	void SaveToGlobal(cPlayer_GlobalSave *apSave);
	void LoadFromGlobal(cPlayer_GlobalSave *apSave);

	/////////////////////////////////////////
	// Properties
	bool IsDead();

	void SetActive(bool abActive);
	bool IsActive() { return mbActive; }

	void SetPushBody(iPhysicsBody *apBody) { mpPushBody = apBody; }
	iPhysicsBody *GetPushBody() { return mpPushBody; }

	float GetDefaultMass() { return mfDefaultMass; }

	float GetMass() { return mfMass; }
	void SetMass(float afX);

	void SetPower(float afX);
	void AddPower(float afX);
	float GetPower() { return mfPower; }

	iCharacterBody *GetCharacterBody() { return mpCharBody; }
	cCamera3D *GetCamera() { return mpCamera; }

	cVector3f GetSize() { return mvSize; }
	float GetCrouchHeight() { return mfCrouchHeight; }

	float GetMaxPushDist() { return mfMaxPushDist; }
	float GetMaxPushSpeed() { return mfMaxPushSpeed; }
	cVector2f GetMaxPushHeadMovement() { return mvMaxPushHeadMovement; }
	cVector2f GetMinPushHeadMovement() { return mvMinPushHeadMovement; }

	float GetMaxMoveDist() { return mfMaxMoveDist; }

	float GetMaxGrabDist() { return mfMaxGrabDist; }

	float GetMaxUseItemDist() { return mfMaxUseItemDist; }

	void SetPrevMoveState(ePlayerMoveState aState);
	iPlayerMoveState *GetMoveStateData(ePlayerMoveState aState) { return mvMoveStates[aState]; }
	ePlayerMoveState GetMoveState() { return mMoveState; }
	ePlayerState GetState() { return mState; }

	iPlayerState *GetStateData(ePlayerState aState) { return mvStates[aState]; }

	float GetSpeedMul() { return mfSpeedMul; }
	void SetSpeedMul(float afSpeedMul);

	float GetHealthSpeedMul() { return mfHealthSpeedMul; }
	void SetHealthSpeedMul(float afHealthSpeedMul);

	void SetHeadMoveSizeMul(float afX) { mfHeadMoveSizeMul = afX; }
	void SetHeadMoveSpeedMul(float afX) { mfHeadMoveSpeedMul = afX; }
	float GetHeadMoveSizeMul() { return mfHeadMoveSizeMul; }
	float GetHeadMoveSpeedMul() { return mfHeadMoveSpeedMul; }

	float GetLookSpeed() { return mfLookSpeed; }

	void SetCrossHairState(eCrossHairState aState) { mCrossHairState = aState; }
	eCrossHairState GetCrossHairState() { return mCrossHairState; }

	iPhysicsBody *GetPickedBody();
	void SetPickedBody(iPhysicsBody *apBody);
	float GetPickedDist();
	const cVector3f &GetPickedPos();
	cPlayerPickRayCallback *GetPickRay();

	float GetCameraHeightAdd() { return mfCameraHeightAdd; }
	bool IsMoving() { return mbMoving; }

	cPlayerFlashLight *GetFlashLight() { return mpFlashLight; }

	cPlayerHeadMove *GetHeadMove() { return mpHeadMove; }

	cPlayerEarRing *GetEarRing() { return mpEarRing; }

	cPlayerGlowStick *GetGlowStick() { return mpGlowStick; }

	cPlayerFlare *GetFlare() { return mpFlare; }

	cPlayerNoiseFilter *GetNoiseFilter() { return mpNoiseFilter; }

	cPlayerFearFilter *GetFearFilter() { return mpFearFilter; }

	cPlayerLookAt *GetLookAt() { return mpLookAt; }

	cPlayerHidden *GetHidden() { return mpHidden; }

	float GetHeightAdd() { return mfHeightAdd; }
	void SetHeightAdd(float afX) { mfHeightAdd = afX; }

	cInit *GetInit() { return mpInit; }

	cVector2f GetInteractMoveBorder() { return mvInteractMoveBorder; }

	cVector2f GetCrossHairPos() { return mvCrossHairPos; }
	void SetCrossHairPos(const cVector2f &avPos) { mvCrossHairPos = avPos; }
	bool AddCrossHairPos(const cVector2f &avPos);
	void ResetCrossHairPos() { mvCrossHairPos = cVector2f(400, 300); }

	void SetCurrentItem(cInventoryItem *apItem) { mpCurrentItem = apItem; }
	cInventoryItem *GetCurrentItem() { return mpCurrentItem; }
	void SetItemFlash(bool abX) { mbItemFlash = abX; }

	void SetWeaponCallback(iPlayerWeaponCallback *apCallback) { mpWeaponCallback = apCallback; }
	iPlayerWeaponCallback *GetWeaponCallback() { return mpWeaponCallback; }

	bool GetLandedFromJump() { return mbLandedFromJump; }
	void SetLandedFromJump(bool abX) { mbLandedFromJump = abX; }

	void SetJumpButtonDown(bool abX);
	bool GetJumpButtonDown() { return mbJumpButtonDown; }
	float GetJumpCount() { return mfJumpCount; }
	float GetMaxJumpCount() { return mfMaxJumpCount; }

	/////////////////////////////////////////
	// Stats
	int mlStat_NumOfSaves;

	/////////////////////////////////////////
	// State properties
	float mfForwardUpMul;
	float mfForwardRightMul;

	float mfUpMul;
	float mfRightMul;

	bool mbPickAtPoint;
	bool mbRotateWithPlayer;
	bool mbUseNormalMass;

	float mfGrabMassMul;

	bool mbCanBeThrown;
	bool mbCanBePulled;

	float mfCurrentMaxInteractDist;

	// Haptic
	bool mbGrabbingMoveBody;
	bool mbProxyTouching;
	float mfHapticTorqueMul;

	bool mbDamageFromPos;
	cVector3f mvDamagePos;

	// Debug
	cVector3f mvLineStart;
	cVector3f mvLineEnd;

private:
	cInit *mpInit;

	cScene *mpScene;
	cGraphics *mpGraphics;
	cResources *mpResources;
	cGraphicsDrawer *mpGfxDrawer;

	FontData *mpFont;

	cNode3D mFeetNode;

	bool mbActive;

	cCamera3D *mpCamera;
	float mfLookSpeed;
	float mfCameraHeightAdd;

	cVector3f mvSize;
	float mfCrouchHeight;

	bool mbJumpButtonDown;
	float mfJumpCount;
	float mfMaxJumpCount;

	bool mbLandedFromJump;

	cVector2f mvInteractMoveBorder;

	float mfHeightAdd;

	float mfMaxPushDist;
	float mfMaxPushSpeed;

	float mfMaxMoveDist;

	float mfMaxGrabDist;
	//float mfMaxGrabForce;

	float mfMaxUseItemDist;

	float mfSpeedMul;
	float mfHealthSpeedMul;

	float mfHeadMoveSizeMul;
	float mfHeadMoveSpeedMul;

	iPhysicsBody *mpPushBody;

	Common::Array<cGfxObject *> mvCrossHairs;

	cVector2f mvMaxPushHeadMovement;
	cVector2f mvMinPushHeadMovement;

	bool mbMoving;

	int mlGroundCount;

	iCharacterBody *mpCharBody;

	cPlayerGroundRayCallback *mpGroundRayCallback;
	cPlayerPickRayCallback *mpPickRayCallback;

	cPlayerBodyCallback *mpBodyCallback;

	cPlayerHeadMove *mpHeadMove;
	cPlayerDamage *mpDamage;
	cPlayerDeath *mpDeath;
	cPlayerFlashLight *mpFlashLight;
	cPlayerLean *mpLean;
	cPlayerEarRing *mpEarRing;
	cPlayerGlowStick *mpGlowStick;
	cPlayerFlare *mpFlare;
	cPlayerHealth *mpHealth;
	cPlayerNoiseFilter *mpNoiseFilter;
	cPlayerFearFilter *mpFearFilter;
	cPlayerLookAt *mpLookAt;
	cPlayerHidden *mpHidden;

	iPlayerWeaponCallback *mpWeaponCallback;

	ePlayerState mState;
	tPlayerStateVec mvStates;

	ePlayerMoveState mMoveState;
	tPlayerMoveStateVec mvMoveStates;

	eCrossHairState mCrossHairState;
	cVector2f mvCrossHairPos;

	cInventoryItem *mpCurrentItem;
	cLinearOscillation mItemFlash;
	bool mbItemFlash;

	float mfHealth;

	float mfPower;

	float mfDefaultMass;
	float mfMass;

	bool mbUpdatingCollisionCallbacks;

	tSoundEntityList mlstFootStepSounds;

	// Debug
	bool mbShowHealth;
	bool mbShowSoundsPlaying;

	tGameCollideScriptMap m_mapCollideCallbacks;
};

#endif // GAME_PLAYER_H