sv_ents5.c

Go to the documentation of this file.

#include "quakedef.h"
#include "protocol.h"
 
static double anim_reducetime(double t, double frameduration, double maxtime)
{
    if(t < 0) // clamp to non-negative
        return 0;
    if(t <= maxtime) // time can be represented normally
        return t;
    if(frameduration == 0) // don't like dividing by zero
        return t;
    if(maxtime <= 2 * frameduration) // if two frames don't fit, we better not do this
        return t;
    t -= frameduration * ceil((t - maxtime) / frameduration);
    // now maxtime - frameduration < t <= maxtime
    return t;
}
 
// see VM_SV_frameduration
static double anim_frameduration(model_t *model, int framenum)
{
    if (!model || !model->animscenes || framenum < 0 || framenum >= model->numframes)
        return 0;
    if(model->animscenes[framenum].framerate)
        return model->animscenes[framenum].framecount / model->animscenes[framenum].framerate;
    return 0;
}
 
void EntityFrame5_FreeDatabase(entityframe5_database_t *d)
{
    // all the [maxedicts] memory is allocated at once, so there's only one
    // thing to free
    if (d->maxedicts)
        Mem_Free(d->deltabits);
    Mem_Free(d);
}
 
static void EntityFrame5_ExpandEdicts(entityframe5_database_t *d, int newmax)
{
    if (d->maxedicts < newmax)
    {
        unsigned char *data;
        int oldmaxedicts = d->maxedicts;
        int *olddeltabits = d->deltabits;
        unsigned char *oldpriorities = d->priorities;
        int *oldupdateframenum = d->updateframenum;
        entity_state_t *oldstates = d->states;
        unsigned char *oldvisiblebits = d->visiblebits;
        d->maxedicts = newmax;
        data = (unsigned char *)Mem_Alloc(sv_mempool, d->maxedicts * sizeof(int) + d->maxedicts * sizeof(unsigned char) + d->maxedicts * sizeof(int) + d->maxedicts * sizeof(entity_state_t) + (d->maxedicts+7)/8 * sizeof(unsigned char));
        d->deltabits = (int *)data;data += d->maxedicts * sizeof(int);
        d->priorities = (unsigned char *)data;data += d->maxedicts * sizeof(unsigned char);
        d->updateframenum = (int *)data;data += d->maxedicts * sizeof(int);
        d->states = (entity_state_t *)data;data += d->maxedicts * sizeof(entity_state_t);
        d->visiblebits = (unsigned char *)data;data += (d->maxedicts+7)/8 * sizeof(unsigned char);
        if (oldmaxedicts)
        {
            memcpy(d->deltabits, olddeltabits, oldmaxedicts * sizeof(int));
            memcpy(d->priorities, oldpriorities, oldmaxedicts * sizeof(unsigned char));
            memcpy(d->updateframenum, oldupdateframenum, oldmaxedicts * sizeof(int));
            memcpy(d->states, oldstates, oldmaxedicts * sizeof(entity_state_t));
            memcpy(d->visiblebits, oldvisiblebits, (oldmaxedicts+7)/8 * sizeof(unsigned char));
            // the previous buffers were a single allocation, so just one free
            Mem_Free(olddeltabits);
        }
    }
}
 
