//-----------------------------------------------------------------------------
// Purpose: Make the weapon visible and tangible
//-----------------------------------------------------------------------------
CBaseEntity* CBaseCombatWeapon::Respawn( void )
{
// make a copy of this weapon that is invisible and inaccessible to players (no touch function). The weapon spawn/respawn code
// will decide when to make the weapon visible and touchable.
CBaseEntity *pNewWeapon = CBaseEntity::Create( GetClassname(), g_pGameRules->VecWeaponRespawnSpot( this ), GetLocalAngles(), GetOwnerEntity() );
if ( pNewWeapon )
{
pNewWeapon->AddEffects( EF_NODRAW );// invisible for now
pNewWeapon->SetTouch( NULL );// no touch
pNewWeapon->SetThink( &CBaseCombatWeapon::AttemptToMaterialize );
UTIL_DropToFloor( this, MASK_SOLID );
// not a typo! We want to know when the weapon the player just picked up should respawn! This new entity we created is the replacement,
// but when it should respawn is based on conditions belonging to the weapon that was taken.
pNewWeapon->SetNextThink( gpGlobals->curtime + g_pGameRules->FlWeaponRespawnTime( this ) );
}
else
{
Warning("Respawn failed to create %s!\n", GetClassname() );
}
return pNewWeapon;
}
void CFuncAreaPortalWindow::Activate()
{
BaseClass::Activate();
// Find our background model.
CBaseEntity *pBackground = gEntList.FindEntityByName( NULL, m_iBackgroundBModelName );
if( pBackground )
{
m_iBackgroundModelIndex = modelinfo->GetModelIndex( STRING( pBackground->GetModelName() ) );
pBackground->AddEffects( EF_NODRAW ); // we will draw for it.
}
// Find our target and steal its bmodel.
CBaseEntity *pTarget = gEntList.FindEntityByName( NULL, m_target );
if( pTarget )
{
SetModel( STRING(pTarget->GetModelName()) );
SetAbsOrigin( pTarget->GetAbsOrigin() );
pTarget->AddEffects( EF_NODRAW ); // we will draw for it.
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CAntlionGrub::SpawnSquashedGrub( void )
{
// If we're already invisible, we're done
if ( GetEffects() & EF_NODRAW )
return;
Vector vecUp;
GetVectors( NULL, NULL, &vecUp );
CBaseEntity *pGib = CreateRagGib( ANTLIONGRUB_SQUASHED_MODEL, GetAbsOrigin(), GetAbsAngles(), vecUp * 16.0f );
if ( pGib )
{
pGib->AddEffects( EF_NOSHADOW );
}
}
void Test_RandomizeInPVS( const CCommand &args )
{
if ( args.ArgC() < 2 )
{
Error( "Test_RandomizeInPVS <percentage chance to change>" );
}
int percent = atoi( args[ 1 ] );
for ( int i=0; i < g_StressEntities.Count(); i++ )
{
CBaseEntity *pEnt = g_StressEntities[i];
if ( pEnt )
{
if ( RandomInt( 0, 100 ) < percent )
{
if ( pEnt->IsEffectActive( EF_NODRAW ) )
pEnt->RemoveEffects( EF_NODRAW );
else
pEnt->AddEffects( EF_NODRAW );
}
}
}
}
void Test_RandomizeInPVS()
{
if ( engine->Cmd_Argc() < 2 )
{
Error( "Test_RandomizeInPVS <percentage chance to change>" );
}
int percent = atoi( engine->Cmd_Argv( 1 ) );
for ( int i=0; i < g_StressEntities.Count(); i++ )
{
CBaseEntity *pEnt = g_StressEntities[i];
if ( pEnt )
{
if ( RandomInt( 0, 100 ) < percent )
{
if ( pEnt->IsEffectActive( EF_NODRAW ) )
pEnt->RemoveEffects( EF_NODRAW );
else
pEnt->AddEffects( EF_NODRAW );
}
}
}
}
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 );
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;
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, 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 )
{
#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 );
}
// 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 );
}
}
}
}
}
}
//---------------------------------------------------------
// Count of all the weapons in the world of my type and
// see if we have a surplus. If there is a surplus, try
// to find suitable candidates for removal.
//
// Right now we just remove the first weapons we find that
// are behind the player, or are out of the player's PVS.
// Later, we may want to score the results so that we
// removed the farthest gun that's not in the player's
// viewcone, etc.
//
// Some notes and thoughts:
//
// This code is designed NOT to remove weapons that are
// hand-placed by level designers. It should only clean
// up weapons dropped by dead NPCs, which is useful in
// situations where enemies are spawned in for a sustained
// period of time.
//
// Right now we PREFER to remove weapons that are not in the
// player's PVS, but this could be opposite of what we
// really want. We may only want to conduct the cleanup on
// weapons that are IN the player's PVS.
//---------------------------------------------------------
void CGameWeaponManager::Think()
{
int i;
// Don't have to think all that often.
SetNextThink( gpGlobals->curtime + 2.0 );
const char *pszWeaponName = STRING( m_iszWeaponName );
CUtlVector<CBaseEntity *> candidates( 0, 64 );
if ( m_bExpectingWeapon )
{
CBaseCombatWeapon *pWeapon = NULL;
// Firstly, count the total number of weapons of this type in the world.
// Also count how many of those can potentially be removed.
pWeapon = assert_cast<CBaseCombatWeapon *>(gEntList.FindEntityByClassname( pWeapon, pszWeaponName ));
while( pWeapon )
{
if( !pWeapon->IsEffectActive( EF_NODRAW ) && pWeapon->IsRemoveable() )
{
candidates.AddToTail( pWeapon );
}
pWeapon = assert_cast<CBaseCombatWeapon *>(gEntList.FindEntityByClassname( pWeapon, pszWeaponName ));
}
}
else
{
for ( i = 0; i < m_ManagedNonWeapons.Count(); i++)
{
CBaseEntity *pEntity = m_ManagedNonWeapons[i];
if ( pEntity )
{
Assert( pEntity->m_iClassname == m_iszWeaponName );
if ( !pEntity->IsEffectActive( EF_NODRAW ) )
{
candidates.AddToTail( pEntity );
}
}
else
{
m_ManagedNonWeapons.FastRemove( i-- );
}
}
}
// Calculate the surplus.
int surplus = candidates.Count() - m_iMaxPieces;
// Based on what the player can see, try to clean up the world by removing weapons that
// the player cannot see right at the moment.
CBaseEntity *pCandidate;
for ( i = 0; i < candidates.Count() && surplus > 0; i++ )
{
bool fRemovedOne = false;
pCandidate = candidates[i];
Assert( !pCandidate->IsEffectActive( EF_NODRAW ) );
// if ( gpGlobals->maxClients == 1 )
{
CBasePlayer *pPlayer = UTIL_GetNearestVisiblePlayer(pCandidate);
// Nodraw serves as a flag that this weapon is already being removed since
// all we're really doing inside this loop is marking them for removal by
// the entity system. We don't want to count the same weapon as removed
// more than once.
if( !UTIL_FindClientInPVS( pCandidate->edict() ) )
{
fRemovedOne = true;
}
else if( !pPlayer->FInViewCone( pCandidate ) )
{
fRemovedOne = true;
}
else if ( UTIL_DistApprox( pPlayer->GetAbsOrigin(), pCandidate->GetAbsOrigin() ) > (30*12) )
{
fRemovedOne = true;
}
}
// else
// {
// fRemovedOne = true;
// }
if( fRemovedOne )
{
pCandidate->AddEffects( EF_NODRAW );
UTIL_Remove( pCandidate );
DevMsg( 2, "Surplus %s removed\n", pszWeaponName);
surplus--;
}
}
}
