ReGameDLL_CS/regamedll/game_shared/bot/bot.h
2017-11-23 00:43:30 +07:00

423 lines
11 KiB
C++

/*
*
* 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.
*
*/
#pragma once
#include "gamerules.h"
// 30 times per second, just like human clients
constexpr float g_flBotCommandInterval = 1.0 / 30.0;
// full AI only 10 times per second
constexpr float g_flBotFullThinkInterval = 1.0 / 10.0;
class BotProfile;
template <class T, class TWrap>
T *CreateBot(const BotProfile *profile)
{
edict_t *pentBot;
if (UTIL_ClientsInGame() >= gpGlobals->maxClients)
{
CONSOLE_ECHO("Unable to create bot: Server is full (%d/%d clients).\n", UTIL_ClientsInGame(), gpGlobals->maxClients);
return nullptr;
}
char netname[64];
UTIL_ConstructBotNetName(netname, sizeof(netname), profile);
pentBot = CREATE_FAKE_CLIENT(netname);
if (FNullEnt(pentBot))
{
CONSOLE_ECHO("Unable to create bot: pfnCreateFakeClient() returned null.\n");
return nullptr;
}
else
{
T *pBot = nullptr;
FREE_PRIVATE(pentBot);
pBot = GetClassPtr<TWrap>((T *)VARS(pentBot));
pBot->Initialize(profile);
return pBot;
}
}
// The base bot class from which bots for specific games are derived
class CBot: public CBasePlayer
{
public:
// constructor initializes all values to zero
CBot();
virtual void Spawn();
// invoked when injured by something
virtual BOOL TakeDamage(entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int bitsDamageType)
{
return CBasePlayer::TakeDamage(pevInflictor, pevAttacker, flDamage, bitsDamageType);
}
// invoked when killed
virtual void Killed(entvars_t *pevAttacker, int iGib)
{
CBasePlayer::Killed(pevAttacker, iGib);
}
virtual void Think() {};
virtual BOOL IsBot() { return TRUE; }
virtual Vector GetAutoaimVector(float flDelta);
// invoked when in contact with a CWeaponBox
virtual void OnTouchingWeapon(CWeaponBox *box) {}
// prepare bot for action
virtual bool Initialize(const BotProfile *profile);
virtual void SpawnBot() = 0;
// lightweight maintenance, invoked frequently
virtual void Upkeep() = 0;
// heavyweight algorithms, invoked less often
virtual void Update() = 0;
virtual void Run();
virtual void Walk();
virtual void Crouch();
virtual void StandUp();
virtual void MoveForward();
virtual void MoveBackward();
virtual void StrafeLeft();
virtual void StrafeRight();
// returns true if jump was started
#define MUST_JUMP true
virtual bool Jump(bool mustJump = false);
// zero any MoveForward(), Jump(), etc
virtual void ClearMovement();
// Weapon interface
virtual void UseEnvironment();
virtual void PrimaryAttack();
virtual void ClearPrimaryAttack();
virtual void TogglePrimaryAttack();
virtual void SecondaryAttack();
virtual void Reload();
// invoked when event occurs in the game (some events have NULL entities)
virtual void OnEvent(GameEventType event, CBaseEntity *pEntity = nullptr, CBaseEntity *pOther = nullptr) {};
// return true if we can see the point
virtual bool IsVisible(const Vector *pos, bool testFOV = false) const = 0;
// return true if we can see any part of the player
virtual bool IsVisible(CBasePlayer *pPlayer, bool testFOV = false, unsigned char *visParts = nullptr) const = 0;
enum VisiblePartType : uint8
{
NONE = 0x00,
CHEST = 0x01,
HEAD = 0x02,
LEFT_SIDE = 0x04, // the left side of the object from our point of view (not their left side)
RIGHT_SIDE = 0x08, // the right side of the object from our point of view (not their right side)
FEET = 0x10
};
// if enemy is visible, return the part we see
virtual bool IsEnemyPartVisible(VisiblePartType part) const = 0;
// return true if player is facing towards us
virtual bool IsPlayerFacingMe(CBasePlayer *pOther) const;
// returns true if other player is pointing right at us
virtual bool IsPlayerLookingAtMe(CBasePlayer *pOther) const;
virtual void ExecuteCommand();
virtual void SetModel(const char *modelName);
public:
// return bot's unique ID
unsigned int GetID() const { return m_id; }
bool IsRunning() const { return m_isRunning; }
bool IsCrouching() const { return m_isCrouching; }
// push the current posture context onto the top of the stack
void PushPostureContext();
// restore the posture context to the next context on the stack
void PopPostureContext();
bool IsJumping();
// return time last jump began
float GetJumpTimestamp() const { return m_jumpTimestamp; }
// returns ratio of ammo left to max ammo (1 = full clip, 0 = empty)
float GetActiveWeaponAmmoRatio() const;
// return true if active weapon has any empty clip
bool IsActiveWeaponClipEmpty() const;
// return true if active weapon has no ammo at all
bool IsActiveWeaponOutOfAmmo() const;
// is the weapon in the middle of a reload
bool IsActiveWeaponReloading() const;
// return true if active weapon's bullet spray has become large and inaccurate
bool IsActiveWeaponRecoilHigh() const;
// return the weapon the bot is currently using
CBasePlayerWeapon *GetActiveWeapon() const;
// return true if looking thru weapon's scope
bool IsUsingScope() const;
// returns TRUE if given entity is our enemy
bool IsEnemy(CBaseEntity *pEntity) const;
// return number of enemies left alive
int GetEnemiesRemaining() const;
// return number of friends left alive
int GetFriendsRemaining() const;
// return true if local player is observing this bot
bool IsLocalPlayerWatchingMe() const;
// output message to console
void Print(char *format,...) const;
// output message to console if we are being watched by the local player
void PrintIfWatched(char *format,...) const;
void BotThink();
#ifdef REGAMEDLL_FIXES
BOOL IsNetClient() { return FALSE; }
#else
// The ambiguous function because there is a virtual function in inherited classes.
bool IsNetClient() const { return false; }
int Save(CSave &save) const;
int Restore(CRestore &restore) const;
#endif
// return our personality profile
const BotProfile *GetProfile() const { return m_profile; }
enum BotRelationshipTeam: uint8
{
BOT_TEAMMATE = 0,
BOT_ENEMY
};
BotRelationshipTeam BotRelationship(CBasePlayer *pTarget) const;
protected:
#ifndef REGAMEDLL_FIXES
// Do a "client command" - useful for invoking menu choices, etc.
void ClientCommand(const char *cmd, const char *arg1 = nullptr, const char *arg2 = nullptr, const char *arg3 = nullptr);
#endif
// the "personality" profile of this bot
const BotProfile *m_profile;
private:
void ResetCommand();
byte ThrottledMsec() const;
// returns current movement speed (for walk/run)
float GetMoveSpeed();
// unique bot ID
unsigned int m_id;
// Think mechanism variables
float m_flNextBotThink;
float m_flNextFullBotThink;
// Command interface variables
float m_flPreviousCommandTime;
// run/walk mode
bool m_isRunning;
// true if crouching (ducking)
bool m_isCrouching;
float m_forwardSpeed;
float m_strafeSpeed;
float m_verticalSpeed;
// bitfield of movement buttons
unsigned short m_buttonFlags;
// time when we last began a jump
float m_jumpTimestamp;
// the PostureContext represents the current settings of walking and crouching
struct PostureContext
{
bool isRunning;
bool isCrouching;
};
enum { MAX_POSTURE_STACK = 8 };
PostureContext m_postureStack[MAX_POSTURE_STACK];
// index of top of stack
int m_postureStackIndex;
};
inline void CBot::SetModel(const char *modelName)
{
SET_CLIENT_KEY_VALUE(entindex(), GET_INFO_BUFFER(edict()), "model", (char *)modelName);
}
inline float CBot::GetMoveSpeed()
{
if (m_isRunning || m_isCrouching)
return pev->maxspeed;
return 0.4f * pev->maxspeed;
}
inline void CBot::Run()
{
m_isRunning = true;
}
inline void CBot::Walk()
{
m_isRunning = false;
}
inline CBasePlayerWeapon *CBot::GetActiveWeapon() const
{
return static_cast<CBasePlayerWeapon *>(m_pActiveItem);
}
inline bool CBot::IsActiveWeaponReloading() const
{
CBasePlayerWeapon *pCurrentWeapon = GetActiveWeapon();
if (!pCurrentWeapon)
return false;
return (pCurrentWeapon->m_fInReload || pCurrentWeapon->m_fInSpecialReload) != 0;
}
inline bool CBot::IsActiveWeaponRecoilHigh() const
{
CBasePlayerWeapon *pCurrentWeapon = GetActiveWeapon();
if (pCurrentWeapon)
{
const float highRecoil = 0.4f;
return (pCurrentWeapon->m_flAccuracy > highRecoil) != 0;
}
return false;
}
inline void CBot::PushPostureContext()
{
if (m_postureStackIndex == MAX_POSTURE_STACK)
{
if (pev)
{
PrintIfWatched("PushPostureContext() overflow error!\n");
}
return;
}
m_postureStack[m_postureStackIndex].isRunning = m_isRunning;
m_postureStack[m_postureStackIndex].isCrouching = m_isCrouching;
m_postureStackIndex++;
}
inline void CBot::PopPostureContext()
{
if (m_postureStackIndex == 0)
{
if (pev)
{
PrintIfWatched("PopPostureContext() underflow error!\n");
}
m_isRunning = true;
m_isCrouching = false;
return;
}
m_postureStackIndex--;
m_isRunning = m_postureStack[m_postureStackIndex].isRunning;
m_isCrouching = m_postureStack[m_postureStackIndex].isCrouching;
}
inline bool CBot::IsPlayerFacingMe(CBasePlayer *pOther) const
{
Vector toOther = pOther->pev->origin - pev->origin;
UTIL_MakeVectors(pOther->pev->v_angle + pOther->pev->punchangle);
Vector otherDir = gpGlobals->v_forward;
if (otherDir.x * toOther.x + otherDir.y * toOther.y < 0.0f)
return true;
return false;
}
inline bool CBot::IsPlayerLookingAtMe(CBasePlayer *pOther) const
{
Vector toOther = pOther->pev->origin - pev->origin;
toOther.NormalizeInPlace();
UTIL_MakeVectors(pOther->pev->v_angle + pOther->pev->punchangle);
Vector otherDir = gpGlobals->v_forward;
const float lookAtCos = 0.9f;
if (otherDir.x * toOther.x + otherDir.y * toOther.y < -lookAtCos)
{
Vector vec(pOther->EyePosition());
if (IsVisible(&vec))
return true;
}
return false;
}
inline CBot::BotRelationshipTeam CBot::BotRelationship(CBasePlayer *pTarget) const
{
#ifdef REGAMEDLL_ADD
if (CSGameRules()->IsFreeForAll())
return BOT_ENEMY;
#endif
return pTarget->m_iTeam == m_iTeam ? BOT_TEAMMATE : BOT_ENEMY;
}
extern const char *BotArgs[4];
extern bool UseBotArgs;
extern bool AreBotsAllowed();