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");
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->moved_from);
690 VectorCopy (check->v->angles, check->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->moved_from, ed->v->origin);
731 VectorCopy (ed->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)sv_player->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);
1069 Player character actions
1072 void SV_Physics_Client (edict_t *ent, int num)
1074 if (!svs.clients[num-1].active)
1075 return; // unconnected slot
1077 // call standard client pre-think
1078 pr_global_struct->time = sv.time;
1079 pr_global_struct->self = EDICT_TO_PROG(ent);
1080 PR_ExecuteProgram (pr_global_struct->PlayerPreThink, "QC function PlayerPreThink is missing");
1083 SV_CheckVelocity (ent);
1085 // decide which move function to call
1086 switch ((int)ent->v->movetype)
1089 if (!SV_RunThink (ent))
1094 if (!SV_RunThink (ent))
1096 if (!SV_CheckWater (ent) && ! ((int)ent->v->flags & FL_WATERJUMP) )
1097 SV_AddGravity (ent);
1098 SV_CheckStuck (ent);
1103 case MOVETYPE_BOUNCE:
1104 SV_Physics_Toss (ent);
1108 if (!SV_RunThink (ent))
1110 SV_CheckWater (ent);
1111 //SV_FlyMove (ent, sv.frametime, NULL);
1115 case MOVETYPE_NOCLIP:
1116 if (!SV_RunThink (ent))
1118 SV_CheckWater (ent);
1119 VectorMA (ent->v->origin, sv.frametime, ent->v->velocity, ent->v->origin);
1120 VectorMA (ent->v->angles, sv.frametime, ent->v->avelocity, ent->v->angles);
1124 Host_Error ("SV_Physics_client: bad movetype %i", (int)ent->v->movetype);
1127 // call standard player post-think
1128 SV_LinkEdict (ent, true);
1130 pr_global_struct->time = sv.time;
1131 pr_global_struct->self = EDICT_TO_PROG(ent);
1132 PR_ExecuteProgram (pr_global_struct->PlayerPostThink, "QC function PlayerPostThink is missing");
1135 //============================================================================
1141 Entities that are "stuck" to another entity
1144 void SV_Physics_Follow (edict_t *ent)
1146 vec3_t vf, vr, vu, angles, v;
1150 if (!SV_RunThink (ent))
1153 // LordHavoc: implemented rotation on MOVETYPE_FOLLOW objects
1154 e = PROG_TO_EDICT(ent->v->aiment);
1155 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])
1157 // quick case for no rotation
1158 VectorAdd(e->v->origin, ent->v->view_ofs, ent->v->origin);
1162 angles[0] = -ent->v->punchangle[0];
1163 angles[1] = ent->v->punchangle[1];
1164 angles[2] = ent->v->punchangle[2];
1165 AngleVectors (angles, vf, vr, vu);
1166 v[0] = ent->v->view_ofs[0] * vf[0] + ent->v->view_ofs[1] * vr[0] + ent->v->view_ofs[2] * vu[0];
1167 v[1] = ent->v->view_ofs[0] * vf[1] + ent->v->view_ofs[1] * vr[1] + ent->v->view_ofs[2] * vu[1];
1168 v[2] = ent->v->view_ofs[0] * vf[2] + ent->v->view_ofs[1] * vr[2] + ent->v->view_ofs[2] * vu[2];
1169 angles[0] = -e->v->angles[0];
1170 angles[1] = e->v->angles[1];
1171 angles[2] = e->v->angles[2];
1172 AngleVectors (angles, vf, vr, vu);
1173 ent->v->origin[0] = v[0] * vf[0] + v[1] * vf[1] + v[2] * vf[2] + e->v->origin[0];
1174 ent->v->origin[1] = v[0] * vr[0] + v[1] * vr[1] + v[2] * vr[2] + e->v->origin[1];
1175 ent->v->origin[2] = v[0] * vu[0] + v[1] * vu[1] + v[2] * vu[2] + e->v->origin[2];
1177 VectorAdd (e->v->angles, ent->v->v_angle, ent->v->angles);
1178 SV_LinkEdict (ent, true);
1185 A moving object that doesn't obey physics
1188 void SV_Physics_Noclip (edict_t *ent)
1191 if (!SV_RunThink (ent))
1194 VectorMA (ent->v->angles, sv.frametime, ent->v->avelocity, ent->v->angles);
1195 VectorMA (ent->v->origin, sv.frametime, ent->v->velocity, ent->v->origin);
1197 SV_LinkEdict (ent, false);
1201 ==============================================================================
1205 ==============================================================================
1210 SV_CheckWaterTransition
1214 void SV_CheckWaterTransition (edict_t *ent)
1217 cont = Mod_PointContents(ent->v->origin, sv.worldmodel);
1218 if (!ent->v->watertype)
1220 // just spawned here
1221 ent->v->watertype = cont;
1222 ent->v->waterlevel = 1;
1226 if (cont <= CONTENTS_WATER)
1228 if (ent->v->watertype == CONTENTS_EMPTY && cont != CONTENTS_LAVA)
1229 // just crossed into water
1230 SV_StartSound (ent, 0, "misc/h2ohit1.wav", 255, 1);
1232 ent->v->watertype = cont;
1233 ent->v->waterlevel = 1;
1237 if (ent->v->watertype != CONTENTS_EMPTY && ent->v->watertype != CONTENTS_LAVA)
1238 // just crossed into water
1239 SV_StartSound (ent, 0, "misc/h2ohit1.wav", 255, 1);
1241 ent->v->watertype = CONTENTS_EMPTY;
1242 ent->v->waterlevel = cont;
1250 Toss, bounce, and fly movement. When onground, do nothing.
1253 void SV_Physics_Toss (edict_t *ent)
1257 edict_t *groundentity;
1260 if (!SV_RunThink (ent))
1263 // if onground, return without moving
1264 if ((int)ent->v->flags & FL_ONGROUND)
1266 VectorClear(ent->v->velocity);
1267 if (ent->v->groundentity == 0)
1269 // if ent was supported by a brush model on previous frame,
1270 // and groundentity is now freed, set groundentity to 0 (floating)
1271 groundentity = PROG_TO_EDICT(ent->v->groundentity);
1272 if (groundentity->v->solid == SOLID_BSP)
1274 ent->suspendedinairflag = true;
1277 else if (ent->suspendedinairflag && groundentity->free)
1279 // leave it suspended in the air
1280 ent->v->groundentity = 0;
1281 ent->suspendedinairflag = false;
1285 ent->suspendedinairflag = false;
1287 SV_CheckVelocity (ent);
1290 if (ent->v->movetype == MOVETYPE_TOSS || ent->v->movetype == MOVETYPE_BOUNCE)
1291 SV_AddGravity (ent);
1294 VectorMA (ent->v->angles, sv.frametime, ent->v->avelocity, ent->v->angles);
1297 VectorScale (ent->v->velocity, sv.frametime, move);
1298 trace = SV_PushEntity (ent, move, vec3_origin);
1302 if (trace.fraction < 1)
1304 if (ent->v->movetype == MOVETYPE_BOUNCEMISSILE)
1306 ClipVelocity (ent->v->velocity, trace.plane.normal, ent->v->velocity, 2.0);
1307 ent->v->flags = (int)ent->v->flags & ~FL_ONGROUND;
1309 else if (ent->v->movetype == MOVETYPE_BOUNCE)
1311 ClipVelocity (ent->v->velocity, trace.plane.normal, ent->v->velocity, 1.5);
1312 // LordHavoc: fixed grenades not bouncing when fired down a slope
1313 if (trace.plane.normal[2] > 0.7 && DotProduct(trace.plane.normal, ent->v->velocity) < 60)
1315 ent->v->flags = (int)ent->v->flags | FL_ONGROUND;
1316 ent->v->groundentity = EDICT_TO_PROG(trace.ent);
1317 VectorClear (ent->v->velocity);
1318 VectorClear (ent->v->avelocity);
1321 ent->v->flags = (int)ent->v->flags & ~FL_ONGROUND;
1325 ClipVelocity (ent->v->velocity, trace.plane.normal, ent->v->velocity, 1.0);
1326 if (trace.plane.normal[2] > 0.7)
1328 ent->v->flags = (int)ent->v->flags | FL_ONGROUND;
1329 ent->v->groundentity = EDICT_TO_PROG(trace.ent);
1330 VectorClear (ent->v->velocity);
1331 VectorClear (ent->v->avelocity);
1334 ent->v->flags = (int)ent->v->flags & ~FL_ONGROUND;
1338 // check for in water
1339 SV_CheckWaterTransition (ent);
1343 ===============================================================================
1347 ===============================================================================
1354 Monsters freefall when they don't have a ground entity, otherwise
1355 all movement is done with discrete steps.
1357 This is also used for objects that have become still on the ground, but
1358 will fall if the floor is pulled out from under them.
1361 void SV_Physics_Step (edict_t *ent)
1363 int flags, fall, hitsound;
1365 // freefall if not fly/swim
1367 flags = (int)ent->v->flags;
1368 if (flags & (FL_FLY | FL_SWIM))
1372 else if ((flags & FL_SWIM) && Mod_PointContents(ent->v->origin, sv.worldmodel) != CONTENTS_EMPTY)
1375 if (fall && (flags & FL_ONGROUND) && ent->v->groundentity == 0)
1380 if (ent->v->velocity[2] < sv_gravity.value*-0.1)
1383 if (flags & FL_ONGROUND)
1389 SV_AddGravity (ent);
1390 SV_CheckVelocity (ent);
1391 SV_FlyMove (ent, sv.frametime, NULL);
1392 SV_LinkEdict (ent, false);
1395 if ((int)ent->v->flags & FL_ONGROUND)
1397 VectorClear(ent->v->velocity);
1399 SV_StartSound (ent, 0, "demon/dland2.wav", 255, 1);
1406 SV_CheckWaterTransition (ent);
1409 //============================================================================
1417 void SV_Physics (void)
1422 // let the progs know that a new frame has started
1423 pr_global_struct->self = EDICT_TO_PROG(sv.edicts);
1424 pr_global_struct->other = EDICT_TO_PROG(sv.edicts);
1425 pr_global_struct->time = sv.time;
1426 PR_ExecuteProgram (pr_global_struct->StartFrame, "QC function StartFrame is missing");
1429 // treat each object in turn
1432 for (i=0 ; i<sv.num_edicts ; i++, ent = NEXT_EDICT(ent))
1437 if (pr_global_struct->force_retouch)
1438 SV_LinkEdict (ent, true); // force retouch even for stationary
1440 if (i > 0 && i <= svs.maxclients)
1442 SV_Physics_Client (ent, i);
1446 switch ((int) ent->v->movetype)
1449 SV_Physics_Pusher (ent);
1452 // LordHavoc: manually inlined the thinktime check here because MOVETYPE_NONE is used on so many objects
1453 if (ent->v->nextthink > 0 && ent->v->nextthink <= sv.time + sv.frametime)
1456 case MOVETYPE_FOLLOW:
1457 SV_Physics_Follow (ent);
1459 case MOVETYPE_NOCLIP:
1460 SV_Physics_Noclip (ent);
1463 SV_Physics_Step (ent);
1465 // LordHavoc: added support for MOVETYPE_WALK on normal entities! :)
1467 if (SV_RunThink (ent))
1469 if (!SV_CheckWater (ent) && ! ((int)ent->v->flags & FL_WATERJUMP) )
1470 SV_AddGravity (ent);
1471 SV_CheckStuck (ent);
1473 SV_LinkEdict (ent, true);
1477 case MOVETYPE_BOUNCE:
1478 case MOVETYPE_BOUNCEMISSILE:
1480 case MOVETYPE_FLYMISSILE:
1481 SV_Physics_Toss (ent);
1484 Host_Error ("SV_Physics: bad movetype %i", (int)ent->v->movetype);
1489 if (pr_global_struct->force_retouch)
1490 pr_global_struct->force_retouch--;
1492 // LordHavoc: endframe support
1495 pr_global_struct->self = EDICT_TO_PROG(sv.edicts);
1496 pr_global_struct->other = EDICT_TO_PROG(sv.edicts);
1497 pr_global_struct->time = sv.time;
1498 PR_ExecuteProgram ((func_t)(EndFrameQC - pr_functions), "");
1501 sv.time += sv.frametime;
1505 trace_t SV_Trace_Toss (edict_t *tossent, edict_t *ignore)
1508 float gravity, savesolid;
1510 edict_t tempent, *tent;
1515 // copy the vars over
1516 memcpy(&vars, tossent->v, sizeof(entvars_t));
1517 // set up the temp entity to point to the copied vars
1521 savesolid = tossent->v->solid;
1522 tossent->v->solid = SOLID_NOT;
1524 // this has to fetch the field from the original edict, since our copy is truncated
1525 val = GETEDICTFIELDVALUE(tossent, eval_gravity);
1526 if (val != NULL && val->_float != 0)
1527 gravity = val->_float;
1530 gravity *= sv_gravity.value * 0.05;
1532 for (i = 0;i < 200;i++) // LordHavoc: sanity check; never trace more than 10 seconds
1534 SV_CheckVelocity (tent);
1535 tent->v->velocity[2] -= gravity;
1536 VectorMA (tent->v->angles, 0.05, tent->v->avelocity, tent->v->angles);
1537 VectorScale (tent->v->velocity, 0.05, move);
1538 VectorAdd (tent->v->origin, move, end);
1539 trace = SV_Move (tent->v->origin, tent->v->mins, tent->v->maxs, end, MOVE_NORMAL, tent);
1540 VectorCopy (trace.endpos, tent->v->origin);
1542 if (trace.fraction < 1 && trace.ent)
1543 if (trace.ent != ignore)
1546 tossent->v->solid = savesolid;
1547 trace.fraction = 0; // not relevant