entity findchainfloat(.string field, float match)
entity findchainentity(.string field, entity match)
-
+
string precache_file(string)
string precache_sound (string sample)
coredump()
const string str_cvar (string)
crash()
stackdump()
-
+
float search_begin(string pattern, float caseinsensitive, float quiet)
void search_end(float handle)
float search_getsize(float handle)
string altstr_prepare(string)
string altstr_get(string,float)
string altstr_set(string altstr, float num, string set)
-
-perhaps only : Menu : WriteMsg
+
+perhaps only : Menu : WriteMsg
===============================
WriteByte(float data, float dest, float desto)
WriteCoord(float data, float dest, float desto)
WriteString(string data, float dest, float desto)
WriteEntity(entity data, float dest, float desto)
-
+
Client & Menu : draw functions & video functions
===================================================
float iscachedpic(string pic)
-string precache_pic(string pic)
+string precache_pic(string pic)
freepic(string s)
float drawcharacter(vector position, float character, vector scale, vector rgb, float alpha, float flag)
float drawstring(vector position, string text, vector scale, vector rgb, float alpha, float flag)
float cin_open(string file, string name)
void cin_close(string name)
void cin_setstate(string name, float type)
-float cin_getstate(string name)
+float cin_getstate(string name)
void cin_restart(string name)
==============================================================================
float stringtokeynum(string key)
- resethostcachemask()
- sethostcachemaskstring(float fld, string str)
- sethostcachemasknumber(float fld, float num, float op)
+ 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"
Con_Printf("VM_sprint: %s: invalid client or server is not active !\n", PRVM_NAME);
return;
}
-
+
client = svs.clients + clientnum;
VM_VarString(1, string, sizeof(string));
MSG_WriteChar(&client->message,svc_print);
void VM_localsound(void)
{
char *s;
-
+
VM_SAFEPARMCOUNT(1,VM_localsound);
s = PRVM_G_STRING(OFS_PARM0);
Con_Printf("VM_localsound: Failed to play %s for %s !\n", s, PRVM_NAME);
PRVM_G_FLOAT(OFS_RETURN) = -4;
return;
- }
+ }
PRVM_G_FLOAT(OFS_RETURN) = 1;
}
const string str_cvar (string)
=================
*/
-void VM_str_cvar(void)
+void VM_str_cvar(void)
{
char *out, *name;
const char *cvar_string;
VM_CheckEmptyString(name);
- out = VM_GetTempString();
+ out = VM_GetTempString();
cvar_string = Cvar_VariableString(name);
-
+
strcpy(out, cvar_string);
PRVM_G_INT(OFS_RETURN) = PRVM_SetString(out);
ent = PRVM_G_FLOAT(OFS_PARM0);
if(PRVM_PROG_TO_EDICT(ent)->p.e->free)
PRVM_ERROR ("VM_ftoe: %s tried to access a freed entity (entity %i)!\n", PRVM_NAME, ent);
-
+
PRVM_G_INT(OFS_RETURN) = ent;
}
=========
*/
-void VM_crash(void)
+void VM_crash(void)
{
VM_SAFEPARMCOUNT(0, VM_crash);
if(!sv.active)
{
- Con_Printf("VM_changelevel: game is not server (%s)\n", PRVM_NAME);
+ Con_Printf("VM_changelevel: game is not server (%s)\n", PRVM_NAME);
return;
}
PRVM_G_FLOAT(OFS_RETURN) = -4;
return;
}
- VM_FILES[filenum] = FS_Open(va("data/%s", filename), modestring, false);
+ VM_FILES[filenum] = FS_Open(va("data/%s", filename), modestring, false, false);
if (VM_FILES[filenum] == NULL && mode == 0)
- VM_FILES[filenum] = FS_Open(va("%s", filename), modestring, false);
+ VM_FILES[filenum] = FS_Open(va("%s", filename), modestring, false, false);
if (VM_FILES[filenum] == NULL)
PRVM_G_FLOAT(OFS_RETURN) = -1;
string[end] = 0;
// remove \n following \r
if (c == '\r')
+ {
c = FS_Getc(VM_FILES[filenum]);
+ if (c != '\n')
+ FS_UnGetc(VM_FILES[filenum], (unsigned char)c);
+ }
if (developer.integer >= 3)
Con_Printf("fgets: %s: %s\n", PRVM_NAME, string);
if (c >= 0 || end)
{
char *s;
- if(prog->argc < 1)
+ if(prog->argc < 1)
PRVM_ERROR("VM_strcat wrong parameter count (min. 1 expected ) !\n");
-
+
s = VM_GetTempString();
VM_VarString(0, s, VM_STRINGTEMP_LENGTH);
PRVM_G_INT(OFS_RETURN) = PRVM_SetString(s);
{
VM_SAFEPARMCOUNT(0,VM_getmousepos);
-
+
PRVM_G_VECTOR(OFS_RETURN)[0] = in_mouse_x;
PRVM_G_VECTOR(OFS_RETURN)[1] = in_mouse_y;
PRVM_G_VECTOR(OFS_RETURN)[2] = 0;
const char *data;
VM_SAFEPARMCOUNT(2, VM_parseentitydata);
-
+
// get edict and test it
ent = PRVM_G_EDICT(OFS_PARM0);
if (ent->p.e->free)
{
char *filename;
qbyte *data;
-
+
VM_SAFEPARMCOUNT(1,VM_loadfromfile);
-
+
filename = PRVM_G_STRING(OFS_PARM0);
// .. is parent directory on many platforms
// / is parent directory on Amiga
data = FS_LoadFile(filename, tempmempool, false);
if (data == NULL)
PRVM_G_FLOAT(OFS_RETURN) = -1;
-
+
PRVM_ED_LoadFromFile(data);
if(data)
caseinsens = PRVM_G_FLOAT(OFS_PARM1);
quiet = PRVM_G_FLOAT(OFS_PARM2);
-
+
for(handle = 0; handle < MAX_VMSEARCHES; handle++)
if(!VM_SEARCHLIST[handle])
break;
VM_SAFEPARMCOUNT(1, VM_search_end);
handle = PRVM_G_FLOAT(OFS_PARM0);
-
+
if(handle < 0 || handle >= MAX_VMSEARCHES)
{
Con_Printf("VM_search_end: invalid handle %i used in %s\n", handle, PRVM_NAME);
Con_Printf("VM_search_getsize: no such handle %i in %s\n", handle, PRVM_NAME);
return;
}
-
+
PRVM_G_FLOAT(OFS_RETURN) = VM_SEARCHLIST[handle]->numfilenames;
}
Con_Printf("VM_search_getfilename: invalid filenum %i in %s\n", filenum, PRVM_NAME);
return;
}
-
+
tmp = VM_GetTempString();
strcpy(tmp, VM_SEARCHLIST[handle]->filenames[filenum]);
{
VM_SAFEPARMCOUNT(1,VM_iscachedpic);
- // drawq hasnt such a function, thus always return true
+ // drawq hasnt such a function, thus always return true
PRVM_G_FLOAT(OFS_RETURN) = false;
}
=========
VM_precache_pic
-string precache_pic(string pic)
+string precache_pic(string pic)
=========
*/
void VM_precache_pic(void)
{
char *s;
-
+
VM_SAFEPARMCOUNT(1, VM_precache_pic);
-
+
s = PRVM_G_STRING(OFS_PARM0);
PRVM_G_INT(OFS_RETURN) = PRVM_G_INT(OFS_PARM0);
-
+
if(!s)
PRVM_ERROR ("VM_precache_pic: %s: NULL\n", PRVM_NAME);
VM_CheckEmptyString (s);
-
+
if(!Draw_CachePic(s))
- PRVM_G_INT(OFS_RETURN) = PRVM_SetString("");
+ PRVM_G_INT(OFS_RETURN) = PRVM_SetString("");
}
/*
VM_SAFEPARMCOUNT(1,VM_freepic);
s = PRVM_G_STRING(OFS_PARM0);
-
+
if(!s)
PRVM_ERROR ("VM_freepic: %s: NULL\n");
-
+
VM_CheckEmptyString (s);
-
+
Draw_FreePic(s);
}
PRVM_G_FLOAT(OFS_RETURN) = -1;
return;
}
-
+
pos = PRVM_G_VECTOR(OFS_PARM0);
scale = PRVM_G_VECTOR(OFS_PARM2);
rgb = PRVM_G_VECTOR(OFS_PARM3);
flag = (int)PRVM_G_FLOAT(OFS_PARM5);
-
+
if(flag < DRAWFLAG_NORMAL || flag >=DRAWFLAG_NUMFLAGS)
{
Con_Printf("VM_drawcharacter: %s: wrong DRAWFLAG %i !\n",PRVM_NAME,flag);
PRVM_G_FLOAT(OFS_RETURN) = -2;
return;
}
-
+
if(pos[2] || scale[2])
- Con_Printf("VM_drawcharacter: z value%c from %s discarded\n",(pos[2] && scale[2]) ? 's' : 0,((pos[2] && scale[2]) ? "pos and scale" : (pos[2] ? "pos" : "scale")));
+ Con_Printf("VM_drawcharacter: z value%c from %s discarded\n",(pos[2] && scale[2]) ? 's' : 0,((pos[2] && scale[2]) ? "pos and scale" : (pos[2] ? "pos" : "scale")));
if(!scale[0] || !scale[1])
{
DrawQ_String (pos[0], pos[1], &character, 1, scale[0], scale[1], rgb[0], rgb[1], rgb[2], PRVM_G_FLOAT(OFS_PARM4), flag);
PRVM_G_FLOAT(OFS_RETURN) = 1;
-}
+}
/*
=========
char *string;
int flag;
VM_SAFEPARMCOUNT(6,VM_drawstring);
-
+
string = PRVM_G_STRING(OFS_PARM1);
if(!string)
{
PRVM_G_FLOAT(OFS_RETURN) = -1;
return;
}
-
+
//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);
rgb = PRVM_G_VECTOR(OFS_PARM3);
flag = (int)PRVM_G_FLOAT(OFS_PARM5);
-
+
if(flag < DRAWFLAG_NORMAL || flag >=DRAWFLAG_NUMFLAGS)
{
Con_Printf("VM_drawstring: %s: wrong DRAWFLAG %i !\n",PRVM_NAME,flag);
PRVM_G_FLOAT(OFS_RETURN) = -2;
return;
}
-
+
if(!scale[0] || !scale[1])
{
Con_Printf("VM_drawstring: scale %s is null !\n", (scale[0] == 0) ? ((scale[1] == 0) ? "x and y" : "x") : "y");
}
if(pos[2] || scale[2])
- Con_Printf("VM_drawstring: z value%c from %s discarded\n",(pos[2] && scale[2]) ? 's' : 0,((pos[2] && scale[2]) ? "pos and scale" : (pos[2] ? "pos" : "scale")));
-
+ Con_Printf("VM_drawstring: z value%c from %s discarded\n",(pos[2] && scale[2]) ? 's' : 0,((pos[2] && scale[2]) ? "pos and scale" : (pos[2] ? "pos" : "scale")));
+
DrawQ_String (pos[0], pos[1], string, 0, scale[0], scale[1], rgb[0], rgb[1], rgb[2], PRVM_G_FLOAT(OFS_PARM4), flag);
PRVM_G_FLOAT(OFS_RETURN) = 1;
}
if(!pic)
{
Con_Printf("VM_drawpic: %s passed null picture name !\n", PRVM_NAME);
- PRVM_G_FLOAT(OFS_RETURN) = -1;
+ PRVM_G_FLOAT(OFS_RETURN) = -1;
return;
}
PRVM_G_FLOAT(OFS_RETURN) = -4;
return;
}
-
+
pos = PRVM_G_VECTOR(OFS_PARM0);
size = PRVM_G_VECTOR(OFS_PARM2);
rgb = PRVM_G_VECTOR(OFS_PARM3);
}
if(pos[2] || size[2])
- Con_Printf("VM_drawstring: z value%c from %s discarded\n",(pos[2] && size[2]) ? 's' : 0,((pos[2] && size[2]) ? "pos and size" : (pos[2] ? "pos" : "size")));
-
+ Con_Printf("VM_drawstring: z value%c from %s discarded\n",(pos[2] && size[2]) ? 's' : 0,((pos[2] && size[2]) ? "pos and size" : (pos[2] ? "pos" : "size")));
+
DrawQ_Pic(pos[0], pos[1], pic, size[0], size[1], rgb[0], rgb[1], rgb[2], PRVM_G_FLOAT(OFS_PARM4), flag);
PRVM_G_FLOAT(OFS_RETURN) = 1;
}
{
float *size, *pos, *rgb;
int flag;
-
+
VM_SAFEPARMCOUNT(5,VM_drawfill);
-
-
+
+
pos = PRVM_G_VECTOR(OFS_PARM0);
size = PRVM_G_VECTOR(OFS_PARM1);
rgb = PRVM_G_VECTOR(OFS_PARM2);
flag = (int) PRVM_G_FLOAT(OFS_PARM4);
-
+
if(flag < DRAWFLAG_NORMAL || flag >=DRAWFLAG_NUMFLAGS)
{
Con_Printf("VM_drawstring: %s: wrong DRAWFLAG %i !\n",PRVM_NAME,flag);
PRVM_G_FLOAT(OFS_RETURN) = -2;
return;
}
-
+
if(pos[2] || size[2])
- Con_Printf("VM_drawstring: z value%c from %s discarded\n",(pos[2] && size[2]) ? 's' : 0,((pos[2] && size[2]) ? "pos and size" : (pos[2] ? "pos" : "size")));
-
+ Con_Printf("VM_drawstring: z value%c from %s discarded\n",(pos[2] && size[2]) ? 's' : 0,((pos[2] && size[2]) ? "pos and size" : (pos[2] ? "pos" : "size")));
+
DrawQ_Pic(pos[0], pos[1], 0, size[0], size[1], rgb[0], rgb[1], rgb[2], PRVM_G_FLOAT(OFS_PARM3), flag);
PRVM_G_FLOAT(OFS_RETURN) = 1;
}
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));
+ h = bound(0, PRVM_G_FLOAT(OFS_PARM3) + PRVM_G_FLOAT(OFS_PARM1) - y, (vid.conheight - y));
DrawQ_SetClipArea(x, y, w, h);
}
cachepic_t *pic;
VM_SAFEPARMCOUNT(1,VM_getimagesize);
-
+
p = PRVM_G_STRING(OFS_PARM0);
if(!p)
PRVM_ERROR("VM_getimagepos: %s passed null picture name !\n", PRVM_NAME);
-
+
VM_CheckEmptyString (p);
pic = Draw_CachePic (p);
{
char *file;
char *name;
-
+
VM_SAFEPARMCOUNT( 2, VM_cin_open );
-
+
file = PRVM_G_STRING( OFS_PARM0 );
name = PRVM_G_STRING( OFS_PARM1 );
name = PRVM_G_STRING( OFS_PARM0 );
VM_CheckEmptyString( name );
- CL_CloseVideo( CL_GetVideo( name ) );
+ CL_CloseVideo( CL_GetVideo( name ) );
}
/*
video = CL_GetVideo( name );
if( video && state > CLVIDEO_UNUSED && state < CLVIDEO_STATECOUNT )
- CL_SetVideoState( video, state );
+ CL_SetVideoState( video, state );
}
/*
for( pos = altstr ; *pos && count ; pos++ )
if( *pos == '\\' && !*++pos )
- break;
+ break;
else if( *pos == '\'' )
count--;
for( ; *str; *out++ = *str++ );
// now jump over the old contents
for( ; *in ; in++ )
- if( *in == '\'' || *in == '\\' && !*++in )
+ if( *in == '\'' || (*in == '\\' && !*++in) )
break;
-
+
if( !in ) {
PRVM_G_INT( OFS_RETURN ) = PRVM_SetString( "" );
return;
else
PRVM_G_FLOAT(OFS_RETURN) = 1;
}
-
+
/*
VM_M_callfunction
callfunction(...,string function_name)
-Extension: pass
+Extension: pass
=========
*/
mfunction_t *PRVM_ED_FindFunction (const char *name);
if(!s)
PRVM_ERROR("VM_M_callfunction: null string !\n");
- VM_CheckEmptyString(s);
+ VM_CheckEmptyString(s);
func = PRVM_ED_FindFunction(s);
PRVM_ExecuteProgram(func - prog->functions,"");
prog->argc++;
}
-}
+}
/*
=========
{
mfunction_t *func;
char *s;
-
+
VM_SAFEPARMCOUNT(1, VM_M_isfunction);
-
+
s = PRVM_G_STRING(OFS_PARM0);
-
+
if(!s)
PRVM_ERROR("VM_M_isfunction: null string !\n");
-
- VM_CheckEmptyString(s);
-
+
+ VM_CheckEmptyString(s);
+
func = PRVM_ED_FindFunction(s);
if(!func)
return;
}
- ent = PRVM_G_EDICT(OFS_PARM1);
+ ent = PRVM_G_EDICT(OFS_PARM1);
if(ent->p.e->free)
{
Con_Printf("VM_M_writetofile: %s: entity %i is free !\n", PRVM_NAME, PRVM_EDICT_NUM(OFS_PARM1));
PRVM_G_VECTOR(OFS_RETURN)[0] = video_resolutions[nr][0];
PRVM_G_VECTOR(OFS_RETURN)[1] = video_resolutions[nr][1];
- PRVM_G_VECTOR(OFS_RETURN)[2] = 0;
+ PRVM_G_VECTOR(OFS_RETURN)[2] = 0;
}
/*
keynum = PRVM_G_FLOAT(OFS_PARM0);
tmp = VM_GetTempString();
-
+
strcpy(tmp, Key_KeynumToString(keynum));
PRVM_G_INT(OFS_RETURN) = PRVM_SetString(tmp);
VM_SAFEPARMCOUNT(1, VM_M_findkeysforcommand);
cmd = PRVM_G_STRING(OFS_PARM0);
-
+
VM_CheckEmptyString(cmd);
(ret = VM_GetTempString())[0] = 0;
-
+
M_FindKeysForCommand(cmd, keys);
for(i = 0; i < NUMKEYS; i++)
PRVM_G_FLOAT ( OFS_RETURN ) = hostcache_viewcount;
return;
case 1:
- PRVM_G_FLOAT ( OFS_RETURN ) = hostcache_cachecount;
+ PRVM_G_FLOAT ( OFS_RETURN ) = hostcache_cachecount;
case 2:
PRVM_G_FLOAT ( OFS_RETURN ) = masterquerycount;
return;
/*
========================
-VM_M_resethostcachemask
+VM_M_resethostcachemasks
-resethostcachemask()
+resethostcachemasks()
========================
*/
-void VM_M_resethostcachemask( void )
+void VM_M_resethostcachemasks( void )
{
- HostCache_ResetMask();
+ HostCache_ResetMasks();
}
========================
VM_M_sethostcachemaskstring
-sethostcachemaskstring(float field, string str)
+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( 2, VM_M_sethostcachemask );
+ VM_SAFEPARMCOUNT( 4, VM_M_sethostcachemaskstring );
str = PRVM_G_STRING( OFS_PARM1 );
if( !str )
- PRVM_ERROR( "VM_M_sethostcachemask: null string passed!" );
+ 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;
+ }
- switch( (int) PRVM_G_FLOAT( OFS_PARM0 ) ) {
+ field = (int) PRVM_G_FLOAT( OFS_PARM1 );
+
+ switch( field ) {
case HCIF_CNAME:
- strncpy( hostcache_currentmask.info.cname, PRVM_G_STRING( OFS_PARM1 ), sizeof(hostcache_currentmask.info.cname) );
+ strncpy( mask->info.cname, PRVM_G_STRING( OFS_PARM2 ), sizeof(mask->info.cname) );
break;
case HCIF_NAME:
- strncpy( hostcache_currentmask.info.name, PRVM_G_STRING( OFS_PARM1 ), sizeof(hostcache_currentmask.info.name) );
+ strncpy( mask->info.name, PRVM_G_STRING( OFS_PARM2 ), sizeof(mask->info.name) );
break;
case HCIF_MAP:
- strncpy( hostcache_currentmask.info.map, PRVM_G_STRING( OFS_PARM1 ), sizeof(hostcache_currentmask.info.map) );
+ strncpy( mask->info.map, PRVM_G_STRING( OFS_PARM2 ), sizeof(mask->info.map) );
break;
case HCIF_MOD:
- strncpy( hostcache_currentmask.info.mod, PRVM_G_STRING( OFS_PARM1 ), sizeof(hostcache_currentmask.info.mod) );
+ strncpy( mask->info.mod, PRVM_G_STRING( OFS_PARM2 ), sizeof(mask->info.mod) );
break;
case HCIF_GAME:
- strncpy( hostcache_currentmask.info.game, PRVM_G_STRING( OFS_PARM1 ), sizeof(hostcache_currentmask.info.game) );
+ strncpy( mask->info.game, PRVM_G_STRING( OFS_PARM2 ), sizeof(mask->info.game) );
break;
default:
- Con_Printf( "VM_M_sethostcachemask: Bad field number %i passed!\n", PRVM_G_INT( OFS_PARM0 ) );
+ 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 field, float num, float op)
+sethostcachemasknumber(float mask, float fld, float num, float op)
+
+0-511 and
+512 - 1024 or
========================
*/
void VM_M_sethostcachemasknumber( void )
{
int number;
- hostcache_maskop_t operand;
- VM_SAFEPARMCOUNT( 3, VM_M_sethostcachemasknumber );
+ 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_PARM1 );
- operand = (int) PRVM_G_FLOAT( OFS_PARM2 );
+ number = PRVM_G_FLOAT( OFS_PARM2 );
+ field = (int) PRVM_G_FLOAT( OFS_PARM1 );
- switch( (int) PRVM_G_FLOAT( OFS_PARM0 ) ) {
+ switch( field ) {
case HCIF_MAXPLAYERS:
- hostcache_currentmask.info.maxplayers = number;
- hostcache_currentmask.maxplayerstest = operand;
+ mask->info.maxplayers = number;
break;
case HCIF_NUMPLAYERS:
- hostcache_currentmask.info.numplayers = number;
- hostcache_currentmask.numplayerstest = operand;
+ mask->info.numplayers = number;
break;
case HCIF_PING:
- hostcache_currentmask.info.ping = number;
- hostcache_currentmask.pingtest = operand;
+ mask->info.ping = number;
break;
case HCIF_PROTOCOL:
- hostcache_currentmask.info.protocol = number;
- hostcache_currentmask.protocoltest = operand;
+ mask->info.protocol = number;
break;
default:
- Con_Printf( "VM_M_sethostcachemask: Bad field number %i passed!\n", PRVM_G_INT( OFS_PARM0 ) );
+ 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 );
}
*/
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_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[] = {
0, // to be consistent with the old vm
// common builtings (mostly)
VM_tokenize,
VM_argv,
VM_isserver, // 60
- VM_clientcount,
- VM_clientstate,
+ VM_clientcount,
+ VM_clientstate,
VM_clcommand,
VM_changelevel,
- VM_localsound,
+ VM_localsound,
VM_getmousepos,
VM_gettime,
VM_loadfromdata,
VM_loadfromfile,
VM_modulo, // 70
- VM_str_cvar,
+ VM_str_cvar,
VM_crash,
VM_stackdump, // 73
VM_search_begin,
VM_search_end,
VM_search_getsize,
VM_search_getfilename, // 77
- VM_chr,
+ VM_chr,
VM_itof,
VM_ftoi, // 80
VM_itof, // isString
VM_drawcharacter,
VM_drawstring,
VM_drawpic,
- VM_drawfill,
+ VM_drawfill,
VM_drawsetcliparea,
VM_drawresetcliparea,
VM_getimagesize,// 460
VM_cin_open,
VM_cin_close,
- VM_cin_setstate,
+ VM_cin_setstate,
VM_cin_getstate,
VM_cin_restart, // 465
0,0,0,0,0, // 470
VM_M_gethostcachestring,
VM_M_parseentitydata,
VM_M_stringtokeynum,
- VM_M_resethostcachemask,
+ VM_M_resethostcachemasks,
VM_M_sethostcachemaskstring,
VM_M_sethostcachemasknumber,
VM_M_resorthostcache,
VM_M_sethostcachesort,
VM_M_refreshhostcache,
- VM_M_gethostcachenumber // 621
+ 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