GameEnemy.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_GAME_ENEMY_H
#define GAME_GAME_ENEMY_H

#include "hpl1/engine/engine.h"
#include "hpl1/penumbra-overture/GameEntity.h"

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

using namespace hpl;

class cGameTrigger;
class cCharacterMove;
class iGameEntity;

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

#define STATE_IDLE 0
#define STATE_HUNT 1
#define STATE_ATTACK 2
#define STATE_FLEE 3
#define STATE_KNOCKDOWN 4
#define STATE_DEAD 5
#define STATE_PATROL 6
#define STATE_INVESTIGATE 7
#define STATE_BREAKDOOR 8
#define STATE_CALLBACKUP 9
#define STATE_MOVETO 10
#define STATE_EAT 11
#define STATE_ATTENTION 12
#define STATE_NUM 13

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

enum eEnemyMoveState {
    eEnemyMoveState_Backward,
    eEnemyMoveState_Stopped,
    eEnemyMoveState_Walking,
    eEnemyMoveState_Running,
    eEnemyMoveState_LastEnum
};

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

class cEnemyPatrolNode : public iSerializable {
    kSerializableClassInit(cEnemyPatrolNode) public : cEnemyPatrolNode() {}
    cEnemyPatrolNode(const tString &asNode, float afTime, const tString &asAnim) : msNodeName(asNode), mfWaitTime(afTime), msAnimation(asAnim) {}

    tString msNodeName;
    float mfWaitTime;
    tString msAnimation;
};

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

class cLineOfSightRayCallback : public iPhysicsRayCallback {
public:
    void Reset();
    bool OnIntersect(iPhysicsBody *pBody, cPhysicsRayParams *apParams);
    bool Intersected();

private:
    bool mbIntersected;
    iPhysicsBody *mpGrabBody;
};

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

class cEnemyFindGround : public iPhysicsRayCallback {
public:
    bool GetGround(const cVector3f &avStartPos, const cVector3f &avDir,
                   cVector3f *apDestPosition, cVector3f *apDestNormal,
                   float afMaxDistance = 10);

    bool OnIntersect(iPhysicsBody *pBody, cPhysicsRayParams *apParams);

private:
    bool mbIntersected;
    float mfMinDist;
    cVector3f mvPos;
    cVector3f mvNormal;
    float mfMaxDistance;
};

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

class cEnemyCheckForDoor : public iPhysicsRayCallback {
public:
    bool CheckDoor(const cVector3f &avStart, const cVector3f &avEnd);

    bool BeforeIntersect(iPhysicsBody *pBody);
    bool OnIntersect(iPhysicsBody *pBody, cPhysicsRayParams *apParams);

private:
    bool mbIntersected;
};

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

class iGameEnemy_SaveData : public iGameEntity_SaveData {
    kSerializableClassInit(iGameEnemy_SaveData);

public:
    bool mbHasBeenActivated;

    cVector3f mvCharBodyPosition;
    cVector3f mvCharBodyRotation;
    int mlCurrentPatrolNode;

    float mfDisappearTime;
    bool mbDisappearActive;
    bool mbHasDisappeared;

    bool mbUsesTriggers;

    cVector3f mvLastPlayerPos;
    tString msOnDeathCallback;
    tString msOnAttackCallback;
    cContainerVec<cEnemyPatrolNode> mvPatrolNodes;

    iGameEntity *CreateEntity();
};

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

class iGameEnemyState {
public:
    iGameEnemyState(int alId, cInit *apInit, iGameEnemy *apEnemy);
    virtual ~iGameEnemyState() = default;

    virtual void OnEnterState(iGameEnemyState *apPrevState) = 0;
    virtual void OnLeaveState(iGameEnemyState *apNextState) = 0;

    virtual void OnUpdate(float afTimeStep) = 0;

    virtual void OnDraw() = 0;
    virtual void OnPostSceneDraw() = 0;

