The-Simpsons-Hit-and-Run/game/code/ai/sequencer/action.h

#ifndef _SEQUENCER_ACTION_HPP
#define _SEQUENCER_ACTION_HPP
//-----------------------------------------------------------------------------
// Copyright (C) 2001 Radical Entertainment Ltd.  All rights reserved.
//
// action.hpp
//
// Description: An atomic unit of execution in the Sequencer, the Action class
//              is the base class for all logical actions that operate on
//              a character for movement and animation.
//
// Modification History:
//  + Created Aug 14, 2001 -- Gary Keong
//      - Snapshot from Hair Club (rev 1) Owner: Laurent Ancessi
//-----------------------------------------------------------------------------

//---------------------------------------------------------------------
// Includes
//---------------------------------------------------------------------

//========================================
// Nested Includes
//========================================
#include <memory/memorypool.h>
#include <p3d/memory.hpp>

#include <ai/sequencer/task.h>
#include <ai/statemanager.h>
#include <p3d/p3dtypes.hpp>
#include <events/eventenum.h>
#include <events/eventmanager.h>

#include <worldsim/character/charactercontroller.h>
#include <radmath/radmath.hpp>
#include <worldsim/redbrick/vehicle.h>

class tName;

class Action: public Task
{
public:

	virtual ~Action();

	virtual bool IsSlave() const;

	virtual void WakeUp(float time);
	virtual void DoSimulation(float time);
	virtual void Update(float time);
	virtual void Clear();
    virtual void Abort() {};

    // Pool allocators.
    //
    static void* operator new( size_t size ) 
    { 
        void *memPtr = sMemoryPool.Allocate( size );
#ifdef RADLOAD_HEAP_DEBUGGING
	radLoadHeapDebugAddAddress( memPtr );
#endif
        return memPtr; 
    }
    static void  operator delete( void* deadObject, size_t size ) 
    { 
        sMemoryPool.Free( deadObject, size ); 
//This is done in the radObject...
//#ifdef RADLOAD_HEAP_DEBUGGING
//	radLoadHeapDebugRemoveAddress( deadObject );
//#endif
    }

    // Declared but not defined to prevent access.
    static void* operator new[]( size_t size );
    static void  operator delete[]( void* pMemory );

private:
    static FBMemoryPool sMemoryPool;
};

class SlaveAction: public Action
{
public:

	virtual bool IsSlave() const;
};
namespace choreo
{
    class AnimationDriver;
    class RootTransformController;
    class RootDriver;
    class Locomotion;
    class LocomotionDriver;
}

class TriggerEventAction
:
public Action
{
public:
    TriggerEventAction( EventEnum eventId, void* pUserData )
        :
    mEventId( eventId ),
        mpUserData( pUserData )
    {
    }
    virtual void WakeUp( float timeins )
    {
        GetEventManager()->TriggerEvent( mEventId, mpUserData );
        Done( );
    }
private:
    EventEnum mEventId;
    void* mpUserData;
};


class DelayAction
:
public Action
{
public:
    DelayAction( float timeins ) : mTime( timeins) { }
    
    virtual void Update( float timeins )
    {
        mTime -= timeins;
        if(mTime <= 0.0f)
        {
            Done( );
        }
    }

private:
    float mTime;
};

//////////////////////////////////////////////////////////////////////////
//  
// class WalkerLocomotionAction
//
//
//////////////////////////////////////////////////////////////////////////
class WalkerLocomotionAction : public SlaveAction
{
public:
	WalkerLocomotionAction( Character* pCharacter );
	~WalkerLocomotionAction( );
	
    virtual void WakeUp( float timeins );
    virtual void DoSimulation( float timeins);
	virtual void Update( float timeins);
    void PlayDriver(void);
    void StopDriver(void);

    void SetDesiredSpeed( float fSpeed )
    {
        mfDesiredSpeed = fSpeed;
    }

    void SwitchLocomotion(void);

    choreo::LocomotionDriver* GetDriver(void) { return mpLocomotionDriver;}

    void AllowIdle(bool b) { mAllowIdle = b; }

protected:
    static rmt::Randomizer sRandom;
    static bool sRandomSeeded;

    float SolveActualDir( float fDesiredDir, float timeins );
    float SolveActualSpeed( float fDesiredSpeed, float timeins );

    float mfDesiredSpeed;
    float mIdleTime;
    float mNextIdle;
    bool  mAllowIdle : 1;

    Character* mpCharacter;

    choreo::Locomotion* mpLocomotion;
    choreo::LocomotionDriver* mpLocomotionDriver;
};

//////////////////////////////////////////////////////////////////////////
class InCarAction : public Action
{
public:
	InCarAction( Character* pCharacter );
	~InCarAction( );
	
