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
===============================
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"
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);
}
return;
}
- //VM_CheckEmptyString(string); Why should it be checked - perhaps the menu wants to the precolored letters, too?
+ //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);
VM_SAFEPARMCOUNT( 1, VM_altstr_count );
altstr = PRVM_G_STRING( OFS_PARM0 );
- VM_CheckEmptyString( altstr );
+ //VM_CheckEmptyString( altstr );
for( count = 0, pos = altstr ; *pos ; pos++ )
if( *pos == '\\' && !*++pos )
VM_SAFEPARMCOUNT( 1, VM_altstr_prepare );
instr = PRVM_G_STRING( OFS_PARM0 );
- VM_CheckEmptyString( instr );
+ //VM_CheckEmptyString( instr );
outstr = VM_GetTempString();
for( out = outstr, in = instr, size = VM_STRINGTEMP_LENGTH - 1 ; size && *in ; size--, in++, out++ )
VM_SAFEPARMCOUNT( 2, VM_altstr_get );
altstr = PRVM_G_STRING( OFS_PARM0 );
- VM_CheckEmptyString( altstr );
+ //VM_CheckEmptyString( altstr );
count = PRVM_G_FLOAT( OFS_PARM1 );
count = count * 2 + 1;
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
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 ) = 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);
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
- if( type == 0 )
- PRVM_G_INT( OFS_RETURN ) = PRVM_SetString( hostcache_viewset[hostnr]->info.cname );
- else if( type == 1 )
- PRVM_G_INT( OFS_RETURN ) = PRVM_SetString( hostcache_viewset[hostnr]->line1 );
+refreshhostcache()
+========================
+*/
+void VM_M_refreshhostcache( void )
+{
+ VM_SAFEPARMCOUNT( 0, VM_M_refreshhostcache );
+ HostCache_QueryList();
+}
+
+/*
+========================
+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_viewset[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_itof, // isString
VM_altstr_count,
VM_altstr_prepare,
- VM_altstr_get, // 84
- 0,0,0,0,0,0, // 90
+ VM_altstr_get,
+ VM_altstr_set, // 85
+ 0,0,0,0,0, // 90
e10, // 100
e100, // 200
e100, // 300
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