int SV_GetPitchSign(prvm_prog_t *prog, prvm_edict_t *ent)
{
- dp_model_t *model;
+ model_t *model;
if (
(model = SV_GetModelFromEdict(ent))
?
// matrices to transform into/out of other entity's space
matrix4x4_t matrix, imatrix;
// model of other entity
- dp_model_t *model;
+ model_t *model;
// list of entities to test for collisions
int numtouchedicts;
static prvm_edict_t *touchedicts[MAX_EDICTS];
+ int clipgroup;
//return SV_TraceBox(start, vec3_origin, vec3_origin, end, type, passedict, hitsupercontentsmask, skipsupercontentsmask, skipmaterialflagsmask);
if (type == MOVE_MISSILE)
{
- // LordHavoc: modified this, was = -15, now -= 15
+ // LadyHavoc: modified this, was = -15, now -= 15
for (i = 0;i < 3;i++)
{
clipmins2[i] -= 15;
// debug override to test against everything
if (sv_debugmove.integer)
{
- clipboxmins[0] = clipboxmins[1] = clipboxmins[2] = -999999999;
- clipboxmaxs[0] = clipboxmaxs[1] = clipboxmaxs[2] = 999999999;
+ clipboxmins[0] = clipboxmins[1] = clipboxmins[2] = (vec_t)-999999999;
+ clipboxmaxs[0] = clipboxmaxs[1] = clipboxmaxs[2] = (vec_t)999999999;
}
// if the passedict is world, make it NULL (to avoid two checks each time)
// precalculate passedict's owner edict pointer for comparisons
traceowner = passedict ? PRVM_PROG_TO_EDICT(PRVM_serveredictedict(passedict, owner)) : 0;
+ clipgroup = passedict ? (int)PRVM_serveredictfloat(passedict, clipgroup) : 0;
+
// clip to entities
// because this uses World_EntitiestoBox, we know all entity boxes overlap
// the clip region, so we can skip culling checks in the loop below
// don't clip owner against owned entities
if (passedictprog == PRVM_serveredictedict(touch, owner))
continue;
+ // don't clip against any entities in the same clipgroup (DP_RM_CLIPGROUP)
+ if (clipgroup && clipgroup == (int)PRVM_serveredictfloat(touch, clipgroup))
+ continue;
// don't clip points against points (they can't collide)
if (VectorCompare(PRVM_serveredictvector(touch, mins), PRVM_serveredictvector(touch, maxs)) && (type != MOVE_MISSILE || !((int)PRVM_serveredictfloat(touch, flags) & FL_MONSTER)))
continue;
// matrices to transform into/out of other entity's space
matrix4x4_t matrix, imatrix;
// model of other entity
- dp_model_t *model;
+ model_t *model;
// list of entities to test for collisions
int numtouchedicts;
static prvm_edict_t *touchedicts[MAX_EDICTS];
+ int clipgroup;
if (VectorCompare(start, end))
return SV_TracePoint(start, type, passedict, hitsupercontentsmask, skipsupercontentsmask, skipmaterialflagsmask);
if (type == MOVE_MISSILE)
{
- // LordHavoc: modified this, was = -15, now -= 15
+ // LadyHavoc: modified this, was = -15, now -= 15
for (i = 0;i < 3;i++)
{
clipmins2[i] -= 15;
// debug override to test against everything
if (sv_debugmove.integer)
{
- clipboxmins[0] = clipboxmins[1] = clipboxmins[2] = -999999999;
- clipboxmaxs[0] = clipboxmaxs[1] = clipboxmaxs[2] = 999999999;
+ clipboxmins[0] = clipboxmins[1] = clipboxmins[2] = (vec_t)-999999999;
+ clipboxmaxs[0] = clipboxmaxs[1] = clipboxmaxs[2] = (vec_t)999999999;
}
// if the passedict is world, make it NULL (to avoid two checks each time)
// precalculate passedict's owner edict pointer for comparisons
traceowner = passedict ? PRVM_PROG_TO_EDICT(PRVM_serveredictedict(passedict, owner)) : 0;
+ clipgroup = passedict ? (int)PRVM_serveredictfloat(passedict, clipgroup) : 0;
+
// clip to entities
// because this uses World_EntitiestoBox, we know all entity boxes overlap
// the clip region, so we can skip culling checks in the loop below
// don't clip owner against owned entities
if (passedictprog == PRVM_serveredictedict(touch, owner))
continue;
+ // don't clip against any entities in the same clipgroup (DP_RM_CLIPGROUP)
+ if (clipgroup && clipgroup == (int)PRVM_serveredictfloat(touch, clipgroup))
+ continue;
// don't clip points against points (they can't collide)
if (VectorCompare(PRVM_serveredictvector(touch, mins), PRVM_serveredictvector(touch, maxs)) && (type != MOVE_MISSILE || !((int)PRVM_serveredictfloat(touch, flags) & FL_MONSTER)))
continue;
==================
*/
#if COLLISIONPARANOID >= 1
-trace_t SV_TraceBox_(const vec3_t start, const vec3_t mins, const vec3_t maxs, const vec3_t end, int type, prvm_edict_t *passedict, int hitsupercontentsmask, int skipsupercontentsmask, int skipmaterialflagsmask, float extend)
+static trace_t SV_TraceBox_(const vec3_t start, const vec3_t mins, const vec3_t maxs, const vec3_t end, int type, prvm_edict_t *passedict, int hitsupercontentsmask, int skipsupercontentsmask, int skipmaterialflagsmask, float extend)
#else
trace_t SV_TraceBox(const vec3_t start, const vec3_t mins, const vec3_t maxs, const vec3_t end, int type, prvm_edict_t *passedict, int hitsupercontentsmask, int skipsupercontentsmask, int skipmaterialflagsmask, float extend)
#endif
int i, bodysupercontents;
int passedictprog;
float pitchsign = 1;
- qboolean pointtrace;
+ qbool pointtrace;
prvm_edict_t *traceowner, *touch;
trace_t trace;
// temporary storage because prvm_vec_t may differ from vec_t
// matrices to transform into/out of other entity's space
matrix4x4_t matrix, imatrix;
// model of other entity
- dp_model_t *model;
+ model_t *model;
// list of entities to test for collisions
int numtouchedicts;
static prvm_edict_t *touchedicts[MAX_EDICTS];
+ int clipgroup;
if (VectorCompare(mins, maxs))
{
vec3_t shiftstart, shiftend;
if (type == MOVE_MISSILE)
{
- // LordHavoc: modified this, was = -15, now -= 15
+ // LadyHavoc: modified this, was = -15, now -= 15
for (i = 0;i < 3;i++)
{
clipmins2[i] -= 15;
// debug override to test against everything
if (sv_debugmove.integer)
{
- clipboxmins[0] = clipboxmins[1] = clipboxmins[2] = -999999999;
- clipboxmaxs[0] = clipboxmaxs[1] = clipboxmaxs[2] = 999999999;
+ clipboxmins[0] = clipboxmins[1] = clipboxmins[2] = (vec_t)-999999999;
+ clipboxmaxs[0] = clipboxmaxs[1] = clipboxmaxs[2] = (vec_t)999999999;
}
// if the passedict is world, make it NULL (to avoid two checks each time)
// precalculate passedict's owner edict pointer for comparisons
traceowner = passedict ? PRVM_PROG_TO_EDICT(PRVM_serveredictedict(passedict, owner)) : 0;
+ clipgroup = passedict ? (int)PRVM_serveredictfloat(passedict, clipgroup) : 0;
+
// clip to entities
// because this uses World_EntitiestoBox, we know all entity boxes overlap
// the clip region, so we can skip culling checks in the loop below
// don't clip owner against owned entities
if (passedictprog == PRVM_serveredictedict(touch, owner))
continue;
+ // don't clip against any entities in the same clipgroup (DP_RM_CLIPGROUP)
+ if (clipgroup && clipgroup == (int)PRVM_serveredictfloat(touch, clipgroup))
+ continue;
// don't clip points against points (they can't collide)
if (pointtrace && VectorCompare(PRVM_serveredictvector(touch, mins), PRVM_serveredictvector(touch, maxs)) && (type != MOVE_MISSILE || !((int)PRVM_serveredictfloat(touch, flags) & FL_MONSTER)))
continue;
}
#if COLLISIONPARANOID >= 1
-trace_t SV_TraceBox(const vec3_t start, const vec3_t mins, const vec3_t maxs, const vec3_t end, int type, prvm_edict_t *passedict, int hitsupercontentsmask, int skipsupercontentsmask, int skipmaterialflagsmask)
+trace_t SV_TraceBox(const vec3_t start, const vec3_t mins, const vec3_t maxs, const vec3_t end, int type, prvm_edict_t *passedict, int hitsupercontentsmask, int skipsupercontentsmask, int skipmaterialflagsmask, float extend)
{
prvm_prog_t *prog = SVVM_prog;
int endstuck;
trace_t trace;
vec3_t temp;
- trace = SV_TraceBox_(start, mins, maxs, end, type, passedict, hitsupercontentsmask, skipsupercontentsmask, skipmaterialflagsmask);
+ trace = SV_TraceBox_(start, mins, maxs, end, type, passedict, hitsupercontentsmask, skipsupercontentsmask, skipmaterialflagsmask, extend);
if (passedict)
{
VectorCopy(trace.endpos, temp);
- endstuck = SV_TraceBox_(temp, mins, maxs, temp, type, passedict, hitsupercontentsmask, skipsupercontentsmask, skipmaterialflagsmask).startsolid;
+ endstuck = SV_TraceBox_(temp, mins, maxs, temp, type, passedict, hitsupercontentsmask, skipsupercontentsmask, skipmaterialflagsmask, extend).startsolid;
#if COLLISIONPARANOID < 3
if (trace.startsolid || endstuck)
#endif
// matrices to transform into/out of other entity's space
matrix4x4_t matrix, imatrix;
// model of other entity
- dp_model_t *model;
+ model_t *model;
int frame;
// list of entities to test for collisions
int numtouchedicts;
vec3_t paddedmins, paddedmaxs;
if (maxedicts < 1 || resultedicts == NULL)
return 0;
- // LordHavoc: discovered this actually causes its own bugs (dm6 teleporters being too close to info_teleport_destination)
+ // LadyHavoc: discovered this actually causes its own bugs (dm6 teleporters being too close to info_teleport_destination)
//VectorSet(paddedmins, mins[0] - 10, mins[1] - 10, mins[2] - 1);
//VectorSet(paddedmaxs, maxs[0] + 10, maxs[1] + 10, maxs[2] + 1);
VectorCopy(mins, paddedmins);
for (edictindex = 1;edictindex < prog->num_edicts;edictindex++)
{
ed = PRVM_EDICT_NUM(edictindex);
- if (!ed->priv.required->free && BoxesOverlap(PRVM_serveredictvector(ed, absmin), PRVM_serveredictvector(ed, absmax), paddedmins, paddedmaxs))
+ if (!ed->free && BoxesOverlap(PRVM_serveredictvector(ed, absmin), PRVM_serveredictvector(ed, absmax), paddedmins, paddedmaxs))
{
resultedicts[numresultedicts++] = ed;
if (numresultedicts == maxedicts)
if (ent == prog->edicts)
return; // don't add the world
- if (ent->priv.server->free)
+ if (ent->free)
return;
if (PRVM_serveredictfloat(ent, solid) == SOLID_NOT)
void SV_LinkEdict (prvm_edict_t *ent)
{
prvm_prog_t *prog = SVVM_prog;
- dp_model_t *model;
+ model_t *model;
vec3_t mins, maxs, entmins, entmaxs, entangles;
int modelindex;
if (ent == prog->edicts)
return; // don't add the world
- if (ent->priv.server->free)
+ if (ent->free)
return;
modelindex = (int)PRVM_serveredictfloat(ent, modelindex);
VectorAdd(PRVM_serveredictvector(ent, origin), PRVM_serveredictvector(ent, maxs), maxs);
}
-//
-// to make items easier to pick up and allow them to be grabbed off
-// of shelves, the abs sizes are expanded
-//
- if ((int)PRVM_serveredictfloat(ent, flags) & FL_ITEM)
+ if (sv_legacy_bbox_expand.integer)
{
- mins[0] -= 15;
- mins[1] -= 15;
- mins[2] -= 1;
- maxs[0] += 15;
- maxs[1] += 15;
- maxs[2] += 1;
- }
- else
- {
- // because movement is clipped an epsilon away from an actual edge,
- // we must fully check even when bounding boxes don't quite touch
- mins[0] -= 1;
- mins[1] -= 1;
- mins[2] -= 1;
- maxs[0] += 1;
- maxs[1] += 1;
- maxs[2] += 1;
+ if ((int)PRVM_serveredictfloat(ent, flags) & FL_ITEM)
+ {
+ // to make items easier to pick up and allow them to be grabbed off
+ // of shelves, the abs sizes are expanded
+ mins[0] -= 15;
+ mins[1] -= 15;
+ mins[2] -= 1;
+ maxs[0] += 15;
+ maxs[1] += 15;
+ maxs[2] += 1;
+ }
+ else
+ {
+ // because movement is clipped an epsilon away from an actual edge,
+ // we must fully check even when bounding boxes don't quite touch
+ mins[0] -= 1;
+ mins[1] -= 1;
+ mins[2] -= 1;
+ maxs[0] += 1;
+ maxs[1] += 1;
+ maxs[2] += 1;
+ }
}
VectorCopy(mins, PRVM_serveredictvector(ent, absmin));
VectorCopy(maxs, PRVM_serveredictvector(ent, absmax));
- World_LinkEdict(&sv.world, ent, mins, maxs);
+ World_LinkEdict(&sv.world, ent, mins, maxs, sv_areagrid_link_SOLID_NOT.integer);
}
/*
//
for (i=0 ; i<3 ; i++)
{
- if (PRVM_IS_NAN(PRVM_serveredictvector(ent, velocity)[i]))
+ if (isnan(PRVM_serveredictvector(ent, velocity)[i]))
{
Con_Printf("Got a NaN velocity on entity #%i (%s)\n", PRVM_NUM_FOR_EDICT(ent), PRVM_GetString(prog, PRVM_serveredictstring(ent, classname)));
PRVM_serveredictvector(ent, velocity)[i] = 0;
}
- if (PRVM_IS_NAN(PRVM_serveredictvector(ent, origin)[i]))
+ if (isnan(PRVM_serveredictvector(ent, origin)[i]))
{
Con_Printf("Got a NaN origin on entity #%i (%s)\n", PRVM_NUM_FOR_EDICT(ent), PRVM_GetString(prog, PRVM_serveredictstring(ent, classname)));
PRVM_serveredictvector(ent, origin)[i] = 0;
}
}
- // LordHavoc: a hack to ensure that the (rather silly) id1 quakec
+ // LadyHavoc: a hack to ensure that the (rather silly) id1 quakec
// player_run/player_stand1 does not horribly malfunction if the
// velocity becomes a denormalized float
if (VectorLength2(PRVM_serveredictvector(ent, velocity)) < 0.0000001)
VectorClear(PRVM_serveredictvector(ent, velocity));
- // LordHavoc: max velocity fix, inspired by Maddes's source fixes, but this is faster
+ // LadyHavoc: max velocity fix, inspired by Maddes's source fixes, but this is faster
wishspeed = DotProduct(PRVM_serveredictvector(ent, velocity), PRVM_serveredictvector(ent, velocity));
if (wishspeed > sv_maxvelocity.value * sv_maxvelocity.value)
{
Returns false if the entity removed itself.
=============
*/
-static qboolean SV_RunThink (prvm_edict_t *ent)
+static qbool SV_RunThink (prvm_edict_t *ent)
{
prvm_prog_t *prog = SVVM_prog;
int iterations;
if (PRVM_serveredictfloat(ent, nextthink) <= 0 || PRVM_serveredictfloat(ent, nextthink) > sv.time + sv.frametime)
return true;
- for (iterations = 0;iterations < 128 && !ent->priv.server->free;iterations++)
+ for (iterations = 0;iterations < 128 && !ent->free;iterations++)
{
PRVM_serverglobalfloat(time) = max(sv.time, PRVM_serveredictfloat(ent, nextthink));
PRVM_serveredictfloat(ent, nextthink) = 0;
if (PRVM_serveredictfloat(ent, nextthink) <= PRVM_serverglobalfloat(time) || PRVM_serveredictfloat(ent, nextthink) > sv.time + sv.frametime || !sv_gameplayfix_multiplethinksperframe.integer)
break;
}
- return !ent->priv.server->free;
+ return !ent->free;
}
/*
VM_SetTraceGlobals(prog, trace);
- if (!e1->priv.server->free && !e2->priv.server->free && PRVM_serveredictfunction(e1, touch) && PRVM_serveredictfloat(e1, solid) != SOLID_NOT)
+ if (!e1->free && !e2->free && PRVM_serveredictfunction(e1, touch) && PRVM_serveredictfloat(e1, solid) != SOLID_NOT)
{
PRVM_serverglobalfloat(time) = sv.time;
PRVM_serverglobaledict(self) = PRVM_EDICT_TO_PROG(e1);
prog->ExecuteProgram(prog, PRVM_serveredictfunction(e1, touch), "QC function self.touch is missing");
}
- if (!e1->priv.server->free && !e2->priv.server->free && PRVM_serveredictfunction(e2, touch) && PRVM_serveredictfloat(e2, solid) != SOLID_NOT)
+ if (!e1->free && !e2->free && PRVM_serveredictfunction(e2, touch) && PRVM_serveredictfloat(e2, solid) != SOLID_NOT)
{
PRVM_serverglobalfloat(time) = sv.time;
PRVM_serverglobaledict(self) = PRVM_EDICT_TO_PROG(e2);
============
*/
static float SV_Gravity (prvm_edict_t *ent);
-static qboolean SV_PushEntity (trace_t *trace, prvm_edict_t *ent, vec3_t push, qboolean dolink);
+static qbool SV_PushEntity (trace_t *trace, prvm_edict_t *ent, vec3_t push, qbool dolink, qbool checkstuck);
#define MAX_CLIP_PLANES 5
-static int SV_FlyMove (prvm_edict_t *ent, float time, qboolean applygravity, float *stepnormal, int hitsupercontentsmask, int skipsupercontentsmask, int skipmaterialflagsmask, float stepheight)
+static int SV_FlyMove (prvm_edict_t *ent, float time, qbool applygravity, float *stepnormal, int hitsupercontentsmask, int skipsupercontentsmask, int skipmaterialflagsmask, float stepheight)
{
prvm_prog_t *prog = SVVM_prog;
- int blocked, bumpcount;
- int i, j, numplanes;
+ unsigned int i, j, numplanes, blocked, bumpcount;
float d, time_left, gravity;
vec3_t dir, push, planes[MAX_CLIP_PLANES];
prvm_vec3_t primal_velocity, original_velocity, new_velocity, restore_velocity;
break;
VectorScale(PRVM_serveredictvector(ent, velocity), time_left, push);
- if(!SV_PushEntity(&trace, ent, push, false))
+ if(!SV_PushEntity(&trace, ent, push, false, true))
{
// we got teleported by a touch function
// let's abort the move
if (trace.fraction == 1)
break;
+
+ time_left *= 1 - trace.fraction;
+
if (trace.plane.normal[2])
{
if (trace.plane.normal[2] > 0.7)
trace_t steptrace3;
//Con_Printf("step %f %f %f : ", PRVM_serveredictvector(ent, origin)[0], PRVM_serveredictvector(ent, origin)[1], PRVM_serveredictvector(ent, origin)[2]);
VectorSet(steppush, 0, 0, stepheight);
+ VectorScale(PRVM_serveredictvector(ent, velocity), time_left, push);
VectorCopy(PRVM_serveredictvector(ent, origin), org);
- if(!SV_PushEntity(&steptrace, ent, steppush, false))
+ if(!SV_PushEntity(&steptrace, ent, steppush, false, true))
{
blocked |= 8;
break;
}
//Con_Printf("%f %f %f : ", PRVM_serveredictvector(ent, origin)[0], PRVM_serveredictvector(ent, origin)[1], PRVM_serveredictvector(ent, origin)[2]);
- if(!SV_PushEntity(&steptrace2, ent, push, false))
+ if(!SV_PushEntity(&steptrace2, ent, push, false, true))
{
blocked |= 8;
break;
}
//Con_Printf("%f %f %f : ", PRVM_serveredictvector(ent, origin)[0], PRVM_serveredictvector(ent, origin)[1], PRVM_serveredictvector(ent, origin)[2]);
VectorSet(steppush, 0, 0, org[2] - PRVM_serveredictvector(ent, origin)[2]);
- if(!SV_PushEntity(&steptrace3, ent, steppush, false))
+ if(!SV_PushEntity(&steptrace3, ent, steppush, false, true))
{
blocked |= 8;
break;
}
//Con_Printf("%f %f %f : ", PRVM_serveredictvector(ent, origin)[0], PRVM_serveredictvector(ent, origin)[1], PRVM_serveredictvector(ent, origin)[2]);
// accept the new position if it made some progress...
- if (fabs(PRVM_serveredictvector(ent, origin)[0] - org[0]) >= 0.03125 || fabs(PRVM_serveredictvector(ent, origin)[1] - org[1]) >= 0.03125)
+ // previously this checked if absolute distance >= 0.03125 which made stepping up unreliable
+ if (PRVM_serveredictvector(ent, origin)[0] - org[0] || PRVM_serveredictvector(ent, origin)[1] - org[1])
{
//Con_Printf("accepted (delta %f %f %f)\n", PRVM_serveredictvector(ent, origin)[0] - org[0], PRVM_serveredictvector(ent, origin)[1] - org[1], PRVM_serveredictvector(ent, origin)[2] - org[2]);
trace = steptrace2;
if (stepnormal)
VectorCopy(trace.plane.normal, stepnormal);
}
+
+ // Unlike some other movetypes Quake's SV_FlyMove calls SV_Impact only after setting ONGROUND which id1 fiends rely on.
+ // If we stepped up (sv_gameplayfix_stepmultipletimes) this will impact the steptrace2 plane instead of the original.
+ if (PRVM_serveredictfloat(ent, solid) >= SOLID_TRIGGER && trace.ent)
+ SV_Impact(ent, &trace);
+ if (ent->free)
+ return blocked; // removed by the impact function
+
if (trace.fraction >= 0.001)
{
// actually covered some distance
numplanes = 0;
}
- time_left *= 1 - trace.fraction;
-
// clipped to another plane
if (numplanes >= MAX_CLIP_PLANES)
{
break;
}
CrossProduct(planes[0], planes[1], dir);
- // LordHavoc: thanks to taniwha of QuakeForge for pointing out this fix for slowed falling in corners
+ // LadyHavoc: thanks to taniwha of QuakeForge for pointing out this fix for slowed falling in corners
VectorNormalize(dir);
d = DotProduct(dir, PRVM_serveredictvector(ent, velocity));
VectorScale(dir, d, PRVM_serveredictvector(ent, velocity));
/*
if ((blocked & 1) == 0 && bumpcount > 1)
{
- // LordHavoc: fix the 'fall to your death in a wedge corner' glitch
+ // LadyHavoc: fix the 'fall to your death in a wedge corner' glitch
// flag ONGROUND if there's ground under it
trace = SV_TraceBox(PRVM_serveredictvector(ent, origin), PRVM_serveredictvector(ent, mins), PRVM_serveredictvector(ent, maxs), end, MOVE_NORMAL, ent, hitsupercontentsmask, skipsupercontentsmask, skipmaterialflagsmask);
}
*/
- // LordHavoc: this came from QW and allows you to get out of water more easily
+ // LadyHavoc: this came from QW and allows you to get out of water more easily
if (sv_gameplayfix_easierwaterjump.integer && ((int)PRVM_serveredictfloat(ent, flags) & FL_WATERJUMP) && !(blocked & 8))
VectorCopy(primal_velocity, PRVM_serveredictvector(ent, velocity));
===============================================================================
*/
-static qboolean SV_NudgeOutOfSolid_PivotIsKnownGood(prvm_edict_t *ent, vec3_t pivot)
+static qbool SV_NudgeOutOfSolid_PivotIsKnownGood(prvm_edict_t *ent, vec3_t pivot)
{
prvm_prog_t *prog = SVVM_prog;
int bump;
return true;
}
-qboolean SV_NudgeOutOfSolid(prvm_edict_t *ent)
-{
- prvm_prog_t *prog = SVVM_prog;
- int bump, pass;
- trace_t stucktrace;
- vec3_t stuckorigin;
- vec3_t stuckmins, stuckmaxs;
- vec_t nudge;
- vec_t separation = sv_gameplayfix_nudgeoutofsolid_separation.value;
- if (sv.worldmodel && sv.worldmodel->brushq1.numclipnodes)
- separation = 0.0f; // when using hulls, it can not be enlarged
- VectorCopy(PRVM_serveredictvector(ent, mins), stuckmins);
- VectorCopy(PRVM_serveredictvector(ent, maxs), stuckmaxs);
- stuckmins[0] -= separation;
- stuckmins[1] -= separation;
- stuckmins[2] -= separation;
- stuckmaxs[0] += separation;
- stuckmaxs[1] += separation;
- stuckmaxs[2] += separation;
- // first pass we try to get it out of brush entities
- // second pass we try to get it out of world only (can't win them all)
- for (pass = 0;pass < 2;pass++)
- {
- VectorCopy(PRVM_serveredictvector(ent, origin), stuckorigin);
- for (bump = 0;bump < 10;bump++)
- {
- stucktrace = SV_TraceBox(stuckorigin, stuckmins, stuckmaxs, stuckorigin, pass ? MOVE_WORLDONLY : MOVE_NOMONSTERS, ent, SV_GenericHitSuperContentsMask(ent), 0, 0, collision_extendmovelength.value);
- if (!stucktrace.bmodelstartsolid || stucktrace.startdepth >= 0)
- {
- // found a good location, use it
- VectorCopy(stuckorigin, PRVM_serveredictvector(ent, origin));
- return true;
- }
- nudge = -stucktrace.startdepth;
- VectorMA(stuckorigin, nudge, stucktrace.startdepthnormal, stuckorigin);
- }
- }
- return false;
-}
-
/*
============
SV_PushEntity
Returns true if the push did not result in the entity being teleported by QC code.
============
*/
-static qboolean SV_PushEntity (trace_t *trace, prvm_edict_t *ent, vec3_t push, qboolean dolink)
+static qbool SV_PushEntity (trace_t *trace, prvm_edict_t *ent, vec3_t push, qbool dolink, qbool checkstuck)
{
prvm_prog_t *prog = SVVM_prog;
int solid;
VectorCopy(PRVM_serveredictvector(ent, mins), mins);
VectorCopy(PRVM_serveredictvector(ent, maxs), maxs);
- // move start position out of solids
- if (sv_gameplayfix_nudgeoutofsolid.integer && sv_gameplayfix_nudgeoutofsolid_separation.value >= 0)
- {
- SV_NudgeOutOfSolid(ent);
- }
-
VectorCopy(PRVM_serveredictvector(ent, origin), start);
VectorAdd(start, push, end);
type = MOVE_NORMAL;
*trace = SV_TraceBox(start, mins, maxs, end, type, ent, SV_GenericHitSuperContentsMask(ent), 0, 0, collision_extendmovelength.value);
- // fail the move if stuck in world
- if (trace->worldstartsolid)
- return true;
+ if (trace->allsolid && checkstuck)
+ {
+ if (SV_UnstickEntity(ent))
+ {
+ VectorCopy(PRVM_serveredictvector(ent, origin), start);
+ VectorAdd(start, push, end);
+ *trace = SV_TraceBox(start, mins, maxs, end, type, ent, SV_GenericHitSuperContentsMask(ent), 0, 0, collision_extendmovelength.value);
+ }
+ // abort move if we're stuck in the world (and didn't make it out)
+ else if (trace->worldstartsolid)
+ return true;
+ }
VectorCopy(trace->endpos, PRVM_serveredictvector(ent, origin));
+ VectorCopy(trace->endpos, PRVM_serveredictvector(ent, oldorigin)); // for SV_UnstickEntity()
ent->priv.required->mark = PRVM_EDICT_MARK_WAIT_FOR_SETORIGIN; // -2: setorigin running
#endif
if (dolink)
+ {
SV_LinkEdict_TouchAreaGrid(ent);
- if((PRVM_serveredictfloat(ent, solid) >= SOLID_TRIGGER && trace->ent && (!((int)PRVM_serveredictfloat(ent, flags) & FL_ONGROUND) || PRVM_serveredictedict(ent, groundentity) != PRVM_EDICT_TO_PROG(trace->ent))))
- SV_Impact (ent, trace);
+ if((PRVM_serveredictfloat(ent, solid) >= SOLID_TRIGGER && trace->ent && (!((int)PRVM_serveredictfloat(ent, flags) & FL_ONGROUND) || PRVM_serveredictedict(ent, groundentity) != PRVM_EDICT_TO_PROG(trace->ent))))
+ SV_Impact (ent, trace);
+ }
if(ent->priv.required->mark == PRVM_EDICT_MARK_SETORIGIN_CAUGHT)
{
int i, e, index;
int pusherowner, pusherprog;
int checkcontents;
- qboolean rotated;
+ qbool rotated;
float savesolid, movetime2, pushltime;
vec3_t mins, maxs, move, move1, moveangle, pushorig, pushang, a, forward, left, up, org, pushermins, pushermaxs, checkorigin, checkmins, checkmaxs;
int num_moved;
int numcheckentities;
static prvm_edict_t *checkentities[MAX_EDICTS];
- dp_model_t *pushermodel;
+ model_t *pushermodel;
trace_t trace, trace2;
matrix4x4_t pusherfinalmatrix, pusherfinalimatrix;
static unsigned short moved_edicts[MAX_EDICTS];
switch ((int) PRVM_serveredictfloat(pusher, solid))
{
- // LordHavoc: valid pusher types
+ // LadyHavoc: valid pusher types
case SOLID_BSP:
case SOLID_BBOX:
case SOLID_SLIDEBOX:
- case SOLID_CORPSE: // LordHavoc: this would be weird...
+ case SOLID_CORPSE: // LadyHavoc: this would be weird...
break;
- // LordHavoc: no collisions
+ // LadyHavoc: no collisions
case SOLID_NOT:
case SOLID_TRIGGER:
VectorMA (PRVM_serveredictvector(pusher, origin), movetime, PRVM_serveredictvector(pusher, velocity), PRVM_serveredictvector(pusher, origin));
// try moving the contacted entity
PRVM_serveredictfloat(pusher, solid) = SOLID_NOT;
- if(!SV_PushEntity (&trace, check, move, true))
+ if(!SV_PushEntity(&trace, check, move, true, true))
{
// entity "check" got teleported
PRVM_serveredictvector(check, angles)[1] += trace.fraction * moveangle[1];
{
// hack to invoke all necessary movement triggers
VectorClear(move2);
- if(!SV_PushEntity(&trace2, check, move2, true))
+ if(!SV_PushEntity(&trace2, check, move2, true, true))
{
// entity "check" got teleported
continue;
static void SV_Physics_Pusher (prvm_edict_t *ent)
{
prvm_prog_t *prog = SVVM_prog;
- float thinktime, oldltime, movetime;
+ prvm_vec_t thinktime, oldltime, movetime;
oldltime = PRVM_serveredictfloat(ent, ltime);
typedef enum unstickresult_e
{
+ // matching the DP_QC_NUDGEOUTOFSOLID return values
UNSTICK_STUCK = 0,
- UNSTICK_GOOD = 1,
- UNSTICK_UNSTUCK = 2
+ UNSTICK_GOOD = -1, ///< didn't need to be unstuck
+ UNSTICK_UNSTUCK = 1
}
unstickresult_t;
if (!SV_TestEntityPosition(ent, unstickoffsets + i))
{
VectorCopy(unstickoffsets + i, offset);
- SV_LinkEdict(ent);
- //SV_LinkEdict_TouchAreaGrid(ent);
return UNSTICK_UNSTUCK;
}
}
VectorClear(offset);
offset[2] = -i;
if (!SV_TestEntityPosition(ent, offset))
- {
- SV_LinkEdict(ent);
- //SV_LinkEdict_TouchAreaGrid(ent);
return UNSTICK_UNSTUCK;
- }
offset[2] = i;
if (!SV_TestEntityPosition(ent, offset))
- {
- SV_LinkEdict(ent);
- //SV_LinkEdict_TouchAreaGrid(ent);
return UNSTICK_UNSTUCK;
- }
}
return UNSTICK_STUCK;
}
-qboolean SV_UnstickEntity (prvm_edict_t *ent)
-{
- prvm_prog_t *prog = SVVM_prog;
- vec3_t offset;
- switch(SV_UnstickEntityReturnOffset(ent, offset))
- {
- case UNSTICK_GOOD:
- return true;
- case UNSTICK_UNSTUCK:
- Con_DPrintf("Unstuck entity %i (classname \"%s\") with offset %f %f %f.\n", (int)PRVM_EDICT_TO_PROG(ent), PRVM_GetString(prog, PRVM_serveredictstring(ent, classname)), offset[0], offset[1], offset[2]);
- return true;
- case UNSTICK_STUCK:
- if (developer_extra.integer)
- Con_DPrintf("Stuck entity %i (classname \"%s\").\n", (int)PRVM_EDICT_TO_PROG(ent), PRVM_GetString(prog, PRVM_serveredictstring(ent, classname)));
- return false;
- default:
- Con_Printf("SV_UnstickEntityReturnOffset returned a value outside its enum.\n");
- return false;
- }
-}
-
/*
=============
SV_CheckStuck
clipping hull.
=============
*/
-static void SV_CheckStuck (prvm_edict_t *ent)
+qbool SV_UnstickEntity (prvm_edict_t *ent)
{
prvm_prog_t *prog = SVVM_prog;
vec3_t offset;
+ if (sv_gameplayfix_nudgeoutofsolid.integer && sv_gameplayfix_nudgeoutofsolid_separation.value >= 0
+ && sv.worldmodel->TraceBox == Mod_CollisionBIH_TraceBox) // Mod_Q1BSP_TraceBox doesn't support startdepth
+ {
+ VectorCopy(PRVM_serveredictvector(ent, origin), offset);
+ switch (PHYS_NudgeOutOfSolid(prog, ent))
+ {
+ case UNSTICK_GOOD:
+ return true;
+ case UNSTICK_UNSTUCK:
+ VectorSubtract(PRVM_serveredictvector(ent, origin), offset, offset);
+ Con_DPrintf("NudgeOutOfSolid fixed stuck entity %i (classname \"%s\") with offset %f %f %f.\n", (int)PRVM_EDICT_TO_PROG(ent), PRVM_GetString(prog, PRVM_serveredictstring(ent, classname)), offset[0], offset[1], offset[2]);
+ return true;
+ case UNSTICK_STUCK:
+ Con_DPrintf(CON_WARN "NudgeOutOfSolid couldn't fix stuck entity %i (classname \"%s\").\n", (int)PRVM_EDICT_TO_PROG(ent), PRVM_GetString(prog, PRVM_serveredictstring(ent, classname)));
+ return false;
+ default:
+ Con_Printf("NudgeOutOfSolid returned a value outside its enum.\n");
+ return false;
+ }
+ }
+
+ if (!(PRVM_NUM_FOR_EDICT(ent) <= svs.maxclients ? sv_gameplayfix_unstickplayers : sv_gameplayfix_unstickentities).integer)
+ return false;
+
switch(SV_UnstickEntityReturnOffset(ent, offset))
{
case UNSTICK_GOOD:
- VectorCopy (PRVM_serveredictvector(ent, origin), PRVM_serveredictvector(ent, oldorigin));
- break;
+ return true;
case UNSTICK_UNSTUCK:
- Con_DPrintf("Unstuck player entity %i (classname \"%s\") with offset %f %f %f.\n", (int)PRVM_EDICT_TO_PROG(ent), PRVM_GetString(prog, PRVM_serveredictstring(ent, classname)), offset[0], offset[1], offset[2]);
- break;
+ Con_DPrintf("Unstuck entity %i (classname \"%s\") with offset %f %f %f.\n", (int)PRVM_EDICT_TO_PROG(ent), PRVM_GetString(prog, PRVM_serveredictstring(ent, classname)), offset[0], offset[1], offset[2]);
+ return true;
case UNSTICK_STUCK:
VectorSubtract(PRVM_serveredictvector(ent, oldorigin), PRVM_serveredictvector(ent, origin), offset);
if (!SV_TestEntityPosition(ent, offset))
{
- Con_DPrintf("Unstuck player entity %i (classname \"%s\") by restoring oldorigin.\n", (int)PRVM_EDICT_TO_PROG(ent), PRVM_GetString(prog, PRVM_serveredictstring(ent, classname)));
- SV_LinkEdict(ent);
- //SV_LinkEdict_TouchAreaGrid(ent);
+ Con_DPrintf("Unstuck entity %i (classname \"%s\") by restoring oldorigin.\n", (int)PRVM_EDICT_TO_PROG(ent), PRVM_GetString(prog, PRVM_serveredictstring(ent, classname)));
+ return true;
}
- else
- Con_DPrintf("Stuck player entity %i (classname \"%s\").\n", (int)PRVM_EDICT_TO_PROG(ent), PRVM_GetString(prog, PRVM_serveredictstring(ent, classname)));
- break;
+ Con_DPrintf(CON_WARN "Stuck entity %i (classname \"%s\").\n", (int)PRVM_EDICT_TO_PROG(ent), PRVM_GetString(prog, PRVM_serveredictstring(ent, classname)));
+ return false;
default:
Con_Printf("SV_UnstickEntityReturnOffset returned a value outside its enum.\n");
+ return false;
}
}
SV_CheckWater
=============
*/
-static qboolean SV_CheckWater (prvm_edict_t *ent)
+static qbool SV_CheckWater (prvm_edict_t *ent)
{
prvm_prog_t *prog = SVVM_prog;
int cont;
int type;
vec3_t upmove, downmove, start_origin, start_velocity, stepnormal, originalmove_origin, originalmove_velocity, entmins, entmaxs;
trace_t downtrace, trace;
- qboolean applygravity;
+ qbool applygravity;
// if frametime is 0 (due to client sending the same timestamp twice),
// don't move
if (sv.frametime <= 0)
return;
- if (sv_gameplayfix_unstickplayers.integer)
- SV_CheckStuck (ent);
-
applygravity = !SV_CheckWater (ent) && PRVM_serveredictfloat(ent, movetype) == MOVETYPE_WALK && ! ((int)PRVM_serveredictfloat(ent, flags) & FL_WATERJUMP);
SV_CheckVelocity(ent);
VectorCopy(PRVM_serveredictvector(ent, maxs), entmaxs);
trace = SV_TraceBox(upmove, entmins, entmaxs, downmove, type, ent, SV_GenericHitSuperContentsMask(ent), skipsupercontentsmask, skipmaterialflagsmask, collision_extendmovelength.value);
if(trace.fraction < 1 && trace.plane.normal[2] > 0.7)
+ {
clip |= 1; // but we HAVE found a floor
+ // set groundentity so we get carried when walking onto a mover with sv_gameplayfix_nogravityonground
+ PRVM_serveredictedict(ent, groundentity) = PRVM_EDICT_TO_PROG(trace.ent);
+ }
}
// if the move did not hit the ground at any point, we're not on ground
// move up
VectorClear (upmove);
upmove[2] = sv_stepheight.value;
- if(!SV_PushEntity(&trace, ent, upmove, true))
+ if(!SV_PushEntity(&trace, ent, upmove, true, true))
{
// we got teleported when upstepping... must abort the move
return;
// move down
VectorClear (downmove);
downmove[2] = -sv_stepheight.value + start_velocity[2]*sv.frametime;
- if(!SV_PushEntity (&downtrace, ent, downmove, true))
+ if(!SV_PushEntity(&downtrace, ent, downmove, true, true))
{
// we got teleported when downstepping... must abort the move
return;
// this has been disabled so that you can't jump when you are stepping
// up while already jumping (also known as the Quake2 double jump bug)
#if 0
- // LordHavoc: disabled this check so you can walk on monsters/players
+ // LadyHavoc: disabled this check so you can walk on monsters/players
//if (PRVM_serveredictfloat(ent, solid) == SOLID_BSP)
{
//Con_Printf("onground\n");
vec3_t vf, vr, vu, angles, v;
prvm_edict_t *e;
- // LordHavoc: implemented rotation on MOVETYPE_FOLLOW objects
+ // LadyHavoc: implemented rotation on MOVETYPE_FOLLOW objects
e = PRVM_PROG_TO_EDICT(PRVM_serveredictedict(ent, aiment));
if (PRVM_serveredictvector(e, angles)[0] == PRVM_serveredictvector(ent, punchangle)[0] && PRVM_serveredictvector(e, angles)[1] == PRVM_serveredictvector(ent, punchangle)[1] && PRVM_serveredictvector(e, angles)[2] == PRVM_serveredictvector(ent, punchangle)[2])
{
{
vec3_t entorigin;
prvm_prog_t *prog = SVVM_prog;
- // LordHavoc: bugfixes in this function are keyed to the sv_gameplayfix_bugfixedcheckwatertransition cvar - if this cvar is 0 then all the original bugs should be reenabled for compatibility
+ // LadyHavoc: bugfixes in this function are keyed to the sv_gameplayfix_bugfixedcheckwatertransition cvar - if this cvar is 0 then all the original bugs should be reenabled for compatibility
int cont;
VectorCopy(PRVM_serveredictvector(ent, origin), entorigin);
cont = Mod_Q1BSP_NativeContentsFromSuperContents(SV_PointSuperContents(entorigin));
// we can trust FL_ONGROUND if groundentity is world because it never moves
return;
}
- else if (ent->priv.server->suspendedinairflag && groundentity->priv.server->free)
+ else if (ent->priv.server->suspendedinairflag && groundentity->free)
{
// if ent was supported by a brush model on previous frame,
// and groundentity is now freed, set groundentity to 0 (world)
{
// move origin
VectorScale(PRVM_serveredictvector(ent, velocity), movetime, move);
- if(!SV_PushEntity(&trace, ent, move, true))
+ // The buzzsaw traps in r2m6 and r2m7 use MOVETYPE_FLY and rely on moving while stuck in the world.
+ // Quake movetypes checked allsolid only in SV_FlyMove().
+ if(!SV_PushEntity(&trace, ent, move, true, PRVM_serveredictfloat(ent, movetype) != MOVETYPE_FLY))
return; // teleported
- if (ent->priv.server->free)
+ if (ent->free)
return;
- if (trace.bmodelstartsolid && sv_gameplayfix_unstickentities.integer)
- {
- // try to unstick the entity
- SV_UnstickEntity(ent);
- if(!SV_PushEntity(&trace, ent, move, true))
- return; // teleported
- if (ent->priv.server->free)
- return;
- }
if (trace.fraction == 1)
break;
movetime *= 1 - min(1, trace.fraction);
ent_gravity = PRVM_serveredictfloat(ent, gravity);
if (!ent_gravity)
ent_gravity = 1.0f;
- // LordHavoc: fixed grenades not bouncing when fired down a slope
+ // LadyHavoc: fixed grenades not bouncing when fired down a slope
if (sv_gameplayfix_grenadebouncedownslopes.integer)
d = fabs(DotProduct(trace.plane.normal, PRVM_serveredictvector(ent, velocity)));
else
// (if an ent spawns a higher numbered ent, it moves in the same frame,
// but if it spawns a lower numbered ent, it doesn't - this never moves
// ents in the first frame regardless)
- qboolean runmove = ent->priv.server->move;
+ qbool runmove = ent->priv.server->move;
ent->priv.server->move = true;
if (!runmove && sv_gameplayfix_delayprojectiles.integer > 0)
return;
SV_Physics_Pusher (ent);
break;
case MOVETYPE_NONE:
- // LordHavoc: manually inlined the thinktime check here because MOVETYPE_NONE is used on so many objects
+ // LadyHavoc: manually inlined the thinktime check here because MOVETYPE_NONE is used on so many objects
if (PRVM_serveredictfloat(ent, nextthink) > 0 && PRVM_serveredictfloat(ent, nextthink) <= sv.time + sv.frametime)
SV_RunThink (ent);
break;
}
}
+// asynchronous path
void SV_Physics_ClientMove(void)
{
prvm_prog_t *prog = SVVM_prog;
// call player physics, this needs the proper frametime
PRVM_serverglobalfloat(frametime) = sv.frametime;
- SV_ClientThink();
+ SV_PlayerPhysics();
// call standard client pre-think, with frametime = 0
PRVM_serverglobalfloat(time) = sv.time;
// angle fixing was requested by physics code...
// so store the current angles for later use
VectorCopy(PRVM_serveredictvector(ent, angles), host_client->fixangle_angles);
- host_client->fixangle_angles_set = TRUE;
+ host_client->fixangle_angles_set = true;
// and clear fixangle for the next frame
PRVM_serveredictfloat(ent, fixangle) = 0;
// don't run physics here if running asynchronously
if (host_client->clmovement_inputtimeout <= 0)
{
- SV_ClientThink();
+ SV_PlayerPhysics();
//host_client->cmd.time = max(host_client->cmd.time, sv.time);
}
// angle fixing was requested by physics code...
// so store the current angles for later use
VectorCopy(PRVM_serveredictvector(ent, angles), host_client->fixangle_angles);
- host_client->fixangle_angles_set = TRUE;
+ host_client->fixangle_angles_set = true;
// and clear fixangle for the next frame
PRVM_serveredictfloat(ent, fixangle) = 0;
SV_Physics_Pusher (ent);
break;
case MOVETYPE_NONE:
- // LordHavoc: manually inlined the thinktime check here because MOVETYPE_NONE is used on so many objects
+ // LadyHavoc: manually inlined the thinktime check here because MOVETYPE_NONE is used on so many objects
if (PRVM_serveredictfloat(ent, nextthink) > 0 && PRVM_serveredictfloat(ent, nextthink) <= sv.time + sv.frametime)
SV_RunThink (ent);
break;
int i;
prvm_edict_t *ent;
+ // free memory for resources that are no longer referenced
+ PRVM_GarbageCollection(prog);
+
// let the progs know that a new frame has started
PRVM_serverglobaledict(self) = PRVM_EDICT_TO_PROG(prog->edicts);
PRVM_serverglobaledict(other) = PRVM_EDICT_TO_PROG(prog->edicts);
PRVM_serverglobalfloat(frametime) = sv.frametime;
prog->ExecuteProgram(prog, PRVM_serverfunction(StartFrame), "QC function StartFrame is missing");
+#ifdef USEODE
// run physics engine
World_Physics_Frame(&sv.world, sv.frametime, sv_gravity.value);
+#endif
//
// treat each object in turn
// if force_retouch, relink all the entities
if (PRVM_serverglobalfloat(force_retouch) > 0)
for (i = 1, ent = PRVM_EDICT_NUM(i);i < prog->num_edicts;i++, ent = PRVM_NEXT_EDICT(ent))
- if (!ent->priv.server->free)
+ if (!ent->free)
SV_LinkEdict_TouchAreaGrid(ent); // force retouch even for stationary
if (sv_gameplayfix_consistentplayerprethink.integer)
{
// run physics on the client entities in 3 stages
for (i = 1, ent = PRVM_EDICT_NUM(i), host_client = svs.clients;i <= svs.maxclients;i++, ent = PRVM_NEXT_EDICT(ent), host_client++)
- if (!ent->priv.server->free)
+ if (!ent->free)
SV_Physics_ClientEntity_PreThink(ent);
for (i = 1, ent = PRVM_EDICT_NUM(i), host_client = svs.clients;i <= svs.maxclients;i++, ent = PRVM_NEXT_EDICT(ent), host_client++)
- if (!ent->priv.server->free)
+ if (!ent->free)
SV_Physics_ClientEntity(ent);
for (i = 1, ent = PRVM_EDICT_NUM(i), host_client = svs.clients;i <= svs.maxclients;i++, ent = PRVM_NEXT_EDICT(ent), host_client++)
- if (!ent->priv.server->free)
+ if (!ent->free)
SV_Physics_ClientEntity_PostThink(ent);
}
else
// run physics on the client entities
for (i = 1, ent = PRVM_EDICT_NUM(i), host_client = svs.clients;i <= svs.maxclients;i++, ent = PRVM_NEXT_EDICT(ent), host_client++)
{
- if (!ent->priv.server->free)
+ if (!ent->free)
{
SV_Physics_ClientEntity_PreThink(ent);
SV_Physics_ClientEntity(ent);
if (!sv_freezenonclients.integer)
{
for (;i < prog->num_edicts;i++, ent = PRVM_NEXT_EDICT(ent))
- if (!ent->priv.server->free)
+ if (!ent->free)
SV_Physics_Entity(ent);
// make a second pass to see if any ents spawned this frame and make
// sure they run their move/think
if (sv_gameplayfix_delayprojectiles.integer < 0)
for (i = svs.maxclients + 1, ent = PRVM_EDICT_NUM(i);i < prog->num_edicts;i++, ent = PRVM_NEXT_EDICT(ent))
- if (!ent->priv.server->move && !ent->priv.server->free)
+ if (!ent->priv.server->move && !ent->free)
SV_Physics_Entity(ent);
}
if (PRVM_serverglobalfloat(force_retouch) > 0)
PRVM_serverglobalfloat(force_retouch) = max(0, PRVM_serverglobalfloat(force_retouch) - 1);
- // LordHavoc: endframe support
+ // LadyHavoc: endframe support
if (PRVM_serverfunction(EndFrame))
{
PRVM_serverglobaledict(self) = PRVM_EDICT_TO_PROG(prog->edicts);
projects / xonotic / darkplaces.git / blobdiff