cl_ents.c File Reference

#include "quakedef.h"
#include "protocol.h"

Include dependency graph for cl_ents.c:

Go to the source code of this file.

Functions
void	EntityFrame_AddFrame_Client (entityframe_database_t *d, vec3_t eye, int framenum, int numentities, const entity_state_t *entitydata)
void	EntityFrame_CL_ReadFrame (void)
int	EntityFrame_MostRecentlyRecievedFrameNum (entityframe_database_t *d)
int	EntityState_ReadExtendBits (void)
void	EntityState_ReadFields (entity_state_t *e, unsigned int bits)

Function Documentation

EntityFrame_AddFrame_Client()

void EntityFrame_AddFrame_Client	(	entityframe_database_t *	d,
		vec3_t	eye,
		int	framenum,
		int	numentities,
		const entity_state_t *	entitydata )

Definition at line 168 of file cl_ents.c.

{
    int n, e;
    entity_frameinfo_t *info;
 
    VectorCopy(eye, d->eye);
 
    // figure out how many entity slots are used already
    if (d->numframes)
    {
        n = d->frames[d->numframes - 1].endentity - d->frames[0].firstentity;
        if (n + numentities > MAX_ENTITY_DATABASE || d->numframes >= MAX_ENTITY_HISTORY)
        {
            // ran out of room, dump database
            EntityFrame_ClearDatabase(d);
        }
    }
 
    info = &d->frames[d->numframes];
    info->framenum = framenum;
    e = -1000;
    // make sure we check the newly added frame as well, but we haven't incremented numframes yet
    for (n = 0;n <= d->numframes;n++)
    {
        if (e >= d->frames[n].framenum)
        {
            if (e == framenum)
                Con_Print("EntityFrame_AddFrame: tried to add out of sequence frame to database\n");
            else
                Con_Print("EntityFrame_AddFrame: out of sequence frames in database\n");
            return;
        }
        e = d->frames[n].framenum;
    }
    // if database still has frames after that...
    if (d->numframes)
        info->firstentity = d->frames[d->numframes - 1].endentity;
    else
        info->firstentity = 0;
    info->endentity = info->firstentity + numentities;
    d->numframes++;
 
    n = info->firstentity % MAX_ENTITY_DATABASE;
    e = MAX_ENTITY_DATABASE - n;
    if (e > numentities)
        e = numentities;
    memcpy(d->entitydata + n, entitydata, sizeof(entity_state_t) * e);
    if (numentities > e)
        memcpy(d->entitydata, entitydata + e, sizeof(entity_state_t) * (numentities - e));
}

References Con_Print(), entity_frameinfo_t::endentity, entityframe_database_t::entitydata, EntityFrame_ClearDatabase(), entityframe_database_t::eye, entity_frameinfo_t::firstentity, entity_frameinfo_t::framenum, entityframe_database_t::frames, MAX_ENTITY_DATABASE, MAX_ENTITY_HISTORY, n, entityframe_database_t::numframes, and VectorCopy.

Referenced by EntityFrame_CL_ReadFrame().

EntityFrame_CL_ReadFrame()

void EntityFrame_CL_ReadFrame

(

void

)

Definition at line 220 of file cl_ents.c.

