fteqw/engine/client/client.h

/*
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 the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

*/
// client.h

#include "../common/particles.h"

enum
{
	SKIN_NOTLOADED,	//not trying to load it. shouldn't really happen, but can.
	SKIN_LOADING,	//still loading. just do something else for now...
	SKIN_LOADED,
	SKIN_FAILED
};
typedef struct qwskin_s
{
	char		name[64];
	int			loadstate;		// the name isn't a valid skin

	//qw skin info
	int			width;
	int			height;
	void		*skindata;

	//for hardware 32bit texture overrides
	texnums_t	textures;
} qwskin_t;

// player_state_t is the information needed by a player entity
// to do move prediction and to generate a drawable entity
typedef struct
{
	int			messagenum;		// all player's won't be updated each frame

	double		state_time;		// not the same as the packet time,
								// because player commands come asyncronously

	usercmd_t	command;		// last command for prediction

	vec3_t		origin;
	vec3_t		predorigin;		// pre-predicted pos for other players (allowing us to just lerp when active)
	vec3_t		viewangles;		// only for demos, not from server
	vec3_t		velocity;
	int			weaponframe;

	unsigned int			modelindex;
	int			frame;
	int			skinnum;
	int			effects;

#ifdef PEXT_SCALE
	float scale;
#endif
	qbyte colourmod[3];
	qbyte alpha;
#ifdef PEXT_FATNESS
	float fatness;
#endif

	int			flags;			// dead, gib, etc

	int			pm_type;

	vec3_t		szmins, szmaxs;

	//maybe-propagated... use the networked value if available.
	float		waterjumptime;	//never networked...
	qboolean	onground;	//networked with Z_EXT_PF_ONGROUND||replacementdeltas
	qboolean	jump_held;	//networked with Z_EXT_PM_TYPE
	int			jump_msec;	// hack for fixing bunny-hop flickering on non-ZQuake servers
	vec3_t		gravitydir;	//networked with replacementdeltas
} player_state_t;


#if defined(Q2CLIENT) || defined(Q2SERVER)
typedef enum
{
	// can accelerate and turn
	Q2PM_NORMAL,
	Q2PM_SPECTATOR,
	// no acceleration or turning
	Q2PM_DEAD,
	Q2PM_GIB,		// different bounding box
	Q2PM_FREEZE
} q2pmtype_t;
enum
{	//urgh.
	// can accelerate and turn
	Q2EPM_NORMAL,
	Q2EPM_GRAPPLE,
	Q2EPM_SPECTATOR,
	Q2EPM_SPECTATOR2,
	// no acceleration or turning
	Q2EPM_DEAD,
	Q2EPM_GIB,		// different bounding box
	Q2EPM_FREEZE
};
typedef struct
{	//shared with q2 dll

	q2pmtype_t	pm_type;

	short		origin[3];		// 13.3
	short		velocity[3];	// 13.3
	qbyte		pm_flags;		// ducked, jump_held, etc
	qbyte		pm_time;		// each unit = 8 ms
	short		gravity;
	short		delta_angles[3];	// add to command angles to get view direction
									// changed by spawns, rotating objects, and teleporters
//	short		pad;
} q2pmove_state_t;

typedef struct
{	//shared with q2 dll so cannot be changed

	q2pmove_state_t	pmove;		// for prediction

	// these fields do not need to be communicated bit-precise

	vec3_t		viewangles;		// for fixed views
	vec3_t		viewoffset;		// add to pmovestate->origin
	vec3_t		kick_angles;	// add to view direction to get render angles
								// set by weapon kicks, pain effects, etc

	vec3_t		gunangles;
	vec3_t		gunoffset;
	int			gunindex;
	int			gunframe;

	float		blend[4];		// rgba full screen effect

	float		fov;			// horizontal field of view

	int			rdflags;		// refdef flags

	short		stats[Q2MAX_STATS];		// fast status bar updates
} q2player_state_t;
#endif

typedef struct colourised_s {
	char name[64];
	unsigned int topcolour;
	unsigned int bottomcolour;
	char skin[64];
	struct colourised_s *next;
} colourised_t;

#define	MAX_SCOREBOARDNAME	64
#define MAX_DISPLAYEDNAME	16
typedef struct player_info_s
{
	int			userid;
	infobuf_t	userinfo;
	qboolean	userinfovalid;	//set if we actually know the userinfo (ie: false on vanilla nq servers)
	char		teamstatus[128];
	float		teamstatustime;

	// scoreboard information
	int		spectator;
	char	name[MAX_SCOREBOARDNAME];
	char	team[MAX_INFO_KEY];
	float	realentertime;	//pegged against realtime, to cope with potentially not knowing the server's time when we first receive this message
	int		frags;
	int		ping;
	qbyte	pl;
	char	ruleset[19]; //has colour markup to say if its accepted or not

	char	ip[128];

	struct
	{
		float time;	//invalid if too old.
		int health;
		int armour;
		unsigned int items;
		vec3_t org;
		char nick[8];	//kinda short, yes.
	} tinfo;

	qboolean ignored;
	qboolean vignored;
	unsigned int chatstate;

	// skin information
	unsigned int		rtopcolor;	//real, according to their userinfo
	unsigned int		rbottomcolor;

#ifdef QWSKINS
	colourised_t *colourised;

	qwskin_t	*qwskin;
	qwskin_t	*lastskin;	//last-known-good skin

	unsigned int		ttopcolor;	//team, according to colour forcing
	unsigned int		tbottomcolor;

	struct model_s	*model;
	#define dtopcolor ttopcolor
	#define dbottomcolor tbottomcolor
#else
	#define dtopcolor rtopcolor
	#define dbottomcolor rbottomcolor
#endif
	skinid_t	skinid;

//	unsigned short vweapindex;
#ifdef HEXEN2
	unsigned char h2playerclass;
#endif

	int prevcount;

#ifdef QUAKEHUD	
	struct wstats_s 
	{
		char wname[16];
		unsigned int hit;
		unsigned int total;
	} weaponstats[16];
#endif

	int stats[MAX_CL_STATS];
	float statsf[MAX_CL_STATS];
} player_info_t;


typedef struct
{
	double		senttime;			// time cmd was sent off
	float		latency;			// the time the packet was acked. -1=choked, -2=dropped, -3=never sent, -4=reply came back invalid

	// generated on client side
	usercmd_t	cmd[MAX_SPLITS];	// cmd that generated the frame
	int			cmd_sequence;		//the outgoing move sequence. if not equal to expected, that index was stale and is no longer valid
	int			server_message_num;	//the inbound frame that was valid when this command was generated

	int server_time;
	int client_time;
	float sentgametime;	//nq timings are based upon server time echos.
} outframe_t;

typedef struct
{
	// received from server
	int			frameid;		//the sequence number of the frame, so we can easily detect which frames are valid without poking all in advance, etc
	int			ackframe;		//the outgoing sequence this frame acked (for prediction backlerping).
	double		receivedtime;	// time message was received, or -1
	player_state_t	playerstate[MAX_CLIENTS+MAX_SPLITS];	// message received that reflects performing
								// the usercmd
	packet_entities_t	packet_entities;
	qboolean	invalid;		// true if the packet_entities delta was invalid
} inframe_t;

#ifdef Q2CLIENT
typedef struct
{
	qboolean		valid;			// cleared if delta parsing was invalid
	int				serverframe;
	int				servertime;		// server time the message is valid for (in msec)
	int				deltaframe;
	struct {
		qbyte				areabits[MAX_Q2MAP_AREAS/8];		// portalarea visibility bits
		q2player_state_t	playerstate;
		int					clientnum;
	} seat[MAX_SPLITS];
	int				num_entities;
	int				parse_entities;	// non-masked index into cl_parse_entities array
} q2frame_t;
#endif

typedef struct
{
	int		destcolor[3];
	float		percent;		// 0-256
} cshift_t;

#define	CSHIFT_CONTENTS	0
#define	CSHIFT_DAMAGE	1
#define	CSHIFT_BONUS	2
#define	CSHIFT_POWERUP	3
#define CSHIFT_SERVER	4
#define	NUM_CSHIFTS		5


//
// client_state_t should hold all pieces of the client state
//
//the light array works thusly:
//dlights are allocated DL_LAST downwards to 0, static wlights are allocated DL_LAST+1 to MAX_RTLIGHTS.
//thus to clear the dlights but not rtlights, set the first light to RTL_FIRST
#define dlightbitmask_t		size_t
#define DL_LAST				(sizeof(dlightbitmask_t)*8-1)
#define RTL_FIRST			(sizeof(dlightbitmask_t)*8)

#define LFLAG_NORMALMODE	(1<<0) /*ppl with r_shadow_realtime_dlight*/
#define LFLAG_REALTIMEMODE	(1<<1) /*ppl with r_shadow_realtime_world*/
#define LFLAG_LIGHTMAP		(1<<2)
#define LFLAG_FLASHBLEND	(1<<3)

