2303 lines
65 KiB
C++
2303 lines
65 KiB
C++
//-----------------------------------------------------------------------------
|
|
//
|
|
// $Logfile:: /Code/DLLs/game/behaviors_general.h $
|
|
// $Revision:: 115 $
|
|
// $Author:: Steven $
|
|
// $Date:: 10/13/03 9:11a $
|
|
//
|
|
// Copyright (C) 2001 by Ritual Entertainment, Inc.
|
|
// All rights reserved.
|
|
//
|
|
// This source may not be distributed and/or modified without
|
|
// expressly written permission by Ritual Entertainment, Inc.
|
|
//
|
|
//
|
|
// DESCRIPTION:
|
|
// Generalized Behaviors will go in this file. Generalized, meaning, behaviors
|
|
// that are meant to be used easily by multiple actors
|
|
//
|
|
|
|
//==============================
|
|
// Forward Declarations
|
|
//==============================
|
|
class CircleStrafeEntity;
|
|
class DoAttack;
|
|
|
|
#ifndef __BEHAVIORS_GENERAL_H__
|
|
#define __BEHAVIORS_GENERAL_H__
|
|
|
|
#include "behavior.h"
|
|
#include "behaviors.h"
|
|
#include "rotateToEntity.hpp"
|
|
#include "teleportToEntity.hpp"
|
|
#include "teleportToPosition.hpp"
|
|
#include "doAttack.hpp"
|
|
//#include "generalCombatWithMeleeWeapon.hpp"
|
|
#include "helper_node.h"
|
|
#include "actor.h"
|
|
#include "GoDirectlyToPoint.h"
|
|
|
|
//=============================
|
|
// Enums for states
|
|
//=============================
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
//===================================================================================
|
|
//
|
|
// Known Working Behaviors -- May need some clean up, but they do work
|
|
//
|
|
//===================================================================================
|
|
|
|
|
|
//------------------------- CLASS ------------------------------
|
|
//
|
|
// Name: WarpToPosition
|
|
// Base Class: Behavior
|
|
//
|
|
// Description: Attempts to Warp the Actor to the specified
|
|
// position
|
|
//
|
|
// Method of Use: State machine or another behavior
|
|
//--------------------------------------------------------------
|
|
|
|
class WarpToPosition : public Behavior
|
|
{
|
|
//------------------------------------
|
|
// States
|
|
//------------------------------------
|
|
public:
|
|
typedef enum
|
|
{
|
|
WARP_TO_POSITION_CHECK_POSITION,
|
|
WARP_TO_POSITION_WARP,
|
|
WARP_TO_POSITION_FAILED,
|
|
WARP_TO_POSITION_SUCCESS,
|
|
WARP_TO_POSITION_NUMBER_OF_STATES
|
|
} WarpToPosStates_t;
|
|
|
|
|
|
//------------------------------------
|
|
// Parameters
|
|
//------------------------------------
|
|
private:
|
|
Vector _position;
|
|
|
|
public:
|
|
CLASS_PROTOTYPE( WarpToPosition );
|
|
|
|
void SetArgs ( Event *ev );
|
|
void Begin ( Actor &self );
|
|
BehaviorReturnCode_t Evaluate ( Actor &self );
|
|
void End ( Actor &self );
|
|
virtual void Archive ( Archiver &arc );
|
|
|
|
// Mutators
|
|
void SetPosition ( const Vector &position );
|
|
|
|
|
|
//-------------------------------------
|
|
// Internal Functionality
|
|
//-------------------------------------
|
|
protected:
|
|
void checkPosition ( Actor &self );
|
|
void checkPositionFailed ( Actor &self );
|
|
void warpToPosition ( Actor &self );
|
|
|
|
|
|
//-------------------------------------
|
|
// Member Variables
|
|
//-------------------------------------
|
|
private:
|
|
// Member Vars
|
|
int _state; //-- Maintains our Behavior's current State
|
|
|
|
};
|
|
|
|
inline void WarpToPosition::SetPosition( const Vector &position )
|
|
{
|
|
_position = position;
|
|
}
|
|
|
|
inline void WarpToPosition::Archive( Archiver &arc )
|
|
{
|
|
Behavior::Archive( arc );
|
|
|
|
// Archive Parameters
|
|
arc.ArchiveVector ( &_position );
|
|
|
|
// Archive Member Variables
|
|
arc.ArchiveInteger ( &_state );
|
|
|
|
}
|
|
|
|
|
|
//------------------------- CLASS ------------------------------
|
|
//
|
|
// Name: WarpToEntity
|
|
// Base Class: Behavior
|
|
//
|
|
// Description: Attempts to Warp the actor to the specified entity
|
|
//
|
|
// Method of Use: State machine or another behavior
|
|
//--------------------------------------------------------------
|
|
|
|
class WarpToEntity : public Behavior
|
|
{
|
|
//------------------------------------
|
|
// States
|
|
//------------------------------------
|
|
public:
|
|
typedef enum
|
|
{
|
|
WARP_TO_ENTITY_SELECT_POSITION,
|
|
WARP_TO_ENTITY_WARP,
|
|
WARP_TO_ENTITY_FAILED,
|
|
WARP_TO_ENTITY_SUCCESS,
|
|
WARP_TO_ENTITY_NUMBER_OF_STATES
|
|
} WarpToEntStates_t;
|
|
|
|
|
|
typedef enum
|
|
{
|
|
POSITION_REAR,
|
|
POSITION_LEFT,
|
|
POSITION_RIGHT,
|
|
POSITION_FRONT,
|
|
POSITION_NUMBER_OF_POSITIONS
|
|
} WarpToEntPositions_t;
|
|
|
|
//------------------------------------
|
|
// Parameters
|
|
//------------------------------------
|
|
private:
|
|
EntityPtr _entity;
|
|
|
|
public:
|
|
CLASS_PROTOTYPE( WarpToEntity );
|
|
|
|
void SetArgs ( Event *ev );
|
|
void Begin ( Actor &self );
|
|
BehaviorReturnCode_t Evaluate ( Actor &self );
|
|
void End ( Actor &self );
|
|
virtual void Archive ( Archiver &arc );
|
|
|
|
// Mutators
|
|
void SetEntity ( Entity *ent );
|
|
|
|
|
|
//-------------------------------------
|
|
// Internal Functionality
|
|
//-------------------------------------
|
|
protected:
|
|
void selectPosition ( Actor &self );
|
|
void setupWarp ( Actor &self );
|
|
void warpToPosition ( Actor &self );
|
|
void warpToPositionFailed ( Actor &self );
|
|
|
|
|
|
//-------------------------------------
|
|
// Member Variables
|
|
//-------------------------------------
|
|
private:
|
|
// Components
|
|
WarpToPosition _warp;
|
|
|
|
// Member Vars
|
|
unsigned int _state;
|
|
unsigned int _position;
|
|
Vector _destination;
|
|
|
|
// Static Constants
|
|
static const float DIST_TO_ENTITY;
|
|
};
|
|
|
|
inline void WarpToEntity::SetEntity( Entity *ent )
|
|
{
|
|
_entity = ent;
|
|
}
|
|
|
|
inline void WarpToEntity::Archive( Archiver &arc )
|
|
{
|
|
Behavior::Archive( arc );
|
|
|
|
// Archive Parameters
|
|
arc.ArchiveSafePointer ( &_entity );
|
|
|
|
// Archive Components
|
|
arc.ArchiveObject ( &_warp );
|
|
|
|
// Archive Member Variables
|
|
arc.ArchiveUnsigned ( &_state );
|
|
arc.ArchiveUnsigned ( &_position );
|
|
arc.ArchiveVector ( &_destination );
|
|
|
|
}
|
|
|
|
|
|
|
|
//------------------------- CLASS ------------------------------
|
|
//
|
|
// Name: GotoEntity
|
|
// Base Class: Behavior
|
|
//
|
|
// Description: Makes the Actor move to the specified entity
|
|
//
|
|
// Method of Use: State machine or another behavior
|
|
//--------------------------------------------------------------
|
|
class GotoEntity : public Behavior
|
|
{
|
|
//------------------------------------
|
|
// Parameters
|
|
//------------------------------------
|
|
private:
|
|
str _anim;
|
|
float _dist;
|
|
EntityPtr _entity;
|
|
|
|
public:
|
|
CLASS_PROTOTYPE( GotoEntity );
|
|
|
|
GotoEntity();
|
|
|
|
void SetArgs ( Event *ev );
|
|
void Begin ( Actor &self );
|
|
BehaviorReturnCode_t Evaluate ( Actor &self );
|
|
void End ( Actor &self );
|
|
virtual void Archive ( Archiver &arc );
|
|
|
|
// Accessors
|
|
void SetEntity ( Actor &self, Entity *ent );
|
|
void SetAnim ( const str &animName );
|
|
void SetDistance ( float distance );
|
|
Entity* GetEntity ();
|
|
|
|
private:
|
|
// Components
|
|
FollowPathToEntity _chase;
|
|
};
|
|
|
|
inline Entity* GotoEntity::GetEntity()
|
|
{
|
|
return _entity;
|
|
}
|
|
|
|
inline void GotoEntity::SetEntity( Actor &self, Entity *ent )
|
|
{
|
|
if ( ent )
|
|
{
|
|
_entity = ent;
|
|
_chase.SetGoal( ent, _dist, self );
|
|
_chase.Begin( self );
|
|
}
|
|
}
|
|
|
|
inline void GotoEntity::SetAnim( const str &animName )
|
|
{
|
|
_anim = animName;
|
|
}
|
|
|
|
inline void GotoEntity::SetDistance( float distance )
|
|
{
|
|
_dist = distance;
|
|
}
|
|
|
|
inline void GotoEntity::Archive( Archiver &arc )
|
|
{
|
|
Behavior::Archive ( arc );
|
|
|
|
// Archive Paramters
|
|
arc.ArchiveString ( &_anim );
|
|
arc.ArchiveFloat ( &_dist );
|
|
arc.ArchiveSafePointer ( &_entity );
|
|
|
|
// Archive Components
|
|
arc.ArchiveObject ( &_chase );
|
|
|
|
// Archive Member Variables
|
|
}
|
|
|
|
|
|
//------------------------- CLASS ------------------------------
|
|
//
|
|
// Name: GotoPoint
|
|
// Base Class: Behavior
|
|
//
|
|
// Description: Makes the Actor move to the specified position
|
|
//
|
|
// Method of Use: State machine or another behavior
|
|
//--------------------------------------------------------------
|
|
class GotoPoint : public Behavior
|
|
{
|
|
private: // Parameters
|
|
str anim;
|
|
float dist;
|
|
Vector point;
|
|
|
|
protected:
|
|
|
|
public:
|
|
CLASS_PROTOTYPE( GotoPoint );
|
|
|
|
void SetArgs ( Event *ev );
|
|
void Begin ( Actor &self );
|
|
BehaviorReturnCode_t Evaluate ( Actor &self );
|
|
void End ( Actor &self );
|
|
virtual void Archive ( Archiver &arc );
|
|
|
|
// Accessors
|
|
void SetPoint ( const Vector &position );
|
|
void SetAnim ( const str &animName );
|
|
void SetDistance ( float distance );
|
|
|
|
private:
|
|
// Components
|
|
FollowPathToPoint _chase;
|
|
bool _chaseFailed;
|
|
|
|
};
|
|
|
|
inline void GotoPoint::Archive( Archiver &arc )
|
|
{
|
|
Behavior::Archive ( arc );
|
|
|
|
// Archive Paramters
|
|
arc.ArchiveString ( &anim );
|
|
arc.ArchiveFloat ( &dist );
|
|
arc.ArchiveVector ( &point );
|
|
|
|
// Archive Components
|
|
arc.ArchiveObject ( &_chase );
|
|
arc.ArchiveBool ( &_chaseFailed );
|
|
|
|
|
|
// Archive Member Variables
|
|
}
|
|
|
|
|
|
#include "MoveRandomDirection.hpp"
|
|
|
|
//------------------------- CLASS ------------------------------
|
|
//
|
|
// Name: MoveDirectlyToPoint
|
|
// Base Class: Behavior
|
|
//
|
|
// Description: Makes the Actor move to the specified position
|
|
// without regard for obstacle or worl avoidance
|
|
//
|
|
// Method of Use: State machine or another behavior
|
|
//--------------------------------------------------------------
|
|
class MoveDirectlyToPoint : public Behavior
|
|
{
|
|
public:
|
|
CLASS_PROTOTYPE( MoveDirectlyToPoint );
|
|
|
|
void SetArgs ( Event *ev );
|
|
void Begin ( Actor &self );
|
|
BehaviorReturnCode_t Evaluate ( Actor &self );
|
|
void End ( Actor &self );
|
|
virtual void Archive ( Archiver &arc );
|
|
|
|
// Accessors
|
|
void SetAnim ( const str &animName );
|
|
void SetPoint ( const Vector &position );
|
|
void SetDistance ( const float distance );
|
|
|
|
private:
|
|
str _anim;
|
|
float _dist;
|
|
// Components
|
|
GoDirectlyToPoint _motion;
|
|
};
|
|
|
|
inline void MoveDirectlyToPoint::Archive( Archiver &arc )
|
|
{
|
|
Behavior::Archive ( arc );
|
|
|
|
// Archive Parameters
|
|
arc.ArchiveString ( &_anim );
|
|
arc.ArchiveFloat ( &_dist );
|
|
|
|
// Archive Components
|
|
arc.ArchiveObject ( &_motion );
|
|
|
|
}
|
|
|
|
|
|
//------------------------- CLASS ------------------------------
|
|
//
|
|
// Name: GotoSpecified
|
|
// Base Class: Behavior
|
|
//
|
|
// Description: Behavior that will the actor to a specified
|
|
// entity, or pathnode. This will mostly
|
|
// be called from script, and will be a replacement
|
|
// for the GotoPathNode Behavior
|
|
//
|
|
// Method of Use: State machine or another behavior
|
|
//--------------------------------------------------------------
|
|
class GotoSpecified : public Behavior
|
|
{
|
|
//------------------------------------
|
|
// States
|
|
//------------------------------------
|
|
public:
|
|
typedef enum
|
|
{
|
|
GOTO_SPEC_CHASE_TARGET,
|
|
GOTO_SPEC_HOLD,
|
|
GOTO_SPEC_WARP_TO_PATH,
|
|
GOTO_SPEC_WARP_TO_DESTINATION,
|
|
GOTO_SPEC_SUCCESS,
|
|
GOTO_SPEC_FAILED,
|
|
GOTO_SPEC_NUMBER_OF_STATES
|
|
} GotoSpecifiedStates_t;
|
|
|
|
public:
|
|
typedef enum
|
|
{
|
|
GOTO_SPEC_CHASE_POSITION,
|
|
GOTO_SPEC_CHASE_ENTITY,
|
|
GOTO_SPEC_CHASE_NUMBER_OF_MODES,
|
|
} GotoSpecifiedModes_t;
|
|
|
|
//------------------------------------
|
|
// Parameters
|
|
//------------------------------------
|
|
private:
|
|
str _anim;
|
|
EntityPtr _targetEntity;
|
|
Vector _targetPosition;
|
|
EntityPtr _headwatchTarget;
|
|
bool _forceToTarget;
|
|
bool _turnAtEnd ;
|
|
int _maxFailures;
|
|
|
|
public:
|
|
CLASS_PROTOTYPE( GotoSpecified );
|
|
|
|
void SetArgs ( Event *ev );
|
|
void AnimDone ( Event *ev );
|
|
void Begin ( Actor &self );
|
|
BehaviorReturnCode_t Evaluate ( Actor &self );
|
|
void End ( Actor &self );
|
|
virtual void Archive ( Archiver &arc );
|
|
|
|
// Accessors
|
|
void SetAnim ( const str &animName );
|
|
void SetEntity ( Entity *ent );
|
|
void SetPosition ( const Vector &pos );
|
|
void SetHeadwatchTarget ( Entity *ent );
|
|
void SetForce ( bool force );
|
|
|
|
|
|
//-------------------------------------
|
|
// Internal Functionality
|
|
//-------------------------------------
|
|
protected:
|
|
void setupChasePosition ( Actor &self );
|
|
void setupChaseEntity ( Actor &self );
|
|
void setupWarpToPathNode ( Actor &self );
|
|
void setupWarpToDestination ( Actor &self );
|
|
void setupHold ( Actor &self );
|
|
|
|
void chasePosition ( Actor &self );
|
|
void chaseEntity ( Actor &self );
|
|
void warpToNearestPathNode ( Actor &self );
|
|
void warpToDestination ( Actor &self );
|
|
void hold ( Actor &self );
|
|
void setAngles ( Actor &self );
|
|
|
|
void chaseFailed ( Actor &self );
|
|
|
|
|
|
|
|
//-------------------------------------
|
|
// Member Variables
|
|
//-------------------------------------
|
|
private:
|
|
// Components
|
|
GotoPoint _chasePosition;
|
|
GotoEntity _chaseEntity;
|
|
WarpToEntity _warpToEntity;
|
|
WarpToPosition _warpToPosition;
|
|
|
|
// Member Variables
|
|
unsigned int _state;
|
|
unsigned int _mode;
|
|
int _moveFailures;
|
|
float _holdTime;
|
|
bool _attemptedPathWarp;
|
|
Vector _endAngles;
|
|
|
|
// Constants
|
|
static const float DIST_TO_TARGET_POSITION;
|
|
static const float DIST_TO_TARGET_ENTITY;
|
|
};
|
|
|
|
inline void GotoSpecified::SetAnim ( const str &animName )
|
|
{
|
|
_anim = animName;
|
|
}
|
|
|
|
inline void GotoSpecified::SetEntity ( Entity *ent )
|
|
{
|
|
_targetEntity = ent;
|
|
_mode = GOTO_SPEC_CHASE_ENTITY;
|
|
}
|
|
|
|
inline void GotoSpecified::SetPosition ( const Vector &pos )
|
|
{
|
|
_targetPosition = pos;
|
|
_mode = GOTO_SPEC_CHASE_POSITION;
|
|
}
|
|
|
|
inline void GotoSpecified::SetHeadwatchTarget( Entity *ent )
|
|
{
|
|
_headwatchTarget = ent;
|
|
}
|
|
|
|
inline void GotoSpecified::SetForce ( bool force )
|
|
{
|
|
_forceToTarget = force;
|
|
}
|
|
|
|
inline void GotoSpecified::Archive( Archiver &arc )
|
|
{
|
|
Behavior::Archive ( arc );
|
|
|
|
// Archive Paramters
|
|
arc.ArchiveString ( &_anim );
|
|
arc.ArchiveSafePointer ( &_targetEntity );
|
|
arc.ArchiveVector ( &_targetPosition );
|
|
arc.ArchiveSafePointer ( &_headwatchTarget );
|
|
arc.ArchiveBool ( &_forceToTarget );
|
|
arc.ArchiveBool ( &_turnAtEnd );
|
|
|
|
// Archive Components
|
|
arc.ArchiveObject ( &_chasePosition );
|
|
arc.ArchiveObject ( &_chaseEntity );
|
|
arc.ArchiveObject ( &_warpToEntity );
|
|
arc.ArchiveObject ( &_warpToPosition );
|
|
|
|
// Archive Member Variables
|
|
arc.ArchiveUnsigned ( &_state );
|
|
arc.ArchiveUnsigned ( &_mode );
|
|
arc.ArchiveInteger ( &_moveFailures );
|
|
arc.ArchiveFloat ( &_holdTime );
|
|
arc.ArchiveBool ( &_attemptedPathWarp );
|
|
arc.ArchiveVector ( &_endAngles );
|
|
arc.ArchiveInteger ( &_maxFailures );
|
|
}
|
|
|
|
//------------------------- CLASS ------------------------------
|
|
//
|
|
// Name: MoveFromConeOfFire
|
|
// Base Class: Behavior
|
|
//
|
|
// Description: The Actor does some traces to find a spot out
|
|
// of the way of the player's cone of fire. If
|
|
// the traces fail, it tries to find a node that
|
|
// satisfies that condition. If that fails,
|
|
// then the behavior fails.
|
|
//
|
|
// Method of Use: State machine or another behavior
|
|
//--------------------------------------------------------------
|
|
|
|
class MoveFromConeOfFire : public Behavior
|
|
{
|
|
//------------------------------------
|
|
// States
|
|
//------------------------------------
|
|
public:
|
|
typedef enum
|
|
{
|
|
MOVE_FCOF_SEARCHING_FOR_SPOT,
|
|
MOVE_FCOF_STATE_FOUND_SPOT,
|
|
MOVE_FCOF_STATE_SEARCHING_FOR_NODE,
|
|
MOVE_FCOF_STATE_FOUND_NODE,
|
|
MOVE_FCOF_STATE_NO_SPOT,
|
|
MOVE_FCOF_SUCCESS,
|
|
MOVE_FCOF_FAILED,
|
|
MOVE_FCOF_NUMBER_OF_STATES
|
|
} MoveFCOFStates_t;
|
|
|
|
|
|
//------------------------------------
|
|
// Parameters
|
|
//------------------------------------
|
|
private:
|
|
str _anim; // --The animation that will be used ( Walk, Run, SideStep, etc )
|
|
|
|
public:
|
|
CLASS_PROTOTYPE( MoveFromConeOfFire );
|
|
|
|
void SetArgs ( Event *ev );
|
|
void Begin ( Actor &self );
|
|
BehaviorReturnCode_t Evaluate ( Actor &self );
|
|
void End ( Actor &self );
|
|
virtual void Archive ( Archiver &arc );
|
|
|
|
// Mutators
|
|
void SetAnim ( const str &anim );
|
|
|
|
//-------------------------------------
|
|
// Internal Functionality
|
|
//-------------------------------------
|
|
protected:
|
|
PathNode *_FindNode ( Actor &self );
|
|
void _setDirectionVectors ( Actor &self );
|
|
void _foundDestination ( Actor &self );
|
|
void _noDestination ( Actor &self );
|
|
void _searchForNode ( Actor &self );
|
|
bool _checkDesiredMovement ( Actor &self , const Vector &startPos , const Vector &endPos );
|
|
|
|
|
|
//-------------------------------------
|
|
// Member Variables
|
|
//-------------------------------------
|
|
private:
|
|
// Component Behaviors
|
|
GotoPoint _chase; //-- Behavior that will steer us to our desired position
|
|
|
|
// Member Vars
|
|
int _state; //-- Maintains our Behavior's current State
|
|
float _nextsearch; //-- Next Time we are allowed to search for a position
|
|
Vector _newDestination; //-- Where we're going
|
|
Vector _left; //-- Holds Data for Left Direction Check
|
|
Vector _right; //-- Holds Data for Right Direction Check
|
|
bool _stuckOnPlayer; //-- Flag for being stuck on the player
|
|
float _oldTurnSpeed;
|
|
Vector _destination;
|
|
str _torsoAnim;
|
|
bool _nextToObstacle;
|
|
|
|
// Constants
|
|
static const float CONE_OF_FIRE_RADIUS;
|
|
};
|
|
|
|
|
|
inline void MoveFromConeOfFire::Archive( Archiver &arc )
|
|
{
|
|
Behavior::Archive( arc );
|
|
|
|
// Archive Parameters
|
|
arc.ArchiveString ( &_anim );
|
|
|
|
// Archive Components
|
|
arc.ArchiveObject ( &_chase );
|
|
|
|
// Archive Member Variables
|
|
arc.ArchiveInteger ( &_state );
|
|
arc.ArchiveFloat ( &_nextsearch );
|
|
arc.ArchiveVector ( &_newDestination );
|
|
arc.ArchiveVector ( &_left );
|
|
arc.ArchiveVector ( &_right );
|
|
arc.ArchiveBool ( &_stuckOnPlayer );
|
|
arc.ArchiveFloat ( &_oldTurnSpeed );
|
|
arc.ArchiveVector ( &_destination );
|
|
arc.ArchiveString ( &_torsoAnim );
|
|
arc.ArchiveBool ( &_nextToObstacle );
|
|
}
|
|
|
|
inline void MoveFromConeOfFire::SetAnim( const str &anim )
|
|
{
|
|
_anim = anim;
|
|
}
|
|
|
|
//------------------------- CLASS ------------------------------
|
|
//
|
|
// Name: Strafe
|
|
// Base Class: Behavior
|
|
//
|
|
// Description: Makes the Actor strafe
|
|
//
|
|
// Method of Use: State machine or another behavior
|
|
//--------------------------------------------------------------
|
|
class Strafe : public Behavior
|
|
{
|
|
public: // Modes
|
|
enum
|
|
{
|
|
STRAFE_LEFT,
|
|
STRAFE_RIGHT,
|
|
STRAFE_RANDOM,
|
|
STRAFE_NUMBER_OF_MODES
|
|
};
|
|
|
|
private: // Parameters
|
|
unsigned int mode;
|
|
|
|
protected:
|
|
void _init ( Actor &self );
|
|
void _setAnim ( Actor &self );
|
|
|
|
public:
|
|
CLASS_PROTOTYPE( Strafe );
|
|
|
|
void SetArgs ( Event *ev );
|
|
void AnimDone ( Event *ev );
|
|
void Begin ( Actor &self );
|
|
BehaviorReturnCode_t Evaluate ( Actor &self );
|
|
void End ( Actor &self );
|
|
virtual void Archive ( Archiver &arc );
|
|
|
|
// Accessors
|
|
void SetMode ( unsigned int strafeMode );
|
|
|
|
private:
|
|
str _anim;
|
|
bool _canStrafe;
|
|
bool _strafeComplete;
|
|
|
|
|
|
};
|
|
|
|
inline void Strafe::Archive( Archiver &arc )
|
|
{
|
|
Behavior::Archive ( arc );
|
|
|
|
// Archive Paramters
|
|
arc.ArchiveUnsigned ( &mode );
|
|
|
|
// Archive Components
|
|
|
|
// Archive Member Variables
|
|
arc.ArchiveString ( &_anim );
|
|
arc.ArchiveBool ( &_canStrafe );
|
|
arc.ArchiveBool ( &_strafeComplete );
|
|
}
|
|
|
|
|
|
//------------------------- CLASS ------------------------------
|
|
//
|
|
// Name: CircleStrafeEntity
|
|
// Base Class: Behavior
|
|
//
|
|
// Description: Makes the Actor circle strafe
|
|
//
|
|
// Method of Use: State machine or another behavior
|
|
//
|
|
// ** Needs Additional Work **
|
|
//--------------------------------------------------------------
|
|
class CircleStrafeEntity : public Behavior
|
|
{
|
|
private: //Parameters
|
|
str _type;
|
|
float _radius;
|
|
str _legAnim;
|
|
bool _clockwise;
|
|
float _testDistance;
|
|
|
|
|
|
public:
|
|
CLASS_PROTOTYPE( CircleStrafeEntity );
|
|
|
|
void SetArgs ( Event *ev );
|
|
void Begin ( Actor &self );
|
|
BehaviorReturnCode_t Evaluate ( Actor &self );
|
|
void End ( Actor &self );
|
|
virtual void Archive ( Archiver &arc );
|
|
|
|
void SetType ( const str &type );
|
|
void SetRadius ( float radius );
|
|
void SetAnim ( const str &anim );
|
|
void SetClockwise ( bool clockwise );
|
|
void SetTestDistance ( float testDistance );
|
|
|
|
protected: //Functions
|
|
Entity* _getStrafeTarget( Actor &self , const str &target );
|
|
void _checkParameters(Event *ev);
|
|
qboolean _checkIfStuck(Actor &self);
|
|
void _init( Actor &self );
|
|
|
|
|
|
private: //Member Vars
|
|
Wander _wander;
|
|
EntityPtr _strafeTarget;
|
|
Vector _lastPosition;
|
|
int _moveAttempts;
|
|
Vector _holdAngles;
|
|
bool _failed;
|
|
float _recheckTime;
|
|
|
|
float _startWanderTime;
|
|
|
|
|
|
};
|
|
|
|
inline void CircleStrafeEntity::SetType( const str &type )
|
|
{
|
|
_type = type;
|
|
}
|
|
|
|
inline void CircleStrafeEntity::SetRadius( float radius )
|
|
{
|
|
_radius = radius;
|
|
}
|
|
|
|
inline void CircleStrafeEntity::SetAnim( const str &anim )
|
|
{
|
|
_legAnim = anim;
|
|
}
|
|
|
|
inline void CircleStrafeEntity::SetClockwise( bool clockwise )
|
|
{
|
|
_clockwise = clockwise;
|
|
}
|
|
|
|
inline void CircleStrafeEntity::SetTestDistance( float testDistance )
|
|
{
|
|
_testDistance = testDistance;
|
|
}
|
|
|
|
inline void CircleStrafeEntity::Archive ( Archiver &arc )
|
|
{
|
|
Behavior::Archive( arc );
|
|
|
|
// Archive Parameters
|
|
arc.ArchiveString ( &_type );
|
|
arc.ArchiveFloat ( &_radius );
|
|
arc.ArchiveString ( &_legAnim );
|
|
arc.ArchiveBool ( &_clockwise );
|
|
arc.ArchiveFloat ( &_testDistance );
|
|
|
|
// Archive Member Vars
|
|
arc.ArchiveObject ( &_wander );
|
|
arc.ArchiveSafePointer ( &_strafeTarget );
|
|
arc.ArchiveVector ( &_lastPosition );
|
|
arc.ArchiveInteger ( &_moveAttempts );
|
|
arc.ArchiveVector ( &_holdAngles );
|
|
arc.ArchiveBool ( &_failed );
|
|
arc.ArchiveFloat ( &_recheckTime );
|
|
|
|
arc.ArchiveFloat( &_startWanderTime );
|
|
}
|
|
|
|
|
|
|
|
|
|
//------------------------- CLASS ------------------------------
|
|
//
|
|
// Name: FollowInFormation
|
|
// Base Class: Behavior
|
|
//
|
|
// Description: Works with other followers to follow in a single file line
|
|
//
|
|
// Method Of Use: State Machine or other Behaviors
|
|
//---------------------------------------------------------------
|
|
class FollowInFormation : public Behavior
|
|
{
|
|
//------------------------------------
|
|
// States
|
|
//------------------------------------
|
|
public:
|
|
typedef enum
|
|
{
|
|
FOLLOW_TARGET_STATE_SELECT_STATE,
|
|
FOLLOW_TARGET_STATE_FIND_FOLLOW_TARGET,
|
|
FOLLOW_TARGET_STATE_FOLLOW_TARGET,
|
|
FOLLOW_TARGET_STATE_FOLLOW_HOLD,
|
|
FOLLOW_TARGET_STATE_FOLLOW_WARP_TO_NEAREST_PATHNODE,
|
|
FOLLOW_TARGET_STATE_FOLLOW_WARP_TO_FOLLOW_TARGET,
|
|
FOLLOW_TARGET_STATE_FOLLOW_FAILED,
|
|
FOLLOW_TARGET_STATE_FOLLOW_NO_TARGET,
|
|
FOLLOW_TARGET_STATE_FOLLOW_SUCCESS,
|
|
FOLLOW_TARGET_NUMBER_OF_STATES
|
|
} followTargetStates_t;
|
|
|
|
//------------------------------------
|
|
// Parameters
|
|
//------------------------------------
|
|
private:
|
|
str _anim;
|
|
float _emergencyDistance;
|
|
float _catchupSpeed;
|
|
|
|
public:
|
|
CLASS_PROTOTYPE( FollowInFormation );
|
|
|
|
void SetArgs ( Event *ev );
|
|
void Begin ( Actor &self );
|
|
BehaviorReturnCode_t Evaluate ( Actor &self );
|
|
void End ( Actor &self );
|
|
virtual void Archive ( Archiver &arc );
|
|
|
|
void SetDefaultFollowTarget ( Actor &self );
|
|
// Mutators
|
|
void SetAnim ( const str &anim );
|
|
void SetEmergencyDistance ( float dist );
|
|
void SetCatchupSpeed ( float speed );
|
|
|
|
|
|
// Accessors
|
|
float GetFollowRange ( );
|
|
unsigned int GetState ( );
|
|
|
|
//-------------------------------------
|
|
// Internal Functionality
|
|
//-------------------------------------
|
|
protected:
|
|
void findFollowTarget ( Actor &self );
|
|
|
|
void selectState ( Actor &self );
|
|
|
|
void setupFollow ( Actor &self );
|
|
void follow ( Actor &self );
|
|
void followFailed ( Actor &self );
|
|
|
|
void setupWarpToPathNode ( Actor &self );
|
|
void warpToPathNode ( Actor &self );
|
|
|
|
void setupWarpToTarget ( Actor &self );
|
|
void warpToTarget ( Actor &self );
|
|
|
|
void setupHold ( Actor &self );
|
|
void hold ( Actor &self );
|
|
|
|
void checkSpeed ( Actor &self );
|
|
|
|
//-------------------------------------
|
|
// Member Variables
|
|
//-------------------------------------
|
|
private:
|
|
// Components
|
|
GotoEntity _followEntity;
|
|
WarpToEntity _warpToEntity;
|
|
WarpToPosition _warpToPosition;
|
|
|
|
// Member Vars
|
|
unsigned int _state;
|
|
float _followFailureTime;
|
|
float _nextFollowAttemptTime;
|
|
float _followDist;
|
|
float _followDistMin;
|
|
float _nextTargetCheckTime;
|
|
float _endHold;
|
|
bool _selectedFollowTarget;
|
|
bool _attemptedWarpToPath;
|
|
bool _setFollowFailureTime;
|
|
float _oldForwardSpeed;
|
|
float _oldTurnSpeed;
|
|
bool _codeDriven;
|
|
|
|
|
|
};
|
|
|
|
inline void FollowInFormation::SetEmergencyDistance( float dist )
|
|
{
|
|
_emergencyDistance = dist;
|
|
}
|
|
|
|
inline void FollowInFormation::SetCatchupSpeed( float speed )
|
|
{
|
|
_catchupSpeed = speed;
|
|
}
|
|
|
|
inline void FollowInFormation::Archive( Archiver &arc )
|
|
{
|
|
Behavior::Archive( arc );
|
|
|
|
// Archive Parameters
|
|
arc.ArchiveString ( &_anim );
|
|
arc.ArchiveFloat ( &_emergencyDistance );
|
|
arc.ArchiveFloat ( &_catchupSpeed );
|
|
|
|
// Archive Components
|
|
arc.ArchiveObject ( &_followEntity );
|
|
arc.ArchiveObject ( &_warpToEntity );
|
|
arc.ArchiveObject ( &_warpToPosition );
|
|
|
|
// Archive Member Vars
|
|
arc.ArchiveUnsigned ( &_state );
|
|
arc.ArchiveFloat ( &_followFailureTime );
|
|
arc.ArchiveFloat ( &_nextFollowAttemptTime );
|
|
arc.ArchiveFloat ( &_followDist );
|
|
arc.ArchiveFloat ( &_followDistMin );
|
|
arc.ArchiveFloat ( &_nextTargetCheckTime );
|
|
arc.ArchiveFloat ( &_endHold );
|
|
arc.ArchiveBool ( &_selectedFollowTarget );
|
|
arc.ArchiveBool ( &_attemptedWarpToPath );
|
|
arc.ArchiveBool ( &_setFollowFailureTime );
|
|
arc.ArchiveFloat ( &_oldForwardSpeed );
|
|
arc.ArchiveFloat ( &_oldTurnSpeed );
|
|
arc.ArchiveBool ( &_codeDriven );
|
|
|
|
}
|
|
|
|
inline void FollowInFormation::SetAnim(const str &anim )
|
|
{
|
|
_anim = anim;
|
|
}
|
|
|
|
inline float FollowInFormation::GetFollowRange()
|
|
{
|
|
return _followDist;
|
|
}
|
|
|
|
inline unsigned int FollowInFormation::GetState()
|
|
{
|
|
return _state;
|
|
}
|
|
|
|
|
|
//------------------------- CLASS ------------------------------
|
|
//
|
|
// Name: GroupFollow
|
|
// Base Class: Behavior
|
|
//
|
|
// Description: Works with other followers to follow in a single file line
|
|
//
|
|
// Method Of Use: State Machine or other Behaviors
|
|
//---------------------------------------------------------------
|
|
class GroupFollow : public Behavior
|
|
{
|
|
//------------------------------------
|
|
// States
|
|
//------------------------------------
|
|
public:
|
|
typedef enum
|
|
{
|
|
CLOSE_WITH_TARGET,
|
|
PACE_TARGET,
|
|
HOLD,
|
|
WANDER,
|
|
NUMBER_OF_STATES,
|
|
INVALID = -1,
|
|
} States;
|
|
|
|
//------------------------------------
|
|
// Parameters
|
|
//------------------------------------
|
|
public:
|
|
CLASS_PROTOTYPE( GroupFollow );
|
|
|
|
void SetArgs( Event *ev );
|
|
void AnimDone( Event *ev );
|
|
void SetArgs ( const float stopDistance, const float paceDistance );
|
|
void Begin( Actor &self );
|
|
BehaviorReturnCode_t Evaluate ( Actor &self );
|
|
void End( Actor &self );
|
|
virtual void Archive( Archiver &arc );
|
|
|
|
// Accessors
|
|
int GetState( void );
|
|
|
|
//-------------------------------------
|
|
// Internal Functionality
|
|
//-------------------------------------
|
|
protected:
|
|
BehaviorReturnCode_t FindFollowTarget( Actor &self );
|
|
BehaviorReturnCode_t Hold( Actor &self );
|
|
BehaviorReturnCode_t PaceTarget( Actor &self );
|
|
BehaviorReturnCode_t CloseWithTarget( Actor &self );
|
|
BehaviorReturnCode_t Wander(Actor &self );
|
|
|
|
float ComputePaceAnimationRateMultiplier( Actor &self );
|
|
float ComputeAnimationRate( Actor &self, const str &animationName, const float scale );
|
|
void GotoHoldState( Actor &self );
|
|
void GotoPaceTargetState( Actor &self );
|
|
void GotoCloseWithTargetState( Actor &self );
|
|
void GotoWanderState(Actor &self);
|
|
|
|
|
|
//-------------------------------------
|
|
// Member Variables
|
|
//-------------------------------------
|
|
private:
|
|
static const float _minRangeMultiplier;
|
|
static const float _maxRangeMultiplier;
|
|
str _idleAnimation;
|
|
str _paceAnimation;
|
|
str _closeAnimation;
|
|
str _torsoAnimation;
|
|
GotoEntity _follow;
|
|
MoveRandomDirection _wander;
|
|
int _state;
|
|
bool _animationRateNeedsUpdate;
|
|
|
|
float _stopDistance;
|
|
float _paceDistance;
|
|
float _endHold;
|
|
float _oldForwardSpeed;
|
|
float _nextFindFollowTime;
|
|
float _nextPathLenCheckTime;
|
|
float _nextPathLenCheckTime2;
|
|
|
|
};
|
|
|
|
inline void GroupFollow::Archive( Archiver &arc )
|
|
{
|
|
Behavior::Archive( arc );
|
|
|
|
arc.ArchiveString( &_idleAnimation );
|
|
arc.ArchiveString( &_paceAnimation );
|
|
arc.ArchiveString( &_closeAnimation );
|
|
arc.ArchiveString( &_torsoAnimation );
|
|
arc.ArchiveObject( &_follow );
|
|
arc.ArchiveObject( &_wander );
|
|
arc.ArchiveInteger( &_state );
|
|
arc.ArchiveBool( &_animationRateNeedsUpdate );
|
|
|
|
arc.ArchiveFloat( &_stopDistance );
|
|
arc.ArchiveFloat( &_paceDistance );
|
|
|
|
arc.ArchiveFloat( &_endHold );
|
|
arc.ArchiveFloat( &_oldForwardSpeed );
|
|
arc.ArchiveFloat( &_nextFindFollowTime );
|
|
arc.ArchiveFloat( &_nextPathLenCheckTime );
|
|
arc.ArchiveFloat( &_nextPathLenCheckTime2 );
|
|
}
|
|
|
|
inline int GroupFollow::GetState()
|
|
{
|
|
return _state;
|
|
}
|
|
//------------------------- CLASS ------------------------------
|
|
//
|
|
// Name: MoveToDistanceFromEnemy
|
|
// Base Class: Behavior
|
|
//
|
|
// Description: Takes information from all the enemies in the
|
|
// actors hate list and uses them to get the
|
|
// best vector away from them.
|
|
//
|
|
// Method of Use: State Machine or other Behaviors
|
|
//--------------------------------------------------------------
|
|
class MoveToDistanceFromEnemy : public Behavior
|
|
{
|
|
public: // States
|
|
typedef enum
|
|
{
|
|
MOVE_TO_DISTANCE_STATE_SEARCHING_FOR_SPOT,
|
|
MOVE_TO_DISTANCE_STATE_FOUND_SPOT,
|
|
MOVE_TO_DISTANCE_STATE_SEARCHING_FOR_NODE,
|
|
MOVE_TO_DISTANCE_STATE_FOUND_NODE,
|
|
MOVE_TO_DISTANCE_STATE_NO_SPOT,
|
|
MOVE_TO_DISTANCE_NUMBER_OF_STATES
|
|
} MoveToDistanceStates_t;
|
|
|
|
private:
|
|
str _anim;
|
|
float _distance;
|
|
|
|
public:
|
|
CLASS_PROTOTYPE( MoveToDistanceFromEnemy );
|
|
|
|
void SetArgs ( Event *ev );
|
|
void Begin ( Actor &self );
|
|
BehaviorReturnCode_t Evaluate ( Actor &self );
|
|
void End ( Actor &self );
|
|
virtual void Archive ( Archiver &arc );
|
|
|
|
// Accessors
|
|
void SetAnim ( const str &anim );
|
|
void SetDistance ( float distance );
|
|
|
|
|
|
protected:
|
|
void _checkParameters ( Event *ev );
|
|
PathNode *_FindNode ( Actor &self );
|
|
|
|
private:
|
|
// Components
|
|
FollowPathToPoint _chase;
|
|
|
|
// Member Vars
|
|
int _state;
|
|
float _nextsearch;
|
|
Vector _away;
|
|
Vector _toTeam;
|
|
|
|
};
|
|
|
|
inline void MoveToDistanceFromEnemy::Archive( Archiver &arc )
|
|
{
|
|
Behavior::Archive( arc );
|
|
|
|
// Archive Parameters
|
|
arc.ArchiveString ( &_anim );
|
|
arc.ArchiveFloat ( &_distance );
|
|
|
|
// Archive Components
|
|
arc.ArchiveObject ( &_chase );
|
|
|
|
// Archive Member Vars
|
|
arc.ArchiveInteger( &_state );
|
|
arc.ArchiveFloat ( &_nextsearch );
|
|
arc.ArchiveVector ( &_away );
|
|
arc.ArchiveVector ( &_toTeam );
|
|
}
|
|
|
|
|
|
|
|
|
|
//Bleh
|
|
#include "MoveRandomDirection.hpp"
|
|
|
|
|
|
//------------------------- CLASS ------------------------------
|
|
//
|
|
// Name: BackAwayFromEnemy
|
|
// Base Class: Behavior
|
|
//
|
|
// Description: Template that can be copied and pasted to
|
|
// generate new behavior
|
|
//
|
|
// Method of Use: State machine or another behavior
|
|
//--------------------------------------------------------------
|
|
|
|
class BackAwayFromEnemy : public Behavior
|
|
{
|
|
//------------------------------------
|
|
// States
|
|
//------------------------------------
|
|
public:
|
|
typedef enum
|
|
{
|
|
BAFE_SELECT_STATE,
|
|
BAFE_BACK_AWAY,
|
|
BAFE_BACK_AWAY_FAILED,
|
|
BAFE_BACK_AWAY_SUCCESS,
|
|
BAFE_NUMBER_OF_STATES
|
|
} BAFEStates_t;
|
|
|
|
|
|
//------------------------------------
|
|
// Parameters
|
|
//------------------------------------
|
|
private:
|
|
str _anim;
|
|
float _dist;
|
|
float _minDist;
|
|
|
|
public:
|
|
CLASS_PROTOTYPE( BackAwayFromEnemy );
|
|
|
|
void SetArgs ( Event *ev );
|
|
void AnimDone ( Event *ev );
|
|
void Begin ( Actor &self );
|
|
BehaviorReturnCode_t Evaluate ( Actor &self );
|
|
void End ( Actor &self );
|
|
virtual void Archive ( Archiver &arc );
|
|
|
|
// Mutators
|
|
void SetAnim ( const str &anim );
|
|
void SetDist ( float dist );
|
|
void SetMinDist ( float minDist );
|
|
|
|
|
|
//-------------------------------------
|
|
// Internal Functionality
|
|
//-------------------------------------
|
|
protected:
|
|
void selectState ( Actor &self );
|
|
void setupMoveRandom ( Actor &self );
|
|
void moveRandom ( Actor &self );
|
|
void moveRandomFailed ( Actor &self );
|
|
|
|
//-------------------------------------
|
|
// Member Variables
|
|
//-------------------------------------
|
|
private:
|
|
// Component Behaviors
|
|
MoveRandomDirection _moveRandom; //-- Behavior that will steer us to our desired position
|
|
|
|
// Member Vars
|
|
int _state; //-- Maintains our Behavior's current State
|
|
|
|
};
|
|
|
|
|
|
inline void BackAwayFromEnemy::Archive( Archiver &arc )
|
|
{
|
|
Behavior::Archive( arc );
|
|
|
|
// Archive Parameters
|
|
arc.ArchiveString ( &_anim );
|
|
arc.ArchiveFloat ( &_dist );
|
|
arc.ArchiveFloat ( &_minDist );
|
|
|
|
// Archive Components
|
|
arc.ArchiveObject ( &_moveRandom );
|
|
|
|
// Archive Member Variables
|
|
arc.ArchiveInteger ( &_state );
|
|
|
|
}
|
|
|
|
inline void BackAwayFromEnemy::SetAnim( const str &anim )
|
|
{
|
|
_anim = anim;
|
|
}
|
|
|
|
inline void BackAwayFromEnemy::SetDist( float dist )
|
|
{
|
|
_dist = dist;
|
|
}
|
|
|
|
inline void BackAwayFromEnemy::SetMinDist( float dist )
|
|
{
|
|
_minDist = dist;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
//------------------------- CLASS ------------------------------
|
|
//
|
|
// Name: AlertIdle
|
|
// Base Class: Behavior
|
|
//
|
|
// Description: The Actor is idle, but willing to get out of
|
|
// the way, follow the player, and (eventually)
|
|
// investigate.
|
|
//
|
|
// Method of Use: Statemachine or another behavior
|
|
//--------------------------------------------------------------
|
|
class AlertIdle : public Behavior
|
|
{
|
|
//------------------------------------
|
|
// States
|
|
//------------------------------------
|
|
public:
|
|
typedef enum
|
|
{
|
|
ALERT_IDLE_SELECT_STATE,
|
|
ALERT_IDLE_IN_THE_WAY,
|
|
ALERT_IDLE_FOLLOW,
|
|
ALERT_IDLE_HOLD,
|
|
ALERT_IDLE_WANDER,
|
|
ALERT_IDLE_NUMBER_OF_STATES
|
|
} AlertIdleStates_t;
|
|
|
|
//------------------------------------
|
|
// Parameters
|
|
//------------------------------------
|
|
private:
|
|
str _followAnim; // Animation to use when following
|
|
str _torsoAnim; // Torso animation to play
|
|
float _baseIdleTime; // Our base time to idle, before wandering
|
|
float _emergencyDist; // Distance at which we switch to code driven speed to catch up
|
|
float _followDist;
|
|
float _wanderDist;
|
|
|
|
|
|
|
|
//-------------------------------------
|
|
// Internal Functionality
|
|
//-------------------------------------
|
|
protected:
|
|
void _init ( Actor &self );
|
|
void _selectState ( Actor &self );
|
|
|
|
void _setupGetOutOfTheWay ( Actor &self );
|
|
void _doGetOutOfTheWay ( Actor &self );
|
|
|
|
void _setupFollow ( Actor &self );
|
|
void _doFollow ( Actor &self );
|
|
|
|
bool _tryWander ( Actor &self );
|
|
void _setupWander ( Actor &self );
|
|
void _doWander ( Actor &self );
|
|
|
|
void _setupHold ( Actor &self );
|
|
void _hold ( Actor &self );
|
|
|
|
void _setNextWanderTime ( Actor &self );
|
|
bool _checkInTheWay ( Actor &self );
|
|
|
|
void _setTorsoAnim ( Actor &self );
|
|
void checkDistance ( Actor &self );
|
|
|
|
public:
|
|
CLASS_PROTOTYPE( AlertIdle );
|
|
|
|
void SetArgs ( Event *ev );
|
|
void AnimDone ( Event *ev );
|
|
|
|
void Begin ( Actor &self );
|
|
BehaviorReturnCode_t Evaluate ( Actor &self );
|
|
void End ( Actor &self );
|
|
|
|
virtual void Archive ( Archiver &arc );
|
|
|
|
//-------------------------------------
|
|
// Member Variables
|
|
//-------------------------------------
|
|
private:
|
|
// Components
|
|
MoveFromConeOfFire _getOutOfTheWay;
|
|
FollowInFormation _follow;
|
|
MoveRandomDirection _wander;
|
|
|
|
// Member Vars
|
|
float _nextFollowAttempt;
|
|
float _nextWanderTime;
|
|
|
|
unsigned int _state;
|
|
bool _useTorsoAnim;
|
|
bool _unableToFollow;
|
|
Actor* _self;
|
|
};
|
|
|
|
|
|
inline void AlertIdle::Archive( Archiver &arc )
|
|
{
|
|
Behavior::Archive ( arc );
|
|
|
|
// Archive Parameters
|
|
arc.ArchiveString ( &_followAnim );
|
|
arc.ArchiveString ( &_torsoAnim );
|
|
arc.ArchiveFloat ( &_baseIdleTime );
|
|
arc.ArchiveFloat ( &_emergencyDist );
|
|
arc.ArchiveFloat ( &_followDist );
|
|
arc.ArchiveFloat ( &_wanderDist );
|
|
|
|
// Archive Components
|
|
arc.ArchiveObject ( &_getOutOfTheWay );
|
|
arc.ArchiveObject ( &_follow );
|
|
arc.ArchiveObject ( &_wander );
|
|
|
|
|
|
|
|
// Archive Member Vars
|
|
arc.ArchiveFloat ( &_nextFollowAttempt );
|
|
arc.ArchiveFloat ( &_nextWanderTime );
|
|
arc.ArchiveUnsigned ( &_state );
|
|
arc.ArchiveBool ( &_useTorsoAnim );
|
|
arc.ArchiveBool ( &_unableToFollow );
|
|
|
|
arc.ArchiveObjectPointer ( ( Class ** )&_self );
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
//------------------------- CLASS ------------------------------
|
|
//
|
|
// Name: DoBeamAttack
|
|
// Base Class: Behavior
|
|
//
|
|
// Description: Rotates the Actor towards its enemy then
|
|
// plays the specified attack animation
|
|
// Similar to the Do Attack Behavior,
|
|
// This one is setup to use and do beam/laser
|
|
// types of attacks
|
|
//
|
|
//
|
|
// Method of Use: State machine or called from another behavior
|
|
//--------------------------------------------------------------
|
|
class DoBeamAttack : public Behavior
|
|
{
|
|
private: // Parameters
|
|
str tagName;
|
|
str beamShader;
|
|
str impactModel;
|
|
str flashModel;
|
|
str anim;
|
|
float damage;
|
|
float time;
|
|
float turnspeed;
|
|
bool trackEnemy;
|
|
int beamCount;
|
|
bool useRotation;
|
|
|
|
|
|
public: // States
|
|
enum
|
|
{
|
|
BEAMATTACK_SETUP,
|
|
BEAMATTACK_ROTATE,
|
|
BEAMATTACK_START_ANIM,
|
|
BEAMATTACK_START_ATTACK,
|
|
BEAMATTACK_ATTACKING,
|
|
BEAMATTACK_COMPLETE,
|
|
BEAMATTACK_FAILED,
|
|
};
|
|
|
|
protected:
|
|
void _setupRotate ( Actor &self );
|
|
void _rotate ( Actor &self );
|
|
void _playAttackAnim ( Actor &self );
|
|
void _startAttack ( Actor &self );
|
|
void _createBeam ( Actor &self );
|
|
void _updateBeam ( Actor &self );
|
|
void _attackFailed ( Actor &self );
|
|
|
|
bool _canAttack ( Actor &self );
|
|
trace_t _beamAttackTrace( Actor &self , const Vector &startPos );
|
|
|
|
public:
|
|
CLASS_PROTOTYPE( DoBeamAttack );
|
|
|
|
void SetArgs ( Event *ev );
|
|
void AnimDone ( Event *ev );
|
|
void Begin ( Actor &self );
|
|
BehaviorReturnCode_t Evaluate ( Actor &self );
|
|
void End ( Actor &self );
|
|
virtual void Archive ( Archiver &arc );
|
|
|
|
private:
|
|
unsigned int _state;
|
|
RotateToEntity _rotateBehavior;
|
|
float _endTime;
|
|
bool _initialRotationComplete;
|
|
//EntityPtr _beam;
|
|
Vector _beamEndPos;
|
|
Container<EntityPtr> _beamList;
|
|
|
|
|
|
static const float BEAMATTACK_SPREADFACTOR;
|
|
|
|
};
|
|
|
|
inline void DoBeamAttack::Archive( Archiver &arc )
|
|
{
|
|
int num , i;
|
|
Behavior::Archive( arc );
|
|
EntityPtr beam;
|
|
|
|
// Archive Parameters
|
|
arc.ArchiveString ( &tagName );
|
|
arc.ArchiveString ( &beamShader );
|
|
arc.ArchiveString ( &impactModel );
|
|
arc.ArchiveString ( &flashModel );
|
|
arc.ArchiveString ( &anim );
|
|
arc.ArchiveFloat ( &damage );
|
|
arc.ArchiveFloat ( &time );
|
|
arc.ArchiveFloat ( &turnspeed );
|
|
arc.ArchiveBool ( &trackEnemy );
|
|
arc.ArchiveInteger ( &beamCount );
|
|
arc.ArchiveBool ( &useRotation );
|
|
|
|
|
|
// Archive Components
|
|
|
|
// Archive Member Vars
|
|
arc.ArchiveUnsigned ( &_state );
|
|
arc.ArchiveObject ( &_rotateBehavior );
|
|
arc.ArchiveFloat ( &_endTime );
|
|
arc.ArchiveBool ( &_initialRotationComplete );
|
|
|
|
//arc.ArchiveSafePointer( &_beam );
|
|
|
|
arc.ArchiveVector ( &_beamEndPos );
|
|
|
|
if ( arc.Saving() )
|
|
{
|
|
num = _beamList.NumObjects();
|
|
arc.ArchiveInteger( &num );
|
|
|
|
|
|
for ( i = 1 ; i <= num; i++ )
|
|
{
|
|
beam = _beamList.ObjectAt( i );
|
|
arc.ArchiveSafePointer( &beam );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
EntityPtr *beamPtr;
|
|
|
|
arc.ArchiveInteger( &num );
|
|
|
|
_beamList.ClearObjectList();
|
|
_beamList.Resize( num );
|
|
|
|
for ( i = 1 ; i <= num ; i++ )
|
|
{
|
|
_beamList.AddObject( beam );
|
|
|
|
beamPtr = &_beamList.ObjectAt( i );
|
|
|
|
arc.ArchiveSafePointer( beamPtr );
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
//------------------------- CLASS ------------------------------
|
|
//
|
|
// Name: FireWeapon
|
|
// Base Class: Behavior
|
|
//
|
|
// Description: Behavior that plays the specified Fire Animation
|
|
//
|
|
// Method of Use: Called From StateMachine or another behavior
|
|
//--------------------------------------------------------------
|
|
class FireWeapon : public Behavior
|
|
{
|
|
private: //Parameters
|
|
str _anim;
|
|
|
|
public:
|
|
CLASS_PROTOTYPE( FireWeapon );
|
|
|
|
FireWeapon();
|
|
|
|
void SetArgs ( Event *ev );
|
|
void Begin ( Actor &self );
|
|
BehaviorReturnCode_t Evaluate ( Actor &self );
|
|
void End ( Actor &self );
|
|
virtual void Archive ( Archiver &arc );
|
|
void SetAnim ( const str &anim );
|
|
void SetTarget ( Entity *target ) { _target = target; }
|
|
void SetTargetPosition( const Vector &targetPos );
|
|
|
|
|
|
|
|
protected:
|
|
void _stopFire ( Actor &self );
|
|
|
|
private: //Member Vars
|
|
int _totalShots;
|
|
int _frameCount;
|
|
float _currentYaw;
|
|
float _currentPitch;
|
|
Vector _aimAngles;
|
|
Vector _targetPosition;
|
|
EntityPtr _target;
|
|
qboolean _attacking;
|
|
bool _havePosition;
|
|
|
|
|
|
|
|
|
|
};
|
|
|
|
inline void FireWeapon::Archive( Archiver &arc )
|
|
{
|
|
Behavior::Archive ( arc );
|
|
|
|
// Archive Parameters
|
|
arc.ArchiveString ( &_anim );
|
|
|
|
// Archive Components
|
|
|
|
// Archive Member Vars
|
|
arc.ArchiveInteger ( &_totalShots );
|
|
arc.ArchiveInteger ( &_frameCount );
|
|
arc.ArchiveFloat ( &_currentYaw );
|
|
arc.ArchiveFloat ( &_currentPitch );
|
|
arc.ArchiveVector ( &_aimAngles );
|
|
arc.ArchiveVector ( &_targetPosition );
|
|
arc.ArchiveSafePointer ( &_target );
|
|
arc.ArchiveBoolean ( &_attacking );
|
|
arc.ArchiveBool ( &_havePosition );
|
|
|
|
}
|
|
|
|
|
|
|
|
//
|
|
// Sigh
|
|
//
|
|
#include "closeInOnEnemy.hpp"
|
|
//
|
|
// ========================================================================
|
|
// MetaBehaviors
|
|
// New ( Larger Scope ) Behaviors like "UseCover" or "GeneralCombat"
|
|
// The reason for these is that constraints with the state machine are
|
|
// preventing me from achieving the kinds of results that we need.
|
|
//
|
|
// I am shooting for a "building block" methodolgy here, I hope to utilize
|
|
// many of the behaviors we already have ( likely with a few accessor/mutator
|
|
// additions ) to build up these large meta behaviors
|
|
// ========================================================================
|
|
//
|
|
|
|
|
|
//------------------------- CLASS ------------------------------
|
|
//
|
|
// Name: SimpleMelee
|
|
// Base Class: Behavior
|
|
//
|
|
// Description: The Actor will rush at the enemy until it
|
|
// is within the specified melee range. Then
|
|
// it will do melee attacks until it can't
|
|
// see the enemy. If it can't see the enemy or
|
|
// can't get to the enemy, it will attempt to
|
|
// circle strafe until it can get in range
|
|
//
|
|
// Method of Use: Statemachine or another behavior
|
|
//
|
|
// Required Animations:
|
|
// -- Component Requirements
|
|
|
|
// Component Behaviors:
|
|
// -- CloseInOnEnemy
|
|
// -- CircleStrafeEntity
|
|
// -- DoAttack
|
|
//
|
|
//--------------------------------------------------------------
|
|
class SimpleMelee : public Behavior
|
|
{
|
|
//------------------------------------
|
|
// States
|
|
//------------------------------------
|
|
public:
|
|
enum
|
|
{
|
|
SIMPLE_MELEE_SELECT_STATE,
|
|
SIMPLE_MELEE_RUSH_ENEMY,
|
|
SIMPLE_MELEE_CIRCLE_STRAFE,
|
|
SIMPLE_MELEE_ATTACK,
|
|
SIMPLE_MELEE_HOLD
|
|
};
|
|
|
|
//------------------------------------
|
|
// Parameters
|
|
//------------------------------------
|
|
private: // Parameters
|
|
str rushAnim;
|
|
str attackAnim;
|
|
float meleeDist;
|
|
float turnSpeed;
|
|
|
|
public:
|
|
CLASS_PROTOTYPE( SimpleMelee );
|
|
|
|
void SetArgs ( Event *ev );
|
|
void AnimDone ( Event *ev );
|
|
void Begin ( Actor &self );
|
|
BehaviorReturnCode_t Evaluate ( Actor &self );
|
|
void End ( Actor &self );
|
|
void SetRushAnim ( const str& anim );
|
|
void SetAttackAnim ( const str& anim );
|
|
void SetMeleeDist ( float dist );
|
|
void SetTurnSpeed ( float turnspeed );
|
|
|
|
virtual void Archive ( Archiver &arc );
|
|
|
|
//-------------------------------------
|
|
// Internal Functionality
|
|
//-------------------------------------
|
|
protected:
|
|
void _init ( Actor &self );
|
|
void _selectState ( Actor &self );
|
|
|
|
void _setupRush ( Actor &self );
|
|
void _rush ( Actor &self );
|
|
|
|
void _setupStrafe ( Actor &self );
|
|
void _strafe ( Actor &self );
|
|
|
|
void _setupMeleeAttack ( Actor &self );
|
|
void _meleeAttack ( Actor &self );
|
|
|
|
void _setupHold ( Actor &self );
|
|
void _hold ( Actor &self );
|
|
|
|
|
|
//-------------------------------------
|
|
// Member Variables
|
|
//-------------------------------------
|
|
|
|
private:
|
|
// Component Behaviors
|
|
CloseInOnEnemy _rushEnemy;
|
|
CircleStrafeEntity _circleStrafe;
|
|
DoAttack _attack;
|
|
|
|
// Member Variables
|
|
unsigned int _state;
|
|
float _holdTime;
|
|
int _holdCount;
|
|
bool _strafeClockwise;
|
|
int _strafeAttempts;
|
|
float _nextStrafeTime;
|
|
float _nextEnemyCheckTime;
|
|
Actor* _self;
|
|
|
|
};
|
|
|
|
|
|
inline void SimpleMelee::Archive( Archiver &arc )
|
|
{
|
|
Behavior::Archive ( arc );
|
|
|
|
// Archive Parameters
|
|
arc.ArchiveString ( &rushAnim );
|
|
arc.ArchiveString ( &attackAnim );
|
|
arc.ArchiveFloat ( &meleeDist );
|
|
arc.ArchiveFloat ( &turnSpeed );
|
|
|
|
// Archive Components
|
|
arc.ArchiveObject ( &_rushEnemy );
|
|
arc.ArchiveObject ( &_circleStrafe );
|
|
arc.ArchiveObject ( &_attack );
|
|
|
|
// Archive Member Vars
|
|
arc.ArchiveUnsigned ( &_state );
|
|
arc.ArchiveFloat ( &_holdTime );
|
|
arc.ArchiveInteger ( &_holdCount );
|
|
arc.ArchiveBool ( &_strafeClockwise );
|
|
arc.ArchiveInteger ( &_strafeAttempts );
|
|
arc.ArchiveFloat ( &_nextStrafeTime );
|
|
arc.ArchiveFloat ( &_nextEnemyCheckTime );
|
|
|
|
arc.ArchiveObjectPointer ( ( Class ** )&_self );
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
//------------------------- CLASS ------------------------------
|
|
//
|
|
// Name: FollowPathBlindly
|
|
// Base Class: Behavior
|
|
//
|
|
// Description: Makes the actor use FollowPathBlindly Helper Nodes
|
|
//
|
|
// Method of Use: Statemachine or another behavior
|
|
//--------------------------------------------------------------
|
|
class FollowPathBlindly : public Behavior
|
|
{
|
|
public:
|
|
CLASS_PROTOTYPE( FollowPathBlindly );
|
|
|
|
void SetArgs ( Event *ev );
|
|
void Begin ( Actor &self );
|
|
BehaviorReturnCode_t Evaluate ( Actor &self );
|
|
void End ( Actor &self );
|
|
|
|
virtual void Archive ( Archiver &arc );
|
|
|
|
protected:
|
|
HelperNodePtr FindNextNode( Actor &self );
|
|
HelperNodePtr FindNearestNode( Actor &self );
|
|
void SetNode( Actor &self, HelperNodePtr node );
|
|
const bool AdvanceNode( Actor &self );
|
|
const Vector ComputeTargetPoint( const HelperNodePtr lastNode, const HelperNodePtr currentNode, const HelperNodePtr nextNode ) const;
|
|
|
|
private:
|
|
// Component Behaviors
|
|
MoveDirectlyToPoint _gotoHelperNode;
|
|
|
|
// Member Variables
|
|
str _animName;
|
|
HelperNodePtr _node;
|
|
HelperNodePtr _nextNode;
|
|
float _offset;
|
|
str _startNodeName;
|
|
};
|
|
|
|
inline void FollowPathBlindly::Archive( Archiver &arc )
|
|
{
|
|
Behavior::Archive ( arc );
|
|
|
|
// Archive Parmeters
|
|
|
|
// Archive Components
|
|
arc.ArchiveObject ( &_gotoHelperNode );
|
|
|
|
// Archive Member Vars
|
|
arc.ArchiveString ( &_animName );
|
|
arc.ArchiveSafePointer ( &_node );
|
|
arc.ArchiveSafePointer ( &_nextNode );
|
|
arc.ArchiveFloat ( &_offset );
|
|
arc.ArchiveString ( &_startNodeName );
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
//------------------------- CLASS ------------------------------
|
|
//
|
|
// Name: Hibernate
|
|
// Base Class: Behavior
|
|
//
|
|
// Description: Makes the Actor use Work Helper Nodes
|
|
// Note, this behavior makes extensive use of
|
|
// the CUSTOM helper node and REQUIRES that
|
|
// the Node's customType = "hibernate"
|
|
//
|
|
// Method of Use: Statemachine or another behavior
|
|
//--------------------------------------------------------------
|
|
class Hibernate : public Behavior
|
|
{
|
|
public: // States
|
|
typedef enum
|
|
{
|
|
HIBERNATE_FIND_CLOSEST_NODE,
|
|
HIBERNATE_MOVING_TO_NODE,
|
|
HIBERNATE_AT_NODE,
|
|
HIBERNATE_START_HIBERNATE,
|
|
HIBERNATE_HIBERNATE,
|
|
HIBERNATE_END_HIBERNATE,
|
|
HIBERNATE_HOLD,
|
|
HIBERNATE_WAIT,
|
|
HIBERNATE_SUCCESSFUL,
|
|
HIBERNATE_FAILED
|
|
} hibernateStates_t;
|
|
|
|
private: // Parameters
|
|
|
|
protected:
|
|
void _init ( Actor &self );
|
|
|
|
bool _setupFindClosestHibernateNode ( Actor &self );
|
|
void _setupFindClosestHibernateNodeFailed ( Actor &self );
|
|
void _findClosestHibernateNode ( Actor &self );
|
|
void _findClosestHibernateNodeFailed ( Actor &self );
|
|
|
|
bool _setupMovingToHibernateNode ( Actor &self );
|
|
void _setupMovingToHibernateNodeFailed ( Actor &self );
|
|
void _moveToHibernateNode ( Actor &self );
|
|
void _moveToHibernateNodeFailed ( Actor &self );
|
|
|
|
bool _setupAtHibernateNode ( Actor &self );
|
|
void _setupAtHibernateNodeFailed ( Actor &self );
|
|
void _atHibernateNode ( Actor &self );
|
|
|
|
bool _setupHold ( Actor &self );
|
|
void _setupHoldFailed ( Actor &self );
|
|
void _hold ( Actor &self );
|
|
|
|
void _startHibernate ( Actor &self );
|
|
void _hibernate ( Actor &self );
|
|
void _endHibernate ( Actor &self );
|
|
void _wait ( Actor &self );
|
|
|
|
|
|
public:
|
|
CLASS_PROTOTYPE( Hibernate );
|
|
|
|
void SetArgs ( Event *ev );
|
|
void AnimDone ( Event *ev );
|
|
|
|
void Begin ( Actor &self );
|
|
BehaviorReturnCode_t Evaluate ( Actor &self );
|
|
void End ( Actor &self );
|
|
|
|
virtual void Archive ( Archiver &arc );
|
|
|
|
private: // Component Behaviors
|
|
GotoPoint _gotoHelperNode;
|
|
|
|
private: // Member Variables
|
|
HelperNodePtr _node;
|
|
|
|
unsigned int _state;
|
|
|
|
int _moveFailures;
|
|
|
|
float _nextMoveAttempt;
|
|
|
|
|
|
|
|
};
|
|
|
|
inline void Hibernate::Archive( Archiver &arc )
|
|
{
|
|
Behavior::Archive ( arc );
|
|
|
|
// Archive Parameters
|
|
|
|
// Archive Components
|
|
arc.ArchiveObject ( &_gotoHelperNode );
|
|
|
|
// Archive Member Vars
|
|
arc.ArchiveSafePointer ( &_node );
|
|
|
|
arc.ArchiveUnsigned ( &_state );
|
|
|
|
arc.ArchiveInteger ( &_moveFailures );
|
|
|
|
arc.ArchiveFloat ( &_nextMoveAttempt );
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
//------------------------- CLASS ------------------------------
|
|
//
|
|
// Name: GotoLiftPosition
|
|
// Base Class: Behavior
|
|
//
|
|
// Description: Makes the Actor use Lift Helper Nodes
|
|
// Note, this behavior makes extensive use of
|
|
// the CUSTOM helper node and REQUIRES that
|
|
// the Node's customType = "lift"
|
|
//
|
|
// Method of Use: Statemachine or another behavior
|
|
//--------------------------------------------------------------
|
|
class GotoLiftPosition : public Behavior
|
|
{
|
|
public: // States
|
|
typedef enum
|
|
{
|
|
GLP_FIND_NODE,
|
|
GLP_MOVING_TO_NODE,
|
|
GLP_MOVE_FAILED,
|
|
GLP_AT_NODE,
|
|
GLP_SUCCESSFUL,
|
|
GLP_FAILED
|
|
} GotoLiftPositionStates_t;
|
|
|
|
private: // Parameters
|
|
|
|
protected:
|
|
void _init ( Actor &self );
|
|
|
|
void _findLiftNode ( Actor &self );
|
|
|
|
void _setupMovingToLiftNode ( Actor &self );
|
|
void _moveToLiftNode ( Actor &self );
|
|
|
|
void _setupMoveToLiftFailed ( Actor &self );
|
|
void _moveToLiftNodeFailed ( Actor &self );
|
|
|
|
|
|
void _setupAtLiftNode ( Actor &self );
|
|
void _atLiftNode ( Actor &self );
|
|
|
|
void _setupHold ( Actor &self );
|
|
void _hold ( Actor &self );
|
|
|
|
void _warpToLiftNode ( Actor &self );
|
|
void _warpToPathNode ( Actor &self );
|
|
|
|
|
|
public:
|
|
CLASS_PROTOTYPE( GotoLiftPosition );
|
|
|
|
void SetArgs ( Event *ev );
|
|
void AnimDone ( Event *ev );
|
|
|
|
void Begin ( Actor &self );
|
|
BehaviorReturnCode_t Evaluate ( Actor &self );
|
|
void End ( Actor &self );
|
|
void FindNodes( Actor &self );
|
|
|
|
virtual void Archive ( Archiver &arc );
|
|
|
|
private: // Component Behaviors
|
|
GotoPoint _gotoHelperNode;
|
|
|
|
private: // Member Variables
|
|
HelperNodePtr _node;
|
|
unsigned int _state;
|
|
int _moveFailures;
|
|
float _nextMoveAttempt;
|
|
Container<HelperNodePtr> _availableNodes;
|
|
Container<HelperNodePtr> _attemptedNodes;
|
|
|
|
};
|
|
|
|
inline void GotoLiftPosition::Archive( Archiver &arc )
|
|
{
|
|
Behavior::Archive ( arc );
|
|
|
|
// Archive Parameters
|
|
|
|
// Archive Components
|
|
arc.ArchiveObject ( &_gotoHelperNode );
|
|
|
|
// Archive Member Vars
|
|
arc.ArchiveSafePointer ( &_node );
|
|
arc.ArchiveUnsigned ( &_state );
|
|
arc.ArchiveInteger ( &_moveFailures );
|
|
arc.ArchiveFloat ( &_nextMoveAttempt );
|
|
|
|
int num , i;
|
|
if ( arc.Saving() )
|
|
{
|
|
num = _availableNodes.NumObjects();
|
|
|
|
arc.ArchiveInteger( &num );
|
|
HelperNodePtr theNode;
|
|
for( i = 1 ; i <= num ; i++ )
|
|
{
|
|
theNode = _availableNodes.ObjectAt(i);
|
|
arc.ArchiveSafePointer( &theNode );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
arc.ArchiveInteger( &num );
|
|
|
|
_availableNodes.Resize( num );
|
|
|
|
for ( i = 1; i <= num; i++ )
|
|
{
|
|
HelperNodePtr theNode;
|
|
HelperNodePtr *ptrTheNode;
|
|
|
|
_availableNodes.AddObject( theNode );
|
|
|
|
ptrTheNode = &_availableNodes.ObjectAt( i );
|
|
|
|
arc.ArchiveSafePointer( ptrTheNode );
|
|
}
|
|
}
|
|
|
|
if ( arc.Saving() )
|
|
{
|
|
num = _attemptedNodes.NumObjects();
|
|
|
|
arc.ArchiveInteger( &num );
|
|
HelperNodePtr theNode;
|
|
for( i = 1 ; i <= num ; i++ )
|
|
{
|
|
theNode = _attemptedNodes.ObjectAt(i);
|
|
arc.ArchiveSafePointer( &theNode );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
arc.ArchiveInteger( &num );
|
|
|
|
for ( i = 1; i <= num; i++ )
|
|
{
|
|
HelperNodePtr theNode;
|
|
arc.ArchiveSafePointer( &theNode );
|
|
_attemptedNodes.AddObject( theNode );
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
//
|
|
// Oh great googly moogly this is weak. Yes yes, I know this is a horrible
|
|
// horrible thing to do... But it's only temporary until I get all the
|
|
// behaviors split out into their own files.
|
|
//
|
|
#include "generalCombatWithRangedWeapon.hpp"
|
|
|
|
|
|
|
|
|
|
|
|
|
|
//
|
|
// ========================================================================
|
|
// Global Functions
|
|
// ========================================================================
|
|
//
|
|
|
|
// Yes, Actor should be const, but find.heuristic stuff complains if it is
|
|
PathNode* FindNode ( Actor &self, FollowPath *chase, unsigned int mask , PathNode* (*check)(PathNode* node) );
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
//------------------------- CLASS ------------------------------
|
|
//
|
|
// Name: Template
|
|
// Base Class: Behavior
|
|
//
|
|
// Description: Template that can be copied and pasted to
|
|
// generate new behavior
|
|
//
|
|
// Method of Use: State machine or another behavior
|
|
//--------------------------------------------------------------
|
|
|
|
class Template : public Behavior
|
|
{
|
|
//------------------------------------
|
|
// States
|
|
//------------------------------------
|
|
public:
|
|
typedef enum
|
|
{
|
|
TEMPLATE_NUMBER_OF_STATES
|
|
} MoveFCOFStates_t;
|
|
|
|
|
|
//------------------------------------
|
|
// Parameters
|
|
//------------------------------------
|
|
private:
|
|
str _anim; // --The animation that will be used ( Walk, Run, SideStep, etc )
|
|
|
|
public:
|
|
CLASS_PROTOTYPE( Template );
|
|
|
|
void SetArgs ( Event *ev );
|
|
void Begin ( Actor &self );
|
|
BehaviorReturnCode_t Evaluate ( Actor &self );
|
|
void End ( Actor &self );
|
|
virtual void Archive ( Archiver &arc );
|
|
|
|
// Mutators
|
|
void SetAnim ( const str &anim );
|
|
|
|
|
|
//-------------------------------------
|
|
// Internal Functionality
|
|
//-------------------------------------
|
|
protected:
|
|
|
|
|
|
//-------------------------------------
|
|
// Member Variables
|
|
//-------------------------------------
|
|
private:
|
|
// Component Behaviors
|
|
GotoPoint _chase; //-- Behavior that will steer us to our desired position
|
|
|
|
// Member Vars
|
|
int _state; //-- Maintains our Behavior's current State
|
|
|
|
// Constants
|
|
static const float THE_CONSTANT;
|
|
};
|
|
|
|
|
|
inline void Template::Archive( Archiver &arc )
|
|
{
|
|
Behavior::Archive( arc );
|
|
|
|
// Archive Parameters
|
|
arc.ArchiveString ( &_anim );
|
|
|
|
// Archive Components
|
|
arc.ArchiveObject ( &_chase );
|
|
|
|
// Archive Member Variables
|
|
arc.ArchiveInteger ( &_state );
|
|
|
|
}
|
|
|
|
inline void Template::SetAnim( const str &anim )
|
|
{
|
|
_anim = anim;
|
|
}
|
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
#endif /* __BEHAVIORS_GENERAL_H__ */
|