Subversion Repositories Kolibri OS

/*

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 the Free Software

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

*/

// world.c -- world query functions

#include "quakedef.h"

/*

entities never clip against themselves, or their owner

line of sight checks trace->crosscontent, but bullets don't

*/

typedef struct

{

	vec3_t		boxmins, boxmaxs;// enclose the test object along entire move

	float		*mins, *maxs;	// size of the moving object

	vec3_t		mins2, maxs2;	// size when clipping against mosnters

	float		*start, *end;

	trace_t		trace;

	int			type;

	edict_t		*passedict;

} moveclip_t;

int SV_HullPointContents (hull_t *hull, int num, vec3_t p);

/*

===============================================================================

HULL BOXES

===============================================================================

*/

static	hull_t		box_hull;

static	dclipnode_t	box_clipnodes[6];

static	mplane_t	box_planes[6];

/*

===================

SV_InitBoxHull

Set up the planes and clipnodes so that the six floats of a bounding box

can just be stored out and get a proper hull_t structure.

===================

*/

void SV_InitBoxHull (void)

{

	int		i;

	int		side;

	box_hull.clipnodes = box_clipnodes;

	box_hull.planes = box_planes;

	box_hull.firstclipnode = 0;

	box_hull.lastclipnode = 5;

	for (i=0 ; i<6 ; i++)

	{

		box_clipnodes[i].planenum = i;

		side = i&1;

		box_clipnodes[i].children[side] = CONTENTS_EMPTY;

		if (i != 5)

			box_clipnodes[i].children[side^1] = i + 1;

		else

			box_clipnodes[i].children[side^1] = CONTENTS_SOLID;

		box_planes[i].type = i>>1;

		box_planes[i].normal[i>>1] = 1;

	}

}

/*

===================

SV_HullForBox

To keep everything totally uniform, bounding boxes are turned into small

BSP trees instead of being compared directly.

===================

*/

hull_t	*SV_HullForBox (vec3_t mins, vec3_t maxs)

{

	box_planes[0].dist = maxs[0];

	box_planes[1].dist = mins[0];

	box_planes[2].dist = maxs[1];

	box_planes[3].dist = mins[1];

	box_planes[4].dist = maxs[2];

	box_planes[5].dist = mins[2];

	return &box_hull;

}

/*

================

SV_HullForEntity

Returns a hull that can be used for testing or clipping an object of mins/maxs

size.

Offset is filled in to contain the adjustment that must be added to the

testing object's origin to get a point to use with the returned hull.

================

*/

hull_t *SV_HullForEntity (edict_t *ent, vec3_t mins, vec3_t maxs, vec3_t offset)

{

	model_t		*model;

	vec3_t		size;

	vec3_t		hullmins, hullmaxs;

	hull_t		*hull;

// decide which clipping hull to use, based on the size

	if (ent->v.solid == SOLID_BSP)

	{	// explicit hulls in the BSP model

		if (ent->v.movetype != MOVETYPE_PUSH)

			Sys_Error ("SOLID_BSP without MOVETYPE_PUSH");

		model = sv.models[ (int)ent->v.modelindex ];

		if (!model || model->type != mod_brush)

			Sys_Error ("MOVETYPE_PUSH with a non bsp model");

		VectorSubtract (maxs, mins, size);

		if (size[0] < 3)

			hull = &model->hulls[0];

		else if (size[0] <= 32)

			hull = &model->hulls[1];

		else

			hull = &model->hulls[2];

// calculate an offset value to center the origin

		VectorSubtract (hull->clip_mins, mins, offset);

		VectorAdd (offset, ent->v.origin, offset);

	}

	else

	{	// create a temp hull from bounding box sizes

		VectorSubtract (ent->v.mins, maxs, hullmins);

		VectorSubtract (ent->v.maxs, mins, hullmaxs);

		hull = SV_HullForBox (hullmins, hullmaxs);

		VectorCopy (ent->v.origin, offset);

	}

	return hull;

}

/*

===============================================================================

ENTITY AREA CHECKING

===============================================================================

*/

typedef struct areanode_s

{

	int		axis;		// -1 = leaf node

	float	dist;

	struct areanode_s	*children[2];

	link_t	trigger_edicts;

	link_t	solid_edicts;

} areanode_t;

#define	AREA_DEPTH	4

#define	AREA_NODES	32

static	areanode_t	sv_areanodes[AREA_NODES];