#define LFLAG_NOSHADOWS		(1<<8)
#define LFLAG_SHADOWMAP		(1<<9)
#define LFLAG_CREPUSCULAR	(1<<10)	//weird type of sun light that gives god rays
#define LFLAG_ORTHO			(1<<11)	//sun-style -light
#define LFLAG_FORCECACHE	(1<<12)	//shadowmap/surfaces should be cached from one frame to the next.

#define LFLAG_INTERNAL		(LFLAG_LIGHTMAP|LFLAG_FLASHBLEND|LFLAG_FORCECACHE)	//these are internal to FTE, and never written to disk (ie: .rtlights files shouldn't contain these)
#define LFLAG_DYNAMIC (LFLAG_LIGHTMAP | LFLAG_FLASHBLEND | LFLAG_NORMALMODE)

typedef struct dlight_s
{
	int		key;				// so entities can reuse same entry
	vec3_t	origin;
	vec3_t	axis[3];
	vec3_t	angles;				//used only for reflection, to avoid things getting rounded/cycled.
	vec3_t	rotation;			//cubemap/spotlight rotation
	float	radius;
	float	die;				// stop lighting after this time
	float	decay;				// drop this each second
	float	minlight;			// don't add when contributing less
	float   color[3];
	float	channelfade[3];
#ifdef RTLIGHTS
	vec3_t lightcolourscales; //ambient, diffuse, specular
#endif
	float	corona;
	float	coronascale;
	float	fade[2];

	unsigned int flags;
	char	cubemapname[MAX_QPATH];
	char	*customstyle;

	int coronaocclusionquery;
	unsigned int coronaocclusionresult;

	//the following are used for rendering (client code should clear on create)
	qboolean rebuildcache;
	struct	shadowmesh_s *worldshadowmesh;
	texid_t cubetexture;
	struct {
		float updatetime;
	} face [6];
	int style;	//multiply by style values if >= 0 && < MAX_LIGHTSTYLES
	float	fov; //spotlight
	float	nearclip; //for spotlights...
	struct dlight_s *next;
} dlight_t;

typedef struct
{
	int		length;
	char	map[MAX_STYLESTRING];
	vec3_t	colours;
	int		colourkey;	//compacted version of the colours, for comparison against caches
} lightstyle_t;

#define	MAX_DEMOS		8
#define	MAX_DEMONAME	16

typedef enum {
ca_disconnected, 	// full screen console with no connection
ca_demostart,		// starting up a demo
ca_connected,		// netchan_t established, waiting for svc_serverdata
ca_onserver,		// processing data lists, donwloading, etc
ca_active			// everything is in, so frames can be rendered
} cactive_t;

typedef enum {
	dl_none,
	dl_model,
	dl_sound,
	dl_skin,
	dl_wad,
	dl_single,
	dl_singlestuffed
} dltype_t;		// download type

typedef struct qdownload_s
{
	enum {DL_QW, DL_QWCHUNKS, DL_Q3, DL_DARKPLACES, DL_QWPENDING, DL_HTTP, DL_FTP} method;
	vfsfile_t		*file;		// file transfer from server
	char			dclname[MAX_OSPATH];	//file to read/write the chunklist from, for download resumption.
	char			tempname[MAX_OSPATH];	//file its currently writing to.
	char			localname[MAX_OSPATH];	//file its going to be renamed to.
	int				prefixbytes;			//number of bytes that prefix the above names (ie: package/ or nothing).
	char			remotename[MAX_OSPATH];	//file its coming from.
	float			percent;				//for progress indicator.
	float			starttime;				//for speed info
	qofs_t			completedbytes;			//number of bytes downloaded, for progress/speed info
	qofs_t			size;					//total size (may be a guess)
	qboolean		sizeunknown;			//says that size is a guess
	unsigned int	filesequence;			//unique file id.
	enum fs_relative fsroot;				//where the local+temp file is meant to be relative to.

	double			ratetime;				//periodically updated
	int				rate;					//ratebytes/ratetimedelta
	int				ratebytes;				//updated by download reception code, and cleared when ratetime is bumped
	unsigned int	flags;

	//chunked downloads uses this
	struct dlblock_s
	{
		qofs_t start;
		qofs_t end;
		enum
		{
			DLB_MISSING,
			DLB_PENDING,
			DLB_RECEIVED
		} state:16;
		unsigned int sequence;	//sequence is only valid on pending blocks.

		struct dlblock_s *next;
	} *dlblocks;
} qdownload_t;
enum qdlabort
{
	QDL_FAILED,		//delete file, tell server.
	QDL_DISCONNECT,	//delete file, don't tell server.
	QDL_COMPLETED,	//rename file, tell server.
};
qboolean DL_Begun(qdownload_t *dl);
void DL_Abort(qdownload_t *dl, enum qdlabort aborttype);		//just frees the download's resources. does not delete the temp file.
qboolean CL_AllowArbitaryDownload(const char *oldname, const char *localfile);


//
// the client_static_t structure is persistant through an arbitrary number
// of server connections
//
typedef struct
{
// connection information
	cactive_t	state;

	/*Specifies which protocol family we're speaking*/
	enum {
		CP_UNKNOWN,
		CP_QUAKEWORLD,
		CP_NETQUAKE,
		CP_QUAKE2,
		CP_QUAKE3,
		CP_PLUGIN
	} protocol;

	/*QuakeWorld protocol flags*/
#ifdef PROTOCOLEXTENSIONS
	unsigned int fteprotocolextensions;
	unsigned int fteprotocolextensions2;
	unsigned int ezprotocolextensions1;
#endif
	unsigned int z_ext;

	/*NQ Protocol flags*/
	enum
	{
		CPNQ_ID,
		CPNQ_NEHAHRA,
		CPNQ_BJP1,	//16bit models, strict 8bit sounds (otherwise based on nehahra)
		CPNQ_BJP2,	//16bit models, strict 16bit sounds
		CPNQ_BJP3,	//16bit models, flagged 16bit sounds, 8bit static sounds.
		CPNQ_FITZ666, /*and rmqe999 protocol, which is a strict superset*/
		CPNQ_DP5,
		CPNQ_DP6,
		CPNQ_DP7
	} protocol_nq;
	#define CPNQ_IS_DP (cls.protocol_nq >= CPNQ_DP5)
	#define CPNQ_IS_BJP (cls.protocol_nq >= CPNQ_BJP1 && cls.protocol_nq <= CPNQ_BJP3)
	qboolean proquake_angles_hack;	//angles are always 16bit
#ifdef NQPROT
	qboolean qex;	//we're connected to a QuakeEx server, which means lots of special workarounds that are not controlled via the actual protocol version.
#endif

	int protocol_q2;
	char downloadurl[MAX_OSPATH];	//where to download files from (for q2pro compat)

	qboolean findtrack;

	int framecount;

	int realip_ident;
	netadr_t realserverip;

// network stuff
	netchan_t	netchan;
	float lastarbiatarypackettime;	//used to mark when packets were sent to prevent mvdsv servers from causing us to disconnect.

	infobuf_t	userinfo[MAX_SPLITS];
	infosync_t	userinfosync;

	char		serverurl[MAX_OSPATH*4];	// eg qw://foo:27500/join?fp=blah
	char		servername[MAX_OSPATH];		// internal parsing, eg dtls://foo:27500

	struct ftenet_connections_s *sockets;

	qdownload_t *download;

// demo loop control
	int			demonum;		// -1 = don't play demos
	char		demos[MAX_DEMOS][MAX_DEMONAME];		// when not playing

// demo recording info must be here, because record is started before
// entering a map (and clearing client_state_t)
	vfsfile_t	*demooutfile;

	enum{DPB_NONE,DPB_QUAKEWORLD,DPB_MVD,DPB_EZTV,
#ifdef NQPROT
		DPB_NETQUAKE,
#endif
#ifdef Q2CLIENT
		DPB_QUAKE2
#endif
	}	demoplayback, demorecording;
	qboolean	demohadkeyframe;	//q2 needs to wait for a packet with a key frame, supposedly.
	qboolean	demoseeking;
	float		demoseektime;
	int			demotrack;
	qboolean	timedemo;
	char		lastdemoname[MAX_OSPATH];
	qboolean	lastdemowassystempath;
	vfsfile_t	*demoinfile;
	float		td_lastframe;		// to meter out one message a frame
	int			td_startframe;		// host_framecount at start
	float		td_starttime;		// realtime at second frame of timedemo
	float		demostarttime;		// the time of the first frame, so we don't get weird results with qw demos

	int			challenge;

	float		latency;		// rolling average

	char		allow_unmaskedskyboxes;	//skyboxes/domes do not need to be depth-masked when set. FIXME: we treat this as an optimisation hint, but some hl/q2/q3 maps require strict do-not-mask rules to look right.
	qboolean	allow_anyparticles;
	qboolean	allow_watervis;	//fixme: not checked any more
	float		allow_fbskins;	//fraction of allowance
	qboolean	allow_cheats;
	qboolean	allow_semicheats;	//defaults to true, but this allows a server to enforce a strict ruleset (smackdown type rules).
	qboolean	allow_csqc;			//disables some legacy/compat things, like proquake parsing.
	float		maxfps;	//server capped
	int			deathmatch;

#ifdef NQPROT
	int signon;
#endif

	colourised_t *colourised;
	qboolean	nqexpectingstatusresponse;
} client_static_t;

