mirror of
https://github.com/ReactionQuake3/reaction.git
synced 2024-11-28 23:12:40 +00:00
446 lines
12 KiB
C
446 lines
12 KiB
C
//-----------------------------------------------------------------------------
|
|
//
|
|
// $Id$
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
// $Log$
|
|
// Revision 1.9 2005/02/15 16:33:38 makro
|
|
// Tons of updates (entity tree attachment system, UI vectors)
|
|
//
|
|
// Revision 1.8 2003/04/19 15:27:30 jbravo
|
|
// Backing out of most of unlagged. Only optimized prediction and smooth clients
|
|
// remains.
|
|
//
|
|
// Revision 1.7 2003/03/09 21:30:38 jbravo
|
|
// Adding unlagged. Still needs work.
|
|
//
|
|
// Revision 1.6 2002/06/16 20:06:13 jbravo
|
|
// Reindented all the source files with "indent -kr -ut -i8 -l120 -lc120 -sob -bad -bap"
|
|
//
|
|
// Revision 1.5 2002/01/11 19:48:29 jbravo
|
|
// Formatted the source in non DOS format.
|
|
//
|
|
// Revision 1.4 2001/12/31 16:28:41 jbravo
|
|
// I made a Booboo with the Log tag.
|
|
//
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
// Copyright (C) 1999-2000 Id Software, Inc.
|
|
//
|
|
// cg_snapshot.c -- things that happen on snapshot transition,
|
|
// not necessarily every single rendered frame
|
|
|
|
#include "cg_local.h"
|
|
|
|
/*
|
|
==================
|
|
CG_ResetEntity
|
|
==================
|
|
*/
|
|
static void CG_ResetEntity(centity_t * cent)
|
|
{
|
|
// if the previous snapshot this entity was updated in is at least
|
|
// an event window back in time then we can reset the previous event
|
|
if (cent->snapShotTime < cg.time - EVENT_VALID_MSEC) {
|
|
cent->previousEvent = 0;
|
|
}
|
|
|
|
cent->trailTime = cg.snap->serverTime;
|
|
|
|
VectorCopy(cent->currentState.origin, cent->lerpOrigin);
|
|
VectorCopy(cent->currentState.angles, cent->lerpAngles);
|
|
if (cent->currentState.eType == ET_PLAYER) {
|
|
CG_ResetPlayerEntity(cent);
|
|
}
|
|
|
|
CG_EvaluateTrajectoryEx(cent, cg.snap->serverTime, cent->lerpOrigin, cent->lerpAngles);
|
|
}
|
|
|
|
/*
|
|
===============
|
|
CG_TransitionEntity
|
|
|
|
cent->nextState is moved to cent->currentState and events are fired
|
|
===============
|
|
*/
|
|
void CG_TransitionEntity(centity_t * cent)
|
|
{
|
|
cent->currentState = cent->nextState;
|
|
cent->currentValid = qtrue;
|
|
|
|
// reset if the entity wasn't in the last frame or was teleported
|
|
if (!cent->interpolate) {
|
|
CG_ResetEntity(cent);
|
|
}
|
|
// clear the next state. if will be set by the next CG_SetNextSnap
|
|
cent->interpolate = qfalse;
|
|
|
|
// check for events
|
|
CG_CheckEvents(cent);
|
|
}
|
|
|
|
/*
|
|
==================
|
|
CG_OrderSnapshotEntities
|
|
|
|
Makro - orders snapshot entities so that
|
|
attached ones are added after their "parents"
|
|
==================
|
|
*/
|
|
static void CG_OrderSnapshotEntities(snapshot_t *snap, int *order)
|
|
{
|
|
int i, j;
|
|
|
|
//initial values
|
|
for (i=0; i<snap->numEntities; i++)
|
|
order[i] = i;
|
|
//actual sorting... not exactly the fastest algorithm ever written
|
|
for (i=0; i<snap->numEntities-1; i++)
|
|
{
|
|
for (j=i+1; j<snap->numEntities; j++)
|
|
{
|
|
if (cg_moveParentRanks[snap->entities[order[i]].number] <
|
|
cg_moveParentRanks[snap->entities[order[j]].number])
|
|
{
|
|
//swap
|
|
order[i] ^= order[j];
|
|
order[j] ^= order[i];
|
|
order[i] ^= order[j];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
static void CG_CheckVidRestart(void)
|
|
{
|
|
trap_SendConsoleCommand("ui_RQ3_postVidRestart\n");
|
|
}
|
|
|
|
/*
|
|
==================
|
|
CG_SetInitialSnapshot
|
|
|
|
This will only happen on the very first snapshot, or
|
|
on tourney restarts. All other times will use
|
|
CG_TransitionSnapshot instead.
|
|
|
|
FIXME: Also called by map_restart?
|
|
==================
|
|
*/
|
|
void CG_SetInitialSnapshot(snapshot_t * snap)
|
|
{
|
|
int i;
|
|
centity_t *cent;
|
|
entityState_t *state;
|
|
|
|
cg.snap = snap;
|
|
//Makro - order snapshot entities so that attached ones are added after their "parents"
|
|
CG_OrderSnapshotEntities(snap, cg_snapEntityOrder);
|
|
|
|
BG_PlayerStateToEntityState(&snap->ps, &cg_entities[snap->ps.clientNum].currentState, qfalse);
|
|
|
|
// sort out solid entities
|
|
CG_BuildSolidList();
|
|
|
|
CG_ExecuteNewServerCommands(snap->serverCommandSequence);
|
|
|
|
// set our local weapon selection pointer to
|
|
// what the server has indicated the current weapon is
|
|
CG_Respawn();
|
|
|
|
for (i = 0; i < cg.snap->numEntities; i++) {
|
|
state = &cg.snap->entities[cg_snapEntityOrder[i]];
|
|
cent = &cg_entities[state->number];
|
|
|
|
memcpy(¢->currentState, state, sizeof(entityState_t));
|
|
//cent->currentState = *state;
|
|
cent->interpolate = qfalse;
|
|
cent->currentValid = qtrue;
|
|
|
|
CG_ResetEntity(cent);
|
|
|
|
// check for events
|
|
CG_CheckEvents(cent);
|
|
}
|
|
|
|
CG_CheckVidRestart();
|
|
}
|
|
|
|
/*
|
|
===================
|
|
CG_TransitionSnapshot
|
|
|
|
The transition point from snap to nextSnap has passed
|
|
===================
|
|
*/
|
|
static void CG_TransitionSnapshot(void)
|
|
{
|
|
centity_t *cent;
|
|
snapshot_t *oldFrame;
|
|
int i;
|
|
|
|
if (!cg.snap) {
|
|
CG_Error("CG_TransitionSnapshot: NULL cg.snap");
|
|
}
|
|
if (!cg.nextSnap) {
|
|
CG_Error("CG_TransitionSnapshot: NULL cg.nextSnap");
|
|
}
|
|
// execute any server string commands before transitioning entities
|
|
CG_ExecuteNewServerCommands(cg.nextSnap->serverCommandSequence);
|
|
|
|
// if we had a map_restart, set everthing with initial
|
|
if (!cg.snap) {
|
|
return;
|
|
}
|
|
|
|
// clear the currentValid flag for all entities in the existing snapshot
|
|
for (i = 0; i < cg.snap->numEntities; i++) {
|
|
cent = &cg_entities[cg.snap->entities[i].number];
|
|
cent->currentValid = qfalse;
|
|
}
|
|
|
|
// move nextSnap to snap and do the transitions
|
|
oldFrame = cg.snap;
|
|
cg.snap = cg.nextSnap;
|
|
//Makro - copy entity order
|
|
memcpy(cg_snapEntityOrder, cg_nextSnapEntityOrder, cg.snap->numEntities * sizeof(cg_nextSnapEntityOrder[0]));
|
|
|
|
BG_PlayerStateToEntityState(&cg.snap->ps, &cg_entities[cg.snap->ps.clientNum].currentState, qfalse);
|
|
cg_entities[cg.snap->ps.clientNum].interpolate = qfalse;
|
|
|
|
for (i = 0; i < cg.snap->numEntities; i++) {
|
|
cent = &cg_entities[cg.snap->entities[i].number];
|
|
CG_TransitionEntity(cent);
|
|
|
|
// remember time of snapshot this entity was last updated in
|
|
cent->snapShotTime = cg.snap->serverTime;
|
|
}
|
|
|
|
cg.nextSnap = NULL;
|
|
|
|
// check for playerstate transition events
|
|
if (oldFrame) {
|
|
playerState_t *ops, *ps;
|
|
|
|
ops = &oldFrame->ps;
|
|
ps = &cg.snap->ps;
|
|
// teleporting checks are irrespective of prediction
|
|
if ((ps->eFlags ^ ops->eFlags) & EF_TELEPORT_BIT) {
|
|
cg.thisFrameTeleport = qtrue; // will be cleared by prediction code
|
|
}
|
|
// if we are not doing client side movement prediction for any
|
|
// reason, then the client events and view changes will be issued now
|
|
if (cg.demoPlayback || (cg.snap->ps.pm_flags & PMF_FOLLOW)
|
|
|| cg_nopredict.integer || cg_synchronousClients.integer) {
|
|
CG_TransitionPlayerState(ps, ops);
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
/*
|
|
===================
|
|
CG_SetNextSnap
|
|
|
|
A new snapshot has just been read in from the client system.
|
|
===================
|
|
*/
|
|
static void CG_SetNextSnap(snapshot_t * snap)
|
|
{
|
|
int num;
|
|
entityState_t *es;
|
|
centity_t *cent;
|
|
|
|
cg.nextSnap = snap;
|
|
//Makro - order snapshot entities so that attached ones are added after their "parents"
|
|
CG_OrderSnapshotEntities(snap, cg_nextSnapEntityOrder);
|
|
|
|
BG_PlayerStateToEntityState(&snap->ps, &cg_entities[snap->ps.clientNum].nextState, qfalse);
|
|
cg_entities[cg.snap->ps.clientNum].interpolate = qtrue;
|
|
|
|
// check for extrapolation errors
|
|
for (num = 0; num < snap->numEntities; num++) {
|
|
es = &snap->entities[num];
|
|
cent = &cg_entities[es->number];
|
|
|
|
memcpy(¢->nextState, es, sizeof(entityState_t));
|
|
//cent->nextState = *es;
|
|
|
|
// if this frame is a teleport, or the entity wasn't in the
|
|
// previous frame, don't interpolate
|
|
if (!cent->currentValid || ((cent->currentState.eFlags ^ es->eFlags) & EF_TELEPORT_BIT)) {
|
|
cent->interpolate = qfalse;
|
|
} else {
|
|
cent->interpolate = qtrue;
|
|
}
|
|
}
|
|
|
|
// if the next frame is a teleport for the playerstate, we
|
|
// can't interpolate during demos
|
|
if (cg.snap && ((snap->ps.eFlags ^ cg.snap->ps.eFlags) & EF_TELEPORT_BIT)) {
|
|
cg.nextFrameTeleport = qtrue;
|
|
} else {
|
|
cg.nextFrameTeleport = qfalse;
|
|
}
|
|
|
|
// if changing follow mode, don't interpolate
|
|
if (cg.nextSnap->ps.clientNum != cg.snap->ps.clientNum) {
|
|
cg.nextFrameTeleport = qtrue;
|
|
}
|
|
// if changing server restarts, don't interpolate
|
|
if ((cg.nextSnap->snapFlags ^ cg.snap->snapFlags) & SNAPFLAG_SERVERCOUNT) {
|
|
cg.nextFrameTeleport = qtrue;
|
|
}
|
|
// sort out solid entities
|
|
CG_BuildSolidList();
|
|
}
|
|
|
|
/*
|
|
========================
|
|
CG_ReadNextSnapshot
|
|
|
|
This is the only place new snapshots are requested
|
|
This may increment cgs.processedSnapshotNum multiple
|
|
times if the client system fails to return a
|
|
valid snapshot.
|
|
========================
|
|
*/
|
|
static snapshot_t *CG_ReadNextSnapshot(void)
|
|
{
|
|
qboolean r;
|
|
snapshot_t *dest;
|
|
|
|
if (cg.latestSnapshotNum > cgs.processedSnapshotNum + 1000) {
|
|
CG_Printf("WARNING: CG_ReadNextSnapshot: way out of range, %i > %i\n",
|
|
cg.latestSnapshotNum, cgs.processedSnapshotNum);
|
|
}
|
|
|
|
while (cgs.processedSnapshotNum < cg.latestSnapshotNum) {
|
|
// decide which of the two slots to load it into
|
|
if (cg.snap == &cg.activeSnapshots[0]) {
|
|
dest = &cg.activeSnapshots[1];
|
|
} else {
|
|
dest = &cg.activeSnapshots[0];
|
|
}
|
|
|
|
// try to read the snapshot from the client system
|
|
cgs.processedSnapshotNum++;
|
|
r = trap_GetSnapshot(cgs.processedSnapshotNum, dest);
|
|
|
|
// FIXME: why would trap_GetSnapshot return a snapshot with the same server time
|
|
if (cg.snap && r && dest->serverTime == cg.snap->serverTime) {
|
|
//continue;
|
|
}
|
|
// if it succeeded, return
|
|
if (r) {
|
|
CG_AddLagometerSnapshotInfo(dest);
|
|
return dest;
|
|
}
|
|
// a GetSnapshot will return failure if the snapshot
|
|
// never arrived, or is so old that its entities
|
|
// have been shoved off the end of the circular
|
|
// buffer in the client system.
|
|
|
|
// record as a dropped packet
|
|
CG_AddLagometerSnapshotInfo(NULL);
|
|
|
|
// If there are additional snapshots, continue trying to
|
|
// read them.
|
|
}
|
|
|
|
// nothing left to read
|
|
return NULL;
|
|
}
|
|
|
|
/*
|
|
============
|
|
CG_ProcessSnapshots
|
|
|
|
We are trying to set up a renderable view, so determine
|
|
what the simulated time is, and try to get snapshots
|
|
both before and after that time if available.
|
|
|
|
If we don't have a valid cg.snap after exiting this function,
|
|
then a 3D game view cannot be rendered. This should only happen
|
|
right after the initial connection. After cg.snap has been valid
|
|
once, it will never turn invalid.
|
|
|
|
Even if cg.snap is valid, cg.nextSnap may not be, if the snapshot
|
|
hasn't arrived yet (it becomes an extrapolating situation instead
|
|
of an interpolating one)
|
|
|
|
============
|
|
*/
|
|
void CG_ProcessSnapshots(void)
|
|
{
|
|
snapshot_t *snap;
|
|
int n;
|
|
|
|
// see what the latest snapshot the client system has is
|
|
trap_GetCurrentSnapshotNumber(&n, &cg.latestSnapshotTime);
|
|
if (n != cg.latestSnapshotNum) {
|
|
if (n < cg.latestSnapshotNum) {
|
|
// this should never happen
|
|
CG_Error("CG_ProcessSnapshots: n < cg.latestSnapshotNum");
|
|
}
|
|
cg.latestSnapshotNum = n;
|
|
}
|
|
// If we have yet to receive a snapshot, check for it.
|
|
// Once we have gotten the first snapshot, cg.snap will
|
|
// always have valid data for the rest of the game
|
|
while (!cg.snap) {
|
|
snap = CG_ReadNextSnapshot();
|
|
if (!snap) {
|
|
// we can't continue until we get a snapshot
|
|
return;
|
|
}
|
|
// set our weapon selection to what
|
|
// the playerstate is currently using
|
|
if (!(snap->snapFlags & SNAPFLAG_NOT_ACTIVE)) {
|
|
CG_SetInitialSnapshot(snap);
|
|
}
|
|
}
|
|
|
|
// loop until we either have a valid nextSnap with a serverTime
|
|
// greater than cg.time to interpolate towards, or we run
|
|
// out of available snapshots
|
|
do {
|
|
// if we don't have a nextframe, try and read a new one in
|
|
if (!cg.nextSnap) {
|
|
snap = CG_ReadNextSnapshot();
|
|
|
|
// if we still don't have a nextframe, we will just have to
|
|
// extrapolate
|
|
if (!snap) {
|
|
break;
|
|
}
|
|
|
|
CG_SetNextSnap(snap);
|
|
|
|
// if time went backwards, we have a level restart
|
|
if (cg.nextSnap->serverTime < cg.snap->serverTime) {
|
|
CG_Error("CG_ProcessSnapshots: Server time went backwards");
|
|
}
|
|
}
|
|
// if our time is < nextFrame's, we have a nice interpolating state
|
|
if (cg.time >= cg.snap->serverTime && cg.time < cg.nextSnap->serverTime) {
|
|
break;
|
|
}
|
|
// we have passed the transition from nextFrame to frame
|
|
CG_TransitionSnapshot();
|
|
} while (1);
|
|
|
|
// assert our valid conditions upon exiting
|
|
if (cg.snap == NULL) {
|
|
CG_Error("CG_ProcessSnapshots: cg.snap == NULL");
|
|
}
|
|
if (cg.time < cg.snap->serverTime) {
|
|
// this can happen right after a vid_restart
|
|
cg.time = cg.snap->serverTime;
|
|
}
|
|
if (cg.nextSnap != NULL && cg.nextSnap->serverTime <= cg.time) {
|
|
CG_Error("CG_ProcessSnapshots: cg.nextSnap->serverTime <= cg.time");
|
|
}
|
|
|
|
}
|