static	int			sv_numareanodes;

/*

===============

SV_CreateAreaNode

===============

*/

areanode_t *SV_CreateAreaNode (int depth, vec3_t mins, vec3_t maxs)

{

	areanode_t	*anode;

	vec3_t		size;

	vec3_t		mins1, maxs1, mins2, maxs2;

	anode = &sv_areanodes[sv_numareanodes];

	sv_numareanodes++;

	ClearLink (&anode->trigger_edicts);

	ClearLink (&anode->solid_edicts);

	if (depth == AREA_DEPTH)

	{

		anode->axis = -1;

		anode->children[0] = anode->children[1] = NULL;

		return anode;

	}

	VectorSubtract (maxs, mins, size);

	if (size[0] > size[1])

		anode->axis = 0;

	else

		anode->axis = 1;

	anode->dist = 0.5 * (maxs[anode->axis] + mins[anode->axis]);

	VectorCopy (mins, mins1);

	VectorCopy (mins, mins2);

	VectorCopy (maxs, maxs1);

	VectorCopy (maxs, maxs2);

	maxs1[anode->axis] = mins2[anode->axis] = anode->dist;

	anode->children[0] = SV_CreateAreaNode (depth+1, mins2, maxs2);

	anode->children[1] = SV_CreateAreaNode (depth+1, mins1, maxs1);

	return anode;

}

/*

===============

SV_ClearWorld

===============

*/

void SV_ClearWorld (void)

{

	SV_InitBoxHull ();

	memset (sv_areanodes, 0, sizeof(sv_areanodes));

	sv_numareanodes = 0;

	SV_CreateAreaNode (0, sv.worldmodel->mins, sv.worldmodel->maxs);

}

/*

===============

SV_UnlinkEdict

===============

*/

void SV_UnlinkEdict (edict_t *ent)

{

	if (!ent->area.prev)

		return;		// not linked in anywhere

	RemoveLink (&ent->area);

	ent->area.prev = ent->area.next = NULL;

}

/*

====================

SV_TouchLinks

====================

*/

void SV_TouchLinks ( edict_t *ent, areanode_t *node )

{

	link_t		*l, *next;

	edict_t		*touch;

	int			old_self, old_other;

// touch linked edicts

	for (l = node->trigger_edicts.next ; l != &node->trigger_edicts ; l = next)

	{

		next = l->next;

		touch = EDICT_FROM_AREA(l);

		if (touch == ent)

			continue;

		if (!touch->v.touch || touch->v.solid != SOLID_TRIGGER)

			continue;

		if (ent->v.absmin[0] > touch->v.absmax[0]

		|| ent->v.absmin[1] > touch->v.absmax[1]

		|| ent->v.absmin[2] > touch->v.absmax[2]

		|| ent->v.absmax[0] < touch->v.absmin[0]

		|| ent->v.absmax[1] < touch->v.absmin[1]

		|| ent->v.absmax[2] < touch->v.absmin[2] )

			continue;

		old_self = pr_global_struct->self;

		old_other = pr_global_struct->other;

		pr_global_struct->self = EDICT_TO_PROG(touch);

		pr_global_struct->other = EDICT_TO_PROG(ent);

		pr_global_struct->time = sv.time;

		PR_ExecuteProgram (touch->v.touch);

		pr_global_struct->self = old_self;

		pr_global_struct->other = old_other;

	}

// recurse down both sides

	if (node->axis == -1)

		return;

	if ( ent->v.absmax[node->axis] > node->dist )

		SV_TouchLinks ( ent, node->children[0] );

	if ( ent->v.absmin[node->axis] < node->dist )

		SV_TouchLinks ( ent, node->children[1] );

}

/*

===============

SV_FindTouchedLeafs

===============

*/

void SV_FindTouchedLeafs (edict_t *ent, mnode_t *node)

{

	mplane_t	*splitplane;

	mleaf_t		*leaf;

	int			sides;

	int			leafnum;

	if (node->contents == CONTENTS_SOLID)

		return;

// add an efrag if the node is a leaf

	if ( node->contents < 0)

	{

		if (ent->num_leafs == MAX_ENT_LEAFS)

			return;

		leaf = (mleaf_t *)node;

		leafnum = leaf - sv.worldmodel->leafs - 1;

		ent->leafnums[ent->num_leafs] = leafnum;

		ent->num_leafs++;

		return;

	}

// NODE_MIXED

	splitplane = node->plane;

	sides = BOX_ON_PLANE_SIDE(ent->v.absmin, ent->v.absmax, splitplane);

// recurse down the contacted sides

	if (sides & 1)

		SV_FindTouchedLeafs (ent, node->children[0]);

	if (sides & 2)

		SV_FindTouchedLeafs (ent, node->children[1]);

}

