// run the impact function
if (impact)
{
- SV_Impact(ent, trace.ent);
+ SV_Impact(ent, (prvm_edict_t *)trace.ent);
// break if removed by the impact function
if (ent->priv.server->free)
SV_LinkEdict (ent, true);
if (trace.ent && (!((int)ent->fields.server->flags & FL_ONGROUND) || ent->fields.server->groundentity != PRVM_EDICT_TO_PROG(trace.ent)))
- SV_Impact (ent, trace.ent);
+ SV_Impact (ent, (prvm_edict_t *)trace.ent);
return trace;
}
============
*/
-trace_t SV_ClipMoveToEntity (prvm_edict_t *ent, vec3_t start, vec3_t mins, vec3_t maxs, vec3_t end, int movetype, int hitsupercontents);
void SV_PushMove (prvm_edict_t *pusher, float movetime)
{
int i, e, index;
- prvm_edict_t *check, *ed;
float savesolid, movetime2, pushltime;
- vec3_t mins, maxs, move, move1, moveangle, pushorig, pushang, a, forward, left, up, org, org2;
+ vec3_t mins, maxs, move, move1, moveangle, pushorig, pushang, a, forward, left, up, org;
int num_moved;
int numcheckentities;
static prvm_edict_t *checkentities[MAX_EDICTS];
numcheckentities = SV_EntitiesInBox(mins, maxs, MAX_EDICTS, checkentities);
for (e = 0;e < numcheckentities;e++)
{
- check = checkentities[e];
- if ((int)check->fields.server->movetype == MOVETYPE_PUSH
- || (int)check->fields.server->movetype == MOVETYPE_NONE
- || (int)check->fields.server->movetype == MOVETYPE_FOLLOW
- || (int)check->fields.server->movetype == MOVETYPE_NOCLIP
- || (int)check->fields.server->movetype == MOVETYPE_FAKEPUSH)
+ prvm_edict_t *check = checkentities[e];
+ if (check->fields.server->movetype == MOVETYPE_NONE
+ || check->fields.server->movetype == MOVETYPE_PUSH
+ || check->fields.server->movetype == MOVETYPE_FOLLOW
+ || check->fields.server->movetype == MOVETYPE_NOCLIP
+ || check->fields.server->movetype == MOVETYPE_FAKEPUSH)
continue;
// if the entity is standing on the pusher, it will definitely be moved
// if the entity is not inside the pusher's final position, leave it alone
if (!SV_ClipMoveToEntity(pusher, check->fields.server->origin, check->fields.server->mins, check->fields.server->maxs, check->fields.server->origin, 0, SUPERCONTENTS_SOLID).startsolid)
continue;
+ // remove the onground flag for non-players
+ if (check->fields.server->movetype != MOVETYPE_WALK)
+ check->fields.server->flags = (int)check->fields.server->flags & ~FL_ONGROUND;
}
+
if (forward[0] != 1 || left[1] != 1) // quick way to check if any rotation is used
{
+ vec3_t org2;
VectorSubtract (check->fields.server->origin, pusher->fields.server->origin, org);
org2[0] = DotProduct (org, forward);
org2[1] = DotProduct (org, left);
else
VectorCopy (move1, move);
- // remove the onground flag for non-players
- if ((int)check->fields.server->movetype != MOVETYPE_WALK)
- check->fields.server->flags = (int)check->fields.server->flags & ~FL_ONGROUND;
-
VectorCopy (check->fields.server->origin, check->priv.server->moved_from);
VectorCopy (check->fields.server->angles, check->priv.server->moved_fromangles);
sv.moved_edicts[num_moved++] = check;
if (SV_ClipMoveToEntity(pusher, check->fields.server->origin, check->fields.server->mins, check->fields.server->maxs, check->fields.server->origin, 0, SUPERCONTENTS_SOLID).startsolid)
{
// try moving the contacted entity a tiny bit further to account for precision errors
+ vec3_t move2;
pusher->fields.server->solid = SOLID_NOT;
- VectorScale(move, 0.1, move);
- SV_PushEntity (check, move);
+ VectorScale(move, 1.1, move2);
+ VectorCopy (check->priv.server->moved_from, check->fields.server->origin);
+ VectorCopy (check->priv.server->moved_fromangles, check->fields.server->angles);
+ SV_PushEntity (check, move2);
pusher->fields.server->solid = savesolid;
if (SV_ClipMoveToEntity(pusher, check->fields.server->origin, check->fields.server->mins, check->fields.server->maxs, check->fields.server->origin, 0, SUPERCONTENTS_SOLID).startsolid)
{
- // still inside pusher, so it's really blocked
-
- // fail the move
- if (check->fields.server->mins[0] == check->fields.server->maxs[0])
- continue;
- if ((int)check->fields.server->solid == SOLID_NOT || (int)check->fields.server->solid == SOLID_TRIGGER)
+ // try moving the contacted entity a tiny bit less to account for precision errors
+ pusher->fields.server->solid = SOLID_NOT;
+ VectorScale(move, 0.9, move2);
+ VectorCopy (check->priv.server->moved_from, check->fields.server->origin);
+ VectorCopy (check->priv.server->moved_fromangles, check->fields.server->angles);
+ SV_PushEntity (check, move2);
+ pusher->fields.server->solid = savesolid;
+ if (SV_ClipMoveToEntity(pusher, check->fields.server->origin, check->fields.server->mins, check->fields.server->maxs, check->fields.server->origin, 0, SUPERCONTENTS_SOLID).startsolid)
{
- // corpse
- check->fields.server->mins[0] = check->fields.server->mins[1] = 0;
- VectorCopy (check->fields.server->mins, check->fields.server->maxs);
- continue;
- }
+ // still inside pusher, so it's really blocked
+
+ // fail the move
+ if (check->fields.server->mins[0] == check->fields.server->maxs[0])
+ continue;
+ if (check->fields.server->solid == SOLID_NOT || check->fields.server->solid == SOLID_TRIGGER)
+ {
+ // corpse
+ check->fields.server->mins[0] = check->fields.server->mins[1] = 0;
+ VectorCopy (check->fields.server->mins, check->fields.server->maxs);
+ continue;
+ }
- VectorCopy (pushorig, pusher->fields.server->origin);
- VectorCopy (pushang, pusher->fields.server->angles);
- pusher->fields.server->ltime = pushltime;
- SV_LinkEdict (pusher, false);
+ VectorCopy (pushorig, pusher->fields.server->origin);
+ VectorCopy (pushang, pusher->fields.server->angles);
+ pusher->fields.server->ltime = pushltime;
+ SV_LinkEdict (pusher, false);
- // move back any entities we already moved
- for (i = 0;i < num_moved;i++)
- {
- ed = sv.moved_edicts[i];
- VectorCopy (ed->priv.server->moved_from, ed->fields.server->origin);
- VectorCopy (ed->priv.server->moved_fromangles, ed->fields.server->angles);
- SV_LinkEdict (ed, false);
- }
+ // move back any entities we already moved
+ for (i = 0;i < num_moved;i++)
+ {
+ prvm_edict_t *ed = sv.moved_edicts[i];
+ VectorCopy (ed->priv.server->moved_from, ed->fields.server->origin);
+ VectorCopy (ed->priv.server->moved_fromangles, ed->fields.server->angles);
+ SV_LinkEdict (ed, false);
+ }
- // if the pusher has a "blocked" function, call it, otherwise just stay in place until the obstacle is gone
- if (pusher->fields.server->blocked)
- {
- prog->globals.server->self = PRVM_EDICT_TO_PROG(pusher);
- prog->globals.server->other = PRVM_EDICT_TO_PROG(check);
- PRVM_ExecuteProgram (pusher->fields.server->blocked, "QC function self.blocked is missing");
+ // if the pusher has a "blocked" function, call it, otherwise just stay in place until the obstacle is gone
+ if (pusher->fields.server->blocked)
+ {
+ prog->globals.server->self = PRVM_EDICT_TO_PROG(pusher);
+ prog->globals.server->other = PRVM_EDICT_TO_PROG(check);
+ PRVM_ExecuteProgram (pusher->fields.server->blocked, "QC function self.blocked is missing");
+ }
+ break;
}
- break;
}
}
}
void SV_CheckWaterTransition (prvm_edict_t *ent)
{
int cont;
- cont = SV_PointQ1Contents(ent->fields.server->origin);
+ cont = Mod_Q1BSP_NativeContentsFromSuperContents(NULL, SV_PointSuperContents(ent->fields.server->origin));
if (!ent->fields.server->watertype)
{
// just spawned here
//============================================================================
-void SV_Physics_Entity (prvm_edict_t *ent, qboolean runmove)
+static void SV_Physics_Entity (prvm_edict_t *ent, qboolean runmove)
{
- int i = ent - prog->edicts;
- if (i >= 1 && i <= svs.maxclients)
+ switch ((int) ent->fields.server->movetype)
{
- // make sure the velocity is sane (not a NaN)
- SV_CheckVelocity(ent);
- // LordHavoc: QuakeC replacement for SV_ClientThink (player movement)
- if (SV_PlayerPhysicsQC && sv_playerphysicsqc.integer)
+ case MOVETYPE_PUSH:
+ case MOVETYPE_FAKEPUSH:
+ SV_Physics_Pusher (ent);
+ break;
+ case MOVETYPE_NONE:
+ // LordHavoc: manually inlined the thinktime check here because MOVETYPE_NONE is used on so many objects
+ if (ent->fields.server->nextthink > 0 && ent->fields.server->nextthink <= sv.time + sv.frametime)
+ SV_RunThink (ent);
+ break;
+ case MOVETYPE_FOLLOW:
+ SV_Physics_Follow (ent);
+ break;
+ case MOVETYPE_NOCLIP:
+ if (SV_RunThink(ent))
{
- prog->globals.server->time = sv.time;
- prog->globals.server->self = PRVM_EDICT_TO_PROG(ent);
- PRVM_ExecuteProgram ((func_t)(SV_PlayerPhysicsQC - prog->functions), "QC function SV_PlayerPhysics is missing");
+ SV_CheckWater(ent);
+ VectorMA(ent->fields.server->origin, sv.frametime, ent->fields.server->velocity, ent->fields.server->origin);
+ VectorMA(ent->fields.server->angles, sv.frametime, ent->fields.server->avelocity, ent->fields.server->angles);
}
- else
- SV_ClientThink ();
- // make sure the velocity is sane (not a NaN)
- SV_CheckVelocity(ent);
- // LordHavoc: a hack to ensure that the (rather silly) id1 quakec
- // player_run/player_stand1 does not horribly malfunction if the
- // velocity becomes a number that is both == 0 and != 0
- // (sounds to me like NaN but to be absolutely safe...)
- if (DotProduct(ent->fields.server->velocity, ent->fields.server->velocity) < 0.0001)
- VectorClear(ent->fields.server->velocity);
- // call standard client pre-think
+ SV_LinkEdict(ent, false);
+ break;
+ case MOVETYPE_STEP:
+ SV_Physics_Step (ent);
+ break;
+ case MOVETYPE_WALK:
+ if (SV_RunThink (ent))
+ {
+ if (!SV_CheckWater (ent) && ! ((int)ent->fields.server->flags & FL_WATERJUMP) )
+ SV_AddGravity (ent);
+ SV_CheckStuck (ent);
+ SV_WalkMove (ent);
+ SV_LinkEdict (ent, true);
+ }
+ break;
+ case MOVETYPE_TOSS:
+ case MOVETYPE_BOUNCE:
+ case MOVETYPE_BOUNCEMISSILE:
+ case MOVETYPE_FLYMISSILE:
+ case MOVETYPE_FLY:
+ // regular thinking
+ if (SV_RunThink (ent) && runmove)
+ SV_Physics_Toss (ent);
+ break;
+ default:
+ Con_Printf ("SV_Physics: bad movetype %i", (int)ent->fields.server->movetype);
+ break;
+ }
+}
+
+void SV_Physics_ClientEntity (prvm_edict_t *ent)
+{
+ // make sure the velocity is sane (not a NaN)
+ SV_CheckVelocity(ent);
+ // LordHavoc: QuakeC replacement for SV_ClientThink (player movement)
+ if (SV_PlayerPhysicsQC && sv_playerphysicsqc.integer)
+ {
prog->globals.server->time = sv.time;
prog->globals.server->self = PRVM_EDICT_TO_PROG(ent);
- PRVM_ExecuteProgram (prog->globals.server->PlayerPreThink, "QC function PlayerPreThink is missing");
- SV_CheckVelocity (ent);
+ PRVM_ExecuteProgram ((func_t)(SV_PlayerPhysicsQC - prog->functions), "QC function SV_PlayerPhysics is missing");
}
+ else
+ SV_ClientThink ();
+ // make sure the velocity is sane (not a NaN)
+ SV_CheckVelocity(ent);
+ // LordHavoc: a hack to ensure that the (rather silly) id1 quakec
+ // player_run/player_stand1 does not horribly malfunction if the
+ // velocity becomes a number that is both == 0 and != 0
+ // (sounds to me like NaN but to be absolutely safe...)
+ if (DotProduct(ent->fields.server->velocity, ent->fields.server->velocity) < 0.0001)
+ VectorClear(ent->fields.server->velocity);
+ // call standard client pre-think
+ prog->globals.server->time = sv.time;
+ prog->globals.server->self = PRVM_EDICT_TO_PROG(ent);
+ PRVM_ExecuteProgram (prog->globals.server->PlayerPreThink, "QC function PlayerPreThink is missing");
+ SV_CheckVelocity (ent);
- // LordHavoc: merged client and normal entity physics
switch ((int) ent->fields.server->movetype)
{
case MOVETYPE_PUSH:
VectorMA(ent->fields.server->origin, sv.frametime, ent->fields.server->velocity, ent->fields.server->origin);
VectorMA(ent->fields.server->angles, sv.frametime, ent->fields.server->avelocity, ent->fields.server->angles);
}
- // 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);
- // 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:
case MOVETYPE_BOUNCEMISSILE:
case MOVETYPE_FLYMISSILE:
// regular thinking
- if (SV_RunThink (ent) && runmove)
+ if (SV_RunThink (ent))
SV_Physics_Toss (ent);
break;
case MOVETYPE_FLY:
- if (SV_RunThink (ent) && runmove)
+ if (SV_RunThink (ent))
{
- if (i > 0 && i <= svs.maxclients)
- {
- SV_CheckWater (ent);
- SV_WalkMove (ent);
- }
- else
- SV_Physics_Toss (ent);
+ SV_CheckWater (ent);
+ SV_WalkMove (ent);
}
break;
default:
- Con_Printf ("SV_Physics: bad movetype %i", (int)ent->fields.server->movetype);
+ Con_Printf ("SV_Physics_ClientEntity: bad movetype %i", (int)ent->fields.server->movetype);
break;
}
- if (i >= 1 && i <= svs.maxclients)
- {
- SV_CheckVelocity (ent);
+ SV_CheckVelocity (ent);
- // call standard player post-think
- SV_LinkEdict (ent, true);
+ // call standard player post-think
+ SV_LinkEdict (ent, true);
- SV_CheckVelocity (ent);
+ SV_CheckVelocity (ent);
- prog->globals.server->time = sv.time;
- prog->globals.server->self = PRVM_EDICT_TO_PROG(ent);
- PRVM_ExecuteProgram (prog->globals.server->PlayerPostThink, "QC function PlayerPostThink is missing");
- }
+ prog->globals.server->time = sv.time;
+ prog->globals.server->self = PRVM_EDICT_TO_PROG(ent);
+ PRVM_ExecuteProgram (prog->globals.server->PlayerPostThink, "QC function PlayerPostThink is missing");
}
-
/*
================
SV_Physics
{
int i, newnum_edicts;
prvm_edict_t *ent;
- qbyte runmove[MAX_EDICTS];
+ unsigned char runmove[MAX_EDICTS];
// let the progs know that a new frame has started
prog->globals.server->self = PRVM_EDICT_TO_PROG(prog->edicts);
prog->globals.server->frametime = sv.frametime;
PRVM_ExecuteProgram (prog->globals.server->StartFrame, "QC function StartFrame is missing");
+ // don't run a move on newly spawned projectiles as it messes up movement
+ // interpolation and rocket trails
newnum_edicts = 0;
for (i = 0, ent = prog->edicts;i < prog->num_edicts;i++, ent = PRVM_NEXT_EDICT(ent))
if ((runmove[i] = !ent->priv.server->free))
// treat each object in turn
//
- for (i = 0, ent = prog->edicts;i < prog->num_edicts;i++, ent = PRVM_NEXT_EDICT(ent))
- {
- if (ent->priv.server->free)
- continue;
-
- if (prog->globals.server->force_retouch)
- SV_LinkEdict (ent, true); // force retouch even for stationary
+ // if force_retouch, relink all the entities
+ if (prog->globals.server->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)
+ SV_LinkEdict (ent, true); // force retouch even for stationary
- if (i >= 1 && i <= svs.maxclients)
+ // 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)
{
- host_client = svs.clients + i - 1;
// don't do physics on disconnected clients, FrikBot relies on this
if (!host_client->spawned)
- {
memset(&host_client->cmd, 0, sizeof(host_client->cmd));
- continue;
- }
- // connected slot
- if (host_client->movesequence)
- continue; // return if running asynchronously
+ // don't run physics here if running asynchronously
+ else if (!host_client->movesequence)
+ SV_Physics_ClientEntity(ent);
}
- else if (sv_freezenonclients.integer)
- continue;
-
- SV_Physics_Entity(ent, runmove[i]);
}
+ // run physics on all the non-client entities
+ if (!sv_freezenonclients.integer)
+ for (;i < prog->num_edicts;i++, ent = PRVM_NEXT_EDICT(ent))
+ if (!ent->priv.server->free)
+ SV_Physics_Entity(ent, runmove[i]);
+
if (prog->globals.server->force_retouch > 0)
prog->globals.server->force_retouch = max(0, prog->globals.server->force_retouch - 1);
projects / xonotic / darkplaces.git / blobdiff