//-----------------------------------------------------------------------------
//
// $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;
}