path: root/game/server/tf2/env_meteor.cpp

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
// $NoKeywords: $
//=============================================================================//

#include "cbase.h"

#include "tf_player.h"
#include "Env_Meteor.h"
#include "entitylist.h"
#include "vphysics_interface.h"
#include "tier1/strtools.h"
#include "mapdata_shared.h"
#include "sharedinterface.h"
#include "skycamera.h"
#include "ispatialpartition.h"
#include "gameinterface.h"
#include "props.h"
#include "tf_func_resource.h"
#include "resource_chunk.h"


#include "ndebugoverlay.h"

//=============================================================================
//
// Enumerator for swept bbox collision.
//
class CCollideList : public IEntityEnumerator
{
public:
	CCollideList( Ray_t *pRay, CBaseEntity* pIgnoreEntity, int nContentsMask ) : 
		m_Entities( 0, 32 ), m_pIgnoreEntity( pIgnoreEntity ),
		m_nContentsMask( nContentsMask ), m_pRay(pRay) {}

	virtual bool EnumEntity( IHandleEntity *pHandleEntity )
	{
		trace_t tr;
		enginetrace->ClipRayToEntity( *m_pRay, m_nContentsMask, pHandleEntity, &tr );
		if (( tr.fraction < 1.0f ) || (tr.startsolid) || (tr.allsolid))
		{
			CBaseEntity *pEntity = gEntList.GetBaseEntity( pHandleEntity->GetRefEHandle() );
			m_Entities.AddToTail( pEntity );
		}

		return true;
	}

	CUtlVector<CBaseEntity*>	m_Entities;

private:
	CBaseEntity		*m_pIgnoreEntity;
	int				m_nContentsMask;
	Ray_t			*m_pRay;
};


//=============================================================================
//
// Meteor Factory Functions
//

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CMeteorFactory::CreateMeteor( int nID, int iType,
								   const Vector &vecPosition, const Vector &vecDirection, 
		                           float flSpeed, float flStartTime, float flDamageRadius,
								   const Vector &vecTriggerMins, const Vector &vecTriggerMaxs )
{
	CEnvMeteor::Create( nID, iType, vecPosition, vecDirection, flSpeed, flStartTime, flDamageRadius,
		                vecTriggerMins, vecTriggerMaxs );
}

//=============================================================================
//
// Meteor Spawner Functions
//

void SendProxy_MeteorTargetPositions( const SendProp *pProp, const void *pStruct, const void *pData, DVariant *pOut, int iElement, int objectID )
{
	CEnvMeteorSpawnerShared *pMeteorSpawner = ( CEnvMeteorSpawnerShared* )pData;
	pOut->m_Vector[0] = pMeteorSpawner->m_aTargets[iElement].m_vecPosition.x;
	pOut->m_Vector[1] = pMeteorSpawner->m_aTargets[iElement].m_vecPosition.y;
	pOut->m_Vector[2] = pMeteorSpawner->m_aTargets[iElement].m_vecPosition.z;
}

void SendProxy_MeteorTargetRadii( const SendProp *pProp, const void *pStruct, const void *pData, DVariant *pOut, int iElement, int objectID )
{
	CEnvMeteorSpawnerShared *pMeteorSpawner = ( CEnvMeteorSpawnerShared* )pData;
	pOut->m_Float = pMeteorSpawner->m_aTargets[iElement].m_flRadius;
}

int SendProxyArrayLength_MeteorTargets( const void *pStruct, int objectID )
{
	CEnvMeteorSpawnerShared *pMeteorSpawner = ( CEnvMeteorSpawnerShared* )pStruct;
	return pMeteorSpawner->m_aTargets.Count();
}

// Link the name "env_meteorspawner" to the CMeteorSpawner class.  This
// links the WC entity with the game code.
LINK_ENTITY_TO_CLASS( env_meteorspawner, CEnvMeteorSpawner );