static int EntityState5_Priority(entityframe5_database_t *d, int stateindex)
{
    int limit, priority;
    entity_state_t *s = NULL; // hush compiler warning by initializing this
    // if it is the player, update urgently
    if (stateindex == d->viewentnum)
        return ENTITYFRAME5_PRIORITYLEVELS - 1;
    // priority increases each frame no matter what happens
    priority = d->priorities[stateindex] + 1;
    // players get an extra priority boost
    if (stateindex <= svs.maxclients)
        priority++;
    // remove dead entities very quickly because they are just 2 bytes
    if (d->states[stateindex].active != ACTIVE_NETWORK)
    {
        priority++;
        return bound(1, priority, ENTITYFRAME5_PRIORITYLEVELS - 1);
    }
    // certain changes are more noticable than others
    if (d->deltabits[stateindex] & (E5_FULLUPDATE | E5_ATTACHMENT | E5_MODEL | E5_FLAGS | E5_COLORMAP))
        priority++;
    // find the root entity this one is attached to, and judge relevance by it
    for (limit = 0;limit < 256;limit++)
    {
        s = d->states + stateindex;
        if (s->flags & RENDER_VIEWMODEL)
            stateindex = d->viewentnum;
        else if (s->tagentity)
            stateindex = s->tagentity;
        else
            break;
        if (d->maxedicts < stateindex)
            EntityFrame5_ExpandEdicts(d, (stateindex+256)&~255);
    }
    if (limit >= 256)
        Con_DPrintf("Protocol: Runaway loop recursing tagentity links on entity %i\n", stateindex);
    // now that we have the parent entity we can make some decisions based on
    // distance from the player
    if (VectorDistance(d->states[d->viewentnum].netcenter, s->netcenter) < 1024.0f)
        priority++;
    return bound(1, priority, ENTITYFRAME5_PRIORITYLEVELS - 1);
}
 
static int EntityState5_DeltaBits(const entity_state_t *o, const entity_state_t *n)
{
    unsigned int bits = 0;
    if (n->active == ACTIVE_NETWORK)
    {
        if (o->active != ACTIVE_NETWORK)
            bits |= E5_FULLUPDATE;
        if (!VectorCompare(o->origin, n->origin))
            bits |= E5_ORIGIN;
        if (!VectorCompare(o->angles, n->angles))
            bits |= E5_ANGLES;
        if (o->modelindex != n->modelindex)
            bits |= E5_MODEL;
        if (o->frame != n->frame)
            bits |= E5_FRAME;
        if (o->skin != n->skin)
            bits |= E5_SKIN;
        if (o->effects != n->effects)
            bits |= E5_EFFECTS;
        if (o->flags != n->flags)
            bits |= E5_FLAGS;
        if (o->alpha != n->alpha)
            bits |= E5_ALPHA;
        if (o->scale != n->scale)
            bits |= E5_SCALE;
        if (o->colormap != n->colormap)
            bits |= E5_COLORMAP;
        if (o->tagentity != n->tagentity || o->tagindex != n->tagindex)
            bits |= E5_ATTACHMENT;
        if (o->light[0] != n->light[0] || o->light[1] != n->light[1] || o->light[2] != n->light[2] || o->light[3] != n->light[3] || o->lightstyle != n->lightstyle || o->lightpflags != n->lightpflags)
            bits |= E5_LIGHT;
        if (o->glowsize != n->glowsize || o->glowcolor != n->glowcolor)
            bits |= E5_GLOW;
        if (o->colormod[0] != n->colormod[0] || o->colormod[1] != n->colormod[1] || o->colormod[2] != n->colormod[2])
            bits |= E5_COLORMOD;
        if (o->glowmod[0] != n->glowmod[0] || o->glowmod[1] != n->glowmod[1] || o->glowmod[2] != n->glowmod[2])
            bits |= E5_GLOWMOD;
        if (n->flags & RENDER_COMPLEXANIMATION)
        {
            if ((o->skeletonobject.model && o->skeletonobject.relativetransforms) != (n->skeletonobject.model && n->skeletonobject.relativetransforms))
            {
                bits |= E5_COMPLEXANIMATION;
            }
            else if (o->skeletonobject.model && o->skeletonobject.relativetransforms)
            {
                if(o->modelindex != n->modelindex)
                    bits |= E5_COMPLEXANIMATION;
                else if(o->skeletonobject.model->num_bones != n->skeletonobject.model->num_bones)
                    bits |= E5_COMPLEXANIMATION;
                else if(memcmp(o->skeletonobject.relativetransforms, n->skeletonobject.relativetransforms, o->skeletonobject.model->num_bones * sizeof(*o->skeletonobject.relativetransforms)))
                    bits |= E5_COMPLEXANIMATION;
            }
            else if (memcmp(o->framegroupblend, n->framegroupblend, sizeof(o->framegroupblend)))
            {
                bits |= E5_COMPLEXANIMATION;
            }
        }
        if (o->traileffectnum != n->traileffectnum)
            bits |= E5_TRAILEFFECTNUM;
    }
    else
        if (o->active == ACTIVE_NETWORK)
            bits |= E5_FULLUPDATE;
    return bits;
}
 
