hl2_src-leak-2017/src/game/server/ai_dynamiclink.cpp

731 lines
20 KiB
C++
Raw Normal View History

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose: A link that can be turned on and off. Unlike normal links
// dyanimc links must be entities so they can receive messages.
// They update the state of the actual links. Allows us to save
// a lot of memory by not making all links into entities
//
// $NoKeywords: $
//=============================================================================//
#include "cbase.h"
#include "collisionutils.h"
#include "ai_dynamiclink.h"
#include "ai_node.h"
#include "ai_link.h"
#include "ai_network.h"
#include "ai_networkmanager.h"
#include "saverestore_utlvector.h"
#include "editor_sendcommand.h"
#include "bitstring.h"
#include "tier0/vprof.h"
// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"
//-----------------------------------------------------------------------------
LINK_ENTITY_TO_CLASS(info_node_link_controller, CAI_DynamicLinkController);
BEGIN_DATADESC( CAI_DynamicLinkController )
DEFINE_KEYFIELD( m_nLinkState, FIELD_INTEGER, "initialstate" ),
DEFINE_KEYFIELD( m_strAllowUse, FIELD_STRING, "AllowUse" ),
DEFINE_KEYFIELD( m_bInvertAllow, FIELD_BOOLEAN, "InvertAllow" ),
DEFINE_KEYFIELD( m_bUseAirLinkRadius, FIELD_BOOLEAN, "useairlinkradius" ),
// m_ControlledLinks (rebuilt)
DEFINE_INPUTFUNC( FIELD_VOID, "TurnOn", InputTurnOn ),
DEFINE_INPUTFUNC( FIELD_VOID, "TurnOff", InputTurnOff ),
DEFINE_INPUTFUNC( FIELD_STRING, "SetAllowed", InputSetAllowed ),
DEFINE_INPUTFUNC( FIELD_BOOLEAN, "SetInvert", InputSetInvert ),
END_DATADESC()
void CAI_DynamicLinkController::GenerateLinksFromVolume()
{
Assert( m_ControlledLinks.Count() == 0 );
int nNodes = g_pBigAINet->NumNodes();
CAI_Node **ppNodes = g_pBigAINet->AccessNodes();
float MinDistCareSq = 0;
if (m_bUseAirLinkRadius)
{
MinDistCareSq = Square(MAX_AIR_NODE_LINK_DIST + 0.1);
}
else
{
MinDistCareSq = Square(MAX_NODE_LINK_DIST + 0.1);
}
const Vector &origin = WorldSpaceCenter();
Vector vAbsMins, vAbsMaxs;
CollisionProp()->WorldSpaceAABB( &vAbsMins, &vAbsMaxs );
vAbsMins -= Vector( 1, 1, 1 );
vAbsMaxs += Vector( 1, 1, 1 );
for ( int i = 0; i < nNodes; i++ )
{
CAI_Node *pNode = ppNodes[i];
const Vector &nodeOrigin = pNode->GetOrigin();
if ( origin.DistToSqr(nodeOrigin) < MinDistCareSq )
{
int nLinks = pNode->NumLinks();
for ( int j = 0; j < nLinks; j++ )
{
CAI_Link *pLink = pNode->GetLinkByIndex( j );
int iLinkDest = pLink->DestNodeID( i );
if ( iLinkDest > i )
{
const Vector &originOther = ppNodes[iLinkDest]->GetOrigin();
if ( origin.DistToSqr(originOther) < MinDistCareSq )
{
if ( IsBoxIntersectingRay( vAbsMins, vAbsMaxs, nodeOrigin, originOther - nodeOrigin ) )
{
Assert( IsBoxIntersectingRay( vAbsMins, vAbsMaxs, originOther, nodeOrigin - originOther ) );
CAI_DynamicLink *pLink = (CAI_DynamicLink *)CreateEntityByName( "info_node_link" );
pLink->m_nSrcID = i;
pLink->m_nDestID = iLinkDest;
pLink->m_nSrcEditID = g_pAINetworkManager->GetEditOps()->GetWCIdFromNodeId( pLink->m_nSrcID );
pLink->m_nDestEditID = g_pAINetworkManager->GetEditOps()->GetWCIdFromNodeId( pLink->m_nDestID );
pLink->m_nLinkState = m_nLinkState;
pLink->m_strAllowUse = m_strAllowUse;
pLink->m_bInvertAllow = m_bInvertAllow;
pLink->m_bFixedUpIds = true;
pLink->m_bNotSaved = true;
pLink->Spawn();
m_ControlledLinks.AddToTail( pLink );
}
}
}
}
}
}
}
void CAI_DynamicLinkController::InputTurnOn( inputdata_t &inputdata )
{
for ( int i = 0; i < m_ControlledLinks.Count(); i++ )
{
if ( m_ControlledLinks[i] == NULL )
{
m_ControlledLinks.FastRemove(i);
if ( i >= m_ControlledLinks.Count() )
break;
}
m_ControlledLinks[i]->InputTurnOn( inputdata );
}
m_nLinkState = LINK_ON;
}
void CAI_DynamicLinkController::InputTurnOff( inputdata_t &inputdata )
{
for ( int i = 0; i < m_ControlledLinks.Count(); i++ )
{
if ( m_ControlledLinks[i] == NULL )
{
m_ControlledLinks.FastRemove(i);
if ( i >= m_ControlledLinks.Count() )
break;
}
m_ControlledLinks[i]->InputTurnOff( inputdata );
}
m_nLinkState = LINK_OFF;
}
void CAI_DynamicLinkController::InputSetAllowed( inputdata_t &inputdata )
{
m_strAllowUse = inputdata.value.StringID();
for ( int i = 0; i < m_ControlledLinks.Count(); i++ )
{
if ( m_ControlledLinks[i] == NULL )
{
m_ControlledLinks.FastRemove(i);
if ( i >= m_ControlledLinks.Count() )
break;
}
m_ControlledLinks[i]->m_strAllowUse = m_strAllowUse;
}
}
void CAI_DynamicLinkController::InputSetInvert( inputdata_t &inputdata )
{
m_bInvertAllow = inputdata.value.Bool();
for ( int i = 0; i < m_ControlledLinks.Count(); i++ )
{
if ( m_ControlledLinks[i] == NULL )
{
m_ControlledLinks.FastRemove(i);
if ( i >= m_ControlledLinks.Count() )
break;
}
m_ControlledLinks[i]->m_bInvertAllow = m_bInvertAllow;
}
}
//-----------------------------------------------------------------------------
LINK_ENTITY_TO_CLASS(info_node_link, CAI_DynamicLink);
BEGIN_DATADESC( CAI_DynamicLink )
// m_pNextDynamicLink
DEFINE_KEYFIELD( m_nLinkState, FIELD_INTEGER, "initialstate" ),
DEFINE_KEYFIELD( m_nSrcEditID, FIELD_INTEGER, "startnode" ),
DEFINE_KEYFIELD( m_nDestEditID, FIELD_INTEGER, "endnode" ),
DEFINE_KEYFIELD( m_nLinkType, FIELD_INTEGER, "linktype" ),
DEFINE_FIELD( m_bInvertAllow, FIELD_BOOLEAN ),
// m_nSrcID (rebuilt)
// m_nDestID (rebuilt)
DEFINE_KEYFIELD( m_strAllowUse, FIELD_STRING, "AllowUse" ),
// m_bFixedUpIds (part of rebuild)
// m_bNotSaved (rebuilt)
DEFINE_INPUTFUNC( FIELD_VOID, "TurnOn", InputTurnOn ),
DEFINE_INPUTFUNC( FIELD_VOID, "TurnOff", InputTurnOff ),
END_DATADESC()
//-----------------------------------------------------------------------------
// Init static variables
//-----------------------------------------------------------------------------
CAI_DynamicLink *CAI_DynamicLink::m_pAllDynamicLinks = NULL;
bool CAI_DynamicLink::gm_bInitialized;
//------------------------------------------------------------------------------
void CAI_DynamicLink::GenerateControllerLinks()
{
CAI_DynamicLinkController *pController = NULL;
while ( ( pController = gEntList.NextEntByClass( pController ) ) != NULL )
{
pController->GenerateLinksFromVolume();
}
}
//------------------------------------------------------------------------------
// Purpose : Initializes src and dest IDs for all dynamic links
//
// Input :
// Output :
//------------------------------------------------------------------------------
void CAI_DynamicLink::InitDynamicLinks(void)
{
if (!g_pAINetworkManager->GetEditOps()->m_pNodeIndexTable)
{
Warning("ERROR: Trying initialize links with no WC ID table!\n");
return;
}
if ( gm_bInitialized )
return;
gm_bInitialized = true;
bool bUpdateZones = false;
GenerateControllerLinks();
CAI_DynamicLink* pDynamicLink = CAI_DynamicLink::m_pAllDynamicLinks;
while (pDynamicLink)
{
// -------------------------------------------------------------
// First convert this links WC IDs to engine IDs
// -------------------------------------------------------------
if ( !pDynamicLink->m_bFixedUpIds )
{
int nSrcID = g_pAINetworkManager->GetEditOps()->GetNodeIdFromWCId( pDynamicLink->m_nSrcEditID );
if (nSrcID == -1)
{
DevMsg( "ERROR: Dynamic link source WC node %d not found\n", pDynamicLink->m_nSrcEditID );
nSrcID = NO_NODE;
}
int nDestID = g_pAINetworkManager->GetEditOps()->GetNodeIdFromWCId( pDynamicLink->m_nDestEditID );
if (nDestID == -1)
{
DevMsg( "ERROR: Dynamic link dest WC node %d not found\n", pDynamicLink->m_nDestEditID );
nDestID = NO_NODE;
}
pDynamicLink->m_nSrcID = nSrcID;
pDynamicLink->m_nDestID = nDestID;
pDynamicLink->m_bFixedUpIds = true;
}
if ( pDynamicLink->m_nSrcID != NO_NODE && pDynamicLink->m_nDestID != NO_NODE )
{
if ( ( pDynamicLink->GetSpawnFlags() & bits_HULL_BITS_MASK ) != 0 )
{
CAI_Link *pLink = pDynamicLink->FindLink();
if ( !pLink )
{
CAI_Node *pNode1, *pNode2;
pNode1 = g_pBigAINet->GetNode( pDynamicLink->m_nSrcID );
pNode2 = g_pBigAINet->GetNode( pDynamicLink->m_nDestID );
if ( pNode1 && pNode2 )
{
pLink = g_pBigAINet->CreateLink( pDynamicLink->m_nSrcID, pDynamicLink->m_nDestID );
if ( !pLink )
DevMsg( "Failed to create dynamic link (%d <--> %d)\n", pDynamicLink->m_nSrcEditID, pDynamicLink->m_nDestEditID );
}
}
if ( pLink )
{
bUpdateZones = true;
int hullBits = ( pDynamicLink->GetSpawnFlags() & bits_HULL_BITS_MASK );
for ( int i = 0; i < NUM_HULLS; i++ )
{
if ( hullBits & ( 1 << i ) )
{
pLink->m_iAcceptedMoveTypes[i] = pDynamicLink->m_nLinkType;
}
}
}
}
// Now set the link's state
pDynamicLink->SetLinkState();
// Go on to the next dynamic link
pDynamicLink = pDynamicLink->m_pNextDynamicLink;
}
else
{
CAI_DynamicLink *pBadDynamicLink = pDynamicLink;
// Go on to the next dynamic link
pDynamicLink = pDynamicLink->m_pNextDynamicLink;
UTIL_RemoveImmediate( pBadDynamicLink );
}
}
if ( bUpdateZones )
{
g_AINetworkBuilder.InitZones( g_pBigAINet );
}
}
//------------------------------------------------------------------------------
// Purpose : Goes through each dynamic link and updates the state of all
// AINetwork links
// Input :
// Output :
//------------------------------------------------------------------------------
void CAI_DynamicLink::ResetDynamicLinks(void)
{
CAI_DynamicLink* pDynamicLink = CAI_DynamicLink::m_pAllDynamicLinks;
while (pDynamicLink)
{
// Now set the link's state
pDynamicLink->SetLinkState();
// Go on to the next dynamic link
pDynamicLink = pDynamicLink->m_pNextDynamicLink;
}
}
//------------------------------------------------------------------------------
// Purpose : Goes through each dynamic link and checks to make sure that
// there is still a corresponding node link, if not removes it
// Input :
// Output :
//------------------------------------------------------------------------------
void CAI_DynamicLink::PurgeDynamicLinks(void)
{
CAI_DynamicLink* pDynamicLink = CAI_DynamicLink::m_pAllDynamicLinks;
while (pDynamicLink)
{
if (!pDynamicLink->IsLinkValid())
{
// Didn't find the link, so remove it
#ifdef _WIN32
int nWCSrcID = g_pAINetworkManager->GetEditOps()->m_pNodeIndexTable[pDynamicLink->m_nSrcID];
int nWCDstID = g_pAINetworkManager->GetEditOps()->m_pNodeIndexTable[pDynamicLink->m_nDestID];
int status = Editor_DeleteNodeLink(nWCSrcID, nWCDstID, false);
if (status == Editor_BadCommand)
{
DevMsg( "Worldcraft failed in PurgeDynamicLinks...\n" );
}
#endif
// Safe to remove it here as this happens only after I leave this function
UTIL_Remove(pDynamicLink);
}
// Go on to the next dynamic link
pDynamicLink = pDynamicLink->m_pNextDynamicLink;
}
}
//------------------------------------------------------------------------------
// Purpose : Returns false if the dynamic link doesn't have a corresponding
// node link
// Input :
// Output :
//------------------------------------------------------------------------------
bool CAI_DynamicLink::IsLinkValid( void )
{
CAI_Node *pNode = g_pBigAINet->GetNode(m_nSrcID);
return ( pNode->GetLink( m_nDestID ) != NULL );
}
//------------------------------------------------------------------------------
// Purpose :
//------------------------------------------------------------------------------
void CAI_DynamicLink::InputTurnOn( inputdata_t &inputdata )
{
if (m_nLinkState == LINK_OFF)
{
m_nLinkState = LINK_ON;
CAI_DynamicLink::SetLinkState();
}
}
//------------------------------------------------------------------------------
// Purpose :
//------------------------------------------------------------------------------
void CAI_DynamicLink::InputTurnOff( inputdata_t &inputdata )
{
if (m_nLinkState == LINK_ON)
{
m_nLinkState = LINK_OFF;
CAI_DynamicLink::SetLinkState();
}
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
CAI_Link *CAI_DynamicLink::FindLink()
{
CAI_Node * pSrcNode = g_pBigAINet->GetNode(m_nSrcID, false);
if ( pSrcNode )
{
int numLinks = pSrcNode->NumLinks();
for (int i=0;i<numLinks;i++)
{
CAI_Link* pLink = pSrcNode->GetLinkByIndex(i);
if (((pLink->m_iSrcID == m_nSrcID )&&
(pLink->m_iDestID == m_nDestID)) ||
((pLink->m_iSrcID == m_nDestID)&&
(pLink->m_iDestID == m_nSrcID )) )
{
return pLink;
}
}
}
return NULL;
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
int CAI_DynamicLink::ObjectCaps()
{
int caps = BaseClass::ObjectCaps();
if ( m_bNotSaved )
caps |= FCAP_DONT_SAVE;
return caps;
}
//------------------------------------------------------------------------------
// Purpose : Updates network link state if dynamic link state has changed
// Input :
// Output :
//------------------------------------------------------------------------------
void CAI_DynamicLink::SetLinkState(void)
{
if ( !gm_bInitialized )
{
// Safe to quietly return. Consistency will be enforced when InitDynamicLinks() is called
return;
}
if (m_nSrcID == NO_NODE || m_nDestID == NO_NODE)
{
Vector pos = GetAbsOrigin();
DevWarning("ERROR: Dynamic link at %f %f %f pointing to invalid node ID!!\n", pos.x, pos.y, pos.z);
return;
}
// ------------------------------------------------------------------
// Now update the node links...
// Nodes share links so we only have to find the node from the src
// For now just using one big AINetwork so find src node on that network
// ------------------------------------------------------------------
CAI_Node * pSrcNode = g_pBigAINet->GetNode(m_nSrcID, false);
if ( pSrcNode )
{
CAI_Link* pLink = FindLink();
if ( pLink )
{
pLink->m_pDynamicLink = this;
if (m_nLinkState == LINK_OFF)
{
pLink->m_LinkInfo |= bits_LINK_OFF;
}
else
{
pLink->m_LinkInfo &= ~bits_LINK_OFF;
}
}
else
{
DevMsg("Dynamic Link Error: (%s) unable to form between nodes %d and %d\n", GetDebugName(), m_nSrcID, m_nDestID );
}
}
}
//------------------------------------------------------------------------------
// Purpose : Given two node ID's return the related dynamic link if any or NULL
//
// Input :
// Output :
//------------------------------------------------------------------------------
CAI_DynamicLink* CAI_DynamicLink::GetDynamicLink(int nSrcID, int nDstID)
{
CAI_DynamicLink* pDynamicLink = CAI_DynamicLink::m_pAllDynamicLinks;
while (pDynamicLink)
{
if ((nSrcID == pDynamicLink->m_nSrcID && nDstID == pDynamicLink->m_nDestID) ||
(nSrcID == pDynamicLink->m_nDestID && nDstID == pDynamicLink->m_nSrcID ) )
{
return pDynamicLink;
}
// Go on to the next dynamic link
pDynamicLink = pDynamicLink->m_pNextDynamicLink;
}
return NULL;
}
//-----------------------------------------------------------------------------
// Purpose: Constructor
// Input :
// Output :
//-----------------------------------------------------------------------------
CAI_DynamicLink::CAI_DynamicLink(void)
{
m_bFixedUpIds = false;
m_bNotSaved = false;
m_nSrcID = NO_NODE;
m_nDestID = NO_NODE;
m_nLinkState = LINK_OFF;
m_nLinkType = bits_CAP_MOVE_GROUND;
m_bInvertAllow = false;
// -------------------------------------
// Add to linked list of dynamic links
// -------------------------------------
m_pNextDynamicLink = CAI_DynamicLink::m_pAllDynamicLinks;
CAI_DynamicLink::m_pAllDynamicLinks = this;
};
//-----------------------------------------------------------------------------
// Purpose:
// Input :
// Output :
//-----------------------------------------------------------------------------
CAI_DynamicLink::~CAI_DynamicLink(void) {
// ----------------------------------------------
// Remove from linked list of all dynamic links
// ----------------------------------------------
CAI_DynamicLink* pDynamicLink = CAI_DynamicLink::m_pAllDynamicLinks;
if (pDynamicLink == this)
{
m_pAllDynamicLinks = pDynamicLink->m_pNextDynamicLink;
}
else
{
while (pDynamicLink)
{
if (pDynamicLink->m_pNextDynamicLink == this)
{
pDynamicLink->m_pNextDynamicLink = pDynamicLink->m_pNextDynamicLink->m_pNextDynamicLink;
break;
}
pDynamicLink = pDynamicLink->m_pNextDynamicLink;
}
}
}
LINK_ENTITY_TO_CLASS(info_radial_link_controller, CAI_RadialLinkController);
BEGIN_DATADESC( CAI_RadialLinkController )
DEFINE_KEYFIELD( m_flRadius, FIELD_FLOAT, "radius" ),
DEFINE_FIELD( m_vecAtRestOrigin, FIELD_POSITION_VECTOR ),
DEFINE_FIELD( m_bAtRest, FIELD_BOOLEAN ),
DEFINE_THINKFUNC( PollMotionThink ),
END_DATADESC()
//---------------------------------------------------------
//---------------------------------------------------------
void CAI_RadialLinkController::Spawn()
{
SetSolid( SOLID_NONE );
AddEffects( EF_NODRAW );
}
//---------------------------------------------------------
//---------------------------------------------------------
void CAI_RadialLinkController::Activate()
{
BaseClass::Activate();
m_bAtRest = false;
m_vecAtRestOrigin = vec3_invalid;
// Force re-evaluation
SetThink( &CAI_RadialLinkController::PollMotionThink );
// Spread think times out.
SetNextThink( gpGlobals->curtime + random->RandomFloat( 0.0f, 1.0f) );
if( GetParent() != NULL )
{
float flDist = GetAbsOrigin().DistTo( GetParent()->GetAbsOrigin() );
if( flDist > 200.0f )
{
// Warn at the console if a link controller is far away from its parent. This
// most likely means that a level designer has copied an entity without researching its hierarchy.
DevMsg("RadialLinkController (%s) is far from its parent!\n", GetDebugName() );
}
}
}
//---------------------------------------------------------
//---------------------------------------------------------
void CAI_RadialLinkController::PollMotionThink()
{
SetNextThink( gpGlobals->curtime + 0.5f );
CBaseEntity *pParent = GetParent();
if( pParent )
{
if( pParent->VPhysicsGetObject()->IsAsleep() )
{
if( !m_bAtRest )
{
m_vecAtRestOrigin = GetAbsOrigin();
ModifyNodeLinks( true );
m_bAtRest = true;
//Msg("At Rest!\n");
}
}
else
{
if( m_bAtRest )
{
float flDist;
flDist = GetAbsOrigin().DistTo(m_vecAtRestOrigin);
if( flDist < 18.0f )
{
// Ignore movement If moved less than 18 inches from the place where we came to rest.
//Msg("Reject.\n");
return;
}
}
//Msg("Polling!\n");
if( m_vecAtRestOrigin != vec3_invalid )
{
ModifyNodeLinks( false );
m_bAtRest = false;
m_vecAtRestOrigin = vec3_invalid;
}
}
}
}
//---------------------------------------------------------
//---------------------------------------------------------
ConVar ai_radial_max_link_dist( "ai_radial_max_link_dist", "512" );
void CAI_RadialLinkController::ModifyNodeLinks( bool bMakeStale )
{
int nNodes = g_pBigAINet->NumNodes();
CAI_Node **ppNodes = g_pBigAINet->AccessNodes();
VPROF_BUDGET("ModifyLinks", "ModifyLinks");
const float MinDistCareSq = Square( ai_radial_max_link_dist.GetFloat() + 0.1 );
for ( int i = 0; i < nNodes; i++ )
{
CAI_Node *pNode = ppNodes[i];
const Vector &nodeOrigin = pNode->GetOrigin();
if ( m_vecAtRestOrigin.DistToSqr(nodeOrigin) < MinDistCareSq )
{
int nLinks = pNode->NumLinks();
for ( int j = 0; j < nLinks; j++ )
{
CAI_Link *pLink = pNode->GetLinkByIndex( j );
int iLinkDest = pLink->DestNodeID( i );
if ( iLinkDest > i )
{
bool bQualify = true;
if( ( (pLink->m_iAcceptedMoveTypes[HULL_HUMAN]||pLink->m_iAcceptedMoveTypes[HULL_WIDE_HUMAN]) & bits_CAP_MOVE_GROUND) == 0 )
{
// Micro-optimization: Ignore any connection that's not a walking connection for humans.(sjb)
bQualify = false;
}
const Vector &originOther = ppNodes[iLinkDest]->GetOrigin();
if ( bQualify && m_vecAtRestOrigin.DistToSqr(originOther) < MinDistCareSq )
{
if ( IsRayIntersectingSphere(nodeOrigin, originOther - nodeOrigin, m_vecAtRestOrigin, m_flRadius) )
{
if( bMakeStale )
{
pLink->m_LinkInfo |= bits_LINK_STALE_SUGGESTED;
pLink->m_timeStaleExpires = FLT_MAX;
}
else
{
pLink->m_LinkInfo &= ~bits_LINK_STALE_SUGGESTED;
}
}
}
}
}
}
}
}