diff options
Diffstat (limited to 'mp/src/game/shared/props_shared.cpp')
| -rw-r--r-- | mp/src/game/shared/props_shared.cpp | 1638 |
1 files changed, 1638 insertions, 0 deletions
diff --git a/mp/src/game/shared/props_shared.cpp b/mp/src/game/shared/props_shared.cpp new file mode 100644 index 00000000..86a8e865 --- /dev/null +++ b/mp/src/game/shared/props_shared.cpp @@ -0,0 +1,1638 @@ +//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: static_prop - don't move, don't animate, don't do anything.
+// physics_prop - move, take damage, but don't animate
+//
+//=============================================================================//
+
+
+#include "cbase.h"
+#include "props_shared.h"
+#include "filesystem.h"
+#include "animation.h"
+#include <vcollide_parse.h>
+#include <bone_setup.h>
+#include <tier0/vprof.h>
+
+#ifdef CLIENT_DLL
+#include "gamestringpool.h"
+#endif
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+ConVar sv_pushaway_clientside_size( "sv_pushaway_clientside_size", "15", FCVAR_REPLICATED | FCVAR_DEVELOPMENTONLY, "Minimum size of pushback objects" );
+ConVar props_break_max_pieces( "props_break_max_pieces", "-1", 0, "Maximum prop breakable piece count (-1 = model default)" );
+ConVar props_break_max_pieces_perframe( "props_break_max_pieces_perframe", "-1", FCVAR_REPLICATED, "Maximum prop breakable piece count per frame (-1 = model default)" );
+#ifdef GAME_DLL
+extern ConVar breakable_multiplayer;
+#else
+ConVar cl_burninggibs( "cl_burninggibs", "0", 0, "A burning player that gibs has burning gibs." );
+#endif // GAME_DLL
+
+extern bool PropBreakableCapEdictsOnCreateAll(int modelindex, IPhysicsObject *pPhysics, const breakablepropparams_t ¶ms, CBaseEntity *pEntity, int iPrecomputedBreakableCount = -1 );
+extern CBaseEntity *BreakModelCreateSingle( CBaseEntity *pOwner, breakmodel_t *pModel, const Vector &position,
+ const QAngle &angles, const Vector &velocity, const AngularImpulse &angVelocity, int nSkin, const breakablepropparams_t ¶ms );
+
+static int nPropBreakablesPerFrameCount = 0;
+static int nFrameNumber = 0;
+
+//=============================================================================================================
+// UTILITY FUNCS
+//=============================================================================================================
+//-----------------------------------------------------------------------------
+// Purpose: returns the axis index with the greatest size
+// Input : &vec -
+// Output : static int
+//-----------------------------------------------------------------------------
+static int GreatestAxis( const Vector &vec )
+{
+ if ( vec.x > vec.y )
+ {
+ if ( vec.x > vec.z )
+ return 0;
+ return 2;
+ }
+ if ( vec.y > vec.z )
+ return 1;
+ return 2;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: returns the axis index with the smallest size
+// Input : &vec -
+// Output : static int
+//-----------------------------------------------------------------------------
+static int SmallestAxis( const Vector &vec )
+{
+ if ( vec.x < vec.y )
+ {
+ if ( vec.x < vec.z )
+ return 0;
+ return 2;
+ }
+ if ( vec.y < vec.z )
+ return 1;
+ return 2;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Rotates a matrix by 90 degrees in the plane of axis0/axis1
+// Input : &matrix -
+// axis0 -
+// axis1 -
+// Output : static void
+//-----------------------------------------------------------------------------
+static void MatrixRot90( matrix3x4_t &matrix, int axis0, int axis1 )
+{
+ Vector col0, col1;
+ MatrixGetColumn( matrix, axis0, col0 );
+ MatrixGetColumn( matrix, axis1, col1 );
+ MatrixSetColumn( col1, axis0, matrix );
+ MatrixSetColumn( -col0, axis1, matrix );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Given two symmetric boxes, rotate the coordinate frame by the necessary
+// 90 degree rotations to approximately align them
+// Input : *pInOutMatrix -
+// &boxExtents1 -
+// &boxExtents2 -
+//-----------------------------------------------------------------------------
+static void AlignBoxes( matrix3x4_t *pInOutMatrix, const Vector &boxExtents1, const Vector &boxExtents2 )
+{
+ int rotCount = 0;
+ struct
+ {
+ int axis0;
+ int axis1;
+ } rotations[2];
+ Vector ext1 = boxExtents1;
+ Vector ext2 = boxExtents2;
+
+ int axis0 = GreatestAxis( ext1 );
+ int axis1 = GreatestAxis( ext2 );
+ if ( axis0 != axis1 )
+ {
+ rotations[rotCount].axis0 = axis0;
+ rotations[rotCount].axis1 = axis1;
+ rotCount++;
+ ext2[axis1] = ext2[axis0];
+ }
+ ext1[axis0] = 0;
+ ext2[axis0] = 0;
+
+ axis0 = GreatestAxis(ext1);
+ axis1 = GreatestAxis(ext2);
+ if ( axis0 != axis1 )
+ {
+ rotations[rotCount].axis0 = axis0;
+ rotations[rotCount].axis1 = axis1;
+ rotCount++;
+ }
+
+ while ( rotCount > 0 )
+ {
+ rotCount--;
+ MatrixRot90( *pInOutMatrix, rotations[rotCount].axis0, rotations[rotCount].axis1 );
+ }
+}
+
+//=============================================================================================================
+// PROP DATA
+//=============================================================================================================
+CPropData g_PropDataSystem;
+
+// Parsing details for each of the propdata interactions
+struct propdata_interaction_s
+{
+ const char *pszSectionName;
+ const char *pszKeyName;
+ const char *pszValue;
+};
+
+#if !defined(_STATIC_LINKED) || defined(CLIENT_DLL)
+propdata_interaction_s sPropdataInteractionSections[PROPINTER_NUM_INTERACTIONS] =
+{
+ { "physgun_interactions", "onworldimpact", "stick" }, // PROPINTER_PHYSGUN_WORLD_STICK,
+ { "physgun_interactions", "onfirstimpact", "break" }, // PROPINTER_PHYSGUN_FIRST_BREAK,
+ { "physgun_interactions", "onfirstimpact", "paintsplat" }, // PROPINTER_PHYSGUN_FIRST_PAINT,
+ { "physgun_interactions", "onfirstimpact", "impale" }, // PROPINTER_PHYSGUN_FIRST_IMPALE,
+ { "physgun_interactions", "onlaunch", "spin_none" }, // PROPINTER_PHYSGUN_LAUNCH_SPIN_NONE,
+ { "physgun_interactions", "onlaunch", "spin_zaxis" }, // PROPINTER_PHYSGUN_LAUNCH_SPIN_Z,
+ { "physgun_interactions", "onbreak", "explode_fire" }, // PROPINTER_PHYSGUN_BREAK_EXPLODE,
+ { "physgun_interactions", "damage", "none" }, // PROPINTER_PHYSGUN_DAMAGE_NONE,
+
+ { "fire_interactions", "flammable", "yes" }, // PROPINTER_FIRE_FLAMMABLE,
+ { "fire_interactions", "explosive_resist", "yes" }, // PROPINTER_FIRE_EXPLOSIVE_RESIST,
+ { "fire_interactions", "ignite", "halfhealth" }, // PROPINTER_FIRE_IGNITE_HALFHEALTH,
+
+ { "physgun_interactions", "onpickup", "create_flare" }, // PROPINTER_PHYSGUN_CREATE_FLARE,
+
+ { "physgun_interactions", "allow_overhead", "yes" }, // PROPINTER_PHYSGUN_ALLOW_OVERHEAD,
+
+ { "world_interactions", "onworldimpact", "bloodsplat" }, // PROPINTER_WORLD_BLOODSPLAT,
+};
+#else
+extern propdata_interaction_s sPropdataInteractionSections[PROPINTER_NUM_INTERACTIONS];
+#endif
+
+//-----------------------------------------------------------------------------
+// Constructor, destructor
+//-----------------------------------------------------------------------------
+CPropData::CPropData( void ) :
+ CAutoGameSystem( "CPropData" )
+{
+ m_bPropDataLoaded = false;
+ m_pKVPropData = NULL;
+}
+
+//-----------------------------------------------------------------------------
+// Inherited from IAutoServerSystem
+//-----------------------------------------------------------------------------
+void CPropData::LevelInitPreEntity( void )
+{
+ m_BreakableChunks.RemoveAll();
+ ParsePropDataFile();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+void CPropData::LevelShutdownPostEntity( void )
+{
+ if ( m_pKVPropData )
+ {
+ m_pKVPropData->deleteThis();
+ m_pKVPropData = NULL;
+ }
+}
+
+//-----------------------------------------------------------------------------
+// Clear out the stats + their history
+//-----------------------------------------------------------------------------
+void CPropData::ParsePropDataFile( void )
+{
+ m_pKVPropData = new KeyValues( "PropDatafile" );
+ if ( !m_pKVPropData->LoadFromFile( filesystem, "scripts/propdata.txt" ) )
+ {
+ m_pKVPropData->deleteThis();
+ m_pKVPropData = NULL;
+ return;
+ }
+
+ m_bPropDataLoaded = true;
+
+ // Now try and parse out the breakable section
+ KeyValues *pBreakableSection = m_pKVPropData->FindKey( "BreakableModels" );
+ if ( pBreakableSection )
+ {
+ KeyValues *pChunkSection = pBreakableSection->GetFirstSubKey();
+ while ( pChunkSection )
+ {
+ // Create a new chunk section and add it to our list
+ int index = m_BreakableChunks.AddToTail();
+ propdata_breakablechunk_t *pBreakableChunk = &m_BreakableChunks[index];
+ pBreakableChunk->iszChunkType = AllocPooledString( pChunkSection->GetName() );
+
+ // Read in all the model names
+ KeyValues *pModelName = pChunkSection->GetFirstSubKey();
+ while ( pModelName )
+ {
+ const char *pModel = pModelName->GetName();
+ string_t pooledName = AllocPooledString( pModel );
+ pBreakableChunk->iszChunkModels.AddToTail( pooledName );
+ CBaseEntity::PrecacheModel( STRING( pooledName ) );
+
+ pModelName = pModelName->GetNextKey();
+ }
+
+ pChunkSection = pChunkSection->GetNextKey();
+ }
+ }
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Parse a keyvalues section into the prop
+//
+// pInteractionSection is a bit of jiggery-pokery to get around the unfortunate
+// fact that the interaction KV sections ("physgun_interactions", "fire_interactions", etc)
+// are OUTSIDE the "prop_data" KV section in the model, but may be contained WITHIN the
+// specified Base's "prop_data" section (i.e. in propdata.txt)
+//-----------------------------------------------------------------------------
+int CPropData::ParsePropFromKV( CBaseEntity *pProp, KeyValues *pSection, KeyValues *pInteractionSection )
+{
+ IBreakableWithPropData *pBreakableInterface = dynamic_cast<IBreakableWithPropData*>(pProp);
+ if ( !pBreakableInterface )
+ return PARSE_FAILED_BAD_DATA;
+
+ if ( !pBreakableInterface )
+ return PARSE_FAILED_BAD_DATA;
+
+ int iBaseResult = PARSE_SUCCEEDED;
+
+ // Do we have a base?
+ char const *pszBase = pSection->GetString( "base" );
+ if ( pszBase && pszBase[0] )
+ {
+ iBaseResult = ParsePropFromBase( pProp, pszBase );
+ if ( (iBaseResult != PARSE_SUCCEEDED) && (iBaseResult != PARSE_SUCCEEDED_ALLOWED_STATIC) )
+ return iBaseResult;
+ }
+
+ // Allow overriding of Block LOS
+ int iBlockLOS = pSection->GetFloat( "blockLOS", -1 );
+ if ( iBlockLOS != -1 )
+ {
+ pBreakableInterface->SetPropDataBlocksLOS( iBlockLOS != 0 );
+ }
+
+ // Set whether AI can walk on this prop
+ int iIsWalkable = pSection->GetFloat( "AIWalkable", -1 );
+ if ( iIsWalkable != -1 )
+ {
+ pBreakableInterface->SetPropDataIsAIWalkable( iIsWalkable != 0 );
+ }
+
+ // Set custom damage table
+ const char *pszTableName;
+ if ( pBreakableInterface->GetPhysicsDamageTable() == NULL_STRING )
+ {
+ pszTableName = pSection->GetString( "damage_table", NULL );
+ }
+ else
+ {
+ pszTableName = pSection->GetString( "damage_table", STRING(pBreakableInterface->GetPhysicsDamageTable()) );
+ }
+ if ( pszTableName && pszTableName[0] )
+ {
+ pBreakableInterface->SetPhysicsDamageTable( AllocPooledString( pszTableName ) );
+ }
+ else
+ {
+ pBreakableInterface->SetPhysicsDamageTable( NULL_STRING );
+ }
+
+ // Get multiplayer physics mode if not set by map
+ pBreakableInterface->SetPhysicsMode( pSection->GetInt( "physicsmode",
+ pBreakableInterface->GetPhysicsMode() ) );
+
+ const char *multiplayer_break = pSection->GetString( "multiplayer_break", NULL );
+ if ( multiplayer_break )
+ {
+ mp_break_t mode = MULTIPLAYER_BREAK_DEFAULT;
+ if ( FStrEq( multiplayer_break, "server" ) )
+ {
+ mode = MULTIPLAYER_BREAK_SERVERSIDE;
+ }
+ else if ( FStrEq( multiplayer_break, "client" ) )
+ {
+ mode = MULTIPLAYER_BREAK_CLIENTSIDE;
+ }
+ else if ( FStrEq( multiplayer_break, "both" ) )
+ {
+ mode = MULTIPLAYER_BREAK_BOTH;
+ }
+ pBreakableInterface->SetMultiplayerBreakMode( mode );
+ }
+
+ // Get damage modifiers, but only if they're specified, because our base may have already overridden them.
+ pBreakableInterface->SetDmgModBullet( pSection->GetFloat( "dmg.bullets", pBreakableInterface->GetDmgModBullet() ) );
+ pBreakableInterface->SetDmgModClub( pSection->GetFloat( "dmg.club", pBreakableInterface->GetDmgModClub() ) );
+ pBreakableInterface->SetDmgModExplosive( pSection->GetFloat( "dmg.explosive", pBreakableInterface->GetDmgModExplosive() ) );
+
+ // Get the health (unless this is an override prop)
+ if ( !FClassnameIs( pProp, "prop_physics_override" ) && !FClassnameIs( pProp, "prop_dynamic_override" ) )
+ {
+ pProp->SetHealth( pSection->GetInt( "health", pProp->GetHealth() ) );
+
+ // Explosive?
+ pBreakableInterface->SetExplosiveDamage( pSection->GetFloat( "explosive_damage", pBreakableInterface->GetExplosiveDamage() ) );
+ pBreakableInterface->SetExplosiveRadius( pSection->GetFloat( "explosive_radius", pBreakableInterface->GetExplosiveRadius() ) );
+
+#ifdef GAME_DLL
+ // If we now have health, we're not allowed to ignore physics damage
+ if ( pProp->GetHealth() )
+ {
+ pProp->RemoveSpawnFlags( SF_PHYSPROP_DONT_TAKE_PHYSICS_DAMAGE );
+ }
+#endif
+ }
+
+ const char *pszBreakableModel;
+ if ( pBreakableInterface->GetBreakableModel() == NULL_STRING )
+ {
+ pszBreakableModel = pSection->GetString( "breakable_model", NULL );
+ }
+ else
+ {
+ pszBreakableModel = pSection->GetString( "breakable_model", STRING(pBreakableInterface->GetBreakableModel()) );
+ }
+ if ( pszBreakableModel && pszBreakableModel[0] )
+ {
+ pBreakableInterface->SetBreakableModel( AllocPooledString( pszBreakableModel ) );
+ }
+ else
+ {
+ pBreakableInterface->SetBreakableModel( NULL_STRING );
+ }
+ pBreakableInterface->SetBreakableSkin( pSection->GetInt( "breakable_skin", pBreakableInterface->GetBreakableSkin() ) );
+ pBreakableInterface->SetBreakableCount( pSection->GetInt( "breakable_count", pBreakableInterface->GetBreakableCount() ) );
+
+ // Calculate the maximum size of the breakables this breakable will produce
+ Vector vecSize = pProp->CollisionProp()->OBBSize();
+ // Throw away the smallest coord
+ int iSmallest = SmallestAxis(vecSize);
+ vecSize[iSmallest] = 1;
+ float flVolume = vecSize.x * vecSize.y * vecSize.z;
+ int iMaxSize = floor( flVolume / (32.0*32.0) );
+ pBreakableInterface->SetMaxBreakableSize( iMaxSize );
+
+ // Now parse our interactions
+ for ( int i = 0; i < PROPINTER_NUM_INTERACTIONS; i++ )
+ {
+ // If we hit this assert, we have too many interactions for our current storage solution to handle
+ Assert( i < 32 );
+
+ propdata_interaction_s *pInteraction = &sPropdataInteractionSections[i];
+
+ KeyValues *pkvCurrentInter = pInteractionSection->FindKey( pInteraction->pszSectionName );
+ if ( pkvCurrentInter )
+ {
+ char const *pszInterBase = pkvCurrentInter->GetString( pInteraction->pszKeyName );
+ if ( pszInterBase && pszInterBase[0] && !stricmp( pszInterBase, pInteraction->pszValue ) )
+ {
+ pBreakableInterface->SetInteraction( (propdata_interactions_t)i );
+ }
+ }
+ }
+
+ // If the base said we're allowed to be static, return that
+ if ( iBaseResult == PARSE_SUCCEEDED_ALLOWED_STATIC )
+ return PARSE_SUCCEEDED_ALLOWED_STATIC;
+
+ // Otherwise, see if our propdata says we are allowed to be static
+ if ( pSection->GetInt( "allowstatic", 0 ) )
+ return PARSE_SUCCEEDED_ALLOWED_STATIC;
+
+ return PARSE_SUCCEEDED;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Fill out a prop's with base data parsed from the propdata file
+//-----------------------------------------------------------------------------
+int CPropData::ParsePropFromBase( CBaseEntity *pProp, const char *pszPropData )
+{
+ if ( !m_bPropDataLoaded )
+ return PARSE_FAILED_NO_DATA;
+
+ IBreakableWithPropData *pBreakableInterface = dynamic_cast<IBreakableWithPropData*>(pProp);
+
+ if ( !pBreakableInterface )
+ {
+ return PARSE_FAILED_BAD_DATA;
+ }
+
+ if ( !m_pKVPropData )
+ {
+ return PARSE_FAILED_BAD_DATA;
+ }
+
+ // Find the specified propdata
+ KeyValues *pSection = m_pKVPropData->FindKey( pszPropData );
+ if ( !pSection )
+ {
+ Warning("%s '%s' has a base specified as '%s', but there is no matching entry in propdata.txt.\n", pProp->GetClassname(), STRING( pProp->GetModelName() ), pszPropData );
+ return PARSE_FAILED_BAD_DATA;
+ }
+
+ // Store off the first base data for debugging
+ if ( pBreakableInterface->GetBasePropData() == NULL_STRING )
+ {
+ pBreakableInterface->SetBasePropData( AllocPooledString( pszPropData ) );
+ }
+
+ return ParsePropFromKV( pProp, pSection, pSection );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+const char *CPropData::GetRandomChunkModel( const char *pszBreakableSection, int iMaxSize )
+{
+ if ( !m_bPropDataLoaded )
+ return NULL;
+
+ // Find the right section
+ int iCount = m_BreakableChunks.Count();
+ int i;
+ for ( i = 0; i < iCount; i++ )
+ {
+ if ( !Q_strncmp( STRING(m_BreakableChunks[i].iszChunkType), pszBreakableSection, strlen(pszBreakableSection) ) )
+ break;
+ }
+ if ( i == iCount )
+ return NULL;
+
+ // Now pick a random one and return it
+ int iRandom;
+ if ( iMaxSize == -1 )
+ {
+ iRandom = RandomInt( 0, m_BreakableChunks[i].iszChunkModels.Count()-1 );
+ }
+ else
+ {
+ // Don't pick anything over the specified size
+ iRandom = RandomInt( 0, MIN(iMaxSize, m_BreakableChunks[i].iszChunkModels.Count()-1) );
+ }
+
+ return STRING(m_BreakableChunks[i].iszChunkModels[iRandom]);
+}
+
+
+// ensure that a model name from a qc file is properly formatted
+static const char *FixupModelName( char *pOut, int sizeOut, const char *pModelNameIn )
+{
+ char tmp[1024];
+
+ Q_strncpy( tmp, pModelNameIn, sizeof(tmp) );
+ if ( Q_strnicmp( tmp, "models/", 7 ) )
+ {
+ Q_snprintf( pOut, sizeOut, "models/%s" , tmp );
+ }
+ else
+ {
+ Q_strncpy( pOut, tmp, sizeOut);
+ }
+ int len = Q_strlen(pOut);
+ if ( len < 4 || Q_stricmp( pOut + (len-4), ".mdl" ) )
+ {
+ Q_strncat( pOut, ".mdl", sizeOut, COPY_ALL_CHARACTERS );
+ }
+
+ return pOut;
+}
+
+
+//-----------------------------------------------------------------------------
+// breakable prop functions
+//-----------------------------------------------------------------------------
+//
+//-----------------------------------------------------------------------------
+// list of models to break into
+class CBreakParser : public IVPhysicsKeyHandler
+{
+public:
+ CBreakParser( float defaultBurstScale, int defaultCollisionGroup )
+ : m_defaultBurstScale(defaultBurstScale), m_defaultCollisionGroup(defaultCollisionGroup) {}
+
+ void ParseModelName( breakmodel_t *pModel, const char *pValue )
+ {
+ FixupModelName( pModel->modelName, sizeof(pModel->modelName), pValue );
+ }
+ virtual void ParseKeyValue( void *pData, const char *pKey, const char *pValue )
+ {
+ breakmodel_t *pModel = (breakmodel_t *)pData;
+ if ( !strcmpi( pKey, "model" ) )
+ {
+ ParseModelName( pModel, pValue );
+ }
+ else if (!strcmpi( pKey, "ragdoll" ) )
+ {
+ ParseModelName( pModel, pValue );
+ pModel->isRagdoll = true;
+ }
+ else if (!strcmpi( pKey, "motiondisabled" ) )
+ {
+ pModel->isMotionDisabled = true;
+ }
+ else if ( !strcmpi( pKey, "offset" ) )
+ {
+ UTIL_StringToVector( pModel->offset.Base(), pValue );
+ }
+ else if ( !strcmpi( pKey, "health" ) )
+ {
+ pModel->health = atof(pValue);
+ }
+ else if ( !strcmpi( pKey, "fadetime" ) )
+ {
+ pModel->fadeTime = atof(pValue);
+ if ( !m_wroteCollisionGroup )
+ {
+ pModel->collisionGroup = COLLISION_GROUP_DEBRIS;
+ }
+ }
+ else if ( !strcmpi( pKey, "fademindist" ) )
+ {
+ pModel->fadeMinDist = atof(pValue);
+ }
+ else if ( !strcmpi( pKey, "fademaxdist" ) )
+ {
+ pModel->fadeMaxDist = atof(pValue);
+ }
+ else if ( !strcmpi( pKey, "debris" ) )
+ {
+ pModel->collisionGroup = atoi(pValue) > 0 ? COLLISION_GROUP_DEBRIS : COLLISION_GROUP_INTERACTIVE;
+ m_wroteCollisionGroup = true;
+ }
+ else if ( !strcmpi( pKey, "burst" ) )
+ {
+ pModel->burstScale = atof( pValue );
+ }
+ else if ( !strcmpi( pKey, "placementbone" ) )
+ {
+ Q_strncpy( pModel->placementName, pValue, sizeof(pModel->placementName) );
+ pModel->placementIsBone = true;
+ }
+ else if ( !strcmpi( pKey, "placementattachment" ) )
+ {
+ Q_strncpy( pModel->placementName, pValue, sizeof(pModel->placementName) );
+ pModel->placementIsBone = false;
+ }
+ else if ( !strcmpi( pKey, "multiplayer_break" ) )
+ {
+ if ( FStrEq( pValue, "server" ) )
+ {
+ pModel->mpBreakMode = MULTIPLAYER_BREAK_SERVERSIDE;
+ }
+ else if ( FStrEq( pValue, "client" ) )
+ {
+ pModel->mpBreakMode = MULTIPLAYER_BREAK_CLIENTSIDE;
+ }
+ }
+ }
+ virtual void SetDefaults( void *pData )
+ {
+ breakmodel_t *pModel = (breakmodel_t *)pData;
+ pModel->modelName[0] = 0;
+ pModel->offset = vec3_origin;
+ pModel->health = 1;
+ pModel->fadeTime = 20.0f;
+ pModel->fadeMinDist = 0.0f;
+ pModel->fadeMaxDist = 0.0f;
+ pModel->burstScale = m_defaultBurstScale;
+ pModel->collisionGroup = m_defaultCollisionGroup;
+ pModel->isRagdoll = false;
+ pModel->isMotionDisabled = false;
+ pModel->placementName[0] = 0;
+ pModel->placementIsBone = false;
+ pModel->mpBreakMode = MULTIPLAYER_BREAK_DEFAULT;
+ m_wroteCollisionGroup = false;
+ }
+
+private:
+ int m_defaultCollisionGroup;
+ float m_defaultBurstScale;
+ bool m_wroteCollisionGroup;
+};
+
+void BreakModelList( CUtlVector<breakmodel_t> &list, int modelindex, float defBurstScale, int defCollisionGroup )
+{
+ vcollide_t *pCollide = modelinfo->GetVCollide( modelindex );
+ if ( !pCollide )
+ return;
+
+ IVPhysicsKeyParser *pParse = physcollision->VPhysicsKeyParserCreate( pCollide->pKeyValues );
+ while ( !pParse->Finished() )
+ {
+ CBreakParser breakParser( defBurstScale, defCollisionGroup );
+
+ const char *pBlock = pParse->GetCurrentBlockName();
+ if ( !strcmpi( pBlock, "break" ) )
+ {
+ int index = list.AddToTail();
+ breakmodel_t &breakModel = list[index];
+ pParse->ParseCustom( &breakModel, &breakParser );
+ }
+ else
+ {
+ pParse->SkipBlock();
+ }
+ }
+ physcollision->VPhysicsKeyParserDestroy( pParse );
+}
+
+#if !defined(_STATIC_LINKED) || defined(CLIENT_DLL)
+int GetAutoMultiplayerPhysicsMode( Vector size, float mass )
+{
+ float volume = size.x * size.y * size.z;
+
+ float minsize = sv_pushaway_clientside_size.GetFloat();
+
+ // if it's too small, client side only
+ if ( volume < (minsize*minsize*minsize) )
+ return PHYSICS_MULTIPLAYER_CLIENTSIDE;
+
+ // if it's too light, no player pushback
+ if ( mass < 8.0 )
+ return PHYSICS_MULTIPLAYER_NON_SOLID;
+
+ // full pushbackmode
+ return PHYSICS_MULTIPLAYER_SOLID;
+}
+#else
+extern int GetAutoMultiplayerPhysicsMode( Vector size, float mass );
+#endif
+
+//-----------------------------------------------------------------------------
+// Purpose: Returns a string describing a real-world equivalent mass.
+// Input : flMass - mass in kg
+//-----------------------------------------------------------------------------
+#if !defined(_STATIC_LINKED) || defined(CLIENT_DLL)
+const char *GetMassEquivalent(float flMass)
+{
+ static struct
+ {
+ float flMass;
+ const char *sz;
+ } masstext[] =
+ {
+ { 5e-6, "snowflake" },
+ { 2.5e-3, "ping-pong ball" },
+ { 5e-3, "penny" },
+ { 0.05, "golf ball" },
+ { 0.17, "billard ball" },
+ { 2, "bag of sugar" },
+ { 7, "male cat" },
+ { 10, "bowling ball" },
+ { 30, "dog" },
+ { 60, "cheetah" },
+ { 90, "adult male human" },
+ { 250, "refrigerator" },
+ { 600, "race horse" },
+ { 1000, "small car" },
+ { 1650, "medium car" },
+ { 2500, "large car" },
+ { 6000, "t-rex" },
+ { 7200, "elephant" },
+ { 8e4, "space shuttle" },
+ { 7e5, "locomotive" },
+ { 9.2e6, "Eiffel tower" },
+ { 6e24, "the Earth" },
+ { 7e24, "really freaking heavy" },
+ };
+
+ for (int i = 0; i < sizeof(masstext) / sizeof(masstext[0]) - 1; i++)
+ {
+ if (flMass < masstext[i].flMass)
+ {
+ return masstext[i].sz;
+ }
+ }
+
+ return masstext[ sizeof(masstext) / sizeof(masstext[0]) - 1 ].sz;
+}
+#else
+extern const char *GetMassEquivalent(float flMass);
+#endif
+
+#ifdef GAME_DLL
+//=========================================================
+//=========================================================
+class CGameGibManager : public CBaseEntity
+{
+ DECLARE_CLASS( CGameGibManager, CBaseEntity );
+ DECLARE_DATADESC();
+
+public:
+
+ CGameGibManager() : m_iCurrentMaxPieces(-1), m_iMaxPieces(-1), m_iMaxPiecesDX8(-1) {}
+
+ void Activate( void );
+ void AddGibToLRU( CBaseAnimating *pEntity );
+
+ inline bool AllowedToSpawnGib( void );
+
+private:
+
+ void UpdateMaxPieces();
+
+ void InputSetMaxPieces( inputdata_t &inputdata );
+ void InputSetMaxPiecesDX8( inputdata_t &inputdata );
+
+ typedef CHandle<CBaseAnimating> CGibHandle;
+ CUtlLinkedList< CGibHandle > m_LRU;
+
+ bool m_bAllowNewGibs;
+
+ int m_iDXLevel;
+ int m_iCurrentMaxPieces;
+ int m_iMaxPieces;
+ int m_iMaxPiecesDX8;
+ int m_iLastFrame;
+};
+
+BEGIN_DATADESC( CGameGibManager )
+ // Silence perfidous classcheck!
+ //DEFINE_FIELD( m_iCurrentMaxPieces, FIELD_INTEGER ),
+ //DEFINE_FIELD( m_iLastFrame, FIELD_INTEGER ),
+ //DEFINE_FIELD( m_iDXLevel, FIELD_INTEGER ),
+ DEFINE_KEYFIELD( m_iMaxPieces, FIELD_INTEGER, "maxpieces" ),
+ DEFINE_KEYFIELD( m_iMaxPiecesDX8, FIELD_INTEGER, "maxpiecesdx8" ),
+ DEFINE_KEYFIELD( m_bAllowNewGibs, FIELD_BOOLEAN, "allownewgibs" ),
+
+ DEFINE_INPUTFUNC( FIELD_INTEGER, "SetMaxPieces", InputSetMaxPieces ),
+ DEFINE_INPUTFUNC( FIELD_INTEGER, "SetMaxPiecesDX8", InputSetMaxPiecesDX8 ),
+END_DATADESC()
+
+LINK_ENTITY_TO_CLASS( game_gib_manager, CGameGibManager );
+
+
+void CGameGibManager::Activate( void )
+{
+ m_LRU.Purge();
+
+ // Cache off the DX level for use later.
+ ConVarRef mat_dxlevel( "mat_dxlevel" );
+ m_iDXLevel = mat_dxlevel.GetInt();
+
+ UpdateMaxPieces();
+
+ BaseClass::Activate();
+}
+
+void CGameGibManager::UpdateMaxPieces()
+{
+ // If we're running DX8, use the DX8 gib limit if set.
+ if ( ( m_iDXLevel < 90 ) && ( m_iMaxPiecesDX8 >= 0 ) )
+ {
+ m_iCurrentMaxPieces = m_iMaxPiecesDX8;
+ }
+ else
+ {
+ m_iCurrentMaxPieces = m_iMaxPieces;
+ }
+}
+
+
+bool CGameGibManager::AllowedToSpawnGib( void )
+{
+ if ( m_bAllowNewGibs )
+ return true;
+
+ // We're not tracking gibs at the moment
+ if ( m_iCurrentMaxPieces < 0 )
+ return true;
+
+ if ( m_iCurrentMaxPieces == 0 )
+ return false;
+
+ if ( m_iLastFrame == gpGlobals->framecount )
+ {
+ if ( m_LRU.Count() >= m_iCurrentMaxPieces )
+ {
+ return false;
+ }
+ }
+
+ return true;
+}
+
+void CGameGibManager::InputSetMaxPieces( inputdata_t &inputdata )
+{
+ m_iMaxPieces = inputdata.value.Int();
+ UpdateMaxPieces();
+}
+
+void CGameGibManager::InputSetMaxPiecesDX8( inputdata_t &inputdata )
+{
+ m_iMaxPiecesDX8 = inputdata.value.Int();
+ UpdateMaxPieces();
+}
+
+void CGameGibManager::AddGibToLRU( CBaseAnimating *pEntity )
+{
+ int i, next;
+
+ if ( pEntity == NULL )
+ return;
+
+ //Find stale gibs.
+ for ( i = m_LRU.Head(); i < m_LRU.InvalidIndex(); i = next )
+ {
+ next = m_LRU.Next(i);
+
+ if ( m_LRU[i].Get() == NULL )
+ {
+ m_LRU.Remove(i);
+ }
+ }
+
+ // We're not tracking gibs at the moment
+ if ( m_iCurrentMaxPieces <= 0 )
+ return;
+
+ while ( m_LRU.Count() >= m_iCurrentMaxPieces )
+ {
+ i = m_LRU.Head();
+
+ //TODO: Make this fade out instead of pop.
+ UTIL_Remove( m_LRU[i] );
+ m_LRU.Remove(i);
+ }
+
+ m_LRU.AddToTail( pEntity );
+ m_iLastFrame = gpGlobals->framecount;
+}
+
+EHANDLE g_hGameGibManager;
+
+CGameGibManager *GetGibManager( void )
+{
+#ifndef HL2_EPISODIC
+ return NULL;
+#endif
+
+ if ( g_hGameGibManager == NULL )
+ {
+ g_hGameGibManager = (CGameGibManager *)gEntList.FindEntityByClassname( NULL, "game_gib_manager" );
+ }
+
+ return (CGameGibManager *)g_hGameGibManager.Get();
+}
+
+#endif
+
+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 );
+ }
+ }
+ }
+ }
+ }
+}
+
+
+void PropBreakableCreateAll( int modelindex, IPhysicsObject *pPhysics, const Vector &origin, const QAngle &angles, const Vector &velocity, const AngularImpulse &angularVelocity, float impactEnergyScale, float defBurstScale, int defCollisionGroup, CBaseEntity *pEntity, bool defaultLocation )
+{
+ breakablepropparams_t params( origin, angles, velocity, angularVelocity );
+ params.impactEnergyScale = impactEnergyScale;
+ params.defBurstScale = defBurstScale;
+ params.defCollisionGroup = defCollisionGroup;
+ PropBreakableCreateAll( modelindex, pPhysics, params, pEntity, -1, false, defaultLocation );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+// Input : modelindex -
+//-----------------------------------------------------------------------------
+void PrecacheGibsForModel( int iModel )
+{
+ VPROF_BUDGET( "PrecacheGibsForModel", VPROF_BUDGETGROUP_PLAYER );
+ vcollide_t *pCollide = modelinfo->GetVCollide( iModel );
+ if ( !pCollide )
+ return;
+
+ // The scale and group doesn't really matter at the moment, we are just using the parser to get the model name to cache.
+ CBreakParser breakParser( 1.0, COLLISION_GROUP_NONE );
+
+ // Create a parser.
+ IVPhysicsKeyParser *pParse = physcollision->VPhysicsKeyParserCreate( pCollide->pKeyValues );
+ while ( !pParse->Finished() )
+ {
+ const char *pBlock = pParse->GetCurrentBlockName();
+ if ( !strcmpi( pBlock, "break" ) )
+ {
+ breakmodel_t breakModel;
+ pParse->ParseCustom( &breakModel, &breakParser );
+ CBaseEntity::PrecacheModel( breakModel.modelName );
+ }
+ else
+ {
+ pParse->SkipBlock();
+ }
+ }
+
+ // Destroy the parser.
+ physcollision->VPhysicsKeyParserDestroy( pParse );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+// Input : &list -
+// modelindex -
+// defBurstScale -
+// defCollisionGroup -
+//-----------------------------------------------------------------------------
+void BuildGibList( CUtlVector<breakmodel_t> &list, int modelindex, float defBurstScale, int defCollisionGroup )
+{
+ BreakModelList( list, modelindex, defBurstScale, defCollisionGroup );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+// Input : &list -
+// modelindex -
+// *pPhysics -
+// ¶ms -
+// *pEntity -
+// iPrecomputedBreakableCount -
+// bIgnoreGibLImit -
+// defaultLocation -
+//-----------------------------------------------------------------------------
+CBaseEntity *CreateGibsFromList( CUtlVector<breakmodel_t> &list, int modelindex, IPhysicsObject *pPhysics, const breakablepropparams_t ¶ms, CBaseEntity *pEntity, int iPrecomputedBreakableCount, bool bIgnoreGibLimit, bool defaultLocation, CUtlVector<EHANDLE> *pGibList, bool bBurning )
+{
+ // 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 NULL;
+ }
+
+ 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 NULL;
+ }
+#endif
+
+ vcollide_t *pCollide = modelinfo->GetVCollide( modelindex );
+ if ( !pCollide )
+ return NULL;
+
+ int nSkin = 0;
+ CBaseEntity *pOwnerEntity = pEntity;
+ CBaseAnimating *pOwnerAnim = NULL;
+ if ( pPhysics )
+ {
+ pOwnerEntity = static_cast<CBaseEntity *>(pPhysics->GetGameData());
+ }
+ if ( pOwnerEntity )
+ {
+ pOwnerAnim = dynamic_cast<CBaseAnimating*>(pOwnerEntity);
+ 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 );
+
+ CBaseEntity *pFirstBreakable = NULL;
+
+ 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;
+
+ float flScale = VectorNormalize( objectVelocity );
+ objectVelocity.x += RandomFloat( -1.f, 1.0f );
+ objectVelocity.y += RandomFloat( -1.0f, 1.0f );
+ objectVelocity.z += RandomFloat( 0.0f, 1.0f );
+ VectorNormalize( objectVelocity );
+ objectVelocity *= flScale;
+
+ 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
+
+#ifndef GAME_DLL
+ if ( bBurning && cl_burninggibs.GetBool() )
+ {
+ pBreakable->ParticleProp()->Create( "burninggibs", PATTACH_POINT_FOLLOW, "bloodpoint" );
+ }
+#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 );
+ }
+ }
+
+ if ( !pFirstBreakable )
+ {
+ pFirstBreakable = pBreakable;
+ }
+
+ if ( pGibList )
+ {
+ pGibList->AddToTail( pBreakable );
+ }
+ }
+ }
+ }
+ // 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 )
+ {
+#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 ( !pFirstBreakable )
+ {
+ pFirstBreakable = pBreakable;
+ }
+
+ if ( pGibList )
+ {
+ pGibList->AddToTail( pBreakable );
+ }
+ }
+ else
+ {
+ DevWarning( "PropBreakableCreateAll: Could not create model %s\n", breakModel.modelName );
+ }
+ }
+ }
+ }
+
+ return pFirstBreakable;
+}
+
|