Moved modified HL SDK to trunk

hlsdk/ricochet/cl_dll/GameStudioModelRenderer.cpp

@@ -0,0 +1,982 @@
+#include <assert.h>
+#include "hud.h"
+#include "cl_util.h"
+#include "const.h"
+#include "com_model.h"
+#include "studio.h"
+#include "entity_state.h"
+#include "cl_entity.h"
+#include "dlight.h"
+#include "triangleapi.h"
+
+#include <stdio.h>
+#include <string.h>
+#include <memory.h>
+#include <math.h>
+
+#include "studio_util.h"
+#include "r_studioint.h"
+
+#include "StudioModelRenderer.h"
+#include "GameStudioModelRenderer.h"
+
+void Ricochet_GetSequence( int *seq, int *gaitseq );
+void Ricochet_GetOrientation( float *o, float *a );
+
+float g_flStartScaleTime;
+int iPrevRenderState;
+int iRenderStateChanged;
+
+// Global engine <-> studio model rendering code interface
+extern engine_studio_api_t IEngineStudio;
+
+typedef struct
+{
+	vec3_t		origin;
+	vec3_t		angles;
+
+	vec3_t		realangles;
+
+	float		animtime;
+	float		frame;
+	int			sequence;
+	int			gaitsequence;
+	float		framerate;
+
+	int			m_fSequenceLoops;
+	int			m_fSequenceFinished;
+
+	byte		controller[ 4 ];
+	byte		blending[ 2 ];
+
+	latchedvars_t	lv;
+} client_anim_state_t;
+
+static client_anim_state_t g_state;
+static client_anim_state_t g_clientstate;
+
+// The renderer object, created on the stack.
+CGameStudioModelRenderer g_StudioRenderer;
+/*
+====================
+CGameStudioModelRenderer
+
+====================
+*/
+CGameStudioModelRenderer::CGameStudioModelRenderer( void )
+{
+	// If you want to predict animations locally, set this to TRUE
+	// NOTE:  The animation code is somewhat broken, but gives you a sense for how
+	//  to do client side animation of the predicted player in a third person game.
+	m_bLocal = false;
+}
+
+/*
+====================
+StudioSetupBones
+
+====================
+*/
+void CGameStudioModelRenderer::StudioSetupBones ( void )
+{
+	int					i;
+	double				f;
+
+	mstudiobone_t		*pbones;
+	mstudioseqdesc_t	*pseqdesc;
+	mstudioanim_t		*panim;
+
+	static float		pos[MAXSTUDIOBONES][3];
+	static vec4_t		q[MAXSTUDIOBONES];
+	float				bonematrix[3][4];
+
+	static float		pos2[MAXSTUDIOBONES][3];
+	static vec4_t		q2[MAXSTUDIOBONES];
+	static float		pos3[MAXSTUDIOBONES][3];
+	static vec4_t		q3[MAXSTUDIOBONES];
+	static float		pos4[MAXSTUDIOBONES][3];
+	static vec4_t		q4[MAXSTUDIOBONES];
+
+	// Use default bone setup for nonplayers
+	if ( !m_pCurrentEntity->player )
+	{
+		CStudioModelRenderer::StudioSetupBones();
+		return;
+	}
+
+	// Bound sequence number.
+	if ( m_pCurrentEntity->curstate.sequence >= m_pStudioHeader->numseq ) 
+	{
+		m_pCurrentEntity->curstate.sequence = 0;
+	}
+
+	pseqdesc = (mstudioseqdesc_t *)((byte *)m_pStudioHeader + m_pStudioHeader->seqindex) + m_pCurrentEntity->curstate.sequence;
+
+	if ( m_pPlayerInfo && m_pPlayerInfo->gaitsequence != 0 )
+	{
+		f = m_pPlayerInfo->gaitframe;
+	}
+	else 
+	{
+		f = StudioEstimateFrame( pseqdesc );
+	}
+
+	// Discwar knows how to do three way blending
+	if ( pseqdesc->numblends == 3 )
+	{
+		float				s;
+
+		// Get left anim
+		panim = StudioGetAnim( m_pRenderModel, pseqdesc );
+
+		// Blending is 0-127 == Left to Middle, 128 to 255 == Middle to right
+		if ( m_pCurrentEntity->curstate.blending[0] <= 127 )
+		{
+			StudioCalcRotations( pos, q, pseqdesc, panim, f );
+			
+			// Scale 0-127 blending up to 0-255
+			s = m_pCurrentEntity->curstate.blending[0];
+			s = ( s * 2.0 );
+		}
+		else
+		{
+			
+			// Skip ahead to middle
+			panim += m_pStudioHeader->numbones;
+
+			StudioCalcRotations( pos, q, pseqdesc, panim, f );
+
+			// Scale 127-255 blending up to 0-255
+			s = m_pCurrentEntity->curstate.blending[0];
+			s = 2.0 * ( s - 127.0 );
+		}
+
+		// Normalize interpolant
+		s /= 255.0;
+
+		// Go to middle or right
+		panim += m_pStudioHeader->numbones;
+
+		StudioCalcRotations( pos2, q2, pseqdesc, panim, f );
+
+		// Spherically interpolate the bones
+		StudioSlerpBones( q, pos, q2, pos2, s );
+	}
+	else
+	{
+		panim = StudioGetAnim( m_pRenderModel, pseqdesc );
+		StudioCalcRotations( pos, q, pseqdesc, panim, f );
+	}
+
+	// Are we in the process of transitioning from one sequence to another.
+	if ( m_fDoInterp &&
+		m_pCurrentEntity->latched.sequencetime &&
+		( m_pCurrentEntity->latched.sequencetime + 0.2 > m_clTime ) && 
+		( m_pCurrentEntity->latched.prevsequence < m_pStudioHeader->numseq ))
+	{
+		// blend from last sequence
+		static float		pos1b[MAXSTUDIOBONES][3];
+		static vec4_t		q1b[MAXSTUDIOBONES];
+		float				s;
+
+		// Blending value into last sequence
+		unsigned char prevseqblending = m_pCurrentEntity->latched.prevseqblending[ 0 ];
+
+		// Point at previous sequenece
+		pseqdesc = (mstudioseqdesc_t *)((byte *)m_pStudioHeader + m_pStudioHeader->seqindex) + m_pCurrentEntity->latched.prevsequence;
+		
+		// Know how to do three way blends
+		if ( pseqdesc->numblends == 3 )
+		{
+			float				s;
+
+			// Get left animation
+			panim = StudioGetAnim( m_pRenderModel, pseqdesc );
+
+			if ( prevseqblending <= 127 )
+			{
+				// Set up bones based on final frame of previous sequence
+				StudioCalcRotations( pos1b, q1b, pseqdesc, panim, m_pCurrentEntity->latched.prevframe );
+				
+				s = prevseqblending;
+				s = ( s * 2.0 );
+			}
+			else
+			{
+				// Skip to middle blend
+				panim += m_pStudioHeader->numbones;
+
+				StudioCalcRotations( pos1b, q1b, pseqdesc, panim, m_pCurrentEntity->latched.prevframe );
+
+				s = prevseqblending;
+				s = 2.0 * ( s - 127.0 );
+			}
+
+			// Normalize
+			s /= 255.0;
+
+			panim += m_pStudioHeader->numbones;
+			StudioCalcRotations( pos2, q2, pseqdesc, panim, m_pCurrentEntity->latched.prevframe );
+
+			// Interpolate bones
+			StudioSlerpBones( q1b, pos1b, q2, pos2, s );
+		}
+		else
+		{
+			panim = StudioGetAnim( m_pRenderModel, pseqdesc );
+			// clip prevframe
+			StudioCalcRotations( pos1b, q1b, pseqdesc, panim, m_pCurrentEntity->latched.prevframe );
+		}
+
+		// Now blend last frame of previous sequence with current sequence.
+		s = 1.0 - (m_clTime - m_pCurrentEntity->latched.sequencetime) / 0.2;
+		StudioSlerpBones( q, pos, q1b, pos1b, s );
+	}
+	else
+	{
+		m_pCurrentEntity->latched.prevframe = f;
+	}
+
+	// Now convert quaternions and bone positions into matrices
+	pbones = (mstudiobone_t *)((byte *)m_pStudioHeader + m_pStudioHeader->boneindex);
+
+	for (i = 0; i < m_pStudioHeader->numbones; i++) 
+	{
+		QuaternionMatrix( q[i], bonematrix );
+
+		bonematrix[0][3] = pos[i][0];
+		bonematrix[1][3] = pos[i][1];
+		bonematrix[2][3] = pos[i][2];
+
+		if (pbones[i].parent == -1) 
+		{
+			if ( IEngineStudio.IsHardware() )
+			{
+				ConcatTransforms ((*m_protationmatrix), bonematrix, (*m_pbonetransform)[i]);
+				ConcatTransforms ((*m_protationmatrix), bonematrix, (*m_plighttransform)[i]);
+			}
+			else
+			{
+				ConcatTransforms ((*m_paliastransform), bonematrix, (*m_pbonetransform)[i]);
+				ConcatTransforms ((*m_protationmatrix), bonematrix, (*m_plighttransform)[i]);
+			}
+
+			// Apply client-side effects to the transformation matrix
+			StudioFxTransform( m_pCurrentEntity, (*m_pbonetransform)[i] );
+		} 
+		else 
+		{
+			ConcatTransforms ((*m_pbonetransform)[pbones[i].parent], bonematrix, (*m_pbonetransform)[i]);
+			ConcatTransforms ((*m_plighttransform)[pbones[i].parent], bonematrix, (*m_plighttransform)[i]);
+		}
+	}
+}
+
+/*
+====================
+StudioEstimateGait
+
+====================
+*/
+void CGameStudioModelRenderer::StudioEstimateGait( entity_state_t *pplayer )
+{
+	float dt;
+	vec3_t est_velocity;
+
+	dt = (m_clTime - m_clOldTime);
+	dt = max( 0.0, dt );
+	dt = min( 1.0, dt );
+
+	if (dt == 0 || m_pPlayerInfo->renderframe == m_nFrameCount)
+	{
+		m_flGaitMovement = 0;
+		return;
+	}
+
+	// VectorAdd( pplayer->velocity, pplayer->prediction_error, est_velocity );
+	if ( m_fGaitEstimation )
+	{
+		VectorSubtract( m_pCurrentEntity->origin, m_pPlayerInfo->prevgaitorigin, est_velocity );
+		VectorCopy( m_pCurrentEntity->origin, m_pPlayerInfo->prevgaitorigin );
+		m_flGaitMovement = Length( est_velocity );
+		if (dt <= 0 || m_flGaitMovement / dt < 5)
+		{
+			m_flGaitMovement = 0;
+			est_velocity[0] = 0;
+			est_velocity[1] = 0;
+		}
+	}
+	else
+	{
+		VectorCopy( pplayer->velocity, est_velocity );
+		m_flGaitMovement = Length( est_velocity ) * dt;
+	}
+
+	if (est_velocity[1] == 0 && est_velocity[0] == 0)
+	{
+		float flYawDiff = m_pCurrentEntity->angles[YAW] - m_pPlayerInfo->gaityaw;
+		flYawDiff = flYawDiff - (int)(flYawDiff / 360) * 360;
+		if (flYawDiff > 180)
+			flYawDiff -= 360;
+		if (flYawDiff < -180)
+			flYawDiff += 360;
+
+		if (dt < 0.25)
+			flYawDiff *= dt * 4;
+		else
+			flYawDiff *= dt;
+
+		m_pPlayerInfo->gaityaw += flYawDiff;
+		m_pPlayerInfo->gaityaw = m_pPlayerInfo->gaityaw - (int)(m_pPlayerInfo->gaityaw / 360) * 360;
+
+		m_flGaitMovement = 0;
+	}
+	else
+	{
+		m_pPlayerInfo->gaityaw = (atan2(est_velocity[1], est_velocity[0]) * 180 / M_PI);
+		if (m_pPlayerInfo->gaityaw > 180)
+			m_pPlayerInfo->gaityaw = 180;
+		if (m_pPlayerInfo->gaityaw < -180)
+			m_pPlayerInfo->gaityaw = -180;
+	}
+
+}
+
+/*
+====================
+StudioProcessGait
+
+====================
+*/
+void CGameStudioModelRenderer::StudioProcessGait( entity_state_t *pplayer )
+{
+	mstudioseqdesc_t	*pseqdesc;
+	float dt;
+	float flYaw;	 // view direction relative to movement
+
+	pseqdesc = (mstudioseqdesc_t *)((byte *)m_pStudioHeader + m_pStudioHeader->seqindex) + m_pCurrentEntity->curstate.sequence;
+
+	m_pCurrentEntity->angles[PITCH] = 0;
+	m_pCurrentEntity->latched.prevangles[PITCH] = m_pCurrentEntity->angles[PITCH];
+
+	dt = (m_clTime - m_clOldTime);
+	dt = max( 0.0, dt );
+	dt = min( 1.0, dt );
+
+	StudioEstimateGait( pplayer );
+
+	// calc side to side turning
+	flYaw = m_pCurrentEntity->angles[YAW] - m_pPlayerInfo->gaityaw;
+
+	flYaw = fmod( flYaw, 360.0f );
+
+	if (flYaw < -180)
+	{
+		flYaw = flYaw + 360;
+	}
+	else if (flYaw > 180)
+	{
+		flYaw = flYaw - 360;
+	}
+
+	float maxyaw = 120.0;
+
+	if (flYaw > maxyaw)
+	{
+		m_pPlayerInfo->gaityaw = m_pPlayerInfo->gaityaw - 180;
+		m_flGaitMovement = -m_flGaitMovement;
+		flYaw = flYaw - 180;
+	}
+	else if (flYaw < -maxyaw)
+	{
+		m_pPlayerInfo->gaityaw = m_pPlayerInfo->gaityaw + 180;
+		m_flGaitMovement = -m_flGaitMovement;
+		flYaw = flYaw + 180;
+	}
+
+	float blend_yaw = ( flYaw / 90.0 ) * 128.0 + 127.0;
+	blend_yaw = min( 255.0, blend_yaw );
+	blend_yaw = max( 0.0, blend_yaw );
+	
+	blend_yaw = 255.0 - blend_yaw;
+
+	m_pCurrentEntity->curstate.blending[0] = (int)(blend_yaw);
+	m_pCurrentEntity->latched.prevblending[0] = m_pCurrentEntity->curstate.blending[0];
+	m_pCurrentEntity->latched.prevseqblending[0] = m_pCurrentEntity->curstate.blending[0];
+
+	m_pCurrentEntity->angles[YAW] = m_pPlayerInfo->gaityaw;
+	if (m_pCurrentEntity->angles[YAW] < -0)
+	{
+		m_pCurrentEntity->angles[YAW] += 360;
+	}
+	m_pCurrentEntity->latched.prevangles[YAW] = m_pCurrentEntity->angles[YAW];
+
+	pseqdesc = (mstudioseqdesc_t *)((byte *)m_pStudioHeader + m_pStudioHeader->seqindex) + pplayer->gaitsequence;
+	
+	// Calc gait frame
+	if (pseqdesc->linearmovement[0] > 0)
+	{
+		m_pPlayerInfo->gaitframe += (m_flGaitMovement / pseqdesc->linearmovement[0]) * pseqdesc->numframes;
+	}
+	else
+	{
+		m_pPlayerInfo->gaitframe += pseqdesc->fps * dt * m_pCurrentEntity->curstate.framerate;
+	}
+
+	// Do modulo
+	m_pPlayerInfo->gaitframe = m_pPlayerInfo->gaitframe - (int)(m_pPlayerInfo->gaitframe / pseqdesc->numframes) * pseqdesc->numframes;
+	if (m_pPlayerInfo->gaitframe < 0)
+	{
+		m_pPlayerInfo->gaitframe += pseqdesc->numframes;
+	}
+}
+
+/*
+==============================
+SavePlayerState
+
+For local player, in third person, we need to store real render data and then
+  setup for with fake/client side animation data
+==============================
+*/
+void CGameStudioModelRenderer::SavePlayerState( entity_state_t *pplayer )
+{
+	client_anim_state_t *st;
+	cl_entity_t *ent = IEngineStudio.GetCurrentEntity();
+	assert( ent );
+	if ( !ent )
+		return;
+
+	st = &g_state;
+
+	st->angles		= ent->curstate.angles;
+	st->origin		= ent->curstate.origin;
+
+	st->realangles	= ent->angles;
+
+	st->sequence	= ent->curstate.sequence;
+	st->gaitsequence = pplayer->gaitsequence;
+	st->animtime	= ent->curstate.animtime;
+	st->frame		= ent->curstate.frame;
+	st->framerate	= ent->curstate.framerate;
+	memcpy( st->blending, ent->curstate.blending, 2 );
+	memcpy( st->controller, ent->curstate.controller, 4 );
+
+	st->lv = ent->latched;
+}
+
+void GetSequenceInfo( void *pmodel, client_anim_state_t *pev, float *pflFrameRate, float *pflGroundSpeed )
+{
+	studiohdr_t *pstudiohdr;
+	
+	pstudiohdr = (studiohdr_t *)pmodel;
+	if (! pstudiohdr)
+		return;
+
+	mstudioseqdesc_t	*pseqdesc;
+
+	if (pev->sequence >= pstudiohdr->numseq)
+	{
+		*pflFrameRate = 0.0;
+		*pflGroundSpeed = 0.0;
+		return;
+	}
+
+	pseqdesc = (mstudioseqdesc_t *)((byte *)pstudiohdr + pstudiohdr->seqindex) + (int)pev->sequence;
+
+	if (pseqdesc->numframes > 1)
+	{
+		*pflFrameRate = 256 * pseqdesc->fps / (pseqdesc->numframes - 1);
+		*pflGroundSpeed = sqrt( pseqdesc->linearmovement[0]*pseqdesc->linearmovement[0]+ pseqdesc->linearmovement[1]*pseqdesc->linearmovement[1]+ pseqdesc->linearmovement[2]*pseqdesc->linearmovement[2] );
+		*pflGroundSpeed = *pflGroundSpeed * pseqdesc->fps / (pseqdesc->numframes - 1);
+	}
+	else
+	{
+		*pflFrameRate = 256.0;
+		*pflGroundSpeed = 0.0;
+	}
+}
+
+int GetSequenceFlags( void *pmodel, client_anim_state_t *pev )
+{
+	studiohdr_t *pstudiohdr;
+	
+	pstudiohdr = (studiohdr_t *)pmodel;
+	if ( !pstudiohdr || pev->sequence >= pstudiohdr->numseq )
+		return 0;
+
+	mstudioseqdesc_t	*pseqdesc;
+	pseqdesc = (mstudioseqdesc_t *)((byte *)pstudiohdr + pstudiohdr->seqindex) + (int)pev->sequence;
+
+	return pseqdesc->flags;
+}
+
+float StudioFrameAdvance ( client_anim_state_t *st, float framerate, float flInterval )
+{
+	if (flInterval == 0.0)
+	{
+		flInterval = (gEngfuncs.GetClientTime() - st->animtime);
+		if (flInterval <= 0.001)
+		{
+			st->animtime = gEngfuncs.GetClientTime();
+			return 0.0;
+		}
+	}
+	if (!st->animtime)
+		flInterval = 0.0;
+	
+	st->frame += flInterval * framerate * st->framerate;
+	st->animtime = gEngfuncs.GetClientTime();
+
+	if (st->frame < 0.0 || st->frame >= 256.0) 
+	{
+		if ( st->m_fSequenceLoops )
+			st->frame -= (int)(st->frame / 256.0) * 256.0;
+		else
+			st->frame = (st->frame < 0.0) ? 0 : 255;
+		st->m_fSequenceFinished = TRUE;	// just in case it wasn't caught in GetEvents
+	}
+
+	return flInterval;
+}
+
+/*
+==============================
+SetupClientAnimation
+
+Called to set up local player's animation values
+==============================
+*/
+void CGameStudioModelRenderer::SetupClientAnimation( entity_state_t *pplayer )
+{
+	static double oldtime;
+	double curtime, dt;
+
+	client_anim_state_t *st;
+	float fr, gs;
+
+	cl_entity_t *ent = IEngineStudio.GetCurrentEntity();
+	assert( ent );
+	if ( !ent )
+		return;
+
+	curtime = gEngfuncs.GetClientTime();
+	dt = curtime - oldtime;
+	dt = min( 1.0, max( 0.0, dt ) );
+
+	oldtime = curtime;
+	st = &g_clientstate;
+	
+	st->framerate = 1.0;
+
+	int oldseq = st->sequence;
+	Ricochet_GetSequence( &st->sequence, &st->gaitsequence );
+	Ricochet_GetOrientation( (float *)&st->origin, (float *)&st->angles );
+	st->realangles = st->angles;
+
+	if ( st->sequence != oldseq )
+	{
+		st->frame = 0.0;
+		st->lv.prevsequence = oldseq;
+		st->lv.sequencetime = st->animtime;
+
+		memcpy( st->lv.prevseqblending, st->blending, 2 );
+		memcpy( st->lv.prevcontroller, st->controller, 4 );
+	}
+
+	void *pmodel = (studiohdr_t *)IEngineStudio.Mod_Extradata( ent->model );
+
+	GetSequenceInfo( pmodel, st, &fr, &gs );
+	st->m_fSequenceLoops = ((GetSequenceFlags( pmodel, st ) & STUDIO_LOOPING) != 0);
+	StudioFrameAdvance( st, fr, dt );
+	
+	ent->angles				= st->realangles;
+	ent->curstate.angles	= st->angles;
+	ent->curstate.origin	= st->origin;
+
+	ent->curstate.sequence	= st->sequence;
+	pplayer->gaitsequence = st->gaitsequence;
+	ent->curstate.animtime	= st->animtime;
+	ent->curstate.frame		= st->frame;
+	ent->curstate.framerate	= st->framerate;
+	memcpy( ent->curstate.blending, st->blending, 2 );
+	memcpy( ent->curstate.controller, st->controller, 4 );
+
+	ent->latched = st->lv;
+}
+
+/*
+==============================
+RestorePlayerState
+
+Called to restore original player state information
+==============================
+*/
+void CGameStudioModelRenderer::RestorePlayerState( entity_state_t *pplayer )
+{
+	client_anim_state_t *st;
+	cl_entity_t *ent = IEngineStudio.GetCurrentEntity();
+	assert( ent );
+	if ( !ent )
+		return;
+
+	st = &g_clientstate;
+
+	st->angles		= ent->curstate.angles;
+	st->origin		= ent->curstate.origin;
+	st->realangles  = ent->angles;
+
+	st->sequence	= ent->curstate.sequence;
+	st->gaitsequence = pplayer->gaitsequence;
+	st->animtime	= ent->curstate.animtime;
+	st->frame		= ent->curstate.frame;
+	st->framerate	= ent->curstate.framerate;
+	memcpy( st->blending, ent->curstate.blending, 2 );
+	memcpy( st->controller, ent->curstate.controller, 4 );
+
+	st->lv = ent->latched;
+
+	st = &g_state;
+
+	ent->curstate.angles	= st->angles;
+	ent->curstate.origin	= st->origin;
+	ent->angles				= st->realangles;
+
+	ent->curstate.sequence	= st->sequence;
+	pplayer->gaitsequence = st->gaitsequence;
+	ent->curstate.animtime	= st->animtime;
+	ent->curstate.frame		= st->frame;
+	ent->curstate.framerate	= st->framerate;
+	memcpy( ent->curstate.blending, st->blending, 2 );
+	memcpy( ent->curstate.controller, st->controller, 4 );
+
+	ent->latched = st->lv;
+}
+
+/*
+==============================
+StudioDrawPlayer
+
+==============================
+*/
+int CGameStudioModelRenderer::StudioDrawPlayer( int flags, entity_state_t *pplayer )
+{
+	int iret = 0;
+
+	bool isLocalPlayer = false;
+		
+	// Set up for client?
+	if ( m_bLocal && IEngineStudio.GetCurrentEntity() == gEngfuncs.GetLocalPlayer() )
+	{
+		isLocalPlayer = true;
+	}
+
+	if ( isLocalPlayer )
+	{
+		// Store original data
+		SavePlayerState( pplayer );
+
+		// Copy in client side animation data
+		SetupClientAnimation( pplayer );
+	}
+
+	// Call real draw function
+	iret = _StudioDrawPlayer( flags, pplayer );
+
+	// Restore for client?
+	if ( isLocalPlayer )
+	{
+		// Restore the original data for the player
+		RestorePlayerState( pplayer );
+	}
+
+	return iret;
+}
+
+/*
+====================
+_StudioDrawPlayer
+
+====================
+*/
+int CGameStudioModelRenderer::_StudioDrawPlayer( int flags, entity_state_t *pplayer )
+{
+	alight_t lighting;
+	vec3_t dir;
+
+	m_pCurrentEntity = IEngineStudio.GetCurrentEntity();
+	IEngineStudio.GetTimes( &m_nFrameCount, &m_clTime, &m_clOldTime );
+	IEngineStudio.GetViewInfo( m_vRenderOrigin, m_vUp, m_vRight, m_vNormal );
+	IEngineStudio.GetAliasScale( &m_fSoftwareXScale, &m_fSoftwareYScale );
+
+	m_nPlayerIndex = pplayer->number - 1;
+
+	if (m_nPlayerIndex < 0 || m_nPlayerIndex >= gEngfuncs.GetMaxClients())
+		return 0;
+
+	m_pRenderModel = IEngineStudio.SetupPlayerModel( m_nPlayerIndex );
+	if (m_pRenderModel == NULL)
+		return 0;
+
+	m_pStudioHeader = (studiohdr_t *)IEngineStudio.Mod_Extradata (m_pRenderModel);
+	IEngineStudio.StudioSetHeader( m_pStudioHeader );
+	IEngineStudio.SetRenderModel( m_pRenderModel );
+
+	if (pplayer->gaitsequence)
+	{
+		vec3_t orig_angles;
+		m_pPlayerInfo = IEngineStudio.PlayerInfo( m_nPlayerIndex );
+
+		VectorCopy( m_pCurrentEntity->angles, orig_angles );
+	
+		StudioProcessGait( pplayer );
+
+		m_pPlayerInfo->gaitsequence = pplayer->gaitsequence;
+		m_pPlayerInfo = NULL;
+
+		StudioSetUpTransform( 0 );
+		VectorCopy( orig_angles, m_pCurrentEntity->angles );
+	}
+	else
+	{
+		m_pCurrentEntity->curstate.controller[0] = 127;
+		m_pCurrentEntity->curstate.controller[1] = 127;
+		m_pCurrentEntity->curstate.controller[2] = 127;
+		m_pCurrentEntity->curstate.controller[3] = 127;
+		m_pCurrentEntity->latched.prevcontroller[0] = m_pCurrentEntity->curstate.controller[0];
+		m_pCurrentEntity->latched.prevcontroller[1] = m_pCurrentEntity->curstate.controller[1];
+		m_pCurrentEntity->latched.prevcontroller[2] = m_pCurrentEntity->curstate.controller[2];
+		m_pCurrentEntity->latched.prevcontroller[3] = m_pCurrentEntity->curstate.controller[3];
+		
+		m_pPlayerInfo = IEngineStudio.PlayerInfo( m_nPlayerIndex );
+		m_pPlayerInfo->gaitsequence = 0;
+
+		StudioSetUpTransform( 0 );
+	}
+
+	if (flags & STUDIO_RENDER)
+	{
+		// see if the bounding box lets us trivially reject, also sets
+		if (!IEngineStudio.StudioCheckBBox ())
+			return 0;
+
+		(*m_pModelsDrawn)++;
+		(*m_pStudioModelCount)++; // render data cache cookie
+
+		if (m_pStudioHeader->numbodyparts == 0)
+			return 1;
+	}
+
+	m_pPlayerInfo = IEngineStudio.PlayerInfo( m_nPlayerIndex );
+	StudioSetupBones( );
+	StudioSaveBones( );
+	m_pPlayerInfo->renderframe = m_nFrameCount;
+
+	m_pPlayerInfo = NULL;
+
+	if (flags & STUDIO_EVENTS)
+	{
+		StudioCalcAttachments( );
+		IEngineStudio.StudioClientEvents( );
+		// copy attachments into global entity array
+		if ( m_pCurrentEntity->index > 0 )
+		{
+			cl_entity_t *ent = gEngfuncs.GetEntityByIndex( m_pCurrentEntity->index );
+
+			memcpy( ent->attachment, m_pCurrentEntity->attachment, sizeof( vec3_t ) * 4 );
+		}
+	}
+
+	if (flags & STUDIO_RENDER)
+	{
+		/*
+		if (m_pCvarHiModels->value && m_pRenderModel != m_pCurrentEntity->model  )
+		{
+			// show highest resolution multiplayer model
+			m_pCurrentEntity->curstate.body = 255;
+		}
+
+		if (!(m_pCvarDeveloper->value == 0 && gEngfuncs.GetMaxClients() == 1 ) && ( m_pRenderModel == m_pCurrentEntity->model ) )
+		{
+			m_pCurrentEntity->curstate.body = 1; // force helmet
+		}
+		*/
+
+		lighting.plightvec = dir;
+		IEngineStudio.StudioDynamicLight(m_pCurrentEntity, &lighting );
+
+		IEngineStudio.StudioEntityLight( &lighting );
+
+		// model and frame independant
+		IEngineStudio.StudioSetupLighting (&lighting);
+
+		m_pPlayerInfo = IEngineStudio.PlayerInfo( m_nPlayerIndex );
+
+		// get remap colors
+		m_nTopColor = m_pPlayerInfo->topcolor;
+		if (m_nTopColor < 0)
+			m_nTopColor = 0;
+		if (m_nTopColor > 360)
+			m_nTopColor = 360;
+		m_nBottomColor = m_pPlayerInfo->bottomcolor;
+		if (m_nBottomColor < 0)
+			m_nBottomColor = 0;
+		if (m_nBottomColor > 360)
+			m_nBottomColor = 360;
+
+		IEngineStudio.StudioSetRemapColors( m_nTopColor, m_nBottomColor );
+
+		StudioRenderModel( );
+		m_pPlayerInfo = NULL;
+
+		if (pplayer->weaponmodel)
+		{
+			cl_entity_t saveent = *m_pCurrentEntity;
+
+			model_t *pweaponmodel = IEngineStudio.GetModelByIndex( pplayer->weaponmodel );
+
+			m_pStudioHeader = (studiohdr_t *)IEngineStudio.Mod_Extradata (pweaponmodel);
+			IEngineStudio.StudioSetHeader( m_pStudioHeader );
+
+			StudioMergeBones( pweaponmodel);
+
+			IEngineStudio.StudioSetupLighting (&lighting);
+
+			StudioRenderModel( );
+
+			StudioCalcAttachments( );
+
+			*m_pCurrentEntity = saveent;
+		}
+	}
+
+	return 1;
+}
+
+/*
+====================
+Studio_FxTransform
+
+====================
+*/
+void CGameStudioModelRenderer::StudioFxTransform( cl_entity_t *ent, float transform[3][4] )
+{
+	switch( ent->curstate.renderfx )
+	{
+	case kRenderFxDistort:
+	case kRenderFxHologram:
+		if ( gEngfuncs.pfnRandomLong(0,49) == 0 )
+		{
+			int axis = gEngfuncs.pfnRandomLong(0,1);
+			if ( axis == 1 ) // Choose between x & z
+				axis = 2;
+			VectorScale( transform[axis], gEngfuncs.pfnRandomFloat(1,1.484), transform[axis] );
+		}
+		else if ( gEngfuncs.pfnRandomLong(0,49) == 0 )
+		{
+			float offset;
+			int axis = gEngfuncs.pfnRandomLong(0,1);
+			if ( axis == 1 ) // Choose between x & z
+				axis = 2;
+			offset = gEngfuncs.pfnRandomFloat(-10,10);
+			transform[gEngfuncs.pfnRandomLong(0,2)][3] += offset;
+		}
+		break;
+	case kRenderFxExplode:
+		{
+			if ( iRenderStateChanged )
+			{
+				g_flStartScaleTime = m_clTime;
+				iRenderStateChanged = FALSE;
+			}
+
+			// Make the Model continue to shrink
+			float flTimeDelta = m_clTime - g_flStartScaleTime;
+			if ( flTimeDelta > 0 )
+			{
+				float flScale = 0.001;
+				// Goes almost all away
+				if ( flTimeDelta <= 2.0 )
+					flScale = 1.0 - (flTimeDelta / 2.0);
+
+				for (int i = 0; i < 3; i++)
+				{
+					for (int j = 0; j < 3; j++)
+						transform[i][j] *= flScale;
+				}
+			}
+		}
+		break;
+	}
+}
+
+////////////////////////////////////
+// Hooks to class implementation
+////////////////////////////////////
+
+/*
+====================
+R_StudioDrawPlayer
+
+====================
+*/
+int R_StudioDrawPlayer( int flags, entity_state_t *pplayer )
+{
+	return g_StudioRenderer.StudioDrawPlayer( flags, pplayer );
+}
+
+/*
+====================
+R_StudioDrawModel
+
+====================
+*/
+int R_StudioDrawModel( int flags )
+{
+	return g_StudioRenderer.StudioDrawModel( flags );
+}
+
+/*
+====================
+R_StudioInit
+
+====================
+*/
+void R_StudioInit( void )
+{
+	g_StudioRenderer.Init();
+}
+
+// The simple drawing interface we'll pass back to the engine
+r_studio_interface_t studio =
+{
+	STUDIO_INTERFACE_VERSION,
+	R_StudioDrawModel,
+	R_StudioDrawPlayer,
+};
+
+/*
+====================
+HUD_GetStudioModelInterface
+
+Export this function for the engine to use the studio renderer class to render objects.
+====================
+*/
+#define DLLEXPORT __declspec( dllexport )
+extern "C" int DLLEXPORT HUD_GetStudioModelInterface( int version, struct r_studio_interface_s **ppinterface, struct engine_studio_api_s *pstudio )
+{
+	if ( version != STUDIO_INTERFACE_VERSION )
+		return 0;
+
+	// Point the engine to our callbacks
+	*ppinterface = &studio;
+
+	// Copy in engine helper functions
+	memcpy( &IEngineStudio, pstudio, sizeof( IEngineStudio ) );
+
+	// Initialize local variables, etc.
+	R_StudioInit();
+
+	// Success
+	return 1;
+}

hlsdk/ricochet/cl_dll/GameStudioModelRenderer.h

@@ -0,0 +1,48 @@
+#if !defined( GAMESTUDIOMODELRENDERER_H )
+#define GAMESTUDIOMODELRENDERER_H
+#if defined( _WIN32 )
+#pragma once
+#endif
+
+/*
+====================
+CGameStudioModelRenderer
+
+====================
+*/
+class CGameStudioModelRenderer : public CStudioModelRenderer
+{
+public:
+	CGameStudioModelRenderer( void );
+
+	// Set up model bone positions
+	virtual void StudioSetupBones ( void );	
+
+	// Estimate gait frame for player
+	virtual void StudioEstimateGait ( entity_state_t *pplayer );
+
+	// Process movement of player
+	virtual void StudioProcessGait ( entity_state_t *pplayer );
+
+	// Player drawing code
+	virtual int StudioDrawPlayer( int flags, entity_state_t *pplayer );
+	virtual int _StudioDrawPlayer( int flags, entity_state_t *pplayer );
+
+	// Apply special effects to transform matrix
+	virtual void StudioFxTransform( cl_entity_t *ent, float transform[3][4] );
+
+private:
+	// For local player, in third person, we need to store real render data and then
+	//  setup for with fake/client side animation data
+	void SavePlayerState( entity_state_t *pplayer );
+	// Called to set up local player's animation values
+	void SetupClientAnimation( entity_state_t *pplayer );
+	// Called to restore original player state information
+	void RestorePlayerState( entity_state_t *pplayer );
+
+private: 
+	// Private data
+	bool m_bLocal;
+};
+
+#endif // GAMESTUDIOMODELRENDERER_H

hlsdk/ricochet/cl_dll/Ricochet_BSPFile.h

@@ -0,0 +1,41 @@
+#if !defined( RICOCHET_BSPFILE_H )
+#define RICOCHET_BSPFILE_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+// MINI-version of BSPFILE.H to support Ricochet entity lump extraction stuff.
+
+#define BSPVERSION	30
+
+typedef struct
+{
+	int		fileofs, filelen;
+} lump_t;
+
+#define	LUMP_ENTITIES	0
+#define	LUMP_PLANES		1
+#define	LUMP_TEXTURES	2
+#define	LUMP_VERTEXES	3
+#define	LUMP_VISIBILITY	4
+#define	LUMP_NODES		5
+#define	LUMP_TEXINFO	6
+#define	LUMP_FACES		7
+#define	LUMP_LIGHTING	8
+#define	LUMP_CLIPNODES	9
+#define	LUMP_LEAFS		10
+#define	LUMP_MARKSURFACES 11
+#define	LUMP_EDGES		12
+#define	LUMP_SURFEDGES	13
+#define	LUMP_MODELS		14
+
+#define	HEADER_LUMPS	15
+
+typedef struct
+{
+	int			version;	
+	lump_t		lumps[HEADER_LUMPS];
+} dheader_t;
+
+
+#endif // RICOCHET_BSPFILE_H

hlsdk/ricochet/cl_dll/Ricochet_JumpPads.cpp

@@ -0,0 +1,586 @@
+#include "extdll.h"
+#include "entity_state.h"
+#include "pm_defs.h"
+#include "pm_movevars.h"
+#include "hud_iface.h"
+#include "com_model.h"
+#include "event_api.h"
+#include "com_weapons.h"
+#include "event_flags.h"
+#include "Ricochet_BSPFile.h"
+
+extern "C" playermove_t *pmove;
+extern int g_runfuncs;
+
+// Don't support more than MAX_PADS pads ( map still can load, but we'll just have some pads that don't predict. )
+#define MAX_PADS 256
+
+// We only care about two kinds of entities for now:  Jump pads and their targets
+// FIXME:  After loading, store a pointer from pad to target instead of looking up all the time.
+typedef enum
+{
+	// Entity is a jump pad
+	RIC_PAD = 0,
+	// Entity is a target
+	RIC_TARGET
+} ric_padtype_t;
+
+typedef struct
+{
+	// Type of entity
+	ric_padtype_t	type;
+
+	// Classname
+	char			classname[ 32 ];
+
+	// Model name
+	char			modelname[ 32 ];
+
+	// What this entity targets
+	char			target[ 32 ];
+
+	// If entity is a target, the name tag it uses
+	char			targetname[ 32 ];
+
+	// Orientation of the pad
+	float			angles[3];
+
+	// Target origin
+	float			origin[3];
+
+	// Bounding box of the pad
+	float			absmin[3];
+	float			absmax[3];
+
+	// Model associated with the pad
+	struct	model_s *model;
+
+	float			height;
+} ric_pad_t;
+
+// Pad/Target entity database
+static ric_pad_t s_pads[ MAX_PADS ];
+static int s_num_pads = 0;
+
+// We'll use this for playing the jump sounds locally.
+static unsigned short s_usJump;
+
+/*
+==============================
+Ricochet_SetKeyValue
+
+Fill in key/values fro the pad
+==============================
+*/
+void Ricochet_SetKeyValue( ric_pad_t *pad, const char *key, const char *value )
+{
+	float x, y, z;
+
+	if ( !stricmp( key, "classname" ) )
+	{
+		strcpy( pad->classname, value );
+	}
+	else if ( !stricmp( key, "target" ) )
+	{
+		strcpy( pad->target, value );
+	}
+	else if ( !stricmp( key, "targetname" ) )
+	{
+		strcpy( pad->targetname, value );
+	}
+	else if ( !stricmp( key, "model" ) )
+	{
+		strcpy( pad->modelname, value );
+	}
+	else if ( !stricmp( key, "height" ) )
+	{
+		pad->height = atof( value );
+	}
+	else if ( !stricmp( key, "angles" ) )
+	{
+		if ( sscanf( value, "%f %f %f", &x, &y, &z ) == 3 )
+		{
+			pad->angles[ 0 ] = x ;
+			pad->angles[ 1 ] = y;
+			pad->angles[ 2 ] = z;
+		}
+	}
+	else if ( !stricmp( key, "origin" ) )
+	{
+		if ( sscanf( value, "%f %f %f", &x, &y, &z ) == 3 )
+		{
+			pad->origin[ 0 ]  = x;
+			pad->origin[ 1 ]  = y;
+			pad->origin[ 2 ]  = z;
+		}
+	}
+}
+
+/*
+==============================
+Ricochet_ParsePad
+
+Evaluate Key/Value pairs for the entity
+==============================
+*/
+char *Ricochet_ParsePad( char *buffer, ric_pad_t *pad, int *error )
+{
+	char		key[256];
+	char		token[ 1024 ];
+	int			n;
+
+	memset( pad, 0, sizeof( *pad ) );
+
+	while (1)
+	{	
+		// Parse key
+		buffer = gEngfuncs.COM_ParseFile ( buffer, token );
+		if ( token[0] == '}' )
+			break;
+
+		// Ran out of input buffer?
+		if ( !buffer )
+		{
+			*error = 1;
+			break;
+		}
+		
+		// Store off the key
+		strcpy ( key, token );
+
+		// Fix heynames with trailing spaces
+		n = strlen( key );
+		while (n && key[n-1] == ' ')
+		{
+			key[n-1] = 0;
+			n--;
+		}
+
+		// Parse value	
+		buffer = gEngfuncs.COM_ParseFile ( buffer, token );
+
+		// Ran out of buffer?
+		if (!buffer)
+		{
+			*error = 1;
+			break;
+		}
+
+		// Hit the end instead of a value?
+		if ( token[0] == '}' )
+		{
+			*error = 1;
+			break;
+		}
+
+		// Assign k/v pair
+		Ricochet_SetKeyValue( pad, key, token );
+	}
+
+	// Return what's left in the stream
+	return buffer;
+}
+
+/*
+==============================
+Ricochet_ProcessEnts
+
+Parse through entity lump looking for pads or targets
+==============================
+*/
+void Ricochet_ProcessEnts( char *buffer )
+{	
+	int i;
+	char token[ 1024 ];
+	ric_pad_t	*pad = NULL;
+	int			error = 0;
+	
+	// parse entities from entity lump of .bsp file
+	while (1)
+	{
+		// parse the opening brace	
+		buffer = gEngfuncs.COM_ParseFile ( buffer, token );
+		if (!buffer)
+			break;
+		
+		// Didn't find opening brace?
+		if ( token[0] != '{' )
+		{
+			gEngfuncs.Con_Printf ("Ricochet_ProcessEnts: found %s when expecting {\n", token );
+			return;
+		}
+
+		// Assume we're filling in this pad
+		pad = &s_pads[ s_num_pads ];
+
+		// Fill in data
+		buffer = Ricochet_ParsePad( buffer, pad, &error );
+
+		// Check for errors and abort if any
+		if ( error )
+		{
+			gEngfuncs.Con_Printf ("Ricochet_ProcessEnts: error parsing entities\n" );
+			return;
+		}
+
+		// Check classname
+		if ( stricmp( pad->classname, "trigger_jump" ) && stricmp( pad->classname, "info_target" ) )
+			continue;
+
+		// Set type based on classname
+		if ( !stricmp( pad->classname, "trigger_jump" ) )
+		{
+			pad->type = RIC_PAD;
+		}
+		else
+		{
+			pad->type = RIC_TARGET;
+		}
+
+		// Load up the model
+		pad->model = gEngfuncs.CL_LoadModel( pad->modelname, NULL );
+		if ( pad->model )
+		{
+			// Fill in abs bbox
+			for ( i = 0; i < 3; i++ )
+			{
+				pad->absmin[ i ] = pad->model->mins[ i ] - 1.0;
+				pad->absmax[ i ] = pad->model->maxs[ i ] + 1.0;
+			}
+		}
+
+		// If we got to here, we're using the entity
+		s_num_pads++;
+
+		// No more room...
+		if ( s_num_pads >= MAX_PADS )
+			break;
+	}
+}
+
+/*
+==============================
+Ricochet_LoadEntityLump
+
+Open the .bsp and read in the entity lump
+==============================
+*/
+char *Ricochet_LoadEntityLump( const char *filename )
+{
+	FILE		*fp;
+	int			i;
+	dheader_t	header;
+	int			size;
+	lump_t		*curLump;
+	char		*buffer = NULL;
+
+	fp = fopen( filename, "rb" );
+	if ( !fp )
+		return NULL;
+
+	// Read in the .bsp header
+	if ( fread(&header, sizeof(dheader_t), 1, fp) != 1 )
+	{
+		gEngfuncs.Con_Printf("Ricochet_LoadEntityLump:  Could not read BSP header for map [%s].\n", filename);
+		fclose(fp);
+		return NULL;
+	}
+
+	// Check the version
+	i = header.version;
+	if ( i != 29 && i != 30)
+	{
+		fclose(fp);
+		gEngfuncs.Con_Printf("Ricochet_LoadEntityLump:  Map [%s] has incorrect BSP version (%i should be %i).\n", filename, i, BSPVERSION);
+		return NULL;
+	}
+
+	// Get entity lump
+	curLump = &header.lumps[ LUMP_ENTITIES ];
+	// and entity lump size
+	size = curLump->filelen;
+
+	// Jump to it
+	fseek( fp, curLump->fileofs, SEEK_SET );
+
+	// Allocate sufficient memmory
+	buffer = (char *)malloc( size + 1 );
+	if ( !buffer )
+	{
+		fclose(fp);
+		gEngfuncs.Con_Printf("Ricochet_LoadEntityLump:  Couldn't allocate %i bytes\n", size + 1 );
+		return NULL;
+	}
+
+	// Read in the entity lump
+	fread( buffer, size, 1, fp );
+
+	// Terminate the string
+	buffer[ size ] = '\0';
+
+	if ( fp )
+	{
+		fclose(fp);
+	}
+
+	return buffer;
+}
+
+/*
+==============================
+Ricochet_LoadJumpPads
+
+Load in the .bsp file and process the entities
+==============================
+*/
+void Ricochet_LoadJumpPads( const char *map )
+{
+	char	*buffer = NULL;
+	char	filename[ 256 ];
+
+	sprintf( filename, "%s/%s", gEngfuncs.pfnGetGameDirectory(), map );
+
+	// TODO:  Fix Slashes?
+
+	// Reset count
+	s_num_pads = 0;
+
+	// Load entity lump
+	buffer = Ricochet_LoadEntityLump( filename );
+	if ( !buffer )
+		return;
+
+	// Process buffer and extract pads/targets
+	Ricochet_ProcessEnts( buffer );
+
+	// Discard buffer
+	free( buffer );
+}
+
+/*
+==============================
+Ricochet_FindTarget
+
+Search entity list for target matching "name"
+==============================
+*/
+ric_pad_t *Ricochet_FindTarget( const char *name, int numpads, ric_pad_t *pads )
+{
+	int i;
+	ric_pad_t *target;
+
+	// Find the target
+	for ( i = 0; i < numpads; i++ )
+	{
+		target = &pads[ i ];
+		if ( !target )
+			continue;
+
+		if ( stricmp( target->targetname, name ) )
+			continue;
+
+		return target;
+	}
+
+	return NULL;
+}
+
+/*
+==============================
+Ricochet_PadTouched
+
+Register impact ( impart velocity on player and if final function call, play appropriate jump sound )
+==============================
+*/
+void Ricochet_PadTouched( int numpads, ric_pad_t *pads, ric_pad_t *pad, struct local_state_s *player )
+{
+	int				i;
+	ric_pad_t		*target;
+	float			origin[ 3 ];
+	pmtrace_t 		tr;
+	float			flGravity = pmove->movevars->gravity;
+
+	float			vecMidPoint[3];
+	float			end[ 3 ];
+
+	// Ricochet jump pads use default jump height
+	float			flHeight = 150;
+
+	float			zero[ 3 ] = { 0.0, 0.0, 0.0 };
+
+	// Find the target
+	target = Ricochet_FindTarget( pad->target, numpads, pads );
+
+	// Target now points to target pad
+	for ( i = 0; i < 3; i++ )
+	{
+		origin[ i ] = player->playerstate.origin[ i ];
+		
+		// Get a rough idea of how high to launch
+		vecMidPoint[ i ] = origin[ i ] + ( target->origin[ i ] - origin[ i ]) * 0.5;
+		end[ i ] = vecMidPoint[ i ];
+	}
+
+	if ( pad->height != 0.0 )
+	{
+		flHeight = pad->height;
+	}
+
+	// Move up by height
+	end[ 2 ] += flHeight;
+
+	// See if we can reach the apex from the midpoint
+	gEngfuncs.pEventAPI->EV_PlayerTrace( vecMidPoint, end, PM_STUDIO_BOX, -1, &tr );
+
+	// Use the end point of the trace as the midpoint of the actual toss
+	for ( i = 0; i < 3; i++ )
+	{
+		vecMidPoint[i] = tr.endpos[i];
+	}
+
+	// Subtract some units so we don't hit the ceiling)
+	vecMidPoint[2] -= 15;
+
+	// How high should we travel to reach the apex
+	float distance1 = fabs(vecMidPoint[2] - origin[2]);
+	float distance2 = fabs(vecMidPoint[2] - target->origin[2]);
+
+	// How long will it take to travel this distance
+	float time1 = sqrt( distance1 / (0.5 * flGravity) );
+	float time2 = sqrt( distance2 / (0.5 * flGravity) );
+	if (time1 < 0.1)
+		return;
+
+	// Determine how hard to launch to get there in time.
+	float vecTargetVel[3];
+	
+	for ( i = 0; i < 3; i++ )
+	{
+		vecTargetVel[ i ] = (target->origin[ i ] - origin[ i ]) / (time1 + time2);
+	}
+
+	// Adjust upward velocity needed
+	vecTargetVel[ 2 ] = flGravity * time1;
+
+	// Fill in needed velocity
+	for ( i = 0; i < 3; i++ )
+	{
+		player->client.velocity[i] = vecTargetVel[i];
+	}
+
+	// Play sound if appropriate
+	if ( s_usJump && g_runfuncs )
+	{
+		gEngfuncs.pfnPlaybackEvent( FEV_NOTHOST, NULL, s_usJump, 0.0, zero, zero, 0.0, 0.0, 0, 0, 0, 0 );
+	}
+}
+
+/*
+==============================
+Ricochet_TouchPads
+
+See if player's resting position impacts any jump pads
+==============================
+*/
+void Ricochet_TouchPads (  struct local_state_s *player, ric_pad_t *pads, int numpads )
+{
+	int			i, j;
+	ric_pad_t	*pad;
+	float		absmin[3], absmax[3];
+	physent_t	pe;
+	hull_t		*hull;
+	int			num;
+	float		test[3];
+	float		pmins[ 3 ] = { 16, 16, 36 };
+
+	// Determine player's bbox
+	for ( j = 0; j < 3; j++ )
+	{
+		absmin[ j ] = player->playerstate.origin[ j ] - pmins[ j ];
+		absmax[ j ] = player->playerstate.origin[ j ] + pmins[ j ];
+	}
+
+	// Cycle through pads looking for a match
+	for ( i = 0; i < numpads; i++ )
+	{
+		pad = &pads[ i ];
+		if ( !pad )
+			continue;
+
+		// Target entities don't make us jump
+		if ( pad->type != RIC_PAD )
+			continue;
+
+		// Trivial reject?
+		if ( absmin[0] > pad->absmax[0]
+			|| absmin[1] > pad->absmax[1]
+			|| absmin[2] > pad->absmax[2]
+			|| absmax[0] < pad->absmin[0]
+			|| absmax[1] < pad->absmin[1]
+			|| absmax[2] < pad->absmin[2] )
+			continue;
+			
+		// Set up physent for the test case
+		pe.model	= pad->model;
+		pe.origin	= pad->origin;
+		
+		// Use standing player hull
+		pmove->usehull = 0;
+
+		// Make sure it's a brush model, of course
+		if ( !pe.model || (modtype_t)pmove->PM_GetModelType( pe.model ) != mod_brush )
+			continue;
+
+		// Get the hull
+		hull = (hull_t *)pmove->PM_HullForBsp( &pe, test );
+		num = hull->firstclipnode;
+
+		// Offset the origin by the offset appropriate for this hull.
+		for ( j = 0; j < 3; j++ )
+		{
+			test[ j ] = player->playerstate.origin[ j ] - test[ j ];
+		}
+
+		// Test the player's hull for intersection with this model
+		if ( pmove->PM_HullPointContents ( hull, num, test ) != CONTENTS_SOLID )
+		{
+			continue;
+		}
+		
+		// TOUCHED!!!
+		Ricochet_PadTouched( numpads, pads, pad, player );
+
+		// Only touch one pad at a time
+		break;
+	}
+}
+
+/*
+==============================
+Ricochet_CheckJumpPads
+
+Load data if needed, otherwise just run checks on player's final position to see if jump pad needs
+ to impart velocity on the player.
+==============================
+*/
+void Ricochet_CheckJumpPads( struct local_state_s *from, struct local_state_s *to )
+{
+	static char current_level[ 128 ];
+	
+	// See if we've changed to a new map
+	if ( stricmp( current_level, gEngfuncs.pfnGetLevelName() ) )
+	{
+		strcpy( current_level, gEngfuncs.pfnGetLevelName() );
+		Ricochet_LoadJumpPads( current_level );
+
+		// Grab sound event
+		s_usJump = gEngfuncs.pfnPrecacheEvent( 1, "events/jump.sc" );
+	}
+
+	// Not while spectating
+	if ( to->client.iuser1 )
+		return;
+
+	// Run test
+	Ricochet_TouchPads( to, s_pads, s_num_pads );
+}

hlsdk/ricochet/cl_dll/Ricochet_JumpPads.h

@@ -0,0 +1,9 @@
+#if !defined( RICHOCHET_JUMPADS_H )
+#define RICHOCHET_JUMPADS_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+void Ricochet_CheckJumpPads( struct local_state_s *from, struct local_state_s *to );
+
+#endif // RICHOCHET_JUMPADS_H

hlsdk/ricochet/cl_dll/StudioModelRenderer.h

@@ -0,0 +1,182 @@
+#if !defined ( STUDIOMODELRENDERER_H )
+#define STUDIOMODELRENDERER_H
+#if defined( _WIN32 )
+#pragma once
+#endif
+
+/*
+====================
+CStudioModelRenderer
+
+====================
+*/
+class CStudioModelRenderer
+{
+public:
+	// Construction/Destruction
+	CStudioModelRenderer( void );
+	virtual ~CStudioModelRenderer( void );
+
+	// Initialization
+	virtual void Init( void );
+
+public:  
+	// Public Interfaces
+	virtual int StudioDrawModel ( int flags );
+	virtual int StudioDrawPlayer ( int flags, struct entity_state_s *pplayer );
+
+public:
+	// Local interfaces
+	//
+
+	// Look up animation data for sequence
+	virtual mstudioanim_t *StudioGetAnim ( model_t *m_pSubModel, mstudioseqdesc_t *pseqdesc );
+
+	// Interpolate model position and angles and set up matrices
+	virtual void StudioSetUpTransform (int trivial_accept);
+
+	// Set up model bone positions
+	virtual void StudioSetupBones ( void );	
+
+	// Find final attachment points
+	virtual void StudioCalcAttachments ( void );
+	
+	// Save bone matrices and names
+	virtual void StudioSaveBones( void );
+
+	// Merge cached bones with current bones for model
+	virtual void StudioMergeBones ( model_t *m_pSubModel );
+
+	// Determine interpolation fraction
+	virtual float StudioEstimateInterpolant( void );
+
+	// Determine current frame for rendering
+	virtual float StudioEstimateFrame ( mstudioseqdesc_t *pseqdesc );
+
+	// Apply special effects to transform matrix
+	virtual void StudioFxTransform( cl_entity_t *ent, float transform[3][4] );
+
+	// Spherical interpolation of bones
+	virtual void StudioSlerpBones ( vec4_t q1[], float pos1[][3], vec4_t q2[], float pos2[][3], float s );
+
+	// Compute bone adjustments ( bone controllers )
+	virtual void StudioCalcBoneAdj ( float dadt, float *adj, const byte *pcontroller1, const byte *pcontroller2, byte mouthopen );
+
+	// Get bone quaternions
+	virtual void StudioCalcBoneQuaterion ( int frame, float s, mstudiobone_t *pbone, mstudioanim_t *panim, float *adj, float *q );
+
+	// Get bone positions
+	virtual void StudioCalcBonePosition ( int frame, float s, mstudiobone_t *pbone, mstudioanim_t *panim, float *adj, float *pos );
+
+	// Compute rotations
+	virtual void StudioCalcRotations ( float pos[][3], vec4_t *q, mstudioseqdesc_t *pseqdesc, mstudioanim_t *panim, float f );
+
+	// Send bones and verts to renderer
+	virtual void StudioRenderModel ( void );
+
+	// Finalize rendering
+	virtual void StudioRenderFinal (void);
+	
+	// GL&D3D vs. Software renderer finishing functions
+	virtual void StudioRenderFinal_Software ( void );
+	virtual void StudioRenderFinal_Hardware ( void );
+
+	// Player specific data
+	// Determine pitch and blending amounts for players
+	virtual void StudioPlayerBlend ( mstudioseqdesc_t *pseqdesc, int *pBlend, float *pPitch );
+
+	// Estimate gait frame for player
+	virtual void StudioEstimateGait ( entity_state_t *pplayer );
+
+	// Process movement of player
+	virtual void StudioProcessGait ( entity_state_t *pplayer );
+
+public:
+
+	// Client clock
+	double			m_clTime;				
+	// Old Client clock
+	double			m_clOldTime;			
+
+	// Do interpolation?
+	int				m_fDoInterp;			
+	// Do gait estimation?
+	int				m_fGaitEstimation;		
+
+	// Current render frame #
+	int				m_nFrameCount;
+
+	// Cvars that studio model code needs to reference
+	//
+	// Use high quality models?
+	cvar_t			*m_pCvarHiModels;	
+	// Developer debug output desired?
+	cvar_t			*m_pCvarDeveloper;
+	// Draw entities bone hit boxes, etc?
+	cvar_t			*m_pCvarDrawEntities;
+
+	// The entity which we are currently rendering.
+	cl_entity_t		*m_pCurrentEntity;		
+
+	// The model for the entity being rendered
+	model_t			*m_pRenderModel;
+
+	// Player info for current player, if drawing a player
+	player_info_t	*m_pPlayerInfo;
+
+	// The index of the player being drawn
+	int				m_nPlayerIndex;
+
+	// The player's gait movement
+	float			m_flGaitMovement;
+
+	// Pointer to header block for studio model data
+	studiohdr_t		*m_pStudioHeader;
+	
+	// Pointers to current body part and submodel
+	mstudiobodyparts_t *m_pBodyPart;
+	mstudiomodel_t	*m_pSubModel;
+
+	// Palette substition for top and bottom of model
+	int				m_nTopColor;			
+	int				m_nBottomColor;
+
+	//
+	// Sprite model used for drawing studio model chrome
+	model_t			*m_pChromeSprite;
+
+	// Caching
+	// Number of bones in bone cache
+	int				m_nCachedBones; 
+	// Names of cached bones
+	char			m_nCachedBoneNames[ MAXSTUDIOBONES ][ 32 ];
+	// Cached bone & light transformation matrices
+	float			m_rgCachedBoneTransform [ MAXSTUDIOBONES ][ 3 ][ 4 ];
+	float			m_rgCachedLightTransform[ MAXSTUDIOBONES ][ 3 ][ 4 ];
+
+	// Software renderer scale factors
+	float			m_fSoftwareXScale, m_fSoftwareYScale;
+
+	// Current view vectors and render origin
+	float			m_vUp[ 3 ];
+	float			m_vRight[ 3 ];
+	float			m_vNormal[ 3 ];
+
+	float			m_vRenderOrigin[ 3 ];
+	
+	// Model render counters ( from engine )
+	int				*m_pStudioModelCount;
+	int				*m_pModelsDrawn;
+
+	// Matrices
+	// Model to world transformation
+	float			(*m_protationmatrix)[ 3 ][ 4 ];	
+	// Model to view transformation
+	float			(*m_paliastransform)[ 3 ][ 4 ];	
+
+	// Concatenated bone and light transforms
+	float			(*m_pbonetransform) [ MAXSTUDIOBONES ][ 3 ][ 4 ];
+	float			(*m_plighttransform)[ MAXSTUDIOBONES ][ 3 ][ 4 ];
+};
+
+#endif // STUDIOMODELRENDERER_H

hlsdk/ricochet/cl_dll/ammo.cpp

@@ -0,0 +1,930 @@
+/***
+*
+*	Copyright (c) 1999, 2000 Valve LLC. All rights reserved.
+*	
+*	This product contains software technology licensed from Id 
+*	Software, Inc. ("Id Technology").  Id Technology (c) 1996 Id Software, Inc. 
+*	All Rights Reserved.
+*
+*   Use, distribution, and modification of this source code and/or resulting
+*   object code is restricted to non-commercial enhancements to products from
+*   Valve LLC.  All other use, distribution, or modification is prohibited
+*   without written permission from Valve LLC.
+*
+****/
+//
+// Ammo.cpp
+//
+// implementation of CHudAmmo class
+//
+
+#include "hud.h"
+#include "cl_util.h"
+#include "parsemsg.h"
+
+#include <string.h>
+#include <stdio.h>
+
+#include "ammohistory.h"
+
+WEAPON *gpActiveSel;	// NULL means off, 1 means just the menu bar, otherwise
+						// this points to the active weapon menu item
+WEAPON *gpLastSel;		// Last weapon menu selection 
+
+client_sprite_t *GetSpriteList(client_sprite_t *pList, const char *psz, int iRes, int iCount);
+
+WeaponsResource gWR;
+
+int g_weaponselect = 0;
+
+void WeaponsResource :: LoadAllWeaponSprites( void )
+{
+	for (int i = 0; i < MAX_WEAPONS; i++)
+	{
+		if ( rgWeapons[i].iId )
+			LoadWeaponSprites( &rgWeapons[i] );
+	}
+}
+
+int WeaponsResource :: CountAmmo( int iId ) 
+{ 
+	if ( iId < 0 )
+		return 0;
+
+	return riAmmo[iId];
+}
+
+int WeaponsResource :: HasAmmo( WEAPON *p )
+{
+	if ( !p )
+		return FALSE;
+
+	// weapons with no max ammo can always be selected
+	if ( p->iMax1 == -1 )
+		return TRUE;
+
+	return (p->iAmmoType == -1) || p->iClip > 0 || CountAmmo(p->iAmmoType) 
+		|| CountAmmo(p->iAmmo2Type) || ( p->iFlags & WEAPON_FLAGS_SELECTONEMPTY );
+}
+
+
+void WeaponsResource :: LoadWeaponSprites( WEAPON *pWeapon )
+{
+	int i, iRes;
+
+	if (ScreenWidth < 640)
+		iRes = 320;
+	else
+		iRes = 640;
+
+	char sz[128];
+
+	if ( !pWeapon )
+		return;
+
+	memset( &pWeapon->rcActive, 0, sizeof(wrect_t) );
+	memset( &pWeapon->rcInactive, 0, sizeof(wrect_t) );
+	memset( &pWeapon->rcAmmo, 0, sizeof(wrect_t) );
+	memset( &pWeapon->rcAmmo2, 0, sizeof(wrect_t) );
+	pWeapon->hInactive = 0;
+	pWeapon->hActive = 0;
+	pWeapon->hAmmo = 0;
+	pWeapon->hAmmo2 = 0;
+
+	sprintf(sz, "sprites/%s.txt", pWeapon->szName);
+	client_sprite_t *pList = SPR_GetList(sz, &i);
+
+	if (!pList)
+		return;
+
+	client_sprite_t *p;
+	
+	p = GetSpriteList( pList, "crosshair", iRes, i );
+	if (p)
+	{
+		sprintf(sz, "sprites/%s.spr", p->szSprite);
+		pWeapon->hCrosshair = SPR_Load(sz);
+		pWeapon->rcCrosshair = p->rc;
+	}
+	else
+		pWeapon->hCrosshair = NULL;
+
+	p = GetSpriteList(pList, "autoaim", iRes, i);
+	if (p)
+	{
+		sprintf(sz, "sprites/%s.spr", p->szSprite);
+		pWeapon->hAutoaim = SPR_Load(sz);
+		pWeapon->rcAutoaim = p->rc;
+	}
+	else
+		pWeapon->hAutoaim = 0;
+
+	p = GetSpriteList( pList, "zoom", iRes, i );
+	if (p)
+	{
+		sprintf(sz, "sprites/%s.spr", p->szSprite);
+		pWeapon->hZoomedCrosshair = SPR_Load(sz);
+		pWeapon->rcZoomedCrosshair = p->rc;
+	}
+	else
+	{
+		pWeapon->hZoomedCrosshair = pWeapon->hCrosshair; //default to non-zoomed crosshair
+		pWeapon->rcZoomedCrosshair = pWeapon->rcCrosshair;
+	}
+
+	p = GetSpriteList(pList, "zoom_autoaim", iRes, i);
+	if (p)
+	{
+		sprintf(sz, "sprites/%s.spr", p->szSprite);
+		pWeapon->hZoomedAutoaim = SPR_Load(sz);
+		pWeapon->rcZoomedAutoaim = p->rc;
+	}
+	else
+	{
+		pWeapon->hZoomedAutoaim = pWeapon->hZoomedCrosshair;  //default to zoomed crosshair
+		pWeapon->rcZoomedAutoaim = pWeapon->rcZoomedCrosshair;
+	}
+
+	p = GetSpriteList(pList, "weapon", iRes, i);
+	if (p)
+	{
+		sprintf(sz, "sprites/%s.spr", p->szSprite);
+		pWeapon->hInactive = SPR_Load(sz);
+		pWeapon->rcInactive = p->rc;
+
+		gHR.iHistoryGap = max( gHR.iHistoryGap, pWeapon->rcActive.bottom - pWeapon->rcActive.top );
+	}
+	else
+		pWeapon->hInactive = 0;
+
+	p = GetSpriteList(pList, "weapon_s", iRes, i);
+	if (p)
+	{
+		sprintf(sz, "sprites/%s.spr", p->szSprite);
+		pWeapon->hActive = SPR_Load(sz);
+		pWeapon->rcActive = p->rc;
+	}
+	else
+		pWeapon->hActive = 0;
+
+	p = GetSpriteList(pList, "ammo", iRes, i);
+	if (p)
+	{
+		sprintf(sz, "sprites/%s.spr", p->szSprite);
+		pWeapon->hAmmo = SPR_Load(sz);
+		pWeapon->rcAmmo = p->rc;
+
+		gHR.iHistoryGap = max( gHR.iHistoryGap, pWeapon->rcActive.bottom - pWeapon->rcActive.top );
+	}
+	else
+		pWeapon->hAmmo = 0;
+
+	p = GetSpriteList(pList, "ammo2", iRes, i);
+	if (p)
+	{
+		sprintf(sz, "sprites/%s.spr", p->szSprite);
+		pWeapon->hAmmo2 = SPR_Load(sz);
+		pWeapon->rcAmmo2 = p->rc;
+
+		gHR.iHistoryGap = max( gHR.iHistoryGap, pWeapon->rcActive.bottom - pWeapon->rcActive.top );
+	}
+	else
+		pWeapon->hAmmo2 = 0;
+
+}
+
+// Returns the first weapon for a given slot.
+WEAPON *WeaponsResource :: GetFirstPos( int iSlot )
+{
+	WEAPON *pret = NULL;
+
+	for (int i = 0; i < MAX_WEAPON_POSITIONS; i++)
+	{
+		if ( rgSlots[iSlot][i] && HasAmmo( rgSlots[iSlot][i] ) )
+		{
+			pret = rgSlots[iSlot][i];
+			break;
+		}
+	}
+
+	return pret;
+}
+
+
+WEAPON* WeaponsResource :: GetNextActivePos( int iSlot, int iSlotPos )
+{
+	if ( iSlotPos >= MAX_WEAPON_POSITIONS || iSlot >= MAX_WEAPON_SLOTS )
+		return NULL;
+
+	WEAPON *p = gWR.rgSlots[ iSlot ][ iSlotPos+1 ];
+	
+	if ( !p || !gWR.HasAmmo(p) )
+		return GetNextActivePos( iSlot, iSlotPos + 1 );
+
+	return p;
+}
+
+
+int giBucketHeight, giBucketWidth, giABHeight, giABWidth; // Ammo Bar width and height
+
+HSPRITE ghsprBuckets;					// Sprite for top row of weapons menu
+
+DECLARE_MESSAGE(m_Ammo, CurWeapon );	// Current weapon and clip
+DECLARE_MESSAGE(m_Ammo, WeaponList);	// new weapon type
+DECLARE_MESSAGE(m_Ammo, AmmoX);			// update known ammo type's count
+DECLARE_MESSAGE(m_Ammo, AmmoPickup);	// flashes an ammo pickup record
+DECLARE_MESSAGE(m_Ammo, WeapPickup);    // flashes a weapon pickup record
+DECLARE_MESSAGE(m_Ammo, HideWeapon);	// hides the weapon, ammo, and crosshair displays temporarily
+DECLARE_MESSAGE(m_Ammo, ItemPickup);
+
+DECLARE_COMMAND(m_Ammo, Slot1);
+DECLARE_COMMAND(m_Ammo, Slot2);
+DECLARE_COMMAND(m_Ammo, Slot3);
+DECLARE_COMMAND(m_Ammo, Slot4);
+DECLARE_COMMAND(m_Ammo, Slot5);
+DECLARE_COMMAND(m_Ammo, Slot6);
+DECLARE_COMMAND(m_Ammo, Slot7);
+DECLARE_COMMAND(m_Ammo, Slot8);
+DECLARE_COMMAND(m_Ammo, Slot9);
+DECLARE_COMMAND(m_Ammo, Slot10);
+DECLARE_COMMAND(m_Ammo, Close);
+DECLARE_COMMAND(m_Ammo, NextWeapon);
+DECLARE_COMMAND(m_Ammo, PrevWeapon);
+
+// width of ammo fonts
+#define AMMO_SMALL_WIDTH 10
+#define AMMO_LARGE_WIDTH 20
+
+#define HISTORY_DRAW_TIME	"5"
+
+int CHudAmmo::Init(void)
+{
+	gHUD.AddHudElem(this);
+
+	HOOK_MESSAGE(CurWeapon);
+	HOOK_MESSAGE(WeaponList);
+	HOOK_MESSAGE(AmmoPickup);
+	HOOK_MESSAGE(WeapPickup);
+	HOOK_MESSAGE(ItemPickup);
+	HOOK_MESSAGE(HideWeapon);
+	HOOK_MESSAGE(AmmoX);
+
+	HOOK_COMMAND("slot1", Slot1);
+	HOOK_COMMAND("slot2", Slot2);
+	HOOK_COMMAND("slot3", Slot3);
+	HOOK_COMMAND("slot4", Slot4);
+	HOOK_COMMAND("slot5", Slot5);
+	HOOK_COMMAND("slot6", Slot6);
+	HOOK_COMMAND("slot7", Slot7);
+	HOOK_COMMAND("slot8", Slot8);
+	HOOK_COMMAND("slot9", Slot9);
+	HOOK_COMMAND("slot10", Slot10);
+	HOOK_COMMAND("cancelselect", Close);
+	HOOK_COMMAND("invnext", NextWeapon);
+	HOOK_COMMAND("invprev", PrevWeapon);
+
+	Reset();
+
+	CVAR_CREATE( "hud_drawhistory_time", HISTORY_DRAW_TIME, 0 );
+	CVAR_CREATE( "hud_fastswitch", "0", FCVAR_ARCHIVE );		// controls whether or not weapons can be selected in one keypress
+
+	m_iFlags |= HUD_ACTIVE; //!!!
+
+	gWR.Init();
+	gHR.Init();
+
+	return 1;
+};
+
+void CHudAmmo::Reset(void)
+{
+	m_fFade = 0;
+	m_iFlags |= HUD_ACTIVE; //!!!
+
+	gpActiveSel = NULL;
+	gHUD.m_iHideHUDDisplay = 0;
+
+	gWR.Reset();
+	gHR.Reset();
+
+	//	VidInit();
+
+}
+
+int CHudAmmo::VidInit(void)
+{
+	// Load sprites for buckets (top row of weapon menu)
+	m_HUD_bucket0 = gHUD.GetSpriteIndex( "bucket1" );
+	m_HUD_selection = gHUD.GetSpriteIndex( "selection" );
+
+	ghsprBuckets = gHUD.GetSprite(m_HUD_bucket0);
+	giBucketWidth = gHUD.GetSpriteRect(m_HUD_bucket0).right - gHUD.GetSpriteRect(m_HUD_bucket0).left;
+	giBucketHeight = gHUD.GetSpriteRect(m_HUD_bucket0).bottom - gHUD.GetSpriteRect(m_HUD_bucket0).top;
+
+	gHR.iHistoryGap = max( gHR.iHistoryGap, gHUD.GetSpriteRect(m_HUD_bucket0).bottom - gHUD.GetSpriteRect(m_HUD_bucket0).top);
+
+	// If we've already loaded weapons, let's get new sprites
+	gWR.LoadAllWeaponSprites();
+
+	if (ScreenWidth >= 640)
+	{
+		giABWidth = 20;
+		giABHeight = 4;
+	}
+	else
+	{
+		giABWidth = 10;
+		giABHeight = 2;
+	}
+
+	return 1;
+}
+
+//
+// Think:
+//  Used for selection of weapon menu item.
+//
+void CHudAmmo::Think(void)
+{
+	if ( gHUD.m_fPlayerDead )
+		return;
+
+	if ( gHUD.m_iWeaponBits != gWR.iOldWeaponBits )
+	{
+		gWR.iOldWeaponBits = gHUD.m_iWeaponBits;
+
+		for (int i = MAX_WEAPONS-1; i > 0; i-- )
+		{
+			WEAPON *p = gWR.GetWeapon(i);
+
+			if ( p )
+			{
+				if ( gHUD.m_iWeaponBits & ( 1 << p->iId ) )
+					gWR.PickupWeapon( p );
+				else
+					gWR.DropWeapon( p );
+			}
+		}
+	}
+
+	if (!gpActiveSel)
+		return;
+
+	// has the player selected one?
+	if (gHUD.m_iKeyBits & IN_ATTACK)
+	{
+		if (gpActiveSel != (WEAPON *)1)
+		{
+			ServerCmd(gpActiveSel->szName);
+			g_weaponselect = gpActiveSel->iId;
+		}
+
+		gpLastSel = gpActiveSel;
+		gpActiveSel = NULL;
+		gHUD.m_iKeyBits &= ~IN_ATTACK;
+
+		PlaySound("common/wpn_select.wav", 1);
+	}
+
+}
+
+//
+// Helper function to return a Ammo pointer from id
+//
+
+HSPRITE* WeaponsResource :: GetAmmoPicFromWeapon( int iAmmoId, wrect_t& rect )
+{
+	for ( int i = 0; i < MAX_WEAPONS; i++ )
+	{
+		if ( rgWeapons[i].iAmmoType == iAmmoId )
+		{
+			rect = rgWeapons[i].rcAmmo;
+			return &rgWeapons[i].hAmmo;
+		}
+		else if ( rgWeapons[i].iAmmo2Type == iAmmoId )
+		{
+			rect = rgWeapons[i].rcAmmo2;
+			return &rgWeapons[i].hAmmo2;
+		}
+	}
+
+	return NULL;
+}
+
+
+// Menu Selection Code
+
+void WeaponsResource :: SelectSlot( int iSlot, int fAdvance, int iDirection )
+{
+	// Discwar has no weapons to switch to
+	return;
+
+	if ( gHUD.m_Menu.m_fMenuDisplayed && (fAdvance == FALSE) && (iDirection == 1) )	
+	{ // menu is overriding slot use commands
+		gHUD.m_Menu.SelectMenuItem( iSlot + 1 );  // slots are one off the key numbers
+		return;
+	}
+
+	if ( iSlot > MAX_WEAPON_SLOTS )
+		return;
+
+	if ( gHUD.m_fPlayerDead || gHUD.m_iHideHUDDisplay & ( HIDEHUD_WEAPONS | HIDEHUD_ALL ) )
+		return;
+
+	if (!(gHUD.m_iWeaponBits & (1<<(WEAPON_SUIT)) ))
+		return;
+
+	if ( ! ( gHUD.m_iWeaponBits & ~(1<<(WEAPON_SUIT)) ))
+		return;
+
+	WEAPON *p = NULL;
+	bool fastSwitch = CVAR_GET_FLOAT( "hud_fastswitch" ) != 0;
+
+	if ( (gpActiveSel == NULL) || (gpActiveSel == (WEAPON *)1) || (iSlot != gpActiveSel->iSlot) )
+	{
+		PlaySound( "common/wpn_hudon.wav", 1 );
+		p = GetFirstPos( iSlot );
+
+		if ( p && fastSwitch ) // check for fast weapon switch mode
+		{
+			// if fast weapon switch is on, then weapons can be selected in a single keypress
+			// but only if there is only one item in the bucket
+			WEAPON *p2 = GetNextActivePos( p->iSlot, p->iSlotPos );
+			if ( !p2 )
+			{	// only one active item in bucket, so change directly to weapon
+				ServerCmd( p->szName );
+				g_weaponselect = p->iId;
+				return;
+			}
+		}
+	}
+	else
+	{
+		PlaySound("common/wpn_moveselect.wav", 1);
+		if ( gpActiveSel )
+			p = GetNextActivePos( gpActiveSel->iSlot, gpActiveSel->iSlotPos );
+		if ( !p )
+			p = GetFirstPos( iSlot );
+	}
+
+	
+	if ( !p )  // no selection found
+	{
+		// just display the weapon list, unless fastswitch is on just ignore it
+		if ( !fastSwitch )
+			gpActiveSel = (WEAPON *)1;
+		else
+			gpActiveSel = NULL;
+	}
+	else 
+		gpActiveSel = p;
+}
+
+
+//------------------------------------------------------------------------
+// Message Handlers
+//------------------------------------------------------------------------
+
+//
+// AmmoX  -- Update the count of a known type of ammo
+// 
+int CHudAmmo::MsgFunc_AmmoX(const char *pszName, int iSize, void *pbuf)
+{
+	BEGIN_READ( pbuf, iSize );
+
+	int iIndex = READ_BYTE();
+	int iCount = READ_BYTE();
+
+	gWR.SetAmmo( iIndex, abs(iCount) );
+
+	return 1;
+}
+
+int CHudAmmo::MsgFunc_AmmoPickup( const char *pszName, int iSize, void *pbuf )
+{
+	BEGIN_READ( pbuf, iSize );
+	int iIndex = READ_BYTE();
+	int iCount = READ_BYTE();
+
+	// Add ammo to the history
+	gHR.AddToHistory( HISTSLOT_AMMO, iIndex, abs(iCount) );
+
+	return 1;
+}
+
+int CHudAmmo::MsgFunc_WeapPickup( const char *pszName, int iSize, void *pbuf )
+{
+	BEGIN_READ( pbuf, iSize );
+	int iIndex = READ_BYTE();
+
+	// Add the weapon to the history
+	gHR.AddToHistory( HISTSLOT_WEAP, iIndex );
+
+	return 1;
+}
+
+int CHudAmmo::MsgFunc_ItemPickup( const char *pszName, int iSize, void *pbuf )
+{
+	BEGIN_READ( pbuf, iSize );
+	const char *szName = READ_STRING();
+
+	// Add the weapon to the history
+	gHR.AddToHistory( HISTSLOT_ITEM, szName );
+
+	return 1;
+}
+
+
+int CHudAmmo::MsgFunc_HideWeapon( const char *pszName, int iSize, void *pbuf )
+{
+	BEGIN_READ( pbuf, iSize );
+	
+	gHUD.m_iHideHUDDisplay = READ_BYTE();
+
+	if ( gHUD.m_iHideHUDDisplay & ( HIDEHUD_WEAPONS | HIDEHUD_ALL ) )
+	{
+		static wrect_t nullrc;
+		gpActiveSel = NULL;
+		SetCrosshair( 0, nullrc, 0, 0, 0 );
+	}
+	else
+	{
+		if ( m_pWeapon )
+			SetCrosshair( m_pWeapon->hCrosshair, m_pWeapon->rcCrosshair, 255, 255, 255 );
+	}
+
+	return 1;
+}
+
+// 
+//  CurWeapon: Update hud state with the current weapon and clip count. Ammo
+//  counts are updated with AmmoX. Server assures that the Weapon ammo type 
+//  numbers match a real ammo type.
+//
+int CHudAmmo::MsgFunc_CurWeapon(const char *pszName, int iSize, void *pbuf )
+{
+	static wrect_t nullrc;
+	int fOnTarget = FALSE;
+
+	BEGIN_READ( pbuf, iSize );
+
+	int iState = READ_BYTE();
+	int iId = READ_CHAR();
+	int iClip = READ_CHAR();
+
+	// detect if we're also on target
+	if ( iState > 1 )
+	{
+		fOnTarget = TRUE;
+	}
+
+	if ( iId < 1 )
+	{
+		SetCrosshair(0, nullrc, 0, 0, 0);
+		return 0;
+	}
+
+	// Is player dead???
+	if ((iId == -1) && (iClip == -1))
+	{
+		gHUD.m_fPlayerDead = TRUE;
+		gpActiveSel = NULL;
+		return 1;
+	}
+	gHUD.m_fPlayerDead = FALSE;
+
+	WEAPON *pWeapon = gWR.GetWeapon( iId );
+
+	if ( !pWeapon )
+		return 0;
+
+	if ( iClip < -1 )
+		pWeapon->iClip = abs(iClip);
+	else
+		pWeapon->iClip = iClip;
+
+
+	if ( iState == 0 )	// we're not the current weapon, so update no more
+		return 1;
+
+	m_pWeapon = pWeapon;
+
+	if ( !(gHUD.m_iHideHUDDisplay & ( HIDEHUD_WEAPONS | HIDEHUD_ALL )) )
+	{
+		if ( gHUD.m_iFOV >= 90 )
+		{ // normal crosshairs
+			if (fOnTarget && m_pWeapon->hAutoaim)
+				SetCrosshair(m_pWeapon->hAutoaim, m_pWeapon->rcAutoaim, 255, 255, 255);
+			else
+				SetCrosshair(m_pWeapon->hCrosshair, m_pWeapon->rcCrosshair, 255, 255, 255);
+		}
+		else
+		{ // zoomed crosshairs
+			if (fOnTarget && m_pWeapon->hZoomedAutoaim)
+				SetCrosshair(m_pWeapon->hZoomedAutoaim, m_pWeapon->rcZoomedAutoaim, 255, 255, 255);
+			else
+				SetCrosshair(m_pWeapon->hZoomedCrosshair, m_pWeapon->rcZoomedCrosshair, 255, 255, 255);
+		}
+	}
+
+	m_fFade = 200.0f; //!!!
+	m_iFlags |= HUD_ACTIVE;
+	
+	return 1;
+}
+
+//
+// WeaponList -- Tells the hud about a new weapon type.
+//
+int CHudAmmo::MsgFunc_WeaponList(const char *pszName, int iSize, void *pbuf )
+{
+	BEGIN_READ( pbuf, iSize );
+	
+	WEAPON Weapon;
+
+	strcpy( Weapon.szName, READ_STRING() );
+	Weapon.iAmmoType = (int)READ_CHAR();	
+	
+	Weapon.iMax1 = READ_BYTE();
+	if (Weapon.iMax1 == 255)
+		Weapon.iMax1 = -1;
+
+	Weapon.iAmmo2Type = READ_CHAR();
+	Weapon.iMax2 = READ_BYTE();
+	if (Weapon.iMax2 == 255)
+		Weapon.iMax2 = -1;
+
+	Weapon.iSlot = READ_CHAR();
+	Weapon.iSlotPos = READ_CHAR();
+	Weapon.iId = READ_CHAR();
+	Weapon.iFlags = READ_BYTE();
+	Weapon.iClip = 0;
+
+	gWR.AddWeapon( &Weapon );
+
+	return 1;
+
+}
+
+//------------------------------------------------------------------------
+// Command Handlers
+//------------------------------------------------------------------------
+
+void CHudAmmo::UserCmd_Slot1(void)
+{
+	gWR.SelectSlot(0, FALSE, 1);
+}
+
+void CHudAmmo::UserCmd_Slot2(void)
+{
+	gWR.SelectSlot(1, FALSE, 1);
+}
+
+void CHudAmmo::UserCmd_Slot3(void)
+{
+	gWR.SelectSlot(2, FALSE, 1);
+}
+
+void CHudAmmo::UserCmd_Slot4(void)
+{
+	gWR.SelectSlot(3, FALSE, 1);
+}
+
+void CHudAmmo::UserCmd_Slot5(void)
+{
+	gWR.SelectSlot(4, FALSE, 1);
+}
+
+void CHudAmmo::UserCmd_Slot6(void)
+{
+	gWR.SelectSlot(5, FALSE, 1);
+}
+
+void CHudAmmo::UserCmd_Slot7(void)
+{
+	gWR.SelectSlot(6, FALSE, 1);
+}
+
+void CHudAmmo::UserCmd_Slot8(void)
+{
+	gWR.SelectSlot(7, FALSE, 1);
+}
+
+void CHudAmmo::UserCmd_Slot9(void)
+{
+	gWR.SelectSlot(8, FALSE, 1);
+}
+
+void CHudAmmo::UserCmd_Slot10(void)
+{
+	gWR.SelectSlot(9, FALSE, 1);
+}
+
+void CHudAmmo::UserCmd_Close(void)
+{
+	if (gpActiveSel)
+	{
+		gpLastSel = gpActiveSel;
+		gpActiveSel = NULL;
+		PlaySound("common/wpn_hudoff.wav", 1);
+	}
+	else
+		ClientCmd("escape");
+}
+
+
+// Selects the next item in the weapon menu
+void CHudAmmo::UserCmd_NextWeapon(void)
+{
+	if ( gHUD.m_fPlayerDead || (gHUD.m_iHideHUDDisplay & (HIDEHUD_WEAPONS | HIDEHUD_ALL)) )
+		return;
+
+	if ( !gpActiveSel || gpActiveSel == (WEAPON*)1 )
+		gpActiveSel = m_pWeapon;
+
+	int pos = 0;
+	int slot = 0;
+	if ( gpActiveSel )
+	{
+		pos = gpActiveSel->iSlotPos + 1;
+		slot = gpActiveSel->iSlot;
+	}
+
+	for ( int loop = 0; loop <= 1; loop++ )
+	{
+		for ( ; slot < MAX_WEAPON_SLOTS; slot++ )
+		{
+			for ( ; pos < MAX_WEAPON_POSITIONS; pos++ )
+			{
+				WEAPON *wsp = gWR.GetWeaponSlot( slot, pos );
+
+				if ( wsp && gWR.HasAmmo(wsp) )
+				{
+					gpActiveSel = wsp;
+					return;
+				}
+			}
+
+			pos = 0;
+		}
+
+		slot = 0;  // start looking from the first slot again
+	}
+
+	gpActiveSel = NULL;
+}
+
+// Selects the previous item in the menu
+void CHudAmmo::UserCmd_PrevWeapon(void)
+{
+	if ( gHUD.m_fPlayerDead || (gHUD.m_iHideHUDDisplay & (HIDEHUD_WEAPONS | HIDEHUD_ALL)) )
+		return;
+
+	if ( !gpActiveSel || gpActiveSel == (WEAPON*)1 )
+		gpActiveSel = m_pWeapon;
+
+	int pos = MAX_WEAPON_POSITIONS-1;
+	int slot = MAX_WEAPON_SLOTS-1;
+	if ( gpActiveSel )
+	{
+		pos = gpActiveSel->iSlotPos - 1;
+		slot = gpActiveSel->iSlot;
+	}
+	
+	for ( int loop = 0; loop <= 1; loop++ )
+	{
+		for ( ; slot >= 0; slot-- )
+		{
+			for ( ; pos >= 0; pos-- )
+			{
+				WEAPON *wsp = gWR.GetWeaponSlot( slot, pos );
+
+				if ( wsp && gWR.HasAmmo(wsp) )
+				{
+					gpActiveSel = wsp;
+					return;
+				}
+			}
+
+			pos = MAX_WEAPON_POSITIONS-1;
+		}
+		
+		slot = MAX_WEAPON_SLOTS-1;
+	}
+
+	gpActiveSel = NULL;
+}
+
+
+
+//-------------------------------------------------------------------------
+// Drawing code
+//-------------------------------------------------------------------------
+
+int CHudAmmo::Draw(float flTime)
+{
+	// No ammo in discwar
+	return 1;
+}
+
+
+//
+// Draws the ammo bar on the hud
+//
+int DrawBar(int x, int y, int width, int height, float f)
+{
+	int r, g, b;
+
+	if (f < 0)
+		f = 0;
+	if (f > 1)
+		f = 1;
+
+	if (f)
+	{
+		int w = f * width;
+
+		// Always show at least one pixel if we have ammo.
+		if (w <= 0)
+			w = 1;
+		UnpackRGB(r, g, b, RGB_GREENISH);
+		FillRGBA(x, y, w, height, r, g, b, 255);
+		x += w;
+		width -= w;
+	}
+
+	UnpackRGB(r, g, b, RGB_YELLOWISH);
+
+	FillRGBA(x, y, width, height, r, g, b, 128);
+
+	return (x + width);
+}
+
+
+
+void DrawAmmoBar(WEAPON *p, int x, int y, int width, int height)
+{
+	if ( !p )
+		return;
+	
+	if (p->iAmmoType != -1)
+	{
+		if (!gWR.CountAmmo(p->iAmmoType))
+			return;
+
+		float f = (float)gWR.CountAmmo(p->iAmmoType)/(float)p->iMax1;
+		
+		x = DrawBar(x, y, width, height, f);
+
+
+		// Do we have secondary ammo too?
+
+		if (p->iAmmo2Type != -1)
+		{
+			f = (float)gWR.CountAmmo(p->iAmmo2Type)/(float)p->iMax2;
+
+			x += 5; //!!!
+
+			DrawBar(x, y, width, height, f);
+		}
+	}
+}
+
+
+
+
+//
+// Draw Weapon Menu
+//
+int CHudAmmo::DrawWList(float flTime)
+{
+	// No ammo in discwar
+	return 0;
+}
+
+
+/* =================================
+	GetSpriteList
+
+Finds and returns the matching 
+sprite name 'psz' and resolution 'iRes'
+in the given sprite list 'pList'
+iCount is the number of items in the pList
+================================= */
+client_sprite_t *GetSpriteList(client_sprite_t *pList, const char *psz, int iRes, int iCount)
+{
+	if (!pList)
+		return NULL;
+
+	int i = iCount;
+	client_sprite_t *p = pList;
+
+	while(i--)
+	{
+		if ((!strcmp(psz, p->szName)) && (p->iRes == iRes))
+			return p;
+		p++;
+	}
+
+	return NULL;
+}

hlsdk/ricochet/cl_dll/ammo.h

@@ -0,0 +1,62 @@
+/***
+*
+*	Copyright (c) 1999, 2000 Valve LLC. All rights reserved.
+*	
+*	This product contains software technology licensed from Id 
+*	Software, Inc. ("Id Technology").  Id Technology (c) 1996 Id Software, Inc. 
+*	All Rights Reserved.
+*
+*   Use, distribution, and modification of this source code and/or resulting
+*   object code is restricted to non-commercial enhancements to products from
+*   Valve LLC.  All other use, distribution, or modification is prohibited
+*   without written permission from Valve LLC.
+*
+****/
+
+#ifndef __AMMO_H__
+#define __AMMO_H__
+
+#define MAX_WEAPON_NAME 128
+
+
+#define WEAPON_FLAGS_SELECTONEMPTY	1
+
+#define WEAPON_IS_ONTARGET 0x40
+
+struct WEAPON
+{
+	char	szName[MAX_WEAPON_NAME];
+	int		iAmmoType;
+	int		iAmmo2Type;
+	int		iMax1;
+	int		iMax2;
+	int		iSlot;
+	int		iSlotPos;
+	int		iFlags;
+	int		iId;
+	int		iClip;
+
+	int		iCount;		// # of itesm in plist
+
+	HSPRITE hActive;
+	wrect_t rcActive;
+	HSPRITE hInactive;
+	wrect_t rcInactive;
+	HSPRITE	hAmmo;
+	wrect_t rcAmmo;
+	HSPRITE hAmmo2;
+	wrect_t rcAmmo2;
+	HSPRITE hCrosshair;
+	wrect_t rcCrosshair;
+	HSPRITE hAutoaim;
+	wrect_t rcAutoaim;
+	HSPRITE hZoomedCrosshair;
+	wrect_t rcZoomedCrosshair;
+	HSPRITE hZoomedAutoaim;
+	wrect_t rcZoomedAutoaim;
+};
+
+typedef int AMMO;
+
+
+#endif

hlsdk/ricochet/cl_dll/ammo_secondary.cpp

@@ -0,0 +1,159 @@
+/***
+*
+*	Copyright (c) 1999, 2000 Valve LLC. All rights reserved.
+*	
+*	This product contains software technology licensed from Id 
+*	Software, Inc. ("Id Technology").  Id Technology (c) 1996 Id Software, Inc. 
+*	All Rights Reserved.
+*
+*   Use, distribution, and modification of this source code and/or resulting
+*   object code is restricted to non-commercial enhancements to products from
+*   Valve LLC.  All other use, distribution, or modification is prohibited
+*   without written permission from Valve LLC.
+*
+****/
+//
+// ammo_secondary.cpp
+//
+// implementation of CHudAmmoSecondary class
+//
+
+#include "hud.h"
+#include "cl_util.h"
+#include <string.h>
+#include <stdio.h>
+#include "parsemsg.h"
+
+DECLARE_MESSAGE( m_AmmoSecondary, SecAmmoVal );
+DECLARE_MESSAGE( m_AmmoSecondary, SecAmmoIcon );
+
+int CHudAmmoSecondary :: Init( void )
+{
+	HOOK_MESSAGE( SecAmmoVal );
+	HOOK_MESSAGE( SecAmmoIcon );
+
+	gHUD.AddHudElem(this);
+	m_HUD_ammoicon = 0;
+
+	for ( int i = 0; i < MAX_SEC_AMMO_VALUES; i++ )
+		m_iAmmoAmounts[i] = -1;  // -1 means don't draw this value
+
+	Reset();
+
+	return 1;
+}
+
+void CHudAmmoSecondary :: Reset( void )
+{
+	m_fFade = 0;
+}
+
+int CHudAmmoSecondary :: VidInit( void )
+{
+	return 1;
+}
+
+int CHudAmmoSecondary :: Draw(float flTime)
+{
+	if ( (gHUD.m_iHideHUDDisplay & ( HIDEHUD_WEAPONS | HIDEHUD_ALL )) )
+		return 1;
+
+	// draw secondary ammo icons above normal ammo readout
+	int a, x, y, r, g, b, AmmoWidth;
+	UnpackRGB( r, g, b, RGB_YELLOWISH );
+	a = (int) max( MIN_ALPHA, m_fFade );
+	if (m_fFade > 0)
+		m_fFade -= (gHUD.m_flTimeDelta * 20);  // slowly lower alpha to fade out icons
+	ScaleColors( r, g, b, a );
+
+	AmmoWidth = gHUD.GetSpriteRect(gHUD.m_HUD_number_0).right - gHUD.GetSpriteRect(gHUD.m_HUD_number_0).left;
+
+	y = ScreenHeight - (gHUD.m_iFontHeight*4);  // this is one font height higher than the weapon ammo values
+	x = ScreenWidth - AmmoWidth;
+
+	if ( m_HUD_ammoicon )
+	{
+		// Draw the ammo icon
+		x -= (gHUD.GetSpriteRect(m_HUD_ammoicon).right - gHUD.GetSpriteRect(m_HUD_ammoicon).left);
+		y -= (gHUD.GetSpriteRect(m_HUD_ammoicon).top - gHUD.GetSpriteRect(m_HUD_ammoicon).bottom);
+
+		SPR_Set( gHUD.GetSprite(m_HUD_ammoicon), r, g, b );
+		SPR_DrawAdditive( 0, x, y, &gHUD.GetSpriteRect(m_HUD_ammoicon) );
+	}
+	else
+	{  // move the cursor by the '0' char instead, since we don't have an icon to work with
+		x -= AmmoWidth;
+		y -= (gHUD.GetSpriteRect(gHUD.m_HUD_number_0).top - gHUD.GetSpriteRect(gHUD.m_HUD_number_0).bottom);
+	}
+
+	// draw the ammo counts, in reverse order, from right to left
+	for ( int i = MAX_SEC_AMMO_VALUES-1; i >= 0; i-- )
+	{
+		if ( m_iAmmoAmounts[i] < 0 )
+			continue; // negative ammo amounts imply that they shouldn't be drawn
+
+		// half a char gap between the ammo number and the previous pic
+		x -= (AmmoWidth / 2);
+
+		// draw the number, right-aligned
+		x -= (gHUD.GetNumWidth( m_iAmmoAmounts[i], DHN_DRAWZERO ) * AmmoWidth);
+		gHUD.DrawHudNumber( x, y, DHN_DRAWZERO, m_iAmmoAmounts[i], r, g, b );
+
+		if ( i != 0 )
+		{
+			// draw the divider bar
+			x -= (AmmoWidth / 2);
+			FillRGBA(x, y, (AmmoWidth/10), gHUD.m_iFontHeight, r, g, b, a);
+		}
+	}
+
+	return 1;
+}
+
+// Message handler for Secondary Ammo Value
+// accepts one value:
+//		string:  sprite name
+int CHudAmmoSecondary :: MsgFunc_SecAmmoIcon( const char *pszName, int iSize, void *pbuf )
+{
+	BEGIN_READ( pbuf, iSize );
+	m_HUD_ammoicon = gHUD.GetSpriteIndex( READ_STRING() );
+
+	return 1;
+}
+
+// Message handler for Secondary Ammo Icon
+// Sets an ammo value
+// takes two values:
+//		byte:  ammo index
+//		byte:  ammo value
+int CHudAmmoSecondary :: MsgFunc_SecAmmoVal( const char *pszName, int iSize, void *pbuf )
+{
+	BEGIN_READ( pbuf, iSize );
+
+	int index = READ_BYTE();
+	if ( index < 0 || index >= MAX_SEC_AMMO_VALUES )
+		return 1;
+
+	m_iAmmoAmounts[index] = READ_BYTE();
+	m_iFlags |= HUD_ACTIVE;
+
+	// check to see if there is anything left to draw
+	int count = 0;
+	for ( int i = 0; i < MAX_SEC_AMMO_VALUES; i++ )
+	{
+		count += max( 0, m_iAmmoAmounts[i] );
+	}
+
+	if ( count == 0 ) 
+	{	// the ammo fields are all empty, so turn off this hud area
+		m_iFlags &= ~HUD_ACTIVE;
+		return 1;
+	}
+
+	// make the icons light up
+	m_fFade = 200.0f;
+
+	return 1;
+}
+
+

hlsdk/ricochet/cl_dll/ammohistory.cpp

@@ -0,0 +1,190 @@
+/***
+*
+*	Copyright (c) 1999, 2000 Valve LLC. All rights reserved.
+*	
+*	This product contains software technology licensed from Id 
+*	Software, Inc. ("Id Technology").  Id Technology (c) 1996 Id Software, Inc. 
+*	All Rights Reserved.
+*
+*   Use, distribution, and modification of this source code and/or resulting
+*   object code is restricted to non-commercial enhancements to products from
+*   Valve LLC.  All other use, distribution, or modification is prohibited
+*   without written permission from Valve LLC.
+*
+****/
+//
+//  ammohistory.cpp
+//
+
+
+#include "hud.h"
+#include "cl_util.h"
+#include "parsemsg.h"
+
+#include <string.h>
+#include <stdio.h>
+
+#include "ammohistory.h"
+
+HistoryResource gHR;
+
+#define AMMO_PICKUP_GAP (gHR.iHistoryGap+5)
+#define AMMO_PICKUP_PICK_HEIGHT		(32 + (gHR.iHistoryGap * 2))
+#define AMMO_PICKUP_HEIGHT_MAX		(ScreenHeight - 100)
+
+#define MAX_ITEM_NAME	32
+int HISTORY_DRAW_TIME = 5;
+
+// keep a list of items
+struct ITEM_INFO
+{
+	char szName[MAX_ITEM_NAME];
+	HSPRITE spr;
+	wrect_t rect;
+};
+
+void HistoryResource :: AddToHistory( int iType, int iId, int iCount )
+{
+	if ( iType == HISTSLOT_AMMO && !iCount )
+		return;  // no amount, so don't add
+
+	if ( (((AMMO_PICKUP_GAP * iCurrentHistorySlot) + AMMO_PICKUP_PICK_HEIGHT) > AMMO_PICKUP_HEIGHT_MAX) || (iCurrentHistorySlot >= MAX_HISTORY) )
+	{	// the pic would have to be drawn too high
+		// so start from the bottom
+		iCurrentHistorySlot = 0;
+	}
+	
+	HIST_ITEM *freeslot = &rgAmmoHistory[iCurrentHistorySlot++];  // default to just writing to the first slot
+	HISTORY_DRAW_TIME = CVAR_GET_FLOAT( "hud_drawhistory_time" );
+
+	freeslot->type = iType;
+	freeslot->iId = iId;
+	freeslot->iCount = iCount;
+	freeslot->DisplayTime = gHUD.m_flTime + HISTORY_DRAW_TIME;
+}
+
+void HistoryResource :: AddToHistory( int iType, const char *szName, int iCount )
+{
+	if ( iType != HISTSLOT_ITEM )
+		return;
+
+	if ( (((AMMO_PICKUP_GAP * iCurrentHistorySlot) + AMMO_PICKUP_PICK_HEIGHT) > AMMO_PICKUP_HEIGHT_MAX) || (iCurrentHistorySlot >= MAX_HISTORY) )
+	{	// the pic would have to be drawn too high
+		// so start from the bottom
+		iCurrentHistorySlot = 0;
+	}
+
+	HIST_ITEM *freeslot = &rgAmmoHistory[iCurrentHistorySlot++];  // default to just writing to the first slot
+
+	// I am really unhappy with all the code in this file
+
+	int i = gHUD.GetSpriteIndex( szName );
+	if ( i == -1 )
+		return;  // unknown sprite name, don't add it to history
+
+	freeslot->iId = i;
+	freeslot->type = iType;
+	freeslot->iCount = iCount;
+
+	HISTORY_DRAW_TIME = CVAR_GET_FLOAT( "hud_drawhistory_time" );
+	freeslot->DisplayTime = gHUD.m_flTime + HISTORY_DRAW_TIME;
+}
+
+
+void HistoryResource :: CheckClearHistory( void )
+{
+	for ( int i = 0; i < MAX_HISTORY; i++ )
+	{
+		if ( rgAmmoHistory[i].type )
+			return;
+	}
+
+	iCurrentHistorySlot = 0;
+}
+
+//
+// Draw Ammo pickup history
+//
+int HistoryResource :: DrawAmmoHistory( float flTime )
+{
+	for ( int i = 0; i < MAX_HISTORY; i++ )
+	{
+		if ( rgAmmoHistory[i].type )
+		{
+			rgAmmoHistory[i].DisplayTime = min( rgAmmoHistory[i].DisplayTime, gHUD.m_flTime + HISTORY_DRAW_TIME );
+
+			if ( rgAmmoHistory[i].DisplayTime <= flTime )
+			{  // pic drawing time has expired
+				memset( &rgAmmoHistory[i], 0, sizeof(HIST_ITEM) );
+				CheckClearHistory();
+			}
+			else if ( rgAmmoHistory[i].type == HISTSLOT_AMMO )
+			{
+				wrect_t rcPic;
+				HSPRITE *spr = gWR.GetAmmoPicFromWeapon( rgAmmoHistory[i].iId, rcPic );
+
+				int r, g, b;
+				UnpackRGB(r,g,b, RGB_YELLOWISH);
+				float scale = (rgAmmoHistory[i].DisplayTime - flTime) * 80;
+				ScaleColors(r, g, b, min(scale, 255) );
+
+				// Draw the pic
+				int ypos = ScreenHeight - (AMMO_PICKUP_PICK_HEIGHT + (AMMO_PICKUP_GAP * i));
+				int xpos = ScreenWidth - 24;
+				if ( spr && *spr )    // weapon isn't loaded yet so just don't draw the pic
+				{ // the dll has to make sure it has sent info the weapons you need
+					SPR_Set( *spr, r, g, b );
+					SPR_DrawAdditive( 0, xpos, ypos, &rcPic );
+				}
+
+				// Draw the number
+				gHUD.DrawHudNumberString( xpos - 10, ypos, xpos - 100, rgAmmoHistory[i].iCount, r, g, b );
+			}
+			else if ( rgAmmoHistory[i].type == HISTSLOT_WEAP )
+			{
+				WEAPON *weap = gWR.GetWeapon( rgAmmoHistory[i].iId );
+
+				if ( !weap )
+					return 1;  // we don't know about the weapon yet, so don't draw anything
+
+				int r, g, b;
+				UnpackRGB(r,g,b, RGB_YELLOWISH);
+
+				if ( !gWR.HasAmmo( weap ) )
+					UnpackRGB(r,g,b, RGB_REDISH);	// if the weapon doesn't have ammo, display it as red
+
+				float scale = (rgAmmoHistory[i].DisplayTime - flTime) * 80;
+				ScaleColors(r, g, b, min(scale, 255) );
+
+				int ypos = ScreenHeight - (AMMO_PICKUP_PICK_HEIGHT + (AMMO_PICKUP_GAP * i));
+				int xpos = ScreenWidth - (weap->rcInactive.right - weap->rcInactive.left);
+				SPR_Set( weap->hInactive, r, g, b );
+				SPR_DrawAdditive( 0, xpos, ypos, &weap->rcInactive );
+			}
+			else if ( rgAmmoHistory[i].type == HISTSLOT_ITEM )
+			{
+				int r, g, b;
+
+				if ( !rgAmmoHistory[i].iId )
+					continue;  // sprite not loaded
+
+				wrect_t rect = gHUD.GetSpriteRect( rgAmmoHistory[i].iId );
+
+				UnpackRGB(r,g,b, RGB_YELLOWISH);
+				float scale = (rgAmmoHistory[i].DisplayTime - flTime) * 80;
+				ScaleColors(r, g, b, min(scale, 255) );
+
+				int ypos = ScreenHeight - (AMMO_PICKUP_PICK_HEIGHT + (AMMO_PICKUP_GAP * i));
+				int xpos = ScreenWidth - (rect.right - rect.left) - 10;
+
+				SPR_Set( gHUD.GetSprite( rgAmmoHistory[i].iId ), r, g, b );
+				SPR_DrawAdditive( 0, xpos, ypos, &rect );
+			}
+		}
+	}
+
+
+	return 1;
+}
+
+

hlsdk/ricochet/cl_dll/ammohistory.h

@@ -0,0 +1,143 @@
+/***
+*
+*	Copyright (c) 1999, Valve LLC. All rights reserved.
+*	
+*	This product contains software technology licensed from Id 
+*	Software, Inc. ("Id Technology").  Id Technology (c) 1996 Id Software, Inc. 
+*	All Rights Reserved.
+*
+*   Use, distribution, and modification of this source code and/or resulting
+*   object code is restricted to non-commercial enhancements to products from
+*   Valve LLC.  All other use, distribution, or modification is prohibited
+*   without written permission from Valve LLC.
+*
+****/
+//
+// ammohistory.h
+//
+
+// this is the max number of items in each bucket
+#define MAX_WEAPON_POSITIONS		MAX_WEAPON_SLOTS
+
+class WeaponsResource
+{
+private:
+	// Information about weapons & ammo
+	WEAPON		rgWeapons[MAX_WEAPONS];	// Weapons Array
+
+	// counts of weapons * ammo
+	WEAPON*		rgSlots[MAX_WEAPON_SLOTS+1][MAX_WEAPON_POSITIONS+1];	// The slots currently in use by weapons.  The value is a pointer to the weapon;  if it's NULL, no weapon is there
+	int			riAmmo[MAX_AMMO_TYPES];							// count of each ammo type
+
+public:
+	void Init( void )
+	{
+		memset( rgWeapons, 0, sizeof rgWeapons );
+		Reset();
+	}
+
+	void Reset( void )
+	{
+		iOldWeaponBits = 0;
+		memset( rgSlots, 0, sizeof rgSlots );
+		memset( riAmmo, 0, sizeof riAmmo );
+	}
+
+///// WEAPON /////
+	int			iOldWeaponBits;
+
+	WEAPON *GetWeapon( int iId ) { return &rgWeapons[iId]; }
+	void AddWeapon( WEAPON *wp ) 
+	{ 
+		rgWeapons[ wp->iId ] = *wp;	
+		LoadWeaponSprites( &rgWeapons[ wp->iId ] );
+	}
+
+	void PickupWeapon( WEAPON *wp )
+	{
+		rgSlots[ wp->iSlot ][ wp->iSlotPos ] = wp;
+	}
+
+	void DropWeapon( WEAPON *wp )
+	{
+		rgSlots[ wp->iSlot ][ wp->iSlotPos ] = NULL;
+	}
+
+	void DropAllWeapons( void )
+	{
+		for ( int i = 0; i < MAX_WEAPONS; i++ )
+		{
+			if ( rgWeapons[i].iId )
+				DropWeapon( &rgWeapons[i] );
+		}
+	}
+
+	WEAPON* GetWeaponSlot( int slot, int pos ) { return rgSlots[slot][pos]; }
+
+	void LoadWeaponSprites( WEAPON* wp );
+	void LoadAllWeaponSprites( void );
+	WEAPON* GetFirstPos( int iSlot );
+	void SelectSlot( int iSlot, int fAdvance, int iDirection );
+	WEAPON* GetNextActivePos( int iSlot, int iSlotPos );
+
+	int HasAmmo( WEAPON *p );
+
+///// AMMO /////
+	AMMO GetAmmo( int iId ) { return riAmmo[ iId ]; }
+
+	void SetAmmo( int iId, int iCount ) { riAmmo[ iId ] = iCount;	}
+
+	int CountAmmo( int iId );
+
+	HSPRITE* GetAmmoPicFromWeapon( int iAmmoId, wrect_t& rect );
+};
+
+extern WeaponsResource gWR;
+
+
+#define MAX_HISTORY 12
+enum {
+	HISTSLOT_EMPTY,
+	HISTSLOT_AMMO,
+	HISTSLOT_WEAP,
+	HISTSLOT_ITEM,
+};
+
+class HistoryResource
+{
+private:
+	struct HIST_ITEM {
+		int type;
+		float DisplayTime;  // the time at which this item should be removed from the history
+		int iCount;
+		int iId;
+	};
+
+	HIST_ITEM rgAmmoHistory[MAX_HISTORY];
+
+public:
+
+	void Init( void )
+	{
+		Reset();
+	}
+
+	void Reset( void )
+	{
+		memset( rgAmmoHistory, 0, sizeof rgAmmoHistory );
+	}
+
+	int iHistoryGap;
+	int iCurrentHistorySlot;
+
+	void AddToHistory( int iType, int iId, int iCount = 0 );
+	void AddToHistory( int iType, const char *szName, int iCount = 0 );
+
+	void CheckClearHistory( void );
+	int DrawAmmoHistory( float flTime );
+};
+
+extern HistoryResource gHR;
+
+
+

hlsdk/ricochet/cl_dll/battery.cpp

@@ -0,0 +1,79 @@
+/***
+*
+*	Copyright (c) 1999, 2000 Valve LLC. All rights reserved.
+*	
+*	This product contains software technology licensed from Id 
+*	Software, Inc. ("Id Technology").  Id Technology (c) 1996 Id Software, Inc. 
+*	All Rights Reserved.
+*
+*   Use, distribution, and modification of this source code and/or resulting
+*   object code is restricted to non-commercial enhancements to products from
+*   Valve LLC.  All other use, distribution, or modification is prohibited
+*   without written permission from Valve LLC.
+*
+****/
+//
+// battery.cpp
+//
+// implementation of CHudBattery class
+//
+
+#include "hud.h"
+#include "cl_util.h"
+#include "parsemsg.h"
+
+#include <string.h>
+#include <stdio.h>
+
+DECLARE_MESSAGE(m_Battery, Battery)
+
+int CHudBattery::Init(void)
+{
+	m_iBat = 0;
+	m_fFade = 0;
+	m_iFlags = 0;
+
+	HOOK_MESSAGE(Battery);
+
+	gHUD.AddHudElem(this);
+
+	return 1;
+};
+
+
+int CHudBattery::VidInit(void)
+{
+	int HUD_suit_empty = gHUD.GetSpriteIndex( "suit_empty" );
+	int HUD_suit_full = gHUD.GetSpriteIndex( "suit_full" );
+
+	m_hSprite1 = m_hSprite2 = 0;  // delaying get sprite handles until we know the sprites are loaded
+	m_prc1 = &gHUD.GetSpriteRect( HUD_suit_empty );
+	m_prc2 = &gHUD.GetSpriteRect( HUD_suit_full );
+	m_iHeight = m_prc2->bottom - m_prc1->top;
+	m_fFade = 0;
+	return 1;
+};
+
+int CHudBattery:: MsgFunc_Battery(const char *pszName,  int iSize, void *pbuf )
+{
+	m_iFlags |= HUD_ACTIVE;
+
+	
+	BEGIN_READ( pbuf, iSize );
+	int x = READ_SHORT();
+
+	if (x != m_iBat)
+	{
+		m_fFade = FADE_TIME;
+		m_iBat = x;
+	}
+
+	return 1;
+}
+
+
+int CHudBattery::Draw(float flTime)
+{
+	// No Armor in Discwar
+	return 1;
+}

hlsdk/ricochet/cl_dll/camera.h

@@ -0,0 +1,31 @@
+/***
+*
+*	Copyright (c) 1999, 2000 Valve LLC. All rights reserved.
+*	
+*	This product contains software technology licensed from Id 
+*	Software, Inc. ("Id Technology").  Id Technology (c) 1996 Id Software, Inc. 
+*	All Rights Reserved.
+*
+*   Use, distribution, and modification of this source code and/or resulting
+*   object code is restricted to non-commercial enhancements to products from
+*   Valve LLC.  All other use, distribution, or modification is prohibited
+*   without written permission from Valve LLC.
+*
+****/
+// Camera.h  --  defines and such for a 3rd person camera
+// NOTE: must include quakedef.h first
+
+#ifndef _CAMERA_H_
+#define _CAMEA_H_
+
+// pitch, yaw, dist
+extern vec3_t cam_ofs;
+// Using third person camera
+extern int cam_thirdperson;
+
+void CAM_Init( void );
+void CAM_ClearStates( void );
+void CAM_StartMouseMove(void);
+void CAM_EndMouseMove(void);
+
+#endif		// _CAMERA_H_

hlsdk/ricochet/cl_dll/cdll_int.cpp

@@ -0,0 +1,268 @@
+/***
+*
+*	Copyright (c) 1999, 2000 Valve LLC. All rights reserved.
+*	
+*	This product contains software technology licensed from Id 
+*	Software, Inc. ("Id Technology").  Id Technology (c) 1996 Id Software, Inc. 
+*	All Rights Reserved.
+*
+*   Use, distribution, and modification of this source code and/or resulting
+*   object code is restricted to non-commercial enhancements to products from
+*   Valve LLC.  All other use, distribution, or modification is prohibited
+*   without written permission from Valve LLC.
+*
+****/
+//
+//  cdll_int.c
+//
+// this implementation handles the linking of the engine to the DLL
+//
+
+#include "hud.h"
+#include "cl_util.h"
+#include <string.h>
+#include "netadr.h"
+#include "vgui_SchemeManager.h"
+
+#define DLLEXPORT __declspec( dllexport )
+cl_enginefunc_t gEngfuncs;
+CHud gHUD	;
+TeamFortressViewport *gViewPort = NULL;
+extern "C"
+{
+#include "pm_shared.h"
+}
+
+#include "hud_servers.h"
+#include "vgui_int.h"
+
+
+void InitInput (void);
+void EV_HookEvents( void );
+void IN_Commands( void );
+
+/*
+========================== 
+    Initialize
+
+Called when the DLL is first loaded.
+==========================
+*/
+extern "C" 
+{
+int DLLEXPORT Initialize( cl_enginefunc_t *pEnginefuncs, int iVersion );
+int DLLEXPORT HUD_VidInit( void );
+void DLLEXPORT HUD_Init( void );
+int DLLEXPORT HUD_Redraw( float flTime, int intermission );
+int DLLEXPORT HUD_UpdateClientData( client_data_t *cdata, float flTime );
+void DLLEXPORT HUD_Reset ( void );
+void DLLEXPORT HUD_PlayerMove( struct playermove_s *ppmove, int server );
+void DLLEXPORT HUD_PlayerMoveInit( struct playermove_s *ppmove );
+char DLLEXPORT HUD_PlayerMoveTexture( char *name );
+int DLLEXPORT HUD_ConnectionlessPacket( const struct netadr_s *net_from, const char *args, char *response_buffer, int *response_buffer_size );
+int DLLEXPORT HUD_GetHullBounds( int hullnumber, float *mins, float *maxs );
+void DLLEXPORT HUD_Frame( double time );
+void DLLEXPORT HUD_PostRunCmd( struct local_state_s *from, struct local_state_s *to, struct usercmd_s *cmd, int runfuncs, double time, unsigned int random_seed );
+void	DLLEXPORT HUD_VoiceStatus(int entindex, qboolean bTalking);
+}
+
+/*
+================================
+HUD_GetHullBounds
+
+  Engine calls this to enumerate player collision hulls, for prediction.  Return 0 if the hullnumber doesn't exist.
+================================
+*/
+int DLLEXPORT HUD_GetHullBounds( int hullnumber, float *mins, float *maxs )
+{
+	int iret = 0;
+
+	switch ( hullnumber )
+	{
+	case 0:				// Normal player
+		mins = Vector(-16, -16, -36);
+		maxs = Vector(16, 16, 36);
+		iret = 1;
+		break;
+	case 1:				// Crouched player
+		mins = Vector(-16, -16, -18 );
+		maxs = Vector(16, 16, 18 );
+		iret = 1;
+		break;
+	case 2:				// Point based hull
+		mins = Vector( 0, 0, 0 );
+		maxs = Vector( 0, 0, 0 );
+		iret = 1;
+		break;
+	}
+
+	return iret;
+}
+
+/*
+================================
+HUD_ConnectionlessPacket
+
+ Return 1 if the packet is valid.  Set response_buffer_size if you want to send a response packet.  Incoming, it holds the max
+  size of the response_buffer, so you must zero it out if you choose not to respond.
+================================
+*/
+int	DLLEXPORT HUD_ConnectionlessPacket( const struct netadr_s *net_from, const char *args, char *response_buffer, int *response_buffer_size )
+{
+	// Parse stuff from args
+	int max_buffer_size = *response_buffer_size;
+
+	// Zero it out since we aren't going to respond.
+	// If we wanted to response, we'd write data into response_buffer
+	*response_buffer_size = 0;
+
+	// Since we don't listen for anything here, just respond that it's a bogus message
+	// If we didn't reject the message, we'd return 1 for success instead.
+	return 0;
+}
+
+void DLLEXPORT HUD_PlayerMoveInit( struct playermove_s *ppmove )
+{
+	PM_Init( ppmove );
+}
+
+char DLLEXPORT HUD_PlayerMoveTexture( char *name )
+{
+	return PM_FindTextureType( name );
+}
+
+void DLLEXPORT HUD_PlayerMove( struct playermove_s *ppmove, int server )
+{
+	PM_Move( ppmove, server );
+}
+
+int DLLEXPORT Initialize( cl_enginefunc_t *pEnginefuncs, int iVersion )
+{
+	gEngfuncs = *pEnginefuncs;
+
+	if (iVersion != CLDLL_INTERFACE_VERSION)
+		return 0;
+
+	memcpy(&gEngfuncs, pEnginefuncs, sizeof(cl_enginefunc_t));
+
+	EV_HookEvents();
+
+	return 1;
+}
+
+
+/*
+==========================
+	HUD_VidInit
+
+Called when the game initializes
+and whenever the vid_mode is changed
+so the HUD can reinitialize itself.
+==========================
+*/
+
+int DLLEXPORT HUD_VidInit( void )
+{
+	gHUD.VidInit();
+
+	VGui_Startup();
+
+	return 1;
+}
+
+/*
+==========================
+	HUD_Init
+
+Called whenever the client connects
+to a server.  Reinitializes all 
+the hud variables.
+==========================
+*/
+
+void DLLEXPORT HUD_Init( void )
+{
+	InitInput();
+	gHUD.Init();
+	Scheme_Init();
+}
+
+
+/*
+==========================
+	HUD_Redraw
+
+called every screen frame to
+redraw the HUD.
+===========================
+*/
+
+int DLLEXPORT HUD_Redraw( float time, int intermission )
+{
+	gHUD.Redraw( time, intermission );
+
+	return 1;
+}
+
+
+/*
+==========================
+	HUD_UpdateClientData
+
+called every time shared client
+dll/engine data gets changed,
+and gives the cdll a chance
+to modify the data.
+
+returns 1 if anything has been changed, 0 otherwise.
+==========================
+*/
+
+int DLLEXPORT HUD_UpdateClientData(client_data_t *pcldata, float flTime )
+{
+	IN_Commands();
+	
+	return gHUD.UpdateClientData(pcldata, flTime );
+}
+
+/*
+==========================
+	HUD_Reset
+
+Called at start and end of demos to restore to "non"HUD state.
+==========================
+*/
+
+void DLLEXPORT HUD_Reset( void )
+{
+	gHUD.VidInit();
+}
+
+
+/*
+==========================
+HUD_Frame
+
+Called by engine every frame that client .dll is loaded
+==========================
+*/
+
+void DLLEXPORT HUD_Frame( double time )
+{
+	ServersThink( time );
+
+	GetClientVoiceMgr()->Frame(time);
+}
+
+/*
+==========================
+HUD_VoiceStatus
+
+Called when a player starts or stops talking.
+==========================
+*/
+
+void DLLEXPORT HUD_VoiceStatus(int entindex, qboolean bTalking)
+{
+	GetClientVoiceMgr()->UpdateSpeakerStatus(entindex, bTalking);
+}

hlsdk/ricochet/cl_dll/cl_dll.h

@@ -0,0 +1,39 @@
+/***
+*
+*	Copyright (c) 1999, 2000 Valve LLC. All rights reserved.
+*	
+*	This product contains software technology licensed from Id 
+*	Software, Inc. ("Id Technology").  Id Technology (c) 1996 Id Software, Inc. 
+*	All Rights Reserved.
+*
+*   Use, distribution, and modification of this source code and/or resulting
+*   object code is restricted to non-commercial enhancements to products from
+*   Valve LLC.  All other use, distribution, or modification is prohibited
+*   without written permission from Valve LLC.
+*
+****/
+//
+//  cl_dll.h
+//
+
+// 4-23-98  JOHN
+
+//
+//  This DLL is linked by the client when they first initialize.
+// This DLL is responsible for the following tasks:
+//		- Loading the HUD graphics upon initialization
+//		- Drawing the HUD graphics every frame
+//		- Handling the custum HUD-update packets
+//
+typedef unsigned char byte;
+typedef unsigned short word;
+typedef float vec_t;
+typedef int (*pfnUserMsgHook)(const char *pszName, int iSize, void *pbuf);
+
+#include "util_vector.h"
+#define EXPORT	_declspec( dllexport )
+
+#include "../engine/cdll_int.h"
+#include "../dlls/cdll_dll.h"
+
+extern cl_enginefunc_t gEngfuncs;

hlsdk/ricochet/cl_dll/cl_util.h

@@ -0,0 +1,151 @@
+/***
+*
+*	Copyright (c) 1999, 2000 Valve LLC. All rights reserved.
+*	
+*	This product contains software technology licensed from Id 
+*	Software, Inc. ("Id Technology").  Id Technology (c) 1996 Id Software, Inc. 
+*	All Rights Reserved.
+*
+*   Use, distribution, and modification of this source code and/or resulting
+*   object code is restricted to non-commercial enhancements to products from
+*   Valve LLC.  All other use, distribution, or modification is prohibited
+*   without written permission from Valve LLC.
+*
+****/
+//
+// util.h
+//
+
+#include "cvardef.h"
+
+#ifndef TRUE
+#define TRUE 1
+#define FALSE 0
+#endif
+
+// Macros to hook function calls into the HUD object
+#define HOOK_MESSAGE(x) gEngfuncs.pfnHookUserMsg(#x, __MsgFunc_##x );
+
+#define DECLARE_MESSAGE(y, x) int __MsgFunc_##x(const char *pszName, int iSize, void *pbuf) \
+							{ \
+							return gHUD.##y.MsgFunc_##x(pszName, iSize, pbuf ); \
+							}
+
+
+#define HOOK_COMMAND(x, y) gEngfuncs.pfnAddCommand( x, __CmdFunc_##y );
+#define DECLARE_COMMAND(y, x) void __CmdFunc_##x( void ) \
+							{ \
+								gHUD.##y.UserCmd_##x( ); \
+							}
+
+inline float CVAR_GET_FLOAT( const char *x ) {	return gEngfuncs.pfnGetCvarFloat( (char*)x ); }
+inline char* CVAR_GET_STRING( const char *x ) {	return gEngfuncs.pfnGetCvarString( (char*)x ); }
+inline struct cvar_s *CVAR_CREATE( const char *cv, const char *val, const int flags ) {	return gEngfuncs.pfnRegisterVariable( (char*)cv, (char*)val, flags ); }
+
+#define SPR_Load (*gEngfuncs.pfnSPR_Load)
+#define SPR_Set (*gEngfuncs.pfnSPR_Set)
+#define SPR_Frames (*gEngfuncs.pfnSPR_Frames)
+#define SPR_GetList (*gEngfuncs.pfnSPR_GetList)
+
+// SPR_Draw  draws a the current sprite as solid
+#define SPR_Draw (*gEngfuncs.pfnSPR_Draw)
+// SPR_DrawHoles  draws the current sprites,  with color index255 not drawn (transparent)
+#define SPR_DrawHoles (*gEngfuncs.pfnSPR_DrawHoles)
+// SPR_DrawAdditive  adds the sprites RGB values to the background  (additive transulency)
+#define SPR_DrawAdditive (*gEngfuncs.pfnSPR_DrawAdditive)
+
+// SPR_EnableScissor  sets a clipping rect for HUD sprites.  (0,0) is the top-left hand corner of the screen.
+#define SPR_EnableScissor (*gEngfuncs.pfnSPR_EnableScissor)
+// SPR_DisableScissor  disables the clipping rect
+#define SPR_DisableScissor (*gEngfuncs.pfnSPR_DisableScissor)
+//
+#define FillRGBA (*gEngfuncs.pfnFillRGBA)
+
+
+// ScreenHeight returns the height of the screen, in pixels
+#define ScreenHeight (gHUD.m_scrinfo.iHeight)
+// ScreenWidth returns the width of the screen, in pixels
+#define ScreenWidth (gHUD.m_scrinfo.iWidth)
+
+#define GetScreenInfo (*gEngfuncs.pfnGetScreenInfo)
+#define ServerCmd (*gEngfuncs.pfnServerCmd)
+#define ClientCmd (*gEngfuncs.pfnClientCmd)
+#define SetCrosshair (*gEngfuncs.pfnSetCrosshair)
+#define AngleVectors (*gEngfuncs.pfnAngleVectors)
+
+
+// Gets the height & width of a sprite,  at the specified frame
+inline int SPR_Height( HSPRITE x, int f )	{ return gEngfuncs.pfnSPR_Height(x, f); }
+inline int SPR_Width( HSPRITE x, int f )	{ return gEngfuncs.pfnSPR_Width(x, f); }
+
+inline 	client_textmessage_t	*TextMessageGet( const char *pName ) { return gEngfuncs.pfnTextMessageGet( pName ); }
+inline 	int						TextMessageDrawChar( int x, int y, int number, int r, int g, int b ) 
+{ 
+	return gEngfuncs.pfnDrawCharacter( x, y, number, r, g, b ); 
+}
+
+inline int DrawConsoleString( int x, int y, const char *string )
+{
+	return gEngfuncs.pfnDrawConsoleString( x, y, (char*) string );
+}
+
+inline void GetConsoleStringSize( const char *string, int *width, int *height )
+{
+	gEngfuncs.pfnDrawConsoleStringLen( string, width, height );
+}
+
+inline int ConsoleStringLen( const char *string )
+{
+	int _width, _height;
+	GetConsoleStringSize( string, &_width, &_height );
+	return _width;
+}
+
+inline void ConsolePrint( const char *string )
+{
+	gEngfuncs.pfnConsolePrint( string );
+}
+
+inline void CenterPrint( const char *string )
+{
+	gEngfuncs.pfnCenterPrint( string );
+}
+
+// returns the players name of entity no.
+#define GetPlayerInfo (*gEngfuncs.pfnGetPlayerInfo)
+
+// sound functions
+inline void PlaySound( char *szSound, float vol ) { gEngfuncs.pfnPlaySoundByName( szSound, vol ); }
+inline void PlaySound( int iSound, float vol ) { gEngfuncs.pfnPlaySoundByIndex( iSound, vol ); }
+
+#define max(a, b)  (((a) > (b)) ? (a) : (b))
+#define min(a, b)  (((a) < (b)) ? (a) : (b))
+#define fabs(x)	   ((x) > 0 ? (x) : 0 - (x))
+
+void ScaleColors( int &r, int &g, int &b, int a );
+
+#define DotProduct(x,y) ((x)[0]*(y)[0]+(x)[1]*(y)[1]+(x)[2]*(y)[2])
+#define VectorSubtract(a,b,c) {(c)[0]=(a)[0]-(b)[0];(c)[1]=(a)[1]-(b)[1];(c)[2]=(a)[2]-(b)[2];}
+#define VectorAdd(a,b,c) {(c)[0]=(a)[0]+(b)[0];(c)[1]=(a)[1]+(b)[1];(c)[2]=(a)[2]+(b)[2];}
+#define VectorCopy(a,b) {(b)[0]=(a)[0];(b)[1]=(a)[1];(b)[2]=(a)[2];}
+#define VectorClear(a) { a[0]=0.0;a[1]=0.0;a[2]=0.0;}
+float Length(const float *v);
+void VectorMA (const float *veca, float scale, const float *vecb, float *vecc);
+void VectorScale (const float *in, float scale, float *out);
+float VectorNormalize (float *v);
+void VectorInverse ( float *v );
+
+extern vec3_t vec3_origin;
+// disable 'possible loss of data converting float to int' warning message
+#pragma warning( disable: 4244 )
+// disable 'truncation from 'const double' to 'float' warning message
+#pragma warning( disable: 4305 )
+
+inline void UnpackRGB(int &r, int &g, int &b, unsigned long ulRGB)\
+{\
+	r = (ulRGB & 0xFF0000) >>16;\
+	g = (ulRGB & 0xFF00) >> 8;\
+	b = ulRGB & 0xFF;\
+}
+
+HSPRITE LoadSprite(const char *pszName);

hlsdk/ricochet/cl_dll/com_weapons.cpp

@@ -0,0 +1,278 @@
+/***
+*
+*	Copyright (c) 1999, Valve LLC. All rights reserved.
+*	
+*	This product contains software technology licensed from Id 
+*	Software, Inc. ("Id Technology").  Id Technology (c) 1996 Id Software, Inc. 
+*	All Rights Reserved.
+*
+*   Use, distribution, and modification of this source code and/or resulting
+*   object code is restricted to non-commercial enhancements to products from
+*   Valve LLC.  All other use, distribution, or modification is prohibited
+*   without written permission from Valve LLC.
+*
+****/
+
+// Com_Weapons.cpp
+// Shared weapons common/shared functions
+#include <stdarg.h>
+#include "hud.h"
+#include "cl_util.h"
+#include "com_weapons.h"
+
+#include "const.h"
+#include "entity_state.h"
+#include "r_efx.h"
+
+// g_runfuncs is true if this is the first time we've "predicated" a particular movement/firing
+//  command.  If it is 1, then we should play events/sounds etc., otherwise, we just will be
+//  updating state info, but not firing events
+int	g_runfuncs = 0;
+
+// During our weapon prediction processing, we'll need to reference some data that is part of
+//  the final state passed into the postthink functionality.  We'll set this pointer and then
+//  reset it to NULL as appropriate
+struct local_state_s *g_finalstate = NULL;
+
+/*
+====================
+COM_Log
+
+Log debug messages to file ( appends )
+====================
+*/
+void COM_Log( char *pszFile, char *fmt, ...)
+{
+	va_list		argptr;
+	char		string[1024];
+	FILE *fp;
+	char *pfilename;
+	
+	if ( !pszFile )
+	{
+		pfilename = "c:\\hllog.txt";
+	}
+	else
+	{
+		pfilename = pszFile;
+	}
+
+	va_start (argptr,fmt);
+	vsprintf (string, fmt,argptr);
+	va_end (argptr);
+
+	fp = fopen( pfilename, "a+t");
+	if (fp)
+	{
+		fprintf(fp, "%s", string);
+		fclose(fp);
+	}
+}
+
+// remember the current animation for the view model, in case we get out of sync with
+//  server.
+static int g_currentanim;
+
+/*
+=====================
+HUD_SendWeaponAnim
+
+Change weapon model animation
+=====================
+*/
+void HUD_SendWeaponAnim( int iAnim, int body, int force )
+{
+	// Don't actually change it.
+	if ( !g_runfuncs && !force )
+		return;
+
+	g_currentanim = iAnim;
+
+	// Tell animation system new info
+	gEngfuncs.pfnWeaponAnim( iAnim, body );
+}
+
+/*
+=====================
+HUD_GetWeaponAnim
+
+Retrieve current predicted weapon animation
+=====================
+*/
+int HUD_GetWeaponAnim( void )
+{
+	return g_currentanim;
+}
+
+/*
+=====================
+HUD_PlaySound
+
+Play a sound, if we are seeing this command for the first time
+=====================
+*/
+void HUD_PlaySound( char *sound, float volume )
+{
+	if ( !g_runfuncs || !g_finalstate )
+		return;
+
+	gEngfuncs.pfnPlaySoundByNameAtLocation( sound, volume, (float *)&g_finalstate->playerstate.origin );
+}
+
+/*
+=====================
+HUD_PlaybackEvent
+
+Directly queue up an event on the client
+=====================
+*/
+void HUD_PlaybackEvent( int flags, const edict_t *pInvoker, unsigned short eventindex, float delay,
+	float *origin, float *angles, float fparam1, float fparam2, int iparam1, int iparam2, int bparam1, int bparam2 )
+{
+	vec3_t org;
+	vec3_t ang;
+
+	if ( !g_runfuncs || !g_finalstate )
+		return;
+
+	// Weapon prediction events are assumed to occur at the player's origin
+	org			= g_finalstate->playerstate.origin;
+	ang			= v_angles;
+	gEngfuncs.pfnPlaybackEvent( flags, pInvoker, eventindex, delay, (float *)&org, (float *)&ang, fparam1, fparam2, iparam1, iparam2, bparam1, bparam2 );
+}
+
+/*
+=====================
+HUD_SetMaxSpeed
+
+=====================
+*/
+void HUD_SetMaxSpeed( const edict_t *ed, float speed )
+{
+}
+
+
+/*
+=====================
+UTIL_WeaponTimeBase
+
+Always 0.0 on client, even if not predicting weapons ( won't get called
+ in that case )
+=====================
+*/
+float UTIL_WeaponTimeBase( void )
+{
+	return 0.0;
+}
+
+static unsigned int glSeed = 0; 
+
+unsigned int seed_table[ 256 ] =
+{
+	28985, 27138, 26457, 9451, 17764, 10909, 28790, 8716, 6361, 4853, 17798, 21977, 19643, 20662, 10834, 20103,
+	27067, 28634, 18623, 25849, 8576, 26234, 23887, 18228, 32587, 4836, 3306, 1811, 3035, 24559, 18399, 315,
+	26766, 907, 24102, 12370, 9674, 2972, 10472, 16492, 22683, 11529, 27968, 30406, 13213, 2319, 23620, 16823,
+	10013, 23772, 21567, 1251, 19579, 20313, 18241, 30130, 8402, 20807, 27354, 7169, 21211, 17293, 5410, 19223,
+	10255, 22480, 27388, 9946, 15628, 24389, 17308, 2370, 9530, 31683, 25927, 23567, 11694, 26397, 32602, 15031,
+	18255, 17582, 1422, 28835, 23607, 12597, 20602, 10138, 5212, 1252, 10074, 23166, 19823, 31667, 5902, 24630,
+	18948, 14330, 14950, 8939, 23540, 21311, 22428, 22391, 3583, 29004, 30498, 18714, 4278, 2437, 22430, 3439,
+	28313, 23161, 25396, 13471, 19324, 15287, 2563, 18901, 13103, 16867, 9714, 14322, 15197, 26889, 19372, 26241,
+	31925, 14640, 11497, 8941, 10056, 6451, 28656, 10737, 13874, 17356, 8281, 25937, 1661, 4850, 7448, 12744,
+	21826, 5477, 10167, 16705, 26897, 8839, 30947, 27978, 27283, 24685, 32298, 3525, 12398, 28726, 9475, 10208,
+	617, 13467, 22287, 2376, 6097, 26312, 2974, 9114, 21787, 28010, 4725, 15387, 3274, 10762, 31695, 17320,
+	18324, 12441, 16801, 27376, 22464, 7500, 5666, 18144, 15314, 31914, 31627, 6495, 5226, 31203, 2331, 4668,
+	12650, 18275, 351, 7268, 31319, 30119, 7600, 2905, 13826, 11343, 13053, 15583, 30055, 31093, 5067, 761,
+	9685, 11070, 21369, 27155, 3663, 26542, 20169, 12161, 15411, 30401, 7580, 31784, 8985, 29367, 20989, 14203,
+	29694, 21167, 10337, 1706, 28578, 887, 3373, 19477, 14382, 675, 7033, 15111, 26138, 12252, 30996, 21409,
+	25678, 18555, 13256, 23316, 22407, 16727, 991, 9236, 5373, 29402, 6117, 15241, 27715, 19291, 19888, 19847
+};
+
+unsigned int U_Random( void ) 
+{ 
+	glSeed *= 69069; 
+	glSeed += seed_table[ glSeed & 0xff ];
+ 
+	return ( ++glSeed & 0x0fffffff ); 
+} 
+
+void U_Srand( unsigned int seed )
+{
+	glSeed = seed_table[ seed & 0xff ];
+}
+
+/*
+=====================
+UTIL_SharedRandomLong
+=====================
+*/
+int UTIL_SharedRandomLong( unsigned int seed, int low, int high )
+{
+
+	unsigned int range;
+
+	U_Srand( (int)seed + low + high );
+
+	range = high - low + 1;
+	if ( !(range - 1) )
+	{
+		return low;
+	}
+	else
+	{
+		int offset;
+		int rnum;
+
+		rnum = U_Random();
+
+		offset = rnum % range;
+
+		return (low + offset);
+	}
+}
+
+/*
+=====================
+UTIL_SharedRandomFloat
+=====================
+*/
+float UTIL_SharedRandomFloat( unsigned int seed, float low, float high )
+{
+	//
+	unsigned int range;
+
+	U_Srand( (int)seed + *(int *)&low + *(int *)&high );
+
+	U_Random();
+	U_Random();
+
+	range = high - low;
+	if ( !range )
+	{
+		return low;
+	}
+	else
+	{
+		int tensixrand;
+		float offset;
+
+		tensixrand = U_Random() & 65535;
+
+		offset = (float)tensixrand / 65536.0;
+
+		return (low + offset * range );
+	}
+}
+
+/*
+======================
+stub_*
+
+stub functions for such things as precaching.  So we don't have to modify weapons code that
+ is compiled into both game and client .dlls.
+======================
+*/
+int				stub_PrecacheModel		( char* s ) { return 0; }
+int				stub_PrecacheSound		( char* s ) { return 0; }
+unsigned short	stub_PrecacheEvent		( int type, const char *s ) { return 0; }
+const char		*stub_NameForFunction	( uint32 function ) { return "func"; }
+void			stub_SetModel			( edict_t *e, const char *m ) {}

hlsdk/ricochet/cl_dll/com_weapons.h

@@ -0,0 +1,41 @@
+// com_weapons.h
+// Shared weapons common function prototypes
+#if !defined( COM_WEAPONSH )
+#define COM_WEAPONSH
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "hud_iface.h"
+
+extern "C"
+{
+	void _DLLEXPORT HUD_PostRunCmd( struct local_state_s *from, struct local_state_s *to, struct usercmd_s *cmd, int runfuncs, double time, unsigned int random_seed );
+}
+
+void			COM_Log( char *pszFile, char *fmt, ...);
+int				CL_IsDead( void );
+
+float			UTIL_SharedRandomFloat( unsigned int seed, float low, float high );
+int				UTIL_SharedRandomLong( unsigned int seed, int low, int high );
+
+int				HUD_GetWeaponAnim( void );
+void			HUD_SendWeaponAnim( int iAnim, int body, int force );
+void			HUD_PlaySound( char *sound, float volume );
+void			HUD_PlaybackEvent( int flags, const struct edict_s *pInvoker, unsigned short eventindex, float delay, float *origin, float *angles, float fparam1, float fparam2, int iparam1, int iparam2, int bparam1, int bparam2 );
+void			HUD_SetMaxSpeed( const struct edict_s *ed, float speed );
+int				stub_PrecacheModel( char* s );
+int				stub_PrecacheSound( char* s );
+unsigned short	stub_PrecacheEvent( int type, const char *s );
+const char		*stub_NameForFunction	( uint32 function );
+void			stub_SetModel			( struct edict_s *e, const char *m );
+
+
+extern cvar_t *cl_lw;
+
+extern int g_runfuncs;
+extern vec3_t v_angles;
+extern float g_lastFOV;
+extern struct local_state_s *g_finalstate;
+
+#endif

hlsdk/ricochet/cl_dll/death.cpp

@@ -0,0 +1,307 @@
+/***
+*
+*	Copyright (c) 1999, Valve LLC. All rights reserved.
+*	
+*	This product contains software technology licensed from Id 
+*	Software, Inc. ("Id Technology").  Id Technology (c) 1996 Id Software, Inc. 
+*	All Rights Reserved.
+*
+*   Use, distribution, and modification of this source code and/or resulting
+*   object code is restricted to non-commercial enhancements to products from
+*   Valve LLC.  All other use, distribution, or modification is prohibited
+*   without written permission from Valve LLC.
+*
+****/
+//
+// death notice
+//
+#include "hud.h"
+#include "cl_util.h"
+#include "parsemsg.h"
+
+#include <string.h>
+#include <stdio.h>
+
+#include "vgui_TeamFortressViewport.h"
+
+DECLARE_MESSAGE( m_DeathNotice, DeathMsg );
+
+struct DeathNoticeItem {
+	char szKiller[MAX_PLAYER_NAME_LENGTH*2];
+	char szVictim[MAX_PLAYER_NAME_LENGTH*2];
+	int iId;	// the index number of the associated sprite
+	int iSuicide;
+	int iTeamKill;
+	int iNonPlayerKill;
+	float flDisplayTime;
+	float *KillerColor;
+	float *VictimColor;
+};
+
+#define MAX_DEATHNOTICES	4
+static int DEATHNOTICE_DISPLAY_TIME = 6;
+
+#define DEATHNOTICE_TOP		20
+
+DeathNoticeItem rgDeathNoticeList[ MAX_DEATHNOTICES + 1 ];
+
+float g_ColorBlue[3]	= { 0.6, 0.8, 1.0 };
+float g_ColorRed[3]		= { 1.0, 0.6, 0.3 };
+float g_ColorGreen[3]	= { 0.6, 1.0, 0.6 };
+float g_ColorYellow[3]	= { 1.0, 0.7, 0.0 };
+
+float *GetClientColor( int clientIndex )
+{
+	const char *teamName = g_PlayerExtraInfo[clientIndex].teamname;
+
+	if ( !teamName || *teamName == 0 ) 
+		return NULL;
+
+	if ( !stricmp( "blue", teamName ) )
+		return g_ColorBlue;
+	else if ( !stricmp( "red", teamName ) )
+		return g_ColorRed;
+	else if ( !stricmp( "green", teamName ) )
+		return g_ColorGreen;
+	else if ( !stricmp( "yellow", teamName ) )
+		return g_ColorYellow;
+
+	return NULL;
+}
+
+
+int CHudDeathNotice :: Init( void )
+{
+	gHUD.AddHudElem( this );
+
+	HOOK_MESSAGE( DeathMsg );
+
+	CVAR_CREATE( "hud_deathnotice_time", "6", 0 );
+
+	return 1;
+}
+
+
+void CHudDeathNotice :: InitHUDData( void )
+{
+	memset( rgDeathNoticeList, 0, sizeof(rgDeathNoticeList) );
+}
+
+
+int CHudDeathNotice :: VidInit( void )
+{
+	m_HUD_d_skull = gHUD.GetSpriteIndex( "d_skull" );
+
+	return 1;
+}
+
+int CHudDeathNotice :: Draw( float flTime )
+{
+	int x, y, r, g, b;
+
+	for ( int i = 0; i < MAX_DEATHNOTICES; i++ )
+	{
+		if ( rgDeathNoticeList[i].iId == 0 )
+			break;  // we've gone through them all
+
+		if ( rgDeathNoticeList[i].flDisplayTime < flTime )
+		{ // display time has expired
+			// remove the current item from the list
+			memmove( &rgDeathNoticeList[i], &rgDeathNoticeList[i+1], sizeof(DeathNoticeItem) * (MAX_DEATHNOTICES - i) );
+			i--;  // continue on the next item;  stop the counter getting incremented
+			continue;
+		}
+
+		rgDeathNoticeList[i].flDisplayTime = min( rgDeathNoticeList[i].flDisplayTime, gHUD.m_flTime + DEATHNOTICE_DISPLAY_TIME );
+
+		// Draw the death notice
+
+		// Make it a bigger increment in 640, 'cos the Discwar death sprites are 32 tall, not 16 in 640
+		if ( ScreenHeight >= 640 )
+			y = DEATHNOTICE_TOP + (36 * i);  //!!!
+		else
+			y = DEATHNOTICE_TOP + (20 * i);  //!!!
+
+		int id = (rgDeathNoticeList[i].iId == -1) ? m_HUD_d_skull : rgDeathNoticeList[i].iId;
+		x = ScreenWidth - ConsoleStringLen(rgDeathNoticeList[i].szVictim) - (gHUD.GetSpriteRect(id).right - gHUD.GetSpriteRect(id).left);
+
+		if ( !rgDeathNoticeList[i].iSuicide )
+		{
+			x -= (5 + ConsoleStringLen( rgDeathNoticeList[i].szKiller ) );
+
+			// Draw killers name
+			if ( rgDeathNoticeList[i].KillerColor )
+				gEngfuncs.pfnDrawSetTextColor( rgDeathNoticeList[i].KillerColor[0], rgDeathNoticeList[i].KillerColor[1], rgDeathNoticeList[i].KillerColor[2] );
+			x = 5 + DrawConsoleString( x, y, rgDeathNoticeList[i].szKiller );
+		}
+
+		r = 255;  g = 80;	b = 0;
+		if ( rgDeathNoticeList[i].iTeamKill )
+		{
+			r = 10;	g = 240; b = 10;  // display it in sickly green
+		}
+
+		// Draw death weapon
+		SPR_Set( gHUD.GetSprite(id), r, g, b );
+		SPR_DrawAdditive( 0, x, y, &gHUD.GetSpriteRect(id) );
+
+		x += (gHUD.GetSpriteRect(id).right - gHUD.GetSpriteRect(id).left);
+
+		// Draw victims name (if it was a player that was killed)
+		if (rgDeathNoticeList[i].iNonPlayerKill == FALSE)
+		{
+			if ( rgDeathNoticeList[i].VictimColor )
+				gEngfuncs.pfnDrawSetTextColor( rgDeathNoticeList[i].VictimColor[0], rgDeathNoticeList[i].VictimColor[1], rgDeathNoticeList[i].VictimColor[2] );
+			x = DrawConsoleString( x, y, rgDeathNoticeList[i].szVictim );
+		}
+	}
+
+	return 1;
+}
+
+// This message handler may be better off elsewhere
+int CHudDeathNotice :: MsgFunc_DeathMsg( const char *pszName, int iSize, void *pbuf )
+{
+	m_iFlags |= HUD_ACTIVE;
+
+	BEGIN_READ( pbuf, iSize );
+
+	int killer = READ_BYTE();
+	int victim = READ_BYTE();
+
+	char killedwith[32];
+	strcpy( killedwith, "d_" );
+	strncat( killedwith, READ_STRING(), 32 );
+
+	if (gViewPort)
+		gViewPort->DeathMsg( killer, victim );
+
+	int i;
+	for ( i = 0; i < MAX_DEATHNOTICES; i++ )
+	{
+		if ( rgDeathNoticeList[i].iId == 0 )
+			break;
+	}
+	if ( i == MAX_DEATHNOTICES )
+	{ // move the rest of the list forward to make room for this item
+		memmove( rgDeathNoticeList, rgDeathNoticeList+1, sizeof(DeathNoticeItem) * MAX_DEATHNOTICES );
+		i = MAX_DEATHNOTICES - 1;
+	}
+
+	if (gViewPort)
+		gViewPort->GetAllPlayersInfo();
+
+	// Get the Killer's name
+	char *killer_name = g_PlayerInfoList[ killer ].name;
+	if ( !killer_name )
+	{
+		killer_name = "";
+		rgDeathNoticeList[i].szKiller[0] = 0;
+	}
+	else
+	{
+		rgDeathNoticeList[i].KillerColor = GetClientColor( killer );
+		strncpy( rgDeathNoticeList[i].szKiller, killer_name, MAX_PLAYER_NAME_LENGTH );
+		rgDeathNoticeList[i].szKiller[MAX_PLAYER_NAME_LENGTH-1] = 0;
+	}
+
+	// Get the Victim's name
+	char *victim_name = NULL;
+	// If victim is -1, the killer killed a specific, non-player object (like a sentrygun)
+	if ( ((char)victim) != -1 )
+		victim_name = g_PlayerInfoList[ victim ].name;
+	if ( !victim_name )
+	{
+		victim_name = "";
+		rgDeathNoticeList[i].szVictim[0] = 0;
+	}
+	else
+	{
+		rgDeathNoticeList[i].VictimColor = GetClientColor( victim );
+		strncpy( rgDeathNoticeList[i].szVictim, victim_name, MAX_PLAYER_NAME_LENGTH );
+		rgDeathNoticeList[i].szVictim[MAX_PLAYER_NAME_LENGTH-1] = 0;
+	}
+
+	// Is it a non-player object kill?
+	if ( ((char)victim) == -1 )
+	{
+		rgDeathNoticeList[i].iNonPlayerKill = TRUE;
+
+		// Store the object's name in the Victim slot (skip the d_ bit)
+		strcpy( rgDeathNoticeList[i].szVictim, killedwith+2 );
+	}
+	else
+	{
+		if ( killer == victim || killer == 0 )
+			rgDeathNoticeList[i].iSuicide = TRUE;
+
+		if ( !strcmp( killedwith, "d_teammate" ) )
+			rgDeathNoticeList[i].iTeamKill = TRUE;
+	}
+
+	// Find the sprite in the list
+	int spr = gHUD.GetSpriteIndex( killedwith );
+
+	rgDeathNoticeList[i].iId = spr;
+
+	DEATHNOTICE_DISPLAY_TIME = CVAR_GET_FLOAT( "hud_deathnotice_time" );
+	rgDeathNoticeList[i].flDisplayTime = gHUD.m_flTime + DEATHNOTICE_DISPLAY_TIME;
+
+	if (rgDeathNoticeList[i].iNonPlayerKill)
+	{
+		ConsolePrint( rgDeathNoticeList[i].szKiller );
+		ConsolePrint( " killed a " );
+		ConsolePrint( rgDeathNoticeList[i].szVictim );
+		ConsolePrint( "\n" );
+	}
+	else
+	{
+		// record the death notice in the console
+		if ( rgDeathNoticeList[i].iSuicide )
+		{
+			ConsolePrint( rgDeathNoticeList[i].szVictim );
+
+			if ( !strcmp( killedwith, "d_world" ) )
+			{
+				ConsolePrint( " died" );
+			}
+			else
+			{
+				ConsolePrint( " killed self" );
+			}
+		}
+		else if ( rgDeathNoticeList[i].iTeamKill )
+		{
+			ConsolePrint( rgDeathNoticeList[i].szKiller );
+			ConsolePrint( " killed his teammate " );
+			ConsolePrint( rgDeathNoticeList[i].szVictim );
+		}
+		else
+		{
+			ConsolePrint( rgDeathNoticeList[i].szKiller );
+			ConsolePrint( " killed " );
+			ConsolePrint( rgDeathNoticeList[i].szVictim );
+		}
+
+		if ( killedwith && *killedwith && (*killedwith > 13 ) && strcmp( killedwith, "d_world" ) && !rgDeathNoticeList[i].iTeamKill )
+		{
+			ConsolePrint( " with " );
+
+			// replace the code names with the 'real' names
+			if ( !strcmp( killedwith+2, "egon" ) )
+				strcpy( killedwith, "d_gluon gun" );
+			if ( !strcmp( killedwith+2, "gauss" ) )
+				strcpy( killedwith, "d_tau cannon" );
+
+			ConsolePrint( killedwith+2 ); // skip over the "d_" part
+		}
+
+		ConsolePrint( "\n" );
+	}
+
+	return 1;
+}
+
+
+
+

hlsdk/ricochet/cl_dll/demo.cpp

@@ -0,0 +1,70 @@
+/***
+*
+*	Copyright (c) 1999, 2000 Valve LLC. All rights reserved.
+*	
+*	This product contains software technology licensed from Id 
+*	Software, Inc. ("Id Technology").  Id Technology (c) 1996 Id Software, Inc. 
+*	All Rights Reserved.
+*
+*   Use, distribution, and modification of this source code and/or resulting
+*   object code is restricted to non-commercial enhancements to products from
+*   Valve LLC.  All other use, distribution, or modification is prohibited
+*   without written permission from Valve LLC.
+*
+****/
+#include "hud.h"
+#include "cl_util.h"
+#include "demo.h"
+#include "demo_api.h"
+#include <memory.h>
+
+#define DLLEXPORT __declspec( dllexport )
+
+extern "C" 
+{
+	void DLLEXPORT Demo_ReadBuffer( int size, unsigned char *buffer );
+}
+
+/*
+=====================
+Demo_WriteBuffer
+
+Write some data to the demo stream
+=====================
+*/
+void Demo_WriteBuffer( int type, int size, unsigned char *buffer )
+{
+	int pos = 0;
+	unsigned char buf[ 32 * 1024 ];
+	*( int * )&buf[pos] = type;
+	pos+=sizeof( int );
+
+	memcpy( &buf[pos], buffer, size );
+
+	// Write full buffer out
+	gEngfuncs.pDemoAPI->WriteBuffer( size + sizeof( int ), buf );
+}
+
+/*
+=====================
+Demo_ReadBuffer
+
+Engine wants us to parse some data from the demo stream
+=====================
+*/
+void DLLEXPORT Demo_ReadBuffer( int size, unsigned char *buffer )
+{
+	int type;
+	int i = 0;
+
+	type = *( int * )buffer;
+	i += sizeof( int );
+	switch ( type )
+	{
+	case TYPE_USER:
+		break;
+	default:
+		gEngfuncs.Con_DPrintf( "Unknown demo buffer type, skipping.\n" );
+		break;
+	}
+}

hlsdk/ricochet/cl_dll/demo.h

@@ -0,0 +1,27 @@
+/***
+*
+*	Copyright (c) 1999, 2000 Valve LLC. All rights reserved.
+*	
+*	This product contains software technology licensed from Id 
+*	Software, Inc. ("Id Technology").  Id Technology (c) 1996 Id Software, Inc. 
+*	All Rights Reserved.
+*
+*   Use, distribution, and modification of this source code and/or resulting
+*   object code is restricted to non-commercial enhancements to products from
+*   Valve LLC.  All other use, distribution, or modification is prohibited
+*   without written permission from Valve LLC.
+*
+****/
+#if !defined( DEMOH )
+#define DEMOH
+#pragma once
+
+// Types of demo messages we can write/parse
+enum
+{
+	TYPE_USER = 0,
+};
+
+void Demo_WriteBuffer( int type, int size, unsigned char *buffer );
+
+#endif

hlsdk/ricochet/cl_dll/entity.cpp

@@ -0,0 +1,643 @@
+/***
+*
+*	Copyright (c) 1999, 2000, Valve LLC. All rights reserved.
+*	
+*	This product contains software technology licensed from Id 
+*	Software, Inc. ("Id Technology").  Id Technology (c) 1996 Id Software, Inc. 
+*	All Rights Reserved.
+*
+*   Use, distribution, and modification of this source code and/or resulting
+*   object code is restricted to non-commercial enhancements to products from
+*   Valve LLC.  All other use, distribution, or modification is prohibited
+*   without written permission from Valve LLC.
+*
+****/
+// Client side entity management functions
+#include <memory.h>
+
+#include "hud.h"
+#include "cl_util.h"
+#include "const.h"
+#include "entity_types.h"
+#include "studio_event.h" // def. of mstudioevent_t
+#include "r_efx.h"
+#include "event_api.h"
+#include "pm_defs.h"
+#include "pmtrace.h"
+
+#include <string.h>
+
+#define DLLEXPORT __declspec( dllexport )
+
+extern vec3_t v_origin;
+extern int	iPrevRenderState;
+extern int  iRenderStateChanged;
+
+void Game_AddObjects( void );
+
+extern "C" 
+{
+	int DLLEXPORT HUD_AddEntity( int type, struct cl_entity_s *ent, const char *modelname );
+	void DLLEXPORT HUD_CreateEntities( void );
+	void DLLEXPORT HUD_StudioEvent( const struct mstudioevent_s *event, const struct cl_entity_s *entity );
+	void DLLEXPORT HUD_TxferLocalOverrides( struct entity_state_s *state, const struct clientdata_s *client );
+	void DLLEXPORT HUD_ProcessPlayerState( struct entity_state_s *dst, const struct entity_state_s *src );
+	void DLLEXPORT HUD_TxferPredictionData ( struct entity_state_s *ps, const struct entity_state_s *pps, struct clientdata_s *pcd, const struct clientdata_s *ppcd, struct weapon_data_s *wd, const struct weapon_data_s *pwd );
+	void DLLEXPORT HUD_TempEntUpdate( double frametime, double client_time, double cl_gravity, struct tempent_s **ppTempEntFree, struct tempent_s **ppTempEntActive, int ( *Callback_AddVisibleEntity )( struct cl_entity_s *pEntity ), void ( *Callback_TempEntPlaySound )( struct tempent_s *pTemp, float damp ) );
+	struct cl_entity_s DLLEXPORT *HUD_GetUserEntity( int index );
+}
+
+/*
+========================
+HUD_AddEntity
+	Return 0 to filter entity from visible list for rendering
+========================
+*/
+int DLLEXPORT HUD_AddEntity( int type, struct cl_entity_s *ent, const char *modelname )
+{
+	switch ( type )
+	{
+	case ET_NORMAL:
+	case ET_PLAYER:
+	case ET_BEAM:
+	case ET_TEMPENTITY:
+	case ET_FRAGMENTED:
+	default:
+		break;
+	}
+
+	return 1;
+}
+
+/*
+=========================
+HUD_TxferLocalOverrides
+
+The server sends us our origin with extra precision as part of the clientdata structure, not during the normal
+playerstate update in entity_state_t.  In order for these overrides to eventually get to the appropriate playerstate
+structure, we need to copy them into the state structure at this point.
+=========================
+*/
+void DLLEXPORT HUD_TxferLocalOverrides( struct entity_state_s *state, const struct clientdata_s *client )
+{
+	VectorCopy( client->origin, state->origin );
+
+	// Spectator
+	state->iuser1 = client->iuser1;
+	state->iuser2 = client->iuser2;
+}
+
+/*
+=========================
+HUD_ProcessPlayerState
+
+We have received entity_state_t for this player over the network.  We need to copy appropriate fields to the
+playerstate structure
+=========================
+*/
+void DLLEXPORT HUD_ProcessPlayerState( struct entity_state_s *dst, const struct entity_state_s *src )
+{
+	cl_entity_t *player = gEngfuncs.GetLocalPlayer();	// Get the local player's index
+
+	// Copy in network data
+	VectorCopy( src->origin, dst->origin );
+	VectorCopy( src->angles, dst->angles );
+
+	VectorCopy( src->velocity, dst->velocity );
+
+	dst->frame					= src->frame;
+	dst->modelindex				= src->modelindex;
+	dst->skin					= src->skin;
+	dst->effects				= src->effects;
+	dst->weaponmodel			= src->weaponmodel;
+	dst->movetype				= src->movetype;
+	dst->sequence				= src->sequence;
+	dst->animtime				= src->animtime;
+	
+	dst->solid					= src->solid;
+	
+	dst->rendermode				= src->rendermode;
+	dst->renderamt				= src->renderamt;	
+	dst->rendercolor.r			= src->rendercolor.r;
+	dst->rendercolor.g			= src->rendercolor.g;
+	dst->rendercolor.b			= src->rendercolor.b;
+	dst->renderfx				= src->renderfx;
+
+	// Hack to find out when our render state changes.
+	// Needed because we need the previous render state when we flip to thirdperson
+	if ( dst->number == player->index )
+	{
+		if ( iPrevRenderState != dst->renderfx )
+			iRenderStateChanged = TRUE;
+		iPrevRenderState			= dst->renderfx;
+	}
+
+	dst->framerate				= src->framerate;
+	dst->body					= src->body;
+
+	memcpy( &dst->controller[0], &src->controller[0], 4 * sizeof( byte ) );
+	memcpy( &dst->blending[0], &src->blending[0], 2 * sizeof( byte ) );
+
+	VectorCopy( src->basevelocity, dst->basevelocity );
+
+	dst->friction				= src->friction;
+	dst->gravity				= src->gravity;
+	dst->gaitsequence			= src->gaitsequence;
+	dst->spectator				= src->spectator;
+	dst->usehull				= src->usehull;
+	dst->playerclass			= src->playerclass;
+	dst->team					= src->team;
+	dst->colormap				= src->colormap;
+
+	// Save off some data so other areas of the Client DLL can get to it
+	if ( dst->number == player->index )
+	{
+		g_iPlayerClass = dst->playerclass;
+		g_iTeamNumber = dst->team;
+		g_iUser1 = src->iuser1;
+		g_iUser2 = src->iuser2;
+	}
+}
+
+/*
+=========================
+HUD_TxferPredictionData
+
+Because we can predict an arbitrary number of frames before the server responds with an update, we need to be able to copy client side prediction data in
+ from the state that the server ack'd receiving, which can be anywhere along the predicted frame path ( i.e., we could predict 20 frames into the future and the server ack's
+ up through 10 of those frames, so we need to copy persistent client-side only state from the 10th predicted frame to the slot the server
+ update is occupying.
+=========================
+*/
+void DLLEXPORT HUD_TxferPredictionData ( struct entity_state_s *ps, const struct entity_state_s *pps, struct clientdata_s *pcd, const struct clientdata_s *ppcd, struct weapon_data_s *wd, const struct weapon_data_s *pwd )
+{
+	ps->oldbuttons				= pps->oldbuttons;
+	ps->flFallVelocity			= pps->flFallVelocity;
+	ps->iStepLeft				= pps->iStepLeft;
+	ps->playerclass				= pps->playerclass;
+
+	ps->sequence				= pps->sequence;
+	ps->gaitsequence			= pps->gaitsequence;
+
+	pcd->viewmodel				= ppcd->viewmodel;
+	pcd->m_iId					= ppcd->m_iId;
+	pcd->ammo_shells			= ppcd->ammo_shells;
+	pcd->ammo_nails				= ppcd->ammo_nails;
+	pcd->ammo_cells				= ppcd->ammo_cells;
+	pcd->ammo_rockets			= ppcd->ammo_rockets;
+	pcd->m_flNextAttack			= ppcd->m_flNextAttack;
+	pcd->fov					= ppcd->fov;
+	pcd->weaponanim				= ppcd->weaponanim;
+	pcd->tfstate				= ppcd->tfstate;
+	pcd->maxspeed				= ppcd->maxspeed;
+
+	pcd->deadflag				= ppcd->deadflag;
+
+	// Spectator
+	pcd->iuser1					= ppcd->iuser1;
+	pcd->iuser2					= ppcd->iuser2;
+
+	pcd->fuser1					= ppcd->fuser1;
+	pcd->fuser2					= ppcd->fuser2;
+	pcd->fuser3					= ppcd->fuser3;
+
+	memcpy( wd, pwd, 32 * sizeof( weapon_data_t ) );
+}
+
+/*
+=========================
+HUD_CreateEntities
+	
+Gives us a chance to add additional entities to the render this frame
+=========================
+*/
+void DLLEXPORT HUD_CreateEntities( void )
+{
+	// e.g., create a persistent cl_entity_t somewhere.
+	// Load an appropriate model into it ( gEngfuncs.CL_LoadModel )
+	// Call gEngfuncs.CL_CreateVisibleEntity to add it to the visedicts list
+
+	// Add in any game specific objects
+	Game_AddObjects();
+
+	GetClientVoiceMgr()->CreateEntities();
+}
+
+/*
+=========================
+HUD_StudioEvent
+
+The entity's studio model description indicated an event was
+fired during this frame, handle the event by it's tag ( e.g., muzzleflash, sound )
+=========================
+*/
+void DLLEXPORT HUD_StudioEvent( const struct mstudioevent_s *event, const struct cl_entity_s *entity )
+{
+	switch( event->event )
+	{
+	case 5001:
+		gEngfuncs.pEfxAPI->R_MuzzleFlash( (float *)&entity->attachment[0], atoi( event->options) );
+		break;
+	case 5011:
+		gEngfuncs.pEfxAPI->R_MuzzleFlash( (float *)&entity->attachment[1], atoi( event->options) );
+		break;
+	case 5021:
+		gEngfuncs.pEfxAPI->R_MuzzleFlash( (float *)&entity->attachment[2], atoi( event->options) );
+		break;
+	case 5031:
+		gEngfuncs.pEfxAPI->R_MuzzleFlash( (float *)&entity->attachment[3], atoi( event->options) );
+		break;
+	case 5002:
+		gEngfuncs.pEfxAPI->R_SparkEffect( (float *)&entity->attachment[0], atoi( event->options), -100, 100 );
+		break;
+	// Client side sound
+	case 5004:		
+		gEngfuncs.pfnPlaySoundByNameAtLocation( (char *)event->options, 1.0, (float *)&entity->attachment[0] );
+		break;
+	default:
+		break;
+	}
+}
+
+/*
+=================
+CL_UpdateTEnts
+
+Simulation and cleanup of temporary entities
+=================
+*/
+void DLLEXPORT HUD_TempEntUpdate (
+	double frametime,   // Simulation time
+	double client_time, // Absolute time on client
+	double cl_gravity,  // True gravity on client
+	TEMPENTITY **ppTempEntFree,   // List of freed temporary ents
+	TEMPENTITY **ppTempEntActive, // List 
+	int		( *Callback_AddVisibleEntity )( cl_entity_t *pEntity ),
+	void	( *Callback_TempEntPlaySound )( TEMPENTITY *pTemp, float damp ) )
+{
+	static int gTempEntFrame = 0;
+	int			i;
+	TEMPENTITY	*pTemp, *pnext, *pprev;
+	float		freq, gravity, gravitySlow, life, fastFreq;
+
+	// Nothing to simulate
+	if ( !*ppTempEntActive )		
+		return;
+
+	// in order to have tents collide with players, we have to run the player prediction code so
+	// that the client has the player list. We run this code once when we detect any COLLIDEALL 
+	// tent, then set this BOOL to true so the code doesn't get run again if there's more than
+	// one COLLIDEALL ent for this update. (often are).
+	gEngfuncs.pEventAPI->EV_SetUpPlayerPrediction( false, true );
+
+	// Store off the old count
+	gEngfuncs.pEventAPI->EV_PushPMStates();
+
+	// Now add in all of the players.
+	gEngfuncs.pEventAPI->EV_SetSolidPlayers ( -1 );	
+
+	// !!!BUGBUG	-- This needs to be time based
+	gTempEntFrame = (gTempEntFrame+1) & 31;
+
+	pTemp = *ppTempEntActive;
+
+	// !!! Don't simulate while paused....  This is sort of a hack, revisit.
+	if ( frametime <= 0 )
+	{
+		while ( pTemp )
+		{
+			if ( !(pTemp->flags & FTENT_NOMODEL ) )
+			{
+				Callback_AddVisibleEntity( &pTemp->entity );
+			}
+			pTemp = pTemp->next;
+		}
+		goto finish;
+	}
+
+	pprev = NULL;
+	freq = client_time * 0.01;
+	fastFreq = client_time * 5.5;
+	gravity = -frametime * cl_gravity;
+	gravitySlow = gravity * 0.5;
+
+	while ( pTemp )
+	{
+		int active;
+
+		active = 1;
+
+		life = pTemp->die - client_time;
+		pnext = pTemp->next;
+		if ( life < 0 )
+		{
+			if ( pTemp->flags & FTENT_FADEOUT )
+			{
+				if (pTemp->entity.curstate.rendermode == kRenderNormal)
+					pTemp->entity.curstate.rendermode = kRenderTransTexture;
+				pTemp->entity.curstate.renderamt = pTemp->entity.baseline.renderamt * ( 1 + life * pTemp->fadeSpeed );
+				if ( pTemp->entity.curstate.renderamt <= 0 )
+					active = 0;
+
+			}
+			else 
+				active = 0;
+		}
+		if ( !active )		// Kill it
+		{
+			pTemp->next = *ppTempEntFree;
+			*ppTempEntFree = pTemp;
+			if ( !pprev )	// Deleting at head of list
+				*ppTempEntActive = pnext;
+			else
+				pprev->next = pnext;
+		}
+		else
+		{
+			pprev = pTemp;
+			
+			VectorCopy( pTemp->entity.origin, pTemp->entity.prevstate.origin );
+
+			if ( pTemp->flags & FTENT_SPARKSHOWER )
+			{
+				// Adjust speed if it's time
+				// Scale is next think time
+				if ( client_time > pTemp->entity.baseline.scale )
+				{
+					// Show Sparks
+					gEngfuncs.pEfxAPI->R_SparkEffect( pTemp->entity.origin, 8, -200, 200 );
+
+					// Reduce life
+					pTemp->entity.baseline.framerate -= 0.1;
+
+					if ( pTemp->entity.baseline.framerate <= 0.0 )
+					{
+						pTemp->die = client_time;
+					}
+					else
+					{
+						// So it will die no matter what
+						pTemp->die = client_time + 0.5;
+
+						// Next think
+						pTemp->entity.baseline.scale = client_time + 0.1;
+					}
+				}
+			}
+			else if ( pTemp->flags & FTENT_PLYRATTACHMENT )
+			{
+				cl_entity_t *pClient;
+
+				pClient = gEngfuncs.GetEntityByIndex( pTemp->clientIndex );
+
+				VectorAdd( pClient->origin, pTemp->tentOffset, pTemp->entity.origin );
+			}
+			else if ( pTemp->flags & FTENT_SINEWAVE )
+			{
+				pTemp->x += pTemp->entity.baseline.origin[0] * frametime;
+				pTemp->y += pTemp->entity.baseline.origin[1] * frametime;
+
+				pTemp->entity.origin[0] = pTemp->x + sin( pTemp->entity.baseline.origin[2] + client_time * pTemp->entity.prevstate.frame ) * (10*pTemp->entity.curstate.framerate);
+				pTemp->entity.origin[1] = pTemp->y + sin( pTemp->entity.baseline.origin[2] + fastFreq + 0.7 ) * (8*pTemp->entity.curstate.framerate);
+				pTemp->entity.origin[2] += pTemp->entity.baseline.origin[2] * frametime;
+			}
+			else if ( pTemp->flags & FTENT_SPIRAL )
+			{
+				float s, c;
+				s = sin( pTemp->entity.baseline.origin[2] + fastFreq );
+				c = cos( pTemp->entity.baseline.origin[2] + fastFreq );
+
+				pTemp->entity.origin[0] += pTemp->entity.baseline.origin[0] * frametime + 8 * sin( client_time * 20 + (int)pTemp );
+				pTemp->entity.origin[1] += pTemp->entity.baseline.origin[1] * frametime + 4 * sin( client_time * 30 + (int)pTemp );
+				pTemp->entity.origin[2] += pTemp->entity.baseline.origin[2] * frametime;
+			}
+			else 
+			{
+				for ( i = 0; i < 3; i++ ) 
+					pTemp->entity.origin[i] += pTemp->entity.baseline.origin[i] * frametime;
+			}
+			
+			if ( pTemp->flags & FTENT_SPRANIMATE )
+			{
+				pTemp->entity.curstate.frame += frametime * pTemp->entity.curstate.framerate;
+				if ( pTemp->entity.curstate.frame >= pTemp->frameMax )
+				{
+					pTemp->entity.curstate.frame = pTemp->entity.curstate.frame - (int)(pTemp->entity.curstate.frame);
+
+					if ( !(pTemp->flags & FTENT_SPRANIMATELOOP) )
+					{
+						// this animating sprite isn't set to loop, so destroy it.
+						pTemp->die = client_time;
+						pTemp = pnext;
+						continue;
+					}
+				}
+			}
+			else if ( pTemp->flags & FTENT_SPRCYCLE )
+			{
+				pTemp->entity.curstate.frame += frametime * 10;
+				if ( pTemp->entity.curstate.frame >= pTemp->frameMax )
+				{
+					pTemp->entity.curstate.frame = pTemp->entity.curstate.frame - (int)(pTemp->entity.curstate.frame);
+				}
+			}
+// Experiment
+#if 0
+			if ( pTemp->flags & FTENT_SCALE )
+				pTemp->entity.curstate.framerate += 20.0 * (frametime / pTemp->entity.curstate.framerate);
+#endif
+
+			if ( pTemp->flags & FTENT_ROTATE )
+			{
+				pTemp->entity.angles[0] += pTemp->entity.baseline.angles[0] * frametime;
+				pTemp->entity.angles[1] += pTemp->entity.baseline.angles[1] * frametime;
+				pTemp->entity.angles[2] += pTemp->entity.baseline.angles[2] * frametime;
+
+				VectorCopy( pTemp->entity.angles, pTemp->entity.latched.prevangles );
+			}
+
+			if ( pTemp->flags & (FTENT_COLLIDEALL | FTENT_COLLIDEWORLD) )
+			{
+				vec3_t	traceNormal;
+				float	traceFraction = 1;
+
+				if ( pTemp->flags & FTENT_COLLIDEALL )
+				{
+					pmtrace_t pmtrace;
+					physent_t *pe;
+				
+					gEngfuncs.pEventAPI->EV_SetTraceHull( 2 );
+
+					gEngfuncs.pEventAPI->EV_PlayerTrace( pTemp->entity.prevstate.origin, pTemp->entity.origin, PM_STUDIO_BOX, -1, &pmtrace );
+
+
+					if ( pmtrace.fraction != 1 )
+					{
+						pe = gEngfuncs.pEventAPI->EV_GetPhysent( pmtrace.ent );
+
+						if ( !pmtrace.ent || ( pe->info != pTemp->clientIndex ) )
+						{
+							traceFraction = pmtrace.fraction;
+							VectorCopy( pmtrace.plane.normal, traceNormal );
+
+							if ( pTemp->hitcallback )
+							{
+								(*pTemp->hitcallback)( pTemp, &pmtrace );
+							}
+						}
+					}
+				}
+				else if ( pTemp->flags & FTENT_COLLIDEWORLD )
+				{
+					pmtrace_t pmtrace;
+					
+					gEngfuncs.pEventAPI->EV_SetTraceHull( 2 );
+
+					gEngfuncs.pEventAPI->EV_PlayerTrace( pTemp->entity.prevstate.origin, pTemp->entity.origin, PM_STUDIO_BOX | PM_WORLD_ONLY, -1, &pmtrace );					
+
+					if ( pmtrace.fraction != 1 )
+					{
+						traceFraction = pmtrace.fraction;
+						VectorCopy( pmtrace.plane.normal, traceNormal );
+
+						if ( pTemp->flags & FTENT_SPARKSHOWER )
+						{
+							// Chop spark speeds a bit more
+							//
+							VectorScale( pTemp->entity.baseline.origin, 0.6, pTemp->entity.baseline.origin );
+
+							if ( Length( pTemp->entity.baseline.origin ) < 10 )
+							{
+								pTemp->entity.baseline.framerate = 0.0;								
+							}
+						}
+
+						if ( pTemp->hitcallback )
+						{
+							(*pTemp->hitcallback)( pTemp, &pmtrace );
+						}
+					}
+				}
+				
+				if ( traceFraction != 1 )	// Decent collision now, and damping works
+				{
+					float  proj, damp;
+
+					// Place at contact point
+					VectorMA( pTemp->entity.prevstate.origin, traceFraction*frametime, pTemp->entity.baseline.origin, pTemp->entity.origin );
+					// Damp velocity
+					damp = pTemp->bounceFactor;
+					if ( pTemp->flags & (FTENT_GRAVITY|FTENT_SLOWGRAVITY) )
+					{
+						damp *= 0.5;
+						if ( traceNormal[2] > 0.9 )		// Hit floor?
+						{
+							if ( pTemp->entity.baseline.origin[2] <= 0 && pTemp->entity.baseline.origin[2] >= gravity*3 )
+							{
+								damp = 0;		// Stop
+								pTemp->flags &= ~(FTENT_ROTATE|FTENT_GRAVITY|FTENT_SLOWGRAVITY|FTENT_COLLIDEWORLD|FTENT_SMOKETRAIL);
+								pTemp->entity.angles[0] = 0;
+								pTemp->entity.angles[2] = 0;
+							}
+						}
+					}
+
+					if (pTemp->hitSound)
+					{
+						Callback_TempEntPlaySound(pTemp, damp);
+					}
+
+					if (pTemp->flags & FTENT_COLLIDEKILL)
+					{
+						// die on impact
+						pTemp->flags &= ~FTENT_FADEOUT;	
+						pTemp->die = client_time;			
+					}
+					else
+					{
+						// Reflect velocity
+						if ( damp != 0 )
+						{
+							proj = DotProduct( pTemp->entity.baseline.origin, traceNormal );
+							VectorMA( pTemp->entity.baseline.origin, -proj*2, traceNormal, pTemp->entity.baseline.origin );
+							// Reflect rotation (fake)
+
+							pTemp->entity.angles[1] = -pTemp->entity.angles[1];
+						}
+						
+						if ( damp != 1 )
+						{
+
+							VectorScale( pTemp->entity.baseline.origin, damp, pTemp->entity.baseline.origin );
+							VectorScale( pTemp->entity.angles, 0.9, pTemp->entity.angles );
+						}
+					}
+				}
+			}
+
+
+			if ( (pTemp->flags & FTENT_FLICKER) && gTempEntFrame == pTemp->entity.curstate.effects )
+			{
+				dlight_t *dl = gEngfuncs.pEfxAPI->CL_AllocDlight (0);
+				VectorCopy (pTemp->entity.origin, dl->origin);
+				dl->radius = 60;
+				dl->color.r = 255;
+				dl->color.g = 120;
+				dl->color.b = 0;
+				dl->die = client_time + 0.01;
+			}
+
+			if ( pTemp->flags & FTENT_SMOKETRAIL )
+			{
+				gEngfuncs.pEfxAPI->R_RocketTrail (pTemp->entity.prevstate.origin, pTemp->entity.origin, 1);
+			}
+
+			if ( pTemp->flags & FTENT_GRAVITY )
+				pTemp->entity.baseline.origin[2] += gravity;
+			else if ( pTemp->flags & FTENT_SLOWGRAVITY )
+				pTemp->entity.baseline.origin[2] += gravitySlow;
+
+			if ( pTemp->flags & FTENT_CLIENTCUSTOM )
+			{
+				if ( pTemp->callback )
+				{
+					( *pTemp->callback )( pTemp, frametime, client_time );
+				}
+			}
+
+			// Cull to PVS (not frustum cull, just PVS)
+			if ( !(pTemp->flags & FTENT_NOMODEL ) )
+			{
+				if ( !Callback_AddVisibleEntity( &pTemp->entity ) )
+				{
+					if ( !(pTemp->flags & FTENT_PERSIST) ) 
+					{
+						pTemp->die = client_time;			// If we can't draw it this frame, just dump it.
+						pTemp->flags &= ~FTENT_FADEOUT;	// Don't fade out, just die
+					}
+				}
+			}
+		}
+		pTemp = pnext;
+	}
+
+finish:
+	// Restore state info
+	gEngfuncs.pEventAPI->EV_PopPMStates();
+}
+
+/*
+=================
+HUD_GetUserEntity
+
+If you specify negative numbers for beam start and end point entities, then
+  the engine will call back into this function requesting a pointer to a cl_entity_t 
+  object that describes the entity to attach the beam onto.
+
+Indices must start at 1, not zero.
+=================
+*/
+cl_entity_t DLLEXPORT *HUD_GetUserEntity( int index )
+{
+return NULL;
+}

hlsdk/ricochet/cl_dll/ev_common.cpp

@@ -0,0 +1,198 @@
+/***
+*
+*	Copyright (c) 1999, Valve LLC. All rights reserved.
+*	
+*	This product contains software technology licensed from Id 
+*	Software, Inc. ("Id Technology").  Id Technology (c) 1996 Id Software, Inc. 
+*	All Rights Reserved.
+*
+*   Use, distribution, and modification of this source code and/or resulting
+*   object code is restricted to non-commercial enhancements to products from
+*   Valve LLC.  All other use, distribution, or modification is prohibited
+*   without written permission from Valve LLC.
+*
+****/
+// shared event functions
+#include "hud.h"
+#include "cl_util.h"
+#include "const.h"
+#include "entity_state.h"
+#include "cl_entity.h"
+
+#include "r_efx.h"
+
+#include "eventscripts.h"
+#include "event_api.h"
+
+/*
+=================
+GetEntity
+
+Return's the requested cl_entity_t
+=================
+*/
+struct cl_entity_s *GetEntity( int idx )
+{
+	return gEngfuncs.GetEntityByIndex( idx );
+}
+
+/*
+=================
+GetViewEntity
+
+Return's the current weapon/view model
+=================
+*/
+struct cl_entity_s *GetViewEntity( void )
+{
+	return gEngfuncs.GetViewModel();
+}
+
+/*
+=================
+EV_CreateTracer
+
+Creates a tracer effect
+=================
+*/
+void EV_CreateTracer( float *start, float *end )
+{
+	gEngfuncs.pEfxAPI->R_TracerEffect( start, end );
+}
+
+/*
+=================
+EV_IsPlayer
+
+Is the entity's index in the player range?
+=================
+*/
+qboolean EV_IsPlayer( int idx )
+{
+	if ( idx >= 1 && idx <= gEngfuncs.GetMaxClients() )
+		return true;
+
+	return false;
+}
+
+/*
+=================
+EV_IsLocal
+
+Is the entity == the local player
+=================
+*/
+qboolean EV_IsLocal( int idx )
+{
+	return gEngfuncs.pEventAPI->EV_IsLocal( idx - 1 ) ? true : false;
+}
+
+/*
+=================
+EV_GetGunPosition
+
+Figure out the height of the gun
+=================
+*/
+void EV_GetGunPosition( event_args_t *args, float *pos, float *origin )
+{
+	int idx;
+	vec3_t view_ofs;
+
+	idx = args->entindex;
+
+	VectorClear( view_ofs );
+	view_ofs[2] = DEFAULT_VIEWHEIGHT;
+
+	if ( EV_IsPlayer( idx ) )
+	{
+		if ( EV_IsLocal( idx ) )
+		{
+			// Grab predicted result for local player
+			gEngfuncs.pEventAPI->EV_LocalPlayerViewheight( view_ofs );
+		}
+		else if ( args->ducking == 1 )
+		{
+			view_ofs[2] = VEC_DUCK_VIEW;
+		}
+	}
+
+	VectorAdd( origin, view_ofs, pos );
+}
+
+/*
+=================
+EV_EjectBrass
+
+Bullet shell casings
+=================
+*/
+void EV_EjectBrass( float *origin, float *velocity, float rotation, int model, int soundtype )
+{
+	vec3_t endpos;
+	VectorClear( endpos );
+	endpos[1] = rotation;
+	gEngfuncs.pEfxAPI->R_TempModel( origin, velocity, endpos, 2.5, model, soundtype );
+}
+
+/*
+=================
+EV_GetDefaultShellInfo
+
+Determine where to eject shells from
+=================
+*/
+void EV_GetDefaultShellInfo( event_args_t *args, float *origin, float *velocity, float *ShellVelocity, float *ShellOrigin, float *forward, float *right, float *up, float forwardScale, float upScale, float rightScale )
+{
+	int i;
+	vec3_t view_ofs;
+	float fR, fU;
+
+	int idx;
+
+	idx = args->entindex;
+
+	VectorClear( view_ofs );
+	view_ofs[2] = DEFAULT_VIEWHEIGHT;
+
+	if ( EV_IsPlayer( idx ) )
+	{
+		if ( EV_IsLocal( idx ) )
+		{
+			gEngfuncs.pEventAPI->EV_LocalPlayerViewheight( view_ofs );
+		}
+		else if ( args->ducking == 1 )
+		{
+			view_ofs[2] = VEC_DUCK_VIEW;
+		}
+	}
+
+	fR = gEngfuncs.pfnRandomFloat( 50, 70 );
+	fU = gEngfuncs.pfnRandomFloat( 100, 150 );
+
+	for ( i = 0; i < 3; i++ )
+	{
+		ShellVelocity[i] = velocity[i] + right[i] * fR + up[i] * fU + forward[i] * 25;
+		ShellOrigin[i]   = origin[i] + view_ofs[i] + up[i] * upScale + forward[i] * forwardScale + right[i] * rightScale;
+	}
+}
+
+/*
+=================
+EV_MuzzleFlash
+
+Flag weapon/view model for muzzle flash
+=================
+*/
+void EV_MuzzleFlash( void )
+{
+	// Add muzzle flash to current weapon model
+	cl_entity_t *ent = GetViewEntity();
+	if ( !ent )
+	{
+		return;
+	}
+
+	// Or in the muzzle flash
+	ent->curstate.effects |= EF_MUZZLEFLASH;
+}

hlsdk/ricochet/cl_dll/ev_hldm.cpp

@@ -0,0 +1,150 @@
+/***
+*
+*	Copyright (c) 1999, Valve LLC. All rights reserved.
+*	
+*	This product contains software technology licensed from Id 
+*	Software, Inc. ("Id Technology").  Id Technology (c) 1996 Id Software, Inc. 
+*	All Rights Reserved.
+*
+*   Use, distribution, and modification of this source code and/or resulting
+*   object code is restricted to non-commercial enhancements to products from
+*   Valve LLC.  All other use, distribution, or modification is prohibited
+*   without written permission from Valve LLC.
+*
+****/
+#include "hud.h"
+#include "cl_util.h"
+#include "const.h"
+#include "entity_state.h"
+#include "cl_entity.h"
+#include "entity_types.h"
+#include "usercmd.h"
+#include "pm_defs.h"
+#include "pm_materials.h"
+
+#include "eventscripts.h"
+#include "ev_hldm.h"
+
+#include "r_efx.h"
+#include "event_api.h"
+#include "event_args.h"
+#include "in_defs.h"
+
+#include <string.h>
+
+extern "C"
+{
+// RICOCHET
+void EV_FireDisc( struct event_args_s *args );
+void EV_TriggerJump( struct event_args_s *args );
+void EV_TrainPitchAdjust( struct event_args_s *args );
+}
+
+/*
+==============================
+EV_TriggerJump
+
+Plays the jump pad sound
+==============================
+*/
+void EV_TriggerJump( event_args_t *args )
+{
+	int idx;
+	idx = args->entindex;
+	vec3_t origin;
+
+	VectorCopy( args->origin, origin );
+
+	gEngfuncs.pEventAPI->EV_PlaySound( idx, origin, CHAN_AUTO, "triggerjump.wav", 1.0, ATTN_NORM, 0, 98 + gEngfuncs.pfnRandomLong( 0, 3 ) );
+}
+
+/*
+==============================
+EV_FireDisc
+
+Play's disc firing animation and play's appropriate sound effect
+==============================
+*/
+void EV_FireDisc( event_args_t *args )
+{
+	int idx;
+
+	idx = args->entindex;
+	vec3_t origin;
+	int decap;
+
+	VectorCopy( args->origin, origin );
+	decap = args->bparam1 ? 1 : 0;
+
+	if ( EV_IsLocal( idx ) )
+	{
+		// Add muzzle flash to current weapon model
+		gEngfuncs.pEventAPI->EV_WeaponAnimation( DISC_THROW1, 2 );
+	}
+
+	if ( decap )
+	{
+		gEngfuncs.pEventAPI->EV_PlaySound( idx, origin, CHAN_WEAPON, "weapons/altfire.wav", 0.8, ATTN_NORM, 0, 100 );
+	}
+	else
+	{
+		gEngfuncs.pEventAPI->EV_PlaySound( idx, origin, CHAN_WEAPON, "weapons/cbar_miss1.wav", 0.8, ATTN_NORM, 0, 100 );
+	}
+}
+
+#define SND_CHANGE_PITCH	(1<<7)
+
+/*
+==============================
+EV_TrainPitchAdjust
+
+Do we support trains in Ricochet?
+==============================
+*/
+void EV_TrainPitchAdjust( event_args_t *args )
+{
+	int idx;
+	vec3_t origin;
+
+	unsigned short us_params;
+	int noise;
+	float m_flVolume;
+	int pitch;
+	int stop;
+	
+	char sz[ 256 ];
+
+	idx = args->entindex;
+	
+	VectorCopy( args->origin, origin );
+
+	us_params = (unsigned short)args->iparam1;
+	stop	  = args->bparam1;
+
+	m_flVolume	= (float)(us_params & 0x003f)/40.0;
+	noise		= (int)(((us_params) >> 12 ) & 0x0007);
+	pitch		= (int)( 10.0 * (float)( ( us_params >> 6 ) & 0x003f ) );
+
+	switch ( noise )
+	{
+	case 1: strcpy( sz, "plats/ttrain1.wav"); break;
+	case 2: strcpy( sz, "plats/ttrain2.wav"); break;
+	case 3: strcpy( sz, "plats/ttrain3.wav"); break; 
+	case 4: strcpy( sz, "plats/ttrain4.wav"); break;
+	case 5: strcpy( sz, "plats/ttrain6.wav"); break;
+	case 6: strcpy( sz, "plats/ttrain7.wav"); break;
+	default:
+		// no sound
+		strcpy( sz, "" );
+		return;
+	}
+
+	if ( stop )
+	{
+		gEngfuncs.pEventAPI->EV_StopSound( idx, CHAN_STATIC, sz );
+	}
+	else
+	{
+		gEngfuncs.pEventAPI->EV_PlaySound( idx, origin, CHAN_STATIC, sz, m_flVolume, ATTN_NORM, SND_CHANGE_PITCH, pitch );
+	}
+}

hlsdk/ricochet/cl_dll/ev_hldm.h

@@ -0,0 +1,16 @@
+#if !defined ( EV_HLDMH )
+#define EV_HLDMH
+
+enum disc_e 
+{
+	DISC_IDLE = 0,
+	DISC_FIDGET,
+	DISC_PINPULL,
+	DISC_THROW1,	// toss
+	DISC_THROW2,	// medium
+	DISC_THROW3,	// hard
+	DISC_HOLSTER,
+	DISC_DRAW
+};
+
+#endif // EV_HLDMH

hlsdk/ricochet/cl_dll/events.cpp

@@ -0,0 +1,30 @@
+/***
+*
+*	Copyright (c) 1999, 2000 Valve LLC. All rights reserved.
+*	
+*	This product contains software technology licensed from Id 
+*	Software, Inc. ("Id Technology").  Id Technology (c) 1996 Id Software, Inc. 
+*	All Rights Reserved.
+*
+*   Use, distribution, and modification of this source code and/or resulting
+*   object code is restricted to non-commercial enhancements to products from
+*   Valve LLC.  All other use, distribution, or modification is prohibited
+*   without written permission from Valve LLC.
+*
+****/
+#include "hud.h"
+#include "cl_util.h"
+
+void Game_HookEvents( void );
+
+/*
+===================
+EV_HookEvents
+
+See if game specific code wants to hook any events.
+===================
+*/
+void EV_HookEvents( void )
+{
+	Game_HookEvents();
+}

hlsdk/ricochet/cl_dll/eventscripts.h

@@ -0,0 +1,80 @@
+/***
+*
+*	Copyright (c) 1999, 2000 Valve LLC. All rights reserved.
+*	
+*	This product contains software technology licensed from Id 
+*	Software, Inc. ("Id Technology").  Id Technology (c) 1996 Id Software, Inc. 
+*	All Rights Reserved.
+*
+*   Use, distribution, and modification of this source code and/or resulting
+*   object code is restricted to non-commercial enhancements to products from
+*   Valve LLC.  All other use, distribution, or modification is prohibited
+*   without written permission from Valve LLC.
+*
+****/
+// eventscripts.h
+#if !defined ( EVENTSCRIPTSH )
+#define EVENTSCRIPTSH
+
+// defaults for clientinfo messages
+#define	DEFAULT_VIEWHEIGHT	28
+#define VEC_DUCK_VIEW 12
+
+#define FTENT_FADEOUT			0x00000080
+
+#define DMG_GENERIC			0			// generic damage was done
+#define DMG_CRUSH			(1 << 0)	// crushed by falling or moving object
+#define DMG_BULLET			(1 << 1)	// shot
+#define DMG_SLASH			(1 << 2)	// cut, clawed, stabbed
+#define DMG_BURN			(1 << 3)	// heat burned
+#define DMG_FREEZE			(1 << 4)	// frozen
+#define DMG_FALL			(1 << 5)	// fell too far
+#define DMG_BLAST			(1 << 6)	// explosive blast damage
+#define DMG_CLUB			(1 << 7)	// crowbar, punch, headbutt
+#define DMG_SHOCK			(1 << 8)	// electric shock
+#define DMG_SONIC			(1 << 9)	// sound pulse shockwave
+#define DMG_ENERGYBEAM		(1 << 10)	// laser or other high energy beam 
+#define DMG_NEVERGIB		(1 << 12)	// with this bit OR'd in, no damage type will be able to gib victims upon death
+#define DMG_ALWAYSGIB		(1 << 13)	// with this bit OR'd in, any damage type can be made to gib victims upon death.
+
+// time-based damage
+//mask off TF-specific stuff too
+#define DMG_TIMEBASED		(~(0xff003fff))	// mask for time-based damage
+
+#define DMG_DROWN			(1 << 14)	// Drowning
+#define DMG_FIRSTTIMEBASED  DMG_DROWN
+
+#define DMG_PARALYZE		(1 << 15)	// slows affected creature down
+#define DMG_NERVEGAS		(1 << 16)	// nerve toxins, very bad
+#define DMG_POISON			(1 << 17)	// blood poisioning
+#define DMG_RADIATION		(1 << 18)	// radiation exposure
+#define DMG_DROWNRECOVER	(1 << 19)	// drowning recovery
+#define DMG_ACID			(1 << 20)	// toxic chemicals or acid burns
+#define DMG_SLOWBURN		(1 << 21)	// in an oven
+#define DMG_SLOWFREEZE		(1 << 22)	// in a subzero freezer
+#define DMG_MORTAR			(1 << 23)	// Hit by air raid (done to distinguish grenade from mortar)
+
+//TF ADDITIONS
+#define DMG_IGNITE			(1 << 24)	// Players hit by this begin to burn
+#define DMG_RADIUS_MAX		(1 << 25)	// Radius damage with this flag doesn't decrease over distance
+#define DMG_RADIUS_QUAKE	(1 << 26)	// Radius damage is done like Quake. 1/2 damage at 1/2 radius.
+#define DMG_IGNOREARMOR		(1 << 27)	// Damage ignores target's armor
+#define DMG_AIMED			(1 << 28)   // Does Hit location damage
+#define DMG_WALLPIERCING	(1 << 29)	// Blast Damages ents through walls
+
+#define DMG_CALTROP				(1<<30)
+#define DMG_HALLUC				(1<<31)
+
+// Some of these are HL/TFC specific?
+void EV_EjectBrass( float *origin, float *velocity, float rotation, int model, int soundtype );
+void EV_GetGunPosition( struct event_args_s *args, float *pos, float *origin );
+void EV_GetDefaultShellInfo( struct event_args_s *args, float *origin, float *velocity, float *ShellVelocity, float *ShellOrigin, float *forward, float *right, float *up, float forwardScale, float upScale, float rightScale );
+qboolean EV_IsLocal( int idx );
+qboolean EV_IsPlayer( int idx );
+void EV_CreateTracer( float *start, float *end );
+
+struct cl_entity_s *GetEntity( int idx );
+struct cl_entity_s *GetViewEntity( void );
+void EV_MuzzleFlash( void );
+
+#endif // EVENTSCRIPTSH

hlsdk/ricochet/cl_dll/flashlight.cpp

@@ -0,0 +1,100 @@
+/***
+*
+*	Copyright (c) 1999, 2000 Valve LLC. All rights reserved.
+*	
+*	This product contains software technology licensed from Id 
+*	Software, Inc. ("Id Technology").  Id Technology (c) 1996 Id Software, Inc. 
+*	All Rights Reserved.
+*
+*   Use, distribution, and modification of this source code and/or resulting
+*   object code is restricted to non-commercial enhancements to products from
+*   Valve LLC.  All other use, distribution, or modification is prohibited
+*   without written permission from Valve LLC.
+*
+****/
+//
+// flashlight.cpp
+//
+// implementation of CHudFlashlight class
+//
+
+#include "hud.h"
+#include "cl_util.h"
+#include "parsemsg.h"
+
+#include <string.h>
+#include <stdio.h>
+
+
+
+DECLARE_MESSAGE(m_Flash, FlashBat)
+DECLARE_MESSAGE(m_Flash, Flashlight)
+
+#define BAT_NAME "sprites/%d_Flashlight.spr"
+
+int CHudFlashlight::Init(void)
+{
+	m_fFade = 0;
+	m_fOn = 0;
+
+	HOOK_MESSAGE(Flashlight);
+	HOOK_MESSAGE(FlashBat);
+
+	m_iFlags |= HUD_ACTIVE;
+
+	gHUD.AddHudElem(this);
+
+	return 1;
+};
+
+void CHudFlashlight::Reset(void)
+{
+	m_fFade = 0;
+	m_fOn = 0;
+}
+
+int CHudFlashlight::VidInit(void)
+{
+	int HUD_flash_empty = gHUD.GetSpriteIndex( "flash_empty" );
+	int HUD_flash_full = gHUD.GetSpriteIndex( "flash_full" );
+	int HUD_flash_beam = gHUD.GetSpriteIndex( "flash_beam" );
+
+	m_hSprite1 = gHUD.GetSprite(HUD_flash_empty);
+	m_hSprite2 = gHUD.GetSprite(HUD_flash_full);
+	m_hBeam = gHUD.GetSprite(HUD_flash_beam);
+	m_prc1 = &gHUD.GetSpriteRect(HUD_flash_empty);
+	m_prc2 = &gHUD.GetSpriteRect(HUD_flash_full);
+	m_prcBeam = &gHUD.GetSpriteRect(HUD_flash_beam);
+	m_iWidth = m_prc2->right - m_prc2->left;
+
+	return 1;
+};
+
+int CHudFlashlight:: MsgFunc_FlashBat(const char *pszName,  int iSize, void *pbuf )
+{
+
+	
+	BEGIN_READ( pbuf, iSize );
+	int x = READ_BYTE();
+	m_iBat = x;
+	m_flBat = ((float)x)/100.0;
+
+	return 1;
+}
+
+int CHudFlashlight:: MsgFunc_Flashlight(const char *pszName,  int iSize, void *pbuf )
+{
+
+	BEGIN_READ( pbuf, iSize );
+	m_fOn = READ_BYTE();
+	int x = READ_BYTE();
+	m_iBat = x;
+	m_flBat = ((float)x)/100.0;
+
+	return 1;
+}
+
+int CHudFlashlight::Draw(float flTime)
+{
+	return 1;
+}

hlsdk/ricochet/cl_dll/geiger.cpp

@@ -0,0 +1,184 @@
+/***
+*
+*	Copyright (c) 1999, 2000 Valve LLC. All rights reserved.
+*	
+*	This product contains software technology licensed from Id 
+*	Software, Inc. ("Id Technology").  Id Technology (c) 1996 Id Software, Inc. 
+*	All Rights Reserved.
+*
+*   Use, distribution, and modification of this source code and/or resulting
+*   object code is restricted to non-commercial enhancements to products from
+*   Valve LLC.  All other use, distribution, or modification is prohibited
+*   without written permission from Valve LLC.
+*
+****/
+//
+// Geiger.cpp
+//
+// implementation of CHudAmmo class
+//
+
+#include "hud.h"
+#include "cl_util.h"
+#include <string.h>
+#include <time.h>
+#include <stdio.h>
+
+#include "parsemsg.h"
+
+DECLARE_MESSAGE(m_Geiger, Geiger )
+
+int CHudGeiger::Init(void)
+{
+	HOOK_MESSAGE( Geiger );
+
+	m_iGeigerRange = 0;
+	m_iFlags = 0;
+
+	gHUD.AddHudElem(this);
+
+	srand( (unsigned)time( NULL ) );
+
+	return 1;
+};
+
+int CHudGeiger::VidInit(void)
+{
+	return 1;
+};
+
+int CHudGeiger::MsgFunc_Geiger(const char *pszName,  int iSize, void *pbuf)
+{
+
+	BEGIN_READ( pbuf, iSize );
+
+	// update geiger data
+	m_iGeigerRange = READ_BYTE();
+	m_iGeigerRange = m_iGeigerRange << 2;
+	
+	m_iFlags |= HUD_ACTIVE;
+
+	return 1;
+}
+
+int CHudGeiger::Draw (float flTime)
+{
+	int pct;
+	float flvol;
+	int rg[3];
+	int i;
+	
+	if (m_iGeigerRange < 1000 && m_iGeigerRange > 0)
+	{
+		// peicewise linear is better than continuous formula for this
+		if (m_iGeigerRange > 800)
+		{
+			pct = 0;			//Con_Printf ( "range > 800\n");
+		}
+		else if (m_iGeigerRange > 600)
+		{
+			pct = 2;
+			flvol = 0.4;		//Con_Printf ( "range > 600\n");
+			rg[0] = 1;
+			rg[1] = 1;
+			i = 2;
+		}
+		else if (m_iGeigerRange > 500)
+		{
+			pct = 4;
+			flvol = 0.5;		//Con_Printf ( "range > 500\n");
+			rg[0] = 1;
+			rg[1] = 2;
+			i = 2;
+		}
+		else if (m_iGeigerRange > 400)
+		{
+			pct = 8;
+			flvol = 0.6;		//Con_Printf ( "range > 400\n");
+			rg[0] = 1;
+			rg[1] = 2;
+			rg[2] = 3;
+			i = 3;
+		}
+		else if (m_iGeigerRange > 300)
+		{
+			pct = 8;
+			flvol = 0.7;		//Con_Printf ( "range > 300\n");
+			rg[0] = 2;
+			rg[1] = 3;
+			rg[2] = 4;
+			i = 3;
+		}
+		else if (m_iGeigerRange > 200)
+		{
+			pct = 28;
+			flvol = 0.78;		//Con_Printf ( "range > 200\n");
+			rg[0] = 2;
+			rg[1] = 3;
+			rg[2] = 4;
+			i = 3;
+		}
+		else if (m_iGeigerRange > 150)
+		{
+			pct = 40;
+			flvol = 0.80;		//Con_Printf ( "range > 150\n");
+			rg[0] = 3;
+			rg[1] = 4;
+			rg[2] = 5;
+			i = 3;
+		}
+		else if (m_iGeigerRange > 100)
+		{
+			pct = 60;
+			flvol = 0.85;		//Con_Printf ( "range > 100\n");
+			rg[0] = 3;
+			rg[1] = 4;
+			rg[2] = 5;
+			i = 3;
+		}
+		else if (m_iGeigerRange > 75)
+		{
+			pct = 80;
+			flvol = 0.9;		//Con_Printf ( "range > 75\n");
+			//gflGeigerDelay = cl.time + GEIGERDELAY * 0.75;
+			rg[0] = 4;
+			rg[1] = 5;
+			rg[2] = 6;
+			i = 3;
+		}
+		else if (m_iGeigerRange > 50)
+		{
+			pct = 90;
+			flvol = 0.95;		//Con_Printf ( "range > 50\n");
+			rg[0] = 5;
+			rg[1] = 6;
+			i = 2;
+		}
+		else
+		{
+			pct = 95;
+			flvol = 1.0;		//Con_Printf ( "range < 50\n");
+			rg[0] = 5;
+			rg[1] = 6;
+			i = 2;
+		}
+
+		flvol = (flvol * ((rand() & 127)) / 255) + 0.25; // UTIL_RandomFloat(0.25, 0.5);
+
+		if ((rand() & 127) < pct || (rand() & 127) < pct)
+		{
+			//S_StartDynamicSound (-1, 0, rgsfx[rand() % i], r_origin, flvol, 1.0, 0, 100);	
+			char sz[256];
+			
+			int j = rand() & 1;
+			if (i > 2)
+				j += rand() & 1;
+
+			sprintf(sz, "player/geiger%d.wav", j + 1);
+			PlaySound(sz, flvol);
+			
+		}
+	}
+
+	return 1;
+}

hlsdk/ricochet/cl_dll/health.cpp

@@ -0,0 +1,425 @@
+/***
+*
+*	Copyright (c) 1999, Valve LLC. All rights reserved.
+*	
+*	This product contains software technology licensed from Id 
+*	Software, Inc. ("Id Technology").  Id Technology (c) 1996 Id Software, Inc. 
+*	All Rights Reserved.
+*
+*   Use, distribution, and modification of this source code and/or resulting
+*   object code is restricted to non-commercial enhancements to products from
+*   Valve LLC.  All other use, distribution, or modification is prohibited
+*   without written permission from Valve LLC.
+*
+****/
+//
+// Health.cpp
+//
+// implementation of CHudHealth class
+//
+
+#include "STDIO.H"
+#include "STDLIB.H"
+#include "MATH.H"
+
+#include "hud.h"
+#include "cl_util.h"
+#include "parsemsg.h"
+#include "vgui_TeamFortressViewport.h"
+#include <string.h>
+
+
+DECLARE_MESSAGE(m_Health, Health )
+DECLARE_MESSAGE(m_Health, Damage )
+
+#define PAIN_NAME "sprites/%d_pain.spr"
+#define DAMAGE_NAME "sprites/%d_dmg.spr"
+
+int giDmgHeight, giDmgWidth;
+
+int giDmgFlags[NUM_DMG_TYPES] = 
+{
+	DMG_POISON,
+	DMG_ACID,
+	DMG_FREEZE|DMG_SLOWFREEZE,
+	DMG_DROWN,
+	DMG_BURN|DMG_SLOWBURN,
+	DMG_NERVEGAS, 
+	DMG_RADIATION,
+	DMG_SHOCK,
+	DMG_CALTROP,
+	DMG_TRANQ,
+	DMG_CONCUSS,
+	DMG_HALLUC
+};
+
+int CHudHealth::Init(void)
+{
+	HOOK_MESSAGE(Health);
+	HOOK_MESSAGE(Damage);
+	m_iHealth = 100;
+	m_fFade = 0;
+	m_iFlags = 0;
+	m_bitsDamage = 0;
+	m_fAttackFront = m_fAttackRear = m_fAttackRight = m_fAttackLeft = 0;
+	giDmgHeight = 0;
+	giDmgWidth = 0;
+
+	memset(m_dmg, 0, sizeof(DAMAGE_IMAGE) * NUM_DMG_TYPES);
+
+
+	gHUD.AddHudElem(this);
+	return 1;
+}
+
+void CHudHealth::Reset( void )
+{
+	// make sure the pain compass is cleared when the player respawns
+	m_fAttackFront = m_fAttackRear = m_fAttackRight = m_fAttackLeft = 0;
+
+
+	// force all the flashing damage icons to expire
+	m_bitsDamage = 0;
+	for ( int i = 0; i < NUM_DMG_TYPES; i++ )
+	{
+		m_dmg[i].fExpire = 0;
+	}
+}
+
+int CHudHealth::VidInit(void)
+{
+	m_hSprite = 0;
+
+	m_HUD_dmg_bio = gHUD.GetSpriteIndex( "dmg_bio" ) + 1;
+	m_HUD_cross = gHUD.GetSpriteIndex( "cross" );
+
+	giDmgHeight = gHUD.GetSpriteRect(m_HUD_dmg_bio).right - gHUD.GetSpriteRect(m_HUD_dmg_bio).left;
+	giDmgWidth = gHUD.GetSpriteRect(m_HUD_dmg_bio).bottom - gHUD.GetSpriteRect(m_HUD_dmg_bio).top;
+	return 1;
+}
+
+int CHudHealth:: MsgFunc_Health(const char *pszName,  int iSize, void *pbuf )
+{
+	// TODO: update local health data
+	BEGIN_READ( pbuf, iSize );
+	int x = READ_BYTE();
+
+	m_iFlags |= HUD_ACTIVE;
+
+	// Only update the fade if we've changed health
+	if (x != m_iHealth)
+	{
+		m_fFade = FADE_TIME;
+		m_iHealth = x;
+	}
+
+	return 1;
+}
+
+
+int CHudHealth:: MsgFunc_Damage(const char *pszName,  int iSize, void *pbuf )
+{
+	BEGIN_READ( pbuf, iSize );
+
+	int armor = READ_BYTE();	// armor
+	int damageTaken = READ_BYTE();	// health
+	long bitsDamage = READ_LONG(); // damage bits
+
+	vec3_t vecFrom;
+
+	for ( int i = 0 ; i < 3 ; i++)
+		vecFrom[i] = READ_COORD();
+
+	UpdateTiles(gHUD.m_flTime, bitsDamage);
+
+	// Actually took damage?
+	if ( damageTaken > 0 || armor > 0 )
+		CalcDamageDirection(vecFrom);
+
+	return 1;
+}
+
+
+// Returns back a color from the
+// Green <-> Yellow <-> Red ramp
+void CHudHealth::GetPainColor( int &r, int &g, int &b )
+{
+	int iHealth = m_iHealth;
+
+	if (iHealth > 25)
+		iHealth -= 25;
+	else if ( iHealth < 0 )
+		iHealth = 0;
+#if 0
+	g = iHealth * 255 / 100;
+	r = 255 - g;
+	b = 0;
+#else
+	if (m_iHealth > 25)
+	{
+		UnpackRGB(r,g,b, RGB_YELLOWISH);
+	}
+	else
+	{
+		r = 250;
+		g = 0;
+		b = 0;
+	}
+#endif 
+}
+
+int CHudHealth::Draw(float flTime)
+{
+	// No Health in Discwar
+	if ( gHUD.m_iHideHUDDisplay & HIDEHUD_HEALTH )
+		return 1;
+
+	if ( !m_hSprite )
+		m_hSprite = LoadSprite(PAIN_NAME);
+
+	return DrawDamage(flTime);
+}
+
+void CHudHealth::CalcDamageDirection(vec3_t vecFrom)
+{
+	vec3_t	forward, right, up;
+	float	side, front;
+	vec3_t vecOrigin, vecAngles;
+
+	if (!vecFrom[0] && !vecFrom[1] && !vecFrom[2])
+	{
+		m_fAttackFront = m_fAttackRear = m_fAttackRight = m_fAttackLeft = 0;
+		return;
+	}
+
+
+	memcpy(vecOrigin, gHUD.m_vecOrigin, sizeof(vec3_t));
+	memcpy(vecAngles, gHUD.m_vecAngles, sizeof(vec3_t));
+
+
+	VectorSubtract (vecFrom, vecOrigin, vecFrom);
+
+	float flDistToTarget = vecFrom.Length();
+
+	vecFrom = vecFrom.Normalize();
+	AngleVectors (vecAngles, forward, right, up);
+
+	front = DotProduct (vecFrom, right);
+	side = DotProduct (vecFrom, forward);
+
+	if (flDistToTarget <= 50)
+	{
+		m_fAttackFront = m_fAttackRear = m_fAttackRight = m_fAttackLeft = 1;
+	}
+	else 
+	{
+		if (side > 0)
+		{
+			if (side > 0.3)
+				m_fAttackFront = max(m_fAttackFront, side);
+		}
+		else
+		{
+			float f = fabs(side);
+			if (f > 0.3)
+				m_fAttackRear = max(m_fAttackRear, f);
+		}
+
+		if (front > 0)
+		{
+			if (front > 0.3)
+				m_fAttackRight = max(m_fAttackRight, front);
+		}
+		else
+		{
+			float f = fabs(front);
+			if (f > 0.3)
+				m_fAttackLeft = max(m_fAttackLeft, f);
+		}
+	}
+}
+
+int CHudHealth::DrawPain(float flTime)
+{
+	if (!(m_fAttackFront || m_fAttackRear || m_fAttackLeft || m_fAttackRight))
+		return 1;
+
+	int r, g, b;
+	int x, y, a, shade;
+
+	// TODO:  get the shift value of the health
+	a = 255;	// max brightness until then
+
+	float fFade = gHUD.m_flTimeDelta * 2;
+	
+	// SPR_Draw top
+	if (m_fAttackFront > 0.4)
+	{
+		GetPainColor(r,g,b);
+		shade = a * max( m_fAttackFront, 0.5 );
+		ScaleColors(r, g, b, shade);
+		SPR_Set(m_hSprite, r, g, b );
+
+		x = ScreenWidth/2 - SPR_Width(m_hSprite, 0)/2;
+		y = ScreenHeight/2 - SPR_Height(m_hSprite,0) * 3;
+		SPR_DrawAdditive(0, x, y, NULL);
+		m_fAttackFront = max( 0, m_fAttackFront - fFade );
+	} else
+		m_fAttackFront = 0;
+
+	if (m_fAttackRight > 0.4)
+	{
+		GetPainColor(r,g,b);
+		shade = a * max( m_fAttackRight, 0.5 );
+		ScaleColors(r, g, b, shade);
+		SPR_Set(m_hSprite, r, g, b );
+
+		x = ScreenWidth/2 + SPR_Width(m_hSprite, 1) * 2;
+		y = ScreenHeight/2 - SPR_Height(m_hSprite,1)/2;
+		SPR_DrawAdditive(1, x, y, NULL);
+		m_fAttackRight = max( 0, m_fAttackRight - fFade );
+	} else
+		m_fAttackRight = 0;
+
+	if (m_fAttackRear > 0.4)
+	{
+		GetPainColor(r,g,b);
+		shade = a * max( m_fAttackRear, 0.5 );
+		ScaleColors(r, g, b, shade);
+		SPR_Set(m_hSprite, r, g, b );
+
+		x = ScreenWidth/2 - SPR_Width(m_hSprite, 2)/2;
+		y = ScreenHeight/2 + SPR_Height(m_hSprite,2) * 2;
+		SPR_DrawAdditive(2, x, y, NULL);
+		m_fAttackRear = max( 0, m_fAttackRear - fFade );
+	} else
+		m_fAttackRear = 0;
+
+	if (m_fAttackLeft > 0.4)
+	{
+		GetPainColor(r,g,b);
+		shade = a * max( m_fAttackLeft, 0.5 );
+		ScaleColors(r, g, b, shade);
+		SPR_Set(m_hSprite, r, g, b );
+
+		x = ScreenWidth/2 - SPR_Width(m_hSprite, 3) * 3;
+		y = ScreenHeight/2 - SPR_Height(m_hSprite,3)/2;
+		SPR_DrawAdditive(3, x, y, NULL);
+
+		m_fAttackLeft = max( 0, m_fAttackLeft - fFade );
+	} else
+		m_fAttackLeft = 0;
+
+	return 1;
+}
+
+int CHudHealth::DrawDamage(float flTime)
+{
+	int r, g, b, a;
+	DAMAGE_IMAGE *pdmg;
+
+	if (!m_bitsDamage)
+		return 1;
+
+	UnpackRGB(r,g,b, RGB_YELLOWISH);
+	
+	a = (int)( fabs(sin(flTime*2)) * 256.0);
+
+	ScaleColors(r, g, b, a);
+
+	// Draw all the items
+	for (int i = 0; i < NUM_DMG_TYPES; i++)
+	{
+		if (m_bitsDamage & giDmgFlags[i])
+		{
+			pdmg = &m_dmg[i];
+			SPR_Set(gHUD.GetSprite(m_HUD_dmg_bio + i), r, g, b );
+
+			// Discwar: Hack. Freeze is the only icon we use. Just place it directly above the disc ammo
+			int iX = (ScreenWidth - DISC_ICON_WIDTH) / 2;
+			int iXPos = iX - DISC_ICON_SPACER; 
+			SPR_DrawAdditive(0, iXPos + (DISC_ICON_SPACER), ScreenHeight - YRES(92), &gHUD.GetSpriteRect(m_HUD_dmg_bio + i));
+		}
+	}
+
+/*
+	// check for bits that should be expired
+	for ( i = 0; i < NUM_DMG_TYPES; i++ )
+	{
+		DAMAGE_IMAGE *pdmg = &m_dmg[i];
+
+		if ( m_bitsDamage & giDmgFlags[i] )
+		{
+			pdmg->fExpire = min( flTime + DMG_IMAGE_LIFE, pdmg->fExpire );
+
+			if ( pdmg->fExpire <= flTime		// when the time has expired
+				&& a < 40 )						// and the flash is at the low point of the cycle
+			{
+				pdmg->fExpire = 0;
+
+				int y = pdmg->y;
+				pdmg->x = pdmg->y = 0;
+
+				// move everyone above down
+				for (int j = 0; j < NUM_DMG_TYPES; j++)
+				{
+					pdmg = &m_dmg[j];
+					if ((pdmg->y) && (pdmg->y < y))
+						pdmg->y += giDmgHeight;
+
+				}
+
+				m_bitsDamage &= ~giDmgFlags[i];  // clear the bits
+			}
+		}
+	}
+*/
+	return 1;
+}
+ 
+
+void CHudHealth::UpdateTiles(float flTime, long bitsDamage)
+{	
+	DAMAGE_IMAGE *pdmg;
+
+	// Which types are new?
+	long bitsOn = ~m_bitsDamage & bitsDamage;
+	
+	for (int i = 0; i < NUM_DMG_TYPES; i++)
+	{
+		pdmg = &m_dmg[i];
+
+		// Is this one already on?
+		if (m_bitsDamage & giDmgFlags[i])
+		{
+			pdmg->fExpire = flTime + DMG_IMAGE_LIFE; // extend the duration
+			if (!pdmg->fBaseline)
+				pdmg->fBaseline = flTime;
+		}
+
+		// Are we just turning it on?
+		if (bitsOn & giDmgFlags[i])
+		{
+			// put this one at the bottom
+			pdmg->x = giDmgWidth/8;
+			pdmg->y = ScreenHeight - giDmgHeight * 2;
+			pdmg->fExpire=flTime + DMG_IMAGE_LIFE;
+			
+			// move everyone else up
+			for (int j = 0; j < NUM_DMG_TYPES; j++)
+			{
+				if (j == i)
+					continue;
+
+				pdmg = &m_dmg[j];
+				if (pdmg->y)
+					pdmg->y -= giDmgHeight;
+
+			}
+			pdmg = &m_dmg[i];
+		}	
+	}	
+
+	// damage bits are only turned on here;  they are turned off when the draw time has expired (in DrawDamage())
+	m_bitsDamage |= bitsDamage;
+}

hlsdk/ricochet/cl_dll/health.h

@@ -0,0 +1,128 @@
+/***
+*
+*	Copyright (c) 1999, 2000 Valve LLC. All rights reserved.
+*	
+*	This product contains software technology licensed from Id 
+*	Software, Inc. ("Id Technology").  Id Technology (c) 1996 Id Software, Inc. 
+*	All Rights Reserved.
+*
+*   Use, distribution, and modification of this source code and/or resulting
+*   object code is restricted to non-commercial enhancements to products from
+*   Valve LLC.  All other use, distribution, or modification is prohibited
+*   without written permission from Valve LLC.
+*
+****/
+
+#define DMG_IMAGE_LIFE		2	// seconds that image is up
+
+#define DMG_IMAGE_POISON	0
+#define DMG_IMAGE_ACID		1
+#define DMG_IMAGE_COLD		2
+#define DMG_IMAGE_DROWN		3
+#define DMG_IMAGE_BURN		4
+#define DMG_IMAGE_NERVE		5
+#define DMG_IMAGE_RAD		6
+#define DMG_IMAGE_SHOCK		7
+//tf defines
+#define DMG_IMAGE_CALTROP	8
+#define DMG_IMAGE_TRANQ		9
+#define DMG_IMAGE_CONCUSS	10
+#define DMG_IMAGE_HALLUC	11
+#define NUM_DMG_TYPES		12
+// instant damage
+
+#define DMG_GENERIC			0			// generic damage was done
+#define DMG_CRUSH			(1 << 0)	// crushed by falling or moving object
+#define DMG_BULLET			(1 << 1)	// shot
+#define DMG_SLASH			(1 << 2)	// cut, clawed, stabbed
+#define DMG_BURN			(1 << 3)	// heat burned
+#define DMG_FREEZE			(1 << 4)	// frozen
+#define DMG_FALL			(1 << 5)	// fell too far
+#define DMG_BLAST			(1 << 6)	// explosive blast damage
+#define DMG_CLUB			(1 << 7)	// crowbar, punch, headbutt
+#define DMG_SHOCK			(1 << 8)	// electric shock
+#define DMG_SONIC			(1 << 9)	// sound pulse shockwave
+#define DMG_ENERGYBEAM		(1 << 10)	// laser or other high energy beam 
+#define DMG_NEVERGIB		(1 << 12)	// with this bit OR'd in, no damage type will be able to gib victims upon death
+#define DMG_ALWAYSGIB		(1 << 13)	// with this bit OR'd in, any damage type can be made to gib victims upon death.
+
+
+// time-based damage
+//mask off TF-specific stuff too
+#define DMG_TIMEBASED		(~(0xff003fff))	// mask for time-based damage
+
+
+#define DMG_DROWN			(1 << 14)	// Drowning
+#define DMG_FIRSTTIMEBASED  DMG_DROWN
+
+#define DMG_PARALYZE		(1 << 15)	// slows affected creature down
+#define DMG_NERVEGAS		(1 << 16)	// nerve toxins, very bad
+#define DMG_POISON			(1 << 17)	// blood poisioning
+#define DMG_RADIATION		(1 << 18)	// radiation exposure
+#define DMG_DROWNRECOVER	(1 << 19)	// drowning recovery
+#define DMG_ACID			(1 << 20)	// toxic chemicals or acid burns
+#define DMG_SLOWBURN		(1 << 21)	// in an oven
+#define DMG_SLOWFREEZE		(1 << 22)	// in a subzero freezer
+#define DMG_MORTAR			(1 << 23)	// Hit by air raid (done to distinguish grenade from mortar)
+
+//TF ADDITIONS
+#define DMG_IGNITE			(1 << 24)	// Players hit by this begin to burn
+#define DMG_RADIUS_MAX		(1 << 25)	// Radius damage with this flag doesn't decrease over distance
+#define DMG_RADIUS_QUAKE	(1 << 26)	// Radius damage is done like Quake. 1/2 damage at 1/2 radius.
+#define DMG_IGNOREARMOR		(1 << 27)	// Damage ignores target's armor
+#define DMG_AIMED			(1 << 28)   // Does Hit location damage
+#define DMG_WALLPIERCING	(1 << 29)	// Blast Damages ents through walls
+
+#define DMG_CALTROP				(1<<30)
+#define DMG_HALLUC				(1<<31)
+
+// TF Healing Additions for TakeHealth
+#define DMG_IGNORE_MAXHEALTH	DMG_IGNITE
+// TF Redefines since we never use the originals
+#define DMG_NAIL				DMG_SLASH
+#define DMG_NOT_SELF			DMG_FREEZE
+
+
+#define DMG_TRANQ				DMG_MORTAR
+#define DMG_CONCUSS				DMG_SONIC
+
+
+
+typedef struct
+{
+	float fExpire;
+	float fBaseline;
+	int	x, y;
+} DAMAGE_IMAGE;
+	
+//
+//-----------------------------------------------------
+//
+class CHudHealth: public CHudBase
+{
+public:
+	virtual int Init( void );
+	virtual int VidInit( void );
+	virtual int Draw(float fTime);
+	virtual void Reset( void );
+	int MsgFunc_Health(const char *pszName,  int iSize, void *pbuf);
+	int MsgFunc_Damage(const char *pszName,  int iSize, void *pbuf);
+	int m_iHealth;
+	int m_HUD_dmg_bio;
+	int m_HUD_cross;
+	float m_fAttackFront, m_fAttackRear, m_fAttackLeft, m_fAttackRight;
+	void GetPainColor( int &r, int &g, int &b );
+	float m_fFade;
+
+	int	m_bitsDamage;
+
+private:
+	HSPRITE m_hSprite;
+	HSPRITE m_hDamage;
+	
+	DAMAGE_IMAGE m_dmg[NUM_DMG_TYPES];
+	int DrawPain(float fTime);
+	int DrawDamage(float fTime);
+	void CalcDamageDirection(vec3_t vecFrom);
+	void UpdateTiles(float fTime, long bits);
+};	

hlsdk/ricochet/cl_dll/hl/hl_baseentity.cpp

@@ -0,0 +1,248 @@
+/***
+*
+*	Copyright (c) 1999, Valve LLC. All rights reserved.
+*	
+*	This product contains software technology licensed from Id 
+*	Software, Inc. ("Id Technology").  Id Technology (c) 1996 Id Software, Inc. 
+*	All Rights Reserved.
+*
+*   Use, distribution, and modification of this source code and/or resulting
+*   object code is restricted to non-commercial enhancements to products from
+*   Valve LLC.  All other use, distribution, or modification is prohibited
+*   without written permission from Valve LLC.
+*
+****/
+
+/*
+==========================
+This file contains "stubs" of class member implementations so that we can predict certain
+ weapons client side.  From time to time you might find that you need to implement part of the
+ these functions.  If so, cut it from here, paste it in hl_weapons.cpp or somewhere else and
+ add in the functionality you need.
+==========================
+*/
+#include	"extdll.h"
+#include	"util.h"
+#include	"cbase.h"
+#include	"player.h"
+#include	"weapons.h"
+#include	"nodes.h"
+
+// Globals used by game logic
+const Vector g_vecZero = Vector( 0, 0, 0 );
+int gmsgWeapPickup = 0;
+enginefuncs_t g_engfuncs;
+globalvars_t  *gpGlobals;
+
+ItemInfo CBasePlayerItem::ItemInfoArray[MAX_WEAPONS];
+
+void EMIT_SOUND_DYN(edict_t *entity, int channel, const char *sample, float volume, float attenuation, int flags, int pitch) { }
+
+// CBaseEntity Stubs
+int CBaseEntity :: TakeHealth( float flHealth, int bitsDamageType ) { return 1; }
+int CBaseEntity :: TakeDamage( entvars_t* pevInflictor, entvars_t* pevAttacker, float flDamage, int bitsDamageType ) { return 1; }
+CBaseEntity *CBaseEntity::GetNextTarget( void ) { return NULL; }
+int CBaseEntity::Save( CSave &save ) { return 1; }
+int CBaseEntity::Restore( CRestore &restore ) { return 1; }
+void CBaseEntity::SetObjectCollisionBox( void ) { }
+int	CBaseEntity :: Intersects( CBaseEntity *pOther ) { return 0; }
+void CBaseEntity :: MakeDormant( void ) { }
+int CBaseEntity :: IsDormant( void ) { return 0; }
+BOOL CBaseEntity :: IsInWorld( void ) { return TRUE; }
+int CBaseEntity::ShouldToggle( USE_TYPE useType, BOOL currentState ) { return 0; }
+int	CBaseEntity :: DamageDecal( int bitsDamageType ) { return -1; }
+CBaseEntity * CBaseEntity::Create( char *szName, const Vector &vecOrigin, const Vector &vecAngles, edict_t *pentOwner ) { return NULL; }
+void CBaseEntity::SUB_Remove( void ) { }
+
+// CBaseDelay Stubs
+void CBaseDelay :: KeyValue( struct KeyValueData_s * ) { }
+int CBaseDelay::Restore( class CRestore & ) { return 1; }
+int CBaseDelay::Save( class CSave & ) { return 1; }
+
+// CBaseAnimating Stubs
+int CBaseAnimating::Restore( class CRestore & ) { return 1; }
+int CBaseAnimating::Save( class CSave & ) { return 1; }
+
+// DEBUG Stubs
+edict_t *DBG_EntOfVars( const entvars_t *pev ) { return NULL; }
+void DBG_AssertFunction(BOOL fExpr,	const char*	szExpr,	const char*	szFile,	int szLine,	const char*	szMessage) { }
+
+// UTIL_* Stubs
+void UTIL_PrecacheOther( const char *szClassname ) { }
+void UTIL_BloodDrips( const Vector &origin, const Vector &direction, int color, int amount ) { }
+void UTIL_DecalTrace( TraceResult *pTrace, int decalNumber ) { }
+void UTIL_GunshotDecalTrace( TraceResult *pTrace, int decalNumber ) { }
+BOOL UTIL_IsValidEntity( edict_t *pent ) { return TRUE; }
+void UTIL_SetOrigin( entvars_t *, const Vector &org ) { }
+BOOL UTIL_GetNextBestWeapon( CBasePlayer *pPlayer, CBasePlayerItem *pCurrentWeapon ) { return TRUE; }
+void UTIL_LogPrintf(char *,...) { }
+void UTIL_ClientPrintAll( int,char const *,char const *,char const *,char const *,char const *) { }
+void ClientPrint( entvars_t *client, int msg_dest, const char *msg_name, const char *param1, const char *param2, const char *param3, const char *param4 ) { }
+
+// CBaseToggle Stubs
+int CBaseToggle::Restore( class CRestore & ) { return 1; }
+int CBaseToggle::Save( class CSave & ) { return 1; }
+void CBaseToggle :: KeyValue( struct KeyValueData_s * ) { }
+
+// CGrenade Stubs
+void CGrenade::BounceSound( void ) { }
+void CGrenade::Explode( Vector, Vector ) { }
+void CGrenade::Explode( TraceResult *, int ) { }
+void CGrenade::Killed( entvars_t *, int ) { }
+void CGrenade::Spawn( void ) { }
+
+CBaseEntity* CBaseMonster :: CheckTraceHullAttack( float flDist, int iDamage, int iDmgType ) { return NULL; }
+void CBaseMonster :: Look ( int iDistance ) { }
+float CBaseAnimating :: StudioFrameAdvance ( float flInterval ) { return 0.0; }
+int CBaseMonster::IRelationship ( CBaseEntity *pTarget ) { return 0; }
+CBaseEntity *CBaseMonster :: BestVisibleEnemy ( void ) { return NULL; }
+BOOL CBaseMonster :: FInViewCone ( CBaseEntity *pEntity ) { return FALSE; }
+BOOL CBaseMonster :: FInViewCone ( Vector *pOrigin ) { return FALSE; }
+BOOL CBaseEntity :: FVisible ( CBaseEntity *pEntity ) { return FALSE; }
+BOOL CBaseEntity :: FVisible ( const Vector &vecOrigin ) { return FALSE; }
+void CBaseMonster :: MakeIdealYaw( Vector vecTarget ) { }
+float CBaseMonster::ChangeYaw ( int yawSpeed ) { return 0; }
+int CBaseAnimating :: LookupActivity ( int activity ) { return 0; }
+int CBaseAnimating :: LookupActivityHeaviest ( int activity ) { return 0; }
+
+BOOL CBaseAnimating :: GetSequenceFlags( ) { return FALSE; }
+void CBaseAnimating :: DispatchAnimEvents ( float flInterval ) { }
+float CBaseAnimating :: SetBoneController ( int iController, float flValue ) { return 0.0; }
+void CBaseAnimating :: InitBoneControllers ( void ) { }
+float CBaseAnimating :: SetBlending ( int iBlender, float flValue ) { return 0; }
+void CBaseAnimating :: GetBonePosition ( int iBone, Vector &origin, Vector &angles ) { }
+void CBaseAnimating :: GetAttachment ( int iAttachment, Vector &origin, Vector &angles ) { }
+int CBaseAnimating :: FindTransition( int iEndingSequence, int iGoalSequence, int *piDir ) { return -1; }
+void CBaseAnimating :: GetAutomovement( Vector &origin, Vector &angles, float flInterval ) { }
+void CBaseAnimating :: SetBodygroup( int iGroup, int iValue ) { }
+int CBaseAnimating :: GetBodygroup( int iGroup ) { return 0; }
+void CBaseEntity::TraceAttack(entvars_t *pevAttacker, float flDamage, Vector vecDir, TraceResult *ptr, int bitsDamageType) { }
+void CBaseEntity::FireBullets(ULONG cShots, Vector vecSrc, Vector vecDirShooting, Vector vecSpread, float flDistance, int iBulletType, int iTracerFreq, int iDamage, entvars_t *pevAttacker ) { }
+void CBaseEntity :: TraceBleed( float flDamage, Vector vecDir, TraceResult *ptr, int bitsDamageType ) { }
+void CBaseMonster :: MakeDamageBloodDecal ( int cCount, float flNoise, TraceResult *ptr, const Vector &vecDir ) { }
+void CBaseMonster::ReportAIState( void ) { }
+void CBaseMonster :: KeyValue( KeyValueData *pkvd ) { }
+BOOL CBaseMonster :: FCheckAITrigger ( void ) { return FALSE; }
+void CBaseMonster::CorpseFallThink( void ) { }
+void CBaseMonster :: MonsterInitDead( void ) { }
+void CBaseMonster :: TraceAttack( entvars_t *pevAttacker, float flDamage, Vector vecDir, TraceResult *ptr, int bitsDamageType) { }
+BOOL CBaseMonster :: ShouldFadeOnDeath( void ) { return FALSE; }
+void CBaseMonster :: RadiusDamage(entvars_t* pevInflictor, entvars_t*	pevAttacker, float flDamage, int iClassIgnore, int bitsDamageType ) { }
+void CBaseMonster :: RadiusDamage( Vector vecSrc, entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int iClassIgnore, int bitsDamageType ) { }
+void CBaseMonster::FadeMonster( void ) { }
+void CBaseMonster :: GibMonster( void ) { }
+BOOL CBaseMonster :: HasHumanGibs( void ) { return FALSE; }
+BOOL CBaseMonster :: HasAlienGibs( void ) { return FALSE; }
+Activity CBaseMonster :: GetDeathActivity ( void ) { return (Activity)0; }
+void CBaseMonster::BecomeDead( void ) {}
+void CBaseMonster :: Killed( entvars_t *pevAttacker, int iGib ) {}
+int CBaseMonster :: TakeHealth (float flHealth, int bitsDamageType) { return 0; }
+int CBaseMonster :: TakeDamage( entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int bitsDamageType ) { return 0; }
+
+int TrainSpeed(int iSpeed, int iMax) { 	return 0; }
+void CBasePlayer :: DeathSound( void ) { }
+int CBasePlayer :: TakeHealth( float flHealth, int bitsDamageType ) { return 0; }
+void CBasePlayer :: TraceAttack( entvars_t *pevAttacker, float flDamage, Vector vecDir, TraceResult *ptr, int bitsDamageType) { }
+int CBasePlayer :: TakeDamage( entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int bitsDamageType ) { return 0; }
+void CBasePlayer::RemoveAllItems( BOOL removeSuit ) { }
+void CBasePlayer::WaterMove() { }
+BOOL CBasePlayer::IsOnLadder( void ) { return FALSE; }
+void CBasePlayer::PlayerDeathThink(void) { }
+void CBasePlayer::StartDeathCam( void ) { }
+void CBasePlayer::StartObserver( Vector vecPosition, Vector vecViewAngle ) { }
+void CBasePlayer::PlayerUse ( void ) { }
+void CBasePlayer::Jump() { }
+void CBasePlayer::Duck( ) { }
+int  CBasePlayer::Classify ( void ) { return 0; }
+void CBasePlayer :: PlayStepSound(int step, float fvol) { }	
+void CBasePlayer :: UpdateStepSound( void ) { }
+void CBasePlayer::PreThink(void) { }
+void CBasePlayer::CheckTimeBasedDamage()  { }
+void CBasePlayer :: UpdateGeigerCounter( void ) { }
+void CBasePlayer::CheckSuitUpdate() { }
+void CBasePlayer::SetSuitUpdate(char *name, int fgroup, int iNoRepeatTime) { }
+void CBasePlayer :: UpdatePlayerSound ( void ) { }
+void CBasePlayer :: Precache( void ) { }
+int CBasePlayer::Save( CSave &save ) { return 0; }
+void CBasePlayer::RenewItems(void) { }
+int CBasePlayer::Restore( CRestore &restore ) { return 0; }
+void CBasePlayer::SelectNextItem( int iItem ) { }
+BOOL CBasePlayer::HasWeapons( void ) { return FALSE; }
+void CBasePlayer::SelectPrevItem( int iItem ) { }
+CBaseEntity *FindEntityForward( CBaseEntity *pMe ) { return NULL; }
+BOOL CBasePlayer :: FlashlightIsOn( void ) { return FALSE; }
+void CBasePlayer :: FlashlightTurnOn( void ) { }
+void CBasePlayer :: FlashlightTurnOff( void ) { }
+void CBasePlayer :: ForceClientDllUpdate( void ) { }
+void CBasePlayer::ImpulseCommands( ) { }
+void CBasePlayer::CheatImpulseCommands( int iImpulse ) { }
+int CBasePlayer::AddPlayerItem( CBasePlayerItem *pItem ) { return FALSE; }
+int CBasePlayer::RemovePlayerItem( CBasePlayerItem *pItem ) { return FALSE; }
+void CBasePlayer::ItemPreFrame() { }
+void CBasePlayer::ItemPostFrame() { }
+int CBasePlayer::AmmoInventory( int iAmmoIndex ) { return -1; }
+int CBasePlayer::GetAmmoIndex(const char *psz) { return -1; }
+void CBasePlayer::SendAmmoUpdate(void) { }
+void CBasePlayer :: UpdateClientData( void ) { }
+BOOL CBasePlayer :: FBecomeProne ( void ) { return TRUE; }
+void CBasePlayer :: BarnacleVictimBitten ( entvars_t *pevBarnacle ) { }
+void CBasePlayer :: BarnacleVictimReleased ( void ) { }
+int CBasePlayer :: Illumination( void ) { return 0; }
+void CBasePlayer :: EnableControl(BOOL fControl) { }
+Vector CBasePlayer :: GetAutoaimVector( float flDelta ) { return g_vecZero; }
+Vector CBasePlayer :: AutoaimDeflection( Vector &vecSrc, float flDist, float flDelta  ) { return g_vecZero; }
+void CBasePlayer :: ResetAutoaim( ) { }
+void CBasePlayer :: SetCustomDecalFrames( int nFrames ) { }
+int CBasePlayer :: GetCustomDecalFrames( void ) { return -1; }
+void CBasePlayer::DropPlayerItem ( char *pszItemName ) { }
+BOOL CBasePlayer::HasPlayerItem( CBasePlayerItem *pCheckItem ) { return FALSE; }
+BOOL CBasePlayer :: SwitchWeapon( CBasePlayerItem *pWeapon )  { return FALSE; }
+Vector CBasePlayer :: GetGunPosition( void ) { return g_vecZero; }
+const char *CBasePlayer::TeamID( void ) { return ""; }
+int CBasePlayer :: GiveAmmo( int iCount, char *szName, int iMax ) { return 0; }
+void CBasePlayer::AddPoints( int score, BOOL bAllowNegativeScore ) { } 
+void CBasePlayer::AddPointsToTeam( int score, BOOL bAllowNegativeScore ) { } 
+void CBasePlayer::RemoveAllPowerups( void ) {}
+bool CBasePlayer::HasPowerup(int) { return 0; }
+
+void ClearMultiDamage(void) { }
+void ApplyMultiDamage(entvars_t *pevInflictor, entvars_t *pevAttacker ) { }
+void AddMultiDamage( entvars_t *pevInflictor, CBaseEntity *pEntity, float flDamage, int bitsDamageType) { }
+void SpawnBlood(Vector vecSpot, int bloodColor, float flDamage) { }
+int DamageDecal( CBaseEntity *pEntity, int bitsDamageType ) { return 0; }
+void DecalGunshot( TraceResult *pTrace, int iBulletType ) { }
+void EjectBrass ( const Vector &vecOrigin, const Vector &vecVelocity, float rotation, int model, int soundtype ) { }
+void AddAmmoNameToAmmoRegistry( const char *szAmmoname ) { }
+int CBasePlayerItem::Restore( class CRestore & ) { return 1; }
+int CBasePlayerItem::Save( class CSave & ) { return 1; }
+int CBasePlayerWeapon::Restore( class CRestore & ) { return 1; }
+int CBasePlayerWeapon::Save( class CSave & ) { return 1; }
+void CBasePlayerItem :: SetObjectCollisionBox( void ) { }
+void CBasePlayerItem :: FallInit( void ) { }
+void CBasePlayerItem::FallThink ( void ) { }
+void CBasePlayerItem::Materialize( void ) { }
+void CBasePlayerItem::AttemptToMaterialize( void ) { }
+void CBasePlayerItem :: CheckRespawn ( void ) { }
+CBaseEntity* CBasePlayerItem::Respawn( void ) { return NULL; }
+void CBasePlayerItem::DefaultTouch( CBaseEntity *pOther ) { }
+void CBasePlayerItem::DestroyItem( void ) { }
+int CBasePlayerItem::AddToPlayer( CBasePlayer *pPlayer ) { return TRUE; }
+void CBasePlayerItem::Drop( void ) { }
+void CBasePlayerItem::Kill( void ) { }
+void CBasePlayerItem::Holster( int skiplocal ) { }
+void CBasePlayerItem::AttachToPlayer ( CBasePlayer *pPlayer ) { }
+int CBasePlayerWeapon::AddDuplicate( CBasePlayerItem *pOriginal ) { return 0; }
+int CBasePlayerWeapon::AddToPlayer( CBasePlayer *pPlayer ) { return FALSE; }
+int CBasePlayerWeapon::UpdateClientData( CBasePlayer *pPlayer ) { return 0; }
+BOOL CBasePlayerWeapon :: AddPrimaryAmmo( int iCount, char *szName, int iMaxClip, int iMaxCarry ) { return TRUE; }
+BOOL CBasePlayerWeapon :: AddSecondaryAmmo( int iCount, char *szName, int iMax ) { return TRUE; }
+BOOL CBasePlayerWeapon :: IsUseable( void ) { return TRUE; }
+int CBasePlayerWeapon::PrimaryAmmoIndex( void ) { return -1; }
+int CBasePlayerWeapon::SecondaryAmmoIndex( void ) {	return -1; }
+void CBasePlayerAmmo::Spawn( void ) { }
+CBaseEntity* CBasePlayerAmmo::Respawn( void ) { return this; }
+void CBasePlayerAmmo::Materialize( void ) { }
+void CBasePlayerAmmo :: DefaultTouch( CBaseEntity *pOther ) { }
+int CBasePlayerWeapon::ExtractAmmo( CBasePlayerWeapon *pWeapon ) { return 0; }
+int CBasePlayerWeapon::ExtractClipAmmo( CBasePlayerWeapon *pWeapon ) { return 0; }	
+void CBasePlayerWeapon::RetireWeapon( void ) { }

hlsdk/ricochet/cl_dll/hl/hl_events.cpp

@@ -0,0 +1,45 @@
+/***
+*
+*	Copyright (c) 1999, Valve LLC. All rights reserved.
+*	
+*	This product contains software technology licensed from Id 
+*	Software, Inc. ("Id Technology").  Id Technology (c) 1996 Id Software, Inc. 
+*	All Rights Reserved.
+*
+*   Use, distribution, and modification of this source code and/or resulting
+*   object code is restricted to non-commercial enhancements to products from
+*   Valve LLC.  All other use, distribution, or modification is prohibited
+*   without written permission from Valve LLC.
+*
+****/
+#include "../hud.h"
+#include "../cl_util.h"
+#include "event_api.h"
+
+extern "C"
+{
+// RICOCHET
+void EV_TriggerJump( struct event_args_s *args );
+void EV_FireDisc( struct event_args_s *args );
+void EV_TrainPitchAdjust( struct event_args_s *args );
+}
+
+/*
+======================
+Game_HookEvents
+
+Associate script file name with callback functions.  Callback's must be extern "C" so
+ the engine doesn't get confused about name mangling stuff.  Note that the format is
+ always the same.  Of course, a clever mod team could actually embed parameters, behavior
+ into the actual .sc files and create a .sc file parser and hook their functionality through
+ that.. i.e., a scripting system.
+
+That was what we were going to do, but we ran out of time...oh well.
+======================
+*/
+void Game_HookEvents( void )
+{
+	gEngfuncs.pfnHookEvent( "events/train.sc",	EV_TrainPitchAdjust );
+	gEngfuncs.pfnHookEvent( "events/firedisc.sc",	EV_FireDisc );
+	gEngfuncs.pfnHookEvent( "events/jump.sc", EV_TriggerJump );
+}

hlsdk/ricochet/cl_dll/hl/hl_objects.cpp

@@ -0,0 +1,28 @@
+/***
+*
+*	Copyright (c) 1999, Valve LLC. All rights reserved.
+*	
+*	This product contains software technology licensed from Id 
+*	Software, Inc. ("Id Technology").  Id Technology (c) 1996 Id Software, Inc. 
+*	All Rights Reserved.
+*
+*   Use, distribution, and modification of this source code and/or resulting
+*   object code is restricted to non-commercial enhancements to products from
+*   Valve LLC.  All other use, distribution, or modification is prohibited
+*   without written permission from Valve LLC.
+*
+****/
+#include "../hud.h"
+#include "../cl_util.h"
+#include "../demo.h"
+
+/*
+=====================
+Game_AddObjects
+
+Add game specific, client-side objects here
+=====================
+*/
+void Game_AddObjects( void )
+{
+}

hlsdk/ricochet/cl_dll/hud.cpp

@@ -0,0 +1,589 @@
+/***
+*
+*	Copyright (c) 1999, 2000 Valve LLC. All rights reserved.
+*	
+*	This product contains software technology licensed from Id 
+*	Software, Inc. ("Id Technology").  Id Technology (c) 1996 Id Software, Inc. 
+*	All Rights Reserved.
+*
+*   Use, distribution, and modification of this source code and/or resulting
+*   object code is restricted to non-commercial enhancements to products from
+*   Valve LLC.  All other use, distribution, or modification is prohibited
+*   without written permission from Valve LLC.
+*
+****/
+//
+// hud.cpp
+//
+// implementation of CHud class
+//
+
+#include "hud.h"
+#include "cl_util.h"
+#include <string.h>
+#include <stdio.h>
+#include "parsemsg.h"
+#include "hud_servers.h"
+#include "vgui_TeamFortressViewport.h"
+
+#include "demo.h"
+#include "demo_api.h"
+
+#include "vgui_scorepanel.h"
+
+extern TeamFortressViewport *gViewPort;
+
+
+class CHLVoiceStatusHelper : public IVoiceStatusHelper
+{
+public:
+	virtual void GetPlayerTextColor(int entindex, int color[3])
+	{
+		color[0] = color[1] = color[2] = 255;
+
+	/*	if( entindex >= 0 && entindex < sizeof(g_PlayerExtraInfo)/sizeof(g_PlayerExtraInfo[0]) )
+		{
+			int iTeam = g_PlayerExtraInfo[entindex].teamnumber;
+
+			if ( iTeam < 0 )
+			{
+				iTeam = 0;
+			}
+
+			iTeam = iTeam % iNumberOfTeamColors;
+
+			color[0] = iTeamColors[iTeam][0];
+			color[1] = iTeamColors[iTeam][1];
+			color[2] = iTeamColors[iTeam][2];
+		}*/
+	}
+
+	virtual void UpdateCursorState()
+	{
+		gViewPort->UpdateCursorState();
+	}
+
+	virtual int	GetAckIconHeight()
+	{
+		return ScreenHeight - gHUD.m_iFontHeight*3 - 6;
+	}
+
+	virtual bool			CanShowSpeakerLabels()
+	{
+		if( gViewPort && gViewPort->m_pScoreBoard )
+			return !gViewPort->m_pScoreBoard->isVisible();
+		else
+			return false;
+	}
+};
+static CHLVoiceStatusHelper g_VoiceStatusHelper;
+
+extern client_sprite_t *GetSpriteList(client_sprite_t *pList, const char *psz, int iRes, int iCount);
+
+extern cvar_t *sensitivity;
+cvar_t *cl_lw = NULL;
+
+void ShutdownInput (void);
+
+void __CmdFunc_ToggleServerBrowser( void )
+{
+	if ( gViewPort )
+	{
+		gViewPort->ToggleServerBrowser();
+	}
+}
+
+//DECLARE_MESSAGE(m_Logo, Logo)
+int __MsgFunc_Logo(const char *pszName, int iSize, void *pbuf)
+{
+	return gHUD.MsgFunc_Logo(pszName, iSize, pbuf );
+}
+
+//DECLARE_MESSAGE(m_Logo, Logo)
+int __MsgFunc_ResetHUD(const char *pszName, int iSize, void *pbuf)
+{
+	return gHUD.MsgFunc_ResetHUD(pszName, iSize, pbuf );
+}
+
+int __MsgFunc_InitHUD(const char *pszName, int iSize, void *pbuf)
+{
+	gHUD.MsgFunc_InitHUD( pszName, iSize, pbuf );
+	return 1;
+}
+
+int __MsgFunc_SetFOV(const char *pszName, int iSize, void *pbuf)
+{
+	return gHUD.MsgFunc_SetFOV( pszName, iSize, pbuf );
+}
+
+int __MsgFunc_Concuss(const char *pszName, int iSize, void *pbuf)
+{
+	return gHUD.MsgFunc_Concuss( pszName, iSize, pbuf );
+}
+
+int __MsgFunc_GameMode(const char *pszName, int iSize, void *pbuf )
+{
+	return gHUD.MsgFunc_GameMode( pszName, iSize, pbuf );
+}
+
+void __CmdFunc_OpenCommandMenu(void)
+{
+	if ( gViewPort )
+	{
+		gViewPort->ShowCommandMenu();
+	}
+}
+
+void __CmdFunc_CloseCommandMenu(void)
+{
+	if ( gViewPort )
+	{
+		gViewPort->InputSignalHideCommandMenu();
+	}
+}
+
+int __MsgFunc_StartRnd(const char *pszName, int iSize, void *pbuf)
+{
+	if (gViewPort)
+		return gViewPort->MsgFunc_StartRnd( pszName, iSize, pbuf );
+	return 0;
+}
+
+int __MsgFunc_EndRnd(const char *pszName, int iSize, void *pbuf)
+{
+	if (gViewPort)
+		return gViewPort->MsgFunc_EndRnd( pszName, iSize, pbuf );
+	return 0;
+}
+
+int __MsgFunc_ScoreInfo(const char *pszName, int iSize, void *pbuf)
+{
+	if (gViewPort)
+		return gViewPort->MsgFunc_ScoreInfo( pszName, iSize, pbuf );
+	return 0;
+}
+
+int __MsgFunc_TeamScore(const char *pszName, int iSize, void *pbuf)
+{
+	if (gViewPort)
+		return gViewPort->MsgFunc_TeamScore( pszName, iSize, pbuf );
+	return 0;
+}
+
+int __MsgFunc_TeamInfo(const char *pszName, int iSize, void *pbuf)
+{
+	if (gViewPort)
+		return gViewPort->MsgFunc_TeamInfo( pszName, iSize, pbuf );
+	return 0;
+}
+
+int __MsgFunc_Powerup(const char *pszName, int iSize, void *pbuf)
+{
+	if (gViewPort)
+		return gViewPort->MsgFunc_Powerup( pszName, iSize, pbuf );
+	return 0;
+}
+
+int __MsgFunc_Reward(const char *pszName, int iSize, void *pbuf)
+{
+	if (gViewPort)
+		return gViewPort->MsgFunc_Reward( pszName, iSize, pbuf );
+	return 0;
+}
+
+int __MsgFunc_Frozen(const char *pszName, int iSize, void *pbuf)
+{
+	if (gViewPort)
+		return gViewPort->MsgFunc_Frozen( pszName, iSize, pbuf );
+	return 0;
+}
+
+// This is called every time the DLL is loaded
+void CHud :: Init( void )
+{
+	HOOK_MESSAGE( Logo );
+	HOOK_MESSAGE( ResetHUD );
+	HOOK_MESSAGE( GameMode );
+	HOOK_MESSAGE( InitHUD );
+	HOOK_MESSAGE( SetFOV );
+	HOOK_MESSAGE( Concuss );
+
+	HOOK_MESSAGE( ScoreInfo );
+	HOOK_MESSAGE( TeamScore );
+	HOOK_MESSAGE( TeamInfo );
+
+	// Discwar
+	HOOK_MESSAGE( StartRnd );
+	HOOK_MESSAGE( EndRnd );
+	HOOK_MESSAGE( Powerup );
+	HOOK_MESSAGE( Reward );
+	HOOK_MESSAGE( Frozen );
+
+	HOOK_COMMAND( "+commandmenu", OpenCommandMenu );
+	HOOK_COMMAND( "-commandmenu", CloseCommandMenu );
+
+	m_iLogo = 0;
+	m_iFOV = 0;
+
+	CVAR_CREATE( "zoom_sensitivity_ratio", "1.2", 0 );
+	default_fov = CVAR_CREATE( "default_fov", "90", 0 );
+	m_pCvarStealMouse = CVAR_CREATE( "hud_capturemouse", "1", FCVAR_ARCHIVE );
+	cl_lw = gEngfuncs.pfnGetCvarPointer( "cl_lw" );
+
+	m_pSpriteList = NULL;
+
+	// Clear any old HUD list
+	if ( m_pHudList )
+	{
+		HUDLIST *pList;
+		while ( m_pHudList )
+		{
+			pList = m_pHudList;
+			m_pHudList = m_pHudList->pNext;
+			free( pList );
+		}
+		m_pHudList = NULL;
+	}
+
+	// In case we get messages before the first update -- time will be valid
+	m_flTime = 1.0;
+
+	m_Ammo.Init();
+	m_Health.Init();
+	m_Geiger.Init();
+	m_Train.Init();
+	m_Battery.Init();
+	m_Flash.Init();
+	m_Message.Init();
+	m_StatusBar.Init();
+	m_DeathNotice.Init();
+	m_AmmoSecondary.Init();
+	m_TextMessage.Init();
+	m_StatusIcons.Init();
+
+	m_SayText.Init();
+	m_Menu.Init();
+
+	GetClientVoiceMgr()->Init(&g_VoiceStatusHelper, (vgui::Panel**)&gViewPort);
+
+	ServersInit();
+
+	MsgFunc_ResetHUD(0, 0, NULL );
+}
+
+// CHud destructor
+// cleans up memory allocated for m_rg* arrays
+CHud :: ~CHud()
+{
+	delete [] m_rghSprites;
+	delete [] m_rgrcRects;
+	delete [] m_rgszSpriteNames;
+
+	if ( m_pHudList )
+	{
+		HUDLIST *pList;
+		while ( m_pHudList )
+		{
+			pList = m_pHudList;
+			m_pHudList = m_pHudList->pNext;
+			free( pList );
+		}
+		m_pHudList = NULL;
+	}
+
+	ServersShutdown();
+}
+
+// GetSpriteIndex()
+// searches through the sprite list loaded from hud.txt for a name matching SpriteName
+// returns an index into the gHUD.m_rghSprites[] array
+// returns 0 if sprite not found
+int CHud :: GetSpriteIndex( const char *SpriteName )
+{
+	// look through the loaded sprite name list for SpriteName
+	for ( int i = 0; i < m_iSpriteCount; i++ )
+	{
+		if ( strncmp( SpriteName, m_rgszSpriteNames + (i * MAX_SPRITE_NAME_LENGTH), MAX_SPRITE_NAME_LENGTH ) == 0 )
+			return i;
+	}
+
+	return -1; // invalid sprite
+}
+
+void CHud :: VidInit( void )
+{
+	m_scrinfo.iSize = sizeof(m_scrinfo);
+	GetScreenInfo(&m_scrinfo);
+
+	// ----------
+	// Load Sprites
+	// ---------
+//	m_hsprFont = LoadSprite("sprites/%d_font.spr");
+	
+	m_hsprLogo = 0;	
+	m_hsprCursor = 0;
+
+	if (ScreenWidth < 640)
+		m_iRes = 320;
+	else
+		m_iRes = 640;
+
+	// Only load this once
+	if ( !m_pSpriteList )
+	{
+		// we need to load the hud.txt, and all sprites within
+		m_pSpriteList = SPR_GetList("sprites/hud.txt", &m_iSpriteCountAllRes);
+
+		if (m_pSpriteList)
+		{
+			// count the number of sprites of the appropriate res
+			m_iSpriteCount = 0;
+			client_sprite_t *p = m_pSpriteList;
+			for ( int j = 0; j < m_iSpriteCountAllRes; j++ )
+			{
+				if ( p->iRes == m_iRes )
+					m_iSpriteCount++;
+				p++;
+			}
+
+			// allocated memory for sprite handle arrays
+ 			m_rghSprites = new HSPRITE[m_iSpriteCount];
+			m_rgrcRects = new wrect_t[m_iSpriteCount];
+			m_rgszSpriteNames = new char[m_iSpriteCount * MAX_SPRITE_NAME_LENGTH];
+
+			p = m_pSpriteList;
+			int index = 0;
+			for ( int j = 0; j < m_iSpriteCountAllRes; j++ )
+			{
+				if ( p->iRes == m_iRes )
+				{
+					char sz[256];
+					sprintf(sz, "sprites/%s.spr", p->szSprite);
+					m_rghSprites[index] = SPR_Load(sz);
+					m_rgrcRects[index] = p->rc;
+					strncpy( &m_rgszSpriteNames[index * MAX_SPRITE_NAME_LENGTH], p->szName, MAX_SPRITE_NAME_LENGTH );
+
+					index++;
+				}
+
+				p++;
+			}
+		}
+	}
+	else
+	{
+		// we have already have loaded the sprite reference from hud.txt, but
+		// we need to make sure all the sprites have been loaded (we've gone through a transition, or loaded a save game)
+		client_sprite_t *p = m_pSpriteList;
+		int index = 0;
+		for ( int j = 0; j < m_iSpriteCountAllRes; j++ )
+		{
+			if ( p->iRes == m_iRes )
+			{
+				char sz[256];
+				sprintf( sz, "sprites/%s.spr", p->szSprite );
+				m_rghSprites[index] = SPR_Load(sz);
+				index++;
+			}
+
+			p++;
+		}
+	}
+
+	// assumption: number_1, number_2, etc, are all listed and loaded sequentially
+	m_HUD_number_0 = GetSpriteIndex( "number_0" );
+
+	m_iFontHeight = m_rgrcRects[m_HUD_number_0].bottom - m_rgrcRects[m_HUD_number_0].top;
+
+	m_Ammo.VidInit();
+	m_Health.VidInit();
+	m_Geiger.VidInit();
+	m_Train.VidInit();
+	m_Battery.VidInit();
+	m_Flash.VidInit();
+	m_Message.VidInit();
+	m_StatusBar.VidInit();
+	m_DeathNotice.VidInit();
+	m_SayText.VidInit();
+	m_Menu.VidInit();
+	m_AmmoSecondary.VidInit();
+	m_TextMessage.VidInit();
+	m_StatusIcons.VidInit();
+	
+	GetClientVoiceMgr()->VidInit();
+}
+
+int CHud::MsgFunc_Logo(const char *pszName,  int iSize, void *pbuf)
+{
+	BEGIN_READ( pbuf, iSize );
+
+	// update Train data
+	m_iLogo = READ_BYTE();
+
+	return 1;
+}
+
+float g_lastFOV = 0.0;
+
+/*
+============
+COM_FileBase
+============
+*/
+// Extracts the base name of a file (no path, no extension, assumes '/' as path separator)
+void COM_FileBase ( const char *in, char *out)
+{
+	int len, start, end;
+
+	len = strlen( in );
+	
+	// scan backward for '.'
+	end = len - 1;
+	while ( end && in[end] != '.' && in[end] != '/' && in[end] != '\\' )
+		end--;
+	
+	if ( in[end] != '.' )		// no '.', copy to end
+		end = len-1;
+	else 
+		end--;					// Found ',', copy to left of '.'
+
+
+	// Scan backward for '/'
+	start = len-1;
+	while ( start >= 0 && in[start] != '/' && in[start] != '\\' )
+		start--;
+
+	if ( in[start] != '/' && in[start] != '\\' )
+		start = 0;
+	else 
+		start++;
+
+	// Length of new sting
+	len = end - start + 1;
+
+	// Copy partial string
+	strncpy( out, &in[start], len );
+	// Terminate it
+	out[len] = 0;
+}
+
+/*
+=================
+HUD_IsGame
+
+=================
+*/
+int HUD_IsGame( const char *game )
+{
+	const char *gamedir;
+	char gd[ 1024 ];
+
+	gamedir = gEngfuncs.pfnGetGameDirectory();
+	if ( gamedir && gamedir[0] )
+	{
+		COM_FileBase( gamedir, gd );
+		if ( !stricmp( gd, game ) )
+			return 1;
+	}
+	return 0;
+}
+
+/*
+=====================
+HUD_GetFOV
+
+Returns last FOV
+=====================
+*/
+float HUD_GetFOV( void )
+{
+/*
+	if ( gEngfuncs.pDemoAPI->IsRecording() )
+	{
+		// Write it
+		int i = 0;
+		unsigned char buf[ 100 ];
+
+		// Active
+		*( float * )&buf[ i ] = g_lastFOV;
+		i += sizeof( float );
+
+		Demo_WriteBuffer( TYPE_ZOOM, i, buf );
+	}
+
+	if ( gEngfuncs.pDemoAPI->IsPlayingback() )
+	{
+		g_lastFOV = g_demozoom;
+	}
+*/
+	return g_lastFOV;
+}
+
+int CHud::MsgFunc_SetFOV(const char *pszName,  int iSize, void *pbuf)
+{
+	BEGIN_READ( pbuf, iSize );
+
+	int newfov = READ_BYTE();
+	int def_fov = CVAR_GET_FLOAT( "default_fov" );
+
+	if ( newfov == 0 )
+	{
+		m_iFOV = def_fov;
+	}
+	else
+	{
+		m_iFOV = newfov;
+	}
+
+	// the clients fov is actually set in the client data update section of the hud
+
+	// Set a new sensitivity
+	if ( m_iFOV == def_fov )
+	{  
+		// reset to saved sensitivity
+		m_flMouseSensitivity = 0;
+	}
+	else
+	{  
+		// set a new sensitivity that is proportional to the change from the FOV default
+		m_flMouseSensitivity = sensitivity->value * ((float)newfov / (float)def_fov) * CVAR_GET_FLOAT("zoom_sensitivity_ratio");
+	}
+
+	return 1;
+}
+
+
+void CHud::AddHudElem(CHudBase *phudelem)
+{
+	HUDLIST *pdl, *ptemp;
+
+//phudelem->Think();
+
+	if (!phudelem)
+		return;
+
+	pdl = (HUDLIST *)malloc(sizeof(HUDLIST));
+	if (!pdl)
+		return;
+
+	memset(pdl, 0, sizeof(HUDLIST));
+	pdl->p = phudelem;
+
+	if (!m_pHudList)
+	{
+		m_pHudList = pdl;
+		return;
+	}
+
+	ptemp = m_pHudList;
+
+	while (ptemp->pNext)
+		ptemp = ptemp->pNext;
+
+	ptemp->pNext = pdl;
+}
+
+float CHud::GetSensitivity( void )
+{
+	return m_flMouseSensitivity;
+}

hlsdk/ricochet/cl_dll/hud.h

@@ -0,0 +1,583 @@
+/***
+*
+*	Copyright (c) 1999, 2000 Valve LLC. All rights reserved.
+*	
+*	This product contains software technology licensed from Id 
+*	Software, Inc. ("Id Technology").  Id Technology (c) 1996 Id Software, Inc. 
+*	All Rights Reserved.
+*
+*   Use, distribution, and modification of this source code and/or resulting
+*   object code is restricted to non-commercial enhancements to products from
+*   Valve LLC.  All other use, distribution, or modification is prohibited
+*   without written permission from Valve LLC.
+*
+****/
+//			
+//  hud.h
+//
+// class CHud declaration
+//
+// CHud handles the message, calculation, and drawing the HUD
+//
+
+
+#define RGB_YELLOWISH 0x00FFA000 //255,160,0
+#define RGB_REDISH 0x00FF1010 //255,160,0
+#define RGB_GREENISH 0x0000A000 //0,160,0
+
+#include "wrect.h"
+#include "cl_dll.h"
+#include "ammo.h"
+
+#define DHN_DRAWZERO 1
+#define DHN_2DIGITS  2
+#define DHN_3DIGITS  4
+#define MIN_ALPHA	 100	
+
+#define		HUDELEM_ACTIVE	1
+
+typedef struct {
+	int x, y;
+} POSITION;
+
+typedef struct {
+	unsigned char r,g,b,a;
+} RGBA;
+
+
+#define HUD_ACTIVE	1
+#define HUD_INTERMISSION 2
+
+#define MAX_PLAYER_NAME_LENGTH		32
+#define	MAX_MOTD_LENGTH				1024
+
+//
+//-----------------------------------------------------
+//
+class CHudBase
+{
+public:
+	POSITION  m_pos;
+	int   m_type;
+	int	  m_iFlags; // active, moving, 
+	virtual int Init( void ) {return 0;}
+	virtual int VidInit( void ) {return 0;}
+	virtual int Draw(float flTime) {return 0;}
+	virtual void Think(void) {return;}
+	virtual void Reset(void) {return;}
+	virtual void InitHUDData( void ) {}		// called every time a server is connected to
+
+};
+
+struct HUDLIST {
+	CHudBase	*p;
+	HUDLIST		*pNext;
+};
+
+#include "voice_status.h"
+
+//
+//-----------------------------------------------------
+//
+class CHudAmmo: public CHudBase
+{
+public:
+	int Init( void );
+	int VidInit( void );
+	int Draw(float flTime);
+	void Think(void);
+	void Reset(void);
+	int DrawWList(float flTime);
+	int MsgFunc_CurWeapon(const char *pszName, int iSize, void *pbuf);
+	int MsgFunc_WeaponList(const char *pszName, int iSize, void *pbuf);
+	int MsgFunc_AmmoX(const char *pszName, int iSize, void *pbuf);
+	int MsgFunc_AmmoPickup( const char *pszName, int iSize, void *pbuf );
+	int MsgFunc_WeapPickup( const char *pszName, int iSize, void *pbuf );
+	int MsgFunc_ItemPickup( const char *pszName, int iSize, void *pbuf );
+	int MsgFunc_HideWeapon( const char *pszName, int iSize, void *pbuf );
+
+	void _cdecl UserCmd_Slot1( void );
+	void _cdecl UserCmd_Slot2( void );
+	void _cdecl UserCmd_Slot3( void );
+	void _cdecl UserCmd_Slot4( void );
+	void _cdecl UserCmd_Slot5( void );
+	void _cdecl UserCmd_Slot6( void );
+	void _cdecl UserCmd_Slot7( void );
+	void _cdecl UserCmd_Slot8( void );
+	void _cdecl UserCmd_Slot9( void );
+	void _cdecl UserCmd_Slot10( void );
+	void _cdecl UserCmd_Close( void );
+	void _cdecl UserCmd_NextWeapon( void );
+	void _cdecl UserCmd_PrevWeapon( void );
+
+private:
+	float m_fFade;
+	RGBA  m_rgba;
+	WEAPON *m_pWeapon;
+	int	m_HUD_bucket0;
+	int m_HUD_selection;
+
+};
+
+//
+//-----------------------------------------------------
+//
+
+class CHudAmmoSecondary: public CHudBase
+{
+public:
+	int Init( void );
+	int VidInit( void );
+	void Reset( void );
+	int Draw(float flTime);
+
+	int MsgFunc_SecAmmoVal( const char *pszName, int iSize, void *pbuf );
+	int MsgFunc_SecAmmoIcon( const char *pszName, int iSize, void *pbuf );
+
+private:
+	enum {
+		MAX_SEC_AMMO_VALUES = 4
+	};
+
+	int m_HUD_ammoicon; // sprite indices
+	int m_iAmmoAmounts[MAX_SEC_AMMO_VALUES];
+	float m_fFade;
+};
+
+
+#include "health.h"
+
+
+#define FADE_TIME 100
+
+
+//
+//-----------------------------------------------------
+//
+class CHudGeiger: public CHudBase
+{
+public:
+	int Init( void );
+	int VidInit( void );
+	int Draw(float flTime);
+	int MsgFunc_Geiger(const char *pszName, int iSize, void *pbuf);
+	
+private:
+	int m_iGeigerRange;
+
+};
+
+//
+//-----------------------------------------------------
+//
+class CHudTrain: public CHudBase
+{
+public:
+	int Init( void );
+	int VidInit( void );
+	int Draw(float flTime);
+	int MsgFunc_Train(const char *pszName, int iSize, void *pbuf);
+
+private:
+	HSPRITE m_hSprite;
+	int m_iPos;
+
+};
+
+//
+//-----------------------------------------------------
+//
+class CHudStatusBar : public CHudBase
+{
+public:
+	int Init( void );
+	int VidInit( void );
+	int Draw( float flTime );
+	void Reset( void );
+	void ParseStatusString( int line_num );
+
+	int MsgFunc_StatusText( const char *pszName, int iSize, void *pbuf );
+	int MsgFunc_StatusValue( const char *pszName, int iSize, void *pbuf );
+
+protected:
+	enum { 
+		MAX_STATUSTEXT_LENGTH = 128,
+		MAX_STATUSBAR_VALUES = 8,
+		MAX_STATUSBAR_LINES = 2,
+	};
+
+	char m_szStatusText[MAX_STATUSBAR_LINES][MAX_STATUSTEXT_LENGTH];  // a text string describing how the status bar is to be drawn
+	char m_szStatusBar[MAX_STATUSBAR_LINES][MAX_STATUSTEXT_LENGTH];	// the constructed bar that is drawn
+	int m_iStatusValues[MAX_STATUSBAR_VALUES];  // an array of values for use in the status bar
+
+	int m_bReparseString; // set to TRUE whenever the m_szStatusBar needs to be recalculated
+};
+
+//
+//-----------------------------------------------------
+//
+enum
+{ 
+	MAX_PLAYERS = 64,
+	MAX_TEAMS = 64,
+	MAX_TEAM_NAME = 16,
+};
+
+struct extra_player_info_t 
+{
+	short frags;
+	short deaths;
+	short playerclass;
+	short teamnumber;
+	char teamname[MAX_TEAM_NAME];
+};
+
+struct team_info_t 
+{
+	char name[MAX_TEAM_NAME];
+	short frags;
+	short deaths;
+	short ping;
+	short packetloss;
+	short ownteam;
+	short players;
+	int already_drawn;
+	int scores_overriden;
+	int teamnumber;
+};
+
+extern hud_player_info_t	g_PlayerInfoList[MAX_PLAYERS+1];	   // player info from the engine
+extern extra_player_info_t	g_PlayerExtraInfo[MAX_PLAYERS+1];  // additional player info sent directly to the client dll
+extern team_info_t			g_TeamInfo[MAX_TEAMS+1];
+extern int					g_IsSpectator[MAX_PLAYERS+1];
+
+
+//
+//-----------------------------------------------------
+//
+class CHudDeathNotice : public CHudBase
+{
+public:
+	int Init( void );
+	void InitHUDData( void );
+	int VidInit( void );
+	int Draw( float flTime );
+	int MsgFunc_DeathMsg( const char *pszName, int iSize, void *pbuf );
+
+private:
+	int m_HUD_d_skull;  // sprite index of skull icon
+};
+
+//
+//-----------------------------------------------------
+//
+class CHudMenu : public CHudBase
+{
+public:
+	int Init( void );
+	void InitHUDData( void );
+	int VidInit( void );
+	void Reset( void );
+	int Draw( float flTime );
+	int MsgFunc_ShowMenu( const char *pszName, int iSize, void *pbuf );
+
+	void SelectMenuItem( int menu_item );
+
+	int m_fMenuDisplayed;
+	int m_bitsValidSlots;
+	float m_flShutoffTime;
+	int m_fWaitingForMore;
+};
+
+//
+//-----------------------------------------------------
+//
+class CHudSayText : public CHudBase
+{
+public:
+	int Init( void );
+	void InitHUDData( void );
+	int VidInit( void );
+	int Draw( float flTime );
+	int MsgFunc_SayText( const char *pszName, int iSize, void *pbuf );
+	void SayTextPrint( const char *pszBuf, int iBufSize, int clientIndex = -1 );
+	void EnsureTextFitsInOneLineAndWrapIfHaveTo( int line );
+};
+
+//
+//-----------------------------------------------------
+//
+class CHudBattery: public CHudBase
+{
+public:
+	int Init( void );
+	int VidInit( void );
+	int Draw(float flTime);
+	int MsgFunc_Battery(const char *pszName,  int iSize, void *pbuf );
+	
+private:
+	HSPRITE m_hSprite1;
+	HSPRITE m_hSprite2;
+	wrect_t *m_prc1;
+	wrect_t *m_prc2;
+	int	  m_iBat;	
+	float m_fFade;
+	int	  m_iHeight;		// width of the battery innards
+};
+
+
+//
+//-----------------------------------------------------
+//
+class CHudFlashlight: public CHudBase
+{
+public:
+	int Init( void );
+	int VidInit( void );
+	int Draw(float flTime);
+	void Reset( void );
+	int MsgFunc_Flashlight(const char *pszName,  int iSize, void *pbuf );
+	int MsgFunc_FlashBat(const char *pszName,  int iSize, void *pbuf );
+	
+private:
+	HSPRITE m_hSprite1;
+	HSPRITE m_hSprite2;
+	HSPRITE m_hBeam;
+	wrect_t *m_prc1;
+	wrect_t *m_prc2;
+	wrect_t *m_prcBeam;
+	float m_flBat;	
+	int	  m_iBat;	
+	int	  m_fOn;
+	float m_fFade;
+	int	  m_iWidth;		// width of the battery innards
+};
+
+//
+//-----------------------------------------------------
+//
+const int maxHUDMessages = 16;
+struct message_parms_t
+{
+	client_textmessage_t	*pMessage;
+	float	time;
+	int x, y;
+	int	totalWidth, totalHeight;
+	int width;
+	int lines;
+	int lineLength;
+	int length;
+	int r, g, b;
+	int text;
+	int fadeBlend;
+	float charTime;
+	float fadeTime;
+};
+
+//
+//-----------------------------------------------------
+//
+
+class CHudTextMessage: public CHudBase
+{
+public:
+	int Init( void );
+	static char *LocaliseTextString( const char *msg, char *dst_buffer, int buffer_size );
+	static char *BufferedLocaliseTextString( const char *msg );
+	char *LookupString( const char *msg_name, int *msg_dest = NULL );
+	int MsgFunc_TextMsg(const char *pszName, int iSize, void *pbuf);
+};
+
+//
+//-----------------------------------------------------
+//
+
+class CHudMessage: public CHudBase
+{
+public:
+	int Init( void );
+	int VidInit( void );
+	int Draw(float flTime);
+	int MsgFunc_HudText(const char *pszName, int iSize, void *pbuf);
+	int MsgFunc_GameTitle(const char *pszName, int iSize, void *pbuf);
+
+	float FadeBlend( float fadein, float fadeout, float hold, float localTime );
+	int	XPosition( float x, int width, int lineWidth );
+	int YPosition( float y, int height );
+
+	void MessageAdd( const char *pName, float time );
+	void MessageDrawScan( client_textmessage_t *pMessage, float time );
+	void MessageScanStart( void );
+	void MessageScanNextChar( void );
+	void Reset( void );
+
+private:
+	client_textmessage_t		*m_pMessages[maxHUDMessages];
+	float						m_startTime[maxHUDMessages];
+	message_parms_t				m_parms;
+	float						m_gameTitleTime;
+	client_textmessage_t		*m_pGameTitle;
+
+	int m_HUD_title_life;
+	int m_HUD_title_half;
+};
+
+//
+//-----------------------------------------------------
+//
+#define MAX_SPRITE_NAME_LENGTH	24
+
+class CHudStatusIcons: public CHudBase
+{
+public:
+	int Init( void );
+	int VidInit( void );
+	void Reset( void );
+	int Draw(float flTime);
+	int MsgFunc_StatusIcon(const char *pszName, int iSize, void *pbuf);
+
+	enum { 
+		MAX_ICONSPRITENAME_LENGTH = MAX_SPRITE_NAME_LENGTH,
+		MAX_ICONSPRITES = 4,
+	};
+
+	
+	//had to make these public so CHud could access them (to enable concussion icon)
+	//could use a friend declaration instead...
+	void EnableIcon( char *pszIconName, unsigned char red, unsigned char green, unsigned char blue );
+	void DisableIcon( char *pszIconName );
+
+private:
+
+	typedef struct
+	{
+		char szSpriteName[MAX_ICONSPRITENAME_LENGTH];
+		HSPRITE spr;
+		wrect_t rc;
+		unsigned char r, g, b;
+	} icon_sprite_t;
+
+	icon_sprite_t m_IconList[MAX_ICONSPRITES];
+
+};
+
+
+//
+//-----------------------------------------------------
+//
+typedef struct cvar_s cvar_t;
+
+class CHud
+{
+private:
+	HUDLIST						*m_pHudList;
+	HSPRITE						m_hsprLogo;
+	int							m_iLogo;
+	client_sprite_t				*m_pSpriteList;
+	int							m_iSpriteCount;
+	int							m_iSpriteCountAllRes;
+	float						m_flMouseSensitivity;
+	int							m_iConcussionEffect; 
+
+public:
+
+	HSPRITE						m_hsprCursor;
+	float m_flTime;	   // the current client time
+	float m_fOldTime;  // the time at which the HUD was last redrawn
+	double m_flTimeDelta; // the difference between flTime and fOldTime
+	Vector	m_vecOrigin;
+	Vector	m_vecAngles;
+	int		m_iKeyBits;
+	int		m_iHideHUDDisplay;
+	int		m_iFOV;
+	int		m_Teamplay;
+	int		m_iRes;
+	cvar_t  *m_pCvarStealMouse;
+
+	int m_iFontHeight;
+	int DrawHudNumber(int x, int y, int iFlags, int iNumber, int r, int g, int b );
+	int DrawHudString(int x, int y, int iMaxX, char *szString, int r, int g, int b );
+	int DrawHudStringReverse( int xpos, int ypos, int iMinX, char *szString, int r, int g, int b );
+	int DrawHudNumberString( int xpos, int ypos, int iMinX, int iNumber, int r, int g, int b );
+	int GetNumWidth(int iNumber, int iFlags);
+
+private:
+	// the memory for these arrays are allocated in the first call to CHud::VidInit(), when the hud.txt and associated sprites are loaded.
+	// freed in ~CHud()
+	HSPRITE *m_rghSprites;	/*[HUD_SPRITE_COUNT]*/			// the sprites loaded from hud.txt
+	wrect_t *m_rgrcRects;	/*[HUD_SPRITE_COUNT]*/
+	char *m_rgszSpriteNames; /*[HUD_SPRITE_COUNT][MAX_SPRITE_NAME_LENGTH]*/
+
+	struct cvar_s *default_fov;
+public:
+	HSPRITE GetSprite( int index ) 
+	{
+		return (index < 0) ? 0 : m_rghSprites[index];
+	}
+
+	wrect_t& GetSpriteRect( int index )
+	{
+		return m_rgrcRects[index];
+	}
+
+	
+	int GetSpriteIndex( const char *SpriteName );	// gets a sprite index, for use in the m_rghSprites[] array
+
+	CHudAmmo	m_Ammo;
+	CHudHealth	m_Health;
+	CHudGeiger	m_Geiger;
+	CHudBattery	m_Battery;
+	CHudTrain	m_Train;
+	CHudFlashlight m_Flash;
+	CHudMessage m_Message;
+	CHudStatusBar    m_StatusBar;
+	CHudDeathNotice m_DeathNotice;
+	CHudSayText m_SayText;
+	CHudMenu	m_Menu;
+	CHudAmmoSecondary	m_AmmoSecondary;
+	CHudTextMessage m_TextMessage;
+	CHudStatusIcons m_StatusIcons;
+
+	void Init( void );
+	void VidInit( void );
+	void Think(void);
+	int Redraw( float flTime, int intermission );
+	int UpdateClientData( client_data_t *cdata, float time );
+
+	CHud() : m_iSpriteCount(0), m_pHudList(NULL) {}  
+	~CHud();			// destructor, frees allocated memory
+
+	// user messages
+	int _cdecl MsgFunc_Damage(const char *pszName, int iSize, void *pbuf );
+	int _cdecl MsgFunc_GameMode(const char *pszName, int iSize, void *pbuf );
+	int _cdecl MsgFunc_Logo(const char *pszName,  int iSize, void *pbuf);
+	int _cdecl MsgFunc_ResetHUD(const char *pszName,  int iSize, void *pbuf);
+	void _cdecl MsgFunc_InitHUD( const char *pszName, int iSize, void *pbuf );
+	int _cdecl MsgFunc_SetFOV(const char *pszName,  int iSize, void *pbuf);
+	int  _cdecl MsgFunc_Concuss( const char *pszName, int iSize, void *pbuf );
+	// Screen information
+	SCREENINFO	m_scrinfo;
+
+	int	m_iWeaponBits;
+	int	m_fPlayerDead;
+	int m_iIntermission;
+
+	// sprite indexes
+	int m_HUD_number_0;
+
+
+	void AddHudElem(CHudBase *p);
+
+	float GetSensitivity();
+};
+
+extern CHud gHUD;
+
+class TeamFortressViewport;
+
+extern TeamFortressViewport *gViewPort;
+
+extern int g_iPlayerClass;
+extern int g_iTeamNumber;
+extern int g_iUser1;
+extern int g_iUser2;

hlsdk/ricochet/cl_dll/hud_iface.h

@@ -0,0 +1,27 @@
+/***
+*
+*	Copyright (c) 1999, 2000 Valve LLC. All rights reserved.
+*	
+*	This product contains software technology licensed from Id 
+*	Software, Inc. ("Id Technology").  Id Technology (c) 1996 Id Software, Inc. 
+*	All Rights Reserved.
+*
+*   Use, distribution, and modification of this source code and/or resulting
+*   object code is restricted to non-commercial enhancements to products from
+*   Valve LLC.  All other use, distribution, or modification is prohibited
+*   without written permission from Valve LLC.
+*
+****/
+#if !defined( HUD_IFACEH )
+#define HUD_IFACEH
+#pragma once
+
+#define EXPORT		_declspec( dllexport )
+#define _DLLEXPORT __declspec( dllexport )
+
+typedef int (*pfnUserMsgHook)(const char *pszName, int iSize, void *pbuf);
+#include "wrect.h"
+#include "../engine/cdll_int.h"
+extern cl_enginefunc_t gEngfuncs;
+
+#endif

hlsdk/ricochet/cl_dll/hud_msg.cpp

@@ -0,0 +1,117 @@
+/***
+*
+*	Copyright (c) 1999, 2000 Valve LLC. All rights reserved.
+*	
+*	This product contains software technology licensed from Id 
+*	Software, Inc. ("Id Technology").  Id Technology (c) 1996 Id Software, Inc. 
+*	All Rights Reserved.
+*
+*   Use, distribution, and modification of this source code and/or resulting
+*   object code is restricted to non-commercial enhancements to products from
+*   Valve LLC.  All other use, distribution, or modification is prohibited
+*   without written permission from Valve LLC.
+*
+****/
+//
+//  hud_msg.cpp
+//
+
+#include "hud.h"
+#include "cl_util.h"
+#include "parsemsg.h"
+
+#include "vgui_int.h"
+#include "vgui_TeamFortressViewport.h"
+#include "vgui_discobjects.h"
+
+/// USER-DEFINED SERVER MESSAGE HANDLERS
+
+int g_iArenaMode = 0;
+
+int CHud :: MsgFunc_ResetHUD(const char *pszName, int iSize, void *pbuf )
+{
+	ASSERT( iSize == 0 );
+
+	// clear all hud data
+	HUDLIST *pList = m_pHudList;
+
+	while ( pList )
+	{
+		if ( pList->p )
+			pList->p->Reset();
+		pList = pList->pNext;
+	}
+
+	// reset sensitivity
+	m_flMouseSensitivity = 0;
+
+	// reset concussion effect
+	m_iConcussionEffect = 0;
+
+	return 1;
+}
+
+void CHud :: MsgFunc_InitHUD( const char *pszName, int iSize, void *pbuf )
+{
+	// prepare all hud data
+	HUDLIST *pList = m_pHudList;
+
+	while (pList)
+	{
+		if ( pList->p )
+			pList->p->InitHUDData();
+		pList = pList->pNext;
+	}
+}
+
+
+int CHud :: MsgFunc_GameMode(const char *pszName, int iSize, void *pbuf )
+{
+	BEGIN_READ( pbuf, iSize );
+	g_iArenaMode = READ_BYTE();
+	
+	if (gViewPort)
+	{
+		gViewPort->m_pDiscEndRound->setVisible( false );
+		gViewPort->m_pDiscStartRound->setVisible ( false );
+	}
+
+	return 1;
+}
+
+
+int CHud :: MsgFunc_Damage(const char *pszName, int iSize, void *pbuf )
+{
+	int		armor, blood;
+	Vector	from;
+	int		i;
+	float	count;
+	
+	BEGIN_READ( pbuf, iSize );
+	armor = READ_BYTE();
+	blood = READ_BYTE();
+
+	for (i=0 ; i<3 ; i++)
+		from[i] = READ_COORD();
+
+	count = (blood * 0.5) + (armor * 0.5);
+
+	if (count < 10)
+		count = 10;
+
+	// TODO: kick viewangles,  show damage visually
+
+	return 1;
+}
+
+int CHud :: MsgFunc_Concuss( const char *pszName, int iSize, void *pbuf )
+{
+	BEGIN_READ( pbuf, iSize );
+	m_iConcussionEffect = READ_BYTE();
+	if (m_iConcussionEffect)
+		this->m_StatusIcons.EnableIcon("dmg_concuss",255,160,0);
+	else
+		this->m_StatusIcons.DisableIcon("dmg_concuss");
+	return 1;
+}
+

hlsdk/ricochet/cl_dll/hud_redraw.cpp

@@ -0,0 +1,261 @@
+/***
+*
+*	Copyright (c) 1999, 2000 Valve LLC. All rights reserved.
+*	
+*	This product contains software technology licensed from Id 
+*	Software, Inc. ("Id Technology").  Id Technology (c) 1996 Id Software, Inc. 
+*	All Rights Reserved.
+*
+*   Use, distribution, and modification of this source code and/or resulting
+*   object code is restricted to non-commercial enhancements to products from
+*   Valve LLC.  All other use, distribution, or modification is prohibited
+*   without written permission from Valve LLC.
+*
+****/
+//
+// hud_redraw.cpp
+//
+#include <math.h>
+#include "hud.h"
+#include "cl_util.h"
+
+
+#define MAX_LOGO_FRAMES 56
+
+int grgLogoFrame[MAX_LOGO_FRAMES] = 
+{
+	1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 13, 13, 13, 13, 13, 12, 11, 10, 9, 8, 14, 15,
+	16, 17, 18, 19, 20, 20, 20, 20, 20, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 
+	29, 29, 29, 29, 29, 28, 27, 26, 25, 24, 30, 31 
+};
+
+extern int g_iVisibleMouse;
+
+// Think
+void CHud::Think(void)
+{
+	HUDLIST *pList = m_pHudList;
+	while (pList)
+	{
+		if (pList->p->m_iFlags & HUD_ACTIVE)
+			pList->p->Think();
+		pList = pList->pNext;
+	}
+
+	// think about default fov
+	if ( m_iFOV == 0 )
+	{  // only let players adjust up in fov,  and only if they are not overriden by something else
+		m_iFOV = max( default_fov->value, 90 );  
+	}
+}
+
+// Redraw
+// step through the local data,  placing the appropriate graphics & text as appropriate
+// returns 1 if they've changed, 0 otherwise
+int CHud :: Redraw( float flTime, int intermission )
+{
+	m_fOldTime = m_flTime;	// save time of previous redraw
+	m_flTime = flTime;
+	m_flTimeDelta = (double)m_flTime - m_fOldTime;
+	
+	// Clock was reset, reset delta
+	if ( m_flTimeDelta < 0 )
+		m_flTimeDelta = 0;
+
+	m_iIntermission = intermission;
+
+	// if no redrawing is necessary
+	// return 0;
+	
+	HUDLIST *pList = m_pHudList;
+
+	while (pList)
+	{
+		if ( !intermission )
+		{
+			if ((pList->p->m_iFlags & HUD_ACTIVE) && !(m_iHideHUDDisplay & HIDEHUD_ALL))
+				pList->p->Draw(flTime);
+		}
+		else
+		{  // it's an intermission,  so only draw hud elements that are set to draw during intermissions
+			if ( pList->p->m_iFlags & HUD_INTERMISSION )
+				pList->p->Draw( flTime );
+		}
+
+		pList = pList->pNext;
+	}
+
+	// are we in demo mode? do we need to draw the logo in the top corner?
+	if (m_iLogo)
+	{
+		int x, y, i;
+
+		if (m_hsprLogo == 0)
+			m_hsprLogo = LoadSprite("sprites/%d_logo.spr");
+
+		SPR_Set(m_hsprLogo, 250, 250, 250 );
+		
+		x = SPR_Width(m_hsprLogo, 0);
+		x = ScreenWidth - x;
+		y = SPR_Height(m_hsprLogo, 0)/2;
+
+		// Draw the logo at 20 fps
+		int iFrame = (int)(flTime * 20) % MAX_LOGO_FRAMES;
+		i = grgLogoFrame[iFrame] - 1;
+
+		SPR_DrawAdditive(i, x, y, NULL);
+	}
+
+	return 1;
+}
+
+void ScaleColors( int &r, int &g, int &b, int a )
+{
+	float x = (float)a / 255;
+	r = (int)(r * x);
+	g = (int)(g * x);
+	b = (int)(b * x);
+}
+
+int CHud :: DrawHudString(int xpos, int ypos, int iMaxX, char *szIt, int r, int g, int b )
+{
+	// draw the string until we hit the null character or a newline character
+	for ( ; *szIt != 0 && *szIt != '\n'; szIt++ )
+	{
+		int next = xpos + gHUD.m_scrinfo.charWidths[ *szIt ]; // variable-width fonts look cool
+		if ( next > iMaxX )
+			return xpos;
+
+		TextMessageDrawChar( xpos, ypos, *szIt, r, g, b );
+		xpos = next;		
+	}
+
+	return xpos;
+}
+
+int CHud :: DrawHudNumberString( int xpos, int ypos, int iMinX, int iNumber, int r, int g, int b )
+{
+	char szString[32];
+	sprintf( szString, "%d", iNumber );
+	return DrawHudStringReverse( xpos, ypos, iMinX, szString, r, g, b );
+
+}
+
+// draws a string from right to left (right-aligned)
+int CHud :: DrawHudStringReverse( int xpos, int ypos, int iMinX, char *szString, int r, int g, int b )
+{
+	// find the end of the string
+	char *szIt = NULL;
+	for ( szIt = szString; *szIt != 0; szIt++ )
+	{ // we should count the length?		
+	}
+
+	// iterate throug the string in reverse
+	for ( szIt--;  szIt != (szString-1);  szIt-- )	
+	{
+		int next = xpos - gHUD.m_scrinfo.charWidths[ *szIt ]; // variable-width fonts look cool
+		if ( next < iMinX )
+			return xpos;
+		xpos = next;
+
+		TextMessageDrawChar( xpos, ypos, *szIt, r, g, b );
+	}
+
+	return xpos;
+}
+
+int CHud :: DrawHudNumber( int x, int y, int iFlags, int iNumber, int r, int g, int b)
+{
+	int iWidth = GetSpriteRect(m_HUD_number_0).right - GetSpriteRect(m_HUD_number_0).left;
+	int k;
+	
+	if (iNumber > 0)
+	{
+		// SPR_Draw 100's
+		if (iNumber >= 100)
+		{
+			 k = iNumber/100;
+			SPR_Set(GetSprite(m_HUD_number_0 + k), r, g, b );
+			SPR_DrawAdditive( 0, x, y, &GetSpriteRect(m_HUD_number_0 + k));
+			x += iWidth;
+		}
+		else if (iFlags & (DHN_3DIGITS))
+		{
+			//SPR_DrawAdditive( 0, x, y, &rc );
+			x += iWidth;
+		}
+
+		// SPR_Draw 10's
+		if (iNumber >= 10)
+		{
+			k = (iNumber % 100)/10;
+			SPR_Set(GetSprite(m_HUD_number_0 + k), r, g, b );
+			SPR_DrawAdditive( 0, x, y, &GetSpriteRect(m_HUD_number_0 + k));
+			x += iWidth;
+		}
+		else if (iFlags & (DHN_3DIGITS | DHN_2DIGITS))
+		{
+			//SPR_DrawAdditive( 0, x, y, &rc );
+			x += iWidth;
+		}
+
+		// SPR_Draw ones
+		k = iNumber % 10;
+		SPR_Set(GetSprite(m_HUD_number_0 + k), r, g, b );
+		SPR_DrawAdditive(0,  x, y, &GetSpriteRect(m_HUD_number_0 + k));
+		x += iWidth;
+	} 
+	else if (iFlags & DHN_DRAWZERO) 
+	{
+		SPR_Set(GetSprite(m_HUD_number_0), r, g, b );
+
+		// SPR_Draw 100's
+		if (iFlags & (DHN_3DIGITS))
+		{
+			//SPR_DrawAdditive( 0, x, y, &rc );
+			x += iWidth;
+		}
+
+		if (iFlags & (DHN_3DIGITS | DHN_2DIGITS))
+		{
+			//SPR_DrawAdditive( 0, x, y, &rc );
+			x += iWidth;
+		}
+
+		// SPR_Draw ones
+		
+		SPR_DrawAdditive( 0,  x, y, &GetSpriteRect(m_HUD_number_0));
+		x += iWidth;
+	}
+
+	return x;
+}
+
+
+int CHud::GetNumWidth( int iNumber, int iFlags )
+{
+	if (iFlags & (DHN_3DIGITS))
+		return 3;
+
+	if (iFlags & (DHN_2DIGITS))
+		return 2;
+
+	if (iNumber <= 0)
+	{
+		if (iFlags & (DHN_DRAWZERO))
+			return 1;
+		else
+			return 0;
+	}
+
+	if (iNumber < 10)
+		return 1;
+
+	if (iNumber < 100)
+		return 2;
+
+	return 3;
+
+}	
+
+

hlsdk/ricochet/cl_dll/hud_servers.h

@@ -0,0 +1,34 @@
+#if !defined( HUD_SERVERSH )
+#define HUD_SERVERSH
+#pragma once
+
+#define NET_CALLBACK /* */
+
+// Dispatchers
+void NET_CALLBACK ListResponse( struct net_response_s *response );
+void NET_CALLBACK ServerResponse( struct net_response_s *response );
+void NET_CALLBACK PingResponse( struct net_response_s *response );
+void NET_CALLBACK RulesResponse( struct net_response_s *response );
+void NET_CALLBACK PlayersResponse( struct net_response_s *response );
+
+void ServersInit( void );
+void ServersShutdown( void );
+void ServersThink( double time );
+void ServersCancel( void );
+
+// Get list and get server info from each
+void ServersList( void );
+
+// Query for IP / IPX LAN servers
+void BroadcastServersList( int clearpending );
+
+void ServerPing( int server );
+void ServerRules( int server );
+void ServerPlayers( int server );
+
+int	ServersGetCount( void );
+const char *ServersGetInfo( int server );
+int	ServersIsQuerying( void );
+void SortServers( const char *fieldname );
+
+#endif // HUD_SERVERSH

hlsdk/ricochet/cl_dll/hud_servers_priv.h

@@ -0,0 +1,91 @@
+#if !defined( HUD_SERVERS_PRIVH )
+#define HUD_SERVERS_PRIVH
+#pragma once
+
+#include "netadr.h"
+
+class CHudServers
+{
+public:
+	typedef struct request_s
+	{
+		struct request_s	*next;
+		netadr_t					remote_address;
+		int							context;
+	} request_t;
+
+	typedef struct server_s
+	{
+		struct server_s	*next;
+		netadr_t				remote_address;
+		char					*info;
+		int						ping;
+	} server_t;
+
+	CHudServers();
+	~CHudServers();
+
+	void	Think( double time );
+	void	QueryThink( void );
+	int		isQuerying( void );
+
+	int		LoadMasterAddresses( int maxservers, int *count, netadr_t *padr );
+
+	void	RequestList( void );
+	void	RequestBroadcastList( int clearpending );
+
+	void	ServerPing( int server );
+	void	ServerRules( int server );
+	void	ServerPlayers( int server );
+
+	void	CancelRequest( void );
+
+	int		CompareServers( server_t *p1, server_t *p2 );
+
+	void	ClearServerList( server_t **ppList );
+	void	ClearRequestList( request_t **ppList );
+
+	void	AddServer( server_t **ppList, server_t *p );
+
+	void	RemoveServerFromList( request_t **ppList, request_t *item );
+
+	request_t *FindRequest( int context, request_t *pList );
+
+	int		ServerListSize( void );
+	char	*GetServerInfo( int server );
+	int		GetServerCount( void );
+	void	SortServers( const char *fieldname );
+
+	void	ListResponse( struct net_response_s *response );
+	void	ServerResponse( struct net_response_s *response );
+	void	PingResponse( struct net_response_s *response );
+	void	RulesResponse( struct net_response_s *response );
+	void	PlayersResponse( struct net_response_s *response );
+private:
+	
+	server_t *GetServer( int server );
+
+	//
+	char				m_szToken[ 1024 ];
+	int					m_nRequesting;
+	int					m_nDone;
+
+	double				m_dStarted;
+
+	request_t	*m_pServerList;
+	request_t	*m_pActiveList;
+	
+	server_t		*m_pServers;
+
+	int					m_nServerCount;
+
+	int					m_nActiveQueries;
+	int					m_nQuerying;
+	double				m_fElapsed;
+
+	request_t			*m_pPingRequest;
+	request_t			*m_pRulesRequest;
+	request_t			*m_pPlayersRequest;
+};
+
+#endif // HUD_SERVERS_PRIVH

hlsdk/ricochet/cl_dll/hud_update.cpp

@@ -0,0 +1,54 @@
+/***
+*
+*	Copyright (c) 1999, 2000 Valve LLC. All rights reserved.
+*	
+*	This product contains software technology licensed from Id 
+*	Software, Inc. ("Id Technology").  Id Technology (c) 1996 Id Software, Inc. 
+*	All Rights Reserved.
+*
+*   Use, distribution, and modification of this source code and/or resulting
+*   object code is restricted to non-commercial enhancements to products from
+*   Valve LLC.  All other use, distribution, or modification is prohibited
+*   without written permission from Valve LLC.
+*
+****/
+//
+//  hud_update.cpp
+//
+
+#include <math.h>
+#include "hud.h"
+#include "cl_util.h"
+#include <stdlib.h>
+#include <memory.h>
+
+int CL_ButtonBits( int );
+void CL_ResetButtonBits( int bits );
+
+extern float v_idlescale;
+float in_fov;
+extern void HUD_SetCmdBits( int bits );
+
+int CHud::UpdateClientData(client_data_t *cdata, float time)
+{
+	memcpy(m_vecOrigin, cdata->origin, sizeof(vec3_t));
+	memcpy(m_vecAngles, cdata->viewangles, sizeof(vec3_t));
+	
+	m_iKeyBits = CL_ButtonBits( 0 );
+	m_iWeaponBits = cdata->iWeaponBits;
+
+	in_fov = cdata->fov;
+
+	Think();
+
+	cdata->fov = m_iFOV;
+	
+	v_idlescale = m_iConcussionEffect;
+
+	CL_ResetButtonBits( m_iKeyBits );
+
+	// return 1 if in anything in the client_data struct has been changed, 0 otherwise
+	return 1;
+}
+
+

hlsdk/ricochet/cl_dll/in_camera.cpp

@@ -0,0 +1,620 @@
+/***
+*
+*	Copyright (c) 1999, 2000 Valve LLC. All rights reserved.
+*	
+*	This product contains software technology licensed from Id 
+*	Software, Inc. ("Id Technology").  Id Technology (c) 1996 Id Software, Inc. 
+*	All Rights Reserved.
+*
+*   Use, distribution, and modification of this source code and/or resulting
+*   object code is restricted to non-commercial enhancements to products from
+*   Valve LLC.  All other use, distribution, or modification is prohibited
+*   without written permission from Valve LLC.
+*
+****/
+#include "hud.h"
+#include "cl_util.h"
+#include "camera.h"
+#include "kbutton.h"
+#include "cvardef.h"
+#include "usercmd.h"
+#include "const.h"
+#include "camera.h"
+#include "in_defs.h"
+
+#include "windows.h"
+
+float CL_KeyState (kbutton_t *key);
+
+extern "C" 
+{
+	void DLLEXPORT CAM_Think( void );
+	int DLLEXPORT CL_IsThirdPerson( void );
+	void DLLEXPORT CL_CameraOffset( float *ofs );
+}
+
+extern cl_enginefunc_t gEngfuncs;
+
+//-------------------------------------------------- Constants
+
+#define CAM_DIST_DELTA 1.0
+#define CAM_ANGLE_DELTA 2.5
+#define CAM_ANGLE_SPEED 2.5
+#define CAM_MIN_DIST 30.0
+#define CAM_ANGLE_MOVE .5
+#define MAX_ANGLE_DIFF 10.0
+#define PITCH_MAX 90.0
+#define PITCH_MIN 0
+#define YAW_MAX  135.0
+#define YAW_MIN	 -135.0
+
+enum ECAM_Command
+{
+	CAM_COMMAND_NONE = 0,
+	CAM_COMMAND_TOTHIRDPERSON = 1,
+	CAM_COMMAND_TOFIRSTPERSON = 2
+};
+
+//-------------------------------------------------- Global Variables
+
+cvar_t	*cam_command;
+cvar_t	*cam_snapto;
+cvar_t	*cam_idealyaw;
+cvar_t	*cam_idealpitch;
+cvar_t	*cam_idealdist;
+cvar_t	*cam_contain;
+
+cvar_t	*c_maxpitch;
+cvar_t	*c_minpitch;
+cvar_t	*c_maxyaw;
+cvar_t	*c_minyaw;
+cvar_t	*c_maxdistance;
+cvar_t	*c_mindistance;
+
+// pitch, yaw, dist
+vec3_t cam_ofs;
+
+
+// In third person
+int cam_thirdperson;
+int cam_mousemove; //true if we are moving the cam with the mouse, False if not
+int iMouseInUse=0;
+int cam_distancemove;
+extern int mouse_x, mouse_y;  //used to determine what the current x and y values are
+int cam_old_mouse_x, cam_old_mouse_y; //holds the last ticks mouse movement
+POINT		cam_mouse;
+//-------------------------------------------------- Local Variables
+
+static kbutton_t cam_pitchup, cam_pitchdown, cam_yawleft, cam_yawright;
+static kbutton_t cam_in, cam_out, cam_move;
+
+//-------------------------------------------------- Prototypes
+
+void CAM_ToThirdPerson(void);
+void CAM_ToFirstPerson(void);
+void CAM_StartDistance(void);
+void CAM_EndDistance(void);
+
+
+//-------------------------------------------------- Local Functions
+
+float MoveToward( float cur, float goal, float maxspeed )
+{
+	if( cur != goal )
+	{
+		if( abs( cur - goal ) > 180.0 )
+		{
+			if( cur < goal )
+				cur += 360.0;
+			else
+				cur -= 360.0;
+		}
+
+		if( cur < goal )
+		{
+			if( cur < goal - 1.0 )
+				cur += ( goal - cur ) / 4.0;
+			else
+				cur = goal;
+		}
+		else
+		{
+			if( cur > goal + 1.0 )
+				cur -= ( cur - goal ) / 4.0;
+			else
+				cur = goal;
+		}
+	}
+
+
+	// bring cur back into range
+	if( cur < 0 )
+		cur += 360.0;
+	else if( cur >= 360 )
+		cur -= 360;
+
+	return cur;
+}
+
+
+//-------------------------------------------------- Gobal Functions
+
+typedef struct
+{
+	vec3_t		boxmins, boxmaxs;// enclose the test object along entire move
+	float		*mins, *maxs;	// size of the moving object
+	vec3_t		mins2, maxs2;	// size when clipping against mosnters
+	float		*start, *end;
+	trace_t		trace;
+	int			type;
+	edict_t		*passedict;
+	qboolean	monsterclip;
+} moveclip_t;
+
+extern trace_t SV_ClipMoveToEntity (edict_t *ent, vec3_t start, vec3_t mins, vec3_t maxs, vec3_t end);
+
+void DLLEXPORT CAM_Think( void )
+{
+	vec3_t origin;
+	vec3_t ext, pnt, camForward, camRight, camUp;
+	moveclip_t	clip;
+	float dist;
+	vec3_t camAngles;
+	float flSensitivity;
+#ifdef LATER
+	int i;
+#endif
+	vec3_t viewangles;
+
+	switch( (int) cam_command->value )
+	{
+		case CAM_COMMAND_TOTHIRDPERSON:
+			CAM_ToThirdPerson();
+			break;
+
+		case CAM_COMMAND_TOFIRSTPERSON:
+			CAM_ToFirstPerson();
+			break;
+
+		case CAM_COMMAND_NONE:
+		default:
+			break;
+	}
+
+	if( !cam_thirdperson )
+		return;
+	
+#ifdef LATER
+	if ( cam_contain->value )
+	{
+		gEngfuncs.GetClientOrigin( origin );
+		ext[0] = ext[1] = ext[2] = 0.0;
+	}
+#endif
+
+	camAngles[ PITCH ] = cam_idealpitch->value;
+	camAngles[ YAW ] = cam_idealyaw->value;
+	dist = cam_idealdist->value;
+	//
+	//movement of the camera with the mouse
+	//
+	if (cam_mousemove)
+	{
+	    //get windows cursor position
+		GetCursorPos (&cam_mouse);
+		//check for X delta values and adjust accordingly
+		//eventually adjust YAW based on amount of movement
+	  //don't do any movement of the cam using YAW/PITCH if we are zooming in/out the camera	
+	  if (!cam_distancemove)
+	  {
+		
+		//keep the camera within certain limits around the player (ie avoid certain bad viewing angles)  
+		if (cam_mouse.x>gEngfuncs.GetWindowCenterX())
+		{
+			//if ((camAngles[YAW]>=225.0)||(camAngles[YAW]<135.0))
+			if (camAngles[YAW]<c_maxyaw->value)
+			{
+				camAngles[ YAW ] += (CAM_ANGLE_MOVE)*((cam_mouse.x-gEngfuncs.GetWindowCenterX())/2);
+			}
+			if (camAngles[YAW]>c_maxyaw->value)
+			{
+				
+				camAngles[YAW]=c_maxyaw->value;
+			}
+		}
+		else if (cam_mouse.x<gEngfuncs.GetWindowCenterX())
+		{
+			//if ((camAngles[YAW]<=135.0)||(camAngles[YAW]>225.0))
+			if (camAngles[YAW]>c_minyaw->value)
+			{
+			   camAngles[ YAW ] -= (CAM_ANGLE_MOVE)* ((gEngfuncs.GetWindowCenterX()-cam_mouse.x)/2);
+			   	
+			}
+			if (camAngles[YAW]<c_minyaw->value)
+			{
+				camAngles[YAW]=c_minyaw->value;
+				
+			}
+		}
+
+		//check for y delta values and adjust accordingly
+		//eventually adjust PITCH based on amount of movement
+		//also make sure camera is within bounds
+		if (cam_mouse.y>gEngfuncs.GetWindowCenterY())
+		{
+			if(camAngles[PITCH]<c_maxpitch->value)
+			{
+			    camAngles[PITCH] +=(CAM_ANGLE_MOVE)* ((cam_mouse.y-gEngfuncs.GetWindowCenterY())/2);
+			}
+			if (camAngles[PITCH]>c_maxpitch->value)
+			{
+				camAngles[PITCH]=c_maxpitch->value;
+			}
+		}
+		else if (cam_mouse.y<gEngfuncs.GetWindowCenterY())
+		{
+			if (camAngles[PITCH]>c_minpitch->value)
+			{
+			   camAngles[PITCH] -= (CAM_ANGLE_MOVE)*((gEngfuncs.GetWindowCenterY()-cam_mouse.y)/2);
+			}
+			if (camAngles[PITCH]<c_minpitch->value)
+			{
+				camAngles[PITCH]=c_minpitch->value;
+			}
+		}
+
+		//set old mouse coordinates to current mouse coordinates
+		//since we are done with the mouse
+
+		if ( ( flSensitivity = gHUD.GetSensitivity() ) != 0 )
+		{
+			cam_old_mouse_x=cam_mouse.x*flSensitivity;
+			cam_old_mouse_y=cam_mouse.y*flSensitivity;
+		}
+		else
+		{
+			cam_old_mouse_x=cam_mouse.x;
+			cam_old_mouse_y=cam_mouse.y;
+		}
+		SetCursorPos (gEngfuncs.GetWindowCenterX(), gEngfuncs.GetWindowCenterY());
+	  }
+	}
+
+	//Nathan code here
+	if( CL_KeyState( &cam_pitchup ) )
+		camAngles[ PITCH ] += CAM_ANGLE_DELTA;
+	else if( CL_KeyState( &cam_pitchdown ) )
+		camAngles[ PITCH ] -= CAM_ANGLE_DELTA;
+
+	if( CL_KeyState( &cam_yawleft ) )
+		camAngles[ YAW ] -= CAM_ANGLE_DELTA;
+	else if( CL_KeyState( &cam_yawright ) )
+		camAngles[ YAW ] += CAM_ANGLE_DELTA;
+
+	if( CL_KeyState( &cam_in ) )
+	{
+		dist -= CAM_DIST_DELTA;
+		if( dist < CAM_MIN_DIST )
+		{
+			// If we go back into first person, reset the angle
+			camAngles[ PITCH ] = 0;
+			camAngles[ YAW ] = 0;
+			dist = CAM_MIN_DIST;
+		}
+
+	}
+	else if( CL_KeyState( &cam_out ) )
+		dist += CAM_DIST_DELTA;
+
+	if (cam_distancemove)
+	{
+		if (cam_mouse.y>gEngfuncs.GetWindowCenterY())
+		{
+			if(dist<c_maxdistance->value)
+			{
+			    dist +=CAM_DIST_DELTA * ((cam_mouse.y-gEngfuncs.GetWindowCenterY())/2);
+			}
+			if (dist>c_maxdistance->value)
+			{
+				dist=c_maxdistance->value;
+			}
+		}
+		else if (cam_mouse.y<gEngfuncs.GetWindowCenterY())
+		{
+			if (dist>c_mindistance->value)
+			{
+			   dist -= (CAM_DIST_DELTA)*((gEngfuncs.GetWindowCenterY()-cam_mouse.y)/2);
+			}
+			if (dist<c_mindistance->value)
+			{
+				dist=c_mindistance->value;
+			}
+		}
+		//set old mouse coordinates to current mouse coordinates
+		//since we are done with the mouse
+		cam_old_mouse_x=cam_mouse.x*gHUD.GetSensitivity();
+		cam_old_mouse_y=cam_mouse.y*gHUD.GetSensitivity();
+		SetCursorPos (gEngfuncs.GetWindowCenterX(), gEngfuncs.GetWindowCenterY());
+	}
+#ifdef LATER
+	if( cam_contain->value )
+	{
+		// check new ideal
+		VectorCopy( origin, pnt );
+		AngleVectors( camAngles, camForward, camRight, camUp );
+		for (i=0 ; i<3 ; i++)
+			pnt[i] += -dist*camForward[i];
+
+		// check line from r_refdef.vieworg to pnt
+		memset ( &clip, 0, sizeof ( moveclip_t ) );
+		clip.trace = SV_ClipMoveToEntity( sv.edicts, r_refdef.vieworg, ext, ext, pnt );
+		if( clip.trace.fraction == 1.0 )
+		{
+			// update ideal
+			cam_idealpitch->value = camAngles[ PITCH ];
+			cam_idealyaw->value = camAngles[ YAW ];
+			cam_idealdist->value = dist;
+		}
+	}
+	else
+#endif
+	{
+		// update ideal
+		cam_idealpitch->value = camAngles[ PITCH ];
+		cam_idealyaw->value = camAngles[ YAW ];
+		cam_idealdist->value = dist;
+	}
+
+	// Move towards ideal
+	VectorCopy( cam_ofs, camAngles );
+
+	gEngfuncs.GetViewAngles( (float *)viewangles );
+
+	if( cam_snapto->value )
+	{
+		camAngles[ YAW ] = cam_idealyaw->value + viewangles[ YAW ];
+		camAngles[ PITCH ] = cam_idealpitch->value + viewangles[ PITCH ];
+		camAngles[ 2 ] = cam_idealdist->value;
+	}
+	else
+	{
+		if( camAngles[ YAW ] - viewangles[ YAW ] != cam_idealyaw->value )
+			camAngles[ YAW ] = MoveToward( camAngles[ YAW ], cam_idealyaw->value + viewangles[ YAW ], CAM_ANGLE_SPEED );
+
+		if( camAngles[ PITCH ] - viewangles[ PITCH ] != cam_idealpitch->value )
+			camAngles[ PITCH ] = MoveToward( camAngles[ PITCH ], cam_idealpitch->value + viewangles[ PITCH ], CAM_ANGLE_SPEED );
+
+		if( abs( camAngles[ 2 ] - cam_idealdist->value ) < 2.0 )
+			camAngles[ 2 ] = cam_idealdist->value;
+		else
+			camAngles[ 2 ] += ( cam_idealdist->value - camAngles[ 2 ] ) / 4.0;
+	}
+#ifdef LATER
+	if( cam_contain->value )
+	{
+		// Test new position
+		dist = camAngles[ ROLL ];
+		camAngles[ ROLL ] = 0;
+
+		VectorCopy( origin, pnt );
+		AngleVectors( camAngles, camForward, camRight, camUp );
+		for (i=0 ; i<3 ; i++)
+			pnt[i] += -dist*camForward[i];
+
+		// check line from r_refdef.vieworg to pnt
+		memset ( &clip, 0, sizeof ( moveclip_t ) );
+		ext[0] = ext[1] = ext[2] = 0.0;
+		clip.trace = SV_ClipMoveToEntity( sv.edicts, r_refdef.vieworg, ext, ext, pnt );
+		if( clip.trace.fraction != 1.0 )
+			return;
+	}
+#endif
+	cam_ofs[ 0 ] = camAngles[ 0 ];
+	cam_ofs[ 1 ] = camAngles[ 1 ];
+	cam_ofs[ 2 ] = dist;
+}
+
+extern void KeyDown (kbutton_t *b);	// HACK
+extern void KeyUp (kbutton_t *b);	// HACK
+
+void CAM_PitchUpDown(void) { KeyDown( &cam_pitchup ); }
+void CAM_PitchUpUp(void) { KeyUp( &cam_pitchup ); }
+void CAM_PitchDownDown(void) { KeyDown( &cam_pitchdown ); }
+void CAM_PitchDownUp(void) { KeyUp( &cam_pitchdown ); }
+void CAM_YawLeftDown(void) { KeyDown( &cam_yawleft ); }
+void CAM_YawLeftUp(void) { KeyUp( &cam_yawleft ); }
+void CAM_YawRightDown(void) { KeyDown( &cam_yawright ); }
+void CAM_YawRightUp(void) { KeyUp( &cam_yawright ); }
+void CAM_InDown(void) { KeyDown( &cam_in ); }
+void CAM_InUp(void) { KeyUp( &cam_in ); }
+void CAM_OutDown(void) { KeyDown( &cam_out ); }
+void CAM_OutUp(void) { KeyUp( &cam_out ); }
+
+void CAM_ToThirdPerson(void)
+{ 
+	vec3_t viewangles;
+
+	gEngfuncs.GetViewAngles( (float *)viewangles );
+
+	if( !cam_thirdperson )
+	{
+		cam_thirdperson = 1; 
+		
+		cam_ofs[ YAW ] = viewangles[ YAW ]; 
+		cam_ofs[ PITCH ] = viewangles[ PITCH ]; 
+		cam_ofs[ 2 ] = CAM_MIN_DIST; 
+	}
+
+	gEngfuncs.Cvar_SetValue( "cam_command", 0 );
+}
+
+void CAM_ToFirstPerson(void) 
+{ 
+	cam_thirdperson = 0;
+	
+	gEngfuncs.Cvar_SetValue( "cam_command", 0 );
+}
+
+void CAM_ToggleSnapto( void )
+{ 
+	cam_snapto->value = !cam_snapto->value;
+}
+
+void CAM_Init( void )
+{
+	gEngfuncs.pfnAddCommand( "+campitchup", CAM_PitchUpDown );
+	gEngfuncs.pfnAddCommand( "-campitchup", CAM_PitchUpUp );
+	gEngfuncs.pfnAddCommand( "+campitchdown", CAM_PitchDownDown );
+	gEngfuncs.pfnAddCommand( "-campitchdown", CAM_PitchDownUp );
+	gEngfuncs.pfnAddCommand( "+camyawleft", CAM_YawLeftDown );
+	gEngfuncs.pfnAddCommand( "-camyawleft", CAM_YawLeftUp );
+	gEngfuncs.pfnAddCommand( "+camyawright", CAM_YawRightDown );
+	gEngfuncs.pfnAddCommand( "-camyawright", CAM_YawRightUp );
+	gEngfuncs.pfnAddCommand( "+camin", CAM_InDown );
+	gEngfuncs.pfnAddCommand( "-camin", CAM_InUp );
+	gEngfuncs.pfnAddCommand( "+camout", CAM_OutDown );
+	gEngfuncs.pfnAddCommand( "-camout", CAM_OutUp );
+	gEngfuncs.pfnAddCommand( "thirdperson", CAM_ToThirdPerson );
+	gEngfuncs.pfnAddCommand( "firstperson", CAM_ToFirstPerson );
+	gEngfuncs.pfnAddCommand( "+cammousemove",CAM_StartMouseMove);
+	gEngfuncs.pfnAddCommand( "-cammousemove",CAM_EndMouseMove);
+	gEngfuncs.pfnAddCommand( "+camdistance", CAM_StartDistance );
+	gEngfuncs.pfnAddCommand( "-camdistance", CAM_EndDistance );
+	gEngfuncs.pfnAddCommand( "snapto", CAM_ToggleSnapto );
+
+	cam_command				= gEngfuncs.pfnRegisterVariable ( "cam_command", "0", 0 );	 // tells camera to go to thirdperson
+	cam_snapto				= gEngfuncs.pfnRegisterVariable ( "cam_snapto", "0", 0 );	 // snap to thirdperson view
+	cam_idealyaw			= gEngfuncs.pfnRegisterVariable ( "cam_idealyaw", "0", 0 );	 // ? yaw
+	cam_idealpitch			= gEngfuncs.pfnRegisterVariable ( "cam_idealpitch", "0", 0 );	 // thirperson pitch
+	cam_idealdist			= gEngfuncs.pfnRegisterVariable ( "cam_idealdist", "196", 0 );	 // thirdperson distance
+	cam_contain				= gEngfuncs.pfnRegisterVariable ( "cam_contain", "0", 0 );	// contain camera to world
+
+	c_maxpitch				= gEngfuncs.pfnRegisterVariable ( "c_maxpitch", "90.0", 0 );
+	c_minpitch				= gEngfuncs.pfnRegisterVariable ( "c_minpitch", "0.0", 0 );
+	c_maxyaw				= gEngfuncs.pfnRegisterVariable ( "c_maxyaw",   "135.0", 0 );
+	c_minyaw				= gEngfuncs.pfnRegisterVariable ( "c_minyaw",   "-135.0", 0 );
+	c_maxdistance			= gEngfuncs.pfnRegisterVariable ( "c_maxdistance",   "200.0", 0 );
+	c_mindistance			= gEngfuncs.pfnRegisterVariable ( "c_mindistance",   "30.0", 0 );
+}
+
+void CAM_ClearStates( void )
+{
+	vec3_t viewangles;
+
+	gEngfuncs.GetViewAngles( (float *)viewangles );
+
+	cam_pitchup.state = 0;
+	cam_pitchdown.state = 0;
+	cam_yawleft.state = 0;
+	cam_yawright.state = 0;
+	cam_in.state = 0;
+	cam_out.state = 0;
+
+	cam_thirdperson = 0;
+	cam_command->value = 0;
+	cam_mousemove=0;
+
+	cam_snapto->value = 0;
+	cam_distancemove = 0;
+
+	cam_ofs[ 0 ] = 0.0;
+	cam_ofs[ 1 ] = 0.0;
+	cam_ofs[ 2 ] = CAM_MIN_DIST;
+
+	cam_idealpitch->value = viewangles[ PITCH ];
+	cam_idealyaw->value = viewangles[ YAW ];
+	cam_idealdist->value = CAM_MIN_DIST;
+}
+
+void CAM_StartMouseMove(void)
+{
+	float flSensitivity;
+		
+	//only move the cam with mouse if we are in third person.
+	if (cam_thirdperson)
+	{
+		//set appropriate flags and initialize the old mouse position
+		//variables for mouse camera movement
+		if (!cam_mousemove)
+		{
+			cam_mousemove=1;
+			iMouseInUse=1;
+			GetCursorPos (&cam_mouse);
+
+			if ( ( flSensitivity = gHUD.GetSensitivity() ) != 0 )
+			{
+				cam_old_mouse_x=cam_mouse.x*flSensitivity;
+				cam_old_mouse_y=cam_mouse.y*flSensitivity;
+			}
+			else
+			{
+				cam_old_mouse_x=cam_mouse.x;
+				cam_old_mouse_y=cam_mouse.y;
+			}
+		}
+	}
+	//we are not in 3rd person view..therefore do not allow camera movement
+	else
+	{   
+		cam_mousemove=0;
+		iMouseInUse=0;
+	}
+}
+
+//the key has been released for camera movement
+//tell the engine that mouse camera movement is off
+void CAM_EndMouseMove(void)
+{
+   cam_mousemove=0;
+   iMouseInUse=0;
+}
+
+
+//----------------------------------------------------------
+//routines to start the process of moving the cam in or out 
+//using the mouse
+//----------------------------------------------------------
+void CAM_StartDistance(void)
+{
+	//only move the cam with mouse if we are in third person.
+	if (cam_thirdperson)
+	{
+	  //set appropriate flags and initialize the old mouse position
+	  //variables for mouse camera movement
+	  if (!cam_distancemove)
+	  {
+		  cam_distancemove=1;
+		  cam_mousemove=1;
+		  iMouseInUse=1;
+		  GetCursorPos (&cam_mouse);
+		  cam_old_mouse_x=cam_mouse.x*gHUD.GetSensitivity();
+		  cam_old_mouse_y=cam_mouse.y*gHUD.GetSensitivity();
+	  }
+	}
+	//we are not in 3rd person view..therefore do not allow camera movement
+	else
+	{   
+		cam_distancemove=0;
+		cam_mousemove=0;
+		iMouseInUse=0;
+	}
+}
+
+//the key has been released for camera movement
+//tell the engine that mouse camera movement is off
+void CAM_EndDistance(void)
+{
+   cam_distancemove=0;
+   cam_mousemove=0;
+   iMouseInUse=0;
+}
+
+int DLLEXPORT CL_IsThirdPerson( void )
+{
+	return cam_thirdperson ? 1 : 0;
+}
+
+void DLLEXPORT CL_CameraOffset( float *ofs )
+{
+	VectorCopy( cam_ofs, ofs );
+}

hlsdk/ricochet/cl_dll/in_defs.h

@@ -0,0 +1,28 @@
+/***
+*
+*	Copyright (c) 1999, 2000 Valve LLC. All rights reserved.
+*	
+*	This product contains software technology licensed from Id 
+*	Software, Inc. ("Id Technology").  Id Technology (c) 1996 Id Software, Inc. 
+*	All Rights Reserved.
+*
+*   Use, distribution, and modification of this source code and/or resulting
+*   object code is restricted to non-commercial enhancements to products from
+*   Valve LLC.  All other use, distribution, or modification is prohibited
+*   without written permission from Valve LLC.
+*
+****/
+#if !defined( IN_DEFSH )
+#define IN_DEFSH
+#pragma once
+
+// up / down
+#define	PITCH	0
+// left / right
+#define	YAW		1
+// fall over
+#define	ROLL	2 
+
+#define DLLEXPORT __declspec( dllexport )
+
+#endif

hlsdk/ricochet/cl_dll/input.cpp

@@ -0,0 +1,980 @@
+/***
+*
+*	Copyright (c) 1999, 2000 Valve LLC. All rights reserved.
+*	
+*	This product contains software technology licensed from Id 
+*	Software, Inc. ("Id Technology").  Id Technology (c) 1996 Id Software, Inc. 
+*	All Rights Reserved.
+*
+*   Use, distribution, and modification of this source code and/or resulting
+*   object code is restricted to non-commercial enhancements to products from
+*   Valve LLC.  All other use, distribution, or modification is prohibited
+*   without written permission from Valve LLC.
+*
+****/
+// input.cpp  -- builds an intended movement command to send to the server
+#include "hud.h"
+#include "cl_util.h"
+#include "camera.h"
+extern "C"
+{
+#include "kbutton.h"
+}
+#include "cvardef.h"
+#include "usercmd.h"
+#include "const.h"
+#include "camera.h"
+#include "in_defs.h"
+#include "view.h"
+#include <string.h>
+#include <ctype.h>
+
+#include "vgui_TeamFortressViewport.h"
+#include "vgui_discobjects.h"
+
+// Observer Movement modes (stored in pev->iuser1, so the physics code can get at them)
+#define OBS_CHASE_LOCKED		1
+#define OBS_CHASE_FREE			2
+#define OBS_ROAMING				3	
+#define OBS_LOCKEDVIEW			4
+
+extern "C" 
+{
+	struct kbutton_s DLLEXPORT *KB_Find( const char *name );
+	void DLLEXPORT CL_CreateMove ( float frametime, struct usercmd_s *cmd, int active );
+	void DLLEXPORT HUD_Shutdown( void );
+	int DLLEXPORT HUD_Key_Event( int eventcode, int keynum, const char *pszCurrentBinding );
+}
+
+extern int g_weaponselect;
+extern cl_enginefunc_t gEngfuncs;
+
+// Defined in pm_math.c
+extern "C" float anglemod( float a );
+
+void IN_Init (void);
+void IN_Move ( float frametime, usercmd_t *cmd);
+void IN_Shutdown( void );
+void V_Init( void );
+int CL_ButtonBits( int );
+
+// xxx need client dll function to get and clear impuse
+extern cvar_t *in_joystick;
+
+int	in_impulse	= 0;
+int	in_cancel	= 0;
+
+cvar_t	*m_pitch;
+cvar_t	*m_yaw;
+cvar_t	*m_forward;
+cvar_t	*m_side;
+
+cvar_t	*lookstrafe;
+cvar_t	*lookspring;
+cvar_t	*cl_pitchup;
+cvar_t	*cl_pitchdown;
+cvar_t	*cl_upspeed;
+cvar_t	*cl_forwardspeed;
+cvar_t	*cl_backspeed;
+cvar_t	*cl_sidespeed;
+cvar_t	*cl_movespeedkey;
+cvar_t	*cl_yawspeed;
+cvar_t	*cl_pitchspeed;
+cvar_t	*cl_anglespeedkey;
+cvar_t	*cl_vsmoothing;
+/*
+===============================================================================
+
+KEY BUTTONS
+
+Continuous button event tracking is complicated by the fact that two different
+input sources (say, mouse button 1 and the control key) can both press the
+same button, but the button should only be released when both of the
+pressing key have been released.
+
+When a key event issues a button command (+forward, +attack, etc), it appends
+its key number as a parameter to the command so it can be matched up with
+the release.
+
+state bit 0 is the current state of the key
+state bit 1 is edge triggered on the up to down transition
+state bit 2 is edge triggered on the down to up transition
+
+===============================================================================
+*/
+
+
+kbutton_t	in_mlook;
+kbutton_t	in_klook;
+kbutton_t	in_jlook;
+kbutton_t	in_left;
+kbutton_t	in_right;
+kbutton_t	in_forward;
+kbutton_t	in_back;
+kbutton_t	in_lookup;
+kbutton_t	in_lookdown;
+kbutton_t	in_moveleft;
+kbutton_t	in_moveright;
+kbutton_t	in_strafe;
+kbutton_t	in_speed;
+kbutton_t	in_use;
+kbutton_t	in_jump;
+kbutton_t	in_attack;
+kbutton_t	in_attack2;
+kbutton_t	in_up;
+kbutton_t	in_down;
+kbutton_t	in_duck;
+kbutton_t	in_reload;
+kbutton_t	in_alt1;
+kbutton_t	in_score;
+kbutton_t	in_break;
+kbutton_t	in_graph;  // Display the netgraph
+
+typedef struct kblist_s
+{
+	struct kblist_s *next;
+	kbutton_t *pkey;
+	char name[32];
+} kblist_t;
+
+kblist_t *g_kbkeys = NULL;
+
+/*
+============
+KB_ConvertString
+
+Removes references to +use and replaces them with the keyname in the output string.  If
+ a binding is unfound, then the original text is retained.
+NOTE:  Only works for text with +word in it.
+============
+*/
+int KB_ConvertString( char *in, char **ppout )
+{
+	char sz[ 4096 ];
+	char binding[ 64 ];
+	char *p;
+	char *pOut;
+	char *pEnd;
+	const char *pBinding;
+
+	if ( !ppout )
+		return 0;
+
+	*ppout = NULL;
+	p = in;
+	pOut = sz;
+	while ( *p )
+	{
+		if ( *p == '+' )
+		{
+			pEnd = binding;
+			while ( *p && ( isalnum( *p ) || ( pEnd == binding ) ) && ( ( pEnd - binding ) < 63 ) )
+			{
+				*pEnd++ = *p++;
+			}
+
+			*pEnd =  '\0';
+
+			pBinding = NULL;
+			if ( strlen( binding + 1 ) > 0 )
+			{
+				// See if there is a binding for binding?
+				pBinding = gEngfuncs.Key_LookupBinding( binding + 1 );
+			}
+
+			if ( pBinding )
+			{
+				*pOut++ = '[';
+				pEnd = (char *)pBinding;
+			}
+			else
+			{
+				pEnd = binding;
+			}
+
+			while ( *pEnd )
+			{
+				*pOut++ = *pEnd++;
+			}
+
+			if ( pBinding )
+			{
+				*pOut++ = ']';
+			}
+		}
+		else
+		{
+			*pOut++ = *p++;
+		}
+	}
+
+	*pOut = '\0';
+
+	pOut = ( char * )malloc( strlen( sz ) + 1 );
+	strcpy( pOut, sz );
+	*ppout = pOut;
+
+	return 1;
+}
+
+/*
+============
+KB_Find
+
+Allows the engine to get a kbutton_t directly ( so it can check +mlook state, etc ) for saving out to .cfg files
+============
+*/
+struct kbutton_s DLLEXPORT *KB_Find( const char *name )
+{
+	kblist_t *p;
+	p = g_kbkeys;
+	while ( p )
+	{
+		if ( !stricmp( name, p->name ) )
+			return p->pkey;
+
+		p = p->next;
+	}
+	return NULL;
+}
+
+/*
+============
+KB_Add
+
+Add a kbutton_t * to the list of pointers the engine can retrieve via KB_Find
+============
+*/
+void KB_Add( const char *name, kbutton_t *pkb )
+{
+	kblist_t *p;	
+	kbutton_t *kb;
+
+	kb = KB_Find( name );
+	
+	if ( kb )
+		return;
+
+	p = ( kblist_t * )malloc( sizeof( kblist_t ) );
+	memset( p, 0, sizeof( *p ) );
+
+	strcpy( p->name, name );
+	p->pkey = pkb;
+
+	p->next = g_kbkeys;
+	g_kbkeys = p;
+}
+
+/*
+============
+KB_Init
+
+Add kbutton_t definitions that the engine can query if needed
+============
+*/
+void KB_Init( void )
+{
+	g_kbkeys = NULL;
+
+	KB_Add( "in_graph", &in_graph );
+	KB_Add( "in_mlook", &in_mlook );
+	KB_Add( "in_jlook", &in_jlook );
+}
+
+/*
+============
+KB_Shutdown
+
+Clear kblist
+============
+*/
+void KB_Shutdown( void )
+{
+	kblist_t *p, *n;
+	p = g_kbkeys;
+	while ( p )
+	{
+		n = p->next;
+		free( p );
+		p = n;
+	}
+	g_kbkeys = NULL;
+}
+
+/*
+============
+KeyDown
+============
+*/
+void KeyDown (kbutton_t *b)
+{
+	int		k;
+	char	*c;
+
+	c = gEngfuncs.Cmd_Argv(1);
+	if (c[0])
+		k = atoi(c);
+	else
+		k = -1;		// typed manually at the console for continuous down
+
+	if (k == b->down[0] || k == b->down[1])
+		return;		// repeating key
+	
+	if (!b->down[0])
+		b->down[0] = k;
+	else if (!b->down[1])
+		b->down[1] = k;
+	else
+	{
+		gEngfuncs.Con_DPrintf ("Three keys down for a button '%c' '%c' '%c'!\n", b->down[0], b->down[1], c);
+		return;
+	}
+	
+	if (b->state & 1)
+		return;		// still down
+	b->state |= 1 + 2;	// down + impulse down
+}
+
+/*
+============
+KeyUp
+============
+*/
+void KeyUp (kbutton_t *b)
+{
+	int		k;
+	char	*c;
+	
+	c = gEngfuncs.Cmd_Argv(1);
+	if (c[0])
+		k = atoi(c);
+	else
+	{ // typed manually at the console, assume for unsticking, so clear all
+		b->down[0] = b->down[1] = 0;
+		b->state = 4;	// impulse up
+		return;
+	}
+
+	if (b->down[0] == k)
+		b->down[0] = 0;
+	else if (b->down[1] == k)
+		b->down[1] = 0;
+	else
+		return;		// key up without coresponding down (menu pass through)
+	if (b->down[0] || b->down[1])
+	{
+		return;		// some other key is still holding it down
+	}
+
+	if (!(b->state & 1))
+		return;		// still up (this should not happen)
+
+	b->state &= ~1;		// now up
+	b->state |= 4; 		// impulse up
+}
+/*
+============
+HUD_Key_Event
+
+Return 1 to allow engine to process the key, otherwise, act on it as needed
+============
+*/
+int DLLEXPORT HUD_Key_Event( int down, int keynum, const char *pszCurrentBinding )
+{
+	if (gViewPort)
+		return gViewPort->KeyInput(down, keynum, pszCurrentBinding);
+
+	return 1;
+}
+
+void IN_BreakDown( void ) { KeyDown( &in_break );};
+void IN_BreakUp( void ) { KeyUp( &in_break ); };
+void IN_KLookDown (void) {KeyDown(&in_klook);}
+void IN_KLookUp (void) {KeyUp(&in_klook);}
+void IN_JLookDown (void) {KeyDown(&in_jlook);}
+void IN_JLookUp (void) {KeyUp(&in_jlook);}
+void IN_MLookDown (void) {KeyDown(&in_mlook);}
+void IN_UpDown(void) {KeyDown(&in_up);}
+void IN_UpUp(void) {KeyUp(&in_up);}
+void IN_DownDown(void) {KeyDown(&in_down);}
+void IN_DownUp(void) {KeyUp(&in_down);}
+void IN_LeftDown(void) {KeyDown(&in_left);}
+void IN_LeftUp(void) {KeyUp(&in_left);}
+void IN_RightDown(void) {KeyDown(&in_right);}
+void IN_RightUp(void) {KeyUp(&in_right);}
+void IN_ForwardDown(void) {KeyDown(&in_forward);}
+void IN_ForwardUp(void) {KeyUp(&in_forward);}
+void IN_BackDown(void) {KeyDown(&in_back);}
+void IN_BackUp(void) {KeyUp(&in_back);}
+void IN_LookupDown(void) {KeyDown(&in_lookup);}
+void IN_LookupUp(void) {KeyUp(&in_lookup);}
+void IN_LookdownDown(void) {KeyDown(&in_lookdown);}
+void IN_LookdownUp(void) {KeyUp(&in_lookdown);}
+void IN_MoveleftDown(void) {KeyDown(&in_moveleft);}
+void IN_MoveleftUp(void) {KeyUp(&in_moveleft);}
+void IN_MoverightDown(void) {KeyDown(&in_moveright);}
+void IN_MoverightUp(void) {KeyUp(&in_moveright);}
+void IN_SpeedDown(void) {KeyDown(&in_speed);}
+void IN_SpeedUp(void) {KeyUp(&in_speed);}
+void IN_StrafeDown(void) {KeyDown(&in_strafe);}
+void IN_StrafeUp(void) {KeyUp(&in_strafe);}
+void IN_Attack2Down(void) {KeyDown(&in_attack2);}
+void IN_Attack2Up(void) {KeyUp(&in_attack2);}
+void IN_UseDown (void) {KeyDown(&in_use);}
+void IN_UseUp (void) {KeyUp(&in_use);}
+void IN_JumpDown (void) {KeyDown(&in_jump);}
+void IN_JumpUp (void) {KeyUp(&in_jump);}
+void IN_DuckDown(void) {KeyDown(&in_duck);}
+void IN_DuckUp(void) {KeyUp(&in_duck);}
+void IN_ReloadDown(void) {KeyDown(&in_reload);}
+void IN_ReloadUp(void) {KeyUp(&in_reload);}
+void IN_Alt1Down(void) {KeyDown(&in_alt1);}
+void IN_Alt1Up(void) {KeyUp(&in_alt1);}
+void IN_GraphDown(void) {KeyDown(&in_graph);}
+void IN_GraphUp(void) {KeyUp(&in_graph);}
+
+void IN_AttackDown(void)
+{
+	KeyDown( &in_attack );
+}
+
+void IN_AttackUp(void)
+{
+	KeyUp( &in_attack );
+	in_cancel = 0;
+}
+
+// Special handling
+void IN_Cancel(void)
+{
+	in_cancel = 1;
+}
+
+void IN_Impulse (void)
+{
+	in_impulse = atoi( gEngfuncs.Cmd_Argv(1) );
+}
+
+void IN_ScoreDown(void)
+{
+	KeyDown(&in_score);
+	if ( gViewPort )
+	{
+		gViewPort->ShowScoreBoard();
+	}
+}
+
+void IN_ScoreUp(void)
+{
+	KeyUp(&in_score);
+	if ( gViewPort )
+	{
+		gViewPort->HideScoreBoard();
+	}
+}
+
+void IN_MLookUp (void)
+{
+	KeyUp( &in_mlook );
+	if ( !( in_mlook.state & 1 ) && lookspring->value )
+	{
+		V_StartPitchDrift();
+	}
+}
+
+/*
+===============
+CL_KeyState
+
+Returns 0.25 if a key was pressed and released during the frame,
+0.5 if it was pressed and held
+0 if held then released, and
+1.0 if held for the entire time
+===============
+*/
+float CL_KeyState (kbutton_t *key)
+{
+	float		val = 0.0;
+	int			impulsedown, impulseup, down;
+	
+	impulsedown = key->state & 2;
+	impulseup	= key->state & 4;
+	down		= key->state & 1;
+	
+	if ( impulsedown && !impulseup )
+	{
+		// pressed and held this frame?
+		val = down ? 0.5 : 0.0;
+	}
+
+	if ( impulseup && !impulsedown )
+	{
+		// released this frame?
+		val = down ? 0.0 : 0.0;
+	}
+
+	if ( !impulsedown && !impulseup )
+	{
+		// held the entire frame?
+		val = down ? 1.0 : 0.0;
+	}
+
+	if ( impulsedown && impulseup )
+	{
+		if ( down )
+		{
+			// released and re-pressed this frame
+			val = 0.75;	
+		}
+		else
+		{
+			// pressed and released this frame
+			val = 0.25;	
+		}
+	}
+
+	// clear impulses
+	key->state &= 1;		
+	return val;
+}
+
+bool bCanMoveMouse ( void )
+{
+	if ( gViewPort && ( gViewPort->m_iUser1 == OBS_ROAMING || gViewPort->m_iUser1 == OBS_CHASE_FREE ) )
+		 return TRUE;
+
+	if ( gViewPort && gViewPort->m_iUser1 == OBS_LOCKEDVIEW )
+		 return FALSE;
+
+	return TRUE;
+}
+/*
+================
+CL_AdjustAngles
+
+Moves the local angle positions
+================
+*/
+void CL_AdjustAngles ( float frametime, float *viewangles )
+{
+	float	speed;
+	float	up, down;
+	
+	if (in_speed.state & 1)
+	{
+		speed = frametime * cl_anglespeedkey->value;
+	}
+	else
+	{
+		speed = frametime;
+	}
+
+	// Ricochet: Don't let them move the mouse when they're in spectator mode
+	if ( bCanMoveMouse() == FALSE ) 
+		 return;
+
+	if (!(in_strafe.state & 1))
+	{
+		viewangles[YAW] -= speed*cl_yawspeed->value*CL_KeyState (&in_right);
+		viewangles[YAW] += speed*cl_yawspeed->value*CL_KeyState (&in_left);
+		viewangles[YAW] = anglemod(viewangles[YAW]);
+	}
+	if (in_klook.state & 1)
+	{
+		V_StopPitchDrift ();
+		viewangles[PITCH] -= speed*cl_pitchspeed->value * CL_KeyState (&in_forward);
+		viewangles[PITCH] += speed*cl_pitchspeed->value * CL_KeyState (&in_back);
+	}
+	
+	up = CL_KeyState (&in_lookup);
+	down = CL_KeyState(&in_lookdown);
+	
+	viewangles[PITCH] -= speed*cl_pitchspeed->value * up;
+	viewangles[PITCH] += speed*cl_pitchspeed->value * down;
+
+	if (up || down)
+		V_StopPitchDrift ();
+		
+	if (viewangles[PITCH] > cl_pitchdown->value)
+		viewangles[PITCH] = cl_pitchdown->value;
+	if (viewangles[PITCH] < -cl_pitchup->value)
+		viewangles[PITCH] = -cl_pitchup->value;
+
+	if (viewangles[ROLL] > 50)
+		viewangles[ROLL] = 50;
+	if (viewangles[ROLL] < -50)
+		viewangles[ROLL] = -50;
+}
+
+/*
+================
+CL_CreateMove
+
+Send the intended movement message to the server
+if active == 1 then we are 1) not playing back demos ( where our commands are ignored ) and
+2 ) we have finished signing on to server
+================
+*/
+void DLLEXPORT CL_CreateMove ( float frametime, struct usercmd_s *cmd, int active )
+{	
+	float spd;
+	vec3_t viewangles;
+	static vec3_t oldangles;
+
+	if ( active )
+	{
+		//memset( viewangles, 0, sizeof( vec3_t ) );
+		//viewangles[ 0 ] = viewangles[ 1 ] = viewangles[ 2 ] = 0.0;
+		gEngfuncs.GetViewAngles( (float *)viewangles );
+
+		CL_AdjustAngles ( frametime, viewangles );
+
+		memset (cmd, 0, sizeof(*cmd));
+		
+		gEngfuncs.SetViewAngles( (float *)viewangles );
+
+		if ( in_strafe.state & 1 )
+		{
+			cmd->sidemove += cl_sidespeed->value * CL_KeyState (&in_right);
+			cmd->sidemove -= cl_sidespeed->value * CL_KeyState (&in_left);
+		}
+
+		cmd->sidemove += cl_sidespeed->value * CL_KeyState (&in_moveright);
+		cmd->sidemove -= cl_sidespeed->value * CL_KeyState (&in_moveleft);
+
+		cmd->upmove += cl_upspeed->value * CL_KeyState (&in_up);
+		cmd->upmove -= cl_upspeed->value * CL_KeyState (&in_down);
+
+		if ( !(in_klook.state & 1 ) )
+		{	
+			cmd->forwardmove += cl_forwardspeed->value * CL_KeyState (&in_forward);
+			cmd->forwardmove -= cl_backspeed->value * CL_KeyState (&in_back);
+		}	
+
+		// adjust for speed key
+		if ( in_speed.state & 1 )
+		{
+			cmd->forwardmove *= cl_movespeedkey->value;
+			cmd->sidemove *= cl_movespeedkey->value;
+			cmd->upmove *= cl_movespeedkey->value;
+		}
+
+		// clip to maxspeed
+		spd = gEngfuncs.GetClientMaxspeed();
+		if ( spd != 0.0 )
+		{
+			// scale the 3 speeds so that the total velocity is not > cl.maxspeed
+			float fmov = sqrt( (cmd->forwardmove*cmd->forwardmove) + (cmd->sidemove*cmd->sidemove) + (cmd->upmove*cmd->upmove) );
+
+			if ( fmov > spd )
+			{
+				float fratio = spd / fmov;
+				cmd->forwardmove *= fratio;
+				cmd->sidemove *= fratio;
+				cmd->upmove *= fratio;
+			}
+		}
+
+		// Allow mice and other controllers to add their inputs
+		IN_Move ( frametime, cmd );
+	}
+
+	cmd->impulse = in_impulse;
+	in_impulse = 0;
+
+	cmd->weaponselect = g_weaponselect;
+	g_weaponselect = 0;
+	//
+	// set button and flag bits
+	//
+	cmd->buttons = CL_ButtonBits( 1 );
+
+	// If they're in a modal dialog, ignore the attack button.
+	if( GetClientVoiceMgr()->IsInSquelchMode() )
+		cmd->buttons &= ~IN_ATTACK;
+	
+	// Using joystick?
+	if ( in_joystick->value )
+	{
+		if ( cmd->forwardmove > 0 )
+		{
+			cmd->buttons |= IN_FORWARD;
+		}
+		else if ( cmd->forwardmove < 0 )
+		{
+			cmd->buttons |= IN_BACK;
+		}
+	}
+
+	gEngfuncs.GetViewAngles( (float *)viewangles );
+	// Set current view angles.
+
+	if ( gHUD.m_Health.m_iHealth > 0 )
+	{
+		VectorCopy( viewangles, cmd->viewangles );
+		VectorCopy( viewangles, oldangles );
+	}
+	else
+	{
+		VectorCopy( oldangles, cmd->viewangles );
+	}
+}
+
+/*
+============
+CL_IsDead
+
+Returns 1 if health is <= 0
+============
+*/
+int	CL_IsDead( void )
+{
+	return ( gHUD.m_Health.m_iHealth <= 0 ) ? 1 : 0;
+}
+
+/*
+============
+CL_ButtonBits
+
+Returns appropriate button info for keyboard and mouse state
+Set bResetState to 1 to clear old state info
+============
+*/
+int CL_ButtonBits( int bResetState )
+{
+	int bits = 0;
+
+	if ( in_attack.state & 3 )
+	{
+		bits |= IN_ATTACK;
+	}
+	
+	if (in_duck.state & 3)
+	{
+		bits |= IN_DUCK;
+	}
+ 
+	if (in_jump.state & 3)
+	{
+		bits |= IN_JUMP;
+	}
+
+	if ( in_forward.state & 3 )
+	{
+		bits |= IN_FORWARD;
+	}
+	
+	if (in_back.state & 3)
+	{
+		bits |= IN_BACK;
+	}
+
+	if (in_use.state & 3)
+	{
+		bits |= IN_USE;
+	}
+
+	if (in_cancel)
+	{
+		bits |= IN_CANCEL;
+	}
+
+	if ( in_left.state & 3 )
+	{
+		bits |= IN_LEFT;
+	}
+	
+	if (in_right.state & 3)
+	{
+		bits |= IN_RIGHT;
+	}
+	
+	if ( in_moveleft.state & 3 )
+	{
+		bits |= IN_MOVELEFT;
+	}
+	
+	if (in_moveright.state & 3)
+	{
+		bits |= IN_MOVERIGHT;
+	}
+
+	if (in_attack2.state & 3)
+	{
+		bits |= IN_ATTACK2;
+	}
+
+	if (in_reload.state & 3)
+	{
+		bits |= IN_RELOAD;
+	}
+
+	if (in_alt1.state & 3)
+	{
+		bits |= IN_ALT1;
+	}
+
+	if ( in_score.state & 3 )
+	{
+		bits |= IN_SCORE;
+	}
+
+	// Dead or in intermission? Shore scoreboard, too
+	if ( CL_IsDead() || gHUD.m_iIntermission )
+	{
+		bits |= IN_SCORE;
+	}
+
+	if ( bResetState )
+	{
+		in_attack.state &= ~2;
+		in_duck.state &= ~2;
+		in_jump.state &= ~2;
+		in_forward.state &= ~2;
+		in_back.state &= ~2;
+		in_use.state &= ~2;
+		in_left.state &= ~2;
+		in_right.state &= ~2;
+		in_moveleft.state &= ~2;
+		in_moveright.state &= ~2;
+		in_attack2.state &= ~2;
+		in_reload.state &= ~2;
+		in_alt1.state &= ~2;
+		in_score.state &= ~2;
+	}
+
+	return bits;
+}
+
+/*
+============
+CL_ResetButtonBits
+
+============
+*/
+void CL_ResetButtonBits( int bits )
+{
+	int bitsNew = CL_ButtonBits( 0 ) ^ bits;
+
+	// Has the attack button been changed
+	if ( bitsNew & IN_ATTACK )
+	{
+		// Was it pressed? or let go?
+		if ( bits & IN_ATTACK )
+		{
+			KeyDown( &in_attack );
+		}
+		else
+		{
+			// totally clear state
+			in_attack.state &= ~7;
+		}
+	}
+}
+
+/*
+============
+InitInput
+============
+*/
+void InitInput (void)
+{
+	gEngfuncs.pfnAddCommand ("+moveup",IN_UpDown);
+	gEngfuncs.pfnAddCommand ("-moveup",IN_UpUp);
+	gEngfuncs.pfnAddCommand ("+movedown",IN_DownDown);
+	gEngfuncs.pfnAddCommand ("-movedown",IN_DownUp);
+	gEngfuncs.pfnAddCommand ("+left",IN_LeftDown);
+	gEngfuncs.pfnAddCommand ("-left",IN_LeftUp);
+	gEngfuncs.pfnAddCommand ("+right",IN_RightDown);
+	gEngfuncs.pfnAddCommand ("-right",IN_RightUp);
+	gEngfuncs.pfnAddCommand ("+forward",IN_ForwardDown);
+	gEngfuncs.pfnAddCommand ("-forward",IN_ForwardUp);
+	gEngfuncs.pfnAddCommand ("+back",IN_BackDown);
+	gEngfuncs.pfnAddCommand ("-back",IN_BackUp);
+	gEngfuncs.pfnAddCommand ("+lookup", IN_LookupDown);
+	gEngfuncs.pfnAddCommand ("-lookup", IN_LookupUp);
+	gEngfuncs.pfnAddCommand ("+lookdown", IN_LookdownDown);
+	gEngfuncs.pfnAddCommand ("-lookdown", IN_LookdownUp);
+	gEngfuncs.pfnAddCommand ("+strafe", IN_StrafeDown);
+	gEngfuncs.pfnAddCommand ("-strafe", IN_StrafeUp);
+	gEngfuncs.pfnAddCommand ("+moveleft", IN_MoveleftDown);
+	gEngfuncs.pfnAddCommand ("-moveleft", IN_MoveleftUp);
+	gEngfuncs.pfnAddCommand ("+moveright", IN_MoverightDown);
+	gEngfuncs.pfnAddCommand ("-moveright", IN_MoverightUp);
+	gEngfuncs.pfnAddCommand ("+speed", IN_SpeedDown);
+	gEngfuncs.pfnAddCommand ("-speed", IN_SpeedUp);
+	gEngfuncs.pfnAddCommand ("+attack", IN_AttackDown);
+	gEngfuncs.pfnAddCommand ("-attack", IN_AttackUp);
+	gEngfuncs.pfnAddCommand ("+attack2", IN_Attack2Down);
+	gEngfuncs.pfnAddCommand ("-attack2", IN_Attack2Up);
+	gEngfuncs.pfnAddCommand ("+use", IN_UseDown);
+	gEngfuncs.pfnAddCommand ("-use", IN_UseUp);
+	gEngfuncs.pfnAddCommand ("+jump", IN_JumpDown);
+	gEngfuncs.pfnAddCommand ("-jump", IN_JumpUp);
+	gEngfuncs.pfnAddCommand ("impulse", IN_Impulse);
+	gEngfuncs.pfnAddCommand ("+klook", IN_KLookDown);
+	gEngfuncs.pfnAddCommand ("-klook", IN_KLookUp);
+	gEngfuncs.pfnAddCommand ("+mlook", IN_MLookDown);
+	gEngfuncs.pfnAddCommand ("-mlook", IN_MLookUp);
+	gEngfuncs.pfnAddCommand ("+jlook", IN_JLookDown);
+	gEngfuncs.pfnAddCommand ("-jlook", IN_JLookUp);
+	gEngfuncs.pfnAddCommand ("+duck", IN_DuckDown);
+	gEngfuncs.pfnAddCommand ("-duck", IN_DuckUp);
+	gEngfuncs.pfnAddCommand ("+reload", IN_ReloadDown);
+	gEngfuncs.pfnAddCommand ("-reload", IN_ReloadUp);
+	gEngfuncs.pfnAddCommand ("+alt1", IN_Alt1Down);
+	gEngfuncs.pfnAddCommand ("-alt1", IN_Alt1Up);
+	gEngfuncs.pfnAddCommand ("+score", IN_ScoreDown);
+	gEngfuncs.pfnAddCommand ("-score", IN_ScoreUp);
+	gEngfuncs.pfnAddCommand ("+showscores", IN_ScoreDown);
+	gEngfuncs.pfnAddCommand ("-showscores", IN_ScoreUp);
+	gEngfuncs.pfnAddCommand ("+graph", IN_GraphDown);
+	gEngfuncs.pfnAddCommand ("-graph", IN_GraphUp);
+	gEngfuncs.pfnAddCommand ("+break",IN_BreakDown);
+	gEngfuncs.pfnAddCommand ("-break",IN_BreakUp);
+
+	lookstrafe			= gEngfuncs.pfnRegisterVariable ( "lookstrafe", "0", FCVAR_ARCHIVE );
+	lookspring			= gEngfuncs.pfnRegisterVariable ( "lookspring", "0", FCVAR_ARCHIVE );
+	cl_anglespeedkey	= gEngfuncs.pfnRegisterVariable ( "cl_anglespeedkey", "0.67", 0 );
+	cl_yawspeed			= gEngfuncs.pfnRegisterVariable ( "cl_yawspeed", "210", 0 );
+	cl_pitchspeed		= gEngfuncs.pfnRegisterVariable ( "cl_pitchspeed", "225", 0 );
+	cl_upspeed			= gEngfuncs.pfnRegisterVariable ( "cl_upspeed", "320", 0 );
+	cl_forwardspeed		= gEngfuncs.pfnRegisterVariable ( "cl_forwardspeed", "400", FCVAR_ARCHIVE );
+	cl_backspeed		= gEngfuncs.pfnRegisterVariable ( "cl_backspeed", "400", FCVAR_ARCHIVE );
+	cl_sidespeed		= gEngfuncs.pfnRegisterVariable ( "cl_sidespeed", "400", 0 );
+	cl_movespeedkey		= gEngfuncs.pfnRegisterVariable ( "cl_movespeedkey", "0.3", 0 );
+	cl_pitchup			= gEngfuncs.pfnRegisterVariable ( "cl_pitchup", "89", 0 );
+	cl_pitchdown		= gEngfuncs.pfnRegisterVariable ( "cl_pitchdown", "89", 0 );
+
+	cl_vsmoothing		= gEngfuncs.pfnRegisterVariable ( "cl_vsmoothing", "0.05", FCVAR_ARCHIVE );
+
+	m_pitch			    = gEngfuncs.pfnRegisterVariable ( "m_pitch","0.022", FCVAR_ARCHIVE );
+	m_yaw				= gEngfuncs.pfnRegisterVariable ( "m_yaw","0.022", FCVAR_ARCHIVE );
+	m_forward			= gEngfuncs.pfnRegisterVariable ( "m_forward","1", FCVAR_ARCHIVE );
+	m_side				= gEngfuncs.pfnRegisterVariable ( "m_side","0.8", FCVAR_ARCHIVE );
+
+	// Initialize third person camera controls.
+	CAM_Init();
+	// Initialize inputs
+	IN_Init();
+	// Initialize keyboard
+	KB_Init();
+	// Initialize view system
+	V_Init();
+}
+
+/*
+============
+ShutdownInput
+============
+*/
+void ShutdownInput (void)
+{
+	IN_Shutdown();
+	KB_Shutdown();
+}
+
+void DLLEXPORT HUD_Shutdown( void )
+{
+	ShutdownInput();
+}

hlsdk/ricochet/cl_dll/inputw32.cpp

@@ -0,0 +1,958 @@
+/***
+*
+*	Copyright (c) 1999, 2000 Valve LLC. All rights reserved.
+*	
+*	This product contains software technology licensed from Id 
+*	Software, Inc. ("Id Technology").  Id Technology (c) 1996 Id Software, Inc. 
+*	All Rights Reserved.
+*
+*   Use, distribution, and modification of this source code and/or resulting
+*   object code is restricted to non-commercial enhancements to products from
+*   Valve LLC.  All other use, distribution, or modification is prohibited
+*   without written permission from Valve LLC.
+*
+****/
+// inputw32.cpp-- windows 95/98/nt mouse and joystick code
+#include "hud.h"
+#include "cl_util.h"
+#include "camera.h"
+#include "kbutton.h"
+#include "cvardef.h"
+#include "usercmd.h"
+#include "const.h"
+#include "camera.h"
+#include "in_defs.h"
+#include "../engine/keydefs.h"
+#include "view.h"
+#include "windows.h"
+#include "vgui_TeamFortressViewport.h"
+
+#define MOUSE_BUTTON_COUNT 5
+
+// Set this to 1 to show mouse cursor.  Experimental
+int	g_iVisibleMouse = 0;
+
+extern "C" 
+{
+	void DLLEXPORT IN_ActivateMouse( void );
+	void DLLEXPORT IN_DeactivateMouse( void );
+	void DLLEXPORT IN_MouseEvent (int mstate);
+	void DLLEXPORT IN_Accumulate (void);
+	void DLLEXPORT IN_ClearStates (void);
+}
+
+extern cl_enginefunc_t gEngfuncs;
+
+extern int iMouseInUse;
+
+extern kbutton_t	in_strafe;
+extern kbutton_t	in_mlook;
+extern kbutton_t	in_speed;
+extern kbutton_t	in_jlook;
+
+extern cvar_t	*m_pitch;
+extern cvar_t	*m_yaw;
+extern cvar_t	*m_forward;
+extern cvar_t	*m_side;
+
+extern cvar_t *lookstrafe;
+extern cvar_t *lookspring;
+extern cvar_t *cl_pitchdown;
+extern cvar_t *cl_pitchup;
+extern cvar_t *cl_yawspeed;
+extern cvar_t *cl_sidespeed;
+extern cvar_t *cl_forwardspeed;
+extern cvar_t *cl_pitchspeed;
+extern cvar_t *cl_movespeedkey;
+
+// mouse variables
+cvar_t		*m_filter;
+cvar_t		*sensitivity;
+
+int			mouse_buttons;
+int			mouse_oldbuttonstate;
+POINT		current_pos;
+int			mouse_x, mouse_y, old_mouse_x, old_mouse_y, mx_accum, my_accum;
+
+static int	restore_spi;
+static int	originalmouseparms[3], newmouseparms[3] = {0, 0, 1};
+static int	mouseactive;
+int			mouseinitialized;
+static int	mouseparmsvalid;
+static int	mouseshowtoggle = 1;
+
+// joystick defines and variables
+// where should defines be moved?
+#define JOY_ABSOLUTE_AXIS	0x00000000		// control like a joystick
+#define JOY_RELATIVE_AXIS	0x00000010		// control like a mouse, spinner, trackball
+#define	JOY_MAX_AXES		6				// X, Y, Z, R, U, V
+#define JOY_AXIS_X			0
+#define JOY_AXIS_Y			1
+#define JOY_AXIS_Z			2
+#define JOY_AXIS_R			3
+#define JOY_AXIS_U			4
+#define JOY_AXIS_V			5
+
+enum _ControlList
+{
+	AxisNada = 0,
+	AxisForward,
+	AxisLook,
+	AxisSide,
+	AxisTurn
+};
+
+DWORD dwAxisFlags[JOY_MAX_AXES] =
+{
+	JOY_RETURNX,
+	JOY_RETURNY,
+	JOY_RETURNZ,
+	JOY_RETURNR,
+	JOY_RETURNU,
+	JOY_RETURNV
+};
+
+DWORD	dwAxisMap[ JOY_MAX_AXES ];
+DWORD	dwControlMap[ JOY_MAX_AXES ];
+PDWORD	pdwRawValue[ JOY_MAX_AXES ];
+
+// none of these cvars are saved over a session
+// this means that advanced controller configuration needs to be executed
+// each time.  this avoids any problems with getting back to a default usage
+// or when changing from one controller to another.  this way at least something
+// works.
+cvar_t	*in_joystick;
+cvar_t	*joy_name;
+cvar_t	*joy_advanced;
+cvar_t	*joy_advaxisx;
+cvar_t	*joy_advaxisy;
+cvar_t	*joy_advaxisz;
+cvar_t	*joy_advaxisr;
+cvar_t	*joy_advaxisu;
+cvar_t	*joy_advaxisv;
+cvar_t	*joy_forwardthreshold;
+cvar_t	*joy_sidethreshold;
+cvar_t	*joy_pitchthreshold;
+cvar_t	*joy_yawthreshold;
+cvar_t	*joy_forwardsensitivity;
+cvar_t	*joy_sidesensitivity;
+cvar_t	*joy_pitchsensitivity;
+cvar_t	*joy_yawsensitivity;
+cvar_t	*joy_wwhack1;
+cvar_t	*joy_wwhack2;
+
+int			joy_avail, joy_advancedinit, joy_haspov;
+DWORD		joy_oldbuttonstate, joy_oldpovstate;
+
+int			joy_id;
+DWORD		joy_flags;
+DWORD		joy_numbuttons;
+
+static JOYINFOEX	ji;
+
+/*
+===========
+Force_CenterView_f
+===========
+*/
+void Force_CenterView_f (void)
+{
+	vec3_t viewangles;
+
+	if (!iMouseInUse)
+	{
+		gEngfuncs.GetViewAngles( (float *)viewangles );
+	    viewangles[PITCH] = 0;
+		gEngfuncs.SetViewAngles( (float *)viewangles );
+	}
+}
+
+/*
+===========
+IN_ActivateMouse
+===========
+*/
+void DLLEXPORT IN_ActivateMouse (void)
+{
+	if (mouseinitialized)
+	{
+		if (mouseparmsvalid)
+			restore_spi = SystemParametersInfo (SPI_SETMOUSE, 0, newmouseparms, 0);
+		mouseactive = 1;
+	}
+}
+
+/*
+===========
+IN_DeactivateMouse
+===========
+*/
+void DLLEXPORT IN_DeactivateMouse (void)
+{
+	if (mouseinitialized)
+	{
+		if (restore_spi)
+			SystemParametersInfo (SPI_SETMOUSE, 0, originalmouseparms, 0);
+
+		mouseactive = 0;
+	}
+}
+
+/*
+===========
+IN_StartupMouse
+===========
+*/
+void IN_StartupMouse (void)
+{
+	if ( gEngfuncs.CheckParm ("-nomouse", NULL ) ) 
+		return; 
+
+	mouseinitialized = 1;
+	mouseparmsvalid = SystemParametersInfo (SPI_GETMOUSE, 0, originalmouseparms, 0);
+
+	if (mouseparmsvalid)
+	{
+		if ( gEngfuncs.CheckParm ("-noforcemspd", NULL ) ) 
+			newmouseparms[2] = originalmouseparms[2];
+
+		if ( gEngfuncs.CheckParm ("-noforcemaccel", NULL ) ) 
+		{
+			newmouseparms[0] = originalmouseparms[0];
+			newmouseparms[1] = originalmouseparms[1];
+		}
+
+		if ( gEngfuncs.CheckParm ("-noforcemparms", NULL ) ) 
+		{
+			newmouseparms[0] = originalmouseparms[0];
+			newmouseparms[1] = originalmouseparms[1];
+			newmouseparms[2] = originalmouseparms[2];
+		}
+	}
+
+	mouse_buttons = MOUSE_BUTTON_COUNT;
+}
+
+/*
+===========
+IN_Shutdown
+===========
+*/
+void IN_Shutdown (void)
+{
+	IN_DeactivateMouse ();
+}
+
+/*
+===========
+IN_GetMousePos
+
+Ask for mouse position from engine
+===========
+*/
+void IN_GetMousePos( int *mx, int *my )
+{
+	gEngfuncs.GetMousePosition( mx, my );
+}
+
+/*
+===========
+IN_ResetMouse
+
+FIXME: Call through to engine?
+===========
+*/
+void IN_ResetMouse( void )
+{
+	SetCursorPos ( gEngfuncs.GetWindowCenterX(), gEngfuncs.GetWindowCenterY() );	
+}
+
+/*
+===========
+IN_MouseEvent
+===========
+*/
+void DLLEXPORT IN_MouseEvent (int mstate)
+{
+	int		i;
+
+	if ( iMouseInUse || g_iVisibleMouse )
+		return;
+
+	// perform button actions
+	for (i=0 ; i<mouse_buttons ; i++)
+	{
+		if ( (mstate & (1<<i)) &&
+			!(mouse_oldbuttonstate & (1<<i)) )
+		{
+			gEngfuncs.Key_Event (K_MOUSE1 + i, 1);
+		}
+
+		if ( !(mstate & (1<<i)) &&
+			(mouse_oldbuttonstate & (1<<i)) )
+		{
+			gEngfuncs.Key_Event (K_MOUSE1 + i, 0);
+		}
+	}	
+	
+	mouse_oldbuttonstate = mstate;
+}
+
+bool bCanMoveMouse ( void );
+
+/*
+===========
+IN_MouseMove
+===========
+*/
+void IN_MouseMove ( float frametime, usercmd_t *cmd)
+{
+	int		mx, my;
+	vec3_t viewangles;
+
+	gEngfuncs.GetViewAngles( (float *)viewangles );
+
+	// Ricochet: Don't let them move the mouse when they're in spectator mode
+	int iSpectator = !bCanMoveMouse();
+
+	//jjb - this disbles normal mouse control if the user is trying to 
+	//      move the camera
+	if ( !iMouseInUse && !g_iVisibleMouse && !iSpectator )
+	{
+		GetCursorPos (&current_pos);
+
+		mx = current_pos.x - gEngfuncs.GetWindowCenterX() + mx_accum;
+		my = current_pos.y - gEngfuncs.GetWindowCenterY() + my_accum; 
+
+		mx_accum = 0;
+		my_accum = 0;
+
+		if (m_filter->value)
+		{
+			mouse_x = (mx + old_mouse_x) * 0.5;
+			mouse_y = (my + old_mouse_y) * 0.5;
+		}
+		else
+		{
+			mouse_x = mx;
+			mouse_y = my;
+		}
+
+		old_mouse_x = mx;
+		old_mouse_y = my;
+
+		if ( gHUD.GetSensitivity() != 0 )
+		{
+			mouse_x *= gHUD.GetSensitivity();
+			mouse_y *= gHUD.GetSensitivity();
+		}
+		else
+		{
+			mouse_x *= sensitivity->value;
+			mouse_y *= sensitivity->value;
+		}
+
+		// add mouse X/Y movement to cmd
+		if ( (in_strafe.state & 1) || (lookstrafe->value && (in_mlook.state & 1) ))
+			cmd->sidemove += m_side->value * mouse_x;
+		else
+			viewangles[YAW] -= m_yaw->value * mouse_x;
+
+		if ( in_mlook.state & 1)
+		{
+			V_StopPitchDrift ();
+		}
+		
+		if ( (in_mlook.state & 1) && !(in_strafe.state & 1))
+		{
+			viewangles[PITCH] += m_pitch->value * mouse_y;
+			if (viewangles[PITCH] > cl_pitchdown->value)
+				viewangles[PITCH] = cl_pitchdown->value;
+			if (viewangles[PITCH] < -cl_pitchup->value)
+				viewangles[PITCH] = -cl_pitchup->value;
+		}
+		else
+		{
+			if ((in_strafe.state & 1) && gEngfuncs.IsNoClipping() )
+			{
+				cmd->upmove -= m_forward->value * mouse_y;
+			}
+			else
+			{
+				cmd->forwardmove -= m_forward->value * mouse_y;
+			}
+		}
+
+		// if the mouse has moved, force it to the center, so there's room to move
+		if ( mx || my )
+		{
+			IN_ResetMouse();
+		}
+	}
+
+	gEngfuncs.SetViewAngles( (float *)viewangles );
+
+/*
+//#define TRACE_TEST
+#if defined( TRACE_TEST )
+	{
+		int mx, my;
+		void V_Move( int mx, int my );
+		IN_GetMousePos( &mx, &my );
+		V_Move( mx, my );
+	}
+#endif
+*/
+}
+
+/*
+===========
+IN_Accumulate
+===========
+*/
+void DLLEXPORT IN_Accumulate (void)
+{
+	//only accumulate mouse if we are not moving the camera with the mouse
+	if ( !iMouseInUse && !g_iVisibleMouse )
+	{
+	    if (mouseactive)
+	    {
+			GetCursorPos (&current_pos);
+
+			mx_accum += current_pos.x - gEngfuncs.GetWindowCenterX();
+			my_accum += current_pos.y - gEngfuncs.GetWindowCenterY();
+
+			// force the mouse to the center, so there's room to move
+			IN_ResetMouse();
+		}
+	}
+
+}
+
+/*
+===================
+IN_ClearStates
+===================
+*/
+void DLLEXPORT IN_ClearStates (void)
+{
+	if ( !mouseactive )
+		return;
+
+	mx_accum = 0;
+	my_accum = 0;
+	mouse_oldbuttonstate = 0;
+}
+
+/* 
+=============== 
+IN_StartupJoystick 
+=============== 
+*/  
+void IN_StartupJoystick (void) 
+{ 
+	int			numdevs;
+	JOYCAPS		jc;
+	MMRESULT	mmr;
+ 
+ 	// assume no joystick
+	joy_avail = 0; 
+
+	// abort startup if user requests no joystick
+	if ( gEngfuncs.CheckParm ("-nojoy", NULL ) ) 
+		return; 
+ 
+	// verify joystick driver is present
+	if ((numdevs = joyGetNumDevs ()) == 0)
+	{
+		gEngfuncs.Con_DPrintf ("joystick not found -- driver not present\n\n");
+		return;
+	}
+
+	// cycle through the joystick ids for the first valid one
+	for (joy_id=0 ; joy_id<numdevs ; joy_id++)
+	{
+		memset (&ji, 0, sizeof(ji));
+		ji.dwSize = sizeof(ji);
+		ji.dwFlags = JOY_RETURNCENTERED;
+
+		if ((mmr = joyGetPosEx (joy_id, &ji)) == JOYERR_NOERROR)
+			break;
+	} 
+
+	// abort startup if we didn't find a valid joystick
+	if (mmr != JOYERR_NOERROR)
+	{
+		gEngfuncs.Con_DPrintf ("joystick not found -- no valid joysticks (%x)\n\n", mmr);
+		return;
+	}
+
+	// get the capabilities of the selected joystick
+	// abort startup if command fails
+	memset (&jc, 0, sizeof(jc));
+	if ((mmr = joyGetDevCaps (joy_id, &jc, sizeof(jc))) != JOYERR_NOERROR)
+	{
+		gEngfuncs.Con_DPrintf ("joystick not found -- invalid joystick capabilities (%x)\n\n", mmr); 
+		return;
+	}
+
+	// save the joystick's number of buttons and POV status
+	joy_numbuttons = jc.wNumButtons;
+	joy_haspov = jc.wCaps & JOYCAPS_HASPOV;
+
+	// old button and POV states default to no buttons pressed
+	joy_oldbuttonstate = joy_oldpovstate = 0;
+
+	// mark the joystick as available and advanced initialization not completed
+	// this is needed as cvars are not available during initialization
+	gEngfuncs.Con_Printf ("joystick found\n\n", mmr); 
+	joy_avail = 1; 
+	joy_advancedinit = 0;
+}
+
+
+/*
+===========
+RawValuePointer
+===========
+*/
+PDWORD RawValuePointer (int axis)
+{
+	switch (axis)
+	{
+	case JOY_AXIS_X:
+		return &ji.dwXpos;
+	case JOY_AXIS_Y:
+		return &ji.dwYpos;
+	case JOY_AXIS_Z:
+		return &ji.dwZpos;
+	case JOY_AXIS_R:
+		return &ji.dwRpos;
+	case JOY_AXIS_U:
+		return &ji.dwUpos;
+	case JOY_AXIS_V:
+		return &ji.dwVpos;
+	}
+	// FIX: need to do some kind of error
+	return &ji.dwXpos;
+}
+
+
+/*
+===========
+Joy_AdvancedUpdate_f
+===========
+*/
+void Joy_AdvancedUpdate_f (void)
+{
+
+	// called once by IN_ReadJoystick and by user whenever an update is needed
+	// cvars are now available
+	int	i;
+	DWORD dwTemp;
+
+	// initialize all the maps
+	for (i = 0; i < JOY_MAX_AXES; i++)
+	{
+		dwAxisMap[i] = AxisNada;
+		dwControlMap[i] = JOY_ABSOLUTE_AXIS;
+		pdwRawValue[i] = RawValuePointer(i);
+	}
+
+	if( joy_advanced->value == 0.0)
+	{
+		// default joystick initialization
+		// 2 axes only with joystick control
+		dwAxisMap[JOY_AXIS_X] = AxisTurn;
+		// dwControlMap[JOY_AXIS_X] = JOY_ABSOLUTE_AXIS;
+		dwAxisMap[JOY_AXIS_Y] = AxisForward;
+		// dwControlMap[JOY_AXIS_Y] = JOY_ABSOLUTE_AXIS;
+	}
+	else
+	{
+		if ( strcmp ( joy_name->string, "joystick") != 0 )
+		{
+			// notify user of advanced controller
+			gEngfuncs.Con_Printf ("\n%s configured\n\n", joy_name->string);
+		}
+
+		// advanced initialization here
+		// data supplied by user via joy_axisn cvars
+		dwTemp = (DWORD) joy_advaxisx->value;
+		dwAxisMap[JOY_AXIS_X] = dwTemp & 0x0000000f;
+		dwControlMap[JOY_AXIS_X] = dwTemp & JOY_RELATIVE_AXIS;
+		dwTemp = (DWORD) joy_advaxisy->value;
+		dwAxisMap[JOY_AXIS_Y] = dwTemp & 0x0000000f;
+		dwControlMap[JOY_AXIS_Y] = dwTemp & JOY_RELATIVE_AXIS;
+		dwTemp = (DWORD) joy_advaxisz->value;
+		dwAxisMap[JOY_AXIS_Z] = dwTemp & 0x0000000f;
+		dwControlMap[JOY_AXIS_Z] = dwTemp & JOY_RELATIVE_AXIS;
+		dwTemp = (DWORD) joy_advaxisr->value;
+		dwAxisMap[JOY_AXIS_R] = dwTemp & 0x0000000f;
+		dwControlMap[JOY_AXIS_R] = dwTemp & JOY_RELATIVE_AXIS;
+		dwTemp = (DWORD) joy_advaxisu->value;
+		dwAxisMap[JOY_AXIS_U] = dwTemp & 0x0000000f;
+		dwControlMap[JOY_AXIS_U] = dwTemp & JOY_RELATIVE_AXIS;
+		dwTemp = (DWORD) joy_advaxisv->value;
+		dwAxisMap[JOY_AXIS_V] = dwTemp & 0x0000000f;
+		dwControlMap[JOY_AXIS_V] = dwTemp & JOY_RELATIVE_AXIS;
+	}
+
+	// compute the axes to collect from DirectInput
+	joy_flags = JOY_RETURNCENTERED | JOY_RETURNBUTTONS | JOY_RETURNPOV;
+	for (i = 0; i < JOY_MAX_AXES; i++)
+	{
+		if (dwAxisMap[i] != AxisNada)
+		{
+			joy_flags |= dwAxisFlags[i];
+		}
+	}
+}
+
+
+/*
+===========
+IN_Commands
+===========
+*/
+void IN_Commands (void)
+{
+	int		i, key_index;
+	DWORD	buttonstate, povstate;
+
+	if (!joy_avail)
+	{
+		return;
+	}
+
+	
+	// loop through the joystick buttons
+	// key a joystick event or auxillary event for higher number buttons for each state change
+	buttonstate = ji.dwButtons;
+	for (i=0 ; i < (int)joy_numbuttons ; i++)
+	{
+		if ( (buttonstate & (1<<i)) && !(joy_oldbuttonstate & (1<<i)) )
+		{
+			key_index = (i < 4) ? K_JOY1 : K_AUX1;
+			gEngfuncs.Key_Event (key_index + i, 1);
+		}
+
+		if ( !(buttonstate & (1<<i)) && (joy_oldbuttonstate & (1<<i)) )
+		{
+			key_index = (i < 4) ? K_JOY1 : K_AUX1;
+			gEngfuncs.Key_Event (key_index + i, 0);
+		}
+	}
+	joy_oldbuttonstate = buttonstate;
+
+	if (joy_haspov)
+	{
+		// convert POV information into 4 bits of state information
+		// this avoids any potential problems related to moving from one
+		// direction to another without going through the center position
+		povstate = 0;
+		if(ji.dwPOV != JOY_POVCENTERED)
+		{
+			if (ji.dwPOV == JOY_POVFORWARD)
+				povstate |= 0x01;
+			if (ji.dwPOV == JOY_POVRIGHT)
+				povstate |= 0x02;
+			if (ji.dwPOV == JOY_POVBACKWARD)
+				povstate |= 0x04;
+			if (ji.dwPOV == JOY_POVLEFT)
+				povstate |= 0x08;
+		}
+		// determine which bits have changed and key an auxillary event for each change
+		for (i=0 ; i < 4 ; i++)
+		{
+			if ( (povstate & (1<<i)) && !(joy_oldpovstate & (1<<i)) )
+			{
+				gEngfuncs.Key_Event (K_AUX29 + i, 1);
+			}
+
+			if ( !(povstate & (1<<i)) && (joy_oldpovstate & (1<<i)) )
+			{
+				gEngfuncs.Key_Event (K_AUX29 + i, 0);
+			}
+		}
+		joy_oldpovstate = povstate;
+	}
+}
+
+
+/* 
+=============== 
+IN_ReadJoystick
+=============== 
+*/  
+int IN_ReadJoystick (void)
+{
+
+	memset (&ji, 0, sizeof(ji));
+	ji.dwSize = sizeof(ji);
+	ji.dwFlags = joy_flags;
+
+	if (joyGetPosEx (joy_id, &ji) == JOYERR_NOERROR)
+	{
+		// this is a hack -- there is a bug in the Logitech WingMan Warrior DirectInput Driver
+		// rather than having 32768 be the zero point, they have the zero point at 32668
+		// go figure -- anyway, now we get the full resolution out of the device
+		if (joy_wwhack1->value != 0.0)
+		{
+			ji.dwUpos += 100;
+		}
+		return 1;
+	}
+	else
+	{
+		// read error occurred
+		// turning off the joystick seems too harsh for 1 read error,\
+		// but what should be done?
+		// Con_Printf ("IN_ReadJoystick: no response\n");
+		// joy_avail = 0;
+		return 0;
+	}
+}
+
+
+/*
+===========
+IN_JoyMove
+===========
+*/
+void IN_JoyMove ( float frametime, usercmd_t *cmd )
+{
+	float	speed, aspeed;
+	float	fAxisValue, fTemp;
+	int		i;
+	vec3_t viewangles;
+
+	gEngfuncs.GetViewAngles( (float *)viewangles );
+
+
+	// complete initialization if first time in
+	// this is needed as cvars are not available at initialization time
+	if( joy_advancedinit != 1 )
+	{
+		Joy_AdvancedUpdate_f();
+		joy_advancedinit = 1;
+	}
+
+	// verify joystick is available and that the user wants to use it
+	if (!joy_avail || !in_joystick->value)
+	{
+		return; 
+	}
+ 
+	// collect the joystick data, if possible
+	if (IN_ReadJoystick () != 1)
+	{
+		return;
+	}
+
+	if (in_speed.state & 1)
+		speed = cl_movespeedkey->value;
+	else
+		speed = 1;
+
+	aspeed = speed * frametime;
+
+	// loop through the axes
+	for (i = 0; i < JOY_MAX_AXES; i++)
+	{
+		// get the floating point zero-centered, potentially-inverted data for the current axis
+		fAxisValue = (float) *pdwRawValue[i];
+		// move centerpoint to zero
+		fAxisValue -= 32768.0;
+
+		if (joy_wwhack2->value != 0.0)
+		{
+			if (dwAxisMap[i] == AxisTurn)
+			{
+				// this is a special formula for the Logitech WingMan Warrior
+				// y=ax^b; where a = 300 and b = 1.3
+				// also x values are in increments of 800 (so this is factored out)
+				// then bounds check result to level out excessively high spin rates
+				fTemp = 300.0 * pow(abs(fAxisValue) / 800.0, 1.3);
+				if (fTemp > 14000.0)
+					fTemp = 14000.0;
+				// restore direction information
+				fAxisValue = (fAxisValue > 0.0) ? fTemp : -fTemp;
+			}
+		}
+
+		// convert range from -32768..32767 to -1..1 
+		fAxisValue /= 32768.0;
+
+		switch (dwAxisMap[i])
+		{
+		case AxisForward:
+			if ((joy_advanced->value == 0.0) && (in_jlook.state & 1))
+			{
+				// user wants forward control to become look control
+				if (fabs(fAxisValue) > joy_pitchthreshold->value)
+				{		
+					// if mouse invert is on, invert the joystick pitch value
+					// only absolute control support here (joy_advanced is 0)
+					if (m_pitch->value < 0.0)
+					{
+						viewangles[PITCH] -= (fAxisValue * joy_pitchsensitivity->value) * aspeed * cl_pitchspeed->value;
+					}
+					else
+					{
+						viewangles[PITCH] += (fAxisValue * joy_pitchsensitivity->value) * aspeed * cl_pitchspeed->value;
+					}
+					V_StopPitchDrift();
+				}
+				else
+				{
+					// no pitch movement
+					// disable pitch return-to-center unless requested by user
+					// *** this code can be removed when the lookspring bug is fixed
+					// *** the bug always has the lookspring feature on
+					if(lookspring->value == 0.0)
+					{
+						V_StopPitchDrift();
+					}
+				}
+			}
+			else
+			{
+				// user wants forward control to be forward control
+				if (fabs(fAxisValue) > joy_forwardthreshold->value)
+				{
+					cmd->forwardmove += (fAxisValue * joy_forwardsensitivity->value) * speed * cl_forwardspeed->value;
+				}
+			}
+			break;
+
+		case AxisSide:
+			if (fabs(fAxisValue) > joy_sidethreshold->value)
+			{
+				cmd->sidemove += (fAxisValue * joy_sidesensitivity->value) * speed * cl_sidespeed->value;
+			}
+			break;
+
+		case AxisTurn:
+			if ((in_strafe.state & 1) || (lookstrafe->value && (in_jlook.state & 1)))
+			{
+				// user wants turn control to become side control
+				if (fabs(fAxisValue) > joy_sidethreshold->value)
+				{
+					cmd->sidemove -= (fAxisValue * joy_sidesensitivity->value) * speed * cl_sidespeed->value;
+				}
+			}
+			else
+			{
+				// user wants turn control to be turn control
+				if (fabs(fAxisValue) > joy_yawthreshold->value)
+				{
+					if(dwControlMap[i] == JOY_ABSOLUTE_AXIS)
+					{
+						viewangles[YAW] += (fAxisValue * joy_yawsensitivity->value) * aspeed * cl_yawspeed->value;
+					}
+					else
+					{
+						viewangles[YAW] += (fAxisValue * joy_yawsensitivity->value) * speed * 180.0;
+					}
+
+				}
+			}
+			break;
+
+		case AxisLook:
+			if (in_jlook.state & 1)
+			{
+				if (fabs(fAxisValue) > joy_pitchthreshold->value)
+				{
+					// pitch movement detected and pitch movement desired by user
+					if(dwControlMap[i] == JOY_ABSOLUTE_AXIS)
+					{
+						viewangles[PITCH] += (fAxisValue * joy_pitchsensitivity->value) * aspeed * cl_pitchspeed->value;
+					}
+					else
+					{
+						viewangles[PITCH] += (fAxisValue * joy_pitchsensitivity->value) * speed * 180.0;
+					}
+					V_StopPitchDrift();
+				}
+				else
+				{
+					// no pitch movement
+					// disable pitch return-to-center unless requested by user
+					// *** this code can be removed when the lookspring bug is fixed
+					// *** the bug always has the lookspring feature on
+					if( lookspring->value == 0.0 )
+					{
+						V_StopPitchDrift();
+					}
+				}
+			}
+			break;
+
+		default:
+			break;
+		}
+	}
+
+	// bounds check pitch
+	if (viewangles[PITCH] > cl_pitchdown->value)
+		viewangles[PITCH] = cl_pitchdown->value;
+	if (viewangles[PITCH] < -cl_pitchup->value)
+		viewangles[PITCH] = -cl_pitchup->value;
+
+	gEngfuncs.SetViewAngles( (float *)viewangles );
+
+}
+
+/*
+===========
+IN_Move
+===========
+*/
+void IN_Move ( float frametime, usercmd_t *cmd)
+{
+	if ( !iMouseInUse && mouseactive )
+	{
+		IN_MouseMove ( frametime, cmd);
+	}
+
+	IN_JoyMove ( frametime, cmd);
+}
+
+/*
+===========
+IN_Init
+===========
+*/
+void IN_Init (void)
+{
+	m_filter				= gEngfuncs.pfnRegisterVariable ( "m_filter","0", FCVAR_ARCHIVE );
+	sensitivity				= gEngfuncs.pfnRegisterVariable ( "sensitivity","3", FCVAR_ARCHIVE ); // user mouse sensitivity setting.
+
+	in_joystick				= gEngfuncs.pfnRegisterVariable ( "joystick","0", FCVAR_ARCHIVE );
+	joy_name				= gEngfuncs.pfnRegisterVariable ( "joyname", "joystick", 0 );
+	joy_advanced			= gEngfuncs.pfnRegisterVariable ( "joyadvanced", "0", 0 );
+	joy_advaxisx			= gEngfuncs.pfnRegisterVariable ( "joyadvaxisx", "0", 0 );
+	joy_advaxisy			= gEngfuncs.pfnRegisterVariable ( "joyadvaxisy", "0", 0 );
+	joy_advaxisz			= gEngfuncs.pfnRegisterVariable ( "joyadvaxisz", "0", 0 );
+	joy_advaxisr			= gEngfuncs.pfnRegisterVariable ( "joyadvaxisr", "0", 0 );
+	joy_advaxisu			= gEngfuncs.pfnRegisterVariable ( "joyadvaxisu", "0", 0 );
+	joy_advaxisv			= gEngfuncs.pfnRegisterVariable ( "joyadvaxisv", "0", 0 );
+	joy_forwardthreshold	= gEngfuncs.pfnRegisterVariable ( "joyforwardthreshold", "0.15", 0 );
+	joy_sidethreshold		= gEngfuncs.pfnRegisterVariable ( "joysidethreshold", "0.15", 0 );
+	joy_pitchthreshold		= gEngfuncs.pfnRegisterVariable ( "joypitchthreshold", "0.15", 0 );
+	joy_yawthreshold		= gEngfuncs.pfnRegisterVariable ( "joyyawthreshold", "0.15", 0 );
+	joy_forwardsensitivity	= gEngfuncs.pfnRegisterVariable ( "joyforwardsensitivity", "-1.0", 0 );
+	joy_sidesensitivity		= gEngfuncs.pfnRegisterVariable ( "joysidesensitivity", "-1.0", 0 );
+	joy_pitchsensitivity	= gEngfuncs.pfnRegisterVariable ( "joypitchsensitivity", "1.0", 0 );
+	joy_yawsensitivity		= gEngfuncs.pfnRegisterVariable ( "joyyawsensitivity", "-1.0", 0 );
+	joy_wwhack1				= gEngfuncs.pfnRegisterVariable ( "joywwhack1", "0.0", 0 );
+	joy_wwhack2				= gEngfuncs.pfnRegisterVariable ( "joywwhack2", "0.0", 0 );
+
+	gEngfuncs.pfnAddCommand ("force_centerview", Force_CenterView_f);
+	gEngfuncs.pfnAddCommand ("joyadvancedupdate", Joy_AdvancedUpdate_f);
+
+	IN_StartupMouse ();
+	IN_StartupJoystick ();
+}

hlsdk/ricochet/cl_dll/kbutton.h

@@ -0,0 +1,25 @@
+/***
+*
+*	Copyright (c) 1999, 2000 Valve LLC. All rights reserved.
+*	
+*	This product contains software technology licensed from Id 
+*	Software, Inc. ("Id Technology").  Id Technology (c) 1996 Id Software, Inc. 
+*	All Rights Reserved.
+*
+*   Use, distribution, and modification of this source code and/or resulting
+*   object code is restricted to non-commercial enhancements to products from
+*   Valve LLC.  All other use, distribution, or modification is prohibited
+*   without written permission from Valve LLC.
+*
+****/
+#if !defined( KBUTTONH )
+#define KBUTTONH
+#pragma once
+
+typedef struct kbutton_s
+{
+	int		down[2];		// key nums holding it down
+	int		state;			// low bit is down state
+} kbutton_t;
+
+#endif // !KBUTTONH

hlsdk/ricochet/cl_dll/menu.cpp

@@ -0,0 +1,187 @@
+/***
+*
+*	Copyright (c) 1999, 2000 Valve LLC. All rights reserved.
+*	
+*	This product contains software technology licensed from Id 
+*	Software, Inc. ("Id Technology").  Id Technology (c) 1996 Id Software, Inc. 
+*	All Rights Reserved.
+*
+*   Use, distribution, and modification of this source code and/or resulting
+*   object code is restricted to non-commercial enhancements to products from
+*   Valve LLC.  All other use, distribution, or modification is prohibited
+*   without written permission from Valve LLC.
+*
+****/
+//
+// menu.cpp
+//
+// generic menu handler
+//
+#include "hud.h"
+#include "cl_util.h"
+#include "parsemsg.h"
+
+#include <string.h>
+#include <stdio.h>
+
+#include "vgui_TeamFortressViewport.h"
+
+#define MAX_MENU_STRING	512
+char g_szMenuString[MAX_MENU_STRING];
+char g_szPrelocalisedMenuString[MAX_MENU_STRING];
+
+int KB_ConvertString( char *in, char **ppout );
+
+DECLARE_MESSAGE( m_Menu, ShowMenu );
+
+int CHudMenu :: Init( void )
+{
+	gHUD.AddHudElem( this );
+
+	HOOK_MESSAGE( ShowMenu );
+
+	InitHUDData();
+
+	return 1;
+}
+
+void CHudMenu :: InitHUDData( void )
+{
+	m_fMenuDisplayed = 0;
+	m_bitsValidSlots = 0;
+	Reset();
+}
+
+void CHudMenu :: Reset( void )
+{
+	g_szPrelocalisedMenuString[0] = 0;
+	m_fWaitingForMore = FALSE;
+}
+
+int CHudMenu :: VidInit( void )
+{
+	return 1;
+}
+
+int CHudMenu :: Draw( float flTime )
+{
+	// check for if menu is set to disappear
+	if ( m_flShutoffTime > 0 )
+	{
+		if ( m_flShutoffTime <= gHUD.m_flTime )
+		{  // times up, shutoff
+			m_fMenuDisplayed = 0;
+			m_iFlags &= ~HUD_ACTIVE;
+			return 1;
+		}
+	}
+
+	// don't draw the menu if the scoreboard is being shown
+	if ( gViewPort && gViewPort->IsScoreBoardVisible() )
+		return 1;
+
+	// draw the menu, along the left-hand side of the screen
+
+	// count the number of newlines
+	int nlc = 0, i = 0;
+	for ( i = 0; i < MAX_MENU_STRING && g_szMenuString[i] != '\0'; i++ )
+	{
+		if ( g_szMenuString[i] == '\n' )
+			nlc++;
+	}
+
+	// center it
+	int y = (ScreenHeight/2) - ((nlc/2)*12) - 40; // make sure it is above the say text
+	int x = 20;
+
+	i = 0;
+	while ( i < MAX_MENU_STRING && g_szMenuString[i] != '\0' )
+	{
+		gHUD.DrawHudString( x, y, 320, g_szMenuString + i, 255, 255, 255 );
+		y += 12;
+
+		while ( i < MAX_MENU_STRING && g_szMenuString[i] != '\0' && g_szMenuString[i] != '\n' )
+			i++;
+		if ( g_szMenuString[i] == '\n' )
+			i++;
+	}
+	
+	return 1;
+}
+
+// selects an item from the menu
+void CHudMenu :: SelectMenuItem( int menu_item )
+{
+	// if menu_item is in a valid slot,  send a menuselect command to the server
+	if ( (menu_item > 0) && (m_bitsValidSlots & (1 << (menu_item-1))) )
+	{
+		char szbuf[32];
+		sprintf( szbuf, "menuselect %d\n", menu_item );
+		ClientCmd( szbuf );
+
+		// remove the menu
+		m_fMenuDisplayed = 0;
+		m_iFlags &= ~HUD_ACTIVE;
+	}
+}
+
+
+// Message handler for ShowMenu message
+// takes four values:
+//		short: a bitfield of keys that are valid input
+//		char : the duration, in seconds, the menu should stay up. -1 means is stays until something is chosen.
+//		byte : a boolean, TRUE if there is more string yet to be received before displaying the menu, FALSE if it's the last string
+//		string: menu string to display
+// if this message is never received, then scores will simply be the combined totals of the players.
+int CHudMenu :: MsgFunc_ShowMenu( const char *pszName, int iSize, void *pbuf )
+{
+	char *temp = NULL;
+
+	BEGIN_READ( pbuf, iSize );
+
+	m_bitsValidSlots = READ_SHORT();
+	int DisplayTime = READ_CHAR();
+	int NeedMore = READ_BYTE();
+
+	if ( DisplayTime > 0 )
+		m_flShutoffTime = DisplayTime + gHUD.m_flTime;
+	else
+		m_flShutoffTime = -1;
+
+	if ( m_bitsValidSlots )
+	{
+		if ( !m_fWaitingForMore ) // this is the start of a new menu
+		{
+			strncpy( g_szPrelocalisedMenuString, READ_STRING(), MAX_MENU_STRING );
+		}
+		else
+		{  // append to the current menu string
+			strncat( g_szPrelocalisedMenuString, READ_STRING(), MAX_MENU_STRING - strlen(g_szPrelocalisedMenuString) );
+		}
+		g_szPrelocalisedMenuString[MAX_MENU_STRING-1] = 0;  // ensure null termination (strncat/strncpy does not)
+
+		if ( !NeedMore )
+		{  // we have the whole string, so we can localise it now
+			strcpy( g_szMenuString, gHUD.m_TextMessage.BufferedLocaliseTextString( g_szPrelocalisedMenuString ) );
+
+			// Swap in characters
+			if ( KB_ConvertString( g_szMenuString, &temp ) )
+			{
+				strcpy( g_szMenuString, temp );
+				free( temp );
+			}
+		}
+
+		m_fMenuDisplayed = 1;
+		m_iFlags |= HUD_ACTIVE;
+	}
+	else
+	{
+		m_fMenuDisplayed = 0; // no valid slots means that the menu should be turned off
+		m_iFlags &= ~HUD_ACTIVE;
+	}
+
+	m_fWaitingForMore = NeedMore;
+
+	return 1;
+}

hlsdk/ricochet/cl_dll/message.cpp

@@ -0,0 +1,463 @@
+/***
+*
+*	Copyright (c) 1999, 2000 Valve LLC. All rights reserved.
+*	
+*	This product contains software technology licensed from Id 
+*	Software, Inc. ("Id Technology").  Id Technology (c) 1996 Id Software, Inc. 
+*	All Rights Reserved.
+*
+*   Use, distribution, and modification of this source code and/or resulting
+*   object code is restricted to non-commercial enhancements to products from
+*   Valve LLC.  All other use, distribution, or modification is prohibited
+*   without written permission from Valve LLC.
+*
+****/
+//
+// Message.cpp
+//
+// implementation of CHudMessage class
+//
+
+#include "hud.h"
+#include "cl_util.h"
+#include <string.h>
+#include <stdio.h>
+#include "parsemsg.h"
+
+DECLARE_MESSAGE( m_Message, HudText )
+DECLARE_MESSAGE( m_Message, GameTitle )
+
+
+int CHudMessage::Init(void)
+{
+	HOOK_MESSAGE( HudText );
+	HOOK_MESSAGE( GameTitle );
+
+	gHUD.AddHudElem(this);
+
+	Reset();
+
+	return 1;
+};
+
+int CHudMessage::VidInit( void )
+{
+	m_HUD_title_half = gHUD.GetSpriteIndex( "title_half" );
+	m_HUD_title_life = gHUD.GetSpriteIndex( "title_life" );
+
+	return 1;
+};
+
+
+void CHudMessage::Reset( void )
+{
+ 	memset( m_pMessages, 0, sizeof( m_pMessages[0] ) * maxHUDMessages );
+	memset( m_startTime, 0, sizeof( m_startTime[0] ) * maxHUDMessages );
+	
+	m_gameTitleTime = 0;
+	m_pGameTitle = NULL;
+}
+
+
+float CHudMessage::FadeBlend( float fadein, float fadeout, float hold, float localTime )
+{
+	float fadeTime = fadein + hold;
+	float fadeBlend;
+
+	if ( localTime < 0 )
+		return 0;
+
+	if ( localTime < fadein )
+	{
+		fadeBlend = 1 - ((fadein - localTime) / fadein);
+	}
+	else if ( localTime > fadeTime )
+	{
+		if ( fadeout > 0 )
+			fadeBlend = 1 - ((localTime - fadeTime) / fadeout);
+		else
+			fadeBlend = 0;
+	}
+	else
+		fadeBlend = 1;
+
+	return fadeBlend;
+}
+
+
+int	CHudMessage::XPosition( float x, int width, int totalWidth )
+{
+	int xPos;
+
+	if ( x == -1 )
+	{
+		xPos = (ScreenWidth - width) / 2;
+	}
+	else
+	{
+		if ( x < 0 )
+			xPos = (1.0 + x) * ScreenWidth - totalWidth;	// Alight right
+		else
+			xPos = x * ScreenWidth;
+	}
+
+	if ( xPos + width > ScreenWidth )
+		xPos = ScreenWidth - width;
+	else if ( xPos < 0 )
+		xPos = 0;
+
+	return xPos;
+}
+
+
+int CHudMessage::YPosition( float y, int height )
+{
+	int yPos;
+
+	if ( y == -1 )	// Centered?
+		yPos = (ScreenHeight - height) * 0.5;
+	else
+	{
+		// Alight bottom?
+		if ( y < 0 )
+			yPos = (1.0 + y) * ScreenHeight - height;	// Alight bottom
+		else // align top
+			yPos = y * ScreenHeight;
+	}
+
+	if ( yPos + height > ScreenHeight )
+		yPos = ScreenHeight - height;
+	else if ( yPos < 0 )
+		yPos = 0;
+
+	return yPos;
+}
+
+
+void CHudMessage::MessageScanNextChar( void )
+{
+	int srcRed, srcGreen, srcBlue, destRed, destGreen, destBlue;
+	int blend;
+
+	srcRed = m_parms.pMessage->r1;
+	srcGreen = m_parms.pMessage->g1;
+	srcBlue = m_parms.pMessage->b1;
+	blend = 0;	// Pure source
+
+	switch( m_parms.pMessage->effect )
+	{
+	// Fade-in / Fade-out
+	case 0:
+	case 1:
+		destRed = destGreen = destBlue = 0;
+		blend = m_parms.fadeBlend;
+		break;
+
+	case 2:
+		m_parms.charTime += m_parms.pMessage->fadein;
+		if ( m_parms.charTime > m_parms.time )
+		{
+			srcRed = srcGreen = srcBlue = 0;
+			blend = 0;	// pure source
+		}
+		else
+		{
+			float deltaTime = m_parms.time - m_parms.charTime;
+
+			destRed = destGreen = destBlue = 0;
+			if ( m_parms.time > m_parms.fadeTime )
+			{
+				blend = m_parms.fadeBlend;
+			}
+			else if ( deltaTime > m_parms.pMessage->fxtime )
+				blend = 0;	// pure dest
+			else
+			{
+				destRed = m_parms.pMessage->r2;
+				destGreen = m_parms.pMessage->g2;
+				destBlue = m_parms.pMessage->b2;
+				blend = 255 - (deltaTime * (1.0/m_parms.pMessage->fxtime) * 255.0 + 0.5);
+			}
+		}
+		break;
+	}
+	if ( blend > 255 )
+		blend = 255;
+	else if ( blend < 0 )
+		blend = 0;
+
+	m_parms.r = ((srcRed * (255-blend)) + (destRed * blend)) >> 8;
+	m_parms.g = ((srcGreen * (255-blend)) + (destGreen * blend)) >> 8;
+	m_parms.b = ((srcBlue * (255-blend)) + (destBlue * blend)) >> 8;
+
+	if ( m_parms.pMessage->effect == 1 && m_parms.charTime != 0 )
+	{
+		if ( m_parms.x >= 0 && m_parms.y >= 0 && (m_parms.x + gHUD.m_scrinfo.charWidths[ m_parms.text ]) <= ScreenWidth )
+			TextMessageDrawChar( m_parms.x, m_parms.y, m_parms.text, m_parms.pMessage->r2, m_parms.pMessage->g2, m_parms.pMessage->b2 );
+	}
+}
+
+
+void CHudMessage::MessageScanStart( void )
+{
+	switch( m_parms.pMessage->effect )
+	{
+	// Fade-in / out with flicker
+	case 1:
+	case 0:
+		m_parms.fadeTime = m_parms.pMessage->fadein + m_parms.pMessage->holdtime;
+		
+
+		if ( m_parms.time < m_parms.pMessage->fadein )
+		{
+			m_parms.fadeBlend = ((m_parms.pMessage->fadein - m_parms.time) * (1.0/m_parms.pMessage->fadein) * 255);
+		}
+		else if ( m_parms.time > m_parms.fadeTime )
+		{
+			if ( m_parms.pMessage->fadeout > 0 )
+				m_parms.fadeBlend = (((m_parms.time - m_parms.fadeTime) / m_parms.pMessage->fadeout) * 255);
+			else
+				m_parms.fadeBlend = 255; // Pure dest (off)
+		}
+		else
+			m_parms.fadeBlend = 0;	// Pure source (on)
+		m_parms.charTime = 0;
+
+		if ( m_parms.pMessage->effect == 1 && (rand()%100) < 10 )
+			m_parms.charTime = 1;
+		break;
+
+	case 2:
+		m_parms.fadeTime = (m_parms.pMessage->fadein * m_parms.length) + m_parms.pMessage->holdtime;
+		
+		if ( m_parms.time > m_parms.fadeTime && m_parms.pMessage->fadeout > 0 )
+			m_parms.fadeBlend = (((m_parms.time - m_parms.fadeTime) / m_parms.pMessage->fadeout) * 255);
+		else
+			m_parms.fadeBlend = 0;
+		break;
+	}
+}
+
+
+void CHudMessage::MessageDrawScan( client_textmessage_t *pMessage, float time )
+{
+	int i, j, length, width;
+	const char *pText;
+	unsigned char line[80];
+
+	pText = pMessage->pMessage;
+	// Count lines
+	m_parms.lines = 1;
+	m_parms.time = time;
+	m_parms.pMessage = pMessage;
+	length = 0;
+	width = 0;
+	m_parms.totalWidth = 0;
+	while ( *pText )
+	{
+		if ( *pText == '\n' )
+		{
+			m_parms.lines++;
+			if ( width > m_parms.totalWidth )
+				m_parms.totalWidth = width;
+			width = 0;
+		}
+		else
+			width += gHUD.m_scrinfo.charWidths[*pText];
+		pText++;
+		length++;
+	}
+	m_parms.length = length;
+	m_parms.totalHeight = (m_parms.lines * gHUD.m_scrinfo.iCharHeight);
+
+
+	m_parms.y = YPosition( pMessage->y, m_parms.totalHeight );
+	pText = pMessage->pMessage;
+
+	m_parms.charTime = 0;
+
+	MessageScanStart();
+
+	for ( i = 0; i < m_parms.lines; i++ )
+	{
+		m_parms.lineLength = 0;
+		m_parms.width = 0;
+		while ( *pText && *pText != '\n' )
+		{
+			unsigned char c = *pText;
+			line[m_parms.lineLength] = c;
+			m_parms.width += gHUD.m_scrinfo.charWidths[c];
+			m_parms.lineLength++;
+			pText++;
+		}
+		pText++;		// Skip LF
+		line[m_parms.lineLength] = 0;
+
+		m_parms.x = XPosition( pMessage->x, m_parms.width, m_parms.totalWidth );
+
+		for ( j = 0; j < m_parms.lineLength; j++ )
+		{
+			m_parms.text = line[j];
+			int next = m_parms.x + gHUD.m_scrinfo.charWidths[ m_parms.text ];
+			MessageScanNextChar();
+			
+			if ( m_parms.x >= 0 && m_parms.y >= 0 && next <= ScreenWidth )
+				TextMessageDrawChar( m_parms.x, m_parms.y, m_parms.text, m_parms.r, m_parms.g, m_parms.b );
+			m_parms.x = next;
+		}
+
+		m_parms.y += gHUD.m_scrinfo.iCharHeight;
+	}
+}
+
+
+int CHudMessage::Draw( float fTime )
+{
+	int i, drawn;
+	client_textmessage_t *pMessage;
+	float endTime;
+
+	drawn = 0;
+
+	if ( m_gameTitleTime > 0 )
+	{
+		float localTime = gHUD.m_flTime - m_gameTitleTime;
+		float brightness;
+
+		// Maybe timer isn't set yet
+		if ( m_gameTitleTime > gHUD.m_flTime )
+			m_gameTitleTime = gHUD.m_flTime;
+
+		if ( localTime > (m_pGameTitle->fadein + m_pGameTitle->holdtime + m_pGameTitle->fadeout) )
+			m_gameTitleTime = 0;
+		else
+		{
+			brightness = FadeBlend( m_pGameTitle->fadein, m_pGameTitle->fadeout, m_pGameTitle->holdtime, localTime );
+
+			int halfWidth = gHUD.GetSpriteRect(m_HUD_title_half).right - gHUD.GetSpriteRect(m_HUD_title_half).left;
+			int fullWidth = halfWidth + gHUD.GetSpriteRect(m_HUD_title_life).right - gHUD.GetSpriteRect(m_HUD_title_life).left;
+			int fullHeight = gHUD.GetSpriteRect(m_HUD_title_half).bottom - gHUD.GetSpriteRect(m_HUD_title_half).top;
+
+			int x = XPosition( m_pGameTitle->x, fullWidth, fullWidth );
+			int y = YPosition( m_pGameTitle->y, fullHeight );
+
+
+			SPR_Set( gHUD.GetSprite(m_HUD_title_half), brightness * m_pGameTitle->r1, brightness * m_pGameTitle->g1, brightness * m_pGameTitle->b1 );
+			SPR_DrawAdditive( 0, x, y, &gHUD.GetSpriteRect(m_HUD_title_half) );
+
+			SPR_Set( gHUD.GetSprite(m_HUD_title_life), brightness * m_pGameTitle->r1, brightness * m_pGameTitle->g1, brightness * m_pGameTitle->b1 );
+			SPR_DrawAdditive( 0, x + halfWidth, y, &gHUD.GetSpriteRect(m_HUD_title_life) );
+
+			drawn = 1;
+		}
+	}
+	// Fixup level transitions
+	for ( i = 0; i < maxHUDMessages; i++ )
+	{
+		// Assume m_parms.time contains last time
+		if ( m_pMessages[i] )
+		{
+			pMessage = m_pMessages[i];
+			if ( m_startTime[i] > gHUD.m_flTime )
+				m_startTime[i] = gHUD.m_flTime + m_parms.time - m_startTime[i] + 0.2;	// Server takes 0.2 seconds to spawn, adjust for this
+		}
+	}
+
+	for ( i = 0; i < maxHUDMessages; i++ )
+	{
+		if ( m_pMessages[i] )
+		{
+			pMessage = m_pMessages[i];
+
+			// This is when the message is over
+			switch( pMessage->effect )
+			{
+			case 0:
+			case 1:
+				endTime = m_startTime[i] + pMessage->fadein + pMessage->fadeout + pMessage->holdtime;
+				break;
+			
+			// Fade in is per character in scanning messages
+			case 2:
+				endTime = m_startTime[i] + (pMessage->fadein * strlen( pMessage->pMessage )) + pMessage->fadeout + pMessage->holdtime;
+				break;
+			}
+
+			if ( fTime <= endTime )
+			{
+				float messageTime = fTime - m_startTime[i];
+
+				// Draw the message
+				// effect 0 is fade in/fade out
+				// effect 1 is flickery credits
+				// effect 2 is write out (training room)
+				MessageDrawScan( pMessage, messageTime );
+
+				drawn++;
+			}
+			else
+			{
+				// The message is over
+				m_pMessages[i] = NULL;
+			}
+		}
+	}
+
+	// Remember the time -- to fix up level transitions
+	m_parms.time = gHUD.m_flTime;
+	// Don't call until we get another message
+	if ( !drawn )
+		m_iFlags &= ~HUD_ACTIVE;
+
+	return 1;
+}
+
+
+void CHudMessage::MessageAdd( const char *pName, float time )
+{
+	int i;
+
+	for ( i = 0; i < maxHUDMessages; i++ )
+	{
+		if ( !m_pMessages[i] )
+		{
+			m_pMessages[i] = TextMessageGet( pName );
+			m_startTime[i] = time;
+			return;
+		}
+	}
+}
+
+
+int CHudMessage::MsgFunc_HudText( const char *pszName,  int iSize, void *pbuf )
+{
+	BEGIN_READ( pbuf, iSize );
+
+	char *pString = READ_STRING();
+
+	MessageAdd( pString, gHUD.m_flTime );
+	// Remember the time -- to fix up level transitions
+	m_parms.time = gHUD.m_flTime;
+
+	// Turn on drawing
+	if ( !(m_iFlags & HUD_ACTIVE) )
+		m_iFlags |= HUD_ACTIVE;
+
+	return 1;
+}
+
+
+int CHudMessage::MsgFunc_GameTitle( const char *pszName,  int iSize, void *pbuf )
+{
+	m_pGameTitle = TextMessageGet( "GAMETITLE" );
+	if ( m_pGameTitle != NULL )
+	{
+		m_gameTitleTime = gHUD.m_flTime;
+
+		// Turn on drawing
+		if ( !(m_iFlags & HUD_ACTIVE) )
+			m_iFlags |= HUD_ACTIVE;
+	}
+
+	return 1;
+}

hlsdk/ricochet/cl_dll/msvc6/cl_dll.dsp

@@ -0,0 +1,524 @@
+# Microsoft Developer Studio Project File - Name="cl_dll" - Package Owner=<4>
+# Microsoft Developer Studio Generated Build File, Format Version 6.00
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Dynamic-Link Library" 0x0102
+
+CFG=cl_dll - Win32 Release
+!MESSAGE This is not a valid makefile. To build this project using NMAKE,
+!MESSAGE use the Export Makefile command and run
+!MESSAGE 
+!MESSAGE NMAKE /f "cl_dll.mak".
+!MESSAGE 
+!MESSAGE You can specify a configuration when running NMAKE
+!MESSAGE by defining the macro CFG on the command line. For example:
+!MESSAGE 
+!MESSAGE NMAKE /f "cl_dll.mak" CFG="cl_dll - Win32 Release"
+!MESSAGE 
+!MESSAGE Possible choices for configuration are:
+!MESSAGE 
+!MESSAGE "cl_dll - Win32 Release" (based on "Win32 (x86) Dynamic-Link Library")
+!MESSAGE "cl_dll - Win32 Debug" (based on "Win32 (x86) Dynamic-Link Library")
+!MESSAGE 
+
+# Begin Project
+# PROP AllowPerConfigDependencies 0
+# PROP Scc_ProjName ""
+# PROP Scc_LocalPath ""
+CPP=cl.exe
+MTL=midl.exe
+RSC=rc.exe
+
+!IF  "$(CFG)" == "cl_dll - Win32 Release"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir ".\Release"
+# PROP BASE Intermediate_Dir ".\Release"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir ".\Release"
+# PROP Intermediate_Dir ".\Release"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /MT /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /YX /c
+# ADD CPP /nologo /MT /W3 /GX /Zi /O2 /I "..\" /I "..\..\" /I "..\..\dlls" /I "..\..\..\engine" /I "..\..\..\common" /I "..\..\..\game_shared" /I "..\..\pm_shared" /I "..\..\..\utils\vgui\include" /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "CLIENT_DLL" /D "RICOCHET_BUILD" /YX /FD /c
+# ADD BASE MTL /nologo /D "NDEBUG" /win32
+# ADD MTL /nologo /D "NDEBUG" /mktyplib203 /win32
+# ADD BASE RSC /l 0x409 /d "NDEBUG"
+# ADD RSC /l 0x409 /d "NDEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /dll /machine:I386
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib winmm.lib ../../../utils/vgui/lib/win32_vc6/vgui.lib wsock32.lib /nologo /subsystem:windows /dll /map /machine:I386 /out:".\Release\client.dll"
+# SUBTRACT LINK32 /debug
+
+!ELSEIF  "$(CFG)" == "cl_dll - Win32 Debug"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir ".\Debug"
+# PROP BASE Intermediate_Dir ".\Debug"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir ".\Debug"
+# PROP Intermediate_Dir ".\Debug"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /MTd /W3 /Gm /GX /Zi /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /YX /c
+# ADD CPP /nologo /G5 /MTd /W3 /Gm /GX /ZI /Od /I "..\" /I "..\..\dlls" /I "..\..\" /I "..\..\..\game_shared" /I "..\..\..\engine" /I "..\..\..\common" /I "..\..\pm_shared" /I "..\..\..\utils\vgui\include" /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /D "CLIENT_DLL" /D "RICOCHET_BUILD" /FR /YX /FD /c
+# ADD BASE MTL /nologo /D "_DEBUG" /win32
+# ADD MTL /nologo /D "_DEBUG" /mktyplib203 /win32
+# ADD BASE RSC /l 0x409 /d "_DEBUG"
+# ADD RSC /l 0x409 /d "_DEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /dll /debug /machine:I386
+# ADD LINK32 oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib winmm.lib ../../../utils/vgui/lib/win32_vc6/vgui.lib wsock32.lib /nologo /subsystem:windows /dll /debug /machine:I386 /out:".\Debug\client.dll"
+
+!ENDIF 
+
+# Begin Target
+
+# Name "cl_dll - Win32 Release"
+# Name "cl_dll - Win32 Debug"
+# Begin Group "Source Files"
+
+# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat;for;f90"
+# Begin Group "hl"
+
+# PROP Default_Filter "*.cpp"
+# Begin Source File
+
+SOURCE=..\..\dlls\wpn_shared\disc_weapon_disc.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\ev_hldm.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\hl\hl_baseentity.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\hl\hl_events.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\hl\hl_objects.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\hl\hl_weapons.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\Ricochet_JumpPads.cpp
+# End Source File
+# End Group
+# Begin Source File
+
+SOURCE=..\ammo.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\ammo_secondary.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\ammohistory.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\battery.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\cdll_int.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\com_weapons.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\death.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\demo.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\entity.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\ev_common.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\events.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\flashlight.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\GameStudioModelRenderer.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\geiger.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\health.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\hud.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\hud_msg.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\hud_redraw.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\hud_servers.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\hud_update.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\in_camera.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\input.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\inputw32.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\common\interface.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\menu.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\message.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\parsemsg.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\parsemsg.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\pm_shared\pm_debug.c
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\pm_shared\pm_math.c
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\pm_shared\pm_shared.c
+# End Source File
+# Begin Source File
+
+SOURCE=..\saytext.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\status_icons.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\statusbar.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\studio_util.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\StudioModelRenderer.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\text_message.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\train.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\tri.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\util.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\game_shared\vgui_checkbutton2.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\vgui_ConsolePanel.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\vgui_ControlConfigPanel.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\vgui_CustomObjects.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\vgui_discobjects.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\game_shared\vgui_grid.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\game_shared\vgui_helpers.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\vgui_int.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\game_shared\vgui_listbox.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\game_shared\vgui_loadtga.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\vgui_MOTDWindow.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\vgui_SchemeManager.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\vgui_ScorePanel.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\game_shared\vgui_scrollbar2.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\vgui_ServerBrowser.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\game_shared\vgui_slider2.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\vgui_TeamFortressViewport.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\view.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\game_shared\voice_banmgr.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\game_shared\voice_status.cpp
+# End Source File
+# End Group
+# Begin Group "Header Files"
+
+# PROP Default_Filter "h;hpp;hxx;hm;inl;fi;fd"
+# Begin Source File
+
+SOURCE=..\ammo.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\ammohistory.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\camera.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\cl_dll.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\com_weapons.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\demo.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\ev_hldm.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\eventscripts.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\GameStudioModelRenderer.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\health.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\hud.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\hud_iface.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\hud_servers.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\hud_servers_priv.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\in_defs.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\kbutton.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\pm_shared\pm_debug.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\pm_shared\pm_defs.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\pm_shared\pm_info.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\pm_shared\pm_materials.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\pm_shared\pm_movevars.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\pm_shared\pm_shared.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\Ricochet_BSPFile.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\Ricochet_JumpPads.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\studio_util.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\StudioModelRenderer.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\util_vector.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\vgui_ConsolePanel.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\vgui_ControlConfigPanel.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\vgui_discobjects.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\vgui_int.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\vgui_SchemeManager.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\vgui_ScorePanel.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\vgui_ServerBrowser.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\vgui_TeamFortressViewport.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\view.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\wrect.h
+# End Source File
+# End Group
+# Begin Group "Resource Files"
+
+# PROP Default_Filter "ico;cur;bmp;dlg;rc2;rct;bin;cnt;rtf;gif;jpg;jpeg;jpe"
+# End Group
+# End Target
+# End Project

hlsdk/ricochet/cl_dll/parsemsg.cpp

@@ -0,0 +1,166 @@
+/***
+*
+*	Copyright (c) 1999, 2000 Valve LLC. All rights reserved.
+*	
+*	This product contains software technology licensed from Id 
+*	Software, Inc. ("Id Technology").  Id Technology (c) 1996 Id Software, Inc. 
+*	All Rights Reserved.
+*
+*   Use, distribution, and modification of this source code and/or resulting
+*   object code is restricted to non-commercial enhancements to products from
+*   Valve LLC.  All other use, distribution, or modification is prohibited
+*   without written permission from Valve LLC.
+*
+****/
+//
+//  parsemsg.cpp
+//
+typedef unsigned char byte;
+#define true 1
+
+static byte *gpBuf;
+static int giSize;
+static int giRead;
+static int giBadRead;
+
+void BEGIN_READ( void *buf, int size )
+{
+	giRead = 0;
+	giBadRead = 0;
+	giSize = size;
+	gpBuf = (byte*)buf;
+}
+
+
+int READ_CHAR( void )
+{
+	int     c;
+	
+	if (giRead + 1 > giSize)
+	{
+		giBadRead = true;
+		return -1;
+	}
+		
+	c = (signed char)gpBuf[giRead];
+	giRead++;
+	
+	return c;
+}
+
+int READ_BYTE( void )
+{
+	int     c;
+	
+	if (giRead+1 > giSize)
+	{
+		giBadRead = true;
+		return -1;
+	}
+		
+	c = (unsigned char)gpBuf[giRead];
+	giRead++;
+	
+	return c;
+}
+
+int READ_SHORT( void )
+{
+	int     c;
+	
+	if (giRead+2 > giSize)
+	{
+		giBadRead = true;
+		return -1;
+	}
+		
+	c = (short)( gpBuf[giRead] + ( gpBuf[giRead+1] << 8 ) );
+	
+	giRead += 2;
+	
+	return c;
+}
+
+int READ_WORD( void )
+{
+	return READ_SHORT();
+}
+
+
+int READ_LONG( void )
+{
+	int     c;
+	
+	if (giRead+4 > giSize)
+	{
+		giBadRead = true;
+		return -1;
+	}
+		
+ 	c = gpBuf[giRead] + (gpBuf[giRead + 1] << 8) + (gpBuf[giRead + 2] << 16) + (gpBuf[giRead + 3] << 24);
+	
+	giRead += 4;
+	
+	return c;
+}
+
+float READ_FLOAT( void )
+{
+	union
+	{
+		byte    b[4];
+		float   f;
+		int     l;
+	} dat;
+	
+	dat.b[0] = gpBuf[giRead];
+	dat.b[1] = gpBuf[giRead+1];
+	dat.b[2] = gpBuf[giRead+2];
+	dat.b[3] = gpBuf[giRead+3];
+	giRead += 4;
+	
+//	dat.l = LittleLong (dat.l);
+
+	return dat.f;   
+}
+
+char* READ_STRING( void )
+{
+	static char     string[2048];
+	int             l,c;
+
+	string[0] = 0;
+
+	l = 0;
+	do
+	{
+		if ( giRead+1 > giSize )
+			break; // no more characters
+
+		c = READ_CHAR();
+		if (c == -1 || c == 0)
+			break;
+		string[l] = c;
+		l++;
+	} while (l < sizeof(string)-1);
+	
+	string[l] = 0;
+	
+	return string;
+}
+
+float READ_COORD( void )
+{
+	return (float)(READ_SHORT() * (1.0/8));
+}
+
+float READ_ANGLE( void )
+{
+	return (float)(READ_CHAR() * (360.0/256));
+}
+
+float READ_HIRESANGLE( void )
+{
+	return (float)(READ_SHORT() * (360.0/65536));
+}
+

hlsdk/ricochet/cl_dll/parsemsg.h

@@ -0,0 +1,40 @@
+/***
+*
+*	Copyright (c) 1999, 2000 Valve LLC. All rights reserved.
+*	
+*	This product contains software technology licensed from Id 
+*	Software, Inc. ("Id Technology").  Id Technology (c) 1996 Id Software, Inc. 
+*	All Rights Reserved.
+*
+*   Use, distribution, and modification of this source code and/or resulting
+*   object code is restricted to non-commercial enhancements to products from
+*   Valve LLC.  All other use, distribution, or modification is prohibited
+*   without written permission from Valve LLC.
+*
+****/
+//
+//  parsemsg.h
+//
+
+#define ASSERT( x )
+
+void BEGIN_READ( void *buf, int size );
+int READ_CHAR( void );
+int READ_BYTE( void );
+int READ_SHORT( void );
+int READ_WORD( void );
+int READ_LONG( void );
+float READ_FLOAT( void );
+char* READ_STRING( void );
+float READ_COORD( void );
+float READ_ANGLE( void );
+float READ_HIRESANGLE( void );
+
+
+
+
+
+
+
+
+

hlsdk/ricochet/cl_dll/saytext.cpp

@@ -0,0 +1,308 @@
+/***
+*
+*	Copyright (c) 1999, Valve LLC. All rights reserved.
+*	
+*	This product contains software technology licensed from Id 
+*	Software, Inc. ("Id Technology").  Id Technology (c) 1996 Id Software, Inc. 
+*	All Rights Reserved.
+*
+*   Use, distribution, and modification of this source code and/or resulting
+*   object code is restricted to non-commercial enhancements to products from
+*   Valve LLC.  All other use, distribution, or modification is prohibited
+*   without written permission from Valve LLC.
+*
+****/
+//
+// saytext.cpp
+//
+// implementation of CHudSayText class
+//
+
+#include "hud.h"
+#include "cl_util.h"
+#include "parsemsg.h"
+
+#include <string.h>
+#include <stdio.h>
+
+extern float *GetClientColor( int clientIndex );
+
+#define MAX_LINES	5
+#define MAX_CHARS_PER_LINE	256  /* it can be less than this, depending on char size */
+
+// allow 20 pixels on either side of the text
+#define MAX_LINE_WIDTH  ( ScreenWidth - 40 )
+#define LINE_START  10
+static float SCROLL_SPEED = 5;
+
+static char g_szLineBuffer[ MAX_LINES + 1 ][ MAX_CHARS_PER_LINE ];
+static float *g_pflNameColors[ MAX_LINES + 1 ];
+static int g_iNameLengths[ MAX_LINES + 1 ];
+static float flScrollTime = 0;  // the time at which the lines next scroll up
+
+static int Y_START = 0;
+static int line_height = 0;
+
+DECLARE_MESSAGE( m_SayText, SayText );
+
+int CHudSayText :: Init( void )
+{
+	gHUD.AddHudElem( this );
+
+	HOOK_MESSAGE( SayText );
+
+	InitHUDData();
+
+	CVAR_CREATE( "hud_saytext_time", "5", 0 );
+
+	return 1;
+}
+
+
+void CHudSayText :: InitHUDData( void )
+{
+	memset( g_szLineBuffer, 0, sizeof g_szLineBuffer );
+	memset( g_pflNameColors, 0, sizeof g_pflNameColors );
+	memset( g_iNameLengths, 0, sizeof g_iNameLengths );
+}
+
+int CHudSayText :: VidInit( void )
+{
+	return 1;
+}
+
+
+int ScrollTextUp( void )
+{
+	ConsolePrint( g_szLineBuffer[0] ); // move the first line into the console buffer
+	g_szLineBuffer[MAX_LINES][0] = 0;
+	memmove( g_szLineBuffer[0], g_szLineBuffer[1], sizeof(g_szLineBuffer) - sizeof(g_szLineBuffer[0]) ); // overwrite the first line
+	memmove( &g_pflNameColors[0], &g_pflNameColors[1], sizeof(g_pflNameColors) - sizeof(g_pflNameColors[0]) );
+	memmove( &g_iNameLengths[0], &g_iNameLengths[1], sizeof(g_iNameLengths) - sizeof(g_iNameLengths[0]) );
+	g_szLineBuffer[MAX_LINES-1][0] = 0;
+
+	if ( g_szLineBuffer[0][0] == ' ' ) // also scroll up following lines
+	{
+		g_szLineBuffer[0][0] = 2;
+		return 1 + ScrollTextUp();
+	}
+
+	return 1;
+}
+
+int CHudSayText :: Draw( float flTime )
+{
+	int y = Y_START;
+
+	// make sure the scrolltime is within reasonable bounds,  to guard against the clock being reset
+	flScrollTime = min( flScrollTime, flTime + SCROLL_SPEED );
+
+	// make sure the scrolltime is within reasonable bounds,  to guard against the clock being reset
+	flScrollTime = min( flScrollTime, flTime + SCROLL_SPEED );
+
+	if ( flScrollTime <= flTime )
+	{
+		if ( *g_szLineBuffer[0] )
+		{
+			flScrollTime = flTime + SCROLL_SPEED;
+			// push the console up
+			ScrollTextUp();
+		}
+		else
+		{ // buffer is empty,  just disable drawing of this section
+			m_iFlags &= ~HUD_ACTIVE;
+		}
+	}
+
+	for ( int i = 0; i < MAX_LINES; i++ )
+	{
+		if ( *g_szLineBuffer[i] )
+		{
+			if ( *g_szLineBuffer[i] == 2 && g_pflNameColors[i] )
+			{
+				// it's a saytext string
+				static char buf[MAX_PLAYER_NAME_LENGTH+32];
+
+				// draw the first x characters in the player color
+				strncpy( buf, g_szLineBuffer[i], min(g_iNameLengths[i], MAX_PLAYER_NAME_LENGTH+32) );
+				buf[ min(g_iNameLengths[i], MAX_PLAYER_NAME_LENGTH+31) ] = 0;
+				gEngfuncs.pfnDrawSetTextColor( g_pflNameColors[i][0], g_pflNameColors[i][1], g_pflNameColors[i][2] );
+				int x = DrawConsoleString( LINE_START, y, buf );
+
+				// color is reset after each string draw
+				DrawConsoleString( x, y, g_szLineBuffer[i] + g_iNameLengths[i] );
+			}
+			else
+			{
+				// normal draw
+				DrawConsoleString( LINE_START, y, g_szLineBuffer[i] );
+			}
+		}
+
+		y += line_height;
+	}
+
+
+	return 1;
+}
+
+int CHudSayText :: MsgFunc_SayText( const char *pszName, int iSize, void *pbuf )
+{
+	BEGIN_READ( pbuf, iSize );
+
+	int client_index = READ_BYTE();		// the client who spoke the message
+	SayTextPrint( READ_STRING(), iSize - 1,  client_index );
+	
+	return 1;
+}
+
+void CHudSayText :: SayTextPrint( const char *pszBuf, int iBufSize, int clientIndex )
+{
+	// find an empty string slot
+	int i;
+	for ( i = 0; i < MAX_LINES; i++ )
+	{
+		if ( ! *g_szLineBuffer[i] )
+			break;
+	}
+	if ( i == MAX_LINES )
+	{
+		// force scroll buffer up
+		ScrollTextUp();
+		i = MAX_LINES - 1;
+	}
+
+	g_iNameLengths[i] = 0;
+	g_pflNameColors[i] = NULL;
+
+	// if it's a say message, search for the players name in the string
+	if ( *pszBuf == 2 && clientIndex > 0 )
+	{
+		GetPlayerInfo( clientIndex, &g_PlayerInfoList[clientIndex] );
+		const char *pName = g_PlayerInfoList[clientIndex].name;
+
+		if ( pName )
+		{
+			const char *nameInString = strstr( pszBuf, pName );
+
+			if ( nameInString )
+			{
+				g_iNameLengths[i] = strlen( pName ) + (nameInString - pszBuf);
+				g_pflNameColors[i] = GetClientColor( clientIndex );
+			}
+		}
+	}
+
+	strncpy( g_szLineBuffer[i], pszBuf, max(iBufSize -1, MAX_CHARS_PER_LINE-1) );
+
+	// make sure the text fits in one line
+	EnsureTextFitsInOneLineAndWrapIfHaveTo( i );
+
+	// Set scroll time
+	if ( i == 0 )
+	{
+		SCROLL_SPEED = CVAR_GET_FLOAT( "hud_saytext_time" );
+		flScrollTime = gHUD.m_flTime + SCROLL_SPEED;
+	}
+
+	m_iFlags |= HUD_ACTIVE;
+	PlaySound( "misc/talk.wav", 1 );
+
+	if ( ScreenHeight >= 480 )
+		Y_START = ScreenHeight - 45;
+	else
+		Y_START = ScreenHeight - 35;
+	Y_START -= (line_height * (MAX_LINES+1));
+
+}
+
+void CHudSayText :: EnsureTextFitsInOneLineAndWrapIfHaveTo( int line )
+{
+	int line_width = 0;
+	GetConsoleStringSize( g_szLineBuffer[line], &line_width, &line_height );
+
+	if ( (line_width + LINE_START) > MAX_LINE_WIDTH )
+	{ // string is too long to fit on line
+		// scan the string until we find what word is too long,  and wrap the end of the sentence after the word
+		int length = LINE_START;
+		int tmp_len = 0;
+		char *last_break = NULL;
+		for ( char *x = g_szLineBuffer[line]; *x != 0; x++ )
+		{
+			// check for a color change, if so skip past it
+			if ( x[0] == '/' && x[1] == '(' )
+			{
+				x += 2;
+				// skip forward until past mode specifier
+				while ( *x != 0 && *x != ')' )
+					x++;
+
+				if ( *x != 0 )
+					x++;
+
+				if ( *x == 0 )
+					break;
+			}
+
+			char buf[2];
+			buf[1] = 0;
+
+			if ( *x == ' ' && x != g_szLineBuffer[line] )  // store each line break,  except for the very first character
+				last_break = x;
+
+			buf[0] = *x;  // get the length of the current character
+			GetConsoleStringSize( buf, &tmp_len, &line_height );
+			length += tmp_len;
+
+			if ( length > MAX_LINE_WIDTH )
+			{  // needs to be broken up
+				if ( !last_break )
+					last_break = x-1;
+
+				x = last_break;
+
+				// find an empty string slot
+				int j;
+				do 
+				{
+					for ( j = 0; j < MAX_LINES; j++ )
+					{
+						if ( ! *g_szLineBuffer[j] )
+							break;
+					}
+					if ( j == MAX_LINES )
+					{
+						// need to make more room to display text, scroll stuff up then fix the pointers
+						int linesmoved = ScrollTextUp();
+						line -= linesmoved;
+						last_break = last_break - (sizeof(g_szLineBuffer[0]) * linesmoved);
+					}
+				}
+				while ( j == MAX_LINES );
+
+				// copy remaining string into next buffer,  making sure it starts with a space character
+				if ( (char)*last_break == (char)' ' )
+				{
+					int linelen = strlen(g_szLineBuffer[j]);
+					int remaininglen = strlen(last_break);
+
+					if ( (linelen - remaininglen) <= MAX_CHARS_PER_LINE )
+						strcat( g_szLineBuffer[j], last_break );
+				}
+				else
+				{
+					if ( (strlen(g_szLineBuffer[j]) - strlen(last_break) - 2) < MAX_CHARS_PER_LINE )
+					{
+						strcat( g_szLineBuffer[j], " " );
+						strcat( g_szLineBuffer[j], last_break );
+					}
+				}
+
+				*last_break = 0; // cut off the last string
+
+				EnsureTextFitsInOneLineAndWrapIfHaveTo( j );
+				break;
+			}
+		}
+	}
+}

hlsdk/ricochet/cl_dll/status_icons.cpp

@@ -0,0 +1,150 @@
+/***
+*
+*	Copyright (c) 1999, 2000 Valve LLC. All rights reserved.
+*	
+*	This product contains software technology licensed from Id 
+*	Software, Inc. ("Id Technology").  Id Technology (c) 1996 Id Software, Inc. 
+*	All Rights Reserved.
+*
+*   Use, distribution, and modification of this source code and/or resulting
+*   object code is restricted to non-commercial enhancements to products from
+*   Valve LLC.  All other use, distribution, or modification is prohibited
+*   without written permission from Valve LLC.
+*
+****/
+//
+// status_icons.cpp
+//
+#include "hud.h"
+#include "cl_util.h"
+#include <string.h>
+#include <stdio.h>
+#include "parsemsg.h"
+
+DECLARE_MESSAGE( m_StatusIcons, StatusIcon );
+
+int CHudStatusIcons::Init( void )
+{
+	HOOK_MESSAGE( StatusIcon );
+
+	gHUD.AddHudElem( this );
+
+	Reset();
+
+	return 1;
+}
+
+int CHudStatusIcons::VidInit( void )
+{
+
+	return 1;
+}
+
+void CHudStatusIcons::Reset( void )
+{
+	memset( m_IconList, 0, sizeof m_IconList );
+	m_iFlags &= ~HUD_ACTIVE;
+}
+
+// Draw status icons along the left-hand side of the screen
+int CHudStatusIcons::Draw( float flTime )
+{
+	// find starting position to draw from, along right-hand side of screen
+	int x = 5;
+	int y = ScreenHeight / 2;
+	
+	// loop through icon list, and draw any valid icons drawing up from the middle of screen
+	for ( int i = 0; i < MAX_ICONSPRITES; i++ )
+	{
+		if ( m_IconList[i].spr )
+		{
+			y -= ( m_IconList[i].rc.bottom - m_IconList[i].rc.top ) + 5;
+			
+			SPR_Set( m_IconList[i].spr, m_IconList[i].r, m_IconList[i].g, m_IconList[i].b );
+			SPR_DrawAdditive( 0, x, y, &m_IconList[i].rc );
+		}
+	}
+	
+	return 1;
+}
+
+// Message handler for StatusIcon message
+// accepts five values:
+//		byte   : TRUE = ENABLE icon, FALSE = DISABLE icon
+//		string : the sprite name to display
+//		byte   : red
+//		byte   : green
+//		byte   : blue
+int CHudStatusIcons::MsgFunc_StatusIcon( const char *pszName, int iSize, void *pbuf )
+{
+	BEGIN_READ( pbuf, iSize );
+
+	int ShouldEnable = READ_BYTE();
+	char *pszIconName = READ_STRING();
+	if ( ShouldEnable )
+	{
+		int r = READ_BYTE();
+		int g = READ_BYTE();
+		int b = READ_BYTE();
+		EnableIcon( pszIconName, r, g, b );
+		m_iFlags |= HUD_ACTIVE;
+	}
+	else
+	{
+		DisableIcon( pszIconName );
+	}
+
+	return 1;
+}
+
+// add the icon to the icon list, and set it's drawing color
+void CHudStatusIcons::EnableIcon( char *pszIconName, unsigned char red, unsigned char green, unsigned char blue )
+{
+	// check to see if the sprite is in the current list
+	int i;
+	for ( i = 0; i < MAX_ICONSPRITES; i++ )
+	{
+		if ( !stricmp( m_IconList[i].szSpriteName, pszIconName ) )
+			break;
+	}
+
+	if ( i == MAX_ICONSPRITES )
+	{
+		// icon not in list, so find an empty slot to add to
+		for ( i = 0; i < MAX_ICONSPRITES; i++ )
+		{
+			if ( !m_IconList[i].spr )
+				break;
+		}
+	}
+
+	// if we've run out of space in the list, overwrite the first icon
+	if ( i == MAX_ICONSPRITES )
+	{
+		i = 0;
+	}
+
+	// Load the sprite and add it to the list
+	// the sprite must be listed in hud.txt
+	int spr_index = gHUD.GetSpriteIndex( pszIconName );
+	m_IconList[i].spr = gHUD.GetSprite( spr_index );
+	m_IconList[i].rc = gHUD.GetSpriteRect( spr_index );
+	m_IconList[i].r = red;
+	m_IconList[i].g = green;
+	m_IconList[i].b = blue;
+	strcpy( m_IconList[i].szSpriteName, pszIconName );
+}
+
+void CHudStatusIcons::DisableIcon( char *pszIconName )
+{
+	// find the sprite is in the current list
+	for ( int i = 0; i < MAX_ICONSPRITES; i++ )
+	{
+		if ( !stricmp( m_IconList[i].szSpriteName, pszIconName ) )
+		{
+			// clear the item from the list
+			memset( &m_IconList[i], 0, sizeof icon_sprite_t );
+			return;
+		}
+	}
+}

hlsdk/ricochet/cl_dll/statusbar.cpp

@@ -0,0 +1,252 @@
+/***
+*
+*	Copyright (c) 1999, Valve LLC. All rights reserved.
+*	
+*	This product contains software technology licensed from Id 
+*	Software, Inc. ("Id Technology").  Id Technology (c) 1996 Id Software, Inc. 
+*	All Rights Reserved.
+*
+*   Use, distribution, and modification of this source code and/or resulting
+*   object code is restricted to non-commercial enhancements to products from
+*   Valve LLC.  All other use, distribution, or modification is prohibited
+*   without written permission from Valve LLC.
+*
+****/
+//
+// statusbar.cpp
+//
+// generic text status bar, set by game dll
+// runs across bottom of screen
+//
+
+#include "hud.h"
+#include "cl_util.h"
+#include "parsemsg.h"
+
+#include <string.h>
+#include <stdio.h>
+
+DECLARE_MESSAGE( m_StatusBar, StatusText );
+DECLARE_MESSAGE( m_StatusBar, StatusValue );
+
+#define STATUSBAR_ID_LINE		1
+
+int CHudStatusBar :: Init( void )
+{
+	gHUD.AddHudElem( this );
+
+	HOOK_MESSAGE( StatusText );
+	HOOK_MESSAGE( StatusValue );
+
+	Reset();
+
+	CVAR_CREATE( "hud_centerid", "0", FCVAR_ARCHIVE );
+
+	return 1;
+}
+
+int CHudStatusBar :: VidInit( void )
+{
+	// Load sprites here
+
+	return 1;
+}
+
+void CHudStatusBar :: Reset( void )
+{
+	m_iFlags &= ~HUD_ACTIVE;  // start out inactive
+	for ( int i = 0; i < MAX_STATUSBAR_LINES; i++ )
+		m_szStatusText[i][0] = 0;
+	memset( m_iStatusValues, 0, sizeof m_iStatusValues );
+
+	m_iStatusValues[0] = 1;  // 0 is the special index, which always returns true
+}
+
+void CHudStatusBar :: ParseStatusString( int line_num )
+{
+	// localise string first
+	char szBuffer[MAX_STATUSTEXT_LENGTH];
+	memset( szBuffer, 0, sizeof szBuffer );
+	gHUD.m_TextMessage.LocaliseTextString( m_szStatusText[line_num], szBuffer, MAX_STATUSTEXT_LENGTH );
+
+	// parse m_szStatusText & m_iStatusValues into m_szStatusBar
+	memset( m_szStatusBar[line_num], 0, MAX_STATUSTEXT_LENGTH );
+	char *src = szBuffer;
+	char *dst = m_szStatusBar[line_num];
+
+	char *src_start = src, *dst_start = dst;
+
+	while ( *src != 0 )
+	{
+		while ( *src == '\n' )
+			src++;  // skip over any newlines
+
+		if ( ((src - src_start) >= MAX_STATUSTEXT_LENGTH) || ((dst - dst_start) >= MAX_STATUSTEXT_LENGTH) )
+			break;
+
+		int index = atoi( src );
+		// should we draw this line?
+		if ( (index >= 0 && index < MAX_STATUSBAR_VALUES) && (m_iStatusValues[index] != 0) )
+		{  // parse this line and append result to the status bar
+			while ( *src >= '0' && *src <= '9' )
+				src++;
+
+			if ( *src == '\n' || *src == 0 )
+				continue; // no more left in this text line
+
+			// copy the text, char by char, until we hit a % or a \n
+			while ( *src != '\n' && *src != 0 )
+			{
+				if ( *src != '%' )
+				{  // just copy the character
+					*dst = *src;
+					dst++, src++;
+				}
+				else
+				{
+					// get the descriptor
+					char valtype = *(++src); // move over %
+
+					// if it's a %, draw a % sign
+					if ( valtype == '%' )
+					{
+						*dst = valtype;
+						dst++, src++;
+						continue;
+					}
+
+					// move over descriptor, then get and move over the index
+					index = atoi( ++src ); 
+					while ( *src >= '0' && *src <= '9' )
+						src++;
+
+					if ( index >= 0 && index < MAX_STATUSBAR_VALUES )
+					{
+						int indexval = m_iStatusValues[index];
+
+						// get the string to substitute in place of the %XX
+						char szRepString[MAX_PLAYER_NAME_LENGTH];
+						switch ( valtype )
+						{
+						case 'p':  // player name
+							GetPlayerInfo( indexval, &g_PlayerInfoList[indexval] );
+							if ( g_PlayerInfoList[indexval].name != NULL )
+							{
+								strncpy( szRepString, g_PlayerInfoList[indexval].name, MAX_PLAYER_NAME_LENGTH );
+							}
+							else
+							{
+								strcpy( szRepString, "******" );
+							}
+							break;
+						case 'i':  // number
+							sprintf( szRepString, "%d", indexval );
+							break;
+						default:
+							szRepString[0] = 0;
+						}
+
+						for ( char *cp = szRepString; *cp != 0 && ((dst - dst_start) < MAX_STATUSTEXT_LENGTH); cp++, dst++ )
+							*dst = *cp;
+					}
+				}
+			}
+		}
+		else
+		{
+			// skip to next line of text
+			while ( *src != 0 && *src != '\n' )
+				src++;
+		}
+	}
+}
+
+int CHudStatusBar :: Draw( float fTime )
+{
+	if ( m_bReparseString )
+	{
+		for ( int i = 0; i < MAX_STATUSBAR_LINES; i++ )
+			ParseStatusString( i );
+		m_bReparseString = FALSE;
+	}
+
+	// Draw the status bar lines
+	for ( int i = 0; i < MAX_STATUSBAR_LINES; i++ )
+	{
+		int TextHeight, TextWidth;
+		GetConsoleStringSize( m_szStatusBar[i], &TextWidth, &TextHeight );
+
+		int Y_START;
+		if ( ScreenHeight >= 480 )
+			Y_START = ScreenHeight - 45;
+		else
+			Y_START = ScreenHeight - 35;
+
+		int x = 5;
+		int y = Y_START - ( TextHeight * i ); // draw along bottom of screen
+
+		// let user set status ID bar centering
+		if ( (i == STATUSBAR_ID_LINE) && CVAR_GET_FLOAT("hud_centerid") )
+		{
+			x = max( 0, max(2, (ScreenWidth - TextWidth)) / 2 );
+			y = (ScreenHeight / 2) + (TextHeight*CVAR_GET_FLOAT("hud_centerid"));
+		}
+
+		DrawConsoleString( x, y, m_szStatusBar[i] );
+	}
+
+	return 1;
+}
+
+// Message handler for StatusText message
+// accepts two values:
+//		byte: line number of status bar text 
+//		string: status bar text
+// this string describes how the status bar should be drawn
+// a semi-regular expression:
+// ( slotnum ([a..z] [%pX] [%iX])*)*
+// where slotnum is an index into the Value table (see below)
+// if slotnum is 0, the string is always drawn
+// if StatusValue[slotnum] != 0, the following string is drawn, upto the next newline - otherwise the text is skipped upto next newline
+// %pX, where X is an integer, will substitute a player name here, getting the player index from StatusValue[X]
+// %iX, where X is an integer, will substitute a number here, getting the number from StatusValue[X]
+int CHudStatusBar :: MsgFunc_StatusText( const char *pszName, int iSize, void *pbuf )
+{
+	BEGIN_READ( pbuf, iSize );
+
+	int line = READ_BYTE();
+
+	if ( line < 0 || line >= MAX_STATUSBAR_LINES )
+		return 1;
+
+	strncpy( m_szStatusText[line], READ_STRING(), MAX_STATUSTEXT_LENGTH );
+	m_szStatusText[line][MAX_STATUSTEXT_LENGTH-1] = 0;  // ensure it's null terminated ( strncpy() won't null terminate if read string too long)
+
+	if ( m_szStatusText[0] == 0 )
+		m_iFlags &= ~HUD_ACTIVE;
+	else
+		m_iFlags |= HUD_ACTIVE;  // we have status text, so turn on the status bar
+
+	m_bReparseString = TRUE;
+
+	return 1;
+}
+
+// Message handler for StatusText message
+// accepts two values:
+//		byte: index into the status value array
+//		short: value to store
+int CHudStatusBar :: MsgFunc_StatusValue( const char *pszName, int iSize, void *pbuf )
+{
+	BEGIN_READ( pbuf, iSize );
+
+	int index = READ_BYTE();
+	if ( index < 1 || index >= MAX_STATUSBAR_VALUES )
+		return 1; // index out of range
+
+	m_iStatusValues[index] = READ_SHORT();
+
+	m_bReparseString = TRUE;
+	
+	return 1;
+}

hlsdk/ricochet/cl_dll/studio_util.cpp

@@ -0,0 +1,244 @@
+#include <memory.h>
+#include "hud.h"
+#include "cl_util.h"
+#include "const.h"
+#include "com_model.h"
+#include "studio_util.h"
+
+/*
+====================
+AngleMatrix
+
+====================
+*/
+void AngleMatrix (const float *angles, float (*matrix)[4] )
+{
+	float		angle;
+	float		sr, sp, sy, cr, cp, cy;
+	
+	angle = angles[YAW] * (M_PI*2 / 360);
+	sy = sin(angle);
+	cy = cos(angle);
+	angle = angles[PITCH] * (M_PI*2 / 360);
+	sp = sin(angle);
+	cp = cos(angle);
+	angle = angles[ROLL] * (M_PI*2 / 360);
+	sr = sin(angle);
+	cr = cos(angle);
+
+	// matrix = (YAW * PITCH) * ROLL
+	matrix[0][0] = cp*cy;
+	matrix[1][0] = cp*sy;
+	matrix[2][0] = -sp;
+	matrix[0][1] = sr*sp*cy+cr*-sy;
+	matrix[1][1] = sr*sp*sy+cr*cy;
+	matrix[2][1] = sr*cp;
+	matrix[0][2] = (cr*sp*cy+-sr*-sy);
+	matrix[1][2] = (cr*sp*sy+-sr*cy);
+	matrix[2][2] = cr*cp;
+	matrix[0][3] = 0.0;
+	matrix[1][3] = 0.0;
+	matrix[2][3] = 0.0;
+}
+
+/*
+====================
+VectorCompare
+
+====================
+*/
+int VectorCompare (const float *v1, const float *v2)
+{
+	int		i;
+	
+	for (i=0 ; i<3 ; i++)
+		if (v1[i] != v2[i])
+			return 0;
+			
+	return 1;
+}
+
+/*
+====================
+CrossProduct
+
+====================
+*/
+void CrossProduct (const float *v1, const float *v2, float *cross)
+{
+	cross[0] = v1[1]*v2[2] - v1[2]*v2[1];
+	cross[1] = v1[2]*v2[0] - v1[0]*v2[2];
+	cross[2] = v1[0]*v2[1] - v1[1]*v2[0];
+}
+
+/*
+====================
+VectorTransform
+
+====================
+*/
+void VectorTransform (const float *in1, float in2[3][4], float *out)
+{
+	out[0] = DotProduct(in1, in2[0]) + in2[0][3];
+	out[1] = DotProduct(in1, in2[1]) + in2[1][3];
+	out[2] = DotProduct(in1, in2[2]) + in2[2][3];
+}
+
+/*
+================
+ConcatTransforms
+
+================
+*/
+void ConcatTransforms (float in1[3][4], float in2[3][4], float out[3][4])
+{
+	out[0][0] = in1[0][0] * in2[0][0] + in1[0][1] * in2[1][0] +
+				in1[0][2] * in2[2][0];
+	out[0][1] = in1[0][0] * in2[0][1] + in1[0][1] * in2[1][1] +
+				in1[0][2] * in2[2][1];
+	out[0][2] = in1[0][0] * in2[0][2] + in1[0][1] * in2[1][2] +
+				in1[0][2] * in2[2][2];
+	out[0][3] = in1[0][0] * in2[0][3] + in1[0][1] * in2[1][3] +
+				in1[0][2] * in2[2][3] + in1[0][3];
+	out[1][0] = in1[1][0] * in2[0][0] + in1[1][1] * in2[1][0] +
+				in1[1][2] * in2[2][0];
+	out[1][1] = in1[1][0] * in2[0][1] + in1[1][1] * in2[1][1] +
+				in1[1][2] * in2[2][1];
+	out[1][2] = in1[1][0] * in2[0][2] + in1[1][1] * in2[1][2] +
+				in1[1][2] * in2[2][2];
+	out[1][3] = in1[1][0] * in2[0][3] + in1[1][1] * in2[1][3] +
+				in1[1][2] * in2[2][3] + in1[1][3];
+	out[2][0] = in1[2][0] * in2[0][0] + in1[2][1] * in2[1][0] +
+				in1[2][2] * in2[2][0];
+	out[2][1] = in1[2][0] * in2[0][1] + in1[2][1] * in2[1][1] +
+				in1[2][2] * in2[2][1];
+	out[2][2] = in1[2][0] * in2[0][2] + in1[2][1] * in2[1][2] +
+				in1[2][2] * in2[2][2];
+	out[2][3] = in1[2][0] * in2[0][3] + in1[2][1] * in2[1][3] +
+				in1[2][2] * in2[2][3] + in1[2][3];
+}
+
+// angles index are not the same as ROLL, PITCH, YAW
+
+/*
+====================
+AngleQuaternion
+
+====================
+*/
+void AngleQuaternion( float *angles, vec4_t quaternion )
+{
+	float		angle;
+	float		sr, sp, sy, cr, cp, cy;
+
+	// FIXME: rescale the inputs to 1/2 angle
+	angle = angles[2] * 0.5;
+	sy = sin(angle);
+	cy = cos(angle);
+	angle = angles[1] * 0.5;
+	sp = sin(angle);
+	cp = cos(angle);
+	angle = angles[0] * 0.5;
+	sr = sin(angle);
+	cr = cos(angle);
+
+	quaternion[0] = sr*cp*cy-cr*sp*sy; // X
+	quaternion[1] = cr*sp*cy+sr*cp*sy; // Y
+	quaternion[2] = cr*cp*sy-sr*sp*cy; // Z
+	quaternion[3] = cr*cp*cy+sr*sp*sy; // W
+}
+
+/*
+====================
+QuaternionSlerp
+
+====================
+*/
+void QuaternionSlerp( vec4_t p, vec4_t q, float t, vec4_t qt )
+{
+	int i;
+	float	omega, cosom, sinom, sclp, sclq;
+
+	// decide if one of the quaternions is backwards
+	float a = 0;
+	float b = 0;
+
+	for (i = 0; i < 4; i++)
+	{
+		a += (p[i]-q[i])*(p[i]-q[i]);
+		b += (p[i]+q[i])*(p[i]+q[i]);
+	}
+	if (a > b)
+	{
+		for (i = 0; i < 4; i++)
+		{
+			q[i] = -q[i];
+		}
+	}
+
+	cosom = p[0]*q[0] + p[1]*q[1] + p[2]*q[2] + p[3]*q[3];
+
+	if ((1.0 + cosom) > 0.000001)
+	{
+		if ((1.0 - cosom) > 0.000001)
+		{
+			omega = acos( cosom );
+			sinom = sin( omega );
+			sclp = sin( (1.0 - t)*omega) / sinom;
+			sclq = sin( t*omega ) / sinom;
+		}
+		else
+		{
+			sclp = 1.0 - t;
+			sclq = t;
+		}
+		for (i = 0; i < 4; i++) {
+			qt[i] = sclp * p[i] + sclq * q[i];
+		}
+	}
+	else
+	{
+		qt[0] = -q[1];
+		qt[1] = q[0];
+		qt[2] = -q[3];
+		qt[3] = q[2];
+		sclp = sin( (1.0 - t) * (0.5 * M_PI));
+		sclq = sin( t * (0.5 * M_PI));
+		for (i = 0; i < 3; i++)
+		{
+			qt[i] = sclp * p[i] + sclq * qt[i];
+		}
+	}
+}
+
+/*
+====================
+QuaternionMatrix
+
+====================
+*/
+void QuaternionMatrix( vec4_t quaternion, float (*matrix)[4] )
+{
+	matrix[0][0] = 1.0 - 2.0 * quaternion[1] * quaternion[1] - 2.0 * quaternion[2] * quaternion[2];
+	matrix[1][0] = 2.0 * quaternion[0] * quaternion[1] + 2.0 * quaternion[3] * quaternion[2];
+	matrix[2][0] = 2.0 * quaternion[0] * quaternion[2] - 2.0 * quaternion[3] * quaternion[1];
+
+	matrix[0][1] = 2.0 * quaternion[0] * quaternion[1] - 2.0 * quaternion[3] * quaternion[2];
+	matrix[1][1] = 1.0 - 2.0 * quaternion[0] * quaternion[0] - 2.0 * quaternion[2] * quaternion[2];
+	matrix[2][1] = 2.0 * quaternion[1] * quaternion[2] + 2.0 * quaternion[3] * quaternion[0];
+
+	matrix[0][2] = 2.0 * quaternion[0] * quaternion[2] + 2.0 * quaternion[3] * quaternion[1];
+	matrix[1][2] = 2.0 * quaternion[1] * quaternion[2] - 2.0 * quaternion[3] * quaternion[0];
+	matrix[2][2] = 1.0 - 2.0 * quaternion[0] * quaternion[0] - 2.0 * quaternion[1] * quaternion[1];
+}
+
+/*
+====================
+MatrixCopy
+
+====================
+*/
+void MatrixCopy( float in[3][4], float out[3][4] )
+{
+	memcpy( out, in, sizeof( float ) * 3 * 4 );
+}

hlsdk/ricochet/cl_dll/studio_util.h

@@ -0,0 +1,33 @@
+#if !defined( STUDIO_UTIL_H )
+#define STUDIO_UTIL_H
+#if defined( WIN32 )
+#pragma once
+#endif
+
+#ifndef M_PI
+#define M_PI		3.14159265358979323846	// matches value in gcc v2 math.h
+#endif
+
+#ifndef PITCH
+// MOVEMENT INFO
+// up / down
+#define	PITCH	0
+// left / right
+#define	YAW		1
+// fall over
+#define	ROLL	2
+#endif
+
+#define FDotProduct( a, b ) (fabs((a[0])*(b[0])) + fabs((a[1])*(b[1])) + fabs((a[2])*(b[2])))
+
+void	AngleMatrix (const float *angles, float (*matrix)[4] );
+int		VectorCompare (const float *v1, const float *v2);
+void	CrossProduct (const float *v1, const float *v2, float *cross);
+void	VectorTransform (const float *in1, float in2[3][4], float *out);
+void	ConcatTransforms (float in1[3][4], float in2[3][4], float out[3][4]);
+void	MatrixCopy( float in[3][4], float out[3][4] );
+void	QuaternionMatrix( vec4_t quaternion, float (*matrix)[4] );
+void	QuaternionSlerp( vec4_t p, vec4_t q, float t, vec4_t qt );
+void	AngleQuaternion( float *angles, vec4_t quaternion );
+
+#endif // STUDIO_UTIL_H

hlsdk/ricochet/cl_dll/text_message.cpp

@@ -0,0 +1,207 @@
+/***
+*
+*	Copyright (c) 1999, 2000 Valve LLC. All rights reserved.
+*	
+*	This product contains software technology licensed from Id 
+*	Software, Inc. ("Id Technology").  Id Technology (c) 1996 Id Software, Inc. 
+*	All Rights Reserved.
+*
+*   Use, distribution, and modification of this source code and/or resulting
+*   object code is restricted to non-commercial enhancements to products from
+*   Valve LLC.  All other use, distribution, or modification is prohibited
+*   without written permission from Valve LLC.
+*
+****/
+//
+// text_message.cpp
+//
+// implementation of CHudTextMessage class
+//
+// this class routes messages through titles.txt for localisation
+//
+
+#include "hud.h"
+#include "cl_util.h"
+#include <string.h>
+#include <stdio.h>
+#include "parsemsg.h"
+
+DECLARE_MESSAGE( m_TextMessage, TextMsg );
+
+int CHudTextMessage::Init(void)
+{
+	HOOK_MESSAGE( TextMsg );
+
+	gHUD.AddHudElem( this );
+
+	Reset();
+
+	return 1;
+};
+
+// Searches through the string for any msg names (indicated by a '#')
+// any found are looked up in titles.txt and the new message substituted
+// the new value is pushed into dst_buffer
+char *CHudTextMessage::LocaliseTextString( const char *msg, char *dst_buffer, int buffer_size )
+{
+	char *dst = dst_buffer;
+	for ( char *src = (char*)msg; *src != 0 && buffer_size > 0; buffer_size-- )
+	{
+		if ( *src == '#' )
+		{
+			// cut msg name out of string
+			static char word_buf[255];
+			char *wdst = word_buf, *word_start = src;
+			for ( ++src ; (*src >= 'A' && *src <= 'z') || (*src >= '0' && *src <= '9'); wdst++, src++ )
+			{
+				*wdst = *src;
+			}
+			*wdst = 0;
+
+			// lookup msg name in titles.txt
+			client_textmessage_t *clmsg = TextMessageGet( word_buf );
+			if ( !clmsg || !(clmsg->pMessage) )
+			{
+				src = word_start;
+				*dst = *src;
+				dst++, src++;
+				continue;
+			}
+
+			// copy string into message over the msg name
+			for ( char *wsrc = (char*)clmsg->pMessage; *wsrc != 0; wsrc++, dst++ )
+			{
+				*dst = *wsrc;
+			}
+			*dst = 0;
+		}
+		else
+		{
+			*dst = *src;
+			dst++, src++;
+			*dst = 0;
+		}
+	}
+
+	dst_buffer[buffer_size-1] = 0; // ensure null termination
+	return dst_buffer;
+}
+
+// As above, but with a local static buffer
+char *CHudTextMessage::BufferedLocaliseTextString( const char *msg )
+{
+	char dst_buffer[1024];
+	return LocaliseTextString( msg, dst_buffer, 1024 );
+}
+
+// Simplified version of LocaliseTextString;  assumes string is only one word
+char *CHudTextMessage::LookupString( const char *msg, int *msg_dest )
+{
+	if ( !msg )
+		return "";
+
+	// '#' character indicates this is a reference to a string in titles.txt, and not the string itself
+	if ( msg[0] == '#' ) 
+	{
+		// this is a message name, so look up the real message
+		client_textmessage_t *clmsg = TextMessageGet( msg+1 );
+
+		if ( !clmsg || !(clmsg->pMessage) )
+			return (char*)msg; // lookup failed, so return the original string
+		
+		if ( msg_dest )
+		{
+			// check to see if titles.txt info overrides msg destination
+			// if clmsg->effect is less than 0, then clmsg->effect holds -1 * message_destination
+			if ( clmsg->effect < 0 )  // 
+				*msg_dest = -clmsg->effect;
+		}
+
+		return (char*)clmsg->pMessage;
+	}
+	else
+	{  // nothing special about this message, so just return the same string
+		return (char*)msg;
+	}
+}
+
+void StripEndNewlineFromString( char *str )
+{
+	int s = strlen( str ) - 1;
+	if ( str[s] == '\n' || str[s] == '\r' )
+		str[s] = 0;
+}
+
+// converts all '\r' characters to '\n', so that the engine can deal with the properly
+// returns a pointer to str
+char* ConvertCRtoNL( char *str )
+{
+	for ( char *ch = str; *ch != 0; ch++ )
+		if ( *ch == '\r' )
+			*ch = '\n';
+	return str;
+}
+
+// Message handler for text messages
+// displays a string, looking them up from the titles.txt file, which can be localised
+// parameters:
+//   byte:   message direction  ( HUD_PRINTCONSOLE, HUD_PRINTNOTIFY, HUD_PRINTCENTER, HUD_PRINTTALK )
+//   string: message
+// optional parameters:
+//   string: message parameter 1
+//   string: message parameter 2
+//   string: message parameter 3
+//   string: message parameter 4
+// any string that starts with the character '#' is a message name, and is used to look up the real message in titles.txt
+// the next (optional) one to four strings are parameters for that string (which can also be message names if they begin with '#')
+int CHudTextMessage::MsgFunc_TextMsg( const char *pszName, int iSize, void *pbuf )
+{
+	BEGIN_READ( pbuf, iSize );
+
+	int msg_dest = READ_BYTE();
+
+	static char szBuf[6][128];
+	char *msg_text = LookupString( READ_STRING(), &msg_dest );
+	msg_text = strcpy( szBuf[0], msg_text );
+
+	// keep reading strings and using C format strings for subsituting the strings into the localised text string
+	char *sstr1 = LookupString( READ_STRING() );
+	sstr1 = strcpy( szBuf[1], sstr1 );
+	StripEndNewlineFromString( sstr1 );  // these strings are meant for subsitution into the main strings, so cull the automatic end newlines
+	char *sstr2 = LookupString( READ_STRING() );
+	sstr2 = strcpy( szBuf[2], sstr2 );
+	StripEndNewlineFromString( sstr2 );
+	char *sstr3 = LookupString( READ_STRING() );
+	sstr3 = strcpy( szBuf[3], sstr3 );
+	StripEndNewlineFromString( sstr3 );
+	char *sstr4 = LookupString( READ_STRING() );
+	sstr4 = strcpy( szBuf[4], sstr4 );
+	StripEndNewlineFromString( sstr4 );
+	char *psz = szBuf[5];
+
+	switch ( msg_dest )
+	{
+	case HUD_PRINTCENTER:
+		sprintf( psz, msg_text, sstr1, sstr2, sstr3, sstr4 );
+		CenterPrint( ConvertCRtoNL( psz ) );
+		break;
+
+	case HUD_PRINTNOTIFY:
+		psz[0] = 1;  // mark this message to go into the notify buffer
+		sprintf( psz+1, msg_text, sstr1, sstr2, sstr3, sstr4 );
+		ConsolePrint( ConvertCRtoNL( psz ) );
+		break;
+
+	case HUD_PRINTTALK:
+		sprintf( psz, msg_text, sstr1, sstr2, sstr3, sstr4 );
+		gHUD.m_SayText.SayTextPrint( ConvertCRtoNL( psz ), 128 );
+		break;
+
+	case HUD_PRINTCONSOLE:
+		sprintf( psz, msg_text, sstr1, sstr2, sstr3, sstr4 );
+		ConsolePrint( ConvertCRtoNL( psz ) );
+		break;
+	}
+
+	return 1;
+}

hlsdk/ricochet/cl_dll/train.cpp

@@ -0,0 +1,85 @@
+/***
+*
+*	Copyright (c) 1999, 2000 Valve LLC. All rights reserved.
+*	
+*	This product contains software technology licensed from Id 
+*	Software, Inc. ("Id Technology").  Id Technology (c) 1996 Id Software, Inc. 
+*	All Rights Reserved.
+*
+*   Use, distribution, and modification of this source code and/or resulting
+*   object code is restricted to non-commercial enhancements to products from
+*   Valve LLC.  All other use, distribution, or modification is prohibited
+*   without written permission from Valve LLC.
+*
+****/
+//
+// Train.cpp
+//
+// implementation of CHudAmmo class
+//
+
+#include "hud.h"
+#include "cl_util.h"
+#include <string.h>
+#include <stdio.h>
+#include "parsemsg.h"
+
+DECLARE_MESSAGE(m_Train, Train )
+
+
+int CHudTrain::Init(void)
+{
+	HOOK_MESSAGE( Train );
+
+	m_iPos = 0;
+	m_iFlags = 0;
+	gHUD.AddHudElem(this);
+
+	return 1;
+};
+
+int CHudTrain::VidInit(void)
+{
+	m_hSprite = 0;
+
+	return 1;
+};
+
+int CHudTrain::Draw(float fTime)
+{
+	if ( !m_hSprite )
+		m_hSprite = LoadSprite("sprites/%d_train.spr");
+
+	if (m_iPos)
+	{
+		int r, g, b, x, y;
+
+		UnpackRGB(r,g,b, RGB_YELLOWISH);
+		SPR_Set(m_hSprite, r, g, b );
+
+		// This should show up to the right and part way up the armor number
+		y = ScreenHeight - SPR_Height(m_hSprite,0) - gHUD.m_iFontHeight;
+		x = ScreenWidth/3 + SPR_Width(m_hSprite,0)/4;
+
+		SPR_DrawAdditive( m_iPos - 1,  x, y, NULL);
+
+	}
+
+	return 1;
+}
+
+
+int CHudTrain::MsgFunc_Train(const char *pszName,  int iSize, void *pbuf)
+{
+	BEGIN_READ( pbuf, iSize );
+
+	// update Train data
+	m_iPos = READ_BYTE();
+
+	if (m_iPos)
+		m_iFlags |= HUD_ACTIVE;
+	else
+		m_iFlags &= ~HUD_ACTIVE;
+
+	return 1;
+}

hlsdk/ricochet/cl_dll/tri.cpp

@@ -0,0 +1,129 @@
+/***
+*
+*	Copyright (c) 1999, 2000 Valve LLC. All rights reserved.
+*	
+*	This product contains software technology licensed from Id 
+*	Software, Inc. ("Id Technology").  Id Technology (c) 1996 Id Software, Inc. 
+*	All Rights Reserved.
+*
+*   Use, distribution, and modification of this source code and/or resulting
+*   object code is restricted to non-commercial enhancements to products from
+*   Valve LLC.  All other use, distribution, or modification is prohibited
+*   without written permission from Valve LLC.
+*
+****/
+// Triangle rendering, if any
+
+#include "hud.h"
+#include "cl_util.h"
+
+// Triangle rendering apis are in gEngfuncs.pTriAPI
+
+#include "const.h"
+#include "entity_state.h"
+#include "cl_entity.h"
+#include "triangleapi.h"
+
+#define DLLEXPORT __declspec( dllexport )
+
+extern "C"
+{
+	void DLLEXPORT HUD_DrawNormalTriangles( void );
+	void DLLEXPORT HUD_DrawTransparentTriangles( void );
+};
+
+//#define TEST_IT
+#if defined( TEST_IT )
+
+/*
+=================
+Draw_Triangles
+
+Example routine.  Draws a sprite offset from the player origin.
+=================
+*/
+void Draw_Triangles( void )
+{
+	cl_entity_t *player;
+	vec3_t org;
+
+	// Load it up with some bogus data
+	player = gEngfuncs.GetLocalPlayer();
+	if ( !player )
+		return;
+
+	org = player->origin;
+
+	org.x += 50;
+	org.y += 50;
+
+	if (gHUD.m_hsprCursor == 0)
+	{
+		char sz[256];
+		sprintf( sz, "sprites/cursor.spr" );
+		gHUD.m_hsprCursor = SPR_Load( sz );
+	}
+
+	if ( !gEngfuncs.pTriAPI->SpriteTexture( (struct model_s *)gEngfuncs.GetSpritePointer( gHUD.m_hsprCursor ), 0 ))
+	{
+		return;
+	}
+	
+	// Create a triangle, sigh
+	gEngfuncs.pTriAPI->RenderMode( kRenderNormal );
+	gEngfuncs.pTriAPI->CullFace( TRI_NONE );
+	gEngfuncs.pTriAPI->Begin( TRI_QUADS );
+	// Overload p->color with index into tracer palette, p->packedColor with brightness
+	gEngfuncs.pTriAPI->Color4f( 1.0, 1.0, 1.0, 1.0 );
+	// UNDONE: This gouraud shading causes tracers to disappear on some cards (permedia2)
+	gEngfuncs.pTriAPI->Brightness( 1 );
+	gEngfuncs.pTriAPI->TexCoord2f( 0, 0 );
+	gEngfuncs.pTriAPI->Vertex3f( org.x, org.y, org.z );
+
+	gEngfuncs.pTriAPI->Brightness( 1 );
+	gEngfuncs.pTriAPI->TexCoord2f( 0, 1 );
+	gEngfuncs.pTriAPI->Vertex3f( org.x, org.y + 50, org.z );
+
+	gEngfuncs.pTriAPI->Brightness( 1 );
+	gEngfuncs.pTriAPI->TexCoord2f( 1, 1 );
+	gEngfuncs.pTriAPI->Vertex3f( org.x + 50, org.y + 50, org.z );
+
+	gEngfuncs.pTriAPI->Brightness( 1 );
+	gEngfuncs.pTriAPI->TexCoord2f( 1, 0 );
+	gEngfuncs.pTriAPI->Vertex3f( org.x + 50, org.y, org.z );
+
+	gEngfuncs.pTriAPI->End();
+	gEngfuncs.pTriAPI->RenderMode( kRenderNormal );
+}
+
+#endif
+
+/*
+=================
+HUD_DrawNormalTriangles
+
+Non-transparent triangles-- add them here
+=================
+*/
+void DLLEXPORT HUD_DrawNormalTriangles( void )
+{
+
+#if defined( TEST_IT )
+//	Draw_Triangles();
+#endif
+}
+
+/*
+=================
+HUD_DrawTransparentTriangles
+
+Render any triangles with transparent rendermode needs here
+=================
+*/
+void DLLEXPORT HUD_DrawTransparentTriangles( void )
+{
+
+#if defined( TEST_IT )
+//	Draw_Triangles();
+#endif
+}

hlsdk/ricochet/cl_dll/util.cpp

@@ -0,0 +1,101 @@
+/***
+*
+*	Copyright (c) 1999, 2000 Valve LLC. All rights reserved.
+*	
+*	This product contains software technology licensed from Id 
+*	Software, Inc. ("Id Technology").  Id Technology (c) 1996 Id Software, Inc. 
+*	All Rights Reserved.
+*
+*   Use, distribution, and modification of this source code and/or resulting
+*   object code is restricted to non-commercial enhancements to products from
+*   Valve LLC.  All other use, distribution, or modification is prohibited
+*   without written permission from Valve LLC.
+*
+****/
+//
+// util.cpp
+//
+// implementation of class-less helper functions
+//
+
+#include "STDIO.H"
+#include "STDLIB.H"
+#include "MATH.H"
+
+#include "hud.h"
+#include "cl_util.h"
+#include <string.h>
+
+vec3_t vec3_origin( 0, 0, 0 );
+
+double sqrt(double x);
+
+float Length(const float *v)
+{
+	int		i;
+	float	length;
+	
+	length = 0;
+	for (i=0 ; i< 3 ; i++)
+		length += v[i]*v[i];
+	length = sqrt (length);		// FIXME
+
+	return length;
+}
+
+float VectorNormalize (float *v)
+{
+	float	length, ilength;
+
+	length = v[0]*v[0] + v[1]*v[1] + v[2]*v[2];
+	length = sqrt (length);		// FIXME
+
+	if (length)
+	{
+		ilength = 1/length;
+		v[0] *= ilength;
+		v[1] *= ilength;
+		v[2] *= ilength;
+	}
+		
+	return length;
+
+}
+
+void VectorInverse ( float *v )
+{
+	v[0] = -v[0];
+	v[1] = -v[1];
+	v[2] = -v[2];
+}
+
+void VectorScale (const float *in, float scale, float *out)
+{
+	out[0] = in[0]*scale;
+	out[1] = in[1]*scale;
+	out[2] = in[2]*scale;
+}
+
+void VectorMA (const float *veca, float scale, const float *vecb, float *vecc)
+{
+	vecc[0] = veca[0] + scale*vecb[0];
+	vecc[1] = veca[1] + scale*vecb[1];
+	vecc[2] = veca[2] + scale*vecb[2];
+}
+
+
+HSPRITE LoadSprite(const char *pszName)
+{
+	int i;
+	char sz[256]; 
+
+	if (ScreenWidth < 640)
+		i = 320;
+	else
+		i = 640;
+
+	sprintf(sz, pszName, i);
+
+	return SPR_Load(sz);
+}
+

hlsdk/ricochet/cl_dll/util_vector.h

@@ -0,0 +1,121 @@
+/***
+*
+*	Copyright (c) 1999, 2000 Valve LLC. All rights reserved.
+*	
+*	This product contains software technology licensed from Id 
+*	Software, Inc. ("Id Technology").  Id Technology (c) 1996 Id Software, Inc. 
+*	All Rights Reserved.
+*
+*   Use, distribution, and modification of this source code and/or resulting
+*   object code is restricted to non-commercial enhancements to products from
+*   Valve LLC.  All other use, distribution, or modification is prohibited
+*   without written permission from Valve LLC.
+*
+****/
+//  Vector.h
+// A subset of the extdll.h in the project HL Entity DLL
+//
+
+// Misc C-runtime library headers
+#include "STDIO.H"
+#include "STDLIB.H"
+#include "MATH.H"
+
+// Header file containing definition of globalvars_t and entvars_t
+typedef int	func_t;					//
+typedef int	string_t;				// from engine's pr_comp.h;
+typedef float vec_t;				// needed before including progdefs.h
+
+//=========================================================
+// 2DVector - used for many pathfinding and many other 
+// operations that are treated as planar rather than 3d.
+//=========================================================
+class Vector2D
+{
+public:
+	inline Vector2D(void)									{ }
+	inline Vector2D(float X, float Y)						{ x = X; y = Y; }
+	inline Vector2D operator+(const Vector2D& v)	const	{ return Vector2D(x+v.x, y+v.y);	}
+	inline Vector2D operator-(const Vector2D& v)	const	{ return Vector2D(x-v.x, y-v.y);	}
+	inline Vector2D operator*(float fl)				const	{ return Vector2D(x*fl, y*fl);	}
+	inline Vector2D operator/(float fl)				const	{ return Vector2D(x/fl, y/fl);	}
+	
+	inline float Length(void)						const	{ return (float)sqrt(x*x + y*y );		}
+
+	inline Vector2D Normalize ( void ) const
+	{
+		Vector2D vec2;
+
+		float flLen = Length();
+		if ( flLen == 0 )
+		{
+			return Vector2D( (float)0, (float)0 );
+		}
+		else
+		{
+			flLen = 1 / flLen;
+			return Vector2D( x * flLen, y * flLen );
+		}
+	}
+
+	vec_t	x, y;
+};
+
+inline float DotProduct(const Vector2D& a, const Vector2D& b) { return( a.x*b.x + a.y*b.y ); }
+inline Vector2D operator*(float fl, const Vector2D& v)	{ return v * fl; }
+
+//=========================================================
+// 3D Vector
+//=========================================================
+class Vector						// same data-layout as engine's vec3_t,
+{								//		which is a vec_t[3]
+public:
+	// Construction/destruction
+	inline Vector(void)								{ }
+	inline Vector(float X, float Y, float Z)		{ x = X; y = Y; z = Z;						}
+	inline Vector(double X, double Y, double Z)		{ x = (float)X; y = (float)Y; z = (float)Z;	}
+	inline Vector(int X, int Y, int Z)				{ x = (float)X; y = (float)Y; z = (float)Z;	}
+	inline Vector(const Vector& v)					{ x = v.x; y = v.y; z = v.z;				} 
+	inline Vector(float rgfl[3])					{ x = rgfl[0]; y = rgfl[1]; z = rgfl[2];	}
+
+	// Operators
+	inline Vector operator-(void) const				{ return Vector(-x,-y,-z);				}
+	inline int operator==(const Vector& v) const	{ return x==v.x && y==v.y && z==v.z;	}
+	inline int operator!=(const Vector& v) const	{ return !(*this==v);					}
+	inline Vector operator+(const Vector& v) const	{ return Vector(x+v.x, y+v.y, z+v.z);	}
+	inline Vector operator-(const Vector& v) const	{ return Vector(x-v.x, y-v.y, z-v.z);	}
+	inline Vector operator*(float fl) const			{ return Vector(x*fl, y*fl, z*fl);		}
+	inline Vector operator/(float fl) const			{ return Vector(x/fl, y/fl, z/fl);		}
+	
+	// Methods
+	inline void CopyToArray(float* rgfl) const		{ rgfl[0] = x, rgfl[1] = y, rgfl[2] = z; }
+	inline float Length(void) const					{ return (float)sqrt(x*x + y*y + z*z); }
+	operator float *()								{ return &x; } // Vectors will now automatically convert to float * when needed
+	operator const float *() const					{ return &x; } // Vectors will now automatically convert to float * when needed
+	inline Vector Normalize(void) const
+	{
+		float flLen = Length();
+		if (flLen == 0) return Vector(0,0,1); // ????
+		flLen = 1 / flLen;
+		return Vector(x * flLen, y * flLen, z * flLen);
+	}
+
+	inline Vector2D Make2D ( void ) const
+	{
+		Vector2D	Vec2;
+
+		Vec2.x = x;
+		Vec2.y = y;
+
+		return Vec2;
+	}
+	inline float Length2D(void) const					{ return (float)sqrt(x*x + y*y); }
+
+	// Members
+	vec_t x, y, z;
+};
+inline Vector operator*(float fl, const Vector& v)	{ return v * fl; }
+inline float DotProduct(const Vector& a, const Vector& b) { return(a.x*b.x+a.y*b.y+a.z*b.z); }
+inline Vector CrossProduct(const Vector& a, const Vector& b) { return Vector( a.y*b.z - a.z*b.y, a.z*b.x - a.x*b.z, a.x*b.y - a.y*b.x ); }
+
+#define vec3_t Vector

hlsdk/ricochet/cl_dll/vgui_ConsolePanel.cpp

@@ -0,0 +1,95 @@
+
+#include"vgui_ConsolePanel.h"
+#include"hud.h"
+#include<VGUI_ActionSignal.h>
+#include<VGUI_TextGrid.h>
+#include<VGUI_TextEntry.h>
+#include<VGUI_EtchedBorder.h>
+#include<VGUI_LoweredBorder.h>
+
+using namespace vgui;
+
+
+namespace
+{
+
+class Handler : public ActionSignal
+{
+private:
+	
+	ConsolePanel* _consolePanel;
+
+public:
+
+	Handler(ConsolePanel* consolePanel)
+	{
+		_consolePanel=consolePanel;
+	}
+
+public:
+
+	virtual void actionPerformed(Panel* panel)
+	{
+		_consolePanel->doExecCommand();
+	}
+
+};
+
+}
+
+
+
+ConsolePanel::ConsolePanel(int x,int y,int wide,int tall) : Panel(x,y,wide,tall)
+{
+	setBorder(new EtchedBorder());
+	
+	_textGrid=new TextGrid(80,21,5,5,200,100);
+	_textGrid->setBorder(new LoweredBorder());
+	_textGrid->setParent(this);
+	
+	_textEntry=new TextEntry("",5,5,200,20);
+	_textEntry->setParent(this);
+	_textEntry->addActionSignal(new Handler(this));
+}
+
+int ConsolePanel::print(const char* text)
+{
+	return _textGrid->printf("%s",text);
+}
+
+int ConsolePanel::vprintf(const char* format,va_list argList)
+{
+	return _textGrid->vprintf(format,argList);
+}
+
+int ConsolePanel::printf(const char* format,...)
+{
+	va_list argList;
+	va_start(argList,format);
+	int ret=vprintf(format,argList);
+	va_end(argList);
+	return ret;
+}
+
+void ConsolePanel::doExecCommand()
+{
+	char buf[2048];
+	_textEntry->getText(0,buf,2048);
+	_textEntry->setText(null,0);
+	gEngfuncs.pfnClientCmd(buf);
+}
+
+void ConsolePanel::setSize(int wide,int tall)
+{
+	Panel::setSize(wide,tall);
+		
+	getPaintSize(wide,tall);
+
+	_textGrid->setBounds(5,5,wide-10,tall-35);
+	_textEntry->setBounds(5,tall-25,wide-10,20);
+}
+
+
+
+
+

hlsdk/ricochet/cl_dll/vgui_ConsolePanel.h

@@ -0,0 +1,32 @@
+
+#ifndef CONSOLEPANEL_H
+#define CONSOLEPANEL_H
+
+#include<stdarg.h>
+#include<VGUI_Panel.h>
+
+namespace vgui
+{
+class TextGrid;
+class TextEntry;
+}
+
+
+class ConsolePanel : public vgui::Panel
+{
+private:
+	vgui::TextGrid*  _textGrid;
+	vgui::TextEntry* _textEntry;
+public:
+	ConsolePanel(int x,int y,int wide,int tall);
+public:
+	virtual void setSize(int wide,int tall);
+	virtual int  print(const char* text);
+	virtual int  vprintf(const char* format,va_list argList);
+	virtual int  printf(const char* format,...);
+	virtual void doExecCommand();
+};
+
+
+
+#endif

hlsdk/ricochet/cl_dll/vgui_ControlConfigPanel.cpp

@@ -0,0 +1,206 @@
+
+#include<stdio.h>
+#include"vgui_ControlConfigPanel.h"
+#include<VGUI_HeaderPanel.h>
+#include<VGUI_TablePanel.h>
+#include<VGUI_Label.h>
+#include<VGUI_ScrollPanel.h>
+#include<VGUI_Scheme.h>
+#include<VGUI_DataInputStream.h>
+#include<VGUI.h>
+#include<VGUI_TextEntry.h>
+
+using namespace vgui;
+
+namespace
+{
+class FooTablePanel : public TablePanel
+{
+private:
+	Label*              _label;
+	TextEntry*          _textEntry;
+	ControlConfigPanel* _controlConfigPanel;
+public:
+	FooTablePanel(ControlConfigPanel* controlConfigPanel,int x,int y,int wide,int tall,int columnCount) : TablePanel(x,y,wide,tall,columnCount)
+	{
+		_controlConfigPanel=controlConfigPanel;
+		_label=new Label("You are a dumb monkey",0,0,100,20);
+		_label->setBgColor(Scheme::sc_primary3);
+		_label->setFgColor(Scheme::sc_primary1);
+		_label->setFont(Scheme::sf_primary3);
+
+		_textEntry=new TextEntry("",0,0,100,20);
+		//_textEntry->setFont(Scheme::sf_primary3);
+	}
+public:
+	virtual int getRowCount()
+	{
+		return _controlConfigPanel->GetCVarCount();
+	}
+	virtual int getCellTall(int row)
+	{
+		return 12;
+	}
+	virtual Panel* getCellRenderer(int column,int row,bool columnSelected,bool rowSelected,bool cellSelected)
+	{
+		char cvar[128],desc[128],bind[128],bindAlt[128];
+		_controlConfigPanel->GetCVar(row,cvar,128,desc,128);
+
+		if(cellSelected)
+		{
+			_label->setBgColor(Scheme::sc_primary1);
+			_label->setFgColor(Scheme::sc_primary3);
+		}
+		else
+		if(rowSelected)
+		{
+			_label->setBgColor(Scheme::sc_primary2);
+			_label->setFgColor(Scheme::sc_primary1);
+		}
+		else
+		{
+			_label->setBgColor(Scheme::sc_primary3);
+			_label->setFgColor(Scheme::sc_primary1);
+		}
+
+		switch(column)
+		{
+			case 0:
+			{
+				_label->setText(desc);
+				_label->setContentAlignment(Label::a_west);
+				break;
+			}
+			case 1:
+			{
+				_controlConfigPanel->GetCVarBind(cvar,bind,128,bindAlt,128);
+				_label->setText(bind);
+				_label->setContentAlignment(Label::a_center);
+				break;
+			}
+			case 2:
+			{
+				_controlConfigPanel->GetCVarBind(cvar,bind,128,bindAlt,128);
+				_label->setText(bindAlt);
+				_label->setContentAlignment(Label::a_center);
+				break;
+			}
+			default:
+			{
+				_label->setText("");
+				break;
+			}
+		}
+
+		return _label;
+	}
+	virtual Panel* startCellEditing(int column,int row)
+	{
+		_textEntry->setText("Goat",strlen("Goat"));
+		_textEntry->requestFocus();
+		return _textEntry;
+	}
+};
+}
+
+ControlConfigPanel::ControlConfigPanel(int x,int y,int wide,int tall) : Panel(x,y,wide,tall)
+{
+	setPaintBorderEnabled(false);
+	setPaintBackgroundEnabled(false);
+	setPaintEnabled(false);
+
+	_actionLabel=new Label("Action");
+	_actionLabel->setBgColor(Scheme::sc_primary3);
+	_actionLabel->setFgColor(Scheme::sc_primary3);
+
+	_keyButtonLabel=new Label("Key / Button");
+	_keyButtonLabel->setBgColor(Scheme::sc_primary3);
+	_keyButtonLabel->setFgColor(Scheme::sc_primary3);
+
+	_alternateLabel=new Label("Alternate");
+	_alternateLabel->setBgColor(Scheme::sc_primary3);
+	_alternateLabel->setFgColor(Scheme::sc_primary3);
+	
+	_headerPanel=new HeaderPanel(0,0,wide,20);
+	_headerPanel->setParent(this);
+
+	_headerPanel->addSectionPanel(_actionLabel);
+	_headerPanel->addSectionPanel(_keyButtonLabel);
+	_headerPanel->addSectionPanel(_alternateLabel);
+	
+	_headerPanel->setSliderPos( 0, wide/2 );
+	_headerPanel->setSliderPos( 1, (wide/2) + (wide/4) );
+	_headerPanel->setSliderPos( 2, wide );
+
+	_scrollPanel=new ScrollPanel(0,20,wide,tall-20);
+	_scrollPanel->setParent(this);
+	_scrollPanel->setPaintBorderEnabled(false);
+	_scrollPanel->setPaintBackgroundEnabled(false);
+	_scrollPanel->setPaintEnabled(false);
+	_scrollPanel->getClient()->setPaintBorderEnabled(false);
+	_scrollPanel->getClient()->setPaintBackgroundEnabled(false);
+	_scrollPanel->getClient()->setPaintEnabled(false);
+	_scrollPanel->setScrollBarVisible(false,true);
+
+	_tablePanel=new FooTablePanel(this,0,0,_scrollPanel->getClient()->getWide(),800, 3);
+	_tablePanel->setParent(_scrollPanel->getClient());
+	_tablePanel->setHeaderPanel(_headerPanel);
+	_tablePanel->setBgColor(Color(200,0,0,255));
+	_tablePanel->setFgColor(Color(Scheme::sc_primary2));
+	_tablePanel->setGridVisible(true,true);
+	_tablePanel->setGridSize(1,1);
+}
+
+void ControlConfigPanel::AddCVar(const char* cvar,const char* desc)
+{
+	_cvarDar.addElement(vgui_strdup(cvar));
+	_descDar.addElement(vgui_strdup(desc));
+}
+
+int ControlConfigPanel::GetCVarCount()
+{
+	return _cvarDar.getCount();
+}
+
+void ControlConfigPanel::GetCVar(int index,char* cvar,int cvarLen,char* desc,int descLen)
+{
+	vgui_strcpy(cvar,cvarLen,_cvarDar[index]);
+	vgui_strcpy(desc,descLen,_descDar[index]);
+}
+
+void ControlConfigPanel::AddCVarFromInputStream(InputStream* is)
+{
+	if(is==null)
+	{
+		return;
+	}
+	
+	DataInputStream dis(is);
+
+	bool success;
+
+	while(1)
+	{
+		char buf[256],cvar[128],desc[128];
+		dis.readLine(buf,256,success);
+		if(!success)
+		{
+			break;
+		}
+		if(sscanf(buf,"\"%[^\"]\" \"%[^\"]\"",cvar,desc)==2)
+		{
+			AddCVar(cvar,desc);
+		}
+	}
+}
+
+void ControlConfigPanel::GetCVarBind(const char* cvar,char* bind,int bindLen,char* bindAlt,int bindAltLen)
+{
+	sprintf(bind,"%s : Bind",cvar);
+	sprintf(bindAlt,"%s : BindAlt",cvar);
+}
+
+void ControlConfigPanel::SetCVarBind(const char* cvar,const char* bind,const char* bindAlt)
+{
+}
+

hlsdk/ricochet/cl_dll/vgui_ControlConfigPanel.h

@@ -0,0 +1,41 @@
+
+#ifndef CONTROLCONFIGPANEL_H
+#define CONTROLCONFIGPANEL_H
+
+#include<VGUI_Panel.h>
+#include<VGUI_Dar.h>
+
+namespace vgui
+{
+class HeaderPanel;
+class TablePanel;
+class ScrollPanel;
+class InputStream;
+class Label;
+}
+
+class ControlConfigPanel : public vgui::Panel
+{
+private:
+	vgui::HeaderPanel* _headerPanel;
+	vgui::TablePanel*  _tablePanel;
+	vgui::ScrollPanel* _scrollPanel;
+	vgui::Dar<char*>   _cvarDar;
+	vgui::Dar<char*>   _descDar;
+	vgui::Label*       _actionLabel;
+	vgui::Label*       _keyButtonLabel;
+	vgui::Label*       _alternateLabel;
+public:
+	ControlConfigPanel(int x,int y,int wide,int tall);
+public:
+	void AddCVar(const char* cvar,const char* desc);
+	void AddCVarFromInputStream(vgui::InputStream* is);
+	int  GetCVarCount();
+	void GetCVar(int index,char* cvar,int cvarLen,char* desc,int descLen);
+	void GetCVarBind(const char* cvar,char* bind,int bindLen,char* bindAlt,int bindAltLen);
+	void SetCVarBind(const char* cvar,const char* bind,const char* bindAlt);
+};
+
+
+
+#endif

hlsdk/ricochet/cl_dll/vgui_CustomObjects.cpp

@@ -0,0 +1,501 @@
+//=========== (C) Copyright 1999 Valve, L.L.C. All rights reserved. ===========
+//
+// The copyright to the contents herein is the property of Valve, L.L.C.
+// The contents may be used and/or copied only with the written permission of
+// Valve, L.L.C., or in accordance with the terms and conditions stipulated in
+// the agreement/contract under which the contents have been supplied.
+//
+// Purpose: Contains implementation of various VGUI-derived objects
+//
+// $Workfile:     $
+// $Date:         $
+//
+//-----------------------------------------------------------------------------
+// $Log: $
+//
+// $NoKeywords: $
+//=============================================================================
+
+#include "VGUI_Font.h"
+
+#include "hud.h"
+#include "cl_util.h"
+#include "camera.h"
+#include "kbutton.h"
+#include "cvardef.h"
+#include "usercmd.h"
+#include "const.h"
+#include "camera.h"
+#include "in_defs.h"
+#include "parsemsg.h"
+
+#include "vgui_int.h"
+#include "vgui_TeamFortressViewport.h"
+#include "vgui_ServerBrowser.h"
+#include "vgui_LoadTGA.h"
+
+// Arrow filenames
+char *sArrowFilenames[] =
+{
+	"arrowup",
+	"arrowdn", 
+	"arrowlt",
+	"arrowrt", 
+};
+
+// Get the name of TGA file, without a gamedir
+char *GetTGANameForRes(const char *pszName)
+{
+	int i;
+	char sz[256]; 
+	static char gd[256]; 
+	if (ScreenWidth < 640)
+		i = 320;
+	else
+		i = 640;
+	sprintf(sz, pszName, i);
+	sprintf(gd, "gfx/vgui/%s.tga", sz);
+	return gd;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Loads a .tga file and returns a pointer to the VGUI tga object
+//-----------------------------------------------------------------------------
+BitmapTGA *LoadTGAForRes( const char* pImageName )
+{
+	BitmapTGA	*pTGA;
+
+	char sz[256];
+	sprintf(sz, "%%d_%s", pImageName);
+	pTGA = vgui_LoadTGA(GetTGANameForRes(sz));
+
+	return pTGA;
+}
+
+//===========================================================
+// All TFC Hud buttons are derived from this one.
+CommandButton::CommandButton( const char* text,int x,int y,int wide,int tall, bool bNoHighlight) : Button("",x,y,wide,tall)
+{
+	m_iPlayerClass = 0;
+	m_bNoHighlight = bNoHighlight;
+	Init();
+	setText( text );
+}
+
+CommandButton::CommandButton( int iPlayerClass, const char* text,int x,int y,int wide,int tall) : Button("",x,y,wide,tall)
+{
+	m_iPlayerClass = iPlayerClass;
+	m_bNoHighlight = false;
+	Init();
+	setText( text );
+}
+
+void CommandButton::Init( void )
+{
+	m_pSubMenu = NULL;
+	m_pSubLabel = NULL;
+	m_pParentMenu = NULL;
+
+	// Set text color to orange
+	setFgColor(Scheme::sc_primary1);
+
+	// left align
+	setContentAlignment( vgui::Label::a_west );
+
+	// Add the Highlight signal
+	if (!m_bNoHighlight)
+		addInputSignal( new CHandler_CommandButtonHighlight(this) );
+
+	// not bound to any button yet
+	m_cBoundKey = 0;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Prepends the button text with the current bound key
+//			if no bound key, then a clear space ' ' instead
+//-----------------------------------------------------------------------------
+void CommandButton::RecalculateText( void )
+{
+	char szBuf[128];
+
+	if ( m_cBoundKey != 0 )
+	{
+		sprintf( szBuf, "  %c  %s", m_cBoundKey, m_sMainText );
+		szBuf[MAX_BUTTON_SIZE-1] = 0;
+	}
+	else
+	{
+		// just draw a space if no key bound
+		sprintf( szBuf, "     %s", m_sMainText );
+		szBuf[MAX_BUTTON_SIZE-1] = 0;
+	}
+
+	Button::setText( szBuf );
+}
+
+void CommandButton::setText( const char *text )
+{
+	strncpy( m_sMainText, text, MAX_BUTTON_SIZE );
+	m_sMainText[MAX_BUTTON_SIZE-1] = 0;
+
+	RecalculateText();
+}
+
+void CommandButton::setBoundKey( char boundKey )
+{
+	m_cBoundKey = boundKey;
+	RecalculateText();
+}
+
+char CommandButton::getBoundKey( void )
+{
+	return m_cBoundKey;
+}
+
+void CommandButton::AddSubMenu( CCommandMenu *pNewMenu )
+{
+	m_pSubMenu = pNewMenu;
+
+	// Prevent this button from being pushed
+	setMouseClickEnabled( MOUSE_LEFT, false );
+}
+
+void CommandButton::UpdateSubMenus( int iAdjustment )
+{
+	if ( m_pSubMenu )
+		m_pSubMenu->RecalculatePositions( iAdjustment );
+}
+
+void CommandButton::paint()
+{
+	// Make the sub label paint the same as the button
+	if ( m_pSubLabel )
+	{
+		if ( isSelected() )
+			m_pSubLabel->PushDown();
+		else
+			m_pSubLabel->PushUp();
+	}
+
+	// draw armed button text in white
+	if ( isArmed() )
+	{
+		setFgColor( Scheme::sc_secondary2 );
+	}
+	else
+	{
+		setFgColor( Scheme::sc_primary1 );
+	}
+	
+	Button::paint();
+}
+
+void CommandButton::paintBackground()
+{
+	if ( isArmed() )
+	{
+		// Orange highlight background
+		drawSetColor( Scheme::sc_primary2 );
+		drawFilledRect(0,0,_size[0],_size[1]);
+	}
+
+	// Orange Border
+	drawSetColor( Scheme::sc_secondary1 );
+	drawOutlinedRect(0,0,_size[0],_size[1]);
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Highlights the current button, and all it's parent menus
+//-----------------------------------------------------------------------------
+void CommandButton::cursorEntered( void )
+{
+	// unarm all the other buttons in this menu
+	CCommandMenu *containingMenu = getParentMenu();
+	if ( containingMenu )
+	{
+		containingMenu->ClearButtonsOfArmedState();
+
+		// make all our higher buttons armed
+		CCommandMenu *pCParent = containingMenu->GetParentMenu();
+		if ( pCParent )
+		{
+			CommandButton *pParentButton = pCParent->FindButtonWithSubmenu( containingMenu );
+
+			pParentButton->cursorEntered();
+		}
+	}
+
+	// arm ourselves
+	setArmed( true );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CommandButton::cursorExited( void )
+{
+	// only clear ourselves if we have do not have a containing menu
+	// only stay armed if we have a sub menu
+	// the buttons only unarm themselves when another button is armed instead
+	if ( !getParentMenu() || !GetSubMenu() )
+	{
+		setArmed( false );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Returns the command menu that the button is part of, if any
+// Output : CCommandMenu *
+//-----------------------------------------------------------------------------
+CCommandMenu *CommandButton::getParentMenu( void )
+{ 
+	return m_pParentMenu; 
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Sets the menu that contains this button
+// Input  : *pParentMenu - 
+//-----------------------------------------------------------------------------
+void CommandButton::setParentMenu( CCommandMenu *pParentMenu )
+{
+	m_pParentMenu = pParentMenu;
+}
+
+
+//===========================================================
+int ClassButton::IsNotValid()
+{
+	// If this is the main ChangeClass button, remove it if the player's only able to be civilians
+	if ( m_iPlayerClass == -1 )
+	{
+		if (gViewPort->GetValidClasses(g_iTeamNumber) == -1)
+			return true;
+
+		return false;
+	}
+
+	// Is it an illegal class?
+	if ((gViewPort->GetValidClasses(0) & sTFValidClassInts[ m_iPlayerClass ]) || (gViewPort->GetValidClasses(g_iTeamNumber) & sTFValidClassInts[ m_iPlayerClass ]))
+		return true;
+
+	// Only check current class if they've got autokill on
+	bool bAutoKill = CVAR_GET_FLOAT( "hud_classautokill" ) != 0;
+	if ( bAutoKill )
+	{	
+		// Is it the player's current class?
+		if ( (gViewPort->IsRandomPC() && m_iPlayerClass == PC_RANDOM) || (!gViewPort->IsRandomPC() && (m_iPlayerClass == g_iPlayerClass)) )
+			return true;
+	}
+
+	return false;
+}
+
+//===========================================================
+// Button with Class image beneath it
+CImageLabel::CImageLabel( const char* pImageName,int x,int y ) : Label( "", x,y )
+{
+	setContentFitted(true);
+	m_pTGA = LoadTGAForRes(pImageName);
+	setImage( m_pTGA );
+}
+
+CImageLabel::CImageLabel( const char* pImageName,int x,int y,int wide,int tall ) : Label( "", x,y,wide,tall )
+{
+	setContentFitted(true);
+	m_pTGA = LoadTGAForRes(pImageName);
+	setImage( m_pTGA );
+}
+
+//===========================================================
+// Image size
+int CImageLabel::getImageWide( void )
+{
+	if( m_pTGA )
+	{
+		int iXSize, iYSize;
+		m_pTGA->getSize( iXSize, iYSize );
+		return iXSize;
+	}
+	else
+	{
+		return 1;
+	}
+}
+
+int CImageLabel::getImageTall( void )
+{
+	if( m_pTGA )
+	{
+		int iXSize, iYSize;
+		m_pTGA->getSize( iXSize, iYSize );
+		return iYSize;
+	}
+	else
+	{
+		return 1;
+	}
+}
+
+void CImageLabel::LoadImage(const char * pImageName)
+{
+	if ( m_pTGA )
+		delete m_pTGA;
+
+	// Load the Image
+	m_pTGA = LoadTGAForRes(pImageName);
+
+	if ( m_pTGA == NULL )
+	{
+		// we didn't find a matching image file for this resolution
+		// try to load file resolution independent
+
+		char sz[256];
+		sprintf(sz, "%s/%s",gEngfuncs.pfnGetGameDirectory(), pImageName );
+		FileInputStream* fis = new FileInputStream( sz, false );
+		m_pTGA = new BitmapTGA(fis,true);
+		fis->close();
+	}
+
+	if ( m_pTGA == NULL )
+		return;	// unable to load image
+	 	
+	int w,t;
+
+	m_pTGA->getSize( w, t );
+
+	setSize( XRES (w),YRES (t) );
+	setImage( m_pTGA );
+}
+
+//===========================================================
+// Various overloaded paint functions for Custom VGUI objects
+void CCommandMenu::paintBackground()
+{
+	// Transparent black background
+	drawSetColor(Scheme::sc_primary3);
+	drawFilledRect(0,0,_size[0],_size[1]);
+}
+
+//=================================================================================
+// CUSTOM SCROLLPANEL
+//=================================================================================
+CTFScrollButton::CTFScrollButton(int iArrow, const char* text,int x,int y,int wide,int tall) : CommandButton(text,x,y,wide,tall)
+{
+	// Set text color to orange
+	setFgColor(Scheme::sc_primary1);
+
+	// Load in the arrow
+	m_pTGA = LoadTGAForRes( sArrowFilenames[iArrow] );
+	setImage( m_pTGA );
+
+	// Highlight signal
+	InputSignal *pISignal = new CHandler_CommandButtonHighlight(this);
+	addInputSignal(pISignal);
+}
+
+void CTFScrollButton::paint( void )
+{
+	if (!m_pTGA)
+		return;
+	// draw armed button text in white
+	if ( isArmed() )
+	{
+		m_pTGA->setColor( Color(255,255,255, 0) );
+	}
+	else
+	{
+		m_pTGA->setColor( Color(255,255,255, 128) );
+	}
+
+	m_pTGA->doPaint(this);
+}
+
+void CTFScrollButton::paintBackground( void )
+{
+/*
+	if ( isArmed() )
+	{
+		// Orange highlight background
+		drawSetColor( Scheme::sc_primary2 );
+		drawFilledRect(0,0,_size[0],_size[1]);
+	}
+
+	// Orange Border
+	drawSetColor( Scheme::sc_secondary1 );
+	drawOutlinedRect(0,0,_size[0]-1,_size[1]);
+*/
+}
+
+void CTFSlider::paintBackground( void )
+{
+	int wide,tall,nobx,noby;
+	getPaintSize(wide,tall);
+	getNobPos(nobx,noby);
+
+	// Border
+	drawSetColor( Scheme::sc_secondary1 );
+	drawOutlinedRect( 0,0,wide,tall );
+
+	if( isVertical() )
+	{
+		// Nob Fill
+		drawSetColor( Scheme::sc_primary2 );
+		drawFilledRect( 0,nobx,wide,noby );
+
+		// Nob Outline
+		drawSetColor( Scheme::sc_primary1 );
+		drawOutlinedRect( 0,nobx,wide,noby );
+	}
+	else
+	{
+		// Nob Fill
+		drawSetColor( Scheme::sc_primary2 );
+		drawFilledRect( nobx,0,noby,tall );
+
+		// Nob Outline
+		drawSetColor( Scheme::sc_primary1 );
+		drawOutlinedRect( nobx,0,noby,tall );
+	}
+}
+
+CTFScrollPanel::CTFScrollPanel(int x,int y,int wide,int tall) : ScrollPanel(x,y,wide,tall)
+{
+	ScrollBar *pScrollBar = getVerticalScrollBar();
+	pScrollBar->setButton( new CTFScrollButton( ARROW_UP, "", 0,0,16,16 ), 0 );
+	pScrollBar->setButton( new CTFScrollButton( ARROW_DOWN, "", 0,0,16,16 ), 1 );
+	pScrollBar->setSlider( new CTFSlider(0,wide-1,wide,(tall-(wide*2))+2,true) ); 
+	pScrollBar->setPaintBorderEnabled(false);
+	pScrollBar->setPaintBackgroundEnabled(false);
+	pScrollBar->setPaintEnabled(false);
+
+	pScrollBar = getHorizontalScrollBar();
+	pScrollBar->setButton( new CTFScrollButton( ARROW_LEFT, "", 0,0,16,16 ), 0 );
+	pScrollBar->setButton( new CTFScrollButton( ARROW_RIGHT, "", 0,0,16,16 ), 1 );
+	pScrollBar->setSlider( new CTFSlider(tall,0,wide-(tall*2),tall,false) );
+	pScrollBar->setPaintBorderEnabled(false);
+	pScrollBar->setPaintBackgroundEnabled(false);
+	pScrollBar->setPaintEnabled(false);
+}
+
+
+//=================================================================================
+// CUSTOM HANDLERS
+//=================================================================================
+void CHandler_MenuButtonOver::cursorEntered(Panel *panel)
+{
+	if ( gViewPort && m_pMenuPanel )
+	{
+		m_pMenuPanel->SetActiveInfo( m_iButton );
+	}
+}
+
+void CMenuHandler_StringCommandClassSelect::actionPerformed(Panel* panel)
+{
+	CMenuHandler_StringCommand::actionPerformed( panel );
+
+	bool bAutoKill = CVAR_GET_FLOAT( "hud_classautokill" ) != 0;
+	if ( bAutoKill && g_iPlayerClass != 0 )
+		gEngfuncs.pfnClientCmd("kill");
+}
+
+

hlsdk/ricochet/cl_dll/vgui_MOTDWindow.cpp

@@ -0,0 +1,154 @@
+//=========== (C) Copyright 1999 Valve, L.L.C. All rights reserved. ===========
+//
+// The copyright to the contents herein is the property of Valve, L.L.C.
+// The contents may be used and/or copied only with the written permission of
+// Valve, L.L.C., or in accordance with the terms and conditions stipulated in
+// the agreement/contract under which the contents have been supplied.
+//
+// Purpose: 
+//
+// $Workfile:     $
+// $Date:         $
+//
+//-----------------------------------------------------------------------------
+// $Log: $
+//
+// $NoKeywords: $
+//=============================================================================
+
+#include "VGUI_Font.h"
+#include "VGUI_ScrollPanel.h"
+#include "VGUI_TextImage.h"
+
+#include<VGUI_StackLayout.h>
+
+#include "hud.h"
+#include "cl_util.h"
+#include "camera.h"
+#include "kbutton.h"
+#include "const.h"
+
+#include "vgui_int.h"
+#include "vgui_TeamFortressViewport.h"
+#include "vgui_ServerBrowser.h"
+
+#define MOTD_TITLE_X		XRES(16)
+#define MOTD_TITLE_Y		YRES(16)
+
+#define MOTD_WINDOW_X				XRES(112)
+#define MOTD_WINDOW_Y				YRES(80)
+#define MOTD_WINDOW_SIZE_X			XRES(424)
+#define MOTD_WINDOW_SIZE_Y			YRES(312)
+
+//-----------------------------------------------------------------------------
+// Purpose: Displays the MOTD and basic server information
+//-----------------------------------------------------------------------------
+class CMessageWindowPanel : public CMenuPanel
+{
+public:
+	CMessageWindowPanel( const char *szMOTD, const char *szTitle, int iShadeFullScreen, int iRemoveMe, int x, int y, int wide, int tall );
+
+private:
+	CTransparentPanel *m_pBackgroundPanel;
+
+};
+
+//-----------------------------------------------------------------------------
+// Purpose: Creates a new CMessageWindowPanel
+// Output : CMenuPanel - interface to the panel
+//-----------------------------------------------------------------------------
+CMenuPanel *CMessageWindowPanel_Create( const char *szMOTD, const char *szTitle, int iShadeFullscreen, int iRemoveMe, int x, int y, int wide, int tall )
+{
+	return new CMessageWindowPanel( szMOTD, szTitle, iShadeFullscreen, iRemoveMe, x, y, wide, tall );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Constructs a message panel
+//-----------------------------------------------------------------------------
+CMessageWindowPanel::CMessageWindowPanel( const char *szMOTD, const char *szTitle, int iShadeFullscreen, int iRemoveMe, int x, int y, int wide, int tall ) : CMenuPanel( iShadeFullscreen ? 100 : 255, iRemoveMe, x, y, wide, tall )
+{
+	// Get the scheme used for the Titles
+	CSchemeManager *pSchemes = gViewPort->GetSchemeManager();
+
+	// schemes
+	SchemeHandle_t hTitleScheme = pSchemes->getSchemeHandle( "Title Font" );
+	SchemeHandle_t hMOTDText = pSchemes->getSchemeHandle( "Briefing Text" );
+
+	// color schemes
+	int r, g, b, a;
+
+	// Create the window
+	m_pBackgroundPanel = new CTransparentPanel( iShadeFullscreen ? 255 : 100, MOTD_WINDOW_X, MOTD_WINDOW_Y, MOTD_WINDOW_SIZE_X, MOTD_WINDOW_SIZE_Y );
+	m_pBackgroundPanel->setParent( this );
+	m_pBackgroundPanel->setBorder( new LineBorder( Color(255 * 0.7,170 * 0.7,0,0)) );
+	m_pBackgroundPanel->setVisible( true );
+
+	int iXSize,iYSize,iXPos,iYPos;
+	m_pBackgroundPanel->getPos( iXPos,iYPos );
+	m_pBackgroundPanel->getSize( iXSize,iYSize );
+
+	// Create the title
+	Label *pLabel = new Label( "", iXPos + MOTD_TITLE_X, iYPos + MOTD_TITLE_Y );
+	pLabel->setParent( this );
+	pLabel->setFont( pSchemes->getFont(hTitleScheme) );
+	pLabel->setFont( Scheme::sf_primary1 );
+
+	pSchemes->getFgColor( hTitleScheme, r, g, b, a );
+	pLabel->setFgColor( r, g, b, a );
+	pLabel->setFgColor( Scheme::sc_primary1 );
+	pSchemes->getBgColor( hTitleScheme, r, g, b, a );
+	pLabel->setBgColor( r, g, b, a );
+	pLabel->setContentAlignment( vgui::Label::a_west );
+	pLabel->setText(szTitle);
+
+	// Create the Scroll panel
+	ScrollPanel *pScrollPanel = new CTFScrollPanel( iXPos + XRES(16), iYPos + MOTD_TITLE_Y*2 + YRES(16), iXSize - XRES(32), iYSize - (YRES(48) + BUTTON_SIZE_Y*2) );
+	pScrollPanel->setParent(this);
+	
+	//force the scrollbars on so clientClip will take them in account after the validate
+	pScrollPanel->setScrollBarAutoVisible(false, false);
+	pScrollPanel->setScrollBarVisible(true, true);
+	pScrollPanel->validate();
+
+	// Create the text panel
+	TextPanel *pText = new TextPanel( "", 0,0, 64,64);
+	pText->setParent( pScrollPanel->getClient() );
+
+	// get the font and colors from the scheme
+	pText->setFont( pSchemes->getFont(hMOTDText) );
+	pSchemes->getFgColor( hMOTDText, r, g, b, a );
+	pText->setFgColor( r, g, b, a );
+	pSchemes->getBgColor( hMOTDText, r, g, b, a );
+	pText->setBgColor( r, g, b, a );
+	pText->setText(szMOTD);
+
+	// Get the total size of the MOTD text and resize the text panel
+	int iScrollSizeX, iScrollSizeY;
+
+	// First, set the size so that the client's wdith is correct at least because the
+	//  width is critical for getting the "wrapped" size right.
+	// You'll see a horizontal scroll bar if there is a single word that won't wrap in the
+	//  specified width.
+	pText->getTextImage()->setSize(pScrollPanel->getClientClip()->getWide(), pScrollPanel->getClientClip()->getTall());
+	pText->getTextImage()->getTextSizeWrapped( iScrollSizeX, iScrollSizeY );
+	
+	// Now resize the textpanel to fit the scrolled size
+	pText->setSize( iScrollSizeX , iScrollSizeY );
+
+	//turn the scrollbars back into automode
+	pScrollPanel->setScrollBarAutoVisible(true, true);
+	pScrollPanel->setScrollBarVisible(false, false);
+
+	pScrollPanel->validate();
+
+	CommandButton *pButton = new CommandButton( CHudTextMessage::BufferedLocaliseTextString( "#Menu_OK" ), iXPos + XRES(16), iYPos + iYSize - YRES(16) - BUTTON_SIZE_Y, CMENU_SIZE_X, BUTTON_SIZE_Y);
+	pButton->addActionSignal(new CMenuHandler_TextWindow(HIDE_TEXTWINDOW));
+	pButton->setParent(this);
+
+}
+
+
+
+
+
+

hlsdk/ricochet/cl_dll/vgui_SchemeManager.cpp

@@ -0,0 +1,544 @@
+//=========== (C) Copyright 1999 Valve, L.L.C. All rights reserved. ===========
+//
+// The copyright to the contents herein is the property of Valve, L.L.C.
+// The contents may be used and/or copied only with the written permission of
+// Valve, L.L.C., or in accordance with the terms and conditions stipulated in
+// the agreement/contract under which the contents have been supplied.
+//
+// Purpose: 
+//
+// $Workfile:     $
+// $Date:         $
+//
+//-----------------------------------------------------------------------------
+// $Log: $
+//
+// $NoKeywords: $
+//=============================================================================
+
+#include "hud.h"
+#include "vgui_SchemeManager.h"
+#include "cvardef.h"
+
+#include <string.h>
+
+
+cvar_t *g_CV_BitmapFonts;
+
+
+void Scheme_Init()
+{
+	g_CV_BitmapFonts = gEngfuncs.pfnRegisterVariable("bitmapfonts", "1", 0);
+}
+
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Scheme managers data container
+//-----------------------------------------------------------------------------
+class CSchemeManager::CScheme
+{
+public:
+	enum { 
+		SCHEME_NAME_LENGTH = 32,
+		FONT_NAME_LENGTH = 48,
+		FONT_FILENAME_LENGTH = 64,
+	};
+	
+	// name
+	char schemeName[SCHEME_NAME_LENGTH];
+
+	// font
+	char fontName[FONT_NAME_LENGTH];
+
+	int fontSize;
+	int fontWeight;
+
+	vgui::Font *font;
+	int ownFontPointer; // true if the font is ours to delete
+
+	// scheme
+	byte fgColor[4];
+	byte bgColor[4];
+	byte armedFgColor[4];
+	byte armedBgColor[4]; 
+	byte mousedownFgColor[4];
+	byte mousedownBgColor[4];
+	byte borderColor[4];
+
+	// construction/destruction
+	CScheme();
+	~CScheme();
+};
+
+CSchemeManager::CScheme::CScheme()
+{
+	schemeName[0] = 0;
+	fontName[0] = 0;
+	fontSize = 0;
+	fontWeight = 0;
+	font = NULL;
+	ownFontPointer = false;
+}
+
+CSchemeManager::CScheme::~CScheme()
+{
+	// only delete our font pointer if we own it
+	if ( ownFontPointer )
+	{
+		delete font;
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: resolution information
+//			!! needs to be shared out
+//-----------------------------------------------------------------------------
+static int g_ResArray[] =
+{
+	320,
+	400,
+	512,
+	640,
+	800,
+	1024,
+	1152,
+	1280,
+	1600
+};
+static int g_NumReses = sizeof(g_ResArray) / sizeof(int);
+
+static byte *LoadFileByResolution( const char *filePrefix, int xRes, const char *filePostfix )
+{
+	// find our resolution in the res array
+	int resNum = g_NumReses - 1;
+	while ( g_ResArray[resNum] > xRes )
+	{
+		resNum--;
+
+		if ( resNum < 0 )
+			return NULL;
+	}
+
+	// try open the file
+	byte *pFile = NULL;
+	while ( 1 )
+	{
+
+		// try load
+		char fname[256];
+		sprintf( fname, "%s%d%s", filePrefix, g_ResArray[resNum], filePostfix );
+		pFile = gEngfuncs.COM_LoadFile( fname, 5, NULL );
+
+		if ( pFile )
+			break;
+
+		if ( resNum == 0 )
+			return NULL;
+
+		resNum--;
+	};
+
+	return pFile;
+}
+
+static void ParseRGBAFromString( byte colorArray[4], const char *colorVector )
+{
+	int r, g, b, a;
+	sscanf( colorVector, "%d %d %d %d", &r, &g, &b, &a );
+	colorArray[0] = r;
+	colorArray[1] = g;
+	colorArray[2] = b;
+	colorArray[3] = a;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: initializes the scheme manager
+//			loading the scheme files for the current resolution
+// Input  : xRes - 
+//			yRes - dimensions of output window
+//-----------------------------------------------------------------------------
+CSchemeManager::CSchemeManager( int xRes, int yRes )
+{
+	// basic setup
+	m_pSchemeList = NULL;
+	m_iNumSchemes = 0;
+
+	// find the closest matching scheme file to our resolution
+	char token[1024];
+	char *pFile = (char*)LoadFileByResolution( "", xRes, "_textscheme.txt" );
+	m_xRes = xRes;
+
+	char *pFileStart = pFile;
+	
+	byte *pFontData;
+	int fontFileLength;
+	char fontFilename[512];
+
+	//
+	// Read the scheme descriptions from the text file, into a temporary array
+	// format is simply:
+	// <paramName name> = <paramValue>
+	//
+	// a <paramName name> of "SchemeName" signals a new scheme is being described
+	//
+
+	const static int numTmpSchemes = 64;
+	static CScheme tmpSchemes[numTmpSchemes];
+	memset( tmpSchemes, 0, sizeof(tmpSchemes) );
+	int currentScheme = -1;
+	CScheme *pScheme = NULL;
+
+	if ( !pFile )
+	{
+		gEngfuncs.Con_DPrintf( "Unable to find *_textscheme.txt\n");
+		goto buildDefaultFont;
+	}
+
+	// record what has been entered so we can create defaults from the different values
+	bool hasFgColor, hasBgColor, hasArmedFgColor, hasArmedBgColor, hasMouseDownFgColor, hasMouseDownBgColor;
+
+	pFile = gEngfuncs.COM_ParseFile( pFile, token );
+	while ( strlen(token) > 0 && (currentScheme < numTmpSchemes) )
+	{
+		// get the paramName name
+		static const int tokenSize = 64;
+		char paramName[tokenSize], paramValue[tokenSize];
+
+		strncpy( paramName, token, tokenSize );
+		paramName[tokenSize-1] = 0; // ensure null termination
+
+		// get the '=' character
+		pFile = gEngfuncs.COM_ParseFile( pFile, token );
+		if ( stricmp( token, "=" ) )
+		{
+			if ( currentScheme < 0 )
+			{
+				gEngfuncs.Con_Printf( "error parsing font scheme text file at file start - expected '=', found '%s''\n", token );
+			}
+			else
+			{
+				gEngfuncs.Con_Printf( "error parsing font scheme text file at scheme '%s' - expected '=', found '%s''\n", tmpSchemes[currentScheme].schemeName, token );
+			}
+			break;
+		}
+
+		// get paramValue
+		pFile = gEngfuncs.COM_ParseFile( pFile, token );
+		strncpy( paramValue, token, tokenSize );
+		paramValue[tokenSize-1] = 0; // ensure null termination
+		
+		// is this a new scheme?
+		if ( !stricmp(paramName, "SchemeName") )
+		{
+			// setup the defaults for the current scheme
+			if ( pScheme )
+			{
+				// foreground color defaults (normal -> armed -> mouse down)
+				if ( !hasFgColor )
+				{
+					pScheme->fgColor[0] = pScheme->fgColor[1] = pScheme->fgColor[2] = pScheme->fgColor[3] = 255;
+				}
+				if ( !hasArmedFgColor )
+				{
+					memcpy( pScheme->armedFgColor, pScheme->fgColor, sizeof(pScheme->armedFgColor) );
+				}
+				if ( !hasMouseDownFgColor )
+				{
+					memcpy( pScheme->mousedownFgColor, pScheme->armedFgColor, sizeof(pScheme->mousedownFgColor) );
+				}
+
+				// background color (normal -> armed -> mouse down)
+				if ( !hasBgColor )
+				{
+					pScheme->bgColor[0] = pScheme->bgColor[1] = pScheme->bgColor[2] = pScheme->bgColor[3] = 0;
+				}
+				if ( !hasArmedBgColor )
+				{
+					memcpy( pScheme->armedBgColor, pScheme->bgColor, sizeof(pScheme->armedBgColor) );
+				}
+				if ( !hasMouseDownBgColor )
+				{
+					memcpy( pScheme->mousedownBgColor, pScheme->armedBgColor, sizeof(pScheme->mousedownBgColor) );
+				}
+
+				// font size
+				if ( !pScheme->fontSize )
+				{
+					pScheme->fontSize = 17;
+				}
+				if ( !pScheme->fontName[0] )
+				{
+					strcpy( pScheme->fontName, "Arial" );
+				}
+			}
+
+			// create the new scheme
+			currentScheme++;
+			pScheme = &tmpSchemes[currentScheme];
+			hasFgColor = hasBgColor = hasArmedFgColor = hasArmedBgColor = hasMouseDownFgColor = hasMouseDownBgColor = false;
+
+			strncpy( pScheme->schemeName, paramValue, CScheme::SCHEME_NAME_LENGTH );
+			pScheme->schemeName[CScheme::SCHEME_NAME_LENGTH-1] = '\0'; // ensure null termination of string
+		}
+
+		if ( !pScheme )
+		{
+			gEngfuncs.Con_Printf( "font scheme text file MUST start with a 'SchemeName'\n");
+			break;
+		}
+
+		// pull the data out into the scheme
+		if ( !stricmp(paramName, "FontName") )
+		{
+			strncpy( pScheme->fontName, paramValue, CScheme::FONT_NAME_LENGTH );
+			pScheme->fontName[CScheme::FONT_NAME_LENGTH-1] = 0;
+		}
+		else if ( !stricmp(paramName, "FontSize") )
+		{
+			pScheme->fontSize = atoi( paramValue );
+		}
+		else if ( !stricmp(paramName, "FontWeight") )
+		{
+			pScheme->fontWeight = atoi( paramValue );
+		}
+		else if ( !stricmp(paramName, "FgColor") )
+		{
+			ParseRGBAFromString( pScheme->fgColor, paramValue );
+			hasFgColor = true;
+		}
+		else if ( !stricmp(paramName, "BgColor") )
+		{
+			ParseRGBAFromString( pScheme->bgColor, paramValue );
+			hasBgColor = true;
+		}
+		else if ( !stricmp(paramName, "FgColorArmed") )
+		{
+			ParseRGBAFromString( pScheme->armedFgColor, paramValue );
+			hasArmedFgColor = true;
+		}	
+		else if ( !stricmp(paramName, "BgColorArmed") )
+		{
+			ParseRGBAFromString( pScheme->armedBgColor, paramValue );
+			hasArmedBgColor = true;
+		}
+		else if ( !stricmp(paramName, "FgColorMousedown") )
+		{
+			ParseRGBAFromString( pScheme->mousedownFgColor, paramValue );
+			hasMouseDownFgColor = true;
+		}
+		else if ( !stricmp(paramName, "BgColorMousedown") )
+		{
+			ParseRGBAFromString( pScheme->mousedownBgColor, paramValue );
+			hasMouseDownBgColor = true;
+		}
+		else if ( !stricmp(paramName, "BorderColor") )
+		{
+			ParseRGBAFromString( pScheme->borderColor, paramValue );
+			hasMouseDownBgColor = true;
+		}
+
+		// get the new token last, so we now if the loop needs to be continued or not
+		pFile = gEngfuncs.COM_ParseFile( pFile, token );
+	}
+
+	// free the file
+	gEngfuncs.COM_FreeFile( pFileStart );
+
+
+buildDefaultFont:
+
+	// make sure we have at least 1 valid font
+	if ( currentScheme < 0 )
+	{
+		currentScheme = 0;
+		strcpy( tmpSchemes[0].schemeName, "Default Scheme" );
+		strcpy( tmpSchemes[0].fontName, "Arial" );
+		tmpSchemes[0].fontSize = 0;
+		tmpSchemes[0].fgColor[0] = tmpSchemes[0].fgColor[1] = tmpSchemes[0].fgColor[2] = tmpSchemes[0].fgColor[3] = 255;
+		tmpSchemes[0].armedFgColor[0] = tmpSchemes[0].armedFgColor[1] = tmpSchemes[0].armedFgColor[2] = tmpSchemes[0].armedFgColor[3] = 255;
+		tmpSchemes[0].mousedownFgColor[0] = tmpSchemes[0].mousedownFgColor[1] = tmpSchemes[0].mousedownFgColor[2] = tmpSchemes[0].mousedownFgColor[3] = 255;
+	}
+
+	// we have the full list of schemes in the tmpSchemes array
+	// now allocate the correct sized list
+	m_iNumSchemes = currentScheme + 1; // 0-based index
+	m_pSchemeList = new CScheme[ m_iNumSchemes ];
+
+	// copy in the data
+	memcpy( m_pSchemeList, tmpSchemes, sizeof(CScheme) * m_iNumSchemes );
+
+	// create the fonts
+	for ( int i = 0; i < m_iNumSchemes; i++ )
+	{
+		m_pSchemeList[i].font = NULL;
+
+		// see if the current font values exist in a previously loaded font
+		for ( int j = 0; j < i; j++ )
+		{
+			// check if the font name, size, and weight are the same
+			if ( !stricmp(m_pSchemeList[i].fontName, m_pSchemeList[j].fontName)  
+				&& m_pSchemeList[i].fontSize == m_pSchemeList[j].fontSize
+				&& m_pSchemeList[i].fontWeight == m_pSchemeList[j].fontWeight )
+			{
+				// copy the pointer, but mark i as not owning it
+				m_pSchemeList[i].font = m_pSchemeList[j].font;
+				m_pSchemeList[i].ownFontPointer = false;
+			}
+		}
+
+		// if we haven't found the font already, load it ourselves
+		if ( !m_pSchemeList[i].font )
+		{
+			fontFileLength = -1;
+			pFontData = NULL;
+
+			if(g_CV_BitmapFonts && g_CV_BitmapFonts->value)
+			{
+				sprintf(fontFilename, "gfx\\vgui\\fonts\\%d_%s.tga", m_xRes, m_pSchemeList[i].schemeName);
+				pFontData = gEngfuncs.COM_LoadFile( fontFilename, 5, &fontFileLength );
+				if(!pFontData)
+					gEngfuncs.Con_Printf("Missing bitmap font: %s\n", fontFilename);
+			}
+
+			m_pSchemeList[i].font = new vgui::Font(
+				m_pSchemeList[i].fontName, 
+				pFontData,
+				fontFileLength,
+				m_pSchemeList[i].fontSize, 
+				0, 
+				0, 
+				m_pSchemeList[i].fontWeight, 
+				false, 
+				false, 
+				false, 
+				false);
+			
+			m_pSchemeList[i].ownFontPointer = true;
+		}
+
+		// fix up alpha values; VGUI uses 1-A (A=0 being solid, A=255 transparent)
+		m_pSchemeList[i].fgColor[3] = 255 - m_pSchemeList[i].fgColor[3];
+		m_pSchemeList[i].bgColor[3] = 255 - m_pSchemeList[i].bgColor[3];
+		m_pSchemeList[i].armedFgColor[3] = 255 - m_pSchemeList[i].armedFgColor[3];
+		m_pSchemeList[i].armedBgColor[3] = 255 - m_pSchemeList[i].armedBgColor[3];
+		m_pSchemeList[i].mousedownFgColor[3] = 255 - m_pSchemeList[i].mousedownFgColor[3];
+		m_pSchemeList[i].mousedownBgColor[3] = 255 - m_pSchemeList[i].mousedownBgColor[3];
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: frees all the memory used by the scheme manager
+//-----------------------------------------------------------------------------
+CSchemeManager::~CSchemeManager()
+{
+	delete [] m_pSchemeList;
+	m_iNumSchemes = 0;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Finds a scheme in the list, by name
+// Input  : char *schemeName - string name of the scheme
+// Output : SchemeHandle_t handle to the scheme
+//-----------------------------------------------------------------------------
+SchemeHandle_t CSchemeManager::getSchemeHandle( const char *schemeName )
+{
+	// iterate through the list
+	for ( int i = 0; i < m_iNumSchemes; i++ )
+	{
+		if ( !stricmp(schemeName, m_pSchemeList[i].schemeName) )
+			return i;
+	}
+
+	return 0;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: always returns a valid scheme handle
+// Input  : schemeHandle - 
+// Output : CScheme
+//-----------------------------------------------------------------------------
+CSchemeManager::CScheme *CSchemeManager::getSafeScheme( SchemeHandle_t schemeHandle )
+{
+	if ( schemeHandle < m_iNumSchemes )
+		return m_pSchemeList + schemeHandle;
+
+	return m_pSchemeList;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Returns the schemes pointer to a font
+// Input  : schemeHandle - 
+// Output : vgui::Font
+//-----------------------------------------------------------------------------
+vgui::Font *CSchemeManager::getFont( SchemeHandle_t schemeHandle )
+{
+	return getSafeScheme( schemeHandle )->font;
+}
+
+void CSchemeManager::getFgColor( SchemeHandle_t schemeHandle, int &r, int &g, int &b, int &a )
+{
+	CScheme *pScheme = getSafeScheme( schemeHandle );
+	r = pScheme->fgColor[0];
+	g = pScheme->fgColor[1];
+	b = pScheme->fgColor[2];
+	a = pScheme->fgColor[3];
+}
+
+void CSchemeManager::getBgColor( SchemeHandle_t schemeHandle, int &r, int &g, int &b, int &a )
+{
+	CScheme *pScheme = getSafeScheme( schemeHandle );
+	r = pScheme->bgColor[0];
+	g = pScheme->bgColor[1];
+	b = pScheme->bgColor[2];
+	a = pScheme->bgColor[3];
+}
+
+void CSchemeManager::getFgArmedColor( SchemeHandle_t schemeHandle, int &r, int &g, int &b, int &a )
+{
+	CScheme *pScheme = getSafeScheme( schemeHandle );
+	r = pScheme->armedFgColor[0];
+	g = pScheme->armedFgColor[1];
+	b = pScheme->armedFgColor[2];
+	a = pScheme->armedFgColor[3];
+}
+
+void CSchemeManager::getBgArmedColor( SchemeHandle_t schemeHandle, int &r, int &g, int &b, int &a )
+{
+	CScheme *pScheme = getSafeScheme( schemeHandle );
+	r = pScheme->armedBgColor[0];
+	g = pScheme->armedBgColor[1];
+	b = pScheme->armedBgColor[2];
+	a = pScheme->armedBgColor[3];
+}
+
+void CSchemeManager::getFgMousedownColor( SchemeHandle_t schemeHandle, int &r, int &g, int &b, int &a )
+{
+	CScheme *pScheme = getSafeScheme( schemeHandle );
+	r = pScheme->mousedownFgColor[0];
+	g = pScheme->mousedownFgColor[1];
+	b = pScheme->mousedownFgColor[2];
+	a = pScheme->mousedownFgColor[3];
+}
+
+void CSchemeManager::getBgMousedownColor( SchemeHandle_t schemeHandle, int &r, int &g, int &b, int &a )
+{
+	CScheme *pScheme = getSafeScheme( schemeHandle );
+	r = pScheme->mousedownBgColor[0];
+	g = pScheme->mousedownBgColor[1];
+	b = pScheme->mousedownBgColor[2];
+	a = pScheme->mousedownBgColor[3];
+}
+
+void CSchemeManager::getBorderColor( SchemeHandle_t schemeHandle, int &r, int &g, int &b, int &a )
+{
+	CScheme *pScheme = getSafeScheme( schemeHandle );
+	r = pScheme->borderColor[0];
+	g = pScheme->borderColor[1];
+	b = pScheme->borderColor[2];
+	a = pScheme->borderColor[3];
+}
+
+
+

hlsdk/ricochet/cl_dll/vgui_SchemeManager.h

@@ -0,0 +1,47 @@
+#include <VGUI_Font.h>
+
+
+// handle to an individual scheme
+typedef int SchemeHandle_t;
+
+
+// Register console variables, etc..
+void Scheme_Init();
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Handles the loading of text scheme description from disk
+//			supports different font/color/size schemes at different resolutions 
+//-----------------------------------------------------------------------------
+class CSchemeManager
+{
+public:
+	// initialization
+	CSchemeManager( int xRes, int yRes );
+	virtual ~CSchemeManager();
+
+	// scheme handling
+	SchemeHandle_t getSchemeHandle( const char *schemeName );
+
+	// getting info from schemes
+	vgui::Font *getFont( SchemeHandle_t schemeHandle );
+	void getFgColor( SchemeHandle_t schemeHandle, int &r, int &g, int &b, int &a );
+	void getBgColor( SchemeHandle_t schemeHandle, int &r, int &g, int &b, int &a );
+	void getFgArmedColor( SchemeHandle_t schemeHandle, int &r, int &g, int &b, int &a );
+	void getBgArmedColor( SchemeHandle_t schemeHandle, int &r, int &g, int &b, int &a );
+	void getFgMousedownColor( SchemeHandle_t schemeHandle, int &r, int &g, int &b, int &a );
+	void getBgMousedownColor( SchemeHandle_t schemeHandle, int &r, int &g, int &b, int &a );
+	void getBorderColor( SchemeHandle_t schemeHandle, int &r, int &g, int &b, int &a );
+
+private:
+	class CScheme;
+	CScheme *m_pSchemeList;
+	int m_iNumSchemes;
+
+	// Resolution we were initted at.
+	int		m_xRes;
+
+	CScheme *getSafeScheme( SchemeHandle_t schemeHandle );
+};
+
+

hlsdk/ricochet/cl_dll/vgui_ScorePanel.h

@@ -0,0 +1,304 @@
+
+#ifndef SCOREPANEL_H
+#define SCOREPANEL_H
+
+#include<VGUI_Panel.h>
+#include<VGUI_TablePanel.h>
+#include<VGUI_HeaderPanel.h>
+#include<VGUI_TextGrid.h>
+#include<VGUI_Label.h>
+#include<VGUI_TextImage.h>
+#include "vgui_listbox.h"
+
+#include <ctype.h>
+
+#define MAX_SCORES					10
+#define MAX_SCOREBOARD_TEAMS		5
+
+// Scoreboard cells
+#define COLUMN_TRACKER	0
+#define COLUMN_NAME		1
+#define COLUMN_CLASS	2
+#define COLUMN_KILLS	3
+#define COLUMN_DEATHS	4
+#define COLUMN_LATENCY	5
+#define COLUMN_VOICE	6
+#define COLUMN_BLANK	7
+#define NUM_COLUMNS		8
+#define NUM_ROWS		(MAX_PLAYERS + (MAX_SCOREBOARD_TEAMS * 2))
+
+using namespace vgui;
+
+class CTextImage2 : public Image
+{
+public:
+	CTextImage2()
+	{
+		_image[0] = new TextImage("");
+		_image[1] = new TextImage("");
+	}
+
+	~CTextImage2()
+	{
+		delete _image[0];
+		delete _image[1];
+	}
+
+	TextImage *GetImage(int image)
+	{
+		return _image[image];
+	}
+
+	void getSize(int &wide, int &tall)
+	{
+		int w1, w2, t1, t2;
+		_image[0]->getTextSize(w1, t1);
+		_image[1]->getTextSize(w2, t2);
+
+		wide = w1 + w2;
+		tall = max(t1, t2);
+		setSize(wide, tall);
+	}
+
+	void doPaint(Panel *panel)
+	{
+		_image[0]->doPaint(panel);
+		_image[1]->doPaint(panel);
+	}
+
+	void setPos(int x, int y)
+	{
+		_image[0]->setPos(x, y);
+		
+		int swide, stall;
+		_image[0]->getSize(swide, stall);
+
+		int wide, tall;
+		_image[1]->getSize(wide, tall);
+		_image[1]->setPos(x + wide, y + (stall * 0.9) - tall);
+	}
+
+	void setColor(Color color)
+	{
+		_image[0]->setColor(color);
+	}
+
+	void setColor2(Color color)
+	{
+		_image[1]->setColor(color);
+	}
+
+private:
+	TextImage *_image[2];
+
+};
+
+//-----------------------------------------------------------------------------
+// Purpose: Custom label for cells in the Scoreboard's Table Header
+//-----------------------------------------------------------------------------
+class CLabelHeader : public Label
+{
+public:
+	CLabelHeader() : Label("")
+	{
+		_dualImage = new CTextImage2();
+		_dualImage->setColor2(Color(255, 170, 0, 0));
+		_row = -2;
+		_useFgColorAsImageColor = true;
+		_offset[0] = 0;
+		_offset[1] = 0;
+	}
+
+	~CLabelHeader()
+	{
+		delete _dualImage;
+	}
+
+	void setRow(int row)
+	{
+		_row = row;
+	}
+
+	void setFgColorAsImageColor(bool state)
+	{
+		_useFgColorAsImageColor = state;
+	}
+
+	virtual void setText(int textBufferLen, const char* text)
+	{
+		_dualImage->GetImage(0)->setText(text);
+
+		// calculate the text size
+		Font *font = _dualImage->GetImage(0)->getFont();
+		_gap = 0;
+		for (const char *ch = text; *ch != 0; ch++)
+		{
+			int a, b, c;
+			font->getCharABCwide(*ch, a, b, c);
+			_gap += (a + b + c);
+		}
+
+		_gap += XRES(5);
+	}
+
+	virtual void setText(const char* text)
+	{
+		// strip any non-alnum characters from the end
+		char buf[512];
+		strcpy(buf, text);
+
+		int len = strlen(buf);
+		while (len && isspace(buf[--len]))
+		{
+			buf[len] = 0;
+		}
+
+		CLabelHeader::setText(0, buf);
+	}
+
+	void setText2(const char *text)
+	{
+		_dualImage->GetImage(1)->setText(text);
+	}
+
+	void getTextSize(int &wide, int &tall)
+	{
+		_dualImage->getSize(wide, tall);
+	}
+
+	void setFgColor(int r,int g,int b,int a)
+	{
+		Label::setFgColor(r,g,b,a);
+		Color color(r,g,b,a);
+		_dualImage->setColor(color);
+		_dualImage->setColor2(color);
+		repaint();
+	}
+
+	void setFgColor(Scheme::SchemeColor sc)
+	{
+		int r, g, b, a;
+		Label::setFgColor(sc);
+		Label::getFgColor( r, g, b, a );
+
+		// Call the r,g,b,a version so it sets the color in the dualImage..
+		setFgColor( r, g, b, a );
+	}
+
+	void setFont(Font *font)
+	{
+		_dualImage->GetImage(0)->setFont(font);
+	}
+
+	void setFont2(Font *font)
+	{
+		_dualImage->GetImage(1)->setFont(font);
+	}
+
+	// this adjust the absolute position of the text after alignment is calculated
+	void setTextOffset(int x, int y)
+	{
+		_offset[0] = x;
+		_offset[1] = y;
+	}
+
+	void paint();
+	void paintBackground();
+	void calcAlignment(int iwide, int itall, int &x, int &y);
+
+private:
+	CTextImage2 *_dualImage;
+	int _row;
+	int _gap;
+	int _offset[2];
+	bool _useFgColorAsImageColor;
+};
+
+class ScoreTablePanel;
+
+#include "vgui_grid.h"
+#include "vgui_defaultinputsignal.h"
+
+//-----------------------------------------------------------------------------
+// Purpose: Scoreboard back panel
+//-----------------------------------------------------------------------------
+class ScorePanel : public Panel, public vgui::CDefaultInputSignal
+{
+private:
+	// Default panel implementation doesn't forward mouse messages when there is no cursor and we need them.
+	class HitTestPanel : public Panel
+	{
+	public:
+		virtual void	internalMousePressed(MouseCode code);
+	};
+
+
+private:
+
+	Label			m_TitleLabel;
+	
+	// Here is how these controls are arranged hierarchically.
+	// m_HeaderGrid
+	//     m_HeaderLabels
+
+	// m_PlayerGridScroll
+	//     m_PlayerGrid
+	//         m_PlayerEntries 
+
+	CGrid			m_HeaderGrid;
+	CLabelHeader	m_HeaderLabels[NUM_COLUMNS];			// Labels above the 
+	CLabelHeader	*m_pCurrentHighlightLabel;
+	int				m_iHighlightRow;
+	
+	vgui::CListBox	m_PlayerList;
+	CGrid			m_PlayerGrids[NUM_ROWS];				// The grid with player and team info. 
+	CLabelHeader	m_PlayerEntries[NUM_COLUMNS][NUM_ROWS];	// Labels for the grid entries.
+
+	ScorePanel::HitTestPanel	m_HitTestPanel;
+//	CommandButton				*m_pCloseButton;
+	CLabelHeader*	GetPlayerEntry(int x, int y)	{return &m_PlayerEntries[x][y];}
+
+public:
+	
+	int				m_iNumTeams;
+	int				m_iPlayerNum;
+	int				m_iShowscoresHeld;
+
+	int				m_iRows;
+	int				m_iSortedRows[NUM_ROWS];
+	int				m_iIsATeam[NUM_ROWS];
+	bool			m_bHasBeenSorted[MAX_PLAYERS];
+	int				m_iLastKilledBy;
+	int				m_fLastKillTime;
+
+
+public:
+
+	ScorePanel(int x,int y,int wide,int tall);
+
+	void Update( void );
+
+	void SortTeams( void );
+	void SortPlayers( int iTeam, char *team );
+	void RebuildTeams( void );
+
+	void FillGrid();
+
+	void DeathMsg( int killer, int victim );
+
+	void Initialize( void );
+
+	void Open( void );
+
+	void MouseOverCell(int row, int col);
+
+// InputSignal overrides.
+public:
+
+	virtual void mousePressed(MouseCode code, Panel* panel);
+	virtual void cursorMoved(int x, int y, Panel *panel);
+
+	friend CLabelHeader;
+};
+
+#endif

hlsdk/ricochet/cl_dll/vgui_ServerBrowser.cpp

@@ -0,0 +1,616 @@
+
+#include<VGUI_HeaderPanel.h>
+#include<VGUI_TablePanel.h>
+#include<VGUI_LineBorder.h>
+#include<VGUI_Label.h>
+#include<VGUI_Button.h>
+#include<VGUI_ActionSignal.h>
+
+#include "hud.h"
+#include "cl_util.h"
+#include "hud_servers.h"
+#include "net_api.h"
+
+#include "vgui_TeamFortressViewport.h"
+#include "vgui_ServerBrowser.h"
+
+using namespace vgui;
+
+namespace
+{
+
+#define MAX_SB_ROWS 24
+
+#define NUM_COLUMNS 5
+
+#define HEADER_SIZE_Y			YRES(18)
+
+// Column sizes
+#define CSIZE_ADDRESS			XRES(200)
+#define CSIZE_SERVER			XRES(400) 
+#define CSIZE_MAP				XRES(500)
+#define CSIZE_CURRENT			XRES(570)
+#define CSIZE_PING				XRES(640)
+
+#define CELL_HEIGHT				YRES(15)
+
+class ServerBrowserTablePanel;
+
+class CBrowser_InputSignal : public InputSignal
+{
+private:
+	ServerBrowserTablePanel *m_pBrowser;
+public:
+	CBrowser_InputSignal( ServerBrowserTablePanel *pBrowser )
+	{
+		m_pBrowser = pBrowser;
+	}
+
+	virtual void cursorMoved(int x,int y,Panel* panel) {};
+	virtual void cursorEntered(Panel* panel){};
+	virtual void cursorExited(Panel* Panel) {};
+
+	virtual void mousePressed(MouseCode code,Panel* panel);
+
+	virtual void mouseDoublePressed(MouseCode code,Panel* panel);
+	virtual void mouseReleased(MouseCode code,Panel* panel) {};
+	virtual void mouseWheeled(int delta,Panel* panel) {};
+	virtual void keyPressed(KeyCode code,Panel* panel) {};
+	virtual void keyTyped(KeyCode code,Panel* panel) {};
+	virtual void keyReleased(KeyCode code,Panel* panel) {};
+	virtual void keyFocusTicked(Panel* panel) {};
+};
+
+class ServerBrowserTablePanel : public TablePanel
+{
+private:
+	Label				*m_pLabel;
+	int					m_nMouseOverRow;
+
+public:
+	
+	ServerBrowserTablePanel( int x,int y,int wide,int tall,int columnCount) : TablePanel( x,y,wide,tall,columnCount)
+	{
+		m_pLabel = new Label( "", 0, 0 /*,wide, tall*/ );
+		
+		m_nMouseOverRow = 0;
+	}
+
+public:
+	void setMouseOverRow( int row )
+	{
+		m_nMouseOverRow	= row;
+	}
+
+	void DoSort( char *sortkey )
+	{
+		// Request server list and refresh servers...
+		SortServers( sortkey );
+	}
+
+	void DoRefresh( void )
+	{
+		// Request server list and refresh servers...
+		ServersList();
+		BroadcastServersList( 0 );
+	}
+	
+	void DoBroadcastRefresh( void )
+	{
+		// Request server list and refresh servers...
+		BroadcastServersList( 1 );
+	}
+
+	void DoStop( void )
+	{
+		// Stop requesting
+		ServersCancel();
+	}
+
+	void DoCancel( void )
+	{
+		ClientCmd( "togglebrowser\n" );
+	}
+
+	void DoConnect( void )
+	{
+		const char *info;
+		const char *address;
+		char sz[ 256 ];
+
+		info = ServersGetInfo( m_nMouseOverRow );
+		if ( !info )
+			return;
+
+		address = gEngfuncs.pNetAPI->ValueForKey( info, "address" );
+		//gEngfuncs.Con_Printf( "Connecting to %s\n", address );
+
+		sprintf( sz, "connect %s\n", address );
+
+		ClientCmd( sz );
+
+		DoCancel();
+	}
+
+	void DoPing( void )
+	{
+		ServerPing( 0 );
+		ServerRules( 0 );
+		ServerPlayers( 0 );
+	}
+
+	virtual int getRowCount()
+	{
+		int rowcount;
+		int height, width;
+
+		getSize( width, height );
+
+		// Space for buttons
+		height -= YRES(20);
+		height = max( 0, height );
+
+		rowcount = height / CELL_HEIGHT;
+
+		return rowcount;
+	}
+
+	virtual int getCellTall(int row)
+	{
+		return CELL_HEIGHT - 2;
+	}
+	
+	virtual Panel* getCellRenderer(int column,int row,bool columnSelected,bool rowSelected,bool cellSelected)
+	{
+		const char *info;
+		const char *val, *val2;
+		char sz[ 32 ];
+
+		info = ServersGetInfo( row );
+
+		if ( row == m_nMouseOverRow )
+		{
+			m_pLabel->setFgColor( 200, 240, 63, 100 );
+		}
+		else
+		{
+			m_pLabel->setFgColor( 255, 255, 255, 0 );
+		}
+		m_pLabel->setBgColor( 0, 0, 0, 200 );
+		m_pLabel->setContentAlignment( vgui::Label::a_west );
+		m_pLabel->setFont( Scheme::sf_primary2 );
+
+		if ( info )
+		{
+			// Fill out with the correct data
+			switch ( column )
+			{
+			case 0:
+				val = gEngfuncs.pNetAPI->ValueForKey( info, "address" );
+				if ( val )
+				{
+					strncpy( sz, val, 31 );
+					sz[ 31 ] = '\0';
+					// Server Name;
+					m_pLabel->setText( sz );
+				}
+				break;
+			case 1:
+				val = gEngfuncs.pNetAPI->ValueForKey( info, "hostname" );
+				if ( val )
+				{
+					strncpy( sz, val, 31 );
+					sz[ 31 ] = '\0';
+					// Server Map;
+					m_pLabel->setText( sz );
+				}
+				break;
+			case 2:
+				val = gEngfuncs.pNetAPI->ValueForKey( info, "map" );
+				if ( val )
+				{
+					strncpy( sz, val, 31 );
+					sz[ 31 ] = '\0';
+					// Server Name;
+					m_pLabel->setText( sz );
+				}
+				break;
+			case 3:
+				val = gEngfuncs.pNetAPI->ValueForKey( info, "current" );
+				val2 = gEngfuncs.pNetAPI->ValueForKey( info, "max" );
+				if ( val && val2 )
+				{
+					sprintf( sz, "%s/%s", val, val2 );
+					sz[ 31 ] = '\0';
+					// Server Map;
+					m_pLabel->setText( sz );
+				}
+				break;
+			case 4:
+				val = gEngfuncs.pNetAPI->ValueForKey( info, "ping" );
+				if ( val )
+				{
+					strncpy( sz, val, 31 );
+					sz[ 31 ] = '\0';
+					// Server Name;
+					m_pLabel->setText( sz );
+				}
+				break;
+			default:
+				break;
+			}
+		}
+		else
+		{
+			if ( !row && !column )
+			{
+				if ( ServersIsQuerying() )
+				{
+					m_pLabel->setText( "Waiting for servers to respond..." );
+				}
+				else
+				{
+					m_pLabel->setText( "Press 'Refresh' to search for servers..." );
+				}
+			}
+			else
+			{
+				m_pLabel->setText( "" );
+			}
+		}
+		
+		return m_pLabel;
+	}
+
+	virtual Panel* startCellEditing(int column,int row)
+	{
+		return null;
+	}
+
+};
+
+class ConnectHandler : public ActionSignal
+{
+private:
+	ServerBrowserTablePanel *m_pBrowser;
+
+public:
+	ConnectHandler( ServerBrowserTablePanel *browser )
+	{
+		m_pBrowser = browser;	
+	}
+
+	virtual void actionPerformed( Panel *panel )
+	{
+		m_pBrowser->DoConnect();
+	}
+};
+
+class RefreshHandler : public ActionSignal
+{
+private:
+	ServerBrowserTablePanel *m_pBrowser;
+
+public:
+	RefreshHandler( ServerBrowserTablePanel *browser )
+	{
+		m_pBrowser = browser;	
+	}
+
+	virtual void actionPerformed( Panel *panel )
+	{
+		m_pBrowser->DoRefresh();
+	}
+};
+
+class BroadcastRefreshHandler : public ActionSignal
+{
+private:
+	ServerBrowserTablePanel *m_pBrowser;
+
+public:
+	BroadcastRefreshHandler( ServerBrowserTablePanel *browser )
+	{
+		m_pBrowser = browser;	
+	}
+
+	virtual void actionPerformed( Panel *panel )
+	{
+		m_pBrowser->DoBroadcastRefresh();
+	}
+};
+
+class StopHandler : public ActionSignal
+{
+private:
+	ServerBrowserTablePanel *m_pBrowser;
+
+public:
+	StopHandler( ServerBrowserTablePanel *browser )
+	{
+		m_pBrowser = browser;	
+	}
+
+	virtual void actionPerformed( Panel *panel )
+	{
+		m_pBrowser->DoStop();
+	}
+};
+
+class CancelHandler : public ActionSignal
+{
+private:
+	ServerBrowserTablePanel *m_pBrowser;
+
+public:
+	CancelHandler( ServerBrowserTablePanel *browser )
+	{
+		m_pBrowser = browser;	
+	}
+
+	virtual void actionPerformed( Panel *panel )
+	{
+		m_pBrowser->DoCancel();
+	}
+};
+
+class PingHandler : public ActionSignal
+{
+private:
+	ServerBrowserTablePanel *m_pBrowser;
+
+public:
+	PingHandler( ServerBrowserTablePanel *browser )
+	{
+		m_pBrowser = browser;	
+	}
+
+	virtual void actionPerformed( Panel *panel )
+	{
+		m_pBrowser->DoPing();
+	}
+};
+
+class SortHandler : public ActionSignal
+{
+private:
+	ServerBrowserTablePanel *m_pBrowser;
+
+public:
+	SortHandler( ServerBrowserTablePanel *browser )
+	{
+		m_pBrowser = browser;	
+	}
+
+	virtual void actionPerformed( Panel *panel )
+	{
+		m_pBrowser->DoSort( "map" );
+	}
+};
+
+}
+
+class LabelSortInputHandler : public InputSignal
+{
+private:
+	ServerBrowserTablePanel *m_pBrowser;
+	char m_szSortKey[ 64 ];
+
+public:
+	LabelSortInputHandler( ServerBrowserTablePanel *pBrowser, char *name )
+	{
+		m_pBrowser = pBrowser;
+		strcpy( m_szSortKey, name );
+	}
+
+	virtual void cursorMoved(int x,int y,Panel* panel) {};
+	virtual void cursorEntered(Panel* panel){};
+	virtual void cursorExited(Panel* Panel) {};
+
+	virtual void mousePressed(MouseCode code,Panel* panel)
+	{
+		m_pBrowser->DoSort( m_szSortKey );
+	}
+
+	virtual void mouseDoublePressed(MouseCode code,Panel* panel)
+	{
+		m_pBrowser->DoSort( m_szSortKey );
+	}
+
+	virtual void mouseReleased(MouseCode code,Panel* panel) {};
+	virtual void mouseWheeled(int delta,Panel* panel) {};
+	virtual void keyPressed(KeyCode code,Panel* panel) {};
+	virtual void keyTyped(KeyCode code,Panel* panel) {};
+	virtual void keyReleased(KeyCode code,Panel* panel) {};
+	virtual void keyFocusTicked(Panel* panel) {};
+};
+
+class CSBLabel : public Label
+{
+
+private:
+	char m_szSortKey[ 64 ];
+	ServerBrowserTablePanel *m_pBrowser;
+
+public:
+	CSBLabel( char *name, char *sortkey ) : Label( name )
+	{
+		m_pBrowser = NULL;
+
+		strcpy( m_szSortKey, sortkey );
+
+		int label_bg_r = 120,
+			label_bg_g = 75,
+			label_bg_b = 32,
+			label_bg_a = 200;
+
+		int label_fg_r = 255,
+			label_fg_g = 0,
+			label_fg_b = 0,
+			label_fg_a = 0;
+
+		setContentAlignment( vgui::Label::a_west );
+		setFgColor( label_fg_r, label_fg_g, label_fg_b, label_fg_a );
+		setBgColor( label_bg_r, label_bg_g, label_bg_b, label_bg_a );
+		setFont( Scheme::sf_primary2 );
+
+	}
+
+	void setTable( ServerBrowserTablePanel *browser )
+	{
+		m_pBrowser = browser;
+
+		addInputSignal( new LabelSortInputHandler( (ServerBrowserTablePanel * )m_pBrowser, m_szSortKey ) );
+	}
+};
+
+ServerBrowser::ServerBrowser(int x,int y,int wide,int tall) : CTransparentPanel( 100, x,y,wide,tall )
+{
+	int i;
+
+	_headerPanel = new HeaderPanel(0,0,wide,HEADER_SIZE_Y);
+	_headerPanel->setParent(this);
+	_headerPanel->setFgColor( 100,100,100, 100 );
+	_headerPanel->setBgColor( 0, 0, 0, 100 );
+
+	CSBLabel *pLabel[5];
+	
+	pLabel[0] = new CSBLabel( "Address", "address" );
+	pLabel[1] = new CSBLabel( "Server", "hostname" );
+	pLabel[2] = new CSBLabel( "Map", "map" );
+	pLabel[3] = new CSBLabel( "Current", "current" );
+	pLabel[4] = new CSBLabel( "Latency", "ping" );
+
+	for ( i = 0; i < 5; i++ )
+	{
+		_headerPanel->addSectionPanel( pLabel[i] );
+	}
+
+	// _headerPanel->setFont( Scheme::sf_primary1 );
+
+	_headerPanel->setSliderPos( 0, CSIZE_ADDRESS );
+	_headerPanel->setSliderPos( 1, CSIZE_SERVER );
+	_headerPanel->setSliderPos( 2, CSIZE_MAP );
+	_headerPanel->setSliderPos( 3, CSIZE_CURRENT );
+	_headerPanel->setSliderPos( 4, CSIZE_PING );
+
+	_tablePanel = new ServerBrowserTablePanel( 0, HEADER_SIZE_Y, wide, tall - HEADER_SIZE_Y, NUM_COLUMNS );
+	_tablePanel->setParent(this);
+	_tablePanel->setHeaderPanel(_headerPanel);
+	_tablePanel->setFgColor( 100,100,100, 100 );
+	_tablePanel->setBgColor( 0, 0, 0, 100 );
+
+	_tablePanel->addInputSignal( new CBrowser_InputSignal( (ServerBrowserTablePanel *)_tablePanel ) );
+
+	for ( i = 0; i < 5; i++ )
+	{
+		pLabel[i]->setTable( (ServerBrowserTablePanel * )_tablePanel );
+	}
+
+	int bw = 80, bh = 15;
+	int by = tall - HEADER_SIZE_Y;
+
+	int btnx = 10;
+
+	_connectButton = new CommandButton( "Connect", btnx, by, bw, bh );
+	_connectButton->setParent( this );
+	_connectButton->addActionSignal( new ConnectHandler(  (ServerBrowserTablePanel * )_tablePanel ) );
+
+	btnx += bw;
+
+	_refreshButton = new CommandButton( "Refresh", btnx, by, bw, bh );
+	_refreshButton->setParent( this );
+	_refreshButton->addActionSignal( new RefreshHandler(  (ServerBrowserTablePanel * )_tablePanel ) );
+
+	/*
+	btnx += bw;
+
+	_broadcastRefreshButton = new CommandButton( "LAN", btnx, by, bw, bh );
+	_broadcastRefreshButton->setParent( this );
+	_broadcastRefreshButton->addActionSignal( new BroadcastRefreshHandler(  (ServerBrowserTablePanel * )_tablePanel ) );
+	*/
+
+	btnx += bw;
+
+	_stopButton = new CommandButton( "Stop", btnx, by, bw, bh );
+	_stopButton->setParent( this );
+	_stopButton->addActionSignal( new StopHandler(  (ServerBrowserTablePanel * )_tablePanel ) );
+
+	/*
+	btnx += bw;
+
+	_pingButton = new CommandButton( "Test", btnx, by, bw, bh );
+	_pingButton->setParent( this );
+	_pingButton->addActionSignal( new PingHandler(  (ServerBrowserTablePanel * )_tablePanel ) );
+	
+	btnx += bw;
+
+	_sortButton = new CommandButton( "Sort", btnx, by, bw, bh );
+	_sortButton->setParent( this );
+	_sortButton->addActionSignal( new SortHandler(  (ServerBrowserTablePanel * )_tablePanel ) );
+	*/
+
+	btnx += bw;
+
+	_cancelButton = new CommandButton( "Close", btnx, by, bw, bh );
+	_cancelButton->setParent( this );
+	_cancelButton->addActionSignal( new CancelHandler(  (ServerBrowserTablePanel * )_tablePanel ) );
+
+	setPaintBorderEnabled(false);
+	setPaintBackgroundEnabled(false);
+	setPaintEnabled(false);
+}
+
+void ServerBrowser::setSize(int wide,int tall)
+{
+	Panel::setSize(wide,tall);
+
+	_headerPanel->setBounds(0,0,wide,HEADER_SIZE_Y);
+	_tablePanel->setBounds(0,HEADER_SIZE_Y,wide,tall - HEADER_SIZE_Y);
+	
+	_connectButton->setBounds( 5, tall - HEADER_SIZE_Y, 75, 15 );
+	_refreshButton->setBounds( 85, tall - HEADER_SIZE_Y, 75, 15 );
+	/*
+	_broadcastRefreshButton->setBounds( 165, tall - HEADER_SIZE_Y, 75, 15 );
+	*/
+	_stopButton->setBounds( 165, tall - HEADER_SIZE_Y, 75, 15 );
+	/*
+	_pingButton->setBounds( 325, tall - HEADER_SIZE_Y, 75, 15 );
+	*/
+	_cancelButton->setBounds( 245, tall - HEADER_SIZE_Y, 75, 15 );
+}
+
+void CBrowser_InputSignal::mousePressed(MouseCode code,Panel* panel)
+{
+	int x, y;
+	int therow = 2;
+
+	if ( code != MOUSE_LEFT )
+		return;
+
+	panel->getApp()->getCursorPos(x,y);
+	panel->screenToLocal( x, y );
+
+	therow = y / CELL_HEIGHT;
+	
+	// Figure out which row it's on
+	m_pBrowser->setMouseOverRow( therow );
+}
+
+void CBrowser_InputSignal::mouseDoublePressed(MouseCode code,Panel* panel)
+{
+	int x, y;
+	int therow = 2;
+
+	if ( code != MOUSE_LEFT )
+		return;
+
+	panel->getApp()->getCursorPos(x,y);
+	panel->screenToLocal( x, y );
+
+	therow = y / CELL_HEIGHT;
+	
+	// Figure out which row it's on
+	m_pBrowser->setMouseOverRow( therow );
+	m_pBrowser->DoConnect();
+}

hlsdk/ricochet/cl_dll/vgui_ServerBrowser.h

@@ -0,0 +1,44 @@
+
+#ifndef ServerBrowser_H
+#define ServerBrowser_H
+
+#include<VGUI_Panel.h>
+
+namespace vgui
+{
+class Button;
+class TablePanel;
+class HeaderPanel;
+}
+
+class CTransparentPanel;
+class CommandButton;
+
+// Scoreboard positions
+#define SB_X_INDENT				(20 * ((float)ScreenHeight / 640))
+#define SB_Y_INDENT				(20 * ((float)ScreenHeight / 480))
+
+class ServerBrowser : public CTransparentPanel
+{
+private:
+	HeaderPanel * _headerPanel;
+	TablePanel*  _tablePanel;
+
+	CommandButton*	   _connectButton;
+	CommandButton*	   _refreshButton;
+	CommandButton*	   _broadcastRefreshButton;
+	CommandButton*	   _stopButton;
+	CommandButton*	   _sortButton;
+	CommandButton*	   _cancelButton;
+
+	CommandButton*		_pingButton;
+
+public:
+	ServerBrowser(int x,int y,int wide,int tall);
+public:
+	virtual void setSize(int wide,int tall);
+};
+
+
+
+#endif

hlsdk/ricochet/cl_dll/vgui_discobjects.cpp

@@ -0,0 +1,593 @@
+//=========== (C) Copyright 1999 Valve, L.L.C. All rights reserved. ===========
+//
+// The copyright to the contents herein is the property of Valve, L.L.C.
+// The contents may be used and/or copied only with the written permission of
+// Valve, L.L.C., or in accordance with the terms and conditions stipulated in
+// the agreement/contract under which the contents have been supplied.
+//
+// Purpose: VGUI objects for Discwar
+//
+// $Workfile:     $
+// $Date:         $
+//
+//-----------------------------------------------------------------------------
+// $Log: $
+//
+// $NoKeywords: $
+//=============================================================================
+
+#include "VGUI_Font.h"
+
+#include "hud.h"
+#include "cl_util.h"
+#include "camera.h"
+#include "kbutton.h"
+#include "cvardef.h"
+#include "usercmd.h"
+#include "const.h"
+#include "camera.h"
+#include "in_defs.h"
+#include "parsemsg.h"
+#include "ammo.h"
+#include "string.h"
+#include "ammohistory.h"
+
+#include "vgui_int.h"
+#include "vgui_TeamFortressViewport.h"
+#include "vgui_ServerBrowser.h"
+#include "vgui_discobjects.h"
+
+// Positions and Dimensions
+#define ARENAWINDOW_SIZE_X		(ScreenWidth)
+#define ARENAWINDOW_SIZE_Y		YRES(128)
+#define ARENAWINDOW_X			((ScreenWidth - ARENAWINDOW_SIZE_X) / 2)
+#define ARENAWINDOW_Y			(ScreenHeight - ARENAWINDOW_SIZE_Y)
+
+#define POWERUP_SIZE_X			(ScreenWidth)
+#define POWERUP_SIZE_Y			YRES(32)
+#define POWERUP_X				((ScreenWidth - POWERUP_SIZE_X) / 2)
+#define POWERUP_Y				(ScreenHeight - POWERUP_SIZE_Y)
+
+#define REWARD_SIZE_X			(ScreenWidth)
+#define REWARD_SIZE_Y			YRES(48)
+#define REWARD_X				((ScreenWidth - POWERUP_SIZE_X) / 2)
+#define REWARD_Y				(ScreenHeight / 6)
+
+extern WeaponsResource gWR;
+int	   g_iCannotFire;
+
+//===========================================================
+// Disc ammo icon
+CDiscPanel::CDiscPanel(int x,int y,int wide,int tall) : Label("", x,y,wide,tall)
+{
+	setContentFitted(true);
+
+	// Standard discs
+	m_pDiscTGA_Red = LoadTGAForRes("discred");
+	m_pDiscTGA_RedGlow = LoadTGAForRes("discred2");
+	m_pDiscTGA_Blue = LoadTGAForRes("discblue");
+	m_pDiscTGA_BlueGlow = LoadTGAForRes("discblue2");
+	m_pDiscTGA_Grey = LoadTGAForRes("discgrey");
+
+	// Powerup discs
+	m_pDiscTGA_Fast = LoadTGAForRes("fast");
+	m_pDiscTGA_Freeze = LoadTGAForRes("freeze");
+	m_pDiscTGA_Hard = LoadTGAForRes("hard");
+	m_pDiscTGA_Triple = LoadTGAForRes("triple");
+
+	setImage( m_pDiscTGA_Red );
+}
+
+void CDiscPanel::Update( int iDiscNo, bool bGlow, int iPowerup )
+{
+	int iDiscs = gWR.GetAmmo( 1 );
+
+	// Grey disc for missing discs
+	if ( iDiscs < iDiscNo+1 )
+	{
+		setImage( m_pDiscTGA_Grey );
+	}
+	// Powerups override team colored discs
+	else if ( iPowerup & POW_TRIPLE )
+	{
+		setImage( m_pDiscTGA_Triple );
+	}
+	else if ( iPowerup & POW_FAST )
+	{
+		setImage( m_pDiscTGA_Fast );
+	}
+	else if ( iPowerup & POW_FREEZE )
+	{
+		setImage( m_pDiscTGA_Freeze );
+	}
+	else if ( iPowerup & POW_HARD )
+	{
+		setImage( m_pDiscTGA_Hard );
+	}
+	else if (g_iTeamNumber == 1)
+	{
+		if ( gWR.GetAmmo( 1 ) == 3 )
+			setImage( m_pDiscTGA_RedGlow );
+		else
+			setImage( m_pDiscTGA_Red );
+	}
+	else
+	{
+		if ( gWR.GetAmmo( 1 ) == 3 )
+			setImage( m_pDiscTGA_BlueGlow );
+		else
+			setImage( m_pDiscTGA_Blue );
+	}
+}
+
+//===========================================================
+// Arena window
+CDiscArenaPanel::CDiscArenaPanel( int x, int y, int wide, int tall ) : CTransparentPanel(255, x,y,wide,tall)
+{
+	m_iNumPlayers = 0;
+}
+
+//===========================================================
+// Message handler. Gets the Ids of the players in the round.
+int CDiscArenaPanel::MsgFunc_GetPlayers(const char *pszName, int iSize, void *pbuf )
+{
+	BEGIN_READ( pbuf, iSize );
+
+	m_iRoundNumber = READ_BYTE();
+	m_iSecondsToGo = READ_BYTE();
+
+	m_iNumPlayers = READ_BYTE();
+	if ( m_iNumPlayers > 0 && m_iNumPlayers <= MAX_PLAYERS )
+	{
+		for (int i = 0; i < m_iNumPlayers; i++)
+			m_iClients[i] = READ_SHORT();
+	}
+
+	RecalculateText();
+
+	return 1;
+}
+
+//===========================================================
+// Message handler. Gets the Ids of the players in the round.
+void CDiscArenaPanel::GetClientList( char *pszString )
+{
+	strcpy( pszString, "" );
+	for (int i = 0; i < m_iNumPlayers; i++ )
+	{
+		if ( m_iClients[i] <= 0 || m_iClients[i] > MAX_PLAYERS )
+		{
+			gEngfuncs.Con_Printf( "Combatant %d out of range: %d\n", i, m_iClients[i] );
+			continue;
+		}
+
+		if ( g_PlayerInfoList[ m_iClients[i] ].name && g_PlayerInfoList[ m_iClients[i] ].name[0] )
+		{	
+			if ( i > 0 )
+			{
+				if ( i == (m_iNumPlayers - 1) )
+				{
+					strcat( pszString, CHudTextMessage::BufferedLocaliseTextString( "#And" ) );
+				}
+				else
+				{
+					strcat( pszString, ", " );
+				}
+			}
+
+			strcat( pszString, g_PlayerInfoList[ m_iClients[i] ].name );
+		}
+	}
+}
+
+//===========================================================
+// Round start window
+#define ROUND_Y				YRES(0)
+#define TEAMONE_Y			(ROUND_Y + YRES(32))
+#define	VERSUS_Y			(TEAMONE_Y + YRES(32))
+#define TEAMTWO_Y			(VERSUS_Y + YRES(32))
+
+CDiscArena_RoundStart::CDiscArena_RoundStart( void ) : CDiscArenaPanel( ARENAWINDOW_X, ARENAWINDOW_Y, ARENAWINDOW_SIZE_X, ARENAWINDOW_SIZE_Y )
+{
+	m_pRound = new Label( "Round 1", 0, ROUND_Y, getWide(), YRES(32) );
+	m_pRound->setParent( this );
+	m_pRound->setBgColor( 0, 0, 0, 128 );
+	m_pRound->setFgColor( 255,255,255, 0 );
+	m_pRound->setContentAlignment( vgui::Label::a_center );
+
+	m_pTeamOne = new Label( "Team One", 0, TEAMONE_Y, getWide(), YRES(32) );
+	m_pTeamOne->setParent( this );
+	m_pTeamOne->setBgColor( 128, 0, 0, 128 );
+	m_pTeamOne->setFgColor( 255,255,255, 0 );
+	m_pTeamOne->setContentAlignment( vgui::Label::a_center );
+
+	// Trim the trailing \n from the VS string
+	char sz[32];
+	strcpy( sz, CHudTextMessage::BufferedLocaliseTextString( "#Versus" ) );
+	sz[ strlen(sz) - 1 ] = '\0';
+	Label *pLabel = new Label( sz, 0, VERSUS_Y, getWide(), YRES(32) );
+	pLabel->setParent( this );
+	pLabel->setBgColor( 0, 0, 0, 255 );
+	pLabel->setFgColor( 255,255,255, 0 );
+	pLabel->setContentAlignment( vgui::Label::a_center );
+
+	m_pTeamTwo = new Label( "Team Two", 0, TEAMTWO_Y, getWide(), YRES(32) );
+	m_pTeamTwo->setParent( this );
+	m_pTeamTwo->setBgColor( 0, 0, 128, 128 );
+	m_pTeamTwo->setFgColor( 255,255,255, 0 );
+	m_pTeamTwo->setContentAlignment( vgui::Label::a_center );
+
+	setVisible(false);
+}
+
+// Recalculate the Text in the window
+void CDiscArena_RoundStart::RecalculateText( void )
+{
+	char sz[1024];
+	char szOpponents[1024];
+	char szTemp[256];
+	char szTemp2[256];
+	char szTemp3[256];
+	char *pszLocalized = NULL;
+
+	// Round started?
+	if (m_iSecondsToGo == 0)
+	{
+		setVisible(false);
+		g_iCannotFire = FALSE;
+
+		// Force spectator menu to update
+		if (gViewPort)
+			gViewPort->m_iUser1 = 0;
+		return;
+	}
+
+	g_iCannotFire = TRUE;
+
+	// Round Number
+	if ( m_iSecondsToGo != 1 )
+	{
+		pszLocalized =  "#Round_Start_n_Seconds";
+	}
+	else
+	{
+		pszLocalized =  "#Round_Start_1_Second";
+	}
+
+	strncpy( szTemp3, CHudTextMessage::BufferedLocaliseTextString( pszLocalized ), sizeof( szTemp3 ) - 1 );
+	szTemp3[ sizeof( szTemp3 ) - 1 ] = '\0';
+	sprintf( sz, szTemp3, m_iRoundNumber, m_iSecondsToGo );
+
+	m_pRound->setText( sz );
+
+	// We may have just got an update for the time to go. If so, m_iNumPlayers will be 0.
+	if ( !m_iNumPlayers )
+		return;
+
+	if (gViewPort)
+		gViewPort->GetAllPlayersInfo();
+
+	// Find out what team this client's on (if a new battle's just starting)
+	strcpy( szOpponents, "" );
+	int iMyTeamNumber = 0;
+	if ( m_iRoundNumber == 1 )
+	{
+		for (int i = 0; i < m_iNumPlayers; i++ )
+		{
+			if ( g_PlayerInfoList[ m_iClients[i] ].thisplayer )
+				iMyTeamNumber = (i < (m_iNumPlayers / 2)) ? 1 : 2;
+		}
+	}
+
+	// Team 1
+	strcpy( sz, "" );
+	int i;
+	for ( i = 0; i < (m_iNumPlayers / 2); i++ )
+	{
+		if ( g_PlayerInfoList[ m_iClients[i] ].name && g_PlayerInfoList[ m_iClients[i] ].name[0] )
+			strcat( sz, g_PlayerInfoList[ m_iClients[i] ].name );
+
+		if ( iMyTeamNumber == 2 )
+		{
+			strcpy( szTemp, CHudTextMessage::BufferedLocaliseTextString( "#Opponent" ) );
+			sprintf( szTemp2, szTemp,  g_PlayerInfoList[ m_iClients[i] ].name, g_PlayerExtraInfo[ m_iClients[i] ].deaths, g_PlayerExtraInfo[ m_iClients[i] ].frags );
+			strcat( szOpponents, szTemp2 );
+		}
+	}
+	m_pTeamOne->setText( sz );
+
+	// Team 2
+	strcpy( sz, "" );
+	for ( ; i < m_iNumPlayers; i++ )
+	{
+		if ( g_PlayerInfoList[ m_iClients[i] ].name && g_PlayerInfoList[ m_iClients[i] ].name[0] )
+			strcat( sz, g_PlayerInfoList[ m_iClients[i] ].name );
+
+		if ( iMyTeamNumber == 1 )
+		{
+			strcpy( szTemp, CHudTextMessage::BufferedLocaliseTextString( "#Opponent" ) );
+			sprintf( szTemp2, szTemp,  g_PlayerInfoList[ m_iClients[i] ].name, g_PlayerExtraInfo[ m_iClients[i] ].deaths, g_PlayerExtraInfo[ m_iClients[i] ].frags );
+			strcat( szOpponents, szTemp2 );
+		}
+	}
+	m_pTeamTwo->setText( sz );
+
+	// Bring up the Opponent details
+	if (gViewPort)
+		gViewPort->m_pDiscRewardWindow->SetMessage( szOpponents );
+
+	// Become visible
+	setVisible(true);
+
+	// Hide the other windows if it's up
+	if (gViewPort)
+	{
+		gViewPort->m_pSpectatorMenu->setVisible( false );
+		gViewPort->m_pDiscPowerupWindow->setVisible( false );
+		gViewPort->m_pDiscEndRound->setVisible( false );
+	}
+}
+
+//===========================================================
+// Round end window
+CDiscArena_RoundEnd::CDiscArena_RoundEnd( void ) : CDiscArenaPanel( ARENAWINDOW_X, ARENAWINDOW_Y, ARENAWINDOW_SIZE_X, ARENAWINDOW_SIZE_Y )
+{
+	m_pRound = new Label( "Round 1 Won By", 0, ROUND_Y, getWide(), YRES(32) );
+	m_pRound->setParent( this );
+	m_pRound->setBgColor( 0, 0, 0, 128 );
+	m_pRound->setFgColor( 255,255,255, 0 );
+	m_pRound->setContentAlignment( vgui::Label::a_center );
+
+	m_pWinners = new Label( "Winners", 0, TEAMONE_Y, getWide(), YRES(32) );
+	m_pWinners->setParent( this );
+	m_pWinners->setBgColor( 128, 0, 0, 128 );
+	m_pWinners->setFgColor( 255,255,255, 0 );
+	m_pWinners->setContentAlignment( vgui::Label::a_center );
+
+	m_pWinningTeam = new Label( "Winners", 0, TEAMTWO_Y, getWide(), YRES(32) );
+	m_pWinningTeam->setParent( this );
+	m_pWinningTeam->setBgColor( 128, 0, 0, 128 );
+	m_pWinningTeam->setFgColor( 255,255,255, 0 );
+	m_pWinningTeam->setContentAlignment( vgui::Label::a_center );
+
+	setVisible(false);
+}
+
+// Recalculate the Text in the window
+void CDiscArena_RoundEnd::RecalculateText( void )
+{
+	char sz[1024];
+	char szTemp1[256];
+	char szTemp2[256];
+
+	// Sends down a 0 for time when this should be removed
+	if (m_iSecondsToGo == 0)
+	{
+		setVisible(false);
+		g_iCannotFire = FALSE;
+
+		// Force spectator menu to update
+		if (gViewPort)
+			gViewPort->m_iUser1 = 0;
+		return;
+	}
+
+	g_iCannotFire = TRUE;
+
+	// Round Number
+	strncpy( szTemp1, CHudTextMessage::BufferedLocaliseTextString( "#Round_Won" ), sizeof( szTemp1 ) - 1 );
+	szTemp1[ sizeof( szTemp1 ) - 1 ] = '\0';
+	sprintf( sz, szTemp1, m_iRoundNumber );
+
+	m_pRound->setText( sz );
+
+	if (gViewPort)
+		gViewPort->GetAllPlayersInfo();
+
+	// Winners
+	GetClientList( sz );
+	m_pWinners->setText( sz );
+
+	// Scores
+	m_iNumPlayers = READ_BYTE();
+	if ( m_iNumPlayers >= 0 && m_iNumPlayers <= MAX_PLAYERS )
+	{
+		for (int i = 0; i < m_iNumPlayers; i++)
+			m_iClients[i] = READ_SHORT();
+
+		int iWinningScore = READ_BYTE();
+		int iLosingScore = READ_BYTE();
+		int iBattleOver = READ_BYTE();
+
+		// Battle over?
+		if ( iBattleOver )
+		{
+			GetClientList( sz );
+
+			strncpy( szTemp2, CHudTextMessage::BufferedLocaliseTextString( "#Round_Won_Scores" ), sizeof( szTemp2 ) - 1 );
+			szTemp2[ sizeof( szTemp2 ) - 1 ] = '\0';			
+
+			_snprintf( sz, sizeof( sz ) - 1, szTemp2, sz, iWinningScore, iLosingScore );
+		}
+		// Tied?
+		else if ( iWinningScore == iLosingScore )
+		{
+			strncpy( szTemp2, CHudTextMessage::BufferedLocaliseTextString( "#Round_Tied" ), sizeof( szTemp2 ) - 1 );
+			szTemp2[ sizeof( szTemp2 ) - 1 ] = '\0';			
+
+			_snprintf( sz, sizeof( sz ) - 1, szTemp2, iWinningScore );
+		}
+		else 
+		{
+			char *pszTemp = NULL;
+
+			GetClientList( sz );
+
+			if ( m_iNumPlayers == 1 )
+			{
+				pszTemp = "#Round_Leads";
+			}
+			else
+			{
+				pszTemp = "#Round_Lead";
+			}
+
+			strncpy( szTemp2, CHudTextMessage::BufferedLocaliseTextString( pszTemp ), sizeof( szTemp2 ) - 1 );
+			szTemp2[ sizeof( szTemp2 ) - 1 ] = '\0';			
+
+			_snprintf( sz, sizeof( sz ) - 1, szTemp2, sz, iWinningScore, iLosingScore );
+		}
+
+		sz[ sizeof( sz ) - 1 ] = '\0';
+		m_pWinningTeam->setText( sz );
+	}
+
+	// Become visible
+	setVisible(true);
+
+	// Hide the other windows if it's up
+	if (gViewPort)
+	{
+		gViewPort->m_pSpectatorMenu->setVisible( false );
+		gViewPort->m_pDiscPowerupWindow->setVisible( false );
+		gViewPort->m_pDiscStartRound->setVisible( false );
+	}
+}
+
+//===========================================================
+// Powerup name window
+CDiscPowerups::CDiscPowerups() : CTransparentPanel( 255, POWERUP_X, POWERUP_Y, POWERUP_SIZE_X, POWERUP_SIZE_Y )
+{
+	m_pLabel = new Label( "Powerups Go Here", 0, ROUND_Y, getWide(), YRES(32) );
+	m_pLabel->setParent( this );
+	m_pLabel->setBgColor( 0, 0, 0, 255 );
+	m_pLabel->setFgColor( 255,255,255, 0 );
+	m_pLabel->setContentAlignment( vgui::Label::a_center );
+	setVisible(false);
+};
+
+void CDiscPowerups::RecalculateText( int iPowerup )
+{
+	char sz[512];
+	bool bAnd = false;
+
+	// Don't appear if a round message is up
+	if (gViewPort)
+	{
+		if ( gViewPort->m_pDiscStartRound->isVisible() || gViewPort->m_pDiscEndRound->isVisible() )
+			return;
+	}
+
+	sprintf(sz, "");
+
+	if ( iPowerup & POW_TRIPLE )
+	{
+		strcat(sz, CHudTextMessage::BufferedLocaliseTextString("#Triple") );
+		bAnd = true;
+	}
+	
+	if ( iPowerup & POW_FAST )
+	{
+		if (bAnd)
+			strcat(sz, ", ");
+		strcat(sz, CHudTextMessage::BufferedLocaliseTextString("#Fast") );
+		bAnd = true;
+	}
+	
+	if ( iPowerup & POW_FREEZE )
+	{
+		if (bAnd)
+			strcat(sz, ", ");
+		strcat(sz, CHudTextMessage::BufferedLocaliseTextString("#Freeze") );
+		bAnd = true;
+	}
+	
+	if ( iPowerup & POW_HARD )
+	{
+		if (bAnd)
+			strcat(sz, ", ");
+		strcat(sz, CHudTextMessage::BufferedLocaliseTextString("#Hard") );
+	}
+
+	m_pLabel->setText( sz );
+
+	// Become visible
+	if (sz && sz[0])
+		setVisible(true);
+	else
+		setVisible(false);
+}
+
+//===========================================================
+// Reward menu
+CDiscRewards::CDiscRewards() : CTransparentPanel( 255, REWARD_X, REWARD_Y, REWARD_SIZE_X, REWARD_SIZE_Y )
+{
+	m_pReward = new Label( "Well Done!", 0, ROUND_Y, getWide(), (REWARD_SIZE_Y / 2) );
+	m_pReward->setParent( this );
+	m_pReward->setBgColor( 0, 0, 0, 255 );
+	m_pReward->setFgColor( 255,255,255, 0 );
+	m_pReward->setContentAlignment( vgui::Label::a_center );
+	setVisible(false);
+
+	m_pTeleBonus = new Label( CHudTextMessage::BufferedLocaliseTextString( "#Hit_Tele" ), 0, (REWARD_SIZE_Y / 2), getWide(), (REWARD_SIZE_Y / 2) );
+	m_pTeleBonus->setParent( this );
+	m_pTeleBonus->setBgColor( 0, 0, 0, 255 );
+	m_pTeleBonus->setFgColor( 255,255,255, 0 );
+	m_pTeleBonus->setContentAlignment( vgui::Label::a_center );
+};
+
+void CDiscRewards::RecalculateText( int iReward )
+{
+	char sz[512];
+
+	// Don't appear if a round message is up
+	if (gViewPort)
+	{
+		if ( gViewPort->m_pDiscStartRound->isVisible() || gViewPort->m_pDiscEndRound->isVisible() )
+			return;
+	}
+
+	if ( !iReward )
+	{
+		setVisible( false );
+		return;
+	}
+
+	// Rewards
+	if ( iReward & REWARD_BOUNCE_NONE )
+		sprintf( sz, CHudTextMessage::BufferedLocaliseTextString( "#Hit_Direct" ) );
+	if ( iReward & REWARD_BOUNCE_ONE )
+		sprintf( sz, CHudTextMessage::BufferedLocaliseTextString( "#Hit_One" ) );
+	if ( iReward & REWARD_BOUNCE_TWO )
+		sprintf( sz, CHudTextMessage::BufferedLocaliseTextString( "#Hit_Two" ) );
+	if ( iReward & REWARD_BOUNCE_THREE )
+		sprintf( sz, CHudTextMessage::BufferedLocaliseTextString( "#Hit_Three" ) );
+	if ( iReward & REWARD_DECAPITATE )
+		sprintf( sz, CHudTextMessage::BufferedLocaliseTextString( "#Hit_Decap" ) );
+	if ( iReward & REWARD_DOUBLEKILL )
+		sprintf( sz, CHudTextMessage::BufferedLocaliseTextString( "#Hit_Multiple" ) );
+
+	if ( iReward & REWARD_TELEPORT )
+		m_pTeleBonus->setVisible( true );
+	else
+		m_pTeleBonus->setVisible( false );
+
+	m_pReward->setText( sz );
+	setVisible( true );
+}
+
+void CDiscRewards::SetMessage( char *pMessage )
+{
+	if (!pMessage)
+	{
+		setVisible(false);
+		return;
+	}
+
+	m_pTeleBonus->setVisible( false );
+	m_pReward->setText( pMessage );
+	setVisible( true );
+
+	if (gViewPort)
+		gViewPort->m_flRewardOpenTime = gHUD.m_flTime + 5.0;
+}

hlsdk/ricochet/cl_dll/vgui_discobjects.h

@@ -0,0 +1,109 @@
+//=========== (C) Copyright 1999 Valve, L.L.C. All rights reserved. ===========
+//
+// The copyright to the contents herein is the property of Valve, L.L.C.
+// The contents may be used and/or copied only with the written permission of
+// Valve, L.L.C., or in accordance with the terms and conditions stipulated in
+// the agreement/contract under which the contents have been supplied.
+//
+// Purpose: VGUI objects for Discwar
+//
+// $Workfile:     $
+// $Date:         $
+//
+//-----------------------------------------------------------------------------
+// $Log: $
+//
+// $NoKeywords: $
+//=============================================================================
+
+#ifndef VGUI_DISCOBJECTS_H
+#define VGUI_DISCOBJECTS_H
+#pragma once
+
+//===========================================================
+// Disc ammo icon
+class CDiscPanel : public Label
+{
+private:
+	BitmapTGA	*m_pDiscTGA_Red;
+	BitmapTGA	*m_pDiscTGA_RedGlow;
+	BitmapTGA	*m_pDiscTGA_Blue;
+	BitmapTGA	*m_pDiscTGA_BlueGlow;
+	BitmapTGA	*m_pDiscTGA_Grey;
+	BitmapTGA	*m_pDiscTGA_Fast;
+	BitmapTGA	*m_pDiscTGA_Freeze;
+	BitmapTGA	*m_pDiscTGA_Hard;
+	BitmapTGA	*m_pDiscTGA_Triple;
+public:
+	CDiscPanel(int x,int y,int wide,int tall);
+	void Update( int iDiscNo, bool bGlow, int iPowerup );
+
+	virtual void paintBackground()
+	{
+		// Do nothing, so the background's left transparent.
+	}
+};
+
+//===========================================================
+// Powerup
+class CDiscPowerups : public CTransparentPanel
+{
+public:
+	CDiscPowerups();
+
+	void	RecalculateText( int iPowerup );
+	Label	*m_pLabel;
+};
+
+class CDiscRewards : public CTransparentPanel
+{
+public:
+	CDiscRewards();
+
+	void	RecalculateText( int iReward );
+	void	SetMessage( char *pMessage );
+	Label	*m_pReward;
+	Label	*m_pTeleBonus;
+};
+
+//===========================================================
+// Arena windows
+class CDiscArenaPanel : public CTransparentPanel
+{
+public:
+	CDiscArenaPanel( int x, int y, int wide, int tall );
+	int  MsgFunc_GetPlayers(const char *pszName, int iSize, void *pbuf );
+	virtual void RecalculateText( void ) {};
+	void GetClientList( char *pszString );
+
+	int  m_iNumPlayers;
+	int	 m_iClients[ MAX_PLAYERS ];
+	int	 m_iRoundNumber;
+	int	 m_iSecondsToGo;
+};
+
+class CDiscArena_RoundStart : public CDiscArenaPanel
+{
+public:
+	CDiscArena_RoundStart();
+
+	void RecalculateText( void );
+
+	Label	*m_pRound;
+	Label	*m_pTeamOne;
+	Label	*m_pTeamTwo;
+};
+
+class CDiscArena_RoundEnd : public CDiscArenaPanel
+{
+public:
+	CDiscArena_RoundEnd();
+
+	void RecalculateText( void );
+
+	Label	*m_pRound;
+	Label	*m_pWinners;
+	Label	*m_pWinningTeam;
+};
+
+#endif // VGUI_DISCOBJECTS_H

hlsdk/ricochet/cl_dll/vgui_int.cpp

@@ -0,0 +1,122 @@
+
+#include"vgui_int.h"
+#include<VGUI_Label.h>
+#include<VGUI_BorderLayout.h>
+#include<VGUI_LineBorder.h>
+#include<VGUI_SurfaceBase.h>
+#include<VGUI_TextEntry.h>
+#include<VGUI_ActionSignal.h>
+#include<string.h>
+#include "hud.h"
+#include "cl_util.h"
+#include "camera.h"
+#include "kbutton.h"
+#include "cvardef.h"
+#include "usercmd.h"
+#include "const.h"
+#include "camera.h"
+#include "in_defs.h"
+#include "vgui_TeamFortressViewport.h"
+#include "vgui_ControlConfigPanel.h"
+
+namespace
+{
+
+class TexturePanel : public Panel , public ActionSignal
+{
+private:
+	int _bindIndex;
+	TextEntry* _textEntry;
+public:
+	TexturePanel() : Panel(0,0,256,276)
+	{
+		_bindIndex=2700;
+		_textEntry=new TextEntry("2700",0,0,128,20);
+		_textEntry->setParent(this);
+		_textEntry->addActionSignal(this);
+	}
+public:
+	virtual bool isWithin(int x,int y)
+	{
+		return _textEntry->isWithin(x,y);
+	}
+public:
+	virtual void actionPerformed(Panel* panel)
+	{
+		char buf[256];
+		_textEntry->getText(0,buf,256);
+		sscanf(buf,"%d",&_bindIndex);
+	}
+protected:
+	virtual void paintBackground()
+	{
+			Panel::paintBackground();
+			
+			int wide,tall;
+			getPaintSize(wide,tall);
+		
+			drawSetColor(0,0,255,0);
+			drawSetTexture(_bindIndex);
+			drawTexturedRect(0,19,257,257);
+	}
+
+};
+
+}
+
+using namespace vgui;
+
+void VGui_ViewportPaintBackground(int extents[4])
+{
+	gEngfuncs.VGui_ViewportPaintBackground(extents);
+}
+
+void* VGui_GetPanel()
+{
+	return (Panel*)gEngfuncs.VGui_GetPanel();
+}
+
+void VGui_Startup()
+{
+	Panel* root=(Panel*)VGui_GetPanel();
+	root->setBgColor(128,128,0,0);
+	//root->setNonPainted(false);
+	//root->setBorder(new LineBorder());
+	root->setLayout(new BorderLayout(0));
+
+	
+	//root->getSurfaceBase()->setEmulatedCursorVisible(true);
+
+	if (gViewPort != NULL)
+	{
+//		root->removeChild(gViewPort);
+
+		// free the memory
+//		delete gViewPort;
+//		gViewPort = NULL;
+
+		gViewPort->Initialize();
+	}
+	else
+	{
+		gViewPort = new TeamFortressViewport(0,0,root->getWide(),root->getTall());
+		gViewPort->setParent(root);
+	}
+
+	/*
+	TexturePanel* texturePanel=new TexturePanel();
+	texturePanel->setParent(gViewPort);
+	*/
+
+}
+
+void VGui_Shutdown()
+{
+	delete gViewPort;
+	gViewPort = NULL;
+}
+
+
+
+
+

hlsdk/ricochet/cl_dll/vgui_int.h

@@ -0,0 +1,15 @@
+
+#ifndef VGUI_INT_H
+#define VGUI_INT_H
+
+extern "C"
+{
+void VGui_Startup();
+void VGui_Shutdown();
+
+//Only safe to call from inside subclass of Panel::paintBackground
+void VGui_ViewportPaintBackground(int extents[4]);
+}
+
+
+#endif

hlsdk/ricochet/cl_dll/view.h

@@ -0,0 +1,22 @@
+/***
+*
+*	Copyright (c) 1999, 2000 Valve LLC. All rights reserved.
+*	
+*	This product contains software technology licensed from Id 
+*	Software, Inc. ("Id Technology").  Id Technology (c) 1996 Id Software, Inc. 
+*	All Rights Reserved.
+*
+*   Use, distribution, and modification of this source code and/or resulting
+*   object code is restricted to non-commercial enhancements to products from
+*   Valve LLC.  All other use, distribution, or modification is prohibited
+*   without written permission from Valve LLC.
+*
+****/
+#if !defined ( VIEWH )
+#define VIEWH 
+#pragma once
+
+void V_StartPitchDrift( void );
+void V_StopPitchDrift( void );
+
+#endif // !VIEWH

hlsdk/ricochet/cl_dll/wrect.h

@@ -0,0 +1,23 @@
+/***
+*
+*	Copyright (c) 1999, 2000 Valve LLC. All rights reserved.
+*	
+*	This product contains software technology licensed from Id 
+*	Software, Inc. ("Id Technology").  Id Technology (c) 1996 Id Software, Inc. 
+*	All Rights Reserved.
+*
+*   Use, distribution, and modification of this source code and/or resulting
+*   object code is restricted to non-commercial enhancements to products from
+*   Valve LLC.  All other use, distribution, or modification is prohibited
+*   without written permission from Valve LLC.
+*
+****/
+#if !defined( WRECTH )
+#define WRECTH
+
+typedef struct rect_s
+{
+	int				left, right, top, bottom;
+} wrect_t;
+
+#endif

hlsdk/ricochet/dlls/Makefile

@@ -0,0 +1,137 @@
+#
+# Half-Life Ricochet SDK 2.3 ricochet_i386.so Makefile for x86 Linux
+#
+# October 2002 by Leon Hartwig (hartwig@valvesoftware.com)
+#
+
+DLLNAME=ricochet
+
+ARCH=i386
+
+#make sure this is the correct compiler for your system
+CC=gcc
+
+DLL_SRCDIR=.
+ENGINE_SRCDIR=../../engine
+COMMON_SRCDIR=../../common
+PM_SHARED_SRCDIR=../pm_shared
+GAME_SHARED_SRCDIR=../../game_shared
+WPN_SRC_DIR=$(DLL_SRCDIR)/wpn_shared
+
+DLL_OBJDIR=$(DLL_SRCDIR)/obj
+PM_SHARED_OBJDIR=$(DLL_OBJDIR)/pm_shared
+GAME_SHARED_OBJDIR=$(DLL_OBJDIR)/game_shared
+WPN_OBJ_DIR=$(DLL_OBJDIR)/wpn_shared
+
+BASE_CFLAGS=-Dstricmp=strcasecmp -D_strnicmp=strncasecmp -Dstrnicmp=strncasecmp -D_vsnprintf=vsnprintf
+
+#safe optimization
+CFLAGS=$(BASE_CFLAGS) -Wall -Wno-non-virtual-dtor -Wno-invalid-offsetof -Werror -m486 -O1
+C_FLAGS=$(BASE_CFLAGS) -Wall -Werror -m486 -O1
+
+#full optimization
+#CFLAGS=$(BASE_CFLAGS) -Wall -Wno-non-virtual-dtor -Wno-invalid-offsetof -Werror -O1 -m486 -ffast-math -funroll-loops \
+	-fomit-frame-pointer -fexpensive-optimizations \
+	-malign-loops=2 -malign-jumps=2 -malign-functions=2
+
+#use these when debugging 
+#CFLAGS=$(BASE_CFLAGS) -g
+
+INCLUDEDIRS=-I. -I$(ENGINE_SRCDIR) -I$(COMMON_SRCDIR) -I$(PM_SHARED_SRCDIR) -I$(GAME_SHARED_SRCDIR)
+
+LDFLAGS=
+
+SHLIBEXT=so
+SHLIBCFLAGS=-fPIC
+SHLIBLDFLAGS=-shared
+
+DO_CC=$(CC) $(CFLAGS) $(SHLIBCFLAGS) $(INCLUDEDIRS) -o $@ -c $<
+DO_C=$(CC) $(C_FLAGS) $(SHLIBCFLAGS) $(INCLUDEDIRS) -o $@ -c $<
+
+#############################################################################
+# SETUP AND BUILD
+# GAME
+#############################################################################
+
+$(DLL_OBJDIR)/%.o: $(DLL_SRCDIR)/%.cpp
+	$(DO_CC)
+
+$(GAME_SHARED_OBJDIR)/%.o: $(GAME_SHARED_SRCDIR)/%.cpp
+	$(DO_CC)
+
+$(PM_SHARED_OBJDIR)/%.o: $(PM_SHARED_SRCDIR)/%.c
+	$(DO_C)
+
+$(WPN_OBJ_DIR)/%.o : $(WPN_SRC_DIR)/%.cpp
+	$(DO_CC)
+
+OBJ = \
+	$(DLL_OBJDIR)/airtank.o \
+	$(DLL_OBJDIR)/animating.o \
+	$(DLL_OBJDIR)/animation.o \
+	$(DLL_OBJDIR)/bmodels.o \
+	$(DLL_OBJDIR)/buttons.o \
+	$(DLL_OBJDIR)/cbase.o \
+	$(DLL_OBJDIR)/client.o \
+	$(DLL_OBJDIR)/combat.o \
+	$(DLL_OBJDIR)/disc_arena.o \
+	$(DLL_OBJDIR)/disc_powerups.o \
+	$(DLL_OBJDIR)/doors.o \
+	$(DLL_OBJDIR)/effects.o \
+	$(DLL_OBJDIR)/explode.o \
+	$(DLL_OBJDIR)/func_break.o \
+	$(DLL_OBJDIR)/func_tank.o \
+	$(DLL_OBJDIR)/game.o \
+	$(DLL_OBJDIR)/gamerules.o \
+	$(DLL_OBJDIR)/ggrenade.o \
+	$(DLL_OBJDIR)/globals.o \
+	$(DLL_OBJDIR)/h_ai.o \
+	$(DLL_OBJDIR)/h_battery.o \
+	$(DLL_OBJDIR)/h_cycler.o \
+	$(DLL_OBJDIR)/h_export.o \
+	$(DLL_OBJDIR)/healthkit.o \
+	$(DLL_OBJDIR)/items.o \
+	$(DLL_OBJDIR)/lights.o \
+	$(DLL_OBJDIR)/maprules.o \
+	$(DLL_OBJDIR)/mortar.o \
+	$(DLL_OBJDIR)/mpstubb.o \
+	$(DLL_OBJDIR)/multiplay_gamerules.o \
+	$(DLL_OBJDIR)/observer.o \
+	$(DLL_OBJDIR)/pathcorner.o \
+	$(DLL_OBJDIR)/plane.o \
+	$(DLL_OBJDIR)/plats.o \
+	$(DLL_OBJDIR)/player.o \
+	$(DLL_OBJDIR)/singleplay_gamerules.o \
+	$(DLL_OBJDIR)/skill.o \
+	$(DLL_OBJDIR)/sound.o \
+	$(DLL_OBJDIR)/soundent.o \
+	$(DLL_OBJDIR)/spectator.o \
+	$(DLL_OBJDIR)/subs.o \
+	$(DLL_OBJDIR)/teamplay_gamerules.o \
+	$(DLL_OBJDIR)/triggers.o \
+	$(DLL_OBJDIR)/util.o \
+	$(DLL_OBJDIR)/weapons.o \
+	$(DLL_OBJDIR)/world.o \
+	$(DLL_OBJDIR)/xen.o \
+	$(WPN_OBJ_DIR)/disc_weapon_disc.o \
+	$(PM_SHARED_OBJDIR)/pm_shared.o \
+	$(PM_SHARED_OBJDIR)/pm_math.o \
+	$(PM_SHARED_OBJDIR)/pm_debug.o \
+	$(GAME_SHARED_OBJDIR)/voice_gamemgr.o
+
+$(DLLNAME)_$(ARCH).$(SHLIBEXT) : neat $(OBJ)
+	$(CC) $(CFLAGS) $(SHLIBLDFLAGS) $(LDFLAGS) -o $@ $(OBJ)
+
+neat:
+	-mkdir -p $(DLL_OBJDIR)
+	-mkdir -p $(GAME_SHARED_OBJDIR)
+	-mkdir -p $(PM_SHARED_OBJDIR)
+	-mkdir -p $(WPN_OBJ_DIR)
+clean:
+	-rm -f $(OBJ)
+	-rm -f $(DLLNAME)_$(ARCH).$(SHLIBEXT)
+spotless: clean
+	-rm -rf $(WPN_OBJ_DIR)
+	-rm -rf $(GAME_SHARED_OBJDIR)
+	-rm -rf $(PM_SHARED_OBJDIR)
+	-rm -rf $(DLL_OBJDIR)

hlsdk/ricochet/dlls/activity.h

@@ -0,0 +1,79 @@
+/***
+*
+*	Copyright (c) 1996-2002, Valve LLC. All rights reserved.
+*	
+*	This product contains software technology licensed from Id 
+*	Software, Inc. ("Id Technology").  Id Technology (c) 1996 Id Software, Inc. 
+*	All Rights Reserved.
+*
+*   Use, distribution, and modification of this source code and/or resulting
+*   object code is restricted to non-commercial enhancements to products from
+*   Valve LLC.  All other use, distribution, or modification is prohibited
+*   without written permission from Valve LLC.
+*
+****/
+
+#ifndef	ACTIVITY_H
+#define	ACTIVITY_H
+
+
+typedef enum {
+	ACT_RESET = 0,		// Set m_Activity to this invalid value to force a reset to m_IdealActivity
+	ACT_IDLE,
+	ACT_HOP,
+	ACT_HOP_LEFT_FOOT,
+	ACT_LEAP,
+
+	ACT_TURN_LEFT,
+	ACT_TURN_RIGHT,
+
+	ACT_BASE_STAND,
+	ACT_BASE_STAND_THROW,
+	ACT_FREEZE_STAND,
+	ACT_FREEZE_STAND_THROW,
+	ACT_HARD_STAND,
+	ACT_HARD_STAND_THROW,
+	ACT_TRIPLE_STAND,
+	ACT_TRIPLE_STAND_THROW,
+
+	ACT_UNARMED_WALK,
+	ACT_UNARMED_RUN,
+	ACT_UNARMED_BACKPEDAL,
+
+	ACT_BASE_WALK,
+	ACT_BASE_RUN,
+	ACT_BASE_THROW,
+	ACT_BASE_BACKUP,
+	ACT_BASE_BACKUP_THROW,
+
+	ACT_BASE_REVERSE,
+	ACT_BASE_REVERSE_THROW,
+
+	ACT_FALL,
+	ACT_FALL_FORWARD,
+	ACT_FALL_BACKWARD,
+	ACT_FALL_LEFT,
+	ACT_FALL_RIGHT,
+
+	ACT_FLINCH_CLOCKWISE,
+	ACT_FLINCH_COUNTERCLOCKWISE,
+	ACT_FLINCH_BACK,
+	ACT_FLINCH_LEFT,
+	ACT_FLINCH_RIGHT,
+	ACT_FLINCH_FORWARD,
+
+	ACT_DIE_HEADSHOT,
+	ACT_DIEFORWARD,
+	ACT_DIEBACKWARD,
+} Activity;
+
+
+typedef struct {
+	int	type;
+	char *name;
+} activity_map_t;
+
+extern activity_map_t activity_map[];
+
+
+#endif	//ACTIVITY_H

hlsdk/ricochet/dlls/activitymap.h

@@ -0,0 +1,37 @@
+/***
+*
+*	Copyright (c) 1996-2002, Valve LLC. All rights reserved.
+*	
+*	This product contains software technology licensed from Id 
+*	Software, Inc. ("Id Technology").  Id Technology (c) 1996 Id Software, Inc. 
+*	All Rights Reserved.
+*
+*   Use, distribution, and modification of this source code and/or resulting
+*   object code is restricted to non-commercial enhancements to products from
+*   Valve LLC.  All other use, distribution, or modification is prohibited
+*   without written permission from Valve LLC.
+*
+****/
+
+#define _A( a ) { a, #a }
+
+activity_map_t activity_map[] =
+{
+_A(	ACT_IDLE ),
+_A(	ACT_HOP ),
+
+_A(	ACT_FALL_FORWARD ),
+_A(	ACT_FALL_BACKWARD ),
+_A(	ACT_FALL_LEFT ),
+_A(	ACT_FALL_RIGHT ),
+
+_A(	ACT_FLINCH_BACK ),
+_A(	ACT_FLINCH_LEFT ),
+_A(	ACT_FLINCH_RIGHT ),
+_A(	ACT_FLINCH_FORWARD ),
+
+_A(	ACT_DIE_HEADSHOT ),
+_A(	ACT_DIEFORWARD ),
+_A(	ACT_DIEBACKWARD ),
+{ 0, NULL }
+};

hlsdk/ricochet/dlls/airtank.cpp

@@ -0,0 +1,118 @@
+/***
+*
+*	Copyright (c) 1996-2002, Valve LLC. All rights reserved.
+*	
+*	This product contains software technology licensed from Id 
+*	Software, Inc. ("Id Technology").  Id Technology (c) 1996 Id Software, Inc. 
+*	All Rights Reserved.
+*
+*   Use, distribution, and modification of this source code and/or resulting
+*   object code is restricted to non-commercial enhancements to products from
+*   Valve LLC.  All other use, distribution, or modification is prohibited
+*   without written permission from Valve LLC.
+*
+****/
+#include "extdll.h"
+#include "util.h"
+#include "cbase.h"
+#include "monsters.h"
+#include "weapons.h"
+#include "nodes.h"
+#include "player.h"
+
+class CAirtank : public CGrenade
+{
+	void Spawn( void );
+	void Precache( void );
+	void EXPORT TankThink( void );
+	void EXPORT TankTouch( CBaseEntity *pOther );
+	int	 BloodColor( void ) { return DONT_BLEED; };
+	void Killed( entvars_t *pevAttacker, int iGib );
+
+	virtual int		Save( CSave &save ); 
+	virtual int		Restore( CRestore &restore );
+	
+	static	TYPEDESCRIPTION m_SaveData[];
+
+	int	 m_state;
+};
+
+
+LINK_ENTITY_TO_CLASS( item_airtank, CAirtank );
+TYPEDESCRIPTION	CAirtank::m_SaveData[] = 
+{
+	DEFINE_FIELD( CAirtank, m_state, FIELD_INTEGER ),
+};
+
+IMPLEMENT_SAVERESTORE( CAirtank, CGrenade );
+
+
+void CAirtank :: Spawn( void )
+{
+	Precache( );
+	// motor
+	pev->movetype = MOVETYPE_FLY;
+	pev->solid = SOLID_BBOX;
+
+	SET_MODEL(ENT(pev), "models/w_oxygen.mdl");
+	UTIL_SetSize(pev, Vector( -16, -16, 0), Vector(16, 16, 36));
+	UTIL_SetOrigin( pev, pev->origin );
+
+	SetTouch( &CAirtank::TankTouch );
+	SetThink( &CAirtank::TankThink );
+
+	pev->flags |= FL_MONSTER;
+	pev->takedamage		= DAMAGE_YES;
+	pev->health			= 20;
+	pev->dmg			= 50;
+	m_state				= 1;
+}
+
+void CAirtank::Precache( void )
+{
+	PRECACHE_MODEL("models/w_oxygen.mdl");
+	PRECACHE_SOUND("doors/aliendoor3.wav");
+}
+
+
+void CAirtank :: Killed( entvars_t *pevAttacker, int iGib )
+{
+	pev->owner = ENT( pevAttacker );
+
+	// UNDONE: this should make a big bubble cloud, not an explosion
+
+	Explode( pev->origin, Vector( 0, 0, -1 ) );
+}
+
+
+void CAirtank::TankThink( void )
+{
+	// Fire trigger
+	m_state = 1;
+	SUB_UseTargets( this, USE_TOGGLE, 0 );
+}
+
+
+void CAirtank::TankTouch( CBaseEntity *pOther )
+{
+	if ( !pOther->IsPlayer() )
+		return;
+
+	if (!m_state)
+	{
+		// "no oxygen" sound
+		EMIT_SOUND( ENT(pev), CHAN_BODY, "player/pl_swim2.wav", 1.0, ATTN_NORM );
+		return;
+	}
+		
+	// give player 12 more seconds of air
+	pOther->pev->air_finished = gpGlobals->time + 12;
+
+	// suit recharge sound
+	EMIT_SOUND( ENT(pev), CHAN_VOICE, "doors/aliendoor3.wav", 1.0, ATTN_NORM );
+
+	// recharge airtank in 30 seconds
+	pev->nextthink = gpGlobals->time + 30;
+	m_state = 0;
+	SUB_UseTargets( this, USE_TOGGLE, 1 );
+}

hlsdk/ricochet/dlls/animating.cpp

@@ -0,0 +1,313 @@
+/***
+*
+*	Copyright (c) 1996-2002, Valve LLC. All rights reserved.
+*	
+*	This product contains software technology licensed from Id 
+*	Software, Inc. ("Id Technology").  Id Technology (c) 1996 Id Software, Inc. 
+*	All Rights Reserved.
+*
+*   Use, distribution, and modification of this source code and/or resulting
+*   object code is restricted to non-commercial enhancements to products from
+*   Valve LLC.  All other use, distribution, or modification is prohibited
+*   without written permission from Valve LLC.
+*
+****/
+/*
+
+===== monsters.cpp ========================================================
+
+  Monster-related utility code
+
+*/
+
+#include "extdll.h"
+#include "util.h"
+#include "cbase.h"
+#include "animation.h"
+#include "saverestore.h"
+
+TYPEDESCRIPTION	CBaseAnimating::m_SaveData[] = 
+{
+	DEFINE_FIELD( CBaseMonster, m_flFrameRate, FIELD_FLOAT ),
+	DEFINE_FIELD( CBaseMonster, m_flGroundSpeed, FIELD_FLOAT ),
+	DEFINE_FIELD( CBaseMonster, m_flLastEventCheck, FIELD_TIME ),
+	DEFINE_FIELD( CBaseMonster, m_fSequenceFinished, FIELD_BOOLEAN ),
+	DEFINE_FIELD( CBaseMonster, m_fSequenceLoops, FIELD_BOOLEAN ),
+};
+
+IMPLEMENT_SAVERESTORE( CBaseAnimating, CBaseDelay );
+
+
+//=========================================================
+// StudioFrameAdvance - advance the animation frame up to the current time
+// if an flInterval is passed in, only advance animation that number of seconds
+//=========================================================
+float CBaseAnimating :: StudioFrameAdvance ( float flInterval )
+{
+	if (flInterval == 0.0)
+	{
+		flInterval = (gpGlobals->time - pev->animtime);
+		if (flInterval <= 0.001)
+		{
+			pev->animtime = gpGlobals->time;
+			return 0.0;
+		}
+	}
+	if (! pev->animtime)
+		flInterval = 0.0;
+	
+	pev->frame += flInterval * m_flFrameRate * pev->framerate;
+	pev->animtime = gpGlobals->time;
+
+	if (pev->frame < 0.0 || pev->frame >= 256.0) 
+	{
+		if (m_fSequenceLoops)
+			pev->frame -= (int)(pev->frame / 256.0) * 256.0;
+		else
+			pev->frame = (pev->frame < 0.0) ? 0 : 255;
+		m_fSequenceFinished = TRUE;	// just in case it wasn't caught in GetEvents
+	}
+
+	return flInterval;
+}
+
+//=========================================================
+// LookupActivity
+//=========================================================
+int CBaseAnimating :: LookupActivity ( int activity )
+{
+	ASSERT( activity != 0 );
+	void *pmodel = GET_MODEL_PTR( ENT(pev) );
+
+	return ::LookupActivity( pmodel, pev, activity );
+}
+
+//=========================================================
+// LookupActivityHeaviest
+//
+// Get activity with highest 'weight'
+//
+//=========================================================
+int CBaseAnimating :: LookupActivityHeaviest ( int activity )
+{
+	void *pmodel = GET_MODEL_PTR( ENT(pev) );
+
+	return ::LookupActivityHeaviest( pmodel, pev, activity );
+}
+
+//=========================================================
+//=========================================================
+int CBaseAnimating :: LookupSequence ( const char *label )
+{
+	void *pmodel = GET_MODEL_PTR( ENT(pev) );
+
+	return ::LookupSequence( pmodel, label );
+}
+
+
+//=========================================================
+//=========================================================
+void CBaseAnimating :: ResetSequenceInfo ( )
+{
+	void *pmodel = GET_MODEL_PTR( ENT(pev) );
+
+	GetSequenceInfo( pmodel, pev, &m_flFrameRate, &m_flGroundSpeed );
+	m_fSequenceLoops = ((GetSequenceFlags() & STUDIO_LOOPING) != 0);
+	pev->animtime = gpGlobals->time;
+	pev->framerate = 1.0;
+	m_fSequenceFinished = FALSE;
+	m_flLastEventCheck = gpGlobals->time;
+}
+
+
+
+//=========================================================
+//=========================================================
+BOOL CBaseAnimating :: GetSequenceFlags( )
+{
+	void *pmodel = GET_MODEL_PTR( ENT(pev) );
+
+	return ::GetSequenceFlags( pmodel, pev );
+}
+
+//=========================================================
+// DispatchAnimEvents
+//=========================================================
+void CBaseAnimating :: DispatchAnimEvents ( float flInterval )
+{
+	MonsterEvent_t	event;
+
+	void *pmodel = GET_MODEL_PTR( ENT(pev) );
+
+	if ( !pmodel )
+	{
+		ALERT( at_aiconsole, "Gibbed monster is thinking!\n" );
+		return;
+	}
+
+	// FIXME: I have to do this or some events get missed, and this is probably causing the problem below
+	flInterval = 0.1;
+
+	// FIX: this still sometimes hits events twice
+	float flStart = pev->frame + (m_flLastEventCheck - pev->animtime) * m_flFrameRate * pev->framerate;
+	float flEnd = pev->frame + flInterval * m_flFrameRate * pev->framerate;
+	m_flLastEventCheck = pev->animtime + flInterval;
+
+	m_fSequenceFinished = FALSE;
+	if (flEnd >= 256 || flEnd <= 0.0) 
+		m_fSequenceFinished = TRUE;
+
+	int index = 0;
+
+	while ( (index = GetAnimationEvent( pmodel, pev, &event, flStart, flEnd, index ) ) != 0 )
+	{
+		HandleAnimEvent( &event );
+	}
+}
+
+
+//=========================================================
+//=========================================================
+float CBaseAnimating :: SetBoneController ( int iController, float flValue )
+{
+	void *pmodel = GET_MODEL_PTR( ENT(pev) );
+
+	return SetController( pmodel, pev, iController, flValue );
+}
+
+//=========================================================
+//=========================================================
+void CBaseAnimating :: InitBoneControllers ( void )
+{
+	void *pmodel = GET_MODEL_PTR( ENT(pev) );
+
+	SetController( pmodel, pev, 0, 0.0 );
+	SetController( pmodel, pev, 1, 0.0 );
+	SetController( pmodel, pev, 2, 0.0 );
+	SetController( pmodel, pev, 3, 0.0 );
+}
+
+//=========================================================
+//=========================================================
+float CBaseAnimating :: SetBlending ( int iBlender, float flValue )
+{
+	void *pmodel = GET_MODEL_PTR( ENT(pev) );
+
+	return ::SetBlending( pmodel, pev, iBlender, flValue );
+}
+
+//=========================================================
+//=========================================================
+void CBaseAnimating :: GetBonePosition ( int iBone, Vector &origin, Vector &angles )
+{
+	GET_BONE_POSITION( ENT(pev), iBone, origin, angles );
+}
+
+//=========================================================
+//=========================================================
+void CBaseAnimating :: GetAttachment ( int iAttachment, Vector &origin, Vector &angles )
+{
+	GET_ATTACHMENT( ENT(pev), iAttachment, origin, angles );
+}
+
+//=========================================================
+//=========================================================
+int CBaseAnimating :: FindTransition( int iEndingSequence, int iGoalSequence, int *piDir )
+{
+	void *pmodel = GET_MODEL_PTR( ENT(pev) );
+	
+	if (piDir == NULL)
+	{
+		int iDir;
+		int sequence = ::FindTransition( pmodel, iEndingSequence, iGoalSequence, &iDir );
+		if (iDir != 1)
+			return -1;
+		else
+			return sequence;
+	}
+
+	return ::FindTransition( pmodel, iEndingSequence, iGoalSequence, piDir );
+}
+
+//=========================================================
+//=========================================================
+void CBaseAnimating :: GetAutomovement( Vector &origin, Vector &angles, float flInterval )
+{
+
+}
+
+void CBaseAnimating :: SetBodygroup( int iGroup, int iValue )
+{
+	::SetBodygroup( GET_MODEL_PTR( ENT(pev) ), pev, iGroup, iValue );
+}
+
+int CBaseAnimating :: GetBodygroup( int iGroup )
+{
+	return ::GetBodygroup( GET_MODEL_PTR( ENT(pev) ), pev, iGroup );
+}
+
+
+int CBaseAnimating :: ExtractBbox( int sequence, float *mins, float *maxs )
+{
+	return ::ExtractBbox( GET_MODEL_PTR( ENT(pev) ), sequence, mins, maxs );
+}
+
+//=========================================================
+//=========================================================
+
+void CBaseAnimating :: SetSequenceBox( void )
+{
+	Vector mins, maxs;
+
+	// Get sequence bbox
+	if ( ExtractBbox( pev->sequence, mins, maxs ) )
+	{
+		// expand box for rotation
+		// find min / max for rotations
+		float yaw = pev->angles.y * (M_PI / 180.0);
+		
+		Vector xvector, yvector;
+		xvector.x = cos(yaw);
+		xvector.y = sin(yaw);
+		yvector.x = -sin(yaw);
+		yvector.y = cos(yaw);
+		Vector bounds[2];
+
+		bounds[0] = mins;
+		bounds[1] = maxs;
+		
+		Vector rmin( 9999, 9999, 9999 );
+		Vector rmax( -9999, -9999, -9999 );
+		Vector base, transformed;
+
+		for (int i = 0; i <= 1; i++ )
+		{
+			base.x = bounds[i].x;
+			for ( int j = 0; j <= 1; j++ )
+			{
+				base.y = bounds[j].y;
+				for ( int k = 0; k <= 1; k++ )
+				{
+					base.z = bounds[k].z;
+					
+				// transform the point
+					transformed.x = xvector.x*base.x + yvector.x*base.y;
+					transformed.y = xvector.y*base.x + yvector.y*base.y;
+					transformed.z = base.z;
+					
+					for ( int l = 0; l < 3; l++ )
+					{
+						if (transformed[l] < rmin[l])
+							rmin[l] = transformed[l];
+						if (transformed[l] > rmax[l])
+							rmax[l] = transformed[l];
+					}
+				}
+			}
+		}
+		rmin.z = 0;
+		rmax.z = rmin.z + 1;
+		UTIL_SetSize( pev, rmin, rmax );
+	}
+}
+

hlsdk/ricochet/dlls/animation.cpp

@@ -0,0 +1,533 @@
+/***
+*
+*	Copyright (c) 1996-2002, Valve LLC. All rights reserved.
+*	
+*	This product contains software technology licensed from Id 
+*	Software, Inc. ("Id Technology").  Id Technology (c) 1996 Id Software, Inc. 
+*	All Rights Reserved.
+*
+*   Use, distribution, and modification of this source code and/or resulting
+*   object code is restricted to non-commercial enhancements to products from
+*   Valve LLC.  All other use, distribution, or modification is prohibited
+*   without written permission from Valve LLC.
+*
+****/
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#if defined _MSC_VER && _MSC_VER >= 1400
+	#ifndef _CRT_SECURE_NO_DEPRECATE
+		#define _CRT_SECURE_NO_DEPRECATE
+	#endif
+
+	#pragma warning(disable: 4996) // deprecated functions
+#endif
+
+typedef bool BOOL;
+
+// hack into header files that we can ship
+typedef int qboolean;
+typedef unsigned char byte;
+#include "../utils/common/mathlib.h"
+#include "const.h"
+#include "progdefs.h"
+#include "edict.h"
+#include "eiface.h"
+
+#include "studio.h"
+
+#include "../engine/studio.h"
+
+#ifndef ACTIVITY_H
+#include "activity.h"
+#endif
+
+#include "activitymap.h"
+
+#ifndef ANIMATION_H
+#include "animation.h"
+#endif
+
+#ifndef SCRIPTEVENT_H
+#include "scriptevent.h"
+#endif
+
+#ifndef ENGINECALLBACK_H
+#include "enginecallback.h"
+#endif
+
+extern globalvars_t				*gpGlobals;
+
+#ifdef _MSC_VER
+#pragma warning( disable : 4244 )
+#endif
+
+
+int ExtractBbox( void *pmodel, int sequence, float *mins, float *maxs )
+{
+	studiohdr_t *pstudiohdr;
+	
+	pstudiohdr = (studiohdr_t *)pmodel;
+	if (! pstudiohdr)
+		return 0;
+
+	mstudioseqdesc_t	*pseqdesc;
+
+	pseqdesc = (mstudioseqdesc_t *)((byte *)pstudiohdr + pstudiohdr->seqindex);
+	
+	mins[0] = pseqdesc[ sequence ].bbmin[0];
+	mins[1] = pseqdesc[ sequence ].bbmin[1];
+	mins[2] = pseqdesc[ sequence ].bbmin[2];
+
+	maxs[0] = pseqdesc[ sequence ].bbmax[0];
+	maxs[1] = pseqdesc[ sequence ].bbmax[1];
+	maxs[2] = pseqdesc[ sequence ].bbmax[2];
+
+	return 1;
+}
+
+
+int LookupActivity( void *pmodel, entvars_t *pev, int activity )
+{
+	studiohdr_t *pstudiohdr;
+	
+	pstudiohdr = (studiohdr_t *)pmodel;
+	if (! pstudiohdr)
+		return 0;
+
+	mstudioseqdesc_t	*pseqdesc;
+
+	pseqdesc = (mstudioseqdesc_t *)((byte *)pstudiohdr + pstudiohdr->seqindex);
+
+	int weighttotal = 0;
+	int seq = ACTIVITY_NOT_AVAILABLE;
+	for (int i = 0; i < pstudiohdr->numseq; i++)
+	{
+		if (pseqdesc[i].activity == activity)
+		{
+			weighttotal += pseqdesc[i].actweight;
+			if (!weighttotal || RANDOM_LONG(0,weighttotal-1) < pseqdesc[i].actweight)
+				seq = i;
+		}
+	}
+
+	return seq;
+}
+
+
+int LookupActivityHeaviest( void *pmodel, entvars_t *pev, int activity )
+{
+	studiohdr_t *pstudiohdr;
+	
+	pstudiohdr = (studiohdr_t *)pmodel;
+	if ( !pstudiohdr )
+		return 0;
+
+	mstudioseqdesc_t	*pseqdesc;
+
+	pseqdesc = (mstudioseqdesc_t *)((byte *)pstudiohdr + pstudiohdr->seqindex);
+
+	int weight = 0;
+	int seq = ACTIVITY_NOT_AVAILABLE;
+	for (int i = 0; i < pstudiohdr->numseq; i++)
+	{
+		if (pseqdesc[i].activity == activity)
+		{
+			if ( pseqdesc[i].actweight > weight )
+			{
+				weight = pseqdesc[i].actweight;
+				seq = i;
+			}
+		}
+	}
+
+	return seq;
+}
+
+void GetEyePosition ( void *pmodel, float *vecEyePosition )
+{
+	studiohdr_t *pstudiohdr;
+	
+	pstudiohdr = (studiohdr_t *)pmodel;
+
+	if ( !pstudiohdr )
+	{
+		ALERT ( at_console, "GetEyePosition() Can't get pstudiohdr ptr!\n" );
+		return;
+	}
+
+	VectorCopy ( pstudiohdr->eyeposition, vecEyePosition );
+}
+
+int LookupSequence( void *pmodel, const char *label )
+{
+	studiohdr_t *pstudiohdr;
+	
+	pstudiohdr = (studiohdr_t *)pmodel;
+	if (! pstudiohdr)
+		return 0;
+
+	mstudioseqdesc_t	*pseqdesc;
+
+	pseqdesc = (mstudioseqdesc_t *)((byte *)pstudiohdr + pstudiohdr->seqindex);
+
+	for (int i = 0; i < pstudiohdr->numseq; i++)
+	{
+		if (stricmp( pseqdesc[i].label, label ) == 0)
+			return i;
+	}
+
+	return -1;
+}
+
+
+int IsSoundEvent( int eventNumber )
+{
+	if ( eventNumber == SCRIPT_EVENT_SOUND || eventNumber == SCRIPT_EVENT_SOUND_VOICE )
+		return 1;
+	return 0;
+}
+
+
+void SequencePrecache( void *pmodel, const char *pSequenceName )
+{
+	int index = LookupSequence( pmodel, pSequenceName );
+	if ( index >= 0 )
+	{
+		studiohdr_t *pstudiohdr;
+	
+		pstudiohdr = (studiohdr_t *)pmodel;
+		if ( !pstudiohdr || index >= pstudiohdr->numseq )
+			return;
+
+		mstudioseqdesc_t	*pseqdesc;
+		mstudioevent_t		*pevent;
+
+		pseqdesc = (mstudioseqdesc_t *)((byte *)pstudiohdr + pstudiohdr->seqindex) + index;
+		pevent = (mstudioevent_t *)((byte *)pstudiohdr + pseqdesc->eventindex);
+
+		for (int i = 0; i < pseqdesc->numevents; i++)
+		{
+			// Don't send client-side events to the server AI
+			if ( pevent[i].event >= EVENT_CLIENT )
+				continue;
+
+			// UNDONE: Add a callback to check to see if a sound is precached yet and don't allocate a copy
+			// of it's name if it is.
+			if ( IsSoundEvent( pevent[i].event ) )
+			{
+				if ( !strlen(pevent[i].options) )
+				{
+					ALERT( at_error, "Bad sound event %d in sequence %s :: %s (sound is \"%s\")\n", pevent[i].event, pstudiohdr->name, pSequenceName, pevent[i].options );
+				}
+
+				PRECACHE_SOUND( (char *)(gpGlobals->pStringBase + ALLOC_STRING(pevent[i].options) ) );
+			}
+		}
+	}
+}
+
+
+
+void GetSequenceInfo( void *pmodel, entvars_t *pev, float *pflFrameRate, float *pflGroundSpeed )
+{
+	studiohdr_t *pstudiohdr;
+	
+	pstudiohdr = (studiohdr_t *)pmodel;
+	if (! pstudiohdr)
+		return;
+
+	mstudioseqdesc_t	*pseqdesc;
+
+	if (pev->sequence >= pstudiohdr->numseq)
+	{
+		*pflFrameRate = 0.0;
+		*pflGroundSpeed = 0.0;
+		return;
+	}
+
+	pseqdesc = (mstudioseqdesc_t *)((byte *)pstudiohdr + pstudiohdr->seqindex) + (int)pev->sequence;
+
+	if (pseqdesc->numframes > 1)
+	{
+		*pflFrameRate = 256 * pseqdesc->fps / (pseqdesc->numframes - 1);
+		*pflGroundSpeed = sqrt( pseqdesc->linearmovement[0]*pseqdesc->linearmovement[0]+ pseqdesc->linearmovement[1]*pseqdesc->linearmovement[1]+ pseqdesc->linearmovement[2]*pseqdesc->linearmovement[2] );
+		*pflGroundSpeed = *pflGroundSpeed * pseqdesc->fps / (pseqdesc->numframes - 1);
+	}
+	else
+	{
+		*pflFrameRate = 256.0;
+		*pflGroundSpeed = 0.0;
+	}
+}
+
+
+int GetSequenceFlags( void *pmodel, entvars_t *pev )
+{
+	studiohdr_t *pstudiohdr;
+	
+	pstudiohdr = (studiohdr_t *)pmodel;
+	if ( !pstudiohdr || pev->sequence >= pstudiohdr->numseq )
+		return 0;
+
+	mstudioseqdesc_t	*pseqdesc;
+	pseqdesc = (mstudioseqdesc_t *)((byte *)pstudiohdr + pstudiohdr->seqindex) + (int)pev->sequence;
+
+	return pseqdesc->flags;
+}
+
+
+int GetAnimationEvent( void *pmodel, entvars_t *pev, MonsterEvent_t *pMonsterEvent, float flStart, float flEnd, int index )
+{
+	studiohdr_t *pstudiohdr;
+	
+	pstudiohdr = (studiohdr_t *)pmodel;
+	if ( !pstudiohdr || pev->sequence >= pstudiohdr->numseq || !pMonsterEvent )
+		return 0;
+
+	mstudioseqdesc_t	*pseqdesc;
+	mstudioevent_t		*pevent;
+
+	pseqdesc = (mstudioseqdesc_t *)((byte *)pstudiohdr + pstudiohdr->seqindex) + (int)pev->sequence;
+	pevent = (mstudioevent_t *)((byte *)pstudiohdr + pseqdesc->eventindex);
+
+	if (pseqdesc->numevents == 0 || index > pseqdesc->numevents )
+		return 0;
+
+	if (pseqdesc->numframes > 1)
+	{
+		flStart *= (pseqdesc->numframes - 1) / 256.0;
+		flEnd *= (pseqdesc->numframes - 1) / 256.0;
+	}
+	else
+	{
+		flStart = 0;
+		flEnd = 1.0;
+	}
+
+	for (; index < pseqdesc->numevents; index++)
+	{
+		// Don't send client-side events to the server AI
+		if ( pevent[index].event >= EVENT_CLIENT )
+			continue;
+
+		if ( (pevent[index].frame >= flStart && pevent[index].frame < flEnd) || 
+			((pseqdesc->flags & STUDIO_LOOPING) && flEnd >= pseqdesc->numframes - 1 && pevent[index].frame < flEnd - pseqdesc->numframes + 1) )
+		{
+			pMonsterEvent->event = pevent[index].event;
+			pMonsterEvent->options = pevent[index].options;
+			return index + 1;
+		}
+	}
+	return 0;
+}
+
+float SetController( void *pmodel, entvars_t *pev, int iController, float flValue )
+{
+	studiohdr_t *pstudiohdr;
+	
+	pstudiohdr = (studiohdr_t *)pmodel;
+	if (! pstudiohdr)
+		return flValue;
+
+	mstudiobonecontroller_t	*pbonecontroller = (mstudiobonecontroller_t *)((byte *)pstudiohdr + pstudiohdr->bonecontrollerindex);
+
+	int i = 0;
+	// find first controller that matches the index
+	for (i = 0; i < pstudiohdr->numbonecontrollers; i++, pbonecontroller++)
+	{
+		if (pbonecontroller->index == iController)
+			break;
+	}
+	if (i >= pstudiohdr->numbonecontrollers)
+		return flValue;
+
+	// wrap 0..360 if it's a rotational controller
+
+	if (pbonecontroller->type & (STUDIO_XR | STUDIO_YR | STUDIO_ZR))
+	{
+		// ugly hack, invert value if end < start
+		if (pbonecontroller->end < pbonecontroller->start)
+			flValue = -flValue;
+
+		// does the controller not wrap?
+		if (pbonecontroller->start + 359.0 >= pbonecontroller->end)
+		{
+			if (flValue > ((pbonecontroller->start + pbonecontroller->end) / 2.0) + 180)
+				flValue = flValue - 360;
+			if (flValue < ((pbonecontroller->start + pbonecontroller->end) / 2.0) - 180)
+				flValue = flValue + 360;
+		}
+		else
+		{
+			if (flValue > 360)
+				flValue = flValue - (int)(flValue / 360.0) * 360.0;
+			else if (flValue < 0)
+				flValue = flValue + (int)((flValue / -360.0) + 1) * 360.0;
+		}
+	}
+
+	int setting = static_cast<int>(255 * (flValue - pbonecontroller->start) / (pbonecontroller->end - pbonecontroller->start));
+
+	if (setting < 0) setting = 0;
+	if (setting > 255) setting = 255;
+	pev->controller[iController] = setting;
+
+	return setting * (1.0 / 255.0) * (pbonecontroller->end - pbonecontroller->start) + pbonecontroller->start;
+}
+
+
+float SetBlending( void *pmodel, entvars_t *pev, int iBlender, float flValue )
+{
+	studiohdr_t *pstudiohdr;
+	
+	pstudiohdr = (studiohdr_t *)pmodel;
+	if (! pstudiohdr)
+		return flValue;
+
+	mstudioseqdesc_t	*pseqdesc;
+
+	pseqdesc = (mstudioseqdesc_t *)((byte *)pstudiohdr + pstudiohdr->seqindex) + (int)pev->sequence;
+
+	if (pseqdesc->blendtype[iBlender] == 0)
+		return flValue;
+
+	if (pseqdesc->blendtype[iBlender] & (STUDIO_XR | STUDIO_YR | STUDIO_ZR))
+	{
+		// ugly hack, invert value if end < start
+		if (pseqdesc->blendend[iBlender] < pseqdesc->blendstart[iBlender])
+			flValue = -flValue;
+
+		// does the controller not wrap?
+		if (pseqdesc->blendstart[iBlender] + 359.0 >= pseqdesc->blendend[iBlender])
+		{
+			if (flValue > ((pseqdesc->blendstart[iBlender] + pseqdesc->blendend[iBlender]) / 2.0) + 180)
+				flValue = flValue - 360;
+			if (flValue < ((pseqdesc->blendstart[iBlender] + pseqdesc->blendend[iBlender]) / 2.0) - 180)
+				flValue = flValue + 360;
+		}
+	}
+
+	int setting = static_cast<int>(255 * (flValue - pseqdesc->blendstart[iBlender]) / (pseqdesc->blendend[iBlender] - pseqdesc->blendstart[iBlender]));
+
+	if (setting < 0) setting = 0;
+	if (setting > 255) setting = 255;
+
+	pev->blending[iBlender] = setting;
+
+	return setting * (1.0 / 255.0) * (pseqdesc->blendend[iBlender] - pseqdesc->blendstart[iBlender]) + pseqdesc->blendstart[iBlender];
+}
+
+
+
+
+int FindTransition( void *pmodel, int iEndingAnim, int iGoalAnim, int *piDir )
+{
+	studiohdr_t *pstudiohdr;
+	
+	pstudiohdr = (studiohdr_t *)pmodel;
+	if (! pstudiohdr)
+		return iGoalAnim;
+
+	mstudioseqdesc_t	*pseqdesc;
+	pseqdesc = (mstudioseqdesc_t *)((byte *)pstudiohdr + pstudiohdr->seqindex);
+
+	// bail if we're going to or from a node 0
+	if (pseqdesc[iEndingAnim].entrynode == 0 || pseqdesc[iGoalAnim].entrynode == 0)
+	{
+		return iGoalAnim;
+	}
+
+	int	iEndNode;
+
+	// ALERT( at_console, "from %d to %d: ", pEndNode->iEndNode, pGoalNode->iStartNode );
+
+	if (*piDir > 0)
+	{
+		iEndNode = pseqdesc[iEndingAnim].exitnode;
+	}
+	else
+	{
+		iEndNode = pseqdesc[iEndingAnim].entrynode;
+	}
+
+	if (iEndNode == pseqdesc[iGoalAnim].entrynode)
+	{
+		*piDir = 1;
+		return iGoalAnim;
+	}
+
+	byte *pTransition = ((byte *)pstudiohdr + pstudiohdr->transitionindex);
+
+	int iInternNode = pTransition[(iEndNode-1)*pstudiohdr->numtransitions + (pseqdesc[iGoalAnim].entrynode-1)];
+
+	if (iInternNode == 0)
+		return iGoalAnim;
+
+	int i;
+
+	// look for someone going
+	for (i = 0; i < pstudiohdr->numseq; i++)
+	{
+		if (pseqdesc[i].entrynode == iEndNode && pseqdesc[i].exitnode == iInternNode)
+		{
+			*piDir = 1;
+			return i;
+		}
+		if (pseqdesc[i].nodeflags)
+		{
+			if (pseqdesc[i].exitnode == iEndNode && pseqdesc[i].entrynode == iInternNode)
+			{
+				*piDir = -1;
+				return i;
+			}
+		}
+	}
+
+	ALERT( at_console, "error in transition graph" );
+	return iGoalAnim;
+}
+
+void SetBodygroup( void *pmodel, entvars_t *pev, int iGroup, int iValue )
+{
+	studiohdr_t *pstudiohdr;
+	
+	pstudiohdr = (studiohdr_t *)pmodel;
+	if (! pstudiohdr)
+		return;
+
+	if (iGroup > pstudiohdr->numbodyparts)
+		return;
+
+	mstudiobodyparts_t *pbodypart = (mstudiobodyparts_t *)((byte *)pstudiohdr + pstudiohdr->bodypartindex) + iGroup;
+
+	if (iValue >= pbodypart->nummodels)
+		return;
+
+	int iCurrent = (pev->body / pbodypart->base) % pbodypart->nummodels;
+
+	pev->body = (pev->body - (iCurrent * pbodypart->base) + (iValue * pbodypart->base));
+}
+
+
+int GetBodygroup( void *pmodel, entvars_t *pev, int iGroup )
+{
+	studiohdr_t *pstudiohdr;
+	
+	pstudiohdr = (studiohdr_t *)pmodel;
+	if (! pstudiohdr)
+		return 0;
+
+	if (iGroup > pstudiohdr->numbodyparts)
+		return 0;
+
+	mstudiobodyparts_t *pbodypart = (mstudiobodyparts_t *)((byte *)pstudiohdr + pstudiohdr->bodypartindex) + iGroup;
+
+	if (pbodypart->nummodels <= 1)
+		return 0;
+
+	int iCurrent = (pev->body / pbodypart->base) % pbodypart->nummodels;
+
+	return iCurrent;
+}

hlsdk/ricochet/dlls/animation.h

@@ -0,0 +1,47 @@
+/***
+*
+*	Copyright (c) 1999, 2000 Valve LLC. All rights reserved.
+*	
+*	This product contains software technology licensed from Id 
+*	Software, Inc. ("Id Technology").  Id Technology (c) 1996 Id Software, Inc. 
+*	All Rights Reserved.
+*
+*   Use, distribution, and modification of this source code and/or resulting
+*   object code is restricted to non-commercial enhancements to products from
+*   Valve LLC.  All other use, distribution, or modification is prohibited
+*   without written permission from Valve LLC.
+*
+****/
+#ifndef ANIMATION_H
+#define ANIMATION_H
+
+#define ACTIVITY_NOT_AVAILABLE		-1
+
+#ifndef MONSTEREVENT_H
+#include "monsterevent.h"
+#endif
+
+extern int IsSoundEvent( int eventNumber );
+
+int LookupActivity( void *pmodel, entvars_t *pev, int activity );
+int LookupActivityHeaviest( void *pmodel, entvars_t *pev, int activity );
+int LookupSequence( void *pmodel, const char *label );
+void GetSequenceInfo( void *pmodel, entvars_t *pev, float *pflFrameRate, float *pflGroundSpeed );
+int GetSequenceFlags( void *pmodel, entvars_t *pev );
+int LookupAnimationEvents( void *pmodel, entvars_t *pev, float flStart, float flEnd );
+float SetController( void *pmodel, entvars_t *pev, int iController, float flValue );
+float SetBlending( void *pmodel, entvars_t *pev, int iBlender, float flValue );
+void GetEyePosition( void *pmodel, float *vecEyePosition );
+void SequencePrecache( void *pmodel, const char *pSequenceName );
+int FindTransition( void *pmodel, int iEndingAnim, int iGoalAnim, int *piDir );
+void SetBodygroup( void *pmodel, entvars_t *pev, int iGroup, int iValue );
+int GetBodygroup( void *pmodel, entvars_t *pev, int iGroup );
+
+int GetAnimationEvent( void *pmodel, entvars_t *pev, MonsterEvent_t *pMonsterEvent, float flStart, float flEnd, int index );
+int ExtractBbox( void *pmodel, int sequence, float *mins, float *maxs );
+
+// From /engine/studio.h
+#define STUDIO_LOOPING		0x0001
+
+
+#endif	//ANIMATION_H

hlsdk/ricochet/dlls/basemonster.h

@@ -0,0 +1,94 @@
+/***
+*
+*	Copyright (c) 1999, 2000 Valve LLC. All rights reserved.
+*	
+*	This product contains software technology licensed from Id 
+*	Software, Inc. ("Id Technology").  Id Technology (c) 1996 Id Software, Inc. 
+*	All Rights Reserved.
+*
+*   Use, distribution, and modification of this source code and/or resulting
+*   object code is restricted to non-commercial enhancements to products from
+*   Valve LLC.  All other use, distribution, or modification is prohibited
+*   without written permission from Valve LLC.
+*
+****/
+#ifndef BASEMONSTER_H
+#define BASEMONSTER_H
+
+class CBaseMonster : public CBaseToggle
+{
+public:
+	Activity			m_Activity;// what the monster is doing (animation)
+	Activity			m_IdealActivity;// monster should switch to this activity
+	int					m_LastHitGroup; // the last body region that took damage
+	int					m_bitsDamageType;	// what types of damage has monster (player) taken
+	BYTE				m_rgbTimeBasedDamage[CDMG_TIMEBASED];
+	MONSTERSTATE		m_MonsterState;// monster's current state
+	MONSTERSTATE		m_IdealMonsterState;// monster should change to this state
+	int					m_afConditions;
+	int					m_afMemory;
+	float				m_flNextAttack;		// cannot attack again until this time
+	EHANDLE				m_hEnemy;		 // the entity that the monster is fighting.
+	EHANDLE				m_hTargetEnt;	 // the entity that the monster is trying to reach
+	float				m_flFieldOfView;// width of monster's field of view ( dot product )
+	int					m_bloodColor;		// color of blood particless
+	Vector				m_HackedGunPos;	// HACK until we can query end of gun
+	Vector				m_vecEnemyLKP;// last known position of enemy. (enemy's origin)
+
+
+	void KeyValue( KeyValueData *pkvd );
+
+	void MakeIdealYaw( Vector vecTarget );
+	virtual float ChangeYaw ( int speed );
+	virtual BOOL HasHumanGibs( void );
+	virtual BOOL HasAlienGibs( void );
+	virtual void FadeMonster( void );	// Called instead of GibMonster() when gibs are disabled
+	virtual void GibMonster( void );
+	virtual Activity GetDeathActivity ( void );
+	Activity GetSmallFlinchActivity( void );
+	virtual void BecomeDead( void );
+	BOOL		 ShouldGibMonster( int iGib );
+	void		 CallGibMonster( void );
+	virtual BOOL	ShouldFadeOnDeath( void );
+	BOOL FCheckAITrigger( void );// checks and, if necessary, fires the monster's trigger target. 
+	virtual int IRelationship ( CBaseEntity *pTarget );
+	virtual int TakeHealth( float flHealth, int bitsDamageType );
+	virtual int TakeDamage( entvars_t* pevInflictor, entvars_t* pevAttacker, float flDamage, int bitsDamageType);
+	int			DeadTakeDamage( entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int bitsDamageType );
+	float DamageForce( float damage );
+	virtual void Killed( entvars_t *pevAttacker, int iGib );
+	virtual void PainSound ( void ) { return; };
+
+	void RadiusDamage(entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int iClassIgnore, int bitsDamageType );
+	void RadiusDamage(Vector vecSrc, entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int iClassIgnore, int bitsDamageType );
+
+	inline void	SetConditions( int iConditions ) { m_afConditions |= iConditions; }
+	inline void	ClearConditions( int iConditions ) { m_afConditions &= ~iConditions; }
+	inline BOOL HasConditions( int iConditions ) { if ( m_afConditions & iConditions ) return TRUE; return FALSE; }
+	inline BOOL HasAllConditions( int iConditions ) { if ( (m_afConditions & iConditions) == iConditions ) return TRUE; return FALSE; }
+
+	inline void	Remember( int iMemory ) { m_afMemory |= iMemory; }
+	inline void	Forget( int iMemory ) { m_afMemory &= ~iMemory; }
+	inline BOOL HasMemory( int iMemory ) { if ( m_afMemory & iMemory ) return TRUE; return FALSE; }
+	inline BOOL HasAllMemories( int iMemory ) { if ( (m_afMemory & iMemory) == iMemory ) return TRUE; return FALSE; }
+
+	// This will stop animation until you call ResetSequenceInfo() at some point in the future
+	inline void StopAnimation( void ) { pev->framerate = 0; }
+
+	virtual void ReportAIState( void );
+	virtual void MonsterInitDead( void );	// Call after animation/pose is set up
+	void EXPORT CorpseFallThink( void );
+
+	virtual void Look ( int iDistance );// basic sight function for monsters
+	virtual CBaseEntity* BestVisibleEnemy ( void );// finds best visible enemy for attack
+	CBaseEntity *CheckTraceHullAttack( float flDist, int iDamage, int iDmgType );
+	virtual BOOL FInViewCone ( CBaseEntity *pEntity );// see if pEntity is in monster's view cone
+	virtual BOOL FInViewCone ( Vector *pOrigin );// see if given location is in monster's view cone
+	void TraceAttack( entvars_t *pevAttacker, float flDamage, Vector vecDir, TraceResult *ptr, int bitsDamageType);
+	void MakeDamageBloodDecal ( int cCount, float flNoise, TraceResult *ptr, const Vector &vecDir );
+	virtual BOOL	IsAlive( void ) { return (pev->deadflag != DEAD_DEAD); }
+
+};
+
+
+#endif

hlsdk/ricochet/dlls/bmodels.cpp

@@ -0,0 +1,958 @@
+/***
+*
+*	Copyright (c) 1996-2002, Valve LLC. All rights reserved.
+*	
+*	This product contains software technology licensed from Id 
+*	Software, Inc. ("Id Technology").  Id Technology (c) 1996 Id Software, Inc. 
+*	All Rights Reserved.
+*
+*   Use, distribution, and modification of this source code and/or resulting
+*   object code is restricted to non-commercial enhancements to products from
+*   Valve LLC.  All other use, distribution, or modification is prohibited
+*   without written permission from Valve LLC.
+*
+****/
+/*
+
+===== bmodels.cpp ========================================================
+
+  spawn, think, and use functions for entities that use brush models
+
+*/
+
+#include "extdll.h"
+#include "util.h"
+#include "cbase.h"
+#include "doors.h"
+
+extern DLL_GLOBAL Vector		g_vecAttackDir;
+
+#define		SF_BRUSH_ACCDCC	16// brush should accelerate and decelerate when toggled
+#define		SF_BRUSH_HURT		32// rotating brush that inflicts pain based on rotation speed
+#define		SF_ROTATING_NOT_SOLID	64	// some special rotating objects are not solid.
+
+// covering cheesy noise1, noise2, & noise3 fields so they make more sense (for rotating fans)
+#define		noiseStart		noise1
+#define		noiseStop		noise2
+#define		noiseRunning	noise3
+
+#define		SF_PENDULUM_SWING		2	// spawnflag that makes a pendulum a rope swing.
+//
+// BModelOrigin - calculates origin of a bmodel from absmin/size because all bmodel origins are 0 0 0
+//
+Vector VecBModelOrigin( entvars_t* pevBModel )
+{
+	return pevBModel->absmin + ( pevBModel->size * 0.5 );
+}
+
+// =================== FUNC_WALL ==============================================
+
+/*QUAKED func_wall (0 .5 .8) ?
+This is just a solid wall if not inhibited
+*/
+class CFuncWall : public CBaseEntity
+{
+public:
+	void	Spawn( void );
+	void	Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value );
+
+	// Bmodels don't go across transitions
+	virtual int	ObjectCaps( void ) { return CBaseEntity :: ObjectCaps() & ~FCAP_ACROSS_TRANSITION; }
+};
+
+LINK_ENTITY_TO_CLASS( func_wall, CFuncWall );
+
+void CFuncWall :: Spawn( void )
+{
+	pev->angles		= g_vecZero;
+	pev->movetype	= MOVETYPE_PUSH;  // so it doesn't get pushed by anything
+	pev->solid		= SOLID_BSP;
+	SET_MODEL( ENT(pev), STRING(pev->model) );
+	
+	// If it can't move/go away, it's really part of the world
+	pev->flags |= FL_WORLDBRUSH;
+}
+
+
+void CFuncWall :: Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value )
+{
+	if ( ShouldToggle( useType, (int)(pev->frame)) )
+		pev->frame = 1 - pev->frame;
+}
+
+
+#define SF_WALL_START_OFF		0x0001
+
+class CFuncWallToggle : public CFuncWall
+{
+public:
+	void	Spawn( void );
+	void	Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value );
+	void	TurnOff( void );
+	void	TurnOn( void );
+	BOOL	IsOn( void );
+};
+
+LINK_ENTITY_TO_CLASS( func_wall_toggle, CFuncWallToggle );
+
+void CFuncWallToggle :: Spawn( void )
+{
+	CFuncWall::Spawn();
+	if ( pev->spawnflags & SF_WALL_START_OFF )
+		TurnOff();
+}
+
+
+void CFuncWallToggle :: TurnOff( void )
+{
+	pev->solid = SOLID_NOT;
+	pev->effects |= EF_NODRAW;
+	UTIL_SetOrigin( pev, pev->origin );
+}
+
+
+void CFuncWallToggle :: TurnOn( void )
+{
+	pev->solid = SOLID_BSP;
+	pev->effects &= ~EF_NODRAW;
+	UTIL_SetOrigin( pev, pev->origin );
+}
+
+
+BOOL CFuncWallToggle :: IsOn( void )
+{
+	if ( pev->solid == SOLID_NOT )
+		return FALSE;
+	return TRUE;
+}
+
+
+void CFuncWallToggle :: Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value )
+{
+	int status = IsOn();
+
+	if ( ShouldToggle( useType, status ) )
+	{
+		if ( status )
+			TurnOff();
+		else
+			TurnOn();
+	}
+}
+
+
+#define SF_CONVEYOR_VISUAL		0x0001
+#define SF_CONVEYOR_NOTSOLID	0x0002
+
+class CFuncConveyor : public CFuncWall
+{
+public:
+	void	Spawn( void );
+	void	Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value );
+	void	UpdateSpeed( float speed );
+};
+
+LINK_ENTITY_TO_CLASS( func_conveyor, CFuncConveyor );
+void CFuncConveyor :: Spawn( void )
+{
+	SetMovedir( pev );
+	CFuncWall::Spawn();
+
+	if ( !(pev->spawnflags & SF_CONVEYOR_VISUAL) )
+		SetBits( pev->flags, FL_CONVEYOR );
+
+	// HACKHACK - This is to allow for some special effects
+	if ( pev->spawnflags & SF_CONVEYOR_NOTSOLID )
+	{
+		pev->solid = SOLID_NOT;
+		pev->skin = 0;		// Don't want the engine thinking we've got special contents on this brush
+	}
+
+	if ( pev->speed == 0 )
+		pev->speed = 100;
+
+	UpdateSpeed( pev->speed );
+}
+
+
+// HACKHACK -- This is ugly, but encode the speed in the rendercolor to avoid adding more data to the network stream
+void CFuncConveyor :: UpdateSpeed( float speed )
+{
+	// Encode it as an integer with 4 fractional bits
+	int speedCode = (int)(fabs(speed) * 16.0);
+
+	if ( speed < 0 )
+		pev->rendercolor.x = 1;
+	else
+		pev->rendercolor.x = 0;
+
+	pev->rendercolor.y = (speedCode >> 8);
+	pev->rendercolor.z = (speedCode & 0xFF);
+}
+
+
+void CFuncConveyor :: Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value )
+{
+    pev->speed = -pev->speed;
+	UpdateSpeed( pev->speed );
+}
+
+
+
+// =================== FUNC_ILLUSIONARY ==============================================
+
+
+/*QUAKED func_illusionary (0 .5 .8) ?
+A simple entity that looks solid but lets you walk through it.
+*/
+class CFuncIllusionary : public CBaseToggle 
+{
+public:
+	void Spawn( void );
+	void EXPORT SloshTouch( CBaseEntity *pOther );
+	void KeyValue( KeyValueData *pkvd );
+	virtual int	ObjectCaps( void ) { return CBaseEntity :: ObjectCaps() & ~FCAP_ACROSS_TRANSITION; }
+};
+
+LINK_ENTITY_TO_CLASS( func_illusionary, CFuncIllusionary );
+
+void CFuncIllusionary :: KeyValue( KeyValueData *pkvd )
+{
+	if (FStrEq(pkvd->szKeyName, "skin"))//skin is used for content type
+	{
+		pev->skin = atoi(pkvd->szValue);
+		pkvd->fHandled = TRUE;
+	}
+	else
+		CBaseToggle::KeyValue( pkvd );
+}
+
+void CFuncIllusionary :: Spawn( void )
+{
+	pev->angles = g_vecZero;
+	pev->movetype = MOVETYPE_NONE;  
+	pev->solid = SOLID_NOT;// always solid_not 
+	SET_MODEL( ENT(pev), STRING(pev->model) );
+	
+	// I'd rather eat the network bandwidth of this than figure out how to save/restore
+	// these entities after they have been moved to the client, or respawn them ala Quake
+	// Perhaps we can do this in deathmatch only.
+	//	MAKE_STATIC(ENT(pev));
+}
+
+
+// -------------------------------------------------------------------------------
+//
+// Monster only clip brush
+// 
+// This brush will be solid for any entity who has the FL_MONSTERCLIP flag set
+// in pev->flags
+//
+// otherwise it will be invisible and not solid.  This can be used to keep 
+// specific monsters out of certain areas
+//
+// -------------------------------------------------------------------------------
+class CFuncMonsterClip : public CFuncWall
+{
+public:
+	void	Spawn( void );
+	void	Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value ) {}		// Clear out func_wall's use function
+};
+
+LINK_ENTITY_TO_CLASS( func_monsterclip, CFuncMonsterClip );
+
+void CFuncMonsterClip::Spawn( void )
+{
+	CFuncWall::Spawn();
+	if ( CVAR_GET_FLOAT("showtriggers") == 0 )
+		pev->effects = EF_NODRAW;
+	pev->flags |= FL_MONSTERCLIP;
+}
+
+
+// =================== FUNC_ROTATING ==============================================
+class CFuncRotating : public CBaseEntity
+{
+public:
+	// basic functions
+	void Spawn( void  );
+	void Precache( void  );
+	void EXPORT SpinUp ( void );
+	void EXPORT SpinDown ( void );
+	void KeyValue( KeyValueData* pkvd);
+	void EXPORT HurtTouch ( CBaseEntity *pOther );
+	void EXPORT RotatingUse( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value );
+	void EXPORT Rotate( void );
+	void RampPitchVol (int fUp );
+	void Blocked( CBaseEntity *pOther );
+	virtual int	ObjectCaps( void ) { return CBaseEntity :: ObjectCaps() & ~FCAP_ACROSS_TRANSITION; }
+	virtual int		Save( CSave &save );
+	virtual int		Restore( CRestore &restore );
+	
+	static	TYPEDESCRIPTION m_SaveData[];
+
+	float m_flFanFriction;
+	float m_flAttenuation;
+	float m_flVolume;
+	float m_pitch;
+	int	  m_sounds;
+};
+
+TYPEDESCRIPTION	CFuncRotating::m_SaveData[] = 
+{
+	DEFINE_FIELD( CFuncRotating, m_flFanFriction, FIELD_FLOAT ),
+	DEFINE_FIELD( CFuncRotating, m_flAttenuation, FIELD_FLOAT ),
+	DEFINE_FIELD( CFuncRotating, m_flVolume, FIELD_FLOAT ),
+	DEFINE_FIELD( CFuncRotating, m_pitch, FIELD_FLOAT ),
+	DEFINE_FIELD( CFuncRotating, m_sounds, FIELD_INTEGER )
+};
+
+IMPLEMENT_SAVERESTORE( CFuncRotating, CBaseEntity );
+
+
+LINK_ENTITY_TO_CLASS( func_rotating, CFuncRotating );
+
+void CFuncRotating :: KeyValue( KeyValueData* pkvd)
+{
+	if (FStrEq(pkvd->szKeyName, "fanfriction"))
+	{
+		m_flFanFriction = atof(pkvd->szValue)/100;
+		pkvd->fHandled = TRUE;
+	}
+	else if (FStrEq(pkvd->szKeyName, "Volume"))
+	{
+		m_flVolume = atof(pkvd->szValue)/10.0;
+
+		if (m_flVolume > 1.0)
+			m_flVolume = 1.0;
+		if (m_flVolume < 0.0)
+			m_flVolume = 0.0;
+		pkvd->fHandled = TRUE;
+	}
+	else if (FStrEq(pkvd->szKeyName, "spawnorigin"))
+	{
+		Vector tmp;
+		UTIL_StringToVector( (float *)tmp, pkvd->szValue );
+		if ( tmp != g_vecZero )
+			pev->origin = tmp;
+	}
+	else if (FStrEq(pkvd->szKeyName, "sounds"))
+	{
+		m_sounds = atoi(pkvd->szValue);
+		pkvd->fHandled = TRUE;
+	}
+	else 
+		CBaseEntity::KeyValue( pkvd );
+}
+
+/*QUAKED func_rotating (0 .5 .8) ? START_ON REVERSE X_AXIS Y_AXIS
+You need to have an origin brush as part of this entity.  The  
+center of that brush will be
+the point around which it is rotated. It will rotate around the Z  
+axis by default.  You can
+check either the X_AXIS or Y_AXIS box to change that.
+
+"speed" determines how fast it moves; default value is 100.
+"dmg"	damage to inflict when blocked (2 default)
+
+REVERSE will cause the it to rotate in the opposite direction.
+*/
+
+
+void CFuncRotating :: Spawn( )
+{
+	// set final pitch.  Must not be PITCH_NORM, since we
+	// plan on pitch shifting later.
+
+	m_pitch = PITCH_NORM - 1;
+
+	// maintain compatibility with previous maps
+	if (m_flVolume == 0.0)
+		m_flVolume = 1.0;
+
+	// if the designer didn't set a sound attenuation, default to one.
+	m_flAttenuation = ATTN_NORM;
+	
+	if ( FBitSet ( pev->spawnflags, SF_BRUSH_ROTATE_SMALLRADIUS) )
+	{
+		m_flAttenuation = ATTN_IDLE;
+	}
+	else if ( FBitSet ( pev->spawnflags, SF_BRUSH_ROTATE_MEDIUMRADIUS) )
+	{
+		m_flAttenuation = ATTN_STATIC;
+	}
+	else if ( FBitSet ( pev->spawnflags, SF_BRUSH_ROTATE_LARGERADIUS) )
+	{
+		m_flAttenuation = ATTN_NORM;
+	}
+
+	// prevent divide by zero if level designer forgets friction!
+	if ( m_flFanFriction == 0 )
+	{
+		m_flFanFriction = 1;
+	}
+	
+	if ( FBitSet(pev->spawnflags, SF_BRUSH_ROTATE_Z_AXIS) )
+		pev->movedir = Vector(0,0,1);
+	else if ( FBitSet(pev->spawnflags, SF_BRUSH_ROTATE_X_AXIS) )
+		pev->movedir = Vector(1,0,0);
+	else 
+		pev->movedir = Vector(0,1,0);	// y-axis
+
+	// check for reverse rotation
+	if ( FBitSet(pev->spawnflags, SF_BRUSH_ROTATE_BACKWARDS) )
+		pev->movedir = pev->movedir * -1;
+
+	// some rotating objects like fake volumetric lights will not be solid.
+	if ( FBitSet(pev->spawnflags, SF_ROTATING_NOT_SOLID) )
+	{
+		pev->solid = SOLID_NOT;
+		pev->skin = CONTENTS_EMPTY;
+		pev->movetype	= MOVETYPE_PUSH;
+	}
+	else
+	{
+		pev->solid		= SOLID_BSP;
+		pev->movetype	= MOVETYPE_PUSH;
+	}
+
+	UTIL_SetOrigin(pev, pev->origin);
+	SET_MODEL( ENT(pev), STRING(pev->model) );
+
+	SetUse( &CFuncRotating::RotatingUse );
+	// did level designer forget to assign speed?
+	if (pev->speed <= 0)
+		pev->speed = 0;
+
+	// Removed this per level designers request.  -- JAY
+	//	if (pev->dmg == 0)
+	//		pev->dmg = 2;
+
+	// instant-use brush?
+	if ( FBitSet( pev->spawnflags, SF_BRUSH_ROTATE_INSTANT) )
+	{		
+		SetThink( &CBaseEntity::SUB_CallUseToggle );
+		pev->nextthink = pev->ltime + 1.5;	// leave a magic delay for client to start up
+	}	
+	// can this brush inflict pain?
+	if ( FBitSet (pev->spawnflags, SF_BRUSH_HURT) )
+	{
+		SetTouch( &CFuncRotating::HurtTouch );
+	}
+	
+	Precache( );
+}
+
+
+void CFuncRotating :: Precache( void )
+{
+	char* szSoundFile = (char*) STRING(pev->message);
+
+	// set up fan sounds
+
+	if (!FStringNull( pev->message ) && strlen( szSoundFile ) > 0)
+	{
+		// if a path is set for a wave, use it
+
+		PRECACHE_SOUND(szSoundFile);
+			
+		pev->noiseRunning = ALLOC_STRING(szSoundFile);
+	} else
+	{
+		// otherwise use preset sound
+		switch (m_sounds)
+		{
+		case 1:
+			PRECACHE_SOUND ("fans/fan1.wav");
+			pev->noiseRunning = ALLOC_STRING("fans/fan1.wav");
+			break;
+		case 2:
+			PRECACHE_SOUND ("fans/fan2.wav");
+			pev->noiseRunning = ALLOC_STRING("fans/fan2.wav");
+			break;
+		case 3:
+			PRECACHE_SOUND ("fans/fan3.wav");
+			pev->noiseRunning = ALLOC_STRING("fans/fan3.wav");
+			break;
+		case 4:
+			PRECACHE_SOUND ("fans/fan4.wav");
+			pev->noiseRunning = ALLOC_STRING("fans/fan4.wav");
+			break;
+		case 5:
+			PRECACHE_SOUND ("fans/fan5.wav");
+			pev->noiseRunning = ALLOC_STRING("fans/fan5.wav");
+			break;
+
+		case 0:
+		default:
+			if (!FStringNull( pev->message ) && strlen( szSoundFile ) > 0)
+			{
+				PRECACHE_SOUND(szSoundFile);
+				
+				pev->noiseRunning = ALLOC_STRING(szSoundFile);
+				break;
+			} else
+			{
+				pev->noiseRunning = ALLOC_STRING("common/null.wav");
+				break;
+			}
+		}
+	}
+	
+	if (pev->avelocity != g_vecZero )
+	{
+		// if fan was spinning, and we went through transition or save/restore,
+		// make sure we restart the sound.  1.5 sec delay is magic number. KDB
+
+		SetThink ( &CFuncRotating::SpinUp );
+		pev->nextthink = pev->ltime + 1.5;
+	}
+}
+
+
+
+//
+// Touch - will hurt others based on how fast the brush is spinning
+//
+void CFuncRotating :: HurtTouch ( CBaseEntity *pOther )
+{
+	entvars_t	*pevOther = pOther->pev;
+
+	// we can't hurt this thing, so we're not concerned with it
+	if ( !pevOther->takedamage )
+		return;
+
+	// calculate damage based on rotation speed
+	pev->dmg = pev->avelocity.Length() / 10;
+
+	pOther->TakeDamage( pev, pev, pev->dmg, DMG_CRUSH);
+	
+	pevOther->velocity = (pevOther->origin - VecBModelOrigin(pev) ).Normalize() * pev->dmg;
+}
+
+//
+// RampPitchVol - ramp pitch and volume up to final values, based on difference
+// between how fast we're going vs how fast we plan to go
+//
+#define FANPITCHMIN		30
+#define FANPITCHMAX		100
+
+void CFuncRotating :: RampPitchVol (int fUp)
+{
+
+	Vector vecAVel = pev->avelocity;
+	vec_t vecCur;
+	vec_t vecFinal;
+	float fpct;
+	float fvol;
+	float fpitch;
+	int pitch;
+	
+	// get current angular velocity
+
+	vecCur = abs(vecAVel.x != 0 ? static_cast<int>(vecAVel.x) : static_cast<int>(vecAVel.y != 0 ? vecAVel.y : vecAVel.z));
+	
+	// get target angular velocity
+
+	vecFinal = (pev->movedir.x != 0 ? pev->movedir.x : (pev->movedir.y != 0 ? pev->movedir.y : pev->movedir.z));
+	vecFinal *= pev->speed;
+	vecFinal = abs(static_cast<int>(vecFinal));
+
+	// calc volume and pitch as % of final vol and pitch
+
+	fpct = vecCur / vecFinal;
+//	if (fUp)
+//		fvol = m_flVolume * (0.5 + fpct/2.0); // spinup volume ramps up from 50% max vol
+//	else
+		fvol = m_flVolume * fpct;			  // slowdown volume ramps down to 0
+
+	fpitch = FANPITCHMIN + (FANPITCHMAX - FANPITCHMIN) * fpct;	
+	
+	pitch = (int) fpitch;
+	if (pitch == PITCH_NORM)
+		pitch = PITCH_NORM-1;
+
+	// change the fan's vol and pitch
+
+	EMIT_SOUND_DYN(ENT(pev), CHAN_STATIC, (char *)STRING(pev->noiseRunning), 
+		fvol, m_flAttenuation, SND_CHANGE_PITCH | SND_CHANGE_VOL, pitch);
+
+}
+
+//
+// SpinUp - accelerates a non-moving func_rotating up to it's speed
+//
+void CFuncRotating :: SpinUp( void )
+{
+	Vector	vecAVel;//rotational velocity
+
+	pev->nextthink = pev->ltime + 0.1;
+	pev->avelocity = pev->avelocity + ( pev->movedir * ( pev->speed * m_flFanFriction ) );
+
+	vecAVel = pev->avelocity;// cache entity's rotational velocity
+
+	// if we've met or exceeded target speed, set target speed and stop thinking
+	if (	abs(static_cast<int>(vecAVel.x)) >= abs(static_cast<int>(pev->movedir.x * pev->speed))	&&
+			abs(static_cast<int>(vecAVel.y)) >= abs(static_cast<int>(pev->movedir.y * pev->speed))	&&
+			abs(static_cast<int>(vecAVel.z)) >= abs(static_cast<int>(pev->movedir.z * pev->speed)) )
+	{
+		pev->avelocity = pev->movedir * pev->speed;// set speed in case we overshot
+		EMIT_SOUND_DYN(ENT(pev), CHAN_STATIC, (char *)STRING(pev->noiseRunning), 
+			m_flVolume, m_flAttenuation, SND_CHANGE_PITCH | SND_CHANGE_VOL, FANPITCHMAX);
+		
+		SetThink( &CFuncRotating::Rotate );
+		Rotate();
+	} 
+	else
+	{
+		RampPitchVol(TRUE);
+	}
+}
+
+//
+// SpinDown - decelerates a moving func_rotating to a standstill.
+//
+void CFuncRotating :: SpinDown( void )
+{
+	Vector	vecAVel;//rotational velocity
+	vec_t vecdir;
+
+	pev->nextthink = pev->ltime + 0.1;
+
+	pev->avelocity = pev->avelocity - ( pev->movedir * ( pev->speed * m_flFanFriction ) );//spin down slower than spinup
+
+	vecAVel = pev->avelocity;// cache entity's rotational velocity
+
+	if (pev->movedir.x != 0)
+		vecdir = pev->movedir.x;
+	else if (pev->movedir.y != 0)
+		vecdir = pev->movedir.y;
+	else
+		vecdir = pev->movedir.z;
+
+	// if we've met or exceeded target speed, set target speed and stop thinking
+	// (note: must check for movedir > 0 or < 0)
+	if (((vecdir > 0) && (vecAVel.x <= 0 && vecAVel.y <= 0 && vecAVel.z <= 0)) || 
+		((vecdir < 0) && (vecAVel.x >= 0 && vecAVel.y >= 0 && vecAVel.z >= 0)))
+	{
+		pev->avelocity = g_vecZero;// set speed in case we overshot
+		
+		// stop sound, we're done
+		EMIT_SOUND_DYN(ENT(pev), CHAN_STATIC, (char *)STRING(pev->noiseRunning /* Stop */), 
+				0, 0, SND_STOP, static_cast<int>(m_pitch));
+
+		SetThink( &CFuncRotating::Rotate );
+		Rotate();
+	} 
+	else
+	{
+		RampPitchVol(FALSE);
+	}
+}
+
+void CFuncRotating :: Rotate( void )
+{
+	pev->nextthink = pev->ltime + 10;
+}
+
+//=========================================================
+// Rotating Use - when a rotating brush is triggered
+//=========================================================
+void CFuncRotating :: RotatingUse( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value )
+{
+	// is this a brush that should accelerate and decelerate when turned on/off (fan)?
+	if ( FBitSet ( pev->spawnflags, SF_BRUSH_ACCDCC ) )
+	{
+		// fan is spinning, so stop it.
+		if ( pev->avelocity != g_vecZero )
+		{
+			SetThink ( &CFuncRotating::SpinDown );
+			//EMIT_SOUND_DYN(ENT(pev), CHAN_WEAPON, (char *)STRING(pev->noiseStop), 
+			//	m_flVolume, m_flAttenuation, 0, m_pitch);
+
+			pev->nextthink = pev->ltime + 0.1;
+		}
+		else// fan is not moving, so start it
+		{
+			SetThink ( &CFuncRotating::SpinUp );
+			EMIT_SOUND_DYN(ENT(pev), CHAN_STATIC, (char *)STRING(pev->noiseRunning), 
+				0.01, m_flAttenuation, 0, FANPITCHMIN);
+
+			pev->nextthink = pev->ltime + 0.1;
+		}
+	}
+	else if ( !FBitSet ( pev->spawnflags, SF_BRUSH_ACCDCC ) )//this is a normal start/stop brush.
+	{
+		if ( pev->avelocity != g_vecZero )
+		{
+			// play stopping sound here
+			SetThink ( &CFuncRotating::SpinDown );
+
+			// EMIT_SOUND_DYN(ENT(pev), CHAN_WEAPON, (char *)STRING(pev->noiseStop), 
+			//	m_flVolume, m_flAttenuation, 0, m_pitch);
+			
+			pev->nextthink = pev->ltime + 0.1;
+			// pev->avelocity = g_vecZero;
+		}
+		else
+		{
+			EMIT_SOUND_DYN(ENT(pev), CHAN_STATIC, (char *)STRING(pev->noiseRunning), 
+				m_flVolume, m_flAttenuation, 0, FANPITCHMAX);
+			pev->avelocity = pev->movedir * pev->speed;
+
+			SetThink( &CFuncRotating::Rotate );
+			Rotate();
+		}
+	}
+}
+
+
+//
+// RotatingBlocked - An entity has blocked the brush
+//
+void CFuncRotating :: Blocked( CBaseEntity *pOther )
+
+{
+	pOther->TakeDamage( pev, pev, pev->dmg, DMG_CRUSH);
+}
+
+
+
+
+
+
+//#endif
+
+
+class CPendulum : public CBaseEntity
+{
+public:
+	void	Spawn ( void );
+	void	KeyValue( KeyValueData *pkvd );
+	void	EXPORT Swing( void );
+	void	EXPORT PendulumUse( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value );
+	void	EXPORT Stop( void );
+	void	Touch( CBaseEntity *pOther );
+	void	EXPORT RopeTouch ( CBaseEntity *pOther );// this touch func makes the pendulum a rope
+	virtual int	ObjectCaps( void ) { return CBaseEntity :: ObjectCaps() & ~FCAP_ACROSS_TRANSITION; }
+	virtual int		Save( CSave &save );
+	virtual int		Restore( CRestore &restore );
+	void	Blocked( CBaseEntity *pOther );
+
+	static	TYPEDESCRIPTION m_SaveData[];
+	
+	float	m_accel;			// Acceleration
+	float	m_distance;			// 
+	float	m_time;
+	float	m_damp;
+	float	m_maxSpeed;
+	float	m_dampSpeed;
+	vec3_t	m_center;
+	vec3_t	m_start;
+};
+
+LINK_ENTITY_TO_CLASS( func_pendulum, CPendulum );
+
+TYPEDESCRIPTION	CPendulum::m_SaveData[] = 
+{
+	DEFINE_FIELD( CPendulum, m_accel, FIELD_FLOAT ),
+	DEFINE_FIELD( CPendulum, m_distance, FIELD_FLOAT ),
+	DEFINE_FIELD( CPendulum, m_time, FIELD_TIME ),
+	DEFINE_FIELD( CPendulum, m_damp, FIELD_FLOAT ),
+	DEFINE_FIELD( CPendulum, m_maxSpeed, FIELD_FLOAT ),
+	DEFINE_FIELD( CPendulum, m_dampSpeed, FIELD_FLOAT ),
+	DEFINE_FIELD( CPendulum, m_center, FIELD_VECTOR ),
+	DEFINE_FIELD( CPendulum, m_start, FIELD_VECTOR ),
+};
+
+IMPLEMENT_SAVERESTORE( CPendulum, CBaseEntity );
+
+
+
+void CPendulum :: KeyValue( KeyValueData *pkvd )
+{
+	if (FStrEq(pkvd->szKeyName, "distance"))
+	{
+		m_distance = atof(pkvd->szValue);
+		pkvd->fHandled = TRUE;
+	}
+	else if (FStrEq(pkvd->szKeyName, "damp"))
+	{
+		m_damp = atof(pkvd->szValue) * 0.001;
+		pkvd->fHandled = TRUE;
+	}
+	else 
+		CBaseEntity::KeyValue( pkvd );
+}
+
+
+void CPendulum :: Spawn( void )
+{
+	// set the axis of rotation
+	CBaseToggle :: AxisDir( pev );
+
+	if ( FBitSet (pev->spawnflags, SF_DOOR_PASSABLE) )
+		pev->solid		= SOLID_NOT;
+	else
+		pev->solid		= SOLID_BSP;
+	pev->movetype	= MOVETYPE_PUSH;
+	UTIL_SetOrigin(pev, pev->origin);
+	SET_MODEL(ENT(pev), STRING(pev->model) );
+
+	if ( m_distance == 0 )
+		return;
+
+	if (pev->speed == 0)
+		pev->speed = 100;
+
+	m_accel = (pev->speed * pev->speed) / (2 * fabs(m_distance));	// Calculate constant acceleration from speed and distance
+	m_maxSpeed = pev->speed;
+	m_start = pev->angles;
+	m_center = pev->angles + (m_distance * 0.5) * pev->movedir;
+
+	if ( FBitSet( pev->spawnflags, SF_BRUSH_ROTATE_INSTANT) )
+	{		
+		SetThink( &CBaseEntity::SUB_CallUseToggle );
+		pev->nextthink = gpGlobals->time + 0.1;
+	}
+	pev->speed = 0;
+	SetUse( &CPendulum::PendulumUse );
+
+	if ( FBitSet( pev->spawnflags, SF_PENDULUM_SWING ) )
+	{
+		SetTouch ( &CPendulum::RopeTouch );
+	}
+}
+
+
+void CPendulum :: PendulumUse( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value )
+{
+	if ( pev->speed )		// Pendulum is moving, stop it and auto-return if necessary
+	{
+		if ( FBitSet( pev->spawnflags, SF_PENDULUM_AUTO_RETURN ) )
+		{		
+			float	delta;
+
+			delta = CBaseToggle :: AxisDelta( pev->spawnflags, pev->angles, m_start );
+
+			pev->avelocity = m_maxSpeed * pev->movedir;
+			pev->nextthink = pev->ltime + (delta / m_maxSpeed);
+			SetThink( &CPendulum::Stop );
+		}
+		else
+		{
+			pev->speed = 0;		// Dead stop
+			SetThink( NULL );
+			pev->avelocity = g_vecZero;
+		}
+	}
+	else
+	{
+		pev->nextthink = pev->ltime + 0.1;		// Start the pendulum moving
+		m_time = gpGlobals->time;		// Save time to calculate dt
+		SetThink( &CPendulum::Swing );
+		m_dampSpeed = m_maxSpeed;
+	}
+}
+
+
+void CPendulum :: Stop( void )
+{
+	pev->angles = m_start;
+	pev->speed = 0;
+	SetThink( NULL );
+	pev->avelocity = g_vecZero;
+}
+
+
+void CPendulum::Blocked( CBaseEntity *pOther )
+{
+	m_time = gpGlobals->time;
+}
+
+
+void CPendulum :: Swing( void )
+{
+	float delta, dt;
+	
+	delta = CBaseToggle :: AxisDelta( pev->spawnflags, pev->angles, m_center );
+	dt = gpGlobals->time - m_time;	// How much time has passed?
+	m_time = gpGlobals->time;		// Remember the last time called
+
+	if ( delta > 0 && m_accel > 0 )
+		pev->speed -= m_accel * dt;	// Integrate velocity
+	else 
+		pev->speed += m_accel * dt;
+
+	if ( pev->speed > m_maxSpeed )
+		pev->speed = m_maxSpeed;
+	else if ( pev->speed < -m_maxSpeed )
+		pev->speed = -m_maxSpeed;
+	// scale the destdelta vector by the time spent traveling to get velocity
+	pev->avelocity = pev->speed * pev->movedir;
+
+	// Call this again
+	pev->nextthink = pev->ltime + 0.1;
+
+	if ( m_damp )
+	{
+		m_dampSpeed -= m_damp * m_dampSpeed * dt;
+		if ( m_dampSpeed < 30.0 )
+		{
+			pev->angles = m_center;
+			pev->speed = 0;
+			SetThink( NULL );
+			pev->avelocity = g_vecZero;
+		}
+		else if ( pev->speed > m_dampSpeed )
+			pev->speed = m_dampSpeed;
+		else if ( pev->speed < -m_dampSpeed )
+			pev->speed = -m_dampSpeed;
+
+	}
+}
+
+
+void CPendulum :: Touch ( CBaseEntity *pOther )
+{
+	entvars_t	*pevOther = pOther->pev;
+
+	if ( pev->dmg <= 0 )
+		return;
+
+	// we can't hurt this thing, so we're not concerned with it
+	if ( !pevOther->takedamage )
+		return;
+
+	// calculate damage based on rotation speed
+	float damage = pev->dmg * pev->speed * 0.01;
+
+	if ( damage < 0 )
+		damage = -damage;
+
+	pOther->TakeDamage( pev, pev, damage, DMG_CRUSH );
+	
+	pevOther->velocity = (pevOther->origin - VecBModelOrigin(pev) ).Normalize() * damage;
+}
+
+void CPendulum :: RopeTouch ( CBaseEntity *pOther )
+{
+	entvars_t	*pevOther = pOther->pev;
+
+	if ( !pOther->IsPlayer() )
+	{// not a player!
+		ALERT ( at_console, "Not a client\n" );
+		return;
+	}
+
+	if ( ENT(pevOther) == pev->enemy )
+	{// this player already on the rope.
+		return;
+	}
+
+	pev->enemy = pOther->edict();
+	pevOther->velocity = g_vecZero;
+	pevOther->movetype = MOVETYPE_NONE;
+}
+
+

hlsdk/ricochet/dlls/cbase.cpp

@@ -0,0 +1,796 @@
+/***
+*
+*	Copyright (c) 1996-2002, Valve LLC. All rights reserved.
+*	
+*	This product contains software technology licensed from Id 
+*	Software, Inc. ("Id Technology").  Id Technology (c) 1996 Id Software, Inc. 
+*	All Rights Reserved.
+*
+*   Use, distribution, and modification of this source code and/or resulting
+*   object code is restricted to non-commercial enhancements to products from
+*   Valve LLC.  All other use, distribution, or modification is prohibited
+*   without written permission from Valve LLC.
+*
+****/
+#include	"extdll.h"
+#include	"util.h"
+#include	"cbase.h"
+#include	"saverestore.h"
+#include	"client.h"
+#include	"decals.h"
+#include	"gamerules.h"
+#include	"game.h"
+
+void EntvarsKeyvalue( entvars_t *pev, KeyValueData *pkvd );
+
+extern "C" void PM_Move ( struct playermove_s *ppmove, int server );
+extern "C" void PM_Init ( struct playermove_s *ppmove  );
+extern "C" char PM_FindTextureType( char *name );
+
+void OnFreeEntPrivateData(edict_s *pEdict);
+
+
+extern Vector VecBModelOrigin( entvars_t* pevBModel );
+extern DLL_GLOBAL Vector		g_vecAttackDir;
+extern DLL_GLOBAL int			g_iSkillLevel;
+
+static DLL_FUNCTIONS gFunctionTable = 
+{
+	GameDLLInit,				//pfnGameInit
+	DispatchSpawn,				//pfnSpawn
+	DispatchThink,				//pfnThink
+	DispatchUse,				//pfnUse
+	DispatchTouch,				//pfnTouch
+	DispatchBlocked,			//pfnBlocked
+	DispatchKeyValue,			//pfnKeyValue
+	DispatchSave,				//pfnSave
+	DispatchRestore,			//pfnRestore
+	DispatchObjectCollsionBox,	//pfnAbsBox
+
+	SaveWriteFields,			//pfnSaveWriteFields
+	SaveReadFields,				//pfnSaveReadFields
+
+	SaveGlobalState,			//pfnSaveGlobalState
+	RestoreGlobalState,			//pfnRestoreGlobalState
+	ResetGlobalState,			//pfnResetGlobalState
+
+	ClientConnect,				//pfnClientConnect
+	ClientDisconnect,			//pfnClientDisconnect
+	ClientKill,					//pfnClientKill
+	ClientPutInServer,			//pfnClientPutInServer
+	ClientCommand,				//pfnClientCommand
+	ClientUserInfoChanged,		//pfnClientUserInfoChanged
+	ServerActivate,				//pfnServerActivate
+	ServerDeactivate,			//pfnServerDeactivate
+
+	PlayerPreThink,				//pfnPlayerPreThink
+	PlayerPostThink,			//pfnPlayerPostThink
+
+	StartFrame,					//pfnStartFrame
+	ParmsNewLevel,				//pfnParmsNewLevel
+	ParmsChangeLevel,			//pfnParmsChangeLevel
+
+	GetGameDescription,         //pfnGetGameDescription    Returns string describing current .dll game.
+	PlayerCustomization,        //pfnPlayerCustomization   Notifies .dll of new customization for player.
+
+	SpectatorConnect,			//pfnSpectatorConnect      Called when spectator joins server
+	SpectatorDisconnect,        //pfnSpectatorDisconnect   Called when spectator leaves the server
+	SpectatorThink,				//pfnSpectatorThink        Called when spectator sends a command packet (usercmd_t)
+	
+	Sys_Error,					//pfnSys_Error				Called when engine has encountered an error
+
+	PM_Move,					//pfnPM_Move
+	PM_Init,					//pfnPM_Init				Server version of player movement initialization
+	PM_FindTextureType,			//pfnPM_FindTextureType
+	
+	SetupVisibility,			//pfnSetupVisibility        Set up PVS and PAS for networking for this client
+	UpdateClientData,			//pfnUpdateClientData       Set up data sent only to specific client
+	AddToFullPack,				//pfnAddToFullPack
+	CreateBaseline,				//pfnCreateBaseline			Tweak entity baseline for network encoding, allows setup of player baselines, too.
+	RegisterEncoders,			//pfnRegisterEncoders		Callbacks for network encoding
+	GetWeaponData,				//pfnGetWeaponData
+	CmdStart,					//pfnCmdStart
+	CmdEnd,						//pfnCmdEnd
+	ConnectionlessPacket,		//pfnConnectionlessPacket
+	GetHullBounds,				//pfnGetHullBounds
+	CreateInstancedBaselines,   //pfnCreateInstancedBaselines
+	InconsistentFile,			//pfnInconsistentFile
+	AllowLagCompensation,		//pfnAllowLagCompensation
+};
+
+NEW_DLL_FUNCTIONS gNewDLLFunctions =
+{
+	OnFreeEntPrivateData,		//pfnOnFreeEntPrivateData
+	GameDLLShutdown,			//pfnGameShutdown
+	ShouldCollide,				//pfnShouldCollide
+};
+
+
+static void SetObjectCollisionBox( entvars_t *pev );
+
+int GetEntityAPI( DLL_FUNCTIONS *pFunctionTable, int interfaceVersion )
+{
+	if ( !pFunctionTable || interfaceVersion != INTERFACE_VERSION )
+	{
+		return FALSE;
+	}
+	
+	memcpy( pFunctionTable, &gFunctionTable, sizeof( DLL_FUNCTIONS ) );
+	return TRUE;
+}
+
+int GetEntityAPI2( DLL_FUNCTIONS *pFunctionTable, int *interfaceVersion )
+{
+	if ( !pFunctionTable || *interfaceVersion != INTERFACE_VERSION )
+	{
+		// Tell engine what version we had, so it can figure out who is out of date.
+		*interfaceVersion = INTERFACE_VERSION;
+		return FALSE;
+	}
+	
+	memcpy( pFunctionTable, &gFunctionTable, sizeof( DLL_FUNCTIONS ) );
+	return TRUE;
+}
+
+int GetNewDLLFunctions(NEW_DLL_FUNCTIONS *pFunctionTable, int *interfaceVersion)
+{
+	if(!pFunctionTable || *interfaceVersion != NEW_DLL_FUNCTIONS_VERSION)
+	{
+		*interfaceVersion = NEW_DLL_FUNCTIONS_VERSION;
+		return FALSE;
+	}
+
+	memcpy(pFunctionTable, &gNewDLLFunctions, sizeof(gNewDLLFunctions));
+	return TRUE;
+}
+
+int DispatchSpawn( edict_t *pent )
+{
+	CBaseEntity *pEntity = (CBaseEntity *)GET_PRIVATE(pent);
+
+	if (pEntity)
+	{
+		// Initialize these or entities who don't link to the world won't have anything in here
+		pEntity->pev->absmin = pEntity->pev->origin - Vector(1,1,1);
+		pEntity->pev->absmax = pEntity->pev->origin + Vector(1,1,1);
+
+		pEntity->Spawn();
+
+		// Try to get the pointer again, in case the spawn function deleted the entity.
+		// UNDONE: Spawn() should really return a code to ask that the entity be deleted, but
+		// that would touch too much code for me to do that right now.
+		pEntity = (CBaseEntity *)GET_PRIVATE(pent);
+
+		if ( pEntity )
+		{
+			if ( g_pGameRules && !g_pGameRules->IsAllowedToSpawn( pEntity ) )
+				return -1;	// return that this entity should be deleted
+			if ( pEntity->pev->flags & FL_KILLME )
+				return -1;
+		}
+
+
+		// Handle global stuff here
+		if ( pEntity && pEntity->pev->globalname ) 
+		{
+			const globalentity_t *pGlobal = gGlobalState.EntityFromTable( pEntity->pev->globalname );
+			if ( pGlobal )
+			{
+				// Already dead? delete
+				if ( pGlobal->state == GLOBAL_DEAD )
+					return -1;
+				else if ( !FStrEq( STRING(gpGlobals->mapname), pGlobal->levelName ) )
+					pEntity->MakeDormant();	// Hasn't been moved to this level yet, wait but stay alive
+				// In this level & not dead, continue on as normal
+			}
+			else
+			{
+				// Spawned entities default to 'On'
+				gGlobalState.EntityAdd( pEntity->pev->globalname, gpGlobals->mapname, GLOBAL_ON );
+//				ALERT( at_console, "Added global entity %s (%s)\n", STRING(pEntity->pev->classname), STRING(pEntity->pev->globalname) );
+			}
+		}
+
+	}
+
+	return 0;
+}
+
+void DispatchKeyValue( edict_t *pentKeyvalue, KeyValueData *pkvd )
+{
+	if ( !pkvd || !pentKeyvalue )
+		return;
+
+	EntvarsKeyvalue( VARS(pentKeyvalue), pkvd );
+
+	// If the key was an entity variable, or there's no class set yet, don't look for the object, it may
+	// not exist yet.
+	if ( pkvd->fHandled || pkvd->szClassName == NULL )
+		return;
+
+	// Get the actualy entity object
+	CBaseEntity *pEntity = (CBaseEntity *)GET_PRIVATE(pentKeyvalue);
+
+	if ( !pEntity )
+		return;
+
+	pEntity->KeyValue( pkvd );
+}
+
+
+// HACKHACK -- this is a hack to keep the node graph entity from "touching" things (like triggers)
+// while it builds the graph
+BOOL gTouchDisabled = FALSE;
+void DispatchTouch( edict_t *pentTouched, edict_t *pentOther )
+{
+	if ( gTouchDisabled )
+		return;
+
+	CBaseEntity *pEntity = (CBaseEntity *)GET_PRIVATE(pentTouched);
+	CBaseEntity *pOther = (CBaseEntity *)GET_PRIVATE( pentOther );
+
+	if ( pEntity && pOther && ! ((pEntity->pev->flags | pOther->pev->flags) & FL_KILLME) )
+		pEntity->Touch( pOther );
+}
+
+
+void DispatchUse( edict_t *pentUsed, edict_t *pentOther )
+{
+	CBaseEntity *pEntity = (CBaseEntity *)GET_PRIVATE(pentUsed);
+	CBaseEntity *pOther = (CBaseEntity *)GET_PRIVATE(pentOther);
+
+	if (pEntity && !(pEntity->pev->flags & FL_KILLME) )
+		pEntity->Use( pOther, pOther, USE_TOGGLE, 0 );
+}
+
+void DispatchThink( edict_t *pent )
+{
+	CBaseEntity *pEntity = (CBaseEntity *)GET_PRIVATE(pent);
+	if (pEntity)
+	{
+		if ( FBitSet( pEntity->pev->flags, FL_DORMANT ) )
+			ALERT( at_error, "Dormant entity %s is thinking!!\n", STRING(pEntity->pev->classname) );
+				
+		pEntity->Think();
+	}
+}
+
+void DispatchBlocked( edict_t *pentBlocked, edict_t *pentOther )
+{
+	CBaseEntity *pEntity = (CBaseEntity *)GET_PRIVATE( pentBlocked );
+	CBaseEntity *pOther = (CBaseEntity *)GET_PRIVATE( pentOther );
+
+	if (pEntity)
+		pEntity->Blocked( pOther );
+}
+
+void DispatchSave( edict_t *pent, SAVERESTOREDATA *pSaveData )
+{
+	CBaseEntity *pEntity = (CBaseEntity *)GET_PRIVATE(pent);
+	
+	if ( pEntity && pSaveData )
+	{
+		ENTITYTABLE *pTable = &pSaveData->pTable[ pSaveData->currentIndex ];
+
+		if ( pTable->pent != pent )
+			ALERT( at_error, "ENTITY TABLE OR INDEX IS WRONG!!!!\n" );
+
+		if ( pEntity->ObjectCaps() & FCAP_DONT_SAVE )
+			return;
+
+		// These don't use ltime & nextthink as times really, but we'll fudge around it.
+		if ( pEntity->pev->movetype == MOVETYPE_PUSH )
+		{
+			float delta = pEntity->pev->nextthink - pEntity->pev->ltime;
+			pEntity->pev->ltime = gpGlobals->time;
+			pEntity->pev->nextthink = pEntity->pev->ltime + delta;
+		}
+
+		pTable->location = pSaveData->size;		// Remember entity position for file I/O
+		pTable->classname = pEntity->pev->classname;	// Remember entity class for respawn
+
+		CSave saveHelper( pSaveData );
+		pEntity->Save( saveHelper );
+
+		pTable->size = pSaveData->size - pTable->location;	// Size of entity block is data size written to block
+	}
+}
+
+void OnFreeEntPrivateData(edict_s *pEdict)
+{
+	if(pEdict && pEdict->pvPrivateData)
+	{
+		((CBaseEntity*)pEdict->pvPrivateData)->~CBaseEntity();
+	}
+}
+
+// Find the matching global entity.  Spit out an error if the designer made entities of
+// different classes with the same global name
+CBaseEntity *FindGlobalEntity( string_t classname, string_t globalname )
+{
+	edict_t *pent = FIND_ENTITY_BY_STRING( NULL, "globalname", STRING(globalname) );
+	CBaseEntity *pReturn = CBaseEntity::Instance( pent );
+	if ( pReturn )
+	{
+		if ( !FClassnameIs( pReturn->pev, STRING(classname) ) )
+		{
+			ALERT( at_console, "Global entity found %s, wrong class %s\n", STRING(globalname), STRING(pReturn->pev->classname) );
+			pReturn = NULL;
+		}
+	}
+
+	return pReturn;
+}
+
+
+int DispatchRestore( edict_t *pent, SAVERESTOREDATA *pSaveData, int globalEntity )
+{
+	CBaseEntity *pEntity = (CBaseEntity *)GET_PRIVATE(pent);
+
+	if ( pEntity && pSaveData )
+	{
+		entvars_t tmpVars;
+		Vector oldOffset;
+
+		CRestore restoreHelper( pSaveData );
+		if ( globalEntity )
+		{
+			CRestore tmpRestore( pSaveData );
+			tmpRestore.PrecacheMode( 0 );
+			tmpRestore.ReadEntVars( "ENTVARS", &tmpVars );
+
+			// HACKHACK - reset the save pointers, we're going to restore for real this time
+			pSaveData->size = pSaveData->pTable[pSaveData->currentIndex].location;
+			pSaveData->pCurrentData = pSaveData->pBaseData + pSaveData->size;
+			// -------------------
+
+
+			const globalentity_t *pGlobal = gGlobalState.EntityFromTable( tmpVars.globalname );
+			
+			// Don't overlay any instance of the global that isn't the latest
+			// pSaveData->szCurrentMapName is the level this entity is coming from
+			// pGlobla->levelName is the last level the global entity was active in.
+			// If they aren't the same, then this global update is out of date.
+			if ( !FStrEq( pSaveData->szCurrentMapName, pGlobal->levelName ) )
+				return 0;
+
+			// Compute the new global offset
+			oldOffset = pSaveData->vecLandmarkOffset;
+			CBaseEntity *pNewEntity = FindGlobalEntity( tmpVars.classname, tmpVars.globalname );
+			if ( pNewEntity )
+			{
+//				ALERT( at_console, "Overlay %s with %s\n", STRING(pNewEntity->pev->classname), STRING(tmpVars.classname) );
+				// Tell the restore code we're overlaying a global entity from another level
+				restoreHelper.SetGlobalMode( 1 );	// Don't overwrite global fields
+				pSaveData->vecLandmarkOffset = (pSaveData->vecLandmarkOffset - pNewEntity->pev->mins) + tmpVars.mins;
+				pEntity = pNewEntity;// we're going to restore this data OVER the old entity
+				pent = ENT( pEntity->pev );
+				// Update the global table to say that the global definition of this entity should come from this level
+				gGlobalState.EntityUpdate( pEntity->pev->globalname, gpGlobals->mapname );
+			}
+			else
+			{
+				// This entity will be freed automatically by the engine.  If we don't do a restore on a matching entity (below)
+				// or call EntityUpdate() to move it to this level, we haven't changed global state at all.
+				return 0;
+			}
+
+		}
+
+		if ( pEntity->ObjectCaps() & FCAP_MUST_SPAWN )
+		{
+			pEntity->Restore( restoreHelper );
+			pEntity->Spawn();
+		}
+		else
+		{
+			pEntity->Restore( restoreHelper );
+			pEntity->Precache( );
+		}
+
+		// Again, could be deleted, get the pointer again.
+		pEntity = (CBaseEntity *)GET_PRIVATE(pent);
+
+#if 0
+		if ( pEntity && pEntity->pev->globalname && globalEntity ) 
+		{
+			ALERT( at_console, "Global %s is %s\n", STRING(pEntity->pev->globalname), STRING(pEntity->pev->model) );
+		}
+#endif
+
+		// Is this an overriding global entity (coming over the transition), or one restoring in a level
+		if ( globalEntity )
+		{
+//			ALERT( at_console, "After: %f %f %f %s\n", pEntity->pev->origin.x, pEntity->pev->origin.y, pEntity->pev->origin.z, STRING(pEntity->pev->model) );
+			pSaveData->vecLandmarkOffset = oldOffset;
+			if ( pEntity )
+			{
+				UTIL_SetOrigin( pEntity->pev, pEntity->pev->origin );
+				pEntity->OverrideReset();
+			}
+		}
+		else if ( pEntity && pEntity->pev->globalname ) 
+		{
+			const globalentity_t *pGlobal = gGlobalState.EntityFromTable( pEntity->pev->globalname );
+			if ( pGlobal )
+			{
+				// Already dead? delete
+				if ( pGlobal->state == GLOBAL_DEAD )
+					return -1;
+				else if ( !FStrEq( STRING(gpGlobals->mapname), pGlobal->levelName ) )
+				{
+					pEntity->MakeDormant();	// Hasn't been moved to this level yet, wait but stay alive
+				}
+				// In this level & not dead, continue on as normal
+			}
+			else
+			{
+				ALERT( at_error, "Global Entity %s (%s) not in table!!!\n", STRING(pEntity->pev->globalname), STRING(pEntity->pev->classname) );
+				// Spawned entities default to 'On'
+				gGlobalState.EntityAdd( pEntity->pev->globalname, gpGlobals->mapname, GLOBAL_ON );
+			}
+		}
+	}
+	return 0;
+}
+
+
+void DispatchObjectCollsionBox( edict_t *pent )
+{
+	CBaseEntity *pEntity = (CBaseEntity *)GET_PRIVATE(pent);
+	if (pEntity)
+	{
+		pEntity->SetObjectCollisionBox();
+	}
+	else
+		SetObjectCollisionBox( &pent->v );
+}
+
+
+void SaveWriteFields( SAVERESTOREDATA *pSaveData, const char *pname, void *pBaseData, TYPEDESCRIPTION *pFields, int fieldCount )
+{
+	CSave saveHelper( pSaveData );
+	saveHelper.WriteFields( pname, pBaseData, pFields, fieldCount );
+}
+
+
+void SaveReadFields( SAVERESTOREDATA *pSaveData, const char *pname, void *pBaseData, TYPEDESCRIPTION *pFields, int fieldCount )
+{
+	CRestore restoreHelper( pSaveData );
+	restoreHelper.ReadFields( pname, pBaseData, pFields, fieldCount );
+}
+
+
+edict_t * EHANDLE::Get( void ) 
+{ 
+	if (m_pent)
+	{
+		if (m_pent->serialnumber == m_serialnumber) 
+			return m_pent; 
+		else
+			return NULL;
+	}
+	return NULL; 
+};
+
+edict_t * EHANDLE::Set( edict_t *pent ) 
+{ 
+	m_pent = pent;  
+	if (pent) 
+		m_serialnumber = m_pent->serialnumber; 
+	return pent; 
+};
+
+
+EHANDLE :: operator CBaseEntity *() 
+{ 
+	return (CBaseEntity *)GET_PRIVATE( Get( ) ); 
+};
+
+
+CBaseEntity * EHANDLE :: operator = (CBaseEntity *pEntity)
+{
+	if (pEntity)
+	{
+		m_pent = ENT( pEntity->pev );
+		if (m_pent)
+			m_serialnumber = m_pent->serialnumber;
+	}
+	else
+	{
+		m_pent = NULL;
+		m_serialnumber = 0;
+	}
+	return pEntity;
+}
+
+EHANDLE :: operator int ()
+{
+	return Get() != NULL;
+}
+
+CBaseEntity * EHANDLE :: operator -> ()
+{
+	return (CBaseEntity *)GET_PRIVATE( Get( ) ); 
+}
+
+
+// give health
+int CBaseEntity :: TakeHealth( float flHealth, int bitsDamageType )
+{
+	if (!pev->takedamage)
+		return 0;
+
+// heal
+	if ( pev->health >= pev->max_health )
+		return 0;
+
+	pev->health += flHealth;
+
+	if (pev->health > pev->max_health)
+		pev->health = pev->max_health;
+
+	return 1;
+}
+
+// inflict damage on this entity.  bitsDamageType indicates type of damage inflicted, ie: DMG_CRUSH
+
+int CBaseEntity :: TakeDamage( entvars_t* pevInflictor, entvars_t* pevAttacker, float flDamage, int bitsDamageType )
+{
+	Vector			vecTemp;
+
+	if (!pev->takedamage)
+		return 0;
+
+	// UNDONE: some entity types may be immune or resistant to some bitsDamageType
+	
+	// if Attacker == Inflictor, the attack was a melee or other instant-hit attack.
+	// (that is, no actual entity projectile was involved in the attack so use the shooter's origin). 
+	if ( pevAttacker == pevInflictor )	
+	{
+		vecTemp = pevInflictor->origin - ( VecBModelOrigin(pev) );
+	}
+	else
+	// an actual missile was involved.
+	{
+		vecTemp = pevInflictor->origin - ( VecBModelOrigin(pev) );
+	}
+
+// this global is still used for glass and other non-monster killables, along with decals.
+	g_vecAttackDir = vecTemp.Normalize();
+		
+// save damage based on the target's armor level
+
+// figure momentum add (don't let hurt brushes or other triggers move player)
+	if ((!FNullEnt(pevInflictor)) && (pev->movetype == MOVETYPE_WALK || pev->movetype == MOVETYPE_STEP) && (pevAttacker->solid != SOLID_TRIGGER) )
+	{
+		Vector vecDir = pev->origin - (pevInflictor->absmin + pevInflictor->absmax) * 0.5;
+		vecDir = vecDir.Normalize();
+
+		float flForce = flDamage * ((32 * 32 * 72.0) / (pev->size.x * pev->size.y * pev->size.z)) * 5;
+		
+		if (flForce > 1000.0) 
+			flForce = 1000.0;
+		pev->velocity = pev->velocity + vecDir * flForce;
+	}
+
+// do the damage
+	pev->health -= flDamage;
+	if (pev->health <= 0)
+	{
+		Killed( pevAttacker, GIB_NORMAL );
+		return 0;
+	}
+
+	return 1;
+}
+
+
+void CBaseEntity :: Killed( entvars_t *pevAttacker, int iGib )
+{
+	pev->takedamage = DAMAGE_NO;
+	pev->deadflag = DEAD_DEAD;
+	UTIL_Remove( this );
+}
+
+
+CBaseEntity *CBaseEntity::GetNextTarget( void )
+{
+	if ( FStringNull( pev->target ) )
+		return NULL;
+	edict_t *pTarget = FIND_ENTITY_BY_TARGETNAME ( NULL, STRING(pev->target) );
+	if ( FNullEnt(pTarget) )
+		return NULL;
+
+	return Instance( pTarget );
+}
+
+// Global Savedata for Delay
+TYPEDESCRIPTION	CBaseEntity::m_SaveData[] = 
+{
+	DEFINE_FIELD( CBaseEntity, m_pGoalEnt, FIELD_CLASSPTR ),
+
+	DEFINE_FIELD( CBaseEntity, m_pfnThink, FIELD_FUNCTION ),		// UNDONE: Build table of these!!!
+	DEFINE_FIELD( CBaseEntity, m_pfnTouch, FIELD_FUNCTION ),
+	DEFINE_FIELD( CBaseEntity, m_pfnUse, FIELD_FUNCTION ),
+	DEFINE_FIELD( CBaseEntity, m_pfnBlocked, FIELD_FUNCTION ),
+};
+
+
+int CBaseEntity::Save( CSave &save )
+{
+	if ( save.WriteEntVars( "ENTVARS", pev ) )
+		return save.WriteFields( "BASE", this, m_SaveData, ARRAYSIZE(m_SaveData) );
+
+	return 0;
+}
+
+int CBaseEntity::Restore( CRestore &restore )
+{
+	int status;
+
+	status = restore.ReadEntVars( "ENTVARS", pev );
+	if ( status )
+		status = restore.ReadFields( "BASE", this, m_SaveData, ARRAYSIZE(m_SaveData) );
+
+    if ( pev->modelindex != 0 && !FStringNull(pev->model) )
+	{
+		Vector mins, maxs;
+		mins = pev->mins;	// Set model is about to destroy these
+		maxs = pev->maxs;
+
+
+		PRECACHE_MODEL( (char *)STRING(pev->model) );
+		SET_MODEL(ENT(pev), STRING(pev->model));
+		UTIL_SetSize(pev, mins, maxs);	// Reset them
+	}
+
+	return status;
+}
+
+
+// Initialize absmin & absmax to the appropriate box
+void SetObjectCollisionBox( entvars_t *pev )
+{
+	if ( (pev->solid == SOLID_BSP) && 
+		 (pev->angles.x || pev->angles.y|| pev->angles.z) )
+	{	// expand for rotation
+		float		max, v;
+		int			i;
+
+		max = 0;
+		for (i=0 ; i<3 ; i++)
+		{
+			v = fabs( pev->mins[i]);
+			if (v > max)
+				max = v;
+			v = fabs( pev->maxs[i]);
+			if (v > max)
+				max = v;
+		}
+		for (i=0 ; i<3 ; i++)
+		{
+			pev->absmin[i] = pev->origin[i] - max;
+			pev->absmax[i] = pev->origin[i] + max;
+		}
+	}
+	else
+	{
+		pev->absmin = pev->origin + pev->mins;
+		pev->absmax = pev->origin + pev->maxs;
+	}
+
+	pev->absmin.x -= 1;
+	pev->absmin.y -= 1;
+	pev->absmin.z -= 1;
+	pev->absmax.x += 1;
+	pev->absmax.y += 1;
+	pev->absmax.z += 1;
+}
+
+
+void CBaseEntity::SetObjectCollisionBox( void )
+{
+	::SetObjectCollisionBox( pev );
+}
+
+
+int	CBaseEntity :: Intersects( CBaseEntity *pOther )
+{
+	if ( pOther->pev->absmin.x > pev->absmax.x ||
+		 pOther->pev->absmin.y > pev->absmax.y ||
+		 pOther->pev->absmin.z > pev->absmax.z ||
+		 pOther->pev->absmax.x < pev->absmin.x ||
+		 pOther->pev->absmax.y < pev->absmin.y ||
+		 pOther->pev->absmax.z < pev->absmin.z )
+		 return 0;
+	return 1;
+}
+
+void CBaseEntity :: MakeDormant( void )
+{
+	SetBits( pev->flags, FL_DORMANT );
+	
+	// Don't touch
+	pev->solid = SOLID_NOT;
+	// Don't move
+	pev->movetype = MOVETYPE_NONE;
+	// Don't draw
+	SetBits( pev->effects, EF_NODRAW );
+	// Don't think
+	pev->nextthink = 0;
+	// Relink
+	UTIL_SetOrigin( pev, pev->origin );
+}
+
+int CBaseEntity :: IsDormant( void )
+{
+	return FBitSet( pev->flags, FL_DORMANT );
+}
+
+BOOL CBaseEntity :: IsInWorld( void )
+{
+	// position 
+	if (pev->origin.x >= 4096) return FALSE;
+	if (pev->origin.y >= 4096) return FALSE;
+	if (pev->origin.z >= 4096) return FALSE;
+	if (pev->origin.x <= -4096) return FALSE;
+	if (pev->origin.y <= -4096) return FALSE;
+	if (pev->origin.z <= -4096) return FALSE;
+	// speed
+	if (pev->velocity.x >= 2000) return FALSE;
+	if (pev->velocity.y >= 2000) return FALSE;
+	if (pev->velocity.z >= 2000) return FALSE;
+	if (pev->velocity.x <= -2000) return FALSE;
+	if (pev->velocity.y <= -2000) return FALSE;
+	if (pev->velocity.z <= -2000) return FALSE;
+
+	return TRUE;
+}
+
+int CBaseEntity::ShouldToggle( USE_TYPE useType, BOOL currentState )
+{
+	if ( useType != USE_TOGGLE && useType != USE_SET )
+	{
+		if ( (currentState && useType == USE_ON) || (!currentState && useType == USE_OFF) )
+			return 0;
+	}
+	return 1;
+}
+
+
+int	CBaseEntity :: DamageDecal( int bitsDamageType )
+{
+	if ( pev->rendermode == kRenderTransAlpha )
+		return -1;
+
+	if ( pev->rendermode != kRenderNormal )
+		return DECAL_BPROOF1;
+
+	return DECAL_GUNSHOT1 + RANDOM_LONG(0,4);
+}
+
+
+
+// NOTE: szName must be a pointer to constant memory, e.g. "monster_class" because the entity
+// will keep a pointer to it after this call.
+CBaseEntity * CBaseEntity::Create( char *szName, const Vector &vecOrigin, const Vector &vecAngles, edict_t *pentOwner )
+{
+	edict_t	*pent;
+	CBaseEntity *pEntity;
+
+	pent = CREATE_NAMED_ENTITY( MAKE_STRING( szName ));
+	if ( FNullEnt( pent ) )
+	{
+		ALERT ( at_console, "NULL Ent in Create!\n" );
+		return NULL;
+	}
+	pEntity = Instance( pent );
+	pEntity->pev->owner = pentOwner;
+	pEntity->pev->origin = vecOrigin;
+	pEntity->pev->angles = vecAngles;
+	DispatchSpawn( pEntity->edict() );
+	return pEntity;
+}
+
+