src/game/GridNotifiers.h

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