BEGIN_DATADESC( CEnvMeteorSpawner )

	// Key Fields.
	DEFINE_KEYFIELD( m_SpawnerShared.m_iMeteorType, FIELD_INTEGER, "MeteorType" ),
	DEFINE_KEYFIELD( m_SpawnerShared.m_bSkybox, FIELD_INTEGER, "SpawnInSkybox" ),
	DEFINE_KEYFIELD( m_SpawnerShared.m_flMinSpawnTime, FIELD_FLOAT, "SpawnIntervalMin" ),
	DEFINE_KEYFIELD( m_SpawnerShared.m_flMaxSpawnTime, FIELD_FLOAT, "SpawnIntervalMax" ),
	DEFINE_KEYFIELD( m_SpawnerShared.m_nMinSpawnCount, FIELD_INTEGER, "SpawnCountMin" ),
	DEFINE_KEYFIELD( m_SpawnerShared.m_nMaxSpawnCount, FIELD_INTEGER, "SpawnCountMax" ),
	DEFINE_KEYFIELD( m_SpawnerShared.m_flMinSpeed, FIELD_FLOAT, "MeteorSpeedMin" ),
	DEFINE_KEYFIELD( m_SpawnerShared.m_flMaxSpeed, FIELD_FLOAT, "MeteorSpeedMax" ),
	DEFINE_KEYFIELD( m_SpawnerShared.m_flMeteorDamageRadius, FIELD_FLOAT, "MeteorDamageRadius" ),
	DEFINE_KEYFIELD( m_fDisabled, FIELD_BOOLEAN,	"StartDisabled" ),

	// Function Pointers.
	DEFINE_FUNCTION( MeteorSpawnerThink ),

	// Inputs
	DEFINE_INPUTFUNC( FIELD_VOID, "Enable", InputEnable ),
	DEFINE_INPUTFUNC( FIELD_VOID, "Disable", InputDisable ),

END_DATADESC()

BEGIN_SEND_TABLE_NOBASE( CEnvMeteorSpawnerShared, DT_EnvMeteorSpawnerShared )
	// Setup (read from) Worldcraft.
	SendPropInt		( SENDINFO( m_iMeteorType ),		 8, SPROP_UNSIGNED ),
	SendPropInt     ( SENDINFO( m_bSkybox ),             4, SPROP_UNSIGNED ),
	SendPropFloat	( SENDINFO( m_flMinSpawnTime ),      0, SPROP_NOSCALE ),	
	SendPropFloat	( SENDINFO( m_flMaxSpawnTime ),      0, SPROP_NOSCALE ),	
	SendPropInt     ( SENDINFO( m_nMinSpawnCount ),     16, SPROP_UNSIGNED ),
	SendPropInt     ( SENDINFO( m_nMaxSpawnCount ),     16, SPROP_UNSIGNED ),
	SendPropFloat	( SENDINFO( m_flMinSpeed ),          0, SPROP_NOSCALE ),	
	SendPropFloat	( SENDINFO( m_flMaxSpeed ),          0, SPROP_NOSCALE ),
	
	// Setup through Init.
	SendPropFloat	( SENDINFO( m_flStartTime ),	    -1, SPROP_NOSCALE ),
	SendPropInt		( SENDINFO( m_nRandomSeed ),		-1, SPROP_UNSIGNED ),
	SendPropVector	( SENDINFO( m_vecMinBounds ),       -1, SPROP_NOSCALE ),
	SendPropVector  ( SENDINFO( m_vecMaxBounds ),		-1, SPROP_NOSCALE ),
	SendPropVector  ( SENDINFO( m_vecTriggerMins ),     -1, SPROP_NOSCALE ),
	SendPropVector  ( SENDINFO( m_vecTriggerMaxs ),		-1, SPROP_NOSCALE ),

	// Target List
	SendPropArray2( SendProxyArrayLength_MeteorTargets, 
	                SendPropVector( "meteortargetposition_array_element", 0, 0, 0, SPROP_NOSCALE, 0, 0, SendProxy_MeteorTargetPositions ), 
		            16, 0, "meteortargetposition_array" ),

	SendPropArray2( SendProxyArrayLength_MeteorTargets,
		            SendPropFloat( "meteortargetradius_array_element", 0, 0, 0, SPROP_NOSCALE, 0, 0, SendProxy_MeteorTargetRadii ), 
		            16, 0, "meteortargetradius_array" )
