ryzom/server/src/ai_service/ai_grp.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
  19 #include "stdpch.h"
  20 #include "ai_grp.h"
  21 #include "visual_properties_interface.h"
  22 #include "ai_profile_npc.h"
  23
  24 using namespace MULTI_LINE_FORMATER;
  25
  26 //////////////////////////////////////////////////////////////////////
  27 // Construction/Destruction
  28 //////////////////////////////////////////////////////////////////////
  29
  30 //--------------------------------------------------------------------------
  31 // METHODS for debugging stuff
  32 //--------------------------------------------------------------------------
  33
  34 bool    GrpHistoryRecordLog     =       true;
  35 CAIVector       lastTriedPos;
  36
  37 CGroup::CGroup  (CManager *owner, RYAI_MAP_CRUNCH::TAStarFlag   denyFlags, CAIAliasDescriptionNode *aliasTree) :
  38                 CAliasChild<CManager>(owner,aliasTree),
  39                 CPersistent<CSpawnGroup>(),
  40                 _EscortTeamId(CTEAM::InvalidTeamId),
  41                 _EscortRange(30),
  42                 _AutoSpawn(true),
  43                 _DenyFlags(denyFlags),
  44                 _AutoDestroy(false),
  45                 _AggroRange(0),
  46                 _UpdateNbTicks(30)
  47 {
  48         owner->getAIInstance()->addGroupInfo(this);
  49 }
  50
  51 CGroup::CGroup  (CManager *owner, RYAI_MAP_CRUNCH::TAStarFlag   denyFlags, uint32 alias, std::string const& name) :
  52                 CAliasChild<CManager>(owner, alias, name),
  53                 CPersistent<CSpawnGroup>(),
  54                 _EscortTeamId(CTEAM::InvalidTeamId),
  55                 _EscortRange(30),
  56                 _AutoSpawn(true),
  57                 _DenyFlags(denyFlags),
  58                 _AutoDestroy(false),
  59                 _AggroRange(0),
  60                 _UpdateNbTicks(30)
  61 {
  62         owner->getAIInstance()->addGroupInfo(this);
  63 }
  64
  65 CGroup::~CGroup ()
  66 {
  67         getAIInstance()->removeGroupInfo(this, this);
  68         getOwner()->removeFromSpawnList (this);
  69         if (isSpawned())
  70         {
  71                 despawnGrp      ();
  72         }
  73
  74 }
  75
  76 CBot* CGroup::getLeader()
  77 {
  78         FOREACH(itBot, CCont<CBot>, bots())
  79         {
  80                 CSpawnBot* const bot = itBot->getSpawnObj();
  81                 if (bot && bot->isAlive())
  82                         return *itBot;
  83         }
  84         // no bots alive, no leader !
  85         return NULL;
  86 }
  87
  88 CBot* CGroup::getSquadLeader(bool checkAliveStatus)
  89 {
  90         CCont<CBot>::iterator itBot = bots().begin();
  91         if (itBot!=bots().end())
  92         {
  93                 CSpawnBot* const bot = itBot->getSpawnObj();
  94                 if (bot && (!checkAliveStatus || bot->isAlive()))
  95                         return *itBot;
  96         }
  97         // first bot not alive, no squad leader !
  98         return NULL;
  99 }
 100
 101 void    CGroup::serviceEvent    (const  CServiceEvent   &info)
 102 {
 103         CCont<CBot>::iterator   it=bots().begin(), itEnd=bots().end();
 104         while (it!=itEnd)
 105         {
 106                 it->serviceEvent        (info);
 107                 ++it;
 108         }
 109
 110 }
 111
 112 void    CGroup::despawnBots     ()
 113 {
 114         for     (CCont<CBot>::iterator  it=_Bots.begin(), itEnd=_Bots.end(); it!=itEnd;++it)
 115         {
 116                 if (it->isSpawned())
 117                         it->despawnBot();
 118         }
 119
 120 }
 121
 122 std::string CGroup::getIndexString() const
 123 {
 124         return getOwner()->getIndexString()+NLMISC::toString(":g%u", getChildIndex());
 125 }
 126
 127 std::string CGroup::getOneLineInfoString() const
 128 {
 129         return std::string("Group '") + getName() + "'";
 130 }
 131
 132 std::vector<std::string> CGroup::getMultiLineInfoString() const
 133 {
 134         std::vector<std::string> container;
 135
 136         pushTitle(container, "CGroup");
 137         pushEntry(container, "id=" + getIndexString());
 138         container.back() += " alias=" + getAliasString();
 139         container.back() += " name=" + getName();
 140         pushEntry(container, "fullname=" + getFullName());
 141         pushEntry(container, "autoSpawn=" + NLMISC::toString(_AutoSpawn));
 142         pushEntry(container, "aggroRange=" + NLMISC::toString(_AggroRange));
 143         container.back() += " updateNbTicks=" + NLMISC::toString(_UpdateNbTicks);
 144         if (isSpawned())
 145         {
 146                 std::vector<std::string> strings = getSpawnObj()->getMultiLineInfoString();
 147                 FOREACHC(it, std::vector<std::string>, strings)
 148                         pushEntry(container, *it);
 149         }
 150         else
 151                 pushEntry(container, "<not spawned>");
 152         pushFooter(container);
 153
 154         return container;
 155 }
 156
 157 std::string CGroup::getFullName() const
 158 {
 159         return std::string(getOwner()->getFullName()+":"+getName());
 160 }
 161
 162 void CGroup::lastBotDespawned()
 163 {
 164         // send message
 165 }
 166
 167 void CGroup::firstBotSpawned()
 168 {
 169         // send message
 170 }
 171
 172 //////////////////////////////////////////////////////////////////////////////
 173 // CSpawnGroup                                                              //
 174 //////////////////////////////////////////////////////////////////////////////
 175
 176 CSpawnGroup::~CSpawnGroup()
 177 {
 178         FOREACH(it, CCont<CBot>,bots())
 179         {
 180                 if ((*it)->isSpawned())
 181                         (*it)->despawnBot();
 182         }
 183
 184         getPersistent().despawnBots();
 185
 186         // clear profiles
 187         _MovingProfile = CProfilePtr();
 188         _FightProfile = CProfilePtr();
 189         _ActivityProfile = CProfilePtr();
 190         _PunctualHoldActivityProfile = CProfilePtr();
 191         _PunctualHoldMovingProfile = CProfilePtr();
 192 }
 193
 194 bool CSpawnGroup::calcCenterPos(CAIVector& grp_pos, bool allowDeadBot)
 195 {
 196         if (bots().size()<=0)
 197                 return  false;
 198
 199         double x(0), y(0);
 200         uint count(0);
 201
 202         FOREACH(it, CCont<CBot>, bots())
 203         {
 204                 CSpawnBot const* const spawnBot = it->getSpawnObj();
 205                 if (!spawnBot || (!allowDeadBot && !spawnBot->isAlive()))
 206                         continue;
 207
 208                 x += spawnBot->pos().x().asDouble();
 209                 y += spawnBot->pos().y().asDouble();
 210                 ++count;
 211         }
 212         if (count==0)
 213                 return false;
 214
 215         grp_pos.setX(x/count);
 216         grp_pos.setY(y/count);
 217         return  true;
 218 }
 219
 220 void CSpawnGroup::spawnBotOfGroup()
 221 {
 222         CCont<CBot>::iterator it = bots().begin();
 223         CCont<CBot>::iterator itEnd = bots().end();
 224         while (it!=itEnd)
 225         {
 226                 CBot* bot = *it;
 227                 if (!bot->isSpawned())
 228                 {
 229                         bool ok= bot->spawn();
 230 // code removed by Sadge because it didn't fix the problem it was added for
 231 //                      if (ok)
 232 //                      {
 233 //                              // the spawn succeeded
 234 //                              // make sure the bot isn't in the despawn list
 235 //                              for (uint32 i= _BotsToDespawn.size(); i--;)
 236 //                              {
 237 //                                      if (_BotsToDespawn[i].getBotIndex()== bot->getChildIndex())
 238 //                                      {
 239 //                                              nldebug("Removing bot from the despawn list because they just respawned: %s",bot->getFullName().c_str());
 240 //                                              _BotsToDespawn[i]= _BotsToDespawn.back();
 241 //                                              _BotsToDespawn.pop_back();
 242 //                                      }
 243 //                              }
 244 //                      }
 245                         if (!ok)
 246                         {
 247                                 // the spawn failed
 248                                 std::string     name;
 249
 250                                 if (!bot->getFullName().empty())
 251                                         name = bot->getFullName();
 252                                 else
 253                                 {
 254                                         if (!bot->getOwner()->getFullName().empty())
 255                                                 name = std::string("from group ") + bot->getOwner()->getFullName();
 256                                         else
 257                                                 name = std::string("Unknown");
 258                                 }
 259
 260                                 if (bot->getSheet()->SheetId()==NLMISC::CSheetId::Unknown)
 261                                         nlwarning("***> Spawn failed position(%s), UNKNOWN SHEET! Bot %s ",     lastTriedPos.toString().c_str(), name.c_str());
 262                                 else
 263                                         nlwarning("***> Spawn failed position(%s), sheetId(%s) Bot %s ", lastTriedPos.toString().c_str(), bot->getSheet()->SheetId().toString().c_str(), name.c_str());
 264                         }
 265                 }
 266                 ++it;
 267         }
 268 }
 269
 270 void CSpawnGroup::addBotToDespawnAndRespawnTime(CBot* bot, uint32 despawnTime, uint32 respawnTime)
 271 {
 272         nlassert(bot->isSpawned());
 273         nlassert(bot->getOwner()==&getPersistent());
 274
 275         uint32 const botIndex = bot->getChildIndex();
 276
 277         FOREACH(it, std::vector<CBotToSpawn>, _BotsToDespawn)
 278         {
 279                 if (it->getBotIndex()==botIndex)
 280                 {
 281                         *it = CBotToSpawn(botIndex, despawnTime, respawnTime);
 282                         return;
 283                 }
 284         }
 285         _BotsToDespawn.push_back(CBotToSpawn(botIndex, despawnTime, respawnTime));
 286 }
 287
 288 void CSpawnGroup::checkDespawn()
 289 {
 290         if (_BotsToDespawn.empty())
 291                 return;
 292
 293         //FOREACH_NOINC(it, std::vector<CBotToSpawn>, _BotsToDespawn)
 294         for(uint32 i = 0; i < _BotsToDespawn.size();)
 295         {
 296                 CBotToSpawn& botToDespawn = _BotsToDespawn[i];
 297                 if (botToDespawn.waitingDespawnTimeOver())
 298                 {
 299                         if (botToDespawn.getBotIndex()>=getPersistent().bots().size())
 300                         {
 301                                 STOP("Array overflow in despawn code!");
 302                         }
 303                         else if (getPersistent().bots()[botToDespawn.getBotIndex()]==NULL)
 304                         {
 305                                 STOP("Trying to despawn a bot who doesn't exist!!");
 306                         }
 307                         else
 308                         {
 309                                 getPersistent().bots()[botToDespawn.getBotIndex()]->despawnBot();
 310                                 if      (getPersistent().isAutoSpawn())
 311                                         _BotsToRespawn.push_back(botToDespawn);
 312                         }
 313
 314                         // pop this entry out of the bots to despawn vector
 315                         // ace: we don't use iterator because when pop_back(), all iterators are invalidated
 316                         _BotsToDespawn[i] = _BotsToDespawn.back();
 317                         _BotsToDespawn.pop_back();
 318                         continue;
 319                 }
 320                 i++;
 321         }
 322
 323         if (_NbSpawnedBot==0 && _BotsToRespawn.size()==0)
 324         {
 325                 // Warn the parent manager that this group is now dead.
 326                 getPersistent().getOwner()->getOwner()->groupDead(&getPersistent());
 327                 if      (getPersistent()._AutoDestroy)
 328                         getPersistent().getOwner()->groups().removeChildByIndex(getPersistent().getChildIndex());
 329         }
 330 }
 331
 332
 333 void CSpawnGroup::incSpawnedBot(CBot& spawnBot)
 334 {
 335 #if !FINAL_VERSION
 336         uint32   botIndex = spawnBot.getChildIndex();
 337         for     (uint32 i=(uint32)_BotsToRespawn.size(); i--; )
 338         {
 339                 if (_BotsToRespawn[i].getBotIndex()==botIndex)
 340                 {
 341                         nldebug("Removing bot from _BotsToRespawn because they just respawned: %s",spawnBot.getFullName().c_str());
 342 //                      nlwarning("WARNING!!! Old assert \"_BotsToRespawn[i].getBotIndex()!=botIndex\" would have failed");
 343                         _BotsToRespawn[i]=_BotsToRespawn.back();
 344                         _BotsToRespawn.pop_back();
 345                 }
 346         }
 347         for     (uint32 i=(uint32)_BotsToDespawn.size(); i--; )
 348         {
 349                 if (_BotsToDespawn[i].getBotIndex()==botIndex)
 350                 {
 351                         nldebug("Removing bot from _BotsToDespawn because they just respawned: %s",spawnBot.getFullName().c_str());
 352 //                      nlwarning("WARNING!!! Old assert \"_BotsToDespawn[i].getBotIndex()!=botIndex\" would have failed");
 353                         _BotsToDespawn[i]=_BotsToDespawn.back();
 354                         _BotsToDespawn.pop_back();
 355                 }
 356         }
 357 #endif
 358         if (_NbSpawnedBot==0)
 359         {
 360                 getPersistent().firstBotSpawned();
 361         }
 362         _NbSpawnedBot++;
 363 }
 364
 365 void CSpawnGroup::decSpawnedBot()
 366 {
 367         --_NbSpawnedBot;
 368         if (_NbSpawnedBot==0)
 369         {
 370                 getPersistent().lastBotDespawned();
 371         }
 372 }
 373
 374 void CSpawnGroup::checkRespawn()
 375 {
 376         // respawn if there is not too much dead .. (no more than one at each tick).
 377         if (_BotsToRespawn.size()<=0)
 378                 return;
 379
 380         // Send url to EGS
 381         std::string url = getUrl();
 382         std::string actionName = getActionName();
 383         CCreatureSetUrlMsg msg;
 384
 385         //FOREACH_NOINC(it, std::vector<CBotToSpawn>, _BotsToRespawn)
 386         for(uint32 i = 0; i < _BotsToRespawn.size();)
 387         {
 388                 CBotToSpawn const& botToSpawn = _BotsToRespawn[i];
 389                 if (botToSpawn.waitingRespawnTimeOver())
 390                 {
 391                         CBot* botPt = getPersistent().bots()[botToSpawn.getBotIndex()];
 392
 393                         CBotToSpawn const botToSpawn = _BotsToRespawn.back();
 394
 395                         //      remove the entry
 396                         _BotsToRespawn[i] = _BotsToRespawn.back();
 397                         _BotsToRespawn.pop_back();
 398
 399                         if (botPt->isSpawned())
 400                         {
 401                                 nlwarning("CSpawnGroup::checkRespawn : trying to respawn a spawned bot");
 402                         }
 403                         if (botPt->isSpawned() || botPt->reSpawn(false))
 404                         {
 405                                 CSpawnBot* pbot = botPt->getSpawnObj();
 406                                 if (pbot!=NULL)
 407                                 {
 408                                         msg.Entities.push_back(pbot->dataSetRow());
 409                                 }
 410                                 continue;                                       //      directly test the same it (the next in fact).
 411                         }
 412                         else
 413                         {
 414                                 _BotsToRespawn.insert(_BotsToRespawn.begin(), botToSpawn);      //      push_front so the end doesn't change.
 415                         }
 416                 }
 417                 ++i;
 418         }
 419
 420         if(url != "")
 421         {
 422                 msg.ActionName = actionName;
 423                 msg.Url = url;
 424                 msg.send(egsString);
 425         }
 426
 427 }
 428
 429 CBot* CSpawnGroup::findLeader()
 430 {
 431         FOREACH(itBot, CCont<CBot>, bots())
 432         {
 433                 CBot* bot = *itBot;
 434                 if (bot->isSpawned())
 435                 {
 436                         if (bot->getSpawnObj()->isAlive())
 437                                 return bot;
 438                 }
 439         }
 440         return NULL;
 441 }
 442
 443 std::vector<std::string> CSpawnGroup::getMultiLineInfoString() const
 444 {
 445         std::vector<std::string> container;
 446
 447         pushTitle(container, "CSpawnGroup");
 448         pushEntry(container, "move profile:     " + _MovingProfile.getOneLineInfoString());
 449         pushEntry(container, "activity profile: " + _ActivityProfile.getOneLineInfoString());
 450         pushEntry(container, "fight profile:    " + _FightProfile.getOneLineInfoString());
 451         pushFooter(container);
 452
 453         return container;
 454 }
 455
 456 NLMISC::CSmartPtr<CAIPlace const> CSpawnGroup::buildFirstHitPlace(TDataSetRow const& aggroBot) const
 457 {
 458         if (_ActivityProfile.getAIProfileType()==AITYPES::ACTIVITY_SQUAD)
 459                 return static_cast<CGrpProfileSquad*>(_ActivityProfile.getAIProfile())->buildFirstHitPlace(aggroBot);
 460         return NULL;
 461 }
 462
 463 void CSpawnGroup::addAggroFor(TDataSetRow const& bot, float aggro, bool forceReturnAggro, NLMISC::CSmartPtr<CAIPlace const> place)
 464 {
 465         CGroup& grp = getPersistent();
 466         FOREACH(itBot, CCont<CBot>, grp.bots())
 467         {
 468                 CBot* pBot = *itBot;
 469                 if (pBot)
 470                 {
 471                         CSpawnBot* spBot = pBot->getSpawnObj();
 472                         if (spBot)
 473                         {
 474                                 spBot->addAggroFor(bot, aggro, forceReturnAggro, place, false);
 475                         }
 476                 }
 477         }
 478 }
 479 void CSpawnGroup::setAggroMinimumFor(TDataSetRow const& bot, float aggro, bool forceReturnAggro, NLMISC::CSmartPtr<CAIPlace const> place)
 480 {
 481         CGroup& grp = getPersistent();
 482         FOREACH(itBot, CCont<CBot>, grp.bots())
 483         {
 484                 CBot* pBot = *itBot;
 485                 if (pBot)
 486                 {
 487                         CSpawnBot* spBot = pBot->getSpawnObj();
 488                         if (spBot)
 489                         {
 490                                 spBot->setAggroMinimumFor(bot, aggro, forceReturnAggro, place, false);
 491                         }
 492                 }
 493         }
 494 }
 495
 496 bool CSpawnGroup::haveAggro() const
 497 {
 498         CGroup const& group = getPersistent();
 499         FOREACHC(itBot, CCont<CBot>, group.bots())
 500         {
 501                 CBot const* pBot = *itBot;
 502                 if (pBot)
 503                 {
 504                         CSpawnBot const* spBot = pBot->getSpawnObj();
 505                         if (spBot && spBot->haveAggro())
 506                                 return true;
 507                 }
 508         }
 509         return false;
 510 }
 511
 512 bool CSpawnGroup::haveAggroOrReturnPlace() const
 513 {
 514         CGroup const& group = getPersistent();
 515         FOREACHC(itBot, CCont<CBot>, group.bots())
 516         {
 517                 CBot const* pBot = *itBot;
 518                 if (pBot)
 519                 {
 520                         CSpawnBot const* spBot = pBot->getSpawnObj();
 521                         if (spBot && spBot->haveAggroOrReturnPlace())
 522                                 return true;
 523                 }
 524         }
 525         return false;
 526 }