{
    int i, number, removed;
    entity_frame_t *f, *delta;
    entity_state_t *e, *old, *oldend;
    entity_t *ent;
    entityframe_database_t *d;
    if (!cl.entitydatabase)
        cl.entitydatabase = EntityFrame_AllocDatabase(cls.levelmempool);
    d = cl.entitydatabase;
    f = &d->framedata;
    delta = &d->deltaframe;
 
    EntityFrame_Clear(f, NULL, -1);
 
    // read the frame header info
    f->time = cl.mtime[0];
    number = MSG_ReadLong(&cl_message);
    f->framenum = MSG_ReadLong(&cl_message);
    CL_NewFrameReceived(f->framenum);
    f->eye[0] = MSG_ReadFloat(&cl_message);
    f->eye[1] = MSG_ReadFloat(&cl_message);
    f->eye[2] = MSG_ReadFloat(&cl_message);
    EntityFrame_AckFrame(d, number);
    EntityFrame_FetchFrame(d, number, delta);
    old = delta->entitydata;
    oldend = old + delta->numentities;
    // read entities until we hit the magic 0xFFFF end tag
    while ((number = (unsigned short) MSG_ReadShort(&cl_message)) != 0xFFFF && !cl_message.badread)
    {
        if (cl_message.badread)
            Host_Error("EntityFrame_Read: read error");
        removed = number & 0x8000;
        number &= 0x7FFF;
        if (number >= MAX_EDICTS)
            Host_Error("EntityFrame_Read: number (%i) >= MAX_EDICTS (%i)", number, MAX_EDICTS);
 
        // seek to entity, while copying any skipped entities (assume unchanged)
        while (old < oldend && old->number < number)
        {
            if (f->numentities >= MAX_ENTITY_DATABASE)
                Host_Error("EntityFrame_Read: entity list too big");
            f->entitydata[f->numentities] = *old++;
            f->entitydata[f->numentities++].time = cl.mtime[0];
        }
        if (removed)
        {
            if (old < oldend && old->number == number)
                old++;
            else
                Con_Printf("EntityFrame_Read: REMOVE on unused entity %i\n", number);
        }
        else
        {
            if (f->numentities >= MAX_ENTITY_DATABASE)
                Host_Error("EntityFrame_Read: entity list too big");
 
            // reserve this slot
            e = f->entitydata + f->numentities++;
 
            if (old < oldend && old->number == number)
            {
                // delta from old entity
                *e = *old++;
            }
            else
            {
                // delta from defaults
                *e = defaultstate;
            }
 
            if (cl.num_entities <= number)
            {
                cl.num_entities = number + 1;
                if (number >= cl.max_entities)
                    CL_ExpandEntities(number);
            }
            cl.entities_active[number] = true;
            e->active = ACTIVE_NETWORK;
            e->time = cl.mtime[0];
            e->number = number;
            EntityState_ReadFields(e, EntityState_ReadExtendBits());
        }
    }
    while (old < oldend)
    {
        if (f->numentities >= MAX_ENTITY_DATABASE)
            Host_Error("EntityFrame_Read: entity list too big");
        f->entitydata[f->numentities] = *old++;
        f->entitydata[f->numentities++].time = cl.mtime[0];
    }
    EntityFrame_AddFrame_Client(d, f->eye, f->framenum, f->numentities, f->entitydata);
 
    memset(cl.entities_active, 0, cl.num_entities * sizeof(unsigned char));
    number = 1;
    for (i = 0;i < f->numentities;i++)
    {
        for (;number < f->entitydata[i].number && number < cl.num_entities;number++)
        {
            if (cl.entities_active[number])
            {
                cl.entities_active[number] = false;
                cl.entities[number].state_current.active = ACTIVE_NOT;
            }
        }
        if (number >= cl.num_entities)
            break;
        // update the entity
        ent = &cl.entities[number];
        ent->state_previous = ent->state_current;
        ent->state_current = f->entitydata[i];
        CL_MoveLerpEntityStates(ent);
        // the entity lives again...
        cl.entities_active[number] = true;
        number++;
    }
    for (;number < cl.num_entities;number++)
    {
        if (cl.entities_active[number])
        {
            cl.entities_active[number] = false;
            cl.entities[number].state_current.active = ACTIVE_NOT;
        }
    }
}

References entity_state_t::active, ACTIVE_NETWORK, ACTIVE_NOT, sizebuf_t::badread, cl, CL_ExpandEntities(), cl_message, CL_MoveLerpEntityStates(), CL_NewFrameReceived(), cls, Con_Printf(), defaultstate, entityframe_database_t::deltaframe, client_state_t::entities, client_state_t::entities_active, entity_frame_t::entitydata, client_state_t::entitydatabase, EntityFrame_AckFrame(), EntityFrame_AddFrame_Client(), EntityFrame_AllocDatabase(), EntityFrame_Clear(), EntityFrame_FetchFrame(), EntityState_ReadExtendBits(), EntityState_ReadFields(), f, entityframe_database_t::framedata, Host_Error(), i, client_static_t::levelmempool, MAX_EDICTS, client_state_t::max_entities, MAX_ENTITY_DATABASE, MSG_ReadFloat, MSG_ReadLong, MSG_ReadShort, client_state_t::mtime, NULL, client_state_t::num_entities, entity_state_t::number, entity_frame_t::numentities, entity_t::state_current, entity_t::state_previous, and entity_state_t::time.

Referenced by CL_ParseServerMessage().

EntityFrame_MostRecentlyRecievedFrameNum()

int EntityFrame_MostRecentlyRecievedFrameNum

(

entityframe_database_t *

d

)

Definition at line 348 of file cl_ents.c.

{
    if (d->numframes)
        return d->frames[d->numframes - 1].framenum;
    else
        return -1;
}

References entity_frameinfo_t::framenum, entityframe_database_t::frames, and entityframe_database_t::numframes.

EntityState_ReadExtendBits()

int EntityState_ReadExtendBits

(

void

)

Definition at line 4 of file cl_ents.c.

{
    unsigned int bits;
    bits = MSG_ReadByte(&cl_message);
    if (bits & 0x00000080)
    {
        bits |= MSG_ReadByte(&cl_message) << 8;
        if (bits & 0x00008000)
        {
            bits |= MSG_ReadByte(&cl_message) << 16;
            if (bits & 0x00800000)
                bits |= MSG_ReadByte(&cl_message) << 24;
        }
    }
    return bits;
}