    virtual void WakeUp( float timeins );
    virtual void DoSimulation( float timeins);
	virtual void Update( float timeins);
	virtual void Clear( void );

protected:
    void IWannaRock(bool);

    Character* mpCharacter;
    choreo::AnimationDriver* mpAnimationDriver;
    bool mIsDriver           : 1;
    bool rockinIsMyBusiness  : 1;
    float timeBetweenBeats;
    float timeSinceLastBeat;
    float lastBeatValue;

    float mIdleTime;
};

//////////////////////////////////////////////////////////////////////////
class HoldAnimationAction : public Action
{
public:
	HoldAnimationAction( Character* pCharacter, const char* animName, float holdFrame);
	~HoldAnimationAction( );
	
    virtual void WakeUp( float timeins );
    virtual void DoSimulation( float timeins);
	virtual void Update( float timeins);
	virtual void Clear( void );

protected:
    virtual bool ShouldRelease(void) = 0;

    Character* mpCharacter;
    tUID mAnimUID;
    choreo::AnimationDriver* mpAnimationDriver;
    float mHoldFrame;
    float mOrigFrames;
};

class SteerAction : public HoldAnimationAction
{
public:

    SteerAction( Character* pCharacter, const char* anim, float frame);
	
protected:
    virtual bool ShouldRelease(void);

};

class ReverseAction : public HoldAnimationAction
{
public:
    ReverseAction( Character* pCharacter, const char* anim, float frame);
	
protected:
    virtual bool ShouldRelease(void);
    float mRelease;

};

class AccelAction : public HoldAnimationAction
{
public:
    AccelAction( Character* pCharacter, const char* anim, float frame);
	
protected:
    virtual bool ShouldRelease(void);

};

class DecelAction : public HoldAnimationAction
{
public:
    DecelAction( Character* pCharacter, const char* anim, float frame);
	
protected:
    virtual bool ShouldRelease(void);

};


//////////////////////////////////////////////////////////////////////////
//  
// class JumpAction
//
//
//////////////////////////////////////////////////////////////////////////
class JumpAction
:
public Action
{
public:
    JumpAction( Character* pCharacter, const char* name, float fUpVelocity );
    virtual ~JumpAction( void );
    enum eJumpState
    {
        NoTranslate = 1 << 16,
        InitJump,
        PostTurboJumpRecover,
        IdleJump,
        
        AllowTranslate = 1 << 17,
        PreJump,
        Jump,
        PostJump,
        JumpDone
    };
    virtual void WakeUp( float timeins );
    float Reset( float fJumpHeight, bool bFalling = false );
    void Reset( const rmt::Vector& jumpTarget, bool bFalling = false );
    virtual void DoSimulation( float timeins );
    virtual void Update( float timeins ); 
    void TestForJumpAgain( const rmt::Vector& currentPos, float fUpVelocity, rmt::Vector& groundPos );
    virtual void Clear( );
    
    void SetRootTransform( void );
    void SetRootPosition( const rmt::Vector& position );
    bool IsInJump( void )
    { 
        return mJumpState == Jump 
            // if we are in the PreJump state with no animation,
            // then we are as good as jumping.
            // had to do it for the launching platforms.
            // Bounce.
            //
            || ( mJumpState == PreJump && mpAnimationDriver == 0 )
            ||  ( mJumpState == PreJump && mbJumpAgain );
    }
    
    bool IsJumpState( eJumpState state )
    {
        return ( state == mJumpState );
    }
    const rmt::Vector& GetJumpVelocity( void ) const
    {
        return mVelocity;
    }

    float GetGravity( void ) const
    {
        return mfGravity;
    }
    
protected:
    void SetJumpVelocity( float fVelocity )
    {
        mVelocity.y = fVelocity;
    }
    float SolveActualDir( float fDesiredDir, float timeins );
    float SolveActualSpeed( float fDesiredSpeed, float timeins );
private:

    Character* mpCharacter;
    eJumpState mJumpState;
    rmt::Vector mVelocity;
    tUID mAnimUid;
    float mfTime;
    float mfGravity;
    float mfStartHeight;
    float mfJumpHeight;
    float mfMaxSpeed;
    choreo::AnimationDriver* mpAnimationDriver;
    choreo::RootTransformController* mpRootController;
    choreo::RootDriver* mpRootDriver;
    bool mbBoost      : 1;
    bool mbFalling    : 1;
    bool mbJumpAgain  : 1;
    bool mbTurboJump  : 1;
    bool mbInJumpKick : 1;
    bool mbDoJumpKick : 1;
    bool mbSlam       : 1;
    bool mbPreSlam    : 1;
};

//////////////////////////////////////////////////////////////////////////
//  
// class DodgeAction
//
//
//////////////////////////////////////////////////////////////////////////

