qc/d3xp/MultiplayerGame.h

/*
===========================================================================

Doom 3 GPL Source Code
Copyright (C) 1999-2011 id Software LLC, a ZeniMax Media company. 

This file is part of the Doom 3 GPL Source Code (?Doom 3 Source Code?).  

Doom 3 Source Code 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 3 of the License, or
(at your option) any later version.

Doom 3 Source Code 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 Doom 3 Source Code.  If not, see <http://www.gnu.org/licenses/>.

In addition, the Doom 3 Source Code is also subject to certain additional terms. You should have received a copy of these additional terms immediately following the terms and conditions of the GNU General Public License which accompanied the Doom 3 Source Code.  If not, please request a copy in writing from id Software at the address below.

If you have questions concerning this license or the applicable additional terms, you may contact in writing id Software LLC, c/o ZeniMax Media Inc., Suite 120, Rockville, Maryland 20850 USA.

===========================================================================
*/

#ifndef __MULTIPLAYERGAME_H__
#define	__MULTIPLAYERGAME_H__

/*
===============================================================================

	Basic DOOM multiplayer

===============================================================================
*/

class idPlayer;

#ifdef CTF
class idItemTeam;
#endif


typedef enum {
	GAME_SP = 0,
	GAME_DM,
	GAME_TOURNEY,
	GAME_TDM,
	GAME_LASTMAN,
#ifdef CTF
    GAME_CTF,
	GAME_COUNT,
#endif
} gameType_t;

#ifdef CTF

// Used by the UI
typedef enum {
    FLAGSTATUS_INBASE = 0,
    FLAGSTATUS_TAKEN  = 1,
    FLAGSTATUS_STRAY  = 2,
    FLAGSTATUS_NONE   = 3
} flagStatus_t;

#endif


typedef enum {
		PLAYER_VOTE_NONE,
		PLAYER_VOTE_NO,
		PLAYER_VOTE_YES,
		PLAYER_VOTE_WAIT	// mark a player allowed to vote
} playerVote_t;

typedef struct mpPlayerState_s {
	int				ping;			// player ping
	int				fragCount;		// kills
	int				teamFragCount;	// team kills
	int				wins;			// wins
	playerVote_t	vote;			// player's vote
	bool			scoreBoardUp;	// toggle based on player scoreboard button, used to activate de-activate the scoreboard gui
	bool			ingame;
} mpPlayerState_t;

const int NUM_CHAT_NOTIFY	= 5;
const int CHAT_FADE_TIME	= 400;
const int FRAGLIMIT_DELAY	= 2000;

const int MP_PLAYER_MINFRAGS = -100;
#ifdef CTF
const int MP_PLAYER_MAXFRAGS = 400;	// in CTF frags are player points
#else
const int MP_PLAYER_MAXFRAGS = 100;
#endif
const int MP_PLAYER_MAXWINS	= 100;
const int MP_PLAYER_MAXPING	= 999;

#ifdef CTF
const int MP_CTF_MAXPOINTS = 25;
#endif

typedef struct mpChatLine_s {
	idStr			line;
	short			fade;			// starts high and decreases, line is removed once reached 0
} mpChatLine_t;

typedef enum {
	SND_YOUWIN = 0,
	SND_YOULOSE,
	SND_FIGHT,
	SND_VOTE,
	SND_VOTE_PASSED,
	SND_VOTE_FAILED,
	SND_THREE,
	SND_TWO,
	SND_ONE,
	SND_SUDDENDEATH,
#ifdef CTF	
	SND_FLAG_CAPTURED_YOURS,
	SND_FLAG_CAPTURED_THEIRS,
	SND_FLAG_RETURN,
	SND_FLAG_TAKEN_YOURS,
	SND_FLAG_TAKEN_THEIRS,
	SND_FLAG_DROPPED_YOURS,
	SND_FLAG_DROPPED_THEIRS,
#endif
	SND_COUNT
} snd_evt_t;

class idMultiplayerGame {
public:

					idMultiplayerGame();

	void			Shutdown( void );

	// resets everything and prepares for a match
	void			Reset( void );

	// setup local data for a new player
	void			SpawnPlayer( int clientNum );

	// checks rules and updates state of the mp game
	void			Run( void );

