client.h File Reference

#include "../server.h"
#include <setjmp.h>

Go to the source code of this file.

Classes
struct	mvd_cs_s
struct	mvd_player_t
struct	mvd_client_t
struct	mvd_snap_t
struct	mvd_s

Macros
#define	MVD_Malloc(size)   Z_TagMalloc(size, TAG_MVD)
#define	MVD_Mallocz(size)   Z_TagMallocz(size, TAG_MVD)
#define	MVD_CopyString(s)   Z_TagCopyString(s, TAG_MVD)
#define	FOR_EACH_MVD(mvd)   LIST_FOR_EACH(mvd_t, mvd, &mvd_channel_list, entry)
#define	FOR_EACH_MVDCL(cl, mvd)   LIST_FOR_EACH(mvd_client_t, cl, &(mvd)->clients, entry)
#define	EDICT_MVDCL(ent)   ((mvd_client_t *)((ent)->client))
#define	CS_NUM(c, n)   ((char *)(c) + (n) * MAX_QPATH)
#define	MVD_InfoSet(var, val)   Cvar_FullSet(var, val, CVAR_SERVERINFO | CVAR_GAME, FROM_CODE)
#define	MVD_FEATURES   (GMF_CLIENTNUM | GMF_PROPERINUSE | GMF_WANT_ALL_DISCONNECTS)
#define	LAYOUT_MSEC   3000
#define	FLOOD_SAMPLES   16
#define	FLOOD_MASK   (FLOOD_SAMPLES - 1)
#define	MAX_MVD_NAME   16

Typedefs
typedef struct mvd_cs_s	mvd_cs_t
typedef struct mvd_s	mvd_t

Enumerations
enum	mvd_layout_t {   LAYOUT_NONE, LAYOUT_FOLLOW, LAYOUT_SCORES, LAYOUT_OLDSCORES,   LAYOUT_MENU, LAYOUT_CLIENTS, LAYOUT_CHANNELS }
enum	mvd_state_t { MVD_DEAD, MVD_WAITING, MVD_READING, MVD_NUM_STATES }

Functions
void	MVD_Destroyf (mvd_t *mvd, const char *fmt,...) q_noreturn q_printf(2
void void	MVD_Shutdown (void)
mvd_t *	MVD_SetChannel (int arg)
void	MVD_File_g (genctx_t *ctx)
void	MVD_Spawn (void)
void	MVD_StopRecord (mvd_t *mvd)
void	MVD_StreamedStop_f (void)
void	MVD_StreamedRecord_f (void)
void	MVD_Register (void)
int	MVD_Frame (void)
qboolean	MVD_ParseMessage (mvd_t *mvd)
void	MVD_ParseEntityString (mvd_t *mvd, const char *data)
void	MVD_ClearState (mvd_t *mvd, qboolean full)
void	MVD_SwitchChannel (mvd_client_t *client, mvd_t *mvd)
void	MVD_RemoveClient (client_t *client)
void	MVD_BroadcastPrintf (mvd_t *mvd, int level, int mask, const char *fmt,...) q_printf(4
void void	MVD_PrepWorldFrame (void)
void	MVD_GameClientNameChanged (edict_t *ent, const char *name)
void	MVD_GameClientDrop (edict_t *ent, const char *prefix, const char *reason)
void	MVD_UpdateClients (mvd_t *mvd)
void	MVD_FreePlayer (mvd_player_t *player)
void	MVD_UpdateConfigstring (mvd_t *mvd, int index)
void	MVD_SetPlayerNames (mvd_t *mvd)
void	MVD_LinkEdict (mvd_t *mvd, edict_t *ent)

Variables
list_t	mvd_channel_list
mvd_t	mvd_waitingRoom
qboolean	mvd_dirty
qboolean	mvd_active
unsigned	mvd_last_activity
jmp_buf	mvd_jmpbuf
mvd_client_t *	mvd_clients

Macro Definition Documentation

CS_NUM

#define CS_NUM	(		c,
			n
	)		((char *)(c) + (n) * MAX_QPATH)

Definition at line 33 of file client.h.

EDICT_MVDCL

#define EDICT_MVDCL

(

ent

)

((mvd_client_t *)((ent)->client))

Definition at line 32 of file client.h.

FLOOD_MASK

#define FLOOD_MASK   (FLOOD_SAMPLES - 1)

Definition at line 54 of file client.h.

FLOOD_SAMPLES

#define FLOOD_SAMPLES   16

Definition at line 53 of file client.h.

FOR_EACH_MVD

#define FOR_EACH_MVD

(

mvd

)

LIST_FOR_EACH(mvd_t, mvd, &mvd_channel_list, entry)

Definition at line 26 of file client.h.

FOR_EACH_MVDCL

#define FOR_EACH_MVDCL	(		cl,
			mvd
	)		LIST_FOR_EACH(mvd_client_t, cl, &(mvd)->clients, entry)

