rewrote server sendstates building code, no longer builds two
authorhavoc <havoc@d7cf8633-e32d-0410-b094-e92efae38249>
Mon, 7 May 2007 05:37:08 +0000 (05:37 +0000)
committerhavoc <havoc@d7cf8633-e32d-0410-b094-e92efae38249>
Mon, 7 May 2007 05:37:08 +0000 (05:37 +0000)
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

15 files changed:
cl_input.c
client.h
clvm_cmds.c
csprogs.c
csprogs.h
host.c
protocol.c
protocol.h
prvm_cmds.c
prvm_edict.c
server.h
sv_main.c
sv_phys.c
svvm_cmds.c
view.c

index c5e1a37..94a64a7 100644 (file)
@@ -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"};
 
index 8f37000..83e4884 100644 (file)
--- 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;
index 2d820b8..674221a 100644 (file)
@@ -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);
index 8ba21cb..dcd6e5b 100644 (file)
--- 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;
 }
index 45b91a3..451fc3d 100644 (file)
--- a/csprogs.h
+++ b/csprogs.h
                                                                // 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 637c2be..3e1ba42 100644 (file)
--- 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);
index aa40970..da01432 100644 (file)
@@ -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, &sectionstarted);
                // update this entity
                EntityFrameCSQC_WriteState(msg, num, true, &sectionstarted);
@@ -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, &sectionstarted);
        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)
index 04faf61..142544f 100644 (file)
@@ -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;
 }
index 7c74a06..9b3dfb7 100644 (file)
@@ -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");
 }
 
 /*
index b3cd3f0..a9ed755 100644 (file)
@@ -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));
index 34c9585..699b11a 100644 (file)
--- 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;
 
index 73d2edd..15a7289 100644 (file)
--- 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;
 
index f1b9b0b..b13f4f5 100644 (file)
--- 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);
index 470b736..f47c05b 100644 (file)
@@ -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 9be30a7..8cbdc5f 100644 (file)
--- 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);
                }
        }
 }