X-Git-Url: http://de.git.xonotic.org/?a=blobdiff_plain;f=prvm_cmds.c;h=f950bd2c4a682de7bb35a11d87ff536404f72a85;hb=9f8c931cec7c02394adaf1242b563aca077d36dc;hp=675049fa80b342f23b1b69941c747673f3b0f34c;hpb=9e1d9d449d3f69ade2f01e16e47d1e0ab3cf1688;p=xonotic%2Fdarkplaces.git diff --git a/prvm_cmds.c b/prvm_cmds.c index 675049fa..f950bd2c 100644 --- a/prvm_cmds.c +++ b/prvm_cmds.c @@ -1,7 +1,7 @@ // 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 @@ -32,11 +32,11 @@ string vtos(vector) string etos(entity) float stof(...[string]) entity spawn() -entity remove() + remove(entity e) entity find(entity start, .string field, string match) -entity findfloat(entity start, .float field, string match) -entity findentity(entity start, .entity field, string match) +entity findfloat(entity start, .float field, float match) +entity findentity(entity start, .entity field, entity match) entity findchain(.string field, string match) @@ -48,7 +48,7 @@ string precache_sound (string sample) coredump() traceon() traceoff() - eprint(entity float) + eprint(entity e) float rint(float) float floor(float) float ceil(float) @@ -56,7 +56,7 @@ entity nextent(entity) float sin(float) float cos(float) float sqrt(float) - randomvec() +vector randomvec() float registercvar (string name, string value) float min(float a, float b, ...[float]) float max(float a, float b, ...[float]) @@ -68,19 +68,35 @@ float fopen(string filename, float mode) string fgets(float fhandle) fputs(float fhandle, string s) float strlen(string s) -string strcat(string s1, string s2) +string strcat(string,string,...[string]) string substring(string s, float start, float length) vector stov(string s) string strzone(string s) - strzone(string s) + strunzone(string s) +float tokenize(string s) +string argv(float n) float isserver() float clientcount() float clientstate() clientcommand(float client, string s) (for client and menu) -float tokenize(string s) 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) + perhaps only : Menu : WriteMsg =============================== @@ -103,6 +119,25 @@ float drawcharacter(vector position, float character, vector scale, vector rgb, 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 + 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) */ @@ -115,7 +150,7 @@ float drawfill(vector position, vector size, vector rgb, float alpha, float flag // 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 @@ -136,9 +171,9 @@ 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 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 @@ -153,11 +188,18 @@ int vm_currentqc_cvar; 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; } @@ -177,7 +219,7 @@ void VM_VarString(int first, char *out, int outlength) 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) @@ -241,7 +283,7 @@ error(value) 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); @@ -267,7 +309,7 @@ objerror(value) 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); @@ -294,10 +336,10 @@ print(string) */ void VM_print (void) { - char string[STRINGTEMP_LENGTH]; + char string[VM_STRINGTEMP_LENGTH]; VM_VarString(0, string, sizeof(string)); - Con_Print(string); + Con_Printf(string); } /* @@ -311,7 +353,7 @@ bprint(...[string]) */ void VM_bprint (void) { - char string[STRINGTEMP_LENGTH]; + char string[VM_STRINGTEMP_LENGTH]; if(!sv.active) { @@ -336,7 +378,7 @@ void VM_sprint (void) { 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); @@ -365,7 +407,7 @@ centerprint(clientent, value) */ void VM_centerprint (void) { - char string[STRINGTEMP_LENGTH]; + char string[VM_STRINGTEMP_LENGTH]; VM_VarString(0, string, sizeof(string)); SCR_CenterPrint(string); @@ -639,6 +681,35 @@ void VM_cvar (void) 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_PARM0) = PRVM_SetString(out); +} + /* ================= VM_cvar_set @@ -662,7 +733,7 @@ dprint(...[string]) */ void VM_dprint (void) { - char string[STRINGTEMP_LENGTH]; + char string[VM_STRINGTEMP_LENGTH]; if (developer.integer) { VM_VarString(0, string, sizeof(string)); @@ -760,7 +831,7 @@ float stof(...[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); } @@ -848,15 +919,15 @@ void VM_find (void) } } - VM_RETURN_EDICT(sv.edicts); + VM_RETURN_EDICT(prog->edicts); } /* ========= VM_findfloat - entity findfloat(entity start, .float field, string match) - entity findentity(entity start, .entity field, string match) + entity findfloat(entity start, .float field, float match) + entity findentity(entity start, .entity field, entity match) ========= */ // LordHavoc: added this for searching float, int, and entity reference fields @@ -1055,7 +1126,39 @@ void VM_coredump (void) { 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); } /* @@ -1090,7 +1193,7 @@ void VM_traceoff (void) ========= VM_eprint -eprint(entity float) +eprint(entity e) ========= */ void VM_eprint (void) @@ -1213,8 +1316,8 @@ sizebuf_t *VM_WriteDest (void) 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; @@ -1347,7 +1450,7 @@ VM_randomvec Returns a vector of length < 1 and > 0 -randomvec() +vector randomvec() ================= */ void VM_randomvec (void) @@ -1461,13 +1564,13 @@ float max(float a, float b, ...[float]) 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; @@ -1627,7 +1730,7 @@ void VM_fopen(void) // \ 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; } @@ -1678,7 +1781,7 @@ string fgets(float fhandle) 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); @@ -1700,7 +1803,7 @@ void VM_fgets(void) 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; @@ -1726,7 +1829,7 @@ fputs(float fhandle, string s) void VM_fputs(void) { int stringlength; - char string[STRINGTEMP_LENGTH]; + char string[VM_STRINGTEMP_LENGTH]; int filenum; VM_SAFEPARMCOUNT(2,VM_fputs); @@ -1774,7 +1877,7 @@ void VM_strlen(void) ========= VM_strcat -string strcat(string s1, string s2) +string strcat(string,string,...[string]) ========= */ //string(string s1, string s2) strcat = #115; @@ -1784,10 +1887,11 @@ void VM_strcat(void) { char *s; - VM_SAFEPARMCOUNT(2,VM_strcat); - + if(prog->argc < 2) + PRVM_ERROR("VM_strcat wrong parameter count (min. 2 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); } @@ -1814,7 +1918,7 @@ void VM_substring(void) 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); @@ -1830,7 +1934,7 @@ vector stov(string s) //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); @@ -1862,7 +1966,7 @@ void VM_strzone(void) ========= VM_strunzone -strzone(string s) +strunzone(string s) ========= */ //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!!!) @@ -2013,7 +2117,7 @@ void PF_setattachment (void) /* ========= -VM_serverstate +VM_isserver float isserver() ========= @@ -2053,6 +2157,301 @@ void VM_clientstate(void) 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_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, 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) @@ -2088,11 +2487,12 @@ void VM_precache_pic(void) 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(""); } /* @@ -2241,7 +2641,7 @@ void VM_drawpic(void) 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); @@ -2302,16 +2702,81 @@ void VM_drawfill(void) PRVM_G_FLOAT(OFS_RETURN) = 1; } +/* +========= +VM_drawsetcliparea + +drawsetcliparea(float x, float y, float width, float height) +========= +*/ +void VM_drawsetcliparea(void) +{ + 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)); + + 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); + + 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_Files_Init(); + VM_Search_Init(); } void VM_Cmd_Reset(void) { - Mem_EmptyPool(VM_STRINGS_MEMPOOL); + //Mem_EmptyPool(VM_STRINGS_MEMPOOL); + Mem_FreePool(&VM_STRINGS_MEMPOOL); + VM_Search_Reset(); VM_Files_CloseAll(); } @@ -2361,10 +2826,59 @@ void VM_CL_Cmd_Reset(void) char *vm_m_extensions = ""; -// void setkeydest(float dest) +/* +========= +VM_M_setmousetarget + +setmousetarget(float target) +========= +*/ +void VM_M_setmousetarget(void) +{ + VM_SAFEPARMCOUNT(1, VM_M_setmousetarget); + + switch((int)PRVM_G_FLOAT(OFS_PARM0)) + { + case 1: + in_client_mouse = false; + break; + case 2: + in_client_mouse = true; + break; + default: + PRVM_ERROR("VM_M_setmousetarget: wrong destination %i !\n",PRVM_G_FLOAT(OFS_PARM0)); + } +} + +/* +========= +VM_M_getmousetarget + +float getmousetarget +========= +*/ +void VM_M_getmousetarget(void) +{ + VM_SAFEPARMCOUNT(0,VM_M_getmousetarget); + + if(in_client_mouse) + PRVM_G_FLOAT(OFS_RETURN) = 2; + else + PRVM_G_FLOAT(OFS_RETURN) = 1; +} + + + +/* +========= +VM_M_setkeydest + +setkeydest(float dest) +========= +*/ void VM_M_setkeydest(void) { - VM_SAFEPARMCOUNT(1,VM_M_SetKeyDest); + VM_SAFEPARMCOUNT(1,VM_M_setkeydest); switch((int)PRVM_G_FLOAT(OFS_PARM0)) { @@ -2381,16 +2895,20 @@ void VM_M_setkeydest(void) // key_dest = key_message // break; default: - PRVM_ERROR("VM_M_SetKeyDest: wrong destination %i !\n",prog->globals[OFS_PARM0]); + PRVM_ERROR("VM_M_setkeydest: wrong destination %i !\n",prog->globals[OFS_PARM0]); } - - return; } -// float getkeydest(void) +/* +========= +VM_M_getkeydest + +float getkeydest +========= +*/ 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) @@ -2410,6 +2928,160 @@ void VM_M_getkeydest(void) } } +/* +========= +VM_M_callfunction + + callfunction(...,string function_name) +========= +*/ +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->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); +} + prvm_builtin_t vm_m_builtins[] = { 0, // to be consistent with the old vm // common builtings (mostly) @@ -2470,20 +3142,28 @@ prvm_builtin_t vm_m_builtins[] = { VM_stov, VM_strzone, VM_strunzone, - VM_isserver, - VM_clientcount, - VM_clientstate, // 60 - VM_clcommand, VM_tokenize, + VM_argv, + VM_isserver, // 60 + VM_clientcount, + VM_clientstate, + VM_clcommand, VM_changelevel, - VM_localsound, // 64 - 0, - 0, - 0, - 0, - 0, - 0, // 70 - e10, // 80 + VM_localsound, + 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, //78 + 0,0,// 80 e10, // 90 e10, // 100 e100, // 200 @@ -2497,7 +3177,7 @@ prvm_builtin_t vm_m_builtins[] = { VM_WriteAngle, VM_WriteCoord, VM_WriteString, - VM_WriteEntity, + VM_WriteEntity, // 408 0, 0, // 410 e10, // 420 @@ -2511,16 +3191,25 @@ prvm_builtin_t vm_m_builtins[] = { 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 e10, // 500 + e100, // 600 // menu functions - + VM_M_setkeydest, + VM_M_getkeydest, + VM_M_setmousetarget, + VM_M_getmousetarget, + VM_M_callfunction, + VM_M_writetofile, + VM_M_isfunction, + VM_M_getresolution, + VM_M_keynumtostring // 609 }; const int vm_m_numbuiltins = sizeof(vm_m_builtins) / sizeof(prvm_builtin_t); @@ -2532,6 +3221,6 @@ void VM_M_Cmd_Init(void) void VM_M_Cmd_Reset(void) { - VM_Cmd_Init(); + //VM_Cmd_Init(); + VM_Cmd_Reset(); } -