renamed varray_ arrays to rsurface_array_, and they are no longer used outside the...

[xonotic/darkplaces.git] / protocol.c

diff --git a/protocol.c b/protocol.c
index 6b104129aed653cda4e0b326c43c6188c644f9a8..ad544396422081f03827e5000eb965c9ace2f655 100644 (file)
--- a/protocol.c
+++ b/protocol.c
@@ -1,6 +1,8 @@
 
 #include "quakedef.h"
 
 
 #include "quakedef.h"
 

+#define E5_PROTOCOL_PRIORITYLEVELS 32
+

 // this is 88 bytes (must match entity_state_t in protocol.h)
 entity_state_t defaultstate =
 {
 // this is 88 bytes (must match entity_state_t in protocol.h)
 entity_state_t defaultstate =
 {


@@ -60,6 +62,17 @@ protocolversioninfo[] =
        {0, NULL}
 };
 
        {0, NULL}
 };
 

+static mempool_t *sv2csqc = NULL;
+int csqc_clent = 0;
+sizebuf_t *sv2csqcbuf = NULL;
+static unsigned char *sv2csqcents_version[MAX_SCOREBOARD];
+
+static entity_frame_t deltaframe; // FIXME?
+static entity_frame_t framedata; // FIXME?
+
+int entityframe5_prioritychaincounts[E5_PROTOCOL_PRIORITYLEVELS];
+unsigned short entityframe5_prioritychains[E5_PROTOCOL_PRIORITYLEVELS][ENTITYFRAME5_MAXSTATES];
+

 protocolversion_t Protocol_EnumForName(const char *s)
 {
        int i;
 protocolversion_t Protocol_EnumForName(const char *s)
 {
        int i;


@@ -102,10 +115,6 @@ void Protocol_Names(char *buffer, size_t buffersize)
        }
 }
 
        }
 }
 

-// keep track of quake entities because they need to be killed if they get stale
-int cl_lastquakeentity = 0;
-unsigned char cl_isquakeentity[MAX_EDICTS];
-

 void EntityFrameQuake_ReadEntity(int bits)
 {
        int num;
 void EntityFrameQuake_ReadEntity(int bits)
 {
        int num;


@@ -131,14 +140,14 @@ void EntityFrameQuake_ReadEntity(int bits)
        if (num < 1)
                Host_Error("EntityFrameQuake_ReadEntity: invalid entity number (%i)", num);
 
        if (num < 1)
                Host_Error("EntityFrameQuake_ReadEntity: invalid entity number (%i)", num);
 

-       if (cl_num_entities <= num)
+       if (cl.num_entities <= num)

        {
        {

-               cl_num_entities = num + 1;
-               if (num >= cl_max_entities)
+               cl.num_entities = num + 1;
+               if (num >= cl.max_entities)

                        CL_ExpandEntities(num);
        }
 
                        CL_ExpandEntities(num);
        }
 

-       ent = cl_entities + num;
+       ent = cl.entities + num;

 
        // note: this inherits the 'active' state of the baseline chosen
        // (state_baseline is always active, state_current may not be active if
 
        // note: this inherits the 'active' state of the baseline chosen
        // (state_baseline is always active, state_current may not be active if


@@ -151,9 +160,9 @@ void EntityFrameQuake_ReadEntity(int bits)
                s.active = true;
        }
 
                s.active = true;
        }
 

-       cl_isquakeentity[num] = true;
-       if (cl_lastquakeentity < num)
-               cl_lastquakeentity = num;
+       cl.isquakeentity[num] = true;
+       if (cl.lastquakeentity < num)
+               cl.lastquakeentity = num;

        s.number = num;
        s.time = cl.mtime[0];
        s.flags = 0;
        s.number = num;
        s.time = cl.mtime[0];
        s.flags = 0;


@@ -206,7 +215,7 @@ void EntityFrameQuake_ReadEntity(int bits)
        if (ent->state_current.active)
        {
                CL_MoveLerpEntityStates(ent);
        if (ent->state_current.active)
        {
                CL_MoveLerpEntityStates(ent);

-               cl_entities_active[ent->state_current.number] = true;
+               cl.entities_active[ent->state_current.number] = true;

        }
 
        if (msg_badread)
        }
 
        if (msg_badread)


@@ -216,35 +225,30 @@ void EntityFrameQuake_ReadEntity(int bits)
 void EntityFrameQuake_ISeeDeadEntities(void)
 {
        int num, lastentity;
 void EntityFrameQuake_ISeeDeadEntities(void)
 {
        int num, lastentity;

-       if (cl_lastquakeentity == 0)
+       if (cl.lastquakeentity == 0)

                return;
                return;

-       lastentity = cl_lastquakeentity;
-       cl_lastquakeentity = 0;
+       lastentity = cl.lastquakeentity;
+       cl.lastquakeentity = 0;

        for (num = 0;num <= lastentity;num++)
        {
        for (num = 0;num <= lastentity;num++)
        {

-               if (cl_isquakeentity[num])
+               if (cl.isquakeentity[num])

                {
                {

-                       if (cl_entities_active[num] && cl_entities[num].state_current.time == cl.mtime[0])
+                       if (cl.entities_active[num] && cl.entities[num].state_current.time == cl.mtime[0])

                        {
                        {

-                               cl_isquakeentity[num] = true;
-                               cl_lastquakeentity = num;
+                               cl.isquakeentity[num] = true;
+                               cl.lastquakeentity = num;

                        }
                        else
                        {
                        }
                        else
                        {

-                               cl_isquakeentity[num] = false;
-                               cl_entities_active[num] = false;
-                               cl_entities[num].state_current = defaultstate;
-                               cl_entities[num].state_current.number = num;
+                               cl.isquakeentity[num] = false;
+                               cl.entities_active[num] = false;
+                               cl.entities[num].state_current = defaultstate;
+                               cl.entities[num].state_current.number = num;

                        }
                }
        }
 }
 
                        }
                }
        }
 }
 

