The Quake sources as originally release under the GPL license on December 21, 1999

QW/client/cl_cam.c

@@ -0,0 +1,574 @@
+/*
+Copyright (C) 1996-1997 Id Software, Inc.
+
+This program is free software; you can redistribute it and/or
+modify it under the terms of the GNU General Public License
+as published by the Free Software Foundation; either version 2
+of the License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  
+
+See the included (GNU.txt) GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+
+*/
+/* ZOID
+ *
+ * Player camera tracking in Spectator mode
+ *
+ * This takes over player controls for spectator automatic camera.
+ * Player moves as a spectator, but the camera tracks and enemy player
+ */
+
+#include "quakedef.h"
+#include "winquake.h"
+
+#define	PM_SPECTATORMAXSPEED	500
+#define	PM_STOPSPEED	100
+#define	PM_MAXSPEED			320
+#define BUTTON_JUMP 2
+#define BUTTON_ATTACK 1
+#define MAX_ANGLE_TURN 10
+
+static vec3_t desired_position; // where the camera wants to be
+static qboolean locked = false;
+static int oldbuttons;
+
+// track high fragger
+cvar_t cl_hightrack = {"cl_hightrack", "0" };
+
+cvar_t cl_chasecam = {"cl_chasecam", "0"};
+
+//cvar_t cl_camera_maxpitch = {"cl_camera_maxpitch", "10" };
+//cvar_t cl_camera_maxyaw = {"cl_camera_maxyaw", "30" };
+
+qboolean cam_forceview;
+vec3_t cam_viewangles;
+double cam_lastviewtime;
+
+int spec_track = 0; // player# of who we are tracking
+int autocam = CAM_NONE;
+
+static void vectoangles(vec3_t vec, vec3_t ang)
+{
+	float	forward;
+	float	yaw, pitch;
+	
+	if (vec[1] == 0 && vec[0] == 0)
+	{
+		yaw = 0;
+		if (vec[2] > 0)
+			pitch = 90;
+		else
+			pitch = 270;
+	}
+	else
+	{
+		yaw = (int) (atan2(vec[1], vec[0]) * 180 / M_PI);
+		if (yaw < 0)
+			yaw += 360;
+
+		forward = sqrt (vec[0]*vec[0] + vec[1]*vec[1]);
+		pitch = (int) (atan2(vec[2], forward) * 180 / M_PI);
+		if (pitch < 0)
+			pitch += 360;
+	}
+
+	ang[0] = pitch;
+	ang[1] = yaw;
+	ang[2] = 0;
+}
+
+static float vlen(vec3_t v)
+{
+	return sqrt(v[0]*v[0] + v[1]*v[1] + v[2]*v[2]);
+}
+
+// returns true if weapon model should be drawn in camera mode
+qboolean Cam_DrawViewModel(void)
+{
+	if (!cl.spectator)
+		return true;
+
+	if (autocam && locked && cl_chasecam.value)
+		return true;
+	return false;
+}
+
+// returns true if we should draw this player, we don't if we are chase camming
+qboolean Cam_DrawPlayer(int playernum)
+{
+	if (cl.spectator && autocam && locked && cl_chasecam.value && 
+		spec_track == playernum)
+		return false;
+	return true;
+}
+
+void Cam_Unlock(void)
+{
+	if (autocam) {
+		MSG_WriteByte (&cls.netchan.message, clc_stringcmd);
+		MSG_WriteString (&cls.netchan.message, "ptrack");
+		autocam = CAM_NONE;
+		locked = false;
+		Sbar_Changed();
+	}
+}
+
+void Cam_Lock(int playernum)
+{
+	char st[40];
+
+	sprintf(st, "ptrack %i", playernum);
+	MSG_WriteByte (&cls.netchan.message, clc_stringcmd);
+	MSG_WriteString (&cls.netchan.message, st);
+	spec_track = playernum;
+	cam_forceview = true;
+	locked = false;
+	Sbar_Changed();
+}
+
+pmtrace_t Cam_DoTrace(vec3_t vec1, vec3_t vec2)
+{
+#if 0
+	memset(&pmove, 0, sizeof(pmove));
+
+	pmove.numphysent = 1;
+	VectorCopy (vec3_origin, pmove.physents[0].origin);
+	pmove.physents[0].model = cl.worldmodel;
+#endif
+
+	VectorCopy (vec1, pmove.origin);
+	return PM_PlayerMove(pmove.origin, vec2);
+}
+	
+// Returns distance or 9999 if invalid for some reason
+static float Cam_TryFlyby(player_state_t *self, player_state_t *player, vec3_t vec, qboolean checkvis)
+{
+	vec3_t v;
+	pmtrace_t trace;
+	float len;
+
+	vectoangles(vec, v);
+//	v[0] = -v[0];
+	VectorCopy (v, pmove.angles);
+	VectorNormalize(vec);
+	VectorMA(player->origin, 800, vec, v);
+	// v is endpos
+	// fake a player move
+	trace = Cam_DoTrace(player->origin, v);
+	if (/*trace.inopen ||*/ trace.inwater)
+		return 9999;
+	VectorCopy(trace.endpos, vec);
+	VectorSubtract(trace.endpos, player->origin, v);
+	len = sqrt(v[0]*v[0] + v[1]*v[1] + v[2]*v[2]);
+	if (len < 32 || len > 800)
+		return 9999;
+	if (checkvis) {
+		VectorSubtract(trace.endpos, self->origin, v);
+		len = sqrt(v[0]*v[0] + v[1]*v[1] + v[2]*v[2]);
+
+		trace = Cam_DoTrace(self->origin, vec);
+		if (trace.fraction != 1 || trace.inwater)
+			return 9999;
+	}
+	return len;
+}
+
+// Is player visible?
+static qboolean Cam_IsVisible(player_state_t *player, vec3_t vec)
+{
+	pmtrace_t trace;
+	vec3_t v;
+	float d;
+
+	trace = Cam_DoTrace(player->origin, vec);
+	if (trace.fraction != 1 || /*trace.inopen ||*/ trace.inwater)
+		return false;
+	// check distance, don't let the player get too far away or too close
+	VectorSubtract(player->origin, vec, v);
+	d = vlen(v);
+	if (d < 16)
+		return false;
+	return true;
+}
+
+static qboolean InitFlyby(player_state_t *self, player_state_t *player, int checkvis) 
+{
+    float f, max;
+    vec3_t vec, vec2;
+	vec3_t forward, right, up;
+
+	VectorCopy(player->viewangles, vec);
+    vec[0] = 0;
+	AngleVectors (vec, forward, right, up);
+//	for (i = 0; i < 3; i++)
+//		forward[i] *= 3;
+
+    max = 1000;
+	VectorAdd(forward, up, vec2);
+	VectorAdd(vec2, right, vec2);
+    if ((f = Cam_TryFlyby(self, player, vec2, checkvis)) < max) {
+        max = f;
+		VectorCopy(vec2, vec);
+    }
+	VectorAdd(forward, up, vec2);
+	VectorSubtract(vec2, right, vec2);
+    if ((f = Cam_TryFlyby(self, player, vec2, checkvis)) < max) {
+        max = f;
+		VectorCopy(vec2, vec);
+    }
+	VectorAdd(forward, right, vec2);
+    if ((f = Cam_TryFlyby(self, player, vec2, checkvis)) < max) {
+        max = f;
+		VectorCopy(vec2, vec);
+    }
+	VectorSubtract(forward, right, vec2);
+    if ((f = Cam_TryFlyby(self, player, vec2, checkvis)) < max) {
+        max = f;
+		VectorCopy(vec2, vec);
+    }
+	VectorAdd(forward, up, vec2);
+    if ((f = Cam_TryFlyby(self, player, vec2, checkvis)) < max) {
+        max = f;
+		VectorCopy(vec2, vec);
+    }
+	VectorSubtract(forward, up, vec2);
+    if ((f = Cam_TryFlyby(self, player, vec2, checkvis)) < max) {
+        max = f;
+		VectorCopy(vec2, vec);
+    }
+	VectorAdd(up, right, vec2);
+	VectorSubtract(vec2, forward, vec2);
+    if ((f = Cam_TryFlyby(self, player, vec2, checkvis)) < max) {
+        max = f;
+		VectorCopy(vec2, vec);
+    }
+	VectorSubtract(up, right, vec2);
+	VectorSubtract(vec2, forward, vec2);
+    if ((f = Cam_TryFlyby(self, player, vec2, checkvis)) < max) {
+        max = f;
+		VectorCopy(vec2, vec);
+    }
+	// invert
+	VectorSubtract(vec3_origin, forward, vec2);
+    if ((f = Cam_TryFlyby(self, player, vec2, checkvis)) < max) {
+        max = f;
+		VectorCopy(vec2, vec);
+    }
+	VectorCopy(forward, vec2);
+    if ((f = Cam_TryFlyby(self, player, vec2, checkvis)) < max) {
+        max = f;
+		VectorCopy(vec2, vec);
+    }
+	// invert
+	VectorSubtract(vec3_origin, right, vec2);
+    if ((f = Cam_TryFlyby(self, player, vec2, checkvis)) < max) {
+        max = f;
+		VectorCopy(vec2, vec);
+    }
+	VectorCopy(right, vec2);
+    if ((f = Cam_TryFlyby(self, player, vec2, checkvis)) < max) {
+        max = f;
+		VectorCopy(vec2, vec);
+    }
+
+	// ack, can't find him
+    if (max >= 1000) {
+//		Cam_Unlock();
+		return false;
+	}
+	locked = true;
+	VectorCopy(vec, desired_position); 
+	return true;
+}
+
+static void Cam_CheckHighTarget(void)
+{
+	int i, j, max;
+	player_info_t	*s;
+
+	j = -1;
+	for (i = 0, max = -9999; i < MAX_CLIENTS; i++) {
+		s = &cl.players[i];
+		if (s->name[0] && !s->spectator && s->frags > max) {
+			max = s->frags;
+			j = i;
+		}
+	}
+	if (j >= 0) {
+		if (!locked || cl.players[j].frags > cl.players[spec_track].frags)
+			Cam_Lock(j);
+	} else
+		Cam_Unlock();
+}
+	
+// ZOID
+//
+// Take over the user controls and track a player.
+// We find a nice position to watch the player and move there
+void Cam_Track(usercmd_t *cmd)
+{
+	player_state_t *player, *self;
+	frame_t *frame;
+	vec3_t vec;
+	float len;
+
+	if (!cl.spectator)
+		return;
+	
+	if (cl_hightrack.value && !locked)
+		Cam_CheckHighTarget();
+
+	if (!autocam || cls.state != ca_active)
+		return;
+
+	if (locked && (!cl.players[spec_track].name[0] || cl.players[spec_track].spectator)) {
+		locked = false;
+		if (cl_hightrack.value)
+			Cam_CheckHighTarget();
+		else
+			Cam_Unlock();
+		return;
+	}
+
+	frame = &cl.frames[cls.netchan.incoming_sequence & UPDATE_MASK];
+	player = frame->playerstate + spec_track;
+	self = frame->playerstate + cl.playernum;
+
+	if (!locked || !Cam_IsVisible(player, desired_position)) {
+		if (!locked || realtime - cam_lastviewtime > 0.1) {
+			if (!InitFlyby(self, player, true))
+				InitFlyby(self, player, false);
+			cam_lastviewtime = realtime;
+		}
+	} else
+		cam_lastviewtime = realtime;
+	
+	// couldn't track for some reason
+	if (!locked || !autocam)
+		return;
+
+	if (cl_chasecam.value) {
+		cmd->forwardmove = cmd->sidemove = cmd->upmove = 0;
+
+		VectorCopy(player->viewangles, cl.viewangles);
+		VectorCopy(player->origin, desired_position);
+		if (memcmp(&desired_position, &self->origin, sizeof(desired_position)) != 0) {
+			MSG_WriteByte (&cls.netchan.message, clc_tmove);
+			MSG_WriteCoord (&cls.netchan.message, desired_position[0]);
+			MSG_WriteCoord (&cls.netchan.message, desired_position[1]);
+			MSG_WriteCoord (&cls.netchan.message, desired_position[2]);
+			// move there locally immediately
+			VectorCopy(desired_position, self->origin);
+		}
+		self->weaponframe = player->weaponframe;
+
+	} else {
+		// Ok, move to our desired position and set our angles to view
+		// the player
+		VectorSubtract(desired_position, self->origin, vec);
+		len = vlen(vec);
+		cmd->forwardmove = cmd->sidemove = cmd->upmove = 0;
+		if (len > 16) { // close enough?
+			MSG_WriteByte (&cls.netchan.message, clc_tmove);
+			MSG_WriteCoord (&cls.netchan.message, desired_position[0]);
+			MSG_WriteCoord (&cls.netchan.message, desired_position[1]);
+			MSG_WriteCoord (&cls.netchan.message, desired_position[2]);
+		}
+
+		// move there locally immediately
+		VectorCopy(desired_position, self->origin);
+										 
+		VectorSubtract(player->origin, desired_position, vec);
+		vectoangles(vec, cl.viewangles);
+		cl.viewangles[0] = -cl.viewangles[0];
+	}
+}
+
+#if 0
+static float adjustang(float current, float ideal, float speed)
+{
+	float move;
+
+	current = anglemod(current);
+	ideal = anglemod(ideal);
+
+	if (current == ideal)
+		return current;
+
+	move = ideal - current;
+	if (ideal > current)
+	{
+		if (move >= 180)
+			move = move - 360;
+	}
+	else
+	{
+		if (move <= -180)
+			move = move + 360;
+	}
+	if (move > 0)
+	{
+		if (move > speed)
+			move = speed;
+	}
+	else
+	{
+		if (move < -speed)
+			move = -speed;
+	}
+
+//Con_Printf("c/i: %4.2f/%4.2f move: %4.2f\n", current, ideal, move);
+	return anglemod (current + move);
+}
+#endif
+
+#if 0
+void Cam_SetView(void)
+{
+	return;
+	player_state_t *player, *self;
+	frame_t *frame;
+	vec3_t vec, vec2;
+
+	if (cls.state != ca_active || !cl.spectator || 
+		!autocam || !locked)
+		return;
+
+	frame = &cl.frames[cls.netchan.incoming_sequence & UPDATE_MASK];
+	player = frame->playerstate + spec_track;
+	self = frame->playerstate + cl.playernum;
+
+	VectorSubtract(player->origin, cl.simorg, vec);
+	if (cam_forceview) {
+		cam_forceview = false;
+		vectoangles(vec, cam_viewangles);
+		cam_viewangles[0] = -cam_viewangles[0];
+	} else {
+		vectoangles(vec, vec2);
+		vec2[PITCH] = -vec2[PITCH];
+
+		cam_viewangles[PITCH] = adjustang(cam_viewangles[PITCH], vec2[PITCH], cl_camera_maxpitch.value);
+		cam_viewangles[YAW] = adjustang(cam_viewangles[YAW], vec2[YAW], cl_camera_maxyaw.value);
+	}
+	VectorCopy(cam_viewangles, cl.viewangles);
+	VectorCopy(cl.viewangles, cl.simangles);
+}
+#endif
+
+void Cam_FinishMove(usercmd_t *cmd)
+{
+	int i;
+	player_info_t	*s;
+	int end;
+
+	if (cls.state != ca_active)
+		return;
+
+	if (!cl.spectator) // only in spectator mode
+		return;
+
+#if 0
+	if (autocam && locked) {
+		frame = &cl.frames[cls.netchan.incoming_sequence & UPDATE_MASK];
+		player = frame->playerstate + spec_track;
+		self = frame->playerstate + cl.playernum;
+
+		VectorSubtract(player->origin, self->origin, vec);
+		if (cam_forceview) {
+			cam_forceview = false;
+			vectoangles(vec, cam_viewangles);
+			cam_viewangles[0] = -cam_viewangles[0];
+		} else {
+			vectoangles(vec, vec2);
+			vec2[PITCH] = -vec2[PITCH];
+
+			cam_viewangles[PITCH] = adjustang(cam_viewangles[PITCH], vec2[PITCH], cl_camera_maxpitch.value);
+			cam_viewangles[YAW] = adjustang(cam_viewangles[YAW], vec2[YAW], cl_camera_maxyaw.value);
+		}
+		VectorCopy(cam_viewangles, cl.viewangles);
+	}
+#endif
+
+	if (cmd->buttons & BUTTON_ATTACK) {
+		if (!(oldbuttons & BUTTON_ATTACK)) {
+
+			oldbuttons |= BUTTON_ATTACK;
+			autocam++;
+
+			if (autocam > CAM_TRACK) {
+				Cam_Unlock();
+				VectorCopy(cl.viewangles, cmd->angles);
+				return;
+			}
+		} else
+			return;
+	} else {
+		oldbuttons &= ~BUTTON_ATTACK;
+		if (!autocam)
+			return;
+	}
+
+	if (autocam && cl_hightrack.value) {
+		Cam_CheckHighTarget();
+		return;
+	}
+
+	if (locked) {
+		if ((cmd->buttons & BUTTON_JUMP) && (oldbuttons & BUTTON_JUMP))
+			return;		// don't pogo stick
+
+		if (!(cmd->buttons & BUTTON_JUMP)) {
+			oldbuttons &= ~BUTTON_JUMP;
+			return;
+		}
+		oldbuttons |= BUTTON_JUMP;	// don't jump again until released
+	}
+
+//	Con_Printf("Selecting track target...\n");
+
+	if (locked && autocam)
+		end = (spec_track + 1) % MAX_CLIENTS;
+	else
+		end = spec_track;
+	i = end;
+	do {
+		s = &cl.players[i];
+		if (s->name[0] && !s->spectator) {
+			Cam_Lock(i);
+			return;
+		}
+		i = (i + 1) % MAX_CLIENTS;
+	} while (i != end);
+	// stay on same guy?
+	i = spec_track;
+	s = &cl.players[i];
+	if (s->name[0] && !s->spectator) {
+		Cam_Lock(i);
+		return;
+	}
+	Con_Printf("No target found ...\n");
+	autocam = locked = false;
+}
+
+void Cam_Reset(void)
+{
+	autocam = CAM_NONE;
+	spec_track = 0;
+}
+
+void CL_InitCam(void)
+{
+	Cvar_RegisterVariable (&cl_hightrack);
+	Cvar_RegisterVariable (&cl_chasecam);
+//	Cvar_RegisterVariable (&cl_camera_maxpitch);
+//	Cvar_RegisterVariable (&cl_camera_maxyaw);
+}
+
+