va_list argptr;
char msg[MAX_INPUTLINE];
static double recursive = -1;
+ int outfd = sys.outfd;
+
+ // set output to stderr
+ sys.outfd = fileno(stderr);
va_start(argptr,fmt);
dpvsnprintf(msg,sizeof(msg),fmt,argptr);
va_end(argptr);
- Con_Printf(CON_WARN "%s", msg);
+ Con_Printf(CON_WARN "%s VM warning: %s", prog->name, 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]
if(prvm_backtraceforwarnings.integer && recursive != host.realtime) // NOTE: this compares to the time, just in case if PRVM_PrintState causes a Host_Error and keeps recursive set
PRVM_PrintState(prog, 0);
recursive = -1;
}
+
+ // restore configured outfd
+ sys.outfd = outfd;
}
prog->error_cmd("%s: Bad string", prog->name);
}
+qbool PRVM_ConsoleCommand (prvm_prog_t *prog, const char *text, int *func, qbool preserve_self, int curself, double ptime, qbool prog_loaded, const char *error_message)
+{
+ int restorevm_tempstringsbuf_cursize;
+ int save_self = 0; // hush compiler warning
+ qbool r = false;
+
+ if(!prog_loaded)
+ return false;
+
+ if(func)
+ {
+ if(preserve_self)
+ save_self = PRVM_gameglobaledict(self);
+ if(ptime)
+ PRVM_gameglobalfloat(time) = ptime;
+ PRVM_gameglobaledict(self) = curself;
+ restorevm_tempstringsbuf_cursize = prog->tempstringsbuf.cursize;
+ PRVM_G_INT(OFS_PARM0) = PRVM_SetTempString(prog, text);
+ prog->ExecuteProgram(prog, *func, error_message);
+ prog->tempstringsbuf.cursize = restorevm_tempstringsbuf_cursize;
+ if(preserve_self)
+ PRVM_gameglobaledict(self) = save_self;
+ r = (int) PRVM_G_FLOAT(OFS_RETURN) != 0;
+ }
+
+ return r;
+}
+
void VM_GenerateFrameGroupBlend(prvm_prog_t *prog, framegroupblend_t *framegroupblend, const prvm_edict_t *ed)
{
// self.frame is the interpolation target (new frame)
if (!strcasecmp("DP_QC_DIGEST_SHA256", name))
return Crypto_Available();
+ // special shreck for libcurl
+ if (!strcasecmp("DP_QC_URI_GET", name) || !strcasecmp("DP_QC_URI_POST", name))
+ return Curl_Available();
+
return true;
}
}
=================
VM_random
-Returns a number from 0<= num < 1
+Returns a random number > 0 and < 1
float random()
=================
=========
VM_localsound
-localsound(string sample)
+localsound(string sample, float chan, float vol)
=========
*/
void VM_localsound(prvm_prog_t *prog)
{
const char *s;
+ float chan, vol;
- VM_SAFEPARMCOUNT(1,VM_localsound);
+ VM_SAFEPARMCOUNTRANGE(1, 3,VM_localsound);
s = PRVM_G_STRING(OFS_PARM0);
-
- if(!S_LocalSound (s))
+ if(prog->argc == 3)
+ {
+ chan = PRVM_G_FLOAT(OFS_PARM1);
+ vol = PRVM_G_FLOAT(OFS_PARM2) == 0 ? 1 : PRVM_G_FLOAT(OFS_PARM2);
+ if(!S_LocalSoundEx(s, chan, vol))
+ {
+ PRVM_G_FLOAT(OFS_RETURN) = -4;
+ VM_Warning(prog, "VM_localsound: Failed to play %s for %s !\n", s, prog->name);
+ return;
+ }
+ }
+ else if(!S_LocalSound (s))
{
PRVM_G_FLOAT(OFS_RETURN) = -4;
VM_Warning(prog, "VM_localsound: Failed to play %s for %s !\n", s, prog->name);
/*
=================
-VM_localcmd_client
+VM_localcmd_local
Sends text over to the client's execution buffer
cmd (string, ...)
=================
*/
-void VM_localcmd_client(prvm_prog_t *prog)
+void VM_localcmd_local(prvm_prog_t *prog)
{
char string[VM_STRINGTEMP_LENGTH];
- VM_SAFEPARMCOUNTRANGE(1, 8, VM_localcmd_client);
+ VM_SAFEPARMCOUNTRANGE(1, 8, VM_localcmd_local);
VM_VarString(prog, 0, string, sizeof(string));
- Cbuf_AddText(&cmd_client, string);
+ Cbuf_AddText(cmd_local, string);
}
/*
char string[VM_STRINGTEMP_LENGTH];
VM_SAFEPARMCOUNTRANGE(1, 8, VM_localcmd_server);
VM_VarString(prog, 0, string, sizeof(string));
- Cbuf_AddText(&cmd_server, string);
+ Cbuf_AddText(cmd_local, string);
}
static qbool PRVM_Cvar_ReadOk(prvm_prog_t *prog, const char *string)
VM_SAFEPARMCOUNT(1, VM_ftoe);
ent = (prvm_int_t)PRVM_G_FLOAT(OFS_PARM0);
- if (ent < 0 || ent >= prog->max_edicts || PRVM_PROG_TO_EDICT(ent)->priv.required->free)
+ if (ent < 0 || ent >= prog->max_edicts || PRVM_PROG_TO_EDICT(ent)->free)
ent = 0; // return world instead of a free or invalid entity
PRVM_G_INT(OFS_RETURN) = ent;
if (developer.integer > 0)
VM_Warning(prog, "VM_remove: tried to remove the null entity or a reserved entity!\n" );
}
- else if( ed->priv.required->free )
+ else if( ed->free )
{
if (developer.integer > 0)
VM_Warning(prog, "VM_remove: tried to remove an already freed entity!\n" );
{
prog->xfunction->builtinsprofile++;
ed = PRVM_EDICT_NUM(e);
- if (ed->priv.required->free)
+ if (ed->free)
continue;
t = PRVM_E_STRING(ed,f);
if (!t)
{
prog->xfunction->builtinsprofile++;
ed = PRVM_EDICT_NUM(e);
- if (ed->priv.required->free)
+ if (ed->free)
continue;
if (PRVM_E_FLOAT(ed,f) == s)
{
for (i = 1;i < prog->num_edicts;i++, ent = PRVM_NEXT_EDICT(ent))
{
prog->xfunction->builtinsprofile++;
- if (ent->priv.required->free)
+ if (ent->free)
continue;
t = PRVM_E_STRING(ent,f);
if (!t)
else
chainfield = prog->fieldoffsets.chain;
if (chainfield < 0)
- prog->error_cmd("VM_findchain: %s doesnt have the specified chain field !", prog->name);
+ prog->error_cmd("VM_findchainfloat: %s doesnt have the specified chain field !", prog->name);
chain = (prvm_edict_t *)prog->edicts;
for (i = 1;i < prog->num_edicts;i++, ent = PRVM_NEXT_EDICT(ent))
{
prog->xfunction->builtinsprofile++;
- if (ent->priv.required->free)
+ if (ent->free)
continue;
if (PRVM_E_FLOAT(ent,f) != s)
continue;
{
prog->xfunction->builtinsprofile++;
ed = PRVM_EDICT_NUM(e);
- if (ed->priv.required->free)
+ if (ed->free)
continue;
if (!PRVM_E_FLOAT(ed,f))
continue;
else
chainfield = prog->fieldoffsets.chain;
if (chainfield < 0)
- prog->error_cmd("VM_findchain: %s doesnt have the specified chain field !", prog->name);
+ prog->error_cmd("VM_findchainflags: %s doesnt have the specified chain field !", prog->name);
chain = (prvm_edict_t *)prog->edicts;
for (i = 1;i < prog->num_edicts;i++, ent = PRVM_NEXT_EDICT(ent))
{
prog->xfunction->builtinsprofile++;
- if (ent->priv.required->free)
+ if (ent->free)
continue;
if (!PRVM_E_FLOAT(ent,f))
continue;
*/
void VM_coredump(prvm_prog_t *prog)
{
- cmd_state_t *cmd = !host_isclient.integer ? &cmd_server : &cmd_client;
VM_SAFEPARMCOUNT(0,VM_coredump);
- Cbuf_AddText(cmd, "prvm_edicts ");
- Cbuf_AddText(cmd, prog->name);
- Cbuf_AddText(cmd, "\n");
+ Cbuf_AddText(cmd_local, "prvm_edicts ");
+ Cbuf_AddText(cmd_local, prog->name);
+ Cbuf_AddText(cmd_local, "\n");
}
/*
return;
}
ent = PRVM_EDICT_NUM(i);
- if (!ent->priv.required->free)
+ if (!ent->free)
{
VM_RETURN_EDICT(ent);
return;
return;
svs.changelevel_issued = true;
- Cbuf_AddText(&cmd_server, va(vabuf, sizeof(vabuf), "changelevel %s\n", PRVM_G_STRING(OFS_PARM0)));
+ Cbuf_AddText(cmd_local, va(vabuf, sizeof(vabuf), "changelevel %s\n", PRVM_G_STRING(OFS_PARM0)));
}
/*
return;
// check for overlap with a command
- if (Cmd_Exists(&cmd_client, name) || Cmd_Exists(&cmd_server, name))
+ if (Cmd_Exists(cmd_local, name))
{
VM_Warning(prog, "VM_registercvar: %s is a command\n", name);
return;
}
ent = PRVM_G_EDICT(OFS_PARM1);
- if(ent->priv.required->free)
+ if(ent->free)
{
VM_Warning(prog, "VM_writetofile: %s: entity %i is free !\n", prog->name, PRVM_NUM_FOR_EDICT(ent));
return;
// get the entity
ent = PRVM_G_EDICT(OFS_PARM1);
- if(ent->priv.required->free)
+ if(ent->free)
{
PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(prog, "");
VM_Warning(prog, "VM_entityfielddata: %s: entity %i is free !\n", prog->name, PRVM_NUM_FOR_EDICT(ent));
// get the entity
ent = PRVM_G_EDICT(OFS_PARM1);
- if(ent->priv.required->free)
+ if(ent->free)
{
VM_Warning(prog, "VM_entityfielddata: %s: entity %i is free !\n", prog->name, PRVM_NUM_FOR_EDICT(ent));
PRVM_G_FLOAT(OFS_RETURN) = 0.0f;
=========
VM_strcat
-string strcat(string,string,...[string])
+string strcat(string s, string...)
=========
*/
-//string(string s1, string s2) strcat = #115;
-// concatenates two strings (for example "abc", "def" would return "abcdef")
+//string(string s, string...) strcat = #115;
+// concatenates strings (for example "abc", "def" would return "abcdef")
// and returns as a tempstring
void VM_strcat(prvm_prog_t *prog)
{
VM_SAFEPARMCOUNT(1,VM_tokenize);
- strlcpy(tokenize_string, PRVM_G_STRING(OFS_PARM0), sizeof(tokenize_string));
+ dp_strlcpy(tokenize_string, PRVM_G_STRING(OFS_PARM0), sizeof(tokenize_string));
p = tokenize_string;
num_tokens = 0;
VM_SAFEPARMCOUNT(1, VM_tokenize_console);
- strlcpy(tokenize_string, PRVM_G_STRING(OFS_PARM0), sizeof(tokenize_string));
+ dp_strlcpy(tokenize_string, PRVM_G_STRING(OFS_PARM0), sizeof(tokenize_string));
p = tokenize_string;
num_tokens = 0;
VM_SAFEPARMCOUNTRANGE(2, 8,VM_tokenizebyseparator);
- strlcpy(tokenize_string, PRVM_G_STRING(OFS_PARM0), sizeof(tokenize_string));
+ dp_strlcpy(tokenize_string, PRVM_G_STRING(OFS_PARM0), sizeof(tokenize_string));
p = tokenize_string;
numseparators = 0;
// get edict and test it
ent = PRVM_G_EDICT(OFS_PARM0);
- if (ent->priv.required->free)
+ if (ent->free)
prog->error_cmd("VM_parseentitydata: %s: Can only set already spawned entities (entity %i is free)!", prog->name, PRVM_NUM_FOR_EDICT(ent));
data = PRVM_G_STRING(OFS_PARM1);
*/
void VM_modulo(prvm_prog_t *prog)
{
- prvm_int_t val, m;
+ vec_t val, m;
+
VM_SAFEPARMCOUNT(2, VM_modulo);
- val = (prvm_int_t) PRVM_G_FLOAT(OFS_PARM0);
- m = (prvm_int_t) PRVM_G_FLOAT(OFS_PARM1);
+ val = PRVM_G_FLOAT(OFS_PARM0);
+ m = PRVM_G_FLOAT(OFS_PARM1);
- PRVM_G_FLOAT(OFS_RETURN) = (prvm_vec_t) (val % m);
+ // matches how gmqcc implements % when mod() builtin isn't defined, and FTEQW mod()
+ if (m)
+ PRVM_G_FLOAT(OFS_RETURN) = val - m * (prvm_int_t)(val / m);
+ else
+ {
+ VM_Warning(prog, "Attempted modulo of %f by zero\n", val);
+ PRVM_G_FLOAT(OFS_RETURN) = 0;
+ }
}
static void VM_Search_Init(prvm_prog_t *prog)
*/
void VM_keynumtostring (prvm_prog_t *prog)
{
- char tinystr[2];
+ char tinystr[TINYSTR_LEN];
VM_SAFEPARMCOUNT(1, VM_keynumtostring);
- PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(prog, Key_KeynumToString((int)PRVM_G_FLOAT(OFS_PARM0), tinystr, sizeof(tinystr)));
+ PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(prog, Key_KeynumToString((int)PRVM_G_FLOAT(OFS_PARM0), tinystr, TINYSTR_LEN));
}
/*
ret[0] = 0;
for(i = 0; i < FKFC_NUMKEYS; i++)
- strlcat(ret, va(vabuf, sizeof(vabuf), " \'%i\'", keys[i]), sizeof(ret));
+ dp_strlcat(ret, va(vabuf, sizeof(vabuf), " \'%i\'", keys[i]), sizeof(ret));
PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(prog, ret);
}
if( *in == '\'' || (*in == '\\' && !*++in) )
break;
- strlcpy(out, in, outstr + sizeof(outstr) - out);
+ dp_strlcpy(out, in, outstr + sizeof(outstr) - out);
PRVM_G_INT( OFS_RETURN ) = PRVM_SetTempString(prog, outstr );
}
for( ; *set ; *out++ = *set++ );
*out++ = '\'';
- strlcpy(out, in, outstr + sizeof(outstr) - out);
+ dp_strlcpy(out, in, outstr + sizeof(outstr) - out);
PRVM_G_INT( OFS_RETURN ) = PRVM_SetTempString(prog, outstr );
}
l += (i > 0 ? strlen(sep) : 0) + strlen(stringbuffer->strings[i]);
if (l >= sizeof(k) - 1)
break;
- strlcat(k, sep, sizeof(k));
- strlcat(k, stringbuffer->strings[i], sizeof(k));
+ dp_strlcat(k, sep, sizeof(k));
+ dp_strlcat(k, stringbuffer->strings[i], sizeof(k));
}
}
PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(prog, k);
match = PRVM_G_STRING(OFS_PARM1);
else
{
- strlcpy(string, PRVM_G_STRING(OFS_PARM1), sizeof(string));
+ dp_strlcpy(string, PRVM_G_STRING(OFS_PARM1), sizeof(string));
match = detect_match_rule(string, &matchrule);
}
matchlen = (int)strlen(match);
match = PRVM_G_STRING(OFS_PARM1);
else
{
- strlcpy(string, PRVM_G_STRING(OFS_PARM1), sizeof(string));
+ dp_strlcpy(string, PRVM_G_STRING(OFS_PARM1), sizeof(string));
match = detect_match_rule(string, &matchrule);
}
VM_Warning(prog, "changeyaw: can not modify world entity\n");
return;
}
- if (ent->priv.server->free)
+ if (ent->free)
{
VM_Warning(prog, "changeyaw: can not modify free entity\n");
return;
VM_Warning(prog, "changepitch: can not modify world entity\n");
return;
}
- if (ent->priv.server->free)
+ if (ent->free)
{
VM_Warning(prog, "changepitch: can not modify free entity\n");
return;
key = PRVM_G_STRING(OFS_PARM1);
VM_VarString(prog, 2, value, sizeof(value));
- strlcpy(temp, info, VM_STRINGTEMP_LENGTH);
+ dp_strlcpy(temp, info, VM_STRINGTEMP_LENGTH);
InfoString_SetValue(temp, VM_STRINGTEMP_LENGTH, key, value);
void VM_wasfreed (prvm_prog_t *prog)
{
VM_SAFEPARMCOUNT(1, VM_wasfreed);
- PRVM_G_FLOAT(OFS_RETURN) = PRVM_G_EDICT(OFS_PARM0)->priv.required->free;
+ PRVM_G_FLOAT(OFS_RETURN) = PRVM_G_EDICT(OFS_PARM0)->free;
}
void VM_SetTraceGlobals(prvm_prog_t *prog, const trace_t *trace)
// POST: we sign postdata \0 query string
size_t ll;
handle->sigdata = (char *)Z_Malloc(8192);
- strlcpy(handle->sigdata, "X-D0-Blind-ID-Detached-Signature: ", 8192);
+ dp_strlcpy(handle->sigdata, "X-D0-Blind-ID-Detached-Signature: ", 8192);
l = strlen(handle->sigdata);
handle->siglen = Crypto_SignDataDetached(handle->postdata, handle->postlen + 1 + lq, postkeyid, handle->sigdata + l, 8192 - l);
if(!handle->siglen)
handle->sigdata[handle->siglen] = 0;
}
out1:
- strlcpy(handle->posttype, posttype, sizeof(handle->posttype));
+ dp_strlcpy(handle->posttype, posttype, sizeof(handle->posttype));
ret = Curl_Begin_ToMemory_POST(url, handle->sigdata, 0, handle->posttype, handle->postdata, handle->postlen, (unsigned char *) handle->buffer, sizeof(handle->buffer), uri_to_string_callback, handle);
}
else
// GET: we sign JUST the query string
size_t l, ll;
handle->sigdata = (char *)Z_Malloc(8192);
- strlcpy(handle->sigdata, "X-D0-Blind-ID-Detached-Signature: ", 8192);
+ dp_strlcpy(handle->sigdata, "X-D0-Blind-ID-Detached-Signature: ", 8192);
l = strlen(handle->sigdata);
handle->siglen = Crypto_SignDataDetached(query_string, lq, postkeyid, handle->sigdata + l, 8192 - l);
if(!handle->siglen)
}
}
+// DP_QC_NUDGEOUTOFSOLID
+// float(entity ent) nudgeoutofsolid = #567;
+void VM_nudgeoutofsolid(prvm_prog_t *prog)
+{
+ prvm_edict_t *ent;
+
+ VM_SAFEPARMCOUNTRANGE(1, 1, VM_nudgeoutofsolid);
+
+ ent = PRVM_G_EDICT(OFS_PARM0);
+ if (ent == prog->edicts)
+ {
+ VM_Warning(prog, "nudgeoutofsolid: can not modify world entity\n");
+ PRVM_G_FLOAT(OFS_RETURN) = 0;
+ return;
+ }
+ if (ent->free)
+ {
+ VM_Warning(prog, "nudgeoutofsolid: can not modify free entity\n");
+ PRVM_G_FLOAT(OFS_RETURN) = 0;
+ return;
+ }
+
+ PRVM_G_FLOAT(OFS_RETURN) = PHYS_NudgeOutOfSolid(prog, ent);
+
+ if (PRVM_G_FLOAT(OFS_RETURN) > 0)
+ {
+ if (prog == SVVM_prog)
+ SV_LinkEdict(ent);
+ else if (prog == CLVM_prog)
+ CL_LinkEdict(ent);
+ else
+ Sys_Error("PHYS_NudgeOutOfSolid: cannot be called from %s VM\n", prog->name);
+ }
+}
+
/*
=========
Common functions between menu.dat and clsprogs
ed = PRVM_G_EDICT(OFS_PARM0);
VectorCopy(PRVM_G_VECTOR(OFS_PARM1), point);
- if (!ed || ed->priv.server->free)
+ if (!ed || ed->free)
return;
model = getmodel(prog, ed);
if (!model || !model->num_surfaces)
// physics builtins
//
+#ifdef USEODE
#define VM_physics_ApplyCmd(ed,f) if (!ed->priv.server->ode_body) VM_physics_newstackfunction(prog, ed, f); else World_Physics_ApplyCmd(ed, f)
static edict_odefunc_t *VM_physics_newstackfunction(prvm_prog_t *prog, prvm_edict_t *ed, edict_odefunc_t *f)
}
return newfunc;
}
+#endif
// void(entity e, float physics_enabled) physics_enable = #;
void VM_physics_enable(prvm_prog_t *prog)
{
+#ifdef USEODE
prvm_edict_t *ed;
edict_odefunc_t f;
-
+#endif
VM_SAFEPARMCOUNT(2, VM_physics_enable);
+#ifdef USEODE
ed = PRVM_G_EDICT(OFS_PARM0);
if (!ed)
{
}
f.type = PRVM_G_FLOAT(OFS_PARM1) == 0 ? ODEFUNC_DISABLE : ODEFUNC_ENABLE;
VM_physics_ApplyCmd(ed, &f);
+#endif
}
// void(entity e, vector force, vector relative_ofs) physics_addforce = #;
void VM_physics_addforce(prvm_prog_t *prog)
{
+#ifdef USEODE
prvm_edict_t *ed;
edict_odefunc_t f;
-
+#endif
VM_SAFEPARMCOUNT(3, VM_physics_addforce);
+#ifdef USEODE
ed = PRVM_G_EDICT(OFS_PARM0);
if (!ed)
{
VectorCopy(PRVM_G_VECTOR(OFS_PARM1), f.v1);
VectorCopy(PRVM_G_VECTOR(OFS_PARM2), f.v2);
VM_physics_ApplyCmd(ed, &f);
+#endif
}
// void(entity e, vector torque) physics_addtorque = #;
void VM_physics_addtorque(prvm_prog_t *prog)
{
+#ifdef USEODE
prvm_edict_t *ed;
edict_odefunc_t f;
-
+#endif
VM_SAFEPARMCOUNT(2, VM_physics_addtorque);
+#ifdef USEODE
ed = PRVM_G_EDICT(OFS_PARM0);
if (!ed)
{
f.type = ODEFUNC_TORQUE;
VectorCopy(PRVM_G_VECTOR(OFS_PARM1), f.v1);
VM_physics_ApplyCmd(ed, &f);
+#endif
}
extern cvar_t prvm_coverage;
projects / xonotic / darkplaces.git / blobdiff