X-Git-Url: http://de.git.xonotic.org/?p=xonotic%2Fdarkplaces.git;a=blobdiff_plain;f=sv_phys.c;h=48af07c47b113b5b4093a4fc6078a38e60d077e3;hp=6e852ae1d70985703bd3f396f5e522bf63fbb34f;hb=6a384398c93b7e2bc1936427797909eb60094160;hpb=85c8ba9ec06127c46afc95ac0101bd154bd90fb0 diff --git a/sv_phys.c b/sv_phys.c index 6e852ae1..48af07c4 100644 --- a/sv_phys.c +++ b/sv_phys.c @@ -45,8 +45,6 @@ cvar_t sv_gravity = {"sv_gravity","800",false,true}; cvar_t sv_maxvelocity = {"sv_maxvelocity","2000"}; cvar_t sv_nostep = {"sv_nostep","0"}; -static vec3_t vec_origin = {0.0, 0.0, 0.0}; - #define MOVE_EPSILON 0.01 void SV_Physics_Toss (edict_t *ent); @@ -272,7 +270,7 @@ int SV_FlyMove (edict_t *ent, float time, trace_t *steptrace) if (trace.allsolid) { // entity is trapped in another solid - VectorCopy (vec3_origin, ent->v.velocity); + VectorClear(ent->v.velocity); return 3; } @@ -318,7 +316,7 @@ int SV_FlyMove (edict_t *ent, float time, trace_t *steptrace) // cliped to another plane if (numplanes >= MAX_CLIP_PLANES) { // this shouldn't really happen - VectorCopy (vec3_origin, ent->v.velocity); + VectorClear(ent->v.velocity); return 3; } @@ -350,7 +348,7 @@ int SV_FlyMove (edict_t *ent, float time, trace_t *steptrace) if (numplanes != 2) { // Con_Printf ("clip velocity, numplanes == %i\n",numplanes); - VectorCopy (vec3_origin, ent->v.velocity); + VectorClear(ent->v.velocity); return 7; } CrossProduct (planes[0], planes[1], dir); @@ -364,7 +362,7 @@ int SV_FlyMove (edict_t *ent, float time, trace_t *steptrace) // if (DotProduct (ent->v.velocity, primal_velocity) <= 0) { - VectorCopy (vec3_origin, ent->v.velocity); + VectorClear(ent->v.velocity); return blocked; } } @@ -443,7 +441,7 @@ SV_PushMove void SV_PushMove (edict_t *pusher, float movetime) { int i, e; - edict_t *check, *block; + edict_t *check; vec3_t mins, maxs, move; vec3_t entorig, pushorig; int num_moved; @@ -451,6 +449,24 @@ void SV_PushMove (edict_t *pusher, float movetime) vec3_t moved_from[MAX_EDICTS]; float savesolid; + switch ((int) pusher->v.solid) + { + // LordHavoc: valid pusher types + case SOLID_BSP: + case SOLID_BBOX: + case SOLID_SLIDEBOX: + case SOLID_CORPSE: // LordHavoc: this would be weird... + break; + // LordHavoc: no collisions + case SOLID_NOT: + case SOLID_TRIGGER: + VectorMA (pusher->v.origin, movetime, pusher->v.velocity, pusher->v.origin); + pusher->v.ltime += movetime; + SV_LinkEdict (pusher, false); + return; + default: + Host_Error("SV_PushMove: unrecognized solid type %f\n", pusher->v.solid); + } if (!pusher->v.velocity[0] && !pusher->v.velocity[1] && !pusher->v.velocity[2]) { pusher->v.ltime += movetime; @@ -521,7 +537,7 @@ void SV_PushMove (edict_t *pusher, float movetime) pusher->v.solid = savesolid; // was SOLID_BSP // if it is still inside the pusher, block - if (block = SV_TestEntityPosition (check)) + if (SV_TestEntityPosition (check)) { // fail the move if (check->v.mins[0] == check->v.maxs[0]) continue; @@ -539,8 +555,7 @@ void SV_PushMove (edict_t *pusher, float movetime) SV_LinkEdict (pusher, false); pusher->v.ltime -= movetime; - // if the pusher has a "blocked" function, call it - // otherwise, just stay in place until the obstacle is gone + // if the pusher has a "blocked" function, call it, otherwise just stay in place until the obstacle is gone if (pusher->v.blocked) { pr_global_struct->self = EDICT_TO_PROG(pusher); @@ -549,6 +564,7 @@ void SV_PushMove (edict_t *pusher, float movetime) } // move back any entities we already moved + num_moved--; // LordHavoc: pop off check, because it was already restored for (i=0 ; iv.origin); @@ -571,16 +587,35 @@ SV_PushRotate void SV_PushRotate (edict_t *pusher, float movetime) { int i, e; - edict_t *check, *block; + edict_t *check; vec3_t move, a, amove; - vec3_t entorig, pushorig; + vec3_t entorigin, entangles, pushorigin, pushangles; int num_moved; edict_t *moved_edict[MAX_EDICTS]; vec3_t moved_from[MAX_EDICTS]; + vec3_t angled_from[MAX_EDICTS]; vec3_t org, org2; vec3_t forward, right, up; float savesolid; + switch ((int) pusher->v.solid) + { + // LordHavoc: valid pusher types + case SOLID_BSP: + case SOLID_BBOX: + case SOLID_SLIDEBOX: + case SOLID_CORPSE: // LordHavoc: this would be weird... + break; + // LordHavoc: no collisions + case SOLID_NOT: + case SOLID_TRIGGER: + VectorMA (pusher->v.angles, movetime, pusher->v.avelocity, pusher->v.angles); + pusher->v.ltime += movetime; + SV_LinkEdict (pusher, false); + return; + default: + Host_Error("SV_PushRotate: unrecognized solid type %f\n", pusher->v.solid); + } if (!pusher->v.avelocity[0] && !pusher->v.avelocity[1] && !pusher->v.avelocity[2]) { pusher->v.ltime += movetime; @@ -590,10 +625,11 @@ void SV_PushRotate (edict_t *pusher, float movetime) for (i=0 ; i<3 ; i++) amove[i] = pusher->v.avelocity[i] * movetime; - VectorSubtract (vec3_origin, amove, a); + VectorNegate (amove, a); AngleVectors (a, forward, right, up); - VectorCopy (pusher->v.angles, pushorig); + VectorCopy (pusher->v.origin, pushorigin); + VectorCopy (pusher->v.angles, pushangles); // move the pusher to it's final position @@ -610,21 +646,20 @@ void SV_PushRotate (edict_t *pusher, float movetime) if (check->free) continue; if (check->v.movetype == MOVETYPE_PUSH - || check->v.movetype == MOVETYPE_NONE - || check->v.movetype == MOVETYPE_FOLLOW - || check->v.movetype == MOVETYPE_NOCLIP) + || check->v.movetype == MOVETYPE_NONE + || check->v.movetype == MOVETYPE_FOLLOW + || check->v.movetype == MOVETYPE_NOCLIP) continue; // if the entity is standing on the pusher, it will definately be moved - if ( ! ( ((int)check->v.flags & FL_ONGROUND) - && PROG_TO_EDICT(check->v.groundentity) == pusher) ) + if (!(((int)check->v.flags & FL_ONGROUND) && PROG_TO_EDICT(check->v.groundentity) == pusher)) { - if ( check->v.absmin[0] >= pusher->v.absmax[0] - || check->v.absmin[1] >= pusher->v.absmax[1] - || check->v.absmin[2] >= pusher->v.absmax[2] - || check->v.absmax[0] <= pusher->v.absmin[0] - || check->v.absmax[1] <= pusher->v.absmin[1] - || check->v.absmax[2] <= pusher->v.absmin[2] ) + if (check->v.absmin[0] >= pusher->v.absmax[0] + || check->v.absmin[1] >= pusher->v.absmax[1] + || check->v.absmin[2] >= pusher->v.absmax[2] + || check->v.absmax[0] <= pusher->v.absmin[0] + || check->v.absmax[1] <= pusher->v.absmin[1] + || check->v.absmax[2] <= pusher->v.absmin[2]) continue; // see if the ent's bbox is inside the pusher's final position @@ -636,8 +671,10 @@ void SV_PushRotate (edict_t *pusher, float movetime) if (check->v.movetype != MOVETYPE_WALK) check->v.flags = (int)check->v.flags & ~FL_ONGROUND; - VectorCopy (check->v.origin, entorig); + VectorCopy (check->v.origin, entorigin); VectorCopy (check->v.origin, moved_from[num_moved]); + VectorCopy (check->v.angles, entangles); + VectorCopy (check->v.angles, angled_from[num_moved]); moved_edict[num_moved] = check; num_moved++; @@ -654,9 +691,10 @@ void SV_PushRotate (edict_t *pusher, float movetime) SV_PushEntity (check, move); pusher->v.solid = savesolid; // LordHavoc: restore to correct solid type + VectorAdd (check->v.angles, amove, check->v.angles); + // if it is still inside the pusher, block - block = SV_TestEntityPosition (check); - if (block) + if (SV_TestEntityPosition (check)) { // fail the move if (check->v.mins[0] == check->v.maxs[0]) continue; @@ -667,15 +705,16 @@ void SV_PushRotate (edict_t *pusher, float movetime) continue; } - VectorCopy (entorig, check->v.origin); + VectorCopy (entorigin, check->v.origin); + VectorCopy (entangles, check->v.angles); SV_LinkEdict (check, true); - VectorCopy (pushorig, pusher->v.angles); + VectorCopy (pushorigin, pusher->v.origin); + VectorCopy (pushangles, pusher->v.angles); SV_LinkEdict (pusher, false); pusher->v.ltime -= movetime; - // if the pusher has a "blocked" function, call it - // otherwise, just stay in place until the obstacle is gone + // if the pusher has a "blocked" function, call it, otherwise just stay in place until the obstacle is gone if (pusher->v.blocked) { pr_global_struct->self = EDICT_TO_PROG(pusher); @@ -684,23 +723,17 @@ void SV_PushRotate (edict_t *pusher, float movetime) } // move back any entities we already moved + num_moved--; // LordHavoc: pop off check, because it was already restored for (i=0 ; iv.origin); - VectorSubtract (moved_edict[i]->v.angles, amove, moved_edict[i]->v.angles); + VectorCopy (angled_from[i], moved_edict[i]->v.angles); SV_LinkEdict (moved_edict[i], false); } return; } - else - { - VectorAdd (check->v.angles, amove, check->v.angles); - } } - - } -//#endif /* ================ @@ -890,7 +923,7 @@ int SV_TryUnstick (edict_t *ent, vec3_t oldvel) trace_t steptrace; VectorCopy (ent->v.origin, oldorg); - VectorCopy (vec3_origin, dir); + VectorClear (dir); for (i=0 ; i<8 ; i++) { @@ -926,7 +959,7 @@ int SV_TryUnstick (edict_t *ent, vec3_t oldvel) VectorCopy (oldorg, ent->v.origin); } - VectorCopy (vec3_origin, ent->v.velocity); + VectorClear (ent->v.velocity); return 7; // still not moving } @@ -981,8 +1014,8 @@ void SV_WalkMove (edict_t *ent) // VectorCopy (oldorg, ent->v.origin); // back to start pos - VectorCopy (vec3_origin, upmove); - VectorCopy (vec3_origin, downmove); + VectorClear (upmove); + VectorClear (downmove); upmove[2] = STEPSIZE; downmove[2] = -STEPSIZE + oldvel[2]*host_frametime; @@ -1083,12 +1116,14 @@ void SV_Physics_Client (edict_t *ent, int num) case MOVETYPE_FLY: if (!SV_RunThink (ent)) return; + SV_CheckWater (ent); SV_FlyMove (ent, host_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); break; @@ -1130,19 +1165,33 @@ Entities that are "stuck" to another entity */ void SV_Physics_Follow (edict_t *ent) { - vec3_t vf, vu, vr, angles; + vec3_t vf, vr, vu, angles; edict_t *e; // regular thinking - SV_RunThink (ent); + if (!SV_RunThink (ent)) + return; // LordHavoc: implemented rotation on MOVETYPE_FOLLOW objects e = PROG_TO_EDICT(ent->v.aiment); - angles[0] = -e->v.angles[0]; - angles[1] = e->v.angles[1]; - angles[2] = e->v.angles[2]; - AngleVectors (angles, vf, vr, vu); - VectorMA (e->v.origin, ent->v.view_ofs[0], vf, ent->v.origin); - VectorMA (ent->v.origin, ent->v.view_ofs[1], vr, ent->v.origin); - VectorMA (ent->v.origin, ent->v.view_ofs[2], vu, ent->v.origin); + if (e->v.angles[0] == ent->v.punchangle[0] && e->v.angles[1] == ent->v.punchangle[1] && e->v.angles[2] == ent->v.punchangle[2]) + { + // quick case for no rotation + VectorAdd(e->v.origin, ent->v.view_ofs, ent->v.origin); + } + 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]; + 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] = 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]; + ent->v.origin[2] = ent->v.view_ofs[2] * vu[0] + ent->v.view_ofs[2] * vu[1] + ent->v.view_ofs[2] * vu[2] + e->v.origin[2]; + */ + } VectorAdd (e->v.angles, ent->v.v_angle, ent->v.angles); // VectorAdd (PROG_TO_EDICT(ent->v.aiment)->v.origin, ent->v.v_angle, ent->v.origin); SV_LinkEdict (ent, true); @@ -1267,8 +1316,8 @@ void SV_Physics_Toss (edict_t *ent) { ent->v.flags = (int)ent->v.flags | FL_ONGROUND; ent->v.groundentity = EDICT_TO_PROG(trace.ent); - VectorCopy (vec3_origin, ent->v.velocity); - VectorCopy (vec3_origin, ent->v.avelocity); + VectorClear (ent->v.velocity); + VectorClear (ent->v.avelocity); } } @@ -1357,25 +1406,33 @@ void SV_Physics (void) continue; if (pr_global_struct->force_retouch) - { SV_LinkEdict (ent, true); // force retouch even for stationary - } if (i > 0 && i <= svs.maxclients) + { SV_Physics_Client (ent, i); - else if (ent->v.movetype == MOVETYPE_PUSH) + continue; + } + + switch ((int) ent->v.movetype) + { + case MOVETYPE_PUSH: SV_Physics_Pusher (ent); - else if (ent->v.movetype == MOVETYPE_NONE) + break; + case MOVETYPE_NONE: SV_Physics_None (ent); - else if (ent->v.movetype == MOVETYPE_FOLLOW) + break; + case MOVETYPE_FOLLOW: SV_Physics_Follow (ent); - else if (ent->v.movetype == MOVETYPE_NOCLIP) + break; + case MOVETYPE_NOCLIP: SV_Physics_Noclip (ent); - else if (ent->v.movetype == MOVETYPE_STEP) + break; + case MOVETYPE_STEP: SV_Physics_Step (ent); + break; // LordHavoc: added support for MOVETYPE_WALK on normal entities! :) - else if (ent->v.movetype == MOVETYPE_WALK) - { + case MOVETYPE_WALK: if (SV_RunThink (ent)) { if (!SV_CheckWater (ent) && ! ((int)ent->v.flags & FL_WATERJUMP) ) @@ -1383,15 +1440,18 @@ void SV_Physics (void) SV_CheckStuck (ent); SV_WalkMove (ent); } - } - else if (ent->v.movetype == MOVETYPE_TOSS - || ent->v.movetype == MOVETYPE_BOUNCE - || ent->v.movetype == MOVETYPE_BOUNCEMISSILE - || ent->v.movetype == MOVETYPE_FLY - || ent->v.movetype == MOVETYPE_FLYMISSILE) + break; + case MOVETYPE_TOSS: + case MOVETYPE_BOUNCE: + case MOVETYPE_BOUNCEMISSILE: + case MOVETYPE_FLY: + case MOVETYPE_FLYMISSILE: SV_Physics_Toss (ent); - else - Host_Error ("SV_Physics: bad movetype %i", (int)ent->v.movetype); + break; + default: + Host_Error ("SV_Physics: bad movetype %i", (int)ent->v.movetype); + break; + } } if (pr_global_struct->force_retouch)