	// draws mp hud, scoredboard, etc.. 
	bool			Draw( int clientNum );

	// updates a player vote
	void			PlayerVote( int clientNum, playerVote_t vote );

	// updates frag counts and potentially ends the match in sudden death
	void			PlayerDeath( idPlayer *dead, idPlayer *killer, bool telefrag );

	void			AddChatLine( const char *fmt, ... ) id_attribute((format(printf,2,3)));

	void			UpdateMainGui( void );
	idUserInterface*StartMenu( void );
	const char*		HandleGuiCommands( const char *menuCommand );
	void			SetMenuSkin( void );

	void			WriteToSnapshot( idBitMsgDelta &msg ) const;
	void			ReadFromSnapshot( const idBitMsgDelta &msg );

	// game state
	typedef enum {
		INACTIVE = 0,						// not running
		WARMUP,								// warming up
		COUNTDOWN,							// post warmup pre-game
		GAMEON,								// game is on
		SUDDENDEATH,						// game is on but in sudden death, first frag wins
		GAMEREVIEW,							// game is over, scoreboard is up. we wait si_gameReviewPause seconds (which has a min value)
		NEXTGAME,
		STATE_COUNT
	} gameState_t;
	static const char *GameStateStrings[ STATE_COUNT ];
	idMultiplayerGame::gameState_t		GetGameState( void ) const;

	static const char *GlobalSoundStrings[ SND_COUNT ];
	void			PlayGlobalSound( int to, snd_evt_t evt, const char *shader = NULL );
#ifdef CTF
	void			PlayTeamSound( int toTeam, snd_evt_t evt, const char *shader = NULL );	// sound that's sent only to member of toTeam team
#endif

	// more compact than a chat line
	typedef enum {
		MSG_SUICIDE = 0,
		MSG_KILLED,
		MSG_KILLEDTEAM,
		MSG_DIED,
		MSG_VOTE,
		MSG_VOTEPASSED,
		MSG_VOTEFAILED,
		MSG_SUDDENDEATH,
		MSG_FORCEREADY,
		MSG_JOINEDSPEC,
		MSG_TIMELIMIT,
		MSG_FRAGLIMIT,
		MSG_TELEFRAGGED,
		MSG_JOINTEAM,
		MSG_HOLYSHIT,
#ifdef CTF
		MSG_POINTLIMIT,

		MSG_FLAGTAKEN,
		MSG_FLAGDROP,
		MSG_FLAGRETURN,
		MSG_FLAGCAPTURE,
		MSG_SCOREUPDATE,

#endif
		MSG_COUNT
	} msg_evt_t;
	void			PrintMessageEvent( int to, msg_evt_t evt, int parm1 = -1, int parm2 = -1 );

	void			DisconnectClient( int clientNum );
	static void		ForceReady_f( const idCmdArgs &args );
	static void		DropWeapon_f( const idCmdArgs &args );
	static void		MessageMode_f( const idCmdArgs &args );
	static void		VoiceChat_f( const idCmdArgs &args );
	static void		VoiceChatTeam_f( const idCmdArgs &args );

	typedef enum {
		VOTE_RESTART = 0,
		VOTE_TIMELIMIT,
		VOTE_FRAGLIMIT,
		VOTE_GAMETYPE,
		VOTE_KICK,
		VOTE_MAP,
		VOTE_SPECTATORS,
		VOTE_NEXTMAP,
		VOTE_COUNT,
		VOTE_NONE
	} vote_flags_t;

	typedef enum {
		VOTE_UPDATE,
		VOTE_FAILED,
		VOTE_PASSED,	// passed, but no reset yet
		VOTE_ABORTED,
		VOTE_RESET		// tell clients to reset vote state
	} vote_result_t;

	static void		Vote_f( const idCmdArgs &args );
	static void		CallVote_f( const idCmdArgs &args );
	void			ClientCallVote( vote_flags_t voteIndex, const char *voteValue );
	void			ServerCallVote( int clientNum, const idBitMsg &msg );
	void			ClientStartVote( int clientNum, const char *voteString );
	void			ServerStartVote( int clientNum, vote_flags_t voteIndex, const char *voteValue );
	void			ClientUpdateVote( vote_result_t result, int yesCount, int noCount );
	void			CastVote( int clientNum, bool vote );
	void			ExecuteVote( void );

