/*
===============
CG_CalcViewValues
Sets cg.refdef view values
===============
*/
static int CG_CalcViewValues( void )
{
playerState_t *ps;
memset( &cg.refdef, 0, sizeof( cg.refdef ) );
// calculate size of 3D view
CG_CalcVrect( );
ps = &cg.predictedPlayerState;
// intermission view
if( ps->pm_type == PM_INTERMISSION || ps->pm_type == PM_FREEZE ||
ps->pm_type == PM_SPECTATOR )
{
VectorCopy( ps->origin, cg.refdef.vieworg );
VectorCopy( ps->viewangles, cg.refdefViewAngles );
AnglesToAxis( cg.refdefViewAngles, cg.refdef.viewaxis );
return CG_CalcFov( );
}
cg.bobcycle = ( ps->bobCycle & 128 ) >> 7;
cg.bobfracsin = fabs( sin( ( ps->bobCycle & 127 ) / 127.0 * M_PI ) );
cg.xyspeed = sqrt( ps->velocity[ 0 ] * ps->velocity[ 0 ] +
ps->velocity[ 1 ] * ps->velocity[ 1 ] );
// the bob velocity should't get too fast to avoid jerking
if( cg.xyspeed > 300.0f )
cg.xyspeed = 300.0f;
VectorCopy( ps->origin, cg.refdef.vieworg );
if( BG_ClassHasAbility( ps->stats[ STAT_CLASS ], SCA_WALLCLIMBER ) )
CG_smoothWWTransitions( ps, ps->viewangles, cg.refdefViewAngles );
else if( BG_ClassHasAbility( ps->stats[ STAT_CLASS ], SCA_WALLJUMPER ) )
CG_smoothWJTransitions( ps, ps->viewangles, cg.refdefViewAngles );
else
VectorCopy( ps->viewangles, cg.refdefViewAngles );
//clumsy logic, but it needs to be this way round because the CS propogation
//delay screws things up otherwise
if( !BG_ClassHasAbility( ps->stats[ STAT_CLASS ], SCA_WALLJUMPER ) )
{
if( !( ps->stats[ STAT_STATE ] & SS_WALLCLIMBING ) )
VectorSet( cg.lastNormal, 0.0f, 0.0f, 1.0f );
}
// add error decay
if( cg_errorDecay.value > 0 )
{
int t;
float f;
t = cg.time - cg.predictedErrorTime;
f = ( cg_errorDecay.value - t ) / cg_errorDecay.value;
if( f > 0 && f < 1 )
VectorMA( cg.refdef.vieworg, f, cg.predictedError, cg.refdef.vieworg );
else
cg.predictedErrorTime = 0;
}
//shut off the poison cloud effect if it's still on the go
if( cg.snap->ps.stats[ STAT_HEALTH ] <= 0 )
{
if( CG_IsParticleSystemValid( &cg.poisonCloudPS ) )
CG_DestroyParticleSystem( &cg.poisonCloudPS );
}
else
cg.wasDeadLastFrame = qfalse;
if( cg.renderingThirdPerson )
{
// back away from character
CG_OffsetThirdPersonView( );
}
else
{
// offset for local bobbing and kicks
CG_OffsetFirstPersonView( );
}
// position eye reletive to origin
AnglesToAxis( cg.refdefViewAngles, cg.refdef.viewaxis );
if( cg.hyperspace )
cg.refdef.rdflags |= RDF_NOWORLDMODEL | RDF_HYPERSPACE;
//draw the surface normal looking at
if( cg_drawSurfNormal.integer )
CG_DrawSurfNormal( );
// field of view
return CG_CalcFov( );
}
/*
==============
CG_EntityEvent
An entity has an event value
also called by CG_CheckPlayerstateEvents
==============
*/
void CG_EntityEvent( centity_t *cent, vec3_t position )
{
entityState_t *es;
int event;
vec3_t dir;
const char *s;
int clientNum;
clientInfo_t *ci;
int steptime;
if ( cg.snap->ps.persistant[ PERS_SPECSTATE ] != SPECTATOR_NOT )
{
steptime = 200;
}
else
{
steptime = BG_Class( cg.snap->ps.stats[ STAT_CLASS ] )->steptime;
}
es = ¢->currentState;
event = es->event & ~EV_EVENT_BITS;
if ( cg_debugEvents.integer )
{
CG_Printf( "ent:%3i event:%3i %s\n", es->number, event,
BG_EventName( event ) );
}
if ( !event )
{
return;
}
clientNum = es->clientNum;
if ( clientNum < 0 || clientNum >= MAX_CLIENTS )
{
clientNum = 0;
}
ci = &cgs.clientinfo[ clientNum ];
switch ( event )
{
case EV_FOOTSTEP:
if ( cg_footsteps.integer && ci->footsteps != FOOTSTEP_NONE )
{
if ( ci->footsteps == FOOTSTEP_CUSTOM )
{
trap_S_StartSound( NULL, es->number, CHAN_BODY,
ci->customFootsteps[ rand() & 3 ] );
}
else
{
trap_S_StartSound( NULL, es->number, CHAN_BODY,
cgs.media.footsteps[ ci->footsteps ][ rand() & 3 ] );
}
}
break;
case EV_FOOTSTEP_METAL:
if ( cg_footsteps.integer && ci->footsteps != FOOTSTEP_NONE )
{
if ( ci->footsteps == FOOTSTEP_CUSTOM )
{
trap_S_StartSound( NULL, es->number, CHAN_BODY,
ci->customMetalFootsteps[ rand() & 3 ] );
}
else
{
trap_S_StartSound( NULL, es->number, CHAN_BODY,
cgs.media.footsteps[ FOOTSTEP_METAL ][ rand() & 3 ] );
}
}
break;
case EV_FOOTSTEP_SQUELCH:
if ( cg_footsteps.integer && ci->footsteps != FOOTSTEP_NONE )
{
trap_S_StartSound( NULL, es->number, CHAN_BODY,
cgs.media.footsteps[ FOOTSTEP_FLESH ][ rand() & 3 ] );
}
break;
case EV_FOOTSPLASH:
if ( cg_footsteps.integer && ci->footsteps != FOOTSTEP_NONE )
{
trap_S_StartSound( NULL, es->number, CHAN_BODY,
cgs.media.footsteps[ FOOTSTEP_SPLASH ][ rand() & 3 ] );
}
break;
case EV_FOOTWADE:
if ( cg_footsteps.integer && ci->footsteps != FOOTSTEP_NONE )
{
trap_S_StartSound( NULL, es->number, CHAN_BODY,
cgs.media.footsteps[ FOOTSTEP_SPLASH ][ rand() & 3 ] );
}
break;
case EV_SWIM:
if ( cg_footsteps.integer && ci->footsteps != FOOTSTEP_NONE )
{
trap_S_StartSound( NULL, es->number, CHAN_BODY,
cgs.media.footsteps[ FOOTSTEP_SPLASH ][ rand() & 3 ] );
}
break;
case EV_FALL_SHORT:
trap_S_StartSound( NULL, es->number, CHAN_AUTO, cgs.media.landSound );
if ( clientNum == cg.predictedPlayerState.clientNum )
{
// smooth landing z changes
cg.landChange = -8;
cg.landTime = cg.time;
}
break;
case EV_FALL_MEDIUM:
// use a general pain sound
trap_S_StartSound( NULL, es->number, CHAN_VOICE, CG_CustomSound( es->number, "*pain100_1.wav" ) );
if ( clientNum == cg.predictedPlayerState.clientNum )
{
// smooth landing z changes
cg.landChange = -16;
cg.landTime = cg.time;
}
break;
case EV_FALL_FAR:
trap_S_StartSound( NULL, es->number, CHAN_AUTO, CG_CustomSound( es->number, "*fall1.wav" ) );
cent->pe.painTime = cg.time; // don't play a pain sound right after this
if ( clientNum == cg.predictedPlayerState.clientNum )
{
// smooth landing z changes
cg.landChange = -24;
cg.landTime = cg.time;
}
break;
case EV_FALLING:
trap_S_StartSound( NULL, es->number, CHAN_AUTO, CG_CustomSound( es->number, "*falling1.wav" ) );
break;
case EV_STEP_4:
case EV_STEP_8:
case EV_STEP_12:
case EV_STEP_16: // smooth out step up transitions
case EV_STEPDN_4:
case EV_STEPDN_8:
case EV_STEPDN_12:
case EV_STEPDN_16: // smooth out step down transitions
{
float oldStep;
int delta;
int step;
if ( clientNum != cg.predictedPlayerState.clientNum )
{
break;
}
// if we are interpolating, we don't need to smooth steps
if ( cg.demoPlayback || ( cg.snap->ps.pm_flags & PMF_FOLLOW ) ||
cg_nopredict.integer || cg_synchronousClients.integer )
{
break;
}
// check for stepping up before a previous step is completed
delta = cg.time - cg.stepTime;
if ( delta < steptime )
{
oldStep = cg.stepChange * ( steptime - delta ) / steptime;
}
else
{
oldStep = 0;
}
// add this amount
if ( event >= EV_STEPDN_4 )
{
step = 4 * ( event - EV_STEPDN_4 + 1 );
cg.stepChange = oldStep - step;
}
else
{
step = 4 * ( event - EV_STEP_4 + 1 );
cg.stepChange = oldStep + step;
}
if ( cg.stepChange > MAX_STEP_CHANGE )
{
cg.stepChange = MAX_STEP_CHANGE;
}
else if ( cg.stepChange < -MAX_STEP_CHANGE )
{
cg.stepChange = -MAX_STEP_CHANGE;
}
cg.stepTime = cg.time;
break;
}
case EV_JUMP:
trap_S_StartSound( NULL, es->number, CHAN_VOICE, CG_CustomSound( es->number, "*jump1.wav" ) );
if ( BG_ClassHasAbility( cg.predictedPlayerState.stats[ STAT_CLASS ], SCA_WALLJUMPER ) )
{
vec3_t surfNormal, refNormal = { 0.0f, 0.0f, 1.0f };
vec3_t rotAxis;
if ( clientNum != cg.predictedPlayerState.clientNum )
{
break;
}
//set surfNormal
VectorCopy( cg.predictedPlayerState.grapplePoint, surfNormal );
//if we are moving from one surface to another smooth the transition
if ( !VectorCompare( surfNormal, cg.lastNormal ) && surfNormal[ 2 ] != 1.0f )
{
CrossProduct( refNormal, surfNormal, rotAxis );
VectorNormalize( rotAxis );
//add the op
CG_addSmoothOp( rotAxis, 15.0f, 1.0f );
}
//copy the current normal to the lastNormal
VectorCopy( surfNormal, cg.lastNormal );
}
break;
case EV_LEV1_GRAB:
trap_S_StartSound( NULL, es->number, CHAN_VOICE, cgs.media.alienL1Grab );
break;
case EV_LEV4_TRAMPLE_PREPARE:
trap_S_StartSound( NULL, es->number, CHAN_VOICE, cgs.media.alienL4ChargePrepare );
break;
case EV_LEV4_TRAMPLE_START:
//FIXME: stop cgs.media.alienL4ChargePrepare playing here
trap_S_StartSound( NULL, es->number, CHAN_VOICE, cgs.media.alienL4ChargeStart );
break;
case EV_TAUNT:
if ( !cg_noTaunt.integer )
{
trap_S_StartSound( NULL, es->number, CHAN_VOICE, CG_CustomSound( es->number, "*taunt.wav" ) );
}
break;
case EV_WATER_TOUCH:
trap_S_StartSound( NULL, es->number, CHAN_AUTO, cgs.media.watrInSound );
break;
case EV_WATER_LEAVE:
trap_S_StartSound( NULL, es->number, CHAN_AUTO, cgs.media.watrOutSound );
break;
case EV_WATER_UNDER:
trap_S_StartSound( NULL, es->number, CHAN_AUTO, cgs.media.watrUnSound );
break;
case EV_WATER_CLEAR:
trap_S_StartSound( NULL, es->number, CHAN_AUTO, CG_CustomSound( es->number, "*gasp.wav" ) );
break;
case EV_JETPACK_ENABLE:
// TODO: Trigger jetpack enable animation
break;
case EV_JETPACK_DISABLE:
// TODO: Trigger jetpack disable animation
break;
case EV_JETPACK_START:
// TODO: Start jetpack gfx/sfx
break;
case EV_JETPACK_STOP:
// TODO: Stop jetpack gfx/sfx
break;
case EV_NOAMMO:
trap_S_StartSound( NULL, es->number, CHAN_WEAPON, cgs.media.weaponEmptyClick );
break;
case EV_CHANGE_WEAPON:
trap_S_StartSound( NULL, es->number, CHAN_AUTO, cgs.media.selectSound );
break;
case EV_FIRE_WEAPON:
CG_HandleFireWeapon( cent, WPM_PRIMARY );
break;
case EV_FIRE_WEAPON2:
CG_HandleFireWeapon( cent, WPM_SECONDARY );
break;
case EV_FIRE_WEAPON3:
CG_HandleFireWeapon( cent, WPM_TERTIARY );
break;
case EV_WEAPON_RELOAD:
if ( cg_weapons[ es->eventParm ].wim[ WPM_PRIMARY ].reloadSound )
{
trap_S_StartSound( NULL, es->number, CHAN_WEAPON, cg_weapons[ es->eventParm ].wim[ WPM_PRIMARY ].reloadSound );
}
break;
case EV_PLAYER_TELEPORT_IN:
//deprecated
break;
case EV_PLAYER_TELEPORT_OUT:
CG_PlayerDisconnect( position );
break;
case EV_BUILD_CONSTRUCT:
break;
case EV_BUILD_DESTROY:
break;
case EV_AMMO_REFILL:
case EV_CLIPS_REFILL:
case EV_FUEL_REFILL:
// TODO: Add different sounds for EV_AMMO_REFILL, EV_CLIPS_REFILL, EV_FUEL_REFILL
trap_S_StartSound( NULL, es->number, CHAN_AUTO, cgs.media.repeaterUseSound );
break;
case EV_GRENADE_BOUNCE:
if ( rand() & 1 )
{
trap_S_StartSound( NULL, es->number, CHAN_AUTO, cgs.media.hardBounceSound1 );
}
else
{
trap_S_StartSound( NULL, es->number, CHAN_AUTO, cgs.media.hardBounceSound2 );
}
break;
case EV_WEAPON_HIT_ENTITY:
CG_HandleWeaponHitEntity( es, position );
break;
case EV_WEAPON_HIT_ENVIRONMENT:
CG_HandleWeaponHitWall( es, position );
break;
case EV_MISSILE_HIT_ENTITY:
CG_HandleMissileHitEntity( es, position );
break;
// currently there is no support for metal sounds
case EV_MISSILE_HIT_ENVIRONMENT:
case EV_MISSILE_HIT_METAL:
CG_HandleMissileHitWall( es, position );
break;
case EV_SHOTGUN:
CG_HandleFireShotgun( es );
break;
case EV_HUMAN_BUILDABLE_DYING:
CG_HumanBuildableDying( (buildable_t) es->modelindex, position );
break;
case EV_HUMAN_BUILDABLE_EXPLOSION:
ByteToDir( es->eventParm, dir );
CG_HumanBuildableExplosion( (buildable_t) es->modelindex, position, dir );
break;
case EV_ALIEN_BUILDABLE_EXPLOSION:
ByteToDir( es->eventParm, dir );
CG_AlienBuildableExplosion( position, dir );
break;
case EV_TESLATRAIL:
cent->currentState.weapon = WP_TESLAGEN;
{
centity_t *source = &cg_entities[ es->generic1 ];
centity_t *target = &cg_entities[ es->clientNum ];
vec3_t sourceOffset = { 0.0f, 0.0f, 28.0f };
if ( !CG_IsTrailSystemValid( &source->muzzleTS ) )
{
source->muzzleTS = CG_SpawnNewTrailSystem( cgs.media.teslaZapTS );
if ( CG_IsTrailSystemValid( &source->muzzleTS ) )
{
CG_SetAttachmentCent( &source->muzzleTS->frontAttachment, source );
CG_SetAttachmentCent( &source->muzzleTS->backAttachment, target );
CG_AttachToCent( &source->muzzleTS->frontAttachment );
CG_AttachToCent( &source->muzzleTS->backAttachment );
CG_SetAttachmentOffset( &source->muzzleTS->frontAttachment, sourceOffset );
source->muzzleTSDeathTime = cg.time + cg_teslaTrailTime.integer;
}
}
}
break;
case EV_GENERAL_SOUND:
if ( cgs.gameSounds[ es->eventParm ] )
{
trap_S_StartSound( NULL, es->number, CHAN_VOICE, cgs.gameSounds[ es->eventParm ] );
}
else
{
s = CG_ConfigString( CS_SOUNDS + es->eventParm );
trap_S_StartSound( NULL, es->number, CHAN_VOICE, CG_CustomSound( es->number, s ) );
}
break;
case EV_GLOBAL_SOUND: // play from the player's head so it never diminishes
if ( cgs.gameSounds[ es->eventParm ] )
{
trap_S_StartSound( NULL, cg.snap->ps.clientNum, CHAN_AUTO, cgs.gameSounds[ es->eventParm ] );
}
else
{
s = CG_ConfigString( CS_SOUNDS + es->eventParm );
trap_S_StartSound( NULL, cg.snap->ps.clientNum, CHAN_AUTO, CG_CustomSound( es->number, s ) );
}
break;
case EV_PAIN:
// local player sounds are triggered in CG_CheckLocalSounds,
// so ignore events on the player
if ( cent->currentState.number != cg.snap->ps.clientNum )
{
CG_PainEvent( cent, es->eventParm );
}
break;
case EV_DEATH1:
case EV_DEATH2:
case EV_DEATH3:
trap_S_StartSound( NULL, es->number, CHAN_VOICE,
CG_CustomSound( es->number, va( "*death%i.wav", event - EV_DEATH1 + 1 ) ) );
break;
case EV_OBITUARY:
CG_Obituary( es );
break;
case EV_GIB_PLAYER:
// no gibbing
break;
case EV_STOPLOOPINGSOUND:
trap_S_StopLoopingSound( es->number );
es->loopSound = 0;
break;
case EV_DEBUG_LINE:
CG_Beam( cent );
break;
case EV_BUILD_DELAY:
if ( clientNum == cg.predictedPlayerState.clientNum )
{
trap_S_StartLocalSound( cgs.media.buildableRepairedSound, CHAN_LOCAL_SOUND );
cg.lastBuildAttempt = cg.time;
}
break;
case EV_BUILD_REPAIR:
trap_S_StartSound( NULL, es->number, CHAN_AUTO, cgs.media.buildableRepairSound );
break;
case EV_BUILD_REPAIRED:
trap_S_StartSound( NULL, es->number, CHAN_AUTO, cgs.media.buildableRepairedSound );
break;
case EV_OVERMIND_ATTACK_1:
case EV_OVERMIND_ATTACK_2:
if ( cg.predictedPlayerState.persistant[ PERS_TEAM ] == TEAM_ALIENS )
{
trap_S_StartLocalSound( cgs.media.alienOvermindAttack, CHAN_ANNOUNCER );
CG_CenterPrint( va( "^%c%s", "31"[ event - EV_OVERMIND_ATTACK_1 ], _( "The Overmind is under attack!" ) ), 200, GIANTCHAR_WIDTH * 4 );
}
break;
case EV_OVERMIND_DYING:
if ( cg.predictedPlayerState.persistant[ PERS_TEAM ] == TEAM_ALIENS )
{
trap_S_StartLocalSound( cgs.media.alienOvermindDying, CHAN_ANNOUNCER );
CG_CenterPrint( _( "^1The Overmind is dying!" ), 200, GIANTCHAR_WIDTH * 4 );
}
break;
case EV_REACTOR_ATTACK_1:
case EV_REACTOR_ATTACK_2:
if ( cg.predictedPlayerState.persistant[ PERS_TEAM ] == TEAM_HUMANS )
{
CG_CenterPrint( va( "^%c%s", "31"[ event - EV_REACTOR_ATTACK_1 ], _( "The reactor is under attack!" ) ), 200, GIANTCHAR_WIDTH * 4 );
}
break;
case EV_REACTOR_DYING:
if ( cg.predictedPlayerState.persistant[ PERS_TEAM ] == TEAM_HUMANS )
{
CG_CenterPrint( _( "^1The reactor is about to explode!" ), 200, GIANTCHAR_WIDTH * 4 );
}
break;
case EV_WARN_ATTACK:
// if eventParm is non-zero, this is for humans and there's a nearby reactor or repeater, otherwise it's for aliens
if ( es->eventParm >= MAX_CLIENTS && es->eventParm < MAX_GENTITIES )
{
const char *location;
qboolean base = cg_entities[ es->eventParm ].currentState.modelindex == BA_H_REACTOR;
centity_t *locent = CG_GetLocation( cg_entities[ es->eventParm ].currentState.origin );
CG_CenterPrint( base ? _( "Our base is under attack!" ) : _( "A forward base is under attack!" ), 200, GIANTCHAR_WIDTH * 4 );
if ( locent )
{
location = CG_ConfigString( CS_LOCATIONS + locent->currentState.generic1 );
}
else
{
location = CG_ConfigString( CS_LOCATIONS );
}
if ( location && *location )
{
Com_Printf( _( "%s Under attack – %s\n" ), base ? "[reactor]" : "[repeater]", location );
}
else
{
Com_Printf( _( "%s Under attack\n" ), base ? "[reactor]" : "[repeater]" );
}
}
else // this is for aliens, and the overmind is in range
{
CG_CenterPrint( _( "Our base is under attack!" ), 200, GIANTCHAR_WIDTH * 4 );
}
break;
case EV_MGTURRET_SPINUP:
trap_S_StartSound( NULL, es->number, CHAN_AUTO, cgs.media.turretSpinupSound );
break;
case EV_OVERMIND_SPAWNS:
if ( cg.predictedPlayerState.persistant[ PERS_TEAM ] == TEAM_ALIENS )
{
trap_S_StartLocalSound( cgs.media.alienOvermindSpawns, CHAN_ANNOUNCER );
CG_CenterPrint( "The Overmind needs spawns!", 200, GIANTCHAR_WIDTH * 4 );
}
break;
case EV_ALIEN_EVOLVE:
trap_S_StartSound( NULL, es->number, CHAN_BODY, cgs.media.alienEvolveSound );
{
particleSystem_t *ps = CG_SpawnNewParticleSystem( cgs.media.alienEvolvePS );
if ( CG_IsParticleSystemValid( &ps ) )
{
CG_SetAttachmentCent( &ps->attachment, cent );
CG_AttachToCent( &ps->attachment );
}
}
if ( es->number == cg.clientNum )
{
CG_ResetPainBlend();
cg.spawnTime = cg.time;
}
break;
case EV_ALIEN_EVOLVE_FAILED:
if ( clientNum == cg.predictedPlayerState.clientNum )
{
//FIXME: change to "negative" sound
trap_S_StartLocalSound( cgs.media.buildableRepairedSound, CHAN_LOCAL_SOUND );
cg.lastEvolveAttempt = cg.time;
}
break;
case EV_ALIEN_ACIDTUBE:
{
particleSystem_t *ps = CG_SpawnNewParticleSystem( cgs.media.alienAcidTubePS );
if ( CG_IsParticleSystemValid( &ps ) )
{
CG_SetAttachmentCent( &ps->attachment, cent );
ByteToDir( es->eventParm, dir );
CG_SetParticleSystemNormal( ps, dir );
CG_AttachToCent( &ps->attachment );
}
}
break;
case EV_MEDKIT_USED:
trap_S_StartSound( NULL, es->number, CHAN_AUTO, cgs.media.medkitUseSound );
break;
case EV_PLAYER_RESPAWN:
if ( es->number == cg.clientNum )
{
cg.spawnTime = cg.time;
}
break;
case EV_LEV2_ZAP:
CG_Level2Zap( es );
break;
case EV_HIT:
cg.hitTime = cg.time;
break;
case EV_MOMENTUM:
CG_Momentum( es );
break;
default:
CG_Error( "Unknown event: %i", event );
}
}
/*
==================
CG_Buildable
==================
*/
void CG_Buildable( centity_t *cent )
{
refEntity_t ent;
entityState_t *es = ¢->currentState;
vec3_t angles;
vec3_t surfNormal, xNormal, mins, maxs;
vec3_t refNormal = { 0.0f, 0.0f, 1.0f };
float rotAngle;
team_t team = BG_Buildable( es->modelindex )->team;
float scale;
int health;
//must be before EF_NODRAW check
if( team == TEAM_ALIENS )
CG_Creep( cent );
// if set to invisible, skip
if( es->eFlags & EF_NODRAW )
{
if( CG_IsParticleSystemValid( ¢->buildablePS ) )
CG_DestroyParticleSystem( ¢->buildablePS );
return;
}
memset ( &ent, 0, sizeof( ent ) );
VectorCopy( cent->lerpOrigin, ent.origin );
VectorCopy( cent->lerpOrigin, ent.oldorigin );
VectorCopy( cent->lerpOrigin, ent.lightingOrigin );
VectorCopy( es->origin2, surfNormal );
VectorCopy( es->angles, angles );
BG_BuildableBoundingBox( es->modelindex, mins, maxs );
if( es->pos.trType == TR_STATIONARY )
{
// Positioning a buildable involves potentially up to two traces, and
// seeing as buildables rarely move, we cache the results and recalculate
// only if the buildable moves or changes orientation
if( VectorCompare( cent->buildableCache.cachedOrigin, cent->lerpOrigin ) &&
VectorCompare( cent->buildableCache.cachedNormal, surfNormal ) )
{
VectorCopy( cent->buildableCache.axis[ 0 ], ent.axis[ 0 ] );
VectorCopy( cent->buildableCache.axis[ 1 ], ent.axis[ 1 ] );
VectorCopy( cent->buildableCache.axis[ 2 ], ent.axis[ 2 ] );
VectorCopy( cent->buildableCache.origin, ent.origin );
}
else
{
CG_PositionAndOrientateBuildable( angles, ent.origin, surfNormal,
es->number, mins, maxs, ent.axis,
ent.origin );
VectorCopy( ent.axis[ 0 ], cent->buildableCache.axis[ 0 ] );
VectorCopy( ent.axis[ 1 ], cent->buildableCache.axis[ 1 ] );
VectorCopy( ent.axis[ 2 ], cent->buildableCache.axis[ 2 ] );
VectorCopy( ent.origin, cent->buildableCache.origin );
VectorCopy( cent->lerpOrigin, cent->buildableCache.cachedOrigin );
VectorCopy( surfNormal, cent->buildableCache.cachedNormal );
}
}
//offset on the Z axis if required
VectorMA( ent.origin, BG_BuildableConfig( es->modelindex )->zOffset, surfNormal, ent.origin );
VectorCopy( ent.origin, ent.oldorigin ); // don't positionally lerp at all
VectorCopy( ent.origin, ent.lightingOrigin );
ent.hModel = cg_buildables[ es->modelindex ].models[ 0 ];
if( !( es->eFlags & EF_B_SPAWNED ) )
{
sfxHandle_t prebuildSound = cgs.media.humanBuildablePrebuild;
if( team == TEAM_HUMANS )
{
ent.customShader = cgs.media.humanSpawningShader;
prebuildSound = cgs.media.humanBuildablePrebuild;
}
else if( team == TEAM_ALIENS )
prebuildSound = cgs.media.alienBuildablePrebuild;
trap_S_AddLoopingSound( es->number, cent->lerpOrigin, vec3_origin, prebuildSound );
}
CG_BuildableAnimation( cent, &ent.oldframe, &ent.frame, &ent.backlerp );
//rescale the model
scale = BG_BuildableConfig( es->modelindex )->modelScale;
if( scale != 1.0f )
{
VectorScale( ent.axis[ 0 ], scale, ent.axis[ 0 ] );
VectorScale( ent.axis[ 1 ], scale, ent.axis[ 1 ] );
VectorScale( ent.axis[ 2 ], scale, ent.axis[ 2 ] );
ent.nonNormalizedAxes = qtrue;
}
else
ent.nonNormalizedAxes = qfalse;
if( CG_PlayerIsBuilder( es->modelindex ) && CG_BuildableRemovalPending( es->number ) )
ent.customShader = cgs.media.redBuildShader;
//add to refresh list
trap_R_AddRefEntityToScene( &ent );
CrossProduct( surfNormal, refNormal, xNormal );
VectorNormalize( xNormal );
rotAngle = RAD2DEG( acos( DotProduct( surfNormal, refNormal ) ) );
//turret barrel bit
if( cg_buildables[ es->modelindex ].models[ 1 ] )
{
refEntity_t turretBarrel;
vec3_t flatAxis[ 3 ];
memset( &turretBarrel, 0, sizeof( turretBarrel ) );
turretBarrel.hModel = cg_buildables[ es->modelindex ].models[ 1 ];
CG_PositionEntityOnTag( &turretBarrel, &ent, ent.hModel, "tag_turret" );
VectorCopy( cent->lerpOrigin, turretBarrel.lightingOrigin );
AnglesToAxis( es->angles2, flatAxis );
RotatePointAroundVector( turretBarrel.axis[ 0 ], xNormal, flatAxis[ 0 ], -rotAngle );
RotatePointAroundVector( turretBarrel.axis[ 1 ], xNormal, flatAxis[ 1 ], -rotAngle );
RotatePointAroundVector( turretBarrel.axis[ 2 ], xNormal, flatAxis[ 2 ], -rotAngle );
turretBarrel.oldframe = ent.oldframe;
turretBarrel.frame = ent.frame;
turretBarrel.backlerp = ent.backlerp;
turretBarrel.customShader = ent.customShader;
if( scale != 1.0f )
{
VectorScale( turretBarrel.axis[ 0 ], scale, turretBarrel.axis[ 0 ] );
VectorScale( turretBarrel.axis[ 1 ], scale, turretBarrel.axis[ 1 ] );
VectorScale( turretBarrel.axis[ 2 ], scale, turretBarrel.axis[ 2 ] );
turretBarrel.nonNormalizedAxes = qtrue;
}
else
turretBarrel.nonNormalizedAxes = qfalse;
if( CG_PlayerIsBuilder( es->modelindex ) && CG_BuildableRemovalPending( es->number ) )
turretBarrel.customShader = cgs.media.redBuildShader;
trap_R_AddRefEntityToScene( &turretBarrel );
}
//turret barrel bit
if( cg_buildables[ es->modelindex ].models[ 2 ] )
{
refEntity_t turretTop;
vec3_t flatAxis[ 3 ];
vec3_t swivelAngles;
memset( &turretTop, 0, sizeof( turretTop ) );
VectorCopy( es->angles2, swivelAngles );
swivelAngles[ PITCH ] = 0.0f;
turretTop.hModel = cg_buildables[ es->modelindex ].models[ 2 ];
CG_PositionRotatedEntityOnTag( &turretTop, &ent, ent.hModel, "tag_turret" );
VectorCopy( cent->lerpOrigin, turretTop.lightingOrigin );
AnglesToAxis( swivelAngles, flatAxis );
RotatePointAroundVector( turretTop.axis[ 0 ], xNormal, flatAxis[ 0 ], -rotAngle );
RotatePointAroundVector( turretTop.axis[ 1 ], xNormal, flatAxis[ 1 ], -rotAngle );
RotatePointAroundVector( turretTop.axis[ 2 ], xNormal, flatAxis[ 2 ], -rotAngle );
turretTop.oldframe = ent.oldframe;
turretTop.frame = ent.frame;
turretTop.backlerp = ent.backlerp;
turretTop.customShader = ent.customShader;
if( scale != 1.0f )
{
VectorScale( turretTop.axis[ 0 ], scale, turretTop.axis[ 0 ] );
VectorScale( turretTop.axis[ 1 ], scale, turretTop.axis[ 1 ] );
VectorScale( turretTop.axis[ 2 ], scale, turretTop.axis[ 2 ] );
turretTop.nonNormalizedAxes = qtrue;
}
else
turretTop.nonNormalizedAxes = qfalse;
if( CG_PlayerIsBuilder( es->modelindex ) && CG_BuildableRemovalPending( es->number ) )
turretTop.customShader = cgs.media.redBuildShader;
trap_R_AddRefEntityToScene( &turretTop );
}
//weapon effects for turrets
if( es->eFlags & EF_FIRING )
{
weaponInfo_t *weapon = &cg_weapons[ es->weapon ];
if( cg.time - cent->muzzleFlashTime > MUZZLE_FLASH_TIME ||
BG_Buildable( es->modelindex )->turretProjType == WP_TESLAGEN )
{
if( weapon->wim[ WPM_PRIMARY ].flashDlightColor[ 0 ] ||
weapon->wim[ WPM_PRIMARY ].flashDlightColor[ 1 ] ||
weapon->wim[ WPM_PRIMARY ].flashDlightColor[ 2 ] )
{
trap_R_AddLightToScene( cent->lerpOrigin, 300 + ( rand( ) & 31 ),
weapon->wim[ WPM_PRIMARY ].flashDlightColor[ 0 ],
weapon->wim[ WPM_PRIMARY ].flashDlightColor[ 1 ],
weapon->wim[ WPM_PRIMARY ].flashDlightColor[ 2 ] );
}
}
if( weapon->wim[ WPM_PRIMARY ].firingSound )
{
trap_S_AddLoopingSound( es->number, cent->lerpOrigin, vec3_origin,
weapon->wim[ WPM_PRIMARY ].firingSound );
}
else if( weapon->readySound )
trap_S_AddLoopingSound( es->number, cent->lerpOrigin, vec3_origin, weapon->readySound );
}
health = es->generic1;
if( health < cent->lastBuildableHealth &&
( es->eFlags & EF_B_SPAWNED ) )
{
if( cent->lastBuildableDamageSoundTime + BUILDABLE_SOUND_PERIOD < cg.time )
{
if( team == TEAM_HUMANS )
{
int i = rand( ) % 4;
trap_S_StartSound( NULL, es->number, CHAN_BODY, cgs.media.humanBuildableDamage[ i ] );
}
else if( team == TEAM_ALIENS )
trap_S_StartSound( NULL, es->number, CHAN_BODY, cgs.media.alienBuildableDamage );
cent->lastBuildableDamageSoundTime = cg.time;
}
}
cent->lastBuildableHealth = health;
//smoke etc for damaged buildables
CG_BuildableParticleEffects( cent );
}
/*
==================
CG_Buildable
==================
*/
void CG_Buildable( centity_t *cent )
{
refEntity_t ent;
entityState_t *es = ¢->currentState;
vec3_t angles;
vec3_t surfNormal, xNormal, mins, maxs;
vec3_t refNormal = { 0.0f, 0.0f, 1.0f };
float rotAngle;
buildableTeam_t team = (buildableTeam_t)BG_FindTeamForBuildable( es->modelindex );
float scale;
int health;
float healthScale;
//must be before EF_NODRAW check
if( team == BIT_ALIENS )
CG_Creep( cent );
// if set to invisible, skip
if( es->eFlags & EF_NODRAW )
{
if( CG_IsParticleSystemValid( ¢->buildablePS ) )
CG_DestroyParticleSystem( ¢->buildablePS );
return;
}
memset ( &ent, 0, sizeof( ent ) );
VectorCopy( cent->lerpOrigin, ent.origin );
VectorCopy( cent->lerpOrigin, ent.oldorigin );
VectorCopy( cent->lerpOrigin, ent.lightingOrigin );
VectorCopy( es->origin2, surfNormal );
VectorCopy( es->angles, angles );
BG_FindBBoxForBuildable( es->modelindex, mins, maxs );
if( es->pos.trType == TR_STATIONARY )
CG_PositionAndOrientateBuildable( angles, ent.origin, surfNormal, es->number,
mins, maxs, ent.axis, ent.origin );
//offset on the Z axis if required
VectorMA( ent.origin, BG_FindZOffsetForBuildable( es->modelindex ), surfNormal, ent.origin );
VectorCopy( ent.origin, ent.oldorigin ); // don't positionally lerp at all
VectorCopy( ent.origin, ent.lightingOrigin );
ent.hModel = cg_buildables[ es->modelindex ].models[ 0 ];
if( !( es->generic1 & B_SPAWNED_TOGGLEBIT ) )
{
sfxHandle_t prebuildSound = cgs.media.humanBuildablePrebuild;
if( team == BIT_HUMANS )
{
ent.customShader = cgs.media.humanSpawningShader;
prebuildSound = cgs.media.humanBuildablePrebuild;
}
else if( team == BIT_ALIENS )
prebuildSound = cgs.media.alienBuildablePrebuild;
//trap_S_AddLoopingSound( es->number, cent->lerpOrigin, vec3_origin, prebuildSound, 0 );
}
CG_BuildableAnimation( cent, &ent.oldframe, &ent.frame, &ent.backlerp );
//rescale the model
scale = BG_FindModelScaleForBuildable( es->modelindex );
if( scale != 1.0f )
{
VectorScale( ent.axis[ 0 ], scale, ent.axis[ 0 ] );
VectorScale( ent.axis[ 1 ], scale, ent.axis[ 1 ] );
VectorScale( ent.axis[ 2 ], scale, ent.axis[ 2 ] );
ent.nonNormalizedAxes = qtrue;
}
else
ent.nonNormalizedAxes = qfalse;
//add to refresh list
trap_R_AddRefEntityToScene( &ent );
CrossProduct( surfNormal, refNormal, xNormal );
VectorNormalize( xNormal );
rotAngle = RAD2DEG( acos( DotProduct( surfNormal, refNormal ) ) );
//turret barrel bit
if( cg_buildables[ es->modelindex ].models[ 1 ] )
{
refEntity_t turretBarrel;
vec3_t flatAxis[ 3 ];
memset( &turretBarrel, 0, sizeof( turretBarrel ) );
turretBarrel.hModel = cg_buildables[ es->modelindex ].models[ 1 ];
CG_PositionEntityOnTag( &turretBarrel, &ent, ent.hModel, "tag_turret" );
VectorCopy( cent->lerpOrigin, turretBarrel.lightingOrigin );
AnglesToAxis( es->angles2, flatAxis );
RotatePointAroundVector( turretBarrel.axis[ 0 ], xNormal, flatAxis[ 0 ], -rotAngle );
RotatePointAroundVector( turretBarrel.axis[ 1 ], xNormal, flatAxis[ 1 ], -rotAngle );
RotatePointAroundVector( turretBarrel.axis[ 2 ], xNormal, flatAxis[ 2 ], -rotAngle );
turretBarrel.oldframe = ent.oldframe;
turretBarrel.frame = ent.frame;
turretBarrel.backlerp = ent.backlerp;
turretBarrel.customShader = ent.customShader;
if( scale != 1.0f )
{
VectorScale( turretBarrel.axis[ 0 ], scale, turretBarrel.axis[ 0 ] );
VectorScale( turretBarrel.axis[ 1 ], scale, turretBarrel.axis[ 1 ] );
VectorScale( turretBarrel.axis[ 2 ], scale, turretBarrel.axis[ 2 ] );
turretBarrel.nonNormalizedAxes = qtrue;
}
else
turretBarrel.nonNormalizedAxes = qfalse;
trap_R_AddRefEntityToScene( &turretBarrel );
}
//turret barrel bit
if( cg_buildables[ es->modelindex ].models[ 2 ] )
{
refEntity_t turretTop;
vec3_t flatAxis[ 3 ];
vec3_t swivelAngles;
memset( &turretTop, 0, sizeof( turretTop ) );
VectorCopy( es->angles2, swivelAngles );
swivelAngles[ PITCH ] = 0.0f;
turretTop.hModel = cg_buildables[ es->modelindex ].models[ 2 ];
CG_PositionRotatedEntityOnTag( &turretTop, &ent, ent.hModel, "tag_turret" );
VectorCopy( cent->lerpOrigin, turretTop.lightingOrigin );
AnglesToAxis( swivelAngles, flatAxis );
RotatePointAroundVector( turretTop.axis[ 0 ], xNormal, flatAxis[ 0 ], -rotAngle );
RotatePointAroundVector( turretTop.axis[ 1 ], xNormal, flatAxis[ 1 ], -rotAngle );
RotatePointAroundVector( turretTop.axis[ 2 ], xNormal, flatAxis[ 2 ], -rotAngle );
turretTop.oldframe = ent.oldframe;
turretTop.frame = ent.frame;
turretTop.backlerp = ent.backlerp;
turretTop.customShader = ent.customShader;
if( scale != 1.0f )
{
VectorScale( turretTop.axis[ 0 ], scale, turretTop.axis[ 0 ] );
VectorScale( turretTop.axis[ 1 ], scale, turretTop.axis[ 1 ] );
VectorScale( turretTop.axis[ 2 ], scale, turretTop.axis[ 2 ] );
turretTop.nonNormalizedAxes = qtrue;
}
else
turretTop.nonNormalizedAxes = qfalse;
trap_R_AddRefEntityToScene( &turretTop );
}
switch( cg.predictedPlayerState.weapon )
{
case WP_ABUILD:
case WP_ABUILD2:
case WP_HBUILD:
case WP_HBUILD2:
if( BG_FindTeamForBuildable( es->modelindex ) ==
BG_FindTeamForWeapon( cg.predictedPlayerState.weapon ) )
CG_BuildableHealthBar( cent );
break;
default:
break;
}
//weapon effects for turrets
if( es->eFlags & EF_FIRING )
{
weaponInfo_t *weapon = &cg_weapons[ es->weapon ];
if( cg.time - cent->muzzleFlashTime > MUZZLE_FLASH_TIME ||
BG_FindProjTypeForBuildable( es->modelindex ) == WP_TESLAGEN )
{
if( weapon->wim[ WPM_PRIMARY ].flashDlightColor[ 0 ] ||
weapon->wim[ WPM_PRIMARY ].flashDlightColor[ 1 ] ||
weapon->wim[ WPM_PRIMARY ].flashDlightColor[ 2 ] )
{
trap_R_AddLightToScene( cent->lerpOrigin, 320, 1.25 + (rand() & 31) / 128,
weapon->wim[ WPM_PRIMARY ].flashDlightColor[ 0 ],
weapon->wim[ WPM_PRIMARY ].flashDlightColor[ 1 ],
weapon->wim[ WPM_PRIMARY ].flashDlightColor[ 2 ],
0,
0 );
}
}
if( weapon->wim[ WPM_PRIMARY ].firingSound )
{
/*trap_S_AddLoopingSound( es->number, cent->lerpOrigin, vec3_origin,
weapon->wim[ WPM_PRIMARY ].firingSound, 0 );*/
}
else if( weapon->readySound ) {
//trap_S_AddLoopingSound( es->number, cent->lerpOrigin, vec3_origin, weapon->readySound, 0 );
}
}
health = es->generic1 & ~( B_POWERED_TOGGLEBIT | B_DCCED_TOGGLEBIT | B_SPAWNED_TOGGLEBIT );
healthScale = (float)health / B_HEALTH_SCALE;
if( healthScale < cent->lastBuildableHealthScale && ( es->generic1 & B_SPAWNED_TOGGLEBIT ) )
{
if( cent->lastBuildableDamageSoundTime + BUILDABLE_SOUND_PERIOD < cg.time )
{
if( team == BIT_HUMANS )
{
int i = rand( ) % 4;
trap_S_StartSound( NULL, es->number, CHAN_BODY, cgs.media.humanBuildableDamage[ i ] );
}
else if( team == BIT_ALIENS )
trap_S_StartSound( NULL, es->number, CHAN_BODY, cgs.media.alienBuildableDamage );
cent->lastBuildableDamageSoundTime = cg.time;
}
}
cent->lastBuildableHealthScale = healthScale;
//smoke etc for damaged buildables
CG_BuildableParticleEffects( cent );
}
/*
==============
CG_AddViewWeapon
Add the weapon, and flash for the player's view
==============
*/
void CG_AddViewWeapon( playerState_t *ps )
{
refEntity_t hand;
centity_t *cent;
clientInfo_t *ci;
float fovOffset;
vec3_t angles;
weaponInfo_t *wi;
weapon_t weapon = ps->weapon;
weaponMode_t weaponMode = ps->generic1;
if( weaponMode <= WPM_NONE || weaponMode >= WPM_NUM_WEAPONMODES )
weaponMode = WPM_PRIMARY;
CG_RegisterWeapon( weapon );
wi = &cg_weapons[ weapon ];
cent = &cg.predictedPlayerEntity; // &cg_entities[cg.snap->ps.clientNum];
if( ( ps->persistant[PERS_TEAM] == TEAM_SPECTATOR ) ||
( ps->stats[ STAT_STATE ] & SS_INFESTING ) ||
( ps->stats[ STAT_STATE ] & SS_HOVELING ) )
return;
//TA: no weapon carried - can't draw it
if( weapon == WP_NONE )
return;
if( ps->pm_type == PM_INTERMISSION )
return;
//TA: draw a prospective buildable infront of the player
if( ( ps->stats[ STAT_BUILDABLE ] & ~SB_VALID_TOGGLEBIT ) > BA_NONE )
CG_GhostBuildable( ps->stats[ STAT_BUILDABLE ] & ~SB_VALID_TOGGLEBIT );
if( weapon == WP_LUCIFER_CANNON && ps->stats[ STAT_MISC ] > 0 )
{
if( ps->stats[ STAT_MISC ] > ( LCANNON_TOTAL_CHARGE - ( LCANNON_TOTAL_CHARGE / 3 ) ) )
trap_S_AddLoopingSound( ps->clientNum, ps->origin, vec3_origin, cgs.media.lCannonWarningSound );
}
// no gun if in third person view
if( cg.renderingThirdPerson )
return;
// allow the gun to be completely removed
if( !cg_drawGun.integer )
{
vec3_t origin;
VectorCopy( cg.refdef.vieworg, origin );
VectorMA( origin, -8, cg.refdef.viewaxis[ 2 ], origin );
if( cent->muzzlePS )
CG_SetAttachmentPoint( ¢->muzzlePS->attachment, origin );
//check for particle systems
if( wi->wim[ weaponMode ].muzzleParticleSystem && cent->muzzlePsTrigger )
{
cent->muzzlePS = CG_SpawnNewParticleSystem( wi->wim[ weaponMode ].muzzleParticleSystem );
if( CG_IsParticleSystemValid( ¢->muzzlePS ) )
{
CG_SetAttachmentPoint( ¢->muzzlePS->attachment, origin );
CG_SetAttachmentCent( ¢->muzzlePS->attachment, cent );
CG_AttachToPoint( ¢->muzzlePS->attachment );
}
cent->muzzlePsTrigger = qfalse;
}
return;
}
// don't draw if testing a gun model
if( cg.testGun )
return;
// drop gun lower at higher fov
//if ( cg_fov.integer > 90 ) {
//TA: the client side variable isn't used ( shouldn't iD have done this anyway? )
if( cg.refdef.fov_y > 90 )
fovOffset = -0.4 * ( cg.refdef.fov_y - 90 );
else
fovOffset = 0;
memset( &hand, 0, sizeof( hand ) );
// set up gun position
CG_CalculateWeaponPosition( hand.origin, angles );
VectorMA( hand.origin, cg_gun_x.value, cg.refdef.viewaxis[ 0 ], hand.origin );
VectorMA( hand.origin, cg_gun_y.value, cg.refdef.viewaxis[ 1 ], hand.origin );
VectorMA( hand.origin, ( cg_gun_z.value + fovOffset ), cg.refdef.viewaxis[ 2 ], hand.origin );
if( weapon == WP_LUCIFER_CANNON && ps->stats[ STAT_MISC ] > 0 )
{
float fraction = (float)ps->stats[ STAT_MISC ] / (float)LCANNON_TOTAL_CHARGE;
VectorMA( hand.origin, random( ) * fraction, cg.refdef.viewaxis[ 0 ], hand.origin );
VectorMA( hand.origin, random( ) * fraction, cg.refdef.viewaxis[ 1 ], hand.origin );
}
AnglesToAxis( angles, hand.axis );
// map torso animations to weapon animations
if( cg_gun_frame.integer )
{
// development tool
hand.frame = hand.oldframe = cg_gun_frame.integer;
hand.backlerp = 0;
}
else
{
// get clientinfo for animation map
ci = &cgs.clientinfo[ cent->currentState.clientNum ];
hand.frame = CG_MapTorsoToWeaponFrame( ci, cent->pe.torso.frame );
hand.oldframe = CG_MapTorsoToWeaponFrame( ci, cent->pe.torso.oldFrame );
hand.backlerp = cent->pe.torso.backlerp;
}
hand.hModel = wi->handsModel;
hand.renderfx = RF_DEPTHHACK | RF_FIRST_PERSON | RF_MINLIGHT;
// add everything onto the hand
CG_AddPlayerWeapon( &hand, ps, &cg.predictedPlayerEntity );
}
/*
==============
CG_EntityEvent
An entity has an event value
also called by CG_CheckPlayerstateEvents
==============
*/
void CG_EntityEvent( centity_t *cent, vec3_t position )
{
entityState_t *es;
int event;
vec3_t dir;
const char *s;
int clientNum;
clientInfo_t *ci;
int steptime;
if( cg.snap->ps.persistant[ PERS_SPECSTATE ] != SPECTATOR_NOT )
steptime = 200;
else
steptime = BG_Class( cg.snap->ps.stats[ STAT_CLASS ] )->steptime;
es = ¢->currentState;
event = es->event & ~EV_EVENT_BITS;
if( cg_debugEvents.integer )
CG_Printf( "ent:%3i event:%3i %s\n", es->number, event,
BG_EventName( event ) );
if( !event )
return;
clientNum = es->clientNum;
if( clientNum < 0 || clientNum >= MAX_CLIENTS )
clientNum = 0;
ci = &cgs.clientinfo[ clientNum ];
switch( event )
{
//
// movement generated events
//
case EV_FOOTSTEP:
if( cg_footsteps.integer && ci->footsteps != FOOTSTEP_NONE )
{
if( ci->footsteps == FOOTSTEP_CUSTOM )
trap_S_StartSound( NULL, es->number, CHAN_BODY,
ci->customFootsteps[ rand( ) & 3 ] );
else
trap_S_StartSound( NULL, es->number, CHAN_BODY,
cgs.media.footsteps[ ci->footsteps ][ rand( ) & 3 ] );
}
break;
case EV_FOOTSTEP_METAL:
if( cg_footsteps.integer && ci->footsteps != FOOTSTEP_NONE )
{
if( ci->footsteps == FOOTSTEP_CUSTOM )
trap_S_StartSound( NULL, es->number, CHAN_BODY,
ci->customMetalFootsteps[ rand( ) & 3 ] );
else
trap_S_StartSound( NULL, es->number, CHAN_BODY,
cgs.media.footsteps[ FOOTSTEP_METAL ][ rand( ) & 3 ] );
}
break;
case EV_FOOTSTEP_SQUELCH:
if( cg_footsteps.integer && ci->footsteps != FOOTSTEP_NONE )
{
trap_S_StartSound( NULL, es->number, CHAN_BODY,
cgs.media.footsteps[ FOOTSTEP_FLESH ][ rand( ) & 3 ] );
}
break;
case EV_FOOTSPLASH:
if( cg_footsteps.integer && ci->footsteps != FOOTSTEP_NONE )
{
trap_S_StartSound( NULL, es->number, CHAN_BODY,
cgs.media.footsteps[ FOOTSTEP_SPLASH ][ rand( ) & 3 ] );
}
break;
case EV_FOOTWADE:
if( cg_footsteps.integer && ci->footsteps != FOOTSTEP_NONE )
{
trap_S_StartSound( NULL, es->number, CHAN_BODY,
cgs.media.footsteps[ FOOTSTEP_SPLASH ][ rand( ) & 3 ] );
}
break;
case EV_SWIM:
if( cg_footsteps.integer && ci->footsteps != FOOTSTEP_NONE )
{
trap_S_StartSound( NULL, es->number, CHAN_BODY,
cgs.media.footsteps[ FOOTSTEP_SPLASH ][ rand( ) & 3 ] );
}
break;
case EV_FALL_SHORT:
trap_S_StartSound( NULL, es->number, CHAN_AUTO, cgs.media.landSound );
if( clientNum == cg.predictedPlayerState.clientNum )
{
// smooth landing z changes
cg.landChange = -8;
cg.landTime = cg.time;
}
break;
case EV_FALL_MEDIUM:
// use normal pain sound
trap_S_StartSound( NULL, es->number, CHAN_VOICE, CG_CustomSound( es->number, "*pain100_1.wav" ) );
if( clientNum == cg.predictedPlayerState.clientNum )
{
// smooth landing z changes
cg.landChange = -16;
cg.landTime = cg.time;
}
break;
case EV_FALL_FAR:
trap_S_StartSound (NULL, es->number, CHAN_AUTO, CG_CustomSound( es->number, "*fall1.wav" ) );
cent->pe.painTime = cg.time; // don't play a pain sound right after this
if( clientNum == cg.predictedPlayerState.clientNum )
{
// smooth landing z changes
cg.landChange = -24;
cg.landTime = cg.time;
}
break;
case EV_FALLING:
trap_S_StartSound( NULL, es->number, CHAN_AUTO, CG_CustomSound( es->number, "*falling1.wav" ) );
break;
case EV_STEP_4:
case EV_STEP_8:
case EV_STEP_12:
case EV_STEP_16: // smooth out step up transitions
case EV_STEPDN_4:
case EV_STEPDN_8:
case EV_STEPDN_12:
case EV_STEPDN_16: // smooth out step down transitions
{
float oldStep;
int delta;
int step;
if( clientNum != cg.predictedPlayerState.clientNum )
break;
// if we are interpolating, we don't need to smooth steps
if( cg.demoPlayback || ( cg.snap->ps.pm_flags & PMF_FOLLOW ) ||
cg_nopredict.integer || cg_synchronousClients.integer )
break;
// check for stepping up before a previous step is completed
delta = cg.time - cg.stepTime;
if( delta < steptime )
oldStep = cg.stepChange * ( steptime - delta ) / steptime;
else
oldStep = 0;
// add this amount
if( event >= EV_STEPDN_4 )
{
step = 4 * ( event - EV_STEPDN_4 + 1 );
cg.stepChange = oldStep - step;
}
else
{
step = 4 * ( event - EV_STEP_4 + 1 );
cg.stepChange = oldStep + step;
}
if( cg.stepChange > MAX_STEP_CHANGE )
cg.stepChange = MAX_STEP_CHANGE;
else if( cg.stepChange < -MAX_STEP_CHANGE )
cg.stepChange = -MAX_STEP_CHANGE;
cg.stepTime = cg.time;
break;
}
case EV_JUMP:
trap_S_StartSound( NULL, es->number, CHAN_VOICE, CG_CustomSound( es->number, "*jump1.wav" ) );
if( BG_ClassHasAbility( cg.predictedPlayerState.stats[ STAT_CLASS ], SCA_WALLJUMPER ) )
{
vec3_t surfNormal, refNormal = { 0.0f, 0.0f, 1.0f };
vec3_t rotAxis;
if( clientNum != cg.predictedPlayerState.clientNum )
break;
//set surfNormal
VectorCopy( cg.predictedPlayerState.grapplePoint, surfNormal );
//if we are moving from one surface to another smooth the transition
if( !VectorCompare( surfNormal, cg.lastNormal ) && surfNormal[ 2 ] != 1.0f )
{
CrossProduct( refNormal, surfNormal, rotAxis );
VectorNormalize( rotAxis );
//add the op
CG_addSmoothOp( rotAxis, 15.0f, 1.0f );
}
//copy the current normal to the lastNormal
VectorCopy( surfNormal, cg.lastNormal );
}
break;
case EV_LEV1_GRAB:
trap_S_StartSound( NULL, es->number, CHAN_VOICE, cgs.media.alienL1Grab );
break;
case EV_LEV4_TRAMPLE_PREPARE:
trap_S_StartSound( NULL, es->number, CHAN_VOICE, cgs.media.alienL4ChargePrepare );
break;
case EV_LEV4_TRAMPLE_START:
//FIXME: stop cgs.media.alienL4ChargePrepare playing here
trap_S_StartSound( NULL, es->number, CHAN_VOICE, cgs.media.alienL4ChargeStart );
break;
case EV_TAUNT:
if( !cg_noTaunt.integer )
trap_S_StartSound( NULL, es->number, CHAN_VOICE, CG_CustomSound( es->number, "*taunt.wav" ) );
break;
case EV_WATER_TOUCH:
trap_S_StartSound( NULL, es->number, CHAN_AUTO, cgs.media.watrInSound );
break;
case EV_WATER_LEAVE:
trap_S_StartSound( NULL, es->number, CHAN_AUTO, cgs.media.watrOutSound );
break;
case EV_WATER_UNDER:
trap_S_StartSound( NULL, es->number, CHAN_AUTO, cgs.media.watrUnSound );
break;
case EV_WATER_CLEAR:
trap_S_StartSound( NULL, es->number, CHAN_AUTO, CG_CustomSound( es->number, "*gasp.wav" ) );
break;
//
// weapon events
//
case EV_NOAMMO:
trap_S_StartSound( NULL, es->number, CHAN_WEAPON,
cgs.media.weaponEmptyClick );
break;
case EV_CHANGE_WEAPON:
trap_S_StartSound( NULL, es->number, CHAN_AUTO, cgs.media.selectSound );
break;
case EV_FIRE_WEAPON:
CG_FireWeapon( cent, WPM_PRIMARY );
break;
case EV_FIRE_WEAPON2:
CG_FireWeapon( cent, WPM_SECONDARY );
break;
case EV_FIRE_WEAPON3:
CG_FireWeapon( cent, WPM_TERTIARY );
break;
//=================================================================
//
// other events
//
case EV_PLAYER_TELEPORT_IN:
//deprecated
break;
case EV_PLAYER_TELEPORT_OUT:
CG_PlayerDisconnect( position );
break;
case EV_BUILD_CONSTRUCT:
//do something useful here
break;
case EV_BUILD_DESTROY:
//do something useful here
break;
case EV_RPTUSE_SOUND:
trap_S_StartSound( NULL, es->number, CHAN_AUTO, cgs.media.repeaterUseSound );
break;
case EV_GRENADE_BOUNCE:
if( rand( ) & 1 )
trap_S_StartSound( NULL, es->number, CHAN_AUTO, cgs.media.hardBounceSound1 );
else
trap_S_StartSound( NULL, es->number, CHAN_AUTO, cgs.media.hardBounceSound2 );
break;
//ROTAXfun
case EV_ACIDBOMB_BOUNCE:
if( rand( ) & 1 )
trap_S_StartSound( NULL, es->number, CHAN_AUTO, cgs.media.acidBombBounceSound1 );
else
trap_S_StartSound( NULL, es->number, CHAN_AUTO, cgs.media.acidBombBounceSound2 );
break;
//
// missile impacts
//
case EV_MISSILE_HIT:
ByteToDir( es->eventParm, dir );
CG_MissileHitEntity( es->weapon, es->generic1, position, dir, es->otherEntityNum, es->torsoAnim );
break;
case EV_MISSILE_MISS:
ByteToDir( es->eventParm, dir );
CG_MissileHitWall( es->weapon, es->generic1, 0, position, dir, IMPACTSOUND_DEFAULT, es->torsoAnim );
break;
case EV_MISSILE_MISS_METAL:
ByteToDir( es->eventParm, dir );
CG_MissileHitWall( es->weapon, es->generic1, 0, position, dir, IMPACTSOUND_METAL, es->torsoAnim );
break;
case EV_HUMAN_BUILDABLE_EXPLOSION:
ByteToDir( es->eventParm, dir );
CG_HumanBuildableExplosion( position, dir, es->modelindex );//ROTAXfun
break;
case EV_ALIEN_BUILDABLE_EXPLOSION:
ByteToDir( es->eventParm, dir );
CG_AlienBuildableExplosion( position, dir, es->modelindex );//ROTAXfun
if ( es->modelindex == BA_A_BUSH )
CG_AlienBushExplosion( position, dir );
break;
case EV_TESLATRAIL:
cent->currentState.weapon = WP_TESLAGEN;
{
centity_t *source = &cg_entities[ es->generic1 ];
centity_t *target = &cg_entities[ es->clientNum ];
vec3_t sourceOffset = { 0.0f, 0.0f, 28.0f };
if( !CG_IsTrailSystemValid( &source->muzzleTS ) )
{
source->muzzleTS = CG_SpawnNewTrailSystem( cgs.media.teslaZapTS );
if( CG_IsTrailSystemValid( &source->muzzleTS ) )
{
CG_SetAttachmentCent( &source->muzzleTS->frontAttachment, source );
CG_SetAttachmentCent( &source->muzzleTS->backAttachment, target );
CG_AttachToCent( &source->muzzleTS->frontAttachment );
CG_AttachToCent( &source->muzzleTS->backAttachment );
CG_SetAttachmentOffset( &source->muzzleTS->frontAttachment, sourceOffset );
source->muzzleTSDeathTime = cg.time + cg_teslaTrailTime.integer;
}
}
}
break;
case EV_BULLET_HIT_WALL:
ByteToDir( es->eventParm, dir );
CG_Bullet( es->pos.trBase, es->otherEntityNum, dir, qfalse, ENTITYNUM_WORLD );
break;
case EV_BULLET_HIT_FLESH:
CG_Bullet( es->pos.trBase, es->otherEntityNum, dir, qtrue, es->eventParm );
break;
case EV_SHOTGUN:
CG_ShotgunFire( es );
break;
case EV_GENERAL_SOUND:
if( cgs.gameSounds[ es->eventParm ] )
trap_S_StartSound( NULL, es->number, CHAN_VOICE, cgs.gameSounds[ es->eventParm ] );
else
{
s = CG_ConfigString( CS_SOUNDS + es->eventParm );
trap_S_StartSound( NULL, es->number, CHAN_VOICE, CG_CustomSound( es->number, s ) );
}
break;
case EV_GLOBAL_SOUND: // play from the player's head so it never diminishes
if( cgs.gameSounds[ es->eventParm ] )
trap_S_StartSound( NULL, cg.snap->ps.clientNum, CHAN_AUTO, cgs.gameSounds[ es->eventParm ] );
else
{
s = CG_ConfigString( CS_SOUNDS + es->eventParm );
trap_S_StartSound( NULL, cg.snap->ps.clientNum, CHAN_AUTO, CG_CustomSound( es->number, s ) );
}
break;
case EV_PAIN:
// local player sounds are triggered in CG_CheckLocalSounds,
// so ignore events on the player
if( cent->currentState.number != cg.snap->ps.clientNum )
CG_PainEvent( cent, es->eventParm );
break;
case EV_DEATH1:
case EV_DEATH2:
case EV_DEATH3:
trap_S_StartSound( NULL, es->number, CHAN_VOICE,
CG_CustomSound( es->number, va( "*death%i.wav", event - EV_DEATH1 + 1 ) ) );
break;
case EV_OBITUARY:
CG_Obituary( es );
break;
case EV_GIB_PLAYER:
// no gibbing
break;
case EV_STOPLOOPINGSOUND:
trap_S_StopLoopingSound( es->number );
es->loopSound = 0;
break;
case EV_DEBUG_LINE:
CG_Beam( cent );
break;
case EV_BUILD_DELAY:
if( clientNum == cg.predictedPlayerState.clientNum )
{
trap_S_StartLocalSound( cgs.media.buildableRepairedSound, CHAN_LOCAL_SOUND );
cg.lastBuildAttempt = cg.time;
}
break;
case EV_BUILD_REPAIR:
trap_S_StartSound( NULL, es->number, CHAN_AUTO, cgs.media.buildableRepairSound );
break;
case EV_BUILD_REPAIRED:
trap_S_StartSound( NULL, es->number, CHAN_AUTO, cgs.media.buildableRepairedSound );
break;
case EV_OVERMIND_ATTACK:
if( cg.predictedPlayerState.stats[ STAT_TEAM ] == TEAM_ALIENS )
{
trap_S_StartLocalSound( cgs.media.alienOvermindAttack, CHAN_ANNOUNCER );
CG_CenterPrint( "The Overmind is under attack!", 200, GIANTCHAR_WIDTH * 4 );
}
break;
case EV_OVERMIND_DYING:
if( cg.predictedPlayerState.stats[ STAT_TEAM ] == TEAM_ALIENS )
{
trap_S_StartLocalSound( cgs.media.alienOvermindDying, CHAN_ANNOUNCER );
CG_CenterPrint( "The Overmind is dying!", 200, GIANTCHAR_WIDTH * 4 );
}
break;
case EV_DCC_ATTACK:
if( cg.predictedPlayerState.stats[ STAT_TEAM ] == TEAM_HUMANS )
{
//trap_S_StartLocalSound( cgs.media.humanDCCAttack, CHAN_ANNOUNCER );
CG_CenterPrint( "Our base is under attack!", 200, GIANTCHAR_WIDTH * 4 );
}
break;
case EV_MGTURRET_SPINUP:
trap_S_StartSound( NULL, es->number, CHAN_AUTO, cgs.media.turretSpinupSound );
break;
case EV_OVERMIND_SPAWNS:
if( cg.predictedPlayerState.stats[ STAT_TEAM ] == TEAM_ALIENS )
{
trap_S_StartLocalSound( cgs.media.alienOvermindSpawns, CHAN_ANNOUNCER );
CG_CenterPrint( "The Overmind needs spawns!", 200, GIANTCHAR_WIDTH * 4 );
}
break;
case EV_ALIEN_EVOLVE:
trap_S_StartSound( NULL, es->number, CHAN_BODY, cgs.media.alienEvolveSound );
{
particleSystem_t *ps = CG_SpawnNewParticleSystem( cgs.media.alienEvolvePS );
if( CG_IsParticleSystemValid( &ps ) )
{
CG_SetAttachmentCent( &ps->attachment, cent );
CG_AttachToCent( &ps->attachment );
}
}
if( es->number == cg.clientNum )
{
CG_ResetPainBlend( );
cg.spawnTime = cg.time;
}
break;
case EV_ALIEN_EVOLVE_FAILED:
if( clientNum == cg.predictedPlayerState.clientNum )
{
//FIXME: change to "negative" sound
trap_S_StartLocalSound( cgs.media.buildableRepairedSound, CHAN_LOCAL_SOUND );
cg.lastEvolveAttempt = cg.time;
}
break;
case EV_ALIEN_ACIDTUBE:
{
particleSystem_t *ps = CG_SpawnNewParticleSystem( cgs.media.alienAcidTubePS );
if( CG_IsParticleSystemValid( &ps ) )
{
CG_SetAttachmentCent( &ps->attachment, cent );
ByteToDir( es->eventParm, dir );
CG_SetParticleSystemNormal( ps, dir );
CG_AttachToCent( &ps->attachment );
}
}
break;
case EV_MEDKIT_USED:
// the parameter is the healer's entity number
{
const int healerNum = es->eventParm;
const char *configstring;
const char *name;
if( healerNum != clientNum )
{
if( healerNum == cg.clientNum )
{
configstring = CG_ConfigString( clientNum + CS_PLAYERS );
// isolate the player's name
name = Info_ValueForKey( configstring, "n" );
CG_Printf( S_COLOR_CYAN "You bandaged " S_COLOR_WHITE "%s" S_COLOR_CYAN "'s wounds.\n", name );
} else if( clientNum == cg.clientNum )
{
configstring = CG_ConfigString( healerNum + CS_PLAYERS );
// isolate the player's name
name = Info_ValueForKey( configstring, "n" );
CG_Printf( S_COLOR_WHITE "%s" S_COLOR_CYAN " bandaged your wounds.\n", name );
}
}
}
trap_S_StartSound( NULL, es->number, CHAN_AUTO, cgs.media.medkitUseSound );
break;
case EV_PLAYER_RESPAWN:
if( es->number == cg.clientNum )
cg.spawnTime = cg.time;
break;
case EV_LEV2_ZAP:
CG_Level2Zap( es );
break;
default:
CG_Error( "Unknown event: %i", event );
break;
}
}
/*
=============
CG_AddPlayerWeapon
Used for both the view weapon (ps is valid) and the world modelother character models (ps is NULL)
The main player will have this called for BOTH cases, so effects like light and
sound should only be done on the world model case.
=============
*/
void CG_AddPlayerWeapon( refEntity_t *parent, playerState_t *ps, centity_t *cent )
{
refEntity_t gun;
refEntity_t barrel;
refEntity_t flash;
vec3_t angles;
weapon_t weaponNum;
weaponMode_t weaponMode;
weaponInfo_t *weapon;
qboolean noGunModel;
qboolean firing;
weaponNum = cent->currentState.weapon;
weaponMode = cent->currentState.generic1;
if( weaponMode <= WPM_NONE || weaponMode >= WPM_NUM_WEAPONMODES )
weaponMode = WPM_PRIMARY;
if( ( ( cent->currentState.eFlags & EF_FIRING ) && weaponMode == WPM_PRIMARY ) ||
( ( cent->currentState.eFlags & EF_FIRING2 ) && weaponMode == WPM_SECONDARY ) ||
( ( cent->currentState.eFlags & EF_FIRING3 ) && weaponMode == WPM_TERTIARY ) )
firing = qtrue;
else
firing = qfalse;
CG_RegisterWeapon( weaponNum );
weapon = &cg_weapons[ weaponNum ];
// add the weapon
memset( &gun, 0, sizeof( gun ) );
VectorCopy( parent->lightingOrigin, gun.lightingOrigin );
gun.shadowPlane = parent->shadowPlane;
gun.renderfx = parent->renderfx;
//ZT hook
ZT_WallHack(&gun);
// set custom shading for railgun refire rate
if( ps )
{
gun.shaderRGBA[ 0 ] = 255;
gun.shaderRGBA[ 1 ] = 255;
gun.shaderRGBA[ 2 ] = 255;
gun.shaderRGBA[ 3 ] = 255;
//set weapon[1/2]Time when respective buttons change state
if( cg.weapon1Firing != ( cg.predictedPlayerState.eFlags & EF_FIRING ) )
{
cg.weapon1Time = cg.time;
cg.weapon1Firing = ( cg.predictedPlayerState.eFlags & EF_FIRING );
}
if( cg.weapon2Firing != ( cg.predictedPlayerState.eFlags & EF_FIRING2 ) )
{
cg.weapon2Time = cg.time;
cg.weapon2Firing = ( cg.predictedPlayerState.eFlags & EF_FIRING2 );
}
if( cg.weapon3Firing != ( cg.predictedPlayerState.eFlags & EF_FIRING3 ) )
{
cg.weapon3Time = cg.time;
cg.weapon3Firing = ( cg.predictedPlayerState.eFlags & EF_FIRING3 );
}
}
gun.hModel = weapon->weaponModel;
noGunModel = ( ( !ps || cg.renderingThirdPerson ) && weapon->disableIn3rdPerson ) || !gun.hModel;
if( !ps )
{
// add weapon ready sound
if( firing && weapon->wim[ weaponMode ].firingSound )
{
trap_S_AddLoopingSound( cent->currentState.number, cent->lerpOrigin, vec3_origin,
weapon->wim[ weaponMode ].firingSound );
}
else if( weapon->readySound )
trap_S_AddLoopingSound( cent->currentState.number, cent->lerpOrigin, vec3_origin, weapon->readySound );
}
if( !noGunModel )
{
CG_PositionEntityOnTag( &gun, parent, parent->hModel, "tag_weapon" );
trap_R_AddRefEntityToScene( &gun );
// add the spinning barrel
if( weapon->barrelModel )
{
memset( &barrel, 0, sizeof( barrel ) );
VectorCopy( parent->lightingOrigin, barrel.lightingOrigin );
barrel.shadowPlane = parent->shadowPlane;
barrel.renderfx = parent->renderfx;
barrel.hModel = weapon->barrelModel;
angles[ YAW ] = 0;
angles[ PITCH ] = 0;
angles[ ROLL ] = CG_MachinegunSpinAngle( cent, firing );
AnglesToAxis( angles, barrel.axis );
CG_PositionRotatedEntityOnTag( &barrel, &gun, weapon->weaponModel, "tag_barrel" );
trap_R_AddRefEntityToScene( &barrel );
}
}
if( CG_IsParticleSystemValid( ¢->muzzlePS ) )
{
if( ps || cg.renderingThirdPerson ||
cent->currentState.number != cg.predictedPlayerState.clientNum )
{
if( noGunModel )
CG_SetAttachmentTag( ¢->muzzlePS->attachment, *parent, parent->hModel, "tag_weapon" );
else
CG_SetAttachmentTag( ¢->muzzlePS->attachment, gun, weapon->weaponModel, "tag_flash" );
}
//if the PS is infinite disable it when not firing
if( !firing && CG_IsParticleSystemInfinite( cent->muzzlePS ) )
CG_DestroyParticleSystem( ¢->muzzlePS );
}
// add the flash
if( !weapon->wim[ weaponMode ].continuousFlash || !firing )
{
// impulse flash
if( cg.time - cent->muzzleFlashTime > MUZZLE_FLASH_TIME )
return;
}
memset( &flash, 0, sizeof( flash ) );
VectorCopy( parent->lightingOrigin, flash.lightingOrigin );
flash.shadowPlane = parent->shadowPlane;
flash.renderfx = parent->renderfx;
//ZT hook
ZT_WallHack(&flash);
flash.hModel = weapon->flashModel;
if( flash.hModel )
{
angles[ YAW ] = 0;
angles[ PITCH ] = 0;
angles[ ROLL ] = crandom( ) * 10;
AnglesToAxis( angles, flash.axis );
if( noGunModel )
CG_PositionRotatedEntityOnTag( &flash, parent, parent->hModel, "tag_weapon" );
else
CG_PositionRotatedEntityOnTag( &flash, &gun, weapon->weaponModel, "tag_flash" );
trap_R_AddRefEntityToScene( &flash );
}
if( ps || cg.renderingThirdPerson ||
cent->currentState.number != cg.predictedPlayerState.clientNum )
{
if( weapon->wim[ weaponMode ].muzzleParticleSystem && cent->muzzlePsTrigger )
{
cent->muzzlePS = CG_SpawnNewParticleSystem( weapon->wim[ weaponMode ].muzzleParticleSystem );
if( CG_IsParticleSystemValid( ¢->muzzlePS ) )
{
if( noGunModel )
CG_SetAttachmentTag( ¢->muzzlePS->attachment, *parent, parent->hModel, "tag_weapon" );
else
CG_SetAttachmentTag( ¢->muzzlePS->attachment, gun, weapon->weaponModel, "tag_flash" );
CG_SetAttachmentCent( ¢->muzzlePS->attachment, cent );
CG_AttachToTag( ¢->muzzlePS->attachment );
}
cent->muzzlePsTrigger = qfalse;
}
// make a dlight for the flash
if( weapon->wim[ weaponMode ].flashDlightColor[ 0 ] ||
weapon->wim[ weaponMode ].flashDlightColor[ 1 ] ||
weapon->wim[ weaponMode ].flashDlightColor[ 2 ] )
{
trap_R_AddLightToScene( flash.origin, 300 + ( rand( ) & 31 ),
weapon->wim[ weaponMode ].flashDlightColor[ 0 ],
weapon->wim[ weaponMode ].flashDlightColor[ 1 ],
weapon->wim[ weaponMode ].flashDlightColor[ 2 ] );
}
}
}
/*
=================
CG_MissileHitWall
Caused by an EV_MISSILE_MISS event, or directly by local bullet tracing
=================
*/
void CG_MissileHitWall( weapon_t weaponNum, weaponMode_t weaponMode, int clientNum,
vec3_t origin, vec3_t dir, impactSound_t soundType )
{
qhandle_t mark = 0;
qhandle_t ps = 0;
int c;
float radius = 1.0f;
weaponInfo_t *weapon = &cg_weapons[ weaponNum ];
if( weaponMode <= WPM_NONE || weaponMode >= WPM_NUM_WEAPONMODES )
weaponMode = WPM_PRIMARY;
mark = weapon->wim[ weaponMode ].impactMark;
radius = weapon->wim[ weaponMode ].impactMarkSize;
ps = weapon->wim[ weaponMode ].impactParticleSystem;
if( soundType == IMPACTSOUND_FLESH )
{
//flesh sound
for( c = 0; c < 4; c++ )
{
if( !weapon->wim[ weaponMode ].impactFleshSound[ c ] )
break;
}
if( c > 0 )
{
c = rand( ) % c;
if( weapon->wim[ weaponMode ].impactFleshSound[ c ] )
trap_S_StartSound( origin, ENTITYNUM_WORLD, CHAN_AUTO, weapon->wim[ weaponMode ].impactFleshSound[ c ] );
}
}
else
{
//normal sound
for( c = 0; c < 4; c++ )
{
if( !weapon->wim[ weaponMode ].impactSound[ c ] )
break;
}
if( c > 0 )
{
c = rand( ) % c;
if( weapon->wim[ weaponMode ].impactSound[ c ] )
trap_S_StartSound( origin, ENTITYNUM_WORLD, CHAN_AUTO, weapon->wim[ weaponMode ].impactSound[ c ] );
}
}
//create impact particle system
if( ps )
{
particleSystem_t *partSystem = CG_SpawnNewParticleSystem( ps );
if( CG_IsParticleSystemValid( &partSystem ) )
{
CG_SetAttachmentPoint( &partSystem->attachment, origin );
CG_SetParticleSystemNormal( partSystem, dir );
CG_AttachToPoint( &partSystem->attachment );
}
}
//
// impact mark
//
if( radius > 0.0f )
CG_ImpactMark( mark, origin, dir, random( ) * 360, 1, 1, 1, 1, qfalse, radius, qfalse );
}
/*
=============
CG_AddPlayerWeapon
Used for both the view weapon (ps is valid) and the world modelother character models (ps is NULL)
The main player will have this called for BOTH cases, so effects like light and
sound should only be done on the world model case.
=============
*/
void CG_AddPlayerWeapon( refEntity_t *parent, playerState_t *ps, centity_t *cent )
{
refEntity_t gun;
refEntity_t barrel;
refEntity_t flash;
vec3_t angles;
weapon_t weaponNum;
weaponMode_t weaponMode;
weaponInfo_t *weapon;
qboolean noGunModel;
qboolean firing;
weaponNum = cent->currentState.weapon;
weaponMode = cent->currentState.generic1;
if( weaponMode <= WPM_NONE || weaponMode >= WPM_NUM_WEAPONMODES )
weaponMode = WPM_PRIMARY;
if( ( ( cent->currentState.eFlags & EF_FIRING ) && weaponMode == WPM_PRIMARY ) ||
( ( cent->currentState.eFlags & EF_FIRING2 ) && weaponMode == WPM_SECONDARY ) ||
( ( cent->currentState.eFlags & EF_FIRING3 ) && weaponMode == WPM_TERTIARY ) )
firing = qtrue;
else
firing = qfalse;
weapon = &cg_weapons[ weaponNum ];
if( !weapon->registered )
{
Com_Printf( S_COLOR_YELLOW "WARNING: CG_AddPlayerWeapon: weapon %d (%s) "
"is not registered\n", weaponNum, BG_Weapon( weaponNum )->name );
return;
}
// add the weapon
Com_Memset( &gun, 0, sizeof( gun ) );
Com_Memset( &barrel, 0, sizeof( barrel ) );
Com_Memset( &flash, 0, sizeof( flash ) );
VectorCopy( parent->lightingOrigin, gun.lightingOrigin );
gun.shadowPlane = parent->shadowPlane;
gun.renderfx = parent->renderfx;
if( ps )
{
gun.shaderRGBA[ 0 ] = 255;
gun.shaderRGBA[ 1 ] = 255;
gun.shaderRGBA[ 2 ] = 255;
gun.shaderRGBA[ 3 ] = 255;
//set weapon[1/2]Time when respective buttons change state
if( cg.weapon1Firing != ( cg.predictedPlayerState.eFlags & EF_FIRING ) )
{
cg.weapon1Time = cg.time;
cg.weapon1Firing = ( cg.predictedPlayerState.eFlags & EF_FIRING );
}
if( cg.weapon2Firing != ( cg.predictedPlayerState.eFlags & EF_FIRING2 ) )
{
cg.weapon2Time = cg.time;
cg.weapon2Firing = ( cg.predictedPlayerState.eFlags & EF_FIRING2 );
}
if( cg.weapon3Firing != ( cg.predictedPlayerState.eFlags & EF_FIRING3 ) )
{
cg.weapon3Time = cg.time;
cg.weapon3Firing = ( cg.predictedPlayerState.eFlags & EF_FIRING3 );
}
}
if( !ps )
{
gun.hModel = weapon->weaponModel3rdPerson;
if( !gun.hModel )
gun.hModel = weapon->weaponModel;
}
else
gun.hModel = weapon->weaponModel;
noGunModel = ( ( !ps || cg.renderingThirdPerson ) && weapon->disableIn3rdPerson ) || !gun.hModel;
if( !ps )
{
// add weapon ready sound
if( firing && weapon->wim[ weaponMode ].firingSound )
{
trap_S_AddLoopingSound( cent->currentState.number, cent->lerpOrigin, vec3_origin,
weapon->wim[ weaponMode ].firingSound );
}
else if( weapon->readySound )
trap_S_AddLoopingSound( cent->currentState.number, cent->lerpOrigin, vec3_origin, weapon->readySound );
}
// Lucifer cannon charge warning beep
if( weaponNum == WP_LUCIFER_CANNON &&
( cent->currentState.eFlags & EF_WARN_CHARGE ) &&
cg.snap->ps.stats[ STAT_TEAM ] != TEAM_ALIENS )
{
trap_S_AddLoopingSound( cent->currentState.number, cent->lerpOrigin,
vec3_origin, ps ? cgs.media.lCannonWarningSound :
cgs.media.lCannonWarningSound2 );
}
if( !noGunModel )
{
CG_PositionEntityOnTag( &gun, parent, parent->hModel, "tag_weapon" );
CG_WeaponAnimation( cent, &gun.oldframe, &gun.frame, &gun.backlerp );
trap_R_AddRefEntityToScene( &gun );
if( !ps )
{
barrel.hModel = weapon->barrelModel3rdPerson;
if( !barrel.hModel )
barrel.hModel = weapon->barrelModel;
}
else
barrel.hModel = weapon->barrelModel;
// add the spinning barrel
if( barrel.hModel )
{
VectorCopy( parent->lightingOrigin, barrel.lightingOrigin );
barrel.shadowPlane = parent->shadowPlane;
barrel.renderfx = parent->renderfx;
angles[ YAW ] = 0;
angles[ PITCH ] = 0;
angles[ ROLL ] = CG_MachinegunSpinAngle( cent, firing );
AnglesToAxis( angles, barrel.axis );
CG_PositionRotatedEntityOnTag( &barrel, &gun, gun.hModel, "tag_barrel" );
trap_R_AddRefEntityToScene( &barrel );
}
}
if( CG_IsParticleSystemValid( ¢->muzzlePS ) )
{
if( ps || cg.renderingThirdPerson ||
cent->currentState.number != cg.predictedPlayerState.clientNum )
{
if( noGunModel )
CG_SetAttachmentTag( ¢->muzzlePS->attachment, *parent, parent->hModel, "tag_weapon" );
else
CG_SetAttachmentTag( ¢->muzzlePS->attachment, gun, gun.hModel, "tag_flash" );
}
//if the PS is infinite disable it when not firing
if( !firing && CG_IsParticleSystemInfinite( cent->muzzlePS ) )
CG_DestroyParticleSystem( ¢->muzzlePS );
}
// add the flash
if( !weapon->wim[ weaponMode ].continuousFlash || !firing )
{
// impulse flash
if( cg.time - cent->muzzleFlashTime > MUZZLE_FLASH_TIME )
return;
}
VectorCopy( parent->lightingOrigin, flash.lightingOrigin );
flash.shadowPlane = parent->shadowPlane;
flash.renderfx = parent->renderfx;
if( !ps )
{
flash.hModel = weapon->flashModel3rdPerson;
if( !flash.hModel )
flash.hModel = weapon->flashModel;
}
else
flash.hModel = weapon->flashModel;
if( flash.hModel )
{
angles[ YAW ] = 0;
angles[ PITCH ] = 0;
angles[ ROLL ] = crandom( ) * 10;
AnglesToAxis( angles, flash.axis );
if( noGunModel )
CG_PositionRotatedEntityOnTag( &flash, parent, parent->hModel, "tag_weapon" );
else
CG_PositionRotatedEntityOnTag( &flash, &gun, gun.hModel, "tag_flash" );
trap_R_AddRefEntityToScene( &flash );
}
if( ps || cg.renderingThirdPerson ||
cent->currentState.number != cg.predictedPlayerState.clientNum )
{
if( weapon->wim[ weaponMode ].muzzleParticleSystem && cent->muzzlePsTrigger )
{
cent->muzzlePS = CG_SpawnNewParticleSystem( weapon->wim[ weaponMode ].muzzleParticleSystem );
if( CG_IsParticleSystemValid( ¢->muzzlePS ) )
{
if( noGunModel )
CG_SetAttachmentTag( ¢->muzzlePS->attachment, *parent, parent->hModel, "tag_weapon" );
else
CG_SetAttachmentTag( ¢->muzzlePS->attachment, gun, gun.hModel, "tag_flash" );
CG_SetAttachmentCent( ¢->muzzlePS->attachment, cent );
CG_AttachToTag( ¢->muzzlePS->attachment );
}
cent->muzzlePsTrigger = qfalse;
}
// make a dlight for the flash
if( weapon->wim[ weaponMode ].flashDlightColor[ 0 ] ||
weapon->wim[ weaponMode ].flashDlightColor[ 1 ] ||
weapon->wim[ weaponMode ].flashDlightColor[ 2 ] )
{
trap_R_AddLightToScene( flash.origin, 300 + ( rand( ) & 31 ),
weapon->wim[ weaponMode ].flashDlightColor[ 0 ],
weapon->wim[ weaponMode ].flashDlightColor[ 1 ],
weapon->wim[ weaponMode ].flashDlightColor[ 2 ] );
}
}
}
void CG_AddViewWeapon( playerState_t *ps )
{
refEntity_t hand;
centity_t *cent;
clientInfo_t *ci;
float fovOffset;
vec3_t angles;
weaponInfo_t *wi;
weapon_t weapon = ps->weapon;
weaponMode_t weaponMode = ps->generic1;
vec3_t cuboidSize;
// no weapon carried - can't draw it
if( weapon == WP_NONE )
return;
if( weaponMode <= WPM_NONE || weaponMode >= WPM_NUM_WEAPONMODES )
weaponMode = WPM_PRIMARY;
wi = &cg_weapons[ weapon ];
if( !wi->registered )
{
Com_Printf( S_COLOR_YELLOW "WARNING: CG_AddViewWeapon: weapon %d (%s) "
"is not registered\n", weapon, BG_Weapon( weapon )->name );
return;
}
cent = &cg.predictedPlayerEntity; // &cg_entities[cg.snap->ps.clientNum];
if( ps->persistant[PERS_SPECSTATE] != SPECTATOR_NOT )
return;
if( ps->pm_type == PM_INTERMISSION )
return;
// draw a prospective buildable infront of the player
if( ( ps->stats[ STAT_BUILDABLE ] & ~SB_VALID_TOGGLEBIT ) > BA_NONE )
CG_GhostBuildable( ps->stats[ STAT_BUILDABLE ] & ~SB_VALID_TOGGLEBIT, cg.cuboidSelection );
// no gun if in third person view
if( cg.renderingThirdPerson )
return;
// allow the gun to be completely removed
if( !cg_drawGun.integer )
{
vec3_t origin;
VectorCopy( cg.refdef.vieworg, origin );
VectorMA( origin, -8, cg.refdef.viewaxis[ 2 ], origin );
if( cent->muzzlePS )
CG_SetAttachmentPoint( ¢->muzzlePS->attachment, origin );
//check for particle systems
if( wi->wim[ weaponMode ].muzzleParticleSystem && cent->muzzlePsTrigger )
{
cent->muzzlePS = CG_SpawnNewParticleSystem( wi->wim[ weaponMode ].muzzleParticleSystem );
if( CG_IsParticleSystemValid( ¢->muzzlePS ) )
{
CG_SetAttachmentPoint( ¢->muzzlePS->attachment, origin );
CG_SetAttachmentCent( ¢->muzzlePS->attachment, cent );
CG_AttachToPoint( ¢->muzzlePS->attachment );
}
cent->muzzlePsTrigger = qfalse;
}
return;
}
// don't draw if testing a gun model
if( cg.testGun )
return;
// drop gun lower at higher fov
if( cg.refdef.fov_y > 90 )
fovOffset = -0.4 * ( cg.refdef.fov_y - 90 );
else
fovOffset = 0;
Com_Memset( &hand, 0, sizeof( hand ) );
// set up gun position
CG_CalculateWeaponPosition( hand.origin, angles );
VectorMA( hand.origin, cg_gun_x.value, cg.refdef.viewaxis[ 0 ], hand.origin );
VectorMA( hand.origin, cg_gun_y.value, cg.refdef.viewaxis[ 1 ], hand.origin );
VectorMA( hand.origin, ( cg_gun_z.value + fovOffset ), cg.refdef.viewaxis[ 2 ], hand.origin );
// Lucifer Cannon vibration effect
if( weapon == WP_LUCIFER_CANNON && ps->stats[ STAT_MISC ] > 0 )
{
float fraction;
fraction = (float)ps->stats[ STAT_MISC ] / LCANNON_CHARGE_TIME_MAX;
VectorMA( hand.origin, random( ) * fraction, cg.refdef.viewaxis[ 0 ],
hand.origin );
VectorMA( hand.origin, random( ) * fraction, cg.refdef.viewaxis[ 1 ],
hand.origin );
}
AnglesToAxis( angles, hand.axis );
// map torso animations to weapon animations
if( cg_gun_frame.integer )
{
// development tool
hand.frame = hand.oldframe = cg_gun_frame.integer;
hand.backlerp = 0;
}
else
{
// get clientinfo for animation map
ci = &cgs.clientinfo[ cent->currentState.clientNum ];
hand.frame = CG_MapTorsoToWeaponFrame( ci, cent->pe.torso.frame );
hand.oldframe = CG_MapTorsoToWeaponFrame( ci, cent->pe.torso.oldFrame );
hand.backlerp = cent->pe.torso.backlerp;
}
hand.hModel = wi->handsModel;
hand.renderfx = RF_DEPTHHACK | RF_FIRST_PERSON | RF_MINLIGHT;
// add everything onto the hand
CG_AddPlayerWeapon( &hand, ps, &cg.predictedPlayerEntity );
}
/*
=================
CG_ServerCommand
The string has been tokenized and can be retrieved with
Cmd_Argc() / Cmd_Argv()
=================
*/
static void CG_ServerCommand( void )
{
const char *cmd;
char text[ MAX_SAY_TEXT ];
cmd = CG_Argv( 0 );
if ( !cmd[ 0 ] )
{
// server claimed the command
return;
}
if ( !strcmp( cmd, "cp" ) )
{
CG_CenterPrint( CG_Argv( 1 ), SCREEN_HEIGHT * 0.30, BIGCHAR_WIDTH );
return;
}
if ( !strcmp( cmd, "cs" ) )
{
CG_ConfigStringModified();
return;
}
if ( !strcmp( cmd, "print" ) )
{
CG_Printf( "%s", CG_Argv( 1 ) );
return;
}
if ( !strcmp( cmd, "chat" ) )
{
if ( !cg_teamChatsOnly.integer )
{
trap_S_StartLocalSound( cgs.media.talkSound, CHAN_LOCAL_SOUND );
Q_strncpyz( text, CG_Argv( 1 ), MAX_SAY_TEXT );
CG_RemoveChatEscapeChar( text );
CG_Printf( "%s\n", text );
}
return;
}
if ( !strcmp( cmd, "tchat" ) )
{
if ( cg.snap->ps.stats[ STAT_PTEAM ] == PTE_ALIENS )
{
trap_S_StartLocalSound( cgs.media.alienTalkSound, CHAN_LOCAL_SOUND );
}
else if ( cg.snap->ps.stats[ STAT_PTEAM ] == PTE_HUMANS )
{
trap_S_StartLocalSound( cgs.media.humanTalkSound, CHAN_LOCAL_SOUND );
}
else
{
trap_S_StartLocalSound( cgs.media.talkSound, CHAN_LOCAL_SOUND );
}
Q_strncpyz( text, CG_Argv( 1 ), MAX_SAY_TEXT );
CG_RemoveChatEscapeChar( text );
CG_AddToTeamChat( text );
CG_Printf( "%s\n", text );
return;
}
if ( !strcmp( cmd, "scores" ) )
{
CG_ParseScores();
return;
}
if ( !strcmp( cmd, "tinfo" ) )
{
CG_ParseTeamInfo();
return;
}
if ( !strcmp( cmd, "map_restart" ) )
{
CG_MapRestart();
return;
}
if ( Q_stricmp( cmd, "remapShader" ) == 0 )
{
if ( trap_Argc() == 4 )
{
trap_R_RemapShader( CG_Argv( 1 ), CG_Argv( 2 ), CG_Argv( 3 ) );
}
}
//the server has triggered a menu
if ( !strcmp( cmd, "servermenu" ) )
{
if ( trap_Argc() == 2 && !cg.demoPlayback )
{
CG_Menu( atoi( CG_Argv( 1 ) ) );
}
return;
}
//the server thinks this client should close all menus
if ( !strcmp( cmd, "serverclosemenus" ) )
{
trap_SendConsoleCommand( "closemenus\n" );
return;
}
//poison cloud effect needs to be reliable
if ( !strcmp( cmd, "poisoncloud" ) )
{
cg.poisonedTime = cg.time;
if ( CG_IsParticleSystemValid( &cg.poisonCloudPS ) )
{
cg.poisonCloudPS = CG_SpawnNewParticleSystem( cgs.media.poisonCloudPS );
CG_SetAttachmentCent( &cg.poisonCloudPS->attachment, &cg.predictedPlayerEntity );
CG_AttachToCent( &cg.poisonCloudPS->attachment );
}
return;
}
if ( !strcmp( cmd, "weaponswitch" ) )
{
CG_Printf( "client weaponswitch\n" );
if ( trap_Argc() == 2 )
{
cg.weaponSelect = atoi( CG_Argv( 1 ) );
cg.weaponSelectTime = cg.time;
}
return;
}
// server requests a ptrc
if ( !strcmp( cmd, "ptrcrequest" ) )
{
int code = CG_ReadPTRCode();
trap_SendClientCommand( va( "ptrcverify %d", code ) );
return;
}
// server issues a ptrc
if ( !strcmp( cmd, "ptrcissue" ) )
{
if ( trap_Argc() == 2 )
{
int code = atoi( CG_Argv( 1 ) );
CG_WritePTRCode( code );
}
return;
}
// reply to ptrcverify
if ( !strcmp( cmd, "ptrcconfirm" ) )
{
trap_SendConsoleCommand( "menu ptrc_popmenu\n" );
return;
}
CG_Printf( "Unknown client game command: %s\n", cmd );
}