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)
vector getresolution(float number)
string keynumtostring(float keynum)
string findkeysforcommand(string command)
-float gethostcachestat(float type)
-string gethostcachestring(float type, float hostnr)
+float getserverliststat(float type)
+string getserverliststring(float fld, float hostnr)
parseentitydata(entity ent, string data)
+
+float stringtokeynum(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"
#define VM_RETURN_EDICT(e) (((int *)prog->globals)[OFS_RETURN] = PRVM_EDICT_TO_PROG(e))
-#define VM_STRINGS_MEMPOOL vm_strings_mempool[PRVM_GetProgNr()]
-
#define e10 0,0,0,0,0,0,0,0,0,0
#define e100 e10,e10,e10,e10,e10,e10,e10,e10,e10,e10
#define e1000 e100,e100,e100,e100,e100,e100,e100,e100,e100,e100
//============================================================================
// Common
-// string zone mempool
-mempool_t *vm_strings_mempool[PRVM_MAXPROGS];
-
// temp string handling
// LordHavoc: added this to semi-fix the problem of using many ftos calls in a print
#define VM_STRINGTEMP_BUFFERS 16
return s;
}
-void VM_CheckEmptyString (char *s)
+void VM_CheckEmptyString (const char *s)
{
if (s[0] <= ' ')
PRVM_ERROR ("%s: Bad string", PRVM_NAME);
*/
// kind of helper function
-static qboolean checkextension(char *name)
+static qboolean checkextension(const char *name)
{
int len;
char *e, *start;
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;
-
+ const 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;
+ char *out;
+ const char *name;
const char *cvar_string;
VM_SAFEPARMCOUNT(1,VM_str_cvar);
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);
+ PRVM_G_INT(OFS_RETURN) = PRVM_SetEngineString(out);
}
/*
sprintf(s, "%i", (int)v);
else
sprintf(s, "%f", v);
- PRVM_G_INT(OFS_RETURN) = PRVM_SetString(s);
+ PRVM_G_INT(OFS_RETURN) = PRVM_SetEngineString(s);
}
/*
s = VM_GetTempString();
sprintf (s, "'%5.1f %5.1f %5.1f'", PRVM_G_VECTOR(OFS_PARM0)[0], PRVM_G_VECTOR(OFS_PARM0)[1], PRVM_G_VECTOR(OFS_PARM0)[2]);
- PRVM_G_INT(OFS_RETURN) = PRVM_SetString(s);
+ PRVM_G_INT(OFS_RETURN) = PRVM_SetEngineString(s);
}
/*
s = VM_GetTempString();
sprintf (s, "entity %i", PRVM_G_EDICTNUM(OFS_PARM0));
- PRVM_G_INT(OFS_RETURN) = PRVM_SetString(s);
+ PRVM_G_INT(OFS_RETURN) = PRVM_SetEngineString(s);
}
/*
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;
}
{
int e;
int f;
- char *s, *t;
+ const char *s, *t;
prvm_edict_t *ed;
VM_SAFEPARMCOUNT(3,VM_find);
int i;
int f;
int chain_of;
- char *s, *t;
+ const char *s, *t;
prvm_edict_t *ent, *chain;
VM_SAFEPARMCOUNT(2,VM_findchain);
*/
void VM_precache_sound (void)
{
- char *s;
+ const char *s;
VM_SAFEPARMCOUNT(1, VM_precache_sound);
=========
*/
-void VM_crash(void)
+void VM_crash(void)
{
VM_SAFEPARMCOUNT(0, VM_crash);
*/
void VM_changelevel (void)
{
- char *s;
+ const char *s;
VM_SAFEPARMCOUNT(1, VM_changelevel);
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;
}
return;
svs.changelevel_issued = true;
- s = G_STRING(OFS_PARM0);
+ s = PRVM_G_STRING(OFS_PARM0);
Cbuf_AddText (va("changelevel %s\n",s));
}
*/
void VM_registercvar (void)
{
- char *name, *value;
+ const char *name, *value;
int flags;
VM_SAFEPARMCOUNT(3,VM_registercvar);
void VM_fopen(void)
{
int filenum, mode;
- char *modestring, *filename;
+ const char *modestring, *filename;
VM_SAFEPARMCOUNT(2,VM_fopen);
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)
- PRVM_G_INT(OFS_RETURN) = PRVM_SetString(string);
+ PRVM_G_INT(OFS_RETURN) = PRVM_SetEngineString(string);
else
PRVM_G_INT(OFS_RETURN) = 0;
}
//float(string s) strlen = #114; // returns how many characters are in a string
void VM_strlen(void)
{
- char *s;
+ const char *s;
VM_SAFEPARMCOUNT(1,VM_strlen);
{
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);
+ PRVM_G_INT(OFS_RETURN) = PRVM_SetEngineString(s);
}
/*
void VM_substring(void)
{
int i, start, length;
- char *s, *string;
+ const char *s;
+ char *string;
VM_SAFEPARMCOUNT(3,VM_substring);
for (i = 0;i < VM_STRINGTEMP_LENGTH - 1 && *s && i < length;i++, s++)
string[i] = *s;
string[i] = 0;
- PRVM_G_INT(OFS_RETURN) = PRVM_SetString(string);
+ PRVM_G_INT(OFS_RETURN) = PRVM_SetEngineString(string);
}
/*
//string(string s) strzone = #118; // makes a copy of a string into the string zone and returns it, this is often used to keep around a tempstring for longer periods of time (tempstrings are replaced often)
void VM_strzone(void)
{
- char *in, *out;
+ const char *in;
+ char *out;
VM_SAFEPARMCOUNT(1,VM_strzone);
in = PRVM_G_STRING(OFS_PARM0);
- out = Mem_Alloc(VM_STRINGS_MEMPOOL, strlen(in) + 1);
+ out = PRVM_AllocString(strlen(in) + 1);
strcpy(out, in);
- PRVM_G_INT(OFS_RETURN) = PRVM_SetString(out);
+ PRVM_G_INT(OFS_RETURN) = PRVM_SetQCString(out);
}
/*
//void(string s) strunzone = #119; // removes a copy of a string from the string zone (you can not use that string again or it may crash!!!)
void VM_strunzone(void)
{
- char *str;
VM_SAFEPARMCOUNT(1,VM_strunzone);
-
- str = PRVM_G_STRING(OFS_PARM0);
- if( developer.integer && !Mem_IsAllocated( VM_STRINGS_MEMPOOL, str ) )
- PRVM_ERROR( "VM_strunzone: Zone string already freed in %s!", PRVM_NAME );
- else
- Mem_Free( str );
+ PRVM_FreeString((char *)PRVM_G_STRING(OFS_PARM0));
}
/*
static int max_tokens, num_tokens = 0;
void VM_tokenize (void)
{
- const char *p;
- char *str;
+ const char *p, *str;
VM_SAFEPARMCOUNT(1,VM_tokenize);
token_num = PRVM_G_FLOAT(OFS_PARM0);
if (token_num >= 0 && token_num < num_tokens)
- PRVM_G_INT(OFS_RETURN) = PRVM_SetString(tokens[token_num]);
+ PRVM_G_INT(OFS_RETURN) = PRVM_SetEngineString(tokens[token_num]);
else
- PRVM_G_INT(OFS_RETURN) = PRVM_SetString("");
+ PRVM_G_INT(OFS_RETURN) = PRVM_SetEngineString(NULL);
}
/*
if (!strcmp(tagname, model->data_overridetagnamesforskin[(unsigned int)tagentity->v->skin].data_overridetagnames[i].name))
v->_float = i + 1;
// FIXME: use a model function to get tag info (need to handle skeletal)
- if (v->_float == 0 && model->alias.aliasnum_tags)
- for (i = 0;i < model->alias.aliasnum_tags;i++)
- if (!strcmp(tagname, model->alias.aliasdata_tags[i].name))
+ if (v->_float == 0 && model->num_tags)
+ for (i = 0;i < model->num_tags;i++)
+ if (!strcmp(tagname, model->data_tags[i].name))
v->_float = i + 1;
if (v->_float == 0)
Con_DPrintf("setattachment(edict %i, edict %i, string \"%s\"): tried to find tag named \"%s\" on entity %i (model \"%s\") but could not find it\n", NUM_FOR_EDICT(e), NUM_FOR_EDICT(tagentity), tagname, tagname, NUM_FOR_EDICT(tagentity), model->name);
{
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)[0] = in_mouse_x * vid_conwidth.integer / vid.width;
+ PRVM_G_VECTOR(OFS_RETURN)[1] = in_mouse_y * vid_conheight.integer / vid.height;
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)
*/
void VM_loadfromfile(void)
{
- char *filename;
+ const 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)
void VM_search_begin(void)
{
int handle;
- char *pattern;
+ const char *pattern;
int caseinsens, quiet;
VM_SAFEPARMCOUNT(3, VM_search_begin);
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]);
- PRVM_G_INT(OFS_RETURN) = PRVM_SetString(tmp);
+ PRVM_G_INT(OFS_RETURN) = PRVM_SetEngineString(tmp);
}
/*
tmp[0] = (unsigned char) PRVM_G_FLOAT(OFS_PARM0);
tmp[1] = 0;
- PRVM_G_INT(OFS_RETURN) = PRVM_SetString(tmp);
+ PRVM_G_INT(OFS_RETURN) = PRVM_SetEngineString(tmp);
}
//=============================================================================
{
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;
-
+ const 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("");
+
+ // AK Draw_CachePic is supposed to always return a valid pointer
+ if( Draw_CachePic(s, false)->tex == r_texture_notexture )
+ PRVM_G_INT(OFS_RETURN) = PRVM_SetEngineString(NULL);
}
/*
*/
void VM_freepic(void)
{
- char *s;
+ const char *s;
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;
-}
+}
/*
=========
void VM_drawstring(void)
{
float *pos,*scale,*rgb;
- char *string;
+ const 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;
}
*/
void VM_drawpic(void)
{
- char *pic;
+ const char *pic;
float *size, *pos, *rgb;
int flag;
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;
}
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) + 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));
+ x = bound(0, PRVM_G_FLOAT(OFS_PARM0), vid_conwidth.integer);
+ y = bound(0, PRVM_G_FLOAT(OFS_PARM1), vid_conheight.integer);
+ w = bound(0, PRVM_G_FLOAT(OFS_PARM2) + PRVM_G_FLOAT(OFS_PARM0) - x, (vid_conwidth.integer - x));
+ h = bound(0, PRVM_G_FLOAT(OFS_PARM3) + PRVM_G_FLOAT(OFS_PARM1) - y, (vid_conheight.integer - y));
DrawQ_SetClipArea(x, y, w, h);
}
*/
void VM_getimagesize(void)
{
- char *p;
+ const char *p;
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;
*/
void VM_cin_open( void )
{
- char *file;
- char *name;
-
+ const char *file;
+ const char *name;
+
VM_SAFEPARMCOUNT( 2, VM_cin_open );
-
+
file = PRVM_G_STRING( OFS_PARM0 );
name = PRVM_G_STRING( OFS_PARM1 );
*/
void VM_cin_close( void )
{
- char *name;
+ const char *name;
VM_SAFEPARMCOUNT( 1, VM_cin_close );
name = PRVM_G_STRING( OFS_PARM0 );
VM_CheckEmptyString( name );
- CL_CloseVideo( CL_GetVideo( name ) );
+ CL_CloseVideo( CL_GetVideo( name ) );
}
/*
*/
void VM_cin_setstate( void )
{
- char *name;
+ const char *name;
clvideostate_t state;
clvideo_t *video;
video = CL_GetVideo( name );
if( video && state > CLVIDEO_UNUSED && state < CLVIDEO_STATECOUNT )
- CL_SetVideoState( video, state );
+ CL_SetVideoState( video, state );
}
/*
*/
void VM_cin_getstate( void )
{
- char *name;
+ const char *name;
clvideo_t *video;
VM_SAFEPARMCOUNT( 1, VM_cin_getstate );
*/
void VM_cin_restart( void )
{
- char *name;
+ const char *name;
clvideo_t *video;
VM_SAFEPARMCOUNT( 1, VM_cin_restart );
*/
void VM_altstr_count( void )
{
- char *altstr, *pos;
+ const char *altstr, *pos;
int count;
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 )
void VM_altstr_prepare( void )
{
char *outstr, *out;
- char *instr, *in;
+ const char *instr, *in;
int size;
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++ )
*out = *in;
*out = 0;
- PRVM_G_INT( OFS_RETURN ) = PRVM_SetString( outstr );
+ PRVM_G_INT( OFS_RETURN ) = PRVM_SetEngineString( outstr );
}
/*
*/
void VM_altstr_get( void )
{
- char *altstr, *pos, *outstr, *out;
+ const char *altstr, *pos;
+ char *outstr, *out;
int count, size;
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--;
if( !*pos ) {
- PRVM_G_INT( OFS_RETURN ) = PRVM_SetString( "" );
+ PRVM_G_INT( OFS_RETURN ) = PRVM_SetEngineString( NULL );
return;
}
*out = *pos;
*out = 0;
- PRVM_G_INT( OFS_RETURN ) = PRVM_SetString( outstr );
+ PRVM_G_INT( OFS_RETURN ) = PRVM_SetEngineString( outstr );
}
/*
void VM_altstr_set( void )
{
int num;
- char *altstr, *str;
- char *in;
+ const char *altstr, *str;
+ const char *in;
char *outstr, *out;
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++ )
num--;
if( !in ) {
- PRVM_G_INT( OFS_RETURN ) = PRVM_SetString( "" );
+ PRVM_G_INT( OFS_RETURN ) = PRVM_SetEngineString( NULL );
return;
}
// 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( "" );
+ PRVM_G_INT( OFS_RETURN ) = PRVM_SetEngineString( NULL );
return;
}
strcpy( out, in );
- PRVM_G_INT( OFS_RETURN ) = PRVM_SetString( outstr );
+ PRVM_G_INT( OFS_RETURN ) = PRVM_SetEngineString( outstr );
+}
+
+/*
+========================
+VM_altstr_ins
+insert after num
+string altstr_ins(string altstr, float num, string set)
+========================
+*/
+void VM_altstr_ins(void)
+{
+ int num;
+ const char *setstr;
+ const char *set;
+ const char *instr;
+ const 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_SetEngineString( outstr );
}
void VM_Cmd_Init(void)
{
// only init the stuff for the current prog
- VM_STRINGS_MEMPOOL = Mem_AllocPool(va("vm_stringsmempool[%s]",PRVM_NAME), 0, NULL);
VM_Files_Init();
VM_Search_Init();
}
void VM_Cmd_Reset(void)
{
- //Mem_EmptyPool(VM_STRINGS_MEMPOOL);
- if( developer.integer >= 2 && VM_STRINGS_MEMPOOL ) {
- memheader_t *header;
- int i;
-
- for( i = 0, header = VM_STRINGS_MEMPOOL->chain ; header ; header = header->next, i++ )
- Con_DPrintf( "Leaked string %i (size: %i): %.*s\n", i, header->size, header->size, ((char*)header) + sizeof( memheader_t ) );
- }
-
- Mem_FreePool(&VM_STRINGS_MEMPOOL);
CL_PurgeOwner( MENUOWNER );
VM_Search_Reset();
VM_Files_CloseAll();
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);
void VM_M_callfunction(void)
{
mfunction_t *func;
- char *s;
+ const char *s;
if(prog->argc == 0)
PRVM_ERROR("VM_M_callfunction: 1 parameter is required !\n");
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++;
}
-}
+}
/*
=========
void VM_M_isfunction(void)
{
mfunction_t *func;
- char *s;
-
+ const 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);
+ PRVM_G_INT(OFS_RETURN) = PRVM_SetEngineString(tmp);
+}
+
+/*
+=========
+VM_M_stringtokeynum
+
+float stringtokeynum(string key)
+=========
+*/
+void VM_M_stringtokeynum( void )
+{
+ const char *str;
+ VM_SAFEPARMCOUNT( 1, VM_M_keynumtostring );
+
+ str = PRVM_G_STRING( OFS_PARM0 );
+
+ PRVM_G_INT(OFS_RETURN) = Key_StringToKeynum( str );
}
/*
*/
#define NUMKEYS 5 // TODO: merge the constant in keys.c with this one somewhen
-void M_FindKeysForCommand(char *command, int *keys);
+void M_FindKeysForCommand(const char *command, int *keys);
void VM_M_findkeysforcommand(void)
{
- char *cmd, *ret;
+ const char *cmd;
+ char *ret;
int keys[NUMKEYS];
int i;
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++)
ret = strcat(ret, va(" \'%i\'", keys[i]));
- PRVM_G_INT(OFS_RETURN) = PRVM_SetString(ret);
+ PRVM_G_INT(OFS_RETURN) = PRVM_SetEngineString(ret);
}
/*
=========
-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
5 serverreplycount
+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;
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;
+ 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;
case 5:
PRVM_G_FLOAT ( OFS_RETURN ) = serverreplycount;
return;
+ case 6:
+ PRVM_G_FLOAT ( OFS_RETURN ) = serverlist_sortbyfield;
+ return;
+ case 7:
+ PRVM_G_FLOAT ( OFS_RETURN ) = serverlist_sortdescending;
+ return;
+ default:
+ Con_Printf( "VM_M_getserverliststat: bad type %i!\n", type );
}
}
/*
========================
-VM_M_sethostcachemask
+VM_M_resetserverlistmasks
-sethostcachemask( string map, string mod, string name,
+resetserverlistmasks()
========================
*/
+void VM_M_resetserverlistmasks( void )
+{
+ ServerList_ResetMasks();
+}
/*
-=========
-VM_M_gethostcachestring
+========================
+VM_M_setserverlistmaskstring
-string gethostcachestring(float type, float hostnr)
-=========
+setserverlistmaskstring(float mask, float fld, string str, float op)
+0-511 and
+512 - 1024 or
+========================
*/
+void VM_M_setserverlistmaskstring( void )
+{
+ const char *str;
+ int masknr;
+ serverlist_mask_t *mask;
+ int field;
+
+ VM_SAFEPARMCOUNT( 4, VM_M_setserverlistmaskstring );
+ str = PRVM_G_STRING( OFS_PARM1 );
+ if( !str )
+ PRVM_ERROR( "VM_M_setserverlistmaskstring: null string passed!" );
+
+ masknr = PRVM_G_FLOAT( OFS_PARM0 );
+ 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_setserverlistmaskstring: invalid mask number %i\n", masknr );
+ return;
+ }
+
+ field = (int) PRVM_G_FLOAT( OFS_PARM1 );
+
+ switch( field ) {
+ case SLIF_CNAME:
+ strncpy( mask->info.cname, PRVM_G_STRING( OFS_PARM2 ), sizeof(mask->info.cname) );
+ break;
+ case SLIF_NAME:
+ strncpy( mask->info.name, PRVM_G_STRING( OFS_PARM2 ), sizeof(mask->info.name) );
+ break;
+ case SLIF_MAP:
+ strncpy( mask->info.map, PRVM_G_STRING( OFS_PARM2 ), sizeof(mask->info.map) );
+ break;
+ case SLIF_MOD:
+ strncpy( mask->info.mod, PRVM_G_STRING( OFS_PARM2 ), sizeof(mask->info.mod) );
+ break;
+ case SLIF_GAME:
+ strncpy( mask->info.game, PRVM_G_STRING( OFS_PARM2 ), sizeof(mask->info.game) );
+ break;
+ default:
+ 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 );
+}
+
/*
-0 Get CName
-1 Get line1
-2 Get line2
+========================
+VM_M_setserverlistmasknumber
+
+setserverlistmasknumber(float mask, float fld, float num, float op)
+
+0-511 and
+512 - 1024 or
+========================
*/
-void VM_M_gethostcachestring(void)
+void VM_M_setserverlistmasknumber( void )
+{
+ int number;
+ serverlist_mask_t *mask;
+ int masknr;
+ int field;
+ VM_SAFEPARMCOUNT( 4, VM_M_setserverlistmasknumber );
+
+ masknr = PRVM_G_FLOAT( OFS_PARM0 );
+ 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_setserverlistmasknumber: invalid mask number %i\n", masknr );
+ return;
+ }
+
+ number = PRVM_G_FLOAT( OFS_PARM2 );
+ field = (int) PRVM_G_FLOAT( OFS_PARM1 );
+
+ switch( field ) {
+ case SLIF_MAXPLAYERS:
+ mask->info.maxplayers = number;
+ break;
+ case SLIF_NUMPLAYERS:
+ mask->info.numplayers = number;
+ break;
+ case SLIF_PING:
+ mask->info.ping = number;
+ break;
+ case SLIF_PROTOCOL:
+ mask->info.protocol = number;
+ break;
+ default:
+ Con_Printf( "VM_M_setserverlistmasknumber: Bad field number %i passed!\n", field );
+ return;
+ }
+
+ mask->active = true;
+ mask->tests[field] = (int) PRVM_G_FLOAT( OFS_PARM3 );
+}
+
+
+/*
+========================
+VM_M_resortserverlist
+
+resortserverlist
+========================
+*/
+void VM_M_resortserverlist( void )
{
- int type;
+ ServerList_RebuildViewList();
+}
+
+/*
+=========
+VM_M_getserverliststring
+
+string getserverliststring(float field, float hostnr)
+=========
+*/
+void VM_M_getserverliststring(void)
+{
+ serverlist_entry_t *cache;
int hostnr;
- VM_SAFEPARMCOUNT(2, VM_M_gethostcachestring);
+ VM_SAFEPARMCOUNT(2, VM_M_getserverliststring);
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 >= serverlist_viewcount)
{
- Con_Print("VM_M_gethostcachestring: bad string type requested!\n");
+ Con_Print("VM_M_getserverliststring: bad hostnr passed!\n");
return;
}
+ cache = serverlist_viewlist[hostnr];
+ switch( (int) PRVM_G_FLOAT(OFS_PARM0) ) {
+ case SLIF_CNAME:
+ PRVM_G_INT( OFS_RETURN ) = PRVM_SetEngineString( cache->info.cname );
+ break;
+ case SLIF_NAME:
+ PRVM_G_INT( OFS_RETURN ) = PRVM_SetEngineString( cache->info.name );
+ break;
+ case SLIF_GAME:
+ PRVM_G_INT( OFS_RETURN ) = PRVM_SetEngineString( cache->info.game );
+ break;
+ case SLIF_MOD:
+ PRVM_G_INT( OFS_RETURN ) = PRVM_SetEngineString( cache->info.mod );
+ break;
+ case SLIF_MAP:
+ PRVM_G_INT( OFS_RETURN ) = PRVM_SetEngineString( cache->info.map );
+ break;
+ // TODO remove this again
+ case 1024:
+ PRVM_G_INT( OFS_RETURN ) = PRVM_SetEngineString( cache->line1 );
+ break;
+ case 1025:
+ PRVM_G_INT( OFS_RETURN ) = PRVM_SetEngineString( cache->line2 );
+ break;
+ default:
+ Con_Print("VM_M_getserverliststring: bad field number passed!\n");
+ }
+}
+
+/*
+=========
+VM_M_getserverlistnumber
+
+float getserverlistnumber(float field, float hostnr)
+=========
+*/
+void VM_M_getserverlistnumber(void)
+{
+ serverlist_entry_t *cache;
+ int hostnr;
+
+ 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 = serverlist_viewlist[hostnr];
+ switch( (int) PRVM_G_FLOAT(OFS_PARM0) ) {
+ case SLIF_MAXPLAYERS:
+ PRVM_G_FLOAT( OFS_RETURN ) = cache->info.maxplayers;
+ break;
+ case SLIF_NUMPLAYERS:
+ PRVM_G_FLOAT( OFS_RETURN ) = cache->info.numplayers;
+ break;
+ case SLIF_PING:
+ PRVM_G_FLOAT( OFS_RETURN ) = cache->info.ping;
+ break;
+ case SLIF_PROTOCOL:
+ PRVM_G_FLOAT( OFS_RETURN ) = cache->info.protocol;
+ break;
+ default:
+ Con_Print("VM_M_getserverlistnumber: 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_setserverlistsort
+
+setserverlistsort(float field, float descending)
+========================
+*/
+void VM_M_setserverlistsort( void )
+{
+ VM_SAFEPARMCOUNT( 2, VM_M_setserverlistsort );
+
+ serverlist_sortbyfield = (int) PRVM_G_FLOAT( OFS_PARM0 );
+ serverlist_sortdescending = (qboolean) PRVM_G_FLOAT( OFS_PARM1 );
+}
+
+/*
+========================
+VM_M_refreshserverlist
+
+refreshserverlist()
+========================
+*/
+void VM_M_refreshserverlist( void )
+{
+ VM_SAFEPARMCOUNT( 0, VM_M_refreshserverlist );
+ ServerList_QueryList();
+}
+
+/*
+========================
+VM_M_getserverlistindexforkey
+
+float getserverlistindexforkey(string key)
+========================
+*/
+void VM_M_getserverlistindexforkey( void )
+{
+ const char *key;
+ VM_SAFEPARMCOUNT( 1, VM_M_getserverlistindexforkey );
+
+ key = PRVM_G_STRING( OFS_PARM0 );
+ VM_CheckEmptyString( key );
+
+ if( !strcmp( key, "cname" ) )
+ PRVM_G_FLOAT( OFS_RETURN ) = SLIF_CNAME;
+ else if( !strcmp( key, "ping" ) )
+ PRVM_G_FLOAT( OFS_RETURN ) = SLIF_PING;
+ else if( !strcmp( key, "game" ) )
+ PRVM_G_FLOAT( OFS_RETURN ) = SLIF_GAME;
+ else if( !strcmp( key, "mod" ) )
+ PRVM_G_FLOAT( OFS_RETURN ) = SLIF_MOD;
+ else if( !strcmp( key, "map" ) )
+ PRVM_G_FLOAT( OFS_RETURN ) = SLIF_MAP;
+ else if( !strcmp( key, "name" ) )
+ PRVM_G_FLOAT( OFS_RETURN ) = SLIF_NAME;
+ else if( !strcmp( key, "maxplayers" ) )
+ PRVM_G_FLOAT( OFS_RETURN ) = SLIF_MAXPLAYERS;
+ else if( !strcmp( key, "numplayers" ) )
+ PRVM_G_FLOAT( OFS_RETURN ) = SLIF_NUMPLAYERS;
+ else if( !strcmp( key, "protocol" ) )
+ PRVM_G_FLOAT( OFS_RETURN ) = SLIF_PROTOCOL;
else
- PRVM_G_INT( OFS_RETURN ) = PRVM_SetString( hostcache_viewset[hostnr]->line2 );
+ PRVM_G_FLOAT( OFS_RETURN ) = -1;
+}
+
+/*
+========================
+VM_M_addwantedserverlistkey
+
+addwantedserverlistkey(string key)
+========================
+*/
+void VM_M_addwantedserverlistkey( void )
+{
+ 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_parseentitydata // 613
+ VM_M_getserverliststat,
+ VM_M_getserverliststring,
+ VM_M_parseentitydata,
+ VM_M_stringtokeynum,
+ 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);