1314 lines
41 KiB
C++
1314 lines
41 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
//
|
|
// Purpose: The robots for use in the Robot Destruction TF2 game mode.
|
|
//
|
|
//=========================================================================//
|
|
|
|
#include "cbase.h"
|
|
#include "tf_logic_robot_destruction.h"
|
|
#include "tf_shareddefs.h"
|
|
#include "particle_parse.h"
|
|
#include "tf_gamerules.h"
|
|
#include "debugoverlay_shared.h"
|
|
#ifdef GAME_DLL
|
|
#include "tf_ammo_pack.h"
|
|
#include "entity_bonuspack.h"
|
|
#include "entity_capture_flag.h"
|
|
#include "effect_dispatch_data.h"
|
|
#include "te_effect_dispatch.h"
|
|
#include "tf_gamestats.h"
|
|
#include "eventlist.h"
|
|
#else
|
|
#include "eventlist.h"
|
|
#endif
|
|
|
|
#ifdef GAME_DLL
|
|
extern ConVar tf_obj_gib_velocity_min;
|
|
extern ConVar tf_obj_gib_velocity_max;
|
|
extern ConVar tf_obj_gib_maxspeed;
|
|
#endif
|
|
|
|
#define ADD_POINTS_CONTEXT "add_points_context"
|
|
#define SPEW_BARS_CONTEXT "spew_bars_context"
|
|
#define SELF_DESTRUCT_THINK "self_destruct_think"
|
|
#define ANIMS_THINK "anims_think"
|
|
|
|
ConVar tf_rd_robot_repair_rate( "tf_rd_robot_repair_rate", "60", FCVAR_REPLICATED | FCVAR_DEVELOPMENTONLY );
|
|
|
|
RobotData_t* g_RobotData[ NUM_ROBOT_TYPES ] =
|
|
{
|
|
// Model // Busted model // Pain // Death // Collide // Idle // Bar offset
|
|
new RobotData_t( "models/bots/bot_worker/bot_worker_A.mdl", "models/bots/bot_worker/bot_worker_A.mdl", "Robot.Pain", "Robot.Death", "Robot.Collide", "Robot.Greeting", -35.f ),
|
|
#ifdef STAGING_ONLY
|
|
new RobotData_t( "models/bots/bot_worker/bot_worker_b.mdl", "models/bots/bot_worker/bot_worker_b.mdl", "Robot.Pain", "Robot.Death", "Robot.Collide", "Robot.Greeting", -30.f ),
|
|
#else
|
|
new RobotData_t( "models/bots/bot_worker/bot_worker2.mdl", "models/bots/bot_worker/bot_worker2.mdl", "Robot.Pain", "Robot.Death", "Robot.Collide", "Robot.Greeting", -30.f ),
|
|
#endif
|
|
new RobotData_t( "models/bots/bot_worker/bot_worker3.mdl", "models/bots/bot_worker/bot_worker3_nohead.mdl", "Robot.Pain", "Robot.Death", "Robot.Collide", "Robot.Greeting", -10.f ),
|
|
};
|
|
|
|
#define ROBOT_DEATH_EXPLOSION "RD.BotDeathExplosion"
|
|
#define SCORING_POINTS_PARTICLE_EFFECT "bot_radio_waves"
|
|
#define DAMAGED_ROBOT_PARTICLE_EFFECT "sentrydamage_4"
|
|
#define DEATH_PARTICLE_EFFECT "rd_robot_explosion"
|
|
|
|
|
|
void RobotData_t::Precache()
|
|
{
|
|
if ( GetStringData( MODEL_KEY ) )
|
|
{
|
|
CBaseEntity::PrecacheModel( GetStringData( MODEL_KEY ) );
|
|
PrecacheGibsForModel( modelinfo->GetModelIndex( GetStringData( MODEL_KEY ) ) );
|
|
PrecachePropsForModel( modelinfo->GetModelIndex( GetStringData( MODEL_KEY ) ), "spawn" );
|
|
}
|
|
if ( GetStringData( DAMAGED_MODEL_KEY ) ) CBaseEntity::PrecacheModel( GetStringData( DAMAGED_MODEL_KEY ) );
|
|
if ( GetStringData( HURT_SOUND_KEY ) ) CBaseEntity::PrecacheScriptSound( GetStringData( HURT_SOUND_KEY ) );
|
|
if ( GetStringData( DEATH_SOUND_KEY ) ) CBaseEntity::PrecacheScriptSound( GetStringData( DEATH_SOUND_KEY ) );
|
|
if ( GetStringData( COLLIDE_SOUND_KEY ) ) CBaseEntity::PrecacheScriptSound( GetStringData( COLLIDE_SOUND_KEY ) );
|
|
if ( GetStringData( IDLE_SOUND_KEY ) ) CBaseEntity::PrecacheScriptSound( GetStringData( IDLE_SOUND_KEY ) );
|
|
}
|
|
|
|
|
|
CTFRobotDestruction_RobotAnimController::CTFRobotDestruction_RobotAnimController( CTFRobotDestruction_Robot *pOuter )
|
|
: m_vecOldOrigin( vec3_origin )
|
|
, m_vecLean( vec3_origin )
|
|
, m_pOuter( pOuter )
|
|
, m_vecImpulse( vec3_origin )
|
|
{}
|
|
|
|
void CTFRobotDestruction_RobotAnimController::Update()
|
|
{
|
|
if( !m_pOuter )
|
|
return;
|
|
|
|
CStudioHdr *pStudioHdr = m_pOuter->GetModelPtr();
|
|
if ( !pStudioHdr )
|
|
return;
|
|
|
|
const Vector vecNewOrigin = m_pOuter->GetAbsOrigin();
|
|
const Vector vecVelocity = m_vecOldOrigin - vecNewOrigin;
|
|
m_vecOldOrigin = vecNewOrigin;
|
|
|
|
Approach( m_vecLean, vecVelocity + m_vecImpulse, 2.f );
|
|
GetPoseParams();
|
|
Approach( m_vecImpulse, vec3_origin, 200.f );
|
|
|
|
Vector vecForward, vecRight;
|
|
AngleVectors( m_pOuter->GetAbsAngles(), &vecForward, &vecRight, NULL );
|
|
|
|
float flRightLean = vecRight.Dot( m_vecLean );
|
|
float flForwardLean = vecForward.Dot( m_vecLean );
|
|
|
|
m_pOuter->SetPoseParameter( m_poseParams.m_nMoveX, flForwardLean );
|
|
m_pOuter->SetPoseParameter( m_poseParams.m_nMoveY, flRightLean );
|
|
}
|
|
|
|
void CTFRobotDestruction_RobotAnimController::Impulse( const Vector& vecImpulse )
|
|
{
|
|
m_vecImpulse += vecImpulse * 5;
|
|
}
|
|
|
|
void CTFRobotDestruction_RobotAnimController::Approach( Vector& vecIn, const Vector& vecTarget, float flRate )
|
|
{
|
|
Vector vecApproach = ( vecTarget - vecIn ) * flRate * gpGlobals->frametime;
|
|
if ( vecApproach.LengthSqr() > ( vecIn - vecTarget ).LengthSqr() )
|
|
vecIn = vecTarget;
|
|
else
|
|
vecIn += vecApproach;
|
|
}
|
|
|
|
void CTFRobotDestruction_RobotAnimController::GetPoseParams()
|
|
{
|
|
m_poseParams.m_nMoveX = m_pOuter->LookupPoseParameter( "move_x" );
|
|
m_poseParams.m_nMoveY = m_pOuter->LookupPoseParameter( "move_y" );
|
|
}
|
|
|
|
IMPLEMENT_NETWORKCLASS_ALIASED( TFRobotDestruction_Robot, DT_TFRobotDestruction_Robot )
|
|
|
|
BEGIN_NETWORK_TABLE( CTFRobotDestruction_Robot, DT_TFRobotDestruction_Robot )
|
|
#ifdef CLIENT_DLL
|
|
RecvPropInt( RECVINFO(m_iHealth) ),
|
|
RecvPropInt( RECVINFO(m_iMaxHealth) ),
|
|
RecvPropInt( RECVINFO(m_eType) ),
|
|
#else
|
|
SendPropInt(SENDINFO(m_iHealth), -1, SPROP_VARINT ),
|
|
SendPropInt(SENDINFO(m_iMaxHealth), -1, SPROP_VARINT ),
|
|
SendPropInt(SENDINFO(m_eType), -1, SPROP_VARINT ),
|
|
#endif
|
|
END_NETWORK_TABLE()
|
|
|
|
BEGIN_DATADESC( CTFRobotDestruction_Robot )
|
|
#ifdef GAME_DLL
|
|
DEFINE_INPUTFUNC( FIELD_VOID, "StopAndUseComputer", InputStopAndUseComputer ),
|
|
#endif
|
|
END_DATADESC()
|
|
|
|
LINK_ENTITY_TO_CLASS( tf_robot_destruction_robot, CTFRobotDestruction_Robot );
|
|
|
|
CTFRobotDestruction_Robot::CTFRobotDestruction_Robot()
|
|
: m_animController( this )
|
|
{
|
|
#ifdef GAME_DLL
|
|
m_nPointsSpewed = 0;
|
|
|
|
m_intention = new CRobotIntention( this );
|
|
m_locomotor = new CRobotLocomotion( this );
|
|
m_body = new CHeadlessHatmanBody( this );
|
|
m_bIsPanicked = false;
|
|
#else
|
|
ListenForGameEvent( "rd_robot_impact" );
|
|
#endif
|
|
}
|
|
|
|
CTFRobotDestruction_Robot::~CTFRobotDestruction_Robot()
|
|
{
|
|
#ifdef CLIENT_DLL
|
|
m_hDamagedParticleEffect = NULL;
|
|
#else
|
|
if ( m_hSpawn )
|
|
m_hSpawn->ClearRobot();
|
|
if ( m_intention )
|
|
delete m_intention;
|
|
if ( m_locomotor )
|
|
delete m_locomotor;
|
|
if ( m_body )
|
|
delete m_body;
|
|
#endif
|
|
}
|
|
|
|
void CTFRobotDestruction_Robot::StaticPrecache()
|
|
{
|
|
PrecacheParticleSystem( DEATH_PARTICLE_EFFECT );
|
|
PrecacheParticleSystem( SCORING_POINTS_PARTICLE_EFFECT );
|
|
PrecacheParticleSystem( DAMAGED_ROBOT_PARTICLE_EFFECT );
|
|
PrecacheScriptSound( ROBOT_DEATH_EXPLOSION );
|
|
|
|
for( int i=0; i < ARRAYSIZE( g_RobotData ); ++i )
|
|
{
|
|
g_RobotData[i]->Precache();
|
|
}
|
|
}
|
|
|
|
void CTFRobotDestruction_Robot::Precache()
|
|
{
|
|
BaseClass::Precache();
|
|
StaticPrecache();
|
|
}
|
|
|
|
void CTFRobotDestruction_Robot::Spawn()
|
|
{
|
|
// Clear out the gib list and create a new one.
|
|
m_aGibs.Purge();
|
|
BuildGibList( m_aGibs, GetModelIndex(), 1.0f, COLLISION_GROUP_NONE );
|
|
BuildPropList( "spawn", m_aSpawnProps, GetModelIndex(), 1.f, COLLISION_GROUP_NONE );
|
|
|
|
BaseClass::Spawn();
|
|
|
|
SetSolid( SOLID_BBOX );
|
|
|
|
m_takedamage = DAMAGE_YES;
|
|
m_nSkin = ( GetTeamNumber() == TF_TEAM_RED ) ? 0 : 1;
|
|
#ifdef GAME_DLL
|
|
SetContextThink( &CTFRobotDestruction_Robot::UpdateAnimsThink, gpGlobals->curtime, ANIMS_THINK );
|
|
|
|
if ( m_hGroup )
|
|
{
|
|
m_hGroup->UpdateState();
|
|
}
|
|
|
|
m_hNextPath.Set( dynamic_cast<CPathTrack*>( gEntList.FindEntityByName( NULL, m_spawnData.m_pszPathName ) ) );
|
|
// The path needs to exist
|
|
if ( !m_hNextPath )
|
|
{
|
|
UTIL_Remove( this );
|
|
}
|
|
|
|
if ( CTFRobotDestructionLogic::GetRobotDestructionLogic() )
|
|
CTFRobotDestructionLogic::GetRobotDestructionLogic()->RobotCreated( this );
|
|
|
|
// Create our dispenser
|
|
m_pDispenser = dynamic_cast<CRobotDispenser*>( CreateEntityByName( "rd_robot_dispenser" ) );
|
|
Assert( m_pDispenser );
|
|
m_pDispenser->SetParent( this );
|
|
m_pDispenser->Spawn();
|
|
m_pDispenser->ChangeTeam( GetTeamNumber() );
|
|
m_pDispenser->OnGoActive();
|
|
#endif
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Dont collide with players
|
|
//-----------------------------------------------------------------------------
|
|
bool CTFRobotDestruction_Robot::ShouldCollide( int collisionGroup, int contentsMask ) const
|
|
{
|
|
if ( collisionGroup == COLLISION_GROUP_PLAYER_MOVEMENT )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
return BaseClass::ShouldCollide( collisionGroup, contentsMask );
|
|
}
|
|
|
|
|
|
#ifdef CLIENT_DLL
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Specify where our healthbars should go over our heads
|
|
//-----------------------------------------------------------------------------
|
|
float CTFRobotDestruction_Robot::GetHealthBarHeightOffset() const
|
|
{
|
|
return g_RobotData[ m_eType ]->GetFloatData( RobotData_t::HEALTH_BAR_OFFSET_KEY );
|
|
}
|
|
|
|
|
|
void CTFRobotDestruction_Robot::OnDataChanged( DataUpdateType_t type )
|
|
{
|
|
BaseClass::OnDataChanged( type );
|
|
|
|
if ( type == DATA_UPDATE_CREATED )
|
|
{
|
|
SetNextClientThink( CLIENT_THINK_ALWAYS );
|
|
}
|
|
|
|
UpdateDamagedEffects();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Play damaged effects, similar to sentries
|
|
//-----------------------------------------------------------------------------
|
|
void CTFRobotDestruction_Robot::UpdateDamagedEffects()
|
|
{
|
|
// Start playing our damaged particle if we're damaged
|
|
bool bLowHealth = GetHealth() <= (GetMaxHealth() * 0.5);
|
|
if ( bLowHealth && !m_hDamagedParticleEffect )
|
|
{
|
|
m_hDamagedParticleEffect = ParticleProp()->Create( DAMAGED_ROBOT_PARTICLE_EFFECT,
|
|
PATTACH_ABSORIGIN_FOLLOW,
|
|
INVALID_PARTICLE_ATTACHMENT,
|
|
Vector(0,0,50) );
|
|
|
|
}
|
|
else if ( !bLowHealth && m_hDamagedParticleEffect )
|
|
{
|
|
ParticleProp()->StopEmission( m_hDamagedParticleEffect );
|
|
m_hDamagedParticleEffect = NULL;
|
|
}
|
|
}
|
|
|
|
void CTFRobotDestruction_Robot::UpdateClientSideAnimation( void )
|
|
{
|
|
m_animController.Update();
|
|
|
|
BaseClass::UpdateClientSideAnimation();
|
|
}
|
|
|
|
void CTFRobotDestruction_Robot::FireEvent( const Vector& origin, const QAngle& angles, int event, const char *options )
|
|
{
|
|
if ( event == AE_RD_ROBOT_POP_PANELS_OFF )
|
|
{
|
|
CUtlVector<breakmodel_t> vecProp;
|
|
FOR_EACH_VEC( m_aSpawnProps, i )
|
|
{
|
|
char pstrLowerName[ MAX_PATH ];
|
|
memset( pstrLowerName, 0, sizeof(pstrLowerName) );
|
|
Q_snprintf( pstrLowerName, sizeof(pstrLowerName), "%s", options );
|
|
Q_strlower( pstrLowerName );
|
|
if ( Q_strstr( m_aSpawnProps[i].modelName, pstrLowerName ) )
|
|
{
|
|
vecProp.AddToTail( m_aSpawnProps[i] );
|
|
}
|
|
}
|
|
|
|
if ( vecProp.Count() )
|
|
{
|
|
Vector vForward, vRight, vUp;
|
|
AngleVectors( GetAbsAngles(), &vForward, &vRight, &vUp );
|
|
|
|
Vector vecBreakVelocity = Vector(0,0,200);
|
|
AngularImpulse angularImpulse( RandomFloat( 0.0f, 120.0f ), RandomFloat( 0.0f, 120.0f ), 0.0 );
|
|
Vector vecOrigin = GetAbsOrigin() + vForward*70 + vUp*10;
|
|
QAngle vecAngles = GetAbsAngles();
|
|
breakablepropparams_t breakParams( vecOrigin, vecAngles, vecBreakVelocity, angularImpulse );
|
|
breakParams.impactEnergyScale = 1.0f;
|
|
breakParams.defBurstScale = 3.f;
|
|
int nModelIndex = GetModelIndex();
|
|
|
|
CreateGibsFromList( vecProp, nModelIndex, NULL, breakParams, this, -1 , false, true );
|
|
}
|
|
}
|
|
|
|
BaseClass::FireEvent( origin, angles, event, options );
|
|
}
|
|
|
|
void CTFRobotDestruction_Robot::FireGameEvent( IGameEvent *pEvent )
|
|
{
|
|
const char *pszName = pEvent->GetName();
|
|
if ( FStrEq( pszName, "rd_robot_impact" ) )
|
|
{
|
|
const int index_ = pEvent->GetInt( "entindex" );
|
|
if ( index_ == entindex() )
|
|
{
|
|
Vector vecImpulse( pEvent->GetFloat( "impulse_x" ), pEvent->GetFloat( "impulse_y" ), pEvent->GetFloat( "impulse_z" ) );
|
|
m_animController.Impulse( vecImpulse.Normalized() * 20 );
|
|
}
|
|
}
|
|
}
|
|
|
|
CStudioHdr* CTFRobotDestruction_Robot::OnNewModel()
|
|
{
|
|
CStudioHdr *hdr = BaseClass::OnNewModel();
|
|
BuildPropList( "spawn", m_aSpawnProps, GetModelIndex(), 1.f, COLLISION_GROUP_NONE );
|
|
|
|
return hdr;
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
#ifdef GAME_DLL
|
|
void CTFRobotDestruction_Robot::HandleAnimEvent( animevent_t *pEvent )
|
|
{
|
|
if ((pEvent->type & AE_TYPE_NEWEVENTSYSTEM) && (pEvent->type & AE_TYPE_SERVER))
|
|
{
|
|
/* if ( pEvent->event == AE_RD_ROBOT_POP_PANELS_OFF )
|
|
{
|
|
CUtlVector<breakmodel_t> vecProp;
|
|
FOR_EACH_VEC( m_aSpawnProps, i )
|
|
{
|
|
char pstrLowerName[ MAX_PATH ];
|
|
memset( pstrLowerName, 0, sizeof(pstrLowerName) );
|
|
Q_snprintf( pstrLowerName, sizeof(pstrLowerName), "%s", pEvent->options );
|
|
Q_strlower( pstrLowerName );
|
|
if ( Q_strstr( m_aSpawnProps[i].modelName, pstrLowerName ) )
|
|
{
|
|
vecProp.AddToTail( m_aSpawnProps[i] );
|
|
}
|
|
}
|
|
|
|
if ( vecProp.Count() )
|
|
{
|
|
Vector vForward, vRight, vUp;
|
|
AngleVectors( GetAbsAngles(), &vForward, &vRight, &vUp );
|
|
|
|
Vector vecBreakVelocity = Vector(0,0,200);
|
|
AngularImpulse angularImpulse( RandomFloat( 0.0f, 120.0f ), RandomFloat( 0.0f, 120.0f ), 0.0 );
|
|
Vector vecOrigin = GetAbsOrigin() + vForward*70 + vUp*10;
|
|
QAngle vecAngles = GetAbsAngles();
|
|
breakablepropparams_t breakParams( vecOrigin, vecAngles, vecBreakVelocity, angularImpulse );
|
|
breakParams.impactEnergyScale = 1.0f;
|
|
|
|
int nModelIndex = modelinfo->GetModelIndex( STRING(GetModelName()) );
|
|
CreateGibsFromList( vecProp, nModelIndex, NULL, breakParams, NULL, -1 , false, true );
|
|
}
|
|
}*/
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Tell the game logic we're gone
|
|
//-----------------------------------------------------------------------------
|
|
void CTFRobotDestruction_Robot::UpdateOnRemove( void )
|
|
{
|
|
BaseClass::UpdateOnRemove();
|
|
|
|
if ( CTFRobotDestructionLogic::GetRobotDestructionLogic() )
|
|
{
|
|
CTFRobotDestructionLogic::GetRobotDestructionLogic()->RobotRemoved( this );
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Play our death visual and audio effects
|
|
//-----------------------------------------------------------------------------
|
|
void CTFRobotDestruction_Robot::PlayDeathEffects()
|
|
{
|
|
EmitSound( g_RobotData[ GetRobotSpawnData().m_eType ]->GetStringData( RobotData_t::DEATH_SOUND_KEY ) );
|
|
EmitSound( ROBOT_DEATH_EXPLOSION );
|
|
DispatchParticleEffect( DEATH_PARTICLE_EFFECT, GetAbsOrigin(), QAngle( 0,0,0 ) );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Handle getting killed
|
|
//-----------------------------------------------------------------------------
|
|
void CTFRobotDestruction_Robot::Event_Killed( const CTakeDamageInfo &info )
|
|
{
|
|
// Let the game logic know that we died
|
|
if ( CTFRobotDestructionLogic::GetRobotDestructionLogic() )
|
|
{
|
|
CTFRobotDestructionLogic::GetRobotDestructionLogic()->RobotRemoved( this );
|
|
}
|
|
|
|
PlayDeathEffects();
|
|
|
|
// Find the killer & the scorer
|
|
CBaseEntity *pInflictor = info.GetInflictor();
|
|
CBaseEntity *pKiller = info.GetAttacker();
|
|
CTFPlayer *pScorer = ToTFPlayer( TFGameRules()->GetDeathScorer( pKiller, pInflictor, this ) );
|
|
CTFPlayer *pAssister = NULL;
|
|
|
|
if ( pScorer )
|
|
{
|
|
// If a player is healing the scorer, give that player credit for the assist
|
|
CTFPlayer *pHealer = ToTFPlayer( static_cast<CBaseEntity *>( pScorer->m_Shared.GetFirstHealer() ) );
|
|
// Must be a medic to receive a healing assist, otherwise engineers get credit for assists from dispensers doing healing.
|
|
// Also don't give an assist for healing if the inflictor was a sentry gun, otherwise medics healing engineers get assists for the engineer's sentry kills.
|
|
if ( pHealer && ( pHealer->GetPlayerClass()->GetClassIndex() == TF_CLASS_MEDIC ) )
|
|
{
|
|
pAssister = pHealer;
|
|
}
|
|
|
|
// Work out what killed the player, and send a message to all clients about it
|
|
int iWeaponID;
|
|
const char *killer_weapon_name = TFGameRules()->GetKillingWeaponName( info, NULL, &iWeaponID );
|
|
const char *killer_weapon_log_name = killer_weapon_name;
|
|
|
|
CTFWeaponBase *pWeapon = dynamic_cast< CTFWeaponBase * >( pScorer->Weapon_OwnsThisID( iWeaponID ) );
|
|
if ( pWeapon )
|
|
{
|
|
CEconItemView *pItem = pWeapon->GetAttributeContainer()->GetItem();
|
|
|
|
if ( pItem )
|
|
{
|
|
if ( pItem->GetStaticData()->GetIconClassname() )
|
|
{
|
|
killer_weapon_name = pItem->GetStaticData()->GetIconClassname();
|
|
}
|
|
|
|
if ( pItem->GetStaticData()->GetLogClassname() )
|
|
{
|
|
killer_weapon_log_name = pItem->GetStaticData()->GetLogClassname();
|
|
}
|
|
}
|
|
}
|
|
|
|
IGameEvent *event = gameeventmanager->CreateEvent( "rd_robot_killed" );
|
|
if ( event )
|
|
{
|
|
if ( pAssister && ( pAssister != pScorer ) )
|
|
{
|
|
event->SetInt( "assister", pAssister->GetUserID() );
|
|
}
|
|
|
|
event->SetInt( "attacker", pScorer->GetUserID() ); // attacker
|
|
event->SetString( "weapon", killer_weapon_name );
|
|
event->SetString( "weapon_logclassname", killer_weapon_log_name );
|
|
event->SetInt( "weaponid", iWeaponID );
|
|
event->SetInt( "priority", 6 ); // HLTV event priority, not transmitted
|
|
|
|
gameeventmanager->FireEvent( event );
|
|
}
|
|
}
|
|
|
|
if ( m_hSpawn )
|
|
{
|
|
m_hSpawn->OnRobotKilled();
|
|
}
|
|
|
|
if ( m_hGroup )
|
|
{
|
|
m_hGroup->OnRobotKilled();
|
|
}
|
|
|
|
// Kings dont die right away. Their head cracks open and they spew points out over time, then self-destruct
|
|
if ( m_spawnData.m_eType == ROBOT_TYPE_KING )
|
|
{
|
|
// Change our model to be the damage king model
|
|
SetModel( g_RobotData[ m_spawnData.m_eType ]->GetStringData( RobotData_t::DAMAGED_MODEL_KEY ) );
|
|
ResetSequence( LookupSequence("idle") );
|
|
|
|
m_takedamage = DAMAGE_NO;
|
|
SetContextThink( &CTFRobotDestruction_Robot::SpewBarsThink, gpGlobals->curtime, SPEW_BARS_CONTEXT );
|
|
SetContextThink( &CTFRobotDestruction_Robot::SelfDestructThink, gpGlobals->curtime + 5.f, SELF_DESTRUCT_THINK );
|
|
|
|
return;
|
|
}
|
|
|
|
// Spew our points
|
|
SpewBars( m_spawnData.m_nNumGibs );
|
|
|
|
// Spew ammo gibs out
|
|
SpewGibs();
|
|
|
|
CBaseAnimating::Event_Killed( info );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Spew out robot gibs that give ammo
|
|
//-----------------------------------------------------------------------------
|
|
void CTFRobotDestruction_Robot::SpewGibs()
|
|
{
|
|
for ( int i=0; i<m_aGibs.Count(); i++ )
|
|
{
|
|
CTFAmmoPack *pAmmoPack = CTFAmmoPack::Create( GetAbsOrigin() + m_aGibs[i].offset, GetAbsAngles(), this, m_aGibs[i].modelName );
|
|
Assert( pAmmoPack );
|
|
if ( pAmmoPack )
|
|
{
|
|
pAmmoPack->ActivateWhenAtRest();
|
|
|
|
// Calculate the initial impulse on the weapon.
|
|
Vector vecImpulse( random->RandomFloat( -0.5f, 0.5f ), random->RandomFloat( -0.5f, 0.5f ), random->RandomFloat( 0.75f, 1.25f ) );
|
|
VectorNormalize( vecImpulse );
|
|
// Detect the head model
|
|
bool bIsTheHead = FStrEq( "models/bots/bot_worker/bot_worker_head_gib.mdl", m_aGibs[i].modelName );
|
|
if ( bIsTheHead )
|
|
{
|
|
// Pop more up than anything
|
|
vecImpulse[2] = 3.f;
|
|
vecImpulse *= random->RandomFloat( tf_obj_gib_velocity_max.GetFloat() * 0.75, tf_obj_gib_velocity_max.GetFloat() );
|
|
}
|
|
else
|
|
{
|
|
vecImpulse *= random->RandomFloat( tf_obj_gib_velocity_min.GetFloat(), tf_obj_gib_velocity_max.GetFloat() );
|
|
}
|
|
|
|
|
|
// Cap the impulse.
|
|
float flSpeed = vecImpulse.Length();
|
|
if ( flSpeed > tf_obj_gib_maxspeed.GetFloat() )
|
|
{
|
|
VectorScale( vecImpulse, tf_obj_gib_maxspeed.GetFloat() / flSpeed, vecImpulse );
|
|
}
|
|
|
|
if ( pAmmoPack->VPhysicsGetObject() )
|
|
{
|
|
AngularImpulse angImpulse( 0.f, random->RandomFloat( 0.f, 100.f ), 0.f );
|
|
if ( bIsTheHead )
|
|
{
|
|
// Make the head spin around like a top
|
|
angImpulse = AngularImpulse( RandomFloat(-60.f,60.f), RandomFloat(-60.f,60.f), 100000.f );
|
|
}
|
|
pAmmoPack->VPhysicsGetObject()->SetVelocityInstantaneous( &vecImpulse, &angImpulse );
|
|
}
|
|
|
|
pAmmoPack->SetInitialVelocity( vecImpulse );
|
|
|
|
pAmmoPack->m_nSkin = ( GetTeamNumber() == TF_TEAM_RED ) ? 0 : 1;
|
|
|
|
// Give the ammo pack some health, so that trains can destroy it.
|
|
pAmmoPack->SetCollisionGroup( COLLISION_GROUP_DEBRIS );
|
|
pAmmoPack->m_takedamage = DAMAGE_YES;
|
|
pAmmoPack->SetHealth( 900 );
|
|
pAmmoPack->m_bObjGib = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Do some special effects when we take damage
|
|
//-----------------------------------------------------------------------------
|
|
int CTFRobotDestruction_Robot::OnTakeDamage( const CTakeDamageInfo &info )
|
|
{
|
|
// Check teams
|
|
if ( info.GetAttacker() )
|
|
{
|
|
if ( InSameTeam(info.GetAttacker()) )
|
|
return 0;
|
|
|
|
CBasePlayer *pAttacker = ToBasePlayer( info.GetAttacker() );
|
|
if ( pAttacker )
|
|
{
|
|
pAttacker->SetLastObjectiveTime( gpGlobals->curtime );
|
|
}
|
|
}
|
|
|
|
SetContextThink( &CTFRobotDestruction_Robot::RepairSelfThink, gpGlobals->curtime + 5.f, "RepairSelfThink" );
|
|
|
|
if ( m_bShielded )
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
CTakeDamageInfo newInfo;
|
|
newInfo = info;
|
|
ModifyDamage( &newInfo );
|
|
|
|
// Get our attack vectors
|
|
Vector vecDamagePos = newInfo.GetDamagePosition();
|
|
QAngle vecDamageAngles;
|
|
VectorAngles( -newInfo.GetDamageForce(), vecDamageAngles );
|
|
// Use worldspace center if no damage position (happens with flamethrowers)
|
|
if ( vecDamagePos == vec3_origin )
|
|
{
|
|
vecDamagePos = WorldSpaceCenter();
|
|
}
|
|
|
|
// Play a spark effect
|
|
DispatchParticleEffect( "rd_bot_impact_sparks", vecDamagePos, vecDamageAngles );
|
|
|
|
// Send an impulse event to the client for this bot
|
|
Vector vecImpulse( newInfo.GetDamageForce() );
|
|
m_animController.Impulse( vecImpulse.Normalized() * 20.f );
|
|
|
|
IGameEvent *event = gameeventmanager->CreateEvent( "rd_robot_impact" );
|
|
if ( event )
|
|
{
|
|
event->SetInt( "entindex", entindex() );
|
|
event->SetInt( "impulse_x", vecImpulse.x );
|
|
event->SetInt( "impulse_y", vecImpulse.y );
|
|
event->SetInt( "impulse_z", vecImpulse.z );
|
|
|
|
gameeventmanager->FireEvent( event );
|
|
}
|
|
|
|
if( m_hGroup )
|
|
{
|
|
m_hGroup->OnRobotAttacked();
|
|
}
|
|
|
|
int nBaseResult = BaseClass::OnTakeDamage( newInfo );
|
|
|
|
// Let the game logic know that we got hurt
|
|
if ( CTFRobotDestructionLogic::GetRobotDestructionLogic() )
|
|
CTFRobotDestructionLogic::GetRobotDestructionLogic()->RobotAttacked( this );
|
|
|
|
return nBaseResult;
|
|
}
|
|
|
|
|
|
void CTFRobotDestruction_Robot::ModifyDamage( CTakeDamageInfo *info ) const
|
|
{
|
|
CTFPlayer *pAttacker = ToTFPlayer( info->GetAttacker() );
|
|
if ( pAttacker )
|
|
{
|
|
float flScale = 1.f;
|
|
|
|
if ( pAttacker->IsPlayerClass( TF_CLASS_SCOUT ) )
|
|
flScale = 1.5f;
|
|
else if( pAttacker->IsPlayerClass( TF_CLASS_SNIPER ) )
|
|
flScale = 2.25f;
|
|
else if ( pAttacker->IsPlayerClass( TF_CLASS_SPY ) )
|
|
flScale = 2.f;
|
|
else if ( pAttacker->IsPlayerClass( TF_CLASS_PYRO ) )
|
|
flScale = 0.75;
|
|
else if ( pAttacker->IsPlayerClass( TF_CLASS_HEAVYWEAPONS ) )
|
|
flScale = 0.75;
|
|
else if ( pAttacker->IsPlayerClass( TF_CLASS_MEDIC ) )
|
|
flScale = 2.f;
|
|
|
|
info->SetDamage( info->GetDamage() * flScale );
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Override base traceattack to prevent visible effects from team members shooting me
|
|
//-----------------------------------------------------------------------------
|
|
void CTFRobotDestruction_Robot::TraceAttack( const CTakeDamageInfo &inputInfo, const Vector &vecDir, trace_t *ptr, CDmgAccumulator *pAccumulator )
|
|
{
|
|
// Prevent team damage here so blood doesn't appear
|
|
if ( inputInfo.GetAttacker() && InSameTeam(inputInfo.GetAttacker()) )
|
|
return;
|
|
|
|
AddMultiDamage( inputInfo, this );
|
|
}
|
|
|
|
void CTFRobotDestruction_Robot::UpdateAnimsThink( void )
|
|
{
|
|
m_animController.Update();
|
|
|
|
SetContextThink( &CTFRobotDestruction_Robot::UpdateAnimsThink, gpGlobals->curtime, ANIMS_THINK );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Change our AI state to use a computer
|
|
//-----------------------------------------------------------------------------
|
|
void CTFRobotDestruction_Robot::InputStopAndUseComputer( inputdata_t &inputdata )
|
|
{
|
|
// TODO: Fire off into the AI
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Shoot bars out as we die
|
|
//-----------------------------------------------------------------------------
|
|
void CTFRobotDestruction_Robot::SpewBars( int nNumToSpew )
|
|
{
|
|
for( int i=0; i < nNumToSpew; ++i )
|
|
{
|
|
CBonusPack *pBonusPack = assert_cast< CBonusPack* >( CreateEntityByName( "item_bonuspack" ) );
|
|
if ( pBonusPack )
|
|
{
|
|
pBonusPack->ChangeTeam( GetEnemyTeam( GetTeamNumber() ) );
|
|
pBonusPack->SetDisabled( false );
|
|
pBonusPack->SetAbsOrigin( GetAbsOrigin() + Vector(0,0,20) );
|
|
pBonusPack->SetAbsAngles( QAngle( 0.f, RandomFloat( 0, 360.f ), 0.f ) );
|
|
// Calculate the initial impulse on the cores
|
|
Vector vecImpulse( random->RandomFloat( -0.5, 0.5 ), random->RandomFloat( -0.5, 0.5 ), random->RandomFloat( 1.0, 1.25 ) );
|
|
VectorNormalize( vecImpulse );
|
|
vecImpulse *= random->RandomFloat( 125.f, 150.f );
|
|
|
|
// Cap the impulse.
|
|
float flSpeed = vecImpulse.Length();
|
|
if ( flSpeed > tf_obj_gib_maxspeed.GetFloat() )
|
|
{
|
|
VectorScale( vecImpulse, tf_obj_gib_maxspeed.GetFloat() / flSpeed, vecImpulse );
|
|
}
|
|
|
|
pBonusPack->SetCollisionGroup( COLLISION_GROUP_DEBRIS );
|
|
pBonusPack->AddSpawnFlags( SF_NORESPAWN );
|
|
pBonusPack->m_nSkin = GetTeamNumber() == TF_TEAM_RED ? 0 : 1;
|
|
|
|
DispatchSpawn( pBonusPack );
|
|
pBonusPack->DropSingleInstance( vecImpulse, NULL, 0, 0 );
|
|
pBonusPack->SetCycle( RandomFloat( 0.f, 1.f ) );
|
|
pBonusPack->SetGravity( 0.2f );
|
|
}
|
|
}
|
|
}
|
|
|
|
void CTFRobotDestruction_Robot::SpewBarsThink()
|
|
{
|
|
int nNumToSpew = 1;
|
|
m_nPointsSpewed += nNumToSpew;
|
|
SpewBars( nNumToSpew );
|
|
|
|
if ( m_nPointsSpewed >= m_spawnData.m_nNumGibs )
|
|
{
|
|
SelfDestructThink();
|
|
}
|
|
else
|
|
{
|
|
SetContextThink( &CTFRobotDestruction_Robot::SpewBarsThink, gpGlobals->curtime + 0.1f, SPEW_BARS_CONTEXT );
|
|
}
|
|
}
|
|
|
|
void CTFRobotDestruction_Robot::SelfDestructThink()
|
|
{
|
|
SpewGibs();
|
|
SpewBars( m_spawnData.m_nNumGibs - m_nPointsSpewed );
|
|
PlayDeathEffects();
|
|
UTIL_Remove( this );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Repair ourselves!
|
|
//-----------------------------------------------------------------------------
|
|
void CTFRobotDestruction_Robot::RepairSelfThink()
|
|
{
|
|
// Heal!
|
|
int nHealth = GetHealth();
|
|
if ( tf_rd_robot_repair_rate.GetFloat() != 0.f )
|
|
{
|
|
nHealth += GetMaxHealth() / tf_rd_robot_repair_rate.GetFloat();
|
|
}
|
|
nHealth = Min( nHealth, GetMaxHealth() );
|
|
SetHealth( nHealth );
|
|
|
|
// Continue to heal if we're still hurt
|
|
if ( GetHealth() != GetMaxHealth() )
|
|
{
|
|
SetContextThink( &CTFRobotDestruction_Robot::RepairSelfThink, gpGlobals->curtime + 1.f, "RepairSelfThink" );
|
|
}
|
|
}
|
|
|
|
void CTFRobotDestruction_Robot::ArriveAtPath()
|
|
{
|
|
m_hNextPath->AcceptInput( "InPass", this, this, variant_t(), 0 );
|
|
m_hNextPath = m_hNextPath->GetNext();
|
|
}
|
|
|
|
void CTFRobotDestruction_Robot::EnableUber()
|
|
{
|
|
m_bShielded = true;
|
|
m_nSkin = GetTeamNumber() == TF_TEAM_RED ? 2 : 3;
|
|
|
|
if ( m_hGroup )
|
|
{
|
|
m_hGroup->UpdateState();
|
|
}
|
|
}
|
|
|
|
void CTFRobotDestruction_Robot::DisableUber()
|
|
{
|
|
m_bShielded = false;
|
|
m_nSkin = GetTeamNumber() == TF_TEAM_RED ? 0 : 1;
|
|
|
|
if ( m_hGroup )
|
|
{
|
|
m_hGroup->UpdateState();
|
|
}
|
|
}
|
|
|
|
void CTFRobotDestruction_Robot::SetNewActivity( Activity activity )
|
|
{
|
|
int nSequence = SelectWeightedSequence( activity );
|
|
if ( nSequence )
|
|
{
|
|
SetSequence( nSequence );
|
|
SetPlaybackRate( 1.0f );
|
|
SetCycle( 0 );
|
|
ResetSequenceInfo();
|
|
}
|
|
}
|
|
|
|
#define CLOSE_ENOUGH_TO_PATH 50.f
|
|
|
|
//---------------------------------------------------------------------------------------------
|
|
class CRobotPatrol : public Action< CTFRobotDestruction_Robot >
|
|
{
|
|
public:
|
|
void PlayIdleActivity( CTFRobotDestruction_Robot *pMe )
|
|
{
|
|
pMe->SetNewActivity( ACT_BOT_PRIMARY_MOVEMENT );
|
|
}
|
|
|
|
virtual ActionResult< CTFRobotDestruction_Robot > OnStart( CTFRobotDestruction_Robot *pMe, Action< CTFRobotDestruction_Robot > *priorAction )
|
|
{
|
|
PlayIdleActivity( pMe );
|
|
|
|
return Continue();
|
|
}
|
|
|
|
virtual ActionResult< CTFRobotDestruction_Robot > OnResume( CTFRobotDestruction_Robot *pMe, Action< CTFRobotDestruction_Robot > *interruptingAction )
|
|
{
|
|
PlayIdleActivity( pMe );
|
|
|
|
return Continue();
|
|
}
|
|
|
|
virtual ActionResult< CTFRobotDestruction_Robot > Update( CTFRobotDestruction_Robot *pMe, float interval )
|
|
{
|
|
CPathTrack* pNextPath = pMe->GetNextPath();
|
|
|
|
if ( pMe->IsRangeGreaterThan( pNextPath, CLOSE_ENOUGH_TO_PATH ) )
|
|
{
|
|
if ( m_path.GetAge() > 0.5f )
|
|
{
|
|
CRobotPathCost cost( pMe );
|
|
m_path.Compute( pMe, pNextPath->GetAbsOrigin(), cost );
|
|
}
|
|
|
|
m_path.Update( pMe );
|
|
}
|
|
else
|
|
{
|
|
pMe->ArriveAtPath();
|
|
}
|
|
|
|
return Continue();
|
|
}
|
|
|
|
virtual const char *GetName( void ) const { return "Patrol"; } // return name of this action
|
|
PathFollower m_path;
|
|
};
|
|
|
|
class CRobotSpawn : public Action< CTFRobotDestruction_Robot >
|
|
{
|
|
virtual ActionResult< CTFRobotDestruction_Robot > OnStart( CTFRobotDestruction_Robot *pMe, Action< CTFRobotDestruction_Robot > *priorAction )
|
|
{
|
|
pMe->SetNewActivity( ACT_BOT_SPAWN );
|
|
return Continue();
|
|
}
|
|
|
|
virtual ActionResult< CTFRobotDestruction_Robot > Update( CTFRobotDestruction_Robot *pMe, float interval )
|
|
{
|
|
if ( pMe->IsActivityFinished() )
|
|
{
|
|
return ChangeTo( new CRobotPatrol, "I've finished my spawn sequence" );
|
|
}
|
|
|
|
return Continue();
|
|
}
|
|
|
|
EventDesiredResult< CTFRobotDestruction_Robot > OnInjured( CTFRobotDestruction_Robot *pMe, const CTakeDamageInfo &info )
|
|
{
|
|
return TryToSustain( RESULT_CRITICAL, "I'm spawning and being attacked" );
|
|
}
|
|
|
|
virtual void OnEnd( CTFRobotDestruction_Robot *pMe, Action< CTFRobotDestruction_Robot > *nextAction )
|
|
{
|
|
pMe->SetBodygroup( pMe->FindBodygroupByName( "head_shell" ), 1 );
|
|
pMe->SetBodygroup( pMe->FindBodygroupByName( "body_shell" ), 1 );
|
|
}
|
|
|
|
virtual const char *GetName( void ) const { return "Spawn"; } // return name of this action
|
|
};
|
|
|
|
class CRobotMaterialize : public Action< CTFRobotDestruction_Robot >
|
|
{
|
|
public:
|
|
virtual ActionResult< CTFRobotDestruction_Robot > OnStart( CTFRobotDestruction_Robot *pMe, Action< CTFRobotDestruction_Robot > *priorAction )
|
|
{
|
|
// TODO: Play the materialize anim and effects
|
|
/*int nSequence = pMe->SelectWeightedSequence( ACT_BOT_MATERIALIZE );
|
|
pMe->ResetSequence( nSequence );*/
|
|
return Continue();
|
|
}
|
|
|
|
virtual ActionResult< CTFRobotDestruction_Robot > Update( CTFRobotDestruction_Robot *pMe, float interval )
|
|
{
|
|
// TODO: Check if materialize activity is finished
|
|
//if ( pMe->IsActivityFinished() )
|
|
{
|
|
return ChangeTo( new CRobotSpawn, "I've fully materialized" );
|
|
}
|
|
|
|
// TODO: Control the materialize anim
|
|
|
|
return Continue();
|
|
}
|
|
|
|
virtual const char *GetName( void ) const { return "Materialize"; } // return name of this action
|
|
PathFollower m_path;
|
|
};
|
|
|
|
|
|
class CRobotPanic : public Action< CTFRobotDestruction_Robot >
|
|
{
|
|
public:
|
|
virtual ActionResult< CTFRobotDestruction_Robot > OnStart( CTFRobotDestruction_Robot *pMe, Action< CTFRobotDestruction_Robot > *priorAction );
|
|
virtual ActionResult< CTFRobotDestruction_Robot > Update( CTFRobotDestruction_Robot *pMe, float interval );
|
|
virtual EventDesiredResult< CTFRobotDestruction_Robot > OnInjured( CTFRobotDestruction_Robot *pMe, const CTakeDamageInfo &info );
|
|
virtual void OnEnd( CTFRobotDestruction_Robot *pMe, Action< CTFRobotDestruction_Robot > *nextAction );
|
|
|
|
virtual const char *GetName( void ) const { return "Panic"; }
|
|
|
|
private:
|
|
|
|
CountdownTimer m_SpeakTimer;
|
|
CountdownTimer m_attackedTimer;
|
|
CountdownTimer m_spinTimer;
|
|
bool m_bSpinRight;
|
|
};
|
|
|
|
class CRobotEnterPanic : public Action< CTFRobotDestruction_Robot >
|
|
{
|
|
virtual ActionResult< CTFRobotDestruction_Robot > OnStart( CTFRobotDestruction_Robot *pMe, Action< CTFRobotDestruction_Robot > *priorAction )
|
|
{
|
|
pMe->SetNewActivity( ACT_BOT_PANIC_START );
|
|
return Continue();
|
|
}
|
|
|
|
virtual ActionResult< CTFRobotDestruction_Robot > Update( CTFRobotDestruction_Robot *pMe, float interval )
|
|
{
|
|
if ( pMe->IsActivityFinished() )
|
|
{
|
|
return ChangeTo( new CRobotPanic, "I've finished my enter panic sequence" );
|
|
}
|
|
|
|
return Continue();
|
|
}
|
|
|
|
EventDesiredResult< CTFRobotDestruction_Robot > OnInjured( CTFRobotDestruction_Robot *pMe, const CTakeDamageInfo &info )
|
|
{
|
|
return TryToSustain( RESULT_CRITICAL, "I'm entering panic and being attacked" );
|
|
}
|
|
|
|
virtual const char *GetName( void ) const { return "Enter Panic"; } // return name of this action
|
|
};
|
|
|
|
class CRobotLeavePanic : public Action< CTFRobotDestruction_Robot >
|
|
{
|
|
virtual ActionResult< CTFRobotDestruction_Robot > OnStart( CTFRobotDestruction_Robot *pMe, Action< CTFRobotDestruction_Robot > *priorAction )
|
|
{
|
|
pMe->SetNewActivity( ACT_BOT_PANIC_END );
|
|
return Continue();
|
|
}
|
|
|
|
virtual ActionResult< CTFRobotDestruction_Robot > Update( CTFRobotDestruction_Robot *pMe, float interval )
|
|
{
|
|
if ( pMe->IsActivityFinished() )
|
|
{
|
|
return Done( "I've finished my leave panic sequence" );
|
|
}
|
|
|
|
return Continue();
|
|
}
|
|
|
|
EventDesiredResult< CTFRobotDestruction_Robot > OnInjured( CTFRobotDestruction_Robot *pMe, const CTakeDamageInfo &info )
|
|
{
|
|
return TryToSustain( RESULT_CRITICAL, "I'm leaving panic and being attacked" );
|
|
}
|
|
|
|
virtual const char *GetName( void ) const { return "Leave Panic"; } // return name of this action
|
|
};
|
|
|
|
//---------------------------------------------------------------------------------------------
|
|
ActionResult< CTFRobotDestruction_Robot > CRobotPanic::OnStart( CTFRobotDestruction_Robot *pMe, Action< CTFRobotDestruction_Robot > *priorAction )
|
|
{
|
|
m_bSpinRight = RandomInt(0,1) == 1; // Randomly pick which way to spin
|
|
pMe->SetIsPanicked( true ); // Let our bot know he's panicked
|
|
m_attackedTimer.Start( 5.f ); // We panic for 5 seconds
|
|
m_spinTimer.Start( RandomFloat( 0.75f, 1.25f ) ); // Spin for a little bit
|
|
pMe->GetLocomotionInterface()->SetDesiredSpeed( 150.f ); // We go fast when panicked
|
|
DispatchParticleEffect( "rocketjump_smoke", PATTACH_POINT_FOLLOW, pMe, "wheel" ); // Smoke trails on our tire when panicked
|
|
pMe->SetNewActivity( ACT_BOT_PANIC ); // Play panicked activity
|
|
|
|
m_SpeakTimer.Start( 3.f );
|
|
const RobotSpawnData_t & data = pMe->GetRobotSpawnData();
|
|
pMe->EmitSound( g_RobotData[ data.m_eType ]->GetStringData( RobotData_t::HURT_SOUND_KEY ) );
|
|
|
|
return Continue();
|
|
}
|
|
|
|
ActionResult< CTFRobotDestruction_Robot > CRobotPanic::Update( CTFRobotDestruction_Robot *pMe, float interval )
|
|
{
|
|
// If we haven't been attacked in awhile, then we're done panicking
|
|
if ( m_attackedTimer.IsElapsed() )
|
|
{
|
|
return ChangeTo( new CRobotLeavePanic, "I'm done panicking" );
|
|
}
|
|
|
|
QAngle angles = pMe->GetLocalAngles();
|
|
|
|
// If our spin timer is still going, then spin!
|
|
if ( m_spinTimer.GetRemainingTime() < ( m_spinTimer.GetCountdownDuration() * 0.5f ) )
|
|
{
|
|
float flSpinAmt = 2500.f * gpGlobals->frametime;
|
|
flSpinAmt *= m_bSpinRight ? 1.f : -1.f;
|
|
angles.y += flSpinAmt;
|
|
pMe->SetLocalAngles( angles );
|
|
}
|
|
|
|
// We just drive forard
|
|
Vector vForward;
|
|
AngleVectors( angles, &vForward );
|
|
Vector vArrivePosition = pMe->GetAbsOrigin() + vForward * 30;
|
|
|
|
trace_t tr;
|
|
// See if we hit anything solid a little bit below the robot. We dont want to jump off cliffs
|
|
UTIL_TraceLine( vArrivePosition, vArrivePosition + Vector(0,0,-30), MASK_PLAYERSOLID, pMe, COLLISION_GROUP_PLAYER_MOVEMENT, &tr );
|
|
if ( tr.fraction < 1.0f )
|
|
{
|
|
pMe->GetLocomotionInterface()->Approach( vArrivePosition );
|
|
}
|
|
|
|
// It's time change our spin direction, choose when to spin next, and reapply our smoke particle
|
|
if ( m_spinTimer.IsElapsed() )
|
|
{
|
|
m_bSpinRight = RandomInt(0,1) == 1;
|
|
m_spinTimer.Start( RandomFloat( 0.75f, 1.25f ) );
|
|
DispatchParticleEffect( "rocketjump_smoke", PATTACH_POINT_FOLLOW, pMe, "wheel" );
|
|
}
|
|
|
|
return Continue();
|
|
}
|
|
|
|
EventDesiredResult< CTFRobotDestruction_Robot > CRobotPanic::OnInjured( CTFRobotDestruction_Robot *pMe, const CTakeDamageInfo &info )
|
|
{
|
|
if ( m_SpeakTimer.IsElapsed() )
|
|
{
|
|
m_SpeakTimer.Start( RandomFloat( 1.5f, 2.f ) );
|
|
const RobotSpawnData_t & data = pMe->GetRobotSpawnData();
|
|
pMe->EmitSound( g_RobotData[ data.m_eType ]->GetStringData( RobotData_t::HURT_SOUND_KEY ) );
|
|
}
|
|
|
|
m_attackedTimer.Start( m_attackedTimer.GetCountdownDuration() );
|
|
return TryToSustain( RESULT_IMPORTANT, "I'm panicking and getting attacked" );
|
|
}
|
|
|
|
void CRobotPanic::OnEnd( CTFRobotDestruction_Robot *pMe, Action< CTFRobotDestruction_Robot > *nextAction )
|
|
{
|
|
pMe->SetIsPanicked( false );
|
|
pMe->GetLocomotionInterface()->SetDesiredSpeed( 80.f );
|
|
}
|
|
|
|
|
|
//---------------------------------------------------------------------------------------------
|
|
Action< CTFRobotDestruction_Robot > *CRobotBehavior::InitialContainedAction( CTFRobotDestruction_Robot *pMe )
|
|
{
|
|
return new CRobotMaterialize;
|
|
}
|
|
|
|
ActionResult< CTFRobotDestruction_Robot > CRobotBehavior::OnStart( CTFRobotDestruction_Robot *pMe, Action< CTFRobotDestruction_Robot > *priorAction )
|
|
{
|
|
return Continue();
|
|
}
|
|
|
|
#ifdef STAGING_ONLY
|
|
ConVar sv_rd_bots_STFU( "sv_rd_bots_STFU", "0", FCVAR_ARCHIVE );
|
|
#endif
|
|
ActionResult< CTFRobotDestruction_Robot > CRobotBehavior::Update( CTFRobotDestruction_Robot *pMe, float interval )
|
|
{
|
|
//const CKnownEntity *pThreat = pMe->GetVisionInterface()->GetPrimaryKnownThreat();
|
|
//if ( pThreat )
|
|
//{
|
|
// return SuspendFor( new CRobotAttackEnemy, "I see an enemy!" );
|
|
//}
|
|
#ifdef STAGING_ONLY
|
|
if ( !sv_rd_bots_STFU.GetBool() )
|
|
#endif
|
|
{
|
|
// We've been wandering for a bit. Speak!
|
|
if ( m_IdleSpeakTimer.IsElapsed() && m_SpeakTimer.IsElapsed() )
|
|
{
|
|
m_SpeakTimer.Start( 1.f );
|
|
m_IdleSpeakTimer.Start( RandomFloat( 6.f, 10.f ) );
|
|
const RobotSpawnData_t & data = pMe->GetRobotSpawnData();
|
|
pMe->EmitSound( g_RobotData[ data.m_eType ]->GetStringData( RobotData_t::IDLE_SOUND_KEY ) );
|
|
}
|
|
}
|
|
|
|
// Do stuff!
|
|
return Continue();
|
|
}
|
|
|
|
EventDesiredResult< CTFRobotDestruction_Robot > CRobotBehavior::OnInjured( CTFRobotDestruction_Robot *pMe, const CTakeDamageInfo &info )
|
|
{
|
|
return TrySuspendFor( new CRobotEnterPanic, RESULT_TRY, "I've been attacked" );
|
|
}
|
|
|
|
|
|
EventDesiredResult< CTFRobotDestruction_Robot > CRobotBehavior::OnContact( CTFRobotDestruction_Robot *pMe, CBaseEntity *pOther, CGameTrace *result )
|
|
{
|
|
if ( m_SpeakTimer.IsElapsed() && ( pOther->IsPlayer() || dynamic_cast< CTFRobotDestruction_Robot * >( pOther ) ) )
|
|
{
|
|
m_SpeakTimer.Start( 3.f );
|
|
|
|
#ifdef STAGING_ONLY
|
|
if ( !sv_rd_bots_STFU.GetBool() )
|
|
#endif
|
|
{
|
|
const RobotSpawnData_t & data = pMe->GetRobotSpawnData();
|
|
pMe->EmitSound( g_RobotData[ data.m_eType ]->GetStringData( RobotData_t::COLLIDE_SOUND_KEY ) );
|
|
}
|
|
}
|
|
|
|
return TryContinue( RESULT_TRY );
|
|
}
|
|
|
|
|
|
//---------------------------------------------------------------------------------------------
|
|
CRobotIntention::CRobotIntention( CTFRobotDestruction_Robot *pMe ) : IIntention( pMe )
|
|
{
|
|
m_behavior = new Behavior< CTFRobotDestruction_Robot >( new CRobotBehavior );
|
|
}
|
|
|
|
CRobotIntention::~CRobotIntention()
|
|
{
|
|
delete m_behavior;
|
|
}
|
|
|
|
void CRobotIntention::Reset( void )
|
|
{
|
|
delete m_behavior;
|
|
m_behavior = new Behavior< CTFRobotDestruction_Robot >( new CRobotBehavior );
|
|
}
|
|
|
|
void CRobotIntention::Update( void )
|
|
{
|
|
m_behavior->Update( static_cast< CTFRobotDestruction_Robot * >( GetBot() ), GetUpdateInterval() );
|
|
}
|
|
|
|
// is this a place we can be?
|
|
QueryResultType CRobotIntention::IsPositionAllowed( const INextBot *pMeBot, const Vector &pos ) const
|
|
{
|
|
return ANSWER_YES;
|
|
}
|
|
|
|
|
|
|
|
//---------------------------------------------------------------------------------------------
|
|
float CRobotLocomotion::GetRunSpeed( void ) const
|
|
{
|
|
CTFRobotDestruction_Robot *pRobotMe = static_cast< CTFRobotDestruction_Robot *>( GetBot()->GetEntity() );
|
|
return pRobotMe->GetIsPanicked() ? 150.f : 80.f;
|
|
}
|
|
|
|
float CRobotLocomotion::GetGroundSpeed() const
|
|
{
|
|
CTFRobotDestruction_Robot *pRobotMe = static_cast< CTFRobotDestruction_Robot *>( GetBot()->GetEntity() );
|
|
return pRobotMe->GetIsPanicked() ? 150.f : 80.f;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------------
|
|
// if delta Z is greater than this, we have to jump to get up
|
|
float CRobotLocomotion::GetStepHeight( void ) const
|
|
{
|
|
return 24.0f;
|
|
}
|
|
|
|
|
|
//---------------------------------------------------------------------------------------------
|
|
// return maximum height of a jump
|
|
float CRobotLocomotion::GetMaxJumpHeight( void ) const
|
|
{
|
|
return 40.0f;
|
|
}
|
|
|
|
|
|
//---------------------------------------------------------------------------------------------
|
|
// Return max rate of yaw rotation
|
|
float CRobotLocomotion::GetMaxYawRate( void ) const
|
|
{
|
|
return 200.0f;
|
|
}
|
|
|
|
|
|
//---------------------------------------------------------------------------------------------
|
|
bool CRobotLocomotion::ShouldCollideWith( const CBaseEntity *object ) const
|
|
{
|
|
return false;
|
|
}
|
|
|
|
#endif
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Robot Dispenser
|
|
//-----------------------------------------------------------------------------
|
|
|
|
BEGIN_DATADESC( CRobotDispenser )
|
|
END_DATADESC()
|
|
|
|
IMPLEMENT_NETWORKCLASS_ALIASED( RobotDispenser, DT_RobotDispenser )
|
|
LINK_ENTITY_TO_CLASS( rd_robot_dispenser, CRobotDispenser );
|
|
|
|
BEGIN_NETWORK_TABLE( CRobotDispenser, DT_RobotDispenser )
|
|
END_NETWORK_TABLE()
|
|
|
|
#ifdef GAME_DLL
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
CRobotDispenser::CRobotDispenser()
|
|
{
|
|
m_bUseGenerateMetalSound = false;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CRobotDispenser::Spawn( void )
|
|
{
|
|
// This cast is for the benefit of GCC
|
|
m_fObjectFlags |= (int)OF_DOESNT_HAVE_A_MODEL;
|
|
m_takedamage = DAMAGE_NO;
|
|
m_iUpgradeLevel = 1;
|
|
|
|
TFGameRules()->OnDispenserBuilt( this );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Finished building
|
|
//-----------------------------------------------------------------------------
|
|
void CRobotDispenser::OnGoActive( void )
|
|
{
|
|
BaseClass::OnGoActive();
|
|
|
|
if ( m_hTouchTrigger )
|
|
{
|
|
m_hTouchTrigger->SetParent( GetParent() );
|
|
}
|
|
|
|
SetModel( "" );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Spawn the vgui control screens on the object
|
|
//-----------------------------------------------------------------------------
|
|
void CRobotDispenser::GetControlPanelInfo( int nPanelIndex, const char *&pPanelName )
|
|
{
|
|
// no panels
|
|
return;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CRobotDispenser::SetModel( const char *pModel )
|
|
{
|
|
CBaseObject::SetModel( pModel );
|
|
}
|
|
|
|
|
|
#endif
|