// 2000-05-02 NVS SVC by Maddes
void PF_NVS_InitSVCMsg(void)
{
edict_t *ent;
int entnum;
client_t *client;
client = NULL;
ent = G_EDICT(OFS_PARM3);
entnum = NUM_FOR_EDICT(ent);
if (entnum == 0) // world means all clients
{
client = NULL;
}
else if (entnum < 1 || entnum > svs.maxclients)
{
PR_RunError ("PF_NVS_InitSVCMsg: entity not a client");
}
else
{
client = &svs.clients[entnum-1];
}
NVS_InitSVCMsg(G_FLOAT(OFS_PARM0), G_FLOAT(OFS_PARM1), G_FLOAT(OFS_PARM2), client);
}
/*
======================
SV_MoveToGoal
======================
*/
void SV_MoveToGoal (void)
{
edict_t *ent, *goal;
float dist;
#ifdef QUAKE2
edict_t *enemy;
#endif
ent = PROG_TO_EDICT(pr_global_struct->self);
goal = PROG_TO_EDICT(ent->v.goalentity);
dist = G_FLOAT(OFS_PARM0);
if ( !( (int)ent->v.flags & (FL_ONGROUND|FL_FLY|FL_SWIM) ) )
{
G_FLOAT(OFS_RETURN) = 0;
return;
}
// if the next step hits the enemy, return immediately
#ifdef QUAKE2
enemy = PROG_TO_EDICT(ent->v.enemy);
if (enemy != sv.edicts && SV_CloseEnough (ent, enemy, dist) )
#else
if ( PROG_TO_EDICT(ent->v.enemy) != sv.edicts && SV_CloseEnough (ent, goal, dist) )
#endif
return;
// bump around...
if ( (rand()&3)==1 ||
!SV_StepDirection (ent, ent->v.ideal_yaw, dist))
{
SV_NewChaseDir (ent, goal, dist);
}
}
qbool PR1_ClientSay(int isTeamSay, char *message)
{
qbool ret = false;
if (mod_ChatMessage)
{
int j;
// remove surrounding " if any.
if (message[0] == '"' && (j = (int)strlen(message)) > 2 && message[j-1] == '"')
{
message++; // skip opening ".
message[max(0,(int)strlen(message)-1)] = 0; // truncate closing ".
}
PR_SetTmpString(&G_INT(OFS_PARM0), message);
G_FLOAT(OFS_PARM1) = (float)isTeamSay;
PR_ExecuteProgram(mod_ChatMessage);
ret = !!G_FLOAT(OFS_RETURN);
}
return ret;
}
// #487 float(string name, string video="http:") gecko_create
void QCBUILTIN PF_cs_media_create (pubprogfuncs_t *prinst, struct globalvars_s *pr_globals)
{
const char *shadername = PR_GetStringOfs(prinst, OFS_PARM0);
const char *videoname = (prinst->callargc > 1)?PR_GetStringOfs(prinst, OFS_PARM1):"http:";
cin_t *cin;
cin = R_ShaderGetCinematic(R_RegisterShader(shadername, SUF_2D, va(
"{\n"
"program default2d\n"
"{\n"
"videomap %s\n"
"rgbgen vertex\n"
"alphagen vertex\n"
"blendfunc blend\n"
"nodepth\n"
"}\n"
"}\n",
videoname)));
if (cin)
{
G_FLOAT(OFS_RETURN) = 1;
Media_Send_Reset(cin);
}
else
G_FLOAT(OFS_RETURN) = 0;
}
void QCBUILTIN PF_soundlength (pubprogfuncs_t *prinst, struct globalvars_s *pr_globals)
{
const char *sample = PR_GetStringOfs(prinst, OFS_PARM0);
sfx_t *sfx = S_PrecacheSound(sample);
if (sfx && sfx->loadstate == SLS_LOADING)
COM_WorkerPartialSync(sfx, &sfx->loadstate, SLS_LOADING);
if (!sfx || sfx->loadstate != SLS_LOADED)
G_FLOAT(OFS_RETURN) = 0;
else
{
sfxcache_t cachebuf, *cache;
if (sfx->decoder.querydata)
{
G_FLOAT(OFS_RETURN) = sfx->decoder.querydata(sfx, NULL);
return;
}
else if (sfx->decoder.decodedata)
cache = sfx->decoder.decodedata(sfx, &cachebuf, 0x7ffffffe, 0);
else
cache = sfx->decoder.buf;
if (!cache)
G_FLOAT(OFS_RETURN) = 0;
else
G_FLOAT(OFS_RETURN) = (cache->soundoffset+cache->length) / (float)snd_speed;
}
}
void QCBUILTIN PF_cl_getkeybind (pubprogfuncs_t *prinst, struct globalvars_s *pr_globals)
{
int keymap = (prinst->callargc > 1)?G_FLOAT(OFS_PARM1):0;
int modifier = (prinst->callargc > 2)?G_FLOAT(OFS_PARM2):0;
char *binding = Key_GetBinding(MP_TranslateQCtoFTECodes(G_FLOAT(OFS_PARM0)), keymap, modifier);
RETURN_TSTRING(binding);
}
void QCBUILTIN PF_cl_localsound(pubprogfuncs_t *prinst, struct globalvars_s *pr_globals)
{
const char * s = PR_GetStringOfs(prinst, OFS_PARM0);
float chan = (prinst->callargc>=1)?G_FLOAT(OFS_PARM1):0;
float vol = (prinst->callargc>=2)?G_FLOAT(OFS_PARM2):1;
S_LocalSound2(s, chan, vol);
}
//void sethostcachemaskstring(float mask, float fld, string str, float op) = #616;
void QCBUILTIN PF_cl_sethostcachemaskstring(pubprogfuncs_t *prinst, struct globalvars_s *pr_globals)
{
int mask = G_FLOAT(OFS_PARM0);
int field = G_FLOAT(OFS_PARM1);
const char *str = PR_GetStringOfs(prinst, OFS_PARM2);
int op = G_FLOAT(OFS_PARM3);
Master_SetMaskString(mask, field, str, op);
}
//void sethostcachemasknumber(float mask, float fld, float num, float op) = #617;
void QCBUILTIN PF_cl_sethostcachemasknumber(pubprogfuncs_t *prinst, struct globalvars_s *pr_globals)
{
int mask = G_FLOAT(OFS_PARM0);
int field = G_FLOAT(OFS_PARM1);
int str = G_FLOAT(OFS_PARM2);
int op = G_FLOAT(OFS_PARM3);
Master_SetMaskInteger(mask, field, str, op);
}
void QCBUILTIN PF_cl_clientcount (pubprogfuncs_t *prinst, struct globalvars_s *pr_globals)
{
#ifndef CLIENTONLY
if (sv.active)
G_FLOAT(OFS_RETURN) = sv.allocated_client_slots;
else
G_FLOAT(OFS_RETURN) = 0;
#endif
}
void QCBUILTIN PF_cl_getcursormode (pubprogfuncs_t *prinst, struct globalvars_s *pr_globals)
{
world_t *world = prinst->parms->user;
if (G_FLOAT(OFS_PARM0))
G_FLOAT(OFS_RETURN) = Key_MouseShouldBeFree();
else if (key_dest_absolutemouse & world->keydestmask)
G_FLOAT(OFS_RETURN) = true;
else
G_FLOAT(OFS_RETURN) = false;
}
void QCBUILTIN PF_cl_SetBindMap (pubprogfuncs_t *prinst, struct globalvars_s *pr_globals)
{
int bm[2] =
{
G_FLOAT(OFS_PARM0+0),
G_FLOAT(OFS_PARM0+1)
};
Key_SetBindMap(bm);
G_FLOAT(OFS_RETURN) = 1;
}
// #490 float(string name, float key, float eventtype) gecko_keyevent
void QCBUILTIN PF_cs_media_keyevent (pubprogfuncs_t *prinst, struct globalvars_s *pr_globals)
{
const char *shader = PR_GetStringOfs(prinst, OFS_PARM0);
int key = G_FLOAT(OFS_PARM1);
int eventtype = G_FLOAT(OFS_PARM2);
cin_t *cin;
cin = R_ShaderFindCinematic(shader);
if (!cin)
return;
Media_Send_KeyEvent(cin, MP_TranslateQCtoFTECodes(key), (key>127)?0:key, eventtype);
}
// #492 void(string name, float w, float h) gecko_resize
void QCBUILTIN PF_cs_media_resize (pubprogfuncs_t *prinst, struct globalvars_s *pr_globals)
{
const char *shader = PR_GetStringOfs(prinst, OFS_PARM0);
float sizex = G_FLOAT(OFS_PARM1);
float sizey = G_FLOAT(OFS_PARM2);
cin_t *cin;
cin = R_ShaderFindCinematic(shader);
if (!cin)
return;
Media_Send_Resize(cin, sizex, sizey);
}
//float gethostcachenumber(float fld, float hostnr) = #621;
void QCBUILTIN PF_cl_gethostcachenumber(pubprogfuncs_t *prinst, struct globalvars_s *pr_globals)
{
float ret = 0;
int keynum = G_FLOAT(OFS_PARM0);
int svnum = G_FLOAT(OFS_PARM1);
serverinfo_t *sv;
sv = Master_SortedServer(svnum);
ret = Master_ReadKeyFloat(sv, keynum);
G_FLOAT(OFS_RETURN) = ret;
}
void QCBUILTIN PF_cl_gethostcachestring (pubprogfuncs_t *prinst, struct globalvars_s *pr_globals)
{
char *ret;
int keynum = G_FLOAT(OFS_PARM0);
int svnum = G_FLOAT(OFS_PARM1);
serverinfo_t *sv;
sv = Master_SortedServer(svnum);
ret = Master_ReadKeyString(sv, keynum);
RETURN_TSTRING(ret);
}
void QCBUILTIN PF_cl_playingdemo (pubprogfuncs_t *prinst, struct globalvars_s *pr_globals)
{
switch(cls.demoplayback)
{
case DPB_NONE:
G_FLOAT(OFS_RETURN) = 0;
break;
case DPB_MVD:
case DPB_EZTV:
G_FLOAT(OFS_RETURN) = 2;
break;
default:
G_FLOAT(OFS_RETURN) = 1;
break;
}
}
void QCBUILTIN PF_cl_stringtokeynum(pubprogfuncs_t *prinst, struct globalvars_s *pr_globals)
{
int i;
int modifier;
const char *s;
s = PR_GetStringOfs(prinst, OFS_PARM0);
i = Key_StringToKeynum(s, &modifier);
if (i < 0 || modifier != ~0)
{
G_FLOAT(OFS_RETURN) = -1;
return;
}
i = MP_TranslateFTEtoQCCodes(i);
G_FLOAT(OFS_RETURN) = i;
}
void QCBUILTIN PF_cl_runningserver (pubprogfuncs_t *prinst, struct globalvars_s *pr_globals)
{
#ifdef CLIENTONLY
G_FLOAT(OFS_RETURN) = false;
#else
if (sv.state != ss_dead)
{
if (sv.allocated_client_slots > 1)
G_FLOAT(OFS_RETURN) = true;
else
G_FLOAT(OFS_RETURN) = 0.5; //give some half-way value if we're singleplayer. NOTE: DP returns 0 in this case, which is kinda useless for things like deciding whether a 'save' menu option can be used.
}
else
G_FLOAT(OFS_RETURN) = false;
#endif
}
void QCBUILTIN PF_shaderforname (pubprogfuncs_t *prinst, struct globalvars_s *pr_globals)
{
const char *str = PR_GetStringOfs(prinst, OFS_PARM0);
const char *defaultbody = PF_VarString(prinst, 1, pr_globals);
shader_t *shad;
if (*defaultbody)
shad = R_RegisterShader(str, SUF_NONE, defaultbody);
else
shad = R_RegisterSkin(str, NULL);
if (shad)
G_FLOAT(OFS_RETURN) = shad->id+1;
else
G_FLOAT(OFS_RETURN) = 0;
}
//string keynumtostring(float keynum) = #609;
void QCBUILTIN PF_cl_keynumtostring (pubprogfuncs_t *prinst, struct globalvars_s *pr_globals)
{
int code = G_FLOAT(OFS_PARM0);
code = MP_TranslateQCtoFTECodes (code);
RETURN_TSTRING(Key_KeynumToString(code, 0));
}
void PR1_PausedTic(float duration)
{
if (GE_PausedTic)
{
G_FLOAT(OFS_PARM0) = duration;
PR_ExecuteProgram (GE_PausedTic);
}
}
void QCBUILTIN PF_cl_gethostcachevalue (pubprogfuncs_t *prinst, struct globalvars_s *pr_globals)
{
hostcacheglobal_t hcg = G_FLOAT(OFS_PARM0);
G_FLOAT(OFS_RETURN) = 0;
switch(hcg)
{
case SLIST_HOSTCACHEVIEWCOUNT:
CL_QueryServers();
Master_CheckPollSockets();
G_FLOAT(OFS_RETURN) = Master_NumSorted();
return;
case SLIST_HOSTCACHETOTALCOUNT:
CL_QueryServers();
Master_CheckPollSockets();
G_FLOAT(OFS_RETURN) = Master_TotalCount();
return;
case SLIST_MASTERQUERYCOUNT:
case SLIST_MASTERREPLYCOUNT:
case SLIST_SERVERQUERYCOUNT:
case SLIST_SERVERREPLYCOUNT:
G_FLOAT(OFS_RETURN) = 0;
return;
case SLIST_SORTFIELD:
G_FLOAT(OFS_RETURN) = Master_GetSortField();
return;
case SLIST_SORTDESCENDING:
G_FLOAT(OFS_RETURN) = Master_GetSortDescending();
return;
default:
return;
}
}
void QCBUILTIN PF_cs_media_setstate (pubprogfuncs_t *prinst, struct globalvars_s *pr_globals)
{
const char *shader = PR_GetStringOfs(prinst, OFS_PARM0);
cinstates_t state = G_FLOAT(OFS_PARM1);
cin_t *cin;
cin = R_ShaderFindCinematic(shader);
if (cin)
Media_SetState(cin, state);
}
//evil builtins to pretend to be a server.
void QCBUILTIN PF_cl_sprint (pubprogfuncs_t *prinst, struct globalvars_s *pr_globals)
{
//this is a bit pointless for menus as it doesn't know player names or anything.
#ifndef CLIENTONLY
int clientnum = G_FLOAT(OFS_PARM0);
char *str = PF_VarString(prinst, 1, pr_globals);
if (sv.active && clientnum < sv.allocated_client_slots && svs.clients[clientnum].state >= cs_connected)
SV_PrintToClient(&svs.clients[clientnum], PRINT_HIGH, str);
#endif
}
qbool PR_UserCmd(void)
{
/*if (!strcmp(Cmd_Argv(0), "admin") || !strcmp(Cmd_Argv(0), "judge"))
{
Con_Printf ("user command %s is banned\n", Cmd_Argv(0));
return true;
}
*/
/*int i;
if (!strcmp(Cmd_Argv(0), "mmode") || !strcmp(Cmd_Argv(0), "cmd"))
{
for (i = 0; i < Cmd_Argc(); i++)
Con_Printf ("PR_UserCmd: [%d] %s | %d\n", i, Cmd_Argv(i), mod_UserCmd);
//return true;
}*/
// ZQ_CLIENTCOMMAND extension
if (!is_ktpro && GE_ClientCommand) {
static char cmd_copy[128], args_copy[1024] /* Ouch! */;
pr_global_struct->time = sv.time;
pr_global_struct->self = EDICT_TO_PROG(sv_player);
strlcpy (cmd_copy, Cmd_Argv(0), sizeof(cmd_copy));
strlcpy (args_copy, Cmd_Args(), sizeof(args_copy));
((int *)pr_globals)[OFS_PARM0] = PR_SetString (cmd_copy);
((int *)pr_globals)[OFS_PARM1] = PR_SetString (args_copy);
PR_ExecuteProgram (GE_ClientCommand);
return G_FLOAT(OFS_RETURN) ? true : false;
}
if (mod_UserCmd)
{
static char cmd_copy[128];
pr_global_struct->time = sv.time;
pr_global_struct->self = EDICT_TO_PROG(sv_player);
strlcpy (cmd_copy, Cmd_Argv(0), sizeof(cmd_copy));
((int *)pr_globals)[OFS_PARM0] = PR_SetString (cmd_copy);
PR_ExecuteProgram (mod_UserCmd);
return G_FLOAT(OFS_RETURN) ? true : false;
}
return false;
}
/*
======================
SV_MoveToGoal
======================
*/
void SV_MoveToGoal (void)
{
edict_t *ent, *goal;
float dist;
ent = PROG_TO_EDICT(PR_GLOBAL_STRUCT(self)); // Entity moving
goal = PROG_TO_EDICT(ent->v.goalentity); // its goalentity
dist = G_FLOAT(OFS_PARM0); // how far to move
// Reset trace_plane_normal
VectorCopy(vec3_origin, PR_GLOBAL_STRUCT(trace_plane_normal));
// If not onground, flying, or swimming, return 0
if ( !( (int)ent->v.flags & (FL_ONGROUND|FL_FLY|FL_SWIM) ) )
{
G_FLOAT(OFS_RETURN) = 0;
return;
}
// if the next step hits the enemy, return immediately
if ( PROG_TO_EDICT(ent->v.enemy) != sv.edicts && SV_CloseEnough (ent, goal, dist) )
{
G_FLOAT(OFS_RETURN) = 0;
return;
}
// bump around...
if (!SV_StepDirection (ent, ent->v.ideal_yaw, dist))//If can't go in a direction (including step check) or 30% chance...
{
SV_NewChaseDir (ent, goal, dist);//Find a new direction to go in instead
G_FLOAT(OFS_RETURN) = 0;
}
else
{
if ((rand()&3)==1)
{
SV_NewChaseDir (ent, goal, dist);//Find a new direction to go in instead
}
G_FLOAT(OFS_RETURN) = 1;
}
return;
}
//#343
void QCBUILTIN PF_cl_setcursormode (pubprogfuncs_t *prinst, struct globalvars_s *pr_globals)
{
world_t *world = prinst->parms->user;
if (G_FLOAT(OFS_PARM0))
key_dest_absolutemouse |= world->keydestmask;
else
key_dest_absolutemouse &= ~world->keydestmask;
if (prinst->callargc>1)
{
struct key_cursor_s *m = &key_customcursor[(world->keydestmask==kdm_game)?kc_game:kc_menu];
Q_strncpyz(m->name, PR_GetStringOfs(prinst, OFS_PARM1), sizeof(m->name));
m->hotspot[0] = (prinst->callargc>2)?G_FLOAT(OFS_PARM2+0):0;
m->hotspot[1] = (prinst->callargc>2)?G_FLOAT(OFS_PARM2+1):0;
m->scale = (prinst->callargc>2)?G_FLOAT(OFS_PARM2+2):0;
if (m->scale <= 0)
m->scale = 1;
m->dirty = true;
}
}
void QCBUILTIN PF_cs_media_getstate (pubprogfuncs_t *prinst, struct globalvars_s *pr_globals)
{
const char *shader = PR_GetStringOfs(prinst, OFS_PARM0);
cinstates_t ret = CINSTATE_INVALID;
cin_t *cin;
cin = R_ShaderFindCinematic(shader);
if (cin)
ret = Media_GetState(cin);
G_FLOAT(OFS_RETURN) = ret;
}
void SV_ParseMultiEffect (sizebuf_t *sb)
{
int idx, count;
byte effect;
vec3_t orig, vel;
MultiEffectIdCount = 0;
effect = G_FLOAT(OFS_PARM0);
switch (effect)
{
case CE_HWRAVENPOWER:
// need to set aside 3 effect ids
MSG_WriteByte (sb, svc_multieffect);
MSG_WriteByte (sb, effect);
VectorCopy(G_VECTOR(OFS_PARM1), orig);
MSG_WriteCoord(sb, orig[0]);
MSG_WriteCoord(sb, orig[1]);
MSG_WriteCoord(sb, orig[2]);
VectorCopy(G_VECTOR(OFS_PARM2), vel);
MSG_WriteCoord(sb, vel[0]);
MSG_WriteCoord(sb, vel[1]);
MSG_WriteCoord(sb, vel[2]);
for (count = 0 ; count < 3 ; count++)
{
for (idx = 0 ; idx < MAX_EFFECTS ; idx++)
{
if (!sv.Effects[idx].type ||
(sv.Effects[idx].expire_time && sv.Effects[idx].expire_time <= sv.time))
break;
}
if (idx >= MAX_EFFECTS)
{
PR_RunError ("MAX_EFFECTS reached");
return;
}
MSG_WriteByte(sb, idx);
sv.Effects[idx].type = CE_HWRAVENPOWER;
VectorCopy(orig, sv.Effects[idx].ef.Missile.origin);
VectorCopy(vel, sv.Effects[idx].ef.Missile.velocity);
sv.Effects[idx].expire_time = sv.time + 10;
MultiEffectIds[count] = idx;
}
break;
default:
PR_RunError ("%s: bad type", __thisfunc__);
}
}