Definition at line 29 of file client.h.

LAYOUT_MSEC

#define LAYOUT_MSEC   3000

Definition at line 41 of file client.h.

MAX_MVD_NAME

#define MAX_MVD_NAME   16

Definition at line 105 of file client.h.

MVD_CopyString

#define MVD_CopyString

(

s

)

Z_TagCopyString(s, TAG_MVD)

Definition at line 24 of file client.h.

MVD_FEATURES

#define MVD_FEATURES   (GMF_CLIENTNUM | GMF_PROPERINUSE | GMF_WANT_ALL_DISCONNECTS)

Definition at line 39 of file client.h.

MVD_InfoSet

#define MVD_InfoSet	(		var,
			val
	)		Cvar_FullSet(var, val, CVAR_SERVERINFO | CVAR_GAME, FROM_CODE)

Definition at line 35 of file client.h.

MVD_Malloc

#define MVD_Malloc

(

size

)

Z_TagMalloc(size, TAG_MVD)

Definition at line 22 of file client.h.

MVD_Mallocz

#define MVD_Mallocz

(

size

)

Z_TagMallocz(size, TAG_MVD)

Definition at line 23 of file client.h.

Typedef Documentation

mvd_cs_t

typedef struct mvd_cs_s mvd_cs_t

mvd_t

typedef struct mvd_s mvd_t

Enumeration Type Documentation

mvd_layout_t

enum mvd_layout_t

Enumerator
LAYOUT_NONE
LAYOUT_FOLLOW
LAYOUT_SCORES
LAYOUT_OLDSCORES
LAYOUT_MENU
LAYOUT_CLIENTS
LAYOUT_CHANNELS

Definition at line 43 of file client.h.

             {
    LAYOUT_NONE,        // no layout at all
    LAYOUT_FOLLOW,      // display chase target name
    LAYOUT_SCORES,      // layout of the MVD dummy
    LAYOUT_OLDSCORES,   // saved at intermission time
    LAYOUT_MENU,        // MVD main menu
    LAYOUT_CLIENTS,     // MVD clients list
    LAYOUT_CHANNELS     // MVD channel list
} mvd_layout_t;

mvd_state_t

enum mvd_state_t

Enumerator
MVD_DEAD
MVD_WAITING
MVD_READING
MVD_NUM_STATES

Definition at line 107 of file client.h.

             {
    MVD_DEAD,       // no gamestate received yet, unusable for observers
    MVD_WAITING,    // buffering more frames, stalled
    MVD_READING,    // reading frames
 
    MVD_NUM_STATES
} mvd_state_t;

Function Documentation

MVD_BroadcastPrintf()

void MVD_BroadcastPrintf	(	mvd_t *	mvd,
		int	level,
		int	mask,
		const char *	fmt,
			...
	)

Referenced by gtv_destroy(), gtv_drop(), gtv_wait_start(), gtv_wait_stop(), MVD_Destroyf(), MVD_ParsePrint(), parse_hello(), and parse_stream_data().

MVD_ClearState()

void MVD_ClearState	(	mvd_t *	mvd,
		qboolean	full
	)

Definition at line 856 of file parse.c.

