This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the GNU General Public License for more details.
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.
-onground is set for toss objects when they come to a complete rest. it is set for steping or walking objects
+onground is set for toss objects when they come to a complete rest. it is set for steping or walking objects
doors, plats, etc are SOLID_BSP, and MOVETYPE_PUSH
bonus items are SOLID_TRIGGER touch, and MOVETYPE_TOSS
*/
-cvar_t sv_friction = {"sv_friction","4",false,true};
-cvar_t sv_stopspeed = {"sv_stopspeed","100"};
-cvar_t sv_gravity = {"sv_gravity","800",false,true};
-cvar_t sv_maxvelocity = {"sv_maxvelocity","2000"};
-cvar_t sv_nostep = {"sv_nostep","0"};
+cvar_t sv_friction = {CVAR_NOTIFY, "sv_friction","4"};
+cvar_t sv_stopspeed = {0, "sv_stopspeed","100"};
+cvar_t sv_gravity = {CVAR_NOTIFY, "sv_gravity","800"};
+cvar_t sv_maxvelocity = {0, "sv_maxvelocity","2000"};
+cvar_t sv_nostep = {0, "sv_nostep","0"};
#define MOVE_EPSILON 0.01
ent->v.velocity[0] *= wishspeed;
ent->v.velocity[1] *= wishspeed;
ent->v.velocity[2] *= wishspeed;
- wishspeed = sv_maxvelocity.value;
}
}
float thinktime;
thinktime = ent->v.nextthink;
- if (thinktime <= 0 || thinktime > sv.time + host_frametime)
+ if (thinktime <= 0 || thinktime > sv.time + sv.frametime)
return true;
if (thinktime < sv.time)
pr_global_struct->time = thinktime;
pr_global_struct->self = EDICT_TO_PROG(ent);
pr_global_struct->other = EDICT_TO_PROG(sv.edicts);
- PR_ExecuteProgram (ent->v.think);
+ PR_ExecuteProgram (ent->v.think, "NULL think function");
return !ent->free;
}
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->self = EDICT_TO_PROG(e1);
pr_global_struct->other = EDICT_TO_PROG(e2);
- PR_ExecuteProgram (e1->v.touch);
+ PR_ExecuteProgram (e1->v.touch, "");
}
-
+
if (e2->v.touch && e2->v.solid != SOLID_NOT)
{
pr_global_struct->self = EDICT_TO_PROG(e2);
pr_global_struct->other = EDICT_TO_PROG(e1);
- PR_ExecuteProgram (e2->v.touch);
+ PR_ExecuteProgram (e2->v.touch, "");
}
pr_global_struct->self = old_self;
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 (out[i] > -STOP_EPSILON && out[i] < STOP_EPSILON)
out[i] = 0;
}
-
+
return blocked;
}
If steptrace is not NULL, the trace of any vertical wall hit will be stored
============
*/
-#define MAX_CLIP_PLANES 5
+// LordHavoc: increased from 5 to 20
+#define MAX_CLIP_PLANES 20
int SV_FlyMove (edict_t *ent, float time, trace_t *steptrace)
{
int bumpcount, numbumps;
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);
numplanes = 0;
-
+
time_left = time;
for (bumpcount=0 ; bumpcount<numbumps ; bumpcount++)
for (i=0 ; i<3 ; i++)
end[i] = ent->v.origin[i] + time_left * ent->v.velocity[i];
- trace = SV_Move (ent->v.origin, ent->v.mins, ent->v.maxs, end, false, ent);
+ 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
- VectorCopy (vec3_origin, ent->v.velocity);
+ 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
- VectorCopy (vec3_origin, ent->v.velocity);
+ VectorClear(ent->v.velocity);
return 3;
}
if (j == numplanes)
break;
}
-
+
if (i != numplanes)
{ // go along this plane
VectorCopy (new_velocity, ent->v.velocity);
if (numplanes != 2)
{
// Con_Printf ("clip velocity, numplanes == %i\n",numplanes);
- VectorCopy (vec3_origin, ent->v.velocity);
+ VectorClear(ent->v.velocity);
return 7;
}
CrossProduct (planes[0], planes[1], dir);
+ // LordHavoc: thanks to taniwha of QuakeForge for pointing out this fix for slowed falling in corners
+ VectorNormalize(dir);
d = DotProduct (dir, ent->v.velocity);
VectorScale (dir, d, ent->v.velocity);
}
//
if (DotProduct (ent->v.velocity, primal_velocity) <= 0)
{
- VectorCopy (vec3_origin, ent->v.velocity);
+ VectorClear(ent->v.velocity);
return blocked;
}
}
ent_gravity = val->_float;
else
ent_gravity = 1.0;
- ent->v.velocity[2] -= ent_gravity * sv_gravity.value * host_frametime;
+ ent->v.velocity[2] -= ent_gravity * sv_gravity.value * sv.frametime;
}
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;
-
- 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;
-
- VectorSubtract (vec3_origin, 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;
+ else
+ VectorCopy (move1, move);
- // 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;
+ // LordHavoc: debugging
+ //VectorAdd(entorig, move, org2);
+ //CL_RocketTrail2 (entorig, org2, 238, NULL);
- // 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
+ // 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->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);
- VectorCopy (angled_from[i], moved_edict[i]->v.angles);
- SV_LinkEdict (moved_edict[i], false);
+ PR_ExecuteProgram (pusher->v.blocked, "");
}
return;
}
float movetime;
oldltime = ent->v.ltime;
-
- /*
+
thinktime = ent->v.nextthink;
- if (thinktime < ent->v.ltime + host_frametime)
+ if (thinktime < ent->v.ltime + sv.frametime)
{
movetime = thinktime - ent->v.ltime;
if (movetime < 0)
movetime = 0;
}
else
- movetime = host_frametime;
+ 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
- }
- */
- if (ent->v.avelocity[0] || ent->v.avelocity[1] || ent->v.avelocity[2])
- SV_PushRotate (ent, host_frametime);
- else
- {
- thinktime = ent->v.nextthink;
- if (thinktime < ent->v.ltime + host_frametime)
- {
- movetime = thinktime - ent->v.ltime;
- if (movetime < 0)
- movetime = 0;
- }
- else
- movetime = host_frametime;
- if (movetime)
- 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;
pr_global_struct->time = sv.time;
pr_global_struct->self = EDICT_TO_PROG(ent);
pr_global_struct->other = EDICT_TO_PROG(sv.edicts);
- PR_ExecuteProgram (ent->v.think);
+ PR_ExecuteProgram (ent->v.think, "NULL think function");
if (ent->free)
return;
}
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;
*/
void SV_WallFriction (edict_t *ent, trace_t *trace)
{
- vec3_t forward, right, up;
+ vec3_t forward;
float d, i;
vec3_t into, side;
-
- AngleVectors (ent->v.v_angle, forward, right, up);
+
+ AngleVectors (ent->v.v_angle, forward, NULL, NULL);
d = DotProduct (trace->plane.normal, forward);
d += 0.5;
if (d >= 0)
return;
-
+
// cut the tangential velocity
i = DotProduct (trace->plane.normal, ent->v.velocity);
VectorScale (trace->plane.normal, i, into);
vec3_t dir;
int clip;
trace_t steptrace;
-
+
VectorCopy (ent->v.origin, oldorg);
- VectorCopy (vec3_origin, dir);
+ VectorClear (dir);
for (i=0 ; i<8 ; i++)
{
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];
- ent->v. velocity[1] = oldvel[1];
- ent->v. velocity[2] = 0;
+ ent->v.velocity[1] = oldvel[1];
+ ent->v.velocity[2] = 0;
clip = SV_FlyMove (ent, 0.1, &steptrace);
if ( fabs(oldorg[1] - ent->v.origin[1]) > 4
//Con_DPrintf ("unstuck!\n");
return clip;
}
-
+
// go back to the original pos and try again
VectorCopy (oldorg, ent->v.origin);
}
- VectorCopy (vec3_origin, ent->v.velocity);
+ VectorClear (ent->v.velocity);
return 7; // still not moving
}
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);
-
- clip = SV_FlyMove (ent, host_frametime, &steptrace);
+
+ clip = SV_FlyMove (ent, sv.frametime, &steptrace);
if ( !(clip & 2) )
return; // move didn't block on a step
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.value)
+
+ if (sv_nostep.integer)
return;
-
+
if ( (int)sv_player->v.flags & FL_WATERJUMP )
return;
//
VectorCopy (oldorg, ent->v.origin); // back to start pos
- VectorCopy (vec3_origin, upmove);
- VectorCopy (vec3_origin, downmove);
+ VectorClear (upmove);
+ VectorClear (downmove);
upmove[2] = STEPSIZE;
- downmove[2] = -STEPSIZE + oldvel[2]*host_frametime;
+ 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];
ent->v. velocity[1] = oldvel[1];
ent->v. velocity[2] = 0;
- clip = SV_FlyMove (ent, host_frametime, &steptrace);
+ clip = SV_FlyMove (ent, sv.frametime, &steptrace);
// check for stuckness, possibly due to the limited precision of floats
// in the clipping hulls
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)
{
{
// if the push down didn't end up on good ground, use the move without
// the step up. This happens near wall / slope combinations, and can
-// cause the player to hop up higher on a slope too steep to climb
+// cause the player to hop up higher on a slope too steep to climb
VectorCopy (nosteporg, ent->v.origin);
VectorCopy (nostepvel, ent->v.velocity);
}
//
// 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);
-
+ 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);
case MOVETYPE_FLY:
if (!SV_RunThink (ent))
return;
- SV_FlyMove (ent, host_frametime, NULL);
+ SV_CheckWater (ent);
+ SV_FlyMove (ent, sv.frametime, NULL);
break;
-
+
case MOVETYPE_NOCLIP:
if (!SV_RunThink (ent))
return;
- VectorMA (ent->v.origin, host_frametime, ent->v.velocity, ent->v.origin);
+ 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;
pr_global_struct->self = EDICT_TO_PROG(ent);
- PR_ExecuteProgram (pr_global_struct->PlayerPostThink);
+ PR_ExecuteProgram (pr_global_struct->PlayerPostThink, "QC function PlayerPostThink is missing");
}
//============================================================================
Non moving objects can only think
=============
*/
+// LordHavoc: inlined manually because it was a real time waster
+/*
void SV_Physics_None (edict_t *ent)
{
// regular thinking
SV_RunThink (ent);
}
+*/
/*
=============
*/
void SV_Physics_Follow (edict_t *ent)
{
- vec3_t vf, vu, vr, angles;
+ vec3_t vf, vr, vu, angles, v;
edict_t *e;
// regular thinking
- SV_RunThink (ent);
+ if (!SV_RunThink (ent))
+ return;
// LordHavoc: implemented rotation on MOVETYPE_FOLLOW objects
e = PROG_TO_EDICT(ent->v.aiment);
- angles[0] = -e->v.angles[0];
- angles[1] = e->v.angles[1];
- angles[2] = e->v.angles[2];
- AngleVectors (angles, vf, vr, vu);
- VectorMA (e->v.origin, ent->v.view_ofs[0], vf, ent->v.origin);
- VectorMA (ent->v.origin, ent->v.view_ofs[1], vr, ent->v.origin);
- VectorMA (ent->v.origin, ent->v.view_ofs[2], vu, ent->v.origin);
+ 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])
+ {
+ // quick case for no rotation
+ VectorAdd(e->v.origin, ent->v.view_ofs, ent->v.origin);
+ }
+ else
+ {
+ angles[0] = -ent->v.punchangle[0];
+ angles[1] = ent->v.punchangle[1];
+ angles[2] = ent->v.punchangle[2];
+ AngleVectors (angles, vf, vr, vu);
+ v[0] = ent->v.view_ofs[0] * vf[0] + ent->v.view_ofs[1] * vr[0] + ent->v.view_ofs[2] * vu[0];
+ v[1] = ent->v.view_ofs[0] * vf[1] + ent->v.view_ofs[1] * vr[1] + ent->v.view_ofs[2] * vu[1];
+ v[2] = ent->v.view_ofs[0] * vf[2] + ent->v.view_ofs[1] * vr[2] + ent->v.view_ofs[2] * vu[2];
+ angles[0] = -e->v.angles[0];
+ angles[1] = e->v.angles[1];
+ angles[2] = e->v.angles[2];
+ AngleVectors (angles, vf, vr, vu);
+ ent->v.origin[0] = v[0] * vf[0] + v[1] * vf[1] + v[2] * vf[2] + e->v.origin[0];
+ ent->v.origin[1] = v[0] * vr[0] + v[1] * vr[1] + v[2] * vr[2] + e->v.origin[1];
+ ent->v.origin[2] = v[0] * vu[0] + v[1] * vu[1] + v[2] * vu[2] + e->v.origin[2];
+ /*
+ ent->v.origin[0] = ent->v.view_ofs[0] * vf[0] + ent->v.view_ofs[0] * vf[1] + ent->v.view_ofs[0] * vf[2] + e->v.origin[0];
+ ent->v.origin[1] = ent->v.view_ofs[1] * vr[0] + ent->v.view_ofs[1] * vr[1] + ent->v.view_ofs[1] * vr[2] + e->v.origin[1];
+ ent->v.origin[2] = ent->v.view_ofs[2] * vu[0] + ent->v.view_ofs[2] * vu[1] + ent->v.view_ofs[2] * vu[2] + e->v.origin[2];
+ */
+ }
VectorAdd (e->v.angles, ent->v.v_angle, ent->v.angles);
// VectorAdd (PROG_TO_EDICT(ent->v.aiment)->v.origin, ent->v.v_angle, ent->v.origin);
SV_LinkEdict (ent, true);
// regular thinking
if (!SV_RunThink (ent))
return;
-
- VectorMA (ent->v.angles, host_frametime, ent->v.avelocity, ent->v.angles);
- VectorMA (ent->v.origin, host_frametime, ent->v.velocity, ent->v.origin);
+
+ VectorMA (ent->v.angles, sv.frametime, ent->v.avelocity, ent->v.angles);
+ VectorMA (ent->v.origin, sv.frametime, ent->v.velocity, ent->v.origin);
SV_LinkEdict (ent, false);
}
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;
// regular thinking
if (!SV_RunThink (ent))
return;
// if onground, return without moving
- if ( ((int)ent->v.flags & FL_ONGROUND) )
+ 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
+ if (ent->v.groundentity)
+ {
+ groundentity = PROG_TO_EDICT(ent->v.groundentity);
+ if (groundentity && groundentity->v.solid != SOLID_NOT && groundentity->v.solid != SOLID_TRIGGER)
+ return;
+ }
+ }
+ */
SV_CheckVelocity (ent);
SV_AddGravity (ent);
// move angles
- VectorMA (ent->v.angles, host_frametime, ent->v.avelocity, ent->v.angles);
+ VectorMA (ent->v.angles, sv.frametime, ent->v.avelocity, ent->v.angles);
// move origin
- VectorScale (ent->v.velocity, host_frametime, move);
- trace = SV_PushEntity (ent, move);
- if (trace.fraction == 1)
- return;
+ VectorScale (ent->v.velocity, sv.frametime, move);
+ trace = SV_PushEntity (ent, move, vec3_origin);
if (ent->free)
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);
+ if (trace.fraction == 1)
+ return;
-// stop if on ground
- if (trace.plane.normal[2] > 0.7)
- {
- if (ent->v.velocity[2] < 60 || (ent->v.movetype != MOVETYPE_BOUNCE && ent->v.movetype != MOVETYPE_BOUNCEMISSILE))
+ 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 (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);
- VectorCopy (vec3_origin, ent->v.velocity);
- VectorCopy (vec3_origin, ent->v.avelocity);
+ VectorClear (ent->v.velocity);
+ VectorClear (ent->v.avelocity);
}
+ else
+ ent->v.flags = (int)ent->v.flags & ~FL_ONGROUND;
}
-
+ else
+ {
+ 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, host_frametime, NULL);
- SV_LinkEdict (ent, true);
+ SV_FlyMove (ent, sv.frametime, NULL);
+ 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);
}
// regular thinking
SV_RunThink (ent);
-
+
SV_CheckWaterTransition (ent);
}
================
*/
-extern dfunction_t *EndFrameQC;
void SV_Physics (void)
{
int i;
pr_global_struct->self = EDICT_TO_PROG(sv.edicts);
pr_global_struct->other = EDICT_TO_PROG(sv.edicts);
pr_global_struct->time = sv.time;
- PR_ExecuteProgram (pr_global_struct->StartFrame);
+ PR_ExecuteProgram (pr_global_struct->StartFrame, "QC function StartFrame is missing");
//SV_CheckAllEnts ();
SV_Physics_Pusher (ent);
break;
case MOVETYPE_NONE:
- SV_Physics_None (ent);
+// SV_Physics_None (ent);
+ // LordHavoc: manually inlined the thinktime check here because MOVETYPE_NONE is used on so many objects
+ if (ent->v.nextthink > 0 && ent->v.nextthink <= sv.time + sv.frametime)
+ SV_RunThink (ent);
break;
case MOVETYPE_FOLLOW:
SV_Physics_Follow (ent);
SV_AddGravity (ent);
SV_CheckStuck (ent);
SV_WalkMove (ent);
+ SV_LinkEdict (ent, true);
}
break;
case MOVETYPE_TOSS:
break;
}
}
-
+
if (pr_global_struct->force_retouch)
- pr_global_struct->force_retouch--;
+ pr_global_struct->force_retouch--;
// LordHavoc: endframe support
if (EndFrameQC)
pr_global_struct->self = EDICT_TO_PROG(sv.edicts);
pr_global_struct->other = EDICT_TO_PROG(sv.edicts);
pr_global_struct->time = sv.time;
- PR_ExecuteProgram ((func_t)(EndFrameQC - pr_functions));
+ PR_ExecuteProgram ((func_t)(EndFrameQC - pr_functions), "");
}
- sv.time += host_frametime;
+ sv.time += sv.frametime;
}
-trace_t SV_Trace_Toss (edict_t *ent, edict_t *ignore)
+trace_t SV_Trace_Toss (edict_t *tossent, edict_t *ignore)
{
int i;
edict_t tempent, *tent;
trace_t trace;
vec3_t move;
vec3_t end;
- double save_frametime;
-
- save_frametime = host_frametime;
- host_frametime = 0.05;
+ float gravity, savesolid;
+ eval_t *val;
- memcpy(&tempent, ent, sizeof(edict_t));
+ memcpy(&tempent, tossent, sizeof(edict_t));
tent = &tempent;
+ savesolid = tossent->v.solid;
+ tossent->v.solid = SOLID_NOT;
+
+ // this has to fetch the field from the original edict, since our copy is truncated
+ val = GETEDICTFIELDVALUE(tossent, eval_gravity);
+ if (val != NULL && val->_float != 0)
+ gravity = val->_float;
+ else
+ gravity = 1.0;
+ gravity *= sv_gravity.value * 0.05;
for (i = 0;i < 200;i++) // LordHavoc: sanity check; never trace more than 10 seconds
{
SV_CheckVelocity (tent);
- SV_AddGravity (tent);
- VectorMA (tent->v.angles, host_frametime, tent->v.avelocity, tent->v.angles);
- VectorScale (tent->v.velocity, host_frametime, move);
+ tent->v.velocity[2] -= gravity;
+ VectorMA (tent->v.angles, 0.05, tent->v.avelocity, tent->v.angles);
+ VectorScale (tent->v.velocity, 0.05, move);
VectorAdd (tent->v.origin, move, end);
- trace = SV_Move (tent->v.origin, tent->v.mins, tent->v.maxs, end, MOVE_NORMAL, tent);
+ trace = SV_Move (tent->v.origin, tent->v.mins, tent->v.maxs, end, MOVE_NORMAL, tent);
VectorCopy (trace.endpos, tent->v.origin);
- if (trace.ent)
+ if (trace.fraction < 1 && trace.ent)
if (trace.ent != ignore)
break;
}
- host_frametime = save_frametime;
+ tossent->v.solid = savesolid;
+ trace.fraction = 0; // not relevant
return trace;
}
projects / xonotic / darkplaces.git / blobdiff