Initial commit

engines/hpl1/penumbra-overture/GameEntity.h

@@ -0,0 +1,347 @@
+/* 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_GAME_ENTITY_H
+#define GAME_GAME_ENTITY_H
+
+#include "hpl1/engine/engine.h"
+
+using namespace hpl;
+
+#include "hpl1/penumbra-overture/GameTypes.h"
+#include "hpl1/penumbra-overture/SaveTypes.h"
+
+class cInit;
+class iGameEntity;
+class cInventoryItem;
+
+//-----------------------------------------
+
+class cGameEntityScript : public iSerializable {
+	kSerializableClassInit(cGameEntityScript) public : cGameEntityScript() : msScriptFunc("") {}
+
+	int mlNum;
+	tString msScriptFunc;
+};
+
+typedef Common::StableMap<tString, cGameEntityScript *> tGameEntityScriptMap;
+typedef tGameEntityScriptMap::iterator tGameEntityScriptMapIt;
+
+//-----------------------------------------
+
+typedef Common::StableMap<tString, int> tGameEntityVarMap;
+typedef tGameEntityVarMap::iterator tGameEntityVarMapIt;
+
+//------------------------------------------
+
+class iGameEntity;
+
+//------------------------------------------
+
+class cGameEntityAnimation_SaveData : public iSerializable {
+	kSerializableClassInit(cGameEntityAnimation_SaveData) public : bool mbActive;
+	bool mbLoop;
+
+	float mfWeight;
+	float mfFadeStep;
+	float mfTimePos;
+	float mfSpeed;
+};
+//------------------------------------------
+
+class iGameEntity_SaveData : public iSerializable {
+	kSerializableClassInit(iGameEntity_SaveData) public : bool mbActive;
+
+	tString msFileName;
+
+	tString msName;
+
+	float mfHealth;
+
+	float mfMaxExamineDist;
+	float mfMaxInteractDist;
+
+	bool mbHasBeenExamined;
+
+	tWString msGameName;
+	tWString msDescription;
+
+	bool mbShowDescritionOnce;
+
+	eGameEntityType mType;
+
+	cMatrixf m_mtxTransform;
+
+	// Engine types
+	cContainerVec<cEngineBody_SaveData> mvBodies;
+	cContainerVec<cEnginePS_SaveData> mvPS;
+	cContainerVec<cEnginePS_SaveData> mvBeams;
+	cContainerVec<cEngineLight_SaveData> mvLights;
+	cContainerVec<cEngineSound_SaveData> mvSounds;
+
+	cEnginePS_SaveData *GetParticleSystem(cParticleSystem3D *apPS);
+	cEngineSound_SaveData *GetSoundEntity(cSoundEntity *apSound);
+
+	// Animations
+	cContainerVec<cGameEntityAnimation_SaveData> mvAnimations;
+
+	// Callbacks
+	cContainerList<cSaveGame_cGameCollideScript> mlstCollideCallbacks;
+
+	cContainerList<cGameEntityScript> mlstCallbackScripts;
+
+	// Script variables
+	cContainerList<cScriptVar> mlstVars;
+
+	// Creation
+	virtual iGameEntity *CreateEntity() = 0;
+};
+
+//------------------------------------------
+
+class iGameEntity {
+	friend class cPlayer;
+
+public:
+	iGameEntity(cInit *apInit, const tString &asName);
+	virtual ~iGameEntity();
+
+	const tString &GetName() { return msName; }
+
+	bool IsActive() { return mbActive; }
+	void SetActive(bool abX);
+	virtual void OnSetActive(bool abX) {}
+
+	virtual bool IsSaved() { return mbIsSaved; }
+
+	virtual void OnWorldLoad() {}
+	virtual void OnPostLoadScripts() {}
+	virtual void OnWorldExit() {}
+	virtual void Update(float afTimeStep) {}
+	virtual void OnDraw() {}
+	virtual void OnPostSceneDraw() {}
+
+	void OnUpdate(float afTimeStep);
+
+	eGameEntityType GetType() { return mType; }
+
+	const tString &GetSubType() { return msSubType; }
+
+	void SetDescription(const tWString &asDesc) { msDescription = asDesc; }
+	const tWString &GetDescription() { return msDescription; }
+
+	void SetShowDescritionOnce(bool abX) { mbShowDescritionOnce = abX; }
+	bool GetShowDescritionOnce() { return mbShowDescritionOnce; }
+
+	bool GetHasBeenExamined() { return mbHasBeenExamined; }
+
+	void SetGameName(const tWString &asName) { msGameName = asName; }
+	const tWString &GetGameName() { return msGameName; }
+
+	iPhysicsBody *GetBody(int alNum) { return mvBodies[alNum]; }
+	int GetBodyNum() { return (int)mvBodies.size(); }
+	void SetBodies(Common::Array<iPhysicsBody *> &avBodies) { mvBodies = avBodies; }
+
+	iPhysicsJoint *GetJoint(int alNum) { return mvJoints[alNum]; }
+	int GetJointNum() { return (int)mvJoints.size(); }
+	void SetJoints(Common::Array<iPhysicsJoint *> &avJoints) { mvJoints = avJoints; }
+
+	int GetLightNum() { return (int)mvLights.size(); }
+	iLight3D *GetLight(int alX) { return mvLights[alX]; }
+	void SetLights(Common::Array<iLight3D *> &avLights) { mvLights = avLights; }
+
+	void SetParticleSystems(Common::Array<cParticleSystem3D *> &avParticleSystems) { mvParticleSystems = avParticleSystems; }
+	void SetBillboards(Common::Array<cBillboard *> &avBillboards) { mvBillboards = avBillboards; }
+	void SetBeams(Common::Array<cBeam *> &avBeams) { mvBeams = avBeams; }
+	void SetSoundEntities(Common::Array<cSoundEntity *> &avSoundEntities) { mvSoundEntities = avSoundEntities; }
+
+	void DestroyLight(iLight3D *apLight);
+	void DestroyParticleSystem(cParticleSystem3D *apPS);
+	void DestroyBillboard(cBillboard *apBillboard);
+	void SetSoundEntity(cSoundEntity *apSound);
+
+	cMeshEntity *GetMeshEntity() { return mpMeshEntity; }
+	void SetMeshEntity(cMeshEntity *apEnity) { mpMeshEntity = apEnity; }
+
+	void PlayerPick();
+	void PlayerInteract();
+	void PlayerExamine();
+
+	virtual void OnPlayerPick() {}
+	virtual void OnPlayerInteract() {}
+	virtual void OnPlayerExamine();
+
+	virtual bool OnUseItem(cInventoryItem *apItem) { return false; }
+
+	virtual void BreakAction() {}
+
+	virtual void OnDamage(float afDamage) {}
+	virtual void OnDeath(float afDamage) {}
+
+	virtual void OnPlayerGravityCollide(iCharacterBody *apCharBody, cCollideData *apCollideData) {}
+
+	bool GetHasInteraction() { return mbHasInteraction; }
+
+	float GetMaxExamineDist() { return mfMaxExamineDist; }
+	void SetMaxExamineDist(float afX) { mfMaxExamineDist = afX; }
+	float GetMaxInteractDist() { return mfMaxInteractDist; }
+	void SetMaxInteractDist(float afX) { mfMaxInteractDist = afX; }
+
+	virtual eCrossHairState GetPickCrossHairState(iPhysicsBody *apBody);
+	virtual float GetPickedDistance();
+
+	void AddCollideScript(eGameCollideScriptType aType, const tString &asFunc, const tString &asEntity);
+	void RemoveCollideScript(eGameCollideScriptType aType, const tString &asFunc);
+	void RemoveCollideScriptWithChildEntity(iGameEntity *apEntity);
+
+	void AddScript(eGameEntityScriptType aType, const tString &asFunc);
+	void RemoveScript(eGameEntityScriptType aType);
+
+	void CreateVar(const tString &asName, int alVal);
+	void SetVar(const tString &asName, int alVal);
+	void AddVar(const tString &asName, int alVal);
+	int GetVar(const tString &asName);
+
+	void Damage(float afDamage, int alStrength);
+	float GetHealth() { return mfHealth; }
+	void SetHealth(float afHealth);
+
+	void SetToughness(int alX) { mlToughness = alX; }
+	int GetToughness() { return mlToughness; }
+
+	bool GetDestroyMe() { return mbDestroyMe; }
+	bool GetBreakMe() { return mbBreakMe; }
+
+	void Break() { mbBreakMe = true; }
+
+	void SetCharBody(iCharacterBody *apCharBody) { mpCharBody = apCharBody; }
+	iCharacterBody *SetCharBody() { return mpCharBody; }
+
+	void SetUpTransMaterials();
+	void SetTransActive(bool abX);
+
+	void SetPauseControllers(bool abX) { mbPauseControllers = abX; }
+	bool GetPauseControllers() { return mbPauseControllers; }
+
+	void SetPauseGravity(bool abX) { mbPauseGravity = abX; }
+	bool GetPauseGravity() { return mbPauseGravity; }
+
+	const cMatrixf &GetOnLoadTransform() { return m_mtxOnLoadTransform; }
+	void SetOnLoadTransform(const cMatrixf &a_mtxPose) { m_mtxOnLoadTransform = a_mtxPose; }
+
+	void SetLastImpulse(const cVector3f &avVec) { mvLastImpulse = avVec; }
+
+	const tString &GetFileName() { return msFileName; }
+
+	cGameEntityScript *GetCallbackScript(eGameEntityScriptType aType) { return mvCallbackScripts[aType]; }
+
+	// Save data stuff
+	void SetSaveData(iGameEntity_SaveData *apData) { mpSaveData = apData; }
+	iGameEntity_SaveData *GetSaveData() { return mpSaveData; }
+
+	virtual iGameEntity_SaveData *CreateSaveData() = 0;
+	virtual void LoadFromSaveData(iGameEntity_SaveData *apSaveData);
+	virtual void SaveToSaveData(iGameEntity_SaveData *apSaveData);
+	virtual void SetupSaveData(iGameEntity_SaveData *apSaveData);
+
+protected:
+	tString GetScriptCommand(eGameEntityScriptType aType);
+
+	void PreloadModel(const tString &asFile);
+
+	cInit *mpInit;
+
+	bool mbActive;
+
+	tString msFileName;
+
+	bool mbIsSaved;
+
+	bool mbDestroyMe;
+	bool mbBreakMe;
+
+	bool mbHasInteraction;
+
+	bool mbHasBeenExamined;
+
+	tString msName;
+
+	tString msSubType;
+
+	float mfHealth;
+	int mlToughness;
+
+	tWString msGameName;
+	tWString msDescription;
+
+	bool mbShowDescritionOnce;
+
+	float mfMaxExamineDist;
+	float mfMaxInteractDist;
+
+	eGameEntityType mType;
+
+	bool mbPauseControllers;
+	bool mbPauseGravity;
+
+	cMatrixf m_mtxOnLoadTransform;
+
+	iGameEntity_SaveData *mpSaveData;
+
+	Common::Array<iPhysicsBody *> mvBodies;
+	Common::Array<iPhysicsJoint *> mvJoints;
+
+	Common::Array<iLight3D *> mvLights;
+	Common::Array<cParticleSystem3D *> mvParticleSystems;
+	Common::Array<cBillboard *> mvBillboards;
+	Common::Array<cBeam *> mvBeams;
+	Common::Array<cSoundEntity *> mvSoundEntities;
+
+	bool mbSaveLights;
+
+	cMeshEntity *mpMeshEntity;
+
+	Common::Array<iMaterial *> mvNormalMaterials;
+	Common::Array<iMaterial *> mvTransMaterials;
+	bool mbTransActive;
+	bool mbTransShadow;
+
+	cVector3f mvLastImpulse;
+
+	Common::Array<cMesh *> mvPreloadedBreakMeshes;
+
+	iCharacterBody *mpCharBody;
+
+	cGameEntityScript *mvCallbackScripts[eGameEntityScriptType_LastEnum];
+	tGameCollideScriptMap m_mapCollideCallbacks;
+
+	tGameEntityVarMap m_mapVars;
+
+	bool mbUpdatingCollisionCallbacks;
+};
+
+#endif // GAME_GAME_ENTITY_H