![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to sv_user.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Quake] / quake1|
Return to sv_user.c CVS log | Up to [Quake] / quake1 |
1.1 root 1: // sv_user.c -- server code for moving users
2:
3: #include "quakedef.h"
4:
5: edict_t *sv_player;
6:
7: extern cvar_t sv_friction;
8: cvar_t sv_edgefriction = {"edgefriction", "2"};
9: extern cvar_t sv_stopspeed;
10:
11: static vec3_t forward, right, up;
12:
13: vec3_t wishdir;
14: float wishspeed;
15:
16: // world
17: float *angles;
18: float *origin;
19: float *velocity;
20:
21: qboolean onground;
22:
23: usercmd_t cmd;
24:
25: cvar_t sv_idealpitchscale = {"sv_idealpitchscale","0.8"};
26:
27:
28: /*
29: ===============
30: SV_SetIdealPitch
31: ===============
32: */
33: #define MAX_FORWARD 6
34: void SV_SetIdealPitch (void)
35: {
36: float angleval, sinval, cosval;
37: trace_t tr;
38: vec3_t top, bottom;
39: float z[MAX_FORWARD];
40: int i, j;
41: int step, dir, steps;
42:
43: if (!((int)sv_player->v.flags & FL_ONGROUND))
44: return;
45:
46: angleval = sv_player->v.angles[YAW] * M_PI*2 / 360;
47: sinval = sin(angleval);
48: cosval = cos(angleval);
49:
50: for (i=0 ; i<MAX_FORWARD ; i++)
51: {
52: top[0] = sv_player->v.origin[0] + cosval*(i+3)*12;
53: top[1] = sv_player->v.origin[1] + sinval*(i+3)*12;
54: top[2] = sv_player->v.origin[2] + sv_player->v.view_ofs[2];
55:
56: bottom[0] = top[0];
57: bottom[1] = top[1];
58: bottom[2] = top[2] - 160;
59:
60: tr = SV_Move (top, vec3_origin, vec3_origin, bottom, 1, sv_player);
61: if (tr.allsolid)
62: return; // looking at a wall, leave ideal the way is was
63:
64: if (tr.fraction == 1)
65: return; // near a dropoff
66:
67: z[i] = top[2] + tr.fraction*(bottom[2]-top[2]);
68: }
69:
70: dir = 0;
71: steps = 0;
72: for (j=1 ; j<i ; j++)
73: {
74: step = z[j] - z[j-1];
75: if (step > -ON_EPSILON && step < ON_EPSILON)
76: continue;
77:
78: if (dir && ( step-dir > ON_EPSILON || step-dir < -ON_EPSILON ) )
79: return; // mixed changes
80:
81: steps++;
82: dir = step;
83: }
84:
85: if (!dir)
86: {
87: sv_player->v.idealpitch = 0;
88: return;
89: }
90:
91: if (steps < 2)
92: return;
93: sv_player->v.idealpitch = -dir * sv_idealpitchscale.value;
94: }
95:
96:
97: /*
98: ==================
99: SV_UserFriction
100:
101: ==================
102: */
103: void SV_UserFriction (void)
104: {
105: float *vel;
106: float speed, newspeed, control;
107: vec3_t start, stop;
108: float friction;
109: trace_t trace;
110:
111: vel = velocity;
112:
113: speed = sqrt(vel[0]*vel[0] +vel[1]*vel[1]);
114: if (!speed)
115: return;
116:
117: // if the leading edge is over a dropoff, increase friction
118: start[0] = stop[0] = origin[0] + vel[0]/speed*16;
119: start[1] = stop[1] = origin[1] + vel[1]/speed*16;
120: start[2] = origin[2] + sv_player->v.mins[2];
121: stop[2] = start[2] - 34;
122:
123: trace = SV_Move (start, vec3_origin, vec3_origin, stop, true, sv_player);
124:
125: if (trace.fraction == 1.0)
126: friction = sv_friction.value*sv_edgefriction.value;
127: else
128: friction = sv_friction.value;
129:
130: // apply friction
131: control = speed < sv_stopspeed.value ? sv_stopspeed.value : speed;
132: newspeed = speed - host_frametime*control*friction;
133:
134: if (newspeed < 0)
135: newspeed = 0;
136: newspeed /= speed;
137:
138: vel[0] = vel[0] * newspeed;
139: vel[1] = vel[1] * newspeed;
140: vel[2] = vel[2] * newspeed;
141: }
142:
143: /*
144: ==============
145: SV_Accelerate
146: ==============
147: */
148: cvar_t sv_maxspeed = {"sv_maxspeed", "320", false, true};
149: cvar_t sv_accelerate = {"sv_accelerate", "10"};
150: #if 0
151: void SV_Accelerate (vec3_t wishvel)
152: {
153: int i;
154: float addspeed, accelspeed;
155: vec3_t pushvec;
156:
157: if (wishspeed == 0)
158: return;
159:
160: VectorSubtract (wishvel, velocity, pushvec);
161: addspeed = VectorNormalize (pushvec);
162:
163: accelspeed = sv_accelerate.value*host_frametime*addspeed;
164: if (accelspeed > addspeed)
165: accelspeed = addspeed;
166:
167: for (i=0 ; i<3 ; i++)
168: velocity[i] += accelspeed*pushvec[i];
169: }
170: #endif
171: void SV_Accelerate (void)
172: {
173: int i;
174: float addspeed, accelspeed, currentspeed;
175:
176: currentspeed = DotProduct (velocity, wishdir);
177: addspeed = wishspeed - currentspeed;
178: if (addspeed <= 0)
179: return;
180: accelspeed = sv_accelerate.value*host_frametime*wishspeed;
181: if (accelspeed > addspeed)
182: accelspeed = addspeed;
183:
184: for (i=0 ; i<3 ; i++)
185: velocity[i] += accelspeed*wishdir[i];
186: }
187:
188: void SV_AirAccelerate (vec3_t wishveloc)
189: {
190: int i;
191: float addspeed, wishspd, accelspeed, currentspeed;
192:
193: wishspd = VectorNormalize (wishveloc);
194: if (wishspd > 30)
195: wishspd = 30;
196: currentspeed = DotProduct (velocity, wishveloc);
197: addspeed = wishspd - currentspeed;
198: if (addspeed <= 0)
199: return;
200: // accelspeed = sv_accelerate.value * host_frametime;
201: accelspeed = sv_accelerate.value*wishspeed * host_frametime;
202: if (accelspeed > addspeed)
203: accelspeed = addspeed;
204:
205: for (i=0 ; i<3 ; i++)
206: velocity[i] += accelspeed*wishveloc[i];
207: }
208:
209:
210: void DropPunchAngle (void)
211: {
212: float len;
213:
214: len = VectorNormalize (sv_player->v.punchangle);
215:
216: len -= 10*host_frametime;
217: if (len < 0)
218: len = 0;
219: VectorScale (sv_player->v.punchangle, len, sv_player->v.punchangle);
220: }
221:
222: /*
223: ===================
224: SV_WaterMove
225:
226: ===================
227: */
228: void SV_WaterMove (void)
229: {
230: int i;
231: vec3_t wishvel;
232: float speed, newspeed, wishspeed, addspeed, accelspeed;
233:
234: //
235: // user intentions
236: //
237: AngleVectors (sv_player->v.v_angle, forward, right, up);
238:
239: for (i=0 ; i<3 ; i++)
240: wishvel[i] = forward[i]*cmd.forwardmove + right[i]*cmd.sidemove;
241:
242: if (!cmd.forwardmove && !cmd.sidemove && !cmd.upmove)
243: wishvel[2] -= 60; // drift towards bottom
244: else
245: wishvel[2] += cmd.upmove;
246:
247: wishspeed = Length(wishvel);
248: if (wishspeed > sv_maxspeed.value)
249: {
250: VectorScale (wishvel, sv_maxspeed.value/wishspeed, wishvel);
251: wishspeed = sv_maxspeed.value;
252: }
253: wishspeed *= 0.7;
254:
255: //
256: // water friction
257: //
258: speed = Length (velocity);
259: if (speed)
260: {
261: newspeed = speed - host_frametime * speed * sv_friction.value;
262: if (newspeed < 0)
263: newspeed = 0;
264: VectorScale (velocity, newspeed/speed, velocity);
265: }
266: else
267: newspeed = 0;
268:
269: //
270: // water acceleration
271: //
272: if (!wishspeed)
273: return;
274:
275: addspeed = wishspeed - newspeed;
276: if (addspeed <= 0)
277: return;
278:
279: VectorNormalize (wishvel);
280: accelspeed = sv_accelerate.value * wishspeed * host_frametime;
281: if (accelspeed > addspeed)
282: accelspeed = addspeed;
283:
284: for (i=0 ; i<3 ; i++)
285: velocity[i] += accelspeed * wishvel[i];
286: }
287:
288: void SV_WaterJump (void)
289: {
290: if (sv.time > sv_player->v.teleport_time
291: || !sv_player->v.waterlevel)
292: {
293: sv_player->v.flags = (int)sv_player->v.flags & ~FL_WATERJUMP;
294: sv_player->v.teleport_time = 0;
295: }
296: sv_player->v.velocity[0] = sv_player->v.movedir[0];
297: sv_player->v.velocity[1] = sv_player->v.movedir[1];
298: }
299:
300:
301: /*
302: ===================
303: SV_AirMove
304:
305: ===================
306: */
307: void SV_AirMove (void)
308: {
309: int i;
310: vec3_t wishvel;
311: float fmove, smove;
312:
313: AngleVectors (sv_player->v.angles, forward, right, up);
314:
315: fmove = cmd.forwardmove;
316: smove = cmd.sidemove;
317:
318: // hack to not let you back into teleporter
319: if (sv.time < sv_player->v.teleport_time && fmove < 0)
320: fmove = 0;
321:
322: for (i=0 ; i<3 ; i++)
323: wishvel[i] = forward[i]*fmove + right[i]*smove;
324:
325: if ( (int)sv_player->v.movetype != MOVETYPE_WALK)
326: wishvel[2] = cmd.upmove;
327: else
328: wishvel[2] = 0;
329:
330: VectorCopy (wishvel, wishdir);
331: wishspeed = VectorNormalize(wishdir);
332: if (wishspeed > sv_maxspeed.value)
333: {
334: VectorScale (wishvel, sv_maxspeed.value/wishspeed, wishvel);
335: wishspeed = sv_maxspeed.value;
336: }
337:
338: if ( sv_player->v.movetype == MOVETYPE_NOCLIP)
339: { // noclip
340: VectorCopy (wishvel, velocity);
341: }
342: else if ( onground )
343: {
344: SV_UserFriction ();
345: SV_Accelerate ();
346: }
347: else
348: { // not on ground, so little effect on velocity
349: SV_AirAccelerate (wishvel);
350: }
351: }
352:
353: /*
354: ===================
355: SV_ClientThink
356:
357: the move fields specify an intended velocity in pix/sec
358: the angle fields specify an exact angular motion in degrees
359: ===================
360: */
361: void SV_ClientThink (void)
362: {
363: vec3_t v_angle;
364:
365: if (sv_player->v.movetype == MOVETYPE_NONE)
366: return;
367:
368: onground = (int)sv_player->v.flags & FL_ONGROUND;
369:
370: origin = sv_player->v.origin;
371: velocity = sv_player->v.velocity;
372:
373: DropPunchAngle ();
374:
375: //
376: // if dead, behave differently
377: //
378: if (sv_player->v.health <= 0)
379: return;
380:
381: //
382: // angles
383: // show 1/3 the pitch angle and all the roll angle
384: cmd = host_client->cmd;
385: angles = sv_player->v.angles;
386:
387: VectorAdd (sv_player->v.v_angle, sv_player->v.punchangle, v_angle);
388: angles[ROLL] = V_CalcRoll (sv_player->v.angles, sv_player->v.velocity)*4;
389: if (!sv_player->v.fixangle)
390: {
391: angles[PITCH] = -v_angle[PITCH]/3;
392: angles[YAW] = v_angle[YAW];
393: }
394:
395: if ( (int)sv_player->v.flags & FL_WATERJUMP )
396: {
397: SV_WaterJump ();
398: return;
399: }
400: //
401: // walk
402: //
403: if ( (sv_player->v.waterlevel >= 2)
404: && (sv_player->v.movetype != MOVETYPE_NOCLIP) )
405: {
406: SV_WaterMove ();
407: return;
408: }
409:
410: SV_AirMove ();
411: }
412:
413:
414: /*
415: ===================
416: SV_ReadClientMove
417: ===================
418: */
419: void SV_ReadClientMove (usercmd_t *move)
420: {
421: int i;
422: vec3_t angle;
423: int bits;
424:
425: // read ping time
426: host_client->ping_times[host_client->num_pings%NUM_PING_TIMES]
427: = sv.time - MSG_ReadFloat ();
428: host_client->num_pings++;
429:
430: // read current angles
431: for (i=0 ; i<3 ; i++)
432: angle[i] = MSG_ReadAngle ();
433:
434: VectorCopy (angle, host_client->edict->v.v_angle);
435:
436: // read movement
437: move->forwardmove = MSG_ReadShort ();
438: move->sidemove = MSG_ReadShort ();
439: move->upmove = MSG_ReadShort ();
440:
441: // read buttons
442: bits = MSG_ReadByte ();
443: host_client->edict->v.button0 = bits & 1;
444: host_client->edict->v.button2 = (bits & 2)>>1;
445:
446: i = MSG_ReadByte ();
447: if (i)
448: host_client->edict->v.impulse = i;
449: }
450:
451: /*
452: ===================
453: SV_ReadClientMessage
454:
455: Returns false if the client should be killed
456: ===================
457: */
458: qboolean SV_ReadClientMessage (void)
459: {
460: int ret;
461: int cmd;
462: char *s;
463:
464: do
465: {
466: nextmsg:
467: ret = NET_GetMessage (host_client->netconnection);
468: if (ret == -1)
469: {
470: Sys_Printf ("SV_ReadClientMessage: NET_GetMessage failed\n");
471: return false;
472: }
473: if (!ret)
474: return true;
475:
476: MSG_BeginReading ();
477:
478: while (1)
479: {
480: if (!host_client->active)
481: return false; // a command caused an error
482:
483: if (msg_badread)
484: {
485: Sys_Printf ("SV_ReadClientMessage: badread\n");
486: return false;
487: }
488:
489: cmd = MSG_ReadChar ();
490:
491: switch (cmd)
492: {
493: case -1:
494: goto nextmsg; // end of message
495:
496: default:
497: Sys_Printf ("SV_ReadClientMessage: unknown command char\n");
498: return false;
499:
500: case clc_nop:
501: // Sys_Printf ("clc_nop\n");
502: break;
503:
504: case clc_stringcmd:
505: s = MSG_ReadString ();
506: Cmd_ExecuteString (s, src_client);
507: break;
508:
509: case clc_disconnect:
510: Sys_Printf ("SV_ReadClientMessage: client disconnected\n");
511: return false;
512:
513: case clc_move:
514: SV_ReadClientMove (&host_client->cmd);
515: break;
516: }
517: }
518: } while (ret == 1);
519:
520: return true;
521: }
522:
523:
524: /*
525: ==================
526: SV_RunClients
527: ==================
528: */
529: void SV_RunClients (void)
530: {
531: int i;
532:
533: for (i=0, host_client = svs.clients ; i<svs.maxclients ; i++, host_client++)
534: {
535: if (!host_client->active)
536: continue;
537:
538: sv_player = host_client->edict;
539:
540: if (!SV_ReadClientMessage ())
541: {
542: SV_DropClient (false); // client misbehaved...
543: continue;
544: }
545:
546: if (!host_client->spawned)
547: {
548: // clear client movement until a new packet is received
549: memset (&host_client->cmd, 0, sizeof(host_client->cmd));
550: continue;
551: }
552:
553: // allways pause in single player if in console or menus
554: if (!sv.paused && (svs.maxclients > 1 || key_dest == key_game) )
555: SV_ClientThink ();
556: }
557: }
558:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.