X-Git-Url: http://git.xonotic.org/?p=xonotic%2Fdarkplaces.git;a=blobdiff_plain;f=sv_move.c;h=0699180d12f6e3bcdd1460723a6a157ff346d9e8;hp=dd71097051c91d188ac44f3a00c23dcb63569e4f;hb=7c62e71683de5672379f033664504eb10d431544;hpb=08489c3f40fec505da1c0af823e388a5f53a1560 diff --git a/sv_move.c b/sv_move.c index dd710970..0699180d 100644 --- a/sv_move.c +++ b/sv_move.c @@ -8,7 +8,7 @@ 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. +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. @@ -20,6 +20,7 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. // sv_move.c -- monster movement #include "quakedef.h" +#include "prvm_cmds.h" /* ============= @@ -32,15 +33,16 @@ is not a staircase. */ int c_yes, c_no; -qboolean SV_CheckBottom (edict_t *ent) +qbool SV_CheckBottom (prvm_edict_t *ent) { + prvm_prog_t *prog = SVVM_prog; vec3_t mins, maxs, start, stop; trace_t trace; int x, y; float mid, bottom; - VectorAdd (ent->v.origin, ent->v.mins, mins); - VectorAdd (ent->v.origin, ent->v.maxs, maxs); + VectorAdd (PRVM_serveredictvector(ent, origin), PRVM_serveredictvector(ent, mins), mins); + VectorAdd (PRVM_serveredictvector(ent, origin), PRVM_serveredictvector(ent, maxs), maxs); // if all of the points under the corners are solid world, don't bother // with the tougher checks @@ -51,7 +53,7 @@ qboolean SV_CheckBottom (edict_t *ent) { start[0] = x ? maxs[0] : mins[0]; start[1] = y ? maxs[1] : mins[1]; - if (Mod_PointInLeaf(start, sv.worldmodel)->contents != CONTENTS_SOLID) + if (!(SV_PointSuperContents(start) & (SUPERCONTENTS_SOLID | SUPERCONTENTS_BODY))) goto realcheck; } @@ -69,7 +71,7 @@ realcheck: start[0] = stop[0] = (mins[0] + maxs[0])*0.5; start[1] = stop[1] = (mins[1] + maxs[1])*0.5; stop[2] = start[2] - 2*sv_stepheight.value; - trace = SV_Move (start, vec3_origin, vec3_origin, stop, MOVE_NOMONSTERS, ent); + trace = SV_TraceLine(start, stop, MOVE_NOMONSTERS, ent, SV_GenericHitSuperContentsMask(ent), 0, 0, collision_extendmovelength.value); if (trace.fraction == 1.0) return false; @@ -82,7 +84,7 @@ realcheck: start[0] = stop[0] = x ? maxs[0] : mins[0]; start[1] = stop[1] = y ? maxs[1] : mins[1]; - trace = SV_Move (start, vec3_origin, vec3_origin, stop, MOVE_NOMONSTERS, ent); + trace = SV_TraceLine(start, stop, MOVE_NOMONSTERS, ent, SV_GenericHitSuperContentsMask(ent), 0, 0, collision_extendmovelength.value); if (trace.fraction != 1.0 && trace.endpos[2] > bottom) bottom = trace.endpos[2]; @@ -101,53 +103,64 @@ SV_movestep Called by monster program code. The move will be adjusted for slopes and stairs, but if the move isn't -possible, no move is done, false is returned, and -pr_global_struct->trace_normal is set to the normal of the blocking wall +possible, no move is done and false is returned ============= */ -qboolean SV_movestep (edict_t *ent, vec3_t move, qboolean relink) +qbool SV_movestep (prvm_edict_t *ent, vec3_t move, qbool relink, qbool noenemy, qbool settrace) { + prvm_prog_t *prog = SVVM_prog; float dz; - vec3_t oldorg, neworg, end, traceendpos; + vec3_t oldorg, neworg, end, traceendpos, entorigin, entmins, entmaxs; trace_t trace; int i; - edict_t *enemy; + prvm_edict_t *enemy; // try the move - VectorCopy (ent->v.origin, oldorg); - VectorAdd (ent->v.origin, move, neworg); + VectorCopy (PRVM_serveredictvector(ent, origin), oldorg); + VectorAdd (PRVM_serveredictvector(ent, origin), move, neworg); + VectorCopy(PRVM_serveredictvector(ent, mins), entmins); + VectorCopy(PRVM_serveredictvector(ent, maxs), entmaxs); // flying monsters don't step up - if ( (int)ent->v.flags & (FL_SWIM | FL_FLY) ) + if ( (int)PRVM_serveredictfloat(ent, flags) & (FL_SWIM | FL_FLY) ) { // try one move with vertical motion, then one without for (i=0 ; i<2 ; i++) { - VectorAdd (ent->v.origin, move, neworg); - enemy = PROG_TO_EDICT(ent->v.enemy); - if (i == 0 && enemy != sv.edicts) + VectorAdd (PRVM_serveredictvector(ent, origin), move, neworg); + if (noenemy) + enemy = prog->edicts; + else { - dz = ent->v.origin[2] - PROG_TO_EDICT(ent->v.enemy)->v.origin[2]; - if (dz > 40) - neworg[2] -= 8; - if (dz < 30) - neworg[2] += 8; + enemy = PRVM_PROG_TO_EDICT(PRVM_serveredictedict(ent, enemy)); + if (i == 0 && enemy != prog->edicts) + { + dz = PRVM_serveredictvector(ent, origin)[2] - PRVM_serveredictvector(enemy, origin)[2]; + if (dz > 40) + neworg[2] -= 8; + if (dz < 30) + neworg[2] += 8; + } } - trace = SV_Move (ent->v.origin, ent->v.mins, ent->v.maxs, neworg, MOVE_NORMAL, ent); + VectorCopy(PRVM_serveredictvector(ent, origin), entorigin); + trace = SV_TraceBox(entorigin, entmins, entmaxs, neworg, MOVE_NORMAL, ent, SV_GenericHitSuperContentsMask(ent), 0, 0, collision_extendmovelength.value); if (trace.fraction == 1) { VectorCopy(trace.endpos, traceendpos); - if ( ((int)ent->v.flags & FL_SWIM) && Mod_PointInLeaf(traceendpos, sv.worldmodel)->contents == CONTENTS_EMPTY ) + if (((int)PRVM_serveredictfloat(ent, flags) & FL_SWIM) && !(SV_PointSuperContents(traceendpos) & SUPERCONTENTS_LIQUIDSMASK)) return false; // swim monster left water - VectorCopy (traceendpos, ent->v.origin); + VectorCopy (traceendpos, PRVM_serveredictvector(ent, origin)); if (relink) - SV_LinkEdict (ent, true); + { + SV_LinkEdict(ent); + SV_LinkEdict_TouchAreaGrid(ent); + } return true; } - if (enemy == sv.edicts) + if (enemy == prog->edicts) break; } @@ -159,27 +172,27 @@ qboolean SV_movestep (edict_t *ent, vec3_t move, qboolean relink) VectorCopy (neworg, end); end[2] -= sv_stepheight.value*2; - trace = SV_Move (neworg, ent->v.mins, ent->v.maxs, end, MOVE_NORMAL, ent); - - if (trace.allsolid) - return false; + trace = SV_TraceBox(neworg, entmins, entmaxs, end, MOVE_NORMAL, ent, SV_GenericHitSuperContentsMask(ent), 0, 0, collision_extendmovelength.value); if (trace.startsolid) { neworg[2] -= sv_stepheight.value; - trace = SV_Move (neworg, ent->v.mins, ent->v.maxs, end, MOVE_NORMAL, ent); - if (trace.allsolid || trace.startsolid) + trace = SV_TraceBox(neworg, entmins, entmaxs, end, MOVE_NORMAL, ent, SV_GenericHitSuperContentsMask(ent), 0, 0, collision_extendmovelength.value); + if (trace.startsolid) return false; } if (trace.fraction == 1) { // if monster had the ground pulled out, go ahead and fall - if ( (int)ent->v.flags & FL_PARTIALGROUND ) + if ( (int)PRVM_serveredictfloat(ent, flags) & FL_PARTIALGROUND ) { - VectorAdd (ent->v.origin, move, ent->v.origin); + VectorAdd (PRVM_serveredictvector(ent, origin), move, PRVM_serveredictvector(ent, origin)); if (relink) - SV_LinkEdict (ent, true); - ent->v.flags = (int)ent->v.flags & ~FL_ONGROUND; + { + SV_LinkEdict(ent); + SV_LinkEdict_TouchAreaGrid(ent); + } + PRVM_serveredictfloat(ent, flags) = (int)PRVM_serveredictfloat(ent, flags) & ~FL_ONGROUND; return true; } @@ -187,29 +200,45 @@ qboolean SV_movestep (edict_t *ent, vec3_t move, qboolean relink) } // check point traces down for dangling corners - VectorCopy (trace.endpos, ent->v.origin); - + VectorCopy (trace.endpos, PRVM_serveredictvector(ent, origin)); + if (!SV_CheckBottom (ent)) { - if ( (int)ent->v.flags & FL_PARTIALGROUND ) + if ( (int)PRVM_serveredictfloat(ent, flags) & FL_PARTIALGROUND ) { // entity had floor mostly pulled out from underneath it // and is trying to correct if (relink) - SV_LinkEdict (ent, true); + { + SV_LinkEdict(ent); + SV_LinkEdict_TouchAreaGrid(ent); + } return true; } - VectorCopy (oldorg, ent->v.origin); + VectorCopy (oldorg, PRVM_serveredictvector(ent, origin)); return false; } - if ( (int)ent->v.flags & FL_PARTIALGROUND ) - ent->v.flags = (int)ent->v.flags & ~FL_PARTIALGROUND; + if ( (int)PRVM_serveredictfloat(ent, flags) & FL_PARTIALGROUND ) + PRVM_serveredictfloat(ent, flags) = (int)PRVM_serveredictfloat(ent, flags) & ~FL_PARTIALGROUND; + +// gameplayfix: check if reached pretty steep plane and bail + if ( ! ( (int)PRVM_serveredictfloat(ent, flags) & (FL_SWIM | FL_FLY) ) && sv_gameplayfix_nostepmoveonsteepslopes.integer ) + { + if (trace.plane.normal[ 2 ] < 0.5) + { + VectorCopy (oldorg, PRVM_serveredictvector(ent, origin)); + return false; + } + } - ent->v.groundentity = EDICT_TO_PROG(trace.ent); + PRVM_serveredictedict(ent, groundentity) = PRVM_EDICT_TO_PROG(trace.ent); // the move is ok if (relink) - SV_LinkEdict (ent, true); + { + SV_LinkEdict(ent); + SV_LinkEdict_TouchAreaGrid(ent); + } return true; } @@ -225,33 +254,35 @@ facing it. ====================== */ -void PF_changeyaw (void); -qboolean SV_StepDirection (edict_t *ent, float yaw, float dist) +static qbool SV_StepDirection (prvm_edict_t *ent, float yaw, float dist) { + prvm_prog_t *prog = SVVM_prog; vec3_t move, oldorigin; float delta; - - ent->v.ideal_yaw = yaw; - PF_changeyaw(); - + + PRVM_serveredictfloat(ent, ideal_yaw) = yaw; + VM_changeyaw(prog); + yaw = yaw*M_PI*2 / 360; move[0] = cos(yaw)*dist; move[1] = sin(yaw)*dist; move[2] = 0; - VectorCopy (ent->v.origin, oldorigin); - if (SV_movestep (ent, move, false)) + VectorCopy (PRVM_serveredictvector(ent, origin), oldorigin); + if (SV_movestep (ent, move, false, false, false)) { - delta = ent->v.angles[YAW] - ent->v.ideal_yaw; + delta = PRVM_serveredictvector(ent, angles)[YAW] - PRVM_serveredictfloat(ent, ideal_yaw); if (delta > 45 && delta < 315) { // not turned far enough, so don't take the step - VectorCopy (oldorigin, ent->v.origin); + VectorCopy (oldorigin, PRVM_serveredictvector(ent, origin)); } - SV_LinkEdict (ent, true); + SV_LinkEdict(ent); + SV_LinkEdict_TouchAreaGrid(ent); return true; } - SV_LinkEdict (ent, true); - + SV_LinkEdict(ent); + SV_LinkEdict_TouchAreaGrid(ent); + return false; } @@ -261,9 +292,10 @@ SV_FixCheckBottom ====================== */ -void SV_FixCheckBottom (edict_t *ent) +static void SV_FixCheckBottom (prvm_edict_t *ent) { - ent->v.flags = (int)ent->v.flags | FL_PARTIALGROUND; + prvm_prog_t *prog = SVVM_prog; + PRVM_serveredictfloat(ent, flags) = (int)PRVM_serveredictfloat(ent, flags) | FL_PARTIALGROUND; } @@ -275,17 +307,18 @@ SV_NewChaseDir ================ */ #define DI_NODIR -1 -void SV_NewChaseDir (edict_t *actor, edict_t *enemy, float dist) +static void SV_NewChaseDir (prvm_edict_t *actor, prvm_edict_t *enemy, float dist) { + prvm_prog_t *prog = SVVM_prog; float deltax,deltay; float d[3]; float tdir, olddir, turnaround; - olddir = ANGLEMOD((int)(actor->v.ideal_yaw/45)*45); + olddir = ANGLEMOD((int)(PRVM_serveredictfloat(actor, ideal_yaw)/45)*45); turnaround = ANGLEMOD(olddir - 180); - deltax = enemy->v.origin[0] - actor->v.origin[0]; - deltay = enemy->v.origin[1] - actor->v.origin[1]; + deltax = PRVM_serveredictvector(enemy, origin)[0] - PRVM_serveredictvector(actor, origin)[0]; + deltay = PRVM_serveredictvector(enemy, origin)[1] - PRVM_serveredictvector(actor, origin)[1]; if (deltax>10) d[1]= 0; else if (deltax<-10) @@ -306,13 +339,13 @@ void SV_NewChaseDir (edict_t *actor, edict_t *enemy, float dist) tdir = d[2] == 90 ? 45 : 315; else tdir = d[2] == 90 ? 135 : 215; - + if (tdir != turnaround && SV_StepDirection(actor, tdir, dist)) return; } // try other directions - if ( ((rand()&3) & 1) || abs(deltay)>abs(deltax)) + if ( ((rand()&3) & 1) || fabs(deltay)>fabs(deltax)) { tdir=d[1]; d[1]=d[2]; @@ -348,7 +381,7 @@ void SV_NewChaseDir (edict_t *actor, edict_t *enemy, float dist) if (turnaround != DI_NODIR && SV_StepDirection(actor, turnaround, dist) ) return; - actor->v.ideal_yaw = olddir; // can't move + PRVM_serveredictfloat(actor, ideal_yaw) = olddir; // can't move // if a bridge was pulled out from underneath a monster, it may not have // a valid standing position at all @@ -364,15 +397,15 @@ SV_CloseEnough ====================== */ -qboolean SV_CloseEnough (edict_t *ent, edict_t *goal, float dist) +static qbool SV_CloseEnough (prvm_edict_t *ent, prvm_edict_t *goal, float dist) { int i; for (i=0 ; i<3 ; i++) { - if (goal->v.absmin[i] > ent->v.absmax[i] + dist) + if (goal->priv.server->areamins[i] > ent->priv.server->areamaxs[i] + dist) return false; - if (goal->v.absmax[i] < ent->v.absmin[i] - dist) + if (goal->priv.server->areamaxs[i] < ent->priv.server->areamins[i] - dist) return false; } return true; @@ -380,32 +413,34 @@ qboolean SV_CloseEnough (edict_t *ent, edict_t *goal, float dist) /* ====================== -SV_MoveToGoal +VM_SV_MoveToGoal ====================== */ -void SV_MoveToGoal (void) +void VM_SV_MoveToGoal(prvm_prog_t *prog) { - edict_t *ent, *goal; + prvm_edict_t *ent, *goal; float dist; - ent = PROG_TO_EDICT(pr_global_struct->self); - goal = PROG_TO_EDICT(ent->v.goalentity); - dist = G_FLOAT(OFS_PARM0); + VM_SAFEPARMCOUNT(1, VM_SV_MoveToGoal); + + ent = PRVM_PROG_TO_EDICT(PRVM_serverglobaledict(self)); + goal = PRVM_PROG_TO_EDICT(PRVM_serveredictedict(ent, goalentity)); + dist = PRVM_G_FLOAT(OFS_PARM0); - if ( !( (int)ent->v.flags & (FL_ONGROUND|FL_FLY|FL_SWIM) ) ) + if ( !( (int)PRVM_serveredictfloat(ent, flags) & (FL_ONGROUND|FL_FLY|FL_SWIM) ) ) { - G_FLOAT(OFS_RETURN) = 0; + PRVM_G_FLOAT(OFS_RETURN) = 0; return; } // if the next step hits the enemy, return immediately - if ( PROG_TO_EDICT(ent->v.enemy) != sv.edicts && SV_CloseEnough (ent, goal, dist) ) + if ( PRVM_PROG_TO_EDICT(PRVM_serveredictedict(ent, enemy)) != prog->edicts && SV_CloseEnough (ent, goal, dist) ) return; // bump around... if ( (rand()&3)==1 || - !SV_StepDirection (ent, ent->v.ideal_yaw, dist)) + !SV_StepDirection (ent, PRVM_serveredictfloat(ent, ideal_yaw), dist)) { SV_NewChaseDir (ent, goal, dist); }