src/game/GridNotifiers.h

   1 /*
   2  * Copyright (C) 2005-2009 MaNGOS <http://getmangos.com/>
   3  *
   4  * This program is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License as published by
   6  * the Free Software Foundation; either version 2 of the License, or
   7  * (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 General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write to the Free Software
  16  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  17  */
  18
  19 #ifndef MANGOS_GRIDNOTIFIERS_H
  20 #define MANGOS_GRIDNOTIFIERS_H
  21
  22 #include "ObjectGridLoader.h"
  23 #include "UpdateData.h"
  24 #include <iostream>
  25
  26 #include "Corpse.h"
  27 #include "Object.h"
  28 #include "DynamicObject.h"
  29 #include "GameObject.h"
  30 #include "Player.h"
  31 #include "Unit.h"
  32 #include "CreatureAI.h"
  33
  34 class Player;
  35 //class Map;
  36
  37 namespace MaNGOS
  38 {
  39
  40     struct MANGOS_DLL_DECL PlayerNotifier
  41     {
  42         explicit PlayerNotifier(Player &pl) : i_player(pl) {}
  43         void Visit(PlayerMapType &);
  44         template<class SKIP> void Visit(GridRefManager<SKIP> &) {}
  45         Player &i_player;
  46     };
  47
  48     struct MANGOS_DLL_DECL VisibleNotifier
  49     {
  50         Player &i_player;
  51         UpdateData i_data;
  52         UpdateDataMapType i_data_updates;
  53         Player::ClientGUIDs i_clientGUIDs;
  54         std::set<WorldObject*> i_visibleNow;
  55
  56         explicit VisibleNotifier(Player &player) : i_player(player),i_clientGUIDs(player.m_clientGUIDs) {}
  57         template<class T> void Visit(GridRefManager<T> &m);
  58         void Visit(PlayerMapType &);
  59         void Notify(void);
  60     };
  61
  62     struct MANGOS_DLL_DECL VisibleChangesNotifier
  63     {
  64         WorldObject &i_object;
  65
  66         explicit VisibleChangesNotifier(WorldObject &object) : i_object(object) {}
  67         template<class T> void Visit(GridRefManager<T> &) {}
  68         void Visit(PlayerMapType &);
  69     };
  70
  71     struct MANGOS_DLL_DECL GridUpdater
  72     {
  73         GridType &i_grid;
  74         uint32 i_timeDiff;
  75         GridUpdater(GridType &grid, uint32 diff) : i_grid(grid), i_timeDiff(diff) {}
  76
  77         template<class T> void updateObjects(GridRefManager<T> &m)
  78         {
  79             for(typename GridRefManager<T>::iterator iter = m.begin(); iter != m.end(); ++iter)
  80                 iter->getSource()->Update(i_timeDiff);
  81         }
  82
  83         void Visit(PlayerMapType &m) { updateObjects<Player>(m); }
  84         void Visit(CreatureMapType &m){ updateObjects<Creature>(m); }
  85         void Visit(GameObjectMapType &m) { updateObjects<GameObject>(m); }
  86         void Visit(DynamicObjectMapType &m) { updateObjects<DynamicObject>(m); }
  87         void Visit(CorpseMapType &m) { updateObjects<Corpse>(m); }
  88     };
  89
  90     struct MANGOS_DLL_DECL MessageDeliverer
  91     {
  92         Player &i_player;
  93         WorldPacket *i_message;
  94         bool i_toSelf;
  95         MessageDeliverer(Player &pl, WorldPacket *msg, bool to_self) : i_player(pl), i_message(msg), i_toSelf(to_self) {}
  96         void Visit(PlayerMapType &m);
  97         template<class SKIP> void Visit(GridRefManager<SKIP> &) {}
  98     };
  99
 100     struct MANGOS_DLL_DECL ObjectMessageDeliverer
 101     {
 102         uint32 i_phaseMask;
 103         WorldPacket *i_message;
 104         explicit ObjectMessageDeliverer(WorldObject& obj, WorldPacket *msg)
 105             : i_phaseMask(obj.GetPhaseMask()), i_message(msg) {}
 106         void Visit(PlayerMapType &m);
 107         template<class SKIP> void Visit(GridRefManager<SKIP> &) {}
 108     };
 109
 110     struct MANGOS_DLL_DECL MessageDistDeliverer
 111     {
 112         Player &i_player;
 113         WorldPacket *i_message;
 114         bool i_toSelf;
 115         bool i_ownTeamOnly;
 116         float i_dist;
 117
 118         MessageDistDeliverer(Player &pl, WorldPacket *msg, float dist, bool to_self, bool ownTeamOnly)
 119             : i_player(pl), i_message(msg), i_toSelf(to_self), i_ownTeamOnly(ownTeamOnly), i_dist(dist) {}
 120         void Visit(PlayerMapType &m);
 121         template<class SKIP> void Visit(GridRefManager<SKIP> &) {}
 122     };
 123
 124     struct MANGOS_DLL_DECL ObjectMessageDistDeliverer
 125     {
 126         WorldObject &i_object;
 127         WorldPacket *i_message;
 128         float i_dist;
 129         ObjectMessageDistDeliverer(WorldObject &obj, WorldPacket *msg, float dist) : i_object(obj), i_message(msg), i_dist(dist) {}
 130         void Visit(PlayerMapType &m);
 131         template<class SKIP> void Visit(GridRefManager<SKIP> &) {}
 132     };
 133
 134     struct MANGOS_DLL_DECL ObjectUpdater
 135     {
 136         uint32 i_timeDiff;
 137         explicit ObjectUpdater(const uint32 &diff) : i_timeDiff(diff) {}
 138         template<class T> void Visit(GridRefManager<T> &m);
 139         void Visit(PlayerMapType &) {}
 140         void Visit(CorpseMapType &) {}
 141         void Visit(CreatureMapType &);
 142     };
 143
 144     template<class T>
 145         struct MANGOS_DLL_DECL ObjectAccessorNotifier
 146     {
 147         T *& i_object;
 148
 149         uint64 i_id;
 150         ObjectAccessorNotifier(T * &obj, uint64 id) : i_object(obj), i_id(id)
 151         {
 152             i_object = NULL;
 153         }
 154
 155         void Visit(GridRefManager<T> &m )
 156         {
 157             if( i_object == NULL )
 158             {
 159                 GridRefManager<T> *iter = m.find(i_id);
 160                 if( iter != m.end() )
 161                 {
 162                     assert( iter->second != NULL );
 163                     i_object = iter->second;
 164                 }
 165             }
 166         }
 167
 168         template<class NOT_INTERESTED> void Visit(GridRefManager<NOT_INTERESTED> &) {}
 169     };
 170
 171     struct MANGOS_DLL_DECL PlayerRelocationNotifier
 172     {
 173         Player &i_player;
 174         PlayerRelocationNotifier(Player &pl) : i_player(pl) {}
 175         template<class T> void Visit(GridRefManager<T> &) {}
 176         void Visit(PlayerMapType &);
 177         void Visit(CreatureMapType &);
 178     };
 179
 180     struct MANGOS_DLL_DECL CreatureRelocationNotifier
 181     {
 182         Creature &i_creature;
 183         CreatureRelocationNotifier(Creature &c) : i_creature(c) {}
 184         template<class T> void Visit(GridRefManager<T> &) {}
 185         #ifdef WIN32
 186         template<> void Visit(PlayerMapType &);
 187         #endif
 188     };
 189
 190     struct MANGOS_DLL_DECL DynamicObjectUpdater
 191     {
 192         DynamicObject &i_dynobject;
 193         Unit* i_check;
 194         DynamicObjectUpdater(DynamicObject &dynobject, Unit* caster) : i_dynobject(dynobject)
 195         {
 196             i_check = caster;
 197             Unit* owner = i_check->GetOwner();
 198             if(owner)
 199                 i_check = owner;
 200         }
 201
 202         template<class T> inline void Visit(GridRefManager<T>  &) {}
 203         #ifdef WIN32
 204         template<> inline void Visit<Player>(PlayerMapType &);
 205         template<> inline void Visit<Creature>(CreatureMapType &);
 206         #endif
 207
 208         void VisitHelper(Unit* target);
 209     };
 210
 211     // SEARCHERS & LIST SEARCHERS & WORKERS
 212
 213     // WorldObject searchers & workers
 214
 215     template<class Check>
 216         struct MANGOS_DLL_DECL WorldObjectSearcher
 217     {
 218         uint32 i_phaseMask;
 219         WorldObject* &i_object;
 220         Check &i_check;
 221
 222         WorldObjectSearcher(WorldObject const* searcher, WorldObject* & result, Check& check)
 223             : i_phaseMask(searcher->GetPhaseMask()), i_object(result),i_check(check) {}
 224
 225         void Visit(GameObjectMapType &m);
 226         void Visit(PlayerMapType &m);
 227         void Visit(CreatureMapType &m);
 228         void Visit(CorpseMapType &m);
 229         void Visit(DynamicObjectMapType &m);
 230
 231         template<class NOT_INTERESTED> void Visit(GridRefManager<NOT_INTERESTED> &) {}
 232     };
 233
 234     template<class Check>
 235         struct MANGOS_DLL_DECL WorldObjectListSearcher
 236     {
 237         uint32 i_phaseMask;
 238         std::list<WorldObject*> &i_objects;
 239         Check& i_check;
 240
 241         WorldObjectListSearcher(WorldObject const* searcher, std::list<WorldObject*> &objects, Check & check)
 242             : i_phaseMask(searcher->GetPhaseMask()), i_objects(objects),i_check(check) {}
 243
 244         void Visit(PlayerMapType &m);
 245         void Visit(CreatureMapType &m);
 246         void Visit(CorpseMapType &m);
 247         void Visit(GameObjectMapType &m);
 248         void Visit(DynamicObjectMapType &m);
 249
 250         template<class NOT_INTERESTED> void Visit(GridRefManager<NOT_INTERESTED> &) {}
 251     };
 252
 253     template<class Do>
 254         struct MANGOS_DLL_DECL WorldObjectWorker
 255     {
 256         uint32 i_phaseMask;
 257         Do const& i_do;
 258
 259         WorldObjectWorker(WorldObject const* searcher, Do const& _do)
 260             : i_phaseMask(searcher->GetPhaseMask()), i_do(_do) {}
 261
 262         void Visit(GameObjectMapType &m)
 263         {
 264             for(GameObjectMapType::iterator itr=m.begin(); itr != m.end(); ++itr)
 265                 if(itr->getSource()->InSamePhase(i_phaseMask))
 266                     i_do(itr->getSource());
 267         }
 268
 269         void Visit(PlayerMapType &m)
 270         {
 271             for(PlayerMapType::iterator itr=m.begin(); itr != m.end(); ++itr)
 272                 if(itr->getSource()->InSamePhase(i_phaseMask))
 273                     i_do(itr->getSource());
 274         }
 275         void Visit(CreatureMapType &m)
 276         {
 277             for(CreatureMapType::iterator itr=m.begin(); itr != m.end(); ++itr)
 278                 if(itr->getSource()->InSamePhase(i_phaseMask))
 279                     i_do(itr->getSource());
 280         }
 281
 282         void Visit(CorpseMapType &m)
 283         {
 284             for(CorpseMapType::iterator itr=m.begin(); itr != m.end(); ++itr)
 285                 if(itr->getSource()->InSamePhase(i_phaseMask))
 286                     i_do(itr->getSource());
 287         }
 288
 289         void Visit(DynamicObjectMapType &m)
 290         {
 291             for(DynamicObjectMapType::iterator itr=m.begin(); itr != m.end(); ++itr)
 292                 if(itr->getSource()->InSamePhase(i_phaseMask))
 293                     i_do(itr->getSource());
 294         }
 295
 296         template<class NOT_INTERESTED> void Visit(GridRefManager<NOT_INTERESTED> &) {}
 297     };
 298
 299     // Gameobject searchers
 300
 301     template<class Check>
 302         struct MANGOS_DLL_DECL GameObjectSearcher
 303     {
 304         uint32 i_phaseMask;
 305         GameObject* &i_object;
 306         Check &i_check;
 307
 308         GameObjectSearcher(WorldObject const* searcher, GameObject* & result, Check& check)
 309             : i_phaseMask(searcher->GetPhaseMask()), i_object(result),i_check(check) {}
 310
 311         void Visit(GameObjectMapType &m);
 312
 313         template<class NOT_INTERESTED> void Visit(GridRefManager<NOT_INTERESTED> &) {}
 314     };
 315
 316     // Last accepted by Check GO if any (Check can change requirements at each call)
 317     template<class Check>
 318         struct MANGOS_DLL_DECL GameObjectLastSearcher
 319     {
 320         uint32 i_phaseMask;
 321         GameObject* &i_object;
 322         Check& i_check;
 323
 324         GameObjectLastSearcher(WorldObject const* searcher, GameObject* & result, Check& check)
 325             : i_phaseMask(searcher->GetPhaseMask()), i_object(result), i_check(check) {}
 326
 327         void Visit(GameObjectMapType &m);
 328
 329         template<class NOT_INTERESTED> void Visit(GridRefManager<NOT_INTERESTED> &) {}
 330     };
 331
 332     template<class Check>
 333         struct MANGOS_DLL_DECL GameObjectListSearcher
 334     {
 335         uint32 i_phaseMask;
 336         std::list<GameObject*> &i_objects;
 337         Check& i_check;
 338
 339         GameObjectListSearcher(WorldObject const* searcher, std::list<GameObject*> &objects, Check & check)
 340             : i_phaseMask(searcher->GetPhaseMask()), i_objects(objects), i_check(check) {}
 341
 342         void Visit(GameObjectMapType &m);
 343
 344         template<class NOT_INTERESTED> void Visit(GridRefManager<NOT_INTERESTED> &) {}
 345     };
 346
 347     // Unit searchers
 348
 349     // First accepted by Check Unit if any
 350     template<class Check>
 351         struct MANGOS_DLL_DECL UnitSearcher
 352     {
 353         uint32 i_phaseMask;
 354         Unit* &i_object;
 355         Check & i_check;
 356
 357         UnitSearcher(WorldObject const* searcher, Unit* & result, Check & check)
 358             : i_phaseMask(searcher->GetPhaseMask()), i_object(result),i_check(check) {}
 359
 360         void Visit(CreatureMapType &m);
 361         void Visit(PlayerMapType &m);
 362
 363         template<class NOT_INTERESTED> void Visit(GridRefManager<NOT_INTERESTED> &) {}
 364     };
 365
 366     // Last accepted by Check Unit if any (Check can change requirements at each call)
 367     template<class Check>
 368         struct MANGOS_DLL_DECL UnitLastSearcher
 369     {
 370         uint32 i_phaseMask;
 371         Unit* &i_object;
 372         Check & i_check;
 373
 374         UnitLastSearcher(WorldObject const* searcher, Unit* & result, Check & check)
 375             : i_phaseMask(searcher->GetPhaseMask()), i_object(result),i_check(check) {}
 376
 377         void Visit(CreatureMapType &m);
 378         void Visit(PlayerMapType &m);
 379
 380         template<class NOT_INTERESTED> void Visit(GridRefManager<NOT_INTERESTED> &) {}
 381     };
 382
 383     // All accepted by Check units if any
 384     template<class Check>
 385         struct MANGOS_DLL_DECL UnitListSearcher
 386     {
 387         uint32 i_phaseMask;
 388         std::list<Unit*> &i_objects;
 389         Check& i_check;
 390
 391         UnitListSearcher(WorldObject const* searcher, std::list<Unit*> &objects, Check & check)
 392             : i_phaseMask(searcher->GetPhaseMask()), i_objects(objects),i_check(check) {}
 393
 394         void Visit(PlayerMapType &m);
 395         void Visit(CreatureMapType &m);
 396
 397         template<class NOT_INTERESTED> void Visit(GridRefManager<NOT_INTERESTED> &) {}
 398     };
 399
 400     // Creature searchers
 401
 402     template<class Check>
 403         struct MANGOS_DLL_DECL CreatureSearcher
 404     {
 405         uint32 i_phaseMask;
 406         Creature* &i_object;
 407         Check & i_check;
 408
 409         CreatureSearcher(WorldObject const* searcher, Creature* & result, Check & check)
 410             : i_phaseMask(searcher->GetPhaseMask()), i_object(result),i_check(check) {}
 411
 412         void Visit(CreatureMapType &m);
 413
 414         template<class NOT_INTERESTED> void Visit(GridRefManager<NOT_INTERESTED> &) {}
 415     };
 416
 417     // Last accepted by Check Creature if any (Check can change requirements at each call)
 418     template<class Check>
 419         struct MANGOS_DLL_DECL CreatureLastSearcher
 420     {
 421         uint32 i_phaseMask;
 422         Creature* &i_object;
 423         Check & i_check;
 424
 425         CreatureLastSearcher(WorldObject const* searcher, Creature* & result, Check & check)
 426             : i_phaseMask(searcher->GetPhaseMask()), i_object(result),i_check(check) {}
 427
 428         void Visit(CreatureMapType &m);
 429
 430         template<class NOT_INTERESTED> void Visit(GridRefManager<NOT_INTERESTED> &) {}
 431     };
 432
 433     template<class Check>
 434         struct MANGOS_DLL_DECL CreatureListSearcher
 435     {
 436         uint32 i_phaseMask;
 437         std::list<Creature*> &i_objects;
 438         Check& i_check;
 439
 440         CreatureListSearcher(WorldObject const* searcher, std::list<Creature*> &objects, Check & check)
 441             : i_phaseMask(searcher->GetPhaseMask()), i_objects(objects),i_check(check) {}
 442
 443         void Visit(CreatureMapType &m);
 444
 445         template<class NOT_INTERESTED> void Visit(GridRefManager<NOT_INTERESTED> &) {}
 446     };
 447
 448     template<class Do>
 449     struct MANGOS_DLL_DECL CreatureWorker
 450     {
 451         uint32 i_phaseMask;
 452         Do& i_do;
 453
 454         CreatureWorker(WorldObject const* searcher, Do& _do)
 455             : i_phaseMask(searcher->GetPhaseMask()), i_do(_do) {}
 456
 457         void Visit(CreatureMapType &m)
 458         {
 459             for(CreatureMapType::iterator itr=m.begin(); itr != m.end(); ++itr)
 460                 if(itr->getSource()->InSamePhase(i_phaseMask))
 461                     i_do(itr->getSource());
 462         }
 463
 464         template<class NOT_INTERESTED> void Visit(GridRefManager<NOT_INTERESTED> &) {}
 465     };
 466
 467     // Player searchers
 468
 469     template<class Check>
 470     struct MANGOS_DLL_DECL PlayerSearcher
 471     {
 472         uint32 i_phaseMask;
 473         Player* &i_object;
 474         Check & i_check;
 475
 476         PlayerSearcher(WorldObject const* searcher, Player* & result, Check & check)
 477             : i_phaseMask(searcher->GetPhaseMask()), i_object(result),i_check(check) {}
 478
 479         void Visit(PlayerMapType &m);
 480
 481         template<class NOT_INTERESTED> void Visit(GridRefManager<NOT_INTERESTED> &) {}
 482     };
 483
 484     template<class Do>
 485     struct MANGOS_DLL_DECL PlayerWorker
 486     {
 487         uint32 i_phaseMask;
 488         Do& i_do;
 489
 490         PlayerWorker(WorldObject const* searcher, Do& _do)
 491             : i_phaseMask(searcher->GetPhaseMask()), i_do(_do) {}
 492
 493         void Visit(PlayerMapType &m)
 494         {
 495             for(PlayerMapType::iterator itr=m.begin(); itr != m.end(); ++itr)
 496                 if(itr->getSource()->InSamePhase(i_phaseMask))
 497                     i_do(itr->getSource());
 498         }
 499
 500         template<class NOT_INTERESTED> void Visit(GridRefManager<NOT_INTERESTED> &) {}
 501     };
 502
 503     template<class Do>
 504     struct MANGOS_DLL_DECL PlayerDistWorker
 505     {
 506         WorldObject const* i_searcher;
 507         float i_dist;
 508         Do& i_do;
 509
 510         PlayerDistWorker(WorldObject const* searcher, float _dist, Do& _do)
 511             : i_searcher(searcher), i_dist(_dist), i_do(_do) {}
 512
 513         void Visit(PlayerMapType &m)
 514         {
 515             for(PlayerMapType::iterator itr=m.begin(); itr != m.end(); ++itr)
 516                 if (itr->getSource()->InSamePhase(i_searcher) && itr->getSource()->IsWithinDist(i_searcher,i_dist))
 517                     i_do(itr->getSource());
 518         }
 519
 520         template<class NOT_INTERESTED> void Visit(GridRefManager<NOT_INTERESTED> &) {}
 521     };
 522
 523     // CHECKS && DO classes
 524
 525     // WorldObject check classes
 526     class RaiseDeadObjectCheck
 527     {
 528         public:
 529             RaiseDeadObjectCheck(Unit* funit, float range) : i_funit(funit), i_range(range) {}
 530             bool operator()(Creature* u)
 531             {
 532                 if (i_funit->GetTypeId()!=TYPEID_PLAYER || !((Player*)i_funit)->isHonorOrXPTarget(u) ||
 533                     u->getDeathState() != CORPSE || u->isDeadByDefault() || u->isInFlight() ||
 534                     ( u->GetCreatureTypeMask() & (1 << (CREATURE_TYPE_HUMANOID-1)) )==0 ||
 535                     (u->GetDisplayId() != u->GetNativeDisplayId()))
 536                     return false;
 537
 538                 return i_funit->IsWithinDistInMap(u, i_range);
 539             }
 540             template<class NOT_INTERESTED> bool operator()(NOT_INTERESTED*) { return false; }
 541         private:
 542             Unit* const i_funit;
 543             float i_range;
 544     };
 545
 546     class ExplodeCorpseObjectCheck
 547     {
 548         public:
 549             ExplodeCorpseObjectCheck(Unit* funit, float range) : i_funit(funit), i_range(range) {}
 550             bool operator()(Player* u)
 551             {
 552                 if (u->getDeathState()!=CORPSE || u->isInFlight() ||
 553                     u->HasAuraType(SPELL_AURA_GHOST) || (u->GetDisplayId() != u->GetNativeDisplayId()))
 554                     return false;
 555
 556                 return i_funit->IsWithinDistInMap(u, i_range);
 557             }
 558             bool operator()(Creature* u)
 559             {
 560                 if (u->getDeathState()!=CORPSE || u->isInFlight() || u->isDeadByDefault() ||
 561                     (u->GetDisplayId() != u->GetNativeDisplayId()) ||
 562                     (u->GetCreatureTypeMask() & CREATURE_TYPEMASK_MECHANICAL_OR_ELEMENTAL)!=0)
 563                     return false;
 564
 565                 return i_funit->IsWithinDistInMap(u, i_range);
 566             }
 567             template<class NOT_INTERESTED> bool operator()(NOT_INTERESTED*) { return false; }
 568         private:
 569             Unit* const i_funit;
 570             float i_range;
 571     };
 572
 573     class CannibalizeObjectCheck
 574     {
 575         public:
 576             CannibalizeObjectCheck(Unit* funit, float range) : i_funit(funit), i_range(range) {}
 577             bool operator()(Player* u)
 578             {
 579                 if( i_funit->IsFriendlyTo(u) || u->isAlive() || u->isInFlight() )
 580                     return false;
 581
 582                 return i_funit->IsWithinDistInMap(u, i_range);
 583             }
 584             bool operator()(Corpse* u);
 585             bool operator()(Creature* u)
 586             {
 587                 if (i_funit->IsFriendlyTo(u) || u->isAlive() || u->isInFlight() ||
 588                     (u->GetCreatureTypeMask() & CREATURE_TYPEMASK_HUMANOID_OR_UNDEAD)==0)
 589                     return false;
 590
 591                 return i_funit->IsWithinDistInMap(u, i_range);
 592             }
 593             template<class NOT_INTERESTED> bool operator()(NOT_INTERESTED*) { return false; }
 594         private:
 595             Unit* const i_funit;
 596             float i_range;
 597     };
 598
 599     // WorldObject do classes
 600
 601     class RespawnDo
 602     {
 603         public:
 604             RespawnDo() {}
 605             void operator()(Creature* u) const { u->Respawn(); }
 606             void operator()(GameObject* u) const { u->Respawn(); }
 607             void operator()(WorldObject*) const {}
 608             void operator()(Corpse*) const {}
 609     };
 610
 611     // GameObject checks
 612
 613     class GameObjectFocusCheck
 614     {
 615         public:
 616             GameObjectFocusCheck(Unit const* unit,uint32 focusId) : i_unit(unit), i_focusId(focusId) {}
 617             bool operator()(GameObject* go) const
 618             {
 619                 if(go->GetGOInfo()->type != GAMEOBJECT_TYPE_SPELL_FOCUS)
 620                     return false;
 621
 622                 if(go->GetGOInfo()->spellFocus.focusId != i_focusId)
 623                     return false;
 624
 625                 float dist = go->GetGOInfo()->spellFocus.dist;
 626
 627                 return go->IsWithinDistInMap(i_unit, dist);
 628             }
 629         private:
 630             Unit const* i_unit;
 631             uint32 i_focusId;
 632     };
 633
 634     // Find the nearest Fishing hole and return true only if source object is in range of hole
 635     class NearestGameObjectFishingHole
 636     {
 637         public:
 638             NearestGameObjectFishingHole(WorldObject const& obj, float range) : i_obj(obj), i_range(range) {}
 639             bool operator()(GameObject* go)
 640             {
 641                 if(go->GetGOInfo()->type == GAMEOBJECT_TYPE_FISHINGHOLE && go->isSpawned() && i_obj.IsWithinDistInMap(go, i_range) && i_obj.IsWithinDistInMap(go, go->GetGOInfo()->fishinghole.radius))
 642                 {
 643                     i_range = i_obj.GetDistance(go);
 644                     return true;
 645                 }
 646                 return false;
 647             }
 648             float GetLastRange() const { return i_range; }
 649         private:
 650             WorldObject const& i_obj;
 651             float  i_range;
 652
 653             // prevent clone
 654             NearestGameObjectFishingHole(NearestGameObjectFishingHole const&);
 655     };
 656
 657     // Success at unit in range, range update for next check (this can be use with GameobjectLastSearcher to find nearest GO)
 658     class NearestGameObjectEntryInObjectRangeCheck
 659     {
 660         public:
 661             NearestGameObjectEntryInObjectRangeCheck(WorldObject const& obj,uint32 entry, float range) : i_obj(obj), i_entry(entry), i_range(range) {}
 662             bool operator()(GameObject* go)
 663             {
 664                 if(go->GetEntry() == i_entry && i_obj.IsWithinDistInMap(go, i_range))
 665                 {
 666                     i_range = i_obj.GetDistance(go);        // use found GO range as new range limit for next check
 667                     return true;
 668                 }
 669                 return false;
 670             }
 671             float GetLastRange() const { return i_range; }
 672         private:
 673             WorldObject const& i_obj;
 674             uint32 i_entry;
 675             float  i_range;
 676
 677             // prevent clone this object
 678             NearestGameObjectEntryInObjectRangeCheck(NearestGameObjectEntryInObjectRangeCheck const&);
 679     };
 680
 681     class GameObjectWithDbGUIDCheck
 682     {
 683         public:
 684             GameObjectWithDbGUIDCheck(WorldObject const& obj,uint32 db_guid) : i_obj(obj), i_db_guid(db_guid) {}
 685             bool operator()(GameObject const* go) const
 686             {
 687                 return go->GetDBTableGUIDLow() == i_db_guid;
 688             }
 689         private:
 690             WorldObject const& i_obj;
 691             uint32 i_db_guid;
 692     };
 693
 694     // Unit checks
 695
 696     class MostHPMissingInRange
 697     {
 698         public:
 699             MostHPMissingInRange(Unit const* obj, float range, uint32 hp) : i_obj(obj), i_range(range), i_hp(hp) {}
 700             bool operator()(Unit* u)
 701             {
 702                 if(u->isAlive() && u->isInCombat() && !i_obj->IsHostileTo(u) && i_obj->IsWithinDistInMap(u, i_range) && u->GetMaxHealth() - u->GetHealth() > i_hp)
 703                 {
 704                     i_hp = u->GetMaxHealth() - u->GetHealth();
 705                     return true;
 706                 }
 707                 return false;
 708             }
 709         private:
 710             Unit const* i_obj;
 711             float i_range;
 712             uint32 i_hp;
 713     };
 714
 715     class FriendlyCCedInRange
 716     {
 717         public:
 718             FriendlyCCedInRange(Unit const* obj, float range) : i_obj(obj), i_range(range) {}
 719             bool operator()(Unit* u)
 720             {
 721                 if(u->isAlive() && u->isInCombat() && !i_obj->IsHostileTo(u) && i_obj->IsWithinDistInMap(u, i_range) &&
 722                     (u->isFeared() || u->isCharmed() || u->isFrozen() || u->hasUnitState(UNIT_STAT_STUNNED | UNIT_STAT_CONFUSED | UNIT_STAT_DIED)))
 723                 {
 724                     return true;
 725                 }
 726                 return false;
 727             }
 728         private:
 729             Unit const* i_obj;
 730             float i_range;
 731     };
 732
 733     class FriendlyMissingBuffInRange
 734     {
 735         public:
 736             FriendlyMissingBuffInRange(Unit const* obj, float range, uint32 spellid) : i_obj(obj), i_range(range), i_spell(spellid) {}
 737             bool operator()(Unit* u)
 738             {
 739                 if(u->isAlive() && u->isInCombat() && !i_obj->IsHostileTo(u) && i_obj->IsWithinDistInMap(u, i_range) &&
 740                     !(u->HasAura(i_spell, 0) || u->HasAura(i_spell, 1) || u->HasAura(i_spell, 2)))
 741                 {
 742                     return true;
 743                 }
 744                 return false;
 745             }
 746         private:
 747             Unit const* i_obj;
 748             float i_range;
 749             uint32 i_spell;
 750     };
 751
 752     class AnyUnfriendlyUnitInObjectRangeCheck
 753     {
 754         public:
 755             AnyUnfriendlyUnitInObjectRangeCheck(WorldObject const* obj, Unit const* funit, float range) : i_obj(obj), i_funit(funit), i_range(range) {}
 756             bool operator()(Unit* u)
 757             {
 758                 if(u->isAlive() && i_obj->IsWithinDistInMap(u, i_range) && !i_funit->IsFriendlyTo(u))
 759                     return true;
 760                 else
 761                     return false;
 762             }
 763         private:
 764             WorldObject const* i_obj;
 765             Unit const* i_funit;
 766             float i_range;
 767     };
 768
 769     class AnyUnfriendlyVisibleUnitInObjectRangeCheck
 770     {
 771         public:
 772             AnyUnfriendlyVisibleUnitInObjectRangeCheck(WorldObject const* obj, Unit const* funit, float range)
 773                 : i_obj(obj), i_funit(funit), i_range(range) {}
 774
 775             bool operator()(Unit* u)
 776             {
 777                 return u->isAlive()
 778                     && i_obj->IsWithinDistInMap(u, i_range)
 779                     && !i_funit->IsFriendlyTo(u)
 780                     && u->isVisibleForOrDetect(i_funit,i_funit,false);
 781             }
 782         private:
 783             WorldObject const* i_obj;
 784             Unit const* i_funit;
 785             float i_range;
 786     };
 787
 788     class AnyFriendlyUnitInObjectRangeCheck
 789     {
 790         public:
 791             AnyFriendlyUnitInObjectRangeCheck(WorldObject const* obj, Unit const* funit, float range) : i_obj(obj), i_funit(funit), i_range(range) {}
 792             bool operator()(Unit* u)
 793             {
 794                 if(u->isAlive() && i_obj->IsWithinDistInMap(u, i_range) && i_funit->IsFriendlyTo(u))
 795                     return true;
 796                 else
 797                     return false;
 798             }
 799         private:
 800             WorldObject const* i_obj;
 801             Unit const* i_funit;
 802             float i_range;
 803     };
 804
 805     class AnyUnitInObjectRangeCheck
 806     {
 807         public:
 808             AnyUnitInObjectRangeCheck(WorldObject const* obj, float range) : i_obj(obj), i_range(range) {}
 809             bool operator()(Unit* u)
 810             {
 811                 if(u->isAlive() && i_obj->IsWithinDistInMap(u, i_range))
 812                     return true;
 813
 814                 return false;
 815             }
 816         private:
 817             WorldObject const* i_obj;
 818             float i_range;
 819     };
 820
 821     // Success at unit in range, range update for next check (this can be use with UnitLastSearcher to find nearest unit)
 822     class NearestAttackableUnitInObjectRangeCheck
 823     {
 824         public:
 825             NearestAttackableUnitInObjectRangeCheck(WorldObject const* obj, Unit const* funit, float range) : i_obj(obj), i_funit(funit), i_range(range) {}
 826             bool operator()(Unit* u)
 827             {
 828                 if( u->isTargetableForAttack() && i_obj->IsWithinDistInMap(u, i_range) &&
 829                     !i_funit->IsFriendlyTo(u) && u->isVisibleForOrDetect(i_funit,i_funit,false)  )
 830                 {
 831                     i_range = i_obj->GetDistance(u);        // use found unit range as new range limit for next check
 832                     return true;
 833                 }
 834
 835                 return false;
 836             }
 837         private:
 838             WorldObject const* i_obj;
 839             Unit const* i_funit;
 840             float i_range;
 841
 842             // prevent clone this object
 843             NearestAttackableUnitInObjectRangeCheck(NearestAttackableUnitInObjectRangeCheck const&);
 844     };
 845
 846     class AnyAoETargetUnitInObjectRangeCheck
 847     {
 848         public:
 849             AnyAoETargetUnitInObjectRangeCheck(WorldObject const* obj, Unit const* funit, float range, bool hitHidden = true)
 850                 : i_obj(obj), i_funit(funit), i_range(range), i_hitHidden(hitHidden)
 851             {
 852                 Unit const* check = i_funit;
 853                 Unit const* owner = i_funit->GetOwner();
 854                 if(owner)
 855                     check = owner;
 856                 i_targetForPlayer = ( check->GetTypeId()==TYPEID_PLAYER );
 857             }
 858             bool operator()(Unit* u)
 859             {
 860                 // Check contains checks for: live, non-selectable, non-attackable flags, flight check and GM check, ignore totems
 861                 if (!u->isTargetableForAttack())
 862                     return false;
 863                 if(u->GetTypeId()==TYPEID_UNIT && ((Creature*)u)->isTotem())
 864                     return false;
 865                 if (!i_hitHidden && !u->isVisibleForOrDetect(i_funit, i_funit, false))
 866                     return false;
 867
 868                 if(( i_targetForPlayer ? !i_funit->IsFriendlyTo(u) : i_funit->IsHostileTo(u) )&& i_obj->IsWithinDistInMap(u, i_range))
 869                     return true;
 870
 871                 return false;
 872             }
 873         private:
 874             bool i_targetForPlayer;
 875             WorldObject const* i_obj;
 876             Unit const* i_funit;
 877             float i_range;
 878             bool i_hitHidden;
 879     };
 880
 881     // do attack at call of help to friendly crearture
 882     class CallOfHelpCreatureInRangeDo
 883     {
 884         public:
 885             CallOfHelpCreatureInRangeDo(Unit* funit, Unit* enemy, float range)
 886                 : i_funit(funit), i_enemy(enemy), i_range(range)
 887             {}
 888             void operator()(Creature* u)
 889             {
 890                 if (u == i_funit)
 891                     return;
 892
 893                 if (!u->CanAssistTo(i_funit, i_enemy, false))
 894                     return;
 895
 896                 // too far
 897                 if (!i_funit->IsWithinDistInMap(u, i_range))
 898                     return;
 899
 900                 // only if see assisted creature
 901                 if (!i_funit->IsWithinLOSInMap(u))
 902                     return;
 903
 904                 if (u->AI())
 905                     u->AI()->AttackStart(i_enemy);
 906             }
 907         private:
 908             Unit* const i_funit;
 909             Unit* const i_enemy;
 910             float i_range;
 911     };
 912
 913     struct AnyDeadUnitCheck
 914     {
 915         bool operator()(Unit* u) { return !u->isAlive(); }
 916     };
 917
 918     struct AnyStealthedCheck
 919     {
 920         bool operator()(Unit* u) { return u->GetVisibility()==VISIBILITY_GROUP_STEALTH; }
 921     };
 922
 923     // Creature checks
 924
 925     class InAttackDistanceFromAnyHostileCreatureCheck
 926     {
 927         public:
 928             explicit InAttackDistanceFromAnyHostileCreatureCheck(Unit* funit) : i_funit(funit) {}
 929             bool operator()(Creature* u)
 930             {
 931                 if(u->isAlive() && u->IsHostileTo(i_funit) && i_funit->IsWithinDistInMap(u, u->GetAttackDistance(i_funit)))
 932                     return true;
 933
 934                 return false;
 935             }
 936         private:
 937             Unit* const i_funit;
 938     };
 939
 940     class AnyAssistCreatureInRangeCheck
 941     {
 942         public:
 943             AnyAssistCreatureInRangeCheck(Unit* funit, Unit* enemy, float range)
 944                 : i_funit(funit), i_enemy(enemy), i_range(range)
 945             {
 946             }
 947             bool operator()(Creature* u)
 948             {
 949                 if(u == i_funit)
 950                     return false;
 951
 952                 if ( !u->CanAssistTo(i_funit, i_enemy) )
 953                     return false;
 954
 955                 // too far
 956                 if( !i_funit->IsWithinDistInMap(u, i_range) )
 957                     return false;
 958
 959                 // only if see assisted creature
 960                 if( !i_funit->IsWithinLOSInMap(u) )
 961                     return false;
 962
 963                 return true;
 964             }
 965         private:
 966             Unit* const i_funit;
 967             Unit* const i_enemy;
 968             float i_range;
 969     };
 970
 971     class NearestAssistCreatureInCreatureRangeCheck
 972     {
 973         public:
 974             NearestAssistCreatureInCreatureRangeCheck(Creature* obj, Unit* enemy, float range)
 975                 : i_obj(obj), i_enemy(enemy), i_range(range) {}
 976
 977             bool operator()(Creature* u)
 978             {
 979                 if(u == i_obj)
 980                     return false;
 981                 if(!u->CanAssistTo(i_obj,i_enemy))
 982                     return false;
 983
 984                 if(!i_obj->IsWithinDistInMap(u, i_range))
 985                     return false;
 986
 987                 if(!i_obj->IsWithinLOSInMap(u))
 988                     return false;
 989
 990                 i_range = i_obj->GetDistance(u);            // use found unit range as new range limit for next check
 991                 return true;
 992             }
 993             float GetLastRange() const { return i_range; }
 994         private:
 995             Creature* const i_obj;
 996             Unit* const i_enemy;
 997             float  i_range;
 998
 999             // prevent clone this object
1000             NearestAssistCreatureInCreatureRangeCheck(NearestAssistCreatureInCreatureRangeCheck const&);
1001     };
1002
1003     // Success at unit in range, range update for next check (this can be use with CreatureLastSearcher to find nearest creature)
1004     class NearestCreatureEntryWithLiveStateInObjectRangeCheck
1005     {
1006         public:
1007             NearestCreatureEntryWithLiveStateInObjectRangeCheck(WorldObject const& obj,uint32 entry, bool alive, float range)
1008                 : i_obj(obj), i_entry(entry), i_alive(alive), i_range(range) {}
1009
1010             bool operator()(Creature* u)
1011             {
1012                 if(u->GetEntry() == i_entry && u->isAlive()==i_alive && i_obj.IsWithinDistInMap(u, i_range))
1013                 {
1014                     i_range = i_obj.GetDistance(u);         // use found unit range as new range limit for next check
1015                     return true;
1016                 }
1017                 return false;
1018             }
1019             float GetLastRange() const { return i_range; }
1020         private:
1021             WorldObject const& i_obj;
1022             uint32 i_entry;
1023             bool   i_alive;
1024             float  i_range;
1025
1026             // prevent clone this object
1027             NearestCreatureEntryWithLiveStateInObjectRangeCheck(NearestCreatureEntryWithLiveStateInObjectRangeCheck const&);
1028     };
1029
1030     class AnyPlayerInObjectRangeCheck
1031     {
1032     public:
1033         AnyPlayerInObjectRangeCheck(WorldObject const* obj, float range) : i_obj(obj), i_range(range) {}
1034         bool operator()(Player* u)
1035         {
1036             if(u->isAlive() && i_obj->IsWithinDistInMap(u, i_range))
1037                 return true;
1038
1039             return false;
1040         }
1041     private:
1042         WorldObject const* i_obj;
1043         float i_range;
1044     };
1045
1046     // Player checks and do
1047
1048     // Prepare using Builder localized packets with caching and send to player
1049     template<class Builder>
1050     class LocalizedPacketDo
1051     {
1052         public:
1053             explicit LocalizedPacketDo(Builder& builder) : i_builder(builder) {}
1054
1055             ~LocalizedPacketDo()
1056             {
1057                 for(size_t i = 0; i < i_data_cache.size(); ++i)
1058                     delete i_data_cache[i];
1059             }
1060             void operator()( Player* p );
1061
1062         private:
1063             Builder& i_builder;
1064             std::vector<WorldPacket*> i_data_cache;         // 0 = default, i => i-1 locale index
1065     };
1066
1067     // Prepare using Builder localized packets with caching and send to player
1068     template<class Builder>
1069     class LocalizedPacketListDo
1070     {
1071         public:
1072             typedef std::vector<WorldPacket*> WorldPacketList;
1073             explicit LocalizedPacketListDo(Builder& builder) : i_builder(builder) {}
1074
1075             ~LocalizedPacketListDo()
1076             {
1077                 for(size_t i = 0; i < i_data_cache.size(); ++i)
1078                     for(size_t j = 0; j < i_data_cache[i].size(); ++j)
1079                         delete i_data_cache[i][j];
1080             }
1081             void operator()( Player* p );
1082
1083         private:
1084             Builder& i_builder;
1085             std::vector<WorldPacketList> i_data_cache;
1086                                                             // 0 = default, i => i-1 locale index
1087     };
1088
1089     #ifndef WIN32
1090     template<> void PlayerRelocationNotifier::Visit<Creature>(CreatureMapType &);
1091     template<> void PlayerRelocationNotifier::Visit<Player>(PlayerMapType &);
1092     template<> void CreatureRelocationNotifier::Visit<Player>(PlayerMapType &);
1093     template<> void CreatureRelocationNotifier::Visit<Creature>(CreatureMapType &);
1094     template<> inline void DynamicObjectUpdater::Visit<Creature>(CreatureMapType &);
1095     template<> inline void DynamicObjectUpdater::Visit<Player>(PlayerMapType &);
1096     #endif
1097 }
1098 #endif