extern client_static_t	cls;

enum dlfailreason_e
{
	DLFAIL_UNTRIED,		//...
	DLFAIL_UNSUPPORTED,	//eg vanilla nq
	DLFAIL_CORRUPTED,	//something weird happened (hash fail)
	DLFAIL_CLIENTCVAR,	//clientside cvar blocked the download
	DLFAIL_CLIENTFILE,	//some sort of error writing the file
	DLFAIL_SERVERCVAR,	//serverside setting blocked the download
	DLFAIL_REDIRECTED,	//server told us to download a different file
	DLFAIL_SERVERFILE,	//server couldn't find the file
};
typedef struct downloadlist_s {
	char rname[128];
	char localname[128];
	unsigned int size;
	unsigned int flags;
#define DLLF_VERBOSE		(1u<<0)		//tell the user that its downloading
#define DLLF_REQUIRED		(1u<<1)		//means that it won't load models etc until its downloaded (ie: requiredownloads 0 makes no difference)
#define DLLF_OVERWRITE		(1u<<2)		//overwrite it even if it already exists
#define DLLF_SIZEUNKNOWN	(1u<<3)		//download's size isn't known
#define DLLF_IGNOREFAILED	(1u<<4)		//
#define DLLF_NONGAME		(1u<<5)		//means the requested download filename+localname is gamedir explicit (so id1/foo.txt is distinct from qw/foo.txt)
#define DLLF_TEMPORARY		(1u<<6)		//download it, but don't actually save it (DLLF_OVERWRITE doesn't actually overwrite, but does ignore any local files)
#define DLLF_USEREXPLICIT	(1u<<7)		//use explicitly requested it, ignore the cl_downloads cvar.

#define DLLF_BEGUN			(1u<<8)		//server has confirmed that the file exists, is readable, and we've opened a file. should not be set on new requests.
#define DLLF_ALLOWWEB		(1u<<9)		//failed http downloads should retry but from the game server itself
#define DLLF_TRYWEB			(1u<<10)	//should be trying to download it from a website...

	enum dlfailreason_e failreason;
	struct downloadlist_s *next;
} downloadlist_t;


typedef struct {
	//current persistant state
	trailkey_t trailstate;	//when to next throw out a trail
	trailkey_t emitstate;    //when to next emit

	//current origin
	vec3_t origin;	//current render position
	vec3_t angles;

	//previous rendering frame (for trails)
	vec3_t lastorigin;
	qboolean isnew;
	qboolean isplayer;

	//intermediate values for frame lerping
	//separate upper+lower lerps
	float framelerpdeltatime[FS_COUNT];
	float newframestarttime[FS_COUNT];
	int newframe[FS_COUNT];
	float oldframestarttime[FS_COUNT];
	int oldframe[FS_COUNT];
	qbyte basebone;

	//intermediate values for origin lerping of stepping things
	int newsequence;
	float orglerpdeltatime;
	float orglerpstarttime;
	vec3_t neworigin; /*origin that we're lerping towards*/
	vec3_t oldorigin; /*origin that we're lerping away from*/
	vec3_t newangle;
	vec3_t oldangle;

	//for further info
	int skeletalobject;
	int sequence;	/*so we know if the ent is still valid*/
	entity_state_t *entstate;
} lerpents_t;

enum
{
	FOGTYPE_AIR,
	FOGTYPE_WATER,
	FOGTYPE_SKYROOM,

	FOGTYPE_COUNT
};

//state associated with each player 'seat' (one for each splitscreen client)
//note that this doesn't include networking inputlog info.
struct playerview_s
{
	int			playernum;		//cl.players index for this player.
	qboolean	nolocalplayer;	//inhibit use of qw-style players, predict based on entities.
	qboolean	spectator;
#ifdef PEXT_SETVIEW
	int			viewentity;		//view is attached to this entity.
#endif

	// information for local display
	int			stats[MAX_CL_STATS];	// health, etc
	float		statsf[MAX_CL_STATS];	// health, etc
	char		*statsstr[MAX_CL_STATS];	// health, etc
	float		item_gettime[32];	// cl.time of aquiring item, for blinking
	float		faceanimtime;		// use anim frame if cl.time < this

#ifdef QUAKEHUD
	qboolean	sb_showscores;
	qboolean	sb_showteamscores;
#ifdef HEXEN2
	int			sb_hexen2_cur_item;//hexen2 hud
	float		sb_hexen2_item_time;
	float		sb_hexen2_extra_info_lines;
	qboolean	sb_hexen2_extra_info;//show the extra stuff
	qboolean	sb_hexen2_infoplaque;
#endif
#endif


// the client maintains its own idea of view angles, which are
// sent to the server each frame.  And only reset at level change
// and teleport times
	vec3_t		aimangles;			//angles actually being sent to the server (different due to in_vraim)
	vec3_t		viewangles;			//current angles
	vec3_t		viewanglechange;	//angles set by input code this frame
	short		baseangles[3];		//networked angles are relative to this value
	vec3_t		intermissionangles;	//absolute angles for intermission
	vec3_t		gravitydir;

	// pitch drifting vars
	float		pitchvel;
	qboolean	nodrift;
	float		driftmove;
	double		laststop;

	int gamerectknown;		//equals cls.framecount if valid
	vrect_t	gamerect;		//position the player's main view was drawn at this frame.

	//prediction state
	int			pmovetype;
	float		entgravity;
	float		maxspeed;
	vec3_t		simorg;
	vec3_t		simvel;
	vec3_t		simangles;
	float		rollangle;
	float		hdr_last;

	int			chatstate;	//1=talking, 2=afk

	float		crouch;			// local amount for smoothing stepups
	vec3_t		oldorigin;		// to track step smoothing
	float		oldz, extracrouch, crouchspeed; // to track step smoothing
	qboolean	onground;
	float		viewheight;
	int			waterlevel;		//for smartjump

	//for values that are propagated from one frame to the next
	//the next frame will always predict from the one we're tracking, where possible.
	//these values should all regenerate naturally from networked state (misses should be small/rare and fade when the physics catches up).
	struct playerpredprop_s
	{
		float		waterjumptime;
		qboolean	onground;
		vec3_t		gravitydir;
		qboolean	jump_held;
		int			jump_msec;		// hack for fixing bunny-hop flickering on non-ZQuake servers

		int			sequence;
	} prop;

#ifdef Q2CLIENT
	float forcefov;
	int handedness;	//0=right,1=left,2=center/hidden
	vec3_t predicted_origin;
	vec3_t predicted_angles;
	vec3_t prediction_error;
	float predicted_step_time;
	float predicted_step;
#endif

	//temporary view kick from weapon firing, angles+origins
	float		punchangle_cl;		// qw-style angles
	vec3_t		punchangle_sv;		// nq-style
	vec3_t		punchorigin;		// nq-style

	float		v_dmg_time;		//various view knockbacks.
	float		v_dmg_roll;
	float		v_dmg_pitch;

	double		bobtime;		//sine wave
	double		bobcltime;		//for tracking time increments
	float		bob;			//bob height


	vec3_t		cam_desired_position;	// where the camera wants to be
	int			cam_oldbuttons;			//
	double		cam_lastviewtime;		// timer for wallcam
	float		cam_reautotrack;		// timer to throttle tracking changes.
	int			cam_spec_track;			// player# of who we are tracking / want to track / might want to track
	enum
	{
		CAM_FREECAM	= 0,		//not attached to another player. we are our own thing (or actually playing).
		CAM_PENDING = 1,		//we want to lock on to cam_spec_track, but we don't have their position / stats yet. still freecamming
		CAM_WALLCAM = 2,		//locked, cl_chasecam=0. we're watching them from a wall.
		CAM_EYECAM	= 3			//locked, cl_chasecam=1. we know where they are, we're in their eyes.

#define CAM_ISLOCKED(pv) ((pv)->cam_state > CAM_PENDING)
	} cam_state;

	cshift_t	cshifts[NUM_CSHIFTS];	// color shifts for damage, powerups and content types
	vec4_t		screentint;
	vec4_t		bordertint;	//won't contain v_cshift values, only powerup+contents+damage+bf flashes

//	entity_t	viewent;	// is this not utterly redundant yet?
	struct
	{
		struct model_s *oldmodel;
		float lerptime;
		float oldlerptime;
		float frameduration;
		int prevframe;
		int oldframe;
	} vm;

	struct
	{
		qboolean defaulted;
		int entnum;
		vec3_t origin;
		vec3_t forward;
		vec3_t right;
		vec3_t up;
		size_t reverbtype;
		vec3_t velocity;
	} audio;

