/* cl_demo.c @description@ 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 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: Free Software Foundation, Inc. 59 Temple Place - Suite 330 Boston, MA 02111-1307, USA */ #ifdef HAVE_CONFIG_H # include "config.h" #endif static __attribute__ ((used)) const char rcsid[] = "$Id$"; #ifdef HAVE_STRING_H # include #endif #ifdef HAVE_STRINGS_H # include #endif #include "QF/cmd.h" #include "QF/cvar.h" #include "QF/dstring.h" #include "QF/keys.h" #include "QF/msg.h" #include "QF/qendian.h" #include "QF/sys.h" #include "QF/va.h" #include "client.h" #include "compat.h" #include "host.h" typedef struct { int frames; double time; double fps; } td_stats_t; char demoname[1024]; int timedemo_count; int timedemo_runs; td_stats_t *timedemo_data; static void CL_FinishTimeDemo (void); cvar_t *demo_gzip; cvar_t *demo_speed; cvar_t *demo_quit; /* DEMO CODE When a demo is playing back, all NET_SendMessages are skipped, and NET_GetMessages are read from the demo file. Whenever cl.time gets past the last received message, another message is read from the demo file. */ /* CL_WriteDemoMessage Dumps the current net message, prefixed by the length and view angles */ static void CL_WriteDemoMessage (void) { int len; int i; float f; len = LittleLong (net_message->message->cursize); Qwrite (cls.demofile, &len, 4); for (i = 0; i < 3; i++) { f = LittleFloat (cl.viewangles[i]); Qwrite (cls.demofile, &f, 4); } Qwrite (cls.demofile, net_message->message->data, net_message->message->cursize); Qflush (cls.demofile); } /* CL_StopPlayback Called when a demo file runs out, or the user starts a game */ void CL_StopPlayback (void) { if (!cls.demoplayback) return; Qclose (cls.demofile); cls.demoplayback = false; cls.demofile = NULL; CL_SetState (ca_disconnected); if (cls.timedemo) CL_FinishTimeDemo (); } void CL_StopRecording (void) { // write a disconnect message to the demo file SZ_Clear (net_message->message); MSG_WriteByte (net_message->message, svc_disconnect); CL_WriteDemoMessage (); // finish up Qclose (cls.demofile); cls.demofile = NULL; cls.demorecording = false; Sys_Printf ("Completed demo\n"); } /* CL_GetMessage Handles recording and playback of demos, on top of NET_ code */ int CL_GetMessage (void) { int r, i; float f; if (cls.demoplayback) { // decide if it is time to grab the next message if (cls.signon == SIGNONS) { // always grab until fully connected if (cls.timedemo) { if (host_framecount == cls.td_lastframe) return 0; // already read this frame's message cls.td_lastframe = host_framecount; // if this is the second frame, grab the real td_starttime // so the bogus time on the first frame doesn't count if (host_framecount == cls.td_startframe + 1) cls.td_starttime = realtime; } else if ( /* cl.time > 0 && */ cl.time <= cl.mtime[0]) { return 0; // don't need another message yet } } // get the next message Qread (cls.demofile, &net_message->message->cursize, 4); VectorCopy (cl.mviewangles[0], cl.mviewangles[1]); for (i = 0; i < 3; i++) { r = Qread (cls.demofile, &f, 4); cl.mviewangles[0][i] = LittleFloat (f); } net_message->message->cursize = LittleLong (net_message->message->cursize); if (net_message->message->cursize > MAX_MSGLEN) Sys_Error ("Demo message > MAX_MSGLEN"); r = Qread (cls.demofile, net_message->message->data, net_message->message->cursize); if (r != net_message->message->cursize) { CL_StopPlayback (); return 0; } return 1; } while (1) { r = NET_GetMessage (cls.netcon); if (r != 1 && r != 2) return r; // discard nop keepalive message if (net_message->message->cursize == 1 && net_message->message->data[0] == svc_nop) Sys_Printf ("<-- server to client keepalive\n"); else break; } if (cls.demorecording) CL_WriteDemoMessage (); return r; } /* CL_Stop_f stop recording a demo */ static void CL_Stop_f (void) { if (cmd_source != src_command) return; if (!cls.demorecording) { Sys_Printf ("Not recording a demo.\n"); return; } CL_StopRecording (); } /* CL_Record_f record [cd track] */ static void CL_Record_f (void) { int c; dstring_t *name; int track; if (cmd_source != src_command) return; c = Cmd_Argc (); if (c != 2 && c != 3 && c != 4) { Sys_Printf ("record [ [cd track]]\n"); return; } if (strstr (Cmd_Argv (1), "..")) { Sys_Printf ("Relative pathnames are not allowed.\n"); return; } if (c == 2 && cls.state == ca_connected) { Sys_Printf ("Can not record - already connected to server\nClient demo recording must be started before connecting\n"); return; } // write the forced cd track number, or -1 if (c == 4) { track = atoi (Cmd_Argv (3)); Sys_Printf ("Forcing CD track to %i\n", cls.forcetrack); } else track = -1; name = dstring_new (); dsprintf (name, "%s/%s", qfs_gamedir->dir.def, Cmd_Argv (1)); // start the map up // if (c > 2) Cmd_ExecuteString (va ("map %s", Cmd_Argv (2)), src_command); // open the demo file // #ifdef HAVE_ZLIB if (demo_gzip->int_val) { QFS_DefaultExtension (name, ".dem.gz"); cls.demofile = QFS_WOpen (name->str, demo_gzip->int_val); } else #endif { QFS_DefaultExtension (name, ".dem"); cls.demofile = QFS_WOpen (name->str, 0); } if (!cls.demofile) { Sys_Printf ("ERROR: couldn't open.\n"); } else { Sys_Printf ("recording to %s.\n", name->str); cls.demorecording = true; cls.forcetrack = track; Qprintf (cls.demofile, "%i\n", cls.forcetrack); } dstring_delete (name); } static void CL_StartDemo (void) { dstring_t *name; int c; qboolean neg = false; // disconnect from server // CL_Disconnect (); // open the demo file // name = dstring_strdup (demoname); QFS_DefaultExtension (name, ".dem"); Sys_Printf ("Playing demo from %s.\n", name->str); QFS_FOpenFile (name->str, &cls.demofile); dstring_delete (name); if (!cls.demofile) { Sys_Printf ("ERROR: couldn't open.\n"); cls.demonum = -1; // stop demo loop return; } cls.demoplayback = true; CL_SetState (ca_connected); cls.forcetrack = 0; key_dest = key_game; game_target = IMT_0; while ((c = Qgetc (cls.demofile)) != '\n') if (c == '-') neg = true; else cls.forcetrack = cls.forcetrack * 10 + (c - '0'); if (neg) cls.forcetrack = -cls.forcetrack; } /* CL_PlayDemo_f play [demoname] */ static void CL_PlayDemo_f (void) { if (cmd_source != src_command) return; if (Cmd_Argc () != 2) { Sys_Printf ("play : plays a demo\n"); return; } timedemo_runs = timedemo_count = 1; // make sure looped timedemos stop strncpy (demoname, Cmd_Argv (1), sizeof (demoname)); CL_StartDemo (); } static void CL_StartTimeDemo (void) { CL_StartDemo (); // cls.td_starttime will be grabbed at the second frame of the demo, so // all the loading time doesn't get counted cls.timedemo = true; cls.td_starttime = 0; cls.td_startframe = host_framecount; cls.td_lastframe = -1; // get a new message this frame } static inline double sqr (double x) { return x * x; } static void CL_FinishTimeDemo (void) { int frames; float time; cls.timedemo = false; // the first frame didn't count frames = (host_framecount - cls.td_startframe) - 1; time = realtime - cls.td_starttime; if (!time) time = 1; Sys_Printf ("%i frame%s %.4g seconds %.4g fps\n", frames, frames == 1 ? "" : "s", time, frames / time); timedemo_count--; if (timedemo_data) { timedemo_data[timedemo_count].frames = frames; timedemo_data[timedemo_count].time = time; timedemo_data[timedemo_count].fps = frames / time; } if (timedemo_count > 0) { CL_StartTimeDemo (); } else { if (--timedemo_runs > 0 && timedemo_data) { double average = 0; double variance = 0; double min, max; int i; min = max = timedemo_data[0].fps; for (i = 0; i < timedemo_runs; i++) { average += timedemo_data[i].fps; min = min (min, timedemo_data[i].fps); max = max (max, timedemo_data[i].fps); } average /= timedemo_runs; for (i = 0; i < timedemo_runs; i++) variance += sqr (timedemo_data[i].fps - average); variance /= timedemo_runs; Sys_Printf ("timedemo stats for %d runs:\n", timedemo_runs); Sys_Printf (" average fps: %.3f\n", average); Sys_Printf (" min/max fps: %.3f/%.3f\n", min, max); Sys_Printf ("std deviation: %.3f fps\n", sqrt (variance)); } if (demo_quit->int_val) Cbuf_InsertText (host_cbuf, "quit\n"); } } /* CL_TimeDemo_f timedemo [demoname] */ static void CL_TimeDemo_f (void) { int count = 1; if (cmd_source != src_command) return; if (Cmd_Argc () < 2 || Cmd_Argc () > 3) { Sys_Printf ("timedemo [count]: gets demo speeds\n"); return; } timedemo_runs = timedemo_count = 1; // make sure looped timedemos stop if (Cmd_Argc () == 3) count = atoi (Cmd_Argv (2)); timedemo_runs = timedemo_count = 1; if (timedemo_data) { free (timedemo_data); timedemo_data = 0; } strncpy (demoname, Cmd_Argv (1), sizeof (demoname)); CL_StartTimeDemo (); timedemo_runs = timedemo_count = max (count, 1); timedemo_data = calloc (timedemo_runs, sizeof (td_stats_t)); } void CL_Demo_Init (void) { demo_gzip = Cvar_Get ("demo_gzip", "0", CVAR_ARCHIVE, NULL, "Compress demos using gzip. 0 = none, 1 = least " "compression, 9 = most compression. Compressed " " demos (1-9) will have .gz appended to the name"); demo_speed = Cvar_Get ("demo_speed", "1.0", CVAR_NONE, NULL, "adjust demo playback speed. 1.0 = normal, " "< 1 slow-mo, > 1 timelapse"); demo_quit = Cvar_Get ("demo_quit", "0", CVAR_NONE, NULL, "automaticly quit after a timedemo has finished"); Cmd_AddCommand ("record", CL_Record_f, "No Description"); Cmd_AddCommand ("stop", CL_Stop_f, "No Description"); Cmd_AddCommand ("playdemo", CL_PlayDemo_f, "No Description"); Cmd_AddCommand ("timedemo", CL_TimeDemo_f, "No Description"); }