/*
================
CG_ConfigStringModified
================
*/
static void CG_ConfigStringModified( void ) {
const char *str;
int num;
num = atoi( CG_Argv( 1 ) );
// get the gamestate from the client system, which will have the
// new configstring already integrated
trap_GetGameState( &cgs.gameState );
// look up the individual string that was modified
str = CG_ConfigString( num );
// do something with it if necessary
if ( num == CS_MUSIC ) {
CG_StartMusic();
} else if ( num == CS_SERVERINFO ) {
CG_ParseServerinfo();
} else if ( num == CS_WARMUP ) {
CG_ParseWarmup();
} else if ( num == CS_SCORES1 ) {
cgs.scores1 = atoi( str );
} else if ( num == CS_SCORES2 ) {
cgs.scores2 = atoi( str );
} else if ( num == CS_LEVEL_START_TIME ) {
cgs.levelStartTime = atoi( str );
} else if ( num == CS_VOTE_TIME ) {
cgs.voteTime = atoi( str );
cgs.voteModified = qtrue;
} else if ( num == CS_VOTE_YES ) {
cgs.voteYes = atoi( str );
cgs.voteModified = qtrue;
} else if ( num == CS_VOTE_NO ) {
cgs.voteNo = atoi( str );
cgs.voteModified = qtrue;
} else if ( num == CS_VOTE_STRING ) {
Q_strncpyz( cgs.voteString, str, sizeof( cgs.voteString ) );
#ifdef MISSIONPACK
trap_S_StartLocalSound( cgs.media.voteNow, CHAN_ANNOUNCER );
#endif //MISSIONPACK
} else if ( num >= CS_TEAMVOTE_TIME && num <= CS_TEAMVOTE_TIME + 1) {
cgs.teamVoteTime[num-CS_TEAMVOTE_TIME] = atoi( str );
cgs.teamVoteModified[num-CS_TEAMVOTE_TIME] = qtrue;
} else if ( num >= CS_TEAMVOTE_YES && num <= CS_TEAMVOTE_YES + 1) {
cgs.teamVoteYes[num-CS_TEAMVOTE_YES] = atoi( str );
cgs.teamVoteModified[num-CS_TEAMVOTE_YES] = qtrue;
} else if ( num >= CS_TEAMVOTE_NO && num <= CS_TEAMVOTE_NO + 1) {
cgs.teamVoteNo[num-CS_TEAMVOTE_NO] = atoi( str );
cgs.teamVoteModified[num-CS_TEAMVOTE_NO] = qtrue;
} else if ( num >= CS_TEAMVOTE_STRING && num <= CS_TEAMVOTE_STRING + 1) {
Q_strncpyz( cgs.teamVoteString[num-CS_TEAMVOTE_STRING], str, sizeof( cgs.teamVoteString ) );
#ifdef MISSIONPACK
trap_S_StartLocalSound( cgs.media.voteNow, CHAN_ANNOUNCER );
#endif
} else if ( num == CS_INTERMISSION ) {
cg.intermissionStarted = atoi( str );
} else if ( num >= CS_MODELS && num < CS_MODELS+MAX_MODELS ) {
cgs.gameModels[ num-CS_MODELS ] = trap_R_RegisterModel( str );
} else if ( num >= CS_SOUNDS && num < CS_SOUNDS+MAX_SOUNDS ) {
if ( str[0] != '*' ) { // player specific sounds don't register here
cgs.gameSounds[ num-CS_SOUNDS] = trap_S_RegisterSound( str, qfalse );
}
} else if ( num >= CS_PLAYERS && num < CS_PLAYERS+MAX_CLIENTS ) {
CG_NewClientInfo( num - CS_PLAYERS );
CG_BuildSpectatorString();
} else if ( num == CS_FLAGSTATUS ) {
if( cgs.gametype == GT_CTF ) {
// format is rb where its red/blue, 0 is at base, 1 is taken, 2 is dropped
cgs.redflag = str[0] - '0';
cgs.blueflag = str[1] - '0';
}
#ifdef MISSIONPACK
else if( cgs.gametype == GT_1FCTF ) {
cgs.flagStatus = str[0] - '0';
}
#endif
}
else if ( num == CS_SHADERSTATE ) {
CG_ShaderStateChanged();
}
}
/*
===============
CG_ParseWeaponModeSection
Parse a weapon mode section
===============
*/
static qboolean CG_ParseWeaponModeSection( weaponInfoMode_t *wim, char **text_p )
{
char *token;
int i;
// read optional parameters
while( 1 )
{
token = COM_Parse( text_p );
if( !token )
break;
if( !Q_stricmp( token, "" ) )
return qfalse;
if( !Q_stricmp( token, "missileModel" ) )
{
token = COM_Parse( text_p );
if( !token )
break;
wim->missileModel = trap_R_RegisterModel( token );
if( !wim->missileModel )
CG_Printf( S_COLOR_RED "ERROR: missile model not found %s\n", token );
continue;
}
else if( !Q_stricmp( token, "missileSprite" ) )
{
int size = 0;
token = COM_Parse( text_p );
if( !token )
break;
size = atoi( token );
if( size < 0 )
size = 0;
token = COM_Parse( text_p );
if( !token )
break;
wim->missileSprite = trap_R_RegisterShader( token );
wim->missileSpriteSize = size;
wim->usesSpriteMissle = qtrue;
if( !wim->missileSprite )
CG_Printf( S_COLOR_RED "ERROR: missile sprite not found %s\n", token );
continue;
}
else if( !Q_stricmp( token, "missileRotates" ) )
{
wim->missileRotates = qtrue;
continue;
}
else if( !Q_stricmp( token, "missileAnimates" ) )
{
wim->missileAnimates = qtrue;
token = COM_Parse( text_p );
if( !token )
break;
wim->missileAnimStartFrame = atoi( token );
token = COM_Parse( text_p );
if( !token )
break;
wim->missileAnimNumFrames = atoi( token );
token = COM_Parse( text_p );
if( !token )
break;
wim->missileAnimFrameRate = atoi( token );
token = COM_Parse( text_p );
if( !token )
break;
wim->missileAnimLooping = atoi( token );
continue;
}
else if( !Q_stricmp( token, "missileParticleSystem" ) )
{
token = COM_Parse( text_p );
if( !token )
break;
wim->missileParticleSystem = CG_RegisterParticleSystem( token );
if( !wim->missileParticleSystem )
CG_Printf( S_COLOR_RED "ERROR: missile particle system not found %s\n", token );
continue;
}
else if( !Q_stricmp( token, "missileTrailSystem" ) )
{
token = COM_Parse( text_p );
if( !token )
break;
wim->missileTrailSystem = CG_RegisterTrailSystem( token );
if( !wim->missileTrailSystem )
CG_Printf( S_COLOR_RED "ERROR: missile trail system not found %s\n", token );
continue;
}
else if( !Q_stricmp( token, "muzzleParticleSystem" ) )
{
token = COM_Parse( text_p );
if( !token )
break;
wim->muzzleParticleSystem = CG_RegisterParticleSystem( token );
if( !wim->muzzleParticleSystem )
CG_Printf( S_COLOR_RED "ERROR: muzzle particle system not found %s\n", token );
continue;
}
else if( !Q_stricmp( token, "impactParticleSystem" ) )
{
token = COM_Parse( text_p );
if( !token )
break;
wim->impactParticleSystem = CG_RegisterParticleSystem( token );
if( !wim->impactParticleSystem )
CG_Printf( S_COLOR_RED "ERROR: impact particle system not found %s\n", token );
continue;
}
else if( !Q_stricmp( token, "impactMark" ) )
{
int size = 0;
token = COM_Parse( text_p );
if( !token )
break;
size = atoi( token );
if( size < 0 )
size = 0;
token = COM_Parse( text_p );
if( !token )
break;
wim->impactMark = trap_R_RegisterShader( token );
wim->impactMarkSize = size;
if( !wim->impactMark )
CG_Printf( S_COLOR_RED "ERROR: impact mark shader not found %s\n", token );
continue;
}
else if( !Q_stricmp( token, "impactSound" ) )
{
int index = 0;
token = COM_Parse( text_p );
if( !token )
break;
index = atoi( token );
if( index < 0 )
index = 0;
else if( index > 3 )
index = 3;
token = COM_Parse( text_p );
if( !token )
break;
wim->impactSound[ index ] = trap_S_RegisterSound( token, qfalse );
continue;
}
else if( !Q_stricmp( token, "impactFleshSound" ) )
{
int index = 0;
token = COM_Parse( text_p );
if( !token )
break;
index = atoi( token );
if( index < 0 )
index = 0;
else if( index > 3 )
index = 3;
token = COM_Parse( text_p );
if( !token )
break;
wim->impactFleshSound[ index ] = trap_S_RegisterSound( token, qfalse );
continue;
}
else if( !Q_stricmp( token, "alwaysImpact" ) )
{
wim->alwaysImpact = qtrue;
continue;
}
else if( !Q_stricmp( token, "flashDLightColor" ) )
{
for( i = 0 ; i < 3 ; i++ )
{
token = COM_Parse( text_p );
if( !token )
break;
wim->flashDlightColor[ i ] = atof( token );
}
continue;
}
else if( !Q_stricmp( token, "continuousFlash" ) )
{
wim->continuousFlash = qtrue;
continue;
}
else if( !Q_stricmp( token, "missileDlightColor" ) )
{
for( i = 0 ; i < 3 ; i++ )
{
token = COM_Parse( text_p );
if( !token )
break;
wim->missileDlightColor[ i ] = atof( token );
}
continue;
}
else if( !Q_stricmp( token, "missileDlight" ) )
{
int size = 0;
token = COM_Parse( text_p );
if( !token )
break;
size = atoi( token );
if( size < 0 )
size = 0;
wim->missileDlight = size;
continue;
}
else if( !Q_stricmp( token, "firingSound" ) )
{
token = COM_Parse( text_p );
if( !token )
break;
wim->firingSound = trap_S_RegisterSound( token, qfalse );
continue;
}
else if( !Q_stricmp( token, "missileSound" ) )
{
token = COM_Parse( text_p );
if( !token )
break;
wim->missileSound = trap_S_RegisterSound( token, qfalse );
continue;
}
else if( !Q_stricmp( token, "flashSound" ) )
{
int index = 0;
token = COM_Parse( text_p );
if( !token )
break;
index = atoi( token );
if( index < 0 )
index = 0;
else if( index > 3 )
index = 3;
token = COM_Parse( text_p );
if( !token )
break;
wim->flashSound[ index ] = trap_S_RegisterSound( token, qfalse );
continue;
}
else if( !Q_stricmp( token, "}" ) )
return qtrue; //reached the end of this weapon section
else
{
CG_Printf( S_COLOR_RED "ERROR: unknown token '%s' in weapon section\n", token );
return qfalse;
}
}
return qfalse;
}
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;
es = ¢->currentState;
event = es->event & ~EV_EVENT_BITS;
if ( cg_debugEvents.integer ) {
CG_Printf( "ent:%3i event:%3i ", es->number, event );
}
if ( !event ) {
DEBUGNAME("ZEROEVENT");
return;
}
clientNum = es->clientNum;
if ( clientNum < 0 || clientNum >= MAX_CLIENTS ) {
clientNum = 0;
}
ci = &cgs.clientinfo[ clientNum ];
switch ( event ) {
//
// movement generated events
//
case EV_FOOTSTEP:
DEBUGNAME("EV_FOOTSTEP");
if (cg_footsteps.integer) {
trap_S_StartSound (NULL, es->number, CHAN_BODY,
cgs.media.footsteps[ ci->footsteps ][rand()&3] );
}
break;
case EV_FOOTSTEP_METAL:
DEBUGNAME("EV_FOOTSTEP_METAL");
if (cg_footsteps.integer) {
trap_S_StartSound (NULL, es->number, CHAN_BODY,
cgs.media.footsteps[ FOOTSTEP_METAL ][rand()&3] );
}
break;
case EV_FOOTSPLASH:
DEBUGNAME("EV_FOOTSPLASH");
if (cg_footsteps.integer) {
trap_S_StartSound (NULL, es->number, CHAN_BODY,
cgs.media.footsteps[ FOOTSTEP_SPLASH ][rand()&3] );
}
break;
case EV_FOOTWADE:
DEBUGNAME("EV_FOOTWADE");
if (cg_footsteps.integer) {
trap_S_StartSound (NULL, es->number, CHAN_BODY,
cgs.media.footsteps[ FOOTSTEP_SPLASH ][rand()&3] );
}
break;
case EV_SWIM:
DEBUGNAME("EV_SWIM");
if (cg_footsteps.integer) {
trap_S_StartSound (NULL, es->number, CHAN_BODY,
cgs.media.footsteps[ FOOTSTEP_SPLASH ][rand()&3] );
}
break;
case EV_FALL_SHORT:
DEBUGNAME("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:
DEBUGNAME("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:
DEBUGNAME("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_STEP_4:
case EV_STEP_8:
case EV_STEP_12:
case EV_STEP_16: // smooth out step up transitions
DEBUGNAME("EV_STEP");
{
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 < STEP_TIME) {
oldStep = cg.stepChange * (STEP_TIME - delta) / STEP_TIME;
} else {
oldStep = 0;
}
// add this amount
step = 4 * (event - EV_STEP_4 + 1 );
cg.stepChange = oldStep + step;
if ( cg.stepChange > MAX_STEP_CHANGE ) {
cg.stepChange = MAX_STEP_CHANGE;
}
cg.stepTime = cg.time;
break;
}
case EV_JUMP_PAD:
DEBUGNAME("EV_JUMP_PAD");
// CG_Printf( "EV_JUMP_PAD w/effect #%i\n", es->eventParm );
{
localEntity_t *smoke;
vec3_t up = {0, 0, 1};
smoke = CG_SmokePuff( cent->lerpOrigin, up,
32,
1, 1, 1, 0.33f,
1000,
cg.time, 0,
LEF_PUFF_DONT_SCALE,
cgs.media.smokePuffShader );
}
// boing sound at origin, jump sound on player
trap_S_StartSound ( cent->lerpOrigin, -1, CHAN_VOICE, cgs.media.jumpPadSound );
trap_S_StartSound (NULL, es->number, CHAN_VOICE, CG_CustomSound( es->number, "*jump1.wav" ) );
break;
case EV_JUMP:
DEBUGNAME("EV_JUMP");
trap_S_StartSound (NULL, es->number, CHAN_VOICE, CG_CustomSound( es->number, "*jump1.wav" ) );
break;
case EV_TAUNT:
DEBUGNAME("EV_TAUNT");
trap_S_StartSound (NULL, es->number, CHAN_VOICE, CG_CustomSound( es->number, "*taunt.wav" ) );
break;
#ifdef MISSIONPACK
case EV_TAUNT_YES:
DEBUGNAME("EV_TAUNT_YES");
CG_VoiceChatLocal(SAY_TEAM, qfalse, es->number, COLOR_CYAN, VOICECHAT_YES);
break;
case EV_TAUNT_NO:
DEBUGNAME("EV_TAUNT_NO");
CG_VoiceChatLocal(SAY_TEAM, qfalse, es->number, COLOR_CYAN, VOICECHAT_NO);
break;
case EV_TAUNT_FOLLOWME:
DEBUGNAME("EV_TAUNT_FOLLOWME");
CG_VoiceChatLocal(SAY_TEAM, qfalse, es->number, COLOR_CYAN, VOICECHAT_FOLLOWME);
break;
case EV_TAUNT_GETFLAG:
DEBUGNAME("EV_TAUNT_GETFLAG");
CG_VoiceChatLocal(SAY_TEAM, qfalse, es->number, COLOR_CYAN, VOICECHAT_ONGETFLAG);
break;
case EV_TAUNT_GUARDBASE:
DEBUGNAME("EV_TAUNT_GUARDBASE");
CG_VoiceChatLocal(SAY_TEAM, qfalse, es->number, COLOR_CYAN, VOICECHAT_ONDEFENSE);
break;
case EV_TAUNT_PATROL:
DEBUGNAME("EV_TAUNT_PATROL");
CG_VoiceChatLocal(SAY_TEAM, qfalse, es->number, COLOR_CYAN, VOICECHAT_ONPATROL);
break;
#endif
case EV_WATER_TOUCH:
DEBUGNAME("EV_WATER_TOUCH");
trap_S_StartSound (NULL, es->number, CHAN_AUTO, cgs.media.watrInSound );
break;
case EV_WATER_LEAVE:
DEBUGNAME("EV_WATER_LEAVE");
trap_S_StartSound (NULL, es->number, CHAN_AUTO, cgs.media.watrOutSound );
break;
case EV_WATER_UNDER:
DEBUGNAME("EV_WATER_UNDER");
trap_S_StartSound (NULL, es->number, CHAN_AUTO, cgs.media.watrUnSound );
break;
case EV_WATER_CLEAR:
DEBUGNAME("EV_WATER_CLEAR");
trap_S_StartSound (NULL, es->number, CHAN_AUTO, CG_CustomSound( es->number, "*gasp.wav" ) );
break;
case EV_ITEM_PICKUP:
DEBUGNAME("EV_ITEM_PICKUP");
{
gitem_t *item;
int index;
index = es->eventParm; // player predicted
if ( index < 1 || index >= bg_numItems ) {
break;
}
item = &bg_itemlist[ index ];
// powerups and team items will have a separate global sound, this one
// will be played at prediction time
if ( item->giType == IT_POWERUP || item->giType == IT_TEAM) {
trap_S_StartSound (NULL, es->number, CHAN_AUTO, cgs.media.n_healthSound );
} else if (item->giType == IT_PERSISTANT_POWERUP) {
#ifdef MISSIONPACK
switch (item->giTag ) {
case PW_SCOUT:
trap_S_StartSound (NULL, es->number, CHAN_AUTO, cgs.media.scoutSound );
break;
case PW_GUARD:
trap_S_StartSound (NULL, es->number, CHAN_AUTO, cgs.media.guardSound );
break;
case PW_DOUBLER:
trap_S_StartSound (NULL, es->number, CHAN_AUTO, cgs.media.doublerSound );
break;
case PW_AMMOREGEN:
trap_S_StartSound (NULL, es->number, CHAN_AUTO, cgs.media.ammoregenSound );
break;
}
#endif
} else {
trap_S_StartSound (NULL, es->number, CHAN_AUTO, trap_S_RegisterSound( item->pickup_sound, qfalse ) );
}
// show icon and name on status bar
if ( es->number == cg.snap->ps.clientNum ) {
CG_ItemPickup(es, index); // [ERGO MOD] added es
}
}
break;
case EV_GLOBAL_ITEM_PICKUP:
DEBUGNAME("EV_GLOBAL_ITEM_PICKUP");
{
gitem_t *item;
int index;
index = es->eventParm; // player predicted
if ( index < 1 || index >= bg_numItems ) {
break;
}
item = &bg_itemlist[ index ];
// powerup pickups are global
if( item->pickup_sound ) {
trap_S_StartSound (NULL, cg.snap->ps.clientNum, CHAN_AUTO, trap_S_RegisterSound( item->pickup_sound, qfalse ) );
}
// show icon and name on status bar
if ( es->number == cg.snap->ps.clientNum ) {
CG_ItemPickup(es, index ); // [ERGO MOD] added es
}
}
break;
//
// weapon events
//
case EV_NOAMMO:
DEBUGNAME("EV_NOAMMO");
// trap_S_StartSound (NULL, es->number, CHAN_AUTO, cgs.media.noAmmoSound );
if ( es->number == cg.snap->ps.clientNum ) {
CG_OutOfAmmoChange();
}
break;
case EV_CHANGE_WEAPON:
DEBUGNAME("EV_CHANGE_WEAPON");
trap_S_StartSound (NULL, es->number, CHAN_AUTO, cgs.media.selectSound );
break;
case EV_FIRE_WEAPON:
DEBUGNAME("EV_FIRE_WEAPON");
CG_FireWeapon( cent );
break;
case EV_USE_ITEM0:
DEBUGNAME("EV_USE_ITEM0");
CG_UseItem( cent );
break;
case EV_USE_ITEM1:
DEBUGNAME("EV_USE_ITEM1");
CG_UseItem( cent );
break;
case EV_USE_ITEM2:
DEBUGNAME("EV_USE_ITEM2");
CG_UseItem( cent );
break;
case EV_USE_ITEM3:
DEBUGNAME("EV_USE_ITEM3");
CG_UseItem( cent );
break;
case EV_USE_ITEM4:
DEBUGNAME("EV_USE_ITEM4");
CG_UseItem( cent );
break;
case EV_USE_ITEM5:
DEBUGNAME("EV_USE_ITEM5");
CG_UseItem( cent );
break;
case EV_USE_ITEM6:
DEBUGNAME("EV_USE_ITEM6");
CG_UseItem( cent );
break;
case EV_USE_ITEM7:
DEBUGNAME("EV_USE_ITEM7");
CG_UseItem( cent );
break;
case EV_USE_ITEM8:
DEBUGNAME("EV_USE_ITEM8");
CG_UseItem( cent );
break;
case EV_USE_ITEM9:
DEBUGNAME("EV_USE_ITEM9");
CG_UseItem( cent );
break;
case EV_USE_ITEM10:
DEBUGNAME("EV_USE_ITEM10");
CG_UseItem( cent );
break;
case EV_USE_ITEM11:
DEBUGNAME("EV_USE_ITEM11");
CG_UseItem( cent );
break;
case EV_USE_ITEM12:
DEBUGNAME("EV_USE_ITEM12");
CG_UseItem( cent );
break;
case EV_USE_ITEM13:
DEBUGNAME("EV_USE_ITEM13");
CG_UseItem( cent );
break;
case EV_USE_ITEM14:
DEBUGNAME("EV_USE_ITEM14");
CG_UseItem( cent );
break;
//=================================================================
//
// other events
//
case EV_PLAYER_TELEPORT_IN:
DEBUGNAME("EV_PLAYER_TELEPORT_IN");
trap_S_StartSound (NULL, es->number, CHAN_AUTO, cgs.media.teleInSound );
CG_SpawnEffect( position);
break;
case EV_PLAYER_TELEPORT_OUT:
DEBUGNAME("EV_PLAYER_TELEPORT_OUT");
trap_S_StartSound (NULL, es->number, CHAN_AUTO, cgs.media.teleOutSound );
CG_SpawnEffect( position);
break;
case EV_ITEM_POP:
DEBUGNAME("EV_ITEM_POP");
trap_S_StartSound (NULL, es->number, CHAN_AUTO, cgs.media.respawnSound );
break;
case EV_ITEM_RESPAWN:
DEBUGNAME("EV_ITEM_RESPAWN");
cent->miscTime = cg.time; // scale up from this
trap_S_StartSound (NULL, es->number, CHAN_AUTO, cgs.media.respawnSound );
break;
case EV_GRENADE_BOUNCE:
DEBUGNAME("EV_GRENADE_BOUNCE");
if ( rand() & 1 ) {
trap_S_StartSound (NULL, es->number, CHAN_AUTO, cgs.media.hgrenb1aSound );
} else {
trap_S_StartSound (NULL, es->number, CHAN_AUTO, cgs.media.hgrenb2aSound );
}
break;
// [ERGO MOD START]
case EV_MOD_HR_INFO:
DEBUGNAME("EV_MOD_HR_INFO");
CG_ModHRInfo(es);
break;
// [ERGO MOD END]
#ifdef MISSIONPACK
case EV_PROXIMITY_MINE_STICK:
DEBUGNAME("EV_PROXIMITY_MINE_STICK");
if( es->eventParm & SURF_FLESH ) {
trap_S_StartSound (NULL, es->number, CHAN_AUTO, cgs.media.wstbimplSound );
} else if( es->eventParm & SURF_METALSTEPS ) {
trap_S_StartSound (NULL, es->number, CHAN_AUTO, cgs.media.wstbimpmSound );
} else {
trap_S_StartSound (NULL, es->number, CHAN_AUTO, cgs.media.wstbimpdSound );
}
break;
case EV_PROXIMITY_MINE_TRIGGER:
DEBUGNAME("EV_PROXIMITY_MINE_TRIGGER");
trap_S_StartSound (NULL, es->number, CHAN_AUTO, cgs.media.wstbactvSound );
break;
case EV_KAMIKAZE:
DEBUGNAME("EV_KAMIKAZE");
CG_KamikazeEffect( cent->lerpOrigin );
break;
case EV_OBELISKEXPLODE:
DEBUGNAME("EV_OBELISKEXPLODE");
CG_ObeliskExplode( cent->lerpOrigin, es->eventParm );
break;
case EV_OBELISKPAIN:
DEBUGNAME("EV_OBELISKPAIN");
CG_ObeliskPain( cent->lerpOrigin );
break;
case EV_INVUL_IMPACT:
DEBUGNAME("EV_INVUL_IMPACT");
CG_InvulnerabilityImpact( cent->lerpOrigin, cent->currentState.angles );
break;
case EV_JUICED:
DEBUGNAME("EV_JUICED");
CG_InvulnerabilityJuiced( cent->lerpOrigin );
break;
case EV_LIGHTNINGBOLT:
DEBUGNAME("EV_LIGHTNINGBOLT");
CG_LightningBoltBeam(es->origin2, es->pos.trBase);
break;
#endif
case EV_SCOREPLUM:
DEBUGNAME("EV_SCOREPLUM");
CG_ScorePlum( cent->currentState.otherEntityNum, cent->lerpOrigin, cent->currentState.time );
break;
//
// missile impacts
//
case EV_MISSILE_HIT:
DEBUGNAME("EV_MISSILE_HIT");
ByteToDir( es->eventParm, dir );
CG_MissileHitPlayer( es->weapon, position, dir, es->otherEntityNum );
break;
case EV_MISSILE_MISS:
DEBUGNAME("EV_MISSILE_MISS");
ByteToDir( es->eventParm, dir );
CG_MissileHitWall( es->weapon, 0, position, dir, IMPACTSOUND_DEFAULT );
break;
case EV_MISSILE_MISS_METAL:
DEBUGNAME("EV_MISSILE_MISS_METAL");
ByteToDir( es->eventParm, dir );
CG_MissileHitWall( es->weapon, 0, position, dir, IMPACTSOUND_METAL );
break;
case EV_RAILTRAIL:
DEBUGNAME("EV_RAILTRAIL");
cent->currentState.weapon = WP_RAILGUN;
// if the end was on a nomark surface, don't make an explosion
CG_RailTrail( ci, es->origin2, es->pos.trBase );
if ( es->eventParm != 255 ) {
ByteToDir( es->eventParm, dir );
CG_MissileHitWall( es->weapon, es->clientNum, position, dir, IMPACTSOUND_DEFAULT );
}
break;
case EV_BULLET_HIT_WALL:
DEBUGNAME("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:
DEBUGNAME("EV_BULLET_HIT_FLESH");
CG_Bullet( es->pos.trBase, es->otherEntityNum, dir, qtrue, es->eventParm );
break;
case EV_SHOTGUN:
DEBUGNAME("EV_SHOTGUN");
CG_ShotgunFire( es );
break;
case EV_GENERAL_SOUND:
DEBUGNAME("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
DEBUGNAME("EV_GLOBAL_SOUND");
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_GLOBAL_TEAM_SOUND: // play from the player's head so it never diminishes
{
DEBUGNAME("EV_GLOBAL_TEAM_SOUND");
switch( es->eventParm ) {
case GTS_RED_CAPTURE: // CTF: red team captured the blue flag, 1FCTF: red team captured the neutral flag
if ( cgs.clientinfo[cg.clientNum].team == TEAM_RED )
CG_AddBufferedSound( cgs.media.captureYourTeamSound );
else
CG_AddBufferedSound( cgs.media.captureOpponentSound );
break;
case GTS_BLUE_CAPTURE: // CTF: blue team captured the red flag, 1FCTF: blue team captured the neutral flag
if ( cgs.clientinfo[cg.clientNum].team == TEAM_BLUE )
CG_AddBufferedSound( cgs.media.captureYourTeamSound );
else
CG_AddBufferedSound( cgs.media.captureOpponentSound );
break;
case GTS_RED_RETURN: // CTF: blue flag returned, 1FCTF: never used
if ( cgs.clientinfo[cg.clientNum].team == TEAM_RED )
CG_AddBufferedSound( cgs.media.returnYourTeamSound );
else
CG_AddBufferedSound( cgs.media.returnOpponentSound );
//
CG_AddBufferedSound( cgs.media.blueFlagReturnedSound );
break;
case GTS_BLUE_RETURN: // CTF red flag returned, 1FCTF: neutral flag returned
if ( cgs.clientinfo[cg.clientNum].team == TEAM_BLUE )
CG_AddBufferedSound( cgs.media.returnYourTeamSound );
else
CG_AddBufferedSound( cgs.media.returnOpponentSound );
//
CG_AddBufferedSound( cgs.media.redFlagReturnedSound );
break;
case GTS_RED_TAKEN: // CTF: red team took blue flag, 1FCTF: blue team took the neutral flag
// if this player picked up the flag then a sound is played in CG_CheckLocalSounds
if (cg.snap->ps.powerups[PW_BLUEFLAG] || cg.snap->ps.powerups[PW_NEUTRALFLAG]) {
}
else {
if (cgs.clientinfo[cg.clientNum].team == TEAM_BLUE) {
#ifdef MISSIONPACK
if (cgs.gametype == GT_1FCTF)
CG_AddBufferedSound( cgs.media.yourTeamTookTheFlagSound );
else
#endif
CG_AddBufferedSound( cgs.media.enemyTookYourFlagSound );
}
else if (cgs.clientinfo[cg.clientNum].team == TEAM_RED) {
#ifdef MISSIONPACK
if (cgs.gametype == GT_1FCTF)
CG_AddBufferedSound( cgs.media.enemyTookTheFlagSound );
else
#endif
CG_AddBufferedSound( cgs.media.yourTeamTookEnemyFlagSound );
}
}
break;
case GTS_BLUE_TAKEN: // CTF: blue team took the red flag, 1FCTF red team took the neutral flag
// if this player picked up the flag then a sound is played in CG_CheckLocalSounds
if (cg.snap->ps.powerups[PW_REDFLAG] || cg.snap->ps.powerups[PW_NEUTRALFLAG]) {
}
else {
if (cgs.clientinfo[cg.clientNum].team == TEAM_RED) {
#ifdef MISSIONPACK
if (cgs.gametype == GT_1FCTF)
CG_AddBufferedSound( cgs.media.yourTeamTookTheFlagSound );
else
#endif
CG_AddBufferedSound( cgs.media.enemyTookYourFlagSound );
}
else if (cgs.clientinfo[cg.clientNum].team == TEAM_BLUE) {
#ifdef MISSIONPACK
if (cgs.gametype == GT_1FCTF)
CG_AddBufferedSound( cgs.media.enemyTookTheFlagSound );
else
#endif
CG_AddBufferedSound( cgs.media.yourTeamTookEnemyFlagSound );
}
}
break;
case GTS_REDOBELISK_ATTACKED: // Overload: red obelisk is being attacked
if (cgs.clientinfo[cg.clientNum].team == TEAM_RED) {
CG_AddBufferedSound( cgs.media.yourBaseIsUnderAttackSound );
}
break;
case GTS_BLUEOBELISK_ATTACKED: // Overload: blue obelisk is being attacked
if (cgs.clientinfo[cg.clientNum].team == TEAM_BLUE) {
CG_AddBufferedSound( cgs.media.yourBaseIsUnderAttackSound );
}
break;
case GTS_REDTEAM_SCORED:
CG_AddBufferedSound(cgs.media.redScoredSound);
break;
case GTS_BLUETEAM_SCORED:
CG_AddBufferedSound(cgs.media.blueScoredSound);
break;
case GTS_REDTEAM_TOOK_LEAD:
CG_AddBufferedSound(cgs.media.redLeadsSound);
break;
case GTS_BLUETEAM_TOOK_LEAD:
CG_AddBufferedSound(cgs.media.blueLeadsSound);
break;
case GTS_TEAMS_ARE_TIED:
CG_AddBufferedSound( cgs.media.teamsTiedSound );
break;
#ifdef MISSIONPACK
case GTS_KAMIKAZE:
trap_S_StartLocalSound(cgs.media.kamikazeFarSound, CHAN_ANNOUNCER);
break;
#endif
default:
break;
}
break;
}
case EV_PAIN:
// local player sounds are triggered in CG_CheckLocalSounds,
// so ignore events on the player
DEBUGNAME("EV_PAIN");
if ( cent->currentState.number != cg.snap->ps.clientNum ) {
CG_PainEvent( cent, es->eventParm );
}
break;
case EV_DEATH1:
case EV_DEATH2:
case EV_DEATH3:
DEBUGNAME("EV_DEATHx");
trap_S_StartSound( NULL, es->number, CHAN_VOICE,
CG_CustomSound( es->number, va("*death%i.wav", event - EV_DEATH1 + 1) ) );
break;
case EV_OBITUARY:
DEBUGNAME("EV_OBITUARY");
CG_Obituary( es );
break;
//
// powerup events
//
case EV_POWERUP_QUAD:
DEBUGNAME("EV_POWERUP_QUAD");
if ( es->number == cg.snap->ps.clientNum ) {
cg.powerupActive = PW_QUAD;
cg.powerupTime = cg.time;
}
trap_S_StartSound (NULL, es->number, CHAN_ITEM, cgs.media.quadSound );
break;
case EV_POWERUP_BATTLESUIT:
DEBUGNAME("EV_POWERUP_BATTLESUIT");
if ( es->number == cg.snap->ps.clientNum ) {
cg.powerupActive = PW_BATTLESUIT;
cg.powerupTime = cg.time;
}
trap_S_StartSound (NULL, es->number, CHAN_ITEM, cgs.media.protectSound );
break;
case EV_POWERUP_REGEN:
DEBUGNAME("EV_POWERUP_REGEN");
if ( es->number == cg.snap->ps.clientNum ) {
cg.powerupActive = PW_REGEN;
cg.powerupTime = cg.time;
}
trap_S_StartSound (NULL, es->number, CHAN_ITEM, cgs.media.regenSound );
break;
case EV_GIB_PLAYER:
DEBUGNAME("EV_GIB_PLAYER");
// don't play gib sound when using the kamikaze because it interferes
// with the kamikaze sound, downside is that the gib sound will also
// not be played when someone is gibbed while just carrying the kamikaze
if ( !(es->eFlags & EF_KAMIKAZE) ) {
trap_S_StartSound( NULL, es->number, CHAN_BODY, cgs.media.gibSound );
}
CG_GibPlayer( cent->lerpOrigin );
break;
case EV_STOPLOOPINGSOUND:
DEBUGNAME("EV_STOPLOOPINGSOUND");
trap_S_StopLoopingSound( es->number );
es->loopSound = 0;
break;
case EV_DEBUG_LINE:
DEBUGNAME("EV_DEBUG_LINE");
CG_Beam( cent );
break;
default:
DEBUGNAME("UNKNOWN");
CG_Error( "Unknown event: %i", event );
break;
}
}
/*
================
CG_ConfigStringModified
================
*/
static void CG_ConfigStringModified( void ) {
const char *str;
int num;
num = atoi( CG_Argv( 1 ) );
// get the gamestate from the client system, which will have the
// new configstring already integrated
trap_GetGameState( &cgs.gameState );
// look up the individual string that was modified
str = CG_ConfigString( num );
// do something with it if necessary
if ( num == CS_MUSIC ) {
CG_StartMusic();
} else if ( num == CS_MUSIC_QUEUE ) { //----(SA) added
CG_QueueMusic();
} else if ( num == CS_MISSIONSTATS ) { //----(SA) added
CG_ParseMissionStats();
} else if ( num == CS_SERVERINFO ) {
CG_ParseServerinfo();
} else if ( num == CS_WARMUP ) {
CG_ParseWarmup();
} else if ( num == CS_SCORES1 ) {
cgs.scores1 = atoi( str );
} else if ( num == CS_SCORES2 ) {
cgs.scores2 = atoi( str );
} else if ( num == CS_LEVEL_START_TIME ) {
cgs.levelStartTime = atoi( str );
} else if ( num == CS_VOTE_TIME ) {
cgs.voteTime = atoi( str );
cgs.voteModified = qtrue;
} else if ( num == CS_VOTE_YES ) {
cgs.voteYes = atoi( str );
cgs.voteModified = qtrue;
} else if ( num == CS_VOTE_NO ) {
cgs.voteNo = atoi( str );
cgs.voteModified = qtrue;
} else if ( num == CS_VOTE_STRING ) {
Q_strncpyz( cgs.voteString, str, sizeof( cgs.voteString ) );
#if 0
trap_S_StartLocalSound( cgs.media.voteNow, CHAN_ANNOUNCER );
} else if ( num >= CS_TEAMVOTE_TIME && num <= CS_TEAMVOTE_TIME + 1 ) {
cgs.teamVoteTime[num - CS_TEAMVOTE_TIME] = atoi( str );
cgs.teamVoteModified[num - CS_TEAMVOTE_TIME] = qtrue;
} else if ( num >= CS_TEAMVOTE_YES && num <= CS_TEAMVOTE_YES + 1 ) {
cgs.teamVoteYes[num - CS_TEAMVOTE_YES] = atoi( str );
cgs.teamVoteModified[num - CS_TEAMVOTE_YES] = qtrue;
} else if ( num >= CS_TEAMVOTE_NO && num <= CS_TEAMVOTE_NO + 1 ) {
cgs.teamVoteNo[num - CS_TEAMVOTE_NO] = atoi( str );
cgs.teamVoteModified[num - CS_TEAMVOTE_NO] = qtrue;
} else if ( num >= CS_TEAMVOTE_STRING && num <= CS_TEAMVOTE_STRING + 1 ) {
Q_strncpyz( cgs.teamVoteString[num - CS_TEAMVOTE_STRING], str, sizeof( cgs.teamVoteString ) );
trap_S_StartLocalSound( cgs.media.voteNow, CHAN_ANNOUNCER );
#endif
} else if ( num == CS_INTERMISSION ) {
cg.intermissionStarted = atoi( str );
} else if ( num == CS_SCREENFADE ) {
CG_ParseScreenFade();
} else if ( num == CS_FOGVARS ) {
CG_ParseFog();
} else if ( num >= CS_MODELS && num < CS_MODELS + MAX_MODELS ) {
cgs.gameModels[ num - CS_MODELS ] = trap_R_RegisterModel( str );
} else if ( num >= CS_SOUNDS && num < CS_SOUNDS + MAX_MODELS ) {
if ( str[0] != '*' ) { // player specific sounds don't register here
// Ridah, register sound scripts seperately
if ( !strstr( str, ".wav" ) ) {
CG_SoundScriptPrecache( str );
} else {
cgs.gameSounds[ num - CS_SOUNDS] = trap_S_RegisterSound( str );
}
}
} else if ( num >= CS_PLAYERS && num < CS_PLAYERS + MAX_CLIENTS ) {
CG_NewClientInfo( num - CS_PLAYERS );
}
// Rafael particle configstring
else if ( num >= CS_PARTICLES && num < CS_PARTICLES + MAX_PARTICLES_AREAS ) {
CG_NewParticleArea( num );
}
//----(SA) have not reached this code yet so I don't know if I really need this here
else if ( num >= CS_DLIGHTS && num < CS_DLIGHTS + MAX_DLIGHTS ) {
CG_Printf( ">>>>>>>>>>>got configstring for dlight: %d\ntell Sherman!!!!!!!!!!", num - CS_DLIGHTS );
//----(SA)
} else if ( num == CS_SHADERSTATE ) {
CG_ShaderStateChanged();
}
}
/*
======================
CG_ParseWeaponFile
Parses a configuration file describing a weapon
======================
*/
static qboolean CG_ParseWeaponFile( const char *filename, weaponInfo_t *wi )
{
char *text_p;
int len;
char *token;
char text[ 20000 ];
fileHandle_t f;
weaponMode_t weaponMode = WPM_NONE;
// load the file
len = trap_FS_FOpenFile( filename, &f, FS_READ );
if( len <= 0 )
return qfalse;
if( len >= sizeof( text ) - 1 )
{
CG_Printf( "File %s too long\n", filename );
return qfalse;
}
trap_FS_Read( text, len, f );
text[ len ] = 0;
trap_FS_FCloseFile( f );
// parse the text
text_p = text;
// read optional parameters
while( 1 )
{
token = COM_Parse( &text_p );
if( !token )
break;
if( !Q_stricmp( token, "" ) )
break;
if( !Q_stricmp( token, "{" ) )
{
if( weaponMode == WPM_NONE )
{
CG_Printf( S_COLOR_RED "ERROR: weapon mode section started without a declaration\n" );
return qfalse;
}
else if( !CG_ParseWeaponModeSection( &wi->wim[ weaponMode ], &text_p ) )
{
CG_Printf( S_COLOR_RED "ERROR: failed to parse weapon mode section\n" );
return qfalse;
}
//start parsing ejectors again
weaponMode = WPM_NONE;
continue;
}
else if( !Q_stricmp( token, "primary" ) )
{
weaponMode = WPM_PRIMARY;
continue;
}
else if( !Q_stricmp( token, "secondary" ) )
{
weaponMode = WPM_SECONDARY;
continue;
}
else if( !Q_stricmp( token, "tertiary" ) )
{
weaponMode = WPM_TERTIARY;
continue;
}
else if( !Q_stricmp( token, "weaponModel" ) )
{
char path[ MAX_QPATH ];
token = COM_Parse( &text_p );
if( !token )
break;
wi->weaponModel = trap_R_RegisterModel( token );
if( !wi->weaponModel )
CG_Printf( S_COLOR_RED "ERROR: weapon model not found %s\n", token );
strcpy( path, token );
COM_StripExtension( path, path );
strcat( path, "_flash.md3" );
wi->flashModel = trap_R_RegisterModel( path );
strcpy( path, token );
COM_StripExtension( path, path );
strcat( path, "_barrel.md3" );
wi->barrelModel = trap_R_RegisterModel( path );
strcpy( path, token );
COM_StripExtension( path, path );
strcat( path, "_hand.md3" );
wi->handsModel = trap_R_RegisterModel( path );
if( !wi->handsModel )
wi->handsModel = trap_R_RegisterModel( "models/weapons2/shotgun/shotgun_hand.md3" );
continue;
}
else if( !Q_stricmp( token, "idleSound" ) )
{
token = COM_Parse( &text_p );
if( !token )
break;
wi->readySound = trap_S_RegisterSound( token, qfalse );
continue;
}
else if( !Q_stricmp( token, "icon" ) )
{
token = COM_Parse( &text_p );
if( !token )
break;
wi->weaponIcon = wi->ammoIcon = trap_R_RegisterShader( token );
if( !wi->weaponIcon )
CG_Printf( S_COLOR_RED "ERROR: weapon icon not found %s\n", token );
continue;
}
else if( !Q_stricmp( token, "crosshair" ) )
{
int size = 0;
token = COM_Parse( &text_p );
if( !token )
break;
size = atoi( token );
if( size < 0 )
size = 0;
token = COM_Parse( &text_p );
if( !token )
break;
wi->crossHair = trap_R_RegisterShader( token );
wi->crossHairSize = size;
if( !wi->crossHair )
CG_Printf( S_COLOR_RED "ERROR: weapon crosshair not found %s\n", token );
continue;
}
else if( !Q_stricmp( token, "disableIn3rdPerson" ) )
{
wi->disableIn3rdPerson = qtrue;
continue;
}
Com_Printf( S_COLOR_RED "ERROR: unknown token '%s'\n", token );
return qfalse;
}
return qtrue;
}
void SP_worldspawn( void ) {
char *s;
int i;
CG_SpawnString( "classname", "", &s );
if ( Q_stricmp( s, "worldspawn" ) ) {
CG_Error( "SP_worldspawn: The first entity isn't 'worldspawn'" );
}
cgs.ccLayers = 0;
if( CG_SpawnVector2D( "mapcoordsmins", "-128 128", cg.mapcoordsMins ) && // top left
CG_SpawnVector2D( "mapcoordsmaxs", "128 -128", cg.mapcoordsMaxs ) ) { // bottom right
cg.mapcoordsValid = qtrue;
} else {
cg.mapcoordsValid = qfalse;
}
CG_ParseSpawns();
CG_SpawnString( "cclayers", "0", &s );
cgs.ccLayers = atoi(s);
for( i = 0; i < cgs.ccLayers; i++ ) {
CG_SpawnString( va("cclayerceil%i",i), "0", &s );
cgs.ccLayerCeils[i] = atoi(s);
}
cg.mapcoordsScale[0] = 1 / (cg.mapcoordsMaxs[0] - cg.mapcoordsMins[0]);
cg.mapcoordsScale[1] = 1 / (cg.mapcoordsMaxs[1] - cg.mapcoordsMins[1]);
BG_InitLocations( cg.mapcoordsMins, cg.mapcoordsMaxs );
CG_SpawnString( "atmosphere", "", &s );
CG_EffectParse( s );
cg.fiveMinuteSound_g[0] = \
cg.fiveMinuteSound_a[0] = \
cg.twoMinuteSound_g[0] = \
cg.twoMinuteSound_a[0] = \
cg.thirtySecondSound_g[0] = \
cg.thirtySecondSound_a[0] = '\0';
CG_SpawnString( "twoMinuteSound_axis", "axis_hq_5minutes", &s );
Q_strncpyz( cg.fiveMinuteSound_g, s, sizeof(cg.fiveMinuteSound_g) );
CG_SpawnString( "twoMinuteSound_allied", "allies_hq_5minutes", &s );
Q_strncpyz( cg.fiveMinuteSound_a, s, sizeof(cg.fiveMinuteSound_a) );
CG_SpawnString( "twoMinuteSound_axis", "axis_hq_2minutes", &s );
Q_strncpyz( cg.twoMinuteSound_g, s, sizeof(cg.twoMinuteSound_g) );
CG_SpawnString( "twoMinuteSound_allied", "allies_hq_2minutes", &s );
Q_strncpyz( cg.twoMinuteSound_a, s, sizeof(cg.twoMinuteSound_a) );
CG_SpawnString( "thirtySecondSound_axis", "axis_hq_30seconds", &s );
Q_strncpyz( cg.thirtySecondSound_g, s, sizeof(cg.thirtySecondSound_g) );
CG_SpawnString( "thirtySecondSound_allied", "allies_hq_30seconds", &s );
Q_strncpyz( cg.thirtySecondSound_a, s, sizeof(cg.thirtySecondSound_a) );
// 5 minute axis
if( !*cg.fiveMinuteSound_g )
cgs.media.fiveMinuteSound_g = 0;
else if( strstr( cg.fiveMinuteSound_g, ".wav" ) )
cgs.media.fiveMinuteSound_g = trap_S_RegisterSound( cg.fiveMinuteSound_g, qtrue );
else
cgs.media.fiveMinuteSound_g = -1;
// 5 minute allied
if( !*cg.fiveMinuteSound_a )
cgs.media.fiveMinuteSound_a = 0;
else if( strstr( cg.fiveMinuteSound_a, ".wav" ) )
cgs.media.fiveMinuteSound_a = trap_S_RegisterSound( cg.fiveMinuteSound_a, qtrue );
else
cgs.media.fiveMinuteSound_a = -1;
// 2 minute axis
if( !*cg.twoMinuteSound_g )
cgs.media.twoMinuteSound_g = 0;
else if( strstr( cg.twoMinuteSound_g, ".wav" ) )
cgs.media.twoMinuteSound_g = trap_S_RegisterSound( cg.twoMinuteSound_g, qtrue );
else
cgs.media.twoMinuteSound_g = -1;
// 2 minute allied
if( !*cg.twoMinuteSound_a )
cgs.media.twoMinuteSound_a = 0;
else if( strstr( cg.twoMinuteSound_a, ".wav" ) )
cgs.media.twoMinuteSound_a = trap_S_RegisterSound( cg.twoMinuteSound_a, qtrue );
else
cgs.media.twoMinuteSound_a = -1;
// 30 seconds axis
if( !*cg.thirtySecondSound_g )
cgs.media.thirtySecondSound_g = 0;
else if( strstr( cg.thirtySecondSound_g, ".wav" ) )
cgs.media.thirtySecondSound_g = trap_S_RegisterSound( cg.thirtySecondSound_g, qtrue );
else
cgs.media.thirtySecondSound_g = -1;
// 30 seconds allied
if( !*cg.thirtySecondSound_a )
cgs.media.thirtySecondSound_a = 0;
else if( strstr( cg.thirtySecondSound_a, ".wav" ) )
cgs.media.thirtySecondSound_a = trap_S_RegisterSound( cg.thirtySecondSound_a, qtrue );
else
cgs.media.thirtySecondSound_a = -1;
}
/*
===============
CG_InitBuildables
Initialises the animation db
===============
*/
void CG_InitBuildables( void )
{
char filename[ MAX_QPATH ];
char soundfile[ MAX_QPATH ];
char *buildableName;
char *modelFile;
int i;
int j;
fileHandle_t f;
memset( cg_buildables, 0, sizeof( cg_buildables ) );
//default sounds
for( j = BANIM_NONE + 1; j < MAX_BUILDABLE_ANIMATIONS; j++ )
{
strcpy( soundfile, cg_buildableSoundNames[ j - 1 ] );
Com_sprintf( filename, sizeof( filename ), "sound/buildables/alien/%s", soundfile );
defaultAlienSounds[ j ] = trap_S_RegisterSound( filename, qfalse );
Com_sprintf( filename, sizeof( filename ), "sound/buildables/human/%s", soundfile );
defaultHumanSounds[ j ] = trap_S_RegisterSound( filename, qfalse );
}
cg.buildablesFraction = 0.0f;
for( i = BA_NONE + 1; i < BA_NUM_BUILDABLES; i++ )
{
buildableName = BG_Buildable( i )->name;
//animation.cfg
Com_sprintf( filename, sizeof( filename ), "models/buildables/%s/animation.cfg", buildableName );
if ( !CG_ParseBuildableAnimationFile( filename, i ) )
Com_Printf( S_COLOR_YELLOW "WARNING: failed to load animation file %s\n", filename );
//sound.cfg
Com_sprintf( filename, sizeof( filename ), "sound/buildables/%s/sound.cfg", buildableName );
if ( !CG_ParseBuildableSoundFile( filename, i ) )
Com_Printf( S_COLOR_YELLOW "WARNING: failed to load sound file %s\n", filename );
//models
for( j = 0; j <= 3; j++ )
{
modelFile = BG_BuildableConfig( i )->models[ j ];
if( strlen( modelFile ) > 0 )
cg_buildables[ i ].models[ j ] = trap_R_RegisterModel( modelFile );
}
//sounds
for( j = BANIM_NONE + 1; j < MAX_BUILDABLE_ANIMATIONS; j++ )
{
strcpy( soundfile, cg_buildableSoundNames[ j - 1 ] );
Com_sprintf( filename, sizeof( filename ), "sound/buildables/%s/%s", buildableName, soundfile );
if( cg_buildables[ i ].sounds[ j ].enabled )
{
if( trap_FS_FOpenFile( filename, &f, FS_READ ) > 0 )
{
//file exists so close it
trap_FS_FCloseFile( f );
cg_buildables[ i ].sounds[ j ].sound = trap_S_RegisterSound( filename, qfalse );
}
else
{
//file doesn't exist - use default
if( BG_Buildable( i )->team == TEAM_ALIENS )
cg_buildables[ i ].sounds[ j ].sound = defaultAlienSounds[ j ];
else
cg_buildables[ i ].sounds[ j ].sound = defaultHumanSounds[ j ];
}
}
}
cg.buildablesFraction = (float)i / (float)( BA_NUM_BUILDABLES - 1 );
trap_UpdateScreen( );
}
cgs.media.teslaZapTS = CG_RegisterTrailSystem( "models/buildables/tesla/zap" );
}
int WM_DrawObjectives( int x, int y, int width, float fade ) {
const char *s, *buf, *str;
char teamstr[32];
int i, num, strwidth, status;
int height, tempy, rows;
vec4_t hcolor;
int msec, mins, seconds, tens; // JPW NERVE
rows = 7;
height = SMALLCHAR_HEIGHT * rows;
hcolor[0] = hcolor[1] = hcolor[2] = 1;
hcolor[3] = 1.f;
trap_R_SetColor( hcolor );
if ( cg.snap->ps.pm_type != PM_INTERMISSION ) {
CG_DrawPic( x - 10, y, width + 20, height + SMALLCHAR_HEIGHT + 10 + 1, trap_R_RegisterShaderNoMip( "ui_mp/assets/mp_score_objectives" ) );
}
VectorSet( hcolor, 1, 1, 1 );
trap_R_SetColor( NULL );
VectorSet( hcolor, ( 68.f / 255.f ), ( 0.f / 255.f ), ( 0.f / 255.f ) );
hcolor[3] = 1 * fade;
// draw header
if ( cg.snap->ps.pm_type != PM_INTERMISSION ) {
CG_DrawSmallString( x, y, CG_TranslateString( "Goals" ), fade );
}
y += SMALLCHAR_HEIGHT + 3;
// draw color bands
tempy = y;
if ( cg.snap->ps.pm_type != PM_INTERMISSION ) {
for ( i = 0; i < rows; i++ ) {
hcolor[3] = fade * 0.3;
if ( i % 2 == 0 ) {
VectorSet( hcolor, ( 0.f / 255.f ), ( 113.f / 255.f ), ( 163.f / 255.f ) ); // LIGHT BLUE
} else {
VectorSet( hcolor, ( 0.f / 255.f ), ( 92.f / 255.f ), ( 133.f / 255.f ) ); // DARK BLUE
}
hcolor[3] = 0;
CG_FillRect( x, y, width, SMALLCHAR_HEIGHT, hcolor );
y += SMALLCHAR_HEIGHT;
}
}
hcolor[3] = 1;
y = tempy;
if ( cg.snap->ps.pm_type == PM_INTERMISSION ) {
const char *s, *buf, *shader = NULL, *flagshader = NULL, *nameshader = NULL;
s = CG_ConfigString( CS_MULTI_MAPWINNER );
buf = Info_ValueForKey( s, "winner" );
if ( atoi( buf ) == -1 ) {
str = "ITS A TIE!";
} else if ( atoi( buf ) ) {
str = "ALLIES";
shader = "ui_mp/assets/portraits/allies_win";
flagshader = "ui_mp/assets/portraits/allies_win_flag.tga";
nameshader = "ui_mp/assets/portraits/text_allies.tga";
if ( !cg.latchVictorySound ) {
cg.latchVictorySound = qtrue;
trap_S_StartLocalSound( trap_S_RegisterSound( "sound/multiplayer/music/l_complete_2.wav" ), CHAN_LOCAL_SOUND );
}
} else {
str = "AXIS";
shader = "ui_mp/assets/portraits/axis_win";
flagshader = "ui_mp/assets/portraits/axis_win_flag.tga";
nameshader = "ui_mp/assets/portraits/text_axis.tga";
if ( !cg.latchVictorySound ) {
cg.latchVictorySound = qtrue;
trap_S_StartLocalSound( trap_S_RegisterSound( "sound/multiplayer/music/s_stinglow.wav" ), CHAN_LOCAL_SOUND );
}
}
y += SMALLCHAR_HEIGHT * ( ( rows - 2 ) / 2 );
if ( flagshader ) {
CG_DrawPic( 10, 10, 210, 136, trap_R_RegisterShaderNoMip( flagshader ) );
CG_DrawPic( 415, 10, 210, 136, trap_R_RegisterShaderNoMip( flagshader ) );
}
if ( shader ) {
CG_DrawPic( 229, 10, 182, 136, trap_R_RegisterShaderNoMip( shader ) );
}
if ( nameshader ) {
CG_DrawPic( 50, 50, 127, 64, trap_R_RegisterShaderNoMip( nameshader ) );
CG_DrawPic( 455, 50, 127, 64, trap_R_RegisterShaderNoMip( "ui_mp/assets/portraits/text_win.tga" ) );
}
return y;
}
// JPW NERVE -- mission time & reinforce time
else {
tempy = y;
y += SMALLCHAR_HEIGHT * ( rows - 1 );
msec = ( cgs.timelimit * 60.f * 1000.f ) - ( cg.time - cgs.levelStartTime );
seconds = msec / 1000;
mins = seconds / 60;
seconds -= mins * 60;
tens = seconds / 10;
seconds -= tens * 10;
if ( msec < 0 ) {
s = va( "%s %s", CG_TranslateString( "Mission time:" ), CG_TranslateString( "Sudden Death" ) );
} else {
s = va( "%s %2.0f:%i%i", CG_TranslateString( "Mission time:" ), (float)mins, tens, seconds ); // float cast to line up with reinforce time
}
CG_DrawSmallString( x,y,s,fade );
if ( cgs.clientinfo[cg.snap->ps.clientNum].team == TEAM_RED ) {
msec = cg_redlimbotime.integer - ( cg.time % cg_redlimbotime.integer );
} else if ( cgs.clientinfo[cg.snap->ps.clientNum].team == TEAM_BLUE ) {
msec = cg_bluelimbotime.integer - ( cg.time % cg_bluelimbotime.integer );
} else { // no team (spectator mode)
msec = 0;
}
if ( msec ) {
seconds = msec / 1000;
mins = seconds / 60;
seconds -= mins * 60;
tens = seconds / 10;
seconds -= tens * 10;
s = va( "%s %2.0f:%i%i", CG_TranslateString( "Reinforce time:" ), (float)mins, tens, seconds );
CG_DrawSmallString( x + 425,y,s,fade );
}
// NERVE - SMF
if ( cgs.gametype == GT_WOLF_STOPWATCH ) {
int w;
s = va( "%s %i", CG_TranslateString( "Stopwatch Round" ), cgs.currentRound + 1 );
w = CG_DrawStrlen( s ) * SMALLCHAR_WIDTH;
CG_DrawSmallString( x + 300 - w / 2,y,s,fade );
}
// -NERVE - SMF
y = tempy;
}
// jpw
// determine character's team
if ( cg.snap->ps.persistant[PERS_TEAM] == TEAM_RED ) {
strcpy( teamstr, "short_axis_desc" );
} else {
strcpy( teamstr, "short_allied_desc" );
}
s = CG_ConfigString( CS_MULTI_INFO );
buf = Info_ValueForKey( s, "numobjectives" );
if ( buf && atoi( buf ) ) {
num = atoi( buf );
for ( i = 0; i < num; i++ ) {
s = CG_ConfigString( CS_MULTI_OBJECTIVE1 + i );
buf = Info_ValueForKey( s, teamstr );
if ( !buf || !strlen( buf ) ) {
str = va( "%s %i", CG_TranslateString( "Objective" ), i + 1 );
} else {
str = va( "%s", CG_TranslateString( buf ) );
}
// draw text
strwidth = CG_DrawStrlen( str ) * SMALLCHAR_WIDTH;
CG_DrawSmallString( x + width / 2 - strwidth / 2 - 12, y, str, fade );
// draw status flags
s = CG_ConfigString( CS_MULTI_OBJ1_STATUS + i );
status = atoi( Info_ValueForKey( s, "status" ) );
if ( status == 0 ) {
CG_DrawPic( x, y + 1, 24, 14, trap_R_RegisterShaderNoMip( "ui_mp/assets/ger_flag.tga" ) );
} else if ( status == 1 ) {
CG_DrawPic( x, y + 1, 24, 14, trap_R_RegisterShaderNoMip( "ui_mp/assets/usa_flag.tga" ) );
}
y += SMALLCHAR_HEIGHT;
}
}
return y;
}
void UI_DrawPlayer( float x, float y, float w, float h, playerInfo_t *pi, int time ) {
refdef_t refdef;
refEntity_t legs;
refEntity_t torso;
refEntity_t head;
refEntity_t gun;
refEntity_t barrel;
refEntity_t backpack;
refEntity_t helmet;
// refEntity_t barrel;
refEntity_t flash;
vec3_t origin;
int renderfx;
vec3_t mins = {-16, -16, -24};
vec3_t maxs = {16, 16, 32};
float len;
float xx;
vec4_t hcolor = { 1, 0, 0, 0.5 };
const char *torso_anim = NULL, *legs_anim = NULL;
if ( !pi->legsModel || !pi->torsoModel || !pi->headModel || !pi->animations[0].numFrames ) {
return;
}
dp_realtime = time;
if ( pi->pendingWeapon != -1 && dp_realtime > pi->weaponTimer ) {
pi->weapon = pi->pendingWeapon;
pi->lastWeapon = pi->pendingWeapon;
pi->pendingWeapon = -1;
pi->weaponTimer = 0;
if( pi->currentWeapon != pi->weapon ) {
trap_S_StartLocalSound( trap_S_RegisterSound( "sound/weapons/change.wav" ), CHAN_LOCAL );
}
}
UI_AdjustFrom640( &x, &y, &w, &h );
y -= jumpHeight;
memset( &refdef, 0, sizeof( refdef ) );
memset( &legs, 0, sizeof(legs) );
memset( &torso, 0, sizeof(torso) );
memset( &head, 0, sizeof(head) );
refdef.rdflags = RDF_NOWORLDMODEL;
AxisClear( refdef.viewaxis );
refdef.x = x;
refdef.y = y;
refdef.width = w;
refdef.height = h;
refdef.fov_x = (int)((float)refdef.width / 640.0f * 90.0f);
xx = refdef.width / tan( refdef.fov_x / 360 * M_PI );
refdef.fov_y = atan2( refdef.height, xx );
refdef.fov_y *= ( 360 / M_PI );
// calculate distance so the player nearly fills the box
len = 1.01 * ( maxs[2] - mins[2] ); // NERVE - SMF - changed from 0.7
origin[0] = len / tan( DEG2RAD(refdef.fov_x) * 0.5 );
origin[1] = 0.5 * ( mins[1] + maxs[1] );
origin[2] = -0.5 * ( mins[2] + maxs[2] );
refdef.time = dp_realtime;
trap_R_SetColor( hcolor );
trap_R_ClearScene();
trap_R_SetColor( NULL );
// get the rotation information
UI_PlayerAngles( pi, legs.axis, torso.axis, head.axis );
// get the animation state (after rotation, to allow feet shuffle)
// UI_PlayerAnimation( pi, &legs.oldframe, &legs.frame, &legs.backlerp,
// &torso.oldframe, &torso.frame, &torso.backlerp );
renderfx = RF_LIGHTING_ORIGIN | RF_NOSHADOW;
//
// add the body
//
legs.hModel = pi->legsModel;
legs.customSkin = pi->legsSkin;
legs.renderfx = renderfx;
VectorCopy( origin, legs.origin );
VectorCopy( origin, legs.lightingOrigin );
VectorCopy (legs.origin, legs.oldorigin);
WM_getWeaponAnim( &torso_anim, &legs_anim );
if ( torso_anim ) {
legs.torsoFrame = UI_GetAnimation( pi, torso_anim );
legs.oldTorsoFrame = UI_GetAnimation( pi, torso_anim );
}
legs.torsoBacklerp = 0; //torso.backlerp;
if ( legs_anim ) {
legs.frame = UI_GetAnimation( pi, legs_anim );
legs.oldframe = UI_GetAnimation( pi, legs_anim );
}
legs.backlerp = 0;
memcpy( legs.torsoAxis, torso.axis, sizeof(torso.axis) );
torso = legs;
trap_R_AddRefEntityToScene( &torso );
//
// add the head
//
head.hModel = pi->headModel;
if (!head.hModel) {
return;
}
head.customSkin = pi->headSkin;
VectorCopy( origin, head.lightingOrigin );
UI_PositionRotatedEntityOnTag( &head, &torso, pi->torsoModel, "tag_head");
head.renderfx = renderfx;
trap_R_AddRefEntityToScene( &head );
//
// add the gun
//
if ( pi->currentWeapon != WP_NONE ) {
memset( &gun, 0, sizeof(gun) );
gun.hModel = pi->weaponModel;
VectorCopy( origin, gun.lightingOrigin );
UI_PositionEntityOnTag( &gun, &torso, pi->torsoModel, "tag_weapon");
gun.renderfx = renderfx;
trap_R_AddRefEntityToScene( &gun );
}
//
// add the gun barrel
//
if ( pi->currentWeapon != WP_NONE && pi->barrelModel ) {
memset( &barrel, 0, sizeof(barrel) );
barrel.hModel = pi->barrelModel;
VectorCopy( origin, barrel.lightingOrigin );
UI_PositionEntityOnTag( &barrel, &gun, pi->weaponModel, "tag_barrel");
barrel.renderfx = renderfx;
trap_R_AddRefEntityToScene( &barrel );
}
//
// add muzzle flash
//
if ( dp_realtime <= pi->muzzleFlashTime ) {
if ( pi->flashModel ) {
memset( &flash, 0, sizeof(flash) );
flash.hModel = pi->flashModel;
VectorCopy( origin, flash.lightingOrigin );
UI_PositionEntityOnTag( &flash, &gun, pi->weaponModel, "tag_flash");
flash.renderfx = renderfx;
trap_R_AddRefEntityToScene( &flash );
}
// make a dlight for the flash
if ( pi->flashDlightColor[0] || pi->flashDlightColor[1] || pi->flashDlightColor[2] ) {
trap_R_AddLightToScene( flash.origin, 200 + (rand()&31), pi->flashDlightColor[0],
pi->flashDlightColor[1], pi->flashDlightColor[2], 0 );
}
}
//
// add the backpack
//
if ( pi->backpackModel ) {
memset( &backpack, 0, sizeof(backpack) );
backpack.hModel = pi->backpackModel;
VectorCopy( origin, backpack.lightingOrigin );
UI_PositionEntityOnTag( &backpack, &torso, pi->torsoModel, "tag_back");
backpack.renderfx = renderfx;
trap_R_AddRefEntityToScene( &backpack );
}
//
// add the helmet
//
if ( pi->helmetModel ) {
memset( &helmet, 0, sizeof(helmet) );
helmet.hModel = pi->helmetModel;
VectorCopy( origin, helmet.lightingOrigin );
UI_PositionEntityOnTag( &helmet, &head, pi->headModel, "tag_mouth");
helmet.renderfx = renderfx;
trap_R_AddRefEntityToScene( &helmet );
}
//
// add the chat icon
//
if ( pi->chat ) {
UI_PlayerFloatSprite( pi, origin, trap_R_RegisterShaderNoMip( "sprites/balloon3" ) );
}
//
// add an accent light
//
origin[0] -= 100; // + = behind, - = in front
origin[1] += 100; // + = left, - = right
origin[2] += 100; // + = above, - = below
trap_R_AddLightToScene( origin, 1000, 1.0, 1.0, 1.0, 0 );
origin[0] -= 100;
origin[1] -= 100;
origin[2] -= 100;
trap_R_AddLightToScene( origin, 1000, 1.0, 1.0, 1.0, 0 );
trap_R_RenderScene( &refdef );
}
/*
=================
UI_SPPostgameMenu_f
=================
*/
void UI_SPPostgameMenu_f( void ) {
int playerGameRank;
int playerClientNum;
int n;
int oldFrags, newFrags;
const char *arena;
int awardValues[6];
char map[MAX_QPATH];
char info[MAX_INFO_STRING];
memset( &postgameMenuInfo, 0, sizeof(postgameMenuInfo) );
trap_GetConfigString( CS_SYSTEMINFO, info, sizeof(info) );
postgameMenuInfo.serverId = atoi( Info_ValueForKey( info, "sv_serverid" ) );
trap_GetConfigString( CS_SERVERINFO, info, sizeof(info) );
Q_strncpyz( map, Info_ValueForKey( info, "mapname" ), sizeof(map) );
arena = UI_GetArenaInfoByMap( map );
if ( !arena ) {
return;
}
Q_strncpyz( arenainfo, arena, sizeof(arenainfo) );
postgameMenuInfo.level = atoi( Info_ValueForKey( arenainfo, "num" ) );
postgameMenuInfo.numClients = atoi( UI_Argv( 1 ) );
playerClientNum = atoi( UI_Argv( 2 ) );
playerGameRank = 8; // in case they ended game as a spectator
if( postgameMenuInfo.numClients > MAX_SCOREBOARD_CLIENTS ) {
postgameMenuInfo.numClients = MAX_SCOREBOARD_CLIENTS;
}
for( n = 0; n < postgameMenuInfo.numClients; n++ ) {
postgameMenuInfo.clientNums[n] = atoi( UI_Argv( 8 + n * 3 + 1 ) );
postgameMenuInfo.ranks[n] = atoi( UI_Argv( 8 + n * 3 + 2 ) );
postgameMenuInfo.scores[n] = atoi( UI_Argv( 8 + n * 3 + 3 ) );
if( postgameMenuInfo.clientNums[n] == playerClientNum ) {
playerGameRank = (postgameMenuInfo.ranks[n] & ~RANK_TIED_FLAG) + 1;
}
}
UI_SetBestScore( postgameMenuInfo.level, playerGameRank );
// process award stats and prepare presentation data
awardValues[AWARD_ACCURACY] = atoi( UI_Argv( 3 ) );
awardValues[AWARD_IMPRESSIVE] = atoi( UI_Argv( 4 ) );
awardValues[AWARD_EXCELLENT] = atoi( UI_Argv( 5 ) );
awardValues[AWARD_GAUNTLET] = atoi( UI_Argv( 6 ) );
awardValues[AWARD_FRAGS] = atoi( UI_Argv( 7 ) );
awardValues[AWARD_PERFECT] = atoi( UI_Argv( 8 ) );
postgameMenuInfo.numAwards = 0;
if( awardValues[AWARD_ACCURACY] >= 50 ) {
UI_LogAwardData( AWARD_ACCURACY, 1 );
postgameMenuInfo.awardsEarned[postgameMenuInfo.numAwards] = AWARD_ACCURACY;
postgameMenuInfo.awardsLevels[postgameMenuInfo.numAwards] = awardValues[AWARD_ACCURACY];
postgameMenuInfo.numAwards++;
}
if( awardValues[AWARD_IMPRESSIVE] ) {
UI_LogAwardData( AWARD_IMPRESSIVE, awardValues[AWARD_IMPRESSIVE] );
postgameMenuInfo.awardsEarned[postgameMenuInfo.numAwards] = AWARD_IMPRESSIVE;
postgameMenuInfo.awardsLevels[postgameMenuInfo.numAwards] = awardValues[AWARD_IMPRESSIVE];
postgameMenuInfo.numAwards++;
}
if( awardValues[AWARD_EXCELLENT] ) {
UI_LogAwardData( AWARD_EXCELLENT, awardValues[AWARD_EXCELLENT] );
postgameMenuInfo.awardsEarned[postgameMenuInfo.numAwards] = AWARD_EXCELLENT;
postgameMenuInfo.awardsLevels[postgameMenuInfo.numAwards] = awardValues[AWARD_EXCELLENT];
postgameMenuInfo.numAwards++;
}
if( awardValues[AWARD_GAUNTLET] ) {
UI_LogAwardData( AWARD_GAUNTLET, awardValues[AWARD_GAUNTLET] );
postgameMenuInfo.awardsEarned[postgameMenuInfo.numAwards] = AWARD_GAUNTLET;
postgameMenuInfo.awardsLevels[postgameMenuInfo.numAwards] = awardValues[AWARD_GAUNTLET];
postgameMenuInfo.numAwards++;
}
oldFrags = UI_GetAwardLevel( AWARD_FRAGS ) / 100;
UI_LogAwardData( AWARD_FRAGS, awardValues[AWARD_FRAGS] );
newFrags = UI_GetAwardLevel( AWARD_FRAGS ) / 100;
if( newFrags > oldFrags ) {
postgameMenuInfo.awardsEarned[postgameMenuInfo.numAwards] = AWARD_FRAGS;
postgameMenuInfo.awardsLevels[postgameMenuInfo.numAwards] = newFrags * 100;
postgameMenuInfo.numAwards++;
}
if( awardValues[AWARD_PERFECT] ) {
UI_LogAwardData( AWARD_PERFECT, 1 );
postgameMenuInfo.awardsEarned[postgameMenuInfo.numAwards] = AWARD_PERFECT;
postgameMenuInfo.awardsLevels[postgameMenuInfo.numAwards] = 1;
postgameMenuInfo.numAwards++;
}
if ( playerGameRank == 1 ) {
postgameMenuInfo.won = UI_TierCompleted( postgameMenuInfo.level );
}
else {
postgameMenuInfo.won = -1;
}
postgameMenuInfo.starttime = uis.realtime;
postgameMenuInfo.scoreboardtime = uis.realtime;
trap_Key_SetCatcher( KEYCATCH_UI );
uis.menusp = 0;
UI_SPPostgameMenu_Init();
UI_PushMenu( &postgameMenuInfo.menu );
if ( playerGameRank == 1 ) {
Menu_SetCursorToItem( &postgameMenuInfo.menu, &postgameMenuInfo.item_next );
}
else {
Menu_SetCursorToItem( &postgameMenuInfo.menu, &postgameMenuInfo.item_again );
}
Prepname( 0 );
Prepname( 1 );
Prepname( 2 );
if ( playerGameRank != 1 ) {
postgameMenuInfo.winnerSound = trap_S_RegisterSound( va( "sound/player/announce/%s_wins.wav", postgameMenuInfo.placeNames[0] ), qfalse );
trap_Cmd_ExecuteText( EXEC_APPEND, "music music/loss\n" );
}
else {
postgameMenuInfo.winnerSound = trap_S_RegisterSound( "sound/player/announce/youwin.wav", qfalse );
trap_Cmd_ExecuteText( EXEC_APPEND, "music music/win\n" );
}
postgameMenuInfo.phase = 1;
postgameMenuInfo.lastTier = UI_GetNumSPTiers();
if ( UI_GetSpecialArenaInfo( "final" ) ) {
postgameMenuInfo.lastTier++;
}
trap_Cvar_Set( "cl_postgame", "1" );
}
/*
=================
CG_RegisterWeapon
The server says this item is used on this level
=================
*/
void CG_RegisterWeapon( int weaponNum) {
weaponInfo_t *weaponInfo;
gitem_t *item, *ammo;
char path[MAX_QPATH];
vec3_t mins, maxs;
int i;
weaponInfo = &cg_weapons[weaponNum];
if ( weaponNum == 0 ) {
return;
}
if ( weaponInfo->registered ) {
return;
}
memset( weaponInfo, 0, sizeof( *weaponInfo ) );
weaponInfo->registered = qtrue;
for ( item = bg_itemlist + 1 ; item->classname ; item++ ) {
if ( item->giType == IT_WEAPON && item->giTag == weaponNum ) {
weaponInfo->item = item;
break;
}
}
if ( !item->classname ) {
CG_Error( "Couldn't find weapon %i", weaponNum );
}
CG_RegisterItemVisuals( item - bg_itemlist );
// load cmodel before model so filecache works
weaponInfo->weaponModel = trap_R_RegisterModel( item->world_model[0] );
// load in-view model also
weaponInfo->viewModel = trap_R_RegisterModel(item->view_model);
// calc midpoint for rotation
trap_R_ModelBounds( weaponInfo->weaponModel, mins, maxs );
for ( i = 0 ; i < 3 ; i++ ) {
weaponInfo->weaponMidpoint[i] = mins[i] + 0.5 * ( maxs[i] - mins[i] );
}
weaponInfo->weaponIcon = trap_R_RegisterShader( item->icon );
weaponInfo->ammoIcon = trap_R_RegisterShader( item->icon );
for ( ammo = bg_itemlist + 1 ; ammo->classname ; ammo++ ) {
if ( ammo->giType == IT_AMMO && ammo->giTag == weaponNum ) {
break;
}
}
if ( ammo->classname && ammo->world_model[0] ) {
weaponInfo->ammoModel = trap_R_RegisterModel( ammo->world_model[0] );
}
// strcpy( path, item->view_model );
// COM_StripExtension( path, path );
// strcat( path, "_flash.md3" );
weaponInfo->flashModel = 0;//trap_R_RegisterModel( path );
if (weaponNum == WP_DISRUPTOR ||
weaponNum == WP_FLECHETTE ||
weaponNum == WP_REPEATER ||
weaponNum == WP_ROCKET_LAUNCHER)
{
strcpy( path, item->view_model );
COM_StripExtension( path, path, sizeof(path) );
strcat( path, "_barrel.md3" );
weaponInfo->barrelModel = trap_R_RegisterModel( path );
}
else if (weaponNum == WP_STUN_BATON)
{ //only weapon with more than 1 barrel..
trap_R_RegisterModel("models/weapons2/stun_baton/baton_barrel.md3");
trap_R_RegisterModel("models/weapons2/stun_baton/baton_barrel2.md3");
trap_R_RegisterModel("models/weapons2/stun_baton/baton_barrel3.md3");
}
else
{
weaponInfo->barrelModel = 0;
}
if (weaponNum != WP_SABER)
{
strcpy( path, item->view_model );
COM_StripExtension( path, path, sizeof(path) );
strcat( path, "_hand.md3" );
weaponInfo->handsModel = trap_R_RegisterModel( path );
}
else
{
weaponInfo->handsModel = 0;
}
// if ( !weaponInfo->handsModel ) {
// weaponInfo->handsModel = trap_R_RegisterModel( "models/weapons2/shotgun/shotgun_hand.md3" );
// }
cgs.effects.forceLightning = trap_FX_RegisterEffect( "effects/force/lightning.efx" );
cgs.effects.forceLightningWide = trap_FX_RegisterEffect( "effects/force/lightningwide.efx" );
cgs.effects.forceDrain = trap_FX_RegisterEffect( "effects/mp/drain.efx" );
cgs.effects.forceDrainWide = trap_FX_RegisterEffect( "effects/mp/drainwide.efx" );
cgs.effects.forceDrained = trap_FX_RegisterEffect( "effects/mp/drainhit.efx");
switch ( weaponNum ) {
case WP_STUN_BATON:
/* MAKERGB( weaponInfo->flashDlightColor, 0.6f, 0.6f, 1.0f );
weaponInfo->firingSound = trap_S_RegisterSound( "sound/weapons/saber/saberhum.wav" );
// weaponInfo->flashSound[0] = trap_S_RegisterSound( "sound/weapons/melee/fstatck.wav" );
*/
//trap_R_RegisterShader( "gfx/effects/stunPass" );
trap_FX_RegisterEffect( "stunBaton/flesh_impact" );
//TEMP
trap_S_RegisterSound( "sound/weapons/melee/punch1.mp3" );
trap_S_RegisterSound( "sound/weapons/melee/punch2.mp3" );
trap_S_RegisterSound( "sound/weapons/melee/punch3.mp3" );
trap_S_RegisterSound( "sound/weapons/melee/punch4.mp3" );
trap_S_RegisterSound( "sound/weapons/baton/idle.wav" );
weaponInfo->flashSound[0] = trap_S_RegisterSound( "sound/weapons/baton/fire.mp3" );
weaponInfo->altFlashSound[0] = trap_S_RegisterSound( "sound/weapons/baton/fire.mp3" );
break;
case WP_SABER:
MAKERGB( weaponInfo->flashDlightColor, 0.6f, 0.6f, 1.0f );
weaponInfo->firingSound = trap_S_RegisterSound( "sound/weapons/saber/saberhum1.wav" );
weaponInfo->missileModel = trap_R_RegisterModel( "models/weapons2/saber/saber_w.glm" );
break;
case WP_BRYAR_PISTOL:
weaponInfo->flashSound[0] = trap_S_RegisterSound( "sound/weapons/bryar/fire.wav");
weaponInfo->firingSound = NULL_SOUND;
weaponInfo->chargeSound = NULL_SOUND;
weaponInfo->muzzleEffect = trap_FX_RegisterEffect( "bryar/muzzle_flash" );
weaponInfo->missileModel = NULL_HANDLE;
weaponInfo->missileSound = NULL_SOUND;
weaponInfo->missileDlight = 0;
//weaponInfo->missileDlightColor= {0,0,0};
weaponInfo->missileHitSound = NULL_SOUND;
weaponInfo->missileTrailFunc = FX_BryarProjectileThink;
weaponInfo->altFlashSound[0] = trap_S_RegisterSound( "sound/weapons/bryar/alt_fire.wav");
weaponInfo->altFiringSound = NULL_SOUND;
weaponInfo->altChargeSound = trap_S_RegisterSound( "sound/weapons/bryar/altcharge.wav");
weaponInfo->altMuzzleEffect = trap_FX_RegisterEffect( "bryar/muzzle_flash" );
weaponInfo->altMissileModel = NULL_HANDLE;
weaponInfo->altMissileSound = NULL_SOUND;
weaponInfo->altMissileDlight = 0;
//weaponInfo->altMissileDlightColor= {0,0,0};
weaponInfo->altMissileHitSound = NULL_SOUND;
weaponInfo->altMissileTrailFunc = FX_BryarAltProjectileThink;
cgs.effects.bryarShotEffect = trap_FX_RegisterEffect( "bryar/shot" );
cgs.effects.bryarPowerupShotEffect = trap_FX_RegisterEffect( "bryar/crackleShot" );
cgs.effects.bryarWallImpactEffect = trap_FX_RegisterEffect( "bryar/wall_impact" );
cgs.effects.bryarWallImpactEffect2 = trap_FX_RegisterEffect( "bryar/wall_impact2" );
cgs.effects.bryarWallImpactEffect3 = trap_FX_RegisterEffect( "bryar/wall_impact3" );
cgs.effects.bryarFleshImpactEffect = trap_FX_RegisterEffect( "bryar/flesh_impact" );
cgs.effects.bryarDroidImpactEffect = trap_FX_RegisterEffect( "bryar/droid_impact" );
cgs.media.bryarFrontFlash = trap_R_RegisterShader( "gfx/effects/bryarFrontFlash" );
// Note these are temp shared effects
trap_FX_RegisterEffect("effects/blaster/deflect.efx");
trap_FX_RegisterEffect("effects/blaster/wall_impact.efx");
trap_FX_RegisterEffect("effects/blaster/flesh_impact.efx");
trap_FX_RegisterEffect("effects/blaster/smoke_bolton.efx");
break;
case WP_BLASTER:
case WP_EMPLACED_GUN: //rww - just use the same as this for now..
weaponInfo->flashSound[0] = trap_S_RegisterSound( "sound/weapons/blaster/fire.wav");
weaponInfo->firingSound = NULL_SOUND;
weaponInfo->chargeSound = NULL_SOUND;
weaponInfo->muzzleEffect = trap_FX_RegisterEffect( "blaster/muzzle_flash" );
weaponInfo->missileModel = NULL_HANDLE;
weaponInfo->missileSound = NULL_SOUND;
weaponInfo->missileDlight = 0;
// weaponInfo->missileDlightColor = {0,0,0};
weaponInfo->missileHitSound = NULL_SOUND;
weaponInfo->missileTrailFunc = FX_BlasterProjectileThink;
weaponInfo->altFlashSound[0] = trap_S_RegisterSound( "sound/weapons/blaster/alt_fire.wav");
weaponInfo->altFiringSound = NULL_SOUND;
weaponInfo->altChargeSound = NULL_SOUND;
weaponInfo->altMuzzleEffect = trap_FX_RegisterEffect( "blaster/muzzle_flash" );
weaponInfo->altMissileModel = NULL_HANDLE;
weaponInfo->altMissileSound = NULL_SOUND;
weaponInfo->altMissileDlight = 0;
// weaponInfo->altMissileDlightColor= {0,0,0};
weaponInfo->altMissileHitSound = NULL_SOUND;
weaponInfo->altMissileTrailFunc = FX_BlasterProjectileThink;
trap_FX_RegisterEffect( "blaster/deflect" );
cgs.effects.blasterShotEffect = trap_FX_RegisterEffect( "blaster/shot" );
cgs.effects.blasterWallImpactEffect = trap_FX_RegisterEffect( "blaster/wall_impact" );
cgs.effects.blasterFleshImpactEffect = trap_FX_RegisterEffect( "blaster/flesh_impact" );
cgs.effects.blasterDroidImpactEffect = trap_FX_RegisterEffect( "blaster/droid_impact" );
trap_FX_RegisterEffect( "blaster/smoke_bolton" ); // note: this will be called game side
break;
case WP_DISRUPTOR:
weaponInfo->flashSound[0] = trap_S_RegisterSound( "sound/weapons/disruptor/fire.wav");
weaponInfo->firingSound = NULL_SOUND;
weaponInfo->chargeSound = NULL_SOUND;
weaponInfo->muzzleEffect = trap_FX_RegisterEffect( "disruptor/muzzle_flash" );
weaponInfo->missileModel = NULL_HANDLE;
weaponInfo->missileSound = NULL_SOUND;
weaponInfo->missileDlight = 0;
// weaponInfo->missileDlightColor = {0,0,0};
weaponInfo->missileHitSound = NULL_SOUND;
weaponInfo->missileTrailFunc = 0;
weaponInfo->altFlashSound[0] = trap_S_RegisterSound( "sound/weapons/disruptor/alt_fire.wav");
weaponInfo->altFiringSound = NULL_SOUND;
weaponInfo->altChargeSound = trap_S_RegisterSound("sound/weapons/disruptor/altCharge.wav");
weaponInfo->altMuzzleEffect = trap_FX_RegisterEffect( "disruptor/muzzle_flash" );
weaponInfo->altMissileModel = NULL_HANDLE;
weaponInfo->altMissileSound = NULL_SOUND;
weaponInfo->altMissileDlight = 0;
// weaponInfo->altMissileDlightColor= {0,0,0};
weaponInfo->altMissileHitSound = NULL_SOUND;
weaponInfo->altMissileTrailFunc = 0;
cgs.effects.disruptorRingsEffect = trap_FX_RegisterEffect( "disruptor/rings" );
cgs.effects.disruptorProjectileEffect = trap_FX_RegisterEffect( "disruptor/projectile" );
cgs.effects.disruptorWallImpactEffect = trap_FX_RegisterEffect( "disruptor/wall_impact" );
cgs.effects.disruptorFleshImpactEffect = trap_FX_RegisterEffect( "disruptor/flesh_impact" );
cgs.effects.disruptorAltMissEffect = trap_FX_RegisterEffect( "disruptor/alt_miss" );
cgs.effects.disruptorAltHitEffect = trap_FX_RegisterEffect( "disruptor/alt_hit" );
trap_R_RegisterShader( "gfx/effects/redLine" );
trap_R_RegisterShader( "gfx/misc/whiteline2" );
trap_R_RegisterShader( "gfx/effects/smokeTrail" );
trap_S_RegisterSound("sound/weapons/disruptor/zoomstart.wav");
trap_S_RegisterSound("sound/weapons/disruptor/zoomend.wav");
// Disruptor gun zoom interface
cgs.media.disruptorMask = trap_R_RegisterShader( "gfx/2d/cropCircle2");
cgs.media.disruptorInsert = trap_R_RegisterShader( "gfx/2d/cropCircle");
cgs.media.disruptorLight = trap_R_RegisterShader( "gfx/2d/cropCircleGlow" );
cgs.media.disruptorInsertTick = trap_R_RegisterShader( "gfx/2d/insertTick" );
cgs.media.disruptorChargeShader = trap_R_RegisterShaderNoMip("gfx/2d/crop_charge");
cgs.media.disruptorZoomLoop = trap_S_RegisterSound( "sound/weapons/disruptor/zoomloop.wav" );
break;
case WP_BOWCASTER:
weaponInfo->altFlashSound[0] = trap_S_RegisterSound( "sound/weapons/bowcaster/fire.wav");
weaponInfo->altFiringSound = NULL_SOUND;
weaponInfo->altChargeSound = NULL_SOUND;
weaponInfo->altMuzzleEffect = trap_FX_RegisterEffect( "bowcaster/muzzle_flash" );
weaponInfo->altMissileModel = NULL_HANDLE;
weaponInfo->altMissileSound = NULL_SOUND;
weaponInfo->altMissileDlight = 0;
// weaponInfo->altMissileDlightColor = {0,0,0};
weaponInfo->altMissileHitSound = NULL_SOUND;
weaponInfo->altMissileTrailFunc = FX_BowcasterProjectileThink;
weaponInfo->flashSound[0] = trap_S_RegisterSound( "sound/weapons/bowcaster/fire.wav");
weaponInfo->firingSound = NULL_SOUND;
weaponInfo->chargeSound = trap_S_RegisterSound( "sound/weapons/bowcaster/altcharge.wav");
weaponInfo->muzzleEffect = trap_FX_RegisterEffect( "bowcaster/muzzle_flash" );
weaponInfo->missileModel = NULL_HANDLE;
weaponInfo->missileSound = NULL_SOUND;
weaponInfo->missileDlight = 0;
// weaponInfo->missileDlightColor= {0,0,0};
weaponInfo->missileHitSound = NULL_SOUND;
weaponInfo->missileTrailFunc = FX_BowcasterAltProjectileThink;
cgs.effects.bowcasterShotEffect = trap_FX_RegisterEffect( "bowcaster/shot" );
cgs.effects.bowcasterImpactEffect = trap_FX_RegisterEffect( "bowcaster/explosion" );
cgs.media.greenFrontFlash = trap_R_RegisterShader( "gfx/effects/greenFrontFlash" );
break;
case WP_REPEATER:
weaponInfo->flashSound[0] = trap_S_RegisterSound( "sound/weapons/repeater/fire.wav");
weaponInfo->firingSound = NULL_SOUND;
weaponInfo->chargeSound = NULL_SOUND;
weaponInfo->muzzleEffect = trap_FX_RegisterEffect( "repeater/muzzle_flash" );
weaponInfo->missileModel = NULL_HANDLE;
weaponInfo->missileSound = NULL_SOUND;
weaponInfo->missileDlight = 0;
// weaponInfo->missileDlightColor = {0,0,0};
weaponInfo->missileHitSound = NULL_SOUND;
weaponInfo->missileTrailFunc = FX_RepeaterProjectileThink;
weaponInfo->altFlashSound[0] = trap_S_RegisterSound( "sound/weapons/repeater/alt_fire.wav");
weaponInfo->altFiringSound = NULL_SOUND;
weaponInfo->altChargeSound = NULL_SOUND;
weaponInfo->altMuzzleEffect = trap_FX_RegisterEffect( "repeater/muzzle_flash" );
weaponInfo->altMissileModel = NULL_HANDLE;
weaponInfo->altMissileSound = NULL_SOUND;
weaponInfo->altMissileDlight = 0;
// weaponInfo->altMissileDlightColor= {0,0,0};
weaponInfo->altMissileHitSound = NULL_SOUND;
weaponInfo->altMissileTrailFunc = FX_RepeaterAltProjectileThink;
cgs.effects.repeaterProjectileEffect = trap_FX_RegisterEffect( "repeater/projectile" );
cgs.effects.repeaterAltProjectileEffect = trap_FX_RegisterEffect( "repeater/alt_projectile" );
cgs.effects.repeaterWallImpactEffect = trap_FX_RegisterEffect( "repeater/wall_impact" );
cgs.effects.repeaterFleshImpactEffect = trap_FX_RegisterEffect( "repeater/flesh_impact" );
//cgs.effects.repeaterAltWallImpactEffect = trap_FX_RegisterEffect( "repeater/alt_wall_impact" );
cgs.effects.repeaterAltWallImpactEffect = trap_FX_RegisterEffect( "repeater/concussion" );
break;
case WP_DEMP2:
weaponInfo->flashSound[0] = trap_S_RegisterSound("sound/weapons/demp2/fire.wav");
weaponInfo->firingSound = NULL_SOUND;
weaponInfo->chargeSound = NULL_SOUND;
weaponInfo->muzzleEffect = trap_FX_RegisterEffect("demp2/muzzle_flash");
weaponInfo->missileModel = NULL_HANDLE;
weaponInfo->missileSound = NULL_SOUND;
weaponInfo->missileDlight = 0;
// weaponInfo->missileDlightColor = {0,0,0};
weaponInfo->missileHitSound = NULL_SOUND;
weaponInfo->missileTrailFunc = FX_DEMP2_ProjectileThink;
weaponInfo->altFlashSound[0] = trap_S_RegisterSound("sound/weapons/demp2/altfire.wav");
weaponInfo->altFiringSound = NULL_SOUND;
weaponInfo->altChargeSound = trap_S_RegisterSound("sound/weapons/demp2/altCharge.wav");
weaponInfo->altMuzzleEffect = trap_FX_RegisterEffect("demp2/muzzle_flash");
weaponInfo->altMissileModel = NULL_HANDLE;
weaponInfo->altMissileSound = NULL_SOUND;
weaponInfo->altMissileDlight = 0;
// weaponInfo->altMissileDlightColor= {0,0,0};
weaponInfo->altMissileHitSound = NULL_SOUND;
weaponInfo->altMissileTrailFunc = 0;
cgs.effects.demp2ProjectileEffect = trap_FX_RegisterEffect( "demp2/projectile" );
cgs.effects.demp2WallImpactEffect = trap_FX_RegisterEffect( "demp2/wall_impact" );
cgs.effects.demp2FleshImpactEffect = trap_FX_RegisterEffect( "demp2/flesh_impact" );
trap_FX_RegisterEffect("demp2/altDetonate.efx");
cgs.media.demp2Shell = trap_R_RegisterModel( "models/items/sphere.md3" );
cgs.media.demp2ShellShader = trap_R_RegisterShader( "gfx/effects/demp2shell" );
cgs.media.lightningFlash = trap_R_RegisterShader("gfx/misc/lightningFlash");
break;
case WP_FLECHETTE:
weaponInfo->flashSound[0] = trap_S_RegisterSound( "sound/weapons/flechette/fire.wav");
weaponInfo->firingSound = NULL_SOUND;
weaponInfo->chargeSound = NULL_SOUND;
weaponInfo->muzzleEffect = trap_FX_RegisterEffect( "flechette/muzzle_flash" );
weaponInfo->missileModel = trap_R_RegisterModel("models/weapons2/golan_arms/projectileMain.md3");
weaponInfo->missileSound = NULL_SOUND;
weaponInfo->missileDlight = 0;
// weaponInfo->missileDlightColor = {0,0,0};
weaponInfo->missileHitSound = NULL_SOUND;
weaponInfo->missileTrailFunc = FX_FlechetteProjectileThink;
weaponInfo->altFlashSound[0] = trap_S_RegisterSound( "sound/weapons/flechette/alt_fire.wav");
weaponInfo->altFiringSound = NULL_SOUND;
weaponInfo->altChargeSound = NULL_SOUND;
weaponInfo->altMuzzleEffect = trap_FX_RegisterEffect( "flechette/muzzle_flash" );
weaponInfo->altMissileModel = trap_R_RegisterModel( "models/weapons2/golan_arms/projectile.md3" );
weaponInfo->altMissileSound = NULL_SOUND;
weaponInfo->altMissileDlight = 0;
// weaponInfo->altMissileDlightColor= {0,0,0};
weaponInfo->altMissileHitSound = NULL_SOUND;
weaponInfo->altMissileTrailFunc = FX_FlechetteAltProjectileThink;
cgs.effects.flechetteShotEffect = trap_FX_RegisterEffect( "flechette/shot" );
cgs.effects.flechetteAltShotEffect = trap_FX_RegisterEffect( "flechette/alt_shot" );
cgs.effects.flechetteWallImpactEffect = trap_FX_RegisterEffect( "flechette/wall_impact" );
cgs.effects.flechetteFleshImpactEffect = trap_FX_RegisterEffect( "flechette/flesh_impact" );
trap_FX_RegisterEffect("flechette/alt_blow.efx");
break;
case WP_ROCKET_LAUNCHER:
weaponInfo->flashSound[0] = trap_S_RegisterSound( "sound/weapons/rocket/fire.wav");
weaponInfo->firingSound = NULL_SOUND;
weaponInfo->chargeSound = NULL_SOUND;
weaponInfo->muzzleEffect = trap_FX_RegisterEffect( "rocket/muzzle_flash" );
weaponInfo->missileModel = trap_R_RegisterModel( "models/weapons2/merr_sonn/projectile.md3" );
weaponInfo->missileSound = trap_S_RegisterSound( "sound/weapons/rocket/missileloop.wav");
weaponInfo->missileDlight = 125;
VectorSet(weaponInfo->missileDlightColor, 1.0, 1.0, 0.5);
weaponInfo->missileHitSound = NULL_SOUND;
weaponInfo->missileTrailFunc = FX_RocketProjectileThink;
weaponInfo->altFlashSound[0] = trap_S_RegisterSound( "sound/weapons/rocket/alt_fire.wav");
weaponInfo->altFiringSound = NULL_SOUND;
weaponInfo->altChargeSound = NULL_SOUND;
weaponInfo->altMuzzleEffect = trap_FX_RegisterEffect( "rocket/muzzle_flash" );
weaponInfo->altMissileModel = trap_R_RegisterModel( "models/weapons2/merr_sonn/projectile.md3" );
weaponInfo->altMissileSound = trap_S_RegisterSound( "sound/weapons/rocket/missileloop.wav");
weaponInfo->altMissileDlight = 125;
VectorSet(weaponInfo->altMissileDlightColor, 1.0, 1.0, 0.5);
weaponInfo->altMissileHitSound = NULL_SOUND;
weaponInfo->altMissileTrailFunc = FX_RocketAltProjectileThink;
cgs.effects.rocketShotEffect = trap_FX_RegisterEffect( "rocket/shot" );
cgs.effects.rocketExplosionEffect = trap_FX_RegisterEffect( "rocket/explosion" );
trap_R_RegisterShaderNoMip( "gfx/2d/wedge" );
trap_R_RegisterShaderNoMip( "gfx/2d/lock" );
trap_S_RegisterSound( "sound/weapons/rocket/lock.wav" );
trap_S_RegisterSound( "sound/weapons/rocket/tick.wav" );
break;
case WP_THERMAL:
weaponInfo->flashSound[0] = trap_S_RegisterSound( "sound/weapons/thermal/fire.wav");
weaponInfo->firingSound = NULL_SOUND;
weaponInfo->chargeSound = trap_S_RegisterSound( "sound/weapons/thermal/charge.wav");
weaponInfo->muzzleEffect = NULL_FX;
weaponInfo->missileModel = trap_R_RegisterModel( "models/weapons2/thermal/thermal_proj.md3" );
weaponInfo->missileSound = NULL_SOUND;
weaponInfo->missileDlight = 0;
// weaponInfo->missileDlightColor = {0,0,0};
weaponInfo->missileHitSound = NULL_SOUND;
weaponInfo->missileTrailFunc = 0;
weaponInfo->altFlashSound[0] = trap_S_RegisterSound( "sound/weapons/thermal/fire.wav");
weaponInfo->altFiringSound = NULL_SOUND;
weaponInfo->altChargeSound = trap_S_RegisterSound( "sound/weapons/thermal/charge.wav");
weaponInfo->altMuzzleEffect = NULL_FX;
weaponInfo->altMissileModel = trap_R_RegisterModel( "models/weapons2/thermal/thermal_proj.md3" );
weaponInfo->altMissileSound = NULL_SOUND;
weaponInfo->altMissileDlight = 0;
// weaponInfo->altMissileDlightColor= {0,0,0};
weaponInfo->altMissileHitSound = NULL_SOUND;
weaponInfo->altMissileTrailFunc = 0;
cgs.effects.thermalExplosionEffect = trap_FX_RegisterEffect( "thermal/explosion" );
cgs.effects.thermalShockwaveEffect = trap_FX_RegisterEffect( "thermal/shockwave" );
cgs.media.grenadeBounce1 = trap_S_RegisterSound( "sound/weapons/thermal/bounce1.wav" );
cgs.media.grenadeBounce2 = trap_S_RegisterSound( "sound/weapons/thermal/bounce2.wav" );
trap_S_RegisterSound( "sound/weapons/thermal/thermloop.wav" );
trap_S_RegisterSound( "sound/weapons/thermal/warning.wav" );
break;
case WP_TRIP_MINE:
weaponInfo->flashSound[0] = trap_S_RegisterSound( "sound/weapons/laser_trap/fire.wav");
weaponInfo->firingSound = NULL_SOUND;
weaponInfo->chargeSound = NULL_SOUND;
weaponInfo->muzzleEffect = NULL_FX;
weaponInfo->missileModel = 0;//trap_R_RegisterModel( "models/weapons2/laser_trap/laser_trap_w.md3" );
weaponInfo->missileSound = NULL_SOUND;
weaponInfo->missileDlight = 0;
// weaponInfo->missileDlightColor = {0,0,0};
weaponInfo->missileHitSound = NULL_SOUND;
weaponInfo->missileTrailFunc = 0;
weaponInfo->altFlashSound[0] = trap_S_RegisterSound( "sound/weapons/laser_trap/fire.wav");
weaponInfo->altFiringSound = NULL_SOUND;
weaponInfo->altChargeSound = NULL_SOUND;
weaponInfo->altMuzzleEffect = NULL_FX;
weaponInfo->altMissileModel = 0;//trap_R_RegisterModel( "models/weapons2/laser_trap/laser_trap_w.md3" );
weaponInfo->altMissileSound = NULL_SOUND;
weaponInfo->altMissileDlight = 0;
// weaponInfo->altMissileDlightColor= {0,0,0};
weaponInfo->altMissileHitSound = NULL_SOUND;
weaponInfo->altMissileTrailFunc = 0;
cgs.effects.tripmineLaserFX = trap_FX_RegisterEffect("tripMine/laserMP.efx");
trap_FX_RegisterEffect( "tripMine/explosion" );
// NOTENOTE temp stuff
trap_S_RegisterSound( "sound/weapons/laser_trap/stick.wav" );
trap_S_RegisterSound( "sound/weapons/laser_trap/warning.wav" );
break;
case WP_DET_PACK:
weaponInfo->flashSound[0] = trap_S_RegisterSound( "sound/weapons/detpack/fire.wav");
weaponInfo->firingSound = NULL_SOUND;
weaponInfo->chargeSound = NULL_SOUND;
weaponInfo->muzzleEffect = NULL_FX;
weaponInfo->missileModel = trap_R_RegisterModel( "models/weapons2/detpack/det_pack.md3" );
weaponInfo->missileSound = NULL_SOUND;
weaponInfo->missileDlight = 0;
// weaponInfo->missileDlightColor = {0,0,0};
weaponInfo->missileHitSound = NULL_SOUND;
weaponInfo->missileTrailFunc = 0;
weaponInfo->altFlashSound[0] = trap_S_RegisterSound( "sound/weapons/detpack/fire.wav");
weaponInfo->altFiringSound = NULL_SOUND;
weaponInfo->altChargeSound = NULL_SOUND;
weaponInfo->altMuzzleEffect = NULL_FX;
weaponInfo->altMissileModel = trap_R_RegisterModel( "models/weapons2/detpack/det_pack.md3" );
weaponInfo->altMissileSound = NULL_SOUND;
weaponInfo->altMissileDlight = 0;
// weaponInfo->altMissileDlightColor= {0,0,0};
weaponInfo->altMissileHitSound = NULL_SOUND;
weaponInfo->altMissileTrailFunc = 0;
trap_FX_RegisterEffect( "detpack/explosion.efx" );
trap_R_RegisterModel( "models/weapons2/detpack/det_pack.md3" );
trap_S_RegisterSound( "sound/weapons/detpack/stick.wav" );
trap_S_RegisterSound( "sound/weapons/detpack/warning.wav" );
trap_S_RegisterSound( "sound/weapons/explosions/explode5.wav" );
break;
default:
MAKERGB( weaponInfo->flashDlightColor, 1, 1, 1 );
weaponInfo->flashSound[0] = trap_S_RegisterSound( "sound/weapons/rocket/rocklf1a.wav" );
break;
}
}
/*
================
CG_ConfigStringModified
================
*/
static void CG_ConfigStringModified( void )
{
const char *str;
int num;
num = atoi( CG_Argv( 1 ) );
// get the gamestate from the client system, which will have the
// new configstring already integrated
trap_GetGameState( &cgs.gameState );
// look up the individual string that was modified
str = CG_ConfigString( num );
// do something with it if necessary
if ( num == CS_MUSIC )
{
CG_StartMusic();
}
else if ( num == CS_SERVERINFO )
{
CG_ParseServerinfo();
}
else if ( num == CS_WARMUP )
{
CG_ParseWarmup();
}
else if ( num == CS_SCORES1 )
{
cgs.scores1 = atoi( str );
}
else if ( num == CS_SCORES2 )
{
cgs.scores2 = atoi( str );
}
else if ( num == CS_BUILDPOINTS )
{
sscanf( str, "%d %d %d %d %d", &cgs.alienBuildPoints,
&cgs.alienBuildPointsTotal,
&cgs.humanBuildPoints,
&cgs.humanBuildPointsTotal,
&cgs.humanBuildPointsPowered );
}
else if ( num == CS_STAGES )
{
stage_t oldAlienStage = cgs.alienStage;
stage_t oldHumanStage = cgs.humanStage;
sscanf( str, "%d %d %d %d %d %d",
&cgs.alienStage, &cgs.humanStage,
&cgs.alienKills, &cgs.humanKills,
&cgs.alienNextStageThreshold, &cgs.humanNextStageThreshold );
if ( cgs.alienStage != oldAlienStage )
{
CG_AnnounceAlienStageTransistion( oldAlienStage, cgs.alienStage );
}
if ( cgs.humanStage != oldHumanStage )
{
CG_AnnounceHumanStageTransistion( oldHumanStage, cgs.humanStage );
}
}
else if ( num == CS_SPAWNS )
{
sscanf( str, "%d %d", &cgs.numAlienSpawns, &cgs.numHumanSpawns );
}
else if ( num == CS_LEVEL_START_TIME )
{
cgs.levelStartTime = atoi( str );
}
else if ( num == CS_VOTE_TIME )
{
cgs.voteTime = atoi( str );
cgs.voteModified = qtrue;
if ( cgs.voteTime )
{
trap_Cvar_Set( "ui_voteActive", "1" );
}
else
{
trap_Cvar_Set( "ui_voteActive", "0" );
}
}
else if ( num == CS_VOTE_YES )
{
cgs.voteYes = atoi( str );
cgs.voteModified = qtrue;
}
else if ( num == CS_VOTE_NO )
{
cgs.voteNo = atoi( str );
cgs.voteModified = qtrue;
}
else if ( num == CS_VOTE_STRING )
{
Q_strncpyz( cgs.voteString, str, sizeof( cgs.voteString ) );
}
else if ( num >= CS_TEAMVOTE_TIME && num <= CS_TEAMVOTE_TIME + 1 )
{
int cs_offset = num - CS_TEAMVOTE_TIME;
cgs.teamVoteTime[ cs_offset ] = atoi( str );
cgs.teamVoteModified[ cs_offset ] = qtrue;
if ( cs_offset == 0 )
{
if ( cgs.teamVoteTime[ cs_offset ] )
{
trap_Cvar_Set( "ui_humanTeamVoteActive", "1" );
}
else
{
trap_Cvar_Set( "ui_humanTeamVoteActive", "0" );
}
}
else if ( cs_offset == 1 )
{
if ( cgs.teamVoteTime[ cs_offset ] )
{
trap_Cvar_Set( "ui_alienTeamVoteActive", "1" );
}
else
{
trap_Cvar_Set( "ui_alienTeamVoteActive", "0" );
}
}
}
else if ( num >= CS_TEAMVOTE_YES && num <= CS_TEAMVOTE_YES + 1 )
{
cgs.teamVoteYes[ num - CS_TEAMVOTE_YES ] = atoi( str );
cgs.teamVoteModified[ num - CS_TEAMVOTE_YES ] = qtrue;
}
else if ( num >= CS_TEAMVOTE_NO && num <= CS_TEAMVOTE_NO + 1 )
{
cgs.teamVoteNo[ num - CS_TEAMVOTE_NO ] = atoi( str );
cgs.teamVoteModified[ num - CS_TEAMVOTE_NO ] = qtrue;
}
else if ( num >= CS_TEAMVOTE_STRING && num <= CS_TEAMVOTE_STRING + 1 )
{
Q_strncpyz( cgs.teamVoteString[ num - CS_TEAMVOTE_STRING ], str, sizeof( cgs.teamVoteString ) );
}
else if ( num == CS_INTERMISSION )
{
cg.intermissionStarted = atoi( str );
}
else if ( num >= CS_MODELS && num < CS_MODELS + MAX_MODELS )
{
cgs.gameModels[ num - CS_MODELS ] = trap_R_RegisterModel( str );
}
else if ( num >= CS_SHADERS && num < CS_SHADERS + MAX_GAME_SHADERS )
{
cgs.gameShaders[ num - CS_SHADERS ] = trap_R_RegisterShader( str );
}
else if ( num >= CS_PARTICLE_SYSTEMS && num < CS_PARTICLE_SYSTEMS + MAX_GAME_PARTICLE_SYSTEMS )
{
cgs.gameParticleSystems[ num - CS_PARTICLE_SYSTEMS ] = CG_RegisterParticleSystem( ( char * ) str );
}
else if ( num >= CS_SOUNDS && num < CS_SOUNDS + MAX_SOUNDS )
{
if ( str[ 0 ] != '*' )
{
// player specific sounds don't register here
cgs.gameSounds[ num - CS_SOUNDS ] = trap_S_RegisterSound( str, qfalse );
}
}
else if ( num >= CS_PLAYERS && num < CS_PLAYERS + MAX_CLIENTS )
{
CG_NewClientInfo( num - CS_PLAYERS );
CG_BuildSpectatorString();
}
else if ( num == CS_FLAGSTATUS )
{
}
else if ( num == CS_SHADERSTATE )
{
CG_ShaderStateChanged();
}
}
/*
=================
UI_Cache
=================
*/
static void UI_Cache_f( void )
{
Menu_Cache();
#ifndef JK2_MODE
extern const char *lukeForceStatusSounds[];
extern const char *kyleForceStatusSounds[];
for (int index = 0; index < 5; index++)
{
DC->registerSound(lukeForceStatusSounds[index], qfalse);
DC->registerSound(kyleForceStatusSounds[index], qfalse);
}
for (int index = 1; index <= 18; index++)
{
DC->registerSound(va("sound/chars/storyinfo/%d",index), qfalse);
}
trap_S_RegisterSound("sound/chars/kyle/04kyk001.mp3", qfalse);
trap_S_RegisterSound("sound/chars/kyle/05kyk001.mp3", qfalse);
trap_S_RegisterSound("sound/chars/kyle/07kyk001.mp3", qfalse);
trap_S_RegisterSound("sound/chars/kyle/14kyk001.mp3", qfalse);
trap_S_RegisterSound("sound/chars/kyle/21kyk001.mp3", qfalse);
trap_S_RegisterSound("sound/chars/kyle/24kyk001.mp3", qfalse);
trap_S_RegisterSound("sound/chars/kyle/25kyk001.mp3", qfalse);
trap_S_RegisterSound("sound/chars/luke/06luk001.mp3", qfalse);
trap_S_RegisterSound("sound/chars/luke/08luk001.mp3", qfalse);
trap_S_RegisterSound("sound/chars/luke/22luk001.mp3", qfalse);
trap_S_RegisterSound("sound/chars/luke/23luk001.mp3", qfalse);
trap_S_RegisterSound("sound/chars/protocol/12pro001.mp3", qfalse);
trap_S_RegisterSound("sound/chars/protocol/15pro001.mp3", qfalse);
trap_S_RegisterSound("sound/chars/protocol/16pro001.mp3", qfalse);
trap_S_RegisterSound("sound/chars/wedge/13wea001.mp3", qfalse);
Menus_ActivateByName("ingameMissionSelect1");
Menus_ActivateByName("ingameMissionSelect2");
Menus_ActivateByName("ingameMissionSelect3");
#endif
}
/*
============
BG_VoiceParseCommand
============
*/
static voiceTrack_t *BG_VoiceParseCommand( int handle )
{
pc_token_t token;
qboolean parsingTrack = qfalse;
voiceTrack_t *voiceTracks = NULL;
voiceTrack_t *top = NULL;
while ( trap_Parse_ReadToken( handle, &token ) )
{
if ( !parsingTrack && token.string[ 0 ] == '}' )
{
return top;
}
if ( parsingTrack )
{
if ( token.string[ 0 ] == '{' )
{
BG_VoiceParseTrack( handle, voiceTracks );
parsingTrack = qfalse;
continue;
}
else
{
BG_VoiceParseError( handle, va( "BG_VoiceParseCommand(): "
"parse error at \"%s\"", token.string ) );
}
}
if ( top == NULL )
{
voiceTracks = BG_Alloc( sizeof( voiceTrack_t ) );
top = voiceTracks;
}
else
{
voiceTracks->next = BG_Alloc( sizeof( voiceCmd_t ) );
voiceTracks = voiceTracks->next;
}
if ( !trap_FS_FOpenFile( token.string, NULL, FS_READ ) )
{
int line;
char filename[ MAX_QPATH ];
trap_Parse_SourceFileAndLine( handle, filename, &line );
Com_Printf( S_WARNING "BG_VoiceParseCommand(): "
"track \"%s\" referenced on line %d of %s does not exist\n",
token.string, line, filename );
}
else
{
#ifdef CGAME
voiceTracks->track = trap_S_RegisterSound( token.string, qfalse );
voiceTracks->duration = 0; // FIXME: Was always zero...
#endif
}
voiceTracks->team = -1;
voiceTracks->pClass = -1;
voiceTracks->weapon = -1;
voiceTracks->enthusiasm = 0;
voiceTracks->text = NULL;
voiceTracks->next = NULL;
parsingTrack = qtrue;
}
return NULL;
}
/*
=================
CG_ParseVoiceChats
=================
*/
int CG_ParseVoiceChats( const char *filename, voiceChatList_t *voiceChatList, int maxVoiceChats ) {
int len, i;
fileHandle_t f;
char buf[MAX_VOICEFILESIZE];
char **p, *ptr;
char *token;
voiceChat_t *voiceChats;
qboolean compress;
sfxHandle_t sound;
compress = qtrue;
if (cg_buildScript.integer) {
compress = qfalse;
}
len = trap_FS_FOpenFile( filename, &f, FS_READ );
if ( !f ) {
trap_Print( va( S_COLOR_RED "voice chat file not found: %s\n", filename ) );
return qfalse;
}
if ( len >= MAX_VOICEFILESIZE ) {
trap_Print( va( S_COLOR_RED "voice chat file too large: %s is %i, max allowed is %i", filename, len, MAX_VOICEFILESIZE ) );
trap_FS_FCloseFile( f );
return qfalse;
}
trap_FS_Read( buf, len, f );
buf[len] = 0;
trap_FS_FCloseFile( f );
ptr = buf;
p = &ptr;
Com_sprintf(voiceChatList->name, sizeof(voiceChatList->name), "%s", filename);
voiceChats = voiceChatList->voiceChats;
for ( i = 0; i < maxVoiceChats; i++ ) {
voiceChats[i].id[0] = 0;
}
token = COM_ParseExt(p, qtrue);
if (!token || token[0] == 0) {
return qtrue;
}
if (!Q_stricmp(token, "female")) {
voiceChatList->gender = GENDER_FEMALE;
}
else if (!Q_stricmp(token, "male")) {
voiceChatList->gender = GENDER_MALE;
}
else if (!Q_stricmp(token, "neuter")) {
voiceChatList->gender = GENDER_NEUTER;
}
else {
trap_Print( va( S_COLOR_RED "expected gender not found in voice chat file: %s\n", filename ) );
return qfalse;
}
voiceChatList->numVoiceChats = 0;
while ( 1 ) {
token = COM_ParseExt(p, qtrue);
if (!token || token[0] == 0) {
return qtrue;
}
Com_sprintf(voiceChats[voiceChatList->numVoiceChats].id, sizeof( voiceChats[voiceChatList->numVoiceChats].id ), "%s", token);
token = COM_ParseExt(p, qtrue);
if (Q_stricmp(token, "{")) {
trap_Print( va( S_COLOR_RED "expected { found %s in voice chat file: %s\n", token, filename ) );
return qfalse;
}
voiceChats[voiceChatList->numVoiceChats].numSounds = 0;
while(1) {
token = COM_ParseExt(p, qtrue);
if (!token || token[0] == 0) {
return qtrue;
}
if (!Q_stricmp(token, "}"))
break;
sound = trap_S_RegisterSound( token, compress );
voiceChats[voiceChatList->numVoiceChats].sounds[voiceChats[voiceChatList->numVoiceChats].numSounds] = sound;
token = COM_ParseExt(p, qtrue);
if (!token || token[0] == 0) {
return qtrue;
}
Com_sprintf(voiceChats[voiceChatList->numVoiceChats].chats[
voiceChats[voiceChatList->numVoiceChats].numSounds], MAX_CHATSIZE, "%s", token);
if (sound)
voiceChats[voiceChatList->numVoiceChats].numSounds++;
if (voiceChats[voiceChatList->numVoiceChats].numSounds >= MAX_VOICESOUNDS)
break;
}
voiceChatList->numVoiceChats++;
if (voiceChatList->numVoiceChats >= maxVoiceChats)
return qtrue;
}
return qtrue;
}
/*
=================
PlayerModel_BuildList
=================
*/
static void PlayerModel_BuildList( void )
{
int numdirs;
int numFiles;
char dirlist[2048];
char filelist[2048];
char skinname[64];
char* dirptr;
char* fileptr;
int i;
int j;
int dirlen;
int filelen;
qboolean precache;
precache = trap_Cvar_VariableValue("com_buildscript");
s_playermodel.modelpage = 0;
s_playermodel.nummodels = 0;
// iterate directory of all player models
numdirs = trap_FS_GetFileList("players/", "/", dirlist, 2048 );
dirptr = dirlist;
for (i=0; i<numdirs && s_playermodel.nummodels < MAX_PLAYERMODELS; i++,dirptr+=dirlen+1)
{
dirlen = strlen(dirptr);
if (dirlen && dirptr[dirlen-1]=='/') dirptr[dirlen-1]='\0';
if (!strcmp(dirptr,".") || !strcmp(dirptr,".."))
continue;
// iterate all skin files in directory
numFiles = trap_FS_GetFileList( va("players//%s",dirptr), "png", filelist, 2048 );
fileptr = filelist;
for (j=0; j<numFiles && s_playermodel.nummodels < MAX_PLAYERMODELS;j++,fileptr+=filelen+1)
{
filelen = strlen(fileptr);
COM_StripExtension(fileptr,skinname, sizeof(skinname));
// look for icon_????
if (!Q_stricmpn(skinname,"icon_",5))
{
Com_sprintf( s_playermodel.modelnames[s_playermodel.nummodels++],
sizeof( s_playermodel.modelnames[s_playermodel.nummodels] ),
"players//%s/%s", dirptr, skinname );
//if (s_playermodel.nummodels >= MAX_PLAYERMODELS)
// return;
}
if( precache ) {
trap_S_RegisterSound( va( "sound/player/announce/%s_wins.ogg", skinname), qfalse );
}
}
}
//APSFIXME - Degenerate no models case
s_playermodel.numpages = s_playermodel.nummodels/MAX_MODELSPERPAGE;
if (s_playermodel.nummodels % MAX_MODELSPERPAGE)
s_playermodel.numpages++;
}
void CG_DoGlass( vec3_t verts[4], vec3_t normal, vec3_t dmgPt, vec3_t dmgDir, float dmgRadius, int maxShards )
{
int i, t;
int mxHeight, mxWidth;
float height, width;
float stepWidth, stepHeight;
float timeDecay;
float x, z;
float xx, zz;
float dif;
int time = 0;
int glassShards = 0;
qboolean stick = qtrue;
vec3_t subVerts[4];
vec2_t biPoints[4];
// To do a smarter tesselation, we should figure out the relative height and width of the brush face,
// then use this to pick a lod value from 1-3 in each axis. This will give us 1-9 lod levels, which will
// hopefully be sufficient.
CG_CalcHeightWidth( verts, &height, &width );
trap_S_StartSound( dmgPt, -1, CHAN_AUTO, trap_S_RegisterSound("sound/effects/glassbreak1.wav"));
// Pick "LOD" for height
if ( height < 100 )
{
stepHeight = 0.2f;
mxHeight = 5;
timeDecay = TIME_DECAY_SLOW;
}
else if ( height > 220 )
{
stepHeight = 0.05f;
mxHeight = 20;
timeDecay = TIME_DECAY_FAST;
}
else
{
stepHeight = 0.1f;
mxHeight = 10;
timeDecay = TIME_DECAY_MED;
}
// Pick "LOD" for width
/*
if ( width < 100 )
{
stepWidth = 0.2f;
mxWidth = 5;
timeDecay = ( timeDecay + TIME_DECAY_SLOW ) * 0.5f;
}
else if ( width > 220 )
{
stepWidth = 0.05f;
mxWidth = 20;
timeDecay = ( timeDecay + TIME_DECAY_FAST ) * 0.5f;
}
else
{
stepWidth = 0.1f;
mxWidth = 10;
timeDecay = ( timeDecay + TIME_DECAY_MED ) * 0.5f;
}
*/
//Attempt to scale the glass directly to the size of the window
stepWidth = (0.25f - (width*0.0002)); //(width*0.0005));
mxWidth = width*0.2;
timeDecay = ( timeDecay + TIME_DECAY_FAST ) * 0.5f;
if (stepWidth < 0.01f)
{
stepWidth = 0.01f;
}
if (mxWidth < 5)
{
mxWidth = 5;
}
for ( z = 0.0f, i = 0; z < 1.0f; z += stepHeight, i++ )
{
for ( x = 0.0f, t = 0; x < 1.0f; x += stepWidth, t++ )
{
// This is nasty..
if ( t > 0 && t < mxWidth )
{
xx = x - offX[i][t];
}
else
{
xx = x;
}
if ( i > 0 && i < mxHeight )
{
zz = z - offZ[t][i];
}
else
{
zz = z;
}
Vector2Set( biPoints[0], xx, zz );
if ( t + 1 > 0 && t + 1 < mxWidth )
{
xx = x - offX[i][t + 1];
}
else
{
xx = x;
}
if ( i > 0 && i < mxHeight )
{
zz = z - offZ[t + 1][i];
}
else
{
zz = z;
}
Vector2Set( biPoints[1], xx + stepWidth, zz );
if ( t + 1 > 0 && t + 1 < mxWidth )
{
xx = x - offX[i + 1][t + 1];
}
else
{
xx = x;
}
if ( i + 1 > 0 && i + 1 < mxHeight )
{
zz = z - offZ[t + 1][i + 1];
}
else
{
zz = z;
}
Vector2Set( biPoints[2], xx + stepWidth, zz + stepHeight);
if ( t > 0 && t < mxWidth )
{
xx = x - offX[i + 1][t];
}
else
{
xx = x;
}
if ( i + 1 > 0 && i + 1 < mxHeight )
{
zz = z - offZ[t][i + 1];
}
else
{
zz = z;
}
Vector2Set( biPoints[3], xx, zz + stepHeight );
CG_CalcBiLerp( verts, subVerts, biPoints );
dif = DistanceSquared( subVerts[0], dmgPt ) * timeDecay - random() * 32;
// If we decrease dif, we are increasing the impact area, making it more likely to blow out large holes
dif -= dmgRadius * dmgRadius;
if ( dif > 1 )
{
stick = qtrue;
time = dif + random() * 200;
}
else
{
stick = qfalse;
time = 0;
}
CG_DoGlassQuad( subVerts, biPoints, stick, time, dmgDir );
glassShards++;
if (maxShards && glassShards >= maxShards)
{
return;
}
}
}
}
/*
* CG_AddLocalSounds
*/
static void CG_AddLocalSounds( void )
{
static bool postmatchsound_set = false, demostream = false, background = false;
static unsigned int lastSecond = 0;
// add local announces
if( GS_Countdown() )
{
if( GS_MatchDuration() )
{
unsigned int duration, curtime, remainingSeconds;
float seconds;
curtime = GS_MatchPaused() ? cg.frame.serverTime : cg.time;
duration = GS_MatchDuration();
if( duration + GS_MatchStartTime() < curtime )
duration = curtime - GS_MatchStartTime(); // avoid negative results
seconds = (float)( GS_MatchStartTime() + duration - curtime ) * 0.001f;
remainingSeconds = (unsigned int)seconds;
if( remainingSeconds != lastSecond )
{
if( 1 + remainingSeconds < 4 )
{
struct sfx_s *sound = trap_S_RegisterSound( va( S_ANNOUNCER_COUNTDOWN_COUNT_1_to_3_SET_1_to_2, 1 + remainingSeconds, 1 ) );
CG_AddAnnouncerEvent( sound, false );
}
lastSecond = remainingSeconds;
}
}
}
else
lastSecond = 0;
// add sounds from announcer
CG_ReleaseAnnouncerEvents();
// if in postmatch, play postmatch song
if( GS_MatchState() >= MATCH_STATE_POSTMATCH )
{
if( !postmatchsound_set && !demostream )
{
trap_S_StartBackgroundTrack( S_PLAYLIST_POSTMATCH, NULL, 3 ); // loop random track from the playlist
postmatchsound_set = true;
background = false;
}
}
else
{
if( cgs.demoPlaying && cgs.demoAudioStream && !demostream )
{
trap_S_StartBackgroundTrack( cgs.demoAudioStream, NULL, 0 );
demostream = true;
}
if( postmatchsound_set )
{
trap_S_StopBackgroundTrack();
postmatchsound_set = false;
background = false;
}
if( (!postmatchsound_set && !demostream) && !background )
{
CG_StartBackgroundTrack();
background = true;
}
// notice: these 2 sound files aren't used anymore
//cgs.media.sfxTimerBipBip
//cgs.media.sfxTimerPloink
}
}