{
    mvd_player_t *player;
    mvd_snap_t *snap, *next;
    int i;
 
    // clear all entities, don't trust num_edicts as it is possible
    // to miscount removed but seen entities
    memset(mvd->edicts, 0, sizeof(mvd->edicts));
    mvd->pool.num_edicts = 0;
 
    // clear all players
    for (i = 0; i < mvd->maxclients; i++) {
        player = &mvd->players[i];
        MVD_FreePlayer(player);
        memset(player, 0, sizeof(*player));
    }
 
    mvd->numplayers = 0;
 
    if (!full)
        return;
 
    // free all snapshots
    LIST_FOR_EACH_SAFE(mvd_snap_t, snap, next, &mvd->snapshots, entry) {
        Z_Free(snap);
    }
 
    List_Init(&mvd->snapshots);
 
    // free current map
    CM_FreeMap(&mvd->cm);
 
    if (mvd->intermission) {
        // save oldscores
        //strcpy(mvd->oldscores, mvd->layout);
    }
 
    memset(mvd->configstrings, 0, sizeof(mvd->configstrings));
    mvd->layout[0] = 0;
 
    mvd->framenum = 0;
    // intermission flag will be cleared in MVD_ChangeLevel
}

Referenced by MVD_ParseServerData(), and MVD_Seek_f().

MVD_Destroyf()

void MVD_Destroyf	(	mvd_t *	mvd,
		const char *	fmt,
			...
	)

MVD_File_g()

void MVD_File_g

(

genctx_t *

ctx

)

Definition at line 2406 of file client.c.

{
    FS_File_g("demos", "*.mvd2;*.mvd2.gz", FS_SEARCH_SAVEPATH | FS_SEARCH_BYFILTER, ctx);
}

Referenced by MVD_Play_c().

MVD_Frame()

int MVD_Frame

(

void

)

Definition at line 406 of file client.c.

{
    gtv_t *gtv, *next;
    int connections = 0;
 
    if (sv.state == ss_broadcast) {
        set_mvd_active();
    }
 
    // run all GTV connections (but not demos)
    LIST_FOR_EACH_SAFE(gtv_t, gtv, next, &mvd_gtv_list, entry) {
        if (setjmp(mvd_jmpbuf)) {
            SZ_Clear(&msg_write);
            continue;
        }
 
        gtv->run(gtv);
 
        connections++;
    }
 
    return connections;
}

Referenced by SV_Frame().

MVD_FreePlayer()

void MVD_FreePlayer

(

mvd_player_t *

player

)

Definition at line 1540 of file game.c.

{
    mvd_cs_t *cs, *next;
 
    for (cs = player->configstrings; cs; cs = next) {
        next = cs->next;
        Z_Free(cs);
    }
    player->configstrings = NULL;
}

Referenced by MVD_ClearState(), and MVD_Free().

MVD_GameClientDrop()

void MVD_GameClientDrop	(	edict_t *	ent,
		const char *	prefix,
		const char *	reason
	)

Definition at line 1934 of file game.c.

{
    mvd_client_t *client = EDICT_MVDCL(ent);
    client_t *cl = client->cl;
 
    if (client->begin_time && MVD_PartFilter(client)) {
        MVD_BroadcastPrintf(client->mvd, PRINT_MEDIUM, UF_MUTE_MISC,
                            "[MVD] %s%s%s\n", cl->name, prefix, reason);
    }
 
    client->begin_time = 0;
}

Referenced by print_drop_reason().

MVD_GameClientNameChanged()

void MVD_GameClientNameChanged	(	edict_t *	ent,
		const char *	name
	)

Definition at line 1922 of file game.c.

{
    mvd_client_t *client = EDICT_MVDCL(ent);
    client_t *cl = client->cl;
 
    if (client->begin_time && MVD_PartFilter(client)) {
        MVD_BroadcastPrintf(client->mvd, PRINT_MEDIUM, UF_MUTE_MISC,
                            "[MVD] %s changed name to %s\n", cl->name, name);
    }
}

Referenced by SV_UserinfoChanged().

MVD_LinkEdict()

void MVD_LinkEdict	(	mvd_t *	mvd,
		edict_t *	ent
	)

Definition at line 1652 of file game.c.