END_SEND_TABLE()

// This table encodes the CBaseEntity data.
IMPLEMENT_SERVERCLASS_ST_NOBASE( CEnvMeteorSpawner, DT_EnvMeteorSpawner )
	SendPropDataTable	( SENDINFO_DT( m_SpawnerShared ), &REFERENCE_SEND_TABLE( DT_EnvMeteorSpawnerShared ) ),
	SendPropInt			( SENDINFO( m_fDisabled ),		1, SPROP_UNSIGNED ),
END_SEND_TABLE()

// Meteor Models
char *strResourceMeteorModels[2] =
{
	"models/props/common/meteorites/meteor04.mdl",
	"models/props/common/meteorites/meteor05.mdl",
};

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
CEnvMeteorSpawner::CEnvMeteorSpawner()
{
}

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CEnvMeteorSpawner::Spawn( void )
{
	// Pre-cache.
	Precache();

	// Server-side is not visible -- for collision only.
	SetSolid( SOLID_NONE );
	SetMoveType( MOVETYPE_NONE );
	AddEffects( EF_NODRAW );

	// Set the "brush model" size and link into the world.
	SetModel( STRING( GetModelName() ) );

	// Set the think function and time.
	if ( !m_fDisabled )
	{
		SetThink( MeteorSpawnerThink );
	}
}

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CEnvMeteorSpawner::InputEnable( inputdata_t &inputdata )
{
	m_fDisabled = false;

	m_SpawnerShared.m_flStartTime = gpGlobals->curtime;
	m_SpawnerShared.m_flNextSpawnTime = m_SpawnerShared.m_flStartTime + m_SpawnerShared.m_flMaxSpawnTime;

	// Probably should set this as a message begin, etc..... will get to this later!!
//
//  CEntityMessageFilter filter( this, "CEnvMeteorSpawner" );
//	MessageBegin( filter, 0 );
//		WRITE_LONG( m_SpawnerShared.m_flStartTime );
//		WRITE_LONG( m_SpawnerShared.m_flNextSpawnTime );
//	MessageEnd();

	// Set the think function and time.
	SetThink( MeteorSpawnerThink );
	SetNextThink( gpGlobals->curtime + m_SpawnerShared.m_flNextSpawnTime );
}

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CEnvMeteorSpawner::InputDisable( inputdata_t &inputdata )
{
	m_fDisabled = true;
	SetThink( NULL );
}

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CEnvMeteorSpawner::Get3DSkyboxWorldBounds( Vector &vecTriggerMins, 
											    Vector &vecTriggerMaxs )
{
	CBaseEntity *pEntity = gEntList.FindEntityByClassname( NULL, "trigger_skybox2world" );
	if ( pEntity && pEntity->edict() )
	{
		pEntity->CollisionProp()->WorldSpaceAABB( &vecTriggerMins, &vecTriggerMaxs );
	}
}

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CEnvMeteorSpawner::Precache( void )
{
	// Precache the meteor models!
	for ( int iType = 0; iType < 2; iType++ )
	{
		PrecacheModel( strResourceMeteorModels[iType] );
	}
}

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CEnvMeteorSpawner::MeteorSpawnerThink( void )
{
	SetNextThink( gpGlobals->curtime + m_SpawnerShared.MeteorThink( gpGlobals->curtime ) );
}

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
int CEnvMeteorSpawner::ShouldTransmit( const CCheckTransmitInfo *pInfo )
{
	if ( m_SpawnerShared.m_bSkybox )
		return FL_EDICT_ALWAYS;

	return BaseClass::ShouldTransmit( pInfo );
}

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CEnvMeteorSpawner::Activate( void )
{
	// Parse the entity list looking for targets!
	int nEntityCount = engine->GetEntityCount();
	for ( int iEntity = 0; iEntity < nEntityCount; ++iEntity )
	{
		edict_t *pEdict = engine->PEntityOfEntIndex( iEntity );
		if ( !pEdict || pEdict->IsFree() )
			continue;

		CBaseEntity *pEntity = GetContainingEntity( pEdict );
		if ( !pEntity )
			continue;

		if ( pEntity->GetFlags()& FL_STATICPROP ) 
			continue;

		if ( !Q_strcmp( pEntity->GetClassname(), "env_meteortarget" ) )
		{
			CEnvMeteorTarget *pMeteorTarget = static_cast<CEnvMeteorTarget*>( pEntity );
			if ( pMeteorTarget && pMeteorTarget->m_target != NULL_STRING )
			{
				if ( !Q_strcmp( STRING( pMeteorTarget->m_target ), STRING( GetEntityName() ) ) )
				{
					m_SpawnerShared.AddToTargetList( pMeteorTarget->GetLocalOrigin(), pMeteorTarget->m_flRadius );
				}
			}
		}
	}

	// Get 3d skybox world trigger bounds.
	Vector vecTriggerMins, vecTriggerMaxs;
	Get3DSkyboxWorldBounds( vecTriggerMins, vecTriggerMaxs );

	// Initialize the spawner.
	float flTime = gpGlobals->curtime;
	m_SpawnerShared.Init( &m_Factory, 0/* seed */, flTime,
		                  WorldAlignMins(), WorldAlignMaxs(), vecTriggerMins, vecTriggerMaxs );

	// Setup next think.
	if ( !m_fDisabled )
	{
		SetNextThink( gpGlobals->curtime + m_SpawnerShared.m_flNextSpawnTime );
	}
}

