Backups/hl2sdk
1
0
Fork 0
mirror of https://github.com/alliedmodders/hl2sdk.git synced 2024-12-23 01:59:43 +08:00
Code
4c27c1305c
hl2sdk/utils/serverplugin_sample/serverplugin_empty.cpp
Joe Ludwig e7d6f4c174 First version of the SOurce SDK 2013
2013-06-26 15:22:04 -07:00

923 lines
31 KiB
C++
Raw Blame History

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
// $NoKeywords: $
//
//===========================================================================//
#include <stdio.h>
//#define GAME_DLL
#ifdef GAME_DLL
#include "cbase.h"
#endif
#include <stdio.h>
#include "interface.h"
#include "filesystem.h"
#include "engine/iserverplugin.h"
#include "eiface.h"
#include "igameevents.h"
#include "convar.h"
#include "Color.h"
#include "vstdlib/random.h"
#include "engine/IEngineTrace.h"
#include "tier2/tier2.h"
#include "game/server/pluginvariant.h"
#include "game/server/iplayerinfo.h"
#include "game/server/ientityinfo.h"
#include "game/server/igameinfo.h"
//#define SAMPLE_TF2_PLUGIN
#ifdef SAMPLE_TF2_PLUGIN
#include "tf/tf_shareddefs.h"
#endif
// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"
// Interfaces from the engine
IVEngineServer *engine = NULL; // helper functions (messaging clients, loading content, making entities, running commands, etc)
IGameEventManager *gameeventmanager_ = NULL; // game events interface
#ifndef GAME_DLL
#define gameeventmanager gameeventmanager_
#endif
IPlayerInfoManager *playerinfomanager = NULL; // game dll interface to interact with players
IEntityInfoManager *entityinfomanager = NULL; // game dll interface to interact with all entities (like IPlayerInfo)
IGameInfoManager *gameinfomanager = NULL; // game dll interface to get data from game rules directly
IBotManager *botmanager = NULL; // game dll interface to interact with bots
IServerPluginHelpers *helpers = NULL; // special 3rd party plugin helpers from the engine
IUniformRandomStream *randomStr = NULL;
IEngineTrace *enginetrace = NULL;
CGlobalVars *gpGlobals = NULL;
// function to initialize any cvars/command in this plugin
void Bot_RunAll( void );
// useful helper func
#ifndef GAME_DLL
inline bool FStrEq(const char *sz1, const char *sz2)
{
return(Q_stricmp(sz1, sz2) == 0);
}
#endif
//---------------------------------------------------------------------------------
// Purpose: a sample 3rd party plugin class
//---------------------------------------------------------------------------------
class CEmptyServerPlugin: public IServerPluginCallbacks, public IGameEventListener
{
public:
CEmptyServerPlugin();
~CEmptyServerPlugin();
// IServerPluginCallbacks methods
virtual bool Load( CreateInterfaceFn interfaceFactory, CreateInterfaceFn gameServerFactory );
virtual void Unload( void );
virtual void Pause( void );
virtual void UnPause( void );
virtual const char *GetPluginDescription( void );
virtual void LevelInit( char const *pMapName );
virtual void ServerActivate( edict_t *pEdictList, int edictCount, int clientMax );
virtual void GameFrame( bool simulating );
virtual void LevelShutdown( void );
virtual void ClientActive( edict_t *pEntity );
virtual void ClientDisconnect( edict_t *pEntity );
virtual void ClientPutInServer( edict_t *pEntity, char const *playername );
virtual void SetCommandClient( int index );
virtual void ClientSettingsChanged( edict_t *pEdict );
virtual PLUGIN_RESULT ClientConnect( bool *bAllowConnect, edict_t *pEntity, const char *pszName, const char *pszAddress, char *reject, int maxrejectlen );
virtual PLUGIN_RESULT ClientCommand( edict_t *pEntity, const CCommand &args );
virtual PLUGIN_RESULT NetworkIDValidated( const char *pszUserName, const char *pszNetworkID );
virtual void OnQueryCvarValueFinished( QueryCvarCookie_t iCookie, edict_t *pPlayerEntity, EQueryCvarValueStatus eStatus, const char *pCvarName, const char *pCvarValue );
virtual void OnEdictAllocated( edict_t *edict );
virtual void OnEdictFreed( const edict_t *edict );
// IGameEventListener Interface
virtual void FireGameEvent( KeyValues * event );
virtual int GetCommandIndex() { return m_iClientCommandIndex; }
private:
int m_iClientCommandIndex;
};
//
// The plugin is a static singleton that is exported as an interface
//
CEmptyServerPlugin g_EmtpyServerPlugin;
EXPOSE_SINGLE_INTERFACE_GLOBALVAR(CEmptyServerPlugin, IServerPluginCallbacks, INTERFACEVERSION_ISERVERPLUGINCALLBACKS, g_EmtpyServerPlugin );
//---------------------------------------------------------------------------------
// Purpose: constructor/destructor
//---------------------------------------------------------------------------------
CEmptyServerPlugin::CEmptyServerPlugin()
{
m_iClientCommandIndex = 0;
}
CEmptyServerPlugin::~CEmptyServerPlugin()
{
}
//---------------------------------------------------------------------------------
// Purpose: called when the plugin is loaded, load the interface we need from the engine
//---------------------------------------------------------------------------------
bool CEmptyServerPlugin::Load( CreateInterfaceFn interfaceFactory, CreateInterfaceFn gameServerFactory )
{
ConnectTier1Libraries( &interfaceFactory, 1 );
ConnectTier2Libraries( &interfaceFactory, 1 );
entityinfomanager = (IEntityInfoManager *)gameServerFactory(INTERFACEVERSION_ENTITYINFOMANAGER,NULL);
if ( !entityinfomanager )
{
Warning( "Unable to load entityinfomanager, ignoring\n" ); // this isn't fatal, we just won't be able to access entity data
}
playerinfomanager = (IPlayerInfoManager *)gameServerFactory(INTERFACEVERSION_PLAYERINFOMANAGER,NULL);
if ( !playerinfomanager )
{
Warning( "Unable to load playerinfomanager, ignoring\n" ); // this isn't fatal, we just won't be able to access specific player data
}
botmanager = (IBotManager *)gameServerFactory(INTERFACEVERSION_PLAYERBOTMANAGER, NULL);
if ( !botmanager )
{
Warning( "Unable to load botcontroller, ignoring\n" ); // this isn't fatal, we just won't be able to access specific bot functions
}
gameinfomanager = (IGameInfoManager *)gameServerFactory(INTERFACEVERSION_GAMEINFOMANAGER, NULL);
if (!gameinfomanager)
{
Warning( "Unable to load gameinfomanager, ignoring\n" );
}
engine = (IVEngineServer*)interfaceFactory(INTERFACEVERSION_VENGINESERVER, NULL);
gameeventmanager = (IGameEventManager *)interfaceFactory(INTERFACEVERSION_GAMEEVENTSMANAGER,NULL);
helpers = (IServerPluginHelpers*)interfaceFactory(INTERFACEVERSION_ISERVERPLUGINHELPERS, NULL);
enginetrace = (IEngineTrace *)interfaceFactory(INTERFACEVERSION_ENGINETRACE_SERVER,NULL);
randomStr = (IUniformRandomStream *)interfaceFactory(VENGINE_SERVER_RANDOM_INTERFACE_VERSION, NULL);
// get the interfaces we want to use
if( ! ( engine && gameeventmanager && g_pFullFileSystem && helpers && enginetrace && randomStr ) )
{
return false; // we require all these interface to function
}
if ( playerinfomanager )
{
gpGlobals = playerinfomanager->GetGlobalVars();
}
MathLib_Init( 2.2f, 2.2f, 0.0f, 2.0f );
ConVar_Register( 0 );
return true;
}
//---------------------------------------------------------------------------------
// Purpose: called when the plugin is unloaded (turned off)
//---------------------------------------------------------------------------------
void CEmptyServerPlugin::Unload( void )
{
gameeventmanager->RemoveListener( this ); // make sure we are unloaded from the event system
ConVar_Unregister( );
DisconnectTier2Libraries( );
DisconnectTier1Libraries( );
}
//---------------------------------------------------------------------------------
// Purpose: called when the plugin is paused (i.e should stop running but isn't unloaded)
//---------------------------------------------------------------------------------
void CEmptyServerPlugin::Pause( void )
{
}
//---------------------------------------------------------------------------------
// Purpose: called when the plugin is unpaused (i.e should start executing again)
//---------------------------------------------------------------------------------
void CEmptyServerPlugin::UnPause( void )
{
}
//---------------------------------------------------------------------------------
// Purpose: the name of this plugin, returned in "plugin_print" command
//---------------------------------------------------------------------------------
const char *CEmptyServerPlugin::GetPluginDescription( void )
{
return "Emtpy-Plugin V2, Valve";
}
//---------------------------------------------------------------------------------
// Purpose: called on level start
//---------------------------------------------------------------------------------
void CEmptyServerPlugin::LevelInit( char const *pMapName )
{
Msg( "Level \"%s\" has been loaded\n", pMapName );
gameeventmanager->AddListener( this, true );
}
//---------------------------------------------------------------------------------
// Purpose: called on level start, when the server is ready to accept client connections
// edictCount is the number of entities in the level, clientMax is the max client count
//---------------------------------------------------------------------------------
void CEmptyServerPlugin::ServerActivate( edict_t *pEdictList, int edictCount, int clientMax )
{
}
//---------------------------------------------------------------------------------
// Purpose: called once per server frame, do recurring work here (like checking for timeouts)
//---------------------------------------------------------------------------------
void CEmptyServerPlugin::GameFrame( bool simulating )
{
if ( simulating )
{
Bot_RunAll();
}
}
//---------------------------------------------------------------------------------
// Purpose: called on level end (as the server is shutting down or going to a new map)
//---------------------------------------------------------------------------------
void CEmptyServerPlugin::LevelShutdown( void ) // !!!!this can get called multiple times per map change
{
gameeventmanager->RemoveListener( this );
}
//---------------------------------------------------------------------------------
// Purpose: called when a client spawns into a server (i.e as they begin to play)
//---------------------------------------------------------------------------------
void CEmptyServerPlugin::ClientActive( edict_t *pEntity )
{
}
//---------------------------------------------------------------------------------
// Purpose: called when a client leaves a server (or is timed out)
//---------------------------------------------------------------------------------
void CEmptyServerPlugin::ClientDisconnect( edict_t *pEntity )
{
}
//---------------------------------------------------------------------------------
// Purpose: called on
//---------------------------------------------------------------------------------
void CEmptyServerPlugin::ClientPutInServer( edict_t *pEntity, char const *playername )
{
KeyValues *kv = new KeyValues( "msg" );
kv->SetString( "title", "Hello" );
kv->SetString( "msg", "Hello there" );
kv->SetColor( "color", Color( 255, 0, 0, 255 ));
kv->SetInt( "level", 5);
kv->SetInt( "time", 10);
helpers->CreateMessage( pEntity, DIALOG_MSG, kv, this );
kv->deleteThis();
}
//---------------------------------------------------------------------------------
// Purpose: called on level start
//---------------------------------------------------------------------------------
void CEmptyServerPlugin::SetCommandClient( int index )
{
m_iClientCommandIndex = index;
}
void ClientPrint( edict_t *pEdict, char *format, ... )
{
va_list argptr;
static char string[1024];
va_start (argptr, format);
Q_vsnprintf(string, sizeof(string), format,argptr);
va_end (argptr);
engine->ClientPrintf( pEdict, string );
}
//---------------------------------------------------------------------------------
// Purpose: called on level start
//---------------------------------------------------------------------------------
void CEmptyServerPlugin::ClientSettingsChanged( edict_t *pEdict )
{
if ( playerinfomanager )
{
IPlayerInfo *playerinfo = playerinfomanager->GetPlayerInfo( pEdict );
const char * name = engine->GetClientConVarValue( engine->IndexOfEdict(pEdict), "name" );
// CAN'T use Q_stricmp here, this dll is made by 3rd parties and may not link to tier0/vstdlib
if ( playerinfo && name && playerinfo->GetName() &&
stricmp( name, playerinfo->GetName()) ) // playerinfo may be NULL if the MOD doesn't support access to player data
// OR if you are accessing the player before they are fully connected
{
ClientPrint( pEdict, "Your name changed to \"%s\" (from \"%s\"\n", name, playerinfo->GetName() );
// this is the bad way to check this, the better option it to listen for the "player_changename" event in FireGameEvent()
// this is here to give a real example of how to use the playerinfo interface
}
}
}
//---------------------------------------------------------------------------------
// Purpose: called when a client joins a server
//---------------------------------------------------------------------------------
PLUGIN_RESULT CEmptyServerPlugin::ClientConnect( bool *bAllowConnect, edict_t *pEntity, const char *pszName, const char *pszAddress, char *reject, int maxrejectlen )
{
return PLUGIN_CONTINUE;
}
CON_COMMAND( DoAskConnect, "Server plugin example of using the ask connect dialog" )
{
if ( args.ArgC() < 2 )
{
Warning ( "DoAskConnect <server IP>\n" );
}
else
{
const char *pServerIP = args.Arg( 1 );
KeyValues *kv = new KeyValues( "menu" );
kv->SetString( "title", pServerIP ); // The IP address of the server to connect to goes in the "title" field.
kv->SetInt( "time", 3 );
for ( int i=1; i < gpGlobals->maxClients; i++ )
{
edict_t *pEdict = engine->PEntityOfEntIndex( i );
if ( pEdict )
{
helpers->CreateMessage( pEdict, DIALOG_ASKCONNECT, kv, &g_EmtpyServerPlugin );
}
}
kv->deleteThis();
}
}
#ifdef SAMPLE_TF2_PLUGIN
const char *classNames[] =
{
"unknown",
"scout",
"sniper",
"soldier",
"demoman",
"medic",
"heavy weapons guy",
"pyro",
"spy",
"engineer",
};
bool TFPlayerHasCondition( int inBits, int condition )
{
Assert( condition >= 0 && condition < TF_COND_LAST );
return ( ( inBits & (1<<condition) ) != 0 );
}
void SentryStatus( edict_t *pEntity )
{
IPlayerInfo *playerinfo = playerinfomanager->GetPlayerInfo( pEntity );
if (!playerinfo)
{
Msg("couldn't get playerinfo\n");
return;
}
Msg("Sentry Status:\n");
pluginvariant value;
pluginvariant emptyVariant;
edict_t *pSentry = NULL;
if (playerinfo->GetCustomInfo(TFPLAYERINFO_ENTINDEX_SENTRY, value, emptyVariant))
{
pSentry = engine->PEntityOfEntIndex( value.Int() );
if (!pSentry)
{
Warning("couldn't attain sentry gun entity\n");
return;
}
}
else
{
Msg("No Sentrygun built.\n");
return;
}
IEntityInfo *entinfo = entityinfomanager->GetEntityInfo( pSentry );
if (!entinfo)
{
Warning("couldn't get entinfo for sentry gun\n");
return;
}
if (playerinfo->GetCustomInfo(TFPLAYERINFO_BUILDING_SENTRY, value, emptyVariant))
{
if (value.Bool())
Msg("Sentry Under Construction...\n");
}
if (playerinfo->GetCustomInfo(TFPLAYERINFO_UPGRADING_SENTRY, value, emptyVariant))
{
if (value.Bool())
Msg("Sentry Upgrading...\n");
}
int sentryLevel = 0;
if (playerinfo->GetCustomInfo(TFPLAYERINFO_SENTRY_LEVEL, value, emptyVariant))
{
sentryLevel = value.Int();
Msg("Sentry Level: %i\n", sentryLevel );
}
else
Msg("Unable to retrive sentry level\n");
if (playerinfo->GetCustomInfo(TFPLAYERINFO_SENTRY_PROGRESS, value, emptyVariant))
{
if (sentryLevel < 3)
{
int iMetal, iRequiredMetal;
iRequiredMetal = value.Int() & 0xFF;
iMetal = (value.Int()>>8) & 0xFF;
Msg("%i / %i Metal Required for Sentry Level %i\n", iMetal, iRequiredMetal, sentryLevel+1);
}
else
Msg("Sentry cannot be upgraded further.\n");
}
Msg("Health: %i\n", entinfo->GetHealth() );
if (playerinfo->GetCustomInfo(TFPLAYERINFO_SENTRY_KILLS, value, emptyVariant))
Msg("Kills: %i\n", value.Int() );
else
Msg("Unable to retrieve sentry kills\n");
if (playerinfo->GetCustomInfo(TFPLAYERINFO_SENTRY_AMMO_SHELLS, value, emptyVariant))
{
int iShells, iMaxShells;
iMaxShells = value.Int() & 0xFF;
iShells = (value.Int()>>8) & 0xFF;
Msg("Shells: %i / %i\n", iShells, iMaxShells);
}
if (sentryLevel > 2)
{
if (playerinfo->GetCustomInfo(TFPLAYERINFO_SENTRY_AMMO_ROCKETS, value, emptyVariant))
{
int iRockets, iMaxRockets;
iMaxRockets = value.Int() & 0xFF;
iRockets = (value.Int()>>8) & 0xFF;
Msg("Rockets: %i / %i\n", iRockets, iMaxRockets);
}
}
}
void DispenserStatus( edict_t *pEntity )
{
IPlayerInfo *playerinfo = playerinfomanager->GetPlayerInfo( pEntity );
if (!playerinfo)
{
Msg("couldn't get playerinfo\n");
return;
}
Msg("Dispenser Status:\n");
pluginvariant value;
pluginvariant emptyVariant;
edict_t *pDispenser = NULL;
if (playerinfo->GetCustomInfo(TFPLAYERINFO_ENTINDEX_DISPENSER, value, emptyVariant))
{
pDispenser = engine->PEntityOfEntIndex( value.Int() );
if (!pDispenser)
{
Warning("couldn't attain dispenser entity\n");
return;
}
}
else
{
Msg("No dispenser built.\n");
return;
}
IEntityInfo *entinfo = entityinfomanager->GetEntityInfo( pDispenser );
if (!entinfo)
{
Warning("couldn't get entinfo for dispenser\n");
return;
}
if (playerinfo->GetCustomInfo(TFPLAYERINFO_BUILDING_DISPENSER, value, emptyVariant))
{
if (value.Bool())
Msg("Dispenser Under Construction...\n");
}
Msg("Health: %i\n", entinfo->GetHealth() );
if (playerinfo->GetCustomInfo(TFPLAYERINFO_DISPENSER_METAL, value, emptyVariant))
Msg("Metal: %i\n", value.Int() );
}
void TeleporterStatus( edict_t *pEntity )
{
IPlayerInfo *playerinfo = playerinfomanager->GetPlayerInfo( pEntity );
if (!playerinfo)
{
Msg("couldn't get playerinfo\n");
return;
}
Msg("Teleporter Status:\n");
pluginvariant value;
pluginvariant emptyVariant;
edict_t *pEntrance = NULL;
edict_t *pExit = NULL;
if (playerinfo->GetCustomInfo(TFPLAYERINFO_ENTINDEX_TELEPORTER_ENTRANCE, value, emptyVariant))
{
pEntrance = engine->PEntityOfEntIndex( value.Int() );
if (!pEntrance)
{
Warning("couldn't attain entrance entity\n");
}
}
else
{
Msg("No Teleporter Entrance built.\n");
}
if (playerinfo->GetCustomInfo(TFPLAYERINFO_ENTINDEX_TELEPORTER_EXIT, value, emptyVariant))
{
pExit = engine->PEntityOfEntIndex( value.Int() );
if (!pExit)
{
Warning("couldn't attain exit entity\n");
}
}
else
{
Msg("No Teleporter Entrance built.\n");
}
IEntityInfo *entranceInfo = entityinfomanager->GetEntityInfo( pEntrance );
if (!entranceInfo)
{
Warning("couldn't get entinfo for teleporter entrance\n");
}
IEntityInfo *exitInfo = entityinfomanager->GetEntityInfo( pExit );
if (!exitInfo)
{
Warning("couldn't get entinfo for teleporter exit\n");
}
if (pEntrance && entranceInfo)
{
if (playerinfo->GetCustomInfo(TFPLAYERINFO_BUILDING_TELEPORTER_ENTRANCE, value, emptyVariant))
{
if (value.Bool())
Msg("Entrance Under Construction...\n");
}
Msg("Entrance Health: %i\n", entranceInfo->GetHealth() );
if (playerinfo->GetCustomInfo(TFPLAYERINFO_TELEPORTER_USES, value, emptyVariant))
Msg("Entrance Used %i Times.\n", value.Int() );
}
if (pExit && exitInfo)
{
if (playerinfo->GetCustomInfo(TFPLAYERINFO_BUILDING_TELEPORTER_EXIT, value, emptyVariant))
{
if (value.Bool())
Msg("Exit Under Construction...\n");
}
Msg("Exit Health: %i\n", exitInfo->GetHealth() );
}
}
void ClassStatus( edict_t *pEntity )
{
IPlayerInfo *playerinfo = playerinfomanager->GetPlayerInfo( pEntity );
if (!playerinfo)
{
Msg("couldn't get playerinfo\n");
return;
}
int playerClassId = playerinfo->GetPlayerClassId();
Msg("Player Class: %s\n", playerinfo->GetPlayerClassName());
pluginvariant conditionValue;
pluginvariant emptyVariant;
if (!playerinfo->GetCustomInfo(TFPLAYERINFO_CONDITIONS, conditionValue, emptyVariant))
{
Warning("unable to retrieve conditions!\n");
}
if (TFPlayerHasCondition(conditionValue.Int(), TF_COND_INVULNERABLE ))
Msg("You are Invulnerable!\n");
if (TFPlayerHasCondition(conditionValue.Int(), TF_COND_SELECTED_TO_TELEPORT ))
Msg("You are about to Teleport.\n");
if (TFPlayerHasCondition(conditionValue.Int(), TF_COND_TELEPORTED ))
Msg("You have recently been teleported.\n");
switch(playerClassId)
{
default:
case TF_CLASS_MEDIC:
break;
case TF_CLASS_ENGINEER:
Msg("Building Information:\n");
SentryStatus( pEntity );
DispenserStatus( pEntity );
TeleporterStatus( pEntity );
break;
case TF_CLASS_SPY:
{
int disguiseClass = 0;
pluginvariant value;
if (playerinfo->GetCustomInfo(TFPLAYERINFO_SPY_DISGUISEDAS, value, emptyVariant))
disguiseClass = value.Int();
if ( TFPlayerHasCondition(conditionValue.Int(), TF_COND_DISGUISING ) )
Msg("Disguising..\n");
else if (TFPlayerHasCondition(conditionValue.Int(), TF_COND_DISGUISED ) )
Msg("Disguised as: %s\n", classNames[disguiseClass] );
if (TFPlayerHasCondition(conditionValue.Int(), TF_COND_STEALTHED ))
Msg("Cloaked!\n");
if (playerinfo->GetCustomInfo(TFPLAYERINFO_SPY_CLOAKCHARGELEVEL, value, emptyVariant))
Msg("Cloak Charge Percent: %d\n", value.Float() );
break;
}
case TF_CLASS_DEMOMAN:
break;
}
}
const char *ctf_flagtype[] =
{
"ctf", //TF_FLAGTYPE_CTF = 0,
"attack / defend", //TF_FLAGTYPE_ATTACK_DEFEND,
"territory control", //TF_FLAGTYPE_TERRITORY_CONTROL,
"invade", //TF_FLAGTYPE_INVADE,
"king of the hill", //TF_FLAGTYPE_KINGOFTHEHILL,
};
const char *ctf_flagstatus[] =
{
"unknown",
"At Home",
"Dropped",
"Stolen",
};
void FlagStatus( edict_t *pPlayer )
{
IPlayerInfo *pInfo = playerinfomanager->GetPlayerInfo( pPlayer );
if (!pInfo)
{
Msg( "couldn't get playerinfo\n" );
return;
}
IGameInfo *gameInfo = gameinfomanager->GetGameInfo();
if (!gameInfo)
{
Msg( "couldn't get gameinfo\n" );
}
int gameType = gameInfo->GetInfo_GameType();
if (gameType != 1)
{
Msg( "Game is not CTF.\n" );
return;
}
Msg( "===============================\n" );
Msg( "Capture The Flag -- Flag Status\n" );
Msg( "===============================\n" );
pluginvariant value, options;
edict_t *pFlag = NULL;
while ( (pFlag = entityinfomanager->FindEntityByClassname(pFlag, "item_teamflag")) != NULL )
{
IEntityInfo *pFlagInfo = entityinfomanager->GetEntityInfo( pFlag );
if (!pFlagInfo)
continue;
Msg( "\nTeam %s's Flag\n", gameInfo->GetInfo_GetTeamName( pFlagInfo->GetTeamIndex() ) );
options.SetInt(engine->IndexOfEdict(pFlag));
if ( gameInfo->GetInfo_Custom( TFGAMEINFO_CTF_FLAG_TYPE, value, options) )
Msg( "Type: %s\n", ctf_flagtype[value.Int()] );
if ( gameInfo->GetInfo_Custom( TFGAMEINFO_CTF_FLAG_STATUS, value, options) )
{
Msg( "Status: %s\n", ctf_flagstatus[value.Int()] );
//Tony; if we're carried, find out who has us.
if (value.Int() == 3)
{
edict_t *pPlayer = pFlagInfo->GetOwner();
if (pPlayer)
{
IPlayerInfo *pPlayerInfo = playerinfomanager->GetPlayerInfo( pPlayer );
if (pPlayerInfo)
Msg( "Carried by: %s\n", pPlayerInfo->GetName() );
}
}
}
}
Msg( "===============================\n" );
}
#endif
//---------------------------------------------------------------------------------
// Purpose: called when a client types in a command (only a subset of commands however, not CON_COMMAND's)
//---------------------------------------------------------------------------------
PLUGIN_RESULT CEmptyServerPlugin::ClientCommand( edict_t *pEntity, const CCommand &args )
{
const char *pcmd = args[0];
if ( !pEntity || pEntity->IsFree() )
{
return PLUGIN_CONTINUE;
}
if ( FStrEq( pcmd, "menu" ) )
{
KeyValues *kv = new KeyValues( "menu" );
kv->SetString( "title", "You've got options, hit ESC" );
kv->SetInt( "level", 1 );
kv->SetColor( "color", Color( 255, 0, 0, 255 ));
kv->SetInt( "time", 20 );
kv->SetString( "msg", "Pick an option\nOr don't." );
for( int i = 1; i < 9; i++ )
{
char num[10], msg[10], cmd[10];
Q_snprintf( num, sizeof(num), "%i", i );
Q_snprintf( msg, sizeof(msg), "Option %i", i );
Q_snprintf( cmd, sizeof(cmd), "option%i", i );
KeyValues *item1 = kv->FindKey( num, true );
item1->SetString( "msg", msg );
item1->SetString( "command", cmd );
}
helpers->CreateMessage( pEntity, DIALOG_MENU, kv, this );
kv->deleteThis();
return PLUGIN_STOP; // we handled this function
}
else if ( FStrEq( pcmd, "rich" ) )
{
KeyValues *kv = new KeyValues( "menu" );
kv->SetString( "title", "A rich message" );
kv->SetInt( "level", 1 );
kv->SetInt( "time", 20 );
kv->SetString( "msg", "This is a long long long text string.\n\nIt also has line breaks." );
helpers->CreateMessage( pEntity, DIALOG_TEXT, kv, this );
kv->deleteThis();
return PLUGIN_STOP; // we handled this function
}
else if ( FStrEq( pcmd, "msg" ) )
{
KeyValues *kv = new KeyValues( "menu" );
kv->SetString( "title", "Just a simple hello" );
kv->SetInt( "level", 1 );
kv->SetInt( "time", 20 );
helpers->CreateMessage( pEntity, DIALOG_MSG, kv, this );
kv->deleteThis();
return PLUGIN_STOP; // we handled this function
}
else if ( FStrEq( pcmd, "entry" ) )
{
KeyValues *kv = new KeyValues( "entry" );
kv->SetString( "title", "Stuff" );
kv->SetString( "msg", "Enter something" );
kv->SetString( "command", "say" ); // anything they enter into the dialog turns into a say command
kv->SetInt( "level", 1 );
kv->SetInt( "time", 20 );
helpers->CreateMessage( pEntity, DIALOG_ENTRY, kv, this );
kv->deleteThis();
return PLUGIN_STOP; // we handled this function
}
#ifdef SAMPLE_TF2_PLUGIN
else if ( FStrEq( pcmd, "gameinfo" ) )
{
IGameInfo *gameInfo = gameinfomanager->GetGameInfo();
if (!gameInfo)
return PLUGIN_STOP;
Msg("=== Game Information ===\n");
Msg("Game Type: %i / %s\n", gameInfo->GetInfo_GameType(), gameInfo->GetInfo_GameTypeName() );
int teamCount = gameInfo->GetInfo_GetTeamCount();
Msg("Num Teams: %i\n", teamCount );
Msg("Player Counts:\n");
for (int i = 0;i<teamCount;i++)
{
//If this failes, we can assume the rest is invalid too.
if (!gameInfo->GetInfo_GetTeamName(i) )
continue;
Msg("Team: %s, Players: %i\n", gameInfo->GetInfo_GetTeamName(i), gameInfo->GetInfo_NumPlayersOnTeam(i) );
}
return PLUGIN_STOP;
}
// Sample to use the new CustomInfo added to TF2 for plugins
else if ( FStrEq( pcmd, "tfcond" ) )
{
IPlayerInfo *playerinfo = playerinfomanager->GetPlayerInfo( pEntity );
if (!playerinfo)
return PLUGIN_STOP;
pluginvariant conditionValue;
pluginvariant emptyVariant;
if (!playerinfo->GetCustomInfo(TFPLAYERINFO_CONDITIONS, conditionValue, emptyVariant))
{
Msg("unable to retrieve conditions!\n");
return PLUGIN_STOP;
}
Msg("Disguising?: %s\n", TFPlayerHasCondition(conditionValue.Int(), TF_COND_DISGUISING ) ? "yes" : "no" );
Msg("Disguised?: %s\n", TFPlayerHasCondition(conditionValue.Int(), TF_COND_DISGUISED ) ? "yes" : "no" );
Msg("Stealthed?: %s\n", TFPlayerHasCondition(conditionValue.Int(), TF_COND_STEALTHED ) ? "yes" : "no" );
Msg("Invulnerable?: %s\n", TFPlayerHasCondition(conditionValue.Int(), TF_COND_INVULNERABLE ) ? "yes" : "no" );
Msg("Teleported Recently?: %s\n", TFPlayerHasCondition(conditionValue.Int(), TF_COND_TELEPORTED ) ? "yes" : "no" );
Msg("Selected for Teleportation?: %s\n", TFPlayerHasCondition(conditionValue.Int(), TF_COND_SELECTED_TO_TELEPORT ) ? "yes" : "no" );
Msg("On Fire?: %s\n", TFPlayerHasCondition(conditionValue.Int(), TF_COND_BURNING ) ? "yes" : "no" );
return PLUGIN_STOP;
}
else if ( FStrEq( pcmd, "sentry_status" ) )
{
SentryStatus(pEntity);
return PLUGIN_STOP;
}
else if ( FStrEq( pcmd, "class_status" ) )
{
ClassStatus(pEntity);
return PLUGIN_STOP;
}
else if ( FStrEq( pcmd, "flag_status" ) )
{
FlagStatus(pEntity);
return PLUGIN_STOP;
}
#ifdef GAME_DLL
else if ( FStrEq( pcmd, "cbe_test" ) )
{
IPlayerInfo *playerinfo = playerinfomanager->GetPlayerInfo( pEntity );
if (!playerinfo)
return PLUGIN_STOP;
CBaseEntity *pEnt = static_cast< CBaseEntity* >(entityinfomanager->GetEntity( pEntity ));
if (pEnt)
Msg("got a pointer to CBaseEntity..\n");
Msg("attempting to print this entities modelname directly..\n");
Msg("ModelName: %s\n", STRING(pEnt->GetModelName()) );
return PLUGIN_STOP;
}
#endif
#endif
return PLUGIN_CONTINUE;
}
//---------------------------------------------------------------------------------
// Purpose: called when a client is authenticated
//---------------------------------------------------------------------------------
PLUGIN_RESULT CEmptyServerPlugin::NetworkIDValidated( const char *pszUserName, const char *pszNetworkID )
{
return PLUGIN_CONTINUE;
}
//---------------------------------------------------------------------------------
// Purpose: called when a cvar value query is finished
//---------------------------------------------------------------------------------
void CEmptyServerPlugin::OnQueryCvarValueFinished( QueryCvarCookie_t iCookie, edict_t *pPlayerEntity, EQueryCvarValueStatus eStatus, const char *pCvarName, const char *pCvarValue )
{
Msg( "Cvar query (cookie: %d, status: %d) - name: %s, value: %s\n", iCookie, eStatus, pCvarName, pCvarValue );
}
void CEmptyServerPlugin::OnEdictAllocated( edict_t *edict )
{
}
void CEmptyServerPlugin::OnEdictFreed( const edict_t *edict )
{
}
//---------------------------------------------------------------------------------
// Purpose: called when an event is fired
//---------------------------------------------------------------------------------
void CEmptyServerPlugin::FireGameEvent( KeyValues * event )
{
const char * name = event->GetName();
Msg( "CEmptyServerPlugin::FireGameEvent: Got event \"%s\"\n", name );
}
//---------------------------------------------------------------------------------
// Purpose: an example of how to implement a new command
//---------------------------------------------------------------------------------
CON_COMMAND( empty_version, "prints the version of the empty plugin" )
{
Msg( "Version:2.0.0.0\n" );
}
CON_COMMAND( empty_log, "logs the version of the empty plugin" )
{
engine->LogPrint( "Version:2.0.0.0\n" );
}
//---------------------------------------------------------------------------------
// Purpose: an example cvar
//---------------------------------------------------------------------------------
static ConVar empty_cvar("plugin_empty", "0", FCVAR_NOTIFY, "Example plugin cvar");
View Git Blame Copy Permalink