{
    int         index;
    mmodel_t    *cm;
    bsp_t       *cache = mvd->cm.cache;
 
    if (!cache) {
        return;
    }
 
    if (ent->s.solid == PACKED_BSP) {
        index = ent->s.modelindex;
        if (index < 1 || index > cache->nummodels) {
            Com_WPrintf("%s: entity %d: bad inline model index: %d\n",
                        __func__, ent->s.number, index);
            return;
        }
        cm = &cache->models[index - 1];
        VectorCopy(cm->mins, ent->mins);
        VectorCopy(cm->maxs, ent->maxs);
        ent->solid = SOLID_BSP;
    } else if (ent->s.solid) {
        MSG_UnpackSolid16(ent->s.solid, ent->mins, ent->maxs);
        ent->solid = SOLID_BBOX;
    } else {
        VectorClear(ent->mins);
        VectorClear(ent->maxs);
        ent->solid = SOLID_NOT;
    }
 
    SV_LinkEdict(&mvd->cm, ent);
}

Referenced by MVD_ParsePacketEntities(), MVD_PlayerToEntityStates(), and MVD_Seek_f().

MVD_ParseEntityString()

void MVD_ParseEntityString	(	mvd_t *	mvd,
		const char *	data
	)

Definition at line 64 of file parse.c.

{
    const char *p;
    char key[MAX_STRING_CHARS];
    char value[MAX_STRING_CHARS];
    char classname[MAX_QPATH];
    vec3_t origin;
    vec3_t angles;
 
    while (data) {
        p = COM_Parse(&data);
        if (!p[0]) {
            break;
        }
        if (p[0] != '{') {
            Com_Error(ERR_DROP, "expected '{', found '%s'", p);
        }
 
        classname[0] = 0;
        VectorClear(origin);
        VectorClear(angles);
        while (1) {
            p = COM_Parse(&data);
            if (p[0] == '}') {
                break;
            }
            if (p[0] == '{') {
                Com_Error(ERR_DROP, "expected key, found '{'");
            }
 
            Q_strlcpy(key, p, sizeof(key));
 
            p = COM_Parse(&data);
            if (!data) {
                Com_Error(ERR_DROP, "expected key/value pair, found EOF");
            }
            if (p[0] == '}' || p[0] == '{') {
                Com_Error(ERR_DROP, "expected value, found '%s'", p);
            }
 
            if (!strcmp(key, "classname")) {
                Q_strlcpy(classname, p, sizeof(classname));
                continue;
            }
 
            Q_strlcpy(value, p, sizeof(value));
 
            p = value;
            if (!strcmp(key, "origin")) {
                origin[0] = atof(COM_Parse(&p));
                origin[1] = atof(COM_Parse(&p));
                origin[2] = atof(COM_Parse(&p));
            } else if (!strncmp(key, "angle", 5)) {
                if (key[5] == 0) {
                    angles[0] = 0;
                    angles[1] = atof(COM_Parse(&p));
                    angles[2] = 0;
                } else if (key[5] == 's' && key[6] == 0) {
                    angles[0] = atof(COM_Parse(&p));
                    angles[1] = atof(COM_Parse(&p));
                    angles[2] = atof(COM_Parse(&p));
                }
            }
        }
 
        if (!classname[0]) {
            Com_Error(ERR_DROP, "entity with no classname");
        }
 
        if (strncmp(classname, "info_player_", 12)) {
            continue;
        }
 
        if (!strcmp(classname + 12, "intermission")) {
            VectorCopy(origin, mvd->spawnOrigin);
            VectorCopy(angles, mvd->spawnAngles);
            break;
        }
 
        if (!strcmp(classname + 12, "start") ||
            !strcmp(classname + 12, "deathmatch")) {
            VectorCopy(origin, mvd->spawnOrigin);
            VectorCopy(angles, mvd->spawnAngles);
        }
 
    }
}

Referenced by MVD_GameInit(), and MVD_ParseServerData().

MVD_ParseMessage()

qboolean MVD_ParseMessage

(

mvd_t *

mvd

)

Definition at line 1098 of file parse.c.