/*

===============

SV_LinkEdict

===============

*/

void SV_LinkEdict (edict_t *ent, qboolean touch_triggers)

{

	areanode_t	*node;

	if (ent->area.prev)

		SV_UnlinkEdict (ent);	// unlink from old position

	if (ent == sv.edicts)

		return;		// don't add the world

	if (ent->free)

		return;

// set the abs box

#ifdef QUAKE2

	if (ent->v.solid == SOLID_BSP &&

	(ent->v.angles[0] || ent->v.angles[1] || ent->v.angles[2]) )

	{	// expand for rotation

		float		max, v;

		int			i;

		max = 0;

		for (i=0 ; i<3 ; i++)

		{

			v =fabs( ent->v.mins[i]);

			if (v > max)

				max = v;

			v =fabs( ent->v.maxs[i]);

			if (v > max)

				max = v;

		}

		for (i=0 ; i<3 ; i++)

		{

			ent->v.absmin[i] = ent->v.origin[i] - max;

			ent->v.absmax[i] = ent->v.origin[i] + max;

		}

	}

	else

#endif

	{

		VectorAdd (ent->v.origin, ent->v.mins, ent->v.absmin);

		VectorAdd (ent->v.origin, ent->v.maxs, ent->v.absmax);

	}

//

// to make items easier to pick up and allow them to be grabbed off

// of shelves, the abs sizes are expanded

//

	if ((int)ent->v.flags & FL_ITEM)

	{

		ent->v.absmin[0] -= 15;

		ent->v.absmin[1] -= 15;

		ent->v.absmax[0] += 15;

		ent->v.absmax[1] += 15;

	}

	else

	{	// because movement is clipped an epsilon away from an actual edge,

		// we must fully check even when bounding boxes don't quite touch

		ent->v.absmin[0] -= 1;

		ent->v.absmin[1] -= 1;

		ent->v.absmin[2] -= 1;

		ent->v.absmax[0] += 1;

		ent->v.absmax[1] += 1;

		ent->v.absmax[2] += 1;

	}

// link to PVS leafs

	ent->num_leafs = 0;

	if (ent->v.modelindex)

		SV_FindTouchedLeafs (ent, sv.worldmodel->nodes);

	if (ent->v.solid == SOLID_NOT)

		return;

// find the first node that the ent's box crosses

	node = sv_areanodes;

	while (1)

	{

		if (node->axis == -1)

			break;

		if (ent->v.absmin[node->axis] > node->dist)

			node = node->children[0];

		else if (ent->v.absmax[node->axis] < node->dist)

			node = node->children[1];

		else

			break;		// crosses the node

	}

// link it in

	if (ent->v.solid == SOLID_TRIGGER)

		InsertLinkBefore (&ent->area, &node->trigger_edicts);

	else

		InsertLinkBefore (&ent->area, &node->solid_edicts);

// if touch_triggers, touch all entities at this node and decend for more

	if (touch_triggers)

		SV_TouchLinks ( ent, sv_areanodes );

}

/*

===============================================================================

POINT TESTING IN HULLS

===============================================================================

*/

#if	!id386

/*

==================

SV_HullPointContents

==================

*/

int SV_HullPointContents (hull_t *hull, int num, vec3_t p)

{

	float		d;

	dclipnode_t	*node;

	mplane_t	*plane;

	while (num >= 0)

	{

		if (num < hull->firstclipnode || num > hull->lastclipnode)

			Sys_Error ("SV_HullPointContents: bad node number");

		node = hull->clipnodes + num;

		plane = hull->planes + node->planenum;

		if (plane->type < 3)

			d = p[plane->type] - plane->dist;

		else

			d = DotProduct (plane->normal, p) - plane->dist;

		if (d < 0)

			num = node->children[1];

		else

			num = node->children[0];

	}

	return num;

}

#endif	// !id386

/*

==================

SV_PointContents

==================

*/

int SV_PointContents (vec3_t p)

