2 Copyright (C) 1996-1997 Id Software, Inc.
4 This program is free software; you can redistribute it and/or
5 modify it under the terms of the GNU General Public License
6 as published by the Free Software Foundation; either version 2
7 of the License, or (at your option) any later version.
9 This program is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
13 See the GNU General Public License for more details.
15 You should have received a copy of the GNU General Public License
16 along with this program; if not, write to the Free Software
17 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
27 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.
29 onground is set for toss objects when they come to a complete rest. it is set for steping or walking objects
31 doors, plats, etc are SOLID_BSP, and MOVETYPE_PUSH
32 bonus items are SOLID_TRIGGER touch, and MOVETYPE_TOSS
33 corpses are SOLID_NOT and MOVETYPE_TOSS
34 crates are SOLID_BBOX and MOVETYPE_TOSS
35 walking monsters are SOLID_SLIDEBOX and MOVETYPE_STEP
36 flying/floating monsters are SOLID_SLIDEBOX and MOVETYPE_FLY
38 solid_edge items only clip against bsp models.
42 cvar_t sv_friction = {CVAR_NOTIFY, "sv_friction","4"};
43 cvar_t sv_stopspeed = {CVAR_NOTIFY, "sv_stopspeed","100"};
44 cvar_t sv_gravity = {CVAR_NOTIFY, "sv_gravity","800"};
45 cvar_t sv_maxvelocity = {CVAR_NOTIFY, "sv_maxvelocity","2000"};
46 cvar_t sv_nostep = {CVAR_NOTIFY, "sv_nostep","0"};
47 cvar_t sv_stepheight = {CVAR_NOTIFY, "sv_stepheight", "18"};
48 cvar_t sv_jumpstep = {CVAR_NOTIFY, "sv_jumpstep", "1"};
49 cvar_t sv_wallfriction = {CVAR_NOTIFY, "sv_wallfriction", "1"};
50 cvar_t sv_newflymove = {CVAR_NOTIFY, "sv_newflymove", "1"};
52 #define MOVE_EPSILON 0.01
54 void SV_Physics_Toss (edict_t *ent);
56 void SV_Phys_Init (void)
58 Cvar_RegisterVariable(&sv_stepheight);
59 Cvar_RegisterVariable(&sv_jumpstep);
60 Cvar_RegisterVariable(&sv_wallfriction);
61 Cvar_RegisterVariable(&sv_newflymove);
69 void SV_CheckAllEnts (void)
74 // see if any solid entities are inside the final position
75 check = NEXT_EDICT(sv.edicts);
76 for (e = 1;e < sv.num_edicts;e++, check = NEXT_EDICT(check))
80 if (check->v->movetype == MOVETYPE_PUSH
81 || check->v->movetype == MOVETYPE_NONE
82 || check->v->movetype == MOVETYPE_FOLLOW
83 || check->v->movetype == MOVETYPE_NOCLIP)
86 if (SV_TestEntityPosition (check))
87 Con_Printf ("entity in invalid position\n");
96 void SV_CheckVelocity (edict_t *ent)
104 for (i=0 ; i<3 ; i++)
106 if (IS_NAN(ent->v->velocity[i]))
108 Con_Printf ("Got a NaN velocity on %s\n", PR_GetString(ent->v->classname));
109 ent->v->velocity[i] = 0;
111 if (IS_NAN(ent->v->origin[i]))
113 Con_Printf ("Got a NaN origin on %s\n", PR_GetString(ent->v->classname));
114 ent->v->origin[i] = 0;
118 // LordHavoc: max velocity fix, inspired by Maddes's source fixes, but this is faster
119 wishspeed = DotProduct(ent->v->velocity, ent->v->velocity);
120 if (wishspeed > sv_maxvelocity.value * sv_maxvelocity.value)
122 wishspeed = sv_maxvelocity.value / sqrt(wishspeed);
123 ent->v->velocity[0] *= wishspeed;
124 ent->v->velocity[1] *= wishspeed;
125 ent->v->velocity[2] *= wishspeed;
133 Runs thinking code if time. There is some play in the exact time the think
134 function will be called, because it is called before any movement is done
135 in a frame. Not used for pushmove objects, because they must be exact.
136 Returns false if the entity removed itself.
139 qboolean SV_RunThink (edict_t *ent)
143 thinktime = ent->v->nextthink;
144 if (thinktime <= 0 || thinktime > sv.time + sv.frametime)
147 // don't let things stay in the past.
148 // it is possible to start that way by a trigger with a local time.
149 if (thinktime < sv.time)
152 ent->v->nextthink = 0;
153 pr_global_struct->time = thinktime;
154 pr_global_struct->self = EDICT_TO_PROG(ent);
155 pr_global_struct->other = EDICT_TO_PROG(sv.edicts);
156 PR_ExecuteProgram (ent->v->think, "NULL think function");
157 return !ent->e->free;
164 Two entities have touched, so run their touch functions
167 void SV_Impact (edict_t *e1, edict_t *e2)
169 int old_self, old_other;
171 old_self = pr_global_struct->self;
172 old_other = pr_global_struct->other;
174 pr_global_struct->time = sv.time;
175 if (e1->v->touch && e1->v->solid != SOLID_NOT)
177 pr_global_struct->self = EDICT_TO_PROG(e1);
178 pr_global_struct->other = EDICT_TO_PROG(e2);
179 PR_ExecuteProgram (e1->v->touch, "");
182 if (e2->v->touch && e2->v->solid != SOLID_NOT)
184 pr_global_struct->self = EDICT_TO_PROG(e2);
185 pr_global_struct->other = EDICT_TO_PROG(e1);
186 PR_ExecuteProgram (e2->v->touch, "");
189 pr_global_struct->self = old_self;
190 pr_global_struct->other = old_other;
198 Slide off of the impacting object
199 returns the blocked flags (1 = floor, 2 = step / wall)
202 #define STOP_EPSILON 0.1
203 void ClipVelocity (vec3_t in, vec3_t normal, vec3_t out, float overbounce)
208 backoff = -DotProduct (in, normal) * overbounce;
209 VectorMA(in, backoff, normal, out);
211 for (i = 0;i < 3;i++)
212 if (out[i] > -STOP_EPSILON && out[i] < STOP_EPSILON)
221 The basic solid body movement clip that slides along multiple planes
222 Returns the clipflags if the velocity was modified (hit something solid)
226 If stepnormal is not NULL, the plane normal of any vertical wall hit will be stored
229 // LordHavoc: increased from 5 to 20
230 #define MAX_CLIP_PLANES 20
231 int SV_FlyMove (edict_t *ent, float time, float *stepnormal)
233 if (sv_newflymove.integer)
235 int blocked, impact, bumpcount;
236 vec3_t end, primal_velocity;
240 VectorCopy (ent->v->velocity, primal_velocity);
242 for (bumpcount = 0;bumpcount < 4;bumpcount++)
244 if (!ent->v->velocity[0] && !ent->v->velocity[1] && !ent->v->velocity[2])
247 VectorMA(ent->v->origin, time, ent->v->velocity, end);
248 trace = SV_Move (ent->v->origin, ent->v->mins, ent->v->maxs, end, MOVE_NORMAL, ent);
249 //Con_Printf("trace %f %f %f : %f : %f %f %f\n", trace.endpos[0], trace.endpos[1], trace.endpos[2], trace.fraction, trace.plane.normal[0], trace.plane.normal[1], trace.plane.normal[2]);
253 // LordHavoc: note: this code is what makes entities stick in place if embedded in another object (which can be the world)
254 // entity is trapped in another solid
255 VectorClear(ent->v->velocity);
259 if (trace.fraction > 0)
261 // actually covered some distance
262 VectorCopy (trace.endpos, ent->v->origin);
265 // break if it moved the entire distance
266 if (trace.fraction == 1)
270 Host_Error ("SV_FlyMove: !trace.ent");
272 if ((int) ent->v->flags & FL_ONGROUND)
274 if (ent->v->groundentity == EDICT_TO_PROG(trace.ent))
278 ent->v->flags = (int)ent->v->flags & ~FL_ONGROUND;
285 if (trace.plane.normal[2] > 0.7)
289 ent->v->flags = (int)ent->v->flags | FL_ONGROUND;
290 ent->v->groundentity = EDICT_TO_PROG(trace.ent);
292 if (!trace.plane.normal[2])
296 // save the trace for player extrafriction
298 VectorCopy(trace.plane.normal, stepnormal);
301 // run the impact function
304 SV_Impact (ent, trace.ent);
306 // break if removed by the impact function
311 time *= 1 - trace.fraction;
313 ClipVelocity (ent->v->velocity, trace.plane.normal, ent->v->velocity, 1);
320 int i, j, blocked, impact, numplanes, bumpcount, numbumps;
322 vec3_t dir, end, planes[MAX_CLIP_PLANES], primal_velocity, original_velocity, new_velocity;
328 VectorCopy (ent->v->velocity, original_velocity);
329 VectorCopy (ent->v->velocity, primal_velocity);
334 for (bumpcount=0 ; bumpcount<numbumps ; bumpcount++)
336 if (!ent->v->velocity[0] && !ent->v->velocity[1] && !ent->v->velocity[2])
339 for (i=0 ; i<3 ; i++)
340 end[i] = ent->v->origin[i] + time_left * ent->v->velocity[i];
342 trace = SV_Move (ent->v->origin, ent->v->mins, ent->v->maxs, end, MOVE_NORMAL, ent);
346 // LordHavoc: note: this code is what makes entities stick in place if embedded in another object (which can be the world)
347 // entity is trapped in another solid
348 VectorClear(ent->v->velocity);
352 if (trace.fraction > 0)
354 // actually covered some distance
355 VectorCopy (trace.endpos, ent->v->origin);
356 VectorCopy (ent->v->velocity, original_velocity);
360 // break if it moved the entire distance
361 if (trace.fraction == 1)
365 Host_Error ("SV_FlyMove: !trace.ent");
367 if ((int) ent->v->flags & FL_ONGROUND)
369 if (ent->v->groundentity == EDICT_TO_PROG(trace.ent))
373 ent->v->flags = (int)ent->v->flags & ~FL_ONGROUND;
380 if (trace.plane.normal[2] > 0.7)
384 ent->v->flags = (int)ent->v->flags | FL_ONGROUND;
385 ent->v->groundentity = EDICT_TO_PROG(trace.ent);
387 if (!trace.plane.normal[2])
391 // save the trace for player extrafriction
393 VectorCopy(trace.plane.normal, stepnormal);
396 // run the impact function
399 SV_Impact (ent, trace.ent);
401 // break if removed by the impact function
407 time_left -= time_left * trace.fraction;
409 // clipped to another plane
410 if (numplanes >= MAX_CLIP_PLANES)
412 // this shouldn't really happen
413 VectorClear(ent->v->velocity);
417 VectorCopy (trace.plane.normal, planes[numplanes]);
420 // modify original_velocity so it parallels all of the clip planes
421 for (i=0 ; i<numplanes ; i++)
423 ClipVelocity (original_velocity, planes[i], new_velocity, 1);
424 for (j=0 ; j<numplanes ; j++)
428 if (DotProduct (new_velocity, planes[j]) < 0)
437 // go along this plane
438 VectorCopy (new_velocity, ent->v->velocity);
442 // go along the crease
445 VectorClear(ent->v->velocity);
448 CrossProduct (planes[0], planes[1], dir);
449 // LordHavoc: thanks to taniwha of QuakeForge for pointing out this fix for slowed falling in corners
450 VectorNormalize(dir);
451 d = DotProduct (dir, ent->v->velocity);
452 VectorScale (dir, d, ent->v->velocity);
455 // if original velocity is against the original velocity,
456 // stop dead to avoid tiny occilations in sloping corners
457 if (DotProduct (ent->v->velocity, primal_velocity) <= 0)
459 VectorClear(ent->v->velocity);
475 void SV_AddGravity (edict_t *ent)
480 val = GETEDICTFIELDVALUE(ent, eval_gravity);
481 if (val!=0 && val->_float)
482 ent_gravity = val->_float;
485 ent->v->velocity[2] -= ent_gravity * sv_gravity.value * sv.frametime;
490 ===============================================================================
494 ===============================================================================
501 Does not change the entities velocity at all
504 trace_t SV_PushEntity (edict_t *ent, vec3_t push, vec3_t pushangles)
509 VectorAdd (ent->v->origin, push, end);
511 if (ent->v->movetype == MOVETYPE_FLYMISSILE)
512 trace = SV_Move (ent->v->origin, ent->v->mins, ent->v->maxs, end, MOVE_MISSILE, ent);
513 else if (ent->v->solid == SOLID_TRIGGER || ent->v->solid == SOLID_NOT)
514 // only clip against bmodels
515 trace = SV_Move (ent->v->origin, ent->v->mins, ent->v->maxs, end, MOVE_NOMONSTERS, ent);
517 trace = SV_Move (ent->v->origin, ent->v->mins, ent->v->maxs, end, MOVE_NORMAL, ent);
519 VectorCopy (trace.endpos, ent->v->origin);
520 // FIXME: turn players specially
521 ent->v->angles[1] += trace.fraction * pushangles[1];
522 SV_LinkEdict (ent, true);
524 if (trace.ent && (!((int)ent->v->flags & FL_ONGROUND) || ent->v->groundentity != EDICT_TO_PROG(trace.ent)))
525 SV_Impact (ent, trace.ent);
536 trace_t SV_ClipMoveToEntity (edict_t *ent, vec3_t start, vec3_t mins, vec3_t maxs, vec3_t end);
537 void SV_PushMove (edict_t *pusher, float movetime)
541 float savesolid, movetime2, pushltime;
542 vec3_t mins, maxs, move, move1, moveangle, pushorig, pushang, a, forward, left, up, org, org2;
544 model_t *pushermodel;
547 switch ((int) pusher->v->solid)
549 // LordHavoc: valid pusher types
553 case SOLID_CORPSE: // LordHavoc: this would be weird...
555 // LordHavoc: no collisions
558 VectorMA (pusher->v->origin, movetime, pusher->v->velocity, pusher->v->origin);
559 VectorMA (pusher->v->angles, movetime, pusher->v->avelocity, pusher->v->angles);
560 pusher->v->ltime += movetime;
561 SV_LinkEdict (pusher, false);
564 Host_Error("SV_PushMove: unrecognized solid type %f\n", pusher->v->solid);
566 if (!pusher->v->velocity[0] && !pusher->v->velocity[1] && !pusher->v->velocity[2] && !pusher->v->avelocity[0] && !pusher->v->avelocity[1] && !pusher->v->avelocity[2])
568 pusher->v->ltime += movetime;
571 index = (int) pusher->v->modelindex;
572 if (index < 1 || index >= MAX_MODELS)
573 Host_Error("SV_PushMove: invalid modelindex %f\n", pusher->v->modelindex);
574 pushermodel = sv.models[index];
576 movetime2 = movetime;
577 VectorScale(pusher->v->velocity, movetime2, move1);
578 VectorScale(pusher->v->avelocity, movetime2, moveangle);
579 if (moveangle[0] || moveangle[2])
581 for (i = 0;i < 3;i++)
585 mins[i] = pushermodel->rotatedmins[i] + pusher->v->origin[i] - 1;
586 maxs[i] = pushermodel->rotatedmaxs[i] + move1[i] + pusher->v->origin[i] + 1;
590 mins[i] = pushermodel->rotatedmins[i] + move1[i] + pusher->v->origin[i] - 1;
591 maxs[i] = pushermodel->rotatedmaxs[i] + pusher->v->origin[i] + 1;
595 else if (moveangle[1])
597 for (i = 0;i < 3;i++)
601 mins[i] = pushermodel->yawmins[i] + pusher->v->origin[i] - 1;
602 maxs[i] = pushermodel->yawmaxs[i] + move1[i] + pusher->v->origin[i] + 1;
606 mins[i] = pushermodel->yawmins[i] + move1[i] + pusher->v->origin[i] - 1;
607 maxs[i] = pushermodel->yawmaxs[i] + pusher->v->origin[i] + 1;
613 for (i = 0;i < 3;i++)
617 mins[i] = pushermodel->normalmins[i] + pusher->v->origin[i] - 1;
618 maxs[i] = pushermodel->normalmaxs[i] + move1[i] + pusher->v->origin[i] + 1;
622 mins[i] = pushermodel->normalmins[i] + move1[i] + pusher->v->origin[i] - 1;
623 maxs[i] = pushermodel->normalmaxs[i] + pusher->v->origin[i] + 1;
628 VectorNegate (moveangle, a);
629 AngleVectorsFLU (a, forward, left, up);
631 VectorCopy (pusher->v->origin, pushorig);
632 VectorCopy (pusher->v->angles, pushang);
633 pushltime = pusher->v->ltime;
635 // move the pusher to it's final position
637 VectorMA (pusher->v->origin, movetime, pusher->v->velocity, pusher->v->origin);
638 VectorMA (pusher->v->angles, movetime, pusher->v->avelocity, pusher->v->angles);
639 pusher->v->ltime += movetime;
640 SV_LinkEdict (pusher, false);
642 savesolid = pusher->v->solid;
644 // see if any solid entities are inside the final position
646 check = NEXT_EDICT(sv.edicts);
647 for (e = 1;e < sv.num_edicts;e++, check = NEXT_EDICT(check))
651 if (check->v->movetype == MOVETYPE_PUSH
652 || check->v->movetype == MOVETYPE_NONE
653 || check->v->movetype == MOVETYPE_FOLLOW
654 || check->v->movetype == MOVETYPE_NOCLIP)
657 // if the entity is standing on the pusher, it will definitely be moved
658 if (!(((int)check->v->flags & FL_ONGROUND) && PROG_TO_EDICT(check->v->groundentity) == pusher))
660 if (check->v->absmin[0] >= maxs[0]
661 || check->v->absmax[0] <= mins[0]
662 || check->v->absmin[1] >= maxs[1]
663 || check->v->absmax[1] <= mins[1]
664 || check->v->absmin[2] >= maxs[2]
665 || check->v->absmax[2] <= mins[2])
668 trace = SV_ClipMoveToEntity (pusher, check->v->origin, check->v->mins, check->v->maxs, check->v->origin);
669 if (!trace.startsolid)
673 if (forward[0] < 0.999f) // quick way to check if any rotation is used
675 VectorSubtract (check->v->origin, pusher->v->origin, org);
676 org2[0] = DotProduct (org, forward);
677 org2[1] = DotProduct (org, left);
678 org2[2] = DotProduct (org, up);
679 VectorSubtract (org2, org, move);
680 VectorAdd (move, move1, move);
683 VectorCopy (move1, move);
685 // remove the onground flag for non-players
686 if (check->v->movetype != MOVETYPE_WALK)
687 check->v->flags = (int)check->v->flags & ~FL_ONGROUND;
689 VectorCopy (check->v->origin, check->e->moved_from);
690 VectorCopy (check->v->angles, check->e->moved_fromangles);
691 sv.moved_edicts[num_moved++] = check;
693 // try moving the contacted entity
694 pusher->v->solid = SOLID_NOT;
695 trace = SV_PushEntity (check, move, moveangle);
696 pusher->v->solid = savesolid; // was SOLID_BSP
698 // if it is still inside the pusher, block
699 if (SV_TestEntityPosition (check))
701 // try moving the contacted entity a tiny bit further to account for precision errors
702 pusher->v->solid = SOLID_NOT;
703 VectorScale(move, 0.1, move);
704 trace = SV_PushEntity (check, move, vec3_origin);
705 pusher->v->solid = savesolid;
706 if (SV_TestEntityPosition (check))
708 // still inside pusher, so it's really blocked
711 if (check->v->mins[0] == check->v->maxs[0])
713 if (check->v->solid == SOLID_NOT || check->v->solid == SOLID_TRIGGER)
716 check->v->mins[0] = check->v->mins[1] = 0;
717 VectorCopy (check->v->mins, check->v->maxs);
721 VectorCopy (pushorig, pusher->v->origin);
722 VectorCopy (pushang, pusher->v->angles);
723 pusher->v->ltime = pushltime;
724 SV_LinkEdict (pusher, false);
726 // move back any entities we already moved
727 for (i = 0;i < num_moved;i++)
729 ed = sv.moved_edicts[i];
730 VectorCopy (ed->e->moved_from, ed->v->origin);
731 VectorCopy (ed->e->moved_fromangles, ed->v->angles);
732 SV_LinkEdict (ed, false);
735 // if the pusher has a "blocked" function, call it, otherwise just stay in place until the obstacle is gone
736 if (pusher->v->blocked)
738 pr_global_struct->self = EDICT_TO_PROG(pusher);
739 pr_global_struct->other = EDICT_TO_PROG(check);
740 PR_ExecuteProgram (pusher->v->blocked, "");
754 void SV_Physics_Pusher (edict_t *ent)
756 float thinktime, oldltime, movetime;
758 oldltime = ent->v->ltime;
760 thinktime = ent->v->nextthink;
761 if (thinktime < ent->v->ltime + sv.frametime)
763 movetime = thinktime - ent->v->ltime;
768 movetime = sv.frametime;
771 // advances ent->v->ltime if not blocked
772 SV_PushMove (ent, movetime);
774 if (thinktime > oldltime && thinktime <= ent->v->ltime)
776 ent->v->nextthink = 0;
777 pr_global_struct->time = sv.time;
778 pr_global_struct->self = EDICT_TO_PROG(ent);
779 pr_global_struct->other = EDICT_TO_PROG(sv.edicts);
780 PR_ExecuteProgram (ent->v->think, "NULL think function");
789 ===============================================================================
793 ===============================================================================
800 This is a big hack to try and fix the rare case of getting stuck in the world
804 void SV_CheckStuck (edict_t *ent)
809 if (!SV_TestEntityPosition(ent))
811 VectorCopy (ent->v->origin, ent->v->oldorigin);
815 VectorCopy (ent->v->origin, org);
816 VectorCopy (ent->v->oldorigin, ent->v->origin);
817 if (!SV_TestEntityPosition(ent))
819 Con_DPrintf ("Unstuck.\n");
820 SV_LinkEdict (ent, true);
824 for (z=0 ; z< 18 ; z++)
825 for (i=-1 ; i <= 1 ; i++)
826 for (j=-1 ; j <= 1 ; j++)
828 ent->v->origin[0] = org[0] + i;
829 ent->v->origin[1] = org[1] + j;
830 ent->v->origin[2] = org[2] + z;
831 if (!SV_TestEntityPosition(ent))
833 Con_DPrintf ("Unstuck.\n");
834 SV_LinkEdict (ent, true);
839 VectorCopy (org, ent->v->origin);
840 Con_DPrintf ("player is stuck.\n");
849 qboolean SV_CheckWater (edict_t *ent)
854 point[0] = ent->v->origin[0];
855 point[1] = ent->v->origin[1];
856 point[2] = ent->v->origin[2] + ent->v->mins[2] + 1;
858 ent->v->waterlevel = 0;
859 ent->v->watertype = CONTENTS_EMPTY;
860 cont = Mod_PointContents(point, sv.worldmodel);
861 if (cont <= CONTENTS_WATER)
863 ent->v->watertype = cont;
864 ent->v->waterlevel = 1;
865 point[2] = ent->v->origin[2] + (ent->v->mins[2] + ent->v->maxs[2])*0.5;
866 cont = Mod_PointContents(point, sv.worldmodel);
867 if (cont <= CONTENTS_WATER)
869 ent->v->waterlevel = 2;
870 point[2] = ent->v->origin[2] + ent->v->view_ofs[2];
871 cont = Mod_PointContents(point, sv.worldmodel);
872 if (cont <= CONTENTS_WATER)
873 ent->v->waterlevel = 3;
877 return ent->v->waterlevel > 1;
886 void SV_WallFriction (edict_t *ent, float *stepnormal)
889 vec3_t forward, into, side;
891 AngleVectors (ent->v->v_angle, forward, NULL, NULL);
892 d = DotProduct (stepnormal, forward);
898 // cut the tangential velocity
899 i = DotProduct (stepnormal, ent->v->velocity);
900 VectorScale (stepnormal, i, into);
901 VectorSubtract (ent->v->velocity, into, side);
903 ent->v->velocity[0] = side[0] * (1 + d);
904 ent->v->velocity[1] = side[1] * (1 + d);
908 =====================
911 Player has come to a dead stop, possibly due to the problem with limited
912 float precision at some angle joins in the BSP hull.
914 Try fixing by pushing one pixel in each direction.
916 This is a hack, but in the interest of good gameplay...
917 ======================
919 int SV_TryUnstick (edict_t *ent, vec3_t oldvel)
924 VectorCopy (ent->v->origin, oldorg);
927 for (i=0 ; i<8 ; i++)
929 // try pushing a little in an axial direction
932 case 0: dir[0] = 2; dir[1] = 0; break;
933 case 1: dir[0] = 0; dir[1] = 2; break;
934 case 2: dir[0] = -2; dir[1] = 0; break;
935 case 3: dir[0] = 0; dir[1] = -2; break;
936 case 4: dir[0] = 2; dir[1] = 2; break;
937 case 5: dir[0] = -2; dir[1] = 2; break;
938 case 6: dir[0] = 2; dir[1] = -2; break;
939 case 7: dir[0] = -2; dir[1] = -2; break;
942 SV_PushEntity (ent, dir, vec3_origin);
944 // retry the original move
945 ent->v->velocity[0] = oldvel[0];
946 ent->v->velocity[1] = oldvel[1];
947 ent->v->velocity[2] = 0;
948 clip = SV_FlyMove (ent, 0.1, NULL);
950 if (fabs(oldorg[1] - ent->v->origin[1]) > 4
951 || fabs(oldorg[0] - ent->v->origin[0]) > 4)
954 // go back to the original pos and try again
955 VectorCopy (oldorg, ent->v->origin);
959 VectorClear (ent->v->velocity);
964 =====================
968 ======================
970 void SV_WalkMove (edict_t *ent)
972 int clip, oldonground;
973 vec3_t upmove, downmove, oldorg, oldvel, nosteporg, nostepvel, stepnormal;
976 // do a regular slide move unless it looks like you ran into a step
977 oldonground = (int)ent->v->flags & FL_ONGROUND;
978 ent->v->flags = (int)ent->v->flags & ~FL_ONGROUND;
980 VectorCopy (ent->v->origin, oldorg);
981 VectorCopy (ent->v->velocity, oldvel);
983 clip = SV_FlyMove (ent, sv.frametime, NULL);
985 // if move didn't block on a step, return
989 if (ent->v->movetype != MOVETYPE_FLY)
991 if (!oldonground && ent->v->waterlevel == 0 && !sv_jumpstep.integer)
992 // don't stair up while jumping
995 if (ent->v->movetype != MOVETYPE_WALK)
996 // gibbed by a trigger
1000 if (sv_nostep.integer)
1003 if ( (int)ent->v->flags & FL_WATERJUMP )
1006 VectorCopy (ent->v->origin, nosteporg);
1007 VectorCopy (ent->v->velocity, nostepvel);
1009 // try moving up and forward to go up a step
1010 // back to start pos
1011 VectorCopy (oldorg, ent->v->origin);
1013 VectorClear (upmove);
1014 VectorClear (downmove);
1015 upmove[2] = sv_stepheight.value;
1016 downmove[2] = -sv_stepheight.value + oldvel[2]*sv.frametime;
1019 // FIXME: don't link?
1020 SV_PushEntity (ent, upmove, vec3_origin);
1023 ent->v->velocity[0] = oldvel[0];
1024 ent->v->velocity[1] = oldvel[1];
1025 ent->v->velocity[2] = 0;
1026 clip = SV_FlyMove (ent, sv.frametime, stepnormal);
1027 ent->v->velocity[2] += oldvel[2];
1029 // check for stuckness, possibly due to the limited precision of floats
1030 // in the clipping hulls
1032 && fabs(oldorg[1] - ent->v->origin[1]) < 0.03125
1033 && fabs(oldorg[0] - ent->v->origin[0]) < 0.03125)
1034 // stepping up didn't make any progress
1035 clip = SV_TryUnstick (ent, oldvel);
1037 // extra friction based on view angle
1038 if (clip & 2 && sv_wallfriction.integer)
1039 SV_WallFriction (ent, stepnormal);
1042 // FIXME: don't link?
1043 downtrace = SV_PushEntity (ent, downmove, vec3_origin);
1045 if (downtrace.plane.normal[2] > 0.7)
1047 // LordHavoc: disabled this so you can walk on monsters/players
1048 //if (ent->v->solid == SOLID_BSP)
1050 ent->v->flags = (int)ent->v->flags | FL_ONGROUND;
1051 ent->v->groundentity = EDICT_TO_PROG(downtrace.ent);
1056 // if the push down didn't end up on good ground, use the move without
1057 // the step up. This happens near wall / slope combinations, and can
1058 // cause the player to hop up higher on a slope too steep to climb
1059 VectorCopy (nosteporg, ent->v->origin);
1060 VectorCopy (nostepvel, ent->v->velocity);
1064 //============================================================================
1070 Entities that are "stuck" to another entity
1073 void SV_Physics_Follow (edict_t *ent)
1075 vec3_t vf, vr, vu, angles, v;
1079 if (!SV_RunThink (ent))
1082 // LordHavoc: implemented rotation on MOVETYPE_FOLLOW objects
1083 e = PROG_TO_EDICT(ent->v->aiment);
1084 if (e->v->angles[0] == ent->v->punchangle[0] && e->v->angles[1] == ent->v->punchangle[1] && e->v->angles[2] == ent->v->punchangle[2])
1086 // quick case for no rotation
1087 VectorAdd(e->v->origin, ent->v->view_ofs, ent->v->origin);
1091 angles[0] = -ent->v->punchangle[0];
1092 angles[1] = ent->v->punchangle[1];
1093 angles[2] = ent->v->punchangle[2];
1094 AngleVectors (angles, vf, vr, vu);
1095 v[0] = ent->v->view_ofs[0] * vf[0] + ent->v->view_ofs[1] * vr[0] + ent->v->view_ofs[2] * vu[0];
1096 v[1] = ent->v->view_ofs[0] * vf[1] + ent->v->view_ofs[1] * vr[1] + ent->v->view_ofs[2] * vu[1];
1097 v[2] = ent->v->view_ofs[0] * vf[2] + ent->v->view_ofs[1] * vr[2] + ent->v->view_ofs[2] * vu[2];
1098 angles[0] = -e->v->angles[0];
1099 angles[1] = e->v->angles[1];
1100 angles[2] = e->v->angles[2];
1101 AngleVectors (angles, vf, vr, vu);
1102 ent->v->origin[0] = v[0] * vf[0] + v[1] * vf[1] + v[2] * vf[2] + e->v->origin[0];
1103 ent->v->origin[1] = v[0] * vr[0] + v[1] * vr[1] + v[2] * vr[2] + e->v->origin[1];
1104 ent->v->origin[2] = v[0] * vu[0] + v[1] * vu[1] + v[2] * vu[2] + e->v->origin[2];
1106 VectorAdd (e->v->angles, ent->v->v_angle, ent->v->angles);
1107 SV_LinkEdict (ent, true);
1114 A moving object that doesn't obey physics
1117 void SV_Physics_Noclip (edict_t *ent)
1120 if (!SV_RunThink (ent))
1123 VectorMA (ent->v->angles, sv.frametime, ent->v->avelocity, ent->v->angles);
1124 VectorMA (ent->v->origin, sv.frametime, ent->v->velocity, ent->v->origin);
1126 SV_LinkEdict (ent, false);
1130 ==============================================================================
1134 ==============================================================================
1139 SV_CheckWaterTransition
1143 void SV_CheckWaterTransition (edict_t *ent)
1146 cont = Mod_PointContents(ent->v->origin, sv.worldmodel);
1147 if (!ent->v->watertype)
1149 // just spawned here
1150 ent->v->watertype = cont;
1151 ent->v->waterlevel = 1;
1155 if (cont <= CONTENTS_WATER)
1157 if (ent->v->watertype == CONTENTS_EMPTY && cont != CONTENTS_LAVA)
1158 // just crossed into water
1159 SV_StartSound (ent, 0, "misc/h2ohit1.wav", 255, 1);
1161 ent->v->watertype = cont;
1162 ent->v->waterlevel = 1;
1166 if (ent->v->watertype != CONTENTS_EMPTY && ent->v->watertype != CONTENTS_LAVA)
1167 // just crossed into water
1168 SV_StartSound (ent, 0, "misc/h2ohit1.wav", 255, 1);
1170 ent->v->watertype = CONTENTS_EMPTY;
1171 ent->v->waterlevel = cont;
1179 Toss, bounce, and fly movement. When onground, do nothing.
1182 void SV_Physics_Toss (edict_t *ent)
1186 edict_t *groundentity;
1189 if (!SV_RunThink (ent))
1192 // if onground, return without moving
1193 if ((int)ent->v->flags & FL_ONGROUND)
1195 VectorClear(ent->v->velocity);
1196 if (ent->v->groundentity == 0)
1198 // if ent was supported by a brush model on previous frame,
1199 // and groundentity is now freed, set groundentity to 0 (floating)
1200 groundentity = PROG_TO_EDICT(ent->v->groundentity);
1201 if (groundentity->v->solid == SOLID_BSP)
1203 ent->e->suspendedinairflag = true;
1206 else if (ent->e->suspendedinairflag && groundentity->e->free)
1208 // leave it suspended in the air
1209 ent->v->groundentity = 0;
1210 ent->e->suspendedinairflag = false;
1214 ent->e->suspendedinairflag = false;
1216 SV_CheckVelocity (ent);
1219 if (ent->v->movetype == MOVETYPE_TOSS || ent->v->movetype == MOVETYPE_BOUNCE)
1220 SV_AddGravity (ent);
1223 VectorMA (ent->v->angles, sv.frametime, ent->v->avelocity, ent->v->angles);
1226 VectorScale (ent->v->velocity, sv.frametime, move);
1227 trace = SV_PushEntity (ent, move, vec3_origin);
1231 if (trace.fraction < 1)
1233 if (ent->v->movetype == MOVETYPE_BOUNCEMISSILE)
1235 ClipVelocity (ent->v->velocity, trace.plane.normal, ent->v->velocity, 2.0);
1236 ent->v->flags = (int)ent->v->flags & ~FL_ONGROUND;
1238 else if (ent->v->movetype == MOVETYPE_BOUNCE)
1240 ClipVelocity (ent->v->velocity, trace.plane.normal, ent->v->velocity, 1.5);
1241 // LordHavoc: fixed grenades not bouncing when fired down a slope
1242 if (trace.plane.normal[2] > 0.7 && DotProduct(trace.plane.normal, ent->v->velocity) < 60)
1244 ent->v->flags = (int)ent->v->flags | FL_ONGROUND;
1245 ent->v->groundentity = EDICT_TO_PROG(trace.ent);
1246 VectorClear (ent->v->velocity);
1247 VectorClear (ent->v->avelocity);
1250 ent->v->flags = (int)ent->v->flags & ~FL_ONGROUND;
1254 ClipVelocity (ent->v->velocity, trace.plane.normal, ent->v->velocity, 1.0);
1255 if (trace.plane.normal[2] > 0.7)
1257 ent->v->flags = (int)ent->v->flags | FL_ONGROUND;
1258 ent->v->groundentity = EDICT_TO_PROG(trace.ent);
1259 VectorClear (ent->v->velocity);
1260 VectorClear (ent->v->avelocity);
1263 ent->v->flags = (int)ent->v->flags & ~FL_ONGROUND;
1267 // check for in water
1268 SV_CheckWaterTransition (ent);
1272 ===============================================================================
1276 ===============================================================================
1283 Monsters freefall when they don't have a ground entity, otherwise
1284 all movement is done with discrete steps.
1286 This is also used for objects that have become still on the ground, but
1287 will fall if the floor is pulled out from under them.
1290 void SV_Physics_Step (edict_t *ent)
1292 int flags, fall, hitsound;
1294 // freefall if not fly/swim
1296 flags = (int)ent->v->flags;
1297 if (flags & (FL_FLY | FL_SWIM))
1301 else if ((flags & FL_SWIM) && Mod_PointContents(ent->v->origin, sv.worldmodel) != CONTENTS_EMPTY)
1304 if (fall && (flags & FL_ONGROUND) && ent->v->groundentity == 0)
1309 if (ent->v->velocity[2] < sv_gravity.value*-0.1)
1312 if (flags & FL_ONGROUND)
1318 SV_AddGravity (ent);
1319 SV_CheckVelocity (ent);
1320 SV_FlyMove (ent, sv.frametime, NULL);
1321 SV_LinkEdict (ent, false);
1324 if ((int)ent->v->flags & FL_ONGROUND)
1326 VectorClear(ent->v->velocity);
1328 SV_StartSound (ent, 0, "demon/dland2.wav", 255, 1);
1335 SV_CheckWaterTransition (ent);
1338 //============================================================================
1346 void SV_Physics (void)
1351 // let the progs know that a new frame has started
1352 pr_global_struct->self = EDICT_TO_PROG(sv.edicts);
1353 pr_global_struct->other = EDICT_TO_PROG(sv.edicts);
1354 pr_global_struct->time = sv.time;
1355 PR_ExecuteProgram (pr_global_struct->StartFrame, "QC function StartFrame is missing");
1358 // treat each object in turn
1361 for (i=0 ; i<sv.num_edicts ; i++, ent = NEXT_EDICT(ent))
1366 if (pr_global_struct->force_retouch)
1367 SV_LinkEdict (ent, true); // force retouch even for stationary
1369 if (i > 0 && i <= svs.maxclients)
1371 if (!svs.clients[i-1].active)
1374 // call standard client pre-think
1375 SV_CheckVelocity (ent);
1376 pr_global_struct->time = sv.time;
1377 pr_global_struct->self = EDICT_TO_PROG(ent);
1378 PR_ExecuteProgram (pr_global_struct->PlayerPreThink, "QC function PlayerPreThink is missing");
1379 SV_CheckVelocity (ent);
1382 // LordHavoc: merged client and normal entity physics
1383 switch ((int) ent->v->movetype)
1386 SV_Physics_Pusher (ent);
1389 // LordHavoc: manually inlined the thinktime check here because MOVETYPE_NONE is used on so many objects
1390 if (ent->v->nextthink > 0 && ent->v->nextthink <= sv.time + sv.frametime)
1393 case MOVETYPE_FOLLOW:
1394 SV_Physics_Follow (ent);
1396 case MOVETYPE_NOCLIP:
1397 if (i > 0 && i <= svs.maxclients)
1399 if (SV_RunThink (ent))
1401 SV_CheckWater (ent);
1402 VectorMA (ent->v->origin, sv.frametime, ent->v->velocity, ent->v->origin);
1403 VectorMA (ent->v->angles, sv.frametime, ent->v->avelocity, ent->v->angles);
1407 SV_Physics_Noclip (ent);
1410 SV_Physics_Step (ent);
1413 if (SV_RunThink (ent))
1415 if (!SV_CheckWater (ent) && ! ((int)ent->v->flags & FL_WATERJUMP) )
1416 SV_AddGravity (ent);
1417 SV_CheckStuck (ent);
1419 SV_LinkEdict (ent, true);
1423 case MOVETYPE_BOUNCE:
1424 case MOVETYPE_BOUNCEMISSILE:
1425 case MOVETYPE_FLYMISSILE:
1426 SV_Physics_Toss (ent);
1429 if (i > 0 && i <= svs.maxclients)
1431 if (SV_RunThink (ent))
1433 SV_CheckWater (ent);
1438 SV_Physics_Toss (ent);
1441 Host_Error ("SV_Physics: bad movetype %i", (int)ent->v->movetype);
1445 if (i > 0 && i <= svs.maxclients && !ent->e->free)
1447 SV_CheckVelocity (ent);
1449 // call standard player post-think
1450 SV_LinkEdict (ent, true);
1452 SV_CheckVelocity (ent);
1454 pr_global_struct->time = sv.time;
1455 pr_global_struct->self = EDICT_TO_PROG(ent);
1456 PR_ExecuteProgram (pr_global_struct->PlayerPostThink, "QC function PlayerPostThink is missing");
1460 if (pr_global_struct->force_retouch)
1461 pr_global_struct->force_retouch--;
1463 // LordHavoc: endframe support
1466 pr_global_struct->self = EDICT_TO_PROG(sv.edicts);
1467 pr_global_struct->other = EDICT_TO_PROG(sv.edicts);
1468 pr_global_struct->time = sv.time;
1469 PR_ExecuteProgram ((func_t)(EndFrameQC - pr_functions), "");
1472 sv.time += sv.frametime;
1476 trace_t SV_Trace_Toss (edict_t *tossent, edict_t *ignore)
1479 float gravity, savesolid;
1481 edict_t tempent, *tent;
1486 // copy the vars over
1487 memcpy(&vars, tossent->v, sizeof(entvars_t));
1488 // set up the temp entity to point to the copied vars
1492 savesolid = tossent->v->solid;
1493 tossent->v->solid = SOLID_NOT;
1495 // this has to fetch the field from the original edict, since our copy is truncated
1496 val = GETEDICTFIELDVALUE(tossent, eval_gravity);
1497 if (val != NULL && val->_float != 0)
1498 gravity = val->_float;
1501 gravity *= sv_gravity.value * 0.05;
1503 for (i = 0;i < 200;i++) // LordHavoc: sanity check; never trace more than 10 seconds
1505 SV_CheckVelocity (tent);
1506 tent->v->velocity[2] -= gravity;
1507 VectorMA (tent->v->angles, 0.05, tent->v->avelocity, tent->v->angles);
1508 VectorScale (tent->v->velocity, 0.05, move);
1509 VectorAdd (tent->v->origin, move, end);
1510 trace = SV_Move (tent->v->origin, tent->v->mins, tent->v->maxs, end, MOVE_NORMAL, tent);
1511 VectorCopy (trace.endpos, tent->v->origin);
1513 if (trace.fraction < 1 && trace.ent)
1514 if (trace.ent != ignore)
1517 tossent->v->solid = savesolid;
1518 trace.fraction = 0; // not relevant