X-Git-Url: http://de.git.xonotic.org/?p=xonotic%2Fdarkplaces.git;a=blobdiff_plain;f=prvm_cmds.c;h=9a4f138db90948009b803bbb65b075bb34b26dad;hp=8e07db729d6cc20b8c113c7995d5b6957a6b1c81;hb=c0b28902ae728d6089484e8f205aa118cd5b525b;hpb=73b087899f1ad0101e7250ed7722cf7d001d7c5d diff --git a/prvm_cmds.c b/prvm_cmds.c index 8e07db72..9a4f138d 100644 --- a/prvm_cmds.c +++ b/prvm_cmds.c @@ -5,36 +5,31 @@ // also applies here #include "prvm_cmds.h" +#include -//============================================================================ -// Common - -// temp string handling -// LordHavoc: added this to semi-fix the problem of using many ftos calls in a print -static char vm_string_temp[VM_STRINGTEMP_BUFFERS][VM_STRINGTEMP_LENGTH]; -static int vm_string_tempindex = 0; +// 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]; -// 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)) + va_start(argptr,fmt); + dpvsnprintf(msg,sizeof(msg),fmt,argptr); + va_end(argptr); -qfile_t *vm_files[MAX_PRVMFILES]; + Con_Print(msg); + // TODO: either add a cvar/cmd to control the state dumping or replace some of the calls with Con_Printf [9/13/2006 Black] + //PRVM_PrintState(); +} -// qc fs search handling -#define MAX_VMSEARCHES 128 -#define TOTAL_VMSEARCHES MAX_VMSEARCHES * PRVM_MAXPROGS -#define VM_SEARCHLIST ((fssearch_t**)(vm_fssearchlist + PRVM_GetProgNr() * MAX_VMSEARCHES)) -fssearch_t *vm_fssearchlist[TOTAL_VMSEARCHES]; +//============================================================================ +// Common -char *VM_GetTempString(void) -{ - char *s; - s = vm_string_temp[vm_string_tempindex]; - vm_string_tempindex = (vm_string_tempindex + 1) % VM_STRINGTEMP_BUFFERS; - return s; -} +// 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] void VM_CheckEmptyString (const char *s) { @@ -76,7 +71,7 @@ static qboolean checkextension(const char *name) { int len; char *e, *start; - len = strlen(name); + len = (int)strlen(name); for (e = prog->extensionstring;*e;e++) { @@ -87,11 +82,8 @@ static qboolean checkextension(const 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; } @@ -119,14 +111,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); + ed = PRVM_PROG_TO_EDICT(PRVM_GLOBALFIELDVALUE(prog->globaloffsets.self)->edict); PRVM_ED_Print(ed); } - 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); } /* @@ -145,26 +137,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); + ed = PRVM_PROG_TO_EDICT(PRVM_GLOBALFIELDVALUE(prog->globaloffsets.self)->edict); PRVM_ED_Print(ed); 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) @@ -190,7 +183,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; } @@ -213,18 +206,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); } /* @@ -233,13 +231,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); } @@ -255,24 +254,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)); } @@ -286,17 +281,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)); } /* @@ -394,49 +380,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; - prvm_edict_t *entity; - int volume; - float attenuation; - - entity = PRVM_G_EDICT(OFS_PARM0); - channel = PRVM_G_FLOAT(OFS_PARM1); - sample = PRVM_G_STRING(OFS_PARM2); - volume = PRVM_G_FLOAT(OFS_PARM3) * 255; - attenuation = PRVM_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 @@ -454,8 +397,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; } @@ -482,15 +425,16 @@ 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); - - Cbuf_AddText(PRVM_G_STRING(OFS_PARM0)); + char string[VM_STRINGTEMP_LENGTH]; + VM_SAFEPARMCOUNTRANGE(1, 8, VM_localcmd); + VM_VarString(0, string, sizeof(string)); + Cbuf_AddText(string); } /* @@ -516,25 +460,14 @@ const string VM_cvar_string (string) */ void VM_cvar_string(void) { - char *out; const char *name; - const char *cvar_string; VM_SAFEPARMCOUNT(1,VM_cvar_string); name = PRVM_G_STRING(OFS_PARM0); - if(!name) - PRVM_ERROR("VM_cvar_string: %s: null string\n", PRVM_NAME); - VM_CheckEmptyString(name); - out = VM_GetTempString(); - - cvar_string = Cvar_VariableString(name); - - strcpy(out, cvar_string); - - PRVM_G_INT(OFS_RETURN) = PRVM_SetEngineString(out); + PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(Cvar_VariableString(name)); } @@ -545,27 +478,16 @@ VM_cvar_defstring const string VM_cvar_defstring (string) ======================== */ -void VM_cvar_defstring (void) +void VM_cvar_defstring (void) { - char *out; const char *name; - const char *cvar_string; VM_SAFEPARMCOUNT(1,VM_cvar_string); name = PRVM_G_STRING(OFS_PARM0); - if(!name) - PRVM_ERROR("VM_cvar_defstring: %s: null string\n", PRVM_NAME); - VM_CheckEmptyString(name); - out = VM_GetTempString(); - - cvar_string = Cvar_VariableDefString(name); - - strcpy(out, cvar_string); - - PRVM_G_INT(OFS_RETURN) = PRVM_SetEngineString(out); + PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(Cvar_VariableDefString(name)); } /* ================= @@ -591,6 +513,7 @@ dprint(...[string]) void VM_dprint (void) { char string[VM_STRINGTEMP_LENGTH]; + VM_SAFEPARMCOUNTRANGE(1, 8, VM_dprint); if (developer.integer) { VM_VarString(0, string, sizeof(string)); @@ -613,18 +536,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); else sprintf(s, "%f", v); - PRVM_G_INT(OFS_RETURN) = PRVM_SetEngineString(s); + PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(s); } /* @@ -655,13 +577,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_SetEngineString(s); + PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(s); } /* @@ -674,13 +595,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_SetEngineString(s); + PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(s); } /* @@ -693,6 +613,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); } @@ -712,23 +633,52 @@ 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)->priv.required->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_strftime + +string strftime(float uselocaltime, string[, string ...]) +========= +*/ +void VM_strftime(void) +{ + time_t t; + struct tm *tm; + 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 (PRVM_G_FLOAT(OFS_PARM0)) + tm = localtime(&t); + else + tm = gmtime(&t); + if (!tm) + { + PRVM_G_FLOAT(OFS_RETURN) = 0; + return; + } + strftime(result, sizeof(result), fmt, tm); + PRVM_G_FLOAT(OFS_RETURN) = PRVM_SetTempString(result); +} + /* ========= VM_spawn @@ -740,6 +690,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); @@ -761,17 +712,22 @@ void VM_remove (void) VM_SAFEPARMCOUNT(1, VM_remove); ed = PRVM_G_EDICT(OFS_PARM0); - if( PRVM_NUM_FOR_EDICT(ed) <= prog->reserved_edicts ) { - Con_DPrint( "VM_remove: tried to remove the null entity or a reserved entity!\n" ); - } else if( ed->priv.required->free ) { - Con_DPrint( "VM_remove: tried to remove an already freed entity!\n" ); - } else { - PRVM_ED_Free (ed); + if( PRVM_NUM_FOR_EDICT(ed) <= prog->reserved_edicts ) + { + if (developer.integer >= 1) + VM_Warning( "VM_remove: tried to remove the null entity or a reserved entity!\n" ); + } + else if( ed->priv.required->free ) + { + if (developer.integer >= 1) + VM_Warning( "VM_remove: tried to remove an already freed entity!\n" ); } + else + PRVM_ED_Free (ed); // if (ed == prog->edicts) -// PRVM_ERROR ("remove: tried to remove world\n"); +// PRVM_ERROR ("remove: tried to remove world"); // if (PRVM_NUM_FOR_EDICT(ed) <= sv.maxclients) -// Host_Error("remove: tried to remove a client\n"); +// Host_Error("remove: tried to remove a client"); } /* @@ -795,12 +751,9 @@ 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++) { @@ -810,7 +763,7 @@ void VM_find (void) continue; t = PRVM_E_STRING(ed,f); if (!t) - continue; + t = ""; if (!strcmp(t,s)) { VM_RETURN_EDICT(ed); @@ -872,27 +825,22 @@ void VM_findchain (void) { int i; int f; - int chain_of; const char *s, *t; prvm_edict_t *ent, *chain; VM_SAFEPARMCOUNT(2,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_FindField("chain")->ofs; + if (prog->fieldoffsets.chain < 0) + PRVM_ERROR("VM_findchain: %s doesnt have a 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)) @@ -902,11 +850,11 @@ void VM_findchain (void) 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,prog->fieldoffsets.chain)->edict = PRVM_NUM_FOR_EDICT(chain); chain = ent; } @@ -927,16 +875,13 @@ void VM_findchainfloat (void) { int i; int f; - int chain_of; float s; prvm_edict_t *ent, *chain; VM_SAFEPARMCOUNT(2, VM_findchainfloat); - if(!prog->flag & PRVM_FE_CHAIN) - PRVM_ERROR("VM_findchainfloat: %s doesnt have a chain field !\n", PRVM_NAME); - - chain_of = PRVM_ED_FindField("chain")->ofs; + if (prog->fieldoffsets.chain < 0) + PRVM_ERROR("VM_findchainfloat: %s doesnt have a chain field !", PRVM_NAME); chain = (prvm_edict_t *)prog->edicts; @@ -952,7 +897,7 @@ void VM_findchainfloat (void) if (PRVM_E_FLOAT(ent,f) != s) continue; - PRVM_E_INT(ent,chain_of) = PRVM_EDICT_TO_PROG(chain); + PRVM_EDICTFIELDVALUE(ent,prog->fieldoffsets.chain)->edict = PRVM_EDICT_TO_PROG(chain); chain = ent; } @@ -987,6 +932,8 @@ void VM_findflags (void) 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); @@ -1010,15 +957,12 @@ void VM_findchainflags (void) int i; int f; int s; - int chain_of; prvm_edict_t *ent, *chain; VM_SAFEPARMCOUNT(2, VM_findchainflags); - if(!prog->flag & PRVM_FE_CHAIN) - PRVM_ERROR("VM_findchainflags: %s doesnt have a chain field !\n", PRVM_NAME); - - chain_of = PRVM_ED_FindField("chain")->ofs; + if (prog->fieldoffsets.chain < 0) + PRVM_ERROR("VM_findchainflags: %s doesnt have a chain field !", PRVM_NAME); chain = (prvm_edict_t *)prog->edicts; @@ -1031,16 +975,58 @@ void VM_findchainflags (void) 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_E_INT(ent,chain_of) = PRVM_EDICT_TO_PROG(chain); + PRVM_EDICTFIELDVALUE(ent,prog->fieldoffsets.chain)->edict = PRVM_EDICT_TO_PROG(chain); chain = ent; } VM_RETURN_EDICT(chain); } +/* +========= +VM_precache_sound + +string precache_sound (string sample) +========= +*/ +void VM_precache_sound (void) +{ + const char *s; + + VM_SAFEPARMCOUNT(1, VM_precache_sound); + + s = PRVM_G_STRING(OFS_PARM0); + PRVM_G_INT(OFS_RETURN) = PRVM_G_INT(OFS_PARM0); + VM_CheckEmptyString(s); + + if(snd_initialized.integer && !S_PrecacheSound(s, true, false)) + { + VM_Warning("VM_precache_sound: Failed to load %s for %s\n", s, PRVM_NAME); + return; + } +} + +/* +================= +VM_precache_file + +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); +} + /* ========= VM_coredump @@ -1084,7 +1070,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); } /* @@ -1138,15 +1124,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); } /* @@ -1190,6 +1175,8 @@ void VM_nextent (void) int i; prvm_edict_t *ent; + VM_SAFEPARMCOUNT(1, VM_nextent); + i = PRVM_G_EDICTNUM(OFS_PARM0); while (1) { @@ -1221,13 +1208,11 @@ changelevel(string map) */ void VM_changelevel (void) { - const 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; } @@ -1236,8 +1221,7 @@ void VM_changelevel (void) return; svs.changelevel_issued = true; - s = PRVM_G_STRING(OFS_PARM0); - Cbuf_AddText (va("changelevel %s\n",s)); + Cbuf_AddText (va("changelevel %s\n",PRVM_G_STRING(OFS_PARM0))); } /* @@ -1278,6 +1262,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 @@ -1320,7 +1365,7 @@ 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) @@ -1328,11 +1373,11 @@ void VM_registercvar (void) 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) @@ -1345,7 +1390,7 @@ 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; } @@ -1354,6 +1399,7 @@ void VM_registercvar (void) PRVM_G_FLOAT(OFS_RETURN) = 1; // success } + /* ================= VM_min @@ -1365,20 +1411,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)); } /* @@ -1392,20 +1437,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)); } /* @@ -1438,90 +1482,37 @@ 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) -{ - prvm_edict_t *in, *out; - VM_SAFEPARMCOUNT(2,VM_copyentity); - in = PRVM_G_EDICT(OFS_PARM0); - out = PRVM_G_EDICT(OFS_PARM1); - memcpy(out->fields.vp, in->fields.vp, prog->progs->entityfields * 4); -} - -/* -================= -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; - prvm_eval_t *val; - - entnum = PRVM_G_EDICTNUM(OFS_PARM0); - i = PRVM_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 = PRVM_GETEDICTFIELDVALUE(client->edict, eval_clientcolors))) - val->_float = i; - client->colors = i; - client->old_colors = i; - client->edict->fields.server->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 (VM_FILES[i]) - FS_Close(VM_FILES[i]); - //VM_FILES[i] = NULL; + if (prog->openfiles[i]) + FS_Close(prog->openfiles[i]); + prog->openfiles[i] = NULL; } - memset(VM_FILES,0,sizeof(qfile_t*[MAX_VMFILES])); // this should be faster (is it ?) } -qfile_t *VM_GetFileHandle( int index ) +static qfile_t *VM_GetFileHandle( int index ) { - if (index < 0 || index >= MAX_VMFILES) + 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 (VM_FILES[index] == NULL) + if (prog->openfiles[index] == NULL) { Con_Printf("VM_GetFileHandle: no such file handle %i (or file has been closed) in %s\n", index, PRVM_NAME); return NULL; } - return VM_FILES[index]; + return prog->openfiles[index]; } /* @@ -1541,16 +1532,16 @@ void VM_fopen(void) 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); + mode = (int)PRVM_G_FLOAT(OFS_PARM1); switch(mode) { case 0: // FILE_READ @@ -1563,27 +1554,27 @@ void VM_fopen(void) modestring = "wb"; 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); - 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); + prog->openfiles[filenum] = FS_Open(va("data/%s", filename), modestring, false, false); + if (prog->openfiles[filenum] == NULL && mode == 0) + prog->openfiles[filenum] = FS_Open(va("%s", filename), modestring, false, false); - if (VM_FILES[filenum] == NULL) + if (prog->openfiles[filenum] == NULL) { - if (developer.integer) - Con_Printf("VM_fopen: %s: %s mode %s failed\n", PRVM_NAME, filename, modestring); PRVM_G_FLOAT(OFS_RETURN) = -1; + if (developer.integer >= 100) + VM_Warning("VM_fopen: %s: %s mode %s failed\n", PRVM_NAME, filename, modestring); } else { - if (developer.integer) - Con_Printf("VM_fopen: %s: %s mode %s opened as #%i\n", PRVM_NAME, filename, modestring, filenum); PRVM_G_FLOAT(OFS_RETURN) = filenum; + if (developer.integer >= 100) + Con_Printf("VM_fopen: %s: %s mode %s opened as #%i\n", PRVM_NAME, filename, modestring, filenum); } } @@ -1601,21 +1592,21 @@ 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; } - if (developer.integer) + FS_Close(prog->openfiles[filenum]); + prog->openfiles[filenum] = NULL; + if (developer.integer >= 100) Con_Printf("VM_fclose: %s: #%i closed\n", PRVM_NAME, filenum); - FS_Close(VM_FILES[filenum]); - VM_FILES[filenum] = NULL; } /* @@ -1629,26 +1620,26 @@ 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) + 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) @@ -1658,16 +1649,16 @@ 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) + if (developer.integer >= 100) Con_Printf("fgets: %s: %s\n", PRVM_NAME, string); if (c >= 0 || end) - PRVM_G_INT(OFS_RETURN) = PRVM_SetEngineString(string); + PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(string); else - PRVM_G_INT(OFS_RETURN) = 0; + PRVM_G_INT(OFS_RETURN) = OFS_NULL; } /* @@ -1686,24 +1677,55 @@ 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) + if ((stringlength = (int)strlen(string))) + FS_Write(prog->openfiles[filenum], string, stringlength); + if (developer.integer >= 100) Con_Printf("fputs: %s: %s\n", PRVM_NAME, string); } +/* +========= +VM_writetofile + + writetofile(float fhandle, entity ent) +========= +*/ +void VM_writetofile(void) +{ + prvm_edict_t * ent; + qfile_t *file; + + VM_SAFEPARMCOUNT(2, VM_writetofile); + + 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); +} + /* ========= VM_strlen @@ -1714,15 +1736,136 @@ float strlen(string s) //float(string s) strlen = #114; // returns how many characters are in a string void VM_strlen(void) { - const char *s; - VM_SAFEPARMCOUNT(1,VM_strlen); - s = PRVM_G_STRING(OFS_PARM0); - if (s) - PRVM_G_FLOAT(OFS_RETURN) = strlen(s); - else - PRVM_G_FLOAT(OFS_RETURN) = 0; + PRVM_G_FLOAT(OFS_RETURN) = strlen(PRVM_G_STRING(OFS_PARM0)); +} + +// DRESK - Decolorized String +/* +========= +VM_strdecolorize + +string strdecolorize(string s) +========= +*/ +// string (string s) strdecolorize = #472; // returns the passed in string with color codes stripped +void VM_strdecolorize(void) +{ + char szNewString[VM_STRINGTEMP_LENGTH]; + const char *szString; + size_t nCnt; + int nPos; + int nFillPos; + int bFinished; + nPos = 0; + nFillPos = 0; + nCnt = 0; + bFinished = 0; + + // Prepare Strings + VM_SAFEPARMCOUNT(1,VM_strdecolorize); + szString = PRVM_G_STRING(OFS_PARM0); + + while(!bFinished) + { // Traverse through String + if( szString[nPos] == '\n' || szString[nPos] == '\r' || szString[nPos] <= 0) + { // String End Found + szNewString[nFillPos++] = szString[nPos]; + bFinished = 1; + } + else + if( szString[nPos] == STRING_COLOR_TAG) + { // Color Code Located + if( szString[nPos + 1] == STRING_COLOR_TAG) + { // Valid Characters to Include + szNewString[nFillPos++] = szString[nPos]; + nPos = nPos + 1; + szNewString[nFillPos++] = szString[nPos]; + } + else + if( szString[nPos + 1] >= '0' && szString[nPos + 1] <= '9' ) + { // Color Code Found; Increment Position + nPos = nPos + 1; + } + else + { // Unknown Color Code; Include + szNewString[nFillPos++] = szString[nPos]; + nPos = nPos + 1; + } + } + else + // Include Character + szNewString[nFillPos++] = szString[nPos]; + + // Increment Position + nPos = nPos + 1; + } + + PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(szNewString); +} + +// DRESK - String Length (not counting color codes) +/* +========= +VM_strlennocol + +float strlennocol(string s) +========= +*/ +// 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) +{ + const char *szString; + size_t nCnt; + int nPos; + int bFinished; + nPos = 0; + nCnt = 0; + bFinished = 0; + + VM_SAFEPARMCOUNT(1,VM_strlennocol); + + szString = PRVM_G_STRING(OFS_PARM0); + + while(!bFinished) + { // Count Characters + // SV_BroadcastPrintf("Position '%d'; Character '%c'; Length '%d'\n", nPos, szString[nPos], nCnt); + + if( szString[nPos] == '\n' || szString[nPos] == '\r' || szString[nPos] <= 0) + { // String End Found + // SV_BroadcastPrintf("Found End of String at '%d'\n", nPos); + bFinished = 1; + } + else + if( szString[nPos] == STRING_COLOR_TAG) + { // Color Code Located + if( szString[nPos + 1] == STRING_COLOR_TAG) + { // Increment Length; Skip Color Code + nCnt = nCnt + 1; + nPos = nPos + 1; + } + else + if( szString[nPos + 1] >= '0' && szString[nPos + 1] <= '9' ) + { // Color Code Found; Increment Position + // SV_BroadcastPrintf("Found Color Codes at '%d'\n", nPos); + nPos = nPos + 1; + } + else + { // Unknown Color Code; Increment Length! + nPos = nPos + 1; + nCnt = nCnt + 1; + } + } + else + // Increment String Length + nCnt = nCnt + 1; + + // Increment Position + nPos = nPos + 1; + } + PRVM_G_FLOAT(OFS_RETURN) = nCnt; } /* @@ -1737,14 +1880,11 @@ string strcat(string,string,...[string]) // and returns as a tempstring void VM_strcat(void) { - char *s; - - if(prog->argc < 1) - PRVM_ERROR("VM_strcat wrong parameter count (min. 1 expected ) !\n"); + char s[VM_STRINGTEMP_LENGTH]; + VM_SAFEPARMCOUNTRANGE(1, 8, VM_strcat); - s = VM_GetTempString(); - VM_VarString(0, s, VM_STRINGTEMP_LENGTH); - PRVM_G_INT(OFS_RETURN) = PRVM_SetEngineString(s); + VM_VarString(0, s, sizeof(s)); + PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(s); } /* @@ -1760,21 +1900,18 @@ void VM_substring(void) { int i, start, length; const char *s; - char *string; + char string[VM_STRINGTEMP_LENGTH]; 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 = ""; + start = (int)PRVM_G_FLOAT(OFS_PARM1); + length = (int)PRVM_G_FLOAT(OFS_PARM2); for (i = 0;i < start && *s;i++, s++); - for (i = 0;i < VM_STRINGTEMP_LENGTH - 1 && *s && i < length;i++, s++) + for (i = 0;i < (int)sizeof(string) - 1 && *s && i < length;i++, s++) string[i] = *s; string[i] = 0; - PRVM_G_INT(OFS_RETURN) = PRVM_SetEngineString(string); + PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(string); } /* @@ -1802,17 +1939,19 @@ 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) +//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) { - const char *in; char *out; + char string[VM_STRINGTEMP_LENGTH]; + size_t alloclen; VM_SAFEPARMCOUNT(1,VM_strzone); - in = PRVM_G_STRING(OFS_PARM0); - PRVM_G_INT(OFS_RETURN) = PRVM_AllocString(strlen(in) + 1, &out); - strcpy(out, in); + VM_VarString(0, string, sizeof(string)); + alloclen = strlen(string) + 1; + PRVM_G_INT(OFS_RETURN) = PRVM_AllocString(alloclen, &out); + memcpy(out, string, alloclen); } /* @@ -1845,10 +1984,10 @@ void VM_clcommand (void) VM_SAFEPARMCOUNT(2,VM_clcommand); - i = PRVM_G_FLOAT(OFS_PARM0); + i = (int)PRVM_G_FLOAT(OFS_PARM0); if (!sv.active || i < 0 || i >= svs.maxclients || !svs.clients[i].active) { - Con_Printf("VM_clientcommand: %s: invalid client/server is not active !\n", PRVM_NAME); + VM_Warning("VM_clientcommand: %s: invalid client/server is not active !\n", PRVM_NAME); return; } @@ -1870,10 +2009,9 @@ float tokenize(string s) //this function originally written by KrimZon, made shorter by LordHavoc //20040203: rewritten by LordHavoc (no longer uses allocations) int num_tokens = 0; -char *tokens[256], tokenbuf[4096]; +int tokens[256]; void VM_tokenize (void) { - int pos; const char *p; VM_SAFEPARMCOUNT(1,VM_tokenize); @@ -1881,16 +2019,77 @@ void VM_tokenize (void) p = PRVM_G_STRING(OFS_PARM0); num_tokens = 0; - pos = 0; while(COM_ParseToken(&p, false)) { if (num_tokens >= (int)(sizeof(tokens)/sizeof(tokens[0]))) break; - if (pos + strlen(com_token) + 1 > sizeof(tokenbuf)) + tokens[num_tokens++] = PRVM_SetTempString(com_token); + } + + PRVM_G_FLOAT(OFS_RETURN) = num_tokens; +} + +/* +========= +VM_tokenizebyseparator + +float tokenizebyseparator(string s, string separator1, ...) +========= +*/ +//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 j, k; + int numseparators; + int separatorlen[7]; + const char *separators[7]; + const char *p; + char tokentext[MAX_INPUTLINE]; + + VM_SAFEPARMCOUNTRANGE(2, 8,VM_tokenizebyseparator); + + p = PRVM_G_STRING(OFS_PARM0); + + numseparators = 0;; + for (j = 1;j < prog->argc;j++) + { + // skip any blank separator strings + if (!PRVM_G_STRING(OFS_PARM0 + j)[0]) + continue; + separators[numseparators] = PRVM_G_STRING(OFS_PARM0 + j); + separatorlen[numseparators] = strlen(separators[numseparators]); + numseparators++; + } + + num_tokens = 0; + for (num_tokens = 0;num_tokens < (int)(sizeof(tokens)/sizeof(tokens[0]));num_tokens++) + { + 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[MAX_INPUTLINE]-1)) + tokentext[j++] = *p; + p++; + } + tokentext[j] = 0; + tokens[num_tokens] = PRVM_SetTempString(tokentext); + if (!*p) break; - tokens[num_tokens++] = tokenbuf + pos; - strcpy(tokenbuf + pos, com_token); - pos += strlen(com_token) + 1; } PRVM_G_FLOAT(OFS_RETURN) = num_tokens; @@ -1904,58 +2103,14 @@ void VM_argv (void) VM_SAFEPARMCOUNT(1,VM_argv); - token_num = PRVM_G_FLOAT(OFS_PARM0); + token_num = (int)PRVM_G_FLOAT(OFS_PARM0); if (token_num >= 0 && token_num < num_tokens) - PRVM_G_INT(OFS_RETURN) = PRVM_SetEngineString(tokens[token_num]); + PRVM_G_INT(OFS_RETURN) = tokens[token_num]; else - PRVM_G_INT(OFS_RETURN) = PRVM_SetEngineString(NULL); + PRVM_G_INT(OFS_RETURN) = OFS_NULL; } -/* -//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) -{ - prvm_edict_t *e = PRVM_G_EDICT(OFS_PARM0); - prvm_edict_t *tagentity = PRVM_G_EDICT(OFS_PARM1); - char *tagname = PRVM_G_STRING(OFS_PARM2); - prvm_eval_t *v; - int i, modelindex; - model_t *model; - - if (tagentity == NULL) - tagentity = prog->edicts; - - v = PRVM_GETEDICTFIELDVALUE(e, eval_tag_entity); - if (v) - fields.server->edict = PRVM_EDICT_TO_PROG(tagentity); - - v = PRVM_GETEDICTFIELDVALUE(e, eval_tag_index); - if (v) - fields.server->_float = 0; - if (tagentity != NULL && tagentity != prog->edicts && tagname && tagname[0]) - { - modelindex = (int)tagentity->fields.server->modelindex; - if (modelindex >= 0 && modelindex < MAX_MODELS) - { - model = sv.models[modelindex]; - if (model->data_overridetagnamesforskin && (unsigned int)tagentity->fields.server->skin < (unsigned int)model->numskins && model->data_overridetagnamesforskin[(unsigned int)tagentity->fields.server->skin].num_overridetagnames) - for (i = 0;i < model->data_overridetagnamesforskin[(unsigned int)tagentity->fields.server->skin].num_overridetagnames;i++) - if (!strcmp(tagname, model->data_overridetagnamesforskin[(unsigned int)tagentity->fields.server->skin].data_overridetagnames[i].name)) - fields.server->_float = i + 1; - // FIXME: use a model function to get tag info (need to handle skeletal) - if (fields.server->_float == 0 && model->num_tags) - for (i = 0;i < model->num_tags;i++) - if (!strcmp(tagname, model->data_tags[i].name)) - fields.server->_float = i + 1; - if (fields.server->_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", PRVM_NUM_FOR_EDICT(e), PRVM_NUM_FOR_EDICT(tagentity), tagname, tagname, PRVM_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", PRVM_NUM_FOR_EDICT(e), PRVM_NUM_FOR_EDICT(tagentity), tagname, tagname, PRVM_NUM_FOR_EDICT(tagentity)); - } -}*/ - /* ========= VM_isserver @@ -1967,7 +2122,7 @@ void VM_isserver(void) { VM_SAFEPARMCOUNT(0,VM_serverstate); - PRVM_G_FLOAT(OFS_RETURN) = sv.active; + PRVM_G_FLOAT(OFS_RETURN) = sv.active && (svs.maxclients > 1 || cls.state == ca_dedicated); } /* @@ -2015,9 +2170,9 @@ void VM_getostype(void) OS_MAC - not supported */ -#ifdef _WIN32 +#ifdef WIN32 PRVM_G_FLOAT(OFS_RETURN) = 0; -#elif defined _MAC +#elif defined(MACOSX) PRVM_G_FLOAT(OFS_RETURN) = 2; #else PRVM_G_FLOAT(OFS_RETURN) = 1; @@ -2052,7 +2207,7 @@ void VM_gettime(void) { VM_SAFEPARMCOUNT(0,VM_gettime); - PRVM_G_FLOAT(OFS_RETURN) = (float) *prog->time; + PRVM_G_FLOAT(OFS_RETURN) = (float) realtime; } /* @@ -2086,13 +2241,13 @@ void VM_parseentitydata(void) // 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)!\n", PRVM_NAME, PRVM_NUM_FOR_EDICT(ent)); + PRVM_ERROR ("VM_parseentitydata: %s: Can only set already spawned entities (entity %i is free)!", PRVM_NAME, PRVM_NUM_FOR_EDICT(ent)); data = PRVM_G_STRING(OFS_PARM1); // parse the opening brace - if (!COM_ParseToken(&data, false) || com_token[0] != '{' ) - PRVM_ERROR ("VM_parseentitydata: %s: Couldn't parse entity data:\n%s\n", PRVM_NAME, data ); + if (!COM_ParseTokenConsole(&data) || com_token[0] != '{' ) + PRVM_ERROR ("VM_parseentitydata: %s: Couldn't parse entity data:\n%s", PRVM_NAME, data ); PRVM_ED_ParseEdict (data, ent); } @@ -2107,24 +2262,20 @@ loadfromfile(string file) void VM_loadfromfile(void) { const char *filename; - qbyte *data; + char *data; VM_SAFEPARMCOUNT(1,VM_loadfromfile); filename = PRVM_G_STRING(OFS_PARM0); - // .. is parent directory on many platforms - // / is parent directory on Amiga - // : is root of drive on Amiga (also used as a directory separator on Mac, but / works there too, so that's a bad idea) - // \ is a windows-ism (so it's naughty to use it, / works on all platforms) - if ((filename[0] == '.' && filename[1] == '.') || filename[0] == '/' || strrchr(filename, ':') || strrchr(filename, '\\')) + if (FS_CheckNastyPath(filename, false)) { - 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; + VM_Warning("VM_loadfromfile: %s dangerous or non-portable filename \"%s\" not allowed. (contains : or \\ or begins with .. or /)\n", PRVM_NAME, filename); return; } // not conform with VM_fopen - data = FS_LoadFile(filename, tempmempool, false); + data = (char *)FS_LoadFile(filename, tempmempool, false, NULL); if (data == NULL) PRVM_G_FLOAT(OFS_RETURN) = -1; @@ -2155,17 +2306,21 @@ void VM_modulo(void) void VM_Search_Init(void) { - memset(VM_SEARCHLIST,0,sizeof(fssearch_t*[MAX_VMSEARCHES])); + int i; + for (i = 0;i < PRVM_MAX_OPENSEARCHES;i++) + prog->opensearches[i] = NULL; } void VM_Search_Reset(void) { int i; // reset the fssearch list - for(i = 0; i < MAX_VMSEARCHES; i++) - if(VM_SEARCHLIST[i]) - FS_FreeSearch(VM_SEARCHLIST[i]); - memset(VM_SEARCHLIST,0,sizeof(fssearch_t*[MAX_VMSEARCHES])); + for(i = 0; i < PRVM_MAX_OPENSEARCHES; i++) + { + if(prog->opensearches[i]) + FS_FreeSearch(prog->opensearches[i]); + prog->opensearches[i] = NULL; + } } /* @@ -2187,21 +2342,21 @@ void VM_search_begin(void) VM_CheckEmptyString(pattern); - caseinsens = PRVM_G_FLOAT(OFS_PARM1); - quiet = PRVM_G_FLOAT(OFS_PARM2); + caseinsens = (int)PRVM_G_FLOAT(OFS_PARM1); + quiet = (int)PRVM_G_FLOAT(OFS_PARM2); - for(handle = 0; handle < MAX_VMSEARCHES; handle++) - if(!VM_SEARCHLIST[handle]) + for(handle = 0; handle < PRVM_MAX_OPENSEARCHES; handle++) + if(!prog->opensearches[handle]) break; - if(handle >= MAX_VMSEARCHES) + if(handle >= PRVM_MAX_OPENSEARCHES) { - 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_search_begin: %s ran out of search handles (%i)\n", PRVM_NAME, PRVM_MAX_OPENSEARCHES); return; } - if(!(VM_SEARCHLIST[handle] = FS_Search(pattern,caseinsens, quiet))) + if(!(prog->opensearches[handle] = FS_Search(pattern,caseinsens, quiet))) PRVM_G_FLOAT(OFS_RETURN) = -1; else PRVM_G_FLOAT(OFS_RETURN) = handle; @@ -2219,21 +2374,21 @@ void VM_search_end(void) int handle; VM_SAFEPARMCOUNT(1, VM_search_end); - handle = PRVM_G_FLOAT(OFS_PARM0); + handle = (int)PRVM_G_FLOAT(OFS_PARM0); - if(handle < 0 || handle >= MAX_VMSEARCHES) + if(handle < 0 || handle >= PRVM_MAX_OPENSEARCHES) { - Con_Printf("VM_search_end: invalid handle %i used in %s\n", handle, PRVM_NAME); + VM_Warning("VM_search_end: invalid handle %i used in %s\n", handle, PRVM_NAME); return; } - if(VM_SEARCHLIST[handle] == NULL) + if(prog->opensearches[handle] == NULL) { - Con_Printf("VM_search_end: no such handle %i in %s\n", handle, PRVM_NAME); + VM_Warning("VM_search_end: no such handle %i in %s\n", handle, PRVM_NAME); return; } - FS_FreeSearch(VM_SEARCHLIST[handle]); - VM_SEARCHLIST[handle] = NULL; + FS_FreeSearch(prog->opensearches[handle]); + prog->opensearches[handle] = NULL; } /* @@ -2248,20 +2403,20 @@ void VM_search_getsize(void) int handle; VM_SAFEPARMCOUNT(1, VM_M_search_getsize); - handle = PRVM_G_FLOAT(OFS_PARM0); + handle = (int)PRVM_G_FLOAT(OFS_PARM0); - if(handle < 0 || handle >= MAX_VMSEARCHES) + if(handle < 0 || handle >= PRVM_MAX_OPENSEARCHES) { - Con_Printf("VM_search_getsize: invalid handle %i used in %s\n", handle, PRVM_NAME); + VM_Warning("VM_search_getsize: invalid handle %i used in %s\n", handle, PRVM_NAME); return; } - if(VM_SEARCHLIST[handle] == NULL) + if(prog->opensearches[handle] == NULL) { - Con_Printf("VM_search_getsize: no such handle %i in %s\n", handle, PRVM_NAME); + VM_Warning("VM_search_getsize: no such handle %i in %s\n", handle, PRVM_NAME); return; } - PRVM_G_FLOAT(OFS_RETURN) = VM_SEARCHLIST[handle]->numfilenames; + PRVM_G_FLOAT(OFS_RETURN) = prog->opensearches[handle]->numfilenames; } /* @@ -2274,32 +2429,28 @@ string search_getfilename(float handle, float num) void VM_search_getfilename(void) { int handle, filenum; - char *tmp; VM_SAFEPARMCOUNT(2, VM_search_getfilename); - handle = PRVM_G_FLOAT(OFS_PARM0); - filenum = PRVM_G_FLOAT(OFS_PARM1); + handle = (int)PRVM_G_FLOAT(OFS_PARM0); + filenum = (int)PRVM_G_FLOAT(OFS_PARM1); - if(handle < 0 || handle >= MAX_VMSEARCHES) + if(handle < 0 || handle >= PRVM_MAX_OPENSEARCHES) { - Con_Printf("VM_search_getfilename: invalid handle %i used in %s\n", handle, PRVM_NAME); + VM_Warning("VM_search_getfilename: invalid handle %i used in %s\n", handle, PRVM_NAME); return; } - if(VM_SEARCHLIST[handle] == NULL) + if(prog->opensearches[handle] == NULL) { - Con_Printf("VM_search_getfilename: no such handle %i in %s\n", handle, PRVM_NAME); + VM_Warning("VM_search_getfilename: no such handle %i in %s\n", handle, PRVM_NAME); return; } - if(filenum < 0 || filenum >= VM_SEARCHLIST[handle]->numfilenames) + if(filenum < 0 || filenum >= prog->opensearches[handle]->numfilenames) { - Con_Printf("VM_search_getfilename: invalid filenum %i in %s\n", filenum, PRVM_NAME); + VM_Warning("VM_search_getfilename: invalid filenum %i in %s\n", filenum, PRVM_NAME); return; } - tmp = VM_GetTempString(); - strcpy(tmp, VM_SEARCHLIST[handle]->filenames[filenum]); - - PRVM_G_INT(OFS_RETURN) = PRVM_SetEngineString(tmp); + PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(prog->opensearches[handle]->filenames[filenum]); } /* @@ -2311,14 +2462,13 @@ string chr(float ascii) */ void VM_chr(void) { - char *tmp; + char tmp[2]; VM_SAFEPARMCOUNT(1, VM_chr); - tmp = VM_GetTempString(); tmp[0] = (unsigned char) PRVM_G_FLOAT(OFS_PARM0); tmp[1] = 0; - PRVM_G_INT(OFS_RETURN) = PRVM_SetEngineString(tmp); + PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(tmp); } //============================================================================= @@ -2354,15 +2504,11 @@ void VM_precache_pic(void) s = PRVM_G_STRING(OFS_PARM0); PRVM_G_INT(OFS_RETURN) = PRVM_G_INT(OFS_PARM0); - - if(!s) - PRVM_ERROR ("VM_precache_pic: %s: NULL\n", PRVM_NAME); - VM_CheckEmptyString (s); // AK Draw_CachePic is supposed to always return a valid pointer if( Draw_CachePic(s, false)->tex == r_texture_notexture ) - PRVM_G_INT(OFS_RETURN) = PRVM_SetEngineString(NULL); + PRVM_G_INT(OFS_RETURN) = OFS_NULL; } /* @@ -2379,10 +2525,6 @@ void VM_freepic(void) VM_SAFEPARMCOUNT(1,VM_freepic); s = PRVM_G_STRING(OFS_PARM0); - - if(!s) - PRVM_ERROR ("VM_freepic: %s: NULL\n"); - VM_CheckEmptyString (s); Draw_FreePic(s); @@ -2405,8 +2547,8 @@ void VM_drawcharacter(void) character = (char) PRVM_G_FLOAT(OFS_PARM1); if(character == 0) { - Con_Printf("VM_drawcharacter: %s passed null character !\n",PRVM_NAME); PRVM_G_FLOAT(OFS_RETURN) = -1; + VM_Warning("VM_drawcharacter: %s passed null character !\n",PRVM_NAME); return; } @@ -2417,8 +2559,8 @@ void VM_drawcharacter(void) if(flag < DRAWFLAG_NORMAL || flag >=DRAWFLAG_NUMFLAGS) { - Con_Printf("VM_drawcharacter: %s: wrong DRAWFLAG %i !\n",PRVM_NAME,flag); PRVM_G_FLOAT(OFS_RETURN) = -2; + VM_Warning("VM_drawcharacter: %s: wrong DRAWFLAG %i !\n",PRVM_NAME,flag); return; } @@ -2427,8 +2569,8 @@ void VM_drawcharacter(void) 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; + VM_Warning("VM_drawcharacter: scale %s is null !\n", (scale[0] == 0) ? ((scale[1] == 0) ? "x and y" : "x") : "y"); return; } @@ -2451,15 +2593,6 @@ void VM_drawstring(void) VM_SAFEPARMCOUNT(6,VM_drawstring); 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; - } - - //VM_CheckEmptyString(string); Why should it be checked - perhaps the menu wants to support the precolored letters, too? - pos = PRVM_G_VECTOR(OFS_PARM0); scale = PRVM_G_VECTOR(OFS_PARM2); rgb = PRVM_G_VECTOR(OFS_PARM3); @@ -2467,20 +2600,20 @@ void VM_drawstring(void) 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; + VM_Warning("VM_drawstring: %s: wrong DRAWFLAG %i !\n",PRVM_NAME,flag); return; } if(!scale[0] || !scale[1]) { - Con_Printf("VM_drawstring: scale %s is null !\n", (scale[0] == 0) ? ((scale[1] == 0) ? "x and y" : "x") : "y"); 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%c from %s discarded\n",(pos[2] && scale[2]) ? 's' : 0,((pos[2] && scale[2]) ? "pos and scale" : (pos[2] ? "pos" : "scale"))); + Con_Printf("VM_drawstring: z value%s from %s discarded\n",(pos[2] && scale[2]) ? "s" : " ",((pos[2] && scale[2]) ? "pos and scale" : (pos[2] ? "pos" : "scale"))); DrawQ_String (pos[0], pos[1], string, 0, scale[0], scale[1], rgb[0], rgb[1], rgb[2], PRVM_G_FLOAT(OFS_PARM4), flag); PRVM_G_FLOAT(OFS_RETURN) = 1; @@ -2494,28 +2627,20 @@ float drawpic(vector position, string pic, vector size, vector rgb, float alpha, */ void VM_drawpic(void) { - const char *pic; + const char *picname; 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; - } - - VM_CheckEmptyString (pic); + picname = PRVM_G_STRING(OFS_PARM1); + VM_CheckEmptyString (picname); // is pic cached ? no function yet for that if(!1) { - Con_Printf("VM_drawpic: %s: %s not cached !\n", PRVM_NAME, pic); PRVM_G_FLOAT(OFS_RETURN) = -4; + VM_Warning("VM_drawpic: %s: %s not cached !\n", PRVM_NAME, picname); return; } @@ -2526,15 +2651,15 @@ void VM_drawpic(void) 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; + VM_Warning("VM_drawpic: %s: wrong DRAWFLAG %i !\n",PRVM_NAME,flag); return; } if(pos[2] || size[2]) - Con_Printf("VM_drawstring: z value%c from %s discarded\n",(pos[2] && size[2]) ? 's' : 0,((pos[2] && size[2]) ? "pos and size" : (pos[2] ? "pos" : "size"))); + Con_Printf("VM_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], pic, size[0], size[1], rgb[0], rgb[1], rgb[2], PRVM_G_FLOAT(OFS_PARM4), flag); + DrawQ_Pic(pos[0], pos[1], Draw_CachePic(picname, true), size[0], size[1], rgb[0], rgb[1], rgb[2], PRVM_G_FLOAT(OFS_PARM4), flag); PRVM_G_FLOAT(OFS_RETURN) = 1; } @@ -2560,15 +2685,15 @@ void VM_drawfill(void) 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; + VM_Warning("VM_drawfill: %s: wrong DRAWFLAG %i !\n",PRVM_NAME,flag); return; } if(pos[2] || size[2]) - Con_Printf("VM_drawstring: z value%c from %s discarded\n",(pos[2] && size[2]) ? 's' : 0,((pos[2] && size[2]) ? "pos and size" : (pos[2] ? "pos" : "size"))); + Con_Printf("VM_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_Pic(pos[0], pos[1], 0, size[0], size[1], rgb[0], rgb[1], rgb[2], PRVM_G_FLOAT(OFS_PARM3), flag); + DrawQ_Pic(pos[0], pos[1], NULL, size[0], size[1], rgb[0], rgb[1], rgb[2], PRVM_G_FLOAT(OFS_PARM3), flag); PRVM_G_FLOAT(OFS_RETURN) = 1; } @@ -2621,10 +2746,6 @@ void VM_getimagesize(void) VM_SAFEPARMCOUNT(1,VM_getimagesize); p = PRVM_G_STRING(OFS_PARM0); - - if(!p) - PRVM_ERROR("VM_getimagepos: %s passed null picture name !\n", PRVM_NAME); - VM_CheckEmptyString (p); pic = Draw_CachePic (p, false); @@ -2634,6 +2755,34 @@ void VM_getimagesize(void) 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_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 /* @@ -2678,7 +2827,7 @@ void VM_cin_close( void ) name = PRVM_G_STRING( OFS_PARM0 ); VM_CheckEmptyString( name ); - CL_CloseVideo( CL_GetVideo( name ) ); + CL_CloseVideo( CL_GetVideoByName( name ) ); } /* @@ -2698,9 +2847,9 @@ void VM_cin_setstate( void ) name = PRVM_G_STRING( OFS_PARM0 ); VM_CheckEmptyString( name ); - state = PRVM_G_FLOAT( OFS_PARM1 ); + state = (clvideostate_t)((int)PRVM_G_FLOAT( OFS_PARM1 )); - video = CL_GetVideo( name ); + video = CL_GetVideoByName( name ); if( video && state > CLVIDEO_UNUSED && state < CLVIDEO_STATECOUNT ) CL_SetVideoState( video, state ); } @@ -2722,7 +2871,7 @@ void VM_cin_getstate( void ) name = PRVM_G_STRING( OFS_PARM0 ); VM_CheckEmptyString( name ); - video = CL_GetVideo( name ); + video = CL_GetVideoByName( name ); if( video ) PRVM_G_FLOAT( OFS_RETURN ) = (int)video->state; else @@ -2746,11 +2895,102 @@ void VM_cin_restart( void ) name = PRVM_G_STRING( OFS_PARM0 ); VM_CheckEmptyString( name ); - video = CL_GetVideo( name ); + video = CL_GetVideoByName( name ); if( video ) CL_RestartVideo( video ); } +/* +============== +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((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 //////////////////////////////////////// @@ -2794,17 +3034,16 @@ string altstr_prepare(string) */ void VM_altstr_prepare( void ) { - char *outstr, *out; + 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 ); - //VM_CheckEmptyString( instr ); - outstr = VM_GetTempString(); - for( out = outstr, in = instr, size = VM_STRINGTEMP_LENGTH - 1 ; size && *in ; size--, in++, out++ ) + for( out = outstr, in = instr, size = sizeof(outstr) - 1 ; size && *in ; size--, in++, out++ ) if( *in == '\'' ) { *out++ = '\\'; *out = '\''; @@ -2813,7 +3052,7 @@ void VM_altstr_prepare( void ) *out = *in; *out = 0; - PRVM_G_INT( OFS_RETURN ) = PRVM_SetEngineString( outstr ); + PRVM_G_INT( OFS_RETURN ) = PRVM_SetTempString( outstr ); } /* @@ -2826,15 +3065,15 @@ string altstr_get(string, float) void VM_altstr_get( void ) { const char *altstr, *pos; - char *outstr, *out; + char *out; int count, size; + char outstr[VM_STRINGTEMP_LENGTH]; VM_SAFEPARMCOUNT( 2, VM_altstr_get ); altstr = PRVM_G_STRING( OFS_PARM0 ); - //VM_CheckEmptyString( altstr ); - count = PRVM_G_FLOAT( OFS_PARM1 ); + count = (int)PRVM_G_FLOAT( OFS_PARM1 ); count = count * 2 + 1; for( pos = altstr ; *pos && count ; pos++ ) @@ -2845,12 +3084,11 @@ void VM_altstr_get( void ) count--; if( !*pos ) { - PRVM_G_INT( OFS_RETURN ) = PRVM_SetEngineString( NULL ); + PRVM_G_INT( OFS_RETURN ) = 0; return; } - outstr = VM_GetTempString(); - for( out = outstr, size = VM_STRINGTEMP_LENGTH - 1 ; size && *pos ; size--, pos++, out++ ) + for( out = outstr, size = sizeof(outstr) - 1 ; size && *pos ; size--, pos++, out++ ) if( *pos == '\\' ) { if( !*++pos ) break; @@ -2862,7 +3100,7 @@ void VM_altstr_get( void ) *out = *pos; *out = 0; - PRVM_G_INT( OFS_RETURN ) = PRVM_SetEngineString( outstr ); + PRVM_G_INT( OFS_RETURN ) = PRVM_SetTempString( outstr ); } /* @@ -2877,19 +3115,18 @@ void VM_altstr_set( void ) int num; const char *altstr, *str; const char *in; - char *outstr, *out; + char *out; + char outstr[VM_STRINGTEMP_LENGTH]; VM_SAFEPARMCOUNT( 3, VM_altstr_set ); altstr = PRVM_G_STRING( OFS_PARM0 ); - //VM_CheckEmptyString( altstr ); - num = PRVM_G_FLOAT( OFS_PARM1 ); + num = (int)PRVM_G_FLOAT( OFS_PARM1 ); str = PRVM_G_STRING( OFS_PARM2 ); - //VM_CheckEmptyString( str ); - outstr = out = VM_GetTempString(); + out = outstr; for( num = num * 2 + 1, in = altstr; *in && num; *out++ = *in++ ) if( *in == '\\' ) { if( !*++in ) { @@ -2899,10 +3136,6 @@ void VM_altstr_set( void ) num--; } - if( !in ) { - PRVM_G_INT( OFS_RETURN ) = PRVM_SetEngineString( altstr ); - return; - } // copy set in for( ; *str; *out++ = *str++ ); // now jump over the old content @@ -2910,13 +3143,8 @@ void VM_altstr_set( void ) if( *in == '\'' || (*in == '\\' && !*++in) ) break; - if( !in ) { - PRVM_G_INT( OFS_RETURN ) = PRVM_SetEngineString( NULL ); - return; - } - - strcpy( out, in ); - PRVM_G_INT( OFS_RETURN ) = PRVM_SetEngineString( outstr ); + strlcpy(out, in, outstr + sizeof(outstr) - out); + PRVM_G_INT( OFS_RETURN ) = PRVM_SetTempString( outstr ); } /* @@ -2933,14 +3161,16 @@ void VM_altstr_ins(void) const char *set; const char *instr; const char *in; - char *outstr; char *out; + char outstr[VM_STRINGTEMP_LENGTH]; + + VM_SAFEPARMCOUNT(3, VM_altstr_ins); in = instr = PRVM_G_STRING( OFS_PARM0 ); - num = PRVM_G_FLOAT( OFS_PARM1 ); + num = (int)PRVM_G_FLOAT( OFS_PARM1 ); set = setstr = PRVM_G_STRING( OFS_PARM2 ); - out = outstr = VM_GetTempString(); + out = outstr; for( num = num * 2 + 2 ; *in && num > 0 ; *out++ = *in++ ) if( *in == '\\' ) { if( !*++in ) { @@ -2954,15 +3184,704 @@ void VM_altstr_ins(void) for( ; *set ; *out++ = *set++ ); *out++ = '\''; - strcpy( out, in ); - PRVM_G_INT( OFS_RETURN ) = PRVM_SetEngineString( outstr ); + strlcpy(out, in, outstr + sizeof(outstr) - out); + PRVM_G_INT( OFS_RETURN ) = PRVM_SetTempString( outstr ); +} + + +//////////////////////////////////////// +// BufString functions +//////////////////////////////////////// +//[515]: string buffers support +#define MAX_QCSTR_BUFFERS 128 +#define MAX_QCSTR_STRINGS 1024 + +typedef struct +{ + int num_strings; + char *strings[MAX_QCSTR_STRINGS]; +}qcstrbuffer_t; + +// FIXME: move stringbuffers to prog_t to allow multiple progs! +static qcstrbuffer_t *qcstringbuffers[MAX_QCSTR_BUFFERS]; +static int num_qcstringbuffers; +static int buf_sortpower; + +#define BUFSTR_BUFFER(a) (a>=MAX_QCSTR_BUFFERS) ? NULL : (qcstringbuffers[a]) +#define BUFSTR_ISFREE(a) (anum_strings<=0) ? 1 : 0 + +static int BufStr_FindFreeBuffer (void) +{ + int i; + if(num_qcstringbuffers == MAX_QCSTR_BUFFERS) + return -1; + for(i=0;inum_strings > 0) + { + for(i=0;inum_strings;i++) + if(b->strings[i]) + Z_Free(b->strings[i]); + num_qcstringbuffers--; + } + Z_Free(qcstringbuffers[index]); + qcstringbuffers[index] = NULL; + } +} + +static int BufStr_FindFreeString (qcstrbuffer_t *b) +{ + int i; + for(i=0;inum_strings;i++) + if(!b->strings[i] || !b->strings[i][0]) + return i; + if(i == MAX_QCSTR_STRINGS) return -1; + else return i; +} + +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, buf_sortpower); +} + +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, buf_sortpower); +} + +/* +======================== +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) +{ + int i; + VM_SAFEPARMCOUNT(0, VM_buf_create); + i = BufStr_FindFreeBuffer(); + if(i >= 0) + num_qcstringbuffers++; + //else + //Con_Printf("VM_buf_create: buffers overflow in %s\n", PRVM_NAME); + 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) +{ + VM_SAFEPARMCOUNT(1, VM_buf_del); + if(BUFSTR_BUFFER((int)PRVM_G_FLOAT(OFS_PARM0))) + BufStr_ClearBuffer((int)PRVM_G_FLOAT(OFS_PARM0)); + else + { + VM_Warning("VM_buf_del: invalid buffer %i used in %s\n", (int)PRVM_G_FLOAT(OFS_PARM0), PRVM_NAME); + return; + } +} + +/* +======================== +VM_buf_getsize +how many strings are stored in buffer +float buf_getsize(float bufhandle) = #462; +======================== +*/ +void VM_buf_getsize (void) +{ + qcstrbuffer_t *b; + VM_SAFEPARMCOUNT(1, VM_buf_getsize); + + b = BUFSTR_BUFFER((int)PRVM_G_FLOAT(OFS_PARM0)); + if(!b) + { + 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) = b->num_strings; } +/* +======================== +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) +{ + qcstrbuffer_t *b1, *b2; + int i; + VM_SAFEPARMCOUNT(2, VM_buf_copy); + + b1 = BUFSTR_BUFFER((int)PRVM_G_FLOAT(OFS_PARM0)); + if(!b1) + { + 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; + } + b2 = BUFSTR_BUFFER(i); + if(!b2) + { + VM_Warning("VM_buf_copy: invalid destination buffer %i used in %s\n", (int)PRVM_G_FLOAT(OFS_PARM1), PRVM_NAME); + return; + } + + BufStr_ClearBuffer(i); + qcstringbuffers[i] = (qcstrbuffer_t *)Z_Malloc(sizeof(qcstrbuffer_t)); + memset(qcstringbuffers[i], 0, sizeof(qcstrbuffer_t)); + b2->num_strings = b1->num_strings; + + for(i=0;inum_strings;i++) + if(b1->strings[i] && b1->strings[i][0]) + { + size_t stringlen; + stringlen = strlen(b1->strings[i]) + 1; + b2->strings[i] = (char *)Z_Malloc(stringlen); + if(!b2->strings[i]) + { + VM_Warning("VM_buf_copy: not enough memory for buffer %i used in %s\n", (int)PRVM_G_FLOAT(OFS_PARM1), PRVM_NAME); + break; + } + memcpy(b2->strings[i], b1->strings[i], stringlen); + } +} + +/* +======================== +VM_buf_sort +sort buffer by beginnings of strings (sortpower defaults it's lenght) +"backward == TRUE" means that sorting goes upside-down +void buf_sort(float bufhandle, float sortpower, float backward) = #464; +======================== +*/ +void VM_buf_sort (void) +{ + qcstrbuffer_t *b; + int i; + VM_SAFEPARMCOUNT(3, VM_buf_sort); + + b = BUFSTR_BUFFER((int)PRVM_G_FLOAT(OFS_PARM0)); + if(!b) + { + VM_Warning("VM_buf_sort: invalid buffer %i used in %s\n", (int)PRVM_G_FLOAT(OFS_PARM0), PRVM_NAME); + return; + } + if(b->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; + } + buf_sortpower = (int)PRVM_G_FLOAT(OFS_PARM1); + if(buf_sortpower <= 0) + buf_sortpower = 99999999; + + if(!PRVM_G_FLOAT(OFS_PARM2)) + qsort(b->strings, b->num_strings, sizeof(char*), BufStr_SortStringsUP); + else + qsort(b->strings, b->num_strings, sizeof(char*), BufStr_SortStringsDOWN); + + for(i=b->num_strings-1;i>=0;i--) //[515]: delete empty lines + if(b->strings) + { + if(b->strings[i][0]) + break; + else + { + Z_Free(b->strings[i]); + --b->num_strings; + b->strings[i] = NULL; + } + } + else + --b->num_strings; +} + +/* +======================== +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_buf_implode (void) +{ + qcstrbuffer_t *b; + char k[VM_STRINGTEMP_LENGTH]; + const char *sep; + int i; + size_t l; + VM_SAFEPARMCOUNT(2, VM_buf_implode); + + b = BUFSTR_BUFFER((int)PRVM_G_FLOAT(OFS_PARM0)); + PRVM_G_INT(OFS_RETURN) = OFS_NULL; + if(!b) + { + VM_Warning("VM_buf_implode: invalid buffer %i used in %s\n", (int)PRVM_G_FLOAT(OFS_PARM0), PRVM_NAME); + return; + } + if(!b->num_strings) + return; + sep = PRVM_G_STRING(OFS_PARM1); + k[0] = 0; + for(l=i=0;inum_strings;i++) + if(b->strings[i]) + { + l += (i > 0 ? strlen(sep) : 0) + strlen(b->strings[i]); + if (l >= sizeof(k) - 1) + break; + strlcat(k, sep, sizeof(k)); + strlcat(k, b->strings[i], sizeof(k)); + } + PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(k); +} + +/* +======================== +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) +{ + qcstrbuffer_t *b; + int strindex; + VM_SAFEPARMCOUNT(2, VM_bufstr_get); + + PRVM_G_INT(OFS_RETURN) = OFS_NULL; + b = BUFSTR_BUFFER((int)PRVM_G_FLOAT(OFS_PARM0)); + if(!b) + { + 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 || strindex > MAX_QCSTR_STRINGS) + { + VM_Warning("VM_bufstr_get: invalid string index %i used in %s\n", strindex, PRVM_NAME); + return; + } + if(b->num_strings <= strindex) + return; + if(b->strings[strindex]) + PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(b->strings[strindex]); +} + +/* +======================== +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 bufindex, strindex; + qcstrbuffer_t *b; + const char *news; + size_t alloclen; + + VM_SAFEPARMCOUNT(3, VM_bufstr_set); + + bufindex = (int)PRVM_G_FLOAT(OFS_PARM0); + b = BUFSTR_BUFFER(bufindex); + if(!b) + { + VM_Warning("VM_bufstr_set: invalid buffer %i used in %s\n", bufindex, PRVM_NAME); + return; + } + strindex = (int)PRVM_G_FLOAT(OFS_PARM1); + if(strindex < 0 || strindex > MAX_QCSTR_STRINGS) + { + VM_Warning("VM_bufstr_set: invalid string index %i used in %s\n", strindex, PRVM_NAME); + return; + } + news = PRVM_G_STRING(OFS_PARM2); + if(b->strings[strindex]) + Z_Free(b->strings[strindex]); + alloclen = strlen(news) + 1; + b->strings[strindex] = (char *)Z_Malloc(alloclen); + memcpy(b->strings[strindex], news, alloclen); +} + +/* +======================== +VM_bufstr_add +adds string to buffer in nearest free slot and returns it +"order == TRUE" means that string will be added after last "full" slot +float bufstr_add(float bufhandle, string str, float order) = #467; +======================== +*/ +void VM_bufstr_add (void) +{ + int bufindex, order, strindex; + qcstrbuffer_t *b; + const char *string; + size_t alloclen; + + VM_SAFEPARMCOUNT(3, VM_bufstr_add); + + bufindex = (int)PRVM_G_FLOAT(OFS_PARM0); + b = BUFSTR_BUFFER(bufindex); + PRVM_G_FLOAT(OFS_RETURN) = -1; + if(!b) + { + VM_Warning("VM_bufstr_add: invalid buffer %i used in %s\n", bufindex, PRVM_NAME); + return; + } + string = PRVM_G_STRING(OFS_PARM1); + order = (int)PRVM_G_FLOAT(OFS_PARM2); + if(order) + strindex = b->num_strings; + else + { + strindex = BufStr_FindFreeString(b); + if(strindex < 0) + { + VM_Warning("VM_bufstr_add: buffer %i has no free string slots in %s\n", bufindex, PRVM_NAME); + return; + } + } + + while(b->num_strings <= strindex) + { + if(b->num_strings == MAX_QCSTR_STRINGS) + { + VM_Warning("VM_bufstr_add: buffer %i has no free string slots in %s\n", bufindex, PRVM_NAME); + return; + } + b->strings[b->num_strings] = NULL; + b->num_strings++; + } + if(b->strings[strindex]) + Z_Free(b->strings[strindex]); + alloclen = strlen(string) + 1; + b->strings[strindex] = (char *)Z_Malloc(alloclen); + memcpy(b->strings[strindex], string, alloclen); + PRVM_G_FLOAT(OFS_RETURN) = strindex; +} + +/* +======================== +VM_bufstr_free +delete string from buffer +void bufstr_free(float bufhandle, float string_index) = #468; +======================== +*/ +void VM_bufstr_free (void) +{ + int i; + qcstrbuffer_t *b; + VM_SAFEPARMCOUNT(2, VM_bufstr_free); + + b = BUFSTR_BUFFER((int)PRVM_G_FLOAT(OFS_PARM0)); + if(!b) + { + 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 || i > MAX_QCSTR_STRINGS) + { + VM_Warning("VM_bufstr_free: invalid string index %i used in %s\n", i, PRVM_NAME); + return; + } + if(b->strings[i]) + Z_Free(b->strings[i]); + b->strings[i] = NULL; + if(i+1 == b->num_strings) + --b->num_strings; +} + +//============= + +/* +============== +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); +} + + +static int Is_Text_Color (char c, char t) +{ + int a = 0; + char c2 = c - (c & 128); + char t2 = t - (t & 128); + + if(c != STRING_COLOR_TAG && c2 != STRING_COLOR_TAG) return 0; + if(t >= '0' && t <= '9') a = 1; + if(t2 >= '0' && t2 <= '9') a = 1; +/* if(t >= 'A' && t <= 'Z') a = 2; + if(t2 >= 'A' && t2 <= 'Z') a = 2; + + if(a == 1 && scr_colortext.integer > 0) + return 1; + if(a == 2 && scr_multifonts.integer > 0) + return 2; +*/ + return a; +} + +void VM_uncolorstring (void) +{ + const char *in; + char out[VM_STRINGTEMP_LENGTH]; + int k = 0, i = 0; + + VM_SAFEPARMCOUNT(1, VM_uncolorstring); + in = PRVM_G_STRING(OFS_PARM0); + VM_CheckEmptyString (in); + + while (in[k]) + { + if(in[k+1]) + if(Is_Text_Color(in[k], in[k+1]) == 1/* || (in[k] == '&' && in[k+1] == 'r')*/) + { + k += 2; + continue; + } + out[i] = in[k]; + ++k; + ++i; + } + PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(out); +} + +//#222 string(string s, float index) str2chr (FTE_STRINGS) +void VM_str2chr (void) +{ + const char *s; + VM_SAFEPARMCOUNT(2, VM_str2chr); + s = PRVM_G_STRING(OFS_PARM0); + if((unsigned)PRVM_G_FLOAT(OFS_PARM1) > strlen(s)) + return; + PRVM_G_FLOAT(OFS_RETURN) = (unsigned char)s[(int)PRVM_G_FLOAT(OFS_PARM1)]; +} + +//#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); +} + +//#228 float(string s1, string s2, float len) strncmp (FTE_STRINGS) +void VM_strncmp (void) +{ + const char *s1, *s2; + VM_SAFEPARMCOUNT(1, VM_strncmp); + s1 = PRVM_G_STRING(OFS_PARM0); + s2 = PRVM_G_STRING(OFS_PARM1); + PRVM_G_FLOAT(OFS_RETURN) = strncmp(s1, s2, (size_t)PRVM_G_FLOAT(OFS_PARM2)); +} + +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_Cmd_Init(void) { // only init the stuff for the current prog VM_Files_Init(); VM_Search_Init(); +// VM_BufStr_Init(); } void VM_Cmd_Reset(void) @@ -2970,6 +3889,6 @@ void VM_Cmd_Reset(void) CL_PurgeOwner( MENUOWNER ); VM_Search_Reset(); VM_Files_CloseAll(); +// VM_BufStr_ShutDown(); } -