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 SV_CheckVelocity (ent);
1079 // call standard client pre-think
1080 pr_global_struct->time = sv.time;
1081 pr_global_struct->self = EDICT_TO_PROG(ent);
1082 PR_ExecuteProgram (pr_global_struct->PlayerPreThink, "QC function PlayerPreThink is missing");
1085 SV_CheckVelocity (ent);
1087 // decide which move function to call
1088 switch ((int)ent->v->movetype)
1091 if (!SV_RunThink (ent))
1096 if (!SV_RunThink (ent))
1098 if (!SV_CheckWater (ent) && ! ((int)ent->v->flags & FL_WATERJUMP) )
1099 SV_AddGravity (ent);
1100 SV_CheckStuck (ent);
1105 case MOVETYPE_BOUNCE:
1106 SV_Physics_Toss (ent);
1110 if (!SV_RunThink (ent))
1112 SV_CheckWater (ent);
1113 //SV_FlyMove (ent, sv.frametime, NULL);
1117 case MOVETYPE_NOCLIP:
1118 if (!SV_RunThink (ent))
1120 SV_CheckWater (ent);
1121 VectorMA (ent->v->origin, sv.frametime, ent->v->velocity, ent->v->origin);
1122 VectorMA (ent->v->angles, sv.frametime, ent->v->avelocity, ent->v->angles);
1126 Host_Error ("SV_Physics_client: bad movetype %i", (int)ent->v->movetype);
1129 SV_CheckVelocity (ent);
1131 // call standard player post-think
1132 SV_LinkEdict (ent, true);
1134 SV_CheckVelocity (ent);
1136 pr_global_struct->time = sv.time;
1137 pr_global_struct->self = EDICT_TO_PROG(ent);
1138 PR_ExecuteProgram (pr_global_struct->PlayerPostThink, "QC function PlayerPostThink is missing");
1141 //============================================================================
1147 Entities that are "stuck" to another entity
1150 void SV_Physics_Follow (edict_t *ent)
1152 vec3_t vf, vr, vu, angles, v;
1156 if (!SV_RunThink (ent))
1159 // LordHavoc: implemented rotation on MOVETYPE_FOLLOW objects
1160 e = PROG_TO_EDICT(ent->v->aiment);
1161 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])
1163 // quick case for no rotation
1164 VectorAdd(e->v->origin, ent->v->view_ofs, ent->v->origin);
1168 angles[0] = -ent->v->punchangle[0];
1169 angles[1] = ent->v->punchangle[1];
1170 angles[2] = ent->v->punchangle[2];
1171 AngleVectors (angles, vf, vr, vu);
1172 v[0] = ent->v->view_ofs[0] * vf[0] + ent->v->view_ofs[1] * vr[0] + ent->v->view_ofs[2] * vu[0];
1173 v[1] = ent->v->view_ofs[0] * vf[1] + ent->v->view_ofs[1] * vr[1] + ent->v->view_ofs[2] * vu[1];
1174 v[2] = ent->v->view_ofs[0] * vf[2] + ent->v->view_ofs[1] * vr[2] + ent->v->view_ofs[2] * vu[2];
1175 angles[0] = -e->v->angles[0];
1176 angles[1] = e->v->angles[1];
1177 angles[2] = e->v->angles[2];
1178 AngleVectors (angles, vf, vr, vu);
1179 ent->v->origin[0] = v[0] * vf[0] + v[1] * vf[1] + v[2] * vf[2] + e->v->origin[0];
1180 ent->v->origin[1] = v[0] * vr[0] + v[1] * vr[1] + v[2] * vr[2] + e->v->origin[1];
1181 ent->v->origin[2] = v[0] * vu[0] + v[1] * vu[1] + v[2] * vu[2] + e->v->origin[2];
1183 VectorAdd (e->v->angles, ent->v->v_angle, ent->v->angles);
1184 SV_LinkEdict (ent, true);
1191 A moving object that doesn't obey physics
1194 void SV_Physics_Noclip (edict_t *ent)
1197 if (!SV_RunThink (ent))
1200 VectorMA (ent->v->angles, sv.frametime, ent->v->avelocity, ent->v->angles);
1201 VectorMA (ent->v->origin, sv.frametime, ent->v->velocity, ent->v->origin);
1203 SV_LinkEdict (ent, false);
1207 ==============================================================================
1211 ==============================================================================
1216 SV_CheckWaterTransition
1220 void SV_CheckWaterTransition (edict_t *ent)
1223 cont = Mod_PointContents(ent->v->origin, sv.worldmodel);
1224 if (!ent->v->watertype)
1226 // just spawned here
1227 ent->v->watertype = cont;
1228 ent->v->waterlevel = 1;
1232 if (cont <= CONTENTS_WATER)
1234 if (ent->v->watertype == CONTENTS_EMPTY && cont != CONTENTS_LAVA)
1235 // just crossed into water
1236 SV_StartSound (ent, 0, "misc/h2ohit1.wav", 255, 1);
1238 ent->v->watertype = cont;
1239 ent->v->waterlevel = 1;
1243 if (ent->v->watertype != CONTENTS_EMPTY && ent->v->watertype != CONTENTS_LAVA)
1244 // just crossed into water
1245 SV_StartSound (ent, 0, "misc/h2ohit1.wav", 255, 1);
1247 ent->v->watertype = CONTENTS_EMPTY;
1248 ent->v->waterlevel = cont;
1256 Toss, bounce, and fly movement. When onground, do nothing.
1259 void SV_Physics_Toss (edict_t *ent)
1263 edict_t *groundentity;
1266 if (!SV_RunThink (ent))
1269 // if onground, return without moving
1270 if ((int)ent->v->flags & FL_ONGROUND)
1272 VectorClear(ent->v->velocity);
1273 if (ent->v->groundentity == 0)
1275 // if ent was supported by a brush model on previous frame,
1276 // and groundentity is now freed, set groundentity to 0 (floating)
1277 groundentity = PROG_TO_EDICT(ent->v->groundentity);
1278 if (groundentity->v->solid == SOLID_BSP)
1280 ent->suspendedinairflag = true;
1283 else if (ent->suspendedinairflag && groundentity->free)
1285 // leave it suspended in the air
1286 ent->v->groundentity = 0;
1287 ent->suspendedinairflag = false;
1291 ent->suspendedinairflag = false;
1293 SV_CheckVelocity (ent);
1296 if (ent->v->movetype == MOVETYPE_TOSS || ent->v->movetype == MOVETYPE_BOUNCE)
1297 SV_AddGravity (ent);
1300 VectorMA (ent->v->angles, sv.frametime, ent->v->avelocity, ent->v->angles);
1303 VectorScale (ent->v->velocity, sv.frametime, move);
1304 trace = SV_PushEntity (ent, move, vec3_origin);
1308 if (trace.fraction < 1)
1310 if (ent->v->movetype == MOVETYPE_BOUNCEMISSILE)
1312 ClipVelocity (ent->v->velocity, trace.plane.normal, ent->v->velocity, 2.0);
1313 ent->v->flags = (int)ent->v->flags & ~FL_ONGROUND;
1315 else if (ent->v->movetype == MOVETYPE_BOUNCE)
1317 ClipVelocity (ent->v->velocity, trace.plane.normal, ent->v->velocity, 1.5);
1318 // LordHavoc: fixed grenades not bouncing when fired down a slope
1319 if (trace.plane.normal[2] > 0.7 && DotProduct(trace.plane.normal, ent->v->velocity) < 60)
1321 ent->v->flags = (int)ent->v->flags | FL_ONGROUND;
1322 ent->v->groundentity = EDICT_TO_PROG(trace.ent);
1323 VectorClear (ent->v->velocity);
1324 VectorClear (ent->v->avelocity);
1327 ent->v->flags = (int)ent->v->flags & ~FL_ONGROUND;
1331 ClipVelocity (ent->v->velocity, trace.plane.normal, ent->v->velocity, 1.0);
1332 if (trace.plane.normal[2] > 0.7)
1334 ent->v->flags = (int)ent->v->flags | FL_ONGROUND;
1335 ent->v->groundentity = EDICT_TO_PROG(trace.ent);
1336 VectorClear (ent->v->velocity);
1337 VectorClear (ent->v->avelocity);
1340 ent->v->flags = (int)ent->v->flags & ~FL_ONGROUND;
1344 // check for in water
1345 SV_CheckWaterTransition (ent);
1349 ===============================================================================
1353 ===============================================================================
1360 Monsters freefall when they don't have a ground entity, otherwise
1361 all movement is done with discrete steps.
1363 This is also used for objects that have become still on the ground, but
1364 will fall if the floor is pulled out from under them.
1367 void SV_Physics_Step (edict_t *ent)
1369 int flags, fall, hitsound;
1371 // freefall if not fly/swim
1373 flags = (int)ent->v->flags;
1374 if (flags & (FL_FLY | FL_SWIM))
1378 else if ((flags & FL_SWIM) && Mod_PointContents(ent->v->origin, sv.worldmodel) != CONTENTS_EMPTY)
1381 if (fall && (flags & FL_ONGROUND) && ent->v->groundentity == 0)
1386 if (ent->v->velocity[2] < sv_gravity.value*-0.1)
1389 if (flags & FL_ONGROUND)
1395 SV_AddGravity (ent);
1396 SV_CheckVelocity (ent);
1397 SV_FlyMove (ent, sv.frametime, NULL);
1398 SV_LinkEdict (ent, false);
1401 if ((int)ent->v->flags & FL_ONGROUND)
1403 VectorClear(ent->v->velocity);
1405 SV_StartSound (ent, 0, "demon/dland2.wav", 255, 1);
1412 SV_CheckWaterTransition (ent);
1415 //============================================================================
1423 void SV_Physics (void)
1428 // let the progs know that a new frame has started
1429 pr_global_struct->self = EDICT_TO_PROG(sv.edicts);
1430 pr_global_struct->other = EDICT_TO_PROG(sv.edicts);
1431 pr_global_struct->time = sv.time;
1432 PR_ExecuteProgram (pr_global_struct->StartFrame, "QC function StartFrame is missing");
1435 // treat each object in turn
1438 for (i=0 ; i<sv.num_edicts ; i++, ent = NEXT_EDICT(ent))
1443 if (pr_global_struct->force_retouch)
1444 SV_LinkEdict (ent, true); // force retouch even for stationary
1446 if (i > 0 && i <= svs.maxclients)
1448 SV_Physics_Client (ent, i);
1452 switch ((int) ent->v->movetype)
1455 SV_Physics_Pusher (ent);
1458 // LordHavoc: manually inlined the thinktime check here because MOVETYPE_NONE is used on so many objects
1459 if (ent->v->nextthink > 0 && ent->v->nextthink <= sv.time + sv.frametime)
1462 case MOVETYPE_FOLLOW:
1463 SV_Physics_Follow (ent);
1465 case MOVETYPE_NOCLIP:
1466 SV_Physics_Noclip (ent);
1469 SV_Physics_Step (ent);
1471 // LordHavoc: added support for MOVETYPE_WALK on normal entities! :)
1473 if (SV_RunThink (ent))
1475 if (!SV_CheckWater (ent) && ! ((int)ent->v->flags & FL_WATERJUMP) )
1476 SV_AddGravity (ent);
1477 SV_CheckStuck (ent);
1479 SV_LinkEdict (ent, true);
1483 case MOVETYPE_BOUNCE:
1484 case MOVETYPE_BOUNCEMISSILE:
1486 case MOVETYPE_FLYMISSILE:
1487 SV_Physics_Toss (ent);
1490 Host_Error ("SV_Physics: bad movetype %i", (int)ent->v->movetype);
1495 if (pr_global_struct->force_retouch)
1496 pr_global_struct->force_retouch--;
1498 // LordHavoc: endframe support
1501 pr_global_struct->self = EDICT_TO_PROG(sv.edicts);
1502 pr_global_struct->other = EDICT_TO_PROG(sv.edicts);
1503 pr_global_struct->time = sv.time;
1504 PR_ExecuteProgram ((func_t)(EndFrameQC - pr_functions), "");
1507 sv.time += sv.frametime;
1511 trace_t SV_Trace_Toss (edict_t *tossent, edict_t *ignore)
1514 float gravity, savesolid;
1516 edict_t tempent, *tent;
1521 // copy the vars over
1522 memcpy(&vars, tossent->v, sizeof(entvars_t));
1523 // set up the temp entity to point to the copied vars
1527 savesolid = tossent->v->solid;
1528 tossent->v->solid = SOLID_NOT;
1530 // this has to fetch the field from the original edict, since our copy is truncated
1531 val = GETEDICTFIELDVALUE(tossent, eval_gravity);
1532 if (val != NULL && val->_float != 0)
1533 gravity = val->_float;
1536 gravity *= sv_gravity.value * 0.05;
1538 for (i = 0;i < 200;i++) // LordHavoc: sanity check; never trace more than 10 seconds
1540 SV_CheckVelocity (tent);
1541 tent->v->velocity[2] -= gravity;
1542 VectorMA (tent->v->angles, 0.05, tent->v->avelocity, tent->v->angles);
1543 VectorScale (tent->v->velocity, 0.05, move);
1544 VectorAdd (tent->v->origin, move, end);
1545 trace = SV_Move (tent->v->origin, tent->v->mins, tent->v->maxs, end, MOVE_NORMAL, tent);
1546 VectorCopy (trace.endpos, tent->v->origin);
1548 if (trace.fraction < 1 && trace.ent)
1549 if (trace.ent != ignore)
1552 tossent->v->solid = savesolid;
1553 trace.fraction = 0; // not relevant