//-----------------------------------------------------------------------------
// Purpose:
// Input : origin -
// radius -
// list -
//-----------------------------------------------------------------------------
void CFuncLadder::FindNearbyDismountPoints( const Vector& origin, float radius, CUtlVector< CInfoLadderDismountHandle >& list )
{
#if !defined( CLIENT_DLL )
CBaseEntity *pEntity = NULL;
while ( (pEntity = gEntList.FindEntityByClassnameWithin( pEntity, "info_ladder_dismount", origin, radius)) != NULL )
{
CInfoLadderDismount *landingspot = static_cast< CInfoLadderDismount * >( pEntity );
Assert( landingspot );
// If spot has a target, then if the target is not this ladder, don't add to our list.
if ( landingspot->m_target != NULL_STRING )
{
if ( landingspot->GetNextTarget() != this )
{
continue;
}
}
CInfoLadderDismountHandle handle;
handle = landingspot;
if ( list.Find( handle ) == list.InvalidIndex() )
{
list.AddToTail( handle );
}
}
#endif
}
//------------------------------------------------------------------------------
// Purpose:
//------------------------------------------------------------------------------
void CPointPlayerMoveConstraint::InputTurnOn( inputdata_t &inputdata )
{
// Find all players within our radius and constraint them
float flRadius = m_flRadius;
// If we're in singleplayer, blow the radius a bunch
if ( gpGlobals->maxClients == 1 )
{
flRadius = MAX_COORD_RANGE;
}
CBaseEntity *pEntity = NULL;
while ( (pEntity = gEntList.FindEntityByClassnameWithin( pEntity, "player", GetLocalOrigin(), flRadius)) != NULL )
{
CBasePlayer *pPlayer = ToBasePlayer( pEntity );
Assert( pPlayer );
// Only add him if he's not already constrained
if ( m_hConstrainedPlayers.Find( pPlayer ) == m_hConstrainedPlayers.InvalidIndex() )
{
m_hConstrainedPlayers.AddToTail( pPlayer );
pPlayer->ActivateMovementConstraint( this, GetAbsOrigin(), m_flRadius, m_flConstraintWidth, m_flSpeedFactor );
}
}
// Only think if we found any
if ( m_hConstrainedPlayers.Count() )
{
SetThink( &CPointPlayerMoveConstraint::ConstraintThink );
SetNextThink( gpGlobals->curtime + 0.1f );
}
}
void CBuildModeDialogMgr::Add( BuildModeDialog *pDlg )
{
if ( m_vecBuildDialogs.Find( pDlg ) == m_vecBuildDialogs.InvalidIndex() )
{
m_vecBuildDialogs.AddToTail( pDlg );
}
}
void CClientLeafSystem::RemoveRenderable( ClientRenderHandle_t handle )
{
// This can happen upon level shutdown
if (!m_Renderables.IsValidIndex(handle))
return;
// Reset the render handle in the entity.
IClientRenderable *pRenderable = m_Renderables[handle].m_pRenderable;
Assert( handle == pRenderable->RenderHandle() );
pRenderable->RenderHandle() = INVALID_CLIENT_RENDER_HANDLE;
// Reemove the renderable from the dirty list
if ( m_Renderables[handle].m_Flags & RENDER_FLAGS_HASCHANGED )
{
// NOTE: This isn't particularly fast (linear search),
// but I'm assuming it's an unusual case where we remove
// renderables that are changing or that m_DirtyRenderables usually
// only has a couple entries
int i = m_DirtyRenderables.Find( handle );
Assert( i != m_DirtyRenderables.InvalidIndex() );
m_DirtyRenderables.FastRemove( i );
}
if ( IsViewModelRenderGroup( (RenderGroup_t)m_Renderables[handle].m_RenderGroup ) )
{
RemoveFromViewModelList( handle );
}
RemoveFromTree( handle );
m_Renderables.Remove( handle );
}
//-----------------------------------------------------------------------------
// Purpose: Checks to see if a weapon is already known
// Input : *pWeapon - weapon to check for
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CTriggerWeaponDissolve::HasWeapon( CBaseCombatWeapon *pWeapon )
{
if ( m_pWeapons.Find( pWeapon ) == m_pWeapons.InvalidIndex() )
return false;
return true;
}
//-----------------------------------------------------------------------------
// Purpose: If we've got a speaker, add ourselves to the list of microphones that want to listen
//-----------------------------------------------------------------------------
void CEnvMicrophone::ActivateSpeaker( void )
{
// If we're enabled, set the dsp_speaker preset to my specified one
if ( !m_bDisabled )
{
ConVarRef dsp_speaker( "dsp_speaker" );
if ( dsp_speaker.IsValid() )
{
int iDSPPreset = m_iSpeakerDSPPreset;
if ( !iDSPPreset )
{
// Reset it to the default
iDSPPreset = atoi( dsp_speaker.GetDefault() );
}
DevMsg( 2, "Microphone %s set dsp_speaker to %d.\n", STRING(GetEntityName()), iDSPPreset);
dsp_speaker.SetValue( m_iSpeakerDSPPreset );
}
}
if ( m_iszSpeakerName != NULL_STRING )
{
// We've got a speaker to play heard sounds through. To do this, we need to add ourselves
// to the list of microphones who want to be told whenever a sound is played.
if ( s_Microphones.Find(this) == -1 )
{
s_Microphones.AddToTail( this );
}
}
}
//-----------------------------------------------------------------------------
// Purpose: Static method
// Input : *event -
// soundlist -
//-----------------------------------------------------------------------------
void CSceneCache::PrecacheSceneEvent( CChoreoEvent *event, CUtlVector< unsigned short >& soundlist )
{
if ( !event || event->GetType() != CChoreoEvent::SPEAK )
return;
int idx = soundemitterbase->GetSoundIndex( event->GetParameters() );
if ( idx != -1 )
{
MEM_ALLOC_CREDIT();
Assert( idx <= 65535 );
soundlist.AddToTail( (unsigned short)idx );
}
if ( event->GetCloseCaptionType() == CChoreoEvent::CC_MASTER )
{
char tok[ CChoreoEvent::MAX_CCTOKEN_STRING ];
if ( event->GetPlaybackCloseCaptionToken( tok, sizeof( tok ) ) )
{
int idx = soundemitterbase->GetSoundIndex( tok );
if ( idx != -1 && soundlist.Find( idx ) == soundlist.InvalidIndex() )
{
MEM_ALLOC_CREDIT();
Assert( idx <= 65535 );
soundlist.AddToTail( (unsigned short)idx );
}
}
}
}
void Spawn( void )
{
// add this element if it isn't already in the list
if ( g_CaptureZones.Find( entindex() ) == -1 )
{
g_CaptureZones.AddToTail( entindex() );
}
}
void CBullseyeList::RemoveFromList( CNPC_Bullseye *pBullseye )
{
int index = m_list.Find( pBullseye );
if ( index != m_list.InvalidIndex() )
{
m_list.FastRemove( index );
}
}
void CSecobModportal1List::RemoveFromList( CNPC_SecobModportal1 *pSecobModportal1 )
{
int index = m_list.Find( pSecobModportal1 );
if ( index != m_list.InvalidIndex() )
{
m_list.FastRemove( index );
}
}
static bool FindAndRemoveExecutionMarker( int iCode )
{
int i = g_ExecutionMarkers.Find( iCode );
if ( i == g_ExecutionMarkers.InvalidIndex() )
return false;
g_ExecutionMarkers.Remove( i );
return true;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void C_TeamTrainWatcher::Spawn( void )
{
BaseClass::Spawn();
if ( g_hTrainWatchers.Find( this ) == g_hTrainWatchers.InvalidIndex() )
{
g_hTrainWatchers.AddToTail( this );
}
}
static int CC_asw_teleport_autocomplete( char const *partial, char commands[ COMMAND_COMPLETION_MAXITEMS ][ COMMAND_COMPLETION_ITEM_LENGTH ] )
{
if ( !g_pGameRules )
{
return 0;
}
char const *cmdname = "asw_teleport";
char *substring = (char *)partial;
if ( Q_strstr( partial, cmdname ) )
{
substring = (char *)partial + strlen( cmdname ) + 1;
}
int checklen = Q_strlen( substring );
CUtlSymbolTable entries( 0, 0, true );
CUtlVector< CUtlSymbol > symbols;
CBaseEntity *pos = NULL;
while ( ( pos = gEntList.NextEnt( pos ) ) != NULL )
{
// Check target name against partial string
if ( pos->GetEntityName() == NULL_STRING )
continue;
if ( Q_strnicmp( STRING( pos->GetEntityName() ), substring, checklen ) )
continue;
CUtlSymbol sym = entries.AddString( STRING( pos->GetEntityName() ) );
int idx = symbols.Find( sym );
if ( idx == symbols.InvalidIndex() )
{
symbols.AddToTail( sym );
}
// Too many
if ( symbols.Count() >= COMMAND_COMPLETION_MAXITEMS )
break;
}
// Now fill in the results
for ( int i = 0; i < symbols.Count(); i++ )
{
char const *name = entries.String( symbols[ i ] );
char buf[ 512 ];
Q_strncpy( buf, name, sizeof( buf ) );
Q_strlower( buf );
Q_snprintf( commands[ i ], COMMAND_COMPLETION_ITEM_LENGTH, "%s %s",
cmdname, buf );
}
return symbols.Count();
}
ClientCCHandle_t CColorCorrectionMgr::AddColorCorrectionVolume( C_ColorCorrectionVolume *pVolume, const char *pName, const char *pFileName )
{
ClientCCHandle_t h = AddColorCorrection(pName, pFileName);
if ( h != INVALID_CLIENT_CCHANDLE )
{
Assert(g_ColorCorrectionVolumeList.Find(pVolume) == -1);
g_ColorCorrectionVolumeList.AddToTail(pVolume);
}
return h;
}
// If the table's ID is -1, writes its info into the buffer and increments curID.
void DataTable_MaybeCreateReceiveTable( CUtlVector< SendTable * >& visited, SendTable *pTable, bool bNeedDecoder )
{
// Already sent?
if ( visited.Find( pTable ) != visited.InvalidIndex() )
return;
visited.AddToTail( pTable );
DataTable_SetupReceiveTableFromSendTable( pTable, bNeedDecoder );
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CNPC_EnemyFinderCombineCannon::UpdateOnRemove()
{
BaseClass::UpdateOnRemove();
// See if I'm in the list of Combine enemyfinders
int index = s_ListEnemyfinders.Find(this);
if( index != -1 )
{
s_ListEnemyfinders.Remove(index);
}
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CNPC_EnemyFinderCombineCannon::Activate()
{
BaseClass::Activate();
// See if I'm in the list of Combine enemyfinders
// If not, add me.
if( s_ListEnemyfinders.Find(this) == -1 )
{
s_ListEnemyfinders.AddToTail(this);
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTriggerPortal::DisableForIncomingEntity( CBaseEntity *pEntity )
{
EHANDLE hHandle;
hHandle = pEntity;
Assert( m_hDisabledForEntities.Find(hHandle) == m_hDisabledForEntities.InvalidIndex() );
m_hDisabledForEntities.AddToTail( hHandle );
// Start thinking, and remove the other as soon as it's not touching me.
// Needs to be done in addition to EndTouch, because entities may move fast
// enough through the portal to come out not touching the other portal.
SetContextThink( &CTriggerPortal::DisabledThink, gpGlobals->curtime + 0.1, TRIGGER_DISABLED_THINK );
}
//-----------------------------------------------------------------------------
// Purpose: Static method
// Input : sounds -
// *soundname -
//-----------------------------------------------------------------------------
void CModelSoundsCache::FindOrAddScriptSound( CUtlVector< unsigned short >& sounds, char const *soundname )
{
int soundindex = soundemitterbase->GetSoundIndex( soundname );
if ( soundindex != -1 )
{
// Only add it once per model...
if ( sounds.Find( soundindex ) == sounds.InvalidIndex() )
{
MEM_ALLOC_CREDIT();
sounds.AddToTail( soundindex );
}
}
}
void CPhysicsMotionController::RemoveCore( IVP_Core *pCore )
{
int index = m_coreList.Find(pCore);
if ( !m_coreList.IsValidIndex(index) )
{
#if DEBUG
Msg("removed invalid core !!!\n");
#endif
return;
}
m_coreList.Remove( index );
pCore->rem_core_controller( static_cast<IVP_Controller_Independent *>(this) );
}
void C_PlantedC4::SetDormant( bool bDormant )
{
BaseClass::SetDormant( bDormant );
// Remove us from the list of planted C4s.
if ( bDormant )
{
g_PlantedC4s.FindAndRemove( this );
}
else
{
if ( g_PlantedC4s.Find( this ) == -1 )
g_PlantedC4s.AddToTail( this );
}
}
//-----------------------------------------------------------------------------
// Helper for crawling events to determine sounds
//-----------------------------------------------------------------------------
void FindSoundsInEvent( CChoreoEvent *pEvent, CUtlVector< short >& soundList )
{
if ( !pEvent || pEvent->GetType() != CChoreoEvent::SPEAK )
return;
unsigned short stringId = g_ChoreoStringPool.FindOrAddString( pEvent->GetParameters() );
if ( soundList.Find( stringId ) == soundList.InvalidIndex() )
{
soundList.AddToTail( stringId );
}
if ( pEvent->GetCloseCaptionType() == CChoreoEvent::CC_MASTER )
{
char tok[ CChoreoEvent::MAX_CCTOKEN_STRING ];
if ( pEvent->GetPlaybackCloseCaptionToken( tok, sizeof( tok ) ) )
{
stringId = g_ChoreoStringPool.FindOrAddString( tok );
if ( soundList.Find( stringId ) == soundList.InvalidIndex() )
{
soundList.AddToTail( stringId );
}
}
}
}
bool CASW_Location_Group::IsGroupLocked( CUtlVector<int> &completedMissions )
{
if ( asw_unlock_all_locations.GetBool() )
return false;
if ( m_UnlockedBy.Count() <= 0 )
return false;
for ( int i = 0; i < m_UnlockedBy.Count(); i++ )
{
if ( completedMissions.Find( m_UnlockedBy[i] ) != completedMissions.InvalidIndex() ) // this mission has been completed, so it won't make this group locked
continue;
// one of our required missions is incomplete, so this group is locked
return true;
}
return false;
}
void CLuaInterface_Hooks::ErrorFromLua_H( const char *err, ... )
{
ILuaInterface *luaInterface = (ILuaInterface *)this;
// Construct error string
char szBuf[512];
va_list arg_ptr;
va_start( arg_ptr, err );
_vsntprintf( szBuf, sizeof(szBuf)-1, (char *)err, arg_ptr );
va_end( arg_ptr );
// Only call hook if the state has the module loaded
if ( g_LuaInterfaces.Find( luaInterface ) == -1 )
{
(this->*ErrorFromLua_T)( szBuf );
return;
}
// Call LuaError hook
ILuaObject *hookTable = luaInterface->GetGlobal( "hook" );
ILuaObject *hookCallFunction = hookTable->GetMember( "Call" );
hookCallFunction->Push();
luaInterface->Push( "LuaError" );
luaInterface->PushNil();
luaInterface->Push( szBuf );
luaInterface->Call( 3, 1 );
hookTable->UnReference();
hookCallFunction->UnReference();
// Check return value
ILuaObject *returnValue = luaInterface->GetReturn( 0 );
// Call original if nothing is returned
if ( returnValue->isNil() )
(this->*ErrorFromLua_T)( szBuf );
returnValue->UnReference();
}
//-----------------------------------------------------------------------------
// Call this when the renderable moves
//-----------------------------------------------------------------------------
void CClientLeafSystem::RenderableChanged( ClientRenderHandle_t handle )
{
Assert ( handle != INVALID_CLIENT_RENDER_HANDLE );
Assert( m_Renderables.IsValidIndex( handle ) );
if ( !m_Renderables.IsValidIndex( handle ) )
return;
if ( (m_Renderables[handle].m_Flags & RENDER_FLAGS_HASCHANGED ) == 0 )
{
m_Renderables[handle].m_Flags |= RENDER_FLAGS_HASCHANGED;
m_DirtyRenderables.AddToTail( handle );
}
#if _DEBUG
else
{
// It had better be in the list
Assert( m_DirtyRenderables.Find( handle ) != m_DirtyRenderables.InvalidIndex() );
}
#endif
}
void CPhysicsMotionController::AttachObject( IPhysicsObject *pObject )
{
Assert(pObject);
// BUGBUG: Sometimes restore comes back with a NULL, REVISIT
if ( !pObject || pObject->IsStatic() )
return;
CPhysicsObject *pPhys = static_cast<CPhysicsObject *>(pObject);
IVP_Real_Object *pIVP = pPhys->GetObject();
IVP_Core *pCore = pIVP->get_core();
#if DEBUG
int index = m_coreList.Find(pCore);
if ( m_coreList.IsValidIndex(index) )
{
Msg("Attached core twice!!!\n");
return;
}
#endif
m_coreList.AddToTail( pCore );
pCore->add_core_controller( (IVP_Controller *)this );
}
//-----------------------------------------------------------------------------
// Display portal error
//-----------------------------------------------------------------------------
static void DisplayPortalError( portal_t *p, int viscontents )
{
char contents[3][1024];
PrintBrushContentsToString( p->nodes[0]->contents, contents[0], sizeof( contents[0] ) );
PrintBrushContentsToString( p->nodes[1]->contents, contents[1], sizeof( contents[1] ) );
PrintBrushContentsToString( viscontents, contents[2], sizeof( contents[2] ) );
Vector center;
WindingCenter( p->winding, center );
Warning( "\nFindPortalSide: Couldn't find a good match for which brush to assign to a portal near (%.1f %.1f %.1f)\n", center.x, center.y, center.z);
Warning( "Leaf 0 contents: %s\n", contents[0] );
Warning( "Leaf 1 contents: %s\n", contents[1] );
Warning( "viscontents (node 0 contents ^ node 1 contents): %s\n", contents[2] );
Warning( "This means that none of the brushes in leaf 0 or 1 that touches the portal has %s\n", contents[2] );
Warning( "Check for a huge brush enclosing the coordinates above that has contents %s\n", contents[2] );
Warning( "Candidate brush IDs: " );
CUtlVector<int> listed;
for (int j=0 ; j<2 ; j++)
{
node_t *n = p->nodes[j];
for (bspbrush_t *bb=n->brushlist ; bb ; bb=bb->next)
{
mapbrush_t *brush = bb->original;
if ( brush->contents & viscontents )
{
if ( listed.Find( brush->brushnum ) == -1 )
{
listed.AddToTail( brush->brushnum );
Warning( "Brush %d: ", brush->id );
}
}
}
}
Warning( "\n\n" );
}
//-----------------------------------------------------------------------------
// Reload particle definitions
//-----------------------------------------------------------------------------
void CClientTools::ReloadParticleDefintions( const char *pFileName, const void *pBufData, int nLen )
{
MDLCACHE_CRITICAL_SECTION(); // Copying particle attachment control points may end up needing to evaluate skeletons
//////////////
// Find any systems that depend on any system in the buffer
// slow, but necessary if we want live reloads to work - and doesn't happen too often
CUtlVector<CUtlString> systemNamesToReload;
g_pParticleSystemMgr->GetParticleSystemsInBuffer( CUtlBuffer(pBufData, nLen, CUtlBuffer::READ_ONLY), &systemNamesToReload );
CUtlVector<CNewParticleEffect*> toReplaceEffects;
CUtlVector<CUtlString> toReplaceNames;
for( CNewParticleEffect *pEffect = ParticleMgr()->FirstNewEffect(); pEffect; pEffect = ParticleMgr()->NextNewEffect(pEffect) )
{
for( int i = 0; i < systemNamesToReload.Count(); ++i )
{
if ( pEffect->DependsOnSystem( systemNamesToReload[i] ) )
{
// only reload a given effect once
if ( -1 == toReplaceEffects.Find(pEffect) )
{
toReplaceNames.AddToTail( pEffect->GetName() );
toReplaceEffects.AddToTail( pEffect );
}
}
}
}
CUtlVector<CNonDrawingParticleSystem*> toReplaceEffectsNonDrawing;
CUtlVector<CUtlString> toReplaceNamesNonDrawing;
for( CNonDrawingParticleSystem *i = ParticleMgr()->m_NonDrawingParticleSystems.Head(); i ; i = i->m_pNext )
{
for( int j = 0; j < systemNamesToReload.Count(); ++j )
{
if ( i->Get()->DependsOnSystem( systemNamesToReload[j] ) )
{
if ( -1 == toReplaceEffectsNonDrawing.Find( i ) )
{
toReplaceNamesNonDrawing.AddToTail( i->Get()->GetName() );
toReplaceEffectsNonDrawing.AddToTail( i );
}
}
}
}
//////////////
// Load the data and stomp the old definitions
g_pParticleSystemMgr->ReadParticleConfigFile( CUtlBuffer(pBufData, nLen, CUtlBuffer::READ_ONLY), true );
//////////////
// Now replace all of the systems with their new versions
Assert( toReplaceEffects.Count() == toReplaceNames.Count() );
for( int i = 0; i < toReplaceNames.Count(); ++i )
{
CNewParticleEffect *pEffect = toReplaceEffects[i];
pEffect->ReplaceWith( toReplaceNames[i] );
}
// update all the non-drawings ones
for( int i = 0; i < toReplaceNamesNonDrawing.Count(); i++ )
{
CNonDrawingParticleSystem *pEffect = toReplaceEffectsNonDrawing[i];
delete pEffect->m_pSystem;
pEffect->m_pSystem = g_pParticleSystemMgr->CreateParticleCollection( toReplaceNamesNonDrawing[i] );
}
}
//-----------------------------------------------------------------------------
// Invokes methods on all installed game systems
//-----------------------------------------------------------------------------
bool IGameSystem::InitAllSystems()
{
int i;
{
// first add any auto systems to the end
CAutoGameSystem *pSystem = s_pSystemList;
while ( pSystem )
{
if ( s_GameSystems.Find( pSystem ) == s_GameSystems.InvalidIndex() )
{
Add( pSystem );
}
else
{
DevWarning( 1, "AutoGameSystem already added to game system list!!!\n" );
}
pSystem = pSystem->m_pNext;
}
s_pSystemList = NULL;
}
{
CAutoGameSystemPerFrame *pSystem = s_pPerFrameSystemList;
while ( pSystem )
{
if ( s_GameSystems.Find( pSystem ) == s_GameSystems.InvalidIndex() )
{
Add( pSystem );
}
else
{
DevWarning( 1, "AutoGameSystem already added to game system list!!!\n" );
}
pSystem = pSystem->m_pNext;
}
s_pSystemList = NULL;
}
// Now remember that we are initted so new CAutoGameSystems will add themselves automatically.
s_bSystemsInitted = true;
for ( i = 0; i < s_GameSystems.Count(); ++i )
{
MDLCACHE_CRITICAL_SECTION();
IGameSystem *sys = s_GameSystems[i];
#if defined( _X360 )
char sz[128];
Q_snprintf( sz, sizeof( sz ), "%s->Init():Start", sys->Name() );
XBX_rTimeStampLog( Plat_FloatTime(), sz );
#endif
bool valid = sys->Init();
#if defined( _X360 )
Q_snprintf( sz, sizeof( sz ), "%s->Init():Finish", sys->Name() );
XBX_rTimeStampLog( Plat_FloatTime(), sz );
#endif
if ( !valid )
return false;
}
return true;
}
//-----------------------------------------------------------------------------
// Purpose: Upon touching a non-filtered entity, CTriggerPortal teleports them to it's
// remote portal location.
// Input : *pOther -
//-----------------------------------------------------------------------------
void CTriggerPortal::Touch( CBaseEntity *pOther )
{
// If we are enabled, and allowed to react to the touched entity
if ( PassesTriggerFilters(pOther) )
{
// If we somehow lost our pointer to the remote portal, get a new one
if ( m_hRemotePortal == NULL )
{
Disable();
return;
}
bool bDebug = portal_debug.GetBool();
if ( bDebug )
{
Msg("%s TOUCH: for %s\n", GetDebugName(), pOther->GetDebugName() );
}
// Don't touch entities that came through us and haven't left us yet.
EHANDLE hHandle;
hHandle = pOther;
if ( m_hDisabledForEntities.Find(hHandle) != m_hDisabledForEntities.InvalidIndex() )
{
Msg(" IGNORED\n", GetDebugName(), pOther->GetDebugName() );
return;
}
Pickup_ForcePlayerToDropThisObject( pOther );
// de-ground this entity
pOther->SetGroundEntity( NULL );
// Build a this --> remote transformation
VMatrix matMyModelToWorld, matMyInverse;
matMyModelToWorld = this->EntityToWorldTransform();
MatrixInverseGeneral ( matMyModelToWorld, matMyInverse );
// Teleport our object
VMatrix matRemotePortalTransform = m_hRemotePortal->EntityToWorldTransform();
Vector ptNewOrigin, vLook, vRight, vUp, vNewLook;
pOther->GetVectors( &vLook, &vRight, &vUp );
// Move origin
ptNewOrigin = matMyInverse * pOther->GetAbsOrigin();
ptNewOrigin = matRemotePortalTransform * Vector( ptNewOrigin.x, -ptNewOrigin.y, ptNewOrigin.z );
// Re-aim camera
vNewLook = matMyInverse.ApplyRotation( vLook );
vNewLook = matRemotePortalTransform.ApplyRotation( Vector( -vNewLook.x, -vNewLook.y, vNewLook.z ) );
// Reorient the physics
Vector vVelocity, vOldVelocity;
pOther->GetVelocity( &vOldVelocity );
vVelocity = matMyInverse.ApplyRotation( vOldVelocity );
vVelocity = matRemotePortalTransform.ApplyRotation( Vector( -vVelocity.x, -vVelocity.y, vVelocity.z ) );
QAngle qNewAngles;
VectorAngles( vNewLook, qNewAngles );
if ( pOther->IsPlayer() )
{
((CBasePlayer*)pOther)->SnapEyeAngles(qNewAngles);
}
Vector vecOldPos = pOther->WorldSpaceCenter();
if ( bDebug )
{
NDebugOverlay::Box( pOther->GetAbsOrigin(), pOther->WorldAlignMins(), pOther->WorldAlignMaxs(), 255,0,0, 8, 20 );
NDebugOverlay::Axis( pOther->GetAbsOrigin(), pOther->GetAbsAngles(), 10.0f, true, 50 );
}
// place player at the new destination
CTriggerPortal *pPortal = m_hRemotePortal.Get();
pPortal->DisableForIncomingEntity( pOther );
pOther->Teleport( &ptNewOrigin, &qNewAngles, &vVelocity );
if ( bDebug )
{
NDebugOverlay::Box( pOther->GetAbsOrigin(), pOther->WorldAlignMins(), pOther->WorldAlignMaxs(), 0,255,0, 8, 20 );
NDebugOverlay::Line( vecOldPos, pOther->WorldSpaceCenter(), 0,255,0, true, 20 );
NDebugOverlay::Axis( pOther->GetAbsOrigin(), pOther->GetAbsAngles(), 10.0f, true, 50 );
Msg("%s TELEPORTED: %s\n", GetDebugName(), pOther->GetDebugName() );
}
// test collision on the new teleport location
Vector vMin, vMax, vCenter;
pOther->CollisionProp()->WorldSpaceAABB( &vMin, &vMax );
vCenter = (vMin + vMax) * 0.5f;
vMin -= vCenter;
vMax -= vCenter;
Vector vStart, vEnd;
vStart = ptNewOrigin;
vEnd = ptNewOrigin;
Ray_t ray;
ray.Init( vStart, vEnd, vMin, vMax );
trace_t tr;
pPortal->TestCollision( ray, pOther->PhysicsSolidMaskForEntity(), tr );
// Teleportation caused us to hit something, deal with it.
if ( tr.DidHit() )
{
}
}
}
