ryzom/server/src/ai_service/ai_aggro.cpp

   1 // Ryzom - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
   2 // Copyright (C) 2010  Winch Gate Property Limited
   3 //
   4 // This program is free software: you can redistribute it and/or modify
   5 // it under the terms of the GNU Affero General Public License as
   6 // published by the Free Software Foundation, either version 3 of the
   7 // License, or (at your option) any later version.
   8 //
   9 // This program is distributed in the hope that it will be useful,
  10 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 // GNU Affero General Public License for more details.
  13 //
  14 // You should have received a copy of the GNU Affero General Public License
  15 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
  16
  17
  18 #include "stdpch.h"
  19 #include "ai_aggro.h"
  20 #include "ai_entity_physical.h"
  21 #include "ai_entity_physical_inline.h"
  22 #include "ai_instance.h"
  23 #include "ai_player.h"
  24
  25 //////////////////////////////////////////////////////////////////////////////
  26 // CBotAggroEntry                                                           //
  27 //////////////////////////////////////////////////////////////////////////////
  28
  29 CBotAggroEntry::CBotAggroEntry(TDataSetRow const& bot, float aggro, CBotAggroOwner const& owner, NLMISC::CSmartPtr<CAIPlace const> place)
  30 : _Bot(bot)
  31 , _Owner(owner)
  32 , _LastHitPlace(place)
  33 {
  34 #ifdef NL_DEBUG
  35         nlassert(aggro>=0.f);
  36 #endif
  37         _Aggro = aggro;
  38         _Owner.aggroGain(_Bot);
  39 }
  40
  41 CBotAggroEntry::~CBotAggroEntry()
  42 {
  43         if(_Owner.getSendAggroLostToEGS())
  44                 _Owner.aggroLost(_Bot);
  45 }
  46
  47 void CBotAggroEntry::operator =(CBotAggroEntry const& other)
  48 {
  49 #ifdef NL_DEBUG
  50         nlassert(&_Owner==&other._Owner); // same owner ?
  51 #endif
  52         _Bot = other._Bot;
  53         _Aggro = other._Aggro;
  54 }
  55
  56 void CBotAggroEntry::addAggro(float aggro, NLMISC::CSmartPtr<CAIPlace const> place)
  57 {
  58         // prevent to add aggro on a bot more than one time per tick.
  59         _Aggro += (1.f-_Aggro)*(aggro);
  60         if (place!=NULL)
  61                 _LastHitPlace = place;
  62 }
  63
  64 bool CBotAggroEntry::updateTime(uint32 const& ticks) const
  65 {
  66         const_cast<CBotAggroEntry*>(this)->decrementAggros(ticks);
  67         return _Aggro==0.f;
  68 }
  69
  70 void CBotAggroEntry::setMinimum(float aggro, NLMISC::CSmartPtr<CAIPlace const> place)
  71 {
  72         if (aggro>=0.f && aggro<=1.f && _Aggro<aggro)
  73         {
  74                 _Aggro = aggro;
  75                 if (place)
  76                         _LastHitPlace = place;
  77         }
  78 }
  79
  80 void CBotAggroEntry::setMaximum(float aggro)
  81 {
  82         if (aggro>=0.f && aggro<=1.f && _Aggro>aggro)
  83         {
  84                 _Aggro = aggro;
  85         }
  86 }
  87
  88 void CBotAggroEntry::decrementAggros(uint32 ticks)
  89 {
  90         static float const TOTAL_DECAY_TIME_SEC = 120.f; // temporary.
  91         static float const AGGRO_DEC = (1.f/(TOTAL_DECAY_TIME_SEC*10.f));
  92         float const decay = (float)(ticks*AGGRO_DEC);
  93
  94         if      (_Aggro>decay)
  95         {
  96                 _Aggro -= decay;
  97         }
  98         else
  99         {
 100                 _Aggro = 0.f;
 101         }
 102 }
 103
 104 //////////////////////////////////////////////////////////////////////////////
 105 // CBotAggroOwner                                                           //
 106 //////////////////////////////////////////////////////////////////////////////
 107 /*
 108 double CBotAggroOwner::defaultReturnDistCheck = 1.5;
 109 uint32 CBotAggroOwner::defaultD1Radius = 100 * 1000; // en mm
 110 uint32 CBotAggroOwner::defaultD2Radius = 50 * 1000; // en mm
 111 float CBotAggroOwner::defaultPrimaryGroupAggroCoef = 0.f; // %age, entre 0 et 1
 112 float CBotAggroOwner::defaultSecondaryGroupAggroCoef = 0.f; // %age, entre 0 et 1
 113 uint32 CBotAggroOwner::defaultAggroPropagationRadius = 60; // en m
 114 */
 115 float CBotAggroOwner::getReturnDistCheck() const
 116 {
 117         return AggroReturnDistCheck;
 118 }
 119
 120 float CBotAggroOwner::getD1Radius() const
 121 {
 122         return AggroD1Radius;
 123 }
 124
 125 float CBotAggroOwner::getD2Radius() const
 126 {
 127         return AggroD2Radius;
 128 }
 129
 130 float CBotAggroOwner::getPrimaryGroupAggroDist() const
 131 {
 132         return AggroPrimaryGroupDist;
 133 }
 134
 135 float CBotAggroOwner::getPrimaryGroupAggroCoef() const
 136 {
 137         return AggroPrimaryGroupCoef;
 138 }
 139
 140 float CBotAggroOwner::getSecondaryGroupAggroDist() const
 141 {
 142         return AggroSecondaryGroupDist;
 143 }
 144
 145 float CBotAggroOwner::getSecondaryGroupAggroCoef() const
 146 {
 147         return AggroSecondaryGroupCoef;
 148 }
 149
 150 float CBotAggroOwner::getAggroPropagationRadius() const
 151 {
 152         return AggroPropagationRadius;
 153 }
 154
 155
 156 CBotAggroOwner::CBotAggroOwner()
 157 : _LastHitTime(CTimeInterface::gameCycle())
 158 , _AggroBlocked(false)
 159 , _ReturnAggroIgnored(false)
 160 , _DontAggro(false)
 161 , _SendAggroLostToEGS(true)
 162 , _ReturnPos()
 163 , _FirstHitPlace(NULL)
 164 //, _State(NoAggro)
 165 {
 166 }
 167
 168 CBotAggroOwner::~CBotAggroOwner()
 169 {
 170 #ifdef NL_DEBUG
 171         nlassert(_BotAggroList.size()==0);      //      have to clear this vector before call destructor (coz of call back).
 172 #endif
 173 }
 174
 175 void CBotAggroOwner::mergeAggroList(CBotAggroOwner const& otherList, float scale)
 176 {
 177         H_AUTO(AGGRO_mergeAggroList);
 178         NLMISC::clamp(scale, 0.0f, 1.0f);
 179
 180         FOREACHC(it, TBotAggroList, otherList._BotAggroList)
 181         {
 182                 CBotAggroEntry* bae = it->second;
 183                 setAggroMinimumFor(bae->getBot(), bae->finalAggro()*scale, true, bae->getLastHitPlace());
 184         }
 185 }
 186
 187
 188 void CBotAggroOwner::updateListAndMarkBot(std::vector<CAIEntityPhysical*>& botList, float coef)
 189 {
 190         H_AUTO(AGGRO_ULAMB);
 191         std::list<TDataSetRow> botsToRemove;
 192         {
 193                 H_AUTO(AGGRO_ULAMB_buildList);
 194                 FOREACH(it, TBotAggroList, _BotAggroList)
 195                 {
 196                         if (!isAggroValid(it->first))
 197                         {
 198                                 botsToRemove.push_back(it->first);
 199                                 continue;
 200                         }
 201                         CAIEntityPhysical* const entity = CAIS::instance().getEntityPhysical(it->second->getBot());
 202                         nlassert(entity); // if this entry is no more valid, then isAggroValid is bugged
 203                         if (entity->_ChooseLastTime!=CTimeInterface::gameCycle())
 204                         {
 205                                 entity->_ChooseLastTime = CTimeInterface::gameCycle();
 206                                 entity->_AggroScore = it->second->finalAggro()*coef;
 207                                 botList.push_back(entity);
 208                         }
 209                         else
 210                         {
 211                                 entity->_AggroScore += it->second->finalAggro()*coef;
 212                         }
 213                 }
 214         }
 215         {
 216                 H_AUTO(AGGRO_ULAMB_removeInvalids);
 217                 FOREACH(it, std::list<TDataSetRow>, botsToRemove)
 218                 {
 219                         _BotAggroList.erase(*it);
 220                 }
 221         }
 222 }
 223
 224 void CBotAggroOwner::blockAggro(sint32 blockTime)
 225 {
 226         if (!_AggroBlocked || _AggroBlockTimer.timeRemaining()<blockTime)
 227                 _AggroBlockTimer.set(blockTime);
 228         _AggroBlocked = true;
 229 }
 230
 231 void CBotAggroOwner::ignoreReturnAggro(bool ignored)
 232 {
 233         _ReturnAggroIgnored = ignored;
 234 }
 235
 236 void CBotAggroOwner::setCanAggro(bool canAggro)
 237 {
 238         _DontAggro = !canAggro;
 239 }
 240
 241 void CBotAggroOwner::update(uint32 ticks)
 242 {
 243         H_AUTO(AGGRO_update);
 244         if (_AggroBlocked)
 245         {
 246                 if (!_AggroBlockTimer.test())
 247                         return;
 248                 _AggroBlocked = false;
 249         }
 250         std::deque<TDataSetRow> botsToRemove;
 251         FOREACH(it, TBotAggroList, _BotAggroList)
 252         {
 253                 // :TODO: Check aggro validity (target position), but it's too expensive I think
 254                 if (it->second->updateTime(ticks))
 255                 {
 256                         botsToRemove.push_back(it->first);
 257                 }
 258                 else
 259                 {
 260                         CAIEntityPhysical* const entity = CAIS::instance().getEntityPhysical(it->second->getBot());
 261                         if (!entity)
 262                                 botsToRemove.push_back(it->first);
 263                 }
 264         }
 265         FOREACH(it, std::deque<TDataSetRow>, botsToRemove)
 266         {
 267                 _BotAggroList.erase(*it);
 268         }
 269         if (_BotAggroList.empty() && _FirstHitPlace)
 270         {
 271                 if (_ReturnPos.toAIVector().quickDistTo(getAggroPos().toAIVector()) < getReturnDistCheck())
 272                         _FirstHitPlace = NULL;
 273         }
 274 }
 275
 276 // :NOTE: If you modify this method modify isNewAggroValid accordingly.
 277 bool CBotAggroOwner::isAggroValid(TDataSetRow const& bot)
 278 {
 279         H_AUTO(AGGRO_isAggroValid);
 280         TBotAggroList::iterator it = _BotAggroList.find(bot);
 281         // Bot has no aggro
 282         if (it==_BotAggroList.end())
 283                 return false;
 284         // Other bot don't exist
 285         CAIEntityPhysical const* entity = CAIS::instance().getEntityPhysical(bot);
 286         if (!entity)
 287                 return false;
 288         // Bot fled too far from last time he hit
 289         if (!it->second->atPlace(entity))
 290                 return false;
 291         // He's outside of first hit place
 292         if (!this->atPlace(entity))
 293                 return false;
 294         // He seems OK, let's aggro him
 295         return true;
 296 }
 297
 298 // :NOTE: If you modify this method modify isAggroValid accordingly.
 299 bool CBotAggroOwner::isNewAggroValid(TDataSetRow const& bot)
 300 {
 301         H_AUTO(AGGRO_isNewAggroValid);
 302         // Other bot don't exist
 303         CAIEntityPhysical const* entity = CAIS::instance().getEntityPhysical(bot);
 304         if (!entity)
 305                 return false;
 306         // He's outside of first hit place
 307         if (!this->atPlace(entity))
 308                 return false;
 309         // He seems OK, let's aggro him
 310         return true;
 311 }
 312
 313 bool CBotAggroOwner::haveAggroWithEntity(const TDataSetRow& rowId) const
 314 {
 315         H_AUTO(AGGRO_haveAggroWithEntity);
 316         return _BotAggroList.find(rowId) != _BotAggroList.end();
 317 }
 318
 319 void CBotAggroOwner::addAggroFor(TDataSetRow const& bot, float aggro, bool forceReturnAggro, NLMISC::CSmartPtr<CAIPlace const> place, bool transferAggro)
 320 {
 321         H_AUTO(AGGRO_AA_Total);
 322         if (!isAggroable(bot) || (_ReturnAggroIgnored && !forceReturnAggro))
 323                 return;
 324
 325         if (_DontAggro)
 326                 return;
 327
 328         // If group aggro build a bot list who aggro (self included), and return
 329         if (transferAggro && getPrimaryGroupAggroCoef()>0.f)
 330         {
 331                 std::set<CBotAggroOwner*> primaryGroup, secondaryGroup;
 332                 {
 333                         H_AUTO(AGGRO_AA_BuildAggroTransferList);
 334                         primaryGroup = getAggroGroup(true);
 335                         primaryGroup.erase(this);
 336                         FOREACH(it, std::set<CBotAggroOwner*>, primaryGroup)
 337                         {
 338                                 if (*it)
 339                                 {
 340                                         std::set<CBotAggroOwner*> aggroGroup = (*it)->getAggroGroup(false);
 341                                         std::set_difference(aggroGroup.begin(), aggroGroup.end(), primaryGroup.begin(), primaryGroup.end(), std::inserter(secondaryGroup, secondaryGroup.end()));
 342                                 }
 343                         }
 344                         secondaryGroup.erase(this);
 345                 }
 346                 this->addAggroFor(bot, aggro, forceReturnAggro, place, false);
 347                 FOREACH(it, std::set<CBotAggroOwner*>, primaryGroup)
 348                         (*it)->addAggroFor(bot, aggro*getPrimaryGroupAggroCoef(), forceReturnAggro, place, false);
 349                 FOREACH(it, std::set<CBotAggroOwner*>, secondaryGroup)
 350                         (*it)->addAggroFor(bot, aggro*getSecondaryGroupAggroCoef(), forceReturnAggro, place, false);
 351                 return;
 352         }
 353
 354 #ifdef NL_DEBUG
 355         nlassert(aggro<=0);
 356 #endif
 357
 358         // If we have no firstHitPlace start fight
 359         if (!_FirstHitPlace)
 360         {
 361                 H_AUTO(AGGRO_AA_BuildFirstHitPlace);
 362                 _ReturnPos = getAggroPos();
 363                 _FirstHitPlace = buildFirstHitPlace(bot);
 364         }
 365         // Else verify this bot is still in range
 366         else
 367         {
 368                 H_AUTO(AGGRO_AA_CheckFirstHitPlace);
 369                 // If aggro is not valid for that bot (he's outside of range)
 370                 if (!isNewAggroValid(bot))
 371                 {
 372                         // Forget him
 373                         forgetAggroFor(bot, true);
 374                         // And ignore him
 375                         return;
 376                 }
 377         }
 378         if (!place)
 379         {
 380                 H_AUTO(AGGRO_AA_BuildLastHitPlace);
 381                 CAIEntityPhysical const* entity = NULL;
 382                 H_TIME(AGGRO_AA_BLHP_GetEntity, entity = CAIS::instance().getEntityPhysical(bot););
 383                 if (entity)
 384                 {
 385                         NLMISC::CSmartPtr<CAIPlaceFastXYR> newPlace(NULL);
 386                         H_TIME(AGGRO_AA_BLHP_AllocPlace, newPlace = NLMISC::CSmartPtr<CAIPlaceFastXYR>(new CAIPlaceFastXYR(NULL)););
 387                         H_TIME(AGGRO_AA_BLHP_ParamPlace, newPlace->setPosAndRadius(AITYPES::vp_auto, entity->pos(), (uint32)(getD2Radius()*1000.f)););
 388                         place = newPlace;
 389                 }
 390         }
 391
 392         _LastHitTime = CTimeInterface::gameCycle();
 393
 394         TBotAggroList::iterator it = _BotAggroList.find(bot);
 395         if (it!=_BotAggroList.end())
 396         {
 397                 H_AUTO(AGGRO_AA_AddAggro);
 398                 it->second->addAggro(-aggro, place);
 399         }
 400         else
 401         {
 402                 H_AUTO(AGGRO_AA_CreateAggro);
 403                 //      not found, so add it.
 404                 //      as its the first time, majorate aggro (square its effect)..
 405                 float firstAggro = 1+aggro;
 406                 firstAggro = 1-firstAggro*firstAggro;
 407
 408                 _BotAggroList.insert(std::make_pair(bot, TAggroEntryPtr(new CBotAggroEntry(bot, firstAggro, *this, place))));
 409         }
 410 }
 411
 412 void CBotAggroOwner::setAggroMinimumFor(TDataSetRow const& bot, float aggro, bool forceReturnAggro, NLMISC::CSmartPtr<CAIPlace const> place, bool transferAggro)
 413 {
 414         H_AUTO(AGGRO_SAM_Total);
 415         if (!isAggroable(bot) || (_ReturnAggroIgnored && !forceReturnAggro))
 416                 return;
 417
 418         if (_DontAggro)
 419                 return;
 420
 421         // If group aggro build a bot list who aggro (self included), and return
 422         if (transferAggro && getPrimaryGroupAggroCoef()>0.f)
 423         {
 424                 std::set<CBotAggroOwner*> primaryGroup, secondaryGroup;
 425                 {
 426                         H_AUTO(AGGRO_SAM_BuildAggroTransferList);
 427                         primaryGroup = getAggroGroup(true);
 428                         primaryGroup.erase(this);
 429                         FOREACH(it, std::set<CBotAggroOwner*>, primaryGroup)
 430                         {
 431                                 if (*it)
 432                                 {
 433                                         std::set<CBotAggroOwner*> aggroGroup = (*it)->getAggroGroup(false);
 434                                         std::set_difference(aggroGroup.begin(), aggroGroup.end(), primaryGroup.begin(), primaryGroup.end(), std::inserter(secondaryGroup, secondaryGroup.end()));
 435                                 }
 436                         }
 437                         secondaryGroup.erase(this);
 438                 }
 439                 this->setAggroMinimumFor(bot, aggro, forceReturnAggro, place, false);
 440                 FOREACH(it, std::set<CBotAggroOwner*>, primaryGroup)
 441                         (*it)->setAggroMinimumFor(bot, aggro*getPrimaryGroupAggroCoef(), forceReturnAggro, place, false);
 442                 FOREACH(it, std::set<CBotAggroOwner*>, secondaryGroup)
 443                         (*it)->setAggroMinimumFor(bot, aggro*getSecondaryGroupAggroCoef(), forceReturnAggro, place, false);
 444                 return;
 445         }
 446
 447 #ifdef NL_DEBUG
 448         nlassert(aggro>=0);
 449 #endif
 450         if (!_FirstHitPlace)
 451         {
 452                 H_AUTO(AGGRO_SAM_BuildFirstHitPlace);
 453                 _ReturnPos = getAggroPos();
 454                 _FirstHitPlace = buildFirstHitPlace(bot);
 455         }
 456         // Else verify this bot is still in range
 457         else
 458         {
 459                 H_AUTO(AGGRO_SAM_CheckFirstHitPlace);
 460                 // If aggro is not valid for that bot (he's outside of range)
 461                 if (!isNewAggroValid(bot))
 462                 {
 463                         // Forget him
 464                         forgetAggroFor(bot, true);
 465                         // And ignore him
 466                         return;
 467                 }
 468         }
 469         if (!place)
 470         {
 471                 H_AUTO(AGGRO_SAM_BuildLastHitPlace);
 472                 CAIEntityPhysical const* entity = NULL;
 473                 H_TIME(AGGRO_SAM_BLHP_GetEntity, entity = CAIS::instance().getEntityPhysical(bot););
 474                 if (entity)
 475                 {
 476                         NLMISC::CSmartPtr<CAIPlaceFastXYR> newPlace(NULL);
 477                         H_TIME(AGGRO_SAM_BLHP_AllocPlace, newPlace = NLMISC::CSmartPtr<CAIPlaceFastXYR>(new CAIPlaceFastXYR(NULL)););
 478                         H_TIME(AGGRO_SAM_BLHP_ParamPlace, newPlace->setPosAndRadius(AITYPES::vp_auto, entity->pos(), (uint32)(getD2Radius()*1000.f)););
 479                         place = newPlace;
 480                 }
 481         }
 482
 483         TBotAggroList::iterator it = _BotAggroList.find(bot);
 484         if (it!=_BotAggroList.end())
 485         {
 486                 H_AUTO(AGGRO_SAM_SetMinimum);
 487                 it->second->setMinimum(aggro, place);
 488         }
 489         else
 490         {
 491                 H_AUTO(AGGRO_SAM_CreateAggro);
 492                 // not found, so add it.
 493                 _BotAggroList.insert(std::make_pair(bot, TAggroEntryPtr(new CBotAggroEntry(bot, aggro, *this, place))));
 494         }
 495 }
 496
 497 void CBotAggroOwner::maximizeAggroFor(TDataSetRow const& bot)
 498 {
 499         H_AUTO(AGGRO_maximizeAggroFor);
 500         if (!isAggroable(bot))
 501                 return;
 502
 503         if (_DontAggro)
 504                 return;
 505
 506         TBotAggroList::iterator it = _BotAggroList.find(bot);
 507         if (it!=_BotAggroList.end())
 508         {
 509                 it->second->setMinimum(0.999f);
 510                 FOREACH(it2, TBotAggroList, _BotAggroList)
 511                 {
 512                         if (it2!=it)
 513                                 it2->second->scaleBy(0.15f);
 514                 }
 515         }
 516         else
 517         {
 518                 _BotAggroList.insert(std::make_pair(bot, TAggroEntryPtr(new CBotAggroEntry(bot, 0.999f, *this))));
 519         }
 520 }
 521
 522 void CBotAggroOwner::minimizeAggroFor(TDataSetRow const& bot)
 523 {
 524         H_AUTO(AGGRO_minimizeAggroFor);
 525         if (!isAggroable(bot))
 526                 return;
 527
 528         if (_DontAggro)
 529                 return;
 530
 531         TBotAggroList::iterator it = _BotAggroList.find(bot);
 532         if (it!=_BotAggroList.end())
 533         {
 534                 it->second->setMaximum(0.1f);
 535                 FOREACH(it2, TBotAggroList, _BotAggroList)
 536                 {
 537                         if (it2!=it)
 538                                 it2->second->setMinimum(0.15f);
 539                 }
 540         }
 541         else
 542         {
 543                 _BotAggroList.insert(std::make_pair(bot, TAggroEntryPtr(new CBotAggroEntry(bot, 0.1f, *this))));
 544         }
 545 }
 546
 547 void CBotAggroOwner::forgetAggroFor(TDataSetRow const& bot, bool forgetDamages)
 548 {
 549         H_AUTO(AGGRO_forgetAggroFor);
 550         _BotAggroList.erase(bot);
 551         if (forgetDamages && getAggroOwnerEid()!=NLMISC::CEntityId::Unknown)
 552         {
 553                 CAIEntityPhysical* const entity = CAIS::instance().getEntityPhysical(bot);
 554                 if (entity)
 555                 {
 556                         // Tell EGS that player is a cheater
 557                         if (entity->getRyzomType()==RYZOMID::player)
 558                         {
 559                                 NLMISC::CEntityId targetId = entity->getEntityId();
 560                                 NLMISC::CEntityId botId = getAggroOwnerEid();
 561
 562                                 NLNET::CMessage msgout("PLAYER_UNREACHABLE");
 563                                 msgout.serial(botId);
 564                                 msgout.serial(targetId);
 565                                 sendMessageViaMirror("EGS", msgout);
 566                         }
 567                 }
 568         }
 569 }
 570
 571 bool CBotAggroOwner::hasBeenHit(uint32 ticks) const
 572 {
 573         return (CTimeInterface::gameCycle()-_LastHitTime)<=ticks;
 574 }
 575
 576 bool CBotAggroOwner::isAggroable(TDataSetRow const& dataSetRow)
 577 {
 578         H_AUTO(AGGRO_isAggroable);
 579         if (CMirrors::getEntityId(dataSetRow).getType()!=RYZOMID::player)
 580                 return true;
 581
 582         CAIEntityPhysical* ep = CAIS::instance().getEntityPhysical(dataSetRow);
 583         if (!ep)
 584                 return false;
 585
 586         CBotPlayer const* const player = NLMISC::safe_cast<CBotPlayer const*>(ep);
 587         if (!player)
 588                 return true;
 589         return player->isAggroable();
 590 }
 591
 592 RYAI_MAP_CRUNCH::CWorldPosition CBotAggroOwner::getAggroPos() const
 593 {
 594         return RYAI_MAP_CRUNCH::CWorldPosition();
 595 }
 596
 597 NLMISC::CEntityId CBotAggroOwner::getAggroOwnerEid() const
 598 {
 599         return NLMISC::CEntityId::Unknown;
 600 }
 601
 602 NLMISC::CSmartPtr<CAIPlace const> CBotAggroOwner::buildFirstHitPlace(TDataSetRow const& aggroBot) const
 603 {
 604         return NLMISC::CSmartPtr<CAIPlace const>(NULL);
 605 }
 606
 607 void CBotAggroOwner::clearAggroList(bool sendMessageToEGS)
 608 {
 609         _SendAggroLostToEGS = sendMessageToEGS;
 610         _BotAggroList.clear();
 611         _SendAggroLostToEGS = true;
 612 }
 613
 614 float CBotAggroOwner::getAggroFor(TDataSetRow const& bot)
 615 {
 616         TBotAggroList::iterator it = _BotAggroList.find(bot);
 617         if (it!=_BotAggroList.end())
 618                 return it->second->finalAggro();
 619         else
 620                 return 0.f;
 621 }