{
    int     cmd, extrabits;
    qboolean ret = qfalse;
 
#ifdef _DEBUG
    if (mvd_shownet->integer == 1) {
        Com_Printf("%"PRIz" ", msg_read.cursize);
    } else if (mvd_shownet->integer > 1) {
        Com_Printf("------------------\n");
    }
#endif
 
//
// parse the message
//
    match_ended_hack = qfalse;
    while (1) {
        if (msg_read.readcount > msg_read.cursize) {
            MVD_Destroyf(mvd, "Read past end of message");
        }
        if (msg_read.readcount == msg_read.cursize) {
            SHOWNET(1, "%3"PRIz":END OF MESSAGE\n", msg_read.readcount - 1);
            break;
        }
 
        cmd = MSG_ReadByte();
        extrabits = cmd >> SVCMD_BITS;
        cmd &= SVCMD_MASK;
 
#ifdef _DEBUG
        if (mvd_shownet->integer > 1) {
            MVD_ShowSVC(cmd);
        }
#endif
 
        switch (cmd) {
        case mvd_serverdata:
            MVD_ParseServerData(mvd, extrabits);
            ret |= qtrue;
            break;
        case mvd_multicast_all:
        case mvd_multicast_pvs:
        case mvd_multicast_phs:
        case mvd_multicast_all_r:
        case mvd_multicast_pvs_r:
        case mvd_multicast_phs_r:
            MVD_ParseMulticast(mvd, cmd, extrabits);
            break;
        case mvd_unicast:
        case mvd_unicast_r:
            MVD_ParseUnicast(mvd, cmd, extrabits);
            break;
        case mvd_configstring:
            MVD_ParseConfigstring(mvd);
            break;
        case mvd_frame:
            MVD_ParseFrame(mvd);
            break;
        case mvd_sound:
            MVD_ParseSound(mvd, extrabits);
            break;
        case mvd_print:
            MVD_ParsePrint(mvd);
            break;
        case mvd_nop:
            break;
        default:
            MVD_Destroyf(mvd, "Illegible command at %"PRIz": %d",
                         msg_read.readcount - 1, cmd);
        }
    }
 
    return ret;
}

Referenced by demo_play_next(), demo_read_frame(), gtv_read_frame(), MVD_Seek_f(), and parse_stream_data().

MVD_PrepWorldFrame()

void void MVD_PrepWorldFrame

(

void

)

Definition at line 2263 of file game.c.

{
    mvd_t *mvd;
    edict_t *ent;
    int i;
 
    // reset events and old origins
    FOR_EACH_MVD(mvd) {
        for (i = 1; i < mvd->pool.num_edicts; i++) {
            ent = &mvd->edicts[i];
            if (!ent->inuse) {
                continue;
            }
            if (!(ent->s.renderfx & RF_BEAM)) {
                VectorCopy(ent->s.origin, ent->s.old_origin);
            }
            ent->s.event = 0;
        }
    }
}

Referenced by SV_PrepWorldFrame().

MVD_Register()

void MVD_Register

(

void

)

Definition at line 2582 of file client.c.

{
#ifdef _DEBUG
    mvd_shownet = Cvar_Get("mvd_shownet", "0", 0);
#endif
    mvd_timeout = Cvar_Get("mvd_timeout", "90", 0);
    mvd_suspend_time = Cvar_Get("mvd_suspend_time", "5", 0);
    mvd_wait_delay = Cvar_Get("mvd_wait_delay", "20", 0);
    mvd_wait_percent = Cvar_Get("mvd_wait_percent", "35", 0);
    mvd_buffer_size = Cvar_Get("mvd_buffer_size", "3", 0);
    mvd_username = Cvar_Get("mvd_username", "unnamed", 0);
    mvd_password = Cvar_Get("mvd_password", "", CVAR_PRIVATE);
    mvd_snaps = Cvar_Get("mvd_snaps", "10", 0);
 
    Cmd_Register(c_mvd);
}

Referenced by SV_Init().

MVD_RemoveClient()

void MVD_RemoveClient

(

client_t *

client

)

Definition at line 1685 of file game.c.

{
    int index = client - svs.client_pool;
    mvd_client_t *cl = &mvd_clients[index];
 
    List_Remove(&cl->entry);
 
    memset(cl, 0, sizeof(*cl));
    cl->cl = client;
}

Referenced by SV_RemoveClient().

MVD_SetChannel()

mvd_t* MVD_SetChannel

(

int

arg

)

Definition at line 230 of file client.c.

