mirror of
https://git.code.sf.net/p/quake/quakeforge
synced 2024-11-26 06:10:56 +00:00
bring sv_phys.c closer to being mergable. I've temporarily(?) disabled
Maddes' max velocity `fix' (yeah, it's physicly correct, but...). I'll probably cvar it.
This commit is contained in:
Bill Currie
parent
80723fdec7
commit
96d3a997c9
7 changed files with 590 additions and 597 deletions
|
|
@ -39,7 +39,7 @@ typedef struct
|
|||
float dist;
|
||||
} plane_t;
|
||||
|
||||
typedef struct
|
||||
typedef struct trace_s
|
||||
{
|
||||
qboolean allsolid; // if true, plane is not valid
|
||||
qboolean startsolid; // if true, the initial point was in a solid area
|
||||
|
|
|
|||
|
|
@ -253,6 +253,13 @@ void SV_AddClientToServer (struct qsocket_s *ret);
|
|||
void SV_ClientPrintf (const char *fmt, ...) __attribute__((format(printf,1,2)));
|
||||
void SV_BroadcastPrintf (const char *fmt, ...) __attribute__((format(printf,1,2)));
|
||||
|
||||
struct trace_s SV_PushEntity (edict_t *ent, vec3_t push);
|
||||
int SV_FlyMove (edict_t *ent, float time, struct trace_s *steptrace);
|
||||
void SV_CheckVelocity (edict_t *ent);
|
||||
qboolean SV_RunThink (edict_t *ent);
|
||||
void SV_AddGravity (edict_t *ent);
|
||||
void SV_Physics_Toss (edict_t *ent);
|
||||
void SV_Physics_Client (edict_t *ent, int num);
|
||||
void SV_Physics (void);
|
||||
|
||||
qboolean SV_CheckBottom (edict_t *ent);
|
||||
|
|
|
|||
|
|
@ -97,7 +97,7 @@ client_sources= cl_cam.c cl_cmd.c cl_demo.c cl_input.c cl_main.c cl_screen.c \
|
|||
locs.c sbar.c
|
||||
|
||||
server_sources= host.c host_cmd.c pr_cmds.c sv_cvar.c sv_main.c \
|
||||
sv_move.c sv_phys.c sv_progs.c sv_user.c
|
||||
sv_move.c sv_cl_phys.c sv_phys.c sv_progs.c sv_user.c
|
||||
|
||||
combined_sources= \
|
||||
$(common_sources) $(client_sources) $(server_sources)
|
||||
|
|
|
|||
376
nq/source/sv_cl_phys.c
Normal file
376
nq/source/sv_cl_phys.c
Normal file
|
|
@ -0,0 +1,376 @@
|
|||
/*
|
||||
sv_phys.c
|
||||
|
||||
@description@
|
||||
|
||||
Copyright (C) 1996-1997 Id Software, Inc.
|
||||
|
||||
This program is free software; you can redistribute it and/or
|
||||
modify it under the terms of the GNU General Public License
|
||||
as published by the Free Software Foundation; either version 2
|
||||
of the License, or (at your option) any later version.
|
||||
|
||||
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.
|
||||
|
||||
See the GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program; if not, write to:
|
||||
|
||||
Free Software Foundation, Inc.
|
||||
59 Temple Place - Suite 330
|
||||
Boston, MA 02111-1307, USA
|
||||
|
||||
*/
|
||||
static const char rcsid[] =
|
||||
"$Id$";
|
||||
|
||||
#ifdef HAVE_CONFIG_H
|
||||
# include "config.h"
|
||||
#endif
|
||||
|
||||
#include "QF/console.h"
|
||||
#include "QF/cvar.h"
|
||||
#include "QF/sys.h"
|
||||
|
||||
#include "host.h"
|
||||
#include "server.h"
|
||||
#include "sv_progs.h"
|
||||
#include "world.h"
|
||||
|
||||
#define sv_frametime host_frametime
|
||||
|
||||
|
||||
// CLIENT MOVEMENT ============================================================
|
||||
|
||||
/*
|
||||
SV_CheckStuck
|
||||
|
||||
This is a big hack to try and fix the rare case of getting stuck in the world
|
||||
clipping hull.
|
||||
*/
|
||||
void
|
||||
SV_CheckStuck (edict_t *ent)
|
||||
{
|
||||
int i, j, z;
|
||||
vec3_t org;
|
||||
|
||||
if (!SV_TestEntityPosition (ent)) {
|
||||
VectorCopy (SVvector (ent, origin), SVvector (ent, oldorigin));
|
||||
return;
|
||||
}
|
||||
|
||||
VectorCopy (SVvector (ent, origin), org);
|
||||
VectorCopy (SVvector (ent, oldorigin), SVvector (ent, origin));
|
||||
if (!SV_TestEntityPosition (ent)) {
|
||||
Con_DPrintf ("Unstuck.\n");
|
||||
SV_LinkEdict (ent, true);
|
||||
return;
|
||||
}
|
||||
|
||||
for (z = 0; z < 18; z++)
|
||||
for (i = -1; i <= 1; i++)
|
||||
for (j = -1; j <= 1; j++) {
|
||||
SVvector (ent, origin)[0] = org[0] + i;
|
||||
SVvector (ent, origin)[1] = org[1] + j;
|
||||
SVvector (ent, origin)[2] = org[2] + z;
|
||||
if (!SV_TestEntityPosition (ent)) {
|
||||
Con_DPrintf ("Unstuck.\n");
|
||||
SV_LinkEdict (ent, true);
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
VectorCopy (org, SVvector (ent, origin));
|
||||
Con_DPrintf ("player is stuck.\n");
|
||||
}
|
||||
|
||||
qboolean
|
||||
SV_CheckWater (edict_t *ent)
|
||||
{
|
||||
int cont;
|
||||
vec3_t point;
|
||||
|
||||
point[0] = SVvector (ent, origin)[0];
|
||||
point[1] = SVvector (ent, origin)[1];
|
||||
point[2] = SVvector (ent, origin)[2] + SVvector (ent, mins)[2] + 1;
|
||||
|
||||
SVfloat (ent, waterlevel) = 0;
|
||||
SVfloat (ent, watertype) = CONTENTS_EMPTY;
|
||||
cont = SV_PointContents (point);
|
||||
if (cont <= CONTENTS_WATER) {
|
||||
SVfloat (ent, watertype) = cont;
|
||||
SVfloat (ent, waterlevel) = 1;
|
||||
point[2] = SVvector (ent, origin)[2] + (SVvector (ent, mins)[2] +
|
||||
SVvector (ent, maxs)[2]) * 0.5;
|
||||
cont = SV_PointContents (point);
|
||||
if (cont <= CONTENTS_WATER) {
|
||||
SVfloat (ent, waterlevel) = 2;
|
||||
point[2] = SVvector (ent, origin)[2] + SVvector (ent, view_ofs)[2];
|
||||
cont = SV_PointContents (point);
|
||||
if (cont <= CONTENTS_WATER)
|
||||
SVfloat (ent, waterlevel) = 3;
|
||||
}
|
||||
}
|
||||
|
||||
return SVfloat (ent, waterlevel) > 1;
|
||||
}
|
||||
|
||||
void
|
||||
SV_WallFriction (edict_t *ent, trace_t *trace)
|
||||
{
|
||||
float d, i;
|
||||
vec3_t forward, right, up, into, side;
|
||||
|
||||
AngleVectors (SVvector (ent, v_angle), forward, right, up);
|
||||
d = DotProduct (trace->plane.normal, forward);
|
||||
|
||||
d += 0.5;
|
||||
if (d >= 0)
|
||||
return;
|
||||
|
||||
// cut the tangential velocity
|
||||
i = DotProduct (trace->plane.normal, SVvector (ent, velocity));
|
||||
VectorScale (trace->plane.normal, i, into);
|
||||
VectorSubtract (SVvector (ent, velocity), into, side);
|
||||
|
||||
SVvector (ent, velocity)[0] = side[0] * (1 + d);
|
||||
SVvector (ent, velocity)[1] = side[1] * (1 + d);
|
||||
}
|
||||
|
||||
/*
|
||||
SV_TryUnstick
|
||||
|
||||
Player has come to a dead stop, possibly due to the problem with limited
|
||||
float precision at some angle joins in the BSP hull.
|
||||
|
||||
Try fixing by pushing one pixel in each direction.
|
||||
|
||||
This is a hack, but in the interest of good gameplay...
|
||||
*/
|
||||
int
|
||||
SV_TryUnstick (edict_t *ent, vec3_t oldvel)
|
||||
{
|
||||
int i, clip;
|
||||
vec3_t dir, oldorg;
|
||||
trace_t steptrace;
|
||||
|
||||
VectorCopy (SVvector (ent, origin), oldorg);
|
||||
VectorCopy (vec3_origin, dir);
|
||||
|
||||
for (i = 0; i < 8; i++) {
|
||||
// try pushing a little in an axial direction
|
||||
switch (i) {
|
||||
case 0:
|
||||
dir[0] = 2;
|
||||
dir[1] = 0;
|
||||
break;
|
||||
case 1:
|
||||
dir[0] = 0;
|
||||
dir[1] = 2;
|
||||
break;
|
||||
case 2:
|
||||
dir[0] = -2;
|
||||
dir[1] = 0;
|
||||
break;
|
||||
case 3:
|
||||
dir[0] = 0;
|
||||
dir[1] = -2;
|
||||
break;
|
||||
case 4:
|
||||
dir[0] = 2;
|
||||
dir[1] = 2;
|
||||
break;
|
||||
case 5:
|
||||
dir[0] = -2;
|
||||
dir[1] = 2;
|
||||
break;
|
||||
case 6:
|
||||
dir[0] = 2;
|
||||
dir[1] = -2;
|
||||
break;
|
||||
case 7:
|
||||
dir[0] = -2;
|
||||
dir[1] = -2;
|
||||
break;
|
||||
}
|
||||
|
||||
SV_PushEntity (ent, dir);
|
||||
|
||||
// retry the original move
|
||||
SVvector (ent, velocity)[0] = oldvel[0];
|
||||
SVvector (ent, velocity)[1] = oldvel[1];
|
||||
SVvector (ent, velocity)[2] = 0;
|
||||
clip = SV_FlyMove (ent, 0.1, &steptrace);
|
||||
|
||||
if (fabs (oldorg[1] - SVvector (ent, origin)[1]) > 4
|
||||
|| fabs (oldorg[0] - SVvector (ent, origin)[0]) > 4) {
|
||||
// Con_DPrintf ("unstuck!\n");
|
||||
return clip;
|
||||
}
|
||||
// go back to the original pos and try again
|
||||
VectorCopy (oldorg, SVvector (ent, origin));
|
||||
}
|
||||
|
||||
VectorCopy (vec3_origin, SVvector (ent, velocity));
|
||||
return 7; // still not moving
|
||||
}
|
||||
|
||||
#define STEPSIZE 18
|
||||
|
||||
/*
|
||||
SV_WalkMove
|
||||
|
||||
Only used by players
|
||||
*/
|
||||
void
|
||||
SV_WalkMove (edict_t *ent)
|
||||
{
|
||||
int clip, oldonground;
|
||||
vec3_t upmove, downmove, nosteporg, nostepvel, oldorg, oldvel;
|
||||
trace_t steptrace, downtrace;
|
||||
|
||||
// do a regular slide move unless it looks like you ran into a step
|
||||
oldonground = (int) SVfloat (ent, flags) & FL_ONGROUND;
|
||||
SVfloat (ent, flags) = (int) SVfloat (ent, flags) & ~FL_ONGROUND;
|
||||
|
||||
VectorCopy (SVvector (ent, origin), oldorg);
|
||||
VectorCopy (SVvector (ent, velocity), oldvel);
|
||||
|
||||
clip = SV_FlyMove (ent, sv_frametime, &steptrace);
|
||||
|
||||
if (!(clip & 2))
|
||||
return; // move didn't block on a step
|
||||
|
||||
if (!oldonground && SVfloat (ent, waterlevel) == 0)
|
||||
return; // don't stair up while jumping
|
||||
|
||||
if (SVfloat (ent, movetype) != MOVETYPE_WALK)
|
||||
return; // gibbed by a trigger
|
||||
|
||||
if (sv_nostep->int_val)
|
||||
return;
|
||||
|
||||
if ((int) SVfloat (sv_player, flags) & FL_WATERJUMP)
|
||||
return;
|
||||
|
||||
VectorCopy (SVvector (ent, origin), nosteporg);
|
||||
VectorCopy (SVvector (ent, velocity), nostepvel);
|
||||
|
||||
// try moving up and forward to go up a step
|
||||
VectorCopy (oldorg, SVvector (ent, origin)); // back to start pos
|
||||
VectorCopy (vec3_origin, upmove);
|
||||
VectorCopy (vec3_origin, downmove);
|
||||
upmove[2] = STEPSIZE;
|
||||
downmove[2] = -STEPSIZE + oldvel[2] * sv_frametime;
|
||||
|
||||
// move up
|
||||
SV_PushEntity (ent, upmove); // FIXME: don't link?
|
||||
|
||||
// move forward
|
||||
SVvector (ent, velocity)[0] = oldvel[0];
|
||||
SVvector (ent, velocity)[1] = oldvel[1];
|
||||
SVvector (ent, velocity)[2] = 0;
|
||||
clip = SV_FlyMove (ent, sv_frametime, &steptrace);
|
||||
|
||||
// check for stuckness, possibly due to the limited precision of floats
|
||||
// in the clipping hulls
|
||||
if (clip) {
|
||||
if (fabs (oldorg[1] - SVvector (ent, origin)[1]) < 0.03125
|
||||
&& fabs (oldorg[0] - SVvector (ent, origin)[0]) < 0.03125) {
|
||||
// stepping up didn't make any progress
|
||||
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?
|
||||
|
||||
if (downtrace.plane.normal[2] > 0.7) {
|
||||
if (SVfloat (ent, solid) == SOLID_BSP) {
|
||||
SVfloat (ent, flags) = (int) SVfloat (ent, flags) | FL_ONGROUND;
|
||||
SVfloat (ent, groundentity) = EDICT_TO_PROG (&sv_pr_state,
|
||||
downtrace.ent);
|
||||
}
|
||||
} else {
|
||||
// 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
|
||||
VectorCopy (nosteporg, SVvector (ent, origin));
|
||||
VectorCopy (nostepvel, SVvector (ent, velocity));
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
SV_Physics_Client
|
||||
|
||||
Player character actions
|
||||
*/
|
||||
void
|
||||
SV_Physics_Client (edict_t *ent, int num)
|
||||
{
|
||||
if (!svs.clients[num - 1].active)
|
||||
return; // unconnected slot
|
||||
|
||||
// call standard client pre-think
|
||||
*sv_globals.time = sv.time;
|
||||
*sv_globals.self = EDICT_TO_PROG (&sv_pr_state, ent);
|
||||
PR_ExecuteProgram (&sv_pr_state,
|
||||
sv_funcs.PlayerPreThink);
|
||||
|
||||
// do a move
|
||||
SV_CheckVelocity (ent);
|
||||
|
||||
// decide which move function to call
|
||||
switch ((int) SVfloat (ent, movetype)) {
|
||||
case MOVETYPE_NONE:
|
||||
if (!SV_RunThink (ent))
|
||||
return;
|
||||
break;
|
||||
|
||||
case MOVETYPE_WALK:
|
||||
if (!SV_RunThink (ent))
|
||||
return;
|
||||
if (!SV_CheckWater (ent) && !((int) SVfloat (ent, flags) &
|
||||
FL_WATERJUMP))
|
||||
SV_AddGravity (ent);
|
||||
SV_CheckStuck (ent);
|
||||
SV_WalkMove (ent);
|
||||
break;
|
||||
|
||||
case MOVETYPE_TOSS:
|
||||
case MOVETYPE_BOUNCE:
|
||||
SV_Physics_Toss (ent);
|
||||
break;
|
||||
|
||||
case MOVETYPE_FLY:
|
||||
if (!SV_RunThink (ent))
|
||||
return;
|
||||
SV_FlyMove (ent, sv_frametime, NULL);
|
||||
break;
|
||||
|
||||
case MOVETYPE_NOCLIP:
|
||||
if (!SV_RunThink (ent))
|
||||
return;
|
||||
VectorMA (SVvector (ent, origin), sv_frametime, SVvector (ent, velocity),
|
||||
SVvector (ent, origin));
|
||||
break;
|
||||
|
||||
default:
|
||||
Sys_Error ("SV_Physics_client: bad movetype %i",
|
||||
(int) SVfloat (ent, movetype));
|
||||
}
|
||||
|
||||
// call standard player post-think
|
||||
SV_LinkEdict (ent, true);
|
||||
|
||||
*sv_globals.time = sv.time;
|
||||
*sv_globals.self = EDICT_TO_PROG (&sv_pr_state, ent);
|
||||
PR_ExecuteProgram (&sv_pr_state,
|
||||
sv_funcs.PlayerPostThink);
|
||||
}
|
||||
|
|
@ -40,6 +40,8 @@ static const char rcsid[] =
|
|||
#include "sv_progs.h"
|
||||
#include "world.h"
|
||||
|
||||
#define sv_frametime host_frametime
|
||||
|
||||
/*
|
||||
pushmove objects do not obey gravity, and do not interact with each
|
||||
other or trigger fields, but block normal movement and push normal
|
||||
|
|
@ -93,6 +95,9 @@ SV_CheckAllEnts (void)
|
|||
void
|
||||
SV_CheckVelocity (edict_t *ent)
|
||||
{
|
||||
#if 0
|
||||
float wishspeed;
|
||||
#endif
|
||||
int i;
|
||||
|
||||
// bound velocity
|
||||
|
|
@ -109,11 +114,20 @@ SV_CheckVelocity (edict_t *ent)
|
|||
classname)));
|
||||
SVvector (ent, origin)[i] = 0;
|
||||
}
|
||||
#if 1
|
||||
if (SVvector (ent, velocity)[i] > sv_maxvelocity->value)
|
||||
SVvector (ent, velocity)[i] = sv_maxvelocity->value;
|
||||
else if (SVvector (ent, velocity)[i] < -sv_maxvelocity->value)
|
||||
SVvector (ent, velocity)[i] = -sv_maxvelocity->value;
|
||||
#endif
|
||||
}
|
||||
#if 0
|
||||
wishspeed = Length (SVvector (ent, velocity));
|
||||
if (wishspeed > sv_maxvelocity->value) {
|
||||
VectorScale (SVvector (ent, velocity), sv_maxvelocity->value /
|
||||
wishspeed, SVvector (ent, velocity));
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
/*
|
||||
|
|
@ -129,8 +143,9 @@ SV_RunThink (edict_t *ent)
|
|||
{
|
||||
float thinktime;
|
||||
|
||||
do {
|
||||
thinktime = SVfloat (ent, nextthink);
|
||||
if (thinktime <= 0 || thinktime > sv.time + host_frametime)
|
||||
if (thinktime <= 0 || thinktime > sv.time + sv_frametime)
|
||||
return true;
|
||||
|
||||
if (thinktime < sv.time)
|
||||
|
|
@ -142,7 +157,12 @@ SV_RunThink (edict_t *ent)
|
|||
*sv_globals.self = EDICT_TO_PROG (&sv_pr_state, ent);
|
||||
*sv_globals.other = EDICT_TO_PROG (&sv_pr_state, sv.edicts);
|
||||
PR_ExecuteProgram (&sv_pr_state, SVfunc (ent, think));
|
||||
return !ent->free;
|
||||
|
||||
if (ent->free)
|
||||
return false;
|
||||
} while (0);
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
/*
|
||||
|
|
@ -343,7 +363,7 @@ SV_AddGravity (edict_t *ent)
|
|||
ent_gravity = val->float_var;
|
||||
else
|
||||
ent_gravity = 1.0;
|
||||
SVvector (ent, velocity)[2] -= ent_gravity * sv_gravity->value * host_frametime;
|
||||
SVvector (ent, velocity)[2] -= ent_gravity * sv_gravity->value * sv_frametime;
|
||||
}
|
||||
|
||||
/* PUSHMOVE */
|
||||
|
|
@ -382,32 +402,24 @@ SV_PushEntity (edict_t *ent, vec3_t push)
|
|||
return trace;
|
||||
}
|
||||
|
||||
void
|
||||
SV_PushMove (edict_t *pusher, float movetime)
|
||||
qboolean
|
||||
SV_Push (edict_t *pusher, vec3_t move)
|
||||
{
|
||||
int i, e, num_moved;
|
||||
float solid_save;
|
||||
int num_moved, i, e;
|
||||
edict_t *check, *block;
|
||||
edict_t *moved_edict[MAX_EDICTS];
|
||||
vec3_t entorig, pushorig, mins, maxs, move;
|
||||
vec3_t entorig;
|
||||
vec3_t mins, maxs, pushorig;
|
||||
vec3_t moved_from[MAX_EDICTS];
|
||||
|
||||
if (!SVvector (pusher, velocity)[0] && !SVvector (pusher, velocity)[1]
|
||||
&& !SVvector (pusher, velocity)[2]) {
|
||||
SVfloat (pusher, ltime) += movetime;
|
||||
return;
|
||||
}
|
||||
|
||||
for (i = 0; i < 3; i++) {
|
||||
move[i] = SVvector (pusher, velocity)[i] * movetime;
|
||||
mins[i] = SVvector (pusher, absmin)[i] + move[i];
|
||||
maxs[i] = SVvector (pusher, absmax)[i] + move[i];
|
||||
}
|
||||
VectorAdd (SVvector (pusher, absmin), move, mins);
|
||||
VectorAdd (SVvector (pusher, absmax), move, maxs);
|
||||
|
||||
VectorCopy (SVvector (pusher, origin), pushorig);
|
||||
|
||||
// move the pusher to it's final position
|
||||
VectorAdd (SVvector (pusher, origin), move, SVvector (pusher, origin));
|
||||
SVfloat (pusher, ltime) += movetime;
|
||||
SV_LinkEdict (pusher, false);
|
||||
|
||||
// see if any solid entities are inside the final position
|
||||
|
|
@ -426,6 +438,7 @@ SV_PushMove (edict_t *pusher, float movetime)
|
|||
if (!(((int) SVfloat (check, flags) & FL_ONGROUND)
|
||||
&& PROG_TO_EDICT (&sv_pr_state,
|
||||
SVentity (check, groundentity)) == pusher)) {
|
||||
// check is NOT standing on pusher
|
||||
if (SVvector (check, absmin)[0] >= maxs[0]
|
||||
|| SVvector (check, absmin)[1] >= maxs[1]
|
||||
|| SVvector (check, absmin)[2] >= maxs[2]
|
||||
|
|
@ -449,17 +462,21 @@ SV_PushMove (edict_t *pusher, float movetime)
|
|||
num_moved++;
|
||||
|
||||
// try moving the contacted entity
|
||||
solid_save = SVfloat (pusher, solid);
|
||||
SVfloat (pusher, solid) = SOLID_NOT;
|
||||
SV_PushEntity (check, move);
|
||||
SVfloat (pusher, solid) = SOLID_BSP;
|
||||
SVfloat (pusher, solid) = solid_save;
|
||||
|
||||
// if it is still inside the pusher, block
|
||||
block = SV_TestEntityPosition (check);
|
||||
if (block) { // fail the move
|
||||
if (SVvector (check, mins)[0] == SVvector (check, maxs)[0])
|
||||
if (!block) {
|
||||
continue;
|
||||
if (SVfloat (check, solid) == SOLID_NOT || SVfloat (check, solid)
|
||||
== SOLID_TRIGGER) { // corpse
|
||||
}
|
||||
// if it is still inside the pusher, block
|
||||
if (SVvector (check, mins)[0] == SVvector (check, maxs)[0]) {
|
||||
continue;
|
||||
}
|
||||
if (SVfloat (check, solid) == SOLID_NOT
|
||||
|| SVfloat (check, solid) == SOLID_TRIGGER) { // corpse
|
||||
SVvector (check, mins)[0] = SVvector (check, mins)[1] = 0;
|
||||
VectorCopy (SVvector (check, mins), SVvector (check, maxs));
|
||||
continue;
|
||||
|
|
@ -470,15 +487,12 @@ SV_PushMove (edict_t *pusher, float movetime)
|
|||
|
||||
VectorCopy (pushorig, SVvector (pusher, origin));
|
||||
SV_LinkEdict (pusher, false);
|
||||
SVfloat (pusher, ltime) -= movetime;
|
||||
|
||||
// if the pusher has a "blocked" function, call it
|
||||
// otherwise, just stay in place until the obstacle is gone
|
||||
if (SVfunc (pusher, blocked)) {
|
||||
*sv_globals.self =
|
||||
EDICT_TO_PROG (&sv_pr_state, pusher);
|
||||
*sv_globals.other =
|
||||
EDICT_TO_PROG (&sv_pr_state, check);
|
||||
*sv_globals.self = EDICT_TO_PROG (&sv_pr_state, pusher);
|
||||
*sv_globals.other = EDICT_TO_PROG (&sv_pr_state, check);
|
||||
PR_ExecuteProgram (&sv_pr_state, SVfunc (pusher, blocked));
|
||||
}
|
||||
// move back any entities we already moved
|
||||
|
|
@ -486,11 +500,25 @@ SV_PushMove (edict_t *pusher, float movetime)
|
|||
VectorCopy (moved_from[i], SVvector (moved_edict[i], origin));
|
||||
SV_LinkEdict (moved_edict[i], false);
|
||||
}
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
void
|
||||
SV_PushMove (edict_t *pusher, float movetime)
|
||||
{
|
||||
vec3_t move;
|
||||
|
||||
if (VectorIsZero (SVvector (pusher, velocity))) {
|
||||
SVfloat (pusher, ltime) += movetime;
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
VectorScale (SVvector (pusher, velocity), movetime, move);
|
||||
|
||||
if (SV_Push (pusher, move))
|
||||
SVfloat (pusher, ltime) += movetime;
|
||||
}
|
||||
|
||||
void
|
||||
|
|
@ -501,12 +529,12 @@ SV_Physics_Pusher (edict_t *ent)
|
|||
oldltime = SVfloat (ent, ltime);
|
||||
|
||||
thinktime = SVfloat (ent, nextthink);
|
||||
if (thinktime < SVfloat (ent, ltime) + host_frametime) {
|
||||
if (thinktime < SVfloat (ent, ltime) + sv_frametime) {
|
||||
movetime = thinktime - SVfloat (ent, ltime);
|
||||
if (movetime < 0)
|
||||
movetime = 0;
|
||||
} else
|
||||
movetime = host_frametime;
|
||||
movetime = sv_frametime;
|
||||
|
||||
if (movetime) {
|
||||
SV_PushMove (ent, movetime); // advances SVfloat (ent, ltime) if not
|
||||
|
|
@ -525,338 +553,6 @@ SV_Physics_Pusher (edict_t *ent)
|
|||
|
||||
}
|
||||
|
||||
// CLIENT MOVEMENT ============================================================
|
||||
|
||||
/*
|
||||
SV_CheckStuck
|
||||
|
||||
This is a big hack to try and fix the rare case of getting stuck in the world
|
||||
clipping hull.
|
||||
*/
|
||||
void
|
||||
SV_CheckStuck (edict_t *ent)
|
||||
{
|
||||
int i, j, z;
|
||||
vec3_t org;
|
||||
|
||||
if (!SV_TestEntityPosition (ent)) {
|
||||
VectorCopy (SVvector (ent, origin), SVvector (ent, oldorigin));
|
||||
return;
|
||||
}
|
||||
|
||||
VectorCopy (SVvector (ent, origin), org);
|
||||
VectorCopy (SVvector (ent, oldorigin), SVvector (ent, origin));
|
||||
if (!SV_TestEntityPosition (ent)) {
|
||||
Con_DPrintf ("Unstuck.\n");
|
||||
SV_LinkEdict (ent, true);
|
||||
return;
|
||||
}
|
||||
|
||||
for (z = 0; z < 18; z++)
|
||||
for (i = -1; i <= 1; i++)
|
||||
for (j = -1; j <= 1; j++) {
|
||||
SVvector (ent, origin)[0] = org[0] + i;
|
||||
SVvector (ent, origin)[1] = org[1] + j;
|
||||
SVvector (ent, origin)[2] = org[2] + z;
|
||||
if (!SV_TestEntityPosition (ent)) {
|
||||
Con_DPrintf ("Unstuck.\n");
|
||||
SV_LinkEdict (ent, true);
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
VectorCopy (org, SVvector (ent, origin));
|
||||
Con_DPrintf ("player is stuck.\n");
|
||||
}
|
||||
|
||||
qboolean
|
||||
SV_CheckWater (edict_t *ent)
|
||||
{
|
||||
int cont;
|
||||
vec3_t point;
|
||||
|
||||
point[0] = SVvector (ent, origin)[0];
|
||||
point[1] = SVvector (ent, origin)[1];
|
||||
point[2] = SVvector (ent, origin)[2] + SVvector (ent, mins)[2] + 1;
|
||||
|
||||
SVfloat (ent, waterlevel) = 0;
|
||||
SVfloat (ent, watertype) = CONTENTS_EMPTY;
|
||||
cont = SV_PointContents (point);
|
||||
if (cont <= CONTENTS_WATER) {
|
||||
SVfloat (ent, watertype) = cont;
|
||||
SVfloat (ent, waterlevel) = 1;
|
||||
point[2] = SVvector (ent, origin)[2] + (SVvector (ent, mins)[2] +
|
||||
SVvector (ent, maxs)[2]) * 0.5;
|
||||
cont = SV_PointContents (point);
|
||||
if (cont <= CONTENTS_WATER) {
|
||||
SVfloat (ent, waterlevel) = 2;
|
||||
point[2] = SVvector (ent, origin)[2] + SVvector (ent, view_ofs)[2];
|
||||
cont = SV_PointContents (point);
|
||||
if (cont <= CONTENTS_WATER)
|
||||
SVfloat (ent, waterlevel) = 3;
|
||||
}
|
||||
}
|
||||
|
||||
return SVfloat (ent, waterlevel) > 1;
|
||||
}
|
||||
|
||||
void
|
||||
SV_WallFriction (edict_t *ent, trace_t *trace)
|
||||
{
|
||||
float d, i;
|
||||
vec3_t forward, right, up, into, side;
|
||||
|
||||
AngleVectors (SVvector (ent, v_angle), forward, right, up);
|
||||
d = DotProduct (trace->plane.normal, forward);
|
||||
|
||||
d += 0.5;
|
||||
if (d >= 0)
|
||||
return;
|
||||
|
||||
// cut the tangential velocity
|
||||
i = DotProduct (trace->plane.normal, SVvector (ent, velocity));
|
||||
VectorScale (trace->plane.normal, i, into);
|
||||
VectorSubtract (SVvector (ent, velocity), into, side);
|
||||
|
||||
SVvector (ent, velocity)[0] = side[0] * (1 + d);
|
||||
SVvector (ent, velocity)[1] = side[1] * (1 + d);
|
||||
}
|
||||
|
||||
/*
|
||||
SV_TryUnstick
|
||||
|
||||
Player has come to a dead stop, possibly due to the problem with limited
|
||||
float precision at some angle joins in the BSP hull.
|
||||
|
||||
Try fixing by pushing one pixel in each direction.
|
||||
|
||||
This is a hack, but in the interest of good gameplay...
|
||||
*/
|
||||
int
|
||||
SV_TryUnstick (edict_t *ent, vec3_t oldvel)
|
||||
{
|
||||
int i, clip;
|
||||
vec3_t dir, oldorg;
|
||||
trace_t steptrace;
|
||||
|
||||
VectorCopy (SVvector (ent, origin), oldorg);
|
||||
VectorCopy (vec3_origin, dir);
|
||||
|
||||
for (i = 0; i < 8; i++) {
|
||||
// try pushing a little in an axial direction
|
||||
switch (i) {
|
||||
case 0:
|
||||
dir[0] = 2;
|
||||
dir[1] = 0;
|
||||
break;
|
||||
case 1:
|
||||
dir[0] = 0;
|
||||
dir[1] = 2;
|
||||
break;
|
||||
case 2:
|
||||
dir[0] = -2;
|
||||
dir[1] = 0;
|
||||
break;
|
||||
case 3:
|
||||
dir[0] = 0;
|
||||
dir[1] = -2;
|
||||
break;
|
||||
case 4:
|
||||
dir[0] = 2;
|
||||
dir[1] = 2;
|
||||
break;
|
||||
case 5:
|
||||
dir[0] = -2;
|
||||
dir[1] = 2;
|
||||
break;
|
||||
case 6:
|
||||
dir[0] = 2;
|
||||
dir[1] = -2;
|
||||
break;
|
||||
case 7:
|
||||
dir[0] = -2;
|
||||
dir[1] = -2;
|
||||
break;
|
||||
}
|
||||
|
||||
SV_PushEntity (ent, dir);
|
||||
|
||||
// retry the original move
|
||||
SVvector (ent, velocity)[0] = oldvel[0];
|
||||
SVvector (ent, velocity)[1] = oldvel[1];
|
||||
SVvector (ent, velocity)[2] = 0;
|
||||
clip = SV_FlyMove (ent, 0.1, &steptrace);
|
||||
|
||||
if (fabs (oldorg[1] - SVvector (ent, origin)[1]) > 4
|
||||
|| fabs (oldorg[0] - SVvector (ent, origin)[0]) > 4) {
|
||||
// Con_DPrintf ("unstuck!\n");
|
||||
return clip;
|
||||
}
|
||||
// go back to the original pos and try again
|
||||
VectorCopy (oldorg, SVvector (ent, origin));
|
||||
}
|
||||
|
||||
VectorCopy (vec3_origin, SVvector (ent, velocity));
|
||||
return 7; // still not moving
|
||||
}
|
||||
|
||||
#define STEPSIZE 18
|
||||
|
||||
/*
|
||||
SV_WalkMove
|
||||
|
||||
Only used by players
|
||||
*/
|
||||
void
|
||||
SV_WalkMove (edict_t *ent)
|
||||
{
|
||||
int clip, oldonground;
|
||||
vec3_t upmove, downmove, nosteporg, nostepvel, oldorg, oldvel;
|
||||
trace_t steptrace, downtrace;
|
||||
|
||||
// do a regular slide move unless it looks like you ran into a step
|
||||
oldonground = (int) SVfloat (ent, flags) & FL_ONGROUND;
|
||||
SVfloat (ent, flags) = (int) SVfloat (ent, flags) & ~FL_ONGROUND;
|
||||
|
||||
VectorCopy (SVvector (ent, origin), oldorg);
|
||||
VectorCopy (SVvector (ent, velocity), oldvel);
|
||||
|
||||
clip = SV_FlyMove (ent, host_frametime, &steptrace);
|
||||
|
||||
if (!(clip & 2))
|
||||
return; // move didn't block on a step
|
||||
|
||||
if (!oldonground && SVfloat (ent, waterlevel) == 0)
|
||||
return; // don't stair up while jumping
|
||||
|
||||
if (SVfloat (ent, movetype) != MOVETYPE_WALK)
|
||||
return; // gibbed by a trigger
|
||||
|
||||
if (sv_nostep->int_val)
|
||||
return;
|
||||
|
||||
if ((int) SVfloat (sv_player, flags) & FL_WATERJUMP)
|
||||
return;
|
||||
|
||||
VectorCopy (SVvector (ent, origin), nosteporg);
|
||||
VectorCopy (SVvector (ent, velocity), nostepvel);
|
||||
|
||||
// try moving up and forward to go up a step
|
||||
VectorCopy (oldorg, SVvector (ent, origin)); // back to start pos
|
||||
VectorCopy (vec3_origin, upmove);
|
||||
VectorCopy (vec3_origin, downmove);
|
||||
upmove[2] = STEPSIZE;
|
||||
downmove[2] = -STEPSIZE + oldvel[2] * host_frametime;
|
||||
|
||||
// move up
|
||||
SV_PushEntity (ent, upmove); // FIXME: don't link?
|
||||
|
||||
// move forward
|
||||
SVvector (ent, velocity)[0] = oldvel[0];
|
||||
SVvector (ent, velocity)[1] = oldvel[1];
|
||||
SVvector (ent, velocity)[2] = 0;
|
||||
clip = SV_FlyMove (ent, host_frametime, &steptrace);
|
||||
|
||||
// check for stuckness, possibly due to the limited precision of floats
|
||||
// in the clipping hulls
|
||||
if (clip) {
|
||||
if (fabs (oldorg[1] - SVvector (ent, origin)[1]) < 0.03125
|
||||
&& fabs (oldorg[0] - SVvector (ent, origin)[0]) < 0.03125) {
|
||||
// stepping up didn't make any progress
|
||||
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?
|
||||
|
||||
if (downtrace.plane.normal[2] > 0.7) {
|
||||
if (SVfloat (ent, solid) == SOLID_BSP) {
|
||||
SVfloat (ent, flags) = (int) SVfloat (ent, flags) | FL_ONGROUND;
|
||||
SVfloat (ent, groundentity) = EDICT_TO_PROG (&sv_pr_state,
|
||||
downtrace.ent);
|
||||
}
|
||||
} else {
|
||||
// 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
|
||||
VectorCopy (nosteporg, SVvector (ent, origin));
|
||||
VectorCopy (nostepvel, SVvector (ent, velocity));
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
SV_Physics_Client
|
||||
|
||||
Player character actions
|
||||
*/
|
||||
void
|
||||
SV_Physics_Client (edict_t *ent, int num)
|
||||
{
|
||||
if (!svs.clients[num - 1].active)
|
||||
return; // unconnected slot
|
||||
|
||||
// call standard client pre-think
|
||||
*sv_globals.time = sv.time;
|
||||
*sv_globals.self = EDICT_TO_PROG (&sv_pr_state, ent);
|
||||
PR_ExecuteProgram (&sv_pr_state,
|
||||
sv_funcs.PlayerPreThink);
|
||||
|
||||
// do a move
|
||||
SV_CheckVelocity (ent);
|
||||
|
||||
// decide which move function to call
|
||||
switch ((int) SVfloat (ent, movetype)) {
|
||||
case MOVETYPE_NONE:
|
||||
if (!SV_RunThink (ent))
|
||||
return;
|
||||
break;
|
||||
|
||||
case MOVETYPE_WALK:
|
||||
if (!SV_RunThink (ent))
|
||||
return;
|
||||
if (!SV_CheckWater (ent) && !((int) SVfloat (ent, flags) &
|
||||
FL_WATERJUMP))
|
||||
SV_AddGravity (ent);
|
||||
SV_CheckStuck (ent);
|
||||
SV_WalkMove (ent);
|
||||
break;
|
||||
|
||||
case MOVETYPE_TOSS:
|
||||
case MOVETYPE_BOUNCE:
|
||||
SV_Physics_Toss (ent);
|
||||
break;
|
||||
|
||||
case MOVETYPE_FLY:
|
||||
if (!SV_RunThink (ent))
|
||||
return;
|
||||
SV_FlyMove (ent, host_frametime, NULL);
|
||||
break;
|
||||
|
||||
case MOVETYPE_NOCLIP:
|
||||
if (!SV_RunThink (ent))
|
||||
return;
|
||||
VectorMA (SVvector (ent, origin), host_frametime, SVvector (ent, velocity),
|
||||
SVvector (ent, origin));
|
||||
break;
|
||||
|
||||
default:
|
||||
Sys_Error ("SV_Physics_client: bad movetype %i",
|
||||
(int) SVfloat (ent, movetype));
|
||||
}
|
||||
|
||||
// call standard player post-think
|
||||
SV_LinkEdict (ent, true);
|
||||
|
||||
*sv_globals.time = sv.time;
|
||||
*sv_globals.self = EDICT_TO_PROG (&sv_pr_state, ent);
|
||||
PR_ExecuteProgram (&sv_pr_state,
|
||||
sv_funcs.PlayerPostThink);
|
||||
}
|
||||
|
||||
/*
|
||||
SV_Physics_None
|
||||
|
||||
|
|
@ -882,9 +578,9 @@ SV_Physics_Noclip (edict_t *ent)
|
|||
if (!SV_RunThink (ent))
|
||||
return;
|
||||
|
||||
VectorMA (SVvector (ent, angles), host_frametime,
|
||||
VectorMA (SVvector (ent, angles), sv_frametime,
|
||||
SVvector (ent, avelocity), SVvector (ent, angles));
|
||||
VectorMA (SVvector (ent, origin), host_frametime, SVvector (ent, velocity),
|
||||
VectorMA (SVvector (ent, origin), sv_frametime, SVvector (ent, velocity),
|
||||
SVvector (ent, origin));
|
||||
|
||||
SV_LinkEdict (ent, false);
|
||||
|
|
@ -950,11 +646,11 @@ SV_Physics_Toss (edict_t *ent)
|
|||
SV_AddGravity (ent);
|
||||
|
||||
// move angles
|
||||
VectorMA (SVvector (ent, angles), host_frametime,
|
||||
VectorMA (SVvector (ent, angles), sv_frametime,
|
||||
SVvector (ent, avelocity), SVvector (ent, angles));
|
||||
|
||||
// move origin
|
||||
VectorScale (SVvector (ent, velocity), host_frametime, move);
|
||||
VectorScale (SVvector (ent, velocity), sv_frametime, move);
|
||||
trace = SV_PushEntity (ent, move);
|
||||
if (trace.fraction == 1)
|
||||
return;
|
||||
|
|
@ -1009,7 +705,7 @@ SV_Physics_Step (edict_t *ent)
|
|||
|
||||
SV_AddGravity (ent);
|
||||
SV_CheckVelocity (ent);
|
||||
SV_FlyMove (ent, host_frametime, NULL);
|
||||
SV_FlyMove (ent, sv_frametime, NULL);
|
||||
SV_LinkEdict (ent, true);
|
||||
|
||||
if ((int) SVfloat (ent, flags) & FL_ONGROUND) // just hit ground
|
||||
|
|
@ -1025,22 +721,53 @@ SV_Physics_Step (edict_t *ent)
|
|||
}
|
||||
|
||||
void
|
||||
SV_Physics (void)
|
||||
SV_ProgStartFrame (void)
|
||||
{
|
||||
int i;
|
||||
edict_t *ent;
|
||||
|
||||
// let the progs know that a new frame has started
|
||||
*sv_globals.self =
|
||||
EDICT_TO_PROG (&sv_pr_state, sv.edicts);
|
||||
*sv_globals.other =
|
||||
EDICT_TO_PROG (&sv_pr_state, sv.edicts);
|
||||
*sv_globals.self = EDICT_TO_PROG (&sv_pr_state, sv.edicts);
|
||||
*sv_globals.other = EDICT_TO_PROG (&sv_pr_state, sv.edicts);
|
||||
*sv_globals.time = sv.time;
|
||||
PR_ExecuteProgram (&sv_pr_state, sv_funcs.StartFrame);
|
||||
}
|
||||
|
||||
// SV_CheckAllEnts ();
|
||||
void
|
||||
SV_RunEntity (edict_t *ent)
|
||||
{
|
||||
switch ((int) SVfloat (ent, movetype)) {
|
||||
case MOVETYPE_PUSH:
|
||||
SV_Physics_Pusher (ent);
|
||||
break;
|
||||
case MOVETYPE_NONE:
|
||||
SV_Physics_None (ent);
|
||||
break;
|
||||
case MOVETYPE_NOCLIP:
|
||||
SV_Physics_Noclip (ent);
|
||||
break;
|
||||
case MOVETYPE_STEP:
|
||||
SV_Physics_Step (ent);
|
||||
break;
|
||||
case MOVETYPE_TOSS:
|
||||
case MOVETYPE_BOUNCE:
|
||||
case MOVETYPE_FLY:
|
||||
case MOVETYPE_FLYMISSILE:
|
||||
SV_Physics_Toss (ent);
|
||||
break;
|
||||
default:
|
||||
Sys_Error ("SV_Physics: bad movetype %i",
|
||||
(int) SVfloat (ent, movetype));
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
SV_Physics (void)
|
||||
{
|
||||
edict_t *ent;
|
||||
int i;
|
||||
|
||||
SV_ProgStartFrame ();
|
||||
|
||||
// treat each object in turn
|
||||
// even the world gets a chance to think
|
||||
ent = sv.edicts;
|
||||
for (i = 0; i < sv.num_edicts; i++, ent = NEXT_EDICT (&sv_pr_state, ent)) {
|
||||
if (ent->free)
|
||||
|
|
@ -1050,28 +777,15 @@ SV_Physics (void)
|
|||
SV_LinkEdict (ent, true); // force retouch even for stationary
|
||||
}
|
||||
|
||||
if (i > 0 && i <= svs.maxclients)
|
||||
if (i > 0 && i <= svs.maxclients) {
|
||||
SV_Physics_Client (ent, i);
|
||||
else if (SVfloat (ent, movetype) == MOVETYPE_PUSH)
|
||||
SV_Physics_Pusher (ent);
|
||||
else if (SVfloat (ent, movetype) == MOVETYPE_NONE)
|
||||
SV_Physics_None (ent);
|
||||
else if (SVfloat (ent, movetype) == MOVETYPE_NOCLIP)
|
||||
SV_Physics_Noclip (ent);
|
||||
else if (SVfloat (ent, movetype) == MOVETYPE_STEP)
|
||||
SV_Physics_Step (ent);
|
||||
else if (SVfloat (ent, movetype) == MOVETYPE_TOSS
|
||||
|| SVfloat (ent, movetype) == MOVETYPE_BOUNCE
|
||||
|| SVfloat (ent, movetype) == MOVETYPE_FLY
|
||||
|| SVfloat (ent, movetype) == MOVETYPE_FLYMISSILE)
|
||||
SV_Physics_Toss (ent);
|
||||
else
|
||||
Sys_Error ("SV_Physics: bad movetype %i",
|
||||
(int) SVfloat (ent, movetype));
|
||||
continue;
|
||||
}
|
||||
SV_RunEntity (ent);
|
||||
}
|
||||
|
||||
if (*sv_globals.force_retouch)
|
||||
(*sv_globals.force_retouch)--;
|
||||
|
||||
sv.time += host_frametime;
|
||||
sv.time += sv_frametime;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -483,7 +483,7 @@ void SV_FlushSignon (void);
|
|||
void SV_ProgStartFrame (void);
|
||||
void SV_Physics (void);
|
||||
void SV_CheckVelocity (struct edict_s *ent);
|
||||
void SV_AddGravity (struct edict_s *ent, float scale);
|
||||
void SV_AddGravity (struct edict_s *ent);
|
||||
qboolean SV_RunThink (struct edict_s *ent);
|
||||
void SV_Physics_Toss (struct edict_s *ent);
|
||||
void SV_RunNewmis (void);
|
||||
|
|
|
|||
|
|
@ -31,6 +31,7 @@ static const char rcsid[] =
|
|||
# include "config.h"
|
||||
#endif
|
||||
|
||||
#include "QF/console.h"
|
||||
#include "QF/cvar.h"
|
||||
#include "QF/sys.h"
|
||||
|
||||
|
|
@ -90,39 +91,46 @@ SV_CheckAllEnts (void)
|
|||
continue;
|
||||
|
||||
if (SV_TestEntityPosition (check))
|
||||
SV_Printf ("entity in invalid position\n");
|
||||
Con_Printf ("entity in invalid position\n");
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
SV_CheckVelocity (edict_t *ent)
|
||||
{
|
||||
float wishspeed; // 1999-10-18 SV_MAXVELOCITY fix by Maddes
|
||||
#if 0
|
||||
float wishspeed;
|
||||
#endif
|
||||
int i;
|
||||
|
||||
// bound velocity
|
||||
for (i = 0; i < 3; i++) {
|
||||
if (IS_NAN (SVvector (ent, velocity)[i])) {
|
||||
SV_Printf ("Got a NaN velocity on %s\n",
|
||||
Con_Printf ("Got a NaN velocity on %s\n",
|
||||
PR_GetString (&sv_pr_state, SVstring (ent,
|
||||
classname)));
|
||||
SVvector (ent, velocity)[i] = 0;
|
||||
}
|
||||
if (IS_NAN (SVvector (ent, origin)[i])) {
|
||||
SV_Printf ("Got a NaN origin on %s\n",
|
||||
Con_Printf ("Got a NaN origin on %s\n",
|
||||
PR_GetString (&sv_pr_state, SVstring (ent,
|
||||
classname)));
|
||||
SVvector (ent, origin)[i] = 0;
|
||||
}
|
||||
#if 1
|
||||
if (SVvector (ent, velocity)[i] > sv_maxvelocity->value)
|
||||
SVvector (ent, velocity)[i] = sv_maxvelocity->value;
|
||||
else if (SVvector (ent, velocity)[i] < -sv_maxvelocity->value)
|
||||
SVvector (ent, velocity)[i] = -sv_maxvelocity->value;
|
||||
#endif
|
||||
}
|
||||
|
||||
// 1999-10-18 SV_MAXVELOCITY fix by Maddes start
|
||||
#if 0
|
||||
wishspeed = Length (SVvector (ent, velocity));
|
||||
if (wishspeed > sv_maxvelocity->value) {
|
||||
VectorScale (SVvector (ent, velocity), sv_maxvelocity->value /
|
||||
wishspeed, SVvector (ent, velocity));
|
||||
}
|
||||
// 1999-10-18 SV_MAXVELOCITY fix by Maddes end
|
||||
#endif
|
||||
}
|
||||
|
||||
/*
|
||||
|
|
@ -277,8 +285,7 @@ SV_FlyMove (edict_t *ent, float time, trace_t *steptrace)
|
|||
|
||||
if (trace.plane.normal[2] > 0.7) {
|
||||
blocked |= 1; // floor
|
||||
if ((SVfloat (trace.ent, solid) == SOLID_BSP)
|
||||
|| (SVfloat (trace.ent, movetype) == MOVETYPE_PPUSH)) {
|
||||
if (SVfloat (trace.ent, solid) == SOLID_BSP) {
|
||||
SVfloat (ent, flags) = (int) SVfloat (ent, flags) |
|
||||
FL_ONGROUND;
|
||||
SVentity (ent, groundentity) = EDICT_TO_PROG (&sv_pr_state,
|
||||
|
|
@ -343,9 +350,9 @@ SV_FlyMove (edict_t *ent, float time, trace_t *steptrace)
|
|||
}
|
||||
|
||||
void
|
||||
SV_AddGravity (edict_t *ent, float scale)
|
||||
SV_AddGravity (edict_t *ent)
|
||||
{
|
||||
SVvector (ent, velocity)[2] -= scale * movevars.gravity * sv_frametime;
|
||||
SVvector (ent, velocity)[2] -= movevars.gravity * sv_frametime;
|
||||
}
|
||||
|
||||
/* PUSHMOVE */
|
||||
|
|
@ -387,17 +394,15 @@ SV_PushEntity (edict_t *ent, vec3_t push)
|
|||
qboolean
|
||||
SV_Push (edict_t *pusher, vec3_t move)
|
||||
{
|
||||
float solid_save; // for Lord Havoc's SOLID_BSP fix --KB
|
||||
float solid_save;
|
||||
int num_moved, i, e;
|
||||
edict_t *check, *block;
|
||||
edict_t *moved_edict[MAX_EDICTS];
|
||||
vec3_t mins, maxs, pushorig;
|
||||
vec3_t moved_from[MAX_EDICTS];
|
||||
|
||||
for (i = 0; i < 3; i++) {
|
||||
mins[i] = SVvector (pusher, absmin)[i] + move[i];
|
||||
maxs[i] = SVvector (pusher, absmax)[i] + move[i];
|
||||
}
|
||||
VectorAdd (SVvector (pusher, absmin), move, mins);
|
||||
VectorAdd (SVvector (pusher, absmax), move, maxs);
|
||||
|
||||
VectorCopy (SVvector (pusher, origin), pushorig);
|
||||
|
||||
|
|
@ -408,28 +413,27 @@ SV_Push (edict_t *pusher, vec3_t move)
|
|||
// see if any solid entities are inside the final position
|
||||
num_moved = 0;
|
||||
check = NEXT_EDICT (&sv_pr_state, sv.edicts);
|
||||
for (e = 1; e < sv.num_edicts; e++, check = NEXT_EDICT (&sv_pr_state,
|
||||
check)) {
|
||||
for (e = 1; e < sv.num_edicts;
|
||||
e++, check = NEXT_EDICT (&sv_pr_state, check)) {
|
||||
if (check->free)
|
||||
continue;
|
||||
if (SVfloat (check, movetype) == MOVETYPE_PUSH
|
||||
|| SVfloat (check, movetype) == MOVETYPE_NONE
|
||||
|| SVfloat (check, movetype) == MOVETYPE_PPUSH
|
||||
|| SVfloat (check, movetype) == MOVETYPE_NOCLIP) continue;
|
||||
|| SVfloat (check, movetype) == MOVETYPE_NOCLIP)
|
||||
continue;
|
||||
|
||||
// Don't assume SOLID_BSP ! --KB
|
||||
solid_save = SVfloat (pusher, solid);
|
||||
SVfloat (pusher, solid) = SOLID_NOT;
|
||||
block = SV_TestEntityPosition (check);
|
||||
// SVfloat (pusher, solid) = SOLID_BSP;
|
||||
SVfloat (pusher, solid) = solid_save;
|
||||
if (block)
|
||||
continue;
|
||||
|
||||
// if the entity is standing on the pusher, it will definately be moved
|
||||
if (!(((int) SVfloat (check, flags) & FL_ONGROUND)
|
||||
&& PROG_TO_EDICT (&sv_pr_state, SVentity (check, groundentity))
|
||||
== pusher)) {
|
||||
&& PROG_TO_EDICT (&sv_pr_state,
|
||||
SVentity (check, groundentity)) == pusher)) {
|
||||
// check is NOT standing on pusher
|
||||
if (SVvector (check, absmin)[0] >= maxs[0]
|
||||
|| SVvector (check, absmin)[1] >= maxs[1]
|
||||
|| SVvector (check, absmin)[2] >= maxs[2]
|
||||
|
|
@ -455,8 +459,8 @@ SV_Push (edict_t *pusher, vec3_t move)
|
|||
continue;
|
||||
}
|
||||
// if it is ok to leave in the old position, do it
|
||||
VectorSubtract (SVvector (check, origin), move, SVvector (check,
|
||||
origin));
|
||||
VectorSubtract (SVvector (check, origin), move,
|
||||
SVvector (check, origin));
|
||||
block = SV_TestEntityPosition (check);
|
||||
if (!block) {
|
||||
num_moved--;
|
||||
|
|
@ -467,8 +471,8 @@ SV_Push (edict_t *pusher, vec3_t move)
|
|||
SV_LinkEdict (check, false);
|
||||
continue;
|
||||
}
|
||||
if (SVfloat (check, solid) == SOLID_NOT || SVfloat (check, solid) ==
|
||||
SOLID_TRIGGER) { // corpse
|
||||
if (SVfloat (check, solid) == SOLID_NOT
|
||||
|| SVfloat (check, solid) == SOLID_TRIGGER) { // corpse
|
||||
SVvector (check, mins)[0] = SVvector (check, mins)[1] = 0;
|
||||
VectorCopy (SVvector (check, mins), SVvector (check, maxs));
|
||||
SV_LinkEdict (check, false);
|
||||
|
|
@ -492,14 +496,12 @@ SV_Push (edict_t *pusher, vec3_t move)
|
|||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
void
|
||||
SV_PushMove (edict_t *pusher, float movetime)
|
||||
{
|
||||
int i;
|
||||
vec3_t move;
|
||||
|
||||
if (VectorIsZero (SVvector (pusher, velocity))) {
|
||||
|
|
@ -507,8 +509,7 @@ SV_PushMove (edict_t *pusher, float movetime)
|
|||
return;
|
||||
}
|
||||
|
||||
for (i = 0; i < 3; i++)
|
||||
move[i] = SVvector (pusher, velocity)[i] * movetime;
|
||||
VectorScale (SVvector (pusher, velocity), movetime, move);
|
||||
|
||||
if (SV_Push (pusher, move))
|
||||
SVfloat (pusher, ltime) += movetime;
|
||||
|
|
@ -517,7 +518,8 @@ SV_PushMove (edict_t *pusher, float movetime)
|
|||
void
|
||||
SV_Physics_Pusher (edict_t *ent)
|
||||
{
|
||||
float movetime, oldltime, thinktime, l;
|
||||
float movetime, oldltime, thinktime;
|
||||
float l;
|
||||
vec3_t oldorg, move;
|
||||
|
||||
oldltime = SVfloat (ent, ltime);
|
||||
|
|
@ -548,7 +550,7 @@ SV_Physics_Pusher (edict_t *ent)
|
|||
|
||||
l = Length (move);
|
||||
if (l > 1.0 / 64) {
|
||||
// SV_Printf ("**** snap: %f\n", Length (l));
|
||||
// Con_Printf ("**** snap: %f\n", Length (l));
|
||||
VectorCopy (oldorg, SVvector (ent, origin));
|
||||
SV_Push (ent, move);
|
||||
}
|
||||
|
|
@ -648,7 +650,7 @@ SV_Physics_Toss (edict_t *ent)
|
|||
// add gravity
|
||||
if (SVfloat (ent, movetype) != MOVETYPE_FLY
|
||||
&& SVfloat (ent, movetype) != MOVETYPE_FLYMISSILE)
|
||||
SV_AddGravity (ent, 1.0);
|
||||
SV_AddGravity (ent);
|
||||
|
||||
// move angles
|
||||
VectorMA (SVvector (ent, angles), sv_frametime,
|
||||
|
|
@ -709,7 +711,7 @@ SV_Physics_Step (edict_t *ent)
|
|||
else
|
||||
hitsound = false;
|
||||
|
||||
SV_AddGravity (ent, 1.0);
|
||||
SV_AddGravity (ent);
|
||||
SV_CheckVelocity (ent);
|
||||
SV_FlyMove (ent, sv_frametime, NULL);
|
||||
SV_LinkEdict (ent, true);
|
||||
|
|
@ -726,110 +728,6 @@ SV_Physics_Step (edict_t *ent)
|
|||
SV_CheckWaterTransition (ent);
|
||||
}
|
||||
|
||||
void
|
||||
SV_PPushMove (edict_t *pusher, float movetime) // player push
|
||||
{
|
||||
int oldsolid, e, i;
|
||||
edict_t *check;
|
||||
trace_t trace;
|
||||
vec3_t maxs, mins, move;
|
||||
|
||||
SV_CheckVelocity (pusher);
|
||||
for (i = 0; i < 3; i++) {
|
||||
move[i] = SVvector (pusher, velocity)[i] * movetime;
|
||||
mins[i] = SVvector (pusher, absmin)[i] + move[i];
|
||||
maxs[i] = SVvector (pusher, absmax)[i] + move[i];
|
||||
}
|
||||
|
||||
VectorCopy (SVvector (pusher, origin), SVvector (pusher, oldorigin)); // Backup origin
|
||||
trace =
|
||||
SV_Move (SVvector (pusher, origin), SVvector (pusher, mins), SVvector (pusher, maxs), move,
|
||||
MOVE_NOMONSTERS, pusher);
|
||||
|
||||
if (trace.fraction == 1) {
|
||||
VectorCopy (SVvector (pusher, origin), SVvector (pusher, oldorigin));
|
||||
// Revert
|
||||
return;
|
||||
}
|
||||
|
||||
|
||||
VectorAdd (SVvector (pusher, origin), move, SVvector (pusher, origin));
|
||||
// Move
|
||||
SV_LinkEdict (pusher, false);
|
||||
SVfloat (pusher, ltime) += movetime;
|
||||
|
||||
oldsolid = SVfloat (pusher, solid);
|
||||
|
||||
check = NEXT_EDICT (&sv_pr_state, sv.edicts);
|
||||
for (e = 1; e < sv.num_edicts; e++, check = NEXT_EDICT (&sv_pr_state,
|
||||
check)) {
|
||||
if (check->free) // What entity?
|
||||
continue;
|
||||
|
||||
// Stage 1: Is it in contact with me?
|
||||
if (!SV_TestEntityPosition (check)) // Nope
|
||||
continue;
|
||||
|
||||
// Stage 2: Is it a player we can push?
|
||||
if (SVfloat (check, movetype) == MOVETYPE_WALK) {
|
||||
SV_Printf ("Pusher encountered a player\n"); // Yes!@#!@
|
||||
SVfloat (pusher, solid) = SOLID_NOT;
|
||||
SV_PushEntity (check, move);
|
||||
SVfloat (pusher, solid) = oldsolid;
|
||||
continue;
|
||||
}
|
||||
// Stage 3: No.. Is it something that blocks us?
|
||||
if (SVvector (check, mins)[0] == SVvector (check, maxs)[0])
|
||||
continue;
|
||||
if (SVfloat (check, solid) == SOLID_NOT || SVfloat (check, solid) ==
|
||||
SOLID_TRIGGER)
|
||||
continue;
|
||||
|
||||
// Stage 4: Yes, it must be. Fail the move.
|
||||
VectorCopy (SVvector (pusher, origin), SVvector (pusher, oldorigin));
|
||||
// Revert
|
||||
if (SVfunc (pusher, blocked)) { // Blocked func?
|
||||
*sv_globals.self = EDICT_TO_PROG (&sv_pr_state, pusher);
|
||||
*sv_globals.other = EDICT_TO_PROG (&sv_pr_state, check);
|
||||
PR_ExecuteProgram (&sv_pr_state, SVfunc (pusher, blocked));
|
||||
}
|
||||
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
SV_Physics_PPusher (edict_t *ent)
|
||||
{
|
||||
float movetime, oldltime, thinktime;
|
||||
// float l;
|
||||
|
||||
oldltime = SVfloat (ent, ltime);
|
||||
|
||||
thinktime = SVfloat (ent, nextthink);
|
||||
if (thinktime < SVfloat (ent, ltime) + sv_frametime) {
|
||||
movetime = thinktime - SVfloat (ent, ltime);
|
||||
if (movetime < 0)
|
||||
movetime = 0;
|
||||
} else
|
||||
movetime = sv_frametime;
|
||||
|
||||
// if (movetime)
|
||||
// {
|
||||
SV_PPushMove (ent, 0.0009); // advances SVfloat (ent, ltime) if not blocked
|
||||
// }
|
||||
|
||||
if (thinktime > oldltime && thinktime <= SVfloat (ent, ltime)) {
|
||||
SVfloat (ent, nextthink) = 0;
|
||||
*sv_globals.time = sv.time;
|
||||
*sv_globals.self = EDICT_TO_PROG (&sv_pr_state, ent);
|
||||
*sv_globals.other = EDICT_TO_PROG (&sv_pr_state, sv.edicts);
|
||||
PR_ExecuteProgram (&sv_pr_state, SVfunc (ent, think));
|
||||
if (ent->free)
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
SV_ProgStartFrame (void)
|
||||
{
|
||||
|
|
@ -851,9 +749,6 @@ SV_RunEntity (edict_t *ent)
|
|||
case MOVETYPE_PUSH:
|
||||
SV_Physics_Pusher (ent);
|
||||
break;
|
||||
case MOVETYPE_PPUSH:
|
||||
SV_Physics_PPusher (ent);
|
||||
break;
|
||||
case MOVETYPE_NONE:
|
||||
SV_Physics_None (ent);
|
||||
break;
|
||||
|
|
@ -870,8 +765,8 @@ SV_RunEntity (edict_t *ent)
|
|||
SV_Physics_Toss (ent);
|
||||
break;
|
||||
default:
|
||||
Sys_Error ("SV_Physics: bad movetype %i", (int) SVfloat (ent,
|
||||
movetype));
|
||||
Sys_Error ("SV_Physics: bad movetype %i",
|
||||
(int) SVfloat (ent, movetype));
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -915,8 +810,9 @@ SV_Physics (void)
|
|||
if (ent->free)
|
||||
continue;
|
||||
|
||||
if (*sv_globals.force_retouch)
|
||||
if (*sv_globals.force_retouch) {
|
||||
SV_LinkEdict (ent, true); // force retouch even for stationary
|
||||
}
|
||||
|
||||
if (i > 0 && i <= MAX_CLIENTS)
|
||||
continue; // clients are run directly from packets
|
||||
|
|
|
|||
Loading…
Reference in a new issue