![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to g_phys.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Quake II] / quake2 / game|
Return to g_phys.c CVS log | Up to [Quake II] / quake2 / game |
1.1 ! root 1: // g_phys.c ! 2: ! 3: #include "g_local.h" ! 4: ! 5: /* ! 6: ! 7: ! 8: 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. ! 9: ! 10: onground is set for toss objects when they come to a complete rest. it is set for steping or walking objects ! 11: ! 12: doors, plats, etc are SOLID_BSP, and MOVETYPE_PUSH ! 13: bonus items are SOLID_TRIGGER touch, and MOVETYPE_TOSS ! 14: corpses are SOLID_NOT and MOVETYPE_TOSS ! 15: crates are SOLID_BBOX and MOVETYPE_TOSS ! 16: walking monsters are SOLID_SLIDEBOX and MOVETYPE_STEP ! 17: flying/floating monsters are SOLID_SLIDEBOX and MOVETYPE_FLY ! 18: ! 19: solid_edge items only clip against bsp models. ! 20: ! 21: */ ! 22: ! 23: ! 24: /* ! 25: ============ ! 26: SV_TestEntityPosition ! 27: ! 28: ============ ! 29: */ ! 30: edict_t *SV_TestEntityPosition (edict_t *ent) ! 31: { ! 32: trace_t trace; ! 33: int mask; ! 34: ! 35: if (ent->clipmask) ! 36: mask = ent->clipmask; ! 37: else ! 38: mask = MASK_SOLID; ! 39: trace = gi.trace (ent->s.origin, ent->mins, ent->maxs, ent->s.origin, ent, mask); ! 40: ! 41: if (trace.startsolid) ! 42: return g_edicts; ! 43: ! 44: return NULL; ! 45: } ! 46: ! 47: ! 48: /* ! 49: ================ ! 50: SV_CheckVelocity ! 51: ================ ! 52: */ ! 53: void SV_CheckVelocity (edict_t *ent) ! 54: { ! 55: int i; ! 56: ! 57: // ! 58: // bound velocity ! 59: // ! 60: for (i=0 ; i<3 ; i++) ! 61: { ! 62: if (ent->velocity[i] > sv_maxvelocity->value) ! 63: ent->velocity[i] = sv_maxvelocity->value; ! 64: else if (ent->velocity[i] < -sv_maxvelocity->value) ! 65: ent->velocity[i] = -sv_maxvelocity->value; ! 66: } ! 67: } ! 68: ! 69: /* ! 70: ============= ! 71: SV_RunThink ! 72: ! 73: Runs thinking code for this frame if necessary ! 74: ============= ! 75: */ ! 76: qboolean SV_RunThink (edict_t *ent) ! 77: { ! 78: float thinktime; ! 79: ! 80: thinktime = ent->nextthink; ! 81: if (thinktime <= 0) ! 82: return true; ! 83: if (thinktime > level.time+0.001) ! 84: return true; ! 85: ! 86: ent->nextthink = 0; ! 87: if (!ent->think) ! 88: gi.error ("NULL ent->think"); ! 89: ent->think (ent); ! 90: ! 91: return false; ! 92: } ! 93: ! 94: /* ! 95: ================== ! 96: SV_Impact ! 97: ! 98: Two entities have touched, so run their touch functions ! 99: ================== ! 100: */ ! 101: void SV_Impact (edict_t *e1, trace_t *trace) ! 102: { ! 103: edict_t *e2; ! 104: // cplane_t backplane; ! 105: ! 106: e2 = trace->ent; ! 107: ! 108: if (e1->touch && e1->solid != SOLID_NOT) ! 109: e1->touch (e1, e2, &trace->plane, trace->surface); ! 110: ! 111: if (e2->touch && e2->solid != SOLID_NOT) ! 112: e2->touch (e2, e1, NULL, NULL); ! 113: } ! 114: ! 115: ! 116: /* ! 117: ================== ! 118: ClipVelocity ! 119: ! 120: Slide off of the impacting object ! 121: returns the blocked flags (1 = floor, 2 = step / wall) ! 122: ================== ! 123: */ ! 124: #define STOP_EPSILON 0.1 ! 125: ! 126: int ClipVelocity (vec3_t in, vec3_t normal, vec3_t out, float overbounce) ! 127: { ! 128: float backoff; ! 129: float change; ! 130: int i, blocked; ! 131: ! 132: blocked = 0; ! 133: if (normal[2] > 0) ! 134: blocked |= 1; // floor ! 135: if (!normal[2]) ! 136: blocked |= 2; // step ! 137: ! 138: backoff = DotProduct (in, normal) * overbounce; ! 139: ! 140: for (i=0 ; i<3 ; i++) ! 141: { ! 142: change = normal[i]*backoff; ! 143: out[i] = in[i] - change; ! 144: if (out[i] > -STOP_EPSILON && out[i] < STOP_EPSILON) ! 145: out[i] = 0; ! 146: } ! 147: ! 148: return blocked; ! 149: } ! 150: ! 151: ! 152: /* ! 153: ============ ! 154: SV_FlyMove ! 155: ! 156: The basic solid body movement clip that slides along multiple planes ! 157: Returns the clipflags if the velocity was modified (hit something solid) ! 158: 1 = floor ! 159: 2 = wall / step ! 160: 4 = dead stop ! 161: ============ ! 162: */ ! 163: #define MAX_CLIP_PLANES 5 ! 164: int SV_FlyMove (edict_t *ent, float time, int mask) ! 165: { ! 166: edict_t *hit; ! 167: int bumpcount, numbumps; ! 168: vec3_t dir; ! 169: float d; ! 170: int numplanes; ! 171: vec3_t planes[MAX_CLIP_PLANES]; ! 172: vec3_t primal_velocity, original_velocity, new_velocity; ! 173: int i, j; ! 174: trace_t trace; ! 175: vec3_t end; ! 176: float time_left; ! 177: int blocked; ! 178: ! 179: numbumps = 4; ! 180: ! 181: blocked = 0; ! 182: VectorCopy (ent->velocity, original_velocity); ! 183: VectorCopy (ent->velocity, primal_velocity); ! 184: numplanes = 0; ! 185: ! 186: time_left = time; ! 187: ! 188: ent->groundentity = NULL; ! 189: for (bumpcount=0 ; bumpcount<numbumps ; bumpcount++) ! 190: { ! 191: for (i=0 ; i<3 ; i++) ! 192: end[i] = ent->s.origin[i] + time_left * ent->velocity[i]; ! 193: ! 194: trace = gi.trace (ent->s.origin, ent->mins, ent->maxs, end, ent, mask); ! 195: ! 196: if (trace.allsolid) ! 197: { // entity is trapped in another solid ! 198: VectorCopy (vec3_origin, ent->velocity); ! 199: return 3; ! 200: } ! 201: ! 202: if (trace.fraction > 0) ! 203: { // actually covered some distance ! 204: VectorCopy (trace.endpos, ent->s.origin); ! 205: VectorCopy (ent->velocity, original_velocity); ! 206: numplanes = 0; ! 207: } ! 208: ! 209: if (trace.fraction == 1) ! 210: break; // moved the entire distance ! 211: ! 212: hit = trace.ent; ! 213: ! 214: if (trace.plane.normal[2] > 0.7) ! 215: { ! 216: blocked |= 1; // floor ! 217: if ( hit->solid == SOLID_BSP) ! 218: { ! 219: ent->groundentity = hit; ! 220: ent->groundentity_linkcount = hit->linkcount; ! 221: } ! 222: } ! 223: if (!trace.plane.normal[2]) ! 224: { ! 225: blocked |= 2; // step ! 226: } ! 227: ! 228: // ! 229: // run the impact function ! 230: // ! 231: SV_Impact (ent, &trace); ! 232: if (!ent->inuse) ! 233: break; // removed by the impact function ! 234: ! 235: ! 236: time_left -= time_left * trace.fraction; ! 237: ! 238: // cliped to another plane ! 239: if (numplanes >= MAX_CLIP_PLANES) ! 240: { // this shouldn't really happen ! 241: VectorCopy (vec3_origin, ent->velocity); ! 242: return 3; ! 243: } ! 244: ! 245: VectorCopy (trace.plane.normal, planes[numplanes]); ! 246: numplanes++; ! 247: ! 248: // ! 249: // modify original_velocity so it parallels all of the clip planes ! 250: // ! 251: for (i=0 ; i<numplanes ; i++) ! 252: { ! 253: ClipVelocity (original_velocity, planes[i], new_velocity, 1); ! 254: for (j=0 ; j<numplanes ; j++) ! 255: if (j != i) ! 256: { ! 257: if (DotProduct (new_velocity, planes[j]) < 0) ! 258: break; // not ok ! 259: } ! 260: if (j == numplanes) ! 261: break; ! 262: } ! 263: ! 264: if (i != numplanes) ! 265: { // go along this plane ! 266: VectorCopy (new_velocity, ent->velocity); ! 267: } ! 268: else ! 269: { // go along the crease ! 270: if (numplanes != 2) ! 271: { ! 272: // gi.dprintf ("clip velocity, numplanes == %i\n",numplanes); ! 273: VectorCopy (vec3_origin, ent->velocity); ! 274: return 7; ! 275: } ! 276: CrossProduct (planes[0], planes[1], dir); ! 277: d = DotProduct (dir, ent->velocity); ! 278: VectorScale (dir, d, ent->velocity); ! 279: } ! 280: ! 281: // ! 282: // if original velocity is against the original velocity, stop dead ! 283: // to avoid tiny occilations in sloping corners ! 284: // ! 285: if (DotProduct (ent->velocity, primal_velocity) <= 0) ! 286: { ! 287: VectorCopy (vec3_origin, ent->velocity); ! 288: return blocked; ! 289: } ! 290: } ! 291: ! 292: return blocked; ! 293: } ! 294: ! 295: ! 296: /* ! 297: ============ ! 298: SV_AddGravity ! 299: ! 300: ============ ! 301: */ ! 302: void SV_AddGravity (edict_t *ent) ! 303: { ! 304: ent->velocity[2] -= ent->gravity * sv_gravity->value * FRAMETIME; ! 305: } ! 306: ! 307: /* ! 308: =============================================================================== ! 309: ! 310: PUSHMOVE ! 311: ! 312: =============================================================================== ! 313: */ ! 314: ! 315: /* ! 316: ============ ! 317: SV_PushEntity ! 318: ! 319: Does not change the entities velocity at all ! 320: ============ ! 321: */ ! 322: trace_t SV_PushEntity (edict_t *ent, vec3_t push) ! 323: { ! 324: trace_t trace; ! 325: vec3_t start; ! 326: vec3_t end; ! 327: int mask; ! 328: ! 329: VectorCopy (ent->s.origin, start); ! 330: VectorAdd (start, push, end); ! 331: ! 332: retry: ! 333: if (ent->clipmask) ! 334: mask = ent->clipmask; ! 335: else ! 336: mask = MASK_SOLID; ! 337: ! 338: trace = gi.trace (start, ent->mins, ent->maxs, end, ent, mask); ! 339: ! 340: VectorCopy (trace.endpos, ent->s.origin); ! 341: gi.linkentity (ent); ! 342: ! 343: if (trace.fraction != 1.0) ! 344: { ! 345: SV_Impact (ent, &trace); ! 346: ! 347: // if the pushed entity went away and the pusher is still there ! 348: if (!trace.ent->inuse && ent->inuse) ! 349: { ! 350: // move the pusher back and try again ! 351: VectorCopy (start, ent->s.origin); ! 352: gi.linkentity (ent); ! 353: goto retry; ! 354: } ! 355: } ! 356: ! 357: if (ent->inuse) ! 358: G_TouchTriggers (ent); ! 359: ! 360: return trace; ! 361: } ! 362: ! 363: ! 364: typedef struct ! 365: { ! 366: edict_t *ent; ! 367: vec3_t origin; ! 368: vec3_t angles; ! 369: float deltayaw; ! 370: } pushed_t; ! 371: pushed_t pushed[MAX_EDICTS], *pushed_p; ! 372: ! 373: edict_t *obstacle; ! 374: ! 375: /* ! 376: ============ ! 377: SV_Push ! 378: ! 379: Objects need to be moved back on a failed push, ! 380: otherwise riders would continue to slide. ! 381: ============ ! 382: */ ! 383: qboolean SV_Push (edict_t *pusher, vec3_t move, vec3_t amove) ! 384: { ! 385: int i, e; ! 386: edict_t *check, *block; ! 387: vec3_t mins, maxs; ! 388: pushed_t *p; ! 389: vec3_t org, org2, move2, forward, right, up; ! 390: ! 391: // clamp the move to 1/8 units, so the position will ! 392: // be accurate for client side prediction ! 393: for (i=0 ; i<3 ; i++) ! 394: { ! 395: float temp; ! 396: temp = move[i]*8.0; ! 397: if (temp > 0.0) ! 398: temp += 0.5; ! 399: else ! 400: temp -= 0.5; ! 401: move[i] = 0.125 * (int)temp; ! 402: } ! 403: ! 404: // find the bounding box ! 405: for (i=0 ; i<3 ; i++) ! 406: { ! 407: mins[i] = pusher->absmin[i] + move[i]; ! 408: maxs[i] = pusher->absmax[i] + move[i]; ! 409: } ! 410: ! 411: // we need this for pushing things later ! 412: VectorSubtract (vec3_origin, amove, org); ! 413: AngleVectors (org, forward, right, up); ! 414: ! 415: // save the pusher's original position ! 416: pushed_p->ent = pusher; ! 417: VectorCopy (pusher->s.origin, pushed_p->origin); ! 418: VectorCopy (pusher->s.angles, pushed_p->angles); ! 419: if (pusher->client) ! 420: pushed_p->deltayaw = pusher->client->ps.pmove.delta_angles[YAW]; ! 421: pushed_p++; ! 422: ! 423: // move the pusher to it's final position ! 424: VectorAdd (pusher->s.origin, move, pusher->s.origin); ! 425: VectorAdd (pusher->s.angles, amove, pusher->s.angles); ! 426: gi.linkentity (pusher); ! 427: ! 428: // see if any solid entities are inside the final position ! 429: check = g_edicts+1; ! 430: for (e = 1; e < globals.num_edicts; e++, check++) ! 431: { ! 432: if (!check->inuse) ! 433: continue; ! 434: if (check->movetype == MOVETYPE_PUSH ! 435: || check->movetype == MOVETYPE_STOP ! 436: || check->movetype == MOVETYPE_NONE ! 437: || check->movetype == MOVETYPE_NOCLIP) ! 438: continue; ! 439: ! 440: if (!check->area.prev) ! 441: continue; // not linked in anywhere ! 442: ! 443: // if the entity is standing on the pusher, it will definitely be moved ! 444: if (check->groundentity != pusher) ! 445: { ! 446: // see if the ent needs to be tested ! 447: if ( check->absmin[0] >= maxs[0] ! 448: || check->absmin[1] >= maxs[1] ! 449: || check->absmin[2] >= maxs[2] ! 450: || check->absmax[0] <= mins[0] ! 451: || check->absmax[1] <= mins[1] ! 452: || check->absmax[2] <= mins[2] ) ! 453: continue; ! 454: ! 455: // see if the ent's bbox is inside the pusher's final position ! 456: if (!SV_TestEntityPosition (check)) ! 457: continue; ! 458: } ! 459: ! 460: if ((pusher->movetype == MOVETYPE_PUSH) || (check->groundentity == pusher)) ! 461: { ! 462: // move this entity ! 463: pushed_p->ent = check; ! 464: VectorCopy (check->s.origin, pushed_p->origin); ! 465: VectorCopy (check->s.angles, pushed_p->angles); ! 466: pushed_p++; ! 467: ! 468: // try moving the contacted entity ! 469: VectorAdd (check->s.origin, move, check->s.origin); ! 470: if (check->client) ! 471: { // FIXME: doesn't rotate monsters? ! 472: check->client->ps.pmove.delta_angles[YAW] += amove[YAW]; ! 473: } ! 474: ! 475: // figure movement due to the pusher's amove ! 476: VectorSubtract (check->s.origin, pusher->s.origin, org); ! 477: org2[0] = DotProduct (org, forward); ! 478: org2[1] = -DotProduct (org, right); ! 479: org2[2] = DotProduct (org, up); ! 480: VectorSubtract (org2, org, move2); ! 481: VectorAdd (check->s.origin, move2, check->s.origin); ! 482: ! 483: // may have pushed them off an edge ! 484: if (check->groundentity != pusher) ! 485: check->groundentity = NULL; ! 486: ! 487: block = SV_TestEntityPosition (check); ! 488: if (!block) ! 489: { // pushed ok ! 490: gi.linkentity (check); ! 491: // impact? ! 492: continue; ! 493: } ! 494: ! 495: // if it is ok to leave in the old position, do it ! 496: // this is only relevent for riding entities, not pushed ! 497: // FIXME: this doesn't acount for rotation ! 498: VectorSubtract (check->s.origin, move, check->s.origin); ! 499: block = SV_TestEntityPosition (check); ! 500: if (!block) ! 501: { ! 502: pushed_p--; ! 503: continue; ! 504: } ! 505: } ! 506: ! 507: // save off the obstacle so we can call the block function ! 508: obstacle = check; ! 509: ! 510: // move back any entities we already moved ! 511: // go backwards, so if the same entity was pushed ! 512: // twice, it goes back to the original position ! 513: for (p=pushed_p-1 ; p>=pushed ; p--) ! 514: { ! 515: VectorCopy (p->origin, p->ent->s.origin); ! 516: VectorCopy (p->angles, p->ent->s.angles); ! 517: if (p->ent->client) ! 518: { ! 519: p->ent->client->ps.pmove.delta_angles[YAW] = p->deltayaw; ! 520: } ! 521: gi.linkentity (p->ent); ! 522: } ! 523: return false; ! 524: } ! 525: ! 526: //FIXME: is there a better way to handle this? ! 527: // see if anything we moved has touched a trigger ! 528: for (p=pushed_p-1 ; p>=pushed ; p--) ! 529: G_TouchTriggers (p->ent); ! 530: ! 531: return true; ! 532: } ! 533: ! 534: /* ! 535: ================ ! 536: SV_Physics_Pusher ! 537: ! 538: Bmodel objects don't interact with each other, but ! 539: push all box objects ! 540: ================ ! 541: */ ! 542: void SV_Physics_Pusher (edict_t *ent) ! 543: { ! 544: vec3_t move, amove; ! 545: edict_t *part, *mv; ! 546: ! 547: // if not a team captain, so movement will be handled elsewhere ! 548: if ( ent->flags & FL_TEAMSLAVE) ! 549: return; ! 550: ! 551: // make sure all team slaves can move before commiting ! 552: // any moves or calling any think functions ! 553: // if the move is blocked, all moved objects will be backed out ! 554: //retry: ! 555: pushed_p = pushed; ! 556: for (part = ent ; part ; part=part->teamchain) ! 557: { ! 558: if (part->velocity[0] || part->velocity[1] || part->velocity[2] || ! 559: part->avelocity[0] || part->avelocity[1] || part->avelocity[2] ! 560: ) ! 561: { // object is moving ! 562: VectorScale (part->velocity, FRAMETIME, move); ! 563: VectorScale (part->avelocity, FRAMETIME, amove); ! 564: ! 565: if (!SV_Push (part, move, amove)) ! 566: break; // move was blocked ! 567: } ! 568: } ! 569: if (pushed_p > &pushed[MAX_EDICTS]) ! 570: gi.error (ERR_FATAL, "pushed_p > &pushed[MAX_EDICTS], memory corrupted"); ! 571: ! 572: if (part) ! 573: { ! 574: // the move failed, bump all nextthink times and back out moves ! 575: for (mv = ent ; mv ; mv=mv->teamchain) ! 576: { ! 577: if (mv->nextthink > 0) ! 578: mv->nextthink += FRAMETIME; ! 579: } ! 580: ! 581: // if the pusher has a "blocked" function, call it ! 582: // otherwise, just stay in place until the obstacle is gone ! 583: if (part->blocked) ! 584: part->blocked (part, obstacle); ! 585: #if 0 ! 586: // if the pushed entity went away and the pusher is still there ! 587: if (!obstacle->inuse && part->inuse) ! 588: goto retry; ! 589: #endif ! 590: } ! 591: else ! 592: { ! 593: // the move succeeded, so call all think functions ! 594: for (part = ent ; part ; part=part->teamchain) ! 595: { ! 596: SV_RunThink (part); ! 597: } ! 598: } ! 599: } ! 600: ! 601: //================================================================== ! 602: ! 603: /* ! 604: ============= ! 605: SV_Physics_None ! 606: ! 607: Non moving objects can only think ! 608: ============= ! 609: */ ! 610: void SV_Physics_None (edict_t *ent) ! 611: { ! 612: // regular thinking ! 613: SV_RunThink (ent); ! 614: } ! 615: ! 616: /* ! 617: ============= ! 618: SV_Physics_Noclip ! 619: ! 620: A moving object that doesn't obey physics ! 621: ============= ! 622: */ ! 623: void SV_Physics_Noclip (edict_t *ent) ! 624: { ! 625: // regular thinking ! 626: if (!SV_RunThink (ent)) ! 627: return; ! 628: ! 629: VectorMA (ent->s.angles, FRAMETIME, ent->avelocity, ent->s.angles); ! 630: VectorMA (ent->s.origin, FRAMETIME, ent->velocity, ent->s.origin); ! 631: ! 632: gi.linkentity (ent); ! 633: } ! 634: ! 635: /* ! 636: ============================================================================== ! 637: ! 638: TOSS / BOUNCE ! 639: ! 640: ============================================================================== ! 641: */ ! 642: ! 643: /* ! 644: ============= ! 645: SV_Physics_Toss ! 646: ! 647: Toss, bounce, and fly movement. When onground, do nothing. ! 648: ============= ! 649: */ ! 650: void SV_Physics_Toss (edict_t *ent) ! 651: { ! 652: trace_t trace; ! 653: vec3_t move; ! 654: float backoff; ! 655: edict_t *slave; ! 656: qboolean wasinwater; ! 657: qboolean isinwater; ! 658: vec3_t old_origin; ! 659: ! 660: // regular thinking ! 661: SV_RunThink (ent); ! 662: ! 663: // if not a team captain, so movement will be handled elsewhere ! 664: if ( ent->flags & FL_TEAMSLAVE) ! 665: return; ! 666: ! 667: if (ent->velocity[2] > 0) ! 668: ent->groundentity = NULL; ! 669: ! 670: // check for the groundentity going away ! 671: if (ent->groundentity) ! 672: if (!ent->groundentity->inuse) ! 673: ent->groundentity = NULL; ! 674: ! 675: // if onground, return without moving ! 676: if ( ent->groundentity ) ! 677: return; ! 678: ! 679: VectorCopy (ent->s.origin, old_origin); ! 680: ! 681: SV_CheckVelocity (ent); ! 682: ! 683: // add gravity ! 684: if (ent->movetype != MOVETYPE_FLY ! 685: && ent->movetype != MOVETYPE_FLYMISSILE) ! 686: SV_AddGravity (ent); ! 687: ! 688: // move angles ! 689: VectorMA (ent->s.angles, FRAMETIME, ent->avelocity, ent->s.angles); ! 690: ! 691: // move origin ! 692: VectorScale (ent->velocity, FRAMETIME, move); ! 693: trace = SV_PushEntity (ent, move); ! 694: if (!ent->inuse) ! 695: return; ! 696: ! 697: if (trace.fraction < 1) ! 698: { ! 699: if (ent->movetype == MOVETYPE_BOUNCE) ! 700: backoff = 1.5; ! 701: else ! 702: backoff = 1; ! 703: ! 704: ClipVelocity (ent->velocity, trace.plane.normal, ent->velocity, backoff); ! 705: ! 706: // stop if on ground ! 707: if (trace.plane.normal[2] > 0.7) ! 708: { ! 709: if (ent->velocity[2] < 60 || ent->movetype != MOVETYPE_BOUNCE ) ! 710: { ! 711: ent->groundentity = trace.ent; ! 712: ent->groundentity_linkcount = trace.ent->linkcount; ! 713: VectorCopy (vec3_origin, ent->velocity); ! 714: VectorCopy (vec3_origin, ent->avelocity); ! 715: } ! 716: } ! 717: ! 718: // if (ent->touch) ! 719: // ent->touch (ent, trace.ent, &trace.plane, trace.surface); ! 720: } ! 721: ! 722: // check for water transition ! 723: wasinwater = (ent->watertype & MASK_WATER); ! 724: ent->watertype = gi.pointcontents (ent->s.origin); ! 725: isinwater = ent->watertype & MASK_WATER; ! 726: ! 727: if (isinwater) ! 728: ent->waterlevel = 1; ! 729: else ! 730: ent->waterlevel = 0; ! 731: ! 732: if (!wasinwater && isinwater) ! 733: gi.positioned_sound (old_origin, g_edicts, CHAN_AUTO, gi.soundindex("misc/h2ohit1.wav"), 1, 1, 0); ! 734: else if (wasinwater && !isinwater) ! 735: gi.positioned_sound (ent->s.origin, g_edicts, CHAN_AUTO, gi.soundindex("misc/h2ohit1.wav"), 1, 1, 0); ! 736: ! 737: // move teamslaves ! 738: for (slave = ent->teamchain; slave; slave = slave->teamchain) ! 739: { ! 740: VectorCopy (ent->s.origin, slave->s.origin); ! 741: gi.linkentity (slave); ! 742: } ! 743: } ! 744: ! 745: /* ! 746: =============================================================================== ! 747: ! 748: STEPPING MOVEMENT ! 749: ! 750: =============================================================================== ! 751: */ ! 752: ! 753: /* ! 754: ============= ! 755: SV_Physics_Step ! 756: ! 757: Monsters freefall when they don't have a ground entity, otherwise ! 758: all movement is done with discrete steps. ! 759: ! 760: This is also used for objects that have become still on the ground, but ! 761: will fall if the floor is pulled out from under them. ! 762: FIXME: is this true? ! 763: ============= ! 764: */ ! 765: ! 766: //FIXME: hacked in for E3 demo ! 767: #define sv_stopspeed 100 ! 768: #define sv_friction 6 ! 769: #define sv_waterfriction 1 ! 770: ! 771: void SV_AddRotationalFriction (edict_t *ent) ! 772: { ! 773: int n; ! 774: float adjustment; ! 775: ! 776: VectorMA (ent->s.angles, FRAMETIME, ent->avelocity, ent->s.angles); ! 777: adjustment = FRAMETIME * sv_stopspeed * sv_friction; ! 778: for (n = 0; n < 3; n++) ! 779: { ! 780: if (ent->avelocity[n] > 0) ! 781: { ! 782: ent->avelocity[n] -= adjustment; ! 783: if (ent->avelocity[n] < 0) ! 784: ent->avelocity[n] = 0; ! 785: } ! 786: else ! 787: { ! 788: ent->avelocity[n] += adjustment; ! 789: if (ent->avelocity[n] > 0) ! 790: ent->avelocity[n] = 0; ! 791: } ! 792: } ! 793: } ! 794: ! 795: void SV_Physics_Step (edict_t *ent) ! 796: { ! 797: qboolean wasonground; ! 798: qboolean hitsound = false; ! 799: float *vel; ! 800: float speed, newspeed, control; ! 801: float friction; ! 802: edict_t *groundentity; ! 803: int mask; ! 804: ! 805: // airborn monsters should always check for ground ! 806: if (!ent->groundentity) ! 807: M_CheckGround (ent); ! 808: ! 809: groundentity = ent->groundentity; ! 810: ! 811: SV_CheckVelocity (ent); ! 812: ! 813: if (groundentity) ! 814: wasonground = true; ! 815: else ! 816: wasonground = false; ! 817: ! 818: if (ent->avelocity[0] || ent->avelocity[1] || ent->avelocity[2]) ! 819: SV_AddRotationalFriction (ent); ! 820: ! 821: // add gravity except: ! 822: // flying monsters ! 823: // swimming monsters who are in the water ! 824: if (! wasonground) ! 825: if (!(ent->flags & FL_FLY)) ! 826: if (!((ent->flags & FL_SWIM) && (ent->waterlevel > 2))) ! 827: { ! 828: if (ent->velocity[2] < sv_gravity->value*-0.1) ! 829: hitsound = true; ! 830: if (ent->waterlevel == 0) ! 831: SV_AddGravity (ent); ! 832: } ! 833: ! 834: // friction for flying monsters that have been given vertical velocity ! 835: if ((ent->flags & FL_FLY) && (ent->velocity[2] != 0)) ! 836: { ! 837: speed = fabs(ent->velocity[2]); ! 838: control = speed < sv_stopspeed ? sv_stopspeed : speed; ! 839: friction = sv_friction/3; ! 840: newspeed = speed - (FRAMETIME * control * friction); ! 841: if (newspeed < 0) ! 842: newspeed = 0; ! 843: newspeed /= speed; ! 844: ent->velocity[2] *= newspeed; ! 845: } ! 846: ! 847: // friction for flying monsters that have been given vertical velocity ! 848: if ((ent->flags & FL_SWIM) && (ent->velocity[2] != 0)) ! 849: { ! 850: speed = fabs(ent->velocity[2]); ! 851: control = speed < sv_stopspeed ? sv_stopspeed : speed; ! 852: newspeed = speed - (FRAMETIME * control * sv_waterfriction * ent->waterlevel); ! 853: if (newspeed < 0) ! 854: newspeed = 0; ! 855: newspeed /= speed; ! 856: ent->velocity[2] *= newspeed; ! 857: } ! 858: ! 859: if (ent->velocity[2] || ent->velocity[1] || ent->velocity[0]) ! 860: { ! 861: // apply friction ! 862: // let dead monsters who aren't completely onground slide ! 863: if ((wasonground) || (ent->flags & (FL_SWIM|FL_FLY))) ! 864: if (!(ent->health <= 0.0 && !M_CheckBottom(ent))) ! 865: { ! 866: vel = ent->velocity; ! 867: speed = sqrt(vel[0]*vel[0] +vel[1]*vel[1]); ! 868: if (speed) ! 869: { ! 870: friction = sv_friction; ! 871: ! 872: control = speed < sv_stopspeed ? sv_stopspeed : speed; ! 873: newspeed = speed - FRAMETIME*control*friction; ! 874: ! 875: if (newspeed < 0) ! 876: newspeed = 0; ! 877: newspeed /= speed; ! 878: ! 879: vel[0] *= newspeed; ! 880: vel[1] *= newspeed; ! 881: } ! 882: } ! 883: ! 884: if (ent->svflags & SVF_MONSTER) ! 885: mask = MASK_MONSTERSOLID; ! 886: else ! 887: mask = MASK_SOLID; ! 888: SV_FlyMove (ent, FRAMETIME, mask); ! 889: ! 890: gi.linkentity (ent); ! 891: G_TouchTriggers (ent); ! 892: ! 893: if (ent->groundentity) ! 894: if (!wasonground) ! 895: if (hitsound) ! 896: gi.sound (ent, 0, gi.soundindex("world/land.wav"), 1, 1, 0); ! 897: } ! 898: ! 899: // regular thinking ! 900: SV_RunThink (ent); ! 901: } ! 902: ! 903: //============================================================================ ! 904: /* ! 905: ================ ! 906: G_RunEntity ! 907: ! 908: ================ ! 909: */ ! 910: void G_RunEntity (edict_t *ent) ! 911: { ! 912: if (ent->prethink) ! 913: ent->prethink (ent); ! 914: ! 915: switch ( (int)ent->movetype) ! 916: { ! 917: case MOVETYPE_PUSH: ! 918: case MOVETYPE_STOP: ! 919: SV_Physics_Pusher (ent); ! 920: break; ! 921: case MOVETYPE_NONE: ! 922: SV_Physics_None (ent); ! 923: break; ! 924: case MOVETYPE_NOCLIP: ! 925: SV_Physics_Noclip (ent); ! 926: break; ! 927: case MOVETYPE_STEP: ! 928: SV_Physics_Step (ent); ! 929: break; ! 930: case MOVETYPE_TOSS: ! 931: case MOVETYPE_BOUNCE: ! 932: case MOVETYPE_FLY: ! 933: case MOVETYPE_FLYMISSILE: ! 934: SV_Physics_Toss (ent); ! 935: break; ! 936: default: ! 937: gi.error ("SV_Physics: bad movetype %i", (int)ent->movetype); ! 938: } ! 939: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.