newlines fixed

git-svn-id: svn://svn.icculus.org/quake3/trunk@6 edf5b092-35ff-0310-97b2-ce42778d08ea

1 files changed, 325 insertions, 325 deletions

diff --git a/code/game/bg_slidemove.c b/code/game/bg_slidemove.c
index ed1349f..6c957a5 100755
--- a/code/game/bg_slidemove.c
+++ b/code/game/bg_slidemove.c
@@ -1,325 +1,325 @@
-/*

-===========================================================================

-Copyright (C) 1999-2005 Id Software, Inc.

-

-This file is part of Quake III Arena source code.

-

-Quake III Arena source code 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.

-

-Quake III Arena source code 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 Foobar; if not, write to the Free Software

-Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

-===========================================================================

-*/

-//

-// bg_slidemove.c -- part of bg_pmove functionality

-

-#include "q_shared.h"

-#include "bg_public.h"

-#include "bg_local.h"

-

-/*

-

-input: origin, velocity, bounds, groundPlane, trace function

-

-output: origin, velocity, impacts, stairup boolean

-

-*/

-

-/*

-==================

-PM_SlideMove

-

-Returns qtrue if the velocity was clipped in some way

-==================

-*/

-#define	MAX_CLIP_PLANES	5

-qboolean	PM_SlideMove( qboolean gravity ) {

-	int			bumpcount, numbumps;

-	vec3_t		dir;

-	float		d;

-	int			numplanes;

-	vec3_t		planes[MAX_CLIP_PLANES];

-	vec3_t		primal_velocity;

-	vec3_t		clipVelocity;

-	int			i, j, k;

-	trace_t	trace;

-	vec3_t		end;

-	float		time_left;

-	float		into;

-	vec3_t		endVelocity;

-	vec3_t		endClipVelocity;

-	

-	numbumps = 4;

-

-	VectorCopy (pm->ps->velocity, primal_velocity);

-

-	if ( gravity ) {

-		VectorCopy( pm->ps->velocity, endVelocity );

-		endVelocity[2] -= pm->ps->gravity * pml.frametime;

-		pm->ps->velocity[2] = ( pm->ps->velocity[2] + endVelocity[2] ) * 0.5;

-		primal_velocity[2] = endVelocity[2];

-		if ( pml.groundPlane ) {

-			// slide along the ground plane

-			PM_ClipVelocity (pm->ps->velocity, pml.groundTrace.plane.normal, 

-				pm->ps->velocity, OVERCLIP );

-		}

-	}

-

-	time_left = pml.frametime;

-

-	// never turn against the ground plane

-	if ( pml.groundPlane ) {

-		numplanes = 1;

-		VectorCopy( pml.groundTrace.plane.normal, planes[0] );

-	} else {

-		numplanes = 0;

-	}

-

-	// never turn against original velocity

-	VectorNormalize2( pm->ps->velocity, planes[numplanes] );

-	numplanes++;

-

-	for ( bumpcount=0 ; bumpcount < numbumps ; bumpcount++ ) {

-

-		// calculate position we are trying to move to

-		VectorMA( pm->ps->origin, time_left, pm->ps->velocity, end );

-

-		// see if we can make it there

-		pm->trace ( &trace, pm->ps->origin, pm->mins, pm->maxs, end, pm->ps->clientNum, pm->tracemask);

-

-		if (trace.allsolid) {

-			// entity is completely trapped in another solid

-			pm->ps->velocity[2] = 0;	// don't build up falling damage, but allow sideways acceleration

-			return qtrue;

-		}

-

-		if (trace.fraction > 0) {

-			// actually covered some distance

-			VectorCopy (trace.endpos, pm->ps->origin);

-		}

-

-		if (trace.fraction == 1) {

-			 break;		// moved the entire distance

-		}

-

-		// save entity for contact

-		PM_AddTouchEnt( trace.entityNum );

-

-		time_left -= time_left * trace.fraction;

-

-		if (numplanes >= MAX_CLIP_PLANES) {

-			// this shouldn't really happen

-			VectorClear( pm->ps->velocity );

-			return qtrue;

-		}

-

-		//

-		// if this is the same plane we hit before, nudge velocity

-		// out along it, which fixes some epsilon issues with

-		// non-axial planes

-		//

-		for ( i = 0 ; i < numplanes ; i++ ) {

-			if ( DotProduct( trace.plane.normal, planes[i] ) > 0.99 ) {

-				VectorAdd( trace.plane.normal, pm->ps->velocity, pm->ps->velocity );

-				break;

-			}

-		}

-		if ( i < numplanes ) {

-			continue;

-		}

-		VectorCopy (trace.plane.normal, planes[numplanes]);

-		numplanes++;

-

-		//

-		// modify velocity so it parallels all of the clip planes

-		//

-

-		// find a plane that it enters

-		for ( i = 0 ; i < numplanes ; i++ ) {

-			into = DotProduct( pm->ps->velocity, planes[i] );

-			if ( into >= 0.1 ) {

-				continue;		// move doesn't interact with the plane

-			}

-

-			// see how hard we are hitting things

-			if ( -into > pml.impactSpeed ) {

-				pml.impactSpeed = -into;

-			}

-

-			// slide along the plane

-			PM_ClipVelocity (pm->ps->velocity, planes[i], clipVelocity, OVERCLIP );

-

-			// slide along the plane

-			PM_ClipVelocity (endVelocity, planes[i], endClipVelocity, OVERCLIP );

-

-			// see if there is a second plane that the new move enters

-			for ( j = 0 ; j < numplanes ; j++ ) {

-				if ( j == i ) {

-					continue;

-				}

-				if ( DotProduct( clipVelocity, planes[j] ) >= 0.1 ) {

-					continue;		// move doesn't interact with the plane

-				}

-

-				// try clipping the move to the plane

-				PM_ClipVelocity( clipVelocity, planes[j], clipVelocity, OVERCLIP );

-				PM_ClipVelocity( endClipVelocity, planes[j], endClipVelocity, OVERCLIP );

-

-				// see if it goes back into the first clip plane

-				if ( DotProduct( clipVelocity, planes[i] ) >= 0 ) {

-					continue;

-				}

-

-				// slide the original velocity along the crease

-				CrossProduct (planes[i], planes[j], dir);

-				VectorNormalize( dir );

-				d = DotProduct( dir, pm->ps->velocity );

-				VectorScale( dir, d, clipVelocity );

-

-				CrossProduct (planes[i], planes[j], dir);

-				VectorNormalize( dir );

-				d = DotProduct( dir, endVelocity );

-				VectorScale( dir, d, endClipVelocity );

-

-				// see if there is a third plane the the new move enters

-				for ( k = 0 ; k < numplanes ; k++ ) {

-					if ( k == i || k == j ) {

-						continue;

-					}

-					if ( DotProduct( clipVelocity, planes[k] ) >= 0.1 ) {

-						continue;		// move doesn't interact with the plane

-					}

-

-					// stop dead at a tripple plane interaction

-					VectorClear( pm->ps->velocity );

-					return qtrue;

-				}

-			}

-

-			// if we have fixed all interactions, try another move

-			VectorCopy( clipVelocity, pm->ps->velocity );

-			VectorCopy( endClipVelocity, endVelocity );

-			break;

-		}

-	}

-

-	if ( gravity ) {

-		VectorCopy( endVelocity, pm->ps->velocity );

-	}

-

-	// don't change velocity if in a timer (FIXME: is this correct?)

-	if ( pm->ps->pm_time ) {

-		VectorCopy( primal_velocity, pm->ps->velocity );

-	}

-

-	return ( bumpcount != 0 );

-}

