/**

  * vim: set ts=4 :

  * =============================================================================

  * SourceMod

  * Copyright (C) 2004-2008 AlliedModders LLC.  All rights reserved.

  * =============================================================================

  *

  * This program is free software; you can redistribute it and/or modify it under

  * the terms of the GNU General Public License, version 3.0, as published by the

  * Free Software Foundation.

  * 

  * 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, see <http://www.gnu.org/licenses/>.

  *

  * As a special exception, AlliedModders LLC gives you permission to link the

  * code of this program (as well as its derivative works) to "Half-Life 2," the

  * "Source Engine," the "SourcePawn JIT," and any Game MODs that run on software

  * by the Valve Corporation.  You must obey the GNU General Public License in

  * all respects for all other code used.  Additionally, AlliedModders LLC grants

  * this exception to all derivative works.  AlliedModders LLC defines further

  * exceptions, found in LICENSE.txt (as of this writing, version JULY-31-2007),

  * or <http://www.sourcemod.net/license.php>.

  *

  * Version: $Id$

  */

 #ifndef _INCLUDE_SOURCEMOD_INTERFACE_IPLAYERHELPERS_H_

 #define _INCLUDE_SOURCEMOD_INTERFACE_IPLAYERHELPERS_H_

 /**

  * @file IPlayerHelpers.h

  * @brief Defines basic helper functions for Half-Life 2 clients

  */

 #include <IShareSys.h>

 #include <IAdminSystem.h>

 #define SMINTERFACE_PLAYERMANAGER_NAME		"IPlayerManager"

 #define SMINTERFACE_PLAYERMANAGER_VERSION	17

 struct edict_t;

 class IPlayerInfo;

 #define SM_REPLY_CONSOLE	0			/**< Reply to console. */

 #define SM_REPLY_CHAT		1			/**< Reply to chat. */

 namespace SourceMod

 {

 	/**

 	 * @brief Abstracts some Half-Life 2 and SourceMod properties about clients.

 	 */

 	class IGamePlayer

 	{

 	public:

 		/**

 		 * @brief Returns the player's name.

 		 *

 		 * @return		String containing the player's name,

 		 *				or NULL if unavailable.

 		 */

 		virtual const char *GetName() =0;

 		/**

 		 * @brief Returns the player's IP address.

 		 *

 		 * @return		String containing the player's IP address,

 		 *				or NULL if unavailable.

 		 */

 		virtual const char *GetIPAddress() =0;

 		/**

 		 * @brief Returns the player's authentication string.

 		 *

 		 * @param		validated	Check backend validation status.

 		 * @return		String containing the player's auth string.

 		 *				May be NULL if unavailable.

 		 */

 		virtual const char *GetAuthString(bool validated = true) =0;

 		/**

 		 * @brief Returns the player's edict_t structure.

 		 *

 		 * @return		edict_t pointer, or NULL if unavailable.

 		 */

 		virtual edict_t *GetEdict() =0;

 		/**

 		 * @brief Returns whether the player is in game (putinserver).

 		 *

 		 * @return		True if in game, false otherwise.

 		 */

 		virtual bool IsInGame() =0;

 		/**

 		 * @brief Returns whether the player is connected.

 		 *

 		 * Note: If this returns true, all above functions except for

 		 * GetAuthString() should return non-NULL results.

 		 *

 		 * @return		True if connected, false otherwise.

 		 */

 		virtual bool IsConnected() =0;

 		/**

 		 * @brief Returns whether the player is a fake client.

 		 *

 		 * @return		True if a fake client, false otherwise.

 		 */

 		virtual bool IsFakeClient() =0;

 		/**

 		 * @brief Returns the client's AdminId, if any.

 		 *

 		 * @return		AdminId, or INVALID_ADMIN_ID if none.

 		 */

 		virtual AdminId GetAdminId() =0;

 		/**

 		 * @brief Sets the client's AdminId.

 		 *

 		 * @param id	AdminId to set.

 		 * @param temp	If true, the id will be invalidated on disconnect.

 		 */

 		virtual void SetAdminId(AdminId id, bool temp) =0;

 		/**

 		 * @brief Returns the client's userid.

 		 *

 		 * @return		Userid.

 		 */

 		virtual int GetUserId() =0;

 		/**

 		 * @brief Returns the client's language id.

 		 *

 		 * @return		Language id.

 		 */

 		virtual unsigned int GetLanguageId() =0;

 		/**

 		 * @brief Returns a player's IPlayerInfo object, if any.

 		 *

 		 * @return		IPlayerInfo pointer, or NULL if none.

 		 */

 		virtual IPlayerInfo *GetPlayerInfo() =0;

 		/**

 		 * @brief Runs through Core's admin authorization checks.  If the 

 		 * client is already an admin, no checks are performed.  

 		 *

 		 * Note that this function operates solely against the in-memory admin 

 		 * cache.  It will check steamids, IPs, names, and verify a password 

 		 * if one exists.  To implement other authentication schemes, simply 

 		 * don't call this function and use IGamePlayer::SetAdminId() instead.

 		 *

 		 * @return				True if access changed, false otherwise.

 		 */

 		virtual bool RunAdminCacheChecks() =0;

 		/**

 		 * @brief Notifies all listeners that the client has completed 

 		 * all of your post-connection (in-game, auth, admin) checks.  

 		 *

 		 * If you returned "false" from OnClientPreAdminCheck(), you must 

 		 * ALWAYS manually invoke this function, even if RunAdminCacheChecks() 

 		 * failed or you did not assign an AdminId.  Failure to call this 

 		 * function could result in plugins (such as reservedslots) not 

 		 * working properly.

 		 *

 		 * If you are implementing asynchronous fetches, and the client 

 		 * disconnects during your fetching process, you should make sure to 

 		 * recognize that case and not call this function.  That is, do not 

 		 * call this function on mismatched PreCheck calls, or on disconnected 

 		 * clients.  A good way to check this is to pass userids around, which 

 		 * are unique per client connection.

 		 *

 		 * Calling this has no effect if it has already been called on the 

 		 * given client (thus it is safe for multiple asynchronous plugins to 

 		 * call it at various times).

 		 */

 		virtual void NotifyPostAdminChecks() =0;

 		/**

 		 * @brief Returns the clients unique serial identifier.

 		 *

 		 * @return	Serial number.

 		 */

 		virtual unsigned int GetSerial() =0;

 		/**

 		 * @brief Return whether the client is authorized.

 		 *

 		 * @return		True if authorized, false otherwise.

 		 */

 		virtual bool IsAuthorized() =0;

 		/**

 		 * @brief Kicks the client with a message

 		 *

 		 * @param message   The message shown to the client when kicked

 		 */

 		virtual void Kick(const char *message) =0;

 		/**

 		 * @brief Returns whether the client is marked as being in the kick

 		 * queue. The client doesn't necessarily have to be in the actual kick

 		 * queue for this function to return true.

 		 *

 		 * @return      True if in the kick queue, false otherwise.

 		 */

 		virtual bool IsInKickQueue() =0;

 		/**

 		 * @brief Marks the client as being in the kick queue. They are not

 		 * actually added to the kick queue. Use IGameHelpers::AddDelayedKick()

 		 * to actually add them to the queue.

 		 */

 		virtual void MarkAsBeingKicked() =0;

 		virtual void SetLanguageId(unsigned int id) =0;

 		/**

 		 * @brief Returns whether the player is the SourceTV bot.

 		 *

 		 * @return		True if the SourceTV bot, false otherwise.

 		 */

 		virtual bool IsSourceTV() const =0;

 		/**

 		 * @brief Returns whether the player is the Replay bot.

 		 *

 		 * @return		True if the Replay bot, false otherwise.

 		 */

 		virtual bool IsReplay() const =0;

 		/**

 		 * @brief Returns the client's Steam account ID.

 		 *

 		 * @param validated		Check backend validation status.

 		 * 

 		 * @return			Steam account ID or 0 if not available.

 		 */

 		virtual unsigned int GetSteamAccountID(bool validated = true) =0;

 	};

 	/**

 	 * @brief Provides callbacks for important client events.

 	 */

 	class IClientListener

 	{

 	public:

 	   /**

 		* @brief Returns the current client listener version.

 		*

 		* @return		Client listener version.

 		*/

 		virtual unsigned int GetClientListenerVersion()

 		{

 			return SMINTERFACE_PLAYERMANAGER_VERSION;

 		}

 	public:

 		/**

 		 * @brief Called when a client requests connection.

 		 *

 		 * @param client		Index of the client.

 		 * @param error			Error buffer for a disconnect reason.

 		 * @param maxlength		Maximum length of error buffer.

 		 * @return				True to allow client, false to reject.

 		 */

 		virtual bool InterceptClientConnect(int client, char *error, size_t maxlength)

 		{

 			return true;

 		}

 		/**

 		 * @brief Called when a client has connected.

 		 *

 		 * @param client		Index of the client.

 		 */

 		virtual void OnClientConnected(int client)

 		{

 		}

 		/**

 		 * @brief Called when a client is put in server.

 		 *

 		 * @param client		Index of the client.

 		 */

 		virtual void OnClientPutInServer(int client)

 		{

 		}

 		/**

 		 * @brief Called when a client is disconnecting (not fully disconnected yet).

 		 *

 		 * @param client		Index of the client.

 		 */

 		virtual void OnClientDisconnecting(int client)

 		{

 		}

 		/**

 		 * @brief Called when a client has fully disconnected.

 		 *

 		 * @param client		Index of the client.

 		 */

 		virtual void OnClientDisconnected(int client)

 		{

 		}

 		/**

 		 * @brief Called when a client has received authorization.

 		 *

 		 * @param client		Index of the client.

 		 * @param authstring	Authorization string.

 		 */

 		virtual void OnClientAuthorized(int client, const char *authstring)

 		{

 		}

 		/**

 		 * @brief Called when the server is activated.

 		 */

 		virtual void OnServerActivated(int max_clients)

 		{

 		}

 		/**

 		 * @brief Called once a client is authorized and fully in-game, but 

 		 * before admin checks are done.  This can be used to override the 

 		 * default admin checks for a client.

 		 *

 		 * By default, this function allows the authentication process to 

 		 * continue as normal.  If you need to delay the cache searching 

 		 * process in order to get asynchronous data, then return false here. 

 		 *

 		 * If you return false, you must call IPlayerManager::NotifyPostAdminCheck 

 		 * for the same client, or else the OnClientPostAdminCheck callback will 

 		 * never be called.

 		 *

 		 * @param client		Client index.

 		 * @return				True to continue normally, false to override 

 		 *						the authentication process.

 		 */

 		virtual bool OnClientPreAdminCheck(int client)

 		{

 			return true;

 		}

 		/**

 		 * @brief Called once a client is authorized and fully in-game, and 

 		 * after all post-connection authorizations have been passed.  If the 

 		 * client does not have an AdminId by this stage, it means that no 

 		 * admin entry was in the cache that matched, and the user could not 

 		 * be authenticated as an admin.

 		 *

 		 * @param client		Client index.

 		 */

 		virtual void OnClientPostAdminCheck(int client)

 		{

 		}

 		/**

 		* @brief Notifies the extension that the maxplayers value has changed

 		*

 		* @param newvalue			New maxplayers value.

 		*/

 		virtual void OnMaxPlayersChanged(int newvalue)

 		{

 		}

 		/**

 		* @brief Notifies the extension that a clients settings changed

 		*

 		* @param client			Client index.

 		*/

 		virtual void OnClientSettingsChanged(int client)

 		{

 		}

 	};

 	#define COMMAND_FILTER_ALIVE		(1<<0)		/**< Only allow alive players */

 	#define COMMAND_FILTER_DEAD			(1<<1)		/**< Only filter dead players */

 	#define COMMAND_FILTER_CONNECTED	(1<<2)		/**< Allow players not fully in-game */

 	#define COMMAND_FILTER_NO_IMMUNITY	(1<<3)		/**< Ignore immunity rules */

 	#define COMMAND_FILTER_NO_MULTI		(1<<4)		/**< Do not allow multiple target patterns */

 	#define COMMAND_FILTER_NO_BOTS		(1<<5)		/**< Do not allow bots to be targetted */

 	#define COMMAND_TARGET_VALID		1			/**< Client passed the filter */

 	#define COMMAND_TARGET_NONE			0			/**< No target was found */

 	#define COMMAND_TARGET_NOT_ALIVE	-1			/**< Single client is not alive */

 	#define COMMAND_TARGET_NOT_DEAD		-2			/**< Single client is not dead */

 	#define COMMAND_TARGET_NOT_IN_GAME	-3			/**< Single client is not in game */

 	#define COMMAND_TARGET_IMMUNE		-4			/**< Single client is immune */

 	#define COMMAND_TARGET_EMPTY_FILTER	-5			/**< A multi-filter (such as @all) had no targets */

 	#define COMMAND_TARGET_NOT_HUMAN	-6			/**< Target was not human */

 	#define COMMAND_TARGET_AMBIGUOUS	-7			/**< Partial name had too many targets */

 	#define COMMAND_TARGETNAME_RAW		0			/**< Target name is a raw string */

 	#define COMMAND_TARGETNAME_ML		1			/**< Target name is a multi-lingual phrase */

 	/**

 	 * @brief Holds the many command target info parameters.

 	 */

 	struct cmd_target_info_t

 	{

 		const char *pattern;			/**< IN: Target pattern string. */

 		int admin;						/**< IN: Client admin index, or 0 if server .*/

 		cell_t *targets;				/**< IN: Array to store targets. */

 		cell_t max_targets;				/**< IN: Max targets (always >= 1) */

 		int flags;						/**< IN: COMMAND_FILTER flags. */

 		char *target_name;				/**< OUT: Buffer to store target name. */

 		size_t target_name_maxlength;	/**< IN: Maximum length of the target name buffer. */

 		int target_name_style;			/**< OUT: Target name style (COMMAND_TARGETNAME) */

 		int reason;						/**< OUT: COMMAND_TARGET reason. */

 		unsigned int num_targets;		/**< OUT: Number of targets. */

 	};

 	/**

 	 * @brief Intercepts a command target operation.

 	 */

 	class ICommandTargetProcessor

 	{

 	public:

 		/**

 		 * @brief Must process the command target and return a COMMAND_TARGET value.

 		 *

 		 * @param info			Struct containing command target information.

 		 *						Any members labelled OUT must be filled if processing 

 		 *						is to be completed (i.e. true returned).

 		 * @return				True to end processing, false to let Core continue.

 		 */

 		virtual bool ProcessCommandTarget(cmd_target_info_t *info) =0;

 	};

 	class IPlayerManager : public SMInterface

 	{

 	public:

 		const char *GetInterfaceName()

 		{

 			return SMINTERFACE_PLAYERMANAGER_NAME;

 		}

 		unsigned int GetInterfaceVersion()

 		{

 			return SMINTERFACE_PLAYERMANAGER_VERSION;

 		}

 	public:

 		/**

 		 * @brief Adds a client listener.

 		 *

 		 * @param listener		Pointer to an IClientListener.

 		 */

 		virtual void AddClientListener(IClientListener *listener) =0;

 		/**

 		 * @brief Removes a client listener.

 		 *

 		 * @param listener		Pointer to an IClientListener.

 		 */

 		virtual void RemoveClientListener(IClientListener *listener) =0;

 		/**

 		 * @brief Retrieves an IGamePlayer object by its client index.

 		 *

 		 * Note: This will return a valid object for any player, connected or not.

 		 * Note: Client indexes start at 1, not 0.

 		 *

 		 * @param client		Index of the client.

 		 * @return				An IGamePlayer pointer, or NULL if out of range.

 		 */

 		virtual IGamePlayer *GetGamePlayer(int client) =0;

 		/**

 		 * @brief Retrieves an IGamePlayer object by its edict_t pointer.

 		 *

 		 * @param pEdict		Index of the client

 		 * @return				An IGamePlayer pointer, or NULL if out of range.

 		 */

 		virtual IGamePlayer *GetGamePlayer(edict_t *pEdict) =0;

 		/**

 		 * @brief Returns the maximum number of clients.

 		 *

 		 * Note: this will not work until the server is activated.

 		 *

 		 * @return				Maximum number of clients.

 		 */

 		virtual int GetMaxClients() =0;

 		/**

 		 * @brief Returns the number of players currently connected.

 		 *

 		 * @return				Current number of connected clients.

 		 */

 		virtual int GetNumPlayers() =0;

 		/**

 		 * @brief Returns the client index by its userid.

 		 *

 		 * @param userid		Userid of the client.

 		 * @return				Client index, or 0 if invalid userid passed.

 		 */

 		virtual int GetClientOfUserId(int userid) =0;

 		/**

 		 * @brief Returns whether or not the server is activated.

 		 *

 		 * @return				True if ServerActivate() has been called

 		 *						at least once, false otherwise.

 		 */

 		virtual bool IsServerActivated() =0;

 		/**

 		 * @brief Gets SourceMod's reply source.

 		 *

 		 * @return				ReplyTo source.

 		 */

 		virtual unsigned int GetReplyTo() =0;

 		/**

 		 * @brief Sets SourceMod's reply source.

 		 *

 		 * @param reply			Reply source.

 		 * @return				Old reply source.

 		 */

 		virtual unsigned int SetReplyTo(unsigned int reply) =0;

 		/**

 		 * @brief Tests if a player meets command filtering rules.

 		 *

 		 * @param pAdmin		IGamePlayer of the admin, or NULL if the server. 

 		 * @param pTarget		IGamePlayer of the player being targeted.

 		 * @param flags			COMMAND_FILTER flags.

 		 * @return				COMMAND_TARGET value.

 		 */

 		virtual int FilterCommandTarget(IGamePlayer *pAdmin, IGamePlayer *pTarget, int flags) =0;

 		/**

 		 * @brief Registers a command target processor.

 		 *

 		 * @param pHandler		Pointer to an ICommandTargetProcessor instance.

 		 */

 		virtual void RegisterCommandTargetProcessor(ICommandTargetProcessor *pHandler) =0;

 		/**

 		 * @brief Removes a command target processor.

 		 *

 		 * @param pHandler		Pointer to an ICommandTargetProcessor instance.

 		 */

 		virtual void UnregisterCommandTargetProcessor(ICommandTargetProcessor *pHandler) =0;

 		/**

 		 * @brief Returns the client index by its serial number.

 		 *

 		 * @return				Client index, or 0 for invalid serial.

 		 */

 		virtual int GetClientFromSerial(unsigned int serial) =0;

 		/**

 		 * @brief Processes the pattern inside a cmd_target_info_t structure

 		 * and outputs the clients that match it.

 		 *

 		 * @param info			Pointer to the cmd_target_info_t structure to process.

 		 */

 		virtual void ProcessCommandTarget(cmd_target_info_t *info) =0;

 	};

 }

 #endif //_INCLUDE_SOURCEMOD_INTERFACE_IPLAYERHELPERS_H_