{
    char *s = Cmd_Argv(arg);
    mvd_t *mvd;
    int id;
 
    if (LIST_EMPTY(&mvd_channel_list)) {
        Com_Printf("No active channels.\n");
        return NULL;
    }
 
    if (!*s) {
        if (LIST_SINGLE(&mvd_channel_list)) {
            return LIST_FIRST(mvd_t, &mvd_channel_list, entry);
        }
        Com_Printf("Please specify an exact channel ID.\n");
        return NULL;
    }
 
#if USE_CLIENT
    // special value of @@ returns the channel local client is on
    if (!dedicated->integer && !strcmp(s, "@@")) {
        if ((mvd = find_local_channel()) != NULL) {
            return mvd;
        }
    } else
#endif
        if (COM_IsUint(s)) {
            id = atoi(s);
            FOR_EACH_MVD(mvd) {
                if (mvd->id == id) {
                    return mvd;
                }
            }
        } else {
            FOR_EACH_MVD(mvd) {
                if (!strcmp(mvd->name, s)) {
                    return mvd;
                }
            }
        }
 
    Com_Printf("No such channel ID: %s\n", s);
    return NULL;
}

Referenced by MVD_Control_f(), MVD_Join_f(), MVD_Kill_f(), MVD_Pause_f(), MVD_Play_f(), MVD_Seek_f(), MVD_Skip_f(), MVD_StreamedRecord_f(), and MVD_StreamedStop_f().

MVD_SetPlayerNames()

void MVD_SetPlayerNames

(

mvd_t *

mvd

)

Definition at line 1607 of file game.c.

{
    int i;
 
    for (i = 0; i < mvd->maxclients; i++) {
        set_player_name(mvd, i);
    }
}

Referenced by MVD_ParseServerData(), and MVD_Seek_f().

MVD_Shutdown()

void void MVD_Shutdown

(

void

)

Definition at line 2528 of file client.c.

{
    gtv_t *gtv, *gtv_next;
    mvd_t *mvd, *mvd_next;
 
    // kill all GTV connections
    LIST_FOR_EACH_SAFE(gtv_t, gtv, gtv_next, &mvd_gtv_list, entry) {
        gtv->destroy(gtv);
    }
 
    // kill all MVD channels (including demo GTVs)
    LIST_FOR_EACH_SAFE(mvd_t, mvd, mvd_next, &mvd_channel_list, entry) {
        if (mvd->gtv) {
            mvd->gtv->mvd = NULL; // don't double destroy
            mvd->gtv->destroy(mvd->gtv);
        }
        MVD_Free(mvd);
    }
 
    List_Init(&mvd_gtv_list);
    List_Init(&mvd_channel_list);
 
    Z_Free(mvd_clients);
    mvd_clients = NULL;
 
    mvd_chanid = 0;
 
    mvd_active = qfalse;
 
    Z_LeakTest(TAG_MVD);
}

Referenced by MVD_GameShutdown(), and SV_Shutdown().

MVD_Spawn()

void MVD_Spawn

(

void

)

Definition at line 1653 of file client.c.

{
    Cvar_SetInteger(sv_running, ss_broadcast, FROM_CODE);
    Cvar_Set("sv_paused", "0");
    Cvar_Set("timedemo", "0");
    SV_InfoSet("port", net_port->string);
 
#if USE_SYSCON
    SV_SetConsoleTitle();
#endif
 
    // generate spawncount for Waiting Room
    sv.spawncount = (rand() | (rand() << 16)) ^ Sys_Milliseconds();
    sv.spawncount &= 0x7FFFFFFF;
 
#if USE_FPS
    // just fixed base FPS
    sv.framerate = BASE_FRAMERATE;
    sv.frametime = BASE_FRAMETIME;
    sv.framediv = 1;
#endif
 
    // set externally visible server name
    Q_strlcpy(sv.name, mvd_waitingRoom.mapname, sizeof(sv.name));
 
    sv.state = ss_broadcast;
 
    // start as inactive
    mvd_last_activity = INT_MIN;
    set_mvd_active();
}

Referenced by MVD_ChangeLevel(), MVD_Spawn_f(), and parse_hello().

MVD_StopRecord()

void MVD_StopRecord

(

mvd_t *

mvd

)

Definition at line 125 of file client.c.

{
    uint16_t msglen;
 
    msglen = 0;
    FS_Write(&msglen, 2, mvd->demorecording);
 
    FS_FCloseFile(mvd->demorecording);
    mvd->demorecording = 0;
 
    Z_Free(mvd->demoname);
    mvd->demoname = NULL;
}

