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 included (GNU.txt) 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 /* ZOID
21 *
22 * Player camera tracking in Spectator mode
23 *
24 * This takes over player controls for spectator automatic camera.
25 * Player moves as a spectator, but the camera tracks and enemy player
26 */
27
28 #include "client.h"
29 #include "console.h"
30 #include "mathlib.h"
31 #include "pmove.h"
32 #include "quakedef.h"
33 #include "sbar.h"
34
35 #define PM_SPECTATORMAXSPEED 500
36 #define PM_STOPSPEED 100
37 #define PM_MAXSPEED 320
38 #define BUTTON_JUMP 2
39 #define BUTTON_ATTACK 1
40 #define MAX_ANGLE_TURN 10
41
42 static vec3_t desired_position; // where the camera wants to be
43 static qboolean locked = false;
44 static int oldbuttons;
45
46 // track high fragger
47 static cvar_t cl_hightrack = { "cl_hightrack", "0" };
48 static cvar_t cl_chasecam = { "cl_chasecam", "0" };
49
50 //cvar_t cl_camera_maxpitch = {"cl_camera_maxpitch", "10" };
51 //cvar_t cl_camera_maxyaw = {"cl_camera_maxyaw", "30" };
52
53 static qboolean cam_forceview;
54 //static vec3_t cam_viewangles;
55 static double cam_lastviewtime;
56
57 int spec_track = 0; // player# of who we are tracking
58 int autocam = CAM_NONE;
59
vectoangles(vec3_t vec,vec3_t ang)60 static void vectoangles(vec3_t vec, vec3_t ang)
61 {
62 float yaw, pitch;
63
64 if (vec[1] == 0 && vec[0] == 0)
65 {
66 yaw = 0;
67 if (vec[2] > 0)
68 pitch = 90;
69 else
70 pitch = 270;
71 }
72 else
73 {
74 float forward;
75 yaw = (int)(atan2(vec[1], vec[0]) * 180 / M_PI);
76 if (yaw < 0)
77 yaw += 360;
78
79 forward = sqrt(vec[0] * vec[0] + vec[1] * vec[1]);
80 pitch = (int)(atan2(vec[2], forward) * 180 / M_PI);
81 if (pitch < 0)
82 pitch += 360;
83 }
84
85 ang[0] = pitch;
86 ang[1] = yaw;
87 ang[2] = 0;
88 }
89
90 static float
vlen(vec3_t v)91 vlen(vec3_t v)
92 {
93 return sqrt(v[0] * v[0] + v[1] * v[1] + v[2] * v[2]);
94 }
95
96 // returns true if weapon model should be drawn in camera mode
97 qboolean
Cam_DrawViewModel(void)98 Cam_DrawViewModel(void)
99 {
100 if (!cl.spectator)
101 return true;
102
103 if (autocam && locked && cl_chasecam.value)
104 return true;
105 return false;
106 }
107
108 // returns true if we should draw this player, we don't if we are chase camming
109 qboolean
Cam_DrawPlayer(int playernum)110 Cam_DrawPlayer(int playernum)
111 {
112 if (cl.spectator && autocam && locked && cl_chasecam.value &&
113 spec_track == playernum)
114 return false;
115 return true;
116 }
117
118 static void
Cam_Unlock(void)119 Cam_Unlock(void)
120 {
121 if (autocam) {
122 MSG_WriteByte(&cls.netchan.message, clc_stringcmd);
123 MSG_WriteString(&cls.netchan.message, "ptrack");
124 autocam = CAM_NONE;
125 locked = false;
126 Sbar_Changed();
127 }
128 }
129
130 static void
Cam_Lock(int playernum)131 Cam_Lock(int playernum)
132 {
133 MSG_WriteByte(&cls.netchan.message, clc_stringcmd);
134 MSG_WriteStringf(&cls.netchan.message, "ptrack %i", playernum);
135 spec_track = playernum;
136 cam_forceview = true;
137 locked = false;
138 Sbar_Changed();
139 }
140
141 static pmtrace_t
Cam_DoTrace(vec3_t vec1,vec3_t vec2)142 Cam_DoTrace(vec3_t vec1, vec3_t vec2)
143 {
144 #if 0
145 memset(&pmove, 0, sizeof(pmove));
146
147 pmove.numphysent = 1;
148 VectorCopy(vec3_origin, pmove.physents[0].origin);
149 pmove.physents[0].model = cl.worldmodel;
150 #endif
151
152 VectorCopy(vec1, pmove.origin);
153 return PM_PlayerMove(pmove.origin, vec2);
154 }
155
156 // Returns distance or 9999 if invalid for some reason
Cam_TryFlyby(player_state_t * self,player_state_t * player,vec3_t vec,qboolean checkvis)157 static float Cam_TryFlyby(player_state_t * self,
158 player_state_t * player, vec3_t vec,
159 qboolean checkvis)
160 {
161 vec3_t v;
162 pmtrace_t trace;
163 float len;
164
165 vectoangles(vec, v);
166 VectorCopy(v, pmove.angles);
167 VectorNormalize(vec);
168 VectorMA(player->origin, 800, vec, v);
169 // v is endpos
170 // fake a player move
171 trace = Cam_DoTrace(player->origin, v);
172 if ( /*trace.inopen || */ trace.inwater)
173 return 9999;
174 VectorCopy(trace.endpos, vec);
175 VectorSubtract(trace.endpos, player->origin, v);
176 len = sqrt(v[0] * v[0] + v[1] * v[1] + v[2] * v[2]);
177 if (len < 32 || len > 800)
178 return 9999;
179 if (checkvis)
180 {
181 VectorSubtract(trace.endpos, self->origin, v);
182 len = sqrt(v[0] * v[0] + v[1] * v[1] + v[2] * v[2]);
183
184 trace = Cam_DoTrace(self->origin, vec);
185 if (trace.fraction != 1 || trace.inwater)
186 return 9999;
187 }
188 return len;
189 }
190
191 // Is player visible?
192 static qboolean
Cam_IsVisible(player_state_t * player,vec3_t vec)193 Cam_IsVisible(player_state_t * player, vec3_t vec)
194 {
195 pmtrace_t trace;
196 vec3_t v;
197 float d;
198
199 trace = Cam_DoTrace(player->origin, vec);
200 if (trace.fraction != 1 || /*trace.inopen || */ trace.inwater)
201 return false;
202 // check distance, don't let the player get too far away or too close
203 VectorSubtract(player->origin, vec, v);
204 d = vlen(v);
205 if (d < 16)
206 return false;
207 return true;
208 }
209
210 static qboolean
InitFlyby(player_state_t * self,player_state_t * player,int checkvis)211 InitFlyby(player_state_t * self, player_state_t * player, int checkvis)
212 {
213 float f, max;
214 vec3_t vec, vec2;
215 vec3_t forward, right, up;
216
217 VectorCopy(player->viewangles, vec);
218 vec[0] = 0;
219 AngleVectors(vec, forward, right, up);
220 // for (i = 0; i < 3; i++)
221 // forward[i] *= 3;
222
223 max = 1000;
224 VectorAdd(forward, up, vec2);
225 VectorAdd(vec2, right, vec2);
226 if ((f = Cam_TryFlyby(self, player, vec2, checkvis)) < max) {
227 max = f;
228 VectorCopy(vec2, vec);
229 }
230 VectorAdd(forward, up, vec2);
231 VectorSubtract(vec2, right, vec2);
232 if ((f = Cam_TryFlyby(self, player, vec2, checkvis)) < max) {
233 max = f;
234 VectorCopy(vec2, vec);
235 }
236 VectorAdd(forward, right, vec2);
237 if ((f = Cam_TryFlyby(self, player, vec2, checkvis)) < max) {
238 max = f;
239 VectorCopy(vec2, vec);
240 }
241 VectorSubtract(forward, right, vec2);
242 if ((f = Cam_TryFlyby(self, player, vec2, checkvis)) < max) {
243 max = f;
244 VectorCopy(vec2, vec);
245 }
246 VectorAdd(forward, up, vec2);
247 if ((f = Cam_TryFlyby(self, player, vec2, checkvis)) < max) {
248 max = f;
249 VectorCopy(vec2, vec);
250 }
251 VectorSubtract(forward, up, vec2);
252 if ((f = Cam_TryFlyby(self, player, vec2, checkvis)) < max) {
253 max = f;
254 VectorCopy(vec2, vec);
255 }
256 VectorAdd(up, right, vec2);
257 VectorSubtract(vec2, forward, vec2);
258 if ((f = Cam_TryFlyby(self, player, vec2, checkvis)) < max) {
259 max = f;
260 VectorCopy(vec2, vec);
261 }
262 VectorSubtract(up, right, vec2);
263 VectorSubtract(vec2, forward, vec2);
264 if ((f = Cam_TryFlyby(self, player, vec2, checkvis)) < max) {
265 max = f;
266 VectorCopy(vec2, vec);
267 }
268 // invert
269 VectorSubtract(vec3_origin, forward, vec2);
270 if ((f = Cam_TryFlyby(self, player, vec2, checkvis)) < max) {
271 max = f;
272 VectorCopy(vec2, vec);
273 }
274 VectorCopy(forward, vec2);
275 if ((f = Cam_TryFlyby(self, player, vec2, checkvis)) < max) {
276 max = f;
277 VectorCopy(vec2, vec);
278 }
279 // invert
280 VectorSubtract(vec3_origin, right, vec2);
281 if ((f = Cam_TryFlyby(self, player, vec2, checkvis)) < max) {
282 max = f;
283 VectorCopy(vec2, vec);
284 }
285 VectorCopy(right, vec2);
286 if ((f = Cam_TryFlyby(self, player, vec2, checkvis)) < max) {
287 max = f;
288 VectorCopy(vec2, vec);
289 }
290 // ack, can't find him
291 if (max >= 1000) {
292 // Cam_Unlock();
293 return false;
294 }
295 locked = true;
296 VectorCopy(vec, desired_position);
297 return true;
298 }
299
300 static void
Cam_CheckHighTarget(void)301 Cam_CheckHighTarget(void)
302 {
303 int i, j, max;
304 player_info_t *s;
305
306 j = -1;
307 for (i = 0, max = -9999; i < MAX_CLIENTS; i++) {
308 s = &cl.players[i];
309 if (s->name[0] && !s->spectator && s->frags > max) {
310 max = s->frags;
311 j = i;
312 }
313 }
314 if (j >= 0) {
315 if (!locked || cl.players[j].frags > cl.players[spec_track].frags)
316 Cam_Lock(j);
317 } else
318 Cam_Unlock();
319 }
320
321 // ZOID
322 //
323 // Take over the user controls and track a player.
324 // We find a nice position to watch the player and move there
325 void
Cam_Track(usercmd_t * cmd)326 Cam_Track(usercmd_t *cmd)
327 {
328 player_state_t *player, *self;
329 frame_t *frame;
330 vec3_t vec;
331
332 if (!cl.spectator)
333 return;
334
335 if (cl_hightrack.value && !locked)
336 Cam_CheckHighTarget();
337
338 if (!autocam || cls.state != ca_active)
339 return;
340
341 if (locked && (!cl.players[spec_track].name[0]
342 || cl.players[spec_track].spectator))
343 {
344 locked = false;
345 if (cl_hightrack.value)
346 Cam_CheckHighTarget();
347 else
348 Cam_Unlock();
349 return;
350 }
351
352 frame = &cl.frames[cls.netchan.incoming_sequence & UPDATE_MASK];
353 player = frame->playerstate + spec_track;
354 self = frame->playerstate + cl.playernum;
355
356 if (!locked || !Cam_IsVisible(player, desired_position)) {
357 if (!locked || realtime - cam_lastviewtime > 0.1) {
358 if (!InitFlyby(self, player, true))
359 InitFlyby(self, player, false);
360 cam_lastviewtime = realtime;
361 }
362 } else
363 cam_lastviewtime = realtime;
364
365 // couldn't track for some reason
366 if (!locked || !autocam)
367 return;
368
369 if (cl_chasecam.value)
370 {
371 cmd->forwardmove = cmd->sidemove = cmd->upmove = 0;
372
373 VectorCopy(player->viewangles, cl.viewangles);
374 VectorCopy(player->origin, desired_position);
375 if (memcmp
376 (&desired_position, &self->origin,
377 sizeof(desired_position)) != 0) {
378 MSG_WriteByte(&cls.netchan.message, clc_tmove);
379 MSG_WriteCoord(&cls.netchan.message, desired_position[0]);
380 MSG_WriteCoord(&cls.netchan.message, desired_position[1]);
381 MSG_WriteCoord(&cls.netchan.message, desired_position[2]);
382 // move there locally immediately
383 VectorCopy(desired_position, self->origin);
384 }
385 self->weaponframe = player->weaponframe;
386
387 }
388 else
389 {
390 float len;
391 // Ok, move to our desired position and set our angles to view
392 // the player
393 VectorSubtract(desired_position, self->origin, vec);
394 len = vlen(vec);
395 cmd->forwardmove = cmd->sidemove = cmd->upmove = 0;
396 if (len > 16) { // close enough?
397 MSG_WriteByte(&cls.netchan.message, clc_tmove);
398 MSG_WriteCoord(&cls.netchan.message, desired_position[0]);
399 MSG_WriteCoord(&cls.netchan.message, desired_position[1]);
400 MSG_WriteCoord(&cls.netchan.message, desired_position[2]);
401 }
402 // move there locally immediately
403 VectorCopy(desired_position, self->origin);
404
405 VectorSubtract(player->origin, desired_position, vec);
406 vectoangles(vec, cl.viewangles);
407 cl.viewangles[0] = -cl.viewangles[0];
408 }
409 }
410
411 #if 0
412 static float
413 adjustang(float current, float ideal, float speed)
414 {
415 float move;
416
417 current = anglemod(current);
418 ideal = anglemod(ideal);
419
420 if (current == ideal)
421 return current;
422
423 move = ideal - current;
424 if (ideal > current) {
425 if (move >= 180)
426 move = move - 360;
427 } else {
428 if (move <= -180)
429 move = move + 360;
430 }
431 if (move > 0) {
432 if (move > speed)
433 move = speed;
434 } else {
435 if (move < -speed)
436 move = -speed;
437 }
438
439 //Con_Printf("c/i: %4.2f/%4.2f move: %4.2f\n", current, ideal, move);
440 return anglemod(current + move);
441 }
442 #endif
443
444 #if 0
445 static void
446 Cam_SetView(void)
447 {
448 return;
449 player_state_t *player, *self;
450 frame_t *frame;
451 vec3_t vec, vec2;
452
453 if (cls.state != ca_active || !cl.spectator || !autocam || !locked)
454 return;
455
456 frame = &cl.frames[cls.netchan.incoming_sequence & UPDATE_MASK];
457 player = frame->playerstate + spec_track;
458 self = frame->playerstate + cl.playernum;
459
460 VectorSubtract(player->origin, cl.simorg, vec);
461 if (cam_forceview) {
462 cam_forceview = false;
463 vectoangles(vec, cam_viewangles);
464 cam_viewangles[0] = -cam_viewangles[0];
465 } else {
466 vectoangles(vec, vec2);
467 vec2[PITCH] = -vec2[PITCH];
468
469 cam_viewangles[PITCH] =
470 adjustang(cam_viewangles[PITCH], vec2[PITCH],
471 cl_camera_maxpitch.value);
472 cam_viewangles[YAW] =
473 adjustang(cam_viewangles[YAW], vec2[YAW], cl_camera_maxyaw.value);
474 }
475 VectorCopy(cam_viewangles, cl.viewangles);
476 VectorCopy(cl.viewangles, cl.simangles);
477 }
478 #endif
479
480 void
Cam_FinishMove(usercmd_t * cmd)481 Cam_FinishMove(usercmd_t *cmd)
482 {
483 int i;
484 player_info_t *s;
485 int end;
486
487 if (cls.state != ca_active)
488 return;
489
490 if (!cl.spectator) // only in spectator mode
491 return;
492
493 #if 0
494 if (autocam && locked) {
495 frame = &cl.frames[cls.netchan.incoming_sequence & UPDATE_MASK];
496 player = frame->playerstate + spec_track;
497 self = frame->playerstate + cl.playernum;
498
499 VectorSubtract(player->origin, self->origin, vec);
500 if (cam_forceview) {
501 cam_forceview = false;
502 vectoangles(vec, cam_viewangles);
503 cam_viewangles[0] = -cam_viewangles[0];
504 } else {
505 vectoangles(vec, vec2);
506 vec2[PITCH] = -vec2[PITCH];
507
508 cam_viewangles[PITCH] =
509 adjustang(cam_viewangles[PITCH], vec2[PITCH],
510 cl_camera_maxpitch.value);
511 cam_viewangles[YAW] =
512 adjustang(cam_viewangles[YAW], vec2[YAW],
513 cl_camera_maxyaw.value);
514 }
515 VectorCopy(cam_viewangles, cl.viewangles);
516 }
517 #endif
518
519 if (cmd->buttons & BUTTON_ATTACK) {
520 if (!(oldbuttons & BUTTON_ATTACK)) {
521
522 oldbuttons |= BUTTON_ATTACK;
523 autocam++;
524
525 if (autocam > CAM_TRACK) {
526 Cam_Unlock();
527 VectorCopy(cl.viewangles, cmd->angles);
528 return;
529 }
530 } else
531 return;
532 } else {
533 oldbuttons &= ~BUTTON_ATTACK;
534 if (!autocam)
535 return;
536 }
537
538 if (autocam && cl_hightrack.value) {
539 Cam_CheckHighTarget();
540 return;
541 }
542
543 if (locked) {
544 if ((cmd->buttons & BUTTON_JUMP) && (oldbuttons & BUTTON_JUMP))
545 return; // don't pogo stick
546
547 if (!(cmd->buttons & BUTTON_JUMP)) {
548 oldbuttons &= ~BUTTON_JUMP;
549 return;
550 }
551 oldbuttons |= BUTTON_JUMP; // don't jump again until released
552 }
553 // Con_Printf("Selecting track target...\n");
554
555 if (locked && autocam)
556 end = (spec_track + 1) % MAX_CLIENTS;
557 else
558 end = spec_track;
559 i = end;
560 do {
561 s = &cl.players[i];
562 if (s->name[0] && !s->spectator) {
563 Cam_Lock(i);
564 return;
565 }
566 i = (i + 1) % MAX_CLIENTS;
567 } while (i != end);
568 // stay on same guy?
569 i = spec_track;
570 s = &cl.players[i];
571 if (s->name[0] && !s->spectator) {
572 Cam_Lock(i);
573 return;
574 }
575 Con_Printf("No target found ...\n");
576 autocam = locked = false;
577 }
578
579 void
Cam_Reset(void)580 Cam_Reset(void)
581 {
582 autocam = CAM_NONE;
583 spec_track = 0;
584 }
585
586 void
CL_InitCam(void)587 CL_InitCam(void)
588 {
589 Cvar_RegisterVariable(&cl_hightrack);
590 Cvar_RegisterVariable(&cl_chasecam);
591 // Cvar_RegisterVariable (&cl_camera_maxpitch);
592 // Cvar_RegisterVariable (&cl_camera_maxyaw);
593 }
594