void CRagdollLRURetirement::Update( float frametime ) // EPISODIC VERSION
{
VPROF( "CRagdollLRURetirement::Update" );
// Compress out dead items
int i, next;
int iMaxRagdollCount = m_iMaxRagdolls;
if ( iMaxRagdollCount == -1 )
{
iMaxRagdollCount = g_ragdoll_maxcount.GetInt();
}
// fade them all for the low violence version
if ( g_RagdollLVManager.IsLowViolence() )
{
iMaxRagdollCount = 0;
}
m_iRagdollCount = 0;
m_iSimulatedRagdollCount = 0;
// First, find ragdolls that are good candidates for deletion because they are not
// visible at all, or are in a culled visibility box
for ( i = m_LRU.Head(); i < m_LRU.InvalidIndex(); i = next )
{
next = m_LRU.Next(i);
CBaseAnimating *pRagdoll = m_LRU[i].Get();
if ( pRagdoll )
{
m_iRagdollCount++;
IPhysicsObject *pObject = pRagdoll->VPhysicsGetObject();
if (pObject && !pObject->IsAsleep())
{
m_iSimulatedRagdollCount++;
}
if ( m_LRU.Count() > iMaxRagdollCount )
{
//Found one, we're done.
if ( ShouldRemoveThisRagdoll( pRagdoll ) == true )
{
#ifdef CLIENT_DLL
pRagdoll->SUB_Remove();
#else
pRagdoll->SUB_StartFadeOut( 0 );
#endif
m_LRU.Remove(i);
return;
}
}
}
else
{
m_LRU.Remove(i);
}
}
//////////////////////////////
/// EPISODIC ALGORITHM ///
//////////////////////////////
// If we get here, it means we couldn't find a suitable ragdoll to remove,
// so just remove the furthest one.
int furthestOne = m_LRU.Head();
float furthestDistSq = 0;
#ifdef CLIENT_DLL
ACTIVE_SPLITSCREEN_PLAYER_GUARD( 0 );
C_BasePlayer *pPlayer = C_BasePlayer::GetLocalPlayer();
#else
CBasePlayer *pPlayer = g_pGameRules->IsMultiplayer() ? NULL : UTIL_GetLocalPlayer();
#endif
if (pPlayer && m_LRU.Count() > iMaxRagdollCount) // find the furthest one algorithm
{
Vector PlayerOrigin = pPlayer->GetAbsOrigin();
// const CBasePlayer *pPlayer = UTIL_GetLocalPlayer();
for ( i = m_LRU.Head(); i < m_LRU.InvalidIndex(); i = next )
{
CBaseAnimating *pRagdoll = m_LRU[i].Get();
next = m_LRU.Next(i);
IPhysicsObject *pObject = pRagdoll->VPhysicsGetObject();
if ( pRagdoll && (pRagdoll->GetEffectEntity() || ( pObject && !pObject->IsAsleep()) ) )
continue;
if ( pRagdoll )
{
// float distToPlayer = (pPlayer->GetAbsOrigin() - pRagdoll->GetAbsOrigin()).LengthSqr();
float distToPlayer = (PlayerOrigin - pRagdoll->GetAbsOrigin()).LengthSqr();
if (distToPlayer > furthestDistSq)
{
furthestOne = i;
furthestDistSq = distToPlayer;
}
}
else // delete bad rags first.
{
furthestOne = i;
break;
}
}
CBaseAnimating *pRemoveRagdoll = m_LRU[ furthestOne ].Get();
#ifdef CLIENT_DLL
pRemoveRagdoll->SUB_Remove();
#else
pRemoveRagdoll->SUB_StartFadeOut( 0 );
#endif
}
else // fall back on old-style pick the oldest one algorithm
{
for ( i = m_LRU.Head(); i < m_LRU.InvalidIndex(); i = next )
{
if ( m_LRU.Count() <= iMaxRagdollCount )
break;
next = m_LRU.Next(i);
CBaseAnimating *pRagdoll = m_LRU[i].Get();
//Just ignore it until we're done burning/dissolving.
IPhysicsObject *pObject = pRagdoll->VPhysicsGetObject();
if ( pRagdoll && (pRagdoll->GetEffectEntity() || ( pObject && !pObject->IsAsleep()) ) )
continue;
#ifdef CLIENT_DLL
pRagdoll->SUB_Remove();
#else
pRagdoll->SUB_StartFadeOut( 0 );
#endif
m_LRU.Remove(i);
}
}
}
void CRagdollLRURetirement::Update( float frametime ) // Non-episodic version
{
VPROF( "CRagdollLRURetirement::Update" );
// Compress out dead items
int i, next;
int iMaxRagdollCount = m_iMaxRagdolls;
if ( iMaxRagdollCount == -1 )
{
iMaxRagdollCount = g_ragdoll_maxcount.GetInt();
}
// fade them all for the low violence version
if ( g_RagdollLVManager.IsLowViolence() )
{
iMaxRagdollCount = 0;
}
m_iRagdollCount = 0;
m_iSimulatedRagdollCount = 0;
// remove ragdolls with a forced retire time
for ( i = m_LRU.Head(); i < m_LRU.InvalidIndex(); i = next )
{
next = m_LRU.Next(i);
CBaseAnimating *pRagdoll = m_LRU[i].Get();
//Just ignore it until we're done burning/dissolving.
if ( pRagdoll && pRagdoll->GetEffectEntity() )
continue;
// ignore if it's not time to force retire this ragdoll
if ( m_LRU[i].GetForcedRetireTime() == 0.0f || gpGlobals->curtime < m_LRU[i].GetForcedRetireTime() )
continue;
//Msg(" Removing ragdoll %s due to forced retire time of %f (now = %f)\n", pRagdoll->GetModelName(), m_LRU[i].GetForcedRetireTime(), gpGlobals->curtime );
#ifdef CLIENT_DLL
pRagdoll->SUB_Remove();
#else
pRagdoll->SUB_StartFadeOut( 0 );
#endif
m_LRU.Remove(i);
}
for ( i = m_LRU.Head(); i < m_LRU.InvalidIndex(); i = next )
{
next = m_LRU.Next(i);
CBaseAnimating *pRagdoll = m_LRU[i].Get();
if ( pRagdoll )
{
m_iRagdollCount++;
IPhysicsObject *pObject = pRagdoll->VPhysicsGetObject();
if (pObject && !pObject->IsAsleep())
{
m_iSimulatedRagdollCount++;
}
if ( m_LRU.Count() > iMaxRagdollCount )
{
//Found one, we're done.
if ( ShouldRemoveThisRagdoll( pRagdoll ) == true )
{
#ifdef CLIENT_DLL
pRagdoll->SUB_Remove();
#else
pRagdoll->SUB_StartFadeOut( 0 );
#endif
m_LRU.Remove(i);
return;
}
}
}
else
{
m_LRU.Remove(i);
}
}
//////////////////////////////
/// ORIGINAL ALGORITHM ///
//////////////////////////////
// not episodic -- this is the original mechanism
for ( i = m_LRU.Head(); i < m_LRU.InvalidIndex(); i = next )
{
if ( m_LRU.Count() <= iMaxRagdollCount )
break;
next = m_LRU.Next(i);
CBaseAnimating *pRagdoll = m_LRU[i].Get();
//Just ignore it until we're done burning/dissolving.
if ( pRagdoll && pRagdoll->GetEffectEntity() )
continue;
#ifdef CLIENT_DLL
pRagdoll->SUB_Remove();
#else
pRagdoll->SUB_StartFadeOut( 0 );
#endif
m_LRU.Remove(i);
}
}
//-----------------------------------------------------------------------------
// This is called by the base object when it's time to spawn the control panels
//-----------------------------------------------------------------------------
void CBaseViewModel::SpawnControlPanels()
{
#if defined( VGUI_CONTROL_PANELS )
char buf[64];
// Destroy existing panels
DestroyControlPanels();
CBaseCombatWeapon *weapon = m_hWeapon.Get();
if ( weapon == NULL )
{
return;
}
MDLCACHE_CRITICAL_SECTION();
// FIXME: Deal with dynamically resizing control panels?
// If we're attached to an entity, spawn control panels on it instead of use
CBaseAnimating *pEntityToSpawnOn = this;
char *pOrgLL = "controlpanel%d_ll";
char *pOrgUR = "controlpanel%d_ur";
char *pAttachmentNameLL = pOrgLL;
char *pAttachmentNameUR = pOrgUR;
/*
if ( IsBuiltOnAttachment() )
{
pEntityToSpawnOn = dynamic_cast<CBaseAnimating*>((CBaseEntity*)m_hBuiltOnEntity.Get());
if ( pEntityToSpawnOn )
{
char sBuildPointLL[64];
char sBuildPointUR[64];
Q_snprintf( sBuildPointLL, sizeof( sBuildPointLL ), "bp%d_controlpanel%%d_ll", m_iBuiltOnPoint );
Q_snprintf( sBuildPointUR, sizeof( sBuildPointUR ), "bp%d_controlpanel%%d_ur", m_iBuiltOnPoint );
pAttachmentNameLL = sBuildPointLL;
pAttachmentNameUR = sBuildPointUR;
}
else
{
pEntityToSpawnOn = this;
}
}
*/
Assert( pEntityToSpawnOn );
// Lookup the attachment point...
int nPanel;
for ( nPanel = 0; true; ++nPanel )
{
Q_snprintf( buf, sizeof( buf ), pAttachmentNameLL, nPanel );
int nLLAttachmentIndex = pEntityToSpawnOn->LookupAttachment(buf);
if (nLLAttachmentIndex <= 0)
{
// Try and use my panels then
pEntityToSpawnOn = this;
Q_snprintf( buf, sizeof( buf ), pOrgLL, nPanel );
nLLAttachmentIndex = pEntityToSpawnOn->LookupAttachment(buf);
if (nLLAttachmentIndex <= 0)
return;
}
Q_snprintf( buf, sizeof( buf ), pAttachmentNameUR, nPanel );
int nURAttachmentIndex = pEntityToSpawnOn->LookupAttachment(buf);
if (nURAttachmentIndex <= 0)
{
// Try and use my panels then
Q_snprintf( buf, sizeof( buf ), pOrgUR, nPanel );
nURAttachmentIndex = pEntityToSpawnOn->LookupAttachment(buf);
if (nURAttachmentIndex <= 0)
return;
}
const char *pScreenName;
weapon->GetControlPanelInfo( nPanel, pScreenName );
if (!pScreenName)
continue;
const char *pScreenClassname;
weapon->GetControlPanelClassName( nPanel, pScreenClassname );
if ( !pScreenClassname )
continue;
// Compute the screen size from the attachment points...
matrix3x4_t panelToWorld;
pEntityToSpawnOn->GetAttachment( nLLAttachmentIndex, panelToWorld );
matrix3x4_t worldToPanel;
MatrixInvert( panelToWorld, worldToPanel );
// Now get the lower right position + transform into panel space
Vector lr, lrlocal;
pEntityToSpawnOn->GetAttachment( nURAttachmentIndex, panelToWorld );
MatrixGetColumn( panelToWorld, 3, lr );
VectorTransform( lr, worldToPanel, lrlocal );
float flWidth = lrlocal.x;
float flHeight = lrlocal.y;
CVGuiScreen *pScreen = CreateVGuiScreen( pScreenClassname, pScreenName, pEntityToSpawnOn, this, nLLAttachmentIndex );
pScreen->ChangeTeam( GetTeamNumber() );
pScreen->SetActualSize( flWidth, flHeight );
pScreen->SetActive( false );
pScreen->MakeVisibleOnlyToTeammates( false );
#ifdef INVASION_DLL
pScreen->SetOverlayMaterial( SCREEN_OVERLAY_MATERIAL );
#endif
pScreen->SetAttachedToViewModel( true );
int nScreen = m_hScreens.AddToTail( );
m_hScreens[nScreen].Set( pScreen );
}
#endif
}
//-----------------------------------------------------------------------------
// Purpose: Called when an entity starts touching us.
// Input : pOther - The entity that is touching us.
//-----------------------------------------------------------------------------
void CTriggerPortalCleanser::StartTouch( CBaseEntity *pOther )
{
if ( PassesTriggerFilters(pOther) )
{
EHANDLE hOther;
hOther = pOther;
bool bAdded = false;
if ( m_hTouchingEntities.Find( hOther ) == m_hTouchingEntities.InvalidIndex() )
{
m_hTouchingEntities.AddToTail( hOther );
bAdded = true;
}
m_OnStartTouch.FireOutput(pOther, this);
if ( bAdded && ( m_hTouchingEntities.Count() == 1 ) )
{
// First entity to touch us that passes our filters
m_OnStartTouchAll.FireOutput( pOther, this );
}
if ( portal_cleanser_debug.GetBool() )
{
Msg("%s START-TOUCH: for %s\n", GetDebugName(), pOther->GetDebugName() );
}
if ( !pOther->IsPlayer() )
{
CBaseAnimating *pAnim = pOther->GetBaseAnimating();
if ( !pAnim )
return;
// Can't dissolve twice.
if ( pAnim->IsDissolving() )
return;
// Force player to drop this object.
Pickup_ForcePlayerToDropThisObject( pOther );
if ( !FClassnameIs( pOther, "prop_physics" ) )
{
if ( FClassnameIs( pOther, "simple_physics_prop" ) || FClassnameIs( pOther, "simple_physics_brush" ) )
{
// simple_physics_prop ?
return;
}
if ( portal_cleanser_debug.GetBool() )
{
Msg("%s IS CREATING: simple_physics_prop\n", GetDebugName());
}
// Other object needs to be replaced by simple_physics_prop.
pOther = CreateSimplePhysicsObject( pOther );
// Dissolve the entity.
CBaseAnimating *pAnim = pOther->GetBaseAnimating();
pAnim->Dissolve( NULL, gpGlobals->curtime, false, ENTITY_DISSOLVE_NORMAL );
if ( portal_cleanser_debug.GetBool() )
{
Msg("%s DISSOLVE SIMPLE PHYSICS: %s\n", GetDebugName(), pOther->GetDebugName() );
}
// Outputs
m_hActivator = pOther;
m_OnDissolve.FireOutput(m_hActivator, this);
return;
}
IPhysicsObject *pPhysics = pOther->VPhysicsGetObject();
if ( pPhysics )
{
// Dissolve the entity.
pAnim->Dissolve( NULL, gpGlobals->curtime, false, ENTITY_DISSOLVE_NORMAL );
if ( portal_cleanser_debug.GetBool() )
{
Msg("%s DISSOLVE PHYSICS: %s\n", GetDebugName(), pOther->GetDebugName() );
}
// Turn off the gravity for this object.
pPhysics->EnableGravity( false );
// Slow down and push up the object.
Vector vecVelocity, vecAngular;
pPhysics->GetVelocity( &vecVelocity, &vecAngular );
vecVelocity /= 2;
vecAngular /= 2;
vecVelocity.z += 10;
pPhysics->SetVelocity( &vecVelocity, &vecAngular );
// Outputs
m_hActivator = pOther;
m_OnDissolve.FireOutput(m_hActivator, this);
const char *pModelName = STRING( pOther->GetModelName() );
if ( Q_strstr( pModelName, "models/props/metal_box.mdl" ) )
{
m_OnDissolveBox.FireOutput(m_hActivator, this);
}
}
}
}
}
//-----------------------------------------------------------------------------
// This is called by the base object when it's time to spawn the control panels
//-----------------------------------------------------------------------------
void CPlantedC4::SpawnControlPanels()
{
char buf[64];
// FIXME: Deal with dynamically resizing control panels?
// If we're attached to an entity, spawn control panels on it instead of use
CBaseAnimating *pEntityToSpawnOn = this;
char *pOrgLL = "controlpanel%d_ll";
char *pOrgUR = "controlpanel%d_ur";
char *pAttachmentNameLL = pOrgLL;
char *pAttachmentNameUR = pOrgUR;
Assert( pEntityToSpawnOn );
// Lookup the attachment point...
int nPanel;
for ( nPanel = 0; true; ++nPanel )
{
Q_snprintf( buf, sizeof( buf ), pAttachmentNameLL, nPanel );
int nLLAttachmentIndex = pEntityToSpawnOn->LookupAttachment(buf);
if (nLLAttachmentIndex <= 0)
{
// Try and use my panels then
pEntityToSpawnOn = this;
Q_snprintf( buf, sizeof( buf ), pOrgLL, nPanel );
nLLAttachmentIndex = pEntityToSpawnOn->LookupAttachment(buf);
if (nLLAttachmentIndex <= 0)
return;
}
Q_snprintf( buf, sizeof( buf ), pAttachmentNameUR, nPanel );
int nURAttachmentIndex = pEntityToSpawnOn->LookupAttachment(buf);
if (nURAttachmentIndex <= 0)
{
// Try and use my panels then
Q_snprintf( buf, sizeof( buf ), pOrgUR, nPanel );
nURAttachmentIndex = pEntityToSpawnOn->LookupAttachment(buf);
if (nURAttachmentIndex <= 0)
return;
}
const char *pScreenName;
GetControlPanelInfo( nPanel, pScreenName );
if (!pScreenName)
continue;
const char *pScreenClassname;
GetControlPanelClassName( nPanel, pScreenClassname );
if ( !pScreenClassname )
continue;
// Compute the screen size from the attachment points...
matrix3x4_t panelToWorld;
pEntityToSpawnOn->GetAttachment( nLLAttachmentIndex, panelToWorld );
matrix3x4_t worldToPanel;
MatrixInvert( panelToWorld, worldToPanel );
// Now get the lower right position + transform into panel space
Vector lr, lrlocal;
pEntityToSpawnOn->GetAttachment( nURAttachmentIndex, panelToWorld );
MatrixGetColumn( panelToWorld, 3, lr );
VectorTransform( lr, worldToPanel, lrlocal );
float flWidth = lrlocal.x;
float flHeight = lrlocal.y;
CVGuiScreen *pScreen = CreateVGuiScreen( pScreenClassname, pScreenName, pEntityToSpawnOn, this, nLLAttachmentIndex );
pScreen->ChangeTeam( GetTeamNumber() );
pScreen->SetActualSize( flWidth, flHeight );
pScreen->SetActive( true );
pScreen->MakeVisibleOnlyToTeammates( false );
int nScreen = m_hScreens.AddToTail( );
m_hScreens[nScreen].Set( pScreen );
}
}
void PropBreakableCreateAll( int modelindex, IPhysicsObject *pPhysics, const breakablepropparams_t ¶ms, CBaseEntity *pEntity, int iPrecomputedBreakableCount, bool bIgnoreGibLimit, bool defaultLocation )
{
// Check for prop breakable count reset.
int nPropCount = props_break_max_pieces_perframe.GetInt();
if ( nPropCount != -1 )
{
if ( nFrameNumber != gpGlobals->framecount )
{
nPropBreakablesPerFrameCount = 0;
nFrameNumber = gpGlobals->framecount;
}
// Check for max breakable count for the frame.
if ( nPropBreakablesPerFrameCount >= nPropCount )
return;
}
int iMaxBreakCount = bIgnoreGibLimit ? -1 : props_break_max_pieces.GetInt();
if ( iMaxBreakCount != -1 )
{
if ( iPrecomputedBreakableCount != -1 )
{
iPrecomputedBreakableCount = MIN( iMaxBreakCount, iPrecomputedBreakableCount );
}
else
{
iPrecomputedBreakableCount = iMaxBreakCount;
}
}
#ifdef GAME_DLL
// On server limit break model creation
if ( !PropBreakableCapEdictsOnCreateAll(modelindex, pPhysics, params, pEntity, iPrecomputedBreakableCount ) )
{
DevMsg( "Failed to create PropBreakable: would exceed MAX_EDICTS\n" );
return;
}
#endif
vcollide_t *pCollide = modelinfo->GetVCollide( modelindex );
if ( !pCollide )
return;
int nSkin = 0;
CBaseEntity *pOwnerEntity = pEntity;
CBaseAnimating *pOwnerAnim = NULL;
if ( pPhysics )
{
pOwnerEntity = static_cast<CBaseEntity *>(pPhysics->GetGameData());
}
if ( pOwnerEntity )
{
pOwnerAnim = pOwnerEntity->GetBaseAnimating();
if ( pOwnerAnim )
{
nSkin = pOwnerAnim->m_nSkin;
}
}
matrix3x4_t localToWorld;
CStudioHdr studioHdr;
const model_t *model = modelinfo->GetModel( modelindex );
if ( model )
{
studioHdr.Init( modelinfo->GetStudiomodel( model ) );
}
Vector parentOrigin = vec3_origin;
int parentAttachment = Studio_FindAttachment( &studioHdr, "placementOrigin" ) + 1;
if ( parentAttachment > 0 )
{
GetAttachmentLocalSpace( &studioHdr, parentAttachment-1, localToWorld );
MatrixGetColumn( localToWorld, 3, parentOrigin );
}
else
{
AngleMatrix( vec3_angle, localToWorld );
}
CUtlVector<breakmodel_t> list;
BreakModelList( list, modelindex, params.defBurstScale, params.defCollisionGroup );
CUtlVector< CBaseEntity* > spawnedGibs;
if ( list.Count() )
{
for ( int i = 0; i < list.Count(); i++ )
{
int modelIndex = modelinfo->GetModelIndex( list[i].modelName );
if ( modelIndex <= 0 )
continue;
// Skip multiplayer pieces that should be spawning on the other dll
#ifdef GAME_DLL
if ( gpGlobals->maxClients > 1 && breakable_multiplayer.GetBool() )
#else
if ( gpGlobals->maxClients > 1 )
#endif
{
#ifdef GAME_DLL
if ( list[i].mpBreakMode == MULTIPLAYER_BREAK_CLIENTSIDE )
continue;
#else
if ( list[i].mpBreakMode == MULTIPLAYER_BREAK_SERVERSIDE )
continue;
#endif
if ( !defaultLocation && list[i].mpBreakMode == MULTIPLAYER_BREAK_DEFAULT )
continue;
}
if ( ( nPropCount != -1 ) && ( nPropBreakablesPerFrameCount > nPropCount ) )
break;
if ( ( iPrecomputedBreakableCount != -1 ) && ( i >= iPrecomputedBreakableCount ) )
break;
matrix3x4_t matrix;
AngleMatrix( params.angles, params.origin, matrix );
CStudioHdr studioHdr;
const model_t *model = modelinfo->GetModel( modelIndex );
if ( model )
{
studioHdr.Init( modelinfo->GetStudiomodel( model ) );
}
// Increment the number of breakable props this frame.
++nPropBreakablesPerFrameCount;
const float flModelScale = pOwnerAnim->GetModelScale();
Vector position = vec3_origin;
QAngle angles = params.angles;
if ( pOwnerAnim && list[i].placementName[0] )
{
if ( list[i].placementIsBone )
{
int boneIndex = pOwnerAnim->LookupBone( list[i].placementName );
if ( boneIndex >= 0 )
{
pOwnerAnim->GetBonePosition( boneIndex, position, angles );
AngleMatrix( angles, position, matrix );
}
}
else
{
int attachmentIndex = Studio_FindAttachment( &studioHdr, list[i].placementName ) + 1;
if ( attachmentIndex > 0 )
{
pOwnerAnim->GetAttachment( attachmentIndex, matrix );
MatrixAngles( matrix, angles );
}
}
}
else
{
int placementIndex = Studio_FindAttachment( &studioHdr, "placementOrigin" ) + 1;
Vector placementOrigin = parentOrigin;
if ( placementIndex > 0 )
{
GetAttachmentLocalSpace( &studioHdr, placementIndex-1, localToWorld );
MatrixGetColumn( localToWorld, 3, placementOrigin );
placementOrigin -= parentOrigin;
}
VectorTransform( list[i].offset - placementOrigin * flModelScale,
matrix, position );
}
Vector objectVelocity = params.velocity;
if (pPhysics)
{
pPhysics->GetVelocityAtPoint( position, &objectVelocity );
}
int nActualSkin = nSkin;
if ( nActualSkin > studioHdr.numskinfamilies() )
nActualSkin = 0;
CBaseEntity *pBreakable = NULL;
#ifdef GAME_DLL
if ( GetGibManager() == NULL || GetGibManager()->AllowedToSpawnGib() )
#endif
{
pBreakable = BreakModelCreateSingle( pOwnerEntity, &list[i], position, angles, objectVelocity, params.angularVelocity, nActualSkin, params );
}
if ( pBreakable )
{
spawnedGibs.AddToTail( pBreakable );
#ifdef GAME_DLL
if ( GetGibManager() )
{
GetGibManager()->AddGibToLRU( pBreakable->GetBaseAnimating() );
}
#endif
if ( pOwnerEntity && pOwnerEntity->IsEffectActive( EF_NOSHADOW ) )
{
pBreakable->AddEffects( EF_NOSHADOW );
}
// If burst scale is set, this piece should 'burst' away from
// the origin in addition to travelling in the wished velocity.
if ( list[i].burstScale != 0.0 )
{
Vector vecBurstDir = position - params.origin;
// If $autocenter wasn't used, try the center of the piece
if ( vecBurstDir == vec3_origin )
{
vecBurstDir = pBreakable->WorldSpaceCenter() - params.origin;
}
VectorNormalize( vecBurstDir );
pBreakable->ApplyAbsVelocityImpulse( vecBurstDir * list[i].burstScale * flModelScale *
params.velocityScale * params.burstScale );
}
if ( params.randomAngularVelocity > 0.0f )
{
AngularImpulse angRandomImpulse = RandomAngularImpulse( -params.randomAngularVelocity, params.randomAngularVelocity );
pBreakable->ApplyLocalAngularVelocityImpulse( angRandomImpulse * params.velocityScale );
}
// If this piece is supposed to be motion disabled, disable it
if ( list[i].isMotionDisabled )
{
IPhysicsObject *pPhysicsObject = pBreakable->VPhysicsGetObject();
if ( pPhysicsObject != NULL )
{
pPhysicsObject->EnableMotion( false );
}
}
}
}
}
// Then see if the propdata specifies any breakable pieces
else if ( pEntity )
{
IBreakableWithPropData *pBreakableInterface = dynamic_cast<IBreakableWithPropData*>(pEntity);
if ( pBreakableInterface && pBreakableInterface->GetBreakableModel() != NULL_STRING && pBreakableInterface->GetBreakableCount() )
{
breakmodel_t breakModel;
for ( int i = 0; i < pBreakableInterface->GetBreakableCount(); i++ )
{
if ( ( iPrecomputedBreakableCount != -1 ) && ( i >= iPrecomputedBreakableCount ) )
break;
Q_strncpy( breakModel.modelName, g_PropDataSystem.GetRandomChunkModel(STRING(pBreakableInterface->GetBreakableModel()), pBreakableInterface->GetMaxBreakableSize()), sizeof(breakModel.modelName) );
breakModel.health = 1;
breakModel.fadeTime = RandomFloat(5,10);
breakModel.fadeMinDist = 0.0f;
breakModel.fadeMaxDist = 0.0f;
breakModel.burstScale = params.defBurstScale;
breakModel.collisionGroup = COLLISION_GROUP_DEBRIS;
breakModel.isRagdoll = false;
breakModel.isMotionDisabled = false;
breakModel.placementName[0] = 0;
breakModel.placementIsBone = false;
Vector vecObbSize = pEntity->CollisionProp()->OBBSize();
// Find a random point on the plane of the original's two largest axis
int smallestAxis = SmallestAxis( vecObbSize );
Vector vecMins(0,0,0);
Vector vecMaxs(1,1,1);
vecMins[smallestAxis] = 0.5;
vecMaxs[smallestAxis] = 0.5;
pEntity->CollisionProp()->RandomPointInBounds( vecMins, vecMaxs, &breakModel.offset );
// Push all chunks away from the center
Vector vecBurstDir = breakModel.offset - params.origin;
VectorNormalize( vecBurstDir );
Vector vecVelocity = vecBurstDir * params.defBurstScale;
QAngle vecAngles = pEntity->GetAbsAngles();
int iSkin = pBreakableInterface->GetBreakableSkin();
CBaseEntity *pBreakable = NULL;
#ifdef GAME_DLL
if ( GetGibManager() == NULL || GetGibManager()->AllowedToSpawnGib() )
#endif
{
pBreakable = BreakModelCreateSingle( pOwnerEntity, &breakModel, breakModel.offset, vecAngles, vecVelocity, vec3_origin/*params.angularVelocity*/, iSkin, params );
if ( !pBreakable )
{
DevWarning( "PropBreakableCreateAll: Could not create model %s\n", breakModel.modelName );
}
}
if ( pBreakable )
{
#ifdef GAME_DLL
if ( GetGibManager() )
{
GetGibManager()->AddGibToLRU( pBreakable->GetBaseAnimating() );
}
#endif
Vector vecBreakableObbSize = pBreakable->CollisionProp()->OBBSize();
// Try to align the gibs along the original axis
matrix3x4_t matrix;
AngleMatrix( vecAngles, matrix );
AlignBoxes( &matrix, vecObbSize, vecBreakableObbSize );
MatrixAngles( matrix, vecAngles );
if ( pBreakable->VPhysicsGetObject() )
{
Vector pos;
pBreakable->VPhysicsGetObject()->GetPosition( &pos, NULL );
pBreakable->VPhysicsGetObject()->SetPosition( pos, vecAngles, true );
}
pBreakable->SetAbsAngles( vecAngles );
if ( pOwnerEntity->IsEffectActive( EF_NOSHADOW ) )
{
pBreakable->AddEffects( EF_NOSHADOW );
}
}
}
}
}
if ( params.connectingParticleNames.Count() > 0 && spawnedGibs.Count() > 1 )
{
const int iGibCount = spawnedGibs.Count();
int iParticlesLeft = iGibCount / 2;
int iEntIndex0 = RandomInt( 0, iGibCount - 1 );
while ( iParticlesLeft > 0 )
{
iParticlesLeft--;
const int iEntIndex1 = ( iEntIndex0 + RandomInt( 1, iGibCount - 1 ) ) % iGibCount;
CBaseEntity *pEnt0 = spawnedGibs[ iEntIndex0 ];
CBaseEntity *pEnt1 = spawnedGibs[ iEntIndex1 ];
const int iParticleSystemIndex = RandomInt( 0, params.connectingParticleNames.Count() - 1 );
DispatchParticleEffect( params.connectingParticleNames[ iParticleSystemIndex ], pEnt0, pEnt1 );
iEntIndex0 = ( iEntIndex0 + RandomInt( 1, iGibCount - 1 ) ) % iGibCount;
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : &info -
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
void CTDP_NPC_CombineS::Event_Killed( const CTakeDamageInfo &info )
{
// Don't bother if we've been told not to, or the player has a megaphyscannon
/* if ( combine_spawn_health.GetBool() == false || PlayerHasMegaPhysCannon() )
{
BaseClass::Event_Killed( info );
return;
}*/
CBasePlayer *pPlayer = ToBasePlayer( info.GetAttacker() );
if ( pPlayer != NULL )
{
// Elites drop alt-fire ammo, so long as they weren't killed by dissolving.
if( IsElite() )
{
CBaseEntity *pItem = DropItem( "item_ammo_ar2_altfire", WorldSpaceCenter()+RandomVector(-4,4), RandomAngle(0,360) );
if ( pItem )
{
IPhysicsObject *pObj = pItem->VPhysicsGetObject();
if ( pObj )
{
Vector vel = RandomVector( -64.0f, 64.0f );
AngularImpulse angImp = RandomAngularImpulse( -300.0f, 300.0f );
vel[2] = 0.0f;
pObj->AddVelocity( &vel, &angImp );
}
if( info.GetDamageType() & DMG_DISSOLVE )
{
CBaseAnimating *pAnimating = dynamic_cast<CBaseAnimating*>(pItem);
if( pAnimating )
{
pAnimating->Dissolve( NULL, gpGlobals->curtime, false, ENTITY_DISSOLVE_NORMAL );
}
}
}
}
//CTDPGameRules *pTDPGameRules = static_cast<CTDPGameRules *>(g_pGameRules);
// Attempt to drop health
/*if ( pTDPGameRules->NPC_ShouldDropHealth( pPlayer ) )
{
DropItem( "item_healthvial", WorldSpaceCenter()+RandomVector(-4,4), RandomAngle(0,360) );
pTDPGameRules->NPC_DroppedHealth();
}*/
// Attempt to drop a grenade
/*if ( pTDPGameRules->NPC_ShouldDropGrenade( pPlayer ) )
{
DropItem( "weapon_frag", WorldSpaceCenter()+RandomVector(-4,4), RandomAngle(0,360) );
pTDPGameRules->NPC_DroppedGrenade();
}*/
}
BaseClass::Event_Killed( info );
}