References cl_message, and MSG_ReadByte.

Referenced by EntityFrame4_CL_ReadFrame(), and EntityFrame_CL_ReadFrame().

EntityState_ReadFields()

void EntityState_ReadFields	(	entity_state_t *	e,
		unsigned int	bits )

Definition at line 21 of file cl_ents.c.

{
    if (cls.protocol == PROTOCOL_DARKPLACES2)
    {
        if (bits & E_ORIGIN1)
            e->origin[0] = MSG_ReadCoord16i(&cl_message);
        if (bits & E_ORIGIN2)
            e->origin[1] = MSG_ReadCoord16i(&cl_message);
        if (bits & E_ORIGIN3)
            e->origin[2] = MSG_ReadCoord16i(&cl_message);
    }
    else
    {
        if (bits & E_FLAGS)
            e->flags = MSG_ReadByte(&cl_message);
        if (e->flags & RENDER_LOWPRECISION)
        {
            if (bits & E_ORIGIN1)
                e->origin[0] = MSG_ReadCoord16i(&cl_message);
            if (bits & E_ORIGIN2)
                e->origin[1] = MSG_ReadCoord16i(&cl_message);
            if (bits & E_ORIGIN3)
                e->origin[2] = MSG_ReadCoord16i(&cl_message);
        }
        else
        {
            if (bits & E_ORIGIN1)
                e->origin[0] = MSG_ReadCoord32f(&cl_message);
            if (bits & E_ORIGIN2)
                e->origin[1] = MSG_ReadCoord32f(&cl_message);
            if (bits & E_ORIGIN3)
                e->origin[2] = MSG_ReadCoord32f(&cl_message);
        }
    }
    if ((cls.protocol == PROTOCOL_DARKPLACES5 || cls.protocol == PROTOCOL_DARKPLACES6) && !(e->flags & RENDER_LOWPRECISION))
    {
        if (bits & E_ANGLE1)
            e->angles[0] = MSG_ReadAngle16i(&cl_message);
        if (bits & E_ANGLE2)
            e->angles[1] = MSG_ReadAngle16i(&cl_message);
        if (bits & E_ANGLE3)
            e->angles[2] = MSG_ReadAngle16i(&cl_message);
    }
    else
    {
        if (bits & E_ANGLE1)
            e->angles[0] = MSG_ReadAngle8i(&cl_message);
        if (bits & E_ANGLE2)
            e->angles[1] = MSG_ReadAngle8i(&cl_message);
        if (bits & E_ANGLE3)
            e->angles[2] = MSG_ReadAngle8i(&cl_message);
    }
    if (bits & E_MODEL1)
        e->modelindex = (e->modelindex & 0xFF00) | (unsigned int) MSG_ReadByte(&cl_message);
    if (bits & E_MODEL2)
        e->modelindex = (e->modelindex & 0x00FF) | ((unsigned int) MSG_ReadByte(&cl_message) << 8);
    if (bits & E_FRAME1)
        e->frame = (e->frame & 0xFF00) | (unsigned int) MSG_ReadByte(&cl_message);
    if (bits & E_FRAME2)
        e->frame = (e->frame & 0x00FF) | ((unsigned int) MSG_ReadByte(&cl_message) << 8);
    if (bits & E_EFFECTS1)
        e->effects = (e->effects & 0xFF00) | (unsigned int) MSG_ReadByte(&cl_message);
    if (bits & E_EFFECTS2)
        e->effects = (e->effects & 0x00FF) | ((unsigned int) MSG_ReadByte(&cl_message) << 8);
    if (bits & E_COLORMAP)
        e->colormap = MSG_ReadByte(&cl_message);
    if (bits & E_SKIN)
        e->skin = MSG_ReadByte(&cl_message);
    if (bits & E_ALPHA)
        e->alpha = MSG_ReadByte(&cl_message);
    if (bits & E_SCALE)
        e->scale = MSG_ReadByte(&cl_message);
    if (bits & E_GLOWSIZE)
        e->glowsize = MSG_ReadByte(&cl_message);
    if (bits & E_GLOWCOLOR)
        e->glowcolor = MSG_ReadByte(&cl_message);
    if (cls.protocol == PROTOCOL_DARKPLACES2)
        if (bits & E_FLAGS)
            e->flags = MSG_ReadByte(&cl_message);
    if (bits & E_TAGATTACHMENT)
    {
        e->tagentity = (unsigned short) MSG_ReadShort(&cl_message);
        e->tagindex = MSG_ReadByte(&cl_message);
    }
    if (bits & E_LIGHT)
    {
        e->light[0] = (unsigned short) MSG_ReadShort(&cl_message);
        e->light[1] = (unsigned short) MSG_ReadShort(&cl_message);
        e->light[2] = (unsigned short) MSG_ReadShort(&cl_message);
        e->light[3] = (unsigned short) MSG_ReadShort(&cl_message);
    }
    if (bits & E_LIGHTSTYLE)
        e->lightstyle = MSG_ReadByte(&cl_message);
    if (bits & E_LIGHTPFLAGS)
        e->lightpflags = MSG_ReadByte(&cl_message);
 
    if (developer_networkentities.integer >= 2)
    {
        Con_Printf("ReadFields e%i", e->number);
 
        if (bits & E_ORIGIN1)
            Con_Printf(" E_ORIGIN1 %f", e->origin[0]);
        if (bits & E_ORIGIN2)
            Con_Printf(" E_ORIGIN2 %f", e->origin[1]);
        if (bits & E_ORIGIN3)
            Con_Printf(" E_ORIGIN3 %f", e->origin[2]);
        if (bits & E_ANGLE1)
            Con_Printf(" E_ANGLE1 %f", e->angles[0]);
        if (bits & E_ANGLE2)
            Con_Printf(" E_ANGLE2 %f", e->angles[1]);
        if (bits & E_ANGLE3)
            Con_Printf(" E_ANGLE3 %f", e->angles[2]);
        if (bits & (E_MODEL1 | E_MODEL2))
            Con_Printf(" E_MODEL %i", e->modelindex);
 
        if (bits & (E_FRAME1 | E_FRAME2))
            Con_Printf(" E_FRAME %i", e->frame);
        if (bits & (E_EFFECTS1 | E_EFFECTS2))
            Con_Printf(" E_EFFECTS %i", e->effects);
        if (bits & E_ALPHA)
            Con_Printf(" E_ALPHA %f", e->alpha / 255.0f);
        if (bits & E_SCALE)
            Con_Printf(" E_SCALE %f", e->scale / 16.0f);
        if (bits & E_COLORMAP)
            Con_Printf(" E_COLORMAP %i", e->colormap);
        if (bits & E_SKIN)
            Con_Printf(" E_SKIN %i", e->skin);
 
        if (bits & E_GLOWSIZE)
            Con_Printf(" E_GLOWSIZE %i", e->glowsize * 4);
        if (bits & E_GLOWCOLOR)
            Con_Printf(" E_GLOWCOLOR %i", e->glowcolor);
 
        if (bits & E_LIGHT)
            Con_Printf(" E_LIGHT %i:%i:%i:%i", e->light[0], e->light[1], e->light[2], e->light[3]);
        if (bits & E_LIGHTPFLAGS)
            Con_Printf(" E_LIGHTPFLAGS %i", e->lightpflags);
 
        if (bits & E_TAGATTACHMENT)
            Con_Printf(" E_TAGATTACHMENT e%i:%i", e->tagentity, e->tagindex);
        if (bits & E_LIGHTSTYLE)
            Con_Printf(" E_LIGHTSTYLE %i", e->lightstyle);
        Con_Print("\n");
    }
}

