1.27 import

1 files changed, 615 insertions, 0 deletions

diff --git a/src/cgame/cg_predict.c b/src/cgame/cg_predict.c
new file mode 100644
index 00000000..0b9505ba
--- /dev/null
+++ b/src/cgame/cg_predict.c
@@ -0,0 +1,615 @@
+// Copyright (C) 1999-2000 Id Software, Inc.
+//
+// cg_predict.c -- this file generates cg.predictedPlayerState by either
+// interpolating between snapshots from the server or locally predicting
+// ahead the client's movement.
+// It also handles local physics interaction, like fragments bouncing off walls
+
+/*
+ *  Portions Copyright (C) 2000-2001 Tim Angus
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2, or (at your option)
+ *  any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ */
+
+/*  To assertain which portions are licensed under the GPL and which are
+ *  licensed by Id Software, Inc. please run a diff between the equivalent
+ *  versions of the "Tremulous" modification and the unmodified "Quake3"
+ *  game source code.
+ */
+                    
+#include "cg_local.h"
+
+static  pmove_t   cg_pmove;
+
+static  int     cg_numSolidEntities;
+static  centity_t *cg_solidEntities[MAX_ENTITIES_IN_SNAPSHOT];
+static  int     cg_numTriggerEntities;
+static  centity_t *cg_triggerEntities[MAX_ENTITIES_IN_SNAPSHOT];
+
+/*
+====================
+CG_BuildSolidList
+
+When a new cg.snap has been set, this function builds a sublist
+of the entities that are actually solid, to make for more
+efficient collision detection
+====================
+*/
+void CG_BuildSolidList( void ) {
+  int     i;
+  centity_t *cent;
+  snapshot_t  *snap;
+  entityState_t *ent;
+
+  cg_numSolidEntities = 0;
+  cg_numTriggerEntities = 0;
+
+  if ( cg.nextSnap && !cg.nextFrameTeleport && !cg.thisFrameTeleport ) {
+    snap = cg.nextSnap;
+  } else {
+    snap = cg.snap;
+  }
+
+  for ( i = 0 ; i < snap->numEntities ; i++ ) {
+    cent = &cg_entities[ snap->entities[ i ].number ];
+    ent = &cent->currentState;
+
+    if ( ent->eType == ET_ITEM || ent->eType == ET_PUSH_TRIGGER || ent->eType == ET_TELEPORT_TRIGGER ) {
+      cg_triggerEntities[cg_numTriggerEntities] = cent;
+      cg_numTriggerEntities++;
+      continue;
+    }
+
+    if ( cent->nextState.solid ) {
+      cg_solidEntities[cg_numSolidEntities] = cent;
+      cg_numSolidEntities++;
+      continue;
+    }
+  }
+}
+
+/*
+====================
+CG_ClipMoveToEntities
+
+====================
+*/
+static void CG_ClipMoveToEntities ( const vec3_t start, const vec3_t mins, const vec3_t maxs, const vec3_t end,
+              int skipNumber, int mask, trace_t *tr ) {
+  int     i, x, zd, zu;
+  trace_t   trace;
+  entityState_t *ent;
+  clipHandle_t  cmodel;
+  vec3_t    bmins, bmaxs;
+  vec3_t    origin, angles;
+  centity_t *cent;
+
+  for ( i = 0 ; i < cg_numSolidEntities ; i++ ) {
+    cent = cg_solidEntities[ i ];
+    ent = &cent->currentState;
+
+    if ( ent->number == skipNumber ) {
+      continue;
+    }
+
+    if ( ent->solid == SOLID_BMODEL ) {
+      // special value for bmodel
+      cmodel = trap_CM_InlineModel( ent->modelindex );
+      VectorCopy( cent->lerpAngles, angles );
+      BG_EvaluateTrajectory( &cent->currentState.pos, cg.physicsTime, origin );
+    } else {
+      // encoded bbox
+      x = (ent->solid & 255);
+      zd = ((ent->solid>>8) & 255);
+      zu = ((ent->solid>>16) & 255) - 32;
+
+      bmins[0] = bmins[1] = -x;
+      bmaxs[0] = bmaxs[1] = x;
+      bmins[2] = -zd;
+      bmaxs[2] = zu;
+
+      cmodel = trap_CM_TempBoxModel( bmins, bmaxs );
+      VectorCopy( vec3_origin, angles );
+      VectorCopy( cent->lerpOrigin, origin );
+    }
+
+
+    trap_CM_TransformedBoxTrace ( &trace, start, end,
+      mins, maxs, cmodel,  mask, origin, angles);
+
+    if (trace.allsolid || trace.fraction < tr->fraction) {
+      trace.entityNum = ent->number;
+      *tr = trace;
+    } else if (trace.startsolid) {
+      tr->startsolid = qtrue;
+    }
+    if ( tr->allsolid ) {
+      return;
+    }
+  }
+}
+
+/*
+================
+CG_Trace
+================
+*/
+void  CG_Trace( trace_t *result, const vec3_t start, const vec3_t mins, const vec3_t maxs, const vec3_t end,
+           int skipNumber, int mask ) {
+  trace_t t;
+
+  trap_CM_BoxTrace ( &t, start, end, mins, maxs, 0, mask);
+  t.entityNum = t.fraction != 1.0 ? ENTITYNUM_WORLD : ENTITYNUM_NONE;
+  // check all other solid models
+  CG_ClipMoveToEntities (start, mins, maxs, end, skipNumber, mask, &t);
+
+  *result = t;
+}
+
+/*
+================
+CG_PointContents
+================
+*/
+int   CG_PointContents( const vec3_t point, int passEntityNum ) {
+  int     i;
+  entityState_t *ent;
+  centity_t *cent;
+  clipHandle_t cmodel;
+  int     contents;
+
+  contents = trap_CM_PointContents (point, 0);
+
+  for ( i = 0 ; i < cg_numSolidEntities ; i++ ) {
+    cent = cg_solidEntities[ i ];
+
+    ent = &cent->currentState;
+
+    if ( ent->number == passEntityNum ) {
+      continue;
+    }
+
+    if (ent->solid != SOLID_BMODEL) { // special value for bmodel
+      continue;
+    }
+
+    cmodel = trap_CM_InlineModel( ent->modelindex );
+    if ( !cmodel ) {
+      continue;
+    }
+
+    contents |= trap_CM_TransformedPointContents( point, cmodel, ent->origin, ent->angles );
+  }
+
+  return contents;
+}
+
+
+/*
+========================
+CG_InterpolatePlayerState
+
+Generates cg.predictedPlayerState by interpolating between
+cg.snap->player_state and cg.nextFrame->player_state
+========================
+*/
+static void CG_InterpolatePlayerState( qboolean grabAngles ) {
+  float     f;
+  int       i;
+  playerState_t *out;
+  snapshot_t    *prev, *next;
+
+  out = &cg.predictedPlayerState;
+  prev = cg.snap;
+  next = cg.nextSnap;
+
+  *out = cg.snap->ps;
+
+  // if we are still allowing local input, short circuit the view angles
+  if ( grabAngles ) {
+    usercmd_t cmd;
+    int     cmdNum;
+
+    cmdNum = trap_GetCurrentCmdNumber();
+    trap_GetUserCmd( cmdNum, &cmd );
+
+    PM_UpdateViewAngles( out, &cmd );
+  }
+
+  // if the next frame is a teleport, we can't lerp to it
+  if ( cg.nextFrameTeleport ) {
+    return;
+  }
+
+  if ( !next || next->serverTime <= prev->serverTime ) {
+    return;
+  }
+
+  f = (float)( cg.time - prev->serverTime ) / ( next->serverTime - prev->serverTime );
+
+  i = next->ps.bobCycle;
+  if ( i < prev->ps.bobCycle ) {
+    i += 256;   // handle wraparound
+  }
+  out->bobCycle = prev->ps.bobCycle + f * ( i - prev->ps.bobCycle );
+
+  for ( i = 0 ; i < 3 ; i++ ) {
+    out->origin[i] = prev->ps.origin[i] + f * (next->ps.origin[i] - prev->ps.origin[i] );
+    if ( !grabAngles ) {
+      out->viewangles[i] = LerpAngle(
+        prev->ps.viewangles[i], next->ps.viewangles[i], f );
+    }
+    out->velocity[i] = prev->ps.velocity[i] +
+      f * (next->ps.velocity[i] - prev->ps.velocity[i] );
+  }
+
+}
+
+/*
+===================
+CG_TouchItem
+===================
+*/
+static void CG_TouchItem( centity_t *cent ) {
+  gitem_t   *item;
+  int       ammo, clips, maxclips;
+
+  BG_unpackAmmoArray( item->giTag, cg.predictedPlayerState.ammo, cg.predictedPlayerState.powerups, &ammo, &clips, &maxclips );
+
+  if ( !cg_predictItems.integer ) {
+    return;
+  }
+  if ( !BG_PlayerTouchesItem( &cg.predictedPlayerState, &cent->currentState, cg.time ) ) {
+    return;
+  }
+
+  // never pick an item up twice in a prediction
+  if ( cent->miscTime == cg.time ) {
+    return;
+  }
+
+  if ( !BG_CanItemBeGrabbed( cgs.gametype, &cent->currentState, &cg.predictedPlayerState ) ) {
+    return;   // can't hold it
+  }
+
+  item = &bg_itemlist[ cent->currentState.modelindex ];
+
+  // grab it
+  BG_AddPredictableEventToPlayerstate( EV_ITEM_PICKUP, cent->currentState.modelindex , &cg.predictedPlayerState);
+
+  // remove it from the frame so it won't be drawn
+  cent->currentState.eFlags |= EF_NODRAW;
+
+  // don't touch it again this prediction
+  cent->miscTime = cg.time;
+
+  // if its a weapon, give them some predicted ammo so the autoswitch will work
+  if ( item->giType == IT_WEAPON ) {
+    BG_packWeapon( item->giTag, cg.predictedPlayerState.stats );
+    if ( ammo == 0 && clips == 0 ) {
+      BG_packAmmoArray( item->giTag, cg.predictedPlayerState.ammo, cg.predictedPlayerState.powerups, 1, 0, 0 );
+    }
+  }
+}
+
+
+/*
+=========================
+CG_TouchTriggerPrediction
+
+Predict push triggers and items
+=========================
+*/
+static void CG_TouchTriggerPrediction( void ) {
+  int     i;
+  trace_t   trace;
+  entityState_t *ent;
+  clipHandle_t cmodel;
+  centity_t *cent;
+  qboolean  spectator;
+
+  // dead clients don't activate triggers
+  if ( cg.predictedPlayerState.stats[STAT_HEALTH] <= 0 ) {
+    return;
+  }
+
+  spectator = ( cg.predictedPlayerState.pm_type == PM_SPECTATOR );
+
+  if ( cg.predictedPlayerState.pm_type != PM_NORMAL && !spectator ) {
+    return;
+  }
+
+  for ( i = 0 ; i < cg_numTriggerEntities ; i++ ) {
+    cent = cg_triggerEntities[ i ];
+    ent = &cent->currentState;
+
+    if ( ent->eType == ET_ITEM && !spectator ) {
+      CG_TouchItem( cent );
+      continue;
+    }
+
+    if ( ent->solid != SOLID_BMODEL ) {
+      continue;
+    }
+
+    cmodel = trap_CM_InlineModel( ent->modelindex );
+    if ( !cmodel ) {
+      continue;
+    }
+
+    trap_CM_BoxTrace( &trace, cg.predictedPlayerState.origin, cg.predictedPlayerState.origin,
+      cg_pmove.mins, cg_pmove.maxs, cmodel, -1 );
+
+    if ( !trace.startsolid ) {
+      continue;
+    }
+
+    if ( ent->eType == ET_TELEPORT_TRIGGER ) {
+      cg.hyperspace = qtrue;
+    } else if ( ent->eType == ET_PUSH_TRIGGER ) {
+      BG_TouchJumpPad( &cg.predictedPlayerState, ent );
+    }
+  }
+
+  // if we didn't touch a jump pad this pmove frame
+  if ( cg.predictedPlayerState.jumppad_frame != cg.predictedPlayerState.pmove_framecount ) {
+    cg.predictedPlayerState.jumppad_frame = 0;
+    cg.predictedPlayerState.jumppad_ent = 0;
+  }
+}
+
+
+
+/*
+=================
+CG_PredictPlayerState
+
+Generates cg.predictedPlayerState for the current cg.time
+cg.predictedPlayerState is guaranteed to be valid after exiting.
+
+For demo playback, this will be an interpolation between two valid
+playerState_t.
+
+For normal gameplay, it will be the result of predicted usercmd_t on
+top of the most recent playerState_t received from the server.
+
+Each new snapshot will usually have one or more new usercmd over the last,
+but we simulate all unacknowledged commands each time, not just the new ones.
+This means that on an internet connection, quite a few pmoves may be issued
+each frame.
+
+OPTIMIZE: don't re-simulate unless the newly arrived snapshot playerState_t
+differs from the predicted one.  Would require saving all intermediate
+playerState_t during prediction.
+
+We detect prediction errors and allow them to be decayed off over several frames
+to ease the jerk.
+=================
+*/
+void CG_PredictPlayerState( void ) {
+  int     cmdNum, current;
+  playerState_t oldPlayerState;
+  qboolean  moved;
+  usercmd_t oldestCmd;
+  usercmd_t latestCmd;
+
+  cg.hyperspace = qfalse; // will be set if touching a trigger_teleport
+
+  // if this is the first frame we must guarantee
+  // predictedPlayerState is valid even if there is some
+  // other error condition
+  if ( !cg.validPPS ) {
+    cg.validPPS = qtrue;
+    cg.predictedPlayerState = cg.snap->ps;
+  }
+
+
+  // demo playback just copies the moves
+  if ( cg.demoPlayback || (cg.snap->ps.pm_flags & PMF_FOLLOW) ) {
+    CG_InterpolatePlayerState( qfalse );
+    return;
+  }
+
+  // non-predicting local movement will grab the latest angles
+  if ( cg_nopredict.integer || cg_synchronousClients.integer ) {
+    CG_InterpolatePlayerState( qtrue );
+    return;
+  }
+
+  // prepare for pmove
+  cg_pmove.ps = &cg.predictedPlayerState;
+  cg_pmove.trace = CG_Trace;
+  cg_pmove.pointcontents = CG_PointContents;
+  if ( cg_pmove.ps->pm_type == PM_DEAD ) {
+    cg_pmove.tracemask = MASK_PLAYERSOLID & ~CONTENTS_BODY;
+  }
+  else {
+    cg_pmove.tracemask = MASK_PLAYERSOLID;
+  }
+  if ( cg.snap->ps.persistant[PERS_TEAM] == TEAM_SPECTATOR ) {
+    cg_pmove.tracemask &= ~CONTENTS_BODY; // spectators can fly through bodies
+  }
+  cg_pmove.noFootsteps = ( cgs.dmflags & DF_NO_FOOTSTEPS ) > 0;
+
+  // save the state before the pmove so we can detect transitions
+  oldPlayerState = cg.predictedPlayerState;
+
+  current = trap_GetCurrentCmdNumber();
+
+  // if we don't have the commands right after the snapshot, we
+  // can't accurately predict a current position, so just freeze at
+  // the last good position we had
+  cmdNum = current - CMD_BACKUP + 1;
+  trap_GetUserCmd( cmdNum, &oldestCmd );
+  if ( oldestCmd.serverTime > cg.snap->ps.commandTime
+    && oldestCmd.serverTime < cg.time ) { // special check for map_restart
+    if ( cg_showmiss.integer ) {
+      CG_Printf ("exceeded PACKET_BACKUP on commands\n");
+    }
+    return;
+  }
+
+  // get the latest command so we can know which commands are from previous map_restarts
+  trap_GetUserCmd( current, &latestCmd );
+
+  // get the most recent information we have, even if
+  // the server time is beyond our current cg.time,
+  // because predicted player positions are going to
+  // be ahead of everything else anyway
+  if ( cg.nextSnap && !cg.nextFrameTeleport && !cg.thisFrameTeleport ) {
+    cg.predictedPlayerState = cg.nextSnap->ps;
+    cg.physicsTime = cg.nextSnap->serverTime;
+  } else {
+    cg.predictedPlayerState = cg.snap->ps;
+    cg.physicsTime = cg.snap->serverTime;
+  }
+
+  if ( pmove_msec.integer < 8 ) {
+    trap_Cvar_Set("pmove_msec", "8");
+  }
+  else if (pmove_msec.integer > 33) {
+    trap_Cvar_Set("pmove_msec", "33");
+  }
+
+  cg_pmove.pmove_fixed = pmove_fixed.integer;// | cg_pmove_fixed.integer;
+  cg_pmove.pmove_msec = pmove_msec.integer;
+
+  // run cmds
+  moved = qfalse;
+  for ( cmdNum = current - CMD_BACKUP + 1 ; cmdNum <= current ; cmdNum++ ) {
+    // get the command
+    trap_GetUserCmd( cmdNum, &cg_pmove.cmd );
+
+    if ( cg_pmove.pmove_fixed ) {
+      PM_UpdateViewAngles( cg_pmove.ps, &cg_pmove.cmd );
+    }
+
+    // don't do anything if the time is before the snapshot player time
+    if ( cg_pmove.cmd.serverTime <= cg.predictedPlayerState.commandTime ) {
+      continue;
+    }
+
+    // don't do anything if the command was from a previous map_restart
+    if ( cg_pmove.cmd.serverTime > latestCmd.serverTime ) {
+      continue;
+    }
+
+    // check for a prediction error from last frame
+    // on a lan, this will often be the exact value
+    // from the snapshot, but on a wan we will have
+    // to predict several commands to get to the point
+    // we want to compare
+    if ( cg.predictedPlayerState.commandTime == oldPlayerState.commandTime ) {
+      vec3_t  delta;
+      float len;
+
+      if ( cg.thisFrameTeleport ) {
+        // a teleport will not cause an error decay
+        VectorClear( cg.predictedError );
+        if ( cg_showmiss.integer ) {
+          CG_Printf( "PredictionTeleport\n" );
+        }
+        cg.thisFrameTeleport = qfalse;
+      } else {
+        vec3_t  adjusted;
+        CG_AdjustPositionForMover( cg.predictedPlayerState.origin,
+          cg.predictedPlayerState.groundEntityNum, cg.physicsTime, cg.oldTime, adjusted );
+
+        if ( cg_showmiss.integer ) {
+          if (!VectorCompare( oldPlayerState.origin, adjusted )) {
+            CG_Printf("prediction error\n");
+          }
+        }
+        VectorSubtract( oldPlayerState.origin, adjusted, delta );
+        len = VectorLength( delta );
+        if ( len > 0.1 ) {
+          if ( cg_showmiss.integer ) {
+            CG_Printf("Prediction miss: %f\n", len);
+          }
+          if ( cg_errorDecay.integer ) {
+            int   t;
+            float f;
+
+            t = cg.time - cg.predictedErrorTime;
+            f = ( cg_errorDecay.value - t ) / cg_errorDecay.value;
+            if ( f < 0 ) {
+              f = 0;
+            }
+            if ( f > 0 && cg_showmiss.integer ) {
+              CG_Printf("Double prediction decay: %f\n", f);
+            }
+            VectorScale( cg.predictedError, f, cg.predictedError );
+          } else {
+            VectorClear( cg.predictedError );
+          }
+          VectorAdd( delta, cg.predictedError, cg.predictedError );
+          cg.predictedErrorTime = cg.oldTime;
+        }
+      }
+    }
+
+    // don't predict gauntlet firing, which is only supposed to happen
+    // when it actually inflicts damage
+    cg_pmove.gauntletHit = qfalse;
+
+    if ( cg_pmove.pmove_fixed ) {
+      cg_pmove.cmd.serverTime = ((cg_pmove.cmd.serverTime + pmove_msec.integer-1) / pmove_msec.integer) * pmove_msec.integer;
+    }
+
+    Pmove (&cg_pmove);
+
+    moved = qtrue;
+
+    // add push trigger movement effects
+    CG_TouchTriggerPrediction();
+
+    // check for predictable events that changed from previous predictions
+    //CG_CheckChangedPredictableEvents(&cg.predictedPlayerState);
+  }
+
+  if ( cg_showmiss.integer > 1 ) {
+    CG_Printf( "[%i : %i] ", cg_pmove.cmd.serverTime, cg.time );
+  }
+
+  if ( !moved ) {
+    if ( cg_showmiss.integer ) {
+      CG_Printf( "not moved\n" );
+    }
+    return;
+  }
+
+  // adjust for the movement of the groundentity
+  CG_AdjustPositionForMover( cg.predictedPlayerState.origin,
+    cg.predictedPlayerState.groundEntityNum,
+    cg.physicsTime, cg.time, cg.predictedPlayerState.origin );
+
+  if ( cg_showmiss.integer ) {
+    if (cg.predictedPlayerState.eventSequence > oldPlayerState.eventSequence + MAX_PS_EVENTS) {
+      CG_Printf("WARNING: dropped event\n");
+    }
+  }
+
+  // fire events and other transition triggered things
+  CG_TransitionPlayerState( &cg.predictedPlayerState, &oldPlayerState );
+
+  if ( cg_showmiss.integer ) {
+    if (cg.eventSequence > cg.predictedPlayerState.eventSequence) {
+      CG_Printf("WARNING: double event\n");
+      cg.eventSequence = cg.predictedPlayerState.eventSequence;
+    }
+  }
+}
+
+