void EntityState5_WriteUpdate(int number, const entity_state_t *s, int changedbits, sizebuf_t *msg)
{
    prvm_prog_t *prog = SVVM_prog;
    unsigned int bits = 0;
    //model_t *model;
 
    if (s->active != ACTIVE_NETWORK)
    {
        ENTITYSIZEPROFILING_START(msg, s->number, 0);
        MSG_WriteShort(msg, number | 0x8000);
        ENTITYSIZEPROFILING_END(msg, s->number, 0);
    }
    else
    {
        if (PRVM_serveredictfunction((&prog->edicts[s->number]), SendEntity))
            return;
 
        bits = changedbits;
        if ((bits & E5_ORIGIN) && (!(s->flags & RENDER_LOWPRECISION) || s->exteriormodelforclient || s->tagentity || s->viewmodelforclient || (s->number >= 1 && s->number <= svs.maxclients) || s->origin[0] <= -4096.0625 || s->origin[0] >= 4095.9375 || s->origin[1] <= -4096.0625 || s->origin[1] >= 4095.9375 || s->origin[2] <= -4096.0625 || s->origin[2] >= 4095.9375))
        // maybe also add: ((model = SV_GetModelByIndex(s->modelindex)) != NULL && model->name[0] == '*')
            bits |= E5_ORIGIN32;
            // possible values:
            //   negative origin:
            //     (int)(f * 8 - 0.5) >= -32768
            //          (f * 8 - 0.5) >  -32769
            //           f            >  -4096.0625
            //   positive origin:
            //     (int)(f * 8 + 0.5) <=  32767
            //          (f * 8 + 0.5) <   32768
            //           f * 8 + 0.5) <   4095.9375
        if ((bits & E5_ANGLES) && !(s->flags & RENDER_LOWPRECISION))
            bits |= E5_ANGLES16;
        if ((bits & E5_MODEL) && s->modelindex >= 256)
            bits |= E5_MODEL16;
        if ((bits & E5_FRAME) && s->frame >= 256)
            bits |= E5_FRAME16;
        if (bits & E5_EFFECTS)
        {
            if (s->effects & 0xFFFF0000)
                bits |= E5_EFFECTS32;
            else if (s->effects & 0xFFFFFF00)
                bits |= E5_EFFECTS16;
        }
        if (bits >= 256)
            bits |= E5_EXTEND1;
        if (bits >= 65536)
            bits |= E5_EXTEND2;
        if (bits >= 16777216)
            bits |= E5_EXTEND3;
        {
            ENTITYSIZEPROFILING_START(msg, s->number, bits);
            MSG_WriteShort(msg, number);
            MSG_WriteByte(msg, bits & 0xFF);
            if (bits & E5_EXTEND1)
                MSG_WriteByte(msg, (bits >> 8) & 0xFF);
            if (bits & E5_EXTEND2)
                MSG_WriteByte(msg, (bits >> 16) & 0xFF);
            if (bits & E5_EXTEND3)
                MSG_WriteByte(msg, (bits >> 24) & 0xFF);
            if (bits & E5_FLAGS)
                MSG_WriteByte(msg, s->flags);
            if (bits & E5_ORIGIN)
            {
                if (bits & E5_ORIGIN32)
                {
                    MSG_WriteCoord32f(msg, s->origin[0]);
                    MSG_WriteCoord32f(msg, s->origin[1]);
                    MSG_WriteCoord32f(msg, s->origin[2]);
                }
                else
                {
                    MSG_WriteCoord13i(msg, s->origin[0]);
                    MSG_WriteCoord13i(msg, s->origin[1]);
                    MSG_WriteCoord13i(msg, s->origin[2]);
                }
            }
            if (bits & E5_ANGLES)
            {
                if (bits & E5_ANGLES16)
                {
                    MSG_WriteAngle16i(msg, s->angles[0]);
                    MSG_WriteAngle16i(msg, s->angles[1]);
                    MSG_WriteAngle16i(msg, s->angles[2]);
                }
                else
                {
                    MSG_WriteAngle8i(msg, s->angles[0]);
                    MSG_WriteAngle8i(msg, s->angles[1]);
                    MSG_WriteAngle8i(msg, s->angles[2]);
                }
            }
            if (bits & E5_MODEL)
            {
                if (bits & E5_MODEL16)
                    MSG_WriteShort(msg, s->modelindex);
                else
                    MSG_WriteByte(msg, s->modelindex);
            }
            if (bits & E5_FRAME)
            {
                if (bits & E5_FRAME16)
                    MSG_WriteShort(msg, s->frame);
                else
                    MSG_WriteByte(msg, s->frame);
            }
            if (bits & E5_SKIN)
                MSG_WriteByte(msg, s->skin);
            if (bits & E5_EFFECTS)
            {
                if (bits & E5_EFFECTS32)
                    MSG_WriteLong(msg, s->effects);
                else if (bits & E5_EFFECTS16)
                    MSG_WriteShort(msg, s->effects);
                else
                    MSG_WriteByte(msg, s->effects);
            }
            if (bits & E5_ALPHA)
                MSG_WriteByte(msg, s->alpha);
            if (bits & E5_SCALE)
                MSG_WriteByte(msg, s->scale);
            if (bits & E5_COLORMAP)
                MSG_WriteByte(msg, s->colormap);
            if (bits & E5_ATTACHMENT)
            {
                MSG_WriteShort(msg, s->tagentity);
                MSG_WriteByte(msg, s->tagindex);
            }
            if (bits & E5_LIGHT)
            {
                MSG_WriteShort(msg, s->light[0]);
                MSG_WriteShort(msg, s->light[1]);
                MSG_WriteShort(msg, s->light[2]);
                MSG_WriteShort(msg, s->light[3]);
                MSG_WriteByte(msg, s->lightstyle);
                MSG_WriteByte(msg, s->lightpflags);
            }
            if (bits & E5_GLOW)
            {
                MSG_WriteByte(msg, s->glowsize);
                MSG_WriteByte(msg, s->glowcolor);
            }
            if (bits & E5_COLORMOD)
            {
                MSG_WriteByte(msg, s->colormod[0]);
                MSG_WriteByte(msg, s->colormod[1]);
                MSG_WriteByte(msg, s->colormod[2]);
            }
            if (bits & E5_GLOWMOD)
            {
                MSG_WriteByte(msg, s->glowmod[0]);
                MSG_WriteByte(msg, s->glowmod[1]);
                MSG_WriteByte(msg, s->glowmod[2]);
            }
            if (bits & E5_COMPLEXANIMATION)
            {
                if (s->skeletonobject.model && s->skeletonobject.relativetransforms)
                {
                    int numbones = s->skeletonobject.model->num_bones;
                    int bonenum;
                    short pose7s[7];
                    MSG_WriteByte(msg, 4);
                    MSG_WriteShort(msg, s->modelindex);
                    MSG_WriteByte(msg, numbones);
                    for (bonenum = 0;bonenum < numbones;bonenum++)
                    {
                        Matrix4x4_ToBonePose7s(s->skeletonobject.relativetransforms + bonenum, 64, pose7s);
                        MSG_WriteShort(msg, pose7s[0]);
                        MSG_WriteShort(msg, pose7s[1]);
                        MSG_WriteShort(msg, pose7s[2]);
                        MSG_WriteShort(msg, pose7s[3]);
                        MSG_WriteShort(msg, pose7s[4]);
                        MSG_WriteShort(msg, pose7s[5]);
                        MSG_WriteShort(msg, pose7s[6]);
                    }
                }
                else
                {
                    model_t *model = SV_GetModelByIndex(s->modelindex);
                    if (s->framegroupblend[3].lerp > 0)
                    {
                        MSG_WriteByte(msg, 3);
                        MSG_WriteShort(msg, s->framegroupblend[0].frame);
                        MSG_WriteShort(msg, s->framegroupblend[1].frame);
                        MSG_WriteShort(msg, s->framegroupblend[2].frame);
                        MSG_WriteShort(msg, s->framegroupblend[3].frame);
                        MSG_WriteShort(msg, (int)(anim_reducetime(sv.time - s->framegroupblend[0].start, anim_frameduration(model, s->framegroupblend[0].frame), 65.535) * 1000.0));
                        MSG_WriteShort(msg, (int)(anim_reducetime(sv.time - s->framegroupblend[1].start, anim_frameduration(model, s->framegroupblend[1].frame), 65.535) * 1000.0));
                        MSG_WriteShort(msg, (int)(anim_reducetime(sv.time - s->framegroupblend[2].start, anim_frameduration(model, s->framegroupblend[2].frame), 65.535) * 1000.0));
                        MSG_WriteShort(msg, (int)(anim_reducetime(sv.time - s->framegroupblend[3].start, anim_frameduration(model, s->framegroupblend[3].frame), 65.535) * 1000.0));
                        MSG_WriteByte(msg, s->framegroupblend[0].lerp * 255.0f);
                        MSG_WriteByte(msg, s->framegroupblend[1].lerp * 255.0f);
                        MSG_WriteByte(msg, s->framegroupblend[2].lerp * 255.0f);
                        MSG_WriteByte(msg, s->framegroupblend[3].lerp * 255.0f);
                    }
                    else if (s->framegroupblend[2].lerp > 0)
                    {
                        MSG_WriteByte(msg, 2);
                        MSG_WriteShort(msg, s->framegroupblend[0].frame);
                        MSG_WriteShort(msg, s->framegroupblend[1].frame);
                        MSG_WriteShort(msg, s->framegroupblend[2].frame);
                        MSG_WriteShort(msg, (int)(anim_reducetime(sv.time - s->framegroupblend[0].start, anim_frameduration(model, s->framegroupblend[0].frame), 65.535) * 1000.0));
                        MSG_WriteShort(msg, (int)(anim_reducetime(sv.time - s->framegroupblend[1].start, anim_frameduration(model, s->framegroupblend[1].frame), 65.535) * 1000.0));
                        MSG_WriteShort(msg, (int)(anim_reducetime(sv.time - s->framegroupblend[2].start, anim_frameduration(model, s->framegroupblend[2].frame), 65.535) * 1000.0));
                        MSG_WriteByte(msg, s->framegroupblend[0].lerp * 255.0f);
                        MSG_WriteByte(msg, s->framegroupblend[1].lerp * 255.0f);
                        MSG_WriteByte(msg, s->framegroupblend[2].lerp * 255.0f);
                    }
                    else if (s->framegroupblend[1].lerp > 0)
                    {
                        MSG_WriteByte(msg, 1);
                        MSG_WriteShort(msg, s->framegroupblend[0].frame);
                        MSG_WriteShort(msg, s->framegroupblend[1].frame);
                        MSG_WriteShort(msg, (int)(anim_reducetime(sv.time - s->framegroupblend[0].start, anim_frameduration(model, s->framegroupblend[0].frame), 65.535) * 1000.0));
                        MSG_WriteShort(msg, (int)(anim_reducetime(sv.time - s->framegroupblend[1].start, anim_frameduration(model, s->framegroupblend[1].frame), 65.535) * 1000.0));
                        MSG_WriteByte(msg, s->framegroupblend[0].lerp * 255.0f);
                        MSG_WriteByte(msg, s->framegroupblend[1].lerp * 255.0f);
                    }
                    else
                    {
                        MSG_WriteByte(msg, 0);
                        MSG_WriteShort(msg, s->framegroupblend[0].frame);
                        MSG_WriteShort(msg, (int)(anim_reducetime(sv.time - s->framegroupblend[0].start, anim_frameduration(model, s->framegroupblend[0].frame), 65.535) * 1000.0));
                    }
                }
            }
            if (bits & E5_TRAILEFFECTNUM)
                MSG_WriteShort(msg, s->traileffectnum);
            ENTITYSIZEPROFILING_END(msg, s->number, bits);
        }
    }
}
 