//=============================================================================
//
// Meteor Target Functions
//

LINK_ENTITY_TO_CLASS( env_meteortarget, CEnvMeteorTarget );

BEGIN_DATADESC( CEnvMeteorTarget )

	// Key Fields.
	DEFINE_KEYFIELD( m_flRadius, FIELD_FLOAT, "EffectRadius" ),

END_DATADESC()

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
CEnvMeteorTarget::CEnvMeteorTarget()
{
	m_iTargetID = -1;
	m_flRadius = 1.0f;
}

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CEnvMeteorTarget::Spawn( void )
{
	BaseClass::Spawn();
}
	
//=============================================================================
//
// Meteor Functions
//

//
// NOTE: The server-side meteor code has not really been tested.  I do not
//       trust that is works correctly and/or cleans itself up nicely!
//

LINK_ENTITY_TO_CLASS( env_meteor, CEnvMeteor );

BEGIN_DATADESC( CEnvMeteor )

	// Function Pointers.
	DEFINE_FUNCTION( MeteorSkyboxThink ),
	DEFINE_FUNCTION( MeteorWorldThink ),

END_DATADESC()

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
CEnvMeteor::CEnvMeteor()
{
	m_vecMin.Init( -10.0f, -10.0f, -10.0f );
	m_vecMax.Init( 10.0f, 10.0f, 10.0f );
}

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
CEnvMeteor *CEnvMeteor::Create( int nID, int iMeteorType, 
							    const Vector &vecOrigin, const Vector &vecDirection,
								float flSpeed, float flStartTime, float flDamageRadius,
								const Vector &vecTriggerMins, const Vector &vecTriggerMaxs )
{
	CEnvMeteor *pMeteor = ( CEnvMeteor* )CreateEntityByName( "env_meteor" );
	if ( pMeteor )
	{
		pMeteor->m_Meteor.Init( nID, flStartTime, METEOR_PASSIVE_TIME, vecOrigin, vecDirection, flSpeed,
			                    flDamageRadius, vecTriggerMins, vecTriggerMaxs );

		// If the meteor will never enter the world, then don't bother with a server-side version.
		if ( pMeteor->m_Meteor.m_flWorldEnterTime == METEOR_INVALID_TIME )
		{
			UTIL_Remove( pMeteor );
		}

		// Handle forward simulation.
		if ( ( pMeteor->m_Meteor.m_flStartTime + METEOR_MAX_LIFETIME ) < gpGlobals->curtime )
		{
			UTIL_Remove( pMeteor );
		}

		pMeteor->Spawn();
		pMeteor->SetNextThink( gpGlobals->curtime + pMeteor->m_Meteor.m_flWorldEnterTime );
	}

	return pMeteor;
}

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CEnvMeteor::Spawn( void )
{
	// Pass data.
	BaseClass::Spawn();

	int iModel = modelinfo->GetModelIndex( "models/props/common/meteorites/meteor04.mdl" );
	if ( iModel > 0 )
	{
		const model_t *pModel = modelinfo->GetModel( iModel );
		modelinfo->GetModelBounds( pModel, m_vecMin, m_vecMax );
	}

	// Assumes we start life in a skybox!
	SetThink( MeteorSkyboxThink );

	m_bPrevInSkybox = true;
}