    virtual void OnSeePlayer(const cVector3f &avPosition, float afChance) = 0;
    virtual bool OnHearNoise(const cVector3f &avPosition, float afVolume) = 0;
    virtual void OnTakeHit(float afDamage) = 0;
    virtual void OnDeath(float afDamage) = 0;
    virtual void OnAnimationOver(const tString &asAnimName) = 0;
    virtual void OnFlashlight(const cVector3f &avPosition) = 0;

    void SetPreviousState(int alX) { mlPreviousState = alX; }
    int GetPreviousState() { return mlPreviousState; }

    int GetId() { return mlId; }

protected:
    int mlId;
    cInit *mpInit;
    cPlayer *mpPlayer;
    iGameEnemy *mpEnemy;
    cCharacterMove *mpMover;

    int mlPreviousState;
};

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

class iGameEnemy : public iGameEntity {
    typedef iGameEntity super;
    friend class cEntityLoader_GameEnemy;

public:
    iGameEnemy(cInit *apInit, const tString &asName, TiXmlElement *apGameElem);
    virtual ~iGameEnemy(void);

    // Special
    void LoadBaseProperties(TiXmlElement *apGameElem);

    // Actions
    void OnPlayerInteract();
    void OnPlayerPick();

    void Setup(cWorld3D *apWorld);

    void OnWorldLoad();
    void OnPostLoadScripts();
    void OnWorldExit();
    void OnDraw();
    void OnPostSceneDraw();
    virtual void ExtraPostSceneDraw() {}

    void Update(float afTimeStep);

    bool IsLoading() { return mbLoading; }

    void OnDamage(float afX);
    void OnDeath(float afX);

    void OnFlashlight(const cVector3f &avPos);

    virtual void OnSetActive(bool abX);

    virtual bool MoveToPos(const cVector3f &avFeetPos) = 0;

    virtual void ShowPlayer(const cVector3f &avPlayerFeetPos) {}

    virtual bool IsFighting() { return false; }

    // Physics
    void SetupBody();

    // Properties
    cVector3f GetPosition();
    void SetFOV(float afAngle) { mfFOV = afAngle; }

    const tString &GetHitPS() { return msHitPS; }
    const tString &GetEnemyType() { return msEnemyType; }

    const tString &GetCloseMusic() { return msCloseMusic; }
    int GetCloseMusicPrio() { return mlCloseMusicPrio; }
    float GetCloseMusicStartDist() { return mfCloseMusicStartDist; }
    float GetCloseMusicStopDist() { return mfCloseMusicStopDist; }

    const tString &GetAttackMusic() { return msAttackMusic; }
    int GetAttackMusicPrio() { return mlAttackMusicPrio; }

    // States
    void AddState(iGameEnemyState *apState);
    void ChangeState(int alId);
    iGameEnemyState *GetState(int alId);
    int GetCurrentStateId() { return mlCurrentState; }

    // Triggers
    bool HandleTrigger(cGameTrigger *apTrigger);

    eGameTriggerType GetTriggerTypes() { return mTriggerTypes; }

    float GetTriggerUpdateCount() { return mfTriggerUpdateCount; }
    void SetTriggerUpdateCount(float afX) { mfTriggerUpdateCount = afX; }
    float GetTriggerUpdateRate() { return mfTriggerUpdateRate; }

    void SetSkipSoundTriggerCount(float afX) { mfSkipSoundTriggerCount = afX; }

    // Content control
    void PlayAnim(const tString &asName, bool abLoop, float afFadeTime,
                  bool abDependsOnSpeed = false, float afSpeedMul = 1.0f,
                  bool abSyncWithPrevFrame = false,
                  bool abOverideMoveState = true);
    void UseMoveStateAnimations();

    cAnimationState *GetCurrentAnimation() { return mpCurrentAnimation; }

    void PlaySound(const tString &asName);

    // Callabcks
    void SetOnDeathCallback(const tString &asFunc) { msOnDeathCallback = asFunc; }
    void SetOnAttackCallback(const tString &asFunc) { msOnAttackCallback = asFunc; }
    tString GetOnAttackCallback() { return msOnAttackCallback; }