-static mempool_t *sv2csqc = NULL;
-int csqc_clent = 0;
-sizebuf_t *sv2csqcbuf = NULL;
-static unsigned char *sv2csqcents_version[64];
-

 void EntityFrameCSQC_ClearVersions (void)
 {
        if(sv2csqc)
 void EntityFrameCSQC_ClearVersions (void)
 {
        if(sv2csqc)


@@ -252,7 +256,7 @@ void EntityFrameCSQC_ClearVersions (void)
                Mem_FreePool(&sv2csqc);
                sv2csqc = NULL;
        }
                Mem_FreePool(&sv2csqc);
                sv2csqc = NULL;
        }

-       memset(sv2csqcents_version, 0, 64*sizeof(unsigned char *));
+       memset(sv2csqcents_version, 0, MAX_SCOREBOARD*sizeof(unsigned char *));

 }
 
 void EntityFrameCSQC_InitClientVersions (int client, qboolean clear)
 }
 
 void EntityFrameCSQC_InitClientVersions (int client, qboolean clear)


@@ -1007,7 +1011,6 @@ void EntityFrame_AddFrame(entityframe_database_t *d, vec3_t eye, int framenum, i
 }
 
 // (server) writes a frame to network stream
 }
 
 // (server) writes a frame to network stream

-static entity_frame_t deltaframe; // FIXME?

 void EntityFrame_WriteFrame(sizebuf_t *msg, entityframe_database_t *d, int numstates, const entity_state_t *states, int viewentnum)
 {
        int i, onum, number;
 void EntityFrame_WriteFrame(sizebuf_t *msg, entityframe_database_t *d, int numstates, const entity_state_t *states, int viewentnum)
 {
        int i, onum, number;


@@ -1076,7 +1079,6 @@ void EntityFrame_WriteFrame(sizebuf_t *msg, entityframe_database_t *d, int numst
 }
 
 // (client) reads a frame from network stream
 }
 
 // (client) reads a frame from network stream

-static entity_frame_t framedata; // FIXME?

 void EntityFrame_CL_ReadFrame(void)
 {
        int i, number, removed;
 void EntityFrame_CL_ReadFrame(void)
 {
        int i, number, removed;


@@ -1085,7 +1087,7 @@ void EntityFrame_CL_ReadFrame(void)
        entity_t *ent;
        entityframe_database_t *d;
        if (!cl.entitydatabase)
        entity_t *ent;
        entityframe_database_t *d;
        if (!cl.entitydatabase)

-               cl.entitydatabase = EntityFrame_AllocDatabase(cl_mempool);
+               cl.entitydatabase = EntityFrame_AllocDatabase(cls.levelmempool);

        d = cl.entitydatabase;
 
        EntityFrame_Clear(f, NULL, -1);
        d = cl.entitydatabase;
 
        EntityFrame_Clear(f, NULL, -1);


@@ -1147,13 +1149,13 @@ void EntityFrame_CL_ReadFrame(void)
                                *e = defaultstate;
                        }
 
                                *e = defaultstate;
                        }
 

-                       if (cl_num_entities <= number)
+                       if (cl.num_entities <= number)

                        {
                        {

-                               cl_num_entities = number + 1;
-                               if (number >= cl_max_entities)
+                               cl.num_entities = number + 1;
+                               if (number >= cl.max_entities)

                                        CL_ExpandEntities(number);
                        }
                                        CL_ExpandEntities(number);
                        }

-                       cl_entities_active[number] = true;
+                       cl.entities_active[number] = true;

                        e->active = true;
                        e->time = cl.mtime[0];
                        e->number = number;
                        e->active = true;
                        e->time = cl.mtime[0];
                        e->number = number;


@@ -1169,35 +1171,35 @@ void EntityFrame_CL_ReadFrame(void)
        }
        EntityFrame_AddFrame(d, f->eye, f->framenum, f->numentities, f->entitydata);
 
        }
        EntityFrame_AddFrame(d, f->eye, f->framenum, f->numentities, f->entitydata);
 

-       memset(cl_entities_active, 0, cl_num_entities * sizeof(unsigned char));
+       memset(cl.entities_active, 0, cl.num_entities * sizeof(unsigned char));

        number = 1;
        for (i = 0;i < f->numentities;i++)
        {
        number = 1;
        for (i = 0;i < f->numentities;i++)
        {

-               for (;number < f->entitydata[i].number && number < cl_num_entities;number++)
+               for (;number < f->entitydata[i].number && number < cl.num_entities;number++)

                {
                {

-                       if (cl_entities_active[number])
+                       if (cl.entities_active[number])

                        {
                        {

-                               cl_entities_active[number] = false;
-                               cl_entities[number].state_current.active = false;
+                               cl.entities_active[number] = false;
+                               cl.entities[number].state_current.active = false;

                        }
                }
                        }
                }

-               if (number >= cl_num_entities)
+               if (number >= cl.num_entities)

                        break;
                // update the entity
                        break;
                // update the entity

-               ent = &cl_entities[number];
+               ent = &cl.entities[number];

                ent->state_previous = ent->state_current;
                ent->state_current = f->entitydata[i];
                CL_MoveLerpEntityStates(ent);
                // the entity lives again...
                ent->state_previous = ent->state_current;
                ent->state_current = f->entitydata[i];
                CL_MoveLerpEntityStates(ent);
                // the entity lives again...

-               cl_entities_active[number] = true;
+               cl.entities_active[number] = true;

                number++;
        }
                number++;
        }