class DodgeAction
: 
public Action
{

public:
    DodgeAction( Character* pCharacter );

    virtual void WakeUp( float timeins );
    virtual void DoSimulation( float timeins);
	virtual void Update( float timeins);
    virtual void Clear();

protected:
    float SolveActualDir( float fDesiredDir, float timeins );
    float SolveActualSpeed( float fDesiredSpeed, float timeins );

    choreo::AnimationDriver* mpAnimationDriver; // stores handle for dodge animation
    Character* mpCharacter;
};


//////////////////////////////////////////////////////////////////////////
//  
// class CringeAction
//
//
//////////////////////////////////////////////////////////////////////////

class CringeAction
: 
public Action
{

public:
    CringeAction( Character* pCharacter );

    virtual void WakeUp( float timeins );
    virtual void DoSimulation( float timeins);
	virtual void Update( float timeins);
    virtual void Clear();

protected:
    float SolveActualDir( float fDesiredDir, float timeins );
    float SolveActualSpeed( float fDesiredSpeed, float timeins );
    choreo::AnimationDriver* mpAnimationDriver; // stores handle for dodge animation
    Character* mpCharacter;
};

//////////////////////////////////////////////////////////////////////////
//  
// class FlailAction
//
//
//////////////////////////////////////////////////////////////////////////

class FlailAction
: 
public Action
{

public:
    FlailAction( Character* pCharacter );

    virtual void WakeUp( float timeins );
    virtual void DoSimulation( float timeins);
	virtual void Update( float timeins);
	virtual void Clear();


protected:
    float SolveActualDir( float fDesiredDir, float timeins );
    float SolveActualSpeed( float fDesiredSpeed, float timeins );

    choreo::AnimationDriver* mpAnimationDriver; // stores handle for dodge animation
    Character* mpCharacter;
};


//////////////////////////////////////////////////////////////////////////
//  
// class GetUpAction
//
//
//////////////////////////////////////////////////////////////////////////

class GetUpAction
: 
public Action
{

public:
    GetUpAction( Character* pCharacter );

    virtual void WakeUp( float timeins );
    virtual void DoSimulation( float timeins);
	virtual void Update( float timeins);
    virtual void Clear();

protected:
    float SolveActualDir( float fDesiredDir, float timeins );
    float SolveActualSpeed( float fDesiredSpeed, float timeins );
    choreo::AnimationDriver* mpAnimationDriver; // stores handle for dodge animation
    Character* mpCharacter;
};


//////////////////////////////////////////////////////////////////////////
//  
// class PlayAnimationAction
//
//
//////////////////////////////////////////////////////////////////////////

class PlayAnimationAction: public Action
{
public:
	PlayAnimationAction( Character* pCharacter, const char* anim, float fFrameRate = 30.0f );
    PlayAnimationAction( Character* pCharacter, const tName& anim, float fFrameRate = 30.0f );

    virtual void WakeUp( float timeins );
    virtual void DoSimulation( float timeins );
    virtual void Update( float timeins );
    virtual void Clear( void );
    void AbortWhenMovementOccurs( bool abort );
    void SetLoop(bool b) { loop = b;}

private:
    PlayAnimationAction( void );

protected:
    virtual bool ShouldAbort(void);

	Character* mpCharacter;
	tUID mAnimUID;
    float mfFrameRate;
    choreo::AnimationDriver* mpAnimationDriver;
    bool mbAbortWhenMovementOccurs : 1;
    bool loop                      : 1;
};

//////////////////////////////////////////////////////////////////////////
//  
// class PlayIdleAnimationAction
//
//
//////////////////////////////////////////////////////////////////////////

class PlayIdleAnimationAction: public PlayAnimationAction
{
public:
	PlayIdleAnimationAction( Character* pCharacter, const char* anim, float fFrameRate = 30.0f );
    PlayIdleAnimationAction( Character* pCharacter, const tName& anim, float fFrameRate = 30.0f );

    virtual void WakeUp( float timeins );
    virtual void Clear( void );
    virtual void Abort( void );

private:
    PlayIdleAnimationAction( void );

protected:
};



//////////////////////////////////////////////////////////////////////////
//  
// class CarDoorAction
//
// Action for opening and closing car doors
//
//////////////////////////////////////////////////////////////////////////

class Sequencer;

class CarDoorAction: public Action
{
public:
    CarDoorAction( Vehicle* vehicle, Vehicle::DoorAction, Vehicle::Door, float delay, float timeins, Character* character = NULL, Sequencer* seq = NULL);
    
    virtual void WakeUp( float timeins );
    virtual void DoSimulation( float timeins );
    virtual void Update( float timeins );
    virtual void Clear( void );

private:
    CarDoorAction( void );

    Vehicle* mpVehicle;
    Vehicle::DoorAction mAction;
    Vehicle::Door mDoor;
    float mTime;
    float mDelay;
    float mCurrentTime;