    // AI
    bool CanSeePlayer();
    cCharacterMove *GetMover() { return mpMover; }
    cVector3f GetLastPlayerPos() { return mvLastPlayerPos; }
    void SetLastPlayerPos(const cVector3f &avPos) { mvLastPlayerPos = avPos; }

    void SetTempPosition(const cVector3f &avPos) { mvTempPosition = avPos; }
    cVector3f GetTempPosition() { return mvTempPosition; }

    void SetTempFloat(float afX) { mfTempFloat = afX; }
    float GetTempFloat() { return mfTempFloat; }

    cEnemyFindGround *GetGroundFinder() { return &mFindGround; }

    cEnemyCheckForDoor *GetDoorChecker() { return &mDoorCheck; }
    bool CheckForDoor();

    bool CheckForTeamMate(float afMaxDist, bool abCheckIfFighting);

    bool IsAttracted() { return mbIsAttracted; }
    void SetAttracted(bool abX) { mbIsAttracted = abX; }

    bool GetUsesTriggers() { return mbUsesTriggers; }
    void SetUsesTriggers(bool abX) { mbUsesTriggers = abX; }

    // Patrolling
    void AddPatrolNode(const tString &asNode, float afTime, const tString &asAnimation);
    cEnemyPatrolNode *GetPatrolNode(int alIdx) { return &mvPatrolNodes[alIdx]; }
    int GetPatrolNodeNum() { return (int)mvPatrolNodes.size(); }
    cEnemyPatrolNode *CurrentPatrolNode() { return &mvPatrolNodes[mlCurrentPatrolNode]; }

    void ClearPatrolNodes();

    int GetCurrentPatrolNode() { return mlCurrentPatrolNode; }
    float GetWaitTime() { return mfWaitTime; }
    float GetWaitTimeCount() { return mfWaitTimeCount; }

    void SetCurrentPatrolNode(int alX) { mlCurrentPatrolNode = alX; }
    void IncCurrentPatrolNode() {
        mlCurrentPatrolNode++;
        if (mlCurrentPatrolNode >= (int)mvPatrolNodes.size())
            mlCurrentPatrolNode = 0;
    }
    void SetWaitTime(float afX) { mfWaitTime = afX; }
    void SetWaitTimeCount(float afX) { mfWaitTimeCount = afX; }
    void AddWaitTimeCount(float afX) { mfWaitTimeCount += afX; }

    float GetDoorBreakCount() { return mfDoorBreakCount; }
    void SetDoorBreakCount(float afX) { mfDoorBreakCount = afX; }
    void AddDoorBreakCount(float afX) { mfDoorBreakCount += afX; }

    const cVector3f &GetModelOffsetAngles() { return mvModelOffsetAngles; }

    // Virtual
    virtual void OnUpdate(float afTimeStep) = 0;
    virtual void OnLoad() = 0;

    // SaveObject implementation
    iGameEntity_SaveData *CreateSaveData();
    void SaveToSaveData(iGameEntity_SaveData *apSaveData);
    void LoadFromSaveData(iGameEntity_SaveData *apSaveData);

protected:
    void UpdateEnemyPose(float afTimeStep);

    void UpdateAnimations(float afTimeStep);
    void UpdateCheckForPlayer(float afTimeStep);

    bool HandleSoundTrigger(cGameTrigger *apTrigger);

    bool LineOfSight(const cVector3f &avPos, const cVector3f &avSize);

    bool mbSetFeetAtGroundOnStart;
    bool mbAttachMeshToBody;
    bool mbRemoveAttackerOnDisable;

    tVector3fVec mvRayStartPoses;
    tVector3fVec mvRayEndPoses;

    cEnemyFindGround mFindGround;

    eGameTriggerType mTriggerTypes;

    cCharacterMove *mpMover;

    tString msEnemyType;

    float mfTriggerUpdateCount;
    float mfTriggerUpdateRate;

    float mfSkipSoundTriggerCount;

    cAStarHandler *mpAStarAir;
    cAStarHandler *mpAStarGround;
    cAINodeContainer *mpNodeContainerAir;
    cAINodeContainer *mpNodeContainerGround;

