quakeforge/nq/source/sv_cl_phys.c

/*
	sv_phys.c

	@description@

	Copyright (C) 1996-1997  Id Software, Inc.

	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
	of the License, 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:

		Free Software Foundation, Inc.
		59 Temple Place - Suite 330
		Boston, MA  02111-1307, USA

*/
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif

static __attribute__ ((unused)) const char rcsid[] = 
	"$Id$";

#include "QF/console.h"
#include "QF/cvar.h"
#include "QF/sys.h"

#include "host.h"
#include "server.h"
#include "sv_progs.h"
#include "world.h"

#define sv_frametime host_frametime


// CLIENT MOVEMENT ============================================================

/*
  SV_CheckStuck

  This is a big hack to try and fix the rare case of getting stuck in the world
  clipping hull.
*/
static void
SV_CheckStuck (edict_t *ent)
{
	int         i, j, z;
	vec3_t      org;

	if (!SV_TestEntityPosition (ent)) {
		VectorCopy (SVvector (ent, origin), SVvector (ent, oldorigin));
		return;
	}

	VectorCopy (SVvector (ent, origin), org);
	VectorCopy (SVvector (ent, oldorigin), SVvector (ent, origin));
	if (!SV_TestEntityPosition (ent)) {
		Con_DPrintf ("Unstuck.\n");
		SV_LinkEdict (ent, true);
		return;
	}

	for (z = 0; z < 18; z++)
		for (i = -1; i <= 1; i++)
			for (j = -1; j <= 1; j++) {
				SVvector (ent, origin)[0] = org[0] + i;
				SVvector (ent, origin)[1] = org[1] + j;
				SVvector (ent, origin)[2] = org[2] + z;
				if (!SV_TestEntityPosition (ent)) {
					Con_DPrintf ("Unstuck.\n");
					SV_LinkEdict (ent, true);
					return;
				}
			}

	VectorCopy (org, SVvector (ent, origin));
	Con_DPrintf ("player is stuck.\n");
}

static qboolean
SV_CheckWater (edict_t *ent)
{
	int         cont;
	vec3_t      point;

	point[0] = SVvector (ent, origin)[0];
	point[1] = SVvector (ent, origin)[1];
	point[2] = SVvector (ent, origin)[2] + SVvector (ent, mins)[2] + 1;

	SVfloat (ent, waterlevel) = 0;
	SVfloat (ent, watertype) = CONTENTS_EMPTY;
	cont = SV_PointContents (point);
	if (cont <= CONTENTS_WATER) {
		SVfloat (ent, watertype) = cont;
		SVfloat (ent, waterlevel) = 1;
		point[2] = SVvector (ent, origin)[2] + (SVvector (ent, mins)[2] +
												SVvector (ent, maxs)[2]) * 0.5;
		cont = SV_PointContents (point);
		if (cont <= CONTENTS_WATER) {
			SVfloat (ent, waterlevel) = 2;
			point[2] = SVvector (ent, origin)[2] + SVvector (ent, view_ofs)[2];
			cont = SV_PointContents (point);
			if (cont <= CONTENTS_WATER)
				SVfloat (ent, waterlevel) = 3;
		}
	}

	return SVfloat (ent, waterlevel) > 1;
}

static void
SV_WallFriction (edict_t *ent, trace_t *trace)
{
	float       d, i;
	vec3_t      forward, right, up, into, side;

	AngleVectors (SVvector (ent, v_angle), forward, right, up);
	d = DotProduct (trace->plane.normal, forward);

	d += 0.5;
	if (d >= 0)
		return;

	// cut the tangential velocity
	i = DotProduct (trace->plane.normal, SVvector (ent, velocity));
	VectorScale (trace->plane.normal, i, into);
	VectorSubtract (SVvector (ent, velocity), into, side);

	SVvector (ent, velocity)[0] = side[0] * (1 + d);
	SVvector (ent, velocity)[1] = side[1] * (1 + d);
}

/*
  SV_TryUnstick

  Player has come to a dead stop, possibly due to the problem with limited
  float precision at some angle joins in the BSP hull.

  Try fixing by pushing one pixel in each direction.

  This is a hack, but in the interest of good gameplay...
*/
static int
SV_TryUnstick (edict_t *ent, vec3_t oldvel)
{
	int         i, clip;
	vec3_t      dir, oldorg;
	trace_t     steptrace;

	VectorCopy (SVvector (ent, origin), oldorg);
	VectorCopy (vec3_origin, dir);

	for (i = 0; i < 8; i++) {
		// try pushing a little in an axial direction
		switch (i) {
		case 0:
			dir[0] = 2;
			dir[1] = 0;
			break;
		case 1:
			dir[0] = 0;
			dir[1] = 2;
			break;
		case 2:
			dir[0] = -2;
			dir[1] = 0;
			break;
		case 3:
			dir[0] = 0;
			dir[1] = -2;
			break;
		case 4:
			dir[0] = 2;
			dir[1] = 2;
			break;
		case 5:
			dir[0] = -2;
			dir[1] = 2;
			break;
		case 6:
			dir[0] = 2;
			dir[1] = -2;
			break;
		case 7:
			dir[0] = -2;
			dir[1] = -2;
			break;
		}

		SV_PushEntity (ent, dir);

		// retry the original move
		SVvector (ent, velocity)[0] = oldvel[0];
		SVvector (ent, velocity)[1] = oldvel[1];
		SVvector (ent, velocity)[2] = 0;
		clip = SV_FlyMove (ent, 0.1, &steptrace);

		if (fabs (oldorg[1] - SVvector (ent, origin)[1]) > 4
			|| fabs (oldorg[0] - SVvector (ent, origin)[0]) > 4) {
//			Con_DPrintf ("unstuck!\n");
			return clip;
		}
		// go back to the original pos and try again
		VectorCopy (oldorg, SVvector (ent, origin));
	}

	VectorCopy (vec3_origin, SVvector (ent, velocity));
	return 7;							// still not moving
}