	void			WantKilled( int clientNum );
	int				NumActualClients( bool countSpectators, int *teamcount = NULL );
	void			DropWeapon( int clientNum );
	void			MapRestart( void );
	// called by idPlayer whenever it detects a team change (init or switch)
	void			SwitchToTeam( int clientNum, int oldteam, int newteam );
	bool			IsPureReady( void ) const;
	void			ProcessChatMessage( int clientNum, bool team, const char *name, const char *text, const char *sound );
	void			ProcessVoiceChat( int clientNum, bool team, int index );

	void			Precache( void );
	
	// throttle UI switch rates
	void			ThrottleUserInfo( void );
	void			ToggleSpectate( void );
	void			ToggleReady( void );
	void			ToggleTeam( void );

	void			ClearFrags( int clientNum );

	void			EnterGame( int clientNum );
	bool			CanPlay( idPlayer *p );
	bool			IsInGame( int clientNum );
	bool			WantRespawn( idPlayer *p );

	void			ServerWriteInitialReliableMessages( int clientNum );
	void			ClientReadStartState( const idBitMsg &msg );
	void			ClientReadWarmupTime( const idBitMsg &msg );

	void			ServerClientConnect( int clientNum );
#ifdef CTF    
    void            ClearHUDStatus( void );
    int             GetFlagPoints( int team );	// Team points in CTF
	void			SetFlagMsg( bool b );		// allow flag event messages to be sent
	bool			IsFlagMsgOn( void );		// should flag event messages go through?
    void			ClearGuis( void );

    int             player_red_flag;            // Ent num of red flag carrier for HUD    
    int             player_blue_flag;           // Ent num of blue flag carrier for HUD

#endif     
	void			PlayerStats( int clientNum, char *data, const int len );

private:
	static const char	*MPGuis[];
	static const char	*ThrottleVars[];
	static const char	*ThrottleVarsInEnglish[];
	static const int	ThrottleDelay[];

	// state vars
	gameState_t		gameState;				// what state the current game is in
	gameState_t		nextState;				// state to switch to when nextStateSwitch is hit
	int				pingUpdateTime;			// time to update ping

	mpPlayerState_t	playerState[ MAX_CLIENTS ];

											// keep track of clients which are willingly in spectator mode

	// vote vars
	vote_flags_t	vote;					// active vote or VOTE_NONE
	int				voteTimeOut;			// when the current vote expires
	int				voteExecTime;			// delay between vote passed msg and execute
	float			yesVotes;				// counter for yes votes
	float			noVotes;				// and for no votes
	idStr			voteValue;				// the data voted upon ( server )
	idStr			voteString;				// the vote string ( client )
	bool			voted;					// hide vote box ( client )
	int				kickVoteMap[ MAX_CLIENTS ];

	// time related
	int				nextStateSwitch;		// time next state switch
	int				warmupEndTime;			// warmup till..
	int				matchStartedTime;		// time current match started

	// tourney
	int				currentTourneyPlayer[2];// our current set of players
	int				lastWinner;				// plays again

	// warmup
	idStr			warmupText;				// text shown in warmup area of screen
	bool			one, two, three;		// keeps count down voice from repeating

	// guis
	idUserInterface *scoreBoard;			// scoreboard
	idUserInterface *spectateGui;			// spectate info
	idUserInterface *guiChat;				// chat text
	idUserInterface *mainGui;				// ready / nick / votes etc.
	idListGUI		*mapList;
	idUserInterface *msgmodeGui;			// message mode
	int				currentMenu;			// 0 - none, 1 - mainGui, 2 - msgmodeGui
	int				nextMenu;				// if 0, will do mainGui
	bool			bCurrentMenuMsg;		// send menu state updates to server

	// chat data
	mpChatLine_t	chatHistory[ NUM_CHAT_NOTIFY ];
	int				chatHistoryIndex;
	int				chatHistorySize;		// 0 <= x < NUM_CHAT_NOTIFY
	bool			chatDataUpdated;
	int				lastChatLineTime;

	// rankings are used by UpdateScoreboard and UpdateHud
	int				numRankedPlayers;		// ranked players, others may be empty slots or spectators
	idPlayer *		rankedPlayers[MAX_CLIENTS];