-       for (;number < cl_num_entities;number++)
+       for (;number < cl.num_entities;number++)

        {
        {

-               if (cl_entities_active[number])
+               if (cl.entities_active[number])

                {
                {

-                       cl_entities_active[number] = false;
-                       cl_entities[number].state_current.active = false;
+                       cl.entities_active[number] = false;
+                       cl.entities[number].state_current.active = false;

                }
        }
 }
                }
        }
 }


@@ -1355,7 +1357,7 @@ void EntityFrame4_CL_ReadFrame(void)
        entity_state_t *s;
        entityframe4_database_t *d;
        if (!cl.entitydatabase4)
        entity_state_t *s;
        entityframe4_database_t *d;
        if (!cl.entitydatabase4)

-               cl.entitydatabase4 = EntityFrame4_AllocDatabase(cl_mempool);
+               cl.entitydatabase4 = EntityFrame4_AllocDatabase(cls.levelmempool);

        d = cl.entitydatabase4;
        // read the number of the frame this refers to
        referenceframenum = MSG_ReadLong();
        d = cl.entitydatabase4;
        // read the number of the frame this refers to
        referenceframenum = MSG_ReadLong();


@@ -1410,10 +1412,10 @@ void EntityFrame4_CL_ReadFrame(void)
                // high bit means it's a remove message
                cnumber = n & 0x7FFF;
                // if this is a live entity we may need to expand the array
                // high bit means it's a remove message
                cnumber = n & 0x7FFF;
                // if this is a live entity we may need to expand the array

-               if (cl_num_entities <= cnumber && !(n & 0x8000))
+               if (cl.num_entities <= cnumber && !(n & 0x8000))

                {
                {

-                       cl_num_entities = cnumber + 1;
-                       if (cnumber >= cl_max_entities)
+                       cl.num_entities = cnumber + 1;
+                       if (cnumber >= cl.max_entities)

                                CL_ExpandEntities(cnumber);
                }
                // add one (the changed one) if not done
                                CL_ExpandEntities(cnumber);
                }
                // add one (the changed one) if not done


