PRVM_ERROR ("%s: Bad string", PRVM_NAME);
}
+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;
+ }
+
+ 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;
+ }
+ }
+ }
+ }
+}
+
+void VM_UpdateEdictSkeleton(prvm_edict_t *ed, const dp_model_t *edmodel, const frameblend_t *frameblend)
+{
+ 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 = 0;
+ skeleton_t *skeleton;
+ prvm_eval_t *val;
+ if ((val = PRVM_EDICTFIELDVALUE(ed, prog->fieldoffsets.skeletonindex))) skeletonindex = (int)val->_float;
+ 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 float *poses = ed->priv.server->skeleton.model->data_poses;
+ const float *framebones;
+ float lerp;
+ 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;
+ framebones = poses + 12 * frameblend[blendindex].subframe * numbones;
+ for (bonenum = 0;bonenum < numbones;bonenum++)
+ {
+ Matrix4x4_FromArray12FloatD3D(&matrix, framebones + 12 * bonenum);
+ Matrix4x4_Accumulate(&ed->priv.server->skeleton.relativetransforms[bonenum], &matrix, lerp);
+ }
+ }
+ }
+ }
+}
+
+void VM_RemoveEdictSkeleton(prvm_edict_t *ed)
+{
+ 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
Cbuf_AddText(string);
}
+static qboolean PRVM_Cvar_ReadOk(const char *string)
+{
+ cvar_t *cvar;
+ cvar = Cvar_FindVar(string);
+ return ((cvar) && ((cvar->flags & CVAR_PRIVATE) == 0));
+}
+
/*
=================
VM_cvar
VM_SAFEPARMCOUNTRANGE(1,8,VM_cvar);
VM_VarString(0, string, sizeof(string));
VM_CheckEmptyString(string);
- PRVM_G_FLOAT(OFS_RETURN) = Cvar_VariableValue(string);
+ PRVM_G_FLOAT(OFS_RETURN) = PRVM_Cvar_ReadOk(string) ? Cvar_VariableValue(string) : 0;
}
/*
VM_SAFEPARMCOUNTRANGE(1,8,VM_cvar_string);
VM_VarString(0, string, sizeof(string));
VM_CheckEmptyString(string);
- PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(Cvar_VariableString(string));
+ PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(PRVM_Cvar_ReadOk(string) ? Cvar_VariableString(string) : "");
}
int f;
const char *s, *t;
prvm_edict_t *ent, *chain;
+ int chainfield;
- VM_SAFEPARMCOUNT(2,VM_findchain);
+ VM_SAFEPARMCOUNTRANGE(2,3,VM_findchain);
- if (prog->fieldoffsets.chain < 0)
- PRVM_ERROR("VM_findchain: %s doesnt have a chain field !", PRVM_NAME);
+ 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;
if (strcmp(t,s))
continue;
- PRVM_EDICTFIELDVALUE(ent,prog->fieldoffsets.chain)->edict = PRVM_NUM_FOR_EDICT(chain);
+ PRVM_EDICTFIELDVALUE(ent,chainfield)->edict = PRVM_NUM_FOR_EDICT(chain);
chain = ent;
}
int f;
float s;
prvm_edict_t *ent, *chain;
+ int chainfield;
- VM_SAFEPARMCOUNT(2, VM_findchainfloat);
+ VM_SAFEPARMCOUNTRANGE(2, 3, VM_findchainfloat);
- if (prog->fieldoffsets.chain < 0)
- PRVM_ERROR("VM_findchainfloat: %s doesnt have a chain field !", PRVM_NAME);
+ 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;
if (PRVM_E_FLOAT(ent,f) != s)
continue;
- PRVM_EDICTFIELDVALUE(ent,prog->fieldoffsets.chain)->edict = PRVM_EDICT_TO_PROG(chain);
+ PRVM_EDICTFIELDVALUE(ent,chainfield)->edict = PRVM_EDICT_TO_PROG(chain);
chain = ent;
}
int f;
int s;
prvm_edict_t *ent, *chain;
+ int chainfield;
- VM_SAFEPARMCOUNT(2, VM_findchainflags);
+ VM_SAFEPARMCOUNTRANGE(2, 3, VM_findchainflags);
- if (prog->fieldoffsets.chain < 0)
- PRVM_ERROR("VM_findchainflags: %s doesnt have a chain field !", PRVM_NAME);
+ 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;
if (!((int)PRVM_E_FLOAT(ent,f) & s))
continue;
- PRVM_EDICTFIELDVALUE(ent,prog->fieldoffsets.chain)->edict = PRVM_EDICT_TO_PROG(chain);
+ PRVM_EDICTFIELDVALUE(ent,chainfield)->edict = PRVM_EDICT_TO_PROG(chain);
chain = ent;
}
s = PRVM_G_STRING(OFS_PARM0);
PRVM_G_INT(OFS_RETURN) = PRVM_G_INT(OFS_PARM0);
- VM_CheckEmptyString(s);
+ //VM_CheckEmptyString(s);
- if(snd_initialized.integer && !S_PrecacheSound(s, true, false))
+ 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;
PRVM_G_FLOAT(OFS_RETURN) = pow(PRVM_G_FLOAT(OFS_PARM0), PRVM_G_FLOAT(OFS_PARM1));
}
+void VM_log (void)
+{
+ VM_SAFEPARMCOUNT(1,VM_log);
+ PRVM_G_FLOAT(OFS_RETURN) = log(PRVM_G_FLOAT(OFS_PARM0));
+}
+
void VM_Files_Init(void)
{
int i;
}
// parse the string into the value
- PRVM_G_FLOAT(OFS_RETURN) = ( PRVM_ED_ParseEpair(ent, d, PRVM_G_STRING(OFS_PARM2)) ) ? 1.0f : 0.0f;
+ PRVM_G_FLOAT(OFS_RETURN) = ( PRVM_ED_ParseEpair(ent, d, PRVM_G_STRING(OFS_PARM2), false) ) ? 1.0f : 0.0f;
}
/*
// returns a section of a string as a tempstring
void VM_substring(void)
{
- int i, start, length;
+ int start, length, slength, maxlen;
const char *s;
char string[VM_STRINGTEMP_LENGTH];
s = PRVM_G_STRING(OFS_PARM0);
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 < (int)sizeof(string) - 1 && *s && i < length;i++, s++)
- string[i] = *s;
- string[i] = 0;
+ 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);
}
//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[256];
-static int tokens_startpos[256];
-static int tokens_endpos[256];
+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 numseparators;
int separatorlen[7];
const char *separators[7];
- const char *p;
+ const char *p, *p0;
const char *token;
char tokentext[MAX_INPUTLINE];
{
token = tokentext + j;
tokens_startpos[num_tokens] = p - tokenize_string;
+ p0 = p;
while (*p)
{
for (k = 0;k < numseparators;k++)
if (j < (int)sizeof(tokentext)-1)
tokentext[j++] = *p;
p++;
+ p0 = p;
}
- tokens_endpos[num_tokens] = p - tokenize_string;
+ tokens_endpos[num_tokens] = p0 - tokenize_string;
if (j >= (int)sizeof(tokentext))
break;
tokentext[j++] = 0;
float gettime(void)
=========
*/
+extern double host_starttime;
+float CDAudio_GetPosition(void);
void VM_gettime(void)
{
- VM_SAFEPARMCOUNT(0,VM_gettime);
+ int timer_index;
+
+ VM_SAFEPARMCOUNTRANGE(0,1,VM_gettime);
- PRVM_G_FLOAT(OFS_RETURN) = (float) realtime;
+ if(prog->argc == 0)
+ {
+ PRVM_G_FLOAT(OFS_RETURN) = (float) realtime;
+ }
+ else
+ {
+ 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;
+ }
+ }
}
/*
Draw_FreePic(s);
}
-dp_font_t *getdrawfont()
+dp_font_t *getdrawfont(void)
{
if(prog->globaloffsets.drawfont >= 0)
{
- int f = PRVM_G_FLOAT(prog->globaloffsets.drawfont);
+ int f = (int) PRVM_G_FLOAT(prog->globaloffsets.drawfont);
if(f < 0 || f >= MAX_FONTS)
return FONT_DEFAULT;
return &dp_fonts[f];
=========
VM_stringwidth
-float stringwidth(string text, float allowColorCodes)
+float stringwidth(string text, float allowColorCodes, float size)
=========
*/
void VM_stringwidth(void)
{
const char *string;
+ float sz, 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;
- VM_SAFEPARMCOUNT(2,VM_drawstring);
+ VM_SAFEPARMCOUNTRANGE(2,3,VM_drawstring);
+
+ 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_Font(string, 0, !colors, getdrawfont()); // 1x1 characters, don't actually draw
+ PRVM_G_FLOAT(OFS_RETURN) = DrawQ_TextWidth_Font(string, 0, !colors, getdrawfont()) * mult; // 1x1 characters, don't actually draw
}
/*
=========
}
/*
=========
+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)
return;
}
- PRVM_G_FLOAT( OFS_RETURN ) = (CL_Gecko_Event_Key( instance, key, eventtype ) == true);
+ PRVM_G_FLOAT( OFS_RETURN ) = (CL_Gecko_Event_Key( instance, (keynum_t) key, eventtype ) == true);
}
/*
if( !instance ) {
return;
}
- CL_Gecko_Resize( instance, w, h );
+ CL_Gecko_Resize( instance, (int) w, (int) h );
}
int n1, n2;
VM_SAFEPARMCOUNT(2, VM_bitshift);
- n1 = (int)fabs((int)PRVM_G_FLOAT(OFS_PARM0));
+ 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;
stringbuffer->max_strings = max(stringbuffer->max_strings * 2, 128);
while (stringbuffer->max_strings <= strindex)
stringbuffer->max_strings *= 2;
- stringbuffer->strings = Mem_Alloc(prog->progs_mempool, stringbuffer->max_strings * sizeof(stringbuffer->strings[0]));
+ 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)
prvm_stringbuffer_t *stringbuffer;
int i;
VM_SAFEPARMCOUNT(0, VM_buf_create);
- stringbuffer = Mem_ExpandableArray_AllocRecord(&prog->stringbuffersarray);
+ 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;
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);
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(partial && strncasecmp(partial, cvar->name, len))
+ 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;
}
n = 0;
for(cvar = cvar_vars; cvar; cvar = cvar->next)
{
- if(len && strncasecmp(partial, cvar->name, len))
+ if(len && (ispattern ? !matchpattern_with_separator(cvar->name, partial, false, "", false) : strncmp(partial, cvar->name, len)))
continue;
- if(antilen && !strncasecmp(antipartial, cvar->name, antilen))
+ if(antilen && (antiispattern ? matchpattern_with_separator(cvar->name, antipartial, false, "", false) : !strncmp(antipartial, cvar->name, antilen)))
continue;
alloclen = strlen(cvar->name) + 1;
VM_SAFEPARMCOUNTRANGE(2, 3, VM_strstrofs);
instr = PRVM_G_STRING(OFS_PARM0);
match = PRVM_G_STRING(OFS_PARM1);
- firstofs = (prog->argc > 2)?PRVM_G_FLOAT(OFS_PARM2):0;
+ firstofs = (prog->argc > 2)?(int)PRVM_G_FLOAT(OFS_PARM2):0;
if (firstofs && (firstofs < 0 || firstofs > (int)strlen(instr)))
{
VM_SAFEPARMCOUNTRANGE(3, 8, VM_strconv);
- ccase = PRVM_G_FLOAT(OFS_PARM0); //0 same, 1 lower, 2 upper
- redalpha = PRVM_G_FLOAT(OFS_PARM1); //0 same, 1 white, 2 red, 5 alternate, 6 alternate-alternate
- rednum = PRVM_G_FLOAT(OFS_PARM2); //0 same, 1 white, 2 red, 3 redspecial, 4 whitespecial, 5 alternate, 6 alternate-alternate
+ 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);
char destbuf[VM_STRINGTEMP_LENGTH];
int pad;
VM_SAFEPARMCOUNTRANGE(1, 8, VM_strpad);
- pad = PRVM_G_FLOAT(OFS_PARM0);
+ pad = (int) PRVM_G_FLOAT(OFS_PARM0);
VM_VarString(1, src, sizeof(src));
// note: < 0 = left padding, > 0 = right padding,
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)
static void uri_to_string_callback(int status, size_t length_received, unsigned char *buffer, void *cbdata)
{
- uri_to_prog_t *handle = cbdata;
+ uri_to_prog_t *handle = (uri_to_prog_t *) cbdata;
if(!PRVM_ProgLoaded(handle->prognr))
{
url = PRVM_G_STRING(OFS_PARM0);
id = PRVM_G_FLOAT(OFS_PARM1);
- handle = Z_Malloc(sizeof(*handle)); // this can't be the prog's mem pool, as curl may call the callback later!
+ 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!
handle->prognr = PRVM_GetProgNr();
handle->starttime = prog->starttime;
ip = PRVM_G_STRING(OFS_PARM0);
port = 0;
if(prog->argc > 1)
- port = PRVM_G_FLOAT(OFS_PARM1);
+ port = (int) PRVM_G_FLOAT(OFS_PARM1);
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(0,VM_argv);
+
+ if (cl_net_extresponse_count <= 0)
+ PRVM_G_INT(OFS_RETURN) = OFS_NULL;
+ else
+ {
+ 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_SetEngineString(cl_net_extresponse[first]);
+ }
+}
+
+void VM_SV_getextresponse (void)
+{
+ VM_SAFEPARMCOUNT(0,VM_argv);
+
+ if (sv_net_extresponse_count <= 0)
+ PRVM_G_INT(OFS_RETURN) = OFS_NULL;
+ else
+ {
+ 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_SetEngineString(sv_net_extresponse[first]);
+ }
+}
+
+/*
+=========
+VM_M_callfunction
+
+ callfunction(...,string function_name)
+Extension: pass
+=========
+*/
+mfunction_t *PRVM_ED_FindFunction (const char *name);
+void VM_callfunction(void)
+{
+ mfunction_t *func;
+ const char *s;
+
+ VM_SAFEPARMCOUNTRANGE(1, 8, VM_callfunction);
+
+ s = PRVM_G_STRING(OFS_PARM0+(prog->argc - 1)*3);
+
+ VM_CheckEmptyString(s);
+
+ func = PRVM_ED_FindFunction(s);
+
+ if(!func)
+ PRVM_ERROR("VM_callfunciton: function %s not found !", s);
+ else if (func->first_statement < 0)
+ {
+ // negative statements are built in functions
+ int builtinnumber = -func->first_statement;
+ prog->xfunction->builtinsprofile++;
+ if (builtinnumber < prog->numbuiltins && prog->builtins[builtinnumber])
+ prog->builtins[builtinnumber]();
+ else
+ PRVM_ERROR("No such builtin #%i in %s; most likely cause: outdated engine build. Try updating!", builtinnumber, PRVM_NAME);
+ }
+ else if(func - prog->functions > 0)
+ {
+ prog->argc--;
+ PRVM_ExecuteProgram(func - prog->functions,"");
+ prog->argc++;
+ }
+}
+
+/*
+=========
+VM_isfunction
+
+float isfunction(string function_name)
+=========
+*/
+mfunction_t *PRVM_ED_FindFunction (const char *name);
+void VM_isfunction(void)
+{
+ mfunction_t *func;
+ const char *s;
+
+ VM_SAFEPARMCOUNT(1, VM_isfunction);
+
+ s = PRVM_G_STRING(OFS_PARM0);
+
+ VM_CheckEmptyString(s);
+
+ func = PRVM_ED_FindFunction(s);
+
+ if(!func)
+ PRVM_G_FLOAT(OFS_RETURN) = false;
+ else
+ PRVM_G_FLOAT(OFS_RETURN) = true;
+}
projects / xonotic / darkplaces.git / blobdiff