qbool EntityFrame5_WriteFrame(sizebuf_t *msg, int maxsize, entityframe5_database_t *d, int numstates, const entity_state_t **states, int viewentnum, unsigned int movesequence, qbool need_empty)
{
    prvm_prog_t *prog = SVVM_prog;
    const entity_state_t *n;
    int i, num, l, framenum, packetlognumber, priority;
    sizebuf_t buf;
    unsigned char data[128];
    entityframe5_packetlog_t *packetlog;
 
    if (prog->max_edicts > d->maxedicts)
        EntityFrame5_ExpandEdicts(d, prog->max_edicts);
 
    framenum = d->latestframenum + 1;
    d->viewentnum = viewentnum;
 
    // if packet log is full, mark all frames as lost, this will cause
    // it to send the lost data again
    for (packetlognumber = 0;packetlognumber < ENTITYFRAME5_MAXPACKETLOGS;packetlognumber++)
        if (d->packetlog[packetlognumber].packetnumber == 0)
            break;
    if (packetlognumber == ENTITYFRAME5_MAXPACKETLOGS)
    {
        Con_DPrintf("EntityFrame5_WriteFrame: packetlog overflow for a client, resetting\n");
        EntityFrame5_LostFrame(d, framenum);
        packetlognumber = 0;
    }
 
    // prepare the buffer
    memset(&buf, 0, sizeof(buf));
    buf.data = data;
    buf.maxsize = sizeof(data);
 
    // detect changes in states
    num = 1;
    for (i = 0;i < numstates;i++)
    {
        n = states[i];
        // mark gaps in entity numbering as removed entities
        for (;num < n->number;num++)
        {
            // if the entity used to exist, clear it
            if (CHECKPVSBIT(d->visiblebits, num))
            {
                CLEARPVSBIT(d->visiblebits, num);
                d->deltabits[num] = E5_FULLUPDATE;
                d->priorities[num] = max(d->priorities[num], 8); // removal is cheap
                d->states[num] = defaultstate;
                d->states[num].number = num;
            }
        }
        // update the entity state data
        if (!CHECKPVSBIT(d->visiblebits, num))
        {
            // entity just spawned in, don't let it completely hog priority
            // because of being ancient on the first frame
            d->updateframenum[num] = framenum;
            // initial priority is a bit high to make projectiles send on the
            // first frame, among other things
            d->priorities[num] = max(d->priorities[num], 4);
        }
        SETPVSBIT(d->visiblebits, num);
        d->deltabits[num] |= EntityState5_DeltaBits(d->states + num, n);
        d->priorities[num] = max(d->priorities[num], 1);
        d->states[num] = *n;
        d->states[num].number = num;
        // advance to next entity so the next iteration doesn't immediately remove it
        num++;
    }
    // all remaining entities are dead
    for (;num < d->maxedicts;num++)
    {
        if (CHECKPVSBIT(d->visiblebits, num))
        {
            CLEARPVSBIT(d->visiblebits, num);
            d->deltabits[num] = E5_FULLUPDATE;
            d->priorities[num] = max(d->priorities[num], 8); // removal is cheap
            d->states[num] = defaultstate;
            d->states[num].number = num;
        }
    }
 
    // if there isn't at least enough room for an empty svc_entities,
    // don't bother trying...
    if (buf.cursize + 11 > buf.maxsize)
        return false;
 
    // build lists of entities by priority level
    memset(d->prioritychaincounts, 0, sizeof(d->prioritychaincounts));
    l = 0;
    for (num = 0;num < d->maxedicts;num++)
    {
        if (d->priorities[num])
        {
            if (d->deltabits[num])
            {
                if (d->priorities[num] < (ENTITYFRAME5_PRIORITYLEVELS - 1))
                    d->priorities[num] = EntityState5_Priority(d, num);
                l = num;
                priority = d->priorities[num];
                if (d->prioritychaincounts[priority] < ENTITYFRAME5_MAXSTATES)
                    d->prioritychains[priority][d->prioritychaincounts[priority]++] = num;
            }
            else
                d->priorities[num] = 0;
        }
    }
 
    packetlog = NULL;
    // write stat updates
    if (sv.protocol != PROTOCOL_QUAKE && sv.protocol != PROTOCOL_QUAKEDP && sv.protocol != PROTOCOL_NEHAHRAMOVIE && sv.protocol != PROTOCOL_NEHAHRABJP && sv.protocol != PROTOCOL_NEHAHRABJP2 && sv.protocol != PROTOCOL_NEHAHRABJP3 && sv.protocol != PROTOCOL_DARKPLACES1 && sv.protocol != PROTOCOL_DARKPLACES2 && sv.protocol != PROTOCOL_DARKPLACES3 && sv.protocol != PROTOCOL_DARKPLACES4 && sv.protocol != PROTOCOL_DARKPLACES5)
    {
        for (i = 0;i < MAX_CL_STATS && msg->cursize + 6 + 11 <= maxsize;i++)
        {
            if (host_client->statsdeltabits[i>>3] & (1<<(i&7)))
            {
                host_client->statsdeltabits[i>>3] &= ~(1<<(i&7));
                // add packetlog entry now that we have something for it
                if (!packetlog)
                {
                    packetlog = d->packetlog + packetlognumber;
                    packetlog->packetnumber = framenum;
                    packetlog->numstates = 0;
                    memset(packetlog->statsdeltabits, 0, sizeof(packetlog->statsdeltabits));
                }
                packetlog->statsdeltabits[i>>3] |= (1<<(i&7));
                if (host_client->stats[i] >= 0 && host_client->stats[i] < 256)
                {
                    MSG_WriteByte(msg, svc_updatestatubyte);
                    MSG_WriteByte(msg, i);
                    MSG_WriteByte(msg, host_client->stats[i]);
                    l = 1;
                }
                else
                {
                    MSG_WriteByte(msg, svc_updatestat);
                    MSG_WriteByte(msg, i);
                    MSG_WriteLong(msg, host_client->stats[i]);
                    l = 1;
                }
            }
        }
    }
 
    // only send empty svc_entities frame if needed
    if(!l && !need_empty)
        return false;
 
    // add packetlog entry now that we have something for it
    if (!packetlog)
    {
        packetlog = d->packetlog + packetlognumber;
        packetlog->packetnumber = framenum;
        packetlog->numstates = 0;
        memset(packetlog->statsdeltabits, 0, sizeof(packetlog->statsdeltabits));
    }
 
    // write state updates
    if (developer_networkentities.integer >= 10)
        Con_Printf("send: svc_entities %i\n", framenum);
    d->latestframenum = framenum;
    MSG_WriteByte(msg, svc_entities);
    MSG_WriteLong(msg, framenum);
    if (sv.protocol != PROTOCOL_QUAKE && sv.protocol != PROTOCOL_QUAKEDP && sv.protocol != PROTOCOL_NEHAHRAMOVIE && sv.protocol != PROTOCOL_DARKPLACES1 && sv.protocol != PROTOCOL_DARKPLACES2 && sv.protocol != PROTOCOL_DARKPLACES3 && sv.protocol != PROTOCOL_DARKPLACES4 && sv.protocol != PROTOCOL_DARKPLACES5 && sv.protocol != PROTOCOL_DARKPLACES6)
        MSG_WriteLong(msg, movesequence);
    for (priority = ENTITYFRAME5_PRIORITYLEVELS - 1;priority >= 0 && packetlog->numstates < ENTITYFRAME5_MAXSTATES;priority--)
    {
        for (i = 0;i < d->prioritychaincounts[priority] && packetlog->numstates < ENTITYFRAME5_MAXSTATES;i++)
        {
            num = d->prioritychains[priority][i];
            n = d->states + num;
            if (d->deltabits[num] & E5_FULLUPDATE)
                d->deltabits[num] = E5_FULLUPDATE | EntityState5_DeltaBits(&defaultstate, n);
            buf.cursize = 0;
            EntityState5_WriteUpdate(num, n, d->deltabits[num], &buf);
            // if the entity won't fit, try the next one
            if (msg->cursize + buf.cursize + 2 > maxsize)
                continue;
            // write entity to the packet
            SZ_Write(msg, buf.data, buf.cursize);
            // mark age on entity for prioritization
            d->updateframenum[num] = framenum;
            // log entity so deltabits can be restored later if lost
            packetlog->states[packetlog->numstates].number = num;
            packetlog->states[packetlog->numstates].bits = d->deltabits[num];
            packetlog->numstates++;
            // clear deltabits and priority so it won't be sent again
            d->deltabits[num] = 0;
            d->priorities[num] = 0;
        }
    }
    MSG_WriteShort(msg, 0x8000);
 
    return true;
}
 