	bool			pureReady;				// defaults to false, set to true once server game is running with pure checksums
	int				fragLimitTimeout;

	int				switchThrottle[ 3 ];
	int				voiceChatThrottle;

	gameType_t		lastGameType;			// for restarts
	int				startFragLimit;			// synchronize to clients in initial state, set on -> GAMEON

#ifdef CTF
	idItemTeam *	teamFlags[ 2 ];
	int				teamPoints[ 2 ];

	bool			flagMsgOn;

	const char *	gameTypeVoteMap[ GAME_COUNT ];
#endif

private:
	void			UpdatePlayerRanks();

	// updates the passed gui with current score information
	void			UpdateRankColor( idUserInterface *gui, const char *mask, int i, const idVec3 &vec );
	void			UpdateScoreboard( idUserInterface *scoreBoard, idPlayer *player );
#ifdef CTF    
	void			UpdateCTFScoreboard( idUserInterface *scoreBoard, idPlayer *player );    
#endif

#ifndef CTF
    // We declare this publically above so we can call it during a map restart.
	void			ClearGuis( void );
#endif    
    
	void			DrawScoreBoard( idPlayer *player );
	void			UpdateHud( idPlayer *player, idUserInterface *hud );
	bool			Warmup( void );
	void			CheckVote( void );
	bool			AllPlayersReady( void );
	idPlayer *		FragLimitHit( void );
	idPlayer *		FragLeader( void );
	bool			TimeLimitHit( void );
#ifdef CTF
	bool			PointLimitHit( void );
	// return team with most points
	int				WinningTeam( void );
#endif
	void			NewState( gameState_t news, idPlayer *player = NULL );
	void			UpdateWinsLosses( idPlayer *winner );
	// fill any empty tourney slots based on the current tourney ranks
	void			FillTourneySlots( void );
	void			CycleTourneyPlayers( void );
	// walk through the tourneyRank to build a wait list for the clients
	void			UpdateTourneyLine( void );
	const char *	GameTime( void );
	void			Clear( void );
	bool			EnoughClientsToPlay( void );
	void			ClearChatData( void );
	void			DrawChat( void );
	// go through the clients, and see if they want to be respawned, and if the game allows it
	// called during normal gameplay for death -> respawn cycles
	// and for a spectator who want back in the game (see param)
	void			CheckRespawns( idPlayer *spectator = NULL );
	void			ForceReady();
	// when clients disconnect or join spectate during game, check if we need to end the game
	void			CheckAbortGame( void );
	void			MessageMode( const idCmdArgs &args );
	void			DisableMenu( void );
	void			SetMapShot( void );
	// scores in TDM
	void			TeamScore( int entityNumber, int team, int delta );
	void			VoiceChat( const idCmdArgs &args, bool team );
	void			DumpTourneyLine( void );
	void			SuddenRespawn( void );

#ifdef CTF
	void			FindTeamFlags( void );
#endif
   
public:

#ifdef CTF    
	idItemTeam *	GetTeamFlag( int team );
    flagStatus_t    GetFlagStatus( int team );
	void			TeamScoreCTF( int team, int delta );
	void			PlayerScoreCTF( int playerIdx, int delta );
	// returns entityNum to team flag carrier, -1 if no flag carrier
	int				GetFlagCarrier( int team );
    void            UpdateScoreboardFlagStatus( void );
	
	void			SetBestGametype( const char * map );
	void			ReloadScoreboard();
#endif

#ifdef _D3XP
	idStr			GetBestGametype( const char* map, const char* gametype );
#endif

/* #ifdef CTF ... merge the below IsGametypeFlagBased */
bool            IsGametypeFlagBased( void );
bool            IsGametypeTeamBased( void );
/* #endif CTF */
    
};

ID_INLINE idMultiplayerGame::gameState_t idMultiplayerGame::GetGameState( void ) const {
	return gameState;
}

ID_INLINE bool idMultiplayerGame::IsPureReady( void ) const {
	return pureReady;
}

ID_INLINE void idMultiplayerGame::ClearFrags( int clientNum ) {
	playerState[ clientNum ].fragCount = 0;
}

ID_INLINE bool idMultiplayerGame::IsInGame( int clientNum ) {
	return playerState[ clientNum ].ingame;
}

#endif	/* !__MULTIPLAYERGAME_H__ */