![[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] / quakeworld / client|
Return to pmove.c CVS log | Up to [Quake] / quakeworld / client |
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:
21: #include "quakedef.h"
22:
23:
24: movevars_t movevars;
25:
26: playermove_t pmove;
27:
28: int onground;
29: int waterlevel;
30: int watertype;
31:
32: float frametime;
33:
34: vec3_t forward, right, up;
35:
36: vec3_t player_mins = {-16, -16, -24};
37: vec3_t player_maxs = {16, 16, 32};
38:
39: // #define PM_GRAVITY 800
40: // #define PM_STOPSPEED 100
41: // #define PM_MAXSPEED 320
42: // #define PM_SPECTATORMAXSPEED 500
43: // #define PM_ACCELERATE 10
44: // #define PM_AIRACCELERATE 0.7
45: // #define PM_WATERACCELERATE 10
46: // #define PM_FRICTION 6
47: // #define PM_WATERFRICTION 1
48:
49: void PM_InitBoxHull (void);
50:
51: void Pmove_Init (void)
52: {
53: PM_InitBoxHull ();
54: }
55:
56: #define STEPSIZE 18
57:
58:
59: #define BUTTON_JUMP 2
60:
61:
62: /*
63: ==================
64: PM_ClipVelocity
65:
66: Slide off of the impacting object
67: returns the blocked flags (1 = floor, 2 = step / wall)
68: ==================
69: */
70: #define STOP_EPSILON 0.1
71:
72: int PM_ClipVelocity (vec3_t in, vec3_t normal, vec3_t out, float overbounce)
73: {
74: float backoff;
75: float change;
76: int i, blocked;
77:
78: blocked = 0;
79: if (normal[2] > 0)
80: blocked |= 1; // floor
81: if (!normal[2])
82: blocked |= 2; // step
83:
84: backoff = DotProduct (in, normal) * overbounce;
85:
86: for (i=0 ; i<3 ; i++)
87: {
88: change = normal[i]*backoff;
89: out[i] = in[i] - change;
90: if (out[i] > -STOP_EPSILON && out[i] < STOP_EPSILON)
91: out[i] = 0;
92: }
93:
94: return blocked;
95: }
96:
97:
98: /*
99: ============
100: PM_FlyMove
101:
102: The basic solid body movement clip that slides along multiple planes
103: ============
104: */
105: #define MAX_CLIP_PLANES 5
106:
107: int PM_FlyMove (void)
108: {
109: int bumpcount, numbumps;
110: vec3_t dir;
111: float d;
112: int numplanes;
113: vec3_t planes[MAX_CLIP_PLANES];
114: vec3_t primal_velocity, original_velocity;
115: int i, j;
116: pmtrace_t trace;
117: vec3_t end;
118: float time_left;
119: int blocked;
120:
121: numbumps = 4;
122:
123: blocked = 0;
124: VectorCopy (pmove.velocity, original_velocity);
125: VectorCopy (pmove.velocity, primal_velocity);
126: numplanes = 0;
127:
128: time_left = frametime;
129:
130: for (bumpcount=0 ; bumpcount<numbumps ; bumpcount++)
131: {
132: for (i=0 ; i<3 ; i++)
133: end[i] = pmove.origin[i] + time_left * pmove.velocity[i];
134:
135: trace = PM_PlayerMove (pmove.origin, end);
136:
137: if (trace.startsolid || trace.allsolid)
138: { // entity is trapped in another solid
139: VectorCopy (vec3_origin, pmove.velocity);
140: return 3;
141: }
142:
143: if (trace.fraction > 0)
144: { // actually covered some distance
145: VectorCopy (trace.endpos, pmove.origin);
146: numplanes = 0;
147: }
148:
149: if (trace.fraction == 1)
150: break; // moved the entire distance
151:
152: // save entity for contact
153: pmove.touchindex[pmove.numtouch] = trace.ent;
154: pmove.numtouch++;
155:
156: if (trace.plane.normal[2] > 0.7)
157: {
158: blocked |= 1; // floor
159: }
160: if (!trace.plane.normal[2])
161: {
162: blocked |= 2; // step
163: }
164:
165: time_left -= time_left * trace.fraction;
166:
167: // cliped to another plane
168: if (numplanes >= MAX_CLIP_PLANES)
169: { // this shouldn't really happen
170: VectorCopy (vec3_origin, pmove.velocity);
171: break;
172: }
173:
174: VectorCopy (trace.plane.normal, planes[numplanes]);
175: numplanes++;
176:
177: //
178: // modify original_velocity so it parallels all of the clip planes
179: //
180: for (i=0 ; i<numplanes ; i++)
181: {
182: PM_ClipVelocity (original_velocity, planes[i], pmove.velocity, 1);
183: for (j=0 ; j<numplanes ; j++)
184: if (j != i)
185: {
186: if (DotProduct (pmove.velocity, planes[j]) < 0)
187: break; // not ok
188: }
189: if (j == numplanes)
190: break;
191: }
192:
193: if (i != numplanes)
194: { // go along this plane
195: }
196: else
197: { // go along the crease
198: if (numplanes != 2)
199: {
200: // Con_Printf ("clip velocity, numplanes == %i\n",numplanes);
201: VectorCopy (vec3_origin, pmove.velocity);
202: break;
203: }
204: CrossProduct (planes[0], planes[1], dir);
205: d = DotProduct (dir, pmove.velocity);
206: VectorScale (dir, d, pmove.velocity);
207: }
208:
209: //
210: // if original velocity is against the original velocity, stop dead
211: // to avoid tiny occilations in sloping corners
212: //
213: if (DotProduct (pmove.velocity, primal_velocity) <= 0)
214: {
215: VectorCopy (vec3_origin, pmove.velocity);
216: break;
217: }
218: }
219:
220: if (pmove.waterjumptime)
221: {
222: VectorCopy (primal_velocity, pmove.velocity);
223: }
224: return blocked;
225: }
226:
227: /*
228: =============
229: PM_GroundMove
230:
231: Player is on ground, with no upwards velocity
232: =============
233: */
234: void PM_GroundMove (void)
235: {
236: vec3_t start, dest;
237: pmtrace_t trace;
238: vec3_t original, originalvel, down, up, downvel;
239: float downdist, updist;
240:
241: pmove.velocity[2] = 0;
242: if (!pmove.velocity[0] && !pmove.velocity[1] && !pmove.velocity[2])
243: return;
244:
245: // first try just moving to the destination
246: dest[0] = pmove.origin[0] + pmove.velocity[0]*frametime;
247: dest[1] = pmove.origin[1] + pmove.velocity[1]*frametime;
248: dest[2] = pmove.origin[2];
249:
250: // first try moving directly to the next spot
251: VectorCopy (dest, start);
252: trace = PM_PlayerMove (pmove.origin, dest);
253: if (trace.fraction == 1)
254: {
255: VectorCopy (trace.endpos, pmove.origin);
256: return;
257: }
258:
259: // try sliding forward both on ground and up 16 pixels
260: // take the move that goes farthest
261: VectorCopy (pmove.origin, original);
262: VectorCopy (pmove.velocity, originalvel);
263:
264: // slide move
265: PM_FlyMove ();
266:
267: VectorCopy (pmove.origin, down);
268: VectorCopy (pmove.velocity, downvel);
269:
270: VectorCopy (original, pmove.origin);
271: VectorCopy (originalvel, pmove.velocity);
272:
273: // move up a stair height
274: VectorCopy (pmove.origin, dest);
275: dest[2] += STEPSIZE;
276: trace = PM_PlayerMove (pmove.origin, dest);
277: if (!trace.startsolid && !trace.allsolid)
278: {
279: VectorCopy (trace.endpos, pmove.origin);
280: }
281:
282: // slide move
283: PM_FlyMove ();
284:
285: // press down the stepheight
286: VectorCopy (pmove.origin, dest);
287: dest[2] -= STEPSIZE;
288: trace = PM_PlayerMove (pmove.origin, dest);
289: if ( trace.plane.normal[2] < 0.7)
290: goto usedown;
291: if (!trace.startsolid && !trace.allsolid)
292: {
293: VectorCopy (trace.endpos, pmove.origin);
294: }
295: VectorCopy (pmove.origin, up);
296:
297: // decide which one went farther
298: downdist = (down[0] - original[0])*(down[0] - original[0])
299: + (down[1] - original[1])*(down[1] - original[1]);
300: updist = (up[0] - original[0])*(up[0] - original[0])
301: + (up[1] - original[1])*(up[1] - original[1]);
302:
303: if (downdist > updist)
304: {
305: usedown:
306: VectorCopy (down, pmove.origin);
307: VectorCopy (downvel, pmove.velocity);
308: } else // copy z value from slide move
309: pmove.velocity[2] = downvel[2];
310:
311: // if at a dead stop, retry the move with nudges to get around lips
312:
313: }
314:
315:
316:
317: /*
318: ==================
319: PM_Friction
320:
321: Handles both ground friction and water friction
322: ==================
323: */
324: void PM_Friction (void)
325: {
326: float *vel;
327: float speed, newspeed, control;
328: float friction;
329: float drop;
330: vec3_t start, stop;
331: pmtrace_t trace;
332:
333: if (pmove.waterjumptime)
334: return;
335:
336: vel = pmove.velocity;
337:
338: speed = sqrt(vel[0]*vel[0] +vel[1]*vel[1] + vel[2]*vel[2]);
339: if (speed < 1)
340: {
341: vel[0] = 0;
342: vel[1] = 0;
343: return;
344: }
345:
346: friction = movevars.friction;
347:
348: // if the leading edge is over a dropoff, increase friction
349: if (onground != -1) {
350: start[0] = stop[0] = pmove.origin[0] + vel[0]/speed*16;
351: start[1] = stop[1] = pmove.origin[1] + vel[1]/speed*16;
352: start[2] = pmove.origin[2] + player_mins[2];
353: stop[2] = start[2] - 34;
354:
355: trace = PM_PlayerMove (start, stop);
356:
357: if (trace.fraction == 1) {
358: friction *= 2;
359: }
360: }
361:
362: drop = 0;
363:
364: if (waterlevel >= 2) // apply water friction
365: drop += speed*movevars.waterfriction*waterlevel*frametime;
366: else if (onground != -1) // apply ground friction
367: {
368: control = speed < movevars.stopspeed ? movevars.stopspeed : speed;
369: drop += control*friction*frametime;
370: }
371:
372:
373: // scale the velocity
374: newspeed = speed - drop;
375: if (newspeed < 0)
376: newspeed = 0;
377: newspeed /= speed;
378:
379: vel[0] = vel[0] * newspeed;
380: vel[1] = vel[1] * newspeed;
381: vel[2] = vel[2] * newspeed;
382: }
383:
384:
385: /*
386: ==============
387: PM_Accelerate
388: ==============
389: */
390: void PM_Accelerate (vec3_t wishdir, float wishspeed, float accel)
391: {
392: int i;
393: float addspeed, accelspeed, currentspeed;
394:
395: if (pmove.dead)
396: return;
397: if (pmove.waterjumptime)
398: return;
399:
400: currentspeed = DotProduct (pmove.velocity, wishdir);
401: addspeed = wishspeed - currentspeed;
402: if (addspeed <= 0)
403: return;
404: accelspeed = accel*frametime*wishspeed;
405: if (accelspeed > addspeed)
406: accelspeed = addspeed;
407:
408: for (i=0 ; i<3 ; i++)
409: pmove.velocity[i] += accelspeed*wishdir[i];
410: }
411:
412: void PM_AirAccelerate (vec3_t wishdir, float wishspeed, float accel)
413: {
414: int i;
415: float addspeed, accelspeed, currentspeed, wishspd = wishspeed;
416:
417: if (pmove.dead)
418: return;
419: if (pmove.waterjumptime)
420: return;
421:
422: if (wishspd > 30)
423: wishspd = 30;
424: currentspeed = DotProduct (pmove.velocity, wishdir);
425: addspeed = wishspd - currentspeed;
426: if (addspeed <= 0)
427: return;
428: accelspeed = accel * wishspeed * frametime;
429: if (accelspeed > addspeed)
430: accelspeed = addspeed;
431:
432: for (i=0 ; i<3 ; i++)
433: pmove.velocity[i] += accelspeed*wishdir[i];
434: }
435:
436:
437:
438: /*
439: ===================
440: PM_WaterMove
441:
442: ===================
443: */
444: void PM_WaterMove (void)
445: {
446: int i;
447: vec3_t wishvel;
448: float wishspeed;
449: vec3_t wishdir;
450: vec3_t start, dest;
451: pmtrace_t trace;
452:
453: //
454: // user intentions
455: //
456: for (i=0 ; i<3 ; i++)
457: wishvel[i] = forward[i]*pmove.cmd.forwardmove + right[i]*pmove.cmd.sidemove;
458:
459: if (!pmove.cmd.forwardmove && !pmove.cmd.sidemove && !pmove.cmd.upmove)
460: wishvel[2] -= 60; // drift towards bottom
461: else
462: wishvel[2] += pmove.cmd.upmove;
463:
464: VectorCopy (wishvel, wishdir);
465: wishspeed = VectorNormalize(wishdir);
466:
467: if (wishspeed > movevars.maxspeed)
468: {
469: VectorScale (wishvel, movevars.maxspeed/wishspeed, wishvel);
470: wishspeed = movevars.maxspeed;
471: }
472: wishspeed *= 0.7;
473:
474: //
475: // water acceleration
476: //
477: // if (pmove.waterjumptime)
478: // Con_Printf ("wm->%f, %f, %f\n", pmove.velocity[0], pmove.velocity[1], pmove.velocity[2]);
479: PM_Accelerate (wishdir, wishspeed, movevars.wateraccelerate);
480:
481: // assume it is a stair or a slope, so press down from stepheight above
482: VectorMA (pmove.origin, frametime, pmove.velocity, dest);
483: VectorCopy (dest, start);
484: start[2] += STEPSIZE + 1;
485: trace = PM_PlayerMove (start, dest);
486: if (!trace.startsolid && !trace.allsolid) // FIXME: check steep slope?
487: { // walked up the step
488: VectorCopy (trace.endpos, pmove.origin);
489: return;
490: }
491:
492: PM_FlyMove ();
493: // if (pmove.waterjumptime)
494: // Con_Printf ("<-wm%f, %f, %f\n", pmove.velocity[0], pmove.velocity[1], pmove.velocity[2]);
495: }
496:
497:
498: /*
499: ===================
500: PM_AirMove
501:
502: ===================
503: */
504: void PM_AirMove (void)
505: {
506: int i;
507: vec3_t wishvel;
508: float fmove, smove;
509: vec3_t wishdir;
510: float wishspeed;
511:
512: fmove = pmove.cmd.forwardmove;
513: smove = pmove.cmd.sidemove;
514:
515: forward[2] = 0;
516: right[2] = 0;
517: VectorNormalize (forward);
518: VectorNormalize (right);
519:
520: for (i=0 ; i<2 ; i++)
521: wishvel[i] = forward[i]*fmove + right[i]*smove;
522: wishvel[2] = 0;
523:
524: VectorCopy (wishvel, wishdir);
525: wishspeed = VectorNormalize(wishdir);
526:
527: //
528: // clamp to server defined max speed
529: //
530: if (wishspeed > movevars.maxspeed)
531: {
532: VectorScale (wishvel, movevars.maxspeed/wishspeed, wishvel);
533: wishspeed = movevars.maxspeed;
534: }
535:
536: // if (pmove.waterjumptime)
537: // Con_Printf ("am->%f, %f, %f\n", pmove.velocity[0], pmove.velocity[1], pmove.velocity[2]);
538:
539: if ( onground != -1)
540: {
541: pmove.velocity[2] = 0;
542: PM_Accelerate (wishdir, wishspeed, movevars.accelerate);
543: pmove.velocity[2] -= movevars.entgravity * movevars.gravity * frametime;
544: PM_GroundMove ();
545: }
546: else
547: { // not on ground, so little effect on velocity
548: PM_AirAccelerate (wishdir, wishspeed, movevars.accelerate);
549:
550: // add gravity
551: pmove.velocity[2] -= movevars.entgravity * movevars.gravity * frametime;
552:
553: PM_FlyMove ();
554:
555: }
556:
557: //Con_Printf("airmove:vec: %4.2f %4.2f %4.2f\n",
558: // pmove.velocity[0],
559: // pmove.velocity[1],
560: // pmove.velocity[2]);
561: //
562:
563: // if (pmove.waterjumptime)
564: // Con_Printf ("<-am%f, %f, %f\n", pmove.velocity[0], pmove.velocity[1], pmove.velocity[2]);
565: }
566:
567:
568:
569: /*
570: =============
571: PM_CatagorizePosition
572: =============
573: */
574: void PM_CatagorizePosition (void)
575: {
576: vec3_t point;
577: int cont;
578: pmtrace_t tr;
579:
580: // if the player hull point one unit down is solid, the player
581: // is on ground
582:
583: // see if standing on something solid
584: point[0] = pmove.origin[0];
585: point[1] = pmove.origin[1];
586: point[2] = pmove.origin[2] - 1;
587: if (pmove.velocity[2] > 180)
588: {
589: onground = -1;
590: }
591: else
592: {
593: tr = PM_PlayerMove (pmove.origin, point);
594: if ( tr.plane.normal[2] < 0.7)
595: onground = -1; // too steep
596: else
597: onground = tr.ent;
598: if (onground != -1)
599: {
600: pmove.waterjumptime = 0;
601: if (!tr.startsolid && !tr.allsolid)
602: VectorCopy (tr.endpos, pmove.origin);
603: }
604:
605: // standing on an entity other than the world
606: if (tr.ent > 0)
607: {
608: pmove.touchindex[pmove.numtouch] = tr.ent;
609: pmove.numtouch++;
610: }
611: }
612:
613: //
614: // get waterlevel
615: //
616: waterlevel = 0;
617: watertype = CONTENTS_EMPTY;
618:
619: point[2] = pmove.origin[2] + player_mins[2] + 1;
620: cont = PM_PointContents (point);
621:
622: if (cont <= CONTENTS_WATER)
623: {
624: watertype = cont;
625: waterlevel = 1;
626: point[2] = pmove.origin[2] + (player_mins[2] + player_maxs[2])*0.5;
627: cont = PM_PointContents (point);
628: if (cont <= CONTENTS_WATER)
629: {
630: waterlevel = 2;
631: point[2] = pmove.origin[2] + 22;
632: cont = PM_PointContents (point);
633: if (cont <= CONTENTS_WATER)
634: waterlevel = 3;
635: }
636: }
637: }
638:
639:
640: /*
641: =============
642: JumpButton
643: =============
644: */
645: void JumpButton (void)
646: {
647: if (pmove.dead)
648: {
649: pmove.oldbuttons |= BUTTON_JUMP; // don't jump again until released
650: return;
651: }
652:
653: if (pmove.waterjumptime)
654: {
655: pmove.waterjumptime -= frametime;
656: if (pmove.waterjumptime < 0)
657: pmove.waterjumptime = 0;
658: return;
659: }
660:
661: if (waterlevel >= 2)
662: { // swimming, not jumping
663: onground = -1;
664:
665: if (watertype == CONTENTS_WATER)
666: pmove.velocity[2] = 100;
667: else if (watertype == CONTENTS_SLIME)
668: pmove.velocity[2] = 80;
669: else
670: pmove.velocity[2] = 50;
671: return;
672: }
673:
674: if (onground == -1)
675: return; // in air, so no effect
676:
677: if ( pmove.oldbuttons & BUTTON_JUMP )
678: return; // don't pogo stick
679:
680: onground = -1;
681: pmove.velocity[2] += 270;
682:
683: pmove.oldbuttons |= BUTTON_JUMP; // don't jump again until released
684: }
685:
686: /*
687: =============
688: CheckWaterJump
689: =============
690: */
691: void CheckWaterJump (void)
692: {
693: vec3_t spot;
694: int cont;
695: vec3_t flatforward;
696:
697: if (pmove.waterjumptime)
698: return;
699:
700: // ZOID, don't hop out if we just jumped in
701: if (pmove.velocity[2] < -180)
702: return; // only hop out if we are moving up
703:
704: // see if near an edge
705: flatforward[0] = forward[0];
706: flatforward[1] = forward[1];
707: flatforward[2] = 0;
708: VectorNormalize (flatforward);
709:
710: VectorMA (pmove.origin, 24, flatforward, spot);
711: spot[2] += 8;
712: cont = PM_PointContents (spot);
713: if (cont != CONTENTS_SOLID)
714: return;
715: spot[2] += 24;
716: cont = PM_PointContents (spot);
717: if (cont != CONTENTS_EMPTY)
718: return;
719: // jump out of water
720: VectorScale (flatforward, 50, pmove.velocity);
721: pmove.velocity[2] = 310;
722: pmove.waterjumptime = 2; // safety net
723: pmove.oldbuttons |= BUTTON_JUMP; // don't jump again until released
724: }
725:
726: /*
727: =================
728: NudgePosition
729:
730: If pmove.origin is in a solid position,
731: try nudging slightly on all axis to
732: allow for the cut precision of the net coordinates
733: =================
734: */
735: void NudgePosition (void)
736: {
737: vec3_t base;
738: int x, y, z;
739: int i;
740: static int sign[3] = {0, -1, 1};
741:
742: VectorCopy (pmove.origin, base);
743:
744: for (i=0 ; i<3 ; i++)
745: pmove.origin[i] = ((int)(pmove.origin[i]*8)) * 0.125;
746: // pmove.origin[2] += 0.124;
747:
748: // if (pmove.dead)
749: // return; // might be a squished point, so don'y bother
750: // if (PM_TestPlayerPosition (pmove.origin) )
751: // return;
752:
753: for (z=0 ; z<=2 ; z++)
754: {
755: for (x=0 ; x<=2 ; x++)
756: {
757: for (y=0 ; y<=2 ; y++)
758: {
759: pmove.origin[0] = base[0] + (sign[x] * 1.0/8);
760: pmove.origin[1] = base[1] + (sign[y] * 1.0/8);
761: pmove.origin[2] = base[2] + (sign[z] * 1.0/8);
762: if (PM_TestPlayerPosition (pmove.origin))
763: return;
764: }
765: }
766: }
767: VectorCopy (base, pmove.origin);
768: // Con_DPrintf ("NudgePosition: stuck\n");
769: }
770:
771: /*
772: ===============
773: SpectatorMove
774: ===============
775: */
776: void SpectatorMove (void)
777: {
778: float speed, drop, friction, control, newspeed, accel;
779: float currentspeed, addspeed, accelspeed;
780: int i;
781: vec3_t wishvel;
782: float fmove, smove;
783: vec3_t wishdir;
784: float wishspeed;
785: #ifndef SERVERONLY
786: extern float server_version; // version of server we connected to
787: #endif
788:
789: // friction
790:
791: speed = Length (pmove.velocity);
792: if (speed < 1)
793: {
794: VectorCopy (vec3_origin, pmove.velocity)
795: }
796: else
797: {
798: drop = 0;
799:
800: friction = movevars.friction*1.5; // extra friction
801: control = speed < movevars.stopspeed ? movevars.stopspeed : speed;
802: drop += control*friction*frametime;
803:
804: // scale the velocity
805: newspeed = speed - drop;
806: if (newspeed < 0)
807: newspeed = 0;
808: newspeed /= speed;
809:
810: VectorScale (pmove.velocity, newspeed, pmove.velocity);
811: }
812:
813: // accelerate
814: fmove = pmove.cmd.forwardmove;
815: smove = pmove.cmd.sidemove;
816:
817: VectorNormalize (forward);
818: VectorNormalize (right);
819:
820: for (i=0 ; i<3 ; i++)
821: wishvel[i] = forward[i]*fmove + right[i]*smove;
822: wishvel[2] += pmove.cmd.upmove;
823:
824: VectorCopy (wishvel, wishdir);
825: wishspeed = VectorNormalize(wishdir);
826:
827: //
828: // clamp to server defined max speed
829: //
830: if (wishspeed > movevars.spectatormaxspeed)
831: {
832: VectorScale (wishvel, movevars.spectatormaxspeed/wishspeed, wishvel);
833: wishspeed = movevars.spectatormaxspeed;
834: }
835:
836: currentspeed = DotProduct(pmove.velocity, wishdir);
837: addspeed = wishspeed - currentspeed;
838: if (addspeed <= 0)
839: return;
840: accelspeed = movevars.accelerate*frametime*wishspeed;
841: if (accelspeed > addspeed)
842: accelspeed = addspeed;
843:
844: for (i=0 ; i<3 ; i++)
845: pmove.velocity[i] += accelspeed*wishdir[i];
846:
847:
848: // move
849: VectorMA (pmove.origin, frametime, pmove.velocity, pmove.origin);
850: }
851:
852: /*
853: =============
854: PlayerMove
855:
856: Returns with origin, angles, and velocity modified in place.
857:
858: Numtouch and touchindex[] will be set if any of the physents
859: were contacted during the move.
860: =============
861: */
862: void PlayerMove (void)
863: {
864: frametime = pmove.cmd.msec * 0.001;
865: pmove.numtouch = 0;
866:
867: AngleVectors (pmove.angles, forward, right, up);
868:
869: if (pmove.spectator)
870: {
871: SpectatorMove ();
872: return;
873: }
874:
875: NudgePosition ();
876:
877: // take angles directly from command
878: VectorCopy (pmove.cmd.angles, pmove.angles);
879:
880: // set onground, watertype, and waterlevel
881: PM_CatagorizePosition ();
882:
883: if (waterlevel == 2)
884: CheckWaterJump ();
885:
886: if (pmove.velocity[2] < 0)
887: pmove.waterjumptime = 0;
888:
889: if (pmove.cmd.buttons & BUTTON_JUMP)
890: JumpButton ();
891: else
892: pmove.oldbuttons &= ~BUTTON_JUMP;
893:
894: PM_Friction ();
895:
896: if (waterlevel >= 2)
897: PM_WaterMove ();
898: else
899: PM_AirMove ();
900:
901: // set onground, watertype, and waterlevel for final spot
902: PM_CatagorizePosition ();
903: }
904:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.