![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to g_phys.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Quake II] / quake2 / rogue|
Return to g_phys.c CVS log | Up to [Quake II] / quake2 / rogue |
1.1 root 1: // g_phys.c
2:
3: #include "g_local.h"
4:
5: /*
6:
7:
8: pushmove objects do not obey gravity, and do not interact with each other or trigger fields, but block normal movement and push normal objects when they move.
9:
10: onground is set for toss objects when they come to a complete rest. it is set for steping or walking objects
11:
12: doors, plats, etc are SOLID_BSP, and MOVETYPE_PUSH
13: bonus items are SOLID_TRIGGER touch, and MOVETYPE_TOSS
14: corpses are SOLID_NOT and MOVETYPE_TOSS
15: crates are SOLID_BBOX and MOVETYPE_TOSS
16: walking monsters are SOLID_SLIDEBOX and MOVETYPE_STEP
17: flying/floating monsters are SOLID_SLIDEBOX and MOVETYPE_FLY
18:
19: solid_edge items only clip against bsp models.
20:
21: */
22:
23: void SV_Physics_NewToss (edict_t *ent); // PGM
24:
25:
26: /*
27: ============
28: SV_TestEntityPosition
29:
30: ============
31: */
32: edict_t *SV_TestEntityPosition (edict_t *ent)
33: {
34: trace_t trace;
35: int mask;
36:
37: if (ent->clipmask)
38: mask = ent->clipmask;
39: else
40: mask = MASK_SOLID;
41: trace = gi.trace (ent->s.origin, ent->mins, ent->maxs, ent->s.origin, ent, mask);
42:
43: if (trace.startsolid)
44: return g_edicts;
45:
46: return NULL;
47: }
48:
49:
50: /*
51: ================
52: SV_CheckVelocity
53: ================
54: */
55: void SV_CheckVelocity (edict_t *ent)
56: {
57: int i;
58:
59: //
60: // bound velocity
61: //
62: for (i=0 ; i<3 ; i++)
63: {
64: if (ent->velocity[i] > sv_maxvelocity->value)
65: ent->velocity[i] = sv_maxvelocity->value;
66: else if (ent->velocity[i] < -sv_maxvelocity->value)
67: ent->velocity[i] = -sv_maxvelocity->value;
68: }
69: }
70:
71: /*
72: =============
73: SV_RunThink
74:
75: Runs thinking code for this frame if necessary
76: =============
77: */
78: qboolean SV_RunThink (edict_t *ent)
79: {
80: float thinktime;
81:
82: thinktime = ent->nextthink;
83: if (thinktime <= 0)
84: return true;
85: if (thinktime > level.time+0.001)
86: return true;
87:
88: ent->nextthink = 0;
89: if (!ent->think)
90: gi.error ("NULL ent->think");
91: ent->think (ent);
92:
93: return false;
94: }
95:
96: /*
97: ==================
98: SV_Impact
99:
100: Two entities have touched, so run their touch functions
101: ==================
102: */
103: void SV_Impact (edict_t *e1, trace_t *trace)
104: {
105: edict_t *e2;
106: // cplane_t backplane;
107:
108: e2 = trace->ent;
109:
110: if (e1->touch && e1->solid != SOLID_NOT)
111: e1->touch (e1, e2, &trace->plane, trace->surface);
112:
113: if (e2->touch && e2->solid != SOLID_NOT)
114: e2->touch (e2, e1, NULL, NULL);
115: }
116:
117:
118: /*
119: ==================
120: ClipVelocity
121:
122: Slide off of the impacting object
123: returns the blocked flags (1 = floor, 2 = step / wall)
124: ==================
125: */
126: #define STOP_EPSILON 0.1
127:
128: int ClipVelocity (vec3_t in, vec3_t normal, vec3_t out, float overbounce)
129: {
130: float backoff;
131: float change;
132: int i, blocked;
133:
134: blocked = 0;
135: if (normal[2] > 0)
136: blocked |= 1; // floor
137: if (!normal[2])
138: blocked |= 2; // step
139:
140: backoff = DotProduct (in, normal) * overbounce;
141:
142: for (i=0 ; i<3 ; i++)
143: {
144: change = normal[i]*backoff;
145: out[i] = in[i] - change;
146: if (out[i] > -STOP_EPSILON && out[i] < STOP_EPSILON)
147: out[i] = 0;
148: }
149:
150: return blocked;
151: }
152:
153:
154: /*
155: ============
156: SV_FlyMove
157:
158: The basic solid body movement clip that slides along multiple planes
159: Returns the clipflags if the velocity was modified (hit something solid)
160: 1 = floor
161: 2 = wall / step
162: 4 = dead stop
163: ============
164: */
165: #define MAX_CLIP_PLANES 5
166: int SV_FlyMove (edict_t *ent, float time, int mask)
167: {
168: edict_t *hit;
169: int bumpcount, numbumps;
170: vec3_t dir;
171: float d;
172: int numplanes;
173: vec3_t planes[MAX_CLIP_PLANES];
174: vec3_t primal_velocity, original_velocity, new_velocity;
175: int i, j;
176: trace_t trace;
177: vec3_t end;
178: float time_left;
179: int blocked;
180:
181: numbumps = 4;
182:
183: blocked = 0;
184: VectorCopy (ent->velocity, original_velocity);
185: VectorCopy (ent->velocity, primal_velocity);
186: numplanes = 0;
187:
188: time_left = time;
189:
190: ent->groundentity = NULL;
191: for (bumpcount=0 ; bumpcount<numbumps ; bumpcount++)
192: {
193: for (i=0 ; i<3 ; i++)
194: end[i] = ent->s.origin[i] + time_left * ent->velocity[i];
195:
196: trace = gi.trace (ent->s.origin, ent->mins, ent->maxs, end, ent, mask);
197:
198: if (trace.allsolid)
199: { // entity is trapped in another solid
200: VectorCopy (vec3_origin, ent->velocity);
201: return 3;
202: }
203:
204: if (trace.fraction > 0)
205: { // actually covered some distance
206: VectorCopy (trace.endpos, ent->s.origin);
207: VectorCopy (ent->velocity, original_velocity);
208: numplanes = 0;
209: }
210:
211: if (trace.fraction == 1)
212: break; // moved the entire distance
213:
214: hit = trace.ent;
215:
216: if (trace.plane.normal[2] > 0.7)
217: {
218: blocked |= 1; // floor
219: if ( hit->solid == SOLID_BSP)
220: {
221: ent->groundentity = hit;
222: ent->groundentity_linkcount = hit->linkcount;
223: }
224: }
225: if (!trace.plane.normal[2])
226: {
227: blocked |= 2; // step
228: }
229:
230: //
231: // run the impact function
232: //
233: SV_Impact (ent, &trace);
234: if (!ent->inuse)
235: break; // removed by the impact function
236:
237:
238: time_left -= time_left * trace.fraction;
239:
240: // cliped to another plane
241: if (numplanes >= MAX_CLIP_PLANES)
242: { // this shouldn't really happen
243: VectorCopy (vec3_origin, ent->velocity);
244: return 3;
245: }
246:
247: VectorCopy (trace.plane.normal, planes[numplanes]);
248: numplanes++;
249:
250: //
251: // modify original_velocity so it parallels all of the clip planes
252: //
253: for (i=0 ; i<numplanes ; i++)
254: {
255: ClipVelocity (original_velocity, planes[i], new_velocity, 1);
256:
257: for (j=0 ; j<numplanes ; j++)
258: if ((j != i) && !VectorCompare (planes[i], planes[j]))
259: {
260: if (DotProduct (new_velocity, planes[j]) < 0)
261: break; // not ok
262: }
263: if (j == numplanes)
264: break;
265: }
266:
267: if (i != numplanes)
268: { // go along this plane
269: VectorCopy (new_velocity, ent->velocity);
270: }
271: else
272: { // go along the crease
273: if (numplanes != 2)
274: {
275: // gi.dprintf ("clip velocity, numplanes == %i\n",numplanes);
276: VectorCopy (vec3_origin, ent->velocity);
277: return 7;
278: }
279: CrossProduct (planes[0], planes[1], dir);
280: d = DotProduct (dir, ent->velocity);
281: VectorScale (dir, d, ent->velocity);
282: }
283:
284: //
285: // if original velocity is against the original velocity, stop dead
286: // to avoid tiny occilations in sloping corners
287: //
288: if (DotProduct (ent->velocity, primal_velocity) <= 0)
289: {
290: VectorCopy (vec3_origin, ent->velocity);
291: return blocked;
292: }
293: }
294:
295: return blocked;
296: }
297:
298:
299: /*
300: ============
301: SV_AddGravity
302:
303: ============
304: */
305: void SV_AddGravity (edict_t *ent)
306: {
307: #ifdef ROGUE_GRAVITY
308: if(ent->gravityVector[2] > 0)
309: {
310: VectorMA(ent->velocity,
311: ent->gravity * sv_gravity->value * FRAMETIME,
312: ent->gravityVector,
313: ent->velocity);
314: }
315: else
316: ent->velocity[2] -= ent->gravity * sv_gravity->value * FRAMETIME;
317: #else
318: ent->velocity[2] -= ent->gravity * sv_gravity->value * FRAMETIME;
319: #endif
320: }
321:
322: /*
323: ===============================================================================
324:
325: PUSHMOVE
326:
327: ===============================================================================
328: */
329:
330: /*
331: ============
332: SV_PushEntity
333:
334: Does not change the entities velocity at all
335: ============
336: */
337: trace_t SV_PushEntity (edict_t *ent, vec3_t push)
338: {
339: trace_t trace;
340: vec3_t start;
341: vec3_t end;
342: int mask;
343:
344: VectorCopy (ent->s.origin, start);
345: VectorAdd (start, push, end);
346:
347: retry:
348: if (ent->clipmask)
349: mask = ent->clipmask;
350: else
351: mask = MASK_SOLID;
352:
353: trace = gi.trace (start, ent->mins, ent->maxs, end, ent, mask);
354:
355: VectorCopy (trace.endpos, ent->s.origin);
356: gi.linkentity (ent);
357:
358: if (trace.fraction != 1.0)
359: {
360: SV_Impact (ent, &trace);
361:
362: // if the pushed entity went away and the pusher is still there
363: if (!trace.ent->inuse && ent->inuse)
364: {
365: // move the pusher back and try again
366: VectorCopy (start, ent->s.origin);
367: gi.linkentity (ent);
368: goto retry;
369: }
370: }
371:
372: // ================
373: // PGM
374: // FIXME - is this needed?
375: ent->gravity = 1.0;
376: // PGM
377: // ================
378:
379: if (ent->inuse)
380: G_TouchTriggers (ent);
381:
382: return trace;
383: }
384:
385:
386: typedef struct
387: {
388: edict_t *ent;
389: vec3_t origin;
390: vec3_t angles;
391: float deltayaw;
392: } pushed_t;
393: pushed_t pushed[MAX_EDICTS], *pushed_p;
394:
395: edict_t *obstacle;
396:
397: /*
398: ============
399: SV_Push
400:
401: Objects need to be moved back on a failed push,
402: otherwise riders would continue to slide.
403: ============
404: */
405: qboolean SV_Push (edict_t *pusher, vec3_t move, vec3_t amove)
406: {
407: int i, e;
408: edict_t *check, *block;
409: vec3_t mins, maxs;
410: pushed_t *p;
411: vec3_t org, org2, move2, forward, right, up;
412:
413: // clamp the move to 1/8 units, so the position will
414: // be accurate for client side prediction
415: for (i=0 ; i<3 ; i++)
416: {
417: float temp;
418: temp = move[i]*8.0;
419: if (temp > 0.0)
420: temp += 0.5;
421: else
422: temp -= 0.5;
423: move[i] = 0.125 * (int)temp;
424: }
425:
426: // find the bounding box
427: for (i=0 ; i<3 ; i++)
428: {
429: mins[i] = pusher->absmin[i] + move[i];
430: maxs[i] = pusher->absmax[i] + move[i];
431: }
432:
433: // we need this for pushing things later
434: VectorSubtract (vec3_origin, amove, org);
435: AngleVectors (org, forward, right, up);
436:
437: // save the pusher's original position
438: pushed_p->ent = pusher;
439: VectorCopy (pusher->s.origin, pushed_p->origin);
440: VectorCopy (pusher->s.angles, pushed_p->angles);
441: if (pusher->client)
442: pushed_p->deltayaw = pusher->client->ps.pmove.delta_angles[YAW];
443: pushed_p++;
444:
445: // move the pusher to it's final position
446: VectorAdd (pusher->s.origin, move, pusher->s.origin);
447: VectorAdd (pusher->s.angles, amove, pusher->s.angles);
448: gi.linkentity (pusher);
449:
450: // see if any solid entities are inside the final position
451: check = g_edicts+1;
452: for (e = 1; e < globals.num_edicts; e++, check++)
453: {
454: if (!check->inuse)
455: continue;
456: if (check->movetype == MOVETYPE_PUSH
457: || check->movetype == MOVETYPE_STOP
458: || check->movetype == MOVETYPE_NONE
459: || check->movetype == MOVETYPE_NOCLIP)
460: continue;
461:
462: if (!check->area.prev)
463: continue; // not linked in anywhere
464:
465: // if the entity is standing on the pusher, it will definitely be moved
466: if (check->groundentity != pusher)
467: {
468: // see if the ent needs to be tested
469: if ( check->absmin[0] >= maxs[0]
470: || check->absmin[1] >= maxs[1]
471: || check->absmin[2] >= maxs[2]
472: || check->absmax[0] <= mins[0]
473: || check->absmax[1] <= mins[1]
474: || check->absmax[2] <= mins[2] )
475: continue;
476:
477: // see if the ent's bbox is inside the pusher's final position
478: if (!SV_TestEntityPosition (check))
479: continue;
480: }
481:
482: if ((pusher->movetype == MOVETYPE_PUSH) || (check->groundentity == pusher))
483: {
484: // move this entity
485: pushed_p->ent = check;
486: VectorCopy (check->s.origin, pushed_p->origin);
487: VectorCopy (check->s.angles, pushed_p->angles);
488: pushed_p++;
489:
490: // try moving the contacted entity
491: VectorAdd (check->s.origin, move, check->s.origin);
492: if (check->client)
493: { // FIXME: doesn't rotate monsters?
494: check->client->ps.pmove.delta_angles[YAW] += amove[YAW];
495: }
496:
497: // figure movement due to the pusher's amove
498: VectorSubtract (check->s.origin, pusher->s.origin, org);
499: org2[0] = DotProduct (org, forward);
500: org2[1] = -DotProduct (org, right);
501: org2[2] = DotProduct (org, up);
502: VectorSubtract (org2, org, move2);
503: VectorAdd (check->s.origin, move2, check->s.origin);
504:
505: // may have pushed them off an edge
506: if (check->groundentity != pusher)
507: check->groundentity = NULL;
508:
509: block = SV_TestEntityPosition (check);
510: if (!block)
511: { // pushed ok
512: gi.linkentity (check);
513: // impact?
514: continue;
515: }
516:
517: // if it is ok to leave in the old position, do it
518: // this is only relevent for riding entities, not pushed
519: // FIXME: this doesn't acount for rotation
520: VectorSubtract (check->s.origin, move, check->s.origin);
521: block = SV_TestEntityPosition (check);
522: if (!block)
523: {
524: pushed_p--;
525: continue;
526: }
527: }
528:
529: // save off the obstacle so we can call the block function
530: obstacle = check;
531:
532: // move back any entities we already moved
533: // go backwards, so if the same entity was pushed
534: // twice, it goes back to the original position
535: for (p=pushed_p-1 ; p>=pushed ; p--)
536: {
537: VectorCopy (p->origin, p->ent->s.origin);
538: VectorCopy (p->angles, p->ent->s.angles);
539: if (p->ent->client)
540: {
541: p->ent->client->ps.pmove.delta_angles[YAW] = p->deltayaw;
542: }
543: gi.linkentity (p->ent);
544: }
545: return false;
546: }
547:
548: //FIXME: is there a better way to handle this?
549: // see if anything we moved has touched a trigger
550: for (p=pushed_p-1 ; p>=pushed ; p--)
551: G_TouchTriggers (p->ent);
552:
553: return true;
554: }
555:
556: /*
557: ================
558: SV_Physics_Pusher
559:
560: Bmodel objects don't interact with each other, but
561: push all box objects
562: ================
563: */
564: void SV_Physics_Pusher (edict_t *ent)
565: {
566: vec3_t move, amove;
567: edict_t *part, *mv;
568:
569: // if not a team captain, so movement will be handled elsewhere
570: if ( ent->flags & FL_TEAMSLAVE)
571: return;
572:
573: // make sure all team slaves can move before commiting
574: // any moves or calling any think functions
575: // if the move is blocked, all moved objects will be backed out
576: //retry:
577: pushed_p = pushed;
578: for (part = ent ; part ; part=part->teamchain)
579: {
580: if (part->velocity[0] || part->velocity[1] || part->velocity[2] ||
581: part->avelocity[0] || part->avelocity[1] || part->avelocity[2]
582: )
583: { // object is moving
584: VectorScale (part->velocity, FRAMETIME, move);
585: VectorScale (part->avelocity, FRAMETIME, amove);
586:
587: if (!SV_Push (part, move, amove))
588: break; // move was blocked
589: }
590: }
591: if (pushed_p > &pushed[MAX_EDICTS])
592: gi.error (ERR_FATAL, "pushed_p > &pushed[MAX_EDICTS], memory corrupted");
593:
594: if (part)
595: {
596: // the move failed, bump all nextthink times and back out moves
597: for (mv = ent ; mv ; mv=mv->teamchain)
598: {
599: if (mv->nextthink > 0)
600: mv->nextthink += FRAMETIME;
601: }
602:
603: // if the pusher has a "blocked" function, call it
604: // otherwise, just stay in place until the obstacle is gone
605: if (part->blocked)
606: part->blocked (part, obstacle);
607: #if 0
608: // if the pushed entity went away and the pusher is still there
609: if (!obstacle->inuse && part->inuse)
610: goto retry;
611: #endif
612: }
613: else
614: {
615: // the move succeeded, so call all think functions
616: for (part = ent ; part ; part=part->teamchain)
617: {
618: // prevent entities that are on trains that have gone away from thinking!
619: if (part->inuse)
620: SV_RunThink (part);
621: }
622: }
623: }
624:
625: //==================================================================
626:
627: /*
628: =============
629: SV_Physics_None
630:
631: Non moving objects can only think
632: =============
633: */
634: void SV_Physics_None (edict_t *ent)
635: {
636: // regular thinking
637: SV_RunThink (ent);
638: }
639:
640: /*
641: =============
642: SV_Physics_Noclip
643:
644: A moving object that doesn't obey physics
645: =============
646: */
647: void SV_Physics_Noclip (edict_t *ent)
648: {
649: // regular thinking
650: if (!SV_RunThink (ent))
651: return;
652:
653: VectorMA (ent->s.angles, FRAMETIME, ent->avelocity, ent->s.angles);
654: VectorMA (ent->s.origin, FRAMETIME, ent->velocity, ent->s.origin);
655:
656: gi.linkentity (ent);
657: }
658:
659: /*
660: ==============================================================================
661:
662: TOSS / BOUNCE
663:
664: ==============================================================================
665: */
666:
667: /*
668: =============
669: SV_Physics_Toss
670:
671: Toss, bounce, and fly movement. When onground, do nothing.
672: =============
673: */
674: void SV_Physics_Toss (edict_t *ent)
675: {
676: trace_t trace;
677: vec3_t move;
678: float backoff;
679: edict_t *slave;
680: qboolean wasinwater;
681: qboolean isinwater;
682: vec3_t old_origin;
683:
684: // regular thinking
685: SV_RunThink (ent);
686:
687: // if not a team captain, so movement will be handled elsewhere
688: if ( ent->flags & FL_TEAMSLAVE)
689: return;
690:
691: if (ent->velocity[2] > 0)
692: ent->groundentity = NULL;
693:
694: // check for the groundentity going away
695: if (ent->groundentity)
696: if (!ent->groundentity->inuse)
697: ent->groundentity = NULL;
698:
699: // if onground, return without moving
700: if ( ent->groundentity && ent->gravity > 0.0) // PGM - gravity hack
701: return;
702:
703: VectorCopy (ent->s.origin, old_origin);
704:
705: SV_CheckVelocity (ent);
706:
707: // add gravity
708: if (ent->movetype != MOVETYPE_FLY
709: && ent->movetype != MOVETYPE_FLYMISSILE)
710: SV_AddGravity (ent);
711:
712: // move angles
713: VectorMA (ent->s.angles, FRAMETIME, ent->avelocity, ent->s.angles);
714:
715: // move origin
716: VectorScale (ent->velocity, FRAMETIME, move);
717: trace = SV_PushEntity (ent, move);
718: if (!ent->inuse)
719: return;
720:
721: if (trace.fraction < 1)
722: {
723: if (ent->movetype == MOVETYPE_BOUNCE)
724: backoff = 1.5;
725: else
726: backoff = 1;
727:
728: ClipVelocity (ent->velocity, trace.plane.normal, ent->velocity, backoff);
729:
730: // stop if on ground
731: if (trace.plane.normal[2] > 0.7)
732: {
733: if (ent->velocity[2] < 60 || ent->movetype != MOVETYPE_BOUNCE )
734: {
735: ent->groundentity = trace.ent;
736: ent->groundentity_linkcount = trace.ent->linkcount;
737: VectorCopy (vec3_origin, ent->velocity);
738: VectorCopy (vec3_origin, ent->avelocity);
739: }
740: }
741:
742: // if (ent->touch)
743: // ent->touch (ent, trace.ent, &trace.plane, trace.surface);
744: }
745:
746: // check for water transition
747: wasinwater = (ent->watertype & MASK_WATER);
748: ent->watertype = gi.pointcontents (ent->s.origin);
749: isinwater = ent->watertype & MASK_WATER;
750:
751: if (isinwater)
752: ent->waterlevel = 1;
753: else
754: ent->waterlevel = 0;
755:
756: if (!wasinwater && isinwater)
757: gi.positioned_sound (old_origin, g_edicts, CHAN_AUTO, gi.soundindex("misc/h2ohit1.wav"), 1, 1, 0);
758: else if (wasinwater && !isinwater)
759: gi.positioned_sound (ent->s.origin, g_edicts, CHAN_AUTO, gi.soundindex("misc/h2ohit1.wav"), 1, 1, 0);
760:
761: // move teamslaves
762: for (slave = ent->teamchain; slave; slave = slave->teamchain)
763: {
764: VectorCopy (ent->s.origin, slave->s.origin);
765: gi.linkentity (slave);
766: }
767: }
768:
769: /*
770: ===============================================================================
771:
772: STEPPING MOVEMENT
773:
774: ===============================================================================
775: */
776:
777: /*
778: =============
779: SV_Physics_Step
780:
781: Monsters freefall when they don't have a ground entity, otherwise
782: all movement is done with discrete steps.
783:
784: This is also used for objects that have become still on the ground, but
785: will fall if the floor is pulled out from under them.
786: FIXME: is this true?
787: =============
788: */
789:
790: //FIXME: hacked in for E3 demo
791: //#define sv_stopspeed 100
792: #define sv_friction 6
793: #define sv_waterfriction 1
794:
795: void SV_AddRotationalFriction (edict_t *ent)
796: {
797: int n;
798: float adjustment;
799:
800: VectorMA (ent->s.angles, FRAMETIME, ent->avelocity, ent->s.angles);
801: adjustment = FRAMETIME * sv_stopspeed->value * sv_friction; //PGM now a cvar
802: for (n = 0; n < 3; n++)
803: {
804: if (ent->avelocity[n] > 0)
805: {
806: ent->avelocity[n] -= adjustment;
807: if (ent->avelocity[n] < 0)
808: ent->avelocity[n] = 0;
809: }
810: else
811: {
812: ent->avelocity[n] += adjustment;
813: if (ent->avelocity[n] > 0)
814: ent->avelocity[n] = 0;
815: }
816: }
817: }
818:
819: void SV_Physics_Step (edict_t *ent)
820: {
821: qboolean wasonground;
822: qboolean hitsound = false;
823: float *vel;
824: float speed, newspeed, control;
825: float friction;
826: edict_t *groundentity;
827: int mask;
828:
829: // airborn monsters should always check for ground
830: if (!ent->groundentity)
831: M_CheckGround (ent);
832:
833: groundentity = ent->groundentity;
834:
835: SV_CheckVelocity (ent);
836:
837: if (groundentity)
838: wasonground = true;
839: else
840: wasonground = false;
841:
842: if (ent->avelocity[0] || ent->avelocity[1] || ent->avelocity[2])
843: SV_AddRotationalFriction (ent);
844:
845: // add gravity except:
846: // flying monsters
847: // swimming monsters who are in the water
848: if (! wasonground)
849: if (!(ent->flags & FL_FLY))
850: if (!((ent->flags & FL_SWIM) && (ent->waterlevel > 2)))
851: {
852: if (ent->velocity[2] < sv_gravity->value*-0.1)
853: hitsound = true;
854: if (ent->waterlevel == 0)
855: SV_AddGravity (ent);
856: }
857:
858: // friction for flying monsters that have been given vertical velocity
859: if ((ent->flags & FL_FLY) && (ent->velocity[2] != 0))
860: {
861: speed = fabs(ent->velocity[2]);
862: control = speed < sv_stopspeed->value ? sv_stopspeed->value : speed;
863: friction = sv_friction/3;
864: newspeed = speed - (FRAMETIME * control * friction);
865: if (newspeed < 0)
866: newspeed = 0;
867: newspeed /= speed;
868: ent->velocity[2] *= newspeed;
869: }
870:
871: // friction for flying monsters that have been given vertical velocity
872: if ((ent->flags & FL_SWIM) && (ent->velocity[2] != 0))
873: {
874: speed = fabs(ent->velocity[2]);
875: control = speed < sv_stopspeed->value ? sv_stopspeed->value : speed;
876: newspeed = speed - (FRAMETIME * control * sv_waterfriction * ent->waterlevel);
877: if (newspeed < 0)
878: newspeed = 0;
879: newspeed /= speed;
880: ent->velocity[2] *= newspeed;
881: }
882:
883: if (ent->velocity[2] || ent->velocity[1] || ent->velocity[0])
884: {
885: // apply friction
886: // let dead monsters who aren't completely onground slide
887: if ((wasonground) || (ent->flags & (FL_SWIM|FL_FLY)))
888: if (!(ent->health <= 0.0 && !M_CheckBottom(ent)))
889: {
890: vel = ent->velocity;
891: speed = sqrt(vel[0]*vel[0] +vel[1]*vel[1]);
892: if (speed)
893: {
894: friction = sv_friction;
895:
896: control = speed < sv_stopspeed->value ? sv_stopspeed->value : speed;
897: newspeed = speed - FRAMETIME*control*friction;
898:
899: if (newspeed < 0)
900: newspeed = 0;
901: newspeed /= speed;
902:
903: vel[0] *= newspeed;
904: vel[1] *= newspeed;
905: }
906: }
907:
908: if (ent->svflags & SVF_MONSTER)
909: mask = MASK_MONSTERSOLID;
910: else
911: mask = MASK_SOLID;
912: SV_FlyMove (ent, FRAMETIME, mask);
913:
914: gi.linkentity (ent);
915:
916: // ========
917: // PGM - reset this every time they move.
918: // G_touchtriggers will set it back if appropriate
919: ent->gravity = 1.0;
920: // ========
921:
922: G_TouchTriggers (ent);
923: if (!ent->inuse)
924: return;
925:
926: if (ent->groundentity)
927: if (!wasonground)
928: if (hitsound)
929: gi.sound (ent, 0, gi.soundindex("world/land.wav"), 1, 1, 0);
930: }
931:
932: if(!ent->inuse) // PGM g_touchtrigger free problem
933: return;
934:
935: // regular thinking
936: SV_RunThink (ent);
937: }
938:
939: //============================================================================
940: /*
941: ================
942: G_RunEntity
943:
944: ================
945: */
946: void G_RunEntity (edict_t *ent)
947: {
948: //PGM
949: trace_t trace;
950: vec3_t previous_origin;
951:
952: if(ent->movetype == MOVETYPE_STEP)
953: VectorCopy(ent->s.origin, previous_origin);
954: //PGM
955:
956: if (ent->prethink)
957: ent->prethink (ent);
958:
959: switch ( (int)ent->movetype)
960: {
961: case MOVETYPE_PUSH:
962: case MOVETYPE_STOP:
963: SV_Physics_Pusher (ent);
964: break;
965: case MOVETYPE_NONE:
966: SV_Physics_None (ent);
967: break;
968: case MOVETYPE_NOCLIP:
969: SV_Physics_Noclip (ent);
970: break;
971: case MOVETYPE_STEP:
972: SV_Physics_Step (ent);
973: break;
974: case MOVETYPE_TOSS:
975: case MOVETYPE_BOUNCE:
976: case MOVETYPE_FLY:
977: case MOVETYPE_FLYMISSILE:
978: SV_Physics_Toss (ent);
979: break;
980: case MOVETYPE_NEWTOSS:
981: SV_Physics_NewToss (ent);
982: break;
983: default:
984: gi.error ("SV_Physics: bad movetype %i", (int)ent->movetype);
985: }
986:
987: //PGM
988: if(ent->movetype == MOVETYPE_STEP)
989: {
990: // if we moved, check and fix origin if needed
991: if (!VectorCompare(ent->s.origin, previous_origin))
992: {
993: trace = gi.trace (ent->s.origin, ent->mins, ent->maxs, previous_origin, ent, MASK_MONSTERSOLID);
994: if(trace.allsolid || trace.startsolid)
995: VectorCopy (previous_origin, ent->s.origin);
996: }
997: }
998: //PGM
999: }
1000:
1001: //============
1002: //ROGUE
1003: /*
1004: =============
1005: SV_Physics_NewToss
1006:
1007: Toss, bounce, and fly movement. When on ground and no velocity, do nothing. With velocity,
1008: slide.
1009: =============
1010: */
1011: void SV_Physics_NewToss (edict_t *ent)
1012: {
1013: trace_t trace;
1014: vec3_t move;
1015: // float backoff;
1016: edict_t *slave;
1017: qboolean wasinwater;
1018: qboolean isinwater;
1019: qboolean wasonground;
1020: float speed, newspeed;
1021: vec3_t old_origin;
1022: // float firstmove;
1023: // int mask;
1024:
1025: // regular thinking
1026: SV_RunThink (ent);
1027:
1028: // if not a team captain, so movement will be handled elsewhere
1029: if ( ent->flags & FL_TEAMSLAVE)
1030: return;
1031:
1032: if (ent->groundentity)
1033: wasonground = true;
1034: else
1035: wasonground = false;
1036:
1037: wasinwater = ent->waterlevel;
1038:
1039: // find out what we're sitting on.
1040: VectorCopy (ent->s.origin, move);
1041: move[2] -= 0.25;
1042: trace = gi.trace (ent->s.origin, ent->mins, ent->maxs, move, ent, ent->clipmask);
1043: if(ent->groundentity && ent->groundentity->inuse)
1044: ent->groundentity = trace.ent;
1045: else
1046: ent->groundentity = NULL;
1047:
1048: // if we're sitting on something flat and have no velocity of our own, return.
1049: if (ent->groundentity && (trace.plane.normal[2] == 1.0) &&
1050: !ent->velocity[0] && !ent->velocity[1] && !ent->velocity[2])
1051: {
1052: return;
1053: }
1054:
1055: // store the old origin
1056: VectorCopy (ent->s.origin, old_origin);
1057:
1058: SV_CheckVelocity (ent);
1059:
1060: // add gravity
1061: SV_AddGravity (ent);
1062:
1063: if (ent->avelocity[0] || ent->avelocity[1] || ent->avelocity[2])
1064: SV_AddRotationalFriction (ent);
1065:
1066: // add friction
1067: speed = VectorLength(ent->velocity);
1068: if(ent->waterlevel) // friction for water movement
1069: {
1070: newspeed = speed - (sv_waterfriction * 6 * ent->waterlevel);
1071: if (newspeed < 0)
1072: newspeed = 0;
1073: newspeed /= speed;
1074: VectorScale (ent->velocity, newspeed, ent->velocity);
1075: }
1076: else if (!ent->groundentity) // friction for air movement
1077: {
1078: newspeed = speed - ((sv_friction));
1079: if (newspeed < 0)
1080: newspeed = 0;
1081: newspeed /= speed;
1082: VectorScale (ent->velocity, newspeed, ent->velocity);
1083: }
1084: else // use ground friction
1085: {
1086: newspeed = speed - (sv_friction * 6);
1087: if (newspeed < 0)
1088: newspeed = 0;
1089: newspeed /= speed;
1090: VectorScale (ent->velocity, newspeed, ent->velocity);
1091: }
1092:
1093: SV_FlyMove (ent, FRAMETIME, ent->clipmask);
1094: gi.linkentity (ent);
1095:
1096: G_TouchTriggers (ent);
1097:
1098: // check for water transition
1099: wasinwater = (ent->watertype & MASK_WATER);
1100: ent->watertype = gi.pointcontents (ent->s.origin);
1101: isinwater = ent->watertype & MASK_WATER;
1102:
1103: if (isinwater)
1104: ent->waterlevel = 1;
1105: else
1106: ent->waterlevel = 0;
1107:
1108: if (!wasinwater && isinwater)
1109: gi.positioned_sound (old_origin, g_edicts, CHAN_AUTO, gi.soundindex("misc/h2ohit1.wav"), 1, 1, 0);
1110: else if (wasinwater && !isinwater)
1111: gi.positioned_sound (ent->s.origin, g_edicts, CHAN_AUTO, gi.soundindex("misc/h2ohit1.wav"), 1, 1, 0);
1112:
1113: // move teamslaves
1114: for (slave = ent->teamchain; slave; slave = slave->teamchain)
1115: {
1116: VectorCopy (ent->s.origin, slave->s.origin);
1117: gi.linkentity (slave);
1118: }
1119: }
1120:
1121: //ROGUE
1122: //============
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.