// AK
// Basically every vm builtin cmd should be in here.
-// All 3 builtin list and extension lists can be found here
-// cause large (I think they will) are from pr_cmds the same copyright like in pr_cms
+// All 3 builtin and extension lists can be found here
+// cause large (I think they will) parts are from pr_cmds the same copyright like in pr_cmds
// also applies here
float cos(float)
float sqrt(float)
vector randomvec()
-float registercvar (string name, string value)
+float registercvar (string name, string value, float flags)
float min(float a, float b, ...[float])
float max(float a, float b, ...[float])
float bound(float min, float value, float max)
changelevel(string map)
localsound(string sample)
vector getmousepos()
+float gettime()
+ loadfromdata(string data)
+ loadfromfile(string file)
+float mod(float val, float m)
+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 search_getfilename(float handle, float num)
+
+string chr(float ascii)
+
+float itof(intt ent)
+intt ftoi(float num)
perhaps only : Menu : WriteMsg
===============================
float drawstring(vector position, string text, vector scale, vector rgb, float alpha, float flag)
float drawpic(vector position, string pic, vector size, vector rgb, float alpha, float flag)
float drawfill(vector position, vector size, vector rgb, float alpha, float flag)
-
+ drawsetcliparea(float x, float y, float width, float height)
+ drawresetcliparea()
+vector getimagesize(string pic)
+
==============================================================================
menu cmd list:
===============
setkeydest(float dest)
-float getkeydest
+float getkeydest()
setmousetarget(float target)
float getmousetarget(void)
+
+ callfunction(...,string function_name)
+ writetofile(float fhandle, entity ent)
+float isfunction(string function_name)
+vector getresolution(float number)
+string keynumtostring(float keynum)
+string findkeysforcommand(string command)
+float gethostcachevalue(float type)
+string gethostcachestring(float type, float hostnr)
+
+ parseentitydata(entity ent, string data)
*/
#include "quakedef.h"
#include "progdefs.h"
+#include "progsvm.h"
#include "clprogdefs.h"
#include "mprogdefs.h"
// nice helper macros
#ifndef VM_NOPARMCHECK
-#define VM_SAFEPARMCOUNT(p,f) if(prog->argc != p) PRVM_ERROR(#f "wrong parameter count (" #p "expected ) !\n")
+#define VM_SAFEPARMCOUNT(p,f) if(prog->argc != p) PRVM_ERROR(#f " wrong parameter count (" #p " expected ) !\n")
#else
#define VM_SAFEPARMCOUNT(p,f)
#endif
// temp string handling
// LordHavoc: added this to semi-fix the problem of using many ftos calls in a print
-#define STRINGTEMP_BUFFERS 16
-#define STRINGTEMP_LENGTH 4096
-static char vm_string_temp[STRINGTEMP_BUFFERS][STRINGTEMP_LENGTH];
+#define VM_STRINGTEMP_BUFFERS 16
+#define VM_STRINGTEMP_LENGTH 4096
+static char vm_string_temp[VM_STRINGTEMP_BUFFERS][VM_STRINGTEMP_LENGTH];
static int vm_string_tempindex = 0;
-// qc cvar
-#define MAX_QC_CVARS 128 * PRVM_MAXPROGS
-cvar_t vm_qc_cvar[MAX_QC_CVARS];
-int vm_currentqc_cvar;
-
// qc file handling
#define MAX_VMFILES 256
#define MAX_PRVMFILES MAX_VMFILES * PRVM_MAXPROGS
qfile_t *vm_files[MAX_PRVMFILES];
+// qc fs search handling
+#define MAX_VMSEARCHES 128
+#define TOTAL_VMSEARCHES MAX_VMSEARCHES * PRVM_MAXPROGS
+#define VM_SEARCHLIST ((fssearch_t**)(vm_fssearchlist + PRVM_GetProgNr() * MAX_VMSEARCHES))
+
+fssearch_t *vm_fssearchlist[TOTAL_VMSEARCHES];
+
static char *VM_GetTempString(void)
{
char *s;
s = vm_string_temp[vm_string_tempindex];
- vm_string_tempindex = (vm_string_tempindex + 1) % STRINGTEMP_BUFFERS;
+ vm_string_tempindex = (vm_string_tempindex + 1) % VM_STRINGTEMP_BUFFERS;
return s;
}
char *outend;
outend = out + outlength - 1;
- for (i = first;i < pr_argc && out < outend;i++)
+ for (i = first;i < prog->argc && out < outend;i++)
{
s = PRVM_G_STRING((OFS_PARM0+i*3));
while (out < outend && *s)
void VM_error (void)
{
prvm_edict_t *ed;
- char string[STRINGTEMP_LENGTH];
+ char string[VM_STRINGTEMP_LENGTH];
VM_VarString(0, string, sizeof(string));
- Con_Printf ("======%S ERROR in %s:\n%s\n", PRVM_NAME, PRVM_GetString(prog->xfunction->s_name), string);
+ Con_Printf("======%S ERROR in %s:\n%s\n", PRVM_NAME, PRVM_GetString(prog->xfunction->s_name), string);
if(prog->self)
{
ed = PRVM_G_EDICT(prog->self->ofs);
- PRVM_ED_Print (ed);
+ PRVM_ED_Print(ed);
}
PRVM_ERROR ("%s: Program error", PRVM_NAME);
void VM_objerror (void)
{
prvm_edict_t *ed;
- char string[STRINGTEMP_LENGTH];
+ char string[VM_STRINGTEMP_LENGTH];
VM_VarString(0, string, sizeof(string));
- Con_Printf ("======%s OBJECT ERROR in %s:\n%s\n", PRVM_NAME, PRVM_GetString(prog->xfunction->s_name), string);
+ Con_Printf("======%s OBJECT ERROR in %s:\n%s\n", PRVM_NAME, PRVM_GetString(prog->xfunction->s_name), string);
if(prog->self)
{
ed = PRVM_G_EDICT (prog->self->ofs);
- PRVM_ED_Print (ed);
+ PRVM_ED_Print(ed);
PRVM_ED_Free (ed);
}
*/
void VM_print (void)
{
- char string[STRINGTEMP_LENGTH];
+ char string[VM_STRINGTEMP_LENGTH];
VM_VarString(0, string, sizeof(string));
Con_Print(string);
*/
void VM_bprint (void)
{
- char string[STRINGTEMP_LENGTH];
+ char string[VM_STRINGTEMP_LENGTH];
if(!sv.active)
{
- Con_Printf("VM_bprint: game is not server(%s) !", PRVM_NAME);
+ Con_Printf("VM_bprint: game is not server(%s) !\n", PRVM_NAME);
return;
}
VM_VarString(0, string, sizeof(string));
- SV_BroadcastPrintf("%s", string);
+ SV_BroadcastPrint(string);
}
/*
{
client_t *client;
int clientnum;
- char string[STRINGTEMP_LENGTH];
+ char string[VM_STRINGTEMP_LENGTH];
//find client for this entity
clientnum = PRVM_G_FLOAT(OFS_PARM0);
if (!sv.active || clientnum < 0 || clientnum >= svs.maxclients || !svs.clients[clientnum].active)
{
- Con_Printf("VM_sprint: %s: invalid client or server is not active !", PRVM_NAME);
+ 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_centerprint (void)
{
- char string[STRINGTEMP_LENGTH];
+ char string[VM_STRINGTEMP_LENGTH];
VM_VarString(0, string, sizeof(string));
SCR_CenterPrint(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);
}
/*
s = PRVM_G_STRING(OFS_PARM0);
- if(!S_GetCached(s))
+ if(!S_LocalSound (s))
{
- Con_Printf("VM_localsound: %s : %s not cached !\n", PRVM_NAME, s);
+ Con_Printf("VM_localsound: Failed to play %s for %s !\n", s, PRVM_NAME);
PRVM_G_FLOAT(OFS_RETURN) = -4;
return;
}
- S_LocalSound(s);
PRVM_G_FLOAT(OFS_RETURN) = 1;
}
PRVM_G_FLOAT(OFS_RETURN) = Cvar_VariableValue(PRVM_G_STRING(OFS_PARM0));
}
+/*
+=================
+VM_str_cvar
+
+const string str_cvar (string)
+=================
+*/
+void VM_str_cvar(void)
+{
+ char *out, *name;
+ const char *cvar_string;
+ VM_SAFEPARMCOUNT(1,VM_str_cvar);
+
+ name = PRVM_G_STRING(OFS_PARM0);
+
+ if(!name)
+ PRVM_ERROR("VM_str_cvar: %s: null string\n", PRVM_NAME);
+
+ VM_CheckEmptyString(name);
+
+ out = VM_GetTempString();
+
+ cvar_string = Cvar_VariableString(name);
+
+ strcpy(out, cvar_string);
+
+ PRVM_G_INT(OFS_RETURN) = PRVM_SetString(out);
+}
+
/*
=================
VM_cvar_set
*/
void VM_dprint (void)
{
- char string[STRINGTEMP_LENGTH];
+ char string[VM_STRINGTEMP_LENGTH];
if (developer.integer)
{
VM_VarString(0, string, sizeof(string));
*/
void VM_stof(void)
{
- char string[STRINGTEMP_LENGTH];
+ char string[VM_STRINGTEMP_LENGTH];
VM_VarString(0, string, sizeof(string));
PRVM_G_FLOAT(OFS_RETURN) = atof(string);
}
+/*
+========================
+VM_itof
+
+float itof(intt ent)
+========================
+*/
+void VM_itof(void)
+{
+ VM_SAFEPARMCOUNT(1, VM_itof);
+ PRVM_G_FLOAT(OFS_RETURN) = PRVM_G_INT(OFS_PARM0);
+}
+
+/*
+========================
+VM_itoe
+
+intt ftoi(float num)
+========================
+*/
+void VM_ftoi(void)
+{
+ int ent;
+ VM_SAFEPARMCOUNT(1, VM_ftoi);
+
+ 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;
+}
+
/*
=========
VM_spawn
=========
VM_remove
-entity remove()
+remove(entity e)
=========
*/
{
prog->xfunction->builtinsprofile++;
ed = PRVM_EDICT_NUM(e);
- if (ed->e->free)
+ if (ed->p.e->free)
continue;
t = PRVM_E_STRING(ed,f);
if (!t)
}
}
- VM_RETURN_EDICT(sv.edicts);
+ VM_RETURN_EDICT(prog->edicts);
}
/*
{
prog->xfunction->builtinsprofile++;
ed = PRVM_EDICT_NUM(e);
- if (ed->e->free)
+ if (ed->p.e->free)
continue;
if (PRVM_E_FLOAT(ed,f) == s)
{
for (i = 1;i < prog->num_edicts;i++, ent = PRVM_NEXT_EDICT(ent))
{
prog->xfunction->builtinsprofile++;
- if (ent->e->free)
+ if (ent->p.e->free)
continue;
t = PRVM_E_STRING(ent,f);
if (!t)
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;
}
for (i = 1;i < prog->num_edicts;i++, ent = PRVM_NEXT_EDICT(ent))
{
prog->xfunction->builtinsprofile++;
- if (ent->e->free)
+ 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;
}
s = PRVM_G_STRING(OFS_PARM0);
PRVM_G_INT(OFS_RETURN) = PRVM_G_INT(OFS_PARM0);
VM_CheckEmptyString (s);
-
- if(S_GetCached(s))
- {
- Con_Printf("VM_precache_sound: %s already cached (%s)\n", s, PRVM_NAME);
- return;
- }
-
- if(!S_PrecacheSound(s,true))
- Con_Printf("VM_prache_sound: Failed to load %s for %s\n", s, PRVM_NAME);
+
+ if(!S_PrecacheSound (s,true, true))
+ Con_Printf("VM_precache_sound: Failed to load %s for %s\n", s, PRVM_NAME);
}
/*
{
VM_SAFEPARMCOUNT(0,VM_coredump);
- PRVM_ED_PrintEdicts_f ();
+ Cbuf_AddText("prvm_edicts ");
+ Cbuf_AddText(PRVM_NAME);
+ Cbuf_AddText("\n");
+}
+
+/*
+=========
+VM_stackdump
+
+stackdump()
+=========
+*/
+void PRVM_StackTrace(void);
+void VM_stackdump (void)
+{
+ VM_SAFEPARMCOUNT(0, VM_stackdump);
+
+ PRVM_StackTrace();
+}
+
+/*
+=========
+VM_crash
+
+crash()
+=========
+*/
+
+void VM_crash(void)
+{
+ VM_SAFEPARMCOUNT(0, VM_crash);
+
+ PRVM_ERROR("Crash called by %s\n",PRVM_NAME);
}
/*
return;
}
ent = PRVM_EDICT_NUM(i);
- if (!ent->e->free)
+ if (!ent->p.e->free)
{
VM_RETURN_EDICT(ent);
return;
case MSG_ONE:
destclient = (int) PRVM_G_FLOAT(OFS_PARM2);
- if (!sv.active || destclient < 0 || destclient >= svs.maxclients || !svs.clients[destclient].active)
- PRVM_ERROR("VM_clientcommand: %s: invalid client/server is not active !", PRVM_NAME);
+ if (destclient < 0 || destclient >= svs.maxclients || !svs.clients[destclient].active)
+ PRVM_ERROR("VM_clientcommand: %s: invalid client !\n", PRVM_NAME);
return &svs.clients[destclient].message;
void VM_WriteAngle (void)
{
- MSG_WriteAngle (VM_WriteDest(), PRVM_G_FLOAT(OFS_PARM0));
+ MSG_WriteAngle (VM_WriteDest(), PRVM_G_FLOAT(OFS_PARM0), sv.protocol);
}
void VM_WriteCoord (void)
{
- MSG_WriteDPCoord (VM_WriteDest(), PRVM_G_FLOAT(OFS_PARM0));
+ MSG_WriteCoord (VM_WriteDest(), PRVM_G_FLOAT(OFS_PARM0), sv.protocol);
}
void VM_WriteString (void)
=========
VM_registercvar
-float registercvar (string name, string value)
+float registercvar (string name, string value, float flags)
=========
*/
void VM_registercvar (void)
{
char *name, *value;
- cvar_t *variable;
+ int flags;
- VM_SAFEPARMCOUNT(2,VM_registercvar);
+ VM_SAFEPARMCOUNT(3,VM_registercvar);
name = PRVM_G_STRING(OFS_PARM0);
value = PRVM_G_STRING(OFS_PARM1);
+ flags = PRVM_G_FLOAT(OFS_PARM2);
PRVM_G_FLOAT(OFS_RETURN) = 0;
+
+ if(flags > CVAR_MAXFLAGSVAL)
+ return;
+
// first check to see if it has already been defined
if (Cvar_FindVar (name))
return;
// check for overlap with a command
if (Cmd_Exists (name))
{
- Con_Printf ("VM_registercvar: %s is a command\n", name);
+ Con_Printf("VM_registercvar: %s is a command\n", name);
return;
}
- if (vm_currentqc_cvar >= MAX_QC_CVARS)
- PRVM_ERROR ("VM_registercvar: ran out of cvar slots (%i)\n", MAX_QC_CVARS);
+ Cvar_Get(name, value, flags);
-// copy the name and value
- variable = &vm_qc_cvar[vm_currentqc_cvar++];
- variable->name = Z_Malloc (strlen(name)+1);
- strcpy (variable->name, name);
- variable->string = Z_Malloc (strlen(value)+1);
- strcpy (variable->string, value);
- variable->value = atof (value);
-
- Cvar_RegisterVariable(variable);
PRVM_G_FLOAT(OFS_RETURN) = 1; // success
}
void VM_max (void)
{
// LordHavoc: 3+ argument enhancement suggested by FrikaC
- if (pr_argc == 2)
+ if (prog->argc == 2)
PRVM_G_FLOAT(OFS_RETURN) = max(PRVM_G_FLOAT(OFS_PARM0), PRVM_G_FLOAT(OFS_PARM1));
- else if (pr_argc >= 3)
+ else if (prog->argc >= 3)
{
int i;
float f = PRVM_G_FLOAT(OFS_PARM0);
- for (i = 1;i < pr_argc;i++)
+ 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);
if (entnum < 1 || entnum > svs.maxclients || !svs.clients[entnum-1].active)
{
- Con_Printf ("tried to setcolor a non-client\n");
+ Con_Print("tried to setcolor a non-client\n");
return;
}
modestring = "wb";
break;
default:
- Con_Printf ("VM_fopen: %s no such mode %i (valid: 0 = read, 1 = append, 2 = write)\n", PRVM_NAME, mode);
+ Con_Printf("VM_fopen: %s no such mode %i (valid: 0 = read, 1 = append, 2 = write)\n", PRVM_NAME, mode);
PRVM_G_FLOAT(OFS_RETURN) = -3;
return;
}
// \ is a windows-ism (so it's naughty to use it, / works on all platforms)
if ((filename[0] == '.' && filename[1] == '.') || filename[0] == '/' || strrchr(filename, ':') || strrchr(filename, '\\'))
{
- Con_Printf("VM_fopen: dangerous or non-portable filename \"%s\" not allowed. (contains : or \\ or begins with .. or /)\n", filename);
+ Con_Printf("VM_fopen: %s dangerous or non-portable filename \"%s\" not allowed. (contains : or \\ or begins with .. or /)\n", PRVM_NAME, filename);
PRVM_G_FLOAT(OFS_RETURN) = -4;
return;
}
VM_FILES[filenum] = FS_Open(va("data/%s", filename), modestring, false);
+ if (VM_FILES[filenum] == NULL && mode == 0)
+ VM_FILES[filenum] = FS_Open(va("%s", filename), modestring, false);
+
if (VM_FILES[filenum] == NULL)
PRVM_G_FLOAT(OFS_RETURN) = -1;
else
void VM_fgets(void)
{
int c, end;
- static char string[STRINGTEMP_LENGTH];
+ static char string[VM_STRINGTEMP_LENGTH];
int filenum;
VM_SAFEPARMCOUNT(1,VM_fgets);
c = FS_Getc(VM_FILES[filenum]);
if (c == '\r' || c == '\n' || c < 0)
break;
- if (end < STRINGTEMP_LENGTH - 1)
+ if (end < VM_STRINGTEMP_LENGTH - 1)
string[end++] = c;
}
string[end] = 0;
c = FS_Getc(VM_FILES[filenum]);
if (developer.integer)
Con_Printf("fgets: %s: %s\n", PRVM_NAME, string);
- if (c >= 0)
+ if (c >= 0 || end)
PRVM_G_INT(OFS_RETURN) = PRVM_SetString(string);
else
PRVM_G_INT(OFS_RETURN) = 0;
void VM_fputs(void)
{
int stringlength;
- char string[STRINGTEMP_LENGTH];
+ char string[VM_STRINGTEMP_LENGTH];
int filenum;
VM_SAFEPARMCOUNT(2,VM_fputs);
{
char *s;
- if(prog->argc <= 2)
- PRVM_ERROR("VM_strcat wrong parameter count (min. 2 expected ) !\n");
+ if(prog->argc < 1)
+ PRVM_ERROR("VM_strcat wrong parameter count (min. 1 expected ) !\n");
s = VM_GetTempString();
- VM_VarString(0, s, STRINGTEMP_LENGTH);
+ VM_VarString(0, s, VM_STRINGTEMP_LENGTH);
PRVM_G_INT(OFS_RETURN) = PRVM_SetString(s);
}
if (!s)
s = "";
for (i = 0;i < start && *s;i++, s++);
- for (i = 0;i < STRINGTEMP_LENGTH - 1 && *s && i < length;i++, s++)
+ 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);
//vector(string s) stov = #117; // returns vector value from a string
void VM_stov(void)
{
- char string[STRINGTEMP_LENGTH];
+ char string[VM_STRINGTEMP_LENGTH];
VM_SAFEPARMCOUNT(1,VM_stov);
//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);
- Mem_Free(PRVM_G_STRING(OFS_PARM0));
+ 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 );
}
/*
i = PRVM_G_FLOAT(OFS_PARM0);
if (!sv.active || i < 0 || i >= svs.maxclients || !svs.clients[i].active)
{
- Con_Printf("VM_clientcommand: %s: invalid client/server is not active !", PRVM_NAME);
+ Con_Printf("VM_clientcommand: %s: invalid client/server is not active !\n", PRVM_NAME);
return;
}
for (i = 0;i < model->data_overridetagnamesforskin[(unsigned int)tagentity->v->skin].num_overridetagnames;i++)
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))
PRVM_G_FLOAT(OFS_RETURN) = cls.state;
}
+/*
+=========
+VM_getostype
+
+float getostype(void)
+=========
+*/ // not used at the moment -> not included in the common list
+void VM_getostype(void)
+{
+ VM_SAFEPARMCOUNT(0,VM_getostype);
+
+ /*
+ OS_WINDOWS
+ OS_LINUX
+ OS_MAC - not supported
+ */
+
+#ifdef _WIN32
+ PRVM_G_FLOAT(OFS_RETURN) = 0;
+#elif defined _MAC
+ PRVM_G_FLOAT(OFS_RETURN) = 2;
+#else
+ PRVM_G_FLOAT(OFS_RETURN) = 1;
+#endif
+}
+
+/*
+=========
+VM_getmousepos
+
+vector getmousepos()
+=========
+*/
+void VM_getmousepos(void)
+{
+
+ VM_SAFEPARMCOUNT(0,VM_getmousepos);
+
+ PRVM_G_VECTOR(OFS_RETURN)[0] = in_mouse_x;
+ PRVM_G_VECTOR(OFS_RETURN)[1] = in_mouse_y;
+ PRVM_G_VECTOR(OFS_RETURN)[2] = 0;
+}
+
+/*
+=========
+VM_gettime
+
+float gettime(void)
+=========
+*/
+void VM_gettime(void)
+{
+ VM_SAFEPARMCOUNT(0,VM_gettime);
+
+ PRVM_G_FLOAT(OFS_RETURN) = (float) *prog->time;
+}
+
+/*
+=========
+VM_loadfromdata
+
+loadfromdata(string data)
+=========
+*/
+void VM_loadfromdata(void)
+{
+ VM_SAFEPARMCOUNT(1,VM_loadentsfromfile);
+
+ PRVM_ED_LoadFromFile(PRVM_G_STRING(OFS_PARM0));
+}
+
+/*
+========================
+VM_M_parseentitydata
+
+parseentitydata(entity ent, string data)
+========================
+*/
+void VM_M_parseentitydata(void)
+{
+ prvm_edict_t *ent;
+ const char *data;
+
+ VM_SAFEPARMCOUNT(2, VM_parseentitydata);
+
+ // get edict and test it
+ ent = PRVM_G_EDICT(OFS_PARM0);
+ if (ent->p.e->free)
+ PRVM_ERROR ("VM_parseentitydata: %s: Can only set already spawned entities (entity %i is free)!\n", PRVM_NAME, PRVM_NUM_FOR_EDICT(ent));
+
+ data = PRVM_G_STRING(OFS_PARM1);
+
+ // parse the opening brace
+ if (!COM_ParseToken(&data, false) || com_token[0] != '{' )
+ PRVM_ERROR ("VM_parseentitydata: %s: Couldn't parse entity data:\n%s\n", PRVM_NAME, data );
+
+ PRVM_ED_ParseEdict (data, ent);
+}
+
+/*
+=========
+VM_loadfromfile
+
+loadfromfile(string file)
+=========
+*/
+void VM_loadfromfile(void)
+{
+ 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
+ // : is root of drive on Amiga (also used as a directory separator on Mac, but / works there too, so that's a bad idea)
+ // \ is a windows-ism (so it's naughty to use it, / works on all platforms)
+ if ((filename[0] == '.' && filename[1] == '.') || filename[0] == '/' || strrchr(filename, ':') || strrchr(filename, '\\'))
+ {
+ Con_Printf("VM_loadfromfile: %s dangerous or non-portable filename \"%s\" not allowed. (contains : or \\ or begins with .. or /)\n", PRVM_NAME, filename);
+ PRVM_G_FLOAT(OFS_RETURN) = -4;
+ return;
+ }
+
+ // not conform with VM_fopen
+ data = FS_LoadFile(filename, tempmempool, false);
+ if (data == NULL)
+ PRVM_G_FLOAT(OFS_RETURN) = -1;
+
+ PRVM_ED_LoadFromFile(data);
+
+ if(data)
+ Mem_Free(data);
+}
+
+
+/*
+=========
+VM_modulo
+
+float mod(float val, float m)
+=========
+*/
+void VM_modulo(void)
+{
+ int val, m;
+ VM_SAFEPARMCOUNT(2,VM_module);
+
+ val = (int) PRVM_G_FLOAT(OFS_PARM0);
+ m = (int) PRVM_G_FLOAT(OFS_PARM1);
+
+ PRVM_G_FLOAT(OFS_RETURN) = (float) (val % m);
+}
+
+void VM_Search_Init(void)
+{
+ memset(VM_SEARCHLIST,0,sizeof(fssearch_t*[MAX_VMSEARCHES]));
+}
+
+void VM_Search_Reset(void)
+{
+ int i;
+ // reset the fssearch list
+ for(i = 0; i < MAX_VMSEARCHES; i++)
+ if(VM_SEARCHLIST[i])
+ FS_FreeSearch(VM_SEARCHLIST[i]);
+ memset(VM_SEARCHLIST,0,sizeof(fssearch_t*[MAX_VMSEARCHES]));
+}
+
+/*
+=========
+VM_search_begin
+
+float search_begin(string pattern, float caseinsensitive, float quiet)
+=========
+*/
+void VM_search_begin(void)
+{
+ int handle;
+ char *pattern;
+ int caseinsens, quiet;
+
+ VM_SAFEPARMCOUNT(3, VM_search_begin);
+
+ pattern = PRVM_G_STRING(OFS_PARM0);
+
+ VM_CheckEmptyString(pattern);
+
+ caseinsens = PRVM_G_FLOAT(OFS_PARM1);
+ quiet = PRVM_G_FLOAT(OFS_PARM2);
+
+ for(handle = 0; handle < MAX_VMSEARCHES; handle++)
+ if(!VM_SEARCHLIST[handle])
+ break;
+
+ if(handle >= MAX_VMSEARCHES)
+ {
+ Con_Printf("VM_search_begin: %s ran out of search handles (%i)\n", PRVM_NAME, MAX_VMSEARCHES);
+ PRVM_G_FLOAT(OFS_RETURN) = -2;
+ return;
+ }
+
+ if(!(VM_SEARCHLIST[handle] = FS_Search(pattern,caseinsens, quiet)))
+ PRVM_G_FLOAT(OFS_RETURN) = -1;
+ else
+ PRVM_G_FLOAT(OFS_RETURN) = handle;
+}
+
+/*
+=========
+VM_search_end
+
+void search_end(float handle)
+=========
+*/
+void VM_search_end(void)
+{
+ int handle;
+ 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);
+ return;
+ }
+ if(VM_SEARCHLIST[handle] == NULL)
+ {
+ Con_Printf("VM_search_end: no such handle %i in %s\n", handle, PRVM_NAME);
+ return;
+ }
+
+ FS_FreeSearch(VM_SEARCHLIST[handle]);
+ VM_SEARCHLIST[handle] = NULL;
+}
+
+/*
+=========
+VM_search_getsize
+
+float search_getsize(float handle)
+=========
+*/
+void VM_search_getsize(void)
+{
+ int handle;
+ VM_SAFEPARMCOUNT(1, VM_M_search_getsize);
+
+ handle = PRVM_G_FLOAT(OFS_PARM0);
+
+ if(handle < 0 || handle >= MAX_VMSEARCHES)
+ {
+ Con_Printf("VM_search_getsize: invalid handle %i used in %s\n", handle, PRVM_NAME);
+ return;
+ }
+ if(VM_SEARCHLIST[handle] == NULL)
+ {
+ 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;
+}
+
+/*
+=========
+VM_search_getfilename
+
+string search_getfilename(float handle, float num)
+=========
+*/
+void VM_search_getfilename(void)
+{
+ int handle, filenum;
+ char *tmp;
+ VM_SAFEPARMCOUNT(2, VM_search_getfilename);
+
+ handle = PRVM_G_FLOAT(OFS_PARM0);
+ filenum = PRVM_G_FLOAT(OFS_PARM1);
+
+ if(handle < 0 || handle >= MAX_VMSEARCHES)
+ {
+ Con_Printf("VM_search_getfilename: invalid handle %i used in %s\n", handle, PRVM_NAME);
+ return;
+ }
+ if(VM_SEARCHLIST[handle] == NULL)
+ {
+ Con_Printf("VM_search_getfilename: no such handle %i in %s\n", handle, PRVM_NAME);
+ return;
+ }
+ if(filenum < 0 || filenum >= 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);
+}
+
+/*
+=========
+VM_chr
+
+string chr(float ascii)
+=========
+*/
+void VM_chr(void)
+{
+ char *tmp;
+ VM_SAFEPARMCOUNT(1, VM_chr);
+
+ tmp = VM_GetTempString();
+ tmp[0] = (unsigned char) PRVM_G_FLOAT(OFS_PARM0);
+ tmp[1] = 0;
+
+ PRVM_G_INT(OFS_RETURN) = PRVM_SetString(tmp);
+}
+
//=============================================================================
// Draw builtins (client & menu)
PRVM_G_INT(OFS_RETURN) = PRVM_G_INT(OFS_PARM0);
if(!s)
- PRVM_ERROR ("VM_precache_pic: %s: NULL\n");
+ PRVM_ERROR ("VM_precache_pic: %s: NULL\n", PRVM_NAME);
VM_CheckEmptyString (s);
- Draw_CachePic(s);
+ if(!Draw_CachePic(s))
+ PRVM_G_INT(OFS_RETURN) = PRVM_SetString("");
}
/*
}
if(pos[2] || scale[2])
- Con_Printf("VM_drawcharacter: z value%c from %s discarded",(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])
{
}
if(pos[2] || scale[2])
- Con_Printf("VM_drawstring: z value%c from %s discarded",(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;
VM_CheckEmptyString (pic);
- // is pic cached ?
+ // is pic cached ? no function yet for that
if(!1)
{
Con_Printf("VM_drawpic: %s: %s not cached !\n", PRVM_NAME, pic);
}
if(pos[2] || size[2])
- Con_Printf("VM_drawstring: z value%c from %s discarded",(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;
}
if(pos[2] || size[2])
- Con_Printf("VM_drawstring: z value%c from %s discarded",(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;
/*
=========
-VM_getmousepos
+VM_drawsetcliparea
-vector getmousepos()
+drawsetcliparea(float x, float y, float width, float height)
=========
*/
-void VM_getmousepos(void)
+void VM_drawsetcliparea(void)
{
+ float x,y,w,h;
+ VM_SAFEPARMCOUNT(4,VM_drawsetcliparea);
- VM_SAFEPARMCOUNT(0,VM_getmousepos);
+ 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));
+
+ DrawQ_SetClipArea(x,y,w,h);
+}
+
+/*
+=========
+VM_drawresetcliparea
+
+drawresetcliparea()
+=========
+*/
+void VM_drawresetcliparea(void)
+{
+ VM_SAFEPARMCOUNT(0,VM_drawresetcliparea);
+
+ DrawQ_ResetClipArea();
+}
+
+/*
+=========
+VM_getimagesize
+
+vector getimagesize(string pic)
+=========
+*/
+void VM_getimagesize(void)
+{
+ char *p;
+ cachepic_t *pic;
+
+ VM_SAFEPARMCOUNT(1,VM_getimagesize);
- PRVM_G_VECTOR(OFS_RETURN)[0] = in_mouse_x;
- PRVM_G_VECTOR(OFS_RETURN)[1] = in_mouse_y;
- PRVM_G_VECTOR(OFS_RETURN)[0] = 0;
+ 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);
+
+ PRVM_G_VECTOR(OFS_RETURN)[0] = pic->width;
+ PRVM_G_VECTOR(OFS_RETURN)[1] = pic->height;
+ PRVM_G_VECTOR(OFS_RETURN)[2] = 0;
}
void VM_Cmd_Init(void)
{
// only init the stuff for the current prog
- VM_STRINGS_MEMPOOL = Mem_AllocPool(va("vm_stringsmempool[%s]",PRVM_NAME));
- VM_Files_Init();
+ 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_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);
+ VM_Search_Reset();
VM_Files_CloseAll();
}
*/
void VM_M_setkeydest(void)
{
- VM_SAFEPARMCOUNT(1,VM_M_SetKeyDest);
+ VM_SAFEPARMCOUNT(1,VM_M_setkeydest);
switch((int)PRVM_G_FLOAT(OFS_PARM0))
{
*/
void VM_M_getkeydest(void)
{
- VM_SAFEPARMCOUNT(0,VM_M_GetKeyDest);
+ VM_SAFEPARMCOUNT(0,VM_M_getkeydest);
// key_game = 0, key_message = 1, key_menu = 2, unknown = 3
switch(key_dest)
}
}
+/*
+=========
+VM_M_callfunction
+
+ callfunction(...,string function_name)
+Extension: pass
+=========
+*/
+mfunction_t *PRVM_ED_FindFunction (const char *name);
+void VM_M_callfunction(void)
+{
+ mfunction_t *func;
+ char *s;
+
+ if(prog->argc == 0)
+ PRVM_ERROR("VM_M_callfunction: 1 parameter is required !\n");
+
+ s = PRVM_G_STRING(OFS_PARM0 + (prog->argc - 1));
+
+ if(!s)
+ PRVM_ERROR("VM_M_callfunction: null string !\n");
+
+ VM_CheckEmptyString(s);
+
+ func = PRVM_ED_FindFunction(s);
+
+ if(!func)
+ PRVM_ERROR("VM_M_callfunciton: function %s not found !\n", s);
+ else if (func->first_statement < 0)
+ {
+ // negative statements are built in functions
+ int builtinnumber = -func->first_statement;
+ prog->xfunction->builtinsprofile++;
+ if (builtinnumber < prog->numbuiltins && prog->builtins[builtinnumber])
+ prog->builtins[builtinnumber]();
+ else
+ PRVM_ERROR("No such builtin #%i in %s", builtinnumber, PRVM_NAME);
+ }
+ else if(func > 0)
+ {
+ prog->argc--;
+ PRVM_ExecuteProgram(func - prog->functions,"");
+ prog->argc++;
+ }
+}
+
+/*
+=========
+VM_M_isfunction
+
+float isfunction(string function_name)
+=========
+*/
+mfunction_t *PRVM_ED_FindFunction (const char *name);
+void VM_M_isfunction(void)
+{
+ mfunction_t *func;
+ char *s;
+
+ VM_SAFEPARMCOUNT(1, VM_M_isfunction);
+
+ s = PRVM_G_STRING(OFS_PARM0);
+
+ if(!s)
+ PRVM_ERROR("VM_M_isfunction: null string !\n");
+
+ VM_CheckEmptyString(s);
+
+ func = PRVM_ED_FindFunction(s);
+
+ if(!func)
+ PRVM_G_FLOAT(OFS_RETURN) = false;
+ else
+ PRVM_G_FLOAT(OFS_RETURN) = true;
+}
+
+/*
+=========
+VM_M_writetofile
+
+ writetofile(float fhandle, entity ent)
+=========
+*/
+void VM_M_writetofile(void)
+{
+ prvm_edict_t * ent;
+ int filenum;
+
+ VM_SAFEPARMCOUNT(2, VM_M_writetofile);
+
+ filenum = PRVM_G_FLOAT(OFS_PARM0);
+ if (filenum < 0 || filenum >= MAX_VMFILES)
+ {
+ Con_Printf("VM_fputs: invalid file handle %i used in %s\n", filenum, PRVM_NAME);
+ return;
+ }
+ if (VM_FILES[filenum] == NULL)
+ {
+ Con_Printf("VM_fputs: no such file handle %i (or file has been closed) in %s\n", filenum, PRVM_NAME);
+ return;
+ }
+
+ 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));
+ return;
+ }
+
+ PRVM_ED_Write (VM_FILES[filenum], ent);
+}
+
+/*
+=========
+VM_M_getresolution
+
+vector getresolution(float number)
+=========
+*/
+extern unsigned short video_resolutions[][2];
+void VM_M_getresolution(void)
+{
+ int nr;
+ VM_SAFEPARMCOUNT(1, VM_getresolution);
+
+ nr = PRVM_G_FLOAT(OFS_PARM0);
+
+
+ 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;
+}
+
+/*
+=========
+VM_M_keynumtostring
+
+string keynumtostring(float keynum)
+=========
+*/
+void VM_M_keynumtostring(void)
+{
+ int keynum;
+ char *tmp;
+ VM_SAFEPARMCOUNT(1, VM_M_keynumtostring);
+
+ keynum = PRVM_G_FLOAT(OFS_PARM0);
+
+ tmp = VM_GetTempString();
+
+ strcpy(tmp, Key_KeynumToString(keynum));
+
+ PRVM_G_INT(OFS_RETURN) = PRVM_SetString(tmp);
+}
+
+/*
+=========
+VM_M_findkeysforcommand
+
+string findkeysforcommand(string command)
+
+the returned string is an altstring
+=========
+*/
+#define NUMKEYS 5 // TODO: merge the constant in keys.c with this one somewhen
+
+void M_FindKeysForCommand(char *command, int *keys);
+void VM_M_findkeysforcommand(void)
+{
+ char *cmd, *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);
+}
+
+/*
+=========
+VM_M_gethostcachecount
+
+float gethostcachevalue(float type)
+=========
+*/
+/*
+ type:
+0 hostcachecount
+1 masterquerycount
+2 masterreplycount
+3 serverquerycount
+4 serverreplycount
+*/
+void VM_M_gethostcachevalue( void )
+{
+ int type;
+ VM_SAFEPARMCOUNT ( 1, VM_M_gethostcachevalue );
+
+ 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)
+ {
+ case 0:
+ PRVM_G_FLOAT ( OFS_RETURN ) = hostCacheCount;
+ return;
+ case 1:
+ PRVM_G_FLOAT ( OFS_RETURN ) = masterquerycount;
+ return;
+ case 2:
+ PRVM_G_FLOAT ( OFS_RETURN ) = masterreplycount;
+ return;
+ case 3:
+ PRVM_G_FLOAT ( OFS_RETURN ) = serverquerycount;
+ return;
+ case 4:
+ PRVM_G_FLOAT ( OFS_RETURN ) = serverreplycount;
+ return;
+ }
+}
+
+/*
+=========
+VM_M_gethostcachestring
+
+string gethostcachestring(float type, float hostnr)
+=========
+*/
+/*
+0 Get CName
+1 Get line1
+2 Get line2
+*/
+void VM_M_gethostcachestring(void)
+{
+ int type;
+ int hostnr;
+
+ VM_SAFEPARMCOUNT(2, VM_M_gethostcachestring);
+
+ PRVM_G_INT(OFS_RETURN) = 0;
+
+ type = PRVM_G_FLOAT(OFS_PARM0);
+
+ if(type < 0 || type > 2)
+ {
+ Con_Print("VM_M_gethostcachestring: bad string type requested!\n");
+ return;
+ }
+
+ hostnr = PRVM_G_FLOAT(OFS_PARM1);
+
+ if(hostnr < 0 || hostnr >= hostCacheCount)
+ {
+ Con_Print("VM_M_gethostcachestring: bad hostnr passed!\n");
+ return;
+ }
+
+ 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 );
+ else
+ PRVM_G_INT( OFS_RETURN ) = PRVM_SetString( hostcache[hostnr].line2 );
+}
+
prvm_builtin_t vm_m_builtins[] = {
0, // to be consistent with the old vm
// common builtings (mostly)
VM_clcommand,
VM_changelevel,
VM_localsound,
- VM_getmousepos, // 66
- 0,
- 0,
- 0,
- 0, // 70
- e10, // 80
+ VM_getmousepos,
+ VM_gettime,
+ VM_loadfromdata,
+ VM_loadfromfile,
+ VM_modulo, // 70
+ VM_str_cvar,
+ VM_crash,
+ VM_stackdump, // 73
+ VM_search_begin,
+ VM_search_end,
+ VM_search_getsize,
+ VM_search_getfilename, // 77
+ VM_chr,
+ VM_itof,
+ VM_ftoi,// 80
e10, // 90
e10, // 100
e100, // 200
VM_WriteAngle,
VM_WriteCoord,
VM_WriteString,
- VM_WriteEntity,
+ VM_WriteEntity, // 408
0,
0, // 410
e10, // 420
VM_drawcharacter,
VM_drawstring,
VM_drawpic,
- VM_drawfill, // 457
- 0,
- 0,
- 0, // 460
+ VM_drawfill,
+ VM_drawsetcliparea,
+ VM_drawresetcliparea,
+ VM_getimagesize,// 460
e10, // 470
e10, // 480
e10, // 490
VM_M_setkeydest,
VM_M_getkeydest,
VM_M_setmousetarget,
- VM_M_getmousetarget
+ VM_M_getmousetarget,
+ VM_M_callfunction,
+ VM_M_writetofile,
+ VM_M_isfunction,
+ VM_M_getresolution,
+ VM_M_keynumtostring,
+ VM_M_findkeysforcommand,// 610
+ VM_M_gethostcachevalue,
+ VM_M_gethostcachestring,
+ VM_M_parseentitydata // 613
};
const int vm_m_numbuiltins = sizeof(vm_m_builtins) / sizeof(prvm_builtin_t);
void VM_M_Cmd_Reset(void)
{
- VM_Cmd_Init();
+ //VM_Cmd_Init();
+ VM_Cmd_Reset();
}
-
projects / xonotic / darkplaces.git / blobdiff