Referenced by MVD_Free(), MVD_StreamedRecord_f(), MVD_StreamedStop_f(), and MVD_WriteDemoMessage().

MVD_StreamedRecord_f()

void MVD_StreamedRecord_f

(

void

)

Definition at line 1896 of file client.c.

{
    char buffer[MAX_OSPATH];
    qhandle_t f;
    mvd_t *mvd;
    uint32_t magic;
    uint16_t msglen;
    unsigned mode = FS_MODE_WRITE;
    ssize_t ret;
    int c;
 
    while ((c = Cmd_ParseOptions(o_record)) != -1) {
        switch (c) {
        case 'h':
            Cmd_PrintUsage(o_record, "<filename> [chanid]");
            Com_Printf("Begin MVD recording on the specified channel.\n");
            Cmd_PrintHelp(o_record);
            return;
        case 'z':
            mode |= FS_FLAG_GZIP;
            break;
        default:
            return;
        }
    }
 
    if (!cmd_optarg[0]) {
        Com_Printf("Missing filename argument.\n");
        Cmd_PrintHint();
        return;
    }
 
    if ((mvd = MVD_SetChannel(cmd_optind + 1)) == NULL) {
        Cmd_PrintHint();
        return;
    }
 
    if (mvd->demorecording) {
        Com_Printf("[%s] Already recording into %s.\n",
                   mvd->name, mvd->demoname);
        return;
    }
 
    //
    // open the demo file
    //
    f = FS_EasyOpenFile(buffer, sizeof(buffer), mode,
                        "demos/", cmd_optarg, ".mvd2");
    if (!f) {
        return;
    }
 
    Com_Printf("[%s] Recording into %s\n", mvd->name, buffer);
 
    mvd->demorecording = f;
    mvd->demoname = MVD_CopyString(buffer);
 
    emit_gamestate(mvd);
 
    // write magic
    magic = MVD_MAGIC;
    ret = FS_Write(&magic, 4, f);
    if (ret != 4)
        goto fail;
 
    // write gamestate
    msglen = LittleShort(msg_write.cursize);
    ret = FS_Write(&msglen, 2, f);
    if (ret != 2)
        goto fail;
    ret = FS_Write(msg_write.data, msg_write.cursize, f);
    if (ret != msg_write.cursize)
        goto fail;
 
    SZ_Clear(&msg_write);
    return;
 
fail:
    SZ_Clear(&msg_write);
    Com_EPrintf("[%s] Couldn't write demo: %s\n", mvd->name, Q_ErrorString(ret));
    MVD_StopRecord(mvd);
}

MVD_StreamedStop_f()

void MVD_StreamedStop_f

(

void

)

Definition at line 1778 of file client.c.

{
    mvd_t *mvd;
 
    mvd = MVD_SetChannel(1);
    if (!mvd) {
        Com_Printf("Usage: %s [chanid]\n", Cmd_Argv(0));
        return;
    }
 
    if (!mvd->demorecording) {
        Com_Printf("[%s] Not recording a demo.\n", mvd->name);
        return;
    }
 
    MVD_StopRecord(mvd);
 
    Com_Printf("[%s] Stopped recording.\n", mvd->name);
}

MVD_SwitchChannel()

void MVD_SwitchChannel	(	mvd_client_t *	client,
		mvd_t *	mvd
	)

Definition at line 765 of file game.c.

{
    client_t *cl = client->cl;
 
    List_Remove(&client->entry);
    List_SeqAdd(&mvd->clients, &client->entry);
    client->mvd = mvd;
    client->begin_time = 0;
    client->target = NULL;
    client->oldtarget = NULL;
    client->chase_mask = 0;
    client->chase_auto = 0;
    client->chase_wait = 0;
    memset(client->chase_bitmap, 0, sizeof(client->chase_bitmap));
    MVD_SetServerState(cl, mvd);
 
    // needs to reconnect
    MSG_WriteByte(svc_stufftext);
    MSG_WriteString(va("changing map=%s; reconnect\n", mvd->mapname));
    SV_ClientReset(cl);
    SV_ClientAddMessage(cl, MSG_RELIABLE | MSG_CLEAR);
}