	struct vrdevinfo_s vrdev[VRDEV_COUNT];
};

//
// the client_state_t structure is wiped completely at every
// server signon
//
typedef struct
{
	int			fpd;
	int			servercount;	// server identification for prespawns

	int			protocol_qw;

	float		gamespeed;
	qboolean	csqcdebug;	//redundant, remove '*csqcdebug' serverinfo key.
	qboolean	allowsendpacket;

	qboolean	stillloading;	// set when doing something slow, and the game is still loading.

	qboolean	haveserverinfo;	//nq servers will usually be false. don't override stuff if we already know better.
	infobuf_t	serverinfo;
	char		*serverpacknames;
	char		*serverpackhashes;
	qboolean	serverpakschanged;

	int			parsecount;		// server message counter
	int			oldparsecount;
	int			oldvalidsequence;
	int			ackedmovesequence;	//in quakeworld/q2 this is always equal to validsequence. nq can differ. may only be updated when validsequence is updated.
	int			lastackedmovesequence;	//can be higher than ackedmovesequence when the received frame was unusable.
	int			validsequence;	// this is the sequence number of the last good
								// packetentity_t we got.  If this is 0, we can't
								// render a frame yet
	int			movesequence;	// client->server frames
	float		movesequence_time;	// client->server frame timestamp (vs cl.time)

//	int			spectator;
	int			autotrack_hint;		//the latest hint from the mod, might be negative for invalid.
	int			autotrack_killer;	//if someone kills the guy we're tracking, this is the guy we should switch to.

	double		last_ping_request;	// while showing scoreboard
	double		last_servermessage;

	//list of ent frames that still need to be acked.
	unsigned int numackframes;
	int ackframes[64];

#ifdef Q2CLIENT
	q2frame_t	q2frame;
	q2frame_t	q2frames[Q2UPDATE_BACKUP];
#endif

// sentcmds[cl.netchan.outgoing_sequence & UPDATE_MASK] = cmd
	outframe_t	outframes[UPDATE_BACKUP];	//user inputs (cl.ackedmovesequence+1 to cl.movesequence are still pending)
	inframe_t	inframes[UPDATE_BACKUP];	//server state (cl.validsequence is the most recent set)
	lerpents_t	*lerpents;
	int			maxlerpents;	//number of slots allocated.
	int			lerpentssequence;
	lerpents_t	lerpplayers[MAX_CLIENTS];

	//when running splitscreen, we have multiple viewports all active at once
	unsigned int	splitclients;	//we are running this many clients split screen.
	playerview_t	playerview[MAX_SPLITS];
	unsigned int	defaultnetsplit;//which multiview splitscreen to parse the message for (set by mvd playback code)

	// localized movement vars
	float		bunnyspeedcap;

// the client simulates or interpolates movement to get these values
	double		time;			// this is the time value that the client
								// is rendering at.  always <= realtime
	double		lasttime;		//cl.time from last frame.
	double		lastlinktime;	//cl.time from last frame.
	double		mapstarttime;	//for computing csqc's cltime.

	double servertime;	//current server time, bound between gametime and gametimemark
	float mtime;		//server time as on the server when we last received a packet. not allowed to decrease.
	float oldmtime;		//server time as on the server for the previously received packet.

	double gametime;
	double gametimemark;
	double oldgametime;		//used as the old time to lerp cl.time from.
	double oldgametimemark;	//if it's 0, cl.time will casually increase.
	float demogametimebias;	//mvd timings are weird.
	int	  demonudge;		//
	float demopausedtilltime;//demo is paused until realtime>this

	float minpitch;
	float maxpitch;

	qboolean	paused;			// send over by server
	qboolean	implicitpause;	//for csqc. only a hint, respected only in singleplayer.

	enum
	{
		IM_NONE,		//off.
		IM_NQSCORES,	//+showscores forced, view still attached to regular view
		IM_NQFINALE,	//slow centerprint text etc, view still attached to regular view. no hud
		IM_NQCUTSCENE,	//IM_NQFINALE, but without the 'finale' header on centerprints.
		IM_H2FINALE,	//IM_NQFINALE, but with the view offset by the player's viewheight.

		IM_QWSCORES		//intermission, view locked at a specific point
	} intermissionmode;	// don't change view angle, full screen, etc
	float		completed_time;	// latched ffrom time at intermission start

//
// information that is static for the entire time connected to a server
//
#ifdef HAVE_LEGACY
	char				model_name_vwep[MAX_VWEP_MODELS][MAX_QPATH];
	struct model_s		*model_precache_vwep[MAX_VWEP_MODELS];
#endif
	char				model_name[MAX_PRECACHE_MODELS][MAX_QPATH];
	struct model_s		*model_precache[MAX_PRECACHE_MODELS];
	char				sound_name[MAX_PRECACHE_SOUNDS][MAX_QPATH];
	struct sfx_s		*sound_precache[MAX_PRECACHE_SOUNDS];
	char				*particle_ssname[MAX_SSPARTICLESPRE];
	int					particle_ssprecache[MAX_SSPARTICLESPRE];	//these are actually 1-based, so 0 can be used to lazy-init them. I cheat.

#ifdef Q2CLIENT
#define Q2MAX_VISIBLE_WEAPONS 32 //q2 has about 20.
	int		numq2visibleweapons;	//q2 sends out visible-on-model weapons in a wierd gender-nutral way.
	char	*q2visibleweapons[Q2MAX_VISIBLE_WEAPONS];//model names beginning with a # are considered 'sexed', and are loaded on a per-client basis. yay. :(

	char		*configstring_general[Q2MAX_CLIENTS|Q2MAX_GENERAL];
	char		*image_name[Q2MAX_IMAGES];
	char		*item_name[Q2MAX_ITEMS];
	short		inventory[MAX_SPLITS][Q2MAX_ITEMS];
#endif

	char				model_csqcname[MAX_CSMODELS][MAX_QPATH];
	struct model_s		*model_csqcprecache[MAX_CSMODELS];
	char				*particle_csname[MAX_CSPARTICLESPRE];
	int					particle_csprecache[MAX_CSPARTICLESPRE];	//these are actually 1-based, so we can be lazy and do a simple negate.

	qboolean			particle_ssprecaches;	//says to not try to do any dp-compat hacks.
	qboolean			particle_csprecaches;	//says to not try to do any dp-compat hacks.

	//used for q2 sky/configstrings
	char skyname[MAX_QPATH];
	float skyrotate;
	qboolean skyautorotate;
	vec3_t skyaxis;

	qboolean	fog_locked;			//FIXME: make bitmask
	fogstate_t	fog[FOGTYPE_COUNT];	//0 = air, 1 = water. if water has no density fall back on air.
	fogstate_t	oldfog[FOGTYPE_COUNT];

	char		levelname[40];	// for display on solo scoreboard
	char		*windowtitle;	// fully overrides the window caption.

// refresh related state
	struct model_s	*worldmodel;	// cl_entitites[0].model
	int			num_entities;	// stored bottom up in cl_entities array
	int			num_statics;	// stored top down in cl_entitiers

// all player information
	unsigned int    allocated_client_slots;
	player_info_t	players[MAX_CLIENTS];


	downloadlist_t *downloadlist;
	downloadlist_t *faileddownloads;

	qboolean gamedirchanged;

#ifdef Q2CLIENT
	char		q2airaccel[16];
	char		q2statusbar[1024];
	char		q2layout[MAX_SPLITS][1024];
	int			q2mapchecksum;
	int parse_entities;
	float lerpfrac;
	float q2svnetrate; //number of frames we expect to receive per second (required to calculate the server time correctly).
#endif

	char lastcenterprint[1024];	//prevents too much spam with console centerprint logging.



	struct itemtimer_s
	{
		float end;
		int entnum;
		float start;
		float duration;
		vec3_t origin;
		vec3_t rgb;
		float radius;
		struct itemtimer_s *next;
	} *itemtimers;

	//interpolation+snapshots
	float	packfrac;
	packet_entities_t	*currentpackentities;
	packet_entities_t	*previouspackentities;
	float				currentpacktime;
	qboolean			do_lerp_players;


	int teamplay;
	int deathmatch;

	qboolean teamfortress;	// *sigh*. This is used for teamplay stuff. This sucks.
	qboolean hexen2pickups;
	qboolean disablemouse;	//no mouse inputs (for controller-only games, though we do also allow keyboards if only because of joy2key type stuff)

	qboolean sendprespawn;
	int contentstage;

	double matchgametimestart;
	enum {
		MATCH_DONTKNOW,	//assumed to be in progress.
		MATCH_COUNTDOWN,
		MATCH_STANDBY,
		MATCH_INPROGRESS
	} matchstate;

	enum {
		CLNQPP_NONE,
		CLNQPP_PINGS,
		CLNQPP_STATUS, //"host:    *\n" ... "players: *\n\n"
		CLNQPP_STATUSPLAYER,	//#...\n
		CLNQPP_STATUSPLAYERIP,	//   foobar\n
	}	nqparseprint;
	int			nqparseprintplayer;
	float		nqplayernamechanged;
} client_state_t;