{

	int		cont;

	cont = SV_HullPointContents (&sv.worldmodel->hulls[0], 0, p);

	if (cont <= CONTENTS_CURRENT_0 && cont >= CONTENTS_CURRENT_DOWN)

		cont = CONTENTS_WATER;

	return cont;

}

int SV_TruePointContents (vec3_t p)

{

	return SV_HullPointContents (&sv.worldmodel->hulls[0], 0, p);

}

//===========================================================================

/*

============

SV_TestEntityPosition

This could be a lot more efficient...

============

*/

edict_t	*SV_TestEntityPosition (edict_t *ent)

{

	trace_t	trace;

	trace = SV_Move (ent->v.origin, ent->v.mins, ent->v.maxs, ent->v.origin, 0, ent);

	if (trace.startsolid)

		return sv.edicts;

	return NULL;

}

/*

===============================================================================

LINE TESTING IN HULLS

===============================================================================

*/

// 1/32 epsilon to keep floating point happy

#define	DIST_EPSILON	(0.03125)

/*

==================

SV_RecursiveHullCheck

==================

*/

qboolean SV_RecursiveHullCheck (hull_t *hull, int num, float p1f, float p2f, vec3_t p1, vec3_t p2, trace_t *trace)

{

	dclipnode_t	*node;

	mplane_t	*plane;

	float		t1, t2;

	float		frac;

	int			i;

	vec3_t		mid;

	int			side;

	float		midf;

// check for empty

	if (num < 0)

	{

		if (num != CONTENTS_SOLID)

		{

			trace->allsolid = false;

			if (num == CONTENTS_EMPTY)

				trace->inopen = true;

			else

				trace->inwater = true;

		}

		else

			trace->startsolid = true;

		return true;		// empty

	}

	if (num < hull->firstclipnode || num > hull->lastclipnode)

		Sys_Error ("SV_RecursiveHullCheck: bad node number");

//

// find the point distances

//

	node = hull->clipnodes + num;

	plane = hull->planes + node->planenum;

	if (plane->type < 3)

	{

		t1 = p1[plane->type] - plane->dist;

		t2 = p2[plane->type] - plane->dist;

	}

	else

	{

		t1 = DotProduct (plane->normal, p1) - plane->dist;

		t2 = DotProduct (plane->normal, p2) - plane->dist;

	}

#if 1

	if (t1 >= 0 && t2 >= 0)

		return SV_RecursiveHullCheck (hull, node->children[0], p1f, p2f, p1, p2, trace);

	if (t1 < 0 && t2 < 0)

		return SV_RecursiveHullCheck (hull, node->children[1], p1f, p2f, p1, p2, trace);

#else

	if ( (t1 >= DIST_EPSILON && t2 >= DIST_EPSILON) || (t2 > t1 && t1 >= 0) )

		return SV_RecursiveHullCheck (hull, node->children[0], p1f, p2f, p1, p2, trace);

	if ( (t1 <= -DIST_EPSILON && t2 <= -DIST_EPSILON) || (t2 < t1 && t1 <= 0) )

		return SV_RecursiveHullCheck (hull, node->children[1], p1f, p2f, p1, p2, trace);

#endif

// put the crosspoint DIST_EPSILON pixels on the near side

	if (t1 < 0)

		frac = (t1 + DIST_EPSILON)/(t1-t2);

	else

		frac = (t1 - DIST_EPSILON)/(t1-t2);

	if (frac < 0)

		frac = 0;

	if (frac > 1)

		frac = 1;

	midf = p1f + (p2f - p1f)*frac;

	for (i=0 ; i<3 ; i++)

		mid[i] = p1[i] + frac*(p2[i] - p1[i]);

	side = (t1 < 0);

// move up to the node

	if (!SV_RecursiveHullCheck (hull, node->children[side], p1f, midf, p1, mid, trace) )

		return false;

#ifdef PARANOID

	if (SV_HullPointContents (sv_hullmodel, mid, node->children[side])

	== CONTENTS_SOLID)

	{

		Con_Printf ("mid PointInHullSolid\n");

		return false;

	}

#endif

	if (SV_HullPointContents (hull, node->children[side^1], mid)

	!= CONTENTS_SOLID)

// go past the node

		return SV_RecursiveHullCheck (hull, node->children[side^1], midf, p2f, mid, p2, trace);

	if (trace->allsolid)

		return false;		// never got out of the solid area

//==================

// the other side of the node is solid, this is the impact point

//==================

	if (!side)

	{

		VectorCopy (plane->normal, trace->plane.normal);

		trace->plane.dist = plane->dist;

	}

	else

	{

		VectorSubtract (vec3_origin, plane->normal, trace->plane.normal);

		trace->plane.dist = -plane->dist;

	}

	while (SV_HullPointContents (hull, hull->firstclipnode, mid)

	== CONTENTS_SOLID)

	{ // shouldn't really happen, but does occasionally

		frac -= 0.1;

		if (frac < 0)

		{

			trace->fraction = midf;

			VectorCopy (mid, trace->endpos);

			Con_DPrintf ("backup past 0\n");

			return false;

		}

		midf = p1f + (p2f - p1f)*frac;

		for (i=0 ; i<3 ; i++)

			mid[i] = p1[i] + frac*(p2[i] - p1[i]);

	}

	trace->fraction = midf;

	VectorCopy (mid, trace->endpos);

	return false;

}