Referenced by MVD_Destroy(), and MVD_TrySwitchChannel().

MVD_UpdateClients()

void MVD_UpdateClients

(

mvd_t *

mvd

)

Definition at line 2175 of file game.c.

{
    mvd_client_t *client;
 
    // check for intermission
    if (mvd_freeze_hack->integer && mvd->dummy) {
        if (!mvd->intermission) {
            if (mvd->dummy->ps.pmove.pm_type == PM_FREEZE) {
                MVD_IntermissionStart(mvd);
            }
        } else if (mvd->dummy->ps.pmove.pm_type != PM_FREEZE) {
            MVD_IntermissionStop(mvd);
        }
    } else if (mvd->intermission) {
        MVD_IntermissionStop(mvd);
    }
 
    // update UDP clients
    FOR_EACH_MVDCL(client, mvd) {
        if (client->cl->state == cs_spawned) {
            MVD_UpdateTarget(client);
            MVD_UpdateClient(client);
            MVD_NotifyClient(client);
        }
    }
}

Referenced by MVD_ParseFrame(), and MVD_Seek_f().

MVD_UpdateConfigstring()

void MVD_UpdateConfigstring	(	mvd_t *	mvd,
		int	index
	)

Definition at line 1616 of file game.c.

{
    char *s = mvd->configstrings[index];
    mvd_client_t *client;
 
    if (index >= CS_PLAYERSKINS && index < CS_PLAYERSKINS + mvd->maxclients) {
        // update player name
        update_player_name(mvd, index - CS_PLAYERSKINS);
    } else if (index >= CS_GENERAL) {
        // reset unicast versions of this string
        reset_unicast_strings(mvd, index);
    }
 
    MSG_WriteByte(svc_configstring);
    MSG_WriteShort(index);
    MSG_WriteString(s);
 
    // broadcast configstring change
    FOR_EACH_MVDCL(client, mvd) {
        if (client->cl->state < cs_primed) {
            continue;
        }
        SV_ClientAddMessage(client->cl, MSG_RELIABLE);
    }
 
    SZ_Clear(&msg_write);
}

Referenced by MVD_ParseConfigstring(), and MVD_Seek_f().

Variable Documentation

mvd_active

qboolean mvd_active

Definition at line 105 of file client.c.

Referenced by check_timeouts(), MVD_LayoutChannels(), MVD_Shutdown(), and set_mvd_active().

mvd_channel_list

list_t mvd_channel_list

Referenced by MVD_GameClientConnect(), MVD_GameRunFrame(), MVD_Invuse_f(), MVD_LayoutChannels(), MVD_LayoutMenu(), MVD_ListChannels_f(), MVD_SetChannel(), and MVD_Shutdown().

mvd_clients

mvd_client_t* mvd_clients

Definition at line 37 of file game.c.

Referenced by MVD_GameInit(), MVD_RemoveClient(), and MVD_Shutdown().

mvd_dirty

qboolean mvd_dirty

Definition at line 102 of file client.c.

Referenced by MVD_ChangeLevel(), MVD_Destroy(), MVD_GameClientBegin(), MVD_GameRunFrame(), MVD_UpdateLayouts(), and set_mvd_active().

mvd_jmpbuf

jmp_buf mvd_jmpbuf

Definition at line 108 of file client.c.

Referenced by MVD_Destroyf(), MVD_Frame(), MVD_GameRunFrame(), MVD_Play_f(), MVD_Seek_f(), and q_printf().

mvd_last_activity

unsigned mvd_last_activity

Definition at line 106 of file client.c.

Referenced by MVD_GameClientCommand(), MVD_GameClientConnect(), MVD_GameClientThink(), MVD_Spawn(), MVD_UpdateClient(), and set_mvd_active().

mvd_waitingRoom

mvd_t mvd_waitingRoom

Definition at line 101 of file client.c.

Referenced by MVD_Destroy(), MVD_GameClientBegin(), MVD_GameClientCommand(), MVD_GameClientConnect(), MVD_GameInit(), MVD_GameRunFrame(), MVD_Invuse_f(), MVD_SetDefaultLayout(), MVD_Spawn(), and MVD_TrySwitchChannel().