Code/CryEngine/CryAction/RangeSignalingSystem/PersonalRangeSignaling.cpp

   1 // Copyright 2001-2018 Crytek GmbH / Crytek Group. All rights reserved.
   2
   3 /********************************************************************
   4    ---------------------------------------------------------------------
   5    File name:   Range.h
   6    $Id$
   7    $DateTime$
   8    Description: Manager per-actor signals to other actors by range
   9    ---------------------------------------------------------------------
  10    History:
  11    - 09:04:2007 : Created by Ricardo Pillosu
  12
  13  *********************************************************************/
  14 #include "StdAfx.h"
  15 #include "PersonalRangeSignaling.h"
  16 #include "RangeSignaling.h"
  17 #include "Range.h"
  18 #include "AngleAlert.h"
  19 #include "IUIDraw.h"
  20
  21 #include <functional>
  22 #include <CryAISystem/IAIObject.h>
  23
  24 // Description:
  25 //   Constructor
  26 // Arguments:
  27 //
  28 // Return:
  29 //
  30 CPersonalRangeSignaling::CPersonalRangeSignaling(CRangeSignaling* pParent) : m_bInit(false), m_bEnabled(false), m_pParent(pParent), m_EntityId(0)
  31 {
  32         CRY_ASSERT(pParent != NULL);
  33
  34         m_pDefaultFont = gEnv->pCryFont->GetFont("default");
  35         CRY_ASSERT(m_pDefaultFont);
  36 }
  37
  38 // Description:
  39 //   Destructor
  40 // Arguments:
  41 //
  42 // Return:
  43 //
  44 CPersonalRangeSignaling::~CPersonalRangeSignaling()
  45 {
  46         Reset();
  47
  48         for (int i = 0; i < m_vecRanges.size(); ++i)
  49         {
  50                 SAFE_DELETE(m_vecRanges[i]);
  51         }
  52
  53         m_vecRanges.clear();
  54
  55         MapTargetRanges::iterator itTargetRange = m_mapTargetRanges.begin();
  56         MapTargetRanges::iterator itTargetRangeEnd = m_mapTargetRanges.end();
  57         for (; itTargetRange != itTargetRangeEnd; ++itTargetRange)
  58         {
  59                 for (int i = 0; i < itTargetRange->second.size(); ++i)
  60                 {
  61                         SAFE_DELETE(itTargetRange->second[i]);
  62                 }
  63         }
  64
  65         m_mapTargetRanges.clear();
  66
  67         for (int i = 0; i < m_vecAngles.size(); ++i)
  68         {
  69                 SAFE_DELETE(m_vecAngles[i]);
  70         }
  71
  72         m_vecAngles.clear();
  73
  74         SetListener(false);
  75 }
  76
  77 // Description:
  78 //
  79 // Arguments:
  80 //
  81 // Return:
  82 //
  83 bool CPersonalRangeSignaling::Init(EntityId Id)
  84 {
  85         CRY_ASSERT(m_bInit == false);
  86
  87         m_EntityId = Id;
  88         m_bInit = true;
  89
  90         // Enabled state starts off matching proxy's state
  91         IAIActorProxy* pAIProxy = GetEntityAIProxy(m_EntityId);
  92         SetEnabled(pAIProxy && pAIProxy->IsEnabled());
  93
  94         if (GetActor() == NULL)
  95         {
  96                 m_bInit = false;
  97         }
  98         else
  99         {
 100                 SetListener(true);
 101         }
 102
 103         return(m_bInit);
 104 }
 105
 106 // Description: std::less functor template specialization, so to make comparison of two CRange pointers
 107 //                                                      work properly
 108 //
 109 // Arguments:           two pointers to CRange instances
 110 //
 111 // Return:                      comparison result
 112 //
 113 namespace std
 114 {
 115
 116 template<>
 117 struct less<CRange*>
 118 {
 119         bool operator()(const CRange* pRange1, const CRange* pRange2) const
 120         {
 121                 CRY_ASSERT(pRange1 != NULL);
 122                 CRY_ASSERT(pRange2 != NULL);
 123
 124                 return((*pRange1) < (*pRange2));
 125         }
 126 };
 127
 128 }
 129
 130 bool CompareRange(CRange* pRange1, CRange* pRange2)
 131 {
 132         CRY_ASSERT(pRange1 != NULL);
 133         CRY_ASSERT(pRange2 != NULL);
 134
 135         return((*pRange1) < (*pRange2));
 136 }
 137
 138 bool CompareAngle(CAngleAlert* pAngle1, CAngleAlert* pAngle2)
 139 {
 140         CRY_ASSERT(pAngle1 != NULL);
 141         CRY_ASSERT(pAngle2 != NULL);
 142
 143         return((*pAngle1) < (*pAngle2));
 144 }
 145
 146 // Description:
 147 //
 148 // Arguments:
 149 //
 150 // Return:
 151 //
 152 bool CPersonalRangeSignaling::AddRangeSignal(float fRadius, float fBoundary, const char* sSignal, IAISignalExtraData* pData /*=NULL*/)
 153 {
 154         CRY_ASSERT(m_bInit == true);
 155         CRY_ASSERT(sSignal != NULL);
 156         CRY_ASSERT(fRadius > 0.5f);
 157         CRY_ASSERT(fBoundary >= 0.0f);
 158
 159         bool bRet = true;
 160         CRange* pRange = SearchRange(sSignal, m_vecRanges);
 161
 162         if (pRange == NULL)
 163         {
 164                 pRange = new CRange(this);
 165                 m_vecRanges.push_back(pRange);
 166         }
 167
 168         pRange->Init(fRadius, fBoundary, sSignal, pData);
 169         std::sort(m_vecRanges.begin(), m_vecRanges.end(), &CompareRange);   // std::less is properly overridden
 170
 171         return(bRet);
 172 }
 173
 174 // Description:
 175 //
 176 // Arguments:
 177 //
 178 // Return:
 179 //
 180 bool CPersonalRangeSignaling::AddTargetRangeSignal(EntityId IdTarget, float fRadius, float fBoundary, const char* sSignal, IAISignalExtraData* pData /*= NULL*/)
 181 {
 182         CRY_ASSERT(m_bInit == true);
 183         CRY_ASSERT(GetActor());
 184         CRY_ASSERT(IdTarget > 0);
 185         CRY_ASSERT(sSignal != NULL);
 186         CRY_ASSERT(fRadius > 0.5f);
 187         CRY_ASSERT(fBoundary >= 0.0f);
 188
 189         bool bRet = true;
 190         CRange* pRange = SearchRange(sSignal, m_mapTargetRanges[IdTarget]);
 191
 192         if (pRange == NULL)
 193         {
 194                 pRange = new CRange(this);
 195                 m_mapTargetRanges[IdTarget].push_back(pRange);
 196         }
 197
 198         pRange->Init(fRadius, fBoundary, sSignal, pData);
 199         std::sort(m_mapTargetRanges[IdTarget].begin(), m_mapTargetRanges[IdTarget].end(), &CompareRange);   // std::less is properly overridden
 200
 201         return(bRet);
 202 }
 203
 204 // Description:
 205 //
 206 // Arguments:
 207 //
 208 // Return:
 209 //
 210 bool CPersonalRangeSignaling::AddAngleSignal(float fAngle, float fBoundary, const char* sSignal, IAISignalExtraData* pData /*=NULL*/)
 211 {
 212         CRY_ASSERT(m_bInit == true);
 213         CRY_ASSERT(sSignal != NULL);
 214         CRY_ASSERT(fAngle > 0.5f);
 215         CRY_ASSERT(fBoundary >= 0.0f);
 216
 217         bool bRet = true;
 218         CAngleAlert* pAngle = SearchAngle(sSignal);
 219
 220         if (pAngle == NULL)
 221         {
 222                 pAngle = new CAngleAlert(this);
 223                 m_vecAngles.push_back(pAngle);
 224         }
 225
 226         pAngle->Init(fAngle, fBoundary, sSignal, pData);
 227         std::sort(m_vecAngles.begin(), m_vecAngles.end(), &CompareAngle);
 228
 229         return(bRet);
 230 }
 231
 232 // Description:
 233 //
 234 // Arguments:
 235 //
 236 // Return:
 237 //
 238 bool CPersonalRangeSignaling::Update(float fElapsedTime, uint32 uDebugOrder)
 239 {
 240         CRY_ASSERT(m_bInit == true);
 241
 242         bool bRet = false;
 243
 244         if (m_bEnabled)
 245         {
 246                 if (uDebugOrder > 0)
 247                 {
 248                         DebugDraw(uDebugOrder);
 249                 }
 250
 251                 // Iterate all actors and check range to them
 252                 IActorIteratorPtr pActorIt = CCryAction::GetCryAction()->GetIActorSystem()->CreateActorIterator();
 253                 while (IActor* pActor = pActorIt->Next())
 254                 {
 255                         EntityId entityId = pActor->GetEntityId();
 256                         if (entityId != GetEntityId())
 257                         {
 258                                 // Skip over if not enabled
 259                                 IAIObject const* pAIObject = GetEntityAI(entityId);
 260                                 if (!pAIObject || pAIObject->IsEnabled())
 261                                 {
 262                                         CheckActorRanges(pActor);
 263                                         CheckActorAngles(pActor);
 264
 265                                         // Do check on target ranges
 266                                         MapTargetRanges::iterator itTargetRanges = m_mapTargetRanges.find(entityId);
 267                                         if (itTargetRanges != m_mapTargetRanges.end())
 268                                         {
 269                                                 CheckActorTargetRanges(pActor);
 270                                         }
 271                                 }
 272                         }
 273                 }
 274
 275                 bRet = true;
 276         }
 277
 278         return(bRet);
 279 }
 280
 281 // Description:
 282 //
 283 // Arguments:
 284 //
 285 // Return:
 286 //
 287 void CPersonalRangeSignaling::CheckActorRanges(IActor* pActor)
 288 {
 289         CRY_ASSERT(pActor != NULL);
 290
 291         MapRangeSignals::iterator it = m_mapRangeSignalsSent.find(pActor->GetEntityId());
 292         CRange const* pRange = GetRangeTo(pActor->GetEntity()->GetPos(), m_vecRanges);
 293         CRange const* pOldRange = ((it != m_mapRangeSignalsSent.end()) ? it->second : NULL);
 294
 295         if (pRange != pOldRange)
 296         {
 297                 if (pRange != NULL)
 298                 {
 299                         // Check boundary
 300                         if (GetRangeTo(pActor->GetEntity()->GetPos(), m_vecRanges, true) != pOldRange)
 301                         {
 302                                 if (pOldRange == NULL)
 303                                 {
 304                                         m_mapRangeSignalsSent.insert(std::pair<EntityId, CRange const*>(pActor->GetEntityId(), pRange));
 305                                 }
 306                                 else
 307                                 {
 308                                         it->second = pRange;
 309                                 }
 310
 311                                 SendSignal(pActor, pRange->GetSignal(), pRange->GetSignalData());
 312                         }
 313                 }
 314                 else
 315                 {
 316                         m_mapRangeSignalsSent.erase(it);
 317                 }
 318         }
 319 }
 320
 321 // Description:
 322 //
 323 // Arguments:
 324 //
 325 // Return:
 326 //
 327 void CPersonalRangeSignaling::CheckActorTargetRanges(IActor* pActor)
 328 {
 329         CRY_ASSERT(pActor != NULL);
 330
 331         MapTargetRanges::iterator itTargetRanges = m_mapTargetRanges.find(pActor->GetEntityId());
 332         CRY_ASSERT(itTargetRanges != m_mapTargetRanges.end());
 333
 334         MapRangeSignals::iterator it = m_mapTargetRangeSignalsSent.find(pActor->GetEntityId());
 335         CRange const* pRange = GetRangeTo(pActor->GetEntity()->GetPos(), itTargetRanges->second);
 336         CRange const* pOldRange = ((it != m_mapTargetRangeSignalsSent.end()) ? it->second : NULL);
 337
 338         if (pRange != pOldRange)
 339         {
 340                 if (pRange != NULL)
 341                 {
 342                         // Check boundary
 343                         if (GetRangeTo(pActor->GetEntity()->GetPos(), itTargetRanges->second, true) != pOldRange)
 344                         {
 345                                 if (pOldRange == NULL)
 346                                 {
 347                                         m_mapTargetRangeSignalsSent.insert(std::pair<EntityId, CRange const*>(pActor->GetEntityId(), pRange));
 348                                 }
 349                                 else
 350                                 {
 351                                         it->second = pRange;
 352                                 }
 353
 354                                 IActor* pMe = GetActor();
 355                                 CRY_ASSERT_MESSAGE(pMe, "An actor has been removed without cleaning up its range signals.");
 356                                 if (pMe)
 357                                 {
 358                                         SendSignal(pMe, pRange->GetSignal(), pRange->GetSignalData());
 359                                 }
 360                         }
 361                 }
 362                 else
 363                 {
 364                         m_mapTargetRangeSignalsSent.erase(it);
 365                 }
 366         }
 367 }
 368
 369 // Description:
 370 //
 371 // Arguments:
 372 //
 373 // Return:
 374 //
 375 void CPersonalRangeSignaling::CheckActorAngles(IActor* pActor)
 376 {
 377         CRY_ASSERT(pActor != NULL);
 378
 379         MapAngleSignals::iterator it = m_mapAngleSignalsSent.find(pActor->GetEntityId());
 380         CAngleAlert const* pAngle = GetAngleTo(pActor->GetEntity()->GetPos());
 381         CAngleAlert const* pOldAngle = ((it != m_mapAngleSignalsSent.end()) ? it->second : NULL);
 382
 383         if (pAngle != pOldAngle)
 384         {
 385                 if (pAngle != NULL)
 386                 {
 387                         // Check boundary
 388                         if (GetAngleTo(pActor->GetEntity()->GetPos(), true) != pOldAngle)
 389                         {
 390                                 if (pOldAngle == NULL)
 391                                 {
 392                                         m_mapAngleSignalsSent.insert(std::pair<EntityId, CAngleAlert const*>(pActor->GetEntityId(), pAngle));
 393                                 }
 394                                 else
 395                                 {
 396                                         it->second = pAngle;
 397                                 }
 398
 399                                 SendSignal(pActor, pAngle->GetSignal(), pAngle->GetSignalData());
 400                         }
 401                 }
 402                 else
 403                 {
 404                         m_mapAngleSignalsSent.erase(it);
 405                 }
 406         }
 407 }
 408
 409 // Description:
 410 //
 411 // Arguments:
 412 //
 413 // Return:
 414 //
 415 void CPersonalRangeSignaling::Reset()
 416 {
 417         m_mapRangeSignalsSent.clear();
 418         m_mapTargetRangeSignalsSent.clear();
 419         m_mapAngleSignalsSent.clear();
 420         m_mapTargetRanges.clear();
 421 }
 422
 423 // Description:
 424 //
 425 // Arguments:
 426 //
 427 // Return:
 428 //
 429 void CPersonalRangeSignaling::OnProxyReset()
 430 {
 431         // Reset listener
 432         SetListener(true);
 433 }
 434
 435 // Description:
 436 //
 437 // Arguments:
 438 //
 439 // Return:
 440 //
 441 void CPersonalRangeSignaling::SetEnabled(bool bEnable)
 442 {
 443         CRY_ASSERT(m_bInit == true);
 444
 445         m_bEnabled = bEnable;
 446 }
 447
 448 // Description:
 449 //
 450 // Arguments:
 451 //
 452 // Return:
 453 //
 454 EntityId CPersonalRangeSignaling::GetEntityId() const
 455 {
 456         CRY_ASSERT(m_bInit == true);
 457
 458         return(m_EntityId);
 459 }
 460
 461 // Description:
 462 //
 463 // Arguments:
 464 //
 465 // Return:
 466 //
 467 IEntity* CPersonalRangeSignaling::GetEntity()
 468 {
 469         CRY_ASSERT(m_bInit == true);
 470
 471         return(gEnv->pEntitySystem->GetEntity(m_EntityId));
 472 }
 473
 474 // Description:
 475 //
 476 // Arguments:
 477 //
 478 // Return:
 479 //
 480 IEntity const* CPersonalRangeSignaling::GetEntity() const
 481 {
 482         CRY_ASSERT(m_bInit == true);
 483
 484         return(gEnv->pEntitySystem->GetEntity(m_EntityId));
 485 }
 486
 487 // Description:
 488 //
 489 // Arguments:
 490 //
 491 // Return:
 492 //
 493 IActor* CPersonalRangeSignaling::GetActor()
 494 {
 495         CRY_ASSERT(m_bInit == true);
 496
 497         return(CCryAction::GetCryAction()->GetIActorSystem()->GetActor(m_EntityId));
 498 }
 499
 500 // Description:
 501 //
 502 // Arguments:
 503 //
 504 // Return:
 505 //
 506 void CPersonalRangeSignaling::SendSignal(IActor* pActor, const string& sSignal, IAISignalExtraData* pData /*= NULL*/) const
 507 {
 508         CRY_ASSERT(m_bInit == true);
 509         CRY_ASSERT(pActor != NULL);
 510         CRY_ASSERT(sSignal.length() > 0);
 511
 512         IAIObject* pAI = pActor->GetEntity()->GetAI();
 513         //CRY_ASSERT(pAI);  Not every actor has an ai, and nor do they need it
 514         if (pAI && gEnv->pAISystem)
 515         {
 516                 gEnv->pAISystem->SendSignal(SIGNALFILTER_SENDER, 1, sSignal, pAI, PrepareSignalData(pData));
 517         }
 518 }
 519
 520 // Description:
 521 //
 522 // Arguments:
 523 //
 524 // Return:
 525 //
 526 IAISignalExtraData* CPersonalRangeSignaling::PrepareSignalData(IAISignalExtraData* pRequestedData) const
 527 {
 528         IAISignalExtraData* pSendData = gEnv->pAISystem->CreateSignalExtraData();
 529         if (pRequestedData)
 530         {
 531                 // Clone requested data and send it over
 532                 *pSendData = *pRequestedData;
 533         }
 534         else
 535         {
 536                 // Send useful info
 537                 pSendData->nID = GetEntityId();
 538                 pSendData->point = (GetEntity() ? GetEntity()->GetWorldPos() : Vec3Constants<float>::fVec3_Zero);
 539         }
 540
 541         return (pSendData);
 542 }
 543
 544 // Description:
 545 //
 546 // Arguments:
 547 //
 548 // Return:
 549 //
 550 CRange const* CPersonalRangeSignaling::GetRangeTo(const Vec3& vPos, const VecRanges& vecRangeList, bool bUseBoundary) const
 551 {
 552         IEntity const* pEntity = GetEntity();
 553         if (!pEntity)
 554                 return(NULL);
 555
 556         CRange const* pRange = NULL;
 557         Vec3 vOrigin = pEntity->GetPos();
 558         float fSquaredDist = (vPos - vOrigin).GetLengthSquared();
 559
 560         for (int i = 0; i < vecRangeList.size(); ++i)
 561         {
 562                 bool bInRange = false;
 563
 564                 if (bUseBoundary == true)
 565                 {
 566                         bInRange = (vecRangeList[i]->IsInRangePlusBoundary(fSquaredDist) == true);
 567                 }
 568                 else
 569                 {
 570                         bInRange = (vecRangeList[i]->IsInRange(fSquaredDist) == true);
 571                 }
 572
 573                 if (bInRange == true)
 574                 {
 575                         pRange = vecRangeList[i];
 576                         break;
 577                 }
 578         }
 579
 580         return(pRange);
 581 }
 582
 583 // Description:
 584 //
 585 // Arguments:
 586 //
 587 // Return:
 588 //
 589 CAngleAlert const* CPersonalRangeSignaling::GetAngleTo(const Vec3& vPos, bool bUseBoundary) const
 590 {
 591         CAngleAlert const* pAngle = NULL;
 592         float fAngleDiff = -1.0f;
 593
 594         for (int i = 0; i < m_vecAngles.size(); ++i)
 595         {
 596                 bool bInAngle = false;
 597
 598                 if (fAngleDiff < 0.0f)
 599                 {
 600                         fAngleDiff = m_vecAngles[i]->GetAngleTo(vPos);
 601                 }
 602
 603                 if (bUseBoundary == true)
 604                 {
 605                         bInAngle = (m_vecAngles[i]->CheckPlusBoundary(fAngleDiff) == true);
 606                 }
 607                 else
 608                 {
 609                         bInAngle = (m_vecAngles[i]->Check(fAngleDiff) == true);
 610                 }
 611
 612                 if (bInAngle == true)
 613                 {
 614                         pAngle = m_vecAngles[i];
 615                         break;
 616                 }
 617         }
 618
 619         return(pAngle);
 620 }
 621
 622 // Description:
 623 //
 624 // Arguments:
 625 //
 626 // Return:
 627 //
 628 CRange* CPersonalRangeSignaling::SearchRange(const char* sSignal, const VecRanges& vecRangeList) const
 629 {
 630         CRange* pRange = NULL;
 631
 632         for (int i = 0; i < vecRangeList.size(); ++i)
 633         {
 634                 if (vecRangeList[i]->GetSignal().compareNoCase(sSignal) == 0)
 635                 {
 636                         pRange = vecRangeList[i];
 637                         break;
 638                 }
 639         }
 640
 641         return(pRange);
 642 }
 643
 644 // Description:
 645 //
 646 // Arguments:
 647 //
 648 // Return:
 649 //
 650 CAngleAlert* CPersonalRangeSignaling::SearchAngle(const char* sSignal) const
 651 {
 652         CAngleAlert* pAngle = NULL;
 653
 654         for (int i = 0; i < m_vecAngles.size(); ++i)
 655         {
 656                 if (m_vecAngles[i]->GetSignal().compareNoCase(sSignal) == 0)
 657                 {
 658                         pAngle = m_vecAngles[i];
 659                         break;
 660                 }
 661         }
 662
 663         return(pAngle);
 664 }
 665
 666 // Description:
 667 //
 668 // Arguments:
 669 //
 670 // Return:
 671 //
 672 void CPersonalRangeSignaling::DebugDraw(uint32 uOrder) const
 673 {
 674         CRY_ASSERT(m_bInit == true);
 675
 676         float x = 120.0f;
 677         float y = 100.0f + (float(uOrder) * 10.0f);
 678         float r = 0.0f;
 679         float g = 8.0f;
 680         float b = 0.0f;
 681
 682         char txt[512] = "\0";
 683
 684         //cry_sprintf( txt, "%s > %s: %0.1f / %0.1f", GetActor()->GetEntity()->GetName(), m_sSignal.c_str(), m_fTimer, m_fRateMax );
 685         //IRenderAuxText::Draw2dLabel( x,y, 13.0f, ColorF(r,g,b), false, "%s", txt);
 686 }
 687
 688 // Description:
 689 //
 690 // Arguments:
 691 //
 692 // Return:
 693 //
 694 IAIObject const* CPersonalRangeSignaling::GetEntityAI(EntityId entityId) const
 695 {
 696         IAIObject const* pAIObject = NULL;
 697
 698         IEntity* pEntity = gEnv->pEntitySystem->GetEntity(entityId);
 699         if (pEntity)
 700         {
 701                 pAIObject = pEntity->GetAI();
 702         }
 703
 704         return pAIObject;
 705 }
 706
 707 // Description:
 708 //
 709 // Arguments:
 710 //
 711 // Return:
 712 //
 713 IAIActorProxy* CPersonalRangeSignaling::GetEntityAIProxy(EntityId entityId) const
 714 {
 715         IAIActorProxy* pAIProxy = NULL;
 716
 717         IAIObject const* pAIObject = GetEntityAI(m_EntityId);
 718         if (pAIObject)
 719         {
 720                 pAIProxy = pAIObject->GetProxy();
 721         }
 722
 723         return pAIProxy;
 724 }
 725
 726 // Description:
 727 //
 728 // Arguments:
 729 //
 730 // Return:
 731 //
 732 void CPersonalRangeSignaling::SetListener(bool bAdd)
 733 {
 734         CAIProxy* pAIProxy = static_cast<CAIProxy*>(GetEntityAIProxy(m_EntityId));
 735         if (pAIProxy)
 736         {
 737                 if (bAdd)
 738                         pAIProxy->AddListener(this);
 739                 else
 740                         pAIProxy->RemoveListener(this);
 741         }
 742 }
 743
 744 // Description:
 745 //
 746 // Arguments:
 747 //
 748 // Return:
 749 //
 750 void CPersonalRangeSignaling::OnAIProxyEnabled(bool bEnabled)
 751 {
 752         if (bEnabled)
 753         {
 754                 Reset();
 755                 SetEnabled(true);
 756         }
 757         else
 758         {
 759                 SetEnabled(false);
 760         }
 761 }