@@ -1421,7 +1423,7 @@ void EntityFrame4_CL_ReadFrame(void)
                // process entities in range from the last one to the changed one
                for (;enumber < stopnumber;enumber++)
                {
                // process entities in range from the last one to the changed one
                for (;enumber < stopnumber;enumber++)
                {

-                       if (skip || enumber >= cl_num_entities)
+                       if (skip || enumber >= cl.num_entities)

                        {
                                if (enumber == cnumber && (n & 0x8000) == 0)
                                {
                        {
                                if (enumber == cnumber && (n & 0x8000) == 0)
                                {


@@ -1431,10 +1433,10 @@ void EntityFrame4_CL_ReadFrame(void)
                                continue;
                        }
                        // slide the current into the previous slot
                                continue;
                        }
                        // slide the current into the previous slot

-                       cl_entities[enumber].state_previous = cl_entities[enumber].state_current;
+                       cl.entities[enumber].state_previous = cl.entities[enumber].state_current;

                        // copy a new current from reference database
                        // copy a new current from reference database

-                       cl_entities[enumber].state_current = *EntityFrame4_GetReferenceEntity(d, enumber);
-                       s = &cl_entities[enumber].state_current;
+                       cl.entities[enumber].state_current = *EntityFrame4_GetReferenceEntity(d, enumber);
+                       s = &cl.entities[enumber].state_current;

                        // if this is the one to modify, read more data...
                        if (enumber == cnumber)
                        {
                        // if this is the one to modify, read more data...
                        if (enumber == cnumber)
                        {


@@ -1456,24 +1458,24 @@ void EntityFrame4_CL_ReadFrame(void)
                        }
                        else if (developer_networkentities.integer >= 4)
                                Con_Printf("entity %i: copy\n", enumber);
                        }
                        else if (developer_networkentities.integer >= 4)
                                Con_Printf("entity %i: copy\n", enumber);

-                       // set the cl_entities_active flag
-                       cl_entities_active[enumber] = s->active;
+                       // set the cl.entities_active flag
+                       cl.entities_active[enumber] = s->active;

                        // set the update time
                        s->time = cl.mtime[0];
                        // fix the number (it gets wiped occasionally by copying from defaultstate)
                        s->number = enumber;
                        // check if we need to update the lerp stuff
                        if (s->active)
                        // set the update time
                        s->time = cl.mtime[0];
                        // fix the number (it gets wiped occasionally by copying from defaultstate)
                        s->number = enumber;
                        // check if we need to update the lerp stuff
                        if (s->active)

-                               CL_MoveLerpEntityStates(&cl_entities[enumber]);
+                               CL_MoveLerpEntityStates(&cl.entities[enumber]);

                        // add this to the commit entry whether it is modified or not
                        if (d->currentcommit)
                        // add this to the commit entry whether it is modified or not
                        if (d->currentcommit)

-                               EntityFrame4_AddCommitEntity(d, &cl_entities[enumber].state_current);
+                               EntityFrame4_AddCommitEntity(d, &cl.entities[enumber].state_current);

                        // print extra messages if desired
                        // print extra messages if desired

-                       if (developer_networkentities.integer >= 2 && cl_entities[enumber].state_current.active != cl_entities[enumber].state_previous.active)
+                       if (developer_networkentities.integer >= 2 && cl.entities[enumber].state_current.active != cl.entities[enumber].state_previous.active)

                        {
                        {

-                               if (cl_entities[enumber].state_current.active)
+                               if (cl.entities[enumber].state_current.active)

                                        Con_Printf("entity #%i has become active\n", enumber);
                                        Con_Printf("entity #%i has become active\n", enumber);

-                               else if (cl_entities[enumber].state_previous.active)
+                               else if (cl.entities[enumber].state_previous.active)

                                        Con_Printf("entity #%i has become inactive\n", enumber);
                        }
                }
                                        Con_Printf("entity #%i has become inactive\n", enumber);
                        }
                }


@@ -1590,8 +1592,6 @@ void EntityFrame4_WriteFrame(sizebuf_t *msg, entityframe4_database_t *d, int num
 
 
 
 
 
 

-#define E5_PROTOCOL_PRIORITYLEVELS 32
-

 entityframe5_database_t *EntityFrame5_AllocDatabase(mempool_t *pool)
 {
        int i;
 entityframe5_database_t *EntityFrame5_AllocDatabase(mempool_t *pool)
 {
        int i;


@@ -2055,14 +2055,14 @@ void EntityFrame5_CL_ReadFrame(void)
                // get the entity number
                enumber = n & 0x7FFF;
                // we may need to expand the array
                // get the entity number
                enumber = n & 0x7FFF;
                // we may need to expand the array

-               if (cl_num_entities <= enumber)
+               if (cl.num_entities <= enumber)

                {
                {

-                       cl_num_entities = enumber + 1;
-                       if (enumber >= cl_max_entities)
+                       cl.num_entities = enumber + 1;
+                       if (enumber >= cl.max_entities)

                                CL_ExpandEntities(enumber);
                }
                // look up the entity
                                CL_ExpandEntities(enumber);
                }
                // look up the entity

-               ent = cl_entities + enumber;
+               ent = cl.entities + enumber;

                // slide the current into the previous slot
                ent->state_previous = ent->state_current;
                // read the update
                // slide the current into the previous slot
                ent->state_previous = ent->state_current;
                // read the update


@@ -2077,21 +2077,21 @@ void EntityFrame5_CL_ReadFrame(void)
                        // update entity
                        EntityState5_ReadUpdate(s);
                }
                        // update entity
                        EntityState5_ReadUpdate(s);
                }

-               // set the cl_entities_active flag
-               cl_entities_active[enumber] = s->active;
+               // set the cl.entities_active flag
+               cl.entities_active[enumber] = s->active;

                // set the update time
                s->time = cl.mtime[0];
                // fix the number (it gets wiped occasionally by copying from defaultstate)
                s->number = enumber;
                // check if we need to update the lerp stuff
                if (s->active)
                // set the update time
                s->time = cl.mtime[0];
                // fix the number (it gets wiped occasionally by copying from defaultstate)
                s->number = enumber;
                // check if we need to update the lerp stuff
                if (s->active)

-                       CL_MoveLerpEntityStates(&cl_entities[enumber]);
+                       CL_MoveLerpEntityStates(&cl.entities[enumber]);

                // print extra messages if desired
                // print extra messages if desired

-               if (developer_networkentities.integer >= 2 && cl_entities[enumber].state_current.active != cl_entities[enumber].state_previous.active)
+               if (developer_networkentities.integer >= 2 && cl.entities[enumber].state_current.active != cl.entities[enumber].state_previous.active)

                {
                {

-                       if (cl_entities[enumber].state_current.active)
+                       if (cl.entities[enumber].state_current.active)

                                Con_Printf("entity #%i has become active\n", enumber);
                                Con_Printf("entity #%i has become active\n", enumber);

-                       else if (cl_entities[enumber].state_previous.active)
+                       else if (cl.entities[enumber].state_previous.active)

                                Con_Printf("entity #%i has become inactive\n", enumber);
                }
        }
                                Con_Printf("entity #%i has become inactive\n", enumber);
                }
        }


@@ -2166,9 +2166,6 @@ void EntityFrame5_AckFrame(entityframe5_database_t *d, int framenum)
                        d->packetlog[i].packetnumber = 0;
 }
 
                        d->packetlog[i].packetnumber = 0;
 }
 

