You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
257 lines
10 KiB
257 lines
10 KiB
/* |
|
* |
|
* This program is free software; you can redistribute it and/or modify it |
|
* under the terms of the GNU General Public License as published by the |
|
* Free Software Foundation; either version 2 of the License, or (at |
|
* your option) any later version. |
|
* |
|
* This program is distributed in the hope that it will be useful, but |
|
* WITHOUT ANY WARRANTY; without even the implied warranty of |
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
|
* General Public License for more details. |
|
* |
|
* You should have received a copy of the GNU General Public License |
|
* along with this program; if not, write to the Free Software Foundation, |
|
* Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
|
* |
|
* In addition, as a special exception, the author gives permission to |
|
* link the code of this program with the Half-Life Game Engine ("HL |
|
* Engine") and Modified Game Libraries ("MODs") developed by Valve, |
|
* L.L.C ("Valve"). You must obey the GNU General Public License in all |
|
* respects for all of the code used other than the HL Engine and MODs |
|
* from Valve. If you modify this file, you may extend this exception |
|
* to your version of the file, but you are not obligated to do so. If |
|
* you do not wish to do so, delete this exception statement from your |
|
* version. |
|
* |
|
*/ |
|
|
|
#ifndef CS_BOT_MANAGER_H |
|
#define CS_BOT_MANAGER_H |
|
#ifdef _WIN32 |
|
#pragma once |
|
#endif |
|
|
|
extern CBotManager *TheBots; |
|
|
|
// The manager for Counter-Strike specific bots |
|
class CCSBotManager: public CBotManager |
|
{ |
|
public: |
|
CCSBotManager(); |
|
|
|
virtual void ClientDisconnect(CBasePlayer *pPlayer); |
|
virtual BOOL ClientCommand(CBasePlayer *pPlayer, const char *pcmd); |
|
|
|
virtual void ServerActivate(); |
|
virtual void ServerDeactivate(); |
|
|
|
virtual void ServerCommand(const char *pcmd); |
|
virtual void AddServerCommand(const char *cmd); |
|
virtual void AddServerCommands(); |
|
|
|
virtual void RestartRound(); // (EXTEND) invoked when a new round begins |
|
virtual void StartFrame(); // (EXTEND) called each frame |
|
|
|
virtual void OnEvent(GameEventType event, CBaseEntity *entity = NULL, CBaseEntity *other = NULL); |
|
virtual unsigned int GetPlayerPriority(CBasePlayer *player) const; // return priority of player (0 = max pri) |
|
virtual bool IsImportantPlayer(CBasePlayer *player) const; // return true if player is important to scenario (VIP, bomb carrier, etc) |
|
|
|
public: |
|
void ValidateMapData(); |
|
bool IsLearningMap() const { return m_isLearningMap; } |
|
void SetLearningMapFlag() { m_isLearningMap = true;} |
|
bool IsAnalysisRequested() const { return m_isAnalysisRequested; } |
|
void RequestAnalysis() { m_isAnalysisRequested = true; } |
|
void AckAnalysisRequest() { m_isAnalysisRequested = false; } |
|
|
|
// difficulty levels |
|
static BotDifficultyType GetDifficultyLevel() |
|
{ |
|
if (cv_bot_difficulty.value < 0.9f) |
|
return BOT_EASY; |
|
|
|
if (cv_bot_difficulty.value < 1.9f) |
|
return BOT_NORMAL; |
|
|
|
if (cv_bot_difficulty.value < 2.9f) |
|
return BOT_HARD; |
|
|
|
return BOT_EXPERT; |
|
} |
|
|
|
// the supported game scenarios |
|
enum GameScenarioType |
|
{ |
|
SCENARIO_DEATHMATCH, |
|
SCENARIO_DEFUSE_BOMB, |
|
SCENARIO_RESCUE_HOSTAGES, |
|
SCENARIO_ESCORT_VIP |
|
}; |
|
GameScenarioType GetScenario() const { return m_gameScenario; } |
|
|
|
// "zones" |
|
// depending on the game mode, these are bomb zones, rescue zones, etc. |
|
enum { MAX_ZONES = 4 }; // max # of zones in a map |
|
enum { MAX_ZONE_NAV_AREAS = 16 }; // max # of nav areas in a zone |
|
struct Zone |
|
{ |
|
CBaseEntity *m_entity; // the map entity |
|
CNavArea *m_area[MAX_ZONE_NAV_AREAS]; // nav areas that overlap this zone |
|
int m_areaCount; |
|
Vector m_center; |
|
bool m_isLegacy; // if true, use pev->origin and 256 unit radius as zone |
|
int m_index; |
|
Extent m_extent; |
|
}; |
|
|
|
const Zone *GetZone(int i) const { return &m_zone[i]; } |
|
const Zone *GetZone(const Vector *pos) const; // return the zone that contains the given position |
|
const Zone *GetClosestZone(const Vector *pos) const; // return the closest zone to the given position |
|
const Zone *GetClosestZone(const CBaseEntity *entity) const { return GetClosestZone(&entity->pev->origin); } // return the closest zone to the given entity |
|
int GetZoneCount() const { return m_zoneCount; } |
|
|
|
const Vector *GetRandomPositionInZone(const Zone *zone) const; |
|
CNavArea *GetRandomAreaInZone(const Zone *zone) const; |
|
|
|
// Return the zone closest to the given position, using the given cost heuristic |
|
template<typename CostFunctor> |
|
const Zone *GetClosestZone(CNavArea *startArea, CostFunctor costFunc, float *travelDistance = NULL) const |
|
{ |
|
const Zone *closeZone = NULL; |
|
float closeDist = 99999999.9f; |
|
|
|
if (startArea == NULL) |
|
return NULL; |
|
|
|
for (int i = 0; i < m_zoneCount; ++i) |
|
{ |
|
if (m_zone[i].m_areaCount == 0) |
|
continue; |
|
|
|
// just use the first overlapping nav area as a reasonable approximation |
|
float dist = NavAreaTravelDistance(startArea, m_zone[i].m_area[0], costFunc); |
|
|
|
if (/*dist >= 0.0f && */dist < closeDist) |
|
{ |
|
closeZone = &m_zone[i]; |
|
closeDist = dist; |
|
} |
|
} |
|
|
|
if (travelDistance != NULL) |
|
*travelDistance = closeDist; |
|
|
|
return closeZone; |
|
} |
|
|
|
// pick a zone at random and return it |
|
const Zone *GetRandomZone() const |
|
{ |
|
if (!m_zoneCount) |
|
return NULL; |
|
|
|
return &m_zone[ RANDOM_LONG(0, m_zoneCount - 1) ]; |
|
} |
|
|
|
bool IsBombPlanted() const { return m_isBombPlanted; } // returns true if bomb has been planted |
|
float GetBombPlantTimestamp() const { return m_bombPlantTimestamp; } // return time bomb was planted |
|
bool IsTimeToPlantBomb() const { return (gpGlobals->time >= m_earliestBombPlantTimestamp); } // return true if it's ok to try to plant bomb |
|
CBasePlayer *GetBombDefuser() const { return m_bombDefuser; } // return the player currently defusing the bomb, or NULL |
|
float GetBombTimeLeft() const; // get the time remaining before the planted bomb explodes |
|
CBaseEntity *GetLooseBomb() { return m_looseBomb; } // return the bomb if it is loose on the ground |
|
CNavArea *GetLooseBombArea() const { return m_looseBombArea; } // return area that bomb is in/near |
|
void SetLooseBomb(CBaseEntity *bomb); |
|
|
|
float GetRadioMessageTimestamp(GameEventType event, int teamID) const; // return the last time the given radio message was sent for given team |
|
float GetRadioMessageInterval(GameEventType event, int teamID) const; // return the interval since the last time this message was sent |
|
void SetRadioMessageTimestamp(GameEventType event, int teamID); |
|
void ResetRadioMessageTimestamps(); |
|
|
|
float GetLastSeenEnemyTimestamp() const { return m_lastSeenEnemyTimestamp; } // return the last time anyone has seen an enemy |
|
void SetLastSeenEnemyTimestamp() { m_lastSeenEnemyTimestamp = gpGlobals->time; } |
|
|
|
float GetRoundStartTime() const { return m_roundStartTimestamp; } |
|
float GetElapsedRoundTime() const { return gpGlobals->time - m_roundStartTimestamp; } // return the elapsed time since the current round began |
|
|
|
bool AllowRogues() const { return cv_bot_allow_rogues.value != 0.0f; } |
|
bool AllowPistols() const { return cv_bot_allow_pistols.value != 0.0f; } |
|
bool AllowShotguns() const { return cv_bot_allow_shotguns.value != 0.0f; } |
|
bool AllowSubMachineGuns() const { return cv_bot_allow_sub_machine_guns.value != 0.0f; } |
|
bool AllowRifles() const { return cv_bot_allow_rifles.value != 0.0f; } |
|
bool AllowMachineGuns() const { return cv_bot_allow_machine_guns.value != 0.0f; } |
|
bool AllowGrenades() const { return cv_bot_allow_grenades.value != 0.0f; } |
|
bool AllowSnipers() const { return cv_bot_allow_snipers.value != 0.0f; } |
|
bool AllowTacticalShield() const { return cv_bot_allow_shield.value != 0.0f; } |
|
bool AllowFriendlyFireDamage() const { return true; }//friendlyfire.value != 0.0f; } |
|
|
|
bool IsWeaponUseable(CBasePlayerItem *item) const; // return true if the bot can use this weapon |
|
|
|
bool IsDefenseRushing() const { return m_isDefenseRushing; } // returns true if defense team has "decided" to rush this round |
|
bool IsOnDefense(CBasePlayer *player) const; // return true if this player is on "defense" |
|
bool IsOnOffense(CBasePlayer *player) const; // return true if this player is on "offense" |
|
|
|
bool IsRoundOver() const { return m_isRoundOver; } // return true if the round has ended |
|
|
|
unsigned int GetNavPlace() const { return m_navPlace; } |
|
void SetNavPlace(unsigned int place) { m_navPlace = place; } |
|
|
|
enum SkillType { LOW, AVERAGE, HIGH, RANDOM }; |
|
NOXREF const char *GetRandomBotName(SkillType skill); |
|
|
|
static void MonitorBotCVars(); |
|
static void MaintainBotQuota(); |
|
static bool AddBot(const BotProfile *profile, BotProfileTeamType team); |
|
|
|
#define FROM_CONSOLE true |
|
static bool BotAddCommand(BotProfileTeamType team, bool isFromConsole = false); // process the "bot_add" console command |
|
|
|
private: |
|
static float m_flNextCVarCheck; |
|
static bool m_isMapDataLoaded; // true if we've attempted to load map data |
|
static bool m_isLearningMap; |
|
static bool m_isAnalysisRequested; |
|
|
|
GameScenarioType m_gameScenario; // what kind of game are we playing |
|
|
|
Zone m_zone[ MAX_ZONES ]; |
|
int m_zoneCount; |
|
|
|
bool m_isBombPlanted; // true if bomb has been planted |
|
float m_bombPlantTimestamp; // time bomb was planted |
|
float m_earliestBombPlantTimestamp; // don't allow planting until after this time has elapsed |
|
CBasePlayer *m_bombDefuser; // the player currently defusing a bomb |
|
EHANDLE m_looseBomb; // will be non-NULL if bomb is loose on the ground |
|
CNavArea *m_looseBombArea; // area that bomb is is/near |
|
|
|
bool m_isRoundOver; // true if the round has ended |
|
|
|
float m_radioMsgTimestamp[24][2]; |
|
|
|
float m_lastSeenEnemyTimestamp; |
|
float m_roundStartTimestamp; // the time when the current round began |
|
|
|
bool m_isDefenseRushing; // whether defensive team is rushing this round or not |
|
|
|
static NavEditCmdType m_editCmd; |
|
unsigned int m_navPlace; |
|
CountdownTimer m_respawnTimer; |
|
bool m_isRespawnStarted; |
|
bool m_canRespawn; |
|
bool m_bServerActive; |
|
}; |
|
|
|
NOXREF inline int OtherTeam(int team) |
|
{ |
|
return 0; |
|
} |
|
|
|
inline CCSBotManager *TheCSBots() |
|
{ |
|
return reinterpret_cast<CCSBotManager *>(TheBots); |
|
} |
|
|
|
void PrintAllEntities(); |
|
void UTIL_DrawBox(Extent *extent, int lifetime, int red, int green, int blue); |
|
|
|
#endif // CS_BOT_MANAGER_H
|
|
|