From ff8d70aa70289d8978b991f0214de17b0c5e1aed Mon Sep 17 00:00:00 2001 From: havoc Date: Mon, 7 May 2007 05:37:08 +0000 Subject: [PATCH] rewrote server sendstates building code, no longer builds two entity_state_t arrays (where one of them is global and one per-client), this is a slight efficiency loss but saves a few megabytes and makes the customizeentityforclient code more straightforward merged some global variables into cl. and sv. structs, and others became arrays on the stack git-svn-id: svn://svn.icculus.org/twilight/trunk/darkplaces@7243 d7cf8633-e32d-0410-b094-e92efae38249 --- cl_input.c | 2 +- client.h | 8 + clvm_cmds.c | 31 +- csprogs.c | 82 ++--- csprogs.h | 4 - host.c | 6 +- protocol.c | 71 +--- protocol.h | 12 +- prvm_cmds.c | 4 - prvm_edict.c | 3 +- server.h | 18 +- sv_main.c | 995 ++++++++++++++++++++++----------------------------- sv_phys.c | 7 +- svvm_cmds.c | 3 +- view.c | 4 +- 15 files changed, 515 insertions(+), 735 deletions(-) diff --git a/cl_input.c b/cl_input.c index c5e1a376..94a64a71 100644 --- a/cl_input.c +++ b/cl_input.c @@ -351,7 +351,7 @@ cvar_t in_pitch_max = {0, "in_pitch_max", "90", "how far upward you can aim (qua cvar_t m_filter = {CVAR_SAVE, "m_filter","0", "smoothes mouse movement, less responsive but smoother aiming"}; cvar_t cl_netinputpacketspersecond = {CVAR_SAVE, "cl_netinputpacketspersecond","50", "how many input packets to send to server each second"}; -cvar_t cl_netinputpacketlosstolerance = {CVAR_SAVE, "cl_netinputpacketlosstolerance", "1", "how many packets in a row can be lost without movement issues when using cl_movement (technically how many input messages to repeat in each packet that have not yet been acknowledged by the server), only affects DP7 servers (Quake uses 0, QuakeWorld uses 2, and just for comparison Quake3 uses 1)"}; +cvar_t cl_netinputpacketlosstolerance = {CVAR_SAVE, "cl_netinputpacketlosstolerance", "1", "how many packets in a row can be lost without movement issues when using cl_movement (technically how many input messages to repeat in each packet that have not yet been acknowledged by the server), only affects DP7 and later servers (Quake uses 0, QuakeWorld uses 2, and just for comparison Quake3 uses 1)"}; cvar_t cl_nodelta = {0, "cl_nodelta", "0", "disables delta compression of non-player entities in QW network protocol"}; diff --git a/client.h b/client.h index 8f370009..83e48846 100644 --- a/client.h +++ b/client.h @@ -982,6 +982,14 @@ typedef struct client_state_s int qw_deltasequence[QW_UPDATE_BACKUP]; // csqc stuff: + // server entity number corresponding to a clientside entity + unsigned short csqc_server2csqcentitynumber[MAX_EDICTS]; + qboolean csqc_loaded; + vec3_t csqc_origin; + vec3_t csqc_angles; + qboolean csqc_usecsqclistener; + matrix4x4_t csqc_listenermatrix; + char csqc_printtextbuf[MAX_INPUTLINE]; // collision culling data world_t world; diff --git a/clvm_cmds.c b/clvm_cmds.c index 2d820b85..674221ab 100644 --- a/clvm_cmds.c +++ b/clvm_cmds.c @@ -604,14 +604,11 @@ static void VM_CL_getlight (void) //[515]: SCENE MANAGER builtins extern qboolean CSQC_AddRenderEdict (prvm_edict_t *ed);//csprogs.c -matrix4x4_t csqc_listenermatrix; -qboolean csqc_usecsqclistener = false;//[515]: per-frame - static void CSQC_R_RecalcView (void) { extern matrix4x4_t viewmodelmatrix; - Matrix4x4_CreateFromQuakeEntity(&r_view.matrix, csqc_origin[0], csqc_origin[1], csqc_origin[2], csqc_angles[0], csqc_angles[1], csqc_angles[2], 1); - Matrix4x4_CreateFromQuakeEntity(&viewmodelmatrix, csqc_origin[0], csqc_origin[1], csqc_origin[2], csqc_angles[0], csqc_angles[1], csqc_angles[2], cl_viewmodel_scale.value); + Matrix4x4_CreateFromQuakeEntity(&r_view.matrix, cl.csqc_origin[0], cl.csqc_origin[1], cl.csqc_origin[2], cl.csqc_angles[0], cl.csqc_angles[1], cl.csqc_angles[2], 1); + Matrix4x4_CreateFromQuakeEntity(&viewmodelmatrix, cl.csqc_origin[0], cl.csqc_origin[1], cl.csqc_origin[2], cl.csqc_angles[0], cl.csqc_angles[1], cl.csqc_angles[2], cl_viewmodel_scale.value); } void CL_RelinkLightFlashes(void); @@ -707,28 +704,28 @@ static void VM_CL_R_SetView (void) break; case VF_FOVY: //r_refdef.fov_y = k; // FIXME! break; - case VF_ORIGIN: VectorCopy(f, csqc_origin); + case VF_ORIGIN: VectorCopy(f, cl.csqc_origin); CSQC_R_RecalcView(); break; - case VF_ORIGIN_X: csqc_origin[0] = k; + case VF_ORIGIN_X: cl.csqc_origin[0] = k; CSQC_R_RecalcView(); break; - case VF_ORIGIN_Y: csqc_origin[1] = k; + case VF_ORIGIN_Y: cl.csqc_origin[1] = k; CSQC_R_RecalcView(); break; - case VF_ORIGIN_Z: csqc_origin[2] = k; + case VF_ORIGIN_Z: cl.csqc_origin[2] = k; CSQC_R_RecalcView(); break; - case VF_ANGLES: VectorCopy(f, csqc_angles); + case VF_ANGLES: VectorCopy(f, cl.csqc_angles); CSQC_R_RecalcView(); break; - case VF_ANGLES_X: csqc_angles[0] = k; + case VF_ANGLES_X: cl.csqc_angles[0] = k; CSQC_R_RecalcView(); break; - case VF_ANGLES_Y: csqc_angles[1] = k; + case VF_ANGLES_Y: cl.csqc_angles[1] = k; CSQC_R_RecalcView(); break; - case VF_ANGLES_Z: csqc_angles[2] = k; + case VF_ANGLES_Z: cl.csqc_angles[2] = k; CSQC_R_RecalcView(); break; case VF_DRAWWORLD: cl.csqc_vidvars.drawworld = k; @@ -1056,8 +1053,8 @@ static void VM_CL_isdemo (void) static void VM_CL_setlistener (void) { VM_SAFEPARMCOUNT(4, VM_CL_setlistener); - Matrix4x4_FromVectors(&csqc_listenermatrix, PRVM_G_VECTOR(OFS_PARM1), PRVM_G_VECTOR(OFS_PARM2), PRVM_G_VECTOR(OFS_PARM3), PRVM_G_VECTOR(OFS_PARM0)); - csqc_usecsqclistener = true; //use csqc listener at this frame + Matrix4x4_FromVectors(&cl.csqc_listenermatrix, PRVM_G_VECTOR(OFS_PARM1), PRVM_G_VECTOR(OFS_PARM2), PRVM_G_VECTOR(OFS_PARM3), PRVM_G_VECTOR(OFS_PARM0)); + cl.csqc_usecsqclistener = true; //use csqc listener at this frame } //#352 void(string cmdname) registercommand (EXT_CSQC) @@ -1952,7 +1949,7 @@ int CL_GetTagMatrix (matrix4x4_t *out, prvm_edict_t *ent, int tagindex) if (val->_float == 0) val->_float = 1; - Matrix4x4_CreateFromQuakeEntity(&entitymatrix, csqc_origin[0], csqc_origin[1], csqc_origin[2], csqc_angles[0], csqc_angles[1], csqc_angles[2], val->_float); + Matrix4x4_CreateFromQuakeEntity(&entitymatrix, cl.csqc_origin[0], cl.csqc_origin[1], cl.csqc_origin[2], cl.csqc_angles[0], cl.csqc_angles[1], cl.csqc_angles[2], val->_float); Matrix4x4_Concat(out, &entitymatrix, &tagmatrix); /* @@ -1964,7 +1961,7 @@ int CL_GetTagMatrix (matrix4x4_t *out, prvm_edict_t *ent, int tagindex) // should be done in QC on the server, but oh well, quake is quake) // LordHavoc: figured out bobup: the time at which the sin is at 180 // degrees (which allows lengthening or squishing the peak or valley) - cycle = sv.time/cl_bobcycle.value; + cycle = cl.time/cl_bobcycle.value; cycle -= (int)cycle; if (cycle < cl_bobup.value) cycle = sin(M_PI * cycle / cl_bobup.value); diff --git a/csprogs.c b/csprogs.c index 8ba21cb7..dcd6e5b3 100644 --- a/csprogs.c +++ b/csprogs.c @@ -25,16 +25,6 @@ static char *cl_required_func[] = static int cl_numrequiredfunc = sizeof(cl_required_func) / sizeof(char*); -static char *csqc_printtextbuf = NULL; -static unsigned short *csqc_sv2csqcents; //[515]: server entities numbers on client side. FIXME : make pointers instead of numbers ? - -qboolean csqc_loaded = false; - -vec3_t csqc_origin, csqc_angles; -static double csqc_frametime = 0; - -static mempool_t *csqc_mempool; - void CL_VM_Error (const char *format, ...) DP_FUNC_PRINTF(1); void CL_VM_Error (const char *format, ...) //[515]: hope it will be never executed =) { @@ -47,8 +37,7 @@ void CL_VM_Error (const char *format, ...) //[515]: hope it will be never execut // Con_Printf( "CL_VM_Error: %s\n", errorstring ); PRVM_Crash(); - csqc_loaded = false; - Mem_FreePool(&csqc_mempool); + cl.csqc_loaded = false; Cvar_SetValueQuick(&csqc_progcrc, -1); Cvar_SetValueQuick(&csqc_progsize, -1); @@ -64,17 +53,16 @@ static void CSQC_SetGlobals (void) CSQC_BEGIN prog->globals.client->time = cl.time; - prog->globals.client->frametime = cl.time - csqc_frametime; - csqc_frametime = cl.time; + prog->globals.client->frametime = max(0, cl.time - cl.oldtime); prog->globals.client->servercommandframe = cls.servermovesequence; prog->globals.client->clientcommandframe = cl.movecmd[0].sequence; VectorCopy(cl.viewangles, prog->globals.client->input_angles); - VectorCopy(cl.viewangles, csqc_angles); + VectorCopy(cl.viewangles, cl.csqc_angles); prog->globals.client->input_buttons = cl.movecmd[0].buttons; VectorSet(prog->globals.client->input_movevalues, cl.movecmd[0].forwardmove, cl.movecmd[0].sidemove, cl.movecmd[0].upmove); - //VectorCopy(cl.movement_origin, csqc_origin); - Matrix4x4_OriginFromMatrix(&cl.entities[cl.viewentity].render.matrix, csqc_origin); - VectorCopy(csqc_origin, prog->globals.client->pmove_org); + //VectorCopy(cl.movement_origin, cl.csqc_origin); + Matrix4x4_OriginFromMatrix(&cl.entities[cl.viewentity].render.matrix, cl.csqc_origin); + VectorCopy(cl.csqc_origin, prog->globals.client->pmove_org); prog->globals.client->maxclients = cl.maxclients; //VectorCopy(cl.movement_velocity, prog->globals.client->pmove_vel); VectorCopy(cl.velocity, prog->globals.client->pmove_vel); @@ -210,7 +198,7 @@ qboolean CSQC_AddRenderEdict(prvm_edict_t *ed) qboolean CL_VM_InputEvent (qboolean pressed, int key) { qboolean r; - if(!csqc_loaded) + if(!cl.csqc_loaded) return false; CSQC_BEGIN prog->globals.client->time = cl.time; @@ -225,7 +213,7 @@ qboolean CL_VM_InputEvent (qboolean pressed, int key) qboolean CL_VM_UpdateView (void) { // vec3_t oldangles; - if(!csqc_loaded) + if(!cl.csqc_loaded) return false; CSQC_BEGIN //VectorCopy(cl.viewangles, oldangles); @@ -246,7 +234,7 @@ qboolean CL_VM_ConsoleCommand (const char *cmd) { int restorevm_tempstringsbuf_cursize; qboolean r; - if(!csqc_loaded) + if(!cl.csqc_loaded) return false; CSQC_BEGIN prog->globals.client->time = cl.time; @@ -263,7 +251,7 @@ qboolean CL_VM_Parse_TempEntity (void) { int t; qboolean r = false; - if(!csqc_loaded) + if(!cl.csqc_loaded) return false; CSQC_BEGIN if(prog->funcoffsets.CSQC_Parse_TempEntity) @@ -302,7 +290,7 @@ void CL_VM_Parse_StuffCmd (const char *msg) csqc_progsize.flags = sizeflags; return; } - if(!csqc_loaded) + if(!cl.csqc_loaded) { Cbuf_AddText(msg); return; @@ -334,7 +322,7 @@ static void CL_VM_Parse_Print (const char *msg) void CSQC_AddPrintText (const char *msg) { size_t i; - if(!csqc_loaded) + if(!cl.csqc_loaded) { Con_Print(msg); return; @@ -346,18 +334,18 @@ void CSQC_AddPrintText (const char *msg) i = strlen(msg)-1; if(msg[i] != '\n' && msg[i] != '\r') { - if(strlen(csqc_printtextbuf)+i >= MAX_INPUTLINE) + if(strlen(cl.csqc_printtextbuf)+i >= MAX_INPUTLINE) { - CL_VM_Parse_Print(csqc_printtextbuf); - csqc_printtextbuf[0] = 0; + CL_VM_Parse_Print(cl.csqc_printtextbuf); + cl.csqc_printtextbuf[0] = 0; } else - strlcat(csqc_printtextbuf, msg, MAX_INPUTLINE); + strlcat(cl.csqc_printtextbuf, msg, MAX_INPUTLINE); return; } - strlcat(csqc_printtextbuf, msg, MAX_INPUTLINE); - CL_VM_Parse_Print(csqc_printtextbuf); - csqc_printtextbuf[0] = 0; + strlcat(cl.csqc_printtextbuf, msg, MAX_INPUTLINE); + CL_VM_Parse_Print(cl.csqc_printtextbuf); + cl.csqc_printtextbuf[0] = 0; } else Con_Print(msg); @@ -367,7 +355,7 @@ void CSQC_AddPrintText (const char *msg) void CL_VM_Parse_CenterPrint (const char *msg) { int restorevm_tempstringsbuf_cursize; - if(!csqc_loaded) + if(!cl.csqc_loaded) { SCR_CenterPrint((char*)msg); return; @@ -389,7 +377,7 @@ void CL_VM_Parse_CenterPrint (const char *msg) float CL_VM_Event (float event) //[515]: needed ? I'd say "YES", but don't know for what :D { float r = 0; - if(!csqc_loaded) + if(!cl.csqc_loaded) return 0; CSQC_BEGIN if(prog->funcoffsets.CSQC_Event) @@ -415,13 +403,13 @@ void CSQC_ReadEntities (void) if(!entnum) return; realentnum = entnum & 0x7FFF; - prog->globals.client->self = csqc_sv2csqcents[realentnum]; + prog->globals.client->self = cl.csqc_server2csqcentitynumber[realentnum]; if(entnum & 0x8000) { if(prog->globals.client->self) { PRVM_ExecuteProgram(prog->funcoffsets.CSQC_Ent_Remove, "QC function CSQC_Ent_Remove is missing"); - csqc_sv2csqcents[realentnum] = 0; + cl.csqc_server2csqcentitynumber[realentnum] = 0; } else Con_Printf("Smth bad happens in csqc...\n"); //[515]: never happens ? @@ -433,7 +421,7 @@ void CSQC_ReadEntities (void) prvm_edict_t *ed; ed = PRVM_ED_Alloc(); ed->fields.client->entnum = realentnum; - prog->globals.client->self = csqc_sv2csqcents[realentnum] = PRVM_EDICT_TO_PROG(ed); + prog->globals.client->self = cl.csqc_server2csqcentitynumber[realentnum] = PRVM_EDICT_TO_PROG(ed); PRVM_G_FLOAT(OFS_PARM0) = 1; } else @@ -527,7 +515,7 @@ void CL_VM_Init (void) Cvar_SetValueQuick(&csqc_progcrc, -1); Cvar_SetValueQuick(&csqc_progsize, -1); - csqc_loaded = false; + cl.csqc_loaded = false; memset(cl.csqc_model_precache, 0, sizeof(cl.csqc_model_precache)); memset(&cl.csqc_vidvars, true, sizeof(csqc_vidvars_t)); @@ -575,8 +563,6 @@ void CL_VM_Init (void) PRVM_Begin; PRVM_InitProg(PRVM_CLIENTPROG); - csqc_mempool = Mem_AllocPool("CSQC", 0, NULL); - // allocate the mempools prog->progs_mempool = Mem_AllocPool(csqc_progname.string, 0, NULL); prog->headercrc = CL_PROGHEADER_CRC; @@ -616,13 +602,6 @@ void CL_VM_Init (void) if (prog->fieldoffsets.nextthink >= 0 && prog->fieldoffsets.frame >= 0 && prog->fieldoffsets.think >= 0 && prog->globaloffsets.self >= 0) prog->flag |= PRVM_OP_STATE; - //[515]: optional fields & funcs - if(prog->funcoffsets.CSQC_Parse_Print) - { - csqc_printtextbuf = (char *)Mem_Alloc(csqc_mempool, MAX_INPUTLINE); - csqc_printtextbuf[0] = 0; - } - if (cl.worldmodel) { VectorCopy(cl.worldmodel->normalmins, cl.world.areagrid_mins); @@ -637,7 +616,6 @@ void CL_VM_Init (void) // set time prog->globals.client->time = cl.time; - csqc_frametime = 0; prog->globals.client->mapname = PRVM_SetEngineString(cl.worldmodel->name); prog->globals.client->player_localentnum = cl.playerentity; @@ -646,10 +624,7 @@ void CL_VM_Init (void) PRVM_ExecuteProgram(prog->funcoffsets.CSQC_Init, "QC function CSQC_Init is missing"); PRVM_End; - csqc_loaded = true; - - csqc_sv2csqcents = (unsigned short *)Mem_Alloc(csqc_mempool, MAX_EDICTS*sizeof(unsigned short)); - memset(csqc_sv2csqcents, 0, MAX_EDICTS*sizeof(unsigned short)); + cl.csqc_loaded = true; cl.csqc_vidvars.drawcrosshair = false; cl.csqc_vidvars.drawenginesbar = false; @@ -660,7 +635,7 @@ void CL_VM_ShutDown (void) Cmd_ClearCsqcFuncs(); Cvar_SetValueQuick(&csqc_progcrc, -1); Cvar_SetValueQuick(&csqc_progsize, -1); - if(!csqc_loaded) + if(!cl.csqc_loaded) return; CSQC_BEGIN prog->globals.client->time = cl.time; @@ -668,6 +643,5 @@ void CL_VM_ShutDown (void) PRVM_ResetProg(); CSQC_END Con_Print("CSQC ^1unloaded\n"); - csqc_loaded = false; - Mem_FreePool(&csqc_mempool); + cl.csqc_loaded = false; } diff --git a/csprogs.h b/csprogs.h index 45b91a34..451fc3d5 100644 --- a/csprogs.h +++ b/csprogs.h @@ -48,12 +48,8 @@ // Note that to use this properly, you'll NEED to use the predraw function to set the globals. //#define RF_DOUBLESIDED 32 -extern qboolean csqc_loaded; -extern vec3_t csqc_origin, csqc_angles; extern cvar_t csqc_progname; //[515]: csqc crc check and right csprogs name according to progs.dat extern cvar_t csqc_progcrc; extern cvar_t csqc_progsize; -extern qboolean csqc_usecsqclistener; -extern matrix4x4_t csqc_listenermatrix; #endif diff --git a/host.c b/host.c index 637c2be6..3e1ba42a 100644 --- a/host.c +++ b/host.c @@ -815,10 +815,10 @@ void Host_Main(void) time2 = Sys_DoubleTime(); // update audio - if(csqc_usecsqclistener) + if(cl.csqc_usecsqclistener) { - S_Update(&csqc_listenermatrix); - csqc_usecsqclistener = false; + S_Update(&cl.csqc_listenermatrix); + cl.csqc_usecsqclistener = false; } else S_Update(&r_view.matrix); diff --git a/protocol.c b/protocol.c index aa40970e..da014322 100644 --- a/protocol.c +++ b/protocol.c @@ -13,15 +13,9 @@ entity_state_t defaultstate = {0,0,0},//float angles[3]; 0,//int number; // entity number this state is for 0,//int effects; - 0,//unsigned int customizeentityforclient; // ! 0,//unsigned short modelindex; 0,//unsigned short frame; 0,//unsigned short tagentity; - 0,//unsigned short specialvisibilityradius; // ! larger if it has effects/light - 0,//unsigned short viewmodelforclient; // ! - 0,//unsigned short exteriormodelforclient; // ! not shown if first person viewing from this entity, shown in all other cases - 0,//unsigned short nodrawtoclient; // ! - 0,//unsigned short drawonlytoclient; // ! {0,0,0,0},//unsigned short light[4]; // color*256 (0.00 to 255.996), and radius*1 0,//unsigned char active; // true if a valid state 0,//unsigned char lightstyle; @@ -33,9 +27,9 @@ entity_state_t defaultstate = 0,//unsigned char glowsize; 254,//unsigned char glowcolor; 0,//unsigned char flags; + 0,//unsigned char internaleffects; // INTEF_FLAG1QW and so on 0,//unsigned char tagindex; {32, 32, 32},//unsigned char colormod[3]; - 0,//unsigned char internaleffects; // INTEF_FLAG1QW and so on // padding to a multiple of 8 bytes (to align the double time) 0//unsigned char unused; // ! }; @@ -64,11 +58,6 @@ protocolversioninfo[] = {0, NULL} }; -static mempool_t *sv2csqc = NULL; -int csqc_clientnum = 0; -sizebuf_t *sv2csqcbuf = NULL; -static unsigned char *sv2csqcents_version[MAX_SCOREBOARD]; - static entity_frame_t deltaframe; // FIXME? static entity_frame_t framedata; // FIXME? @@ -251,29 +240,6 @@ void EntityFrameQuake_ISeeDeadEntities(void) } } -void EntityFrameCSQC_ClearVersions (void) -{ - if(sv2csqc) - { - Mem_FreePool(&sv2csqc); - sv2csqc = NULL; - } - memset(sv2csqcents_version, 0, MAX_SCOREBOARD*sizeof(unsigned char *)); -} - -void EntityFrameCSQC_InitClientVersions (int client, qboolean clear) -{ - if(!sv2csqc) - sv2csqc = Mem_AllocPool("SV2CSQC", 0, NULL); - if(sv2csqcents_version[client]) - { - Mem_Free(sv2csqcents_version[client]); - sv2csqcents_version[client] = NULL; - } - sv2csqcents_version[client] = (unsigned char *)Mem_Alloc(sv2csqc, MAX_EDICTS); - memset(sv2csqcents_version[client], 0, MAX_EDICTS); -} - // FIXME FIXME FIXME: at this time the CSQC entity writing does not store // packet logs and thus if an update is lost it is never repeated, this makes // csqc entities useless at the moment. @@ -290,17 +256,16 @@ void EntityFrameCSQC_WriteState (sizebuf_t *msg, int number, qboolean doupdate, val2 = PRVM_EDICTFIELDVALUE((&prog->edicts[number]), prog->fieldoffsets.Version); version = (int)val2->_float; // LordHavoc: do some validity checks on self.Version - // if Version reaches 8388608, it has already exhausted half of the - // reliable integer space in a 32bit float, and should be reset to 1 - // FIXME: we should set all client versions of this entity to -1 - // so that it will not be skipped accidentally in some cases after - // the reset + // if self.Version reaches 255, it will soon exceed the byte used to + // store an entity version in the client struct, so we need to reset + // all the version to 1 and force all the existing clients' version of + // it to 255 (which we're not allowing to actually occur) if (version < 0) val2->_float = 0; - if (version >= 8388608) + if (version >= 255) { int i; - val2->_float = 1; + val2->_float = version = 1; // since we just reset the Version field to 1, it may accidentally // end up being equal to an existing client version now or in the // future, so to fix this situation we have to loop over all @@ -308,13 +273,13 @@ void EntityFrameCSQC_WriteState (sizebuf_t *msg, int number, qboolean doupdate, // which never matches, thus causing them to receive the update // soon, as they should for (i = 0;i < svs.maxclients;i++) - if (sv2csqcents_version[i] && sv2csqcents_version[i][number]) - sv2csqcents_version[i][number] = -1; + if (svs.clients[sv.writeentitiestoclient_clientnumber].csqcentityversion[number]) + svs.clients[sv.writeentitiestoclient_clientnumber].csqcentityversion[number] = 255; } } // if the version already matches, we don't need to do anything as the // latest version has already been sent. - if (sv2csqcents_version[csqc_clientnum][number] == version) + if (svs.clients[sv.writeentitiestoclient_clientnumber].csqcentityversion[number] == version) return; if (version) { @@ -328,7 +293,7 @@ void EntityFrameCSQC_WriteState (sizebuf_t *msg, int number, qboolean doupdate, if(!*sectionstarted) MSG_WriteByte(msg, svc_csqcentities); MSG_WriteShort(msg, number); - ((int *)prog->globals.generic)[OFS_PARM0] = csqc_clientnum+1; + ((int *)prog->globals.generic)[OFS_PARM0] = sv.writeentitiestoclient_cliententitynumber; prog->globals.server->self = number; PRVM_ExecuteProgram(val->function, "Null SendEntity\n"); if(prog->globals.generic[OFS_RETURN]) @@ -343,7 +308,7 @@ void EntityFrameCSQC_WriteState (sizebuf_t *msg, int number, qboolean doupdate, return; } // an update has been successfully written, update the version - sv2csqcents_version[csqc_clientnum][number] = version; + svs.clients[sv.writeentitiestoclient_clientnumber].csqcentityversion[number] = version; // and take note that we have begun the svc_csqcentities // section of the packet *sectionstarted = 1; @@ -361,7 +326,7 @@ void EntityFrameCSQC_WriteState (sizebuf_t *msg, int number, qboolean doupdate, } // write a remove message if needed // if already removed, do nothing - if (!sv2csqcents_version[csqc_clientnum][number]) + if (!svs.clients[sv.writeentitiestoclient_clientnumber].csqcentityversion[number]) return; // if there isn't enough room to write the remove message, just return, as // it will be handled in a later packet @@ -375,7 +340,7 @@ void EntityFrameCSQC_WriteState (sizebuf_t *msg, int number, qboolean doupdate, } // write the remove message MSG_WriteShort(msg, (unsigned short)number | 0x8000); - sv2csqcents_version[csqc_clientnum][number] = 0; + svs.clients[sv.writeentitiestoclient_clientnumber].csqcentityversion[number] = 0; } //[515]: we use only one array per-client for SendEntity feature @@ -392,16 +357,13 @@ void EntityFrameCSQC_WriteFrame (sizebuf_t *msg, int numstates, const entity_sta // the terminator (0x0000) and at least one entity update if (msg->cursize + 32 >= msg->maxsize) return; - if(!sv2csqcents_version[csqc_clientnum]) - EntityFrameCSQC_InitClientVersions(csqc_clientnum, false); - sv2csqcbuf = msg; num = 1; for (i = 0, n = states;i < numstates;i++, n++) { // all entities between the previous entity state and this one are dead for (;num < n->number;num++) - if(sv2csqcents_version[csqc_clientnum][num]) + if(svs.clients[sv.writeentitiestoclient_clientnumber].csqcentityversion[num]) EntityFrameCSQC_WriteState(msg, num, false, §ionstarted); // update this entity EntityFrameCSQC_WriteState(msg, num, true, §ionstarted); @@ -410,14 +372,13 @@ void EntityFrameCSQC_WriteFrame (sizebuf_t *msg, int numstates, const entity_sta } // all remaining entities are dead for (;num < prog->num_edicts;num++) - if(sv2csqcents_version[csqc_clientnum][num]) + if(svs.clients[sv.writeentitiestoclient_clientnumber].csqcentityversion[num]) EntityFrameCSQC_WriteState(msg, num, false, §ionstarted); if (sectionstarted) { // write index 0 to end the update (0 is never used by real entities) MSG_WriteShort(msg, 0); } - sv2csqcbuf = NULL; } void Protocol_UpdateClientStats(const int *stats) diff --git a/protocol.h b/protocol.h index 04faf61e..142544f8 100644 --- a/protocol.h +++ b/protocol.h @@ -336,7 +336,7 @@ void Protocol_Names(char *buffer, size_t buffersize); #define RENDER_NOSELFSHADOW 262144 // render lighting on this entity before its own shadow is added to the scene // (note: all RENDER_NOSELFSHADOW entities are grouped together and rendered in a batch before their shadows are rendered, so they can not shadow eachother either) -// this is 96 bytes +// this is 80 bytes typedef struct entity_state_s { // ! means this is not sent to client @@ -344,17 +344,11 @@ typedef struct entity_state_s float netcenter[3]; // ! for network prioritization, this is the center of the bounding box (which may differ from the origin) float origin[3]; float angles[3]; - int number; // entity number this state is for int effects; - unsigned int customizeentityforclient; // ! + unsigned short number; // entity number this state is for unsigned short modelindex; unsigned short frame; unsigned short tagentity; - unsigned short specialvisibilityradius; // ! larger if it has effects/light - unsigned short viewmodelforclient; // ! - unsigned short exteriormodelforclient; // ! not shown if first person viewing from this entity, shown in all other cases - unsigned short nodrawtoclient; // ! - unsigned short drawonlytoclient; // ! unsigned short light[4]; // color*256 (0.00 to 255.996), and radius*1 unsigned char active; // true if a valid state unsigned char lightstyle; @@ -366,9 +360,9 @@ typedef struct entity_state_s unsigned char glowsize; unsigned char glowcolor; unsigned char flags; + unsigned char internaleffects; // INTEF_FLAG1QW and so on unsigned char tagindex; unsigned char colormod[3]; - unsigned char internaleffects; // INTEF_FLAG1QW and so on // padding to a multiple of 8 bytes (to align the double time) unsigned char unused; } diff --git a/prvm_cmds.c b/prvm_cmds.c index 7c74a060..9b3dfb7c 100644 --- a/prvm_cmds.c +++ b/prvm_cmds.c @@ -724,10 +724,6 @@ void VM_remove (void) } else PRVM_ED_Free (ed); -// if (ed == prog->edicts) -// PRVM_ERROR ("remove: tried to remove world"); -// if (PRVM_NUM_FOR_EDICT(ed) <= sv.maxclients) -// Host_Error("remove: tried to remove a client"); } /* diff --git a/prvm_edict.c b/prvm_edict.c index b3cd3f05..a9ed755e 100644 --- a/prvm_edict.c +++ b/prvm_edict.c @@ -953,8 +953,7 @@ qboolean PRVM_ED_ParseEpair(prvm_edict_t *ent, ddef_t *key, const char *s) Con_Printf("PRVM_ED_ParseEpair: ev_entity reference too large (edict %u >= MAX_EDICTS %u) on %s\n", (unsigned int)i, (unsigned int)MAX_EDICTS, PRVM_NAME); while (i >= prog->max_edicts) PRVM_MEM_IncreaseEdicts(); - //SV_IncreaseEdicts(); - // if SV_IncreaseEdicts was called the base pointer needs to be updated + // if IncreaseEdicts was called the base pointer needs to be updated if (ent) val = (prvm_eval_t *)((int *)ent->fields.vp + key->ofs); val->edict = PRVM_EDICT_TO_PROG(PRVM_EDICT_NUM((int)i)); diff --git a/server.h b/server.h index 34c95851..699b11a1 100644 --- a/server.h +++ b/server.h @@ -91,9 +91,6 @@ typedef struct server_s // updated by SV_SoundIndex char sound_precache[MAX_SOUNDS][MAX_QPATH]; char lightstyles[MAX_LIGHTSTYLES][64]; - // PushMove sometimes has to move entities back from a failed move - // (dynamically resized) - prvm_edict_t **moved_edicts; // some actions are only valid during load server_state_t state; @@ -116,6 +113,18 @@ typedef struct server_s #define SV_MAX_PARTICLEEFFECTNAME 256 qboolean particleeffectnamesloaded; char particleeffectname[SV_MAX_PARTICLEEFFECTNAME][MAX_QPATH]; + + int writeentitiestoclient_stats_culled_pvs; + int writeentitiestoclient_stats_culled_trace; + int writeentitiestoclient_stats_visibleentities; + int writeentitiestoclient_stats_totalentities; + int writeentitiestoclient_cliententitynumber; + int writeentitiestoclient_clientnumber; + sizebuf_t *writeentitiestoclient_msg; + vec3_t writeentitiestoclient_testeye; + int writeentitiestoclient_pvsbytes; + unsigned char writeentitiestoclient_pvs[MAX_MAP_LEAFS/8]; + entity_state_t writeentitiestoclient_sendstates[MAX_EDICTS]; } server_t; // if defined this does ping smoothing, otherwise it does not @@ -182,6 +191,9 @@ typedef struct client_s // visibility state float visibletime[MAX_EDICTS]; + // version number of csqc-based entity to decide whether to send it + unsigned char csqcentityversion[MAX_EDICTS]; + // prevent animated names float nametime; diff --git a/sv_main.c b/sv_main.c index 73d2edde..15a72896 100644 --- a/sv_main.c +++ b/sv_main.c @@ -22,12 +22,13 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. #include "quakedef.h" #include "libcurl.h" -void SV_VM_Init(); -void SV_VM_Setup(); +extern void SV_Phys_Init (void); +static void SV_SaveEntFile_f(void); +static void SV_StartDownload_f(void); +static void SV_Download_f(void); +static void SV_VM_Setup(); void VM_CustomStats_Clear (void); -void EntityFrameCSQC_ClearVersions (void); -void EntityFrameCSQC_InitClientVersions (int client, qboolean clear); void VM_SV_UpdateCustomStats (client_t *client, prvm_edict_t *ent, sizebuf_t *msg, int *stats); void EntityFrameCSQC_WriteFrame (sizebuf_t *msg, int numstates, const entity_state_t *states); @@ -69,6 +70,40 @@ cvar_t sv_gameplayfix_droptofloorstartsolid = {0, "sv_gameplayfix_droptofloorsta cvar_t sv_progs = {0, "sv_progs", "progs.dat", "selects which quakec progs.dat file to run" }; +cvar_t pr_checkextension = {CVAR_READONLY, "pr_checkextension", "1", "indicates to QuakeC that the standard quakec extensions system is available (if 0, quakec should not attempt to use extensions)"}; +cvar_t nomonsters = {0, "nomonsters", "0", "unused cvar in quake, can be used by mods"}; +cvar_t gamecfg = {0, "gamecfg", "0", "unused cvar in quake, can be used by mods"}; +cvar_t scratch1 = {0, "scratch1", "0", "unused cvar in quake, can be used by mods"}; +cvar_t scratch2 = {0,"scratch2", "0", "unused cvar in quake, can be used by mods"}; +cvar_t scratch3 = {0, "scratch3", "0", "unused cvar in quake, can be used by mods"}; +cvar_t scratch4 = {0, "scratch4", "0", "unused cvar in quake, can be used by mods"}; +cvar_t savedgamecfg = {CVAR_SAVE, "savedgamecfg", "0", "unused cvar in quake that is saved to config.cfg on exit, can be used by mods"}; +cvar_t saved1 = {CVAR_SAVE, "saved1", "0", "unused cvar in quake that is saved to config.cfg on exit, can be used by mods"}; +cvar_t saved2 = {CVAR_SAVE, "saved2", "0", "unused cvar in quake that is saved to config.cfg on exit, can be used by mods"}; +cvar_t saved3 = {CVAR_SAVE, "saved3", "0", "unused cvar in quake that is saved to config.cfg on exit, can be used by mods"}; +cvar_t saved4 = {CVAR_SAVE, "saved4", "0", "unused cvar in quake that is saved to config.cfg on exit, can be used by mods"}; +cvar_t nehx00 = {0, "nehx00", "0", "nehahra data storage cvar (used in singleplayer)"}; +cvar_t nehx01 = {0, "nehx01", "0", "nehahra data storage cvar (used in singleplayer)"}; +cvar_t nehx02 = {0, "nehx02", "0", "nehahra data storage cvar (used in singleplayer)"}; +cvar_t nehx03 = {0, "nehx03", "0", "nehahra data storage cvar (used in singleplayer)"}; +cvar_t nehx04 = {0, "nehx04", "0", "nehahra data storage cvar (used in singleplayer)"}; +cvar_t nehx05 = {0, "nehx05", "0", "nehahra data storage cvar (used in singleplayer)"}; +cvar_t nehx06 = {0, "nehx06", "0", "nehahra data storage cvar (used in singleplayer)"}; +cvar_t nehx07 = {0, "nehx07", "0", "nehahra data storage cvar (used in singleplayer)"}; +cvar_t nehx08 = {0, "nehx08", "0", "nehahra data storage cvar (used in singleplayer)"}; +cvar_t nehx09 = {0, "nehx09", "0", "nehahra data storage cvar (used in singleplayer)"}; +cvar_t nehx10 = {0, "nehx10", "0", "nehahra data storage cvar (used in singleplayer)"}; +cvar_t nehx11 = {0, "nehx11", "0", "nehahra data storage cvar (used in singleplayer)"}; +cvar_t nehx12 = {0, "nehx12", "0", "nehahra data storage cvar (used in singleplayer)"}; +cvar_t nehx13 = {0, "nehx13", "0", "nehahra data storage cvar (used in singleplayer)"}; +cvar_t nehx14 = {0, "nehx14", "0", "nehahra data storage cvar (used in singleplayer)"}; +cvar_t nehx15 = {0, "nehx15", "0", "nehahra data storage cvar (used in singleplayer)"}; +cvar_t nehx16 = {0, "nehx16", "0", "nehahra data storage cvar (used in singleplayer)"}; +cvar_t nehx17 = {0, "nehx17", "0", "nehahra data storage cvar (used in singleplayer)"}; +cvar_t nehx18 = {0, "nehx18", "0", "nehahra data storage cvar (used in singleplayer)"}; +cvar_t nehx19 = {0, "nehx19", "0", "nehahra data storage cvar (used in singleplayer)"}; +cvar_t cutscene = {0, "cutscene", "1", "enables cutscenes in nehahra, can be used by other mods"}; + // TODO: move these cvars here extern cvar_t sv_clmovement_enable; extern cvar_t sv_clmovement_minping; @@ -80,12 +115,125 @@ server_static_t svs; mempool_t *sv_mempool = NULL; -//============================================================================ +extern cvar_t slowmo; +extern float scr_centertime_off; + +// MUST match effectnameindex_t in client.h +static const char *standardeffectnames[EFFECT_TOTAL] = +{ + "", + "TE_GUNSHOT", + "TE_GUNSHOTQUAD", + "TE_SPIKE", + "TE_SPIKEQUAD", + "TE_SUPERSPIKE", + "TE_SUPERSPIKEQUAD", + "TE_WIZSPIKE", + "TE_KNIGHTSPIKE", + "TE_EXPLOSION", + "TE_EXPLOSIONQUAD", + "TE_TAREXPLOSION", + "TE_TELEPORT", + "TE_LAVASPLASH", + "TE_SMALLFLASH", + "TE_FLAMEJET", + "EF_FLAME", + "TE_BLOOD", + "TE_SPARK", + "TE_PLASMABURN", + "TE_TEI_G3", + "TE_TEI_SMOKE", + "TE_TEI_BIGEXPLOSION", + "TE_TEI_PLASMAHIT", + "EF_STARDUST", + "TR_ROCKET", + "TR_GRENADE", + "TR_BLOOD", + "TR_WIZSPIKE", + "TR_SLIGHTBLOOD", + "TR_KNIGHTSPIKE", + "TR_VORESPIKE", + "TR_NEHAHRASMOKE", + "TR_NEXUIZPLASMA", + "TR_GLOWTRAIL", + "SVC_PARTICLE" +}; + +#define REQFIELDS (sizeof(reqfields) / sizeof(prvm_required_field_t)) + +prvm_required_field_t reqfields[] = +{ + {ev_entity, "cursor_trace_ent"}, + {ev_entity, "drawonlytoclient"}, + {ev_entity, "exteriormodeltoclient"}, + {ev_entity, "nodrawtoclient"}, + {ev_entity, "tag_entity"}, + {ev_entity, "viewmodelforclient"}, + {ev_float, "Version"}, + {ev_float, "alpha"}, + {ev_float, "ammo_cells1"}, + {ev_float, "ammo_lava_nails"}, + {ev_float, "ammo_multi_rockets"}, + {ev_float, "ammo_nails1"}, + {ev_float, "ammo_plasma"}, + {ev_float, "ammo_rockets1"}, + {ev_float, "ammo_shells1"}, + {ev_float, "button3"}, + {ev_float, "button4"}, + {ev_float, "button5"}, + {ev_float, "button6"}, + {ev_float, "button7"}, + {ev_float, "button8"}, + {ev_float, "button9"}, + {ev_float, "button10"}, + {ev_float, "button11"}, + {ev_float, "button12"}, + {ev_float, "button13"}, + {ev_float, "button14"}, + {ev_float, "button15"}, + {ev_float, "button16"}, + {ev_float, "buttonchat"}, + {ev_float, "buttonuse"}, + {ev_float, "clientcolors"}, + {ev_float, "cursor_active"}, + {ev_float, "disableclientprediction"}, + {ev_float, "fullbright"}, + {ev_float, "glow_color"}, + {ev_float, "glow_size"}, + {ev_float, "glow_trail"}, + {ev_float, "gravity"}, + {ev_float, "idealpitch"}, + {ev_float, "items2"}, + {ev_float, "light_lev"}, + {ev_float, "modelflags"}, + {ev_float, "pflags"}, + {ev_float, "ping"}, + {ev_float, "pitch_speed"}, + {ev_float, "pmodel"}, + {ev_float, "renderamt"}, // HalfLife support + {ev_float, "rendermode"}, // HalfLife support + {ev_float, "scale"}, + {ev_float, "style"}, + {ev_float, "tag_index"}, + {ev_float, "viewzoom"}, + {ev_function, "SendEntity"}, + {ev_function, "contentstransition"}, // DRESK - Support for Entity Contents Transition Event + {ev_function, "customizeentityforclient"}, + {ev_string, "netaddress"}, + {ev_string, "playermodel"}, + {ev_string, "playerskin"}, + {ev_vector, "color"}, + {ev_vector, "colormod"}, + {ev_vector, "cursor_screen"}, + {ev_vector, "cursor_trace_endpos"}, + {ev_vector, "cursor_trace_start"}, + {ev_vector, "movement"}, + {ev_vector, "punchvector"}, +}; + -extern void SV_Phys_Init (void); -static void SV_SaveEntFile_f(void); -static void SV_StartDownload_f(void); -static void SV_Download_f(void); + +//============================================================================ void SV_AreaStats_f(void) { @@ -164,7 +312,44 @@ void SV_Init (void) Cvar_RegisterVariable (&sv_allowdownloads_dlcache); Cvar_RegisterVariable (&sv_progs); - SV_VM_Init(); + Cvar_RegisterVariable (&pr_checkextension); + Cvar_RegisterVariable (&nomonsters); + Cvar_RegisterVariable (&gamecfg); + Cvar_RegisterVariable (&scratch1); + Cvar_RegisterVariable (&scratch2); + Cvar_RegisterVariable (&scratch3); + Cvar_RegisterVariable (&scratch4); + Cvar_RegisterVariable (&savedgamecfg); + Cvar_RegisterVariable (&saved1); + Cvar_RegisterVariable (&saved2); + Cvar_RegisterVariable (&saved3); + Cvar_RegisterVariable (&saved4); + // LordHavoc: Nehahra uses these to pass data around cutscene demos + if (gamemode == GAME_NEHAHRA) + { + Cvar_RegisterVariable (&nehx00); + Cvar_RegisterVariable (&nehx01); + Cvar_RegisterVariable (&nehx02); + Cvar_RegisterVariable (&nehx03); + Cvar_RegisterVariable (&nehx04); + Cvar_RegisterVariable (&nehx05); + Cvar_RegisterVariable (&nehx06); + Cvar_RegisterVariable (&nehx07); + Cvar_RegisterVariable (&nehx08); + Cvar_RegisterVariable (&nehx09); + Cvar_RegisterVariable (&nehx10); + Cvar_RegisterVariable (&nehx11); + Cvar_RegisterVariable (&nehx12); + Cvar_RegisterVariable (&nehx13); + Cvar_RegisterVariable (&nehx14); + Cvar_RegisterVariable (&nehx15); + Cvar_RegisterVariable (&nehx16); + Cvar_RegisterVariable (&nehx17); + Cvar_RegisterVariable (&nehx18); + Cvar_RegisterVariable (&nehx19); + } + Cvar_RegisterVariable (&cutscene); // for Nehahra but useful to other mods as well + SV_Phys_Init(); sv_mempool = Mem_AllocPool("server", 0, NULL); @@ -386,6 +571,9 @@ void SV_SendServerinfo (client_t *client) client->entitydatabase5 = EntityFrame5_AllocDatabase(sv_mempool); } + // reset csqc entity versions + memset(client->csqcentityversion, 0, sizeof(client->csqcentityversion)); + SZ_Clear (&client->netconnection->message); MSG_WriteByte (&client->netconnection->message, svc_print); dpsnprintf (message, sizeof (message), "\nServer: %s build %s (progs %i crc)", gamename, buildstring, prog->filecrc); @@ -486,9 +674,6 @@ void SV_ConnectClient (int clientnum, netconn_t *netconnection) client = svs.clients + clientnum; - if(netconnection)//[515]: bots don't play with csqc =) - EntityFrameCSQC_InitClientVersions(clientnum, false); - // set up the client_t if (sv.loadgame) memcpy (spawn_parms, client->spawn_parms, sizeof(spawn_parms)); @@ -557,35 +742,34 @@ crosses a waterline. ============================================================================= */ -int sv_writeentitiestoclient_pvsbytes; -unsigned char sv_writeentitiestoclient_pvs[MAX_MAP_LEAFS/8]; - -static int numsendentities; -static entity_state_t sendentities[MAX_EDICTS]; -static entity_state_t *sendentitiesindex[MAX_EDICTS]; - -static int sententitiesmark = 0; -static int sententities[MAX_EDICTS]; -static int sententitiesconsideration[MAX_EDICTS]; -static int sv_writeentitiestoclient_culled_pvs; -static int sv_writeentitiestoclient_culled_trace; -static int sv_writeentitiestoclient_visibleentities; -static int sv_writeentitiestoclient_totalentities; -//static entity_frame_t sv_writeentitiestoclient_entityframe; -static int sv_writeentitiestoclient_clentnum; -static vec3_t sv_writeentitiestoclient_testeye; -static client_t *sv_writeentitiestoclient_client; - -qboolean SV_PrepareEntityForSending (prvm_edict_t *ent, entity_state_t *cs, int e) +static qboolean SV_BuildEntityState (entity_state_t *cs, prvm_edict_t *ent, int enumber) { int i; + unsigned int tagentity; unsigned int modelindex, effects, flags, glowsize, lightstyle, lightpflags, light[4], specialvisibilityradius; unsigned int customizeentityforclient; float f; - vec3_t cullmins, cullmaxs; + vec3_t cullmins, cullmaxs, netcenter; model_t *model; prvm_eval_t *val; + // see if the customizeentityforclient extension is used by this entity + customizeentityforclient = PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.customizeentityforclient)->function; + if (customizeentityforclient) + { + prog->globals.server->self = enumber; + prog->globals.server->other = sv.writeentitiestoclient_cliententitynumber; + PRVM_ExecuteProgram(customizeentityforclient, "customizeentityforclient: NULL function"); + // customizeentityforclient can return false to reject the entity + if (!PRVM_G_FLOAT(OFS_RETURN)) + return false; + } + + // this 2 billion unit check is actually to detect NAN origins + // (we really don't want to send those) + if (!(VectorLength2(ent->fields.server->origin) < 2000000000.0*2000000000.0)) + return false; + // EF_NODRAW prevents sending for any reason except for your own // client, so we must keep all clients in this superset effects = (unsigned)ent->fields.server->effects; @@ -594,13 +778,15 @@ qboolean SV_PrepareEntityForSending (prvm_edict_t *ent, entity_state_t *cs, int // LordHavoc: this could kill tags attached to an invisible entity, I // just hope we never have to support that case i = (int)ent->fields.server->modelindex; - modelindex = (i >= 1 && i < MAX_MODELS && *PRVM_GetString(ent->fields.server->model)) ? i : 0; + modelindex = (i >= 1 && i < MAX_MODELS && ent->fields.server->model && *PRVM_GetString(ent->fields.server->model)) ? i : 0; flags = 0; i = (int)(PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.glow_size)->_float * 0.25f); glowsize = (unsigned char)bound(0, i, 255); if (PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.glow_trail)->_float) flags |= RENDER_GLOWTRAIL; + if (PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.viewmodelforclient)->edict) + flags |= RENDER_VIEWMODEL; f = PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.color)->vector[0]*256; light[0] = (unsigned short)bound(0, f, 65535); @@ -660,144 +846,74 @@ qboolean SV_PrepareEntityForSending (prvm_edict_t *ent, entity_state_t *cs, int specialvisibilityradius = max(specialvisibilityradius, 100); } - // early culling checks - // (final culling is done by SV_MarkWriteEntityStateToClient) - customizeentityforclient = PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.customizeentityforclient)->function; - if (!customizeentityforclient) + // don't send uninteresting entities + if (enumber != sv.writeentitiestoclient_cliententitynumber) { - if (e > svs.maxclients && (!modelindex && !specialvisibilityradius)) + if (!modelindex && !specialvisibilityradius) return false; - // this 2 billion unit check is actually to detect NAN origins - // (we really don't want to send those) - if (VectorLength2(ent->fields.server->origin) > 2000000000.0*2000000000.0) + if (PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.nodrawtoclient)->edict == sv.writeentitiestoclient_cliententitynumber) + return false; + if (PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.drawonlytoclient)->edict && PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.drawonlytoclient)->edict != sv.writeentitiestoclient_cliententitynumber) + return false; + if (PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.viewmodelforclient)->edict && PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.viewmodelforclient)->edict != sv.writeentitiestoclient_cliententitynumber) + return false; + if (flags & RENDER_VIEWMODEL && PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.viewmodelforclient)->edict != sv.writeentitiestoclient_cliententitynumber) + return false; + if (effects & EF_NODRAW) return false; } - - *cs = defaultstate; - cs->active = true; - cs->number = e; - VectorCopy(ent->fields.server->origin, cs->origin); - VectorCopy(ent->fields.server->angles, cs->angles); - cs->flags = flags; - cs->effects = effects; - cs->colormap = (unsigned)ent->fields.server->colormap; - cs->modelindex = modelindex; - cs->skin = (unsigned)ent->fields.server->skin; - cs->frame = (unsigned)ent->fields.server->frame; - cs->viewmodelforclient = PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.viewmodelforclient)->edict; - cs->exteriormodelforclient = PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.exteriormodeltoclient)->edict; - cs->nodrawtoclient = PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.nodrawtoclient)->edict; - cs->drawonlytoclient = PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.drawonlytoclient)->edict; - cs->customizeentityforclient = customizeentityforclient; - cs->tagentity = PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.tag_entity)->edict; - cs->tagindex = (unsigned char)PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.tag_index)->_float; - cs->glowsize = glowsize; - - // don't need to init cs->colormod because the defaultstate did that for us - //cs->colormod[0] = cs->colormod[1] = cs->colormod[2] = 32; - val = PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.colormod); - if (val->vector[0] || val->vector[1] || val->vector[2]) - { - i = (int)(val->vector[0] * 32.0f);cs->colormod[0] = bound(0, i, 255); - i = (int)(val->vector[1] * 32.0f);cs->colormod[1] = bound(0, i, 255); - i = (int)(val->vector[2] * 32.0f);cs->colormod[2] = bound(0, i, 255); - } - - cs->modelindex = modelindex; - - cs->alpha = 255; - f = (PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.alpha)->_float * 255.0f); - if (f) - { - i = (int)f; - cs->alpha = (unsigned char)bound(0, i, 255); - } - // halflife - f = (PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.renderamt)->_float); - if (f) - { - i = (int)f; - cs->alpha = (unsigned char)bound(0, i, 255); - } - - cs->scale = 16; - f = (PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.scale)->_float * 16.0f); - if (f) - { - i = (int)f; - cs->scale = (unsigned char)bound(0, i, 255); - } - - cs->glowcolor = 254; - f = (PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.glow_color)->_float); - if (f) - cs->glowcolor = (int)f; - - if (PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.fullbright)->_float) - cs->effects |= EF_FULLBRIGHT; - - val = PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.modelflags); - if (val && val->_float) - cs->effects |= ((unsigned int)val->_float & 0xff) << 24; - - if (ent->fields.server->movetype == MOVETYPE_STEP) - cs->flags |= RENDER_STEP; - if (cs->number != sv_writeentitiestoclient_clentnum && (cs->effects & EF_LOWPRECISION) && cs->origin[0] >= -32768 && cs->origin[1] >= -32768 && cs->origin[2] >= -32768 && cs->origin[0] <= 32767 && cs->origin[1] <= 32767 && cs->origin[2] <= 32767) - cs->flags |= RENDER_LOWPRECISION; - if (ent->fields.server->colormap >= 1024) - cs->flags |= RENDER_COLORMAPPED; - if (cs->viewmodelforclient) - cs->flags |= RENDER_VIEWMODEL; // show relative to the view - - cs->light[0] = light[0]; - cs->light[1] = light[1]; - cs->light[2] = light[2]; - cs->light[3] = light[3]; - cs->lightstyle = lightstyle; - cs->lightpflags = lightpflags; - - cs->specialvisibilityradius = specialvisibilityradius; + // don't send child if parent was rejected + // FIXME: it would be better to force the parent to send... + tagentity = PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.tag_entity)->edict; + if (tagentity && !SV_BuildEntityState(NULL, PRVM_EDICT_NUM(tagentity), tagentity)) + return false; // calculate the visible box of this entity (don't use the physics box // as that is often smaller than a model, and would not count // specialvisibilityradius) if ((model = sv.models[modelindex])) { - float scale = cs->scale * (1.0f / 16.0f); - if (cs->angles[0] || cs->angles[2]) // pitch and roll + float scale = PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.glow_color)->_float; + if (scale) + scale *= (1.0f / 16.0f); + else + scale = 1; + if (ent->fields.server->angles[0] || ent->fields.server->angles[2]) // pitch and roll { - VectorMA(cs->origin, scale, model->rotatedmins, cullmins); - VectorMA(cs->origin, scale, model->rotatedmaxs, cullmaxs); + VectorMA(ent->fields.server->origin, scale, model->rotatedmins, cullmins); + VectorMA(ent->fields.server->origin, scale, model->rotatedmaxs, cullmaxs); } - else if (cs->angles[1]) + else if (ent->fields.server->angles[1]) { - VectorMA(cs->origin, scale, model->yawmins, cullmins); - VectorMA(cs->origin, scale, model->yawmaxs, cullmaxs); + VectorMA(ent->fields.server->origin, scale, model->yawmins, cullmins); + VectorMA(ent->fields.server->origin, scale, model->yawmaxs, cullmaxs); } else { - VectorMA(cs->origin, scale, model->normalmins, cullmins); - VectorMA(cs->origin, scale, model->normalmaxs, cullmaxs); + VectorMA(ent->fields.server->origin, scale, model->normalmins, cullmins); + VectorMA(ent->fields.server->origin, scale, model->normalmaxs, cullmaxs); } } else { // if there is no model (or it could not be loaded), use the physics box - VectorAdd(cs->origin, ent->fields.server->mins, cullmins); - VectorAdd(cs->origin, ent->fields.server->maxs, cullmaxs); + VectorAdd(ent->fields.server->origin, ent->fields.server->mins, cullmins); + VectorAdd(ent->fields.server->origin, ent->fields.server->maxs, cullmaxs); } if (specialvisibilityradius) { - cullmins[0] = min(cullmins[0], cs->origin[0] - specialvisibilityradius); - cullmins[1] = min(cullmins[1], cs->origin[1] - specialvisibilityradius); - cullmins[2] = min(cullmins[2], cs->origin[2] - specialvisibilityradius); - cullmaxs[0] = max(cullmaxs[0], cs->origin[0] + specialvisibilityradius); - cullmaxs[1] = max(cullmaxs[1], cs->origin[1] + specialvisibilityradius); - cullmaxs[2] = max(cullmaxs[2], cs->origin[2] + specialvisibilityradius); + cullmins[0] = min(cullmins[0], ent->fields.server->origin[0] - specialvisibilityradius); + cullmins[1] = min(cullmins[1], ent->fields.server->origin[1] - specialvisibilityradius); + cullmins[2] = min(cullmins[2], ent->fields.server->origin[2] - specialvisibilityradius); + cullmaxs[0] = max(cullmaxs[0], ent->fields.server->origin[0] + specialvisibilityradius); + cullmaxs[1] = max(cullmaxs[1], ent->fields.server->origin[1] + specialvisibilityradius); + cullmaxs[2] = max(cullmaxs[2], ent->fields.server->origin[2] + specialvisibilityradius); } + // calculate center of bbox for network prioritization purposes - VectorMAM(0.5f, cullmins, 0.5f, cullmaxs, cs->netcenter); + VectorMAM(0.5f, cullmins, 0.5f, cullmaxs, netcenter); + // if culling box has moved, update pvs cluster links if (!VectorCompare(cullmins, ent->priv.server->cullmins) || !VectorCompare(cullmaxs, ent->priv.server->cullmaxs)) { @@ -816,107 +932,36 @@ qboolean SV_PrepareEntityForSending (prvm_edict_t *ent, entity_state_t *cs, int } } - return true; -} - -void SV_PrepareEntitiesForSending(void) -{ - int e; - prvm_edict_t *ent; - // send all entities that touch the pvs - numsendentities = 0; - sendentitiesindex[0] = NULL; - memset(sendentitiesindex, 0, prog->num_edicts * sizeof(entity_state_t *)); - for (e = 1, ent = PRVM_NEXT_EDICT(prog->edicts);e < prog->num_edicts;e++, ent = PRVM_NEXT_EDICT(ent)) - { - if (!ent->priv.server->free && SV_PrepareEntityForSending(ent, sendentities + numsendentities, e)) - { - sendentitiesindex[e] = sendentities + numsendentities; - numsendentities++; - } - } -} - -void SV_MarkWriteEntityStateToClient(entity_state_t *s) -{ - int isbmodel; - model_t *model; - prvm_edict_t *ed; - if (sententitiesconsideration[s->number] == sententitiesmark) - return; - sententitiesconsideration[s->number] = sententitiesmark; - sv_writeentitiestoclient_totalentities++; - - if (s->customizeentityforclient) - { - prog->globals.server->self = s->number; - prog->globals.server->other = sv_writeentitiestoclient_clentnum; - PRVM_ExecuteProgram(s->customizeentityforclient, "customizeentityforclient: NULL function"); - if(!PRVM_G_FLOAT(OFS_RETURN) || !SV_PrepareEntityForSending(PRVM_EDICT_NUM(s->number), s, s->number)) - return; - } - - // never reject player - if (s->number != sv_writeentitiestoclient_clentnum) + if (enumber != sv.writeentitiestoclient_cliententitynumber && !(effects & EF_NODEPTHTEST) && !(flags & RENDER_VIEWMODEL) && !tagentity) { - // check various rejection conditions - if (s->nodrawtoclient == sv_writeentitiestoclient_clentnum) - return; - if (s->drawonlytoclient && s->drawonlytoclient != sv_writeentitiestoclient_clentnum) - return; - if (s->effects & EF_NODRAW) - return; - // LordHavoc: only send entities with a model or important effects - if (!s->modelindex && s->specialvisibilityradius == 0) - return; - - isbmodel = (model = sv.models[s->modelindex]) != NULL && model->name[0] == '*'; - // viewmodels don't have visibility checking - if (s->viewmodelforclient) - { - if (s->viewmodelforclient != sv_writeentitiestoclient_clentnum) - return; - } - else if (s->tagentity) - { - // tag attached entities simply check their parent - if (!sendentitiesindex[s->tagentity]) - return; - SV_MarkWriteEntityStateToClient(sendentitiesindex[s->tagentity]); - if (sententities[s->tagentity] != sententitiesmark) - return; - } - // always send world submodels in newer protocols because they don't - // generate much traffic (in old protocols they hog bandwidth) - // but only if sv_cullentities_alwayssendbmodels is on - else if (!(s->effects & EF_NODEPTHTEST) && (!isbmodel || !sv_cullentities_nevercullbmodels.integer || sv.protocol == PROTOCOL_QUAKE || sv.protocol == PROTOCOL_QUAKEDP || sv.protocol == PROTOCOL_NEHAHRAMOVIE)) + qboolean isbmodel = (model = sv.models[modelindex]) != NULL && model->name[0] == '*'; + if (!isbmodel || !sv_cullentities_nevercullbmodels.integer) { - // entity has survived every check so far, check if visible - ed = PRVM_EDICT_NUM(s->number); + // cull based on visibility // if not touching a visible leaf - if (sv_cullentities_pvs.integer && sv_writeentitiestoclient_pvsbytes) + if (sv_cullentities_pvs.integer && sv.writeentitiestoclient_pvsbytes) { - if (ed->priv.server->pvs_numclusters < 0) + if (ent->priv.server->pvs_numclusters < 0) { // entity too big for clusters list - if (sv.worldmodel && sv.worldmodel->brush.BoxTouchingPVS && !sv.worldmodel->brush.BoxTouchingPVS(sv.worldmodel, sv_writeentitiestoclient_pvs, ed->priv.server->cullmins, ed->priv.server->cullmaxs)) + if (sv.worldmodel && sv.worldmodel->brush.BoxTouchingPVS && !sv.worldmodel->brush.BoxTouchingPVS(sv.worldmodel, sv.writeentitiestoclient_pvs, cullmins, cullmaxs)) { - sv_writeentitiestoclient_culled_pvs++; - return; + sv.writeentitiestoclient_stats_culled_pvs++; + return false; } } else { int i; // check cached clusters list - for (i = 0;i < ed->priv.server->pvs_numclusters;i++) - if (CHECKPVSBIT(sv_writeentitiestoclient_pvs, ed->priv.server->pvs_clusterlist[i])) + for (i = 0;i < ent->priv.server->pvs_numclusters;i++) + if (CHECKPVSBIT(sv.writeentitiestoclient_pvs, ent->priv.server->pvs_clusterlist[i])) break; - if (i == ed->priv.server->pvs_numclusters) + if (i == ent->priv.server->pvs_numclusters) { - sv_writeentitiestoclient_culled_pvs++; - return; + sv.writeentitiestoclient_stats_culled_pvs++; + return false; } } } @@ -924,14 +969,14 @@ void SV_MarkWriteEntityStateToClient(entity_state_t *s) // or not seen by random tracelines if (sv_cullentities_trace.integer && !isbmodel) { - int samples = s->specialvisibilityradius ? sv_cullentities_trace_samples_extra.integer : sv_cullentities_trace_samples.integer; + int samples = specialvisibilityradius ? sv_cullentities_trace_samples_extra.integer : sv_cullentities_trace_samples.integer; float enlarge = sv_cullentities_trace_enlarge.value; - qboolean visible = TRUE; + qboolean visible = true; do { - if(Mod_CanSeeBox_Trace(samples, enlarge, sv.worldmodel, sv_writeentitiestoclient_testeye, ed->priv.server->cullmins, ed->priv.server->cullmaxs)) + if(Mod_CanSeeBox_Trace(samples, enlarge, sv.worldmodel, sv.writeentitiestoclient_testeye, cullmins, cullmaxs)) break; // directly visible from the server's view if(sv_cullentities_trace_prediction.integer) @@ -943,10 +988,10 @@ void SV_MarkWriteEntityStateToClient(entity_state_t *s) // sorry, no wallhacking by high ping please, and at 200ms // ping a FPS is annoying to play anyway and a player is // likely to have changed his direction - VectorMA(sv_writeentitiestoclient_testeye, predtime, host_client->edict->fields.server->velocity, predeye); - if(sv.worldmodel->brush.TraceLineOfSight(sv.worldmodel, sv_writeentitiestoclient_testeye, predeye)) // must be able to go there... + VectorMA(sv.writeentitiestoclient_testeye, predtime, host_client->edict->fields.server->velocity, predeye); + if(sv.worldmodel->brush.TraceLineOfSight(sv.worldmodel, sv.writeentitiestoclient_testeye, predeye)) // must be able to go there... { - if(Mod_CanSeeBox_Trace(samples, enlarge, sv.worldmodel, predeye, ed->priv.server->cullmins, ed->priv.server->cullmaxs)) + if(Mod_CanSeeBox_Trace(samples, enlarge, sv.worldmodel, predeye, cullmins, cullmaxs)) break; // directly visible from the predicted view } else @@ -955,96 +1000,161 @@ void SV_MarkWriteEntityStateToClient(entity_state_t *s) } } - // when we get here, we can't see the entity - visible = FALSE; - } - while(0); + // when we get here, we can't see the entity + visible = false; + } + while(0); + + if(visible) + svs.clients[sv.writeentitiestoclient_clientnumber].visibletime[enumber] = realtime + sv_cullentities_trace_delay.value; + else if (realtime > svs.clients[sv.writeentitiestoclient_clientnumber].visibletime[enumber]) + { + sv.writeentitiestoclient_stats_culled_trace++; + return false; + } + } + } + } + + // if the caller was just checking... return true + if (!cs) + return true; + + *cs = defaultstate; + cs->active = true; + cs->number = enumber; + VectorCopy(netcenter, cs->netcenter); + VectorCopy(ent->fields.server->origin, cs->origin); + VectorCopy(ent->fields.server->angles, cs->angles); + cs->flags = flags; + cs->effects = effects; + cs->colormap = (unsigned)ent->fields.server->colormap; + cs->modelindex = modelindex; + cs->skin = (unsigned)ent->fields.server->skin; + cs->frame = (unsigned)ent->fields.server->frame; + cs->tagentity = PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.tag_entity)->edict; + cs->tagindex = (unsigned char)PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.tag_index)->_float; + cs->glowsize = glowsize; + + // don't need to init cs->colormod because the defaultstate did that for us + //cs->colormod[0] = cs->colormod[1] = cs->colormod[2] = 32; + val = PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.colormod); + if (val->vector[0] || val->vector[1] || val->vector[2]) + { + i = (int)(val->vector[0] * 32.0f);cs->colormod[0] = bound(0, i, 255); + i = (int)(val->vector[1] * 32.0f);cs->colormod[1] = bound(0, i, 255); + i = (int)(val->vector[2] * 32.0f);cs->colormod[2] = bound(0, i, 255); + } + + cs->modelindex = modelindex; + + cs->alpha = 255; + f = (PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.alpha)->_float * 255.0f); + if (f) + { + i = (int)f; + cs->alpha = (unsigned char)bound(0, i, 255); + } + // halflife + f = (PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.renderamt)->_float); + if (f) + { + i = (int)f; + cs->alpha = (unsigned char)bound(0, i, 255); + } + + cs->scale = 16; + f = (PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.scale)->_float * 16.0f); + if (f) + { + i = (int)f; + cs->scale = (unsigned char)bound(0, i, 255); + } + + cs->glowcolor = 254; + f = (PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.glow_color)->_float); + if (f) + cs->glowcolor = (int)f; + + if (PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.fullbright)->_float) + cs->effects |= EF_FULLBRIGHT; - if(visible) - sv_writeentitiestoclient_client->visibletime[s->number] = realtime + sv_cullentities_trace_delay.value; + val = PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.modelflags); + if (val && val->_float) + cs->effects |= ((unsigned int)val->_float & 0xff) << 24; - if (realtime > sv_writeentitiestoclient_client->visibletime[s->number]) - { - sv_writeentitiestoclient_culled_trace++; - return; - } - } - } - } + if (ent->fields.server->movetype == MOVETYPE_STEP) + cs->flags |= RENDER_STEP; + if (cs->number != sv.writeentitiestoclient_cliententitynumber && (cs->effects & EF_LOWPRECISION) && cs->origin[0] >= -32768 && cs->origin[1] >= -32768 && cs->origin[2] >= -32768 && cs->origin[0] <= 32767 && cs->origin[1] <= 32767 && cs->origin[2] <= 32767) + cs->flags |= RENDER_LOWPRECISION; + if (ent->fields.server->colormap >= 1024) + cs->flags |= RENDER_COLORMAPPED; + if (PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.glow_trail)->edict && PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.glow_trail)->edict == sv.writeentitiestoclient_cliententitynumber) + cs->flags |= RENDER_EXTERIORMODEL; - // this just marks it for sending - // FIXME: it would be more efficient to send here, but the entity - // compressor isn't that flexible - sv_writeentitiestoclient_visibleentities++; - sententities[s->number] = sententitiesmark; -} + cs->light[0] = light[0]; + cs->light[1] = light[1]; + cs->light[2] = light[2]; + cs->light[3] = light[3]; + cs->lightstyle = lightstyle; + cs->lightpflags = lightpflags; -entity_state_t sendstates[MAX_EDICTS]; -extern int csqc_clientnum; + return true; +} -void SV_WriteEntitiesToClient(client_t *client, prvm_edict_t *clent, sizebuf_t *msg) +static void SV_WriteEntitiesToClient(client_t *client, prvm_edict_t *clent, sizebuf_t *msg) { - int i, numsendstates; - entity_state_t *s; + int i; + int numsendstates; + prvm_edict_t *ent; // if there isn't enough space to accomplish anything, skip it if (msg->cursize + 25 > msg->maxsize) return; - sv_writeentitiestoclient_client = client; + sv.writeentitiestoclient_msg = msg; + sv.writeentitiestoclient_clientnumber = client - svs.clients; - sv_writeentitiestoclient_culled_pvs = 0; - sv_writeentitiestoclient_culled_trace = 0; - sv_writeentitiestoclient_visibleentities = 0; - sv_writeentitiestoclient_totalentities = 0; + sv.writeentitiestoclient_stats_culled_pvs = 0; + sv.writeentitiestoclient_stats_culled_trace = 0; + sv.writeentitiestoclient_stats_visibleentities = 0; + sv.writeentitiestoclient_stats_totalentities = 0; // find the client's PVS // the real place being tested from - VectorAdd(clent->fields.server->origin, clent->fields.server->view_ofs, sv_writeentitiestoclient_testeye); - sv_writeentitiestoclient_pvsbytes = 0; + VectorAdd(clent->fields.server->origin, clent->fields.server->view_ofs, sv.writeentitiestoclient_testeye); + sv.writeentitiestoclient_pvsbytes = 0; if (sv.worldmodel && sv.worldmodel->brush.FatPVS) - sv_writeentitiestoclient_pvsbytes = sv.worldmodel->brush.FatPVS(sv.worldmodel, sv_writeentitiestoclient_testeye, 8, sv_writeentitiestoclient_pvs, sizeof(sv_writeentitiestoclient_pvs)); - - sv_writeentitiestoclient_clentnum = PRVM_EDICT_TO_PROG(clent); // LordHavoc: for comparison purposes - csqc_clientnum = sv_writeentitiestoclient_clentnum - 1; + sv.writeentitiestoclient_pvsbytes = sv.worldmodel->brush.FatPVS(sv.worldmodel, sv.writeentitiestoclient_testeye, 8, sv.writeentitiestoclient_pvs, sizeof(sv.writeentitiestoclient_pvs)); - sententitiesmark++; - - for (i = 0;i < numsendentities;i++) - SV_MarkWriteEntityStateToClient(sendentities + i); + sv.writeentitiestoclient_cliententitynumber = PRVM_EDICT_TO_PROG(clent); // LordHavoc: for comparison purposes + // send all entities that touch the pvs numsendstates = 0; - for (i = 0;i < numsendentities;i++) - { - if (sententities[sendentities[i].number] == sententitiesmark) - { - s = &sendstates[numsendstates++]; - *s = sendentities[i]; - if (s->exteriormodelforclient && s->exteriormodelforclient == sv_writeentitiestoclient_clentnum) - s->flags |= RENDER_EXTERIORMODEL; - } - } + for (i = 1, ent = PRVM_NEXT_EDICT(prog->edicts);i < prog->num_edicts;i++, ent = PRVM_NEXT_EDICT(ent)) + if (!ent->priv.server->free && SV_BuildEntityState(sv.writeentitiestoclient_sendstates + numsendstates, ent, i)) + numsendstates++; if (sv_cullentities_stats.integer) - Con_Printf("client \"%s\" entities: %d total, %d visible, %d culled by: %d pvs %d trace\n", client->name, sv_writeentitiestoclient_totalentities, sv_writeentitiestoclient_visibleentities, sv_writeentitiestoclient_culled_pvs + sv_writeentitiestoclient_culled_trace, sv_writeentitiestoclient_culled_pvs, sv_writeentitiestoclient_culled_trace); + Con_Printf("client \"%s\" entities: %d total, %d visible, %d culled by: %d pvs %d trace\n", client->name, sv.writeentitiestoclient_stats_totalentities, sv.writeentitiestoclient_stats_visibleentities, sv.writeentitiestoclient_stats_culled_pvs + sv.writeentitiestoclient_stats_culled_trace, sv.writeentitiestoclient_stats_culled_pvs, sv.writeentitiestoclient_stats_culled_trace); - EntityFrameCSQC_WriteFrame(msg, numsendstates, sendstates); + EntityFrameCSQC_WriteFrame(msg, numsendstates, sv.writeentitiestoclient_sendstates); if (client->entitydatabase5) - EntityFrame5_WriteFrame(msg, client->entitydatabase5, numsendstates, sendstates, client - svs.clients + 1, client->movesequence); + EntityFrame5_WriteFrame(msg, client->entitydatabase5, numsendstates, sv.writeentitiestoclient_sendstates, client - svs.clients + 1, client->movesequence); else if (client->entitydatabase4) { - EntityFrame4_WriteFrame(msg, client->entitydatabase4, numsendstates, sendstates); + EntityFrame4_WriteFrame(msg, client->entitydatabase4, numsendstates, sv.writeentitiestoclient_sendstates); Protocol_WriteStatsReliable(); } else if (client->entitydatabase) { - EntityFrame_WriteFrame(msg, client->entitydatabase, numsendstates, sendstates, client - svs.clients + 1); + EntityFrame_WriteFrame(msg, client->entitydatabase, numsendstates, sv.writeentitiestoclient_sendstates, client - svs.clients + 1); Protocol_WriteStatsReliable(); } else { - EntityFrameQuake_WriteFrame(msg, numsendstates, sendstates); + EntityFrameQuake_WriteFrame(msg, numsendstates, sv.writeentitiestoclient_sendstates); Protocol_WriteStatsReliable(); } } @@ -1055,7 +1165,7 @@ SV_CleanupEnts ============= */ -void SV_CleanupEnts (void) +static void SV_CleanupEnts (void) { int e; prvm_edict_t *ent; @@ -1082,7 +1192,6 @@ void SV_WriteClientdataToMessage (client_t *client, prvm_edict_t *ent, sizebuf_t int viewzoom; const char *s; float *statsf = (float *)stats; -extern cvar_t slowmo; // // send a damage message @@ -1339,7 +1448,7 @@ void SV_FlushBroadcastMessages(void) SZ_Clear(&sv.datagram); } -void SV_WriteUnreliableMessages(client_t *client, sizebuf_t *msg) +static void SV_WriteUnreliableMessages(client_t *client, sizebuf_t *msg) { // scan the splitpoints to find out how many we can fit in int numsegments, j, split; @@ -1382,12 +1491,12 @@ void SV_WriteUnreliableMessages(client_t *client, sizebuf_t *msg) SV_SendClientDatagram ======================= */ -static unsigned char sv_sendclientdatagram_buf[NET_MAXMESSAGE]; // FIXME? -void SV_SendClientDatagram (client_t *client) +static void SV_SendClientDatagram (client_t *client) { int clientrate, maxrate, maxsize, maxsize2, downloadsize; sizebuf_t msg; int stats[MAX_CL_STATS]; + unsigned char sv_sendclientdatagram_buf[NET_MAXMESSAGE]; // PROTOCOL_DARKPLACES5 and later support packet size limiting of updates maxrate = max(NET_MINRATE, sv_maxrate.integer); @@ -1508,7 +1617,7 @@ void SV_SendClientDatagram (client_t *client) SV_UpdateToReliableMessages ======================= */ -void SV_UpdateToReliableMessages (void) +static void SV_UpdateToReliableMessages (void) { int i, j; client_t *client; @@ -1601,7 +1710,7 @@ SV_SendClientMessages */ void SV_SendClientMessages (void) { - int i, prepared = false; + int i; if (sv.protocol == PROTOCOL_QUAKEWORLD) Sys_Error("SV_SendClientMessages: no quakeworld support\n"); @@ -1625,12 +1734,6 @@ void SV_SendClientMessages (void) continue; } - if (!prepared) - { - prepared = true; - // only prepare entities once per frame - SV_PrepareEntitiesForSending(); - } SV_SendClientDatagram (host_client); } @@ -1638,13 +1741,13 @@ void SV_SendClientMessages (void) SV_CleanupEnts(); } -void SV_StartDownload_f(void) +static void SV_StartDownload_f(void) { if (host_client->download_file) host_client->download_started = true; } -void SV_Download_f(void) +static void SV_Download_f(void) { const char *whichpack, *whichpack2, *extension; @@ -1883,47 +1986,6 @@ int SV_SoundIndex(const char *s, int precachemode) return 0; } -// MUST match effectnameindex_t in client.h -static const char *standardeffectnames[EFFECT_TOTAL] = -{ - "", - "TE_GUNSHOT", - "TE_GUNSHOTQUAD", - "TE_SPIKE", - "TE_SPIKEQUAD", - "TE_SUPERSPIKE", - "TE_SUPERSPIKEQUAD", - "TE_WIZSPIKE", - "TE_KNIGHTSPIKE", - "TE_EXPLOSION", - "TE_EXPLOSIONQUAD", - "TE_TAREXPLOSION", - "TE_TELEPORT", - "TE_LAVASPLASH", - "TE_SMALLFLASH", - "TE_FLAMEJET", - "EF_FLAME", - "TE_BLOOD", - "TE_SPARK", - "TE_PLASMABURN", - "TE_TEI_G3", - "TE_TEI_SMOKE", - "TE_TEI_BIGEXPLOSION", - "TE_TEI_PLASMAHIT", - "EF_STARDUST", - "TR_ROCKET", - "TR_GRENADE", - "TR_BLOOD", - "TR_WIZSPIKE", - "TR_SLIGHTBLOOD", - "TR_KNIGHTSPIKE", - "TR_VORESPIKE", - "TR_NEHAHRASMOKE", - "TR_NEXUIZPLASMA", - "TR_GLOWTRAIL", - "SVC_PARTICLE" -}; - /* ================ SV_ParticleEffectIndex @@ -2009,7 +2071,7 @@ SV_CreateBaseline ================ */ -void SV_CreateBaseline (void) +static void SV_CreateBaseline (void) { int i, entnum, large; prvm_edict_t *svent; @@ -2102,49 +2164,6 @@ void SV_SaveSpawnparms (void) host_client->spawn_parms[j] = (&prog->globals.server->parm1)[j]; } } -/* -void SV_IncreaseEdicts(void) -{ - int i; - prvm_edict_t *ent; - int oldmax_edicts = prog->max_edicts; - void *oldedictsengineprivate = prog->edictprivate; - void *oldedictsfields = prog->edictsfields; - void *oldmoved_edicts = sv.moved_edicts; - - if (prog->max_edicts >= MAX_EDICTS) - return; - - // links don't survive the transition, so unlink everything - for (i = 0, ent = prog->edicts;i < prog->max_edicts;i++, ent++) - { - if (!ent->priv.server->free) - SV_UnlinkEdict(prog->edicts + i); - memset(&ent->priv.server->areagrid, 0, sizeof(ent->priv.server->areagrid)); - } - World_Clear(&sv.world); - - prog->max_edicts = min(prog->max_edicts + 256, MAX_EDICTS); - prog->edictprivate = PR_Alloc(prog->max_edicts * sizeof(edict_engineprivate_t)); - prog->edictsfields = PR_Alloc(prog->max_edicts * prog->edict_size); - sv.moved_edicts = PR_Alloc(prog->max_edicts * sizeof(prvm_edict_t *)); - - memcpy(prog->edictprivate, oldedictsengineprivate, oldmax_edicts * sizeof(edict_engineprivate_t)); - memcpy(prog->edictsfields, oldedictsfields, oldmax_edicts * prog->edict_size); - - for (i = 0, ent = prog->edicts;i < prog->max_edicts;i++, ent++) - { - ent->priv.vp = (unsigned char*) prog->edictprivate + i * prog->edictprivate_size; - ent->fields.server = (void *)((unsigned char *)prog->edictsfields + i * prog->edict_size); - // link every entity except world - if (!ent->priv.server->free) - SV_LinkEdict(ent, false); - } - - PR_Free(oldedictsengineprivate); - PR_Free(oldedictsfields); - PR_Free(oldmoved_edicts); -}*/ /* ================ @@ -2153,7 +2172,6 @@ SV_SpawnServer This is called at the start of each level ================ */ -extern float scr_centertime_off; void SV_SpawnServer (const char *server) { @@ -2252,30 +2270,6 @@ void SV_SpawnServer (const char *server) // load progs to get entity field count //PR_LoadProgs ( sv_progs.string ); - // allocate server memory - /*// start out with just enough room for clients and a reasonable estimate of entities - prog->max_edicts = max(svs.maxclients + 1, 512); - prog->max_edicts = min(prog->max_edicts, MAX_EDICTS); - - // prvm_edict_t structures (hidden from progs) - prog->edicts = PR_Alloc(MAX_EDICTS * sizeof(prvm_edict_t)); - // engine private structures (hidden from progs) - prog->edictprivate = PR_Alloc(prog->max_edicts * sizeof(edict_engineprivate_t)); - // progs fields, often accessed by server - prog->edictsfields = PR_Alloc(prog->max_edicts * prog->edict_size);*/ - // used by PushMove to move back pushed entities - sv.moved_edicts = (prvm_edict_t **)PRVM_Alloc(prog->max_edicts * sizeof(prvm_edict_t *)); - /*for (i = 0;i < prog->max_edicts;i++) - { - ent = prog->edicts + i; - ent->priv.vp = (unsigned char*) prog->edictprivate + i * prog->edictprivate_size; - ent->fields.server = (void *)((unsigned char *)prog->edictsfields + i * prog->edict_size); - }*/ - - // reset client csqc entity versions right away. - for (i = 0, host_client = svs.clients;i < svs.maxclients;i++, host_client++) - EntityFrameCSQC_InitClientVersions(i, true); - sv.datagram.maxsize = sizeof(sv.datagram_buf); sv.datagram.cursize = 0; sv.datagram.data = sv.datagram_buf; @@ -2426,14 +2420,11 @@ void SV_SpawnServer (const char *server) ///////////////////////////////////////////////////// // SV VM stuff -void SV_VM_CB_BeginIncreaseEdicts(void) +static void SV_VM_CB_BeginIncreaseEdicts(void) { int i; prvm_edict_t *ent; - PRVM_Free( sv.moved_edicts ); - sv.moved_edicts = (prvm_edict_t **)PRVM_Alloc(prog->max_edicts * sizeof(prvm_edict_t *)); - // links don't survive the transition, so unlink everything for (i = 0, ent = prog->edicts;i < prog->max_edicts;i++, ent++) { @@ -2444,7 +2435,7 @@ void SV_VM_CB_BeginIncreaseEdicts(void) World_Clear(&sv.world); } -void SV_VM_CB_EndIncreaseEdicts(void) +static void SV_VM_CB_EndIncreaseEdicts(void) { int i; prvm_edict_t *ent; @@ -2455,7 +2446,7 @@ void SV_VM_CB_EndIncreaseEdicts(void) SV_LinkEdict(ent, false); } -void SV_VM_CB_InitEdict(prvm_edict_t *e) +static void SV_VM_CB_InitEdict(prvm_edict_t *e) { // LordHavoc: for consistency set these here int num = PRVM_NUM_FOR_EDICT(e) - 1; @@ -2495,7 +2486,7 @@ void SV_VM_CB_InitEdict(prvm_edict_t *e) } } -void SV_VM_CB_FreeEdict(prvm_edict_t *ed) +static void SV_VM_CB_FreeEdict(prvm_edict_t *ed) { World_UnlinkEdict(ed); // unlink from world bsp @@ -2511,7 +2502,7 @@ void SV_VM_CB_FreeEdict(prvm_edict_t *ed) ed->fields.server->solid = 0; } -void SV_VM_CB_CountEdicts(void) +static void SV_VM_CB_CountEdicts(void) { int i; prvm_edict_t *ent; @@ -2539,7 +2530,7 @@ void SV_VM_CB_CountEdicts(void) Con_Printf("step :%3i\n", step); } -qboolean SV_VM_CB_LoadEdict(prvm_edict_t *ent) +static qboolean SV_VM_CB_LoadEdict(prvm_edict_t *ent) { // remove things from different skill levels or deathmatch if (gamemode != GAME_TRANSFUSION) //Transfusion does this in QC @@ -2561,154 +2552,7 @@ qboolean SV_VM_CB_LoadEdict(prvm_edict_t *ent) return true; } -cvar_t pr_checkextension = {CVAR_READONLY, "pr_checkextension", "1", "indicates to QuakeC that the standard quakec extensions system is available (if 0, quakec should not attempt to use extensions)"}; -cvar_t nomonsters = {0, "nomonsters", "0", "unused cvar in quake, can be used by mods"}; -cvar_t gamecfg = {0, "gamecfg", "0", "unused cvar in quake, can be used by mods"}; -cvar_t scratch1 = {0, "scratch1", "0", "unused cvar in quake, can be used by mods"}; -cvar_t scratch2 = {0,"scratch2", "0", "unused cvar in quake, can be used by mods"}; -cvar_t scratch3 = {0, "scratch3", "0", "unused cvar in quake, can be used by mods"}; -cvar_t scratch4 = {0, "scratch4", "0", "unused cvar in quake, can be used by mods"}; -cvar_t savedgamecfg = {CVAR_SAVE, "savedgamecfg", "0", "unused cvar in quake that is saved to config.cfg on exit, can be used by mods"}; -cvar_t saved1 = {CVAR_SAVE, "saved1", "0", "unused cvar in quake that is saved to config.cfg on exit, can be used by mods"}; -cvar_t saved2 = {CVAR_SAVE, "saved2", "0", "unused cvar in quake that is saved to config.cfg on exit, can be used by mods"}; -cvar_t saved3 = {CVAR_SAVE, "saved3", "0", "unused cvar in quake that is saved to config.cfg on exit, can be used by mods"}; -cvar_t saved4 = {CVAR_SAVE, "saved4", "0", "unused cvar in quake that is saved to config.cfg on exit, can be used by mods"}; -cvar_t nehx00 = {0, "nehx00", "0", "nehahra data storage cvar (used in singleplayer)"}; -cvar_t nehx01 = {0, "nehx01", "0", "nehahra data storage cvar (used in singleplayer)"}; -cvar_t nehx02 = {0, "nehx02", "0", "nehahra data storage cvar (used in singleplayer)"}; -cvar_t nehx03 = {0, "nehx03", "0", "nehahra data storage cvar (used in singleplayer)"}; -cvar_t nehx04 = {0, "nehx04", "0", "nehahra data storage cvar (used in singleplayer)"}; -cvar_t nehx05 = {0, "nehx05", "0", "nehahra data storage cvar (used in singleplayer)"}; -cvar_t nehx06 = {0, "nehx06", "0", "nehahra data storage cvar (used in singleplayer)"}; -cvar_t nehx07 = {0, "nehx07", "0", "nehahra data storage cvar (used in singleplayer)"}; -cvar_t nehx08 = {0, "nehx08", "0", "nehahra data storage cvar (used in singleplayer)"}; -cvar_t nehx09 = {0, "nehx09", "0", "nehahra data storage cvar (used in singleplayer)"}; -cvar_t nehx10 = {0, "nehx10", "0", "nehahra data storage cvar (used in singleplayer)"}; -cvar_t nehx11 = {0, "nehx11", "0", "nehahra data storage cvar (used in singleplayer)"}; -cvar_t nehx12 = {0, "nehx12", "0", "nehahra data storage cvar (used in singleplayer)"}; -cvar_t nehx13 = {0, "nehx13", "0", "nehahra data storage cvar (used in singleplayer)"}; -cvar_t nehx14 = {0, "nehx14", "0", "nehahra data storage cvar (used in singleplayer)"}; -cvar_t nehx15 = {0, "nehx15", "0", "nehahra data storage cvar (used in singleplayer)"}; -cvar_t nehx16 = {0, "nehx16", "0", "nehahra data storage cvar (used in singleplayer)"}; -cvar_t nehx17 = {0, "nehx17", "0", "nehahra data storage cvar (used in singleplayer)"}; -cvar_t nehx18 = {0, "nehx18", "0", "nehahra data storage cvar (used in singleplayer)"}; -cvar_t nehx19 = {0, "nehx19", "0", "nehahra data storage cvar (used in singleplayer)"}; -cvar_t cutscene = {0, "cutscene", "1", "enables cutscenes in nehahra, can be used by other mods"}; - -void SV_VM_Init(void) -{ - Cvar_RegisterVariable (&pr_checkextension); - Cvar_RegisterVariable (&nomonsters); - Cvar_RegisterVariable (&gamecfg); - Cvar_RegisterVariable (&scratch1); - Cvar_RegisterVariable (&scratch2); - Cvar_RegisterVariable (&scratch3); - Cvar_RegisterVariable (&scratch4); - Cvar_RegisterVariable (&savedgamecfg); - Cvar_RegisterVariable (&saved1); - Cvar_RegisterVariable (&saved2); - Cvar_RegisterVariable (&saved3); - Cvar_RegisterVariable (&saved4); - // LordHavoc: Nehahra uses these to pass data around cutscene demos - if (gamemode == GAME_NEHAHRA) - { - Cvar_RegisterVariable (&nehx00); - Cvar_RegisterVariable (&nehx01); - Cvar_RegisterVariable (&nehx02); - Cvar_RegisterVariable (&nehx03); - Cvar_RegisterVariable (&nehx04); - Cvar_RegisterVariable (&nehx05); - Cvar_RegisterVariable (&nehx06); - Cvar_RegisterVariable (&nehx07); - Cvar_RegisterVariable (&nehx08); - Cvar_RegisterVariable (&nehx09); - Cvar_RegisterVariable (&nehx10); - Cvar_RegisterVariable (&nehx11); - Cvar_RegisterVariable (&nehx12); - Cvar_RegisterVariable (&nehx13); - Cvar_RegisterVariable (&nehx14); - Cvar_RegisterVariable (&nehx15); - Cvar_RegisterVariable (&nehx16); - Cvar_RegisterVariable (&nehx17); - Cvar_RegisterVariable (&nehx18); - Cvar_RegisterVariable (&nehx19); - } - Cvar_RegisterVariable (&cutscene); // for Nehahra but useful to other mods as well -} - -#define REQFIELDS (sizeof(reqfields) / sizeof(prvm_required_field_t)) - -prvm_required_field_t reqfields[] = -{ - {ev_entity, "cursor_trace_ent"}, - {ev_entity, "drawonlytoclient"}, - {ev_entity, "exteriormodeltoclient"}, - {ev_entity, "nodrawtoclient"}, - {ev_entity, "tag_entity"}, - {ev_entity, "viewmodelforclient"}, - {ev_float, "Version"}, - {ev_float, "alpha"}, - {ev_float, "ammo_cells1"}, - {ev_float, "ammo_lava_nails"}, - {ev_float, "ammo_multi_rockets"}, - {ev_float, "ammo_nails1"}, - {ev_float, "ammo_plasma"}, - {ev_float, "ammo_rockets1"}, - {ev_float, "ammo_shells1"}, - {ev_float, "button3"}, - {ev_float, "button4"}, - {ev_float, "button5"}, - {ev_float, "button6"}, - {ev_float, "button7"}, - {ev_float, "button8"}, - {ev_float, "button9"}, - {ev_float, "button10"}, - {ev_float, "button11"}, - {ev_float, "button12"}, - {ev_float, "button13"}, - {ev_float, "button14"}, - {ev_float, "button15"}, - {ev_float, "button16"}, - {ev_float, "buttonchat"}, - {ev_float, "buttonuse"}, - {ev_float, "clientcolors"}, - {ev_float, "cursor_active"}, - {ev_float, "disableclientprediction"}, - {ev_float, "fullbright"}, - {ev_float, "glow_color"}, - {ev_float, "glow_size"}, - {ev_float, "glow_trail"}, - {ev_float, "gravity"}, - {ev_float, "idealpitch"}, - {ev_float, "items2"}, - {ev_float, "light_lev"}, - {ev_float, "modelflags"}, - {ev_float, "pflags"}, - {ev_float, "ping"}, - {ev_float, "pitch_speed"}, - {ev_float, "pmodel"}, - {ev_float, "renderamt"}, // HalfLife support - {ev_float, "rendermode"}, // HalfLife support - {ev_float, "scale"}, - {ev_float, "style"}, - {ev_float, "tag_index"}, - {ev_float, "viewzoom"}, - {ev_function, "SendEntity"}, - {ev_function, "contentstransition"}, // DRESK - Support for Entity Contents Transition Event - {ev_function, "customizeentityforclient"}, - {ev_string, "netaddress"}, - {ev_string, "playermodel"}, - {ev_string, "playerskin"}, - {ev_vector, "color"}, - {ev_vector, "colormod"}, - {ev_vector, "cursor_screen"}, - {ev_vector, "cursor_trace_endpos"}, - {ev_vector, "cursor_trace_start"}, - {ev_vector, "movement"}, - {ev_vector, "punchvector"}, -}; - -void SV_VM_Setup(void) +static void SV_VM_Setup(void) { extern cvar_t csqc_progname; //[515]: csqc crc check and right csprogs name according to progs.dat extern cvar_t csqc_progcrc; @@ -2774,7 +2618,6 @@ void SV_VM_Setup(void) prog->flag |= PRVM_OP_STATE; VM_CustomStats_Clear();//[515]: csqc - EntityFrameCSQC_ClearVersions();//[515]: csqc PRVM_End; diff --git a/sv_phys.c b/sv_phys.c index f1b9b0b7..b13f4f57 100644 --- a/sv_phys.c +++ b/sv_phys.c @@ -303,7 +303,7 @@ void SV_LinkEdict_TouchAreaGrid(prvm_edict_t *ent) prvm_edict_t *touch, *touchedicts[MAX_EDICTS]; // build a list of edicts to touch, because the link loop can be corrupted - // by SV_IncreaseEdicts called during touch functions + // by IncreaseEdicts called during touch functions numtouchedicts = World_EntitiesInBox(&sv.world, ent->priv.server->areamins, ent->priv.server->areamaxs, MAX_EDICTS, touchedicts); if (numtouchedicts > MAX_EDICTS) { @@ -1029,6 +1029,7 @@ void SV_PushMove (prvm_edict_t *pusher, float movetime) model_t *pushermodel; trace_t trace; matrix4x4_t pusherfinalmatrix, pusherfinalimatrix; + unsigned short moved_edicts[MAX_EDICTS]; if (!pusher->fields.server->velocity[0] && !pusher->fields.server->velocity[1] && !pusher->fields.server->velocity[2] && !pusher->fields.server->avelocity[0] && !pusher->fields.server->avelocity[1] && !pusher->fields.server->avelocity[2]) { @@ -1182,7 +1183,7 @@ void SV_PushMove (prvm_edict_t *pusher, float movetime) VectorCopy (check->fields.server->origin, check->priv.server->moved_from); VectorCopy (check->fields.server->angles, check->priv.server->moved_fromangles); - sv.moved_edicts[num_moved++] = check; + moved_edicts[num_moved++] = PRVM_NUM_FOR_EDICT(check); // try moving the contacted entity pusher->fields.server->solid = SOLID_NOT; @@ -1244,7 +1245,7 @@ void SV_PushMove (prvm_edict_t *pusher, float movetime) // move back any entities we already moved for (i = 0;i < num_moved;i++) { - prvm_edict_t *ed = sv.moved_edicts[i]; + prvm_edict_t *ed = PRVM_EDICT_NUM(moved_edicts[i]); VectorCopy (ed->priv.server->moved_from, ed->fields.server->origin); VectorCopy (ed->priv.server->moved_fromangles, ed->fields.server->angles); SV_LinkEdict (ed, false); diff --git a/svvm_cmds.c b/svvm_cmds.c index 470b7366..f47c05b0 100644 --- a/svvm_cmds.c +++ b/svvm_cmds.c @@ -1109,7 +1109,6 @@ sizebuf_t *WriteDest (void) int entnum; int dest; prvm_edict_t *ent; - extern sizebuf_t *sv2csqcbuf; dest = (int)PRVM_G_FLOAT(OFS_PARM0); switch (dest) @@ -1137,7 +1136,7 @@ sizebuf_t *WriteDest (void) return &sv.signon; case MSG_ENTITY: - return sv2csqcbuf; + return sv.writeentitiestoclient_msg; } return NULL; diff --git a/view.c b/view.c index 9be30a70..8cbdc5f7 100644 --- a/view.c +++ b/view.c @@ -496,8 +496,8 @@ void V_CalcRefdef (void) Matrix4x4_CreateFromQuakeEntity(&r_view.matrix, vieworg[0], vieworg[1], vieworg[2], viewangles[0], viewangles[1], viewangles[2] + v_idlescale.value * sin(cl.time*v_iroll_cycle.value) * v_iroll_level.value, 1); // calculate a viewmodel matrix for use in view-attached entities Matrix4x4_CreateFromQuakeEntity(&viewmodelmatrix, gunorg[0], gunorg[1], gunorg[2], viewangles[0], viewangles[1], viewangles[2], cl_viewmodel_scale.value); - VectorCopy(vieworg, csqc_origin); - VectorCopy(viewangles, csqc_angles); + VectorCopy(vieworg, cl.csqc_origin); + VectorCopy(viewangles, cl.csqc_angles); } } } -- 2.39.2