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)
==============================================================================
vector getresolution(float number)
string keynumtostring(float keynum)
string findkeysforcommand(string command)
-float gethostcachestat(float type)
-string gethostcachestring(float fld, float hostnr)
+float getserverliststat(float type)
+string getserverliststring(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)
+ resetserverlistmasks()
+ setserverlistmaskstring(float mask, float fld, string str)
+ setserverlistmasknumber(float mask, float fld, float num, float op)
+ resortserverlist()
+ setserverlistsort(float field, float descending)
+ refreshserverlist()
+float getserverlistnumber(float fld, float hostnr)
+float getserverlistindexforkey(string key)
+ addwantedserverlistkey(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(1,VM_strunzone);
str = PRVM_G_STRING(OFS_PARM0);
+ if( !str )
+ PRVM_ERROR( "VM_strunzone: s%: Null string passed!", PRVM_NAME );
if( developer.integer && !Mem_IsAllocated( VM_STRINGS_MEMPOOL, str ) )
PRVM_ERROR( "VM_strunzone: Zone string already freed in %s!", PRVM_NAME );
else
{
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("");
+
+ if(!Draw_CachePic(s, false))
+ 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);
+ pic = Draw_CachePic (p, false);
PRVM_G_VECTOR(OFS_RETURN)[0] = pic->width;
PRVM_G_VECTOR(OFS_RETURN)[1] = pic->height;
{
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( ; *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_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++)
/*
=========
-VM_M_gethostcachestat
+VM_M_getserverliststat
-float gethostcachestat(float type)
+float getserverliststat(float type)
=========
*/
/*
type:
-0 hostcache_viewcount
-1 hostcache_totalcount
+0 serverlist_viewcount
+1 serverlist_totalcount
2 masterquerycount
3 masterreplycount
4 serverquerycount
6 sortfield
7 sortdescending
*/
-void VM_M_gethostcachestat( void )
+void VM_M_getserverliststat( void )
{
int type;
- VM_SAFEPARMCOUNT ( 1, VM_M_gethostcachestat );
+ VM_SAFEPARMCOUNT ( 1, VM_M_getserverliststat );
PRVM_G_FLOAT( OFS_RETURN ) = 0;
switch(type)
{
case 0:
- PRVM_G_FLOAT ( OFS_RETURN ) = hostcache_viewcount;
+ PRVM_G_FLOAT ( OFS_RETURN ) = serverlist_viewcount;
return;
case 1:
- PRVM_G_FLOAT ( OFS_RETURN ) = hostcache_cachecount;
+ PRVM_G_FLOAT ( OFS_RETURN ) = serverlist_cachecount;
case 2:
PRVM_G_FLOAT ( OFS_RETURN ) = masterquerycount;
return;
PRVM_G_FLOAT ( OFS_RETURN ) = serverreplycount;
return;
case 6:
- PRVM_G_FLOAT ( OFS_RETURN ) = hostcache_sortbyfield;
+ PRVM_G_FLOAT ( OFS_RETURN ) = serverlist_sortbyfield;
return;
case 7:
- PRVM_G_FLOAT ( OFS_RETURN ) = hostcache_sortdescending;
+ PRVM_G_FLOAT ( OFS_RETURN ) = serverlist_sortdescending;
return;
default:
- Con_Printf( "VM_M_gethostcachestat: bad type %i!\n", type );
+ Con_Printf( "VM_M_getserverliststat: bad type %i!\n", type );
}
}
/*
========================
-VM_M_resethostcachemasks
+VM_M_resetserverlistmasks
-resethostcachemasks()
+resetserverlistmasks()
========================
*/
-void VM_M_resethostcachemasks( void )
+void VM_M_resetserverlistmasks( void )
{
- HostCache_ResetMasks();
+ ServerList_ResetMasks();
}
/*
========================
-VM_M_sethostcachemaskstring
+VM_M_setserverlistmaskstring
-sethostcachemaskstring(float mask, float fld, string str, float op)
+setserverlistmaskstring(float mask, float fld, string str, float op)
0-511 and
512 - 1024 or
========================
*/
-void VM_M_sethostcachemaskstring( void )
+void VM_M_setserverlistmaskstring( void )
{
char *str;
int masknr;
- hostcache_mask_t *mask;
+ serverlist_mask_t *mask;
int field;
- VM_SAFEPARMCOUNT( 4, VM_M_sethostcachemaskstring );
+ VM_SAFEPARMCOUNT( 4, VM_M_setserverlistmaskstring );
str = PRVM_G_STRING( OFS_PARM1 );
if( !str )
- PRVM_ERROR( "VM_M_sethostcachemaskstring: null string passed!" );
+ PRVM_ERROR( "VM_M_setserverlistmaskstring: 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 ];
+ if( masknr >= 0 && masknr <= SERVERLIST_ANDMASKCOUNT )
+ mask = &serverlist_andmasks[masknr];
+ else if( masknr >= 512 && masknr - 512 <= SERVERLIST_ORMASKCOUNT )
+ mask = &serverlist_ormasks[masknr - 512 ];
else {
- Con_Printf( "VM_M_sethostcachemaskstring: invalid mask number %i\n", masknr );
+ Con_Printf( "VM_M_setserverlistmaskstring: invalid mask number %i\n", masknr );
return;
}
field = (int) PRVM_G_FLOAT( OFS_PARM1 );
-
+
switch( field ) {
- case HCIF_CNAME:
+ case SLIF_CNAME:
strncpy( mask->info.cname, PRVM_G_STRING( OFS_PARM2 ), sizeof(mask->info.cname) );
break;
- case HCIF_NAME:
+ case SLIF_NAME:
strncpy( mask->info.name, PRVM_G_STRING( OFS_PARM2 ), sizeof(mask->info.name) );
break;
- case HCIF_MAP:
+ case SLIF_MAP:
strncpy( mask->info.map, PRVM_G_STRING( OFS_PARM2 ), sizeof(mask->info.map) );
break;
- case HCIF_MOD:
+ case SLIF_MOD:
strncpy( mask->info.mod, PRVM_G_STRING( OFS_PARM2 ), sizeof(mask->info.mod) );
break;
- case HCIF_GAME:
+ case SLIF_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 );
+ Con_Printf( "VM_M_setserverlistmaskstring: Bad field number %i passed!\n", field );
return;
}
mask->active = true;
mask->tests[field] = (int) PRVM_G_FLOAT( OFS_PARM3 );
-}
+}
/*
========================
-VM_M_sethostcachemasknumber
+VM_M_setserverlistmasknumber
-sethostcachemasknumber(float mask, float fld, float num, float op)
+setserverlistmasknumber(float mask, float fld, float num, float op)
0-511 and
512 - 1024 or
========================
*/
-void VM_M_sethostcachemasknumber( void )
+void VM_M_setserverlistmasknumber( void )
{
int number;
- hostcache_mask_t *mask;
+ serverlist_mask_t *mask;
int masknr;
int field;
- VM_SAFEPARMCOUNT( 4, VM_M_sethostcachemasknumber );
+ VM_SAFEPARMCOUNT( 4, VM_M_setserverlistmasknumber );
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 ];
+ if( masknr >= 0 && masknr <= SERVERLIST_ANDMASKCOUNT )
+ mask = &serverlist_andmasks[masknr];
+ else if( masknr >= 512 && masknr - 512 <= SERVERLIST_ORMASKCOUNT )
+ mask = &serverlist_ormasks[masknr - 512 ];
else {
- Con_Printf( "VM_M_sethostcachemasknumber: invalid mask number %i\n", masknr );
+ Con_Printf( "VM_M_setserverlistmasknumber: invalid mask number %i\n", masknr );
return;
}
field = (int) PRVM_G_FLOAT( OFS_PARM1 );
switch( field ) {
- case HCIF_MAXPLAYERS:
+ case SLIF_MAXPLAYERS:
mask->info.maxplayers = number;
break;
- case HCIF_NUMPLAYERS:
+ case SLIF_NUMPLAYERS:
mask->info.numplayers = number;
break;
- case HCIF_PING:
+ case SLIF_PING:
mask->info.ping = number;
break;
- case HCIF_PROTOCOL:
+ case SLIF_PROTOCOL:
mask->info.protocol = number;
break;
default:
- Con_Printf( "VM_M_sethostcachemasknumber: Bad field number %i passed!\n", field );
+ Con_Printf( "VM_M_setserverlistmasknumber: Bad field number %i passed!\n", field );
return;
}
/*
========================
-VM_M_resorthostcache
+VM_M_resortserverlist
-resorthostcache
+resortserverlist
========================
*/
-void VM_M_resorthostcache( void )
+void VM_M_resortserverlist( void )
{
- HostCache_RebuildViewSet();
+ ServerList_RebuildViewList();
}
/*
=========
-VM_M_gethostcachestring
+VM_M_getserverliststring
-string gethostcachestring(float field, float hostnr)
+string getserverliststring(float field, float hostnr)
=========
*/
-void VM_M_gethostcachestring(void)
+void VM_M_getserverliststring(void)
{
- hostcache_t *cache;
+ serverlist_entry_t *cache;
int hostnr;
- VM_SAFEPARMCOUNT(2, VM_M_gethostcachestring);
+ VM_SAFEPARMCOUNT(2, VM_M_getserverliststring);
PRVM_G_INT(OFS_RETURN) = 0;
hostnr = PRVM_G_FLOAT(OFS_PARM1);
- if(hostnr < 0 || hostnr >= hostcache_viewcount)
+ if(hostnr < 0 || hostnr >= serverlist_viewcount)
{
- Con_Print("VM_M_gethostcachestring: bad hostnr passed!\n");
+ Con_Print("VM_M_getserverliststring: bad hostnr passed!\n");
return;
}
- cache = hostcache_viewset[hostnr];
+ cache = serverlist_viewlist[hostnr];
switch( (int) PRVM_G_FLOAT(OFS_PARM0) ) {
- case HCIF_CNAME:
+ case SLIF_CNAME:
PRVM_G_INT( OFS_RETURN ) = PRVM_SetString( cache->info.cname );
break;
- case HCIF_NAME:
+ case SLIF_NAME:
PRVM_G_INT( OFS_RETURN ) = PRVM_SetString( cache->info.name );
break;
- case HCIF_GAME:
+ case SLIF_GAME:
PRVM_G_INT( OFS_RETURN ) = PRVM_SetString( cache->info.game );
break;
- case HCIF_MOD:
+ case SLIF_MOD:
PRVM_G_INT( OFS_RETURN ) = PRVM_SetString( cache->info.mod );
break;
- case HCIF_MAP:
+ case SLIF_MAP:
PRVM_G_INT( OFS_RETURN ) = PRVM_SetString( cache->info.map );
break;
// TODO remove this again
PRVM_G_INT( OFS_RETURN ) = PRVM_SetString( cache->line2 );
break;
default:
- Con_Print("VM_M_gethostcachestring: bad field number passed!\n");
+ Con_Print("VM_M_getserverliststring: bad field number passed!\n");
}
}
/*
=========
-VM_M_gethostcachenumber
+VM_M_getserverlistnumber
-float gethostcachenumber(float field, float hostnr)
+float getserverlistnumber(float field, float hostnr)
=========
*/
-void VM_M_gethostcachenumber(void)
+void VM_M_getserverlistnumber(void)
{
- hostcache_t *cache;
+ serverlist_entry_t *cache;
int hostnr;
- VM_SAFEPARMCOUNT(2, VM_M_gethostcachestring);
+ VM_SAFEPARMCOUNT(2, VM_M_getserverliststring);
PRVM_G_INT(OFS_RETURN) = 0;
hostnr = PRVM_G_FLOAT(OFS_PARM1);
- if(hostnr < 0 || hostnr >= hostcache_viewcount)
+ if(hostnr < 0 || hostnr >= serverlist_viewcount)
{
- Con_Print("VM_M_gethostcachestring: bad hostnr passed!\n");
+ Con_Print("VM_M_getserverliststring: bad hostnr passed!\n");
return;
}
- cache = hostcache_viewset[hostnr];
+ cache = serverlist_viewlist[hostnr];
switch( (int) PRVM_G_FLOAT(OFS_PARM0) ) {
- case HCIF_MAXPLAYERS:
+ case SLIF_MAXPLAYERS:
PRVM_G_FLOAT( OFS_RETURN ) = cache->info.maxplayers;
break;
- case HCIF_NUMPLAYERS:
+ case SLIF_NUMPLAYERS:
PRVM_G_FLOAT( OFS_RETURN ) = cache->info.numplayers;
break;
- case HCIF_PING:
+ case SLIF_PING:
PRVM_G_FLOAT( OFS_RETURN ) = cache->info.ping;
break;
- case HCIF_PROTOCOL:
+ case SLIF_PROTOCOL:
PRVM_G_FLOAT( OFS_RETURN ) = cache->info.protocol;
break;
default:
- Con_Print("VM_M_gethostcachenumber: bad field number passed!\n");
+ Con_Print("VM_M_getserverlistnumber: bad field number passed!\n");
}
}
/*
========================
-VM_M_sethostcachesort
+VM_M_setserverlistsort
-sethostcachesort(float field, float descending)
+setserverlistsort(float field, float descending)
========================
*/
-void VM_M_sethostcachesort( void )
+void VM_M_setserverlistsort( void )
{
- VM_SAFEPARMCOUNT( 2, VM_M_sethostcachesort );
+ VM_SAFEPARMCOUNT( 2, VM_M_setserverlistsort );
- hostcache_sortbyfield = (int) PRVM_G_FLOAT( OFS_PARM0 );
- hostcache_sortdescending = (qboolean) PRVM_G_FLOAT( OFS_PARM1 );
+ serverlist_sortbyfield = (int) PRVM_G_FLOAT( OFS_PARM0 );
+ serverlist_sortdescending = (qboolean) PRVM_G_FLOAT( OFS_PARM1 );
}
/*
========================
-VM_M_refreshhostcache
+VM_M_refreshserverlist
-refreshhostcache()
+refreshserverlist()
========================
*/
-void VM_M_refreshhostcache( void )
+void VM_M_refreshserverlist( void )
{
- VM_SAFEPARMCOUNT( 0, VM_M_refreshhostcache );
- HostCache_QueryList();
+ VM_SAFEPARMCOUNT( 0, VM_M_refreshserverlist );
+ ServerList_QueryList();
}
/*
========================
-VM_M_gethostcacheindexforkey
+VM_M_getserverlistindexforkey
-float gethostcacheindexforkey(string key)
+float getserverlistindexforkey(string key)
========================
*/
-void VM_M_gethostcacheindexforkey( void )
+void VM_M_getserverlistindexforkey( void )
{
char *key;
- VM_SAFEPARMCOUNT( 1, VM_M_gethostcacheindexforkey );
+ VM_SAFEPARMCOUNT( 1, VM_M_getserverlistindexforkey );
key = PRVM_G_STRING( OFS_PARM0 );
VM_CheckEmptyString( key );
-
+
if( !strcmp( key, "cname" ) )
- PRVM_G_FLOAT( OFS_RETURN ) = HCIF_CNAME;
+ PRVM_G_FLOAT( OFS_RETURN ) = SLIF_CNAME;
else if( !strcmp( key, "ping" ) )
- PRVM_G_FLOAT( OFS_RETURN ) = HCIF_PING;
+ PRVM_G_FLOAT( OFS_RETURN ) = SLIF_PING;
else if( !strcmp( key, "game" ) )
- PRVM_G_FLOAT( OFS_RETURN ) = HCIF_GAME;
+ PRVM_G_FLOAT( OFS_RETURN ) = SLIF_GAME;
else if( !strcmp( key, "mod" ) )
- PRVM_G_FLOAT( OFS_RETURN ) = HCIF_MOD;
+ PRVM_G_FLOAT( OFS_RETURN ) = SLIF_MOD;
else if( !strcmp( key, "map" ) )
- PRVM_G_FLOAT( OFS_RETURN ) = HCIF_MAP;
+ PRVM_G_FLOAT( OFS_RETURN ) = SLIF_MAP;
else if( !strcmp( key, "name" ) )
- PRVM_G_FLOAT( OFS_RETURN ) = HCIF_NAME;
+ PRVM_G_FLOAT( OFS_RETURN ) = SLIF_NAME;
else if( !strcmp( key, "maxplayers" ) )
- PRVM_G_FLOAT( OFS_RETURN ) = HCIF_MAXPLAYERS;
+ PRVM_G_FLOAT( OFS_RETURN ) = SLIF_MAXPLAYERS;
else if( !strcmp( key, "numplayers" ) )
- PRVM_G_FLOAT( OFS_RETURN ) = HCIF_NUMPLAYERS;
+ PRVM_G_FLOAT( OFS_RETURN ) = SLIF_NUMPLAYERS;
else if( !strcmp( key, "protocol" ) )
- PRVM_G_FLOAT( OFS_RETURN ) = HCIF_PROTOCOL;
+ PRVM_G_FLOAT( OFS_RETURN ) = SLIF_PROTOCOL;
else
PRVM_G_FLOAT( OFS_RETURN ) = -1;
}
/*
========================
-VM_M_addwantedhostcachekey
+VM_M_addwantedserverlistkey
-addwantedhostcachekey(string key)
+addwantedserverlistkey(string key)
========================
*/
-void VM_M_addwantedhostcachekey( void )
+void VM_M_addwantedserverlistkey( void )
{
- VM_SAFEPARMCOUNT( 1, VM_M_addwantedhostcachekey );
+ VM_SAFEPARMCOUNT( 1, VM_M_addwantedserverlistkey );
}
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_getresolution,
VM_M_keynumtostring,
VM_M_findkeysforcommand,// 610
- VM_M_gethostcachestat,
- VM_M_gethostcachestring,
+ VM_M_getserverliststat,
+ VM_M_getserverliststring,
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
+ VM_M_resetserverlistmasks,
+ VM_M_setserverlistmaskstring,
+ VM_M_setserverlistmasknumber,
+ VM_M_resortserverlist,
+ VM_M_setserverlistsort,
+ VM_M_refreshserverlist,
+ VM_M_getserverlistnumber,
+ VM_M_getserverlistindexforkey,
+ VM_M_addwantedserverlistkey // 623
};
const int vm_m_numbuiltins = sizeof(vm_m_builtins) / sizeof(prvm_builtin_t);
projects / xonotic / darkplaces.git / blobdiff