float itof(intt ent)
intt ftoi(float num)
+
+float altstr_count(string)
+string altstr_prepare(string)
+string altstr_get(string,float)
+string altstr_set(string altstr, float num, string set)
perhaps only : Menu : WriteMsg
===============================
WriteString(string data, float dest, float desto)
WriteEntity(entity data, float dest, float desto)
-Client & Menu : draw functions
-===============================
+Client & Menu : draw functions & video functions
+===================================================
float iscachedpic(string pic)
string precache_pic(string pic)
drawsetcliparea(float x, float y, float width, float height)
drawresetcliparea()
vector getimagesize(string pic)
-
+
+float cin_open(string file, string name)
+void cin_close(string name)
+void cin_setstate(string name, float type)
+float cin_getstate(string name)
+void cin_restart(string name)
==============================================================================
menu cmd list:
setkeydest(float dest)
float getkeydest()
setmousetarget(float target)
-float getmousetarget(void)
+float getmousetarget()
callfunction(...,string function_name)
writetofile(float fhandle, entity ent)
vector getresolution(float number)
string keynumtostring(float keynum)
string findkeysforcommand(string command)
-float gethostcachevalue(float type)
-string gethostcachestring(float type, float hostnr)
+float gethostcachestat(float type)
+string gethostcachestring(float fld, float hostnr)
parseentitydata(entity ent, string data)
+
+float stringtokeynum(string key)
+
+ resethostcachemasks()
+ sethostcachemaskstring(float mask, float fld, string str)
+ sethostcachemasknumber(float mask, float fld, float num, float op)
+ resorthostcache()
+ sethostcachesort(float field, float descending)
+ refreshhostcache()
+float gethostcachenumber(float fld, float hostnr)
+float gethostcacheindexforkey(string key)
+ addwantedhostcachekey(string key)
*/
#include "quakedef.h"
#include "clprogdefs.h"
#include "mprogdefs.h"
+#include "cl_video.h"
+
//============================================================================
// nice helper macros
PRVM_G_INT(OFS_RETURN) = PRVM_G_INT(OFS_PARM0);
VM_CheckEmptyString (s);
- if(!S_PrecacheSound (s,true, true))
+ if(snd_initialized.integer && !S_PrecacheSound (s,true, true))
Con_Printf("VM_precache_sound: Failed to load %s for %s\n", s, PRVM_NAME);
}
// remove \n following \r
if (c == '\r')
c = FS_Getc(VM_FILES[filenum]);
- if (developer.integer)
+ if (developer.integer >= 3)
Con_Printf("fgets: %s: %s\n", PRVM_NAME, string);
if (c >= 0 || end)
PRVM_G_INT(OFS_RETURN) = PRVM_SetString(string);
VM_SAFEPARMCOUNT(1,VM_iscachedpic);
// drawq hasnt such a function, thus always return true
- PRVM_G_FLOAT(OFS_RETURN) = TRUE;
+ PRVM_G_FLOAT(OFS_RETURN) = false;
}
/*
return;
}
- VM_CheckEmptyString(string);
+ //VM_CheckEmptyString(string); Why should it be checked - perhaps the menu wants to support the precolored letters, too?
pos = PRVM_G_VECTOR(OFS_PARM0);
scale = PRVM_G_VECTOR(OFS_PARM2);
float x,y,w,h;
VM_SAFEPARMCOUNT(4,VM_drawsetcliparea);
- x = bound(0,PRVM_G_FLOAT(OFS_PARM0),vid.conwidth);
- y = bound(0,PRVM_G_FLOAT(OFS_PARM1),vid.conheight);
- w = bound(0,PRVM_G_FLOAT(OFS_PARM2),(vid.conwidth - x));
- h = bound(0,PRVM_G_FLOAT(OFS_PARM3),(vid.conheight - y));
+ x = bound(0, PRVM_G_FLOAT(OFS_PARM0), vid.conwidth);
+ y = bound(0, PRVM_G_FLOAT(OFS_PARM1), vid.conheight);
+ w = bound(0, PRVM_G_FLOAT(OFS_PARM2) + PRVM_G_FLOAT(OFS_PARM0) - x, (vid.conwidth - x));
+ h = bound(0, PRVM_G_FLOAT(OFS_PARM3) + PRVM_G_FLOAT(OFS_PARM1) - y, (vid.conheight - y));
- DrawQ_SetClipArea(x,y,w,h);
+ DrawQ_SetClipArea(x, y, w, h);
}
/*
PRVM_G_VECTOR(OFS_RETURN)[2] = 0;
}
+// CL_Video interface functions
+
+/*
+========================
+VM_cin_open
+
+float cin_open(string file, string name)
+========================
+*/
+void VM_cin_open( void )
+{
+ char *file;
+ char *name;
+
+ VM_SAFEPARMCOUNT( 2, VM_cin_open );
+
+ file = PRVM_G_STRING( OFS_PARM0 );
+ name = PRVM_G_STRING( OFS_PARM1 );
+
+ VM_CheckEmptyString( file );
+ VM_CheckEmptyString( name );
+
+ if( CL_OpenVideo( file, name, MENUOWNER ) )
+ PRVM_G_FLOAT( OFS_RETURN ) = 1;
+ else
+ PRVM_G_FLOAT( OFS_RETURN ) = 0;
+}
+
+/*
+========================
+VM_cin_close
+
+void cin_close(string name)
+========================
+*/
+void VM_cin_close( void )
+{
+ char *name;
+
+ VM_SAFEPARMCOUNT( 1, VM_cin_close );
+
+ name = PRVM_G_STRING( OFS_PARM0 );
+ VM_CheckEmptyString( name );
+
+ CL_CloseVideo( CL_GetVideo( name ) );
+}
+
+/*
+========================
+VM_cin_setstate
+void cin_setstate(string name, float type)
+========================
+*/
+void VM_cin_setstate( void )
+{
+ char *name;
+ clvideostate_t state;
+ clvideo_t *video;
+
+ VM_SAFEPARMCOUNT( 2, VM_cin_netstate );
+
+ name = PRVM_G_STRING( OFS_PARM0 );
+ VM_CheckEmptyString( name );
+
+ state = PRVM_G_FLOAT( OFS_PARM1 );
+
+ video = CL_GetVideo( name );
+ if( video && state > CLVIDEO_UNUSED && state < CLVIDEO_STATECOUNT )
+ CL_SetVideoState( video, state );
+}
+
+/*
+========================
+VM_cin_getstate
+
+float cin_getstate(string name)
+========================
+*/
+void VM_cin_getstate( void )
+{
+ char *name;
+ clvideo_t *video;
+
+ VM_SAFEPARMCOUNT( 1, VM_cin_getstate );
+
+ name = PRVM_G_STRING( OFS_PARM0 );
+ VM_CheckEmptyString( name );
+
+ video = CL_GetVideo( name );
+ if( video )
+ PRVM_G_FLOAT( OFS_RETURN ) = (int)video->state;
+ else
+ PRVM_G_FLOAT( OFS_RETURN ) = 0;
+}
+
+/*
+========================
+VM_cin_restart
+
+void cin_restart(string name)
+========================
+*/
+void VM_cin_restart( void )
+{
+ char *name;
+ clvideo_t *video;
+
+ VM_SAFEPARMCOUNT( 1, VM_cin_restart );
+
+ name = PRVM_G_STRING( OFS_PARM0 );
+ VM_CheckEmptyString( name );
+
+ video = CL_GetVideo( name );
+ if( video )
+ CL_RestartVideo( video );
+}
+
+////////////////////////////////////////
+// AltString functions
+////////////////////////////////////////
+
+/*
+========================
+VM_altstr_count
+
+float altstr_count(string)
+========================
+*/
+void VM_altstr_count( void )
+{
+ char *altstr, *pos;
+ int count;
+
+ VM_SAFEPARMCOUNT( 1, VM_altstr_count );
+
+ altstr = PRVM_G_STRING( OFS_PARM0 );
+ //VM_CheckEmptyString( altstr );
+
+ for( count = 0, pos = altstr ; *pos ; pos++ )
+ if( *pos == '\\' && !*++pos )
+ break;
+ else if( *pos == '\'' )
+ count++;
+
+ PRVM_G_FLOAT( OFS_RETURN ) = (float) (count / 2);
+}
+
+/*
+========================
+VM_altstr_prepare
+
+string altstr_prepare(string)
+========================
+*/
+void VM_altstr_prepare( void )
+{
+ char *outstr, *out;
+ char *instr, *in;
+ int size;
+
+ VM_SAFEPARMCOUNT( 1, VM_altstr_prepare );
+
+ instr = PRVM_G_STRING( OFS_PARM0 );
+ //VM_CheckEmptyString( instr );
+ outstr = VM_GetTempString();
+
+ for( out = outstr, in = instr, size = VM_STRINGTEMP_LENGTH - 1 ; size && *in ; size--, in++, out++ )
+ if( *in == '\'' ) {
+ *out++ = '\\';
+ *out = '\'';
+ size--;
+ } else
+ *out = *in;
+ *out = 0;
+
+ PRVM_G_INT( OFS_RETURN ) = PRVM_SetString( outstr );
+}
+
+/*
+========================
+VM_altstr_get
+
+string altstr_get(string, float)
+========================
+*/
+void VM_altstr_get( void )
+{
+ char *altstr, *pos, *outstr, *out;
+ int count, size;
+
+ VM_SAFEPARMCOUNT( 2, VM_altstr_get );
+
+ altstr = PRVM_G_STRING( OFS_PARM0 );
+ //VM_CheckEmptyString( altstr );
+
+ count = PRVM_G_FLOAT( OFS_PARM1 );
+ count = count * 2 + 1;
+
+ for( pos = altstr ; *pos && count ; pos++ )
+ if( *pos == '\\' && !*++pos )
+ break;
+ else if( *pos == '\'' )
+ count--;
+
+ if( !*pos ) {
+ PRVM_G_INT( OFS_RETURN ) = PRVM_SetString( "" );
+ return;
+ }
+
+ outstr = VM_GetTempString();
+ for( out = outstr, size = VM_STRINGTEMP_LENGTH - 1 ; size && *pos ; size--, pos++, out++ )
+ if( *pos == '\\' ) {
+ if( !*++pos )
+ break;
+ *out = *pos;
+ size--;
+ } else if( *pos == '\'' )
+ break;
+ else
+ *out = *pos;
+
+ *out = 0;
+ PRVM_G_INT( OFS_RETURN ) = PRVM_SetString( outstr );
+}
+
+/*
+========================
+VM_altstr_set
+
+string altstr_set(string altstr, float num, string set)
+========================
+*/
+void VM_altstr_set( void )
+{
+ int num;
+ char *altstr, *str;
+ char *in;
+ char *outstr, *out;
+
+ VM_SAFEPARMCOUNT( 3, VM_altstr_set );
+
+ altstr = PRVM_G_STRING( OFS_PARM0 );
+ //VM_CheckEmptyString( altstr );
+
+ num = PRVM_G_FLOAT( OFS_PARM1 );
+
+ str = PRVM_G_STRING( OFS_PARM2 );
+ //VM_CheckEmptyString( str );
+
+ outstr = out = VM_GetTempString();
+ for( num = num * 2 + 1, in = altstr; *in && num; *out++ = *in++ )
+ if( *in == '\\' && !*++in )
+ break;
+ else if( *in == '\'' )
+ num--;
+
+ if( !in ) {
+ PRVM_G_INT( OFS_RETURN ) = PRVM_SetString( "" );
+ return;
+ }
+ // copy set in
+ for( ; *str; *out++ = *str++ );
+ // now jump over the old contents
+ for( ; *in ; in++ )
+ if( *in == '\'' || *in == '\\' && !*++in )
+ break;
+
+ if( !in ) {
+ PRVM_G_INT( OFS_RETURN ) = PRVM_SetString( "" );
+ return;
+ }
+
+ strcpy( out, in );
+ PRVM_G_INT( OFS_RETURN ) = PRVM_SetString( outstr );
+}
+
void VM_Cmd_Init(void)
{
// only init the stuff for the current prog
}
Mem_FreePool(&VM_STRINGS_MEMPOOL);
+ CL_PurgeOwner( MENUOWNER );
VM_Search_Reset();
VM_Files_CloseAll();
}
// Menu
char *vm_m_extensions =
-"";
+"DP_CINEMATIC_DPV";
/*
=========
PRVM_G_INT(OFS_RETURN) = PRVM_SetString(tmp);
}
+/*
+=========
+VM_M_stringtokeynum
+
+float stringtokeynum(string key)
+=========
+*/
+void VM_M_stringtokeynum( void )
+{
+ char *str;
+ VM_SAFEPARMCOUNT( 1, VM_M_keynumtostring );
+
+ str = PRVM_G_STRING( OFS_PARM0 );
+
+ PRVM_G_INT(OFS_RETURN) = Key_StringToKeynum( str );
+}
+
/*
=========
VM_M_findkeysforcommand
/*
=========
-VM_M_gethostcachecount
+VM_M_gethostcachestat
-float gethostcachevalue(float type)
+float gethostcachestat(float type)
=========
*/
/*
type:
-0 hostcachecount
-1 masterquerycount
-2 masterreplycount
-3 serverquerycount
-4 serverreplycount
+0 hostcache_viewcount
+1 hostcache_totalcount
+2 masterquerycount
+3 masterreplycount
+4 serverquerycount
+5 serverreplycount
+6 sortfield
+7 sortdescending
*/
-void VM_M_gethostcachevalue( void )
+void VM_M_gethostcachestat( void )
{
int type;
- VM_SAFEPARMCOUNT ( 1, VM_M_gethostcachevalue );
+ VM_SAFEPARMCOUNT ( 1, VM_M_gethostcachestat );
PRVM_G_FLOAT( OFS_RETURN ) = 0;
type = PRVM_G_FLOAT( OFS_PARM0 );
- if( type < 0 || type > 4 )
- Con_Printf( "VM_M_gethostcachevalue: bad type %i!\n", type );
- else switch(type)
+ switch(type)
{
case 0:
- PRVM_G_FLOAT ( OFS_RETURN ) = hostCacheCount;
+ PRVM_G_FLOAT ( OFS_RETURN ) = hostcache_viewcount;
return;
case 1:
+ PRVM_G_FLOAT ( OFS_RETURN ) = hostcache_cachecount;
+ case 2:
PRVM_G_FLOAT ( OFS_RETURN ) = masterquerycount;
return;
- case 2:
+ case 3:
PRVM_G_FLOAT ( OFS_RETURN ) = masterreplycount;
return;
- case 3:
+ case 4:
PRVM_G_FLOAT ( OFS_RETURN ) = serverquerycount;
return;
- case 4:
+ case 5:
PRVM_G_FLOAT ( OFS_RETURN ) = serverreplycount;
return;
+ case 6:
+ PRVM_G_FLOAT ( OFS_RETURN ) = hostcache_sortbyfield;
+ return;
+ case 7:
+ PRVM_G_FLOAT ( OFS_RETURN ) = hostcache_sortdescending;
+ return;
+ default:
+ Con_Printf( "VM_M_gethostcachestat: bad type %i!\n", type );
+ }
+}
+
+/*
+========================
+VM_M_resethostcachemasks
+
+resethostcachemasks()
+========================
+*/
+void VM_M_resethostcachemasks( void )
+{
+ HostCache_ResetMasks();
+}
+
+
+/*
+========================
+VM_M_sethostcachemaskstring
+
+sethostcachemaskstring(float mask, float fld, string str, float op)
+0-511 and
+512 - 1024 or
+========================
+*/
+void VM_M_sethostcachemaskstring( void )
+{
+ char *str;
+ int masknr;
+ hostcache_mask_t *mask;
+ int field;
+
+ VM_SAFEPARMCOUNT( 4, VM_M_sethostcachemaskstring );
+ str = PRVM_G_STRING( OFS_PARM1 );
+ if( !str )
+ PRVM_ERROR( "VM_M_sethostcachemaskstring: null string passed!" );
+
+ masknr = PRVM_G_FLOAT( OFS_PARM0 );
+ if( masknr >= 0 && masknr <= HOSTCACHE_ANDMASKCOUNT )
+ mask = &hostcache_andmasks[masknr];
+ else if( masknr >= 512 && masknr - 512 <= HOSTCACHE_ORMASKCOUNT )
+ mask = &hostcache_ormasks[masknr - 512 ];
+ else {
+ Con_Printf( "VM_M_sethostcachemaskstring: invalid mask number %i\n", masknr );
+ return;
}
+
+ field = (int) PRVM_G_FLOAT( OFS_PARM1 );
+
+ switch( field ) {
+ case HCIF_CNAME:
+ strncpy( mask->info.cname, PRVM_G_STRING( OFS_PARM2 ), sizeof(mask->info.cname) );
+ break;
+ case HCIF_NAME:
+ strncpy( mask->info.name, PRVM_G_STRING( OFS_PARM2 ), sizeof(mask->info.name) );
+ break;
+ case HCIF_MAP:
+ strncpy( mask->info.map, PRVM_G_STRING( OFS_PARM2 ), sizeof(mask->info.map) );
+ break;
+ case HCIF_MOD:
+ strncpy( mask->info.mod, PRVM_G_STRING( OFS_PARM2 ), sizeof(mask->info.mod) );
+ break;
+ case HCIF_GAME:
+ strncpy( mask->info.game, PRVM_G_STRING( OFS_PARM2 ), sizeof(mask->info.game) );
+ break;
+ default:
+ Con_Printf( "VM_M_sethostcachemaskstring: Bad field number %i passed!\n", field );
+ return;
+ }
+
+ mask->active = true;
+ mask->tests[field] = (int) PRVM_G_FLOAT( OFS_PARM3 );
+}
+
+/*
+========================
+VM_M_sethostcachemasknumber
+
+sethostcachemasknumber(float mask, float fld, float num, float op)
+
+0-511 and
+512 - 1024 or
+========================
+*/
+void VM_M_sethostcachemasknumber( void )
+{
+ int number;
+ hostcache_mask_t *mask;
+ int masknr;
+ int field;
+ VM_SAFEPARMCOUNT( 4, VM_M_sethostcachemasknumber );
+
+ masknr = PRVM_G_FLOAT( OFS_PARM0 );
+ if( masknr >= 0 && masknr <= HOSTCACHE_ANDMASKCOUNT )
+ mask = &hostcache_andmasks[masknr];
+ else if( masknr >= 512 && masknr - 512 <= HOSTCACHE_ORMASKCOUNT )
+ mask = &hostcache_ormasks[masknr - 512 ];
+ else {
+ Con_Printf( "VM_M_sethostcachemasknumber: invalid mask number %i\n", masknr );
+ return;
+ }
+
+ number = PRVM_G_FLOAT( OFS_PARM2 );
+ field = (int) PRVM_G_FLOAT( OFS_PARM1 );
+
+ switch( field ) {
+ case HCIF_MAXPLAYERS:
+ mask->info.maxplayers = number;
+ break;
+ case HCIF_NUMPLAYERS:
+ mask->info.numplayers = number;
+ break;
+ case HCIF_PING:
+ mask->info.ping = number;
+ break;
+ case HCIF_PROTOCOL:
+ mask->info.protocol = number;
+ break;
+ default:
+ Con_Printf( "VM_M_sethostcachemasknumber: Bad field number %i passed!\n", field );
+ return;
+ }
+
+ mask->active = true;
+ mask->tests[field] = (int) PRVM_G_FLOAT( OFS_PARM3 );
+}
+
+
+/*
+========================
+VM_M_resorthostcache
+
+resorthostcache
+========================
+*/
+void VM_M_resorthostcache( void )
+{
+ HostCache_RebuildViewSet();
}
/*
=========
VM_M_gethostcachestring
-string gethostcachestring(float type, float hostnr)
+string gethostcachestring(float field, float hostnr)
=========
*/
-/*
-0 Get CName
-1 Get line1
-2 Get line2
-*/
void VM_M_gethostcachestring(void)
{
- int type;
+ hostcache_t *cache;
int hostnr;
VM_SAFEPARMCOUNT(2, VM_M_gethostcachestring);
PRVM_G_INT(OFS_RETURN) = 0;
- type = PRVM_G_FLOAT(OFS_PARM0);
-
- if(type < 0 || type > 2)
+ hostnr = PRVM_G_FLOAT(OFS_PARM1);
+
+ if(hostnr < 0 || hostnr >= hostcache_viewcount)
{
- Con_Print("VM_M_gethostcachestring: bad string type requested!\n");
+ Con_Print("VM_M_gethostcachestring: bad hostnr passed!\n");
return;
}
+ cache = hostcache_viewset[hostnr];
+ switch( (int) PRVM_G_FLOAT(OFS_PARM0) ) {
+ case HCIF_CNAME:
+ PRVM_G_INT( OFS_RETURN ) = PRVM_SetString( cache->info.cname );
+ break;
+ case HCIF_NAME:
+ PRVM_G_INT( OFS_RETURN ) = PRVM_SetString( cache->info.name );
+ break;
+ case HCIF_GAME:
+ PRVM_G_INT( OFS_RETURN ) = PRVM_SetString( cache->info.game );
+ break;
+ case HCIF_MOD:
+ PRVM_G_INT( OFS_RETURN ) = PRVM_SetString( cache->info.mod );
+ break;
+ case HCIF_MAP:
+ PRVM_G_INT( OFS_RETURN ) = PRVM_SetString( cache->info.map );
+ break;
+ // TODO remove this again
+ case 1024:
+ PRVM_G_INT( OFS_RETURN ) = PRVM_SetString( cache->line1 );
+ break;
+ case 1025:
+ PRVM_G_INT( OFS_RETURN ) = PRVM_SetString( cache->line2 );
+ break;
+ default:
+ Con_Print("VM_M_gethostcachestring: bad field number passed!\n");
+ }
+}
+
+/*
+=========
+VM_M_gethostcachenumber
+
+float gethostcachenumber(float field, float hostnr)
+=========
+*/
+void VM_M_gethostcachenumber(void)
+{
+ hostcache_t *cache;
+ int hostnr;
+
+ VM_SAFEPARMCOUNT(2, VM_M_gethostcachestring);
+
+ PRVM_G_INT(OFS_RETURN) = 0;
hostnr = PRVM_G_FLOAT(OFS_PARM1);
- if(hostnr < 0 || hostnr >= hostCacheCount)
+ if(hostnr < 0 || hostnr >= hostcache_viewcount)
{
Con_Print("VM_M_gethostcachestring: bad hostnr passed!\n");
return;
}
+ cache = hostcache_viewset[hostnr];
+ switch( (int) PRVM_G_FLOAT(OFS_PARM0) ) {
+ case HCIF_MAXPLAYERS:
+ PRVM_G_FLOAT( OFS_RETURN ) = cache->info.maxplayers;
+ break;
+ case HCIF_NUMPLAYERS:
+ PRVM_G_FLOAT( OFS_RETURN ) = cache->info.numplayers;
+ break;
+ case HCIF_PING:
+ PRVM_G_FLOAT( OFS_RETURN ) = cache->info.ping;
+ break;
+ case HCIF_PROTOCOL:
+ PRVM_G_FLOAT( OFS_RETURN ) = cache->info.protocol;
+ break;
+ default:
+ Con_Print("VM_M_gethostcachenumber: bad field number passed!\n");
+ }
+}
+
+/*
+========================
+VM_M_sethostcachesort
+
+sethostcachesort(float field, float descending)
+========================
+*/
+void VM_M_sethostcachesort( void )
+{
+ VM_SAFEPARMCOUNT( 2, VM_M_sethostcachesort );
+
+ hostcache_sortbyfield = (int) PRVM_G_FLOAT( OFS_PARM0 );
+ hostcache_sortdescending = (qboolean) PRVM_G_FLOAT( OFS_PARM1 );
+}
+
+/*
+========================
+VM_M_refreshhostcache
+
+refreshhostcache()
+========================
+*/
+void VM_M_refreshhostcache( void )
+{
+ VM_SAFEPARMCOUNT( 0, VM_M_refreshhostcache );
+ HostCache_QueryList();
+}
- if( type == 0 )
- PRVM_G_INT( OFS_RETURN ) = PRVM_SetString( hostcache[hostnr].cname );
- else if( type == 1 )
- PRVM_G_INT( OFS_RETURN ) = PRVM_SetString( hostcache[hostnr].line1 );
+/*
+========================
+VM_M_gethostcacheindexforkey
+
+float gethostcacheindexforkey(string key)
+========================
+*/
+void VM_M_gethostcacheindexforkey( void )
+{
+ char *key;
+ VM_SAFEPARMCOUNT( 1, VM_M_gethostcacheindexforkey );
+
+ key = PRVM_G_STRING( OFS_PARM0 );
+ VM_CheckEmptyString( key );
+
+ if( !strcmp( key, "cname" ) )
+ PRVM_G_FLOAT( OFS_RETURN ) = HCIF_CNAME;
+ else if( !strcmp( key, "ping" ) )
+ PRVM_G_FLOAT( OFS_RETURN ) = HCIF_PING;
+ else if( !strcmp( key, "game" ) )
+ PRVM_G_FLOAT( OFS_RETURN ) = HCIF_GAME;
+ else if( !strcmp( key, "mod" ) )
+ PRVM_G_FLOAT( OFS_RETURN ) = HCIF_MOD;
+ else if( !strcmp( key, "map" ) )
+ PRVM_G_FLOAT( OFS_RETURN ) = HCIF_MAP;
+ else if( !strcmp( key, "name" ) )
+ PRVM_G_FLOAT( OFS_RETURN ) = HCIF_NAME;
+ else if( !strcmp( key, "maxplayers" ) )
+ PRVM_G_FLOAT( OFS_RETURN ) = HCIF_MAXPLAYERS;
+ else if( !strcmp( key, "numplayers" ) )
+ PRVM_G_FLOAT( OFS_RETURN ) = HCIF_NUMPLAYERS;
+ else if( !strcmp( key, "protocol" ) )
+ PRVM_G_FLOAT( OFS_RETURN ) = HCIF_PROTOCOL;
else
- PRVM_G_INT( OFS_RETURN ) = PRVM_SetString( hostcache[hostnr].line2 );
+ PRVM_G_FLOAT( OFS_RETURN ) = -1;
+}
+
+/*
+========================
+VM_M_addwantedhostcachekey
+
+addwantedhostcachekey(string key)
+========================
+*/
+void VM_M_addwantedhostcachekey( void )
+{
+ VM_SAFEPARMCOUNT( 1, VM_M_addwantedhostcachekey );
}
prvm_builtin_t vm_m_builtins[] = {
VM_search_getfilename, // 77
VM_chr,
VM_itof,
- VM_ftoi,// 80
- e10, // 90
+ VM_ftoi, // 80
+ VM_itof, // isString
+ VM_altstr_count,
+ VM_altstr_prepare,
+ VM_altstr_get,
+ VM_altstr_set, // 85
+ 0,0,0,0,0, // 90
e10, // 100
e100, // 200
e100, // 300
VM_drawsetcliparea,
VM_drawresetcliparea,
VM_getimagesize,// 460
- e10, // 470
+ VM_cin_open,
+ VM_cin_close,
+ VM_cin_setstate,
+ VM_cin_getstate,
+ VM_cin_restart, // 465
+ 0,0,0,0,0, // 470
e10, // 480
e10, // 490
e10, // 500
VM_M_getresolution,
VM_M_keynumtostring,
VM_M_findkeysforcommand,// 610
- VM_M_gethostcachevalue,
+ VM_M_gethostcachestat,
VM_M_gethostcachestring,
- VM_M_parseentitydata // 613
+ VM_M_parseentitydata,
+ VM_M_stringtokeynum,
+ VM_M_resethostcachemasks,
+ VM_M_sethostcachemaskstring,
+ VM_M_sethostcachemasknumber,
+ VM_M_resorthostcache,
+ VM_M_sethostcachesort,
+ VM_M_refreshhostcache,
+ VM_M_gethostcachenumber,
+ VM_M_gethostcacheindexforkey,
+ VM_M_addwantedhostcachekey // 623
};
const int vm_m_numbuiltins = sizeof(vm_m_builtins) / sizeof(prvm_builtin_t);
projects / xonotic / darkplaces.git / blobdiff