nav: various fixes to movement code
refactor: move some things into new game state class
This commit is contained in:
jeefo
parent
6604145481
commit
7b378ba3fa
29 changed files with 805 additions and 745 deletions
|
|
@ -311,7 +311,7 @@ void GraphAnalyze::flood (const Vector &pos, const Vector &next, float range) {
|
|||
game.testHull (pos, { next.x, next.y, next.z + 19.0f }, TraceIgnore::Monsters, head_hull, nullptr, &tr);
|
||||
|
||||
// we're can't reach next point
|
||||
if (!cr::fequal (tr.flFraction, 1.0f) && !util.isBreakableEntity (tr.pHit)) {
|
||||
if (!cr::fequal (tr.flFraction, 1.0f) && !game.isBreakableEntity (tr.pHit)) {
|
||||
return;
|
||||
}
|
||||
|
||||
|
|
|
|||
158
src/botlib.cpp
158
src/botlib.cpp
|
|
@ -37,7 +37,7 @@ ConVar cv_pickup_custom_items ("pickup_custom_items", "0", "Allows or disallows
|
|||
ConVar cv_pickup_ammo_and_kits ("pickup_ammo_and_kits", "0", "Allows bots to pick up mod items like ammo, health kits, and suits.");
|
||||
ConVar cv_pickup_best ("pickup_best", "1", "Allows or disallows bots to pick up the best weapons.");
|
||||
ConVar cv_ignore_objectives ("ignore_objectives", "0", "Allows or disallows bots to do map objectives, i.e. plant/defuse bombs, and save hostages.");
|
||||
ConVar cv_smoke_grenade_checks ("smoke_grenade_checks", "2", "Affects the bot's vision by smoke clouds.", true, 0.0f, 2.0f);
|
||||
ConVar cv_smoke_grenade_checks ("smoke_grenade_checks", "1", "Affects the bot's vision by smoke clouds.", true, 0.0f, 2.0f);
|
||||
|
||||
// game console variables
|
||||
ConVar mp_c4timer ("mp_c4timer", nullptr, Var::GameRef);
|
||||
|
|
@ -78,10 +78,10 @@ void Bot::avoidGrenades () {
|
|||
m_needAvoidGrenade = 0;
|
||||
}
|
||||
|
||||
if (!bots.hasActiveGrenades ()) {
|
||||
if (!gameState.hasActiveGrenades ()) {
|
||||
return;
|
||||
}
|
||||
const auto &activeGrenades = bots.getActiveGrenades ();
|
||||
const auto &activeGrenades = gameState.getActiveGrenades ();
|
||||
|
||||
// find all grenades on the map
|
||||
for (const auto &pent : activeGrenades) {
|
||||
|
|
@ -105,7 +105,7 @@ void Bot::avoidGrenades () {
|
|||
}
|
||||
}
|
||||
else if (game.isNullEntity (m_avoidGrenade) && model == kExplosiveModelName) {
|
||||
if (game.getTeam (pent->v.owner) == m_team || pent->v.owner == ent ()) {
|
||||
if (game.getPlayerTeam (pent->v.owner) == m_team || pent->v.owner == ent ()) {
|
||||
continue;
|
||||
}
|
||||
|
||||
|
|
@ -209,7 +209,7 @@ void Bot::checkBreakablesAround () {
|
|||
continue;
|
||||
}
|
||||
|
||||
if (!util.isBreakableEntity (breakable)) {
|
||||
if (!game.isBreakableEntity (breakable)) {
|
||||
continue;
|
||||
}
|
||||
|
||||
|
|
@ -257,7 +257,7 @@ edict_t *Bot::lookupBreakable () {
|
|||
// this function checks if bot is blocked by a shoot able breakable in his moving direction
|
||||
|
||||
// we're got something already
|
||||
if (util.isBreakableEntity (m_breakableEntity)) {
|
||||
if (game.isBreakableEntity (m_breakableEntity)) {
|
||||
return m_breakableEntity;
|
||||
}
|
||||
const float detectBreakableDistance = (usesKnife () || isOnLadder ()) ? 32.0f : rg (72.0f, 256.0f);
|
||||
|
|
@ -270,7 +270,7 @@ edict_t *Bot::lookupBreakable () {
|
|||
auto hit = tr.pHit;
|
||||
|
||||
// check if this isn't a triggered (bomb) breakable and if it takes damage. if true, shoot the crap!
|
||||
if (util.isBreakableEntity (hit)) {
|
||||
if (game.isBreakableEntity (hit)) {
|
||||
m_breakableOrigin = game.getEntityOrigin (hit);
|
||||
m_breakableEntity = hit;
|
||||
|
||||
|
|
@ -286,7 +286,7 @@ edict_t *Bot::lookupBreakable () {
|
|||
}
|
||||
|
||||
// check breakable team, needed for some plugins
|
||||
if (ent->v.team > 0 && ent->v.team != game.getGameTeam (this->ent ())) {
|
||||
if (ent->v.team > 0 && ent->v.team != game.getPlayerTeamGame (this->ent ())) {
|
||||
return false;
|
||||
}
|
||||
|
||||
|
|
@ -362,7 +362,7 @@ void Bot::updatePickups () {
|
|||
}
|
||||
|
||||
// no interesting entities, how ?
|
||||
else if (!bots.hasInterestingEntities ()) {
|
||||
else if (!gameState.hasInterestingEntities ()) {
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
|
|
@ -376,7 +376,7 @@ void Bot::updatePickups () {
|
|||
return;
|
||||
}
|
||||
|
||||
const auto &interesting = bots.getInterestingEntities ();
|
||||
const auto &interesting = gameState.getInterestingEntities ();
|
||||
const float radiusSq = cr::sqrf (cv_object_pickup_radius.as <float> ());
|
||||
|
||||
if (!game.isNullEntity (m_pickupItem)) {
|
||||
|
|
@ -446,7 +446,7 @@ void Bot::updatePickups () {
|
|||
const bool isHostageRescueMap = game.mapIs (MapFlags::HostageRescue);
|
||||
const bool isCSDM = game.is (GameFlags::CSDM);
|
||||
|
||||
if (isHostageRescueMap && util.isHostageEntity (ent)) {
|
||||
if (isHostageRescueMap && game.isHostageEntity (ent)) {
|
||||
allowPickup = true;
|
||||
pickupType = Pickup::Hostage;
|
||||
}
|
||||
|
|
@ -551,7 +551,7 @@ void Bot::updatePickups () {
|
|||
allowPickup = true;
|
||||
pickupType = Pickup::PlantedC4;
|
||||
}
|
||||
else if (cv_pickup_custom_items && util.isItem (ent) && !classname.startsWith ("item_thighpack")) {
|
||||
else if (cv_pickup_custom_items && game.isItemEntity (ent) && !classname.startsWith ("item_thighpack")) {
|
||||
allowPickup = true;
|
||||
pickupType = Pickup::Items;
|
||||
}
|
||||
|
|
@ -632,7 +632,7 @@ void Bot::updatePickups () {
|
|||
const auto &path = graph[index];
|
||||
|
||||
const float bombTimer = mp_c4timer.as <float> ();
|
||||
const float timeMidBlowup = bots.getTimeBombPlanted () + (bombTimer * 0.5f + bombTimer * 0.25f) - graph.calculateTravelTime (pev->maxspeed, pev->origin, path.origin);
|
||||
const float timeMidBlowup = gameState.getTimeBombPlanted () + (bombTimer * 0.5f + bombTimer * 0.25f) - graph.calculateTravelTime (pev->maxspeed, pev->origin, path.origin);
|
||||
|
||||
if (timeMidBlowup > game.time ()) {
|
||||
clearTask (Task::MoveToPosition); // remove any move tasks
|
||||
|
|
@ -683,7 +683,7 @@ void Bot::updatePickups () {
|
|||
}
|
||||
}
|
||||
else if (pickupType == Pickup::PlantedC4) {
|
||||
if (util.isAlive (m_enemy)) {
|
||||
if (game.isAliveEntity (m_enemy)) {
|
||||
return;
|
||||
}
|
||||
|
||||
|
|
@ -706,7 +706,7 @@ void Bot::updatePickups () {
|
|||
const int index = findDefendNode (origin);
|
||||
const auto &path = graph[index];
|
||||
|
||||
const float timeToExplode = bots.getTimeBombPlanted () + mp_c4timer.as <float> () - graph.calculateTravelTime (pev->maxspeed, pev->origin, path.origin);
|
||||
const float timeToExplode = gameState.getTimeBombPlanted () + mp_c4timer.as <float> () - graph.calculateTravelTime (pev->maxspeed, pev->origin, path.origin);
|
||||
|
||||
clearTask (Task::MoveToPosition); // remove any move tasks
|
||||
|
||||
|
|
@ -1294,7 +1294,7 @@ void Bot::buyStuff () {
|
|||
const auto tab = conf.getRawWeapons ();
|
||||
|
||||
const bool isPistolMode = tab[25].teamStandard == -1 && tab[3].teamStandard == 2;
|
||||
const bool teamHasGoodEconomics = bots.checkTeamEco (m_team);
|
||||
const bool teamHasGoodEconomics = bots.getTeamEconomics (m_team);
|
||||
|
||||
// do this, because xash engine is not capable to run all the features goldsrc, but we have cs 1.6 on it, so buy table must be the same
|
||||
const bool isOldGame = game.is (GameFlags::Legacy);
|
||||
|
|
@ -1696,7 +1696,7 @@ void Bot::overrideConditions () {
|
|||
// check if we need to escape from bomb
|
||||
if ((tid == Task::Normal || tid == Task::MoveToPosition)
|
||||
&& game.mapIs (MapFlags::Demolition)
|
||||
&& bots.isBombPlanted ()
|
||||
&& gameState.isBombPlanted ()
|
||||
&& m_isAlive
|
||||
&& tid != Task::EscapeFromBomb
|
||||
&& tid != Task::Camp
|
||||
|
|
@ -1710,7 +1710,7 @@ void Bot::overrideConditions () {
|
|||
float reachEnemyKnifeDistanceSq = cr::sqrf (128.0f);
|
||||
|
||||
// special handling, if we have a knife in our hands
|
||||
if (isKnifeMode () && (util.isPlayer (m_enemy) || (cv_attack_monsters && util.isMonster (m_enemy)))) {
|
||||
if (isKnifeMode () && (game.isPlayerEntity (m_enemy) || (cv_attack_monsters && game.isMonsterEntity (m_enemy)))) {
|
||||
const auto distanceSq2d = pev->origin.distanceSq2d (m_enemy->v.origin);
|
||||
const auto nearestToEnemyPoint = graph.getNearest (m_enemy->v.origin);
|
||||
|
||||
|
|
@ -1760,7 +1760,7 @@ void Bot::overrideConditions () {
|
|||
}
|
||||
|
||||
// special handling for reloading
|
||||
if (!bots.isRoundOver ()
|
||||
if (!gameState.isRoundOver ()
|
||||
&& tid == Task::Normal
|
||||
&& m_reloadState != Reload::None
|
||||
&& m_isReloading
|
||||
|
|
@ -1787,7 +1787,7 @@ void Bot::overrideConditions () {
|
|||
if (game.is (GameFlags::ZombieMod)
|
||||
&& !m_isCreature
|
||||
&& m_infectedEnemyTeam
|
||||
&& util.isAlive (m_enemy)
|
||||
&& game.isAliveEntity (m_enemy)
|
||||
&& m_retreatTime < game.time ()
|
||||
&& pev->origin.distanceSq2d (m_enemy->v.origin) < cr::sqrf (512.0f)) {
|
||||
|
||||
|
|
@ -1811,7 +1811,7 @@ void Bot::syncUpdatePredictedIndex () {
|
|||
const auto &lastEnemyOrigin = m_lastEnemyOrigin;
|
||||
const auto currentNodeIndex = m_currentNodeIndex;
|
||||
|
||||
if (lastEnemyOrigin.empty () || !vistab.isReady () || !util.isAlive (m_lastEnemy)) {
|
||||
if (lastEnemyOrigin.empty () || !vistab.isReady () || !game.isAliveEntity (m_lastEnemy)) {
|
||||
wipePredict ();
|
||||
return;
|
||||
}
|
||||
|
|
@ -1849,7 +1849,7 @@ void Bot::syncUpdatePredictedIndex () {
|
|||
}
|
||||
|
||||
void Bot::updatePredictedIndex () {
|
||||
if (!m_isAlive || m_lastEnemyOrigin.empty () || !vistab.isReady () || !util.isAlive (m_lastEnemy)) {
|
||||
if (!m_isAlive || m_lastEnemyOrigin.empty () || !vistab.isReady () || !game.isAliveEntity (m_lastEnemy)) {
|
||||
return; // do not run task if no last enemy
|
||||
}
|
||||
|
||||
|
|
@ -1904,7 +1904,7 @@ void Bot::setConditions () {
|
|||
|
||||
// did bot just kill an enemy?
|
||||
if (!game.isNullEntity (m_lastVictim)) {
|
||||
if (game.getTeam (m_lastVictim) != m_team) {
|
||||
if (game.getPlayerTeam (m_lastVictim) != m_team) {
|
||||
// add some aggression because we just killed somebody
|
||||
m_agressionLevel += 0.1f;
|
||||
|
||||
|
|
@ -1969,7 +1969,7 @@ void Bot::setConditions () {
|
|||
}
|
||||
|
||||
// if no more enemies found AND bomb planted, switch to knife to get to bomb place faster
|
||||
if (m_team == Team::CT && !usesKnife () && m_numEnemiesLeft == 0 && bots.isBombPlanted ()) {
|
||||
if (m_team == Team::CT && !usesKnife () && m_numEnemiesLeft == 0 && gameState.isBombPlanted ()) {
|
||||
selectWeaponById (Weapon::Knife);
|
||||
m_plantedBombNodeIndex = getNearestToPlantedBomb ();
|
||||
|
||||
|
|
@ -1990,7 +1990,7 @@ void Bot::setConditions () {
|
|||
|
||||
// check if our current enemy is still valid
|
||||
if (!game.isNullEntity (m_lastEnemy)) {
|
||||
if (!util.isAlive (m_lastEnemy) && m_shootAtDeadTime < game.time ()) {
|
||||
if (!game.isAliveEntity (m_lastEnemy) && m_shootAtDeadTime < game.time ()) {
|
||||
m_lastEnemy = nullptr;
|
||||
}
|
||||
}
|
||||
|
|
@ -2089,7 +2089,7 @@ void Bot::filterTasks () {
|
|||
float &blindedDesire = filter[Task::Blind].desire;
|
||||
|
||||
// calculate desires to seek cover or hunt
|
||||
if (util.isPlayer (m_lastEnemy) && !m_lastEnemyOrigin.empty () && !m_hasC4) {
|
||||
if (game.isPlayerEntity (m_lastEnemy) && !m_lastEnemyOrigin.empty () && !m_hasC4) {
|
||||
const float retreatLevel = (100.0f - (m_healthValue > 70.0f ? 100.0f : m_healthValue)) * tempFear; // retreat level depends on bot health
|
||||
|
||||
if (m_isCreature ||
|
||||
|
|
@ -2117,7 +2117,7 @@ void Bot::filterTasks () {
|
|||
if (m_isCreature) {
|
||||
ratio = 0.0f;
|
||||
}
|
||||
if (bots.isBombPlanted () || m_isStuck || usesKnife ()) {
|
||||
if (gameState.isBombPlanted () || m_isStuck || usesKnife ()) {
|
||||
ratio /= 3.0f; // reduce the seek cover desire if bomb is planted
|
||||
}
|
||||
else if (m_isVIP || m_isReloading || (sniping && usesSniper ())) {
|
||||
|
|
@ -2139,7 +2139,7 @@ void Bot::filterTasks () {
|
|||
if (getCurrentTaskId () != Task::EscapeFromBomb
|
||||
&& game.isNullEntity (m_enemy)
|
||||
&& !m_isVIP
|
||||
&& bots.getRoundMidTime () < game.time ()
|
||||
&& gameState.getRoundMidTime () < game.time ()
|
||||
&& !m_hasHostage
|
||||
&& !m_isUsingGrenade
|
||||
&& m_currentNodeIndex != graph.getNearest (m_lastEnemyOrigin)
|
||||
|
|
@ -2256,10 +2256,11 @@ void Bot::startTask (Task id, float desire, int data, float time, bool resume) {
|
|||
}
|
||||
return;
|
||||
}
|
||||
else {
|
||||
clearSearchNodes ();
|
||||
}
|
||||
}
|
||||
m_tasks.emplace (filter[id].func, id, desire, data, time, resume);
|
||||
|
||||
clearSearchNodes ();
|
||||
ignoreCollision ();
|
||||
|
||||
const auto tid = getCurrentTaskId ();
|
||||
|
|
@ -2438,7 +2439,7 @@ void Bot::handleChatterTaskChange (Task tid) {
|
|||
}
|
||||
|
||||
if (rg.chance (25) && tid == Task::Camp) {
|
||||
if (game.mapIs (MapFlags::Demolition) && bots.isBombPlanted ()) {
|
||||
if (game.mapIs (MapFlags::Demolition) && gameState.isBombPlanted ()) {
|
||||
pushChatterMessage (Chatter::GuardingPlantedC4);
|
||||
}
|
||||
else {
|
||||
|
|
@ -2471,12 +2472,12 @@ void Bot::executeChatterFrameEvents () {
|
|||
if (!hasFriendNearby && rg.chance (45) && (m_enemy->v.weapons & cr::bit (Weapon::C4))) {
|
||||
pushChatterMessage (Chatter::SpotTheBomber);
|
||||
}
|
||||
else if (!hasFriendNearby && rg.chance (45) && m_team == Team::Terrorist && util.isPlayerVIP (m_enemy)) {
|
||||
else if (!hasFriendNearby && rg.chance (45) && m_team == Team::Terrorist && game.isPlayerVIP (m_enemy)) {
|
||||
pushChatterMessage (Chatter::VIPSpotted);
|
||||
}
|
||||
else if (!hasFriendNearby
|
||||
&& rg.chance (50)
|
||||
&& game.getTeam (m_enemy) != m_team
|
||||
&& game.getPlayerTeam (m_enemy) != m_team
|
||||
&& isGroupOfEnemies (m_enemy->v.origin)) {
|
||||
|
||||
pushChatterMessage (Chatter::ScaredEmotion);
|
||||
|
|
@ -2495,7 +2496,7 @@ void Bot::executeChatterFrameEvents () {
|
|||
}
|
||||
|
||||
// if bomb planted warn players !
|
||||
if (bots.hasBombSay (BombPlantedSay::Chatter) && bots.isBombPlanted () && m_team == Team::CT) {
|
||||
if (bots.hasBombSay (BombPlantedSay::Chatter) && gameState.isBombPlanted () && m_team == Team::CT) {
|
||||
pushChatterMessage (Chatter::GottaFindC4);
|
||||
bots.clearBombSay (BombPlantedSay::Chatter);
|
||||
}
|
||||
|
|
@ -2706,7 +2707,7 @@ void Bot::checkRadioQueue () {
|
|||
break;
|
||||
|
||||
case Radio::ShesGonnaBlow:
|
||||
if (game.isNullEntity (m_enemy) && distanceSq < cr::sqrf (2048.0f) && bots.isBombPlanted () && m_team == Team::Terrorist) {
|
||||
if (game.isNullEntity (m_enemy) && distanceSq < cr::sqrf (2048.0f) && gameState.isBombPlanted () && m_team == Team::Terrorist) {
|
||||
pushRadioMessage (Radio::RogerThat);
|
||||
|
||||
if (getCurrentTaskId () == Task::Camp) {
|
||||
|
|
@ -2722,11 +2723,11 @@ void Bot::checkRadioQueue () {
|
|||
|
||||
case Radio::RegroupTeam:
|
||||
// if no more enemies found AND bomb planted, switch to knife to get to bombplace faster
|
||||
if (m_team == Team::CT && !usesKnife () && m_numEnemiesLeft == 0 && bots.isBombPlanted () && getCurrentTaskId () != Task::DefuseBomb) {
|
||||
if (m_team == Team::CT && !usesKnife () && m_numEnemiesLeft == 0 && gameState.isBombPlanted () && getCurrentTaskId () != Task::DefuseBomb) {
|
||||
selectWeaponById (Weapon::Knife);
|
||||
clearSearchNodes ();
|
||||
|
||||
m_position = graph.getBombOrigin ();
|
||||
m_position = gameState.getBombOrigin ();
|
||||
startTask (Task::MoveToPosition, TaskPri::MoveToPosition, kInvalidNodeIndex, 0.0f, true);
|
||||
|
||||
pushRadioMessage (Radio::RogerThat);
|
||||
|
|
@ -2850,7 +2851,7 @@ void Bot::checkRadioQueue () {
|
|||
|
||||
case Task::Camp:
|
||||
if (rg.chance (m_radioPercent)) {
|
||||
if (bots.isBombPlanted () && m_team == Team::Terrorist) {
|
||||
if (gameState.isBombPlanted () && m_team == Team::Terrorist) {
|
||||
pushChatterMessage (Chatter::GuardingPlantedC4);
|
||||
}
|
||||
else if (m_inEscapeZone && m_team == Team::CT) {
|
||||
|
|
@ -2915,14 +2916,14 @@ void Bot::checkRadioQueue () {
|
|||
|
||||
case Radio::SectorClear:
|
||||
// is bomb planted and it's a ct
|
||||
if (!bots.isBombPlanted ()) {
|
||||
if (!gameState.isBombPlanted ()) {
|
||||
break;
|
||||
}
|
||||
|
||||
// check if it's a ct command
|
||||
if (game.getTeam (m_radioEntity) == Team::CT
|
||||
if (game.getPlayerTeam (m_radioEntity) == Team::CT
|
||||
&& m_team == Team::CT
|
||||
&& util.isFakeClient (m_radioEntity)
|
||||
&& game.isFakeClientEntity (m_radioEntity)
|
||||
&& bots.getPlantedBombSearchTimestamp () < game.time ()) {
|
||||
|
||||
float nearestDistanceSq = kInfiniteDistance;
|
||||
|
|
@ -3015,11 +3016,11 @@ void Bot::checkRadioQueue () {
|
|||
void Bot::tryHeadTowardRadioMessage () {
|
||||
const auto tid = getCurrentTaskId ();
|
||||
|
||||
if (tid == Task::MoveToPosition || m_headedTime + 15.0f < game.time () || !util.isAlive (m_radioEntity) || m_hasC4) {
|
||||
if (tid == Task::MoveToPosition || m_headedTime + 15.0f < game.time () || !game.isAliveEntity (m_radioEntity) || m_hasC4) {
|
||||
return;
|
||||
}
|
||||
|
||||
if ((util.isFakeClient (m_radioEntity)
|
||||
if ((game.isFakeClientEntity (m_radioEntity)
|
||||
&& rg.chance (m_radioPercent)
|
||||
&& m_personality == Personality::Normal) || !(m_radioEntity->v.flags & FL_FAKECLIENT)) {
|
||||
|
||||
|
|
@ -3064,8 +3065,8 @@ void Bot::frame () {
|
|||
return;
|
||||
}
|
||||
|
||||
if (bots.isBombPlanted () && m_team == Team::CT && m_isAlive) {
|
||||
const auto &bombPosition = graph.getBombOrigin ();
|
||||
if (gameState.isBombPlanted () && m_team == Team::CT && m_isAlive) {
|
||||
const auto &bombPosition = gameState.getBombOrigin ();
|
||||
|
||||
if (!m_hasProgressBar
|
||||
&& getCurrentTaskId () != Task::EscapeFromBomb
|
||||
|
|
@ -3101,8 +3102,8 @@ void Bot::update () {
|
|||
const auto tid = getCurrentTaskId ();
|
||||
|
||||
m_canChooseAimDirection = true;
|
||||
m_isAlive = util.isAlive (ent ());
|
||||
m_team = game.getTeam (ent ());
|
||||
m_isAlive = game.isAliveEntity (ent ());
|
||||
m_team = game.getPlayerTeam (ent ());
|
||||
m_healthValue = cr::clamp (pev->health, 0.0f, 99999.9f);
|
||||
|
||||
if (m_team == Team::Terrorist && game.mapIs (MapFlags::Demolition)) {
|
||||
|
|
@ -3148,7 +3149,7 @@ void Bot::update () {
|
|||
m_lastVoteKick = m_voteKickIndex;
|
||||
|
||||
// if bot tk punishment is enabled slay the tk
|
||||
if (cv_tkpunish.as <int> () != 2 || util.isFakeClient (game.entityOfIndex (m_voteKickIndex))) {
|
||||
if (cv_tkpunish.as <int> () != 2 || game.isFakeClientEntity (game.entityOfIndex (m_voteKickIndex))) {
|
||||
return;
|
||||
}
|
||||
auto killer = game.entityOfIndex (m_lastVoteKick);
|
||||
|
|
@ -3337,7 +3338,7 @@ void Bot::checkSpawnConditions () {
|
|||
void Bot::logic () {
|
||||
// this function gets called each frame and is the core of all bot ai. from here all other subroutines are called
|
||||
|
||||
m_movedDistance = kMinMovedDistance; // length of different vector (distance bot moved)
|
||||
m_movedDistance = kMinMovedDistance + 0.1f; // length of different vector (distance bot moved)
|
||||
|
||||
resetMovement ();
|
||||
|
||||
|
|
@ -3369,7 +3370,7 @@ void Bot::logic () {
|
|||
|
||||
// save current position as previous
|
||||
m_prevOrigin = pev->origin;
|
||||
m_prevTime = game.time () + (0.2f - m_frameInterval * 2.0f);
|
||||
m_prevTime = game.time () + (0.15f - m_frameInterval * 2.0f);
|
||||
}
|
||||
|
||||
// if there's some radio message to respond, check it
|
||||
|
|
@ -3607,7 +3608,7 @@ void Bot::showDebugOverlay () {
|
|||
|
||||
static hudtextparms_t textParams {};
|
||||
|
||||
textParams.channel = 1;
|
||||
textParams.channel = 4;
|
||||
textParams.x = -1.0f;
|
||||
textParams.y = 0.0f;
|
||||
textParams.effect = 0;
|
||||
|
|
@ -3669,7 +3670,7 @@ void Bot::takeDamage (edict_t *inflictor, int damage, int armor, int bits) {
|
|||
m_lastDamageType = bits;
|
||||
|
||||
if (m_isCreature) {
|
||||
if (util.isPlayer (inflictor) && game.isNullEntity (m_enemy)) {
|
||||
if (game.isPlayerEntity (inflictor) && game.isNullEntity (m_enemy)) {
|
||||
if (seesEnemy (inflictor)) {
|
||||
m_enemy = inflictor;
|
||||
m_enemyOrigin = inflictor->v.origin;
|
||||
|
|
@ -3683,10 +3684,10 @@ void Bot::takeDamage (edict_t *inflictor, int damage, int armor, int bits) {
|
|||
}
|
||||
m_lastDamageTimestamp = game.time ();
|
||||
|
||||
if (util.isPlayer (inflictor) || (cv_attack_monsters && util.isMonster (inflictor))) {
|
||||
const auto inflictorTeam = game.getTeam (inflictor);
|
||||
if (game.isPlayerEntity (inflictor) || (cv_attack_monsters && game.isMonsterEntity (inflictor))) {
|
||||
const auto inflictorTeam = game.getPlayerTeam (inflictor);
|
||||
|
||||
if (!util.isMonster (inflictor) && cv_tkpunish && inflictorTeam == m_team && !util.isFakeClient (inflictor)) {
|
||||
if (!game.isMonsterEntity (inflictor) && cv_tkpunish && inflictorTeam == m_team && !game.isFakeClientEntity (inflictor)) {
|
||||
// alright, die you team killer!!!
|
||||
m_actualReactionTime = 0.0f;
|
||||
m_seeEnemyTime = game.time ();
|
||||
|
|
@ -3750,7 +3751,7 @@ void Bot::takeBlind (int alpha) {
|
|||
m_viewDistance = rg (10.0f, 20.0f);
|
||||
|
||||
// do not take in effect some unique map effects on round start
|
||||
if (bots.getRoundStartTime () + 5.0f < game.time ()) {
|
||||
if (gameState.getRoundStartTime () + 5.0f < game.time ()) {
|
||||
m_viewDistance = m_maxViewDistance;
|
||||
}
|
||||
m_blindTime = game.time () + static_cast <float> (alpha - 200) / 16.0f;
|
||||
|
|
@ -3812,11 +3813,11 @@ void Bot::updatePracticeValue (int damage) const {
|
|||
void Bot::updatePracticeDamage (edict_t *attacker, int damage) {
|
||||
// this function gets called each time a bot gets damaged by some enemy. stores the damage (team-specific) done by victim.
|
||||
|
||||
if (!util.isPlayer (attacker)) {
|
||||
if (!game.isPlayerEntity (attacker)) {
|
||||
return;
|
||||
}
|
||||
|
||||
const int attackerTeam = game.getTeam (attacker);
|
||||
const int attackerTeam = game.getPlayerTeam (attacker);
|
||||
const int victimTeam = m_team;
|
||||
|
||||
if (attackerTeam == victimTeam) {
|
||||
|
|
@ -3847,7 +3848,7 @@ void Bot::updatePracticeDamage (edict_t *attacker, int damage) {
|
|||
practice.setDamage (victimIndex, victimIndex, victimIndex, cr::clamp (practice.getDamage (victimTeam, victimIndex, victimIndex), 0, kMaxDamageValue));
|
||||
}
|
||||
}
|
||||
const auto updateDamage = util.isFakeClient (attacker) ? 10 : 7;
|
||||
const auto updateDamage = game.isFakeClientEntity (attacker) ? 10 : 7;
|
||||
|
||||
// store away the damage done
|
||||
const auto damageValue = cr::clamp (practice.getDamage (m_team, victimIndex, attackerIndex) + damage / updateDamage, 0, kMaxDamageValue);
|
||||
|
|
@ -3871,7 +3872,7 @@ void Bot::dropWeaponForUser (edict_t *user, bool discardC4) {
|
|||
// this function, asks bot to discard his current primary weapon (or c4) to the user that requested it with /drop*
|
||||
// command, very useful, when i'm don't have money to buy anything... )
|
||||
|
||||
if (util.isAlive (user) && m_moneyAmount >= 2000 && hasPrimaryWeapon () && user->v.origin.distanceSq (pev->origin) <= cr::sqrf (450.0f)) {
|
||||
if (game.isAliveEntity (user) && m_moneyAmount >= 2000 && hasPrimaryWeapon () && user->v.origin.distanceSq (pev->origin) <= cr::sqrf (450.0f)) {
|
||||
m_aimFlags |= AimFlags::Entity;
|
||||
m_lookAt = user->v.origin;
|
||||
|
||||
|
|
@ -3962,16 +3963,16 @@ void Bot::debugMsgInternal (StringRef str) {
|
|||
Vector Bot::isBombAudible () {
|
||||
// this function checks if bomb is can be heard by the bot, calculations done by manual testing.
|
||||
|
||||
if (!bots.isBombPlanted () || getCurrentTaskId () == Task::EscapeFromBomb) {
|
||||
if (!gameState.isBombPlanted () || getCurrentTaskId () == Task::EscapeFromBomb) {
|
||||
return nullptr; // reliability check
|
||||
}
|
||||
|
||||
if (m_difficulty > Difficulty::Hard) {
|
||||
return graph.getBombOrigin ();
|
||||
return gameState.getBombOrigin ();
|
||||
}
|
||||
const auto &bombOrigin = graph.getBombOrigin ();
|
||||
const auto &bombOrigin = gameState.getBombOrigin ();
|
||||
|
||||
const float timeElapsed = ((game.time () - bots.getTimeBombPlanted ()) / mp_c4timer.as <float> ()) * 100.0f;
|
||||
const float timeElapsed = ((game.time () - gameState.getTimeBombPlanted ()) / mp_c4timer.as <float> ()) * 100.0f;
|
||||
float desiredRadius = 768.0f;
|
||||
|
||||
// start the manual calculations
|
||||
|
|
@ -4052,12 +4053,7 @@ void Bot::runMovement () {
|
|||
m_oldButtons = pev->button;
|
||||
}
|
||||
|
||||
float Bot::getBombTimeleft () const {
|
||||
if (!bots.isBombPlanted ()) {
|
||||
return 0.0f;
|
||||
}
|
||||
return cr::max (bots.getTimeBombPlanted () + mp_c4timer.as <float> () - game.time (), 0.0f);
|
||||
}
|
||||
|
||||
|
||||
bool Bot::isOutOfBombTimer () {
|
||||
if (!game.mapIs (MapFlags::Demolition)) {
|
||||
|
|
@ -4069,13 +4065,13 @@ bool Bot::isOutOfBombTimer () {
|
|||
}
|
||||
|
||||
// calculate left time
|
||||
const float timeLeft = getBombTimeleft ();
|
||||
const float timeLeft = gameState.getBombTimeLeft ();
|
||||
|
||||
// if time left greater than 13, no need to do other checks
|
||||
if (timeLeft > 13.0f) {
|
||||
return false;
|
||||
}
|
||||
const auto &bombOrigin = graph.getBombOrigin ();
|
||||
const auto &bombOrigin = gameState.getBombOrigin ();
|
||||
|
||||
// for terrorist, if timer is lower than 13 seconds, return true
|
||||
if (timeLeft < 13.0f && m_team == Team::Terrorist && bombOrigin.distanceSq (pev->origin) < cr::sqrf (964.0f)) {
|
||||
|
|
@ -4100,7 +4096,7 @@ bool Bot::isOutOfBombTimer () {
|
|||
return true;
|
||||
}
|
||||
|
||||
if (m_hasProgressBar && isOnFloor () && ((m_hasDefuser ? 10.0f : 15.0f) > getBombTimeleft ())) {
|
||||
if (m_hasProgressBar && isOnFloor () && ((m_hasDefuser ? 10.0f : 15.0f) > gameState.getBombTimeLeft ())) {
|
||||
return true;
|
||||
}
|
||||
return false; // return false otherwise
|
||||
|
|
@ -4114,7 +4110,7 @@ void Bot::updateHearing () {
|
|||
float nearestDistanceSq = kInfiniteDistance;
|
||||
|
||||
// do not hear to other enemies if just tracked old one
|
||||
if (m_timeNextTracking < game.time () && m_lastEnemy == m_trackingEdict && util.isAlive (m_lastEnemy)) {
|
||||
if (m_timeNextTracking < game.time () && m_lastEnemy == m_trackingEdict && game.isAliveEntity (m_lastEnemy)) {
|
||||
m_hearedEnemy = m_lastEnemy;
|
||||
m_lastEnemyOrigin = m_lastEnemy->v.origin;
|
||||
|
||||
|
|
@ -4153,7 +4149,7 @@ void Bot::updateHearing () {
|
|||
}
|
||||
|
||||
// did the bot hear someone ?
|
||||
if (util.isPlayer (m_hearedEnemy)) {
|
||||
if (game.isPlayerEntity (m_hearedEnemy)) {
|
||||
// change to best weapon if heard something
|
||||
if (m_shootTime < game.time () - 5.0f
|
||||
&& isOnFloor ()
|
||||
|
|
@ -4257,8 +4253,8 @@ void Bot::enteredBuyZone (int buyState) {
|
|||
if (m_seeEnemyTime + 12.0f < game.time ()
|
||||
&& m_lastEquipTime + 30.0f < game.time ()
|
||||
&& m_inBuyZone
|
||||
&& (bots.getRoundStartTime () + rg (10.0f, 20.0f) + mp_buytime.as <float> () < game.time ())
|
||||
&& !bots.isBombPlanted ()
|
||||
&& (gameState.getRoundStartTime () + rg (10.0f, 20.0f) + mp_buytime.as <float> () < game.time ())
|
||||
&& !gameState.isBombPlanted ()
|
||||
&& m_moneyAmount > econLimit[EcoLimit::PrimaryGreater]) {
|
||||
|
||||
m_ignoreBuyDelay = true;
|
||||
|
|
@ -4297,7 +4293,7 @@ void Bot::selectCampButtons (int index) {
|
|||
bool Bot::isBombDefusing (const Vector &bombOrigin) const {
|
||||
// this function finds if somebody currently defusing the bomb.
|
||||
|
||||
if (!bots.isBombPlanted ()) {
|
||||
if (!gameState.isBombPlanted ()) {
|
||||
return false;
|
||||
}
|
||||
bool defusingInProgress = false;
|
||||
|
|
@ -4370,8 +4366,8 @@ void Bot::refreshCreatureStatus (char *infobuffer) {
|
|||
}
|
||||
|
||||
// if bot is on infected team, and zombie mode is active, assume bot is a creature/zombie
|
||||
m_isOnInfectedTeam = game.getRealTeam (ent ()) == infectedTeam;
|
||||
m_infectedEnemyTeam = game.getRealTeam (m_enemy) == infectedTeam;
|
||||
m_isOnInfectedTeam = game.getRealPlayerTeam (ent ()) == infectedTeam;
|
||||
m_infectedEnemyTeam = game.getRealPlayerTeam (m_enemy) == infectedTeam;
|
||||
|
||||
// do not process next if already infected
|
||||
if (m_isOnInfectedTeam || m_infectedEnemyTeam) {
|
||||
|
|
@ -4451,7 +4447,7 @@ void Bot::donateC4ToHuman () {
|
|||
|
||||
// search world for just dropped bomb
|
||||
game.searchEntities ("classname", "weaponbox", [&] (edict_t *ent) {
|
||||
if (util.isModel (ent, "backpack.mdl")) {
|
||||
if (game.isEntityModelMatches (ent, "backpack.mdl")) {
|
||||
bomb = ent;
|
||||
|
||||
if (!game.isNullEntity (bomb)) {
|
||||
|
|
|
|||
|
|
@ -161,7 +161,7 @@ void Bot::prepareChatMessage (StringRef message) {
|
|||
auto humanizedName = [] (int index) -> String {
|
||||
auto ent = game.playerOfIndex (index);
|
||||
|
||||
if (!util.isPlayer (ent)) {
|
||||
if (!game.isPlayerEntity (ent)) {
|
||||
return "unknown";
|
||||
}
|
||||
String playerName = ent->v.netname.chars ();
|
||||
|
|
@ -193,7 +193,7 @@ void Bot::prepareChatMessage (StringRef message) {
|
|||
|
||||
// get roundtime
|
||||
auto getRoundTime = [] () -> String {
|
||||
auto roundTimeSecs = static_cast <int> (bots.getRoundEndTime () - game.time ());
|
||||
const auto roundTimeSecs = static_cast <int> (gameState.getRoundEndTime () - game.time ());
|
||||
|
||||
String roundTime {};
|
||||
roundTime.assignf ("%02d:%02d", cr::clamp (roundTimeSecs / 60, 0, 59), cr::clamp (cr::abs (roundTimeSecs % 60), 0, 59));
|
||||
|
|
@ -241,8 +241,8 @@ void Bot::prepareChatMessage (StringRef message) {
|
|||
return humanizedName (playerIndex);
|
||||
}
|
||||
else if (!needsEnemy && m_team == client.team) {
|
||||
if (util.isPlayer (pev->dmg_inflictor)
|
||||
&& game.getRealTeam (pev->dmg_inflictor) == m_team) {
|
||||
if (game.isPlayerEntity (pev->dmg_inflictor)
|
||||
&& game.getRealPlayerTeam (pev->dmg_inflictor) == m_team) {
|
||||
|
||||
return humanizedName (game.indexOfPlayer (pev->dmg_inflictor));
|
||||
}
|
||||
|
|
|
|||
|
|
@ -335,7 +335,7 @@ bool Bot::checkBodyPartsWithHitboxes (edict_t *target) {
|
|||
bool Bot::seesEnemy (edict_t *player) {
|
||||
auto isBehindSmokeClouds = [&] (const Vector &pos) {
|
||||
if (cv_smoke_grenade_checks.as <int> () == 2) {
|
||||
return bots.isLineBlockedBySmoke (getEyesPos (), pos);
|
||||
return util.isLineBlockedBySmoke (getEyesPos (), pos);
|
||||
}
|
||||
return false;
|
||||
};
|
||||
|
|
@ -345,7 +345,7 @@ bool Bot::seesEnemy (edict_t *player) {
|
|||
}
|
||||
bool ignoreFieldOfView = false;
|
||||
|
||||
if (cv_whose_your_daddy && util.isPlayer (pev->dmg_inflictor) && game.getTeam (pev->dmg_inflictor) != m_team) {
|
||||
if (cv_whose_your_daddy && game.isPlayerEntity (pev->dmg_inflictor) && game.getPlayerTeam (pev->dmg_inflictor) != m_team) {
|
||||
ignoreFieldOfView = true;
|
||||
}
|
||||
|
||||
|
|
@ -387,7 +387,7 @@ bool Bot::lookupEnemies () {
|
|||
if (!game.isNullEntity (m_enemy) && (m_states & Sense::SeeingEnemy)) {
|
||||
m_states &= ~Sense::SuspectEnemy;
|
||||
}
|
||||
else if (game.isNullEntity (m_enemy) && m_seeEnemyTime + 4.0f > game.time () && util.isAlive (m_lastEnemy)) {
|
||||
else if (game.isNullEntity (m_enemy) && m_seeEnemyTime + 4.0f > game.time () && game.isAliveEntity (m_lastEnemy)) {
|
||||
m_states |= Sense::SuspectEnemy;
|
||||
|
||||
const bool denyLastEnemy = pev->velocity.lengthSq2d () > 0.0f
|
||||
|
|
@ -406,7 +406,7 @@ bool Bot::lookupEnemies () {
|
|||
// is player is alive
|
||||
if (m_enemyUpdateTime > game.time ()
|
||||
&& player->v.origin.distanceSq (pev->origin) < nearestDistanceSq
|
||||
&& util.isAlive (player)
|
||||
&& game.isAliveEntity (player)
|
||||
&& seesEnemy (player)) {
|
||||
|
||||
newEnemy = player;
|
||||
|
|
@ -427,8 +427,8 @@ bool Bot::lookupEnemies () {
|
|||
|
||||
if (cv_attack_monsters) {
|
||||
// search the world for monsters...
|
||||
for (const auto &interesting : bots.getInterestingEntities ()) {
|
||||
if (!util.isMonster (interesting)) {
|
||||
for (const auto &interesting : gameState.getInterestingEntities ()) {
|
||||
if (!game.isMonsterEntity (interesting)) {
|
||||
continue;
|
||||
}
|
||||
|
||||
|
|
@ -485,7 +485,7 @@ bool Bot::lookupEnemies () {
|
|||
newEnemy = player;
|
||||
|
||||
// aim VIP first on AS maps...
|
||||
if (game.is (MapFlags::Assassination) && util.isPlayerVIP (newEnemy)) {
|
||||
if (game.is (MapFlags::Assassination) && game.isPlayerVIP (newEnemy)) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
|
@ -498,7 +498,7 @@ bool Bot::lookupEnemies () {
|
|||
}
|
||||
}
|
||||
|
||||
if (newEnemy != nullptr && (util.isPlayer (newEnemy) || (cv_attack_monsters && util.isMonster (newEnemy)))) {
|
||||
if (newEnemy != nullptr && (game.isPlayerEntity (newEnemy) || (cv_attack_monsters && game.isMonsterEntity (newEnemy)))) {
|
||||
bots.setCanPause (true);
|
||||
|
||||
m_aimFlags |= AimFlags::Enemy;
|
||||
|
|
@ -587,7 +587,7 @@ bool Bot::lookupEnemies () {
|
|||
newEnemy = m_enemy;
|
||||
m_lastEnemy = newEnemy;
|
||||
|
||||
if (!util.isAlive (newEnemy)) {
|
||||
if (!game.isAliveEntity (newEnemy)) {
|
||||
m_enemy = nullptr;
|
||||
m_enemyBodyPartSet = nullptr;
|
||||
|
||||
|
|
@ -638,7 +638,7 @@ bool Bot::lookupEnemies () {
|
|||
&& game.isNullEntity (m_enemy)
|
||||
&& getCurrentTaskId () != Task::ShootBreakable
|
||||
&& getCurrentTaskId () != Task::PlantBomb
|
||||
&& getCurrentTaskId () != Task::DefuseBomb) || bots.isRoundOver ()) {
|
||||
&& getCurrentTaskId () != Task::DefuseBomb) || gameState.isRoundOver ()) {
|
||||
|
||||
if (!m_reloadState) {
|
||||
m_reloadState = Reload::Primary;
|
||||
|
|
@ -719,7 +719,7 @@ Vector Bot::getEnemyBodyOffset () {
|
|||
if (!m_enemyParts && (m_states & Sense::SuspectEnemy)) {
|
||||
spot += getBodyOffsetError (distance);
|
||||
}
|
||||
else if (util.isPlayer (m_enemy)) {
|
||||
else if (game.isPlayerEntity (m_enemy)) {
|
||||
// now take in account different parts of enemy body
|
||||
if (m_enemyParts & (Visibility::Head | Visibility::Body)) {
|
||||
auto headshotPct = conf.getDifficultyTweaks (m_difficulty)->headshotPct;
|
||||
|
|
@ -828,11 +828,11 @@ bool Bot::isFriendInLineOfFire (float distance) const {
|
|||
game.testLine (getEyesPos (), getEyesPos () + pev->v_angle.normalize_apx () * distance, TraceIgnore::None, ent (), &tr);
|
||||
|
||||
// check if we hit something
|
||||
if (util.isPlayer (tr.pHit) && tr.pHit != ent ()) {
|
||||
if (game.isPlayerEntity (tr.pHit) && tr.pHit != ent ()) {
|
||||
auto hit = tr.pHit;
|
||||
|
||||
// check valid range
|
||||
if (game.getTeam (hit) == m_team && util.isAlive (hit)) {
|
||||
if (game.getPlayerTeam (hit) == m_team && game.isAliveEntity (hit)) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
|
@ -1459,7 +1459,7 @@ void Bot::attackMovement () {
|
|||
if (!game.is (GameFlags::CSDM) && !isKnifeMode ()) {
|
||||
if ((m_states & Sense::SeeingEnemy)
|
||||
&& approach < 30
|
||||
&& !bots.isBombPlanted ()
|
||||
&& !gameState.isBombPlanted ()
|
||||
&& (isEnemyCone || m_isVIP || m_isReloading)) {
|
||||
|
||||
if (m_retreatTime < game.time ()) {
|
||||
|
|
@ -1973,7 +1973,7 @@ void Bot::decideFollowUser () {
|
|||
continue;
|
||||
}
|
||||
|
||||
if (seesEntity (client.origin) && !util.isFakeClient (client.ent)) {
|
||||
if (seesEntity (client.origin) && !game.isFakeClientEntity (client.ent)) {
|
||||
users.push (client.ent);
|
||||
}
|
||||
}
|
||||
|
|
@ -2248,7 +2248,7 @@ edict_t *Bot::setCorrectGrenadeVelocity (StringRef model) {
|
|||
edict_t *result = nullptr;
|
||||
|
||||
game.searchEntities ("classname", "grenade", [&] (edict_t *ent) {
|
||||
if (ent->v.owner == this->ent () && util.isModel (ent, model)) {
|
||||
if (ent->v.owner == this->ent () && game.isEntityModelMatches (ent, model)) {
|
||||
result = ent;
|
||||
|
||||
// set the correct velocity for the grenade
|
||||
|
|
@ -2286,7 +2286,7 @@ void Bot::checkGrenadesThrow () {
|
|||
|| cv_ignore_enemies
|
||||
|| m_isUsingGrenade
|
||||
|| m_isReloading
|
||||
|| (isKnifeMode () && !bots.isBombPlanted ())
|
||||
|| (isKnifeMode () && !gameState.isBombPlanted ())
|
||||
|| m_grenadeCheckTime >= game.time ()
|
||||
|| m_lastEnemyOrigin.empty ());
|
||||
|
||||
|
|
@ -2300,7 +2300,7 @@ void Bot::checkGrenadesThrow () {
|
|||
|
||||
const auto senseCondition = isGrenadeMode ? false : !(m_states & (Sense::SuspectEnemy | Sense::HearingEnemy));
|
||||
|
||||
if (!util.isAlive (m_lastEnemy) || senseCondition) {
|
||||
if (!game.isAliveEntity (m_lastEnemy) || senseCondition) {
|
||||
clearThrowStates (m_states);
|
||||
return;
|
||||
}
|
||||
|
|
@ -2343,7 +2343,7 @@ void Bot::checkGrenadesThrow () {
|
|||
|
||||
// special condition if we're have valid current enemy
|
||||
if (!isGrenadeMode && ((m_states & Sense::SeeingEnemy)
|
||||
&& util.isAlive (m_enemy)
|
||||
&& game.isAliveEntity (m_enemy)
|
||||
&& ((m_enemy->v.button | m_enemy->v.oldbuttons) & IN_ATTACK)
|
||||
&& util.isVisible (pev->origin, m_enemy))
|
||||
&& util.isInViewCone (pev->origin, m_enemy)) {
|
||||
|
|
|
|||
|
|
@ -352,7 +352,7 @@ void BotConfig::loadChatterConfig () {
|
|||
{ "Chatter_Camp", Chatter::Camping, 10.0f },
|
||||
{ "Chatter_OnARoll", Chatter::OnARoll, kMaxChatterRepeatInterval},
|
||||
};
|
||||
Array <String> badFiles {};
|
||||
Array <String> missingWaves {};
|
||||
|
||||
while (file.getLine (line)) {
|
||||
line.trim ();
|
||||
|
|
@ -394,7 +394,7 @@ void BotConfig::loadChatterConfig () {
|
|||
m_chatter[event.code].emplace (cr::move (sound), event.repeat, duration);
|
||||
}
|
||||
else {
|
||||
badFiles.push (sound);
|
||||
missingWaves.push (sound);
|
||||
}
|
||||
}
|
||||
sentences.clear ();
|
||||
|
|
@ -404,8 +404,16 @@ void BotConfig::loadChatterConfig () {
|
|||
}
|
||||
file.close ();
|
||||
|
||||
if (!badFiles.empty ()) {
|
||||
game.print ("Warning: Couldn't get duration of next chatter sounds: %s.", String::join (badFiles, ","));
|
||||
if (!missingWaves.empty ()) {
|
||||
constexpr auto kMaxErroredWaves = 10;
|
||||
|
||||
// too much erros bail out
|
||||
if (missingWaves.length () > kMaxErroredWaves) {
|
||||
cv_radio_mode.set (1);
|
||||
|
||||
missingWaves.resize (kMaxErroredWaves);
|
||||
}
|
||||
game.print ("Warning: Couldn't get duration of next chatter sounds: %s ...", String::join (missingWaves, ","));
|
||||
}
|
||||
}
|
||||
else {
|
||||
|
|
|
|||
|
|
@ -183,7 +183,7 @@ int BotControl::cmdMenu () {
|
|||
// reset the current menu
|
||||
closeMenu ();
|
||||
|
||||
if (arg <StringRef> (cmd) == "cmd" && util.isAlive (m_ent)) {
|
||||
if (arg <StringRef> (cmd) == "cmd" && game.isAliveEntity (m_ent)) {
|
||||
showMenu (Menu::Commands);
|
||||
}
|
||||
else {
|
||||
|
|
@ -205,7 +205,7 @@ int BotControl::cmdCvars () {
|
|||
auto match = arg <StringRef> (pattern);
|
||||
|
||||
// stop printing if executed once more
|
||||
flushPrintQueue ();
|
||||
m_printQueue.clear ();
|
||||
|
||||
// revert all the cvars to their default values
|
||||
if (match == "defaults") {
|
||||
|
|
@ -1115,7 +1115,7 @@ int BotControl::menuFeatures (int item) {
|
|||
break;
|
||||
|
||||
case 5:
|
||||
if (util.isAlive (m_ent)) {
|
||||
if (game.isAliveEntity (m_ent)) {
|
||||
showMenu (Menu::Commands);
|
||||
}
|
||||
else {
|
||||
|
|
@ -1924,7 +1924,7 @@ bool BotControl::executeCommands () {
|
|||
}
|
||||
|
||||
bool BotControl::executeMenus () {
|
||||
if (!util.isPlayer (m_ent) || game.isBotCmd ()) {
|
||||
if (!game.isPlayerEntity (m_ent) || game.isBotCmd ()) {
|
||||
return false;
|
||||
}
|
||||
const auto &issuer = util.getClient (game.indexOfPlayer (m_ent));
|
||||
|
|
@ -1966,7 +1966,7 @@ void BotControl::showMenu (int id) {
|
|||
menusParsed = true;
|
||||
}
|
||||
|
||||
if (!util.isPlayer (m_ent)) {
|
||||
if (!game.isPlayerEntity (m_ent)) {
|
||||
return;
|
||||
}
|
||||
auto &client = util.getClient (game.indexOfPlayer (m_ent));
|
||||
|
|
@ -2007,7 +2007,7 @@ void BotControl::showMenu (int id) {
|
|||
}
|
||||
|
||||
void BotControl::closeMenu () {
|
||||
if (!util.isPlayer (m_ent)) {
|
||||
if (!game.isPlayerEntity (m_ent)) {
|
||||
return;
|
||||
}
|
||||
auto &client = util.getClient (game.indexOfPlayer (m_ent));
|
||||
|
|
@ -2073,7 +2073,7 @@ void BotControl::kickBotByMenu (int page) {
|
|||
}
|
||||
|
||||
void BotControl::assignAdminRights (edict_t *ent, char *infobuffer) {
|
||||
if (!game.isDedicated () || util.isFakeClient (ent)) {
|
||||
if (!game.isDedicated () || game.isFakeClientEntity (ent)) {
|
||||
return;
|
||||
}
|
||||
StringRef key = cv_password_key.as <StringRef> ();
|
||||
|
|
@ -2100,7 +2100,7 @@ void BotControl::maintainAdminRights () {
|
|||
StringRef password = cv_password.as <StringRef> ();
|
||||
|
||||
for (auto &client : util.getClients ()) {
|
||||
if (!(client.flags & ClientFlags::Used) || util.isFakeClient (client.ent)) {
|
||||
if (!(client.flags & ClientFlags::Used) || game.isFakeClientEntity (client.ent)) {
|
||||
continue;
|
||||
}
|
||||
auto ent = client.ent;
|
||||
|
|
|
|||
287
src/engine.cpp
287
src/engine.cpp
|
|
@ -12,6 +12,7 @@ ConVar cv_ignore_map_prefix_game_mode ("ignore_map_prefix_game_mode", "0", "If e
|
|||
ConVar cv_threadpool_workers ("threadpool_workers", "-1", "Maximum number of threads the bot will run to process some tasks. -1 means half of the CPU cores are used.", true, -1.0f, static_cast <float> (plat.hardwareConcurrency ()));
|
||||
ConVar cv_grenadier_mode ("grenadier_mode", "0", "If enabled, bots will not apply throwing conditions on grenades.");
|
||||
ConVar cv_ignore_enemies_after_spawn_time ("ignore_enemies_after_spawn_time", "0", "Makes bots ignore enemies for a specified time in seconds on a new round. Useful for Zombie Plague mods.", false);
|
||||
ConVar cv_breakable_health_limit ("breakable_health_limit", "500.0", "Specifies the maximum health of a breakable object that the bot will consider destroying.", true, 1.0f, 3000.0);
|
||||
|
||||
ConVar sv_skycolor_r ("sv_skycolor_r", nullptr, Var::GameRef);
|
||||
ConVar sv_skycolor_g ("sv_skycolor_g", nullptr, Var::GameRef);
|
||||
|
|
@ -77,7 +78,7 @@ void Game::levelInitialize (edict_t *entities, int max) {
|
|||
conf.loadMainConfig ();
|
||||
|
||||
// ensure the server admin is confident about features he's using
|
||||
game.ensureHealthyGameEnvironment ();
|
||||
ensureHealthyGameEnvironment ();
|
||||
|
||||
// load map-specific config
|
||||
conf.loadMapSpecificConfig ();
|
||||
|
|
@ -138,7 +139,7 @@ void Game::levelInitialize (edict_t *entities, int max) {
|
|||
else if (classname == "func_vip_safetyzone" || classname == "info_vip_safetyzone") {
|
||||
m_mapFlags |= MapFlags::Assassination; // assassination map
|
||||
}
|
||||
else if (util.isHostageEntity (ent)) {
|
||||
else if (isHostageEntity (ent)) {
|
||||
m_mapFlags |= MapFlags::HostageRescue; // rescue map
|
||||
}
|
||||
else if (classname == "func_bomb_target" || classname == "info_bomb_target") {
|
||||
|
|
@ -152,13 +153,13 @@ void Game::levelInitialize (edict_t *entities, int max) {
|
|||
m_mapFlags &= ~MapFlags::HostageRescue;
|
||||
}
|
||||
}
|
||||
else if (util.isDoorEntity (ent)) {
|
||||
else if (isDoorEntity (ent)) {
|
||||
m_mapFlags |= MapFlags::HasDoors;
|
||||
}
|
||||
else if (classname.startsWith ("func_button")) {
|
||||
m_mapFlags |= MapFlags::HasButtons;
|
||||
}
|
||||
else if (util.isBreakableEntity (ent, true)) {
|
||||
else if (isBreakableEntity (ent, true)) {
|
||||
|
||||
// add breakable for material check
|
||||
m_checkedBreakables[indexOfEntity (ent)] = ent->v.impulse <= 0;
|
||||
|
|
@ -197,12 +198,12 @@ void Game::levelShutdown () {
|
|||
bots.destroyKillerEntity ();
|
||||
|
||||
// ensure players are off on xash3d
|
||||
if (game.is (GameFlags::Xash3DLegacy)) {
|
||||
if (is (GameFlags::Xash3DLegacy)) {
|
||||
bots.kickEveryone (true, false);
|
||||
}
|
||||
|
||||
// set state to unprecached
|
||||
game.setUnprecached ();
|
||||
setUnprecached ();
|
||||
|
||||
// enable lightstyle animations on level change
|
||||
illum.enableAnimation (true);
|
||||
|
|
@ -211,7 +212,7 @@ void Game::levelShutdown () {
|
|||
util.setNeedForWelcome (false);
|
||||
|
||||
// clear local entity
|
||||
game.setLocalEntity (nullptr);
|
||||
setLocalEntity (nullptr);
|
||||
|
||||
// reset graph state
|
||||
graph.reset ();
|
||||
|
|
@ -229,7 +230,7 @@ void Game::drawLine (edict_t *ent, const Vector &start, const Vector &end, int w
|
|||
// is pointed to by ent, from the vector location start to the vector location end,
|
||||
// which is supposed to last life tenths seconds, and having the color defined by RGB.
|
||||
|
||||
if (!util.isPlayer (ent)) {
|
||||
if (!isPlayerEntity (ent)) {
|
||||
return; // reliability check
|
||||
}
|
||||
|
||||
|
|
@ -373,7 +374,7 @@ void Game::setPlayerStartDrawModels () {
|
|||
};
|
||||
|
||||
models.foreach ([&] (const String &key, const String &val) {
|
||||
game.searchEntities ("classname", key, [&] (edict_t *ent) {
|
||||
searchEntities ("classname", key, [&] (edict_t *ent) {
|
||||
m_engineWrap.setModel (ent, val.chars ());
|
||||
return EntitySearchResult::Continue;
|
||||
});
|
||||
|
|
@ -426,12 +427,12 @@ void Game::sendClientMessage (bool console, edict_t *ent, StringRef message) {
|
|||
// helper to sending the client message
|
||||
|
||||
// do not send messages to fake clients
|
||||
if (!util.isPlayer (ent) || util.isFakeClient (ent)) {
|
||||
if (!isPlayerEntity (ent) || isFakeClientEntity (ent)) {
|
||||
return;
|
||||
}
|
||||
|
||||
// if console message and destination is listenserver entity, just print via server message instead of through unreliable channel
|
||||
if (console && ent == game.getLocalEntity ()) {
|
||||
if (console && ent == getLocalEntity ()) {
|
||||
sendServerMessage (message);
|
||||
return;
|
||||
}
|
||||
|
|
@ -482,7 +483,7 @@ void Game::sendServerMessage (StringRef message) {
|
|||
void Game::sendHudMessage (edict_t *ent, const hudtextparms_t &htp, StringRef message) {
|
||||
constexpr size_t kMaxSendLength = 512;
|
||||
|
||||
if (game.isNullEntity (ent)) {
|
||||
if (isNullEntity (ent)) {
|
||||
return;
|
||||
}
|
||||
MessageWriter msg (MSG_ONE_UNRELIABLE, SVC_TEMPENTITY, nullptr, ent);
|
||||
|
|
@ -1006,7 +1007,7 @@ bool Game::postload () {
|
|||
|
||||
// register fake metamod command handler if we not! under mm
|
||||
if (!(is (GameFlags::Metamod))) {
|
||||
game.registerEngineCommand ("meta", [] () {
|
||||
registerEngineCommand ("meta", [] () {
|
||||
game.print ("You're launched standalone version of %s. Metamod is not installed or not enabled!", product.name);
|
||||
});
|
||||
}
|
||||
|
|
@ -1126,7 +1127,7 @@ void Game::slowFrame () {
|
|||
if (m_halfSecondFrame < time ()) {
|
||||
|
||||
// refresh bomb origin in case some plugin moved it out
|
||||
graph.setBombOrigin ();
|
||||
gameState.setBombOrigin ();
|
||||
|
||||
// ensure the server admin is confident about features he's using
|
||||
ensureHealthyGameEnvironment ();
|
||||
|
|
@ -1209,7 +1210,7 @@ void Game::searchEntities (const Vector &position, float radius, EntitySearch fu
|
|||
}
|
||||
}
|
||||
|
||||
bool Game::hasEntityInGame (StringRef classname) {
|
||||
bool Game::hasEntityInGame (StringRef classname) const {
|
||||
return !isNullEntity (engfuncs.pfnFindEntityByString (nullptr, "classname", classname.chars ()));
|
||||
}
|
||||
|
||||
|
|
@ -1367,6 +1368,120 @@ bool Game::isDeveloperMode () const {
|
|||
return developer.exists () && developer.value () > 0.0f;
|
||||
}
|
||||
|
||||
bool Game::isAliveEntity (edict_t *ent) const {
|
||||
if (isNullEntity (ent)) {
|
||||
return false;
|
||||
}
|
||||
return ent->v.deadflag == DEAD_NO && ent->v.health > 0.0f && ent->v.movetype != MOVETYPE_NOCLIP;
|
||||
}
|
||||
|
||||
bool Game::isPlayerEntity (edict_t *ent) const {
|
||||
if (isNullEntity (ent)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
if (ent->v.flags & FL_PROXY) {
|
||||
return false;
|
||||
}
|
||||
|
||||
if ((ent->v.flags & (FL_CLIENT | FL_FAKECLIENT)) || bots[ent] != nullptr) {
|
||||
return !strings.isEmpty (ent->v.netname.chars ());
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
bool Game::isMonsterEntity (edict_t *ent) const {
|
||||
if (isNullEntity (ent)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
if (~ent->v.flags & FL_MONSTER) {
|
||||
return false;
|
||||
}
|
||||
|
||||
if (isHostageEntity (ent)) {
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
bool Game::isItemEntity (edict_t *ent) const {
|
||||
return ent && ent->v.classname.str ().contains ("item_");
|
||||
}
|
||||
|
||||
bool Game::isPlayerVIP (edict_t *ent) const {
|
||||
if (!mapIs (MapFlags::Assassination)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
if (!isPlayerEntity (ent)) {
|
||||
return false;
|
||||
}
|
||||
return *(engfuncs.pfnInfoKeyValue (engfuncs.pfnGetInfoKeyBuffer (ent), "model")) == 'v';
|
||||
}
|
||||
|
||||
bool Game::isDoorEntity (edict_t *ent) const {
|
||||
if (isNullEntity (ent)) {
|
||||
return false;
|
||||
}
|
||||
const auto classHash = ent->v.classname.str ().hash ();
|
||||
|
||||
constexpr auto kFuncDoor = StringRef::fnv1a32 ("func_door");
|
||||
constexpr auto kFuncDoorRotating = StringRef::fnv1a32 ("func_door_rotating");
|
||||
|
||||
return classHash == kFuncDoor || classHash == kFuncDoorRotating;
|
||||
}
|
||||
|
||||
bool Game::isHostageEntity (edict_t *ent) const {
|
||||
if (isNullEntity (ent)) {
|
||||
return false;
|
||||
}
|
||||
const auto classHash = ent->v.classname.str ().hash ();
|
||||
|
||||
constexpr auto kHostageEntity = StringRef::fnv1a32 ("hostage_entity");
|
||||
constexpr auto kMonsterScientist = StringRef::fnv1a32 ("monster_scientist");
|
||||
|
||||
return classHash == kHostageEntity || classHash == kMonsterScientist;
|
||||
}
|
||||
|
||||
bool Game::isBreakableEntity (edict_t *ent, bool initialSeed) const {
|
||||
if (!initialSeed) {
|
||||
if (!hasBreakables ()) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
if (isNullEntity (ent) || ent == getStartEntity () || (!initialSeed && !game.isBreakableValid (ent))) {
|
||||
return false;
|
||||
}
|
||||
const auto limit = cv_breakable_health_limit.as <float> ();
|
||||
|
||||
// not shoot-able
|
||||
if (ent->v.health >= limit) {
|
||||
return false;
|
||||
}
|
||||
constexpr auto kFuncBreakable = StringRef::fnv1a32 ("func_breakable");
|
||||
constexpr auto kFuncPushable = StringRef::fnv1a32 ("func_pushable");
|
||||
constexpr auto kFuncWall = StringRef::fnv1a32 ("func_wall");
|
||||
|
||||
if (ent->v.takedamage > 0.0f && ent->v.impulse <= 0 && !(ent->v.flags & FL_WORLDBRUSH) && !(ent->v.spawnflags & SF_BREAK_TRIGGER_ONLY)) {
|
||||
const auto classHash = ent->v.classname.str ().hash ();
|
||||
|
||||
if (classHash == kFuncBreakable || (classHash == kFuncPushable && (ent->v.spawnflags & SF_PUSH_BREAKABLE)) || classHash == kFuncWall) {
|
||||
return ent->v.movetype == MOVETYPE_PUSH || ent->v.movetype == MOVETYPE_PUSHSTEP;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
bool Game::isFakeClientEntity (edict_t *ent) const {
|
||||
return bots[ent] != nullptr || (!isNullEntity (ent) && (ent->v.flags & FL_FAKECLIENT));
|
||||
}
|
||||
|
||||
bool Game::isEntityModelMatches (const edict_t *ent, StringRef model) const {
|
||||
return model.startsWith (ent->v.model.chars (9));
|
||||
}
|
||||
|
||||
void LightMeasure::initializeLightstyles () {
|
||||
// this function initializes lighting information...
|
||||
|
||||
|
|
@ -1588,7 +1703,7 @@ Vector PlayerHitboxEnumerator::get (edict_t *ent, int part, float updateTimestam
|
|||
void PlayerHitboxEnumerator::update (edict_t *ent) {
|
||||
constexpr auto kInvalidHitbox = -1;
|
||||
|
||||
if (!util.isAlive (ent)) {
|
||||
if (!game.isAliveEntity (ent)) {
|
||||
return;
|
||||
}
|
||||
// get info about player
|
||||
|
|
@ -1677,3 +1792,143 @@ void PlayerHitboxEnumerator::reset () {
|
|||
part = {};
|
||||
}
|
||||
}
|
||||
|
||||
void GameState::setBombOrigin (bool reset, const Vector &pos) {
|
||||
// this function stores the bomb position as a vector
|
||||
|
||||
if (!game.mapIs (MapFlags::Demolition) || !gameState.isBombPlanted ()) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (reset) {
|
||||
m_bombOrigin.clear ();
|
||||
setBombPlanted (false);
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
if (!pos.empty ()) {
|
||||
m_bombOrigin = pos;
|
||||
return;
|
||||
}
|
||||
bool wasFound = false;
|
||||
auto bombModel = conf.getBombModelName ();
|
||||
|
||||
game.searchEntities ("classname", "grenade", [&] (edict_t *ent) {
|
||||
if (game.isEntityModelMatches (ent, bombModel)) {
|
||||
m_bombOrigin = game.getEntityOrigin (ent);
|
||||
wasFound = true;
|
||||
|
||||
return EntitySearchResult::Break;
|
||||
}
|
||||
return EntitySearchResult::Continue;
|
||||
});
|
||||
|
||||
if (!wasFound) {
|
||||
m_bombOrigin.clear ();
|
||||
setBombPlanted (false);
|
||||
}
|
||||
}
|
||||
|
||||
void GameState::roundStart () {
|
||||
m_roundOver = false;
|
||||
m_timeBombPlanted = 0.0f;
|
||||
|
||||
// tell the bots
|
||||
bots.initRound ();
|
||||
setBombOrigin (true);
|
||||
|
||||
// calculate the round mid/end in world time
|
||||
m_timeRoundStart = game.time () + mp_freezetime.as <float> ();
|
||||
m_timeRoundMid = m_timeRoundStart + mp_roundtime.as <float> () * 60.0f * 0.5f;
|
||||
m_timeRoundEnd = m_timeRoundStart + mp_roundtime.as <float> () * 60.0f;
|
||||
|
||||
m_interestingEntities.clear ();
|
||||
m_activeGrenades.clear ();
|
||||
|
||||
m_activeGrenadesUpdateTime.reset ();
|
||||
m_interestingEntitiesUpdateTime.reset ();
|
||||
}
|
||||
|
||||
float GameState::getBombTimeLeft () const {
|
||||
if (!m_bombPlanted) {
|
||||
return 0.0f;
|
||||
}
|
||||
return cr::max (m_timeBombPlanted + mp_c4timer.as <float> () - game.time (), 0.0f);
|
||||
}
|
||||
|
||||
void GameState::setBombPlanted (bool isPlanted) {
|
||||
if (cv_ignore_objectives) {
|
||||
m_bombPlanted = false;
|
||||
return;
|
||||
}
|
||||
|
||||
if (isPlanted) {
|
||||
m_timeBombPlanted = game.time ();
|
||||
}
|
||||
m_bombPlanted = isPlanted;
|
||||
}
|
||||
|
||||
void GameState::updateActiveGrenade () {
|
||||
constexpr auto kUpdateTime = 0.25f;
|
||||
|
||||
if (m_activeGrenadesUpdateTime.lessThen (kUpdateTime)) {
|
||||
return;
|
||||
}
|
||||
m_activeGrenades.clear (); // clear previously stored grenades
|
||||
|
||||
// need to ignore bomb model in active grenades...
|
||||
auto bombModel = conf.getBombModelName ();
|
||||
|
||||
// search the map for any type of grenade
|
||||
game.searchEntities ("classname", "grenade", [&] (edict_t *e) {
|
||||
// do not count c4 as a grenade
|
||||
if (!game.isEntityModelMatches (e, bombModel)) {
|
||||
m_activeGrenades.push (e);
|
||||
}
|
||||
return EntitySearchResult::Continue; // continue iteration
|
||||
});
|
||||
m_activeGrenadesUpdateTime.start ();
|
||||
}
|
||||
|
||||
void GameState::updateInterestingEntities () {
|
||||
constexpr auto kUpdateTime = 0.5f;
|
||||
|
||||
if (m_interestingEntitiesUpdateTime.lessThen (kUpdateTime)) {
|
||||
return;
|
||||
}
|
||||
m_interestingEntities.clear (); // clear previously stored entities
|
||||
|
||||
// search the map for any type of grenade
|
||||
game.searchEntities (nullptr, kInfiniteDistance, [&] (edict_t *e) {
|
||||
auto classname = e->v.classname.str ();
|
||||
|
||||
// search for grenades, weaponboxes, weapons, items and armoury entities
|
||||
if (classname.startsWith ("weaponbox") || classname.startsWith ("grenade") || game.isItemEntity (e) || classname.startsWith ("armoury")) {
|
||||
m_interestingEntities.push (e);
|
||||
}
|
||||
|
||||
// pickup some hostage if on cs_ maps
|
||||
if (game.mapIs (MapFlags::HostageRescue) && game.isHostageEntity (e)) {
|
||||
m_interestingEntities.push (e);
|
||||
}
|
||||
|
||||
// add buttons
|
||||
if (game.mapIs (MapFlags::HasButtons) && classname.startsWith ("func_button")) {
|
||||
m_interestingEntities.push (e);
|
||||
}
|
||||
|
||||
// pickup some csdm stuff if we're running csdm
|
||||
if (game.is (GameFlags::CSDM) && classname.startsWith ("csdm")) {
|
||||
m_interestingEntities.push (e);
|
||||
}
|
||||
|
||||
if (cv_attack_monsters && game.isMonsterEntity (e)) {
|
||||
m_interestingEntities.push (e);
|
||||
}
|
||||
|
||||
// continue iteration
|
||||
return EntitySearchResult::Continue;
|
||||
});
|
||||
m_interestingEntitiesUpdateTime.start ();
|
||||
}
|
||||
|
|
|
|||
|
|
@ -9,7 +9,7 @@
|
|||
|
||||
// on other than win32/linux platforms i.e. arm we're using xash3d engine to run which exposes
|
||||
// nice interface to handle with linkents. if ever rehlds or hlds engine will ever run on ARM or
|
||||
// other platforms, and you want to run bot on it without metamod, consider enabling LINKENT_STATIC_THUNKS
|
||||
// other platforms, and you want to run bot on it without metamod, consider enabling LINKENT_STATIC
|
||||
// when compiling the bot, to get it supported.
|
||||
#if defined(LINKENT_STATIC)
|
||||
void forwardEntity_helper (EntityProto &addr, const char *name, entvars_t *pev) {
|
||||
|
|
|
|||
|
|
@ -24,7 +24,7 @@ void BotFakePingManager::reset (edict_t *to) {
|
|||
}
|
||||
|
||||
for (const auto &client : util.getClients ()) {
|
||||
if (!(client.flags & ClientFlags::Used) || util.isFakeClient (client.ent)) {
|
||||
if (!(client.flags & ClientFlags::Used) || game.isFakeClientEntity (client.ent)) {
|
||||
continue;
|
||||
}
|
||||
m_pbm.start (client.ent);
|
||||
|
|
@ -46,7 +46,7 @@ void BotFakePingManager::syncCalculate () {
|
|||
int numHumans {};
|
||||
|
||||
for (const auto &client : util.getClients ()) {
|
||||
if (!(client.flags & ClientFlags::Used) || util.isFakeClient (client.ent)) {
|
||||
if (!(client.flags & ClientFlags::Used) || game.isFakeClientEntity (client.ent)) {
|
||||
continue;
|
||||
}
|
||||
numHumans++;
|
||||
|
|
@ -101,7 +101,7 @@ void BotFakePingManager::calculate () {
|
|||
}
|
||||
|
||||
void BotFakePingManager::emit (edict_t *ent) {
|
||||
if (!util.isPlayer (ent)) {
|
||||
if (!game.isPlayerEntity (ent)) {
|
||||
return;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -1310,7 +1310,7 @@ void BotGraph::emitNotify (int32_t sound) const {
|
|||
};
|
||||
|
||||
// notify editor
|
||||
if (util.isPlayer (m_editor) && !m_silenceMessages) {
|
||||
if (game.isPlayerEntity (m_editor) && !m_silenceMessages) {
|
||||
game.playSound (m_editor, notifySounds[sound].chars ());
|
||||
}
|
||||
}
|
||||
|
|
@ -1483,7 +1483,7 @@ void BotGraph::calculatePathRadius (int index) {
|
|||
if (tr.flFraction < 1.0f) {
|
||||
game.testLine (radiusStart, radiusEnd, TraceIgnore::Monsters, nullptr, &tr);
|
||||
|
||||
if (util.isDoorEntity (tr.pHit)) {
|
||||
if (game.isDoorEntity (tr.pHit)) {
|
||||
path.radius = 0.0f;
|
||||
wayBlocked = true;
|
||||
|
||||
|
|
@ -1976,7 +1976,7 @@ bool BotGraph::isNodeReacheableEx (const Vector &src, const Vector &destination,
|
|||
// check if this node is "visible"...
|
||||
game.testLine (src, destination, TraceIgnore::Monsters, m_editor, &tr);
|
||||
|
||||
const bool isDoor = util.isDoorEntity (tr.pHit);
|
||||
const bool isDoor = game.isDoorEntity (tr.pHit);
|
||||
|
||||
// if node is visible from current position (even behind head)...
|
||||
if (tr.flFraction >= 1.0f || isDoor) {
|
||||
|
|
@ -2059,7 +2059,7 @@ void BotGraph::frame () {
|
|||
}
|
||||
|
||||
// keep the clipping mode enabled, or it can be turned off after new round has started
|
||||
if (graph.hasEditFlag (GraphEdit::Noclip) && util.isAlive (m_editor)) {
|
||||
if (graph.hasEditFlag (GraphEdit::Noclip) && game.isAliveEntity (m_editor)) {
|
||||
m_editor->v.movetype = MOVETYPE_NOCLIP;
|
||||
}
|
||||
|
||||
|
|
@ -2123,7 +2123,7 @@ void BotGraph::frame () {
|
|||
// check if node is within a distance, and is visible
|
||||
if (distanceSq < cr::sqrf (cv_graph_draw_distance.as <float> ())
|
||||
&& ((util.isVisible (path.origin, m_editor)
|
||||
&& util.isInViewCone (path.origin, m_editor)) || !util.isAlive (m_editor) || distanceSq < cr::sqrf (64.0f))) {
|
||||
&& util.isInViewCone (path.origin, m_editor)) || !game.isAliveEntity (m_editor) || distanceSq < cr::sqrf (64.0f))) {
|
||||
|
||||
// check the distance
|
||||
if (distanceSq < nearestDistanceSq) {
|
||||
|
|
@ -2766,43 +2766,6 @@ void BotGraph::addBasic () {
|
|||
autoCreateForEntity (NodeAddFlag::Goal, "func_escapezone"); // terrorist escape zone
|
||||
}
|
||||
|
||||
void BotGraph::setBombOrigin (bool reset, const Vector &pos) {
|
||||
// this function stores the bomb position as a vector
|
||||
|
||||
if (!game.mapIs (MapFlags::Demolition) || !bots.isBombPlanted ()) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (reset) {
|
||||
m_bombOrigin.clear ();
|
||||
bots.setBombPlanted (false);
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
if (!pos.empty ()) {
|
||||
m_bombOrigin = pos;
|
||||
return;
|
||||
}
|
||||
bool wasFound = false;
|
||||
auto bombModel = conf.getBombModelName ();
|
||||
|
||||
game.searchEntities ("classname", "grenade", [&] (edict_t *ent) {
|
||||
if (util.isModel (ent, bombModel)) {
|
||||
m_bombOrigin = game.getEntityOrigin (ent);
|
||||
wasFound = true;
|
||||
|
||||
return EntitySearchResult::Break;
|
||||
}
|
||||
return EntitySearchResult::Continue;
|
||||
});
|
||||
|
||||
if (!wasFound) {
|
||||
m_bombOrigin.clear ();
|
||||
bots.setBombPlanted (false);
|
||||
}
|
||||
}
|
||||
|
||||
void BotGraph::startLearnJump () {
|
||||
m_jumpLearnNode = true;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -27,7 +27,7 @@ int32_t ServerQueryHook::sendTo (int socket, const void *message, size_t length,
|
|||
buffer.skip <int32_t> (); // score
|
||||
|
||||
auto ctime = buffer.read <float> (); // override connection time
|
||||
buffer.write <float> (bots.getConnectTime (name, ctime));
|
||||
buffer.write <float> (bots.getConnectionTimes (name, ctime));
|
||||
}
|
||||
return send (buffer.data ());
|
||||
}
|
||||
|
|
|
|||
|
|
@ -50,7 +50,7 @@ CR_FORCE_STACK_ALIGN void handler_engClientCommand (edict_t *ent, char const *fo
|
|||
// case it's a bot asking for a client command, we handle it like we do for bot commands
|
||||
|
||||
if (!game.isNullEntity (ent)) {
|
||||
if (bots[ent] || util.isFakeClient (ent) || (ent->v.flags & FL_DORMANT)) {
|
||||
if (bots[ent] || game.isFakeClientEntity (ent) || (ent->v.flags & FL_DORMANT)) {
|
||||
if (game.is (GameFlags::Metamod)) {
|
||||
RETURN_META (MRES_SUPERCEDE); // prevent bots to be forced to issue client commands
|
||||
}
|
||||
|
|
@ -159,7 +159,7 @@ CR_EXPORT int GetEntityAPI (gamefuncs_t *table, int interfaceVersion) {
|
|||
|
||||
auto bot = bots[pentTouched];
|
||||
|
||||
if (bot && util.isBreakableEntity (pentOther)) {
|
||||
if (bot && game.isBreakableEntity (pentOther)) {
|
||||
bot->checkBreakable (pentOther);
|
||||
}
|
||||
}
|
||||
|
|
@ -389,10 +389,10 @@ CR_EXPORT int GetEntityAPI (gamefuncs_t *table, int interfaceVersion) {
|
|||
|
||||
if (bots.hasBotsOnline ()) {
|
||||
// keep track of grenades on map
|
||||
bots.updateActiveGrenade ();
|
||||
gameState.updateActiveGrenade ();
|
||||
|
||||
// keep track of interesting entities
|
||||
bots.updateInterestingEntities ();
|
||||
gameState.updateInterestingEntities ();
|
||||
}
|
||||
|
||||
// keep bot number up to date
|
||||
|
|
@ -429,7 +429,7 @@ CR_EXPORT int GetEntityAPI (gamefuncs_t *table, int interfaceVersion) {
|
|||
auto ent = const_cast <edict_t *> (reinterpret_cast <const edict_t *> (player));
|
||||
|
||||
if (fakeping.hasFeature ()) {
|
||||
if (!util.isFakeClient (ent) && (ent->v.oldbuttons | ent->v.button) & IN_SCORE) {
|
||||
if (!game.isFakeClientEntity (ent) && (ent->v.oldbuttons | ent->v.button) & IN_SCORE) {
|
||||
fakeping.emit (ent);
|
||||
}
|
||||
}
|
||||
|
|
@ -560,7 +560,7 @@ CR_C_LINKAGE int GetEntityAPI_Post (gamefuncs_t *table, int) {
|
|||
auto ent = const_cast <edict_t *> (reinterpret_cast <const edict_t *> (player));
|
||||
|
||||
if (fakeping.hasFeature ()) {
|
||||
if (!util.isFakeClient (ent) && (ent->v.oldbuttons | ent->v.button) & IN_SCORE) {
|
||||
if (!game.isFakeClientEntity (ent) && (ent->v.oldbuttons | ent->v.button) & IN_SCORE) {
|
||||
fakeping.emit (ent);
|
||||
}
|
||||
}
|
||||
|
|
@ -591,7 +591,7 @@ CR_C_LINKAGE int GetEngineFunctions (enginefuncs_t *table, int *) {
|
|||
table->pfnFindEntityByString = [] (edict_t *edictStartSearchAfter, const char *field, const char *value) CR_FORCE_STACK_ALIGN {
|
||||
// round starts in counter-strike 1.5
|
||||
if (strcmp (value, "info_map_parameters") == 0) {
|
||||
bots.initRound ();
|
||||
gameState.roundStart ();
|
||||
}
|
||||
|
||||
if (game.is (GameFlags::Metamod)) {
|
||||
|
|
@ -786,7 +786,7 @@ CR_C_LINKAGE int GetEngineFunctions (enginefuncs_t *table, int *) {
|
|||
// as it will crash your server. Why would you, anyway ? bots have no client DLL as far as
|
||||
// we know, right ? But since stupidity rules this world, we do a preventive check :)
|
||||
|
||||
if (util.isFakeClient (ent)) {
|
||||
if (game.isFakeClientEntity (ent)) {
|
||||
if (game.is (GameFlags::Metamod)) {
|
||||
RETURN_META (MRES_SUPERCEDE);
|
||||
}
|
||||
|
|
|
|||
260
src/manager.cpp
260
src/manager.cpp
|
|
@ -469,7 +469,7 @@ void BotManager::maintainLeaders () {
|
|||
}
|
||||
|
||||
// select leader each team somewhere in round start
|
||||
if (m_timeRoundStart + rg (1.5f, 3.0f) < game.time ()) {
|
||||
if (gameState.getRoundStartTime () + rg (1.5f, 3.0f) < game.time ()) {
|
||||
for (int team = 0; team < kGameTeamNum; ++team) {
|
||||
selectLeaders (team, false);
|
||||
}
|
||||
|
|
@ -487,7 +487,7 @@ void BotManager::maintainRoundRestart () {
|
|||
&& m_numPreviousPlayers == 0
|
||||
&& totalHumans == 1
|
||||
&& totalBots > 0
|
||||
&& !m_resetHud) {
|
||||
&& !gameState.isResetHUD ()) {
|
||||
|
||||
static ConVarRef sv_restartround ("sv_restartround");
|
||||
|
||||
|
|
@ -496,13 +496,13 @@ void BotManager::maintainRoundRestart () {
|
|||
}
|
||||
}
|
||||
m_numPreviousPlayers = totalHumans;
|
||||
m_resetHud = false;
|
||||
gameState.setResetHUD (false);
|
||||
}
|
||||
|
||||
void BotManager::maintainAutoKill () {
|
||||
const float killDelay = cv_autokill_delay.as <float> ();
|
||||
|
||||
if (killDelay < 1.0f || m_roundOver) {
|
||||
if (killDelay < 1.0f || gameState.isRoundOver ()) {
|
||||
return;
|
||||
}
|
||||
|
||||
|
|
@ -516,7 +516,7 @@ void BotManager::maintainAutoKill () {
|
|||
int aliveBots = 0;
|
||||
|
||||
// do not interrupt bomb-defuse scenario
|
||||
if (game.mapIs (MapFlags::Demolition) && isBombPlanted ()) {
|
||||
if (game.mapIs (MapFlags::Demolition) && gameState.isBombPlanted ()) {
|
||||
return;
|
||||
}
|
||||
const int totalHumans = getHumansCount (true); // we're ignore spectators intentionally
|
||||
|
|
@ -531,7 +531,7 @@ void BotManager::maintainAutoKill () {
|
|||
++aliveBots;
|
||||
|
||||
// do not interrupt assassination scenario, if vip is a bot
|
||||
if (game.is (MapFlags::Assassination) && util.isPlayerVIP (bot->ent ())) {
|
||||
if (game.is (MapFlags::Assassination) && game.isPlayerVIP (bot->ent ())) {
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
|
@ -545,15 +545,9 @@ void BotManager::maintainAutoKill () {
|
|||
}
|
||||
|
||||
void BotManager::reset () {
|
||||
m_grenadeUpdateTime = 0.0f;
|
||||
m_entityUpdateTime = 0.0f;
|
||||
m_plantSearchUpdateTime = 0.0f;
|
||||
m_lastChatTime = 0.0f;
|
||||
m_timeBombPlanted = 0.0f;
|
||||
m_bombSayStatus = BombPlantedSay::ChatSay | BombPlantedSay::Chatter;
|
||||
|
||||
m_interestingEntities.clear ();
|
||||
m_activeGrenades.clear ();
|
||||
}
|
||||
|
||||
void BotManager::initFilters () {
|
||||
|
|
@ -681,7 +675,7 @@ void BotManager::kickFromTeam (Team team, bool removeAll) {
|
|||
}
|
||||
|
||||
for (const auto &bot : m_bots) {
|
||||
if (team == game.getRealTeam (bot->ent ())) {
|
||||
if (team == game.getRealPlayerTeam (bot->ent ())) {
|
||||
bot->kick (removeAll);
|
||||
|
||||
if (!removeAll) {
|
||||
|
|
@ -696,7 +690,7 @@ void BotManager::killAllBots (int team, bool silent) {
|
|||
// this function kills all bots on server (only this dll controlled bots)
|
||||
|
||||
for (const auto &bot : m_bots) {
|
||||
if (team != Team::Invalid && game.getRealTeam (bot->ent ()) != team) {
|
||||
if (team != Team::Invalid && game.getRealPlayerTeam (bot->ent ()) != team) {
|
||||
continue;
|
||||
}
|
||||
bot->kill ();
|
||||
|
|
@ -732,7 +726,7 @@ bool BotManager::kickRandom (bool decQuota, Team fromTeam) {
|
|||
if (fromTeam == Team::Unassigned) {
|
||||
return true;
|
||||
}
|
||||
return game.getRealTeam (bot->ent ()) == fromTeam;
|
||||
return game.getRealPlayerTeam (bot->ent ()) == fromTeam;
|
||||
};
|
||||
|
||||
// first try to kick the bot that is currently dead
|
||||
|
|
@ -830,7 +824,7 @@ bool BotManager::hasCustomCSDMSpawnEntities () {
|
|||
|
||||
void BotManager::setLastWinner (int winner) {
|
||||
m_lastWinner = winner;
|
||||
m_roundOver = true;
|
||||
gameState.setRoundOver (true);
|
||||
|
||||
if (cv_radio_mode.as <int> () != 2) {
|
||||
return;
|
||||
|
|
@ -839,7 +833,7 @@ void BotManager::setLastWinner (int winner) {
|
|||
|
||||
if (notify) {
|
||||
if (notify->m_team == winner) {
|
||||
if (getRoundMidTime () > game.time ()) {
|
||||
if (gameState.getRoundMidTime () > game.time ()) {
|
||||
notify->pushChatterMessage (Chatter::QuickWonRound);
|
||||
}
|
||||
else {
|
||||
|
|
@ -929,7 +923,7 @@ void BotManager::listBots () {
|
|||
ctrl.msg ("%-3.5s\t%-19.16s\t%-10.12s\t%-3.4s\t%-3.4s\t%-3.4s\t%-3.6s\t%-3.5s\t%-3.8s", "index", "name", "personality", "team", "difficulty", "frags", "deaths", "alive", "timeleft");
|
||||
|
||||
auto botTeam = [] (edict_t *ent) -> StringRef {
|
||||
const auto team = game.getRealTeam (ent);
|
||||
const auto team = game.getRealPlayerTeam (ent);
|
||||
|
||||
switch (team) {
|
||||
case Team::CT:
|
||||
|
|
@ -967,7 +961,7 @@ void BotManager::listBots () {
|
|||
ctrl.msg ("%d bots", m_bots.length ());
|
||||
}
|
||||
|
||||
float BotManager::getConnectTime (StringRef name, float original) {
|
||||
float BotManager::getConnectionTimes (StringRef name, float original) {
|
||||
// this function get's fake bot player time.
|
||||
|
||||
for (const auto &bot : m_bots) {
|
||||
|
|
@ -1020,19 +1014,18 @@ Twin <int, int> BotManager::countTeamPlayers () {
|
|||
}
|
||||
|
||||
Bot *BotManager::findHighestFragBot (int team) {
|
||||
int bestIndex = 0;
|
||||
float bestScore = -1;
|
||||
Twin <int32_t, float> best {};
|
||||
|
||||
// search bots in this team
|
||||
for (const auto &bot : bots) {
|
||||
if (bot->m_isAlive && game.getRealTeam (bot->ent ()) == team) {
|
||||
if (bot->pev->frags > bestScore) {
|
||||
bestIndex = bot->index ();
|
||||
bestScore = bot->pev->frags;
|
||||
if (bot->m_isAlive && game.getRealPlayerTeam (bot->ent ()) == team) {
|
||||
if (bot->pev->frags > best.second) {
|
||||
best.first = bot->index ();
|
||||
best.second = bot->pev->frags;
|
||||
}
|
||||
}
|
||||
}
|
||||
return findBotByIndex (bestIndex);
|
||||
return findBotByIndex (best.first);
|
||||
}
|
||||
|
||||
void BotManager::updateTeamEconomics (int team, bool setTrue) {
|
||||
|
|
@ -1398,8 +1391,8 @@ void BotManager::disconnectBot (Bot *bot) {
|
|||
}
|
||||
|
||||
void BotManager::handleDeath (edict_t *killer, edict_t *victim) {
|
||||
const auto killerTeam = game.getRealTeam (killer);
|
||||
const auto victimTeam = game.getRealTeam (victim);
|
||||
const auto killerTeam = game.getRealPlayerTeam (killer);
|
||||
const auto victimTeam = game.getRealPlayerTeam (victim);
|
||||
|
||||
if (cv_radio_mode.as <int> () == 2) {
|
||||
// need to send congrats on well placed shot
|
||||
|
|
@ -1512,7 +1505,7 @@ void Bot::newRound () {
|
|||
node = kInvalidNodeIndex;
|
||||
}
|
||||
m_navTimeset = game.time ();
|
||||
m_team = game.getTeam (ent ());
|
||||
m_team = game.getPlayerTeam (ent ());
|
||||
|
||||
resetPathSearchType ();
|
||||
|
||||
|
|
@ -1841,7 +1834,7 @@ void Bot::updateTeamJoin () {
|
|||
if (!m_notStarted) {
|
||||
return;
|
||||
}
|
||||
const auto botTeam = game.getRealTeam (ent ());
|
||||
const auto botTeam = game.getRealPlayerTeam (ent ());
|
||||
|
||||
// cs prior beta 7.0 uses hud-based motd, so press fire once
|
||||
if (game.is (GameFlags::Legacy)) {
|
||||
|
|
@ -1948,15 +1941,15 @@ void BotManager::captureChatRadio (StringRef cmd, StringRef arg, edict_t *ent) {
|
|||
}
|
||||
|
||||
if (cmd.startsWith ("say")) {
|
||||
const bool alive = util.isAlive (ent);
|
||||
const bool alive = game.isAliveEntity (ent);
|
||||
int team = -1;
|
||||
|
||||
if (cmd.endsWith ("team")) {
|
||||
team = game.getRealTeam (ent);
|
||||
team = game.getRealPlayerTeam (ent);
|
||||
}
|
||||
|
||||
for (const auto &client : util.getClients ()) {
|
||||
if (!(client.flags & ClientFlags::Used) || (team != -1 && team != client.team2) || alive != util.isAlive (client.ent)) {
|
||||
if (!(client.flags & ClientFlags::Used) || (team != -1 && team != client.team2) || alive != game.isAliveEntity (client.ent)) {
|
||||
continue;
|
||||
}
|
||||
auto target = bots[client.ent];
|
||||
|
|
@ -2003,7 +1996,7 @@ void BotManager::captureChatRadio (StringRef cmd, StringRef arg, edict_t *ent) {
|
|||
void BotManager::notifyBombDefuse () {
|
||||
// notify all terrorists that CT is starting bomb defusing
|
||||
|
||||
const auto &bombPos = graph.getBombOrigin ();
|
||||
const auto &bombPos = gameState.getBombOrigin ();
|
||||
|
||||
for (const auto &bot : bots) {
|
||||
const auto task = bot->getCurrentTaskId ();
|
||||
|
|
@ -2027,68 +2020,6 @@ void BotManager::notifyBombDefuse () {
|
|||
}
|
||||
}
|
||||
|
||||
void BotManager::updateActiveGrenade () {
|
||||
if (m_grenadeUpdateTime > game.time ()) {
|
||||
return;
|
||||
}
|
||||
m_activeGrenades.clear (); // clear previously stored grenades
|
||||
|
||||
// need to ignore bomb model in active grenades...
|
||||
auto bombModel = conf.getBombModelName ();
|
||||
|
||||
// search the map for any type of grenade
|
||||
game.searchEntities ("classname", "grenade", [&] (edict_t *e) {
|
||||
// do not count c4 as a grenade
|
||||
if (!util.isModel (e, bombModel)) {
|
||||
m_activeGrenades.push (e);
|
||||
}
|
||||
return EntitySearchResult::Continue; // continue iteration
|
||||
});
|
||||
m_grenadeUpdateTime = game.time () + 0.25f;
|
||||
}
|
||||
|
||||
void BotManager::updateInterestingEntities () {
|
||||
if (m_entityUpdateTime > game.time ()) {
|
||||
return;
|
||||
}
|
||||
|
||||
// clear previously stored entities
|
||||
m_interestingEntities.clear ();
|
||||
|
||||
// search the map for any type of grenade
|
||||
game.searchEntities (nullptr, kInfiniteDistance, [&] (edict_t *e) {
|
||||
auto classname = e->v.classname.str ();
|
||||
|
||||
// search for grenades, weaponboxes, weapons, items and armoury entities
|
||||
if (classname.startsWith ("weaponbox") || classname.startsWith ("grenade") || util.isItem (e) || classname.startsWith ("armoury")) {
|
||||
m_interestingEntities.push (e);
|
||||
}
|
||||
|
||||
// pickup some hostage if on cs_ maps
|
||||
if (game.mapIs (MapFlags::HostageRescue) && util.isHostageEntity (e)) {
|
||||
m_interestingEntities.push (e);
|
||||
}
|
||||
|
||||
// add buttons
|
||||
if (game.mapIs (MapFlags::HasButtons) && classname.startsWith ("func_button")) {
|
||||
m_interestingEntities.push (e);
|
||||
}
|
||||
|
||||
// pickup some csdm stuff if we're running csdm
|
||||
if (game.is (GameFlags::CSDM) && classname.startsWith ("csdm")) {
|
||||
m_interestingEntities.push (e);
|
||||
}
|
||||
|
||||
if (cv_attack_monsters && util.isMonster (e)) {
|
||||
m_interestingEntities.push (e);
|
||||
}
|
||||
|
||||
// continue iteration
|
||||
return EntitySearchResult::Continue;
|
||||
});
|
||||
m_entityUpdateTime = game.time () + 0.5f;
|
||||
}
|
||||
|
||||
void BotManager::selectLeaders (int team, bool reset) {
|
||||
auto &leaderChoosen = m_teamData[team].leaderChoosen;
|
||||
|
||||
|
|
@ -2191,8 +2122,6 @@ void BotManager::selectLeaders (int team, bool reset) {
|
|||
void BotManager::initRound () {
|
||||
// this is called at the start of each round
|
||||
|
||||
m_roundOver = false;
|
||||
|
||||
// check team economics
|
||||
for (int team = 0; team < kGameTeamNum; ++team) {
|
||||
updateTeamEconomics (team);
|
||||
|
|
@ -2211,35 +2140,15 @@ void BotManager::initRound () {
|
|||
for (auto &client : util.getClients ()) {
|
||||
client.radio = 0;
|
||||
}
|
||||
|
||||
graph.setBombOrigin (true);
|
||||
graph.clearVisited ();
|
||||
|
||||
m_bombSayStatus = BombPlantedSay::ChatSay | BombPlantedSay::Chatter;
|
||||
m_timeBombPlanted = 0.0f;
|
||||
m_plantSearchUpdateTime = 0.0f;
|
||||
m_autoKillCheckTime = 0.0f;
|
||||
m_botsCanPause = false;
|
||||
|
||||
resetFilters ();
|
||||
practice.update (); // update practice data on round start
|
||||
|
||||
// calculate the round mid/end in world time
|
||||
m_timeRoundStart = game.time () + mp_freezetime.as <float> ();
|
||||
m_timeRoundMid = m_timeRoundStart + mp_roundtime.as <float> () * 60.0f * 0.5f;
|
||||
m_timeRoundEnd = m_timeRoundStart + mp_roundtime.as <float> () * 60.0f;
|
||||
}
|
||||
|
||||
void BotManager::setBombPlanted (bool isPlanted) {
|
||||
if (cv_ignore_objectives) {
|
||||
m_bombPlanted = false;
|
||||
return;
|
||||
}
|
||||
|
||||
if (isPlanted) {
|
||||
m_timeBombPlanted = game.time ();
|
||||
}
|
||||
m_bombPlanted = isPlanted;
|
||||
}
|
||||
|
||||
void BotThreadWorker::shutdown () {
|
||||
|
|
@ -2293,121 +2202,6 @@ void BotThreadWorker::startup (int workers) {
|
|||
m_pool->startup (static_cast <size_t> (requestedThreads));
|
||||
}
|
||||
|
||||
bool BotManager::isLineBlockedBySmoke (const Vector &from, const Vector &to) {
|
||||
if (m_activeGrenades.empty ()) {
|
||||
return false;
|
||||
}
|
||||
constexpr auto kSmokeGrenadeRadius = 115.0f;
|
||||
|
||||
// distance along line of sight covered by smoke
|
||||
float totalSmokedLength = 0.0f;
|
||||
|
||||
Vector sightDir = to - from;
|
||||
const float sightLength = sightDir.normalizeInPlace ();
|
||||
|
||||
for (auto pent : m_activeGrenades) {
|
||||
if (game.isNullEntity (pent)) {
|
||||
continue;
|
||||
}
|
||||
|
||||
// need drawn models
|
||||
if (pent->v.effects & EF_NODRAW) {
|
||||
continue;
|
||||
}
|
||||
|
||||
// smoke must be on a ground
|
||||
if (!(pent->v.flags & FL_ONGROUND)) {
|
||||
continue;
|
||||
}
|
||||
|
||||
// must be a smoke grenade
|
||||
if (!util.isModel (pent, kSmokeModelName)) {
|
||||
continue;
|
||||
}
|
||||
|
||||
const float smokeRadiusSq = cr::sqrf (kSmokeGrenadeRadius);
|
||||
const Vector &smokeOrigin = game.getEntityOrigin (pent);
|
||||
|
||||
Vector toGrenade = smokeOrigin - from;
|
||||
float alongDist = toGrenade | sightDir;
|
||||
|
||||
// compute closest point to grenade along line of sight ray
|
||||
Vector close {};
|
||||
|
||||
// constrain closest point to line segment
|
||||
if (alongDist < 0.0f) {
|
||||
close = from;
|
||||
}
|
||||
else if (alongDist >= sightLength) {
|
||||
close = to;
|
||||
}
|
||||
else {
|
||||
close = from + sightDir * alongDist;
|
||||
}
|
||||
|
||||
// if closest point is within smoke radius, the line overlaps the smoke cloud
|
||||
Vector toClose = close - smokeOrigin;
|
||||
float lengthSq = toClose.lengthSq ();
|
||||
|
||||
if (lengthSq < smokeRadiusSq) {
|
||||
// some portion of the ray intersects the cloud
|
||||
|
||||
const float fromSq = toGrenade.lengthSq ();
|
||||
const float toSq = (smokeOrigin - to).lengthSq ();
|
||||
|
||||
if (fromSq < smokeRadiusSq) {
|
||||
if (toSq < smokeRadiusSq) {
|
||||
// both 'from' and 'to' lie within the cloud
|
||||
// entire length is smoked
|
||||
totalSmokedLength += (to - from).length ();
|
||||
}
|
||||
else {
|
||||
// 'from' is inside the cloud, 'to' is outside
|
||||
// compute half of total smoked length as if ray crosses entire cloud chord
|
||||
float halfSmokedLength = cr::sqrtf (smokeRadiusSq - lengthSq);
|
||||
|
||||
if (alongDist > 0.0f) {
|
||||
// ray goes thru 'close'
|
||||
totalSmokedLength += halfSmokedLength + (close - from).length ();
|
||||
}
|
||||
else {
|
||||
// ray starts after 'close'
|
||||
totalSmokedLength += halfSmokedLength - (close - from).length ();
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
else if (toSq < smokeRadiusSq) {
|
||||
// 'from' is outside the cloud, 'to' is inside
|
||||
// compute half of total smoked length as if ray crosses entire cloud chord
|
||||
const float halfSmokedLength = cr::sqrtf (smokeRadiusSq - lengthSq);
|
||||
Vector v = to - smokeOrigin;
|
||||
|
||||
if ((v | sightDir) > 0.0f) {
|
||||
// ray goes thru 'close'
|
||||
totalSmokedLength += halfSmokedLength + (close - to).length ();
|
||||
}
|
||||
else {
|
||||
// ray ends before 'close'
|
||||
totalSmokedLength += halfSmokedLength - (close - to).length ();
|
||||
}
|
||||
}
|
||||
else {
|
||||
// 'from' and 'to' lie outside of the cloud - the line of sight completely crosses it
|
||||
// determine the length of the chord that crosses the cloud
|
||||
const float smokedLength = 2.0f * cr::sqrtf (smokeRadiusSq - lengthSq);
|
||||
totalSmokedLength += smokedLength;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// define how much smoke a bot can see thru
|
||||
const float maxSmokedLength = 0.7f * kSmokeGrenadeRadius;
|
||||
|
||||
// return true if the total length of smoke-covered line-of-sight is too much
|
||||
return totalSmokedLength > maxSmokedLength;
|
||||
}
|
||||
|
||||
bool BotManager::isFrameSkipDisabled () {
|
||||
if (game.is (GameFlags::Legacy)) {
|
||||
return true;
|
||||
|
|
|
|||
|
|
@ -26,7 +26,7 @@ void MessageDispatcher::netMsgTextMsg () {
|
|||
// reset bomb position for all the bots
|
||||
const auto resetBombPosition = [] () -> void {
|
||||
if (game.mapIs (MapFlags::Demolition)) {
|
||||
graph.setBombOrigin (true);
|
||||
gameState.setBombOrigin (true);
|
||||
}
|
||||
};
|
||||
|
||||
|
|
@ -53,8 +53,8 @@ void MessageDispatcher::netMsgTextMsg () {
|
|||
bots.setLastWinner (Team::Terrorist); // update last winner for economics
|
||||
resetBombPosition ();
|
||||
}
|
||||
else if ((cached & TextMsgCache::BombPlanted) && !bots.isBombPlanted ()) {
|
||||
bots.setBombPlanted (true);
|
||||
else if ((cached & TextMsgCache::BombPlanted) && !gameState.isBombPlanted ()) {
|
||||
gameState.setBombPlanted (true);
|
||||
|
||||
for (const auto ¬ify : bots) {
|
||||
if (notify->m_isAlive) {
|
||||
|
|
@ -68,7 +68,7 @@ void MessageDispatcher::netMsgTextMsg () {
|
|||
}
|
||||
}
|
||||
}
|
||||
graph.setBombOrigin ();
|
||||
gameState.setBombOrigin ();
|
||||
}
|
||||
|
||||
// check for burst fire message
|
||||
|
|
@ -319,7 +319,7 @@ void MessageDispatcher::netMsgHLTV () {
|
|||
|
||||
// need to start new round ? (we're tracking FOV reset message)
|
||||
if (m_args[players].long_ == 0 && m_args[fov].long_ == 0) {
|
||||
bots.initRound ();
|
||||
gameState.roundStart ();
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -389,7 +389,7 @@ void MessageDispatcher::netMsgBarTime () {
|
|||
m_bot->m_hasProgressBar = true; // the progress bar on a hud
|
||||
|
||||
// notify bots about defusing has started
|
||||
if (game.mapIs (MapFlags::Demolition) && bots.isBombPlanted () && m_bot->m_team == Team::CT) {
|
||||
if (game.mapIs (MapFlags::Demolition) && gameState.isBombPlanted () && m_bot->m_team == Team::CT) {
|
||||
bots.notifyBombDefuse ();
|
||||
}
|
||||
}
|
||||
|
|
@ -435,7 +435,7 @@ void MessageDispatcher::netMsgResetHUD () {
|
|||
if (m_bot) {
|
||||
m_bot->spawned ();
|
||||
}
|
||||
bots.setResetHUD (true);
|
||||
gameState.setResetHUD (true);
|
||||
}
|
||||
|
||||
MessageDispatcher::MessageDispatcher () {
|
||||
|
|
|
|||
|
|
@ -60,12 +60,12 @@ int Bot::findBestGoal () {
|
|||
bool hasMoreHostagesAround = false;
|
||||
|
||||
// try to search nearby-unused hostage, and if so, go to next goal
|
||||
if (bots.hasInterestingEntities ()) {
|
||||
const auto &interesting = bots.getInterestingEntities ();
|
||||
if (gameState.hasInterestingEntities ()) {
|
||||
const auto &interesting = gameState.getInterestingEntities ();
|
||||
|
||||
// search world for hostages
|
||||
for (const auto &ent : interesting) {
|
||||
if (!util.isHostageEntity (ent)) {
|
||||
if (!game.isHostageEntity (ent)) {
|
||||
continue;
|
||||
}
|
||||
bool hostageInUse = false;
|
||||
|
|
@ -134,7 +134,7 @@ int Bot::findBestGoal () {
|
|||
}
|
||||
}
|
||||
else if (game.mapIs (MapFlags::Demolition) && m_team == Team::CT) {
|
||||
if (bots.isBombPlanted () && getCurrentTaskId () != Task::EscapeFromBomb && !graph.getBombOrigin ().empty ()) {
|
||||
if (gameState.isBombPlanted () && getCurrentTaskId () != Task::EscapeFromBomb && !gameState.getBombOrigin ().empty ()) {
|
||||
|
||||
if (bots.hasBombSay (BombPlantedSay::ChatSay)) {
|
||||
pushChatMessage (Chat::Plant);
|
||||
|
|
@ -149,10 +149,10 @@ int Bot::findBestGoal () {
|
|||
defensive += 10.0f;
|
||||
}
|
||||
}
|
||||
else if (game.mapIs (MapFlags::Demolition) && m_team == Team::Terrorist && bots.getRoundStartTime () + 10.0f < game.time ()) {
|
||||
else if (game.mapIs (MapFlags::Demolition) && m_team == Team::Terrorist && gameState.getRoundStartTime () + 10.0f < game.time ()) {
|
||||
// send some terrorists to guard planted bomb
|
||||
if (!m_defendedBomb && bots.isBombPlanted () && getCurrentTaskId () != Task::EscapeFromBomb && getBombTimeleft () >= 15.0f) {
|
||||
return m_chosenGoalIndex = findDefendNode (graph.getBombOrigin ());
|
||||
if (!m_defendedBomb && gameState.isBombPlanted () && getCurrentTaskId () != Task::EscapeFromBomb && gameState.getBombTimeLeft () >= 15.0f) {
|
||||
return m_chosenGoalIndex = findDefendNode (gameState.getBombOrigin ());
|
||||
}
|
||||
}
|
||||
else if (game.mapIs (MapFlags::Escape)) {
|
||||
|
|
@ -202,9 +202,9 @@ int Bot::findBestGoal () {
|
|||
int Bot::findBestGoalWhenBombAction () {
|
||||
int result = kInvalidNodeIndex;
|
||||
|
||||
if (!bots.isBombPlanted () && !cv_ignore_objectives) {
|
||||
if (!gameState.isBombPlanted () && !cv_ignore_objectives) {
|
||||
game.searchEntities ("classname", "weaponbox", [&] (edict_t *ent) {
|
||||
if (util.isModel (ent, "backpack.mdl")) {
|
||||
if (game.isEntityModelMatches (ent, "backpack.mdl")) {
|
||||
result = graph.getNearest (game.getEntityOrigin (ent));
|
||||
|
||||
if (graph.exists (result)) {
|
||||
|
|
@ -230,7 +230,7 @@ int Bot::findBestGoalWhenBombAction () {
|
|||
}
|
||||
}
|
||||
else if (!m_defendedBomb) {
|
||||
const auto &bombOrigin = graph.getBombOrigin ();
|
||||
const auto &bombOrigin = gameState.getBombOrigin ();
|
||||
|
||||
if (!bombOrigin.empty ()) {
|
||||
m_defendedBomb = true;
|
||||
|
|
@ -239,7 +239,7 @@ int Bot::findBestGoalWhenBombAction () {
|
|||
const auto &path = graph[result];
|
||||
|
||||
const float bombTimer = mp_c4timer.as <float> ();
|
||||
const float timeMidBlowup = bots.getTimeBombPlanted () + (bombTimer * 0.5f + bombTimer * 0.25f) - graph.calculateTravelTime (pev->maxspeed, pev->origin, path.origin);
|
||||
const float timeMidBlowup = gameState.getTimeBombPlanted () + (bombTimer * 0.5f + bombTimer * 0.25f) - graph.calculateTravelTime (pev->maxspeed, pev->origin, path.origin);
|
||||
|
||||
if (timeMidBlowup > game.time ()) {
|
||||
clearTask (Task::MoveToPosition); // remove any move tasks
|
||||
|
|
@ -288,14 +288,15 @@ int Bot::findGoalPost (int tactic, IntArray *defensive, IntArray *offensive) {
|
|||
else if (tactic == GoalTactic::Goal && !graph.m_goalPoints.empty ()) { // map goal node
|
||||
|
||||
// force bomber to select closest goal, if round-start goal was reset by something
|
||||
if (m_isVIP || (m_hasC4 && bots.getRoundStartTime () + 20.0f < game.time ())) {
|
||||
if (m_isVIP || (m_hasC4 && gameState.getRoundStartTime () + 20.0f < game.time ())) {
|
||||
float nearestDistanceSq = kInfiniteDistance;
|
||||
int count = 0;
|
||||
|
||||
for (const auto &point : graph.m_goalPoints) {
|
||||
const float distanceSq = graph[point].origin.distanceSq (pev->origin);
|
||||
|
||||
if (distanceSq > cr::sqrf (1024.0f) || isGroupOfEnemies (graph[point].origin)) {
|
||||
if (distanceSq > cr::sqrf (1024.0f)
|
||||
|| (rg.chance (25) && isGroupOfEnemies (graph[point].origin))) {
|
||||
continue;
|
||||
}
|
||||
if (distanceSq < nearestDistanceSq) {
|
||||
|
|
@ -594,7 +595,7 @@ void Bot::doPlayerAvoidance (const Vector &normal) {
|
|||
|
||||
void Bot::checkTerrain (const Vector &dirNormal) {
|
||||
|
||||
// if avoiding someone do not consider stuck
|
||||
// if avoiding someone do not consider stuckn
|
||||
TraceResult tr {};
|
||||
m_isStuck = false;
|
||||
|
||||
|
|
@ -602,7 +603,7 @@ void Bot::checkTerrain (const Vector &dirNormal) {
|
|||
|
||||
// minimal speed for consider stuck
|
||||
const float minimalSpeed = isDucking () ? kMinMovedDistance : kMinMovedDistance * 4;
|
||||
const auto randomProbeTime = rg (0.75f, 1.15f);
|
||||
const auto randomProbeTime = rg (0.50f, 0.75f);
|
||||
|
||||
// standing still, no need to check?
|
||||
if ((cr::abs (m_moveSpeed) >= minimalSpeed || cr::abs (m_strafeSpeed) >= minimalSpeed)
|
||||
|
|
@ -900,10 +901,7 @@ void Bot::checkTerrain (const Vector &dirNormal) {
|
|||
}
|
||||
|
||||
void Bot::checkFall () {
|
||||
if (isPreviousLadder ()) {
|
||||
return;
|
||||
}
|
||||
else if ((m_pathFlags & NodeFlag::Ladder) && isPreviousLadder () && isOnLadder ()) {
|
||||
if (isPreviousLadder () || (m_pathFlags & NodeFlag::Ladder)) {
|
||||
return;
|
||||
}
|
||||
|
||||
|
|
@ -1105,7 +1103,7 @@ bool Bot::updateNavigation () {
|
|||
if (m_desiredVelocity.length2d () > 0.0f) {
|
||||
pev->velocity = m_desiredVelocity;
|
||||
}
|
||||
else {
|
||||
else if (graph.isAnalyzed ()) {
|
||||
auto feet = pev->origin + pev->mins;
|
||||
auto node = Vector { m_pathOrigin.x, m_pathOrigin.y, m_pathOrigin.z - ((m_pathFlags & NodeFlag::Crouch) ? 18.0f : 36.0f) };
|
||||
|
||||
|
|
@ -1151,7 +1149,7 @@ bool Bot::updateNavigation () {
|
|||
}
|
||||
|
||||
if (m_pathFlags & NodeFlag::Ladder) {
|
||||
constexpr auto kLadderOffset = Vector (0.0f, 0.0f, 36.0f);
|
||||
constexpr auto kLadderOffset = Vector { 0.0f, 0.0f, 36.0f };
|
||||
|
||||
const auto prevNodeIndex = m_previousNodes[0];
|
||||
const float ladderDistance = pev->origin.distance (m_pathOrigin);
|
||||
|
|
@ -1231,7 +1229,7 @@ bool Bot::updateNavigation () {
|
|||
if (game.mapIs (MapFlags::HasDoors) || (m_pathFlags & NodeFlag::Button)) {
|
||||
game.testLine (pev->origin, m_pathOrigin, TraceIgnore::Monsters, ent (), &tr);
|
||||
|
||||
if (!game.isNullEntity (tr.pHit) && game.isNullEntity (m_liftEntity) && util.isDoorEntity (tr.pHit)) {
|
||||
if (!game.isNullEntity (tr.pHit) && game.isNullEntity (m_liftEntity) && game.isDoorEntity (tr.pHit)) {
|
||||
const auto &origin = game.getEntityOrigin (tr.pHit);
|
||||
const float distanceSq = pev->origin.distanceSq (origin);
|
||||
|
||||
|
|
@ -1285,7 +1283,7 @@ bool Bot::updateNavigation () {
|
|||
util.findNearestPlayer (reinterpret_cast <void **> (&nearest), ent (), 256.0f, false, false, true, true, false);
|
||||
|
||||
// check if enemy is penetrable
|
||||
if (util.isAlive (nearest) && isPenetrableObstacle (nearest->v.origin) && !cv_ignore_enemies) {
|
||||
if (game.isAliveEntity (nearest) && isPenetrableObstacle (nearest->v.origin) && !cv_ignore_enemies) {
|
||||
m_seeEnemyTime = game.time ();
|
||||
|
||||
m_states |= Sense::SeeingEnemy | Sense::SuspectEnemy;
|
||||
|
|
@ -1324,7 +1322,7 @@ bool Bot::updateNavigation () {
|
|||
}
|
||||
}
|
||||
|
||||
float desiredDistanceSq = cr::sqrf (8.0f);
|
||||
float desiredDistanceSq = cr::sqrf (32.0f);
|
||||
const float nodeDistanceSq = pev->origin.distanceSq (m_pathOrigin);
|
||||
|
||||
// initialize the radius for a special node type, where the node is considered to be reached
|
||||
|
|
@ -1336,7 +1334,7 @@ bool Bot::updateNavigation () {
|
|||
|
||||
// on cs_ maps goals are usually hostages, so increase reachability distance for them, they (hostages) picked anyway
|
||||
if (game.mapIs (MapFlags::HostageRescue) && (m_pathFlags & NodeFlag::Goal)) {
|
||||
desiredDistanceSq = cr::sqrf (128.0f);
|
||||
desiredDistanceSq = cr::sqrf (96.0f);
|
||||
}
|
||||
}
|
||||
else if (m_pathFlags & NodeFlag::Ladder) {
|
||||
|
|
@ -1374,7 +1372,7 @@ bool Bot::updateNavigation () {
|
|||
}
|
||||
|
||||
// needs precise placement - check if we get past the point
|
||||
if (desiredDistanceSq < cr::sqrf (20.0f) && nodeDistanceSq < cr::sqrf (30.0f)) {
|
||||
if (desiredDistanceSq < cr::sqrf (16.0f) && nodeDistanceSq < cr::sqrf (30.0f)) {
|
||||
const auto predictRangeSq = m_pathOrigin.distanceSq (pev->origin + pev->velocity * m_frameInterval);
|
||||
|
||||
if (predictRangeSq >= nodeDistanceSq || predictRangeSq <= desiredDistanceSq) {
|
||||
|
|
@ -1386,7 +1384,10 @@ bool Bot::updateNavigation () {
|
|||
// is sitting there, so the bot is unable to reach the node because of other player on it, and he starts to jumping and so on
|
||||
// here we're clearing task memory data (important!), since task executor may restart goal with one from memory, so this process
|
||||
// will go in cycle, and forcing bot to re-create new route.
|
||||
if (m_pathWalk.hasNext () && m_pathWalk.next () == m_pathWalk.last () && isOccupiedNode (m_pathWalk.next (), pathHasFlags)) {
|
||||
if (m_pathWalk.hasNext ()
|
||||
&& m_pathWalk.next () == m_pathWalk.last ()
|
||||
&& isOccupiedNode (m_pathWalk.next (), pathHasFlags)) {
|
||||
|
||||
getTask ()->data = kInvalidNodeIndex;
|
||||
|
||||
m_currentNodeIndex = kInvalidNodeIndex;
|
||||
|
|
@ -1418,7 +1419,7 @@ bool Bot::updateNavigation () {
|
|||
const int taskTarget = getTask ()->data;
|
||||
|
||||
if (game.mapIs (MapFlags::Demolition)
|
||||
&& bots.isBombPlanted ()
|
||||
&& gameState.isBombPlanted ()
|
||||
&& m_team == Team::CT
|
||||
&& getCurrentTaskId () != Task::EscapeFromBomb
|
||||
&& taskTarget != kInvalidNodeIndex) {
|
||||
|
|
@ -1481,7 +1482,7 @@ bool Bot::updateLiftHandling () {
|
|||
game.testLine (pev->origin, m_pathOrigin, TraceIgnore::Everything, ent (), &tr);
|
||||
|
||||
if (tr.flFraction < 1.0f
|
||||
&& util.isDoorEntity (tr.pHit)
|
||||
&& game.isDoorEntity (tr.pHit)
|
||||
&& (m_liftState == LiftState::None || m_liftState == LiftState::WaitingFor || m_liftState == LiftState::LookingButtonOutside)
|
||||
&& pev->groundentity != tr.pHit) {
|
||||
|
||||
|
|
@ -2117,7 +2118,7 @@ int Bot::findBombNode () {
|
|||
|
||||
const auto &goals = graph.m_goalPoints;
|
||||
|
||||
const auto &bomb = graph.getBombOrigin ();
|
||||
const auto &bomb = gameState.getBombOrigin ();
|
||||
const auto &audible = isBombAudible ();
|
||||
|
||||
// take the nearest to bomb nodes instead of goal if close enough
|
||||
|
|
@ -2535,9 +2536,9 @@ bool Bot::advanceMovement () {
|
|||
|
||||
// only if we in normal task and bomb is not planted
|
||||
if (tid == Task::Normal
|
||||
&& bots.getRoundMidTime () + 5.0f < game.time ()
|
||||
&& gameState.getRoundMidTime () + 5.0f < game.time ()
|
||||
&& m_timeCamping + 5.0f < game.time ()
|
||||
&& !bots.isBombPlanted ()
|
||||
&& !gameState.isBombPlanted ()
|
||||
&& m_personality != Personality::Rusher
|
||||
&& !m_hasC4 && !m_isVIP
|
||||
&& m_loosedBombNodeIndex == kInvalidNodeIndex
|
||||
|
|
@ -2549,7 +2550,7 @@ bool Bot::advanceMovement () {
|
|||
auto kills = static_cast <float> (practice.getDamage (m_team, nextIndex, nextIndex));
|
||||
|
||||
// if damage done higher than one
|
||||
if (kills > 1.0f && bots.getRoundMidTime () > game.time ()) {
|
||||
if (kills > 1.0f && gameState.getRoundMidTime () > game.time ()) {
|
||||
switch (m_personality) {
|
||||
case Personality::Normal:
|
||||
kills *= 0.33f;
|
||||
|
|
@ -2647,7 +2648,7 @@ bool Bot::advanceMovement () {
|
|||
|
||||
// mark as jump sequence, if the current and next paths are jumps
|
||||
if (isCurrentJump) {
|
||||
m_jumpSequence = willJump;
|
||||
m_jumpSequence = willJump && jumpDistanceSq > cr::sqrf (96.0f);
|
||||
}
|
||||
|
||||
// is there a jump node right ahead and do we need to draw out the light weapon ?
|
||||
|
|
@ -2752,11 +2753,11 @@ bool Bot::isBlockedForward (const Vector &normal, TraceResult *tr) {
|
|||
if (!game.mapIs (MapFlags::HasDoors)) {
|
||||
return false;
|
||||
}
|
||||
return result->flFraction < 1.0f && !util.isDoorEntity (result->pHit);
|
||||
return result->flFraction < 1.0f && !game.isDoorEntity (result->pHit);
|
||||
};
|
||||
|
||||
auto checkHostage = [&] (TraceResult *result) {
|
||||
return result->flFraction < 1.0f && m_team == Team::Terrorist && !util.isHostageEntity (result->pHit);
|
||||
return result->flFraction < 1.0f && m_team == Team::Terrorist && !game.isHostageEntity (result->pHit);
|
||||
};
|
||||
|
||||
// trace from the bot's eyes straight forward...
|
||||
|
|
@ -2764,8 +2765,8 @@ bool Bot::isBlockedForward (const Vector &normal, TraceResult *tr) {
|
|||
|
||||
// check if the trace hit something...
|
||||
if (tr->flFraction < 1.0f) {
|
||||
if ((game.mapIs (MapFlags::HasDoors) && util.isDoorEntity (tr->pHit))
|
||||
|| (m_team == Team::CT && util.isHostageEntity (tr->pHit))) {
|
||||
if ((game.mapIs (MapFlags::HasDoors) && game.isDoorEntity (tr->pHit))
|
||||
|| (m_team == Team::CT && game.isHostageEntity (tr->pHit))) {
|
||||
return false;
|
||||
}
|
||||
return true; // bot's head will hit something
|
||||
|
|
@ -3120,7 +3121,7 @@ bool Bot::isBlockedLeft () {
|
|||
game.testLine (pev->origin, pev->origin - forward * direction - right * 48.0f, TraceIgnore::Monsters, ent (), &tr);
|
||||
|
||||
// check if the trace hit something...
|
||||
if (game.mapIs (MapFlags::HasDoors) && tr.flFraction < 1.0f && !util.isDoorEntity (tr.pHit)) {
|
||||
if (game.mapIs (MapFlags::HasDoors) && tr.flFraction < 1.0f && !game.isDoorEntity (tr.pHit)) {
|
||||
return true; // bot's body will hit something
|
||||
}
|
||||
return false;
|
||||
|
|
@ -3140,7 +3141,7 @@ bool Bot::isBlockedRight () {
|
|||
game.testLine (pev->origin, pev->origin + forward * direction + right * 48.0f, TraceIgnore::Monsters, ent (), &tr);
|
||||
|
||||
// check if the trace hit something...
|
||||
if (game.mapIs (MapFlags::HasDoors) && tr.flFraction < 1.0f && !util.isDoorEntity (tr.pHit)) {
|
||||
if (game.mapIs (MapFlags::HasDoors) && tr.flFraction < 1.0f && !game.isDoorEntity (tr.pHit)) {
|
||||
return true; // bot's body will hit something
|
||||
}
|
||||
return false;
|
||||
|
|
@ -3302,7 +3303,7 @@ int Bot::getNearestToPlantedBomb () {
|
|||
|
||||
// search the bomb on the map
|
||||
game.searchEntities ("classname", "grenade", [&] (edict_t *ent) {
|
||||
if (util.isModel (ent, bombModel)) {
|
||||
if (game.isEntityModelMatches (ent, bombModel)) {
|
||||
result = graph.getNearest (game.getEntityOrigin (ent));
|
||||
|
||||
if (graph.exists (result)) {
|
||||
|
|
|
|||
|
|
@ -17,12 +17,12 @@ float PlannerHeuristic::gfunctionKillsDist (int team, int currentIndex, int pare
|
|||
if (parentIndex == kInvalidNodeIndex) {
|
||||
return 0.0f;
|
||||
}
|
||||
auto cost = practice.plannerGetDamage (team, currentIndex, currentIndex, true);
|
||||
auto cost = practice.getDamageEx (team, currentIndex, currentIndex, true);
|
||||
const auto ¤t = graph[currentIndex];
|
||||
|
||||
for (const auto &neighbour : current.links) {
|
||||
if (neighbour.index != kInvalidNodeIndex) {
|
||||
cost += practice.plannerGetDamage (team, neighbour.index, neighbour.index, false);
|
||||
cost += practice.getDamageEx (team, neighbour.index, neighbour.index, false);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -45,12 +45,12 @@ float PlannerHeuristic::gfunctionKillsDistCTWithHostage (int team, int currentIn
|
|||
}
|
||||
|
||||
float PlannerHeuristic::gfunctionKills (int team, int currentIndex, int) {
|
||||
auto cost = practice.plannerGetDamage (team, currentIndex, currentIndex, false);
|
||||
auto cost = practice.getDamageEx (team, currentIndex, currentIndex, false);
|
||||
const auto ¤t = graph[currentIndex];
|
||||
|
||||
for (const auto &neighbour : current.links) {
|
||||
if (neighbour.index != kInvalidNodeIndex) {
|
||||
cost += practice.plannerGetDamage (team, neighbour.index, neighbour.index, false);
|
||||
cost += practice.getDamageEx (team, neighbour.index, neighbour.index, false);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -264,7 +264,7 @@ AStarResult AStarAlgo::find (int botTeam, int srcIndex, int destIndex, NodeAdder
|
|||
auto rsRandomizer = 1.0f;
|
||||
|
||||
// randomize path on round start now and then
|
||||
if (cv_path_randomize_on_round_start && bots.getRoundStartTime () + 2.0f > game.time ()) {
|
||||
if (cv_path_randomize_on_round_start && gameState.getRoundStartTime () + 2.0f > game.time ()) {
|
||||
rsRandomizer = rg (0.5f, static_cast <float> (botTeam) * 2.0f);
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -64,7 +64,7 @@ void BotPractice::setDamage (int32_t team, int32_t start, int32_t goal, int32_t
|
|||
m_data[{start, goal, team}].damage = static_cast <int16_t> (value);
|
||||
}
|
||||
|
||||
float BotPractice::plannerGetDamage (int32_t team, int32_t start, int32_t goal, bool addTeamHighestDamage) {
|
||||
float BotPractice::getDamageEx (int32_t team, int32_t start, int32_t goal, bool addTeamHighestDamage) {
|
||||
if (!m_damageUpdateLock.tryLock ()) {
|
||||
return 0.0f;
|
||||
}
|
||||
|
|
|
|||
238
src/support.cpp
238
src/support.cpp
|
|
@ -9,7 +9,6 @@
|
|||
|
||||
ConVar cv_display_welcome_text ("display_welcome_text", "1", "Enables or disables showing a welcome message to the host entity on game start.");
|
||||
ConVar cv_enable_query_hook ("enable_query_hook", "0", "Enables or disables fake server query responses, which show bots as real players in the server browser.");
|
||||
ConVar cv_breakable_health_limit ("breakable_health_limit", "500.0", "Specifies the maximum health of a breakable object that the bot will consider destroying.", true, 1.0f, 3000.0);
|
||||
ConVar cv_enable_fake_steamids ("enable_fake_steamids", "0", "Allows or disallows bots to return a fake Steam ID.");
|
||||
|
||||
BotSupport::BotSupport () {
|
||||
|
|
@ -82,13 +81,6 @@ BotSupport::BotSupport () {
|
|||
m_clients.resize (kGameMaxPlayers + 1);
|
||||
}
|
||||
|
||||
bool BotSupport::isAlive (edict_t *ent) {
|
||||
if (game.isNullEntity (ent)) {
|
||||
return false;
|
||||
}
|
||||
return ent->v.deadflag == DEAD_NO && ent->v.health > 0.0f && ent->v.movetype != MOVETYPE_NOCLIP;
|
||||
}
|
||||
|
||||
bool BotSupport::isVisible (const Vector &origin, edict_t *ent) {
|
||||
if (game.isNullEntity (ent)) {
|
||||
return false;
|
||||
|
|
@ -151,109 +143,6 @@ void BotSupport::decalTrace (TraceResult *trace, int decalIndex) {
|
|||
msg.end ();
|
||||
}
|
||||
|
||||
bool BotSupport::isPlayer (edict_t *ent) {
|
||||
if (game.isNullEntity (ent)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
if (ent->v.flags & FL_PROXY) {
|
||||
return false;
|
||||
}
|
||||
|
||||
if ((ent->v.flags & (FL_CLIENT | FL_FAKECLIENT)) || bots[ent] != nullptr) {
|
||||
return !strings.isEmpty (ent->v.netname.chars ());
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
bool BotSupport::isMonster (edict_t *ent) {
|
||||
if (game.isNullEntity (ent)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
if (~ent->v.flags & FL_MONSTER) {
|
||||
return false;
|
||||
}
|
||||
|
||||
if (isHostageEntity (ent)) {
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
bool BotSupport::isItem (edict_t *ent) {
|
||||
return ent && ent->v.classname.str ().contains ("item_");
|
||||
}
|
||||
|
||||
bool BotSupport::isPlayerVIP (edict_t *ent) {
|
||||
if (!game.mapIs (MapFlags::Assassination)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
if (!isPlayer (ent)) {
|
||||
return false;
|
||||
}
|
||||
return *(engfuncs.pfnInfoKeyValue (engfuncs.pfnGetInfoKeyBuffer (ent), "model")) == 'v';
|
||||
}
|
||||
|
||||
bool BotSupport::isDoorEntity (edict_t *ent) {
|
||||
if (game.isNullEntity (ent)) {
|
||||
return false;
|
||||
}
|
||||
const auto classHash = ent->v.classname.str ().hash ();
|
||||
|
||||
constexpr auto kFuncDoor = StringRef::fnv1a32 ("func_door");
|
||||
constexpr auto kFuncDoorRotating = StringRef::fnv1a32 ("func_door_rotating");
|
||||
|
||||
return classHash == kFuncDoor || classHash == kFuncDoorRotating;
|
||||
}
|
||||
|
||||
bool BotSupport::isHostageEntity (edict_t *ent) {
|
||||
if (game.isNullEntity (ent)) {
|
||||
return false;
|
||||
}
|
||||
const auto classHash = ent->v.classname.str ().hash ();
|
||||
|
||||
constexpr auto kHostageEntity = StringRef::fnv1a32 ("hostage_entity");
|
||||
constexpr auto kMonsterScientist = StringRef::fnv1a32 ("monster_scientist");
|
||||
|
||||
return classHash == kHostageEntity || classHash == kMonsterScientist;
|
||||
}
|
||||
|
||||
bool BotSupport::isBreakableEntity (edict_t *ent, bool initialSeed) {
|
||||
if (!initialSeed) {
|
||||
if (!game.hasBreakables ()) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
if (game.isNullEntity (ent) || ent == game.getStartEntity () || (!initialSeed && !game.isBreakableValid (ent))) {
|
||||
return false;
|
||||
}
|
||||
const auto limit = cv_breakable_health_limit.as <float> ();
|
||||
|
||||
// not shoot-able
|
||||
if (ent->v.health >= limit) {
|
||||
return false;
|
||||
}
|
||||
constexpr auto kFuncBreakable = StringRef::fnv1a32 ("func_breakable");
|
||||
constexpr auto kFuncPushable = StringRef::fnv1a32 ("func_pushable");
|
||||
constexpr auto kFuncWall = StringRef::fnv1a32 ("func_wall");
|
||||
|
||||
if (ent->v.takedamage > 0.0f && ent->v.impulse <= 0 && !(ent->v.flags & FL_WORLDBRUSH) && !(ent->v.spawnflags & SF_BREAK_TRIGGER_ONLY)) {
|
||||
const auto classHash = ent->v.classname.str ().hash ();
|
||||
|
||||
if (classHash == kFuncBreakable || (classHash == kFuncPushable && (ent->v.spawnflags & SF_PUSH_BREAKABLE)) || classHash == kFuncWall) {
|
||||
return ent->v.movetype == MOVETYPE_PUSH || ent->v.movetype == MOVETYPE_PUSHSTEP;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
bool BotSupport::isFakeClient (edict_t *ent) {
|
||||
return bots[ent] != nullptr || (!game.isNullEntity (ent) && (ent->v.flags & FL_FAKECLIENT));
|
||||
}
|
||||
|
||||
void BotSupport::checkWelcome () {
|
||||
// the purpose of this function, is to send quick welcome message, to the listenserver entity.
|
||||
|
||||
|
|
@ -264,7 +153,7 @@ void BotSupport::checkWelcome () {
|
|||
const bool needToSendMsg = (graph.length () > 0 ? m_needToSendWelcome : true);
|
||||
auto receiveEnt = game.getLocalEntity ();
|
||||
|
||||
if (isAlive (receiveEnt) && m_welcomeReceiveTime < 1.0f && needToSendMsg) {
|
||||
if (game.isAliveEntity (receiveEnt) && m_welcomeReceiveTime < 1.0f && needToSendMsg) {
|
||||
m_welcomeReceiveTime = game.time () + 2.0f + mp_freezetime.as <float> (); // receive welcome message in four seconds after game has commencing
|
||||
}
|
||||
|
||||
|
|
@ -344,7 +233,7 @@ bool BotSupport::findNearestPlayer (void **pvHolder, edict_t *to, float searchDi
|
|||
continue;
|
||||
}
|
||||
|
||||
if ((sameTeam && client.team != game.getTeam (to))
|
||||
if ((sameTeam && client.team != game.getPlayerTeam (to))
|
||||
|| (needAlive && !(client.flags & ClientFlags::Alive))
|
||||
|| (needBot && !bots[client.ent])
|
||||
|| (needDrawn && (client.ent->v.effects & EF_NODRAW))
|
||||
|
|
@ -373,7 +262,7 @@ void BotSupport::updateClients () {
|
|||
client.ent = player;
|
||||
client.flags |= ClientFlags::Used;
|
||||
|
||||
if (isAlive (player)) {
|
||||
if (game.isAliveEntity (player)) {
|
||||
client.flags |= ClientFlags::Alive;
|
||||
}
|
||||
else {
|
||||
|
|
@ -392,10 +281,6 @@ void BotSupport::updateClients () {
|
|||
}
|
||||
}
|
||||
|
||||
bool BotSupport::isModel (const edict_t *ent, StringRef model) {
|
||||
return model.startsWith (ent->v.model.chars (9));
|
||||
}
|
||||
|
||||
String BotSupport::getCurrentDateTime () {
|
||||
time_t ticks = time (&ticks);
|
||||
tm timeinfo {};
|
||||
|
|
@ -409,7 +294,7 @@ String BotSupport::getCurrentDateTime () {
|
|||
}
|
||||
|
||||
StringRef BotSupport::getFakeSteamId (edict_t *ent) {
|
||||
if (!cv_enable_fake_steamids || !isPlayer (ent)) {
|
||||
if (!cv_enable_fake_steamids || !game.isPlayerEntity (ent)) {
|
||||
return "BOT";
|
||||
}
|
||||
auto botNameHash = StringRef::fnv1a32 (ent->v.netname.chars ());
|
||||
|
|
@ -479,3 +364,118 @@ void BotSupport::setCustomCvarDescriptions () {
|
|||
});
|
||||
game.setCvarDescription (cv_restricted_weapons, restrictInfo);
|
||||
}
|
||||
|
||||
bool BotSupport::isLineBlockedBySmoke (const Vector &from, const Vector &to) {
|
||||
if (!gameState.hasActiveGrenades ()) {
|
||||
return false;
|
||||
}
|
||||
constexpr auto kSmokeGrenadeRadius = 115.0f;
|
||||
|
||||
// distance along line of sight covered by smoke
|
||||
float totalSmokedLength = 0.0f;
|
||||
|
||||
Vector sightDir = to - from;
|
||||
const float sightLength = sightDir.normalizeInPlace ();
|
||||
|
||||
for (auto pent : gameState.getActiveGrenades ()) {
|
||||
if (game.isNullEntity (pent)) {
|
||||
continue;
|
||||
}
|
||||
|
||||
// need drawn models
|
||||
if (pent->v.effects & EF_NODRAW) {
|
||||
continue;
|
||||
}
|
||||
|
||||
// smoke must be on a ground
|
||||
if (!(pent->v.flags & FL_ONGROUND)) {
|
||||
continue;
|
||||
}
|
||||
|
||||
// must be a smoke grenade
|
||||
if (!game.isEntityModelMatches (pent, kSmokeModelName)) {
|
||||
continue;
|
||||
}
|
||||
|
||||
const float smokeRadiusSq = cr::sqrf (kSmokeGrenadeRadius);
|
||||
const Vector &smokeOrigin = game.getEntityOrigin (pent);
|
||||
|
||||
Vector toGrenade = smokeOrigin - from;
|
||||
float alongDist = toGrenade | sightDir;
|
||||
|
||||
// compute closest point to grenade along line of sight ray
|
||||
Vector close {};
|
||||
|
||||
// constrain closest point to line segment
|
||||
if (alongDist < 0.0f) {
|
||||
close = from;
|
||||
}
|
||||
else if (alongDist >= sightLength) {
|
||||
close = to;
|
||||
}
|
||||
else {
|
||||
close = from + sightDir * alongDist;
|
||||
}
|
||||
|
||||
// if closest point is within smoke radius, the line overlaps the smoke cloud
|
||||
Vector toClose = close - smokeOrigin;
|
||||
float lengthSq = toClose.lengthSq ();
|
||||
|
||||
if (lengthSq < smokeRadiusSq) {
|
||||
// some portion of the ray intersects the cloud
|
||||
|
||||
const float fromSq = toGrenade.lengthSq ();
|
||||
const float toSq = (smokeOrigin - to).lengthSq ();
|
||||
|
||||
if (fromSq < smokeRadiusSq) {
|
||||
if (toSq < smokeRadiusSq) {
|
||||
// both 'from' and 'to' lie within the cloud
|
||||
// entire length is smoked
|
||||
totalSmokedLength += (to - from).length ();
|
||||
}
|
||||
else {
|
||||
// 'from' is inside the cloud, 'to' is outside
|
||||
// compute half of total smoked length as if ray crosses entire cloud chord
|
||||
float halfSmokedLength = cr::sqrtf (smokeRadiusSq - lengthSq);
|
||||
|
||||
if (alongDist > 0.0f) {
|
||||
// ray goes thru 'close'
|
||||
totalSmokedLength += halfSmokedLength + (close - from).length ();
|
||||
}
|
||||
else {
|
||||
// ray starts after 'close'
|
||||
totalSmokedLength += halfSmokedLength - (close - from).length ();
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
else if (toSq < smokeRadiusSq) {
|
||||
// 'from' is outside the cloud, 'to' is inside
|
||||
// compute half of total smoked length as if ray crosses entire cloud chord
|
||||
const float halfSmokedLength = cr::sqrtf (smokeRadiusSq - lengthSq);
|
||||
Vector v = to - smokeOrigin;
|
||||
|
||||
if ((v | sightDir) > 0.0f) {
|
||||
// ray goes thru 'close'
|
||||
totalSmokedLength += halfSmokedLength + (close - to).length ();
|
||||
}
|
||||
else {
|
||||
// ray ends before 'close'
|
||||
totalSmokedLength += halfSmokedLength - (close - to).length ();
|
||||
}
|
||||
}
|
||||
else {
|
||||
// 'from' and 'to' lie outside of the cloud - the line of sight completely crosses it
|
||||
// determine the length of the chord that crosses the cloud
|
||||
const float smokedLength = 2.0f * cr::sqrtf (smokeRadiusSq - lengthSq);
|
||||
totalSmokedLength += smokedLength;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// define how much smoke a bot can see thru
|
||||
const float maxSmokedLength = 0.7f * kSmokeGrenadeRadius;
|
||||
|
||||
// return true if the total length of smoke-covered line-of-sight is too much
|
||||
return totalSmokedLength > maxSmokedLength;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -28,12 +28,18 @@ void Bot::normal_ () {
|
|||
getTask ()->data = debugGoal;
|
||||
m_chosenGoalIndex = debugGoal;
|
||||
}
|
||||
const auto &debugOrigin = graph[debugGoal].origin;
|
||||
const auto distanceToDebugOriginSq = debugOrigin.distanceSq (pev->origin);
|
||||
|
||||
if (!isDucking () && distanceToDebugOriginSq < cr::sqrf (172.0f)) {
|
||||
m_moveSpeed = pev->maxspeed * 0.4f;
|
||||
}
|
||||
|
||||
// stop the bot if precisely reached debug goal
|
||||
if (m_currentNodeIndex == debugGoal) {
|
||||
const auto &debugOrigin = graph[debugGoal].origin;
|
||||
if (distanceToDebugOriginSq < cr::sqrf (22.0f)
|
||||
&& util.isVisible (debugOrigin, ent ())) {
|
||||
|
||||
if (debugOrigin.distanceSq2d (pev->origin) < cr::sqrf (22.0f) && util.isVisible (debugOrigin, ent ())) {
|
||||
m_moveToGoal = false;
|
||||
m_checkTerrain = false;
|
||||
|
||||
|
|
@ -48,7 +54,7 @@ void Bot::normal_ () {
|
|||
// bots rushing with knife, when have no enemy (thanks for idea to nicebot project)
|
||||
if (cv_random_knife_attacks
|
||||
&& usesKnife ()
|
||||
&& (game.isNullEntity (m_lastEnemy) || !util.isAlive (m_lastEnemy))
|
||||
&& (game.isNullEntity (m_lastEnemy) || !game.isAliveEntity (m_lastEnemy))
|
||||
&& game.isNullEntity (m_enemy)
|
||||
&& m_knifeAttackTime < game.time ()
|
||||
&& !m_hasHostage
|
||||
|
|
@ -71,7 +77,7 @@ void Bot::normal_ () {
|
|||
|
||||
// if bomb planted and it's a CT calculate new path to bomb point if he's not already heading for
|
||||
if (!m_bombSearchOverridden
|
||||
&& bots.isBombPlanted ()
|
||||
&& gameState.isBombPlanted ()
|
||||
&& m_team == Team::CT
|
||||
&& getTask ()->data != kInvalidNodeIndex
|
||||
&& !(graph[getTask ()->data].flags & NodeFlag::Goal)
|
||||
|
|
@ -84,7 +90,7 @@ void Bot::normal_ () {
|
|||
// reached the destination (goal) node?
|
||||
if (updateNavigation ()) {
|
||||
// if we're reached the goal, and there is not enemies, notify the team
|
||||
if (!bots.isBombPlanted ()
|
||||
if (!gameState.isBombPlanted ()
|
||||
&& m_currentNodeIndex != kInvalidNodeIndex
|
||||
&& (m_pathFlags & NodeFlag::Goal)
|
||||
&& rg.chance (15)
|
||||
|
|
@ -106,7 +112,7 @@ void Bot::normal_ () {
|
|||
&& m_moveSpeed >= getShiftSpeed ()
|
||||
&& game.isNullEntity (m_pickupItem)) {
|
||||
|
||||
if (!(game.mapIs (MapFlags::Demolition) && bots.isBombPlanted () && m_team == Team::CT)) {
|
||||
if (!(game.mapIs (MapFlags::Demolition) && gameState.isBombPlanted () && m_team == Team::CT)) {
|
||||
startTask (Task::Spraypaint, TaskPri::Spraypaint, kInvalidNodeIndex, game.time () + 1.0f, false);
|
||||
}
|
||||
}
|
||||
|
|
@ -134,7 +140,7 @@ void Bot::normal_ () {
|
|||
}
|
||||
|
||||
// don't allow vip on as_ maps to camp + don't allow terrorist carrying c4 to camp
|
||||
if (m_isVIP || (game.mapIs (MapFlags::Demolition) && m_team == Team::Terrorist && !bots.isBombPlanted () && m_hasC4)) {
|
||||
if (m_isVIP || (game.mapIs (MapFlags::Demolition) && m_team == Team::Terrorist && !gameState.isBombPlanted () && m_hasC4)) {
|
||||
campingAllowed = false;
|
||||
}
|
||||
|
||||
|
|
@ -218,7 +224,7 @@ void Bot::normal_ () {
|
|||
}
|
||||
}
|
||||
else if (m_team == Team::CT) {
|
||||
if (!bots.isBombPlanted () && numFriendsNear (pev->origin, 210.0f) < 4) {
|
||||
if (!gameState.isBombPlanted () && numFriendsNear (pev->origin, 210.0f) < 4) {
|
||||
const int index = findDefendNode (m_path->origin);
|
||||
float campTime = rg (25.0f, 40.0f);
|
||||
|
||||
|
|
@ -258,7 +264,7 @@ void Bot::normal_ () {
|
|||
auto pathSearchType = m_pathType;
|
||||
|
||||
// override with fast path
|
||||
if (game.mapIs (MapFlags::Demolition) && bots.isBombPlanted ()) {
|
||||
if (game.mapIs (MapFlags::Demolition) && gameState.isBombPlanted ()) {
|
||||
pathSearchType = rg.chance (80) ? FindPath::Fast : FindPath::Optimal;
|
||||
}
|
||||
ensureCurrentNodeIndex ();
|
||||
|
|
@ -280,7 +286,7 @@ void Bot::normal_ () {
|
|||
&& (m_heardSoundTime + 6.0f >= game.time () || (m_states & Sense::HearingEnemy))
|
||||
&& numEnemiesNear (pev->origin, 768.0f) >= 1
|
||||
&& !isKnifeMode ()
|
||||
&& !bots.isBombPlanted ()) {
|
||||
&& !gameState.isBombPlanted ()) {
|
||||
|
||||
m_moveSpeed = shiftSpeed;
|
||||
}
|
||||
|
|
@ -288,7 +294,7 @@ void Bot::normal_ () {
|
|||
// bot hasn't seen anything in a long time and is asking his teammates to report in
|
||||
if (cv_radio_mode.as <int> () > 1
|
||||
&& bots.getLastRadio (m_team) != Radio::ReportInTeam
|
||||
&& bots.getRoundStartTime () + 20.0f < game.time ()
|
||||
&& gameState.getRoundStartTime () + 20.0f < game.time ()
|
||||
&& m_askCheckTime < game.time () && rg.chance (15)
|
||||
&& m_seeEnemyTime + rg (45.0f, 80.0f) < game.time ()
|
||||
&& numFriendsNear (pev->origin, 1024.0f) == 0) {
|
||||
|
|
@ -357,7 +363,7 @@ void Bot::huntEnemy_ () {
|
|||
clearTask (Task::Hunt);
|
||||
m_prevGoalIndex = kInvalidNodeIndex;
|
||||
}
|
||||
else if (game.getTeam (m_lastEnemy) == m_team) {
|
||||
else if (game.getPlayerTeam (m_lastEnemy) == m_team) {
|
||||
|
||||
// don't hunt down our teammate...
|
||||
clearTask (Task::Hunt);
|
||||
|
|
@ -413,7 +419,7 @@ void Bot::huntEnemy_ () {
|
|||
void Bot::seekCover_ () {
|
||||
m_aimFlags |= AimFlags::Nav;
|
||||
|
||||
if (!util.isAlive (m_lastEnemy)) {
|
||||
if (!game.isAliveEntity (m_lastEnemy)) {
|
||||
completeTask ();
|
||||
m_prevGoalIndex = kInvalidNodeIndex;
|
||||
}
|
||||
|
|
@ -565,7 +571,7 @@ void Bot::blind_ () {
|
|||
if (rg.chance (50)
|
||||
&& m_difficulty >= Difficulty::Normal
|
||||
&& !m_lastEnemyOrigin.empty ()
|
||||
&& util.isPlayer (m_lastEnemy)
|
||||
&& game.isPlayerEntity (m_lastEnemy)
|
||||
&& !usesSniper ()) {
|
||||
|
||||
auto error = kSprayDistance * m_lastEnemyOrigin.distance (pev->origin) / 2048.0f;
|
||||
|
|
@ -624,7 +630,7 @@ void Bot::camp_ () {
|
|||
m_checkTerrain = false;
|
||||
m_moveToGoal = false;
|
||||
|
||||
if (m_team == Team::CT && bots.isBombPlanted () && m_defendedBomb && !isBombDefusing (graph.getBombOrigin ()) && !isOutOfBombTimer ()) {
|
||||
if (m_team == Team::CT && gameState.isBombPlanted () && m_defendedBomb && !isBombDefusing (gameState.getBombOrigin ()) && !isOutOfBombTimer ()) {
|
||||
m_defendedBomb = false;
|
||||
completeTask ();
|
||||
}
|
||||
|
|
@ -644,7 +650,7 @@ void Bot::camp_ () {
|
|||
|
||||
// random camp dir, or prediction
|
||||
auto useRandomCampDirOrPredictEnemy = [&] () {
|
||||
if (!m_lastEnemyOrigin.empty () && util.isAlive (m_lastEnemy)) {
|
||||
if (!m_lastEnemyOrigin.empty () && game.isAliveEntity (m_lastEnemy)) {
|
||||
auto pathLength = m_lastPredictLength;
|
||||
auto predictNode = m_lastPredictIndex;
|
||||
|
||||
|
|
@ -843,7 +849,7 @@ void Bot::plantBomb_ () {
|
|||
selectWeaponById (Weapon::C4);
|
||||
}
|
||||
|
||||
if (util.isAlive (m_enemy) || !m_inBombZone) {
|
||||
if (game.isAliveEntity (m_enemy) || !m_inBombZone) {
|
||||
completeTask ();
|
||||
}
|
||||
else {
|
||||
|
|
@ -886,7 +892,7 @@ void Bot::plantBomb_ () {
|
|||
|
||||
void Bot::defuseBomb_ () {
|
||||
const float fullDefuseTime = m_hasDefuser ? 7.0f : 12.0f;
|
||||
const float timeToBlowUp = getBombTimeleft ();
|
||||
const float timeToBlowUp = gameState.getBombTimeLeft ();
|
||||
|
||||
float defuseRemainingTime = fullDefuseTime;
|
||||
|
||||
|
|
@ -894,7 +900,7 @@ void Bot::defuseBomb_ () {
|
|||
defuseRemainingTime = fullDefuseTime - game.time ();
|
||||
}
|
||||
|
||||
const auto &bombPos = graph.getBombOrigin ();
|
||||
const auto &bombPos = gameState.getBombOrigin ();
|
||||
bool defuseError = false;
|
||||
|
||||
// exception: bomb has been defused
|
||||
|
|
@ -908,7 +914,7 @@ void Bot::defuseBomb_ () {
|
|||
startTask (Task::MoveToPosition, TaskPri::MoveToPosition, defendPoint, game.time () + rg (3.0f, 6.0f), true); // push move command
|
||||
}
|
||||
}
|
||||
graph.setBombOrigin (true);
|
||||
gameState.setBombOrigin (true);
|
||||
|
||||
if (m_numFriendsLeft != 0 && rg.chance (50)) {
|
||||
if (timeToBlowUp <= 3.0f) {
|
||||
|
|
@ -1064,7 +1070,7 @@ void Bot::defuseBomb_ () {
|
|||
}
|
||||
|
||||
void Bot::followUser_ () {
|
||||
if (game.isNullEntity (m_targetEntity) || !util.isAlive (m_targetEntity)) {
|
||||
if (game.isNullEntity (m_targetEntity) || !game.isAliveEntity (m_targetEntity)) {
|
||||
m_targetEntity = nullptr;
|
||||
completeTask ();
|
||||
|
||||
|
|
@ -1075,7 +1081,7 @@ void Bot::followUser_ () {
|
|||
TraceResult tr {};
|
||||
game.testLine (m_targetEntity->v.origin + m_targetEntity->v.view_ofs, m_targetEntity->v.v_angle.forward () * 500.0f, TraceIgnore::Everything, ent (), &tr);
|
||||
|
||||
if (!game.isNullEntity (tr.pHit) && util.isPlayer (tr.pHit) && game.getTeam (tr.pHit) != m_team) {
|
||||
if (!game.isNullEntity (tr.pHit) && game.isPlayerEntity (tr.pHit) && game.getPlayerTeam (tr.pHit) != m_team) {
|
||||
m_targetEntity = nullptr;
|
||||
m_lastEnemy = tr.pHit;
|
||||
m_lastEnemyOrigin = tr.pHit->v.origin;
|
||||
|
|
@ -1325,7 +1331,7 @@ void Bot::throwSmoke_ () {
|
|||
}
|
||||
|
||||
void Bot::doublejump_ () {
|
||||
if (!util.isAlive (m_doubleJumpEntity)
|
||||
if (!game.isAliveEntity (m_doubleJumpEntity)
|
||||
|| (m_aimFlags & AimFlags::Enemy)
|
||||
|| (m_travelStartIndex != kInvalidNodeIndex
|
||||
&& getTask ()->time + (graph.calculateTravelTime (pev->maxspeed, graph[m_travelStartIndex].origin, m_doubleJumpOrigin) + 11.0f) < game.time ())) {
|
||||
|
|
@ -1399,7 +1405,7 @@ void Bot::doublejump_ () {
|
|||
void Bot::escapeFromBomb_ () {
|
||||
m_aimFlags |= AimFlags::Nav;
|
||||
|
||||
if (!bots.isBombPlanted ()) {
|
||||
if (!gameState.isBombPlanted ()) {
|
||||
completeTask ();
|
||||
}
|
||||
|
||||
|
|
@ -1407,7 +1413,7 @@ void Bot::escapeFromBomb_ () {
|
|||
pev->button |= IN_ATTACK2;
|
||||
}
|
||||
|
||||
if (!usesKnife () && game.isNullEntity (m_enemy) && !util.isAlive (m_lastEnemy)) {
|
||||
if (!usesKnife () && game.isNullEntity (m_enemy) && !game.isAliveEntity (m_lastEnemy)) {
|
||||
selectWeaponById (Weapon::Knife);
|
||||
}
|
||||
|
||||
|
|
@ -1432,7 +1438,7 @@ void Bot::escapeFromBomb_ () {
|
|||
float nearestDistanceSq = kInfiniteDistance;
|
||||
|
||||
for (const auto &path : graph) {
|
||||
if (path.origin.distanceSq (graph.getBombOrigin ()) < cr::sqrf (safeRadius) || isOccupiedNode (path.number)) {
|
||||
if (path.origin.distanceSq (gameState.getBombOrigin ()) < cr::sqrf (safeRadius) || isOccupiedNode (path.number)) {
|
||||
continue;
|
||||
}
|
||||
const float distanceSq = pev->origin.distanceSq (path.origin);
|
||||
|
|
@ -1465,7 +1471,7 @@ void Bot::escapeFromBomb_ () {
|
|||
void Bot::shootBreakable_ () {
|
||||
|
||||
// breakable destroyed?
|
||||
if (!util.isBreakableEntity (m_breakableEntity)) {
|
||||
if (!game.isBreakableEntity (m_breakableEntity)) {
|
||||
completeTask ();
|
||||
return;
|
||||
}
|
||||
|
|
@ -1647,7 +1653,7 @@ void Bot::pickupItem_ () {
|
|||
case Pickup::Hostage:
|
||||
m_aimFlags |= AimFlags::Entity;
|
||||
|
||||
if (!util.isAlive (m_pickupItem)) {
|
||||
if (!game.isAliveEntity (m_pickupItem)) {
|
||||
// don't pickup dead hostages
|
||||
m_pickupItem = nullptr;
|
||||
completeTask ();
|
||||
|
|
@ -1676,7 +1682,7 @@ void Bot::pickupItem_ () {
|
|||
|
||||
// find the nearest 'unused' hostage within the area
|
||||
game.searchEntities (pev->origin, 1024.0f, [&] (edict_t *ent) {
|
||||
if (!util.isHostageEntity (ent)) {
|
||||
if (!game.isHostageEntity (ent)) {
|
||||
return EntitySearchResult::Continue;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -445,8 +445,8 @@ void Bot::setAimDirection () {
|
|||
|
||||
&& m_forgetLastVictimTimer.elapsed ()
|
||||
&& !m_lastEnemyOrigin.empty ()
|
||||
&& util.isPlayer (m_lastEnemy)
|
||||
&& !util.isPlayer (m_enemy)) {
|
||||
&& game.isPlayerEntity (m_lastEnemy)
|
||||
&& !game.isPlayerEntity (m_enemy)) {
|
||||
|
||||
flags |= AimFlags::LastEnemy;
|
||||
}
|
||||
|
|
@ -503,7 +503,7 @@ void Bot::setAimDirection () {
|
|||
else if (flags & AimFlags::PredictPath) {
|
||||
bool changePredictedEnemy = true;
|
||||
|
||||
if (m_timeNextTracking < game.time () && m_trackingEdict == m_lastEnemy && util.isAlive (m_lastEnemy)) {
|
||||
if (m_timeNextTracking < game.time () && m_trackingEdict == m_lastEnemy && game.isAliveEntity (m_lastEnemy)) {
|
||||
changePredictedEnemy = false;
|
||||
}
|
||||
|
||||
|
|
@ -573,7 +573,9 @@ void Bot::setAimDirection () {
|
|||
const auto &destOrigin = m_destOrigin + pev->view_ofs;
|
||||
m_lookAt = destOrigin;
|
||||
|
||||
if (m_moveToGoal && m_seeEnemyTime + 4.0f < game.time ()
|
||||
const bool horizontalMovement = (m_pathFlags & NodeFlag::Ladder) || isOnLadder ();
|
||||
|
||||
if (!horizontalMovement && m_moveToGoal && m_seeEnemyTime + 4.0f < game.time ()
|
||||
&& !m_isStuck && !(pev->button & IN_DUCK)
|
||||
&& m_currentNodeIndex != kInvalidNodeIndex
|
||||
&& !(m_pathFlags & (NodeFlag::Ladder | NodeFlag::Crouch))
|
||||
|
|
@ -598,7 +600,6 @@ void Bot::setAimDirection () {
|
|||
else {
|
||||
m_lookAt = destOrigin;
|
||||
}
|
||||
const bool horizontalMovement = (m_pathFlags & NodeFlag::Ladder) || isOnLadder ();
|
||||
|
||||
if (m_numEnemiesLeft > 0
|
||||
&& m_canChooseAimDirection
|
||||
|
|
@ -625,14 +626,17 @@ void Bot::setAimDirection () {
|
|||
}
|
||||
|
||||
// try look at next node if on ladder
|
||||
if (horizontalMovement && m_pathWalk.hasNext ()) {
|
||||
if (horizontalMovement
|
||||
&& m_pathWalk.hasNext ()
|
||||
&& !(m_currentTravelFlags & PathFlag::Jump)) {
|
||||
|
||||
const auto &nextPath = graph[m_pathWalk.next ()];
|
||||
|
||||
if ((nextPath.flags & NodeFlag::Ladder)
|
||||
&& m_destOrigin.distanceSq (pev->origin) < cr::sqrf (128.0f)
|
||||
&& nextPath.origin.z > m_pathOrigin.z + 26.0f) {
|
||||
&& m_destOrigin.distanceSq (pev->origin) < cr::sqrf (64.0f)
|
||||
&& nextPath.origin.z > m_pathOrigin.z + 30.0f) {
|
||||
|
||||
m_lookAt = nextPath.origin + pev->view_ofs;
|
||||
m_lookAt = nextPath.origin;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -125,7 +125,9 @@ void GraphVistable::rebuild () {
|
|||
m_sliceIndex += rg (250, 400);
|
||||
}
|
||||
auto notifyProgress = [] (int value) {
|
||||
game.print ("Rebuilding vistable... %d%% done.", value);
|
||||
if (value >= 100 || cv_debug) {
|
||||
game.print ("Rebuilding vistable... %d%% done.", value);
|
||||
}
|
||||
};
|
||||
|
||||
// notify host about rebuilding
|
||||
|
|
@ -139,6 +141,7 @@ void GraphVistable::rebuild () {
|
|||
|
||||
m_rebuild = false;
|
||||
m_notifyMsgTimestamp = 0.0f;
|
||||
m_curIndex = 0;
|
||||
|
||||
save ();
|
||||
}
|
||||
|
|
@ -149,7 +152,7 @@ void GraphVistable::startRebuild () {
|
|||
m_notifyMsgTimestamp = game.time ();
|
||||
}
|
||||
|
||||
bool GraphVistable::visible (int srcIndex, int destIndex, VisIndex vis) {
|
||||
bool GraphVistable::visible (int srcIndex, int destIndex, VisIndex vis) const {
|
||||
if (!graph.exists (srcIndex) || !graph.exists (destIndex)) {
|
||||
return false;
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue