return s;
}
-#define RETURN_EDICT(e) (((int *)pr_globals)[OFS_RETURN] = EDICT_TO_PROG(e))
+#define RETURN_EDICT(e) (G_INT(OFS_RETURN) = EDICT_TO_PROG(e))
+#define PF_WARNING(s) do{Con_Printf(s);PR_PrintState();return;}while(0)
+#define PF_ERROR(s) do{Host_Error(s);return;}while(0)
/*
char *ENGINE_EXTENSIONS =
"DP_CL_LOADSKY "
-"DP_EF_NODRAW "
"DP_EF_ADDITIVE "
"DP_EF_BLUE "
-"DP_EF_RED "
-"DP_EF_FULLBRIGHT "
"DP_EF_FLAME "
+"DP_EF_FULLBRIGHT "
+"DP_EF_NODRAW "
+"DP_EF_RED "
"DP_EF_STARDUST "
"DP_ENT_ALPHA "
"DP_ENT_CUSTOMCOLORMAP "
"DP_ENT_EXTERIORMODELTOCLIENT "
-"DP_ENT_LOWPRECISION "
"DP_ENT_GLOW "
+"DP_ENT_LOWPRECISION "
"DP_ENT_SCALE "
"DP_ENT_VIEWMODEL "
"DP_GFX_EXTERNALTEXTURES "
"DP_HALFLIFE_MAP "
"DP_HALFLIFE_MAP_CVAR "
"DP_INPUTBUTTONS "
+"DP_LITSUPPORT "
"DP_MONSTERWALK "
"DP_MOVETYPEBOUNCEMISSILE "
"DP_MOVETYPEFOLLOW "
"DP_QC_CHANGEPITCH "
"DP_QC_COPYENTITY "
+"DP_QC_CVAR_STRING "
"DP_QC_ETOS "
"DP_QC_FINDCHAIN "
"DP_QC_FINDCHAINFLOAT "
"DP_QC_FINDFLOAT "
+"DP_QC_FS_SEARCH " // Black: same as in the menu qc
"DP_QC_GETLIGHT "
"DP_QC_GETSURFACE "
"DP_QC_MINMAXBOUND "
"DP_QC_SINCOSSQRTPOW "
"DP_QC_TRACEBOX "
"DP_QC_TRACETOSS "
-"DP_QC_TRACE_MOVETYPE_WORLDONLY "
"DP_QC_TRACE_MOVETYPE_HITMODEL "
+"DP_QC_TRACE_MOVETYPE_WORLDONLY "
"DP_QC_VECTORVECTORS "
"DP_QUAKE2_MODEL "
"DP_QUAKE3_MODEL "
"KRIMZON_SV_PARSECLIENTCOMMAND "
"NEH_CMD_PLAY2 "
"NEH_RESTOREGAME "
+"TENEBRAE_GFX_DLIGHTS "
"TW_SV_STEPCONTROL "
;
ed = PROG_TO_EDICT(pr_global_struct->self);
ED_Print (ed);
- Host_Error ("Program error");
+ PF_ERROR("Program error");
}
/*
e = G_EDICT(OFS_PARM0);
if (e == sv.edicts)
- Host_Error("setorigin: can not modify world entity\n");
+ PF_WARNING("setorigin: can not modify world entity\n");
if (e->e->free)
- Host_Error("setorigin: can not modify free entity\n");
+ PF_WARNING("setorigin: can not modify free entity\n");
org = G_VECTOR(OFS_PARM1);
VectorCopy (org, e->v->origin);
SV_LinkEdict (e, false);
for (i=0 ; i<3 ; i++)
if (min[i] > max[i])
- Host_Error ("backwards mins/maxs");
+ PF_ERROR("SetMinMaxSize: backwards mins/maxs\n");
// set derived values
VectorCopy (min, e->v->mins);
e = G_EDICT(OFS_PARM0);
if (e == sv.edicts)
- Host_Error("setsize: can not modify world entity\n");
+ PF_WARNING("setsize: can not modify world entity\n");
if (e->e->free)
- Host_Error("setsize: can not modify free entity\n");
+ PF_WARNING("setsize: can not modify free entity\n");
min = G_VECTOR(OFS_PARM1);
max = G_VECTOR(OFS_PARM2);
SetMinMaxSize (e, min, max, false);
e = G_EDICT(OFS_PARM0);
if (e == sv.edicts)
- Host_Error("setmodel: can not modify world entity\n");
+ PF_WARNING("setmodel: can not modify world entity\n");
if (e->e->free)
- Host_Error("setmodel: can not modify free entity\n");
+ PF_WARNING("setmodel: can not modify free entity\n");
m = G_STRING(OFS_PARM1);
// check to see if model was properly precached
break;
if (!*check)
- Host_Error ("no precache: %s\n", m);
+ PF_WARNING("setmodel: no precache\n");
e->v->model = PR_SetString(*check);
attenuation = G_FLOAT(OFS_PARM4);
if (volume < 0 || volume > 255)
- Host_Error ("SV_StartSound: volume = %i", volume);
+ PF_WARNING("SV_StartSound: volume must be in range 0-1\n");
if (attenuation < 0 || attenuation > 4)
- Host_Error ("SV_StartSound: attenuation = %f", attenuation);
+ PF_WARNING("SV_StartSound: attenuation must be in range 0-4\n");
if (channel < 0 || channel > 7)
- Host_Error ("SV_StartSound: channel = %i", channel);
+ PF_WARNING("SV_StartSound: channel must be in range 0-7\n");
SV_StartSound (entity, channel, sample, volume, attenuation);
}
*/
void PF_break (void)
{
- Host_Error ("break statement");
+ PF_ERROR("break: break statement\n");
}
/*
{
float *v1, *v2;
trace_t trace;
- int nomonsters;
+ int move;
edict_t *ent;
pr_xfunction->builtinsprofile += 30;
v1 = G_VECTOR(OFS_PARM0);
v2 = G_VECTOR(OFS_PARM1);
- nomonsters = G_FLOAT(OFS_PARM2);
+ move = G_FLOAT(OFS_PARM2);
ent = G_EDICT(OFS_PARM3);
- trace = SV_Move (v1, vec3_origin, vec3_origin, v2, nomonsters, ent);
+ trace = SV_Move (v1, vec3_origin, vec3_origin, v2, move, ent);
pr_global_struct->trace_allsolid = trace.allsolid;
pr_global_struct->trace_startsolid = trace.startsolid;
{
float *v1, *v2, *m1, *m2;
trace_t trace;
- int nomonsters;
+ int move;
edict_t *ent;
pr_xfunction->builtinsprofile += 30;
m1 = G_VECTOR(OFS_PARM1);
m2 = G_VECTOR(OFS_PARM2);
v2 = G_VECTOR(OFS_PARM3);
- nomonsters = G_FLOAT(OFS_PARM4);
+ move = G_FLOAT(OFS_PARM4);
ent = G_EDICT(OFS_PARM5);
- trace = SV_Move (v1, m1, m2, v2, nomonsters ? MOVE_NOMONSTERS : MOVE_NORMAL, ent);
+ trace = SV_Move (v1, m1, m2, v2, move, ent);
pr_global_struct->trace_allsolid = trace.allsolid;
pr_global_struct->trace_startsolid = trace.startsolid;
ent = G_EDICT(OFS_PARM0);
if (ent == sv.edicts)
- Host_Error("tracetoss: can not use world entity\n");
+ PF_WARNING("tracetoss: can not use world entity\n");
ignore = G_EDICT(OFS_PARM1);
trace = SV_Trace_Toss (ent, ignore);
ed = G_EDICT(OFS_PARM0);
if (ed == sv.edicts)
- Host_Error("remove: tried to remove world\n");
+ PF_WARNING("remove: tried to remove world\n");
if (NUM_FOR_EDICT(ed) <= svs.maxclients)
- Host_Error("remove: tried to remove a client\n");
+ PF_WARNING("remove: tried to remove a client\n");
// LordHavoc: not an error because id1 progs did this in some cases (killtarget removes entities, even if they are already removed in some cases...)
if (ed->e->free && developer.integer)
- Con_Printf("remove: tried to remove an entity that was already removed\n");
+ PF_WARNING("remove: tried to remove an entity that was already removed\n");
ED_Free (ed);
}
void PR_CheckEmptyString (char *s)
{
if (s[0] <= ' ')
- Host_Error ("Bad string");
+ PF_ERROR("Bad string");
}
void PF_precache_file (void)
int i;
if (sv.state != ss_loading)
- Host_Error ("PF_Precache_*: Precache can only be done in spawn functions");
+ PF_ERROR("PF_Precache_*: Precache can only be done in spawn functions");
s = G_STRING(OFS_PARM0);
G_INT(OFS_RETURN) = G_INT(OFS_PARM0);
if (!strcmp(sv.sound_precache[i], s))
return;
}
- Host_Error ("PF_precache_sound: overflow");
+ PF_ERROR("PF_precache_sound: overflow");
}
void PF_precache_model (void)
int i;
if (sv.state != ss_loading)
- Host_Error ("PF_Precache_*: Precache can only be done in spawn functions");
+ PF_ERROR("PF_Precache_*: Precache can only be done in spawn functions");
s = G_STRING(OFS_PARM0);
if (sv.worldmodel->brush.ishlbsp && ((!s) || (!s[0])))
if (!strcmp(sv.model_precache[i], s))
return;
}
- Host_Error ("PF_precache_model: overflow");
+ PF_ERROR("PF_precache_model: overflow");
}
mfunction_t *oldf;
int oldself;
+ // assume failure if it returns early
+ G_FLOAT(OFS_RETURN) = 0;
+
ent = PROG_TO_EDICT(pr_global_struct->self);
if (ent == sv.edicts)
- Host_Error("walkmove: can not modify world entity\n");
+ PF_WARNING("walkmove: can not modify world entity\n");
if (ent->e->free)
- Host_Error("walkmove: can not modify free entity\n");
+ PF_WARNING("walkmove: can not modify free entity\n");
yaw = G_FLOAT(OFS_PARM0);
dist = G_FLOAT(OFS_PARM1);
if ( !( (int)ent->v->flags & (FL_ONGROUND|FL_FLY|FL_SWIM) ) )
- {
- G_FLOAT(OFS_RETURN) = 0;
return;
- }
yaw = yaw*M_PI*2 / 360;
vec3_t end;
trace_t trace;
+ // assume failure if it returns early
+ G_FLOAT(OFS_RETURN) = 0;
+
ent = PROG_TO_EDICT(pr_global_struct->self);
if (ent == sv.edicts)
- Host_Error("droptofloor: can not modify world entity\n");
+ PF_WARNING("droptofloor: can not modify world entity\n");
if (ent->e->free)
- Host_Error("droptofloor: can not modify free entity\n");
+ PF_WARNING("droptofloor: can not modify free entity\n");
VectorCopy (ent->v->origin, end);
end[2] -= 256;
trace = SV_Move (ent->v->origin, ent->v->mins, ent->v->maxs, end, MOVE_NORMAL, ent);
- if (trace.fraction == 1)
- G_FLOAT(OFS_RETURN) = 0;
- else
+ if (trace.fraction != 1)
{
VectorCopy (trace.endpos, ent->v->origin);
SV_LinkEdict (ent, false);
float dist, bestdist;
float speed;
+ // assume failure if it returns early
+ VectorClear(G_VECTOR(OFS_RETURN));
+
ent = G_EDICT(OFS_PARM0);
if (ent == sv.edicts)
- Host_Error("aim: can not use world entity\n");
+ PF_WARNING("aim: can not use world entity\n");
if (ent->e->free)
- Host_Error("aim: can not use free entity\n");
+ PF_WARNING("aim: can not use free entity\n");
speed = G_FLOAT(OFS_PARM1);
VectorCopy (ent->v->origin, start);
ent = PROG_TO_EDICT(pr_global_struct->self);
if (ent == sv.edicts)
- Host_Error("changeyaw: can not modify world entity\n");
+ PF_WARNING("changeyaw: can not modify world entity\n");
if (ent->e->free)
- Host_Error("changeyaw: can not modify free entity\n");
+ PF_WARNING("changeyaw: can not modify free entity\n");
current = ANGLEMOD(ent->v->angles[1]);
ideal = ent->v->ideal_yaw;
speed = ent->v->yaw_speed;
ent = G_EDICT(OFS_PARM0);
if (ent == sv.edicts)
- Host_Error("changepitch: can not modify world entity\n");
+ PF_WARNING("changepitch: can not modify world entity\n");
if (ent->e->free)
- Host_Error("changepitch: can not modify free entity\n");
+ PF_WARNING("changepitch: can not modify free entity\n");
current = ANGLEMOD( ent->v->angles[0] );
if ((val = GETEDICTFIELDVALUE(ent, eval_idealpitch)))
ideal = val->_float;
else
{
- Host_Error ("PF_changepitch: .float idealpitch and .float pitch_speed must be defined to use changepitch");
+ PF_WARNING("PF_changepitch: .float idealpitch and .float pitch_speed must be defined to use changepitch\n");
return;
}
if ((val = GETEDICTFIELDVALUE(ent, eval_pitch_speed)))
speed = val->_float;
else
{
- Host_Error ("PF_changepitch: .float idealpitch and .float pitch_speed must be defined to use changepitch");
+ PF_WARNING("PF_changepitch: .float idealpitch and .float pitch_speed must be defined to use changepitch\n");
return;
}
return &sv.signon;
default:
- Host_Error ("WriteDest: bad destination");
+ Host_Error("WriteDest: bad destination");
break;
}
ent = G_EDICT(OFS_PARM0);
if (ent == sv.edicts)
- Host_Error("makestatic: can not modify world entity\n");
+ PF_WARNING("makestatic: can not modify world entity\n");
if (ent->e->free)
- Host_Error("makestatic: can not modify free entity\n");
+ PF_WARNING("makestatic: can not modify free entity\n");
large = false;
if (ent->v->modelindex >= 256 || ent->v->frame >= 256)
}
if (currentqc_cvar >= MAX_QC_CVARS)
- Host_Error ("PF_registercvar: ran out of cvar slots (%i)\n", MAX_QC_CVARS);
+ PF_ERROR("PF_registercvar: ran out of cvar slots\n");
// copy the name and value
variable = &qc_cvar[currentqc_cvar++];
G_FLOAT(OFS_RETURN) = f;
}
else
- Host_Error("min: must supply at least 2 floats\n");
+ {
+ G_FLOAT(OFS_RETURN) = 0;
+ PF_WARNING("min: must supply at least 2 floats\n");
+ }
}
/*
G_FLOAT(OFS_RETURN) = f;
}
else
- Host_Error("max: must supply at least 2 floats\n");
+ {
+ G_FLOAT(OFS_RETURN) = 0;
+ PF_WARNING("max: must supply at least 2 floats\n");
+ }
}
/*
edict_t *in, *out;
in = G_EDICT(OFS_PARM0);
if (in == sv.edicts)
- Host_Error("copyentity: can not read world entity\n");
+ PF_WARNING("copyentity: can not read world entity\n");
if (in->e->free)
- Host_Error("copyentity: can not read free entity\n");
+ PF_WARNING("copyentity: can not read free entity\n");
out = G_EDICT(OFS_PARM1);
if (out == sv.edicts)
- Host_Error("copyentity: can not modify world entity\n");
+ PF_WARNING("copyentity: can not modify world entity\n");
if (out->e->free)
- Host_Error("copyentity: can not modify free entity\n");
+ PF_WARNING("copyentity: can not modify free entity\n");
memcpy(out->v, in->v, progs->entityfields * 4);
}
char *s;
s = G_STRING(OFS_PARM1);
if (!s || !s[0])
- Host_Error("effect: no model specified\n");
+ PF_WARNING("effect: no model specified\n");
SV_StartEffect(G_VECTOR(OFS_PARM0), SV_ModelIndex(s), G_FLOAT(OFS_PARM2), G_FLOAT(OFS_PARM3), G_FLOAT(OFS_PARM4));
}
//float(string s) tokenize = #441; // takes apart a string into individal words (access them with argv), returns how many
//this function originally written by KrimZon, made shorter by LordHavoc
-char **tokens = NULL;
-int max_tokens, num_tokens = 0;
+//20040203: rewritten by LordHavoc (no longer uses allocations)
+int num_tokens = 0;
+char *tokens[256], tokenbuf[4096];
void PF_tokenize (void)
{
+ int pos;
const char *p;
- char *str;
- str = G_STRING(OFS_PARM0);
-
- if (tokens != NULL)
- {
- int i;
- for (i=0;i<num_tokens;i++)
- Z_Free(tokens[i]);
- Z_Free(tokens);
- num_tokens = 0;
- }
+ p = G_STRING(OFS_PARM0);
- tokens = Z_Malloc(strlen(str) * sizeof(char *));
- max_tokens = strlen(str);
-
- for (p = str;COM_ParseToken(&p, false) && num_tokens < max_tokens;num_tokens++)
+ num_tokens = 0;
+ pos = 0;
+ while(COM_ParseToken(&p, false))
{
- tokens[num_tokens] = Z_Malloc(strlen(com_token) + 1);
- strcpy(tokens[num_tokens], com_token);
+ if (num_tokens >= (int)(sizeof(tokens)/sizeof(tokens[0])))
+ break;
+ if (pos + strlen(com_token) + 1 > sizeof(tokenbuf))
+ break;
+ tokens[num_tokens++] = tokenbuf + pos;
+ strcpy(tokenbuf + pos, com_token);
+ pos += strlen(com_token) + 1;
}
G_FLOAT(OFS_RETURN) = num_tokens;
model_t *model;
if (e == sv.edicts)
- Host_Error("setattachment: can not modify world entity\n");
+ PF_WARNING("setattachment: can not modify world entity\n");
if (e->e->free)
- Host_Error("setattachment: can not modify free entity\n");
+ PF_WARNING("setattachment: can not modify free entity\n");
if (tagentity == NULL)
tagentity = sv.edicts;
}
+/////////////////////////////////////////
+// DP_QC_FS_SEARCH extension
+
+// qc fs search handling
+#define MAX_SEARCHES 128
+
+fssearch_t *pr_fssearchlist[MAX_SEARCHES];
+
+void PR_Search_Init(void)
+{
+ memset(pr_fssearchlist,0,sizeof(pr_fssearchlist));
+}
+
+void PR_Search_Reset(void)
+{
+ int i;
+ // reset the fssearch list
+ for(i = 0; i < MAX_SEARCHES; i++)
+ if(pr_fssearchlist[i])
+ FS_FreeSearch(pr_fssearchlist[i]);
+ memset(pr_fssearchlist,0,sizeof(pr_fssearchlist));
+}
+
+/*
+=========
+PF_search_begin
+
+float search_begin(string pattern, float caseinsensitive, float quiet)
+=========
+*/
+void PF_search_begin(void)
+{
+ int handle;
+ char *pattern;
+ int caseinsens, quiet;
+
+ pattern = G_STRING(OFS_PARM0);
+
+ PR_CheckEmptyString(pattern);
+
+ caseinsens = G_FLOAT(OFS_PARM1);
+ quiet = G_FLOAT(OFS_PARM2);
+
+ for(handle = 0; handle < MAX_SEARCHES; handle++)
+ if(!pr_fssearchlist[handle])
+ break;
+
+ if(handle >= MAX_SEARCHES)
+ {
+ Con_Printf("PR_search_begin: ran out of search handles (%i)\n", MAX_SEARCHES);
+ G_FLOAT(OFS_RETURN) = -2;
+ return;
+ }
+
+ if(!(pr_fssearchlist[handle] = FS_Search(pattern,caseinsens, quiet)))
+ G_FLOAT(OFS_RETURN) = -1;
+ else
+ G_FLOAT(OFS_RETURN) = handle;
+}
+
+/*
+=========
+VM_search_end
+
+void search_end(float handle)
+=========
+*/
+void PF_search_end(void)
+{
+ int handle;
+
+ handle = G_FLOAT(OFS_PARM0);
+
+ if(handle < 0 || handle >= MAX_SEARCHES)
+ {
+ Con_Printf("PF_search_end: invalid handle %i\n", handle);
+ return;
+ }
+ if(pr_fssearchlist[handle] == NULL)
+ {
+ Con_Printf("PF_search_end: no such handle %i\n", handle);
+ return;
+ }
+
+ FS_FreeSearch(pr_fssearchlist[handle]);
+ pr_fssearchlist[handle] = NULL;
+}
+
+/*
+=========
+VM_search_getsize
+
+float search_getsize(float handle)
+=========
+*/
+void PF_search_getsize(void)
+{
+ int handle;
+
+ handle = G_FLOAT(OFS_PARM0);
+
+ if(handle < 0 || handle >= MAX_SEARCHES)
+ {
+ Con_Printf("PF_search_getsize: invalid handle %i\n", handle);
+ return;
+ }
+ if(pr_fssearchlist[handle] == NULL)
+ {
+ Con_Printf("PF_search_getsize: no such handle %i\n", handle);
+ return;
+ }
+
+ G_FLOAT(OFS_RETURN) = pr_fssearchlist[handle]->numfilenames;
+}
+
+/*
+=========
+VM_search_getfilename
+
+string search_getfilename(float handle, float num)
+=========
+*/
+void PF_search_getfilename(void)
+{
+ int handle, filenum;
+ char *tmp;
+
+ handle = G_FLOAT(OFS_PARM0);
+ filenum = G_FLOAT(OFS_PARM1);
+
+ if(handle < 0 || handle >= MAX_SEARCHES)
+ {
+ Con_Printf("PF_search_getfilename: invalid handle %i\n", handle);
+ return;
+ }
+ if(pr_fssearchlist[handle] == NULL)
+ {
+ Con_Printf("PF_search_getfilename: no such handle %i\n", handle);
+ return;
+ }
+ if(filenum < 0 || filenum >= pr_fssearchlist[handle]->numfilenames)
+ {
+ Con_Printf("PF_search_getfilename: invalid filenum %i\n", filenum);
+ return;
+ }
+
+ tmp = PR_GetTempString();
+ strcpy(tmp, pr_fssearchlist[handle]->filenames[filenum]);
+
+ G_INT(OFS_RETURN) = PR_SetString(tmp);
+}
+
+void PF_cvar_string (void)
+{
+ char *str;
+ cvar_t *var;
+ char *tmp;
+
+ str = G_STRING(OFS_PARM0);
+ var = Cvar_FindVar (str);
+
+ tmp = PR_GetTempString();
+ strcpy(tmp, var->string);
+
+ G_INT(OFS_RETURN) = PR_SetString(tmp);
+}
+
+
+
builtin_t pr_builtin[] =
{
NULL, // #0
PF_tokenize, // #441 float(string s) tokenize (KRIMZON_SV_PARSECLIENTCOMMAND)
PF_argv, // #442 string(float n) argv (KRIMZON_SV_PARSECLIENTCOMMAND)
PF_setattachment, // #443 void(entity e, entity tagentity, string tagname) setattachment (DP_GFX_QUAKE3MODELTAGS)
-NULL, // #444
-NULL, // #445
-NULL, // #446
-NULL, // #447
-NULL, // #448
+PF_search_begin, // #444
+PF_search_end, // #445
+PF_search_getsize, // #446
+PF_search_getfilename, // #447
+PF_cvar_string, // #448 string(string s) cvar_string (DP_QC_CVAR_STRING)
NULL, // #449
a a a a a // #450-499 (LordHavoc)
};
{
pr_strings_mempool = Mem_AllocPool("pr_stringszone");
PR_Files_Init();
+ PR_Search_Init();
}
void PR_Cmd_Reset(void)
{
Mem_EmptyPool(pr_strings_mempool);
+ PR_Search_Reset();
PR_Files_CloseAll();
}
projects / xonotic / darkplaces.git / blobdiff