-int entityframe5_prioritychaincounts[E5_PROTOCOL_PRIORITYLEVELS];
-unsigned short entityframe5_prioritychains[E5_PROTOCOL_PRIORITYLEVELS][ENTITYFRAME5_MAXSTATES];
-

 void EntityFrame5_WriteFrame(sizebuf_t *msg, entityframe5_database_t *d, int numstates, const entity_state_t *states, int viewentnum, int *stats, int movesequence)
 {
        const entity_state_t *n;
 void EntityFrame5_WriteFrame(sizebuf_t *msg, entityframe5_database_t *d, int numstates, const entity_state_t *states, int viewentnum, int *stats, int movesequence)
 {
        const entity_state_t *n;


@@ -2340,6 +2337,44 @@ void EntityFrame5_WriteFrame(sizebuf_t *msg, entityframe5_database_t *d, int num
 }
 
 
 }
 
 

+static int QW_TranslateEffects(int qweffects, int number)
+{
+       int effects = 0;
+       if (qweffects & QW_EF_BRIGHTFIELD)
+               effects |= EF_BRIGHTFIELD;
+       if (qweffects & QW_EF_MUZZLEFLASH)
+               effects |= EF_MUZZLEFLASH;
+       if (qweffects & QW_EF_FLAG1)
+       {
+               // mimic FTEQW's interpretation of EF_FLAG1 as EF_NODRAW on non-player entities
+               if (number > cl.maxclients)
+                       effects |= EF_NODRAW;
+               else
+                       effects |= EF_FLAG1QW;
+       }
+       if (qweffects & QW_EF_FLAG2)
+       {
+               // mimic FTEQW's interpretation of EF_FLAG2 as EF_ADDITIVE on non-player entities
+               if (number > cl.maxclients)
+                       effects |= EF_ADDITIVE;
+               else
+                       effects |= EF_FLAG2QW;
+       }
+       if (qweffects & QW_EF_RED)
+       {
+               if (qweffects & QW_EF_BLUE)
+                       effects |= EF_RED | EF_BLUE;
+               else
+                       effects |= EF_RED;
+       }
+       else if (qweffects & QW_EF_BLUE)
+               effects |= EF_BLUE;
+       else if (qweffects & QW_EF_BRIGHTLIGHT)
+               effects |= EF_BRIGHTLIGHT;
+       else if (qweffects & QW_EF_DIMLIGHT)
+               effects |= EF_DIMLIGHT;
+       return effects;
+}

 
 void EntityStateQW_ReadPlayerUpdate(void)
 {
 
 void EntityStateQW_ReadPlayerUpdate(void)
 {


@@ -2351,7 +2386,7 @@ void EntityStateQW_ReadPlayerUpdate(void)
        int bits;
        entity_state_t *s;
        // look up the entity
        int bits;
        entity_state_t *s;
        // look up the entity

-       entity_t *ent = cl_entities + enumber;
+       entity_t *ent = cl.entities + enumber;

        vec3_t viewangles;
        vec3_t velocity;
 
        vec3_t viewangles;
        vec3_t velocity;
 


@@ -2362,9 +2397,14 @@ void EntityStateQW_ReadPlayerUpdate(void)
        s = &ent->state_current;
        *s = defaultstate;
        s->active = true;
        s = &ent->state_current;
        *s = defaultstate;
        s->active = true;

+       s->colormap = enumber;

        playerflags = MSG_ReadShort();
        MSG_ReadVector(s->origin, cls.protocol);
        s->frame = MSG_ReadByte();
        playerflags = MSG_ReadShort();
        MSG_ReadVector(s->origin, cls.protocol);
        s->frame = MSG_ReadByte();

+
+       VectorClear(viewangles);
+       VectorClear(velocity);
+

        if (playerflags & QW_PF_MSEC)
        {
                // time difference between last update this player sent to the server,
        if (playerflags & QW_PF_MSEC)
        {
                // time difference between last update this player sent to the server,


@@ -2379,23 +2419,23 @@ void EntityStateQW_ReadPlayerUpdate(void)
        {
                bits = MSG_ReadByte();
                if (bits & QW_CM_ANGLE1)
        {
                bits = MSG_ReadByte();
                if (bits & QW_CM_ANGLE1)

-                       viewangles[0] = MSG_ReadAngle16i();
+                       viewangles[0] = MSG_ReadAngle16i(); // cmd->angles[0]

                if (bits & QW_CM_ANGLE2)
                if (bits & QW_CM_ANGLE2)

-                       viewangles[1] = MSG_ReadAngle16i();
+                       viewangles[1] = MSG_ReadAngle16i(); // cmd->angles[1]

                if (bits & QW_CM_ANGLE3)
                if (bits & QW_CM_ANGLE3)

-                       viewangles[2] = MSG_ReadAngle16i();
+                       viewangles[2] = MSG_ReadAngle16i(); // cmd->angles[2]

                if (bits & QW_CM_FORWARD)
                if (bits & QW_CM_FORWARD)

-                       MSG_ReadShort();
+                       MSG_ReadShort(); // cmd->forwardmove

                if (bits & QW_CM_SIDE)
                if (bits & QW_CM_SIDE)

-                       MSG_ReadShort();
+                       MSG_ReadShort(); // cmd->sidemove

                if (bits & QW_CM_UP)
                if (bits & QW_CM_UP)

-                       MSG_ReadShort();
+                       MSG_ReadShort(); // cmd->upmove

                if (bits & QW_CM_BUTTONS)
                if (bits & QW_CM_BUTTONS)

-                       MSG_ReadByte();
+                       MSG_ReadByte(); // cmd->buttons

                if (bits & QW_CM_IMPULSE)
                if (bits & QW_CM_IMPULSE)

-                       MSG_ReadByte();
+                       MSG_ReadByte(); // cmd->impulse
+               MSG_ReadByte(); // cmd->msec

        }
        }

-       VectorClear(velocity);

        if (playerflags & QW_PF_VELOCITY1)
                velocity[0] = MSG_ReadShort();
        if (playerflags & QW_PF_VELOCITY2)
        if (playerflags & QW_PF_VELOCITY1)
                velocity[0] = MSG_ReadShort();
        if (playerflags & QW_PF_VELOCITY2)


@@ -2409,9 +2449,17 @@ void EntityStateQW_ReadPlayerUpdate(void)
        if (playerflags & QW_PF_SKINNUM)
                s->skin = MSG_ReadByte();
        if (playerflags & QW_PF_EFFECTS)
        if (playerflags & QW_PF_SKINNUM)
                s->skin = MSG_ReadByte();
        if (playerflags & QW_PF_EFFECTS)

-               s->effects = MSG_ReadByte();
+               s->effects = QW_TranslateEffects(MSG_ReadByte(), enumber);

        if (playerflags & QW_PF_WEAPONFRAME)
                weaponframe = MSG_ReadByte();
        if (playerflags & QW_PF_WEAPONFRAME)
                weaponframe = MSG_ReadByte();

+       else
+               weaponframe = 0;
+
+       if (enumber == cl.playerentity)
+       {
+               // if this is an update on our player, update the angles
+               VectorCopy(cl.viewangles, viewangles);
+       }

 
        // calculate the entity angles from the viewangles
        s->angles[0] = viewangles[0] * -0.0333;
 
        // calculate the entity angles from the viewangles
        s->angles[0] = viewangles[0] * -0.0333;


@@ -2441,17 +2489,23 @@ void EntityStateQW_ReadPlayerUpdate(void)
 
                VectorCopy(velocity, cl.mvelocity[0]);
                cl.stats[STAT_WEAPONFRAME] = weaponframe;
 
                VectorCopy(velocity, cl.mvelocity[0]);
                cl.stats[STAT_WEAPONFRAME] = weaponframe;

+               if (playerflags & QW_PF_GIB)
+                       cl.stats[STAT_VIEWHEIGHT] = 8;
+               else if (playerflags & QW_PF_DEAD)
+                       cl.stats[STAT_VIEWHEIGHT] = -16;
+               else
+                       cl.stats[STAT_VIEWHEIGHT] = 22;

        }
 
        }
 

-       // set the cl_entities_active flag
-       cl_entities_active[enumber] = s->active;
+       // set the cl.entities_active flag
+       cl.entities_active[enumber] = s->active;

        // set the update time
        s->time = cl.mtime[0] - msec * 0.001; // qw has no clock
        // fix the number (it gets wiped occasionally by copying from defaultstate)
        s->number = enumber;
        // check if we need to update the lerp stuff
        if (s->active)
        // set the update time
        s->time = cl.mtime[0] - msec * 0.001; // qw has no clock
        // fix the number (it gets wiped occasionally by copying from defaultstate)
        s->number = enumber;
        // check if we need to update the lerp stuff
        if (s->active)

-               CL_MoveLerpEntityStates(&cl_entities[enumber]);
+               CL_MoveLerpEntityStates(&cl.entities[enumber]);

 }
 
 static void EntityStateQW_ReadEntityUpdate(entity_state_t *s, int bits)
 }
 
 static void EntityStateQW_ReadEntityUpdate(entity_state_t *s, int bits)


@@ -2474,43 +2528,7 @@ static void EntityStateQW_ReadEntityUpdate(entity_state_t *s, int bits)
        if (bits & QW_U_SKIN)
                s->skin = MSG_ReadByte();
        if (bits & QW_U_EFFECTS)
        if (bits & QW_U_SKIN)
                s->skin = MSG_ReadByte();
        if (bits & QW_U_EFFECTS)

-       {
-               s->effects = 0;
-               qweffects = MSG_ReadByte();
-               if (qweffects & QW_EF_BRIGHTFIELD)
-                       s->effects |= EF_BRIGHTFIELD;
-               if (qweffects & QW_EF_MUZZLEFLASH)
-                       s->effects |= EF_MUZZLEFLASH;
-               if (qweffects & QW_EF_FLAG1)
-               {
-                       // mimic FTEQW's interpretation of EF_FLAG1 as EF_NODRAW on non-player entities
-                       if (s->number > cl.maxclients)
-                               s->effects |= EF_NODRAW;
-                       else
-                               s->effects |= EF_FLAG1QW;
-               }
-               if (qweffects & QW_EF_FLAG2)
-               {
-                       // mimic FTEQW's interpretation of EF_FLAG2 as EF_ADDITIVE on non-player entities
-                       if (s->number > cl.maxclients)
-                               s->effects |= EF_ADDITIVE;
-                       else
-                               s->effects |= EF_FLAG2QW;
-               }
-               if (qweffects & QW_EF_RED)
-               {
-                       if (qweffects & QW_EF_BLUE)
-                               s->effects |= EF_RED | EF_BLUE;
-                       else
-                               s->effects |= EF_RED;
-               }
-               else if (qweffects & QW_EF_BLUE)
-                       s->effects |= EF_BLUE;
-               else if (qweffects & QW_EF_BRIGHTLIGHT)
-                       s->effects |= EF_BRIGHTLIGHT;
-               else if (qweffects & QW_EF_DIMLIGHT)
-                       s->effects |= EF_DIMLIGHT;
-       }
+               s->effects = QW_TranslateEffects(qweffects = MSG_ReadByte(), s->number);

        if (bits & QW_U_ORIGIN1)
                s->origin[0] = MSG_ReadCoord13i();
        if (bits & QW_U_ANGLE1)
        if (bits & QW_U_ORIGIN1)
                s->origin[0] = MSG_ReadCoord13i();
        if (bits & QW_U_ANGLE1)


@@ -2538,57 +2556,76 @@ static void EntityStateQW_ReadEntityUpdate(entity_state_t *s, int bits)
                if (bits & QW_U_EFFECTS)
                        Con_Printf(" U_EFFECTS %i", qweffects);
                if (bits & QW_U_ORIGIN1)
                if (bits & QW_U_EFFECTS)
                        Con_Printf(" U_EFFECTS %i", qweffects);
                if (bits & QW_U_ORIGIN1)

-                       Con_Printf(" U_ORIGIN1 %i", s->origin[0]);
+                       Con_Printf(" U_ORIGIN1 %f", s->origin[0]);

                if (bits & QW_U_ANGLE1)
                if (bits & QW_U_ANGLE1)

-                       Con_Printf(" U_ANGLE1 %i", s->angles[0]);
+                       Con_Printf(" U_ANGLE1 %f", s->angles[0]);

                if (bits & QW_U_ORIGIN2)
                if (bits & QW_U_ORIGIN2)

-                       Con_Printf(" U_ORIGIN2 %i", s->origin[1]);
+                       Con_Printf(" U_ORIGIN2 %f", s->origin[1]);

                if (bits & QW_U_ANGLE2)
                if (bits & QW_U_ANGLE2)

-                       Con_Printf(" U_ANGLE2 %i", s->angles[1]);
+                       Con_Printf(" U_ANGLE2 %f", s->angles[1]);

                if (bits & QW_U_ORIGIN3)
                if (bits & QW_U_ORIGIN3)

-                       Con_Printf(" U_ORIGIN3 %i", s->origin[2]);
+                       Con_Printf(" U_ORIGIN3 %f", s->origin[2]);

                if (bits & QW_U_ANGLE3)
                if (bits & QW_U_ANGLE3)

-                       Con_Printf(" U_ANGLE3 %i", s->angles[2]);
+                       Con_Printf(" U_ANGLE3 %f", s->angles[2]);

                if (bits & QW_U_SOLID)
                        Con_Printf(" U_SOLID");
                Con_Print("\n");
        }
 }
 
                if (bits & QW_U_SOLID)
                        Con_Printf(" U_SOLID");
                Con_Print("\n");
        }
 }
 