extern unsigned int		cl_teamtopcolor;
extern unsigned int		cl_teambottomcolor;
extern unsigned int		cl_enemytopcolor;
extern unsigned int		cl_enemybottomcolor;

//FPD values
//(commented out ones are ones that we don't support)
//#define FPD_NO_SAY_MACROS			(1 << 0)
//#define FPD_NO_TIMERS				(1 << 1)
//#define FPD_NO_SOUNDTRIGGERS		(1 << 2)
#define FPD_NO_FAKE_LAG				(1 << 3)
#define FPD_ANOUNCE_FAKE_LAG		(1 << 4)
//#define FPD_HIDE_ENEMY_VICINITY	(1 << 5)
//#define FPD_NO_SPEC_CHAT			(1 << 6)
//#define FPD_HIDE_X_Y_MACRO		(1 << 7)
#define FPD_NO_FORCE_SKIN			(1 << 8)
#define FPD_NO_FORCE_COLOR			(1 << 9)
#define FPD_LIMIT_PITCH				(1 << 14)	//limit scripted pitch changes
#define FPD_LIMIT_YAW				(1 << 15)	//limit scripted yaw changes

//
// cvars
//
extern  cvar_t	cl_warncmd;
extern	cvar_t	cl_upspeed;
extern	cvar_t	cl_forwardspeed;
extern	cvar_t	cl_backspeed;
extern	cvar_t	cl_sidespeed;

extern	cvar_t	cl_movespeedkey;

extern	cvar_t	cl_yawspeed;
extern	cvar_t	cl_pitchspeed;

extern	cvar_t	cl_anglespeedkey;

extern	cvar_t	cl_shownet;
extern	cvar_t	cl_sbar;
extern	cvar_t	cl_hudswap;

extern	cvar_t	cl_pitchdriftspeed;
extern	cvar_t	lookspring;
extern	cvar_t	lookstrafe;
extern	cvar_t	sensitivity;

extern	cvar_t	m_pitch;
extern	cvar_t	m_yaw;
extern	cvar_t	m_forward;
extern	cvar_t	m_side;

#ifndef SERVERONLY
extern	cvar_t	name;
#endif


extern cvar_t ruleset_allow_playercount;
extern cvar_t ruleset_allow_frj;
extern cvar_t ruleset_allow_semicheats;
extern cvar_t ruleset_allow_packet;
extern cvar_t ruleset_allow_particle_lightning;
extern cvar_t ruleset_allow_overlongsounds;
extern cvar_t ruleset_allow_larger_models;
extern cvar_t ruleset_allow_modified_eyes;
extern cvar_t ruleset_allow_sensitive_texture_replacements;
extern cvar_t ruleset_allow_localvolume;
extern cvar_t ruleset_allow_shaders;
extern cvar_t ruleset_allow_watervis;
extern cvar_t ruleset_allow_triggers;

#ifndef SERVERONLY
extern	client_state_t	cl;
#endif

typedef struct
{
	entity_t		ent;
	entity_state_t	state;
	trailkey_t      emit;
	int	mdlidx;	/*negative are csqc indexes*/
} static_entity_t;

// FIXME, allocate dynamically
extern	entity_state_t *cl_baselines;
extern	static_entity_t		*cl_static_entities;
extern	unsigned int	cl_max_static_entities;
extern	lightstyle_t	*cl_lightstyle;
extern	size_t			cl_max_lightstyles;
extern	dlight_t		*cl_dlights;
extern	size_t cl_maxdlights;

extern	int				d_lightstylevalue[MAX_NET_LIGHTSTYLES];

extern size_t rtlights_first, rtlights_max;
extern int cl_baselines_count;

extern	qboolean	nomaster;

//=============================================================================


//
// cl_main
//
void CL_InitDlights(void);
void CL_FreeDlights(void);
dlight_t *CL_AllocDlight (int key);	//allocates or reuses the light with the specified key index
dlight_t *CL_AllocDlightOrg (int keyidx, vec3_t keyorg); //reuses the light at the specified origin...
dlight_t *CL_AllocSlight (void);	//allocates a new static light
dlight_t *CL_NewDlight (int key, const vec3_t origin, float radius, float time, float r, float g, float b);
dlight_t *CL_NewDlightCube (int key, const vec3_t origin, vec3_t angles, float radius, float time, vec3_t colours);
void CL_CloneDlight(dlight_t *dl, dlight_t *src);	//copies one light to another safely
void	CL_DecayLights (void);

void CLQW_ParseDelta (struct entity_state_s *from, struct entity_state_s *to, int bits);

void CL_Init (void);
void Host_WriteConfiguration (void);
void CL_CheckServerInfo(void);
void CL_CheckServerPacks(void);

void CL_EstablishConnection (char *host);

void CL_Disconnect (const char *reason);
void CL_Disconnect_f (void);
void CL_Reconnect_f (void);
void CL_NextDemo (void);
void CL_Startdemos_f (void);
void CL_Demos_f (void);
void CL_Stopdemo_f (void);
void CL_Changing_f (void);
void CL_Reconnect_f (void);
void CL_ConnectionlessPacket (void);
qboolean CL_DemoBehind(void);
void CL_SaveInfo(vfsfile_t *f);
void CL_SetInfo (int pnum, const char *key, const char *value);
void CL_SetInfoBlob (int pnum, const char *key, const char *value, size_t valuesize);

char *CL_TryingToConnect(void);

void CL_ExecInitialConfigs(char *defaultexec, qboolean fullvidrestart);

extern	int				cl_framecount;	//number of times the entity lists have been cleared+reset.
extern	int				cl_numvisedicts;
extern	int				cl_maxvisedicts;
extern	entity_t		*cl_visedicts;

/*these are for q3 really*/
typedef struct {
	struct shader_s *shader;
	int firstvert;
	int firstidx;
	int numvert;
	int numidx;
	unsigned int flags;
} scenetris_t;
extern scenetris_t		*cl_stris;
extern vecV_t			*fte_restrict cl_strisvertv;
extern vec4_t			*fte_restrict cl_strisvertc;
extern vec2_t			*fte_restrict cl_strisvertt;
extern vec3_t			*fte_restrict cl_strisvertn[3];
extern index_t			*fte_restrict cl_strisidx;
extern unsigned int cl_numstrisidx;
extern unsigned int cl_maxstrisidx;
extern unsigned int cl_numstrisvert;
extern unsigned int cl_maxstrisvert;
extern unsigned int cl_numstrisnormals;
extern unsigned int cl_maxstrisnormals;
extern unsigned int cl_numstris;
extern unsigned int cl_maxstris;

#define cl_stris_ExpandVerts(max) \
	do {			\
		cl_maxstrisvert = max;	\
		cl_strisvertv = BZ_Realloc(cl_strisvertv, sizeof(*cl_strisvertv)*cl_maxstrisvert);	\
		cl_strisvertt = BZ_Realloc(cl_strisvertt, sizeof(*cl_strisvertt)*cl_maxstrisvert);	\
		cl_strisvertc = BZ_Realloc(cl_strisvertc, sizeof(*cl_strisvertc)*cl_maxstrisvert);	\
/*		cl_strisvertn[0] = BZ_Realloc(cl_strisvertn[0], sizeof(*cl_strisvertn[0])*cl_maxstrisvert);	\
		cl_strisvertn[1] = BZ_Realloc(cl_strisvertn[1], sizeof(*cl_strisvertn[1])*cl_maxstrisvert);	\
		cl_strisvertn[2] = BZ_Realloc(cl_strisvertn[2], sizeof(*cl_strisvertn[2])*cl_maxstrisvert);	\
*/	} while(0)

extern char emodel_name[], pmodel_name[], prespawn_name[], modellist_name[], soundlist_name[];

//CL_TraceLine traces against network(positive)+csqc(negative) ents. returns frac(1 on failure), and impact, normal, ent values
float CL_TraceLine (vec3_t start, vec3_t end, vec3_t impact, vec3_t normal, int *ent);
entity_t *TraceLineR (vec3_t start, vec3_t end, vec3_t impact, vec3_t normal, qboolean bsponly);

//
// cl_input
//
typedef struct kbutton_s
{
	int		down[MAX_SPLITS][2];		// key nums holding it down
	int		state[MAX_SPLITS];			// low bit is down state

	struct kbutton_s *suppressed[MAX_SPLITS];	//the button that was suppressed by this one getting pressed
} kbutton_t;

extern	kbutton_t	in_mlook;
extern 	kbutton_t 	in_strafe;
extern 	kbutton_t 	in_speed;

extern	float in_sensitivityscale;

void CL_MakeActive(char *gamename);
void CL_UpdateWindowTitle(void);

