{0,0}//unsigned char unused[2]; // !
};
+// LordHavoc: I own protocol ranges 96, 97, 3500-3599
+
+struct protocolversioninfo_s
+{
+ int number;
+ const char *name;
+}
+protocolversioninfo[] =
+{
+ {0, "UNKNOWN"},
+ {3504, "DP7"},
+ {3503, "DP6"},
+ {3502, "DP5"},
+ {3501, "DP4"},
+ {3500, "DP3"},
+ {97, "DP2"},
+ {96, "DP1"},
+ {15, "QUAKEDP"},
+ {250, "NEHAHRAMOVIE"},
+ {15, "QUAKE"},
+ {0, NULL}
+};
+
+protocolversion_t Protocol_EnumForName(const char *s)
+{
+ int i;
+ for (i = 1;protocolversioninfo[i].name;i++)
+ if (!strcasecmp(s, protocolversioninfo[i].name))
+ return (protocolversion_t)i;
+ return PROTOCOL_UNKNOWN;
+}
+
+const char *Protocol_NameForEnum(protocolversion_t p)
+{
+ return protocolversioninfo[p].name;
+}
+
+protocolversion_t Protocol_EnumForNumber(int n)
+{
+ int i;
+ for (i = 1;protocolversioninfo[i].name;i++)
+ if (protocolversioninfo[i].number == n)
+ return (protocolversion_t)i;
+ return PROTOCOL_UNKNOWN;
+}
+
+int Protocol_NumberForEnum(protocolversion_t p)
+{
+ return protocolversioninfo[p].number;
+}
+
+void Protocol_Names(char *buffer, size_t buffersize)
+{
+ int i;
+ if (buffersize < 1)
+ return;
+ buffer[0] = 0;
+ for (i = 1;protocolversioninfo[i].name;i++)
+ {
+ if (i > 1)
+ strlcat(buffer, " ", sizeof(buffer));
+ strlcat(buffer, protocolversioninfo[i].name, sizeof(buffer));
+ }
+}
+
// keep track of quake entities because they need to be killed if they get stale
int cl_lastquakeentity = 0;
qbyte cl_isquakeentity[MAX_EDICTS];
bits |= U_EXTERIORMODEL;
// LordHavoc: old stuff, but rewritten to have more exact tolerances
- baseline = sv.edicts[s->number].e->baseline;
+ baseline = prog->edicts[s->number].priv.server->baseline;
if (baseline.origin[0] != s->origin[0])
bits |= U_ORIGIN1;
if (baseline.origin[1] != s->origin[1])
bits |= U_GLOWCOLOR;
// if extensions are disabled, clear the relevant update flags
- if (sv.netquakecompatible)
+ if (sv.protocol == PROTOCOL_QUAKE || sv.protocol == PROTOCOL_NEHAHRAMOVIE)
bits &= 0x7FFF;
+ if (sv.protocol == PROTOCOL_NEHAHRAMOVIE)
+ if (s->alpha != 255 || s->effects & EF_FULLBRIGHT)
+ bits |= U_EXTEND1;
// write the message
if (bits >= 16777216)
if (bits & U_FRAME2) MSG_WriteByte(&buf, s->frame >> 8);
if (bits & U_MODEL2) MSG_WriteByte(&buf, s->modelindex >> 8);
+ // the nasty protocol
+ if ((bits & U_EXTEND1) && sv.protocol == PROTOCOL_NEHAHRAMOVIE)
+ {
+ if (s->effects & EF_FULLBRIGHT)
+ {
+ MSG_WriteFloat(&buf, 2); // QSG protocol version
+ MSG_WriteFloat(&buf, s->alpha <= 0 ? 0 : (s->alpha >= 255 ? 1 : s->alpha * (1.0f / 255.0f))); // alpha
+ MSG_WriteFloat(&buf, 1); // fullbright
+ }
+ else
+ {
+ MSG_WriteFloat(&buf, 1); // QSG protocol version
+ MSG_WriteFloat(&buf, s->alpha <= 0 ? 0 : (s->alpha >= 255 ? 1 : s->alpha * (1.0f / 255.0f))); // alpha
+ }
+ }
+
// if the commit is full, we're done this frame
if (msg->cursize + buf.cursize > msg->maxsize)
{
if (bits & E_ORIGIN3)
MSG_WriteCoord16i(msg, ent->origin[2]);
}
- else if (sv.protocol == PROTOCOL_DARKPLACES1 || sv.protocol == PROTOCOL_DARKPLACES3 || sv.protocol == PROTOCOL_DARKPLACES4 || sv.protocol == PROTOCOL_DARKPLACES5 || sv.protocol == PROTOCOL_DARKPLACES6)
+ else
{
// LordHavoc: have to write flags first, as they can modify protocol
if (bits & E_FLAGS)
MSG_WriteCoord32f(msg, ent->origin[2]);
}
}
- if ((sv.protocol == PROTOCOL_DARKPLACES5 || sv.protocol == PROTOCOL_DARKPLACES6) && !(ent->flags & RENDER_LOWPRECISION))
+ if ((sv.protocol == PROTOCOL_DARKPLACES1 || sv.protocol == PROTOCOL_DARKPLACES2 || sv.protocol == PROTOCOL_DARKPLACES3 || sv.protocol == PROTOCOL_DARKPLACES4) && (ent->flags & RENDER_LOWPRECISION))
{
if (bits & E_ANGLE1)
- MSG_WriteAngle16i(msg, ent->angles[0]);
+ MSG_WriteAngle8i(msg, ent->angles[0]);
if (bits & E_ANGLE2)
- MSG_WriteAngle16i(msg, ent->angles[1]);
+ MSG_WriteAngle8i(msg, ent->angles[1]);
if (bits & E_ANGLE3)
- MSG_WriteAngle16i(msg, ent->angles[2]);
+ MSG_WriteAngle8i(msg, ent->angles[2]);
}
else
{
if (bits & E_ANGLE1)
- MSG_WriteAngle8i(msg, ent->angles[0]);
+ MSG_WriteAngle16i(msg, ent->angles[0]);
if (bits & E_ANGLE2)
- MSG_WriteAngle8i(msg, ent->angles[1]);
+ MSG_WriteAngle16i(msg, ent->angles[1]);
if (bits & E_ANGLE3)
- MSG_WriteAngle8i(msg, ent->angles[2]);
+ MSG_WriteAngle16i(msg, ent->angles[2]);
}
if (bits & E_MODEL1)
MSG_WriteByte(msg, ent->modelindex & 0xFF);
if (bits & E_ORIGIN3)
e->origin[2] = MSG_ReadCoord16i();
}
- else if (cl.protocol == PROTOCOL_DARKPLACES1 || cl.protocol == PROTOCOL_DARKPLACES3 || cl.protocol == PROTOCOL_DARKPLACES4 || cl.protocol == PROTOCOL_DARKPLACES5 || cl.protocol == PROTOCOL_DARKPLACES6)
+ else
{
if (bits & E_FLAGS)
e->flags = MSG_ReadByte();
e->origin[2] = MSG_ReadCoord32f();
}
}
- else
- Host_Error("EntityState_ReadFields: unknown cl.protocol %i\n", cl.protocol);
if ((cl.protocol == PROTOCOL_DARKPLACES5 || cl.protocol == PROTOCOL_DARKPLACES6) && !(e->flags & RENDER_LOWPRECISION))
{
if (bits & E_ANGLE1)
// (client and server) allocates a new empty database
entityframe_database_t *EntityFrame_AllocDatabase(mempool_t *mempool)
{
- return Mem_Alloc(mempool, sizeof(entityframe_database_t));
+ return (entityframe_database_t *)Mem_Alloc(mempool, sizeof(entityframe_database_t));
}
// (client and server) frees the database
int oldmax = d->maxreferenceentities;
entity_state_t *oldentity = d->referenceentity;
d->maxreferenceentities = (number + 15) & ~7;
- d->referenceentity = Mem_Alloc(d->mempool, d->maxreferenceentities * sizeof(*d->referenceentity));
+ d->referenceentity = (entity_state_t *)Mem_Alloc(d->mempool, d->maxreferenceentities * sizeof(*d->referenceentity));
if (oldentity)
{
memcpy(d->referenceentity, oldentity, oldmax * sizeof(*d->referenceentity));
{
entity_state_t *oldentity = d->currentcommit->entity;
d->currentcommit->maxentities += 8;
- d->currentcommit->entity = Mem_Alloc(d->mempool, d->currentcommit->maxentities * sizeof(*d->currentcommit->entity));
+ d->currentcommit->entity = (entity_state_t *)Mem_Alloc(d->mempool, d->currentcommit->maxentities * sizeof(*d->currentcommit->entity));
if (oldentity)
{
memcpy(d->currentcommit->entity, oldentity, d->currentcommit->numentities * sizeof(*d->currentcommit->entity));
entityframe4_database_t *EntityFrame4_AllocDatabase(mempool_t *pool)
{
entityframe4_database_t *d;
- d = Mem_Alloc(pool, sizeof(*d));
+ d = (entityframe4_database_t *)Mem_Alloc(pool, sizeof(*d));
d->mempool = pool;
EntityFrame4_ResetDatabase(d);
return d;
Con_Printf(" %i", d->commit[i].framenum);
Con_Print(")\n");
}
- if (d->currententitynumber >= sv.max_edicts)
+ if (d->currententitynumber >= prog->max_edicts)
startnumber = 1;
else
- startnumber = bound(1, d->currententitynumber, sv.max_edicts - 1);
+ startnumber = bound(1, d->currententitynumber, prog->max_edicts - 1);
MSG_WriteShort(msg, startnumber);
// reset currententitynumber so if the loop does not break it we will
// start at beginning next frame (if it does break, it will set it)
d->currententitynumber = 1;
- for (i = 0, n = startnumber;n < sv.max_edicts;n++)
+ for (i = 0, n = startnumber;n < prog->max_edicts;n++)
{
// find the old state to delta from
e = EntityFrame4_GetReferenceEntity(d, n);
entityframe5_database_t *EntityFrame5_AllocDatabase(mempool_t *pool)
{
entityframe5_database_t *d;
- d = Mem_Alloc(pool, sizeof(*d));
+ d = (entityframe5_database_t *)Mem_Alloc(pool, sizeof(*d));
EntityFrame5_ResetDatabase(d);
return d;
}
entity_state_t *oldstates = d->states;
qbyte *oldvisiblebits = d->visiblebits;
d->maxedicts = newmax;
- data = Mem_Alloc(sv_mempool, d->maxedicts * sizeof(int) + d->maxedicts * sizeof(qbyte) + d->maxedicts * sizeof(int) + d->maxedicts * sizeof(entity_state_t) + (d->maxedicts+7)/8 * sizeof(qbyte));
- d->deltabits = (void *)data;data += d->maxedicts * sizeof(int);
- d->priorities = (void *)data;data += d->maxedicts * sizeof(qbyte);
- d->updateframenum = (void *)data;data += d->maxedicts * sizeof(int);
- d->states = (void *)data;data += d->maxedicts * sizeof(entity_state_t);
- d->visiblebits = (void *)data;data += (d->maxedicts+7)/8 * sizeof(qbyte);
+ data = (qbyte *)Mem_Alloc(sv_mempool, d->maxedicts * sizeof(int) + d->maxedicts * sizeof(qbyte) + d->maxedicts * sizeof(int) + d->maxedicts * sizeof(entity_state_t) + (d->maxedicts+7)/8 * sizeof(qbyte));
+ d->deltabits = (int *)data;data += d->maxedicts * sizeof(int);
+ d->priorities = (qbyte *)data;data += d->maxedicts * sizeof(qbyte);
+ d->updateframenum = (int *)data;data += d->maxedicts * sizeof(int);
+ d->states = (entity_state_t *)data;data += d->maxedicts * sizeof(entity_state_t);
+ d->visiblebits = (qbyte *)data;data += (d->maxedicts+7)/8 * sizeof(qbyte);
if (oldmaxedicts)
{
- memcpy(d->deltabits, olddeltabits, d->maxedicts * sizeof(int));
- memcpy(d->priorities, oldpriorities, d->maxedicts * sizeof(qbyte));
- memcpy(d->updateframenum, oldupdateframenum, d->maxedicts * sizeof(int));
- memcpy(d->states, oldstates, d->maxedicts * sizeof(entity_state_t));
- memcpy(d->visiblebits, oldvisiblebits, (d->maxedicts+7)/8 * sizeof(qbyte));
+ memcpy(d->deltabits, olddeltabits, oldmaxedicts * sizeof(int));
+ memcpy(d->priorities, oldpriorities, oldmaxedicts * sizeof(qbyte));
+ memcpy(d->updateframenum, oldupdateframenum, oldmaxedicts * sizeof(int));
+ memcpy(d->states, oldstates, oldmaxedicts * sizeof(entity_state_t));
+ memcpy(d->visiblebits, oldvisiblebits, (oldmaxedicts+7)/8 * sizeof(qbyte));
// the previous buffers were a single allocation, so just one free
Mem_Free(olddeltabits);
}
else
{
bits = changedbits;
- if ((bits & E5_ORIGIN) && (s->origin[0] < -4096 || s->origin[0] >= 4096 || s->origin[1] < -4096 || s->origin[1] >= 4096 || s->origin[2] < -4096 || s->origin[2] >= 4096))
+ if ((bits & E5_ORIGIN) && (!(s->flags & RENDER_LOWPRECISION) || s->origin[0] < -4096 || s->origin[0] >= 4096 || s->origin[1] < -4096 || s->origin[1] >= 4096 || s->origin[2] < -4096 || s->origin[2] >= 4096))
bits |= E5_ORIGIN32;
if ((bits & E5_ANGLES) && !(s->flags & RENDER_LOWPRECISION))
bits |= E5_ANGLES16;
for (i = 0;i < LATESTFRAMENUMS-1;i++)
cl.latestframenums[i] = cl.latestframenums[i+1];
cl.latestframenums[LATESTFRAMENUMS-1] = MSG_ReadLong();
+ if (cl.protocol != PROTOCOL_QUAKE && cl.protocol != PROTOCOL_QUAKEDP && cl.protocol != PROTOCOL_NEHAHRAMOVIE && cl.protocol != PROTOCOL_DARKPLACES1 && cl.protocol != PROTOCOL_DARKPLACES2 && cl.protocol != PROTOCOL_DARKPLACES3 && cl.protocol != PROTOCOL_DARKPLACES4 && cl.protocol != PROTOCOL_DARKPLACES5 && cl.protocol != PROTOCOL_DARKPLACES6)
+ cl.servermovesequence = MSG_ReadLong();
// read entity numbers until we find a 0x8000
// (which would be remove world entity, but is actually a terminator)
while ((n = (unsigned short)MSG_ReadShort()) != 0x8000 && !msg_badread)
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)
+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;
int i, num, l, framenum, packetlognumber, priority;
qbyte data[128];
entityframe5_packetlog_t *packetlog;
- if (sv.num_edicts > d->maxedicts)
- EntityFrame5_ExpandEdicts(d, (sv.num_edicts + 255) & ~255);
+ if (prog->max_edicts > d->maxedicts)
+ EntityFrame5_ExpandEdicts(d, prog->max_edicts);
framenum = d->latestframenum + 1;
d->viewentnum = viewentnum;
break;
if (packetlognumber == ENTITYFRAME5_MAXPACKETLOGS)
{
+ Con_DPrintf("EntityFrame5_WriteFrame: packetlog overflow for a client, resetting\n");
EntityFrame5_LostFrame(d, framenum);
packetlognumber = 0;
}
num++;
}
// all remaining entities are dead
- for (;num < sv.num_edicts;num++)
+ for (;num < d->maxedicts;num++)
{
if (CHECKPVSBIT(d->visiblebits, 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;
+
// build lists of entities by priority level
memset(entityframe5_prioritychaincounts, 0, sizeof(entityframe5_prioritychaincounts));
l = 0;
- for (num = 0;num < sv.num_edicts;num++)
+ for (num = 0;num < d->maxedicts;num++)
{
if (d->priorities[num])
{
packetlog->packetnumber = framenum;
packetlog->numstates = 0;
// write stat updates
- if (sv.protocol == PROTOCOL_DARKPLACES6)
+ 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)
{
- for (i = 0;i < MAX_CL_STATS;i++)
+ for (i = 0;i < MAX_CL_STATS && msg->cursize + 6 + 11 <= msg->maxsize;i++)
{
if (d->statsdeltabits[i>>3] & (1<<(i&7)))
{
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 = E5_PROTOCOL_PRIORITYLEVELS - 1;priority >= 0 && packetlog->numstates < ENTITYFRAME5_MAXSTATES;priority--)
{
for (i = 0;i < entityframe5_prioritychaincounts[priority] && packetlog->numstates < ENTITYFRAME5_MAXSTATES;i++)
projects / xonotic / darkplaces.git / blobdiff