+entityframeqw_database_t *EntityFrameQW_AllocDatabase(mempool_t *pool)
+{
+       entityframeqw_database_t *d;
+       d = (entityframeqw_database_t *)Mem_Alloc(pool, sizeof(*d));
+       return d;
+}
+
+void EntityFrameQW_FreeDatabase(entityframeqw_database_t *d)
+{
+       Mem_Free(d);
+}
+

 void EntityFrameQW_CL_ReadFrame(qboolean delta)
 {
        qboolean invalid = false;
 void EntityFrameQW_CL_ReadFrame(qboolean delta)
 {
        qboolean invalid = false;

-       int i, number, oldsnapindex, newsnapindex, oldindex, newindex, oldnum, newnum;
+       int number, oldsnapindex, newsnapindex, oldindex, newindex, oldnum, newnum;

        entity_t *ent;
        entity_t *ent;

-       entityframeqw_database_t *d = cl.entitydatabaseqw;
+       entityframeqw_database_t *d;

        entityframeqw_snapshot_t *oldsnap, *newsnap;
 
        entityframeqw_snapshot_t *oldsnap, *newsnap;
 

+       if (!cl.entitydatabaseqw)
+               cl.entitydatabaseqw = EntityFrameQW_AllocDatabase(cls.levelmempool);
+       d = cl.entitydatabaseqw;
+

        newsnapindex = cls.netcon->qw.incoming_sequence & QW_UPDATE_MASK;
        newsnap = d->snapshot + newsnapindex;
        memset(newsnap, 0, sizeof(*newsnap));
        newsnapindex = cls.netcon->qw.incoming_sequence & QW_UPDATE_MASK;
        newsnap = d->snapshot + newsnapindex;
        memset(newsnap, 0, sizeof(*newsnap));

+       oldsnapindex = -1;
+       oldsnap = NULL;

        if (delta)
        {
        if (delta)
        {

-               oldsnapindex = MSG_ReadByte() & QW_UPDATE_MASK;
-               oldsnap = d->snapshot + oldsnapindex;
-               if (cls.netcon->qw.outgoing_sequence - oldsnapindex >= QW_UPDATE_BACKUP-1)
+               number = MSG_ReadByte();
+               oldsnapindex = cl.qw_deltasequence[newsnapindex];
+               if ((number & QW_UPDATE_MASK) != (oldsnapindex & QW_UPDATE_MASK))
+                       Con_DPrintf("WARNING: from mismatch\n");
+               if (oldsnapindex != -1)

                {
                {

-                       Con_DPrintf("delta update too old\n");
-                       newsnap->invalid = invalid = true; // too old
-                       delta = false;
+                       if (cls.netcon->qw.outgoing_sequence - oldsnapindex >= QW_UPDATE_BACKUP-1)
+                       {
+                               Con_DPrintf("delta update too old\n");
+                               newsnap->invalid = invalid = true; // too old
+                               delta = false;
+                       }
+                       oldsnap = d->snapshot + (oldsnapindex & QW_UPDATE_MASK);

                }
                }

-       }
-       else
-       {
-               oldsnapindex = -1;
-               oldsnap = NULL;
+               else
+                       delta = false;

        }
 
        // read the number of this frame to echo back in next input packet
        }
 
        // read the number of this frame to echo back in next input packet

-       for (i = 0;i < LATESTFRAMENUMS-1;i++)
-               cl.latestframenums[i] = cl.latestframenums[i+1];
-       cl.latestframenums[LATESTFRAMENUMS-1] = cls.netcon->qw.incoming_sequence;
+       cl.qw_validsequence = cls.netcon->qw.incoming_sequence;

        if (invalid)
        if (invalid)

-               cl.latestframenums[LATESTFRAMENUMS-1] = 0;
+               cl.qw_validsequence = 0;

 
        // read entity numbers until we find a 0x0000
        // (which would be an empty update on world entity, but is actually a terminator)
 
        // read entity numbers until we find a 0x0000
        // (which would be an empty update on world entity, but is actually a terminator)


@@ -2632,7 +2669,7 @@ void EntityFrameQW_CL_ReadFrame(qboolean delta)
                {
                        if (newnum != oldnum && !delta && !invalid)
                        {
                {
                        if (newnum != oldnum && !delta && !invalid)
                        {

-                               cl.latestframenums[LATESTFRAMENUMS-1] = 0;
+                               cl.qw_validsequence = 0;

                                Con_Printf("WARNING: U_REMOVE %i on full update\n", newnum);
                        }
                }
                                Con_Printf("WARNING: U_REMOVE %i on full update\n", newnum);
                        }
                }


@@ -2640,44 +2677,48 @@ void EntityFrameQW_CL_ReadFrame(qboolean delta)
                {
                        if (newsnap->num_entities >= QW_MAX_PACKET_ENTITIES)
                                Host_Error("EntityFrameQW_CL_ReadFrame: newsnap->num_entities == MAX_PACKETENTITIES");
                {
                        if (newsnap->num_entities >= QW_MAX_PACKET_ENTITIES)
                                Host_Error("EntityFrameQW_CL_ReadFrame: newsnap->num_entities == MAX_PACKETENTITIES");

-                       newsnap->entities[newsnap->num_entities] = (newnum == oldnum) ? oldsnap->entities[oldindex++] : cl_entities[newnum].state_baseline;
+                       newsnap->entities[newsnap->num_entities] = (newnum == oldnum) ? oldsnap->entities[oldindex] : cl.entities[newnum].state_baseline;

                        EntityStateQW_ReadEntityUpdate(newsnap->entities + newsnap->num_entities, word);
                        newsnap->num_entities++;
                }
                        EntityStateQW_ReadEntityUpdate(newsnap->entities + newsnap->num_entities, word);
                        newsnap->num_entities++;
                }

+
+               if (newnum == oldnum)
+                       oldindex++;

        }
 
        }
 