#ifdef QUAKESTATS
const char *IN_GetPreselectedViewmodelName(unsigned int pnum);
qboolean IN_WeaponWheelAccumulate(int pnum, float x, float y, float threshhold);
qboolean IN_DrawWeaponWheel(int pnum);
qboolean IN_WeaponWheelIsShown(void);	//to decide when the game should be auto-paused.
#endif
void CL_InitInput (void);
void CL_SendCmd (double frametime, qboolean mainloop);
void CL_SendMove (usercmd_t *cmd);
#ifdef NQPROT
void CL_ParseTEnt (qboolean nqprot);
#else
void CL_ParseTEnt (void);
#endif
void CL_ParseTEnt_Sized (void);
void CL_UpdateTEnts (void);

enum beamtype_e
{	//these are internal ids, matching the beam table
	BT_Q1LIGHTNING1,
	BT_Q1LIGHTNING2,
	BT_Q1LIGHTNING3,
	BT_Q1BEAM,

	BT_Q2PARASITE,
	BT_Q2GRAPPLE,
	BT_Q2HEATBEAM,
	BT_Q2LIGHTNING,

	BT_H2LIGHTNING_SMALL,
	BT_H2CHAIN,
	BT_H2SUNSTAFF1,
	BT_H2SUNSTAFF1_SUB,	//inner beam hack
	BT_H2SUNSTAFF2,		//same model as 1, but different particle effect
	BT_H2LIGHTNING,
	BT_H2COLORBEAM,
	BT_H2ICECHUNKS,
	BT_H2GAZE,
	BT_H2FAMINE,
};
typedef struct beam_s beam_t;
beam_t *CL_AddBeam (enum beamtype_e tent, int ent, vec3_t start, vec3_t end);

void CL_ClearState (qboolean gamestart);
void CLQ2_ClearState(void);

void CL_ReadPackets (void);
void CL_ReadPacket(void);

int  CL_ReadFromServer (void);
void CL_WriteToServer (usercmd_t *cmd);

int Master_FindBestRoute(char *server, char *out, size_t outsize, int *directcost, int *chainedcost);

float CL_KeyState (kbutton_t *key, int pnum, qboolean noslowstart);
const char *Key_KeynumToString (int keynum, int modifier);
const char *Key_KeynumToLocalString (int keynum, int modifier);
int Key_StringToKeynum (const char *str, int *modifier);
const char *Key_GetBinding(int keynum, int bindmap, int modifier);
void Key_GetBindMap(int *bindmaps);
void Key_SetBindMap(int *bindmaps);

void CL_UseIndepPhysics(qboolean allow);
extern qboolean runningindepphys;
qboolean CL_AllowIndependantSendCmd(qboolean allow);	//returns previous state.

void CL_FlushClientCommands(void);
void VARGS CL_SendClientCommand(qboolean reliable, char *format, ...) LIKEPRINTF(2);
void VARGS CL_SendSeatClientCommand(qboolean reliable, unsigned int seat, char *format, ...) LIKEPRINTF(3);
float CL_FilterTime (double time, float wantfps, float limit, qboolean ignoreserver);
int CL_RemoveClientCommands(char *command);

//
// cl_demo.c
//
void CL_StopPlayback (void);
qboolean CL_GetDemoMessage (void);
void CL_WriteDemoCmd (usercmd_t *pcmd);
void CL_Demo_ClientCommand(char *commandtext);	//for QTV.

void CL_WriteSetDemoMessage (void);	//'restarts' a qwd, when we have reloads/map changes in them
void CL_WriteRecordQ2DemoMessage(sizebuf_t *msg);
void CL_Stop_f (void);
void CL_Record_f (void);
void CL_ReRecord_f (void);
void CL_DemoList_c(int argn, const char *partial, struct xcommandargcompletioncb_s *ctx);
void CL_PlayDemo_f (void);
void CL_QTVPlay_f (void);
void CL_QTVPoll (void);
void CL_QTVList_f (void);
void CL_QTVDemos_f (void);
void CL_DemoJump_f(void);
void CL_DemoNudge_f(void);
void CL_ProgressDemoTime(void);
void CL_TimeDemo_f (void);
typedef struct 
{
	enum
	{
		QTVCT_NONE,
		QTVCT_STREAM,
		QTVCT_CONNECT,
		QTVCT_JOIN,
		QTVCT_OBSERVE,
		QTVCT_MAP
	} connectiontype;
	enum
	{
		QTVCT_NETQUAKE,
		QTVCT_QUAKEWORLD,
		QTVCT_QUAKE2,
		QTVCT_QUAKE3
	} protocol;
	char server[256];
	char splashscreen[256];
	//char *datafiles;
} qtvfile_t;
void CL_ParseQTVFile(vfsfile_t *f, const char *fname, qtvfile_t *result);

//
// cl_parse.c
//
#define NET_TIMINGS 256
#define NET_TIMINGSMASK 255
extern float	packet_latency[NET_TIMINGS];
int CL_CalcNet (float scale);
void CL_CalcNet2 (float *pings, float *pings_min, float *pings_max, float *pingms_stddev, float *pingfr, int *pingfr_min, int *pingfr_max, float *dropped, float *choked, float *invalid);
void CL_ClearParseState(void);
void CL_Parse_Disconnected(void);
void CL_DumpPacket(void);
void CL_ParseEstablished(void);
void CLQW_ParseServerMessage (void);
void CLNQ_ParseServerMessage (void);
#ifdef Q2CLIENT
void CLQ2_ParseServerMessage (void);
#endif
void CL_ShowTrafficUsage(float x, float y);
void CL_NewTranslation (int slot);

int CL_IsDownloading(const char *localname);
qboolean CL_CheckDLFile(const char *filename);
qboolean CL_CheckOrEnqueDownloadFile (const char *filename, const char *localname, unsigned int flags);
qboolean CL_EnqueDownload(const char *filename, const char *localname, unsigned int flags);
downloadlist_t *CL_DownloadFailed(const char *name, qdownload_t *qdl, enum dlfailreason_e failreason);
int CL_DownloadRate(void);
void CL_GetDownloadSizes(unsigned int *filecount, qofs_t *totalsize, qboolean *somesizesunknown);
qboolean CL_ParseOOBDownload(void);
void CL_DownloadFinished(qdownload_t *dl);
void CL_RequestNextDownload (void);
void CL_SendDownloadReq(sizebuf_t *msg);
void Sound_CheckDownload(const char *s); /*checkorenqueue a sound file*/

qboolean CL_IsUploading(void);
void CL_NextUpload(void);
void CL_StartUpload (qbyte *data, int size);
void CL_StopUpload(void);

qboolean CL_CheckBaselines (int size);

//
// view.c
//
void V_StartPitchDrift (playerview_t *pv);
void V_StopPitchDrift (playerview_t *pv);

void V_RenderView (qboolean no2d);
void V_Register (void);
void V_ParseDamage (playerview_t *pv);
void V_SetContentsColor (int contents);

//used directly by csqc
void V_CalcRefdef (playerview_t *pv);
void V_ClearRefdef(playerview_t *pv);
void V_ApplyRefdef(void);
void V_CalcGunPositionAngle (playerview_t *pv, float bob);
float V_CalcBob (playerview_t *pv, qboolean queryold);
void DropPunchAngle (playerview_t *pv);

int V_EditExternalModels(int newviewentity, entity_t *viewentities, int maxviewenties);
void V_DepthSortEntities(float *vieworg);


//
// cl_tent
//
void CL_RegisterParticles(void);
void CL_InitTEnts (void);
void CL_InitTEntSounds (void);
void CL_ClearTEnts (void);
void CL_ClearTEntParticleState (void);
void CL_ClearCustomTEnts(void);
void CL_ParseCustomTEnt(void);
qboolean CL_WriteCustomTEnt(sizebuf_t *buf, int id);
void CL_ParseEffect (qboolean effect2);

void CLNQ_ParseParticleEffect (void);
void CL_ParseParticleEffect2 (void);
void CL_ParseParticleEffect3 (void);
void CL_ParseParticleEffect4 (void);

int CL_TranslateParticleFromServer(int sveffect);
void CL_ParseTrailParticles(void);
void CL_ParsePointParticles(qboolean compact);
void CL_SpawnSpriteEffect(vec3_t org, vec3_t dir, vec3_t orientationup, struct model_s *model, int startframe, int framecount, float framerate, float alpha, float scale, float randspin, float gravity, int traileffect, unsigned int renderflags, int skinnum);	/*called from the particlesystem*/