//-----------------------------------------------------------------------------
// Purpose: This think function should be called at the time when the meteor 
//          will be leaving the skybox and entering the world.
//-----------------------------------------------------------------------------
void CEnvMeteor::MeteorSkyboxThink( void )
{
	SetThink( MeteorWorldThink );
	SetNextThink( gpGlobals->curtime + 0.2f );
}

//-----------------------------------------------------------------------------
// Purpose: This think function simulates (moves/collides) the meteor while in
//          the world.
//-----------------------------------------------------------------------------
void CEnvMeteor::MeteorWorldThink( void )
{
	// Get the current time.
	float flTime = gpGlobals->curtime;

	// Convert if need be!
	if ( m_bPrevInSkybox )
	{
		m_Meteor.ConvertFromSkyboxToWorld();
		UTIL_SetOrigin( this, m_Meteor.m_vecStartPosition );

		m_bPrevInSkybox = false;
	}

	// Update meteor position for swept collision test.
	Vector vecEndPosition;
	m_Meteor.GetPositionAtTime( flTime, vecEndPosition );

	// Debugging!!
//	NDebugOverlay::Box( GetAbsOrigin(), m_vecMin * 0.5f, m_vecMax * 0.5f, 255, 255, 0, 0, 5 );
//	NDebugOverlay::Box( vecEndPosition, m_vecMin, m_vecMax, 255, 0, 0, 0, 5 );

	Ray_t ray;
	ray.Init( GetAbsOrigin(), vecEndPosition, m_vecMin, m_vecMax );

	CCollideList collideList( &ray, this, MASK_SOLID );
	enginetrace->EnumerateEntities( ray, false, &collideList );

	// Now get each entity and react accordinly!
	for( int iEntity = collideList.m_Entities.Count(); --iEntity >= 0; )
	{
		CBaseEntity *pEntity = collideList.m_Entities[iEntity];

		if  ( pEntity )
		{
			Vector vecForceDir = m_Meteor.m_vecDirection;

			// Check for a physics object and apply force!
			IPhysicsObject *pPhysObject = pEntity->VPhysicsGetObject();
			if ( pPhysObject )
			{
//				float flMass = pPhysObject->GetMass();
				
				// Send it flying!!!
				vecForceDir *= 5000000000000.0f;
				pPhysObject->ApplyForceCenter( vecForceDir );
			}

			if ( pEntity->m_takedamage )
			{
				CTakeDamageInfo info( this, this, 200.0f, DMG_CLUB );
				CalculateExplosiveDamageForce( &info, vecForceDir, pEntity->GetAbsOrigin() );
				pEntity->TakeDamage( info );
			}
		}
	}

	trace_t trace;
	UTIL_TraceHull( GetAbsOrigin(), vecEndPosition, m_vecMin, m_vecMax,
		            MASK_NPCWORLDSTATIC, this, COLLISION_GROUP_NONE, &trace );
	if( ( trace.fraction < 1.0f ) && !( trace.surface.flags & SURF_SKY ) )
	{
		CBaseEntity *pEntity = trace.m_pEnt;
		if ( pEntity )
		{
			// Hit the world? The meteor is destroyed!
			if ( pEntity->GetSolid() == SOLID_BSP )
			{
#if 0
				// Suppress resources for now!!

				// Create a random number or resource chunks.
				int nChunkCount = random->RandomInt( 0, 4 );
				for( int iChunk = 0; iChunk < nChunkCount; ++iChunk )
				{
					// Generate a random velocity vector.
					Vector vVelocity = Vector( random->RandomFloat( -20,20 ), random->RandomFloat( -20,20 ), random->RandomFloat( 100,150 ) );
					CResourceChunk::Create( false, GetAbsOrigin(), vVelocity );
				}
#endif

				// Splash damage!
				Vector vecImpactPoint;
				vecImpactPoint = GetAbsOrigin() + ( ( vecEndPosition - GetAbsOrigin() ) * trace.fraction ); 

				// Debugging!!
//				NDebugOverlay::Box( vecImpactPoint, m_vecMin, m_vecMax, 0, 255, 0, 0, 5 );

				//Iterate on all entities in the vicinity.
				for ( CEntitySphereQuery sphere( vecImpactPoint, m_Meteor.GetDamageRadius() ); pEntity = sphere.GetCurrentEntity(); sphere.NextEntity() )
				{
					// Get distance to object and use it as a scale value.
					Vector vecSegment;
					vecSegment = pEntity->GetAbsOrigin() - vecImpactPoint;
					float flDistance = vecSegment.Length();

					float flScale = flDistance / ( m_Meteor.GetDamageRadius() * 0.75f );
					if ( flScale > 1.0f ) 
					{ 
						flScale = 1.0f; 
					}
					
					Vector vecForceDir = m_Meteor.m_vecDirection;

					// Check for a physics object and apply force!
					IPhysicsObject *pPhysObject = pEntity->VPhysicsGetObject();
					if ( pPhysObject )
					{
//						float flMass = pPhysObject->GetMass();

						// Send it flying!!!
						vecForceDir *= 5000000000000.0f * flScale;
						pPhysObject->ApplyForceCenter( vecForceDir );
					}

					if ( pEntity->m_takedamage )
					{
						CTakeDamageInfo info( this, this, 300.0f * flScale, DMG_CLUB );
						CalculateExplosiveDamageForce( &info, vecForceDir, pEntity->GetAbsOrigin() );
						pEntity->TakeDamage( info );
					}
				}

				UTIL_Remove( this );
				return;
			}
		}
	}

	// Always move full movement.
	UTIL_SetOrigin( this, vecEndPosition );
	SetNextThink( gpGlobals->curtime + 0.2f );

	// Check for death.
	if ( flTime >= m_Meteor.m_flWorldExitTime )
	{
		UTIL_Remove( this );
		return;
	}
}

