mirror of
https://github.com/nillerusr/source-engine.git
synced 2024-12-23 06:36:54 +00:00
1296 lines
37 KiB
C++
1296 lines
37 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
//
|
|
// Purpose: A planar textured surface that breaks into increasingly smaller fragments
|
|
// as it takes damage. Undamaged pieces remain attached to the world
|
|
// until they are damaged. Used for window panes.
|
|
//
|
|
// $NoKeywords: $
|
|
//=============================================================================//
|
|
|
|
#include "cbase.h"
|
|
#include "ndebugoverlay.h"
|
|
#include "filters.h"
|
|
#include "player.h"
|
|
#include "func_breakablesurf.h"
|
|
#include "shattersurfacetypes.h"
|
|
#include "materialsystem/imaterialsystem.h"
|
|
#include "materialsystem/imaterial.h"
|
|
#include "materialsystem/imaterialvar.h"
|
|
#include "globals.h"
|
|
#include "physics_impact_damage.h"
|
|
#include "te_effect_dispatch.h"
|
|
|
|
//=============================================================================
|
|
// HPE_BEGIN
|
|
// [dwenger] Necessary for stats tracking
|
|
//=============================================================================
|
|
#include "gamestats.h"
|
|
//=============================================================================
|
|
// HPE_END
|
|
//=============================================================================
|
|
|
|
// memdbgon must be the last include file in a .cpp file!!!
|
|
#include "tier0/memdbgon.h"
|
|
|
|
// Spawn flags
|
|
#define SF_BREAKABLESURF_CRACK_DECALS 0x00000001
|
|
#define SF_BREAKABLESURF_DAMAGE_FROM_HELD_OBJECTS 0x00000002
|
|
|
|
//#############################################################################
|
|
// > CWindowPane
|
|
//#############################################################################
|
|
#define WINDOW_PANEL_SIZE 12
|
|
#define WINDOW_SMALL_SHARD_SIZE 4
|
|
#define WINDOW_LARGE_SHARD_SIZE 7
|
|
#define WINDOW_MAX_SUPPORT 6.75
|
|
#define WINDOW_BREAK_SUPPORT 0.20
|
|
|
|
#define WINDOW_PANE_BROKEN -1
|
|
#define WINDOW_PANE_HEALTHY 1
|
|
|
|
// Also defined in WC
|
|
#define QUAD_ERR_NONE 0
|
|
#define QUAD_ERR_MULT_FACES 1
|
|
#define QUAD_ERR_NOT_QUAD 2
|
|
|
|
//
|
|
// func_breakable - bmodel that breaks into pieces after taking damage
|
|
//
|
|
LINK_ENTITY_TO_CLASS( window_pane, CWindowPane );
|
|
BEGIN_DATADESC( CWindowPane )
|
|
|
|
// Function Pointers
|
|
DEFINE_FUNCTION( Die ),
|
|
DEFINE_FUNCTION( PaneTouch ),
|
|
|
|
END_DATADESC()
|
|
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Purpose :
|
|
// Input :
|
|
// Output :
|
|
//------------------------------------------------------------------------------
|
|
void CWindowPane::Spawn( void )
|
|
{
|
|
Precache( );
|
|
|
|
SetSolid( SOLID_BBOX );
|
|
SetMoveType( MOVETYPE_FLYGRAVITY );
|
|
m_takedamage = DAMAGE_YES;
|
|
|
|
SetCollisionGroup( COLLISION_GROUP_BREAKABLE_GLASS );
|
|
|
|
SetModel( "models/brokenglass_piece.mdl" );//set size and link into world.
|
|
}
|
|
|
|
void CWindowPane::Precache( void )
|
|
{
|
|
PrecacheModel( "models/brokenglass_piece.mdl" );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : pOther -
|
|
//-----------------------------------------------------------------------------
|
|
void CWindowPane::PaneTouch( CBaseEntity *pOther )
|
|
{
|
|
if (pOther &&
|
|
pOther->GetCollisionGroup() != COLLISION_GROUP_BREAKABLE_GLASS)
|
|
{
|
|
Die();
|
|
}
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Purpose :
|
|
// Input :
|
|
// Output :
|
|
//------------------------------------------------------------------------------
|
|
void CWindowPane::Die( void )
|
|
{
|
|
CPASFilter filter( GetAbsOrigin() );
|
|
te->ShatterSurface( filter, 0.0,
|
|
&GetAbsOrigin(), &GetAbsAngles(),
|
|
&GetAbsVelocity(), &GetAbsOrigin(),
|
|
WINDOW_PANEL_SIZE, WINDOW_PANEL_SIZE,WINDOW_SMALL_SHARD_SIZE,SHATTERSURFACE_GLASS,
|
|
255,255,255,255,255,255);
|
|
|
|
UTIL_Remove(this);
|
|
}
|
|
|
|
///------------------------------------------------------------------------------
|
|
// Purpose :
|
|
// Input :
|
|
// Output :
|
|
//------------------------------------------------------------------------------
|
|
CWindowPane* CWindowPane::CreateWindowPane( const Vector &vecOrigin, const QAngle &vecAngles )
|
|
{
|
|
CWindowPane *pGlass = (CWindowPane*)CreateEntityByName( "window_pane" );
|
|
if ( !pGlass )
|
|
{
|
|
Msg( "NULL Ent in CreateWindowPane!\n" );
|
|
return NULL;
|
|
}
|
|
|
|
if ( pGlass->edict() )
|
|
{
|
|
pGlass->SetLocalOrigin( vecOrigin );
|
|
pGlass->SetLocalAngles( vecAngles );
|
|
pGlass->Spawn();
|
|
pGlass->SetTouch(&CWindowPane::PaneTouch);
|
|
pGlass->SetLocalAngularVelocity( RandomAngle(-50,50) );
|
|
pGlass->m_nBody = random->RandomInt(0,2);
|
|
}
|
|
return pGlass;
|
|
}
|
|
|
|
|
|
//####################################################################################
|
|
// > CBreakableSurface
|
|
//####################################################################################
|
|
LINK_ENTITY_TO_CLASS( func_breakable_surf, CBreakableSurface );
|
|
|
|
BEGIN_DATADESC( CBreakableSurface )
|
|
|
|
DEFINE_KEYFIELD( m_nSurfaceType, FIELD_INTEGER, "surfacetype"),
|
|
DEFINE_KEYFIELD( m_nFragility, FIELD_INTEGER, "fragility"),
|
|
DEFINE_KEYFIELD( m_vLLVertex, FIELD_VECTOR, "lowerleft" ),
|
|
DEFINE_KEYFIELD( m_vULVertex, FIELD_VECTOR, "upperleft" ),
|
|
DEFINE_KEYFIELD( m_vLRVertex, FIELD_VECTOR, "lowerright" ),
|
|
DEFINE_KEYFIELD( m_vURVertex, FIELD_VECTOR, "upperright" ),
|
|
DEFINE_KEYFIELD( m_nQuadError, FIELD_INTEGER, "error" ),
|
|
|
|
DEFINE_FIELD( m_nNumWide, FIELD_INTEGER),
|
|
DEFINE_FIELD( m_nNumHigh, FIELD_INTEGER),
|
|
DEFINE_FIELD( m_flPanelWidth, FIELD_FLOAT),
|
|
DEFINE_FIELD( m_flPanelHeight, FIELD_FLOAT),
|
|
DEFINE_FIELD( m_vNormal, FIELD_VECTOR),
|
|
DEFINE_FIELD( m_vCorner, FIELD_POSITION_VECTOR),
|
|
DEFINE_FIELD( m_bIsBroken, FIELD_BOOLEAN),
|
|
DEFINE_FIELD( m_nNumBrokenPanes, FIELD_INTEGER),
|
|
|
|
// UNDONE: How to load save this? Need a way to update
|
|
// the client about the state of the window upon load...
|
|
// We should use client-side save/load to fix this problem.
|
|
DEFINE_AUTO_ARRAY2D( m_flSupport, FIELD_FLOAT),
|
|
DEFINE_ARRAY( m_RawPanelBitVec, FIELD_BOOLEAN, MAX_NUM_PANELS*MAX_NUM_PANELS ),
|
|
|
|
// Function Pointers
|
|
DEFINE_THINKFUNC( BreakThink ),
|
|
DEFINE_ENTITYFUNC( SurfaceTouch ),
|
|
|
|
DEFINE_INPUTFUNC( FIELD_VECTOR, "Shatter", InputShatter ),
|
|
|
|
// DEFINE_FIELD( m_ForceUpdateClientData, CBitVec < MAX_PLAYERS > ), // No need to save/restore this, it's just a temporary flag field
|
|
END_DATADESC()
|
|
|
|
|
|
IMPLEMENT_SERVERCLASS_ST(CBreakableSurface, DT_BreakableSurface)
|
|
SendPropInt(SENDINFO(m_nNumWide), 8, SPROP_UNSIGNED),
|
|
SendPropInt(SENDINFO(m_nNumHigh), 8, SPROP_UNSIGNED),
|
|
SendPropFloat(SENDINFO(m_flPanelWidth), 0, SPROP_NOSCALE),
|
|
SendPropFloat(SENDINFO(m_flPanelHeight), 0, SPROP_NOSCALE),
|
|
SendPropVector(SENDINFO(m_vNormal), -1, SPROP_COORD),
|
|
SendPropVector(SENDINFO(m_vCorner), -1, SPROP_COORD),
|
|
SendPropInt(SENDINFO(m_bIsBroken), 1, SPROP_UNSIGNED),
|
|
SendPropInt(SENDINFO(m_nSurfaceType), 2, SPROP_UNSIGNED),
|
|
SendPropArray3(SENDINFO_ARRAY3(m_RawPanelBitVec), SendPropInt( SENDINFO_ARRAY( m_RawPanelBitVec ), 1, SPROP_UNSIGNED ) ),
|
|
END_SEND_TABLE()
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CBreakableSurface::Precache(void)
|
|
{
|
|
UTIL_PrecacheOther( "window_pane" );
|
|
|
|
// Load the edge types and styles for the specific surface type
|
|
if (m_nSurfaceType == SHATTERSURFACE_TILE)
|
|
{
|
|
PrecacheMaterial( "models/brokentile/tilebroken_03a" );
|
|
PrecacheMaterial( "models/brokentile/tilebroken_03b" );
|
|
PrecacheMaterial( "models/brokentile/tilebroken_03c" );
|
|
PrecacheMaterial( "models/brokentile/tilebroken_03d" );
|
|
|
|
PrecacheMaterial( "models/brokentile/tilebroken_02a" );
|
|
PrecacheMaterial( "models/brokentile/tilebroken_02b" );
|
|
PrecacheMaterial( "models/brokentile/tilebroken_02c" );
|
|
PrecacheMaterial( "models/brokentile/tilebroken_02d" );
|
|
|
|
PrecacheMaterial( "models/brokentile/tilebroken_01a" );
|
|
PrecacheMaterial( "models/brokentile/tilebroken_01b" );
|
|
PrecacheMaterial( "models/brokentile/tilebroken_01c" );
|
|
PrecacheMaterial( "models/brokentile/tilebroken_01d" );
|
|
}
|
|
else
|
|
{
|
|
PrecacheMaterial( "models/brokenglass/glassbroken_solid" );
|
|
PrecacheMaterial( "models/brokenglass/glassbroken_01a" );
|
|
PrecacheMaterial( "models/brokenglass/glassbroken_01b" );
|
|
PrecacheMaterial( "models/brokenglass/glassbroken_01c" );
|
|
PrecacheMaterial( "models/brokenglass/glassbroken_01d" );
|
|
PrecacheMaterial( "models/brokenglass/glassbroken_02a" );
|
|
PrecacheMaterial( "models/brokenglass/glassbroken_02b" );
|
|
PrecacheMaterial( "models/brokenglass/glassbroken_02c" );
|
|
PrecacheMaterial( "models/brokenglass/glassbroken_02d" );
|
|
PrecacheMaterial( "models/brokenglass/glassbroken_03a" );
|
|
PrecacheMaterial( "models/brokenglass/glassbroken_03b" );
|
|
PrecacheMaterial( "models/brokenglass/glassbroken_03c" );
|
|
PrecacheMaterial( "models/brokenglass/glassbroken_03d" );
|
|
}
|
|
|
|
BaseClass::Precache();
|
|
}
|
|
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Purpose : Window has been touched. Break out pieces based on touching
|
|
// entity's bounding box
|
|
// Input :
|
|
// Output :
|
|
//------------------------------------------------------------------------------
|
|
void CBreakableSurface::SurfaceTouch( CBaseEntity *pOther )
|
|
{
|
|
// If tile only break if object is moving fast
|
|
if (m_nSurfaceType == SHATTERSURFACE_TILE)
|
|
{
|
|
Vector vVel;
|
|
pOther->GetVelocity( &vVel, NULL );
|
|
if (vVel.Length() < 500)
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
|
|
// Find nearest point on plane for max
|
|
Vector vecAbsMins, vecAbsMaxs;
|
|
pOther->CollisionProp()->WorldSpaceAABB( &vecAbsMins, &vecAbsMaxs );
|
|
Vector vToPlane = (vecAbsMaxs - m_vCorner);
|
|
float vDistToPlane = DotProduct(m_vNormal,vToPlane);
|
|
Vector vTouchPos = vecAbsMaxs + vDistToPlane*m_vNormal;
|
|
|
|
float flMinsWidth,flMinsHeight;
|
|
PanePos(vTouchPos, &flMinsWidth, &flMinsHeight);
|
|
|
|
// Find nearest point on plane for mins
|
|
vToPlane = (vecAbsMins - m_vCorner);
|
|
vDistToPlane = DotProduct(m_vNormal,vToPlane);
|
|
vTouchPos = vecAbsMins + vDistToPlane*m_vNormal;
|
|
|
|
float flMaxsWidth,flMaxsHeight;
|
|
PanePos(vTouchPos, &flMaxsWidth, &flMaxsHeight);
|
|
|
|
int nMinWidth = Floor2Int(MAX(0, MIN(flMinsWidth,flMaxsWidth)));
|
|
int nMaxWidth = Ceil2Int(MIN(m_nNumWide,MAX(flMinsWidth,flMaxsWidth)));
|
|
|
|
int nMinHeight = Floor2Int(MAX(0, MIN(flMinsHeight,flMaxsHeight)));
|
|
int nMaxHeight = Ceil2Int(MIN(m_nNumHigh,MAX(flMinsHeight,flMaxsHeight)));
|
|
|
|
Vector vHitVel;
|
|
pOther->GetVelocity( &vHitVel, NULL );
|
|
|
|
// Move faster then penetrating object so can see shards
|
|
vHitVel *= 5;
|
|
|
|
// If I'm not broken yet, break me
|
|
if ( !m_bIsBroken )
|
|
{
|
|
Die( pOther, vHitVel );
|
|
}
|
|
|
|
for (int height=nMinHeight;height<nMaxHeight;height++)
|
|
{
|
|
// Randomly break the one before so it doesn't look square
|
|
if (random->RandomInt(0,1))
|
|
{
|
|
ShatterPane(nMinWidth-1, height,vHitVel,pOther->GetLocalOrigin());
|
|
}
|
|
for (int width=nMinWidth;width<nMaxWidth;width++)
|
|
{
|
|
ShatterPane(width, height,vHitVel,pOther->GetLocalOrigin());
|
|
}
|
|
// Randomly break the one after so it doesn't look square
|
|
if (random->RandomInt(0,1))
|
|
{
|
|
ShatterPane(nMaxWidth+1, height,vHitVel,pOther->GetLocalOrigin());
|
|
}
|
|
}
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Purpose : Only take damage in trace attack
|
|
// Input :
|
|
// Output :
|
|
//------------------------------------------------------------------------------
|
|
int CBreakableSurface::OnTakeDamage( const CTakeDamageInfo &info )
|
|
{
|
|
if ( !m_bIsBroken && info.GetDamageType() == DMG_CRUSH )
|
|
{
|
|
// physics will kill me now
|
|
Die( info.GetAttacker(), info.GetDamageForce() );
|
|
return 0;
|
|
}
|
|
|
|
if ( m_nSurfaceType == SHATTERSURFACE_GLASS && info.GetDamageType() & DMG_BLAST )
|
|
{
|
|
Vector vecDir = info.GetInflictor()->GetAbsOrigin() - WorldSpaceCenter();
|
|
VectorNormalize( vecDir );
|
|
Die( info.GetAttacker(), vecDir );
|
|
return 0;
|
|
}
|
|
|
|
// Accept slash damage, too. Manhacks and such.
|
|
if ( m_nSurfaceType == SHATTERSURFACE_GLASS && (info.GetDamageType() & DMG_SLASH) )
|
|
{
|
|
Die( info.GetAttacker(), info.GetDamageForce() );
|
|
return 0;
|
|
}
|
|
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Purpose: Accepts damage and breaks if health drops below zero.
|
|
//------------------------------------------------------------------------------
|
|
void CBreakableSurface::TraceAttack( const CTakeDamageInfo &info, const Vector &vecDir, trace_t *ptr, CDmgAccumulator *pAccumulator )
|
|
{
|
|
//=============================================================================
|
|
// HPE_BEGIN:
|
|
// [dwenger] Window break stat tracking
|
|
//=============================================================================
|
|
|
|
// Make sure this pane has not already been shattered
|
|
bool bWasBroken = m_bIsBroken;
|
|
|
|
//=============================================================================
|
|
// HPE_END
|
|
//=============================================================================
|
|
|
|
// Decrease health
|
|
m_iHealth -= info.GetDamage();
|
|
m_OnHealthChanged.Set( m_iHealth, info.GetAttacker(), this );
|
|
|
|
// If I'm not broken yet, break me
|
|
if (!m_bIsBroken )
|
|
{
|
|
Vector vSurfDir = ptr->endpos - ptr->startpos;
|
|
Die( info.GetAttacker(), vSurfDir );
|
|
}
|
|
|
|
if (info.GetDamageType() & (DMG_BULLET | DMG_CLUB))
|
|
{
|
|
// Figure out which panel has taken the damage and break it
|
|
float flWidth,flHeight;
|
|
PanePos(ptr->endpos,&flWidth,&flHeight);
|
|
int nWidth = flWidth;
|
|
int nHeight = flHeight;
|
|
|
|
if ( ShatterPane(nWidth, nHeight,vecDir*500,ptr->endpos) )
|
|
{
|
|
//=============================================================================
|
|
// HPE_BEGIN:
|
|
// [dwenger] Window break stat tracking
|
|
//=============================================================================
|
|
|
|
CBasePlayer* pAttacker = ToBasePlayer(info.GetAttacker());
|
|
if ( ( pAttacker ) && ( !bWasBroken ) )
|
|
{
|
|
gamestats->Event_WindowShattered( pAttacker );
|
|
}
|
|
|
|
//=============================================================================
|
|
// HPE_END
|
|
//=============================================================================
|
|
|
|
// Do an impact hit
|
|
CEffectData data;
|
|
|
|
data.m_vNormal = ptr->plane.normal;
|
|
data.m_vOrigin = ptr->endpos;
|
|
|
|
CPASFilter filter( data.m_vOrigin );
|
|
|
|
// client cannot trace against triggers
|
|
filter.SetIgnorePredictionCull( true );
|
|
|
|
te->DispatchEffect( filter, 0.0, data.m_vOrigin, "GlassImpact", data );
|
|
}
|
|
|
|
if (m_nSurfaceType == SHATTERSURFACE_GLASS)
|
|
{
|
|
// Break nearby panes if damages was near pane edge
|
|
float flWRem = flWidth - nWidth;
|
|
float flHRem = flHeight - nHeight;
|
|
|
|
if (flWRem > 0.8 && nWidth != m_nNumWide-1)
|
|
{
|
|
ShatterPane(nWidth+1, nHeight,vecDir*500,ptr->endpos);
|
|
}
|
|
else if (flWRem < 0.2 && nWidth != 0)
|
|
{
|
|
ShatterPane(nWidth-1, nHeight,vecDir*500,ptr->endpos);
|
|
}
|
|
if (flHRem > 0.8 && nHeight != m_nNumHigh-1)
|
|
{
|
|
ShatterPane(nWidth, nHeight+1,vecDir*500,ptr->endpos);
|
|
}
|
|
else if (flHRem < 0.2 && nHeight != 0)
|
|
{
|
|
ShatterPane(nWidth, nHeight-1,vecDir*500,ptr->endpos);
|
|
}
|
|
|
|
// Occasionally break the pane above me
|
|
if (random->RandomInt(0,1)==0)
|
|
{
|
|
ShatterPane(nWidth, nHeight+1,vecDir*1000,ptr->endpos);
|
|
// Occasionally break the pane above that
|
|
if (random->RandomInt(0,1)==0)
|
|
{
|
|
ShatterPane(nWidth, nHeight+2,vecDir*1000,ptr->endpos);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else if (info.GetDamageType() & (DMG_SONIC | DMG_BLAST))
|
|
{
|
|
// ----------------------------------------
|
|
// If it's tile blow out nearby tiles
|
|
// ----------------------------------------
|
|
if (m_nSurfaceType == SHATTERSURFACE_TILE)
|
|
{
|
|
// Figure out which panel has taken the damage and break it
|
|
float flWidth,flHeight;
|
|
if (info.GetAttacker())
|
|
{
|
|
PanePos(info.GetAttacker()->GetAbsOrigin(),&flWidth,&flHeight);
|
|
}
|
|
else
|
|
{
|
|
PanePos(ptr->endpos,&flWidth,&flHeight);
|
|
}
|
|
int nWidth = flWidth;
|
|
int nHeight = flHeight;
|
|
|
|
// Blow out a roughly circular patch of tile with some randomness
|
|
for (int width =nWidth-4;width<nWidth+4;width++)
|
|
{
|
|
for (int height =nHeight-4;height<nHeight+4;height++)
|
|
{
|
|
if ((abs(nWidth-width)+abs(nHeight-height))<random->RandomInt(2,5))
|
|
{
|
|
ShatterPane(width, height,vecDir*500,ptr->endpos);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
// ----------------------------------------
|
|
// If it's glass blow out the whole window
|
|
// ----------------------------------------
|
|
else
|
|
{
|
|
//=============================================================================
|
|
// HPE_BEGIN:
|
|
// [pfreese] Window break stat tracking
|
|
//=============================================================================
|
|
|
|
CBasePlayer* pAttacker = ToBasePlayer(info.GetAttacker());
|
|
if ( ( pAttacker ) && ( !bWasBroken ) )
|
|
{
|
|
gamestats->Event_WindowShattered( pAttacker );
|
|
}
|
|
|
|
//=============================================================================
|
|
// HPE_END
|
|
//=============================================================================
|
|
|
|
float flDot = DotProduct(m_vNormal,vecDir);
|
|
|
|
#ifdef CSTRIKE_DLL
|
|
float damageMultiplier = info.GetDamage();
|
|
#else
|
|
float damageMultiplier = 1.0f;
|
|
#endif
|
|
|
|
Vector vBlastDir;
|
|
if (flDot > 0)
|
|
{
|
|
vBlastDir = damageMultiplier * 3000 * m_vNormal;
|
|
}
|
|
else
|
|
{
|
|
vBlastDir = damageMultiplier * -3000 * m_vNormal;
|
|
}
|
|
|
|
// Has the window already been destroyed?
|
|
if (m_nNumBrokenPanes >= m_nNumWide*m_nNumHigh)
|
|
{
|
|
return;
|
|
}
|
|
// ---------------------------------------------------------------
|
|
// If less than 10% of my panels have been broken, blow me
|
|
// up in one large glass shatter
|
|
// ---------------------------------------------------------------
|
|
else if ( m_nNumBrokenPanes < 0.1*(m_nNumWide*m_nNumHigh))
|
|
{
|
|
QAngle vAngles;
|
|
VectorAngles(-1*m_vNormal,vAngles);
|
|
|
|
CreateShards(m_vCorner, vAngles,vBlastDir, ptr->endpos,
|
|
m_nNumWide*m_flPanelWidth, m_nNumHigh*m_flPanelHeight, WINDOW_LARGE_SHARD_SIZE);
|
|
}
|
|
// ---------------------------------------------------------------
|
|
// Otherwise break in the longest vertical strips possible
|
|
// (to cut down on the network bandwidth)
|
|
// ---------------------------------------------------------------
|
|
else
|
|
{
|
|
QAngle vAngles;
|
|
VectorAngles(-1*m_vNormal,vAngles);
|
|
Vector vWidthDir,vHeightDir;
|
|
AngleVectors(vAngles,NULL,&vWidthDir,&vHeightDir);
|
|
|
|
for (int width=0;width<m_nNumWide;width++)
|
|
{
|
|
int height;
|
|
int nHCount = 0;
|
|
for ( height=0;height<m_nNumHigh;height++)
|
|
{
|
|
// Keep count of how many panes
|
|
if (!IsBroken(width,height))
|
|
{
|
|
nHCount++;
|
|
}
|
|
// Shatter the strip and start counting again
|
|
else if (nHCount > 0)
|
|
{
|
|
Vector vBreakPos = m_vCorner +
|
|
(width*vWidthDir*m_flPanelWidth) +
|
|
((height-nHCount)*vHeightDir*m_flPanelHeight);
|
|
|
|
CreateShards(vBreakPos, vAngles,
|
|
vBlastDir, ptr->endpos,
|
|
m_flPanelWidth, nHCount*m_flPanelHeight,
|
|
WINDOW_LARGE_SHARD_SIZE);
|
|
|
|
nHCount = 0;
|
|
}
|
|
}
|
|
if (nHCount)
|
|
{
|
|
Vector vBreakPos = m_vCorner +
|
|
(width*vWidthDir*m_flPanelWidth) +
|
|
((height-nHCount)*vHeightDir*m_flPanelHeight);
|
|
|
|
CreateShards(vBreakPos, vAngles,
|
|
vBlastDir, ptr->endpos,
|
|
m_flPanelWidth,nHCount*m_flPanelHeight,
|
|
WINDOW_LARGE_SHARD_SIZE);
|
|
}
|
|
}
|
|
}
|
|
|
|
BreakAllPanes();
|
|
}
|
|
}
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Purpose: Break into panels
|
|
// Input : pBreaker -
|
|
// vDir -
|
|
//-----------------------------------------------------------------------------
|
|
void CBreakableSurface::Die( CBaseEntity *pBreaker, const Vector &vAttackDir )
|
|
{
|
|
if ( m_bIsBroken )
|
|
return;
|
|
|
|
// Play a break sound
|
|
PhysBreakSound( this, VPhysicsGetObject(), GetAbsOrigin() );
|
|
|
|
m_bIsBroken = true;
|
|
m_iHealth = 0.0f;
|
|
|
|
if (pBreaker)
|
|
{
|
|
m_OnBreak.FireOutput( pBreaker, this );
|
|
}
|
|
else
|
|
{
|
|
m_OnBreak.FireOutput( this, this );
|
|
}
|
|
|
|
float flDir = -1;
|
|
|
|
if ( vAttackDir.LengthSqr() > 0.001 )
|
|
{
|
|
float flDot = DotProduct( m_vNormal, vAttackDir );
|
|
if (flDot < 0)
|
|
{
|
|
m_vLLVertex += m_vNormal;
|
|
m_vLRVertex += m_vNormal;
|
|
m_vULVertex += m_vNormal;
|
|
m_vURVertex += m_vNormal;
|
|
m_vNormal *= -1;
|
|
flDir = 1;
|
|
}
|
|
}
|
|
|
|
// -------------------------------------------------------
|
|
// The surface has two sides, when we are killed pick
|
|
// the side that the damage came from
|
|
// -------------------------------------------------------
|
|
Vector vWidth = m_vLLVertex - m_vLRVertex;
|
|
Vector vHeight = m_vLLVertex - m_vULVertex;
|
|
CrossProduct( vWidth, vHeight, m_vNormal.GetForModify() );
|
|
VectorNormalize(m_vNormal.GetForModify());
|
|
|
|
// ---------------------------------------------------
|
|
// Make sure width and height are oriented correctly
|
|
// ---------------------------------------------------
|
|
QAngle vAngles;
|
|
VectorAngles(-1*m_vNormal,vAngles);
|
|
Vector vWidthDir,vHeightDir;
|
|
AngleVectors(vAngles,NULL,&vWidthDir,&vHeightDir);
|
|
|
|
float flWDist = DotProduct(vWidthDir,vWidth);
|
|
if (fabs(flWDist)<0.5)
|
|
{
|
|
Vector vSaveHeight = vHeight;
|
|
vHeight = vWidth * flDir;
|
|
vWidth = vSaveHeight * flDir;
|
|
}
|
|
|
|
// -------------------------------------------------
|
|
// Find which corner to use
|
|
// -------------------------------------------------
|
|
bool bLeft = (DotProduct(vWidthDir,vWidth) < 0);
|
|
bool bLower = (DotProduct(vHeightDir,vHeight) < 0);
|
|
if (bLeft)
|
|
{
|
|
m_vCorner = bLower ? m_vLLVertex : m_vULVertex;
|
|
}
|
|
else
|
|
{
|
|
m_vCorner = bLower ? m_vLRVertex : m_vURVertex;
|
|
}
|
|
|
|
// -------------------------------------------------
|
|
// Calculate the number of panels
|
|
// -------------------------------------------------
|
|
float flWidth = vWidth.Length();
|
|
float flHeight = vHeight.Length();
|
|
m_nNumWide = flWidth / WINDOW_PANEL_SIZE;
|
|
m_nNumHigh = flHeight / WINDOW_PANEL_SIZE;
|
|
|
|
// If to many panels make panel size bigger
|
|
if (m_nNumWide > MAX_NUM_PANELS) m_nNumWide = MAX_NUM_PANELS;
|
|
if (m_nNumHigh > MAX_NUM_PANELS) m_nNumHigh = MAX_NUM_PANELS;
|
|
|
|
m_flPanelWidth = flWidth / m_nNumWide;
|
|
m_flPanelHeight = flHeight / m_nNumHigh;
|
|
|
|
// Initialize panels
|
|
for (int w=0;w<MAX_NUM_PANELS;w++)
|
|
{
|
|
for (int h=0;h<MAX_NUM_PANELS;h++)
|
|
{
|
|
SetSupport( w, h, WINDOW_PANE_HEALTHY );
|
|
}
|
|
}
|
|
|
|
// Reset onground flags for any entity that may
|
|
// have been standing on me
|
|
ResetOnGroundFlags();
|
|
|
|
VPhysicsDestroyObject();
|
|
AddSolidFlags( FSOLID_TRIGGER );
|
|
AddSolidFlags( FSOLID_NOT_SOLID );
|
|
SetTouch(&CBreakableSurface::SurfaceTouch);
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Purpose: Set an instaneous force on the rope.
|
|
// Input : Force vector.
|
|
//------------------------------------------------------------------------------
|
|
void CBreakableSurface::InputShatter( inputdata_t &inputdata )
|
|
{
|
|
Vector vecShatterInfo;
|
|
inputdata.value.Vector3D(vecShatterInfo);
|
|
|
|
if (!m_bIsBroken)
|
|
{
|
|
Die( NULL, vec3_origin );
|
|
}
|
|
|
|
// Figure out which panel has taken the damage and break it
|
|
float flCenterX = vecShatterInfo.x * m_nNumWide;
|
|
float flCenterY = vecShatterInfo.y * m_nNumHigh;
|
|
|
|
// Bah: m_flPanelWidth is the width of a single panel
|
|
int nMinX = (int)(flCenterX - vecShatterInfo.z / m_flPanelWidth);
|
|
int nMaxX = (int)(flCenterX + vecShatterInfo.z / m_flPanelWidth) + 1;
|
|
if (nMinX < 0)
|
|
nMinX = 0;
|
|
if (nMaxX > m_nNumWide)
|
|
nMaxX = m_nNumWide;
|
|
|
|
int nMinY = (int)(flCenterY - vecShatterInfo.z / m_flPanelHeight);
|
|
int nMaxY = (int)(flCenterY + vecShatterInfo.z / m_flPanelHeight) + 1;
|
|
|
|
if (nMinY < 0)
|
|
nMinY = 0;
|
|
if (nMaxY > m_nNumHigh)
|
|
nMaxY = m_nNumHigh;
|
|
|
|
QAngle vAngles;
|
|
VectorAngles(-1*m_vNormal,vAngles);
|
|
Vector vWidthDir,vHeightDir;
|
|
AngleVectors(vAngles,NULL,&vWidthDir,&vHeightDir);
|
|
|
|
// Blow out a roughly circular of tile with some randomness
|
|
Vector2D vecActualCenter( flCenterX * m_flPanelWidth, flCenterY * m_flPanelHeight );
|
|
for (int width = nMinX; width < nMaxX; width++)
|
|
{
|
|
for (int height = nMinY; height < nMaxY; height++)
|
|
{
|
|
Vector2D pt( (width + 0.5f) * m_flPanelWidth, (height + 0.5f) * m_flPanelWidth );
|
|
if ( pt.DistToSqr(vecActualCenter) <= vecShatterInfo.z * vecShatterInfo.z )
|
|
{
|
|
Vector vBreakPos = m_vCorner +
|
|
(width*vWidthDir*m_flPanelWidth) +
|
|
(height*vHeightDir*m_flPanelHeight);
|
|
|
|
ShatterPane( width, height, m_vNormal * 500, vBreakPos );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Purpose :
|
|
// Input :
|
|
// Output :
|
|
//------------------------------------------------------------------------------
|
|
void CBreakableSurface::Event_Killed( CBaseEntity *pInflictor, CBaseEntity *pAttacker, float flDamage, int bitsDamageType )
|
|
{
|
|
return;
|
|
}
|
|
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Purpose :
|
|
// Input :
|
|
// Output :
|
|
//------------------------------------------------------------------------------
|
|
bool CBreakableSurface::IsBroken(int nWidth, int nHeight)
|
|
{
|
|
if (nWidth < 0 || nWidth >= m_nNumWide) return true;
|
|
if (nHeight < 0 || nHeight >= m_nNumHigh) return true;
|
|
|
|
return (m_flSupport[nWidth][nHeight]==WINDOW_PANE_BROKEN);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : w -
|
|
// h -
|
|
// support -
|
|
//-----------------------------------------------------------------------------
|
|
void CBreakableSurface::SetSupport( int w, int h, float support )
|
|
{
|
|
m_flSupport[ w ][ h ] = support;
|
|
|
|
int offset = w + h * m_nNumWide;
|
|
|
|
bool prevval = m_RawPanelBitVec.Get( offset );
|
|
bool curval = prevval;
|
|
|
|
if ( support < 0.0f )
|
|
{
|
|
curval = false;
|
|
}
|
|
else
|
|
{
|
|
curval = true;
|
|
}
|
|
if ( curval != prevval )
|
|
{
|
|
m_RawPanelBitVec.Set( offset, curval );
|
|
m_RawPanelBitVec.GetForModify( offset );
|
|
}
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Purpose :
|
|
// Input :
|
|
// Output :
|
|
//------------------------------------------------------------------------------
|
|
float CBreakableSurface::GetSupport(int nWidth, int nHeight)
|
|
{
|
|
return MAX(0,m_flSupport[nWidth][nHeight]);
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Purpose : Return the structural support for this pane. Assumes window
|
|
// is upright. Still works for windows parallel to the ground
|
|
// but simulation isn't quite as good
|
|
// Input :
|
|
// Output :
|
|
//------------------------------------------------------------------------------
|
|
float CBreakableSurface::RecalcSupport(int nWidth, int nHeight)
|
|
{
|
|
// Always has some support. Zero signifies that it has been broken
|
|
float flSupport = 0.01;
|
|
|
|
// ------------
|
|
// Top support
|
|
// ------------
|
|
if (nHeight == m_nNumHigh-1)
|
|
{
|
|
flSupport += 1.0;
|
|
}
|
|
else
|
|
{
|
|
flSupport += GetSupport(nWidth,nHeight+1);
|
|
}
|
|
|
|
// ------------
|
|
// Bottom Support
|
|
// ------------
|
|
if (nHeight == 0)
|
|
{
|
|
flSupport += 1.25;
|
|
}
|
|
else
|
|
{
|
|
flSupport += 1.25 * GetSupport(nWidth,nHeight-1);
|
|
}
|
|
|
|
// ------------
|
|
// Left Support
|
|
// ------------
|
|
if (nWidth == 0)
|
|
{
|
|
flSupport += 1.0;
|
|
}
|
|
else
|
|
{
|
|
flSupport += GetSupport(nWidth-1,nHeight);
|
|
}
|
|
|
|
// --------------
|
|
// Right Support
|
|
// --------------
|
|
if (nWidth == m_nNumWide-1)
|
|
{
|
|
flSupport += 1.0;
|
|
}
|
|
else
|
|
{
|
|
flSupport += GetSupport(nWidth+1,nHeight);
|
|
}
|
|
|
|
// --------------------
|
|
// Bottom Left Support
|
|
// --------------------
|
|
if (nHeight == 0 || nWidth == 0)
|
|
{
|
|
flSupport += 1.0;
|
|
}
|
|
else
|
|
{
|
|
flSupport += GetSupport(nWidth-1,nHeight-1);
|
|
}
|
|
|
|
// ---------------------
|
|
// Bottom Right Support
|
|
// ---------------------
|
|
if (nHeight == 0 || nWidth == m_nNumWide-1)
|
|
{
|
|
flSupport += 1.0;
|
|
}
|
|
else
|
|
{
|
|
flSupport += GetSupport(nWidth+1,nHeight-1);
|
|
}
|
|
|
|
// -----------------
|
|
// Top Right Support
|
|
// -----------------
|
|
if (nHeight == m_nNumHigh-1 || nWidth == m_nNumWide-1)
|
|
{
|
|
flSupport += 0.25;
|
|
}
|
|
else
|
|
{
|
|
flSupport += 0.25 * GetSupport(nWidth+1,nHeight+1);
|
|
}
|
|
|
|
// -----------------
|
|
// Top Left Support
|
|
// -----------------
|
|
if (nHeight == m_nNumHigh-1 || nWidth == 0)
|
|
{
|
|
flSupport += 0.25;
|
|
}
|
|
else
|
|
{
|
|
flSupport += 0.25 * GetSupport(nWidth-1,nHeight+1);
|
|
}
|
|
|
|
return flSupport;
|
|
}
|
|
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Purpose : Itterate through the panels and make sure none have become
|
|
// unstable
|
|
// Input :
|
|
// Output :
|
|
//------------------------------------------------------------------------------
|
|
void CBreakableSurface::BreakThink(void)
|
|
{
|
|
// Don't calculate support if I'm tile
|
|
if (m_nSurfaceType == SHATTERSURFACE_TILE)
|
|
{
|
|
return;
|
|
}
|
|
|
|
// -----------------------
|
|
// Recalculate all support
|
|
// -----------------------
|
|
int w;
|
|
float flSupport[MAX_NUM_PANELS][MAX_NUM_PANELS];
|
|
for (w=0;w<m_nNumWide;w++)
|
|
{
|
|
for (int h=0;h<m_nNumHigh;h++)
|
|
{
|
|
if (!IsBroken(w,h))
|
|
{
|
|
flSupport[w][h] = RecalcSupport(w,h);
|
|
}
|
|
}
|
|
}
|
|
|
|
// ----------------------------------------------------
|
|
// Set support and break inadequately supported panes
|
|
// ----------------------------------------------------
|
|
float flBreakValue = WINDOW_BREAK_SUPPORT*(m_nFragility/100.0);
|
|
for (w=0;w<m_nNumWide;w++)
|
|
{
|
|
for (int h=0;h<m_nNumHigh;h++)
|
|
{
|
|
if (!IsBroken(w,h))
|
|
{
|
|
SetSupport( w, h, flSupport[w][h]/WINDOW_MAX_SUPPORT );
|
|
if (m_flSupport[w][h] < flBreakValue)
|
|
{
|
|
// Occasionaly drop a pane
|
|
if (random->RandomInt(0,1))
|
|
{
|
|
DropPane(w,h);
|
|
}
|
|
// Otherwise just shatter the glass
|
|
else
|
|
{
|
|
ShatterPane(w,h,vec3_origin,vec3_origin);
|
|
}
|
|
SetNextThink( gpGlobals->curtime );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Purpose : Given a 3D position on the window in space return the height and
|
|
// width of the position from the window's corner
|
|
// Input :
|
|
// Output :
|
|
//------------------------------------------------------------------------------
|
|
void CBreakableSurface::PanePos(const Vector &vPos, float *flWidth, float *flHeight)
|
|
{
|
|
Vector vAttackVec = vPos - m_vCorner;
|
|
QAngle vAngles;
|
|
VectorAngles(-1*m_vNormal,vAngles);
|
|
Vector vWidthDir,vHeightDir;
|
|
AngleVectors(vAngles,NULL,&vWidthDir,&vHeightDir);
|
|
float flWDist = DotProduct(vWidthDir,vAttackVec);
|
|
float flHDist = DotProduct(vHeightDir,vAttackVec);
|
|
|
|
// Figure out which quadrent I'm in
|
|
*flWidth = flWDist/m_flPanelWidth;
|
|
*flHeight = flHDist/m_flPanelHeight;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Purpose :
|
|
// Input :
|
|
// Output :
|
|
//------------------------------------------------------------------------------
|
|
void CBreakableSurface::BreakAllPanes(void)
|
|
{
|
|
// Now tell the client all the panes have been broken
|
|
for (int width=0;width<m_nNumWide;width++)
|
|
{
|
|
for (int height=0;height<m_nNumHigh;height++)
|
|
{
|
|
//SetSupport( width, height, WINDOW_PANE_BROKEN );
|
|
|
|
BreakPane(width,height);
|
|
}
|
|
}
|
|
|
|
m_nNumBrokenPanes = m_nNumWide*m_nNumHigh;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Purpose : Drop a window pane entity
|
|
// Input :
|
|
// Output :
|
|
//------------------------------------------------------------------------------
|
|
void CBreakableSurface::BreakPane(int nWidth, int nHeight)
|
|
{
|
|
// Check parameter range
|
|
if (nWidth < 0 || nWidth >= m_nNumWide) return;
|
|
if (nHeight < 0 || nHeight >= m_nNumHigh) return;
|
|
|
|
// Count how many panes have been broken or dropped
|
|
m_nNumBrokenPanes++;
|
|
SetSupport( nWidth, nHeight, WINDOW_PANE_BROKEN );
|
|
|
|
SetThink(&CBreakableSurface::BreakThink);
|
|
SetNextThink( gpGlobals->curtime );
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Purpose : Drop a window pane entity
|
|
// Input :
|
|
// Output :
|
|
//------------------------------------------------------------------------------
|
|
void CBreakableSurface::DropPane(int nWidth, int nHeight)
|
|
{
|
|
// Check parameter range
|
|
if (nWidth < 0 || nWidth >= m_nNumWide) return;
|
|
if (nHeight < 0 || nHeight >= m_nNumHigh) return;
|
|
|
|
if (!IsBroken(nWidth,nHeight))
|
|
{
|
|
BreakPane(nWidth,nHeight);
|
|
|
|
QAngle vAngles;
|
|
VectorAngles(-1*m_vNormal,vAngles);
|
|
|
|
Vector vWidthDir,vHeightDir;
|
|
AngleVectors(vAngles,NULL,&vWidthDir,&vHeightDir);
|
|
Vector vBreakPos = m_vCorner +
|
|
(nWidth*vWidthDir*m_flPanelWidth) +
|
|
(nHeight*vHeightDir*m_flPanelHeight);
|
|
|
|
CreateShards(vBreakPos, vAngles, vec3_origin, vec3_origin,
|
|
WINDOW_PANEL_SIZE, WINDOW_PANEL_SIZE,
|
|
WINDOW_SMALL_SHARD_SIZE);
|
|
|
|
DamageSound();
|
|
|
|
CWindowPane *pPane = CWindowPane::CreateWindowPane(vBreakPos, vAngles);
|
|
if (pPane)
|
|
{
|
|
pPane->SetLocalAngularVelocity( RandomAngle(-120,120) );
|
|
}
|
|
}
|
|
}
|
|
|
|
void CBreakableSurface::CreateShards(const Vector &vBreakPos, const QAngle &vAngles,
|
|
const Vector &vForce, const Vector &vForcePos,
|
|
float flWidth, float flHeight,
|
|
int nShardSize)
|
|
{
|
|
Vector vAdjustedBreakPos = vBreakPos;
|
|
Vector vAdjustedForce = vForce;
|
|
int front_r,front_g,front_b;
|
|
int back_r,back_g,back_b;
|
|
|
|
|
|
// UNDONE: For now hardcode these colors. Later when used by more textures
|
|
// we'll automate this process or expose the colors in WC
|
|
if (m_nSurfaceType == SHATTERSURFACE_TILE)
|
|
{
|
|
// If tile shoot shards back from the shattered surface and offset slightly
|
|
// from the surface.
|
|
vAdjustedBreakPos -= 8*m_vNormal;
|
|
vAdjustedForce = -0.75*vForce;
|
|
front_r = 89;
|
|
front_g = 120;
|
|
front_b = 83;
|
|
back_r = 99;
|
|
back_g = 76;
|
|
back_b = 21;
|
|
}
|
|
else
|
|
{
|
|
front_r = 255;
|
|
front_g = 255;
|
|
front_b = 255;
|
|
back_r = 255;
|
|
back_g = 255;
|
|
back_b = 255;
|
|
}
|
|
|
|
CPASFilter filter( vAdjustedBreakPos );
|
|
te->ShatterSurface(filter, 0.0,
|
|
&vAdjustedBreakPos, &vAngles,
|
|
&vAdjustedForce, &vForcePos,
|
|
flWidth, flHeight,WINDOW_SMALL_SHARD_SIZE,m_nSurfaceType,
|
|
front_r,front_g,front_b,back_r,back_g,back_b);//4);
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Purpose : Break a panel
|
|
// Input :
|
|
// Output :
|
|
//------------------------------------------------------------------------------
|
|
bool CBreakableSurface::ShatterPane(int nWidth, int nHeight, const Vector &vForce, const Vector &vForcePos)
|
|
{
|
|
// Check parameter range
|
|
if (nWidth < 0 || nWidth >= m_nNumWide) return false;
|
|
if (nHeight < 0 || nHeight >= m_nNumHigh) return false;
|
|
|
|
if ( IsBroken(nWidth,nHeight) )
|
|
return false;
|
|
|
|
BreakPane(nWidth,nHeight);
|
|
|
|
QAngle vAngles;
|
|
VectorAngles(-1*m_vNormal,vAngles);
|
|
Vector vWidthDir,vHeightDir;
|
|
AngleVectors(vAngles,NULL,&vWidthDir,&vHeightDir);
|
|
Vector vBreakPos = m_vCorner +
|
|
(nWidth*vWidthDir*m_flPanelWidth) +
|
|
(nHeight*vHeightDir*m_flPanelHeight);
|
|
|
|
CreateShards(vBreakPos, vAngles,vForce, vForcePos, m_flPanelWidth, m_flPanelHeight, WINDOW_SMALL_SHARD_SIZE);
|
|
|
|
DamageSound();
|
|
return true;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Purpose :
|
|
// Input :
|
|
// Output :
|
|
//------------------------------------------------------------------------------
|
|
void CBreakableSurface::Spawn(void)
|
|
{
|
|
BaseClass::Spawn();
|
|
SetCollisionGroup( COLLISION_GROUP_BREAKABLE_GLASS );
|
|
m_bIsBroken = false;
|
|
|
|
if (m_nQuadError == QUAD_ERR_MULT_FACES)
|
|
{
|
|
Warning("Rejecting func_breakablesurf. Has multiple faces that aren't NODRAW.\n");
|
|
UTIL_Remove(this);
|
|
}
|
|
else if (m_nQuadError == QUAD_ERR_NOT_QUAD)
|
|
{
|
|
Warning("Rejecting func_breakablesurf. Drawn face isn't a quad.\n");
|
|
UTIL_Remove(this);
|
|
}
|
|
|
|
int materialCount = modelinfo->GetModelMaterialCount( const_cast<model_t*>(GetModel()) );
|
|
if( materialCount != 1 )
|
|
{
|
|
Warning( "Encountered func_breakablesurf that has a material applied to more than one surface!\n" );
|
|
UTIL_Remove(this);
|
|
}
|
|
|
|
// Get at the first material; even if there are more than one.
|
|
IMaterial* pMaterial;
|
|
modelinfo->GetModelMaterials( const_cast<model_t*>(GetModel()), 1, &pMaterial );
|
|
|
|
// The material should point to a cracked version of itself
|
|
bool foundVar;
|
|
IMaterialVar* pCrackName = pMaterial->FindVar( "$crackmaterial", &foundVar, false );
|
|
if (foundVar)
|
|
{
|
|
PrecacheMaterial( pCrackName->GetStringValue() );
|
|
}
|
|
|
|
// Init the Panel bit vector to all true. ( no panes are broken )
|
|
int bitVecLength = MAX_NUM_PANELS * MAX_NUM_PANELS;
|
|
|
|
for( int i=0;i<bitVecLength;i++ )
|
|
{
|
|
m_RawPanelBitVec.Set( i, true );
|
|
}
|
|
}
|
|
|
|
void CBreakableSurface::VPhysicsCollision( int index, gamevcollisionevent_t *pEvent )
|
|
{
|
|
if ( !m_bIsBroken )
|
|
{
|
|
int damageType = 0;
|
|
string_t iszDamageTable = ( ( m_nSurfaceType == SHATTERSURFACE_GLASS ) ? ( "glass" ) : ( NULL_STRING ) );
|
|
bool bDamageFromHeldObjects = ( ( m_spawnflags & SF_BREAKABLESURF_DAMAGE_FROM_HELD_OBJECTS ) != 0 );
|
|
float damage = CalculateDefaultPhysicsDamage( index, pEvent, 1.0, false, damageType, iszDamageTable, bDamageFromHeldObjects );
|
|
|
|
if ( damage > 10 )
|
|
{
|
|
// HACKHACK: Reset mass to get correct collision response for the object breaking this
|
|
pEvent->pObjects[index]->SetMass( 2.0f );
|
|
|
|
Vector normal, damagePos;
|
|
pEvent->pInternalData->GetSurfaceNormal( normal );
|
|
if ( index == 0 )
|
|
{
|
|
normal *= -1.0f;
|
|
}
|
|
pEvent->pInternalData->GetContactPoint( damagePos );
|
|
int otherIndex = !index;
|
|
CBaseEntity *pInflictor = pEvent->pEntities[otherIndex];
|
|
CTakeDamageInfo info( pInflictor, pInflictor, normal, damagePos, damage, damageType );
|
|
PhysCallbackDamage( this, info, *pEvent, index );
|
|
}
|
|
else if ( damage > 0 )
|
|
{
|
|
if ( m_spawnflags & SF_BREAKABLESURF_CRACK_DECALS )
|
|
{
|
|
|
|
Vector normal, damagePos;
|
|
pEvent->pInternalData->GetSurfaceNormal( normal );
|
|
if ( index == 0 )
|
|
{
|
|
normal *= -1.0f;
|
|
}
|
|
pEvent->pInternalData->GetContactPoint( damagePos );
|
|
|
|
trace_t tr;
|
|
UTIL_TraceLine ( damagePos - normal, damagePos + normal, MASK_SOLID_BRUSHONLY, NULL, COLLISION_GROUP_NONE, &tr );
|
|
|
|
// Only place decals and draw effects if we hit something valid
|
|
if ( tr.m_pEnt && tr.m_pEnt == this )
|
|
{
|
|
// Build the impact data
|
|
CEffectData data;
|
|
data.m_vOrigin = tr.endpos;
|
|
data.m_vStart = tr.startpos;
|
|
data.m_nSurfaceProp = tr.surface.surfaceProps;
|
|
data.m_nDamageType = DMG_CLUB;
|
|
data.m_nHitBox = tr.hitbox;
|
|
data.m_nEntIndex = entindex();
|
|
|
|
// Send it on its way
|
|
DispatchEffect( "Impact", data );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
BaseClass::VPhysicsCollision( index, pEvent );
|
|
}
|
|
|