/*

==================

SV_ClipMoveToEntity

Handles selection or creation of a clipping hull, and offseting (and

eventually rotation) of the end points

==================

*/

trace_t SV_ClipMoveToEntity (edict_t *ent, vec3_t start, vec3_t mins, vec3_t maxs, vec3_t end)

{

	trace_t		trace;

	vec3_t		offset;

	vec3_t		start_l, end_l;

	hull_t		*hull;

// fill in a default trace

	memset (&trace, 0, sizeof(trace_t));

	trace.fraction = 1;

	trace.allsolid = true;

	VectorCopy (end, trace.endpos);

// get the clipping hull

	hull = SV_HullForEntity (ent, mins, maxs, offset);

	VectorSubtract (start, offset, start_l);

	VectorSubtract (end, offset, end_l);

#ifdef QUAKE2

	// rotate start and end into the models frame of reference

	if (ent->v.solid == SOLID_BSP &&

	(ent->v.angles[0] || ent->v.angles[1] || ent->v.angles[2]) )

	{

		vec3_t	a;

		vec3_t	forward, right, up;

		vec3_t	temp;

		AngleVectors (ent->v.angles, forward, right, up);

		VectorCopy (start_l, temp);

		start_l[0] = DotProduct (temp, forward);

		start_l[1] = -DotProduct (temp, right);

		start_l[2] = DotProduct (temp, up);

		VectorCopy (end_l, temp);

		end_l[0] = DotProduct (temp, forward);

		end_l[1] = -DotProduct (temp, right);

		end_l[2] = DotProduct (temp, up);

	}

#endif

// trace a line through the apropriate clipping hull

	SV_RecursiveHullCheck (hull, hull->firstclipnode, 0, 1, start_l, end_l, &trace);

#ifdef QUAKE2

	// rotate endpos back to world frame of reference

	if (ent->v.solid == SOLID_BSP &&

	(ent->v.angles[0] || ent->v.angles[1] || ent->v.angles[2]) )

	{

		vec3_t	a;

		vec3_t	forward, right, up;

		vec3_t	temp;

		if (trace.fraction != 1)

		{

			VectorSubtract (vec3_origin, ent->v.angles, a);

			AngleVectors (a, forward, right, up);

			VectorCopy (trace.endpos, temp);

			trace.endpos[0] = DotProduct (temp, forward);

			trace.endpos[1] = -DotProduct (temp, right);

			trace.endpos[2] = DotProduct (temp, up);

			VectorCopy (trace.plane.normal, temp);

			trace.plane.normal[0] = DotProduct (temp, forward);

			trace.plane.normal[1] = -DotProduct (temp, right);

			trace.plane.normal[2] = DotProduct (temp, up);

		}

	}

#endif

// fix trace up by the offset

	if (trace.fraction != 1)

		VectorAdd (trace.endpos, offset, trace.endpos);

// did we clip the move?

	if (trace.fraction < 1 || trace.startsolid  )

		trace.ent = ent;

	return trace;

}

//===========================================================================

/*

====================

SV_ClipToLinks

Mins and maxs enclose the entire area swept by the move

====================

*/

void SV_ClipToLinks ( areanode_t *node, moveclip_t *clip )

