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)
float itof(intt ent)
intt ftoi(float num)
-
-perhaps only : Menu : WriteMsg
+
+float altstr_count(string)
+string altstr_prepare(string)
+string altstr_get(string,float)
+string altstr_set(string altstr, float num, string set)
+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
-===============================
+
+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)
drawsetcliparea(float x, float y, float width, float height)
drawresetcliparea()
vector getimagesize(string pic)
-
+
+float cin_open(string file, string name)
+void cin_close(string name)
+void cin_setstate(string name, float type)
+float cin_getstate(string name)
+void cin_restart(string name)
==============================================================================
menu cmd list:
setkeydest(float dest)
float getkeydest()
setmousetarget(float target)
-float getmousetarget(void)
+float getmousetarget()
callfunction(...,string function_name)
writetofile(float fhandle, entity ent)
vector getresolution(float number)
string keynumtostring(float keynum)
string findkeysforcommand(string command)
-float gethostcachevalue(float type)
-string gethostcachestring(float type, float hostnr)
+float 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"
#include "clprogdefs.h"
#include "mprogdefs.h"
+#include "cl_video.h"
+
//============================================================================
// nice helper macros
#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;
- if (!client->netconnection)
- return;
VM_VarString(1, string, sizeof(string));
MSG_WriteChar(&client->message,svc_print);
MSG_WriteString(&client->message, string);
*/
void VM_random (void)
{
- float num;
-
VM_SAFEPARMCOUNT(0,VM_random);
- num = (rand ()&0x7fff) / ((float)0x7fff);
-
- PRVM_G_FLOAT(OFS_RETURN) = num;
+ PRVM_G_FLOAT(OFS_RETURN) = lhrandom(0, 1);
}
/*
*/
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);
if (strcmp(t,s))
continue;
- PRVM_E_FLOAT(ent,chain_of) = PRVM_NUM_FOR_EDICT(chain);
+ PRVM_E_INT(ent,chain_of) = PRVM_NUM_FOR_EDICT(chain);
chain = ent;
}
prog->xfunction->builtinsprofile++;
if (ent->p.e->free)
continue;
- if (E_FLOAT(ent,f) != s)
+ if (PRVM_E_FLOAT(ent,f) != s)
continue;
- PRVM_E_FLOAT(ent,chain_of) = PRVM_NUM_FOR_EDICT(chain);
+ PRVM_E_INT(ent,chain_of) = PRVM_EDICT_TO_PROG(chain);
chain = ent;
}
*/
void VM_precache_sound (void)
{
- char *s;
+ const char *s;
VM_SAFEPARMCOUNT(1, VM_precache_sound);
s = PRVM_G_STRING(OFS_PARM0);
PRVM_G_INT(OFS_RETURN) = PRVM_G_INT(OFS_PARM0);
VM_CheckEmptyString (s);
-
- if(!S_PrecacheSound (s,true, true))
+
+ if(snd_initialized.integer && !S_PrecacheSound (s,true, true))
Con_Printf("VM_precache_sound: Failed to load %s for %s\n", s, PRVM_NAME);
}
=========
*/
-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);
for (i = 1;i < prog->argc;i++)
if (PRVM_G_FLOAT((OFS_PARM0+i*3)) > f)
f = PRVM_G_FLOAT((OFS_PARM0+i*3));
- G_FLOAT(OFS_RETURN) = f;
+ PRVM_G_FLOAT(OFS_RETURN) = f;
}
else
PRVM_ERROR("VM_max: %s must supply at least 2 floats\n", PRVM_NAME);
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 (developer.integer)
+ 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
- PRVM_G_FLOAT(OFS_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);
-
+
+ //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),(vid.conwidth - x));
- h = bound(0,PRVM_G_FLOAT(OFS_PARM3),(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);
+ 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;
PRVM_G_VECTOR(OFS_RETURN)[2] = 0;
}
+// CL_Video interface functions
+
+/*
+========================
+VM_cin_open
+
+float cin_open(string file, string name)
+========================
+*/
+void VM_cin_open( void )
+{
+ const char *file;
+ const char *name;
+
+ VM_SAFEPARMCOUNT( 2, VM_cin_open );
+
+ file = PRVM_G_STRING( OFS_PARM0 );
+ name = PRVM_G_STRING( OFS_PARM1 );
+
+ VM_CheckEmptyString( file );
+ VM_CheckEmptyString( name );
+
+ if( CL_OpenVideo( file, name, MENUOWNER ) )
+ PRVM_G_FLOAT( OFS_RETURN ) = 1;
+ else
+ PRVM_G_FLOAT( OFS_RETURN ) = 0;
+}
+
+/*
+========================
+VM_cin_close
+
+void cin_close(string name)
+========================
+*/
+void VM_cin_close( void )
+{
+ const char *name;
+
+ VM_SAFEPARMCOUNT( 1, VM_cin_close );
+
+ name = PRVM_G_STRING( OFS_PARM0 );
+ VM_CheckEmptyString( name );
+
+ CL_CloseVideo( CL_GetVideo( name ) );
+}
+
+/*
+========================
+VM_cin_setstate
+void cin_setstate(string name, float type)
+========================
+*/
+void VM_cin_setstate( void )
+{
+ const char *name;
+ clvideostate_t state;
+ clvideo_t *video;
+
+ VM_SAFEPARMCOUNT( 2, VM_cin_netstate );
+
+ name = PRVM_G_STRING( OFS_PARM0 );
+ VM_CheckEmptyString( name );
+
+ state = PRVM_G_FLOAT( OFS_PARM1 );
+
+ video = CL_GetVideo( name );
+ if( video && state > CLVIDEO_UNUSED && state < CLVIDEO_STATECOUNT )
+ CL_SetVideoState( video, state );
+}
+
+/*
+========================
+VM_cin_getstate
+
+float cin_getstate(string name)
+========================
+*/
+void VM_cin_getstate( void )
+{
+ const char *name;
+ clvideo_t *video;
+
+ VM_SAFEPARMCOUNT( 1, VM_cin_getstate );
+
+ name = PRVM_G_STRING( OFS_PARM0 );
+ VM_CheckEmptyString( name );
+
+ video = CL_GetVideo( name );
+ if( video )
+ PRVM_G_FLOAT( OFS_RETURN ) = (int)video->state;
+ else
+ PRVM_G_FLOAT( OFS_RETURN ) = 0;
+}
+
+/*
+========================
+VM_cin_restart
+
+void cin_restart(string name)
+========================
+*/
+void VM_cin_restart( void )
+{
+ const char *name;
+ clvideo_t *video;
+
+ VM_SAFEPARMCOUNT( 1, VM_cin_restart );
+
+ name = PRVM_G_STRING( OFS_PARM0 );
+ VM_CheckEmptyString( name );
+
+ video = CL_GetVideo( name );
+ if( video )
+ CL_RestartVideo( video );
+}
+
+////////////////////////////////////////
+// AltString functions
+////////////////////////////////////////
+
+/*
+========================
+VM_altstr_count
+
+float altstr_count(string)
+========================
+*/
+void VM_altstr_count( void )
+{
+ const char *altstr, *pos;
+ int count;
+
+ VM_SAFEPARMCOUNT( 1, VM_altstr_count );
+
+ altstr = PRVM_G_STRING( OFS_PARM0 );
+ //VM_CheckEmptyString( altstr );
+
+ for( count = 0, pos = altstr ; *pos ; pos++ )
+ if( *pos == '\\' && !*++pos )
+ break;
+ else if( *pos == '\'' )
+ count++;
+
+ PRVM_G_FLOAT( OFS_RETURN ) = (float) (count / 2);
+}
+
+/*
+========================
+VM_altstr_prepare
+
+string altstr_prepare(string)
+========================
+*/
+void VM_altstr_prepare( void )
+{
+ char *outstr, *out;
+ const char *instr, *in;
+ int size;
+
+ VM_SAFEPARMCOUNT( 1, VM_altstr_prepare );
+
+ instr = PRVM_G_STRING( OFS_PARM0 );
+ //VM_CheckEmptyString( instr );
+ outstr = VM_GetTempString();
+
+ for( out = outstr, in = instr, size = VM_STRINGTEMP_LENGTH - 1 ; size && *in ; size--, in++, out++ )
+ if( *in == '\'' ) {
+ *out++ = '\\';
+ *out = '\'';
+ size--;
+ } else
+ *out = *in;
+ *out = 0;
+
+ PRVM_G_INT( OFS_RETURN ) = PRVM_SetEngineString( outstr );
+}
+
+/*
+========================
+VM_altstr_get
+
+string altstr_get(string, float)
+========================
+*/
+void VM_altstr_get( void )
+{
+ 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 );
+
+ count = PRVM_G_FLOAT( OFS_PARM1 );
+ count = count * 2 + 1;
+
+ for( pos = altstr ; *pos && count ; pos++ )
+ if( *pos == '\\' && !*++pos )
+ break;
+ else if( *pos == '\'' )
+ count--;
+
+ if( !*pos ) {
+ PRVM_G_INT( OFS_RETURN ) = PRVM_SetEngineString( NULL );
+ return;
+ }
+
+ outstr = VM_GetTempString();
+ for( out = outstr, size = VM_STRINGTEMP_LENGTH - 1 ; size && *pos ; size--, pos++, out++ )
+ if( *pos == '\\' ) {
+ if( !*++pos )
+ break;
+ *out = *pos;
+ size--;
+ } else if( *pos == '\'' )
+ break;
+ else
+ *out = *pos;
+
+ *out = 0;
+ PRVM_G_INT( OFS_RETURN ) = PRVM_SetEngineString( outstr );
+}
+
+/*
+========================
+VM_altstr_set
+
+string altstr_set(string altstr, float num, string set)
+========================
+*/
+void VM_altstr_set( void )
+{
+ int num;
+ 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 );
+
+ num = PRVM_G_FLOAT( OFS_PARM1 );
+
+ str = PRVM_G_STRING( OFS_PARM2 );
+ //VM_CheckEmptyString( str );
+
+ outstr = out = VM_GetTempString();
+ for( num = num * 2 + 1, in = altstr; *in && num; *out++ = *in++ )
+ if( *in == '\\' && !*++in )
+ break;
+ else if( *in == '\'' )
+ num--;
+
+ if( !in ) {
+ PRVM_G_INT( OFS_RETURN ) = PRVM_SetEngineString( NULL );
+ return;
+ }
+ // copy set in
+ for( ; *str; *out++ = *str++ );
+ // now jump over the old contents
+ for( ; *in ; in++ )
+ if( *in == '\'' || (*in == '\\' && !*++in) )
+ break;
+
+ if( !in ) {
+ PRVM_G_INT( OFS_RETURN ) = PRVM_SetEngineString( NULL );
+ return;
+ }
+
+ strcpy( out, in );
+ 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);
- Mem_FreePool(&VM_STRINGS_MEMPOOL);
+ CL_PurgeOwner( MENUOWNER );
VM_Search_Reset();
VM_Files_CloseAll();
}
// Menu
char *vm_m_extensions =
-"";
+"DP_CINEMATIC_DPV";
/*
=========
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_gethostcachecount
+VM_M_getserverliststat
-float gethostcachevalue(float type)
+float getserverliststat(float type)
=========
*/
/*
type:
-0 hostcachecount
-1 masterquerycount
-2 masterreplycount
-3 serverquerycount
-4 serverreplycount
+0 serverlist_viewcount
+1 serverlist_totalcount
+2 masterquerycount
+3 masterreplycount
+4 serverquerycount
+5 serverreplycount
+6 sortfield
+7 sortdescending
*/
-void VM_M_gethostcachevalue( void )
+void VM_M_getserverliststat( void )
{
int type;
- VM_SAFEPARMCOUNT ( 1, VM_M_gethostcachevalue );
+ 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_gethostcachevalue: bad type %i!\n", type );
- else switch(type)
+ switch(type)
{
case 0:
- PRVM_G_FLOAT ( OFS_RETURN ) = hostCacheCount;
+ PRVM_G_FLOAT ( OFS_RETURN ) = serverlist_viewcount;
return;
case 1:
+ PRVM_G_FLOAT ( OFS_RETURN ) = serverlist_cachecount;
+ case 2:
PRVM_G_FLOAT ( OFS_RETURN ) = masterquerycount;
return;
- case 2:
+ case 3:
PRVM_G_FLOAT ( OFS_RETURN ) = masterreplycount;
return;
- case 3:
+ case 4:
PRVM_G_FLOAT ( OFS_RETURN ) = serverquerycount;
return;
- case 4:
+ case 5:
PRVM_G_FLOAT ( OFS_RETURN ) = serverreplycount;
return;
+ case 6:
+ PRVM_G_FLOAT ( OFS_RETURN ) = 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_gethostcachestring
+========================
+VM_M_resetserverlistmasks
-string gethostcachestring(float type, float hostnr)
-=========
+resetserverlistmasks()
+========================
*/
+void VM_M_resetserverlistmasks( void )
+{
+ ServerList_ResetMasks();
+}
+
+
/*
-0 Get CName
-1 Get line1
-2 Get line2
+========================
+VM_M_setserverlistmaskstring
+
+setserverlistmaskstring(float mask, float fld, string str, float op)
+0-511 and
+512 - 1024 or
+========================
*/
-void VM_M_gethostcachestring(void)
+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 );
+}
+
+/*
+========================
+VM_M_setserverlistmasknumber
+
+setserverlistmasknumber(float mask, float fld, float num, float op)
+
+0-511 and
+512 - 1024 or
+========================
+*/
+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 >= hostCacheCount)
+ 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");
+ }
+}
+
+/*
+========================
+VM_M_setserverlistsort
- if( type == 0 )
- PRVM_G_INT( OFS_RETURN ) = PRVM_SetString( hostcache[hostnr].cname );
- else if( type == 1 )
- PRVM_G_INT( OFS_RETURN ) = PRVM_SetString( hostcache[hostnr].line1 );
+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[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
- e10, // 90
+ VM_ftoi, // 80
+ VM_itof, // isString
+ VM_altstr_count,
+ VM_altstr_prepare,
+ VM_altstr_get,
+ 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
- e10, // 470
+ VM_cin_open,
+ VM_cin_close,
+ VM_cin_setstate,
+ VM_cin_getstate,
+ VM_cin_restart, // 465
+ 0,0,0,0,0, // 470
e10, // 480
e10, // 490
e10, // 500
VM_M_getresolution,
VM_M_keynumtostring,
VM_M_findkeysforcommand,// 610
- VM_M_gethostcachevalue,
- 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);