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.fraction < 1 && 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");
786 ===============================================================================
790 ===============================================================================
797 This is a big hack to try and fix the rare case of getting stuck in the world
801 void SV_CheckStuck (edict_t *ent)
806 if (!SV_TestEntityPosition(ent))
808 VectorCopy (ent->v->origin, ent->v->oldorigin);
812 VectorCopy (ent->v->origin, org);
813 VectorCopy (ent->v->oldorigin, ent->v->origin);
814 if (!SV_TestEntityPosition(ent))
816 Con_DPrintf ("Unstuck.\n");
817 SV_LinkEdict (ent, true);
821 for (z=0 ; z< 18 ; z++)
822 for (i=-1 ; i <= 1 ; i++)
823 for (j=-1 ; j <= 1 ; j++)
825 ent->v->origin[0] = org[0] + i;
826 ent->v->origin[1] = org[1] + j;
827 ent->v->origin[2] = org[2] + z;
828 if (!SV_TestEntityPosition(ent))
830 Con_DPrintf ("Unstuck.\n");
831 SV_LinkEdict (ent, true);
836 VectorCopy (org, ent->v->origin);
837 Con_DPrintf ("player is stuck.\n");
846 qboolean SV_CheckWater (edict_t *ent)
851 point[0] = ent->v->origin[0];
852 point[1] = ent->v->origin[1];
853 point[2] = ent->v->origin[2] + ent->v->mins[2] + 1;
855 ent->v->waterlevel = 0;
856 ent->v->watertype = CONTENTS_EMPTY;
857 cont = SV_PointQ1Contents(point);
858 if (cont <= CONTENTS_WATER)
860 ent->v->watertype = cont;
861 ent->v->waterlevel = 1;
862 point[2] = ent->v->origin[2] + (ent->v->mins[2] + ent->v->maxs[2])*0.5;
863 cont = SV_PointQ1Contents(point);
864 if (cont <= CONTENTS_WATER)
866 ent->v->waterlevel = 2;
867 point[2] = ent->v->origin[2] + ent->v->view_ofs[2];
868 cont = SV_PointQ1Contents(point);
869 if (cont <= CONTENTS_WATER)
870 ent->v->waterlevel = 3;
874 return ent->v->waterlevel > 1;
883 void SV_WallFriction (edict_t *ent, float *stepnormal)
886 vec3_t forward, into, side;
888 AngleVectors (ent->v->v_angle, forward, NULL, NULL);
889 if ((d = DotProduct (stepnormal, forward) + 0.5) < 0)
891 // cut the tangential velocity
892 i = DotProduct (stepnormal, ent->v->velocity);
893 VectorScale (stepnormal, i, into);
894 VectorSubtract (ent->v->velocity, into, side);
895 ent->v->velocity[0] = side[0] * (1 + d);
896 ent->v->velocity[1] = side[1] * (1 + d);
901 =====================
904 Player has come to a dead stop, possibly due to the problem with limited
905 float precision at some angle joins in the BSP hull.
907 Try fixing by pushing one pixel in each direction.
909 This is a hack, but in the interest of good gameplay...
910 ======================
912 int SV_TryUnstick (edict_t *ent, vec3_t oldvel)
917 VectorCopy (ent->v->origin, oldorg);
920 for (i=0 ; i<8 ; i++)
922 // try pushing a little in an axial direction
925 case 0: dir[0] = 2; dir[1] = 0; break;
926 case 1: dir[0] = 0; dir[1] = 2; break;
927 case 2: dir[0] = -2; dir[1] = 0; break;
928 case 3: dir[0] = 0; dir[1] = -2; break;
929 case 4: dir[0] = 2; dir[1] = 2; break;
930 case 5: dir[0] = -2; dir[1] = 2; break;
931 case 6: dir[0] = 2; dir[1] = -2; break;
932 case 7: dir[0] = -2; dir[1] = -2; break;
935 SV_PushEntity (ent, dir, vec3_origin);
937 // retry the original move
938 ent->v->velocity[0] = oldvel[0];
939 ent->v->velocity[1] = oldvel[1];
940 ent->v->velocity[2] = 0;
941 clip = SV_FlyMove (ent, 0.1, NULL);
943 if (fabs(oldorg[1] - ent->v->origin[1]) > 4
944 || fabs(oldorg[0] - ent->v->origin[0]) > 4)
947 // go back to the original pos and try again
948 VectorCopy (oldorg, ent->v->origin);
952 VectorClear (ent->v->velocity);
957 =====================
961 ======================
963 void SV_WalkMove (edict_t *ent)
965 int clip, oldonground;
966 vec3_t upmove, downmove, oldorg, oldvel, nosteporg, nostepvel, stepnormal;
969 SV_CheckVelocity(ent);
971 // do a regular slide move unless it looks like you ran into a step
972 oldonground = (int)ent->v->flags & FL_ONGROUND;
973 ent->v->flags = (int)ent->v->flags & ~FL_ONGROUND;
975 VectorCopy (ent->v->origin, oldorg);
976 VectorCopy (ent->v->velocity, oldvel);
978 clip = SV_FlyMove (ent, sv.frametime, NULL);
980 SV_CheckVelocity(ent);
982 // if move didn't block on a step, return
986 if (ent->v->movetype != MOVETYPE_FLY)
988 if (!oldonground && ent->v->waterlevel == 0 && !sv_jumpstep.integer)
989 // don't stair up while jumping
992 if (ent->v->movetype != MOVETYPE_WALK)
993 // gibbed by a trigger
997 SV_CheckVelocity(ent);
999 if (sv_nostep.integer || (int)ent->v->flags & FL_WATERJUMP )
1002 VectorCopy (ent->v->origin, nosteporg);
1003 VectorCopy (ent->v->velocity, nostepvel);
1005 // try moving up and forward to go up a step
1006 // back to start pos
1007 VectorCopy (oldorg, ent->v->origin);
1009 VectorClear (upmove);
1010 VectorClear (downmove);
1011 upmove[2] = sv_stepheight.value;
1012 downmove[2] = -sv_stepheight.value + oldvel[2]*sv.frametime;
1015 // FIXME: don't link?
1016 SV_PushEntity (ent, upmove, vec3_origin);
1019 ent->v->velocity[0] = oldvel[0];
1020 ent->v->velocity[1] = oldvel[1];
1021 ent->v->velocity[2] = 0;
1022 clip = SV_FlyMove (ent, sv.frametime, stepnormal);
1023 ent->v->velocity[2] += oldvel[2];
1025 // check for stuckness, possibly due to the limited precision of floats
1026 // in the clipping hulls
1028 && fabs(oldorg[1] - ent->v->origin[1]) < 0.03125
1029 && fabs(oldorg[0] - ent->v->origin[0]) < 0.03125)
1030 // stepping up didn't make any progress
1031 clip = SV_TryUnstick (ent, oldvel);
1033 // extra friction based on view angle
1034 if (clip & 2 && sv_wallfriction.integer)
1035 SV_WallFriction (ent, stepnormal);
1038 // FIXME: don't link?
1039 downtrace = SV_PushEntity (ent, downmove, vec3_origin);
1041 if (downtrace.plane.normal[2] > 0.7)
1043 // LordHavoc: disabled this so you can walk on monsters/players
1044 //if (ent->v->solid == SOLID_BSP)
1046 ent->v->flags = (int)ent->v->flags | FL_ONGROUND;
1047 ent->v->groundentity = EDICT_TO_PROG(downtrace.ent);
1052 // if the push down didn't end up on good ground, use the move without
1053 // the step up. This happens near wall / slope combinations, and can
1054 // cause the player to hop up higher on a slope too steep to climb
1055 VectorCopy (nosteporg, ent->v->origin);
1056 VectorCopy (nostepvel, ent->v->velocity);
1059 SV_CheckVelocity(ent);
1062 //============================================================================
1068 Entities that are "stuck" to another entity
1071 void SV_Physics_Follow (edict_t *ent)
1073 vec3_t vf, vr, vu, angles, v;
1077 if (!SV_RunThink (ent))
1080 // LordHavoc: implemented rotation on MOVETYPE_FOLLOW objects
1081 e = PROG_TO_EDICT(ent->v->aiment);
1082 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])
1084 // quick case for no rotation
1085 VectorAdd(e->v->origin, ent->v->view_ofs, ent->v->origin);
1089 angles[0] = -ent->v->punchangle[0];
1090 angles[1] = ent->v->punchangle[1];
1091 angles[2] = ent->v->punchangle[2];
1092 AngleVectors (angles, vf, vr, vu);
1093 v[0] = ent->v->view_ofs[0] * vf[0] + ent->v->view_ofs[1] * vr[0] + ent->v->view_ofs[2] * vu[0];
1094 v[1] = ent->v->view_ofs[0] * vf[1] + ent->v->view_ofs[1] * vr[1] + ent->v->view_ofs[2] * vu[1];
1095 v[2] = ent->v->view_ofs[0] * vf[2] + ent->v->view_ofs[1] * vr[2] + ent->v->view_ofs[2] * vu[2];
1096 angles[0] = -e->v->angles[0];
1097 angles[1] = e->v->angles[1];
1098 angles[2] = e->v->angles[2];
1099 AngleVectors (angles, vf, vr, vu);
1100 ent->v->origin[0] = v[0] * vf[0] + v[1] * vf[1] + v[2] * vf[2] + e->v->origin[0];
1101 ent->v->origin[1] = v[0] * vr[0] + v[1] * vr[1] + v[2] * vr[2] + e->v->origin[1];
1102 ent->v->origin[2] = v[0] * vu[0] + v[1] * vu[1] + v[2] * vu[2] + e->v->origin[2];
1104 VectorAdd (e->v->angles, ent->v->v_angle, ent->v->angles);
1105 SV_LinkEdict (ent, true);
1109 ==============================================================================
1113 ==============================================================================
1118 SV_CheckWaterTransition
1122 void SV_CheckWaterTransition (edict_t *ent)
1125 cont = SV_PointQ1Contents(ent->v->origin);
1126 if (!ent->v->watertype)
1128 // just spawned here
1129 ent->v->watertype = cont;
1130 ent->v->waterlevel = 1;
1134 // check if the entity crossed into or out of water
1135 if ((ent->v->watertype == CONTENTS_WATER || ent->v->watertype == CONTENTS_SLIME) != (cont == CONTENTS_WATER || cont == CONTENTS_SLIME))
1136 SV_StartSound (ent, 0, "misc/h2ohit1.wav", 255, 1);
1138 if (cont <= CONTENTS_WATER)
1140 ent->v->watertype = cont;
1141 ent->v->waterlevel = 1;
1145 ent->v->watertype = CONTENTS_EMPTY;
1146 ent->v->waterlevel = 0;
1154 Toss, bounce, and fly movement. When onground, do nothing.
1157 void SV_Physics_Toss (edict_t *ent)
1161 edict_t *groundentity;
1164 if (!SV_RunThink (ent))
1167 // if onground, return without moving
1168 if ((int)ent->v->flags & FL_ONGROUND)
1170 if (ent->v->groundentity == 0)
1172 // if ent was supported by a brush model on previous frame,
1173 // and groundentity is now freed, set groundentity to 0 (floating)
1174 groundentity = PROG_TO_EDICT(ent->v->groundentity);
1175 if (groundentity->v->solid == SOLID_BSP)
1177 ent->e->suspendedinairflag = true;
1180 else if (ent->e->suspendedinairflag && groundentity->e->free)
1182 // leave it suspended in the air
1183 ent->v->groundentity = 0;
1184 ent->e->suspendedinairflag = false;
1188 ent->e->suspendedinairflag = false;
1190 SV_CheckVelocity (ent);
1193 if (ent->v->movetype == MOVETYPE_TOSS || ent->v->movetype == MOVETYPE_BOUNCE)
1194 SV_AddGravity (ent);
1197 VectorMA (ent->v->angles, sv.frametime, ent->v->avelocity, ent->v->angles);
1200 VectorScale (ent->v->velocity, sv.frametime, move);
1201 trace = SV_PushEntity (ent, move, vec3_origin);
1205 if (trace.fraction < 1)
1207 if (ent->v->movetype == MOVETYPE_BOUNCEMISSILE)
1209 ClipVelocity (ent->v->velocity, trace.plane.normal, ent->v->velocity, 2.0);
1210 ent->v->flags = (int)ent->v->flags & ~FL_ONGROUND;
1212 else if (ent->v->movetype == MOVETYPE_BOUNCE)
1214 ClipVelocity (ent->v->velocity, trace.plane.normal, ent->v->velocity, 1.5);
1215 // LordHavoc: fixed grenades not bouncing when fired down a slope
1216 if (trace.plane.normal[2] > 0.7 && DotProduct(trace.plane.normal, ent->v->velocity) < 60)
1218 ent->v->flags = (int)ent->v->flags | FL_ONGROUND;
1219 ent->v->groundentity = EDICT_TO_PROG(trace.ent);
1220 VectorClear (ent->v->velocity);
1221 VectorClear (ent->v->avelocity);
1224 ent->v->flags = (int)ent->v->flags & ~FL_ONGROUND;
1228 ClipVelocity (ent->v->velocity, trace.plane.normal, ent->v->velocity, 1.0);
1229 if (trace.plane.normal[2] > 0.7)
1231 ent->v->flags = (int)ent->v->flags | FL_ONGROUND;
1232 ent->v->groundentity = EDICT_TO_PROG(trace.ent);
1233 VectorClear (ent->v->velocity);
1234 VectorClear (ent->v->avelocity);
1237 ent->v->flags = (int)ent->v->flags & ~FL_ONGROUND;
1241 // check for in water
1242 SV_CheckWaterTransition (ent);
1246 ===============================================================================
1250 ===============================================================================
1257 Monsters freefall when they don't have a ground entity, otherwise
1258 all movement is done with discrete steps.
1260 This is also used for objects that have become still on the ground, but
1261 will fall if the floor is pulled out from under them.
1264 void SV_Physics_Step (edict_t *ent)
1266 // freefall if not onground/fly/swim
1267 if (!((int)ent->v->flags & (FL_ONGROUND | FL_FLY | FL_SWIM)))
1269 int hitsound = ent->v->velocity[2] < sv_gravity.value * -0.1;
1272 SV_CheckVelocity(ent);
1273 SV_FlyMove(ent, sv.frametime, NULL);
1274 SV_LinkEdict(ent, false);
1277 if (hitsound && (int)ent->v->flags & FL_ONGROUND)
1278 SV_StartSound(ent, 0, "demon/dland2.wav", 255, 1);
1284 SV_CheckWaterTransition(ent);
1287 //============================================================================
1295 void SV_Physics (void)
1300 // let the progs know that a new frame has started
1301 pr_global_struct->self = EDICT_TO_PROG(sv.edicts);
1302 pr_global_struct->other = EDICT_TO_PROG(sv.edicts);
1303 pr_global_struct->time = sv.time;
1304 PR_ExecuteProgram (pr_global_struct->StartFrame, "QC function StartFrame is missing");
1307 // treat each object in turn
1310 for (i=0 ; i<sv.num_edicts ; i++, ent = NEXT_EDICT(ent))
1315 if (pr_global_struct->force_retouch)
1316 SV_LinkEdict (ent, true); // force retouch even for stationary
1318 if (i > 0 && i <= svs.maxclients)
1320 if (!svs.clients[i-1].spawned)
1323 // call standard client pre-think
1324 SV_CheckVelocity (ent);
1325 pr_global_struct->time = sv.time;
1326 pr_global_struct->self = EDICT_TO_PROG(ent);
1327 PR_ExecuteProgram (pr_global_struct->PlayerPreThink, "QC function PlayerPreThink is missing");
1328 SV_CheckVelocity (ent);
1331 // LordHavoc: merged client and normal entity physics
1332 switch ((int) ent->v->movetype)
1335 SV_Physics_Pusher (ent);
1338 // LordHavoc: manually inlined the thinktime check here because MOVETYPE_NONE is used on so many objects
1339 if (ent->v->nextthink > 0 && ent->v->nextthink <= sv.time + sv.frametime)
1342 case MOVETYPE_FOLLOW:
1343 SV_Physics_Follow (ent);
1345 case MOVETYPE_NOCLIP:
1346 if (SV_RunThink(ent))
1349 VectorMA(ent->v->origin, sv.frametime, ent->v->velocity, ent->v->origin);
1350 VectorMA(ent->v->angles, sv.frametime, ent->v->avelocity, ent->v->angles);
1352 // relink normal entities here, players always get relinked so don't relink twice
1353 if (!(i > 0 && i <= svs.maxclients))
1354 SV_LinkEdict(ent, false);
1357 SV_Physics_Step (ent);
1360 if (SV_RunThink (ent))
1362 if (!SV_CheckWater (ent) && ! ((int)ent->v->flags & FL_WATERJUMP) )
1363 SV_AddGravity (ent);
1364 SV_CheckStuck (ent);
1366 SV_LinkEdict (ent, true);
1370 case MOVETYPE_BOUNCE:
1371 case MOVETYPE_BOUNCEMISSILE:
1372 case MOVETYPE_FLYMISSILE:
1373 SV_Physics_Toss (ent);
1376 if (i > 0 && i <= svs.maxclients)
1378 if (SV_RunThink (ent))
1380 SV_CheckWater (ent);
1385 SV_Physics_Toss (ent);
1388 Host_Error ("SV_Physics: bad movetype %i", (int)ent->v->movetype);
1392 if (i > 0 && i <= svs.maxclients && !ent->e->free)
1394 SV_CheckVelocity (ent);
1396 // call standard player post-think
1397 SV_LinkEdict (ent, true);
1399 SV_CheckVelocity (ent);
1401 pr_global_struct->time = sv.time;
1402 pr_global_struct->self = EDICT_TO_PROG(ent);
1403 PR_ExecuteProgram (pr_global_struct->PlayerPostThink, "QC function PlayerPostThink is missing");
1407 if (pr_global_struct->force_retouch)
1408 pr_global_struct->force_retouch--;
1410 // LordHavoc: endframe support
1413 pr_global_struct->self = EDICT_TO_PROG(sv.edicts);
1414 pr_global_struct->other = EDICT_TO_PROG(sv.edicts);
1415 pr_global_struct->time = sv.time;
1416 PR_ExecuteProgram ((func_t)(EndFrameQC - pr_functions), "");
1419 sv.time += sv.frametime;
1423 trace_t SV_Trace_Toss (edict_t *tossent, edict_t *ignore)
1426 float gravity, savesolid;
1428 edict_t tempent, *tent;
1433 // copy the vars over
1434 memcpy(&vars, tossent->v, sizeof(entvars_t));
1435 // set up the temp entity to point to the copied vars
1439 savesolid = tossent->v->solid;
1440 tossent->v->solid = SOLID_NOT;
1442 // this has to fetch the field from the original edict, since our copy is truncated
1443 val = GETEDICTFIELDVALUE(tossent, eval_gravity);
1444 if (val != NULL && val->_float != 0)
1445 gravity = val->_float;
1448 gravity *= sv_gravity.value * 0.05;
1450 for (i = 0;i < 200;i++) // LordHavoc: sanity check; never trace more than 10 seconds
1452 SV_CheckVelocity (tent);
1453 tent->v->velocity[2] -= gravity;
1454 VectorMA (tent->v->angles, 0.05, tent->v->avelocity, tent->v->angles);
1455 VectorScale (tent->v->velocity, 0.05, move);
1456 VectorAdd (tent->v->origin, move, end);
1457 trace = SV_Move (tent->v->origin, tent->v->mins, tent->v->maxs, end, MOVE_NORMAL, tent);
1458 VectorCopy (trace.endpos, tent->v->origin);
1460 if (trace.fraction < 1 && trace.ent)
1461 if (trace.ent != ignore)
1464 tossent->v->solid = savesolid;
1465 trace.fraction = 0; // not relevant