References entity_state_t::alpha, entity_state_t::angles, cl_message, cls, entity_state_t::colormap, Con_Print(), Con_Printf(), developer_networkentities, E_ALPHA, E_ANGLE1, E_ANGLE2, E_ANGLE3, E_COLORMAP, E_EFFECTS1, E_EFFECTS2, E_FLAGS, E_FRAME1, E_FRAME2, E_GLOWCOLOR, E_GLOWSIZE, E_LIGHT, E_LIGHTPFLAGS, E_LIGHTSTYLE, E_MODEL1, E_MODEL2, E_ORIGIN1, E_ORIGIN2, E_ORIGIN3, E_SCALE, E_SKIN, E_TAGATTACHMENT, entity_state_t::effects, entity_state_t::flags, entity_state_t::frame, entity_state_t::glowcolor, entity_state_t::glowsize, cvar_t::integer, entity_state_t::light, entity_state_t::lightpflags, entity_state_t::lightstyle, entity_state_t::modelindex, MSG_ReadAngle16i(), MSG_ReadAngle8i(), MSG_ReadByte, MSG_ReadCoord16i(), MSG_ReadCoord32f(), MSG_ReadShort, entity_state_t::number, entity_state_t::origin, client_static_t::protocol, PROTOCOL_DARKPLACES2, PROTOCOL_DARKPLACES5, PROTOCOL_DARKPLACES6, RENDER_LOWPRECISION, entity_state_t::scale, entity_state_t::skin, entity_state_t::tagentity, and entity_state_t::tagindex.

Referenced by EntityFrame4_CL_ReadFrame(), and EntityFrame_CL_ReadFrame().