+/*
+Copyright (C) 2006-2021 DarkPlaces contributors
+
+This program is free software; you can redistribute it and/or
+modify it under the terms of the GNU General Public License
+as published by the Free Software Foundation; either version 2
+of the License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+
+See the GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+
+*/
+
#include "quakedef.h"
#include "progsvm.h"
#include "clprogdefs.h"
}
extern cvar_t cl_noplayershadow;
-qboolean CSQC_AddRenderEdict(prvm_edict_t *ed, int edictnum)
+qbool CSQC_AddRenderEdict(prvm_edict_t *ed, int edictnum)
{
prvm_prog_t *prog = CLVM_prog;
int renderflags;
int c;
float scale;
entity_render_t *entrender;
- dp_model_t *model;
+ model_t *model;
prvm_vec3_t modellight_origin;
model = CL_GetModelFromEdict(ed);
// 1 = keyup, key, character (EXT_CSQC)
// 2 = mousemove relative, x, y (EXT_CSQC)
// 3 = mousemove absolute, x, y (DP_CSQC)
-qboolean CL_VM_InputEvent (int eventtype, float x, float y)
+qbool CL_VM_InputEvent (int eventtype, float x, float y)
{
prvm_prog_t *prog = CLVM_prog;
- qboolean r;
+ qbool r;
if(!cl.csqc_loaded)
return false;
extern r_refdef_view_t csqc_original_r_refdef_view;
extern r_refdef_view_t csqc_main_r_refdef_view;
-qboolean CL_VM_UpdateView (double frametime)
+qbool CL_VM_UpdateView (double frametime)
{
prvm_prog_t *prog = CLVM_prog;
vec3_t emptyvector;
prog->polygonbegin_guess2d = false;
// free memory for resources that are no longer referenced
PRVM_GarbageCollection(prog);
- // pass in width and height as parameters (EXT_CSQC_1)
+ // pass in width and height and menu/focus state as parameters (EXT_CSQC_1)
PRVM_G_FLOAT(OFS_PARM0) = vid.width;
PRVM_G_FLOAT(OFS_PARM1) = vid.height;
+ /*
+ * This should be fine for now but FTEQW uses flags for keydest
+ * and checks that an array called "eyeoffset" is 0
+ *
+ * Just a note in case there's compatibility problems later
+ */
+ PRVM_G_FLOAT(OFS_PARM2) = key_dest == key_game;
prog->ExecuteProgram(prog, PRVM_clientfunction(CSQC_UpdateView), "QC function CSQC_UpdateView is missing");
//VectorCopy(oldangles, cl.viewangles);
// Dresk : Reset Dmg Globals Here
return true;
}
-qboolean CL_VM_ConsoleCommand (const char *text)
+qbool CL_VM_ConsoleCommand (const char *text)
{
prvm_prog_t *prog = CLVM_prog;
- int restorevm_tempstringsbuf_cursize;
- qboolean r = false;
- if(!cl.csqc_loaded)
- return false;
- CSQC_BEGIN
- if (PRVM_clientfunction(CSQC_ConsoleCommand))
- {
- PRVM_clientglobalfloat(time) = cl.time;
- PRVM_clientglobaledict(self) = cl.csqc_server2csqcentitynumber[cl.playerentity];
- restorevm_tempstringsbuf_cursize = prog->tempstringsbuf.cursize;
- PRVM_G_INT(OFS_PARM0) = PRVM_SetTempString(prog, text);
- prog->ExecuteProgram(prog, PRVM_clientfunction(CSQC_ConsoleCommand), "QC function CSQC_ConsoleCommand is missing");
- prog->tempstringsbuf.cursize = restorevm_tempstringsbuf_cursize;
- r = CSQC_RETURNVAL != 0;
- }
- CSQC_END
- return r;
+ return PRVM_ConsoleCommand(prog, text, &prog->funcoffsets.CSQC_ConsoleCommand, false, cl.csqc_server2csqcentitynumber[cl.playerentity], cl.time, cl.csqc_loaded, "QC function CSQC_ConsoleCommand is missing");
}
-qboolean CL_VM_Parse_TempEntity (void)
+qbool CL_VM_Parse_TempEntity (void)
{
prvm_prog_t *prog = CLVM_prog;
int t;
- qboolean r = false;
+ qbool r = false;
if(!cl.csqc_loaded)
return false;
CSQC_BEGIN
// temporarily so that it can be set by the cvar command,
// and then reprotect it afterwards
int crcflags = csqc_progcrc.flags;
- int sizeflags = csqc_progcrc.flags;
- csqc_progcrc.flags &= ~CVAR_READONLY;
- csqc_progsize.flags &= ~CVAR_READONLY;
- Cmd_ExecuteString(&cmd_client, msg, src_command, true);
- csqc_progcrc.flags = crcflags;
- csqc_progsize.flags = sizeflags;
+ csqc_progcrc.flags &= ~CF_READONLY;
+ csqc_progsize.flags &= ~CF_READONLY;
+ Cmd_ExecuteString(cmd_local, msg, src_local, true);
+ csqc_progcrc.flags = csqc_progsize.flags = crcflags;
return;
}
l = sizeof(buf) - 1;
strlcpy(buf, p, l + 1); // strlcpy needs a + 1 as it includes the newline!
- Cmd_ExecuteString(&cmd_client, buf, src_command, true);
+ Cmd_ExecuteString(cmd_local, buf, src_local, true);
p += l;
if(*p == '\n')
else
break; // end of string or overflow
}
- Cmd_ExecuteString(&cmd_client, "curl --clear_autodownload", src_command, true); // don't inhibit CSQC loading
+ Cmd_ExecuteString(cmd_local, "curl --clear_autodownload", src_local, true); // don't inhibit CSQC loading
return;
}
if(!cl.csqc_loaded)
{
- Cbuf_AddText(&cmd_client, msg);
+ Cbuf_AddText(cmd_local, msg);
return;
}
CSQC_BEGIN
prog->tempstringsbuf.cursize = restorevm_tempstringsbuf_cursize;
}
else
- Cbuf_AddText(&cmd_client, msg);
+ Cbuf_AddText(cmd_local, msg);
CSQC_END
}
{
prvm_prog_t *prog = CLVM_prog;
size_t i;
- if(!cl.csqc_loaded)
- {
- Con_Print(msg);
- return;
- }
CSQC_BEGIN
- if(PRVM_clientfunction(CSQC_Parse_Print))
+ if(cl.csqc_loaded && PRVM_clientfunction(CSQC_Parse_Print))
{
// FIXME: is this bugged?
i = strlen(msg)-1;
{
prvm_prog_t *prog = CLVM_prog;
int restorevm_tempstringsbuf_cursize;
- if(!cl.csqc_loaded)
- {
- SCR_CenterPrint(msg);
- return;
- }
CSQC_BEGIN
- if(PRVM_clientfunction(CSQC_Parse_CenterPrint))
+ if(cl.csqc_loaded && PRVM_clientfunction(CSQC_Parse_CenterPrint))
{
PRVM_clientglobalfloat(time) = cl.time;
PRVM_clientglobaledict(self) = cl.csqc_server2csqcentitynumber[cl.playerentity];
CSQC_END
}
}
-qboolean CL_VM_Event_Sound(int sound_num, float fvolume, int channel, float attenuation, int ent, vec3_t pos, int flags, float speed)
+qbool CL_VM_Event_Sound(int sound_num, float fvolume, int channel, float attenuation, int ent, vec3_t pos, int flags, float speed)
{
prvm_prog_t *prog = CLVM_prog;
- qboolean r = false;
+ qbool r = false;
if(cl.csqc_loaded)
{
CSQC_BEGIN
// link every entity except world
for (i = 1, ent = prog->edicts;i < prog->num_edicts;i++, ent++)
- if (!ent->priv.server->free && !VectorCompare(PRVM_clientedictvector(ent, absmin), PRVM_clientedictvector(ent, absmax)))
+ if (!ent->free && !VectorCompare(PRVM_clientedictvector(ent, absmin), PRVM_clientedictvector(ent, absmax)))
CL_LinkEdict(ent);
}
World_UnlinkEdict(ed);
memset(ed->fields.fp, 0, prog->entityfields * sizeof(prvm_vec_t));
VM_RemoveEdictSkeleton(prog, ed);
+#ifdef USEODE
World_Physics_RemoveFromEntity(&cl.world, ed);
World_Physics_RemoveJointFromEntity(&cl.world, ed);
+#endif
}
static void CLVM_count_edicts(prvm_prog_t *prog)
for (i=0 ; i<prog->num_edicts ; i++)
{
ent = PRVM_EDICT_NUM(i);
- if (ent->priv.server->free)
+ if (ent->free)
continue;
active++;
if (PRVM_clientedictfloat(ent, solid))
Con_Printf("touch :%3i\n", solid);
}
-static qboolean CLVM_load_edict(prvm_prog_t *prog, prvm_edict_t *ent)
+static qbool CLVM_load_edict(prvm_prog_t *prog, prvm_edict_t *ent)
{
return true;
}
// returns true if the packet is valid, false if end of file is reached
// used for dumping the CSQC download into demo files
-qboolean MakeDownloadPacket(const char *filename, unsigned char *data, size_t len, int crc, int cnt, sizebuf_t *buf, int protocol)
+qbool MakeDownloadPacket(const char *filename, unsigned char *data, size_t len, int crc, int cnt, sizebuf_t *buf, int protocol)
{
int packetsize = buf->maxsize - 7; // byte short long
int npackets = ((int)len + packetsize - 1) / (packetsize);
}
else
{
- Con_DPrintf("Not using buffered \"%s\" (buffered: %p, %d)\n", csprogsfn, cls.caughtcsprogsdata, (int) cls.caughtcsprogsdatasize);
+ Con_DPrintf("Not using buffered \"%s\" (buffered: %p, %d)\n", csprogsfn, (void *)cls.caughtcsprogsdata, (int) cls.caughtcsprogsdatasize);
csprogsdata = FS_LoadFile(csprogsfn, tempmempool, true, &csprogsdatasize);
}
}
{
if (cls.demoplayback)
{
- Con_Warnf("Warning: Your %s is not the same version as the demo was recorded with (CRC/size are %i/%i but should be %i/%i)\n", csqc_progname.string, csprogsdatacrc, (int)csprogsdatasize, requiredcrc, requiredsize);
+ Con_Printf(CON_WARN "Warning: Your %s is not the same version as the demo was recorded with (CRC/size are %i/%i but should be %i/%i)\n", csqc_progname.string, csprogsdatacrc, (int)csprogsdatasize, requiredcrc, requiredsize);
// Mem_Free(csprogsdata);
// return;
// We WANT to continue here, and play the demo with different csprogs!
else
{
Mem_Free(csprogsdata);
- Con_Errorf("Your %s is not the same version as the server (CRC is %i/%i but should be %i/%i)\n", csqc_progname.string, csprogsdatacrc, (int)csprogsdatasize, requiredcrc, requiredsize);
- CL_Disconnect();
+ CL_DisconnectEx(false, "Your %s is not the same version as the server (CRC is %i/%i but should be %i/%i)\n", csqc_progname.string, csprogsdatacrc, (int)csprogsdatasize, requiredcrc, requiredsize);
return;
}
}
else
{
if (requiredcrc >= 0)
- {
- if (cls.demoplayback)
- Con_Errorf("CL_VM_Init: demo requires CSQC, but \"%s\" wasn't found\n", csqc_progname.string);
- else
- Con_Errorf("CL_VM_Init: server requires CSQC, but \"%s\" wasn't found\n", csqc_progname.string);
- CL_Disconnect();
- }
+ CL_DisconnectEx(false, CON_ERROR "CL_VM_Init: %s requires CSQC, but \"%s\" wasn't found\n", cls.demoplayback ? "demo" : "server", csqc_progname.string);
return;
}
- PRVM_Prog_Init(prog, &cmd_client);
+ PRVM_Prog_Init(prog, cmd_local);
// allocate the mempools
prog->progs_mempool = Mem_AllocPool(csqc_progname.string, 0, NULL);
if (!prog->loaded)
{
- Host_Error("CSQC %s failed to load\n", csprogsfn);
- if(!sv.active)
- CL_Disconnect();
Mem_Free(csprogsdata);
- return;
+ Host_Error("CSQC %s failed to load\n", csprogsfn);
}
- Con_DPrintf("CSQC %s ^5loaded (crc=%i, size=%i)\n", csprogsfn, csprogsdatacrc, (int)csprogsdatasize);
-
if(cls.demorecording)
{
if(cls.demo_lastcsprogssize != csprogsdatasize || cls.demo_lastcsprogscrc != csprogsdatacrc)
void CL_VM_ShutDown (void)
{
prvm_prog_t *prog = CLVM_prog;
- Cmd_ClearCSQCCommands(&cmd_client);
+ Cmd_ClearCSQCCommands(cmd_local);
//Cvar_SetValueQuick(&csqc_progcrc, -1);
//Cvar_SetValueQuick(&csqc_progsize, -1);
if(!cl.csqc_loaded)
cl.csqc_loaded = false;
}
-qboolean CL_VM_GetEntitySoundOrigin(int entnum, vec3_t out)
+qbool CL_VM_GetEntitySoundOrigin(int entnum, vec3_t out)
{
prvm_prog_t *prog = CLVM_prog;
prvm_edict_t *ed;
- dp_model_t *mod;
+ model_t *mod;
matrix4x4_t matrix;
- qboolean r = 0;
+ qbool r = 0;
CSQC_BEGIN;
ed = PRVM_EDICT_NUM(entnum - MAX_EDICTS);
- if(!ed->priv.required->free)
+ if(!ed->free)
{
mod = CL_GetModelFromEdict(ed);
VectorCopy(PRVM_clientedictvector(ed, origin), out);
return r;
}
-qboolean CL_VM_TransformView(int entnum, matrix4x4_t *viewmatrix, mplane_t *clipplane, vec3_t visorigin)
+qbool CL_VM_TransformView(int entnum, matrix4x4_t *viewmatrix, mplane_t *clipplane, vec3_t visorigin)
{
prvm_prog_t *prog = CLVM_prog;
- qboolean ret = false;
+ qbool ret = false;
prvm_edict_t *ed;
vec3_t forward, left, up, origin, ang;
matrix4x4_t mat, matq;