    cLineOfSightRayCallback mRayCallback;

    Common::Array<iGameEnemyState *> mvStates;
    int mlCurrentState;

    cEnemyCheckForDoor mDoorCheck;

    cAnimationState *mpCurrentAnimation;
    bool mbAnimationIsSpeedDependant;
    float mfAnimationSpeedMul;

    bool mbOverideMoveState;
    eEnemyMoveState mMoveState;

    cVector3f mvTempPosition;
    float mfTempFloat;

    tStringVec mvPreloadSounds;

    bool mbLoading;

    bool mbAlignToGroundNormal;
    cMatrixf m_mtxStartPose;
    cMatrixf m_mtxGoalPose;
    float mfPoseCount;

    bool mbHasBeenActivated;

    bool mbUsesTriggers;

    // Variable Properties
    cVector3f mvLastPlayerPos;
    float mfCanSeePlayerCount;
    float mfCheckForPlayerCount;
    float mfCheckForPlayerRate;
    bool mbCanSeePlayer;
    int mlPlayerInLOSCount;
    int mlMaxPlayerInLOSCount;

    float mfCalcPlayerHiddenPosCount;

    float mfDamageSoundTimer;

    tString msOnDeathCallback;
    tString msOnAttackCallback;

    Common::Array<cEnemyPatrolNode> mvPatrolNodes;

    int mlCurrentPatrolNode;
    float mfWaitTime;
    float mfWaitTimeCount;

    float mfDoorBreakCount;

    bool mbIsAttracted;

    // Properties to be implemented
    bool mbDisappear;
    float mfDisappearMinTime;
    float mfDisappearMaxTime;
    float mfDisappearMinDistance;
    tString msDisappearPS;
    tString msDisappearSound;
    bool mbDisappearFreezesRagdoll;

    float mfDisappearTime;
    bool mbDisappearActive;
    bool mbHasDisappeared;

    tString msCloseMusic;
    int mlCloseMusicPrio;
    float mfCloseMusicStartDist;
    float mfCloseMusicStopDist;

    tString msAttackMusic;
    int mlAttackMusicPrio;

    bool mbShowDebug;

    tString msGroundNodeType;

    cVector3f mvBodySize;
    float mfBodyMass;

    float mfMaxForwardSpeed;
    float mfMaxBackwardSpeed;

    float mfAcceleration;
    float mfDeacceleration;

    float mfMaxTurnSpeed;
    float mfAngleDistTurnMul;

    float mfMinBreakAngle;
    float mfBreakAngleMul;

    float mfSpeedMoveAnimMul;
    float mfTurnSpeedMoveAnimMul;

    cMatrixf m_mtxModelOffset;
    cVector3f mvModelOffsetAngles;

    float mfIdleToMoveLimit;
    float mfMoveToLideLimit;

    float mfMaxPushMass;
    float mfPushForce;

    float mfMaxSeeDist;

    float mfMinAttackDist;

    float mfFOV;
    float mfFOVXMul;

    float mfMaxHealth;

    float mfStoppedToWalkSpeed;
    float mfWalkToStoppedSpeed;
    float mfWalkToRunSpeed;
    float mfRunToWalkSpeed;
    float mfMoveAnimSpeedMul;
    tString msBackwardAnim;
    tString msStoppedAnim;
    tString msWalkAnim;
    tString msRunAnim;

    float mfMinStunSpeed;
    float mfMinStunImpulse;
    float mfObjectCollideStun;
    float mfStunDamageMul;

    tString msHitPS;
};

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

class cEntityLoader_GameEnemy : public cEntityLoader_Object {

public:
    cEntityLoader_GameEnemy(const tString &asName, cInit *apInit);
    ~cEntityLoader_GameEnemy();

private:
    void BeforeLoad(TiXmlElement *apRootElem, const cMatrixf &a_mtxTransform, cWorld3D *apWorld);
    void AfterLoad(TiXmlElement *apRootElem, const cMatrixf &a_mtxTransform, cWorld3D *apWorld);

    cInit *mpInit;
};

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

#endif // GAME_GAME_ENEMY_H