X-Git-Url: http://de.git.xonotic.org/?a=blobdiff_plain;f=prvm_cmds.c;h=48184e519169af58496829b94490ea17e18193e2;hb=a7160f8d92d7278b9292087401847c18841852f4;hp=e306d917908b56cf06a93d154d02d187f3b6bb7b;hpb=78ac19b44fc4e0e415395d88c1258dc37dacd368;p=xonotic%2Fdarkplaces.git diff --git a/prvm_cmds.c b/prvm_cmds.c index e306d917..48184e51 100644 --- a/prvm_cmds.c +++ b/prvm_cmds.c @@ -4,239 +4,238 @@ // cause large (I think they will) parts are from pr_cmds the same copyright like in pr_cmds // also applies here +#include "quakedef.h" -/* -============================================================================ -common cmd list: -================= - - checkextension(string) - error(...[string]) - objerror(...[string) - print(...[strings]) - bprint(...[string]) - sprint(float clientnum,...[string]) - centerprint(...[string]) -vector normalize(vector) -float vlen(vector) -float vectoyaw(vector) -vector vectoangles(vector) -float random() - cmd(string) - float cvar (string) - cvar_set (string,string) - dprint(...[string]) -string ftos(float) -float fabs(float) -string vtos(vector) -string etos(entity) -float stof(...[string]) -entity spawn() - remove(entity e) -entity find(entity start, .string 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) - -entity findchainfloat(.string field, float match) -entity findchainentity(.string field, entity match) - -string precache_file(string) -string precache_sound (string sample) - coredump() - traceon() - traceoff() - eprint(entity e) -float rint(float) -float floor(float) -float ceil(float) -entity nextent(entity) -float sin(float) -float cos(float) -float sqrt(float) -vector randomvec() -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) -float pow(float a, float b) - copyentity(entity src, entity dst) -float fopen(string filename, float mode) - fclose(float fhandle) -string fgets(float fhandle) - fputs(float fhandle, string s) -float strlen(string s) -string strcat(string,string,...[string]) -string substring(string s, float start, float length) -vector stov(string s) -string 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) - 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) - -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) - WriteChar(float data, float dest, float desto) - WriteShort(float data, float dest, float desto) - WriteLong(float data, float dest, float desto) - WriteAngle(float data, float dest, float desto) - WriteCoord(float data, float dest, float desto) - WriteString(string data, float dest, float desto) - WriteEntity(entity data, float dest, float desto) - -Client & Menu : draw functions & video functions -=================================================== - -float iscachedpic(string pic) -string precache_pic(string pic) - freepic(string s) -float drawcharacter(vector position, float character, vector scale, vector rgb, float alpha, float flag) -float drawstring(vector position, string text, vector scale, vector rgb, float alpha, float flag) -float 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) - -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() - - 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 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 "prvm_cmds.h" +#include "libcurl.h" +#include -#include "quakedef.h" -#include "progdefs.h" -#include "progsvm.h" -#include "clprogdefs.h" -#include "mprogdefs.h" +#include "cl_collision.h" +#include "clvm_cmds.h" +#include "ft2.h" -#include "cl_video.h" +extern cvar_t prvm_backtraceforwarnings; -//============================================================================ -// nice helper macros +// LordHavoc: changed this to NOT use a return statement, so that it can be used in functions that must return a value +void VM_Warning(const char *fmt, ...) +{ + va_list argptr; + char msg[MAX_INPUTLINE]; + static double recursive = -1; -#ifndef VM_NOPARMCHECK -#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 + va_start(argptr,fmt); + dpvsnprintf(msg,sizeof(msg),fmt,argptr); + va_end(argptr); -#define VM_RETURN_EDICT(e) (((int *)prog->globals)[OFS_RETURN] = PRVM_EDICT_TO_PROG(e)) + Con_DPrint(msg); -#define VM_STRINGS_MEMPOOL vm_strings_mempool[PRVM_GetProgNr()] + // TODO: either add a cvar/cmd to control the state dumping or replace some of the calls with Con_Printf [9/13/2006 Black] + if(prvm_backtraceforwarnings.integer && recursive != realtime) // NOTE: this compares to the time, just in case if PRVM_PrintState causes a Host_Error and keeps recursive set + { + recursive = realtime; + PRVM_PrintState(); + recursive = -1; + } +} -#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 -#define VM_STRINGTEMP_LENGTH 4096 -static char vm_string_temp[VM_STRINGTEMP_BUFFERS][VM_STRINGTEMP_LENGTH]; -static int vm_string_tempindex = 0; - -// qc file handling -#define MAX_VMFILES 256 -#define MAX_PRVMFILES MAX_VMFILES * PRVM_MAXPROGS -#define VM_FILES ((qfile_t**)(vm_files + PRVM_GetProgNr() * MAX_VMFILES)) +// TODO DONE: move vm_files and vm_fssearchlist to prvm_prog_t struct +// TODO: move vm_files and vm_fssearchlist back [9/13/2006 Black] +// TODO: (move vm_files and vm_fssearchlist to prvm_prog_t struct again) [2007-01-23 LordHavoc] +// TODO: will this war ever end? [2007-01-23 LordHavoc] -qfile_t *vm_files[MAX_PRVMFILES]; +void VM_CheckEmptyString (const char *s) +{ + if (ISWHITESPACE(s[0])) + PRVM_ERROR ("%s: Bad string", PRVM_NAME); +} -// 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)) +void VM_GenerateFrameGroupBlend(framegroupblend_t *framegroupblend, const prvm_edict_t *ed) +{ + prvm_eval_t *val; + // self.frame is the interpolation target (new frame) + // self.frame1time is the animation base time for the interpolation target + // self.frame2 is the interpolation start (previous frame) + // self.frame2time is the animation base time for the interpolation start + // self.lerpfrac is the interpolation strength for self.frame2 + // self.lerpfrac3 is the interpolation strength for self.frame3 + // self.lerpfrac4 is the interpolation strength for self.frame4 + // pitch angle on a player model where the animator set up 5 sets of + // animations and the csqc simply lerps between sets) + if ((val = PRVM_EDICTFIELDVALUE(ed, prog->fieldoffsets.frame))) framegroupblend[0].frame = (int) val->_float; + if ((val = PRVM_EDICTFIELDVALUE(ed, prog->fieldoffsets.frame2))) framegroupblend[1].frame = (int) val->_float; + if ((val = PRVM_EDICTFIELDVALUE(ed, prog->fieldoffsets.frame3))) framegroupblend[2].frame = (int) val->_float; + if ((val = PRVM_EDICTFIELDVALUE(ed, prog->fieldoffsets.frame4))) framegroupblend[3].frame = (int) val->_float; + if ((val = PRVM_EDICTFIELDVALUE(ed, prog->fieldoffsets.frame1time))) framegroupblend[0].start = val->_float; + if ((val = PRVM_EDICTFIELDVALUE(ed, prog->fieldoffsets.frame2time))) framegroupblend[1].start = val->_float; + if ((val = PRVM_EDICTFIELDVALUE(ed, prog->fieldoffsets.frame3time))) framegroupblend[2].start = val->_float; + if ((val = PRVM_EDICTFIELDVALUE(ed, prog->fieldoffsets.frame4time))) framegroupblend[3].start = val->_float; + if ((val = PRVM_EDICTFIELDVALUE(ed, prog->fieldoffsets.lerpfrac))) framegroupblend[1].lerp = val->_float; + if ((val = PRVM_EDICTFIELDVALUE(ed, prog->fieldoffsets.lerpfrac3))) framegroupblend[2].lerp = val->_float; + if ((val = PRVM_EDICTFIELDVALUE(ed, prog->fieldoffsets.lerpfrac4))) framegroupblend[3].lerp = val->_float; + // assume that the (missing) lerpfrac1 is whatever remains after lerpfrac2+lerpfrac3+lerpfrac4 are summed + framegroupblend[0].lerp = 1 - framegroupblend[1].lerp - framegroupblend[2].lerp - framegroupblend[3].lerp; +} + +// LordHavoc: quite tempting to break apart this function to reuse the +// duplicated code, but I suspect it is better for performance +// this way +void VM_FrameBlendFromFrameGroupBlend(frameblend_t *frameblend, const framegroupblend_t *framegroupblend, const dp_model_t *model) +{ + int sub2, numframes, f, i, k; + int isfirstframegroup = true; + int nolerp; + double sublerp, lerp, d; + const animscene_t *scene; + const framegroupblend_t *g; + frameblend_t *blend = frameblend; + + memset(blend, 0, MAX_FRAMEBLENDS * sizeof(*blend)); + + if (!model || !model->surfmesh.isanimated) + { + blend[0].lerp = 1; + return; + } -fssearch_t *vm_fssearchlist[TOTAL_VMSEARCHES]; + nolerp = (model->type == mod_sprite) ? !r_lerpsprites.integer : !r_lerpmodels.integer; + numframes = model->numframes; + for (k = 0, g = framegroupblend;k < MAX_FRAMEGROUPBLENDS;k++, g++) + { + f = g->frame; + if ((unsigned int)f >= (unsigned int)numframes) + { + Con_DPrintf("VM_FrameBlendFromFrameGroupBlend: no such frame %d in model %s\n", f, model->name); + f = 0; + } + d = lerp = g->lerp; + if (lerp <= 0) + continue; + if (nolerp) + { + if (isfirstframegroup) + { + d = lerp = 1; + isfirstframegroup = false; + } + else + continue; + } + if (model->animscenes) + { + scene = model->animscenes + f; + f = scene->firstframe; + if (scene->framecount > 1) + { + // this code path is only used on .zym models and torches + sublerp = scene->framerate * (cl.time - g->start); + f = (int) floor(sublerp); + sublerp -= f; + sub2 = f + 1; + if (sublerp < (1.0 / 65536.0f)) + sublerp = 0; + if (sublerp > (65535.0f / 65536.0f)) + sublerp = 1; + if (nolerp) + sublerp = 0; + if (scene->loop) + { + f = (f % scene->framecount); + sub2 = (sub2 % scene->framecount); + } + f = bound(0, f, (scene->framecount - 1)) + scene->firstframe; + sub2 = bound(0, sub2, (scene->framecount - 1)) + scene->firstframe; + d = sublerp * lerp; + // two framelerps produced from one animation + if (d > 0) + { + for (i = 0;i < MAX_FRAMEBLENDS;i++) + { + if (blend[i].lerp <= 0 || blend[i].subframe == sub2) + { + blend[i].subframe = sub2; + blend[i].lerp += d; + break; + } + } + } + d = (1 - sublerp) * lerp; + } + } + if (d > 0) + { + for (i = 0;i < MAX_FRAMEBLENDS;i++) + { + if (blend[i].lerp <= 0 || blend[i].subframe == f) + { + blend[i].subframe = f; + blend[i].lerp += d; + break; + } + } + } + } +} -static char *VM_GetTempString(void) +void VM_UpdateEdictSkeleton(prvm_edict_t *ed, const dp_model_t *edmodel, const frameblend_t *frameblend) { - char *s; - s = vm_string_temp[vm_string_tempindex]; - vm_string_tempindex = (vm_string_tempindex + 1) % VM_STRINGTEMP_BUFFERS; - return s; + if (ed->priv.server->skeleton.model != edmodel) + { + VM_RemoveEdictSkeleton(ed); + ed->priv.server->skeleton.model = edmodel; + } + if (!ed->priv.server->skeleton.relativetransforms && ed->priv.server->skeleton.model && ed->priv.server->skeleton.model->num_bones) + ed->priv.server->skeleton.relativetransforms = Mem_Alloc(prog->progs_mempool, ed->priv.server->skeleton.model->num_bones * sizeof(matrix4x4_t)); + if (ed->priv.server->skeleton.relativetransforms) + { + int skeletonindex = -1; + skeleton_t *skeleton; + prvm_eval_t *val; + if ((val = PRVM_EDICTFIELDVALUE(ed, prog->fieldoffsets.skeletonindex))) skeletonindex = (int)val->_float - 1; + if (skeletonindex >= 0 && skeletonindex < MAX_EDICTS && (skeleton = prog->skeletons[skeletonindex]) && skeleton->model->num_bones == ed->priv.server->skeleton.model->num_bones) + { + // custom skeleton controlled by the game (FTE_CSQC_SKELETONOBJECTS) + memcpy(ed->priv.server->skeleton.relativetransforms, skeleton->relativetransforms, ed->priv.server->skeleton.model->num_bones * sizeof(matrix4x4_t)); + } + else + { + // generated skeleton from frame animation + int blendindex; + int bonenum; + int numbones = ed->priv.server->skeleton.model->num_bones; + const short *framebones6s; + float lerp; + float scale = ed->priv.server->skeleton.model->num_posescale; + matrix4x4_t *relativetransforms = ed->priv.server->skeleton.relativetransforms; + matrix4x4_t matrix; + memset(relativetransforms, 0, numbones * sizeof(matrix4x4_t)); + for (blendindex = 0;blendindex < MAX_FRAMEBLENDS && frameblend[blendindex].lerp > 0;blendindex++) + { + lerp = frameblend[blendindex].lerp; + framebones6s = ed->priv.server->skeleton.model->data_poses6s + 6 * frameblend[blendindex].subframe * numbones; + for (bonenum = 0;bonenum < numbones;bonenum++) + { + Matrix4x4_FromBonePose6s(&matrix, scale, framebones6s + 6 * bonenum); + Matrix4x4_Accumulate(&ed->priv.server->skeleton.relativetransforms[bonenum], &matrix, lerp); + } + } + } + } } -void VM_CheckEmptyString (char *s) +void VM_RemoveEdictSkeleton(prvm_edict_t *ed) { - if (s[0] <= ' ') - PRVM_ERROR ("%s: Bad string", PRVM_NAME); + if (ed->priv.server->skeleton.relativetransforms) + Mem_Free(ed->priv.server->skeleton.relativetransforms); + memset(&ed->priv.server->skeleton, 0, sizeof(ed->priv.server->skeleton)); } + + + //============================================================================ //BUILT-IN FUNCTIONS @@ -267,11 +266,11 @@ checkextension(extensionname) */ // kind of helper function -static qboolean checkextension(char *name) +static qboolean checkextension(const char *name) { int len; char *e, *start; - len = strlen(name); + len = (int)strlen(name); for (e = prog->extensionstring;*e;e++) { @@ -282,11 +281,8 @@ static qboolean checkextension(char *name) start = e; while (*e && *e != ' ') e++; - if (e - start == len) - if (!strncasecmp(start, name, len)) - { - return true; - } + if ((e - start) == len && !strncasecmp(start, name, len)) + return true; } return false; } @@ -314,14 +310,14 @@ void VM_error (void) 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); - if(prog->self) + Con_Printf("======%s ERROR in %s:\n%s\n", PRVM_NAME, PRVM_GetString(prog->xfunction->s_name), string); + if (prog->globaloffsets.self >= 0) { - ed = PRVM_G_EDICT(prog->self->ofs); - PRVM_ED_Print(ed); + ed = PRVM_PROG_TO_EDICT(PRVM_GLOBALFIELDVALUE(prog->globaloffsets.self)->edict); + PRVM_ED_Print(ed, NULL); } - PRVM_ERROR ("%s: Program error", PRVM_NAME); + PRVM_ERROR ("%s: Program error in function %s:\n%s\nTip: read above for entity information\n", PRVM_NAME, PRVM_GetString(prog->xfunction->s_name), string); } /* @@ -340,26 +336,27 @@ void VM_objerror (void) 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); - if(prog->self) + Con_Printf("======OBJECT ERROR======\n"); // , PRVM_NAME, PRVM_GetString(prog->xfunction->s_name), string); // or include them? FIXME + if (prog->globaloffsets.self >= 0) { - ed = PRVM_G_EDICT (prog->self->ofs); - PRVM_ED_Print(ed); + ed = PRVM_PROG_TO_EDICT(PRVM_GLOBALFIELDVALUE(prog->globaloffsets.self)->edict); + PRVM_ED_Print(ed, NULL); PRVM_ED_Free (ed); } else // objerror has to display the object fields -> else call - PRVM_ERROR ("VM_objecterror: self not defined !\n"); + PRVM_ERROR ("VM_objecterror: self not defined !"); + Con_Printf("%s OBJECT ERROR in %s:\n%s\nTip: read above for entity information\n", PRVM_NAME, PRVM_GetString(prog->xfunction->s_name), string); } /* ================= -VM_print (actually used only by client and menu) +VM_print print to console -print(string) +print(...[string]) ================= */ void VM_print (void) @@ -385,7 +382,7 @@ void VM_bprint (void) if(!sv.active) { - Con_Printf("VM_bprint: game is not server(%s) !\n", PRVM_NAME); + VM_Warning("VM_bprint: game is not server(%s) !\n", PRVM_NAME); return; } @@ -408,18 +405,23 @@ void VM_sprint (void) int clientnum; char string[VM_STRINGTEMP_LENGTH]; + VM_SAFEPARMCOUNTRANGE(1, 8, VM_sprint); + //find client for this entity - clientnum = PRVM_G_FLOAT(OFS_PARM0); + clientnum = (int)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 !\n", PRVM_NAME); + VM_Warning("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); + MSG_WriteChar(&client->netconnection->message,svc_print); + MSG_WriteString(&client->netconnection->message, string); } /* @@ -428,13 +430,14 @@ VM_centerprint single print to the screen -centerprint(clientent, value) +centerprint(value) ================= */ void VM_centerprint (void) { char string[VM_STRINGTEMP_LENGTH]; + VM_SAFEPARMCOUNTRANGE(1, 8, VM_centerprint); VM_VarString(0, string, sizeof(string)); SCR_CenterPrint(string); } @@ -450,24 +453,20 @@ void VM_normalize (void) { float *value1; vec3_t newvalue; - float new; + double f; VM_SAFEPARMCOUNT(1,VM_normalize); value1 = PRVM_G_VECTOR(OFS_PARM0); - new = value1[0] * value1[0] + value1[1] * value1[1] + value1[2]*value1[2]; - new = sqrt(new); - - if (new == 0) - newvalue[0] = newvalue[1] = newvalue[2] = 0; - else + f = VectorLength2(value1); + if (f) { - new = 1/new; - newvalue[0] = value1[0] * new; - newvalue[1] = value1[1] * new; - newvalue[2] = value1[2] * new; + f = 1.0 / sqrt(f); + VectorScale(value1, f, newvalue); } + else + VectorClear(newvalue); VectorCopy (newvalue, PRVM_G_VECTOR(OFS_RETURN)); } @@ -481,17 +480,8 @@ scalar vlen(vector) */ void VM_vlen (void) { - float *value1; - float new; - VM_SAFEPARMCOUNT(1,VM_vlen); - - value1 = PRVM_G_VECTOR(OFS_PARM0); - - new = value1[0] * value1[0] + value1[1] * value1[1] + value1[2]*value1[2]; - new = sqrt(new); - - PRVM_G_FLOAT(OFS_RETURN) = new; + PRVM_G_FLOAT(OFS_RETURN) = VectorLength(PRVM_G_VECTOR(OFS_PARM0)); } /* @@ -527,50 +517,14 @@ void VM_vectoyaw (void) ================= VM_vectoangles -vector vectoangles(vector) +vector vectoangles(vector[, vector]) ================= */ void VM_vectoangles (void) { - float *value1; - float forward; - float yaw, pitch; - - VM_SAFEPARMCOUNT(1,VM_vectoangles); - - value1 = PRVM_G_VECTOR(OFS_PARM0); - - if (value1[1] == 0 && value1[0] == 0) - { - yaw = 0; - if (value1[2] > 0) - pitch = 90; - else - pitch = 270; - } - else - { - // LordHavoc: optimized a bit - if (value1[0]) - { - yaw = (atan2(value1[1], value1[0]) * 180 / M_PI); - if (yaw < 0) - yaw += 360; - } - else if (value1[1] > 0) - yaw = 90; - else - yaw = 270; + VM_SAFEPARMCOUNTRANGE(1, 2,VM_vectoangles); - forward = sqrt(value1[0]*value1[0] + value1[1]*value1[1]); - pitch = (int) (atan2(value1[2], forward) * 180 / M_PI); - if (pitch < 0) - pitch += 360; - } - - PRVM_G_FLOAT(OFS_RETURN+0) = pitch; - PRVM_G_FLOAT(OFS_RETURN+1) = yaw; - PRVM_G_FLOAT(OFS_RETURN+2) = 0; + AnglesFromVectors(PRVM_G_VECTOR(OFS_RETURN), PRVM_G_VECTOR(OFS_PARM0), prog->argc >= 2 ? PRVM_G_VECTOR(OFS_PARM1) : NULL, true); } /* @@ -589,49 +543,6 @@ void VM_random (void) PRVM_G_FLOAT(OFS_RETURN) = lhrandom(0, 1); } -/* -================= -PF_sound - -Each entity can have eight independant sound sources, like voice, -weapon, feet, etc. - -Channel 0 is an auto-allocate channel, the others override anything -already running on that entity/channel pair. - -An attenuation of 0 will play full volume everywhere in the level. -Larger attenuations will drop off. - -================= -*/ -/* -void PF_sound (void) -{ - char *sample; - int channel; - edict_t *entity; - int volume; - float attenuation; - - entity = G_EDICT(OFS_PARM0); - channel = G_FLOAT(OFS_PARM1); - sample = G_STRING(OFS_PARM2); - volume = G_FLOAT(OFS_PARM3) * 255; - attenuation = G_FLOAT(OFS_PARM4); - - if (volume < 0 || volume > 255) - Host_Error ("SV_StartSound: volume = %i", volume); - - if (attenuation < 0 || attenuation > 4) - Host_Error ("SV_StartSound: attenuation = %f", attenuation); - - if (channel < 0 || channel > 7) - Host_Error ("SV_StartSound: channel = %i", channel); - - SV_StartSound (entity, channel, sample, volume, attenuation); -} -*/ - /* ========= VM_localsound @@ -641,7 +552,7 @@ localsound(string sample) */ void VM_localsound(void) { - char *s; + const char *s; VM_SAFEPARMCOUNT(1,VM_localsound); @@ -649,8 +560,8 @@ void VM_localsound(void) if(!S_LocalSound (s)) { - Con_Printf("VM_localsound: Failed to play %s for %s !\n", s, PRVM_NAME); PRVM_G_FLOAT(OFS_RETURN) = -4; + VM_Warning("VM_localsound: Failed to play %s for %s !\n", s, PRVM_NAME); return; } @@ -677,15 +588,23 @@ VM_localcmd Sends text over to the client's execution buffer -[localcmd (string) or] -cmd (string) +[localcmd (string, ...) or] +cmd (string, ...) ================= */ void VM_localcmd (void) { - VM_SAFEPARMCOUNT(1,VM_localcmd); + char string[VM_STRINGTEMP_LENGTH]; + VM_SAFEPARMCOUNTRANGE(1, 8, VM_localcmd); + VM_VarString(0, string, sizeof(string)); + Cbuf_AddText(string); +} - Cbuf_AddText(PRVM_G_STRING(OFS_PARM0)); +static qboolean PRVM_Cvar_ReadOk(const char *string) +{ + cvar_t *cvar; + cvar = Cvar_FindVar(string); + return ((cvar) && ((cvar->flags & CVAR_PRIVATE) == 0)); } /* @@ -697,52 +616,123 @@ float cvar (string) */ void VM_cvar (void) { - VM_SAFEPARMCOUNT(1,VM_cvar); - - PRVM_G_FLOAT(OFS_RETURN) = Cvar_VariableValue(PRVM_G_STRING(OFS_PARM0)); + char string[VM_STRINGTEMP_LENGTH]; + VM_SAFEPARMCOUNTRANGE(1,8,VM_cvar); + VM_VarString(0, string, sizeof(string)); + VM_CheckEmptyString(string); + PRVM_G_FLOAT(OFS_RETURN) = PRVM_Cvar_ReadOk(string) ? Cvar_VariableValue(string) : 0; } /* ================= -VM_str_cvar +VM_cvar -const string str_cvar (string) +float cvar_type (string) +float CVAR_TYPEFLAG_EXISTS = 1; +float CVAR_TYPEFLAG_SAVED = 2; +float CVAR_TYPEFLAG_PRIVATE = 4; +float CVAR_TYPEFLAG_ENGINE = 8; +float CVAR_TYPEFLAG_HASDESCRIPTION = 16; +float CVAR_TYPEFLAG_READONLY = 32; ================= */ -void VM_str_cvar(void) +void VM_cvar_type (void) { - char *out, *name; - const char *cvar_string; - VM_SAFEPARMCOUNT(1,VM_str_cvar); + char string[VM_STRINGTEMP_LENGTH]; + cvar_t *cvar; + int ret; - name = PRVM_G_STRING(OFS_PARM0); + VM_SAFEPARMCOUNTRANGE(1,8,VM_cvar); + VM_VarString(0, string, sizeof(string)); + VM_CheckEmptyString(string); + cvar = Cvar_FindVar(string); - if(!name) - PRVM_ERROR("VM_str_cvar: %s: null string\n", PRVM_NAME); - VM_CheckEmptyString(name); + if(!cvar) + { + PRVM_G_FLOAT(OFS_RETURN) = 0; + return; // CVAR_TYPE_NONE + } + + ret = 1; // CVAR_EXISTS + if(cvar->flags & CVAR_SAVE) + ret |= 2; // CVAR_TYPE_SAVED + if(cvar->flags & CVAR_PRIVATE) + ret |= 4; // CVAR_TYPE_PRIVATE + if(!(cvar->flags & CVAR_ALLOCATED)) + ret |= 8; // CVAR_TYPE_ENGINE + if(cvar->description != cvar_dummy_description) + ret |= 16; // CVAR_TYPE_HASDESCRIPTION + if(cvar->flags & CVAR_READONLY) + ret |= 32; // CVAR_TYPE_READONLY + + PRVM_G_FLOAT(OFS_RETURN) = ret; +} + +/* +================= +VM_cvar_string - out = VM_GetTempString(); +const string VM_cvar_string (string, ...) +================= +*/ +void VM_cvar_string(void) +{ + char string[VM_STRINGTEMP_LENGTH]; + VM_SAFEPARMCOUNTRANGE(1,8,VM_cvar_string); + VM_VarString(0, string, sizeof(string)); + VM_CheckEmptyString(string); + PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(PRVM_Cvar_ReadOk(string) ? Cvar_VariableString(string) : ""); +} - cvar_string = Cvar_VariableString(name); - strcpy(out, cvar_string); +/* +======================== +VM_cvar_defstring - PRVM_G_INT(OFS_RETURN) = PRVM_SetString(out); +const string VM_cvar_defstring (string, ...) +======================== +*/ +void VM_cvar_defstring (void) +{ + char string[VM_STRINGTEMP_LENGTH]; + VM_SAFEPARMCOUNTRANGE(1,8,VM_cvar_defstring); + VM_VarString(0, string, sizeof(string)); + VM_CheckEmptyString(string); + PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(Cvar_VariableDefString(string)); } +/* +======================== +VM_cvar_defstring + +const string VM_cvar_description (string, ...) +======================== +*/ +void VM_cvar_description (void) +{ + char string[VM_STRINGTEMP_LENGTH]; + VM_SAFEPARMCOUNTRANGE(1,8,VM_cvar_description); + VM_VarString(0, string, sizeof(string)); + VM_CheckEmptyString(string); + PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(Cvar_VariableDescription(string)); +} /* ================= VM_cvar_set -void cvar_set (string,string) +void cvar_set (string,string, ...) ================= */ void VM_cvar_set (void) { - VM_SAFEPARMCOUNT(2,VM_cvar_set); - - Cvar_Set(PRVM_G_STRING(OFS_PARM0), PRVM_G_STRING(OFS_PARM1)); + const char *name; + char string[VM_STRINGTEMP_LENGTH]; + VM_SAFEPARMCOUNTRANGE(2,8,VM_cvar_set); + VM_VarString(1, string, sizeof(string)); + name = PRVM_G_STRING(OFS_PARM0); + VM_CheckEmptyString(name); + Cvar_Set(name, string); } /* @@ -755,11 +745,13 @@ dprint(...[string]) void VM_dprint (void) { char string[VM_STRINGTEMP_LENGTH]; - if (developer.integer) - { - VM_VarString(0, string, sizeof(string)); - Con_Printf("%s: %s", PRVM_NAME, string); - } + VM_SAFEPARMCOUNTRANGE(1, 8, VM_dprint); + VM_VarString(0, string, sizeof(string)); +#if 1 + Con_DPrintf("%s", string); +#else + Con_DPrintf("%s: %s", PRVM_NAME, string); +#endif } /* @@ -773,18 +765,17 @@ string ftos(float) void VM_ftos (void) { float v; - char *s; + char s[128]; VM_SAFEPARMCOUNT(1, VM_ftos); v = PRVM_G_FLOAT(OFS_PARM0); - s = VM_GetTempString(); if ((float)((int)v) == v) - sprintf(s, "%i", (int)v); + dpsnprintf(s, sizeof(s), "%i", (int)v); else - sprintf(s, "%f", v); - PRVM_G_INT(OFS_RETURN) = PRVM_SetString(s); + dpsnprintf(s, sizeof(s), "%f", v); + PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(s); } /* @@ -815,13 +806,12 @@ string vtos(vector) void VM_vtos (void) { - char *s; + char s[512]; VM_SAFEPARMCOUNT(1,VM_vtos); - 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); + dpsnprintf (s, sizeof(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_SetTempString(s); } /* @@ -834,13 +824,12 @@ string etos(entity) void VM_etos (void) { - char *s; + char s[128]; VM_SAFEPARMCOUNT(1, VM_etos); - s = VM_GetTempString(); - sprintf (s, "entity %i", PRVM_G_EDICTNUM(OFS_PARM0)); - PRVM_G_INT(OFS_RETURN) = PRVM_SetString(s); + dpsnprintf (s, sizeof(s), "entity %i", PRVM_G_EDICTNUM(OFS_PARM0)); + PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(s); } /* @@ -853,6 +842,7 @@ float stof(...[string]) void VM_stof(void) { char string[VM_STRINGTEMP_LENGTH]; + VM_SAFEPARMCOUNTRANGE(1, 8, VM_stof); VM_VarString(0, string, sizeof(string)); PRVM_G_FLOAT(OFS_RETURN) = atof(string); } @@ -872,23 +862,82 @@ void VM_itof(void) /* ======================== -VM_itoe +VM_ftoe -intt ftoi(float num) +entity ftoe(float num) ======================== */ -void VM_ftoi(void) +void VM_ftoe(void) { int ent; - VM_SAFEPARMCOUNT(1, VM_ftoi); + VM_SAFEPARMCOUNT(1, VM_ftoe); - 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); + ent = (int)PRVM_G_FLOAT(OFS_PARM0); + if (ent < 0 || ent >= MAX_EDICTS || PRVM_PROG_TO_EDICT(ent)->priv.required->free) + ent = 0; // return world instead of a free or invalid entity PRVM_G_INT(OFS_RETURN) = ent; } +/* +======================== +VM_etof + +float etof(entity ent) +======================== +*/ +void VM_etof(void) +{ + VM_SAFEPARMCOUNT(1, VM_etof); + PRVM_G_FLOAT(OFS_RETURN) = PRVM_G_EDICTNUM(OFS_PARM0); +} + +/* +========= +VM_strftime + +string strftime(float uselocaltime, string[, string ...]) +========= +*/ +void VM_strftime(void) +{ + time_t t; +#if _MSC_VER >= 1400 + struct tm tm; + int tmresult; +#else + struct tm *tm; +#endif + char fmt[VM_STRINGTEMP_LENGTH]; + char result[VM_STRINGTEMP_LENGTH]; + VM_SAFEPARMCOUNTRANGE(2, 8, VM_strftime); + VM_VarString(1, fmt, sizeof(fmt)); + t = time(NULL); +#if _MSC_VER >= 1400 + if (PRVM_G_FLOAT(OFS_PARM0)) + tmresult = localtime_s(&tm, &t); + else + tmresult = gmtime_s(&tm, &t); + if (!tmresult) +#else + if (PRVM_G_FLOAT(OFS_PARM0)) + tm = localtime(&t); + else + tm = gmtime(&t); + if (!tm) +#endif + { + PRVM_G_INT(OFS_RETURN) = 0; + return; + } +#if _MSC_VER >= 1400 + strftime(result, sizeof(result), fmt, &tm); +#else + strftime(result, sizeof(result), fmt, tm); +#endif + PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(result); +} + /* ========= VM_spawn @@ -900,6 +949,7 @@ entity spawn() void VM_spawn (void) { prvm_edict_t *ed; + VM_SAFEPARMCOUNT(0, VM_spawn); prog->xfunction->builtinsprofile += 20; ed = PRVM_ED_Alloc(); VM_RETURN_EDICT(ed); @@ -921,11 +971,18 @@ void VM_remove (void) VM_SAFEPARMCOUNT(1, VM_remove); ed = PRVM_G_EDICT(OFS_PARM0); -// if (ed == prog->edicts) -// PRVM_ERROR ("remove: tried to remove world\n"); -// if (PRVM_NUM_FOR_EDICT(ed) <= sv.maxclients) -// Host_Error("remove: tried to remove a client\n"); - PRVM_ED_Free (ed); + if( PRVM_NUM_FOR_EDICT(ed) <= prog->reserved_edicts ) + { + if (developer.integer) + VM_Warning( "VM_remove: tried to remove the null entity or a reserved entity!\n" ); + } + else if( ed->priv.required->free ) + { + if (developer.integer) + VM_Warning( "VM_remove: tried to remove an already freed entity!\n" ); + } + else + PRVM_ED_Free (ed); } /* @@ -940,7 +997,7 @@ void VM_find (void) { int e; int f; - char *s, *t; + const char *s, *t; prvm_edict_t *ed; VM_SAFEPARMCOUNT(3,VM_find); @@ -949,22 +1006,19 @@ void VM_find (void) f = PRVM_G_INT(OFS_PARM1); s = PRVM_G_STRING(OFS_PARM2); - if (!s || !s[0]) - { - // return reserved edict 0 (could be used for whatever the prog wants) - VM_RETURN_EDICT(prog->edicts); - return; - } + // LordHavoc: apparently BloodMage does a find(world, weaponmodel, "") and + // expects it to find all the monsters, so we must be careful to support + // searching for "" for (e++ ; e < prog->num_edicts ; e++) { prog->xfunction->builtinsprofile++; ed = PRVM_EDICT_NUM(e); - if (ed->p.e->free) + if (ed->priv.required->free) continue; t = PRVM_E_STRING(ed,f); if (!t) - continue; + t = ""; if (!strcmp(t,s)) { VM_RETURN_EDICT(ed); @@ -1001,7 +1055,7 @@ void VM_findfloat (void) { prog->xfunction->builtinsprofile++; ed = PRVM_EDICT_NUM(e); - if (ed->p.e->free) + if (ed->priv.required->free) continue; if (PRVM_E_FLOAT(ed,f) == s) { @@ -1020,48 +1074,47 @@ VM_findchain entity findchain(.string field, string match) ========= */ -int PRVM_ED_FindFieldOffset(const char *field); // chained search for strings in entity fields // entity(.string field, string match) findchain = #402; void VM_findchain (void) { int i; int f; - int chain_of; - char *s, *t; + const char *s, *t; prvm_edict_t *ent, *chain; + int chainfield; - VM_SAFEPARMCOUNT(2,VM_findchain); + VM_SAFEPARMCOUNTRANGE(2,3,VM_findchain); - // is the same like !(prog->flag & PRVM_FE_CHAIN) - even if the operator precedence is another - if(!prog->flag & PRVM_FE_CHAIN) - PRVM_ERROR("VM_findchain: %s doesnt have a chain field !\n", PRVM_NAME); - - chain_of = PRVM_ED_FindFieldOffset ("chain"); + if(prog->argc == 3) + chainfield = PRVM_G_INT(OFS_PARM2); + else + chainfield = prog->fieldoffsets.chain; + if (chainfield < 0) + PRVM_ERROR("VM_findchain: %s doesnt have the specified chain field !", PRVM_NAME); chain = prog->edicts; f = PRVM_G_INT(OFS_PARM0); s = PRVM_G_STRING(OFS_PARM1); - if (!s || !s[0]) - { - VM_RETURN_EDICT(prog->edicts); - return; - } + + // LordHavoc: apparently BloodMage does a find(world, weaponmodel, "") and + // expects it to find all the monsters, so we must be careful to support + // searching for "" ent = PRVM_NEXT_EDICT(prog->edicts); for (i = 1;i < prog->num_edicts;i++, ent = PRVM_NEXT_EDICT(ent)) { prog->xfunction->builtinsprofile++; - if (ent->p.e->free) + if (ent->priv.required->free) continue; t = PRVM_E_STRING(ent,f); if (!t) - continue; + t = ""; if (strcmp(t,s)) continue; - PRVM_E_INT(ent,chain_of) = PRVM_NUM_FOR_EDICT(chain); + PRVM_EDICTFIELDVALUE(ent,chainfield)->edict = PRVM_NUM_FOR_EDICT(chain); chain = ent; } @@ -1082,16 +1135,18 @@ void VM_findchainfloat (void) { int i; int f; - int chain_of; float s; prvm_edict_t *ent, *chain; + int chainfield; - VM_SAFEPARMCOUNT(2, VM_findchainfloat); - - if(!prog->flag & PRVM_FE_CHAIN) - PRVM_ERROR("VM_findchainfloat: %s doesnt have a chain field !\n", PRVM_NAME); + VM_SAFEPARMCOUNTRANGE(2, 3, VM_findchainfloat); - chain_of = PRVM_ED_FindFieldOffset ("chain"); + if(prog->argc == 3) + chainfield = PRVM_G_INT(OFS_PARM2); + else + chainfield = prog->fieldoffsets.chain; + if (chainfield < 0) + PRVM_ERROR("VM_findchain: %s doesnt have the specified chain field !", PRVM_NAME); chain = (prvm_edict_t *)prog->edicts; @@ -1102,12 +1157,12 @@ void VM_findchainfloat (void) for (i = 1;i < prog->num_edicts;i++, ent = PRVM_NEXT_EDICT(ent)) { prog->xfunction->builtinsprofile++; - if (ent->p.e->free) + if (ent->priv.required->free) continue; if (PRVM_E_FLOAT(ent,f) != s) continue; - PRVM_E_INT(ent,chain_of) = PRVM_EDICT_TO_PROG(chain); + PRVM_EDICTFIELDVALUE(ent,chainfield)->edict = PRVM_EDICT_TO_PROG(chain); chain = ent; } @@ -1115,30 +1170,91 @@ void VM_findchainfloat (void) } /* -========= -VM_precache_file +======================== +VM_findflags -string precache_file(string) -========= +entity findflags(entity start, .float field, float match) +======================== */ -void VM_precache_file (void) -{ // precache_file is only used to copy files with qcc, it does nothing - VM_SAFEPARMCOUNT(1,VM_precache_file); +// LordHavoc: search for flags in float fields +void VM_findflags (void) +{ + int e; + int f; + int s; + prvm_edict_t *ed; - PRVM_G_INT(OFS_RETURN) = PRVM_G_INT(OFS_PARM0); + VM_SAFEPARMCOUNT(3, VM_findflags); + + + e = PRVM_G_EDICTNUM(OFS_PARM0); + f = PRVM_G_INT(OFS_PARM1); + s = (int)PRVM_G_FLOAT(OFS_PARM2); + + for (e++ ; e < prog->num_edicts ; e++) + { + prog->xfunction->builtinsprofile++; + ed = PRVM_EDICT_NUM(e); + if (ed->priv.required->free) + continue; + if (!PRVM_E_FLOAT(ed,f)) + continue; + if ((int)PRVM_E_FLOAT(ed,f) & s) + { + VM_RETURN_EDICT(ed); + return; + } + } + + VM_RETURN_EDICT(prog->edicts); } /* -========= -VM_preache_error +======================== +VM_findchainflags -used instead of the other VM_precache_* functions in the builtin list -========= +entity findchainflags(.float field, float match) +======================== */ - -void VM_precache_error (void) +// LordHavoc: chained search for flags in float fields +void VM_findchainflags (void) { - PRVM_ERROR ("PF_Precache_*: Precache can only be done in spawn functions"); + int i; + int f; + int s; + prvm_edict_t *ent, *chain; + int chainfield; + + VM_SAFEPARMCOUNTRANGE(2, 3, VM_findchainflags); + + if(prog->argc == 3) + chainfield = PRVM_G_INT(OFS_PARM2); + else + chainfield = prog->fieldoffsets.chain; + if (chainfield < 0) + PRVM_ERROR("VM_findchain: %s doesnt have the specified chain field !", PRVM_NAME); + + chain = (prvm_edict_t *)prog->edicts; + + f = PRVM_G_INT(OFS_PARM0); + s = (int)PRVM_G_FLOAT(OFS_PARM1); + + ent = PRVM_NEXT_EDICT(prog->edicts); + for (i = 1;i < prog->num_edicts;i++, ent = PRVM_NEXT_EDICT(ent)) + { + prog->xfunction->builtinsprofile++; + if (ent->priv.required->free) + continue; + if (!PRVM_E_FLOAT(ent,f)) + continue; + if (!((int)PRVM_E_FLOAT(ent,f) & s)) + continue; + + PRVM_EDICTFIELDVALUE(ent,chainfield)->edict = PRVM_EDICT_TO_PROG(chain); + chain = ent; + } + + VM_RETURN_EDICT(chain); } /* @@ -1150,16 +1266,35 @@ string precache_sound (string sample) */ 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); + //VM_CheckEmptyString(s); + + if(snd_initialized.integer && !S_PrecacheSound(s, true, true)) + { + VM_Warning("VM_precache_sound: Failed to load %s for %s\n", s, PRVM_NAME); + return; + } +} + +/* +================= +VM_precache_file - if(snd_initialized.integer && !S_PrecacheSound (s,true, true)) - Con_Printf("VM_precache_sound: Failed to load %s for %s\n", s, PRVM_NAME); +returns the same string as output + +does nothing, only used by qcc to build .pak archives +================= +*/ +void VM_precache_file (void) +{ + VM_SAFEPARMCOUNT(1,VM_precache_file); + // precache_file is only used to copy files with qcc, it does nothing + PRVM_G_INT(OFS_RETURN) = PRVM_G_INT(OFS_PARM0); } /* @@ -1205,7 +1340,7 @@ void VM_crash(void) { VM_SAFEPARMCOUNT(0, VM_crash); - PRVM_ERROR("Crash called by %s\n",PRVM_NAME); + PRVM_ERROR("Crash called by %s",PRVM_NAME); } /* @@ -1247,7 +1382,7 @@ void VM_eprint (void) { VM_SAFEPARMCOUNT(1,VM_eprint); - PRVM_ED_PrintNum (PRVM_G_EDICTNUM(OFS_PARM0)); + PRVM_ED_PrintNum (PRVM_G_EDICTNUM(OFS_PARM0), NULL); } /* @@ -1259,15 +1394,14 @@ float rint(float) */ void VM_rint (void) { - float f; - + float f; VM_SAFEPARMCOUNT(1,VM_rint); f = PRVM_G_FLOAT(OFS_PARM0); if (f > 0) - PRVM_G_FLOAT(OFS_RETURN) = (int)(f + 0.5); + PRVM_G_FLOAT(OFS_RETURN) = floor(f + 0.5); else - PRVM_G_FLOAT(OFS_RETURN) = (int)(f - 0.5); + PRVM_G_FLOAT(OFS_RETURN) = ceil(f - 0.5); } /* @@ -1311,6 +1445,8 @@ void VM_nextent (void) int i; prvm_edict_t *ent; + VM_SAFEPARMCOUNT(1, VM_nextent); + i = PRVM_G_EDICTNUM(OFS_PARM0); while (1) { @@ -1322,7 +1458,7 @@ void VM_nextent (void) return; } ent = PRVM_EDICT_NUM(i); - if (!ent->p.e->free) + if (!ent->priv.required->free) { VM_RETURN_EDICT(ent); return; @@ -1330,98 +1466,6 @@ void VM_nextent (void) } } -/* -=============================================================================== -MESSAGE WRITING - -used only for client and menu -severs uses VM_SV_... - -Write*(* data, float type, float to) - -=============================================================================== -*/ - -#define MSG_BROADCAST 0 // unreliable to all -#define MSG_ONE 1 // reliable to one (msg_entity) -#define MSG_ALL 2 // reliable to all -#define MSG_INIT 3 // write to the init string - -sizebuf_t *VM_WriteDest (void) -{ - int dest; - int destclient; - - if(!sv.active) - PRVM_ERROR("VM_WriteDest: game is not server (%s)\n", PRVM_NAME); - - dest = G_FLOAT(OFS_PARM1); - switch (dest) - { - case MSG_BROADCAST: - return &sv.datagram; - - case MSG_ONE: - destclient = (int) PRVM_G_FLOAT(OFS_PARM2); - 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; - - case MSG_ALL: - return &sv.reliable_datagram; - - case MSG_INIT: - return &sv.signon; - - default: - PRVM_ERROR ("WriteDest: bad destination"); - break; - } - - return NULL; -} - -void VM_WriteByte (void) -{ - MSG_WriteByte (VM_WriteDest(), PRVM_G_FLOAT(OFS_PARM0)); -} - -void VM_WriteChar (void) -{ - MSG_WriteChar (VM_WriteDest(), PRVM_G_FLOAT(OFS_PARM0)); -} - -void VM_WriteShort (void) -{ - MSG_WriteShort (VM_WriteDest(), PRVM_G_FLOAT(OFS_PARM0)); -} - -void VM_WriteLong (void) -{ - MSG_WriteLong (VM_WriteDest(), PRVM_G_FLOAT(OFS_PARM0)); -} - -void VM_WriteAngle (void) -{ - MSG_WriteAngle (VM_WriteDest(), PRVM_G_FLOAT(OFS_PARM0), sv.protocol); -} - -void VM_WriteCoord (void) -{ - MSG_WriteCoord (VM_WriteDest(), PRVM_G_FLOAT(OFS_PARM0), sv.protocol); -} - -void VM_WriteString (void) -{ - MSG_WriteString (VM_WriteDest(), PRVM_G_STRING(OFS_PARM0)); -} - -void VM_WriteEntity (void) -{ - MSG_WriteShort (VM_WriteDest(), PRVM_G_EDICTNUM(OFS_PARM0)); -} - //============================================================================= /* @@ -1434,13 +1478,11 @@ changelevel(string map) */ void VM_changelevel (void) { - char *s; - VM_SAFEPARMCOUNT(1, VM_changelevel); if(!sv.active) { - Con_Printf("VM_changelevel: game is not server (%s)\n", PRVM_NAME); + VM_Warning("VM_changelevel: game is not server (%s)\n", PRVM_NAME); return; } @@ -1449,8 +1491,7 @@ void VM_changelevel (void) return; svs.changelevel_issued = true; - s = G_STRING(OFS_PARM0); - Cbuf_AddText (va("changelevel %s\n",s)); + Cbuf_AddText (va("changelevel %s\n",PRVM_G_STRING(OFS_PARM0))); } /* @@ -1491,6 +1532,67 @@ void VM_sqrt (void) PRVM_G_FLOAT(OFS_RETURN) = sqrt(PRVM_G_FLOAT(OFS_PARM0)); } +/* +========= +VM_asin + +float asin(float) +========= +*/ +void VM_asin (void) +{ + VM_SAFEPARMCOUNT(1,VM_asin); + PRVM_G_FLOAT(OFS_RETURN) = asin(PRVM_G_FLOAT(OFS_PARM0)); +} + +/* +========= +VM_acos +float acos(float) +========= +*/ +void VM_acos (void) +{ + VM_SAFEPARMCOUNT(1,VM_acos); + PRVM_G_FLOAT(OFS_RETURN) = acos(PRVM_G_FLOAT(OFS_PARM0)); +} + +/* +========= +VM_atan +float atan(float) +========= +*/ +void VM_atan (void) +{ + VM_SAFEPARMCOUNT(1,VM_atan); + PRVM_G_FLOAT(OFS_RETURN) = atan(PRVM_G_FLOAT(OFS_PARM0)); +} + +/* +========= +VM_atan2 +float atan2(float,float) +========= +*/ +void VM_atan2 (void) +{ + VM_SAFEPARMCOUNT(2,VM_atan2); + PRVM_G_FLOAT(OFS_RETURN) = atan2(PRVM_G_FLOAT(OFS_PARM0), PRVM_G_FLOAT(OFS_PARM1)); +} + +/* +========= +VM_tan +float tan(float) +========= +*/ +void VM_tan (void) +{ + VM_SAFEPARMCOUNT(1,VM_tan); + PRVM_G_FLOAT(OFS_RETURN) = tan(PRVM_G_FLOAT(OFS_PARM0)); +} + /* ================= VM_randomvec @@ -1533,19 +1635,19 @@ void VM_randomvec (void) ========= VM_registercvar -float registercvar (string name, string value, float flags) +float registercvar (string name, string value[, float flags]) ========= */ void VM_registercvar (void) { - char *name, *value; + const char *name, *value; int flags; - VM_SAFEPARMCOUNT(3,VM_registercvar); + VM_SAFEPARMCOUNTRANGE(2, 3, VM_registercvar); name = PRVM_G_STRING(OFS_PARM0); value = PRVM_G_STRING(OFS_PARM1); - flags = PRVM_G_FLOAT(OFS_PARM2); + flags = prog->argc >= 3 ? (int)PRVM_G_FLOAT(OFS_PARM2) : 0; PRVM_G_FLOAT(OFS_RETURN) = 0; if(flags > CVAR_MAXFLAGSVAL) @@ -1558,15 +1660,16 @@ void VM_registercvar (void) // check for overlap with a command if (Cmd_Exists (name)) { - Con_Printf("VM_registercvar: %s is a command\n", name); + VM_Warning("VM_registercvar: %s is a command\n", name); return; } - Cvar_Get(name, value, flags); + Cvar_Get(name, value, flags, NULL); PRVM_G_FLOAT(OFS_RETURN) = 1; // success } + /* ================= VM_min @@ -1578,20 +1681,19 @@ float min(float a, float b, ...[float]) */ void VM_min (void) { + VM_SAFEPARMCOUNTRANGE(2, 8, VM_min); // LordHavoc: 3+ argument enhancement suggested by FrikaC - if (prog->argc == 2) - PRVM_G_FLOAT(OFS_RETURN) = min(PRVM_G_FLOAT(OFS_PARM0), PRVM_G_FLOAT(OFS_PARM1)); - else if (prog->argc >= 3) + if (prog->argc >= 3) { int i; float f = PRVM_G_FLOAT(OFS_PARM0); for (i = 1;i < prog->argc;i++) - if (PRVM_G_FLOAT((OFS_PARM0+i*3)) < f) + if (f > PRVM_G_FLOAT((OFS_PARM0+i*3))) f = PRVM_G_FLOAT((OFS_PARM0+i*3)); PRVM_G_FLOAT(OFS_RETURN) = f; } else - PRVM_ERROR("VM_min: %s must supply at least 2 floats\n", PRVM_NAME); + PRVM_G_FLOAT(OFS_RETURN) = min(PRVM_G_FLOAT(OFS_PARM0), PRVM_G_FLOAT(OFS_PARM1)); } /* @@ -1605,20 +1707,19 @@ float max(float a, float b, ...[float]) */ void VM_max (void) { + VM_SAFEPARMCOUNTRANGE(2, 8, VM_max); // LordHavoc: 3+ argument enhancement suggested by FrikaC - if (prog->argc == 2) - PRVM_G_FLOAT(OFS_RETURN) = max(PRVM_G_FLOAT(OFS_PARM0), PRVM_G_FLOAT(OFS_PARM1)); - else if (prog->argc >= 3) + if (prog->argc >= 3) { int i; float f = PRVM_G_FLOAT(OFS_PARM0); for (i = 1;i < prog->argc;i++) - if (PRVM_G_FLOAT((OFS_PARM0+i*3)) > f) + if (f < PRVM_G_FLOAT((OFS_PARM0+i*3))) f = PRVM_G_FLOAT((OFS_PARM0+i*3)); PRVM_G_FLOAT(OFS_RETURN) = f; } else - PRVM_ERROR("VM_max: %s must supply at least 2 floats\n", PRVM_NAME); + PRVM_G_FLOAT(OFS_RETURN) = max(PRVM_G_FLOAT(OFS_PARM0), PRVM_G_FLOAT(OFS_PARM1)); } /* @@ -1651,75 +1752,43 @@ void VM_pow (void) PRVM_G_FLOAT(OFS_RETURN) = pow(PRVM_G_FLOAT(OFS_PARM0), PRVM_G_FLOAT(OFS_PARM1)); } -/* -================= -VM_copyentity - -copies data from one entity to another - -copyentity(entity src, entity dst) -================= -*/ -void VM_copyentity (void) +void VM_log (void) { - prvm_edict_t *in, *out; - VM_SAFEPARMCOUNT(2,VM_copyentity); - in = PRVM_G_EDICT(OFS_PARM0); - out = PRVM_G_EDICT(OFS_PARM1); - memcpy(out->v, in->v, prog->progs->entityfields * 4); + VM_SAFEPARMCOUNT(1,VM_log); + PRVM_G_FLOAT(OFS_RETURN) = log(PRVM_G_FLOAT(OFS_PARM0)); } -/* -================= -VM_setcolor - -sets the color of a client and broadcasts the update to all connected clients - -setcolor(clientent, value) -================= -*/ -/*void PF_setcolor (void) -{ - client_t *client; - int entnum, i; - eval_t *val; - - entnum = G_EDICTNUM(OFS_PARM0); - i = G_FLOAT(OFS_PARM1); - - if (entnum < 1 || entnum > svs.maxclients || !svs.clients[entnum-1].active) - { - Con_Print("tried to setcolor a non-client\n"); - return; - } - - client = svs.clients + entnum-1; - if ((val = GETEDICTFIELDVALUE(client->edict, eval_clientcolors))) - val->_float = i; - client->colors = i; - client->old_colors = i; - client->edict->v->team = (i & 15) + 1; - - MSG_WriteByte (&sv.reliable_datagram, svc_updatecolors); - MSG_WriteByte (&sv.reliable_datagram, entnum - 1); - MSG_WriteByte (&sv.reliable_datagram, i); -}*/ - void VM_Files_Init(void) { - memset(VM_FILES, 0, sizeof(qfile_t*[MAX_VMFILES])); + int i; + for (i = 0;i < PRVM_MAX_OPENFILES;i++) + prog->openfiles[i] = NULL; } void VM_Files_CloseAll(void) { int i; - for (i = 0;i < MAX_VMFILES;i++) + for (i = 0;i < PRVM_MAX_OPENFILES;i++) + { + if (prog->openfiles[i]) + FS_Close(prog->openfiles[i]); + prog->openfiles[i] = NULL; + } +} + +static qfile_t *VM_GetFileHandle( int index ) +{ + if (index < 0 || index >= PRVM_MAX_OPENFILES) + { + Con_Printf("VM_GetFileHandle: invalid file handle %i used in %s\n", index, PRVM_NAME); + return NULL; + } + if (prog->openfiles[index] == NULL) { - if (VM_FILES[i]) - FS_Close(VM_FILES[i]); - //VM_FILES[i] = NULL; + Con_Printf("VM_GetFileHandle: no such file handle %i (or file has been closed) in %s\n", index, PRVM_NAME); + return NULL; } - memset(VM_FILES,0,sizeof(qfile_t*[MAX_VMFILES])); // this should be faster (is it ?) + return prog->openfiles[index]; } /* @@ -1735,55 +1804,56 @@ float fopen(string filename, float mode) void VM_fopen(void) { int filenum, mode; - char *modestring, *filename; + const char *modestring, *filename; VM_SAFEPARMCOUNT(2,VM_fopen); - for (filenum = 0;filenum < MAX_VMFILES;filenum++) - if (VM_FILES[filenum] == NULL) + for (filenum = 0;filenum < PRVM_MAX_OPENFILES;filenum++) + if (prog->openfiles[filenum] == NULL) break; - if (filenum >= MAX_VMFILES) + if (filenum >= PRVM_MAX_OPENFILES) { - Con_Printf("VM_fopen: %s ran out of file handles (%i)\n", PRVM_NAME, MAX_VMFILES); PRVM_G_FLOAT(OFS_RETURN) = -2; + VM_Warning("VM_fopen: %s ran out of file handles (%i)\n", PRVM_NAME, PRVM_MAX_OPENFILES); return; } - mode = PRVM_G_FLOAT(OFS_PARM1); + filename = PRVM_G_STRING(OFS_PARM0); + mode = (int)PRVM_G_FLOAT(OFS_PARM1); switch(mode) { case 0: // FILE_READ modestring = "rb"; + prog->openfiles[filenum] = FS_OpenVirtualFile(va("data/%s", filename), false); + if (prog->openfiles[filenum] == NULL) + prog->openfiles[filenum] = FS_OpenVirtualFile(va("%s", filename), false); break; case 1: // FILE_APPEND - modestring = "ab"; + modestring = "a"; + prog->openfiles[filenum] = FS_OpenRealFile(va("data/%s", filename), modestring, false); break; case 2: // FILE_WRITE - modestring = "wb"; + modestring = "w"; + prog->openfiles[filenum] = FS_OpenRealFile(va("data/%s", filename), modestring, false); break; default: - 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; + VM_Warning("VM_fopen: %s: no such mode %i (valid: 0 = read, 1 = append, 2 = write)\n", PRVM_NAME, mode); return; } - 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_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, false); - if (VM_FILES[filenum] == NULL && mode == 0) - VM_FILES[filenum] = FS_Open(va("%s", filename), modestring, false, false); - if (VM_FILES[filenum] == NULL) + if (prog->openfiles[filenum] == NULL) + { PRVM_G_FLOAT(OFS_RETURN) = -1; + if (developer_extra.integer) + VM_Warning("VM_fopen: %s: %s mode %s failed\n", PRVM_NAME, filename, modestring); + } else + { PRVM_G_FLOAT(OFS_RETURN) = filenum; + if (developer_extra.integer) + Con_DPrintf("VM_fopen: %s: %s mode %s opened as #%i\n", PRVM_NAME, filename, modestring, filenum); + prog->openfiles_origin[filenum] = PRVM_AllocationOrigin(); + } } /* @@ -1800,19 +1870,23 @@ void VM_fclose(void) VM_SAFEPARMCOUNT(1,VM_fclose); - filenum = PRVM_G_FLOAT(OFS_PARM0); - if (filenum < 0 || filenum >= MAX_VMFILES) + filenum = (int)PRVM_G_FLOAT(OFS_PARM0); + if (filenum < 0 || filenum >= PRVM_MAX_OPENFILES) { - Con_Printf("VM_fclose: invalid file handle %i used in %s\n", filenum, PRVM_NAME); + VM_Warning("VM_fclose: invalid file handle %i used in %s\n", filenum, PRVM_NAME); return; } - if (VM_FILES[filenum] == NULL) + if (prog->openfiles[filenum] == NULL) { - Con_Printf("VM_fclose: no such file handle %i (or file has been closed) in %s\n", filenum, PRVM_NAME); + VM_Warning("VM_fclose: no such file handle %i (or file has been closed) in %s\n", filenum, PRVM_NAME); return; } - FS_Close(VM_FILES[filenum]); - VM_FILES[filenum] = NULL; + FS_Close(prog->openfiles[filenum]); + prog->openfiles[filenum] = NULL; + if(prog->openfiles_origin[filenum]) + PRVM_Free((char *)prog->openfiles_origin[filenum]); + if (developer_extra.integer) + Con_DPrintf("VM_fclose: %s: #%i closed\n", PRVM_NAME, filenum); } /* @@ -1826,26 +1900,29 @@ string fgets(float fhandle) void VM_fgets(void) { int c, end; - static char string[VM_STRINGTEMP_LENGTH]; + char string[VM_STRINGTEMP_LENGTH]; int filenum; VM_SAFEPARMCOUNT(1,VM_fgets); - filenum = PRVM_G_FLOAT(OFS_PARM0); - if (filenum < 0 || filenum >= MAX_VMFILES) + // set the return value regardless of any possible errors + PRVM_G_INT(OFS_RETURN) = OFS_NULL; + + filenum = (int)PRVM_G_FLOAT(OFS_PARM0); + if (filenum < 0 || filenum >= PRVM_MAX_OPENFILES) { - Con_Printf("VM_fgets: invalid file handle %i used in %s\n", filenum, PRVM_NAME); + VM_Warning("VM_fgets: invalid file handle %i used in %s\n", filenum, PRVM_NAME); return; } - if (VM_FILES[filenum] == NULL) + if (prog->openfiles[filenum] == NULL) { - Con_Printf("VM_fgets: no such file handle %i (or file has been closed) in %s\n", filenum, PRVM_NAME); + VM_Warning("VM_fgets: no such file handle %i (or file has been closed) in %s\n", filenum, PRVM_NAME); return; } end = 0; for (;;) { - c = FS_Getc(VM_FILES[filenum]); + c = FS_Getc(prog->openfiles[filenum]); if (c == '\r' || c == '\n' || c < 0) break; if (end < VM_STRINGTEMP_LENGTH - 1) @@ -1855,16 +1932,14 @@ void VM_fgets(void) // remove \n following \r if (c == '\r') { - c = FS_Getc(VM_FILES[filenum]); + c = FS_Getc(prog->openfiles[filenum]); if (c != '\n') - FS_UnGetc(VM_FILES[filenum], (unsigned char)c); + FS_UnGetc(prog->openfiles[filenum], (unsigned char)c); } - if (developer.integer >= 3) - Con_Printf("fgets: %s: %s\n", PRVM_NAME, string); + if (developer_extra.integer) + Con_DPrintf("fgets: %s: %s\n", PRVM_NAME, string); if (c >= 0 || end) - PRVM_G_INT(OFS_RETURN) = PRVM_SetString(string); - else - PRVM_G_INT(OFS_RETURN) = 0; + PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(string); } /* @@ -1883,1452 +1958,3666 @@ void VM_fputs(void) VM_SAFEPARMCOUNT(2,VM_fputs); - filenum = PRVM_G_FLOAT(OFS_PARM0); - if (filenum < 0 || filenum >= MAX_VMFILES) + filenum = (int)PRVM_G_FLOAT(OFS_PARM0); + if (filenum < 0 || filenum >= PRVM_MAX_OPENFILES) { - Con_Printf("VM_fputs: invalid file handle %i used in %s\n", filenum, PRVM_NAME); + VM_Warning("VM_fputs: invalid file handle %i used in %s\n", filenum, PRVM_NAME); return; } - if (VM_FILES[filenum] == NULL) + if (prog->openfiles[filenum] == NULL) { - Con_Printf("VM_fputs: no such file handle %i (or file has been closed) in %s\n", filenum, PRVM_NAME); + VM_Warning("VM_fputs: no such file handle %i (or file has been closed) in %s\n", filenum, PRVM_NAME); return; } VM_VarString(1, string, sizeof(string)); - if ((stringlength = strlen(string))) - FS_Write(VM_FILES[filenum], string, stringlength); - if (developer.integer) - Con_Printf("fputs: %s: %s\n", PRVM_NAME, string); + if ((stringlength = (int)strlen(string))) + FS_Write(prog->openfiles[filenum], string, stringlength); + if (developer_extra.integer) + Con_DPrintf("fputs: %s: %s\n", PRVM_NAME, string); } /* ========= -VM_strlen +VM_writetofile -float strlen(string s) + writetofile(float fhandle, entity ent) ========= */ -//float(string s) strlen = #114; // returns how many characters are in a string -void VM_strlen(void) +void VM_writetofile(void) { - char *s; + prvm_edict_t * ent; + qfile_t *file; - VM_SAFEPARMCOUNT(1,VM_strlen); + VM_SAFEPARMCOUNT(2, VM_writetofile); - s = PRVM_G_STRING(OFS_PARM0); - if (s) - PRVM_G_FLOAT(OFS_RETURN) = strlen(s); - else - PRVM_G_FLOAT(OFS_RETURN) = 0; + file = VM_GetFileHandle( (int)PRVM_G_FLOAT(OFS_PARM0) ); + if( !file ) + { + VM_Warning("VM_writetofile: invalid or closed file handle\n"); + return; + } + + ent = PRVM_G_EDICT(OFS_PARM1); + if(ent->priv.required->free) + { + VM_Warning("VM_writetofile: %s: entity %i is free !\n", PRVM_NAME, PRVM_NUM_FOR_EDICT(ent)); + return; + } + + PRVM_ED_Write (file, ent); } +// KrimZon - DP_QC_ENTITYDATA /* ========= -VM_strcat +VM_numentityfields -string strcat(string,string,...[string]) +float() numentityfields +Return the number of entity fields - NOT offsets ========= */ -//string(string s1, string s2) strcat = #115; -// concatenates two strings (for example "abc", "def" would return "abcdef") -// and returns as a tempstring -void VM_strcat(void) +void VM_numentityfields(void) { - char *s; - - 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_FLOAT(OFS_RETURN) = prog->progs->numfielddefs; } +// KrimZon - DP_QC_ENTITYDATA /* ========= -VM_substring +VM_entityfieldname -string substring(string s, float start, float length) +string(float fieldnum) entityfieldname +Return name of the specified field as a string, or empty if the field is invalid (warning) ========= */ -// string(string s, float start, float length) substring = #116; -// returns a section of a string as a tempstring -void VM_substring(void) +void VM_entityfieldname(void) { - int i, start, length; - char *s, *string; - - VM_SAFEPARMCOUNT(3,VM_substring); - - string = VM_GetTempString(); - s = PRVM_G_STRING(OFS_PARM0); - start = PRVM_G_FLOAT(OFS_PARM1); - length = PRVM_G_FLOAT(OFS_PARM2); - if (!s) - s = ""; - for (i = 0;i < start && *s;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); -} - -/* -========= -VM_stov - -vector stov(string s) -========= -*/ -//vector(string s) stov = #117; // returns vector value from a string -void VM_stov(void) -{ - char string[VM_STRINGTEMP_LENGTH]; - - VM_SAFEPARMCOUNT(1,VM_stov); - - VM_VarString(0, string, sizeof(string)); - Math_atov(string, PRVM_G_VECTOR(OFS_RETURN)); -} - -/* -========= -VM_strzone - -string strzone(string s) -========= -*/ -//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; - - VM_SAFEPARMCOUNT(1,VM_strzone); - - in = PRVM_G_STRING(OFS_PARM0); - out = Mem_Alloc(VM_STRINGS_MEMPOOL, strlen(in) + 1); - strcpy(out, in); - PRVM_G_INT(OFS_RETURN) = PRVM_SetString(out); + ddef_t *d; + int i = (int)PRVM_G_FLOAT(OFS_PARM0); + + if (i < 0 || i >= prog->progs->numfielddefs) + { + VM_Warning("VM_entityfieldname: %s: field index out of bounds\n", PRVM_NAME); + PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(""); + return; + } + + d = &prog->fielddefs[i]; + PRVM_G_INT(OFS_RETURN) = d->s_name; // presuming that s_name points to a string already } +// KrimZon - DP_QC_ENTITYDATA /* ========= -VM_strunzone +VM_entityfieldtype -strunzone(string s) +float(float fieldnum) entityfieldtype ========= */ -//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) +void VM_entityfieldtype(void) { - char *str; - VM_SAFEPARMCOUNT(1,VM_strunzone); - - str = PRVM_G_STRING(OFS_PARM0); - if( !str ) - PRVM_ERROR( "VM_strunzone: s%: Null string passed!", PRVM_NAME ); - 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 ); + ddef_t *d; + int i = (int)PRVM_G_FLOAT(OFS_PARM0); + + if (i < 0 || i >= prog->progs->numfielddefs) + { + VM_Warning("VM_entityfieldtype: %s: field index out of bounds\n", PRVM_NAME); + PRVM_G_FLOAT(OFS_RETURN) = -1.0; + return; + } + + d = &prog->fielddefs[i]; + PRVM_G_FLOAT(OFS_RETURN) = (float)d->type; } +// KrimZon - DP_QC_ENTITYDATA /* ========= -VM_command (used by client and menu) +VM_getentityfieldstring -clientcommand(float client, string s) (for client and menu) +string(float fieldnum, entity ent) getentityfieldstring ========= */ -//void(entity e, string s) clientcommand = #440; // executes a command string as if it came from the specified client -//this function originally written by KrimZon, made shorter by LordHavoc -void VM_clcommand (void) +void VM_getentityfieldstring(void) { - client_t *temp_client; - int i; - - VM_SAFEPARMCOUNT(2,VM_clcommand); - - i = PRVM_G_FLOAT(OFS_PARM0); - if (!sv.active || i < 0 || i >= svs.maxclients || !svs.clients[i].active) + // put the data into a string + ddef_t *d; + int type, j; + int *v; + prvm_edict_t * ent; + int i = (int)PRVM_G_FLOAT(OFS_PARM0); + + if (i < 0 || i >= prog->progs->numfielddefs) { - Con_Printf("VM_clientcommand: %s: invalid client/server is not active !\n", PRVM_NAME); + VM_Warning("VM_entityfielddata: %s: field index out of bounds\n", PRVM_NAME); + PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(""); return; } - - temp_client = host_client; - host_client = svs.clients + i; - Cmd_ExecuteString (PRVM_G_STRING(OFS_PARM1), src_client); - host_client = temp_client; + + d = &prog->fielddefs[i]; + + // get the entity + ent = PRVM_G_EDICT(OFS_PARM1); + if(ent->priv.required->free) + { + PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(""); + VM_Warning("VM_entityfielddata: %s: entity %i is free !\n", PRVM_NAME, PRVM_NUM_FOR_EDICT(ent)); + return; + } + v = (int *)((char *)ent->fields.vp + d->ofs*4); + + // if it's 0 or blank, return an empty string + type = d->type & ~DEF_SAVEGLOBAL; + for (j=0 ; jtype, (prvm_eval_t *)v)); } - +// KrimZon - DP_QC_ENTITYDATA /* ========= -VM_tokenize +VM_putentityfieldstring -float tokenize(string s) +float(float fieldnum, entity ent, string s) putentityfieldstring ========= */ -//float(string s) tokenize = #441; -// takes apart a string into individal words (access them with argv), returns how many -// this function originally written by KrimZon, made shorter by LordHavoc -static char **tokens = NULL; -static int max_tokens, num_tokens = 0; -void VM_tokenize (void) +void VM_putentityfieldstring(void) { - const char *p; - char *str; - - VM_SAFEPARMCOUNT(1,VM_tokenize); - - str = PRVM_G_STRING(OFS_PARM0); + ddef_t *d; + prvm_edict_t * ent; + int i = (int)PRVM_G_FLOAT(OFS_PARM0); - if (tokens != NULL) + if (i < 0 || i >= prog->progs->numfielddefs) { - int i; - for (i=0;ifielddefs[i]; - for (p = str;COM_ParseToken(&p, false) && num_tokens < max_tokens;num_tokens++) + // get the entity + ent = PRVM_G_EDICT(OFS_PARM1); + if(ent->priv.required->free) { - tokens[num_tokens] = Z_Malloc(strlen(com_token) + 1); - strcpy(tokens[num_tokens], com_token); + VM_Warning("VM_entityfielddata: %s: entity %i is free !\n", PRVM_NAME, PRVM_NUM_FOR_EDICT(ent)); + PRVM_G_FLOAT(OFS_RETURN) = 0.0f; + return; } - PRVM_G_FLOAT(OFS_RETURN) = num_tokens; + // parse the string into the value + PRVM_G_FLOAT(OFS_RETURN) = ( PRVM_ED_ParseEpair(ent, d, PRVM_G_STRING(OFS_PARM2), false) ) ? 1.0f : 0.0f; } /* ========= -VM_argv +VM_strlen -string argv(float n) +float strlen(string s) ========= */ -//string(float n) argv = #442; -// returns a word from the tokenized string (returns nothing for an invalid index) -// this function originally written by KrimZon, made shorter by LordHavoc -void VM_argv (void) +//float(string s) strlen = #114; // returns how many characters are in a string +void VM_strlen(void) { - int token_num; - - VM_SAFEPARMCOUNT(1,VM_argv); + VM_SAFEPARMCOUNT(1,VM_strlen); - 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]); - else - PRVM_G_INT(OFS_RETURN) = PRVM_SetString(""); + //PRVM_G_FLOAT(OFS_RETURN) = strlen(PRVM_G_STRING(OFS_PARM0)); + PRVM_G_FLOAT(OFS_RETURN) = u8_strlen(PRVM_G_STRING(OFS_PARM0)); } -/* -//void(entity e, entity tagentity, string tagname) setattachment = #443; // attachs e to a tag on tagentity (note: use "" to attach to entity origin/angles instead of a tag) -void PF_setattachment (void) -{ - edict_t *e = G_EDICT(OFS_PARM0); - edict_t *tagentity = G_EDICT(OFS_PARM1); - char *tagname = G_STRING(OFS_PARM2); - eval_t *v; - int i, modelindex; - model_t *model; - - if (tagentity == NULL) - tagentity = sv.edicts; - - v = GETEDICTFIELDVALUE(e, eval_tag_entity); - if (v) - v->edict = EDICT_TO_PROG(tagentity); - - v = GETEDICTFIELDVALUE(e, eval_tag_index); - if (v) - v->_float = 0; - if (tagentity != NULL && tagentity != sv.edicts && tagname && tagname[0]) - { - modelindex = (int)tagentity->v->modelindex; - if (modelindex >= 0 && modelindex < MAX_MODELS) - { - model = sv.models[modelindex]; - if (model->data_overridetagnamesforskin && (unsigned int)tagentity->v->skin < (unsigned int)model->numskins && model->data_overridetagnamesforskin[(unsigned int)tagentity->v->skin].num_overridetagnames) - 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)) - 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); - } - else - Con_DPrintf("setattachment(edict %i, edict %i, string \"%s\"): tried to find tag named \"%s\" on entity %i but it has no model\n", NUM_FOR_EDICT(e), NUM_FOR_EDICT(tagentity), tagname, tagname, NUM_FOR_EDICT(tagentity)); - } -}*/ - +// DRESK - Decolorized String /* ========= -VM_isserver +VM_strdecolorize -float isserver() +string strdecolorize(string s) ========= */ -void VM_isserver(void) +// string (string s) strdecolorize = #472; // returns the passed in string with color codes stripped +void VM_strdecolorize(void) { - VM_SAFEPARMCOUNT(0,VM_serverstate); + char szNewString[VM_STRINGTEMP_LENGTH]; + const char *szString; - PRVM_G_FLOAT(OFS_RETURN) = sv.active; + // Prepare Strings + VM_SAFEPARMCOUNT(1,VM_strdecolorize); + szString = PRVM_G_STRING(OFS_PARM0); + COM_StringDecolorize(szString, 0, szNewString, sizeof(szNewString), TRUE); + PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(szNewString); } +// DRESK - String Length (not counting color codes) /* ========= -VM_clientcount +VM_strlennocol -float clientcount() +float strlennocol(string s) ========= */ -void VM_clientcount(void) +// float(string s) strlennocol = #471; // returns how many characters are in a string not including color codes +// For example, ^2Dresk returns a length of 5 +void VM_strlennocol(void) { - VM_SAFEPARMCOUNT(0,VM_clientcount); + const char *szString; + int nCnt; - PRVM_G_FLOAT(OFS_RETURN) = svs.maxclients; -} + VM_SAFEPARMCOUNT(1,VM_strlennocol); -/* -========= -VM_clientstate + szString = PRVM_G_STRING(OFS_PARM0); -float clientstate() -========= -*/ -void VM_clientstate(void) -{ - VM_SAFEPARMCOUNT(0,VM_clientstate); + //nCnt = COM_StringLengthNoColors(szString, 0, NULL); + nCnt = u8_COM_StringLengthNoColors(szString, 0, NULL); - PRVM_G_FLOAT(OFS_RETURN) = cls.state; + PRVM_G_FLOAT(OFS_RETURN) = nCnt; } +// DRESK - String to Uppercase and Lowercase /* ========= -VM_getostype +VM_strtolower -float getostype(void) +string strtolower(string s) ========= -*/ // not used at the moment -> not included in the common list -void VM_getostype(void) +*/ +// string (string s) strtolower = #480; // returns passed in string in lowercase form +void VM_strtolower(void) { - VM_SAFEPARMCOUNT(0,VM_getostype); + char szNewString[VM_STRINGTEMP_LENGTH]; + const char *szString; - /* - OS_WINDOWS - OS_LINUX - OS_MAC - not supported - */ + // Prepare Strings + VM_SAFEPARMCOUNT(1,VM_strtolower); + szString = PRVM_G_STRING(OFS_PARM0); -#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 + COM_ToLowerString(szString, szNewString, sizeof(szNewString) ); + + PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(szNewString); } /* ========= -VM_getmousepos +VM_strtoupper -vector getmousepos() +string strtoupper(string s) ========= */ -void VM_getmousepos(void) +// string (string s) strtoupper = #481; // returns passed in string in uppercase form +void VM_strtoupper(void) { + char szNewString[VM_STRINGTEMP_LENGTH]; + const char *szString; - VM_SAFEPARMCOUNT(0,VM_getmousepos); + // Prepare Strings + VM_SAFEPARMCOUNT(1,VM_strtoupper); + szString = PRVM_G_STRING(OFS_PARM0); - 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; + COM_ToUpperString(szString, szNewString, sizeof(szNewString) ); + + PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(szNewString); } /* ========= -VM_gettime +VM_strcat -float gettime(void) +string strcat(string,string,...[string]) ========= */ -void VM_gettime(void) +//string(string s1, string s2) strcat = #115; +// concatenates two strings (for example "abc", "def" would return "abcdef") +// and returns as a tempstring +void VM_strcat(void) { - VM_SAFEPARMCOUNT(0,VM_gettime); + char s[VM_STRINGTEMP_LENGTH]; + VM_SAFEPARMCOUNTRANGE(1, 8, VM_strcat); - PRVM_G_FLOAT(OFS_RETURN) = (float) *prog->time; + VM_VarString(0, s, sizeof(s)); + PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(s); } /* ========= -VM_loadfromdata +VM_substring -loadfromdata(string data) +string substring(string s, float start, float length) ========= */ -void VM_loadfromdata(void) +// string(string s, float start, float length) substring = #116; +// returns a section of a string as a tempstring +void VM_substring(void) { - VM_SAFEPARMCOUNT(1,VM_loadentsfromfile); + int start, length; + int u_slength = 0, u_start; + size_t u_length; + const char *s; + char string[VM_STRINGTEMP_LENGTH]; - PRVM_ED_LoadFromFile(PRVM_G_STRING(OFS_PARM0)); + VM_SAFEPARMCOUNT(3,VM_substring); + + /* + s = PRVM_G_STRING(OFS_PARM0); + start = (int)PRVM_G_FLOAT(OFS_PARM1); + length = (int)PRVM_G_FLOAT(OFS_PARM2); + slength = strlen(s); + + if (start < 0) // FTE_STRINGS feature + start += slength; + start = bound(0, start, slength); + + if (length < 0) // FTE_STRINGS feature + length += slength - start + 1; + maxlen = min((int)sizeof(string) - 1, slength - start); + length = bound(0, length, maxlen); + + memcpy(string, s + start, length); + string[length] = 0; + PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(string); + */ + + s = PRVM_G_STRING(OFS_PARM0); + start = (int)PRVM_G_FLOAT(OFS_PARM1); + length = (int)PRVM_G_FLOAT(OFS_PARM2); + + if (start < 0) // FTE_STRINGS feature + { + u_slength = u8_strlen(s); + start += u_slength; + start = bound(0, start, u_slength); + } + + if (length < 0) // FTE_STRINGS feature + { + if (!u_slength) // it's not calculated when it's not needed above + u_slength = u8_strlen(s); + length += u_slength - start + 1; + } + + // positive start, positive length + u_start = u8_byteofs(s, start, NULL); + if (u_start < 0) + { + PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(""); + return; + } + u_length = u8_bytelen(s + u_start, length); + if (u_length >= sizeof(string)-1) + u_length = sizeof(string)-1; + + memcpy(string, s + u_start, u_length); + string[u_length] = 0; + PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(string); } /* -======================== -VM_M_parseentitydata +========= +VM_strreplace -parseentitydata(entity ent, string data) -======================== +string(string search, string replace, string subject) strreplace = #484; +========= */ -void VM_M_parseentitydata(void) +// replaces all occurrences of search with replace in the string subject, and returns the result +void VM_strreplace(void) { - prvm_edict_t *ent; - const char *data; + int i, j, si; + const char *search, *replace, *subject; + char string[VM_STRINGTEMP_LENGTH]; + int search_len, replace_len, subject_len; - VM_SAFEPARMCOUNT(2, VM_parseentitydata); + VM_SAFEPARMCOUNT(3,VM_strreplace); - // 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)); + search = PRVM_G_STRING(OFS_PARM0); + replace = PRVM_G_STRING(OFS_PARM1); + subject = PRVM_G_STRING(OFS_PARM2); - data = PRVM_G_STRING(OFS_PARM1); + search_len = (int)strlen(search); + replace_len = (int)strlen(replace); + subject_len = (int)strlen(subject); - // 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 ); + si = 0; + for (i = 0; i < subject_len; i++) + { + for (j = 0; j < search_len && i+j < subject_len; j++) + if (subject[i+j] != search[j]) + break; + if (j == search_len || i+j == subject_len) + { + // found it at offset 'i' + for (j = 0; j < replace_len && si < (int)sizeof(string) - 1; j++) + string[si++] = replace[j]; + i += search_len - 1; + } + else + { + // not found + if (si < (int)sizeof(string) - 1) + string[si++] = subject[i]; + } + } + string[si] = '\0'; - PRVM_ED_ParseEdict (data, ent); + PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(string); } /* ========= -VM_loadfromfile +VM_strireplace -loadfromfile(string file) +string(string search, string replace, string subject) strireplace = #485; ========= */ -void VM_loadfromfile(void) +// case-insensitive version of strreplace +void VM_strireplace(void) { - char *filename; - qbyte *data; + int i, j, si; + const char *search, *replace, *subject; + char string[VM_STRINGTEMP_LENGTH]; + int search_len, replace_len, subject_len; - VM_SAFEPARMCOUNT(1,VM_loadfromfile); + VM_SAFEPARMCOUNT(3,VM_strreplace); - 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; - } + search = PRVM_G_STRING(OFS_PARM0); + replace = PRVM_G_STRING(OFS_PARM1); + subject = PRVM_G_STRING(OFS_PARM2); - // not conform with VM_fopen - data = FS_LoadFile(filename, tempmempool, false); - if (data == NULL) - PRVM_G_FLOAT(OFS_RETURN) = -1; + search_len = (int)strlen(search); + replace_len = (int)strlen(replace); + subject_len = (int)strlen(subject); - PRVM_ED_LoadFromFile(data); + si = 0; + for (i = 0; i < subject_len; i++) + { + for (j = 0; j < search_len && i+j < subject_len; j++) + if (tolower(subject[i+j]) != tolower(search[j])) + break; + if (j == search_len || i+j == subject_len) + { + // found it at offset 'i' + for (j = 0; j < replace_len && si < (int)sizeof(string) - 1; j++) + string[si++] = replace[j]; + i += search_len - 1; + } + else + { + // not found + if (si < (int)sizeof(string) - 1) + string[si++] = subject[i]; + } + } + string[si] = '\0'; - if(data) - Mem_Free(data); + PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(string); } - /* ========= -VM_modulo +VM_stov -float mod(float val, float m) +vector stov(string s) ========= */ -void VM_modulo(void) +//vector(string s) stov = #117; // returns vector value from a string +void VM_stov(void) { - int val, m; - VM_SAFEPARMCOUNT(2,VM_module); + char string[VM_STRINGTEMP_LENGTH]; - val = (int) PRVM_G_FLOAT(OFS_PARM0); - m = (int) PRVM_G_FLOAT(OFS_PARM1); + VM_SAFEPARMCOUNT(1,VM_stov); - PRVM_G_FLOAT(OFS_RETURN) = (float) (val % m); + VM_VarString(0, string, sizeof(string)); + Math_atov(string, PRVM_G_VECTOR(OFS_RETURN)); } -void VM_Search_Init(void) -{ - memset(VM_SEARCHLIST,0,sizeof(fssearch_t*[MAX_VMSEARCHES])); -} +/* +========= +VM_strzone -void VM_Search_Reset(void) +string strzone(string s) +========= +*/ +//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) { - 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])); + char *out; + char string[VM_STRINGTEMP_LENGTH]; + size_t alloclen; + + VM_SAFEPARMCOUNT(1,VM_strzone); + + VM_VarString(0, string, sizeof(string)); + alloclen = strlen(string) + 1; + PRVM_G_INT(OFS_RETURN) = PRVM_AllocString(alloclen, &out); + memcpy(out, string, alloclen); } /* ========= -VM_search_begin +VM_strunzone -float search_begin(string pattern, float caseinsensitive, float quiet) +strunzone(string s) ========= */ -void VM_search_begin(void) +//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) { - int handle; - char *pattern; - int caseinsens, quiet; - - VM_SAFEPARMCOUNT(3, VM_search_begin); - - pattern = PRVM_G_STRING(OFS_PARM0); + VM_SAFEPARMCOUNT(1,VM_strunzone); + PRVM_FreeString(PRVM_G_INT(OFS_PARM0)); +} - VM_CheckEmptyString(pattern); +/* +========= +VM_command (used by client and menu) - caseinsens = PRVM_G_FLOAT(OFS_PARM1); - quiet = PRVM_G_FLOAT(OFS_PARM2); +clientcommand(float client, string s) (for client and menu) +========= +*/ +//void(entity e, string s) clientcommand = #440; // executes a command string as if it came from the specified client +//this function originally written by KrimZon, made shorter by LordHavoc +void VM_clcommand (void) +{ + client_t *temp_client; + int i; - for(handle = 0; handle < MAX_VMSEARCHES; handle++) - if(!VM_SEARCHLIST[handle]) - break; + VM_SAFEPARMCOUNT(2,VM_clcommand); - if(handle >= MAX_VMSEARCHES) + i = (int)PRVM_G_FLOAT(OFS_PARM0); + if (!sv.active || i < 0 || i >= svs.maxclients || !svs.clients[i].active) { - Con_Printf("VM_search_begin: %s ran out of search handles (%i)\n", PRVM_NAME, MAX_VMSEARCHES); - PRVM_G_FLOAT(OFS_RETURN) = -2; + VM_Warning("VM_clientcommand: %s: invalid client/server is not active !\n", PRVM_NAME); return; } - if(!(VM_SEARCHLIST[handle] = FS_Search(pattern,caseinsens, quiet))) - PRVM_G_FLOAT(OFS_RETURN) = -1; - else - PRVM_G_FLOAT(OFS_RETURN) = handle; + temp_client = host_client; + host_client = svs.clients + i; + Cmd_ExecuteString (PRVM_G_STRING(OFS_PARM1), src_client); + host_client = temp_client; } + /* ========= -VM_search_end +VM_tokenize -void search_end(float handle) +float tokenize(string s) ========= */ -void VM_search_end(void) +//float(string s) tokenize = #441; // takes apart a string into individal words (access them with argv), returns how many +//this function originally written by KrimZon, made shorter by LordHavoc +//20040203: rewritten by LordHavoc (no longer uses allocations) +static int num_tokens = 0; +static int tokens[VM_STRINGTEMP_LENGTH / 2]; +static int tokens_startpos[VM_STRINGTEMP_LENGTH / 2]; +static int tokens_endpos[VM_STRINGTEMP_LENGTH / 2]; +static char tokenize_string[VM_STRINGTEMP_LENGTH]; +void VM_tokenize (void) { - int handle; - VM_SAFEPARMCOUNT(1, VM_search_end); + const char *p; + + VM_SAFEPARMCOUNT(1,VM_tokenize); - handle = PRVM_G_FLOAT(OFS_PARM0); + strlcpy(tokenize_string, PRVM_G_STRING(OFS_PARM0), sizeof(tokenize_string)); + p = tokenize_string; - if(handle < 0 || handle >= MAX_VMSEARCHES) + num_tokens = 0; + for(;;) { - Con_Printf("VM_search_end: invalid handle %i used in %s\n", handle, PRVM_NAME); - return; + if (num_tokens >= (int)(sizeof(tokens)/sizeof(tokens[0]))) + break; + + // skip whitespace here to find token start pos + while(*p && ISWHITESPACE(*p)) + ++p; + + tokens_startpos[num_tokens] = p - tokenize_string; + if(!COM_ParseToken_VM_Tokenize(&p, false)) + break; + tokens_endpos[num_tokens] = p - tokenize_string; + tokens[num_tokens] = PRVM_SetTempString(com_token); + ++num_tokens; } - if(VM_SEARCHLIST[handle] == NULL) + + PRVM_G_FLOAT(OFS_RETURN) = num_tokens; +} + +//float(string s) tokenize = #514; // takes apart a string into individal words (access them with argv), returns how many +void VM_tokenize_console (void) +{ + const char *p; + + VM_SAFEPARMCOUNT(1,VM_tokenize); + + strlcpy(tokenize_string, PRVM_G_STRING(OFS_PARM0), sizeof(tokenize_string)); + p = tokenize_string; + + num_tokens = 0; + for(;;) { - Con_Printf("VM_search_end: no such handle %i in %s\n", handle, PRVM_NAME); - return; + if (num_tokens >= (int)(sizeof(tokens)/sizeof(tokens[0]))) + break; + + // skip whitespace here to find token start pos + while(*p && ISWHITESPACE(*p)) + ++p; + + tokens_startpos[num_tokens] = p - tokenize_string; + if(!COM_ParseToken_Console(&p)) + break; + tokens_endpos[num_tokens] = p - tokenize_string; + tokens[num_tokens] = PRVM_SetTempString(com_token); + ++num_tokens; } - FS_FreeSearch(VM_SEARCHLIST[handle]); - VM_SEARCHLIST[handle] = NULL; + PRVM_G_FLOAT(OFS_RETURN) = num_tokens; } /* ========= -VM_search_getsize +VM_tokenizebyseparator -float search_getsize(float handle) +float tokenizebyseparator(string s, string separator1, ...) ========= */ -void VM_search_getsize(void) +//float(string s, string separator1, ...) tokenizebyseparator = #479; // takes apart a string into individal words (access them with argv), returns how many +//this function returns the token preceding each instance of a separator (of +//which there can be multiple), and the text following the last separator +//useful for parsing certain kinds of data like IP addresses +//example: +//numnumbers = tokenizebyseparator("10.1.2.3", "."); +//returns 4 and the tokens "10" "1" "2" "3". +void VM_tokenizebyseparator (void) { - int handle; - VM_SAFEPARMCOUNT(1, VM_M_search_getsize); + int j, k; + int numseparators; + int separatorlen[7]; + const char *separators[7]; + const char *p, *p0; + const char *token; + char tokentext[MAX_INPUTLINE]; + + VM_SAFEPARMCOUNTRANGE(2, 8,VM_tokenizebyseparator); - handle = PRVM_G_FLOAT(OFS_PARM0); + strlcpy(tokenize_string, PRVM_G_STRING(OFS_PARM0), sizeof(tokenize_string)); + p = tokenize_string; - if(handle < 0 || handle >= MAX_VMSEARCHES) + numseparators = 0; + for (j = 1;j < prog->argc;j++) { - Con_Printf("VM_search_getsize: invalid handle %i used in %s\n", handle, PRVM_NAME); - return; + // skip any blank separator strings + const char *s = PRVM_G_STRING(OFS_PARM0+j*3); + if (!s[0]) + continue; + separators[numseparators] = s; + separatorlen[numseparators] = strlen(s); + numseparators++; } - if(VM_SEARCHLIST[handle] == NULL) + + num_tokens = 0; + j = 0; + + while (num_tokens < (int)(sizeof(tokens)/sizeof(tokens[0]))) { - Con_Printf("VM_search_getsize: no such handle %i in %s\n", handle, PRVM_NAME); - return; + token = tokentext + j; + tokens_startpos[num_tokens] = p - tokenize_string; + p0 = p; + while (*p) + { + for (k = 0;k < numseparators;k++) + { + if (!strncmp(p, separators[k], separatorlen[k])) + { + p += separatorlen[k]; + break; + } + } + if (k < numseparators) + break; + if (j < (int)sizeof(tokentext)-1) + tokentext[j++] = *p; + p++; + p0 = p; + } + tokens_endpos[num_tokens] = p0 - tokenize_string; + if (j >= (int)sizeof(tokentext)) + break; + tokentext[j++] = 0; + tokens[num_tokens++] = PRVM_SetTempString(token); + if (!*p) + break; } - PRVM_G_FLOAT(OFS_RETURN) = VM_SEARCHLIST[handle]->numfilenames; + PRVM_G_FLOAT(OFS_RETURN) = num_tokens; } -/* -========= -VM_search_getfilename +//string(float n) argv = #442; // returns a word from the tokenized string (returns nothing for an invalid index) +//this function originally written by KrimZon, made shorter by LordHavoc +void VM_argv (void) +{ + int token_num; -string search_getfilename(float handle, float num) -========= -*/ -void VM_search_getfilename(void) + VM_SAFEPARMCOUNT(1,VM_argv); + + token_num = (int)PRVM_G_FLOAT(OFS_PARM0); + + if(token_num < 0) + token_num += num_tokens; + + if (token_num >= 0 && token_num < num_tokens) + PRVM_G_INT(OFS_RETURN) = tokens[token_num]; + else + PRVM_G_INT(OFS_RETURN) = OFS_NULL; +} + +//float(float n) argv_start_index = #515; // returns the start index of a token +void VM_argv_start_index (void) { - int handle, filenum; - char *tmp; - VM_SAFEPARMCOUNT(2, VM_search_getfilename); + int token_num; + + VM_SAFEPARMCOUNT(1,VM_argv); - handle = PRVM_G_FLOAT(OFS_PARM0); - filenum = PRVM_G_FLOAT(OFS_PARM1); + token_num = (int)PRVM_G_FLOAT(OFS_PARM0); - 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; - } + if(token_num < 0) + token_num += num_tokens; + + if (token_num >= 0 && token_num < num_tokens) + PRVM_G_FLOAT(OFS_RETURN) = tokens_startpos[token_num]; + else + PRVM_G_FLOAT(OFS_RETURN) = -1; +} + +//float(float n) argv_end_index = #516; // returns the end index of a token +void VM_argv_end_index (void) +{ + int token_num; + + VM_SAFEPARMCOUNT(1,VM_argv); - tmp = VM_GetTempString(); - strcpy(tmp, VM_SEARCHLIST[handle]->filenames[filenum]); + token_num = (int)PRVM_G_FLOAT(OFS_PARM0); - PRVM_G_INT(OFS_RETURN) = PRVM_SetString(tmp); + if(token_num < 0) + token_num += num_tokens; + + if (token_num >= 0 && token_num < num_tokens) + PRVM_G_FLOAT(OFS_RETURN) = tokens_endpos[token_num]; + else + PRVM_G_FLOAT(OFS_RETURN) = -1; } /* ========= -VM_chr +VM_isserver -string chr(float ascii) +float isserver() ========= */ -void VM_chr(void) +void VM_isserver(void) { - char *tmp; - VM_SAFEPARMCOUNT(1, VM_chr); - - tmp = VM_GetTempString(); - tmp[0] = (unsigned char) PRVM_G_FLOAT(OFS_PARM0); - tmp[1] = 0; + VM_SAFEPARMCOUNT(0,VM_serverstate); - PRVM_G_INT(OFS_RETURN) = PRVM_SetString(tmp); + PRVM_G_FLOAT(OFS_RETURN) = sv.active && (svs.maxclients > 1 || cls.state == ca_dedicated); } -//============================================================================= -// Draw builtins (client & menu) - /* ========= -VM_iscachedpic +VM_clientcount -float iscachedpic(string pic) +float clientcount() ========= */ -void VM_iscachedpic(void) +void VM_clientcount(void) { - VM_SAFEPARMCOUNT(1,VM_iscachedpic); + VM_SAFEPARMCOUNT(0,VM_clientcount); - // drawq hasnt such a function, thus always return true - PRVM_G_FLOAT(OFS_RETURN) = false; + PRVM_G_FLOAT(OFS_RETURN) = svs.maxclients; } /* ========= -VM_precache_pic +VM_clientstate -string precache_pic(string pic) +float clientstate() ========= */ -void VM_precache_pic(void) +void VM_clientstate(void) { - 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_SAFEPARMCOUNT(0,VM_clientstate); - VM_CheckEmptyString (s); - if(!Draw_CachePic(s)) - PRVM_G_INT(OFS_RETURN) = PRVM_SetString(""); + switch( cls.state ) { + case ca_uninitialized: + case ca_dedicated: + PRVM_G_FLOAT(OFS_RETURN) = 0; + break; + case ca_disconnected: + PRVM_G_FLOAT(OFS_RETURN) = 1; + break; + case ca_connected: + PRVM_G_FLOAT(OFS_RETURN) = 2; + break; + default: + // should never be reached! + break; + } } /* ========= -VM_freepic +VM_getostype -freepic(string s) +float getostype(void) ========= -*/ -void VM_freepic(void) +*/ // not used at the moment -> not included in the common list +void VM_getostype(void) { - char *s; - - VM_SAFEPARMCOUNT(1,VM_freepic); - - s = PRVM_G_STRING(OFS_PARM0); - - if(!s) - PRVM_ERROR ("VM_freepic: %s: NULL\n"); + VM_SAFEPARMCOUNT(0,VM_getostype); - VM_CheckEmptyString (s); + /* + OS_WINDOWS + OS_LINUX + OS_MAC - not supported + */ - Draw_FreePic(s); +#ifdef WIN32 + PRVM_G_FLOAT(OFS_RETURN) = 0; +#elif defined(MACOSX) + PRVM_G_FLOAT(OFS_RETURN) = 2; +#else + PRVM_G_FLOAT(OFS_RETURN) = 1; +#endif } /* ========= -VM_drawcharacter +VM_gettime -float drawcharacter(vector position, float character, vector scale, vector rgb, float alpha, float flag) +float gettime(void) ========= */ -void VM_drawcharacter(void) +extern double host_starttime; +float CDAudio_GetPosition(void); +void VM_gettime(void) { - float *pos,*scale,*rgb; - char character; - int flag; - VM_SAFEPARMCOUNT(6,VM_drawcharacter); + int timer_index; - character = (char) PRVM_G_FLOAT(OFS_PARM1); - if(character == 0) + VM_SAFEPARMCOUNTRANGE(0,1,VM_gettime); + + if(prog->argc == 0) { - Con_Printf("VM_drawcharacter: %s passed null character !\n",PRVM_NAME); - PRVM_G_FLOAT(OFS_RETURN) = -1; - return; + PRVM_G_FLOAT(OFS_RETURN) = (float) realtime; } - - 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) + else { - Con_Printf("VM_drawcharacter: %s: wrong DRAWFLAG %i !\n",PRVM_NAME,flag); - PRVM_G_FLOAT(OFS_RETURN) = -2; - return; + timer_index = (int) PRVM_G_FLOAT(OFS_PARM0); + switch(timer_index) + { + case 0: // GETTIME_FRAMESTART + PRVM_G_FLOAT(OFS_RETURN) = (float) realtime; + break; + case 1: // GETTIME_REALTIME + PRVM_G_FLOAT(OFS_RETURN) = (float) Sys_DoubleTime(); + break; + case 2: // GETTIME_HIRES + PRVM_G_FLOAT(OFS_RETURN) = (float) (Sys_DoubleTime() - realtime); + break; + case 3: // GETTIME_UPTIME + PRVM_G_FLOAT(OFS_RETURN) = (float) (Sys_DoubleTime() - host_starttime); + break; + case 4: // GETTIME_CDTRACK + PRVM_G_FLOAT(OFS_RETURN) = (float) CDAudio_GetPosition(); + break; + default: + VM_Warning("VM_gettime: %s: unsupported timer specified, returning realtime\n", PRVM_NAME); + PRVM_G_FLOAT(OFS_RETURN) = (float) realtime; + break; + } } - - 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"))); - - if(!scale[0] || !scale[1]) - { - Con_Printf("VM_drawcharacter: scale %s is null !\n", (scale[0] == 0) ? ((scale[1] == 0) ? "x and y" : "x") : "y"); - PRVM_G_FLOAT(OFS_RETURN) = -3; - return; - } - - 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; -} +} /* ========= -VM_drawstring +VM_loadfromdata -float drawstring(vector position, string text, vector scale, vector rgb, float alpha, float flag) +loadfromdata(string data) ========= */ -void VM_drawstring(void) +void VM_loadfromdata(void) { - float *pos,*scale,*rgb; - char *string; - int flag; - VM_SAFEPARMCOUNT(6,VM_drawstring); + VM_SAFEPARMCOUNT(1,VM_loadentsfromfile); - string = PRVM_G_STRING(OFS_PARM1); - if(!string) - { - Con_Printf("VM_drawstring: %s passed null string !\n",PRVM_NAME); - PRVM_G_FLOAT(OFS_RETURN) = -1; - return; - } + PRVM_ED_LoadFromFile(PRVM_G_STRING(OFS_PARM0)); +} - //VM_CheckEmptyString(string); Why should it be checked - perhaps the menu wants to support the precolored letters, too? +/* +======================== +VM_parseentitydata - 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); +parseentitydata(entity ent, string data) +======================== +*/ +void VM_parseentitydata(void) +{ + prvm_edict_t *ent; + const char *data; - 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; - } + VM_SAFEPARMCOUNT(2, VM_parseentitydata); - 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"); - PRVM_G_FLOAT(OFS_RETURN) = -3; - return; - } + // get edict and test it + ent = PRVM_G_EDICT(OFS_PARM0); + if (ent->priv.required->free) + PRVM_ERROR ("VM_parseentitydata: %s: Can only set already spawned entities (entity %i is free)!", PRVM_NAME, PRVM_NUM_FOR_EDICT(ent)); - 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"))); + data = PRVM_G_STRING(OFS_PARM1); - 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; + // parse the opening brace + if (!COM_ParseToken_Simple(&data, false, false) || com_token[0] != '{' ) + PRVM_ERROR ("VM_parseentitydata: %s: Couldn't parse entity data:\n%s", PRVM_NAME, data ); + + PRVM_ED_ParseEdict (data, ent); } + /* ========= -VM_drawpic +VM_loadfromfile -float drawpic(vector position, string pic, vector size, vector rgb, float alpha, float flag) +loadfromfile(string file) ========= */ -void VM_drawpic(void) +void VM_loadfromfile(void) { - char *pic; - float *size, *pos, *rgb; - int flag; - - VM_SAFEPARMCOUNT(6,VM_drawpic); - - pic = PRVM_G_STRING(OFS_PARM1); - - if(!pic) - { - Con_Printf("VM_drawpic: %s passed null picture name !\n", PRVM_NAME); - PRVM_G_FLOAT(OFS_RETURN) = -1; - return; - } + const char *filename; + char *data; - VM_CheckEmptyString (pic); + VM_SAFEPARMCOUNT(1,VM_loadfromfile); - // is pic cached ? no function yet for that - if(!1) + filename = PRVM_G_STRING(OFS_PARM0); + if (FS_CheckNastyPath(filename, false)) { - Con_Printf("VM_drawpic: %s: %s not cached !\n", PRVM_NAME, pic); PRVM_G_FLOAT(OFS_RETURN) = -4; + VM_Warning("VM_loadfromfile: %s dangerous or non-portable filename \"%s\" not allowed. (contains : or \\ or begins with .. or /)\n", PRVM_NAME, filename); return; } - pos = PRVM_G_VECTOR(OFS_PARM0); - size = 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; - } + // not conform with VM_fopen + data = (char *)FS_LoadFile(filename, tempmempool, false, NULL); + if (data == NULL) + PRVM_G_FLOAT(OFS_RETURN) = -1; - 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"))); + PRVM_ED_LoadFromFile(data); - 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(data) + Mem_Free(data); } + /* ========= -VM_drawfill +VM_modulo -float drawfill(vector position, vector size, vector rgb, float alpha, float flag) +float mod(float val, float m) ========= */ -void VM_drawfill(void) +void VM_modulo(void) { - float *size, *pos, *rgb; - int flag; + int val, m; + VM_SAFEPARMCOUNT(2,VM_module); - VM_SAFEPARMCOUNT(5,VM_drawfill); + val = (int) PRVM_G_FLOAT(OFS_PARM0); + m = (int) PRVM_G_FLOAT(OFS_PARM1); + PRVM_G_FLOAT(OFS_RETURN) = (float) (val % m); +} - 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); +void VM_Search_Init(void) +{ + int i; + for (i = 0;i < PRVM_MAX_OPENSEARCHES;i++) + prog->opensearches[i] = NULL; +} - if(flag < DRAWFLAG_NORMAL || flag >=DRAWFLAG_NUMFLAGS) +void VM_Search_Reset(void) +{ + int i; + // reset the fssearch list + for(i = 0; i < PRVM_MAX_OPENSEARCHES; i++) { - Con_Printf("VM_drawstring: %s: wrong DRAWFLAG %i !\n",PRVM_NAME,flag); - PRVM_G_FLOAT(OFS_RETURN) = -2; - return; + if(prog->opensearches[i]) + FS_FreeSearch(prog->opensearches[i]); + prog->opensearches[i] = NULL; } - - 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"))); - - 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_drawsetcliparea +VM_search_begin -drawsetcliparea(float x, float y, float width, float height) +float search_begin(string pattern, float caseinsensitive, float quiet) ========= */ -void VM_drawsetcliparea(void) +void VM_search_begin(void) { - float x,y,w,h; - VM_SAFEPARMCOUNT(4,VM_drawsetcliparea); + int handle; + const char *pattern; + int caseinsens, quiet; - 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)); + VM_SAFEPARMCOUNT(3, VM_search_begin); - DrawQ_SetClipArea(x, y, w, h); + pattern = PRVM_G_STRING(OFS_PARM0); + + VM_CheckEmptyString(pattern); + + caseinsens = (int)PRVM_G_FLOAT(OFS_PARM1); + quiet = (int)PRVM_G_FLOAT(OFS_PARM2); + + for(handle = 0; handle < PRVM_MAX_OPENSEARCHES; handle++) + if(!prog->opensearches[handle]) + break; + + if(handle >= PRVM_MAX_OPENSEARCHES) + { + PRVM_G_FLOAT(OFS_RETURN) = -2; + VM_Warning("VM_search_begin: %s ran out of search handles (%i)\n", PRVM_NAME, PRVM_MAX_OPENSEARCHES); + return; + } + + if(!(prog->opensearches[handle] = FS_Search(pattern,caseinsens, quiet))) + PRVM_G_FLOAT(OFS_RETURN) = -1; + else + { + prog->opensearches_origin[handle] = PRVM_AllocationOrigin(); + PRVM_G_FLOAT(OFS_RETURN) = handle; + } } /* ========= -VM_drawresetcliparea +VM_search_end -drawresetcliparea() +void search_end(float handle) ========= */ -void VM_drawresetcliparea(void) +void VM_search_end(void) { - VM_SAFEPARMCOUNT(0,VM_drawresetcliparea); + int handle; + VM_SAFEPARMCOUNT(1, VM_search_end); - DrawQ_ResetClipArea(); + handle = (int)PRVM_G_FLOAT(OFS_PARM0); + + if(handle < 0 || handle >= PRVM_MAX_OPENSEARCHES) + { + VM_Warning("VM_search_end: invalid handle %i used in %s\n", handle, PRVM_NAME); + return; + } + if(prog->opensearches[handle] == NULL) + { + VM_Warning("VM_search_end: no such handle %i in %s\n", handle, PRVM_NAME); + return; + } + + FS_FreeSearch(prog->opensearches[handle]); + prog->opensearches[handle] = NULL; + if(prog->opensearches_origin[handle]) + PRVM_Free((char *)prog->opensearches_origin[handle]); } /* ========= -VM_getimagesize +VM_search_getsize -vector getimagesize(string pic) +float search_getsize(float handle) ========= */ -void VM_getimagesize(void) +void VM_search_getsize(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); + int handle; + VM_SAFEPARMCOUNT(1, VM_M_search_getsize); - VM_CheckEmptyString (p); + handle = (int)PRVM_G_FLOAT(OFS_PARM0); - pic = Draw_CachePic (p); + if(handle < 0 || handle >= PRVM_MAX_OPENSEARCHES) + { + VM_Warning("VM_search_getsize: invalid handle %i used in %s\n", handle, PRVM_NAME); + return; + } + if(prog->opensearches[handle] == NULL) + { + VM_Warning("VM_search_getsize: no such handle %i in %s\n", handle, PRVM_NAME); + return; + } - PRVM_G_VECTOR(OFS_RETURN)[0] = pic->width; - PRVM_G_VECTOR(OFS_RETURN)[1] = pic->height; - PRVM_G_VECTOR(OFS_RETURN)[2] = 0; + PRVM_G_FLOAT(OFS_RETURN) = prog->opensearches[handle]->numfilenames; } -// CL_Video interface functions - /* -======================== -VM_cin_open +========= +VM_search_getfilename -float cin_open(string file, string name) -======================== +string search_getfilename(float handle, float num) +========= */ -void VM_cin_open( void ) +void VM_search_getfilename(void) { - char *file; - char *name; - - VM_SAFEPARMCOUNT( 2, VM_cin_open ); + int handle, filenum; + VM_SAFEPARMCOUNT(2, VM_search_getfilename); - file = PRVM_G_STRING( OFS_PARM0 ); - name = PRVM_G_STRING( OFS_PARM1 ); + handle = (int)PRVM_G_FLOAT(OFS_PARM0); + filenum = (int)PRVM_G_FLOAT(OFS_PARM1); - VM_CheckEmptyString( file ); - VM_CheckEmptyString( name ); + if(handle < 0 || handle >= PRVM_MAX_OPENSEARCHES) + { + VM_Warning("VM_search_getfilename: invalid handle %i used in %s\n", handle, PRVM_NAME); + return; + } + if(prog->opensearches[handle] == NULL) + { + VM_Warning("VM_search_getfilename: no such handle %i in %s\n", handle, PRVM_NAME); + return; + } + if(filenum < 0 || filenum >= prog->opensearches[handle]->numfilenames) + { + VM_Warning("VM_search_getfilename: invalid filenum %i in %s\n", filenum, PRVM_NAME); + return; + } - if( CL_OpenVideo( file, name, MENUOWNER ) ) - PRVM_G_FLOAT( OFS_RETURN ) = 1; - else - PRVM_G_FLOAT( OFS_RETURN ) = 0; + PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(prog->opensearches[handle]->filenames[filenum]); } /* -======================== -VM_cin_close +========= +VM_chr -void cin_close(string name) -======================== +string chr(float ascii) +========= */ -void VM_cin_close( void ) +void VM_chr(void) { - char *name; + /* + char tmp[2]; + VM_SAFEPARMCOUNT(1, VM_chr); - VM_SAFEPARMCOUNT( 1, VM_cin_close ); + tmp[0] = (unsigned char) PRVM_G_FLOAT(OFS_PARM0); + tmp[1] = 0; - name = PRVM_G_STRING( OFS_PARM0 ); - VM_CheckEmptyString( name ); + PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(tmp); + */ + + char tmp[8]; + int len; + VM_SAFEPARMCOUNT(1, VM_chr); - CL_CloseVideo( CL_GetVideo( name ) ); + len = u8_fromchar((Uchar)PRVM_G_FLOAT(OFS_PARM0), tmp, sizeof(tmp)); + tmp[len] = 0; + PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(tmp); +} + +//============================================================================= +// Draw builtins (client & menu) + +/* +========= +VM_iscachedpic + +float iscachedpic(string pic) +========= +*/ +void VM_iscachedpic(void) +{ + VM_SAFEPARMCOUNT(1,VM_iscachedpic); + + // drawq hasnt such a function, thus always return true + PRVM_G_FLOAT(OFS_RETURN) = false; +} + +/* +========= +VM_precache_pic + +string precache_pic(string pic) +========= +*/ +void VM_precache_pic(void) +{ + 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); + VM_CheckEmptyString (s); + + // AK Draw_CachePic is supposed to always return a valid pointer + if( Draw_CachePic_Flags(s, CACHEPICFLAG_NOTPERSISTENT)->tex == r_texture_notexture ) + PRVM_G_INT(OFS_RETURN) = OFS_NULL; +} + +/* +========= +VM_freepic + +freepic(string s) +========= +*/ +void VM_freepic(void) +{ + const char *s; + + VM_SAFEPARMCOUNT(1,VM_freepic); + + s = PRVM_G_STRING(OFS_PARM0); + VM_CheckEmptyString (s); + + Draw_FreePic(s); +} + +void getdrawfontscale(float *sx, float *sy) +{ + vec3_t v; + *sx = *sy = 1; + if(prog->globaloffsets.drawfontscale >= 0) + { + VectorCopy(PRVM_G_VECTOR(prog->globaloffsets.drawfontscale), v); + if(VectorLength2(v) > 0) + { + *sx = v[0]; + *sy = v[1]; + } + } +} + +dp_font_t *getdrawfont(void) +{ + if(prog->globaloffsets.drawfont >= 0) + { + int f = (int) PRVM_G_FLOAT(prog->globaloffsets.drawfont); + if(f < 0 || f >= MAX_FONTS) + return FONT_DEFAULT; + return &dp_fonts[f]; + } + else + return FONT_DEFAULT; +} + +/* +========= +VM_drawcharacter + +float drawcharacter(vector position, float character, vector scale, vector rgb, float alpha, float flag) +========= +*/ +void VM_drawcharacter(void) +{ + float *pos,*scale,*rgb; + char character; + int flag; + float sx, sy; + VM_SAFEPARMCOUNT(6,VM_drawcharacter); + + character = (char) PRVM_G_FLOAT(OFS_PARM1); + if(character == 0) + { + PRVM_G_FLOAT(OFS_RETURN) = -1; + VM_Warning("VM_drawcharacter: %s passed null character !\n",PRVM_NAME); + 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) + { + PRVM_G_FLOAT(OFS_RETURN) = -2; + VM_Warning("VM_drawcharacter: %s: wrong DRAWFLAG %i !\n",PRVM_NAME,flag); + 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"))); + + if(!scale[0] || !scale[1]) + { + PRVM_G_FLOAT(OFS_RETURN) = -3; + VM_Warning("VM_drawcharacter: scale %s is null !\n", (scale[0] == 0) ? ((scale[1] == 0) ? "x and y" : "x") : "y"); + return; + } + + getdrawfontscale(&sx, &sy); + DrawQ_String_Scale(pos[0], pos[1], &character, 1, scale[0], scale[1], sx, sy, rgb[0], rgb[1], rgb[2], PRVM_G_FLOAT(OFS_PARM4), flag, NULL, true, getdrawfont()); + PRVM_G_FLOAT(OFS_RETURN) = 1; +} + +/* +========= +VM_drawstring + +float drawstring(vector position, string text, vector scale, vector rgb, float alpha, float flag) +========= +*/ +void VM_drawstring(void) +{ + float *pos,*scale,*rgb; + const char *string; + int flag; + float sx, sy; + VM_SAFEPARMCOUNT(6,VM_drawstring); + + string = PRVM_G_STRING(OFS_PARM1); + 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) + { + PRVM_G_FLOAT(OFS_RETURN) = -2; + VM_Warning("VM_drawstring: %s: wrong DRAWFLAG %i !\n",PRVM_NAME,flag); + return; + } + + if(!scale[0] || !scale[1]) + { + PRVM_G_FLOAT(OFS_RETURN) = -3; + VM_Warning("VM_drawstring: scale %s is null !\n", (scale[0] == 0) ? ((scale[1] == 0) ? "x and y" : "x") : "y"); + return; + } + + if(pos[2] || scale[2]) + Con_Printf("VM_drawstring: z value%s from %s discarded\n",(pos[2] && scale[2]) ? "s" : " ",((pos[2] && scale[2]) ? "pos and scale" : (pos[2] ? "pos" : "scale"))); + + getdrawfontscale(&sx, &sy); + DrawQ_String_Scale(pos[0], pos[1], string, 0, scale[0], scale[1], sx, sy, rgb[0], rgb[1], rgb[2], PRVM_G_FLOAT(OFS_PARM4), flag, NULL, true, getdrawfont()); + //Font_DrawString(pos[0], pos[1], string, 0, scale[0], scale[1], rgb[0], rgb[1], rgb[2], PRVM_G_FLOAT(OFS_PARM4), flag, NULL, true); + PRVM_G_FLOAT(OFS_RETURN) = 1; +} + +/* +========= +VM_drawcolorcodedstring + +float drawcolorcodedstring(vector position, string text, vector scale, float alpha, float flag) +========= +*/ +void VM_drawcolorcodedstring(void) +{ + float *pos,*scale; + const char *string; + int flag; + float sx, sy; + VM_SAFEPARMCOUNT(5,VM_drawstring); + + string = PRVM_G_STRING(OFS_PARM1); + pos = PRVM_G_VECTOR(OFS_PARM0); + scale = PRVM_G_VECTOR(OFS_PARM2); + flag = (int)PRVM_G_FLOAT(OFS_PARM4); + + if(flag < DRAWFLAG_NORMAL || flag >=DRAWFLAG_NUMFLAGS) + { + PRVM_G_FLOAT(OFS_RETURN) = -2; + VM_Warning("VM_drawcolorcodedstring: %s: wrong DRAWFLAG %i !\n",PRVM_NAME,flag); + return; + } + + if(!scale[0] || !scale[1]) + { + PRVM_G_FLOAT(OFS_RETURN) = -3; + VM_Warning("VM_drawcolorcodedstring: scale %s is null !\n", (scale[0] == 0) ? ((scale[1] == 0) ? "x and y" : "x") : "y"); + return; + } + + if(pos[2] || scale[2]) + Con_Printf("VM_drawcolorcodedstring: z value%s from %s discarded\n",(pos[2] && scale[2]) ? "s" : " ",((pos[2] && scale[2]) ? "pos and scale" : (pos[2] ? "pos" : "scale"))); + + getdrawfontscale(&sx, &sy); + DrawQ_String_Scale(pos[0], pos[1], string, 0, scale[0], scale[1], sx, sy, 1, 1, 1, PRVM_G_FLOAT(OFS_PARM3), flag, NULL, false, getdrawfont()); + PRVM_G_FLOAT(OFS_RETURN) = 1; +} +/* +========= +VM_stringwidth + +float stringwidth(string text, float allowColorCodes, float size) +========= +*/ +void VM_stringwidth(void) +{ + const char *string; + float *szv; + float mult; // sz is intended font size so we can later add freetype support, mult is font size multiplier in pixels per character cell + int colors; + float sx, sy; + size_t maxlen = 0; + VM_SAFEPARMCOUNTRANGE(2,3,VM_drawstring); + + getdrawfontscale(&sx, &sy); + if(prog->argc == 3) + { + szv = PRVM_G_VECTOR(OFS_PARM2); + mult = 1; + } + else + { + // we want the width for 8x8 font size, divided by 8 + static float defsize[] = {8, 8}; + szv = defsize; + mult = 0.125; + // to make sure snapping is turned off, ALWAYS use a nontrivial scale in this case + if(sx >= 0.9 && sx <= 1.1) + { + mult *= 2; + sx /= 2; + sy /= 2; + } + } + + string = PRVM_G_STRING(OFS_PARM0); + colors = (int)PRVM_G_FLOAT(OFS_PARM1); + + PRVM_G_FLOAT(OFS_RETURN) = DrawQ_TextWidth_UntilWidth_TrackColors_Scale(string, &maxlen, szv[0], szv[1], sx, sy, NULL, !colors, getdrawfont(), 1000000000) * mult; +/* + if(prog->argc == 3) + { + mult = sz = PRVM_G_FLOAT(OFS_PARM2); + } + else + { + sz = 8; + mult = 1; + } + + string = PRVM_G_STRING(OFS_PARM0); + colors = (int)PRVM_G_FLOAT(OFS_PARM1); + + PRVM_G_FLOAT(OFS_RETURN) = DrawQ_TextWidth(string, 0, !colors, getdrawfont()) * mult; // 1x1 characters, don't actually draw +*/ + +} +/* +========= +VM_drawpic + +float drawpic(vector position, string pic, vector size, vector rgb, float alpha, float flag) +========= +*/ +void VM_drawpic(void) +{ + const char *picname; + float *size, *pos, *rgb; + int flag; + + VM_SAFEPARMCOUNT(6,VM_drawpic); + + picname = PRVM_G_STRING(OFS_PARM1); + VM_CheckEmptyString (picname); + + // is pic cached ? no function yet for that + if(!1) + { + PRVM_G_FLOAT(OFS_RETURN) = -4; + VM_Warning("VM_drawpic: %s: %s not cached !\n", PRVM_NAME, picname); + return; + } + + pos = PRVM_G_VECTOR(OFS_PARM0); + size = 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) + { + PRVM_G_FLOAT(OFS_RETURN) = -2; + VM_Warning("VM_drawpic: %s: wrong DRAWFLAG %i !\n",PRVM_NAME,flag); + return; + } + + if(pos[2] || size[2]) + Con_Printf("VM_drawpic: z value%s from %s discarded\n",(pos[2] && size[2]) ? "s" : " ",((pos[2] && size[2]) ? "pos and size" : (pos[2] ? "pos" : "size"))); + + DrawQ_Pic(pos[0], pos[1], Draw_CachePic (picname), size[0], size[1], rgb[0], rgb[1], rgb[2], PRVM_G_FLOAT(OFS_PARM4), flag); + PRVM_G_FLOAT(OFS_RETURN) = 1; +} +/* +========= +VM_drawrotpic + +float drawrotpic(vector position, string pic, vector size, vector org, float angle, vector rgb, float alpha, float flag) +========= +*/ +void VM_drawrotpic(void) +{ + const char *picname; + float *size, *pos, *org, *rgb; + int flag; + + VM_SAFEPARMCOUNT(8,VM_drawrotpic); + + picname = PRVM_G_STRING(OFS_PARM1); + VM_CheckEmptyString (picname); + + // is pic cached ? no function yet for that + if(!1) + { + PRVM_G_FLOAT(OFS_RETURN) = -4; + VM_Warning("VM_drawrotpic: %s: %s not cached !\n", PRVM_NAME, picname); + return; + } + + pos = PRVM_G_VECTOR(OFS_PARM0); + size = PRVM_G_VECTOR(OFS_PARM2); + org = PRVM_G_VECTOR(OFS_PARM3); + rgb = PRVM_G_VECTOR(OFS_PARM5); + flag = (int) PRVM_G_FLOAT(OFS_PARM7); + + if(flag < DRAWFLAG_NORMAL || flag >=DRAWFLAG_NUMFLAGS) + { + PRVM_G_FLOAT(OFS_RETURN) = -2; + VM_Warning("VM_drawrotpic: %s: wrong DRAWFLAG %i !\n",PRVM_NAME,flag); + return; + } + + if(pos[2] || size[2] || org[2]) + Con_Printf("VM_drawrotpic: z value from pos/size/org discarded\n"); + + DrawQ_RotPic(pos[0], pos[1], Draw_CachePic(picname), size[0], size[1], org[0], org[1], PRVM_G_FLOAT(OFS_PARM4), rgb[0], rgb[1], rgb[2], PRVM_G_FLOAT(OFS_PARM6), flag); + PRVM_G_FLOAT(OFS_RETURN) = 1; +} +/* +========= +VM_drawsubpic + +float drawsubpic(vector position, vector size, string pic, vector srcPos, vector srcSize, vector rgb, float alpha, float flag) + +========= +*/ +void VM_drawsubpic(void) +{ + const char *picname; + float *size, *pos, *rgb, *srcPos, *srcSize, alpha; + int flag; + + VM_SAFEPARMCOUNT(8,VM_drawsubpic); + + picname = PRVM_G_STRING(OFS_PARM2); + VM_CheckEmptyString (picname); + + // is pic cached ? no function yet for that + if(!1) + { + PRVM_G_FLOAT(OFS_RETURN) = -4; + VM_Warning("VM_drawsubpic: %s: %s not cached !\n", PRVM_NAME, picname); + return; + } + + pos = PRVM_G_VECTOR(OFS_PARM0); + size = PRVM_G_VECTOR(OFS_PARM1); + srcPos = PRVM_G_VECTOR(OFS_PARM3); + srcSize = PRVM_G_VECTOR(OFS_PARM4); + rgb = PRVM_G_VECTOR(OFS_PARM5); + alpha = PRVM_G_FLOAT(OFS_PARM6); + flag = (int) PRVM_G_FLOAT(OFS_PARM7); + + if(flag < DRAWFLAG_NORMAL || flag >=DRAWFLAG_NUMFLAGS) + { + PRVM_G_FLOAT(OFS_RETURN) = -2; + VM_Warning("VM_drawsubpic: %s: wrong DRAWFLAG %i !\n",PRVM_NAME,flag); + return; + } + + if(pos[2] || size[2]) + Con_Printf("VM_drawsubpic: z value%s from %s discarded\n",(pos[2] && size[2]) ? "s" : " ",((pos[2] && size[2]) ? "pos and size" : (pos[2] ? "pos" : "size"))); + + DrawQ_SuperPic(pos[0], pos[1], Draw_CachePic (picname), + size[0], size[1], + srcPos[0], srcPos[1], rgb[0], rgb[1], rgb[2], alpha, + srcPos[0] + srcSize[0], srcPos[1], rgb[0], rgb[1], rgb[2], alpha, + srcPos[0], srcPos[1] + srcSize[1], rgb[0], rgb[1], rgb[2], alpha, + srcPos[0] + srcSize[0], srcPos[1] + srcSize[1], rgb[0], rgb[1], rgb[2], alpha, + flag); + PRVM_G_FLOAT(OFS_RETURN) = 1; +} + +/* +========= +VM_drawfill + +float drawfill(vector position, vector size, vector rgb, float alpha, float flag) +========= +*/ +void VM_drawfill(void) +{ + 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) + { + PRVM_G_FLOAT(OFS_RETURN) = -2; + VM_Warning("VM_drawfill: %s: wrong DRAWFLAG %i !\n",PRVM_NAME,flag); + return; + } + + if(pos[2] || size[2]) + Con_Printf("VM_drawfill: z value%s from %s discarded\n",(pos[2] && size[2]) ? "s" : " ",((pos[2] && size[2]) ? "pos and size" : (pos[2] ? "pos" : "size"))); + + DrawQ_Fill(pos[0], pos[1], size[0], size[1], rgb[0], rgb[1], rgb[2], PRVM_G_FLOAT(OFS_PARM3), flag); + 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.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); +} + +/* +========= +VM_drawresetcliparea + +drawresetcliparea() +========= +*/ +void VM_drawresetcliparea(void) +{ + VM_SAFEPARMCOUNT(0,VM_drawresetcliparea); + + DrawQ_ResetClipArea(); +} + +/* +========= +VM_getimagesize + +vector getimagesize(string pic) +========= +*/ +void VM_getimagesize(void) +{ + const char *p; + cachepic_t *pic; + + VM_SAFEPARMCOUNT(1,VM_getimagesize); + + p = PRVM_G_STRING(OFS_PARM0); + VM_CheckEmptyString (p); + + pic = Draw_CachePic_Flags (p, CACHEPICFLAG_NOTPERSISTENT); + + PRVM_G_VECTOR(OFS_RETURN)[0] = pic->width; + PRVM_G_VECTOR(OFS_RETURN)[1] = pic->height; + PRVM_G_VECTOR(OFS_RETURN)[2] = 0; +} + +/* +========= +VM_keynumtostring + +string keynumtostring(float keynum) +========= +*/ +void VM_keynumtostring (void) +{ + VM_SAFEPARMCOUNT(1, VM_keynumtostring); + + PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(Key_KeynumToString((int)PRVM_G_FLOAT(OFS_PARM0))); +} + +/* +========= +VM_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(const char *command, int *keys); +void VM_findkeysforcommand(void) +{ + const char *cmd; + char ret[VM_STRINGTEMP_LENGTH]; + int keys[NUMKEYS]; + int i; + + VM_SAFEPARMCOUNT(1, VM_findkeysforcommand); + + cmd = PRVM_G_STRING(OFS_PARM0); + + VM_CheckEmptyString(cmd); + + M_FindKeysForCommand(cmd, keys); + + ret[0] = 0; + for(i = 0; i < NUMKEYS; i++) + strlcat(ret, va(" \'%i\'", keys[i]), sizeof(ret)); + + PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(ret); +} + +/* +========= +VM_stringtokeynum + +float stringtokeynum(string key) +========= +*/ +void VM_stringtokeynum (void) +{ + VM_SAFEPARMCOUNT( 1, VM_keynumtostring ); + + PRVM_G_INT(OFS_RETURN) = Key_StringToKeynum(PRVM_G_STRING(OFS_PARM0)); +} + +// 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_GetVideoByName( 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 = (clvideostate_t)((int)PRVM_G_FLOAT( OFS_PARM1 )); + + video = CL_GetVideoByName( 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_GetVideoByName( 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_GetVideoByName( name ); + if( video ) + CL_RestartVideo( video ); +} + +/* +======================== +VM_Gecko_Init +======================== +*/ +void VM_Gecko_Init( void ) { + // the prog struct is memset to 0 by Initprog? [12/6/2007 Black] + // FIXME: remove the other _Init functions then, too? [12/6/2007 Black] +} + +/* +======================== +VM_Gecko_Destroy +======================== +*/ +void VM_Gecko_Destroy( void ) { + int i; + for( i = 0 ; i < PRVM_MAX_GECKOINSTANCES ; i++ ) { + clgecko_t **instance = &prog->opengeckoinstances[ i ]; + if( *instance ) { + CL_Gecko_DestroyBrowser( *instance ); + } + *instance = NULL; + } +} + +/* +======================== +VM_gecko_create + +float[bool] gecko_create( string name ) +======================== +*/ +void VM_gecko_create( void ) { + const char *name; + int i; + clgecko_t *instance; + + VM_SAFEPARMCOUNT( 1, VM_gecko_create ); + + name = PRVM_G_STRING( OFS_PARM0 ); + VM_CheckEmptyString( name ); + + // find an empty slot for this gecko browser.. + for( i = 0 ; i < PRVM_MAX_GECKOINSTANCES ; i++ ) { + if( prog->opengeckoinstances[ i ] == NULL ) { + break; + } + } + if( i == PRVM_MAX_GECKOINSTANCES ) { + VM_Warning("VM_gecko_create: %s ran out of gecko handles (%i)\n", PRVM_NAME, PRVM_MAX_GECKOINSTANCES); + PRVM_G_FLOAT( OFS_RETURN ) = 0; + return; + } + + instance = prog->opengeckoinstances[ i ] = CL_Gecko_CreateBrowser( name, PRVM_GetProgNr() ); + if( !instance ) { + // TODO: error handling [12/3/2007 Black] + PRVM_G_FLOAT( OFS_RETURN ) = 0; + return; + } + PRVM_G_FLOAT( OFS_RETURN ) = 1; +} + +/* +======================== +VM_gecko_destroy + +void gecko_destroy( string name ) +======================== +*/ +void VM_gecko_destroy( void ) { + const char *name; + clgecko_t *instance; + + VM_SAFEPARMCOUNT( 1, VM_gecko_destroy ); + + name = PRVM_G_STRING( OFS_PARM0 ); + VM_CheckEmptyString( name ); + instance = CL_Gecko_FindBrowser( name ); + if( !instance ) { + return; + } + CL_Gecko_DestroyBrowser( instance ); +} + +/* +======================== +VM_gecko_navigate + +void gecko_navigate( string name, string URI ) +======================== +*/ +void VM_gecko_navigate( void ) { + const char *name; + const char *URI; + clgecko_t *instance; + + VM_SAFEPARMCOUNT( 2, VM_gecko_navigate ); + + name = PRVM_G_STRING( OFS_PARM0 ); + URI = PRVM_G_STRING( OFS_PARM1 ); + VM_CheckEmptyString( name ); + VM_CheckEmptyString( URI ); + + instance = CL_Gecko_FindBrowser( name ); + if( !instance ) { + return; + } + CL_Gecko_NavigateToURI( instance, URI ); +} + +/* +======================== +VM_gecko_keyevent + +float[bool] gecko_keyevent( string name, float key, float eventtype ) +======================== +*/ +void VM_gecko_keyevent( void ) { + const char *name; + unsigned int key; + clgecko_buttoneventtype_t eventtype; + clgecko_t *instance; + + VM_SAFEPARMCOUNT( 3, VM_gecko_keyevent ); + + name = PRVM_G_STRING( OFS_PARM0 ); + VM_CheckEmptyString( name ); + key = (unsigned int) PRVM_G_FLOAT( OFS_PARM1 ); + switch( (unsigned int) PRVM_G_FLOAT( OFS_PARM2 ) ) { + case 0: + eventtype = CLG_BET_DOWN; + break; + case 1: + eventtype = CLG_BET_UP; + break; + case 2: + eventtype = CLG_BET_PRESS; + break; + case 3: + eventtype = CLG_BET_DOUBLECLICK; + break; + default: + // TODO: console printf? [12/3/2007 Black] + PRVM_G_FLOAT( OFS_RETURN ) = 0; + return; + } + + instance = CL_Gecko_FindBrowser( name ); + if( !instance ) { + PRVM_G_FLOAT( OFS_RETURN ) = 0; + return; + } + + PRVM_G_FLOAT( OFS_RETURN ) = (CL_Gecko_Event_Key( instance, (keynum_t) key, eventtype ) == true); +} + +/* +======================== +VM_gecko_movemouse + +void gecko_mousemove( string name, float x, float y ) +======================== +*/ +void VM_gecko_movemouse( void ) { + const char *name; + float x, y; + clgecko_t *instance; + + VM_SAFEPARMCOUNT( 3, VM_gecko_movemouse ); + + name = PRVM_G_STRING( OFS_PARM0 ); + VM_CheckEmptyString( name ); + x = PRVM_G_FLOAT( OFS_PARM1 ); + y = PRVM_G_FLOAT( OFS_PARM2 ); + + instance = CL_Gecko_FindBrowser( name ); + if( !instance ) { + return; + } + CL_Gecko_Event_CursorMove( instance, x, y ); +} + + +/* +======================== +VM_gecko_resize + +void gecko_resize( string name, float w, float h ) +======================== +*/ +void VM_gecko_resize( void ) { + const char *name; + float w, h; + clgecko_t *instance; + + VM_SAFEPARMCOUNT( 3, VM_gecko_movemouse ); + + name = PRVM_G_STRING( OFS_PARM0 ); + VM_CheckEmptyString( name ); + w = PRVM_G_FLOAT( OFS_PARM1 ); + h = PRVM_G_FLOAT( OFS_PARM2 ); + + instance = CL_Gecko_FindBrowser( name ); + if( !instance ) { + return; + } + CL_Gecko_Resize( instance, (int) w, (int) h ); +} + + +/* +======================== +VM_gecko_get_texture_extent + +vector gecko_get_texture_extent( string name ) +======================== +*/ +void VM_gecko_get_texture_extent( void ) { + const char *name; + clgecko_t *instance; + + VM_SAFEPARMCOUNT( 1, VM_gecko_movemouse ); + + name = PRVM_G_STRING( OFS_PARM0 ); + VM_CheckEmptyString( name ); + + PRVM_G_VECTOR(OFS_RETURN)[2] = 0; + instance = CL_Gecko_FindBrowser( name ); + if( !instance ) { + PRVM_G_VECTOR(OFS_RETURN)[0] = 0; + PRVM_G_VECTOR(OFS_RETURN)[1] = 0; + return; + } + CL_Gecko_GetTextureExtent( instance, + PRVM_G_VECTOR(OFS_RETURN), PRVM_G_VECTOR(OFS_RETURN)+1 ); +} + + + +/* +============== +VM_makevectors + +Writes new values for v_forward, v_up, and v_right based on angles +void makevectors(vector angle) +============== +*/ +void VM_makevectors (void) +{ + prvm_eval_t *valforward, *valright, *valup; + valforward = PRVM_GLOBALFIELDVALUE(prog->globaloffsets.v_forward); + valright = PRVM_GLOBALFIELDVALUE(prog->globaloffsets.v_right); + valup = PRVM_GLOBALFIELDVALUE(prog->globaloffsets.v_up); + if (!valforward || !valright || !valup) + { + VM_Warning("makevectors: could not find v_forward, v_right, or v_up global variables\n"); + return; + } + VM_SAFEPARMCOUNT(1, VM_makevectors); + AngleVectors (PRVM_G_VECTOR(OFS_PARM0), valforward->vector, valright->vector, valup->vector); +} + +/* +============== +VM_vectorvectors + +Writes new values for v_forward, v_up, and v_right based on the given forward vector +vectorvectors(vector) +============== +*/ +void VM_vectorvectors (void) +{ + prvm_eval_t *valforward, *valright, *valup; + valforward = PRVM_GLOBALFIELDVALUE(prog->globaloffsets.v_forward); + valright = PRVM_GLOBALFIELDVALUE(prog->globaloffsets.v_right); + valup = PRVM_GLOBALFIELDVALUE(prog->globaloffsets.v_up); + if (!valforward || !valright || !valup) + { + VM_Warning("vectorvectors: could not find v_forward, v_right, or v_up global variables\n"); + return; + } + VM_SAFEPARMCOUNT(1, VM_vectorvectors); + VectorNormalize2(PRVM_G_VECTOR(OFS_PARM0), valforward->vector); + VectorVectors(valforward->vector, valright->vector, valup->vector); +} + +/* +======================== +VM_drawline + +void drawline(float width, vector pos1, vector pos2, vector rgb, float alpha, float flags) +======================== +*/ +void VM_drawline (void) +{ + float *c1, *c2, *rgb; + float alpha, width; + unsigned char flags; + + VM_SAFEPARMCOUNT(6, VM_drawline); + width = PRVM_G_FLOAT(OFS_PARM0); + c1 = PRVM_G_VECTOR(OFS_PARM1); + c2 = PRVM_G_VECTOR(OFS_PARM2); + rgb = PRVM_G_VECTOR(OFS_PARM3); + alpha = PRVM_G_FLOAT(OFS_PARM4); + flags = (int)PRVM_G_FLOAT(OFS_PARM5); + DrawQ_Line(width, c1[0], c1[1], c2[0], c2[1], rgb[0], rgb[1], rgb[2], alpha, flags); +} + +// float(float number, float quantity) bitshift (EXT_BITSHIFT) +void VM_bitshift (void) +{ + int n1, n2; + VM_SAFEPARMCOUNT(2, VM_bitshift); + + n1 = (int)fabs((float)((int)PRVM_G_FLOAT(OFS_PARM0))); + n2 = (int)PRVM_G_FLOAT(OFS_PARM1); + if(!n1) + PRVM_G_FLOAT(OFS_RETURN) = n1; + else + if(n2 < 0) + PRVM_G_FLOAT(OFS_RETURN) = (n1 >> -n2); + else + PRVM_G_FLOAT(OFS_RETURN) = (n1 << n2); +} + +//////////////////////////////////////// +// 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 == '\\' ) { + if( !*++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 *out; + const char *instr, *in; + int size; + char outstr[VM_STRINGTEMP_LENGTH]; + + VM_SAFEPARMCOUNT( 1, VM_altstr_prepare ); + + instr = PRVM_G_STRING( OFS_PARM0 ); + + for( out = outstr, in = instr, size = sizeof(outstr) - 1 ; size && *in ; size--, in++, out++ ) + if( *in == '\'' ) { + *out++ = '\\'; + *out = '\''; + size--; + } else + *out = *in; + *out = 0; + + PRVM_G_INT( OFS_RETURN ) = PRVM_SetTempString( outstr ); +} + +/* +======================== +VM_altstr_get + +string altstr_get(string, float) +======================== +*/ +void VM_altstr_get( void ) +{ + const char *altstr, *pos; + char *out; + int count, size; + char outstr[VM_STRINGTEMP_LENGTH]; + + VM_SAFEPARMCOUNT( 2, VM_altstr_get ); + + altstr = PRVM_G_STRING( OFS_PARM0 ); + + count = (int)PRVM_G_FLOAT( OFS_PARM1 ); + count = count * 2 + 1; + + for( pos = altstr ; *pos && count ; pos++ ) + if( *pos == '\\' ) { + if( !*++pos ) + break; + } else if( *pos == '\'' ) + count--; + + if( !*pos ) { + PRVM_G_INT( OFS_RETURN ) = 0; + return; + } + + for( out = outstr, size = sizeof(outstr) - 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_SetTempString( 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 *out; + char outstr[VM_STRINGTEMP_LENGTH]; + + VM_SAFEPARMCOUNT( 3, VM_altstr_set ); + + altstr = PRVM_G_STRING( OFS_PARM0 ); + + num = (int)PRVM_G_FLOAT( OFS_PARM1 ); + + str = PRVM_G_STRING( OFS_PARM2 ); + + out = outstr; + for( num = num * 2 + 1, in = altstr; *in && num; *out++ = *in++ ) + if( *in == '\\' ) { + if( !*++in ) { + break; + } + } else if( *in == '\'' ) { + num--; + } + + // copy set in + for( ; *str; *out++ = *str++ ); + // now jump over the old content + for( ; *in ; in++ ) + if( *in == '\'' || (*in == '\\' && !*++in) ) + break; + + strlcpy(out, in, outstr + sizeof(outstr) - out); + PRVM_G_INT( OFS_RETURN ) = PRVM_SetTempString( 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 *set; + const char *in; + char *out; + char outstr[VM_STRINGTEMP_LENGTH]; + + VM_SAFEPARMCOUNT(3, VM_altstr_ins); + + in = PRVM_G_STRING( OFS_PARM0 ); + num = (int)PRVM_G_FLOAT( OFS_PARM1 ); + set = PRVM_G_STRING( OFS_PARM2 ); + + out = outstr; + for( num = num * 2 + 2 ; *in && num > 0 ; *out++ = *in++ ) + if( *in == '\\' ) { + if( !*++in ) { + break; + } + } else if( *in == '\'' ) { + num--; + } + + *out++ = '\''; + for( ; *set ; *out++ = *set++ ); + *out++ = '\''; + + strlcpy(out, in, outstr + sizeof(outstr) - out); + PRVM_G_INT( OFS_RETURN ) = PRVM_SetTempString( outstr ); +} + + +//////////////////////////////////////// +// BufString functions +//////////////////////////////////////// +//[515]: string buffers support + +static size_t stringbuffers_sortlength; + +static void BufStr_Expand(prvm_stringbuffer_t *stringbuffer, int strindex) +{ + if (stringbuffer->max_strings <= strindex) + { + char **oldstrings = stringbuffer->strings; + stringbuffer->max_strings = max(stringbuffer->max_strings * 2, 128); + while (stringbuffer->max_strings <= strindex) + stringbuffer->max_strings *= 2; + stringbuffer->strings = (char **) Mem_Alloc(prog->progs_mempool, stringbuffer->max_strings * sizeof(stringbuffer->strings[0])); + if (stringbuffer->num_strings > 0) + memcpy(stringbuffer->strings, oldstrings, stringbuffer->num_strings * sizeof(stringbuffer->strings[0])); + if (oldstrings) + Mem_Free(oldstrings); + } +} + +static void BufStr_Shrink(prvm_stringbuffer_t *stringbuffer) +{ + // reduce num_strings if there are empty string slots at the end + while (stringbuffer->num_strings > 0 && stringbuffer->strings[stringbuffer->num_strings - 1] == NULL) + stringbuffer->num_strings--; + + // if empty, free the string pointer array + if (stringbuffer->num_strings == 0) + { + stringbuffer->max_strings = 0; + if (stringbuffer->strings) + Mem_Free(stringbuffer->strings); + stringbuffer->strings = NULL; + } +} + +static int BufStr_SortStringsUP (const void *in1, const void *in2) +{ + const char *a, *b; + a = *((const char **) in1); + b = *((const char **) in2); + if(!a[0]) return 1; + if(!b[0]) return -1; + return strncmp(a, b, stringbuffers_sortlength); +} + +static int BufStr_SortStringsDOWN (const void *in1, const void *in2) +{ + const char *a, *b; + a = *((const char **) in1); + b = *((const char **) in2); + if(!a[0]) return 1; + if(!b[0]) return -1; + return strncmp(b, a, stringbuffers_sortlength); +} + +/* +======================== +VM_buf_create +creates new buffer, and returns it's index, returns -1 if failed +float buf_create(void) = #460; +======================== +*/ +void VM_buf_create (void) +{ + prvm_stringbuffer_t *stringbuffer; + int i; + VM_SAFEPARMCOUNT(0, VM_buf_create); + stringbuffer = (prvm_stringbuffer_t *) Mem_ExpandableArray_AllocRecord(&prog->stringbuffersarray); + for (i = 0;stringbuffer != Mem_ExpandableArray_RecordAtIndex(&prog->stringbuffersarray, i);i++); + stringbuffer->origin = PRVM_AllocationOrigin(); + PRVM_G_FLOAT(OFS_RETURN) = i; +} + +/* +======================== +VM_buf_del +deletes buffer and all strings in it +void buf_del(float bufhandle) = #461; +======================== +*/ +void VM_buf_del (void) +{ + prvm_stringbuffer_t *stringbuffer; + VM_SAFEPARMCOUNT(1, VM_buf_del); + stringbuffer = (prvm_stringbuffer_t *)Mem_ExpandableArray_RecordAtIndex(&prog->stringbuffersarray, (int)PRVM_G_FLOAT(OFS_PARM0)); + if (stringbuffer) + { + int i; + for (i = 0;i < stringbuffer->num_strings;i++) + if (stringbuffer->strings[i]) + Mem_Free(stringbuffer->strings[i]); + if (stringbuffer->strings) + Mem_Free(stringbuffer->strings); + if(stringbuffer->origin) + PRVM_Free((char *)stringbuffer->origin); + Mem_ExpandableArray_FreeRecord(&prog->stringbuffersarray, stringbuffer); + } + else + { + VM_Warning("VM_buf_del: invalid buffer %i used in %s\n", (int)PRVM_G_FLOAT(OFS_PARM0), PRVM_NAME); + return; + } } /* ======================== -VM_cin_setstate -void cin_setstate(string name, float type) +VM_buf_getsize +how many strings are stored in buffer +float buf_getsize(float bufhandle) = #462; ======================== */ -void VM_cin_setstate( void ) +void VM_buf_getsize (void) { - char *name; - clvideostate_t state; - clvideo_t *video; + prvm_stringbuffer_t *stringbuffer; + VM_SAFEPARMCOUNT(1, VM_buf_getsize); - VM_SAFEPARMCOUNT( 2, VM_cin_netstate ); + stringbuffer = (prvm_stringbuffer_t *)Mem_ExpandableArray_RecordAtIndex(&prog->stringbuffersarray, (int)PRVM_G_FLOAT(OFS_PARM0)); + if(!stringbuffer) + { + PRVM_G_FLOAT(OFS_RETURN) = -1; + VM_Warning("VM_buf_getsize: invalid buffer %i used in %s\n", (int)PRVM_G_FLOAT(OFS_PARM0), PRVM_NAME); + return; + } + else + PRVM_G_FLOAT(OFS_RETURN) = stringbuffer->num_strings; +} - name = PRVM_G_STRING( OFS_PARM0 ); - VM_CheckEmptyString( name ); +/* +======================== +VM_buf_copy +copy all content from one buffer to another, make sure it exists +void buf_copy(float bufhandle_from, float bufhandle_to) = #463; +======================== +*/ +void VM_buf_copy (void) +{ + prvm_stringbuffer_t *srcstringbuffer, *dststringbuffer; + int i; + VM_SAFEPARMCOUNT(2, VM_buf_copy); + + srcstringbuffer = (prvm_stringbuffer_t *)Mem_ExpandableArray_RecordAtIndex(&prog->stringbuffersarray, (int)PRVM_G_FLOAT(OFS_PARM0)); + if(!srcstringbuffer) + { + VM_Warning("VM_buf_copy: invalid source buffer %i used in %s\n", (int)PRVM_G_FLOAT(OFS_PARM0), PRVM_NAME); + return; + } + i = (int)PRVM_G_FLOAT(OFS_PARM1); + if(i == (int)PRVM_G_FLOAT(OFS_PARM0)) + { + VM_Warning("VM_buf_copy: source == destination (%i) in %s\n", i, PRVM_NAME); + return; + } + dststringbuffer = (prvm_stringbuffer_t *)Mem_ExpandableArray_RecordAtIndex(&prog->stringbuffersarray, (int)PRVM_G_FLOAT(OFS_PARM0)); + if(!dststringbuffer) + { + VM_Warning("VM_buf_copy: invalid destination buffer %i used in %s\n", (int)PRVM_G_FLOAT(OFS_PARM1), PRVM_NAME); + return; + } - state = PRVM_G_FLOAT( OFS_PARM1 ); + for (i = 0;i < dststringbuffer->num_strings;i++) + if (dststringbuffer->strings[i]) + Mem_Free(dststringbuffer->strings[i]); + if (dststringbuffer->strings) + Mem_Free(dststringbuffer->strings); + *dststringbuffer = *srcstringbuffer; + if (dststringbuffer->max_strings) + dststringbuffer->strings = (char **)Mem_Alloc(prog->progs_mempool, sizeof(dststringbuffer->strings[0]) * dststringbuffer->max_strings); - video = CL_GetVideo( name ); - if( video && state > CLVIDEO_UNUSED && state < CLVIDEO_STATECOUNT ) - CL_SetVideoState( video, state ); + for (i = 0;i < dststringbuffer->num_strings;i++) + { + if (srcstringbuffer->strings[i]) + { + size_t stringlen; + stringlen = strlen(srcstringbuffer->strings[i]) + 1; + dststringbuffer->strings[i] = (char *)Mem_Alloc(prog->progs_mempool, stringlen); + memcpy(dststringbuffer->strings[i], srcstringbuffer->strings[i], stringlen); + } + } } /* ======================== -VM_cin_getstate +VM_buf_sort +sort buffer by beginnings of strings (cmplength defaults it's length) +"backward == TRUE" means that sorting goes upside-down +void buf_sort(float bufhandle, float cmplength, float backward) = #464; +======================== +*/ +void VM_buf_sort (void) +{ + prvm_stringbuffer_t *stringbuffer; + VM_SAFEPARMCOUNT(3, VM_buf_sort); -float cin_getstate(string name) + stringbuffer = (prvm_stringbuffer_t *)Mem_ExpandableArray_RecordAtIndex(&prog->stringbuffersarray, (int)PRVM_G_FLOAT(OFS_PARM0)); + if(!stringbuffer) + { + VM_Warning("VM_buf_sort: invalid buffer %i used in %s\n", (int)PRVM_G_FLOAT(OFS_PARM0), PRVM_NAME); + return; + } + if(stringbuffer->num_strings <= 0) + { + VM_Warning("VM_buf_sort: tried to sort empty buffer %i in %s\n", (int)PRVM_G_FLOAT(OFS_PARM0), PRVM_NAME); + return; + } + stringbuffers_sortlength = (int)PRVM_G_FLOAT(OFS_PARM1); + if(stringbuffers_sortlength <= 0) + stringbuffers_sortlength = 0x7FFFFFFF; + + if(!PRVM_G_FLOAT(OFS_PARM2)) + qsort(stringbuffer->strings, stringbuffer->num_strings, sizeof(char*), BufStr_SortStringsUP); + else + qsort(stringbuffer->strings, stringbuffer->num_strings, sizeof(char*), BufStr_SortStringsDOWN); + + BufStr_Shrink(stringbuffer); +} + +/* +======================== +VM_buf_implode +concantenates all buffer string into one with "glue" separator and returns it as tempstring +string buf_implode(float bufhandle, string glue) = #465; ======================== */ -void VM_cin_getstate( void ) +void VM_buf_implode (void) { - char *name; - clvideo_t *video; + prvm_stringbuffer_t *stringbuffer; + char k[VM_STRINGTEMP_LENGTH]; + const char *sep; + int i; + size_t l; + VM_SAFEPARMCOUNT(2, VM_buf_implode); - VM_SAFEPARMCOUNT( 1, VM_cin_getstate ); + stringbuffer = (prvm_stringbuffer_t *)Mem_ExpandableArray_RecordAtIndex(&prog->stringbuffersarray, (int)PRVM_G_FLOAT(OFS_PARM0)); + PRVM_G_INT(OFS_RETURN) = OFS_NULL; + if(!stringbuffer) + { + VM_Warning("VM_buf_implode: invalid buffer %i used in %s\n", (int)PRVM_G_FLOAT(OFS_PARM0), PRVM_NAME); + return; + } + if(!stringbuffer->num_strings) + return; + sep = PRVM_G_STRING(OFS_PARM1); + k[0] = 0; + for(l = i = 0;i < stringbuffer->num_strings;i++) + { + if(stringbuffer->strings[i]) + { + l += (i > 0 ? strlen(sep) : 0) + strlen(stringbuffer->strings[i]); + if (l >= sizeof(k) - 1) + break; + strlcat(k, sep, sizeof(k)); + strlcat(k, stringbuffer->strings[i], sizeof(k)); + } + } + PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(k); +} - name = PRVM_G_STRING( OFS_PARM0 ); - VM_CheckEmptyString( name ); +/* +======================== +VM_bufstr_get +get a string from buffer, returns tempstring, dont str_unzone it! +string bufstr_get(float bufhandle, float string_index) = #465; +======================== +*/ +void VM_bufstr_get (void) +{ + prvm_stringbuffer_t *stringbuffer; + int strindex; + VM_SAFEPARMCOUNT(2, VM_bufstr_get); - video = CL_GetVideo( name ); - if( video ) - PRVM_G_FLOAT( OFS_RETURN ) = (int)video->state; - else - PRVM_G_FLOAT( OFS_RETURN ) = 0; + PRVM_G_INT(OFS_RETURN) = OFS_NULL; + stringbuffer = (prvm_stringbuffer_t *)Mem_ExpandableArray_RecordAtIndex(&prog->stringbuffersarray, (int)PRVM_G_FLOAT(OFS_PARM0)); + if(!stringbuffer) + { + VM_Warning("VM_bufstr_get: invalid buffer %i used in %s\n", (int)PRVM_G_FLOAT(OFS_PARM0), PRVM_NAME); + return; + } + strindex = (int)PRVM_G_FLOAT(OFS_PARM1); + if (strindex < 0) + { + VM_Warning("VM_bufstr_get: invalid string index %i used in %s\n", strindex, PRVM_NAME); + return; + } + if (strindex < stringbuffer->num_strings && stringbuffer->strings[strindex]) + PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(stringbuffer->strings[strindex]); } /* ======================== -VM_cin_restart +VM_bufstr_set +copies a string into selected slot of buffer +void bufstr_set(float bufhandle, float string_index, string str) = #466; +======================== +*/ +void VM_bufstr_set (void) +{ + int strindex; + prvm_stringbuffer_t *stringbuffer; + const char *news; -void cin_restart(string name) + VM_SAFEPARMCOUNT(3, VM_bufstr_set); + + stringbuffer = (prvm_stringbuffer_t *)Mem_ExpandableArray_RecordAtIndex(&prog->stringbuffersarray, (int)PRVM_G_FLOAT(OFS_PARM0)); + if(!stringbuffer) + { + VM_Warning("VM_bufstr_set: invalid buffer %i used in %s\n", (int)PRVM_G_FLOAT(OFS_PARM0), PRVM_NAME); + return; + } + strindex = (int)PRVM_G_FLOAT(OFS_PARM1); + if(strindex < 0 || strindex >= 1000000) // huge number of strings + { + VM_Warning("VM_bufstr_set: invalid string index %i used in %s\n", strindex, PRVM_NAME); + return; + } + + BufStr_Expand(stringbuffer, strindex); + stringbuffer->num_strings = max(stringbuffer->num_strings, strindex + 1); + + if(stringbuffer->strings[strindex]) + Mem_Free(stringbuffer->strings[strindex]); + stringbuffer->strings[strindex] = NULL; + + news = PRVM_G_STRING(OFS_PARM2); + if (news && news[0]) + { + size_t alloclen = strlen(news) + 1; + stringbuffer->strings[strindex] = (char *)Mem_Alloc(prog->progs_mempool, alloclen); + memcpy(stringbuffer->strings[strindex], news, alloclen); + } + + BufStr_Shrink(stringbuffer); +} + +/* +======================== +VM_bufstr_add +adds string to buffer in first free slot and returns its index +"order == TRUE" means that string will be added after last "full" slot +float bufstr_add(float bufhandle, string str, float order) = #467; ======================== */ -void VM_cin_restart( void ) +void VM_bufstr_add (void) { - char *name; - clvideo_t *video; + int order, strindex; + prvm_stringbuffer_t *stringbuffer; + const char *string; + size_t alloclen; - VM_SAFEPARMCOUNT( 1, VM_cin_restart ); + VM_SAFEPARMCOUNT(3, VM_bufstr_add); - name = PRVM_G_STRING( OFS_PARM0 ); - VM_CheckEmptyString( name ); + stringbuffer = (prvm_stringbuffer_t *)Mem_ExpandableArray_RecordAtIndex(&prog->stringbuffersarray, (int)PRVM_G_FLOAT(OFS_PARM0)); + PRVM_G_FLOAT(OFS_RETURN) = -1; + if(!stringbuffer) + { + VM_Warning("VM_bufstr_add: invalid buffer %i used in %s\n", (int)PRVM_G_FLOAT(OFS_PARM0), PRVM_NAME); + return; + } + string = PRVM_G_STRING(OFS_PARM1); + if(!string || !string[0]) + { + VM_Warning("VM_bufstr_add: can not add an empty string to buffer %i in %s\n", (int)PRVM_G_FLOAT(OFS_PARM0), PRVM_NAME); + return; + } + order = (int)PRVM_G_FLOAT(OFS_PARM2); + if(order) + strindex = stringbuffer->num_strings; + else + for (strindex = 0;strindex < stringbuffer->num_strings;strindex++) + if (stringbuffer->strings[strindex] == NULL) + break; - video = CL_GetVideo( name ); - if( video ) - CL_RestartVideo( video ); + BufStr_Expand(stringbuffer, strindex); + + stringbuffer->num_strings = max(stringbuffer->num_strings, strindex + 1); + alloclen = strlen(string) + 1; + stringbuffer->strings[strindex] = (char *)Mem_Alloc(prog->progs_mempool, alloclen); + memcpy(stringbuffer->strings[strindex], string, alloclen); + + PRVM_G_FLOAT(OFS_RETURN) = strindex; } -//////////////////////////////////////// -// AltString functions -//////////////////////////////////////// +/* +======================== +VM_bufstr_free +delete string from buffer +void bufstr_free(float bufhandle, float string_index) = #468; +======================== +*/ +void VM_bufstr_free (void) +{ + int i; + prvm_stringbuffer_t *stringbuffer; + VM_SAFEPARMCOUNT(2, VM_bufstr_free); + + stringbuffer = (prvm_stringbuffer_t *)Mem_ExpandableArray_RecordAtIndex(&prog->stringbuffersarray, (int)PRVM_G_FLOAT(OFS_PARM0)); + if(!stringbuffer) + { + VM_Warning("VM_bufstr_free: invalid buffer %i used in %s\n", (int)PRVM_G_FLOAT(OFS_PARM0), PRVM_NAME); + return; + } + i = (int)PRVM_G_FLOAT(OFS_PARM1); + if(i < 0) + { + VM_Warning("VM_bufstr_free: invalid string index %i used in %s\n", i, PRVM_NAME); + return; + } + + if (i < stringbuffer->num_strings) + { + if(stringbuffer->strings[i]) + Mem_Free(stringbuffer->strings[i]); + stringbuffer->strings[i] = NULL; + } + + BufStr_Shrink(stringbuffer); +} + + + + + + + +void VM_buf_cvarlist(void) +{ + cvar_t *cvar; + const char *partial, *antipartial; + size_t len, antilen; + size_t alloclen; + qboolean ispattern, antiispattern; + int n; + prvm_stringbuffer_t *stringbuffer; + VM_SAFEPARMCOUNTRANGE(2, 3, VM_buf_cvarlist); + + stringbuffer = (prvm_stringbuffer_t *)Mem_ExpandableArray_RecordAtIndex(&prog->stringbuffersarray, (int)PRVM_G_FLOAT(OFS_PARM0)); + if(!stringbuffer) + { + VM_Warning("VM_bufstr_free: invalid buffer %i used in %s\n", (int)PRVM_G_FLOAT(OFS_PARM0), PRVM_NAME); + return; + } + + partial = PRVM_G_STRING(OFS_PARM1); + if(!partial) + len = 0; + else + len = strlen(partial); + + if(prog->argc == 3) + antipartial = PRVM_G_STRING(OFS_PARM2); + else + antipartial = NULL; + if(!antipartial) + antilen = 0; + else + antilen = strlen(antipartial); + + for (n = 0;n < stringbuffer->num_strings;n++) + if (stringbuffer->strings[n]) + Mem_Free(stringbuffer->strings[n]); + if (stringbuffer->strings) + Mem_Free(stringbuffer->strings); + stringbuffer->strings = NULL; + + ispattern = partial && (strchr(partial, '*') || strchr(partial, '?')); + antiispattern = antipartial && (strchr(antipartial, '*') || strchr(antipartial, '?')); + + n = 0; + for(cvar = cvar_vars; cvar; cvar = cvar->next) + { + if(len && (ispattern ? !matchpattern_with_separator(cvar->name, partial, false, "", false) : strncmp(partial, cvar->name, len))) + continue; + + if(antilen && (antiispattern ? matchpattern_with_separator(cvar->name, antipartial, false, "", false) : !strncmp(antipartial, cvar->name, antilen))) + continue; + + ++n; + } + + stringbuffer->max_strings = stringbuffer->num_strings = n; + if (stringbuffer->max_strings) + stringbuffer->strings = (char **)Mem_Alloc(prog->progs_mempool, sizeof(stringbuffer->strings[0]) * stringbuffer->max_strings); + + n = 0; + for(cvar = cvar_vars; cvar; cvar = cvar->next) + { + if(len && (ispattern ? !matchpattern_with_separator(cvar->name, partial, false, "", false) : strncmp(partial, cvar->name, len))) + continue; + + if(antilen && (antiispattern ? matchpattern_with_separator(cvar->name, antipartial, false, "", false) : !strncmp(antipartial, cvar->name, antilen))) + continue; + + alloclen = strlen(cvar->name) + 1; + stringbuffer->strings[n] = (char *)Mem_Alloc(prog->progs_mempool, alloclen); + memcpy(stringbuffer->strings[n], cvar->name, alloclen); + + ++n; + } +} + + + + +//============= + +/* +============== +VM_changeyaw + +This was a major timewaster in progs, so it was converted to C +============== +*/ +void VM_changeyaw (void) +{ + prvm_edict_t *ent; + float ideal, current, move, speed; + + // this is called (VERY HACKISHLY) by SV_MoveToGoal, so it can not use any + // parameters because they are the parameters to SV_MoveToGoal, not this + //VM_SAFEPARMCOUNT(0, VM_changeyaw); + + ent = PRVM_PROG_TO_EDICT(PRVM_GLOBALFIELDVALUE(prog->globaloffsets.self)->edict); + if (ent == prog->edicts) + { + VM_Warning("changeyaw: can not modify world entity\n"); + return; + } + if (ent->priv.server->free) + { + VM_Warning("changeyaw: can not modify free entity\n"); + return; + } + if (prog->fieldoffsets.angles < 0 || prog->fieldoffsets.ideal_yaw < 0 || prog->fieldoffsets.yaw_speed < 0) + { + VM_Warning("changeyaw: angles, ideal_yaw, or yaw_speed field(s) not found\n"); + return; + } + current = ANGLEMOD(PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.angles)->vector[1]); + ideal = PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.ideal_yaw)->_float; + speed = PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.yaw_speed)->_float; + + if (current == ideal) + return; + move = ideal - current; + if (ideal > current) + { + if (move >= 180) + move = move - 360; + } + else + { + if (move <= -180) + move = move + 360; + } + if (move > 0) + { + if (move > speed) + move = speed; + } + else + { + if (move < -speed) + move = -speed; + } + + PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.angles)->vector[1] = ANGLEMOD (current + move); +} + +/* +============== +VM_changepitch +============== +*/ +void VM_changepitch (void) +{ + prvm_edict_t *ent; + float ideal, current, move, speed; + + VM_SAFEPARMCOUNT(1, VM_changepitch); + + ent = PRVM_G_EDICT(OFS_PARM0); + if (ent == prog->edicts) + { + VM_Warning("changepitch: can not modify world entity\n"); + return; + } + if (ent->priv.server->free) + { + VM_Warning("changepitch: can not modify free entity\n"); + return; + } + if (prog->fieldoffsets.angles < 0 || prog->fieldoffsets.idealpitch < 0 || prog->fieldoffsets.pitch_speed < 0) + { + VM_Warning("changepitch: angles, idealpitch, or pitch_speed field(s) not found\n"); + return; + } + current = ANGLEMOD(PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.angles)->vector[0]); + ideal = PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.idealpitch)->_float; + speed = PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.pitch_speed)->_float; + + if (current == ideal) + return; + move = ideal - current; + if (ideal > current) + { + if (move >= 180) + move = move - 360; + } + else + { + if (move <= -180) + move = move + 360; + } + if (move > 0) + { + if (move > speed) + move = speed; + } + else + { + if (move < -speed) + move = -speed; + } + + PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.angles)->vector[0] = ANGLEMOD (current + move); +} -/* -======================== -VM_altstr_count -float altstr_count(string) -======================== -*/ -void VM_altstr_count( void ) +void VM_uncolorstring (void) { - char *altstr, *pos; - int count; + char szNewString[VM_STRINGTEMP_LENGTH]; + const char *szString; - VM_SAFEPARMCOUNT( 1, VM_altstr_count ); + // Prepare Strings + VM_SAFEPARMCOUNT(1, VM_uncolorstring); + szString = PRVM_G_STRING(OFS_PARM0); + COM_StringDecolorize(szString, 0, szNewString, sizeof(szNewString), TRUE); + PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(szNewString); + +} - altstr = PRVM_G_STRING( OFS_PARM0 ); - //VM_CheckEmptyString( altstr ); +// #221 float(string str, string sub[, float startpos]) strstrofs (FTE_STRINGS) +//strstr, without generating a new string. Use in conjunction with FRIK_FILE's substring for more similar strstr. +void VM_strstrofs (void) +{ + const char *instr, *match; + int firstofs; + VM_SAFEPARMCOUNTRANGE(2, 3, VM_strstrofs); + instr = PRVM_G_STRING(OFS_PARM0); + match = PRVM_G_STRING(OFS_PARM1); + firstofs = (prog->argc > 2)?(int)PRVM_G_FLOAT(OFS_PARM2):0; + firstofs = u8_bytelen(instr, firstofs); - for( count = 0, pos = altstr ; *pos ; pos++ ) - if( *pos == '\\' && !*++pos ) - break; - else if( *pos == '\'' ) - count++; + if (firstofs && (firstofs < 0 || firstofs > (int)strlen(instr))) + { + PRVM_G_FLOAT(OFS_RETURN) = -1; + return; + } - PRVM_G_FLOAT( OFS_RETURN ) = (float) (count / 2); + match = strstr(instr+firstofs, match); + if (!match) + PRVM_G_FLOAT(OFS_RETURN) = -1; + else + PRVM_G_FLOAT(OFS_RETURN) = match - instr; } -/* -======================== -VM_altstr_prepare - -string altstr_prepare(string) -======================== -*/ -void VM_altstr_prepare( void ) +//#222 string(string s, float index) str2chr (FTE_STRINGS) +void VM_str2chr (void) { - char *outstr, *out; - char *instr, *in; - int size; - - VM_SAFEPARMCOUNT( 1, VM_altstr_prepare ); - - instr = PRVM_G_STRING( OFS_PARM0 ); - //VM_CheckEmptyString( instr ); - outstr = VM_GetTempString(); + const char *s; + Uchar ch; + int index; + VM_SAFEPARMCOUNT(2, VM_str2chr); + s = PRVM_G_STRING(OFS_PARM0); + index = u8_bytelen(s, (int)PRVM_G_FLOAT(OFS_PARM1)); - 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; + if((unsigned)index < strlen(s)) + { + if (utf8_enable.integer) + ch = u8_getchar_noendptr(s + index); + else + ch = (unsigned char)s[index]; + PRVM_G_FLOAT(OFS_RETURN) = ch; + } + else + PRVM_G_FLOAT(OFS_RETURN) = 0; +} - PRVM_G_INT( OFS_RETURN ) = PRVM_SetString( outstr ); +//#223 string(float c, ...) chr2str (FTE_STRINGS) +void VM_chr2str (void) +{ + /* + char t[9]; + int i; + VM_SAFEPARMCOUNTRANGE(0, 8, VM_chr2str); + for(i = 0;i < prog->argc && i < (int)sizeof(t) - 1;i++) + t[i] = (unsigned char)PRVM_G_FLOAT(OFS_PARM0+i*3); + t[i] = 0; + PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(t); + */ + char t[9 * 4 + 1]; + int i; + size_t len = 0; + VM_SAFEPARMCOUNTRANGE(0, 8, VM_chr2str); + for(i = 0; i < prog->argc && len < sizeof(t)-1; ++i) + len += u8_fromchar((Uchar)PRVM_G_FLOAT(OFS_PARM0+i*3), t + len, sizeof(t)-1); + t[len] = 0; + PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(t); } -/* -======================== -VM_altstr_get +static int chrconv_number(int i, int base, int conv) +{ + i -= base; + switch (conv) + { + default: + case 5: + case 6: + case 0: + break; + case 1: + base = '0'; + break; + case 2: + base = '0'+128; + break; + case 3: + base = '0'-30; + break; + case 4: + base = '0'+128-30; + break; + } + return i + base; +} +static int chrconv_punct(int i, int base, int conv) +{ + i -= base; + switch (conv) + { + default: + case 0: + break; + case 1: + base = 0; + break; + case 2: + base = 128; + break; + } + return i + base; +} -string altstr_get(string, float) -======================== -*/ -void VM_altstr_get( void ) +static int chrchar_alpha(int i, int basec, int baset, int convc, int convt, int charnum) { - char *altstr, *pos, *outstr, *out; - int count, size; + //convert case and colour seperatly... - VM_SAFEPARMCOUNT( 2, VM_altstr_get ); + i -= baset + basec; + switch (convt) + { + default: + case 0: + break; + case 1: + baset = 0; + break; + case 2: + baset = 128; + break; - altstr = PRVM_G_STRING( OFS_PARM0 ); - //VM_CheckEmptyString( altstr ); + case 5: + case 6: + baset = 128*((charnum&1) == (convt-5)); + break; + } - count = PRVM_G_FLOAT( OFS_PARM1 ); - count = count * 2 + 1; + switch (convc) + { + default: + case 0: + break; + case 1: + basec = 'a'; + break; + case 2: + basec = 'A'; + break; + } + return i + basec + baset; +} +// #224 string(float ccase, float calpha, float cnum, string s, ...) strconv (FTE_STRINGS) +//bulk convert a string. change case or colouring. +void VM_strconv (void) +{ + int ccase, redalpha, rednum, len, i; + unsigned char resbuf[VM_STRINGTEMP_LENGTH]; + unsigned char *result = resbuf; - for( pos = altstr ; *pos && count ; pos++ ) - if( *pos == '\\' && !*++pos ) - break; - else if( *pos == '\'' ) - count--; + VM_SAFEPARMCOUNTRANGE(3, 8, VM_strconv); - if( !*pos ) { - PRVM_G_INT( OFS_RETURN ) = PRVM_SetString( "" ); - return; - } + ccase = (int) PRVM_G_FLOAT(OFS_PARM0); //0 same, 1 lower, 2 upper + redalpha = (int) PRVM_G_FLOAT(OFS_PARM1); //0 same, 1 white, 2 red, 5 alternate, 6 alternate-alternate + rednum = (int) PRVM_G_FLOAT(OFS_PARM2); //0 same, 1 white, 2 red, 3 redspecial, 4 whitespecial, 5 alternate, 6 alternate-alternate + VM_VarString(3, (char *) resbuf, sizeof(resbuf)); + len = strlen((char *) resbuf); - 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; + for (i = 0; i < len; i++, result++) //should this be done backwards? + { + if (*result >= '0' && *result <= '9') //normal numbers... + *result = chrconv_number(*result, '0', rednum); + else if (*result >= '0'+128 && *result <= '9'+128) + *result = chrconv_number(*result, '0'+128, rednum); + else if (*result >= '0'+128-30 && *result <= '9'+128-30) + *result = chrconv_number(*result, '0'+128-30, rednum); + else if (*result >= '0'-30 && *result <= '9'-30) + *result = chrconv_number(*result, '0'-30, rednum); + + else if (*result >= 'a' && *result <= 'z') //normal numbers... + *result = chrchar_alpha(*result, 'a', 0, ccase, redalpha, i); + else if (*result >= 'A' && *result <= 'Z') //normal numbers... + *result = chrchar_alpha(*result, 'A', 0, ccase, redalpha, i); + else if (*result >= 'a'+128 && *result <= 'z'+128) //normal numbers... + *result = chrchar_alpha(*result, 'a', 128, ccase, redalpha, i); + else if (*result >= 'A'+128 && *result <= 'Z'+128) //normal numbers... + *result = chrchar_alpha(*result, 'A', 128, ccase, redalpha, i); + + else if ((*result & 127) < 16 || !redalpha) //special chars.. + *result = *result; + else if (*result < 128) + *result = chrconv_punct(*result, 0, redalpha); else - *out = *pos; + *result = chrconv_punct(*result, 128, redalpha); + } + *result = '\0'; - *out = 0; - PRVM_G_INT( OFS_RETURN ) = PRVM_SetString( outstr ); + PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString((char *) resbuf); } -/* -======================== -VM_altstr_set - -string altstr_set(string altstr, float num, string set) -======================== -*/ -void VM_altstr_set( void ) +// #225 string(float chars, string s, ...) strpad (FTE_STRINGS) +void VM_strpad (void) { - int num; - char *altstr, *str; - char *in; - char *outstr, *out; - - VM_SAFEPARMCOUNT( 3, VM_altstr_set ); + char src[VM_STRINGTEMP_LENGTH]; + char destbuf[VM_STRINGTEMP_LENGTH]; + int pad; + VM_SAFEPARMCOUNTRANGE(1, 8, VM_strpad); + pad = (int) PRVM_G_FLOAT(OFS_PARM0); + VM_VarString(1, src, sizeof(src)); - altstr = PRVM_G_STRING( OFS_PARM0 ); - //VM_CheckEmptyString( altstr ); + // note: < 0 = left padding, > 0 = right padding, + // this is reverse logic of printf! + dpsnprintf(destbuf, sizeof(destbuf), "%*s", -pad, src); - num = PRVM_G_FLOAT( OFS_PARM1 ); + PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(destbuf); +} - str = PRVM_G_STRING( OFS_PARM2 ); - //VM_CheckEmptyString( str ); +// #226 string(string info, string key, string value, ...) infoadd (FTE_STRINGS) +//uses qw style \key\value strings +void VM_infoadd (void) +{ + const char *info, *key; + char value[VM_STRINGTEMP_LENGTH]; + char temp[VM_STRINGTEMP_LENGTH]; - outstr = out = VM_GetTempString(); - for( num = num * 2 + 1, in = altstr; *in && num; *out++ = *in++ ) - if( *in == '\\' && !*++in ) - break; - else if( *in == '\'' ) - num--; + VM_SAFEPARMCOUNTRANGE(2, 8, VM_infoadd); + info = PRVM_G_STRING(OFS_PARM0); + key = PRVM_G_STRING(OFS_PARM1); + VM_VarString(2, value, sizeof(value)); - if( !in ) { - PRVM_G_INT( OFS_RETURN ) = PRVM_SetString( "" ); - return; - } - // copy set in - for( ; *str; *out++ = *str++ ); - // now jump over the old contents - for( ; *in ; in++ ) - if( *in == '\'' || (*in == '\\' && !*++in) ) - break; + strlcpy(temp, info, VM_STRINGTEMP_LENGTH); - if( !in ) { - PRVM_G_INT( OFS_RETURN ) = PRVM_SetString( "" ); - return; - } + InfoString_SetValue(temp, VM_STRINGTEMP_LENGTH, key, value); - strcpy( out, in ); - PRVM_G_INT( OFS_RETURN ) = PRVM_SetString( outstr ); + PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(temp); } -/* -======================== -VM_altstr_ins -insert after num -string altstr_ins(string altstr, float num, string set) -======================== -*/ -void VM_altstr_ins(void) +// #227 string(string info, string key) infoget (FTE_STRINGS) +//uses qw style \key\value strings +void VM_infoget (void) { - int num; - char *setstr; - char *set; - char *instr; - char *in; - char *outstr; - char *out; + const char *info; + const char *key; + char value[VM_STRINGTEMP_LENGTH]; - 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--; + VM_SAFEPARMCOUNT(2, VM_infoget); + info = PRVM_G_STRING(OFS_PARM0); + key = PRVM_G_STRING(OFS_PARM1); - for( ; *set ; *out++ = *set++ ); + InfoString_GetValue(info, key, value, VM_STRINGTEMP_LENGTH); + + PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(value); +} + +//#228 float(string s1, string s2, float len) strncmp (FTE_STRINGS) +// also float(string s1, string s2) strcmp (FRIK_FILE) +void VM_strncmp (void) +{ + const char *s1, *s2; + VM_SAFEPARMCOUNTRANGE(2, 3, VM_strncmp); + s1 = PRVM_G_STRING(OFS_PARM0); + s2 = PRVM_G_STRING(OFS_PARM1); + if (prog->argc > 2) + { + PRVM_G_FLOAT(OFS_RETURN) = strncmp(s1, s2, (size_t)PRVM_G_FLOAT(OFS_PARM2)); + } + else + { + PRVM_G_FLOAT(OFS_RETURN) = strcmp(s1, s2); + } +} - strcpy( out, in ); - PRVM_G_INT( OFS_RETURN ) = PRVM_SetString( outstr ); +// #229 float(string s1, string s2) strcasecmp (FTE_STRINGS) +// #230 float(string s1, string s2, float len) strncasecmp (FTE_STRINGS) +void VM_strncasecmp (void) +{ + const char *s1, *s2; + VM_SAFEPARMCOUNTRANGE(2, 3, VM_strncasecmp); + s1 = PRVM_G_STRING(OFS_PARM0); + s2 = PRVM_G_STRING(OFS_PARM1); + if (prog->argc > 2) + { + PRVM_G_FLOAT(OFS_RETURN) = strncasecmp(s1, s2, (size_t)PRVM_G_FLOAT(OFS_PARM2)); + } + else + { + PRVM_G_FLOAT(OFS_RETURN) = strcasecmp(s1, s2); + } } +// #494 float(float caseinsensitive, string s, ...) crc16 +void VM_crc16(void) +{ + float insensitive; + static char s[VM_STRINGTEMP_LENGTH]; + VM_SAFEPARMCOUNTRANGE(2, 8, VM_hash); + insensitive = PRVM_G_FLOAT(OFS_PARM0); + VM_VarString(1, s, sizeof(s)); + PRVM_G_FLOAT(OFS_RETURN) = (unsigned short) ((insensitive ? CRC_Block_CaseInsensitive : CRC_Block) ((unsigned char *) s, strlen(s))); +} + +void VM_wasfreed (void) +{ + VM_SAFEPARMCOUNT(1, VM_wasfreed); + PRVM_G_FLOAT(OFS_RETURN) = PRVM_G_EDICT(OFS_PARM0)->priv.required->free; +} + +void VM_SetTraceGlobals(const trace_t *trace) +{ + prvm_eval_t *val; + if ((val = PRVM_GLOBALFIELDVALUE(prog->globaloffsets.trace_allsolid))) + val->_float = trace->allsolid; + if ((val = PRVM_GLOBALFIELDVALUE(prog->globaloffsets.trace_startsolid))) + val->_float = trace->startsolid; + if ((val = PRVM_GLOBALFIELDVALUE(prog->globaloffsets.trace_fraction))) + val->_float = trace->fraction; + if ((val = PRVM_GLOBALFIELDVALUE(prog->globaloffsets.trace_inwater))) + val->_float = trace->inwater; + if ((val = PRVM_GLOBALFIELDVALUE(prog->globaloffsets.trace_inopen))) + val->_float = trace->inopen; + if ((val = PRVM_GLOBALFIELDVALUE(prog->globaloffsets.trace_endpos))) + VectorCopy(trace->endpos, val->vector); + if ((val = PRVM_GLOBALFIELDVALUE(prog->globaloffsets.trace_plane_normal))) + VectorCopy(trace->plane.normal, val->vector); + if ((val = PRVM_GLOBALFIELDVALUE(prog->globaloffsets.trace_plane_dist))) + val->_float = trace->plane.dist; + if ((val = PRVM_GLOBALFIELDVALUE(prog->globaloffsets.trace_ent))) + val->edict = PRVM_EDICT_TO_PROG(trace->ent ? trace->ent : prog->edicts); + if ((val = PRVM_GLOBALFIELDVALUE(prog->globaloffsets.trace_dpstartcontents))) + val->_float = trace->startsupercontents; + if ((val = PRVM_GLOBALFIELDVALUE(prog->globaloffsets.trace_dphitcontents))) + val->_float = trace->hitsupercontents; + if ((val = PRVM_GLOBALFIELDVALUE(prog->globaloffsets.trace_dphitq3surfaceflags))) + val->_float = trace->hitq3surfaceflags; + if ((val = PRVM_GLOBALFIELDVALUE(prog->globaloffsets.trace_dphittexturename))) + val->string = trace->hittexture ? PRVM_SetTempString(trace->hittexture->name) : 0; +} + +void VM_ClearTraceGlobals(void) +{ + // clean up all trace globals when leaving the VM (anti-triggerbot safeguard) + prvm_eval_t *val; + if ((val = PRVM_GLOBALFIELDVALUE(prog->globaloffsets.trace_allsolid))) + val->_float = 0; + if ((val = PRVM_GLOBALFIELDVALUE(prog->globaloffsets.trace_startsolid))) + val->_float = 0; + if ((val = PRVM_GLOBALFIELDVALUE(prog->globaloffsets.trace_fraction))) + val->_float = 0; + if ((val = PRVM_GLOBALFIELDVALUE(prog->globaloffsets.trace_inwater))) + val->_float = 0; + if ((val = PRVM_GLOBALFIELDVALUE(prog->globaloffsets.trace_inopen))) + val->_float = 0; + if ((val = PRVM_GLOBALFIELDVALUE(prog->globaloffsets.trace_endpos))) + VectorClear(val->vector); + if ((val = PRVM_GLOBALFIELDVALUE(prog->globaloffsets.trace_plane_normal))) + VectorClear(val->vector); + if ((val = PRVM_GLOBALFIELDVALUE(prog->globaloffsets.trace_plane_dist))) + val->_float = 0; + if ((val = PRVM_GLOBALFIELDVALUE(prog->globaloffsets.trace_ent))) + val->edict = PRVM_EDICT_TO_PROG(prog->edicts); + if ((val = PRVM_GLOBALFIELDVALUE(prog->globaloffsets.trace_dpstartcontents))) + val->_float = 0; + if ((val = PRVM_GLOBALFIELDVALUE(prog->globaloffsets.trace_dphitcontents))) + val->_float = 0; + if ((val = PRVM_GLOBALFIELDVALUE(prog->globaloffsets.trace_dphitq3surfaceflags))) + val->_float = 0; + if ((val = PRVM_GLOBALFIELDVALUE(prog->globaloffsets.trace_dphittexturename))) + val->string = 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), 0, NULL); VM_Files_Init(); VM_Search_Init(); + VM_Gecko_Init(); +// VM_BufStr_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(); + VM_Gecko_Destroy(); +// VM_BufStr_ShutDown(); } -//============================================================================ -// Server - -char *vm_sv_extensions = -""; +// #510 string(string input, ...) uri_escape (DP_QC_URI_ESCAPE) +// does URI escaping on a string (replace evil stuff by %AB escapes) +void VM_uri_escape (void) +{ + char src[VM_STRINGTEMP_LENGTH]; + char dest[VM_STRINGTEMP_LENGTH]; + char *p, *q; + static const char *hex = "0123456789ABCDEF"; -prvm_builtin_t vm_sv_builtins[] = { -0 // to be consistent with the old vm -}; + VM_SAFEPARMCOUNTRANGE(1, 8, VM_uri_escape); + VM_VarString(0, src, sizeof(src)); -const int vm_sv_numbuiltins = sizeof(vm_sv_builtins) / sizeof(prvm_builtin_t); + for(p = src, q = dest; *p && q < dest + sizeof(dest) - 3; ++p) + { + if((*p >= 'A' && *p <= 'Z') + || (*p >= 'a' && *p <= 'z') + || (*p >= '0' && *p <= '9') + || (*p == '-') || (*p == '_') || (*p == '.') + || (*p == '!') || (*p == '~') || (*p == '*') + || (*p == '\'') || (*p == '(') || (*p == ')')) + *q++ = *p; + else + { + *q++ = '%'; + *q++ = hex[(*(unsigned char *)p >> 4) & 0xF]; + *q++ = hex[ *(unsigned char *)p & 0xF]; + } + } + *q++ = 0; -void VM_SV_Cmd_Init(void) -{ + PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(dest); } -void VM_SV_Cmd_Reset(void) +// #510 string(string input, ...) uri_unescape (DP_QC_URI_ESCAPE) +// does URI unescaping on a string (get back the evil stuff) +void VM_uri_unescape (void) { -} - -//============================================================================ -// Client + char src[VM_STRINGTEMP_LENGTH]; + char dest[VM_STRINGTEMP_LENGTH]; + char *p, *q; + int hi, lo; -char *vm_cl_extensions = -""; + VM_SAFEPARMCOUNTRANGE(1, 8, VM_uri_unescape); + VM_VarString(0, src, sizeof(src)); -prvm_builtin_t vm_cl_builtins[] = { -0 // to be consistent with the old vm -}; + for(p = src, q = dest; *p; ) // no need to check size, because unescape can't expand + { + if(*p == '%') + { + if(p[1] >= '0' && p[1] <= '9') + hi = p[1] - '0'; + else if(p[1] >= 'a' && p[1] <= 'f') + hi = p[1] - 'a' + 10; + else if(p[1] >= 'A' && p[1] <= 'F') + hi = p[1] - 'A' + 10; + else + goto nohex; + if(p[2] >= '0' && p[2] <= '9') + lo = p[2] - '0'; + else if(p[2] >= 'a' && p[2] <= 'f') + lo = p[2] - 'a' + 10; + else if(p[2] >= 'A' && p[2] <= 'F') + lo = p[2] - 'A' + 10; + else + goto nohex; + if(hi != 0 || lo != 0) // don't unescape NUL bytes + *q++ = (char) (hi * 0x10 + lo); + p += 3; + continue; + } -const int vm_cl_numbuiltins = sizeof(vm_cl_builtins) / sizeof(prvm_builtin_t); +nohex: + // otherwise: + *q++ = *p++; + } + *q++ = 0; -void VM_CL_Cmd_Init(void) -{ + PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(dest); } -void VM_CL_Cmd_Reset(void) +// #502 string(string filename) whichpack (DP_QC_WHICHPACK) +// returns the name of the pack containing a file, or "" if it is not in any pack (but local or non-existant) +void VM_whichpack (void) { -} + const char *fn, *pack; -//============================================================================ -// Menu + VM_SAFEPARMCOUNT(1, VM_whichpack); + fn = PRVM_G_STRING(OFS_PARM0); + pack = FS_WhichPack(fn); -char *vm_m_extensions = -"DP_CINEMATIC_DPV"; + PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(pack ? pack : ""); +} -/* -========= -VM_M_setmousetarget +typedef struct +{ + int prognr; + double starttime; + float id; + char buffer[MAX_INPUTLINE]; +} +uri_to_prog_t; -setmousetarget(float target) -========= -*/ -void VM_M_setmousetarget(void) +static void uri_to_string_callback(int status, size_t length_received, unsigned char *buffer, void *cbdata) { - VM_SAFEPARMCOUNT(1, VM_M_setmousetarget); + uri_to_prog_t *handle = (uri_to_prog_t *) cbdata; - switch((int)PRVM_G_FLOAT(OFS_PARM0)) + if(!PRVM_ProgLoaded(handle->prognr)) { - 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)); + // curl reply came too late... so just drop it + Z_Free(handle); + return; } + + PRVM_SetProg(handle->prognr); + PRVM_Begin; + if((prog->starttime == handle->starttime) && (prog->funcoffsets.URI_Get_Callback)) + { + if(length_received >= sizeof(handle->buffer)) + length_received = sizeof(handle->buffer) - 1; + handle->buffer[length_received] = 0; + + PRVM_G_FLOAT(OFS_PARM0) = handle->id; + PRVM_G_FLOAT(OFS_PARM1) = status; + PRVM_G_INT(OFS_PARM2) = PRVM_SetTempString(handle->buffer); + PRVM_ExecuteProgram(prog->funcoffsets.URI_Get_Callback, "QC function URI_Get_Callback is missing"); + } + PRVM_End; + + Z_Free(handle); } -/* -========= -VM_M_getmousetarget - -float getmousetarget -========= -*/ -void VM_M_getmousetarget(void) +// uri_get() gets content from an URL and calls a callback "uri_get_callback" with it set as string; an unique ID of the transfer is returned +// returns 1 on success, and then calls the callback with the ID, 0 or the HTTP status code, and the received data in a string +void VM_uri_get (void) { - VM_SAFEPARMCOUNT(0,VM_M_getmousetarget); + const char *url; + float id; + qboolean ret; + uri_to_prog_t *handle; + + if(!prog->funcoffsets.URI_Get_Callback) + PRVM_ERROR("uri_get called by %s without URI_Get_Callback defined", PRVM_NAME); + + VM_SAFEPARMCOUNT(2, VM_uri_get); + + url = PRVM_G_STRING(OFS_PARM0); + id = PRVM_G_FLOAT(OFS_PARM1); + handle = (uri_to_prog_t *) Z_Malloc(sizeof(*handle)); // this can't be the prog's mem pool, as curl may call the callback later! - if(in_client_mouse) - PRVM_G_FLOAT(OFS_RETURN) = 2; + handle->prognr = PRVM_GetProgNr(); + handle->starttime = prog->starttime; + handle->id = id; + ret = Curl_Begin_ToMemory(url, (unsigned char *) handle->buffer, sizeof(handle->buffer), uri_to_string_callback, handle); + if(ret) + { + PRVM_G_INT(OFS_RETURN) = 1; + } else - PRVM_G_FLOAT(OFS_RETURN) = 1; + { + Z_Free(handle); + PRVM_G_INT(OFS_RETURN) = 0; + } } +void VM_netaddress_resolve (void) +{ + const char *ip; + char normalized[128]; + int port; + lhnetaddress_t addr; + VM_SAFEPARMCOUNTRANGE(1, 2, VM_netaddress_resolve); -/* -========= -VM_M_setkeydest + ip = PRVM_G_STRING(OFS_PARM0); + port = 0; + if(prog->argc > 1) + port = (int) PRVM_G_FLOAT(OFS_PARM1); -setkeydest(float dest) -========= -*/ -void VM_M_setkeydest(void) + if(LHNETADDRESS_FromString(&addr, ip, port) && LHNETADDRESS_ToString(&addr, normalized, sizeof(normalized), prog->argc > 1)) + PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(normalized); + else + PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(""); +} + +//string(void) getextresponse = #624; // returns the next extResponse packet that was sent to this client +void VM_CL_getextresponse (void) { - VM_SAFEPARMCOUNT(1,VM_M_setkeydest); + VM_SAFEPARMCOUNT(0,VM_argv); - switch((int)PRVM_G_FLOAT(OFS_PARM0)) + if (cl_net_extresponse_count <= 0) + PRVM_G_INT(OFS_RETURN) = OFS_NULL; + else { - case 0: - // key_game - key_dest = key_game; - break; - case 2: - // key_menu - key_dest = key_menu; - break; - case 1: - // key_message - // key_dest = key_message - // break; - default: - PRVM_ERROR("VM_M_setkeydest: wrong destination %i !\n",prog->globals[OFS_PARM0]); + int first; + --cl_net_extresponse_count; + first = (cl_net_extresponse_last + NET_EXTRESPONSE_MAX - cl_net_extresponse_count) % NET_EXTRESPONSE_MAX; + PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(cl_net_extresponse[first]); } } -/* -========= -VM_M_getkeydest - -float getkeydest -========= -*/ -void VM_M_getkeydest(void) +void VM_SV_getextresponse (void) { - VM_SAFEPARMCOUNT(0,VM_M_getkeydest); + VM_SAFEPARMCOUNT(0,VM_argv); - // key_game = 0, key_message = 1, key_menu = 2, unknown = 3 - switch(key_dest) + if (sv_net_extresponse_count <= 0) + PRVM_G_INT(OFS_RETURN) = OFS_NULL; + else { - case key_game: - PRVM_G_FLOAT(OFS_RETURN) = 0; - break; - case key_menu: - PRVM_G_FLOAT(OFS_RETURN) = 2; - break; - case key_message: - // not supported - // PRVM_G_FLOAT(OFS_RETURN) = 1; - // break; - default: - PRVM_G_FLOAT(OFS_RETURN) = 3; + int first; + --sv_net_extresponse_count; + first = (sv_net_extresponse_last + NET_EXTRESPONSE_MAX - sv_net_extresponse_count) % NET_EXTRESPONSE_MAX; + PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(sv_net_extresponse[first]); } } @@ -3341,25 +5630,21 @@ Extension: pass ========= */ mfunction_t *PRVM_ED_FindFunction (const char *name); -void VM_M_callfunction(void) +void VM_callfunction(void) { mfunction_t *func; - char *s; - - if(prog->argc == 0) - PRVM_ERROR("VM_M_callfunction: 1 parameter is required !\n"); + const char *s; - s = PRVM_G_STRING(OFS_PARM0 + (prog->argc - 1)); + VM_SAFEPARMCOUNTRANGE(1, 8, VM_callfunction); - if(!s) - PRVM_ERROR("VM_M_callfunction: null string !\n"); + s = PRVM_G_STRING(OFS_PARM0+(prog->argc - 1)*3); VM_CheckEmptyString(s); func = PRVM_ED_FindFunction(s); if(!func) - PRVM_ERROR("VM_M_callfunciton: function %s not found !\n", s); + PRVM_ERROR("VM_callfunciton: function %s not found !", s); else if (func->first_statement < 0) { // negative statements are built in functions @@ -3368,9 +5653,9 @@ void VM_M_callfunction(void) if (builtinnumber < prog->numbuiltins && prog->builtins[builtinnumber]) prog->builtins[builtinnumber](); else - PRVM_ERROR("No such builtin #%i in %s", builtinnumber, PRVM_NAME); + PRVM_ERROR("No such builtin #%i in %s; most likely cause: outdated engine build. Try updating!", builtinnumber, PRVM_NAME); } - else if(func > 0) + else if(func - prog->functions > 0) { prog->argc--; PRVM_ExecuteProgram(func - prog->functions,""); @@ -3380,24 +5665,21 @@ void VM_M_callfunction(void) /* ========= -VM_M_isfunction +VM_isfunction float isfunction(string function_name) ========= */ mfunction_t *PRVM_ED_FindFunction (const char *name); -void VM_M_isfunction(void) +void VM_isfunction(void) { mfunction_t *func; - char *s; + const char *s; - VM_SAFEPARMCOUNT(1, VM_M_isfunction); + VM_SAFEPARMCOUNT(1, VM_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); @@ -3410,663 +5692,692 @@ void VM_M_isfunction(void) /* ========= -VM_M_writetofile +VM_sprintf - writetofile(float fhandle, entity ent) +string sprintf(string format, ...) ========= */ -void VM_M_writetofile(void) + +void VM_sprintf(void) { - prvm_edict_t * ent; - int filenum; + const char *s, *s0; + char outbuf[MAX_INPUTLINE]; + char *o = outbuf, *end = outbuf + sizeof(outbuf), *err; + int argpos = 1; + int width, precision, thisarg, flags; + char formatbuf[16]; + char *f; + qboolean isfloat; +#define PRINTF_ALTERNATE 1 +#define PRINTF_ZEROPAD 2 +#define PRINTF_LEFT 4 +#define PRINTF_SPACEPOSITIVE 8 +#define PRINTF_SIGNPOSITIVE 16 + + formatbuf[0] = '%'; - VM_SAFEPARMCOUNT(2, VM_M_writetofile); + s = PRVM_G_STRING(OFS_PARM0); + +#define GETARG_FLOAT(a) (((a)>=1 && (a)argc) ? (PRVM_G_FLOAT(OFS_PARM0 + 3 * (a))) : 0) +#define GETARG_INT(a) (((a)>=1 && (a)argc) ? (PRVM_G_INT(OFS_PARM0 + 3 * (a))) : 0) +#define GETARG_STRING(a) (((a)>=1 && (a)argc) ? (PRVM_G_STRING(OFS_PARM0 + 3 * (a))) : "") - filenum = PRVM_G_FLOAT(OFS_PARM0); - if (filenum < 0 || filenum >= MAX_VMFILES) + for(;;) { - Con_Printf("VM_fputs: invalid file handle %i used in %s\n", filenum, PRVM_NAME); - return; + s0 = s; + switch(*s) + { + case 0: + goto finished; + case '%': + ++s; + + if(*s == '%') + goto verbatim; + + // complete directive format: + // %3$*1$.*2$ld + + width = -1; + precision = -1; + thisarg = -1; + flags = 0; + + // is number following? + if(*s >= '0' && *s <= '9') + { + width = strtol(s, &err, 10); + if(!err) + { + VM_Warning("VM_sprintf: invalid directive in %s: %s\n", PRVM_NAME, s0); + goto finished; + } + if(*err == '$') + { + thisarg = width; + width = -1; + s = err + 1; + } + else + { + if(*s == '0') + { + flags |= PRINTF_ZEROPAD; + if(width == 0) + width = -1; // it was just a flag + } + s = err; + } + } + + if(width < 0) + { + for(;;) + { + switch(*s) + { + case '#': flags |= PRINTF_ALTERNATE; break; + case '0': flags |= PRINTF_ZEROPAD; break; + case '-': flags |= PRINTF_LEFT; break; + case ' ': flags |= PRINTF_SPACEPOSITIVE; break; + case '+': flags |= PRINTF_SIGNPOSITIVE; break; + default: + goto noflags; + } + ++s; + } +noflags: + if(*s == '*') + { + ++s; + if(*s >= '0' && *s <= '9') + { + width = strtol(s, &err, 10); + if(!err || *err != '$') + { + VM_Warning("VM_sprintf: invalid directive in %s: %s\n", PRVM_NAME, s0); + goto finished; + } + s = err + 1; + } + else + width = argpos++; + width = GETARG_FLOAT(width); + if(width < 0) + { + flags |= PRINTF_LEFT; + width = -width; + } + } + else if(*s >= '0' && *s <= '9') + { + width = strtol(s, &err, 10); + if(!err) + { + VM_Warning("VM_sprintf: invalid directive in %s: %s\n", PRVM_NAME, s0); + goto finished; + } + s = err; + if(width < 0) + { + flags |= PRINTF_LEFT; + width = -width; + } + } + // otherwise width stays -1 + } + + if(*s == '.') + { + ++s; + if(*s == '*') + { + ++s; + if(*s >= '0' && *s <= '9') + { + precision = strtol(s, &err, 10); + if(!err || *err != '$') + { + VM_Warning("VM_sprintf: invalid directive in %s: %s\n", PRVM_NAME, s0); + goto finished; + } + s = err + 1; + } + else + precision = argpos++; + precision = GETARG_FLOAT(precision); + } + else if(*s >= '0' && *s <= '9') + { + precision = strtol(s, &err, 10); + if(!err) + { + VM_Warning("VM_sprintf: invalid directive in %s: %s\n", PRVM_NAME, s0); + goto finished; + } + s = err; + } + else + { + VM_Warning("VM_sprintf: invalid directive in %s: %s\n", PRVM_NAME, s0); + goto finished; + } + } + + isfloat = true; + for(;;) + { + switch(*s) + { + case 'h': isfloat = true; break; + case 'l': isfloat = false; break; + case 'L': isfloat = false; break; + case 'j': break; + case 'z': break; + case 't': break; + default: + goto nolength; + } + ++s; + } +nolength: + + if(thisarg < 0) + thisarg = argpos++; + + if(o < end - 1) + { + f = &formatbuf[1]; + if(*s != 's' && *s != 'c') + if(flags & PRINTF_ALTERNATE) *f++ = '#'; + if(flags & PRINTF_ZEROPAD) *f++ = '0'; + if(flags & PRINTF_LEFT) *f++ = '-'; + if(flags & PRINTF_SPACEPOSITIVE) *f++ = ' '; + if(flags & PRINTF_SIGNPOSITIVE) *f++ = '+'; + *f++ = '*'; + *f++ = '.'; + *f++ = '*'; + *f++ = *s; + *f++ = 0; + + if(width < 0) // not set + width = 0; + + switch(*s) + { + case 'd': case 'i': + if(precision < 0) // not set + precision = 1; + o += dpsnprintf(o, end - o, formatbuf, width, precision, (isfloat ? (int) GETARG_FLOAT(thisarg) : (int) GETARG_INT(thisarg))); + break; + case 'o': case 'u': case 'x': case 'X': + if(precision < 0) // not set + precision = 1; + o += dpsnprintf(o, end - o, formatbuf, width, precision, (isfloat ? (unsigned int) GETARG_FLOAT(thisarg) : (unsigned int) GETARG_INT(thisarg))); + break; + case 'e': case 'E': case 'f': case 'F': case 'g': case 'G': + if(precision < 0) // not set + precision = 6; + o += dpsnprintf(o, end - o, formatbuf, width, precision, (isfloat ? (double) GETARG_FLOAT(thisarg) : (double) GETARG_INT(thisarg))); + break; + case 'c': + if(precision < 0) // not set + precision = end - o - 1; + if(flags & PRINTF_ALTERNATE) + o += dpsnprintf(o, end - o, formatbuf, width, precision, (isfloat ? (unsigned int) GETARG_FLOAT(thisarg) : (unsigned int) GETARG_INT(thisarg))); + else + { + unsigned int c = (isfloat ? (unsigned int) GETARG_FLOAT(thisarg) : (unsigned int) GETARG_INT(thisarg)); + const char *buf = u8_encodech(c, NULL); + if(!buf) + buf = ""; + o += u8_strpad(o, end - o, buf, (flags & PRINTF_LEFT) != 0, width, precision); + } + break; + case 's': + if(precision < 0) // not set + precision = end - o - 1; + if(flags & PRINTF_ALTERNATE) + o += dpsnprintf(o, end - o, formatbuf, width, precision, GETARG_STRING(thisarg)); + else + o += u8_strpad(o, end - o, GETARG_STRING(thisarg), (flags & PRINTF_LEFT) != 0, width, precision); + break; + default: + VM_Warning("VM_sprintf: invalid directive in %s: %s\n", PRVM_NAME, s0); + goto finished; + } + } + ++s; + break; + default: +verbatim: + if(o < end - 1) + *o++ = *s++; + break; + } } - if (VM_FILES[filenum] == NULL) +finished: + *o = 0; + PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(outbuf); +} + + +// surface querying + +static dp_model_t *getmodel(prvm_edict_t *ed) +{ + switch(PRVM_GetProgNr()) { - Con_Printf("VM_fputs: no such file handle %i (or file has been closed) in %s\n", filenum, PRVM_NAME); - return; + case PRVM_SERVERPROG: + return SV_GetModelFromEdict(ed); + case PRVM_CLIENTPROG: + return CL_GetModelFromEdict(ed); + default: + return NULL; } +} - ent = PRVM_G_EDICT(OFS_PARM1); - if(ent->p.e->free) +typedef struct +{ + unsigned int progid; + dp_model_t *model; + frameblend_t frameblend[MAX_FRAMEBLENDS]; + skeleton_t *skeleton_p; + skeleton_t skeleton; + float *data_vertex3f; + float *data_svector3f; + float *data_tvector3f; + float *data_normal3f; + int max_vertices; + float *buf_vertex3f; + float *buf_svector3f; + float *buf_tvector3f; + float *buf_normal3f; +} +animatemodel_cache_t; +static animatemodel_cache_t animatemodel_cache; + +void animatemodel(dp_model_t *model, prvm_edict_t *ed) +{ + prvm_eval_t *val; + skeleton_t *skeleton; + int skeletonindex = -1; + qboolean need = false; + if(!model->AnimateVertices) { - Con_Printf("VM_M_writetofile: %s: entity %i is free !\n", PRVM_NAME, PRVM_EDICT_NUM(OFS_PARM1)); + animatemodel_cache.data_vertex3f = model->surfmesh.data_vertex3f; + animatemodel_cache.data_svector3f = model->surfmesh.data_svector3f; + animatemodel_cache.data_tvector3f = model->surfmesh.data_tvector3f; + animatemodel_cache.data_normal3f = model->surfmesh.data_normal3f; return; } - - PRVM_ED_Write (VM_FILES[filenum], ent); + if(animatemodel_cache.progid != prog->id) + memset(&animatemodel_cache, 0, sizeof(animatemodel_cache)); + need |= (animatemodel_cache.model != model); + VM_GenerateFrameGroupBlend(ed->priv.server->framegroupblend, ed); + VM_FrameBlendFromFrameGroupBlend(ed->priv.server->frameblend, ed->priv.server->framegroupblend, model); + need |= (memcmp(&animatemodel_cache.frameblend, &ed->priv.server->frameblend, sizeof(ed->priv.server->frameblend))); + if ((val = PRVM_EDICTFIELDVALUE(ed, prog->fieldoffsets.skeletonindex))) skeletonindex = (int)val->_float - 1; + if (!(skeletonindex >= 0 && skeletonindex < MAX_EDICTS && (skeleton = prog->skeletons[skeletonindex]) && skeleton->model->num_bones == ed->priv.server->skeleton.model->num_bones)) + skeleton = NULL; + need |= (animatemodel_cache.skeleton_p != skeleton); + if(skeleton) + need |= (memcmp(&animatemodel_cache.skeleton, skeleton, sizeof(ed->priv.server->skeleton))); + if(!need) + return; + if(model->surfmesh.num_vertices > animatemodel_cache.max_vertices) + { + animatemodel_cache.max_vertices = model->surfmesh.num_vertices * 2; + if(animatemodel_cache.buf_vertex3f) Mem_Free(animatemodel_cache.buf_vertex3f); + if(animatemodel_cache.buf_svector3f) Mem_Free(animatemodel_cache.buf_svector3f); + if(animatemodel_cache.buf_tvector3f) Mem_Free(animatemodel_cache.buf_tvector3f); + if(animatemodel_cache.buf_normal3f) Mem_Free(animatemodel_cache.buf_normal3f); + animatemodel_cache.buf_vertex3f = Mem_Alloc(prog->progs_mempool, sizeof(float[3]) * animatemodel_cache.max_vertices); + animatemodel_cache.buf_svector3f = Mem_Alloc(prog->progs_mempool, sizeof(float[3]) * animatemodel_cache.max_vertices); + animatemodel_cache.buf_tvector3f = Mem_Alloc(prog->progs_mempool, sizeof(float[3]) * animatemodel_cache.max_vertices); + animatemodel_cache.buf_normal3f = Mem_Alloc(prog->progs_mempool, sizeof(float[3]) * animatemodel_cache.max_vertices); + } + animatemodel_cache.data_vertex3f = animatemodel_cache.buf_vertex3f; + animatemodel_cache.data_svector3f = animatemodel_cache.buf_svector3f; + animatemodel_cache.data_tvector3f = animatemodel_cache.buf_tvector3f; + animatemodel_cache.data_normal3f = animatemodel_cache.buf_normal3f; + VM_UpdateEdictSkeleton(ed, model, ed->priv.server->frameblend); + model->AnimateVertices(model, ed->priv.server->frameblend, &ed->priv.server->skeleton, animatemodel_cache.data_vertex3f, animatemodel_cache.data_normal3f, animatemodel_cache.data_svector3f, animatemodel_cache.data_tvector3f); + animatemodel_cache.progid = prog->id; + animatemodel_cache.model = model; + memcpy(&animatemodel_cache.frameblend, &ed->priv.server->frameblend, sizeof(ed->priv.server->frameblend)); + animatemodel_cache.skeleton_p = skeleton; + if(skeleton) + memcpy(&animatemodel_cache.skeleton, skeleton, sizeof(ed->priv.server->skeleton)); +} + +static void getmatrix(prvm_edict_t *ed, matrix4x4_t *out) +{ + switch(PRVM_GetProgNr()) + { + case PRVM_SERVERPROG: + SV_GetEntityMatrix(ed, out, false); + break; + case PRVM_CLIENTPROG: + CL_GetEntityMatrix(ed, out, false); + break; + default: + *out = identitymatrix; + break; + } } -/* -========= -VM_M_getresolution - -vector getresolution(float number) -========= -*/ -extern unsigned short video_resolutions[][2]; -void VM_M_getresolution(void) +static void applytransform_forward(const vec3_t in, prvm_edict_t *ed, vec3_t out) { - 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; + matrix4x4_t m; + getmatrix(ed, &m); + Matrix4x4_Transform(&m, in, out); } -/* -========= -VM_M_keynumtostring - -string keynumtostring(float keynum) -========= -*/ -void VM_M_keynumtostring(void) +static void applytransform_forward_direction(const vec3_t in, prvm_edict_t *ed, vec3_t out) { - 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); + matrix4x4_t m; + getmatrix(ed, &m); + Matrix4x4_Transform3x3(&m, in, out); } -/* -========= -VM_M_stringtokeynum - -float stringtokeynum(string key) -========= -*/ -void VM_M_stringtokeynum( void ) +static void applytransform_inverted(const vec3_t in, prvm_edict_t *ed, vec3_t out) { - char *str; - VM_SAFEPARMCOUNT( 1, VM_M_keynumtostring ); - - str = PRVM_G_STRING( OFS_PARM0 ); - - PRVM_G_INT(OFS_RETURN) = Key_StringToKeynum( str ); + matrix4x4_t m, n; + getmatrix(ed, &m); + Matrix4x4_Invert_Full(&m, &n); + Matrix4x4_Transform3x3(&n, in, out); } -/* -========= -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) +static void applytransform_forward_normal(const vec3_t in, prvm_edict_t *ed, vec3_t out) { - 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); + matrix4x4_t m; + float p[4]; + getmatrix(ed, &m); + Matrix4x4_TransformPositivePlane(&m, in[0], in[1], in[2], 0, p); + VectorCopy(p, out); } -/* -========= -VM_M_getserverliststat - -float getserverliststat(float type) -========= -*/ -/* - type: -0 serverlist_viewcount -1 serverlist_totalcount -2 masterquerycount -3 masterreplycount -4 serverquerycount -5 serverreplycount -6 sortfield -7 sortdescending -*/ -void VM_M_getserverliststat( void ) +static void clippointtosurface(prvm_edict_t *ed, dp_model_t *model, msurface_t *surface, vec3_t p, vec3_t out) { - int type; - VM_SAFEPARMCOUNT ( 1, VM_M_getserverliststat ); - - PRVM_G_FLOAT( OFS_RETURN ) = 0; - - type = PRVM_G_FLOAT( OFS_PARM0 ); - switch(type) + int i, j, k; + float *v[3], facenormal[3], edgenormal[3], sidenormal[3], temp[3], offsetdist, dist, bestdist; + const int *e; + animatemodel(model, ed); + bestdist = 1000000000; + VectorCopy(p, out); + for (i = 0, e = (model->surfmesh.data_element3i + 3 * surface->num_firsttriangle);i < surface->num_triangles;i++, e += 3) { - case 0: - 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 3: - PRVM_G_FLOAT ( OFS_RETURN ) = masterreplycount; - return; - case 4: - PRVM_G_FLOAT ( OFS_RETURN ) = serverquerycount; - return; - case 5: - PRVM_G_FLOAT ( OFS_RETURN ) = serverreplycount; - return; - case 6: - PRVM_G_FLOAT ( OFS_RETURN ) = serverlist_sortbyfield; - return; - case 7: - PRVM_G_FLOAT ( OFS_RETURN ) = serverlist_sortdescending; - return; - default: - Con_Printf( "VM_M_getserverliststat: bad type %i!\n", type ); + // clip original point to each triangle of the surface and find the + // triangle that is closest + v[0] = animatemodel_cache.data_vertex3f + e[0] * 3; + v[1] = animatemodel_cache.data_vertex3f + e[1] * 3; + v[2] = animatemodel_cache.data_vertex3f + e[2] * 3; + TriangleNormal(v[0], v[1], v[2], facenormal); + VectorNormalize(facenormal); + offsetdist = DotProduct(v[0], facenormal) - DotProduct(p, facenormal); + VectorMA(p, offsetdist, facenormal, temp); + for (j = 0, k = 2;j < 3;k = j, j++) + { + VectorSubtract(v[k], v[j], edgenormal); + CrossProduct(edgenormal, facenormal, sidenormal); + VectorNormalize(sidenormal); + offsetdist = DotProduct(v[k], sidenormal) - DotProduct(temp, sidenormal); + if (offsetdist < 0) + VectorMA(temp, offsetdist, sidenormal, temp); + } + dist = VectorDistance2(temp, p); + if (bestdist > dist) + { + bestdist = dist; + VectorCopy(temp, out); + } } } -/* -======================== -VM_M_resetserverlistmasks - -resetserverlistmasks() -======================== -*/ -void VM_M_resetserverlistmasks( void ) +static msurface_t *getsurface(dp_model_t *model, int surfacenum) { - ServerList_ResetMasks(); + if (surfacenum < 0 || surfacenum >= model->nummodelsurfaces) + return NULL; + return model->data_surfaces + surfacenum + model->firstmodelsurface; } -/* -======================== -VM_M_setserverlistmaskstring - -setserverlistmaskstring(float mask, float fld, string str, float op) -0-511 and -512 - 1024 or -======================== -*/ -void VM_M_setserverlistmaskstring( void ) +//PF_getsurfacenumpoints, // #434 float(entity e, float s) getsurfacenumpoints = #434; +void VM_getsurfacenumpoints(void) { - 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 ); + dp_model_t *model; + msurface_t *surface; + VM_SAFEPARMCOUNT(2, VM_getsurfacenumpoints); + // return 0 if no such surface + if (!(model = getmodel(PRVM_G_EDICT(OFS_PARM0))) || !(surface = getsurface(model, (int)PRVM_G_FLOAT(OFS_PARM1)))) + { + PRVM_G_FLOAT(OFS_RETURN) = 0; 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 ); + // note: this (incorrectly) assumes it is a simple polygon + PRVM_G_FLOAT(OFS_RETURN) = surface->num_vertices; } - -/* -======================== -VM_M_setserverlistmasknumber - -setserverlistmasknumber(float mask, float fld, float num, float op) - -0-511 and -512 - 1024 or -======================== -*/ -void VM_M_setserverlistmasknumber( void ) +//PF_getsurfacepoint, // #435 vector(entity e, float s, float n) getsurfacepoint = #435; +void VM_getsurfacepoint(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 ); + prvm_edict_t *ed; + dp_model_t *model; + msurface_t *surface; + int pointnum; + VM_SAFEPARMCOUNT(3, VM_getsurfacepoint); + VectorClear(PRVM_G_VECTOR(OFS_RETURN)); + ed = PRVM_G_EDICT(OFS_PARM0); + if (!(model = getmodel(ed)) || !(surface = getsurface(model, (int)PRVM_G_FLOAT(OFS_PARM1)))) 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 ) -{ - 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_getserverliststring); - - PRVM_G_INT(OFS_RETURN) = 0; + // note: this (incorrectly) assumes it is a simple polygon + pointnum = (int)PRVM_G_FLOAT(OFS_PARM2); + if (pointnum < 0 || pointnum >= surface->num_vertices) + return; + animatemodel(model, ed); + applytransform_forward(&(animatemodel_cache.data_vertex3f + 3 * surface->num_firstvertex)[pointnum * 3], ed, PRVM_G_VECTOR(OFS_RETURN)); +} +//PF_getsurfacepointattribute, // #486 vector(entity e, float s, float n, float a) getsurfacepointattribute = #486; +// float SPA_POSITION = 0; +// float SPA_S_AXIS = 1; +// float SPA_T_AXIS = 2; +// float SPA_R_AXIS = 3; // same as SPA_NORMAL +// float SPA_TEXCOORDS0 = 4; +// float SPA_LIGHTMAP0_TEXCOORDS = 5; +// float SPA_LIGHTMAP0_COLOR = 6; +void VM_getsurfacepointattribute(void) +{ + prvm_edict_t *ed; + dp_model_t *model; + msurface_t *surface; + int pointnum; + int attributetype; + + VM_SAFEPARMCOUNT(4, VM_getsurfacepoint); + VectorClear(PRVM_G_VECTOR(OFS_RETURN)); + ed = PRVM_G_EDICT(OFS_PARM0); + if (!(model = getmodel(ed)) || !(surface = getsurface(model, (int)PRVM_G_FLOAT(OFS_PARM1)))) + return; + pointnum = (int)PRVM_G_FLOAT(OFS_PARM2); + if (pointnum < 0 || pointnum >= surface->num_vertices) + return; + attributetype = (int) PRVM_G_FLOAT(OFS_PARM3); - hostnr = PRVM_G_FLOAT(OFS_PARM1); + animatemodel(model, ed); - if(hostnr < 0 || hostnr >= serverlist_viewcount) - { - 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_SetString( cache->info.cname ); + switch( attributetype ) { + // float SPA_POSITION = 0; + case 0: + applytransform_forward(&(animatemodel_cache.data_vertex3f + 3 * surface->num_firstvertex)[pointnum * 3], ed, PRVM_G_VECTOR(OFS_RETURN)); break; - case SLIF_NAME: - PRVM_G_INT( OFS_RETURN ) = PRVM_SetString( cache->info.name ); + // float SPA_S_AXIS = 1; + case 1: + applytransform_forward_direction(&(animatemodel_cache.data_svector3f + 3 * surface->num_firstvertex)[pointnum * 3], ed, PRVM_G_VECTOR(OFS_RETURN)); break; - case SLIF_GAME: - PRVM_G_INT( OFS_RETURN ) = PRVM_SetString( cache->info.game ); + // float SPA_T_AXIS = 2; + case 2: + applytransform_forward_direction(&(animatemodel_cache.data_tvector3f + 3 * surface->num_firstvertex)[pointnum * 3], ed, PRVM_G_VECTOR(OFS_RETURN)); break; - case SLIF_MOD: - PRVM_G_INT( OFS_RETURN ) = PRVM_SetString( cache->info.mod ); + // float SPA_R_AXIS = 3; // same as SPA_NORMAL + case 3: + applytransform_forward_direction(&(animatemodel_cache.data_normal3f + 3 * surface->num_firstvertex)[pointnum * 3], ed, PRVM_G_VECTOR(OFS_RETURN)); break; - case SLIF_MAP: - PRVM_G_INT( OFS_RETURN ) = PRVM_SetString( cache->info.map ); + // float SPA_TEXCOORDS0 = 4; + case 4: { + float *ret = PRVM_G_VECTOR(OFS_RETURN); + float *texcoord = &(model->surfmesh.data_texcoordtexture2f + 2 * surface->num_firstvertex)[pointnum * 2]; + ret[0] = texcoord[0]; + ret[1] = texcoord[1]; + ret[2] = 0.0f; break; - // TODO remove this again - case 1024: - PRVM_G_INT( OFS_RETURN ) = PRVM_SetString( cache->line1 ); + } + // float SPA_LIGHTMAP0_TEXCOORDS = 5; + case 5: { + float *ret = PRVM_G_VECTOR(OFS_RETURN); + float *texcoord = &(model->surfmesh.data_texcoordlightmap2f + 2 * surface->num_firstvertex)[pointnum * 2]; + ret[0] = texcoord[0]; + ret[1] = texcoord[1]; + ret[2] = 0.0f; break; - case 1025: - PRVM_G_INT( OFS_RETURN ) = PRVM_SetString( cache->line2 ); + } + // float SPA_LIGHTMAP0_COLOR = 6; + case 6: + // ignore alpha for now.. + VectorCopy( &(model->surfmesh.data_lightmapcolor4f + 4 * surface->num_firstvertex)[pointnum * 4], PRVM_G_VECTOR(OFS_RETURN)); break; default: - Con_Print("VM_M_getserverliststring: bad field number passed!\n"); + VectorSet( PRVM_G_VECTOR(OFS_RETURN), 0.0f, 0.0f, 0.0f ); + break; } } - -/* -========= -VM_M_getserverlistnumber - -float getserverlistnumber(float field, float hostnr) -========= -*/ -void VM_M_getserverlistnumber(void) +//PF_getsurfacenormal, // #436 vector(entity e, float s) getsurfacenormal = #436; +void VM_getsurfacenormal(void) { - serverlist_entry_t *cache; - int hostnr; - - VM_SAFEPARMCOUNT(2, VM_M_getserverliststring); + dp_model_t *model; + msurface_t *surface; + vec3_t normal; + VM_SAFEPARMCOUNT(2, VM_getsurfacenormal); + VectorClear(PRVM_G_VECTOR(OFS_RETURN)); + if (!(model = getmodel(PRVM_G_EDICT(OFS_PARM0))) || !(surface = getsurface(model, (int)PRVM_G_FLOAT(OFS_PARM1)))) + return; + // note: this only returns the first triangle, so it doesn't work very + // well for curved surfaces or arbitrary meshes + animatemodel(model, PRVM_G_EDICT(OFS_PARM0)); + TriangleNormal((animatemodel_cache.data_vertex3f + 3 * surface->num_firstvertex), (animatemodel_cache.data_vertex3f + 3 * surface->num_firstvertex) + 3, (animatemodel_cache.data_vertex3f + 3 * surface->num_firstvertex) + 6, normal); + applytransform_forward_normal(normal, PRVM_G_EDICT(OFS_PARM0), PRVM_G_VECTOR(OFS_RETURN)); + VectorNormalize(PRVM_G_VECTOR(OFS_RETURN)); +} +//PF_getsurfacetexture, // #437 string(entity e, float s) getsurfacetexture = #437; +void VM_getsurfacetexture(void) +{ + dp_model_t *model; + msurface_t *surface; + VM_SAFEPARMCOUNT(2, VM_getsurfacetexture); + PRVM_G_INT(OFS_RETURN) = OFS_NULL; + if (!(model = getmodel(PRVM_G_EDICT(OFS_PARM0))) || !(surface = getsurface(model, (int)PRVM_G_FLOAT(OFS_PARM1)))) + return; + PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(surface->texture->name); +} +//PF_getsurfacenearpoint, // #438 float(entity e, vector p) getsurfacenearpoint = #438; +void VM_getsurfacenearpoint(void) +{ + int surfacenum, best; + vec3_t clipped, p; + vec_t dist, bestdist; + prvm_edict_t *ed; + dp_model_t *model; + msurface_t *surface; + vec_t *point; + VM_SAFEPARMCOUNT(2, VM_getsurfacenearpoint); + PRVM_G_FLOAT(OFS_RETURN) = -1; + ed = PRVM_G_EDICT(OFS_PARM0); + point = PRVM_G_VECTOR(OFS_PARM1); - PRVM_G_INT(OFS_RETURN) = 0; + if (!ed || ed->priv.server->free) + return; + model = getmodel(ed); + if (!model || !model->num_surfaces) + return; - hostnr = PRVM_G_FLOAT(OFS_PARM1); + animatemodel(model, ed); - if(hostnr < 0 || hostnr >= serverlist_viewcount) + applytransform_inverted(point, ed, p); + best = -1; + bestdist = 1000000000; + for (surfacenum = 0;surfacenum < model->nummodelsurfaces;surfacenum++) { - 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"); + surface = model->data_surfaces + surfacenum + model->firstmodelsurface; + // first see if the nearest point on the surface's box is closer than the previous match + clipped[0] = bound(surface->mins[0], p[0], surface->maxs[0]) - p[0]; + clipped[1] = bound(surface->mins[1], p[1], surface->maxs[1]) - p[1]; + clipped[2] = bound(surface->mins[2], p[2], surface->maxs[2]) - p[2]; + dist = VectorLength2(clipped); + if (dist < bestdist) + { + // it is, check the nearest point on the actual geometry + clippointtosurface(ed, model, surface, p, clipped); + VectorSubtract(clipped, p, clipped); + dist += VectorLength2(clipped); + if (dist < bestdist) + { + // that's closer too, store it as the best match + best = surfacenum; + bestdist = dist; + } + } } + PRVM_G_FLOAT(OFS_RETURN) = best; } - -/* -======================== -VM_M_setserverlistsort - -setserverlistsort(float field, float descending) -======================== -*/ -void VM_M_setserverlistsort( void ) -{ - VM_SAFEPARMCOUNT( 2, VM_M_setserverlistsort ); - - serverlist_sortbyfield = (int) PRVM_G_FLOAT( OFS_PARM0 ); - serverlist_sortdescending = (qboolean) PRVM_G_FLOAT( OFS_PARM1 ); -} - -/* -======================== -VM_M_refreshserverlist - -refreshserverlist() -======================== -*/ -void VM_M_refreshserverlist( void ) -{ - VM_SAFEPARMCOUNT( 0, VM_M_refreshserverlist ); - ServerList_QueryList(); -} - -/* -======================== -VM_M_getserverlistindexforkey - -float getserverlistindexforkey(string key) -======================== -*/ -void VM_M_getserverlistindexforkey( void ) +//PF_getsurfaceclippedpoint, // #439 vector(entity e, float s, vector p) getsurfaceclippedpoint = #439; +void VM_getsurfaceclippedpoint(void) { - 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_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[] = { - 0, // to be consistent with the old vm - // common builtings (mostly) - VM_checkextension, - VM_error, - VM_objerror, - VM_print, - VM_bprint, - VM_sprint, - VM_centerprint, - VM_normalize, - VM_vlen, - VM_vectoyaw, // #10 - VM_vectoangles, - VM_random, - VM_localcmd, - VM_cvar, - VM_cvar_set, - VM_dprint, - VM_ftos, - VM_fabs, - VM_vtos, - VM_etos, // 20 - VM_stof, - VM_spawn, - VM_remove, - VM_find, - VM_findfloat, - VM_findchain, - VM_findchainfloat, - VM_precache_file, - VM_precache_sound, - VM_coredump, // 30 - VM_traceon, - VM_traceoff, - VM_eprint, - VM_rint, - VM_floor, - VM_ceil, - VM_nextent, - VM_sin, - VM_cos, - VM_sqrt, // 40 - VM_randomvec, - VM_registercvar, - VM_min, - VM_max, - VM_bound, - VM_pow, - VM_copyentity, - VM_fopen, - VM_fclose, - VM_fgets, // 50 - VM_fputs, - VM_strlen, - VM_strcat, - VM_substring, - VM_stov, - VM_strzone, - VM_strunzone, - VM_tokenize, - VM_argv, - VM_isserver, // 60 - VM_clientcount, - VM_clientstate, - VM_clcommand, - VM_changelevel, - 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, - VM_itof, - 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 - e100, // 400 - // msg functions - VM_WriteByte, - VM_WriteChar, - VM_WriteShort, - VM_WriteLong, - VM_WriteAngle, - VM_WriteCoord, - VM_WriteString, - VM_WriteEntity, // 408 - 0, - 0, // 410 - e10, // 420 - e10, // 430 - e10, // 440 - e10, // 450 - // draw functions - VM_iscachedpic, - VM_precache_pic, - VM_freepic, - VM_drawcharacter, - VM_drawstring, - VM_drawpic, - VM_drawfill, - VM_drawsetcliparea, - VM_drawresetcliparea, - VM_getimagesize,// 460 - 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 - 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, - VM_M_findkeysforcommand,// 610 - 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); - -void VM_M_Cmd_Init(void) -{ - VM_Cmd_Init(); -} - -void VM_M_Cmd_Reset(void) -{ - //VM_Cmd_Init(); - VM_Cmd_Reset(); + prvm_edict_t *ed; + dp_model_t *model; + msurface_t *surface; + vec3_t p, out; + VM_SAFEPARMCOUNT(3, VM_te_getsurfaceclippedpoint); + VectorClear(PRVM_G_VECTOR(OFS_RETURN)); + ed = PRVM_G_EDICT(OFS_PARM0); + if (!(model = getmodel(ed)) || !(surface = getsurface(model, (int)PRVM_G_FLOAT(OFS_PARM1)))) + return; + animatemodel(model, ed); + applytransform_inverted(PRVM_G_VECTOR(OFS_PARM2), ed, p); + clippointtosurface(ed, model, surface, p, out); + VectorAdd(out, ed->fields.server->origin, PRVM_G_VECTOR(OFS_RETURN)); +} + +//PF_getsurfacenumtriangles, // #??? float(entity e, float s) getsurfacenumtriangles = #???; +void VM_getsurfacenumtriangles(void) +{ + dp_model_t *model; + msurface_t *surface; + VM_SAFEPARMCOUNT(2, VM_SV_getsurfacenumtriangles); + // return 0 if no such surface + if (!(model = getmodel(PRVM_G_EDICT(OFS_PARM0))) || !(surface = getsurface(model, (int)PRVM_G_FLOAT(OFS_PARM1)))) + { + PRVM_G_FLOAT(OFS_RETURN) = 0; + return; + } + + // note: this (incorrectly) assumes it is a simple polygon + PRVM_G_FLOAT(OFS_RETURN) = surface->num_triangles; +} +//PF_getsurfacetriangle, // #??? vector(entity e, float s, float n) getsurfacetriangle = #???; +void VM_getsurfacetriangle(void) +{ + prvm_edict_t *ed; + dp_model_t *model; + msurface_t *surface; + int trinum; + VM_SAFEPARMCOUNT(3, VM_SV_getsurfacetriangle); + VectorClear(PRVM_G_VECTOR(OFS_RETURN)); + ed = PRVM_G_EDICT(OFS_PARM0); + if (!(model = getmodel(ed)) || !(surface = getsurface(model, (int)PRVM_G_FLOAT(OFS_PARM1)))) + return; + trinum = (int)PRVM_G_FLOAT(OFS_PARM2); + if (trinum < 0 || trinum >= surface->num_triangles) + return; + // FIXME: implement rotation/scaling + VectorCopy(&(model->surfmesh.data_element3i + 3 * surface->num_firsttriangle)[trinum * 3], PRVM_G_VECTOR(OFS_RETURN)); }