![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to sv_phys.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Quake] / quake1|
Return to sv_phys.c CVS log | Up to [Quake] / quake1 |
1.1 root 1: // sv_phys.c
2:
3: #include "quakedef.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: cvar_t sv_friction = {"sv_friction","4",false,true};
24: cvar_t sv_stopspeed = {"sv_stopspeed","100"};
25: cvar_t sv_gravity = {"sv_gravity","800",false,true};
26: cvar_t sv_maxvelocity = {"sv_maxvelocity","2000"};
27: cvar_t sv_nostep = {"sv_nostep","0"};
28:
29: #define MOVE_EPSILON 0.01
30:
31: void SV_Physics_Toss (edict_t *ent);
32:
33: /*
34: ================
35: SV_CheckAllEnts
36: ================
37: */
38: void SV_CheckAllEnts (void)
39: {
40: int e;
41: edict_t *check;
42:
43: // see if any solid entities are inside the final position
44: check = NEXT_EDICT(sv.edicts);
45: for (e=1 ; e<sv.num_edicts ; e++, check = NEXT_EDICT(check))
46: {
47: if (check->free)
48: continue;
49: if (check->v.movetype == MOVETYPE_PUSH
50: || check->v.movetype == MOVETYPE_NONE
51: || check->v.movetype == MOVETYPE_NOCLIP)
52: continue;
53:
54: if (SV_TestEntityPosition (check))
55: Con_Printf ("entity in invalid position\n");
56: }
57: }
58:
59: /*
60: ================
61: SV_CheckVelocity
62: ================
63: */
64: void SV_CheckVelocity (edict_t *ent)
65: {
66: int i;
67:
68: //
69: // bound velocity
70: //
71: for (i=0 ; i<3 ; i++)
72: {
73: if (IS_NAN(ent->v.velocity[i]))
74: {
75: Con_Printf ("Got a NaN velocity on %s\n", pr_strings + ent->v.classname);
76: ent->v.velocity[i] = 0;
77: }
78: if (IS_NAN(ent->v.origin[i]))
79: {
80: Con_Printf ("Got a NaN origin on %s\n", pr_strings + ent->v.classname);
81: ent->v.origin[i] = 0;
82: }
83: if (ent->v.velocity[i] > sv_maxvelocity.value)
84: ent->v.velocity[i] = sv_maxvelocity.value;
85: else if (ent->v.velocity[i] < -sv_maxvelocity.value)
86: ent->v.velocity[i] = -sv_maxvelocity.value;
87: }
88: }
89:
90: /*
91: =============
92: SV_RunThink
93:
94: Runs thinking code if time. There is some play in the exact time the think
95: function will be called, because it is called before any movement is done
96: in a frame. Not used for pushmove objects, because they must be exact.
97: Returns false if the entity removed itself.
98: =============
99: */
100: qboolean SV_RunThink (edict_t *ent)
101: {
102: float thinktime;
103:
104: thinktime = ent->v.nextthink;
105: if (thinktime <= 0 || thinktime > sv.time + host_frametime)
106: return true;
107:
108: if (thinktime < sv.time)
109: thinktime = sv.time; // don't let things stay in the past.
110: // it is possible to start that way
111: // by a trigger with a local time.
112: ent->v.nextthink = 0;
113: pr_global_struct->time = thinktime;
114: pr_global_struct->self = EDICT_TO_PROG(ent);
115: pr_global_struct->other = EDICT_TO_PROG(sv.edicts);
116: PR_ExecuteProgram (ent->v.think);
117: return !ent->free;
118: }
119:
120: /*
121: ==================
122: SV_Impact
123:
124: Two entities have touched, so run their touch functions
125: ==================
126: */
127: void SV_Impact (edict_t *e1, edict_t *e2)
128: {
129: int old_self, old_other;
130:
131: old_self = pr_global_struct->self;
132: old_other = pr_global_struct->other;
133:
134: pr_global_struct->time = sv.time;
135: if (e1->v.touch && e1->v.solid != SOLID_NOT)
136: {
137: pr_global_struct->self = EDICT_TO_PROG(e1);
138: pr_global_struct->other = EDICT_TO_PROG(e2);
139: PR_ExecuteProgram (e1->v.touch);
140: }
141:
142: if (e2->v.touch && e2->v.solid != SOLID_NOT)
143: {
144: pr_global_struct->self = EDICT_TO_PROG(e2);
145: pr_global_struct->other = EDICT_TO_PROG(e1);
146: PR_ExecuteProgram (e2->v.touch);
147: }
148:
149: pr_global_struct->self = old_self;
150: pr_global_struct->other = old_other;
151: }
152:
153:
154: /*
155: ==================
156: ClipVelocity
157:
158: Slide off of the impacting object
159: returns the blocked flags (1 = floor, 2 = step / wall)
160: ==================
161: */
162: #define STOP_EPSILON 0.1
163:
164: int ClipVelocity (vec3_t in, vec3_t normal, vec3_t out, float overbounce)
165: {
166: float backoff;
167: float change;
168: int i, blocked;
169:
170: blocked = 0;
171: if (normal[2] > 0)
172: blocked |= 1; // floor
173: if (!normal[2])
174: blocked |= 2; // step
175:
176: backoff = DotProduct (in, normal) * overbounce;
177:
178: for (i=0 ; i<3 ; i++)
179: {
180: change = normal[i]*backoff;
181: out[i] = in[i] - change;
182: if (out[i] > -STOP_EPSILON && out[i] < STOP_EPSILON)
183: out[i] = 0;
184: }
185:
186: return blocked;
187: }
188:
189:
190: /*
191: ============
192: SV_FlyMove
193:
194: The basic solid body movement clip that slides along multiple planes
195: Returns the clipflags if the velocity was modified (hit something solid)
196: 1 = floor
197: 2 = wall / step
198: 4 = dead stop
199: If steptrace is not NULL, the trace of any vertical wall hit will be stored
200: ============
201: */
202: #define MAX_CLIP_PLANES 5
203: int SV_FlyMove (edict_t *ent, float time, trace_t *steptrace)
204: {
205: int bumpcount, numbumps;
206: vec3_t dir;
207: float d;
208: int numplanes;
209: vec3_t planes[MAX_CLIP_PLANES];
210: vec3_t primal_velocity, original_velocity, new_velocity;
211: int i, j;
212: trace_t trace;
213: vec3_t end;
214: float time_left;
215: int blocked;
216:
217: numbumps = 4;
218:
219: blocked = 0;
220: VectorCopy (ent->v.velocity, original_velocity);
221: VectorCopy (ent->v.velocity, primal_velocity);
222: numplanes = 0;
223:
224: time_left = time;
225:
226: for (bumpcount=0 ; bumpcount<numbumps ; bumpcount++)
227: {
228: for (i=0 ; i<3 ; i++)
229: end[i] = ent->v.origin[i] + time_left * ent->v.velocity[i];
230:
231: trace = SV_Move (ent->v.origin, ent->v.mins, ent->v.maxs, end, false, ent);
232:
233: if (trace.allsolid)
234: { // entity is trapped in another solid
235: VectorCopy (vec3_origin, ent->v.velocity);
236: return 3;
237: }
238:
239: if (trace.fraction > 0)
240: { // actually covered some distance
241: VectorCopy (trace.endpos, ent->v.origin);
242: VectorCopy (ent->v.velocity, original_velocity);
243: numplanes = 0;
244: }
245:
246: if (trace.fraction == 1)
247: break; // moved the entire distance
248:
249: if (!trace.ent)
250: Sys_Error ("SV_FlyMove: !trace.ent");
251:
252: if (trace.plane.normal[2] > 0.7)
253: {
254: blocked |= 1; // floor
255: if (trace.ent->v.solid == SOLID_BSP)
256: {
257: ent->v.flags = (int)ent->v.flags | FL_ONGROUND;
258: ent->v.groundentity = EDICT_TO_PROG(trace.ent);
259: }
260: }
261: if (!trace.plane.normal[2])
262: {
263: blocked |= 2; // step
264: if (steptrace)
265: *steptrace = trace; // save for player extrafriction
266: }
267:
268: //
269: // run the impact function
270: //
271: SV_Impact (ent, trace.ent);
272: if (ent->free)
273: break; // removed by the impact function
274:
275:
276: time_left -= time_left * trace.fraction;
277:
278: // cliped to another plane
279: if (numplanes >= MAX_CLIP_PLANES)
280: { // this shouldn't really happen
281: VectorCopy (vec3_origin, ent->v.velocity);
282: return 3;
283: }
284:
285: VectorCopy (trace.plane.normal, planes[numplanes]);
286: numplanes++;
287:
288: //
289: // modify original_velocity so it parallels all of the clip planes
290: //
291: for (i=0 ; i<numplanes ; i++)
292: {
293: ClipVelocity (original_velocity, planes[i], new_velocity, 1);
294: for (j=0 ; j<numplanes ; j++)
295: if (j != i)
296: {
297: if (DotProduct (new_velocity, planes[j]) < 0)
298: break; // not ok
299: }
300: if (j == numplanes)
301: break;
302: }
303:
304: if (i != numplanes)
305: { // go along this plane
306: VectorCopy (new_velocity, ent->v.velocity);
307: }
308: else
309: { // go along the crease
310: if (numplanes != 2)
311: {
312: // Con_Printf ("clip velocity, numplanes == %i\n",numplanes);
313: VectorCopy (vec3_origin, ent->v.velocity);
314: return 7;
315: }
316: CrossProduct (planes[0], planes[1], dir);
317: d = DotProduct (dir, ent->v.velocity);
318: VectorScale (dir, d, ent->v.velocity);
319: }
320:
321: //
322: // if original velocity is against the original velocity, stop dead
323: // to avoid tiny occilations in sloping corners
324: //
325: if (DotProduct (ent->v.velocity, primal_velocity) <= 0)
326: {
327: VectorCopy (vec3_origin, ent->v.velocity);
328: return blocked;
329: }
330: }
331:
332: return blocked;
333: }
334:
335:
336: /*
337: ============
338: SV_AddGravity
339:
340: ============
341: */
342: void SV_AddGravity (edict_t *ent, float scale)
343: {
344: ent->v.velocity[2] -= scale * sv_gravity.value * host_frametime;
345: }
346:
347: /*
348: ===============================================================================
349:
350: PUSHMOVE
351:
352: ===============================================================================
353: */
354:
355: /*
356: ============
357: SV_PushEntity
358:
359: Does not change the entities velocity at all
360: ============
361: */
362: trace_t SV_PushEntity (edict_t *ent, vec3_t push)
363: {
364: trace_t trace;
365: vec3_t end;
366:
367: VectorAdd (ent->v.origin, push, end);
368:
369: if (ent->v.movetype == MOVETYPE_FLYMISSILE)
370: trace = SV_Move (ent->v.origin, ent->v.mins, ent->v.maxs, end, MOVE_MISSILE, ent);
371: else if (ent->v.solid == SOLID_TRIGGER || ent->v.solid == SOLID_NOT)
372: // only clip against bmodels
373: trace = SV_Move (ent->v.origin, ent->v.mins, ent->v.maxs, end, MOVE_NOMONSTERS, ent);
374: else
375: trace = SV_Move (ent->v.origin, ent->v.mins, ent->v.maxs, end, MOVE_NORMAL, ent);
376:
377: VectorCopy (trace.endpos, ent->v.origin);
378: SV_LinkEdict (ent, true);
379:
380: if (trace.ent)
381: SV_Impact (ent, trace.ent);
382:
383: return trace;
384: }
385:
386:
387: /*
388: ============
389: SV_PushMove
390:
391: ============
392: */
393: void SV_PushMove (edict_t *pusher, float movetime)
394: {
395: int i, e;
396: edict_t *check, *block;
397: vec3_t mins, maxs, move;
398: vec3_t entorig, pushorig;
399: int num_moved;
400: edict_t *moved_edict[MAX_EDICTS];
401: vec3_t moved_from[MAX_EDICTS];
402:
403: if (!pusher->v.velocity[0] && !pusher->v.velocity[1] && !pusher->v.velocity[2])
404: {
405: pusher->v.ltime += movetime;
406: return;
407: }
408:
409: for (i=0 ; i<3 ; i++)
410: {
411: move[i] = pusher->v.velocity[i] * movetime;
412: mins[i] = pusher->v.absmin[i] + move[i];
413: maxs[i] = pusher->v.absmax[i] + move[i];
414: }
415:
416: VectorCopy (pusher->v.origin, pushorig);
417:
418: // move the pusher to it's final position
419:
420: VectorAdd (pusher->v.origin, move, pusher->v.origin);
421: pusher->v.ltime += movetime;
422: SV_LinkEdict (pusher, false);
423:
424:
425: // see if any solid entities are inside the final position
426: num_moved = 0;
427: check = NEXT_EDICT(sv.edicts);
428: for (e=1 ; e<sv.num_edicts ; e++, check = NEXT_EDICT(check))
429: {
430: if (check->free)
431: continue;
432: if (check->v.movetype == MOVETYPE_PUSH
433: || check->v.movetype == MOVETYPE_NONE
434: || check->v.movetype == MOVETYPE_NOCLIP)
435: continue;
436:
437: // if the entity is standing on the pusher, it will definately be moved
438: if ( ! ( ((int)check->v.flags & FL_ONGROUND)
439: && PROG_TO_EDICT(check->v.groundentity) == pusher) )
440: {
441: if ( check->v.absmin[0] >= maxs[0]
442: || check->v.absmin[1] >= maxs[1]
443: || check->v.absmin[2] >= maxs[2]
444: || check->v.absmax[0] <= mins[0]
445: || check->v.absmax[1] <= mins[1]
446: || check->v.absmax[2] <= mins[2] )
447: continue;
448:
449: // see if the ent's bbox is inside the pusher's final position
450: if (!SV_TestEntityPosition (check))
451: continue;
452: }
453:
454: // remove the onground flag for non-players
455: if (check->v.movetype != MOVETYPE_WALK)
456: check->v.flags = (int)check->v.flags & ~FL_ONGROUND;
457:
458: VectorCopy (check->v.origin, entorig);
459: VectorCopy (check->v.origin, moved_from[num_moved]);
460: moved_edict[num_moved] = check;
461: num_moved++;
462:
463: // try moving the contacted entity
464: pusher->v.solid = SOLID_NOT;
465: SV_PushEntity (check, move);
466: pusher->v.solid = SOLID_BSP;
467:
468: // if it is still inside the pusher, block
469: block = SV_TestEntityPosition (check);
470: if (block)
471: { // fail the move
472: if (check->v.mins[0] == check->v.maxs[0])
473: continue;
474: if (check->v.solid == SOLID_NOT || check->v.solid == SOLID_TRIGGER)
475: { // corpse
476: check->v.mins[0] = check->v.mins[1] = 0;
477: VectorCopy (check->v.mins, check->v.maxs);
478: continue;
479: }
480:
481: VectorCopy (entorig, check->v.origin);
482: SV_LinkEdict (check, true);
483:
484: VectorCopy (pushorig, pusher->v.origin);
485: SV_LinkEdict (pusher, false);
486: pusher->v.ltime -= movetime;
487:
488: // if the pusher has a "blocked" function, call it
489: // otherwise, just stay in place until the obstacle is gone
490: if (pusher->v.blocked)
491: {
492: pr_global_struct->self = EDICT_TO_PROG(pusher);
493: pr_global_struct->other = EDICT_TO_PROG(check);
494: PR_ExecuteProgram (pusher->v.blocked);
495: }
496:
497: // move back any entities we already moved
498: for (i=0 ; i<num_moved ; i++)
499: {
500: VectorCopy (moved_from[i], moved_edict[i]->v.origin);
501: SV_LinkEdict (moved_edict[i], false);
502: }
503: return;
504: }
505: }
506:
507:
508: }
509:
510:
511: /*
512: ================
513: SV_Physics_Pusher
514:
515: ================
516: */
517: void SV_Physics_Pusher (edict_t *ent)
518: {
519: float thinktime;
520: float oldltime;
521: float movetime;
522:
523: oldltime = ent->v.ltime;
524:
525: thinktime = ent->v.nextthink;
526: if (thinktime < ent->v.ltime + host_frametime)
527: {
528: movetime = thinktime - ent->v.ltime;
529: if (movetime < 0)
530: movetime = 0;
531: }
532: else
533: movetime = host_frametime;
534:
535: if (movetime)
536: {
537: SV_PushMove (ent, movetime); // advances ent->v.ltime if not blocked
538: }
539:
540: if (thinktime > oldltime && thinktime <= ent->v.ltime)
541: {
542: ent->v.nextthink = 0;
543: pr_global_struct->time = sv.time;
544: pr_global_struct->self = EDICT_TO_PROG(ent);
545: pr_global_struct->other = EDICT_TO_PROG(sv.edicts);
546: PR_ExecuteProgram (ent->v.think);
547: if (ent->free)
548: return;
549: }
550:
551: }
552:
553:
554: /*
555: ===============================================================================
556:
557: CLIENT MOVEMENT
558:
559: ===============================================================================
560: */
561:
562: /*
563: =============
564: SV_CheckStuck
565:
566: This is a big hack to try and fix the rare case of getting stuck in the world
567: clipping hull.
568: =============
569: */
570: void SV_CheckStuck (edict_t *ent)
571: {
572: int i, j;
573: int z;
574: vec3_t org;
575:
576: if (!SV_TestEntityPosition(ent))
577: {
578: VectorCopy (ent->v.origin, ent->v.oldorigin);
579: return;
580: }
581:
582: VectorCopy (ent->v.origin, org);
583: VectorCopy (ent->v.oldorigin, ent->v.origin);
584: if (!SV_TestEntityPosition(ent))
585: {
586: Con_Printf ("Unstuck.\n");
587: SV_LinkEdict (ent, true);
588: return;
589: }
590:
591: for (z=0 ; z< 18 ; z++)
592: for (i=-1 ; i <= 1 ; i++)
593: for (j=-1 ; j <= 1 ; j++)
594: {
595: ent->v.origin[0] = org[0] + i;
596: ent->v.origin[1] = org[1] + j;
597: ent->v.origin[2] = org[2] + z;
598: if (!SV_TestEntityPosition(ent))
599: {
600: Con_DPrintf ("Unstuck.\n");
601: SV_LinkEdict (ent, true);
602: return;
603: }
604: }
605:
606: VectorCopy (org, ent->v.origin);
607: Con_DPrintf ("player is stuck.\n");
608: }
609:
610:
611: /*
612: =============
613: SV_CheckWater
614: =============
615: */
616: qboolean SV_CheckWater (edict_t *ent)
617: {
618: vec3_t point;
619: int cont;
620:
621: point[0] = ent->v.origin[0];
622: point[1] = ent->v.origin[1];
623:
624: ent->v.waterlevel = 0;
625: ent->v.watertype = CONTENTS_EMPTY;
626: point[2] = ent->v.origin[2] + ent->v.mins[2] + 1;
627: cont = SV_PointContents (point);
628: if (cont <= CONTENTS_WATER)
629: {
630: ent->v.watertype = cont;
631: ent->v.waterlevel = 1;
632: point[2] = ent->v.origin[2] + (ent->v.mins[2] + ent->v.maxs[2])*0.5;
633: cont = SV_PointContents (point);
634: if (cont <= CONTENTS_WATER)
635: {
636: ent->v.waterlevel = 2;
637: point[2] = ent->v.origin[2] + ent->v.view_ofs[2];
638: cont = SV_PointContents (point);
639: if (cont <= CONTENTS_WATER)
640: ent->v.waterlevel = 3;
641: }
642: }
643:
644: return ent->v.waterlevel > 1;
645: }
646:
647: /*
648: ============
649: SV_WallFriction
650:
651: ============
652: */
653: void SV_WallFriction (edict_t *ent, trace_t *trace)
654: {
655: vec3_t forward, right, up;
656: float d, i;
657: vec3_t into, side;
658:
659: AngleVectors (ent->v.v_angle, forward, right, up);
660: d = DotProduct (trace->plane.normal, forward);
661:
662: d += 0.5;
663: if (d >= 0)
664: return;
665:
666: // cut the tangential velocity
667: i = DotProduct (trace->plane.normal, ent->v.velocity);
668: VectorScale (trace->plane.normal, i, into);
669: VectorSubtract (ent->v.velocity, into, side);
670:
671: ent->v.velocity[0] = side[0] * (1 + d);
672: ent->v.velocity[1] = side[1] * (1 + d);
673: }
674:
675: /*
676: =====================
677: SV_TryUnstick
678:
679: Player has come to a dead stop, possibly due to the problem with limited
680: float precision at some angle joins in the BSP hull.
681:
682: Try fixing by pushing one pixel in each direction.
683:
684: This is a hack, but in the interest of good gameplay...
685: ======================
686: */
687: int SV_TryUnstick (edict_t *ent, vec3_t oldvel)
688: {
689: int i;
690: vec3_t oldorg;
691: vec3_t dir;
692: int clip;
693: trace_t steptrace;
694:
695: VectorCopy (ent->v.origin, oldorg);
696: VectorCopy (vec3_origin, dir);
697:
698: for (i=0 ; i<8 ; i++)
699: {
700: // try pushing a little in an axial direction
701: switch (i)
702: {
703: case 0: dir[0] = 2; dir[1] = 0; break;
704: case 1: dir[0] = 0; dir[1] = 2; break;
705: case 2: dir[0] = -2; dir[1] = 0; break;
706: case 3: dir[0] = 0; dir[1] = -2; break;
707: case 4: dir[0] = 2; dir[1] = 2; break;
708: case 5: dir[0] = -2; dir[1] = 2; break;
709: case 6: dir[0] = 2; dir[1] = -2; break;
710: case 7: dir[0] = -2; dir[1] = -2; break;
711: }
712:
713: SV_PushEntity (ent, dir);
714:
715: // retry the original move
716: ent->v.velocity[0] = oldvel[0];
717: ent->v. velocity[1] = oldvel[1];
718: ent->v. velocity[2] = 0;
719: clip = SV_FlyMove (ent, 0.1, &steptrace);
720:
721: if ( fabs(oldorg[1] - ent->v.origin[1]) > 4
722: || fabs(oldorg[0] - ent->v.origin[0]) > 4 )
723: {
724: //Con_Printf ("unstuck!\n");
725: return clip;
726: }
727:
728: // go back to the original pos and try again
729: VectorCopy (oldorg, ent->v.origin);
730: }
731:
732: VectorCopy (vec3_origin, ent->v.velocity);
733: return 7; // still not moving
734: }
735:
736: /*
737: =====================
738: SV_WalkMove
739:
740: Only used by players
741: ======================
742: */
743: #define STEPSIZE 18
744: void SV_WalkMove (edict_t *ent)
745: {
746: vec3_t upmove, downmove;
747: vec3_t oldorg, oldvel;
748: vec3_t nosteporg, nostepvel;
749: int clip;
750: int oldonground;
751: trace_t steptrace, downtrace;
752:
753: //
754: // do a regular slide move unless it looks like you ran into a step
755: //
756: oldonground = (int)ent->v.flags & FL_ONGROUND;
757: ent->v.flags = (int)ent->v.flags & ~FL_ONGROUND;
758:
759: VectorCopy (ent->v.origin, oldorg);
760: VectorCopy (ent->v.velocity, oldvel);
761:
762: clip = SV_FlyMove (ent, host_frametime, &steptrace);
763:
764: if ( !(clip & 2) )
765: return; // move didn't block on a step
766:
767: if (!oldonground && ent->v.waterlevel == 0)
768: return; // don't stair up while jumping
769:
770: if (ent->v.movetype != MOVETYPE_WALK)
771: return; // gibbed by a trigger
772:
773: if (sv_nostep.value)
774: return;
775:
776: if ( (int)sv_player->v.flags & FL_WATERJUMP )
777: return;
778:
779: VectorCopy (ent->v.origin, nosteporg);
780: VectorCopy (ent->v.velocity, nostepvel);
781:
782: //
783: // try moving up and forward to go up a step
784: //
785: VectorCopy (oldorg, ent->v.origin); // back to start pos
786:
787: VectorCopy (vec3_origin, upmove);
788: VectorCopy (vec3_origin, downmove);
789: upmove[2] = STEPSIZE;
790: downmove[2] = -STEPSIZE + oldvel[2]*host_frametime;
791:
792: // move up
793: SV_PushEntity (ent, upmove); // FIXME: don't link?
794:
795: // move forward
796: ent->v.velocity[0] = oldvel[0];
797: ent->v. velocity[1] = oldvel[1];
798: ent->v. velocity[2] = 0;
799: clip = SV_FlyMove (ent, host_frametime, &steptrace);
800:
801: // check for stuckness, possibly due to the limited precision of floats
802: // in the clipping hulls
803: if (clip)
804: {
805: if ( fabs(oldorg[1] - ent->v.origin[1]) < 0.03125
806: && fabs(oldorg[0] - ent->v.origin[0]) < 0.03125 )
807: { // stepping up didn't make any progress
808: clip = SV_TryUnstick (ent, oldvel);
809: }
810: }
811:
812: // extra friction based on view angle
813: if ( clip & 2 )
814: SV_WallFriction (ent, &steptrace);
815:
816: // move down
817: downtrace = SV_PushEntity (ent, downmove); // FIXME: don't link?
818:
819: if (downtrace.plane.normal[2] > 0.7)
820: {
821: if (ent->v.solid == SOLID_BSP)
822: {
823: ent->v.flags = (int)ent->v.flags | FL_ONGROUND;
824: ent->v.groundentity = EDICT_TO_PROG(downtrace.ent);
825: }
826: }
827: else
828: {
829: // if the push down didn't end up on good ground, use the move without
830: // the step up. This happens near wall / slope combinations, and can
831: // cause the player to hop up higher on a slope too steep to climb
832: VectorCopy (nosteporg, ent->v.origin);
833: VectorCopy (nostepvel, ent->v.velocity);
834: }
835: }
836:
837:
838: /*
839: ================
840: SV_Physics_Client
841:
842: Player character actions
843: ================
844: */
845: void SV_Physics_Client (edict_t *ent, int num)
846: {
847: if ( ! svs.clients[num-1].active )
848: return; // unconnected slot
849:
850: //
851: // call standard client pre-think
852: //
853: pr_global_struct->time = sv.time;
854: pr_global_struct->self = EDICT_TO_PROG(ent);
855: PR_ExecuteProgram (pr_global_struct->PlayerPreThink);
856:
857: //
858: // do a move
859: //
860: SV_CheckVelocity (ent);
861:
862: //
863: // decide which move function to call
864: //
865: switch ((int)ent->v.movetype)
866: {
867: case MOVETYPE_NONE:
868: if (!SV_RunThink (ent))
869: return;
870: break;
871:
872: case MOVETYPE_WALK:
873: if (!SV_RunThink (ent))
874: return;
875: if (!SV_CheckWater (ent) && ! ((int)ent->v.flags & FL_WATERJUMP) )
876: SV_AddGravity (ent, 1.0);
877: SV_CheckStuck (ent);
878: SV_WalkMove (ent);
879: break;
880:
881: case MOVETYPE_TOSS:
882: case MOVETYPE_BOUNCE:
883: SV_Physics_Toss (ent);
884: break;
885:
886: case MOVETYPE_FLY:
887: if (!SV_RunThink (ent))
888: return;
889: SV_FlyMove (ent, host_frametime, NULL);
890: break;
891:
892: case MOVETYPE_NOCLIP:
893: if (!SV_RunThink (ent))
894: return;
895: VectorMA (ent->v.origin, host_frametime, ent->v.velocity, ent->v.origin);
896: break;
897:
898: default:
899: Sys_Error ("SV_Physics_client: bad movetype %i", (int)ent->v.movetype);
900: }
901:
902: //
903: // call standard player post-think
904: //
905: SV_LinkEdict (ent, true);
906:
907: pr_global_struct->time = sv.time;
908: pr_global_struct->self = EDICT_TO_PROG(ent);
909: PR_ExecuteProgram (pr_global_struct->PlayerPostThink);
910: }
911:
912: //============================================================================
913:
914: /*
915: =============
916: SV_Physics_None
917:
918: Non moving objects can only think
919: =============
920: */
921: void SV_Physics_None (edict_t *ent)
922: {
923: // regular thinking
924: SV_RunThink (ent);
925: }
926:
927: /*
928: =============
929: SV_Physics_Noclip
930:
931: A moving object that doesn't obey physics
932: =============
933: */
934: void SV_Physics_Noclip (edict_t *ent)
935: {
936: // regular thinking
937: if (!SV_RunThink (ent))
938: return;
939:
940: VectorMA (ent->v.angles, host_frametime, ent->v.avelocity, ent->v.angles);
941: VectorMA (ent->v.origin, host_frametime, ent->v.velocity, ent->v.origin);
942:
943: SV_LinkEdict (ent, false);
944: }
945:
946: /*
947: ==============================================================================
948:
949: TOSS / BOUNCE
950:
951: ==============================================================================
952: */
953:
954: /*
955: =============
956: SV_CheckWaterTransition
957:
958: =============
959: */
960: void SV_CheckWaterTransition (edict_t *ent)
961: {
962: int cont;
963:
964: cont = SV_PointContents (ent->v.origin);
965: if (!ent->v.watertype)
966: { // just spawned here
967: ent->v.watertype = cont;
968: ent->v.waterlevel = 1;
969: return;
970: }
971:
972: if (cont <= CONTENTS_WATER)
973: {
974: if (ent->v.watertype == CONTENTS_EMPTY)
975: { // just crossed into water
976: SV_StartSound (ent, 0, "misc/h2ohit1.wav", 255, 1);
977: }
978: ent->v.watertype = cont;
979: ent->v.waterlevel = 1;
980: }
981: else
982: {
983: if (ent->v.watertype != CONTENTS_EMPTY)
984: { // just crossed into water
985: SV_StartSound (ent, 0, "misc/h2ohit1.wav", 255, 1);
986: }
987: ent->v.watertype = CONTENTS_EMPTY;
988: ent->v.waterlevel = cont;
989: }
990: }
991:
992: /*
993: =============
994: SV_Physics_Toss
995:
996: Toss, bounce, and fly movement. When onground, do nothing.
997: =============
998: */
999: void SV_Physics_Toss (edict_t *ent)
1000: {
1001: trace_t trace;
1002: vec3_t move;
1003: float backoff;
1004:
1005: // regular thinking
1006: if (!SV_RunThink (ent))
1007: return;
1008:
1009: // if onground, return without moving
1010: if ( ((int)ent->v.flags & FL_ONGROUND) )
1011: return;
1012:
1013: SV_CheckVelocity (ent);
1014:
1015: // add gravity
1016: if (ent->v.movetype != MOVETYPE_FLY
1017: && ent->v.movetype != MOVETYPE_FLYMISSILE)
1018: SV_AddGravity (ent, 1.0);
1019:
1020: // move angles
1021: VectorMA (ent->v.angles, host_frametime, ent->v.avelocity, ent->v.angles);
1022:
1023: // move origin
1024: VectorScale (ent->v.velocity, host_frametime, move);
1025: trace = SV_PushEntity (ent, move);
1026: if (trace.fraction == 1)
1027: return;
1028: if (ent->free)
1029: return;
1030:
1031: if (ent->v.movetype == MOVETYPE_BOUNCE)
1032: backoff = 1.5;
1033: else
1034: backoff = 1;
1035:
1036: ClipVelocity (ent->v.velocity, trace.plane.normal, ent->v.velocity, backoff);
1037:
1038: // stop if on ground
1039: if (trace.plane.normal[2] > 0.7)
1040: {
1041: if (ent->v.velocity[2] < 60 || ent->v.movetype != MOVETYPE_BOUNCE )
1042: {
1043: ent->v.flags = (int)ent->v.flags | FL_ONGROUND;
1044: ent->v.groundentity = EDICT_TO_PROG(trace.ent);
1045: VectorCopy (vec3_origin, ent->v.velocity);
1046: VectorCopy (vec3_origin, ent->v.avelocity);
1047: }
1048: }
1049:
1050: // check for in water
1051: SV_CheckWaterTransition (ent);
1052: }
1053:
1054: /*
1055: ===============================================================================
1056:
1057: STEPPING MOVEMENT
1058:
1059: ===============================================================================
1060: */
1061:
1062: /*
1063: =============
1064: SV_Physics_Step
1065:
1066: Monsters freefall when they don't have a ground entity, otherwise
1067: all movement is done with discrete steps.
1068:
1069: This is also used for objects that have become still on the ground, but
1070: will fall if the floor is pulled out from under them.
1071: =============
1072: */
1073: void SV_Physics_Step (edict_t *ent)
1074: {
1075: qboolean hitsound;
1076:
1077: // frefall if not onground
1078: if ( ! ((int)ent->v.flags & (FL_ONGROUND | FL_FLY | FL_SWIM) ) )
1079: {
1080: if (ent->v.velocity[2] < sv_gravity.value*-0.1)
1081: hitsound = true;
1082: else
1083: hitsound = false;
1084:
1085: SV_AddGravity (ent, 1.0);
1086: SV_CheckVelocity (ent);
1087: SV_FlyMove (ent, host_frametime, NULL);
1088: SV_LinkEdict (ent, true);
1089:
1090: if ( (int)ent->v.flags & FL_ONGROUND ) // just hit ground
1091: {
1092: if (hitsound)
1093: SV_StartSound (ent, 0, "demon/dland2.wav", 255, 1);
1094: }
1095: }
1096:
1097: // regular thinking
1098: SV_RunThink (ent);
1099:
1100: SV_CheckWaterTransition (ent);
1101: }
1102:
1103: //============================================================================
1104:
1105: /*
1106: ================
1107: SV_Physics
1108:
1109: ================
1110: */
1111: void SV_Physics (void)
1112: {
1113: int i;
1114: edict_t *ent;
1115:
1116: // let the progs know that a new frame has started
1117: pr_global_struct->self = EDICT_TO_PROG(sv.edicts);
1118: pr_global_struct->other = EDICT_TO_PROG(sv.edicts);
1119: pr_global_struct->time = sv.time;
1120: PR_ExecuteProgram (pr_global_struct->StartFrame);
1121:
1122: //SV_CheckAllEnts ();
1123:
1124: //
1125: // treat each object in turn
1126: //
1127: ent = sv.edicts;
1128: for (i=0 ; i<sv.num_edicts ; i++, ent = NEXT_EDICT(ent))
1129: {
1130: if (ent->free)
1131: continue;
1132:
1133: if (pr_global_struct->force_retouch)
1134: {
1135: SV_LinkEdict (ent, true); // force retouch even for stationary
1136: }
1137:
1138: if (i > 0 && i <= svs.maxclients)
1139: SV_Physics_Client (ent, i);
1140: else if (ent->v.movetype == MOVETYPE_PUSH)
1141: SV_Physics_Pusher (ent);
1142: else if (ent->v.movetype == MOVETYPE_NONE)
1143: SV_Physics_None (ent);
1144: else if (ent->v.movetype == MOVETYPE_NOCLIP)
1145: SV_Physics_Noclip (ent);
1146: else if (ent->v.movetype == MOVETYPE_STEP)
1147: SV_Physics_Step (ent);
1148: else if (ent->v.movetype == MOVETYPE_TOSS
1149: || ent->v.movetype == MOVETYPE_BOUNCE
1150: || ent->v.movetype == MOVETYPE_FLY
1151: || ent->v.movetype == MOVETYPE_FLYMISSILE)
1152: SV_Physics_Toss (ent);
1153: else
1154: Sys_Error ("SV_Physics: bad movetype %i", (int)ent->v.movetype);
1155: }
1156:
1157: if (pr_global_struct->force_retouch)
1158: pr_global_struct->force_retouch--;
1159:
1160: sv.time += host_frametime;
1161: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.