void
Cmd_Score_f(edict_t *ent)
{
if (!ent)
{
return;
}
ent->client->showinventory = false;
ent->client->showhelp = false;
if (!deathmatch->value && !coop->value)
{
return;
}
if (ent->client->showscores)
{
ent->client->showscores = false;
return;
}
ent->client->showscores = true;
DeathmatchScoreboardMessage(ent, ent->enemy);
gi.unicast(ent, true);
}
void MoveClientToIntermission (edict_t *ent)
{
if (deathmatch->value || coop->value)
ent->client->showscores = true;
VectorCopy (level.intermission_origin, ent->s.origin);
ent->client->ps.pmove.origin[0] = level.intermission_origin[0]*8;
ent->client->ps.pmove.origin[1] = level.intermission_origin[1]*8;
ent->client->ps.pmove.origin[2] = level.intermission_origin[2]*8;
VectorCopy (level.intermission_angle, ent->client->ps.viewangles);
ent->client->ps.pmove.pm_type = PM_FREEZE;
ent->client->ps.gunindex = 0;
#ifdef KMQUAKE2_ENGINE_MOD
ent->client->ps.gunindex2 = 0;
#endif
ent->client->ps.blend[3] = 0;
ent->client->ps.rdflags &= ~RDF_UNDERWATER;
#ifdef KMQUAKE2_ENGINE_MOD
if (level.intermission_letterbox) // Knightmare- letterboxing
ent->client->ps.rdflags |= RDF_LETTERBOX;
#endif
// clean up powerup info
ent->client->quad_framenum = 0;
ent->client->invincible_framenum = 0;
ent->client->breather_framenum = 0;
ent->client->enviro_framenum = 0;
ent->client->grenade_blew_up = false;
ent->client->grenade_time = 0;
ent->viewheight = 0;
ent->s.modelindex = 0;
ent->s.modelindex2 = 0;
ent->s.modelindex3 = 0;
ent->s.modelindex4 = 0;
#ifdef KMQUAKE2_ENGINE_MOD
ent->s.modelindex5 = 0;
ent->s.modelindex6 = 0;
#ifndef LOOP_SOUND_ATTENUATION
ent->s.modelindex7 = 0;
ent->s.modelindex8 = 0;
#endif
#endif
ent->s.effects = 0;
ent->s.sound = 0;
ent->solid = SOLID_NOT;
#ifdef JETPACK_MOD
ent->client->jetpack_framenum = 0;
#endif
// add the layout
if (deathmatch->value || coop->value)
{
DeathmatchScoreboardMessage (ent, NULL);
gi.unicast (ent, true);
}
}
/*
========================
SendScoreboardMessageToAllClients
Do this at BeginIntermission time and whenever ranks are recalculated
due to enters/exits/forced team changes
========================
*/
void SendScoreboardMessageToAllClients( void ) {
int i;
for ( i = 0 ; i < level.maxclients ; i++ ) {
if ( level.clients[ i ].pers.connected == CON_CONNECTED ) {
DeathmatchScoreboardMessage( g_entities + i );
}
}
}
/*
==================
DeathmatchScoreboard
Draw instead of help message.
Note that it isn't that hard to overflow the 1400 byte message limit!
==================
*/
void DeathmatchScoreboard (edict_t *ent)
{
if (g_dmscoreboardmode->value == 0)
DeathmatchScoreboardMessage (ent, ent->enemy);
else
DeathmatchScoreboardMessage2 (ent, ent->enemy);
gi.unicast (ent, true);
}
/*
==================
DeathmatchScoreboard
Draw instead of help message.
Note that it isn't that hard to overflow the 1400 byte message limit!
==================
*/
void DeathmatchScoreboard (edict_t *ent)
{
//GHz START
if (ent->client->menustorage.menu_active)
closemenu(ent);
//GHz END
DeathmatchScoreboardMessage (ent, ent->enemy);
gi.unicast (ent, true);
}
/*
==================
Cmd_Score_f
Display the scoreboard
==================
*/
static void Cmd_Score_f(edict_t *ent)
{
if (ent->client->layout == LAYOUT_SCORES) {
ent->client->layout = 0;
return;
}
ent->client->layout = LAYOUT_SCORES;
DeathmatchScoreboardMessage(ent, true);
}
/*
==================
DeathmatchScoreboard
Draw instead of help message.
Note that it isn't that hard to overflow the 1400 byte message limit!
==================
*/
void DeathmatchScoreboard (edict_t *ent)
{
// Make sure ent exists!
if (!G_EntExists(ent))
return;
DeathmatchScoreboardMessage (ent, ent->enemy);
gi.unicast (ent, true);
}
/*
========================
SendScoreboardMessageToAllClients
Do this at BeginIntermission time and whenever ranks are recalculated
due to enters/exits/forced team changes
========================
*/
void SendScoreboardMessageToAllClients()
{
int i;
for( i = 1 ; i <= theLevel.maxclients_ ; i++ )
{
GameClient* client = theLevel.getClient(i);
if( client && client->pers_.connected_ == GameClient::ClientPersistant::CON_CONNECTED )
DeathmatchScoreboardMessage( theLevel.getEntity(i) );
}
}
void MoveClientToIntermission (edict_t *ent)
{
gclient_t *client;
//RAV
char song[80];
//
client = ent->client;
if (deathmatch->value || coop->value)
ent->client->showscores = true;
VectorCopy (level.intermission_origin, ent->s.origin);
ent->client->ps.pmove.origin[0] = level.intermission_origin[0]*8;
ent->client->ps.pmove.origin[1] = level.intermission_origin[1]*8;
ent->client->ps.pmove.origin[2] = level.intermission_origin[2]*8;
VectorCopy (level.intermission_angle, ent->client->ps.viewangles);
ent->client->ps.pmove.pm_type = PM_FREEZE;
ent->client->ps.gunindex = 0;
ent->client->ps.blend[3] = 0;
ent->client->ps.rdflags &= ~RDF_UNDERWATER;
// clean up powerup info
client->quad_framenum = 0;
client->invincible_framenum = 0;
client->breather_framenum = 0;
client->enviro_framenum = 0;
client->grenade_blew_up = false;
client->grenade_time = 0;
ent->viewheight = 0;
ent->s.modelindex = 0;
ent->s.modelindex2 = 0;
ent->s.modelindex3 = 0;
ent->s.modelindex = 0;
ent->s.effects = 0;
ent->s.sound = 0;
ent->solid = SOLID_NOT;
// add the layout
if (!ent->bot_client && (deathmatch->value || coop->value))
{
DeathmatchScoreboardMessage (ent, NULL);
gi.unicast (ent, true);
}
//RAV
if(wavs->value && !ent->bot_client)
{
sprintf(song, songtoplay->string);
//gi.sound (ent, CHAN_ITEM, gi.soundindex (song), 1, ATTN_NORM, 0);
stuffcmd(ent, va("play %s\n", song));
}
}
/*
* ================== DeathmatchScoreboard
*
* Draw instead of help message. Note that it isn't that hard to overflow the
* 1400 byte message limit! ==================
*/
void
DeathmatchScoreboard(edict_t * ent)
{
#ifdef WITH_ACEBOT
/* ACEBOT_ADD */
if (ent->is_bot)
return;
/* ACEBOT_END */
#endif
DeathmatchScoreboardMessage(ent, ent->enemy);
gi.unicast(ent, true);
}
void MoveClientToIntermission (edict_t *ent)
{
ent->client->showscores = true;
// VectorCopy (level.intermission_origin, ent->s.origin);
ent->client->ps.pmove.origin[0] = level.intermission_origin[0]*8;
ent->client->ps.pmove.origin[1] = level.intermission_origin[1]*8;
ent->client->ps.pmove.origin[2] = level.intermission_origin[2]*8;
VectorCopy (level.intermission_angle, ent->client->ps.viewangles);
ent->client->ps.pmove.pm_type = PM_FREEZE;
ent->client->ps.gunindex = 0;
ent->client->ps.blend[3] = 0;
VectorCopy (level.intermission_origin, ent->s.origin);
// clean up powerup info
ent->client->quad_framenum = 0;
ent->client->invincible_framenum = 0;
ent->client->breather_framenum = 0;
ent->client->enviro_framenum = 0;
ent->client->grenade_blew_up = false;
ent->client->grenade_time = 0;
// RemoveAllAuras(ent);
// RemoveAllCurses(ent);
AuraRemove(ent, 0);
CurseRemove(ent, 0);
// RAFAEL
ent->client->quadfire_framenum = 0;
// RAFAEL
//ent->client->trap_blew_up = false;
//ent->client->trap_time = 0;
ent->viewheight = 0;
ent->s.modelindex = 0;
ent->s.modelindex2 = 0;
ent->s.modelindex3 = 0;
ent->s.modelindex = 0;
ent->s.effects = 0;
ent->s.sound = 0;
ent->solid = SOLID_NOT;
// add the layout
if (deathmatch->value && !(ent->svflags & SVF_MONSTER))
{
DeathmatchScoreboardMessage (ent, NULL);
gi.unicast (ent, true);
}
}
void
MoveClientToIntermission(edict_t *ent)
{
if (!ent)
{
return;
}
if (deathmatch->value || coop->value)
{
ent->client->showscores = true;
}
VectorCopy(level.intermission_origin, ent->s.origin);
ent->client->ps.pmove.origin[0] = level.intermission_origin[0] * 8;
ent->client->ps.pmove.origin[1] = level.intermission_origin[1] * 8;
ent->client->ps.pmove.origin[2] = level.intermission_origin[2] * 8;
VectorCopy(level.intermission_angle, ent->client->ps.viewangles);
ent->client->ps.pmove.pm_type = PM_FREEZE;
ent->client->ps.gunindex = 0;
ent->client->ps.blend[3] = 0;
ent->client->ps.rdflags &= ~RDF_UNDERWATER;
/* clean up powerup info */
ent->client->quad_framenum = 0;
ent->client->invincible_framenum = 0;
ent->client->breather_framenum = 0;
ent->client->enviro_framenum = 0;
ent->client->grenade_blew_up = false;
ent->client->grenade_time = 0;
ent->viewheight = 0;
ent->s.modelindex = 0;
ent->s.modelindex2 = 0;
ent->s.modelindex3 = 0;
ent->s.modelindex = 0;
ent->s.effects = 0;
ent->s.sound = 0;
ent->solid = SOLID_NOT;
gi.linkentity(ent);
/* add the layout */
if (deathmatch->value || coop->value)
{
DeathmatchScoreboardMessage(ent, NULL);
gi.unicast(ent, true);
}
}
/*
* Called for each player at the end of
* the server frame and right after spawning
*/
void
ClientEndServerFrame(edict_t *ent)
{
float bobtime;
int i;
if (!ent)
{
return;
}
current_player = ent;
current_client = ent->client;
/* If the origin or velocity have changed since ClientThink(),
update the pmove values. This will happen when the client
is pushed by a bmodel or kicked by an explosion.
If it wasn't updated here, the view position would lag a frame
behind the body position when pushed -- "sinking into plats" */
for (i = 0; i < 3; i++)
{
current_client->ps.pmove.origin[i] = ent->s.origin[i] * 8.0;
current_client->ps.pmove.velocity[i] = ent->velocity[i] * 8.0;
}
/* If the end of unit layout is displayed, don't give
the player any normal movement attributes */
if (level.intermissiontime)
{
current_client->ps.blend[3] = 0;
current_client->ps.fov = 90;
G_SetStats(ent);
return;
}
AngleVectors(ent->client->v_angle, forward, right, up);
/* burn from lava, etc */
P_WorldEffects();
/* set model angles from view angles so other things in
the world can tell which direction you are looking */
if (ent->client->v_angle[PITCH] > 180)
{
ent->s.angles[PITCH] = (-360 + ent->client->v_angle[PITCH]) / 3;
}
else
{
ent->s.angles[PITCH] = ent->client->v_angle[PITCH] / 3;
}
ent->s.angles[YAW] = ent->client->v_angle[YAW];
ent->s.angles[ROLL] = 0;
ent->s.angles[ROLL] = SV_CalcRoll(ent->s.angles, ent->velocity) * 4;
/* calculate speed and cycle to be used for
all cyclic walking effects */
xyspeed = sqrt(ent->velocity[0] * ent->velocity[0] +
ent->velocity[1] * ent->velocity[1]);
if (xyspeed < 5)
{
bobmove = 0;
current_client->bobtime = 0; /* start at beginning of cycle again */
}
else if (ent->groundentity)
{
/* so bobbing only cycles when on ground */
if (xyspeed > 210)
{
bobmove = 0.25;
}
else if (xyspeed > 100)
{
bobmove = 0.125;
}
else
{
bobmove = 0.0625;
}
}
bobtime = (current_client->bobtime += bobmove);
if (current_client->ps.pmove.pm_flags & PMF_DUCKED)
{
bobtime *= 4;
}
bobcycle = (int)bobtime;
bobfracsin = fabs(sin(bobtime * M_PI));
/* detect hitting the floor */
P_FallingDamage(ent);
/* apply all the damage taken this frame */
P_DamageFeedback(ent);
/* determine the view offsets */
SV_CalcViewOffset(ent);
/* determine the gun offsets */
SV_CalcGunOffset(ent);
/* determine the full screen color blend
must be after viewoffset, so eye contents
can be accurately determined */
SV_CalcBlend(ent);
/* chase cam stuff */
if (ent->client->resp.spectator)
{
G_SetSpectatorStats(ent);
}
else
{
G_SetStats(ent);
}
G_CheckChaseStats(ent);
G_SetClientEvent(ent);
G_SetClientEffects(ent);
G_SetClientSound(ent);
G_SetClientFrame(ent);
VectorCopy(ent->velocity, ent->client->oldvelocity);
VectorCopy(ent->client->ps.viewangles, ent->client->oldviewangles);
/* clear weapon kicks */
VectorClear(ent->client->kick_origin);
VectorClear(ent->client->kick_angles);
if (!(level.framenum & 31))
{
/* if the scoreboard is up, update it */
if (ent->client->showscores)
{
DeathmatchScoreboardMessage(ent, ent->enemy);
gi.unicast(ent, false);
}
/* if the help computer is up, update it */
if (ent->client->showhelp)
{
ent->client->pers.helpchanged = 0;
HelpComputerMessage(ent);
gi.unicast(ent, false);
}
}
/* if the inventory is up, update it */
if (ent->client->showinventory)
{
InventoryMessage(ent);
gi.unicast(ent, false);
}
}
void ClientEndServerFrame (edict_t *ent)
{
float bobtime;
int i;
current_player = ent;
current_client = ent->client;
//
// If the origin or velocity have changed since ClientThink(),
// update the pmove values. This will happen when the client
// is pushed by a bmodel or kicked by an explosion.
//
// If it wasn't updated here, the view position would lag a frame
// behind the body position when pushed -- "sinking into plats"
//
for (i=0 ; i<3 ; i++)
{
current_client->ps.pmove.origin[i] = ent->s.origin[i]*8.0;
current_client->ps.pmove.velocity[i] = ent->velocity[i]*8.0;
}
//
// If the end of unit layout is displayed, don't give
// the player any normal movement attributes
//
if (level.intermissiontime)
{
// FIXME: add view drifting here?
current_client->ps.blend[3] = 0;
current_client->ps.fov = 90;
G_SetStats (ent);
return;
}
AngleVectors (ent->client->v_angle, forward, right, up);
// burn from lava, etc
P_WorldEffects ();
//
// set model angles from view angles so other things in
// the world can tell which direction you are looking
//
if (ent->client->v_angle[PITCH] > 180)
ent->s.angles[PITCH] = (-360 + ent->client->v_angle[PITCH])/3;
else
ent->s.angles[PITCH] = ent->client->v_angle[PITCH]/3;
ent->s.angles[YAW] = ent->client->v_angle[YAW];
ent->s.angles[ROLL] = 0;
ent->s.angles[ROLL] = SV_CalcRoll (ent->s.angles, ent->velocity)*4;
//
// calculate speed and cycle to be used for
// all cyclic walking effects
//
xyspeed = sqrt(ent->velocity[0]*ent->velocity[0] + ent->velocity[1]*ent->velocity[1]);
if (xyspeed < 5)
{
bobmove = 0;
current_client->bobtime = 0; // start at beginning of cycle again
}
//Kngightmare- exception for wading
else if (ent->groundentity || ent->waterlevel == 2)
{ // so bobbing only cycles when on ground
if (xyspeed > 450) // Knightmare added
bobmove = 0.50;
else if (xyspeed > 210)
bobmove = 0.25;
else if (!ent->groundentity && ent->waterlevel == 2 && xyspeed > 100)
bobmove = 0.45;
else if (xyspeed > 100)
bobmove = 0.125;
else if (!ent->groundentity && ent->waterlevel == 2)
bobmove = 0.325;
else
bobmove = 0.0625;
}
bobtime = (current_client->bobtime += bobmove);
if (current_client->ps.pmove.pm_flags & PMF_DUCKED)
bobtime *= 4;
bobcycle = (int)bobtime;
// Lazarus: vehicle drivers don't bob
if(ent->vehicle)
bobfracsin = 0.;
else
bobfracsin = fabs(sin(bobtime*M_PI));
// detect hitting the floor
P_FallingDamage (ent);
// Lazarus: detect hitting walls
P_SlamDamage (ent);
// apply all the damage taken this frame
P_DamageFeedback (ent);
// determine the view offsets
SV_CalcViewOffset (ent);
// determine the gun offsets
SV_CalcGunOffset (ent);
// determine the full screen color blend
// must be after viewoffset, so eye contents can be
// accurately determined
// FIXME: with client prediction, the contents
// should be determined by the client
SV_CalcBlend (ent);
// chase cam stuff
if (ent->client->resp.spectator)
G_SetSpectatorStats(ent);
//ZOID
else //if (!ent->client->chase_target)
//ZOID
G_SetStats (ent);
G_CheckChaseStats(ent);
G_SetClientEvent (ent);
G_SetClientEffects (ent);
G_SetClientSound (ent);
G_SetClientFrame (ent);
VectorCopy (ent->velocity, ent->client->oldvelocity);
VectorCopy (ent->client->ps.viewangles, ent->client->oldviewangles);
// clear weapon kicks
VectorClear (ent->client->kick_origin);
VectorClear (ent->client->kick_angles);
// if the scoreboard is up, update it
if (!(level.framenum & 31))
{
if (ent->client->showscores)
{
if (ent->client->menu)
{
// PMenu_Update(ent);
PMenu_Do_Update(ent);
ent->client->menudirty = false;
ent->client->menutime = level.time;
}
else if (ent->client->textdisplay)
Text_Update(ent);
else
DeathmatchScoreboardMessage (ent, ent->enemy);
gi.unicast (ent, false);
}
else if(ent->client->whatsit)
WhatsIt(ent);
}
// tpp
if (ent->client->chasetoggle == 1)
CheckChasecam_Viewent(ent);
// end tpp
}
/*
================
G_RankRunFrame
================
*/
void G_RankRunFrame()
{
gentity_t* ent;
gentity_t* ent2;
grank_status_t old_status;
grank_status_t status;
int time;
int i;
int j;
if( !trap_RankCheckInit() )
{
trap_RankBegin( GR_GAMEKEY );
}
trap_RankPoll();
if( trap_RankActive() )
{
for( i = 0; i < level.maxclients; i++ )
{
ent = &(g_entities[i]);
if ( !ent->inuse )
continue;
if ( ent->client == NULL )
continue;
if ( ent->r.svFlags & SVF_BOT)
{
// no bots in ranked games
trap_SendConsoleCommand( EXEC_INSERT, va("kick %s\n",
ent->client->pers.netname) );
continue;
}
old_status = ent->client->client_status;
status = trap_RankUserStatus( i );
if( ent->client->client_status != status )
{
// inform client of current status
// not needed for client side log in
trap_SendServerCommand( i, va("rank_status %i\n",status) );
if ( i == 0 )
{
int j = 0;
}
ent->client->client_status = status;
}
switch( status )
{
case QGR_STATUS_NEW:
case QGR_STATUS_SPECTATOR:
if( ent->client->sess.sessionTeam != TEAM_SPECTATOR )
{
ent->client->sess.sessionTeam = TEAM_SPECTATOR;
ent->client->sess.spectatorState = SPECTATOR_FREE;
ClientSpawn( ent );
// make sure by now CS_GRAND rankingsGameID is ready
trap_SendServerCommand( i, va("rank_status %i\n",status) );
trap_SendServerCommand( i, "rank_menu\n" );
}
break;
case QGR_STATUS_NO_USER:
case QGR_STATUS_BAD_PASSWORD:
case QGR_STATUS_TIMEOUT:
case QGR_STATUS_NO_MEMBERSHIP:
case QGR_STATUS_INVALIDUSER:
case QGR_STATUS_ERROR:
if( (ent->r.svFlags & SVF_BOT) == 0 )
{
trap_RankUserReset( ent->s.clientNum );
}
break;
case QGR_STATUS_ACTIVE:
if( (ent->client->sess.sessionTeam == TEAM_SPECTATOR) &&
(g_gametype.integer < GT_TEAM) )
{
SetTeam( ent, "free" );
}
if( old_status != QGR_STATUS_ACTIVE )
{
// player has just become active
for( j = 0; j < level.maxclients; j++ )
{
ent2 = &(g_entities[j]);
if ( !ent2->inuse )
continue;
if ( ent2->client == NULL )
continue;
if ( ent2->r.svFlags & SVF_BOT)
continue;
if( (i != j) && (trap_RankUserStatus( j ) == QGR_STATUS_ACTIVE) )
{
trap_RankReportInt( i, j, QGR_KEY_PLAYED_WITH, 1, 0 );
}
// send current scores so the player's rank will show
// up under the crosshair immediately
DeathmatchScoreboardMessage( ent2 );
}
}
break;
default:
break;
}
}
// don't let ranked games last forever
if( ((g_fraglimit.integer == 0) || (g_fraglimit.integer > 100)) &&
((g_timelimit.integer == 0) || (g_timelimit.integer > 1000)) )
{
trap_Cvar_Set( "timelimit", "1000" );
}
}
// tell time to clients so they can show current match rating
if( level.intermissiontime == 0 )
{
for( i = 0; i < level.maxclients; i++ )
{
ent = &(g_entities[i]);
if( ent->client == NULL )
{
continue;
}
time = (level.time - ent->client->pers.enterTime) / 1000;
ent->client->ps.persistant[PERS_MATCH_TIME] = time;
}
}
}
/*
==================
Cmd_Score_f
Request current scoreboard information
==================
*/
void Cmd_Score_f( gentity_t *ent ) {
DeathmatchScoreboardMessage( ent );
}
/*
==================
DeathmatchScoreboard
Draw instead of help message.
Note that it isn't that hard to overflow the 1400 byte message limit!
==================
*/
void DeathmatchScoreboard (edict_t *ent)
{
DeathmatchScoreboardMessage (ent, ent->enemy);
gi.unicast (ent, true);
}
/*
=================
ClientEndServerFrame
Called for each player at the end of the server frame
and right after spawning
=================
*/
void ClientEndServerFrame (edict_t * ent)
{
float bobtime;
int i;
//char player_name[30];
//char temp[40];
// int damage; // zucc for bleeding
current_player = ent;
current_client = ent->client;
//AQ2:TNG - Slicer : Stuffs the client x seconds after he enters the server, needed for Video check
if (ent->client->resp.checktime[0] <= level.time)
{
ent->client->resp.checktime[0] = level.time + video_checktime->value;
if (video_check->value || video_check_lockpvs->value
|| video_check_glclear->value || darkmatch->value)
stuffcmd (ent, "%!fc $vid_ref\n");
if (video_force_restart->value && video_check->value && !ent->client->resp.checked)
{
stuffcmd (ent, "vid_restart\n");
ent->client->resp.checked = true;
}
}
if (ent->client->resp.checktime[1] <= level.time)
{
ent->client->resp.checktime[1] = level.time + video_checktime->value;
ent->client->resp.checktime[2] = level.time + 1;
if (video_check->value || video_check_lockpvs->value
|| video_check_glclear->value || darkmatch->value)
{
if (ent->client->resp.vidref && Q_stricmp(ent->client->resp.vidref, "soft"))
stuffcmd (ent, "%cpsi $gl_modulate $gl_lockpvs $gl_clear $gl_dynamic $gl_driver\n");
}
}
if (ent->client->resp.checktime[2] <= level.time)
{
// ent->client->resp.checktime[2] = level.time + video_checktime->value;
if (video_check->value || video_check_lockpvs->value
|| video_check_glclear->value || darkmatch->value)
{
if (ent->client->resp.vidref && Q_stricmp(ent->client->resp.vidref, "soft"))
VideoCheckClient (ent);
}
}
if(pause_time)
{
G_SetStats (ent);
return;
}
//FIREBLADE - Unstick avoidance stuff.
if (ent->solid == SOLID_TRIGGER && !lights_camera_action)
{
edict_t *overlap;
if ((overlap = FindOverlap (ent, NULL)) == NULL)
{
ent->solid = SOLID_BBOX;
gi.linkentity (ent);
RemoveFromTransparentList (ent);
}
else
{
do
{
if (overlap->solid == SOLID_BBOX)
{
overlap->solid = SOLID_TRIGGER;
gi.linkentity (overlap);
AddToTransparentList (overlap);
}
overlap = FindOverlap (ent, overlap);
}
while (overlap != NULL);
}
}
//FIREBLADE
//
// If the origin or velocity have changed since ClientThink(),
// update the pmove values. This will happen when the client
// is pushed by a bmodel or kicked by an explosion.
//
// If it wasn't updated here, the view position would lag a frame
// behind the body position when pushed -- "sinking into plats"
//
for (i = 0; i < 3; i++)
{
current_client->ps.pmove.origin[i] = ent->s.origin[i] * 8.0;
current_client->ps.pmove.velocity[i] = ent->velocity[i] * 8.0;
}
//
// If the end of unit layout is displayed, don't give
// the player any normal movement attributes
//
if (level.intermissiontime)
{
// FIXME: add view drifting here?
current_client->ps.blend[3] = 0;
current_client->ps.fov = 90;
G_SetStats (ent);
return;
}
AngleVectors (ent->client->v_angle, forward, right, up);
// burn from lava, etc
P_WorldEffects ();
//
// set model angles from view angles so other things in
// the world can tell which direction you are looking
//
if (ent->client->v_angle[PITCH] > 180)
ent->s.angles[PITCH] = (-360 + ent->client->v_angle[PITCH]) / 3;
else
ent->s.angles[PITCH] = ent->client->v_angle[PITCH] / 3;
ent->s.angles[YAW] = ent->client->v_angle[YAW];
ent->s.angles[ROLL] = 0;
ent->s.angles[ROLL] = SV_CalcRoll (ent->s.angles, ent->velocity) * 4;
//
// calculate speed and cycle to be used for
// all cyclic walking effects
//
xyspeed = sqrt(ent->velocity[0]*ent->velocity[0] + ent->velocity[1]*ent->velocity[1]);
if (xyspeed < 5 || ent->solid == SOLID_NOT)
{
bobmove = 0;
current_client->bobtime = 0; // start at beginning of cycle again
}
else if (ent->groundentity)
{ // so bobbing only cycles when on ground
if (xyspeed > 210)
bobmove = 0.25;
else if (xyspeed > 100)
bobmove = 0.125;
else
bobmove = 0.0625;
}
bobtime = (current_client->bobtime += bobmove);
if (current_client->ps.pmove.pm_flags & PMF_DUCKED)
bobtime *= 4;
bobcycle = (int) bobtime;
bobfracsin = fabs (sin (bobtime * M_PI));
// detect hitting the floor
P_FallingDamage (ent);
// zucc handle any bleeding damage here
Do_Bleeding (ent);
// apply all the damage taken this frame
P_DamageFeedback (ent);
// determine the view offsets
SV_CalcViewOffset (ent);
// determine the gun offsets
SV_CalcGunOffset (ent);
// determine the full screen color blend
// must be after viewoffset, so eye contents can be
// accurately determined
// FIXME: with client prediction, the contents
// should be determined by the client
SV_CalcBlend (ent);
G_SetStats (ent);
//FIREBLADE
for (i = 1; i <= maxclients->value; i++)
{
int stats_copy;
edict_t *e = g_edicts + i;
if (!ent->inuse || e->client->chase_mode == 0 || e->client->chase_target != ent)
continue;
for (stats_copy = 0; stats_copy < MAX_STATS; stats_copy++)
{
if (stats_copy >= STAT_TEAM_HEADER && stats_copy <= STAT_TEAM2_SCORE)
continue; // protect these
if (stats_copy >= STAT_TEAM3_PIC && stats_copy <= STAT_TEAM3_SCORE)
continue; // protect these
if (stats_copy == STAT_LAYOUTS || stats_copy == STAT_ID_VIEW)
continue; // protect these
if (stats_copy == STAT_SNIPER_ICON && e->client->chase_mode != 2)
continue; // only show sniper lens when in chase mode 2
if (stats_copy == STAT_FRAGS)
continue;
e->client->ps.stats[stats_copy] = ent->client->ps.stats[stats_copy];
}
//FB e->client->ps.stats[STAT_LAYOUTS] = 1;
//FB break;
}
//FIREBLADE
G_SetClientEvent (ent);
G_SetClientEffects (ent);
G_SetClientSound (ent);
G_SetClientFrame (ent);
VectorCopy (ent->velocity, ent->client->oldvelocity);
VectorCopy (ent->client->ps.viewangles, ent->client->oldviewangles);
// clear weapon kicks
VectorClear (ent->client->kick_origin);
VectorClear (ent->client->kick_angles);
// zucc - clear the open door command
ent->client->doortoggle = 0;
if (ent->client->push_timeout > 0)
ent->client->push_timeout--;
/* else
{
ent->client->attacker = NULL;
ent->client->attacker_mod = MOD_BLEEDING;
}
*/
if (ent->client->reload_attempts > 0)
{
if (((ent->client->latched_buttons | ent->client->buttons) & BUTTON_ATTACK)
&& canFire(ent))
{
ent->client->reload_attempts = 0;
}
else
{
Cmd_Reload_f (ent);
}
}
if (ent->client->weapon_attempts > 0)
Cmd_Weapon_f (ent);
// if the scoreboard is up, update it
if (ent->client->showscores && !(level.framenum & 31))
{
//FIREBLADE
if (ent->client->menu)
{
PMenu_Update (ent);
}
else
//FIREBLADE
DeathmatchScoreboardMessage (ent, ent->enemy);
gi.unicast (ent, false);
}
//FIREBLADE
if(!pause_time)
RadioThink (ent);
//FIREBLADE
}
/*
=================
ClientEndServerFrame
Called for each player at the end of the server frame
and right after spawning
=================
*/
void ClientEndServerFrame (edict_t *ent)
{
float bobtime;
int i, updateFrame;
current_player = ent;
current_client = ent->client;
//
// If the origin or velocity have changed since ClientThink(),
// update the pmove values. This will happen when the client
// is pushed by a bmodel or kicked by an explosion.
//
// If it wasn't updated here, the view position would lag a frame
// behind the body position when pushed -- "sinking into plats"
//
for (i=0 ; i<3 ; i++)
{
current_client->ps.pmove.origin[i] = ent->s.origin[i]*8.0;
current_client->ps.pmove.velocity[i] = ent->velocity[i]*8.0;
}
//
// If the end of unit layout is displayed, don't give
// the player any normal movement attributes
//
if (level.intermissiontime)
{
// FIXME: add view drifting here?
current_client->ps.blend[3] = 0;
current_client->ps.fov = 90;
G_SetStats (ent);
return;
}
AngleVectors (ent->client->v_angle, forward, right, up);
// burn from lava, etc
P_WorldEffects ();
//
// set model angles from view angles so other things in
// the world can tell which direction you are looking
//
if (ent->client->v_angle[PITCH] > 180)
ent->s.angles[PITCH] = (-360 + ent->client->v_angle[PITCH])/3;
else
ent->s.angles[PITCH] = ent->client->v_angle[PITCH]/3;
//GHz START
// monsters don't use pitch
if (ent->mtype)
ent->s.angles[PITCH] = 0;
//GHz END
ent->s.angles[YAW] = ent->client->v_angle[YAW];
ent->s.angles[ROLL] = 0;
ent->s.angles[ROLL] = SV_CalcRoll (ent->s.angles, ent->velocity)*4;
//
// calculate speed and cycle to be used for
// all cyclic walking effects
//
xyspeed = sqrt(ent->velocity[0]*ent->velocity[0] + ent->velocity[1]*ent->velocity[1]);
if (xyspeed < 5)
{
bobmove = 0;
current_client->bobtime = 0; // start at beginning of cycle again
}
else if (ent->groundentity)
{ // so bobbing only cycles when on ground
if (xyspeed > 210)
bobmove = 0.25;
else if (xyspeed > 100)
bobmove = 0.125;
else
bobmove = 0.0625;
}
bobtime = (current_client->bobtime += bobmove);
if (current_client->ps.pmove.pm_flags & PMF_DUCKED)
bobtime *= 4;
bobcycle = (int)bobtime;
bobfracsin = fabs(sin(bobtime*M_PI));
// detect hitting the floor
P_FallingDamage (ent);
// apply all the damage taken this frame
P_DamageFeedback (ent);
// determine the view offsets
SV_CalcViewOffset (ent);
// determine the gun offsets
SV_CalcGunOffset (ent);
// determine the full screen color blend
// must be after viewoffset, so eye contents can be
// accurately determined
// FIXME: with client prediction, the contents
// should be determined by the client
SV_CalcBlend (ent);
// chase cam stuff
if (ent->client->resp.spectator)
G_SetSpectatorStats(ent);
else
G_SetStats (ent);
G_CheckChaseStats(ent);
G_SetClientEvent (ent);
G_SetClientEffects (ent);
G_SetClientSound (ent);
G_SetClientFrame (ent);
VectorCopy (ent->velocity, ent->client->oldvelocity);
VectorCopy (ent->client->ps.viewangles, ent->client->oldviewangles);
// clear weapon kicks
VectorClear (ent->client->kick_origin);
VectorClear (ent->client->kick_angles);
if (ent->client->pers.scanner_active & 1)
updateFrame = SCANNER_UPDATE_FREQ;
else
updateFrame = 31;
// if the scoreboard is up, update it
//if (ent->client->showscores && !(level.framenum & 31) && !ent->client->menustorage.menu_active)
if (((ent->client->showscores || ent->client->pers.scanner_active) && !ent->client->menustorage.menu_active && !ent->client->show_allyinfo
&& !(level.framenum % updateFrame)) || (ent->client->pers.scanner_active & 2))
{
DeathmatchScoreboardMessage (ent, ent->enemy);
gi.unicast (ent, false);
}
else if (ent->client->show_allyinfo && !(level.framenum%10))
{
ShowAllyInfo(ent);
}
//GHz START
else if (!ent->client->showscores && ent->client->menustorage.menu_active)
{
closemenu(ent);
}
//GHz END
// P_FollowWall(ent);
}