Modified source engine (2017) developed by valve and leaked in 2020. Not for commercial purporses
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 
 
 

662 lines
21 KiB

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose: Shared util code between client and server.
//
//=============================================================================//
#ifndef UTIL_SHARED_H
#define UTIL_SHARED_H
#ifdef _WIN32
#pragma once
#endif
#include "mathlib/vector.h"
#include "cmodel.h"
#include "utlvector.h"
#include "networkvar.h"
#include "engine/IEngineTrace.h"
#include "engine/IStaticPropMgr.h"
#include "shared_classnames.h"
#include "steam/steamuniverse.h"
#ifdef CLIENT_DLL
#include "cdll_client_int.h"
#endif
#ifdef PORTAL
#include "portal_util_shared.h"
#endif
//-----------------------------------------------------------------------------
// Forward declarations
//-----------------------------------------------------------------------------
class CGameTrace;
class CBasePlayer;
typedef CGameTrace trace_t;
extern ConVar developer; // developer mode
//-----------------------------------------------------------------------------
// Language IDs.
//-----------------------------------------------------------------------------
#define LANGUAGE_ENGLISH 0
#define LANGUAGE_GERMAN 1
#define LANGUAGE_FRENCH 2
#define LANGUAGE_BRITISH 3
//-----------------------------------------------------------------------------
// Pitch + yaw
//-----------------------------------------------------------------------------
float UTIL_VecToYaw (const Vector &vec);
float UTIL_VecToPitch (const Vector &vec);
float UTIL_VecToYaw (const matrix3x4_t& matrix, const Vector &vec);
float UTIL_VecToPitch (const matrix3x4_t& matrix, const Vector &vec);
Vector UTIL_YawToVector ( float yaw );
//-----------------------------------------------------------------------------
// Shared random number generators for shared/predicted code:
// whenever generating random numbers in shared/predicted code, these functions
// have to be used. Each call should specify a unique "sharedname" string that
// seeds the random number generator. In loops make sure the "additionalSeed"
// is increased with the loop counter, otherwise it will always return the
// same random number
//-----------------------------------------------------------------------------
float SharedRandomFloat( const char *sharedname, float flMinVal, float flMaxVal, int additionalSeed = 0 );
int SharedRandomInt( const char *sharedname, int iMinVal, int iMaxVal, int additionalSeed = 0 );
Vector SharedRandomVector( const char *sharedname, float minVal, float maxVal, int additionalSeed = 0 );
QAngle SharedRandomAngle( const char *sharedname, float minVal, float maxVal, int additionalSeed = 0 );
//-----------------------------------------------------------------------------
// Standard collision filters...
//-----------------------------------------------------------------------------
bool PassServerEntityFilter( const IHandleEntity *pTouch, const IHandleEntity *pPass );
bool StandardFilterRules( IHandleEntity *pHandleEntity, int fContentsMask );
//-----------------------------------------------------------------------------
// Converts an IHandleEntity to an CBaseEntity
//-----------------------------------------------------------------------------
inline const CBaseEntity *EntityFromEntityHandle( const IHandleEntity *pConstHandleEntity )
{
IHandleEntity *pHandleEntity = const_cast<IHandleEntity*>(pConstHandleEntity);
#ifdef CLIENT_DLL
IClientUnknown *pUnk = (IClientUnknown*)pHandleEntity;
return pUnk->GetBaseEntity();
#else
if ( staticpropmgr->IsStaticProp( pHandleEntity ) )
return NULL;
IServerUnknown *pUnk = (IServerUnknown*)pHandleEntity;
return pUnk->GetBaseEntity();
#endif
}
inline CBaseEntity *EntityFromEntityHandle( IHandleEntity *pHandleEntity )
{
#ifdef CLIENT_DLL
IClientUnknown *pUnk = (IClientUnknown*)pHandleEntity;
return pUnk->GetBaseEntity();
#else
if ( staticpropmgr->IsStaticProp( pHandleEntity ) )
return NULL;
IServerUnknown *pUnk = (IServerUnknown*)pHandleEntity;
return pUnk->GetBaseEntity();
#endif
}
typedef bool (*ShouldHitFunc_t)( IHandleEntity *pHandleEntity, int contentsMask );
//-----------------------------------------------------------------------------
// traceline methods
//-----------------------------------------------------------------------------
class CTraceFilterSimple : public CTraceFilter
{
public:
// It does have a base, but we'll never network anything below here..
DECLARE_CLASS_NOBASE( CTraceFilterSimple );
CTraceFilterSimple( const IHandleEntity *passentity, int collisionGroup, ShouldHitFunc_t pExtraShouldHitCheckFn = NULL );
virtual bool ShouldHitEntity( IHandleEntity *pHandleEntity, int contentsMask );
virtual void SetPassEntity( const IHandleEntity *pPassEntity ) { m_pPassEnt = pPassEntity; }
virtual void SetCollisionGroup( int iCollisionGroup ) { m_collisionGroup = iCollisionGroup; }
const IHandleEntity *GetPassEntity( void ){ return m_pPassEnt;}
private:
const IHandleEntity *m_pPassEnt;
int m_collisionGroup;
ShouldHitFunc_t m_pExtraShouldHitCheckFunction;
};
class CTraceFilterSkipTwoEntities : public CTraceFilterSimple
{
public:
// It does have a base, but we'll never network anything below here..
DECLARE_CLASS( CTraceFilterSkipTwoEntities, CTraceFilterSimple );
CTraceFilterSkipTwoEntities( const IHandleEntity *passentity, const IHandleEntity *passentity2, int collisionGroup );
virtual bool ShouldHitEntity( IHandleEntity *pHandleEntity, int contentsMask );
virtual void SetPassEntity2( const IHandleEntity *pPassEntity2 ) { m_pPassEnt2 = pPassEntity2; }
private:
const IHandleEntity *m_pPassEnt2;
};
class CTraceFilterSimpleList : public CTraceFilterSimple
{
public:
CTraceFilterSimpleList( int collisionGroup );
virtual bool ShouldHitEntity( IHandleEntity *pHandleEntity, int contentsMask );
void AddEntityToIgnore( IHandleEntity *pEntity );
protected:
CUtlVector<IHandleEntity*> m_PassEntities;
};
class CTraceFilterOnlyNPCsAndPlayer : public CTraceFilterSimple
{
public:
CTraceFilterOnlyNPCsAndPlayer( const IHandleEntity *passentity, int collisionGroup )
: CTraceFilterSimple( passentity, collisionGroup )
{
}
virtual TraceType_t GetTraceType() const
{
return TRACE_ENTITIES_ONLY;
}
virtual bool ShouldHitEntity( IHandleEntity *pHandleEntity, int contentsMask );
};
class CTraceFilterNoNPCsOrPlayer : public CTraceFilterSimple
{
public:
CTraceFilterNoNPCsOrPlayer( const IHandleEntity *passentity, int collisionGroup )
: CTraceFilterSimple( passentity, collisionGroup )
{
}
virtual bool ShouldHitEntity( IHandleEntity *pHandleEntity, int contentsMask );
};
//-----------------------------------------------------------------------------
// Purpose: Custom trace filter used for NPC LOS traces
//-----------------------------------------------------------------------------
class CTraceFilterLOS : public CTraceFilterSkipTwoEntities
{
public:
CTraceFilterLOS( IHandleEntity *pHandleEntity, int collisionGroup, IHandleEntity *pHandleEntity2 = NULL );
bool ShouldHitEntity( IHandleEntity *pHandleEntity, int contentsMask );
};
class CTraceFilterSkipClassname : public CTraceFilterSimple
{
public:
CTraceFilterSkipClassname( const IHandleEntity *passentity, const char *pchClassname, int collisionGroup );
virtual bool ShouldHitEntity( IHandleEntity *pHandleEntity, int contentsMask );
private:
const char *m_pchClassname;
};
class CTraceFilterSkipTwoClassnames : public CTraceFilterSkipClassname
{
public:
// It does have a base, but we'll never network anything below here..
DECLARE_CLASS( CTraceFilterSkipTwoClassnames, CTraceFilterSkipClassname );
CTraceFilterSkipTwoClassnames( const IHandleEntity *passentity, const char *pchClassname, const char *pchClassname2, int collisionGroup );
virtual bool ShouldHitEntity( IHandleEntity *pHandleEntity, int contentsMask );
private:
const char *m_pchClassname2;
};
class CTraceFilterSimpleClassnameList : public CTraceFilterSimple
{
public:
CTraceFilterSimpleClassnameList( const IHandleEntity *passentity, int collisionGroup );
virtual bool ShouldHitEntity( IHandleEntity *pHandleEntity, int contentsMask );
void AddClassnameToIgnore( const char *pchClassname );
private:
CUtlVector<const char*> m_PassClassnames;
};
class CTraceFilterChain : public CTraceFilter
{
public:
CTraceFilterChain( ITraceFilter *pTraceFilter1, ITraceFilter *pTraceFilter2 );
virtual bool ShouldHitEntity( IHandleEntity *pHandleEntity, int contentsMask );
private:
ITraceFilter *m_pTraceFilter1;
ITraceFilter *m_pTraceFilter2;
};
// helper
void DebugDrawLine( const Vector& vecAbsStart, const Vector& vecAbsEnd, int r, int g, int b, bool test, float duration );
extern ConVar r_visualizetraces;
inline void UTIL_TraceLine( const Vector& vecAbsStart, const Vector& vecAbsEnd, unsigned int mask,
const IHandleEntity *ignore, int collisionGroup, trace_t *ptr )
{
Ray_t ray;
ray.Init( vecAbsStart, vecAbsEnd );
CTraceFilterSimple traceFilter( ignore, collisionGroup );
enginetrace->TraceRay( ray, mask, &traceFilter, ptr );
if( r_visualizetraces.GetBool() )
{
DebugDrawLine( ptr->startpos, ptr->endpos, 255, 0, 0, true, -1.0f );
}
}
inline void UTIL_TraceLine( const Vector& vecAbsStart, const Vector& vecAbsEnd, unsigned int mask,
ITraceFilter *pFilter, trace_t *ptr )
{
Ray_t ray;
ray.Init( vecAbsStart, vecAbsEnd );
enginetrace->TraceRay( ray, mask, pFilter, ptr );
if( r_visualizetraces.GetBool() )
{
DebugDrawLine( ptr->startpos, ptr->endpos, 255, 0, 0, true, -1.0f );
}
}
inline void UTIL_TraceHull( const Vector &vecAbsStart, const Vector &vecAbsEnd, const Vector &hullMin,
const Vector &hullMax, unsigned int mask, const IHandleEntity *ignore,
int collisionGroup, trace_t *ptr )
{
Ray_t ray;
ray.Init( vecAbsStart, vecAbsEnd, hullMin, hullMax );
CTraceFilterSimple traceFilter( ignore, collisionGroup );
enginetrace->TraceRay( ray, mask, &traceFilter, ptr );
if( r_visualizetraces.GetBool() )
{
DebugDrawLine( ptr->startpos, ptr->endpos, 255, 255, 0, true, -1.0f );
}
}
inline void UTIL_TraceHull( const Vector &vecAbsStart, const Vector &vecAbsEnd, const Vector &hullMin,
const Vector &hullMax, unsigned int mask, ITraceFilter *pFilter, trace_t *ptr )
{
Ray_t ray;
ray.Init( vecAbsStart, vecAbsEnd, hullMin, hullMax );
enginetrace->TraceRay( ray, mask, pFilter, ptr );
if( r_visualizetraces.GetBool() )
{
DebugDrawLine( ptr->startpos, ptr->endpos, 255, 255, 0, true, -1.0f );
}
}
inline void UTIL_TraceRay( const Ray_t &ray, unsigned int mask,
const IHandleEntity *ignore, int collisionGroup, trace_t *ptr, ShouldHitFunc_t pExtraShouldHitCheckFn = NULL )
{
CTraceFilterSimple traceFilter( ignore, collisionGroup, pExtraShouldHitCheckFn );
enginetrace->TraceRay( ray, mask, &traceFilter, ptr );
if( r_visualizetraces.GetBool() )
{
DebugDrawLine( ptr->startpos, ptr->endpos, 255, 0, 0, true, -1.0f );
}
}
// Sweeps a particular entity through the world
void UTIL_TraceEntity( CBaseEntity *pEntity, const Vector &vecAbsStart, const Vector &vecAbsEnd, unsigned int mask, trace_t *ptr );
void UTIL_TraceEntity( CBaseEntity *pEntity, const Vector &vecAbsStart, const Vector &vecAbsEnd,
unsigned int mask, ITraceFilter *pFilter, trace_t *ptr );
void UTIL_TraceEntity( CBaseEntity *pEntity, const Vector &vecAbsStart, const Vector &vecAbsEnd,
unsigned int mask, const IHandleEntity *ignore, int collisionGroup, trace_t *ptr );
bool UTIL_EntityHasMatchingRootParent( CBaseEntity *pRootParent, CBaseEntity *pEntity );
inline int UTIL_PointContents( const Vector &vec )
{
return enginetrace->GetPointContents( vec );
}
// Sweeps against a particular model, using collision rules
void UTIL_TraceModel( const Vector &vecStart, const Vector &vecEnd, const Vector &hullMin,
const Vector &hullMax, CBaseEntity *pentModel, int collisionGroup, trace_t *ptr );
void UTIL_ClipTraceToPlayers( const Vector& vecAbsStart, const Vector& vecAbsEnd, unsigned int mask, ITraceFilter *filter, trace_t *tr );
// Particle effect tracer
void UTIL_ParticleTracer( const char *pszTracerEffectName, const Vector &vecStart, const Vector &vecEnd, int iEntIndex = 0, int iAttachment = 0, bool bWhiz = false );
// Old style, non-particle system, tracers
void UTIL_Tracer( const Vector &vecStart, const Vector &vecEnd, int iEntIndex = 0, int iAttachment = TRACER_DONT_USE_ATTACHMENT, float flVelocity = 0, bool bWhiz = false, const char *pCustomTracerName = NULL, int iParticleID = 0 );
bool UTIL_IsLowViolence( void );
bool UTIL_ShouldShowBlood( int bloodColor );
void UTIL_BloodDrips( const Vector &origin, const Vector &direction, int color, int amount );
void UTIL_BloodImpact( const Vector &pos, const Vector &dir, int color, int amount );
void UTIL_BloodDecalTrace( trace_t *pTrace, int bloodColor );
void UTIL_DecalTrace( trace_t *pTrace, char const *decalName );
bool UTIL_IsSpaceEmpty( CBaseEntity *pMainEnt, const Vector &vMin, const Vector &vMax );
void UTIL_StringToVector( float *pVector, const char *pString );
void UTIL_StringToIntArray( int *pVector, int count, const char *pString );
void UTIL_StringToFloatArray( float *pVector, int count, const char *pString );
void UTIL_StringToColor32( color32 *color, const char *pString );
CBasePlayer *UTIL_PlayerByIndex( int entindex );
// Helper for use with console commands and the like.
// Returns NULL if not found or if the provided arg would match multiple players.
// Currently accepts, in descending priority:
// - Formatted SteamID ([U:1:1234])
// - SteamID64 (76561197989728462)
// - Legacy SteamID (STEAM_0:1:1234)
// - UserID preceded by a pound (#4)
// - Partial name match (if unique)
// - UserID not preceded by a pound*
//
// *Does not count as ambiguous with higher priority items
CBasePlayer* UTIL_PlayerByCommandArg( const char *arg );
CBasePlayer* UTIL_PlayerByUserId( int userID );
CBasePlayer* UTIL_PlayerByName( const char *name ); // not case sensitive
// Finds a player who has this non-ambiguous substring. Also not case sensitive.
CBasePlayer* UTIL_PlayerByPartialName( const char *name );
// decodes a buffer using a 64bit ICE key (inplace)
void UTIL_DecodeICE( unsigned char * buffer, int size, const unsigned char *key);
//--------------------------------------------------------------------------------------------------------------
/**
* Given a position and a ray, return the shortest distance between the two.
* If 'pos' is beyond either end of the ray, the returned distance is negated.
*/
inline float DistanceToRay( const Vector &pos, const Vector &rayStart, const Vector &rayEnd, float *along = NULL, Vector *pointOnRay = NULL )
{
Vector to = pos - rayStart;
Vector dir = rayEnd - rayStart;
float length = dir.NormalizeInPlace();
float rangeAlong = DotProduct( dir, to );
if (along)
{
*along = rangeAlong;
}
float range;
if (rangeAlong < 0.0f)
{
// off start point
range = -(pos - rayStart).Length();
if (pointOnRay)
{
*pointOnRay = rayStart;
}
}
else if (rangeAlong > length)
{
// off end point
range = -(pos - rayEnd).Length();
if (pointOnRay)
{
*pointOnRay = rayEnd;
}
}
else // within ray bounds
{
Vector onRay = rayStart + rangeAlong * dir;
range = (pos - onRay).Length();
if (pointOnRay)
{
*pointOnRay = onRay;
}
}
return range;
}
//--------------------------------------------------------------------------------------------------------------
/**
* Macro for creating an interface that when inherited from automatically maintains a list of instances
* that inherit from that interface.
*/
// interface for entities that want to a auto maintained global list
#define DECLARE_AUTO_LIST( interfaceName ) \
class interfaceName; \
abstract_class interfaceName \
{ \
public: \
interfaceName( bool bAutoAdd = true ); \
virtual ~interfaceName(); \
static void AddToAutoList( interfaceName *pElement ) { m_##interfaceName##AutoList.AddToTail( pElement ); } \
static void RemoveFromAutoList( interfaceName *pElement ) { m_##interfaceName##AutoList.FindAndFastRemove( pElement ); } \
static const CUtlVector< interfaceName* >& AutoList( void ) { return m_##interfaceName##AutoList; } \
private: \
static CUtlVector< interfaceName* > m_##interfaceName##AutoList; \
};
// Creates the auto add/remove constructor/destructor...
// Pass false to the constructor to not auto add
#define IMPLEMENT_AUTO_LIST( interfaceName ) \
CUtlVector< class interfaceName* > interfaceName::m_##interfaceName##AutoList; \
interfaceName::interfaceName( bool bAutoAdd ) \
{ \
if ( bAutoAdd ) \
{ \
AddToAutoList( this ); \
} \
} \
interfaceName::~interfaceName() \
{ \
RemoveFromAutoList( this ); \
}
//--------------------------------------------------------------------------------------------------------------
// You can use this if you need an autolist without an extra interface type involved.
// To use this, just inherit (class Mine : public TAutoList<Mine> {)
template< class T >
class TAutoList
{
public:
typedef CUtlVector< T* > AutoListType;
static AutoListType &GetAutoList()
{
return m_autolist;
}
protected:
TAutoList()
{
m_autolist.AddToTail( static_cast< T* >( this ) );
}
virtual ~TAutoList()
{
m_autolist.FindAndFastRemove( static_cast< T* >( this ) );
}
private:
static AutoListType m_autolist;
};
template< class T >
CUtlVector< T* > TAutoList< T >::m_autolist;
//--------------------------------------------------------------------------------------------------------------
/**
* Simple class for tracking intervals of game time.
* Upon creation, the timer is invalidated. To measure time intervals, start the timer via Start().
*/
class IntervalTimer
{
public:
IntervalTimer( void )
{
m_timestamp = -1.0f;
}
void Reset( void )
{
m_timestamp = Now();
}
void Start( void )
{
m_timestamp = Now();
}
void Invalidate( void )
{
m_timestamp = -1.0f;
}
bool HasStarted( void ) const
{
return (m_timestamp > 0.0f);
}
/// if not started, elapsed time is very large
float GetElapsedTime( void ) const
{
return (HasStarted()) ? (Now() - m_timestamp) : 99999.9f;
}
bool IsLessThen( float duration ) const
{
return (Now() - m_timestamp < duration) ? true : false;
}
bool IsGreaterThen( float duration ) const
{
return (Now() - m_timestamp > duration) ? true : false;
}
private:
float m_timestamp;
float Now( void ) const; // work-around since client header doesn't like inlined gpGlobals->curtime
};
//--------------------------------------------------------------------------------------------------------------
/**
* Simple class for counting down a short interval of time.
* Upon creation, the timer is invalidated. Invalidated countdown timers are considered to have elapsed.
*/
class CountdownTimer
{
public:
CountdownTimer( void )
{
m_timestamp = -1.0f;
m_duration = 0.0f;
}
void Reset( void )
{
m_timestamp = Now() + m_duration;
}
void Start( float duration )
{
m_timestamp = Now() + duration;
m_duration = duration;
}
void Invalidate( void )
{
m_timestamp = -1.0f;
}
bool HasStarted( void ) const
{
return (m_timestamp > 0.0f);
}
bool IsElapsed( void ) const
{
return (Now() > m_timestamp);
}
float GetElapsedTime( void ) const
{
return Now() - m_timestamp + m_duration;
}
float GetRemainingTime( void ) const
{
return (m_timestamp - Now());
}
/// return original countdown time
float GetCountdownDuration( void ) const
{
return (m_timestamp > 0.0f) ? m_duration : 0.0f;
}
private:
float m_duration;
float m_timestamp;
virtual float Now( void ) const; // work-around since client header doesn't like inlined gpGlobals->curtime
};
class RealTimeCountdownTimer : public CountdownTimer
{
virtual float Now( void ) const OVERRIDE
{
return Plat_FloatTime();
}
};
char* ReadAndAllocStringValue( KeyValues *pSub, const char *pName, const char *pFilename = NULL );
int UTIL_StringFieldToInt( const char *szValue, const char **pValueStrings, int iNumStrings );
//-----------------------------------------------------------------------------
// Holidays
//-----------------------------------------------------------------------------
// Used at level change and round start to re-calculate which holiday is active
void UTIL_CalculateHolidays();
bool UTIL_IsHolidayActive( /*EHoliday*/ int eHoliday );
/*EHoliday*/ int UTIL_GetHolidayForString( const char* pszHolidayName );
// This will return the first active holiday string it can find. In the case of multiple
// holidays overlapping, the list order will act as priority.
const char *UTIL_GetActiveHolidayString();
const char *UTIL_GetRandomSoundFromEntry( const char* pszEntryName );
/// Clamp and round float vals to int. The values are in the 0...255 range.
Color FloatRGBAToColor( float r, float g, float b, float a );
float LerpFloat( float x0, float x1, float t );
Color LerpColor( const Color &c0, const Color &c1, float t );
// Global econ-level helper functionality.
EUniverse GetUniverse();
#endif // UTIL_SHARED_H