#define	STEPSIZE	18

/*
  SV_WalkMove

  Only used by players
*/
static void
SV_WalkMove (edict_t *ent)
{
	int         clip, oldonground;
	vec3_t      upmove, downmove, nosteporg, nostepvel, oldorg, oldvel;
	trace_t     steptrace, downtrace;

	// do a regular slide move unless it looks like you ran into a step
	oldonground = (int) SVfloat (ent, flags) & FL_ONGROUND;
	SVfloat (ent, flags) = (int) SVfloat (ent, flags) & ~FL_ONGROUND;

	VectorCopy (SVvector (ent, origin), oldorg);
	VectorCopy (SVvector (ent, velocity), oldvel);

	clip = SV_FlyMove (ent, sv_frametime, &steptrace);

	if (!(clip & 2))
		return;							// move didn't block on a step

	if (!oldonground && SVfloat (ent, waterlevel) == 0)
		return;							// don't stair up while jumping

	if (SVfloat (ent, movetype) != MOVETYPE_WALK)
		return;							// gibbed by a trigger

	if (sv_nostep->int_val)
		return;

	if ((int) SVfloat (sv_player, flags) & FL_WATERJUMP)
		return;

	VectorCopy (SVvector (ent, origin), nosteporg);
	VectorCopy (SVvector (ent, velocity), nostepvel);

	// try moving up and forward to go up a step
	VectorCopy (oldorg, SVvector (ent, origin));	// back to start pos
	VectorCopy (vec3_origin, upmove);
	VectorCopy (vec3_origin, downmove);
	upmove[2] = STEPSIZE;
	downmove[2] = -STEPSIZE + oldvel[2] * sv_frametime;

	// move up
	SV_PushEntity (ent, upmove);		// FIXME: don't link?

	// move forward
	SVvector (ent, velocity)[0] = oldvel[0];
	SVvector (ent, velocity)[1] = oldvel[1];
	SVvector (ent, velocity)[2] = 0;
	clip = SV_FlyMove (ent, sv_frametime, &steptrace);

	// check for stuckness, possibly due to the limited precision of floats
	// in the clipping hulls
	if (clip) {
		if (fabs (oldorg[1] - SVvector (ent, origin)[1]) < 0.03125
			&& fabs (oldorg[0] - SVvector (ent, origin)[0]) < 0.03125) {
			// stepping up didn't make any progress
			clip = SV_TryUnstick (ent, oldvel);
		}
	}
	// extra friction based on view angle
	if (clip & 2)
		SV_WallFriction (ent, &steptrace);

	// move down
	downtrace = SV_PushEntity (ent, downmove);	// FIXME: don't link?

	if (downtrace.plane.normal[2] > 0.7) {
		if (SVfloat (ent, solid) == SOLID_BSP) {
			SVfloat (ent, flags) = (int) SVfloat (ent, flags) | FL_ONGROUND;
			SVfloat (ent, groundentity) = EDICT_TO_PROG (&sv_pr_state,
														 downtrace.ent);
		}
	} else {
		// if the push down didn't end up on good ground, use the move without
		// the step up.  This happens near wall / slope combinations, and can
		// cause the player to hop up higher on a slope too steep to climb  
		VectorCopy (nosteporg, SVvector (ent, origin));
		VectorCopy (nostepvel, SVvector (ent, velocity));
	}
}

/*
  SV_Physics_Client

  Player character actions
*/
void
SV_Physics_Client (edict_t *ent, int num)
{
	if (!svs.clients[num - 1].active)
		return;							// unconnected slot

	// call standard client pre-think
	*sv_globals.time = sv.time;
	*sv_globals.self = EDICT_TO_PROG (&sv_pr_state, ent);
	PR_ExecuteProgram (&sv_pr_state, sv_funcs.PlayerPreThink);

	// do a move
	SV_CheckVelocity (ent);

	// decide which move function to call
	switch ((int) SVfloat (ent, movetype)) {
	case MOVETYPE_NONE:
		if (!SV_RunThink (ent))
			return;
		break;

	case MOVETYPE_WALK:
		if (!SV_RunThink (ent))
			return;
		if (!SV_CheckWater (ent) && !((int) SVfloat (ent, flags) &
									  FL_WATERJUMP))
			SV_AddGravity (ent);
		SV_CheckStuck (ent);
		SV_WalkMove (ent);
		break;

	case MOVETYPE_TOSS:
	case MOVETYPE_BOUNCE:
		SV_Physics_Toss (ent);
		break;

	case MOVETYPE_FLY:
		if (!SV_RunThink (ent))
			return;
		SV_FlyMove (ent, sv_frametime, NULL);
		break;

	case MOVETYPE_NOCLIP:
		if (!SV_RunThink (ent))
			return;
		VectorMA (SVvector (ent, origin), sv_frametime, SVvector (ent, velocity),
				  SVvector (ent, origin));
		break;

	default:
		Sys_Error ("SV_Physics_client: bad movetype %i",
				   (int) SVfloat (ent, movetype));
	}

	// call standard player post-think
	SV_LinkEdict (ent, true);

	*sv_globals.time = sv.time;
	*sv_globals.self = EDICT_TO_PROG (&sv_pr_state, ent);
	PR_ExecuteProgram (&sv_pr_state, sv_funcs.PlayerPostThink);
}