-

-/*

-==================

-PM_StepSlideMove

-

-==================

-*/

-void PM_StepSlideMove( qboolean gravity ) {

-	vec3_t		start_o, start_v;

-	vec3_t		down_o, down_v;

-	trace_t		trace;

-//	float		down_dist, up_dist;

-//	vec3_t		delta, delta2;

-	vec3_t		up, down;

-	float		stepSize;

-

-	VectorCopy (pm->ps->origin, start_o);

-	VectorCopy (pm->ps->velocity, start_v);

-

-	if ( PM_SlideMove( gravity ) == 0 ) {

-		return;		// we got exactly where we wanted to go first try	

-	}

-

-	VectorCopy(start_o, down);

-	down[2] -= STEPSIZE;

-	pm->trace (&trace, start_o, pm->mins, pm->maxs, down, pm->ps->clientNum, pm->tracemask);

-	VectorSet(up, 0, 0, 1);

-	// never step up when you still have up velocity

-	if ( pm->ps->velocity[2] > 0 && (trace.fraction == 1.0 ||

-										DotProduct(trace.plane.normal, up) < 0.7)) {

-		return;

-	}

-

-	VectorCopy (pm->ps->origin, down_o);

-	VectorCopy (pm->ps->velocity, down_v);

-

-	VectorCopy (start_o, up);

-	up[2] += STEPSIZE;

-

-	// test the player position if they were a stepheight higher

-	pm->trace (&trace, start_o, pm->mins, pm->maxs, up, pm->ps->clientNum, pm->tracemask);

-	if ( trace.allsolid ) {

-		if ( pm->debugLevel ) {

-			Com_Printf("%i:bend can't step\n", c_pmove);

-		}

-		return;		// can't step up

-	}

-

-	stepSize = trace.endpos[2] - start_o[2];

-	// try slidemove from this position

-	VectorCopy (trace.endpos, pm->ps->origin);

-	VectorCopy (start_v, pm->ps->velocity);

-

-	PM_SlideMove( gravity );

-

-	// push down the final amount

-	VectorCopy (pm->ps->origin, down);

-	down[2] -= stepSize;

-	pm->trace (&trace, pm->ps->origin, pm->mins, pm->maxs, down, pm->ps->clientNum, pm->tracemask);

-	if ( !trace.allsolid ) {

-		VectorCopy (trace.endpos, pm->ps->origin);

-	}

-	if ( trace.fraction < 1.0 ) {

-		PM_ClipVelocity( pm->ps->velocity, trace.plane.normal, pm->ps->velocity, OVERCLIP );

-	}

-

-#if 0

-	// if the down trace can trace back to the original position directly, don't step

-	pm->trace( &trace, pm->ps->origin, pm->mins, pm->maxs, start_o, pm->ps->clientNum, pm->tracemask);

-	if ( trace.fraction == 1.0 ) {

-		// use the original move

-		VectorCopy (down_o, pm->ps->origin);

-		VectorCopy (down_v, pm->ps->velocity);

-		if ( pm->debugLevel ) {

-			Com_Printf("%i:bend\n", c_pmove);

-		}

-	} else 

-#endif

-	{

-		// use the step move

-		float	delta;

-

-		delta = pm->ps->origin[2] - start_o[2];

-		if ( delta > 2 ) {

-			if ( delta < 7 ) {

-				PM_AddEvent( EV_STEP_4 );

-			} else if ( delta < 11 ) {

-				PM_AddEvent( EV_STEP_8 );

-			} else if ( delta < 15 ) {

-				PM_AddEvent( EV_STEP_12 );

-			} else {

-				PM_AddEvent( EV_STEP_16 );

-			}

-		}

-		if ( pm->debugLevel ) {

-			Com_Printf("%i:stepped\n", c_pmove);

-		}

-	}

-}

