/*
================
SV_ActivateServer
activate server on changed map, run physics
================
*/
void SV_ActivateServer( void )
{
int i, numFrames;
if( !svs.initialized )
return;
// custom muzzleflashes
pfnPrecacheModel( "sprites/muzzleflash.spr" );
pfnPrecacheModel( "sprites/muzzleflash1.spr" );
pfnPrecacheModel( "sprites/muzzleflash2.spr" );
pfnPrecacheModel( "sprites/muzzleflash3.spr" );
// rocket flare
pfnPrecacheModel( "sprites/animglow01.spr" );
// ricochet sprite
pfnPrecacheModel( "sprites/richo1.spr" );
// Activate the DLL server code
svgame.dllFuncs.pfnServerActivate( svgame.edicts, svgame.numEntities, svgame.globals->maxClients );
// create a baseline for more efficient communications
SV_CreateBaseline();
// check and count all files that marked by user as unmodified (typically is a player models etc)
sv.num_consistency_resources = SV_TransferConsistencyInfo();
// send serverinfo to all connected clients
for( i = 0; i < sv_maxclients->integer; i++ )
{
if( svs.clients[i].state >= cs_connected )
{
Netchan_Clear( &svs.clients[i].netchan );
svs.clients[i].delta_sequence = -1;
}
}
numFrames = (sv.loadgame) ? 1 : 2;
if( !sv.loadgame || svgame.globals->changelevel )
host.frametime = 0.1f;
// GoldSrc rules
// NOTE: this stuff is breaking sound from func_rotating in multiplayer
// e.g. ambience\boomer.wav on snark_pit.bsp
numFrames *= sv_maxclients->integer;
// run some frames to allow everything to settle
for( i = 0; i < numFrames; i++ )
{
SV_Physics();
}
// invoke to refresh all movevars
Q_memset( &svgame.oldmovevars, 0, sizeof( movevars_t ));
svgame.globals->changelevel = false; // changelevel ends here
// setup hostflags
sv.hostflags = 0;
// tell what kind of server has been started.
if( svgame.globals->maxClients > 1 )
{
MsgDev( D_INFO, "%i player server started\n", svgame.globals->maxClients );
Cvar_Reset( "clockwindow" );
}
else
{
// clear the ugly moving delay in singleplayer
Cvar_SetFloat( "clockwindow", 0.0f );
MsgDev( D_INFO, "Game started\n" );
}
if( host.type == HOST_DEDICATED )
{
Mod_FreeUnused ();
}
sv.state = ss_active;
physinfo->modified = true;
sv.changelevel = false;
sv.paused = false;
Host_SetServerState( sv.state );
if( sv_maxclients->integer > 1 && public_server->integer )
{
MsgDev( D_INFO, "Add your server, to master server list\n" );
Master_Add( );
}
}
/*
================
SV_SpawnServer
Change the server to a new map, taking all connected
clients along with it.
================
*/
qboolean SV_SpawnServer( const char *mapname, const char *startspot )
{
int i, current_skill;
qboolean loadgame, paused;
qboolean background, changelevel;
// save state
loadgame = sv.loadgame;
background = sv.background;
changelevel = sv.changelevel;
paused = sv.paused;
if( sv.state == ss_dead )
SV_InitGame(); // the game is just starting
else if( !sv_maxclients->modified )
Cmd_ExecuteString( "latch\n", src_command );
else MsgDev( D_ERROR, "SV_SpawnServer: while 'maxplayers' was modified.\n" );
sv_maxclients->modified = false;
deathmatch->modified = false;
teamplay->modified = false;
coop->modified = false;
if( !svs.initialized )
return false;
svgame.globals->changelevel = false; // will be restored later if needed
svs.timestart = Sys_DoubleTime();
svs.spawncount++; // any partially connected client will be restarted
if( startspot )
{
MsgDev( D_INFO, "Spawn Server: %s [%s]\n", mapname, startspot );
}
else
{
MsgDev( D_INFO, "Spawn Server: %s\n", mapname );
}
sv.state = ss_dead;
Host_SetServerState( sv.state );
Q_memset( &sv, 0, sizeof( sv )); // wipe the entire per-level structure
// restore state
sv.paused = paused;
sv.loadgame = loadgame;
sv.background = background;
sv.changelevel = changelevel;
sv.time = 1.0f; // server spawn time it's always 1.0 second
svgame.globals->time = sv.time;
// initialize buffers
BF_Init( &sv.datagram, "Datagram", sv.datagram_buf, sizeof( sv.datagram_buf ));
BF_Init( &sv.reliable_datagram, "Datagram R", sv.reliable_datagram_buf, sizeof( sv.reliable_datagram_buf ));
BF_Init( &sv.multicast, "Multicast", sv.multicast_buf, sizeof( sv.multicast_buf ));
BF_Init( &sv.signon, "Signon", sv.signon_buf, sizeof( sv.signon_buf ));
BF_Init( &sv.spectator_datagram, "Spectator Datagram", sv.spectator_buf, sizeof( sv.spectator_buf ));
// leave slots at start for clients only
for( i = 0; i < sv_maxclients->integer; i++ )
{
// needs to reconnect
if( svs.clients[i].state > cs_connected )
svs.clients[i].state = cs_connected;
}
// make cvars consistant
if( Cvar_VariableInteger( "coop" )) Cvar_SetFloat( "deathmatch", 0 );
current_skill = (int)(Cvar_VariableValue( "skill" ) + 0.5f);
current_skill = bound( 0, current_skill, 3 );
Cvar_SetFloat( "skill", (float)current_skill );
if( sv.background ) // tell the game parts about background state
Cvar_FullSet( "sv_background", "1", CVAR_READ_ONLY );
else Cvar_FullSet( "sv_background", "0", CVAR_READ_ONLY );
// make sure what server name doesn't contain path and extension
FS_FileBase( mapname, sv.name );
if( startspot )
Q_strncpy( sv.startspot, startspot, sizeof( sv.startspot ));
else sv.startspot[0] = '\0';
Q_snprintf( sv.model_precache[1], sizeof( sv.model_precache[0] ), "maps/%s.bsp", sv.name );
Mod_LoadWorld( sv.model_precache[1], &sv.checksum, false );
sv.worldmodel = Mod_Handle( 1 ); // get world pointer
for( i = 1; i < sv.worldmodel->numsubmodels; i++ )
{
Q_sprintf( sv.model_precache[i+1], "*%i", i );
Mod_RegisterModel( sv.model_precache[i+1], i+1 );
}
// precache and static commands can be issued during map initialization
sv.state = ss_loading;
Host_SetServerState( sv.state );
// clear physics interaction links
SV_ClearWorld();
// tell dlls about new level started
svgame.dllFuncs.pfnParmsNewLevel();
return true;
}
/*
=================
SCR_SizeUp_f
Keybinding command
=================
*/
void SCR_SizeUp_f( void )
{
Cvar_SetFloat( "viewsize", min( scr_viewsize->value + 10, 120 ));
}
/*
=================
SCR_SizeDown_f
Keybinding command
=================
*/
void SCR_SizeDown_f( void )
{
Cvar_SetFloat( "viewsize", max( scr_viewsize->value - 10, 30 ));
}
void CEngineSurface :: setWindowedMode( void )
{
Cvar_SetFloat( "fullscreen", 0.0f );
}
/*
===============
R_ShowTextures
Draw all the images to the screen, on top of whatever
was there. This is used to test for texture thrashing.
===============
*/
void R_ShowTextures( void )
{
gltexture_t *image;
float x, y, w, h;
int i, j, k, base_w, base_h;
int total, start, end;
rgba_t color = { 192, 192, 192, 255 };
int charHeight, numTries = 0;
static qboolean showHelp = true;
string shortname;
if( !gl_showtextures->integer )
return;
if( showHelp )
{
CL_CenterPrint( "use '<-' and '->' keys for view all the textures", 0.25f );
showHelp = false;
}
pglClear( GL_COLOR_BUFFER_BIT );
pglFinish();
base_w = 8;
base_h = 6;
rebuild_page:
total = base_w * base_h;
start = total * (gl_showtextures->integer - 1);
end = total * gl_showtextures->integer;
if( end > MAX_TEXTURES ) end = MAX_TEXTURES;
w = glState.width / base_w;
h = glState.height / base_h;
Con_DrawStringLen( NULL, NULL, &charHeight );
for( i = j = 0; i < MAX_TEXTURES; i++ )
{
image = R_GetTexture( i );
if( j == start ) break; // found start
if( pglIsTexture( image->texnum )) j++;
}
if( i == MAX_TEXTURES && gl_showtextures->integer != 1 )
{
// bad case, rewind to one and try again
Cvar_SetFloat( "r_showtextures", max( 1, gl_showtextures->integer - 1 ));
if( ++numTries < 2 ) goto rebuild_page; // to prevent infinite loop
}
for( k = 0; i < MAX_TEXTURES; i++ )
{
if( j == end ) break; // page is full
image = R_GetTexture( i );
if( !pglIsTexture( image->texnum ))
continue;
x = k % base_w * w;
y = k / base_w * h;
pglColor4f( 1.0f, 1.0f, 1.0f, 1.0f );
GL_Bind( GL_TEXTURE0, i ); // NOTE: don't use image->texnum here, because skybox has a 'wrong' indexes
if(( image->flags & TF_DEPTHMAP ) && !( image->flags & TF_NOCOMPARE ))
pglTexParameteri( image->target, GL_TEXTURE_COMPARE_MODE_ARB, GL_NONE );
pglBegin( GL_QUADS );
pglTexCoord2f( 0, 0 );
pglVertex2f( x, y );
if( image->flags & TF_TEXTURE_RECTANGLE )
pglTexCoord2f( image->width, 0 );
else pglTexCoord2f( 1, 0 );
pglVertex2f( x + w, y );
if( image->flags & TF_TEXTURE_RECTANGLE )
pglTexCoord2f( image->width, image->height );
else pglTexCoord2f( 1, 1 );
pglVertex2f( x + w, y + h );
if( image->flags & TF_TEXTURE_RECTANGLE )
pglTexCoord2f( 0, image->height );
else pglTexCoord2f( 0, 1 );
pglVertex2f( x, y + h );
pglEnd();
if(( image->flags & TF_DEPTHMAP ) && !( image->flags & TF_NOCOMPARE ))
pglTexParameteri( image->target, GL_TEXTURE_COMPARE_MODE_ARB, GL_COMPARE_R_TO_TEXTURE_ARB );
FS_FileBase( image->name, shortname );
if( Q_strlen( shortname ) > 18 )
{
// cutoff too long names, it looks ugly
shortname[16] = '.';
shortname[17] = '.';
shortname[18] = '\0';
}
Con_DrawString( x + 1, y + h - charHeight, shortname, color );
j++, k++;
}
CL_DrawCenterPrint ();
pglFinish();
}
/*
==================
CL_ParseServerData
==================
*/
void CL_ParseServerData( sizebuf_t *msg )
{
string gamefolder;
qboolean background;
int i;
MsgDev( D_NOTE, "Serverdata packet received.\n" );
cls.demowaiting = false; // server is changed
clgame.load_sequence++; // now all hud sprites are invalid
// wipe the client_t struct
if( !cls.changelevel && !cls.changedemo )
CL_ClearState ();
cls.state = ca_connected;
// parse protocol version number
i = BF_ReadLong( msg );
cls.serverProtocol = i;
if( i != PROTOCOL_VERSION )
Host_Error( "Server use invalid protocol (%i should be %i)\n", i, PROTOCOL_VERSION );
cl.servercount = BF_ReadLong( msg );
cl.checksum = BF_ReadLong( msg );
cl.playernum = BF_ReadByte( msg );
cl.maxclients = BF_ReadByte( msg );
clgame.maxEntities = BF_ReadWord( msg );
clgame.maxEntities = bound( 600, clgame.maxEntities, 4096 );
Q_strncpy( clgame.mapname, BF_ReadString( msg ), MAX_STRING );
Q_strncpy( clgame.maptitle, BF_ReadString( msg ), MAX_STRING );
background = BF_ReadOneBit( msg );
Q_strncpy( gamefolder, BF_ReadString( msg ), MAX_STRING );
host.features = (uint)BF_ReadLong( msg );
if( cl.maxclients > 1 && host.developer < 1 )
host.developer++;
// set the background state
if( cls.demoplayback && ( cls.demonum != -1 ))
{
// re-init mouse
host.mouse_visible = false;
cl.background = true;
}
else cl.background = background;
if( cl.background ) // tell the game parts about background state
Cvar_FullSet( "cl_background", "1", CVAR_READ_ONLY );
else Cvar_FullSet( "cl_background", "0", CVAR_READ_ONLY );
if( !cls.changelevel )
{
// continue playing if we are changing level
S_StopBackgroundTrack ();
}
#if 0
// NOTE: this is not tested as well. Use with precaution
CL_ChangeGame( gamefolder, false );
#endif
if( !cls.changedemo )
UI_SetActiveMenu( cl.background );
else if( !cls.demoplayback )
Key_SetKeyDest( key_menu );
cl.refdef.viewentity = cl.playernum + 1; // always keep viewent an actual
menu.globals->maxClients = cl.maxclients;
Q_strncpy( menu.globals->maptitle, clgame.maptitle, sizeof( menu.globals->maptitle ));
if( !cls.changelevel && !cls.changedemo )
CL_InitEdicts (); // re-arrange edicts
// get splash name
if( cls.demoplayback && ( cls.demonum != -1 ))
Cvar_Set( "cl_levelshot_name", va( "levelshots/%s_%s", cls.demoname, glState.wideScreen ? "16x9" : "4x3" ));
else Cvar_Set( "cl_levelshot_name", va( "levelshots/%s_%s", clgame.mapname, glState.wideScreen ? "16x9" : "4x3" ));
Cvar_SetFloat( "scr_loading", 0.0f ); // reset progress bar
if(( cl_allow_levelshots->integer && !cls.changelevel ) || cl.background )
{
if( !FS_FileExists( va( "%s.bmp", cl_levelshot_name->string ), true ))
Cvar_Set( "cl_levelshot_name", "*black" ); // render a black screen
cls.scrshot_request = scrshot_plaque; // request levelshot even if exist (check filetime)
}
if( scr_dark->integer )
{
screenfade_t *sf = &clgame.fade;
client_textmessage_t *title;
title = CL_TextMessageGet( "GAMETITLE" );
if( title )
{
// get settings from titles.txt
sf->fadeEnd = title->holdtime + title->fadeout;
sf->fadeReset = title->fadeout;
}
else sf->fadeEnd = sf->fadeReset = 4.0f;
sf->fadeFlags = FFADE_IN;
sf->fader = sf->fadeg = sf->fadeb = 0;
sf->fadealpha = 255;
sf->fadeSpeed = (float)sf->fadealpha / sf->fadeReset;
sf->fadeReset += cl.time;
sf->fadeEnd += sf->fadeReset;
Cvar_SetFloat( "v_dark", 0.0f );
}
// need to prep refresh at next oportunity
cl.video_prepped = false;
cl.audio_prepped = false;
Q_memset( &clgame.movevars, 0, sizeof( clgame.movevars ));
Q_memset( &clgame.oldmovevars, 0, sizeof( clgame.oldmovevars ));
}
/*
=====================
CL_ParseServerMessage
=====================
*/
void CL_ParseServerMessage( sizebuf_t *msg )
{
char *s;
int i, j, cmd;
int param1, param2;
int bufStart;
cls_message_debug.parsing = true; // begin parsing
starting_count = BF_GetNumBytesRead( msg ); // updates each frame
// parse the message
while( 1 )
{
if( BF_CheckOverflow( msg ))
{
Host_Error( "CL_ParseServerMessage: overflow!\n" );
return;
}
// mark start position
bufStart = BF_GetNumBytesRead( msg );
// end of message
if( BF_GetNumBitsLeft( msg ) < 8 )
break;
cmd = BF_ReadByte( msg );
// record command for debugging spew on parse problem
CL_Parse_RecordCommand( cmd, bufStart );
// other commands
switch( cmd )
{
case svc_bad:
Host_Error( "svc_bad\n" );
break;
case svc_nop:
// this does nothing
break;
case svc_disconnect:
CL_Drop ();
Host_AbortCurrentFrame ();
break;
case svc_changing:
if( BF_ReadOneBit( msg ))
{
cls.changelevel = true;
S_StopAllSounds();
if( cls.demoplayback )
{
SCR_BeginLoadingPlaque( cl.background );
cls.changedemo = true;
}
}
else MsgDev( D_INFO, "Server disconnected, reconnecting\n" );
CL_ClearState ();
CL_InitEdicts (); // re-arrange edicts
if( cls.demoplayback )
{
cl.background = (cls.demonum != -1) ? true : false;
cls.state = ca_connected;
}
else cls.state = ca_connecting;
cls.connect_time = MAX_HEARTBEAT; // CL_CheckForResend() will fire immediately
break;
case svc_setview:
cl.refdef.viewentity = BF_ReadWord( msg );
break;
case svc_sound:
CL_ParseSoundPacket( msg, false );
break;
case svc_time:
// shuffle timestamps
cl.mtime[1] = cl.mtime[0];
cl.mtime[0] = BF_ReadFloat( msg );
break;
case svc_print:
i = BF_ReadByte( msg );
MsgDev( D_INFO, "^6%s", BF_ReadString( msg ));
if( i == PRINT_CHAT ) S_StartLocalSound( "common/menu2.wav", VOL_NORM, false );
break;
case svc_stufftext:
s = BF_ReadString( msg );
Cbuf_AddText( s );
break;
case svc_lightstyle:
CL_ParseLightStyle( msg );
break;
case svc_setangle:
CL_ParseSetAngle( msg );
break;
case svc_serverdata:
Cbuf_Execute(); // make sure any stuffed commands are done
CL_ParseServerData( msg );
break;
case svc_addangle:
CL_ParseAddAngle( msg );
break;
case svc_clientdata:
CL_ParseClientData( msg );
break;
case svc_packetentities:
CL_ParsePacketEntities( msg, false );
break;
case svc_deltapacketentities:
CL_ParsePacketEntities( msg, true );
break;
case svc_updatepings:
CL_UpdateUserPings( msg );
break;
case svc_usermessage:
CL_RegisterUserMessage( msg );
break;
case svc_particle:
CL_ParseParticles( msg );
break;
case svc_restoresound:
CL_ParseRestoreSoundPacket( msg );
break;
case svc_spawnstatic:
CL_ParseStaticEntity( msg );
break;
case svc_ambientsound:
CL_ParseSoundPacket( msg, true );
break;
case svc_crosshairangle:
CL_ParseCrosshairAngle( msg );
break;
case svc_spawnbaseline:
CL_ParseBaseline( msg );
break;
case svc_temp_entity:
CL_ParseTempEntity( msg );
break;
case svc_setpause:
cl.refdef.paused = ( BF_ReadOneBit( msg ) != 0 );
break;
case svc_deltamovevars:
CL_ParseMovevars( msg );
break;
case svc_customization:
CL_ParseCustomization( msg );
break;
case svc_centerprint:
CL_CenterPrint( BF_ReadString( msg ), 0.25f );
break;
case svc_event:
CL_ParseEvent( msg );
break;
case svc_event_reliable:
CL_ParseReliableEvent( msg );
break;
case svc_updateuserinfo:
CL_UpdateUserinfo( msg );
break;
case svc_intermission:
cl.refdef.intermission = true;
break;
case svc_modelindex:
CL_PrecacheModel( msg );
break;
case svc_soundindex:
CL_PrecacheSound( msg );
break;
case svc_soundfade:
CL_ParseSoundFade( msg );
break;
case svc_cdtrack:
param1 = BF_ReadByte( msg );
param1 = bound( 1, param1, MAX_CDTRACKS ); // tracknum
param2 = BF_ReadByte( msg );
param2 = bound( 1, param2, MAX_CDTRACKS ); // loopnum
S_StartBackgroundTrack( clgame.cdtracks[param1-1], clgame.cdtracks[param2-1], 0 );
break;
case svc_serverinfo:
CL_ServerInfo( msg );
break;
case svc_eventindex:
CL_PrecacheEvent( msg );
break;
case svc_deltatable:
Delta_ParseTableField( msg );
break;
case svc_weaponanim:
param1 = BF_ReadByte( msg ); // iAnim
param2 = BF_ReadByte( msg ); // body
CL_WeaponAnim( param1, param2 );
break;
case svc_bspdecal:
CL_ParseStaticDecal( msg );
break;
case svc_roomtype:
param1 = BF_ReadShort( msg );
Cvar_SetFloat( "room_type", param1 );
break;
case svc_chokecount:
i = BF_ReadByte( msg );
j = cls.netchan.incoming_acknowledged - 1;
for( ; i > 0 && j > cls.netchan.outgoing_sequence - CL_UPDATE_BACKUP; j-- )
{
if( cl.frames[j & CL_UPDATE_MASK].receivedtime != -3.0 )
{
cl.frames[j & CL_UPDATE_MASK].receivedtime = -2.0;
i--;
}
}
break;
case svc_resourcelist:
CL_ParseResourceList( msg );
break;
case svc_director:
CL_ParseDirector( msg );
break;
case svc_studiodecal:
CL_ParseStudioDecal( msg );
break;
case svc_querycvarvalue:
CL_ParseCvarValue( msg );
break;
case svc_querycvarvalue2:
CL_ParseCvarValue2( msg );
break;
default:
CL_ParseUserMessage( msg, cmd );
break;
}
}
cls_message_debug.parsing = false; // done
// we don't know if it is ok to save a demo message until
// after we have parsed the frame
if( !cls.demoplayback )
{
if( cls.demorecording && !cls.demowaiting )
{
CL_WriteDemoMessage( false, starting_count, msg );
}
else if( cls.state != ca_active )
{
CL_WriteDemoMessage( true, starting_count, msg );
}
}
}
/*
==============================
Netchan_UpdateProgress
==============================
*/
void Netchan_UpdateProgress( netchan_t *chan )
{
fragbuf_t *p;
int i, c = 0;
int total = 0;
float bestpercent = 0.0;
if ( net_drawslider->integer != 1 )
{
// do show slider for file downloads.
if( !chan->incomingbufs[FRAG_FILE_STREAM] )
{
return;
}
}
for( i = MAX_STREAMS - 1; i >= 0; i-- )
{
// receiving data
if( chan->incomingbufs[i] )
{
p = chan->incomingbufs[i];
total = FRAG_GETCOUNT( p->bufferid );
while( p )
{
c++;
p = p->next;
}
if( total )
{
float percent;
percent = 100.0f * ( float )c / ( float )total;
if( percent > bestpercent )
{
bestpercent = percent;
}
}
p = chan->incomingbufs[i];
if( i == FRAG_FILE_STREAM )
{
char sz[MAX_SYSPATH];
char *in, *out;
int len = 0;
in = (char *)BF_GetData( &p->frag_message );
out = sz;
while( *in )
{
*out++ = *in++;
len++;
if( len > 128 )
break;
}
*out = '\0';
}
}
else if( chan->fragbufs[i] ) // Sending data
{
if( chan->fragbufcount[i] )
{
float percent;
percent = 100.0f * (float)chan->fragbufs[i]->bufferid / (float)chan->fragbufcount[i];
if( percent > bestpercent )
{
bestpercent = percent;
}
}
}
}
if( bestpercent )
Cvar_SetFloat( "scr_download", bestpercent );
}