//
// cl_ents.c
//
void CL_SetSolidPlayers (void);
void CL_SetUpPlayerPrediction(qboolean dopred);
void CL_LinkStaticEntities(void *pvs, int *areas);
void CL_TransitionEntities (void); /*call at the start of the frame*/
void CL_EmitEntities (void);
void CL_ClearProjectiles (void);
void CL_ParseProjectiles (int modelindex, qboolean nails2);
void CLQW_ParsePacketEntities (qboolean delta);
void CLFTE_ParseEntities (void);
void CLFTE_ParseBaseline(entity_state_t *es, qboolean numberisimportant);
void CL_SetSolidEntities (void);
void CLQW_ParsePlayerinfo (void);
void CL_ParseClientPersist(void);
//these last ones are needed for csqc handling of engine-bound ents.
void CL_ClearEntityLists(void);
void CL_FreeVisEdicts(void);
void CL_LinkViewModel(void);
void CL_LinkPlayers (void);
void CL_LinkPacketEntities (void);
void CL_LinkProjectiles (void);
void CL_ClearLerpEntsParticleState (void);
qboolean CL_MayLerp(void);

//
//pr_csqc.c
//
#ifdef CSQC_DAT
qboolean CSQC_Inited(void);
void	 CSQC_RendererRestarted(qboolean initing);
qboolean CSQC_UnconnectedOkay(qboolean inprinciple);
qboolean CSQC_UnconnectedInit(void);
qboolean CSQC_CheckDownload(const char *name, unsigned int checksum, size_t checksize);	//reports whether we already have a usable csprogs.dat
qboolean CSQC_Init (qboolean anycsqc, const char *csprogsname, unsigned int checksum, size_t progssize);
qboolean CSQC_ConsoleLink(char *text, char *info);
void	 CSQC_RegisterCvarsAndThings(void);
qboolean CSQC_SetupToRenderPortal(int entnum);
qboolean CSQC_DrawView(void);
qboolean CSQC_DrawHud(playerview_t *pv);
qboolean CSQC_DrawScores(playerview_t *pv);
qboolean CSQC_UseGamecodeLoadingScreen(void);
void	 CSQC_Shutdown(void);
qboolean CSQC_StuffCmd(int lplayernum, char *cmd, char *cmdend);
void	 CSQC_MapEntityEdited(int modelindex, int idx, const char *newe);
//qboolean CSQC_LoadResource(char *resname, char *restype);
qboolean CSQC_ParsePrint(char *message, int printlevel);
qboolean CSQC_ParseGamePacket(int seat, qboolean sized);
qboolean CSQC_CenterPrint(int seat, const char *cmd);
void	 CSQC_ServerInfoChanged(void);
void	 CSQC_PlayerInfoChanged(int player);
qboolean CSQC_Parse_Damage(int seat, float save, float take, vec3_t source);
qboolean CSQC_Parse_SetAngles(int seat, vec3_t newangles, qboolean wasdelta);
void	 CSQC_Input_Frame(int seat, usercmd_t *cmd);
void	 CSQC_WorldLoaded(void);
qboolean CSQC_ParseTempEntity(void);
qboolean CSQC_ConsoleCommand(int seat, const char *cmd);
qboolean CSQC_KeyPress(int key, int unicode, qboolean down, unsigned int devid);
qboolean CSQC_MouseMove(float xdelta, float ydelta, unsigned int devid);
qboolean CSQC_MousePosition(float xabs, float yabs, unsigned int devid);
qboolean CSQC_JoystickAxis(int axis, float value, unsigned int devid);
qboolean CSQC_Accelerometer(float x, float y, float z);
qboolean CSQC_Gyroscope(float x, float y, float z);
int		 CSQC_StartSound(int entnum, int channel, char *soundname, vec3_t pos, float vol, float attenuation, float pitchmod, float timeofs, unsigned int flags);
void	 CSQC_ParseEntities(qboolean sized);
const char *CSQC_GetExtraFieldInfo(void *went, char *out, size_t outsize);
void	 CSQC_ResetTrails(void);

qboolean CSQC_DeltaPlayer(int playernum, player_state_t *state);
void	 CSQC_DeltaStart(float time);
qboolean CSQC_DeltaUpdate(entity_state_t *src);
void	 CSQC_DeltaEnd(void);

void	 CSQC_CvarChanged(cvar_t *var);
#else
#define CSQC_UnconnectedOkay(inprinciple) false
#define CSQC_UnconnectedInit() false
#define CSQC_UseGamecodeLoadingScreen() false
#define CSQC_Parse_SetAngles(seat,newangles,wasdelta) false
#define CSQC_ServerInfoChanged()
#define CSQC_PlayerInfoChanged(player)
#endif

//
// cl_pred.c
//
void CL_InitPrediction (void);
void CL_PredictMove (void);
void CL_PredictUsercmd (int seat, int entnum, player_state_t *from, player_state_t *to, usercmd_t *u);
#ifdef Q2CLIENT
void CLQ2_CheckPredictionError (void);
#endif
void CL_CalcClientTime(void);

//
// cl_cam.c
//
qboolean Cam_DrawViewModel(playerview_t *pv);
int Cam_TrackNum(playerview_t *pv);
void Cam_Unlock(playerview_t *pv);				//revert to freecam or so, because that entity failed.
void Cam_Lock(playerview_t *pv, int playernum);	//attempt to lock on to the given player.
void Cam_NowLocked(playerview_t *pv);						//player was located, track them now
void Cam_SelfTrack(playerview_t *pv);
void Cam_Track(playerview_t *pv, usercmd_t *cmd);
void Cam_SetModAutoTrack(int userid);
void Cam_FinishMove(playerview_t *pv, usercmd_t *cmd);
void Cam_Reset(void);
void Cam_TrackPlayer(int seat, char *cmdname, char *plrarg);
void CL_InitCam(void);
void Cam_AutoTrack_Update(const char *mode);	//reset autotrack setting (because we started a new map or whatever)

//
//zqtp.c
//
#define TPM_UNKNOWN    0
#define TPM_NORMAL     1
#define TPM_TEAM       2
#define TPM_SPECTATOR  4
#define TPM_FAKED     16
#define TPM_OBSERVEDTEAM  32
#define TPM_QTV       64		//should only be qtv_say_game/qtv_say_team_game

void		CL_Say (qboolean team, char *extra);
int			TP_CategorizeMessage (char *s, int *offset, player_info_t **plr);
void		TP_ExecTrigger (char *s, qboolean indemos);		//executes one of the user's f_foo aliases from some engine-defined event.
qboolean	TP_FilterMessage (char *s);
void		TP_Init(void);
char*		TP_LocationName (const vec3_t location);
void		TP_NewMap (void);
qboolean	TP_CheckSoundTrigger (char *str);				//plays sound files when some substring exists in chat.
void		TP_SearchForMsgTriggers (char *s, int level);	//msg_trigger: executes aliases when a chat message contains some user-defined string.
qboolean	TP_SuppressMessage(char *buf);	//true when the message contains macro results that the local player isn't meant to see (teamplay messages that contain enemy player counts for instance)
char		*TP_GenerateDemoName(void);		//makes something up.
#ifdef QUAKESTATS
//hack zone: this stuff makes assumptions about quake-only stats+items+rules and stuff.
void		TP_CheckPickupSound(char *s, vec3_t org, int seat);
void		TP_ParsePlayerInfo(player_state_t *oldstate, player_state_t *state, player_info_t *info);
qboolean	TP_IsPlayerVisible(vec3_t origin);
qboolean	TP_SoundTrigger(char *message);
void		TP_StatChanged (int stat, int value);
void		TP_UpdateAutoStatus(void);
#endif
#ifdef QWSKINS
colourised_t *TP_FindColours(char *name);
#endif

//
// skin.c
//

typedef struct
{
    char	manufacturer;
    char	version;
    char	encoding;
    char	bits_per_pixel;
    unsigned short	xmin,ymin,xmax,ymax;
    unsigned short	hres,vres;
    unsigned char	palette[48];
    char	reserved;
    char	color_planes;
    unsigned short	bytes_per_line;
    unsigned short	palette_type;
    char	filler[58];
//    unsigned char	data;			// unbounded
} pcx_t;
qbyte *ReadPCXData(qbyte *buf, int length, int width, int height, qbyte *result);


qwskin_t *Skin_Lookup (char *fullname);
char *Skin_FindName (player_info_t *sc);
void	Skin_Find (player_info_t *sc);
qbyte	*Skin_TryCache8 (qwskin_t *skin);
void	Skin_Skins_f (void);
void	Skin_FlushSkin(char *name);
void	Skin_AllSkins_f (void);
void	Skin_NextDownload (void);
void Skin_FlushPlayers(void);
void Skin_FlushAll(void);

#define RSSHOT_WIDTH 320
#define RSSHOT_HEIGHT 200





//valid.c
#define RULESET_USERINFO	"*rs"	//the userinfo used to report the ruleset name to other clients. FIXME: remove the _dbg when we think its all working properly.
void		Ruleset_Check(char *keyval, char *out, size_t outsize);
void		Ruleset_Scan(void);
void		Ruleset_Shutdown(void);
const char *Ruleset_GetRulesetName(void);
qboolean	Ruleset_FileLoaded(const char *filename, const qbyte *filedata, size_t filesize);	//return false if the file is not permitted.
void	Validation_Apply_Ruleset(void);
void	Validation_FlushFileList(void);
void	Validation_CheckIfResponse(char *text);
void	Validation_DelatchRulesets(void);
void	InitValidation(void);
void	Validation_Auto_Response(int playernum, char *s);