-       // expand cl_num_entities to include every entity we've seen this game
+       // expand cl.num_entities to include every entity we've seen this game

        newnum = newsnap->num_entities ? newsnap->entities[newsnap->num_entities - 1].number : 1;
        newnum = newsnap->num_entities ? newsnap->entities[newsnap->num_entities - 1].number : 1;

-       if (cl_num_entities <= newnum)
+       if (cl.num_entities <= newnum)

        {
        {

-               cl_num_entities = newnum + 1;
-               if (cl_max_entities < newnum + 1)
+               cl.num_entities = newnum + 1;
+               if (cl.max_entities < newnum + 1)

                        CL_ExpandEntities(newnum);
        }
 
                        CL_ExpandEntities(newnum);
        }
 

-       // now update the entities from the snapshot states
-       number = 1;
+       // now update the non-player entities from the snapshot states
+       number = cl.maxclients + 1;

        for (newindex = 0;;newindex++)
        {
        for (newindex = 0;;newindex++)
        {

-               newnum = newindex >= newsnap->num_entities ? cl_num_entities : newsnap->entities[newindex].number;
+               newnum = newindex >= newsnap->num_entities ? cl.num_entities : newsnap->entities[newindex].number;

                // kill any missing entities
                for (;number < newnum;number++)
                {
                // kill any missing entities
                for (;number < newnum;number++)
                {

-                       if (cl_entities_active[number])
+                       if (cl.entities_active[number])

                        {
                        {

-                               cl_entities_active[number] = false;
-                               cl_entities[number].state_current.active = false;
+                               cl.entities_active[number] = false;
+                               cl.entities[number].state_current.active = false;

                        }
                }
                        }
                }

-               if (number >= cl_num_entities)
+               if (number >= cl.num_entities)

                        break;
                // update the entity
                        break;
                // update the entity

-               ent = &cl_entities[number];
+               ent = &cl.entities[number];

                ent->state_previous = ent->state_current;
                ent->state_current = newsnap->entities[newindex];
                ent->state_previous = ent->state_current;
                ent->state_current = newsnap->entities[newindex];

+               ent->state_current.time = cl.mtime[0];

                CL_MoveLerpEntityStates(ent);
                // the entity lives again...
                CL_MoveLerpEntityStates(ent);
                // the entity lives again...

-               cl_entities_active[number] = true;
+               cl.entities_active[number] = true;

                number++;
        }
 }
                number++;
        }
 }