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;
}
{
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;
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, to partially fix angled corner sticking
+// (example - start.bsp hall to e1m4, leading to the pool there are two
+// angled corners, which you could get stuck on, now they are just a one
+// frame hiccup)
+#define MAX_CLIP_PLANES 20
int SV_FlyMove (edict_t *ent, float time, trace_t *steptrace)
{
int bumpcount, numbumps;
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;
}
{
pr_global_struct->self = EDICT_TO_PROG(pusher);
pr_global_struct->other = EDICT_TO_PROG(check);
- PR_ExecuteProgram (pusher->v.blocked);
+ PR_ExecuteProgram (pusher->v.blocked, "");
}
// move back any entities we already moved
{
pr_global_struct->self = EDICT_TO_PROG(pusher);
pr_global_struct->other = EDICT_TO_PROG(check);
- PR_ExecuteProgram (pusher->v.blocked);
+ PR_ExecuteProgram (pusher->v.blocked, "");
}
// move back any entities we already moved
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)
{
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;
}
*/
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;
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
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?
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
//
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
if (!SV_RunThink (ent))
return;
SV_CheckWater (ent);
- SV_FlyMove (ent, host_frametime, NULL);
+ SV_FlyMove (ent, sv.frametime, NULL);
break;
case MOVETYPE_NOCLIP:
if (!SV_RunThink (ent))
return;
SV_CheckWater (ent);
- VectorMA (ent->v.origin, host_frametime, ent->v.velocity, ent->v.origin);
+ VectorMA (ent->v.origin, sv.frametime, ent->v.velocity, ent->v.origin);
break;
default:
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");
}
//============================================================================
*/
void SV_Physics_Follow (edict_t *ent)
{
- vec3_t vf, vr, vu, angles;
+ vec3_t vf, vr, vu, angles, v;
edict_t *e;
// regular thinking
if (!SV_RunThink (ent))
}
else
{
- angles[0] = -(e->v.angles[0] - ent->v.punchangle[0]);
- angles[1] = e->v.angles[1] - ent->v.punchangle[1];
- angles[2] = e->v.angles[2] - ent->v.punchangle[2];
+ 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] = ent->v.view_ofs[0] * vf[0] + ent->v.view_ofs[1] * vr[0] + ent->v.view_ofs[2] * vu[0] + e->v.origin[0];
- ent->v.origin[1] = ent->v.view_ofs[0] * vf[1] + ent->v.view_ofs[1] * vr[1] + ent->v.view_ofs[2] * vu[1] + e->v.origin[1];
- ent->v.origin[2] = ent->v.view_ofs[0] * vf[2] + ent->v.view_ofs[1] * vr[2] + ent->v.view_ofs[2] * vu[2] + e->v.origin[2];
+ 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];
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);
}
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);
+ VectorScale (ent->v.velocity, sv.frametime, move);
trace = SV_PushEntity (ent, move);
if (trace.fraction == 1)
return;
SV_AddGravity (ent);
SV_CheckVelocity (ent);
- SV_FlyMove (ent, host_frametime, NULL);
+ SV_FlyMove (ent, sv.frametime, NULL);
SV_LinkEdict (ent, true);
if ( (int)ent->v.flags & FL_ONGROUND ) // just hit ground
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 ();
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 trace;
vec3_t move;
vec3_t end;
- double save_frametime;
-
- save_frametime = host_frametime;
- host_frametime = 0.05;
memcpy(&tempent, ent, sizeof(edict_t));
tent = &tempent;
{
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);
+ 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);
VectorCopy (trace.endpos, tent->v.origin);
if (trace.ent != ignore)
break;
}
- host_frametime = save_frametime;
+ trace.fraction = 0; // not relevant
return trace;
}
projects / xonotic / darkplaces.git / blobdiff