//=============================================================================
// 
// Shooting Star Spawner Functionality.
//

// Link the name "env_meteorspawner" to the CMeteorSpawner class.  This
// links the WC entity with the game code.
LINK_ENTITY_TO_CLASS( env_shootingstarspawner, CShootingStarSpawner );

BEGIN_DATADESC( CShootingStarSpawner )

	// keys 
	DEFINE_KEYFIELD_NOT_SAVED( m_flSpawnInterval, FIELD_FLOAT, "SpawnInterval" ),
	DEFINE_KEYFIELD_NOT_SAVED( m_bSkybox, FIELD_INTEGER, "SpawnInSkybox" ),

END_DATADESC()

IMPLEMENT_SERVERCLASS_ST( CShootingStarSpawner, DT_ShootingStarSpawner )
	SendPropFloat( SENDINFO( m_flSpawnInterval ), -1, SPROP_NOSCALE ),
END_SEND_TABLE()

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CShootingStarSpawner::CShootingStarSpawner()
{
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
int CShootingStarSpawner::ShouldTransmit( const CCheckTransmitInfo *pInfo )
{
	// Always send shooting star spawners if they are in the skybox!
	if ( m_bSkybox )
		return FL_EDICT_ALWAYS ;

	return BaseClass::ShouldTransmit( pInfo );
}