![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to world.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Quake] / quake1|
Return to world.c CVS log | Up to [Quake] / quake1 |
1.1 root 1: // world.c -- world query functions
2:
3: #include "quakedef.h"
4:
5: /*
6:
7: entities never clip against themselves, or their owner
8:
9: line of sight checks trace->crosscontent, but bullets don't
10:
11: */
12:
13:
14: typedef struct
15: {
16: vec3_t boxmins, boxmaxs;// enclose the test object along entire move
17: float *mins, *maxs; // size of the moving object
18: vec3_t mins2, maxs2; // size when clipping against mosnters
19: float *start, *end;
20: trace_t trace;
21: int type;
22: edict_t *passedict;
23: } moveclip_t;
24:
25:
26: int SV_HullPointContents (hull_t *hull, int num, vec3_t p);
27:
28: /*
29: ===============================================================================
30:
31: HULL BOXES
32:
33: ===============================================================================
34: */
35:
36:
37: static hull_t box_hull;
38: static dclipnode_t box_clipnodes[6];
39: static mplane_t box_planes[6];
40:
41: /*
42: ===================
43: SV_InitBoxHull
44:
45: Set up the planes and clipnodes so that the six floats of a bounding box
46: can just be stored out and get a proper hull_t structure.
47: ===================
48: */
49: void SV_InitBoxHull (void)
50: {
51: int i;
52: int side;
53:
54: box_hull.clipnodes = box_clipnodes;
55: box_hull.planes = box_planes;
56: box_hull.firstclipnode = 0;
57: box_hull.lastclipnode = 5;
58:
59: for (i=0 ; i<6 ; i++)
60: {
61: box_clipnodes[i].planenum = i;
62:
63: side = i&1;
64:
65: box_clipnodes[i].children[side] = CONTENTS_EMPTY;
66: if (i != 5)
67: box_clipnodes[i].children[side^1] = i + 1;
68: else
69: box_clipnodes[i].children[side^1] = CONTENTS_SOLID;
70:
71: box_planes[i].type = i>>1;
72: box_planes[i].normal[i>>1] = 1;
73: }
74:
75: }
76:
77:
78: /*
79: ===================
80: SV_HullForBox
81:
82: To keep everything totally uniform, bounding boxes are turned into small
83: BSP trees instead of being compared directly.
84: ===================
85: */
86: hull_t *SV_HullForBox (vec3_t mins, vec3_t maxs)
87: {
88: box_planes[0].dist = maxs[0];
89: box_planes[1].dist = mins[0];
90: box_planes[2].dist = maxs[1];
91: box_planes[3].dist = mins[1];
92: box_planes[4].dist = maxs[2];
93: box_planes[5].dist = mins[2];
94:
95: return &box_hull;
96: }
97:
98:
99:
100: /*
101: ================
102: SV_HullForEntity
103:
104: Returns a hull that can be used for testing or clipping an object of mins/maxs
105: size.
106: Offset is filled in to contain the adjustment that must be added to the
107: testing object's origin to get a point to use with the returned hull.
108: ================
109: */
110: hull_t *SV_HullForEntity (edict_t *ent, vec3_t mins, vec3_t maxs, vec3_t offset)
111: {
112: model_t *model;
113: vec3_t size;
114: vec3_t hullmins, hullmaxs;
115: hull_t *hull;
116:
117: // decide which clipping hull to use, based on the size
118: if (ent->v.solid == SOLID_BSP)
119: { // explicit hulls in the BSP model
120: if (ent->v.movetype != MOVETYPE_PUSH)
121: Sys_Error ("SOLID_BSP without MOVETYPE_PUSH");
122:
123: model = sv.models[ (int)ent->v.modelindex ];
124:
125: if (!model || model->type != mod_brush)
126: Sys_Error ("MOVETYPE_PUSH with a non bsp model");
127:
128: VectorSubtract (maxs, mins, size);
129: if (size[0] < 3)
130: hull = &model->hulls[0];
131: else if (size[0] <= 32)
132: hull = &model->hulls[1];
133: else
134: hull = &model->hulls[2];
135:
136: // calculate an offset value to center the origin
137: VectorSubtract (hull->clip_mins, mins, offset);
138: VectorAdd (offset, ent->v.origin, offset);
139: }
140: else
141: { // create a temp hull from bounding box sizes
142:
143: VectorSubtract (ent->v.mins, maxs, hullmins);
144: VectorSubtract (ent->v.maxs, mins, hullmaxs);
145: hull = SV_HullForBox (hullmins, hullmaxs);
146:
147: VectorCopy (ent->v.origin, offset);
148: }
149:
150:
151: return hull;
152: }
153:
154: /*
155: ===============================================================================
156:
157: ENTITY AREA CHECKING
158:
159: ===============================================================================
160: */
161:
162: typedef struct areanode_s
163: {
164: int axis; // -1 = leaf node
165: float dist;
166: struct areanode_s *children[2];
167: link_t trigger_edicts;
168: link_t solid_edicts;
169: } areanode_t;
170:
171: #define AREA_DEPTH 4
172: #define AREA_NODES 32
173:
174: static areanode_t sv_areanodes[AREA_NODES];
175: static int sv_numareanodes;
176:
177: /*
178: ===============
179: SV_CreateAreaNode
180:
181: ===============
182: */
183: areanode_t *SV_CreateAreaNode (int depth, vec3_t mins, vec3_t maxs)
184: {
185: areanode_t *anode;
186: vec3_t size;
187: vec3_t mins1, maxs1, mins2, maxs2;
188:
189: anode = &sv_areanodes[sv_numareanodes];
190: sv_numareanodes++;
191:
192: ClearLink (&anode->trigger_edicts);
193: ClearLink (&anode->solid_edicts);
194:
195: if (depth == AREA_DEPTH)
196: {
197: anode->axis = -1;
198: anode->children[0] = anode->children[1] = NULL;
199: return anode;
200: }
201:
202: VectorSubtract (maxs, mins, size);
203: if (size[0] > size[1])
204: anode->axis = 0;
205: else
206: anode->axis = 1;
207:
208: anode->dist = 0.5 * (maxs[anode->axis] + mins[anode->axis]);
209: VectorCopy (mins, mins1);
210: VectorCopy (mins, mins2);
211: VectorCopy (maxs, maxs1);
212: VectorCopy (maxs, maxs2);
213:
214: maxs1[anode->axis] = mins2[anode->axis] = anode->dist;
215:
216: anode->children[0] = SV_CreateAreaNode (depth+1, mins2, maxs2);
217: anode->children[1] = SV_CreateAreaNode (depth+1, mins1, maxs1);
218:
219: return anode;
220: }
221:
222: /*
223: ===============
224: SV_ClearWorld
225:
226: ===============
227: */
228: void SV_ClearWorld (void)
229: {
230: SV_InitBoxHull ();
231:
232: memset (sv_areanodes, 0, sizeof(sv_areanodes));
233: sv_numareanodes = 0;
234: SV_CreateAreaNode (0, sv.worldmodel->mins, sv.worldmodel->maxs);
235: }
236:
237:
238: /*
239: ===============
240: SV_UnlinkEdict
241:
242: ===============
243: */
244: void SV_UnlinkEdict (edict_t *ent)
245: {
246: if (!ent->area.prev)
247: return; // not linked in anywhere
248: RemoveLink (&ent->area);
249: ent->area.prev = ent->area.next = NULL;
250: }
251:
252:
253: /*
254: ====================
255: SV_TouchLinks
256: ====================
257: */
258: void SV_TouchLinks ( edict_t *ent, areanode_t *node )
259: {
260: link_t *l, *next;
261: edict_t *touch;
262: int old_self, old_other;
263:
264: // touch linked edicts
265: for (l = node->trigger_edicts.next ; l != &node->trigger_edicts ; l = next)
266: {
267: next = l->next;
268: touch = EDICT_FROM_AREA(l);
269: if (touch == ent)
270: continue;
271: if (!touch->v.touch || touch->v.solid != SOLID_TRIGGER)
272: continue;
273: if (ent->v.absmin[0] > touch->v.absmax[0]
274: || ent->v.absmin[1] > touch->v.absmax[1]
275: || ent->v.absmin[2] > touch->v.absmax[2]
276: || ent->v.absmax[0] < touch->v.absmin[0]
277: || ent->v.absmax[1] < touch->v.absmin[1]
278: || ent->v.absmax[2] < touch->v.absmin[2] )
279: continue;
280:
281: old_self = pr_global_struct->self;
282: old_other = pr_global_struct->other;
283:
284: pr_global_struct->self = EDICT_TO_PROG(touch);
285: pr_global_struct->other = EDICT_TO_PROG(ent);
286: pr_global_struct->time = sv.time;
287: PR_ExecuteProgram (touch->v.touch);
288:
289: pr_global_struct->self = old_self;
290: pr_global_struct->other = old_other;
291: }
292:
293: // recurse down both sides
294: if (node->axis == -1)
295: return;
296:
297: if ( ent->v.absmax[node->axis] > node->dist )
298: SV_TouchLinks ( ent, node->children[0] );
299: if ( ent->v.absmin[node->axis] < node->dist )
300: SV_TouchLinks ( ent, node->children[1] );
301: }
302:
303:
304: /*
305: ===============
306: SV_FindTouchedLeafs
307:
308: ===============
309: */
310: void SV_FindTouchedLeafs (edict_t *ent, mnode_t *node)
311: {
312: mplane_t *splitplane;
313: mleaf_t *leaf;
314: int sides;
315: int leafnum;
316:
317: if (node->contents == CONTENTS_SOLID)
318: return;
319:
320: // add an efrag if the node is a leaf
321:
322: if ( node->contents < 0)
323: {
324: if (ent->num_leafs == MAX_ENT_LEAFS)
325: return;
326:
327: leaf = (mleaf_t *)node;
328: leafnum = leaf - sv.worldmodel->leafs - 1;
329:
330: ent->leafnums[ent->num_leafs] = leafnum;
331: ent->num_leafs++;
332: return;
333: }
334:
335: // NODE_MIXED
336:
337: splitplane = node->plane;
338: sides = BOX_ON_PLANE_SIDE(ent->v.absmin, ent->v.absmax, splitplane);
339:
340: // recurse down the contacted sides
341: if (sides & 1)
342: SV_FindTouchedLeafs (ent, node->children[0]);
343:
344: if (sides & 2)
345: SV_FindTouchedLeafs (ent, node->children[1]);
346: }
347:
348: /*
349: ===============
350: SV_LinkEdict
351:
352: ===============
353: */
354: void SV_LinkEdict (edict_t *ent, qboolean touch_triggers)
355: {
356: areanode_t *node;
357:
358: if (ent->area.prev)
359: SV_UnlinkEdict (ent); // unlink from old position
360:
361: if (ent == sv.edicts)
362: return; // don't add the world
363:
364: if (ent->free)
365: return;
366:
367: // set the abs box
368: VectorAdd (ent->v.origin, ent->v.mins, ent->v.absmin);
369: VectorAdd (ent->v.origin, ent->v.maxs, ent->v.absmax);
370:
371: //
372: // to make items easier to pick up and allow them to be grabbed off
373: // of shelves, the abs sizes are expanded
374: //
375: if ((int)ent->v.flags & FL_ITEM)
376: {
377: ent->v.absmin[0] -= 15;
378: ent->v.absmin[1] -= 15;
379: ent->v.absmax[0] += 15;
380: ent->v.absmax[1] += 15;
381: }
382: else
383: { // because movement is clipped an epsilon away from an actual edge,
384: // we must fully check even when bounding boxes don't quite touch
385: ent->v.absmin[0] -= 1;
386: ent->v.absmin[1] -= 1;
387: ent->v.absmin[2] -= 1;
388: ent->v.absmax[0] += 1;
389: ent->v.absmax[1] += 1;
390: ent->v.absmax[2] += 1;
391: }
392:
393: // link to PVS leafs
394: ent->num_leafs = 0;
395: if (ent->v.modelindex)
396: SV_FindTouchedLeafs (ent, sv.worldmodel->nodes);
397:
398: if (ent->v.solid == SOLID_NOT)
399: return;
400:
401: // find the first node that the ent's box crosses
402: node = sv_areanodes;
403: while (1)
404: {
405: if (node->axis == -1)
406: break;
407: if (ent->v.absmin[node->axis] > node->dist)
408: node = node->children[0];
409: else if (ent->v.absmax[node->axis] < node->dist)
410: node = node->children[1];
411: else
412: break; // crosses the node
413: }
414:
415: // link it in
416:
417: if (ent->v.solid == SOLID_TRIGGER)
418: InsertLinkBefore (&ent->area, &node->trigger_edicts);
419: else
420: InsertLinkBefore (&ent->area, &node->solid_edicts);
421:
422: // if touch_triggers, touch all entities at this node and decend for more
423: if (touch_triggers)
424: SV_TouchLinks ( ent, sv_areanodes );
425: }
426:
427:
428:
429: /*
430: ===============================================================================
431:
432: POINT TESTING IN HULLS
433:
434: ===============================================================================
435: */
436:
437: #if !id386
438:
439: /*
440: ==================
441: SV_HullPointContents
442:
443: ==================
444: */
445: int SV_HullPointContents (hull_t *hull, int num, vec3_t p)
446: {
447: float d;
448: dclipnode_t *node;
449: mplane_t *plane;
450:
451: while (num >= 0)
452: {
453: if (num < hull->firstclipnode || num > hull->lastclipnode)
454: Sys_Error ("SV_HullPointContents: bad node number");
455:
456: node = hull->clipnodes + num;
457: plane = hull->planes + node->planenum;
458:
459: if (plane->type < 3)
460: d = p[plane->type] - plane->dist;
461: else
462: d = DotProduct (plane->normal, p) - plane->dist;
463: if (d < 0)
464: num = node->children[1];
465: else
466: num = node->children[0];
467: }
468:
469: return num;
470: }
471:
472: #endif // !id386
473:
474:
475: /*
476: ==================
477: SV_PointContents
478:
479: ==================
480: */
481: int SV_PointContents (vec3_t p)
482: {
483: return SV_HullPointContents (&sv.worldmodel->hulls[0], 0, p);
484: }
485:
486: //===========================================================================
487:
488: /*
489: ============
490: SV_TestEntityPosition
491:
492: A small wrapper around SV_BoxInSolidEntity that never clips against the
493: supplied entity.
494: ============
495: */
496: edict_t *SV_TestEntityPosition (edict_t *ent)
497: {
498: trace_t trace;
499:
500: trace = SV_Move (ent->v.origin, ent->v.mins, ent->v.maxs, ent->v.origin, 0, ent);
501:
502: if (trace.startsolid)
503: return sv.edicts;
504:
505: return NULL;
506: }
507:
508:
509: /*
510: ===============================================================================
511:
512: LINE TESTING IN HULLS
513:
514: ===============================================================================
515: */
516:
517: // 1/32 epsilon to keep floating point happy
518: #define DIST_EPSILON (0.03125)
519:
520: /*
521: ==================
522: SV_RecursiveHullCheck
523:
524: ==================
525: */
526: qboolean SV_RecursiveHullCheck (hull_t *hull, int num, float p1f, float p2f, vec3_t p1, vec3_t p2, trace_t *trace)
527: {
528: dclipnode_t *node;
529: mplane_t *plane;
530: float t1, t2;
531: float frac;
532: int i;
533: vec3_t mid;
534: int side;
535: float midf;
536:
537: // check for empty
538: if (num < 0)
539: {
540: if (num != CONTENTS_SOLID)
541: {
542: trace->allsolid = false;
543: if (num == CONTENTS_EMPTY)
544: trace->inopen = true;
545: else
546: trace->inwater = true;
547: }
548: else
549: trace->startsolid = true;
550: return true; // empty
551: }
552:
553: if (num < hull->firstclipnode || num > hull->lastclipnode)
554: Sys_Error ("SV_RecursiveHullCheck: bad node number");
555:
556: //
557: // find the point distances
558: //
559: node = hull->clipnodes + num;
560: plane = hull->planes + node->planenum;
561:
562: if (plane->type < 3)
563: {
564: t1 = p1[plane->type] - plane->dist;
565: t2 = p2[plane->type] - plane->dist;
566: }
567: else
568: {
569: t1 = DotProduct (plane->normal, p1) - plane->dist;
570: t2 = DotProduct (plane->normal, p2) - plane->dist;
571: }
572:
573: #if 1
574: if (t1 >= 0 && t2 >= 0)
575: return SV_RecursiveHullCheck (hull, node->children[0], p1f, p2f, p1, p2, trace);
576: if (t1 < 0 && t2 < 0)
577: return SV_RecursiveHullCheck (hull, node->children[1], p1f, p2f, p1, p2, trace);
578: #else
579: if ( (t1 >= DIST_EPSILON && t2 >= DIST_EPSILON) || (t2 > t1 && t1 >= 0) )
580: return SV_RecursiveHullCheck (hull, node->children[0], p1f, p2f, p1, p2, trace);
581: if ( (t1 <= -DIST_EPSILON && t2 <= -DIST_EPSILON) || (t2 < t1 && t1 <= 0) )
582: return SV_RecursiveHullCheck (hull, node->children[1], p1f, p2f, p1, p2, trace);
583: #endif
584:
585: // put the crosspoint DIST_EPSILON pixels on the near side
586: if (t1 < 0)
587: frac = (t1 + DIST_EPSILON)/(t1-t2);
588: else
589: frac = (t1 - DIST_EPSILON)/(t1-t2);
590: if (frac < 0)
591: frac = 0;
592: if (frac > 1)
593: frac = 1;
594:
595: midf = p1f + (p2f - p1f)*frac;
596: for (i=0 ; i<3 ; i++)
597: mid[i] = p1[i] + frac*(p2[i] - p1[i]);
598:
599: side = (t1 < 0);
600:
601: // move up to the node
602: if (!SV_RecursiveHullCheck (hull, node->children[side], p1f, midf, p1, mid, trace) )
603: return false;
604:
605: #ifdef PARANOID
606: if (SV_HullPointContents (sv_hullmodel, mid, node->children[side])
607: == CONTENTS_SOLID)
608: {
609: Con_Printf ("mid PointInHullSolid\n");
610: return false;
611: }
612: #endif
613:
614: if (SV_HullPointContents (hull, node->children[side^1], mid)
615: != CONTENTS_SOLID)
616: // go past the node
617: return SV_RecursiveHullCheck (hull, node->children[side^1], midf, p2f, mid, p2, trace);
618:
619: if (trace->allsolid)
620: return false; // never got out of the solid area
621:
622: //==================
623: // the other side of the node is solid, this is the impact point
624: //==================
625: if (!side)
626: {
627: VectorCopy (plane->normal, trace->plane.normal);
628: trace->plane.dist = plane->dist;
629: }
630: else
631: {
632: VectorSubtract (vec3_origin, plane->normal, trace->plane.normal);
633: trace->plane.dist = -plane->dist;
634: }
635:
636: while (SV_HullPointContents (hull, hull->firstclipnode, mid)
637: == CONTENTS_SOLID)
638: { // shouldn't really happen, but does occasionally
639: frac -= 0.1;
640: if (frac < 0)
641: {
642: trace->fraction = midf;
643: VectorCopy (mid, trace->endpos);
644: Con_Printf ("backup past 0\n");
645: return false;
646: }
647: midf = p1f + (p2f - p1f)*frac;
648: for (i=0 ; i<3 ; i++)
649: mid[i] = p1[i] + frac*(p2[i] - p1[i]);
650: }
651:
652: trace->fraction = midf;
653: VectorCopy (mid, trace->endpos);
654:
655: return false;
656: }
657:
658:
659: /*
660: ==================
661: SV_ClipMoveToEntity
662:
663: Handles selection or creation of a clipping hull, and offseting (and
664: eventually rotation) of the end points
665: ==================
666: */
667: trace_t SV_ClipMoveToEntity (edict_t *ent, vec3_t start, vec3_t mins, vec3_t maxs, vec3_t end)
668: {
669: trace_t trace;
670: vec3_t offset;
671: vec3_t start_l, end_l;
672: hull_t *hull;
673:
674: // fill in a default trace
675: memset (&trace, 0, sizeof(trace_t));
676: trace.fraction = 1;
677: trace.allsolid = true;
678: VectorCopy (end, trace.endpos);
679:
680: // get the clipping hull
681: hull = SV_HullForEntity (ent, mins, maxs, offset);
682:
683: VectorSubtract (start, offset, start_l);
684: VectorSubtract (end, offset, end_l);
685:
686: // trace a line through the apropriate clipping hull
687: SV_RecursiveHullCheck (hull, hull->firstclipnode, 0, 1, start_l, end_l, &trace);
688:
689: // fix trace up by the offset
690: if (trace.fraction != 1)
691: VectorAdd (trace.endpos, offset, trace.endpos);
692:
693: // did we clip the move?
694: if (trace.fraction < 1 || trace.startsolid )
695: trace.ent = ent;
696:
697: return trace;
698: }
699:
700: //===========================================================================
701:
702: /*
703: ====================
704: SV_ClipToLinks
705:
706: Mins and maxs enclose the entire area swept by the move
707: ====================
708: */
709: void SV_ClipToLinks ( areanode_t *node, moveclip_t *clip )
710: {
711: link_t *l, *next;
712: edict_t *touch;
713: trace_t trace;
714:
715: // touch linked edicts
716: for (l = node->solid_edicts.next ; l != &node->solid_edicts ; l = next)
717: {
718: next = l->next;
719: touch = EDICT_FROM_AREA(l);
720: if (touch->v.solid == SOLID_NOT)
721: continue;
722: if (touch == clip->passedict)
723: continue;
724: if (touch->v.solid == SOLID_TRIGGER)
725: Sys_Error ("Trigger in clipping list");
726:
727: if (clip->type == MOVE_NOMONSTERS && touch->v.solid != SOLID_BSP)
728: continue;
729:
730: if (clip->boxmins[0] > touch->v.absmax[0]
731: || clip->boxmins[1] > touch->v.absmax[1]
732: || clip->boxmins[2] > touch->v.absmax[2]
733: || clip->boxmaxs[0] < touch->v.absmin[0]
734: || clip->boxmaxs[1] < touch->v.absmin[1]
735: || clip->boxmaxs[2] < touch->v.absmin[2] )
736: continue;
737:
738: if (clip->passedict && clip->passedict->v.size[0] && !touch->v.size[0])
739: continue; // points never interact
740:
741: // might intersect, so do an exact clip
742: if (clip->trace.allsolid)
743: return;
744: if (clip->passedict)
745: {
746: if (PROG_TO_EDICT(touch->v.owner) == clip->passedict)
747: continue; // don't clip against own missiles
748: if (PROG_TO_EDICT(clip->passedict->v.owner) == touch)
749: continue; // don't clip against owner
750: }
751:
752: if ((int)touch->v.flags & FL_MONSTER)
753: trace = SV_ClipMoveToEntity (touch, clip->start, clip->mins2, clip->maxs2, clip->end);
754: else
755: trace = SV_ClipMoveToEntity (touch, clip->start, clip->mins, clip->maxs, clip->end);
756: if (trace.allsolid || trace.startsolid ||
757: trace.fraction < clip->trace.fraction)
758: {
759: trace.ent = touch;
760: if (clip->trace.startsolid)
761: {
762: clip->trace = trace;
763: clip->trace.startsolid = true;
764: }
765: else
766: clip->trace = trace;
767: }
768: else if (trace.startsolid)
769: clip->trace.startsolid = true;
770: }
771:
772: // recurse down both sides
773: if (node->axis == -1)
774: return;
775:
776: if ( clip->boxmaxs[node->axis] > node->dist )
777: SV_ClipToLinks ( node->children[0], clip );
778: if ( clip->boxmins[node->axis] < node->dist )
779: SV_ClipToLinks ( node->children[1], clip );
780: }
781:
782:
783: /*
784: ==================
785: SV_MoveBounds
786: ==================
787: */
788: void SV_MoveBounds (vec3_t start, vec3_t mins, vec3_t maxs, vec3_t end, vec3_t boxmins, vec3_t boxmaxs)
789: {
790: #if 0
791: // debug to test against everything
792: boxmins[0] = boxmins[1] = boxmins[2] = -9999;
793: boxmaxs[0] = boxmaxs[1] = boxmaxs[2] = 9999;
794: #else
795: int i;
796:
797: for (i=0 ; i<3 ; i++)
798: {
799: if (end[i] > start[i])
800: {
801: boxmins[i] = start[i] + mins[i] - 1;
802: boxmaxs[i] = end[i] + maxs[i] + 1;
803: }
804: else
805: {
806: boxmins[i] = end[i] + mins[i] - 1;
807: boxmaxs[i] = start[i] + maxs[i] + 1;
808: }
809: }
810: #endif
811: }
812:
813: /*
814: ==================
815: SV_Move
816: ==================
817: */
818: trace_t SV_Move (vec3_t start, vec3_t mins, vec3_t maxs, vec3_t end, int type, edict_t *passedict)
819: {
820: moveclip_t clip;
821: int i;
822:
823: memset ( &clip, 0, sizeof ( moveclip_t ) );
824:
825: // clip to world
826: clip.trace = SV_ClipMoveToEntity ( sv.edicts, start, mins, maxs, end );
827:
828: clip.start = start;
829: clip.end = end;
830: clip.mins = mins;
831: clip.maxs = maxs;
832: clip.type = type;
833: clip.passedict = passedict;
834:
835: if (type == MOVE_MISSILE)
836: {
837: for (i=0 ; i<3 ; i++)
838: {
839: clip.mins2[i] = -15;
840: clip.maxs2[i] = 15;
841: }
842: }
843: else
844: {
845: VectorCopy (mins, clip.mins2);
846: VectorCopy (maxs, clip.maxs2);
847: }
848:
849: // create the bounding box of the entire move
850: SV_MoveBounds ( start, clip.mins2, clip.maxs2, end, clip.boxmins, clip.boxmaxs );
851:
852: // clip to entities
853: SV_ClipToLinks ( sv_areanodes, &clip );
854:
855: return clip.trace;
856: }
857:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.