Imported MaNGOS revision 6767 from http://mangos.svn.sourceforge.net/svnroot/mangos/trunk/

2025-12-18 19:37:01 +00:00 · 2008-10-14 00:29:20 +02:00 · 2008-10-14 00:29:20 +02:00 · 800ee76535
commit 800ee76535
parent d767495d5b
3322 changed files with 903437 additions and 0 deletions
--- a/src/game/GridNotifiers.h
+++ b/src/game/GridNotifiers.h
@ -0,0 +1,812 @@
+/*
+ * Copyright (C) 2005-2008 MaNGOS <http://getmangos.com/>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#ifndef MANGOS_GRIDNOTIFIERS_H
+#define MANGOS_GRIDNOTIFIERS_H
+
+#include "ObjectGridLoader.h"
+#include "ByteBuffer.h"
+#include "UpdateData.h"
+#include <iostream>
+
+#include "Corpse.h"
+#include "Object.h"
+#include "DynamicObject.h"
+#include "GameObject.h"
+#include "Player.h"
+#include "Unit.h"
+
+class Player;
+//class Map;
+
+namespace MaNGOS
+{
+
+    struct MANGOS_DLL_DECL PlayerNotifier
+    {
+        explicit PlayerNotifier(Player &pl) : i_player(pl) {}
+        void Visit(PlayerMapType &);
+        template<class SKIP> void Visit(GridRefManager<SKIP> &) {}
+        Player &i_player;
+    };
+
+    struct MANGOS_DLL_DECL VisibleNotifier
+    {
+        Player &i_player;
+        UpdateData i_data;
+        UpdateDataMapType i_data_updates;
+        Player::ClientGUIDs i_clientGUIDs;
+        std::set<WorldObject*> i_visibleNow;
+
+        explicit VisibleNotifier(Player &player) : i_player(player),i_clientGUIDs(player.m_clientGUIDs) {}
+        template<class T> void Visit(GridRefManager<T> &m);
+        void Visit(PlayerMapType &);
+        void Notify(void);
+    };
+
+    struct MANGOS_DLL_DECL VisibleChangesNotifier
+    {
+        WorldObject &i_object;
+
+        explicit VisibleChangesNotifier(WorldObject &object) : i_object(object) {}
+        template<class T> void Visit(GridRefManager<T> &) {}
+        void Visit(PlayerMapType &);
+    };
+
+    struct MANGOS_DLL_DECL GridUpdater
+    {
+        GridType &i_grid;
+        uint32 i_timeDiff;
+        GridUpdater(GridType &grid, uint32 diff) : i_grid(grid), i_timeDiff(diff) {}
+
+        template<class T> void updateObjects(GridRefManager<T> &m)
+        {
+            for(typename GridRefManager<T>::iterator iter = m.begin(); iter != m.end(); ++iter)
+                iter->getSource()->Update(i_timeDiff);
+        }
+
+        void Visit(PlayerMapType &m) { updateObjects<Player>(m); }
+        void Visit(CreatureMapType &m){ updateObjects<Creature>(m); }
+        void Visit(GameObjectMapType &m) { updateObjects<GameObject>(m); }
+        void Visit(DynamicObjectMapType &m) { updateObjects<DynamicObject>(m); }
+        void Visit(CorpseMapType &m) { updateObjects<Corpse>(m); }
+    };
+
+    struct MANGOS_DLL_DECL MessageDeliverer
+    {
+        Player &i_player;
+        WorldPacket *i_message;
+        bool i_toSelf;
+        MessageDeliverer(Player &pl, WorldPacket *msg, bool to_self) : i_player(pl), i_message(msg), i_toSelf(to_self) {}
+        void Visit(PlayerMapType &m);
+        template<class SKIP> void Visit(GridRefManager<SKIP> &) {}
+    };
+
+    struct MANGOS_DLL_DECL ObjectMessageDeliverer
+    {
+        WorldPacket *i_message;
+        explicit ObjectMessageDeliverer(WorldPacket *msg) : i_message(msg) {}
+        void Visit(PlayerMapType &m);
+        template<class SKIP> void Visit(GridRefManager<SKIP> &) {}
+    };
+
+    struct MANGOS_DLL_DECL MessageDistDeliverer
+    {
+        Player &i_player;
+        WorldPacket *i_message;
+        bool i_toSelf;
+        bool i_ownTeamOnly;
+        float i_dist;
+        MessageDistDeliverer(Player &pl, WorldPacket *msg, float dist, bool to_self, bool ownTeamOnly) : i_player(pl), i_message(msg), i_dist(dist), i_toSelf(to_self), i_ownTeamOnly(ownTeamOnly) {}
+        void Visit(PlayerMapType &m);
+        template<class SKIP> void Visit(GridRefManager<SKIP> &) {}
+    };
+
+    struct MANGOS_DLL_DECL ObjectMessageDistDeliverer
+    {
+        WorldObject &i_object;
+        WorldPacket *i_message;
+        float i_dist;
+        ObjectMessageDistDeliverer(WorldObject &obj, WorldPacket *msg, float dist) : i_object(obj), i_message(msg), i_dist(dist) {}
+        void Visit(PlayerMapType &m);
+        template<class SKIP> void Visit(GridRefManager<SKIP> &) {}
+    };
+
+    struct MANGOS_DLL_DECL ObjectUpdater
+    {
+        uint32 i_timeDiff;
+        explicit ObjectUpdater(const uint32 &diff) : i_timeDiff(diff) {}
+        template<class T> void Visit(GridRefManager<T> &m);
+        void Visit(PlayerMapType &) {}
+        void Visit(CorpseMapType &) {}
+        void Visit(CreatureMapType &);
+    };
+
+    template<class T>
+        struct MANGOS_DLL_DECL ObjectAccessorNotifier
+    {
+        T *& i_object;
+
+        uint64 i_id;
+        ObjectAccessorNotifier(T * &obj, uint64 id) : i_object(obj), i_id(id)
+        {
+            i_object = NULL;
+        }
+
+        void Visit(GridRefManager<T> &m )
+        {
+            if( i_object == NULL )
+            {
+                GridRefManager<T> *iter = m.find(i_id);
+                if( iter != m.end() )
+                {
+                    assert( iter->second != NULL );
+                    i_object = iter->second;
+                }
+            }
+        }
+
+        template<class NOT_INTERESTED> void Visit(GridRefManager<NOT_INTERESTED> &) {}
+    };
+
+    struct MANGOS_DLL_DECL PlayerRelocationNotifier
+    {
+        Player &i_player;
+        PlayerRelocationNotifier(Player &pl) : i_player(pl) {}
+        template<class T> void Visit(GridRefManager<T> &) {}
+        void Visit(PlayerMapType &);
+        void Visit(CreatureMapType &);
+    };
+
+    struct MANGOS_DLL_DECL CreatureRelocationNotifier
+    {
+        Creature &i_creature;
+        CreatureRelocationNotifier(Creature &c) : i_creature(c) {}
+        template<class T> void Visit(GridRefManager<T> &) {}
+        #ifdef WIN32
+        template<> void Visit(PlayerMapType &);
+        #endif
+    };
+
+    struct MANGOS_DLL_DECL DynamicObjectUpdater
+    {
+        DynamicObject &i_dynobject;
+        Unit* i_check;
+        DynamicObjectUpdater(DynamicObject &dynobject, Unit* caster) : i_dynobject(dynobject)
+        {
+            i_check = caster;
+            Unit* owner = i_check->GetOwner();
+            if(owner)
+                i_check = owner;
+        }
+
+        template<class T> inline void Visit(GridRefManager<T>  &) {}
+        #ifdef WIN32
+        template<> inline void Visit<Player>(PlayerMapType &);
+        template<> inline void Visit<Creature>(CreatureMapType &);
+        #endif
+
+        void VisitHelper(Unit* target);
+    };
+
+    // SEARCHERS & LIST SEARCHERS & WORKERS
+
+    // WorldObject searchers & workers
+
+    template<class Check>
+        struct MANGOS_DLL_DECL WorldObjectSearcher
+    {
+        WorldObject* &i_object;
+        Check &i_check;
+
+        WorldObjectSearcher(WorldObject* & result, Check& check) : i_object(result),i_check(check) {}
+
+        void Visit(GameObjectMapType &m);
+        void Visit(PlayerMapType &m);
+        void Visit(CreatureMapType &m);
+        void Visit(CorpseMapType &m);
+        void Visit(DynamicObjectMapType &m);
+
+        template<class NOT_INTERESTED> void Visit(GridRefManager<NOT_INTERESTED> &) {}
+    };
+
+    template<class Check>
+        struct MANGOS_DLL_DECL WorldObjectListSearcher
+    {
+        std::list<WorldObject*> &i_objects;
+        Check& i_check;
+
+        WorldObjectListSearcher(std::list<WorldObject*> &objects, Check & check) : i_objects(objects),i_check(check) {}
+
+        void Visit(PlayerMapType &m);
+        void Visit(CreatureMapType &m);
+        void Visit(CorpseMapType &m);
+        void Visit(GameObjectMapType &m);
+        void Visit(DynamicObjectMapType &m);
+
+        template<class NOT_INTERESTED> void Visit(GridRefManager<NOT_INTERESTED> &) {}
+    };
+
+    template<class Do>
+        struct MANGOS_DLL_DECL WorldObjectWorker
+    {
+        Do const& i_do;
+
+        explicit WorldObjectWorker(Do const& _do) : i_do(_do) {}
+
+        void Visit(GameObjectMapType &m)
+        {
+            for(GameObjectMapType::iterator itr=m.begin(); itr != m.end(); ++itr)
+                i_do(itr->getSource());
+        }
+
+        void Visit(PlayerMapType &m)
+        {
+            for(PlayerMapType::iterator itr=m.begin(); itr != m.end(); ++itr)
+                i_do(itr->getSource());
+        }
+        void Visit(CreatureMapType &m)
+        {
+            for(CreatureMapType::iterator itr=m.begin(); itr != m.end(); ++itr)
+                i_do(itr->getSource());
+        }
+
+        void Visit(CorpseMapType &m)
+        {
+            for(CorpseMapType::iterator itr=m.begin(); itr != m.end(); ++itr)
+                i_do(itr->getSource());
+        }
+
+        void Visit(DynamicObjectMapType &m)
+        {
+            for(DynamicObjectMapType::iterator itr=m.begin(); itr != m.end(); ++itr)
+                i_do(itr->getSource());
+        }
+
+        template<class NOT_INTERESTED> void Visit(GridRefManager<NOT_INTERESTED> &) {}
+    };
+
+    // Gameobject searchers
+
+    template<class Check>
+        struct MANGOS_DLL_DECL GameObjectSearcher
+    {
+        GameObject* &i_object;
+        Check &i_check;
+
+        GameObjectSearcher(GameObject* & result, Check& check) : i_object(result),i_check(check) {}
+
+        void Visit(GameObjectMapType &m);
+
+        template<class NOT_INTERESTED> void Visit(GridRefManager<NOT_INTERESTED> &) {}
+    };
+
+    // Last accepted by Check GO if any (Check can change requirements at each call)
+    template<class Check>
+        struct MANGOS_DLL_DECL GameObjectLastSearcher
+    {
+        GameObject* &i_object;
+        Check& i_check;
+
+        GameObjectLastSearcher(GameObject* & result, Check& check) : i_object(result),i_check(check) {}
+
+        void Visit(GameObjectMapType &m);
+
+        template<class NOT_INTERESTED> void Visit(GridRefManager<NOT_INTERESTED> &) {}
+    };
+
+    template<class Check>
+        struct MANGOS_DLL_DECL GameObjectListSearcher
+    {
+        std::list<GameObject*> &i_objects;
+        Check& i_check;
+
+        GameObjectListSearcher(std::list<GameObject*> &objects, Check & check) : i_objects(objects),i_check(check) {}
+
+        void Visit(GameObjectMapType &m);
+
+        template<class NOT_INTERESTED> void Visit(GridRefManager<NOT_INTERESTED> &) {}
+    };
+
+    // Unit searchers
+
+    // First accepted by Check Unit if any
+    template<class Check>
+        struct MANGOS_DLL_DECL UnitSearcher
+    {
+        Unit* &i_object;
+        Check & i_check;
+
+        UnitSearcher(Unit* & result, Check & check) : i_object(result),i_check(check) {}
+
+        void Visit(CreatureMapType &m);
+        void Visit(PlayerMapType &m);
+
+        template<class NOT_INTERESTED> void Visit(GridRefManager<NOT_INTERESTED> &) {}
+    };
+
+    // Last accepted by Check Unit if any (Check can change requirements at each call)
+    template<class Check>
+        struct MANGOS_DLL_DECL UnitLastSearcher
+    {
+        Unit* &i_object;
+        Check & i_check;
+
+        UnitLastSearcher(Unit* & result, Check & check) : i_object(result),i_check(check) {}
+
+        void Visit(CreatureMapType &m);
+        void Visit(PlayerMapType &m);
+
+        template<class NOT_INTERESTED> void Visit(GridRefManager<NOT_INTERESTED> &) {}
+    };
+
+    // All accepted by Check units if any
+    template<class Check>
+        struct MANGOS_DLL_DECL UnitListSearcher
+    {
+        std::list<Unit*> &i_objects;
+        Check& i_check;
+
+        UnitListSearcher(std::list<Unit*> &objects, Check & check) : i_objects(objects),i_check(check) {}
+
+        void Visit(PlayerMapType &m);
+        void Visit(CreatureMapType &m);
+
+        template<class NOT_INTERESTED> void Visit(GridRefManager<NOT_INTERESTED> &) {}
+    };
+
+    // Creature searchers
+
+    template<class Check>
+        struct MANGOS_DLL_DECL CreatureSearcher
+    {
+        Creature* &i_object;
+        Check & i_check;
+
+        CreatureSearcher(Creature* & result, Check & check) : i_object(result),i_check(check) {}
+
+        void Visit(CreatureMapType &m);
+
+        template<class NOT_INTERESTED> void Visit(GridRefManager<NOT_INTERESTED> &) {}
+    };
+
+    // Last accepted by Check Creature if any (Check can change requirements at each call)
+    template<class Check>
+        struct MANGOS_DLL_DECL CreatureLastSearcher
+    {
+        Creature* &i_object;
+        Check & i_check;
+
+        CreatureLastSearcher(Creature* & result, Check & check) : i_object(result),i_check(check) {}
+
+        void Visit(CreatureMapType &m);
+
+        template<class NOT_INTERESTED> void Visit(GridRefManager<NOT_INTERESTED> &) {}
+    };
+
+    template<class Check>
+        struct MANGOS_DLL_DECL CreatureListSearcher
+    {
+        std::list<Creature*> &i_objects;
+        Check& i_check;
+
+        CreatureListSearcher(std::list<Creature*> &objects, Check & check) : i_objects(objects),i_check(check) {}
+
+        void Visit(CreatureMapType &m);
+
+        template<class NOT_INTERESTED> void Visit(GridRefManager<NOT_INTERESTED> &) {}
+    };
+
+    // Player searchers
+
+    template<class Check>
+    struct MANGOS_DLL_DECL PlayerSearcher
+    {
+        Player* &i_object;
+        Check & i_check;
+
+        PlayerSearcher(Player* & result, Check & check) : i_object(result),i_check(check) {}
+
+        void Visit(PlayerMapType &m);
+
+        template<class NOT_INTERESTED> void Visit(GridRefManager<NOT_INTERESTED> &) {}
+    };
+
+    template<class Do>
+    struct MANGOS_DLL_DECL PlayerWorker
+    {
+        Do& i_do;
+
+        explicit PlayerWorker(Do& _do) : i_do(_do) {}
+
+        void Visit(PlayerMapType &m)
+        {
+            for(PlayerMapType::iterator itr=m.begin(); itr != m.end(); ++itr)
+                i_do(itr->getSource());
+        }
+
+        template<class NOT_INTERESTED> void Visit(GridRefManager<NOT_INTERESTED> &) {}
+    };
+
+    // CHECKS && DO classes
+
+    // WorldObject check classes
+    class CannibalizeObjectCheck
+    {
+        public:
+            CannibalizeObjectCheck(Unit* funit, float range) : i_funit(funit), i_range(range) {}
+            bool operator()(Player* u)
+            {
+                if( i_funit->IsFriendlyTo(u) || u->isAlive() || u->isInFlight() )
+                    return false;
+
+                if(i_funit->IsWithinDistInMap(u, i_range) )
+                    return true;
+
+                return false;
+            }
+            bool operator()(Corpse* u);
+            bool operator()(Creature* u)
+            {
+                if( i_funit->IsFriendlyTo(u) || u->isAlive() || u->isInFlight() ||
+                    (u->GetCreatureTypeMask() & CREATURE_TYPEMASK_HUMANOID_OR_UNDEAD)==0)
+                    return false;
+
+                if(i_funit->IsWithinDistInMap(u, i_range) )
+                    return true;
+
+                return false;
+            }
+            template<class NOT_INTERESTED> bool operator()(NOT_INTERESTED* u) { return false; }
+        private:
+            Unit* const i_funit;
+            float i_range;
+    };
+
+    // WorldObject do classes
+
+    class RespawnDo
+    {
+        public:
+            RespawnDo() {}
+            void operator()(Creature* u) const { u->Respawn(); }
+            void operator()(GameObject* u) const { u->Respawn(); }
+            void operator()(WorldObject*) const {}
+            void operator()(Corpse*) const {}
+    };
+
+    // GameObject checks
+
+    class GameObjectFocusCheck
+    {
+        public:
+            GameObjectFocusCheck(Unit const* unit,uint32 focusId) : i_unit(unit), i_focusId(focusId) {}
+            bool operator()(GameObject* go) const
+            {
+                if(go->GetGOInfo()->type != GAMEOBJECT_TYPE_SPELL_FOCUS)
+                    return false;
+
+                if(go->GetGOInfo()->spellFocus.focusId != i_focusId)
+                    return false;
+
+                float dist = go->GetGOInfo()->spellFocus.dist;
+
+                return go->IsWithinDistInMap(i_unit, dist);
+            }
+        private:
+            Unit const* i_unit;
+            uint32 i_focusId;
+    };
+
+    // Find the nearest Fishing hole and return true only if source object is in range of hole
+    class NearestGameObjectFishingHole
+    {
+        public:
+            NearestGameObjectFishingHole(WorldObject const& obj, float range) : i_obj(obj), i_range(range) {}
+            bool operator()(GameObject* go)
+            {
+                if(go->GetGOInfo()->type == GAMEOBJECT_TYPE_FISHINGHOLE && go->isSpawned() && i_obj.IsWithinDistInMap(go, i_range) && i_obj.IsWithinDistInMap(go, go->GetGOInfo()->fishinghole.radius))
+                {
+                    i_range = i_obj.GetDistance(go);
+                    return true;
+                }
+                return false;
+            }
+            float GetLastRange() const { return i_range; }
+        private:
+            WorldObject const& i_obj;
+            float  i_range;
+
+            // prevent clone
+            NearestGameObjectFishingHole(NearestGameObjectFishingHole const&);
+    };
+
+    // Success at unit in range, range update for next check (this can be use with GameobjectLastSearcher to find nearest GO)
+    class NearestGameObjectEntryInObjectRangeCheck
+    {
+        public:
+            NearestGameObjectEntryInObjectRangeCheck(WorldObject const& obj,uint32 entry, float range) : i_obj(obj), i_entry(entry), i_range(range) {}
+            bool operator()(GameObject* go)
+            {
+                if(go->GetEntry() == i_entry && i_obj.IsWithinDistInMap(go, i_range))
+                {
+                    i_range = i_obj.GetDistance(go);        // use found GO range as new range limit for next check
+                    return true;
+                }
+                return false;
+            }
+            float GetLastRange() const { return i_range; }
+        private:
+            WorldObject const& i_obj;
+            uint32 i_entry;
+            float  i_range;
+
+            // prevent clone this object
+            NearestGameObjectEntryInObjectRangeCheck(NearestGameObjectEntryInObjectRangeCheck const&);
+    };
+
+    class GameObjectWithDbGUIDCheck
+    {
+        public:
+            GameObjectWithDbGUIDCheck(WorldObject const& obj,uint32 db_guid) : i_obj(obj), i_db_guid(db_guid) {}
+            bool operator()(GameObject const* go) const
+            {
+                return go->GetDBTableGUIDLow() == i_db_guid;
+            }
+        private:
+            WorldObject const& i_obj;
+            uint32 i_db_guid;
+    };
+
+    // Unit checks
+
+    class AnyUnfriendlyUnitInObjectRangeCheck
+    {
+        public:
+            AnyUnfriendlyUnitInObjectRangeCheck(WorldObject const* obj, Unit const* funit, float range) : i_obj(obj), i_funit(funit), i_range(range) {}
+            bool operator()(Unit* u)
+            {
+                if(u->isAlive() && i_obj->IsWithinDistInMap(u, i_range) && !i_funit->IsFriendlyTo(u))
+                    return true;
+                else
+                    return false;
+            }
+        private:
+            WorldObject const* i_obj;
+            Unit const* i_funit;
+            float i_range;
+    };
+
+    class AnyFriendlyUnitInObjectRangeCheck
+    {
+        public:
+            AnyFriendlyUnitInObjectRangeCheck(WorldObject const* obj, Unit const* funit, float range) : i_obj(obj), i_funit(funit), i_range(range) {}
+            bool operator()(Unit* u)
+            {
+                if(u->isAlive() && i_obj->IsWithinDistInMap(u, i_range) && i_funit->IsFriendlyTo(u))
+                    return true;
+                else
+                    return false;
+            }
+        private:
+            WorldObject const* i_obj;
+            Unit const* i_funit;
+            float i_range;
+    };
+
+    class AnyUnitInObjectRangeCheck
+    {
+        public:
+            AnyUnitInObjectRangeCheck(WorldObject const* obj, float range) : i_obj(obj), i_range(range) {}
+            bool operator()(Unit* u)
+            {
+                if(u->isAlive() && i_obj->IsWithinDistInMap(u, i_range))
+                    return true;
+
+                return false;
+            }
+        private:
+            WorldObject const* i_obj;
+            float i_range;
+    };
+
+    // Success at unit in range, range update for next check (this can be use with UnitLastSearcher to find nearest unit)
+    class NearestAttackableUnitInObjectRangeCheck
+    {
+        public:
+            NearestAttackableUnitInObjectRangeCheck(WorldObject const* obj, Unit const* funit, float range) : i_obj(obj), i_funit(funit), i_range(range) {}
+            bool operator()(Unit* u)
+            {
+                if( u->isTargetableForAttack() && i_obj->IsWithinDistInMap(u, i_range) &&
+                    !i_funit->IsFriendlyTo(u) && u->isVisibleForOrDetect(i_funit,false)  )
+                {
+                    i_range = i_obj->GetDistance(u);        // use found unit range as new range limit for next check
+                    return true;
+                }
+
+                return false;
+            }
+        private:
+            WorldObject const* i_obj;
+            Unit const* i_funit;
+            float i_range;
+
+            // prevent clone this object
+            NearestAttackableUnitInObjectRangeCheck(NearestAttackableUnitInObjectRangeCheck const&);
+    };
+
+    class AnyAoETargetUnitInObjectRangeCheck
+    {
+        public:
+            AnyAoETargetUnitInObjectRangeCheck(WorldObject const* obj, Unit const* funit, float range)
+                : i_obj(obj), i_funit(funit), i_range(range)
+            {
+                Unit const* check = i_funit;
+                Unit const* owner = i_funit->GetOwner();
+                if(owner)
+                    check = owner;
+                i_targetForPlayer = ( check->GetTypeId()==TYPEID_PLAYER );
+            }
+            bool operator()(Unit* u)
+            {
+                // Check contains checks for: live, non-selectable, non-attackable flags, flight check and GM check, ignore totems
+                if (!u->isTargetableForAttack())
+                    return false;
+                if(u->GetTypeId()==TYPEID_UNIT && ((Creature*)u)->isTotem())
+                    return false;
+
+                if(( i_targetForPlayer ? !i_funit->IsFriendlyTo(u) : i_funit->IsHostileTo(u) )&& i_obj->IsWithinDistInMap(u, i_range))
+                    return true;
+
+                return false;
+            }
+        private:
+            bool i_targetForPlayer;
+            WorldObject const* i_obj;
+            Unit const* i_funit;
+            float i_range;
+    };
+
+    struct AnyDeadUnitCheck
+    {
+        bool operator()(Unit* u) { return !u->isAlive(); }
+    };
+
+    struct AnyStealthedCheck
+    {
+        bool operator()(Unit* u) { return u->GetVisibility()==VISIBILITY_GROUP_STEALTH; }
+    };
+
+    // Creature checks
+
+    class InAttackDistanceFromAnyHostileCreatureCheck
+    {
+        public:
+            explicit InAttackDistanceFromAnyHostileCreatureCheck(Unit* funit) : i_funit(funit) {}
+            bool operator()(Creature* u)
+            {
+                if(u->isAlive() && u->IsHostileTo(i_funit) && i_funit->IsWithinDistInMap(u, u->GetAttackDistance(i_funit)))
+                    return true;
+
+                return false;
+            }
+        private:
+            Unit* const i_funit;
+    };
+
+    class AnyAssistCreatureInRangeCheck
+    {
+        public:
+            AnyAssistCreatureInRangeCheck(Unit* funit, Unit* enemy, float range)
+                : i_funit(funit), i_enemy(enemy), i_range(range)
+            {
+            }
+            bool operator()(Creature* u)
+            {
+                if(u == i_funit)
+                    return false;
+
+                // we don't need help from zombies :)
+                if( !u->isAlive() )
+                    return false;
+
+                // skip fighting creature
+                if( u->isInCombat() )
+                    return false;
+
+                // only from same creature faction
+                if(u->getFaction() != i_funit->getFaction() )
+                    return false;
+
+                // only free creature
+                if( u->GetCharmerOrOwnerGUID() )
+                    return false;
+
+                // too far
+                if( !i_funit->IsWithinDistInMap(u, i_range) )
+                    return false;
+
+                // skip non hostile to caster enemy creatures
+                if( !u->IsHostileTo(i_enemy) )
+                    return false;
+
+                // only if see assisted creature
+                if(!u->IsWithinLOSInMap(i_funit) )
+                    return false;
+
+                return true;
+            }
+        private:
+            Unit* const i_funit;
+            Unit* const i_enemy;
+            float i_range;
+    };
+
+    // Success at unit in range, range update for next check (this can be use with CreatureLastSearcher to find nearest creature)
+    class NearestCreatureEntryWithLiveStateInObjectRangeCheck
+    {
+        public:
+            NearestCreatureEntryWithLiveStateInObjectRangeCheck(WorldObject const& obj,uint32 entry, bool alive, float range)
+                : i_obj(obj), i_entry(entry), i_alive(alive), i_range(range) {}
+
+            bool operator()(Creature* u)
+            {
+                if(u->GetEntry() == i_entry && u->isAlive()==i_alive && i_obj.IsWithinDistInMap(u, i_range))
+                {
+                    i_range = i_obj.GetDistance(u);         // use found unit range as new range limit for next check
+                    return true;
+                }
+                return false;
+            }
+            float GetLastRange() const { return i_range; }
+        private:
+            WorldObject const& i_obj;
+            uint32 i_entry;
+            bool   i_alive;
+            float  i_range;
+
+            // prevent clone this object
+            NearestCreatureEntryWithLiveStateInObjectRangeCheck(NearestCreatureEntryWithLiveStateInObjectRangeCheck const&);
+    };
+
+    class AnyPlayerInObjectRangeCheck
+    {
+    public:
+        AnyPlayerInObjectRangeCheck(WorldObject const* obj, float range) : i_obj(obj), i_range(range) {}
+        bool operator()(Player* u)
+        {
+            if(u->isAlive() && i_obj->IsWithinDistInMap(u, i_range))
+                return true;
+
+            return false;
+        }
+    private:
+        WorldObject const* i_obj;
+        float i_range;
+    };
+
+    #ifndef WIN32
+    template<> void PlayerRelocationNotifier::Visit<Creature>(CreatureMapType &);
+    template<> void PlayerRelocationNotifier::Visit<Player>(PlayerMapType &);
+    template<> void CreatureRelocationNotifier::Visit<Player>(PlayerMapType &);
+    template<> void CreatureRelocationNotifier::Visit<Creature>(CreatureMapType &);
+    template<> inline void DynamicObjectUpdater::Visit<Creature>(CreatureMapType &);
+    template<> inline void DynamicObjectUpdater::Visit<Player>(PlayerMapType &);
+    #endif
+}
+#endif