{

	link_t		*l, *next;

	edict_t		*touch;

	trace_t		trace;

// touch linked edicts

	for (l = node->solid_edicts.next ; l != &node->solid_edicts ; l = next)

	{

		next = l->next;

		touch = EDICT_FROM_AREA(l);

		if (touch->v.solid == SOLID_NOT)

			continue;

		if (touch == clip->passedict)

			continue;

		if (touch->v.solid == SOLID_TRIGGER)

			Sys_Error ("Trigger in clipping list");

		if (clip->type == MOVE_NOMONSTERS && touch->v.solid != SOLID_BSP)

			continue;

		if (clip->boxmins[0] > touch->v.absmax[0]

		|| clip->boxmins[1] > touch->v.absmax[1]

		|| clip->boxmins[2] > touch->v.absmax[2]

		|| clip->boxmaxs[0] < touch->v.absmin[0]

		|| clip->boxmaxs[1] < touch->v.absmin[1]

		|| clip->boxmaxs[2] < touch->v.absmin[2] )

			continue;

		if (clip->passedict && clip->passedict->v.size[0] && !touch->v.size[0])

			continue;	// points never interact

	// might intersect, so do an exact clip

		if (clip->trace.allsolid)

			return;

		if (clip->passedict)

		{

		 	if (PROG_TO_EDICT(touch->v.owner) == clip->passedict)

				continue;	// don't clip against own missiles

			if (PROG_TO_EDICT(clip->passedict->v.owner) == touch)

				continue;	// don't clip against owner

		}

		if ((int)touch->v.flags & FL_MONSTER)

			trace = SV_ClipMoveToEntity (touch, clip->start, clip->mins2, clip->maxs2, clip->end);

		else

			trace = SV_ClipMoveToEntity (touch, clip->start, clip->mins, clip->maxs, clip->end);

		if (trace.allsolid || trace.startsolid ||

		trace.fraction < clip->trace.fraction)

		{

			trace.ent = touch;

		 	if (clip->trace.startsolid)

			{

				clip->trace = trace;

				clip->trace.startsolid = true;

			}

			else

				clip->trace = trace;

		}

		else if (trace.startsolid)

			clip->trace.startsolid = true;

	}

// recurse down both sides

	if (node->axis == -1)

		return;

	if ( clip->boxmaxs[node->axis] > node->dist )

		SV_ClipToLinks ( node->children[0], clip );

	if ( clip->boxmins[node->axis] < node->dist )

		SV_ClipToLinks ( node->children[1], clip );

}

/*

==================

SV_MoveBounds

==================

*/

void SV_MoveBounds (vec3_t start, vec3_t mins, vec3_t maxs, vec3_t end, vec3_t boxmins, vec3_t boxmaxs)

{

#if 0

// debug to test against everything

boxmins[0] = boxmins[1] = boxmins[2] = -9999;

boxmaxs[0] = boxmaxs[1] = boxmaxs[2] = 9999;

#else

	int		i;

	for (i=0 ; i<3 ; i++)

	{

		if (end[i] > start[i])

		{

			boxmins[i] = start[i] + mins[i] - 1;

			boxmaxs[i] = end[i] + maxs[i] + 1;

		}

		else

		{

			boxmins[i] = end[i] + mins[i] - 1;

			boxmaxs[i] = start[i] + maxs[i] + 1;

		}

	}

#endif

}

/*

==================

SV_Move

==================

*/

trace_t SV_Move (vec3_t start, vec3_t mins, vec3_t maxs, vec3_t end, int type, edict_t *passedict)

{

	moveclip_t	clip;

	int			i;

	memset ( &clip, 0, sizeof ( moveclip_t ) );

// clip to world

	clip.trace = SV_ClipMoveToEntity ( sv.edicts, start, mins, maxs, end );

	clip.start = start;

	clip.end = end;

	clip.mins = mins;

	clip.maxs = maxs;

	clip.type = type;

	clip.passedict = passedict;

	if (type == MOVE_MISSILE)

	{

		for (i=0 ; i<3 ; i++)

		{

			clip.mins2[i] = -15;

			clip.maxs2[i] = 15;

		}

	}

	else

	{

		VectorCopy (mins, clip.mins2);

		VectorCopy (maxs, clip.maxs2);

	}

// create the bounding box of the entire move

	SV_MoveBounds ( start, clip.mins2, clip.maxs2, end, clip.boxmins, clip.boxmaxs );

// clip to entities

	SV_ClipToLinks ( sv_areanodes, &clip );

	return clip.trace;

}