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
===============================
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"
#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;
*/
void VM_localsound(void)
{
- char *s;
+ const char *s;
VM_SAFEPARMCOUNT(1,VM_localsound);
*/
void VM_str_cvar(void)
{
- char *out, *name;
+ char *out;
+ const char *name;
const char *cvar_string;
VM_SAFEPARMCOUNT(1,VM_str_cvar);
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);
}
/*
{
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_changelevel (void)
{
- char *s;
+ const char *s;
VM_SAFEPARMCOUNT(1, VM_changelevel);
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;
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);
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;
}
*/
void VM_loadfromfile(void)
{
- char *filename;
+ const char *filename;
qbyte *data;
VM_SAFEPARMCOUNT(1,VM_loadfromfile);
void VM_search_begin(void)
{
int handle;
- char *pattern;
+ const char *pattern;
int caseinsens, quiet;
VM_SAFEPARMCOUNT(3, VM_search_begin);
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);
}
//=============================================================================
*/
void VM_precache_pic(void)
{
- char *s;
+ const char *s;
VM_SAFEPARMCOUNT(1, VM_precache_pic);
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);
void VM_drawstring(void)
{
float *pos,*scale,*rgb;
- char *string;
+ const char *string;
int flag;
VM_SAFEPARMCOUNT(6,VM_drawstring);
*/
void VM_drawpic(void)
{
- char *pic;
+ const char *pic;
float *size, *pos, *rgb;
int flag;
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);
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 );
*/
void VM_cin_close( void )
{
- char *name;
+ const char *name;
VM_SAFEPARMCOUNT( 1, VM_cin_close );
*/
void VM_cin_setstate( void )
{
- char *name;
+ const char *name;
clvideostate_t state;
clvideo_t *video;
*/
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 );
void VM_altstr_prepare( void )
{
char *outstr, *out;
- char *instr, *in;
+ const char *instr, *in;
int size;
VM_SAFEPARMCOUNT( 1, VM_altstr_prepare );
*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 );
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 );
num--;
if( !in ) {
- PRVM_G_INT( OFS_RETURN ) = PRVM_SetString( "" );
+ PRVM_G_INT( OFS_RETURN ) = PRVM_SetEngineString( NULL );
return;
}
// copy set 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();
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");
void VM_M_isfunction(void)
{
mfunction_t *func;
- char *s;
+ const char *s;
VM_SAFEPARMCOUNT(1, VM_M_isfunction);
strcpy(tmp, Key_KeynumToString(keynum));
- PRVM_G_INT(OFS_RETURN) = PRVM_SetString(tmp);
+ PRVM_G_INT(OFS_RETURN) = PRVM_SetEngineString(tmp);
}
/*
*/
void VM_M_stringtokeynum( void )
{
- char *str;
+ const char *str;
VM_SAFEPARMCOUNT( 1, VM_M_keynumtostring );
str = PRVM_G_STRING( OFS_PARM0 );
*/
#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;
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
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;
+ const 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;
}
/*
========================
-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:
- PRVM_G_INT( OFS_RETURN ) = PRVM_SetString( cache->info.cname );
+ case SLIF_CNAME:
+ PRVM_G_INT( OFS_RETURN ) = PRVM_SetEngineString( cache->info.cname );
break;
- case HCIF_NAME:
- PRVM_G_INT( OFS_RETURN ) = PRVM_SetString( cache->info.name );
+ case SLIF_NAME:
+ PRVM_G_INT( OFS_RETURN ) = PRVM_SetEngineString( cache->info.name );
break;
- case HCIF_GAME:
- PRVM_G_INT( OFS_RETURN ) = PRVM_SetString( cache->info.game );
+ case SLIF_GAME:
+ PRVM_G_INT( OFS_RETURN ) = PRVM_SetEngineString( cache->info.game );
break;
- case HCIF_MOD:
- PRVM_G_INT( OFS_RETURN ) = PRVM_SetString( cache->info.mod );
+ case SLIF_MOD:
+ PRVM_G_INT( OFS_RETURN ) = PRVM_SetEngineString( cache->info.mod );
break;
- case HCIF_MAP:
- PRVM_G_INT( OFS_RETURN ) = PRVM_SetString( cache->info.map );
+ 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_SetString( cache->line1 );
+ PRVM_G_INT( OFS_RETURN ) = PRVM_SetEngineString( cache->line1 );
break;
case 1025:
- PRVM_G_INT( OFS_RETURN ) = PRVM_SetString( cache->line2 );
+ PRVM_G_INT( OFS_RETURN ) = PRVM_SetEngineString( 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 );
+ 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 ) = 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_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_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);