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
+string altstr_ins(string altstr, float num, string set)
+
+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)
==============================================================================
setkeydest(float dest)
float getkeydest()
setmousetarget(float target)
-float getmousetarget(void)
+float getmousetarget()
callfunction(...,string function_name)
writetofile(float fhandle, entity ent)
string keynumtostring(float keynum)
string findkeysforcommand(string command)
float gethostcachestat(float type)
-string gethostcachestring(float type, float hostnr)
+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"
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 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);
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 );
}
/*
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;
for( pos = altstr ; *pos && count ; pos++ )
if( *pos == '\\' && !*++pos )
- break;
+ break;
else if( *pos == '\'' )
count--;
VM_SAFEPARMCOUNT( 3, VM_altstr_set );
altstr = PRVM_G_STRING( OFS_PARM0 );
- VM_CheckEmptyString( altstr );
+ //VM_CheckEmptyString( altstr );
num = PRVM_G_FLOAT( OFS_PARM1 );
str = PRVM_G_STRING( OFS_PARM2 );
- VM_CheckEmptyString( str );
+ //VM_CheckEmptyString( str );
outstr = out = VM_GetTempString();
for( num = num * 2 + 1, in = altstr; *in && num; *out++ = *in++ )
// copy set in
for( ; *str; *out++ = *str++ );
// now jump over the old contents
- for( ; *in; *out++ = *in++ )
- if( *in == '\'' || *in == '\\' && !*++in )
+ for( ; *in ; in++ )
+ if( *in == '\'' || (*in == '\\' && !*++in) )
break;
-
+
if( !in ) {
PRVM_G_INT( OFS_RETURN ) = PRVM_SetString( "" );
return;
PRVM_G_INT( OFS_RETURN ) = PRVM_SetString( outstr );
}
+/*
+========================
+VM_altstr_ins
+insert after num
+string altstr_ins(string altstr, float num, string set)
+========================
+*/
+void VM_altstr_ins(void)
+{
+ int num;
+ char *setstr;
+ char *set;
+ char *instr;
+ char *in;
+ char *outstr;
+ char *out;
+
+ in = instr = PRVM_G_STRING( OFS_PARM0 );
+ num = PRVM_G_FLOAT( OFS_PARM1 );
+ set = setstr = PRVM_G_STRING( OFS_PARM2 );
+
+ out = outstr = VM_GetTempString();
+ for( num = num * 2 + 2 ; *in && num > 0 ; *out++ = *in++ )
+ if( *in == '\\' && !*++in )
+ break;
+ else if( *in == '\'' )
+ num--;
+
+ for( ; *set ; *out++ = *set++ );
+
+ strcpy( out, in );
+ PRVM_G_INT( OFS_RETURN ) = PRVM_SetString( outstr );
+}
+
void VM_Cmd_Init(void)
{
// only init the stuff for the current prog
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_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_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++)
3 masterreplycount
4 serverquerycount
5 serverreplycount
+6 sortfield
+7 sortdescending
*/
void VM_M_gethostcachestat( void )
{
PRVM_G_FLOAT( OFS_RETURN ) = 0;
type = PRVM_G_FLOAT( OFS_PARM0 );
- if( type < 0 || type > 4 )
- Con_Printf( "VM_M_gethostcachestat: 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;
+ PRVM_G_FLOAT ( OFS_RETURN ) = hostcache_cachecount;
case 2:
PRVM_G_FLOAT ( OFS_RETURN ) = masterquerycount;
return;
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_sethostcachemask
+VM_M_resethostcachemasks
-sethostcachemask( string map, string mod, string name,
+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");
+ }
+}
- 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 );
+/*
+========================
+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();
+}
+
+/*
+========================
+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_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_altstr_count,
VM_altstr_prepare,
VM_altstr_get,
- VM_altstr_set, // 85
- 0,0,0,0,0, // 90
+ VM_altstr_set,
+ VM_altstr_ins, // 86
+ 0,0,0,0, // 90
e10, // 100
e100, // 200
e100, // 300
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_findkeysforcommand,// 610
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