Fix line endings. WHAMMY.

1 files changed, 604 insertions, 604 deletions

diff --git a/sp/src/game/shared/util_shared.h b/sp/src/game/shared/util_shared.h
index 8d40f4f5..18f066c3 100644
--- a/sp/src/game/shared/util_shared.h
+++ b/sp/src/game/shared/util_shared.h
@@ -1,604 +1,604 @@
-//========= 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"

-

-#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 );

-

-//=============================================================================

-// HPE_BEGIN:

-// [menglish] Added UTIL function for events in client win_panel which transmit the player as a user ID

-//=============================================================================

-CBasePlayer *UTIL_PlayerByUserId( int userID );

-//=============================================================================

-// HPE_END

-//=============================================================================

-

-// 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 Add( interfaceName *pElement ) { m_##interfaceName##AutoList.AddToTail( pElement ); } \

-		static void Remove( 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 ) \

-		{ \

-			Add( this ); \

-		} \

-	} \

-	interfaceName::~interfaceName() \

-	{ \

-		Remove( this ); \

-	}

-

-

-//--------------------------------------------------------------------------------------------------------------

-/**

- * 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;

-	float Now( void ) const;		// work-around since client header doesn't like inlined gpGlobals->curtime

-};

-

-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();

-

-

-#endif // UTIL_SHARED_H

+//========= 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"
+
+#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 );
+
+//=============================================================================
+// HPE_BEGIN:
+// [menglish] Added UTIL function for events in client win_panel which transmit the player as a user ID
+//=============================================================================
+CBasePlayer *UTIL_PlayerByUserId( int userID );
+//=============================================================================
+// HPE_END
+//=============================================================================
+
+// 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 Add( interfaceName *pElement ) { m_##interfaceName##AutoList.AddToTail( pElement ); } \
+		static void Remove( 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 ) \
+		{ \
+			Add( this ); \
+		} \
+	} \
+	interfaceName::~interfaceName() \
+	{ \
+		Remove( this ); \
+	}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * 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;
+	float Now( void ) const;		// work-around since client header doesn't like inlined gpGlobals->curtime
+};
+
+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();
+
+
+#endif // UTIL_SHARED_H