![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to pmove.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Quake II] / quake2 / qcommon|
Return to pmove.c CVS log | Up to [Quake II] / quake2 / qcommon |
1.1 ! root 1: ! 2: #include "qcommon.h" ! 3: ! 4: #define STEPSIZE 18 ! 5: ! 6: // all of the locals will be zeroed before each ! 7: // pmove, just to make damn sure we don't have ! 8: // any differences when running on client or server ! 9: ! 10: typedef struct ! 11: { ! 12: vec3_t origin; // full float precision ! 13: vec3_t velocity; // full float precision ! 14: ! 15: vec3_t forward, right, up; ! 16: float frametime; ! 17: ! 18: ! 19: csurface_t *groundsurface; ! 20: cplane_t groundplane; ! 21: int groundcontents; ! 22: ! 23: vec3_t previous_origin; ! 24: qboolean ladder; ! 25: } pml_t; ! 26: ! 27: pmove_t *pm; ! 28: pml_t pml; ! 29: ! 30: // movement parameters ! 31: float pm_stopspeed = 100; ! 32: float pm_maxspeed = 300; ! 33: float pm_duckspeed = 100; ! 34: float pm_accelerate = 10; ! 35: float pm_airaccelerate = 1; ! 36: float pm_wateraccelerate = 10; ! 37: float pm_friction = 6; ! 38: float pm_waterfriction = 1; ! 39: float pm_waterspeed = 400; ! 40: /* ! 41: walking up a step should kill some velocity ! 42: */ ! 43: /* ! 44: ================== ! 45: PM_ClipVelocity ! 46: Slide off of the impacting object ! 47: returns the blocked flags (1 = floor, 2 = step / wall) ! 48: ================== ! 49: */ ! 50: #define STOP_EPSILON 0.1 ! 51: void PM_ClipVelocity (vec3_t in, vec3_t normal, vec3_t out, float overbounce) ! 52: { ! 53: float backoff; ! 54: float change; ! 55: int i; ! 56: ! 57: backoff = DotProduct (in, normal) * overbounce; ! 58: for (i=0 ; i<3 ; i++) ! 59: { ! 60: change = normal[i]*backoff; ! 61: out[i] = in[i] - change; ! 62: if (out[i] > -STOP_EPSILON && out[i] < STOP_EPSILON) ! 63: out[i] = 0; ! 64: } ! 65: } ! 66: /* ! 67: ================== ! 68: PM_StepSlideMove ! 69: Each intersection will try to step over the obstruction instead of ! 70: sliding along it. ! 71: Returns a new origin, velocity, and contact entity ! 72: Does not modify any world state? ! 73: ================== ! 74: */ ! 75: #define MIN_STEP_NORMAL 0.7 // can't step up onto very steep slopes ! 76: #define MAX_CLIP_PLANES 5 ! 77: void PM_StepSlideMove_ (void) ! 78: { ! 79: int bumpcount, numbumps; ! 80: vec3_t dir; ! 81: float d, rub; ! 82: int numplanes; ! 83: vec3_t planes[MAX_CLIP_PLANES]; ! 84: vec3_t primal_velocity; ! 85: int i; ! 86: trace_t trace; ! 87: vec3_t end; ! 88: float time_left; ! 89: ! 90: numbumps = 4; ! 91: ! 92: VectorCopy (pml.velocity, primal_velocity); ! 93: numplanes = 0; ! 94: ! 95: time_left = pml.frametime; ! 96: for (bumpcount=0 ; bumpcount<numbumps ; bumpcount++) ! 97: { ! 98: for (i=0 ; i<3 ; i++) ! 99: end[i] = pml.origin[i] + time_left * pml.velocity[i]; ! 100: trace = pm->trace (pml.origin, pm->mins, pm->maxs, end); ! 101: if (trace.allsolid) ! 102: { // entity is trapped in another solid ! 103: pml.velocity[2] = 0; // don't build up falling damage ! 104: return; ! 105: } ! 106: if (trace.fraction > 0) ! 107: { // actually covered some distance ! 108: VectorCopy (trace.endpos, pml.origin); ! 109: numplanes = 0; ! 110: } ! 111: if (trace.fraction == 1) ! 112: break; // moved the entire distance ! 113: // save entity for contact ! 114: if (pm->numtouch < MAXTOUCH && trace.ent) ! 115: { ! 116: pm->touchents[pm->numtouch] = trace.ent; ! 117: pm->numtouch++; ! 118: } ! 119: ! 120: time_left -= time_left * trace.fraction; ! 121: // slide along this plane ! 122: if (numplanes >= MAX_CLIP_PLANES) ! 123: { // this shouldn't really happen ! 124: VectorCopy (vec3_origin, pml.velocity); ! 125: break; ! 126: } ! 127: VectorCopy (trace.plane.normal, planes[numplanes]); ! 128: numplanes++; ! 129: // ! 130: // modify velocity so it parallels all of the clip planes ! 131: // ! 132: if (numplanes == 1) ! 133: { // go along this plane ! 134: VectorCopy (pml.velocity, dir); ! 135: VectorNormalize (dir); ! 136: rub = 1.0 + 0.5 * DotProduct (dir, planes[0]); ! 137: ! 138: // slide along the plane ! 139: PM_ClipVelocity (pml.velocity, planes[0], pml.velocity, 1.01); ! 140: // rub some extra speed off on xy axis ! 141: // not on Z, or you can scrub down walls ! 142: pml.velocity[0] *= rub; ! 143: pml.velocity[1] *= rub; ! 144: pml.velocity[2] *= rub; ! 145: } ! 146: else if (numplanes == 2) ! 147: { // go along the crease ! 148: VectorCopy (pml.velocity, dir); ! 149: VectorNormalize (dir); ! 150: rub = 1.0 + 0.5 * DotProduct (dir, planes[0]); ! 151: ! 152: // slide along the plane ! 153: CrossProduct (planes[0], planes[1], dir); ! 154: d = DotProduct (dir, pml.velocity); ! 155: VectorScale (dir, d, pml.velocity); ! 156: // rub some extra speed off ! 157: VectorScale (pml.velocity, rub, pml.velocity); ! 158: } ! 159: else ! 160: { ! 161: // Con_Printf ("clip velocity, numplanes == %i\n",numplanes); ! 162: VectorCopy (vec3_origin, pml.velocity); ! 163: break; ! 164: } ! 165: // ! 166: // if velocity is against the original velocity, stop dead ! 167: // to avoid tiny occilations in sloping corners ! 168: // ! 169: if (DotProduct (pml.velocity, primal_velocity) <= 0) ! 170: { ! 171: VectorCopy (vec3_origin, pml.velocity); ! 172: break; ! 173: } ! 174: } ! 175: if (pm->s.pm_time) ! 176: { ! 177: VectorCopy (primal_velocity, pml.velocity); ! 178: } ! 179: } ! 180: ! 181: /* ! 182: ================== ! 183: PM_StepSlideMove ! 184: ! 185: ================== ! 186: */ ! 187: void PM_StepSlideMove (void) ! 188: { ! 189: vec3_t start_o, start_v; ! 190: vec3_t down_o, down_v; ! 191: trace_t trace; ! 192: float down_dist, up_dist; ! 193: vec3_t delta; ! 194: vec3_t up, down; ! 195: ! 196: VectorCopy (pml.origin, start_o); ! 197: VectorCopy (pml.velocity, start_v); ! 198: ! 199: PM_StepSlideMove_ (); ! 200: ! 201: VectorCopy (pml.origin, down_o); ! 202: VectorCopy (pml.velocity, down_v); ! 203: ! 204: VectorCopy (start_o, up); ! 205: up[2] += STEPSIZE; ! 206: ! 207: trace = pm->trace (up, pm->mins, pm->maxs, up); ! 208: if (trace.allsolid) ! 209: return; // can't step up ! 210: ! 211: // try sliding above ! 212: VectorCopy (up, pml.origin); ! 213: VectorCopy (start_v, pml.velocity); ! 214: ! 215: PM_StepSlideMove_ (); ! 216: ! 217: // push down the final amount ! 218: VectorCopy (pml.origin, down); ! 219: down[2] -= STEPSIZE; ! 220: trace = pm->trace (pml.origin, pm->mins, pm->maxs, down); ! 221: if (!trace.allsolid) ! 222: { ! 223: VectorCopy (trace.endpos, pml.origin); ! 224: } ! 225: ! 226: VectorSubtract (pml.origin, up, delta); ! 227: up_dist = DotProduct (delta, start_v); ! 228: ! 229: VectorSubtract (down_o, start_o, delta); ! 230: down_dist = DotProduct (delta, start_v); ! 231: ! 232: if (down_dist > up_dist || trace.plane.normal[2] < MIN_STEP_NORMAL) ! 233: { ! 234: VectorCopy (down_o, pml.origin); ! 235: VectorCopy (down_v, pml.velocity); ! 236: return; ! 237: } ! 238: ! 239: } ! 240: ! 241: /* ! 242: ================== ! 243: PM_Friction ! 244: Handles both ground friction and water friction ! 245: ================== ! 246: */ ! 247: void PM_Friction (void) ! 248: { ! 249: float *vel; ! 250: float speed, newspeed, control; ! 251: float friction; ! 252: float drop; ! 253: ! 254: vel = pml.velocity; ! 255: ! 256: speed = sqrt(vel[0]*vel[0] +vel[1]*vel[1] + vel[2]*vel[2]); ! 257: if (speed < 1) ! 258: { ! 259: vel[0] = 0; ! 260: vel[1] = 0; ! 261: return; ! 262: } ! 263: drop = 0; ! 264: // apply ground friction ! 265: if ((pm->groundentity && pml.groundsurface && !(pml.groundsurface->flags & SURF_SLICK) ) || (pml.ladder) ) ! 266: { ! 267: friction = pm_friction; ! 268: control = speed < pm_stopspeed ? pm_stopspeed : speed; ! 269: drop += control*friction*pml.frametime; ! 270: } ! 271: // apply water friction ! 272: if (pm->waterlevel && !pml.ladder) ! 273: drop += speed*pm_waterfriction*pm->waterlevel*pml.frametime; ! 274: // scale the velocity ! 275: newspeed = speed - drop; ! 276: if (newspeed < 0) ! 277: { ! 278: newspeed = 0; ! 279: } ! 280: newspeed /= speed; ! 281: vel[0] = vel[0] * newspeed; ! 282: vel[1] = vel[1] * newspeed; ! 283: vel[2] = vel[2] * newspeed; ! 284: } ! 285: /* ! 286: ============== ! 287: PM_Accelerate ! 288: Handles user intended acceleration ! 289: ============== ! 290: */ ! 291: void PM_Accelerate (vec3_t wishdir, float wishspeed, float accel) ! 292: { ! 293: int i; ! 294: float addspeed, accelspeed, currentspeed; ! 295: ! 296: currentspeed = DotProduct (pml.velocity, wishdir); ! 297: addspeed = wishspeed - currentspeed; ! 298: if (addspeed <= 0) ! 299: return; ! 300: accelspeed = accel*pml.frametime*wishspeed; ! 301: if (accelspeed > addspeed) ! 302: accelspeed = addspeed; ! 303: ! 304: for (i=0 ; i<3 ; i++) ! 305: pml.velocity[i] += accelspeed*wishdir[i]; ! 306: } ! 307: /* ! 308: ============= ! 309: PM_AddCurrents ! 310: ============= ! 311: */ ! 312: void PM_AddCurrents (vec3_t wishvel) ! 313: { ! 314: vec3_t v; ! 315: float s; ! 316: // ! 317: // account for ladders ! 318: // ! 319: if (pml.ladder && fabs(pml.velocity[2]) <= 200) ! 320: { ! 321: if ((pm->viewangles[PITCH] <= -15) && (pm->cmd.forwardmove > 0)) ! 322: wishvel[2] = 200; ! 323: else if ((pm->viewangles[PITCH] >= 15) && (pm->cmd.forwardmove > 0)) ! 324: wishvel[2] = -200; ! 325: else if (pm->cmd.upmove > 0) ! 326: wishvel[2] = 200; ! 327: else if (pm->cmd.upmove < 0) ! 328: wishvel[2] = -200; ! 329: else ! 330: wishvel[2] = 0; ! 331: // limit horizontal speed when on a ladder ! 332: if (wishvel[0] < -25) ! 333: wishvel[0] = -25; ! 334: else if (wishvel[0] > 25) ! 335: wishvel[0] = 25; ! 336: if (wishvel[1] < -25) ! 337: wishvel[1] = -25; ! 338: else if (wishvel[1] > 25) ! 339: wishvel[1] = 25; ! 340: } ! 341: // ! 342: // add water currents ! 343: // ! 344: if (pm->watertype & MASK_CURRENT) ! 345: { ! 346: VectorClear (v); ! 347: if (pm->watertype & CONTENTS_CURRENT_0) ! 348: v[0] += 1; ! 349: if (pm->watertype & CONTENTS_CURRENT_90) ! 350: v[1] += 1; ! 351: if (pm->watertype & CONTENTS_CURRENT_180) ! 352: v[0] -= 1; ! 353: if (pm->watertype & CONTENTS_CURRENT_270) ! 354: v[1] -= 1; ! 355: if (pm->watertype & CONTENTS_CURRENT_UP) ! 356: v[2] += 1; ! 357: if (pm->watertype & CONTENTS_CURRENT_DOWN) ! 358: v[2] -= 1; ! 359: s = pm_waterspeed; ! 360: if ((pm->waterlevel == 1) && (pm->groundentity)) ! 361: s /= 2; ! 362: VectorMA (wishvel, s, v, wishvel); ! 363: } ! 364: // ! 365: // add conveyor belt velocities ! 366: // ! 367: if (pm->groundentity) ! 368: { ! 369: VectorClear (v); ! 370: if (pml.groundcontents & CONTENTS_CURRENT_0) ! 371: v[0] += 1; ! 372: if (pml.groundcontents & CONTENTS_CURRENT_90) ! 373: v[1] += 1; ! 374: if (pml.groundcontents & CONTENTS_CURRENT_180) ! 375: v[0] -= 1; ! 376: if (pml.groundcontents & CONTENTS_CURRENT_270) ! 377: v[1] -= 1; ! 378: if (pml.groundcontents & CONTENTS_CURRENT_UP) ! 379: v[2] += 1; ! 380: if (pml.groundcontents & CONTENTS_CURRENT_DOWN) ! 381: v[2] -= 1; ! 382: ! 383: VectorMA (wishvel, 100 /* pm->groundentity->speed */, v, wishvel); ! 384: } ! 385: } ! 386: /* ! 387: =================== ! 388: PM_WaterMove ! 389: =================== ! 390: */ ! 391: void PM_WaterMove (void) ! 392: { ! 393: int i; ! 394: vec3_t wishvel; ! 395: float wishspeed; ! 396: vec3_t wishdir; ! 397: // ! 398: // user intentions ! 399: // ! 400: for (i=0 ; i<3 ; i++) ! 401: wishvel[i] = pml.forward[i]*pm->cmd.forwardmove + pml.right[i]*pm->cmd.sidemove; ! 402: if (!pm->cmd.forwardmove && !pm->cmd.sidemove && !pm->cmd.upmove) ! 403: wishvel[2] -= 60; // drift towards bottom ! 404: else ! 405: wishvel[2] += pm->cmd.upmove; ! 406: PM_AddCurrents (wishvel); ! 407: VectorCopy (wishvel, wishdir); ! 408: wishspeed = VectorNormalize(wishdir); ! 409: if (wishspeed > pm_maxspeed) ! 410: { ! 411: VectorScale (wishvel, pm_maxspeed/wishspeed, wishvel); ! 412: wishspeed = pm_maxspeed; ! 413: } ! 414: wishspeed *= 0.5; ! 415: PM_Accelerate (wishdir, wishspeed, pm_wateraccelerate); ! 416: PM_StepSlideMove (); ! 417: } ! 418: /* ! 419: =================== ! 420: PM_AirMove ! 421: =================== ! 422: */ ! 423: void PM_AirMove (void) ! 424: { ! 425: int i; ! 426: vec3_t wishvel; ! 427: float fmove, smove; ! 428: vec3_t wishdir; ! 429: float wishspeed; ! 430: float maxspeed; ! 431: fmove = pm->cmd.forwardmove; ! 432: smove = pm->cmd.sidemove; ! 433: ! 434: pml.forward[2] = 0; ! 435: pml.right[2] = 0; ! 436: VectorNormalize (pml.forward); ! 437: VectorNormalize (pml.right); ! 438: for (i=0 ; i<2 ; i++) ! 439: wishvel[i] = pml.forward[i]*fmove + pml.right[i]*smove; ! 440: wishvel[2] = 0; ! 441: PM_AddCurrents (wishvel); ! 442: VectorCopy (wishvel, wishdir); ! 443: wishspeed = VectorNormalize(wishdir); ! 444: // ! 445: // clamp to server defined max speed ! 446: // ! 447: maxspeed = (pm->s.pm_flags & PMF_DUCKED) ? pm_duckspeed : pm_maxspeed; ! 448: if (wishspeed > maxspeed) ! 449: { ! 450: VectorScale (wishvel, maxspeed/wishspeed, wishvel); ! 451: wishspeed = maxspeed; ! 452: } ! 453: ! 454: if ( pml.ladder ) ! 455: { ! 456: PM_Accelerate (wishdir, wishspeed, pm_accelerate); ! 457: if (!wishvel[2]) ! 458: { ! 459: if (pml.velocity[2] > 0) ! 460: { ! 461: pml.velocity[2] -= pm->s.gravity * pml.frametime; ! 462: if (pml.velocity[2] < 0) ! 463: pml.velocity[2] = 0; ! 464: } ! 465: else ! 466: { ! 467: pml.velocity[2] += pm->s.gravity * pml.frametime; ! 468: if (pml.velocity[2] > 0) ! 469: pml.velocity[2] = 0; ! 470: } ! 471: } ! 472: PM_StepSlideMove (); ! 473: } ! 474: else if ( pm->groundentity ) ! 475: { // walking on ground ! 476: PM_Accelerate (wishdir, wishspeed, pm_accelerate); ! 477: pml.velocity[2] = 0; ! 478: if (!pml.velocity[0] && !pml.velocity[1]) ! 479: return; ! 480: PM_StepSlideMove (); ! 481: } ! 482: else ! 483: { // not on ground, so little effect on velocity ! 484: PM_Accelerate (wishdir, wishspeed, pm_airaccelerate); ! 485: // add gravity ! 486: pml.velocity[2] -= pm->s.gravity * pml.frametime; ! 487: PM_StepSlideMove (); ! 488: } ! 489: } ! 490: /* ! 491: ============= ! 492: PM_CatagorizePosition ! 493: ============= ! 494: */ ! 495: void PM_CatagorizePosition (void) ! 496: { ! 497: vec3_t point; ! 498: int cont; ! 499: trace_t trace; ! 500: int sample1; ! 501: int sample2; ! 502: // if the player hull point one unit down is solid, the player ! 503: // is on ground ! 504: // see if standing on something solid ! 505: point[0] = pml.origin[0]; ! 506: point[1] = pml.origin[1]; ! 507: point[2] = pml.origin[2] - 0.25; ! 508: if (pml.velocity[2] > 100) ! 509: { ! 510: pm->s.pm_flags &= ~PMF_ON_GROUND; ! 511: pm->groundentity = NULL; ! 512: } ! 513: else ! 514: { ! 515: trace = pm->trace (pml.origin, pm->mins, pm->maxs, point); ! 516: pml.groundplane = trace.plane; ! 517: pml.groundsurface = trace.surface; ! 518: pml.groundcontents = trace.contents; ! 519: ! 520: if (!trace.ent || (trace.plane.normal[2] < 0.7 && !trace.startsolid) ) ! 521: { ! 522: pm->groundentity = NULL; ! 523: pm->s.pm_flags &= ~PMF_ON_GROUND; ! 524: } ! 525: else ! 526: { ! 527: pm->groundentity = trace.ent; ! 528: ! 529: // hitting solid ground will end a waterjump ! 530: if (pm->s.pm_flags & PMF_TIME_WATERJUMP) ! 531: { ! 532: pm->s.pm_flags &= ~(PMF_TIME_WATERJUMP | PMF_TIME_LAND | PMF_TIME_TELEPORT); ! 533: pm->s.pm_time = 0; ! 534: } ! 535: ! 536: if (! (pm->s.pm_flags & PMF_ON_GROUND) ) ! 537: { // just hit the ground ! 538: pm->s.pm_flags |= PMF_ON_GROUND; ! 539: // don't do landing time if we were just going down a slope ! 540: if (pml.velocity[2] < -200) ! 541: { ! 542: pm->s.pm_flags |= PMF_TIME_LAND; ! 543: // don't allow another jump for a little while ! 544: if (pml.velocity[2] < -400) ! 545: pm->s.pm_time = 25; ! 546: else ! 547: pm->s.pm_time = 18; ! 548: } ! 549: } ! 550: } ! 551: if (trace.fraction < 1.0 && trace.ent && pml.velocity[2] < 0) ! 552: pml.velocity[2] = 0; ! 553: ! 554: if (pm->numtouch < MAXTOUCH && trace.ent) ! 555: { ! 556: pm->touchents[pm->numtouch] = trace.ent; ! 557: pm->numtouch++; ! 558: } ! 559: } ! 560: // ! 561: // get waterlevel, accounting for ducking ! 562: // ! 563: pm->waterlevel = 0; ! 564: pm->watertype = 0; ! 565: sample2 = pm->viewheight - pm->mins[2]; ! 566: sample1 = sample2 / 2; ! 567: point[2] = pml.origin[2] + pm->mins[2] + 1; ! 568: cont = pm->pointcontents (point); ! 569: if (cont & MASK_WATER) ! 570: { ! 571: pm->watertype = cont; ! 572: pm->waterlevel = 1; ! 573: point[2] = pml.origin[2] + pm->mins[2] + sample1; ! 574: cont = pm->pointcontents (point); ! 575: if (cont & MASK_WATER) ! 576: { ! 577: pm->waterlevel = 2; ! 578: point[2] = pml.origin[2] + pm->mins[2] + sample2; ! 579: cont = pm->pointcontents (point); ! 580: if (cont & MASK_WATER) ! 581: pm->waterlevel = 3; ! 582: } ! 583: } ! 584: } ! 585: /* ! 586: ============= ! 587: PM_CheckJump ! 588: ============= ! 589: */ ! 590: void PM_CheckJump (void) ! 591: { ! 592: if (pm->s.pm_flags & PMF_TIME_LAND) ! 593: { // hasn't been long enough since landing to jump again ! 594: return; ! 595: } ! 596: if (pm->cmd.upmove < 10) ! 597: { // not holding jump ! 598: pm->s.pm_flags &= ~PMF_JUMP_HELD; ! 599: return; ! 600: } ! 601: ! 602: // must wait for jump to be released ! 603: if (pm->s.pm_flags & PMF_JUMP_HELD) ! 604: return; ! 605: ! 606: if (pm->s.pm_type == PM_DEAD) ! 607: return; ! 608: if (pm->waterlevel >= 2) ! 609: { // swimming, not jumping ! 610: pm->groundentity = NULL; ! 611: if (pml.velocity[2] <= -300) ! 612: return; ! 613: ! 614: if (pm->watertype == CONTENTS_WATER) ! 615: pml.velocity[2] = 100; ! 616: else if (pm->watertype == CONTENTS_SLIME) ! 617: pml.velocity[2] = 80; ! 618: else ! 619: pml.velocity[2] = 50; ! 620: return; ! 621: } ! 622: if (pm->groundentity == NULL) ! 623: return; // in air, so no effect ! 624: pm->s.pm_flags |= PMF_JUMP_HELD; ! 625: ! 626: pm->groundentity = NULL; ! 627: pml.velocity[2] = 270; ! 628: } ! 629: /* ! 630: ============= ! 631: PM_CheckSpecialMovement ! 632: ============= ! 633: */ ! 634: void PM_CheckSpecialMovement (void) ! 635: { ! 636: vec3_t spot; ! 637: int cont; ! 638: vec3_t flatforward; ! 639: trace_t trace; ! 640: ! 641: if (pm->s.pm_time) ! 642: return; ! 643: ! 644: pml.ladder = false; ! 645: // check for ladder ! 646: flatforward[0] = pml.forward[0]; ! 647: flatforward[1] = pml.forward[1]; ! 648: flatforward[2] = 0; ! 649: VectorNormalize (flatforward); ! 650: VectorMA (pml.origin, 1, flatforward, spot); ! 651: trace = pm->trace (pml.origin, pm->mins, pm->maxs, spot); ! 652: if ((trace.fraction < 1) && (trace.contents & CONTENTS_LADDER)) ! 653: pml.ladder = true; ! 654: // check for water jump ! 655: if (pm->waterlevel != 2) ! 656: return; ! 657: VectorMA (pml.origin, 30, flatforward, spot); ! 658: spot[2] += 4; ! 659: cont = pm->pointcontents (spot); ! 660: if (!(cont & CONTENTS_SOLID)) ! 661: return; ! 662: spot[2] += 16; ! 663: cont = pm->pointcontents (spot); ! 664: if (cont) ! 665: return; ! 666: // jump out of water ! 667: VectorScale (pml.forward, 200, pml.velocity); ! 668: pml.velocity[2] = 350; ! 669: ! 670: pm->s.pm_flags |= PMF_TIME_WATERJUMP; ! 671: pm->s.pm_time = 255; ! 672: } ! 673: /* ! 674: =============== ! 675: PM_NoclipMove ! 676: =============== ! 677: */ ! 678: void PM_NoclipMove (void) ! 679: { ! 680: float speed, drop, friction, control, newspeed; ! 681: float currentspeed, addspeed, accelspeed; ! 682: int i; ! 683: vec3_t wishvel; ! 684: float fmove, smove; ! 685: vec3_t wishdir; ! 686: float wishspeed; ! 687: ! 688: pm->viewheight = 22; ! 689: // friction ! 690: speed = VectorLength (pml.velocity); ! 691: if (speed < 1) ! 692: { ! 693: VectorCopy (vec3_origin, pml.velocity); ! 694: } ! 695: else ! 696: { ! 697: drop = 0; ! 698: friction = pm_friction*1.5; // extra friction ! 699: control = speed < pm_stopspeed ? pm_stopspeed : speed; ! 700: drop += control*friction*pml.frametime; ! 701: // scale the velocity ! 702: newspeed = speed - drop; ! 703: if (newspeed < 0) ! 704: newspeed = 0; ! 705: newspeed /= speed; ! 706: VectorScale (pml.velocity, newspeed, pml.velocity); ! 707: } ! 708: // accelerate ! 709: fmove = pm->cmd.forwardmove; ! 710: smove = pm->cmd.sidemove; ! 711: ! 712: VectorNormalize (pml.forward); ! 713: VectorNormalize (pml.right); ! 714: for (i=0 ; i<3 ; i++) ! 715: wishvel[i] = pml.forward[i]*fmove + pml.right[i]*smove; ! 716: wishvel[2] += pm->cmd.upmove; ! 717: VectorCopy (wishvel, wishdir); ! 718: wishspeed = VectorNormalize(wishdir); ! 719: // ! 720: // clamp to server defined max speed ! 721: // ! 722: if (wishspeed > pm_maxspeed) ! 723: { ! 724: VectorScale (wishvel, pm_maxspeed/wishspeed, wishvel); ! 725: wishspeed = pm_maxspeed; ! 726: } ! 727: currentspeed = DotProduct(pml.velocity, wishdir); ! 728: addspeed = wishspeed - currentspeed; ! 729: if (addspeed <= 0) ! 730: return; ! 731: accelspeed = pm_accelerate*pml.frametime*wishspeed; ! 732: if (accelspeed > addspeed) ! 733: accelspeed = addspeed; ! 734: ! 735: for (i=0 ; i<3 ; i++) ! 736: pml.velocity[i] += accelspeed*wishdir[i]; ! 737: // move ! 738: VectorMA (pml.origin, pml.frametime, pml.velocity, pml.origin); ! 739: } ! 740: /* ! 741: ============== ! 742: PM_CheckDuck ! 743: ! 744: Sets mins, maxs, and pm->viewheight ! 745: ============== ! 746: */ ! 747: void PM_CheckDuck (void) ! 748: { ! 749: trace_t trace; ! 750: ! 751: pm->mins[0] = -16; ! 752: pm->mins[1] = -16; ! 753: ! 754: pm->maxs[0] = 16; ! 755: pm->maxs[1] = 16; ! 756: if (pm->s.pm_type == PM_GIB) ! 757: { ! 758: pm->mins[2] = 0; ! 759: pm->maxs[2] = 16; ! 760: pm->viewheight = 8; ! 761: return; ! 762: } ! 763: ! 764: pm->mins[2] = -24; ! 765: ! 766: if (pm->s.pm_type == PM_DEAD) ! 767: { ! 768: pm->s.pm_flags |= PMF_DUCKED; ! 769: } ! 770: else if (pm->cmd.upmove < 0 && (pm->s.pm_flags & PMF_ON_GROUND) ) ! 771: { // duck ! 772: pm->s.pm_flags |= PMF_DUCKED; ! 773: } ! 774: else ! 775: { // stand up if possible ! 776: if (pm->s.pm_flags & PMF_DUCKED) ! 777: { ! 778: // try to stand up ! 779: pm->maxs[2] = 32; ! 780: trace = pm->trace (pml.origin, pm->mins, pm->maxs, pml.origin); ! 781: if (!trace.allsolid) ! 782: pm->s.pm_flags &= ~PMF_DUCKED; ! 783: } ! 784: } ! 785: ! 786: if (pm->s.pm_flags & PMF_DUCKED) ! 787: { ! 788: pm->maxs[2] = 4; ! 789: pm->viewheight = -2; ! 790: } ! 791: else ! 792: { ! 793: pm->maxs[2] = 32; ! 794: pm->viewheight = 22; ! 795: } ! 796: } ! 797: ! 798: /* ! 799: ============== ! 800: PM_DeadMove ! 801: ============== ! 802: */ ! 803: void PM_DeadMove (void) ! 804: { ! 805: float forward; ! 806: ! 807: if (!pm->groundentity) ! 808: return; ! 809: ! 810: // extra friction ! 811: ! 812: forward = VectorLength (pml.velocity); ! 813: forward -= 20; ! 814: if (forward <= 0) ! 815: { ! 816: VectorClear (pml.velocity); ! 817: } ! 818: else ! 819: { ! 820: VectorNormalize (pml.velocity); ! 821: VectorScale (pml.velocity, forward, pml.velocity); ! 822: } ! 823: } ! 824: ! 825: ! 826: qboolean PM_GoodPosition (void) ! 827: { ! 828: trace_t trace; ! 829: vec3_t origin, end; ! 830: int i; ! 831: ! 832: if (pm->s.pm_type == PM_SPECTATOR) ! 833: return true; ! 834: ! 835: for (i=0 ; i<3 ; i++) ! 836: origin[i] = end[i] = pm->s.origin[i]*0.125; ! 837: trace = pm->trace (origin, pm->mins, pm->maxs, end); ! 838: ! 839: return !trace.allsolid; ! 840: } ! 841: ! 842: /* ! 843: ================ ! 844: PM_SnapPosition ! 845: ! 846: On exit, the origin will have a value that is pre-quantized to the 0.125 ! 847: precision of the network channel and in a valid position. ! 848: ================ ! 849: */ ! 850: void PM_SnapPosition (void) ! 851: { ! 852: int sign[3]; ! 853: int i, j, bits; ! 854: short base[3]; ! 855: // try all single bits first ! 856: static int jitterbits[8] = {0,4,1,2,3,5,6,7}; ! 857: ! 858: // snap velocity to eigths ! 859: for (i=0 ; i<3 ; i++) ! 860: pm->s.velocity[i] = (int)(pml.velocity[i]*8); ! 861: ! 862: for (i=0 ; i<3 ; i++) ! 863: { ! 864: if (pml.origin[i] >= 0) ! 865: sign[i] = 1; ! 866: else ! 867: sign[i] = -1; ! 868: pm->s.origin[i] = (int)(pml.origin[i]*8); ! 869: if (pm->s.origin[i]*0.125 == pml.origin[i]) ! 870: sign[i] = 0; ! 871: } ! 872: VectorCopy (pm->s.origin, base); ! 873: ! 874: // try all combinations ! 875: for (j=0 ; j<8 ; j++) ! 876: { ! 877: bits = jitterbits[j]; ! 878: VectorCopy (base, pm->s.origin); ! 879: for (i=0 ; i<3 ; i++) ! 880: if (bits & (1<<i) ) ! 881: pm->s.origin[i] += sign[i]; ! 882: ! 883: if (PM_GoodPosition ()) ! 884: return; ! 885: } ! 886: ! 887: // go back to the last position ! 888: VectorCopy (pml.previous_origin, pm->s.origin); ! 889: // Com_DPrintf ("using previous_origin\n"); ! 890: } ! 891: ! 892: /* ! 893: ================ ! 894: PM_InitialSnapPosition ! 895: ! 896: ================ ! 897: */ ! 898: void PM_InitialSnapPosition (void) ! 899: { ! 900: int x, y, z; ! 901: short base[3]; ! 902: ! 903: VectorCopy (pm->s.origin, base); ! 904: ! 905: for (z=1 ; z>=-1 ; z--) ! 906: { ! 907: pm->s.origin[2] = base[2] + z; ! 908: for (y=1 ; y>=-1 ; y--) ! 909: { ! 910: pm->s.origin[1] = base[1] + y; ! 911: for (x=1 ; x>=-1 ; x--) ! 912: { ! 913: pm->s.origin[0] = base[0] + x; ! 914: if (PM_GoodPosition ()) ! 915: { ! 916: pml.origin[0] = pm->s.origin[0]*0.125; ! 917: pml.origin[1] = pm->s.origin[1]*0.125; ! 918: pml.origin[2] = pm->s.origin[2]*0.125; ! 919: VectorCopy (pm->s.origin, pml.previous_origin); ! 920: return; ! 921: } ! 922: } ! 923: } ! 924: } ! 925: ! 926: Com_DPrintf ("Bad InitialSnapPosition\n"); ! 927: } ! 928: ! 929: /* ! 930: ================ ! 931: PM_ClampAngles ! 932: ! 933: ================ ! 934: */ ! 935: void PM_ClampAngles (void) ! 936: { ! 937: short temp; ! 938: int i; ! 939: ! 940: if (pm->s.pm_flags & PMF_TIME_TELEPORT) ! 941: { ! 942: pm->viewangles[YAW] = SHORT2ANGLE(pm->cmd.angles[YAW] + pm->s.delta_angles[YAW]); ! 943: pm->viewangles[PITCH] = 0; ! 944: pm->viewangles[ROLL] = 0; ! 945: } ! 946: else ! 947: { ! 948: // circularly clamp the angles with deltas ! 949: for (i=0 ; i<3 ; i++) ! 950: { ! 951: temp = pm->cmd.angles[i] + pm->s.delta_angles[i]; ! 952: pm->viewangles[i] = SHORT2ANGLE(temp); ! 953: } ! 954: ! 955: // don't let the player look up or down more than 90 degrees ! 956: if (pm->viewangles[PITCH] > 89 && pm->viewangles[PITCH] < 180) ! 957: pm->viewangles[PITCH] = 89; ! 958: else if (pm->viewangles[PITCH] < 271 && pm->viewangles[PITCH] >= 180) ! 959: pm->viewangles[PITCH] = 271; ! 960: } ! 961: AngleVectors (pm->viewangles, pml.forward, pml.right, pml.up); ! 962: } ! 963: ! 964: /* ! 965: ================ ! 966: Pmove ! 967: ! 968: Can be called by either the server or the client ! 969: ================ ! 970: */ ! 971: void Pmove (pmove_t *pmove) ! 972: { ! 973: pm = pmove; ! 974: ! 975: // clear results ! 976: pm->numtouch = 0; ! 977: VectorClear (pm->viewangles); ! 978: pm->viewheight = 0; ! 979: pm->groundentity = 0; ! 980: pm->watertype = 0; ! 981: pm->waterlevel = 0; ! 982: ! 983: // clear all pmove local vars ! 984: memset (&pml, 0, sizeof(pml)); ! 985: ! 986: // convert origin and velocity to float values ! 987: pml.origin[0] = pm->s.origin[0]*0.125; ! 988: pml.origin[1] = pm->s.origin[1]*0.125; ! 989: pml.origin[2] = pm->s.origin[2]*0.125; ! 990: ! 991: pml.velocity[0] = pm->s.velocity[0]*0.125; ! 992: pml.velocity[1] = pm->s.velocity[1]*0.125; ! 993: pml.velocity[2] = pm->s.velocity[2]*0.125; ! 994: ! 995: // save old org in case we get stuck ! 996: VectorCopy (pm->s.origin, pml.previous_origin); ! 997: ! 998: pml.frametime = pm->cmd.msec * 0.001; ! 999: ! 1000: PM_ClampAngles (); ! 1001: ! 1002: if (pm->s.pm_type == PM_SPECTATOR) ! 1003: { ! 1004: PM_NoclipMove (); ! 1005: PM_SnapPosition (); ! 1006: return; ! 1007: } ! 1008: ! 1009: if (pm->s.pm_type >= PM_DEAD) ! 1010: { ! 1011: pm->cmd.forwardmove = 0; ! 1012: pm->cmd.sidemove = 0; ! 1013: pm->cmd.upmove = 0; ! 1014: } ! 1015: ! 1016: if (pm->s.pm_type == PM_FREEZE) ! 1017: return; // no movement at all ! 1018: ! 1019: // set mins, maxs, and viewheight ! 1020: PM_CheckDuck (); ! 1021: ! 1022: if (pm->snapinitial) ! 1023: PM_InitialSnapPosition (); ! 1024: ! 1025: // set groundentity, watertype, and waterlevel ! 1026: PM_CatagorizePosition (); ! 1027: ! 1028: if (pm->s.pm_type == PM_DEAD) ! 1029: PM_DeadMove (); ! 1030: ! 1031: PM_CheckSpecialMovement (); ! 1032: ! 1033: // drop timing counter ! 1034: if (pm->s.pm_time) ! 1035: { ! 1036: int msec; ! 1037: ! 1038: msec = pm->cmd.msec >> 3; ! 1039: if (!msec) ! 1040: msec = 1; ! 1041: if ( msec >= pm->s.pm_time) ! 1042: { ! 1043: pm->s.pm_flags &= ~(PMF_TIME_WATERJUMP | PMF_TIME_LAND | PMF_TIME_TELEPORT); ! 1044: pm->s.pm_time = 0; ! 1045: } ! 1046: else ! 1047: pm->s.pm_time -= msec; ! 1048: } ! 1049: ! 1050: if (pm->s.pm_flags & PMF_TIME_TELEPORT) ! 1051: { // teleport pause stays exactly in place ! 1052: } ! 1053: else if (pm->s.pm_flags & PMF_TIME_WATERJUMP) ! 1054: { // waterjump has no control, but falls ! 1055: pml.velocity[2] -= pm->s.gravity * pml.frametime; ! 1056: if (pml.velocity[2] < 0) ! 1057: { // cancel as soon as we are falling down again ! 1058: pm->s.pm_flags &= ~(PMF_TIME_WATERJUMP | PMF_TIME_LAND | PMF_TIME_TELEPORT); ! 1059: pm->s.pm_time = 0; ! 1060: } ! 1061: ! 1062: PM_StepSlideMove (); ! 1063: } ! 1064: else ! 1065: { ! 1066: PM_CheckJump (); ! 1067: ! 1068: PM_Friction (); ! 1069: ! 1070: if (pm->waterlevel >= 2) ! 1071: PM_WaterMove (); ! 1072: else ! 1073: PM_AirMove (); ! 1074: } ! 1075: ! 1076: // set groundentity, watertype, and waterlevel for final spot ! 1077: PM_CatagorizePosition (); ! 1078: ! 1079: PM_SnapPosition (); ! 1080: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.