cvar_t sv_jumpstep = {CVAR_NOTIFY, "sv_jumpstep", "1"};
cvar_t sv_wallfriction = {CVAR_NOTIFY, "sv_wallfriction", "1"};
cvar_t sv_newflymove = {CVAR_NOTIFY, "sv_newflymove", "1"};
+cvar_t sv_freezenonclients = {CVAR_NOTIFY, "sv_freezenonclients", "0"};
#define MOVE_EPSILON 0.01
Cvar_RegisterVariable(&sv_jumpstep);
Cvar_RegisterVariable(&sv_wallfriction);
Cvar_RegisterVariable(&sv_newflymove);
+ Cvar_RegisterVariable(&sv_freezenonclients);
}
/*
#define MAX_CLIP_PLANES 20
int SV_FlyMove (edict_t *ent, float time, float *stepnormal)
{
+ int blocked, bumpcount;
+ edict_t *hackongroundentity;
+ hackongroundentity = NULL;
if (sv_newflymove.integer)
{
- int blocked, impact, bumpcount;
+ int impact;
vec3_t end, primal_velocity;
trace_t trace;
blocked = 0;
VectorCopy (ent->v->velocity, primal_velocity);
- for (bumpcount = 0;bumpcount < 4;bumpcount++)
+ for (bumpcount = 0;bumpcount < 8;bumpcount++)
{
+ //Con_Printf("entity %i bump %i: blocked %i velocity %f %f %f\n", ent - sv.edicts, bumpcount, blocked, ent->v->velocity[0], ent->v->velocity[1], ent->v->velocity[2]);
if (!ent->v->velocity[0] && !ent->v->velocity[1] && !ent->v->velocity[2])
break;
trace = SV_Move (ent->v->origin, ent->v->mins, ent->v->maxs, end, MOVE_NORMAL, ent);
//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]);
- if (trace.allsolid)
+ /*
+ if (trace.startsolid)
{
// LordHavoc: note: this code is what makes entities stick in place if embedded in another object (which can be the world)
// entity is trapped in another solid
VectorClear(ent->v->velocity);
return 3;
}
+ */
- if (trace.fraction > 0)
+ if (trace.fraction >= 0.001)
{
// actually covered some distance
VectorCopy (trace.endpos, ent->v->origin);
else
impact = true;
- if (trace.plane.normal[2] > 0.7)
+ if (trace.plane.normal[2])
{
- // floor
- blocked |= 1;
- ent->v->flags = (int)ent->v->flags | FL_ONGROUND;
- ent->v->groundentity = EDICT_TO_PROG(trace.ent);
+ if (trace.plane.normal[2] > 0.7)
+ {
+ // floor
+ blocked |= 1;
+ ent->v->flags = (int)ent->v->flags | FL_ONGROUND;
+ ent->v->groundentity = EDICT_TO_PROG(trace.ent);
+ }
+ else if (trace.fraction < 0.001)
+ hackongroundentity = trace.ent;
}
- if (!trace.plane.normal[2])
+ else
{
// step
blocked |= 2;
time *= 1 - trace.fraction;
ClipVelocity (ent->v->velocity, trace.plane.normal, ent->v->velocity, 1);
- }
- return blocked;
+ // if original velocity is against the original velocity,
+ // stop dead to avoid tiny occilations in sloping corners
+ if (DotProduct (ent->v->velocity, primal_velocity) < 0)
+ {
+ VectorClear(ent->v->velocity);
+ break;
+ }
+ }
}
else
{
- int i, j, blocked, impact, numplanes, bumpcount, numbumps;
+ int i, j, impact, numplanes;
float d, time_left;
vec3_t dir, end, planes[MAX_CLIP_PLANES], primal_velocity, original_velocity, new_velocity;
trace_t trace;
- numbumps = 4;
-
blocked = 0;
VectorCopy (ent->v->velocity, original_velocity);
VectorCopy (ent->v->velocity, primal_velocity);
time_left = time;
- for (bumpcount=0 ; bumpcount<numbumps ; bumpcount++)
+ for (bumpcount = 0;bumpcount < 8;bumpcount++)
{
+ //Con_Printf("entity %i bump %i: blocked %i velocity %f %f %f\n", ent - sv.edicts, bumpcount, blocked, ent->v->velocity[0], ent->v->velocity[1], ent->v->velocity[2]);
if (!ent->v->velocity[0] && !ent->v->velocity[1] && !ent->v->velocity[2])
break;
trace = SV_Move (ent->v->origin, ent->v->mins, ent->v->maxs, end, MOVE_NORMAL, ent);
- if (trace.allsolid)
+ /*
+ if (trace.startsolid)
{
// LordHavoc: note: this code is what makes entities stick in place if embedded in another object (which can be the world)
// entity is trapped in another solid
VectorClear(ent->v->velocity);
return 3;
}
+ */
if (trace.fraction > 0)
{
else
impact = true;
- if (trace.plane.normal[2] > 0.7)
+ if (trace.plane.normal[2])
{
- // floor
- blocked |= 1;
- ent->v->flags = (int)ent->v->flags | FL_ONGROUND;
- ent->v->groundentity = EDICT_TO_PROG(trace.ent);
+ if (trace.plane.normal[2] > 0.7)
+ {
+ // floor
+ blocked |= 1;
+ ent->v->flags = (int)ent->v->flags | FL_ONGROUND;
+ ent->v->groundentity = EDICT_TO_PROG(trace.ent);
+ }
+ else if (trace.fraction < 0.001)
+ hackongroundentity = trace.ent;
}
- if (!trace.plane.normal[2])
+ else
{
// step
blocked |= 2;
{
// this shouldn't really happen
VectorClear(ent->v->velocity);
- return 3;
+ blocked = 3;
+ break;
}
VectorCopy (trace.plane.normal, planes[numplanes]);
if (numplanes != 2)
{
VectorClear(ent->v->velocity);
- return 7;
+ blocked = 7;
+ break;
}
CrossProduct (planes[0], planes[1], dir);
// LordHavoc: thanks to taniwha of QuakeForge for pointing out this fix for slowed falling in corners
if (DotProduct (ent->v->velocity, primal_velocity) <= 0)
{
VectorClear(ent->v->velocity);
- return blocked;
+ break;
}
}
+ }
+
+ //Con_Printf("entity %i final: blocked %i velocity %f %f %f\n", ent - sv.edicts, blocked, ent->v->velocity[0], ent->v->velocity[1], ent->v->velocity[2]);
- return blocked;
+ /*
+ // FIXME: this doesn't work well at all, find another solution
+ // if player is ontop of a non-onground floor and made no progress,
+ // set onground anyway (this tends to happen if standing in a wedge)
+ if (bumpcount == 8 && hackongroundentity)
+ {
+ blocked |= 1;
+ ent->v->flags = (int)ent->v->flags | FL_ONGROUND;
+ ent->v->groundentity = EDICT_TO_PROG(hackongroundentity);
}
+ */
+
+ /*
+ if ((blocked & 1) == 0 && bumpcount > 1)
+ {
+ // LordHavoc: fix the 'fall to your death in a wedge corner' glitch
+ // flag ONGROUND if there's ground under it
+ trace = SV_Move (ent->v->origin, ent->v->mins, ent->v->maxs, end, MOVE_NORMAL, ent);
+ }
+ */
+ return blocked;
}
vec3_t mins, maxs, move, move1, moveangle, pushorig, pushang, a, forward, left, up, org, org2;
int num_moved;
model_t *pushermodel;
- trace_t trace;
+
+ 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;
+ }
switch ((int) pusher->v->solid)
{
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->angles[0] -= 360.0 * floor(pusher->v->angles[0] * (1.0 / 360.0));
+ pusher->v->angles[1] -= 360.0 * floor(pusher->v->angles[1] * (1.0 / 360.0));
+ pusher->v->angles[2] -= 360.0 * floor(pusher->v->angles[2] * (1.0 / 360.0));
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] && !pusher->v->avelocity[0] && !pusher->v->avelocity[1] && !pusher->v->avelocity[2])
- {
- pusher->v->ltime += movetime;
- return;
- }
index = (int) pusher->v->modelindex;
if (index < 1 || index >= MAX_MODELS)
Host_Error("SV_PushMove: invalid modelindex %f\n", pusher->v->modelindex);
|| check->v->absmax[2] <= mins[2])
continue;
- trace = SV_ClipMoveToEntity (pusher, check->v->origin, check->v->mins, check->v->maxs, check->v->origin);
- if (!trace.startsolid)
+ if (!SV_ClipMoveToEntity(pusher, check->v->origin, check->v->mins, check->v->maxs, check->v->origin).startsolid)
continue;
}
- if (forward[0] < 0.999f) // quick way to check if any rotation is used
+ if (forward[0] != 1) // quick way to check if any rotation is used
{
VectorSubtract (check->v->origin, pusher->v->origin, org);
org2[0] = DotProduct (org, forward);
// try moving the contacted entity
pusher->v->solid = SOLID_NOT;
- trace = SV_PushEntity (check, move, moveangle);
+ SV_PushEntity (check, move, moveangle);
pusher->v->solid = savesolid; // was SOLID_BSP
// if it is still inside the pusher, block
- if (SV_TestEntityPosition (check))
+ if (SV_ClipMoveToEntity(pusher, check->v->origin, check->v->mins, check->v->maxs, check->v->origin).startsolid)
{
// try moving the contacted entity a tiny bit further to account for precision errors
pusher->v->solid = SOLID_NOT;
VectorScale(move, 0.1, move);
- trace = SV_PushEntity (check, move, vec3_origin);
+ SV_PushEntity (check, move, vec3_origin);
pusher->v->solid = savesolid;
- if (SV_TestEntityPosition (check))
+ if (SV_ClipMoveToEntity(pusher, check->v->origin, check->v->mins, check->v->maxs, check->v->origin).startsolid)
{
// still inside pusher, so it's really blocked
pr_global_struct->other = EDICT_TO_PROG(check);
PR_ExecuteProgram (pusher->v->blocked, "");
}
- return;
+ break;
}
}
}
+ pusher->v->angles[0] -= 360.0 * floor(pusher->v->angles[0] * (1.0 / 360.0));
+ pusher->v->angles[1] -= 360.0 * floor(pusher->v->angles[1] * (1.0 / 360.0));
+ pusher->v->angles[2] -= 360.0 * floor(pusher->v->angles[2] * (1.0 / 360.0));
}
/*
ent->v->waterlevel = 0;
ent->v->watertype = CONTENTS_EMPTY;
- cont = Mod_PointContents(point, sv.worldmodel);
+ cont = SV_PointQ1Contents(point);
if (cont <= CONTENTS_WATER)
{
ent->v->watertype = cont;
ent->v->waterlevel = 1;
point[2] = ent->v->origin[2] + (ent->v->mins[2] + ent->v->maxs[2])*0.5;
- cont = Mod_PointContents(point, sv.worldmodel);
+ cont = SV_PointQ1Contents(point);
if (cont <= CONTENTS_WATER)
{
ent->v->waterlevel = 2;
point[2] = ent->v->origin[2] + ent->v->view_ofs[2];
- cont = Mod_PointContents(point, sv.worldmodel);
+ cont = SV_PointQ1Contents(point);
if (cont <= CONTENTS_WATER)
ent->v->waterlevel = 3;
}
if (fabs(oldorg[1] - ent->v->origin[1]) > 4
|| fabs(oldorg[0] - ent->v->origin[0]) > 4)
+ {
+ Con_DPrintf("TryUnstick - success.\n");
return clip;
+ }
// go back to the original pos and try again
VectorCopy (oldorg, ent->v->origin);
// still not moving
VectorClear (ent->v->velocity);
+ Con_DPrintf("TryUnstick - failure.\n");
return 7;
}
*/
void SV_WalkMove (edict_t *ent)
{
- int clip, oldonground;
- vec3_t upmove, downmove, oldorg, oldvel, nosteporg, nostepvel, stepnormal;
+ int clip, oldonground, originalmove_clip, originalmove_flags, originalmove_groundentity;
+ vec3_t upmove, downmove, oldorg, oldvel, nosteporg, nostepvel, stepnormal, originalmove_origin, originalmove_velocity;
trace_t downtrace;
+ SV_CheckVelocity(ent);
+
// 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->velocity, oldvel);
clip = SV_FlyMove (ent, sv.frametime, NULL);
+ VectorCopy(ent->v->origin, originalmove_origin);
+ VectorCopy(ent->v->velocity, originalmove_velocity);
+ originalmove_clip = clip;
+ originalmove_flags = (int)ent->v->flags;
+ originalmove_groundentity = ent->v->groundentity;
+
+ SV_CheckVelocity(ent);
// if move didn't block on a step, return
if ( !(clip & 2) )
return;
+ // if move was not trying to move into the step, return
+ if (fabs(oldvel[0]) < 0.03125 && fabs(oldvel[1]) < 0.03125)
+ return;
+
if (ent->v->movetype != MOVETYPE_FLY)
{
if (!oldonground && ent->v->waterlevel == 0 && !sv_jumpstep.integer)
return;
}
- if (sv_nostep.integer)
- return;
+ SV_CheckVelocity(ent);
- if ( (int)ent->v->flags & FL_WATERJUMP )
+ if (sv_nostep.integer || (int)ent->v->flags & FL_WATERJUMP )
return;
VectorCopy (ent->v->origin, nosteporg);
// move up
// FIXME: don't link?
- SV_PushEntity (ent, upmove, vec3_origin);
+ SV_PushEntity(ent, upmove, vec3_origin);
// move forward
ent->v->velocity[0] = oldvel[0];
if (clip
&& fabs(oldorg[1] - ent->v->origin[1]) < 0.03125
&& fabs(oldorg[0] - ent->v->origin[0]) < 0.03125)
- // stepping up didn't make any progress
- clip = SV_TryUnstick (ent, oldvel);
+ {
+ // stepping up didn't make any progress, revert to original move
+ VectorCopy(originalmove_origin, ent->v->origin);
+ VectorCopy(originalmove_velocity, ent->v->velocity);
+ clip = originalmove_clip;
+ ent->v->flags = originalmove_flags;
+ ent->v->groundentity = originalmove_groundentity;
+ // now try to unstick if needed
+ //clip = SV_TryUnstick (ent, oldvel);
+ return;
+ }
// extra friction based on view angle
if (clip & 2 && sv_wallfriction.integer)
VectorCopy (nosteporg, ent->v->origin);
VectorCopy (nostepvel, ent->v->velocity);
}
+
+ SV_CheckVelocity(ent);
}
//============================================================================
SV_LinkEdict (ent, true);
}
-/*
-=============
-SV_Physics_Noclip
-
-A moving object that doesn't obey physics
-=============
-*/
-void SV_Physics_Noclip (edict_t *ent)
-{
- // 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);
-
- SV_LinkEdict (ent, false);
-}
-
/*
==============================================================================
void SV_CheckWaterTransition (edict_t *ent)
{
int cont;
- cont = Mod_PointContents(ent->v->origin, sv.worldmodel);
+ cont = SV_PointQ1Contents(ent->v->origin);
if (!ent->v->watertype)
{
// just spawned here
return;
}
+ // check if the entity crossed into or out of water
+ if ((ent->v->watertype == CONTENTS_WATER || ent->v->watertype == CONTENTS_SLIME) != (cont == CONTENTS_WATER || cont == CONTENTS_SLIME))
+ SV_StartSound (ent, 0, "misc/h2ohit1.wav", 255, 1);
+
if (cont <= CONTENTS_WATER)
{
- if (ent->v->watertype == CONTENTS_EMPTY && cont != CONTENTS_LAVA)
- // just crossed into water
- SV_StartSound (ent, 0, "misc/h2ohit1.wav", 255, 1);
-
ent->v->watertype = cont;
ent->v->waterlevel = 1;
}
else
{
- if (ent->v->watertype != CONTENTS_EMPTY && ent->v->watertype != CONTENTS_LAVA)
- // just crossed into water
- SV_StartSound (ent, 0, "misc/h2ohit1.wav", 255, 1);
-
ent->v->watertype = CONTENTS_EMPTY;
- ent->v->waterlevel = cont;
+ ent->v->waterlevel = 0;
}
}
SV_AddGravity(ent);
SV_CheckVelocity(ent);
SV_FlyMove(ent, sv.frametime, NULL);
- SV_LinkEdict(ent, false);
+ SV_LinkEdict(ent, true);
// just hit ground
if (hitsound && (int)ent->v->flags & FL_ONGROUND)
if (pr_global_struct->force_retouch)
SV_LinkEdict (ent, true); // force retouch even for stationary
- if (i > 0 && i <= svs.maxclients)
+ if (i <= svs.maxclients && i > 0)
{
- if (!svs.clients[i-1].active)
+ if (!svs.clients[i-1].spawned)
continue;
// connected slot
// call standard client pre-think
PR_ExecuteProgram (pr_global_struct->PlayerPreThink, "QC function PlayerPreThink is missing");
SV_CheckVelocity (ent);
}
+ else if (sv_freezenonclients.integer)
+ break;
// LordHavoc: merged client and normal entity physics
switch ((int) ent->v->movetype)
SV_Physics_Follow (ent);
break;
case MOVETYPE_NOCLIP:
- if (i > 0 && i <= svs.maxclients)
+ if (SV_RunThink(ent))
{
- if (SV_RunThink (ent))
- {
- SV_CheckWater (ent);
- VectorMA (ent->v->origin, sv.frametime, ent->v->velocity, ent->v->origin);
- VectorMA (ent->v->angles, sv.frametime, ent->v->avelocity, ent->v->angles);
- }
+ SV_CheckWater(ent);
+ VectorMA(ent->v->origin, sv.frametime, ent->v->velocity, ent->v->origin);
+ VectorMA(ent->v->angles, sv.frametime, ent->v->avelocity, ent->v->angles);
}
- else
- SV_Physics_Noclip (ent);
+ // relink normal entities here, players always get relinked so don't relink twice
+ if (!(i > 0 && i <= svs.maxclients))
+ SV_LinkEdict(ent, false);
break;
case MOVETYPE_STEP:
SV_Physics_Step (ent);
SV_AddGravity (ent);
SV_CheckStuck (ent);
SV_WalkMove (ent);
- SV_LinkEdict (ent, true);
+ // relink normal entities here, players always get relinked so don't relink twice
+ if (!(i > 0 && i <= svs.maxclients))
+ SV_LinkEdict (ent, true);
}
break;
case MOVETYPE_TOSS:
trace = SV_Move (tent->v->origin, tent->v->mins, tent->v->maxs, end, MOVE_NORMAL, tent);
VectorCopy (trace.endpos, tent->v->origin);
- if (trace.fraction < 1 && trace.ent)
- if (trace.ent != ignore)
- break;
+ if (trace.fraction < 1 && trace.ent && trace.ent != ignore)
+ break;
}
tossent->v->solid = savesolid;
trace.fraction = 0; // not relevant
projects / xonotic / darkplaces.git / blobdiff