entityframe5_database_t *EntityFrame5_AllocDatabase(mempool_t *pool)
{
    int i;
    entityframe5_database_t *d;
    d = (entityframe5_database_t *)Mem_Alloc(pool, sizeof(*d));
    d->latestframenum = 0;
    for (i = 0;i < d->maxedicts;i++)
        d->states[i] = defaultstate;
    return d;
}
 
static int packetlog5cmp(const void *a_, const void *b_)
{
    const entityframe5_packetlog_t *a = (const entityframe5_packetlog_t *) a_;
    const entityframe5_packetlog_t *b = (const entityframe5_packetlog_t *) b_;
    return a->packetnumber - b->packetnumber;
}
 
void EntityFrame5_LostFrame(entityframe5_database_t *d, int framenum)
{
    int i, j, l, bits;
    entityframe5_changestate_t *s;
    entityframe5_packetlog_t *p;
    static unsigned char statsdeltabits[(MAX_CL_STATS+7)/8];
    static int deltabits[MAX_EDICTS];
    entityframe5_packetlog_t *packetlogs[ENTITYFRAME5_MAXPACKETLOGS];
 
    for (i = 0, p = d->packetlog;i < ENTITYFRAME5_MAXPACKETLOGS;i++, p++)
        packetlogs[i] = p;
    qsort(packetlogs, sizeof(*packetlogs), ENTITYFRAME5_MAXPACKETLOGS, packetlog5cmp);
 
    memset(deltabits, 0, sizeof(deltabits));
    memset(statsdeltabits, 0, sizeof(statsdeltabits));
    for (i = 0; i < ENTITYFRAME5_MAXPACKETLOGS; i++)
    {
        p = packetlogs[i];
 
        if (!p->packetnumber)
            continue;
 
        if (p->packetnumber <= framenum)
        {
            for (j = 0, s = p->states;j < p->numstates;j++, s++)
                deltabits[s->number] |= s->bits;
 
            for (l = 0;l < (MAX_CL_STATS+7)/8;l++)
                statsdeltabits[l] |= p->statsdeltabits[l];
 
            p->packetnumber = 0;
        }
        else
        {
            for (j = 0, s = p->states;j < p->numstates;j++, s++)
                deltabits[s->number] &= ~s->bits;
            for (l = 0;l < (MAX_CL_STATS+7)/8;l++)
                statsdeltabits[l] &= ~p->statsdeltabits[l];
        }
    }
 
    for(i = 0; i < d->maxedicts; ++i)
    {
        bits = deltabits[i] & ~d->deltabits[i];
        if(bits)
        {
            d->deltabits[i] |= bits;
            // if it was a very important update, set priority higher
            if (bits & (E5_FULLUPDATE | E5_ATTACHMENT | E5_MODEL | E5_COLORMAP))
                d->priorities[i] = max(d->priorities[i], 4);
            else
                d->priorities[i] = max(d->priorities[i], 1);
        }
    }
 
    for (l = 0;l < (MAX_CL_STATS+7)/8;l++)
        host_client->statsdeltabits[l] |= statsdeltabits[l];
        // no need to mask out the already-set bits here, as we do not
        // do that priorities stuff
}
 
void EntityFrame5_AckFrame(entityframe5_database_t *d, int framenum)
{
    int i;
    // scan for packets made obsolete by this ack and delete them
    for (i = 0;i < ENTITYFRAME5_MAXPACKETLOGS;i++)
        if (d->packetlog[i].packetnumber <= framenum)
            d->packetlog[i].packetnumber = 0;
}