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