![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to sv_phys.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Quake] / quakeworld / server|
Return to sv_phys.c CVS log | Up to [Quake] / quakeworld / server |
1.1 ! root 1: /* ! 2: Copyright (C) 1996-1997 Id Software, Inc. ! 3: ! 4: This program is free software; you can redistribute it and/or ! 5: modify it under the terms of the GNU General Public License ! 6: as published by the Free Software Foundation; either version 2 ! 7: of the License, or (at your option) any later version. ! 8: ! 9: This program is distributed in the hope that it will be useful, ! 10: but WITHOUT ANY WARRANTY; without even the implied warranty of ! 11: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. ! 12: ! 13: See the GNU General Public License for more details. ! 14: ! 15: You should have received a copy of the GNU General Public License ! 16: along with this program; if not, write to the Free Software ! 17: Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. ! 18: ! 19: */ ! 20: // sv_phys.c ! 21: ! 22: #include "qwsvdef.h" ! 23: ! 24: /* ! 25: ! 26: ! 27: pushmove objects do not obey gravity, and do not interact with each other or trigger fields, but block normal movement and push normal objects when they move. ! 28: ! 29: onground is set for toss objects when they come to a complete rest. it is set for steping or walking objects ! 30: ! 31: doors, plats, etc are SOLID_BSP, and MOVETYPE_PUSH ! 32: bonus items are SOLID_TRIGGER touch, and MOVETYPE_TOSS ! 33: corpses are SOLID_NOT and MOVETYPE_TOSS ! 34: crates are SOLID_BBOX and MOVETYPE_TOSS ! 35: walking monsters are SOLID_SLIDEBOX and MOVETYPE_STEP ! 36: flying/floating monsters are SOLID_SLIDEBOX and MOVETYPE_FLY ! 37: ! 38: solid_edge items only clip against bsp models. ! 39: ! 40: */ ! 41: ! 42: cvar_t sv_maxvelocity = {"sv_maxvelocity","2000"}; ! 43: ! 44: cvar_t sv_gravity = { "sv_gravity", "800"}; ! 45: cvar_t sv_stopspeed = { "sv_stopspeed", "100"}; ! 46: cvar_t sv_maxspeed = { "sv_maxspeed", "320"}; ! 47: cvar_t sv_spectatormaxspeed = { "sv_spectatormaxspeed", "500"}; ! 48: cvar_t sv_accelerate = { "sv_accelerate", "10"}; ! 49: cvar_t sv_airaccelerate = { "sv_airaccelerate", "0.7"}; ! 50: cvar_t sv_wateraccelerate = { "sv_wateraccelerate", "10"}; ! 51: cvar_t sv_friction = { "sv_friction", "4"}; ! 52: cvar_t sv_waterfriction = { "sv_waterfriction", "4"}; ! 53: ! 54: ! 55: #define MOVE_EPSILON 0.01 ! 56: ! 57: void SV_Physics_Toss (edict_t *ent); ! 58: ! 59: /* ! 60: ================ ! 61: SV_CheckAllEnts ! 62: ================ ! 63: */ ! 64: void SV_CheckAllEnts (void) ! 65: { ! 66: int e; ! 67: edict_t *check; ! 68: ! 69: // see if any solid entities are inside the final position ! 70: check = NEXT_EDICT(sv.edicts); ! 71: for (e=1 ; e<sv.num_edicts ; e++, check = NEXT_EDICT(check)) ! 72: { ! 73: if (check->free) ! 74: continue; ! 75: if (check->v.movetype == MOVETYPE_PUSH ! 76: || check->v.movetype == MOVETYPE_NONE ! 77: || check->v.movetype == MOVETYPE_NOCLIP) ! 78: continue; ! 79: ! 80: if (SV_TestEntityPosition (check)) ! 81: Con_Printf ("entity in invalid position\n"); ! 82: } ! 83: } ! 84: ! 85: /* ! 86: ================ ! 87: SV_CheckVelocity ! 88: ================ ! 89: */ ! 90: void SV_CheckVelocity (edict_t *ent) ! 91: { ! 92: int i; ! 93: ! 94: // ! 95: // bound velocity ! 96: // ! 97: for (i=0 ; i<3 ; i++) ! 98: { ! 99: if (IS_NAN(ent->v.velocity[i])) ! 100: { ! 101: Con_Printf ("Got a NaN velocity on %s\n", PR_GetString(ent->v.classname)); ! 102: ent->v.velocity[i] = 0; ! 103: } ! 104: if (IS_NAN(ent->v.origin[i])) ! 105: { ! 106: Con_Printf ("Got a NaN origin on %s\n", PR_GetString(ent->v.classname)); ! 107: ent->v.origin[i] = 0; ! 108: } ! 109: if (ent->v.velocity[i] > sv_maxvelocity.value) ! 110: ent->v.velocity[i] = sv_maxvelocity.value; ! 111: else if (ent->v.velocity[i] < -sv_maxvelocity.value) ! 112: ent->v.velocity[i] = -sv_maxvelocity.value; ! 113: } ! 114: } ! 115: ! 116: /* ! 117: ============= ! 118: SV_RunThink ! 119: ! 120: Runs thinking code if time. There is some play in the exact time the think ! 121: function will be called, because it is called before any movement is done ! 122: in a frame. Not used for pushmove objects, because they must be exact. ! 123: Returns false if the entity removed itself. ! 124: ============= ! 125: */ ! 126: qboolean SV_RunThink (edict_t *ent) ! 127: { ! 128: float thinktime; ! 129: ! 130: do ! 131: { ! 132: thinktime = ent->v.nextthink; ! 133: if (thinktime <= 0) ! 134: return true; ! 135: if (thinktime > sv.time + host_frametime) ! 136: return true; ! 137: ! 138: if (thinktime < sv.time) ! 139: thinktime = sv.time; // don't let things stay in the past. ! 140: // it is possible to start that way ! 141: // by a trigger with a local time. ! 142: ent->v.nextthink = 0; ! 143: pr_global_struct->time = thinktime; ! 144: pr_global_struct->self = EDICT_TO_PROG(ent); ! 145: pr_global_struct->other = EDICT_TO_PROG(sv.edicts); ! 146: PR_ExecuteProgram (ent->v.think); ! 147: ! 148: if (ent->free) ! 149: return false; ! 150: } while (1); ! 151: ! 152: return true; ! 153: } ! 154: ! 155: /* ! 156: ================== ! 157: SV_Impact ! 158: ! 159: Two entities have touched, so run their touch functions ! 160: ================== ! 161: */ ! 162: void SV_Impact (edict_t *e1, edict_t *e2) ! 163: { ! 164: int old_self, old_other; ! 165: ! 166: old_self = pr_global_struct->self; ! 167: old_other = pr_global_struct->other; ! 168: ! 169: pr_global_struct->time = sv.time; ! 170: if (e1->v.touch && e1->v.solid != SOLID_NOT) ! 171: { ! 172: pr_global_struct->self = EDICT_TO_PROG(e1); ! 173: pr_global_struct->other = EDICT_TO_PROG(e2); ! 174: PR_ExecuteProgram (e1->v.touch); ! 175: } ! 176: ! 177: if (e2->v.touch && e2->v.solid != SOLID_NOT) ! 178: { ! 179: pr_global_struct->self = EDICT_TO_PROG(e2); ! 180: pr_global_struct->other = EDICT_TO_PROG(e1); ! 181: PR_ExecuteProgram (e2->v.touch); ! 182: } ! 183: ! 184: pr_global_struct->self = old_self; ! 185: pr_global_struct->other = old_other; ! 186: } ! 187: ! 188: ! 189: /* ! 190: ================== ! 191: ClipVelocity ! 192: ! 193: Slide off of the impacting object ! 194: returns the blocked flags (1 = floor, 2 = step / wall) ! 195: ================== ! 196: */ ! 197: #define STOP_EPSILON 0.1 ! 198: ! 199: int ClipVelocity (vec3_t in, vec3_t normal, vec3_t out, float overbounce) ! 200: { ! 201: float backoff; ! 202: float change; ! 203: int i, blocked; ! 204: ! 205: blocked = 0; ! 206: if (normal[2] > 0) ! 207: blocked |= 1; // floor ! 208: if (!normal[2]) ! 209: blocked |= 2; // step ! 210: ! 211: backoff = DotProduct (in, normal) * overbounce; ! 212: ! 213: for (i=0 ; i<3 ; i++) ! 214: { ! 215: change = normal[i]*backoff; ! 216: out[i] = in[i] - change; ! 217: if (out[i] > -STOP_EPSILON && out[i] < STOP_EPSILON) ! 218: out[i] = 0; ! 219: } ! 220: ! 221: return blocked; ! 222: } ! 223: ! 224: ! 225: /* ! 226: ============ ! 227: SV_FlyMove ! 228: ! 229: The basic solid body movement clip that slides along multiple planes ! 230: Returns the clipflags if the velocity was modified (hit something solid) ! 231: 1 = floor ! 232: 2 = wall / step ! 233: 4 = dead stop ! 234: If steptrace is not NULL, the trace of any vertical wall hit will be stored ! 235: ============ ! 236: */ ! 237: #define MAX_CLIP_PLANES 5 ! 238: int SV_FlyMove (edict_t *ent, float time, trace_t *steptrace) ! 239: { ! 240: int bumpcount, numbumps; ! 241: vec3_t dir; ! 242: float d; ! 243: int numplanes; ! 244: vec3_t planes[MAX_CLIP_PLANES]; ! 245: vec3_t primal_velocity, original_velocity, new_velocity; ! 246: int i, j; ! 247: trace_t trace; ! 248: vec3_t end; ! 249: float time_left; ! 250: int blocked; ! 251: ! 252: numbumps = 4; ! 253: ! 254: blocked = 0; ! 255: VectorCopy (ent->v.velocity, original_velocity); ! 256: VectorCopy (ent->v.velocity, primal_velocity); ! 257: numplanes = 0; ! 258: ! 259: time_left = time; ! 260: ! 261: for (bumpcount=0 ; bumpcount<numbumps ; bumpcount++) ! 262: { ! 263: for (i=0 ; i<3 ; i++) ! 264: end[i] = ent->v.origin[i] + time_left * ent->v.velocity[i]; ! 265: ! 266: trace = SV_Move (ent->v.origin, ent->v.mins, ent->v.maxs, end, false, ent); ! 267: ! 268: if (trace.allsolid) ! 269: { // entity is trapped in another solid ! 270: VectorCopy (vec3_origin, ent->v.velocity); ! 271: return 3; ! 272: } ! 273: ! 274: if (trace.fraction > 0) ! 275: { // actually covered some distance ! 276: VectorCopy (trace.endpos, ent->v.origin); ! 277: VectorCopy (ent->v.velocity, original_velocity); ! 278: numplanes = 0; ! 279: } ! 280: ! 281: if (trace.fraction == 1) ! 282: break; // moved the entire distance ! 283: ! 284: if (!trace.ent) ! 285: SV_Error ("SV_FlyMove: !trace.ent"); ! 286: ! 287: if (trace.plane.normal[2] > 0.7) ! 288: { ! 289: blocked |= 1; // floor ! 290: if (trace.ent->v.solid == SOLID_BSP) ! 291: { ! 292: ent->v.flags = (int)ent->v.flags | FL_ONGROUND; ! 293: ent->v.groundentity = EDICT_TO_PROG(trace.ent); ! 294: } ! 295: } ! 296: if (!trace.plane.normal[2]) ! 297: { ! 298: blocked |= 2; // step ! 299: if (steptrace) ! 300: *steptrace = trace; // save for player extrafriction ! 301: } ! 302: ! 303: // ! 304: // run the impact function ! 305: // ! 306: SV_Impact (ent, trace.ent); ! 307: if (ent->free) ! 308: break; // removed by the impact function ! 309: ! 310: ! 311: time_left -= time_left * trace.fraction; ! 312: ! 313: // cliped to another plane ! 314: if (numplanes >= MAX_CLIP_PLANES) ! 315: { // this shouldn't really happen ! 316: VectorCopy (vec3_origin, ent->v.velocity); ! 317: return 3; ! 318: } ! 319: ! 320: VectorCopy (trace.plane.normal, planes[numplanes]); ! 321: numplanes++; ! 322: ! 323: // ! 324: // modify original_velocity so it parallels all of the clip planes ! 325: // ! 326: for (i=0 ; i<numplanes ; i++) ! 327: { ! 328: ClipVelocity (original_velocity, planes[i], new_velocity, 1); ! 329: for (j=0 ; j<numplanes ; j++) ! 330: if (j != i) ! 331: { ! 332: if (DotProduct (new_velocity, planes[j]) < 0) ! 333: break; // not ok ! 334: } ! 335: if (j == numplanes) ! 336: break; ! 337: } ! 338: ! 339: if (i != numplanes) ! 340: { // go along this plane ! 341: VectorCopy (new_velocity, ent->v.velocity); ! 342: } ! 343: else ! 344: { // go along the crease ! 345: if (numplanes != 2) ! 346: { ! 347: // Con_Printf ("clip velocity, numplanes == %i\n",numplanes); ! 348: VectorCopy (vec3_origin, ent->v.velocity); ! 349: return 7; ! 350: } ! 351: CrossProduct (planes[0], planes[1], dir); ! 352: d = DotProduct (dir, ent->v.velocity); ! 353: VectorScale (dir, d, ent->v.velocity); ! 354: } ! 355: ! 356: // ! 357: // if original velocity is against the original velocity, stop dead ! 358: // to avoid tiny occilations in sloping corners ! 359: // ! 360: if (DotProduct (ent->v.velocity, primal_velocity) <= 0) ! 361: { ! 362: VectorCopy (vec3_origin, ent->v.velocity); ! 363: return blocked; ! 364: } ! 365: } ! 366: ! 367: return blocked; ! 368: } ! 369: ! 370: ! 371: /* ! 372: ============ ! 373: SV_AddGravity ! 374: ! 375: ============ ! 376: */ ! 377: void SV_AddGravity (edict_t *ent, float scale) ! 378: { ! 379: ent->v.velocity[2] -= scale * movevars.gravity * host_frametime; ! 380: } ! 381: ! 382: /* ! 383: =============================================================================== ! 384: ! 385: PUSHMOVE ! 386: ! 387: =============================================================================== ! 388: */ ! 389: ! 390: /* ! 391: ============ ! 392: SV_PushEntity ! 393: ! 394: Does not change the entities velocity at all ! 395: ============ ! 396: */ ! 397: trace_t SV_PushEntity (edict_t *ent, vec3_t push) ! 398: { ! 399: trace_t trace; ! 400: vec3_t end; ! 401: ! 402: VectorAdd (ent->v.origin, push, end); ! 403: ! 404: if (ent->v.movetype == MOVETYPE_FLYMISSILE) ! 405: trace = SV_Move (ent->v.origin, ent->v.mins, ent->v.maxs, end, MOVE_MISSILE, ent); ! 406: else if (ent->v.solid == SOLID_TRIGGER || ent->v.solid == SOLID_NOT) ! 407: // only clip against bmodels ! 408: trace = SV_Move (ent->v.origin, ent->v.mins, ent->v.maxs, end, MOVE_NOMONSTERS, ent); ! 409: else ! 410: trace = SV_Move (ent->v.origin, ent->v.mins, ent->v.maxs, end, MOVE_NORMAL, ent); ! 411: ! 412: VectorCopy (trace.endpos, ent->v.origin); ! 413: SV_LinkEdict (ent, true); ! 414: ! 415: if (trace.ent) ! 416: SV_Impact (ent, trace.ent); ! 417: ! 418: return trace; ! 419: } ! 420: ! 421: ! 422: /* ! 423: ============ ! 424: SV_Push ! 425: ! 426: ============ ! 427: */ ! 428: qboolean SV_Push (edict_t *pusher, vec3_t move) ! 429: { ! 430: int i, e; ! 431: edict_t *check, *block; ! 432: vec3_t mins, maxs; ! 433: vec3_t pushorig; ! 434: int num_moved; ! 435: edict_t *moved_edict[MAX_EDICTS]; ! 436: vec3_t moved_from[MAX_EDICTS]; ! 437: ! 438: for (i=0 ; i<3 ; i++) ! 439: { ! 440: mins[i] = pusher->v.absmin[i] + move[i]; ! 441: maxs[i] = pusher->v.absmax[i] + move[i]; ! 442: } ! 443: ! 444: VectorCopy (pusher->v.origin, pushorig); ! 445: ! 446: // move the pusher to it's final position ! 447: ! 448: VectorAdd (pusher->v.origin, move, pusher->v.origin); ! 449: SV_LinkEdict (pusher, false); ! 450: ! 451: // see if any solid entities are inside the final position ! 452: num_moved = 0; ! 453: check = NEXT_EDICT(sv.edicts); ! 454: for (e=1 ; e<sv.num_edicts ; e++, check = NEXT_EDICT(check)) ! 455: { ! 456: if (check->free) ! 457: continue; ! 458: if (check->v.movetype == MOVETYPE_PUSH ! 459: || check->v.movetype == MOVETYPE_NONE ! 460: || check->v.movetype == MOVETYPE_NOCLIP) ! 461: continue; ! 462: ! 463: pusher->v.solid = SOLID_NOT; ! 464: block = SV_TestEntityPosition (check); ! 465: pusher->v.solid = SOLID_BSP; ! 466: if (block) ! 467: continue; ! 468: ! 469: // if the entity is standing on the pusher, it will definately be moved ! 470: if ( ! ( ((int)check->v.flags & FL_ONGROUND) ! 471: && PROG_TO_EDICT(check->v.groundentity) == pusher) ) ! 472: { ! 473: if ( check->v.absmin[0] >= maxs[0] ! 474: || check->v.absmin[1] >= maxs[1] ! 475: || check->v.absmin[2] >= maxs[2] ! 476: || check->v.absmax[0] <= mins[0] ! 477: || check->v.absmax[1] <= mins[1] ! 478: || check->v.absmax[2] <= mins[2] ) ! 479: continue; ! 480: ! 481: // see if the ent's bbox is inside the pusher's final position ! 482: if (!SV_TestEntityPosition (check)) ! 483: continue; ! 484: } ! 485: ! 486: VectorCopy (check->v.origin, moved_from[num_moved]); ! 487: moved_edict[num_moved] = check; ! 488: num_moved++; ! 489: ! 490: // try moving the contacted entity ! 491: VectorAdd (check->v.origin, move, check->v.origin); ! 492: block = SV_TestEntityPosition (check); ! 493: if (!block) ! 494: { // pushed ok ! 495: SV_LinkEdict (check, false); ! 496: continue; ! 497: } ! 498: ! 499: // if it is ok to leave in the old position, do it ! 500: VectorSubtract (check->v.origin, move, check->v.origin); ! 501: block = SV_TestEntityPosition (check); ! 502: if (!block) ! 503: { ! 504: num_moved--; ! 505: continue; ! 506: } ! 507: ! 508: // if it is still inside the pusher, block ! 509: if (check->v.mins[0] == check->v.maxs[0]) ! 510: { ! 511: SV_LinkEdict (check, false); ! 512: continue; ! 513: } ! 514: if (check->v.solid == SOLID_NOT || check->v.solid == SOLID_TRIGGER) ! 515: { // corpse ! 516: check->v.mins[0] = check->v.mins[1] = 0; ! 517: VectorCopy (check->v.mins, check->v.maxs); ! 518: SV_LinkEdict (check, false); ! 519: continue; ! 520: } ! 521: ! 522: VectorCopy (pushorig, pusher->v.origin); ! 523: SV_LinkEdict (pusher, false); ! 524: ! 525: // if the pusher has a "blocked" function, call it ! 526: // otherwise, just stay in place until the obstacle is gone ! 527: if (pusher->v.blocked) ! 528: { ! 529: pr_global_struct->self = EDICT_TO_PROG(pusher); ! 530: pr_global_struct->other = EDICT_TO_PROG(check); ! 531: PR_ExecuteProgram (pusher->v.blocked); ! 532: } ! 533: ! 534: // move back any entities we already moved ! 535: for (i=0 ; i<num_moved ; i++) ! 536: { ! 537: VectorCopy (moved_from[i], moved_edict[i]->v.origin); ! 538: SV_LinkEdict (moved_edict[i], false); ! 539: } ! 540: return false; ! 541: } ! 542: ! 543: return true; ! 544: } ! 545: ! 546: /* ! 547: ============ ! 548: SV_PushMove ! 549: ! 550: ============ ! 551: */ ! 552: void SV_PushMove (edict_t *pusher, float movetime) ! 553: { ! 554: int i; ! 555: vec3_t move; ! 556: ! 557: if (!pusher->v.velocity[0] && !pusher->v.velocity[1] && !pusher->v.velocity[2]) ! 558: { ! 559: pusher->v.ltime += movetime; ! 560: return; ! 561: } ! 562: ! 563: for (i=0 ; i<3 ; i++) ! 564: move[i] = pusher->v.velocity[i] * movetime; ! 565: ! 566: if (SV_Push (pusher, move)) ! 567: pusher->v.ltime += movetime; ! 568: } ! 569: ! 570: ! 571: /* ! 572: ================ ! 573: SV_Physics_Pusher ! 574: ! 575: ================ ! 576: */ ! 577: void SV_Physics_Pusher (edict_t *ent) ! 578: { ! 579: float thinktime; ! 580: float oldltime; ! 581: float movetime; ! 582: vec3_t oldorg, move; ! 583: float l; ! 584: ! 585: oldltime = ent->v.ltime; ! 586: ! 587: thinktime = ent->v.nextthink; ! 588: if (thinktime < ent->v.ltime + host_frametime) ! 589: { ! 590: movetime = thinktime - ent->v.ltime; ! 591: if (movetime < 0) ! 592: movetime = 0; ! 593: } ! 594: else ! 595: movetime = host_frametime; ! 596: ! 597: if (movetime) ! 598: { ! 599: SV_PushMove (ent, movetime); // advances ent->v.ltime if not blocked ! 600: } ! 601: ! 602: if (thinktime > oldltime && thinktime <= ent->v.ltime) ! 603: { ! 604: VectorCopy (ent->v.origin, oldorg); ! 605: ent->v.nextthink = 0; ! 606: pr_global_struct->time = sv.time; ! 607: pr_global_struct->self = EDICT_TO_PROG(ent); ! 608: pr_global_struct->other = EDICT_TO_PROG(sv.edicts); ! 609: PR_ExecuteProgram (ent->v.think); ! 610: if (ent->free) ! 611: return; ! 612: VectorSubtract (ent->v.origin, oldorg, move); ! 613: ! 614: l = Length(move); ! 615: if (l > 1.0/64) ! 616: { ! 617: // Con_Printf ("**** snap: %f\n", Length (l)); ! 618: VectorCopy (oldorg, ent->v.origin); ! 619: SV_Push (ent, move); ! 620: } ! 621: ! 622: } ! 623: ! 624: } ! 625: ! 626: ! 627: /* ! 628: ============= ! 629: SV_Physics_None ! 630: ! 631: Non moving objects can only think ! 632: ============= ! 633: */ ! 634: void SV_Physics_None (edict_t *ent) ! 635: { ! 636: // regular thinking ! 637: SV_RunThink (ent); ! 638: } ! 639: ! 640: /* ! 641: ============= ! 642: SV_Physics_Noclip ! 643: ! 644: A moving object that doesn't obey physics ! 645: ============= ! 646: */ ! 647: void SV_Physics_Noclip (edict_t *ent) ! 648: { ! 649: // regular thinking ! 650: if (!SV_RunThink (ent)) ! 651: return; ! 652: ! 653: VectorMA (ent->v.angles, host_frametime, ent->v.avelocity, ent->v.angles); ! 654: VectorMA (ent->v.origin, host_frametime, ent->v.velocity, ent->v.origin); ! 655: ! 656: SV_LinkEdict (ent, false); ! 657: } ! 658: ! 659: /* ! 660: ============================================================================== ! 661: ! 662: TOSS / BOUNCE ! 663: ! 664: ============================================================================== ! 665: */ ! 666: ! 667: /* ! 668: ============= ! 669: SV_CheckWaterTransition ! 670: ! 671: ============= ! 672: */ ! 673: void SV_CheckWaterTransition (edict_t *ent) ! 674: { ! 675: int cont; ! 676: ! 677: cont = SV_PointContents (ent->v.origin); ! 678: if (!ent->v.watertype) ! 679: { // just spawned here ! 680: ent->v.watertype = cont; ! 681: ent->v.waterlevel = 1; ! 682: return; ! 683: } ! 684: ! 685: if (cont <= CONTENTS_WATER) ! 686: { ! 687: if (ent->v.watertype == CONTENTS_EMPTY) ! 688: { // just crossed into water ! 689: SV_StartSound (ent, 0, "misc/h2ohit1.wav", 255, 1); ! 690: } ! 691: ent->v.watertype = cont; ! 692: ent->v.waterlevel = 1; ! 693: } ! 694: else ! 695: { ! 696: if (ent->v.watertype != CONTENTS_EMPTY) ! 697: { // just crossed into water ! 698: SV_StartSound (ent, 0, "misc/h2ohit1.wav", 255, 1); ! 699: } ! 700: ent->v.watertype = CONTENTS_EMPTY; ! 701: ent->v.waterlevel = cont; ! 702: } ! 703: } ! 704: ! 705: /* ! 706: ============= ! 707: SV_Physics_Toss ! 708: ! 709: Toss, bounce, and fly movement. When onground, do nothing. ! 710: ============= ! 711: */ ! 712: void SV_Physics_Toss (edict_t *ent) ! 713: { ! 714: trace_t trace; ! 715: vec3_t move; ! 716: float backoff; ! 717: ! 718: // regular thinking ! 719: if (!SV_RunThink (ent)) ! 720: return; ! 721: ! 722: if (ent->v.velocity[2] > 0) ! 723: ent->v.flags = (int)ent->v.flags & ~FL_ONGROUND; ! 724: ! 725: // if onground, return without moving ! 726: if ( ((int)ent->v.flags & FL_ONGROUND) ) ! 727: return; ! 728: ! 729: SV_CheckVelocity (ent); ! 730: ! 731: // add gravity ! 732: if (ent->v.movetype != MOVETYPE_FLY ! 733: && ent->v.movetype != MOVETYPE_FLYMISSILE) ! 734: SV_AddGravity (ent, 1.0); ! 735: ! 736: // move angles ! 737: VectorMA (ent->v.angles, host_frametime, ent->v.avelocity, ent->v.angles); ! 738: ! 739: // move origin ! 740: VectorScale (ent->v.velocity, host_frametime, move); ! 741: trace = SV_PushEntity (ent, move); ! 742: if (trace.fraction == 1) ! 743: return; ! 744: if (ent->free) ! 745: return; ! 746: ! 747: if (ent->v.movetype == MOVETYPE_BOUNCE) ! 748: backoff = 1.5; ! 749: else ! 750: backoff = 1; ! 751: ! 752: ClipVelocity (ent->v.velocity, trace.plane.normal, ent->v.velocity, backoff); ! 753: ! 754: // stop if on ground ! 755: if (trace.plane.normal[2] > 0.7) ! 756: { ! 757: if (ent->v.velocity[2] < 60 || ent->v.movetype != MOVETYPE_BOUNCE ) ! 758: { ! 759: ent->v.flags = (int)ent->v.flags | FL_ONGROUND; ! 760: ent->v.groundentity = EDICT_TO_PROG(trace.ent); ! 761: VectorCopy (vec3_origin, ent->v.velocity); ! 762: VectorCopy (vec3_origin, ent->v.avelocity); ! 763: } ! 764: } ! 765: ! 766: // check for in water ! 767: SV_CheckWaterTransition (ent); ! 768: } ! 769: ! 770: /* ! 771: =============================================================================== ! 772: ! 773: STEPPING MOVEMENT ! 774: ! 775: =============================================================================== ! 776: */ ! 777: ! 778: /* ! 779: ============= ! 780: SV_Physics_Step ! 781: ! 782: Monsters freefall when they don't have a ground entity, otherwise ! 783: all movement is done with discrete steps. ! 784: ! 785: This is also used for objects that have become still on the ground, but ! 786: will fall if the floor is pulled out from under them. ! 787: FIXME: is this true? ! 788: ============= ! 789: */ ! 790: void SV_Physics_Step (edict_t *ent) ! 791: { ! 792: qboolean hitsound; ! 793: ! 794: // frefall if not onground ! 795: if ( ! ((int)ent->v.flags & (FL_ONGROUND | FL_FLY | FL_SWIM) ) ) ! 796: { ! 797: if (ent->v.velocity[2] < movevars.gravity*-0.1) ! 798: hitsound = true; ! 799: else ! 800: hitsound = false; ! 801: ! 802: SV_AddGravity (ent, 1.0); ! 803: SV_CheckVelocity (ent); ! 804: SV_FlyMove (ent, host_frametime, NULL); ! 805: SV_LinkEdict (ent, true); ! 806: ! 807: if ( (int)ent->v.flags & FL_ONGROUND ) // just hit ground ! 808: { ! 809: if (hitsound) ! 810: SV_StartSound (ent, 0, "demon/dland2.wav", 255, 1); ! 811: } ! 812: } ! 813: ! 814: // regular thinking ! 815: SV_RunThink (ent); ! 816: ! 817: SV_CheckWaterTransition (ent); ! 818: } ! 819: ! 820: //============================================================================ ! 821: ! 822: void SV_ProgStartFrame (void) ! 823: { ! 824: // let the progs know that a new frame has started ! 825: pr_global_struct->self = EDICT_TO_PROG(sv.edicts); ! 826: pr_global_struct->other = EDICT_TO_PROG(sv.edicts); ! 827: pr_global_struct->time = sv.time; ! 828: PR_ExecuteProgram (pr_global_struct->StartFrame); ! 829: } ! 830: ! 831: /* ! 832: ================ ! 833: SV_RunEntity ! 834: ! 835: ================ ! 836: */ ! 837: void SV_RunEntity (edict_t *ent) ! 838: { ! 839: if (ent->v.lastruntime == (float)realtime) ! 840: return; ! 841: ent->v.lastruntime = (float)realtime; ! 842: ! 843: switch ( (int)ent->v.movetype) ! 844: { ! 845: case MOVETYPE_PUSH: ! 846: SV_Physics_Pusher (ent); ! 847: break; ! 848: case MOVETYPE_NONE: ! 849: SV_Physics_None (ent); ! 850: break; ! 851: case MOVETYPE_NOCLIP: ! 852: SV_Physics_Noclip (ent); ! 853: break; ! 854: case MOVETYPE_STEP: ! 855: SV_Physics_Step (ent); ! 856: break; ! 857: case MOVETYPE_TOSS: ! 858: case MOVETYPE_BOUNCE: ! 859: case MOVETYPE_FLY: ! 860: case MOVETYPE_FLYMISSILE: ! 861: SV_Physics_Toss (ent); ! 862: break; ! 863: default: ! 864: SV_Error ("SV_Physics: bad movetype %i", (int)ent->v.movetype); ! 865: } ! 866: } ! 867: ! 868: /* ! 869: ================ ! 870: SV_RunNewmis ! 871: ! 872: ================ ! 873: */ ! 874: void SV_RunNewmis (void) ! 875: { ! 876: edict_t *ent; ! 877: ! 878: if (!pr_global_struct->newmis) ! 879: return; ! 880: ent = PROG_TO_EDICT(pr_global_struct->newmis); ! 881: host_frametime = 0.05; ! 882: pr_global_struct->newmis = 0; ! 883: ! 884: SV_RunEntity (ent); ! 885: } ! 886: ! 887: /* ! 888: ================ ! 889: SV_Physics ! 890: ! 891: ================ ! 892: */ ! 893: void SV_Physics (void) ! 894: { ! 895: int i; ! 896: edict_t *ent; ! 897: static double old_time; ! 898: ! 899: // don't bother running a frame if sys_ticrate seconds haven't passed ! 900: host_frametime = realtime - old_time; ! 901: if (host_frametime < sv_mintic.value) ! 902: return; ! 903: if (host_frametime > sv_maxtic.value) ! 904: host_frametime = sv_maxtic.value; ! 905: old_time = realtime; ! 906: ! 907: pr_global_struct->frametime = host_frametime; ! 908: ! 909: SV_ProgStartFrame (); ! 910: ! 911: // ! 912: // treat each object in turn ! 913: // even the world gets a chance to think ! 914: // ! 915: ent = sv.edicts; ! 916: for (i=0 ; i<sv.num_edicts ; i++, ent = NEXT_EDICT(ent)) ! 917: { ! 918: if (ent->free) ! 919: continue; ! 920: ! 921: if (pr_global_struct->force_retouch) ! 922: SV_LinkEdict (ent, true); // force retouch even for stationary ! 923: ! 924: if (i > 0 && i <= MAX_CLIENTS) ! 925: continue; // clients are run directly from packets ! 926: ! 927: SV_RunEntity (ent); ! 928: SV_RunNewmis (); ! 929: } ! 930: ! 931: if (pr_global_struct->force_retouch) ! 932: pr_global_struct->force_retouch--; ! 933: } ! 934: ! 935: void SV_SetMoveVars(void) ! 936: { ! 937: movevars.gravity = sv_gravity.value; ! 938: movevars.stopspeed = sv_stopspeed.value; ! 939: movevars.maxspeed = sv_maxspeed.value; ! 940: movevars.spectatormaxspeed = sv_spectatormaxspeed.value; ! 941: movevars.accelerate = sv_accelerate.value; ! 942: movevars.airaccelerate = sv_airaccelerate.value; ! 943: movevars.wateraccelerate = sv_wateraccelerate.value; ! 944: movevars.friction = sv_friction.value; ! 945: movevars.waterfriction = sv_waterfriction.value; ! 946: movevars.entgravity = 1.0; ! 947: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.