rq3/reaction
0
0
Fork 0
mirror of https://github.com/ReactionQuake3/reaction.git synced 2024-11-10 07:11:36 +00:00
Code Issues Projects Releases Packages Wiki Activity
reaction/code/cgame/cg_unlagged.c
Richard Allen b6ae8af89f Moving everything up one folder.
2013-01-04 13:27:22 +00:00

420 lines
12 KiB
C
Raw Blame History

//-----------------------------------------------------------------------------
//
// $Id$
//
//-----------------------------------------------------------------------------
//
// $Log$
// Revision 1.3 2003/04/19 15:27:30 jbravo
// Backing out of most of unlagged. Only optimized prediction and smooth clients
// remains.
//
// Revision 1.2 2003/03/10 07:07:58 jbravo
// Small unlagged fixes and voting delay added.
//
// Revision 1.1 2003/03/09 21:32:23 jbravo
// *** empty log message ***
//
//
//-----------------------------------------------------------------------------
#include "cg_local.h"
// we'll need these prototypes
//void CG_ShotgunPattern(vec3_t origin, vec3_t origin2, int seed, int otherEntNum);
//void CG_Bullet(vec3_t end, int sourceEntityNum, vec3_t normal, qboolean flesh, int fleshEntityNum);
// and this as well
//#define MACHINEGUN_SPREAD 200
/*
=======================
CG_PredictWeaponEffects
Draws predicted effects for the railgun, shotgun, and machinegun. The
lightning gun is done in CG_LightningBolt, since it was just a matter
of setting the right origin and angles.
=======================
*/
/*void CG_PredictWeaponEffects(centity_t * cent)
{
vec3_t muzzlePoint, forward, right, up;
entityState_t *ent = &cent->currentState;
// if the client isn't us, forget it
if (cent->currentState.number != cg.predictedPlayerState.clientNum) {
return;
}
// if it's not switched on server-side, forget it
if (!cgs.delagHitscan) {
return;
}
// get the muzzle point
VectorCopy(cg.predictedPlayerState.origin, muzzlePoint);
muzzlePoint[2] += cg.predictedPlayerState.viewheight;
// get forward, right, and up
AngleVectors(cg.predictedPlayerState.viewangles, forward, right, up);
VectorMA(muzzlePoint, 14, forward, muzzlePoint);
// was it a rail attack?
if (ent->weapon == WP_SSG3000) {
// do we have it on for the rail gun?
if (cg_delag.integer & 1 || cg_delag.integer & 16) {
trace_t trace;
vec3_t endPoint;
// trace forward
VectorMA(muzzlePoint, 8192, forward, endPoint);
// THIS IS FOR DEBUGGING!
// you definitely *will* want something like this to test the backward reconciliation
// to make sure it's working *exactly* right
if (cg_debugDelag.integer) {
// trace forward
CG_Trace(&trace, muzzlePoint, vec3_origin, vec3_origin, endPoint,
cent->currentState.number, CONTENTS_BODY | CONTENTS_SOLID);
// did we hit another player?
if (trace.fraction < 1.0f && (trace.contents & CONTENTS_BODY)) {
// if we have two snapshots (we're interpolating)
if (cg.nextSnap) {
centity_t *c = &cg_entities[trace.entityNum];
vec3_t origin1, origin2;
// figure the two origins used for interpolation
BG_EvaluateTrajectory(&c->currentState.pos, cg.snap->serverTime,
origin1);
BG_EvaluateTrajectory(&c->nextState.pos, cg.nextSnap->serverTime,
origin2);
// print some debugging stuff exactly like what the server does
// it starts with "Int:" to let you know the target was interpolated
CG_Printf("^3Int: time: %d, j: %d, k: %d, origin: %0.2f %0.2f %0.2f\n",
cg.oldTime, cg.snap->serverTime, cg.nextSnap->serverTime,
c->lerpOrigin[0], c->lerpOrigin[1], c->lerpOrigin[2]);
CG_Printf
("^5frac: %0.4f, origin1: %0.2f %0.2f %0.2f, origin2: %0.2f %0.2f %0.2f\n",
cg.frameInterpolation, origin1[0], origin1[1], origin1[2],
origin2[0], origin2[1], origin2[2]);
} else {
// we haven't got a next snapshot
// the client clock has either drifted ahead (seems to happen once per server frame
// when you play locally) or the client is using timenudge
// in any case, CG_CalcEntityLerpPositions extrapolated rather than interpolated
centity_t *c = &cg_entities[trace.entityNum];
vec3_t origin1, origin2;
c->currentState.pos.trTime = TR_LINEAR_STOP;
c->currentState.pos.trTime = cg.snap->serverTime;
c->currentState.pos.trDuration = 1000 / sv_fps.integer;
BG_EvaluateTrajectory(&c->currentState.pos, cg.snap->serverTime,
origin1);
BG_EvaluateTrajectory(&c->currentState.pos,
cg.snap->serverTime + 1000 / sv_fps.integer,
origin2);
// print some debugging stuff exactly like what the server does
// it starts with "Ext:" to let you know the target was extrapolated
CG_Printf("^3Ext: time: %d, j: %d, k: %d, origin: %0.2f %0.2f %0.2f\n",
cg.oldTime, cg.snap->serverTime, cg.snap->serverTime,
c->lerpOrigin[0], c->lerpOrigin[1], c->lerpOrigin[2]);
CG_Printf
("^5frac: %0.4f, origin1: %0.2f %0.2f %0.2f, origin2: %0.2f %0.2f %0.2f\n",
cg.frameInterpolation, origin1[0], origin1[1], origin1[2],
origin2[0], origin2[1], origin2[2]);
}
}
}
// find the rail's end point
CG_Trace(&trace, muzzlePoint, vec3_origin, vec3_origin, endPoint,
cg.predictedPlayerState.clientNum, CONTENTS_SOLID);
// do the magic-number adjustment
VectorMA(muzzlePoint, 4, right, muzzlePoint);
VectorMA(muzzlePoint, -1, up, muzzlePoint);
// draw a rail trail
// CG_RailTrail(&cgs.clientinfo[cent->currentState.number], muzzlePoint, trace.endpos);
//Com_Printf( "Predicted rail trail\n" );
// explosion at end if not SURF_NOIMPACT
if (!(trace.surfaceFlags & SURF_NOIMPACT)) {
// predict an explosion
CG_MissileHitWall(ent->weapon, cg.predictedPlayerState.clientNum, trace.endpos,
trace.plane.normal, IMPACTSOUND_DEFAULT, 0);
}
}
}
// was it a shotgun attack?
else if (ent->weapon == WP_M3 || ent->weapon == WP_HANDCANNON) {
// do we have it on for the shotgun?
if (cg_delag.integer & 1 || cg_delag.integer & 4) {
int contents;
vec3_t endPoint, v;
// do everything like the server does
SnapVector(muzzlePoint);
VectorScale(forward, 4096, endPoint);
SnapVector(endPoint);
VectorSubtract(endPoint, muzzlePoint, v);
VectorNormalize(v);
VectorScale(v, 32, v);
VectorAdd(muzzlePoint, v, v);
if (cgs.glconfig.hardwareType != GLHW_RAGEPRO) {
// ragepro can't alpha fade, so don't even bother with smoke
vec3_t up;
contents = trap_CM_PointContents(muzzlePoint, 0);
if (!(contents & CONTENTS_WATER)) {
VectorSet(up, 0, 0, 8);
CG_SmokePuff(v, up, 32, 1, 1, 1, 0.33f, 900, cg.time, 0, LEF_PUFF_DONT_SCALE,
cgs.media.shotgunSmokePuffShader);
}
}
// do the shotgun pellets
CG_ShotgunPattern(muzzlePoint, endPoint, cg.oldTime % 256, cg.predictedPlayerState.clientNum);
//Com_Printf( "Predicted shotgun pattern\n" );
}
}
// was it a machinegun attack?
else if (ent->weapon == WP_MP5 || ent->weapon == WP_M4 || ent->weapon == WP_PISTOL || ent->weapon == WP_AKIMBO) {
// do we have it on for the machinegun?
if (cg_delag.integer & 1 || cg_delag.integer & 2) {
// the server will use this exact time (it'll be serverTime on that end)
int seed = cg.oldTime % 256;
float r, u;
trace_t tr;
qboolean flesh;
int fleshEntityNum;
vec3_t endPoint;
// do everything exactly like the server does
r = Q_random(&seed) * M_PI * 2.0f;
u = sin(r) * Q_crandom(&seed) * MACHINEGUN_SPREAD * 16;
r = cos(r) * Q_crandom(&seed) * MACHINEGUN_SPREAD * 16;
VectorMA(muzzlePoint, 8192 * 16, forward, endPoint);
VectorMA(endPoint, r, right, endPoint);
VectorMA(endPoint, u, up, endPoint);
CG_Trace(&tr, muzzlePoint, NULL, NULL, endPoint, cg.predictedPlayerState.clientNum, MASK_SHOT);
if (tr.surfaceFlags & SURF_NOIMPACT) {
return;
}
// snap the endpos to integers, but nudged towards the line
SnapVectorTowards(tr.endpos, muzzlePoint);
// do bullet impact
if (tr.entityNum < MAX_CLIENTS) {
flesh = qtrue;
fleshEntityNum = tr.entityNum;
} else {
flesh = qfalse;
}
// do the bullet impact
CG_Bullet(tr.endpos, cg.predictedPlayerState.clientNum, tr.plane.normal, flesh, fleshEntityNum, IMPACTSOUND_DEFAULT);
//Com_Printf( "Predicted bullet\n" );
}
}
} */
/*
=================
CG_AddBoundingBox
Draws a bounding box around a player. Called from CG_Player.
=================
*/
void CG_AddBoundingBox(centity_t * cent)
{
polyVert_t verts[4];
clientInfo_t *ci;
int i;
vec3_t mins = { -15, -15, -24 };
vec3_t maxs = { 15, 15, 32 };
float extx, exty, extz;
vec3_t corners[8];
qhandle_t bboxShader, bboxShader_nocull;
if (!cg_drawBBox.integer) {
return;
}
// don't draw it if it's us in first-person
if (cent->currentState.number == cg.predictedPlayerState.clientNum && !cg.renderingThirdPerson) {
return;
}
// don't draw it for dead players
if (cent->currentState.eFlags & EF_DEAD) {
return;
}
// get the shader handles
bboxShader = trap_R_RegisterShader("bbox");
bboxShader_nocull = trap_R_RegisterShader("bbox_nocull");
// if they don't exist, forget it
if (!bboxShader || !bboxShader_nocull) {
return;
}
// get the player's client info
ci = &cgs.clientinfo[cent->currentState.clientNum];
// if it's us
if (cent->currentState.number == cg.predictedPlayerState.clientNum) {
// use the view height
maxs[2] = cg.predictedPlayerState.viewheight + 6;
} else {
int x, zd, zu;
// otherwise grab the encoded bounding box
x = (cent->currentState.solid & 255);
zd = ((cent->currentState.solid >> 8) & 255);
zu = ((cent->currentState.solid >> 16) & 255) - 32;
mins[0] = mins[1] = -x;
maxs[0] = maxs[1] = x;
mins[2] = -zd;
maxs[2] = zu;
}
// get the extents (size)
extx = maxs[0] - mins[0];
exty = maxs[1] - mins[1];
extz = maxs[2] - mins[2];
// set the polygon's texture coordinates
verts[0].st[0] = 0;
verts[0].st[1] = 0;
verts[1].st[0] = 0;
verts[1].st[1] = 1;
verts[2].st[0] = 1;
verts[2].st[1] = 1;
verts[3].st[0] = 1;
verts[3].st[1] = 0;
// set the polygon's vertex colors
if (ci->team == TEAM_RED) {
for (i = 0; i < 4; i++) {
verts[i].modulate[0] = 160;
verts[i].modulate[1] = 0;
verts[i].modulate[2] = 0;
verts[i].modulate[3] = 255;
}
} else if (ci->team == TEAM_BLUE) {
for (i = 0; i < 4; i++) {
verts[i].modulate[0] = 0;
verts[i].modulate[1] = 0;
verts[i].modulate[2] = 192;
verts[i].modulate[3] = 255;
}
} else {
for (i = 0; i < 4; i++) {
verts[i].modulate[0] = 0;
verts[i].modulate[1] = 128;
verts[i].modulate[2] = 0;
verts[i].modulate[3] = 255;
}
}
VectorAdd(cent->lerpOrigin, maxs, corners[3]);
VectorCopy(corners[3], corners[2]);
corners[2][0] -= extx;
VectorCopy(corners[2], corners[1]);
corners[1][1] -= exty;
VectorCopy(corners[1], corners[0]);
corners[0][0] += extx;
for (i = 0; i < 4; i++) {
VectorCopy(corners[i], corners[i + 4]);
corners[i + 4][2] -= extz;
}
// top
VectorCopy(corners[0], verts[0].xyz);
VectorCopy(corners[1], verts[1].xyz);
VectorCopy(corners[2], verts[2].xyz);
VectorCopy(corners[3], verts[3].xyz);
trap_R_AddPolyToScene(bboxShader, 4, verts);
// bottom
VectorCopy(corners[7], verts[0].xyz);
VectorCopy(corners[6], verts[1].xyz);
VectorCopy(corners[5], verts[2].xyz);
VectorCopy(corners[4], verts[3].xyz);
trap_R_AddPolyToScene(bboxShader, 4, verts);
// top side
VectorCopy(corners[3], verts[0].xyz);
VectorCopy(corners[2], verts[1].xyz);
VectorCopy(corners[6], verts[2].xyz);
VectorCopy(corners[7], verts[3].xyz);
trap_R_AddPolyToScene(bboxShader_nocull, 4, verts);
// left side
VectorCopy(corners[2], verts[0].xyz);
VectorCopy(corners[1], verts[1].xyz);
VectorCopy(corners[5], verts[2].xyz);
VectorCopy(corners[6], verts[3].xyz);
trap_R_AddPolyToScene(bboxShader_nocull, 4, verts);
// right side
VectorCopy(corners[0], verts[0].xyz);
VectorCopy(corners[3], verts[1].xyz);
VectorCopy(corners[7], verts[2].xyz);
VectorCopy(corners[4], verts[3].xyz);
trap_R_AddPolyToScene(bboxShader_nocull, 4, verts);
// bottom side
VectorCopy(corners[1], verts[0].xyz);
VectorCopy(corners[0], verts[1].xyz);
VectorCopy(corners[4], verts[2].xyz);
VectorCopy(corners[5], verts[3].xyz);
trap_R_AddPolyToScene(bboxShader_nocull, 4, verts);
}
/*
================
CG_Cvar_ClampInt
Clamps a cvar between two integer values, returns qtrue if it had to.
================
*/
qboolean CG_Cvar_ClampInt(const char *name, vmCvar_t * vmCvar, int min, int max)
{
if (vmCvar->integer > max) {
CG_Printf("Allowed values are %d to %d.\n", min, max);
Com_sprintf(vmCvar->string, MAX_CVAR_VALUE_STRING, "%d", max);
vmCvar->value = max;
vmCvar->integer = max;
trap_Cvar_Set(name, vmCvar->string);
return qtrue;
}
if (vmCvar->integer < min) {
CG_Printf("Allowed values are %d to %d.\n", min, max);
Com_sprintf(vmCvar->string, MAX_CVAR_VALUE_STRING, "%d", min);
vmCvar->value = min;
vmCvar->integer = min;
trap_Cvar_Set(name, vmCvar->string);
return qtrue;
}
return qfalse;
}
Reference in a new issue View git blame Copy permalink