extern	qboolean f_modified_particles;
extern	qboolean care_f_modified;


//random files (fixme: clean up)

#ifdef Q2CLIENT
unsigned int CLQ2_GatherSounds(vec3_t *positions, unsigned int *entnums, sfx_t **sounds, unsigned int max);
void CLQ2_ParseTEnt (void);
void CLQ2_AddEntities (void);
void CLQ2_ParseBaseline (void);
void CLQ2_ClearParticleState(void);
void CLR1Q2_ParsePlayerUpdate(void);
void CLQ2_ParseFrame (int extrabits);
void CLQ2_ParseMuzzleFlash (void);
void CLQ2_ParseMuzzleFlash2 (void);
void CLQ2EX_ParseMuzzleFlash3 (void);
void CLQ2_ParseInventory (int seat);
int CLQ2_RegisterTEntModels (void);
void CLQ2_WriteDemoBaselines(sizebuf_t *buf);
#endif

#ifdef HLCLIENT
//networking
void CLHL_LoadClientGame(void);
int CLHL_ParseGamePacket(void);
int CLHL_AnimateViewEntity(entity_t *ent);
//screen
int CLHL_DrawHud(void);
//inputs
int CLHL_GamecodeDoesMouse(void);
int CLHL_MouseEvent(unsigned int buttonmask);
void CLHL_SetMouseActive(int activate);
int CLHL_BuildUserInput(int msecs, usercmd_t *cmd);
#endif

#ifdef NQPROT
void CLNQ_ParseEntity(unsigned int bits);
void NQ_P_ParseParticleEffect (void);
void CLNQ_SignonReply (void);
void NQ_BeginConnect(char *to);
void NQ_ContinueConnect(char *to);
int CLNQ_GetMessage (void);
#endif

void CL_BeginServerReconnect(void);
qboolean CL_IsPendingServerAddress(netadr_t *adr);
void CL_Transfer(netadr_t *adr);

void SV_User_f (void);	//called by client version of the function
void SV_Serverinfo_f (void);
void SV_ConSay_f(void);



#ifdef TEXTEDITOR
extern console_t *editormodal;
void Editor_Draw(void);
void Editor_Init(void);
struct pubprogfuncs_s;
void Editor_ProgsKilled(struct pubprogfuncs_s *dead);
#else
#define editormodal false
#endif

void SCR_StringToRGB (char *rgbstring, float *rgb, float rgbinputscale);

struct model_s;
void CL_AddVWeapModel(entity_t *player, struct model_s *model);

typedef struct cin_s cin_t;
#ifdef HAVE_MEDIA_DECODER

#ifdef Q2CLIENT /*q2 cinematics*/
struct cinematics_s;
void CIN_StopCinematic (struct cinematics_s *cin);
struct cinematics_s *CIN_PlayCinematic (char *arg);
int CIN_RunCinematic (struct cinematics_s *cin, float playbacktime, qbyte **outdata, int *outwidth, int *outheight, qbyte **outpalette);
void CIN_Rewind(struct cinematics_s *cin);
#endif

typedef enum
{
	CINSTATE_INVALID,	//also reported for not playing
	CINSTATE_PLAY,
	CINSTATE_LOOP,
	CINSTATE_PAUSE,
	CINSTATE_ENDED,
	CINSTATE_FLUSHED,	//video will restart from beginning
} cinstates_t;
/*media playing system*/
qboolean Media_PlayFilm(char *name, qboolean enqueue);
qboolean Media_StopFilm(qboolean all);
struct cin_s *Media_StartCin(char *name);
texid_tf Media_UpdateForShader(cin_t *cin);
void Media_ShutdownCin(cin_t *cin);

//these accept NULL for cin to mean the current fullscreen video
void Media_Send_Command(cin_t *cin, const char *command);
void Media_Send_MouseMove(cin_t *cin, float x, float y);
void Media_Send_Resize(cin_t *cin, int x, int y);
void Media_Send_GetSize(cin_t *cin, int *x, int *y, float *aspect);
void Media_Send_KeyEvent(cin_t *cin, int button, int unicode, int event);
void Media_Send_Reset(cin_t *cin);
void Media_SetState(cin_t *cin, cinstates_t newstate);
cinstates_t Media_GetState(cin_t *cin);
const char *Media_Send_GetProperty(cin_t *cin, const char *key);

#else
#define Media_PlayFilm(n,e) false
#define Media_StopFilm(a) (void)true
#endif

void Media_SaveTracks(vfsfile_t *outcfg);
void Media_Init(void);
qboolean Media_NamedTrack(const char *initialtrack, const char *looptrack);	//new background music interface
void Media_NumberedTrack(unsigned int initialtrack, unsigned int looptrack);				//legacy cd interface for protocols that only support numbered tracks.
void Media_EndedTrack(void);	//cd is no longer running, media code needs to pick a new track (cd track or faketrack)

void MVD_Interpolate(void);

int Stats_GetKills(int playernum);
int Stats_GetTKills(int playernum);
int Stats_GetDeaths(int playernum);
int Stats_GetTouches(int playernum);
int Stats_GetCaptures(int playernum);
qboolean Stats_HaveFlags(int mode);
qboolean Stats_HaveKills(void);
float Stats_GetLastOwnFrag(int seat, char *res, int reslen);
void VARGS Stats_Message(char *msg, ...) LIKEPRINTF(1);
qboolean Stats_ParsePrintLine(const char *line);
qboolean Stats_ParsePickups(const char *line);
void Stats_NewMap(void);
void Stats_Clear(void);
void Stats_Init(void);

//enum uploadfmt;
/*struct mediacallbacks_s
{	//functions provided by the engine/renderer, for faster/off-thread updates
	qboolean pbocanoffthread;
	qboolean (VARGS *PBOLock)(struct mediacallbacks_s *ctx, size_t width, size_t height, uploadfmt_t fmt, qboolean *lost);
	void (VARGS *PBOUpdate)(struct mediacallbacks_s *ctx, void *data, size_t width, size_t height, int stride);
	void (VARGS *PBOUnlock)(struct mediacallbacks_s *ctx);

	void (VARGS *AudioStream) (void *auddata, int rate, int frames, int channels, int width);

	void (VARGS *WorkQueue) (void *wctx, void (VARGS *callback)(void *data), void *data);
	void (VARGS *WorkSync)  (void *wctx, int *address, int oldvalue);	//blocks until the address changes. make sure you queued something that will change it from that value. oldvalue is present to avoid races. if you're reading the address then you should probably volatile it to avoid compiler opts reading it twice (fixme: needs a proper barrier).
};
*/
typedef struct
{
	size_t structsize;
	const char *drivername;
	void *(VARGS *createdecoder)(const char *name);
	qboolean (VARGS *decodeframe)(void *ctx, qboolean nosound, qboolean forcevideo, double mediatime, void (QDECL *uploadtexture)(void *ectx, uploadfmt_t fmt, int width, int height, void *data, void *palette), void *ectx);
	void (VARGS *shutdown)(void *ctx);
	void (VARGS *rewind)(void *ctx);

	//these are any interactivity functions you might want...
	void (VARGS *cursormove) (void *ctx, float posx, float posy);	//pos is 0-1
	void (VARGS *key) (void *ctx, int code, int unicode, int event);
	qboolean (VARGS *setsize) (void *ctx, int width, int height);
	void (VARGS *getsize) (void *ctx, int *width, int *height);
	void (VARGS *changestream) (void *ctx, const char *streamname);

	qboolean (VARGS *getproperty) (void *ctx, const char *field, char *out, size_t *outsize);	//if out is null, returns required buffer size. returns 0 on failure / buffer too small

//	void *(VARGS *createdecoderCB)(const char *name, struct mediacallbacks_s *callbacks);
} media_decoder_funcs_t;
typedef struct
{
	size_t structsize;
	const char *drivername;
	const char *description;
	const char *extensions;
	void *(VARGS *capture_begin) (char *streamname, int videorate, int width, int height, int *sndkhz, int *sndchannels, int *sndbits);
	void (VARGS *capture_video) (void *ctx, int frame, void *data, int stride, int width, int height, enum uploadfmt fmt);
	void (VARGS *capture_audio) (void *ctx, void *data, int bytes);
	void (VARGS *capture_end) (void *ctx);
} media_encoder_funcs_t;
extern struct plugin_s *currentplug;
qboolean Media_RegisterDecoder(struct plugin_s *plug, media_decoder_funcs_t *funcs);
qboolean Media_UnregisterDecoder(struct plugin_s *plug, media_decoder_funcs_t *funcs);
qboolean Media_RegisterEncoder(struct plugin_s *plug, media_encoder_funcs_t *funcs);
qboolean Media_UnregisterEncoder(struct plugin_s *plug, media_encoder_funcs_t *funcs);