void SV_Impact (edict_t *e1, edict_t *e2)
{
int old_self, old_other;
-
+
old_self = pr_global_struct->self;
old_other = pr_global_struct->other;
-
+
pr_global_struct->time = sv.time;
if (e1->v.touch && e1->v.solid != SOLID_NOT)
{
pr_global_struct->other = EDICT_TO_PROG(e2);
PR_ExecuteProgram (e1->v.touch, "");
}
-
+
if (e2->v.touch && e2->v.solid != SOLID_NOT)
{
pr_global_struct->self = EDICT_TO_PROG(e2);
float backoff;
float change;
int i, blocked;
-
+
blocked = 0;
if (normal[2] > 0)
blocked |= 1; // floor
if (!normal[2])
blocked |= 2; // step
-
+
backoff = DotProduct (in, normal) * overbounce;
for (i=0 ; i<3 ; i++)
If steptrace is not NULL, the trace of any vertical wall hit will be stored
============
*/
-// LordHavoc: increased from 5 to 20, to partially fix angled corner sticking
-// (example - start.bsp hall to e4, leading to the pool there are two
-// angled corners, which you could get stuck on, now they are just a one
-// frame hiccup)
+// LordHavoc: increased from 5 to 20
#define MAX_CLIP_PLANES 20
int SV_FlyMove (edict_t *ent, float time, trace_t *steptrace)
{
trace_t trace;
vec3_t end;
float time_left;
- int blocked;
-
+ int blocked, impact;
+
numbumps = 4;
-
+
blocked = 0;
VectorCopy (ent->v.velocity, original_velocity);
VectorCopy (ent->v.velocity, primal_velocity);
trace = SV_Move (ent->v.origin, ent->v.mins, ent->v.maxs, end, MOVE_NORMAL, ent);
+ /*
if (trace.allsolid)
{ // entity is trapped in another solid
VectorClear(ent->v.velocity);
return 3;
}
+ */
if (trace.fraction > 0)
{ // actually covered some distance
if (!trace.ent)
Host_Error ("SV_FlyMove: !trace.ent");
+ if ((int) ent->v.flags & FL_ONGROUND)
+ {
+ if (ent->v.groundentity == EDICT_TO_PROG(trace.ent))
+ impact = false;
+ else
+ {
+ ent->v.flags = (int)ent->v.flags & ~FL_ONGROUND;
+ impact = true;
+ }
+ }
+ else
+ impact = true;
+
if (trace.plane.normal[2] > 0.7)
{
blocked |= 1; // floor
- if (trace.ent->v.solid == SOLID_BSP)
+ //if (trace.ent->v.solid == SOLID_BSP)
{
ent->v.flags = (int)ent->v.flags | FL_ONGROUND;
ent->v.groundentity = EDICT_TO_PROG(trace.ent);
//
// run the impact function
//
- SV_Impact (ent, trace.ent);
+ if (impact)
+ SV_Impact (ent, trace.ent);
if (ent->free)
break; // removed by the impact function
-
+
time_left -= time_left * trace.fraction;
-
+
// cliped to another plane
if (numplanes >= MAX_CLIP_PLANES)
{ // this shouldn't really happen
if (j == numplanes)
break;
}
-
+
if (i != numplanes)
{ // go along this plane
VectorCopy (new_velocity, ent->v.velocity);
Does not change the entities velocity at all
============
*/
-trace_t SV_PushEntity (edict_t *ent, vec3_t push)
+trace_t SV_PushEntity (edict_t *ent, vec3_t push, vec3_t pushangles)
{
trace_t trace;
vec3_t end;
-
+
VectorAdd (ent->v.origin, push, end);
if (ent->v.movetype == MOVETYPE_FLYMISSILE)
// only clip against bmodels
trace = SV_Move (ent->v.origin, ent->v.mins, ent->v.maxs, end, MOVE_NOMONSTERS, ent);
else
- trace = SV_Move (ent->v.origin, ent->v.mins, ent->v.maxs, end, MOVE_NORMAL, ent);
-
+ trace = SV_Move (ent->v.origin, ent->v.mins, ent->v.maxs, end, MOVE_NORMAL, ent);
+
VectorCopy (trace.endpos, ent->v.origin);
+ // FIXME: turn players specially
+ ent->v.angles[1] += trace.fraction * pushangles[1];
SV_LinkEdict (ent, true);
- if (trace.ent)
- SV_Impact (ent, trace.ent);
-
+ if (trace.ent && (!((int)ent->v.flags & FL_ONGROUND) || ent->v.groundentity != EDICT_TO_PROG(trace.ent)))
+ SV_Impact (ent, trace.ent);
return trace;
-}
+}
/*
============
*/
+trace_t SV_ClipMoveToEntity (edict_t *ent, vec3_t start, vec3_t mins, vec3_t maxs, vec3_t end);
void SV_PushMove (edict_t *pusher, float movetime)
{
- int i, e;
+ int i, e, index;
edict_t *check;
- vec3_t mins, maxs, move;
- vec3_t entorig, pushorig;
+ float savesolid, movetime2, pushltime;
+ vec3_t mins, maxs, move, move1, moveangle, /*entorig, entang, */pushorig, pushang, a, forward, left, up, org, org2;
int num_moved;
edict_t *moved_edict[MAX_EDICTS];
- vec3_t moved_from[MAX_EDICTS];
- float savesolid;
+ vec3_t moved_from[MAX_EDICTS], moved_fromangles[MAX_EDICTS];
+ model_t *pushermodel;
+ trace_t trace;
switch ((int) pusher->v.solid)
{
case SOLID_NOT:
case SOLID_TRIGGER:
VectorMA (pusher->v.origin, movetime, pusher->v.velocity, pusher->v.origin);
+ VectorMA (pusher->v.angles, movetime, pusher->v.avelocity, pusher->v.angles);
pusher->v.ltime += movetime;
SV_LinkEdict (pusher, false);
return;
default:
Host_Error("SV_PushMove: unrecognized solid type %f\n", pusher->v.solid);
}
- if (!pusher->v.velocity[0] && !pusher->v.velocity[1] && !pusher->v.velocity[2])
+ 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])
{
pusher->v.ltime += movetime;
return;
}
-
- for (i=0 ; i<3 ; i++)
+ index = (int) pusher->v.modelindex;
+ if (index < 1 || index >= MAX_MODELS)
+ Host_Error("SV_PushMove: invalid modelindex %f\n", pusher->v.modelindex);
+ pushermodel = sv.models[index];
+
+ // LordHavoc: round up by a small epsilon
+ movetime2 = movetime; // + (1.0 / 256.0);
+ VectorScale(pusher->v.velocity, movetime2, move1);
+ VectorScale(pusher->v.avelocity, movetime2, moveangle);
+ if (moveangle[0] || moveangle[2])
+ {
+ for (i = 0;i < 3;i++)
+ {
+ if (move1[i] > 0)
+ {
+ mins[i] = pushermodel->rotatedmins[i] + pusher->v.origin[i] - 1;
+ maxs[i] = pushermodel->rotatedmaxs[i] + move1[i] + pusher->v.origin[i] + 1;
+ }
+ else
+ {
+ mins[i] = pushermodel->rotatedmins[i] + move1[i] + pusher->v.origin[i] - 1;
+ maxs[i] = pushermodel->rotatedmaxs[i] + pusher->v.origin[i] + 1;
+ }
+ }
+ }
+ else if (moveangle[1])
+ {
+ for (i = 0;i < 3;i++)
+ {
+ if (move1[i] > 0)
+ {
+ mins[i] = pushermodel->yawmins[i] + pusher->v.origin[i] - 1;
+ maxs[i] = pushermodel->yawmaxs[i] + move1[i] + pusher->v.origin[i] + 1;
+ }
+ else
+ {
+ mins[i] = pushermodel->yawmins[i] + move1[i] + pusher->v.origin[i] - 1;
+ maxs[i] = pushermodel->yawmaxs[i] + pusher->v.origin[i] + 1;
+ }
+ }
+ }
+ else
{
- move[i] = pusher->v.velocity[i] * movetime;
- mins[i] = pusher->v.absmin[i] + move[i];
- maxs[i] = pusher->v.absmax[i] + move[i];
+ for (i = 0;i < 3;i++)
+ {
+ if (move1[i] > 0)
+ {
+ mins[i] = pushermodel->normalmins[i] + pusher->v.origin[i] - 1;
+ maxs[i] = pushermodel->normalmaxs[i] + move1[i] + pusher->v.origin[i] + 1;
+ }
+ else
+ {
+ mins[i] = pushermodel->normalmins[i] + move1[i] + pusher->v.origin[i] - 1;
+ maxs[i] = pushermodel->normalmaxs[i] + pusher->v.origin[i] + 1;
+ }
+ }
}
+ VectorNegate (moveangle, a);
+ AngleVectorsFLU (a, forward, left, up);
+
VectorCopy (pusher->v.origin, pushorig);
-
+ VectorCopy (pusher->v.angles, pushang);
+ pushltime = pusher->v.ltime;
+
// move the pusher to it's final position
- VectorAdd (pusher->v.origin, move, pusher->v.origin);
+ VectorMA (pusher->v.origin, movetime, pusher->v.velocity, pusher->v.origin);
+ VectorMA (pusher->v.angles, movetime, pusher->v.avelocity, pusher->v.angles);
pusher->v.ltime += movetime;
SV_LinkEdict (pusher, false);
+ savesolid = pusher->v.solid;
// see if any solid entities are inside the final position
num_moved = 0;
if (!(((int)check->v.flags & FL_ONGROUND) && PROG_TO_EDICT(check->v.groundentity) == pusher))
{
if (check->v.absmin[0] >= maxs[0]
- || check->v.absmin[1] >= maxs[1]
- || check->v.absmin[2] >= maxs[2]
|| check->v.absmax[0] <= mins[0]
+ || check->v.absmin[1] >= maxs[1]
|| check->v.absmax[1] <= mins[1]
+ || check->v.absmin[2] >= maxs[2]
|| check->v.absmax[2] <= mins[2])
continue;
+ /*
+ if (forward[0] < 0.999f) // quick way to check if any rotation is used
+ {
+ VectorSubtract (check->v.origin, pusher->v.origin, org);
+ org2[0] = DotProduct (org, forward);
+ org2[1] = DotProduct (org, left);
+ org2[2] = DotProduct (org, up);
+ //VectorSubtract (org2, org, move);
+ //VectorAdd (move, move1, move);
+ //VectorSubtract(check->v.origin, move, a);
+ a[0] = check->v.origin[0] + (org[0] - org2[0]) - move1[0];
+ a[1] = check->v.origin[1] + (org[1] - org2[1]) - move1[1];
+ a[2] = check->v.origin[2] + (org[2] - org2[2]) - move1[2];
+ }
+ else
+ VectorSubtract (check->v.origin, move1, a);
+
+ trace = SV_ClipMoveToEntity (pusher, a, check->v.mins, check->v.maxs, check->v.origin);
+ if (trace.fraction == 1 && !trace.startsolid)
+ continue;
+ */
+ trace = SV_ClipMoveToEntity (pusher, check->v.origin, check->v.mins, check->v.maxs, check->v.origin);
+ if (!trace.startsolid)
+ continue;
+ /*
// see if the ent's bbox is inside the pusher's final position
if (!SV_TestEntityPosition (check))
continue;
+ */
}
- // remove the onground flag for non-players
- if (check->v.movetype != MOVETYPE_WALK)
- check->v.flags = (int)check->v.flags & ~FL_ONGROUND;
-
- VectorCopy (check->v.origin, entorig);
- VectorCopy (check->v.origin, moved_from[num_moved]);
- moved_edict[num_moved] = check;
- num_moved++;
-
- // LordHavoc: pusher fixes (teleport train bug, etc)
- savesolid = pusher->v.solid;
- if (savesolid == SOLID_BSP || savesolid == SOLID_BBOX || savesolid == SOLID_SLIDEBOX)
+ if (forward[0] < 0.999f) // quick way to check if any rotation is used
{
- // try moving the contacted entity
- pusher->v.solid = SOLID_NOT;
- SV_PushEntity (check, move);
- pusher->v.solid = savesolid; // was SOLID_BSP
-
- // if it is still inside the pusher, block
- if (SV_TestEntityPosition (check))
- { // fail the move
- if (check->v.mins[0] == check->v.maxs[0])
- continue;
- if (check->v.solid == SOLID_NOT || check->v.solid == SOLID_TRIGGER)
- { // corpse
- check->v.mins[0] = check->v.mins[1] = 0;
- VectorCopy (check->v.mins, check->v.maxs);
- continue;
- }
-
- VectorCopy (entorig, check->v.origin);
- SV_LinkEdict (check, true);
-
- VectorCopy (pushorig, pusher->v.origin);
- SV_LinkEdict (pusher, false);
- pusher->v.ltime -= movetime;
-
- // if the pusher has a "blocked" function, call it, otherwise just stay in place until the obstacle is gone
- if (pusher->v.blocked)
- {
- pr_global_struct->self = EDICT_TO_PROG(pusher);
- pr_global_struct->other = EDICT_TO_PROG(check);
- PR_ExecuteProgram (pusher->v.blocked, "");
- }
-
- // move back any entities we already moved
- num_moved--; // LordHavoc: pop off check, because it was already restored
- for (i=0 ; i<num_moved ; i++)
- {
- VectorCopy (moved_from[i], moved_edict[i]->v.origin);
- SV_LinkEdict (moved_edict[i], false);
- }
- return;
- }
+ VectorSubtract (check->v.origin, pusher->v.origin, org);
+ org2[0] = DotProduct (org, forward);
+ org2[1] = DotProduct (org, left);
+ org2[2] = DotProduct (org, up);
+ VectorSubtract (org2, org, move);
+ VectorAdd (move, move1, move);
}
- }
-
-
-}
-
-/*
-============
-SV_PushRotate
-
-============
-*/
-void SV_PushRotate (edict_t *pusher, float movetime)
-{
- int i, e;
- edict_t *check;
- vec3_t move, a, amove;
- vec3_t entorigin, entangles, pushorigin, pushangles;
- int num_moved;
- edict_t *moved_edict[MAX_EDICTS];
- vec3_t moved_from[MAX_EDICTS];
- vec3_t angled_from[MAX_EDICTS];
- vec3_t org, org2;
- vec3_t forward, right, up;
- float savesolid;
-
- switch ((int) pusher->v.solid)
- {
- // LordHavoc: valid pusher types
- case SOLID_BSP:
- case SOLID_BBOX:
- case SOLID_SLIDEBOX:
- case SOLID_CORPSE: // LordHavoc: this would be weird...
- break;
- // LordHavoc: no collisions
- case SOLID_NOT:
- case SOLID_TRIGGER:
- VectorMA (pusher->v.angles, movetime, pusher->v.avelocity, pusher->v.angles);
- pusher->v.ltime += movetime;
- SV_LinkEdict (pusher, false);
- return;
- default:
- Host_Error("SV_PushRotate: unrecognized solid type %f\n", pusher->v.solid);
- }
- if (!pusher->v.avelocity[0] && !pusher->v.avelocity[1] && !pusher->v.avelocity[2])
- {
- pusher->v.ltime += movetime;
- return;
- }
-
- for (i=0 ; i<3 ; i++)
- amove[i] = pusher->v.avelocity[i] * movetime;
-
- VectorNegate (amove, a);
- AngleVectors (a, forward, right, up);
-
- VectorCopy (pusher->v.origin, pushorigin);
- VectorCopy (pusher->v.angles, pushangles);
-
-// move the pusher to it's final position
-
- VectorAdd (pusher->v.angles, amove, pusher->v.angles);
- pusher->v.ltime += movetime;
- SV_LinkEdict (pusher, false);
-
-
-// see if any solid entities are inside the final position
- num_moved = 0;
- check = NEXT_EDICT(sv.edicts);
- for (e=1 ; e<sv.num_edicts ; e++, check = NEXT_EDICT(check))
- {
- if (check->free)
- continue;
- if (check->v.movetype == MOVETYPE_PUSH
- || check->v.movetype == MOVETYPE_NONE
- || check->v.movetype == MOVETYPE_FOLLOW
- || check->v.movetype == MOVETYPE_NOCLIP)
- continue;
-
- // if the entity is standing on the pusher, it will definately be moved
- if (!(((int)check->v.flags & FL_ONGROUND) && PROG_TO_EDICT(check->v.groundentity) == pusher))
- {
- if (check->v.absmin[0] >= pusher->v.absmax[0]
- || check->v.absmin[1] >= pusher->v.absmax[1]
- || check->v.absmin[2] >= pusher->v.absmax[2]
- || check->v.absmax[0] <= pusher->v.absmin[0]
- || check->v.absmax[1] <= pusher->v.absmin[1]
- || check->v.absmax[2] <= pusher->v.absmin[2])
- continue;
+ else
+ VectorCopy (move1, move);
- // see if the ent's bbox is inside the pusher's final position
- if (!SV_TestEntityPosition (check))
- continue;
- }
+ // LordHavoc: debugging
+ //VectorAdd(entorig, move, org2);
+ //CL_RocketTrail2 (entorig, org2, 238, NULL);
- // remove the onground flag for non-players
+ // remove the onground flag for non-players
if (check->v.movetype != MOVETYPE_WALK)
check->v.flags = (int)check->v.flags & ~FL_ONGROUND;
-
- VectorCopy (check->v.origin, entorigin);
+
+ //VectorCopy (check->v.origin, entorig);
+ //VectorCopy (check->v.angles, entang);
VectorCopy (check->v.origin, moved_from[num_moved]);
- VectorCopy (check->v.angles, entangles);
- VectorCopy (check->v.angles, angled_from[num_moved]);
- moved_edict[num_moved] = check;
- num_moved++;
-
- // calculate destination position
- VectorSubtract (check->v.origin, pusher->v.origin, org);
- org2[0] = DotProduct (org, forward);
- org2[1] = -DotProduct (org, right);
- org2[2] = DotProduct (org, up);
- VectorSubtract (org2, org, move);
-
- // try moving the contacted entity
- savesolid = pusher->v.solid; // LordHavoc: restore to correct solid type
- pusher->v.solid = SOLID_NOT;
- SV_PushEntity (check, move);
- pusher->v.solid = savesolid; // LordHavoc: restore to correct solid type
+ VectorCopy (check->v.angles, moved_fromangles[num_moved]);
+ moved_edict[num_moved++] = check;
- VectorAdd (check->v.angles, amove, check->v.angles);
+ // try moving the contacted entity
+ pusher->v.solid = SOLID_NOT;
+ trace = SV_PushEntity (check, move, moveangle);
+ pusher->v.solid = savesolid; // was SOLID_BSP
- // if it is still inside the pusher, block
- if (SV_TestEntityPosition (check))
- { // fail the move
+ // if it is still inside the pusher, block
+ // LordHavoc: cleanup - check trace.fraction and startsolid
+ if (/*trace.fraction != 1 || trace.startsolid || */SV_TestEntityPosition (check))
+ {
+ // fail the move
if (check->v.mins[0] == check->v.maxs[0])
continue;
if (check->v.solid == SOLID_NOT || check->v.solid == SOLID_TRIGGER)
- { // corpse
+ {
+ // corpse
check->v.mins[0] = check->v.mins[1] = 0;
VectorCopy (check->v.mins, check->v.maxs);
continue;
}
-
- VectorCopy (entorigin, check->v.origin);
- VectorCopy (entangles, check->v.angles);
+
+ /*
+ VectorCopy (entorig, check->v.origin);
+ VectorCopy (entang, check->v.angles);
SV_LinkEdict (check, true);
+ */
- VectorCopy (pushorigin, pusher->v.origin);
- VectorCopy (pushangles, pusher->v.angles);
+ VectorCopy (pushorig, pusher->v.origin);
+ VectorCopy (pushang, pusher->v.angles);
+ pusher->v.ltime = pushltime;
SV_LinkEdict (pusher, false);
- pusher->v.ltime -= movetime;
+
+ // move back any entities we already moved
+ //num_moved--; // LordHavoc: pop off check, because it was already restored
+ for (i=0 ; i<num_moved ; i++)
+ {
+ VectorCopy (moved_from[i], moved_edict[i]->v.origin);
+ VectorCopy (moved_fromangles[i], moved_edict[i]->v.angles);
+ SV_LinkEdict (moved_edict[i], false);
+ }
// if the pusher has a "blocked" function, call it, otherwise just stay in place until the obstacle is gone
if (pusher->v.blocked)
pr_global_struct->other = EDICT_TO_PROG(check);
PR_ExecuteProgram (pusher->v.blocked, "");
}
-
- // move back any entities we already moved
- num_moved--; // LordHavoc: pop off check, because it was already restored
- for (i=0 ; i<num_moved ; i++)
- {
- VectorCopy (moved_from[i], moved_edict[i]->v.origin);
- VectorCopy (angled_from[i], moved_edict[i]->v.angles);
- SV_LinkEdict (moved_edict[i], false);
- }
return;
}
}
movetime = sv.frametime;
if (movetime)
- {
- if (ent->v.avelocity[0] || ent->v.avelocity[1] || ent->v.avelocity[2])
- SV_PushRotate (ent, movetime);
- else
- SV_PushMove (ent, movetime); // advances ent->v.ltime if not blocked
- }
-
+ SV_PushMove (ent, movetime); // advances ent->v.ltime if not blocked
+
if (thinktime > oldltime && thinktime <= ent->v.ltime)
{
ent->v.nextthink = 0;
point[0] = ent->v.origin[0];
point[1] = ent->v.origin[1];
- point[2] = ent->v.origin[2] + ent->v.mins[2] + 1;
+ point[2] = ent->v.origin[2] + ent->v.mins[2] + 1;
ent->v.waterlevel = 0;
ent->v.watertype = CONTENTS_EMPTY;
vec3_t forward;
float d, i;
vec3_t into, side;
-
+
AngleVectors (ent->v.v_angle, forward, NULL, NULL);
d = DotProduct (trace->plane.normal, forward);
vec3_t dir;
int clip;
trace_t steptrace;
-
+
VectorCopy (ent->v.origin, oldorg);
VectorClear (dir);
case 6: dir[0] = 2; dir[1] = -2; break;
case 7: dir[0] = -2; dir[1] = -2; break;
}
-
- SV_PushEntity (ent, dir);
+
+ SV_PushEntity (ent, dir, vec3_origin);
// retry the original move
ent->v.velocity[0] = oldvel[0];
//Con_DPrintf ("unstuck!\n");
return clip;
}
-
+
// go back to the original pos and try again
VectorCopy (oldorg, ent->v.origin);
}
int clip;
int oldonground;
trace_t steptrace, downtrace;
-
+
//
// do a regular slide move unless it looks like you ran into a step
//
oldonground = (int)ent->v.flags & FL_ONGROUND;
ent->v.flags = (int)ent->v.flags & ~FL_ONGROUND;
-
+
VectorCopy (ent->v.origin, oldorg);
VectorCopy (ent->v.velocity, oldvel);
if (!oldonground && ent->v.waterlevel == 0)
return; // don't stair up while jumping
-
+
if (ent->v.movetype != MOVETYPE_WALK)
return; // gibbed by a trigger
-
+
if (sv_nostep.integer)
return;
-
+
if ( (int)sv_player->v.flags & FL_WATERJUMP )
return;
downmove[2] = -STEPSIZE + oldvel[2]*sv.frametime;
// move up
- SV_PushEntity (ent, upmove); // FIXME: don't link?
+ SV_PushEntity (ent, upmove, vec3_origin); // FIXME: don't link?
// move forward
ent->v.velocity[0] = oldvel[0];
clip = SV_TryUnstick (ent, oldvel);
}
}
-
+
// extra friction based on view angle
if ( clip & 2 )
SV_WallFriction (ent, &steptrace);
// move down
- downtrace = SV_PushEntity (ent, downmove); // FIXME: don't link?
+ downtrace = SV_PushEntity (ent, downmove, vec3_origin); // FIXME: don't link?
if (downtrace.plane.normal[2] > 0.7)
{
//
// call standard client pre-think
-//
+//
pr_global_struct->time = sv.time;
pr_global_struct->self = EDICT_TO_PROG(ent);
PR_ExecuteProgram (pr_global_struct->PlayerPreThink, "QC function PlayerPreThink is missing");
-
+
//
// do a move
//
SV_CheckStuck (ent);
SV_WalkMove (ent);
break;
-
+
case MOVETYPE_TOSS:
case MOVETYPE_BOUNCE:
SV_Physics_Toss (ent);
SV_CheckWater (ent);
SV_FlyMove (ent, sv.frametime, NULL);
break;
-
+
case MOVETYPE_NOCLIP:
if (!SV_RunThink (ent))
return;
SV_CheckWater (ent);
VectorMA (ent->v.origin, sv.frametime, ent->v.velocity, ent->v.origin);
break;
-
+
default:
Host_Error ("SV_Physics_client: bad movetype %i", (int)ent->v.movetype);
}
//
// call standard player post-think
-//
+//
SV_LinkEdict (ent, true);
pr_global_struct->time = sv.time;
// regular thinking
if (!SV_RunThink (ent))
return;
-
+
VectorMA (ent->v.angles, sv.frametime, ent->v.avelocity, ent->v.angles);
VectorMA (ent->v.origin, sv.frametime, ent->v.velocity, ent->v.origin);
ent->v.waterlevel = 1;
return;
}
-
+
if (cont <= CONTENTS_WATER)
{
if (ent->v.watertype == CONTENTS_EMPTY)
{ // just crossed into water
SV_StartSound (ent, 0, "misc/h2ohit1.wav", 255, 1);
- }
+ }
ent->v.watertype = cont;
ent->v.waterlevel = 1;
}
if (ent->v.watertype != CONTENTS_EMPTY)
{ // just crossed into water
SV_StartSound (ent, 0, "misc/h2ohit1.wav", 255, 1);
- }
+ }
ent->v.watertype = CONTENTS_EMPTY;
ent->v.waterlevel = cont;
}
{
trace_t trace;
vec3_t move;
- float backoff;
- edict_t *groundentity;
+ //edict_t *groundentity;
// regular thinking
if (!SV_RunThink (ent))
return;
// if onground, return without moving
+ if (((int)ent->v.flags & FL_ONGROUND) && ent->v.groundentity == 0)
+ return;
+ /*
if ( ((int)ent->v.flags & FL_ONGROUND) )
{
// LordHavoc: fall if the groundentity was removed
return;
}
}
- ent->v.flags = (int)ent->v.flags & ~FL_ONGROUND;
+ */
SV_CheckVelocity (ent);
// move origin
VectorScale (ent->v.velocity, sv.frametime, move);
- trace = SV_PushEntity (ent, move);
- if (trace.fraction == 1)
- return;
+ trace = SV_PushEntity (ent, move, vec3_origin);
if (ent->free)
return;
+ if (trace.fraction == 1)
+ return;
- if (ent->v.movetype == MOVETYPE_BOUNCE)
- backoff = 1.5;
- else if (ent->v.movetype == MOVETYPE_BOUNCEMISSILE)
- backoff = 2.0;
- else
- backoff = 1;
-
- ClipVelocity (ent->v.velocity, trace.plane.normal, ent->v.velocity, backoff);
-
-// stop if on ground
- if (trace.plane.normal[2] > 0.7)
+ if (ent->v.movetype == MOVETYPE_BOUNCEMISSILE)
+ {
+ ClipVelocity (ent->v.velocity, trace.plane.normal, ent->v.velocity, 2.0);
+ ent->v.flags = (int)ent->v.flags & ~FL_ONGROUND;
+ }
+ else if (ent->v.movetype == MOVETYPE_BOUNCE)
{
+ ClipVelocity (ent->v.velocity, trace.plane.normal, ent->v.velocity, 1.5);
// LordHavoc: fixed grenades not bouncing when fired down a slope
- if (fabs(ent->v.velocity[2]) < 60 || (ent->v.movetype != MOVETYPE_BOUNCE && ent->v.movetype != MOVETYPE_BOUNCEMISSILE))
- //if (ent->v.velocity[2] < 60 || (ent->v.movetype != MOVETYPE_BOUNCE && ent->v.movetype != MOVETYPE_BOUNCEMISSILE))
+ if (trace.plane.normal[2] > 0.7 && DotProduct(trace.plane.normal, ent->v.velocity) < 60)
+ //if (trace.plane.normal[2] > 0.7 && ent->v.velocity[2] < 60)
{
ent->v.flags = (int)ent->v.flags | FL_ONGROUND;
ent->v.groundentity = EDICT_TO_PROG(trace.ent);
ent->v.flags = (int)ent->v.flags & ~FL_ONGROUND;
}
else
- ent->v.flags = (int)ent->v.flags & ~FL_ONGROUND;
+ {
+ ClipVelocity (ent->v.velocity, trace.plane.normal, ent->v.velocity, 1.0);
+ if (trace.plane.normal[2] > 0.7)
+ {
+ ent->v.flags = (int)ent->v.flags | FL_ONGROUND;
+ ent->v.groundentity = EDICT_TO_PROG(trace.ent);
+ VectorClear (ent->v.velocity);
+ VectorClear (ent->v.avelocity);
+ }
+ else
+ ent->v.flags = (int)ent->v.flags & ~FL_ONGROUND;
+ }
// check for in water
SV_CheckWaterTransition (ent);
*/
void SV_Physics_Step (edict_t *ent)
{
- qboolean hitsound;
+ int flags, fall, hitsound;
-// freefall if not onground
- if ( ! ((int)ent->v.flags & (FL_ONGROUND | FL_FLY | FL_SWIM) ) )
+ // freefall if not fly/swim
+ fall = true;
+ flags = (int)ent->v.flags;
+ if (flags & (FL_FLY | FL_SWIM))
+ {
+ if (flags & FL_FLY)
+ fall = false;
+ else if ((flags & FL_SWIM) && SV_PointContents(ent->v.origin) != CONTENTS_EMPTY)
+ fall = false;
+ }
+ if (fall && (flags & FL_ONGROUND) && ent->v.groundentity == 0)
+ fall = false;
+
+ if (fall)
{
if (ent->v.velocity[2] < sv_gravity.value*-0.1)
+ {
hitsound = true;
+ if (flags & FL_ONGROUND)
+ hitsound = false;
+ }
else
hitsound = false;
SV_AddGravity (ent);
SV_CheckVelocity (ent);
SV_FlyMove (ent, sv.frametime, NULL);
- SV_LinkEdict (ent, true);
+ SV_LinkEdict (ent, false);
- if ( (int)ent->v.flags & FL_ONGROUND ) // just hit ground
+ // just hit ground
+ if ((int)ent->v.flags & FL_ONGROUND)
{
+ VectorClear(ent->v.velocity);
if (hitsound)
SV_StartSound (ent, 0, "demon/dland2.wav", 255, 1);
}
break;
}
}
-
+
if (pr_global_struct->force_retouch)
- pr_global_struct->force_retouch--;
+ pr_global_struct->force_retouch--;
// LordHavoc: endframe support
if (EndFrameQC)