ensl/NS
0
0
Fork 0
mirror of https://github.com/ENSL/NS.git synced 2024-11-25 05:51:11 +00:00
Code Issues Projects Releases Packages Wiki Activity
NS/main/source/mod/AvHConsoleCommands.cpp
RGreenlees 6021daabab Wave attacking implementation
2024-05-08 14:43:14 -04:00

1784 lines
No EOL
46 KiB
C++
Raw Blame History

//======== (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 "AvHGamerules.h"
#include "AvHConstants.h"
#include "AvHMarineEquipmentConstants.h"
#include "AvHEntities.h"
#include "AvHParticleTemplateServer.h"
#include "AvHPlayer.h"
#include "../dlls/client.h"
#include "../dlls/game.h"
#include "../dlls/util.h"
#include "AvHServerUtil.h"
#include "AvHServerVariables.h"
#include "AvHMessage.h"
#include "AvHSoundListManager.h"
#include "AvHServerUtil.h"
#include "AvHTitles.h"
#include "AvHParticleSystemManager.h"
#include "AvHMarineEquipment.h"
#include "AvHMovementUtil.h"
#include "AvHSharedUtil.h"
#include "../textrep/TRFactory.h"
#include "AvHEntities.h"
#include "AvHScriptManager.h"
#include "AvHCommandConstants.h"
#include "AvHPlayerUpgrade.h"
#include <stdio.h>
#include "../game_shared/voice_gamemgr.h"
#include "AvHNetworkMessages.h"
#include "AvHNexusServer.h"
#include "AvHAIPlayerUtil.h"
#include "AvHAIHelper.h"
#include "AvHAIMath.h"
#include "AvHAINavigation.h"
#include "AvHAIPlayerManager.h"
#include "AvHAITask.h"
#include "AvHAITactical.h"
#include "AvHAICommander.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 DEBUG
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, kcMenuReadyRoom ) )
{
if(theAvHPlayer)
{
if (!theAvHPlayer->GetIsBeingDigested())
{
theAvHPlayer->SetPlayMode(PLAYMODE_READYROOM, true);
}
theSuccess = true;
}
theSuccess = true;
}
else if ( FStrEq( pcmd, kcReadyRoom ) )
{
if(theAvHPlayer)
{
if (!theAvHPlayer->GetIsBeingDigested())
{
// : 984
// Add a throttle on the readyroom key
const static int kReadyRoomThrottleTimeout = 2.0f;
if ((theAvHPlayer->GetTimeLastF4() == -1.0f) ||
(gpGlobals->time > theAvHPlayer->GetTimeLastF4() + kReadyRoomThrottleTimeout))
{
theAvHPlayer->SendMessage(kReadyRoomThrottleMessage);
theAvHPlayer->SetTimeLastF4(gpGlobals->time);
}
else if (gpGlobals->time < theAvHPlayer->GetTimeLastF4() + kReadyRoomThrottleTimeout)
{
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);
// : 0001010 - Boost the player 32 units up to avoid sticking in the ground
theCurrentPosition[2] += 32.0f;
// 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
// : 0001073
#ifdef USE_OLDAUTH
else if(FStrEq(pcmd, "forceuplink"))
{
if(theIsDeveloper || theIsDedicatedServer)
{
this->InitializeAuthentication();
UTIL_SayText("Initialized authentication.", theAvHPlayer);
}
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(true);
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)?TOOLTIP:NORMAL);
}
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(), TOOLTIP);
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);
sscanf(CMD_ARGV(1), "%f", &this->mMapGammaAlt);
}
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, TOOLTIP);
NetMsg_EditPS( theAvHPlayer->pev, theParticleIndex );
}
else
{
theAvHPlayer->SendMessage(kNoParticleSystem, TOOLTIP);
}
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 (!theAvHPlayer || theIsServerOp || theIsPlaytest || theIsDedicatedServer || 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;
}*/
theSuccess = true;
}
#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;
}
}
#ifdef BOTDEBUG
else if (FStrEq(pcmd, "bot_setdebugaiplayer"))
{
CBaseEntity* SpectatedPlayer = theAvHPlayer->GetSpectatingEntity();
if (SpectatedPlayer)
{
AIMGR_SetDebugAIPlayer(theAvHPlayer->edict(), SpectatedPlayer->edict());
}
else
{
AIMGR_SetDebugAIPlayer(theAvHPlayer->edict(), nullptr);
}
theSuccess = true;
}
#endif
else if (FStrEq(pcmd, "bot_cometome"))
{
vector<AvHAIPlayer*> AIPlayers = AIMGR_GetAllAIPlayers();
for (auto it = AIPlayers.begin(); it != AIPlayers.end(); it++)
{
AvHAIPlayer* thisBot = (*it);
AITASK_SetMoveTask(thisBot, &thisBot->PrimaryBotTask, theAvHPlayer->pev->origin, true);
}
theSuccess = true;
}
else if (FStrEq(pcmd, "bot_drawtempobstacles"))
{
AIDEBUG_DrawTemporaryObstacles(10.0f);
theSuccess = true;
}
else if (FStrEq(pcmd, "bot_drawoffmeshconns"))
{
AIDEBUG_DrawOffMeshConnections(10.0f);
theSuccess = true;
}
else if (FStrEq(pcmd, "bot_evolveskulk"))
{
vector<AvHAIPlayer*> AIPlayers = AIMGR_GetAllAIPlayers();
for (auto it = AIPlayers.begin(); it != AIPlayers.end(); it++)
{
AvHAIPlayer* thisBot = (*it);
if (!IsPlayerAlien(thisBot->Edict) || !IsPlayerActiveInGame(thisBot->Edict)) { continue; }
AITASK_SetEvolveTask(thisBot, &thisBot->PrimaryBotTask, thisBot->CurrentFloorPosition, ALIEN_LIFEFORM_ONE, true);
}
theSuccess = true;
}
else if (FStrEq(pcmd, "bot_evolvegorge"))
{
vector<AvHAIPlayer*> AIPlayers = AIMGR_GetAllAIPlayers();
for (auto it = AIPlayers.begin(); it != AIPlayers.end(); it++)
{
AvHAIPlayer* thisBot = (*it);
if (!IsPlayerAlien(thisBot->Edict) || !IsPlayerActiveInGame(thisBot->Edict)) { continue; }
if (thisBot->Player->GetResources() < BALANCE_VAR(kGorgeCost))
{
thisBot->Player->GiveResources(BALANCE_VAR(kGorgeCost));
}
AITASK_SetEvolveTask(thisBot, &thisBot->PrimaryBotTask, thisBot->CurrentFloorPosition, ALIEN_LIFEFORM_TWO, true);
}
theSuccess = true;
}
else if (FStrEq(pcmd, "bot_evolvelerk"))
{
vector<AvHAIPlayer*> AIPlayers = AIMGR_GetAllAIPlayers();
for (auto it = AIPlayers.begin(); it != AIPlayers.end(); it++)
{
AvHAIPlayer* thisBot = (*it);
if (!IsPlayerAlien(thisBot->Edict) || !IsPlayerActiveInGame(thisBot->Edict)) { continue; }
if (thisBot->Player->GetResources() < BALANCE_VAR(kLerkCost))
{
thisBot->Player->GiveResources(BALANCE_VAR(kLerkCost));
}
AITASK_SetEvolveTask(thisBot, &thisBot->PrimaryBotTask, thisBot->CurrentFloorPosition, ALIEN_LIFEFORM_THREE, true);
}
theSuccess = true;
}
else if (FStrEq(pcmd, "bot_evolvefade"))
{
vector<AvHAIPlayer*> AIPlayers = AIMGR_GetAllAIPlayers();
for (auto it = AIPlayers.begin(); it != AIPlayers.end(); it++)
{
AvHAIPlayer* thisBot = (*it);
if (!IsPlayerAlien(thisBot->Edict) || !IsPlayerActiveInGame(thisBot->Edict)) { continue; }
if (thisBot->Player->GetResources() < BALANCE_VAR(kFadeCost))
{
thisBot->Player->GiveResources(BALANCE_VAR(kFadeCost));
}
AITASK_SetEvolveTask(thisBot, &thisBot->PrimaryBotTask, thisBot->CurrentFloorPosition, ALIEN_LIFEFORM_FOUR, true);
}
theSuccess = true;
}
else if (FStrEq(pcmd, "bot_evolveonos"))
{
vector<AvHAIPlayer*> AIPlayers = AIMGR_GetAllAIPlayers();
for (auto it = AIPlayers.begin(); it != AIPlayers.end(); it++)
{
AvHAIPlayer* thisBot = (*it);
if (!IsPlayerAlien(thisBot->Edict) || !IsPlayerActiveInGame(thisBot->Edict)) { continue; }
if (thisBot->Player->GetResources() < BALANCE_VAR(kOnosCost))
{
thisBot->Player->GiveResources(BALANCE_VAR(kOnosCost));
}
AITASK_SetEvolveTask(thisBot, &thisBot->PrimaryBotTask, thisBot->CurrentFloorPosition, ALIEN_LIFEFORM_FIVE, 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);
}*/
// : 0001073
#ifdef USE_OLDAUTH
if(allow_spectators.value && GetGameRules()->PerformHardAuthorization(theAvHPlayer))
#else
else if(allow_spectators.value)
#endif
{
if(theAvHPlayer->GetPlayMode() == PLAYMODE_READYROOM)
{
theAvHPlayer->SetPlayMode(PLAYMODE_OBSERVER);
//this->PutPlayerIntoSpectateMode(theAvHPlayer);
}
}
else
{
theAvHPlayer->SendMessage(kSpectatorsNotAllowed, TOOLTIP);
}
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;
}
}
// : 0001073
#ifdef USE_OLDAUTH
#ifndef AVH_SECURE_PRERELEASE_BUILD
else if(FStrEq(pcmd, kcAuth))
{
// Toggle auth mask
bool theNewState = !theAvHPlayer->GetAllowAuth();
theAvHPlayer->SetAllowAuth(theNewState);
if(theNewState)
{
UTIL_SayText("Authentication ON\n", theAvHPlayer);
}
else
{
UTIL_SayText("Authentication OFF\n", theAvHPlayer);
}
theSuccess = true;
}
#endif
#endif
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;
}
Reference in a new issue View git blame Copy permalink