    Character* character;
    Sequencer* sequencer;
};

class ReleaseDoorsAction: public Action
{
public:
    ReleaseDoorsAction( Vehicle* v ) : mVehicle(v) {};
    virtual void Update( float timeins );

protected:
    Vehicle* mVehicle;
};

//////////////////////////////////////////////////////////////////////////
//  
// class Arrive
//
//
//////////////////////////////////////////////////////////////////////////
class Arrive
:
public Action
{
public:
    Arrive( Character* pCharacter, rmt::Vector& destination, bool strict = false );
    virtual ~Arrive( void );
    virtual void WakeUp( float timeins );
    virtual void DoSimulation( float timeins );
    virtual void Update( float timeins );
    virtual void Clear( );
protected:
private:
    Character* mpCharacter;
    rmt::Vector mDestination;
    float mfDecelTime;
    float mfMaxSpeed;
    float mEstTime;
    float mElapsedTime;
    bool mbSolveState   : 1;
    bool mbPrevLocoMode : 1;
    bool mStrict : 1;
};

class FragileArrive : public Arrive
{
public:
    FragileArrive( Character* pCharacter, rmt::Vector& destination, bool strict = false ) :
       Arrive( pCharacter, destination, strict ) {}
    bool IsSlave() const { return true; }
};

//////////////////////////////////////////////////////////////////////////
//  
// class Orient
//
//
//////////////////////////////////////////////////////////////////////////
class Orient
:
public Action
{
public:
    Orient( Character* pCharacter, rmt::Vector& facing );
    virtual ~Orient( void );

    virtual void WakeUp( float timeins );
    virtual void DoSimulation( float timeins );
    virtual void Update( float timeins );
protected:
private:
    Character* mpCharacter;
    float mfTarget;
};
//////////////////////////////////////////////////////////////////////////
//  
// class Position
//
//
//////////////////////////////////////////////////////////////////////////
class Position
:
public Action
{
public:
    Position( Character* pCharacter, rmt::Vector& position, float fDuration, bool local = false );
    virtual ~Position( void );

    virtual void WakeUp( float timeins );
    virtual void DoSimulation( float timeins );
    virtual void Update( float timeins );
protected:
private:
    Character* mpCharacter;
    rmt::Vector mDestination;
    float mfDuration;
    float mfTimeLeft;
    bool mLocal : 1;
};

class GroundSnap
:
public Action
{
public:
    GroundSnap( Character* pCharacter) : mpCharacter( pCharacter ) {}
    virtual ~GroundSnap( void ) {}

    virtual void WakeUp( float timeins );
    virtual void DoSimulation( float timeins ) {}
    virtual void Update( float timeins ) {}
protected:
private:
    Character* mpCharacter;
};

//////////////////////////////////////////////////////////////////////////
//  
// class AssignValueToFloat
//
//
//////////////////////////////////////////////////////////////////////////
class AssignValueToFloat
:
public Action
{
public:
    AssignValueToFloat( float& refFloat, float fValue )
        :
    mRefFloat( refFloat ),
        mfValue( fValue )
    {
    }
    virtual void WakeUp( float timeins )
    {
        mRefFloat = mfValue;
        Done( );
    }
private:
    float& mRefFloat;
    float mfValue;
};


class ChangeLocomotion
:
public Action
{
public:
    enum LocoType  { INCAR, WALKING };

    ChangeLocomotion( Character* c, LocoType type) : mpCharacter(c), mType(type) { }
    
    virtual void Update( float timeins );

private:
    Character* mpCharacter;
    LocoType mType;
};


class ChangeNPCControllerState
:
public Action
{
public:
    ChangeNPCControllerState( Character* c, NPCController::State state) : mpCharacter(c), mState(state) { }
    virtual void Update( float timeins );
    virtual void Abort( void );
private:
    Character* mpCharacter;
    NPCController::State mState;
};


class KickAction
:
public SlaveAction
{
public:
    KickAction( Character* c, float contact) : mpCharacter(c), mTime(0.0f), mContact(contact) { }
    
    virtual void Update( float timeins );

private:
    Character* mpCharacter;
    float mTime;
    float mContact;
};

class SurfAction : public PlayAnimationAction
{
public:
    SurfAction(Character*);

protected:
    unsigned mLowCount;
    bool ShouldAbort(void);
    void Update(float);
};

template <class STATE> class ChangeState
:
public Action
{
public:
    ChangeState( Character* c) : mpCharacter(c) { }
    
    virtual void Update( float timeins )
    {
        CharacterAi::SetState<STATE>( mpCharacter->GetStateManager() );
        Done();
    }

private:
    Character* mpCharacter;
};


#endif // HC_SEQUENCER_ACTION_HPP