mirror of
https://github.com/ENSL/NS.git
synced 2024-11-14 17:01:29 +00:00
b918c731aa
Rewrote WeaponsResource code so that uninitialized slots are no longer returned as valid weapons Removed upp_* from command constants and console commands Removed commented out entry from hl_baseentity.cpp Shift in map data position is now performed by the network layer instead of at the time of creation Deleted obsolete Util.vcproj Replaced calls to fmax with calls to max in AvHEntities.cpp (Win32 compiler wasn't finding fmax command without explicit include) Began implementation of client-to-server tunnel for Nexus git-svn-id: https://unknownworlds.svn.cloudforge.com/ns1@94 67975925-1194-0748-b3d5-c16f83f1a3a1
1573 lines
No EOL
42 KiB
C++
1573 lines
No EOL
42 KiB
C++
//======== (C) Copyright 2001 Charles G. Cleveland All rights reserved. =========
|
|
//
|
|
// The copyright to the contents herein is the property of Charles G. Cleveland.
|
|
// The contents may be used and/or copied only with the written permission of
|
|
// Charles G. Cleveland, or in accordance with the terms and conditions stipulated in
|
|
// the agreement/contract under which the contents have been supplied.
|
|
//
|
|
// Purpose:
|
|
//
|
|
// $Workfile: AvHConsoleCommands.cpp$
|
|
// $Date: 2002/11/22 21:28:16 $
|
|
//
|
|
//-------------------------------------------------------------------------------
|
|
// $Log: AvHConsoleCommands.cpp,v $
|
|
// Revision 1.31 2002/11/22 21:28:16 Flayra
|
|
// - mp_consistency changes
|
|
//
|
|
// Revision 1.30 2002/11/15 04:46:53 Flayra
|
|
// - Utility command
|
|
//
|
|
// Revision 1.29 2002/11/03 04:49:56 Flayra
|
|
// - Team balance fixes
|
|
//
|
|
// Revision 1.28 2002/10/28 20:33:55 Flayra
|
|
// - Added confirmation to auth command
|
|
//
|
|
// Revision 1.27 2002/10/24 21:22:40 Flayra
|
|
// - Commented out adjust score cheat for release (even with cheats on, this is abusive)
|
|
//
|
|
// Revision 1.26 2002/10/20 16:45:19 Flayra
|
|
// - Linux update
|
|
//
|
|
// Revision 1.25 2002/10/20 16:35:46 Flayra
|
|
// - Added hack code to create a fake client to test profiling
|
|
//
|
|
// Revision 1.24 2002/10/18 22:17:12 Flayra
|
|
// - Added redeem cheat
|
|
//
|
|
// Revision 1.23 2002/10/16 00:51:33 Flayra
|
|
// - Added auth command and setauth cheat
|
|
// - Require cheats for some dev commands (oops)
|
|
//
|
|
// Revision 1.22 2002/10/03 18:41:35 Flayra
|
|
// - Allow setskin to work without chets, for testing
|
|
//
|
|
// Revision 1.21 2002/09/23 22:11:46 Flayra
|
|
// - Regular update
|
|
//
|
|
// Revision 1.20 2002/09/09 19:49:25 Flayra
|
|
// - Added deathmessage cheat
|
|
//
|
|
// Revision 1.19 2002/08/16 02:33:32 Flayra
|
|
// - Added endgame cheat to end game for either team (to test endgame music)
|
|
//
|
|
// Revision 1.18 2002/08/09 00:56:11 Flayra
|
|
// - Added "adjustscore" cheat for testing new scoreboard
|
|
//
|
|
// Revision 1.17 2002/08/02 22:01:27 Flayra
|
|
// - Added some new cheats, refactored cheat names, changes for new alert system
|
|
//
|
|
// Revision 1.16 2002/07/10 14:39:24 Flayra
|
|
// - Added "overflow" cheat for debugging
|
|
//
|
|
// Revision 1.15 2002/07/08 16:49:34 Flayra
|
|
// - Unhacked this to fix some random bug
|
|
//
|
|
// Revision 1.14 2002/06/03 16:41:19 Flayra
|
|
// - Added "invul" cheat
|
|
//
|
|
// Revision 1.13 2002/05/23 02:34:00 Flayra
|
|
// - Post-crash checkin. Restored @Backup from around 4/16. Contains changes for last four weeks of development.
|
|
//
|
|
//===============================================================================
|
|
#include "util/nowarnings.h"
|
|
#include "dlls/extdll.h"
|
|
#include "dlls/util.h"
|
|
#include "dlls/cbase.h"
|
|
#include "dlls/player.h"
|
|
#include "dlls/weapons.h"
|
|
#include "mod/AvHGamerules.h"
|
|
#include "mod/AvHConstants.h"
|
|
#include "mod/AvHMarineEquipmentConstants.h"
|
|
#include "mod/AvHEntities.h"
|
|
#include "mod/AvHParticleTemplateServer.h"
|
|
#include "mod/AvHPlayer.h"
|
|
#include "dlls/client.h"
|
|
#include "dlls/game.h"
|
|
#include "dlls/util.h"
|
|
#include "mod/AvHServerUtil.h"
|
|
#include "mod/AvHServerVariables.h"
|
|
#include "mod/AvHMessage.h"
|
|
#include "mod/AvHSoundListManager.h"
|
|
#include "mod/AvHServerUtil.h"
|
|
#include "mod/AvHTitles.h"
|
|
#include "mod/AvHParticleSystemManager.h"
|
|
#include "mod/AvHMarineEquipment.h"
|
|
#include "mod/AvHMovementUtil.h"
|
|
#include "mod/AvHSharedUtil.h"
|
|
#include "textrep/TRFactory.h"
|
|
#include "mod/AvHEntities.h"
|
|
#include "mod/AvHScriptManager.h"
|
|
#include "mod/AvHCommandConstants.h"
|
|
#include "mod/AvHPlayerUpgrade.h"
|
|
#include <stdio.h>
|
|
#include "game_shared/voice_gamemgr.h"
|
|
#include "mod/AvHNetworkMessages.h"
|
|
#include "mod/AvHNexusServer.h"
|
|
|
|
extern AvHParticleTemplateListServer gParticleTemplateList;
|
|
extern CVoiceGameMgr g_VoiceGameMgr;
|
|
extern int gCommanderPointsAwardedEventID;
|
|
extern cvar_t allow_spectators;
|
|
extern cvar_t avh_tournamentmode;
|
|
extern int kNumEntsProcessedForPlayerOne;
|
|
|
|
#ifdef WIN32
|
|
// this is the LINK_ENTITY_TO_CLASS function that creates a player (bot)
|
|
HINSTANCE h_Library = NULL;
|
|
typedef void (*LINK_ENTITY_FUNC)(entvars_t *);
|
|
|
|
void player( entvars_t *pev )
|
|
{
|
|
if(!h_Library)
|
|
{
|
|
string libName = string(getModDirectory()) + "\\dlls\\ns.dll";
|
|
h_Library = LoadLibrary(libName.c_str());
|
|
}
|
|
|
|
static LINK_ENTITY_FUNC otherClassName = NULL;
|
|
if (otherClassName == NULL)
|
|
otherClassName = (LINK_ENTITY_FUNC)GetProcAddress(h_Library, "player");
|
|
if (otherClassName != NULL)
|
|
{
|
|
(*otherClassName)(pev);
|
|
}
|
|
}
|
|
#endif
|
|
|
|
//------------------------------------------------------------------
|
|
// begin future MapUtils.h / MapUtils.cpp
|
|
//------------------------------------------------------------------
|
|
typedef std::pair<string,int> EntityInfoNodeType;
|
|
typedef std::map<string,int> EntityInfoMapType;
|
|
typedef std::vector<EntityInfoNodeType> EntityInfoVectorType;
|
|
|
|
bool EntityInfoSortFunction(const EntityInfoNodeType& left,const EntityInfoNodeType& right)
|
|
{
|
|
if(left.second > right.second)
|
|
{ return true; }
|
|
if(left.first.compare(right.first) < 0)
|
|
{ return true; }
|
|
return false;
|
|
}
|
|
|
|
bool EntityInfoShouldCount(const string& inClassName)
|
|
{
|
|
bool theShouldCount = true;
|
|
if(inClassName.empty()) // unassigned player slot
|
|
{
|
|
theShouldCount = false;
|
|
}
|
|
else if(inClassName.compare(0,7,"weapon_") == 0)
|
|
{
|
|
theShouldCount = false;
|
|
}
|
|
else if(inClassName.compare("bodyque") == 0)
|
|
{
|
|
theShouldCount = false;
|
|
}
|
|
else if(inClassName.compare("player") == 0)
|
|
{
|
|
theShouldCount = false;
|
|
}
|
|
return theShouldCount;
|
|
}
|
|
|
|
EntityInfoVectorType EntityInfoGetVector(void)
|
|
{
|
|
EntityInfoMapType theMap;
|
|
const char* theClassName;
|
|
string theClassNameString;
|
|
|
|
for(int index = 0; index < gpGlobals->maxEntities; ++index)
|
|
{
|
|
edict_t* theEdict = INDEXENT(index);
|
|
if(!FNullEnt(theEdict))
|
|
{
|
|
theClassName = STRING(theEdict->v.classname);
|
|
if(theClassName)
|
|
{
|
|
++theMap[string(theClassName)];
|
|
}
|
|
}
|
|
}
|
|
|
|
EntityInfoVectorType theVector;
|
|
|
|
EntityInfoMapType::iterator end = theMap.end();
|
|
for(EntityInfoMapType::iterator current = theMap.begin(); current != end; ++current)
|
|
{
|
|
if(EntityInfoShouldCount(current->first))
|
|
{
|
|
theVector.push_back(EntityInfoNodeType(current->first,current->second));
|
|
}
|
|
}
|
|
|
|
//sort it
|
|
sort(theVector.begin(),theVector.end(),EntityInfoSortFunction);
|
|
|
|
return theVector;
|
|
}
|
|
|
|
int EntityInfoGetCount()
|
|
{
|
|
int theCount = 0;
|
|
EntityInfoVectorType theVector = EntityInfoGetVector();
|
|
EntityInfoVectorType::iterator end = theVector.end();
|
|
for(EntityInfoVectorType::iterator current = theVector.begin(); current != end; ++current)
|
|
{
|
|
theCount += current->second;
|
|
}
|
|
return theCount;
|
|
}
|
|
//------------------------------------------------------------------
|
|
// end future MapUtils.h / MapUtils.cpp
|
|
//------------------------------------------------------------------
|
|
|
|
|
|
void ReportPlayer(CBasePlayer* inPlayer, const char* inCommand)
|
|
{
|
|
#ifdef AVH_PLAYTEST_BUILD
|
|
// Tell the server that this player executed x message
|
|
char* theMessage = UTIL_VarArgs("%s initiated command \"%s\"\n", STRING(inPlayer->pev->netname), inCommand);
|
|
UTIL_ClientPrintAll(HUD_PRINTNOTIFY, theMessage);
|
|
UTIL_LogPrintf(theMessage);
|
|
#endif
|
|
}
|
|
|
|
BOOL AvHGamerules::ClientCommand( CBasePlayer *pPlayer, const char *pcmd )
|
|
{
|
|
//adding Nexus TunnelToClient functionality up here...
|
|
if( strcmp( pcmd, "NexusData" ) == 0 )
|
|
{
|
|
const char* arg1 = CMD_ARGV(1);
|
|
return AvHNexus::recv(pPlayer->pev,arg1,strlen(arg1));
|
|
}
|
|
//non-Nexus signal handler down here...
|
|
|
|
AvHPlayer* theAvHPlayer = dynamic_cast<AvHPlayer*>(pPlayer);
|
|
AvHTeam* theTeam = NULL;
|
|
bool theSuccess = false;
|
|
bool theIsDeveloper = false;
|
|
bool theIsGuide = false;
|
|
bool theIsServerOp = false;
|
|
bool theIsPlaytester = false;
|
|
bool theIsPlayerHelper = false;
|
|
bool theIsPlaytest = false;
|
|
bool theReportPlayer = false;
|
|
bool theIsDedicatedServer = false;
|
|
bool theIsDebug = false;
|
|
|
|
#ifdef DEBUG
|
|
theIsDebug = true;
|
|
#endif
|
|
|
|
if(theAvHPlayer)
|
|
{
|
|
theTeam = theAvHPlayer->GetTeamPointer();
|
|
theIsDeveloper = theAvHPlayer->GetIsMember(PLAYERAUTH_DEVELOPER);
|
|
theIsGuide = theAvHPlayer->GetIsMember(PLAYERAUTH_GUIDE);
|
|
theIsPlaytester = theAvHPlayer->GetIsMember(PLAYERAUTH_PLAYTESTER);
|
|
theIsPlayerHelper = theIsDeveloper || theIsGuide || theIsPlaytester;
|
|
|
|
#ifdef AVH_PLAYTEST_BUILD
|
|
theIsPlaytest = theIsPlaytester || theIsDeveloper;
|
|
#endif
|
|
}
|
|
else
|
|
{
|
|
theIsDedicatedServer = true;
|
|
}
|
|
|
|
if( !theAvHPlayer || theAvHPlayer->GetIsMember(PLAYERAUTH_SERVEROP) )
|
|
{
|
|
theIsServerOp = true;
|
|
}
|
|
|
|
if(g_VoiceGameMgr.ClientCommand(pPlayer, pcmd))
|
|
{
|
|
theSuccess = true;
|
|
}
|
|
else if ( FStrEq( pcmd, kcJoinTeamOne ) )
|
|
{
|
|
if(theAvHPlayer)
|
|
{
|
|
this->AttemptToJoinTeam(theAvHPlayer, TEAM_ONE, true);
|
|
theSuccess = true;
|
|
}
|
|
}
|
|
else if ( FStrEq( pcmd, kcJoinTeamTwo ) )
|
|
{
|
|
if(theAvHPlayer)
|
|
{
|
|
this->AttemptToJoinTeam(theAvHPlayer, TEAM_TWO, true);
|
|
theSuccess = true;
|
|
}
|
|
}
|
|
else if ( FStrEq( pcmd, kcJoinTeamThree ) )
|
|
{
|
|
if(theAvHPlayer)
|
|
{
|
|
this->AttemptToJoinTeam(theAvHPlayer, TEAM_THREE, true);
|
|
theSuccess = true;
|
|
}
|
|
}
|
|
else if ( FStrEq( pcmd, kcJoinTeamFour ) )
|
|
{
|
|
if(theAvHPlayer)
|
|
{
|
|
this->AttemptToJoinTeam(theAvHPlayer, TEAM_FOUR, true);
|
|
theSuccess = true;
|
|
}
|
|
}
|
|
else if ( FStrEq( pcmd, kcAutoAssign ) )
|
|
{
|
|
if(theAvHPlayer)
|
|
{
|
|
this->AutoAssignPlayer(theAvHPlayer);
|
|
theSuccess = true;
|
|
}
|
|
}
|
|
else if ( FStrEq( pcmd, kcReadyRoom ) )
|
|
{
|
|
if(theAvHPlayer)
|
|
{
|
|
if(!(theAvHPlayer->pev->flags & FL_FAKECLIENT))
|
|
{
|
|
if(!theAvHPlayer->GetIsBeingDigested())
|
|
{
|
|
theAvHPlayer->SetPlayMode(PLAYMODE_READYROOM, true);
|
|
}
|
|
|
|
theSuccess = true;
|
|
}
|
|
}
|
|
theSuccess = true;
|
|
}
|
|
else if (FStrEq(pcmd, kcStartGame))
|
|
{
|
|
if(this->GetCheatsEnabled())
|
|
{
|
|
this->SetGameStarted(true);
|
|
}
|
|
theSuccess = true;
|
|
}
|
|
else if(FStrEq(pcmd, kcSwitch))
|
|
{
|
|
if(this->GetCheatsEnabled() || theIsPlaytest)
|
|
{
|
|
AvHTeamNumber thePlayerTeam = theAvHPlayer->GetTeam();
|
|
if(thePlayerTeam != TEAM_IND)
|
|
{
|
|
ReportPlayer(theAvHPlayer, kcSwitch);
|
|
AvHTeamNumber teamA = GetGameRules()->GetTeamA()->GetTeamNumber();
|
|
AvHTeamNumber teamB = GetGameRules()->GetTeamB()->GetTeamNumber();
|
|
|
|
// Get other team
|
|
AvHTeamNumber theOtherTeamNumber = (thePlayerTeam == teamA) ? teamB : teamA;
|
|
|
|
// Remember current position
|
|
Vector theCurrentPosition = theAvHPlayer->pev->origin;
|
|
Vector theCurrentAngles = theAvHPlayer->pev->angles;
|
|
|
|
// Switch teams
|
|
theAvHPlayer->SetPlayMode(PLAYMODE_READYROOM, true);
|
|
this->AttemptToJoinTeam(theAvHPlayer, theOtherTeamNumber, false);
|
|
|
|
// Set our position again
|
|
theAvHPlayer->pev->origin = theCurrentPosition;
|
|
theAvHPlayer->pev->angles = theCurrentAngles;
|
|
theAvHPlayer->pev->fixangle = 1;
|
|
}
|
|
|
|
theSuccess = true;
|
|
}
|
|
}
|
|
else if(FStrEq(pcmd, "givexp"))
|
|
{
|
|
if(this->GetCheatsEnabled())
|
|
{
|
|
AvHPlayer* thePlayer = dynamic_cast<AvHPlayer*>(theAvHPlayer->GetSpectatingEntity());
|
|
if(!thePlayer)
|
|
{
|
|
thePlayer = theAvHPlayer;
|
|
}
|
|
|
|
if(thePlayer && thePlayer->GetIsRelevant())
|
|
{
|
|
int theTargetLevel = 1;
|
|
|
|
int theNumArgs = CMD_ARGC();
|
|
if(theNumArgs == 2)
|
|
{
|
|
sscanf(CMD_ARGV(1), "%d", &theTargetLevel);
|
|
}
|
|
|
|
GetGameRules()->AwardExperience(thePlayer, theTargetLevel);
|
|
|
|
theSuccess = true;
|
|
}
|
|
}
|
|
}
|
|
else if(FStrEq(pcmd, kcRestartRound) || FStrEq(pcmd, kcRestart))
|
|
{
|
|
if(!theAvHPlayer || theIsServerOp || theIsPlaytest || theIsDedicatedServer || theIsDebug || this->GetCheatsEnabled())
|
|
{
|
|
if(theAvHPlayer)
|
|
{
|
|
ReportPlayer(theAvHPlayer, pcmd);
|
|
}
|
|
|
|
// Reset game world
|
|
this->ResetGame(true);
|
|
}
|
|
theSuccess = true;
|
|
}
|
|
#ifdef AVH_PLAYTEST_BUILD
|
|
else if(FStrEq(pcmd, kcTournyMode))
|
|
{
|
|
if(theIsPlaytest)
|
|
{
|
|
char theCommand[128];
|
|
sprintf(theCommand, "%s %d\n", kvTournamentMode, !((int)avh_tournamentmode.value));
|
|
SERVER_COMMAND(theCommand);
|
|
|
|
theSuccess = true;
|
|
}
|
|
}
|
|
#endif
|
|
else if(FStrEq(pcmd, kcSetBalanceVar))
|
|
{
|
|
if( theAvHPlayer && theAvHPlayer->GetIsAuthorized(AUTH_ACTION_ADJUST_BALANCE,0) )
|
|
{
|
|
BalanceValueContainer* container = BalanceValueContainerFactory::get(BalanceValueContainerFactory::getDefaultFilename());
|
|
int theNumArgs = CMD_ARGC();
|
|
if( theNumArgs == 3 )
|
|
{
|
|
string name(CMD_ARGV(1));
|
|
string value(CMD_ARGV(2));
|
|
if( value.at(0) == '"' )
|
|
{
|
|
container->insert(name,value.substr(1,value.length()-1));
|
|
}
|
|
else if( value.at(value.length()-1) == 'f' || value.find('.') != string::npos )
|
|
{
|
|
float fvalue = (float)atof(value.c_str());
|
|
container->insert(name,fvalue);
|
|
}
|
|
else
|
|
{
|
|
int ivalue = atoi(value.c_str());
|
|
container->insert(name,ivalue);
|
|
}
|
|
}
|
|
}
|
|
|
|
theSuccess = true;
|
|
}
|
|
else if(FStrEq(pcmd, kcNSChangeLevel))
|
|
{
|
|
if(theIsServerOp || theIsPlaytest)
|
|
{
|
|
char theLevelName[1024];
|
|
if(sscanf(CMD_ARGV(1), "%s", theLevelName) == 1)
|
|
{
|
|
ReportPlayer(theAvHPlayer, pcmd);
|
|
CHANGE_LEVEL(theLevelName, NULL );
|
|
}
|
|
else
|
|
{
|
|
UTIL_SayText("Usage: changelevel <mapname>", theAvHPlayer);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
UTIL_SayText("You're not authorized to changelevel.", theAvHPlayer);
|
|
}
|
|
|
|
theSuccess = true;
|
|
}
|
|
else if (FStrEq(pcmd, kcTestEvent))
|
|
{
|
|
if(theAvHPlayer && this->GetCheatsEnabled())
|
|
{
|
|
vec3_t theOrigin = theAvHPlayer->pev->origin;
|
|
theOrigin.z -= 500;
|
|
int theFlags = 0;//FEV_GLOBAL;// | FEV_HOSTONLY;
|
|
PLAYBACK_EVENT_FULL(theFlags, theAvHPlayer->edict(), gCommanderPointsAwardedEventID, 0, theOrigin, (float *)&g_vecZero, 0.0, 0.0, /*theWeaponIndex*/ 0, 0, 0, 0 );
|
|
theSuccess = true;
|
|
}
|
|
}
|
|
else if (FStrEq(pcmd, kcGetNumPlayers))
|
|
{
|
|
if(theAvHPlayer && this->GetCheatsEnabled())
|
|
{
|
|
int theNumPlayers = GetGameRules()->GetNumberOfPlayers();
|
|
char theMessage[128];
|
|
sprintf(theMessage, "Num players: %d\n", theNumPlayers);
|
|
UTIL_SayText(theMessage, theAvHPlayer);
|
|
theSuccess = true;
|
|
}
|
|
}
|
|
else if (FStrEq(pcmd, kcAddCat))
|
|
{
|
|
if(theAvHPlayer && (this->GetCheatsEnabled() || theIsPlaytest))
|
|
{
|
|
AvHTeam* theTeam = theAvHPlayer->GetTeamPointer();
|
|
if(theTeam && (theTeam->GetTeamType() == AVH_CLASS_TYPE_ALIEN))
|
|
{
|
|
ReportPlayer(theAvHPlayer, pcmd);
|
|
|
|
int theCategory = 0;
|
|
sscanf(CMD_ARGV(1), "%d", &theCategory);
|
|
AvHAlienUpgradeCategory theUpgradeCategory = AvHAlienUpgradeCategory(theCategory);
|
|
|
|
theTeam->AddTeamUpgrade(theUpgradeCategory);
|
|
|
|
theSuccess = true;
|
|
}
|
|
}
|
|
}
|
|
else if (FStrEq(pcmd, kcSendMessage))
|
|
{
|
|
if(theAvHPlayer)
|
|
{
|
|
if(this->GetCheatsEnabled())
|
|
{
|
|
if(CMD_ARGC() >= 3)
|
|
{
|
|
char theTooltipText[512];
|
|
sscanf(CMD_ARGV(1), "%s", theTooltipText);
|
|
|
|
int theMode = 0;
|
|
sscanf(CMD_ARGV(2), "%d", &theMode);
|
|
|
|
if(theMode == 0)
|
|
{
|
|
UTIL_ShowMessage(theTooltipText, theAvHPlayer);
|
|
}
|
|
else if(theMode == 1)
|
|
{
|
|
UTIL_Error(theAvHPlayer, theTooltipText);
|
|
}
|
|
else
|
|
{
|
|
bool theIsToolTip = (theMode == 2);
|
|
|
|
theAvHPlayer->SendMessage(theTooltipText, theIsToolTip);
|
|
}
|
|
|
|
theSuccess = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else if (FStrEq(pcmd, kcTooltip))
|
|
{
|
|
if(theAvHPlayer && theIsPlayerHelper)
|
|
{
|
|
char thePlayerName[512];
|
|
sscanf(CMD_ARGV(1), "%s", thePlayerName);
|
|
|
|
// Read first word as target player
|
|
AvHPlayer* theTargetPlayer = NULL;
|
|
|
|
FOR_ALL_ENTITIES(kAvHPlayerClassName, AvHPlayer*)
|
|
const char* thePlayerCStrName = STRING(theEntity->pev->netname);
|
|
if(!strcmp(thePlayerCStrName, thePlayerName))
|
|
{
|
|
theTargetPlayer = theEntity;
|
|
}
|
|
END_FOR_ALL_ENTITIES(kAvHPlayerClassName)
|
|
|
|
if(theTargetPlayer)
|
|
{
|
|
string theToolTip;
|
|
theToolTip = string(STRING(theAvHPlayer->pev->netname));
|
|
theToolTip += ":";
|
|
|
|
int theNumArgs = CMD_ARGC();
|
|
|
|
for(int i=0; i < theNumArgs - 2; i++)
|
|
{
|
|
theToolTip += string(" ");
|
|
char theTooltipText[512];
|
|
sscanf(CMD_ARGV(i+2), "%s ", theTooltipText);
|
|
theToolTip += string(theTooltipText);
|
|
|
|
// For some reason, some punctuation comes through as separate arguments
|
|
//if(strcmp(theTooltipText, ","))
|
|
//{
|
|
// theToolTip += string(" ");
|
|
//}
|
|
}
|
|
|
|
theTargetPlayer->SendMessage(theToolTip.c_str(), true);
|
|
theSuccess = true;
|
|
}
|
|
else
|
|
{
|
|
char theErrorMessage[1024];
|
|
sprintf(theErrorMessage, "Player \"%s\" not found. Usage: %s CaseSensitivePlayerName Message goes here.\n", thePlayerName, kcTooltip);
|
|
UTIL_SayText(theErrorMessage, theAvHPlayer);
|
|
}
|
|
}
|
|
}
|
|
else if (FStrEq(pcmd, kcRemoveCat))
|
|
{
|
|
if(theAvHPlayer)
|
|
{
|
|
if(this->GetCheatsEnabled() || theIsPlaytest)
|
|
{
|
|
AvHTeam* theTeam = theAvHPlayer->GetTeamPointer();
|
|
if(theTeam && (theTeam->GetTeamType() == AVH_CLASS_TYPE_ALIEN))
|
|
{
|
|
ReportPlayer(theAvHPlayer, pcmd);
|
|
|
|
int theCategory = 0;
|
|
sscanf(CMD_ARGV(1), "%d", &theCategory);
|
|
AvHAlienUpgradeCategory theUpgradeCategory = AvHAlienUpgradeCategory(theCategory);
|
|
|
|
theTeam->RemoveAlienUpgradeCategory(theUpgradeCategory);
|
|
|
|
theSuccess = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else if (FStrEq(pcmd, kcEndGame))
|
|
{
|
|
// Put this back in when doing larger scale playtesting
|
|
if(this->GetCheatsEnabled() || theIsServerOp || theIsPlaytest)
|
|
{
|
|
ReportPlayer(theAvHPlayer, pcmd);
|
|
|
|
string theCheat = kcEndGame1;
|
|
|
|
int theTeam = 0;
|
|
sscanf(CMD_ARGV(1), "%d", &theTeam);
|
|
|
|
if(theTeam == 2)
|
|
{
|
|
theCheat = kcEndGame2;
|
|
}
|
|
|
|
this->SetCheatEnabled(theCheat);
|
|
|
|
//this->mVictoryTeam = theTeamNumber;
|
|
//this->mVictoryTime = gpGlobals->time;
|
|
////this->mVictoryDraw = true;
|
|
}
|
|
theSuccess = true;
|
|
}
|
|
else if (FStrEq(pcmd, kcStartCommandMode))
|
|
{
|
|
if(this->GetCheatsEnabled() && theAvHPlayer)
|
|
{
|
|
if( theAvHPlayer->GetTeamPointer(true)->GetTeamType() != AVH_CLASS_TYPE_MARINE )
|
|
{
|
|
for( int counter = TEAM_ACTIVE_BEGIN; counter < TEAM_ACTIVE_END; ++counter )
|
|
{
|
|
AvHTeam* team = GetGameRules()->GetTeam((AvHTeamNumber)counter);
|
|
if( team && team->GetTeamType() == AVH_CLASS_TYPE_MARINE )
|
|
{
|
|
this->AttemptToJoinTeam( theAvHPlayer, (AvHTeamNumber)counter );
|
|
}
|
|
}
|
|
}
|
|
|
|
// Find position of command station
|
|
FOR_ALL_ENTITIES(kwsTeamCommand, AvHCommandStation*)
|
|
if( theEntity->GetTeamNumber() == theAvHPlayer->pev->team )
|
|
{
|
|
Vector theCommandStationOrigin;
|
|
theCommandStationOrigin.x = (theEntity->pev->absmax.x + theEntity->pev->absmin.x)/2.0f;
|
|
theCommandStationOrigin.y = (theEntity->pev->absmax.y + theEntity->pev->absmin.y)/2.0f;
|
|
theCommandStationOrigin.z = (theEntity->pev->absmax.z + theEntity->pev->absmin.z)/2.0f;
|
|
|
|
// Circle the station, trying points around it to see if there's room
|
|
for(int i = 0; i < 8; i++)
|
|
{
|
|
const int kDistance = 100;
|
|
Vector theOffset;
|
|
float theAngle = (i/(float)360)*2*M_PI;
|
|
theOffset.x = cos(theAngle)*kDistance;
|
|
theOffset.y = sin(theAngle)*kDistance;
|
|
theOffset.z = 20;
|
|
|
|
Vector thePosition = theCommandStationOrigin + theOffset;
|
|
|
|
if(AvHSUGetIsEnoughRoomForHull(thePosition, AvHMUGetHull(false, theAvHPlayer->pev->iuser3), NULL))
|
|
{
|
|
// Teleport to this place
|
|
theAvHPlayer->pev->origin = thePosition;
|
|
theSuccess = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
END_FOR_ALL_ENTITIES(kwsTeamCommand)
|
|
}
|
|
}
|
|
else if (FStrEq(pcmd, kcHurt))
|
|
{
|
|
if(this->GetCheatsEnabled())
|
|
{
|
|
theAvHPlayer->TakeDamage(theAvHPlayer->pev, theAvHPlayer->pev, 100, DMG_GENERIC);
|
|
theSuccess = true;
|
|
}
|
|
}
|
|
else if (FStrEq(pcmd, kcSetCullDistance))
|
|
{
|
|
if(this->GetCheatsEnabled())
|
|
{
|
|
float theCullDistance = 0.0f;
|
|
if(sscanf(CMD_ARGV(1), "%f", &theCullDistance) == 1)
|
|
{
|
|
this->mMapExtents.SetTopDownCullDistance(theCullDistance);
|
|
theSuccess = true;
|
|
}
|
|
}
|
|
}
|
|
else if (FStrEq(pcmd, kcSetGamma))
|
|
{
|
|
if(this->GetCheatsEnabled())
|
|
{
|
|
sscanf(CMD_ARGV(1), "%f", &this->mMapGamma);
|
|
}
|
|
theSuccess = true;
|
|
}
|
|
else if (FStrEq(pcmd, kcStopCommandMode))
|
|
{
|
|
// Fixes problem where players can bind "stopcommandermode" and execute in ready room or maybe as spectator to get weapon
|
|
if(theAvHPlayer && theAvHPlayer->GetIsInTopDownMode())
|
|
{
|
|
theAvHPlayer->SetUser3(AVH_USER3_MARINE_PLAYER);
|
|
|
|
// Cheesy way to make sure player class change is sent to everyone
|
|
theAvHPlayer->EffectivePlayerClassChanged();
|
|
|
|
theSuccess = true;
|
|
}
|
|
else
|
|
{
|
|
int a = 0;
|
|
}
|
|
}
|
|
else if(FStrEq(pcmd, kcBigDig))
|
|
{
|
|
if(this->GetCheatsEnabled())
|
|
{
|
|
bool theNewState = !GetGameRules()->GetIsCheatEnabled(kcBigDig);
|
|
GetGameRules()->SetCheatEnabled(kcBigDig, theNewState);
|
|
theSuccess = true;
|
|
}
|
|
}
|
|
else if(FStrEq(pcmd, kcLowCost))
|
|
{
|
|
if(this->GetCheatsEnabled())
|
|
{
|
|
bool theNewState = !GetGameRules()->GetIsCheatEnabled(kcLowCost);
|
|
GetGameRules()->SetCheatEnabled(kcLowCost, theNewState);
|
|
theSuccess = true;
|
|
}
|
|
}
|
|
else if(FStrEq(pcmd, kcHighDamage))
|
|
{
|
|
if(this->GetCheatsEnabled())
|
|
{
|
|
GetGameRules()->SetCheatEnabled(kcHighDamage);
|
|
theSuccess = true;
|
|
}
|
|
}
|
|
else if(FStrEq(pcmd, kcHighTech))
|
|
{
|
|
if(this->GetCheatsEnabled())
|
|
{
|
|
GetGameRules()->SetCheatEnabled(kcHighTech);
|
|
theSuccess = true;
|
|
}
|
|
}
|
|
else if(FStrEq(pcmd, kcSlowResearch))
|
|
{
|
|
if(this->GetCheatsEnabled())
|
|
{
|
|
GetGameRules()->SetCheatEnabled(kcSlowResearch);
|
|
theSuccess = true;
|
|
}
|
|
}
|
|
else if(FStrEq(pcmd, kcDetectAll))
|
|
{
|
|
if(this->GetCheatsEnabled())
|
|
{
|
|
GetGameRules()->SetCheatEnabled(kcDetectAll);
|
|
theSuccess = true;
|
|
}
|
|
}
|
|
else if(FStrEq(pcmd, kcNumInfos))
|
|
{
|
|
if(this->GetCheatsEnabled())
|
|
{
|
|
int theNumInfos = this->mInfoLocations.size();
|
|
|
|
char theNumInfosString[128];
|
|
sprintf(theNumInfosString, "Num infos: %d\n", theNumInfos);
|
|
UTIL_SayText(theNumInfosString, theAvHPlayer);
|
|
theSuccess = true;
|
|
}
|
|
}
|
|
else if(FStrEq(pcmd, kcNumSpawns))
|
|
{
|
|
if(this->GetCheatsEnabled())
|
|
{
|
|
int theNumSpawns = this->mSpawnList.size();
|
|
|
|
char theNumSpawnsString[128];
|
|
sprintf(theNumSpawnsString, "Num spawns: %d\n", theNumSpawns);
|
|
UTIL_SayText(theNumSpawnsString, theAvHPlayer);
|
|
theSuccess = true;
|
|
}
|
|
}
|
|
else if(FStrEq(pcmd, kcEntityInfo) || FStrEq(pcmd, kcMapUtilEntityInfo))
|
|
{
|
|
if(this->GetCheatsEnabled())
|
|
{
|
|
EntityInfoVectorType theEntityInfo = EntityInfoGetVector();
|
|
|
|
ALERT(at_console, "------------------------------------------------------\n");
|
|
ALERT(at_logged, "------------------------------------------------------\nEntityInfo Report:\n------------------------------------------------------\n");
|
|
|
|
char theEntityMessage[1024];
|
|
EntityInfoVectorType::iterator end = theEntityInfo.end();
|
|
for(EntityInfoVectorType::iterator current = theEntityInfo.begin(); current != end; ++current)
|
|
{
|
|
sprintf(theEntityMessage, "\t%3d \"%s\" entities\n", current->second, current->first.c_str());
|
|
ALERT(at_console, theEntityMessage);
|
|
ALERT(at_logged, theEntityMessage);
|
|
}
|
|
|
|
ALERT(at_console, "------------------------------------------------------\n");
|
|
ALERT(at_logged, "------------------------------------------------------\n");
|
|
|
|
theSuccess = true;
|
|
}
|
|
}
|
|
else if(FStrEq(pcmd, kcInvul))
|
|
{
|
|
if(this->GetCheatsEnabled())
|
|
{
|
|
if(theAvHPlayer->pev->takedamage == DAMAGE_AIM)
|
|
{
|
|
theAvHPlayer->pev->takedamage = DAMAGE_NO;
|
|
UTIL_SayText("Invul ON", theAvHPlayer);
|
|
}
|
|
else
|
|
{
|
|
theAvHPlayer->pev->takedamage = DAMAGE_AIM;
|
|
UTIL_SayText("Invul OFF", theAvHPlayer);
|
|
}
|
|
theSuccess = true;
|
|
}
|
|
}
|
|
else if (FStrEq(pcmd, kcEditPS))
|
|
{
|
|
if(this->GetCheatsEnabled() && theAvHPlayer)
|
|
{
|
|
const char* theName = CMD_ARGV(1);
|
|
uint32 theParticleIndex;
|
|
if(gParticleTemplateList.GetTemplateIndexWithName(theName, theParticleIndex))
|
|
{
|
|
theAvHPlayer->SendMessage(kEditingParticleSystem, true);
|
|
NetMsg_EditPS( theAvHPlayer->pev, theParticleIndex );
|
|
}
|
|
else
|
|
{
|
|
theAvHPlayer->SendMessage(kNoParticleSystem, true);
|
|
}
|
|
theSuccess = true;
|
|
}
|
|
}
|
|
else if (FStrEq(pcmd, kcListPS))
|
|
{
|
|
if(this->GetCheatsEnabled() && theAvHPlayer)
|
|
{
|
|
int theNumTemplates = gParticleTemplateList.GetNumberTemplates();
|
|
|
|
for(int i = 0; i < theNumTemplates; i++)
|
|
{
|
|
string theTemplateName("<system not found>");
|
|
const AvHParticleTemplate* theTemplate = gParticleTemplateList.GetTemplateAtIndex(i);
|
|
if(theTemplate)
|
|
{ theTemplateName = theTemplate->GetName(); }
|
|
|
|
theTemplateName += "\n";
|
|
NetMsg_ListPS( theAvHPlayer->pev, theTemplateName );
|
|
}
|
|
theSuccess = true;
|
|
}
|
|
}
|
|
else if(FStrEq(pcmd, kcRedeem))
|
|
{
|
|
if(this->GetCheatsEnabled())
|
|
{
|
|
theAvHPlayer->Redeem();
|
|
theSuccess = true;
|
|
}
|
|
}
|
|
else if (FStrEq(pcmd, kcBuildMiniMap))
|
|
{
|
|
if(this->GetCheatsEnabled() && theAvHPlayer)
|
|
{
|
|
const char* theCStrLevelName = STRING(gpGlobals->mapname);
|
|
if(theCStrLevelName && !FStrEq(theCStrLevelName, ""))
|
|
{
|
|
GetGameRules()->BuildMiniMap(theAvHPlayer);
|
|
theSuccess = true;
|
|
}
|
|
}
|
|
}
|
|
else if(FStrEq(pcmd, "votemap"))
|
|
{
|
|
if(theAvHPlayer)
|
|
{
|
|
// If map number passed
|
|
int theMapNumber = 0;
|
|
if(sscanf(CMD_ARGV(1), "%d", &theMapNumber) == 1)
|
|
{
|
|
// Add vote to this map. Server might change maps immediately.
|
|
GetGameRules()->VoteMap(theAvHPlayer->entindex(), theMapNumber);
|
|
}
|
|
else
|
|
{
|
|
// Print the list of maps and votes to the player
|
|
StringList theMapVoteList;
|
|
GetGameRules()->GetMapVoteStrings(theMapVoteList);
|
|
|
|
for(StringList::iterator theIter = theMapVoteList.begin(); theIter != theMapVoteList.end(); theIter++)
|
|
{
|
|
ClientPrint(theAvHPlayer->pev, HUD_PRINTNOTIFY, theIter->c_str());
|
|
}
|
|
}
|
|
|
|
theSuccess = true;
|
|
}
|
|
}
|
|
else if(FStrEq(pcmd, "weapondebug"))
|
|
{
|
|
// ClientPrint(theAvHPlayer->pev, HUD_PRINTNOTIFY, theIter->c_str());
|
|
if(theAvHPlayer)
|
|
{
|
|
ClientPrint(theAvHPlayer->pev, HUD_PRINTNOTIFY, "weapondebug\n");
|
|
FOR_ALL_ENTITIES(kAvHPlayerClassName, AvHPlayer*)
|
|
theEntity->PrintWeaponListToClient(theAvHPlayer);
|
|
END_FOR_ALL_ENTITIES(kAvHPlayerClassName)
|
|
theSuccess = true;
|
|
}
|
|
}
|
|
#ifdef DEBUG
|
|
else if(FStrEq(pcmd, "catalyst"))
|
|
{
|
|
if(this->GetCheatsEnabled())
|
|
{
|
|
if(AvHCatalyst::GiveCatalyst(theAvHPlayer))
|
|
{
|
|
theSuccess = true;
|
|
}
|
|
}
|
|
}
|
|
else if(FStrEq(pcmd, "showmenu"))
|
|
{
|
|
short theSlots = 0x1f;
|
|
char theDisplayTime = -1;
|
|
bool theNeedMore = false;
|
|
char* theString = NULL;
|
|
|
|
char theMenuText[1024];
|
|
if(sscanf(CMD_ARGV(1), "%s", theMenuText) == 1)
|
|
{
|
|
NetMsg_ShowMenu( theAvHPlayer->pev, theSlots, theDisplayTime, theNeedMore ? 1 : 0, string(theMenuText) );
|
|
}
|
|
|
|
theSuccess = true;
|
|
}
|
|
else if(FStrEq(pcmd, "calcxp"))
|
|
{
|
|
if(theAvHPlayer)
|
|
{
|
|
char theString[512];
|
|
sprintf(theString, "Experience for levels:\n");
|
|
|
|
for(int i=1; i <= 10; i++)
|
|
{
|
|
float theExperienceForLevel = AvHPlayerUpgrade::GetExperienceForLevel(i);
|
|
char theExpString[128];
|
|
sprintf(theExpString, "\t%d/%d\n", i, (int)theExperienceForLevel);
|
|
strcat(theString, theExpString);
|
|
}
|
|
|
|
ALERT(at_logged, theString);
|
|
theSuccess = true;
|
|
}
|
|
}
|
|
else if(FStrEq(pcmd, "calcspawn"))
|
|
{
|
|
if(theAvHPlayer)
|
|
{
|
|
char theString[512];
|
|
sprintf(theString, "Spawn times (marines):\n");
|
|
|
|
char theResult[128];
|
|
sprintf(theResult, "1v1 -> low: %f high: %f\n", AvHSUCalcCombatSpawnTime(AVH_CLASS_TYPE_MARINE, 1, 0, 1), AvHSUCalcCombatSpawnTime(AVH_CLASS_TYPE_MARINE, 1, 9, 1));
|
|
strcat(theString, theResult);
|
|
|
|
sprintf(theResult, "16v16 -> low: %f high: %f\n", AvHSUCalcCombatSpawnTime(AVH_CLASS_TYPE_MARINE, 16, 0, 1), AvHSUCalcCombatSpawnTime(AVH_CLASS_TYPE_MARINE, 16, 9, 1));
|
|
strcat(theString, theResult);
|
|
|
|
ALERT(at_logged, theString);
|
|
theSuccess = true;
|
|
}
|
|
}
|
|
else if(FStrEq(pcmd, "testscores"))
|
|
{
|
|
PlayerListType thePlayerList;
|
|
|
|
FOR_ALL_ENTITIES(kAvHPlayerClassName, AvHPlayer*)
|
|
if(UTIL_IsValidEntity(theEntity->edict()))
|
|
{
|
|
thePlayerList.push_back(theEntity);
|
|
}
|
|
END_FOR_ALL_ENTITIES(kAvHPlayerClassName);
|
|
|
|
// Find random player
|
|
if(thePlayerList.size() > 0)
|
|
{
|
|
AvHPlayer* thePlayer = thePlayerList[RANDOM_LONG(0, thePlayerList.size() - 1)];
|
|
ASSERT(thePlayer);
|
|
|
|
// Changes scores
|
|
int theChangeType = RANDOM_LONG(0, 2);
|
|
int theSign = RANDOM_LONG(0, 1) ? 1 : -1;
|
|
int theAmount = RANDOM_LONG(0, 5);
|
|
|
|
switch(theChangeType)
|
|
{
|
|
case 0:
|
|
thePlayer->SetScore(thePlayer->GetScore() + theSign*theAmount);
|
|
break;
|
|
case 1:
|
|
thePlayer->pev->frags += theSign*theAmount;
|
|
break;
|
|
case 2:
|
|
thePlayer->m_iDeaths += theSign*theAmount;
|
|
break;
|
|
}
|
|
|
|
thePlayer->EffectivePlayerClassChanged();
|
|
|
|
theSuccess = true;
|
|
}
|
|
}
|
|
#endif
|
|
else if(FStrEq(pcmd, kcOrderSelf))
|
|
{
|
|
if(this->GetCheatsEnabled())
|
|
{
|
|
GetGameRules()->SetCheatEnabled(kcOrderSelf);
|
|
theSuccess = true;
|
|
}
|
|
}
|
|
#ifdef DEBUG
|
|
else if(FStrEq(pcmd, kcAdjustScore))
|
|
{
|
|
if(theAvHPlayer)
|
|
{
|
|
AvHTeam* theTeam = theAvHPlayer->GetTeamPointer();
|
|
if(theTeam)
|
|
{
|
|
int theAmount = 0;
|
|
sscanf(CMD_ARGV(1), "%d", &theAmount);
|
|
|
|
theAvHPlayer->AddPoints(theAmount, TRUE);
|
|
theAvHPlayer->EffectivePlayerClassChanged();
|
|
|
|
theSuccess = true;
|
|
}
|
|
}
|
|
}
|
|
else if(FStrEq(pcmd, kcAttackCS))
|
|
{
|
|
if(this->GetCheatsEnabled())
|
|
{
|
|
FOR_ALL_ENTITIES(kwsTeamCommand, AvHCommandStation*)
|
|
if(theEntity->pev->team == theAvHPlayer->pev->team)
|
|
{
|
|
GetGameRules()->TriggerAlert((AvHTeamNumber)theAvHPlayer->pev->team, ALERT_UNDER_ATTACK, theEntity->entindex());
|
|
theSuccess = true;
|
|
break;
|
|
}
|
|
END_FOR_ALL_ENTITIES(kwsTeamCommand);
|
|
}
|
|
}
|
|
else if (FStrEq(pcmd, kcPlayHUDSound))
|
|
{
|
|
if(theAvHPlayer && GetGameRules()->GetCheatsEnabled())
|
|
{
|
|
AvHHUDSound theHUDSound = HUD_SOUND_INVALID;
|
|
if(sscanf(CMD_ARGV(1), "%d", &theHUDSound) == 1)
|
|
{
|
|
theSuccess = theAvHPlayer->PlayHUDSound(theHUDSound);
|
|
}
|
|
}
|
|
}
|
|
else if(FStrEq(pcmd, kcHighSpeed))
|
|
{
|
|
if(this->GetCheatsEnabled())
|
|
{
|
|
// Toggle hispeed cheat
|
|
bool theHiSpeedEnabled = GetGameRules()->GetIsCheatEnabled(kcHighSpeed);
|
|
GetGameRules()->SetCheatEnabled(kcHighSpeed, !theHiSpeedEnabled);
|
|
theSuccess = true;
|
|
}
|
|
}
|
|
else if (FStrEq(pcmd, kcCrash))
|
|
{
|
|
if(this->GetCheatsEnabled())
|
|
{
|
|
char* theCrashString = NULL;
|
|
*theCrashString = 1;
|
|
}
|
|
}
|
|
else if (FStrEq(pcmd, kcAssert))
|
|
{
|
|
if(this->GetCheatsEnabled())
|
|
{
|
|
ASSERT(false);
|
|
theSuccess = true;
|
|
}
|
|
}
|
|
else if (FStrEq(pcmd, kcRun))
|
|
{
|
|
if(this->GetCheatsEnabled() /*|| theIsDeveloper*/)
|
|
{
|
|
const char* theScriptName = CMD_ARGV(1);
|
|
if(theScriptName)
|
|
{
|
|
AvHScriptManager::Instance()->RunScript(theScriptName);
|
|
theSuccess = true;
|
|
}
|
|
}
|
|
}
|
|
else if (FStrEq(pcmd, kcClientRun))
|
|
{
|
|
if(this->GetCheatsEnabled() /*|| theIsDeveloper*/)
|
|
{
|
|
const char* theScriptName = CMD_ARGV(1);
|
|
if(theAvHPlayer && theScriptName)
|
|
{
|
|
theAvHPlayer->RunClientScript(theScriptName);
|
|
theSuccess = true;
|
|
}
|
|
}
|
|
}
|
|
else if(FStrEq(pcmd, kcParasite))
|
|
{
|
|
if(this->GetCheatsEnabled())
|
|
{
|
|
SetUpgradeMask(&theAvHPlayer->pev->iuser4, MASK_PARASITED);
|
|
}
|
|
}
|
|
else if(FStrEq( pcmd, kcStun) )
|
|
{
|
|
if(this->GetCheatsEnabled() && theAvHPlayer)
|
|
{
|
|
theAvHPlayer->SetIsStunned(true, 4.0f);
|
|
theSuccess = true;
|
|
}
|
|
}
|
|
else if (FStrEq(pcmd, kcWeb))
|
|
{
|
|
if(this->GetCheatsEnabled())
|
|
{
|
|
theAvHPlayer->SetEnsnareState(true);
|
|
theSuccess = true;
|
|
}
|
|
}
|
|
else if(FStrEq(pcmd, kcDigest))
|
|
{
|
|
if(this->GetCheatsEnabled())
|
|
{
|
|
int theDevourerIndex = 0;
|
|
int theDevoureeIndex = 0;
|
|
if((sscanf(CMD_ARGV(1), "%d", &theDevourerIndex) == 1) && (sscanf(CMD_ARGV(2), "%d", &theDevoureeIndex) == 1))
|
|
{
|
|
AvHPlayer* theDevourerPlayer = dynamic_cast<AvHPlayer*>(CBaseEntity::Instance(g_engfuncs.pfnPEntityOfEntIndex(theDevourerIndex)));
|
|
AvHPlayer* theDevoureePlayer = dynamic_cast<AvHPlayer*>(CBaseEntity::Instance(g_engfuncs.pfnPEntityOfEntIndex(theDevoureeIndex)));
|
|
if(theDevourerPlayer && theDevoureePlayer)
|
|
{
|
|
if(!theDevoureePlayer->GetIsBeingDigested())
|
|
{
|
|
theDevourerPlayer->StartDigestion(theDevoureePlayer->entindex());
|
|
}
|
|
else
|
|
{
|
|
theDevourerPlayer->StopDigestion(false);
|
|
}
|
|
}
|
|
}
|
|
theSuccess = true;
|
|
}
|
|
}
|
|
else if(FStrEq(pcmd, kcBoxes))
|
|
{
|
|
if(this->GetCheatsEnabled())
|
|
{
|
|
FOR_ALL_BASEENTITIES()
|
|
AvHBaseBuildable* theBuildable = dynamic_cast<AvHBaseBuildable*>(theBaseEntity);
|
|
if(theBuildable)
|
|
{
|
|
vec3_t theMinPosition = theBuildable->pev->origin + theBuildable->pev->mins;
|
|
vec3_t theMaxPosition = theBuildable->pev->origin + theBuildable->pev->maxs;
|
|
|
|
MESSAGE_BEGIN( MSG_BROADCAST, SVC_TEMPENTITY );
|
|
|
|
WRITE_BYTE(TE_BOX);
|
|
|
|
WRITE_COORD(theMinPosition.x);
|
|
WRITE_COORD(theMinPosition.y);
|
|
WRITE_COORD(theMinPosition.x);
|
|
|
|
WRITE_COORD(theMaxPosition.x);
|
|
WRITE_COORD(theMaxPosition.y);
|
|
WRITE_COORD(theMaxPosition.z);
|
|
|
|
WRITE_SHORT(100);
|
|
|
|
WRITE_BYTE(0);
|
|
WRITE_BYTE(255);
|
|
WRITE_BYTE(0);
|
|
|
|
MESSAGE_END();
|
|
}
|
|
|
|
END_FOR_ALL_BASEENTITIES();
|
|
|
|
theSuccess = true;
|
|
}
|
|
}
|
|
else if(FStrEq(pcmd, kcOverflow))
|
|
{
|
|
if(this->GetCheatsEnabled())
|
|
{
|
|
// Force an overflow
|
|
for(int i = 0; i < 100; i++)
|
|
{
|
|
theAvHPlayer->ForceClientDllUpdate();
|
|
}
|
|
theSuccess = true;
|
|
}
|
|
}
|
|
else if ( FStrEq( pcmd, kcViewAll) )
|
|
{
|
|
// Allow even with cheats off right now, put this back in for first beta
|
|
if(this->GetCheatsEnabled() && theAvHPlayer)
|
|
{
|
|
GetGameRules()->SetCheatEnabled(kcViewAll);
|
|
theSuccess = true;
|
|
}
|
|
}
|
|
else if(FStrEq(pcmd, kcDeathMessage))
|
|
{
|
|
if(this->GetCheatsEnabled())
|
|
{
|
|
const char* theWeaponName = CMD_ARGV(1);
|
|
|
|
NetMsg_DeathMsg( theAvHPlayer->entindex(), theAvHPlayer->entindex(), string(theWeaponName) );
|
|
}
|
|
}
|
|
else if(FStrEq(pcmd, kcSetSkin))
|
|
{
|
|
if(this->GetCheatsEnabled())
|
|
{
|
|
int theSkin = 0;
|
|
if(sscanf(CMD_ARGV(1), "%d", &theSkin) == 1)
|
|
{
|
|
theAvHPlayer->SetSkin(theSkin);
|
|
|
|
theSuccess = true;
|
|
}
|
|
}
|
|
}
|
|
else if(FStrEq(pcmd, kcElectric))
|
|
{
|
|
if(this->GetCheatsEnabled())
|
|
{
|
|
bool theNewValue = !GetGameRules()->GetIsCheatEnabled(kcElectric);
|
|
GetGameRules()->SetCheatEnabled(kcElectric, theNewValue);
|
|
}
|
|
}
|
|
else if(FStrEq(pcmd, kcRoomType))
|
|
{
|
|
if(this->GetCheatsEnabled())
|
|
{
|
|
int theRoomType = 0;
|
|
if(sscanf(CMD_ARGV(1), "%d", &theRoomType) == 1)
|
|
{
|
|
MESSAGE_BEGIN( MSG_ONE, SVC_ROOMTYPE, NULL, theAvHPlayer->pev);
|
|
WRITE_SHORT( (short)theRoomType );
|
|
MESSAGE_END();
|
|
|
|
char theString[128];
|
|
sprintf(theString, "Set room type to %d.\n", theRoomType);
|
|
UTIL_SayText(theString, theAvHPlayer);
|
|
|
|
theSuccess = true;
|
|
}
|
|
}
|
|
}
|
|
#ifdef WIN32
|
|
else if(FStrEq(pcmd, "createfake"))
|
|
{
|
|
if(this->GetCheatsEnabled())
|
|
{
|
|
char theFakeClientName[256];
|
|
sprintf(theFakeClientName, "Bot%d", RANDOM_LONG(0, 2000));
|
|
edict_t* BotEnt = (*g_engfuncs.pfnCreateFakeClient)(theFakeClientName);
|
|
|
|
// create the player entity by calling MOD's player function
|
|
// (from LINK_ENTITY_TO_CLASS for player object)
|
|
player( VARS(BotEnt) );
|
|
|
|
char ptr[128]; // allocate space for message from ClientConnect
|
|
ClientConnect( BotEnt, theFakeClientName, "127.0.0.1", ptr );
|
|
|
|
// Pieter van Dijk - use instead of DispatchSpawn() - Hip Hip Hurray!
|
|
ClientPutInServer( BotEnt );
|
|
|
|
BotEnt->v.flags |= FL_FAKECLIENT;
|
|
}
|
|
}
|
|
#endif
|
|
#endif
|
|
else if( FStrEq( pcmd, kcGiveUpgrade) )
|
|
{
|
|
// Allow even with cheats off right now, put this back in for first beta
|
|
if(this->GetCheatsEnabled())
|
|
{
|
|
ReportPlayer(theAvHPlayer, pcmd);
|
|
|
|
int theUpgrade = 0;
|
|
sscanf(CMD_ARGV(1), "%d", &theUpgrade);
|
|
AvHMessageID theNewUpgrade = AvHMessageID(theUpgrade);
|
|
|
|
AvHTeam* theVisibleTeam = theAvHPlayer->GetTeamPointer(true);
|
|
if(theVisibleTeam)
|
|
{
|
|
theVisibleTeam->GetTechNodes().SetResearchDone(theNewUpgrade);
|
|
this->ProcessTeamUpgrade(theNewUpgrade, theAvHPlayer->GetTeam(true), 0, true);
|
|
}
|
|
theSuccess = true;
|
|
}
|
|
}
|
|
else if( FStrEq( pcmd, kcRemoveUpgrade) )
|
|
{
|
|
// Allow even with cheats off right now, put this back in for first beta
|
|
if(this->GetCheatsEnabled())
|
|
{
|
|
ReportPlayer(theAvHPlayer, pcmd);
|
|
|
|
int theUpgrade = 0;
|
|
sscanf(CMD_ARGV(1), "%d", &theUpgrade);
|
|
AvHMessageID theNewUpgrade = AvHMessageID(theUpgrade);
|
|
|
|
AvHTeam* theVisibleTeam = theAvHPlayer->GetTeamPointer(true);
|
|
if(theVisibleTeam)
|
|
{
|
|
theVisibleTeam->GetTechNodes().SetResearchDone(theNewUpgrade, false);
|
|
this->ProcessTeamUpgrade(theNewUpgrade, theAvHPlayer->GetTeam(true), 0, false);
|
|
}
|
|
|
|
theSuccess = true;
|
|
}
|
|
}
|
|
else if ( FStrEq( pcmd, kcSpectate ) )
|
|
{
|
|
if(theAvHPlayer)
|
|
{
|
|
if( !theAvHPlayer->GetIsAuthorized(AUTH_ACTION_JOIN_TEAM, TEAM_SPECT) )
|
|
{
|
|
AvHNexus::handleUnauthorizedJoinTeamAttempt(theAvHPlayer->edict(),TEAM_SPECT);
|
|
}
|
|
else if(allow_spectators.value)
|
|
{
|
|
if(theAvHPlayer->GetPlayMode() == PLAYMODE_READYROOM)
|
|
{
|
|
theAvHPlayer->SetPlayMode(PLAYMODE_OBSERVER);
|
|
//this->PutPlayerIntoSpectateMode(theAvHPlayer);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
theAvHPlayer->SendMessage(kSpectatorsNotAllowed, true);
|
|
}
|
|
theSuccess = true;
|
|
}
|
|
}
|
|
else if ( FStrEq( pcmd, kcGivePoints) )
|
|
{
|
|
// Allow even with cheats off right now, put this back in for first beta
|
|
if(this->GetCheatsEnabled() && theAvHPlayer)
|
|
{
|
|
int theAmount = 20;
|
|
|
|
theAvHPlayer->SetResources(theAvHPlayer->GetResources() + theAmount, true);
|
|
|
|
if(theTeam)
|
|
{
|
|
theTeam->AddResourcesGathered(theAmount);
|
|
}
|
|
|
|
theSuccess = true;
|
|
}
|
|
}
|
|
else if(FStrEq( pcmd, kcKillCS) )
|
|
{
|
|
if(this->GetCheatsEnabled())
|
|
{
|
|
if(theTeam)
|
|
{
|
|
theTeam->KillCS();
|
|
theSuccess = true;
|
|
}
|
|
}
|
|
}
|
|
else if(FStrEq( pcmd, kcKillHive) )
|
|
{
|
|
if(this->GetCheatsEnabled() || theIsPlaytest)
|
|
{
|
|
if(theTeam)
|
|
{
|
|
ReportPlayer(theAvHPlayer, pcmd);
|
|
theTeam->KillHive();
|
|
theSuccess = true;
|
|
}
|
|
}
|
|
}
|
|
else if(FStrEq( pcmd, kcSpawnHive) )
|
|
{
|
|
if(this->GetCheatsEnabled() || theIsPlaytest)
|
|
{
|
|
AvHTeam* theHiveTeam = theAvHPlayer->GetTeamPointer(true);
|
|
if( theHiveTeam->GetTeamType() != AVH_CLASS_TYPE_ALIEN )
|
|
{
|
|
for( int counter = TEAM_ACTIVE_BEGIN; counter < TEAM_ACTIVE_END; ++counter )
|
|
{
|
|
theHiveTeam = GetGameRules()->GetTeam((AvHTeamNumber)counter);
|
|
if( theHiveTeam && theHiveTeam->GetTeamType() == AVH_CLASS_TYPE_ALIEN )
|
|
{ break; }
|
|
}
|
|
}
|
|
|
|
if(theHiveTeam)
|
|
{
|
|
ReportPlayer(theAvHPlayer, pcmd);
|
|
theHiveTeam->SpawnHive();
|
|
theSuccess = true;
|
|
}
|
|
}
|
|
}
|
|
else if(FStrEq( pcmd, kcAlert) )
|
|
{
|
|
if(this->GetCheatsEnabled() && theAvHPlayer)
|
|
{
|
|
AvHTeam* theTeam = theAvHPlayer->GetTeamPointer(true);
|
|
if(theTeam)
|
|
{
|
|
if(theTeam->GetTeamType() == AVH_CLASS_TYPE_ALIEN)
|
|
{
|
|
// Look for random hive, set it under attack
|
|
AvHHive* theHive = AvHSUGetRandomActiveHive(theTeam->GetTeamNumber());
|
|
if(theHive)
|
|
{
|
|
AvHAlertType theRandomAlert = (RANDOM_LONG(0, 1) == 0) ? ALERT_HIVE_DYING : ALERT_UNDER_ATTACK;
|
|
GetGameRules()->TriggerAlert(theTeam->GetTeamNumber(), theRandomAlert, theHive->entindex());
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if(this->GetIsCombatMode())
|
|
{
|
|
// Find Command station, trigger alert (to test for soldiers on ground)
|
|
int theCCEntityIndex = 0;
|
|
FOR_ALL_ENTITIES(kwsTeamCommand, AvHCommandStation*)
|
|
theCCEntityIndex = theEntity->entindex();
|
|
break;
|
|
END_FOR_ALL_ENTITIES(kwsTeamCommand);
|
|
|
|
if(theCCEntityIndex > 0)
|
|
{
|
|
this->TriggerAlert(theTeam->GetTeamNumber(), ALERT_UNDER_ATTACK, theCCEntityIndex);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
int theRandomEntity = RANDOM_LONG(1, 500);
|
|
|
|
AvHAlertType theRandomAlert = AvHAlertType(RANDOM_LONG(0, ALERT_MAX_ALERTS-1));
|
|
GetGameRules()->TriggerAlert(theTeam->GetTeamNumber(), theRandomAlert, theRandomEntity);
|
|
}
|
|
}
|
|
|
|
theSuccess = true;
|
|
}
|
|
}
|
|
}
|
|
else if(FStrEq( pcmd, kcKillAll) )
|
|
{
|
|
if(this->GetCheatsEnabled())
|
|
{
|
|
FOR_ALL_ENTITIES(kAvHPlayerClassName, AvHPlayer*)
|
|
theEntity->TakeDamage(theAvHPlayer->pev, theAvHPlayer->pev, 2000, DMG_GENERIC | DMG_ALWAYSGIB);
|
|
END_FOR_ALL_ENTITIES(kAvHPlayerClassName);
|
|
|
|
theSuccess = true;
|
|
}
|
|
}
|
|
else if(FStrEq(pcmd, kcNumEnts))
|
|
{
|
|
bool theEnableNumEnts = GetGameRules()->GetCheatsEnabled();
|
|
|
|
if(theEnableNumEnts)
|
|
{
|
|
if(theAvHPlayer)
|
|
{
|
|
ReportPlayer(theAvHPlayer, pcmd);
|
|
}
|
|
|
|
int theEntityCount = this->GetNumEntities();
|
|
|
|
char theNumEntsString[1024];
|
|
sprintf(theNumEntsString, "Total entity count: %d\n", theEntityCount);
|
|
ALERT(at_console, theNumEntsString);
|
|
ALERT(at_logged, theNumEntsString);
|
|
}
|
|
|
|
theSuccess = true;
|
|
}
|
|
else if(FStrEq(pcmd, kcMapUtilNumEnts))
|
|
{
|
|
if(GetGameRules()->GetCheatsEnabled())
|
|
{
|
|
int theEntityCount = EntityInfoGetCount();
|
|
|
|
char theNumEntsString[1024];
|
|
sprintf(theNumEntsString, "Total map related entity count: %d\n", theEntityCount);
|
|
ALERT(at_console, theNumEntsString);
|
|
ALERT(at_logged, theNumEntsString);
|
|
}
|
|
|
|
theSuccess = true;
|
|
}
|
|
|
|
return theSuccess;
|
|
} |