-

+/*
+===========================================================================
+Copyright (C) 1999-2005 Id Software, Inc.
+
+This file is part of Quake III Arena source code.
+
+Quake III Arena source code 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.
+
+Quake III Arena source code 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 Foobar; if not, write to the Free Software
+Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+===========================================================================
+*/
+//
+// bg_slidemove.c -- part of bg_pmove functionality
+
+#include "q_shared.h"
+#include "bg_public.h"
+#include "bg_local.h"
+
+/*
+
+input: origin, velocity, bounds, groundPlane, trace function
+
+output: origin, velocity, impacts, stairup boolean
+
+*/
+
+/*
+==================
+PM_SlideMove
+
+Returns qtrue if the velocity was clipped in some way
+==================
+*/
+#define	MAX_CLIP_PLANES	5
+qboolean	PM_SlideMove( qboolean gravity ) {
+	int			bumpcount, numbumps;
+	vec3_t		dir;
+	float		d;
+	int			numplanes;
+	vec3_t		planes[MAX_CLIP_PLANES];
+	vec3_t		primal_velocity;
+	vec3_t		clipVelocity;
+	int			i, j, k;
+	trace_t	trace;
+	vec3_t		end;
+	float		time_left;
+	float		into;
+	vec3_t		endVelocity;
+	vec3_t		endClipVelocity;
+	
+	numbumps = 4;
+
+	VectorCopy (pm->ps->velocity, primal_velocity);
+
+	if ( gravity ) {
+		VectorCopy( pm->ps->velocity, endVelocity );
+		endVelocity[2] -= pm->ps->gravity * pml.frametime;
+		pm->ps->velocity[2] = ( pm->ps->velocity[2] + endVelocity[2] ) * 0.5;
+		primal_velocity[2] = endVelocity[2];
+		if ( pml.groundPlane ) {
+			// slide along the ground plane
+			PM_ClipVelocity (pm->ps->velocity, pml.groundTrace.plane.normal, 
+				pm->ps->velocity, OVERCLIP );
+		}
+	}
+
+	time_left = pml.frametime;
+
+	// never turn against the ground plane
+	if ( pml.groundPlane ) {
+		numplanes = 1;
+		VectorCopy( pml.groundTrace.plane.normal, planes[0] );
+	} else {
+		numplanes = 0;
+	}
+
+	// never turn against original velocity
+	VectorNormalize2( pm->ps->velocity, planes[numplanes] );
+	numplanes++;
+
+	for ( bumpcount=0 ; bumpcount < numbumps ; bumpcount++ ) {
+
+		// calculate position we are trying to move to
+		VectorMA( pm->ps->origin, time_left, pm->ps->velocity, end );
+
+		// see if we can make it there
+		pm->trace ( &trace, pm->ps->origin, pm->mins, pm->maxs, end, pm->ps->clientNum, pm->tracemask);
+
+		if (trace.allsolid) {
+			// entity is completely trapped in another solid
+			pm->ps->velocity[2] = 0;	// don't build up falling damage, but allow sideways acceleration
+			return qtrue;
+		}
+
+		if (trace.fraction > 0) {
+			// actually covered some distance
+			VectorCopy (trace.endpos, pm->ps->origin);
+		}
+
+		if (trace.fraction == 1) {
+			 break;		// moved the entire distance
+		}
+
+		// save entity for contact
+		PM_AddTouchEnt( trace.entityNum );
+
+		time_left -= time_left * trace.fraction;
+
+		if (numplanes >= MAX_CLIP_PLANES) {
+			// this shouldn't really happen
+			VectorClear( pm->ps->velocity );
+			return qtrue;
+		}
+
+		//
+		// if this is the same plane we hit before, nudge velocity
+		// out along it, which fixes some epsilon issues with
+		// non-axial planes
+		//
+		for ( i = 0 ; i < numplanes ; i++ ) {
+			if ( DotProduct( trace.plane.normal, planes[i] ) > 0.99 ) {
+				VectorAdd( trace.plane.normal, pm->ps->velocity, pm->ps->velocity );
+				break;
+			}
+		}
+		if ( i < numplanes ) {
+			continue;
+		}
+		VectorCopy (trace.plane.normal, planes[numplanes]);
+		numplanes++;
+
+		//
+		// modify velocity so it parallels all of the clip planes
+		//
+
+		// find a plane that it enters
+		for ( i = 0 ; i < numplanes ; i++ ) {
+			into = DotProduct( pm->ps->velocity, planes[i] );
+			if ( into >= 0.1 ) {
+				continue;		// move doesn't interact with the plane
+			}
+
+			// see how hard we are hitting things
+			if ( -into > pml.impactSpeed ) {
+				pml.impactSpeed = -into;
+			}
+
+			// slide along the plane
+			PM_ClipVelocity (pm->ps->velocity, planes[i], clipVelocity, OVERCLIP );
+
+			// slide along the plane
+			PM_ClipVelocity (endVelocity, planes[i], endClipVelocity, OVERCLIP );
+
+			// see if there is a second plane that the new move enters
+			for ( j = 0 ; j < numplanes ; j++ ) {
+				if ( j == i ) {
+					continue;
+				}
+				if ( DotProduct( clipVelocity, planes[j] ) >= 0.1 ) {
+					continue;		// move doesn't interact with the plane
+				}
+
+				// try clipping the move to the plane
+				PM_ClipVelocity( clipVelocity, planes[j], clipVelocity, OVERCLIP );
+				PM_ClipVelocity( endClipVelocity, planes[j], endClipVelocity, OVERCLIP );
+
+				// see if it goes back into the first clip plane
+				if ( DotProduct( clipVelocity, planes[i] ) >= 0 ) {
+					continue;
+				}
+
+				// slide the original velocity along the crease
+				CrossProduct (planes[i], planes[j], dir);
+				VectorNormalize( dir );
+				d = DotProduct( dir, pm->ps->velocity );
+				VectorScale( dir, d, clipVelocity );
+
+				CrossProduct (planes[i], planes[j], dir);
+				VectorNormalize( dir );
+				d = DotProduct( dir, endVelocity );
+				VectorScale( dir, d, endClipVelocity );
+
+				// see if there is a third plane the the new move enters
+				for ( k = 0 ; k < numplanes ; k++ ) {
+					if ( k == i || k == j ) {
+						continue;
+					}
+					if ( DotProduct( clipVelocity, planes[k] ) >= 0.1 ) {
+						continue;		// move doesn't interact with the plane
+					}
+
+					// stop dead at a tripple plane interaction
+					VectorClear( pm->ps->velocity );
+					return qtrue;
+				}
+			}
+
+			// if we have fixed all interactions, try another move
+			VectorCopy( clipVelocity, pm->ps->velocity );
+			VectorCopy( endClipVelocity, endVelocity );
+			break;
+		}
+	}
+
+	if ( gravity ) {
+		VectorCopy( endVelocity, pm->ps->velocity );
+	}
+
+	// don't change velocity if in a timer (FIXME: is this correct?)
+	if ( pm->ps->pm_time ) {
+		VectorCopy( primal_velocity, pm->ps->velocity );
+	}
+
+	return ( bumpcount != 0 );
+}
+
+/*
+==================
+PM_StepSlideMove
+
+==================
+*/
+void PM_StepSlideMove( qboolean gravity ) {
+	vec3_t		start_o, start_v;
+	vec3_t		down_o, down_v;
+	trace_t		trace;
+//	float		down_dist, up_dist;
+//	vec3_t		delta, delta2;
+	vec3_t		up, down;
+	float		stepSize;
+
+	VectorCopy (pm->ps->origin, start_o);
+	VectorCopy (pm->ps->velocity, start_v);
+
+	if ( PM_SlideMove( gravity ) == 0 ) {
+		return;		// we got exactly where we wanted to go first try	
+	}
+
+	VectorCopy(start_o, down);
+	down[2] -= STEPSIZE;
+	pm->trace (&trace, start_o, pm->mins, pm->maxs, down, pm->ps->clientNum, pm->tracemask);
+	VectorSet(up, 0, 0, 1);
+	// never step up when you still have up velocity
+	if ( pm->ps->velocity[2] > 0 && (trace.fraction == 1.0 ||
+										DotProduct(trace.plane.normal, up) < 0.7)) {
+		return;
+	}
+
+	VectorCopy (pm->ps->origin, down_o);
+	VectorCopy (pm->ps->velocity, down_v);
+
+	VectorCopy (start_o, up);
+	up[2] += STEPSIZE;
+
+	// test the player position if they were a stepheight higher
+	pm->trace (&trace, start_o, pm->mins, pm->maxs, up, pm->ps->clientNum, pm->tracemask);
+	if ( trace.allsolid ) {
+		if ( pm->debugLevel ) {
+			Com_Printf("%i:bend can't step\n", c_pmove);
+		}
+		return;		// can't step up
+	}
+
+	stepSize = trace.endpos[2] - start_o[2];
+	// try slidemove from this position
+	VectorCopy (trace.endpos, pm->ps->origin);
+	VectorCopy (start_v, pm->ps->velocity);
+
+	PM_SlideMove( gravity );
+
+	// push down the final amount
+	VectorCopy (pm->ps->origin, down);
+	down[2] -= stepSize;
+	pm->trace (&trace, pm->ps->origin, pm->mins, pm->maxs, down, pm->ps->clientNum, pm->tracemask);
+	if ( !trace.allsolid ) {
+		VectorCopy (trace.endpos, pm->ps->origin);
+	}
+	if ( trace.fraction < 1.0 ) {
+		PM_ClipVelocity( pm->ps->velocity, trace.plane.normal, pm->ps->velocity, OVERCLIP );
+	}
+
+#if 0
+	// if the down trace can trace back to the original position directly, don't step
+	pm->trace( &trace, pm->ps->origin, pm->mins, pm->maxs, start_o, pm->ps->clientNum, pm->tracemask);
+	if ( trace.fraction == 1.0 ) {
+		// use the original move
+		VectorCopy (down_o, pm->ps->origin);
+		VectorCopy (down_v, pm->ps->velocity);
+		if ( pm->debugLevel ) {
+			Com_Printf("%i:bend\n", c_pmove);
+		}
+	} else 
+#endif
+	{
+		// use the step move
+		float	delta;
+
+		delta = pm->ps->origin[2] - start_o[2];
+		if ( delta > 2 ) {
+			if ( delta < 7 ) {
+				PM_AddEvent( EV_STEP_4 );
+			} else if ( delta < 11 ) {
+				PM_AddEvent( EV_STEP_8 );
+			} else if ( delta < 15 ) {
+				PM_AddEvent( EV_STEP_12 );
+			} else {
+				PM_AddEvent( EV_STEP_16 );
+			}
+		}
+		if ( pm->debugLevel ) {
+			Com_Printf("%i:stepped\n", c_pmove);
+		}
+	}
+}
+