void QGL_EnableLogging( bool enable ) {
static bool isEnabled;
// return if we're already active
if ( isEnabled && enable ) {
// decrement log counter and stop if it has reached 0
Cvar_Set( "r_logFile", va( "%d", r_logFile->integer - 1 ) );
if ( r_logFile->integer ) {
return;
}
enable = false;
}
// return if we're already disabled
if ( !enable && !isEnabled ) {
return;
}
isEnabled = enable;
if ( enable ) {
if ( !log_fp ) {
struct tm* newtime;
time_t aclock;
time( &aclock );
newtime = localtime( &aclock );
log_fp = FS_FOpenFileWrite( "gl.log" );
QGL_Log( "%s\n", asctime( newtime ) );
}
#define GLF_0( r, n ) qgl ## n = log ## n;
#define GLF_V0( n ) qgl ## n = log ## n;
#define GLF_1( r, n, t1, p1 ) qgl ## n = log ## n;
#define GLF_V1( n, t1, p1 ) qgl ## n = log ## n;
#define GLF_V2( n, t1, p1, t2, p2 ) qgl ## n = log ## n;
#define GLF_3( r, n, t1, p1, t2, p2, t3, p3 ) qgl ## n = log ## n;
#define GLF_V3( n, t1, p1, t2, p2, t3, p3 ) qgl ## n = log ## n;
#define GLF_V4( n, t1, p1, t2, p2, t3, p3, t4, p4 ) qgl ## n = log ## n;
#define GLF_V5( n, t1, p1, t2, p2, t3, p3, t4, p4, t5, p5 ) qgl ## n = log ## n;
#define GLF_V6( n, t1, p1, t2, p2, t3, p3, t4, p4, t5, p5, t6, p6 ) qgl ## n = log ## n;
#define GLF_V7( n, t1, p1, t2, p2, t3, p3, t4, p4, t5, p5, t6, p6, t7, p7 ) qgl ## n = log ## n;
#define GLF_V8( n, t1, p1, t2, p2, t3, p3, t4, p4, t5, p5, t6, p6, t7, p7, t8, p8 ) qgl ## n = log ## n;
#define GLF_V9( n, t1, p1, t2, p2, t3, p3, t4, p4, t5, p5, t6, p6, t7, p7, t8, p8, t9, p9 ) qgl ## n = log ## n;
#define GLF_V10( n, t1, p1, t2, p2, t3, p3, t4, p4, t5, p5, t6, p6, t7, p7, t8, p8, t9, p9, t10, p10 ) qgl ## n = log ## n;
#include "qgl_functions.h"
#undef GLF_0
#undef GLF_V0
#undef GLF_1
#undef GLF_V1
#undef GLF_V2
#undef GLF_3
#undef GLF_V3
#undef GLF_V4
#undef GLF_V5
#undef GLF_V6
#undef GLF_V7
#undef GLF_V8
#undef GLF_V9
#undef GLF_V10
} else {
if ( log_fp ) {
QGL_Log( "*** CLOSING LOG ***\n" );
FS_FCloseFile( log_fp );
log_fp = 0;
}
#define GLF_0( r, n ) qgl ## n = gl ## n;
#define GLF_V0( n ) qgl ## n = gl ## n;
#define GLF_1( r, n, t1, p1 ) qgl ## n = gl ## n;
#define GLF_V1( n, t1, p1 ) qgl ## n = gl ## n;
#define GLF_V2( n, t1, p1, t2, p2 ) qgl ## n = gl ## n;
#define GLF_3( r, n, t1, p1, t2, p2, t3, p3 ) qgl ## n = gl ## n;
#define GLF_V3( n, t1, p1, t2, p2, t3, p3 ) qgl ## n = gl ## n;
#define GLF_V4( n, t1, p1, t2, p2, t3, p3, t4, p4 ) qgl ## n = gl ## n;
#define GLF_V5( n, t1, p1, t2, p2, t3, p3, t4, p4, t5, p5 ) qgl ## n = gl ## n;
#define GLF_V6( n, t1, p1, t2, p2, t3, p3, t4, p4, t5, p5, t6, p6 ) qgl ## n = gl ## n;
#define GLF_V7( n, t1, p1, t2, p2, t3, p3, t4, p4, t5, p5, t6, p6, t7, p7 ) qgl ## n = gl ## n;
#define GLF_V8( n, t1, p1, t2, p2, t3, p3, t4, p4, t5, p5, t6, p6, t7, p7, t8, p8 ) qgl ## n = gl ## n;
#define GLF_V9( n, t1, p1, t2, p2, t3, p3, t4, p4, t5, p5, t6, p6, t7, p7, t8, p8, t9, p9 ) qgl ## n = gl ## n;
#define GLF_V10( n, t1, p1, t2, p2, t3, p3, t4, p4, t5, p5, t6, p6, t7, p7, t8, p8, t9, p9, t10, p10 ) qgl ## n = gl ## n;
#include "qgl_functions.h"
#undef GLF_0
#undef GLF_V0
#undef GLF_1
#undef GLF_V1
#undef GLF_V2
#undef GLF_3
#undef GLF_V3
#undef GLF_V4
#undef GLF_V5
#undef GLF_V6
#undef GLF_V7
#undef GLF_V8
#undef GLF_V9
#undef GLF_V10
}
}
/*
====================
CL_CgameSystemCalls
The cgame module is making a system call
====================
*/
intptr_t CL_CgameSystemCalls( intptr_t *args ) {
switch ( args[0] ) {
case CG_PRINT:
Com_Printf( "%s", (const char*)VMA(1) );
return 0;
case CG_ERROR:
Com_Error( ERR_DROP, "%s", (const char*)VMA(1) );
return 0;
case CG_MILLISECONDS:
return Sys_Milliseconds();
case CG_CVAR_REGISTER:
Cvar_Register( VMA( 1 ), VMA( 2 ), VMA( 3 ), args[4] );
return 0;
case CG_CVAR_UPDATE:
Cvar_Update( VMA( 1 ) );
return 0;
case CG_CVAR_SET:
Cvar_SetSafe( VMA(1), VMA(2) );
return 0;
case CG_CVAR_VARIABLESTRINGBUFFER:
Cvar_VariableStringBuffer( VMA( 1 ), VMA( 2 ), args[3] );
return 0;
case CG_ARGC:
return Cmd_Argc();
case CG_ARGV:
Cmd_ArgvBuffer( args[1], VMA( 2 ), args[3] );
return 0;
case CG_ARGS:
Cmd_ArgsBuffer( VMA( 1 ), args[2] );
return 0;
case CG_FS_FOPENFILE:
return FS_FOpenFileByMode( VMA( 1 ), VMA( 2 ), args[3] );
case CG_FS_READ:
FS_Read( VMA( 1 ), args[2], args[3] );
return 0;
case CG_FS_WRITE:
return FS_Write( VMA( 1 ), args[2], args[3] );
case CG_FS_FCLOSEFILE:
FS_FCloseFile( args[1] );
return 0;
case CG_SENDCONSOLECOMMAND:
Cbuf_AddText( VMA( 1 ) );
return 0;
case CG_ADDCOMMAND:
CL_AddCgameCommand( VMA( 1 ) );
return 0;
case CG_REMOVECOMMAND:
Cmd_RemoveCommandSafe( VMA(1) );
return 0;
case CG_SENDCLIENTCOMMAND:
CL_AddReliableCommand(VMA(1), qfalse);
return 0;
case CG_UPDATESCREEN:
// this is used during lengthy level loading, so pump message loop
// Com_EventLoop(); // FIXME: if a server restarts here, BAD THINGS HAPPEN!
// We can't call Com_EventLoop here, a restart will crash and this _does_ happen
// if there is a map change while we are downloading at pk3.
// ZOID
SCR_UpdateScreen();
return 0;
case CG_CM_LOADMAP:
CL_CM_LoadMap( VMA( 1 ) );
return 0;
case CG_CM_NUMINLINEMODELS:
return CM_NumInlineModels();
case CG_CM_INLINEMODEL:
return CM_InlineModel( args[1] );
case CG_CM_TEMPBOXMODEL:
return CM_TempBoxModel( VMA( 1 ), VMA( 2 ), qfalse );
case CG_CM_TEMPCAPSULEMODEL:
return CM_TempBoxModel( VMA( 1 ), VMA( 2 ), qtrue );
case CG_CM_POINTCONTENTS:
return CM_PointContents( VMA( 1 ), args[2] );
case CG_CM_TRANSFORMEDPOINTCONTENTS:
return CM_TransformedPointContents( VMA( 1 ), args[2], VMA( 3 ), VMA( 4 ) );
case CG_CM_BOXTRACE:
CM_BoxTrace( VMA( 1 ), VMA( 2 ), VMA( 3 ), VMA( 4 ), VMA( 5 ), args[6], args[7], /*int capsule*/ qfalse );
return 0;
case CG_CM_TRANSFORMEDBOXTRACE:
CM_TransformedBoxTrace( VMA( 1 ), VMA( 2 ), VMA( 3 ), VMA( 4 ), VMA( 5 ), args[6], args[7], VMA( 8 ), VMA( 9 ), /*int capsule*/ qfalse );
return 0;
case CG_CM_CAPSULETRACE:
CM_BoxTrace( VMA( 1 ), VMA( 2 ), VMA( 3 ), VMA( 4 ), VMA( 5 ), args[6], args[7], /*int capsule*/ qtrue );
return 0;
case CG_CM_TRANSFORMEDCAPSULETRACE:
CM_TransformedBoxTrace( VMA( 1 ), VMA( 2 ), VMA( 3 ), VMA( 4 ), VMA( 5 ), args[6], args[7], VMA( 8 ), VMA( 9 ), /*int capsule*/ qtrue );
return 0;
case CG_CM_MARKFRAGMENTS:
return re.MarkFragments( args[1], VMA( 2 ), VMA( 3 ), args[4], VMA( 5 ), args[6], VMA( 7 ) );
case CG_S_STARTSOUND:
S_StartSound( VMA( 1 ), args[2], args[3], args[4] );
return 0;
//----(SA) added
case CG_S_STARTSOUNDEX:
S_StartSoundEx( VMA( 1 ), args[2], args[3], args[4], args[5] );
return 0;
//----(SA) end
case CG_S_STARTLOCALSOUND:
S_StartLocalSound( args[1], args[2] );
return 0;
case CG_S_CLEARLOOPINGSOUNDS:
S_ClearLoopingSounds( args[1] ); // (SA) modified so no_pvs sounds can function
return 0;
case CG_S_ADDLOOPINGSOUND:
// FIXME MrE: handling of looping sounds changed
S_AddLoopingSound( args[1], VMA( 2 ), VMA( 3 ), args[4], args[5], args[6] );
return 0;
case CG_S_ADDREALLOOPINGSOUND:
S_AddLoopingSound( args[1], VMA( 2 ), VMA( 3 ), args[4], args[5], args[6] );
//S_AddRealLoopingSound( args[1], VMA(2), VMA(3), args[4], args[5] );
return 0;
case CG_S_STOPLOOPINGSOUND:
// RF, not functional anymore, since we reverted to old looping code
//S_StopLoopingSound( args[1] );
return 0;
case CG_S_UPDATEENTITYPOSITION:
S_UpdateEntityPosition( args[1], VMA( 2 ) );
return 0;
// Ridah, talking animations
case CG_S_GETVOICEAMPLITUDE:
return S_GetVoiceAmplitude( args[1] );
// done.
case CG_S_RESPATIALIZE:
S_Respatialize( args[1], VMA( 2 ), VMA( 3 ), args[4] );
return 0;
case CG_S_REGISTERSOUND:
return S_RegisterSound( VMA( 1 ), qfalse );
case CG_S_STARTBACKGROUNDTRACK:
S_StartBackgroundTrack( VMA( 1 ), VMA( 2 ) );
return 0;
case CG_S_STARTSTREAMINGSOUND:
S_StartStreamingSound( VMA( 1 ), VMA( 2 ), args[3], args[4], args[5] );
return 0;
case CG_R_LOADWORLDMAP:
re.LoadWorld( VMA( 1 ) );
return 0;
case CG_R_REGISTERMODEL:
return re.RegisterModel( VMA( 1 ) );
case CG_R_REGISTERSKIN:
return re.RegisterSkin( VMA( 1 ) );
//----(SA) added
case CG_R_GETSKINMODEL:
return re.GetSkinModel( args[1], VMA( 2 ), VMA( 3 ) );
case CG_R_GETMODELSHADER:
return re.GetShaderFromModel( args[1], args[2], args[3] );
//----(SA) end
case CG_R_REGISTERSHADER:
return re.RegisterShader( VMA( 1 ) );
case CG_R_REGISTERFONT:
re.RegisterFont( VMA( 1 ), args[2], VMA( 3 ) );
return 0;
case CG_R_REGISTERSHADERNOMIP:
return re.RegisterShaderNoMip( VMA( 1 ) );
case CG_R_CLEARSCENE:
re.ClearScene();
return 0;
case CG_R_ADDREFENTITYTOSCENE:
re.AddRefEntityToScene( VMA( 1 ) );
return 0;
case CG_R_ADDPOLYTOSCENE:
re.AddPolyToScene( args[1], args[2], VMA( 3 ) );
return 0;
// Ridah
case CG_R_ADDPOLYSTOSCENE:
re.AddPolysToScene( args[1], args[2], VMA( 3 ), args[4] );
return 0;
// done.
// case CG_R_LIGHTFORPOINT:
// return re.LightForPoint( VMA(1), VMA(2), VMA(3), VMA(4) );
case CG_R_ADDLIGHTTOSCENE:
re.AddLightToScene( VMA( 1 ), VMF( 2 ), VMF( 3 ), VMF( 4 ), VMF( 5 ), args[6] );
return 0;
// case CG_R_ADDADDITIVELIGHTTOSCENE:
// re.AddAdditiveLightToScene( VMA(1), VMF(2), VMF(3), VMF(4), VMF(5) );
// return 0;
case CG_R_ADDCORONATOSCENE:
re.AddCoronaToScene( VMA( 1 ), VMF( 2 ), VMF( 3 ), VMF( 4 ), VMF( 5 ), args[6], args[7] );
return 0;
case CG_R_SETFOG:
re.SetFog( args[1], args[2], args[3], VMF( 4 ), VMF( 5 ), VMF( 6 ), VMF( 7 ) );
return 0;
case CG_R_RENDERSCENE:
re.RenderScene( VMA( 1 ) );
return 0;
case CG_R_SETCOLOR:
re.SetColor( VMA( 1 ) );
return 0;
case CG_R_DRAWSTRETCHPIC:
re.DrawStretchPic( VMF( 1 ), VMF( 2 ), VMF( 3 ), VMF( 4 ), VMF( 5 ), VMF( 6 ), VMF( 7 ), VMF( 8 ), args[9] );
return 0;
case CG_R_DRAWROTATEDPIC:
re.DrawRotatedPic( VMF( 1 ), VMF( 2 ), VMF( 3 ), VMF( 4 ), VMF( 5 ), VMF( 6 ), VMF( 7 ), VMF( 8 ), args[9], VMF( 10 ) );
return 0;
case CG_R_DRAWSTRETCHPIC_GRADIENT:
re.DrawStretchPicGradient( VMF( 1 ), VMF( 2 ), VMF( 3 ), VMF( 4 ), VMF( 5 ), VMF( 6 ), VMF( 7 ), VMF( 8 ), args[9], VMA( 10 ), args[11] );
return 0;
case CG_R_MODELBOUNDS:
re.ModelBounds( args[1], VMA( 2 ), VMA( 3 ) );
return 0;
case CG_R_LERPTAG:
return re.LerpTag( VMA( 1 ), VMA( 2 ), VMA( 3 ), args[4] );
case CG_GETGLCONFIG:
CL_GetGlconfig( VMA( 1 ) );
return 0;
case CG_GETGAMESTATE:
CL_GetGameState( VMA( 1 ) );
return 0;
case CG_GETCURRENTSNAPSHOTNUMBER:
CL_GetCurrentSnapshotNumber( VMA( 1 ), VMA( 2 ) );
return 0;
case CG_GETSNAPSHOT:
return CL_GetSnapshot( args[1], VMA( 2 ) );
case CG_GETSERVERCOMMAND:
return CL_GetServerCommand( args[1] );
case CG_GETCURRENTCMDNUMBER:
return CL_GetCurrentCmdNumber();
case CG_GETUSERCMD:
return CL_GetUserCmd( args[1], VMA( 2 ) );
case CG_SETUSERCMDVALUE:
CL_SetUserCmdValue( args[1], args[2], VMF( 3 ), args[4], args[5] );
return 0;
case CG_SETCLIENTLERPORIGIN:
CL_SetClientLerpOrigin( VMF( 1 ), VMF( 2 ), VMF( 3 ) );
return 0;
case CG_MEMORY_REMAINING:
return Hunk_MemoryRemaining();
case CG_KEY_ISDOWN:
return Key_IsDown( args[1] );
case CG_KEY_GETCATCHER:
return Key_GetCatcher();
case CG_KEY_SETCATCHER:
// Don't allow the cgame module to close the console
Key_SetCatcher( args[1] | ( Key_GetCatcher( ) & KEYCATCH_CONSOLE ) );
return 0;
case CG_KEY_GETKEY:
return Key_GetKey( VMA( 1 ) );
case CG_MEMSET:
Com_Memset( VMA(1), args[2], args[3] );
return args[1];
case CG_MEMCPY:
Com_Memcpy( VMA(1), VMA(2), args[3] );
return args[1];
case CG_STRNCPY:
strncpy( VMA(1), VMA(2), args[3] );
return args[1];
case CG_SIN:
return FloatAsInt( sin( VMF( 1 ) ) );
case CG_COS:
return FloatAsInt( cos( VMF( 1 ) ) );
case CG_ATAN2:
return FloatAsInt( atan2( VMF( 1 ), VMF( 2 ) ) );
case CG_SQRT:
return FloatAsInt( sqrt( VMF( 1 ) ) );
case CG_FLOOR:
return FloatAsInt( floor( VMF( 1 ) ) );
case CG_CEIL:
return FloatAsInt( ceil( VMF( 1 ) ) );
case CG_ACOS:
return FloatAsInt( Q_acos( VMF( 1 ) ) );
case CG_PC_ADD_GLOBAL_DEFINE:
return botlib_export->PC_AddGlobalDefine( VMA( 1 ) );
case CG_PC_LOAD_SOURCE:
return botlib_export->PC_LoadSourceHandle( VMA( 1 ) );
case CG_PC_FREE_SOURCE:
return botlib_export->PC_FreeSourceHandle( args[1] );
case CG_PC_READ_TOKEN:
return botlib_export->PC_ReadTokenHandle( args[1], VMA( 2 ) );
case CG_PC_SOURCE_FILE_AND_LINE:
return botlib_export->PC_SourceFileAndLine( args[1], VMA( 2 ), VMA( 3 ) );
case CG_S_STOPBACKGROUNDTRACK:
S_StopBackgroundTrack();
return 0;
case CG_REAL_TIME:
return Com_RealTime( VMA( 1 ) );
case CG_SNAPVECTOR:
Q_SnapVector(VMA(1));
return 0;
case CG_SENDMOVESPEEDSTOGAME:
SV_SendMoveSpeedsToGame( args[1], VMA( 2 ) );
return 0;
case CG_CIN_PLAYCINEMATIC:
return CIN_PlayCinematic( VMA( 1 ), args[2], args[3], args[4], args[5], args[6] );
case CG_CIN_STOPCINEMATIC:
return CIN_StopCinematic( args[1] );
case CG_CIN_RUNCINEMATIC:
return CIN_RunCinematic( args[1] );
case CG_CIN_DRAWCINEMATIC:
CIN_DrawCinematic( args[1] );
return 0;
case CG_CIN_SETEXTENTS:
CIN_SetExtents( args[1], args[2], args[3], args[4], args[5] );
return 0;
case CG_R_REMAP_SHADER:
re.RemapShader( VMA( 1 ), VMA( 2 ), VMA( 3 ) );
return 0;
case CG_TESTPRINTINT:
// Com_Printf( "%s%i\n", (const char*)VMA( 1 ), args[2] );
return 0;
case CG_TESTPRINTFLOAT:
// Com_Printf( "%s%f\n", (const char*)VMA( 1 ), VMF( 2 ) );
return 0;
case CG_LOADCAMERA:
return loadCamera( args[1], VMA( 2 ) );
case CG_STARTCAMERA:
startCamera( args[1], args[2] );
return 0;
case CG_GETCAMERAINFO:
return getCameraInfo( args[1], args[2], VMA( 3 ), VMA( 4 ), VMA( 5 ) );
case CG_GET_ENTITY_TOKEN:
return re.GetEntityToken( VMA( 1 ), args[2] );
case CG_INGAME_POPUP:
if ( clc.state == CA_ACTIVE && !clc.demoplaying ) {
// NERVE - SMF
if ( VMA( 1 ) && !Q_stricmp( VMA( 1 ), "UIMENU_WM_PICKTEAM" ) ) {
VM_Call( uivm, UI_SET_ACTIVE_MENU, UIMENU_WM_PICKTEAM );
} else if ( VMA( 1 ) && !Q_stricmp( VMA( 1 ), "UIMENU_WM_PICKPLAYER" ) ) {
VM_Call( uivm, UI_SET_ACTIVE_MENU, UIMENU_WM_PICKPLAYER );
} else if ( VMA( 1 ) && !Q_stricmp( VMA( 1 ), "UIMENU_WM_QUICKMESSAGE" ) ) {
VM_Call( uivm, UI_SET_ACTIVE_MENU, UIMENU_WM_QUICKMESSAGE );
} else if ( VMA( 1 ) && !Q_stricmp( VMA( 1 ), "UIMENU_WM_QUICKMESSAGEALT" ) ) {
VM_Call( uivm, UI_SET_ACTIVE_MENU, UIMENU_WM_QUICKMESSAGEALT );
} else if ( VMA( 1 ) && !Q_stricmp( VMA( 1 ), "UIMENU_WM_LIMBO" ) ) {
VM_Call( uivm, UI_SET_ACTIVE_MENU, UIMENU_WM_LIMBO );
} else if ( VMA( 1 ) && !Q_stricmp( VMA( 1 ), "UIMENU_WM_AUTOUPDATE" ) ) {
VM_Call( uivm, UI_SET_ACTIVE_MENU, UIMENU_WM_AUTOUPDATE );
}
// -NERVE - SMF
else if ( VMA( 1 ) && !Q_stricmp( VMA( 1 ), "hbook1" ) ) { //----(SA)
VM_Call( uivm, UI_SET_ACTIVE_MENU, UIMENU_BOOK1 );
} else if ( VMA( 1 ) && !Q_stricmp( VMA( 1 ), "hbook2" ) ) { //----(SA)
VM_Call( uivm, UI_SET_ACTIVE_MENU, UIMENU_BOOK2 );
} else if ( VMA( 1 ) && !Q_stricmp( VMA( 1 ), "hbook3" ) ) { //----(SA)
VM_Call( uivm, UI_SET_ACTIVE_MENU, UIMENU_BOOK3 );
} else {
VM_Call( uivm, UI_SET_ACTIVE_MENU, UIMENU_CLIPBOARD );
}
}
return 0;
// NERVE - SMF
case CG_INGAME_CLOSEPOPUP:
// if popup menu is up, then close it
if ( VMA( 1 ) && !Q_stricmp( VMA( 1 ), "UIMENU_WM_LIMBO" ) ) {
if ( VM_Call( uivm, UI_GET_ACTIVE_MENU ) == UIMENU_WM_LIMBO ) {
VM_Call( uivm, UI_KEY_EVENT, K_ESCAPE, qtrue );
VM_Call( uivm, UI_KEY_EVENT, K_ESCAPE, qtrue );
}
}
return 0;
case CG_LIMBOCHAT:
if ( VMA( 1 ) ) {
CL_AddToLimboChat( VMA( 1 ) );
}
return 0;
case CG_KEY_GETBINDINGBUF:
Key_GetBindingBuf( args[1], VMA( 2 ), args[3] );
return 0;
case CG_KEY_SETBINDING:
Key_SetBinding( args[1], VMA( 2 ) );
return 0;
case CG_KEY_KEYNUMTOSTRINGBUF:
Key_KeynumToStringBuf( args[1], VMA( 2 ), args[3] );
return 0;
case CG_TRANSLATE_STRING:
CL_TranslateString( VMA( 1 ), VMA( 2 ) );
return 0;
// - NERVE - SMF
default:
Com_Error( ERR_DROP, "Bad cgame system trap: %ld", (long int) args[0] );
}
return 0;
}
/*
================
SV_SpawnServer
Change the server to a new map, taking all connected
clients along with it.
================
*/
void SV_SpawnServer (char *server, char *spawnpoint, server_state_t serverstate, qboolean attractloop, qboolean loadgame)
{
int i;
unsigned checksum;
if (attractloop)
Cvar_Set ("paused", "0");
Com_Printf ("------- Server Initialization -------\n");
Com_DPrintf ("SpawnServer: %s\n",server);
if (sv.demofile)
FS_FCloseFile (sv.demofile);
svs.spawncount++; // any partially connected client will be
// restarted
sv.state = ss_dead;
Com_SetServerState (sv.state);
// wipe the entire per-level structure
memset (&sv, 0, sizeof(sv));
svs.realtime = 0;
sv.loadgame = loadgame;
sv.attractloop = attractloop;
// save name for levels that don't set message
strcpy (sv.configstrings[CS_NAME], server);
if (Cvar_VariableValue ("deathmatch"))
{
sprintf(sv.configstrings[CS_AIRACCEL], "%g", sv_airaccelerate->value);
pm_airaccelerate = sv_airaccelerate->value;
}
else
{
strcpy(sv.configstrings[CS_AIRACCEL], "0");
pm_airaccelerate = 0;
}
SZ_Init (&sv.multicast, sv.multicast_buf, sizeof(sv.multicast_buf));
strcpy (sv.name, server);
// leave slots at start for clients only
for (i=0 ; i<maxclients->value ; i++)
{
// needs to reconnect
if (svs.clients[i].state > cs_connected)
svs.clients[i].state = cs_connected;
svs.clients[i].lastframe = -1;
}
sv.time = 1000;
strcpy (sv.name, server);
strcpy (sv.configstrings[CS_NAME], server);
if (serverstate != ss_game)
{
sv.models[1] = CM_LoadMap ("", false, &checksum); // no real map
}
else
{
Com_sprintf (sv.configstrings[CS_MODELS+1],sizeof(sv.configstrings[CS_MODELS+1]),
"maps/%s.bsp", server);
sv.models[1] = CM_LoadMap (sv.configstrings[CS_MODELS+1], false, &checksum);
}
Com_sprintf (sv.configstrings[CS_MAPCHECKSUM],sizeof(sv.configstrings[CS_MAPCHECKSUM]),
"%i", checksum);
//
// clear physics interaction links
//
SV_ClearWorld ();
for (i=1 ; i< CM_NumInlineModels() ; i++)
{
Com_sprintf (sv.configstrings[CS_MODELS+1+i], sizeof(sv.configstrings[CS_MODELS+1+i]),
"*%i", i);
sv.models[i+1] = CM_InlineModel (sv.configstrings[CS_MODELS+1+i]);
}
//
// spawn the rest of the entities on the map
//
// precache and static commands can be issued during
// map initialization
sv.state = ss_loading;
Com_SetServerState (sv.state);
// load and spawn all other entities
ge->SpawnEntities ( sv.name, CM_EntityString(), spawnpoint );
// run two frames to allow everything to settle
ge->RunFrame ();
ge->RunFrame ();
// all precaches are complete
sv.state = serverstate;
Com_SetServerState (sv.state);
// create a baseline for more efficient communications
SV_CreateBaseline ();
// check for a savegame
SV_CheckForSavegame ();
// set serverinfo variable
Cvar_FullSet ("mapname", sv.name, CVAR_SERVERINFO | CVAR_NOSET);
Com_Printf ("-------------------------------------\n");
}
/*
====================
CL_CgameSystemCalls
The cgame module is making a system call
====================
*/
intptr_t CL_CgameSystemCalls( intptr_t *args ) {
switch( args[0] ) {
case CG_PRINT:
Com_Printf( "%s", (const char*)VMA(1) );
return 0;
case CG_ERROR:
Com_Error( ERR_DROP, "%s", (const char*)VMA(1) );
return 0;
case CG_MILLISECONDS:
return Sys_Milliseconds();
case CG_CVAR_REGISTER:
Cvar_Register( VMA(1), VMA(2), VMA(3), args[4] );
return 0;
case CG_CVAR_UPDATE:
Cvar_Update( VMA(1) );
return 0;
case CG_CVAR_SET:
Cvar_Set( VMA(1), VMA(2) );
return 0;
case CG_CVAR_VARIABLESTRINGBUFFER:
Cvar_VariableStringBuffer( VMA(1), VMA(2), args[3] );
return 0;
case CG_ARGC:
return Cmd_Argc();
case CG_ARGV:
Cmd_ArgvBuffer( args[1], VMA(2), args[3] );
return 0;
case CG_ARGS:
Cmd_ArgsBuffer( VMA(1), args[2] );
return 0;
case CG_FS_FOPENFILE:
return FS_FOpenFileByMode( VMA(1), VMA(2), args[3] );
case CG_FS_READ:
FS_Read2( VMA(1), args[2], args[3] );
return 0;
case CG_FS_WRITE:
FS_Write( VMA(1), args[2], args[3] );
return 0;
case CG_FS_FCLOSEFILE:
FS_FCloseFile( args[1] );
return 0;
case CG_FS_SEEK:
return FS_Seek( args[1], args[2], args[3] );
case CG_SENDCONSOLECOMMAND:
Cbuf_AddText( VMA(1) );
return 0;
case CG_ADDCOMMAND:
CL_AddCgameCommand( VMA(1) );
return 0;
case CG_REMOVECOMMAND:
Cmd_RemoveCommand( VMA(1) );
return 0;
case CG_SENDCLIENTCOMMAND:
CL_AddReliableCommand( VMA(1) );
return 0;
case CG_UPDATESCREEN:
// this is used during lengthy level loading, so pump message loop
// Com_EventLoop(); // FIXME: if a server restarts here, BAD THINGS HAPPEN!
// We can't call Com_EventLoop here, a restart will crash and this _does_ happen
// if there is a map change while we are downloading at pk3.
// ZOID
SCR_UpdateScreen();
return 0;
case CG_CM_LOADMAP:
CL_CM_LoadMap( VMA(1) );
return 0;
case CG_CM_NUMINLINEMODELS:
return CM_NumInlineModels();
case CG_CM_INLINEMODEL:
return CM_InlineModel( args[1] );
case CG_CM_TEMPBOXMODEL:
return CM_TempBoxModel( VMA(1), VMA(2), /*int capsule*/ qfalse );
case CG_CM_TEMPCAPSULEMODEL:
return CM_TempBoxModel( VMA(1), VMA(2), /*int capsule*/ qtrue );
case CG_CM_POINTCONTENTS:
return CM_PointContents( VMA(1), args[2] );
case CG_CM_TRANSFORMEDPOINTCONTENTS:
return CM_TransformedPointContents( VMA(1), args[2], VMA(3), VMA(4) );
case CG_CM_BOXTRACE:
CM_BoxTrace( VMA(1), VMA(2), VMA(3), VMA(4), VMA(5), args[6], args[7], /*int capsule*/ qfalse );
return 0;
case CG_CM_CAPSULETRACE:
CM_BoxTrace( VMA(1), VMA(2), VMA(3), VMA(4), VMA(5), args[6], args[7], /*int capsule*/ qtrue );
return 0;
case CG_CM_TRANSFORMEDBOXTRACE:
CM_TransformedBoxTrace( VMA(1), VMA(2), VMA(3), VMA(4), VMA(5), args[6], args[7], VMA(8), VMA(9), /*int capsule*/ qfalse );
return 0;
case CG_CM_TRANSFORMEDCAPSULETRACE:
CM_TransformedBoxTrace( VMA(1), VMA(2), VMA(3), VMA(4), VMA(5), args[6], args[7], VMA(8), VMA(9), /*int capsule*/ qtrue );
return 0;
case CG_CM_MARKFRAGMENTS:
return re.MarkFragments( args[1], VMA(2), VMA(3), args[4], VMA(5), args[6], VMA(7) );
case CG_S_STARTSOUND:
S_StartSound( VMA(1), args[2], args[3], args[4] );
return 0;
case CG_S_STARTLOCALSOUND:
S_StartLocalSound( args[1], args[2] );
return 0;
case CG_S_CLEARLOOPINGSOUNDS:
S_ClearLoopingSounds(args[1]);
return 0;
case CG_S_ADDLOOPINGSOUND:
S_AddLoopingSound( args[1], VMA(2), VMA(3), args[4] );
return 0;
case CG_S_ADDREALLOOPINGSOUND:
S_AddRealLoopingSound( args[1], VMA(2), VMA(3), args[4] );
return 0;
case CG_S_STOPLOOPINGSOUND:
S_StopLoopingSound( args[1] );
return 0;
case CG_S_UPDATEENTITYPOSITION:
S_UpdateEntityPosition( args[1], VMA(2) );
return 0;
case CG_S_RESPATIALIZE:
S_Respatialize( args[1], VMA(2), VMA(3), args[4] );
return 0;
case CG_S_REGISTERSOUND:
return S_RegisterSound( VMA(1), args[2] );
case CG_S_STARTBACKGROUNDTRACK:
S_StartBackgroundTrack( VMA(1), VMA(2) );
return 0;
case CG_R_LOADWORLDMAP:
re.LoadWorld( VMA(1) );
return 0;
case CG_R_REGISTERMODEL:
return re.RegisterModel( VMA(1) );
case CG_R_REGISTERSKIN:
return re.RegisterSkin( VMA(1) );
case CG_R_REGISTERSHADER:
return re.RegisterShader( VMA(1) );
case CG_R_REGISTERSHADERNOMIP:
return re.RegisterShaderNoMip( VMA(1) );
case CG_R_REGISTERFONT:
re.RegisterFont( VMA(1), args[2], VMA(3));
case CG_R_CLEARSCENE:
re.ClearScene();
return 0;
case CG_R_ADDREFENTITYTOSCENE:
re.AddRefEntityToScene( VMA(1) );
return 0;
case CG_R_ADDPOLYTOSCENE:
re.AddPolyToScene( args[1], args[2], VMA(3), 1 );
return 0;
case CG_R_ADDPOLYSTOSCENE:
re.AddPolyToScene( args[1], args[2], VMA(3), args[4] );
return 0;
case CG_R_LIGHTFORPOINT:
return re.LightForPoint( VMA(1), VMA(2), VMA(3), VMA(4) );
case CG_R_ADDLIGHTTOSCENE:
re.AddLightToScene( VMA(1), VMF(2), VMF(3), VMF(4), VMF(5) );
return 0;
case CG_R_ADDADDITIVELIGHTTOSCENE:
re.AddAdditiveLightToScene( VMA(1), VMF(2), VMF(3), VMF(4), VMF(5) );
return 0;
case CG_R_RENDERSCENE:
re.RenderScene( VMA(1) );
return 0;
case CG_R_SETCOLOR:
re.SetColor( VMA(1) );
return 0;
case CG_R_DRAWSTRETCHPIC:
re.DrawStretchPic( VMF(1), VMF(2), VMF(3), VMF(4), VMF(5), VMF(6), VMF(7), VMF(8), args[9] );
return 0;
case CG_R_MODELBOUNDS:
re.ModelBounds( args[1], VMA(2), VMA(3) );
return 0;
case CG_R_LERPTAG:
return re.LerpTag( VMA(1), args[2], args[3], args[4], VMF(5), VMA(6) );
case CG_GETGLCONFIG:
CL_GetGlconfig( VMA(1) );
return 0;
case CG_GETGAMESTATE:
CL_GetGameState( VMA(1) );
return 0;
case CG_GETCURRENTSNAPSHOTNUMBER:
CL_GetCurrentSnapshotNumber( VMA(1), VMA(2) );
return 0;
case CG_GETSNAPSHOT:
return CL_GetSnapshot( args[1], VMA(2) );
case CG_GETSERVERCOMMAND:
return CL_GetServerCommand( args[1] );
case CG_GETCURRENTCMDNUMBER:
return CL_GetCurrentCmdNumber();
case CG_GETUSERCMD:
return CL_GetUserCmd( args[1], VMA(2) );
case CG_SETUSERCMDVALUE:
CL_SetUserCmdValue( args[1], VMF(2) );
return 0;
case CG_MEMORY_REMAINING:
return Hunk_MemoryRemaining();
case CG_KEY_ISDOWN:
return Key_IsDown( args[1] );
case CG_KEY_GETCATCHER:
return Key_GetCatcher();
case CG_KEY_SETCATCHER:
// Don't allow the cgame module to close the console
Key_SetCatcher( args[1] | ( Key_GetCatcher( ) & KEYCATCH_CONSOLE ) );
return 0;
case CG_KEY_GETKEY:
return Key_GetKey( VMA(1) );
case CG_MEMSET:
Com_Memset( VMA(1), args[2], args[3] );
return 0;
case CG_MEMCPY:
Com_Memcpy( VMA(1), VMA(2), args[3] );
return 0;
case CG_STRNCPY:
strncpy( VMA(1), VMA(2), args[3] );
return args[1];
case CG_SIN:
return FloatAsInt( sin( VMF(1) ) );
case CG_COS:
return FloatAsInt( cos( VMF(1) ) );
case CG_ATAN2:
return FloatAsInt( atan2( VMF(1), VMF(2) ) );
case CG_SQRT:
return FloatAsInt( sqrt( VMF(1) ) );
case CG_FLOOR:
return FloatAsInt( floor( VMF(1) ) );
case CG_CEIL:
return FloatAsInt( ceil( VMF(1) ) );
case CG_ACOS:
return FloatAsInt( Q_acos( VMF(1) ) );
case CG_PC_ADD_GLOBAL_DEFINE:
return botlib_export->PC_AddGlobalDefine( VMA(1) );
case CG_PC_LOAD_SOURCE:
return botlib_export->PC_LoadSourceHandle( VMA(1) );
case CG_PC_FREE_SOURCE:
return botlib_export->PC_FreeSourceHandle( args[1] );
case CG_PC_READ_TOKEN:
return botlib_export->PC_ReadTokenHandle( args[1], VMA(2) );
case CG_PC_SOURCE_FILE_AND_LINE:
return botlib_export->PC_SourceFileAndLine( args[1], VMA(2), VMA(3) );
case CG_S_STOPBACKGROUNDTRACK:
S_StopBackgroundTrack();
return 0;
case CG_REAL_TIME:
return Com_RealTime( VMA(1) );
case CG_SNAPVECTOR:
Sys_SnapVector( VMA(1) );
return 0;
case CG_CIN_PLAYCINEMATIC:
return CIN_PlayCinematic(VMA(1), args[2], args[3], args[4], args[5], args[6]);
case CG_CIN_STOPCINEMATIC:
return CIN_StopCinematic(args[1]);
case CG_CIN_RUNCINEMATIC:
return CIN_RunCinematic(args[1]);
case CG_CIN_DRAWCINEMATIC:
CIN_DrawCinematic(args[1]);
return 0;
case CG_CIN_SETEXTENTS:
CIN_SetExtents(args[1], args[2], args[3], args[4], args[5]);
return 0;
case CG_R_REMAP_SHADER:
re.RemapShader( VMA(1), VMA(2), VMA(3) );
return 0;
/*
case CG_LOADCAMERA:
return loadCamera(VMA(1));
case CG_STARTCAMERA:
startCamera(args[1]);
return 0;
case CG_GETCAMERAINFO:
return getCameraInfo(args[1], VMA(2), VMA(3));
*/
case CG_GET_ENTITY_TOKEN:
return re.GetEntityToken( VMA(1), args[2] );
case CG_R_INPVS:
return re.inPVS( VMA(1), VMA(2) );
default:
assert(0);
Com_Error( ERR_DROP, "Bad cgame system trap: %ld", (long int) args[0] );
}
return 0;
}
/**
* @brief The ui module is making a system call
* @param[in] args
* @return
*/
intptr_t CL_UISystemCalls(intptr_t *args)
{
switch (args[0])
{
case UI_ERROR:
Com_Error(ERR_DROP, "%s", (char *)VMA(1));
case UI_PRINT:
Com_Printf("%s", (char *)VMA(1));
return 0;
case UI_MILLISECONDS:
return Sys_Milliseconds();
case UI_CVAR_REGISTER:
Cvar_Register(VMA(1), VMA(2), VMA(3), args[4]);
return 0;
case UI_CVAR_UPDATE:
Cvar_Update(VMA(1));
return 0;
case UI_CVAR_SET:
Cvar_SetSafe(VMA(1), VMA(2));
return 0;
case UI_CVAR_VARIABLEVALUE:
return FloatAsInt(Cvar_VariableValue(VMA(1)));
case UI_CVAR_VARIABLESTRINGBUFFER:
Cvar_VariableStringBuffer(VMA(1), VMA(2), args[3]);
return 0;
case UI_CVAR_LATCHEDVARIABLESTRINGBUFFER:
Cvar_LatchedVariableStringBuffer(VMA(1), VMA(2), args[3]);
return 0;
case UI_CVAR_SETVALUE:
Cvar_SetValueSafe(VMA(1), VMF(2));
return 0;
case UI_CVAR_RESET:
Cvar_Reset(VMA(1));
return 0;
case UI_CVAR_CREATE:
Cvar_Register(NULL, VMA(1), VMA(2), args[3]);
return 0;
case UI_CVAR_INFOSTRINGBUFFER:
Cvar_InfoStringBuffer(args[1], VMA(2), args[3]);
return 0;
case UI_ARGC:
return Cmd_Argc();
case UI_ARGV:
Cmd_ArgvBuffer(args[1], VMA(2), args[3]);
return 0;
case UI_CMD_EXECUTETEXT:
if (args[1] == EXEC_NOW
&& (!strncmp(VMA(2), "snd_restart", 11)
|| !strncmp(VMA(2), "vid_restart", 11)
|| !strncmp(VMA(2), "quit", 5)))
{
Com_Printf(S_COLOR_YELLOW "turning EXEC_NOW '%.11s' into EXEC_INSERT\n", (const char *)VMA(2));
args[1] = EXEC_INSERT;
}
Cbuf_ExecuteText(args[1], VMA(2));
return 0;
case UI_ADDCOMMAND:
Cmd_AddCommand(VMA(1));
return 0;
case UI_FS_FOPENFILE:
return FS_FOpenFileByMode(VMA(1), VMA(2), (fsMode_t)args[3]);
case UI_FS_READ:
FS_Read(VMA(1), args[2], args[3]);
return 0;
case UI_FS_WRITE:
FS_Write(VMA(1), args[2], args[3]);
return 0;
case UI_FS_FCLOSEFILE:
FS_FCloseFile(args[1]);
return 0;
case UI_FS_DELETEFILE:
return FS_Delete(VMA(1));
case UI_FS_GETFILELIST:
return FS_GetFileList(VMA(1), VMA(2), VMA(3), args[4]);
case UI_R_REGISTERMODEL:
return re.RegisterModel(VMA(1));
case UI_R_REGISTERSKIN:
return re.RegisterSkin(VMA(1));
case UI_R_REGISTERSHADERNOMIP:
return re.RegisterShaderNoMip(VMA(1));
case UI_R_CLEARSCENE:
re.ClearScene();
return 0;
case UI_R_ADDREFENTITYTOSCENE:
re.AddRefEntityToScene(VMA(1));
return 0;
case UI_R_ADDPOLYTOSCENE:
re.AddPolyToScene(args[1], args[2], VMA(3));
return 0;
case UI_R_ADDPOLYSTOSCENE:
re.AddPolysToScene(args[1], args[2], VMA(3), args[4]);
return 0;
case UI_R_ADDLIGHTTOSCENE:
// new dlight code
re.AddLightToScene(VMA(1), VMF(2), VMF(3), VMF(4), VMF(5), VMF(6), args[7], args[8]);
return 0;
case UI_R_ADDCORONATOSCENE:
re.AddCoronaToScene(VMA(1), VMF(2), VMF(3), VMF(4), VMF(5), args[6], (qboolean)args[7]);
return 0;
case UI_R_RENDERSCENE:
re.RenderScene(VMA(1));
return 0;
case UI_R_SETCOLOR:
re.SetColor(VMA(1));
return 0;
case UI_R_DRAW2DPOLYS:
re.Add2dPolys(VMA(1), args[2], args[3]);
return 0;
case UI_R_DRAWSTRETCHPIC:
re.DrawStretchPic(VMF(1), VMF(2), VMF(3), VMF(4), VMF(5), VMF(6), VMF(7), VMF(8), args[9]);
return 0;
case UI_R_DRAWROTATEDPIC:
re.DrawRotatedPic(VMF(1), VMF(2), VMF(3), VMF(4), VMF(5), VMF(6), VMF(7), VMF(8), args[9], VMF(10));
return 0;
case UI_R_MODELBOUNDS:
re.ModelBounds(args[1], VMA(2), VMA(3));
return 0;
case UI_UPDATESCREEN:
SCR_UpdateScreen();
return 0;
case UI_CM_LERPTAG:
return re.LerpTag(VMA(1), VMA(2), VMA(3), args[4]);
case UI_S_REGISTERSOUND:
return S_RegisterSound(VMA(1), (qboolean)args[2]);
case UI_S_STARTLOCALSOUND:
S_StartLocalSound(args[1], args[2], args[3]);
return 0;
case UI_S_FADESTREAMINGSOUND:
S_FadeStreamingSound(VMF(1), args[2], args[3]);
return 0;
case UI_S_FADEALLSOUNDS:
S_FadeAllSounds(VMF(1), args[2], (qboolean)args[3]);
return 0;
case UI_KEY_KEYNUMTOSTRINGBUF:
Key_KeynumToStringBuf(args[1], VMA(2), args[3]);
return 0;
case UI_KEY_GETBINDINGBUF:
Key_GetBindingBuf(args[1], VMA(2), args[3]);
return 0;
case UI_KEY_SETBINDING:
Key_SetBinding(args[1], VMA(2));
return 0;
case UI_KEY_BINDINGTOKEYS:
Key_GetBindingByString(VMA(1), VMA(2), VMA(3));
return 0;
case UI_KEY_ISDOWN:
return Key_IsDown(args[1]);
case UI_KEY_GETOVERSTRIKEMODE:
return Key_GetOverstrikeMode();
case UI_KEY_SETOVERSTRIKEMODE:
Key_SetOverstrikeMode((qboolean)args[1]);
return 0;
case UI_KEY_CLEARSTATES:
Key_ClearStates();
return 0;
case UI_KEY_GETCATCHER:
return Key_GetCatcher();
case UI_KEY_SETCATCHER:
// Don't allow the ui module to close the console
Key_SetCatcher(args[1] | (Key_GetCatcher() & KEYCATCH_CONSOLE));
return 0;
case UI_GETCLIPBOARDDATA:
GetClipboardData(VMA(1), args[2]);
return 0;
case UI_GETCLIENTSTATE:
GetClientState(VMA(1));
return 0;
case UI_GETGLCONFIG:
CL_GetGlconfig(VMA(1));
return 0;
case UI_GETCONFIGSTRING:
return GetConfigString(args[1], VMA(2), args[3]);
case UI_LAN_LOADCACHEDSERVERS:
LAN_LoadCachedServers();
return 0;
case UI_LAN_SAVECACHEDSERVERS:
//LAN_SaveServersToFile(); // now done on add/remove fav server so we no longer save LAN favs on shutdown & restart
return 0;
case UI_LAN_ADDSERVER:
return LAN_AddServer(args[1], VMA(2), VMA(3));
case UI_LAN_REMOVESERVER:
LAN_RemoveServer(args[1], VMA(2));
return 0;
case UI_LAN_GETPINGQUEUECOUNT:
return LAN_GetPingQueueCount();
case UI_LAN_CLEARPING:
LAN_ClearPing(args[1]);
return 0;
case UI_LAN_GETPING:
LAN_GetPing(args[1], VMA(2), args[3], VMA(4));
return 0;
case UI_LAN_GETPINGINFO:
LAN_GetPingInfo(args[1], VMA(2), args[3]);
return 0;
case UI_LAN_GETSERVERCOUNT:
return LAN_GetServerCount(args[1]);
case UI_LAN_GETSERVERADDRESSSTRING:
LAN_GetServerAddressString(args[1], args[2], VMA(3), args[4]);
return 0;
case UI_LAN_GETSERVERINFO:
LAN_GetServerInfo(args[1], args[2], VMA(3), args[4]);
return 0;
case UI_LAN_GETSERVERPING:
return LAN_GetServerPing(args[1], args[2]);
case UI_LAN_MARKSERVERVISIBLE:
LAN_MarkServerVisible(args[1], args[2], (qboolean)args[3]);
return 0;
case UI_LAN_SERVERISVISIBLE:
return LAN_ServerIsVisible(args[1], args[2]);
case UI_LAN_UPDATEVISIBLEPINGS:
return LAN_UpdateVisiblePings(args[1]);
case UI_LAN_RESETPINGS:
LAN_ResetPings(args[1]);
return 0;
case UI_LAN_SERVERSTATUS:
return LAN_GetServerStatus(VMA(1), VMA(2), args[3]);
case UI_LAN_SERVERISINFAVORITELIST:
return LAN_ServerIsInFavoriteList(args[1], args[2]);
case UI_LAN_COMPARESERVERS:
return LAN_CompareServers(args[1], args[2], args[3], args[4], args[5]);
case UI_MEMORY_REMAINING:
return Hunk_MemoryRemaining();
case UI_R_REGISTERFONT:
re.RegisterFont(VMA(1), args[2], VMA(3), (args[4] == qtrue));
return 0;
case UI_MEMSET:
return (intptr_t)memset(VMA(1), args[2], args[3]);
case UI_MEMCPY:
return (intptr_t)memcpy(VMA(1), VMA(2), args[3]);
case UI_STRNCPY:
return (intptr_t)strncpy(VMA(1), VMA(2), args[3]);
case UI_SIN:
return FloatAsInt(sin(VMF(1)));
case UI_COS:
return FloatAsInt(cos(VMF(1)));
case UI_ATAN2:
return FloatAsInt(atan2(VMF(1), VMF(2)));
case UI_SQRT:
return FloatAsInt(sqrt(VMF(1)));
case UI_FLOOR:
return FloatAsInt(floor(VMF(1)));
case UI_CEIL:
return FloatAsInt(ceil(VMF(1)));
case UI_PC_ADD_GLOBAL_DEFINE:
return botlib_export->PC_AddGlobalDefine(VMA(1));
case UI_PC_REMOVE_ALL_GLOBAL_DEFINES:
botlib_export->PC_RemoveAllGlobalDefines();
return 0;
case UI_PC_LOAD_SOURCE:
return botlib_export->PC_LoadSourceHandle(VMA(1));
case UI_PC_FREE_SOURCE:
return botlib_export->PC_FreeSourceHandle(args[1]);
case UI_PC_READ_TOKEN:
return botlib_export->PC_ReadTokenHandle(args[1], VMA(2));
case UI_PC_SOURCE_FILE_AND_LINE:
return botlib_export->PC_SourceFileAndLine(args[1], VMA(2), VMA(3));
case UI_PC_UNREAD_TOKEN:
botlib_export->PC_UnreadLastTokenHandle(args[1]);
return 0;
case UI_S_STOPBACKGROUNDTRACK:
S_StopBackgroundTrack();
return 0;
case UI_S_STARTBACKGROUNDTRACK:
S_StartBackgroundTrack(VMA(1), VMA(2), args[3]); // added fadeup time
return 0;
case UI_REAL_TIME:
return Com_RealTime(VMA(1));
case UI_CIN_PLAYCINEMATIC:
Com_DPrintf("UI_CIN_PlayCinematic\n");
return CIN_PlayCinematic(VMA(1), args[2], args[3], args[4], args[5], args[6]);
case UI_CIN_STOPCINEMATIC:
return CIN_StopCinematic(args[1]);
case UI_CIN_RUNCINEMATIC:
return CIN_RunCinematic(args[1]);
case UI_CIN_DRAWCINEMATIC:
CIN_DrawCinematic(args[1]);
return 0;
case UI_CIN_SETEXTENTS:
CIN_SetExtents(args[1], args[2], args[3], args[4], args[5]);
return 0;
case UI_R_REMAP_SHADER:
re.RemapShader(VMA(1), VMA(2), VMA(3));
return 0;
case UI_CL_GETLIMBOSTRING:
return CL_GetLimboString(args[1], VMA(2));
case UI_CL_TRANSLATE_STRING:
CL_TranslateStringMod(VMA(1), VMA(2));
return 0;
case UI_CHECKAUTOUPDATE:
CL_RequestMasterData(qfalse);
return 0;
case UI_GET_AUTOUPDATE:
Com_GetAutoUpdate();
return 0;
case UI_OPENURL:
CL_OpenURL((const char *)VMA(1));
return 0;
case UI_GETHUNKDATA:
Com_GetHunkInfo(VMA(1), VMA(2));
return 0;
// obsolete
case UI_SET_PBCLSTATUS:
case UI_SET_PBSVSTATUS:
return 0;
default:
Com_Error(ERR_DROP, "Bad UI system trap: %ld", (long int) args[0]);
}
}
/*
=================
S_CodecUtilClose
=================
*/
void S_CodecUtilClose(snd_stream_t *stream)
{
FS_FCloseFile(stream->file);
Z_Free(stream);
}
/*
==================
SV_WriteDownloadToClient
Check to see if the client wants a file, open it if needed and start pumping the client
Fill up msg with data
==================
*/
void SV_WriteDownloadToClient(client_t *cl, msg_t *msg)
{
int curindex;
int rate;
int blockspersnap;
int unreferenced = 1;
char errorMessage[1024];
char pakbuf[MAX_QPATH], *pakptr;
int numRefPaks;
if (!*cl->downloadName)
return; // Nothing being downloaded
if(!cl->download)
{
qboolean idPack = qfalse;
qboolean missionPack = qfalse;
// Chop off filename extension.
Com_sprintf(pakbuf, sizeof(pakbuf), "%s", cl->downloadName);
pakptr = strrchr(pakbuf, '.');
if(pakptr)
{
*pakptr = '\0';
// Check for pk3 filename extension
if(!Q_stricmp(pakptr + 1, "pk3"))
{
const char *referencedPaks = FS_ReferencedPakNames();
// Check whether the file appears in the list of referenced
// paks to prevent downloading of arbitrary files.
Cmd_TokenizeStringIgnoreQuotes(referencedPaks);
numRefPaks = Cmd_Argc();
for(curindex = 0; curindex < numRefPaks; curindex++)
{
if(!FS_FilenameCompare(Cmd_Argv(curindex), pakbuf))
{
unreferenced = 0;
// now that we know the file is referenced,
// check whether it's legal to download it.
missionPack = FS_idPak(pakbuf, "missionpack");
idPack = missionPack;
idPack = (qboolean)(idPack || FS_idPak(pakbuf, BASEGAME));
break;
}
}
}
}
cl->download = 0;
// We open the file here
if ( !sv_allowDownload->integer ||
idPack || unreferenced ||
( cl->downloadSize = FS_SV_FOpenFileRead( cl->downloadName, &cl->download ) ) < 0 ) {
// cannot auto-download file
if(unreferenced)
{
Com_Printf("clientDownload: %d : \"%s\" is not referenced and cannot be downloaded.\n", (int) (cl - svs.clients), cl->downloadName);
Com_sprintf(errorMessage, sizeof(errorMessage), "File \"%s\" is not referenced and cannot be downloaded.", cl->downloadName);
}
else if (idPack) {
Com_Printf("clientDownload: %d : \"%s\" cannot download id pk3 files\n", (int) (cl - svs.clients), cl->downloadName);
if(missionPack)
{
Com_sprintf(errorMessage, sizeof(errorMessage), "Cannot autodownload Team Arena file \"%s\"\n"
"The Team Arena mission pack can be found in your local game store.", cl->downloadName);
}
else
{
Com_sprintf(errorMessage, sizeof(errorMessage), "Cannot autodownload id pk3 file \"%s\"", cl->downloadName);
}
}
else if ( !sv_allowDownload->integer ) {
Com_Printf("clientDownload: %d : \"%s\" download disabled\n", (int) (cl - svs.clients), cl->downloadName);
if (sv_pure->integer) {
Com_sprintf(errorMessage, sizeof(errorMessage), "Could not download \"%s\" because autodownloading is disabled on the server.\n\n"
"You will need to get this file elsewhere before you "
"can connect to this pure server.\n", cl->downloadName);
} else {
Com_sprintf(errorMessage, sizeof(errorMessage), "Could not download \"%s\" because autodownloading is disabled on the server.\n\n"
"The server you are connecting to is not a pure server, "
"set autodownload to No in your settings and you might be "
"able to join the game anyway.\n", cl->downloadName);
}
} else {
// NOTE TTimo this is NOT supposed to happen unless bug in our filesystem scheme?
// if the pk3 is referenced, it must have been found somewhere in the filesystem
Com_Printf("clientDownload: %d : \"%s\" file not found on server\n", (int) (cl - svs.clients), cl->downloadName);
Com_sprintf(errorMessage, sizeof(errorMessage), "File \"%s\" not found on server for autodownloading.\n", cl->downloadName);
}
MSG_WriteByte( msg, svc_download );
MSG_WriteShort( msg, 0 ); // client is expecting block zero
MSG_WriteLong( msg, -1 ); // illegal file size
MSG_WriteString( msg, errorMessage );
*cl->downloadName = 0;
if(cl->download)
FS_FCloseFile(cl->download);
return;
}
Com_Printf( "clientDownload: %d : beginning \"%s\"\n", (int) (cl - svs.clients), cl->downloadName );
// Init
cl->downloadCurrentBlock = cl->downloadClientBlock = cl->downloadXmitBlock = 0;
cl->downloadCount = 0;
cl->downloadEOF = qfalse;
}
// Perform any reads that we need to
while (cl->downloadCurrentBlock - cl->downloadClientBlock < MAX_DOWNLOAD_WINDOW &&
cl->downloadSize != cl->downloadCount) {
curindex = (cl->downloadCurrentBlock % MAX_DOWNLOAD_WINDOW);
if (!cl->downloadBlocks[curindex])
cl->downloadBlocks[curindex] = (unsigned char *)Z_Malloc( MAX_DOWNLOAD_BLKSIZE, TAG_DOWNLOAD, qtrue );
cl->downloadBlockSize[curindex] = FS_Read( cl->downloadBlocks[curindex], MAX_DOWNLOAD_BLKSIZE, cl->download );
if (cl->downloadBlockSize[curindex] < 0) {
// EOF right now
cl->downloadCount = cl->downloadSize;
break;
}
cl->downloadCount += cl->downloadBlockSize[curindex];
// Load in next block
cl->downloadCurrentBlock++;
}
// Check to see if we have eof condition and add the EOF block
if (cl->downloadCount == cl->downloadSize &&
!cl->downloadEOF &&
cl->downloadCurrentBlock - cl->downloadClientBlock < MAX_DOWNLOAD_WINDOW) {
cl->downloadBlockSize[cl->downloadCurrentBlock % MAX_DOWNLOAD_WINDOW] = 0;
cl->downloadCurrentBlock++;
cl->downloadEOF = qtrue; // We have added the EOF block
}
// Loop up to window size times based on how many blocks we can fit in the
// client snapMsec and rate
// based on the rate, how many bytes can we fit in the snapMsec time of the client
// normal rate / snapshotMsec calculation
rate = cl->rate;
if ( sv_maxRate->integer ) {
if ( sv_maxRate->integer < 1000 ) {
Cvar_Set( "sv_MaxRate", "1000" );
}
if ( sv_maxRate->integer < rate ) {
rate = sv_maxRate->integer;
}
}
if (!rate) {
blockspersnap = 1;
} else {
blockspersnap = ( (rate * cl->snapshotMsec) / 1000 + MAX_DOWNLOAD_BLKSIZE ) /
MAX_DOWNLOAD_BLKSIZE;
}
if (blockspersnap < 0)
blockspersnap = 1;
while (blockspersnap--) {
// Write out the next section of the file, if we have already reached our window,
// automatically start retransmitting
if (cl->downloadClientBlock == cl->downloadCurrentBlock)
return; // Nothing to transmit
if (cl->downloadXmitBlock == cl->downloadCurrentBlock) {
// We have transmitted the complete window, should we start resending?
//FIXME: This uses a hardcoded one second timeout for lost blocks
//the timeout should be based on client rate somehow
if (svs.time - cl->downloadSendTime > 1000)
cl->downloadXmitBlock = cl->downloadClientBlock;
else
return;
}
// Send current block
curindex = (cl->downloadXmitBlock % MAX_DOWNLOAD_WINDOW);
MSG_WriteByte( msg, svc_download );
MSG_WriteShort( msg, cl->downloadXmitBlock );
// block zero is special, contains file size
if ( cl->downloadXmitBlock == 0 )
MSG_WriteLong( msg, cl->downloadSize );
MSG_WriteShort( msg, cl->downloadBlockSize[curindex] );
// Write the block
if ( cl->downloadBlockSize[curindex] ) {
MSG_WriteData( msg, cl->downloadBlocks[curindex], cl->downloadBlockSize[curindex] );
}
Com_DPrintf( "clientDownload: %d : writing block %d\n", (int) (cl - svs.clients), cl->downloadXmitBlock );
// Move on to the next block
// It will get sent with next snap shot. The rate will keep us in line.
cl->downloadXmitBlock++;
cl->downloadSendTime = svs.time;
}
}
/*
=====================
CL_ParseDownload
A download message has been received from the server
=====================
*/
void CL_ParseDownload( msg_t *msg )
{
int size;
unsigned char data[ MAX_MSGLEN ];
int block;
if ( !*cls.downloadTempName )
{
Com_Printf( "Server sending download, but no download was requested\n" );
// Eat the packet anyway
block = MSG_ReadShort( msg );
if (block == -1) {
MSG_ReadString( msg );
MSG_ReadLong( msg );
MSG_ReadLong( msg );
} else if (block != 0) {
size = MSG_ReadShort( msg );
if ( size < 0 || size > (int) sizeof( data ) )
{
Com_Error( ERR_DROP, "CL_ParseDownload: Invalid size %d for download chunk.", size );
}
MSG_ReadData( msg, data, size );
}
CL_AddReliableCommand( "stopdl" );
return;
}
// read the data
block = MSG_ReadShort( msg );
// TTimo - www dl
// if we haven't acked the download redirect yet
if ( block == -1 )
{
if ( !clc.bWWWDl )
{
// server is sending us a www download
Q_strncpyz( cls.originalDownloadName, cls.downloadName, sizeof( cls.originalDownloadName ) );
Q_strncpyz( cls.downloadName, MSG_ReadString( msg ), sizeof( cls.downloadName ) );
clc.downloadSize = MSG_ReadLong( msg );
clc.downloadFlags = MSG_ReadLong( msg );
downloadLogger.Debug("Server sent us a new WWW DL '%s', size %i, flags %i",
cls.downloadName, clc.downloadSize, clc.downloadFlags);
Cvar_SetValue( "cl_downloadSize", clc.downloadSize );
clc.bWWWDl = true; // activate wwwdl client loop
CL_AddReliableCommand( "wwwdl ack" );
cls.state = CA_DOWNLOADING;
// make sure the server is not trying to redirect us again on a bad checksum
if ( strstr( clc.badChecksumList, va( "@%s", cls.originalDownloadName ) ) )
{
Com_Printf( "refusing redirect to %s by server (bad checksum)\n", cls.downloadName );
CL_AddReliableCommand( "wwwdl fail" );
clc.bWWWDlAborting = true;
return;
}
if ( !DL_BeginDownload( cls.downloadTempName, cls.downloadName ) )
{
// setting bWWWDl to false after sending the wwwdl fail doesn't work
// not sure why, but I suspect we have to eat all remaining block -1 that the server has sent us
// still leave a flag so that CL_WWWDownload is inactive
// we count on server sending us a gamestate to start up clean again
CL_AddReliableCommand( "wwwdl fail" );
clc.bWWWDlAborting = true;
Com_Printf( "Failed to initialize download for '%s'\n", cls.downloadName );
}
// Check for a disconnected download
// we'll let the server disconnect us when it gets the bbl8r message
if ( clc.downloadFlags & ( 1 << DL_FLAG_DISCON ) )
{
CL_AddReliableCommand( "wwwdl bbl8r" );
cls.bWWWDlDisconnected = true;
}
return;
}
else
{
// server keeps sending that message till we ack it, eat and ignore
//MSG_ReadLong( msg );
MSG_ReadString( msg );
MSG_ReadLong( msg );
MSG_ReadLong( msg );
return;
}
}
if ( !block )
{
// block zero is special, contains file size
clc.downloadSize = MSG_ReadLong( msg );
downloadLogger.Debug("Starting new direct download of size %i for '%s'", clc.downloadSize, cls.downloadTempName);
Cvar_SetValue( "cl_downloadSize", clc.downloadSize );
if ( clc.downloadSize < 0 )
{
Com_Error( ERR_DROP, "%s", MSG_ReadString( msg ) );
}
}
size = MSG_ReadShort( msg );
if ( size < 0 || size > (int) sizeof( data ) )
{
Com_Error( ERR_DROP, "CL_ParseDownload: Invalid size %d for download chunk.", size );
}
downloadLogger.Debug("Received block of size %i", size);
MSG_ReadData( msg, data, size );
if ( clc.downloadBlock != block )
{
downloadLogger.Debug( "CL_ParseDownload: Expected block %i, got %i", clc.downloadBlock, block );
return;
}
// open the file if not opened yet
if ( !clc.download )
{
clc.download = FS_SV_FOpenFileWrite( cls.downloadTempName );
if ( !clc.download )
{
Com_Printf( "Could not create %s\n", cls.downloadTempName );
CL_AddReliableCommand( "stopdl" );
CL_NextDownload();
return;
}
}
if ( size )
{
FS_Write( data, size, clc.download );
}
CL_AddReliableCommand( va( "nextdl %d", clc.downloadBlock ) );
clc.downloadBlock++;
clc.downloadCount += size;
// So UI gets access to it
Cvar_SetValue( "cl_downloadCount", clc.downloadCount );
if ( !size )
{
downloadLogger.Debug("Received EOF, closing '%s'", cls.downloadTempName);
// A zero length block means EOF
if ( clc.download )
{
FS_FCloseFile( clc.download );
clc.download = 0;
// rename the file
FS_SV_Rename( cls.downloadTempName, cls.downloadName );
}
*cls.downloadTempName = *cls.downloadName = 0;
Cvar_Set( "cl_downloadName", "" );
// send intentions now
// We need this because without it, we would hold the last nextdl and then start
// loading right away. If we take a while to load, the server is happily trying
// to send us that last block over and over.
// Write it twice to help make sure we acknowledge the download
CL_WritePacket();
CL_WritePacket();
// get another file if needed
CL_NextDownload();
}
}
/**
* @brief This updates the "hunkusage.dat" file with the current map and it's hunk usage count
*
* This is used for level loading, so we can show a percentage bar dependant on the amount
* of hunk memory allocated so far
*
* This will be slightly inaccurate if some settings like sound quality are changed, but these
* things should only account for a small variation (hopefully)
*/
void CL_UpdateLevelHunkUsage(void)
{
int handle;
const char *memlistfile = "hunkusage.dat";
char outstr[256];
int len, memusage;
memusage = Cvar_VariableIntegerValue("com_hunkused");
len = FS_FOpenFileByMode(memlistfile, &handle, FS_READ);
if (len >= 0) // the file exists, so read it in, strip out the current entry for this map, and save it out, so we can append the new value
{
char *buftrav, *outbuftrav;
char *outbuf;
char *token;
char *buf;
buf = (char *)Z_Malloc(len + 1);
Com_Memset(buf, 0, len + 1);
outbuf = (char *)Z_Malloc(len + 1);
Com_Memset(outbuf, 0, len + 1);
(void) FS_Read((void *)buf, len, handle);
FS_FCloseFile(handle);
// now parse the file, filtering out the current map
buftrav = buf;
outbuftrav = outbuf;
outbuftrav[0] = '\0';
COM_BeginParseSession("CL_UpdateLevelHunkUsage");
while ((token = COM_Parse(&buftrav)) != NULL && token[0])
{
if (!Q_stricmp(token, cl.mapname))
{
// found a match
token = COM_Parse(&buftrav); // read the size
if (token && token[0])
{
if (atoi(token) == memusage) // if it is the same, abort this process
{
Z_Free(buf);
Z_Free(outbuf);
return;
}
}
}
else // send it to the outbuf
{
Q_strcat(outbuftrav, len + 1, token);
Q_strcat(outbuftrav, len + 1, " ");
token = COM_Parse(&buftrav); // read the size
if (token && token[0])
{
Q_strcat(outbuftrav, len + 1, token);
Q_strcat(outbuftrav, len + 1, "\n");
}
else
{
//Com_Error does memory clean up
//Z_Free(buf);
//Z_Free(outbuf);
Com_Error(ERR_DROP, "hunkusage.dat file is corrupt");
}
}
}
handle = FS_FOpenFileWrite(memlistfile);
if (handle < 0)
{
Com_Error(ERR_DROP, "cannot create %s", memlistfile);
}
// input file is parsed, now output to the new file
len = strlen(outbuf);
if (FS_Write((void *)outbuf, len, handle) != len)
{
Com_Error(ERR_DROP, "cannot write to %s", memlistfile);
}
FS_FCloseFile(handle);
Z_Free(buf);
Z_Free(outbuf);
}
// now append the current map to the current file
(void) FS_FOpenFileByMode(memlistfile, &handle, FS_APPEND);
if (handle < 0)
{
Com_Error(ERR_DROP, "cannot write to hunkusage.dat, check disk full");
}
Com_sprintf(outstr, sizeof(outstr), "%s %i\n", cl.mapname, memusage);
(void) FS_Write(outstr, strlen(outstr), handle);
FS_FCloseFile(handle);
// now just open it and close it, so it gets copied to the pak dir
len = FS_FOpenFileByMode(memlistfile, &handle, FS_READ);
if (len >= 0)
{
FS_FCloseFile(handle);
}
}
/*
======================
S_StartBackgroundTrack
======================
*/
void S_StartBackgroundTrack( const char *intro, const char *loop )
{
int len;
char dump[16];
char name[MAX_QPATH];
if ( !intro )
{
intro = "";
}
if ( !loop || !loop[0] )
{
loop = intro;
}
Com_DPrintf( "S_StartBackgroundTrack( %s, %s )\n", intro, loop );
Q_strncpyz( name, intro, sizeof( name ) - 4 );
COM_DefaultExtension( name, sizeof( name ), ".wav" );
if ( !intro[0] )
{
return;
}
Q_strncpyz( s_backgroundLoop, loop, sizeof( s_backgroundLoop ) );
// close the background track, but DON'T reset s_rawend
// if restarting the same back ground track
if ( s_backgroundFile )
{
Sys_EndStreamedFile( s_backgroundFile );
FS_FCloseFile( s_backgroundFile );
s_backgroundFile = 0;
}
//
// open up a wav file and get all the info
//
FS_FOpenFileRead( name, &s_backgroundFile, qtrue );
if ( !s_backgroundFile )
{
Com_Printf( S_COLOR_YELLOW "WARNING: couldn't open music file %s\n", name );
return;
}
// skip the riff wav header
FS_Read(dump, 12, s_backgroundFile);
if ( !S_FindWavChunk( s_backgroundFile, "fmt " ) )
{
Com_Printf( "No fmt chunk in %s\n", name );
FS_FCloseFile( s_backgroundFile );
s_backgroundFile = 0;
return;
}
// save name for soundinfo
s_backgroundInfo.format = FGetLittleShort( s_backgroundFile );
s_backgroundInfo.channels = FGetLittleShort( s_backgroundFile );
s_backgroundInfo.rate = FGetLittleLong( s_backgroundFile );
FGetLittleLong( s_backgroundFile );
FGetLittleShort( s_backgroundFile );
s_backgroundInfo.width = FGetLittleShort( s_backgroundFile ) / 8;
if ( s_backgroundInfo.format != WAV_FORMAT_PCM )
{
FS_FCloseFile( s_backgroundFile );
s_backgroundFile = 0;
Com_Printf("Not a microsoft PCM format wav: %s\n", name);
return;
}
if ( s_backgroundInfo.channels != 2 || s_backgroundInfo.rate != 22050 )
{
Com_Printf(S_COLOR_YELLOW "WARNING: music file %s is not 22k stereo\n", name );
}
if ( ( len = S_FindWavChunk( s_backgroundFile, "data" ) ) == 0 )
{
FS_FCloseFile( s_backgroundFile );
s_backgroundFile = 0;
Com_Printf("No data chunk in %s\n", name);
return;
}
s_backgroundInfo.samples = len / (s_backgroundInfo.width * s_backgroundInfo.channels);
s_backgroundSamples = s_backgroundInfo.samples;
//
// start the background streaming
//
Sys_BeginStreamedFile( s_backgroundFile, 0x10000 );
}
/*
======================
S_UpdateBackgroundTrack
======================
*/
void S_UpdateBackgroundTrack( void )
{
int bufferSamples;
int fileSamples;
byte raw[30000]; // just enough to fit in a mac stack frame
int fileBytes;
int r;
static float musicVolume = 0.5f;
if ( !s_backgroundFile )
{
return;
}
// graeme see if this is OK
musicVolume = (musicVolume + (s_musicVolume->value * 2))/4.0f;
// don't bother playing anything if musicvolume is 0
if ( musicVolume <= 0 )
{
return;
}
// see how many samples should be copied into the raw buffer
if ( s_rawend < s_soundtime )
{
s_rawend = s_soundtime;
}
while ( s_rawend < s_soundtime + MAX_RAW_SAMPLES )
{
bufferSamples = MAX_RAW_SAMPLES - (s_rawend - s_soundtime);
// decide how much data needs to be read from the file
fileSamples = bufferSamples * s_backgroundInfo.rate / dma.speed;
// don't try and read past the end of the file
if ( fileSamples > s_backgroundSamples )
{
fileSamples = s_backgroundSamples;
}
// our max buffer size
fileBytes = fileSamples * (s_backgroundInfo.width * s_backgroundInfo.channels);
if ( fileBytes > sizeof(raw) )
{
fileBytes = sizeof(raw);
fileSamples = fileBytes / (s_backgroundInfo.width * s_backgroundInfo.channels);
}
r = Sys_StreamedRead( raw, 1, fileBytes, s_backgroundFile );
if ( r != fileBytes )
{
Com_Printf("StreamedRead failure on music track\n");
S_StopBackgroundTrack();
return;
}
// byte swap if needed
S_ByteSwapRawSamples( fileSamples, s_backgroundInfo.width, s_backgroundInfo.channels, raw );
// add to raw buffer
S_RawSamples( fileSamples, s_backgroundInfo.rate,
s_backgroundInfo.width, s_backgroundInfo.channels, raw, musicVolume );
s_backgroundSamples -= fileSamples;
if ( !s_backgroundSamples )
{
// loop
if (s_backgroundLoop[0])
{
Sys_EndStreamedFile( s_backgroundFile );
FS_FCloseFile( s_backgroundFile );
s_backgroundFile = 0;
S_StartBackgroundTrack( s_backgroundLoop, s_backgroundLoop );
if ( !s_backgroundFile )
{
return; // loop failed to restart
}
}
else
{
s_backgroundFile = 0;
return;
}
}
}
}
static mufont_t *SCR_LoadMUFont( const char *name, size_t len )
{
size_t filename_size;
char *filename;
qbyte *buf;
char *ptr, *token, *start;
int filenum;
int length;
mufont_t *font;
struct shader_s *shader;
int numchar;
int x, y, w, h;
filename_size = strlen( "fonts/" ) + len + strlen( ".tga" ) + 1;
filename = Mem_TempMalloc( filename_size );
Q_snprintfz( filename, filename_size, "fonts/%s", name );
// load the shader
COM_ReplaceExtension( filename, ".tga", filename_size );
shader = R_RegisterPic( filename );
if( !shader )
{
Mem_TempFree( filename );
return NULL;
}
// load the font description
COM_ReplaceExtension( filename, ".wfd", filename_size );
// load the file
length = FS_FOpenFile( filename, &filenum, FS_READ );
if( length == -1 )
{
Mem_TempFree( filename );
return NULL;
}
Mem_TempFree( filename );
buf = Mem_TempMalloc( length + 1 );
length = FS_Read( buf, length, filenum );
FS_FCloseFile( filenum );
if( !length )
{
Mem_TempFree( buf );
return NULL;
}
// seems to be valid. Allocate it
font = (mufont_t *)Font_Alloc( sizeof( mufont_t ) );
font->shader = shader;
font->name = Font_Alloc( len + 1 );
Q_strncpyz( font->name, name, len + 1 );
// proceed
ptr = ( char * )buf;
// get texture width and height
token = COM_Parse( &ptr );
if( !token[0] )
goto error;
font->imagewidth = atoi( token );
token = COM_Parse( &ptr );
if( !token[0] )
goto error;
font->imageheight = atoi( token );
font->numchars = MIN_FONT_CHARS;
// get the number of chars
start = ptr;
while( ptr )
{
// "<char>" "<x>" "<y>" "<width>" "<height>"
token = COM_Parse( &ptr );
if( !token[0] )
break;
numchar = atoi( token );
if( numchar <= 0 )
break;
x = atoi( COM_Parse( &ptr ) ), y = atoi( COM_Parse( &ptr ) );
w = atoi( COM_Parse( &ptr ) ), h = atoi( COM_Parse( &ptr ) );
if( numchar < 32 || numchar >= MAX_FONT_CHARS )
continue;
if( ( unsigned int )( numchar + 1 ) > font->numchars )
font->numchars = ( unsigned int )numchar + 1;
}
if( !font->numchars )
goto error;
font->chars = Font_Alloc( font->numchars * sizeof( muchar_t ) );
// get the chars
ptr = start;
while( ptr )
{
token = COM_Parse( &ptr );
if( !token[0] )
break;
numchar = atoi( token );
if( numchar <= 0 )
break;
x = atoi( COM_Parse( &ptr ) ), y = atoi( COM_Parse( &ptr ) );
w = atoi( COM_Parse( &ptr ) ), h = atoi( COM_Parse( &ptr ) );
if( numchar < 32 || ( unsigned int )numchar >= font->numchars )
continue;
font->chars[numchar].x = x;
font->chars[numchar].y = y;
font->chars[numchar].width = w;
font->chars[numchar].height = h;
// create the texture coordinates
font->chars[numchar].s1 = ( (float)x )/(float)font->imagewidth;
font->chars[numchar].s2 = ( (float)( x + w ) )/(float)font->imagewidth;
font->chars[numchar].t1 = ( (float)y )/(float)font->imageheight;
font->chars[numchar].t2 = ( (float)( y + h ) )/(float)font->imageheight;
}
// mudFont is not always giving a proper size to the space character
font->chars[' '].width = font->chars['-'].width;
// height is the same for every character
font->fontheight = font->chars['a'].height;
// if REPLACEMENT_CHAR is not present in this font, copy '?' to that position
if( !( font->chars[REPLACEMENT_CHAR].height ) )
font->chars[REPLACEMENT_CHAR] = font->chars['?'];
Mem_TempFree( buf );
return font;
error:
if( font->chars )
Font_Free( font->chars );
if( font->name )
Font_Free( font->name );
Font_Free( font );
Mem_TempFree( buf );
return NULL;
}
void DL_End( CURLcode res, CURLMcode resm )
{
CURLMsg *msg;
int msgs;
if( dl_verbose->integer == 0 && dl_showprogress->integer == 2 && !curlm )
Com_Printf( "\n" );
if( curlm )
{
// res = final download result
while( ( msg = curl_multi_info_read( curlm, &msgs ) ) )
{
if( msg->msg != CURLMSG_DONE )
{
if( dl_error[0] == '\0' )
Q_strncpyz( dl_error, "Download Interrupted.", sizeof(dl_error) );
}
else if( msg->easy_handle == curl )
{
if( msg->data.result != CURLE_OK );
res = msg->data.result;
}
else
{
Com_Printf( "Invalid cURL handle.\n" );
}
}
curl_multi_cleanup( curlm );
curlm = NULL;
}
if( curl )
{
curl_easy_cleanup( curl );
curl = NULL;
}
// get possible error messages
if( !*dl_error && res != CURLE_OK )
Q_strncpyz( dl_error, curl_easy_strerror(res), sizeof(dl_error) );
if( !*dl_error && resm != CURLM_OK )
Q_strncpyz( dl_error, curl_multi_strerror(resm), sizeof(dl_error) );
if( !*dl_error && !f )
Q_strncpyz( dl_error, "File is not opened.", sizeof(dl_error) );
if (f) {
FS_FCloseFile(f);
f = 0;
if (!*dl_error) { // download succeeded
char dest[MAX_OSPATH];
Com_Printf("Download complete, restarting filesystem.\n");
Q_strncpyz(dest, path, strlen(path)-3); // -4 +1 for the trailing \0
Q_strcat(dest, sizeof(dest), ".pk3");
if (!FS_FileExists(dest)) {
FS_SV_Rename(path, dest);
FS_Restart(clc.checksumFeed);
if (dl_showmotd->integer && *motd) {
Com_Printf("Server motd: %s\n", motd);
}
} else {
// normally such errors should be caught upon starting the transfer. Anyway better do
// it here again - the filesystem might have changed, plus this may help contain some
// bugs / exploitable flaws in the code.
Com_Printf("Failed to copy downloaded file to its location - file already exists.\n");
FS_HomeRemove(path);
}
} else {
FS_HomeRemove(path);
}
}
Cvar_Set( "cl_downloadName", "" ); // hide the ui downloading screen
Cvar_SetValue( "cl_downloadSize", 0 );
Cvar_SetValue( "cl_downloadCount", 0 );
Cvar_SetValue( "cl_downloadTime", 0 );
Cvar_Set( "cl_downloadMotd", "" );
if( *dl_error )
{
if( clc.state == CA_CONNECTED )
Com_Error( ERR_DROP, "%s\n", dl_error ); // download error while connecting, can not continue loading
else
Com_Printf( "%s\n", dl_error ); // download error while in game, do not disconnect
*dl_error = '\0';
}
else
{
if (strlen(Cvar_VariableString("cl_downloadDemo"))) {
Cbuf_AddText( va("demo %s\n", Cvar_VariableString("cl_downloadDemo") ) );
// download completed, request new gamestate to check possible new map if we are not already in game
} else if( clc.state == CA_CONNECTED)
CL_AddReliableCommand( "donedl", qfalse); // get new gamestate info from server
}
}
/*
====================
CL_UISystemCalls
The ui module is making a system call
====================
*/
intptr_t CL_UISystemCalls( intptr_t *args ) {
switch ( args[0] ) {
case UI_ERROR:
Com_Error( ERR_DROP, "%s", VMA( 1 ) );
return 0;
case UI_PRINT:
Com_Printf( "%s", VMA( 1 ) );
return 0;
case UI_MILLISECONDS:
return Sys_Milliseconds();
case UI_CVAR_REGISTER:
Cvar_Register( VMA( 1 ), VMA( 2 ), VMA( 3 ), args[4] );
return 0;
case UI_CVAR_UPDATE:
Cvar_Update( VMA( 1 ) );
return 0;
case UI_CVAR_SET:
Cvar_Set( VMA( 1 ), VMA( 2 ) );
return 0;
case UI_CVAR_VARIABLEVALUE:
return FloatAsInt( Cvar_VariableValue( VMA( 1 ) ) );
case UI_CVAR_VARIABLESTRINGBUFFER:
Cvar_VariableStringBuffer( VMA( 1 ), VMA( 2 ), args[3] );
return 0;
case UI_CVAR_SETVALUE:
Cvar_SetValue( VMA( 1 ), VMF( 2 ) );
return 0;
case UI_CVAR_RESET:
Cvar_Reset( VMA( 1 ) );
return 0;
case UI_CVAR_CREATE:
Cvar_Get( VMA( 1 ), VMA( 2 ), args[3] );
return 0;
case UI_CVAR_INFOSTRINGBUFFER:
Cvar_InfoStringBuffer( args[1], VMA( 2 ), args[3] );
return 0;
case UI_ARGC:
return Cmd_Argc();
case UI_ARGV:
Cmd_ArgvBuffer( args[1], VMA( 2 ), args[3] );
return 0;
case UI_CMD_EXECUTETEXT:
Cbuf_ExecuteText( args[1], VMA( 2 ) );
return 0;
case UI_FS_FOPENFILE:
return FS_FOpenFileByMode( VMA( 1 ), VMA( 2 ), args[3] );
case UI_FS_READ:
FS_Read( VMA( 1 ), args[2], args[3] );
return 0;
case UI_FS_WRITE:
FS_Write( VMA( 1 ), args[2], args[3] );
return 0;
case UI_FS_FCLOSEFILE:
FS_FCloseFile( args[1] );
return 0;
case UI_FS_DELETEFILE:
return FS_Delete( VMA( 1 ) );
case UI_FS_GETFILELIST:
return FS_GetFileList( VMA( 1 ), VMA( 2 ), VMA( 3 ), args[4] );
case UI_R_REGISTERMODEL:
return re.RegisterModel( VMA( 1 ) );
case UI_R_REGISTERSKIN:
return re.RegisterSkin( VMA( 1 ) );
case UI_R_REGISTERSHADERNOMIP:
return re.RegisterShaderNoMip( VMA( 1 ) );
case UI_R_CLEARSCENE:
re.ClearScene();
return 0;
case UI_R_ADDREFENTITYTOSCENE:
re.AddRefEntityToScene( VMA( 1 ) );
return 0;
case UI_R_ADDPOLYTOSCENE:
re.AddPolyToScene( args[1], args[2], VMA( 3 ) );
return 0;
// Ridah
case UI_R_ADDPOLYSTOSCENE:
re.AddPolysToScene( args[1], args[2], VMA( 3 ), args[4] );
return 0;
// done.
case UI_R_ADDLIGHTTOSCENE:
re.AddLightToScene( VMA( 1 ), VMF( 2 ), VMF( 3 ), VMF( 4 ), VMF( 5 ), args[6] );
return 0;
case UI_R_ADDCORONATOSCENE:
re.AddCoronaToScene( VMA( 1 ), VMF( 2 ), VMF( 3 ), VMF( 4 ), VMF( 5 ), args[6], args[7] );
return 0;
case UI_R_RENDERSCENE:
re.RenderScene( VMA( 1 ) );
return 0;
case UI_R_SETCOLOR:
re.SetColor( VMA( 1 ) );
return 0;
case UI_R_DRAWSTRETCHPIC:
re.DrawStretchPic( VMF( 1 ), VMF( 2 ), VMF( 3 ), VMF( 4 ), VMF( 5 ), VMF( 6 ), VMF( 7 ), VMF( 8 ), args[9] );
return 0;
case UI_R_MODELBOUNDS:
re.ModelBounds( args[1], VMA( 2 ), VMA( 3 ) );
return 0;
case UI_UPDATESCREEN:
SCR_UpdateScreen();
return 0;
case UI_CM_LERPTAG:
return re.LerpTag( VMA( 1 ), VMA( 2 ), VMA( 3 ), args[4] );
case UI_S_REGISTERSOUND:
#ifdef DOOMSOUND ///// (SA) DOOMSOUND
return S_RegisterSound( VMA( 1 ) );
#else
return S_RegisterSound( VMA( 1 ), qfalse );
#endif ///// (SA) DOOMSOUND
case UI_S_STARTLOCALSOUND:
S_StartLocalSound( args[1], args[2] );
return 0;
case UI_KEY_KEYNUMTOSTRINGBUF:
Key_KeynumToStringBuf( args[1], VMA( 2 ), args[3] );
return 0;
case UI_KEY_GETBINDINGBUF:
Key_GetBindingBuf( args[1], VMA( 2 ), args[3] );
return 0;
case UI_KEY_SETBINDING:
Key_SetBinding( args[1], VMA( 2 ) );
return 0;
case UI_KEY_ISDOWN:
return Key_IsDown( args[1] );
case UI_KEY_GETOVERSTRIKEMODE:
return Key_GetOverstrikeMode();
case UI_KEY_SETOVERSTRIKEMODE:
Key_SetOverstrikeMode( args[1] );
return 0;
case UI_KEY_CLEARSTATES:
Key_ClearStates();
return 0;
case UI_KEY_GETCATCHER:
return Key_GetCatcher();
case UI_KEY_SETCATCHER:
Key_SetCatcher( args[1] );
return 0;
case UI_GETCLIPBOARDDATA:
GetClipboardData( VMA( 1 ), args[2] );
return 0;
case UI_GETCLIENTSTATE:
GetClientState( VMA( 1 ) );
return 0;
case UI_GETGLCONFIG:
CL_GetGlconfig( VMA( 1 ) );
return 0;
case UI_GETCONFIGSTRING:
return GetConfigString( args[1], VMA( 2 ), args[3] );
case UI_LAN_LOADCACHEDSERVERS:
LAN_LoadCachedServers();
return 0;
case UI_LAN_SAVECACHEDSERVERS:
LAN_SaveServersToCache();
return 0;
case UI_LAN_ADDSERVER:
return LAN_AddServer( args[1], VMA( 2 ), VMA( 3 ) );
case UI_LAN_REMOVESERVER:
LAN_RemoveServer( args[1], VMA( 2 ) );
return 0;
case UI_LAN_GETPINGQUEUECOUNT:
return LAN_GetPingQueueCount();
case UI_LAN_CLEARPING:
LAN_ClearPing( args[1] );
return 0;
case UI_LAN_GETPING:
LAN_GetPing( args[1], VMA( 2 ), args[3], VMA( 4 ) );
return 0;
case UI_LAN_GETPINGINFO:
LAN_GetPingInfo( args[1], VMA( 2 ), args[3] );
return 0;
case UI_LAN_GETSERVERCOUNT:
return LAN_GetServerCount( args[1] );
case UI_LAN_GETSERVERADDRESSSTRING:
LAN_GetServerAddressString( args[1], args[2], VMA( 3 ), args[4] );
return 0;
case UI_LAN_GETSERVERINFO:
LAN_GetServerInfo( args[1], args[2], VMA( 3 ), args[4] );
return 0;
case UI_LAN_GETSERVERPING:
return LAN_GetServerPing( args[1], args[2] );
case UI_LAN_MARKSERVERVISIBLE:
LAN_MarkServerVisible( args[1], args[2], args[3] );
return 0;
case UI_LAN_SERVERISVISIBLE:
return LAN_ServerIsVisible( args[1], args[2] );
case UI_LAN_UPDATEVISIBLEPINGS:
return LAN_UpdateVisiblePings( args[1] );
case UI_LAN_RESETPINGS:
LAN_ResetPings( args[1] );
return 0;
case UI_LAN_SERVERSTATUS:
return LAN_GetServerStatus( VMA( 1 ), VMA( 2 ), args[3] );
case UI_SET_PBCLSTATUS:
return 0;
case UI_SET_PBSVSTATUS:
return 0;
case UI_LAN_COMPARESERVERS:
return LAN_CompareServers( args[1], args[2], args[3], args[4], args[5] );
case UI_MEMORY_REMAINING:
return Hunk_MemoryRemaining();
case UI_GET_CDKEY:
CLUI_GetCDKey( VMA( 1 ), args[2] );
return 0;
case UI_SET_CDKEY:
CLUI_SetCDKey( VMA( 1 ) );
return 0;
case UI_R_REGISTERFONT:
re.RegisterFont( VMA( 1 ), args[2], VMA( 3 ) );
return 0;
case UI_MEMSET:
return (intptr_t)memset( VMA( 1 ), args[2], args[3] );
case UI_MEMCPY:
return (intptr_t)memcpy( VMA( 1 ), VMA( 2 ), args[3] );
case UI_STRNCPY:
return (intptr_t)strncpy( VMA( 1 ), VMA( 2 ), args[3] );
case UI_SIN:
return FloatAsInt( sin( VMF( 1 ) ) );
case UI_COS:
return FloatAsInt( cos( VMF( 1 ) ) );
case UI_ATAN2:
return FloatAsInt( atan2( VMF( 1 ), VMF( 2 ) ) );
case UI_SQRT:
return FloatAsInt( sqrt( VMF( 1 ) ) );
case UI_FLOOR:
return FloatAsInt( floor( VMF( 1 ) ) );
case UI_CEIL:
return FloatAsInt( ceil( VMF( 1 ) ) );
case UI_PC_ADD_GLOBAL_DEFINE:
return botlib_export->PC_AddGlobalDefine( VMA( 1 ) );
case UI_PC_LOAD_SOURCE:
return botlib_export->PC_LoadSourceHandle( VMA( 1 ) );
case UI_PC_FREE_SOURCE:
return botlib_export->PC_FreeSourceHandle( args[1] );
case UI_PC_READ_TOKEN:
return botlib_export->PC_ReadTokenHandle( args[1], VMA( 2 ) );
case UI_PC_SOURCE_FILE_AND_LINE:
return botlib_export->PC_SourceFileAndLine( args[1], VMA( 2 ), VMA( 3 ) );
case UI_S_STOPBACKGROUNDTRACK:
S_StopBackgroundTrack();
return 0;
case UI_S_STARTBACKGROUNDTRACK:
S_StartBackgroundTrack( VMA( 1 ), VMA( 2 ) );
return 0;
case UI_REAL_TIME:
return Com_RealTime( VMA( 1 ) );
case UI_CIN_PLAYCINEMATIC:
Com_DPrintf( "UI_CIN_PlayCinematic\n" );
return CIN_PlayCinematic( VMA( 1 ), args[2], args[3], args[4], args[5], args[6] );
case UI_CIN_STOPCINEMATIC:
return CIN_StopCinematic( args[1] );
case UI_CIN_RUNCINEMATIC:
return CIN_RunCinematic( args[1] );
case UI_CIN_DRAWCINEMATIC:
CIN_DrawCinematic( args[1] );
return 0;
case UI_CIN_SETEXTENTS:
CIN_SetExtents( args[1], args[2], args[3], args[4], args[5] );
return 0;
case UI_R_REMAP_SHADER:
re.RemapShader( VMA( 1 ), VMA( 2 ), VMA( 3 ) );
return 0;
case UI_VERIFY_CDKEY:
return CL_CDKeyValidate( VMA( 1 ), VMA( 2 ) );
// NERVE - SMF
case UI_CL_GETLIMBOSTRING:
return CL_GetLimboString( args[1], VMA( 2 ) );
case UI_CL_TRANSLATE_STRING:
CL_TranslateString( VMA( 1 ), VMA( 2 ) );
return 0;
// -NERVE - SMF
// DHM - Nerve
case UI_CHECKAUTOUPDATE:
CL_CheckAutoUpdate();
return 0;
case UI_GET_AUTOUPDATE:
CL_GetAutoUpdate();
return 0;
// DHM - Nerve
case UI_OPENURL:
CL_OpenURL( (const char *)VMA( 1 ) );
return 0;
default:
Com_Error( ERR_DROP, "Bad UI system trap: %i", args[0] );
}
return 0;
}
static void logfile_write(print_type_t type, const char *s)
{
char text[MAXPRINTMSG];
char buf[MAX_QPATH];
char *p, *maxp;
size_t len;
ssize_t ret;
int c;
if (logfile_prefix->string[0]) {
p = strchr(logfile_prefix->string, '@');
if (p) {
// expand it in place, hacky
switch (type) {
case PRINT_TALK: *p = 'T'; break;
case PRINT_DEVELOPER: *p = 'D'; break;
case PRINT_WARNING: *p = 'W'; break;
case PRINT_ERROR: *p = 'E'; break;
case PRINT_NOTICE: *p = 'N'; break;
default: *p = 'A'; break;
}
}
len = format_local_time(buf, sizeof(buf), logfile_prefix->string);
if (p) {
*p = '@';
}
} else {
len = 0;
}
p = text;
maxp = text + sizeof(text) - 1;
while (*s) {
if (com_logNewline) {
if (len > 0 && p + len < maxp) {
memcpy(p, buf, len);
p += len;
}
com_logNewline = qfalse;
}
if (p == maxp) {
break;
}
c = *s++;
if (c == '\n') {
com_logNewline = qtrue;
} else {
c = Q_charascii(c);
}
*p++ = c;
}
*p = 0;
len = p - text;
ret = FS_Write(text, len, com_logFile);
if (ret != len) {
// zero handle BEFORE doing anything else to avoid recursion
qhandle_t tmp = com_logFile;
com_logFile = 0;
FS_FCloseFile(tmp);
Com_EPrintf("Couldn't write console log: %s\n", Q_ErrorString(ret));
Cvar_Set("logfile", "0");
}
}
/**
* @brief The cgame module is making a system call
* @param[in] args
* @return
*/
intptr_t CL_CgameSystemCalls(intptr_t *args)
{
switch (args[0])
{
case CG_PRINT:
Com_Printf("%s", (char *)VMA(1));
return 0;
case CG_ERROR:
Com_Error(ERR_DROP, "%s", (char *)VMA(1));
case CG_MILLISECONDS:
return Sys_Milliseconds();
case CG_CVAR_REGISTER:
Cvar_Register(VMA(1), VMA(2), VMA(3), args[4]);
return 0;
case CG_CVAR_UPDATE:
Cvar_Update(VMA(1));
return 0;
case CG_CVAR_SET:
Cvar_SetSafe(VMA(1), VMA(2));
return 0;
case CG_CVAR_VARIABLESTRINGBUFFER:
Cvar_VariableStringBuffer(VMA(1), VMA(2), args[3]);
return 0;
case CG_CVAR_LATCHEDVARIABLESTRINGBUFFER:
Cvar_LatchedVariableStringBuffer(VMA(1), VMA(2), args[3]);
return 0;
case CG_ARGC:
return Cmd_Argc();
case CG_ARGV:
Cmd_ArgvBuffer(args[1], VMA(2), args[3]);
return 0;
case CG_ARGS:
Cmd_ArgsBuffer(VMA(1), args[2]);
return 0;
case CG_FS_FOPENFILE:
return FS_FOpenFileByMode(VMA(1), VMA(2), args[3]);
case CG_FS_READ:
FS_Read(VMA(1), args[2], args[3]);
return 0;
case CG_FS_WRITE:
return FS_Write(VMA(1), args[2], args[3]);
case CG_FS_FCLOSEFILE:
FS_FCloseFile(args[1]);
return 0;
case CG_FS_GETFILELIST:
return FS_GetFileList(VMA(1), VMA(2), VMA(3), args[4]);
case CG_FS_DELETEFILE:
return FS_Delete(VMA(1));
case CG_SENDCONSOLECOMMAND:
Cbuf_AddText(VMA(1));
return 0;
case CG_ADDCOMMAND:
Cmd_AddCommand(VMA(1));
return 0;
case CG_REMOVECOMMAND:
Cmd_RemoveCommandSafe(VMA(1));
return 0;
case CG_SENDCLIENTCOMMAND:
CL_AddReliableCommand(VMA(1));
return 0;
case CG_UPDATESCREEN:
SCR_UpdateScreen();
return 0;
case CG_CM_LOADMAP:
CL_CM_LoadMap(VMA(1));
return 0;
case CG_CM_NUMINLINEMODELS:
return CM_NumInlineModels();
case CG_CM_INLINEMODEL:
return CM_InlineModel(args[1]);
case CG_CM_TEMPBOXMODEL:
return CM_TempBoxModel(VMA(1), VMA(2), qfalse);
case CG_CM_TEMPCAPSULEMODEL:
return CM_TempBoxModel(VMA(1), VMA(2), qtrue);
case CG_CM_POINTCONTENTS:
return CM_PointContents(VMA(1), args[2]);
case CG_CM_TRANSFORMEDPOINTCONTENTS:
return CM_TransformedPointContents(VMA(1), args[2], VMA(3), VMA(4));
case CG_CM_BOXTRACE:
CM_BoxTrace(VMA(1), VMA(2), VMA(3), VMA(4), VMA(5), args[6], args[7], /*int capsule*/ qfalse);
return 0;
case CG_CM_CAPSULETRACE:
CM_BoxTrace(VMA(1), VMA(2), VMA(3), VMA(4), VMA(5), args[6], args[7], /*int capsule*/ qtrue);
return 0;
case CG_CM_TRANSFORMEDBOXTRACE:
CM_TransformedBoxTrace(VMA(1), VMA(2), VMA(3), VMA(4), VMA(5), args[6], args[7], VMA(8), VMA(9), /*int capsule*/ qfalse);
return 0;
case CG_CM_TRANSFORMEDCAPSULETRACE:
CM_TransformedBoxTrace(VMA(1), VMA(2), VMA(3), VMA(4), VMA(5), args[6], args[7], VMA(8), VMA(9), /*int capsule*/ qtrue);
return 0;
case CG_CM_MARKFRAGMENTS:
return re.MarkFragments(args[1], VMA(2), VMA(3), args[4], VMA(5), args[6], VMA(7));
case CG_R_PROJECTDECAL:
re.ProjectDecal(args[1], args[2], VMA(3), VMA(4), VMA(5), args[6], args[7]);
return 0;
case CG_R_CLEARDECALS:
re.ClearDecals();
return 0;
case CG_S_STARTSOUND:
S_StartSound(VMA(1), args[2], args[3], args[4], args[5]);
return 0;
case CG_S_STARTSOUNDEX:
S_StartSoundEx(VMA(1), args[2], args[3], args[4], args[5], args[6]);
return 0;
case CG_S_STARTLOCALSOUND:
S_StartLocalSound(args[1], args[2], args[3]);
return 0;
case CG_S_CLEARLOOPINGSOUNDS:
S_ClearLoopingSounds();
return 0;
case CG_S_CLEARSOUNDS:
if (args[1] == 0)
{
S_ClearSounds(qtrue, qfalse);
}
else if (args[1] == 1)
{
S_ClearSounds(qtrue, qtrue);
}
return 0;
case CG_S_ADDLOOPINGSOUND:
// FIXME handling of looping sounds changed
S_AddLoopingSound(VMA(1), VMA(2), args[3], args[4], args[5], args[6]);
return 0;
case CG_S_ADDREALLOOPINGSOUND:
S_AddRealLoopingSound(VMA(1), VMA(2), args[3], args[4], args[5], args[6]);
return 0;
case CG_S_STOPSTREAMINGSOUND:
S_StopEntStreamingSound(args[1]);
return 0;
case CG_S_UPDATEENTITYPOSITION:
S_UpdateEntityPosition(args[1], VMA(2));
return 0;
// talking animations
case CG_S_GETVOICEAMPLITUDE:
return S_GetVoiceAmplitude(args[1]);
case CG_S_GETSOUNDLENGTH:
return S_GetSoundLength(args[1]);
// for looped sound starts
case CG_S_GETCURRENTSOUNDTIME:
return S_GetCurrentSoundTime();
case CG_S_RESPATIALIZE:
S_Respatialize(args[1], VMA(2), VMA(3), args[4]);
return 0;
case CG_S_REGISTERSOUND:
return S_RegisterSound(VMA(1), args[2]);
case CG_S_STARTBACKGROUNDTRACK:
S_StartBackgroundTrack(VMA(1), VMA(2), args[3]); // added fadeup time
return 0;
case CG_S_FADESTREAMINGSOUND:
S_FadeStreamingSound(VMF(1), args[2], args[3]); // added music/all-streaming options
return 0;
case CG_S_STARTSTREAMINGSOUND:
return S_StartStreamingSound(VMA(1), VMA(2), args[3], args[4], args[5]);
case CG_R_LOADWORLDMAP:
re.LoadWorld(VMA(1));
return 0;
case CG_R_REGISTERMODEL:
return re.RegisterModel(VMA(1));
case CG_R_REGISTERSKIN:
return re.RegisterSkin(VMA(1));
case CG_R_GETSKINMODEL:
return re.GetSkinModel(args[1], VMA(2), VMA(3));
case CG_R_GETMODELSHADER:
return re.GetShaderFromModel(args[1], args[2], args[3]);
case CG_R_REGISTERSHADER:
return re.RegisterShader(VMA(1));
case CG_R_REGISTERSHADERNOMIP:
return re.RegisterShaderNoMip(VMA(1));
case CG_R_REGISTERFONT:
re.RegisterFont(VMA(1), args[2], VMA(3), (args[4] == qtrue));
return 0;
case CG_R_CLEARSCENE:
re.ClearScene();
return 0;
case CG_R_ADDREFENTITYTOSCENE:
re.AddRefEntityToScene(VMA(1));
return 0;
case CG_R_ADDPOLYTOSCENE:
re.AddPolyToScene(args[1], args[2], VMA(3));
return 0;
case CG_R_ADDPOLYSTOSCENE:
re.AddPolysToScene(args[1], args[2], VMA(3), args[4]);
return 0;
case CG_R_ADDPOLYBUFFERTOSCENE:
re.AddPolyBufferToScene(VMA(1));
return 0;
case CG_R_ADDLIGHTTOSCENE:
re.AddLightToScene(VMA(1), VMF(2), VMF(3), VMF(4), VMF(5), VMF(6), args[7], args[8]);
return 0;
case CG_R_ADDCORONATOSCENE:
re.AddCoronaToScene(VMA(1), VMF(2), VMF(3), VMF(4), VMF(5), args[6], args[7]);
return 0;
case CG_R_SETFOG:
re.SetFog(args[1], args[2], args[3], VMF(4), VMF(5), VMF(6), VMF(7));
return 0;
case CG_R_SETGLOBALFOG:
re.SetGlobalFog(args[1], args[2], VMF(3), VMF(4), VMF(5), VMF(6));
return 0;
case CG_R_RENDERSCENE:
re.RenderScene(VMA(1));
return 0;
case CG_R_SAVEVIEWPARMS:
return 0;
case CG_R_RESTOREVIEWPARMS:
return 0;
case CG_R_SETCOLOR:
re.SetColor(VMA(1));
return 0;
case CG_R_DRAWSTRETCHPIC:
re.DrawStretchPic(VMF(1), VMF(2), VMF(3), VMF(4), VMF(5), VMF(6), VMF(7), VMF(8), args[9]);
return 0;
case CG_R_DRAWROTATEDPIC:
re.DrawRotatedPic(VMF(1), VMF(2), VMF(3), VMF(4), VMF(5), VMF(6), VMF(7), VMF(8), args[9], VMF(10));
return 0;
case CG_R_DRAWSTRETCHPIC_GRADIENT:
re.DrawStretchPicGradient(VMF(1), VMF(2), VMF(3), VMF(4), VMF(5), VMF(6), VMF(7), VMF(8), args[9], VMA(10), args[11]);
return 0;
case CG_R_DRAW2DPOLYS:
re.Add2dPolys(VMA(1), args[2], args[3]);
return 0;
case CG_R_MODELBOUNDS:
re.ModelBounds(args[1], VMA(2), VMA(3));
return 0;
case CG_R_LERPTAG:
return re.LerpTag(VMA(1), VMA(2), VMA(3), args[4]);
case CG_GETGLCONFIG:
CL_GetGlconfig(VMA(1));
return 0;
case CG_GETGAMESTATE:
CL_GetGameState(VMA(1));
return 0;
case CG_GETCURRENTSNAPSHOTNUMBER:
CL_GetCurrentSnapshotNumber(VMA(1), VMA(2));
return 0;
case CG_GETSNAPSHOT:
return CL_GetSnapshot(args[1], VMA(2));
case CG_GETSERVERCOMMAND:
return CL_GetServerCommand(args[1]);
case CG_GETCURRENTCMDNUMBER:
return CL_GetCurrentCmdNumber();
case CG_GETUSERCMD:
return CL_GetUserCmd(args[1], VMA(2));
case CG_SETUSERCMDVALUE:
CL_SetUserCmdValue(args[1], args[2], VMF(3), args[4]);
return 0;
case CG_SETCLIENTLERPORIGIN:
CL_SetClientLerpOrigin(VMF(1), VMF(2), VMF(3));
return 0;
case CG_MEMORY_REMAINING:
return Hunk_MemoryRemaining();
case CG_KEY_ISDOWN:
return Key_IsDown(args[1]);
case CG_KEY_GETCATCHER:
return Key_GetCatcher();
case CG_KEY_SETCATCHER:
// Don't allow the cgame module to close the console
Key_SetCatcher(args[1] | (Key_GetCatcher() & KEYCATCH_CONSOLE));
return 0;
case CG_KEY_GETKEY:
return Key_GetKey(VMA(1));
case CG_KEY_GETOVERSTRIKEMODE:
return Key_GetOverstrikeMode();
case CG_KEY_SETOVERSTRIKEMODE:
Key_SetOverstrikeMode(args[1]);
return 0;
case CG_MEMSET:
return (intptr_t)Com_Memset(VMA(1), args[2], args[3]);
case CG_MEMCPY:
return (intptr_t)Com_Memcpy(VMA(1), VMA(2), args[3]);
case CG_STRNCPY:
return (intptr_t)strncpy(VMA(1), VMA(2), args[3]);
case CG_SIN:
return FloatAsInt(sin(VMF(1)));
case CG_COS:
return FloatAsInt(cos(VMF(1)));
case CG_ATAN2:
return FloatAsInt(atan2(VMF(1), VMF(2)));
case CG_SQRT:
return FloatAsInt(sqrt(VMF(1)));
case CG_FLOOR:
return FloatAsInt(floor(VMF(1)));
case CG_CEIL:
return FloatAsInt(ceil(VMF(1)));
case CG_ACOS:
return FloatAsInt(Q_acos(VMF(1)));
case CG_PC_ADD_GLOBAL_DEFINE:
return botlib_export->PC_AddGlobalDefine(VMA(1));
case CG_PC_LOAD_SOURCE:
return botlib_export->PC_LoadSourceHandle(VMA(1));
case CG_PC_FREE_SOURCE:
return botlib_export->PC_FreeSourceHandle(args[1]);
case CG_PC_READ_TOKEN:
return botlib_export->PC_ReadTokenHandle(args[1], VMA(2));
case CG_PC_SOURCE_FILE_AND_LINE:
return botlib_export->PC_SourceFileAndLine(args[1], VMA(2), VMA(3));
case CG_PC_UNREAD_TOKEN:
botlib_export->PC_UnreadLastTokenHandle(args[1]);
return 0;
case CG_S_STOPBACKGROUNDTRACK:
S_StopBackgroundTrack();
return 0;
case CG_REAL_TIME:
return Com_RealTime(VMA(1));
case CG_SNAPVECTOR:
Sys_SnapVector(VMA(1));
return 0;
case CG_CIN_PLAYCINEMATIC:
return CIN_PlayCinematic(VMA(1), args[2], args[3], args[4], args[5], args[6]);
case CG_CIN_STOPCINEMATIC:
return CIN_StopCinematic(args[1]);
case CG_CIN_RUNCINEMATIC:
return CIN_RunCinematic(args[1]);
case CG_CIN_DRAWCINEMATIC:
CIN_DrawCinematic(args[1]);
return 0;
case CG_CIN_SETEXTENTS:
CIN_SetExtents(args[1], args[2], args[3], args[4], args[5]);
return 0;
case CG_R_REMAP_SHADER:
re.RemapShader(VMA(1), VMA(2), VMA(3));
return 0;
case CG_TESTPRINTINT:
Com_Printf("%s%li\n", (char *)VMA(1), (long)args[2]);
return 0;
case CG_TESTPRINTFLOAT:
Com_Printf("%s%f\n", (char *)VMA(1), VMF(2));
return 0;
case CG_GET_ENTITY_TOKEN:
return re.GetEntityToken(VMA(1), args[2]);
case CG_INGAME_POPUP:
if (cls.state == CA_ACTIVE && !clc.demoplaying)
{
if (uivm) // can be called as the system is shutting down
{
VM_Call(uivm, UI_SET_ACTIVE_MENU, args[1]);
}
}
return 0;
case CG_KEY_GETBINDINGBUF:
Key_GetBindingBuf(args[1], VMA(2), args[3]);
return 0;
case CG_KEY_SETBINDING:
Key_SetBinding(args[1], VMA(2));
return 0;
case CG_KEY_KEYNUMTOSTRINGBUF:
Key_KeynumToStringBuf(args[1], VMA(2), args[3]);
return 0;
case CG_KEY_BINDINGTOKEYS:
Key_GetBindingByString(VMA(1), VMA(2), VMA(3));
return 0;
case CG_TRANSLATE_STRING:
CL_TranslateStringMod(VMA(1), VMA(2));
return 0;
case CG_S_FADEALLSOUNDS:
S_FadeAllSounds(VMF(1), args[2], args[3]);
return 0;
case CG_R_INPVS:
return re.inPVS(VMA(1), VMA(2));
case CG_GETHUNKDATA:
Com_GetHunkInfo(VMA(1), VMA(2));
return 0;
// binary channel
case CG_SENDMESSAGE:
return CL_SendBinaryMessage(VMA(1), args[2]);
case CG_MESSAGESTATUS:
return CL_BinaryMessageStatus();
case CG_R_LOADDYNAMICSHADER:
return re.LoadDynamicShader(VMA(1), VMA(2));
case CG_R_RENDERTOTEXTURE:
re.RenderToTexture(args[1], args[2], args[3], args[4], args[5]);
return 0;
case CG_R_GETTEXTUREID:
return re.GetTextureId(VMA(1));
// flush gl rendering buffers
case CG_R_FINISH:
re.Finish();
return 0;
case CG_LOADCAMERA:
case CG_STARTCAMERA:
case CG_STOPCAMERA:
case CG_GETCAMERAINFO:
case CG_PUMPEVENTLOOP:
case CG_INGAME_CLOSEPOPUP:
case CG_R_LIGHTFORPOINT: // re-added to avoid a crash when called - still in enum of cgameImport_t
// This shows (developer 1) when the vanilla mod code is loaded or mods using obsolete system calls - see cases.
Com_DPrintf("Obsolete cgame system trap: %ld\n", (long int) args[0]);
return 0;
default:
Com_Error(ERR_DROP, "Bad cgame system trap: %ld", (long int) args[0]);
break;
}
return 0;
}
/*
=====================
SV_DropClient
Called when the player is totally leaving the server, either willingly
or unwillingly. This is NOT called if the entire server is quiting
or crashing -- SV_FinalMessage() will handle that
=====================
*/
void SV_DropClient( client_t *drop, const char *reason ) {
int i;
challenge_t *challenge;
const qboolean isBot = drop->netchan.remoteAddress.type == NA_BOT;
if ( drop->state == CS_ZOMBIE ) {
return; // already dropped
}
if ( !isBot ) {
// see if we already have a challenge for this ip
challenge = &svs.challenges[0];
for (i = 0 ; i < MAX_CHALLENGES ; i++, challenge++)
{
if(NET_CompareAdr(drop->netchan.remoteAddress, challenge->adr))
{
Com_Memset(challenge, 0, sizeof(*challenge));
break;
}
}
}
// Kill any download
SV_CloseDownload( drop );
// tell everyone why they got dropped
SV_SendServerCommand( NULL, "print \"%s" S_COLOR_WHITE " %s\n\"", drop->name, reason );
if (drop->download) {
FS_FCloseFile( drop->download );
drop->download = 0;
}
// call the prog function for removing a client
// this will remove the body, among other things
VM_Call( gvm, GAME_CLIENT_DISCONNECT, drop - svs.clients );
// add the disconnect command
SV_SendServerCommand( drop, "disconnect \"%s\"", reason);
if ( isBot ) {
SV_BotFreeClient( drop - svs.clients );
}
// nuke user info
SV_SetUserinfo( drop - svs.clients, "" );
if ( isBot ) {
// bots shouldn't go zombie, as there's no real net connection.
drop->state = CS_FREE;
} else {
Com_DPrintf( "Going to CS_ZOMBIE for %s\n", drop->name );
drop->state = CS_ZOMBIE; // become free in a few seconds
}
// if this was the last client on the server, send a heartbeat
// to the master so it is known the server is empty
// send a heartbeat now so the master will get up to date info
// if there is already a slot for this ip, reuse it
for (i=0 ; i < sv_maxclients->integer ; i++ ) {
if ( svs.clients[i].state >= CS_CONNECTED ) {
break;
}
}
if ( i == sv_maxclients->integer ) {
SV_Heartbeat_f();
}
}
unsigned int _GeoIP_seek_record ( unsigned long ipnum ) {
fileHandle_t file;
int depth;
unsigned int x;
unsigned char stack_buffer[2 * MAX_RECORD_LENGTH];
const unsigned char *buf = stack_buffer;
unsigned int offset = 0;
const unsigned char * p;
int j;
FS_SV_FOpenFileRead("GeoIP.dat", &file);
if(!file){
Com_Printf("File Read error.\n");
return 0;
}
/*
unsigned char *data; = malloc(1024*1024*2);
if(!FS_Seek(file, 0, SEEK_SET)){
FS_Read(data , 1024*1024*2, file);
}
*/
unsigned int foffset;
for (depth = 31; depth >= 0; depth--) {
/* read from disk */
foffset = (long)RECORD_LENGTH * 2 *offset;
if(!FS_Seek(file, foffset, FS_SEEK_SET)){
FS_Read(stack_buffer , RECORD_LENGTH * 2, file);
}
/* simply point to record in memory */
// buf = data + (long)RECORD_LENGTH * 2 *offset;
if (ipnum & (1 << depth)) {
/* Take the right-hand branch */
if ( RECORD_LENGTH == 3 ) {
/* Most common case is completely unrolled and uses constants. */
x = (buf[3*1 + 0] << (0*8)) + (buf[3*1 + 1] << (1*8)) + (buf[3*1 + 2] << (2*8));
} else {
/* General case */
j = RECORD_LENGTH;
p = &buf[2*j];
x = 0;
do {
x <<= 8;
x += *(--p);
} while ( --j );
}
} else {
/* Take the left-hand branch */
if ( RECORD_LENGTH == 3 ) {
/* Most common case is completely unrolled and uses constants. */
x = (buf[3*0 + 0] << (0*8)) + (buf[3*0 + 1] << (1*8)) + (buf[3*0 + 2] << (2*8));
} else {
/* General case */
j = RECORD_LENGTH;
p = &buf[1*j];
x = 0;
do {
x <<= 8;
x += *(--p);
} while ( --j );
}
}
if (x >= BEGIN_OFFSET) {
//gi->netmask = gl->netmask = 32 - depth;
FS_FCloseFile(file);
return x - BEGIN_OFFSET;
}
offset = x;
}
/* shouldn't reach here */
Com_PrintError("Traversing Database for ipnum = %lu - Perhaps database is corrupt?\n",ipnum);
FS_FCloseFile(file);
return 0;
}
/*
==================
SV_RehashBans_f
Load saved bans from file.
==================
*/
static void SV_RehashBans_f(void)
{
int index, filelen;
fileHandle_t readfrom;
char *textbuf, *curpos, *maskpos, *newlinepos, *endpos;
char filepath[MAX_QPATH];
// make sure server is running
if ( !com_sv_running->integer ) {
return;
}
serverBansCount = 0;
if(!sv_banFile->string || !*sv_banFile->string)
return;
Com_sprintf(filepath, sizeof(filepath), "%s/%s", FS_GetCurrentGameDir(), sv_banFile->string);
if((filelen = FS_SV_FOpenFileRead(filepath, &readfrom)) >= 0)
{
if(filelen < 2)
{
// Don't bother if file is too short.
FS_FCloseFile(readfrom);
return;
}
curpos = textbuf = Z_Malloc(filelen);
filelen = FS_Read(textbuf, filelen, readfrom);
FS_FCloseFile(readfrom);
endpos = textbuf + filelen;
for(index = 0; index < SERVER_MAXBANS && curpos + 2 < endpos; index++)
{
// find the end of the address string
for(maskpos = curpos + 2; maskpos < endpos && *maskpos != ' '; maskpos++);
if(maskpos + 1 >= endpos)
break;
*maskpos = '\0';
maskpos++;
// find the end of the subnet specifier
for(newlinepos = maskpos; newlinepos < endpos && *newlinepos != '\n'; newlinepos++);
if(newlinepos >= endpos)
break;
*newlinepos = '\0';
if(NET_StringToAdr(curpos + 2, &serverBans[index].ip, NA_UNSPEC))
{
serverBans[index].isexception = (curpos[0] != '0');
serverBans[index].subnet = atoi(maskpos);
if(serverBans[index].ip.type == NA_IP &&
(serverBans[index].subnet < 1 || serverBans[index].subnet > 32))
{
serverBans[index].subnet = 32;
}
else if(serverBans[index].ip.type == NA_IP6 &&
(serverBans[index].subnet < 1 || serverBans[index].subnet > 128))
{
serverBans[index].subnet = 128;
}
}
curpos = newlinepos + 1;
}
serverBansCount = index;
Z_Free(textbuf);
}
}
static void S_StreamClose( openSound_t *open ) {
if ( open->fileHandle > 0) {
FS_FCloseFile( open->fileHandle );
open->fileHandle = 0;
}
}
/*
====================
CL_UISystemCalls
The ui module is making a system call
====================
*/
intptr_t CL_UISystemCalls( intptr_t *args ) {
switch( args[0] ) {
case UI_ERROR:
Com_Error( ERR_DROP, "%s", (const char*)VMA(1) );
return 0;
case UI_PRINT:
Com_Printf( "%s", (const char*)VMA(1) );
return 0;
case UI_MILLISECONDS:
return Sys_Milliseconds();
case UI_CVAR_REGISTER:
Cvar_Register( VMA(1), VMA(2), VMA(3), args[4] );
return 0;
case UI_CVAR_UPDATE:
Cvar_Update( VMA(1) );
return 0;
case UI_CVAR_SET:
Cvar_SetSafe( VMA(1), VMA(2) );
return 0;
case UI_CVAR_VARIABLEVALUE:
return FloatAsInt( Cvar_VariableValue( VMA(1) ) );
case UI_CVAR_VARIABLESTRINGBUFFER:
Cvar_VariableStringBuffer( VMA(1), VMA(2), args[3] );
return 0;
case UI_CVAR_SETVALUE:
Cvar_SetValueSafe( VMA(1), VMF(2) );
return 0;
case UI_CVAR_RESET:
Cvar_Reset( VMA(1) );
return 0;
case UI_CVAR_CREATE:
Cvar_Get( VMA(1), VMA(2), args[3] );
return 0;
case UI_CVAR_INFOSTRINGBUFFER:
Cvar_InfoStringBuffer( args[1], VMA(2), args[3] );
return 0;
case UI_ARGC:
return Cmd_Argc();
case UI_ARGV:
Cmd_ArgvBuffer( args[1], VMA(2), args[3] );
return 0;
case UI_CMD_EXECUTETEXT:
if(args[1] == 0
&& (!strncmp(VMA(2), "snd_restart", 11)
|| !strncmp(VMA(2), "vid_restart", 11)
|| !strncmp(VMA(2), "quit", 5)))
{
Com_DPrintf (S_COLOR_YELLOW "turning EXEC_NOW '%.11s' into EXEC_INSERT\n", (const char*)VMA(2));
args[1] = EXEC_INSERT;
}
Cbuf_ExecuteText( args[1], VMA(2) );
return 0;
case UI_FS_FOPENFILE:
return FS_FOpenFileByMode( VMA(1), VMA(2), args[3] );
case UI_FS_READ:
FS_Read2( VMA(1), args[2], args[3] );
return 0;
case UI_FS_WRITE:
FS_Write( VMA(1), args[2], args[3] );
return 0;
case UI_FS_FCLOSEFILE:
FS_FCloseFile( args[1] );
return 0;
case UI_FS_GETFILELIST:
return FS_GetFileList( VMA(1), VMA(2), VMA(3), args[4] );
case UI_FS_SEEK:
return FS_Seek( args[1], args[2], args[3] );
case UI_R_REGISTERMODEL:
return re.RegisterModel( VMA(1) );
case UI_R_REGISTERSKIN:
return re.RegisterSkin( VMA(1) );
case UI_R_REGISTERSHADERNOMIP:
return re.RegisterShaderNoMip( VMA(1) );
case UI_R_CLEARSCENE:
re.ClearScene();
return 0;
case UI_R_ADDREFENTITYTOSCENE:
re.AddRefEntityToScene( VMA(1) );
return 0;
case UI_R_ADDPOLYTOSCENE:
re.AddPolyToScene( args[1], args[2], VMA(3), 1 );
return 0;
case UI_R_ADDLIGHTTOSCENE:
re.AddLightToScene( VMA(1), VMF(2), VMF(3), VMF(4), VMF(5) );
return 0;
case UI_R_RENDERSCENE:
re.RenderScene( VMA(1) );
return 0;
case UI_R_SETCOLOR:
re.SetColor( VMA(1) );
return 0;
case UI_R_DRAWSTRETCHPIC:
re.DrawStretchPic( VMF(1), VMF(2), VMF(3), VMF(4), VMF(5), VMF(6), VMF(7), VMF(8), args[9] );
return 0;
case UI_R_MODELBOUNDS:
re.ModelBounds( args[1], VMA(2), VMA(3) );
return 0;
case UI_UPDATESCREEN:
SCR_UpdateScreen();
return 0;
case UI_CM_LERPTAG:
re.LerpTag( VMA(1), args[2], args[3], args[4], VMF(5), VMA(6) );
return 0;
case UI_S_REGISTERSOUND:
return S_RegisterSound( VMA(1), args[2] );
case UI_S_STARTLOCALSOUND:
S_StartLocalSound( args[1], args[2] );
return 0;
case UI_KEY_KEYNUMTOSTRINGBUF:
Key_KeynumToStringBuf( args[1], VMA(2), args[3] );
return 0;
case UI_KEY_GETBINDINGBUF:
Key_GetBindingBuf( args[1], VMA(2), args[3] );
return 0;
case UI_KEY_SETBINDING:
Key_SetBinding( args[1], VMA(2) );
return 0;
case UI_KEY_ISDOWN:
return Key_IsDown( args[1] );
case UI_KEY_GETOVERSTRIKEMODE:
return Key_GetOverstrikeMode();
case UI_KEY_SETOVERSTRIKEMODE:
Key_SetOverstrikeMode( args[1] );
return 0;
case UI_KEY_CLEARSTATES:
Key_ClearStates();
return 0;
case UI_KEY_GETCATCHER:
return Key_GetCatcher();
case UI_KEY_SETCATCHER:
// Don't allow the ui module to close the console
Key_SetCatcher( args[1] | ( Key_GetCatcher( ) & KEYCATCH_CONSOLE ) );
return 0;
case UI_GETCLIPBOARDDATA:
CL_GetClipboardData( VMA(1), args[2] );
return 0;
case UI_GETCLIENTSTATE:
GetClientState( VMA(1) );
return 0;
case UI_GETGLCONFIG:
CL_GetGlconfig( VMA(1) );
return 0;
case UI_GETCONFIGSTRING:
return GetConfigString( args[1], VMA(2), args[3] );
case UI_LAN_LOADCACHEDSERVERS:
LAN_LoadCachedServers();
return 0;
case UI_LAN_SAVECACHEDSERVERS:
LAN_SaveServersToCache();
return 0;
case UI_LAN_ADDSERVER:
return LAN_AddServer(args[1], VMA(2), VMA(3));
case UI_LAN_REMOVESERVER:
LAN_RemoveServer(args[1], VMA(2));
return 0;
case UI_LAN_GETPINGQUEUECOUNT:
return LAN_GetPingQueueCount();
case UI_LAN_CLEARPING:
LAN_ClearPing( args[1] );
return 0;
case UI_LAN_GETPING:
LAN_GetPing( args[1], VMA(2), args[3], VMA(4) );
return 0;
case UI_LAN_GETPINGINFO:
LAN_GetPingInfo( args[1], VMA(2), args[3] );
return 0;
case UI_LAN_GETSERVERCOUNT:
return LAN_GetServerCount(args[1]);
case UI_LAN_GETSERVERADDRESSSTRING:
LAN_GetServerAddressString( args[1], args[2], VMA(3), args[4] );
return 0;
case UI_LAN_GETSERVERINFO:
LAN_GetServerInfo( args[1], args[2], VMA(3), args[4] );
return 0;
case UI_LAN_GETSERVERPING:
return LAN_GetServerPing( args[1], args[2] );
case UI_LAN_MARKSERVERVISIBLE:
LAN_MarkServerVisible( args[1], args[2], args[3] );
return 0;
case UI_LAN_SERVERISVISIBLE:
return LAN_ServerIsVisible( args[1], args[2] );
case UI_LAN_UPDATEVISIBLEPINGS:
return LAN_UpdateVisiblePings( args[1] );
case UI_LAN_RESETPINGS:
LAN_ResetPings( args[1] );
return 0;
case UI_LAN_SERVERSTATUS:
return LAN_GetServerStatus( VMA(1), VMA(2), args[3] );
case UI_LAN_COMPARESERVERS:
return LAN_CompareServers( args[1], args[2], args[3], args[4], args[5] );
case UI_MEMORY_REMAINING:
return Hunk_MemoryRemaining();
case UI_SET_PBCLSTATUS:
return 0;
case UI_CROSSHAIR_PLAYER:
return VM_Call( cgvm, CG_CROSSHAIR_PLAYER );
case UI_LAST_ATTACKER:
return VM_Call( cgvm, CG_LAST_ATTACKER );
case UI_R_REGISTERFONT:
re.RegisterFont( VMA(1), args[2], VMA(3));
return 0;
case UI_MEMSET:
Com_Memset( VMA(1), args[2], args[3] );
return 0;
case UI_MEMCPY:
Com_Memcpy( VMA(1), VMA(2), args[3] );
return 0;
case UI_STRNCPY:
strncpy( VMA(1), VMA(2), args[3] );
return args[1];
case UI_SIN:
return FloatAsInt( sin( VMF(1) ) );
case UI_COS:
return FloatAsInt( cos( VMF(1) ) );
case UI_ATAN2:
return FloatAsInt( atan2( VMF(1), VMF(2) ) );
case UI_SQRT:
return FloatAsInt( sqrt( VMF(1) ) );
case UI_FLOOR:
return FloatAsInt( floor( VMF(1) ) );
case UI_CEIL:
return FloatAsInt( ceil( VMF(1) ) );
case UI_PC_ADD_GLOBAL_DEFINE:
return botlib_export->PC_AddGlobalDefine( VMA(1) );
case UI_PC_LOAD_SOURCE:
return botlib_export->PC_LoadSourceHandle( VMA(1) );
case UI_PC_FREE_SOURCE:
return botlib_export->PC_FreeSourceHandle( args[1] );
case UI_PC_READ_TOKEN:
return botlib_export->PC_ReadTokenHandle( args[1], VMA(2) );
case UI_PC_SOURCE_FILE_AND_LINE:
return botlib_export->PC_SourceFileAndLine( args[1], VMA(2), VMA(3) );
case UI_S_STOPBACKGROUNDTRACK:
S_StopBackgroundTrack();
return 0;
case UI_S_STARTBACKGROUNDTRACK:
S_StartBackgroundTrack( VMA(1), VMA(2));
return 0;
case UI_REAL_TIME:
return Com_RealTime( VMA(1) );
case UI_CIN_PLAYCINEMATIC:
Com_DPrintf("UI_CIN_PlayCinematic\n");
return CIN_PlayCinematic(VMA(1), args[2], args[3], args[4], args[5], args[6]);
case UI_CIN_STOPCINEMATIC:
return CIN_StopCinematic(args[1]);
case UI_CIN_RUNCINEMATIC:
return CIN_RunCinematic(args[1]);
case UI_CIN_DRAWCINEMATIC:
CIN_DrawCinematic(args[1]);
return 0;
case UI_CIN_SETEXTENTS:
CIN_SetExtents(args[1], args[2], args[3], args[4], args[5]);
return 0;
case UI_R_REMAP_SHADER:
re.RemapShader( VMA(1), VMA(2), VMA(3) );
return 0;
default:
Com_Error( ERR_DROP, "Bad UI system trap: %ld", (long int) args[0] );
}
return 0;
}
/**
* @brief A download message has been received from the server
*/
void CL_ParseDownload(msg_t *msg)
{
int size;
unsigned char data[MAX_MSGLEN];
int block;
if (!*cls.download.downloadTempName)
{
Com_Printf("Server sending download, but no download was requested\n");
CL_AddReliableCommand("stopdl");
return;
}
// read the data
block = MSG_ReadShort(msg);
// unfortunately DLTYPE_WWW is -1 FIXME: change this someday!
//if (block < 0)
//{
//Com_Error(ERR_DROP, "CL_ParseDownload: Server sending invalid download data");
//}
// www dl, if we haven't acknowledged the download redirect yet
if (block == DLTYPE_WWW)
{
if (!cls.download.bWWWDl)
{
// server is sending us a www download
Q_strncpyz(cls.download.originalDownloadName, cls.download.downloadName, sizeof(cls.download.originalDownloadName));
Q_strncpyz(cls.download.downloadName, MSG_ReadString(msg), sizeof(cls.download.downloadName));
cls.download.downloadSize = MSG_ReadLong(msg);
cls.download.downloadFlags = MSG_ReadLong(msg);
if (cls.download.downloadFlags & (1 << DL_FLAG_URL))
{
Sys_OpenURL(cls.download.downloadName, qtrue);
Cbuf_ExecuteText(EXEC_APPEND, "quit\n");
CL_AddReliableCommand("wwwdl bbl8r"); // not sure if that's the right msg
cls.download.bWWWDlAborting = qtrue;
return;
}
Cvar_SetValue("cl_downloadSize", cls.download.downloadSize);
Com_DPrintf("Server redirected download: %s\n", cls.download.downloadName);
cls.download.bWWWDl = qtrue; // activate wwwdl client loop
CL_AddReliableCommand("wwwdl ack");
// make sure the server is not trying to redirect us again on a bad checksum
if (strstr(cls.download.badChecksumList, va("@%s", cls.download.originalDownloadName)))
{
Com_Printf("refusing redirect to %s by server (bad checksum)\n", cls.download.downloadName);
CL_AddReliableCommand("wwwdl fail");
cls.download.bWWWDlAborting = qtrue;
return;
}
// make downloadTempName an OS path
Q_strncpyz(cls.download.downloadTempName, FS_BuildOSPath(Cvar_VariableString("fs_homepath"), cls.download.downloadTempName, ""), sizeof(cls.download.downloadTempName));
cls.download.downloadTempName[strlen(cls.download.downloadTempName) - 1] = '\0';
if (!DL_BeginDownload(cls.download.downloadTempName, cls.download.downloadName))
{
// setting bWWWDl to false after sending the wwwdl fail doesn't work
// not sure why, but I suspect we have to eat all remaining block -1 that the server has sent us
// still leave a flag so that CL_WWWDownload is inactive
// we count on server sending us a gamestate to start up clean again
CL_AddReliableCommand("wwwdl fail");
cls.download.bWWWDlAborting = qtrue;
Com_Printf("Failed to initialize download for '%s'\n", cls.download.downloadName);
}
// Check for a disconnected download
// we'll let the server disconnect us when it gets the bbl8r message
if (cls.download.downloadFlags & (1 << DL_FLAG_DISCON))
{
CL_AddReliableCommand("wwwdl bbl8r");
cls.download.bWWWDlDisconnected = qtrue;
}
return;
}
else
{
// server keeps sending that message till we acknowledge it, eat and ignore
//MSG_ReadLong( msg );
MSG_ReadString(msg);
MSG_ReadLong(msg);
MSG_ReadLong(msg);
return;
}
}
if (!block)
{
// block zero is special, contains file size
cls.download.downloadSize = MSG_ReadLong(msg);
Cvar_SetValue("cl_downloadSize", cls.download.downloadSize);
if (cls.download.downloadSize < 0)
{
Com_Error(ERR_DROP, "%s", MSG_ReadString(msg));
return;
}
}
size = MSG_ReadShort(msg);
if (size < 0 || size > sizeof(data))
{
Com_Error(ERR_DROP, "CL_ParseDownload: Invalid size %d for download chunk.", size);
return;
}
MSG_ReadData(msg, data, size);
if (cls.download.downloadBlock != block)
{
Com_DPrintf("CL_ParseDownload: Expected block %d, got %d\n", cls.download.downloadBlock, block);
return;
}
// open the file if not opened yet
if (!cls.download.download)
{
cls.download.download = FS_SV_FOpenFileWrite(cls.download.downloadTempName);
if (!cls.download.download)
{
Com_Printf("Could not create %s\n", cls.download.downloadTempName);
CL_AddReliableCommand("stopdl");
Com_NextDownload();
return;
}
}
if (size)
{
FS_Write(data, size, cls.download.download);
}
CL_AddReliableCommand(va("nextdl %d", cls.download.downloadBlock));
cls.download.downloadBlock++;
cls.download.downloadCount += size;
// So UI gets access to it
Cvar_SetValue("cl_downloadCount", cls.download.downloadCount);
if (!size) // A zero length block means EOF
{
if (cls.download.download)
{
FS_FCloseFile(cls.download.download);
cls.download.download = 0;
// rename the file
FS_SV_Rename(cls.download.downloadTempName, cls.download.downloadName);
}
*cls.download.downloadTempName = *cls.download.downloadName = 0;
Cvar_Set("cl_downloadName", "");
// send intentions now
// We need this because without it, we would hold the last nextdl and then start
// loading right away. If we take a while to load, the server is happily trying
// to send us that last block over and over.
// Write it twice to help make sure we acknowledge the download
CL_WritePacket();
CL_WritePacket();
// get another file if needed
Com_NextDownload();
}
}
/*
====================
CL_CgameSystemCalls
The cgame module is making a system call
====================
*/
intptr_t CL_CgameSystemCalls( intptr_t *args )
{
switch ( args[ 0 ] )
{
case CG_PRINT:
Com_Printf( "%s", ( char * ) VMA( 1 ) );
return 0;
case CG_ERROR:
Com_Error( ERR_DROP, "%s", ( char * ) VMA( 1 ) );
return 0; //silence warning and have a fallback behavior if Com_Error behavior changes
case CG_LOG:
Com_LogEvent( VMA( 1 ), NULL );
return 0;
case CG_MILLISECONDS:
return Sys_Milliseconds();
case CG_CVAR_REGISTER:
Cvar_Register( VMA( 1 ), VMA( 2 ), VMA( 3 ), args[ 4 ] );
return 0;
case CG_CVAR_UPDATE:
Cvar_Update( VMA( 1 ) );
return 0;
case CG_CVAR_SET:
Cvar_Set( VMA( 1 ), VMA( 2 ) );
return 0;
case CG_CVAR_VARIABLESTRINGBUFFER:
VM_CheckBlock( args[2], args[3], "CVARVSB" );
Cvar_VariableStringBuffer( VMA( 1 ), VMA( 2 ), args[ 3 ] );
return 0;
case CG_CVAR_LATCHEDVARIABLESTRINGBUFFER:
VM_CheckBlock( args[2], args[3], "CVARLVSB" );
Cvar_LatchedVariableStringBuffer( VMA( 1 ), VMA( 2 ), args[ 3 ] );
return 0;
case CG_CVAR_VARIABLEINTEGERVALUE:
return Cvar_VariableIntegerValue( VMA( 1 ) );
case CG_ARGC:
return Cmd_Argc();
case CG_ARGV:
VM_CheckBlock( args[2], args[3], "ARGV" );
Cmd_ArgvBuffer( args[ 1 ], VMA( 2 ), args[ 3 ] );
return 0;
case CG_ARGS:
VM_CheckBlock( args[1], args[2], "ARGS" );
Cmd_ArgsBuffer( VMA( 1 ), args[ 2 ] );
return 0;
case CG_LITERAL_ARGS:
// FIXME
VM_CheckBlock( args[1], args[2], "LARGS" );
Cmd_LiteralArgsBuffer( VMA( 1 ), args[ 2 ] );
// Cmd_ArgsBuffer(VMA(1), args[2]);
return 0;
case CG_GETDEMOSTATE:
return CL_DemoState();
case CG_GETDEMOPOS:
return CL_DemoPos();
case CG_FS_FOPENFILE:
return FS_FOpenFileByMode( VMA( 1 ), VMA( 2 ), args[ 3 ] );
case CG_FS_READ:
VM_CheckBlock( args[1], args[2], "FSREAD" );
FS_Read( VMA( 1 ), args[ 2 ], args[ 3 ] );
return 0;
case CG_FS_WRITE:
VM_CheckBlock( args[1], args[2], "FSWRITE" );
return FS_Write( VMA( 1 ), args[ 2 ], args[ 3 ] );
case CG_FS_FCLOSEFILE:
FS_FCloseFile( args[ 1 ] );
return 0;
case CG_FS_GETFILELIST:
VM_CheckBlock( args[3], args[4], "FSGFL" );
return FS_GetFileList( VMA( 1 ), VMA( 2 ), VMA( 3 ), args[ 4 ] );
case CG_FS_DELETEFILE:
return FS_Delete( VMA( 1 ) );
case CG_SENDCONSOLECOMMAND:
Cbuf_AddText( VMA( 1 ) );
return 0;
case CG_ADDCOMMAND:
CL_AddCgameCommand( VMA( 1 ) );
return 0;
case CG_REMOVECOMMAND:
Cmd_RemoveCommand( VMA( 1 ) );
return 0;
case CG_COMPLETE_CALLBACK:
if ( completer )
{
completer( VMA( 1 ) );
}
return 0;
case CG_SENDCLIENTCOMMAND:
CL_AddReliableCommand( VMA( 1 ) );
return 0;
case CG_UPDATESCREEN:
SCR_UpdateScreen();
return 0;
case CG_CM_LOADMAP:
CL_CM_LoadMap( VMA( 1 ) );
return 0;
case CG_CM_NUMINLINEMODELS:
return CM_NumInlineModels();
case CG_CM_INLINEMODEL:
return CM_InlineModel( args[ 1 ] );
case CG_CM_TEMPBOXMODEL:
return CM_TempBoxModel( VMA( 1 ), VMA( 2 ), qfalse );
case CG_CM_TEMPCAPSULEMODEL:
return CM_TempBoxModel( VMA( 1 ), VMA( 2 ), qtrue );
case CG_CM_POINTCONTENTS:
return CM_PointContents( VMA( 1 ), args[ 2 ] );
case CG_CM_TRANSFORMEDPOINTCONTENTS:
return CM_TransformedPointContents( VMA( 1 ), args[ 2 ], VMA( 3 ), VMA( 4 ) );
case CG_CM_BOXTRACE:
CM_BoxTrace( VMA( 1 ), VMA( 2 ), VMA( 3 ), VMA( 4 ), VMA( 5 ), args[ 6 ], args[ 7 ], TT_AABB );
return 0;
case CG_CM_TRANSFORMEDBOXTRACE:
CM_TransformedBoxTrace( VMA( 1 ), VMA( 2 ), VMA( 3 ), VMA( 4 ), VMA( 5 ), args[ 6 ], args[ 7 ], VMA( 8 ), VMA( 9 ), TT_AABB );
return 0;
case CG_CM_CAPSULETRACE:
CM_BoxTrace( VMA( 1 ), VMA( 2 ), VMA( 3 ), VMA( 4 ), VMA( 5 ), args[ 6 ], args[ 7 ], TT_CAPSULE );
return 0;
case CG_CM_TRANSFORMEDCAPSULETRACE:
CM_TransformedBoxTrace( VMA( 1 ), VMA( 2 ), VMA( 3 ), VMA( 4 ), VMA( 5 ), args[ 6 ], args[ 7 ], VMA( 8 ), VMA( 9 ), TT_CAPSULE );
return 0;
case CG_CM_BISPHERETRACE:
CM_BiSphereTrace( VMA( 1 ), VMA( 2 ), VMA( 3 ), VMF( 4 ), VMF( 5 ), args[ 6 ], args[ 7 ] );
return 0;
case CG_CM_TRANSFORMEDBISPHERETRACE:
CM_TransformedBiSphereTrace( VMA( 1 ), VMA( 2 ), VMA( 3 ), VMF( 4 ), VMF( 5 ), args[ 6 ], args[ 7 ], VMA( 8 ) );
return 0;
case CG_CM_MARKFRAGMENTS:
return re.MarkFragments( args[ 1 ], VMA( 2 ), VMA( 3 ), args[ 4 ], VMA( 5 ), args[ 6 ], VMA( 7 ) );
case CG_R_PROJECTDECAL:
re.ProjectDecal( args[ 1 ], args[ 2 ], VMA( 3 ), VMA( 4 ), VMA( 5 ), args[ 6 ], args[ 7 ] );
return 0;
case CG_R_CLEARDECALS:
re.ClearDecals();
return 0;
case CG_S_STARTSOUND:
S_StartSound( VMA( 1 ), args[ 2 ], args[ 3 ], args[ 4 ] );
return 0;
case CG_S_STARTSOUNDEX:
S_StartSoundEx( VMA( 1 ), args[ 2 ], args[ 3 ], args[ 4 ] );
return 0;
case CG_S_STARTLOCALSOUND:
S_StartLocalSound( args[ 1 ], args[ 2 ] );
return 0;
case CG_S_CLEARLOOPINGSOUNDS:
S_ClearLoopingSounds( args[ 1 ] );
return 0;
case CG_S_CLEARSOUNDS:
/*if(args[1] == 0)
{
S_ClearSounds(qtrue, qfalse);
}
else if(args[1] == 1)
{
S_ClearSounds(qtrue, qtrue);
}*/
return 0;
case CG_S_ADDLOOPINGSOUND:
S_AddLoopingSound( args[ 1 ], VMA( 2 ), VMA( 3 ), args[ 4 ] );
return 0;
case CG_S_ADDREALLOOPINGSOUND:
S_AddRealLoopingSound( args[ 1 ], VMA( 2 ), VMA( 3 ), args[ 4 ] );
return 0;
case CG_S_STOPLOOPINGSOUND:
S_StopLoopingSound( args[ 1 ] );
return 0;
case CG_S_STOPSTREAMINGSOUND:
// FIXME
//S_StopEntStreamingSound(args[1]);
return 0;
case CG_S_UPDATEENTITYPOSITION:
S_UpdateEntityPosition( args[ 1 ], VMA( 2 ) );
return 0;
case CG_S_GETVOICEAMPLITUDE:
return S_GetVoiceAmplitude( args[ 1 ] );
case CG_S_GETSOUNDLENGTH:
return S_GetSoundLength( args[ 1 ] );
// ydnar: for looped sound starts
case CG_S_GETCURRENTSOUNDTIME:
return S_GetCurrentSoundTime();
case CG_S_RESPATIALIZE:
S_Respatialize( args[ 1 ], VMA( 2 ), VMA( 3 ), args[ 4 ] );
return 0;
case CG_S_REGISTERSOUND:
#ifdef DOOMSOUND ///// (SA) DOOMSOUND
return S_RegisterSound( VMA( 1 ) );
#else
return S_RegisterSound( VMA( 1 ), args[ 2 ] );
#endif ///// (SA) DOOMSOUND
case CG_S_STARTBACKGROUNDTRACK:
//S_StartBackgroundTrack(VMA(1), VMA(2), args[3]); //----(SA) added fadeup time
S_StartBackgroundTrack( VMA( 1 ), VMA( 2 ) );
return 0;
case CG_S_FADESTREAMINGSOUND:
// FIXME
//S_FadeStreamingSound(VMF(1), args[2], args[3]); //----(SA) added music/all-streaming options
return 0;
case CG_S_STARTSTREAMINGSOUND:
// FIXME
//return S_StartStreamingSound(VMA(1), VMA(2), args[3], args[4], args[5]);
return 0;
case CG_R_LOADWORLDMAP:
re.SetWorldVisData( CM_ClusterPVS( -1 ) );
re.LoadWorld( VMA( 1 ) );
return 0;
case CG_R_REGISTERMODEL:
return re.RegisterModel( VMA( 1 ) );
case CG_R_REGISTERSKIN:
return re.RegisterSkin( VMA( 1 ) );
//----(SA) added
case CG_R_GETSKINMODEL:
return re.GetSkinModel( args[ 1 ], VMA( 2 ), VMA( 3 ) );
case CG_R_GETMODELSHADER:
return re.GetShaderFromModel( args[ 1 ], args[ 2 ], args[ 3 ] );
//----(SA) end
case CG_R_REGISTERSHADER:
return re.RegisterShader( VMA( 1 ), args[ 2 ] );
case CG_R_REGISTERFONT:
re.RegisterFontVM( VMA( 1 ), VMA( 2 ), args[ 3 ], VMA( 4 ) );
return 0;
case CG_R_CLEARSCENE:
re.ClearScene();
return 0;
case CG_R_ADDREFENTITYTOSCENE:
re.AddRefEntityToScene( VMA( 1 ) );
return 0;
#if defined( USE_REFLIGHT )
case CG_R_ADDREFLIGHTSTOSCENE:
re.AddRefLightToScene( VMA( 1 ) );
return 0;
#endif
case CG_R_ADDPOLYTOSCENE:
re.AddPolyToScene( args[ 1 ], args[ 2 ], VMA( 3 ) );
return 0;
case CG_R_ADDPOLYSTOSCENE:
re.AddPolysToScene( args[ 1 ], args[ 2 ], VMA( 3 ), args[ 4 ] );
return 0;
case CG_R_ADDPOLYBUFFERTOSCENE:
re.AddPolyBufferToScene( VMA( 1 ) );
return 0;
case CG_R_ADDLIGHTTOSCENE:
re.AddLightToScene( VMA( 1 ), VMF( 2 ), VMF( 3 ), VMF( 4 ), VMF( 5 ), VMF( 6 ), args[ 7 ], args[ 8 ] );
return 0;
case CG_R_ADDADDITIVELIGHTTOSCENE:
re.AddAdditiveLightToScene( VMA( 1 ), VMF( 2 ), VMF( 3 ), VMF( 4 ), VMF( 5 ) );
return 0;
case CG_FS_SEEK:
return FS_Seek( args[ 1 ], args[ 2 ], args[ 3 ] );
case CG_R_ADDCORONATOSCENE:
re.AddCoronaToScene( VMA( 1 ), VMF( 2 ), VMF( 3 ), VMF( 4 ), VMF( 5 ), args[ 6 ], args[ 7 ] );
return 0;
case CG_R_SETFOG:
re.SetFog( args[ 1 ], args[ 2 ], args[ 3 ], VMF( 4 ), VMF( 5 ), VMF( 6 ), VMF( 7 ) );
return 0;
case CG_R_SETGLOBALFOG:
re.SetGlobalFog( args[ 1 ], args[ 2 ], VMF( 3 ), VMF( 4 ), VMF( 5 ), VMF( 6 ) );
return 0;
case CG_R_RENDERSCENE:
re.RenderScene( VMA( 1 ) );
return 0;
case CG_R_SAVEVIEWPARMS:
re.SaveViewParms();
return 0;
case CG_R_RESTOREVIEWPARMS:
re.RestoreViewParms();
return 0;
case CG_R_SETCOLOR:
re.SetColor( VMA( 1 ) );
return 0;
// Tremulous
case CG_R_SETCLIPREGION:
re.SetClipRegion( VMA( 1 ) );
return 0;
case CG_R_DRAWSTRETCHPIC:
re.DrawStretchPic( VMF( 1 ), VMF( 2 ), VMF( 3 ), VMF( 4 ), VMF( 5 ), VMF( 6 ), VMF( 7 ), VMF( 8 ), args[ 9 ] );
return 0;
case CG_R_DRAWROTATEDPIC:
re.DrawRotatedPic( VMF( 1 ), VMF( 2 ), VMF( 3 ), VMF( 4 ), VMF( 5 ), VMF( 6 ), VMF( 7 ), VMF( 8 ), args[ 9 ], VMF( 10 ) );
return 0;
case CG_R_DRAWSTRETCHPIC_GRADIENT:
re.DrawStretchPicGradient( VMF( 1 ), VMF( 2 ), VMF( 3 ), VMF( 4 ), VMF( 5 ), VMF( 6 ), VMF( 7 ), VMF( 8 ), args[ 9 ], VMA( 10 ), args[ 11 ] );
return 0;
case CG_R_DRAW2DPOLYS:
re.Add2dPolys( VMA( 1 ), args[ 2 ], args[ 3 ] );
return 0;
case CG_R_MODELBOUNDS:
re.ModelBounds( args[ 1 ], VMA( 2 ), VMA( 3 ) );
return 0;
case CG_R_LERPTAG:
return re.LerpTag( VMA( 1 ), VMA( 2 ), VMA( 3 ), args[ 4 ] );
case CG_GETGLCONFIG:
CL_GetGlconfig( VMA( 1 ) );
return 0;
case CG_GETGAMESTATE:
CL_GetGameState( VMA( 1 ) );
return 0;
case CG_GETCURRENTSNAPSHOTNUMBER:
CL_GetCurrentSnapshotNumber( VMA( 1 ), VMA( 2 ) );
return 0;
case CG_GETSNAPSHOT:
return CL_GetSnapshot( args[ 1 ], VMA( 2 ) );
case CG_GETSERVERCOMMAND:
return CL_GetServerCommand( args[ 1 ] );
case CG_GETCURRENTCMDNUMBER:
return CL_GetCurrentCmdNumber();
case CG_GETUSERCMD:
return CL_GetUserCmd( args[ 1 ], VMA( 2 ) );
case CG_SETUSERCMDVALUE:
CL_SetUserCmdValue( args[ 1 ], args[ 2 ], VMF( 3 ), args[ 4 ] );
return 0;
case CG_SETCLIENTLERPORIGIN:
CL_SetClientLerpOrigin( VMF( 1 ), VMF( 2 ), VMF( 3 ) );
return 0;
case CG_MEMORY_REMAINING:
return Hunk_MemoryRemaining();
case CG_KEY_ISDOWN:
return Key_IsDown( args[ 1 ] );
case CG_KEY_GETCATCHER:
return Key_GetCatcher();
case CG_KEY_SETCATCHER:
Key_SetCatcher( args[ 1 ] );
return 0;
case CG_KEY_GETKEY:
return Key_GetKey( VMA( 1 ), 0 ); // FIXME BIND
case CG_KEY_GETOVERSTRIKEMODE:
return Key_GetOverstrikeMode();
case CG_KEY_SETOVERSTRIKEMODE:
Key_SetOverstrikeMode( args[ 1 ] );
return 0;
case CG_S_STOPBACKGROUNDTRACK:
S_StopBackgroundTrack();
return 0;
case CG_REAL_TIME:
return Com_RealTime( VMA( 1 ) );
case CG_SNAPVECTOR:
Q_SnapVector( VMA( 1 ) );
return 0;
case CG_CIN_PLAYCINEMATIC:
return CIN_PlayCinematic( VMA( 1 ), args[ 2 ], args[ 3 ], args[ 4 ], args[ 5 ], args[ 6 ] );
case CG_CIN_STOPCINEMATIC:
return CIN_StopCinematic( args[ 1 ] );
case CG_CIN_RUNCINEMATIC:
return CIN_RunCinematic( args[ 1 ] );
case CG_CIN_DRAWCINEMATIC:
CIN_DrawCinematic( args[ 1 ] );
return 0;
case CG_CIN_SETEXTENTS:
CIN_SetExtents( args[ 1 ], args[ 2 ], args[ 3 ], args[ 4 ], args[ 5 ] );
return 0;
case CG_R_REMAP_SHADER:
re.RemapShader( VMA( 1 ), VMA( 2 ), VMA( 3 ) );
return 0;
case CG_GET_ENTITY_TOKEN:
VM_CheckBlock( args[1], args[2], "GETET" );
return re.GetEntityToken( VMA( 1 ), args[ 2 ] );
case CG_INGAME_POPUP:
if ( cls.state == CA_ACTIVE && !clc.demoplaying )
{
if ( uivm )
{
// Gordon: can be called as the system is shutting down
VM_Call( uivm, UI_SET_ACTIVE_MENU, args[ 1 ] );
}
}
return 0;
case CG_INGAME_CLOSEPOPUP:
return 0;
case CG_KEY_GETBINDINGBUF:
VM_CheckBlock( args[3], args[4], "KEYGBB" );
Key_GetBindingBuf( args[ 1 ], args[ 2 ], VMA( 3 ), args[ 4 ] );
return 0;
case CG_KEY_SETBINDING:
Key_SetBinding( args[ 1 ], args[ 2 ], VMA( 3 ) ); // FIXME BIND
return 0;
case CG_PARSE_ADD_GLOBAL_DEFINE:
return Parse_AddGlobalDefine( VMA( 1 ) );
case CG_PARSE_LOAD_SOURCE:
return Parse_LoadSourceHandle( VMA( 1 ) );
case CG_PARSE_FREE_SOURCE:
return Parse_FreeSourceHandle( args[ 1 ] );
case CG_PARSE_READ_TOKEN:
return Parse_ReadTokenHandle( args[ 1 ], VMA( 2 ) );
case CG_PARSE_SOURCE_FILE_AND_LINE:
return Parse_SourceFileAndLine( args[ 1 ], VMA( 2 ), VMA( 3 ) );
case CG_KEY_KEYNUMTOSTRINGBUF:
VM_CheckBlock( args[2], args[3], "KEYNTSB" );
Key_KeynumToStringBuf( args[ 1 ], VMA( 2 ), args[ 3 ] );
return 0;
case CG_S_FADEALLSOUNDS:
// FIXME
//S_FadeAllSounds(VMF(1), args[2], args[3]);
return 0;
case CG_R_INPVS:
return re.inPVS( VMA( 1 ), VMA( 2 ) );
case CG_R_INPVVS:
return re.inPVVS( VMA( 1 ), VMA( 2 ) );
case CG_GETHUNKDATA:
Com_GetHunkInfo( VMA( 1 ), VMA( 2 ) );
return 0;
//bani - dynamic shaders
case CG_R_LOADDYNAMICSHADER:
return re.LoadDynamicShader( VMA( 1 ), VMA( 2 ) );
// fretn - render to texture
case CG_R_RENDERTOTEXTURE:
re.RenderToTexture( args[ 1 ], args[ 2 ], args[ 3 ], args[ 4 ], args[ 5 ] );
return 0;
//bani
case CG_R_GETTEXTUREID:
return re.GetTextureId( VMA( 1 ) );
//bani - flush gl rendering buffers
case CG_R_FINISH:
re.Finish();
return 0;
case CG_GETDEMONAME:
VM_CheckBlock( args[1], args[2], "GETDM" );
CL_DemoName( VMA( 1 ), args[ 2 ] );
return 0;
case CG_R_LIGHTFORPOINT:
return re.LightForPoint( VMA( 1 ), VMA( 2 ), VMA( 3 ), VMA( 4 ) );
case CG_S_SOUNDDURATION:
return S_SoundDuration( args[ 1 ] );
#if defined( USE_REFENTITY_ANIMATIONSYSTEM )
case CG_R_REGISTERANIMATION:
return re.RegisterAnimation( VMA( 1 ) );
case CG_R_CHECKSKELETON:
return re.CheckSkeleton( VMA( 1 ), args[ 2 ], args[ 3 ] );
case CG_R_BUILDSKELETON:
return re.BuildSkeleton( VMA( 1 ), args[ 2 ], args[ 3 ], args[ 4 ], VMF( 5 ), args[ 6 ] );
case CG_R_BLENDSKELETON:
return re.BlendSkeleton( VMA( 1 ), VMA( 2 ), VMF( 3 ) );
case CG_R_BONEINDEX:
return re.BoneIndex( args[ 1 ], VMA( 2 ) );
case CG_R_ANIMNUMFRAMES:
return re.AnimNumFrames( args[ 1 ] );
case CG_R_ANIMFRAMERATE:
return re.AnimFrameRate( args[ 1 ] );
#endif
case CG_REGISTER_BUTTON_COMMANDS:
CL_RegisterButtonCommands( VMA( 1 ) );
return 0;
case CG_GETCLIPBOARDDATA:
VM_CheckBlock( args[1], args[2], "GETCLIP" );
if ( cl_allowPaste->integer )
{
CL_GetClipboardData( VMA(1), args[2], args[3] );
}
else
{
( (char *) VMA( 1 ) )[0] = '\0';
}
return 0;
case CG_QUOTESTRING:
VM_CheckBlock( args[ 2 ], args[ 3 ], "QUOTE" );
Cmd_QuoteStringBuffer( VMA( 1 ), VMA( 2 ), args[ 3 ] );
return 0;
case CG_GETTEXT:
VM_CheckBlock( args[ 1 ], args[ 3 ], "CGGETTEXT" );
Q_strncpyz( VMA(1), __( VMA( 2 ) ), args[3] );
return 0;
case CG_PGETTEXT:
VM_CheckBlock( args[ 1 ], args[ 4 ], "CGPGETTEXT" );
Q_strncpyz( VMA( 1 ), C__( VMA( 2 ), VMA( 3 ) ), args[ 4 ] );
return 0;
case CG_GETTEXT_PLURAL:
VM_CheckBlock( args[ 1 ], args[ 5 ], "CGGETTEXTP" );
Q_strncpyz( VMA( 1 ), P__( VMA( 2 ), VMA( 3 ), args[ 4 ] ), args[ 5 ] );
return 0;
case CG_R_GLYPH:
re.GlyphVM( args[1], VMA(2), VMA(3) );
return 0;
case CG_R_GLYPHCHAR:
re.GlyphCharVM( args[1], args[2], VMA(3) );
return 0;
case CG_R_UREGISTERFONT:
re.UnregisterFontVM( args[1] );
return 0;
case CG_NOTIFY_TEAMCHANGE:
CL_OnTeamChanged( args[1] );
return 0;
case CG_REGISTERVISTEST:
return re.RegisterVisTest();
case CG_ADDVISTESTTOSCENE:
re.AddVisTestToScene( args[1], VMA(2), VMF(3), VMF(4) );
return 0;
case CG_CHECKVISIBILITY:
return FloatAsInt( re.CheckVisibility( args[1] ) );
case CG_UNREGISTERVISTEST:
re.UnregisterVisTest( args[1] );
return 0;
case CG_SETCOLORGRADING:
re.SetColorGrading( args[1], args[2] );
return 0;
case CG_CM_DISTANCETOMODEL:
return FloatAsInt( CM_DistanceToModel( VMA(1), args[2] ) );
case CG_R_SCISSOR_ENABLE:
re.ScissorEnable( args[1] );
return 0;
case CG_R_SCISSOR_SET:
re.ScissorSet( args[1], args[2], args[3], args[4] );
return 0;
default:
Com_Error( ERR_DROP, "Bad cgame system trap: %ld", ( long int ) args[ 0 ] );
exit(1); // silence warning, and make sure this behaves as expected, if Com_Error's behavior changes
}
return 0;
}
intptr_t CL_UISystemCalls( intptr_t *args ) {
switch ( args[0] ) {
//rww - alright, DO NOT EVER add a GAME/CGAME/UI generic call without adding a trap to match, and
//all of these traps must be shared and have cases in sv_game, cl_cgame, and cl_ui. They must also
//all be in the same order, and start at 100.
case TRAP_MEMSET:
Com_Memset( VMA(1), args[2], args[3] );
return 0;
case TRAP_MEMCPY:
Com_Memcpy( VMA(1), VMA(2), args[3] );
return 0;
case TRAP_STRNCPY:
strncpy( (char *)VMA(1), (const char *)VMA(2), args[3] );
return args[1];
case TRAP_SIN:
return FloatAsInt( sin( VMF(1) ) );
case TRAP_COS:
return FloatAsInt( cos( VMF(1) ) );
case TRAP_ATAN2:
return FloatAsInt( atan2( VMF(1), VMF(2) ) );
case TRAP_SQRT:
return FloatAsInt( sqrt( VMF(1) ) );
case TRAP_MATRIXMULTIPLY:
MatrixMultiply( (vec3_t *)VMA(1), (vec3_t *)VMA(2), (vec3_t *)VMA(3) );
return 0;
case TRAP_ANGLEVECTORS:
AngleVectors( (const float *)VMA(1), (float *)VMA(2), (float *)VMA(3), (float *)VMA(4) );
return 0;
case TRAP_PERPENDICULARVECTOR:
PerpendicularVector( (float *)VMA(1), (const float *)VMA(2) );
return 0;
case TRAP_FLOOR:
return FloatAsInt( floor( VMF(1) ) );
case TRAP_CEIL:
return FloatAsInt( ceil( VMF(1) ) );
case TRAP_TESTPRINTINT:
return 0;
case TRAP_TESTPRINTFLOAT:
return 0;
case TRAP_ACOS:
return FloatAsInt( Q_acos( VMF(1) ) );
case TRAP_ASIN:
return FloatAsInt( Q_asin( VMF(1) ) );
case UI_ERROR:
Com_Error( ERR_DROP, "%s", VMA(1) );
return 0;
case UI_PRINT:
Com_Printf( "%s", VMA(1) );
return 0;
case UI_MILLISECONDS:
return Sys_Milliseconds();
case UI_CVAR_REGISTER:
Cvar_Register( (vmCvar_t *)VMA(1), (const char *)VMA(2), (const char *)VMA(3), args[4] );
return 0;
case UI_CVAR_UPDATE:
Cvar_Update( (vmCvar_t *)VMA(1) );
return 0;
case UI_CVAR_SET:
Cvar_Set( (const char *)VMA(1), (const char *)VMA(2) );
return 0;
case UI_CVAR_VARIABLEVALUE:
return FloatAsInt( Cvar_VariableValue( (const char *)VMA(1) ) );
case UI_CVAR_VARIABLESTRINGBUFFER:
Cvar_VariableStringBuffer( (const char *)VMA(1), (char *)VMA(2), args[3] );
return 0;
case UI_CVAR_SETVALUE:
Cvar_SetValue( (const char *)VMA(1), VMF(2) );
return 0;
case UI_CVAR_RESET:
Cvar_Reset( (const char *)VMA(1) );
return 0;
case UI_CVAR_CREATE:
Cvar_Get( (const char *)VMA(1), (const char *)VMA(2), args[3] );
return 0;
case UI_CVAR_INFOSTRINGBUFFER:
Cvar_InfoStringBuffer( args[1], (char *)VMA(2), args[3] );
return 0;
case UI_ARGC:
return Cmd_Argc();
case UI_ARGV:
Cmd_ArgvBuffer( args[1], (char *)VMA(2), args[3] );
return 0;
case UI_CMD_EXECUTETEXT:
Cbuf_ExecuteText( args[1], (const char *)VMA(2) );
return 0;
case UI_FS_FOPENFILE:
return FS_FOpenFileByMode( (const char *)VMA(1), (int *)VMA(2), (fsMode_t)args[3] );
case UI_FS_READ:
FS_Read2( VMA(1), args[2], args[3] );
return 0;
case UI_FS_WRITE:
FS_Write( VMA(1), args[2], args[3] );
return 0;
case UI_FS_FCLOSEFILE:
FS_FCloseFile( args[1] );
return 0;
case UI_FS_GETFILELIST:
return FS_GetFileList( (const char *)VMA(1), (const char *)VMA(2), (char *)VMA(3), args[4] );
case UI_R_REGISTERMODEL:
return re->RegisterModel( (const char *)VMA(1) );
case UI_R_REGISTERSKIN:
return re->RegisterSkin( (const char *)VMA(1) );
case UI_R_REGISTERSHADERNOMIP:
return re->RegisterShaderNoMip( (const char *)VMA(1) );
case UI_R_SHADERNAMEFROMINDEX:
CL_R_ShaderNameFromIndex( (char *)VMA(1), args[2] );
return 0;
case UI_R_CLEARSCENE:
re->ClearScene();
return 0;
case UI_R_ADDREFENTITYTOSCENE:
re->AddRefEntityToScene( (const refEntity_t *)VMA(1) );
return 0;
case UI_R_ADDPOLYTOSCENE:
re->AddPolyToScene( args[1], args[2], (const polyVert_t *)VMA(3), 1 );
return 0;
case UI_R_ADDLIGHTTOSCENE:
#ifdef VV_LIGHTING
VVLightMan.RE_AddLightToScene( (const float *)VMA(1), VMF(2), VMF(3), VMF(4), VMF(5) );
#else
re->AddLightToScene( (const float *)VMA(1), VMF(2), VMF(3), VMF(4), VMF(5) );
#endif
return 0;
case UI_R_RENDERSCENE:
re->RenderScene( (const refdef_t *)VMA(1) );
return 0;
case UI_R_SETCOLOR:
re->SetColor( (const float *)VMA(1) );
return 0;
case UI_R_DRAWSTRETCHPIC:
re->DrawStretchPic( VMF(1), VMF(2), VMF(3), VMF(4), VMF(5), VMF(6), VMF(7), VMF(8), args[9] );
return 0;
case UI_R_MODELBOUNDS:
re->ModelBounds( args[1], (float *)VMA(2), (float *)VMA(3) );
return 0;
case UI_UPDATESCREEN:
SCR_UpdateScreen();
return 0;
case UI_CM_LERPTAG:
re->LerpTag( (orientation_t *)VMA(1), args[2], args[3], args[4], VMF(5), (const char *)VMA(6) );
return 0;
case UI_S_REGISTERSOUND:
return S_RegisterSound( (const char *)VMA(1) );
case UI_S_STARTLOCALSOUND:
S_StartLocalSound( args[1], args[2] );
return 0;
case UI_KEY_KEYNUMTOSTRINGBUF:
Key_KeynumToStringBuf( args[1], (char *)VMA(2), args[3] );
return 0;
case UI_KEY_GETBINDINGBUF:
Key_GetBindingBuf( args[1], (char *)VMA(2), args[3] );
return 0;
case UI_KEY_SETBINDING:
Key_SetBinding( args[1], (const char *)VMA(2) );
return 0;
case UI_KEY_ISDOWN:
return Key_IsDown( args[1] );
case UI_KEY_GETOVERSTRIKEMODE:
return Key_GetOverstrikeMode();
case UI_KEY_SETOVERSTRIKEMODE:
Key_SetOverstrikeMode( (qboolean)args[1] );
return 0;
case UI_KEY_CLEARSTATES:
Key_ClearStates();
return 0;
case UI_KEY_GETCATCHER:
return Key_GetCatcher();
case UI_KEY_SETCATCHER:
Key_SetCatcher( args[1] );
return 0;
case UI_GETCLIPBOARDDATA:
GetClipboardData( (char *)VMA(1), args[2] );
return 0;
case UI_GETCLIENTSTATE:
CL_GetClientState( (uiClientState_t *)VMA(1) );
return 0;
case UI_GETGLCONFIG:
CL_GetGlconfig( (glconfig_t *)VMA(1) );
return 0;
case UI_GETCONFIGSTRING:
return GetConfigString( args[1], (char *)VMA(2), args[3] );
case UI_LAN_LOADCACHEDSERVERS:
LAN_LoadCachedServers();
return 0;
case UI_LAN_SAVECACHEDSERVERS:
LAN_SaveServersToCache();
return 0;
case UI_LAN_ADDSERVER:
return LAN_AddServer(args[1], (const char *)VMA(2), (const char *)VMA(3));
case UI_LAN_REMOVESERVER:
LAN_RemoveServer(args[1], (const char *)VMA(2));
return 0;
case UI_LAN_GETPINGQUEUECOUNT:
return LAN_GetPingQueueCount();
case UI_LAN_CLEARPING:
LAN_ClearPing( args[1] );
return 0;
case UI_LAN_GETPING:
LAN_GetPing( args[1], (char *)VMA(2), args[3], (int *)VMA(4) );
return 0;
case UI_LAN_GETPINGINFO:
LAN_GetPingInfo( args[1], (char *)VMA(2), args[3] );
return 0;
case UI_LAN_GETSERVERCOUNT:
return LAN_GetServerCount(args[1]);
case UI_LAN_GETSERVERADDRESSSTRING:
LAN_GetServerAddressString( args[1], args[2], (char *)VMA(3), args[4] );
return 0;
case UI_LAN_GETSERVERINFO:
LAN_GetServerInfo( args[1], args[2], (char *)VMA(3), args[4] );
return 0;
case UI_LAN_GETSERVERPING:
return LAN_GetServerPing( args[1], args[2] );
case UI_LAN_MARKSERVERVISIBLE:
LAN_MarkServerVisible( args[1], args[2], (qboolean)args[3] );
return 0;
case UI_LAN_SERVERISVISIBLE:
return LAN_ServerIsVisible( args[1], args[2] );
case UI_LAN_UPDATEVISIBLEPINGS:
return LAN_UpdateVisiblePings( args[1] );
case UI_LAN_RESETPINGS:
LAN_ResetPings( args[1] );
return 0;
case UI_LAN_SERVERSTATUS:
return LAN_GetServerStatus( (char *)VMA(1), (char *)VMA(2), args[3] );
case UI_LAN_COMPARESERVERS:
return LAN_CompareServers( args[1], args[2], args[3], args[4], args[5] );
case UI_MEMORY_REMAINING:
return Hunk_MemoryRemaining();
case UI_R_REGISTERFONT:
return re->RegisterFont( (const char *)VMA(1) );
case UI_R_FONT_STRLENPIXELS:
return re->Font_StrLenPixels( (const char *)VMA(1), args[2], VMF(3) );
case UI_R_FONT_STRLENCHARS:
return re->Font_StrLenChars( (const char *)VMA(1) );
case UI_R_FONT_STRHEIGHTPIXELS:
return re->Font_HeightPixels( args[1], VMF(2) );
case UI_R_FONT_DRAWSTRING:
re->Font_DrawString( args[1], args[2], (const char *)VMA(3), (const float *) VMA(4), args[5], args[6], VMF(7) );
return 0;
case UI_LANGUAGE_ISASIAN:
return re->Language_IsAsian();
case UI_LANGUAGE_USESSPACES:
return re->Language_UsesSpaces();
case UI_ANYLANGUAGE_READCHARFROMSTRING:
return re->AnyLanguage_ReadCharFromString( (const char *)VMA(1), (int *) VMA(2), (qboolean *) VMA(3) );
case UI_PC_ADD_GLOBAL_DEFINE:
return botlib_export->PC_AddGlobalDefine( (char *)VMA(1) );
case UI_PC_LOAD_SOURCE:
return botlib_export->PC_LoadSourceHandle( (const char *)VMA(1) );
case UI_PC_FREE_SOURCE:
return botlib_export->PC_FreeSourceHandle( args[1] );
case UI_PC_READ_TOKEN:
return botlib_export->PC_ReadTokenHandle( args[1], (struct pc_token_s *)VMA(2) );
case UI_PC_SOURCE_FILE_AND_LINE:
return botlib_export->PC_SourceFileAndLine( args[1], (char *)VMA(2), (int *)VMA(3) );
case UI_PC_LOAD_GLOBAL_DEFINES:
return botlib_export->PC_LoadGlobalDefines ( (char *)VMA(1) );
case UI_PC_REMOVE_ALL_GLOBAL_DEFINES:
botlib_export->PC_RemoveAllGlobalDefines ( );
return 0;
case UI_S_STOPBACKGROUNDTRACK:
S_StopBackgroundTrack();
return 0;
case UI_S_STARTBACKGROUNDTRACK:
S_StartBackgroundTrack( (const char *)VMA(1), (const char *)VMA(2), qfalse );
return 0;
case UI_REAL_TIME:
return Com_RealTime( (struct qtime_s *)VMA(1) );
case UI_CIN_PLAYCINEMATIC:
Com_DPrintf("UI_CIN_PlayCinematic\n");
return CIN_PlayCinematic((const char *)VMA(1), args[2], args[3], args[4], args[5], args[6]);
case UI_CIN_STOPCINEMATIC:
return CIN_StopCinematic(args[1]);
case UI_CIN_RUNCINEMATIC:
return CIN_RunCinematic(args[1]);
case UI_CIN_DRAWCINEMATIC:
CIN_DrawCinematic(args[1]);
return 0;
case UI_CIN_SETEXTENTS:
CIN_SetExtents(args[1], args[2], args[3], args[4], args[5]);
return 0;
case UI_R_REMAP_SHADER:
re->RemapShader( (const char *)VMA(1), (const char *)VMA(2), (const char *)VMA(3) );
return 0;
case UI_SP_GETNUMLANGUAGES:
return SE_GetNumLanguages();
case UI_SP_GETLANGUAGENAME:
CL_SE_GetLanguageName( args[1], (char *)VMA(2) );
return 0;
case UI_SP_GETSTRINGTEXTSTRING:
return CL_SE_GetStringTextString( (const char *)VMA(1), (char *)VMA(2), args[3] );
case UI_G2_LISTSURFACES:
re->G2API_ListSurfaces( (CGhoul2Info *) args[1] );
return 0;
case UI_G2_LISTBONES:
re->G2API_ListBones( (CGhoul2Info *) args[1], args[2]);
return 0;
case UI_G2_HAVEWEGHOULMODELS:
return re->G2API_HaveWeGhoul2Models( *((CGhoul2Info_v *)args[1]) );
case UI_G2_SETMODELS:
re->G2API_SetGhoul2ModelIndexes( *((CGhoul2Info_v *)args[1]),(qhandle_t *)VMA(2),(qhandle_t *)VMA(3));
return 0;
case UI_G2_GETBOLT:
return re->G2API_GetBoltMatrix(*((CGhoul2Info_v *)args[1]), args[2], args[3], (mdxaBone_t *)VMA(4), (const float *)VMA(5),(const float *)VMA(6), args[7], (qhandle_t *)VMA(8), (float *)VMA(9));
case UI_G2_GETBOLT_NOREC:
re->G2API_BoltMatrixReconstruction( qfalse );//gG2_GBMNoReconstruct = qtrue;
return re->G2API_GetBoltMatrix(*((CGhoul2Info_v *)args[1]), args[2], args[3], (mdxaBone_t *)VMA(4), (const float *)VMA(5),(const float *)VMA(6), args[7], (qhandle_t *)VMA(8), (float *)VMA(9));
case UI_G2_GETBOLT_NOREC_NOROT:
//RAZFIXME: cgame reconstructs bolt matrix, why is this different?
re->G2API_BoltMatrixReconstruction( qfalse );//gG2_GBMNoReconstruct = qtrue;
re->G2API_BoltMatrixSPMethod( qtrue );//gG2_GBMUseSPMethod = qtrue;
return re->G2API_GetBoltMatrix(*((CGhoul2Info_v *)args[1]), args[2], args[3], (mdxaBone_t *)VMA(4), (const float *)VMA(5),(const float *)VMA(6), args[7], (qhandle_t *)VMA(8), (float *)VMA(9));
case UI_G2_INITGHOUL2MODEL:
#ifdef _FULL_G2_LEAK_CHECKING
g_G2AllocServer = 0;
#endif
return re->G2API_InitGhoul2Model((CGhoul2Info_v **)VMA(1), (const char *)VMA(2), args[3], (qhandle_t) args[4], (qhandle_t) args[5], args[6], args[7]);
case UI_G2_COLLISIONDETECT:
case UI_G2_COLLISIONDETECTCACHE:
return 0; //not supported for ui
case UI_G2_ANGLEOVERRIDE:
return re->G2API_SetBoneAngles(*((CGhoul2Info_v *)args[1]), args[2], (const char *)VMA(3), (float *)VMA(4), args[5], (const Eorientations) args[6], (const Eorientations) args[7], (const Eorientations) args[8], (qhandle_t *)VMA(9), args[10], args[11] );
case UI_G2_CLEANMODELS:
#ifdef _FULL_G2_LEAK_CHECKING
g_G2AllocServer = 0;
#endif
re->G2API_CleanGhoul2Models((CGhoul2Info_v **)VMA(1));
// re->G2API_CleanGhoul2Models((CGhoul2Info_v **)args[1]);
return 0;
case UI_G2_PLAYANIM:
return re->G2API_SetBoneAnim(*((CGhoul2Info_v *)args[1]), args[2], (const char *)VMA(3), args[4], args[5], args[6], VMF(7), args[8], VMF(9), args[10]);
case UI_G2_GETBONEANIM:
{
CGhoul2Info_v &g2 = *((CGhoul2Info_v *)args[1]);
int modelIndex = args[10];
return re->G2API_GetBoneAnim(&g2[modelIndex], (const char*)VMA(2), args[3], (float *)VMA(4), (int *)VMA(5), (int *)VMA(6), (int *)VMA(7), (float *)VMA(8), (int *)VMA(9));
}
case UI_G2_GETBONEFRAME:
{ //rwwFIXMEFIXME: Just make a G2API_GetBoneFrame func too. This is dirty.
CGhoul2Info_v &g2 = *((CGhoul2Info_v *)args[1]);
int modelIndex = args[6];
int iDontCare1 = 0, iDontCare2 = 0, iDontCare3 = 0;
float fDontCare1 = 0;
return re->G2API_GetBoneAnim(&g2[modelIndex], (const char*)VMA(2), args[3], (float *)VMA(4), &iDontCare1, &iDontCare2, &iDontCare3, &fDontCare1, (int *)VMA(5));
}
case UI_G2_GETGLANAME:
// return (int)G2API_GetGLAName(*((CGhoul2Info_v *)VMA(1)), args[2]);
{
char *point = ((char *)VMA(3));
char *local;
local = re->G2API_GetGLAName(*((CGhoul2Info_v *)args[1]), args[2]);
if (local)
{
strcpy(point, local);
}
}
return 0;
case UI_G2_COPYGHOUL2INSTANCE:
return (int)re->G2API_CopyGhoul2Instance(*((CGhoul2Info_v *)args[1]), *((CGhoul2Info_v *)args[2]), args[3]);
case UI_G2_COPYSPECIFICGHOUL2MODEL:
re->G2API_CopySpecificG2Model(*((CGhoul2Info_v *)args[1]), args[2], *((CGhoul2Info_v *)args[3]), args[4]);
return 0;
case UI_G2_DUPLICATEGHOUL2INSTANCE:
#ifdef _FULL_G2_LEAK_CHECKING
g_G2AllocServer = 0;
#endif
re->G2API_DuplicateGhoul2Instance(*((CGhoul2Info_v *)args[1]), (CGhoul2Info_v **)VMA(2));
return 0;
case UI_G2_HASGHOUL2MODELONINDEX:
return (int)re->G2API_HasGhoul2ModelOnIndex((CGhoul2Info_v **)VMA(1), args[2]);
//return (int)G2API_HasGhoul2ModelOnIndex((CGhoul2Info_v **)args[1], args[2]);
case UI_G2_REMOVEGHOUL2MODEL:
#ifdef _FULL_G2_LEAK_CHECKING
g_G2AllocServer = 0;
#endif
return (int)re->G2API_RemoveGhoul2Model((CGhoul2Info_v **)VMA(1), args[2]);
//return (int)G2API_RemoveGhoul2Model((CGhoul2Info_v **)args[1], args[2]);
case UI_G2_ADDBOLT:
return re->G2API_AddBolt(*((CGhoul2Info_v *)args[1]), args[2], (const char *)VMA(3));
case UI_G2_SETBOLTON:
re->G2API_SetBoltInfo(*((CGhoul2Info_v *)args[1]), args[2], args[3]);
return 0;
case UI_G2_SETROOTSURFACE:
return re->G2API_SetRootSurface(*((CGhoul2Info_v *)args[1]), args[2], (const char *)VMA(3));
case UI_G2_SETSURFACEONOFF:
return re->G2API_SetSurfaceOnOff(*((CGhoul2Info_v *)args[1]), (const char *)VMA(2), /*(const int)VMA(3)*/args[3]);
case UI_G2_SETNEWORIGIN:
return re->G2API_SetNewOrigin(*((CGhoul2Info_v *)args[1]), /*(const int)VMA(2)*/args[2]);
case UI_G2_GETTIME:
return re->G2API_GetTime(0);
case UI_G2_SETTIME:
re->G2API_SetTime(args[1], args[2]);
return 0;
case UI_G2_SETRAGDOLL:
return 0; //not supported for ui
break;
case UI_G2_ANIMATEG2MODELS:
return 0; //not supported for ui
break;
case UI_G2_SETBONEIKSTATE:
return re->G2API_SetBoneIKState(*((CGhoul2Info_v *)args[1]), args[2], (const char *)VMA(3), args[4], (sharedSetBoneIKStateParams_t *)VMA(5));
case UI_G2_IKMOVE:
return re->G2API_IKMove(*((CGhoul2Info_v *)args[1]), args[2], (sharedIKMoveParams_t *)VMA(3));
case UI_G2_GETSURFACENAME:
{ //Since returning a pointer in such a way to a VM seems to cause MASSIVE FAILURE<tm>, we will shove data into the pointer the vm passes instead
char *point = ((char *)VMA(4));
char *local;
int modelindex = args[3];
CGhoul2Info_v &g2 = *((CGhoul2Info_v *)args[1]);
local = re->G2API_GetSurfaceName(&g2[modelindex], args[2]);
if (local)
{
strcpy(point, local);
}
}
return 0;
case UI_G2_SETSKIN:
{
CGhoul2Info_v &g2 = *((CGhoul2Info_v *)args[1]);
int modelIndex = args[2];
return re->G2API_SetSkin(&g2[modelIndex], args[3], args[4]);
}
case UI_G2_ATTACHG2MODEL:
{
CGhoul2Info_v *g2From = ((CGhoul2Info_v *)args[1]);
CGhoul2Info_v *g2To = ((CGhoul2Info_v *)args[3]);
return re->G2API_AttachG2Model(*g2From, args[2], *g2To, args[4], args[5]);
}
default:
Com_Error( ERR_DROP, "Bad UI system trap: %ld", (long int) args[0] );
}
return 0;
}
/*
=================
S_CodecUtilClose
=================
*/
void S_CodecUtilClose(snd_stream_t **stream)
{
FS_FCloseFile((*stream)->file);
Z_Free(*stream);
*stream = NULL;
}
static void SV_AddBanToList(qboolean isexception)
{
char *banstring, *suffix;
netadr_t ip;
int argc, mask;
fileHandle_t writeto;
argc = Cmd_Argc();
if(argc < 2 || argc > 3)
{
Com_Printf ("Usage: %s (ip[/subnet] | clientnum [subnet])\n", Cmd_Argv(0));
return;
}
if(serverBansCount > sizeof(serverBans) / sizeof(*serverBans))
{
Com_Printf ("Error: Maximum number of bans/exceptions exceeded.\n");
return;
}
banstring = Cmd_Argv(1);
if(strchr(banstring, '.') || strchr(banstring, ':'))
{
// This is an ip address, not a client num.
// Look for a CIDR-Notation suffix
suffix = strchr(banstring, '/');
if(suffix)
{
*suffix = '\0';
suffix++;
}
if(!NET_StringToAdr(banstring, &ip, NA_UNSPEC))
{
Com_Printf("Error: Invalid address %s\n", banstring);
return;
}
}
else
{
client_t *cl;
// client num.
if(!com_sv_running->integer)
{
Com_Printf("Server is not running.\n");
return;
}
cl = SV_GetPlayerByNum();
if(!cl)
{
Com_Printf("Error: Playernum %s does not exist.\n", Cmd_Argv(1));
return;
}
ip = cl->netchan.remoteAddress;
if(argc == 3)
suffix = Cmd_Argv(2);
else
suffix = NULL;
}
if(ip.type != NA_IP && ip.type != NA_IP6)
{
Com_Printf("Error: Can ban players connected via the internet only.\n");
return;
}
if(suffix)
{
mask = atoi(suffix);
if(ip.type == NA_IP)
{
if(mask < 0 || mask > 32)
mask = 32;
}
else
{
if(mask < 0 || mask > 128)
mask = 128;
}
}
else if(ip.type == NA_IP)
mask = 32;
else
mask = 128;
serverBans[serverBansCount].ip = ip;
serverBans[serverBansCount].subnet = mask;
serverBans[serverBansCount].isexception = isexception;
Com_Printf("Added %s: %s/%d\n", isexception ? "ban exception" : "ban",
NET_AdrToString(ip), mask);
// Write out the ban information.
if((writeto = FS_FOpenFileAppend(SERVER_BANFILE)))
{
char writebuf[128];
Com_sprintf(writebuf, sizeof(writebuf), "%d %s %d\n", isexception, NET_AdrToString(ip), mask);
FS_Write(writebuf, strlen(writebuf), writeto);
FS_FCloseFile(writeto);
}
serverBansCount++;
}
/*
====================
CL_UpdateLevelHunkUsage
This updates the "hunkusage.dat" file with the current map and it's hunk usage count
This is used for level loading, so we can show a percentage bar dependant on the amount
of hunk memory allocated so far
This will be slightly inaccurate if some settings like sound quality are changed, but these
things should only account for a small variation (hopefully)
====================
*/
void CL_UpdateLevelHunkUsage( void ) {
int handle;
char *memlistfile = "hunkusage.dat";
char *buf, *outbuf;
char *buftrav, *outbuftrav;
char *token;
char outstr[256];
int len, memusage;
memusage = Cvar_VariableIntegerValue( "com_hunkused" ) + Cvar_VariableIntegerValue( "hunk_soundadjust" );
len = FS_FOpenFileByMode( memlistfile, &handle, FS_READ );
if ( len >= 0 ) { // the file exists, so read it in, strip out the current entry for this map, and save it out, so we can append the new value
buf = (char *)Z_Malloc( len + 1 );
memset( buf, 0, len + 1 );
outbuf = (char *)Z_Malloc( len + 1 );
memset( outbuf, 0, len + 1 );
FS_Read( (void *)buf, len, handle );
FS_FCloseFile( handle );
// now parse the file, filtering out the current map
buftrav = buf;
outbuftrav = outbuf;
outbuftrav[0] = '\0';
while ( ( token = COM_Parse( &buftrav ) ) && token[0] ) {
if ( !Q_strcasecmp( token, cl.mapname ) ) {
// found a match
token = COM_Parse( &buftrav ); // read the size
if ( token && token[0] ) {
if ( atoi( token ) == memusage ) { // if it is the same, abort this process
Z_Free( buf );
Z_Free( outbuf );
return;
}
}
} else { // send it to the outbuf
Q_strcat( outbuftrav, len + 1, token );
Q_strcat( outbuftrav, len + 1, " " );
token = COM_Parse( &buftrav ); // read the size
if ( token && token[0] ) {
Q_strcat( outbuftrav, len + 1, token );
Q_strcat( outbuftrav, len + 1, "\n" );
} else {
Com_Error( ERR_DROP, "hunkusage.dat file is corrupt\n" );
}
}
}
#ifdef __MACOS__ //DAJ MacOS file typing
{
extern _MSL_IMP_EXP_C long _fcreator, _ftype;
_ftype = 'TEXT';
_fcreator = 'WlfS';
}
#endif
handle = FS_FOpenFileWrite( memlistfile );
if ( handle < 0 ) {
Com_Error( ERR_DROP, "cannot create %s\n", memlistfile );
}
// input file is parsed, now output to the new file
len = strlen( outbuf );
if ( FS_Write( (void *)outbuf, len, handle ) != len ) {
Com_Error( ERR_DROP, "cannot write to %s\n", memlistfile );
}
FS_FCloseFile( handle );
Z_Free( buf );
Z_Free( outbuf );
}
// now append the current map to the current file
FS_FOpenFileByMode( memlistfile, &handle, FS_APPEND );
if ( handle < 0 ) {
Com_Error( ERR_DROP, "cannot write to hunkusage.dat, check disk full\n" );
}
Com_sprintf( outstr, sizeof( outstr ), "%s %i\n", cl.mapname, memusage );
FS_Write( outstr, strlen( outstr ), handle );
FS_FCloseFile( handle );
// now just open it and close it, so it gets copied to the pak dir
len = FS_FOpenFileByMode( memlistfile, &handle, FS_READ );
if ( len >= 0 ) {
FS_FCloseFile( handle );
}
}
qboolean demoCut(const char *oldName, int startTime, int endTime) {
fileHandle_t oldHandle = 0;
fileHandle_t newHandle = 0;
msg_t oldMsg;
byte oldData[MAX_MSGLEN];
int oldSize;
char newName[MAX_OSPATH];
int buf;
int readGamestate = 0;
int i;
demoPlay_t *play = demo.play.handle;
qboolean ret = qfalse;
int framesSaved = 0;
char newGameDir[MAX_QPATH];
char next;
char *ext;
if (!play) {
Com_Printf("Demo cutting is allowed in mme mode only.\n");
return qfalse;
}
startTime += play->startTime;
endTime += play->startTime;
ext = Cvar_FindVar("mme_demoExt")->string;
if (!*ext)
ext = ".dm_26";
oldSize = FS_FOpenFileRead(va("demos/%s%s", oldName, ext), &oldHandle, qtrue);
if (!oldHandle) {
Com_Printf("Failed to open %s for cutting.\n", oldName);
return qfalse;
}
memset(&demo.cut.Clc, 0, sizeof(demo.cut.Clc));
Com_SetLoadingMsg("Cutting the demo...");
while (oldSize > 0) {
cutcontinue:
MSG_Init(&oldMsg, oldData, sizeof(oldData));
/* Read the sequence number */
if (FS_Read(&demo.cut.Clc.serverMessageSequence, 4, oldHandle) != 4)
goto cuterror;
demo.cut.Clc.serverMessageSequence = LittleLong(demo.cut.Clc.serverMessageSequence);
oldSize -= 4;
/* Read the message size */
if (FS_Read(&oldMsg.cursize,4, oldHandle) != 4)
goto cuterror;
oldMsg.cursize = LittleLong(oldMsg.cursize);
oldSize -= 4;
/* Negative size signals end of demo */
if (oldMsg.cursize < 0)
break;
if (oldMsg.cursize > oldMsg.maxsize)
goto cuterror;
/* Read the actual message */
if (FS_Read(oldMsg.data, oldMsg.cursize, oldHandle) != oldMsg.cursize)
goto cuterror;
oldSize -= oldMsg.cursize;
// init the bitstream
MSG_BeginReading(&oldMsg);
// Skip the reliable sequence acknowledge number
MSG_ReadLong(&oldMsg);
//
// parse the message
//
while (1) {
byte cmd;
if (oldMsg.readcount > oldMsg.cursize) {
Com_Printf("Demo cutter, read past end of server message.\n");
goto cuterror;
}
cmd = MSG_ReadByte(&oldMsg);
if (cmd == svc_EOF) {
break;
}
// skip all the gamestates until we reach needed
if (readGamestate < demo.currentNum) {
if (cmd == svc_gamestate) {
readGamestate++;
}
goto cutcontinue;
}
// other commands
switch (cmd) {
default:
Com_Printf(S_COLOR_RED"ERROR: CL_ParseServerMessage: Illegible server message\n");
goto cuterror;
case svc_nop:
break;
case svc_serverCommand:
demoCutParseCommandString(&oldMsg, &demo.cut.Clc);
break;
case svc_gamestate:
if (readGamestate > demo.currentNum) {
Com_Printf("Warning: unexpected new gamestate, finishing cutting.\n");
goto cutcomplete;
}
if (!demoCutParseGamestate(&oldMsg, &demo.cut.Clc, &demo.cut.Cl)) {
goto cuterror;
}
Com_sprintf(newName, sizeof(newName), "demos/%s_cut%s", oldName, ext);
newHandle = FS_FOpenFileWrite(newName);
if (!newHandle) {
Com_Printf("Failed to open %s for target cutting.\n", newName);
return qfalse;
}
readGamestate++;
break;
case svc_snapshot:
if (!demoCutParseSnapshot(&oldMsg, &demo.cut.Clc, &demo.cut.Cl)) {
goto cuterror;
}
break;
case svc_download:
// read block number
buf = MSG_ReadShort(&oldMsg);
if (!buf) //0 block, read file size
MSG_ReadLong(&oldMsg);
// read block size
buf = MSG_ReadShort(&oldMsg);
// read the data block
for (;buf>0;buf--)
MSG_ReadByte(&oldMsg);
break;
case svc_setgame:
i = 0;
while (i < MAX_QPATH) {
next = MSG_ReadByte(&oldMsg);
if(next) {
newGameDir[i] = next;
} else {
break;
}
i++;
}
newGameDir[i] = 0;
// But here we stop, and don't do more. If this goes horribly wrong sometime, you might have to go and actually do something with this.
break;
case svc_mapchange:
// nothing to parse.
break;
}
}
int firstServerCommand = demo.cut.Clc.lastExecutedServerCommand;
// process any new server commands
for (;demo.cut.Clc.lastExecutedServerCommand < demo.cut.Clc.serverCommandSequence; demo.cut.Clc.lastExecutedServerCommand++) {
char *command = demo.cut.Clc.serverCommands[demo.cut.Clc.lastExecutedServerCommand & (MAX_RELIABLE_COMMANDS - 1)];
Cmd_TokenizeString(command);
char *cmd = Cmd_Argv(0);
if (cmd[0]) {
firstServerCommand = demo.cut.Clc.lastExecutedServerCommand;
}
if (!strcmp(cmd, "cs")) {
if (!demoCutConfigstringModified(&demo.cut.Cl)) {
goto cuterror;
}
}
}
if (demo.cut.Cl.snap.serverTime > endTime) {
goto cutcomplete;
} else if (framesSaved > 0) {
/* this msg is in range, write it */
if (framesSaved > max(10, demo.cut.Cl.snap.messageNum - demo.cut.Cl.snap.deltaNum)) {
demoCutWriteDemoMessage(&oldMsg, newHandle, &demo.cut.Clc);
} else {
demoCutWriteDeltaSnapshot(firstServerCommand, newHandle, qfalse, &demo.cut.Clc, &demo.cut.Cl);
}
framesSaved++;
} else if (demo.cut.Cl.snap.serverTime >= startTime) {
demoCutWriteDemoHeader(newHandle, &demo.cut.Clc, &demo.cut.Cl);
demoCutWriteDeltaSnapshot(firstServerCommand, newHandle, qtrue, &demo.cut.Clc, &demo.cut.Cl);
// copy rest
framesSaved = 1;
}
}
cutcomplete:
if (newHandle) {
buf = -1;
FS_Write(&buf, 4, newHandle);
FS_Write(&buf, 4, newHandle);
ret = qtrue;
}
cuterror:
//remove previosly converted demo from the same cut
if (newHandle) {
memset(newName, 0, sizeof(newName));
if (demo.currentNum > 0) {
Com_sprintf(newName, sizeof(newName), "mmedemos/%s.%d_cut.mme", oldName, demo.currentNum);
} else {
Com_sprintf(newName, sizeof(newName), "mmedemos/%s_cut.mme", oldName);
}
if (FS_FileExists(newName))
FS_FileErase(newName);
}
FS_FCloseFile(oldHandle);
FS_FCloseFile(newHandle);
return ret;
}
/*
=====================
CL_ParseDownload
A download message has been received from the server
=====================
*/
void CL_ParseDownload ( msg_t *msg ) {
int size;
unsigned char data[MAX_MSGLEN];
uint16_t block;
if (!*clc.downloadTempName) {
Com_Printf("Server sending download, but no download was requested\n");
CL_AddReliableCommand("stopdl", qfalse);
return;
}
// read the data
block = MSG_ReadShort ( msg );
if(!block && !clc.downloadBlock)
{
// block zero is special, contains file size
clc.downloadSize = MSG_ReadLong ( msg );
Cvar_SetValue( "cl_downloadSize", clc.downloadSize );
if (clc.downloadSize < 0)
{
Com_Error( ERR_DROP, "%s", MSG_ReadString( msg ) );
return;
}
}
size = MSG_ReadShort ( msg );
if (size < 0 || size > sizeof(data))
{
Com_Error(ERR_DROP, "CL_ParseDownload: Invalid size %d for download chunk", size);
return;
}
MSG_ReadData(msg, data, size);
if((clc.downloadBlock & 0xFFFF) != block)
{
Com_DPrintf( "CL_ParseDownload: Expected block %d, got %d\n", (clc.downloadBlock & 0xFFFF), block);
return;
}
// open the file if not opened yet
if (!clc.download)
{
clc.download = FS_SV_FOpenFileWrite( clc.downloadTempName );
if (!clc.download) {
Com_Printf( "Could not create %s\n", clc.downloadTempName );
CL_AddReliableCommand("stopdl", qfalse);
CL_NextDownload();
return;
}
}
if (size)
FS_Write( data, size, clc.download );
CL_AddReliableCommand(va("nextdl %d", clc.downloadBlock), qfalse);
clc.downloadBlock++;
clc.downloadCount += size;
// So UI gets access to it
Cvar_SetValue( "cl_downloadCount", clc.downloadCount );
if (!size) { // A zero length block means EOF
if (clc.download) {
FS_FCloseFile( clc.download );
clc.download = 0;
// rename the file
FS_SV_Rename ( clc.downloadTempName, clc.downloadName );
}
// send intentions now
// We need this because without it, we would hold the last nextdl and then start
// loading right away. If we take a while to load, the server is happily trying
// to send us that last block over and over.
// Write it twice to help make sure we acknowledge the download
CL_WritePacket();
CL_WritePacket();
// get another file if needed
CL_NextDownload ();
}
}
/*
* SV_AutoUpdateFromWeb
*/
void SV_AutoUpdateFromWeb( qboolean checkOnly )
{
static const char *autoUpdateBaseUrl = APP_UPDATE_URL APP_SERVER_UPDATE_DIRECTORY;
char checksumString1[32], checksumString2[32];
unsigned int checksum;
qboolean success;
int length, filenum;
qbyte *data;
const char *token, *ptr;
char path[MAX_QPATH];
int downloadCount = 0, downloadFailed = 0;
char newVersionTag[MAX_QPATH];
qboolean newVersion = qfalse;
if( !dedicated->integer )
return;
assert( svs.mapcmd[0] );
if( !checkOnly )
SV_UpdateActivity();
Com_Printf( "\n" );
Com_Printf( "========== Starting Auto Update ===========\n" );
Com_Printf( "Checking for updates\n" );
// download the update file list
success = SV_WebDownload( autoUpdateBaseUrl, APP_SERVER_UPDATE_FILE, qtrue, qtrue );
// set as last updated today
if( !checkOnly )
Cvar_ForceSet( "sv_lastAutoUpdate", va( "%i", (int)Com_DaysSince1900() ) );
if( !success ) // no update to do
goto done;
// read the file list
if( ( length = FS_FOpenBaseFile( APP_SERVER_UPDATE_FILE, &filenum, FS_READ ) ) == -1 )
{
Com_Printf( "WARNING: Couldn't find %s\n", path );
goto done;
}
if( !length )
{
FS_FCloseFile( filenum );
goto done;
}
data = Mem_TempMalloc( length + 1 );
FS_Read( data, length, filenum );
FS_FCloseFile( filenum );
FS_RemoveBaseFile( APP_SERVER_UPDATE_FILE );
ptr = (const char *)data;
// first token is always the current release version
token = COM_ParseExt( &ptr, qtrue );
if( !token[0] )
goto cancel;
// compare versions
Q_strncpyz( newVersionTag, token, sizeof( newVersionTag ) );
if( atof( newVersionTag ) > atof( va( "%4.3f", APP_VERSION ) ) )
newVersion = qtrue;
while( ptr )
{
// we got what should be a checksum
token = COM_ParseExt( &ptr, qtrue );
if( !token[0] )
goto cancel;
// copy checksum reported by server
Q_strncpyz( checksumString1, token, sizeof( checksumString1 ) );
// get filename
token = COM_ParseExt( &ptr, qtrue );
if( !token[0] )
goto cancel;
// filename should never begin with a slash
if( token[0] == '/' )
token++;
Q_strncpyz( path, token, sizeof( path ) );
// we got what should be a file path
if( !COM_ValidateRelativeFilename( path ) )
{
Com_Printf( "WARNING: Invalid filename %s\n", path );
continue;
}
checksum = FS_ChecksumBaseFile( path );
Q_snprintfz( checksumString2, sizeof( checksumString2 ), "%u", checksum );
// if same checksum no need to update
if( !strcmp( checksumString1, checksumString2 ) )
continue;
// if it's a pack file and the file exists it can't be replaced, so skip
if( FS_CheckPakExtension( path ) && checksum )
{
Com_Printf( "WARNING: Purity check failed for: %s\n", path );
Com_Printf( "WARNING: This file has been locally modified. It is highly \n" );
Com_Printf( "WARNING: recommended to restore the original file.\n" );
Com_Printf( "WARNING: Reinstalling \""APPLICATION"\" might be convenient.\n" );
continue;
}
if( checkOnly )
{
Com_Printf( "File update available : %s\n", path );
continue;
}
if( developer->integer )
Com_Printf( "Downloading update of %s (checksum %s local checksum %s)\n", path, checksumString1, checksumString2 );
else
Com_Printf( "Updating %s\n", path );
if( !SV_WebDownload( autoUpdateBaseUrl, path, qtrue, qtrue ) )
{
Com_Printf( "Failed to update %s\n", path );
downloadFailed++;
}
downloadCount++;
}
cancel:
Mem_TempFree( data );
done:
if( newVersion )
{
if( downloadCount )
{
if( downloadFailed )
Com_Printf( "This version of "APPLICATION" was updated incompletely\n" );
else
Com_Printf( "This version of "APPLICATION" was updated successfully\n\n" );
}
Com_Printf( "****** Version %s of "APPLICATION" is available. ******\n", newVersionTag );
Com_Printf( "****** Please download the new version at "APP_URL" ******\n" );
}
else if( downloadCount )
{
if( downloadFailed )
Com_Printf( APPLICATION" was updated incompletely\n" );
else
Com_Printf( APPLICATION" was updated successfully\n" );
}
else if( !checkOnly )
{
if( downloadFailed )
Com_Printf( "At least one file failed to update\n" );
else
Com_Printf( APPLICATION" is up to date\n" );
}
Com_Printf( "========== Auto Update Finished ===========\n" );
Com_Printf( "\n" );
// update the map list, which also does a filesystem rescan
ML_Update();
// if there are any new filesystem entries, restart
if( FS_GetNotifications() & FS_NOTIFT_NEWPAKS )
{
if( sv.state != ss_dead )
{
// restart the current map, SV_Map also rescans the filesystem
Com_Printf( "The server will now restart...\n\n" );
// start the default map if current map isn't available
Cbuf_ExecuteText( EXEC_APPEND, va( "map %s\n", svs.mapcmd[0] ? svs.mapcmd : sv_defaultmap->string ) );
}
}
}