First Commit

For Azeroth!

src/server/game/AI/CoreAI/CombatAI.cpp

@@ -0,0 +1,323 @@
+/*
+ * Copyright (C) 
+ * Copyright (C) 
+ *
+ * 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "CombatAI.h"
+#include "SpellMgr.h"
+#include "SpellInfo.h"
+#include "Vehicle.h"
+#include "ObjectAccessor.h"
+#include "Player.h"
+
+/////////////////
+// AggressorAI
+/////////////////
+
+int AggressorAI::Permissible(const Creature* creature)
+{
+    // have some hostile factions, it will be selected by IsHostileTo check at MoveInLineOfSight
+    if (!creature->IsCivilian() && !creature->IsNeutralToAll())
+        return PERMIT_BASE_PROACTIVE;
+
+    return PERMIT_BASE_NO;
+}
+
+void AggressorAI::UpdateAI(uint32 /*diff*/)
+{
+    if (!UpdateVictim())
+        return;
+
+    DoMeleeAttackIfReady();
+}
+
+/////////////////
+// CombatAI
+/////////////////
+
+void CombatAI::InitializeAI()
+{
+    for (uint32 i = 0; i < CREATURE_MAX_SPELLS; ++i)
+        if (me->m_spells[i] && sSpellMgr->GetSpellInfo(me->m_spells[i]))
+            spells.push_back(me->m_spells[i]);
+
+    CreatureAI::InitializeAI();
+}
+
+void CombatAI::Reset()
+{
+    events.Reset();
+}
+
+void CombatAI::JustDied(Unit* killer)
+{
+    for (SpellVct::iterator i = spells.begin(); i != spells.end(); ++i)
+        if (AISpellInfo[*i].condition == AICOND_DIE)
+            me->CastSpell(killer, *i, true);
+}
+
+void CombatAI::EnterCombat(Unit* who)
+{
+    for (SpellVct::iterator i = spells.begin(); i != spells.end(); ++i)
+    {
+        if (AISpellInfo[*i].condition == AICOND_AGGRO)
+            me->CastSpell(who, *i, false);
+        else if (AISpellInfo[*i].condition == AICOND_COMBAT)
+            events.ScheduleEvent(*i, AISpellInfo[*i].cooldown + rand()%AISpellInfo[*i].cooldown);
+    }
+}
+
+void CombatAI::UpdateAI(uint32 diff)
+{
+    if (!UpdateVictim())
+        return;
+
+    events.Update(diff);
+
+    if (me->HasUnitState(UNIT_STATE_CASTING))
+        return;
+
+    if (uint32 spellId = events.ExecuteEvent())
+    {
+        DoCast(spellId);
+        events.ScheduleEvent(spellId, AISpellInfo[spellId].cooldown + rand()%AISpellInfo[spellId].cooldown);
+    }
+    else
+        DoMeleeAttackIfReady();
+}
+
+/////////////////
+// CasterAI
+/////////////////
+
+void CasterAI::InitializeAI()
+{
+    CombatAI::InitializeAI();
+
+    m_attackDist = 30.0f;
+    for (SpellVct::iterator itr = spells.begin(); itr != spells.end(); ++itr)
+        if (AISpellInfo[*itr].condition == AICOND_COMBAT && m_attackDist > GetAISpellInfo(*itr)->maxRange)
+            m_attackDist = GetAISpellInfo(*itr)->maxRange;
+    if (m_attackDist == 30.0f)
+        m_attackDist = MELEE_RANGE;
+}
+
+void CasterAI::EnterCombat(Unit* who)
+{
+    if (spells.empty())
+        return;
+
+    uint32 spell = rand()%spells.size();
+    uint32 count = 0;
+    for (SpellVct::iterator itr = spells.begin(); itr != spells.end(); ++itr, ++count)
+    {
+        if (AISpellInfo[*itr].condition == AICOND_AGGRO)
+            me->CastSpell(who, *itr, false);
+        else if (AISpellInfo[*itr].condition == AICOND_COMBAT)
+        {
+            uint32 cooldown = GetAISpellInfo(*itr)->realCooldown;
+            if (count == spell)
+            {
+                DoCast(spells[spell]);
+                cooldown += me->GetCurrentSpellCastTime(*itr);
+            }
+            events.ScheduleEvent(*itr, cooldown);
+        }
+    }
+}
+
+void CasterAI::UpdateAI(uint32 diff)
+{
+    if (!UpdateVictim())
+        return;
+
+    events.Update(diff);
+
+    if (me->GetVictim()->HasBreakableByDamageCrowdControlAura(me))
+    {
+        me->InterruptNonMeleeSpells(false);
+        return;
+    }
+
+    if (me->HasUnitState(UNIT_STATE_CASTING))
+        return;
+
+    if (uint32 spellId = events.ExecuteEvent())
+    {
+        DoCast(spellId);
+        uint32 casttime = me->GetCurrentSpellCastTime(spellId);
+        events.ScheduleEvent(spellId, (casttime ? casttime : 500) + GetAISpellInfo(spellId)->realCooldown);
+    }
+}
+
+//////////////
+// ArcherAI
+//////////////
+
+ArcherAI::ArcherAI(Creature* c) : CreatureAI(c)
+{
+    if (!me->m_spells[0])
+        sLog->outError("ArcherAI set for creature (entry = %u) with spell1=0. AI will do nothing", me->GetEntry());
+
+    SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(me->m_spells[0]);
+    m_minRange = spellInfo ? spellInfo->GetMinRange(false) : 0;
+
+    if (!m_minRange)
+        m_minRange = MELEE_RANGE;
+    me->m_CombatDistance = spellInfo ? spellInfo->GetMaxRange(false) : 0;
+    me->m_SightDistance = me->m_CombatDistance;
+}
+
+void ArcherAI::AttackStart(Unit* who)
+{
+    if (!who)
+        return;
+
+    if (me->IsWithinCombatRange(who, m_minRange))
+    {
+        if (me->Attack(who, true) && !who->IsFlying())
+            me->GetMotionMaster()->MoveChase(who);
+    }
+    else
+    {
+        if (me->Attack(who, false) && !who->IsFlying())
+            me->GetMotionMaster()->MoveChase(who, me->m_CombatDistance);
+    }
+
+    if (who->IsFlying())
+        me->GetMotionMaster()->MoveIdle();
+}
+
+void ArcherAI::UpdateAI(uint32 /*diff*/)
+{
+    if (!UpdateVictim())
+        return;
+
+    if (!me->IsWithinCombatRange(me->GetVictim(), m_minRange))
+        DoSpellAttackIfReady(me->m_spells[0]);
+    else
+        DoMeleeAttackIfReady();
+}
+
+//////////////
+// TurretAI
+//////////////
+
+TurretAI::TurretAI(Creature* c) : CreatureAI(c)
+{
+    if (!me->m_spells[0])
+        sLog->outError("TurretAI set for creature (entry = %u) with spell1=0. AI will do nothing", me->GetEntry());
+
+    SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(me->m_spells[0]);
+    m_minRange = spellInfo ? spellInfo->GetMinRange(false) : 0;
+    me->m_CombatDistance = spellInfo ? spellInfo->GetMaxRange(false) : 0;
+    me->m_SightDistance = me->m_CombatDistance;
+}
+
+bool TurretAI::CanAIAttack(const Unit* /*who*/) const
+{
+    // TODO: use one function to replace it
+    if (!me->IsWithinCombatRange(me->GetVictim(), me->m_CombatDistance)
+        || (m_minRange && me->IsWithinCombatRange(me->GetVictim(), m_minRange)))
+        return false;
+    return true;
+}
+
+void TurretAI::AttackStart(Unit* who)
+{
+    if (who)
+        me->Attack(who, false);
+}
+
+void TurretAI::UpdateAI(uint32 /*diff*/)
+{
+    if (!UpdateVictim())
+        return;
+
+    if( me->m_spells[0] )
+        DoSpellAttackIfReady(me->m_spells[0]);
+}
+
+//////////////
+// VehicleAI
+//////////////
+
+VehicleAI::VehicleAI(Creature* c) : CreatureAI(c), m_ConditionsTimer(VEHICLE_CONDITION_CHECK_TIME)
+{
+    LoadConditions();
+    m_DoDismiss = false;
+    m_DismissTimer = VEHICLE_DISMISS_TIME;
+}
+
+//NOTE: VehicleAI::UpdateAI runs even while the vehicle is mounted
+void VehicleAI::UpdateAI(uint32 diff)
+{
+    CheckConditions(diff);
+
+    if (m_DoDismiss)
+    {
+        if (m_DismissTimer < diff)
+        {
+            m_DoDismiss = false;
+            me->DespawnOrUnsummon();
+        }
+		else
+			m_DismissTimer -= diff;
+    }
+}
+
+void VehicleAI::OnCharmed(bool apply)
+{
+    if (!me->GetVehicleKit()->IsVehicleInUse() && !apply && !conditions.empty()) // was used and has conditions
+        m_DoDismiss = true; // needs reset
+    else if (apply)
+        m_DoDismiss = false; // in use again
+
+    m_DismissTimer = VEHICLE_DISMISS_TIME;//reset timer
+}
+
+void VehicleAI::LoadConditions()
+{
+    conditions = sConditionMgr->GetConditionsForNotGroupedEntry(CONDITION_SOURCE_TYPE_CREATURE_TEMPLATE_VEHICLE, me->GetEntry());
+    //if (!conditions.empty())
+        ;//sLog->outDebug(LOG_FILTER_CONDITIONSYS, "VehicleAI::LoadConditions: loaded %u conditions", uint32(conditions.size()));
+}
+
+void VehicleAI::CheckConditions(uint32 diff)
+{
+    if (m_ConditionsTimer < diff)
+    {
+        if (!conditions.empty())
+        {
+            if (Vehicle* vehicleKit = me->GetVehicleKit())
+                for (SeatMap::iterator itr = vehicleKit->Seats.begin(); itr != vehicleKit->Seats.end(); ++itr)
+                    if (Unit* passenger = ObjectAccessor::GetUnit(*me, itr->second.Passenger.Guid))
+                    {
+                        if (Player* player = passenger->ToPlayer())
+                        {
+                            if (!sConditionMgr->IsObjectMeetToConditions(player, me, conditions))
+                            {
+                                player->ExitVehicle();
+                                return; // check other pessanger in next tick
+                            }
+                        }
+                    }
+        }
+        m_ConditionsTimer = VEHICLE_CONDITION_CHECK_TIME;
+    }
+    else
+        m_ConditionsTimer -= diff;
+}

src/server/game/AI/CoreAI/CombatAI.h

@@ -0,0 +1,120 @@
+/*
+ * Copyright (C) 
+ * Copyright (C) 
+ *
+ * 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef TRINITY_COMBATAI_H
+#define TRINITY_COMBATAI_H
+
+#include "CreatureAI.h"
+#include "CreatureAIImpl.h"
+#include "ConditionMgr.h"
+
+class Creature;
+
+class AggressorAI : public CreatureAI
+{
+    public:
+        explicit AggressorAI(Creature* c) : CreatureAI(c) {}
+
+        void UpdateAI(uint32);
+        static int Permissible(const Creature*);
+};
+
+typedef std::vector<uint32> SpellVct;
+
+class CombatAI : public CreatureAI
+{
+    public:
+        explicit CombatAI(Creature* c) : CreatureAI(c) {}
+
+        void InitializeAI();
+        void Reset();
+        void EnterCombat(Unit* who);
+        void JustDied(Unit* killer);
+        void UpdateAI(uint32 diff);
+
+        static int Permissible(Creature const* /*creature*/) { return PERMIT_BASE_NO; }
+
+    protected:
+        EventMap events;
+        SpellVct spells;
+};
+
+class CasterAI : public CombatAI
+{
+    public:
+        explicit CasterAI(Creature* c) : CombatAI(c) { m_attackDist = MELEE_RANGE; }
+        void InitializeAI();
+        void AttackStart(Unit* victim) { AttackStartCaster(victim, m_attackDist); }
+        void UpdateAI(uint32 diff);
+        void EnterCombat(Unit* /*who*/);
+    private:
+        float m_attackDist;
+};
+
+struct ArcherAI : public CreatureAI
+{
+    public:
+        explicit ArcherAI(Creature* c);
+        void AttackStart(Unit* who);
+        void UpdateAI(uint32 diff);
+
+
+        static int Permissible(Creature const* /*creature*/) { return PERMIT_BASE_NO; }
+
+    protected:
+        float m_minRange;
+};
+
+struct TurretAI : public CreatureAI
+{
+    public:
+        explicit TurretAI(Creature* c);
+        bool CanAIAttack(const Unit* who) const;
+        void AttackStart(Unit* who);
+        void UpdateAI(uint32 diff);
+
+        static int Permissible(Creature const* /*creature*/) { return PERMIT_BASE_NO; }
+
+    protected:
+        float m_minRange;
+};
+
+#define VEHICLE_CONDITION_CHECK_TIME 1000
+#define VEHICLE_DISMISS_TIME 5000
+struct VehicleAI : public CreatureAI
+{
+    public:
+        explicit VehicleAI(Creature* creature);
+
+        void UpdateAI(uint32 diff);
+        void MoveInLineOfSight(Unit*) {}
+        void AttackStart(Unit*) {}
+        void OnCharmed(bool apply);
+
+        static int Permissible(Creature const* /*creature*/) { return PERMIT_BASE_NO; }
+
+    private:
+        void LoadConditions();
+        void CheckConditions(uint32 diff);
+        ConditionList conditions;
+        uint32 m_ConditionsTimer;
+        bool m_DoDismiss;
+        uint32 m_DismissTimer;
+};
+
+#endif

src/server/game/AI/CoreAI/GameObjectAI.cpp

@@ -0,0 +1,29 @@
+/*
+ * Copyright (C) 
+ * Copyright (C) 
+ *
+ * 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "GameObjectAI.h"
+
+//GameObjectAI::GameObjectAI(GameObject* g) : go(g) {}
+int GameObjectAI::Permissible(const GameObject* go)
+{
+    if (go->GetAIName() == "GameObjectAI")
+        return PERMIT_BASE_SPECIAL;
+    return PERMIT_BASE_NO;
+}
+
+NullGameObjectAI::NullGameObjectAI(GameObject* g) : GameObjectAI(g) {}

src/server/game/AI/CoreAI/GameObjectAI.h

@@ -0,0 +1,76 @@
+/*
+ * Copyright (C) 
+ * Copyright (C) 
+ *
+ * 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef TRINITY_GAMEOBJECTAI_H
+#define TRINITY_GAMEOBJECTAI_H
+
+#include "Define.h"
+#include <list>
+#include "Object.h"
+#include "QuestDef.h"
+#include "GameObject.h"
+#include "CreatureAI.h"
+
+class GameObjectAI
+{
+    protected:
+        GameObject* const go;
+    public:
+        explicit GameObjectAI(GameObject* g) : go(g) {}
+        virtual ~GameObjectAI() {}
+
+        virtual void UpdateAI(uint32 /*diff*/) {}
+
+        virtual void InitializeAI() { Reset(); }
+
+        virtual void Reset() { }
+
+        // Pass parameters between AI
+        virtual void DoAction(int32 /*param = 0 */) {}
+        virtual void SetGUID(uint64 /*guid*/, int32 /*id = 0 */) {}
+        virtual uint64 GetGUID(int32 /*id = 0 */) const { return 0; }
+
+        static int Permissible(GameObject const* go);
+
+        virtual bool GossipHello(Player* /*player*/, bool reportUse) { return false; }
+        virtual bool GossipSelect(Player* /*player*/, uint32 /*sender*/, uint32 /*action*/) { return false; }
+        virtual bool GossipSelectCode(Player* /*player*/, uint32 /*sender*/, uint32 /*action*/, char const* /*code*/) { return false; }
+        virtual bool QuestAccept(Player* /*player*/, Quest const* /*quest*/) { return false; }
+        virtual bool QuestReward(Player* /*player*/, Quest const* /*quest*/, uint32 /*opt*/) { return false; }
+        virtual uint32 GetDialogStatus(Player* /*player*/) { return DIALOG_STATUS_SCRIPTED_NO_STATUS; }
+        virtual void Destroyed(Player* /*player*/, uint32 /*eventId*/) {}
+        virtual uint32 GetData(uint32 /*id*/) const { return 0; }
+        virtual void SetData64(uint32 /*id*/, uint64 /*value*/) {}
+        virtual uint64 GetData64(uint32 /*id*/) const { return 0; }
+        virtual void SetData(uint32 /*id*/, uint32 /*value*/) {}
+        virtual void OnGameEvent(bool /*start*/, uint16 /*eventId*/) {}
+        virtual void OnStateChanged(uint32 /*state*/, Unit* /*unit*/) {}
+        virtual void EventInform(uint32 /*eventId*/) {}
+		virtual void SpellHit(Unit* unit, const SpellInfo* spellInfo) {}
+};
+
+class NullGameObjectAI : public GameObjectAI
+{
+    public:
+        explicit NullGameObjectAI(GameObject* g);
+
+        void UpdateAI(uint32 /*diff*/) {}
+
+        static int Permissible(GameObject const* /*go*/) { return PERMIT_BASE_IDLE; }
+};
+#endif

src/server/game/AI/CoreAI/GuardAI.cpp

@@ -0,0 +1,69 @@
+/*
+ * Copyright (C) 
+ * Copyright (C) 
+ *
+ * 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "GuardAI.h"
+#include "Errors.h"
+#include "Player.h"
+#include "ObjectAccessor.h"
+#include "World.h"
+#include "CreatureAIImpl.h"
+
+int GuardAI::Permissible(Creature const* creature)
+{
+    if (creature->IsGuard())
+        return PERMIT_BASE_SPECIAL;
+
+    return PERMIT_BASE_NO;
+}
+
+GuardAI::GuardAI(Creature* creature) : ScriptedAI(creature)
+{
+}
+
+void GuardAI::Reset()
+{
+	ScriptedAI::Reset();
+	me->CastSpell(me, 18950 /*SPELL_INVISIBILITY_AND_STEALTH_DETECTION*/, true);
+}
+
+void GuardAI::EnterEvadeMode()
+{
+    if (!me->IsAlive())
+    {
+        me->GetMotionMaster()->MoveIdle();
+        me->CombatStop(true);
+        me->DeleteThreatList();
+        return;
+    }
+
+    ;//sLog->outDebug(LOG_FILTER_UNITS, "Guard entry: %u enters evade mode.", me->GetEntry());
+
+    me->RemoveAllAuras();
+    me->DeleteThreatList();
+    me->CombatStop(true);
+
+    // Remove ChaseMovementGenerator from MotionMaster stack list, and add HomeMovementGenerator instead
+    if (me->GetMotionMaster()->GetCurrentMovementGeneratorType() == CHASE_MOTION_TYPE)
+        me->GetMotionMaster()->MoveTargetedHome();
+}
+
+void GuardAI::JustDied(Unit* killer)
+{
+    if (Player* player = killer->GetCharmerOrOwnerPlayerOrPlayerItself())
+        me->SendZoneUnderAttackMessage(player);
+}

src/server/game/AI/CoreAI/GuardAI.h

@@ -0,0 +1,37 @@
+/*
+ * Copyright (C) 
+ * Copyright (C) 
+ *
+ * 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef TRINITY_GUARDAI_H
+#define TRINITY_GUARDAI_H
+
+#include "ScriptedCreature.h"
+
+class Creature;
+
+class GuardAI : public ScriptedAI
+{
+    public:
+        explicit GuardAI(Creature* creature);
+
+        static int Permissible(Creature const* creature);
+
+		void Reset();
+        void EnterEvadeMode();
+        void JustDied(Unit* killer);
+};
+#endif

src/server/game/AI/CoreAI/PassiveAI.cpp

@@ -0,0 +1,92 @@
+/*
+ * Copyright (C) 
+ * Copyright (C) 
+ *
+ * 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "PassiveAI.h"
+#include "Creature.h"
+#include "TemporarySummon.h"
+
+PassiveAI::PassiveAI(Creature* c) : CreatureAI(c) { me->SetReactState(REACT_PASSIVE); }
+PossessedAI::PossessedAI(Creature* c) : CreatureAI(c) { me->SetReactState(REACT_PASSIVE); }
+NullCreatureAI::NullCreatureAI(Creature* c) : CreatureAI(c) { me->SetReactState(REACT_PASSIVE); }
+
+void PassiveAI::UpdateAI(uint32)
+{
+    if (me->IsInCombat() && me->getAttackers().empty())
+        EnterEvadeMode();
+}
+
+void PossessedAI::AttackStart(Unit* target)
+{
+    me->Attack(target, true);
+}
+
+void PossessedAI::UpdateAI(uint32 /*diff*/)
+{
+    if (me->GetVictim())
+    {
+        if (!me->IsValidAttackTarget(me->GetVictim()))
+            me->AttackStop();
+        else
+            DoMeleeAttackIfReady();
+    }
+}
+
+void PossessedAI::JustDied(Unit* /*u*/)
+{
+    // We died while possessed, disable our loot
+    me->RemoveFlag(UNIT_DYNAMIC_FLAGS, UNIT_DYNFLAG_LOOTABLE);
+}
+
+void PossessedAI::KilledUnit(Unit* victim)
+{
+    // We killed a creature, disable victim's loot
+    //if (victim->GetTypeId() == TYPEID_UNIT)
+    //    victim->RemoveFlag(UNIT_DYNAMIC_FLAGS, UNIT_DYNFLAG_LOOTABLE);
+}
+
+void CritterAI::DamageTaken(Unit*, uint32&, DamageEffectType, SpellSchoolMask)
+{
+    if (!me->HasUnitState(UNIT_STATE_FLEEING))
+        me->SetControlled(true, UNIT_STATE_FLEEING);
+
+	_combatTimer = 1;
+}
+
+void CritterAI::EnterEvadeMode()
+{
+    if (me->HasUnitState(UNIT_STATE_FLEEING))
+        me->SetControlled(false, UNIT_STATE_FLEEING);
+    CreatureAI::EnterEvadeMode();
+	_combatTimer = 0;
+}
+
+void CritterAI::UpdateAI(uint32 diff)
+{
+	if (me->IsInCombat())
+	{
+		_combatTimer += diff;
+		if (_combatTimer >= 5000)
+			EnterEvadeMode();
+	}
+}
+
+void TriggerAI::IsSummonedBy(Unit* summoner)
+{
+    if (me->m_spells[0])
+		me->CastSpell(me, me->m_spells[0], false, 0, 0, summoner ? summoner->GetGUID() : 0);
+}

src/server/game/AI/CoreAI/PassiveAI.h

@@ -0,0 +1,89 @@
+/*
+ * Copyright (C) 
+ * Copyright (C) 
+ *
+ * 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef TRINITY_PASSIVEAI_H
+#define TRINITY_PASSIVEAI_H
+
+#include "CreatureAI.h"
+//#include "CreatureAIImpl.h"
+
+class PassiveAI : public CreatureAI
+{
+    public:
+        explicit PassiveAI(Creature* c);
+
+        void MoveInLineOfSight(Unit*) {}
+        void AttackStart(Unit*) {}
+        void UpdateAI(uint32);
+
+        static int Permissible(const Creature*) { return PERMIT_BASE_IDLE;  }
+};
+
+class PossessedAI : public CreatureAI
+{
+    public:
+        explicit PossessedAI(Creature* c);
+
+        void MoveInLineOfSight(Unit*) {}
+        void AttackStart(Unit* target);
+        void UpdateAI(uint32);
+        void EnterEvadeMode() {}
+
+        void JustDied(Unit*);
+        void KilledUnit(Unit* victim);
+
+        static int Permissible(const Creature*) { return PERMIT_BASE_IDLE;  }
+};
+
+class NullCreatureAI : public CreatureAI
+{
+    public:
+        explicit NullCreatureAI(Creature* c);
+
+        void MoveInLineOfSight(Unit*) {}
+        void AttackStart(Unit*) {}
+        void UpdateAI(uint32) {}
+        void EnterEvadeMode() {}
+        void OnCharmed(bool /*apply*/) {}
+
+        static int Permissible(const Creature*) { return PERMIT_BASE_IDLE;  }
+};
+
+class CritterAI : public PassiveAI
+{
+    public:
+        explicit CritterAI(Creature* c) : PassiveAI(c) { _combatTimer = 0; }
+
+        void DamageTaken(Unit* /*done_by*/, uint32& /*damage*/, DamageEffectType damagetype, SpellSchoolMask damageSchoolMask);
+        void EnterEvadeMode();
+		void UpdateAI(uint32);
+
+	// Xinef: Added
+	private:
+		uint32 _combatTimer;
+};
+
+class TriggerAI : public NullCreatureAI
+{
+    public:
+        explicit TriggerAI(Creature* c) : NullCreatureAI(c) {}
+        void IsSummonedBy(Unit* summoner);
+};
+
+#endif
+

src/server/game/AI/CoreAI/PetAI.cpp

@@ -0,0 +1,742 @@
+/*
+ * Copyright (C) 
+ * Copyright (C) 
+ *
+ * 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "PetAI.h"
+#include "Errors.h"
+#include "Pet.h"
+#include "Player.h"
+#include "DBCStores.h"
+#include "Spell.h"
+#include "ObjectAccessor.h"
+#include "SpellMgr.h"
+#include "Creature.h"
+#include "World.h"
+#include "Util.h"
+#include "Group.h"
+#include "SpellInfo.h"
+#include "SpellAuraEffects.h"
+#include "WorldSession.h"
+
+int PetAI::Permissible(const Creature* creature)
+{
+    if (creature->IsPet())
+        return PERMIT_BASE_SPECIAL;
+
+    return PERMIT_BASE_NO;
+}
+
+PetAI::PetAI(Creature* c) : CreatureAI(c), i_tracker(TIME_INTERVAL_LOOK)
+{
+    UpdateAllies();
+}
+
+bool PetAI::_needToStop()
+{
+    // This is needed for charmed creatures, as once their target was reset other effects can trigger threat
+    if (me->IsCharmed() && me->GetVictim() == me->GetCharmer())
+        return true;
+
+	// xinef: dont allow to follow targets out of visibility range
+	if (me->GetExactDist(me->GetVictim()) > me->GetVisibilityRange()-5.0f)
+		return true;
+
+	// dont allow pets to follow targets far away from owner
+	if (Unit* owner = me->GetCharmerOrOwner())
+		if (owner->GetExactDist(me) >= (owner->GetVisibilityRange()-10.0f))
+			return true;
+
+	if (!me->_CanDetectFeignDeathOf(me->GetVictim()))
+		return true;
+
+	if (me->isTargetNotAcceptableByMMaps(me->GetVictim()->GetGUID(), sWorld->GetGameTime(), me->GetVictim()))
+		return true;
+
+	return !me->CanCreatureAttack(me->GetVictim());
+}
+
+void PetAI::_stopAttack()
+{
+    if (!me->IsAlive())
+    {
+        ;//sLog->outStaticDebug("Creature stoped attacking cuz his dead [guid=%u]", me->GetGUIDLow());
+        me->GetMotionMaster()->Clear();
+        me->GetMotionMaster()->MoveIdle();
+        me->CombatStop();
+        me->getHostileRefManager().deleteReferences();
+        return;
+    }
+
+    me->AttackStop();
+    me->InterruptNonMeleeSpells(false);
+    me->GetCharmInfo()->SetIsCommandAttack(false);
+    ClearCharmInfoFlags();
+    HandleReturnMovement();
+}
+
+void PetAI::_doMeleeAttack()
+{
+	// Xinef: Imps cannot attack with melee
+	if (!_canMeleeAttack())
+		return;
+
+	DoMeleeAttackIfReady();
+}
+
+bool PetAI::_canMeleeAttack() const
+{
+	return me->GetEntry() != 416 /*ENTRY_IMP*/ &&
+		me->GetEntry() != 510 /*ENTRY_WATER_ELEMENTAL*/ &&
+		me->GetEntry() != 37994 /*ENTRY_WATER_ELEMENTAL_PERM*/;	
+}
+
+void PetAI::UpdateAI(uint32 diff)
+{
+    if (!me->IsAlive() || !me->GetCharmInfo())
+        return;
+
+    Unit* owner = me->GetCharmerOrOwner();
+
+    if (m_updateAlliesTimer <= diff)
+        // UpdateAllies self set update timer
+        UpdateAllies();
+    else
+        m_updateAlliesTimer -= diff;
+
+    if (me->GetVictim() && me->GetVictim()->IsAlive())
+    {
+        // is only necessary to stop casting, the pet must not exit combat
+        if (me->GetVictim()->HasBreakableByDamageCrowdControlAura(me))
+        {
+            me->InterruptNonMeleeSpells(false);
+            return;
+        }
+
+        if (_needToStop())
+        {
+            ;//sLog->outStaticDebug("Pet AI stopped attacking [guid=%u]", me->GetGUIDLow());
+            _stopAttack();
+            return;
+        }
+
+        // Check before attacking to prevent pets from leaving stay position
+        if (me->GetCharmInfo()->HasCommandState(COMMAND_STAY))
+        {
+            if (me->GetCharmInfo()->IsCommandAttack() || (me->GetCharmInfo()->IsAtStay() && me->IsWithinMeleeRange(me->GetVictim())))
+                _doMeleeAttack();
+        }
+        else
+            _doMeleeAttack();
+    }
+    else if (!me->GetCharmInfo() || (!me->GetCharmInfo()->GetForcedSpell() && !me->HasUnitState(UNIT_STATE_CASTING)))
+    {
+        if (me->HasReactState(REACT_AGGRESSIVE) || me->GetCharmInfo()->IsAtStay())
+        {
+            // Every update we need to check targets only in certain cases
+            // Aggressive - Allow auto select if owner or pet don't have a target
+            // Stay - Only pick from pet or owner targets / attackers so targets won't run by
+            //   while chasing our owner. Don't do auto select.
+            // All other cases (ie: defensive) - Targets are assigned by AttackedBy(), OwnerAttackedBy(), OwnerAttacked(), etc.
+            Unit* nextTarget = SelectNextTarget(me->HasReactState(REACT_AGGRESSIVE));
+
+            if (nextTarget)
+                AttackStart(nextTarget);
+            else
+                HandleReturnMovement();
+        }
+        else
+            HandleReturnMovement();
+    }
+
+	// xinef: charm info must be always available
+	if (!me->GetCharmInfo())
+		return;
+
+    // Autocast (casted only in combat or persistent spells in any state)
+    if (!me->HasUnitState(UNIT_STATE_CASTING))
+    {
+		if (owner && owner->GetTypeId() == TYPEID_PLAYER && me->GetCharmInfo()->GetForcedSpell() && me->GetCharmInfo()->GetForcedTarget())
+		{
+			owner->ToPlayer()->GetSession()->HandlePetActionHelper(me, me->GetGUID(), abs(me->GetCharmInfo()->GetForcedSpell()), ACT_ENABLED, me->GetCharmInfo()->GetForcedTarget());
+
+			// xinef: if spell was casted properly and we are in passive mode, handle return
+			if (!me->GetCharmInfo()->GetForcedSpell() && me->HasReactState(REACT_PASSIVE))
+			{
+				if (me->HasUnitState(UNIT_STATE_CASTING))
+				{
+					me->GetMotionMaster()->Clear(false);
+					me->StopMoving();
+				}
+				else
+					_stopAttack();
+			}
+			return;
+		}
+
+		// xinef: dont allow ghouls to cast spells below 75 energy
+		if (me->IsPet() && me->ToPet()->IsPetGhoul() && me->GetPower(POWER_ENERGY) < 75)
+			return;
+
+        typedef std::vector<std::pair<Unit*, Spell*> > TargetSpellList;
+        TargetSpellList targetSpellStore;
+
+        for (uint8 i = 0; i < me->GetPetAutoSpellSize(); ++i)
+        {
+            uint32 spellID = me->GetPetAutoSpellOnPos(i);
+            if (!spellID)
+                continue;
+
+            SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(spellID);
+            if (!spellInfo)
+                continue;
+
+            if (me->GetCharmInfo()->GetGlobalCooldownMgr().HasGlobalCooldown(spellInfo))
+                continue;
+
+            // check spell cooldown, this should be checked in CheckCast...
+            if (me->HasSpellCooldown(spellInfo->Id))
+                continue;
+
+            if (spellInfo->IsPositive())
+            {
+                if (spellInfo->CanBeUsedInCombat())
+                {
+                    // Check if we're in combat or commanded to attack
+                    if (!me->IsInCombat() && !me->GetCharmInfo()->IsCommandAttack())
+                        continue;
+                }
+
+                Spell* spell = new Spell(me, spellInfo, TRIGGERED_NONE, 0);
+				spell->LoadScripts(); // xinef: load for CanAutoCast (calling CheckPetCast)
+                bool spellUsed = false;
+
+                // Some spells can target enemy or friendly (DK Ghoul's Leap)
+                // Check for enemy first (pet then owner)
+                Unit* target = me->getAttackerForHelper();
+                if (!target && owner)
+                    target = owner->getAttackerForHelper();
+
+                if (target)
+                {
+                    if (CanAttack(target) && spell->CanAutoCast(target))
+                    {
+                        targetSpellStore.push_back(std::make_pair(target, spell));
+                        spellUsed = true;
+                    }
+                }
+
+                // No enemy, check friendly
+                if (!spellUsed)
+                {
+                    for (std::set<uint64>::const_iterator tar = m_AllySet.begin(); tar != m_AllySet.end(); ++tar)
+                    {
+                        Unit* ally = ObjectAccessor::GetUnit(*me, *tar);
+
+                        //only buff targets that are in combat, unless the spell can only be cast while out of combat
+                        if (!ally)
+                            continue;
+
+                        if (spell->CanAutoCast(ally))
+                        {
+                            targetSpellStore.push_back(std::make_pair(ally, spell));
+                            spellUsed = true;
+                            break;
+                        }
+                    }
+                }
+
+                // No valid targets at all
+                if (!spellUsed)
+                    delete spell;
+            }
+            else if (me->GetVictim() && CanAttack(me->GetVictim(), spellInfo) && spellInfo->CanBeUsedInCombat())
+            {
+                Spell* spell = new Spell(me, spellInfo, TRIGGERED_NONE, 0);
+                if (spell->CanAutoCast(me->GetVictim()))
+                    targetSpellStore.push_back(std::make_pair(me->GetVictim(), spell));
+                else
+                    delete spell;
+            }
+        }
+
+        //found units to cast on to
+        if (!targetSpellStore.empty())
+        {
+            uint32 index = urand(0, targetSpellStore.size() - 1);
+
+            Spell* spell  = targetSpellStore[index].second;
+            Unit*  target = targetSpellStore[index].first;
+
+            targetSpellStore.erase(targetSpellStore.begin() + index);
+
+            SpellCastTargets targets;
+            targets.SetUnitTarget(target);
+
+            if (!me->HasInArc(M_PI, target))
+            {
+                me->SetInFront(target);
+                if (target && target->GetTypeId() == TYPEID_PLAYER)
+                    me->SendUpdateToPlayer(target->ToPlayer());
+
+                if (owner && owner->GetTypeId() == TYPEID_PLAYER)
+                    me->SendUpdateToPlayer(owner->ToPlayer());
+            }
+
+            me->AddSpellCooldown(spell->m_spellInfo->Id, 0, 0);
+
+            spell->prepare(&targets);
+        }
+
+        // deleted cached Spell objects
+        for (TargetSpellList::const_iterator itr = targetSpellStore.begin(); itr != targetSpellStore.end(); ++itr)
+            delete itr->second;
+    }
+}
+
+void PetAI::UpdateAllies()
+{
+    Unit* owner = me->GetCharmerOrOwner();
+    Group* group = NULL;
+
+    m_updateAlliesTimer = 10*IN_MILLISECONDS;                //update friendly targets every 10 seconds, lesser checks increase performance
+
+    if (!owner)
+        return;
+    else if (owner->GetTypeId() == TYPEID_PLAYER)
+        group = owner->ToPlayer()->GetGroup();
+
+    //only pet and owner/not in group->ok
+    if (m_AllySet.size() == 2 && !group)
+        return;
+    //owner is in group; group members filled in already (no raid -> subgroupcount = whole count)
+    if (group && !group->isRaidGroup() && m_AllySet.size() == (group->GetMembersCount() + 2))
+        return;
+
+    m_AllySet.clear();
+    m_AllySet.insert(me->GetGUID());
+    if (group)                                              //add group
+    {
+        for (GroupReference* itr = group->GetFirstMember(); itr != NULL; itr = itr->next())
+        {
+            Player* Target = itr->GetSource();
+			if (!Target || !Target->IsInMap(owner) || !group->SameSubGroup(owner->ToPlayer(), Target))
+                continue;
+
+            if (Target->GetGUID() == owner->GetGUID())
+                continue;
+
+            m_AllySet.insert(Target->GetGUID());
+        }
+    }
+    else                                                    //remove group
+        m_AllySet.insert(owner->GetGUID());
+}
+
+void PetAI::KilledUnit(Unit* victim)
+{
+    // Called from Unit::Kill() in case where pet or owner kills something
+    // if owner killed this victim, pet may still be attacking something else
+    if (me->GetVictim() && me->GetVictim() != victim)
+        return;
+
+	// Xinef: if pet is channeling a spell and owner killed something different, dont interrupt it
+	if (me->HasUnitState(UNIT_STATE_CASTING) && me->GetUInt64Value(UNIT_FIELD_CHANNEL_OBJECT) && me->GetUInt64Value(UNIT_FIELD_CHANNEL_OBJECT) != victim->GetGUID())
+		return;
+
+    // Clear target just in case. May help problem where health / focus / mana
+    // regen gets stuck. Also resets attack command.
+    // Can't use _stopAttack() because that activates movement handlers and ignores
+    // next target selection
+    me->AttackStop();
+    me->InterruptNonMeleeSpells(false);
+
+    // Before returning to owner, see if there are more things to attack
+    if (Unit* nextTarget = SelectNextTarget(false))
+        AttackStart(nextTarget);
+    else
+        HandleReturnMovement(); // Return
+}
+
+void PetAI::AttackStart(Unit* target)
+{
+    // Overrides Unit::AttackStart to correctly evaluate Pet states
+
+    // Check all pet states to decide if we can attack this target
+    if (!CanAttack(target))
+        return;
+
+    // Only chase if not commanded to stay or if stay but commanded to attack
+    DoAttack(target, (!me->GetCharmInfo()->HasCommandState(COMMAND_STAY) || me->GetCharmInfo()->IsCommandAttack()));
+}
+
+void PetAI::OwnerAttackedBy(Unit* attacker)
+{
+    // Called when owner takes damage. This function helps keep pets from running off
+    //  simply due to owner gaining aggro.
+
+    if (!attacker)
+        return;
+
+    // Passive pets don't do anything
+    if (me->HasReactState(REACT_PASSIVE))
+        return;
+
+    // Prevent pet from disengaging from current target
+    if (me->GetVictim() && me->GetVictim()->IsAlive())
+        return;
+
+    // Continue to evaluate and attack if necessary
+    AttackStart(attacker);
+}
+
+void PetAI::OwnerAttacked(Unit* target)
+{
+    // Called when owner attacks something. Allows defensive pets to know
+    //  that they need to assist
+
+    // Target might be NULL if called from spell with invalid cast targets
+    if (!target)
+        return;
+
+    // Passive pets don't do anything
+    if (me->HasReactState(REACT_PASSIVE))
+        return;
+
+    // Prevent pet from disengaging from current target
+    if (me->GetVictim() && me->GetVictim()->IsAlive())
+        return;
+
+    // Continue to evaluate and attack if necessary
+    AttackStart(target);
+}
+
+Unit* PetAI::SelectNextTarget(bool allowAutoSelect) const
+{
+    // Provides next target selection after current target death.
+    // This function should only be called internally by the AI
+    // Targets are not evaluated here for being valid targets, that is done in _CanAttack()
+    // The parameter: allowAutoSelect lets us disable aggressive pet auto targeting for certain situations
+
+    // Passive pets don't do next target selection
+    if (me->HasReactState(REACT_PASSIVE))
+        return NULL;
+
+    // Check pet attackers first so we don't drag a bunch of targets to the owner
+    if (Unit* myAttacker = me->getAttackerForHelper())
+		if (!myAttacker->HasBreakableByDamageCrowdControlAura() && me->_CanDetectFeignDeathOf(myAttacker) && me->CanCreatureAttack(myAttacker) && !me->isTargetNotAcceptableByMMaps(myAttacker->GetGUID(), sWorld->GetGameTime(), myAttacker))
+            return myAttacker;
+
+    // Check pet's attackers first to prevent dragging mobs back to owner
+	if (me->HasAuraType(SPELL_AURA_MOD_TAUNT))
+	{
+		const Unit::AuraEffectList& tauntAuras = me->GetAuraEffectsByType(SPELL_AURA_MOD_TAUNT);
+		if (!tauntAuras.empty())
+			for (Unit::AuraEffectList::const_reverse_iterator itr = tauntAuras.rbegin(); itr != tauntAuras.rend(); ++itr)
+				if (Unit* caster = (*itr)->GetCaster())
+					if (me->_CanDetectFeignDeathOf(caster) && me->CanCreatureAttack(caster) && !caster->HasAuraTypeWithCaster(SPELL_AURA_IGNORED, me->GetGUID()))
+						return caster;
+	}
+
+    // Not sure why we wouldn't have an owner but just in case...
+	Unit* owner = me->GetCharmerOrOwner();
+    if (!owner)
+        return NULL;
+
+    // Check owner attackers
+    if (Unit* ownerAttacker = owner->getAttackerForHelper())
+		if (!ownerAttacker->HasBreakableByDamageCrowdControlAura() && me->_CanDetectFeignDeathOf(ownerAttacker) && me->CanCreatureAttack(ownerAttacker) && !me->isTargetNotAcceptableByMMaps(ownerAttacker->GetGUID(), sWorld->GetGameTime(), ownerAttacker))
+            return ownerAttacker;
+
+    // Check owner victim
+    // 3.0.2 - Pets now start attacking their owners victim in defensive mode as soon as the hunter does
+    if (Unit* ownerVictim = owner->GetVictim())
+		if (me->_CanDetectFeignDeathOf(ownerVictim) && me->CanCreatureAttack(ownerVictim) && !me->isTargetNotAcceptableByMMaps(ownerVictim->GetGUID(), sWorld->GetGameTime(), ownerVictim))
+			return ownerVictim;
+
+    // Neither pet or owner had a target and aggressive pets can pick any target
+    // To prevent aggressive pets from chain selecting targets and running off, we
+    // only select a random target if certain conditions are met.
+    if (allowAutoSelect)
+        if (!me->GetCharmInfo()->IsReturning() || me->GetCharmInfo()->IsFollowing() || me->GetCharmInfo()->IsAtStay())
+            if (Unit* nearTarget = me->ToCreature()->SelectNearestTargetInAttackDistance(MAX_AGGRO_RADIUS))
+                return nearTarget;
+
+    // Default - no valid targets
+    return NULL;
+}
+
+void PetAI::HandleReturnMovement()
+{
+    // Handles moving the pet back to stay or owner
+
+    // Prevent activating movement when under control of spells
+    // such as "Eyes of the Beast"
+    if (me->isPossessed())
+        return;
+
+    if (me->GetCharmInfo()->HasCommandState(COMMAND_STAY))
+    {
+        if (!me->GetCharmInfo()->IsAtStay() && !me->GetCharmInfo()->IsReturning())
+        {
+            // Return to previous position where stay was clicked
+            if (me->GetMotionMaster()->GetMotionSlotType(MOTION_SLOT_CONTROLLED) == NULL_MOTION_TYPE)
+            {
+                float x, y, z;
+
+                me->GetCharmInfo()->GetStayPosition(x, y, z);
+                ClearCharmInfoFlags();
+                me->GetCharmInfo()->SetIsReturning(true);
+                me->GetMotionMaster()->Clear();
+                me->GetMotionMaster()->MovePoint(me->GetGUIDLow(), x, y, z);
+            }
+        }
+    }
+    else // COMMAND_FOLLOW
+    {
+        if (!me->GetCharmInfo()->IsFollowing() && !me->GetCharmInfo()->IsReturning())
+        {
+			if (me->GetMotionMaster()->GetMotionSlotType(MOTION_SLOT_CONTROLLED) == NULL_MOTION_TYPE)
+            {
+                ClearCharmInfoFlags();
+                me->GetCharmInfo()->SetIsReturning(true);
+                me->GetMotionMaster()->Clear();
+                me->GetMotionMaster()->MoveFollow(me->GetCharmerOrOwner(), PET_FOLLOW_DIST, me->GetFollowAngle());
+            }
+        }
+    }
+
+	me->GetCharmInfo()->SetForcedSpell(0);
+	me->GetCharmInfo()->SetForcedTargetGUID(0);
+
+	// xinef: remember that npcs summoned by npcs can also be pets
+	me->DeleteThreatList();
+	me->ClearInPetCombat();
+}
+
+void PetAI::SpellHit(Unit* caster, const SpellInfo* spellInfo)
+{
+	// Xinef: taunt behavior code
+	if (spellInfo->HasAura(SPELL_AURA_MOD_TAUNT) && !me->HasReactState(REACT_PASSIVE))
+	{
+		me->GetCharmInfo()->SetForcedSpell(0);
+		me->GetCharmInfo()->SetForcedTargetGUID(0);
+		AttackStart(caster);
+	}
+}
+
+void PetAI::DoAttack(Unit* target, bool chase)
+{
+    // Handles attack with or without chase and also resets flags
+    // for next update / creature kill
+
+    if (me->Attack(target, true))
+    {
+		// xinef: properly fix fake combat after pet is sent to attack
+		if (Unit* owner = me->GetOwner())
+			owner->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_PET_IN_COMBAT);
+
+		me->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_PET_IN_COMBAT);
+
+        // Play sound to let the player know the pet is attacking something it picked on its own
+        if (me->HasReactState(REACT_AGGRESSIVE) && !me->GetCharmInfo()->IsCommandAttack())
+            me->SendPetAIReaction(me->GetGUID());
+
+        if (CharmInfo* ci = me->GetCharmInfo())
+        {
+            ci->SetIsAtStay(false);
+            ci->SetIsCommandFollow(false);
+            ci->SetIsFollowing(false);
+            ci->SetIsReturning(false);
+        }
+
+        if (chase)
+        {
+			me->GetMotionMaster()->MoveChase(target, !_canMeleeAttack() ? 20.0f: 0.0f, me->GetAngle(target));
+        }
+        else // (Stay && ((Aggressive || Defensive) && In Melee Range)))
+        {
+            me->GetCharmInfo()->SetIsAtStay(true);
+			me->GetMotionMaster()->MovementExpiredOnSlot(MOTION_SLOT_ACTIVE, false);
+            me->GetMotionMaster()->MoveIdle();
+        }
+    }
+}
+
+void PetAI::MovementInform(uint32 moveType, uint32 data)
+{
+    // Receives notification when pet reaches stay or follow owner
+    switch (moveType)
+    {
+        case POINT_MOTION_TYPE:
+        {
+            // Pet is returning to where stay was clicked. data should be
+            // pet's GUIDLow since we set that as the waypoint ID
+            if (data == me->GetGUIDLow() && me->GetCharmInfo()->IsReturning())
+            {
+                ClearCharmInfoFlags();
+                me->GetCharmInfo()->SetIsAtStay(true);
+                me->GetMotionMaster()->Clear();
+                me->GetMotionMaster()->MoveIdle();
+            }
+            break;
+        }
+        case FOLLOW_MOTION_TYPE:
+        {
+            // If data is owner's GUIDLow then we've reached follow point,
+            // otherwise we're probably chasing a creature
+            if (me->GetCharmerOrOwner() && me->GetCharmInfo() && data == me->GetCharmerOrOwner()->GetGUIDLow() && me->GetCharmInfo()->IsReturning())
+            {
+                ClearCharmInfoFlags();
+                me->GetCharmInfo()->SetIsFollowing(true);
+            }
+            break;
+        }
+        default:
+            break;
+    }
+}
+
+bool PetAI::CanAttack(Unit* target, const SpellInfo* spellInfo)
+{
+    // Evaluates wether a pet can attack a specific target based on CommandState, ReactState and other flags
+    // IMPORTANT: The order in which things are checked is important, be careful if you add or remove checks
+
+    // Hmmm...
+    if (!target)
+        return false;
+
+    if (!target->IsAlive())
+    {
+		// xinef: if target is invalid, pet should evade automaticly
+        // Clear target to prevent getting stuck on dead targets
+        //me->AttackStop();
+        //me->InterruptNonMeleeSpells(false);
+        return false;
+    }
+
+	// xinef: check unit states of pet
+	if (me->HasUnitState(UNIT_STATE_LOST_CONTROL))
+		return false;
+
+	// xinef: pets of mounted players have stunned flag only, check this also
+	if (me->HasFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_STUNNED))
+		return false;
+
+	// pussywizard: ZOMG! TEMP!
+	if (!me->GetCharmInfo())
+	{
+		sLog->outMisc("PetAI::CanAttack (A1) - %u, %u", me->GetEntry(), GUID_LOPART(me->GetOwnerGUID()));
+		return false;
+	}
+
+    // Passive - passive pets can attack if told to
+    if (me->HasReactState(REACT_PASSIVE))
+        return me->GetCharmInfo()->IsCommandAttack();
+
+    // CC - mobs under crowd control can be attacked if owner commanded
+	if (target->HasBreakableByDamageCrowdControlAura() && (!spellInfo || !spellInfo->HasAttribute(SPELL_ATTR4_DAMAGE_DOESNT_BREAK_AURAS)))
+        return me->GetCharmInfo()->IsCommandAttack();
+
+    // Returning - pets ignore attacks only if owner clicked follow
+    if (me->GetCharmInfo()->IsReturning())
+        return !me->GetCharmInfo()->IsCommandFollow();
+
+    // Stay - can attack if target is within range or commanded to
+    if (me->GetCharmInfo()->HasCommandState(COMMAND_STAY))
+        return (me->IsWithinMeleeRange(target) || me->GetCharmInfo()->IsCommandAttack());
+	
+    //  Pets attacking something (or chasing) should only switch targets if owner tells them to
+    if (me->GetVictim() && me->GetVictim() != target)
+    {
+        // Check if our owner selected this target and clicked "attack"
+        Unit* ownerTarget = NULL;
+        if (Player* owner = me->GetCharmerOrOwner()->ToPlayer())
+            ownerTarget = owner->GetSelectedUnit();
+        else
+            ownerTarget = me->GetCharmerOrOwner()->GetVictim();
+ 	
+        if (ownerTarget && me->GetCharmInfo()->IsCommandAttack())
+            return (target->GetGUID() == ownerTarget->GetGUID());
+    }
+
+    // Follow
+    if (me->GetCharmInfo()->HasCommandState(COMMAND_FOLLOW))
+        return !me->GetCharmInfo()->IsReturning();        
+
+    // default, though we shouldn't ever get here
+    return false;
+}
+
+void PetAI::ReceiveEmote(Player* player, uint32 emote)
+{
+    if (me->GetOwnerGUID() && me->GetOwnerGUID() == player->GetGUID())
+        switch (emote)
+        {
+            case TEXT_EMOTE_COWER:
+                if (me->IsPet() && me->ToPet()->IsPetGhoul())
+                    me->HandleEmoteCommand(/*EMOTE_ONESHOT_ROAR*/EMOTE_ONESHOT_OMNICAST_GHOUL);
+                break;
+            case TEXT_EMOTE_ANGRY:
+                if (me->IsPet() && me->ToPet()->IsPetGhoul())
+                    me->HandleEmoteCommand(/*EMOTE_ONESHOT_COWER*/EMOTE_STATE_STUN);
+                break;
+            case TEXT_EMOTE_GLARE:
+                if (me->IsPet() && me->ToPet()->IsPetGhoul())
+                    me->HandleEmoteCommand(EMOTE_STATE_STUN);
+                break;
+            case TEXT_EMOTE_SOOTHE:
+                if (me->IsPet() && me->ToPet()->IsPetGhoul())
+                    me->HandleEmoteCommand(EMOTE_ONESHOT_OMNICAST_GHOUL);
+                break;
+        }
+}
+
+void PetAI::ClearCharmInfoFlags()
+{
+    // Quick access to set all flags to FALSE
+
+    CharmInfo* ci = me->GetCharmInfo();
+
+    if (ci)
+    {
+        ci->SetIsAtStay(false);
+        ci->SetIsCommandAttack(false);
+        ci->SetIsCommandFollow(false);
+        ci->SetIsFollowing(false);
+        ci->SetIsReturning(false);
+    }
+}
+
+void PetAI::AttackedBy(Unit* attacker)
+{
+    // Called when pet takes damage. This function helps keep pets from running off
+    //  simply due to gaining aggro.
+
+    if (!attacker)
+        return;
+
+    // Passive pets don't do anything
+    if (me->HasReactState(REACT_PASSIVE))
+        return;
+
+    // Prevent pet from disengaging from current target
+    if (me->GetVictim() && me->GetVictim()->IsAlive())
+        return;
+
+    // Continue to evaluate and attack if necessary
+    AttackStart(attacker);
+}

src/server/game/AI/CoreAI/PetAI.h

@@ -0,0 +1,72 @@
+/*
+ * Copyright (C) 
+ * Copyright (C) 
+ *
+ * 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef TRINITY_PETAI_H
+#define TRINITY_PETAI_H
+
+#include "CreatureAI.h"
+#include "Timer.h"
+
+class Creature;
+class Spell;
+
+class PetAI : public CreatureAI
+{
+    public:
+
+        explicit PetAI(Creature* c);
+
+        void UpdateAI(uint32);
+        static int Permissible(const Creature*);
+
+        void KilledUnit(Unit* /*victim*/);
+        void AttackStart(Unit* target);
+        void MovementInform(uint32 moveType, uint32 data);
+        void OwnerAttackedBy(Unit* attacker);
+        void OwnerAttacked(Unit* target);
+        void AttackedBy(Unit* attacker);
+        void ReceiveEmote(Player* player, uint32 textEmote);
+
+        // The following aren't used by the PetAI but need to be defined to override
+        //  default CreatureAI functions which interfere with the PetAI
+        //
+        void MoveInLineOfSight(Unit* /*who*/) {} // CreatureAI interferes with returning pets
+        void MoveInLineOfSight_Safe(Unit* /*who*/) {} // CreatureAI interferes with returning pets
+        void EnterEvadeMode() {} // For fleeing, pets don't use this type of Evade mechanic
+		void SpellHit(Unit* caster, const SpellInfo* spellInfo);
+
+    private:
+        bool _isVisible(Unit*) const;
+        bool _needToStop(void);
+        void _stopAttack(void);
+		void _doMeleeAttack();
+		bool _canMeleeAttack() const;
+
+        void UpdateAllies();
+
+        TimeTracker i_tracker;
+        std::set<uint64> m_AllySet;
+        uint32 m_updateAlliesTimer;
+
+        Unit* SelectNextTarget(bool allowAutoSelect) const;
+        void HandleReturnMovement();
+        void DoAttack(Unit* target, bool chase);
+        bool CanAttack(Unit* target, const SpellInfo* spellInfo = NULL);
+        void ClearCharmInfoFlags();
+};
+#endif

src/server/game/AI/CoreAI/ReactorAI.cpp

@@ -0,0 +1,40 @@
+/*
+ * Copyright (C) 
+ * Copyright (C) 
+ *
+ * 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "ByteBuffer.h"
+#include "ReactorAI.h"
+#include "Errors.h"
+#include "Log.h"
+#include "ObjectAccessor.h"
+#include "CreatureAIImpl.h"
+
+int ReactorAI::Permissible(const Creature* creature)
+{
+    if (creature->IsCivilian() || creature->IsNeutralToAll())
+        return PERMIT_BASE_REACTIVE;
+
+    return PERMIT_BASE_NO;
+}
+
+void ReactorAI::UpdateAI(uint32 /*diff*/)
+{
+    if (!UpdateVictim())
+        return;
+
+    DoMeleeAttackIfReady();
+}

src/server/game/AI/CoreAI/ReactorAI.h

@@ -0,0 +1,37 @@
+/*
+ * Copyright (C) 
+ * Copyright (C) 
+ *
+ * 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef TRINITY_REACTORAI_H
+#define TRINITY_REACTORAI_H
+
+#include "CreatureAI.h"
+
+class Unit;
+
+class ReactorAI : public CreatureAI
+{
+    public:
+
+        explicit ReactorAI(Creature* c) : CreatureAI(c) {}
+
+        void MoveInLineOfSight(Unit*) {}
+        void UpdateAI(uint32 diff);
+
+        static int Permissible(const Creature*);
+};
+#endif

src/server/game/AI/CoreAI/TotemAI.cpp

@@ -0,0 +1,117 @@
+/*
+ * Copyright (C) 
+ * Copyright (C) 
+ *
+ * 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "TotemAI.h"
+#include "Totem.h"
+#include "Creature.h"
+#include "DBCStores.h"
+#include "ObjectAccessor.h"
+#include "SpellMgr.h"
+
+#include "GridNotifiers.h"
+#include "GridNotifiersImpl.h"
+#include "CellImpl.h"
+
+int TotemAI::Permissible(Creature const* creature)
+{
+    if (creature->IsTotem())
+        return PERMIT_BASE_PROACTIVE;
+
+    return PERMIT_BASE_NO;
+}
+
+TotemAI::TotemAI(Creature* c) : CreatureAI(c), i_victimGuid(0)
+{
+    ASSERT(c->IsTotem());
+}
+
+void TotemAI::SpellHit(Unit* /*caster*/, const SpellInfo* spellInfo)
+{
+}
+
+void TotemAI::DoAction(int32 param)
+{
+}
+
+void TotemAI::MoveInLineOfSight(Unit* /*who*/)
+{
+}
+
+void TotemAI::EnterEvadeMode()
+{
+    me->CombatStop(true);
+}
+
+void TotemAI::UpdateAI(uint32 /*diff*/)
+{
+    if (me->ToTotem()->GetTotemType() != TOTEM_ACTIVE)
+        return;
+
+    if (!me->IsAlive() || me->IsNonMeleeSpellCast(false))
+        return;
+
+    // Search spell
+    SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(me->ToTotem()->GetSpell());
+    if (!spellInfo)
+        return;
+
+    // Get spell range
+    float max_range = spellInfo->GetMaxRange(false);
+
+    // SPELLMOD_RANGE not applied in this place just because not existence range mods for attacking totems
+
+    // pointer to appropriate target if found any
+    Unit* victim = i_victimGuid ? ObjectAccessor::GetUnit(*me, i_victimGuid) : NULL;
+
+    // Search victim if no, not attackable, or out of range, or friendly (possible in case duel end)
+    if (!victim ||
+        !victim->isTargetableForAttack(true, me) || !me->IsWithinDistInMap(victim, max_range) ||
+        me->IsFriendlyTo(victim) || !me->CanSeeOrDetect(victim))
+    {
+        victim = NULL;
+        Trinity::NearestAttackableUnitInObjectRangeCheck u_check(me, me, max_range);
+        Trinity::UnitLastSearcher<Trinity::NearestAttackableUnitInObjectRangeCheck> checker(me, victim, u_check);
+        me->VisitNearbyObject(max_range, checker);
+    }
+
+    // If have target
+    if (victim)
+    {
+        // remember
+        i_victimGuid = victim->GetGUID();
+
+        // attack
+        me->SetInFront(victim);                         // client change orientation by self
+        me->CastSpell(victim, me->ToTotem()->GetSpell(), false);
+    }
+    else
+        i_victimGuid = 0;
+}
+
+void TotemAI::AttackStart(Unit* /*victim*/)
+{
+    // Sentry totem sends ping on attack
+    if (me->GetEntry() == SENTRY_TOTEM_ENTRY && me->GetOwner()->GetTypeId() == TYPEID_PLAYER)
+    {
+        WorldPacket data(MSG_MINIMAP_PING, (8+4+4));
+        data << me->GetGUID();
+        data << me->GetPositionX();
+        data << me->GetPositionY();
+        me->GetOwner()->ToPlayer()->GetSession()->SendPacket(&data);
+    }
+}

src/server/game/AI/CoreAI/TotemAI.h

@@ -0,0 +1,62 @@
+/*
+ * Copyright (C) 
+ * Copyright (C) 
+ *
+ * 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef TRINITY_TOTEMAI_H
+#define TRINITY_TOTEMAI_H
+
+#include "CreatureAI.h"
+#include "Timer.h"
+
+class Creature;
+class Totem;
+
+class TotemAI : public CreatureAI
+{
+    public:
+
+        explicit TotemAI(Creature* c);
+
+        void MoveInLineOfSight(Unit* who);
+        void AttackStart(Unit* victim);
+        void EnterEvadeMode();
+        void SpellHit(Unit* /*caster*/, const SpellInfo* /*spellInfo*/);
+        void DoAction(int32 param);
+
+        void UpdateAI(uint32 diff);
+        static int Permissible(Creature const* creature);
+
+    private:
+        uint64 i_victimGuid;
+};
+
+class KillMagnetEvent : public BasicEvent
+{
+	public:
+		KillMagnetEvent(Unit& self) : _self(self) { }
+		bool Execute(uint64 e_time, uint32 p_time)
+		{
+			_self.setDeathState(JUST_DIED);
+			return true;
+		}
+
+	protected:
+		Unit& _self;
+};
+
+#endif
+

src/server/game/AI/CoreAI/UnitAI.cpp

@@ -0,0 +1,336 @@
+/*
+ * Copyright (C) 
+ * Copyright (C) 
+ *
+ * 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "UnitAI.h"
+#include "Player.h"
+#include "Creature.h"
+#include "SpellAuras.h"
+#include "SpellAuraEffects.h"
+#include "SpellMgr.h"
+#include "SpellInfo.h"
+#include "Spell.h"
+#include "CreatureAIImpl.h"
+
+void UnitAI::AttackStart(Unit* victim)
+{
+    if (victim && me->Attack(victim, true))
+        me->GetMotionMaster()->MoveChase(victim);
+}
+
+void UnitAI::AttackStartCaster(Unit* victim, float dist)
+{
+    if (victim && me->Attack(victim, false))
+        me->GetMotionMaster()->MoveChase(victim, dist);
+}
+
+void UnitAI::DoMeleeAttackIfReady()
+{
+    if (me->HasUnitState(UNIT_STATE_CASTING))
+        return;
+
+    Unit *victim = me->GetVictim();
+    if (!victim || !victim->IsInWorld())
+        return;
+
+    if (!me->IsWithinMeleeRange(victim))
+        return;
+
+    //Make sure our attack is ready and we aren't currently casting before checking distance
+    if (me->isAttackReady())
+    {
+		// xinef: prevent base and off attack in same time, delay attack at 0.2 sec
+		if (me->haveOffhandWeapon())
+			if (me->getAttackTimer(OFF_ATTACK) < ATTACK_DISPLAY_DELAY)
+				me->setAttackTimer(OFF_ATTACK, ATTACK_DISPLAY_DELAY);
+
+        me->AttackerStateUpdate(victim);
+        me->resetAttackTimer();
+    }
+
+    if (me->haveOffhandWeapon() && me->isAttackReady(OFF_ATTACK))
+    {
+		// xinef: delay main hand attack if both will hit at the same time (players code)
+		if (me->getAttackTimer(BASE_ATTACK) < ATTACK_DISPLAY_DELAY)
+            me->setAttackTimer(BASE_ATTACK, ATTACK_DISPLAY_DELAY);
+
+        me->AttackerStateUpdate(victim, OFF_ATTACK);
+        me->resetAttackTimer(OFF_ATTACK);
+    }
+}
+
+bool UnitAI::DoSpellAttackIfReady(uint32 spell)
+{
+    if (me->HasUnitState(UNIT_STATE_CASTING) || !me->isAttackReady())
+        return true;
+
+    if (SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(spell))
+    {
+        if (me->IsWithinCombatRange(me->GetVictim(), spellInfo->GetMaxRange(false)))
+        {
+            me->CastSpell(me->GetVictim(), spell, false);
+            me->resetAttackTimer();
+            return true;
+        }
+    }
+
+    return false;
+}
+
+Unit* UnitAI::SelectTarget(SelectAggroTarget targetType, uint32 position, float dist, bool playerOnly, int32 aura)
+{
+    return SelectTarget(targetType, position, DefaultTargetSelector(me, dist, playerOnly, aura));
+}
+
+void UnitAI::SelectTargetList(std::list<Unit*>& targetList, uint32 num, SelectAggroTarget targetType, float dist, bool playerOnly, int32 aura)
+{
+    SelectTargetList(targetList, DefaultTargetSelector(me, dist, playerOnly, aura), num, targetType);
+}
+
+float UnitAI::DoGetSpellMaxRange(uint32 spellId, bool positive)
+{
+    SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(spellId);
+    return spellInfo ? spellInfo->GetMaxRange(positive) : 0;
+}
+
+void UnitAI::DoAddAuraToAllHostilePlayers(uint32 spellid)
+{
+    if (me->IsInCombat())
+    {
+        ThreatContainer::StorageType threatlist = me->getThreatManager().getThreatList();
+        for (ThreatContainer::StorageType::const_iterator itr = threatlist.begin(); itr != threatlist.end(); ++itr)
+        {
+            if (Unit* unit = ObjectAccessor::GetUnit(*me, (*itr)->getUnitGuid()))
+                if (unit->GetTypeId() == TYPEID_PLAYER)
+                    me->AddAura(spellid, unit);
+        }
+    }
+}
+
+void UnitAI::DoCastToAllHostilePlayers(uint32 spellid, bool triggered)
+{
+    if (me->IsInCombat())
+    {
+        ThreatContainer::StorageType threatlist = me->getThreatManager().getThreatList();
+        for (ThreatContainer::StorageType::const_iterator itr = threatlist.begin(); itr != threatlist.end(); ++itr)
+        {
+            if (Unit* unit = ObjectAccessor::GetUnit(*me, (*itr)->getUnitGuid()))
+                if (unit->GetTypeId() == TYPEID_PLAYER)
+                    me->CastSpell(unit, spellid, triggered);
+        }
+    }
+}
+
+void UnitAI::DoCast(uint32 spellId)
+{
+    Unit* target = NULL;
+    //sLog->outError("aggre %u %u", spellId, (uint32)AISpellInfo[spellId].target);
+    switch (AISpellInfo[spellId].target)
+    {
+        default:
+        case AITARGET_SELF:     target = me; break;
+        case AITARGET_VICTIM:   target = me->GetVictim(); break;
+        case AITARGET_ENEMY:
+        {
+            const SpellInfo* spellInfo = sSpellMgr->GetSpellInfo(spellId);
+            bool playerOnly = spellInfo->HasAttribute(SPELL_ATTR3_ONLY_TARGET_PLAYERS);
+            //float range = GetSpellMaxRange(spellInfo, false);
+            target = SelectTarget(SELECT_TARGET_RANDOM, 0, spellInfo->GetMaxRange(false), playerOnly);
+            break;
+        }
+        case AITARGET_ALLY:     target = me; break;
+        case AITARGET_BUFF:     target = me; break;
+        case AITARGET_DEBUFF:
+        {
+            const SpellInfo* spellInfo = sSpellMgr->GetSpellInfo(spellId);
+            bool playerOnly = spellInfo->HasAttribute(SPELL_ATTR3_ONLY_TARGET_PLAYERS);
+            float range = spellInfo->GetMaxRange(false);
+
+            DefaultTargetSelector targetSelector(me, range, playerOnly, -(int32)spellId);
+            if (!(spellInfo->AuraInterruptFlags & AURA_INTERRUPT_FLAG_NOT_VICTIM)
+                && targetSelector(me->GetVictim()))
+                target = me->GetVictim();
+            else
+                target = SelectTarget(SELECT_TARGET_RANDOM, 0, targetSelector);
+            break;
+        }
+    }
+
+    if (target)
+        me->CastSpell(target, spellId, false);
+}
+
+void UnitAI::DoCast(Unit* victim, uint32 spellId, bool triggered)
+{
+    if (!victim || (me->HasUnitState(UNIT_STATE_CASTING) && !triggered))
+        return;
+
+    me->CastSpell(victim, spellId, triggered);
+}
+
+void UnitAI::DoCastVictim(uint32 spellId, bool triggered)
+{
+    if (!me->GetVictim() || (me->HasUnitState(UNIT_STATE_CASTING) && !triggered))
+        return;
+
+    me->CastSpell(me->GetVictim(), spellId, triggered);
+}
+
+void UnitAI::DoCastAOE(uint32 spellId, bool triggered)
+{
+    if (!triggered && me->HasUnitState(UNIT_STATE_CASTING))
+        return;
+
+    me->CastSpell((Unit*)NULL, spellId, triggered);
+}
+
+#define UPDATE_TARGET(a) {if (AIInfo->target<a) AIInfo->target=a;}
+
+void UnitAI::FillAISpellInfo()
+{
+    AISpellInfo = new AISpellInfoType[sSpellMgr->GetSpellInfoStoreSize()];
+
+    AISpellInfoType* AIInfo = AISpellInfo;
+    const SpellInfo* spellInfo;
+
+    for (uint32 i = 0; i < sSpellMgr->GetSpellInfoStoreSize(); ++i, ++AIInfo)
+    {
+        spellInfo = sSpellMgr->GetSpellInfo(i);
+        if (!spellInfo)
+            continue;
+
+        if (spellInfo->HasAttribute(SPELL_ATTR0_CASTABLE_WHILE_DEAD))
+            AIInfo->condition = AICOND_DIE;
+        else if (spellInfo->IsPassive() || spellInfo->GetDuration() == -1)
+            AIInfo->condition = AICOND_AGGRO;
+        else
+            AIInfo->condition = AICOND_COMBAT;
+
+        if (AIInfo->cooldown < spellInfo->RecoveryTime)
+            AIInfo->cooldown = spellInfo->RecoveryTime;
+
+        if (!spellInfo->GetMaxRange(false))
+            UPDATE_TARGET(AITARGET_SELF)
+        else
+        {
+            for (uint32 j = 0; j < MAX_SPELL_EFFECTS; ++j)
+            {
+                uint32 targetType = spellInfo->Effects[j].TargetA.GetTarget();
+
+                if (targetType == TARGET_UNIT_TARGET_ENEMY
+                    || targetType == TARGET_DEST_TARGET_ENEMY)
+                    UPDATE_TARGET(AITARGET_VICTIM)
+                else if (targetType == TARGET_UNIT_DEST_AREA_ENEMY)
+                    UPDATE_TARGET(AITARGET_ENEMY)
+
+                if (spellInfo->Effects[j].Effect == SPELL_EFFECT_APPLY_AURA)
+                {
+                    if (targetType == TARGET_UNIT_TARGET_ENEMY)
+                        UPDATE_TARGET(AITARGET_DEBUFF)
+                    else if (spellInfo->IsPositive())
+                        UPDATE_TARGET(AITARGET_BUFF)
+                }
+            }
+        }
+        AIInfo->realCooldown = spellInfo->RecoveryTime + spellInfo->StartRecoveryTime;
+        AIInfo->maxRange = spellInfo->GetMaxRange(false) * 3 / 4;
+    }
+}
+
+//Enable PlayerAI when charmed
+void PlayerAI::OnCharmed(bool apply)
+{
+    me->IsAIEnabled = apply;
+}
+
+void SimpleCharmedAI::UpdateAI(uint32 /*diff*/)
+{
+  Creature* charmer = me->GetCharmer()->ToCreature();
+
+    //kill self if charm aura has infinite duration
+    if (charmer->IsInEvadeMode())
+    {
+        Unit::AuraEffectList const& auras = me->GetAuraEffectsByType(SPELL_AURA_MOD_CHARM);
+        for (Unit::AuraEffectList::const_iterator iter = auras.begin(); iter != auras.end(); ++iter)
+            if ((*iter)->GetCasterGUID() == charmer->GetGUID() && (*iter)->GetBase()->IsPermanent())
+            {
+                Unit::Kill(charmer, me);
+                return;
+            }
+    }
+
+    if (!charmer->IsInCombat())
+        me->GetMotionMaster()->MoveFollow(charmer, PET_FOLLOW_DIST, me->GetFollowAngle());
+
+    Unit* target = me->GetVictim();
+    if (!target || !charmer->IsValidAttackTarget(target))
+        AttackStart(charmer->SelectNearestTargetInAttackDistance(ATTACK_DISTANCE));
+}
+
+SpellTargetSelector::SpellTargetSelector(Unit* caster, uint32 spellId) :
+    _caster(caster), _spellInfo(sSpellMgr->GetSpellForDifficultyFromSpell(sSpellMgr->GetSpellInfo(spellId), caster))
+{
+    ASSERT(_spellInfo);
+}
+
+bool SpellTargetSelector::operator()(Unit const* target) const
+{
+    if (!target)
+        return false;
+
+    if (_spellInfo->CheckTarget(_caster, target) != SPELL_CAST_OK)
+        return false;
+
+    // copypasta from Spell::CheckRange
+    uint32 range_type = _spellInfo->RangeEntry ? _spellInfo->RangeEntry->type : 0;
+    float max_range = _caster->GetSpellMaxRangeForTarget(target, _spellInfo);
+    float min_range = _caster->GetSpellMinRangeForTarget(target, _spellInfo);
+
+
+    if (target && target != _caster)
+    {
+        if (range_type == SPELL_RANGE_MELEE)
+        {
+            // Because of lag, we can not check too strictly here.
+            if (!_caster->IsWithinMeleeRange(target, max_range))
+                return false;
+        }
+        else if (!_caster->IsWithinCombatRange(target, max_range))
+            return false;
+
+        if (range_type == SPELL_RANGE_RANGED)
+        {
+            if (_caster->IsWithinMeleeRange(target))
+                return false;
+        }
+        else if (min_range && _caster->IsWithinCombatRange(target, min_range)) // skip this check if min_range = 0
+            return false;
+    }
+
+    return true;
+}
+
+bool NonTankTargetSelector::operator()(Unit const* target) const
+{
+    if (!target)
+        return false;
+
+    if (_playerOnly && target->GetTypeId() != TYPEID_PLAYER)
+        return false;
+
+    return target != _source->GetVictim();
+}

src/server/game/AI/CoreAI/UnitAI.h

@@ -0,0 +1,340 @@
+/*
+ * Copyright (C) 
+ * Copyright (C) 
+ *
+ * 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef TRINITY_UNITAI_H
+#define TRINITY_UNITAI_H
+
+#include "Define.h"
+#include "Unit.h"
+#include "Containers.h"
+#include <list>
+
+class Player;
+class Quest;
+class Unit;
+struct AISpellInfoType;
+
+//Selection method used by SelectTarget
+enum SelectAggroTarget
+{
+    SELECT_TARGET_RANDOM = 0,                               //Just selects a random target
+    SELECT_TARGET_TOPAGGRO,                                 //Selects targes from top aggro to bottom
+    SELECT_TARGET_BOTTOMAGGRO,                              //Selects targets from bottom aggro to top
+    SELECT_TARGET_NEAREST,
+    SELECT_TARGET_FARTHEST,
+};
+
+// default predicate function to select target based on distance, player and/or aura criteria
+struct DefaultTargetSelector : public std::unary_function<Unit*, bool>
+{
+    const Unit* me;
+    float m_dist;
+    bool m_playerOnly;
+    int32 m_aura;
+
+    // unit: the reference unit
+    // dist: if 0: ignored, if > 0: maximum distance to the reference unit, if < 0: minimum distance to the reference unit
+    // playerOnly: self explaining
+    // aura: if 0: ignored, if > 0: the target shall have the aura, if < 0, the target shall NOT have the aura
+    DefaultTargetSelector(Unit const* unit, float dist, bool playerOnly, int32 aura) : me(unit), m_dist(dist), m_playerOnly(playerOnly), m_aura(aura) {}
+
+    bool operator()(Unit const* target) const
+    {
+        if (!me)
+            return false;
+
+        if (!target)
+            return false;
+
+        if (m_playerOnly && (target->GetTypeId() != TYPEID_PLAYER))
+            return false;
+
+        if (m_dist > 0.0f && !me->IsWithinCombatRange(target, m_dist))
+            return false;
+
+        if (m_dist < 0.0f && me->IsWithinCombatRange(target, -m_dist))
+            return false;
+
+        if (m_aura)
+        {
+            if (m_aura > 0)
+            {
+                if (!target->HasAura(m_aura))
+                    return false;
+            }
+            else
+            {
+                if (target->HasAura(-m_aura))
+                    return false;
+            }
+        }
+
+        return true;
+    }
+};
+
+// Target selector for spell casts checking range, auras and attributes
+// TODO: Add more checks from Spell::CheckCast
+struct SpellTargetSelector : public std::unary_function<Unit*, bool>
+{
+    public:
+        SpellTargetSelector(Unit* caster, uint32 spellId);
+        bool operator()(Unit const* target) const;
+
+    private:
+        Unit const* _caster;
+        SpellInfo const* _spellInfo;
+};
+
+// Very simple target selector, will just skip main target
+// NOTE: When passing to UnitAI::SelectTarget remember to use 0 as position for random selection
+//       because tank will not be in the temporary list
+struct NonTankTargetSelector : public std::unary_function<Unit*, bool>
+{
+    public:
+        NonTankTargetSelector(Creature* source, bool playerOnly = true) : _source(source), _playerOnly(playerOnly) { }
+        bool operator()(Unit const* target) const;
+
+    private:
+        Creature const* _source;
+        bool _playerOnly;
+};
+
+// Simple selector for units using mana
+struct PowerUsersSelector : public std::unary_function<Unit*, bool>
+{
+    Unit const* _me;
+    float const _dist;
+    bool const _playerOnly;
+	Powers const _power;
+
+
+    PowerUsersSelector(Unit const* unit, Powers power, float dist, bool playerOnly) : _me(unit), _power(power), _dist(dist), _playerOnly(playerOnly) { }
+
+    bool operator()(Unit const* target) const
+    {
+        if (!_me || !target)
+            return false;
+
+		if (target->getPowerType() != _power)
+			return false;
+
+        if (_playerOnly && target->GetTypeId() != TYPEID_PLAYER)
+            return false;
+
+        if (_dist > 0.0f && !_me->IsWithinCombatRange(target, _dist))
+            return false;
+
+        if (_dist < 0.0f && _me->IsWithinCombatRange(target, -_dist))
+            return false;
+
+        return true;
+    }
+};
+
+struct FarthestTargetSelector : public std::unary_function<Unit*, bool>
+{
+    FarthestTargetSelector(Unit const* unit, float dist, bool playerOnly, bool inLos) : _me(unit), _dist(dist), _playerOnly(playerOnly), _inLos(inLos) {}
+
+    bool operator()(Unit const* target) const
+    {
+        if (!_me || !target)
+            return false;
+
+        if (_playerOnly && target->GetTypeId() != TYPEID_PLAYER)
+            return false;
+
+        if (_dist > 0.0f && !_me->IsWithinCombatRange(target, _dist))
+            return false;
+
+		if (_inLos && !_me->IsWithinLOSInMap(target))
+			return false;
+
+        return true;
+    }
+
+private:
+    const Unit* _me;
+    float _dist;
+    bool _playerOnly;
+	bool _inLos;
+};
+
+class UnitAI
+{
+    protected:
+        Unit* const me;
+    public:
+        explicit UnitAI(Unit* unit) : me(unit) {}
+        virtual ~UnitAI() {}
+
+        virtual bool CanAIAttack(Unit const* /*target*/) const { return true; }
+        virtual void AttackStart(Unit* /*target*/);
+        virtual void UpdateAI(uint32 diff) = 0;
+
+        virtual void InitializeAI() { if (!me->isDead()) Reset(); }
+
+        virtual void Reset() {};
+
+        // Called when unit is charmed
+        virtual void OnCharmed(bool apply) = 0;
+
+        // Pass parameters between AI
+        virtual void DoAction(int32 /*param*/) {}
+        virtual uint32 GetData(uint32 /*id = 0*/) const { return 0; }
+        virtual void SetData(uint32 /*id*/, uint32 /*value*/) {}
+        virtual void SetGUID(uint64 /*guid*/, int32 /*id*/ = 0) {}
+        virtual uint64 GetGUID(int32 /*id*/ = 0) const { return 0; }
+
+        Unit* SelectTarget(SelectAggroTarget targetType, uint32 position = 0, float dist = 0.0f, bool playerOnly = false, int32 aura = 0);
+        // Select the targets satifying the predicate.
+        // predicate shall extend std::unary_function<Unit*, bool>
+        template <class PREDICATE> Unit* SelectTarget(SelectAggroTarget targetType, uint32 position, PREDICATE const& predicate)
+        {
+            ThreatContainer::StorageType const& threatlist = me->getThreatManager().getThreatList();
+            if (position >= threatlist.size())
+                return NULL;
+
+            std::list<Unit*> targetList;
+            for (ThreatContainer::StorageType::const_iterator itr = threatlist.begin(); itr != threatlist.end(); ++itr)
+                if (predicate((*itr)->getTarget()))
+                    targetList.push_back((*itr)->getTarget());
+
+            if (position >= targetList.size())
+                return NULL;
+
+            if (targetType == SELECT_TARGET_NEAREST || targetType == SELECT_TARGET_FARTHEST)
+                targetList.sort(Trinity::ObjectDistanceOrderPred(me));
+
+            switch (targetType)
+            {
+                case SELECT_TARGET_NEAREST:
+                case SELECT_TARGET_TOPAGGRO:
+                {
+                    std::list<Unit*>::iterator itr = targetList.begin();
+                    std::advance(itr, position);
+                    return *itr;
+                }
+                case SELECT_TARGET_FARTHEST:
+                case SELECT_TARGET_BOTTOMAGGRO:
+                {
+                    std::list<Unit*>::reverse_iterator ritr = targetList.rbegin();
+                    std::advance(ritr, position);
+                    return *ritr;
+                }
+                case SELECT_TARGET_RANDOM:
+                {
+                    std::list<Unit*>::iterator itr = targetList.begin();
+                    std::advance(itr, urand(position, targetList.size() - 1));
+                    return *itr;
+                }
+                default:
+                    break;
+            }
+
+            return NULL;
+        }
+
+        void SelectTargetList(std::list<Unit*>& targetList, uint32 num, SelectAggroTarget targetType, float dist = 0.0f, bool playerOnly = false, int32 aura = 0);
+
+        // Select the targets satifying the predicate.
+        // predicate shall extend std::unary_function<Unit*, bool>
+        template <class PREDICATE> void SelectTargetList(std::list<Unit*>& targetList, PREDICATE const& predicate, uint32 maxTargets, SelectAggroTarget targetType)
+        {
+            ThreatContainer::StorageType const& threatlist = me->getThreatManager().getThreatList();
+            if (threatlist.empty())
+                return;
+
+            for (ThreatContainer::StorageType::const_iterator itr = threatlist.begin(); itr != threatlist.end(); ++itr)
+                if (predicate((*itr)->getTarget()))
+                    targetList.push_back((*itr)->getTarget());
+
+            if (targetList.size() < maxTargets)
+                return;
+
+            if (targetType == SELECT_TARGET_NEAREST || targetType == SELECT_TARGET_FARTHEST)
+                targetList.sort(Trinity::ObjectDistanceOrderPred(me));
+
+            if (targetType == SELECT_TARGET_FARTHEST || targetType == SELECT_TARGET_BOTTOMAGGRO)
+                targetList.reverse();
+
+            if (targetType == SELECT_TARGET_RANDOM)
+                Trinity::Containers::RandomResizeList(targetList, maxTargets);
+            else
+                targetList.resize(maxTargets);
+        }
+
+        // Called at any Damage to any victim (before damage apply)
+        virtual void DamageDealt(Unit* /*victim*/, uint32& /*damage*/, DamageEffectType /*damageType*/) { }
+
+        // Called at any Damage from any attacker (before damage apply)
+        // Note: it for recalculation damage or special reaction at damage
+        // for attack reaction use AttackedBy called for not DOT damage in Unit::DealDamage also
+        virtual void DamageTaken(Unit* /*attacker*/, uint32& /*damage*/, DamageEffectType /*damagetype*/, SpellSchoolMask /*damageSchoolMask*/ ) {}
+
+        // Called when the creature receives heal
+        virtual void HealReceived(Unit* /*done_by*/, uint32& /*addhealth*/) {}
+
+        // Called when the unit heals
+        virtual void HealDone(Unit* /*done_to*/, uint32& /*addhealth*/) {}
+
+        void AttackStartCaster(Unit* victim, float dist);
+
+        void DoAddAuraToAllHostilePlayers(uint32 spellid);
+        void DoCast(uint32 spellId);
+        void DoCast(Unit* victim, uint32 spellId, bool triggered = false);
+        void DoCastToAllHostilePlayers(uint32 spellid, bool triggered = false);
+        void DoCastVictim(uint32 spellId, bool triggered = false);
+        void DoCastAOE(uint32 spellId, bool triggered = false);
+
+        float DoGetSpellMaxRange(uint32 spellId, bool positive = false);
+
+        void DoMeleeAttackIfReady();
+        bool DoSpellAttackIfReady(uint32 spell);
+
+        static AISpellInfoType* AISpellInfo;
+        static void FillAISpellInfo();
+
+        virtual void sGossipHello(Player* /*player*/) {}
+        virtual void sGossipSelect(Player* /*player*/, uint32 /*sender*/, uint32 /*action*/) {}
+        virtual void sGossipSelectCode(Player* /*player*/, uint32 /*sender*/, uint32 /*action*/, char const* /*code*/) {}
+        virtual void sQuestAccept(Player* /*player*/, Quest const* /*quest*/) {}
+        virtual void sQuestSelect(Player* /*player*/, Quest const* /*quest*/) {}
+        virtual void sQuestComplete(Player* /*player*/, Quest const* /*quest*/) {}
+        virtual void sQuestReward(Player* /*player*/, Quest const* /*quest*/, uint32 /*opt*/) {}
+        virtual void sOnGameEvent(bool /*start*/, uint16 /*eventId*/) {}
+};
+
+class PlayerAI : public UnitAI
+{
+    protected:
+        Player* const me;
+    public:
+        explicit PlayerAI(Player* player) : UnitAI((Unit*)player), me(player) {}
+
+        void OnCharmed(bool apply);
+};
+
+class SimpleCharmedAI : public PlayerAI
+{
+    public:
+        void UpdateAI(uint32 diff);
+        SimpleCharmedAI(Player* player): PlayerAI(player) {}
+};
+
+#endif

src/server/game/AI/CreatureAI.cpp

@@ -0,0 +1,268 @@
+/*
+ * Copyright (C) 
+ * Copyright (C) 
+ *
+ * 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "CreatureAI.h"
+#include "CreatureAIImpl.h"
+#include "Creature.h"
+#include "World.h"
+#include "SpellMgr.h"
+#include "Vehicle.h"
+#include "Log.h"
+#include "MapReference.h"
+#include "Player.h"
+#include "CreatureTextMgr.h"
+
+//Disable CreatureAI when charmed
+void CreatureAI::OnCharmed(bool /*apply*/)
+{
+    //me->IsAIEnabled = !apply;*/
+    me->NeedChangeAI = true;
+    me->IsAIEnabled = false;
+}
+
+AISpellInfoType* UnitAI::AISpellInfo;
+AISpellInfoType* GetAISpellInfo(uint32 i) { return &CreatureAI::AISpellInfo[i]; }
+
+void CreatureAI::Talk(uint8 id, WorldObject const* whisperTarget /*= NULL*/)
+{
+    sCreatureTextMgr->SendChat(me, id, whisperTarget);
+}
+
+void CreatureAI::DoZoneInCombat(Creature* creature /*= NULL*/, float maxRangeToNearestTarget /* = 50.0f*/)
+{
+    if (!creature)
+        creature = me;
+
+    if (!creature->CanHaveThreatList())
+        return;
+
+    Map* map = creature->GetMap();
+    if (!map->IsDungeon())                                  //use IsDungeon instead of Instanceable, in case battlegrounds will be instantiated
+    {
+        sLog->outError("DoZoneInCombat call for map that isn't an instance (creature entry = %d)", creature->GetTypeId() == TYPEID_UNIT ? creature->ToCreature()->GetEntry() : 0);
+        return;
+    }
+
+	// Xinef: Skip creatures in evade mode
+	if (!creature->HasReactState(REACT_PASSIVE) && !creature->GetVictim() && !creature->IsInEvadeMode())
+    {
+        if (Unit* nearTarget = creature->SelectNearestTarget(maxRangeToNearestTarget))
+            creature->AI()->AttackStart(nearTarget);
+        else if (creature->IsSummon())
+        {
+            if (Unit* summoner = creature->ToTempSummon()->GetSummoner())
+            {
+                Unit* target = summoner->getAttackerForHelper();
+                if (!target && summoner->CanHaveThreatList() && !summoner->getThreatManager().isThreatListEmpty())
+                    target = summoner->getThreatManager().getHostilTarget();
+                if (target && (creature->IsFriendlyTo(summoner) || creature->IsHostileTo(target)))
+                    creature->AI()->AttackStart(target);
+            }
+        }
+    }
+
+    if (!creature->HasReactState(REACT_PASSIVE) && !creature->GetVictim())
+    {
+        sLog->outError("DoZoneInCombat called for creature that has empty threat list (creature entry = %u)", creature->GetEntry());
+        return;
+    }
+
+    Map::PlayerList const& playerList = map->GetPlayers();
+
+    if (playerList.isEmpty())
+        return;
+
+    for (Map::PlayerList::const_iterator itr = playerList.begin(); itr != playerList.end(); ++itr)
+    {
+        if (Player* player = itr->GetSource())
+        {
+            if (player->IsGameMaster())
+                continue;
+
+            if (player->IsAlive())
+            {
+                creature->SetInCombatWith(player);
+                player->SetInCombatWith(creature);
+                creature->AddThreat(player, 0.0f);
+            }
+
+            /* Causes certain things to never leave the threat list (Priest Lightwell, etc):
+            for (Unit::ControlSet::const_iterator itr = player->m_Controlled.begin(); itr != player->m_Controlled.end(); ++itr)
+            {
+                creature->SetInCombatWith(*itr);
+                (*itr)->SetInCombatWith(creature);
+                creature->AddThreat(*itr, 0.0f);
+            }*/
+        }
+    }
+}
+
+// scripts does not take care about MoveInLineOfSight loops
+// MoveInLineOfSight can be called inside another MoveInLineOfSight and cause stack overflow
+void CreatureAI::MoveInLineOfSight_Safe(Unit* who)
+{
+    if (m_MoveInLineOfSight_locked == true)
+        return;
+    m_MoveInLineOfSight_locked = true;
+    MoveInLineOfSight(who);
+    m_MoveInLineOfSight_locked = false;
+}
+
+void CreatureAI::MoveInLineOfSight(Unit* who)
+{
+    if (me->GetVictim())
+        return;
+
+	// pussywizard: civilian, non-combat pet or any other NOT HOSTILE TO ANYONE (!)
+	if (me->IsMoveInLineOfSightDisabled())
+		if (me->GetCreatureType() == CREATURE_TYPE_NON_COMBAT_PET ||      // nothing more to do, return
+			!who->IsInCombat() ||                                         // if not in combat, nothing more to do
+			!me->IsWithinDist(who, ATTACK_DISTANCE))                      // if in combat and in dist - neutral to all can actually assist other creatures
+			return;
+
+    if (me->CanStartAttack(who))
+        AttackStart(who);
+}
+
+void CreatureAI::EnterEvadeMode()
+{
+    if (!_EnterEvadeMode())
+        return;
+
+    ;//sLog->outDebug(LOG_FILTER_UNITS, "Creature %u enters evade mode.", me->GetEntry());
+
+    if (!me->GetVehicle()) // otherwise me will be in evade mode forever
+    {
+        if (Unit* owner = me->GetCharmerOrOwner())
+        {
+            me->GetMotionMaster()->Clear(false);
+            me->GetMotionMaster()->MoveFollow(owner, PET_FOLLOW_DIST, me->GetFollowAngle(), MOTION_SLOT_ACTIVE);
+        }
+        else
+        {
+            // Required to prevent attacking creatures that are evading and cause them to reenter combat
+            // Does not apply to MoveFollow
+            me->AddUnitState(UNIT_STATE_EVADE);
+            me->GetMotionMaster()->MoveTargetedHome();
+        }
+    }
+
+    Reset();
+
+    if (me->IsVehicle()) // use the same sequence of addtoworld, aireset may remove all summons!
+        me->GetVehicleKit()->Reset(true);
+}
+
+/*void CreatureAI::AttackedBy(Unit* attacker)
+{
+    if (!me->GetVictim())
+        AttackStart(attacker);
+}*/
+
+void CreatureAI::SetGazeOn(Unit* target)
+{
+    if (me->IsValidAttackTarget(target))
+    {
+        AttackStart(target);
+        me->SetReactState(REACT_PASSIVE);
+    }
+}
+
+bool CreatureAI::UpdateVictimWithGaze()
+{
+    if (!me->IsInCombat())
+        return false;
+
+    if (me->HasReactState(REACT_PASSIVE))
+    {
+        if (me->GetVictim())
+            return true;
+        else
+            me->SetReactState(REACT_AGGRESSIVE);
+    }
+
+    if (Unit* victim = me->SelectVictim())
+        AttackStart(victim);
+    return me->GetVictim();
+}
+
+bool CreatureAI::UpdateVictim()
+{
+    if (!me->IsInCombat())
+        return false;
+
+    if (!me->HasReactState(REACT_PASSIVE))
+    {
+        if (Unit* victim = me->SelectVictim())
+            AttackStart(victim);
+        return me->GetVictim();
+    }
+	// xinef: if we have any victim, just return true
+	else if (me->GetVictim() && me->GetExactDist(me->GetVictim()) < 30.0f)
+		return true;
+    else if (me->getThreatManager().isThreatListEmpty())
+    {
+        EnterEvadeMode();
+        return false;
+    }
+
+    return true;
+}
+
+bool CreatureAI::_EnterEvadeMode()
+{
+    if (!me->IsAlive())
+        return false;
+
+    // don't remove vehicle auras, passengers aren't supposed to drop off the vehicle
+    // don't remove clone caster on evade (to be verified)
+    me->RemoveEvadeAuras();
+
+    // sometimes bosses stuck in combat?
+    me->DeleteThreatList();
+    me->CombatStop(true);
+    me->LoadCreaturesAddon(true);
+    me->SetLootRecipient(NULL);
+    me->ResetPlayerDamageReq();
+    me->SetLastDamagedTime(0);
+
+    if (me->IsInEvadeMode())
+        return false;
+
+    return true;
+}
+
+Creature* CreatureAI::DoSummon(uint32 entry, const Position& pos, uint32 despawnTime, TempSummonType summonType)
+{
+    return me->SummonCreature(entry, pos, summonType, despawnTime);
+}
+
+Creature* CreatureAI::DoSummon(uint32 entry, WorldObject* obj, float radius, uint32 despawnTime, TempSummonType summonType)
+{
+    Position pos;
+    obj->GetRandomNearPosition(pos, radius);
+    return me->SummonCreature(entry, pos, summonType, despawnTime);
+}
+
+Creature* CreatureAI::DoSummonFlyer(uint32 entry, WorldObject* obj, float flightZ, float radius, uint32 despawnTime, TempSummonType summonType)
+{
+    Position pos;
+    obj->GetRandomNearPosition(pos, radius);
+    pos.m_positionZ += flightZ;
+    return me->SummonCreature(entry, pos, summonType, despawnTime);
+}

src/server/game/AI/CreatureAI.h

@@ -0,0 +1,193 @@
+/*
+ * Copyright (C) 
+ * Copyright (C) 
+ *
+ * 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef TRINITY_CREATUREAI_H
+#define TRINITY_CREATUREAI_H
+
+#include "Creature.h"
+#include "UnitAI.h"
+#include "Common.h"
+
+class WorldObject;
+class Unit;
+class Creature;
+class Player;
+class SpellInfo;
+
+#define TIME_INTERVAL_LOOK   5000
+#define VISIBILITY_RANGE    10000
+
+//Spell targets used by SelectSpell
+enum SelectTargetType
+{
+    SELECT_TARGET_DONTCARE = 0,                             //All target types allowed
+
+    SELECT_TARGET_SELF,                                     //Only Self casting
+
+    SELECT_TARGET_SINGLE_ENEMY,                             //Only Single Enemy
+    SELECT_TARGET_AOE_ENEMY,                                //Only AoE Enemy
+    SELECT_TARGET_ANY_ENEMY,                                //AoE or Single Enemy
+
+    SELECT_TARGET_SINGLE_FRIEND,                            //Only Single Friend
+    SELECT_TARGET_AOE_FRIEND,                               //Only AoE Friend
+    SELECT_TARGET_ANY_FRIEND,                               //AoE or Single Friend
+};
+
+//Spell Effects used by SelectSpell
+enum SelectEffect
+{
+    SELECT_EFFECT_DONTCARE = 0,                             //All spell effects allowed
+    SELECT_EFFECT_DAMAGE,                                   //Spell does damage
+    SELECT_EFFECT_HEALING,                                  //Spell does healing
+    SELECT_EFFECT_AURA,                                     //Spell applies an aura
+};
+
+enum SCEquip
+{
+    EQUIP_NO_CHANGE = -1,
+    EQUIP_UNEQUIP   = 0
+};
+
+class CreatureAI : public UnitAI
+{
+    protected:
+        Creature* const me;
+
+        bool UpdateVictim();
+        bool UpdateVictimWithGaze();
+
+        void SetGazeOn(Unit* target);
+
+        Creature* DoSummon(uint32 entry, Position const& pos, uint32 despawnTime = 30000, TempSummonType summonType = TEMPSUMMON_CORPSE_TIMED_DESPAWN);
+        Creature* DoSummon(uint32 entry, WorldObject* obj, float radius = 5.0f, uint32 despawnTime = 30000, TempSummonType summonType = TEMPSUMMON_CORPSE_TIMED_DESPAWN);
+        Creature* DoSummonFlyer(uint32 entry, WorldObject* obj, float flightZ, float radius = 5.0f, uint32 despawnTime = 30000, TempSummonType summonType = TEMPSUMMON_CORPSE_TIMED_DESPAWN);
+
+    public:
+        void Talk(uint8 id, WorldObject const* whisperTarget = NULL);
+        explicit CreatureAI(Creature* creature) : UnitAI(creature), me(creature), m_MoveInLineOfSight_locked(false) {}
+
+        virtual ~CreatureAI() {}
+
+        /// == Reactions At =================================
+
+        // Called if IsVisible(Unit* who) is true at each who move, reaction at visibility zone enter
+        void MoveInLineOfSight_Safe(Unit* who);
+
+        // Called in Creature::Update when deathstate = DEAD. Inherited classes may maniuplate the ability to respawn based on scripted events.
+        virtual bool CanRespawn() { return true; }
+
+        // Called for reaction at stopping attack at no attackers or targets
+        virtual void EnterEvadeMode();
+
+        // Called for reaction at enter to combat if not in combat yet (enemy can be NULL)
+        virtual void EnterCombat(Unit* /*victim*/) {}
+
+        // Called when the creature is killed
+        virtual void JustDied(Unit* /*killer*/) {}
+
+        // Called when the creature kills a unit
+        virtual void KilledUnit(Unit* /*victim*/) {}
+
+        // Called when the creature summon successfully other creature
+        virtual void JustSummoned(Creature* /*summon*/) {}
+        virtual void IsSummonedBy(Unit* /*summoner*/) {}
+
+        virtual void SummonedCreatureDespawn(Creature* /*summon*/) {}
+        virtual void SummonedCreatureDies(Creature* /*summon*/, Unit* /*killer*/) {}
+
+        // Called when hit by a spell
+        virtual void SpellHit(Unit* /*caster*/, SpellInfo const* /*spell*/) {}
+
+        // Called when spell hits a target
+        virtual void SpellHitTarget(Unit* /*target*/, SpellInfo const* /*spell*/) {}
+
+        // Called when the creature is target of hostile action: swing, hostile spell landed, fear/etc)
+        virtual void AttackedBy(Unit* /*attacker*/) {}
+        virtual bool IsEscorted() { return false; }
+
+        // Called when creature is spawned or respawned (for reseting variables)
+        virtual void JustRespawned() { Reset(); }
+
+        // Called at waypoint reached or point movement finished
+        virtual void MovementInform(uint32 /*type*/, uint32 /*id*/) {}
+
+        void OnCharmed(bool apply);
+
+        // Called at reaching home after evade
+        virtual void JustReachedHome() {}
+
+        void DoZoneInCombat(Creature* creature = NULL, float maxRangeToNearestTarget = 50.0f);
+
+        // Called at text emote receive from player
+        virtual void ReceiveEmote(Player* /*player*/, uint32 /*emoteId*/) {}
+
+        // Called when owner takes damage
+        virtual void OwnerAttackedBy(Unit* /*attacker*/) {}
+
+        // Called when owner attacks something
+        virtual void OwnerAttacked(Unit* /*target*/) {}
+
+        /// == Triggered Actions Requested ==================
+
+        // Called when creature attack expected (if creature can and no have current victim)
+        // Note: for reaction at hostile action must be called AttackedBy function.
+        //virtual void AttackStart(Unit*) {}
+
+        // Called at World update tick
+        //virtual void UpdateAI(uint32 /*diff*/) {}
+
+        /// == State checks =================================
+
+        // Is unit visible for MoveInLineOfSight
+        //virtual bool IsVisible(Unit*) const { return false; }
+
+        // called when the corpse of this creature gets removed
+        virtual void CorpseRemoved(uint32& /*respawnDelay*/) {}
+
+        // Called when victim entered water and creature can not enter water
+        //virtual bool CanReachByRangeAttack(Unit*) { return false; }
+
+        /// == Fields =======================================
+        virtual void PassengerBoarded(Unit* /*passenger*/, int8 /*seatId*/, bool /*apply*/) {}
+
+		virtual void OnSpellClick(Unit* /*clicker*/, bool& /*result*/) { }
+
+        virtual bool CanSeeAlways(WorldObject const* /*obj*/) { return false; }
+
+		virtual bool CanBeSeen(Player const* /*seer*/) { return true; }
+
+    protected:
+        virtual void MoveInLineOfSight(Unit* /*who*/);
+
+        bool _EnterEvadeMode();
+
+    private:
+        bool m_MoveInLineOfSight_locked;
+};
+
+enum Permitions
+{
+    PERMIT_BASE_NO                 = -1,
+    PERMIT_BASE_IDLE               = 1,
+    PERMIT_BASE_REACTIVE           = 100,
+    PERMIT_BASE_PROACTIVE          = 200,
+    PERMIT_BASE_FACTION_SPECIFIC   = 400,
+    PERMIT_BASE_SPECIAL            = 800
+};
+
+#endif

src/server/game/AI/CreatureAIFactory.h

@@ -0,0 +1,80 @@
+/*
+ * Copyright (C) 
+ * Copyright (C) 
+ *
+ * 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, see <http://www.gnu.org/licenses/>.
+ */
+#ifndef TRINITY_CREATUREAIFACTORY_H
+#define TRINITY_CREATUREAIFACTORY_H
+
+//#include "Policies/Singleton.h"
+#include "ObjectRegistry.h"
+#include "FactoryHolder.h"
+#include "GameObjectAI.h"
+
+struct SelectableAI : public FactoryHolder<CreatureAI>, public Permissible<Creature>
+{
+    SelectableAI(const char* id) : FactoryHolder<CreatureAI>(id) {}
+};
+
+template<class REAL_AI>
+struct CreatureAIFactory : public SelectableAI
+{
+    CreatureAIFactory(const char* name) : SelectableAI(name) {}
+
+    CreatureAI* Create(void*) const;
+
+    int Permit(const Creature* c) const { return REAL_AI::Permissible(c); }
+};
+
+template<class REAL_AI>
+inline CreatureAI*
+CreatureAIFactory<REAL_AI>::Create(void* data) const
+{
+    Creature* creature = reinterpret_cast<Creature*>(data);
+    return (new REAL_AI(creature));
+}
+
+typedef FactoryHolder<CreatureAI> CreatureAICreator;
+typedef FactoryHolder<CreatureAI>::FactoryHolderRegistry CreatureAIRegistry;
+typedef FactoryHolder<CreatureAI>::FactoryHolderRepository CreatureAIRepository;
+
+//GO
+struct SelectableGameObjectAI : public FactoryHolder<GameObjectAI>, public Permissible<GameObject>
+{
+    SelectableGameObjectAI(const char* id) : FactoryHolder<GameObjectAI>(id) {}
+};
+
+template<class REAL_GO_AI>
+struct GameObjectAIFactory : public SelectableGameObjectAI
+{
+    GameObjectAIFactory(const char* name) : SelectableGameObjectAI(name) {}
+
+    GameObjectAI* Create(void*) const;
+
+    int Permit(const GameObject* g) const { return REAL_GO_AI::Permissible(g); }
+};
+
+template<class REAL_GO_AI>
+inline GameObjectAI*
+GameObjectAIFactory<REAL_GO_AI>::Create(void* data) const
+{
+    GameObject* go = reinterpret_cast<GameObject*>(data);
+    return (new REAL_GO_AI(go));
+}
+
+typedef FactoryHolder<GameObjectAI> GameObjectAICreator;
+typedef FactoryHolder<GameObjectAI>::FactoryHolderRegistry GameObjectAIRegistry;
+typedef FactoryHolder<GameObjectAI>::FactoryHolderRepository GameObjectAIRepository;
+#endif

src/server/game/AI/CreatureAIImpl.h

@@ -0,0 +1,347 @@
+/*
+ * Copyright (C) 
+ *
+ * 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, see <http://www.gnu.org/licenses/>.
+ */
+#ifndef CREATUREAIIMPL_H
+#define CREATUREAIIMPL_H
+
+#include "Common.h"
+#include "Define.h"
+#include "TemporarySummon.h"
+#include "CreatureAI.h"
+#include "SpellMgr.h"
+
+template<class T>
+inline
+const T& RAND(const T& v1, const T& v2)
+{
+    return (urand(0, 1)) ? v1 : v2;
+}
+
+template<class T>
+inline
+const T& RAND(const T& v1, const T& v2, const T& v3)
+{
+    switch (urand(0, 2))
+    {
+        default:
+        case 0: return v1;
+        case 1: return v2;
+        case 2: return v3;
+    }
+}
+
+template<class T>
+inline
+const T& RAND(const T& v1, const T& v2, const T& v3, const T& v4)
+{
+    switch (urand(0, 3))
+    {
+        default:
+        case 0: return v1;
+        case 1: return v2;
+        case 2: return v3;
+        case 3: return v4;
+    }
+}
+
+template<class T>
+inline
+const T& RAND(const T& v1, const T& v2, const T& v3, const T& v4, const T& v5)
+{
+    switch (urand(0, 4))
+    {
+        default:
+        case 0: return v1;
+        case 1: return v2;
+        case 2: return v3;
+        case 3: return v4;
+        case 4: return v5;
+    }
+}
+
+template<class T>
+inline
+const T& RAND(const T& v1, const T& v2, const T& v3, const T& v4, const T& v5, const T& v6)
+{
+    switch (urand(0, 5))
+    {
+        default:
+        case 0: return v1;
+        case 1: return v2;
+        case 2: return v3;
+        case 3: return v4;
+        case 4: return v5;
+        case 5: return v6;
+    }
+}
+
+template<class T>
+inline
+const T& RAND(const T& v1, const T& v2, const T& v3, const T& v4, const T& v5, const T& v6, const T& v7)
+{
+    switch (urand(0, 6))
+    {
+        default:
+        case 0: return v1;
+        case 1: return v2;
+        case 2: return v3;
+        case 3: return v4;
+        case 4: return v5;
+        case 5: return v6;
+        case 6: return v7;
+    }
+}
+
+template<class T>
+inline
+const T& RAND(const T& v1, const T& v2, const T& v3, const T& v4, const T& v5, const T& v6, const T& v7, const T& v8)
+{
+    switch (urand(0, 7))
+    {
+        default:
+        case 0: return v1;
+        case 1: return v2;
+        case 2: return v3;
+        case 3: return v4;
+        case 4: return v5;
+        case 5: return v6;
+        case 6: return v7;
+        case 7: return v8;
+    }
+}
+
+template<class T>
+inline
+const T& RAND(const T& v1, const T& v2, const T& v3, const T& v4, const T& v5, const T& v6, const T& v7, const T& v8,
+              const T& v9)
+{
+    switch (urand(0, 8))
+    {
+        default:
+        case 0: return v1;
+        case 1: return v2;
+        case 2: return v3;
+        case 3: return v4;
+        case 4: return v5;
+        case 5: return v6;
+        case 6: return v7;
+        case 7: return v8;
+        case 8: return v9;
+    }
+}
+
+template<class T>
+inline
+const T& RAND(const T& v1, const T& v2, const T& v3, const T& v4, const T& v5, const T& v6, const T& v7, const T& v8,
+              const T& v9, const T& v10)
+{
+    switch (urand(0, 9))
+    {
+        default:
+        case 0: return v1;
+        case 1: return v2;
+        case 2: return v3;
+        case 3: return v4;
+        case 4: return v5;
+        case 5: return v6;
+        case 6: return v7;
+        case 7: return v8;
+        case 8: return v9;
+        case 9: return v10;
+    }
+}
+
+template<class T>
+inline
+const T& RAND(const T& v1, const T& v2, const T& v3, const T& v4, const T& v5, const T& v6, const T& v7, const T& v8,
+              const T& v9, const T& v10, const T& v11)
+{
+    switch (urand(0, 10))
+    {
+        default:
+        case 0: return v1;
+        case 1: return v2;
+        case 2: return v3;
+        case 3: return v4;
+        case 4: return v5;
+        case 5: return v6;
+        case 6: return v7;
+        case 7: return v8;
+        case 8: return v9;
+        case 9: return v10;
+        case 10: return v11;
+    }
+}
+
+template<class T>
+inline
+const T& RAND(const T& v1, const T& v2, const T& v3, const T& v4, const T& v5, const T& v6, const T& v7, const T& v8,
+              const T& v9, const T& v10, const T& v11, const T& v12)
+{
+    switch (urand(0, 11))
+    {
+        default:
+        case 0: return v1;
+        case 1: return v2;
+        case 2: return v3;
+        case 3: return v4;
+        case 4: return v5;
+        case 5: return v6;
+        case 6: return v7;
+        case 7: return v8;
+        case 8: return v9;
+        case 9: return v10;
+        case 10: return v11;
+        case 11: return v12;
+    }
+}
+
+template<class T>
+inline
+const T& RAND(const T& v1, const T& v2, const T& v3, const T& v4, const T& v5, const T& v6, const T& v7, const T& v8,
+              const T& v9, const T& v10, const T& v11, const T& v12, const T& v13)
+{
+    switch (urand(0, 12))
+    {
+        default:
+        case 0: return v1;
+        case 1: return v2;
+        case 2: return v3;
+        case 3: return v4;
+        case 4: return v5;
+        case 5: return v6;
+        case 6: return v7;
+        case 7: return v8;
+        case 8: return v9;
+        case 9: return v10;
+        case 10: return v11;
+        case 11: return v12;
+        case 12: return v13;
+    }
+}
+
+template<class T>
+inline
+const T& RAND(const T& v1, const T& v2, const T& v3, const T& v4, const T& v5, const T& v6, const T& v7, const T& v8,
+              const T& v9, const T& v10, const T& v11, const T& v12, const T& v13, const T& v14)
+{
+    switch (urand(0, 13))
+    {
+        default:
+        case 0: return v1;
+        case 1: return v2;
+        case 2: return v3;
+        case 3: return v4;
+        case 4: return v5;
+        case 5: return v6;
+        case 6: return v7;
+        case 7: return v8;
+        case 8: return v9;
+        case 9: return v10;
+        case 10: return v11;
+        case 11: return v12;
+        case 12: return v13;
+        case 13: return v14;
+    }
+}
+
+template<class T>
+inline
+const T& RAND(const T& v1, const T& v2, const T& v3, const T& v4, const T& v5, const T& v6, const T& v7, const T& v8,
+              const T& v9, const T& v10, const T& v11, const T& v12, const T& v13, const T& v14, const T& v15)
+{
+    switch (urand(0, 14))
+    {
+        default:
+        case 0: return v1;
+        case 1: return v2;
+        case 2: return v3;
+        case 3: return v4;
+        case 4: return v5;
+        case 5: return v6;
+        case 6: return v7;
+        case 7: return v8;
+        case 8: return v9;
+        case 9: return v10;
+        case 10: return v11;
+        case 11: return v12;
+        case 12: return v13;
+        case 13: return v14;
+        case 14: return v15;
+    }
+}
+
+template<class T>
+inline
+const T& RAND(const T& v1, const T& v2, const T& v3, const T& v4, const T& v5, const T& v6, const T& v7, const T& v8,
+              const T& v9, const T& v10, const T& v11, const T& v12, const T& v13, const T& v14, const T& v15, const T& v16)
+{
+    switch (urand(0, 15))
+    {
+        default:
+        case 0: return v1;
+        case 1: return v2;
+        case 2: return v3;
+        case 3: return v4;
+        case 4: return v5;
+        case 5: return v6;
+        case 6: return v7;
+        case 7: return v8;
+        case 8: return v9;
+        case 9: return v10;
+        case 10: return v11;
+        case 11: return v12;
+        case 12: return v13;
+        case 13: return v14;
+        case 14: return v15;
+        case 15: return v16;
+    }
+}
+
+enum AITarget
+{
+    AITARGET_SELF,
+    AITARGET_VICTIM,
+    AITARGET_ENEMY,
+    AITARGET_ALLY,
+    AITARGET_BUFF,
+    AITARGET_DEBUFF,
+};
+
+enum AICondition
+{
+    AICOND_AGGRO,
+    AICOND_COMBAT,
+    AICOND_DIE,
+};
+
+#define AI_DEFAULT_COOLDOWN 5000
+
+struct AISpellInfoType
+{
+    AISpellInfoType() : target(AITARGET_SELF), condition(AICOND_COMBAT)
+        , cooldown(AI_DEFAULT_COOLDOWN), realCooldown(0), maxRange(0.0f){}
+    AITarget target;
+    AICondition condition;
+    uint32 cooldown;
+    uint32 realCooldown;
+    float maxRange;
+};
+
+AISpellInfoType* GetAISpellInfo(uint32 i);
+
+#endif
+

src/server/game/AI/CreatureAIRegistry.cpp

@@ -0,0 +1,59 @@
+/*
+ * Copyright (C) 
+ * Copyright (C) 
+ *
+ * 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "PassiveAI.h"
+#include "ReactorAI.h"
+#include "CombatAI.h"
+#include "GuardAI.h"
+#include "PetAI.h"
+#include "TotemAI.h"
+#include "RandomMovementGenerator.h"
+#include "MovementGeneratorImpl.h"
+#include "CreatureAIRegistry.h"
+#include "WaypointMovementGenerator.h"
+#include "CreatureAIFactory.h"
+#include "SmartAI.h"
+
+//#include "CreatureAIImpl.h"
+namespace AIRegistry
+{
+    void Initialize()
+    {
+        (new CreatureAIFactory<NullCreatureAI>("NullCreatureAI"))->RegisterSelf();
+        (new CreatureAIFactory<TriggerAI>("TriggerAI"))->RegisterSelf();
+        (new CreatureAIFactory<AggressorAI>("AggressorAI"))->RegisterSelf();
+        (new CreatureAIFactory<ReactorAI>("ReactorAI"))->RegisterSelf();
+        (new CreatureAIFactory<PassiveAI>("PassiveAI"))->RegisterSelf();
+        (new CreatureAIFactory<CritterAI>("CritterAI"))->RegisterSelf();
+        (new CreatureAIFactory<GuardAI>("GuardAI"))->RegisterSelf();
+        (new CreatureAIFactory<PetAI>("PetAI"))->RegisterSelf();
+        (new CreatureAIFactory<TotemAI>("TotemAI"))->RegisterSelf();
+        (new CreatureAIFactory<CombatAI>("CombatAI"))->RegisterSelf();
+        (new CreatureAIFactory<ArcherAI>("ArcherAI"))->RegisterSelf();
+        (new CreatureAIFactory<TurretAI>("TurretAI"))->RegisterSelf();
+        (new CreatureAIFactory<VehicleAI>("VehicleAI"))->RegisterSelf();
+        (new CreatureAIFactory<SmartAI>("SmartAI"))->RegisterSelf();
+
+        (new GameObjectAIFactory<GameObjectAI>("GameObjectAI"))->RegisterSelf();
+        (new GameObjectAIFactory<SmartGameObjectAI>("SmartGameObjectAI"))->RegisterSelf();
+
+        (new MovementGeneratorFactory<RandomMovementGenerator<Creature> >(RANDOM_MOTION_TYPE))->RegisterSelf();
+        (new MovementGeneratorFactory<WaypointMovementGenerator<Creature> >(WAYPOINT_MOTION_TYPE))->RegisterSelf();
+    }
+}
+

src/server/game/AI/CreatureAIRegistry.h

@@ -0,0 +1,27 @@
+/*
+ * Copyright (C) 
+ * Copyright (C) 
+ *
+ * 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef TRINITY_CREATUREAIREGISTRY_H
+#define TRINITY_CREATUREAIREGISTRY_H
+
+namespace AIRegistry
+{
+    void Initialize(void);
+}
+#endif
+

src/server/game/AI/CreatureAISelector.cpp

@@ -0,0 +1,154 @@
+/*
+ * Copyright (C) 
+ * Copyright (C) 
+ *
+ * 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "Creature.h"
+#include "CreatureAISelector.h"
+#include "PassiveAI.h"
+
+#include "MovementGenerator.h"
+#include "Pet.h"
+#include "TemporarySummon.h"
+#include "CreatureAIFactory.h"
+#include "ScriptMgr.h"
+
+namespace FactorySelector
+{
+    CreatureAI* selectAI(Creature* creature)
+    {
+        const CreatureAICreator* ai_factory = NULL;
+        CreatureAIRegistry& ai_registry(*CreatureAIRepository::instance());
+
+		// xinef: if we have controlable guardian, define petai for players as they can steer him, otherwise db / normal ai
+		// xinef: dont remember why i changed this qq commented out as may break some quests
+        if (creature->IsPet()/* || (creature->HasUnitTypeMask(UNIT_MASK_CONTROLABLE_GUARDIAN) && ((Guardian*)creature)->GetOwner()->GetTypeId() == TYPEID_PLAYER)*/)
+            ai_factory = ai_registry.GetRegistryItem("PetAI");
+
+        //scriptname in db
+        if (!ai_factory)
+            if (CreatureAI* scriptedAI = sScriptMgr->GetCreatureAI(creature))
+                return scriptedAI;
+
+        // AIname in db
+        std::string ainame=creature->GetAIName();
+        if (!ai_factory && !ainame.empty())
+            ai_factory = ai_registry.GetRegistryItem(ainame);
+
+        // select by NPC flags
+        if (!ai_factory)
+        {
+            if (creature->IsVehicle())
+                ai_factory = ai_registry.GetRegistryItem("VehicleAI");
+            else if (creature->HasUnitTypeMask(UNIT_MASK_CONTROLABLE_GUARDIAN) && ((Guardian*)creature)->GetOwner()->GetTypeId() == TYPEID_PLAYER)
+                ai_factory = ai_registry.GetRegistryItem("PetAI");
+            else if (creature->HasFlag(UNIT_NPC_FLAGS, UNIT_NPC_FLAG_SPELLCLICK))
+                ai_factory = ai_registry.GetRegistryItem("NullCreatureAI");
+            else if (creature->IsGuard())
+                ai_factory = ai_registry.GetRegistryItem("GuardAI");
+            else if (creature->HasUnitTypeMask(UNIT_MASK_CONTROLABLE_GUARDIAN))
+                ai_factory = ai_registry.GetRegistryItem("PetAI");
+            else if (creature->IsTotem())
+                ai_factory = ai_registry.GetRegistryItem("TotemAI");
+            else if (creature->IsTrigger())
+            {
+                if (creature->m_spells[0])
+                    ai_factory = ai_registry.GetRegistryItem("TriggerAI");
+                else
+                    ai_factory = ai_registry.GetRegistryItem("NullCreatureAI");
+            }
+            else if (creature->IsCritter() && !creature->HasUnitTypeMask(UNIT_MASK_GUARDIAN))
+                ai_factory = ai_registry.GetRegistryItem("CritterAI");
+        }
+
+        // select by permit check
+        if (!ai_factory)
+        {
+            int best_val = -1;
+            typedef CreatureAIRegistry::RegistryMapType RMT;
+            RMT const& l = ai_registry.GetRegisteredItems();
+            for (RMT::const_iterator iter = l.begin(); iter != l.end(); ++iter)
+            {
+                const CreatureAICreator* factory = iter->second;
+                const SelectableAI* p = dynamic_cast<const SelectableAI*>(factory);
+                ASSERT(p);
+                int val = p->Permit(creature);
+                if (val > best_val)
+                {
+                    best_val = val;
+                    ai_factory = p;
+                }
+            }
+        }
+
+        // select NullCreatureAI if not another cases
+		// xinef: unused
+        // ainame = (ai_factory == NULL) ? "NullCreatureAI" : ai_factory->key();
+
+        ;//sLog->outDebug(LOG_FILTER_TSCR, "Creature %u used AI is %s.", creature->GetGUIDLow(), ainame.c_str());
+        return (ai_factory == NULL ? new NullCreatureAI(creature) : ai_factory->Create(creature));
+    }
+
+    MovementGenerator* selectMovementGenerator(Creature* creature)
+    {
+        MovementGeneratorRegistry& mv_registry(*MovementGeneratorRepository::instance());
+        ASSERT(creature->GetCreatureTemplate());
+        const MovementGeneratorCreator* mv_factory = mv_registry.GetRegistryItem(creature->GetDefaultMovementType());
+
+        /* if (mv_factory == NULL)
+        {
+            int best_val = -1;
+            StringVector l;
+            mv_registry.GetRegisteredItems(l);
+            for (StringVector::iterator iter = l.begin(); iter != l.end(); ++iter)
+            {
+            const MovementGeneratorCreator *factory = mv_registry.GetRegistryItem((*iter).c_str());
+            const SelectableMovement *p = dynamic_cast<const SelectableMovement *>(factory);
+            ASSERT(p != NULL);
+            int val = p->Permit(creature);
+            if (val > best_val)
+            {
+                best_val = val;
+                mv_factory = p;
+            }
+            }
+        }*/
+
+        return (mv_factory == NULL ? NULL : mv_factory->Create(creature));
+
+    }
+
+    GameObjectAI* SelectGameObjectAI(GameObject* go)
+    {
+        const GameObjectAICreator* ai_factory = NULL;
+        GameObjectAIRegistry& ai_registry(*GameObjectAIRepository::instance());
+
+        if (GameObjectAI* scriptedAI = sScriptMgr->GetGameObjectAI(go))
+            return scriptedAI;
+
+        ai_factory = ai_registry.GetRegistryItem(go->GetAIName());
+
+        //future goAI types go here
+
+		// xinef: unused
+        //std::string ainame = (ai_factory == NULL || go->GetScriptId()) ? "NullGameObjectAI" : ai_factory->key();
+
+        ;//sLog->outDebug(LOG_FILTER_TSCR, "GameObject %u used AI is %s.", go->GetGUIDLow(), ainame.c_str());
+
+        return (ai_factory == NULL ? new NullGameObjectAI(go) : ai_factory->Create(go));
+    }
+}
+

src/server/game/AI/CreatureAISelector.h

@@ -0,0 +1,35 @@
+/*
+ * Copyright (C) 
+ * Copyright (C) 
+ *
+ * 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef TRINITY_CREATUREAISELECTOR_H
+#define TRINITY_CREATUREAISELECTOR_H
+
+class CreatureAI;
+class Creature;
+class MovementGenerator;
+class GameObjectAI;
+class GameObject;
+
+namespace FactorySelector
+{
+    CreatureAI* selectAI(Creature*);
+    MovementGenerator* selectMovementGenerator(Creature*);
+    GameObjectAI* SelectGameObjectAI(GameObject*);
+}
+#endif
+

src/server/game/AI/ScriptedAI/ScriptedCreature.cpp

@@ -0,0 +1,668 @@
+/*
+ * Copyright (C) 
+ *
+ * 
+ *
+ * This program is free software licensed under GPL version 2
+ * Please see the included DOCS/LICENSE.TXT for more information */
+
+#include "ScriptedCreature.h"
+#include "Item.h"
+#include "Spell.h"
+#include "GridNotifiers.h"
+#include "GridNotifiersImpl.h"
+#include "Cell.h"
+#include "CellImpl.h"
+#include "ObjectMgr.h"
+#include "TemporarySummon.h"
+
+// Spell summary for ScriptedAI::SelectSpell
+struct TSpellSummary
+{
+    uint8 Targets;                                          // set of enum SelectTarget
+    uint8 Effects;                                          // set of enum SelectEffect
+} extern* SpellSummary;
+
+void SummonList::DoZoneInCombat(uint32 entry)
+{
+    for (StorageType::iterator i = storage_.begin(); i != storage_.end();)
+    {
+        Creature* summon = ObjectAccessor::GetCreature(*me, *i);
+        ++i;
+        if (summon && summon->IsAIEnabled
+                && (!entry || summon->GetEntry() == entry))
+        {
+            summon->AI()->DoZoneInCombat();
+        }
+    }
+}
+
+void SummonList::DespawnEntry(uint32 entry)
+{
+    for (StorageType::iterator i = storage_.begin(); i != storage_.end();)
+    {
+        Creature* summon = ObjectAccessor::GetCreature(*me, *i);
+        if (!summon)
+            i = storage_.erase(i);
+        else if (summon->GetEntry() == entry)
+        {
+            i = storage_.erase(i);
+            summon->DespawnOrUnsummon();
+        }
+        else
+            ++i;
+    }
+}
+
+void SummonList::DespawnAll()
+{
+    while (!storage_.empty())
+    {
+        Creature* summon = ObjectAccessor::GetCreature(*me, storage_.front());
+        storage_.pop_front();
+        if (summon)
+            summon->DespawnOrUnsummon();
+    }
+}
+
+void SummonList::RemoveNotExisting()
+{
+    for (StorageType::iterator i = storage_.begin(); i != storage_.end();)
+    {
+        if (ObjectAccessor::GetCreature(*me, *i))
+            ++i;
+        else
+            i = storage_.erase(i);
+    }
+}
+
+bool SummonList::HasEntry(uint32 entry) const
+{
+    for (StorageType::const_iterator i = storage_.begin(); i != storage_.end(); ++i)
+    {
+        Creature* summon = ObjectAccessor::GetCreature(*me, *i);
+        if (summon && summon->GetEntry() == entry)
+            return true;
+    }
+
+    return false;
+}
+
+uint32 SummonList::GetEntryCount(uint32 entry) const
+{
+	uint32 count = 0;
+    for (StorageType::const_iterator i = storage_.begin(); i != storage_.end(); ++i)
+    {
+        Creature* summon = ObjectAccessor::GetCreature(*me, *i);
+        if (summon && summon->GetEntry() == entry)
+            ++count;
+    }
+
+    return count;
+}
+
+void SummonList::Respawn()
+{
+    for (StorageType::iterator i = storage_.begin(); i != storage_.end();)
+    {
+        if (Creature* summon = ObjectAccessor::GetCreature(*me, *i))
+		{
+			summon->Respawn(true);
+            ++i;
+		}
+        else
+            i = storage_.erase(i);
+    }
+}
+
+Creature* SummonList::GetCreatureWithEntry(uint32 entry) const
+{
+    for (StorageType::const_iterator i = storage_.begin(); i != storage_.end(); ++i)
+    {
+        if (Creature* summon = ObjectAccessor::GetCreature(*me, *i))
+			if (summon->GetEntry() == entry)
+				return summon;
+    }
+
+    return NULL;
+}
+
+ScriptedAI::ScriptedAI(Creature* creature) : CreatureAI(creature),
+    me(creature),
+    IsFleeing(false),
+    _evadeCheckCooldown(2500),
+    _isCombatMovementAllowed(true)
+{
+    _isHeroic = me->GetMap()->IsHeroic();
+    _difficulty = Difficulty(me->GetMap()->GetSpawnMode());
+}
+
+void ScriptedAI::AttackStartNoMove(Unit* who)
+{
+    if (!who)
+        return;
+
+    if (me->Attack(who, true))
+        DoStartNoMovement(who);
+}
+
+void ScriptedAI::AttackStart(Unit* who)
+{
+    if (IsCombatMovementAllowed())
+        CreatureAI::AttackStart(who);
+    else
+        AttackStartNoMove(who);
+}
+
+void ScriptedAI::UpdateAI(uint32 /*diff*/)
+{
+    //Check if we have a current target
+    if (!UpdateVictim())
+        return;
+
+    DoMeleeAttackIfReady();
+}
+
+void ScriptedAI::DoStartMovement(Unit* victim, float distance, float angle)
+{
+    if (victim)
+        me->GetMotionMaster()->MoveChase(victim, distance, angle);
+}
+
+void ScriptedAI::DoStartNoMovement(Unit* victim)
+{
+    if (!victim)
+        return;
+
+    me->GetMotionMaster()->MoveIdle();
+}
+
+void ScriptedAI::DoStopAttack()
+{
+    if (me->GetVictim())
+        me->AttackStop();
+}
+
+void ScriptedAI::DoCastSpell(Unit* target, SpellInfo const* spellInfo, bool triggered)
+{
+    if (!target || me->IsNonMeleeSpellCast(false))
+        return;
+
+    me->StopMoving();
+    me->CastSpell(target, spellInfo, triggered ? TRIGGERED_FULL_MASK : TRIGGERED_NONE);
+}
+
+void ScriptedAI::DoPlaySoundToSet(WorldObject* source, uint32 soundId)
+{
+    if (!source)
+        return;
+
+    if (!sSoundEntriesStore.LookupEntry(soundId))
+    {
+        sLog->outError("TSCR: Invalid soundId %u used in DoPlaySoundToSet (Source: TypeId %u, GUID %u)", soundId, source->GetTypeId(), source->GetGUIDLow());
+        return;
+    }
+
+    source->PlayDirectSound(soundId);
+}
+
+Creature* ScriptedAI::DoSpawnCreature(uint32 entry, float offsetX, float offsetY, float offsetZ, float angle, uint32 type, uint32 despawntime)
+{
+    return me->SummonCreature(entry, me->GetPositionX() + offsetX, me->GetPositionY() + offsetY, me->GetPositionZ() + offsetZ, angle, TempSummonType(type), despawntime);
+}
+
+SpellInfo const* ScriptedAI::SelectSpell(Unit* target, uint32 school, uint32 mechanic, SelectTargetType targets, uint32 powerCostMin, uint32 powerCostMax, float rangeMin, float rangeMax, SelectEffect effects)
+{
+    //No target so we can't cast
+    if (!target)
+        return NULL;
+
+    //Silenced so we can't cast
+    if (me->HasFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_SILENCED))
+        return NULL;
+
+    //Using the extended script system we first create a list of viable spells
+    SpellInfo const* apSpell[CREATURE_MAX_SPELLS];
+    memset(apSpell, 0, CREATURE_MAX_SPELLS * sizeof(SpellInfo*));
+
+    uint32 spellCount = 0;
+
+    SpellInfo const* tempSpell = NULL;
+
+    //Check if each spell is viable(set it to null if not)
+    for (uint32 i = 0; i < CREATURE_MAX_SPELLS; i++)
+    {
+        tempSpell = sSpellMgr->GetSpellInfo(me->m_spells[i]);
+
+        //This spell doesn't exist
+        if (!tempSpell)
+            continue;
+
+        // Targets and Effects checked first as most used restrictions
+        //Check the spell targets if specified
+        if (targets && !(SpellSummary[me->m_spells[i]].Targets & (1 << (targets-1))))
+            continue;
+
+        //Check the type of spell if we are looking for a specific spell type
+        if (effects && !(SpellSummary[me->m_spells[i]].Effects & (1 << (effects-1))))
+            continue;
+
+        //Check for school if specified
+        if (school && (tempSpell->SchoolMask & school) == 0)
+            continue;
+
+        //Check for spell mechanic if specified
+        if (mechanic && tempSpell->Mechanic != mechanic)
+            continue;
+
+        //Make sure that the spell uses the requested amount of power
+        if (powerCostMin && tempSpell->ManaCost < powerCostMin)
+            continue;
+
+        if (powerCostMax && tempSpell->ManaCost > powerCostMax)
+            continue;
+
+        //Continue if we don't have the mana to actually cast this spell
+        if (tempSpell->ManaCost > me->GetPower(Powers(tempSpell->PowerType)))
+            continue;
+
+        //Check if the spell meets our range requirements
+        if (rangeMin && me->GetSpellMinRangeForTarget(target, tempSpell) < rangeMin)
+            continue;
+        if (rangeMax && me->GetSpellMaxRangeForTarget(target, tempSpell) > rangeMax)
+            continue;
+
+        //Check if our target is in range
+        if (me->IsWithinDistInMap(target, float(me->GetSpellMinRangeForTarget(target, tempSpell))) || !me->IsWithinDistInMap(target, float(me->GetSpellMaxRangeForTarget(target, tempSpell))))
+            continue;
+
+        //All good so lets add it to the spell list
+        apSpell[spellCount] = tempSpell;
+        ++spellCount;
+    }
+
+    //We got our usable spells so now lets randomly pick one
+    if (!spellCount)
+        return NULL;
+
+    return apSpell[urand(0, spellCount - 1)];
+}
+
+void ScriptedAI::DoResetThreat()
+{
+    if (!me->CanHaveThreatList() || me->getThreatManager().isThreatListEmpty())
+    {
+        sLog->outError("DoResetThreat called for creature that either cannot have threat list or has empty threat list (me entry = %d)", me->GetEntry());
+        return;
+    }
+
+	me->getThreatManager().resetAllAggro();
+}
+
+float ScriptedAI::DoGetThreat(Unit* unit)
+{
+    if (!unit)
+        return 0.0f;
+    return me->getThreatManager().getThreat(unit);
+}
+
+void ScriptedAI::DoModifyThreatPercent(Unit* unit, int32 pct)
+{
+    if (!unit)
+        return;
+    me->getThreatManager().modifyThreatPercent(unit, pct);
+}
+
+void ScriptedAI::DoTeleportPlayer(Unit* unit, float x, float y, float z, float o)
+{
+    if (!unit)
+        return;
+
+    if (Player* player = unit->ToPlayer())
+        player->TeleportTo(unit->GetMapId(), x, y, z, o, TELE_TO_NOT_LEAVE_COMBAT);
+    else
+        sLog->outError("TSCR: Creature " UI64FMTD " (Entry: %u) Tried to teleport non-player unit (Type: %u GUID: " UI64FMTD ") to x: %f y:%f z: %f o: %f. Aborted.", me->GetGUID(), me->GetEntry(), unit->GetTypeId(), unit->GetGUID(), x, y, z, o);
+}
+
+void ScriptedAI::DoTeleportAll(float x, float y, float z, float o)
+{
+    Map* map = me->GetMap();
+    if (!map->IsDungeon())
+        return;
+
+    Map::PlayerList const& PlayerList = map->GetPlayers();
+    for (Map::PlayerList::const_iterator itr = PlayerList.begin(); itr != PlayerList.end(); ++itr)
+        if (Player* player = itr->GetSource())
+            if (player->IsAlive())
+                player->TeleportTo(me->GetMapId(), x, y, z, o, TELE_TO_NOT_LEAVE_COMBAT);
+}
+
+Unit* ScriptedAI::DoSelectLowestHpFriendly(float range, uint32 minHPDiff)
+{
+    Unit* unit = NULL;
+    Trinity::MostHPMissingInRange u_check(me, range, minHPDiff);
+    Trinity::UnitLastSearcher<Trinity::MostHPMissingInRange> searcher(me, unit, u_check);
+    me->VisitNearbyObject(range, searcher);
+
+    return unit;
+}
+
+std::list<Creature*> ScriptedAI::DoFindFriendlyCC(float range)
+{
+    std::list<Creature*> list;
+    Trinity::FriendlyCCedInRange u_check(me, range);
+    Trinity::CreatureListSearcher<Trinity::FriendlyCCedInRange> searcher(me, list, u_check);
+    me->VisitNearbyObject(range, searcher);
+    return list;
+}
+
+std::list<Creature*> ScriptedAI::DoFindFriendlyMissingBuff(float range, uint32 uiSpellid)
+{
+    std::list<Creature*> list;
+    Trinity::FriendlyMissingBuffInRange u_check(me, range, uiSpellid);
+    Trinity::CreatureListSearcher<Trinity::FriendlyMissingBuffInRange> searcher(me, list, u_check);
+    me->VisitNearbyObject(range, searcher);
+    return list;
+}
+
+Player* ScriptedAI::GetPlayerAtMinimumRange(float minimumRange)
+{
+    Player* player = NULL;
+
+    CellCoord pair(Trinity::ComputeCellCoord(me->GetPositionX(), me->GetPositionY()));
+    Cell cell(pair);
+    cell.SetNoCreate();
+
+    Trinity::PlayerAtMinimumRangeAway check(me, minimumRange);
+    Trinity::PlayerSearcher<Trinity::PlayerAtMinimumRangeAway> searcher(me, player, check);
+    TypeContainerVisitor<Trinity::PlayerSearcher<Trinity::PlayerAtMinimumRangeAway>, GridTypeMapContainer> visitor(searcher);
+
+    cell.Visit(pair, visitor, *me->GetMap(), *me, minimumRange);
+
+    return player;
+}
+
+void ScriptedAI::SetEquipmentSlots(bool loadDefault, int32 mainHand /*= EQUIP_NO_CHANGE*/, int32 offHand /*= EQUIP_NO_CHANGE*/, int32 ranged /*= EQUIP_NO_CHANGE*/)
+{
+    if (loadDefault)
+    {
+        me->LoadEquipment(me->GetOriginalEquipmentId(), true);
+        return;
+    }
+
+    if (mainHand >= 0)
+        me->SetUInt32Value(UNIT_VIRTUAL_ITEM_SLOT_ID + 0, uint32(mainHand));
+
+    if (offHand >= 0)
+        me->SetUInt32Value(UNIT_VIRTUAL_ITEM_SLOT_ID + 1, uint32(offHand));
+
+    if (ranged >= 0)
+        me->SetUInt32Value(UNIT_VIRTUAL_ITEM_SLOT_ID + 2, uint32(ranged));
+}
+
+void ScriptedAI::SetCombatMovement(bool allowMovement)
+{
+    _isCombatMovementAllowed = allowMovement;
+}
+
+enum eNPCs
+{
+    NPC_BROODLORD   = 12017,
+    NPC_JAN_ALAI    = 23578,
+    NPC_SARTHARION  = 28860,
+	NPC_FREYA		= 32906,
+};
+
+bool ScriptedAI::EnterEvadeIfOutOfCombatArea()
+{
+	if (me->IsInEvadeMode() || !me->IsInCombat())
+        return false;
+
+	if (_evadeCheckCooldown == time(NULL))
+		return false;
+	_evadeCheckCooldown = time(NULL);
+
+	if (!CheckEvadeIfOutOfCombatArea())
+		return false;
+
+    EnterEvadeMode();
+    return true;
+}
+
+Player* ScriptedAI::SelectTargetFromPlayerList(float maxdist, uint32 excludeAura, bool mustBeInLOS) const
+{
+	Map::PlayerList const& pList = me->GetMap()->GetPlayers();
+	std::vector<Player*> tList;
+	for(Map::PlayerList::const_iterator itr = pList.begin(); itr != pList.end(); ++itr)
+	{
+		if (me->GetDistance(itr->GetSource()) > maxdist || !itr->GetSource()->IsAlive() || itr->GetSource()->IsGameMaster())
+			continue;
+		if (excludeAura && itr->GetSource()->HasAura(excludeAura))
+			continue;
+		if (mustBeInLOS && !me->IsWithinLOSInMap(itr->GetSource()))
+			continue;
+		tList.push_back(itr->GetSource());
+	}
+	if (!tList.empty())
+		return tList[urand(0,tList.size()-1)];
+	else
+		return NULL;
+}
+
+// BossAI - for instanced bosses
+
+BossAI::BossAI(Creature* creature, uint32 bossId) : ScriptedAI(creature),
+    instance(creature->GetInstanceScript()),
+    summons(creature),
+    _boundary(instance ? instance->GetBossBoundary(bossId) : NULL),
+    _bossId(bossId)
+{
+}
+
+void BossAI::_Reset()
+{
+    if (!me->IsAlive())
+        return;
+
+    me->ResetLootMode();
+    events.Reset();
+    summons.DespawnAll();
+    if (instance)
+        instance->SetBossState(_bossId, NOT_STARTED);
+}
+
+void BossAI::_JustDied()
+{
+    events.Reset();
+    summons.DespawnAll();
+    if (instance)
+    {
+        instance->SetBossState(_bossId, DONE);
+        instance->SaveToDB();
+    }
+}
+
+void BossAI::_EnterCombat()
+{
+    me->setActive(true);
+    DoZoneInCombat();
+    if (instance)
+    {
+        // bosses do not respawn, check only on enter combat
+        if (!instance->CheckRequiredBosses(_bossId))
+        {
+            EnterEvadeMode();
+            return;
+        }
+        instance->SetBossState(_bossId, IN_PROGRESS);
+    }
+}
+
+void BossAI::TeleportCheaters()
+{
+    float x, y, z;
+    me->GetPosition(x, y, z);
+
+    ThreatContainer::StorageType threatList = me->getThreatManager().getThreatList();
+    for (ThreatContainer::StorageType::const_iterator itr = threatList.begin(); itr != threatList.end(); ++itr)
+        if (Unit* target = (*itr)->getTarget())
+            if (target->GetTypeId() == TYPEID_PLAYER && !CheckBoundary(target))
+                target->NearTeleportTo(x, y, z, 0);
+}
+
+bool BossAI::CheckBoundary(Unit* who)
+{
+    if (!GetBoundary() || !who)
+        return true;
+
+    for (BossBoundaryMap::const_iterator itr = GetBoundary()->begin(); itr != GetBoundary()->end(); ++itr)
+    {
+        switch (itr->first)
+        {
+            case BOUNDARY_N:
+                if (who->GetPositionX() > itr->second)
+                    return false;
+                break;
+            case BOUNDARY_S:
+                if (who->GetPositionX() < itr->second)
+                    return false;
+                break;
+            case BOUNDARY_E:
+                if (who->GetPositionY() < itr->second)
+                    return false;
+                break;
+            case BOUNDARY_W:
+                if (who->GetPositionY() > itr->second)
+                    return false;
+                break;
+            case BOUNDARY_NW:
+                if (who->GetPositionX() + who->GetPositionY() > itr->second)
+                    return false;
+                break;
+            case BOUNDARY_SE:
+                if (who->GetPositionX() + who->GetPositionY() < itr->second)
+                    return false;
+                break;
+            case BOUNDARY_NE:
+                if (who->GetPositionX() - who->GetPositionY() > itr->second)
+                    return false;
+                break;
+            case BOUNDARY_SW:
+                if (who->GetPositionX() - who->GetPositionY() < itr->second)
+                    return false;
+                break;
+            default:
+                break;
+        }
+    }
+
+    return true;
+}
+
+void BossAI::JustSummoned(Creature* summon)
+{
+    summons.Summon(summon);
+    if (me->IsInCombat())
+        DoZoneInCombat(summon);
+}
+
+void BossAI::SummonedCreatureDespawn(Creature* summon)
+{
+    summons.Despawn(summon);
+}
+
+void BossAI::UpdateAI(uint32 diff)
+{
+    if (!UpdateVictim())
+        return;
+
+    events.Update(diff);
+
+    if (me->HasUnitState(UNIT_STATE_CASTING))
+        return;
+
+    while (uint32 eventId = events.ExecuteEvent())
+        ExecuteEvent(eventId);
+
+    DoMeleeAttackIfReady();
+}
+
+// WorldBossAI - for non-instanced bosses
+
+WorldBossAI::WorldBossAI(Creature* creature) :
+    ScriptedAI(creature),
+    summons(creature)
+{
+}
+
+void WorldBossAI::_Reset()
+{
+    if (!me->IsAlive())
+        return;
+
+    events.Reset();
+    summons.DespawnAll();
+}
+
+void WorldBossAI::_JustDied()
+{
+    events.Reset();
+    summons.DespawnAll();
+}
+
+void WorldBossAI::_EnterCombat()
+{
+    Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 0.0f, true);
+    if (target)
+        AttackStart(target);
+}
+
+void WorldBossAI::JustSummoned(Creature* summon)
+{
+    summons.Summon(summon);
+    Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 0.0f, true);
+    if (target)
+        summon->AI()->AttackStart(target);
+}
+
+void WorldBossAI::SummonedCreatureDespawn(Creature* summon)
+{
+    summons.Despawn(summon);
+}
+
+void WorldBossAI::UpdateAI(uint32 diff)
+{
+    if (!UpdateVictim())
+        return;
+
+    events.Update(diff);
+
+    if (me->HasUnitState(UNIT_STATE_CASTING))
+        return;
+
+    while (uint32 eventId = events.ExecuteEvent())
+        ExecuteEvent(eventId);
+
+    DoMeleeAttackIfReady();
+}
+
+// SD2 grid searchers.
+Creature* GetClosestCreatureWithEntry(WorldObject* source, uint32 entry, float maxSearchRange, bool alive /*= true*/)
+{
+    return source->FindNearestCreature(entry, maxSearchRange, alive);
+}
+
+GameObject* GetClosestGameObjectWithEntry(WorldObject* source, uint32 entry, float maxSearchRange)
+{
+    return source->FindNearestGameObject(entry, maxSearchRange);
+}
+
+void GetCreatureListWithEntryInGrid(std::list<Creature*>& list, WorldObject* source, uint32 entry, float maxSearchRange)
+{
+    source->GetCreatureListWithEntryInGrid(list, entry, maxSearchRange);
+}
+
+void GetGameObjectListWithEntryInGrid(std::list<GameObject*>& list, WorldObject* source, uint32 entry, float maxSearchRange)
+{
+    source->GetGameObjectListWithEntryInGrid(list, entry, maxSearchRange);
+}

src/server/game/AI/ScriptedAI/ScriptedCreature.h

@@ -0,0 +1,457 @@
+/*
+ * Copyright (C) 
+ * Copyright (C) 
+ *
+ * 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef SCRIPTEDCREATURE_H_
+#define SCRIPTEDCREATURE_H_
+
+#include "Creature.h"
+#include "CreatureAI.h"
+#include "CreatureAIImpl.h"
+#include "InstanceScript.h"
+
+#define CAST_AI(a, b)   (dynamic_cast<a*>(b))
+
+class InstanceScript;
+
+class SummonList
+{
+public:
+    typedef std::list<uint64> StorageType;
+    typedef StorageType::iterator iterator;
+    typedef StorageType::const_iterator const_iterator;
+    typedef StorageType::size_type size_type;
+    typedef StorageType::value_type value_type;
+
+    explicit SummonList(Creature* creature)
+        : me(creature)
+    { }
+
+    // And here we see a problem of original inheritance approach. People started
+    // to exploit presence of std::list members, so I have to provide wrappers
+
+    iterator begin()
+    {
+        return storage_.begin();
+    }
+
+    const_iterator begin() const
+    {
+        return storage_.begin();
+    }
+
+    iterator end()
+    {
+        return storage_.end();
+    }
+
+    const_iterator end() const
+    {
+        return storage_.end();
+    }
+
+    iterator erase(iterator i)
+    {
+        return storage_.erase(i);
+    }
+
+    bool empty() const
+    {
+        return storage_.empty();
+    }
+
+    size_type size() const
+    {
+        return storage_.size();
+    }
+
+	void clear()
+	{
+		storage_.clear();
+	}
+
+    void Summon(Creature const* summon) { storage_.push_back(summon->GetGUID()); }
+    void Despawn(Creature const* summon) { storage_.remove(summon->GetGUID()); }
+    void DespawnEntry(uint32 entry);
+    void DespawnAll();
+
+    template <typename T>
+    void DespawnIf(T const &predicate)
+    {
+        storage_.remove_if(predicate);
+    }
+
+    void DoAction(int32 info, uint16 max = 0)
+    {
+        if (max)
+            RemoveNotExisting(); // pussywizard: when max is set, non existing can be chosen and nothing will happen
+
+		StorageType listCopy = storage_;
+        for (StorageType::const_iterator i = listCopy.begin(); i != listCopy.end(); ++i)
+        {
+            if (Creature* summon = ObjectAccessor::GetCreature(*me, *i))
+                if (summon->IsAIEnabled)
+                    summon->AI()->DoAction(info);
+        }
+    }
+
+    template <class Predicate>
+    void DoAction(int32 info, Predicate& predicate, uint16 max = 0)
+    {
+        if (max)
+            RemoveNotExisting(); // pussywizard: when max is set, non existing can be chosen and nothing will happen
+
+        // We need to use a copy of SummonList here, otherwise original SummonList would be modified
+        StorageType listCopy = storage_;
+        Trinity::Containers::RandomResizeList<uint64, Predicate>(listCopy, predicate, max);
+        for (StorageType::iterator i = listCopy.begin(); i != listCopy.end(); ++i)
+        {
+            Creature* summon = ObjectAccessor::GetCreature(*me, *i);
+            if (summon)
+            {
+                if (summon->IsAIEnabled)
+                    summon->AI()->DoAction(info);
+            }
+            else
+                storage_.remove(*i);
+        }
+    }
+
+    void DoZoneInCombat(uint32 entry = 0);
+    void RemoveNotExisting();
+    bool HasEntry(uint32 entry) const;
+    uint32 GetEntryCount(uint32 entry) const;
+	void Respawn();
+	Creature* GetCreatureWithEntry(uint32 entry) const;
+
+private:
+    Creature* me;
+    StorageType storage_;
+};
+
+class EntryCheckPredicate
+{
+    public:
+        EntryCheckPredicate(uint32 entry) : _entry(entry) {}
+        bool operator()(uint64 guid) { return GUID_ENPART(guid) == _entry; }
+
+    private:
+        uint32 _entry;
+};
+
+class PlayerOrPetCheck
+{
+    public:
+        bool operator() (WorldObject* unit) const
+        {
+            if (unit->GetTypeId() != TYPEID_PLAYER)
+				if (!IS_PLAYER_GUID(unit->ToUnit()->GetOwnerGUID()))
+                    return true;
+
+            return false;
+        }
+};
+
+struct ScriptedAI : public CreatureAI
+{
+    explicit ScriptedAI(Creature* creature);
+    virtual ~ScriptedAI() {}
+
+    // *************
+    //CreatureAI Functions
+    // *************
+
+    void AttackStartNoMove(Unit* target);
+
+    // Called at any Damage from any attacker (before damage apply)
+    void DamageTaken(Unit* /*attacker*/, uint32& /*damage*/, DamageEffectType /*damagetype*/, SpellSchoolMask /*damageSchoolMask*/) {}
+
+    //Called at World update tick
+    virtual void UpdateAI(uint32 diff);
+
+    //Called at creature death
+    void JustDied(Unit* /*killer*/) {}
+
+    //Called at creature killing another unit
+    void KilledUnit(Unit* /*victim*/) {}
+
+    // Called when the creature summon successfully other creature
+    void JustSummoned(Creature* /*summon*/) {}
+
+    // Called when a summoned creature is despawned
+    void SummonedCreatureDespawn(Creature* /*summon*/) {}
+
+    // Called when hit by a spell
+    void SpellHit(Unit* /*caster*/, SpellInfo const* /*spell*/) {}
+
+    // Called when spell hits a target
+    void SpellHitTarget(Unit* /*target*/, SpellInfo const* /*spell*/) {}
+
+    //Called at waypoint reached or PointMovement end
+    void MovementInform(uint32 /*type*/, uint32 /*id*/) {}
+
+    // Called when AI is temporarily replaced or put back when possess is applied or removed
+    void OnPossess(bool /*apply*/) {}
+
+    // *************
+    // Variables
+    // *************
+
+    //Pointer to creature we are manipulating
+    Creature* me;
+
+    //For fleeing
+    bool IsFleeing;
+
+    // *************
+    //Pure virtual functions
+    // *************
+
+    //Called at creature reset either by death or evade
+    void Reset() {}
+
+    //Called at creature aggro either by MoveInLOS or Attack Start
+    void EnterCombat(Unit* /*victim*/) {}
+
+    // Called before EnterCombat even before the creature is in combat.
+    void AttackStart(Unit* /*target*/);
+
+    // *************
+    //AI Helper Functions
+    // *************
+
+    //Start movement toward victim
+    void DoStartMovement(Unit* target, float distance = 0.0f, float angle = 0.0f);
+
+    //Start no movement on victim
+    void DoStartNoMovement(Unit* target);
+
+    //Stop attack of current victim
+    void DoStopAttack();
+
+    //Cast spell by spell info
+    void DoCastSpell(Unit* target, SpellInfo const* spellInfo, bool triggered = false);
+
+    //Plays a sound to all nearby players
+    void DoPlaySoundToSet(WorldObject* source, uint32 soundId);
+
+    //Drops all threat to 0%. Does not remove players from the threat list
+    void DoResetThreat();
+
+    float DoGetThreat(Unit* unit);
+    void DoModifyThreatPercent(Unit* unit, int32 pct);
+
+    //Teleports a player without dropping threat (only teleports to same map)
+    void DoTeleportPlayer(Unit* unit, float x, float y, float z, float o);
+    void DoTeleportAll(float x, float y, float z, float o);
+
+    //Returns friendly unit with the most amount of hp missing from max hp
+    Unit* DoSelectLowestHpFriendly(float range, uint32 minHPDiff = 1);
+
+    //Returns a list of friendly CC'd units within range
+    std::list<Creature*> DoFindFriendlyCC(float range);
+
+    //Returns a list of all friendly units missing a specific buff within range
+    std::list<Creature*> DoFindFriendlyMissingBuff(float range, uint32 spellId);
+
+    //Return a player with at least minimumRange from me
+    Player* GetPlayerAtMinimumRange(float minRange);
+
+    //Spawns a creature relative to me
+    Creature* DoSpawnCreature(uint32 entry, float offsetX, float offsetY, float offsetZ, float angle, uint32 type, uint32 despawntime);
+
+    bool HealthBelowPct(uint32 pct) const { return me->HealthBelowPct(pct); }
+    bool HealthAbovePct(uint32 pct) const { return me->HealthAbovePct(pct); }
+
+    //Returns spells that meet the specified criteria from the creatures spell list
+    SpellInfo const* SelectSpell(Unit* target, uint32 school, uint32 mechanic, SelectTargetType targets, uint32 powerCostMin, uint32 powerCostMax, float rangeMin, float rangeMax, SelectEffect effect);
+
+    void SetEquipmentSlots(bool loadDefault, int32 mainHand = EQUIP_NO_CHANGE, int32 offHand = EQUIP_NO_CHANGE, int32 ranged = EQUIP_NO_CHANGE);
+
+    // Used to control if MoveChase() is to be used or not in AttackStart(). Some creatures does not chase victims
+    // NOTE: If you use SetCombatMovement while the creature is in combat, it will do NOTHING - This only affects AttackStart
+    //       You should make the necessary to make it happen so.
+    //       Remember that if you modified _isCombatMovementAllowed (e.g: using SetCombatMovement) it will not be reset at Reset().
+    //       It will keep the last value you set.
+    void SetCombatMovement(bool allowMovement);
+    bool IsCombatMovementAllowed() const { return _isCombatMovementAllowed; }
+
+    bool EnterEvadeIfOutOfCombatArea();
+	virtual bool CheckEvadeIfOutOfCombatArea() const { return false; }
+
+    // return true for heroic mode. i.e.
+    //   - for dungeon in mode 10-heroic,
+    //   - for raid in mode 10-Heroic
+    //   - for raid in mode 25-heroic
+    // DO NOT USE to check raid in mode 25-normal.
+    bool IsHeroic() const { return _isHeroic; }
+
+    // return the dungeon or raid difficulty
+    Difficulty GetDifficulty() const { return _difficulty; }
+
+    // return true for 25 man or 25 man heroic mode
+    bool Is25ManRaid() const { return _difficulty & RAID_DIFFICULTY_MASK_25MAN; }
+
+    template<class T> inline
+    const T& DUNGEON_MODE(const T& normal5, const T& heroic10) const
+    {
+        switch (_difficulty)
+        {
+            case DUNGEON_DIFFICULTY_NORMAL:
+                return normal5;
+            case DUNGEON_DIFFICULTY_HEROIC:
+                return heroic10;
+            default:
+                break;
+        }
+
+        return heroic10;
+    }
+
+    template<class T> inline
+    const T& RAID_MODE(const T& normal10, const T& normal25) const
+    {
+        switch (_difficulty)
+        {
+            case RAID_DIFFICULTY_10MAN_NORMAL:
+                return normal10;
+            case RAID_DIFFICULTY_25MAN_NORMAL:
+                return normal25;
+            default:
+                break;
+        }
+
+        return normal25;
+    }
+
+    template<class T> inline
+    const T& RAID_MODE(const T& normal10, const T& normal25, const T& heroic10, const T& heroic25) const
+    {
+        switch (_difficulty)
+        {
+            case RAID_DIFFICULTY_10MAN_NORMAL:
+                return normal10;
+            case RAID_DIFFICULTY_25MAN_NORMAL:
+                return normal25;
+            case RAID_DIFFICULTY_10MAN_HEROIC:
+                return heroic10;
+            case RAID_DIFFICULTY_25MAN_HEROIC:
+                return heroic25;
+            default:
+                break;
+        }
+
+        return heroic25;
+    }
+
+	Player* SelectTargetFromPlayerList(float maxdist, uint32 excludeAura = 0, bool mustBeInLOS = false) const;
+
+    private:
+        Difficulty _difficulty;
+        uint32 _evadeCheckCooldown;
+        bool _isCombatMovementAllowed;
+        bool _isHeroic;
+};
+
+class BossAI : public ScriptedAI
+{
+    public:
+        BossAI(Creature* creature, uint32 bossId);
+        virtual ~BossAI() {}
+
+        InstanceScript* const instance;
+        BossBoundaryMap const* GetBoundary() const { return _boundary; }
+
+        void JustSummoned(Creature* summon);
+        void SummonedCreatureDespawn(Creature* summon);
+
+        virtual void UpdateAI(uint32 diff);
+
+        // Hook used to execute events scheduled into EventMap without the need
+        // to override UpdateAI
+        // note: You must re-schedule the event within this method if the event
+        // is supposed to run more than once
+        virtual void ExecuteEvent(uint32 /*eventId*/) { }
+
+        void Reset() { _Reset(); }
+        void EnterCombat(Unit* /*who*/) { _EnterCombat(); }
+        void JustDied(Unit* /*killer*/) { _JustDied(); }
+        void JustReachedHome() { _JustReachedHome(); }
+
+    protected:
+        void _Reset();
+        void _EnterCombat();
+        void _JustDied();
+        void _JustReachedHome() { me->setActive(false); }
+
+        bool CheckInRoom()
+        {
+            if (CheckBoundary(me))
+                return true;
+
+            EnterEvadeMode();
+            return false;
+        }
+
+        bool CheckBoundary(Unit* who);
+        void TeleportCheaters();
+
+        EventMap events;
+        SummonList summons;
+
+    private:
+        BossBoundaryMap const* const _boundary;
+        uint32 const _bossId;
+};
+
+class WorldBossAI : public ScriptedAI
+{
+    public:
+        WorldBossAI(Creature* creature);
+        virtual ~WorldBossAI() {}
+
+        void JustSummoned(Creature* summon);
+        void SummonedCreatureDespawn(Creature* summon);
+
+        virtual void UpdateAI(uint32 diff);
+
+        // Hook used to execute events scheduled into EventMap without the need
+        // to override UpdateAI
+        // note: You must re-schedule the event within this method if the event
+        // is supposed to run more than once
+        virtual void ExecuteEvent(uint32 /*eventId*/) { }
+
+        void Reset() { _Reset(); }
+        void EnterCombat(Unit* /*who*/) { _EnterCombat(); }
+        void JustDied(Unit* /*killer*/) { _JustDied(); }
+
+    protected:
+        void _Reset();
+        void _EnterCombat();
+        void _JustDied();
+
+        EventMap events;
+        SummonList summons;
+};
+
+// SD2 grid searchers.
+Creature* GetClosestCreatureWithEntry(WorldObject* source, uint32 entry, float maxSearchRange, bool alive = true);
+GameObject* GetClosestGameObjectWithEntry(WorldObject* source, uint32 entry, float maxSearchRange);
+void GetCreatureListWithEntryInGrid(std::list<Creature*>& list, WorldObject* source, uint32 entry, float maxSearchRange);
+void GetGameObjectListWithEntryInGrid(std::list<GameObject*>& list, WorldObject* source, uint32 entry, float maxSearchRange);
+
+#endif // SCRIPTEDCREATURE_H_

src/server/game/AI/ScriptedAI/ScriptedEscortAI.cpp

@@ -0,0 +1,584 @@
+/* Copyright (C) 2006 - 2009 ScriptDev2 <https://scriptdev2.svn.sourceforge.net/>
+ * This program is free software licensed under GPL version 2
+ * Please see the included DOCS/LICENSE.TXT for more information */
+
+/* ScriptData
+SDName: Npc_EscortAI
+SD%Complete: 100
+SDComment:
+SDCategory: Npc
+EndScriptData */
+
+#include "ScriptedCreature.h"
+#include "ScriptedEscortAI.h"
+#include "Group.h"
+#include "Player.h"
+
+enum ePoints
+{
+    POINT_LAST_POINT    = 0xFFFFFF,
+    POINT_HOME          = 0xFFFFFE
+};
+
+npc_escortAI::npc_escortAI(Creature* creature) : ScriptedAI(creature),
+    m_uiPlayerGUID(0),
+    m_uiWPWaitTimer(1000),
+    m_uiPlayerCheckTimer(0),
+    m_uiEscortState(STATE_ESCORT_NONE),
+    MaxPlayerDistance(DEFAULT_MAX_PLAYER_DISTANCE),
+    m_pQuestForEscort(NULL),
+    m_bIsActiveAttacker(true),
+    m_bIsRunning(false),
+    m_bCanInstantRespawn(false),
+    m_bCanReturnToStart(false),
+    DespawnAtEnd(true),
+    DespawnAtFar(true),
+    ScriptWP(false),
+    HasImmuneToNPCFlags(false)
+{}
+
+void npc_escortAI::AttackStart(Unit* who)
+{
+    if (!who)
+        return;
+
+    if (me->Attack(who, true))
+    {
+        MovementGeneratorType type = me->GetMotionMaster()->GetMotionSlotType(MOTION_SLOT_ACTIVE);
+        if (type == ESCORT_MOTION_TYPE || type == POINT_MOTION_TYPE)
+        {
+            me->GetMotionMaster()->MovementExpired();
+            //me->DisableSpline();
+            me->StopMoving();
+        }
+
+        if (IsCombatMovementAllowed())
+            me->GetMotionMaster()->MoveChase(who);
+    }
+}
+
+//see followerAI
+bool npc_escortAI::AssistPlayerInCombat(Unit* who)
+{
+    if (!who || !who->GetVictim())
+        return false;
+
+    //experimental (unknown) flag not present
+    if (!(me->GetCreatureTemplate()->type_flags & CREATURE_TYPEFLAGS_AID_PLAYERS))
+        return false;
+
+    //not a player
+    if (!who->GetVictim()->GetCharmerOrOwnerPlayerOrPlayerItself())
+        return false;
+
+    //never attack friendly
+    if (!me->IsValidAttackTarget(who))
+        return false;
+
+    //too far away and no free sight?
+    if (me->IsWithinDistInMap(who, GetMaxPlayerDistance()) && me->IsWithinLOSInMap(who))
+    {
+        AttackStart(who);
+        return true;
+    }
+
+    return false;
+}
+
+void npc_escortAI::MoveInLineOfSight(Unit* who)
+{
+	if (me->GetVictim())
+		return;
+
+    if (!me->HasUnitState(UNIT_STATE_STUNNED) && who->isTargetableForAttack(true, me) && who->isInAccessiblePlaceFor(me))
+        if (HasEscortState(STATE_ESCORT_ESCORTING) && AssistPlayerInCombat(who))
+            return;
+
+    if (me->CanStartAttack(who))
+        AttackStart(who);
+}
+
+void npc_escortAI::JustDied(Unit* /*killer*/)
+{
+    if (!HasEscortState(STATE_ESCORT_ESCORTING) || !m_uiPlayerGUID || !m_pQuestForEscort)
+        return;
+
+    if (Player* player = GetPlayerForEscort())
+    {
+        if (Group* group = player->GetGroup())
+        {
+            for (GroupReference* groupRef = group->GetFirstMember(); groupRef != NULL; groupRef = groupRef->next())
+                if (Player* member = groupRef->GetSource())
+                    if (member->IsInMap(player) && member->GetQuestStatus(m_pQuestForEscort->GetQuestId()) == QUEST_STATUS_INCOMPLETE)
+                        member->FailQuest(m_pQuestForEscort->GetQuestId());
+        }
+        else
+        {
+            if (player->GetQuestStatus(m_pQuestForEscort->GetQuestId()) == QUEST_STATUS_INCOMPLETE)
+                player->FailQuest(m_pQuestForEscort->GetQuestId());
+        }
+    }
+}
+
+void npc_escortAI::JustRespawned()
+{
+	RemoveEscortState(STATE_ESCORT_ESCORTING|STATE_ESCORT_RETURNING|STATE_ESCORT_PAUSED);
+
+    if (!IsCombatMovementAllowed())
+        SetCombatMovement(true);
+
+    //add a small delay before going to first waypoint, normal in near all cases
+    m_uiWPWaitTimer = 1000;
+
+    if (me->getFaction() != me->GetCreatureTemplate()->faction)
+        me->RestoreFaction();
+
+    Reset();
+}
+
+void npc_escortAI::ReturnToLastPoint()
+{
+    float x, y, z, o;
+	me->SetWalk(false);
+    me->GetHomePosition(x, y, z, o);
+    me->GetMotionMaster()->MovePoint(POINT_LAST_POINT, x, y, z);
+}
+
+void npc_escortAI::EnterEvadeMode()
+{
+    me->RemoveAllAuras();
+    me->DeleteThreatList();
+    me->CombatStop(true);
+    me->SetLootRecipient(NULL);
+
+    if (HasEscortState(STATE_ESCORT_ESCORTING))
+    {
+        AddEscortState(STATE_ESCORT_RETURNING);
+        ReturnToLastPoint();
+        ;//sLog->outDebug(LOG_FILTER_TSCR, "TSCR: EscortAI has left combat and is now returning to last point");
+    }
+    else
+    {
+        me->GetMotionMaster()->MoveTargetedHome();
+        if (HasImmuneToNPCFlags)
+            me->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_IMMUNE_TO_NPC);
+        Reset();
+    }
+}
+
+bool npc_escortAI::IsPlayerOrGroupInRange()
+{
+    if (Player* player = GetPlayerForEscort())
+    {
+        if (Group* group = player->GetGroup())
+        {
+            for (GroupReference* groupRef = group->GetFirstMember(); groupRef != NULL; groupRef = groupRef->next())
+                if (Player* member = groupRef->GetSource())
+                    if (me->IsWithinDistInMap(member, GetMaxPlayerDistance()))
+                        return true;
+        }
+        else if (me->IsWithinDistInMap(player, GetMaxPlayerDistance()))
+            return true;
+    }
+
+    return false;
+}
+
+void npc_escortAI::UpdateAI(uint32 diff)
+{
+    if (HasEscortState(STATE_ESCORT_ESCORTING) && !me->GetVictim() && m_uiWPWaitTimer && !HasEscortState(STATE_ESCORT_RETURNING))
+    {
+        if (m_uiWPWaitTimer <= diff)
+        {
+            if (CurrentWP == WaypointList.end())
+            {
+                if (DespawnAtEnd)
+                {
+                    if (m_bCanReturnToStart)
+                    {
+                        float fRetX, fRetY, fRetZ;
+                        me->GetRespawnPosition(fRetX, fRetY, fRetZ);
+                        me->GetMotionMaster()->MovePoint(POINT_HOME, fRetX, fRetY, fRetZ);
+
+                        m_uiWPWaitTimer = 0;
+                        return;
+                    }
+
+                    if (m_bCanInstantRespawn)
+                    {
+                        me->setDeathState(JUST_DIED);
+                        me->Respawn();
+                    }
+                    else
+                        me->DespawnOrUnsummon();
+                }
+
+				// xinef: remove escort state, escort was finished (lack of this line resulted in skipping UpdateEscortAI calls after finished escort)
+				RemoveEscortState(STATE_ESCORT_ESCORTING);
+                return;
+            }
+
+            if (!HasEscortState(STATE_ESCORT_PAUSED))
+            {
+                // xinef, start escort if there is no spline active
+                if (me->movespline->Finalized())
+                {
+                    Movement::PointsArray pathPoints;
+                    GenerateWaypointArray(&pathPoints);
+                    me->GetMotionMaster()->MoveSplinePath(&pathPoints);
+                }
+
+                WaypointStart(CurrentWP->id);
+                m_uiWPWaitTimer = 0;
+            }
+        }
+        else
+            m_uiWPWaitTimer -= diff;
+    }
+
+    //Check if player or any member of his group is within range
+    if (HasEscortState(STATE_ESCORT_ESCORTING) && m_uiPlayerGUID && !me->GetVictim() && !HasEscortState(STATE_ESCORT_RETURNING))
+    {
+		m_uiPlayerCheckTimer += diff;
+        if (m_uiPlayerCheckTimer > 1000)
+        {
+            if (DespawnAtFar && !IsPlayerOrGroupInRange())
+            {
+                if (m_bCanInstantRespawn)
+                {
+                    me->setDeathState(JUST_DIED);
+                    me->Respawn();
+                }
+                else
+                    me->DespawnOrUnsummon();
+
+                return;
+            }
+
+            m_uiPlayerCheckTimer = 0;
+        }
+    }
+
+    UpdateEscortAI(diff);
+}
+
+void npc_escortAI::UpdateEscortAI(uint32 /*diff*/)
+{
+    if (!UpdateVictim())
+        return;
+
+    DoMeleeAttackIfReady();
+}
+
+void npc_escortAI::MovementInform(uint32 moveType, uint32 pointId)
+{
+    // xinef: no action allowed if there is no escort
+    if (!HasEscortState(STATE_ESCORT_ESCORTING))
+        return;
+
+    if (moveType == POINT_MOTION_TYPE)
+    {
+        //Combat start position reached, continue waypoint movement
+        if (pointId == POINT_LAST_POINT)
+        {
+            ;//sLog->outDebug(LOG_FILTER_TSCR, "TSCR: EscortAI has returned to original position before combat");
+
+            me->SetWalk(!m_bIsRunning);
+            RemoveEscortState(STATE_ESCORT_RETURNING);
+
+            if (!m_uiWPWaitTimer)
+                m_uiWPWaitTimer = 1;
+        }
+        else if (pointId == POINT_HOME)
+        {
+            ;//sLog->outDebug(LOG_FILTER_TSCR, "TSCR: EscortAI has returned to original home location and will continue from beginning of waypoint list.");
+
+            CurrentWP = WaypointList.begin();
+            m_uiWPWaitTimer = 1;
+        }
+    }
+    else if (moveType == ESCORT_MOTION_TYPE)
+    {
+        if (m_uiWPWaitTimer <= 1 && !HasEscortState(STATE_ESCORT_PAUSED) && CurrentWP != WaypointList.end())
+        {
+            //Call WP function
+            me->SetPosition(CurrentWP->x, CurrentWP->y, CurrentWP->z, me->GetOrientation());
+			me->SetHomePosition(me->GetPositionX(), me->GetPositionY(), me->GetPositionZ(), me->GetOrientation());
+            WaypointReached(CurrentWP->id);
+
+            m_uiWPWaitTimer = CurrentWP->WaitTimeMs + 1;
+
+            ++CurrentWP;
+
+            if (m_uiWPWaitTimer > 1 || HasEscortState(STATE_ESCORT_PAUSED))
+            {
+                if (me->GetMotionMaster()->GetMotionSlotType(MOTION_SLOT_ACTIVE) == ESCORT_MOTION_TYPE)
+                    me->GetMotionMaster()->MovementExpired();
+                me->StopMovingOnCurrentPos();
+                me->GetMotionMaster()->MoveIdle();
+            }
+        }
+    }
+}
+
+/*
+void npc_escortAI::OnPossess(bool apply)
+{
+    // We got possessed in the middle of being escorted, store the point
+    // where we left off to come back to when possess is removed
+    if (HasEscortState(STATE_ESCORT_ESCORTING))
+    {
+        if (apply)
+            me->GetPosition(LastPos.x, LastPos.y, LastPos.z);
+        else
+        {
+            Returning = true;
+            me->GetMotionMaster()->MovementExpired();
+            me->GetMotionMaster()->MovePoint(WP_LAST_POINT, LastPos.x, LastPos.y, LastPos.z);
+        }
+    }
+}
+*/
+
+void npc_escortAI::AddWaypoint(uint32 id, float x, float y, float z, uint32 waitTime)
+{
+    Escort_Waypoint t(id, x, y, z, waitTime);
+
+    WaypointList.push_back(t);
+
+    // i think SD2 no longer uses this function
+    ScriptWP = true;
+    /*PointMovement wp;
+    wp.m_uiCreatureEntry = me->GetEntry();
+    wp.m_uiPointId = id;
+    wp.m_fX = x;
+    wp.m_fY = y;
+    wp.m_fZ = z;
+    wp.m_uiWaitTime = WaitTimeMs;
+    PointMovementMap[wp.m_uiCreatureEntry].push_back(wp);*/
+}
+
+void npc_escortAI::FillPointMovementListForCreature()
+{
+    ScriptPointVector const& movePoints = sScriptSystemMgr->GetPointMoveList(me->GetEntry());
+    if (movePoints.empty())
+        return;
+
+    ScriptPointVector::const_iterator itrEnd = movePoints.end();
+    for (ScriptPointVector::const_iterator itr = movePoints.begin(); itr != itrEnd; ++itr)
+    {
+        Escort_Waypoint point(itr->uiPointId, itr->fX, itr->fY, itr->fZ, itr->uiWaitTime);
+        WaypointList.push_back(point);
+    }
+}
+
+void npc_escortAI::SetRun(bool on)
+{
+    if (on)
+    {
+        if (!m_bIsRunning)
+            me->SetWalk(false);
+        else
+            ;//sLog->outDebug(LOG_FILTER_TSCR, "TSCR: EscortAI attempt to set run mode, but is already running.");
+    }
+    else
+    {
+        if (m_bIsRunning)
+            me->SetWalk(true);
+        else
+            ;//sLog->outDebug(LOG_FILTER_TSCR, "TSCR: EscortAI attempt to set walk mode, but is already walking.");
+    }
+
+    m_bIsRunning = on;
+}
+
+//TODO: get rid of this many variables passed in function.
+void npc_escortAI::Start(bool isActiveAttacker /* = true*/, bool run /* = false */, uint64 playerGUID /* = 0 */, Quest const* quest /* = NULL */, bool instantRespawn /* = false */, bool canLoopPath /* = false */, bool resetWaypoints /* = true */)
+{
+    if (me->GetVictim())
+    {
+        sLog->outError("TSCR ERROR: EscortAI (script: %s, creature entry: %u) attempts to Start while in combat", me->GetScriptName().c_str(), me->GetEntry());
+        return;
+    }
+
+    if (HasEscortState(STATE_ESCORT_ESCORTING))
+    {
+        sLog->outError("TSCR: EscortAI (script: %s, creature entry: %u) attempts to Start while already escorting", me->GetScriptName().c_str(), me->GetEntry());
+        return;
+    }
+
+    if (!ScriptWP && resetWaypoints) // sd2 never adds wp in script, but tc does
+    {
+        if (!WaypointList.empty())
+            WaypointList.clear();
+        FillPointMovementListForCreature();
+    }
+
+    if (WaypointList.empty())
+    {
+        sLog->outErrorDb("TSCR: EscortAI (script: %s, creature entry: %u) starts with 0 waypoints (possible missing entry in script_waypoint. Quest: %u).",
+            me->GetScriptName().c_str(), me->GetEntry(), quest ? quest->GetQuestId() : 0);
+        return;
+    }
+
+    //set variables
+    m_bIsActiveAttacker = isActiveAttacker;
+    m_bIsRunning = run;
+
+    m_uiPlayerGUID = playerGUID;
+    m_pQuestForEscort = quest;
+
+    m_bCanInstantRespawn = instantRespawn;
+    m_bCanReturnToStart = canLoopPath;
+
+    //if (m_bCanReturnToStart && m_bCanInstantRespawn)
+        ;//sLog->outDebug(LOG_FILTER_TSCR, "TSCR: EscortAI is set to return home after waypoint end and instant respawn at waypoint end. Creature will never despawn.");
+
+    if (me->GetMotionMaster()->GetCurrentMovementGeneratorType() == WAYPOINT_MOTION_TYPE)
+    {
+        me->GetMotionMaster()->MovementExpired();
+        me->GetMotionMaster()->MoveIdle();
+        ;//sLog->outDebug(LOG_FILTER_TSCR, "TSCR: EscortAI start with WAYPOINT_MOTION_TYPE, changed to MoveIdle.");
+    }
+
+    //disable npcflags
+    me->SetUInt32Value(UNIT_NPC_FLAGS, UNIT_NPC_FLAG_NONE);
+    if (me->HasFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_IMMUNE_TO_NPC))
+    {
+        HasImmuneToNPCFlags = true;
+        me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_IMMUNE_TO_NPC);
+    }
+
+    ;//sLog->outDebug(LOG_FILTER_TSCR, "TSCR: EscortAI started with " UI64FMTD " waypoints. ActiveAttacker = %d, Run = %d, PlayerGUID = " UI64FMTD "", uint64(WaypointList.size()), m_bIsActiveAttacker, m_bIsRunning, m_uiPlayerGUID);
+
+    CurrentWP = WaypointList.begin();
+
+    //Set initial speed
+    if (m_bIsRunning)
+        me->SetWalk(false);
+    else
+        me->SetWalk(true);
+
+    AddEscortState(STATE_ESCORT_ESCORTING);
+    if (me->GetMotionMaster()->GetMotionSlotType(MOTION_SLOT_ACTIVE) == ESCORT_MOTION_TYPE)
+        me->GetMotionMaster()->MovementExpired();
+    me->DisableSpline();
+    me->GetMotionMaster()->MoveIdle();
+}
+
+void npc_escortAI::SetEscortPaused(bool on)
+{
+    if (!HasEscortState(STATE_ESCORT_ESCORTING))
+        return;
+
+    if (on)
+        AddEscortState(STATE_ESCORT_PAUSED);
+    else
+        RemoveEscortState(STATE_ESCORT_PAUSED);
+}
+
+bool npc_escortAI::SetNextWaypoint(uint32 pointId, float x, float y, float z, float orientation)
+{
+    me->UpdatePosition(x, y, z, orientation);
+    return SetNextWaypoint(pointId, false);
+}
+
+bool npc_escortAI::SetNextWaypoint(uint32 pointId, bool setPosition)
+{
+    if (!WaypointList.empty())
+        WaypointList.clear();
+
+    FillPointMovementListForCreature();
+
+    if (WaypointList.empty())
+        return false;
+
+    size_t const size = WaypointList.size();
+    Escort_Waypoint waypoint(0, 0, 0, 0, 0);
+	for (CurrentWP = WaypointList.begin(); CurrentWP != WaypointList.end(); ++CurrentWP)
+    {
+		if (CurrentWP->id == pointId)
+        {
+            if (setPosition)
+                me->UpdatePosition(CurrentWP->x, CurrentWP->y, CurrentWP->z, me->GetOrientation());
+            return true;
+        }
+    }
+
+    return false;
+}
+
+bool npc_escortAI::GetWaypointPosition(uint32 pointId, float& x, float& y, float& z)
+{
+    ScriptPointVector const& waypoints = sScriptSystemMgr->GetPointMoveList(me->GetEntry());
+    if (waypoints.empty())
+        return false;
+
+    for (ScriptPointVector::const_iterator itr = waypoints.begin(); itr != waypoints.end(); ++itr)
+    {
+        if (itr->uiPointId == pointId)
+        {
+            x = itr->fX;
+            y = itr->fY;
+            z = itr->fZ;
+            return true;
+        }
+    }
+
+    return false;
+}
+
+void npc_escortAI::GenerateWaypointArray(Movement::PointsArray* points)
+{
+    if (WaypointList.empty())
+        return;
+
+    uint32 startingWaypointId = CurrentWP->id;
+
+    // Flying unit, just fill array
+    if (me->m_movementInfo.HasMovementFlag((MovementFlags)(MOVEMENTFLAG_CAN_FLY|MOVEMENTFLAG_DISABLE_GRAVITY)))
+    {
+        // xinef: first point in vector is unit real position
+        points->clear();
+		points->push_back(G3D::Vector3(me->GetPositionX(), me->GetPositionY(), me->GetPositionZ()));
+        for (std::list<Escort_Waypoint>::const_iterator itr = CurrentWP; itr != WaypointList.end(); ++itr)
+            points->push_back(G3D::Vector3(itr->x, itr->y, itr->z));
+    }
+    else
+    {
+        for (float size = 1.0f; size; size *= 0.5f)
+        {
+            std::vector<G3D::Vector3> pVector;
+            // xinef: first point in vector is unit real position
+            pVector.push_back(G3D::Vector3(me->GetPositionX(), me->GetPositionY(), me->GetPositionZ()));
+            uint32 length = (WaypointList.size() - startingWaypointId)*size;
+
+            uint32 cnt = 0;
+            for (std::list<Escort_Waypoint>::const_iterator itr = CurrentWP; itr != WaypointList.end() && cnt <= length; ++itr, ++cnt)
+                pVector.push_back(G3D::Vector3(itr->x, itr->y, itr->z));
+
+            if (pVector.size() > 2) // more than source + dest
+            {
+                G3D::Vector3 middle = (pVector[0] + pVector[pVector.size()-1]) / 2.f;
+                G3D::Vector3 offset;
+
+                bool continueLoop = false;
+                for (uint32 i = 1; i < pVector.size()-1; ++i)
+                {
+                    offset = middle - pVector[i];
+                    if (fabs(offset.x) >= 0xFF || fabs(offset.y) >= 0xFF || fabs(offset.z) >= 0x7F)
+                    {
+                        // offset is too big, split points
+                        continueLoop = true;
+                        break;
+                    }
+                }
+                if (continueLoop)
+                    continue;
+            }
+            // everything ok
+            *points = pVector;
+            break;
+       }
+    }
+}

src/server/game/AI/ScriptedAI/ScriptedEscortAI.h

@@ -0,0 +1,128 @@
+/* Copyright (C) 2006 - 2009 ScriptDev2 <https://scriptdev2.svn.sourceforge.net/>
+ * This program is free software licensed under GPL version 2
+ * Please see the included DOCS/LICENSE.TXT for more information */
+
+#ifndef SC_ESCORTAI_H
+#define SC_ESCORTAI_H
+
+#include "ScriptSystem.h"
+
+#define DEFAULT_MAX_PLAYER_DISTANCE 50
+
+struct Escort_Waypoint
+{
+    Escort_Waypoint(uint32 _id, float _x, float _y, float _z, uint32 _w)
+    {
+        id = _id;
+        x = _x;
+        y = _y;
+        z = _z;
+        WaitTimeMs = _w;
+    }
+
+    uint32 id;
+    float x;
+    float y;
+    float z;
+    uint32 WaitTimeMs;
+};
+
+enum eEscortState
+{
+    STATE_ESCORT_NONE       = 0x000,                        //nothing in progress
+    STATE_ESCORT_ESCORTING  = 0x001,                        //escort are in progress
+    STATE_ESCORT_RETURNING  = 0x002,                        //escort is returning after being in combat
+    STATE_ESCORT_PAUSED     = 0x004                         //will not proceed with waypoints before state is removed
+};
+
+struct npc_escortAI : public ScriptedAI
+{
+    public:
+        explicit npc_escortAI(Creature* creature);
+        ~npc_escortAI() {}
+
+        // CreatureAI functions
+        void AttackStart(Unit* who);
+
+        void MoveInLineOfSight(Unit* who);
+
+        void JustDied(Unit*);
+
+        void JustRespawned();
+
+        void ReturnToLastPoint();
+
+        void EnterEvadeMode();
+
+        void UpdateAI(uint32 diff);                   //the "internal" update, calls UpdateEscortAI()
+        virtual void UpdateEscortAI(uint32 diff);     //used when it's needed to add code in update (abilities, scripted events, etc)
+
+        void MovementInform(uint32, uint32);
+
+        // EscortAI functions
+        void AddWaypoint(uint32 id, float x, float y, float z, uint32 waitTime = 0);    // waitTime is in ms
+
+        //this will set the current position to x/y/z/o, and the current WP to pointId.
+        bool SetNextWaypoint(uint32 pointId, float x, float y, float z, float orientation);
+
+        //this will set the current position to WP start position (if setPosition == true),
+        //and the current WP to pointId
+        bool SetNextWaypoint(uint32 pointId, bool setPosition = true);
+
+        bool GetWaypointPosition(uint32 pointId, float& x, float& y, float& z);
+
+        void GenerateWaypointArray(Movement::PointsArray* points);
+
+        virtual void WaypointReached(uint32 pointId) = 0;
+        virtual void WaypointStart(uint32 /*pointId*/) {}
+
+        void Start(bool isActiveAttacker = true, bool run = false, uint64 playerGUID = 0, Quest const* quest = NULL, bool instantRespawn = false, bool canLoopPath = false, bool resetWaypoints = true);
+
+        void SetRun(bool on = true);
+        void SetEscortPaused(bool on);
+
+        bool HasEscortState(uint32 escortState) { return (m_uiEscortState & escortState); }
+        virtual bool IsEscorted() { return (m_uiEscortState & STATE_ESCORT_ESCORTING); }
+
+        void SetMaxPlayerDistance(float newMax) { MaxPlayerDistance = newMax; }
+        float GetMaxPlayerDistance() { return MaxPlayerDistance; }
+
+        void SetDespawnAtEnd(bool despawn) { DespawnAtEnd = despawn; }
+        void SetDespawnAtFar(bool despawn) { DespawnAtFar = despawn; }
+        bool GetAttack() { return m_bIsActiveAttacker; }//used in EnterEvadeMode override
+        void SetCanAttack(bool attack) { m_bIsActiveAttacker = attack; }
+        uint64 GetEventStarterGUID() { return m_uiPlayerGUID; }
+
+        void AddEscortState(uint32 escortState) { m_uiEscortState |= escortState; }
+        void RemoveEscortState(uint32 escortState) { m_uiEscortState &= ~escortState; }
+
+    protected:
+        Player* GetPlayerForEscort() { return ObjectAccessor::GetPlayer(*me, m_uiPlayerGUID); }
+
+    private:
+        bool AssistPlayerInCombat(Unit* who);
+        bool IsPlayerOrGroupInRange();
+        void FillPointMovementListForCreature();
+
+        uint64 m_uiPlayerGUID;
+        uint32 m_uiWPWaitTimer;
+        uint32 m_uiPlayerCheckTimer;
+        uint32 m_uiEscortState;
+        float MaxPlayerDistance;
+
+        Quest const* m_pQuestForEscort;                     //generally passed in Start() when regular escort script.
+
+        std::list<Escort_Waypoint> WaypointList;
+        std::list<Escort_Waypoint>::iterator CurrentWP;
+
+        bool m_bIsActiveAttacker;                           //obsolete, determined by faction.
+        bool m_bIsRunning;                                  //all creatures are walking by default (has flag MOVEMENTFLAG_WALK)
+        bool m_bCanInstantRespawn;                          //if creature should respawn instantly after escort over (if not, database respawntime are used)
+        bool m_bCanReturnToStart;                           //if creature can walk same path (loop) without despawn. Not for regular escort quests.
+        bool DespawnAtEnd;
+        bool DespawnAtFar;
+        bool ScriptWP;
+        bool HasImmuneToNPCFlags;
+};
+#endif
+

src/server/game/AI/ScriptedAI/ScriptedFollowerAI.cpp

@@ -0,0 +1,362 @@
+/* Copyright (C) 2006 - 2009 ScriptDev2 <https://scriptdev2.svn.sourceforge.net/>
+ * This program is free software licensed under GPL version 2
+ * Please see the included DOCS/LICENSE.TXT for more information */
+
+/* ScriptData
+SDName: FollowerAI
+SD%Complete: 50
+SDComment: This AI is under development
+SDCategory: Npc
+EndScriptData */
+
+#include "ScriptedCreature.h"
+#include "ScriptedFollowerAI.h"
+#include "Group.h"
+#include "Player.h"
+
+const float MAX_PLAYER_DISTANCE = 100.0f;
+
+enum ePoints
+{
+    POINT_COMBAT_START  = 0xFFFFFF
+};
+
+FollowerAI::FollowerAI(Creature* creature) : ScriptedAI(creature),
+    m_uiLeaderGUID(0),
+    m_uiUpdateFollowTimer(2500),
+    m_uiFollowState(STATE_FOLLOW_NONE),
+    m_pQuestForFollow(NULL)
+{}
+
+void FollowerAI::AttackStart(Unit* who)
+{
+    if (!who)
+        return;
+
+    if (me->Attack(who, true))
+    {
+		// This is done in Unit::Attack function which wont bug npcs by not adding threat upon combat start...
+        //me->AddThreat(who, 0.0f);
+        //me->SetInCombatWith(who);
+        //who->SetInCombatWith(me);
+
+        if (me->HasUnitState(UNIT_STATE_FOLLOW))
+            me->ClearUnitState(UNIT_STATE_FOLLOW);
+
+        if (IsCombatMovementAllowed())
+            me->GetMotionMaster()->MoveChase(who);
+    }
+}
+
+//This part provides assistance to a player that are attacked by who, even if out of normal aggro range
+//It will cause me to attack who that are attacking _any_ player (which has been confirmed may happen also on offi)
+//The flag (type_flag) is unconfirmed, but used here for further research and is a good candidate.
+bool FollowerAI::AssistPlayerInCombat(Unit* who)
+{
+    if (!who || !who->GetVictim())
+        return false;
+
+    //experimental (unknown) flag not present
+    if (!(me->GetCreatureTemplate()->type_flags & CREATURE_TYPEFLAGS_AID_PLAYERS))
+        return false;
+
+    //not a player
+    if (!who->GetVictim()->GetCharmerOrOwnerPlayerOrPlayerItself())
+        return false;
+
+    //never attack friendly
+    if (me->IsFriendlyTo(who))
+        return false;
+
+    //too far away and no free sight?
+    if (me->IsWithinDistInMap(who, MAX_PLAYER_DISTANCE) && me->IsWithinLOSInMap(who))
+    {
+        AttackStart(who);
+        return true;
+    }
+
+    return false;
+}
+
+void FollowerAI::MoveInLineOfSight(Unit* who)
+{
+	if (me->GetVictim())
+		return;
+
+    if (!me->HasUnitState(UNIT_STATE_STUNNED) && who->isTargetableForAttack(true, me) && who->isInAccessiblePlaceFor(me))
+        if (HasFollowState(STATE_FOLLOW_INPROGRESS) && AssistPlayerInCombat(who))
+            return;
+
+	if (me->CanStartAttack(who))
+        AttackStart(who);
+}
+
+void FollowerAI::JustDied(Unit* /*pKiller*/)
+{
+    if (!HasFollowState(STATE_FOLLOW_INPROGRESS) || !m_uiLeaderGUID || !m_pQuestForFollow)
+        return;
+
+    //TODO: need a better check for quests with time limit.
+    if (Player* player = GetLeaderForFollower())
+    {
+        if (Group* group = player->GetGroup())
+        {
+            for (GroupReference* groupRef = group->GetFirstMember(); groupRef != NULL; groupRef = groupRef->next())
+            {
+                if (Player* member = groupRef->GetSource())
+                {
+                    if (member->IsInMap(player) && member->GetQuestStatus(m_pQuestForFollow->GetQuestId()) == QUEST_STATUS_INCOMPLETE)
+                        member->FailQuest(m_pQuestForFollow->GetQuestId());
+                }
+            }
+        }
+        else
+        {
+            if (player->GetQuestStatus(m_pQuestForFollow->GetQuestId()) == QUEST_STATUS_INCOMPLETE)
+                player->FailQuest(m_pQuestForFollow->GetQuestId());
+        }
+    }
+}
+
+void FollowerAI::JustRespawned()
+{
+    m_uiFollowState = STATE_FOLLOW_NONE;
+
+    if (!IsCombatMovementAllowed())
+        SetCombatMovement(true);
+
+    if (me->getFaction() != me->GetCreatureTemplate()->faction)
+        me->setFaction(me->GetCreatureTemplate()->faction);
+
+    Reset();
+}
+
+void FollowerAI::EnterEvadeMode()
+{
+    me->RemoveAllAuras();
+    me->DeleteThreatList();
+    me->CombatStop(true);
+    me->SetLootRecipient(NULL);
+
+    if (HasFollowState(STATE_FOLLOW_INPROGRESS))
+    {
+        ;//sLog->outDebug(LOG_FILTER_TSCR, "TSCR: FollowerAI left combat, returning to CombatStartPosition.");
+
+        if (me->GetMotionMaster()->GetCurrentMovementGeneratorType() == CHASE_MOTION_TYPE)
+        {
+            float fPosX, fPosY, fPosZ;
+            me->GetPosition(fPosX, fPosY, fPosZ);
+            me->GetMotionMaster()->MovePoint(POINT_COMBAT_START, fPosX, fPosY, fPosZ);
+        }
+    }
+    else
+    {
+        if (me->GetMotionMaster()->GetCurrentMovementGeneratorType() == CHASE_MOTION_TYPE)
+            me->GetMotionMaster()->MoveTargetedHome();
+    }
+
+    Reset();
+}
+
+void FollowerAI::UpdateAI(uint32 uiDiff)
+{
+    if (HasFollowState(STATE_FOLLOW_INPROGRESS) && !me->GetVictim())
+    {
+        if (m_uiUpdateFollowTimer <= uiDiff)
+        {
+            if (HasFollowState(STATE_FOLLOW_COMPLETE) && !HasFollowState(STATE_FOLLOW_POSTEVENT))
+            {
+                ;//sLog->outDebug(LOG_FILTER_TSCR, "TSCR: FollowerAI is set completed, despawns.");
+                me->DespawnOrUnsummon();
+                return;
+            }
+
+            bool bIsMaxRangeExceeded = true;
+
+            if (Player* player = GetLeaderForFollower())
+            {
+                if (HasFollowState(STATE_FOLLOW_RETURNING))
+                {
+                    ;//sLog->outDebug(LOG_FILTER_TSCR, "TSCR: FollowerAI is returning to leader.");
+
+                    RemoveFollowState(STATE_FOLLOW_RETURNING);
+                    me->GetMotionMaster()->MoveFollow(player, PET_FOLLOW_DIST, PET_FOLLOW_ANGLE);
+                    return;
+                }
+
+                if (Group* group = player->GetGroup())
+                {
+                    for (GroupReference* groupRef = group->GetFirstMember(); groupRef != NULL; groupRef = groupRef->next())
+                    {
+                        Player* member = groupRef->GetSource();
+
+                        if (member && me->IsWithinDistInMap(member, MAX_PLAYER_DISTANCE))
+                        {
+                            bIsMaxRangeExceeded = false;
+                            break;
+                        }
+                    }
+                }
+                else
+                {
+                    if (me->IsWithinDistInMap(player, MAX_PLAYER_DISTANCE))
+                        bIsMaxRangeExceeded = false;
+                }
+            }
+
+            if (bIsMaxRangeExceeded)
+            {
+                ;//sLog->outDebug(LOG_FILTER_TSCR, "TSCR: FollowerAI failed because player/group was to far away or not found");
+                me->DespawnOrUnsummon();
+                return;
+            }
+
+            m_uiUpdateFollowTimer = 1000;
+        }
+        else
+            m_uiUpdateFollowTimer -= uiDiff;
+    }
+
+    UpdateFollowerAI(uiDiff);
+}
+
+void FollowerAI::UpdateFollowerAI(uint32 /*uiDiff*/)
+{
+    if (!UpdateVictim())
+        return;
+
+    DoMeleeAttackIfReady();
+}
+
+void FollowerAI::MovementInform(uint32 motionType, uint32 pointId)
+{
+    if (motionType != POINT_MOTION_TYPE || !HasFollowState(STATE_FOLLOW_INPROGRESS))
+        return;
+
+    if (pointId == POINT_COMBAT_START)
+    {
+        if (GetLeaderForFollower())
+        {
+            if (!HasFollowState(STATE_FOLLOW_PAUSED))
+                AddFollowState(STATE_FOLLOW_RETURNING);
+        }
+        else
+            me->DespawnOrUnsummon();
+    }
+}
+
+void FollowerAI::StartFollow(Player* player, uint32 factionForFollower, const Quest* quest)
+{
+    if (me->GetVictim())
+    {
+        ;//sLog->outDebug(LOG_FILTER_TSCR, "TSCR: FollowerAI attempt to StartFollow while in combat.");
+        return;
+    }
+
+    if (HasFollowState(STATE_FOLLOW_INPROGRESS))
+    {
+        sLog->outError("TSCR: FollowerAI attempt to StartFollow while already following.");
+        return;
+    }
+
+    //set variables
+    m_uiLeaderGUID = player->GetGUID();
+
+    if (factionForFollower)
+        me->setFaction(factionForFollower);
+
+    m_pQuestForFollow = quest;
+
+    if (me->GetMotionMaster()->GetCurrentMovementGeneratorType() == WAYPOINT_MOTION_TYPE)
+    {
+        me->GetMotionMaster()->Clear();
+        me->GetMotionMaster()->MoveIdle();
+        ;//sLog->outDebug(LOG_FILTER_TSCR, "TSCR: FollowerAI start with WAYPOINT_MOTION_TYPE, set to MoveIdle.");
+    }
+
+    me->SetUInt32Value(UNIT_NPC_FLAGS, UNIT_NPC_FLAG_NONE);
+
+    AddFollowState(STATE_FOLLOW_INPROGRESS);
+
+    me->GetMotionMaster()->MoveFollow(player, PET_FOLLOW_DIST, PET_FOLLOW_ANGLE);
+
+    ;//sLog->outDebug(LOG_FILTER_TSCR, "TSCR: FollowerAI start follow %s (GUID " UI64FMTD ")", player->GetName().c_str(), m_uiLeaderGUID);
+}
+
+Player* FollowerAI::GetLeaderForFollower()
+{
+    if (Player* player = ObjectAccessor::GetPlayer(*me, m_uiLeaderGUID))
+    {
+        if (player->IsAlive())
+            return player;
+        else
+        {
+            if (Group* group = player->GetGroup())
+            {
+                for (GroupReference* groupRef = group->GetFirstMember(); groupRef != NULL; groupRef = groupRef->next())
+                {
+                    Player* member = groupRef->GetSource();
+
+                    if (member && me->IsWithinDistInMap(member, MAX_PLAYER_DISTANCE) && member->IsAlive())
+                    {
+                        ;//sLog->outDebug(LOG_FILTER_TSCR, "TSCR: FollowerAI GetLeader changed and returned new leader.");
+                        m_uiLeaderGUID = member->GetGUID();
+                        return member;
+                    }
+                }
+            }
+        }
+    }
+
+    ;//sLog->outDebug(LOG_FILTER_TSCR, "TSCR: FollowerAI GetLeader can not find suitable leader.");
+    return NULL;
+}
+
+void FollowerAI::SetFollowComplete(bool bWithEndEvent)
+{
+    if (me->HasUnitState(UNIT_STATE_FOLLOW))
+    {
+        me->ClearUnitState(UNIT_STATE_FOLLOW);
+
+        me->StopMoving();
+        me->GetMotionMaster()->Clear();
+        me->GetMotionMaster()->MoveIdle();
+    }
+
+    if (bWithEndEvent)
+        AddFollowState(STATE_FOLLOW_POSTEVENT);
+    else
+    {
+        if (HasFollowState(STATE_FOLLOW_POSTEVENT))
+            RemoveFollowState(STATE_FOLLOW_POSTEVENT);
+    }
+
+    AddFollowState(STATE_FOLLOW_COMPLETE);
+}
+
+void FollowerAI::SetFollowPaused(bool paused)
+{
+    if (!HasFollowState(STATE_FOLLOW_INPROGRESS) || HasFollowState(STATE_FOLLOW_COMPLETE))
+        return;
+
+    if (paused)
+    {
+        AddFollowState(STATE_FOLLOW_PAUSED);
+
+        if (me->HasUnitState(UNIT_STATE_FOLLOW))
+        {
+            me->ClearUnitState(UNIT_STATE_FOLLOW);
+
+            me->StopMoving();
+            me->GetMotionMaster()->Clear();
+            me->GetMotionMaster()->MoveIdle();
+        }
+    }
+    else
+    {
+        RemoveFollowState(STATE_FOLLOW_PAUSED);
+
+        if (Player* leader = GetLeaderForFollower())
+            me->GetMotionMaster()->MoveFollow(leader, PET_FOLLOW_DIST, PET_FOLLOW_ANGLE);
+    }
+}

src/server/game/AI/ScriptedAI/ScriptedFollowerAI.h

@@ -0,0 +1,67 @@
+/* Copyright (C) 2006 - 2009 ScriptDev2 <https://scriptdev2.svn.sourceforge.net/>
+ * This program is free software licensed under GPL version 2
+ * Please see the included DOCS/LICENSE.TXT for more information */
+
+#ifndef SC_FOLLOWERAI_H
+#define SC_FOLLOWERAI_H
+
+#include "ScriptSystem.h"
+
+enum eFollowState
+{
+    STATE_FOLLOW_NONE       = 0x000,
+    STATE_FOLLOW_INPROGRESS = 0x001,                        //must always have this state for any follow
+    STATE_FOLLOW_RETURNING  = 0x002,                        //when returning to combat start after being in combat
+    STATE_FOLLOW_PAUSED     = 0x004,                        //disables following
+    STATE_FOLLOW_COMPLETE   = 0x008,                        //follow is completed and may end
+    STATE_FOLLOW_PREEVENT   = 0x010,                        //not implemented (allow pre event to run, before follow is initiated)
+    STATE_FOLLOW_POSTEVENT  = 0x020                         //can be set at complete and allow post event to run
+};
+
+class FollowerAI : public ScriptedAI
+{
+    public:
+        explicit FollowerAI(Creature* creature);
+        ~FollowerAI() {}
+
+        //virtual void WaypointReached(uint32 uiPointId) = 0;
+
+        void MovementInform(uint32 motionType, uint32 pointId);
+
+        void AttackStart(Unit*);
+
+        void MoveInLineOfSight(Unit*);
+
+        void EnterEvadeMode();
+
+        void JustDied(Unit*);
+
+        void JustRespawned();
+
+        void UpdateAI(uint32);                        //the "internal" update, calls UpdateFollowerAI()
+        virtual void UpdateFollowerAI(uint32);        //used when it's needed to add code in update (abilities, scripted events, etc)
+
+        void StartFollow(Player* player, uint32 factionForFollower = 0, const Quest* quest = NULL);
+
+        void SetFollowPaused(bool bPaused);                 //if special event require follow mode to hold/resume during the follow
+        void SetFollowComplete(bool bWithEndEvent = false);
+
+        bool HasFollowState(uint32 uiFollowState) { return (m_uiFollowState & uiFollowState); }
+
+    protected:
+        Player* GetLeaderForFollower();
+
+    private:
+        void AddFollowState(uint32 uiFollowState) { m_uiFollowState |= uiFollowState; }
+        void RemoveFollowState(uint32 uiFollowState) { m_uiFollowState &= ~uiFollowState; }
+
+        bool AssistPlayerInCombat(Unit* who);
+
+        uint64 m_uiLeaderGUID;
+        uint32 m_uiUpdateFollowTimer;
+        uint32 m_uiFollowState;
+
+        const Quest* m_pQuestForFollow;                     //normally we have a quest
+};
+
+#endif

src/server/game/AI/ScriptedAI/ScriptedGossip.h

@@ -0,0 +1,90 @@
+/* Copyright (C) 
+ *
+ * 
+ *
+ * This program is free software licensed under GPL version 2
+ * Please see the included DOCS/LICENSE.TXT for more information */
+
+#ifndef SC_GOSSIP_H
+#define SC_GOSSIP_H
+
+#include "GossipDef.h"
+#include "QuestDef.h"
+
+// Gossip Item Text
+#define GOSSIP_TEXT_BROWSE_GOODS        "I'd like to browse your goods."
+#define GOSSIP_TEXT_TRAIN               "Train me!"
+
+enum eTradeskill
+{
+    // Skill defines
+    TRADESKILL_ALCHEMY                  = 1,
+    TRADESKILL_BLACKSMITHING            = 2,
+    TRADESKILL_COOKING                  = 3,
+    TRADESKILL_ENCHANTING               = 4,
+    TRADESKILL_ENGINEERING              = 5,
+    TRADESKILL_FIRSTAID                 = 6,
+    TRADESKILL_HERBALISM                = 7,
+    TRADESKILL_LEATHERWORKING           = 8,
+    TRADESKILL_POISONS                  = 9,
+    TRADESKILL_TAILORING                = 10,
+    TRADESKILL_MINING                   = 11,
+    TRADESKILL_FISHING                  = 12,
+    TRADESKILL_SKINNING                 = 13,
+    TRADESKILL_JEWLCRAFTING             = 14,
+    TRADESKILL_INSCRIPTION              = 15,
+
+    TRADESKILL_LEVEL_NONE               = 0,
+    TRADESKILL_LEVEL_APPRENTICE         = 1,
+    TRADESKILL_LEVEL_JOURNEYMAN         = 2,
+    TRADESKILL_LEVEL_EXPERT             = 3,
+    TRADESKILL_LEVEL_ARTISAN            = 4,
+    TRADESKILL_LEVEL_MASTER             = 5,
+    TRADESKILL_LEVEL_GRAND_MASTER       = 6,
+
+    // Gossip defines
+    GOSSIP_ACTION_TRADE                 = 1,
+    GOSSIP_ACTION_TRAIN                 = 2,
+    GOSSIP_ACTION_TAXI                  = 3,
+    GOSSIP_ACTION_GUILD                 = 4,
+    GOSSIP_ACTION_BATTLE                = 5,
+    GOSSIP_ACTION_BANK                  = 6,
+    GOSSIP_ACTION_INN                   = 7,
+    GOSSIP_ACTION_HEAL                  = 8,
+    GOSSIP_ACTION_TABARD                = 9,
+    GOSSIP_ACTION_AUCTION               = 10,
+    GOSSIP_ACTION_INN_INFO              = 11,
+    GOSSIP_ACTION_UNLEARN               = 12,
+    GOSSIP_ACTION_INFO_DEF              = 1000,
+
+    GOSSIP_SENDER_MAIN                  = 1,
+    GOSSIP_SENDER_INN_INFO              = 2,
+    GOSSIP_SENDER_INFO                  = 3,
+    GOSSIP_SENDER_SEC_PROFTRAIN         = 4,
+    GOSSIP_SENDER_SEC_CLASSTRAIN        = 5,
+    GOSSIP_SENDER_SEC_BATTLEINFO        = 6,
+    GOSSIP_SENDER_SEC_BANK              = 7,
+    GOSSIP_SENDER_SEC_INN               = 8,
+    GOSSIP_SENDER_SEC_MAILBOX           = 9,
+    GOSSIP_SENDER_SEC_STABLEMASTER      = 10
+};
+
+// Defined fuctions to use with player.
+
+// This fuction add's a menu item,
+// a - Icon Id
+// b - Text
+// c - Sender(this is to identify the current Menu with this item)
+// d - Action (identifys this Menu Item)
+// e - Text to be displayed in pop up box
+// f - Money value in pop up box
+#define ADD_GOSSIP_ITEM(a, b, c, d)   PlayerTalkClass->GetGossipMenu().AddMenuItem(-1, a, b, c, d, "", 0)
+#define ADD_GOSSIP_ITEM_EXTENDED(a, b, c, d, e, f, g)   PlayerTalkClass->GetGossipMenu().AddMenuItem(-1, a, b, c, d, e, f, g)
+
+// This fuction Sends the current menu to show to client, a - NPCTEXTID(uint32), b - npc guid(uint64)
+#define SEND_GOSSIP_MENU(a, b)      PlayerTalkClass->SendGossipMenu(a, b)
+
+// Closes the Menu
+#define CLOSE_GOSSIP_MENU()        PlayerTalkClass->SendCloseGossip()
+
+#endif

src/server/game/AI/SmartScripts/SmartAI.h

@@ -0,0 +1,274 @@
+/*
+ * Copyright (C) 
+ *
+ * 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef TRINITY_SMARTAI_H
+#define TRINITY_SMARTAI_H
+
+#include "Common.h"
+#include "Creature.h"
+#include "CreatureAI.h"
+#include "Unit.h"
+#include "Spell.h"
+
+#include "SmartScript.h"
+#include "SmartScriptMgr.h"
+#include "GameObjectAI.h"
+
+enum SmartEscortState
+{
+    SMART_ESCORT_NONE       = 0x000,                        //nothing in progress
+    SMART_ESCORT_ESCORTING  = 0x001,                        //escort is in progress
+    SMART_ESCORT_RETURNING  = 0x002,                        //escort is returning after being in combat
+    SMART_ESCORT_PAUSED     = 0x004                         //will not proceed with waypoints before state is removed
+};
+
+enum SmartEscortVars
+{
+    SMART_ESCORT_MAX_PLAYER_DIST        = 60,
+    SMART_MAX_AID_DIST					= SMART_ESCORT_MAX_PLAYER_DIST / 2,
+};
+
+class SmartAI : public CreatureAI
+{
+    public:
+        ~SmartAI(){};
+        explicit SmartAI(Creature* c);
+
+        // Start moving to the desired MovePoint
+        void StartPath(bool run = false, uint32 path = 0, bool repeat = false, Unit* invoker = NULL);
+        bool LoadPath(uint32 entry);
+        void PausePath(uint32 delay, bool forced = false);
+        void StopPath(uint32 DespawnTime = 0, uint32 quest = 0, bool fail = false);
+        void EndPath(bool fail = false);
+        void ResumePath();
+        WayPoint* GetNextWayPoint();
+        void GenerateWayPointArray(Movement::PointsArray* points);
+        bool HasEscortState(uint32 uiEscortState) { return (mEscortState & uiEscortState); }
+        void AddEscortState(uint32 uiEscortState) { mEscortState |= uiEscortState; }
+		virtual bool IsEscorted() { return (mEscortState & SMART_ESCORT_ESCORTING); }
+        void RemoveEscortState(uint32 uiEscortState) { mEscortState &= ~uiEscortState; }
+        void SetAutoAttack(bool on) { mCanAutoAttack = on; }
+        void SetCombatMove(bool on);
+		bool CanCombatMove() { return mCanCombatMove; }
+        void SetFollow(Unit* target, float dist = 0.0f, float angle = 0.0f, uint32 credit = 0, uint32 end = 0, uint32 creditType = 0, bool aliveState = true);
+        void StopFollow(bool complete);
+
+        void SetScript9(SmartScriptHolder& e, uint32 entry, Unit* invoker);
+        SmartScript* GetScript() { return &mScript; }
+        bool IsEscortInvokerInRange();
+
+        // Called when creature is spawned or respawned
+        void JustRespawned();
+
+        // Called at reaching home after evade, InitializeAI(), EnterEvadeMode() for resetting variables
+        void JustReachedHome();
+
+        // Called for reaction at enter to combat if not in combat yet (enemy can be NULL)
+        void EnterCombat(Unit* enemy);
+
+        // Called for reaction at stopping attack at no attackers or targets
+        void EnterEvadeMode();
+
+        // Called when the creature is killed
+        void JustDied(Unit* killer);
+
+        // Called when the creature kills a unit
+        void KilledUnit(Unit* victim);
+
+        // Called when the creature summon successfully other creature
+        void JustSummoned(Creature* creature);
+
+        // Tell creature to attack and follow the victim
+        void AttackStart(Unit* who);
+
+        // Called if IsVisible(Unit* who) is true at each *who move, reaction at visibility zone enter
+        void MoveInLineOfSight(Unit* who);
+
+        // Called when hit by a spell
+        void SpellHit(Unit* unit, const SpellInfo* spellInfo);
+
+        // Called when spell hits a target
+        void SpellHitTarget(Unit* target, const SpellInfo* spellInfo);
+
+        // Called at any Damage from any attacker (before damage apply)
+        void DamageTaken(Unit* done_by, uint32 &damage, DamageEffectType damagetype, SpellSchoolMask damageSchoolMask);
+
+        // Called when the creature receives heal
+        void HealReceived(Unit* doneBy, uint32& addhealth);
+
+        // Called at World update tick
+        void UpdateAI(uint32 diff);
+
+        // Called at text emote receive from player
+        void ReceiveEmote(Player* player, uint32 textEmote);
+
+        // Called at waypoint reached or point movement finished
+        void MovementInform(uint32 MovementType, uint32 Data);
+
+        // Called when creature is summoned by another unit
+        void IsSummonedBy(Unit* summoner);
+
+        // Called at any Damage to any victim (before damage apply)
+        void DamageDealt(Unit* doneTo, uint32& damage, DamageEffectType damagetyp);
+
+        // Called when a summoned creature dissapears (UnSommoned)
+        void SummonedCreatureDespawn(Creature* unit);
+
+        // called when the corpse of this creature gets removed
+        void CorpseRemoved(uint32& respawnDelay);
+
+        // Called at World update tick if creature is charmed
+        void UpdateAIWhileCharmed(const uint32 diff);
+
+        // Called when a Player/Creature enters the creature (vehicle)
+        void PassengerBoarded(Unit* who, int8 seatId, bool apply);
+
+        // Called when gets initialized, when creature is added to world
+        void InitializeAI();
+
+        // Called when creature gets charmed by another unit
+        void OnCharmed(bool apply);
+
+        // Called when victim is in line of sight
+        bool CanAIAttack(const Unit* who) const;
+
+        // Used in scripts to share variables
+        void DoAction(int32 param = 0);
+
+        // Used in scripts to share variables
+        uint32 GetData(uint32 id = 0) const;
+
+        // Used in scripts to share variables
+        void SetData(uint32 id, uint32 value);
+
+        // Used in scripts to share variables
+        void SetGUID(uint64 guid, int32 id = 0);
+
+        // Used in scripts to share variables
+        uint64 GetGUID(int32 id = 0) const;
+
+        //core related
+        static int32 Permissible(const Creature*);
+
+        // Called at movepoint reached
+        void MovepointReached(uint32 id);
+
+        // Makes the creature run/walk
+        void SetRun(bool run = true);
+
+        void SetFly(bool fly = true);
+
+        void SetSwim(bool swim = true);
+
+        void SetInvincibilityHpLevel(uint32 level) { mInvincibilityHpLevel = level; }
+
+        void sGossipHello(Player* player);
+        void sGossipSelect(Player* player, uint32 sender, uint32 action);
+        void sGossipSelectCode(Player* player, uint32 sender, uint32 action, const char* code);
+        void sQuestAccept(Player* player, Quest const* quest);
+        //void sQuestSelect(Player* player, Quest const* quest);
+        //void sQuestComplete(Player* player, Quest const* quest);
+        void sQuestReward(Player* player, Quest const* quest, uint32 opt);
+        void sOnGameEvent(bool start, uint16 eventId);
+
+        uint32 mEscortQuestID;
+
+        void SetDespawnTime (uint32 t)
+        {
+            mDespawnTime = t;
+            mDespawnState = t ? 1 : 0;
+        }
+        void StartDespawn() { mDespawnState = 2; }
+
+        void OnSpellClick(Unit* clicker, bool& result);
+
+		// Xinef
+		void SetWPPauseTimer(uint32 time) { mWPPauseTimer = time; }
+		void SetForcedCombatMove(float dist);
+
+    private:
+        uint32 mFollowCreditType;
+        uint32 mFollowArrivedTimer;
+        uint32 mFollowCredit;
+        uint32 mFollowArrivedEntry;
+		bool   mFollowArrivedAlive;
+        uint64 mFollowGuid;
+        float mFollowDist;
+        float mFollowAngle;
+
+        void ReturnToLastOOCPos();
+        void UpdatePath(const uint32 diff);
+        SmartScript mScript;
+        WPPath* mWayPoints;
+        uint32 mEscortState;
+        uint32 mCurrentWPID;
+        bool mWPReached;
+		bool mOOCReached;
+        uint32 mWPPauseTimer;
+        WayPoint* mLastWP;
+        uint32 mEscortNPCFlags;
+        uint32 GetWPCount() { return mWayPoints ? mWayPoints->size() : 0; }
+        bool mCanRepeatPath;
+        bool mRun;
+        bool mCanAutoAttack;
+        bool mCanCombatMove;
+        bool mForcedPaused;
+        uint32 mInvincibilityHpLevel;
+
+        bool AssistPlayerInCombat(Unit* who);
+
+        uint32 mDespawnTime;
+        uint32 mDespawnState;
+        void UpdateDespawn(const uint32 diff);
+        uint32 mEscortInvokerCheckTimer;
+        bool mJustReset;
+
+		// Xinef: Vehicle conditions
+        void CheckConditions(const uint32 diff);
+        ConditionList conditions;
+        uint32 m_ConditionsTimer;
+};
+
+class SmartGameObjectAI : public GameObjectAI
+{
+    public:
+        SmartGameObjectAI(GameObject* g) : GameObjectAI(g) {}
+        ~SmartGameObjectAI() {}
+
+        void UpdateAI(uint32 diff);
+        void InitializeAI();
+        void Reset();
+        SmartScript* GetScript() { return &mScript; }
+        static int32 Permissible(const GameObject* g);
+
+        bool GossipHello(Player* player, bool reportUse);
+        bool GossipSelect(Player* player, uint32 sender, uint32 action);
+        bool GossipSelectCode(Player* /*player*/, uint32 /*sender*/, uint32 /*action*/, const char* /*code*/);
+        bool QuestAccept(Player* player, Quest const* quest);
+        bool QuestReward(Player* player, Quest const* quest, uint32 opt);
+        void Destroyed(Player* player, uint32 eventId);
+        void SetData(uint32 id, uint32 value);
+        void SetScript9(SmartScriptHolder& e, uint32 entry, Unit* invoker);
+        void OnGameEvent(bool start, uint16 eventId);
+        void OnStateChanged(uint32 state, Unit* unit);
+        void EventInform(uint32 eventId);
+		void SpellHit(Unit* unit, const SpellInfo* spellInfo);
+
+    protected:
+        SmartScript mScript;
+};
+#endif

src/server/game/AI/SmartScripts/SmartScript.h

@@ -0,0 +1,343 @@
+/*
+ * Copyright (C) 
+ *
+ * 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef TRINITY_SMARTSCRIPT_H
+#define TRINITY_SMARTSCRIPT_H
+
+#include "Common.h"
+#include "Creature.h"
+#include "CreatureAI.h"
+#include "Unit.h"
+#include "Spell.h"
+#include "GridNotifiers.h"
+
+#include "SmartScriptMgr.h"
+//#include "SmartAI.h"
+
+class SmartScript
+{
+    public:
+        SmartScript();
+        ~SmartScript();
+
+        void OnInitialize(WorldObject* obj, AreaTriggerEntry const* at = NULL);
+        void GetScript();
+        void FillScript(SmartAIEventList e, WorldObject* obj, AreaTriggerEntry const* at);
+
+        void ProcessEventsFor(SMART_EVENT e, Unit* unit = NULL, uint32 var0 = 0, uint32 var1 = 0, bool bvar = false, const SpellInfo* spell = NULL, GameObject* gob = NULL);
+        void ProcessEvent(SmartScriptHolder& e, Unit* unit = NULL, uint32 var0 = 0, uint32 var1 = 0, bool bvar = false, const SpellInfo* spell = NULL, GameObject* gob = NULL);
+        bool CheckTimer(SmartScriptHolder const& e) const;
+        void RecalcTimer(SmartScriptHolder& e, uint32 min, uint32 max);
+        void UpdateTimer(SmartScriptHolder& e, uint32 const diff);
+        void InitTimer(SmartScriptHolder& e);
+        void ProcessAction(SmartScriptHolder& e, Unit* unit = NULL, uint32 var0 = 0, uint32 var1 = 0, bool bvar = false, const SpellInfo* spell = NULL, GameObject* gob = NULL);
+        void ProcessTimedAction(SmartScriptHolder& e, uint32 const& min, uint32 const& max, Unit* unit = NULL, uint32 var0 = 0, uint32 var1 = 0, bool bvar = false, const SpellInfo* spell = NULL, GameObject* gob = NULL);
+        ObjectList* GetTargets(SmartScriptHolder const& e, Unit* invoker = NULL);
+        ObjectList* GetWorldObjectsInDist(float dist);
+        void InstallTemplate(SmartScriptHolder const& e);
+        SmartScriptHolder CreateEvent(SMART_EVENT e, uint32 event_flags, uint32 event_param1, uint32 event_param2, uint32 event_param3, uint32 event_param4, SMART_ACTION action, uint32 action_param1, uint32 action_param2, uint32 action_param3, uint32 action_param4, uint32 action_param5, uint32 action_param6, SMARTAI_TARGETS t, uint32 target_param1, uint32 target_param2, uint32 target_param3, uint32 phaseMask = 0);
+        void AddEvent(SMART_EVENT e, uint32 event_flags, uint32 event_param1, uint32 event_param2, uint32 event_param3, uint32 event_param4, SMART_ACTION action, uint32 action_param1, uint32 action_param2, uint32 action_param3, uint32 action_param4, uint32 action_param5, uint32 action_param6, SMARTAI_TARGETS t, uint32 target_param1, uint32 target_param2, uint32 target_param3, uint32 phaseMask = 0);
+        void SetPathId(uint32 id) { mPathId = id; }
+        uint32 GetPathId() const { return mPathId; }
+        WorldObject* GetBaseObject()
+        {
+            WorldObject* obj = NULL;
+            if (me)
+                obj = me;
+            else if (go)
+                obj = go;
+            return obj;
+        }
+
+        bool IsUnit(WorldObject* obj)
+        {
+            return obj && obj->IsInWorld() && (obj->GetTypeId() == TYPEID_UNIT || obj->GetTypeId() == TYPEID_PLAYER);
+        }
+
+        bool IsPlayer(WorldObject* obj)
+        {
+            return obj && obj->IsInWorld() && obj->GetTypeId() == TYPEID_PLAYER;
+        }
+
+        bool IsCreature(WorldObject* obj)
+        {
+            return obj && obj->IsInWorld() && obj->GetTypeId() == TYPEID_UNIT;
+        }
+
+        bool IsGameObject(WorldObject* obj)
+        {
+            return obj && obj->IsInWorld() && obj->GetTypeId() == TYPEID_GAMEOBJECT;
+        }
+
+        void OnUpdate(const uint32 diff);
+        void OnMoveInLineOfSight(Unit* who);
+
+        Unit* DoSelectLowestHpFriendly(float range, uint32 MinHPDiff);
+        void DoFindFriendlyCC(std::list<Creature*>& _list, float range);
+        void DoFindFriendlyMissingBuff(std::list<Creature*>& list, float range, uint32 spellid);
+        Unit* DoFindClosestFriendlyInRange(float range, bool playerOnly);
+
+        void StoreTargetList(ObjectList* targets, uint32 id)
+        {
+            if (!targets)
+                return;
+
+            if (mTargetStorage->find(id) != mTargetStorage->end())
+            {
+                // check if already stored
+                if ((*mTargetStorage)[id]->Equals(targets))
+                    return;
+
+                delete (*mTargetStorage)[id];
+            }
+
+            (*mTargetStorage)[id] = new ObjectGuidList(targets, GetBaseObject());
+        }
+
+        bool IsSmart(Creature* c = NULL)
+        {
+            bool smart = true;
+            if (c && c->GetAIName() != "SmartAI")
+                smart = false;
+
+            if (!me || me->GetAIName() != "SmartAI")
+                smart = false;
+
+            if (!smart)
+                sLog->outErrorDb("SmartScript: Action target Creature(entry: %u) is not using SmartAI, action skipped to prevent crash.", c ? c->GetEntry() : (me ? me->GetEntry() : 0));
+
+            return smart;
+        }
+
+        bool IsSmartGO(GameObject* g = NULL)
+        {
+            bool smart = true;
+            if (g && g->GetAIName() != "SmartGameObjectAI")
+                smart = false;
+
+            if (!go || go->GetAIName() != "SmartGameObjectAI")
+                smart = false;
+            if (!smart)
+                sLog->outErrorDb("SmartScript: Action target GameObject(entry: %u) is not using SmartGameObjectAI, action skipped to prevent crash.", g ? g->GetEntry() : (go ? go->GetEntry() : 0));
+
+            return smart;
+        }
+
+        ObjectList* GetTargetList(uint32 id)
+        {
+            ObjectListMap::iterator itr = mTargetStorage->find(id);
+            if (itr != mTargetStorage->end())
+                return (*itr).second->GetObjectList();
+            return NULL;
+        }
+
+        void StoreCounter(uint32 id, uint32 value, uint32 reset)
+        {
+            CounterMap::iterator itr = mCounterList.find(id);
+            if (itr != mCounterList.end())
+            {
+                if (reset == 0)
+                    itr->second += value;
+				else
+					itr->second = value;
+            }
+			else
+				mCounterList.insert(std::make_pair(id, value));
+
+            ProcessEventsFor(SMART_EVENT_COUNTER_SET, NULL, id);
+        }
+
+        uint32 GetCounterValue(uint32 id)
+        {
+            CounterMap::iterator itr = mCounterList.find(id);
+            if (itr != mCounterList.end())
+                return itr->second;
+            return 0;
+        }
+
+        GameObject* FindGameObjectNear(WorldObject* searchObject, uint32 guid) const
+        {
+            GameObject* gameObject = NULL;
+
+            CellCoord p(Trinity::ComputeCellCoord(searchObject->GetPositionX(), searchObject->GetPositionY()));
+            Cell cell(p);
+
+            Trinity::GameObjectWithDbGUIDCheck goCheck(*searchObject, guid);
+            Trinity::GameObjectSearcher<Trinity::GameObjectWithDbGUIDCheck> checker(searchObject, gameObject, goCheck);
+
+            TypeContainerVisitor<Trinity::GameObjectSearcher<Trinity::GameObjectWithDbGUIDCheck>, GridTypeMapContainer > objectChecker(checker);
+            cell.Visit(p, objectChecker, *searchObject->GetMap(), *searchObject, searchObject->GetVisibilityRange());
+
+            return gameObject;
+        }
+
+        Creature* FindCreatureNear(WorldObject* searchObject, uint32 guid) const
+        {
+            Creature* creature = NULL;
+            CellCoord p(Trinity::ComputeCellCoord(searchObject->GetPositionX(), searchObject->GetPositionY()));
+            Cell cell(p);
+
+            Trinity::CreatureWithDbGUIDCheck target_check(searchObject, guid);
+            Trinity::CreatureSearcher<Trinity::CreatureWithDbGUIDCheck> checker(searchObject, creature, target_check);
+
+            TypeContainerVisitor<Trinity::CreatureSearcher <Trinity::CreatureWithDbGUIDCheck>, GridTypeMapContainer > unit_checker(checker);
+            cell.Visit(p, unit_checker, *searchObject->GetMap(), *searchObject, searchObject->GetVisibilityRange());
+
+            return creature;
+        }
+
+        ObjectListMap* mTargetStorage;
+
+        void OnReset();
+        void ResetBaseObject()
+        {
+            if (meOrigGUID)
+            {
+                if (Creature* m = HashMapHolder<Creature>::Find(meOrigGUID))
+                {
+                    me = m;
+                    go = NULL;
+                }
+            }
+            if (goOrigGUID)
+            {
+                if (GameObject* o = HashMapHolder<GameObject>::Find(goOrigGUID))
+                {
+                    me = NULL;
+                    go = o;
+                }
+            }
+            goOrigGUID = 0;
+            meOrigGUID = 0;
+        }
+
+        //TIMED_ACTIONLIST (script type 9 aka script9)
+        void SetScript9(SmartScriptHolder& e, uint32 entry);
+        Unit* GetLastInvoker(Unit* invoker = NULL);
+        uint64 mLastInvoker;
+        typedef UNORDERED_MAP<uint32, uint32> CounterMap;
+        CounterMap mCounterList;
+
+		// Xinef: Fix Combat Movement
+		void SetActualCombatDist(uint32 dist) { mActualCombatDist = dist; }
+		void RestoreMaxCombatDist() { mActualCombatDist = mMaxCombatDist; }
+		uint32 GetActualCombatDist() const { return mActualCombatDist; }
+		uint32 GetMaxCombatDist() const { return mMaxCombatDist; }
+
+		// Xinef: SmartCasterAI, replace above
+		void SetCasterActualDist(float dist) { smartCasterActualDist = dist; }
+		void RestoreCasterMaxDist() { smartCasterActualDist = smartCasterMaxDist; }
+		Powers GetCasterPowerType() const { return smartCasterPowerType; }
+		float GetCasterActualDist() const { return smartCasterActualDist; }
+		float GetCasterMaxDist() const { return smartCasterMaxDist; }
+
+		bool AllowPhaseReset() const { return _allowPhaseReset; }
+		void SetPhaseReset(bool allow) { _allowPhaseReset = allow; }
+
+    private:
+        void IncPhase(uint32 p)
+		{
+			// Xinef: protect phase from overflowing
+			mEventPhase = std::min<uint32>(SMART_EVENT_PHASE_12, mEventPhase + p);
+		}
+
+        void DecPhase(uint32 p) 
+		{
+			if (p >= mEventPhase)
+				mEventPhase = 0;
+			else
+				mEventPhase -= p;
+		}
+        bool IsInPhase(uint32 p) const 
+		{ 
+			if (mEventPhase == 0)
+				return false;
+			return (1 << (mEventPhase - 1)) & p;
+		}
+        void SetPhase(uint32 p = 0) { mEventPhase = p; }
+
+        SmartAIEventList mEvents;
+        SmartAIEventList mInstallEvents;
+        SmartAIEventList mTimedActionList;
+        bool isProcessingTimedActionList;
+        Creature* me;
+        uint64 meOrigGUID;
+        GameObject* go;
+        uint64 goOrigGUID;
+        AreaTriggerEntry const* trigger;
+        SmartScriptType mScriptType;
+        uint32 mEventPhase;
+
+        UNORDERED_MAP<int32, int32> mStoredDecimals;
+        uint32 mPathId;
+        SmartAIEventStoredList mStoredEvents;
+        std::list<uint32> mRemIDs;
+
+        uint32 mTextTimer;
+        uint32 mLastTextID;
+        uint32 mTalkerEntry;
+        bool mUseTextTimer;
+
+		// Xinef: Fix Combat Movement
+		uint32 mActualCombatDist;
+		uint32 mMaxCombatDist;
+
+		// Xinef: SmartCasterAI, replace above in future
+		uint32 smartCasterActualDist;
+		uint32 smartCasterMaxDist;
+		Powers smartCasterPowerType;
+
+		// Xinef: misc
+		bool _allowPhaseReset;
+
+        SMARTAI_TEMPLATE mTemplate;
+        void InstallEvents();
+
+        void RemoveStoredEvent (uint32 id)
+        {
+            if (!mStoredEvents.empty())
+            {
+                for (SmartAIEventStoredList::iterator i = mStoredEvents.begin(); i != mStoredEvents.end(); ++i)
+                {
+                    if (i->event_id == id)
+                    {
+                        mStoredEvents.erase(i);
+                        return;
+                    }
+
+                }
+            }
+        }
+        SmartScriptHolder FindLinkedEvent (uint32 link)
+        {
+            if (!mEvents.empty())
+            {
+                for (SmartAIEventList::iterator i = mEvents.begin(); i != mEvents.end(); ++i)
+                {
+                    if (i->event_id == link)
+                    {
+                        return (*i);
+                    }
+
+                }
+            }
+            SmartScriptHolder s;
+            return s;
+        }
+};
+
+#endif

src/server/game/Accounts/AccountMgr.cpp

@@ -0,0 +1,151 @@
+/*
+ * Copyright (C) 
+ * Copyright (C) 
+ *
+ * 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "AccountMgr.h"
+#include "DatabaseEnv.h"
+#include "ObjectAccessor.h"
+#include "Player.h"
+#include "Util.h"
+#include "SHA1.h"
+#include "WorldSession.h"
+
+namespace AccountMgr
+{
+
+uint32 GetId(std::string const& username)
+{
+    PreparedStatement* stmt = LoginDatabase.GetPreparedStatement(LOGIN_GET_ACCOUNT_ID_BY_USERNAME);
+    stmt->setString(0, username);
+    PreparedQueryResult result = LoginDatabase.Query(stmt);
+
+    return (result) ? (*result)[0].GetUInt32() : 0;
+}
+
+uint32 GetSecurity(uint32 accountId)
+{
+    PreparedStatement* stmt = LoginDatabase.GetPreparedStatement(LOGIN_GET_ACCOUNT_ACCESS_GMLEVEL);
+    stmt->setUInt32(0, accountId);
+    PreparedQueryResult result = LoginDatabase.Query(stmt);
+
+    return (result) ? (*result)[0].GetUInt8() : uint32(SEC_PLAYER);
+}
+
+uint32 GetSecurity(uint32 accountId, int32 realmId)
+{
+    PreparedStatement* stmt = LoginDatabase.GetPreparedStatement(LOGIN_GET_GMLEVEL_BY_REALMID);
+    stmt->setUInt32(0, accountId);
+    stmt->setInt32(1, realmId);
+    PreparedQueryResult result = LoginDatabase.Query(stmt);
+
+    return (result) ? (*result)[0].GetUInt8() : uint32(SEC_PLAYER);
+}
+
+bool GetName(uint32 accountId, std::string& name)
+{
+    PreparedStatement* stmt = LoginDatabase.GetPreparedStatement(LOGIN_GET_USERNAME_BY_ID);
+    stmt->setUInt32(0, accountId);
+    PreparedQueryResult result = LoginDatabase.Query(stmt);
+
+    if (result)
+    {
+        name = (*result)[0].GetString();
+        return true;
+    }
+
+    return false;
+}
+
+bool CheckPassword(uint32 accountId, std::string password)
+{
+    std::string username;
+
+    if (!GetName(accountId, username))
+        return false;
+
+    normalizeString(username);
+    normalizeString(password);
+
+    PreparedStatement* stmt = LoginDatabase.GetPreparedStatement(LOGIN_SEL_CHECK_PASSWORD);
+    stmt->setUInt32(0, accountId);
+    stmt->setString(1, CalculateShaPassHash(username, password));
+    PreparedQueryResult result = LoginDatabase.Query(stmt);
+
+    return (result) ? true : false;
+}
+
+uint32 GetCharactersCount(uint32 accountId)
+{
+    // check character count
+    PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_SUM_CHARS);
+    stmt->setUInt32(0, accountId);
+    PreparedQueryResult result = CharacterDatabase.Query(stmt);
+
+    return (result) ? (*result)[0].GetUInt64() : 0;
+}
+
+bool normalizeString(std::string& utf8String)
+{
+    wchar_t buffer[MAX_ACCOUNT_STR+1];
+
+    size_t maxLength = MAX_ACCOUNT_STR;
+    if (!Utf8toWStr(utf8String, buffer, maxLength))
+        return false;
+#ifdef _MSC_VER
+#pragma warning(disable: 4996)
+#endif
+    std::transform(&buffer[0], buffer+maxLength, &buffer[0], wcharToUpperOnlyLatin);
+#ifdef _MSC_VER
+#pragma warning(default: 4996)
+#endif
+
+    return WStrToUtf8(buffer, maxLength, utf8String);
+}
+
+std::string CalculateShaPassHash(std::string const& name, std::string const& password)
+{
+    SHA1Hash sha;
+    sha.Initialize();
+    sha.UpdateData(name);
+    sha.UpdateData(":");
+    sha.UpdateData(password);
+    sha.Finalize();
+
+    return ByteArrayToHexStr(sha.GetDigest(), sha.GetLength());
+}
+
+bool IsPlayerAccount(uint32 gmlevel)
+{
+    return gmlevel == SEC_PLAYER;
+}
+
+bool IsGMAccount(uint32 gmlevel)
+{
+    return gmlevel >= SEC_GAMEMASTER && gmlevel <= SEC_CONSOLE;
+}
+
+bool IsAdminAccount(uint32 gmlevel)
+{
+    return gmlevel >= SEC_ADMINISTRATOR && gmlevel <= SEC_CONSOLE;
+}
+
+bool IsConsoleAccount(uint32 gmlevel)
+{
+    return gmlevel == SEC_CONSOLE;
+}
+
+} // Namespace AccountMgr

src/server/game/Accounts/AccountMgr.h

@@ -0,0 +1,55 @@
+/*
+ * Copyright (C) 
+ * Copyright (C) 
+ *
+ * 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef _ACCMGR_H
+#define _ACCMGR_H
+
+#include "Define.h"
+#include <string>
+
+enum AccountOpResult
+{
+    AOR_OK,
+    AOR_NAME_TOO_LONG,
+    AOR_PASS_TOO_LONG,
+    AOR_NAME_ALREDY_EXIST,
+    AOR_NAME_NOT_EXIST,
+    AOR_DB_INTERNAL_ERROR
+};
+
+#define MAX_ACCOUNT_STR 20
+
+namespace AccountMgr
+{
+    bool CheckPassword(uint32 accountId, std::string password);
+
+    uint32 GetId(std::string const& username);
+    uint32 GetSecurity(uint32 accountId);
+    uint32 GetSecurity(uint32 accountId, int32 realmId);
+    bool GetName(uint32 accountId, std::string& name);
+    uint32 GetCharactersCount(uint32 accountId);
+    std::string CalculateShaPassHash(std::string const& name, std::string const& password);
+
+    bool normalizeString(std::string& utf8String);
+    bool IsPlayerAccount(uint32 gmlevel);
+    bool IsGMAccount(uint32 gmlevel);
+    bool IsAdminAccount(uint32 gmlevel);
+    bool IsConsoleAccount(uint32 gmlevel);
+};
+
+#endif

src/server/game/Achievements/AchievementMgr.h

@@ -0,0 +1,403 @@
+/*
+ * Copyright (C) 
+ * Copyright (C) 
+ *
+ * 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, see <http://www.gnu.org/licenses/>.
+ */
+#ifndef __TRINITY_ACHIEVEMENTMGR_H
+#define __TRINITY_ACHIEVEMENTMGR_H
+
+#include <map>
+#include <string>
+
+#include "Common.h"
+#include <ace/Singleton.h>
+#include "DatabaseEnv.h"
+#include "DBCEnums.h"
+#include "DBCStores.h"
+
+typedef std::list<AchievementCriteriaEntry const*> AchievementCriteriaEntryList;
+typedef std::list<AchievementEntry const*>         AchievementEntryList;
+
+typedef UNORDERED_MAP<uint32, AchievementCriteriaEntryList> AchievementCriteriaListByAchievement;
+typedef std::map<uint32, AchievementEntryList>         AchievementListByReferencedId;
+
+struct CriteriaProgress
+{
+    uint32 counter;
+    time_t date;                                            // latest update time.
+    bool changed;
+};
+
+enum AchievementCriteriaDataType
+{                                                           // value1         value2        comment
+    ACHIEVEMENT_CRITERIA_DATA_TYPE_NONE                = 0, // 0              0
+    ACHIEVEMENT_CRITERIA_DATA_TYPE_T_CREATURE          = 1, // creature_id    0
+    ACHIEVEMENT_CRITERIA_DATA_TYPE_T_PLAYER_CLASS_RACE = 2, // class_id       race_id
+    ACHIEVEMENT_CRITERIA_DATA_TYPE_T_PLAYER_LESS_HEALTH= 3, // health_percent 0
+    ACHIEVEMENT_CRITERIA_DATA_TYPE_T_PLAYER_DEAD       = 4, // own_team       0             not corpse (not released body), own_team == false if enemy team expected
+    ACHIEVEMENT_CRITERIA_DATA_TYPE_S_AURA              = 5, // spell_id       effect_idx
+    ACHIEVEMENT_CRITERIA_DATA_TYPE_S_AREA              = 6, // area id        0
+    ACHIEVEMENT_CRITERIA_DATA_TYPE_T_AURA              = 7, // spell_id       effect_idx
+    ACHIEVEMENT_CRITERIA_DATA_TYPE_VALUE               = 8, // minvalue                     value provided with achievement update must be not less that limit
+    ACHIEVEMENT_CRITERIA_DATA_TYPE_T_LEVEL             = 9, // minlevel                     minlevel of target
+    ACHIEVEMENT_CRITERIA_DATA_TYPE_T_GENDER            = 10, // gender                       0=male; 1=female
+    ACHIEVEMENT_CRITERIA_DATA_TYPE_SCRIPT              = 11, // scripted requirement
+    ACHIEVEMENT_CRITERIA_DATA_TYPE_MAP_DIFFICULTY      = 12, // difficulty                   normal/heroic difficulty for current event map
+    ACHIEVEMENT_CRITERIA_DATA_TYPE_MAP_PLAYER_COUNT    = 13, // count                        "with less than %u people in the zone"
+    ACHIEVEMENT_CRITERIA_DATA_TYPE_T_TEAM              = 14, // team                         HORDE(67), ALLIANCE(469)
+    ACHIEVEMENT_CRITERIA_DATA_TYPE_S_DRUNK             = 15, // drunken_state  0             (enum DrunkenState) of player
+    ACHIEVEMENT_CRITERIA_DATA_TYPE_HOLIDAY             = 16, // holiday_id     0             event in holiday time
+    ACHIEVEMENT_CRITERIA_DATA_TYPE_BG_LOSS_TEAM_SCORE  = 17, // min_score      max_score     player's team win bg and opposition team have team score in range
+    ACHIEVEMENT_CRITERIA_DATA_TYPE_INSTANCE_SCRIPT     = 18, // 0              0             maker instance script call for check current criteria requirements fit
+    ACHIEVEMENT_CRITERIA_DATA_TYPE_S_EQUIPED_ITEM      = 19, // item_level     item_quality  for equipped item in slot to check item level and quality
+    ACHIEVEMENT_CRITERIA_DATA_TYPE_MAP_ID              = 20, // map_id         0             player must be on map with id in map_id
+    ACHIEVEMENT_CRITERIA_DATA_TYPE_S_PLAYER_CLASS_RACE = 21, // class_id       race_id
+    ACHIEVEMENT_CRITERIA_DATA_TYPE_NTH_BIRTHDAY        = 22, // N                            login on day of N-th Birthday
+    ACHIEVEMENT_CRITERIA_DATA_TYPE_S_KNOWN_TITLE       = 23  // title_id                     known (pvp) title, values from dbc
+};
+
+#define MAX_ACHIEVEMENT_CRITERIA_DATA_TYPE               24 // maximum value in AchievementCriteriaDataType enum
+
+class Player;
+class Unit;
+
+struct AchievementCriteriaData
+{
+    AchievementCriteriaDataType dataType;
+    union
+    {
+        // ACHIEVEMENT_CRITERIA_DATA_TYPE_NONE              = 0 (no data)
+        // ACHIEVEMENT_CRITERIA_DATA_TYPE_T_CREATURE        = 1
+        struct
+        {
+            uint32 id;
+        } creature;
+        // ACHIEVEMENT_CRITERIA_DATA_TYPE_T_PLAYER_CLASS_RACE = 2
+        // ACHIEVEMENT_CRITERIA_DATA_TYPE_S_PLAYER_CLASS_RACE = 21
+        struct
+        {
+            uint32 class_id;
+            uint32 race_id;
+        } classRace;
+        // ACHIEVEMENT_CRITERIA_DATA_TYPE_T_PLAYER_LESS_HEALTH = 3
+        struct
+        {
+            uint32 percent;
+        } health;
+        // ACHIEVEMENT_CRITERIA_DATA_TYPE_T_PLAYER_DEAD     = 4
+        struct
+        {
+            uint32 own_team_flag;
+        } player_dead;
+        // ACHIEVEMENT_CRITERIA_DATA_TYPE_S_AURA            = 5
+        // ACHIEVEMENT_CRITERIA_DATA_TYPE_T_AURA            = 7
+        struct
+        {
+            uint32 spell_id;
+            uint32 effect_idx;
+        } aura;
+        // ACHIEVEMENT_CRITERIA_DATA_TYPE_S_AREA            = 6
+        struct
+        {
+            uint32 id;
+        } area;
+        // ACHIEVEMENT_CRITERIA_DATA_TYPE_VALUE             = 8
+        struct
+        {
+            uint32 value;
+            uint32 compType;
+        } value;
+        // ACHIEVEMENT_CRITERIA_DATA_TYPE_T_LEVEL           = 9
+        struct
+        {
+            uint32 minlevel;
+        } level;
+        // ACHIEVEMENT_CRITERIA_DATA_TYPE_T_GENDER          = 10
+        struct
+        {
+            uint32 gender;
+        } gender;
+        // ACHIEVEMENT_CRITERIA_DATA_TYPE_SCRIPT            = 11 (no data)
+        // ACHIEVEMENT_CRITERIA_DATA_TYPE_MAP_DIFFICULTY    = 12
+        struct
+        {
+            uint32 difficulty;
+        } difficulty;
+        // ACHIEVEMENT_CRITERIA_DATA_TYPE_MAP_PLAYER_COUNT  = 13
+        struct
+        {
+            uint32 maxcount;
+        } map_players;
+        // ACHIEVEMENT_CRITERIA_DATA_TYPE_T_TEAM            = 14
+        struct
+        {
+            uint32 team;
+        } team;
+        // ACHIEVEMENT_CRITERIA_DATA_TYPE_S_DRUNK           = 15
+        struct
+        {
+            uint32 state;
+        } drunk;
+        // ACHIEVEMENT_CRITERIA_DATA_TYPE_HOLIDAY           = 16
+        struct
+        {
+            uint32 id;
+        } holiday;
+        // ACHIEVEMENT_CRITERIA_DATA_TYPE_BG_LOSS_TEAM_SCORE= 17
+        struct
+        {
+            uint32 min_score;
+            uint32 max_score;
+        } bg_loss_team_score;
+        // ACHIEVEMENT_CRITERIA_DATA_TYPE_INSTANCE_SCRIPT        = 18 (no data)
+        // ACHIEVEMENT_CRITERIA_DATA_TYPE_S_EQUIPED_ITEM    = 19
+        struct
+        {
+            uint32 item_level;
+            uint32 item_quality;
+        } equipped_item;
+        // ACHIEVEMENT_CRITERIA_DATA_TYPE_MAP_ID            = 20
+        struct
+        {
+            uint32 mapId;
+        } map_id;
+        // ACHIEVEMENT_CRITERIA_DATA_TYPE_NTH_BIRTHDAY      = 21
+        struct
+        {
+            uint32 nth_birthday;
+        } birthday_login;
+        // ACHIEVEMENT_CRITERIA_DATA_TYPE_KNOWN_TITLE       = 22
+        struct
+        {
+            uint32 title_id;
+        } known_title;
+        // ...
+        struct
+        {
+            uint32 value1;
+            uint32 value2;
+        } raw;
+    };
+    uint32 ScriptId;
+
+    AchievementCriteriaData() : dataType(ACHIEVEMENT_CRITERIA_DATA_TYPE_NONE)
+    {
+        raw.value1 = 0;
+        raw.value2 = 0;
+        ScriptId = 0;
+    }
+
+    AchievementCriteriaData(uint32 _dataType, uint32 _value1, uint32 _value2, uint32 _scriptId) : dataType(AchievementCriteriaDataType(_dataType))
+    {
+        raw.value1 = _value1;
+        raw.value2 = _value2;
+        ScriptId = _scriptId;
+    }
+
+    bool IsValid(AchievementCriteriaEntry const* criteria);
+    bool Meets(uint32 criteria_id, Player const* source, Unit const* target, uint32 miscvalue1 = 0) const;
+};
+
+struct AchievementCriteriaDataSet
+{
+        AchievementCriteriaDataSet() : criteria_id(0) {}
+        typedef std::vector<AchievementCriteriaData> Storage;
+        void Add(AchievementCriteriaData const& data) { storage.push_back(data); }
+        bool Meets(Player const* source, Unit const* target, uint32 miscvalue = 0) const;
+        void SetCriteriaId(uint32 id) {criteria_id = id;}
+    private:
+        uint32 criteria_id;
+        Storage storage;
+};
+
+typedef std::map<uint32, AchievementCriteriaDataSet> AchievementCriteriaDataMap;
+
+struct AchievementReward
+{
+    uint32 titleId[2];
+    uint32 itemId;
+    uint32 sender;
+    std::string subject;
+    std::string text;
+    uint32 mailTemplate;
+};
+
+typedef std::map<uint32, AchievementReward> AchievementRewards;
+
+struct AchievementRewardLocale
+{
+    StringVector subject;
+    StringVector text;
+};
+
+typedef std::map<uint32, AchievementRewardLocale> AchievementRewardLocales;
+
+struct CompletedAchievementData
+{
+    time_t date;
+    bool changed;
+};
+
+typedef UNORDERED_MAP<uint32, CriteriaProgress> CriteriaProgressMap;
+typedef UNORDERED_MAP<uint32, CompletedAchievementData> CompletedAchievementMap;
+
+class Unit;
+class Player;
+class WorldPacket;
+
+class AchievementMgr
+{
+    public:
+        AchievementMgr(Player* player);
+        ~AchievementMgr();
+
+        void Reset();
+        static void DeleteFromDB(uint32 lowguid);
+        void LoadFromDB(PreparedQueryResult achievementResult, PreparedQueryResult criteriaResult);
+        void SaveToDB(SQLTransaction& trans);
+        void ResetAchievementCriteria(AchievementCriteriaCondition condition, uint32 value, bool evenIfCriteriaComplete = false);
+        void UpdateAchievementCriteria(AchievementCriteriaTypes type, uint32 miscValue1 = 0, uint32 miscValue2 = 0, Unit* unit = NULL);
+        void CompletedAchievement(AchievementEntry const* entry);
+        void CheckAllAchievementCriteria();
+        void SendAllAchievementData() const;
+        void SendRespondInspectAchievements(Player* player) const;
+        bool HasAchieved(uint32 achievementId) const;
+        Player* GetPlayer() const { return m_player; }
+        void UpdateTimedAchievements(uint32 timeDiff);
+        void StartTimedAchievement(AchievementCriteriaTimedTypes type, uint32 entry, uint32 timeLost = 0);
+        void RemoveTimedAchievement(AchievementCriteriaTimedTypes type, uint32 entry);   // used for quest and scripted timed achievements
+
+		void RemoveCriteriaProgress(AchievementCriteriaEntry const* entry);
+    private:
+        enum ProgressType { PROGRESS_SET, PROGRESS_ACCUMULATE, PROGRESS_HIGHEST, PROGRESS_RESET };
+        void SendAchievementEarned(AchievementEntry const* achievement) const;
+        void SendCriteriaUpdate(AchievementCriteriaEntry const* entry, CriteriaProgress const* progress, uint32 timeElapsed, bool timedCompleted) const;
+        CriteriaProgress* GetCriteriaProgress(AchievementCriteriaEntry const* entry);
+        void SetCriteriaProgress(AchievementCriteriaEntry const* entry, uint32 changeValue, ProgressType ptype = PROGRESS_SET);
+        void CompletedCriteriaFor(AchievementEntry const* achievement);
+        bool IsCompletedCriteria(AchievementCriteriaEntry const* achievementCriteria, AchievementEntry const* achievement);
+        bool IsCompletedAchievement(AchievementEntry const* entry);
+        bool CanUpdateCriteria(AchievementCriteriaEntry const* criteria, AchievementEntry const* achievement);
+        void BuildAllDataPacket(WorldPacket* data, bool inspect = false) const;
+
+        Player* m_player;
+        CriteriaProgressMap m_criteriaProgress;
+        CompletedAchievementMap m_completedAchievements;
+        typedef std::map<uint32, uint32> TimedAchievementMap;
+        TimedAchievementMap m_timedAchievements;      // Criteria id/time left in MS
+};
+
+class AchievementGlobalMgr
+{
+        friend class ACE_Singleton<AchievementGlobalMgr, ACE_Null_Mutex>;
+        AchievementGlobalMgr() {}
+        ~AchievementGlobalMgr() {}
+
+    public:
+        AchievementCriteriaEntryList const* GetAchievementCriteriaByType(AchievementCriteriaTypes type) const
+        {
+            return &m_AchievementCriteriasByType[type];
+        }
+
+        AchievementCriteriaEntryList const* GetSpecialAchievementCriteriaByType(AchievementCriteriaTypes type, uint32 val)
+        {
+            if (m_SpecialList[type].find(val) != m_SpecialList[type].end())
+                return &m_SpecialList[type][val];
+            return NULL;
+        }
+
+        AchievementCriteriaEntryList const* GetAchievementCriteriaByCondition(AchievementCriteriaCondition condition, uint32 val)
+        {
+            if (m_AchievementCriteriasByCondition[condition].find(val) != m_AchievementCriteriasByCondition[condition].end())
+                return &m_AchievementCriteriasByCondition[condition][val];
+            return NULL;
+        }
+
+        AchievementCriteriaEntryList const& GetTimedAchievementCriteriaByType(AchievementCriteriaTimedTypes type) const
+        {
+            return m_AchievementCriteriasByTimedType[type];
+        }
+
+        AchievementCriteriaEntryList const* GetAchievementCriteriaByAchievement(uint32 id) const
+        {
+            AchievementCriteriaListByAchievement::const_iterator itr = m_AchievementCriteriaListByAchievement.find(id);
+            return itr != m_AchievementCriteriaListByAchievement.end() ? &itr->second : NULL;
+        }
+
+        AchievementEntryList const* GetAchievementByReferencedId(uint32 id) const
+        {
+            AchievementListByReferencedId::const_iterator itr = m_AchievementListByReferencedId.find(id);
+            return itr != m_AchievementListByReferencedId.end() ? &itr->second : NULL;
+        }
+
+        AchievementReward const* GetAchievementReward(AchievementEntry const* achievement) const
+        {
+            AchievementRewards::const_iterator iter = m_achievementRewards.find(achievement->ID);
+            return iter != m_achievementRewards.end() ? &iter->second : NULL;
+        }
+
+        AchievementRewardLocale const* GetAchievementRewardLocale(AchievementEntry const* achievement) const
+        {
+            AchievementRewardLocales::const_iterator iter = m_achievementRewardLocales.find(achievement->ID);
+            return iter != m_achievementRewardLocales.end() ? &iter->second : NULL;
+        }
+
+        AchievementCriteriaDataSet const* GetCriteriaDataSet(AchievementCriteriaEntry const* achievementCriteria) const
+        {
+            AchievementCriteriaDataMap::const_iterator iter = m_criteriaDataMap.find(achievementCriteria->ID);
+            return iter != m_criteriaDataMap.end() ? &iter->second : NULL;
+        }
+
+        bool IsRealmCompleted(AchievementEntry const* achievement) const
+        {
+            return m_allCompletedAchievements.find(achievement->ID) != m_allCompletedAchievements.end();
+        }
+
+        void SetRealmCompleted(AchievementEntry const* achievement)
+        {
+            m_allCompletedAchievements.insert(achievement->ID);
+        }
+
+        void LoadAchievementCriteriaList();
+        void LoadAchievementCriteriaData();
+        void LoadAchievementReferenceList();
+        void LoadCompletedAchievements();
+        void LoadRewards();
+        void LoadRewardLocales();
+    private:
+        AchievementCriteriaDataMap m_criteriaDataMap;
+
+        // store achievement criterias by type to speed up lookup
+        AchievementCriteriaEntryList m_AchievementCriteriasByType[ACHIEVEMENT_CRITERIA_TYPE_TOTAL];
+        AchievementCriteriaEntryList m_AchievementCriteriasByTimedType[ACHIEVEMENT_TIMED_TYPE_MAX];
+        // store achievement criterias by achievement to speed up lookup
+        AchievementCriteriaListByAchievement m_AchievementCriteriaListByAchievement;
+        // store achievements by referenced achievement id to speed up lookup
+        AchievementListByReferencedId m_AchievementListByReferencedId;
+
+        typedef std::set<uint32> AllCompletedAchievements;
+        AllCompletedAchievements m_allCompletedAchievements;
+
+        AchievementRewards m_achievementRewards;
+        AchievementRewardLocales m_achievementRewardLocales;
+
+		// pussywizard:
+		std::map<uint32, AchievementCriteriaEntryList> m_SpecialList[ACHIEVEMENT_CRITERIA_TYPE_TOTAL];
+		std::map<uint32, AchievementCriteriaEntryList> m_AchievementCriteriasByCondition[ACHIEVEMENT_CRITERIA_CONDITION_TOTAL];
+};
+
+#define sAchievementMgr ACE_Singleton<AchievementGlobalMgr, ACE_Null_Mutex>::instance()
+
+#endif

src/server/game/Addons/AddonMgr.cpp

@@ -0,0 +1,96 @@
+/*
+ * Copyright (C) 
+ * Copyright (C) 
+ *
+ * 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "AddonMgr.h"
+#include "DatabaseEnv.h"
+#include "Log.h"
+#include "Timer.h"
+
+#include <list>
+
+namespace AddonMgr
+{
+
+// Anonymous namespace ensures file scope of all the stuff inside it, even
+// if you add something more to this namespace somewhere else.
+namespace
+{
+    // List of saved addons (in DB).
+    typedef std::list<SavedAddon> SavedAddonsList;
+
+    SavedAddonsList m_knownAddons;
+}
+
+void LoadFromDB()
+{
+    uint32 oldMSTime = getMSTime();
+
+    QueryResult result = CharacterDatabase.Query("SELECT name, crc FROM addons");
+    if (!result)
+    {
+        sLog->outString(">> Loaded 0 known addons. DB table `addons` is empty!");
+        sLog->outString();
+        return;
+    }
+
+    uint32 count = 0;
+
+    do
+    {
+        Field* fields = result->Fetch();
+
+        std::string name = fields[0].GetString();
+        uint32 crc = fields[1].GetUInt32();
+
+        m_knownAddons.push_back(SavedAddon(name, crc));
+
+        ++count;
+    }
+    while (result->NextRow());
+
+    sLog->outString(">> Loaded %u known addons in %u ms", count, GetMSTimeDiffToNow(oldMSTime));
+    sLog->outString();
+}
+
+void SaveAddon(AddonInfo const& addon)
+{
+    std::string name = addon.Name;
+
+    PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_INS_ADDON);
+
+    stmt->setString(0, name);
+    stmt->setUInt32(1, addon.CRC);
+
+    CharacterDatabase.Execute(stmt);
+
+    m_knownAddons.push_back(SavedAddon(addon.Name, addon.CRC));
+}
+
+SavedAddon const* GetAddonInfo(const std::string& name)
+{
+    for (SavedAddonsList::const_iterator it = m_knownAddons.begin(); it != m_knownAddons.end(); ++it)
+    {
+        SavedAddon const& addon = (*it);
+        if (addon.Name == name)
+            return &addon;
+    }
+
+    return NULL;
+}
+
+} // Namespace

src/server/game/Addons/AddonMgr.h

@@ -0,0 +1,58 @@
+/*
+ * Copyright (C) 
+ * Copyright (C) 
+ *
+ * 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef _ADDONMGR_H
+#define _ADDONMGR_H
+
+#include "Define.h"
+#include <string>
+
+struct AddonInfo
+{
+    AddonInfo(const std::string& name, uint8 enabled, uint32 crc, uint8 state, bool crcOrPubKey)
+        : Name(name), Enabled(enabled), CRC(crc), State(state), UsePublicKeyOrCRC(crcOrPubKey) {}
+
+    std::string Name;
+    uint8 Enabled;
+    uint32 CRC;
+    uint8 State;
+    bool UsePublicKeyOrCRC;
+};
+
+struct SavedAddon
+{
+    SavedAddon(const std::string& name, uint32 crc) : Name(name)
+    {
+        CRC = crc;
+    }
+
+    std::string Name;
+    uint32 CRC;
+};
+
+#define STANDARD_ADDON_CRC 0x4c1c776d
+
+namespace AddonMgr
+{
+    void LoadFromDB();
+    void SaveAddon(AddonInfo const& addon);
+    SavedAddon const* GetAddonInfo(const std::string& name);
+}
+
+#endif
+

src/server/game/ArenaSpectator/ArenaSpectator.h

@@ -0,0 +1,217 @@
+
+#ifndef SUNWELLCORE_ARENASPECTATOR_H
+#define SUNWELLCORE_ARENASPECTATOR_H
+
+#include "Player.h"
+#include "World.h"
+#include "Map.h"
+#include "Battleground.h"
+#include "Pet.h"
+#include "SpellAuras.h"
+#include "SpellAuraEffects.h"
+#include "Chat.h"
+#include "LFGMgr.h"
+
+#define SPECTATOR_ADDON_VERSION 27
+#define SPECTATOR_BUFFER_LEN 150
+#define SPECTATOR_ADDON_PREFIX "ASSUN\x09"
+#define SPECTATOR_COOLDOWN_MIN 20
+#define SPECTATOR_COOLDOWN_MAX 900
+#define SPECTATOR_SPELL_BINDSIGHT 6277
+#define SPECTATOR_SPELL_SPEED 1557
+
+namespace ArenaSpectator
+{
+	template<class T> inline void SendCommand(T* o, const char* format, ...) ATTR_PRINTF(2, 3);
+	inline void CreatePacket(WorldPacket& data, const char* m);
+	inline void SendPacketTo(const Player* p, const char* m);
+	inline void SendPacketTo(const Map* map, const char* m);
+	inline void HandleResetCommand(Player* p);
+	inline bool ShouldSendAura(Aura* aura, uint8 effMask, uint64 targetGUID, bool remove);
+
+	template<class T> inline void SendCommand_String(T* p, uint64 targetGUID, const char* prefix, const std::string& c);
+	template<class T> inline void SendCommand_UInt32Value(T* o, uint64 targetGUID, const char* prefix, uint32 t);
+	template<class T> inline void SendCommand_GUID(T* o, uint64 targetGUID, const char* prefix, uint64 t);
+	template<class T> inline void SendCommand_Spell(T* o, uint64 targetGUID, const char* prefix, uint32 id, int32 casttime);
+	template<class T> inline void SendCommand_Cooldown(T* o, uint64 targetGUID, const char* prefix, uint32 id, uint32 dur, uint32 maxdur);
+	template<class T> inline void SendCommand_Aura(T* o, uint64 targetGUID, const char* prefix, uint64 caster, uint32 id, bool isDebuff, uint32 dispel, int32 dur, int32 maxdur, uint32 stack, bool remove);
+
+	bool HandleSpectatorSpectateCommand(ChatHandler* handler, char const* args);
+	bool HandleSpectatorWatchCommand(ChatHandler* handler, char const* args);
+
+	// definitions below:
+
+	template<class T>
+	void SendCommand(T* o, const char* format, ...)
+	{
+		if (!format)
+			return;
+        char buffer[SPECTATOR_BUFFER_LEN];
+		va_list ap;
+        va_start(ap, format);
+        vsnprintf(buffer, SPECTATOR_BUFFER_LEN, format, ap);
+        va_end(ap);
+		SendPacketTo(o, buffer);
+	}
+
+	void CreatePacket(WorldPacket& data, const char* m)
+	{
+		size_t len = strlen(m);
+		data.Initialize(SMSG_MESSAGECHAT, 1+4+8+4+8+4+1+len+1);
+		data << uint8(CHAT_MSG_WHISPER);
+		data << uint32(LANG_ADDON);
+		data << uint64(0);
+		data << uint32(0);
+		data << uint64(0);
+		data << uint32(len + 1);
+		data << m;
+		data << uint8(0);
+	}
+
+	void SendPacketTo(const Player* p, const char* m)
+	{
+		WorldPacket data;
+		CreatePacket(data, m);
+		p->GetSession()->SendPacket(&data);
+	}
+
+	void SendPacketTo(const Map* map, const char* m)
+	{
+		if (!map->IsBattleArena())
+			return;
+		Battleground* bg = ((BattlegroundMap*)map)->GetBG();
+		if (!bg || bg->GetStatus() != STATUS_IN_PROGRESS)
+			return;
+		WorldPacket data;
+		CreatePacket(data, m);
+		bg->SpectatorsSendPacket(data);
+	}
+
+	template<class T> 
+	void SendCommand_String(T* o, uint64 targetGUID, const char* prefix, const char* c)
+	{
+		if (!IS_PLAYER_GUID(targetGUID))
+			return;
+		SendCommand(o, "%s0x%016llX;%s=%s;", SPECTATOR_ADDON_PREFIX, targetGUID, prefix, c);
+	}
+
+	template<class T>
+	void SendCommand_UInt32Value(T* o, uint64 targetGUID, const char* prefix, uint32 t)
+	{
+		if (!IS_PLAYER_GUID(targetGUID))
+			return;
+		SendCommand(o, "%s0x%016llX;%s=%u;", SPECTATOR_ADDON_PREFIX, targetGUID, prefix, t);
+	}
+
+	template<class T>
+	void SendCommand_GUID(T* o, uint64 targetGUID, const char* prefix, uint64 t)
+	{
+		if (!IS_PLAYER_GUID(targetGUID))
+			return;
+		SendCommand(o, "%s0x%016llX;%s=0x%016llX;", SPECTATOR_ADDON_PREFIX, targetGUID, prefix, t);
+	}
+
+	template<class T>
+	void SendCommand_Spell(T* o, uint64 targetGUID, const char* prefix, uint32 id, int32 casttime)
+	{
+		if (!IS_PLAYER_GUID(targetGUID))
+			return;
+		SendCommand(o, "%s0x%016llX;%s=%u,%i;", SPECTATOR_ADDON_PREFIX, targetGUID, prefix, id, casttime);
+	}
+
+	template<class T>
+	void SendCommand_Cooldown(T* o, uint64 targetGUID, const char* prefix, uint32 id, uint32 dur, uint32 maxdur)
+	{
+		if (!IS_PLAYER_GUID(targetGUID))
+			return;
+		if (const SpellInfo* si = sSpellMgr->GetSpellInfo(id))
+			if (si->SpellIconID == 1)
+				return;
+		SendCommand(o, "%s0x%016llX;%s=%u,%u,%u;", SPECTATOR_ADDON_PREFIX, targetGUID, prefix, id, dur, maxdur);
+	}
+
+	template<class T>
+	void SendCommand_Aura(T* o, uint64 targetGUID, const char* prefix, uint64 caster, uint32 id, bool isDebuff, uint32 dispel, int32 dur, int32 maxdur, uint32 stack, bool remove)
+	{
+		if (!IS_PLAYER_GUID(targetGUID))
+			return;
+		SendCommand(o, "%s0x%016llX;%s=%u,%u,%i,%i,%u,%u,%u,0x%016llX;", SPECTATOR_ADDON_PREFIX, targetGUID, prefix, remove ? 1 : 0, stack, dur, maxdur, id, dispel, isDebuff ? 1 : 0, caster);
+	}
+
+	void HandleResetCommand(Player* p)
+	{
+		if (!p->FindMap() || !p->IsInWorld() || !p->FindMap()->IsBattleArena())
+			return;
+		Battleground* bg = ((BattlegroundMap*)p->FindMap())->GetBG();
+		if (!bg || bg->GetStatus() != STATUS_IN_PROGRESS)
+			return;
+		Battleground::BattlegroundPlayerMap const& pl = bg->GetPlayers();
+		for (Battleground::BattlegroundPlayerMap::const_iterator itr = pl.begin(); itr != pl.end(); ++itr)
+		{
+			if (p->HasReceivedSpectatorResetFor(GUID_LOPART(itr->first)))
+				continue;
+
+			Player* plr = itr->second;
+			p->AddReceivedSpectatorResetFor(GUID_LOPART(itr->first));
+
+			SendCommand_String(p, itr->first, "NME", plr->GetName().c_str());
+			// Xinef: addon compatibility
+			SendCommand_UInt32Value(p, itr->first, "TEM", plr->GetBgTeamId() == TEAM_ALLIANCE ? ALLIANCE : HORDE);
+			SendCommand_UInt32Value(p, itr->first, "CLA", plr->getClass());
+			SendCommand_UInt32Value(p, itr->first, "MHP", plr->GetMaxHealth());
+			SendCommand_UInt32Value(p, itr->first, "CHP", plr->GetHealth());
+			SendCommand_UInt32Value(p, itr->first, "STA", plr->IsAlive() ? 1 : 0);
+			Powers ptype = plr->getPowerType();
+			SendCommand_UInt32Value(p, itr->first, "PWT", ptype);
+			SendCommand_UInt32Value(p, itr->first, "MPW", ptype == POWER_RAGE || ptype == POWER_RUNIC_POWER ? plr->GetMaxPower(ptype)/10 : plr->GetMaxPower(ptype));
+			SendCommand_UInt32Value(p, itr->first, "CPW", ptype == POWER_RAGE || ptype == POWER_RUNIC_POWER ? plr->GetPower(ptype)/10 : plr->GetPower(ptype));
+			Pet* pet = plr->GetPet();
+			SendCommand_UInt32Value(p, itr->first, "PHP", pet && pet->GetCreatureTemplate()->family ? (uint32)pet->GetHealthPct() : 0);
+			SendCommand_UInt32Value(p, itr->first, "PET", pet ? pet->GetCreatureTemplate()->family : 0);
+			SendCommand_GUID(p, itr->first, "TRG", plr->GetTarget());
+			SendCommand_UInt32Value(p, itr->first, "RES", 1);
+			SendCommand_UInt32Value(p, itr->first, "CDC", 1);
+			SendCommand_UInt32Value(p, itr->first, "TIM", (bg->GetStartTime() < 46*MINUTE*IN_MILLISECONDS) ? (46*MINUTE*IN_MILLISECONDS-bg->GetStartTime())/IN_MILLISECONDS : 0);
+			// "SPE" not here (only possible to send starting a new cast)
+
+			// send all "CD"
+			SpellCooldowns const& sc = plr->GetSpellCooldownMap();
+			for (SpellCooldowns::const_iterator itrc = sc.begin(); itrc != sc.end(); ++itrc)
+				if (itrc->second.sendToSpectator && itrc->second.maxduration >= SPECTATOR_COOLDOWN_MIN*IN_MILLISECONDS && itrc->second.maxduration <= SPECTATOR_COOLDOWN_MAX*IN_MILLISECONDS)
+					if (uint32 cd = (getMSTimeDiff(World::GetGameTimeMS(), itrc->second.end)/1000))
+						SendCommand_Cooldown(p, itr->first, "ACD", itrc->first, cd, itrc->second.maxduration/1000);
+
+			// send all visible "AUR"
+			Unit::VisibleAuraMap const *visibleAuras = plr->GetVisibleAuras();
+			for (Unit::VisibleAuraMap::const_iterator aitr = visibleAuras->begin(); aitr != visibleAuras->end(); ++aitr)
+			{
+				Aura *aura = aitr->second->GetBase();
+				if (ShouldSendAura(aura, aitr->second->GetEffectMask(), plr->GetGUID(), false))
+					SendCommand_Aura(p, itr->first, "AUR", aura->GetCasterGUID(), aura->GetSpellInfo()->Id, aura->GetSpellInfo()->IsPositive(), aura->GetSpellInfo()->Dispel, aura->GetDuration(), aura->GetMaxDuration(), (aura->GetCharges() > 1 ? aura->GetCharges() : aura->GetStackAmount()), false);
+			}
+		}
+	}
+
+	bool ShouldSendAura(Aura* aura, uint8 effMask, uint64 targetGUID, bool remove)
+	{
+		if (aura->GetSpellInfo()->SpellIconID == 1 || aura->GetSpellInfo()->HasAttribute(SPELL_ATTR1_DONT_DISPLAY_IN_AURA_BAR))
+			return false;
+
+		if (remove || aura->GetSpellInfo()->HasAttribute(SPELL_ATTR0_CU_AURA_CC) || aura->GetSpellInfo()->SpellFamilyName == SPELLFAMILY_GENERIC)
+			return true;
+
+		for(uint8 i=EFFECT_0; i<MAX_SPELL_EFFECTS; ++i)
+		{
+			if (effMask & (1<<i))
+			{
+				AuraType at = aura->GetEffect(i)->GetAuraType();
+				if (aura->GetEffect(i)->GetAmount() && (aura->GetSpellInfo()->IsPositive() || targetGUID != aura->GetCasterGUID()) || 
+					at == SPELL_AURA_MECHANIC_IMMUNITY || at == SPELL_AURA_EFFECT_IMMUNITY || at == SPELL_AURA_STATE_IMMUNITY || at == SPELL_AURA_SCHOOL_IMMUNITY || at == SPELL_AURA_DISPEL_IMMUNITY)
+					return true;
+			}
+		}
+		return false;
+	}
+}
+
+#endif

src/server/game/AuctionHouse/AuctionHouseMgr.cpp

@@ -0,0 +1,820 @@
+/*
+ * Copyright (C) 
+ * Copyright (C) 
+ *
+ * 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "Common.h"
+#include "ObjectMgr.h"
+#include "Player.h"
+#include "World.h"
+#include "WorldPacket.h"
+#include "WorldSession.h"
+#include "DatabaseEnv.h"
+#include "DBCStores.h"
+#include "ScriptMgr.h"
+#include "AccountMgr.h"
+#include "AuctionHouseMgr.h"
+#include "Item.h"
+#include "Language.h"
+#include "Logging/Log.h"
+#include <vector>
+#include "AvgDiffTracker.h"
+#include "AsyncAuctionListing.h"
+
+enum eAuctionHouse
+{
+    AH_MINIMUM_DEPOSIT = 100,
+};
+
+AuctionHouseMgr::AuctionHouseMgr()
+{
+}
+
+AuctionHouseMgr::~AuctionHouseMgr()
+{
+    for (ItemMap::iterator itr = mAitems.begin(); itr != mAitems.end(); ++itr)
+        delete itr->second;
+}
+
+AuctionHouseObject* AuctionHouseMgr::GetAuctionsMap(uint32 factionTemplateId)
+{
+    // team have linked auction houses
+    FactionTemplateEntry const* u_entry = sFactionTemplateStore.LookupEntry(factionTemplateId);
+    if (!u_entry)
+        return &mNeutralAuctions;
+    else if (u_entry->ourMask & FACTION_MASK_ALLIANCE)
+        return &mAllianceAuctions;
+    else if (u_entry->ourMask & FACTION_MASK_HORDE)
+        return &mHordeAuctions;
+    else
+        return &mNeutralAuctions;
+}
+
+uint32 AuctionHouseMgr::GetAuctionDeposit(AuctionHouseEntry const* entry, uint32 time, Item* pItem, uint32 count)
+{
+    uint32 MSV = pItem->GetTemplate()->SellPrice;
+
+    if (MSV <= 0)
+        return AH_MINIMUM_DEPOSIT;
+
+    float multiplier = CalculatePct(float(entry->depositPercent), 3);
+    uint32 timeHr = (((time / 60) / 60) / 12);
+    uint32 deposit = uint32(((multiplier * MSV * count / 3) * timeHr * 3) * sWorld->getRate(RATE_AUCTION_DEPOSIT));
+
+    ;//sLog->outDebug(LOG_FILTER_AUCTIONHOUSE, "MSV:        %u", MSV);
+    ;//sLog->outDebug(LOG_FILTER_AUCTIONHOUSE, "Items:      %u", count);
+    ;//sLog->outDebug(LOG_FILTER_AUCTIONHOUSE, "Multiplier: %f", multiplier);
+    ;//sLog->outDebug(LOG_FILTER_AUCTIONHOUSE, "Deposit:    %u", deposit);
+
+    if (deposit < AH_MINIMUM_DEPOSIT)
+        return AH_MINIMUM_DEPOSIT;
+    else
+        return deposit;
+}
+
+//does not clear ram
+void AuctionHouseMgr::SendAuctionWonMail(AuctionEntry* auction, SQLTransaction& trans)
+{
+    Item* pItem = GetAItem(auction->item_guidlow);
+    if (!pItem)
+        return;
+
+	uint64 bidder_guid = MAKE_NEW_GUID(auction->bidder, 0, HIGHGUID_PLAYER);
+	uint32 bidder_accId = 0;
+	Player* bidder = ObjectAccessor::FindPlayerInOrOutOfWorld(bidder_guid);
+	if (bidder)
+		bidder_accId = bidder->GetSession()->GetAccountId();
+	else
+		bidder_accId = sObjectMgr->GetPlayerAccountIdByGUID(bidder_guid);
+
+    // receiver exist
+    if (bidder || bidder_accId)
+    {
+        // set owner to bidder (to prevent delete item with sender char deleting)
+        // owner in `data` will set at mail receive and item extracting
+        PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_UPD_ITEM_OWNER);
+        stmt->setUInt32(0, auction->bidder);
+        stmt->setUInt32(1, pItem->GetGUIDLow());
+        trans->Append(stmt);
+
+        if (bidder)
+        {
+            bidder->GetSession()->SendAuctionBidderNotification(auction->GetHouseId(), auction->Id, bidder_guid, 0, 0, auction->item_template);
+            // FIXME: for offline player need also
+            bidder->UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_WON_AUCTIONS, 1);
+        }
+
+        MailDraft(auction->BuildAuctionMailSubject(AUCTION_WON), AuctionEntry::BuildAuctionMailBody(auction->owner, auction->bid, auction->buyout, 0, 0))
+            .AddItem(pItem)
+            .SendMailTo(trans, MailReceiver(bidder, auction->bidder), auction, MAIL_CHECK_MASK_COPIED);
+    }
+    else
+		sAuctionMgr->RemoveAItem(auction->item_guidlow, true);
+}
+
+void AuctionHouseMgr::SendAuctionSalePendingMail(AuctionEntry* auction, SQLTransaction& trans)
+{
+    uint64 owner_guid = MAKE_NEW_GUID(auction->owner, 0, HIGHGUID_PLAYER);
+    Player* owner = ObjectAccessor::FindPlayerInOrOutOfWorld(owner_guid);
+    uint32 owner_accId = sObjectMgr->GetPlayerAccountIdByGUID(owner_guid);
+    // owner exist (online or offline)
+    if (owner || owner_accId)
+        MailDraft(auction->BuildAuctionMailSubject(AUCTION_SALE_PENDING), AuctionEntry::BuildAuctionMailBody(auction->bidder, auction->bid, auction->buyout, auction->deposit, auction->GetAuctionCut()))
+            .SendMailTo(trans, MailReceiver(owner, auction->owner), auction, MAIL_CHECK_MASK_COPIED);
+}
+
+//call this method to send mail to auction owner, when auction is successful, it does not clear ram
+void AuctionHouseMgr::SendAuctionSuccessfulMail(AuctionEntry* auction, SQLTransaction& trans)
+{
+    uint64 owner_guid = MAKE_NEW_GUID(auction->owner, 0, HIGHGUID_PLAYER);
+    Player* owner = ObjectAccessor::FindPlayerInOrOutOfWorld(owner_guid);
+    uint32 owner_accId = sObjectMgr->GetPlayerAccountIdByGUID(owner_guid);
+    // owner exist
+    if (owner || owner_accId)
+    {
+        uint32 profit = auction->bid + auction->deposit - auction->GetAuctionCut();
+
+        if (owner)
+        {
+            owner->UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_GOLD_EARNED_BY_AUCTIONS, profit);
+            owner->UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_HIGHEST_AUCTION_SOLD, auction->bid);
+            owner->GetSession()->SendAuctionOwnerNotification(auction);
+        }
+
+        MailDraft(auction->BuildAuctionMailSubject(AUCTION_SUCCESSFUL), AuctionEntry::BuildAuctionMailBody(auction->bidder, auction->bid, auction->buyout, auction->deposit, auction->GetAuctionCut()))
+            .AddMoney(profit)
+            .SendMailTo(trans, MailReceiver(owner, auction->owner), auction, MAIL_CHECK_MASK_COPIED, sWorld->getIntConfig(CONFIG_MAIL_DELIVERY_DELAY));
+
+		if (auction->bid >= 500*GOLD)
+			if (const GlobalPlayerData* gpd = sWorld->GetGlobalPlayerData(auction->bidder))
+			{
+				uint64 bidder_guid = MAKE_NEW_GUID(auction->bidder, 0, HIGHGUID_PLAYER);
+				Player* bidder = ObjectAccessor::FindPlayerInOrOutOfWorld(bidder_guid);
+				std::string owner_name = "";
+				uint8 owner_level = 0;
+				if (const GlobalPlayerData* gpd_owner = sWorld->GetGlobalPlayerData(auction->owner))
+				{
+					owner_name = gpd_owner->name;
+					owner_level = gpd_owner->level;
+				}
+				CharacterDatabase.PExecute("INSERT INTO log_money VALUES(%u, %u, \"%s\", \"%s\", %u, \"%s\", %u, \"<AH> profit: %ug, bidder: %s %u lvl (guid: %u), seller: %s %u lvl (guid: %u), item %u (%u)\", NOW())", gpd->accountId, auction->bidder, gpd->name.c_str(), bidder ? bidder->GetSession()->GetRemoteAddress().c_str() : "", owner_accId, owner_name.c_str(), auction->bid, (profit/GOLD), gpd->name.c_str(), gpd->level, auction->bidder, owner_name.c_str(), owner_level, auction->owner, auction->item_template, auction->itemCount);
+			}
+    }
+}
+
+//does not clear ram
+void AuctionHouseMgr::SendAuctionExpiredMail(AuctionEntry* auction, SQLTransaction& trans)
+{
+    //return an item in auction to its owner by mail
+    Item* pItem = GetAItem(auction->item_guidlow);
+    if (!pItem)
+        return;
+
+    uint64 owner_guid = MAKE_NEW_GUID(auction->owner, 0, HIGHGUID_PLAYER);
+    Player* owner = ObjectAccessor::FindPlayerInOrOutOfWorld(owner_guid);
+    uint32 owner_accId = sObjectMgr->GetPlayerAccountIdByGUID(owner_guid);
+
+    // owner exist
+    if (owner || owner_accId)
+    {
+        if (owner)
+            owner->GetSession()->SendAuctionOwnerNotification(auction);
+
+        MailDraft(auction->BuildAuctionMailSubject(AUCTION_EXPIRED), AuctionEntry::BuildAuctionMailBody(0, 0, auction->buyout, auction->deposit, 0))
+            .AddItem(pItem)
+            .SendMailTo(trans, MailReceiver(owner, auction->owner), auction, MAIL_CHECK_MASK_COPIED, 0);
+    }
+	else
+		sAuctionMgr->RemoveAItem(auction->item_guidlow, true);
+}
+
+//this function sends mail to old bidder
+void AuctionHouseMgr::SendAuctionOutbiddedMail(AuctionEntry* auction, uint32 newPrice, Player* newBidder, SQLTransaction& trans)
+{
+    uint64 oldBidder_guid = MAKE_NEW_GUID(auction->bidder, 0, HIGHGUID_PLAYER);
+    Player* oldBidder = ObjectAccessor::FindPlayerInOrOutOfWorld(oldBidder_guid);
+
+    uint32 oldBidder_accId = 0;
+    if (!oldBidder)
+        oldBidder_accId = sObjectMgr->GetPlayerAccountIdByGUID(oldBidder_guid);
+
+    // old bidder exist
+    if (oldBidder || oldBidder_accId)
+    {
+        if (oldBidder && newBidder)
+            oldBidder->GetSession()->SendAuctionBidderNotification(auction->GetHouseId(), auction->Id, newBidder->GetGUID(), newPrice, auction->GetAuctionOutBid(), auction->item_template);
+
+        MailDraft(auction->BuildAuctionMailSubject(AUCTION_OUTBIDDED), AuctionEntry::BuildAuctionMailBody(auction->owner, auction->bid, auction->buyout, auction->deposit, auction->GetAuctionCut()))
+            .AddMoney(auction->bid)
+            .SendMailTo(trans, MailReceiver(oldBidder, auction->bidder), auction, MAIL_CHECK_MASK_COPIED);
+    }
+}
+
+//this function sends mail, when auction is cancelled to old bidder
+void AuctionHouseMgr::SendAuctionCancelledToBidderMail(AuctionEntry* auction, SQLTransaction& trans)
+{
+    uint64 bidder_guid = MAKE_NEW_GUID(auction->bidder, 0, HIGHGUID_PLAYER);
+    Player* bidder = ObjectAccessor::FindPlayerInOrOutOfWorld(bidder_guid);
+
+    uint32 bidder_accId = 0;
+    if (!bidder)
+        bidder_accId = sObjectMgr->GetPlayerAccountIdByGUID(bidder_guid);
+
+    // bidder exist
+    if (bidder || bidder_accId)
+        MailDraft(auction->BuildAuctionMailSubject(AUCTION_CANCELLED_TO_BIDDER), AuctionEntry::BuildAuctionMailBody(auction->owner, auction->bid, auction->buyout, auction->deposit, 0))
+            .AddMoney(auction->bid)
+            .SendMailTo(trans, MailReceiver(bidder, auction->bidder), auction, MAIL_CHECK_MASK_COPIED);
+}
+
+void AuctionHouseMgr::LoadAuctionItems()
+{
+    uint32 oldMSTime = getMSTime();
+
+    // need to clear in case we are reloading
+    if (!mAitems.empty())
+    {
+        for (ItemMap::iterator itr = mAitems.begin(); itr != mAitems.end(); ++itr)
+            delete itr->second;
+
+        mAitems.clear();
+    }
+
+    // data needs to be at first place for Item::LoadFromDB
+    PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_AUCTION_ITEMS);
+    PreparedQueryResult result = CharacterDatabase.Query(stmt);
+
+    if (!result)
+    {
+        sLog->outString(">> Loaded 0 auction items. DB table `auctionhouse` or `item_instance` is empty!");
+        sLog->outString();
+        return;
+    }
+
+    uint32 count = 0;
+
+    do
+    {
+
+        Field* fields = result->Fetch();
+
+        uint32 item_guid        = fields[11].GetUInt32();
+        uint32 item_template    = fields[12].GetUInt32();
+
+        ItemTemplate const* proto = sObjectMgr->GetItemTemplate(item_template);
+        if (!proto)
+        {
+            sLog->outError("AuctionHouseMgr::LoadAuctionItems: Unknown item (GUID: %u id: #%u) in auction, skipped.", item_guid, item_template);
+            continue;
+        }
+
+        Item* item = NewItemOrBag(proto);
+        if (!item->LoadFromDB(item_guid, 0, fields, item_template))
+        {
+            delete item;
+            continue;
+        }
+        AddAItem(item);
+
+        ++count;
+    }
+    while (result->NextRow());
+
+    sLog->outString(">> Loaded %u auction items in %u ms", count, GetMSTimeDiffToNow(oldMSTime));
+    sLog->outString();
+}
+
+void AuctionHouseMgr::LoadAuctions()
+{
+    uint32 oldMSTime = getMSTime();
+
+    PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_AUCTIONS);
+    PreparedQueryResult result = CharacterDatabase.Query(stmt);
+
+    if (!result)
+    {
+        sLog->outString(">> Loaded 0 auctions. DB table `auctionhouse` is empty.");
+        sLog->outString();
+        return;
+    }
+
+    uint32 count = 0;
+
+    SQLTransaction trans = CharacterDatabase.BeginTransaction();
+    do
+    {
+        Field* fields = result->Fetch();
+
+        AuctionEntry* aItem = new AuctionEntry();
+        if (!aItem->LoadFromDB(fields))
+        {
+            aItem->DeleteFromDB(trans);
+            delete aItem;
+            continue;
+        }
+
+        GetAuctionsMap(aItem->factionTemplateId)->AddAuction(aItem);
+        count++;
+    } while (result->NextRow());
+
+    CharacterDatabase.CommitTransaction(trans);
+
+    sLog->outString(">> Loaded %u auctions in %u ms", count, GetMSTimeDiffToNow(oldMSTime));
+    sLog->outString();
+}
+
+void AuctionHouseMgr::AddAItem(Item* it)
+{
+    ASSERT(it);
+    ASSERT(mAitems.find(it->GetGUIDLow()) == mAitems.end());
+    mAitems[it->GetGUIDLow()] = it;
+}
+
+bool AuctionHouseMgr::RemoveAItem(uint32 id, bool deleteFromDB)
+{
+    ItemMap::iterator i = mAitems.find(id);
+    if (i == mAitems.end())
+        return false;
+
+	if (deleteFromDB)
+	{
+		SQLTransaction trans = CharacterDatabase.BeginTransaction();
+		i->second->FSetState(ITEM_REMOVED);
+		i->second->SaveToDB(trans);
+		CharacterDatabase.CommitTransaction(trans);
+	}
+
+    mAitems.erase(i);
+    return true;
+}
+
+void AuctionHouseMgr::Update()
+{
+    mHordeAuctions.Update();
+    mAllianceAuctions.Update();
+    mNeutralAuctions.Update();
+}
+
+AuctionHouseEntry const* AuctionHouseMgr::GetAuctionHouseEntry(uint32 factionTemplateId)
+{
+    uint32 houseid = 7; // goblin auction house
+
+    //if (!sWorld->getBoolConfig(CONFIG_ALLOW_TWO_SIDE_INTERACTION_AUCTION))
+    {
+        //FIXME: found way for proper auctionhouse selection by another way
+        // AuctionHouse.dbc have faction field with _player_ factions associated with auction house races.
+        // but no easy way convert creature faction to player race faction for specific city
+        switch (factionTemplateId)
+        {
+            case   12: houseid = 1; break; // human
+            case   29: houseid = 6; break; // orc, and generic for horde
+            case   55: houseid = 2; break; // dwarf, and generic for alliance
+            case   68: houseid = 4; break; // undead
+            case   80: houseid = 3; break; // n-elf
+            case  104: houseid = 5; break; // trolls
+            case  120: houseid = 7; break; // booty bay, neutral
+            case  474: houseid = 7; break; // gadgetzan, neutral
+            case  855: houseid = 7; break; // everlook, neutral
+            case 1604: houseid = 6; break; // b-elfs,
+            default:                       // for unknown case
+            {
+                FactionTemplateEntry const* u_entry = sFactionTemplateStore.LookupEntry(factionTemplateId);
+                if (!u_entry)
+                    houseid = 7; // goblin auction house
+                else if (u_entry->ourMask & FACTION_MASK_ALLIANCE)
+                    houseid = 1; // human auction house
+                else if (u_entry->ourMask & FACTION_MASK_HORDE)
+                    houseid = 6; // orc auction house
+                else
+                    houseid = 7; // goblin auction house
+                break;
+            }
+        }
+    }
+
+    return sAuctionHouseStore.LookupEntry(houseid);
+}
+
+void AuctionHouseObject::AddAuction(AuctionEntry* auction)
+{
+    ASSERT(auction);
+
+    AuctionsMap[auction->Id] = auction;
+    sScriptMgr->OnAuctionAdd(this, auction);
+}
+
+bool AuctionHouseObject::RemoveAuction(AuctionEntry* auction)
+{
+    bool wasInMap = AuctionsMap.erase(auction->Id) ? true : false;
+
+    sScriptMgr->OnAuctionRemove(this, auction);
+
+    // we need to delete the entry, it is not referenced any more
+    delete auction;
+    auction = NULL;
+
+    return wasInMap;
+}
+
+void AuctionHouseObject::Update()
+{
+    time_t checkTime = sWorld->GetGameTime() + 60;
+    ///- Handle expired auctions
+
+    // If storage is empty, no need to update. next == NULL in this case.
+    if (AuctionsMap.empty())
+        return;
+
+    SQLTransaction trans = CharacterDatabase.BeginTransaction();
+
+	for (AuctionEntryMap::iterator itr, iter = AuctionsMap.begin(); iter != AuctionsMap.end(); )
+	{
+		itr = iter++;
+		AuctionEntry* auction = (*itr).second;
+
+		if (auction->expire_time > checkTime)
+			continue;
+
+        ///- Either cancel the auction if there was no bidder
+        if (auction->bidder == 0)
+        {
+            sAuctionMgr->SendAuctionExpiredMail(auction, trans);
+            sScriptMgr->OnAuctionExpire(this, auction);
+        }
+        ///- Or perform the transaction
+        else
+        {
+            //we should send an "item sold" message if the seller is online
+            //we send the item to the winner
+            //we send the money to the seller
+            sAuctionMgr->SendAuctionSuccessfulMail(auction, trans);
+            sAuctionMgr->SendAuctionWonMail(auction, trans);
+            sScriptMgr->OnAuctionSuccessful(this, auction);
+        }
+
+        ///- In any case clear the auction
+        auction->DeleteFromDB(trans);
+
+        sAuctionMgr->RemoveAItem(auction->item_guidlow);
+        RemoveAuction(auction);
+    }
+    CharacterDatabase.CommitTransaction(trans);
+}
+
+void AuctionHouseObject::BuildListBidderItems(WorldPacket& data, Player* player, uint32& count, uint32& totalcount)
+{
+    for (AuctionEntryMap::const_iterator itr = AuctionsMap.begin(); itr != AuctionsMap.end(); ++itr)
+    {
+        AuctionEntry* Aentry = itr->second;
+        if (Aentry && Aentry->bidder == player->GetGUIDLow())
+        {
+            if (itr->second->BuildAuctionInfo(data))
+                ++count;
+
+            ++totalcount;
+        }
+    }
+}
+
+void AuctionHouseObject::BuildListOwnerItems(WorldPacket& data, Player* player, uint32& count, uint32& totalcount)
+{
+    for (AuctionEntryMap::const_iterator itr = AuctionsMap.begin(); itr != AuctionsMap.end(); ++itr)
+    {
+        AuctionEntry* Aentry = itr->second;
+        if (Aentry && Aentry->owner == player->GetGUIDLow())
+        {
+            if (Aentry->BuildAuctionInfo(data))
+                ++count;
+
+            ++totalcount;
+        }
+    }
+}
+
+bool AuctionHouseObject::BuildListAuctionItems(WorldPacket& data, Player* player,
+    std::wstring const& wsearchedname, uint32 listfrom, uint8 levelmin, uint8 levelmax, uint8 usable,
+    uint32 inventoryType, uint32 itemClass, uint32 itemSubClass, uint32 quality,
+    uint32& count, uint32& totalcount, uint8 getAll)
+{
+	uint32 itrcounter = 0;
+
+	// pussywizard: optimization, this is a simplified case
+	if (itemClass == 0xffffffff && itemSubClass == 0xffffffff && inventoryType == 0xffffffff && quality == 0xffffffff && levelmin == 0x00 && levelmax == 0x00 && usable == 0x00 && wsearchedname.empty())
+	{
+		totalcount = Getcount();
+		if (listfrom < totalcount)
+		{
+			AuctionEntryMap::iterator itr = AuctionsMap.begin();
+			std::advance(itr, listfrom);
+			for (; itr != AuctionsMap.end(); ++itr)
+			{
+				itr->second->BuildAuctionInfo(data);
+				if ((++count) >= 50)
+					break;
+			}
+		}
+		return true;
+	}
+
+    time_t curTime = sWorld->GetGameTime();
+
+    for (AuctionEntryMap::const_iterator itr = AuctionsMap.begin(); itr != AuctionsMap.end(); ++itr)
+    {
+		if (AsyncAuctionListingMgr::IsAuctionListingAllowed() == false) // pussywizard: World::Update is waiting for us...
+			if ((itrcounter++) % 100 == 0) // check condition every 100 iterations
+				if (avgDiffTracker.getAverage() >= 30 || getMSTimeDiff(World::GetGameTimeMS(), getMSTime()) >= 10) // pussywizard: stop immediately if diff is high or waiting too long
+					return false;
+
+        AuctionEntry* Aentry = itr->second;
+        // Skip expired auctions
+        if (Aentry->expire_time < curTime)
+            continue;
+
+        Item* item = sAuctionMgr->GetAItem(Aentry->item_guidlow);
+        if (!item)
+            continue;
+
+        ItemTemplate const* proto = item->GetTemplate();
+
+        if (itemClass != 0xffffffff && proto->Class != itemClass)
+            continue;
+
+        if (itemSubClass != 0xffffffff && proto->SubClass != itemSubClass)
+            continue;
+
+        if (inventoryType != 0xffffffff && proto->InventoryType != inventoryType)
+		{
+			// xinef: exception, robes are counted as chests
+			if (inventoryType != INVTYPE_CHEST || proto->InventoryType != INVTYPE_ROBE)
+				continue;
+		}
+
+        if (quality != 0xffffffff && proto->Quality != quality)
+            continue;
+
+        if (levelmin != 0x00 && (proto->RequiredLevel < levelmin || (levelmax != 0x00 && proto->RequiredLevel > levelmax)))
+            continue;
+
+        if (usable != 0x00)
+		{
+			if (player->CanUseItem(item) != EQUIP_ERR_OK)
+				continue;
+
+			// xinef: check already learded recipes and pets
+			if (proto->Spells[1].SpellTrigger == ITEM_SPELLTRIGGER_LEARN_SPELL_ID && player->HasSpell(proto->Spells[1].SpellId))
+				continue;
+		}
+
+        // Allow search by suffix (ie: of the Monkey) or partial name (ie: Monkey)
+        // No need to do any of this if no search term was entered
+        if (!wsearchedname.empty())
+        {
+            std::string name = proto->Name1;
+            if (name.empty())
+                continue;
+
+            // DO NOT use GetItemEnchantMod(proto->RandomProperty) as it may return a result
+            //  that matches the search but it may not equal item->GetItemRandomPropertyId()
+            //  used in BuildAuctionInfo() which then causes wrong items to be listed
+            int32 propRefID = item->GetItemRandomPropertyId();
+
+            if (propRefID)
+            {
+                // Append the suffix to the name (ie: of the Monkey) if one exists
+                // These are found in ItemRandomSuffix.dbc and ItemRandomProperties.dbc
+                //  even though the DBC name seems misleading
+
+                char* const* suffix = NULL;
+
+                if (propRefID < 0)
+                {
+                    const ItemRandomSuffixEntry* itemRandEntry = sItemRandomSuffixStore.LookupEntry(-item->GetItemRandomPropertyId());
+                    if (itemRandEntry)
+                        suffix = itemRandEntry->nameSuffix;
+                }
+                else
+                {
+                    const ItemRandomPropertiesEntry* itemRandEntry = sItemRandomPropertiesStore.LookupEntry(item->GetItemRandomPropertyId());
+                    if (itemRandEntry)
+                        suffix = itemRandEntry->nameSuffix;
+                }
+
+                // dbc local name
+                if (suffix)
+                {
+                    // Append the suffix (ie: of the Monkey) to the name using localization
+                    // or default enUS if localization is invalid
+                    name += ' ';
+                    name += suffix[LOCALE_enUS];
+                }
+            }
+
+            // Perform the search (with or without suffix)
+            if (!Utf8FitTo(name, wsearchedname))
+                continue;
+        }
+
+        // Add the item if no search term or if entered search term was found
+        if (count < 50 && totalcount >= listfrom)
+        {
+            ++count;
+            Aentry->BuildAuctionInfo(data);
+        }
+        ++totalcount;
+    }
+
+	return true;
+}
+
+//this function inserts to WorldPacket auction's data
+bool AuctionEntry::BuildAuctionInfo(WorldPacket& data) const
+{
+    Item* item = sAuctionMgr->GetAItem(item_guidlow);
+    if (!item)
+    {
+        sLog->outError("AuctionEntry::BuildAuctionInfo: Auction %u has a non-existent item: %u", Id, item_guidlow);
+        return false;
+    }
+    data << uint32(Id);
+    data << uint32(item->GetEntry());
+
+    for (uint8 i = 0; i < MAX_INSPECTED_ENCHANTMENT_SLOT; ++i)
+    {
+        data << uint32(item->GetEnchantmentId(EnchantmentSlot(i)));
+        data << uint32(item->GetEnchantmentDuration(EnchantmentSlot(i)));
+        data << uint32(item->GetEnchantmentCharges(EnchantmentSlot(i)));
+    }
+
+    data << int32(item->GetItemRandomPropertyId());                 // Random item property id
+    data << uint32(item->GetItemSuffixFactor());                    // SuffixFactor
+    data << uint32(item->GetCount());                               // item->count
+    data << uint32(item->GetSpellCharges());                        // item->charge FFFFFFF
+    data << uint32(0);                                              // Unknown
+    data << uint64(owner);                                          // Auction->owner
+    data << uint32(startbid);                                       // Auction->startbid (not sure if useful)
+    data << uint32(bid ? GetAuctionOutBid() : 0);
+    // Minimal outbid
+    data << uint32(buyout);                                         // Auction->buyout
+    data << uint32((expire_time - time(NULL)) * IN_MILLISECONDS);   // time left
+    data << uint64(bidder);                                         // auction->bidder current
+    data << uint32(bid);                                            // current bid
+    return true;
+}
+
+uint32 AuctionEntry::GetAuctionCut() const
+{
+    int32 cut = int32(CalculatePct(bid, auctionHouseEntry->cutPercent) * sWorld->getRate(RATE_AUCTION_CUT));
+    return std::max(cut, 0);
+}
+
+/// the sum of outbid is (1% from current bid)*5, if bid is very small, it is 1c
+uint32 AuctionEntry::GetAuctionOutBid() const
+{
+    uint32 outbid = CalculatePct(bid, 5);
+    return outbid ? outbid : 1;
+}
+
+void AuctionEntry::DeleteFromDB(SQLTransaction& trans) const
+{
+    PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_AUCTION);
+    stmt->setUInt32(0, Id);
+    trans->Append(stmt);
+}
+
+void AuctionEntry::SaveToDB(SQLTransaction& trans) const
+{
+    PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_INS_AUCTION);
+    stmt->setUInt32(0, Id);
+    stmt->setUInt32(1, auctioneer);
+    stmt->setUInt32(2, item_guidlow);
+    stmt->setUInt32(3, owner);
+    stmt->setUInt32 (4, buyout);
+    stmt->setUInt32(5, uint32(expire_time));
+    stmt->setUInt32(6, bidder);
+    stmt->setUInt32 (7, bid);
+    stmt->setUInt32 (8, startbid);
+    stmt->setUInt32 (9, deposit);
+    trans->Append(stmt);
+}
+
+bool AuctionEntry::LoadFromDB(Field* fields)
+{
+    Id = fields[0].GetUInt32();
+    auctioneer = fields[1].GetUInt32();
+    item_guidlow = fields[2].GetUInt32();
+    item_template = fields[3].GetUInt32();
+    itemCount = fields[4].GetUInt32();
+    owner = fields[5].GetUInt32();
+    buyout = fields[6].GetUInt32();
+    expire_time = fields[7].GetUInt32();
+    bidder = fields[8].GetUInt32();
+    bid = fields[9].GetUInt32();
+    startbid = fields[10].GetUInt32();
+    deposit = fields[11].GetUInt32();
+
+    CreatureData const* auctioneerData = sObjectMgr->GetCreatureData(auctioneer);
+    if (!auctioneerData)
+    {
+        sLog->outError("Auction %u has not a existing auctioneer (GUID : %u)", Id, auctioneer);
+        return false;
+    }
+
+    CreatureTemplate const* auctioneerInfo = sObjectMgr->GetCreatureTemplate(auctioneerData->id);
+    if (!auctioneerInfo)
+    {
+        sLog->outError("Auction %u has not a existing auctioneer (GUID : %u Entry: %u)", Id, auctioneer, auctioneerData->id);
+        return false;
+    }
+
+    factionTemplateId = auctioneerInfo->faction;
+    auctionHouseEntry = AuctionHouseMgr::GetAuctionHouseEntry(factionTemplateId);
+    if (!auctionHouseEntry)
+    {
+        sLog->outError("Auction %u has auctioneer (GUID : %u Entry: %u) with wrong faction %u", Id, auctioneer, auctioneerData->id, factionTemplateId);
+        return false;
+    }
+
+    // check if sold item exists for guid
+    // and item_template in fact (GetAItem will fail if problematic in result check in AuctionHouseMgr::LoadAuctionItems)
+    if (!sAuctionMgr->GetAItem(item_guidlow))
+    {
+        sLog->outError("Auction %u has not a existing item : %u", Id, item_guidlow);
+        return false;
+    }
+    return true;
+}
+
+bool AuctionEntry::LoadFromFieldList(Field* fields)
+{
+    // Loads an AuctionEntry item from a field list. Unlike "LoadFromDB()", this one
+    //  does not require the AuctionEntryMap to have been loaded with items. It simply
+    //  acts as a wrapper to fill out an AuctionEntry struct from a field list
+
+    Id = fields[0].GetUInt32();
+    auctioneer = fields[1].GetUInt32();
+    item_guidlow = fields[2].GetUInt32();
+    item_template = fields[3].GetUInt32();
+    itemCount = fields[4].GetUInt32();
+    owner = fields[5].GetUInt32();
+    buyout = fields[6].GetUInt32();
+    expire_time = fields[7].GetUInt32();
+    bidder = fields[8].GetUInt32();
+    bid = fields[9].GetUInt32();
+    startbid = fields[10].GetUInt32();
+    deposit = fields[11].GetUInt32();
+
+    CreatureData const* auctioneerData = sObjectMgr->GetCreatureData(auctioneer);
+    if (!auctioneerData)
+    {
+        sLog->outError("AuctionEntry::LoadFromFieldList() - Auction %u has not a existing auctioneer (GUID : %u)", Id, auctioneer);
+        return false;
+    }
+
+    CreatureTemplate const* auctioneerInfo = sObjectMgr->GetCreatureTemplate(auctioneerData->id);
+    if (!auctioneerInfo)
+    {
+        sLog->outError("AuctionEntry::LoadFromFieldList() - Auction %u has not a existing auctioneer (GUID : %u Entry: %u)", Id, auctioneer, auctioneerData->id);
+        return false;
+    }
+
+    factionTemplateId = auctioneerInfo->faction;
+    auctionHouseEntry = AuctionHouseMgr::GetAuctionHouseEntry(factionTemplateId);
+
+    if (!auctionHouseEntry)
+    {
+        sLog->outError("AuctionEntry::LoadFromFieldList() - Auction %u has auctioneer (GUID : %u Entry: %u) with wrong faction %u", Id, auctioneer, auctioneerData->id, factionTemplateId);
+        return false;
+    }
+
+    return true;
+}
+
+std::string AuctionEntry::BuildAuctionMailSubject(MailAuctionAnswers response) const
+{
+    std::ostringstream strm;
+    strm << item_template << ":0:" << response << ':' << Id << ':' << itemCount;
+    return strm.str();
+}
+
+std::string AuctionEntry::BuildAuctionMailBody(uint32 lowGuid, uint32 bid, uint32 buyout, uint32 deposit, uint32 cut)
+{
+    std::ostringstream strm;
+    strm.width(16);
+    strm << std::right << std::hex << MAKE_NEW_GUID(lowGuid, 0, HIGHGUID_PLAYER);   // HIGHGUID_PLAYER always present, even for empty guids
+    strm << std::dec << ':' << bid << ':' << buyout;
+    strm << ':' << deposit << ':' << cut;
+    return strm.str();
+}

src/server/game/AuctionHouse/AuctionHouseMgr.h

@@ -0,0 +1,201 @@
+/*
+ * Copyright (C) 
+ * Copyright (C) 
+ *
+ * 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef _AUCTION_HOUSE_MGR_H
+#define _AUCTION_HOUSE_MGR_H
+
+#include <ace/Singleton.h>
+
+#include "Common.h"
+#include "DatabaseEnv.h"
+#include "DBCStructure.h"
+#include "EventProcessor.h"
+#include "WorldPacket.h"
+
+class Item;
+class Player;
+
+#define MIN_AUCTION_TIME (12*HOUR)
+#define MAX_AUCTION_ITEMS 160
+
+enum AuctionError
+{
+    ERR_AUCTION_OK                  = 0,
+    ERR_AUCTION_INVENTORY           = 1,
+    ERR_AUCTION_DATABASE_ERROR      = 2,
+    ERR_AUCTION_NOT_ENOUGHT_MONEY   = 3,
+    ERR_AUCTION_ITEM_NOT_FOUND      = 4,
+    ERR_AUCTION_HIGHER_BID          = 5,
+    ERR_AUCTION_BID_INCREMENT       = 7,
+    ERR_AUCTION_BID_OWN             = 10,
+    ERR_AUCTION_RESTRICTED_ACCOUNT  = 13
+};
+
+enum AuctionAction
+{
+    AUCTION_SELL_ITEM   = 0,
+    AUCTION_CANCEL      = 1,
+    AUCTION_PLACE_BID   = 2
+};
+
+enum MailAuctionAnswers
+{
+    AUCTION_OUTBIDDED           = 0,
+    AUCTION_WON                 = 1,
+    AUCTION_SUCCESSFUL          = 2,
+    AUCTION_EXPIRED             = 3,
+    AUCTION_CANCELLED_TO_BIDDER = 4,
+    AUCTION_CANCELED            = 5,
+    AUCTION_SALE_PENDING        = 6
+};
+
+struct AuctionEntry
+{
+    uint32 Id;
+    uint32 auctioneer;                                      // creature low guid
+    uint32 item_guidlow;
+    uint32 item_template;
+    uint32 itemCount;
+    uint32 owner;
+    uint32 startbid;                                        //maybe useless
+    uint32 bid;
+    uint32 buyout;
+    time_t expire_time;
+    uint32 bidder;
+    uint32 deposit;                                         //deposit can be calculated only when creating auction
+    AuctionHouseEntry const* auctionHouseEntry;             // in AuctionHouse.dbc
+    uint32 factionTemplateId;
+
+    // helpers
+    uint32 GetHouseId() const { return auctionHouseEntry->houseId; }
+    uint32 GetHouseFaction() const { return auctionHouseEntry->faction; }
+    uint32 GetAuctionCut() const;
+    uint32 GetAuctionOutBid() const;
+    bool BuildAuctionInfo(WorldPacket & data) const;
+    void DeleteFromDB(SQLTransaction& trans) const;
+    void SaveToDB(SQLTransaction& trans) const;
+    bool LoadFromDB(Field* fields);
+    bool LoadFromFieldList(Field* fields);
+    std::string BuildAuctionMailSubject(MailAuctionAnswers response) const;
+    static std::string BuildAuctionMailBody(uint32 lowGuid, uint32 bid, uint32 buyout, uint32 deposit, uint32 cut);
+
+};
+
+//this class is used as auctionhouse instance
+class AuctionHouseObject
+{
+  public:
+    // Initialize storage
+    AuctionHouseObject() { next = AuctionsMap.begin(); }
+    ~AuctionHouseObject()
+    {
+        for (AuctionEntryMap::iterator itr = AuctionsMap.begin(); itr != AuctionsMap.end(); ++itr)
+            delete itr->second;
+    }
+
+    typedef std::map<uint32, AuctionEntry*> AuctionEntryMap;
+
+    uint32 Getcount() const { return AuctionsMap.size(); }
+
+    AuctionEntryMap::iterator GetAuctionsBegin() {return AuctionsMap.begin();}
+    AuctionEntryMap::iterator GetAuctionsEnd() {return AuctionsMap.end();}
+
+    AuctionEntry* GetAuction(uint32 id) const
+    {
+        AuctionEntryMap::const_iterator itr = AuctionsMap.find(id);
+        return itr != AuctionsMap.end() ? itr->second : NULL;
+    }
+
+    void AddAuction(AuctionEntry* auction);
+
+    bool RemoveAuction(AuctionEntry* auction);
+
+    void Update();
+
+    void BuildListBidderItems(WorldPacket& data, Player* player, uint32& count, uint32& totalcount);
+    void BuildListOwnerItems(WorldPacket& data, Player* player, uint32& count, uint32& totalcount);
+    bool BuildListAuctionItems(WorldPacket& data, Player* player,
+        std::wstring const& searchedname, uint32 listfrom, uint8 levelmin, uint8 levelmax, uint8 usable,
+        uint32 inventoryType, uint32 itemClass, uint32 itemSubClass, uint32 quality,
+        uint32& count, uint32& totalcount, uint8 getAll);
+
+  private:
+    AuctionEntryMap AuctionsMap;
+
+    // storage for "next" auction item for next Update()
+    AuctionEntryMap::const_iterator next;
+};
+
+class AuctionHouseMgr
+{
+    friend class ACE_Singleton<AuctionHouseMgr, ACE_Null_Mutex>;
+
+    private:
+        AuctionHouseMgr();
+        ~AuctionHouseMgr();
+
+    public:
+
+        typedef UNORDERED_MAP<uint32, Item*> ItemMap;
+
+        AuctionHouseObject* GetAuctionsMap(uint32 factionTemplateId);
+        AuctionHouseObject* GetBidsMap(uint32 factionTemplateId);
+
+        Item* GetAItem(uint32 id)
+        {
+            ItemMap::const_iterator itr = mAitems.find(id);
+            if (itr != mAitems.end())
+                return itr->second;
+
+            return NULL;
+        }
+
+        //auction messages
+        void SendAuctionWonMail(AuctionEntry* auction, SQLTransaction& trans);
+        void SendAuctionSalePendingMail(AuctionEntry* auction, SQLTransaction& trans);
+        void SendAuctionSuccessfulMail(AuctionEntry* auction, SQLTransaction& trans);
+        void SendAuctionExpiredMail(AuctionEntry* auction, SQLTransaction& trans);
+        void SendAuctionOutbiddedMail(AuctionEntry* auction, uint32 newPrice, Player* newBidder, SQLTransaction& trans);
+        void SendAuctionCancelledToBidderMail(AuctionEntry* auction, SQLTransaction& trans);
+
+        static uint32 GetAuctionDeposit(AuctionHouseEntry const* entry, uint32 time, Item* pItem, uint32 count);
+        static AuctionHouseEntry const* GetAuctionHouseEntry(uint32 factionTemplateId);
+
+    public:
+
+        //load first auction items, because of check if item exists, when loading
+        void LoadAuctionItems();
+        void LoadAuctions();
+
+        void AddAItem(Item* it);
+        bool RemoveAItem(uint32 id, bool deleteFromDB = false);
+
+        void Update();
+
+    private:
+
+        AuctionHouseObject mHordeAuctions;
+        AuctionHouseObject mAllianceAuctions;
+        AuctionHouseObject mNeutralAuctions;
+
+        ItemMap mAitems;
+};
+
+#define sAuctionMgr ACE_Singleton<AuctionHouseMgr, ACE_Null_Mutex>::instance()
+
+#endif

src/server/game/Battlefield/Battlefield.h

@@ -0,0 +1,436 @@
+/*
+ * Copyright (C) 
+ * Copyright (C) 
+ *
+ * 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef BATTLEFIELD_H_
+#define BATTLEFIELD_H_
+
+#include "Utilities/Util.h"
+#include "SharedDefines.h"
+#include "ZoneScript.h"
+#include "WorldPacket.h"
+#include "GameObject.h"
+#include "Battleground.h"
+#include "ObjectAccessor.h"
+
+enum BattlefieldTypes
+{
+    BATTLEFIELD_WG,                                         // Wintergrasp
+    BATTLEFIELD_TB,                                         // Tol Barad (cataclysm)
+};
+
+enum BattlefieldIDs
+{
+    BATTLEFIELD_BATTLEID_WG                      = 1,       // Wintergrasp battle 
+};
+
+enum BattlefieldObjectiveStates
+{
+    BF_CAPTUREPOINT_OBJECTIVESTATE_NEUTRAL = 0,
+    BF_CAPTUREPOINT_OBJECTIVESTATE_ALLIANCE,
+    BF_CAPTUREPOINT_OBJECTIVESTATE_HORDE,
+    BF_CAPTUREPOINT_OBJECTIVESTATE_NEUTRAL_ALLIANCE_CHALLENGE,
+    BF_CAPTUREPOINT_OBJECTIVESTATE_NEUTRAL_HORDE_CHALLENGE,
+    BF_CAPTUREPOINT_OBJECTIVESTATE_ALLIANCE_HORDE_CHALLENGE,
+    BF_CAPTUREPOINT_OBJECTIVESTATE_HORDE_ALLIANCE_CHALLENGE,
+};
+
+enum BattlefieldSounds
+{
+    BF_HORDE_WINS                                = 8454,
+    BF_ALLIANCE_WINS                             = 8455,
+    BF_START                                     = 3439
+};
+
+enum BattlefieldTimers
+{
+    BATTLEFIELD_OBJECTIVE_UPDATE_INTERVAL        = 1000
+};
+
+
+const uint32 BattlefieldFactions[BG_TEAMS_COUNT] =
+{
+    1732, // Alliance
+    1735  // Horde
+};
+
+// some class predefs
+class Player;
+class GameObject;
+class WorldPacket;
+class Creature;
+class Unit;
+
+class Battlefield;
+class BfGraveyard;
+
+typedef UNORDERED_SET<uint64> GuidSet;
+typedef std::vector<BfGraveyard*> GraveyardVect;
+typedef std::map<uint64, time_t> PlayerTimerMap;
+
+class BfCapturePoint
+{
+    public:
+        BfCapturePoint(Battlefield* bf);
+
+        virtual void FillInitialWorldStates(WorldPacket& /*data*/) {}
+
+        // Send world state update to all players present
+        void SendUpdateWorldState(uint32 field, uint32 value);
+
+        // Send kill notify to players in the controlling faction
+        void SendObjectiveComplete(uint32 id, uint64 guid);
+
+        // Used when player is activated/inactivated in the area
+        virtual bool HandlePlayerEnter(Player* player);
+        virtual GuidSet::iterator HandlePlayerLeave(Player* player);
+        //virtual void HandlePlayerActivityChanged(Player* player);
+
+        // Checks if player is in range of a capture credit marker
+        bool IsInsideObjective(Player* player) const;
+
+        // Returns true if the state of the objective has changed, in this case, the OutdoorPvP must send a world state ui update.
+        virtual bool Update(uint32 diff);
+        virtual void ChangeTeam(TeamId /*oldTeam*/) {}
+        virtual void SendChangePhase();
+
+        bool SetCapturePointData(GameObject* capturePoint);
+        GameObject* GetCapturePointGo() { return ObjectAccessor::GetObjectInWorld(m_capturePoint, (GameObject*)NULL); }
+		GameObject* GetCapturePointGo(WorldObject* obj) { return ObjectAccessor::GetGameObject(*obj, m_capturePoint); }
+
+        TeamId GetTeamId() { return m_team; }
+    protected:
+        bool DelCapturePoint();
+
+        // active Players in the area of the objective, 0 - alliance, 1 - horde
+        GuidSet m_activePlayers[2];
+
+        // Total shift needed to capture the objective
+        float m_maxValue;
+        float m_minValue;
+
+        // Maximum speed of capture
+        float m_maxSpeed;
+
+        // The status of the objective
+        float m_value;
+        TeamId m_team;
+
+        // Objective states
+        BattlefieldObjectiveStates m_OldState;
+        BattlefieldObjectiveStates m_State;
+
+        // Neutral value on capture bar
+        uint32 m_neutralValuePct;
+
+        // Pointer to the Battlefield this objective belongs to
+        Battlefield* m_Bf;
+
+        // Capture point entry
+        uint32 m_capturePointEntry;
+
+        // Gameobject related to that capture point
+        uint64 m_capturePoint;
+};
+
+class BfGraveyard
+{
+    public:
+        BfGraveyard(Battlefield* Bf);
+
+        // Method to changing who controls the graveyard
+        void GiveControlTo(TeamId team);
+        TeamId GetControlTeamId() const { return m_ControlTeam; }
+
+        // Find the nearest graveyard to a player
+        float GetDistance(Player* player);
+
+        // Initialize the graveyard
+        void Initialize(TeamId startcontrol, uint32 gy);
+
+        // Set spirit service for the graveyard
+        void SetSpirit(Creature* spirit, TeamId team);
+
+        // Add a player to the graveyard
+        void AddPlayer(uint64 player_guid);
+
+        // Remove a player from the graveyard
+        void RemovePlayer(uint64 player_guid);
+
+        // Resurrect players
+        void Resurrect();
+
+        // Move players waiting to that graveyard on the nearest one
+        void RelocateDeadPlayers();
+
+        // Check if this graveyard has a spirit guide
+        bool HasNpc(uint64 guid)
+        {
+            if (!m_SpiritGuide[0] && !m_SpiritGuide[1])
+                return false;
+
+			// performance
+            /*if (!ObjectAccessor::FindUnit(m_SpiritGuide[0]) &&
+                !ObjectAccessor::FindUnit(m_SpiritGuide[1]))
+                return false;*/
+
+            return (m_SpiritGuide[0] == guid || m_SpiritGuide[1] == guid);
+        }
+
+        // Check if a player is in this graveyard's resurrect queue
+        bool HasPlayer(uint64 guid) const { return m_ResurrectQueue.find(guid) != m_ResurrectQueue.end(); }
+
+        // Get the graveyard's ID.
+        uint32 GetGraveyardId() const { return m_GraveyardId; }
+
+    protected:
+        TeamId m_ControlTeam;
+        uint32 m_GraveyardId;
+        uint64 m_SpiritGuide[2];
+        GuidSet m_ResurrectQueue;
+        Battlefield* m_Bf;
+};
+
+class Battlefield : public ZoneScript
+{
+    friend class BattlefieldMgr;
+
+    public:
+        /// Constructor
+        Battlefield();
+        /// Destructor
+        virtual ~Battlefield();
+
+        /// typedef of map witch store capturepoint and the associate gameobject entry
+        typedef std::map<uint32 /*lowguid */, BfCapturePoint*> BfCapturePointMap;
+
+        /// Call this to init the Battlefield
+        virtual bool SetupBattlefield() { return true; }
+
+        /// Update data of a worldstate to all players present in zone
+        void SendUpdateWorldState(uint32 field, uint32 value);
+
+        /**
+         * \brief Called every time for update bf data and time
+         * - Update timer for start/end battle
+         * - Invite player in zone to queue m_StartGroupingTimer minutes before start
+         * - Kick Afk players
+         * \param diff : time ellapsed since last call (in ms)
+         */
+        virtual bool Update(uint32 diff);
+
+        /// Invite all players in zone to join the queue, called x minutes before battle start in Update()
+        void InvitePlayersInZoneToQueue();
+        /// Invite all players in queue to join battle on battle start
+        void InvitePlayersInQueueToWar();
+        /// Invite all players in zone to join battle on battle start
+        void InvitePlayersInZoneToWar();
+
+        /// Called when a Unit is kill in battlefield zone
+        virtual void HandleKill(Player* /*killer*/, Unit* /*killed*/) {};
+
+        uint32 GetTypeId() { return m_TypeId; }
+        uint32 GetZoneId() { return m_ZoneId; }
+
+        void TeamApplyBuff(TeamId team, uint32 spellId, uint32 spellId2 = 0);
+
+        /// Return true if battle is start, false if battle is not started
+        bool IsWarTime() { return m_isActive; }
+
+        /// Enable or Disable battlefield
+        void ToggleBattlefield(bool enable) { m_IsEnabled = enable; }
+        /// Return if battlefield is enable
+        bool IsEnabled() { return m_IsEnabled; }
+
+        /**
+         * \brief Kick player from battlefield and teleport him to kick-point location
+         * \param guid : guid of player who must be kick
+         */
+        void KickPlayerFromBattlefield(uint64 guid);
+
+        /// Called when player (player) enter in zone
+        void HandlePlayerEnterZone(Player* player, uint32 zone);
+        /// Called when player (player) leave the zone
+        void HandlePlayerLeaveZone(Player* player, uint32 zone);
+
+        // All-purpose data storage 64 bit
+        virtual uint64 GetData64(uint32 dataId) const { return m_Data64[dataId]; }
+        virtual void SetData64(uint32 dataId, uint64 value) { m_Data64[dataId] = value; }
+
+        // All-purpose data storage 32 bit
+        virtual uint32 GetData(uint32 dataId) const { return m_Data32[dataId]; }
+        virtual void SetData(uint32 dataId, uint32 value) { m_Data32[dataId] = value; }
+        virtual void UpdateData(uint32 index, int32 pad) { m_Data32[index] += pad; }
+
+        // Battlefield - generic methods
+        TeamId GetDefenderTeam() { return m_DefenderTeam; }
+        TeamId GetAttackerTeam() { return TeamId(1 - m_DefenderTeam); }
+        TeamId GetOtherTeam(TeamId team) { return (team == TEAM_HORDE ? TEAM_ALLIANCE : TEAM_HORDE); }
+        void SetDefenderTeam(TeamId team) { m_DefenderTeam = team; }
+
+        // Group methods
+        /**
+         * \brief Find a not full battlefield group, if there is no, create one
+         * \param TeamId : Id of player team for who we search a group (player->GetTeamId())
+         */
+        Group* GetFreeBfRaid(TeamId TeamId);
+        /// Return battlefield group where player is.
+        Group* GetGroupPlayer(uint64 guid, TeamId TeamId);
+        /// Force player to join a battlefield group
+        bool AddOrSetPlayerToCorrectBfGroup(Player* player);
+
+        // Graveyard methods
+        // Find which graveyard the player must be teleported to to be resurrected by spiritguide
+        WorldSafeLocsEntry const * GetClosestGraveyard(Player* player);
+
+        virtual void AddPlayerToResurrectQueue(uint64 npc_guid, uint64 player_guid);
+        void RemovePlayerFromResurrectQueue(uint64 player_guid);
+        void SetGraveyardNumber(uint32 number) { m_GraveyardList.resize(number); }
+        BfGraveyard* GetGraveyardById(uint32 id) const;
+
+        // Misc methods
+        Creature* SpawnCreature(uint32 entry, float x, float y, float z, float o, TeamId teamId);
+        Creature* SpawnCreature(uint32 entry, Position pos, TeamId teamId);
+        GameObject* SpawnGameObject(uint32 entry, float x, float y, float z, float o);
+
+        // Script-methods
+
+        /// Called on start
+        virtual void OnBattleStart() {};
+        /// Called at the end of battle
+        virtual void OnBattleEnd(bool /*endByTimer*/) {};
+        /// Called x minutes before battle start when player in zone are invite to join queue
+        virtual void OnStartGrouping() {};
+        /// Called when a player accept to join the battle
+        virtual void OnPlayerJoinWar(Player* /*player*/) {};
+        /// Called when a player leave the battle
+        virtual void OnPlayerLeaveWar(Player* /*player*/) {};
+        /// Called when a player leave battlefield zone
+        virtual void OnPlayerLeaveZone(Player* /*player*/) {};
+        /// Called when a player enter in battlefield zone
+        virtual void OnPlayerEnterZone(Player* /*player*/) {};
+
+        void SendWarningToAllInZone(uint32 entry);
+        void SendWarningToPlayer(Player* player, uint32 entry);
+
+        void PlayerAcceptInviteToQueue(Player* player);
+        void PlayerAcceptInviteToWar(Player* player);
+        uint32 GetBattleId() { return m_BattleId; }
+        void AskToLeaveQueue(Player* player);
+
+        //virtual void DoCompleteOrIncrementAchievement(uint32 /*achievement*/, Player* /*player*/, uint8 /*incrementNumber = 1*/) {};
+
+        /// Send all worldstate data to all player in zone.
+        virtual void SendInitWorldStatesToAll() = 0;	
+        virtual void FillInitialWorldStates(WorldPacket& /*data*/) = 0;
+
+        /// Return if we can use mount in battlefield
+        bool CanFlyIn() { return !m_isActive; }
+
+        void SendAreaSpiritHealerQueryOpcode(Player* player, const uint64 & guid);
+
+        void StartBattle();
+        void EndBattle(bool endByTimer);
+
+        void HideNpc(Creature* creature);
+        void ShowNpc(Creature* creature, bool aggressive);
+
+        GraveyardVect GetGraveyardVector() { return m_GraveyardList; }
+
+        uint32 GetTimer() { return m_Timer; }
+        void SetTimer(uint32 timer) { m_Timer = timer; }
+
+        void DoPlaySoundToAll(uint32 SoundID);
+
+        void InvitePlayerToQueue(Player* player);
+        void InvitePlayerToWar(Player* player);
+
+        void InitStalker(uint32 entry, float x, float y, float z, float o);
+
+    protected:
+        uint64 StalkerGuid;
+        uint32 m_Timer;                                         // Global timer for event
+        bool m_IsEnabled;
+        bool m_isActive;
+        TeamId m_DefenderTeam;
+
+        // Map of the objectives belonging to this OutdoorPvP
+        BfCapturePointMap m_capturePoints;
+
+        // Players info maps
+        GuidSet m_players[BG_TEAMS_COUNT];                      // Players in zone
+        GuidSet m_PlayersInQueue[BG_TEAMS_COUNT];               // Players in the queue
+        GuidSet m_PlayersInWar[BG_TEAMS_COUNT];                 // Players in WG combat
+        PlayerTimerMap m_InvitedPlayers[BG_TEAMS_COUNT];
+        PlayerTimerMap m_PlayersWillBeKick[BG_TEAMS_COUNT];
+
+        // Variables that must exist for each battlefield
+        uint32 m_TypeId;                                        // See enum BattlefieldTypes
+        uint32 m_BattleId;                                      // BattleID (for packet)
+        uint32 m_ZoneId;                                        // ZoneID of Wintergrasp = 4197
+        uint32 m_MapId;                                         // MapId where is Battlefield
+        uint32 m_MaxPlayer;                                     // Maximum number of player that participated to Battlefield
+        uint32 m_MinPlayer;                                     // Minimum number of player for Battlefield start
+        uint32 m_MinLevel;                                      // Required level to participate at Battlefield
+        uint32 m_BattleTime;                                    // Length of a battle
+        uint32 m_NoWarBattleTime;                               // Time between two battles
+        uint32 m_RestartAfterCrash;                             // Delay to restart Wintergrasp if the server crashed during a running battle.
+        uint32 m_TimeForAcceptInvite;
+        uint32 m_uiKickDontAcceptTimer;
+        WorldLocation KickPosition;                             // Position where players are teleported if they switch to afk during the battle or if they don't accept invitation
+
+        uint32 m_uiKickAfkPlayersTimer;                         // Timer for check Afk in war
+
+        // Graveyard variables
+        GraveyardVect m_GraveyardList;                          // Vector witch contain the different GY of the battle
+        uint32 m_LastResurectTimer;                             // Timer for resurect player every 30 sec
+
+        uint32 m_StartGroupingTimer;                            // Timer for invite players in area 15 minute before start battle
+        bool m_StartGrouping;                                   // bool for know if all players in area has been invited
+
+        GuidSet m_Groups[BG_TEAMS_COUNT];                       // Contain different raid group
+
+        std::vector<uint64> m_Data64;
+        std::vector<uint32> m_Data32;
+
+        void KickAfkPlayers();
+
+        // use for switch off all worldstate for client
+        virtual void SendRemoveWorldStates(Player* /*player*/) {}
+
+        // use for send a packet for all player list
+        void BroadcastPacketToZone(WorldPacket& data) const;
+        void BroadcastPacketToQueue(WorldPacket& data) const;
+        void BroadcastPacketToWar(WorldPacket& data) const;
+
+        // CapturePoint system
+        void AddCapturePoint(BfCapturePoint* cp, GameObject* go) { m_capturePoints[go->GetEntry()] = cp; }
+
+        BfCapturePoint* GetCapturePoint(uint32 lowguid) const
+        {
+            Battlefield::BfCapturePointMap::const_iterator itr = m_capturePoints.find(lowguid);
+            if (itr != m_capturePoints.end())
+                return itr->second;
+            return NULL;
+        }
+
+        void RegisterZone(uint32 zoneid);
+        bool HasPlayer(Player* player) const;
+        void TeamCastSpell(TeamId team, int32 spellId);
+};
+
+#endif

src/server/game/Battlefield/BattlefieldHandler.cpp

@@ -0,0 +1,151 @@
+/*
+ * Copyright (C) 
+ * Copyright (C) 
+ *
+ * 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "Common.h"
+#include "ObjectAccessor.h"
+#include "ObjectMgr.h"
+#include "WorldPacket.h"
+#include "WorldSession.h"
+
+#include "Battlefield.h"
+#include "BattlefieldMgr.h"
+#include "Opcodes.h"
+#include "Player.h"
+
+//This send to player windows for invite player to join the war
+//Param1:(BattleId) the BattleId of Bf
+//Param2:(ZoneId) the zone where the battle is (4197 for wg)
+//Param3:(time) Time in second that the player have for accept
+void WorldSession::SendBfInvitePlayerToWar(uint32 BattleId, uint32 ZoneId, uint32 p_time)
+{
+    //Send packet 
+    WorldPacket data(SMSG_BATTLEFIELD_MGR_ENTRY_INVITE, 12);
+    data << uint32(BattleId);
+    data << uint32(ZoneId);
+    data << uint32((time(NULL) + p_time));
+
+    //Sending the packet to player
+    SendPacket(&data);
+}
+
+//This send invitation to player to join the queue
+//Param1:(BattleId) the BattleId of Bf
+void WorldSession::SendBfInvitePlayerToQueue(uint32 BattleId)
+{
+    WorldPacket data(SMSG_BATTLEFIELD_MGR_QUEUE_INVITE, 5);
+
+    data << uint32(BattleId);
+    data << uint8(1);                                       //warmup ? used ?
+
+    //Sending packet to player
+    SendPacket(&data);
+}
+
+//This send packet for inform player that he join queue
+//Param1:(BattleId) the BattleId of Bf
+//Param2:(ZoneId) the zone where the battle is (4197 for wg)
+//Param3:(CanQueue) if able to queue
+//Param4:(Full) on log in is full
+void WorldSession::SendBfQueueInviteResponse(uint32 BattleId,uint32 ZoneId, bool CanQueue, bool Full)
+{
+    WorldPacket data(SMSG_BATTLEFIELD_MGR_QUEUE_REQUEST_RESPONSE, 11);
+    data << uint32(BattleId);
+    data << uint32(ZoneId);
+    data << uint8((CanQueue ? 1 : 0));  //Accepted          //0 you cannot queue wg     //1 you are queued     
+    data << uint8((Full ? 0 : 1));      //Logging In        //0 wg full                 //1 queue for upcoming
+    data << uint8(1); //Warmup
+    SendPacket(&data);
+}
+
+//This is call when player accept to join war 
+//Param1:(BattleId) the BattleId of Bf
+void WorldSession::SendBfEntered(uint32 BattleId)
+{
+//    m_PlayerInWar[player->GetTeamId()].insert(player->GetGUID());
+    WorldPacket data(SMSG_BATTLEFIELD_MGR_ENTERED, 7);
+    data << uint32(BattleId);
+    data << uint8(1);                                       //unk
+    data << uint8(1);                                       //unk
+    data << uint8(_player->isAFK() ? 1 : 0);                //Clear AFK
+    SendPacket(&data);
+}
+
+void WorldSession::SendBfLeaveMessage(uint32 BattleId, BFLeaveReason reason)
+{
+    WorldPacket data(SMSG_BATTLEFIELD_MGR_EJECTED, 7);
+    data << uint32(BattleId);
+    data << uint8(reason);//byte Reason
+    data << uint8(2);//byte BattleStatus
+    data << uint8(0);//bool Relocated
+    SendPacket(&data);
+}
+
+//Send by client when he click on accept for queue
+void WorldSession::HandleBfQueueInviteResponse(WorldPacket & recvData)
+{
+    uint32 BattleId;
+    uint8 Accepted;
+
+    recvData >> BattleId >> Accepted;
+    //sLog->outError("HandleQueueInviteResponse: BattleID:%u Accepted:%u", BattleId, Accepted);
+    Battlefield* Bf = sBattlefieldMgr->GetBattlefieldByBattleId(BattleId);
+    if (!Bf)
+        return;
+
+    if (Accepted)
+    {
+        Bf->PlayerAcceptInviteToQueue(_player);
+    }
+}
+
+//Send by client on clicking in accept or refuse of invitation windows for join game
+void WorldSession::HandleBfEntryInviteResponse(WorldPacket & recvData)
+{
+    uint32 BattleId;
+    uint8 Accepted;
+
+    recvData >> BattleId >> Accepted;
+    //sLog->outError("HandleBattlefieldInviteResponse: BattleID:%u Accepted:%u", BattleId, Accepted);
+    Battlefield* Bf = sBattlefieldMgr->GetBattlefieldByBattleId(BattleId);
+    if (!Bf)
+        return;
+
+    //If player accept invitation
+    if (Accepted)
+    {
+        Bf->PlayerAcceptInviteToWar(_player);
+    }
+    else
+    {
+        if (_player->GetZoneId() == Bf->GetZoneId())
+            Bf->KickPlayerFromBattlefield(_player->GetGUID());
+    }
+}
+
+void WorldSession::HandleBfExitRequest(WorldPacket & recvData)
+{
+    uint32 BattleId;
+
+    recvData >> BattleId;
+    //sLog->outError("HandleBfExitRequest: BattleID:%u ", BattleId);
+    Battlefield* Bf = sBattlefieldMgr->GetBattlefieldByBattleId(BattleId);
+    if (!Bf)
+        return;
+
+    Bf->AskToLeaveQueue(_player);
+}

src/server/game/Battlefield/BattlefieldMgr.cpp

@@ -0,0 +1,142 @@
+/*
+ * Copyright (C) 
+ * Copyright (C) 
+ *
+ * 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "BattlefieldMgr.h"
+#include "Zones/BattlefieldWG.h"
+#include "ObjectMgr.h"
+#include "Player.h"
+
+BattlefieldMgr::BattlefieldMgr()
+{
+    m_UpdateTimer = 0;
+    //sLog->outDebug(LOG_FILTER_BATTLEFIELD, "Instantiating BattlefieldMgr");
+}
+
+BattlefieldMgr::~BattlefieldMgr()
+{
+    //sLog->outDebug(LOG_FILTER_BATTLEFIELD, "Deleting BattlefieldMgr");
+    for (BattlefieldSet::iterator itr = m_BattlefieldSet.begin(); itr != m_BattlefieldSet.end(); ++itr)
+        delete *itr;
+}
+
+void BattlefieldMgr::InitBattlefield()
+{
+    Battlefield* pBf = new BattlefieldWG;
+    // respawn, init variables
+    if (!pBf->SetupBattlefield())
+    {
+        sLog->outString();
+        sLog->outString("Battlefield : Wintergrasp init failed.");
+        delete pBf;
+    }
+    else
+    {
+        m_BattlefieldSet.push_back(pBf);
+        sLog->outString();
+        sLog->outString("Battlefield : Wintergrasp successfully initiated.");
+    }
+
+    /* For Cataclysm: Tol Barad
+       pBf = new BattlefieldTB;
+       // respawn, init variables
+       if(!pBf->SetupBattlefield())
+       {
+       ;//sLog->outDebug(LOG_FILTER_BATTLEFIELD, "Battlefield : Tol Barad init failed.");
+       delete pBf;
+       }
+       else
+       {
+       m_BattlefieldSet.push_back(pBf);
+       ;//sLog->outDebug(LOG_FILTER_BATTLEFIELD, "Battlefield : Tol Barad successfully initiated.");
+       } */
+}
+
+void BattlefieldMgr::AddZone(uint32 zoneid, Battlefield *handle)
+{
+    m_BattlefieldMap[zoneid] = handle;
+}
+
+void BattlefieldMgr::HandlePlayerEnterZone(Player * player, uint32 zoneid)
+{
+    BattlefieldMap::iterator itr = m_BattlefieldMap.find(zoneid);
+    if (itr == m_BattlefieldMap.end())
+        return;
+
+    if (itr->second->HasPlayer(player) || !itr->second->IsEnabled())
+        return;
+
+    itr->second->HandlePlayerEnterZone(player, zoneid);
+    ;//sLog->outDebug(LOG_FILTER_BATTLEFIELD, "Player %u entered outdoorpvp id %u", player->GetGUIDLow(), itr->second->GetTypeId());
+}
+
+void BattlefieldMgr::HandlePlayerLeaveZone(Player * player, uint32 zoneid)
+{
+    BattlefieldMap::iterator itr = m_BattlefieldMap.find(zoneid);
+    if (itr == m_BattlefieldMap.end())
+        return;
+
+    // teleport: remove once in removefromworld, once in updatezone
+    if (!itr->second->HasPlayer(player))
+        return;
+    itr->second->HandlePlayerLeaveZone(player, zoneid);
+    ;//sLog->outDebug(LOG_FILTER_BATTLEFIELD, "Player %u left outdoorpvp id %u", player->GetGUIDLow(), itr->second->GetTypeId());
+}
+
+Battlefield *BattlefieldMgr::GetBattlefieldToZoneId(uint32 zoneid)
+{
+    BattlefieldMap::iterator itr = m_BattlefieldMap.find(zoneid);
+    if (itr == m_BattlefieldMap.end())
+    {
+        // no handle for this zone, return
+        return NULL;
+    }
+    if (!itr->second->IsEnabled())
+        return NULL;
+    return itr->second;
+}
+
+Battlefield *BattlefieldMgr::GetBattlefieldByBattleId(uint32 battleid)
+{
+    for (BattlefieldSet::iterator itr = m_BattlefieldSet.begin(); itr != m_BattlefieldSet.end(); ++itr)
+    {
+        if ((*itr)->GetBattleId() == battleid)
+            return (*itr);
+    }
+    return NULL;
+}
+
+void BattlefieldMgr::Update(uint32 diff)
+{
+    m_UpdateTimer += diff;
+    if (m_UpdateTimer > BATTLEFIELD_OBJECTIVE_UPDATE_INTERVAL)
+    {
+        for (BattlefieldSet::iterator itr = m_BattlefieldSet.begin(); itr != m_BattlefieldSet.end(); ++itr)
+            //if ((*itr)->IsEnabled())
+                (*itr)->Update(m_UpdateTimer);
+        m_UpdateTimer = 0;
+    }
+}
+
+ZoneScript *BattlefieldMgr::GetZoneScript(uint32 zoneId)
+{
+    BattlefieldMap::iterator itr = m_BattlefieldMap.find(zoneId);
+    if (itr != m_BattlefieldMap.end())
+        return itr->second;
+    else
+        return NULL;
+}

src/server/game/Battlefield/BattlefieldMgr.h

@@ -0,0 +1,79 @@
+/*
+ * Copyright (C) 
+ * Copyright (C) 
+ *
+ * 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef BATTLEFIELD_MGR_H_
+#define BATTLEFIELD_MGR_H_
+
+#include "Battlefield.h"
+#include "ace/Singleton.h"
+
+class Player;
+class GameObject;
+class Creature;
+class ZoneScript;
+struct GossipMenuItems;
+
+// class to handle player enter / leave / areatrigger / GO use events
+class BattlefieldMgr
+{
+  public:
+    // ctor
+    BattlefieldMgr();
+    // dtor
+    ~BattlefieldMgr();
+
+    // create battlefield events
+    void InitBattlefield();
+    // called when a player enters an battlefield area
+    void HandlePlayerEnterZone(Player * player, uint32 areaflag);
+    // called when player leaves an battlefield area
+    void HandlePlayerLeaveZone(Player * player, uint32 areaflag);
+    // called when player resurrects
+    void HandlePlayerResurrects(Player * player, uint32 areaflag);
+    // return assigned battlefield
+    Battlefield* GetBattlefieldToZoneId(uint32 zoneid);
+    Battlefield* GetBattlefieldByBattleId(uint32 battleid);
+
+    ZoneScript* GetZoneScript(uint32 zoneId);
+
+    void AddZone(uint32 zoneid, Battlefield * handle);
+
+    void Update(uint32 diff);
+
+    void HandleGossipOption(Player * player, uint64 guid, uint32 gossipid);
+
+    bool CanTalkTo(Player * player, Creature * creature, GossipMenuItems gso);
+
+    void HandleDropFlag(Player * player, uint32 spellId);
+
+    typedef std::vector < Battlefield * >BattlefieldSet;
+    typedef std::map < uint32 /* zoneid */ , Battlefield * >BattlefieldMap;
+  private:
+    // contains all initiated battlefield events
+    // used when initing / cleaning up
+      BattlefieldSet m_BattlefieldSet;
+    // maps the zone ids to an battlefield event
+    // used in player event handling
+    BattlefieldMap m_BattlefieldMap;
+    // update interval
+    uint32 m_UpdateTimer;
+};
+
+#define sBattlefieldMgr ACE_Singleton<BattlefieldMgr, ACE_Null_Mutex>::instance()
+
+#endif

src/server/game/Battlegrounds/ArenaTeam.cpp

@@ -0,0 +1,913 @@
+/*
+ * Copyright (C) 
+ * Copyright (C) 
+ *
+ * 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "ObjectMgr.h"
+#include "WorldPacket.h"
+#include "ArenaTeam.h"
+#include "World.h"
+#include "Group.h"
+#include "ArenaTeamMgr.h"
+#include "Player.h"
+#include "WorldSession.h"
+#include "Opcodes.h"
+
+ArenaTeam::ArenaTeam()
+    : TeamId(0), Type(0), TeamName(), CaptainGuid(0), BackgroundColor(0), EmblemStyle(0), EmblemColor(0),
+    BorderStyle(0), BorderColor(0)
+{
+    Stats.WeekGames   = 0;
+    Stats.SeasonGames = 0;
+    Stats.Rank        = 0;
+    Stats.Rating      = sWorld->getIntConfig(CONFIG_ARENA_START_RATING);
+    Stats.WeekWins    = 0;
+    Stats.SeasonWins  = 0;
+}
+
+ArenaTeam::~ArenaTeam()
+{
+}
+
+bool ArenaTeam::Create(uint64 captainGuid, uint8 type, std::string const& teamName, uint32 backgroundColor, uint8 emblemStyle, uint32 emblemColor, uint8 borderStyle, uint32 borderColor)
+{
+    // Check if captain is present
+    if (!ObjectAccessor::FindPlayerInOrOutOfWorld(captainGuid))
+        return false;
+
+    // Check if arena team name is already taken
+    if (sArenaTeamMgr->GetArenaTeamByName(TeamName))
+        return false;
+
+    // Generate new arena team id
+    TeamId = sArenaTeamMgr->GenerateArenaTeamId();
+
+    // Assign member variables
+    CaptainGuid = captainGuid;
+    Type = type;
+    TeamName = teamName;
+    BackgroundColor = backgroundColor;
+    EmblemStyle = emblemStyle;
+    EmblemColor = emblemColor;
+    BorderStyle = borderStyle;
+    BorderColor = borderColor;
+    uint32 captainLowGuid = GUID_LOPART(captainGuid);
+
+    // Save arena team to db
+    PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_INS_ARENA_TEAM);
+    stmt->setUInt32(0, TeamId);
+    stmt->setString(1, TeamName);
+    stmt->setUInt32(2, captainLowGuid);
+    stmt->setUInt8(3, Type);
+    stmt->setUInt16(4, Stats.Rating);
+    stmt->setUInt32(5, BackgroundColor);
+    stmt->setUInt8(6, EmblemStyle);
+    stmt->setUInt32(7, EmblemColor);
+    stmt->setUInt8(8, BorderStyle);
+    stmt->setUInt32(9, BorderColor);
+    CharacterDatabase.Execute(stmt);
+
+    // Add captain as member
+    AddMember(CaptainGuid);
+    return true;
+}
+
+bool ArenaTeam::AddMember(uint64 playerGuid)
+{
+    std::string playerName;
+    uint8 playerClass;
+
+    // Check if arena team is full (Can't have more than type * 2 players)
+    if (GetMembersSize() >= GetType() * 2)
+        return false;
+
+	// xinef: Get player name and class from player storage or global data storage
+    Player* player = ObjectAccessor::FindPlayerInOrOutOfWorld(playerGuid);
+    if (player)
+    {
+        playerClass = player->getClass();
+        playerName = player->GetName();
+    }
+    else
+    {
+		GlobalPlayerData const* playerData = sWorld->GetGlobalPlayerData(GUID_LOPART(playerGuid));
+		if (!playerData)
+			return false;
+
+		playerName = playerData->name;
+		playerClass = playerData->playerClass;
+    }
+
+    // Check if player is already in a similar arena team
+    if ((player && player->GetArenaTeamId(GetSlot())) || Player::GetArenaTeamIdFromStorage(GUID_LOPART(playerGuid), GetSlot()) != 0)
+    {
+        sLog->outError("Arena: Player %s (guid: %u) already has an arena team of type %u", playerName.c_str(), GUID_LOPART(playerGuid), GetType());
+        return false;
+    }
+
+    // Set player's personal rating
+    uint32 personalRating = 0;
+
+    if (sWorld->getIntConfig(CONFIG_ARENA_START_PERSONAL_RATING) > 0)
+        personalRating = sWorld->getIntConfig(CONFIG_ARENA_START_PERSONAL_RATING);
+    else if (GetRating() >= 1000)
+        personalRating = 1000;
+
+	// xinef: zomg! sync query
+    // Try to get player's match maker rating from db and fall back to config setting if not found
+    PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_MATCH_MAKER_RATING);
+    stmt->setUInt32(0, GUID_LOPART(playerGuid));
+    stmt->setUInt8(1, GetSlot());
+    PreparedQueryResult result = CharacterDatabase.Query(stmt);
+
+    uint16 matchMakerRating;
+    uint16 maxMMR;
+    if (result)
+    {
+        matchMakerRating = (*result)[0].GetUInt16();
+        uint16 Max = (*result)[1].GetUInt16();
+        maxMMR = std::max(Max, matchMakerRating);
+    }
+    else
+    {
+        matchMakerRating = sWorld->getIntConfig(CONFIG_ARENA_START_MATCHMAKER_RATING);
+        maxMMR = matchMakerRating;
+    }
+
+    // Remove all player signatures from other petitions
+    // This will prevent player from joining too many arena teams and corrupt arena team data integrity
+    Player::RemovePetitionsAndSigns(playerGuid, GetType());
+
+    // Feed data to the struct
+    ArenaTeamMember newMember;
+    //newMember.Name             = playerName;
+    newMember.Guid             = playerGuid;
+    newMember.Class            = playerClass;
+    newMember.SeasonGames      = 0;
+    newMember.WeekGames        = 0;
+    newMember.SeasonWins       = 0;
+    newMember.WeekWins         = 0;
+    newMember.PersonalRating   = personalRating;
+    newMember.MatchMakerRating = matchMakerRating;
+	newMember.MaxMMR           = maxMMR;
+
+    Members.push_back(newMember);
+	sWorld->UpdateGlobalPlayerArenaTeam(GUID_LOPART(playerGuid), GetSlot(), GetId());
+
+    // Save player's arena team membership to db
+    stmt = CharacterDatabase.GetPreparedStatement(CHAR_INS_ARENA_TEAM_MEMBER);
+    stmt->setUInt32(0, TeamId);
+    stmt->setUInt32(1, GUID_LOPART(playerGuid));
+    CharacterDatabase.Execute(stmt);
+
+    // Inform player if online
+    if (player)
+    {
+        player->SetInArenaTeam(TeamId, GetSlot(), GetType());
+        player->SetArenaTeamIdInvited(0);
+
+        // Hide promote/remove buttons
+        if (CaptainGuid != playerGuid)
+            player->SetArenaTeamInfoField(GetSlot(), ARENA_TEAM_MEMBER, 1);
+    }
+
+    return true;
+}
+
+bool ArenaTeam::LoadArenaTeamFromDB(QueryResult result)
+{
+    if (!result)
+        return false;
+
+    Field* fields = result->Fetch();
+
+    TeamId            = fields[0].GetUInt32();
+    TeamName          = fields[1].GetString();
+    CaptainGuid       = MAKE_NEW_GUID(fields[2].GetUInt32(), 0, HIGHGUID_PLAYER);
+    Type              = fields[3].GetUInt8();
+    BackgroundColor   = fields[4].GetUInt32();
+    EmblemStyle       = fields[5].GetUInt8();
+    EmblemColor       = fields[6].GetUInt32();
+    BorderStyle       = fields[7].GetUInt8();
+    BorderColor       = fields[8].GetUInt32();
+    Stats.Rating      = fields[9].GetUInt16();
+    Stats.WeekGames   = fields[10].GetUInt16();
+    Stats.WeekWins    = fields[11].GetUInt16();
+    Stats.SeasonGames = fields[12].GetUInt16();
+    Stats.SeasonWins  = fields[13].GetUInt16();
+    Stats.Rank        = fields[14].GetUInt32();
+
+    return true;
+}
+
+bool ArenaTeam::LoadMembersFromDB(QueryResult result)
+{
+    if (!result)
+        return false;
+
+    bool captainPresentInTeam = false;
+
+    do
+    {
+        Field* fields = result->Fetch();
+
+        // Prevent crash if db records are broken when all members in result are already processed and current team doesn't have any members
+        if (!fields)
+            break;
+
+        uint32 arenaTeamId = fields[0].GetUInt32();
+
+        // We loaded all members for this arena_team already, break cycle
+        if (arenaTeamId > TeamId)
+            break;
+
+        ArenaTeamMember newMember;
+        newMember.Guid             = MAKE_NEW_GUID(fields[1].GetUInt32(), 0, HIGHGUID_PLAYER);
+        newMember.WeekGames        = fields[2].GetUInt16();
+        newMember.WeekWins         = fields[3].GetUInt16();
+        newMember.SeasonGames      = fields[4].GetUInt16();
+        newMember.SeasonWins       = fields[5].GetUInt16();
+        //newMember.Name             = fields[6].GetString();
+        newMember.Class            = fields[7].GetUInt8();
+        newMember.PersonalRating   = fields[8].GetUInt16();
+        newMember.MatchMakerRating = fields[9].GetUInt16() > 0 ? fields[9].GetUInt16() : sWorld->getIntConfig(CONFIG_ARENA_START_MATCHMAKER_RATING);;
+		newMember.MaxMMR           = std::max(fields[10].GetUInt16(), newMember.MatchMakerRating);
+
+        // Delete member if character information is missing
+        if (fields[6].GetString().empty())
+        {
+            sLog->outErrorDb("ArenaTeam %u has member with empty name - probably player %u doesn't exist, deleting him from memberlist!", arenaTeamId, GUID_LOPART(newMember.Guid));
+            this->DelMember(newMember.Guid, true);
+            continue;
+        }
+
+        // Check if team team has a valid captain
+        if (newMember.Guid == GetCaptain())
+            captainPresentInTeam = true;
+
+        // Put the player in the team
+        Members.push_back(newMember);
+		sWorld->UpdateGlobalPlayerArenaTeam(GUID_LOPART(newMember.Guid), GetSlot(), GetId());
+    }
+    while (result->NextRow());
+
+    if (Empty() || !captainPresentInTeam)
+    {
+        // Arena team is empty or captain is not in team, delete from db
+        ;//sLog->outDebug(LOG_FILTER_BATTLEGROUND, "ArenaTeam %u does not have any members or its captain is not in team, disbanding it...", TeamId);
+        return false;
+    }
+
+    return true;
+}
+
+void ArenaTeam::SetCaptain(uint64 guid)
+{
+    // Disable remove/promote buttons
+    Player* oldCaptain = ObjectAccessor::FindPlayerInOrOutOfWorld(GetCaptain());
+    if (oldCaptain)
+        oldCaptain->SetArenaTeamInfoField(GetSlot(), ARENA_TEAM_MEMBER, 1);
+
+    // Set new captain
+    CaptainGuid = guid;
+
+    // Update database
+    PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_UPD_ARENA_TEAM_CAPTAIN);
+    stmt->setUInt32(0, GUID_LOPART(guid));
+    stmt->setUInt32(1, GetId());
+    CharacterDatabase.Execute(stmt);
+
+    // Enable remove/promote buttons
+    if (Player* newCaptain = ObjectAccessor::FindPlayerInOrOutOfWorld(guid))
+    {
+        newCaptain->SetArenaTeamInfoField(GetSlot(), ARENA_TEAM_MEMBER, 0);
+        /*if (oldCaptain)
+        {
+            sLog->outDebug(LOG_FILTER_BATTLEGROUND, "Player: %s [GUID: %u] promoted player: %s [GUID: %u] to leader of arena team [Id: %u] [Type: %u].",
+                oldCaptain->GetName().c_str(), oldCaptain->GetGUIDLow(), newCaptain->GetName().c_str(),
+                newCaptain->GetGUIDLow(), GetId(), GetType());
+        }*/
+    }
+}
+
+void ArenaTeam::DelMember(uint64 guid, bool cleanDb)
+{
+    // Remove member from team
+    for (MemberList::iterator itr = Members.begin(); itr != Members.end(); ++itr)
+        if (itr->Guid == guid)
+        {
+            Members.erase(itr);
+			sWorld->UpdateGlobalPlayerArenaTeam(GUID_LOPART(guid), GetSlot(), 0);
+            break;
+        }
+
+    // Inform player and remove arena team info from player data
+    if (Player* player = ObjectAccessor::FindPlayerInOrOutOfWorld(guid))
+    {
+        player->GetSession()->SendArenaTeamCommandResult(ERR_ARENA_TEAM_QUIT_S, GetName(), "", 0);
+        // delete all info regarding this team
+        for (uint32 i = 0; i < ARENA_TEAM_END; ++i)
+            player->SetArenaTeamInfoField(GetSlot(), ArenaTeamInfoType(i), 0);
+    }
+
+    // Only used for single member deletion, for arena team disband we use a single query for more efficiency
+    if (cleanDb)
+    {
+        PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_ARENA_TEAM_MEMBER);
+        stmt->setUInt32(0, GetId());
+        stmt->setUInt32(1, GUID_LOPART(guid));
+        CharacterDatabase.Execute(stmt);
+    }
+}
+
+void ArenaTeam::Disband(WorldSession* session)
+{
+    // Remove all members from arena team
+    while (!Members.empty())
+        DelMember(Members.front().Guid, false);
+
+    // Broadcast update
+    if (session)
+    {
+        BroadcastEvent(ERR_ARENA_TEAM_DISBANDED_S, 0, 2, session->GetPlayerName(), GetName(), "");
+    }
+
+    // Update database
+    SQLTransaction trans = CharacterDatabase.BeginTransaction();
+
+    PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_ARENA_TEAM);
+    stmt->setUInt32(0, TeamId);
+    trans->Append(stmt);
+
+    stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_ARENA_TEAM_MEMBERS);
+    stmt->setUInt32(0, TeamId);
+    trans->Append(stmt);
+
+    CharacterDatabase.CommitTransaction(trans);
+
+    // Remove arena team from ObjectMgr
+    sArenaTeamMgr->RemoveArenaTeam(TeamId);
+}
+
+void ArenaTeam::Roster(WorldSession* session)
+{
+    Player* player = NULL;
+
+    uint8 unk308 = 0;
+	std::string tempName;
+
+    WorldPacket data(SMSG_ARENA_TEAM_ROSTER, 100);
+    data << uint32(GetId());                                // team id
+    data << uint8(unk308);                                  // 308 unknown value but affect packet structure
+    data << uint32(GetMembersSize());                       // members count
+    data << uint32(GetType());                              // arena team type?
+
+    for (MemberList::const_iterator itr = Members.begin(); itr != Members.end(); ++itr)
+    {
+        player = ObjectAccessor::FindPlayerInOrOutOfWorld(itr->Guid);
+
+        data << uint64(itr->Guid);                          // guid
+        data << uint8((player ? 1 : 0));                        // online flag
+		tempName = "";
+		sObjectMgr->GetPlayerNameByGUID(itr->Guid, tempName);
+		data << tempName;                                  // member name
+        data << uint32((itr->Guid == GetCaptain() ? 0 : 1));// captain flag 0 captain 1 member
+        data << uint8((player ? player->getLevel() : 0));           // unknown, level?
+        data << uint8(itr->Class);                         // class
+        data << uint32(itr->WeekGames);                    // played this week
+        data << uint32(itr->WeekWins);                     // wins this week
+        data << uint32(itr->SeasonGames);                  // played this season
+        data << uint32(itr->SeasonWins);                   // wins this season
+        data << uint32(itr->PersonalRating);               // personal rating
+        if (unk308)
+        {
+            data << float(0.0f);                           // 308 unk
+            data << float(0.0f);                           // 308 unk
+        }
+    }
+
+    session->SendPacket(&data);
+    ;//sLog->outDebug(LOG_FILTER_NETWORKIO, "WORLD: Sent SMSG_ARENA_TEAM_ROSTER");
+}
+
+void ArenaTeam::Query(WorldSession* session)
+{
+    WorldPacket data(SMSG_ARENA_TEAM_QUERY_RESPONSE, 4*7+GetName().size()+1);
+    data << uint32(GetId());                                // team id
+    data << GetName();                                      // team name
+    data << uint32(GetType());                              // arena team type (2=2x2, 3=3x3 or 5=5x5)
+    data << uint32(BackgroundColor);                        // background color
+    data << uint32(EmblemStyle);                            // emblem style
+    data << uint32(EmblemColor);                            // emblem color
+    data << uint32(BorderStyle);                            // border style
+    data << uint32(BorderColor);                            // border color
+    session->SendPacket(&data);
+    ;//sLog->outDebug(LOG_FILTER_NETWORKIO, "WORLD: Sent SMSG_ARENA_TEAM_QUERY_RESPONSE");
+}
+
+void ArenaTeam::SendStats(WorldSession* session)
+{
+    WorldPacket data(SMSG_ARENA_TEAM_STATS, 4*7);
+    data << uint32(GetId());                                // team id
+    data << uint32(Stats.Rating);                           // rating
+    data << uint32(Stats.WeekGames);                        // games this week
+    data << uint32(Stats.WeekWins);                         // wins this week
+    data << uint32(Stats.SeasonGames);                      // played this season
+    data << uint32(Stats.SeasonWins);                       // wins this season
+    data << uint32(Stats.Rank);                             // rank
+    session->SendPacket(&data);
+}
+
+void ArenaTeam::NotifyStatsChanged()
+{
+    // This is called after a rated match ended
+    // Updates arena team stats for every member of the team (not only the ones who participated!)
+    for (MemberList::const_iterator itr = Members.begin(); itr != Members.end(); ++itr)
+        if (Player* player = ObjectAccessor::FindPlayerInOrOutOfWorld(itr->Guid))
+            SendStats(player->GetSession());
+}
+
+void ArenaTeam::Inspect(WorldSession* session, uint64 guid)
+{
+    ArenaTeamMember* member = GetMember(guid);
+    if (!member)
+        return;
+
+    WorldPacket data(MSG_INSPECT_ARENA_TEAMS, 8+1+4*6);
+    data << uint64(guid);                                   // player guid
+    data << uint8(GetSlot());                               // slot (0...2)
+    data << uint32(GetId());                                // arena team id
+    data << uint32(Stats.Rating);                           // rating
+    data << uint32(Stats.SeasonGames);                      // season played
+    data << uint32(Stats.SeasonWins);                       // season wins
+    data << uint32(member->SeasonGames);                    // played (count of all games, that the inspected member participated...)
+    data << uint32(member->PersonalRating);                 // personal rating
+    session->SendPacket(&data);
+}
+
+void ArenaTeamMember::ModifyPersonalRating(Player* player, int32 mod, uint32 type)
+{
+    if (int32(PersonalRating) + mod < 0)
+        PersonalRating = 0;
+    else
+        PersonalRating += mod;
+
+    if (player)
+    {
+        player->SetArenaTeamInfoField(ArenaTeam::GetSlotByType(type), ARENA_TEAM_PERSONAL_RATING, PersonalRating);
+        player->UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_HIGHEST_PERSONAL_RATING, PersonalRating, type);
+    }
+}
+
+void ArenaTeamMember::ModifyMatchmakerRating(int32 mod, uint32 /*slot*/)
+{
+	if (mod < 0)
+	{
+		// pussywizard: prevent lowering MMR too much from max achieved MMR
+		int32 maxAllowedDrop = (int32)sWorld->getIntConfig(CONFIG_MAX_ALLOWED_MMR_DROP);
+		mod = std::min<int32>(std::max<int32>(-((int32)MatchMakerRating - (int32)MaxMMR + maxAllowedDrop), mod), 0);
+	}
+
+    if (int32(MatchMakerRating) + mod < 0)
+        MatchMakerRating = 0;
+    else
+        MatchMakerRating += mod;
+
+	if (MatchMakerRating > MaxMMR)
+		MaxMMR = MatchMakerRating;
+}
+
+void ArenaTeam::BroadcastPacket(WorldPacket* packet)
+{
+    for (MemberList::const_iterator itr = Members.begin(); itr != Members.end(); ++itr)
+        if (Player* player = ObjectAccessor::FindPlayerInOrOutOfWorld(itr->Guid))
+            player->GetSession()->SendPacket(packet);
+}
+
+void ArenaTeam::BroadcastEvent(ArenaTeamEvents event, uint64 guid, uint8 strCount, std::string const& str1, std::string const& str2, std::string const& str3)
+{
+    WorldPacket data(SMSG_ARENA_TEAM_EVENT, 1+1+1);
+    data << uint8(event);
+    data << uint8(strCount);
+    switch (strCount)
+    {
+        case 0:
+            break;
+        case 1:
+            data << str1;
+            break;
+        case 2:
+            data << str1 << str2;
+            break;
+        case 3:
+            data << str1 << str2 << str3;
+            break;
+        default:
+            sLog->outError("Unhandled strCount %u in ArenaTeam::BroadcastEvent", strCount);
+            return;
+    }
+
+    if (guid)
+        data << uint64(guid);
+
+    BroadcastPacket(&data);
+
+    ;//sLog->outDebug(LOG_FILTER_NETWORKIO, "WORLD: Sent SMSG_ARENA_TEAM_EVENT");
+}
+
+void ArenaTeam::MassInviteToEvent(WorldSession* session)
+{
+    WorldPacket data(SMSG_CALENDAR_ARENA_TEAM, (Members.size() - 1) * (4 + 8 + 1));
+    data << uint32(Members.size() - 1);
+
+    for (MemberList::const_iterator itr = Members.begin(); itr != Members.end(); ++itr)
+    {
+        if (itr->Guid != session->GetPlayer()->GetGUID())
+        {
+            data.appendPackGUID(itr->Guid);
+            data << uint8(0); // unk
+        }
+    }
+
+    session->SendPacket(&data);
+}
+
+uint8 ArenaTeam::GetSlotByType(uint32 type)
+{
+    switch (type)
+    {
+        case ARENA_TEAM_2v2: return 0;
+        case ARENA_TEAM_3v3: return 1;
+        case ARENA_TEAM_5v5: return 2;
+        default:
+            break;
+    }
+    sLog->outError("FATAL: Unknown arena team type %u for some arena team", type);
+    return 0xFF;
+}
+
+bool ArenaTeam::IsMember(uint64 guid) const
+{
+    for (MemberList::const_iterator itr = Members.begin(); itr != Members.end(); ++itr)
+        if (itr->Guid == guid)
+            return true;
+
+    return false;
+}
+
+uint32 ArenaTeam::GetPoints(uint32 memberRating)
+{
+    // Returns how many points would be awarded with this team type with this rating
+    float points;
+
+    uint32 rating = memberRating + 150 < Stats.Rating ? memberRating : Stats.Rating;
+
+    if (rating <= 1500)
+    {
+        if (sWorld->getIntConfig(CONFIG_ARENA_SEASON_ID) < 6)
+            points = (float)rating * 0.22f + 14.0f;
+        else
+            points = 344;
+    }
+    else
+        points = 1511.26f / (1.0f + 1639.28f * exp(-0.00412f * (float)rating));
+
+    // Type penalties for teams < 5v5
+    if (Type == ARENA_TEAM_2v2)
+        points *= 0.76f;
+    else if (Type == ARENA_TEAM_3v3)
+        points *= 0.88f;
+
+    return (uint32) points;
+}
+
+uint32 ArenaTeam::GetAverageMMR(Group* group) const
+{
+    if (!group)
+        return 0;
+
+    uint32 matchMakerRating = 0;
+    uint32 playerDivider = 0;
+    for (MemberList::const_iterator itr = Members.begin(); itr != Members.end(); ++itr)
+    {
+        // Skip if player is not online
+        if (!ObjectAccessor::FindPlayerInOrOutOfWorld(itr->Guid))
+            continue;
+
+        // Skip if player is not member of group
+        if (!group->IsMember(itr->Guid))
+            continue;
+
+        matchMakerRating += itr->MatchMakerRating;
+        ++playerDivider;
+    }
+
+    // x/0 = crash
+    if (playerDivider == 0)
+        playerDivider = 1;
+
+    matchMakerRating /= playerDivider;
+
+    return matchMakerRating;
+}
+
+float ArenaTeam::GetChanceAgainst(uint32 ownRating, uint32 opponentRating)
+{
+    // Returns the chance to win against a team with the given rating, used in the rating adjustment calculation
+    // ELO system
+    return 1.0f / (1.0f + exp(log(10.0f) * (float)((float)opponentRating - (float)ownRating) / 650.0f));
+}
+
+int32 ArenaTeam::GetMatchmakerRatingMod(uint32 ownRating, uint32 opponentRating, bool won /*, float& confidence_factor*/)
+{
+    // 'Chance' calculation - to beat the opponent
+    // This is a simulation. Not much info on how it really works
+    float chance = GetChanceAgainst(ownRating, opponentRating);
+    float won_mod = (won) ? 1.0f : 0.0f;
+    float mod = won_mod - chance;
+
+    // Work in progress:
+    /*
+    // This is a simulation, as there is not much info on how it really works
+    float confidence_mod = min(1.0f - fabs(mod), 0.5f);
+
+    // Apply confidence factor to the mod:
+    mod *= confidence_factor
+
+    // And only after that update the new confidence factor
+    confidence_factor -= ((confidence_factor - 1.0f) * confidence_mod) / confidence_factor;
+    */
+
+    // Real rating modification
+    mod *= 24.0f;
+
+    return (int32)ceil(mod);
+}
+
+int32 ArenaTeam::GetRatingMod(uint32 ownRating, uint32 opponentRating, bool won /*, float confidence_factor*/)
+{
+    // 'Chance' calculation - to beat the opponent
+    // This is a simulation. Not much info on how it really works
+    float chance = GetChanceAgainst(ownRating, opponentRating);
+    float won_mod = (won) ? 1.0f : 0.0f;
+
+    // Calculate the rating modification
+    float mod;
+
+    // TODO: Replace this hack with using the confidence factor (limiting the factor to 2.0f)
+    if (won && ownRating < 1300)
+    {
+        if (ownRating < 1000)
+            mod = 48.0f * (won_mod - chance);
+        else
+            mod = (24.0f + (24.0f * (1300.0f - float(ownRating)) / 300.0f)) * (won_mod - chance);
+    }
+    else
+        mod = 24.0f * (won_mod - chance);
+
+    return (int32)ceil(mod);
+}
+
+void ArenaTeam::FinishGame(int32 mod, const Map* bgMap)
+{
+    // Rating can only drop to 0
+    if (int32(Stats.Rating) + mod < 0)
+        Stats.Rating = 0;
+    else
+    {
+        Stats.Rating += mod;
+
+        // Check if rating related achivements are met
+        for (MemberList::iterator itr = Members.begin(); itr != Members.end(); ++itr)
+            if (Player* member = ObjectAccessor::FindPlayerInOrOutOfWorld(itr->Guid))
+                if (member->FindMap() == bgMap)
+                    member->UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_HIGHEST_TEAM_RATING, Stats.Rating, Type);
+    }
+
+    // Update number of games played per season or week
+    Stats.WeekGames += 1;
+    Stats.SeasonGames += 1;
+
+    // Update team's rank, start with rank 1 and increase until no team with more rating was found
+    Stats.Rank = 1;
+    ArenaTeamMgr::ArenaTeamContainer::const_iterator i = sArenaTeamMgr->GetArenaTeamMapBegin();
+    for (; i != sArenaTeamMgr->GetArenaTeamMapEnd(); ++i)
+    {
+        if (i->second->GetType() == Type && i->second->GetStats().Rating > Stats.Rating)
+            ++Stats.Rank;
+    }
+}
+
+int32 ArenaTeam::WonAgainst(uint32 Own_MMRating, uint32 Opponent_MMRating, int32& rating_change, const Map* bgMap)
+{
+    // Called when the team has won
+    // Change in Matchmaker rating
+    int32 mod = GetMatchmakerRatingMod(Own_MMRating, Opponent_MMRating, true);
+
+    // Change in Team Rating
+    rating_change = GetRatingMod(Stats.Rating, Opponent_MMRating, true);
+
+    // Modify the team stats accordingly
+    FinishGame(rating_change, bgMap);
+
+    // Update number of wins per season and week
+    Stats.WeekWins += 1;
+    Stats.SeasonWins += 1;
+
+    // Return the rating change, used to display it on the results screen
+    return mod;
+}
+
+int32 ArenaTeam::LostAgainst(uint32 Own_MMRating, uint32 Opponent_MMRating, int32& rating_change, const Map* bgMap)
+{
+    // Called when the team has lost
+    // Change in Matchmaker Rating
+    int32 mod = GetMatchmakerRatingMod(Own_MMRating, Opponent_MMRating, false);
+
+    // Change in Team Rating
+    rating_change = GetRatingMod(Stats.Rating, Opponent_MMRating, false);
+
+    // Modify the team stats accordingly
+    FinishGame(rating_change, bgMap);
+
+    // return the rating change, used to display it on the results screen
+    return mod;
+}
+
+void ArenaTeam::MemberLost(Player* player, uint32 againstMatchmakerRating, int32 MatchmakerRatingChange)
+{
+    // Called for each participant of a match after losing
+    for (MemberList::iterator itr = Members.begin(); itr != Members.end(); ++itr)
+    {
+        if (itr->Guid == player->GetGUID())
+        {
+            // Update personal rating
+            int32 mod = GetRatingMod(itr->PersonalRating, againstMatchmakerRating, false);
+            itr->ModifyPersonalRating(player, mod, GetType());
+
+            // Update matchmaker rating
+            itr->ModifyMatchmakerRating(MatchmakerRatingChange, GetSlot());
+
+            // Update personal played stats
+            itr->WeekGames +=1;
+            itr->SeasonGames +=1;
+
+            // update the unit fields
+            player->SetArenaTeamInfoField(GetSlot(), ARENA_TEAM_GAMES_WEEK,  itr->WeekGames);
+            player->SetArenaTeamInfoField(GetSlot(), ARENA_TEAM_GAMES_SEASON,  itr->SeasonGames);
+            return;
+        }
+    }
+}
+
+void ArenaTeam::MemberWon(Player* player, uint32 againstMatchmakerRating, int32 MatchmakerRatingChange)
+{
+    // called for each participant after winning a match
+    for (MemberList::iterator itr = Members.begin(); itr != Members.end(); ++itr)
+    {
+        if (itr->Guid == player->GetGUID())
+        {
+            // update personal rating
+            int32 mod = GetRatingMod(itr->PersonalRating, againstMatchmakerRating, true);
+            itr->ModifyPersonalRating(player, mod, GetType());
+
+            // update matchmaker rating (pussywizard: but don't allow it to go over team rating)
+			if (itr->MatchMakerRating < Stats.Rating)
+			{
+				mod = std::min(MatchmakerRatingChange, Stats.Rating - itr->MatchMakerRating);
+				itr->ModifyMatchmakerRating(mod, GetSlot());
+			}
+
+            // update personal stats
+            itr->WeekGames +=1;
+            itr->SeasonGames +=1;
+            itr->SeasonWins += 1;
+            itr->WeekWins += 1;
+            // update unit fields
+            player->SetArenaTeamInfoField(GetSlot(), ARENA_TEAM_GAMES_WEEK, itr->WeekGames);
+            player->SetArenaTeamInfoField(GetSlot(), ARENA_TEAM_GAMES_SEASON, itr->SeasonGames);
+            return;
+        }
+    }
+}
+
+void ArenaTeam::UpdateArenaPointsHelper(std::map<uint32, uint32>& playerPoints)
+{
+    // Called after a match has ended and the stats are already modified
+    // Helper function for arena point distribution (this way, when distributing, no actual calculation is required, just a few comparisons)
+    // 10 played games per week is a minimum
+    if (Stats.WeekGames < 10)
+        return;
+
+    // To get points, a player has to participate in at least 30% of the matches
+    uint32 requiredGames = (uint32)ceil(Stats.WeekGames * 0.3f);
+
+    for (MemberList::const_iterator itr = Members.begin(); itr != Members.end(); ++itr)
+    {
+        // The player participated in enough games, update his points
+        uint32 pointsToAdd = 0;
+        if (itr->WeekGames >= requiredGames)
+            pointsToAdd = GetPoints(itr->PersonalRating);
+
+        std::map<uint32, uint32>::iterator plr_itr = playerPoints.find(GUID_LOPART(itr->Guid));
+        if (plr_itr != playerPoints.end())
+        {
+            // Check if there is already more points
+            if (plr_itr->second < pointsToAdd)
+                playerPoints[GUID_LOPART(itr->Guid)] = pointsToAdd;
+        }
+        else
+            playerPoints[GUID_LOPART(itr->Guid)] = pointsToAdd;
+    }
+}
+
+void ArenaTeam::SaveToDB()
+{
+    // Save team and member stats to db
+    // Called after a match has ended or when calculating arena_points
+
+    SQLTransaction trans = CharacterDatabase.BeginTransaction();
+
+    PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_UPD_ARENA_TEAM_STATS);
+    stmt->setUInt16(0, Stats.Rating);
+    stmt->setUInt16(1, Stats.WeekGames);
+    stmt->setUInt16(2, Stats.WeekWins);
+    stmt->setUInt16(3, Stats.SeasonGames);
+    stmt->setUInt16(4, Stats.SeasonWins);
+    stmt->setUInt32(5, Stats.Rank);
+    stmt->setUInt32(6, GetId());
+    trans->Append(stmt);
+
+    for (MemberList::const_iterator itr = Members.begin(); itr != Members.end(); ++itr)
+    {
+        stmt = CharacterDatabase.GetPreparedStatement(CHAR_UPD_ARENA_TEAM_MEMBER);
+        stmt->setUInt16(0, itr->PersonalRating);
+        stmt->setUInt16(1, itr->WeekGames);
+        stmt->setUInt16(2, itr->WeekWins);
+        stmt->setUInt16(3, itr->SeasonGames);
+        stmt->setUInt16(4, itr->SeasonWins);
+        stmt->setUInt32(5, GetId());
+        stmt->setUInt32(6, GUID_LOPART(itr->Guid));
+        trans->Append(stmt);
+
+        stmt = CharacterDatabase.GetPreparedStatement(CHAR_REP_CHARACTER_ARENA_STATS);
+        stmt->setUInt32(0, GUID_LOPART(itr->Guid));
+        stmt->setUInt8(1, GetSlot());
+        stmt->setUInt16(2, itr->MatchMakerRating);
+		stmt->setUInt16(3, itr->MaxMMR);
+        trans->Append(stmt);
+    }
+
+    CharacterDatabase.CommitTransaction(trans);
+}
+
+void ArenaTeam::FinishWeek()
+{
+    // Reset team stats
+    Stats.WeekGames = 0;
+    Stats.WeekWins = 0;
+
+    // Reset member stats
+    for (MemberList::iterator itr = Members.begin(); itr != Members.end(); ++itr)
+    {
+        itr->WeekGames = 0;
+        itr->WeekWins = 0;
+    }
+}
+
+bool ArenaTeam::IsFighting() const
+{
+    for (MemberList::const_iterator itr = Members.begin(); itr != Members.end(); ++itr)
+        if (Player* player = ObjectAccessor::FindPlayer(itr->Guid))
+            if (player->GetMap()->IsBattleArena())
+                return true;
+
+    return false;
+}
+
+ArenaTeamMember* ArenaTeam::GetMember(const std::string& name)
+{
+	return GetMember(sObjectMgr->GetPlayerGUIDByName(name));
+}
+
+ArenaTeamMember* ArenaTeam::GetMember(uint64 guid)
+{
+    for (MemberList::iterator itr = Members.begin(); itr != Members.end(); ++itr)
+        if (itr->Guid == guid)
+            return &(*itr);
+
+    return NULL;
+}

src/server/game/Battlegrounds/ArenaTeam.h

@@ -0,0 +1,205 @@
+/*
+ * Copyright (C) 
+ * Copyright (C) 
+ *
+ * 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef SUNWELLCORE_ARENATEAM_H
+#define SUNWELLCORE_ARENATEAM_H
+
+#include "QueryResult.h"
+#include "Map.h"
+#include <ace/Singleton.h>
+#include <list>
+#include <map>
+
+class WorldSession;
+class WorldPacket;
+class Player;
+class Group;
+
+enum ArenaTeamCommandTypes
+{
+    ERR_ARENA_TEAM_CREATE_S                 = 0x00,
+    ERR_ARENA_TEAM_INVITE_SS                = 0x01,
+    ERR_ARENA_TEAM_QUIT_S                   = 0x03,
+    ERR_ARENA_TEAM_FOUNDER_S                = 0x0E
+};
+
+enum ArenaTeamCommandErrors
+{
+    ERR_ARENA_TEAM_INTERNAL                 = 0x01,
+    ERR_ALREADY_IN_ARENA_TEAM               = 0x02,
+    ERR_ALREADY_IN_ARENA_TEAM_S             = 0x03,
+    ERR_INVITED_TO_ARENA_TEAM               = 0x04,
+    ERR_ALREADY_INVITED_TO_ARENA_TEAM_S     = 0x05,
+    ERR_ARENA_TEAM_NAME_INVALID             = 0x06,
+    ERR_ARENA_TEAM_NAME_EXISTS_S            = 0x07,
+    ERR_ARENA_TEAM_LEADER_LEAVE_S           = 0x08,
+    ERR_ARENA_TEAM_PERMISSIONS              = 0x08,
+    ERR_ARENA_TEAM_PLAYER_NOT_IN_TEAM       = 0x09,
+    ERR_ARENA_TEAM_PLAYER_NOT_IN_TEAM_SS    = 0x0A,
+    ERR_ARENA_TEAM_PLAYER_NOT_FOUND_S       = 0x0B,
+    ERR_ARENA_TEAM_NOT_ALLIED               = 0x0C,
+    ERR_ARENA_TEAM_IGNORING_YOU_S           = 0x13,
+    ERR_ARENA_TEAM_TARGET_TOO_LOW_S         = 0x15,
+    ERR_ARENA_TEAM_TARGET_TOO_HIGH_S        = 0x16,
+    ERR_ARENA_TEAM_TOO_MANY_MEMBERS_S       = 0x17,
+    ERR_ARENA_TEAM_NOT_FOUND                = 0x1B,
+    ERR_ARENA_TEAMS_LOCKED                  = 0x1E
+};
+
+enum ArenaTeamEvents
+{
+    ERR_ARENA_TEAM_JOIN_SS                  = 3,            // player name + arena team name
+    ERR_ARENA_TEAM_LEAVE_SS                 = 4,            // player name + arena team name
+    ERR_ARENA_TEAM_REMOVE_SSS               = 5,            // player name + arena team name + captain name
+    ERR_ARENA_TEAM_LEADER_IS_SS             = 6,            // player name + arena team name
+    ERR_ARENA_TEAM_LEADER_CHANGED_SSS       = 7,            // old captain + new captain + arena team name
+    ERR_ARENA_TEAM_DISBANDED_S              = 8             // captain name + arena team name
+};
+
+/*
+need info how to send these ones:
+ERR_ARENA_TEAM_YOU_JOIN_S - client show it automatically when accept invite
+ERR_ARENA_TEAM_TARGET_TOO_LOW_S
+ERR_ARENA_TEAM_TOO_MANY_MEMBERS_S
+ERR_ARENA_TEAM_LEVEL_TOO_LOW_I
+*/
+
+enum ArenaTeamTypes
+{
+    ARENA_TEAM_2v2      = 2,
+    ARENA_TEAM_3v3      = 3,
+    ARENA_TEAM_5v5      = 5
+};
+
+struct ArenaTeamMember
+{
+    uint64 Guid;
+    //std::string Name;
+    uint8 Class;
+    uint16 WeekGames;
+    uint16 WeekWins;
+    uint16 SeasonGames;
+    uint16 SeasonWins;
+    uint16 PersonalRating;
+    uint16 MatchMakerRating;
+	uint16 MaxMMR;
+
+    void ModifyPersonalRating(Player* player, int32 mod, uint32 type);
+    void ModifyMatchmakerRating(int32 mod, uint32 slot);
+};
+
+struct ArenaTeamStats
+{
+    uint16 Rating;
+    uint16 WeekGames;
+    uint16 WeekWins;
+    uint16 SeasonGames;
+    uint16 SeasonWins;
+    uint32 Rank;
+};
+
+#define MAX_ARENA_SLOT 3                                    // 0..2 slots
+
+class ArenaTeam
+{
+    public:
+        ArenaTeam();
+        ~ArenaTeam();
+
+        bool Create(uint64 captainGuid, uint8 type, std::string const& teamName, uint32 backgroundColor, uint8 emblemStyle, uint32 emblemColor, uint8 borderStyle, uint32 borderColor);
+        void Disband(WorldSession* session);
+
+        typedef std::list<ArenaTeamMember> MemberList;
+
+        uint32 GetId() const              { return TeamId; }
+        uint32 GetType() const            { return Type; }
+        uint8  GetSlot() const            { return GetSlotByType(GetType()); }
+        static uint8 GetSlotByType(uint32 type);
+        uint64 GetCaptain() const  { return CaptainGuid; }
+        std::string const& GetName() const       { return TeamName; }
+        const ArenaTeamStats& GetStats() const { return Stats; }
+
+        uint32 GetRating() const          { return Stats.Rating; }
+        uint32 GetAverageMMR(Group* group) const;
+
+        void SetCaptain(uint64 guid);
+        bool AddMember(uint64 playerGuid);
+
+        // Shouldn't be uint64 ed, because than can reference guid from members on Disband
+        // and this method removes given record from list. So invalid reference can happen.
+        void DelMember(uint64 guid, bool cleanDb);
+
+        size_t GetMembersSize() const         { return Members.size(); }
+        bool   Empty() const                  { return Members.empty(); }
+        MemberList::iterator m_membersBegin() { return Members.begin(); }
+        MemberList::iterator m_membersEnd()   { return Members.end(); }
+        bool IsMember(uint64 guid) const;
+
+        ArenaTeamMember* GetMember(uint64 guid);
+        ArenaTeamMember* GetMember(std::string const& name);
+
+        bool IsFighting() const;
+
+        bool LoadArenaTeamFromDB(QueryResult arenaTeamDataResult);
+        bool LoadMembersFromDB(QueryResult arenaTeamMembersResult);
+        void LoadStatsFromDB(uint32 ArenaTeamId);
+        void SaveToDB();
+
+        void BroadcastPacket(WorldPacket* packet);
+        void BroadcastEvent(ArenaTeamEvents event, uint64 guid, uint8 strCount, std::string const& str1, std::string const& str2, std::string const& str3);
+        void NotifyStatsChanged();
+
+        void MassInviteToEvent(WorldSession* session);
+
+        void Roster(WorldSession* session);
+        void Query(WorldSession* session);
+        void SendStats(WorldSession* session);
+        void Inspect(WorldSession* session, uint64 guid);
+
+        uint32 GetPoints(uint32 MemberRating);
+        int32  GetMatchmakerRatingMod(uint32 ownRating, uint32 opponentRating, bool won);
+        int32  GetRatingMod(uint32 ownRating, uint32 opponentRating, bool won);
+        float  GetChanceAgainst(uint32 ownRating, uint32 opponentRating);
+        int32  WonAgainst(uint32 Own_MMRating, uint32 Opponent_MMRating, int32& rating_change, const Map* bgMap);
+        void   MemberWon(Player* player, uint32 againstMatchmakerRating, int32 MatchmakerRatingChange);
+        int32  LostAgainst(uint32 Own_MMRating, uint32 Opponent_MMRating, int32& rating_change, const Map* bgMap);
+        void   MemberLost(Player* player, uint32 againstMatchmakerRating, int32 MatchmakerRatingChange = -12);
+
+        void UpdateArenaPointsHelper(std::map<uint32, uint32> & PlayerPoints);
+
+        void FinishWeek();
+        void FinishGame(int32 mod, const Map* bgMap);
+
+    protected:
+
+        uint32      TeamId;
+        uint8       Type;
+        std::string TeamName;
+        uint64      CaptainGuid;
+
+        uint32 BackgroundColor; // ARGB format
+        uint8  EmblemStyle;     // icon id
+        uint32 EmblemColor;     // ARGB format
+        uint8  BorderStyle;     // border image id
+        uint32 BorderColor;     // ARGB format
+
+        MemberList     Members;
+        ArenaTeamStats Stats;
+};
+#endif
+

src/server/game/Battlegrounds/ArenaTeamMgr.cpp

@@ -0,0 +1,195 @@
+/*
+ * Copyright (C) 
+ *
+ * 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "Define.h"
+#include "ArenaTeamMgr.h"
+#include "World.h"
+#include "Log.h"
+#include "DatabaseEnv.h"
+#include "Language.h"
+#include "ObjectAccessor.h"
+#include "Player.h"
+
+ArenaTeamMgr::ArenaTeamMgr()
+{
+    NextArenaTeamId = 1;
+	LastArenaLogId = 0;
+}
+
+ArenaTeamMgr::~ArenaTeamMgr()
+{
+    for (ArenaTeamContainer::iterator itr = ArenaTeamStore.begin(); itr != ArenaTeamStore.end(); ++itr)
+        delete itr->second;
+}
+
+// Arena teams collection
+ArenaTeam* ArenaTeamMgr::GetArenaTeamById(uint32 arenaTeamId) const
+{
+    ArenaTeamContainer::const_iterator itr = ArenaTeamStore.find(arenaTeamId);
+    if (itr != ArenaTeamStore.end())
+        return itr->second;
+
+    return NULL;
+}
+
+ArenaTeam* ArenaTeamMgr::GetArenaTeamByName(const std::string& arenaTeamName) const
+{
+    std::string search = arenaTeamName;
+    std::transform(search.begin(), search.end(), search.begin(), ::toupper);
+    for (ArenaTeamContainer::const_iterator itr = ArenaTeamStore.begin(); itr != ArenaTeamStore.end(); ++itr)
+    {
+        std::string teamName = itr->second->GetName();
+        std::transform(teamName.begin(), teamName.end(), teamName.begin(), ::toupper);
+        if (search == teamName)
+            return itr->second;
+    }
+    return NULL;
+}
+
+ArenaTeam* ArenaTeamMgr::GetArenaTeamByCaptain(uint64 guid) const
+{
+    for (ArenaTeamContainer::const_iterator itr = ArenaTeamStore.begin(); itr != ArenaTeamStore.end(); ++itr)
+        if (itr->second->GetCaptain() == guid)
+            return itr->second;
+
+    return NULL;
+}
+
+void ArenaTeamMgr::AddArenaTeam(ArenaTeam* arenaTeam)
+{
+    ArenaTeamStore[arenaTeam->GetId()] = arenaTeam;
+}
+
+void ArenaTeamMgr::RemoveArenaTeam(uint32 arenaTeamId)
+{
+    ArenaTeamStore.erase(arenaTeamId);
+}
+
+uint32 ArenaTeamMgr::GenerateArenaTeamId()
+{
+    if (NextArenaTeamId >= 0xFFFFFFFE)
+    {
+        sLog->outError("Arena team ids overflow!! Can't continue, shutting down server. ");
+        World::StopNow(ERROR_EXIT_CODE);
+    }
+    return NextArenaTeamId++;
+}
+
+void ArenaTeamMgr::LoadArenaTeams()
+{
+    uint32 oldMSTime = getMSTime();
+
+    // Clean out the trash before loading anything
+    CharacterDatabase.Execute("DELETE FROM arena_team_member WHERE arenaTeamId NOT IN (SELECT arenaTeamId FROM arena_team)");       // One-time query
+
+    //                                                        0        1         2         3          4              5            6            7           8
+    QueryResult result = CharacterDatabase.Query("SELECT arenaTeamId, name, captainGuid, type, backgroundColor, emblemStyle, emblemColor, borderStyle, borderColor, "
+    //      9        10        11         12           13       14
+        "rating, weekGames, weekWins, seasonGames, seasonWins, rank FROM arena_team ORDER BY arenaTeamId ASC");
+
+    if (!result)
+    {
+        sLog->outString(">> Loaded 0 arena teams. DB table `arena_team` is empty!");
+        sLog->outString();
+        return;
+    }
+
+    QueryResult result2 = CharacterDatabase.Query(
+        //              0              1           2             3              4                 5          6     7          8                  9      10
+        "SELECT arenaTeamId, atm.guid, atm.weekGames, atm.weekWins, atm.seasonGames, atm.seasonWins, c.name, class, personalRating, matchMakerRating, maxMMR FROM arena_team_member atm"
+        " INNER JOIN arena_team ate USING (arenaTeamId)"
+        " LEFT JOIN characters AS c ON atm.guid = c.guid"
+        " LEFT JOIN character_arena_stats AS cas ON c.guid = cas.guid AND (cas.slot = 0 AND ate.type = 2 OR cas.slot = 1 AND ate.type = 3 OR cas.slot = 2 AND ate.type = 5)"
+        " ORDER BY atm.arenateamid ASC");
+
+    uint32 count = 0;
+    do
+    {
+        ArenaTeam* newArenaTeam = new ArenaTeam;
+
+        if (!newArenaTeam->LoadArenaTeamFromDB(result) || !newArenaTeam->LoadMembersFromDB(result2))
+        {
+            newArenaTeam->Disband(NULL);
+            delete newArenaTeam;
+            continue;
+        }
+
+        AddArenaTeam(newArenaTeam);
+
+        ++count;
+    }
+    while (result->NextRow());
+
+    sLog->outString(">> Loaded %u arena teams in %u ms", count, GetMSTimeDiffToNow(oldMSTime));
+    sLog->outString();
+}
+
+void ArenaTeamMgr::DistributeArenaPoints()
+{
+    // Used to distribute arena points based on last week's stats
+    sWorld->SendWorldText(LANG_DIST_ARENA_POINTS_START);
+
+    sWorld->SendWorldText(LANG_DIST_ARENA_POINTS_ONLINE_START);
+
+    // Temporary structure for storing maximum points to add values for all players
+    std::map<uint32, uint32> PlayerPoints;
+
+    // At first update all points for all team members
+    for (ArenaTeamContainer::iterator teamItr = GetArenaTeamMapBegin(); teamItr != GetArenaTeamMapEnd(); ++teamItr)
+        if (ArenaTeam* at = teamItr->second)
+            at->UpdateArenaPointsHelper(PlayerPoints);
+
+    SQLTransaction trans = CharacterDatabase.BeginTransaction();
+
+    PreparedStatement* stmt;
+
+    // Cycle that gives points to all players
+    for (std::map<uint32, uint32>::iterator playerItr = PlayerPoints.begin(); playerItr != PlayerPoints.end(); ++playerItr)
+    {
+        // Add points to player if online
+        if (Player* player = HashMapHolder<Player>::Find(playerItr->first))
+            player->ModifyArenaPoints(playerItr->second, &trans);
+        else    // Update database
+        {
+            stmt = CharacterDatabase.GetPreparedStatement(CHAR_UPD_CHAR_ARENA_POINTS);
+            stmt->setUInt32(0, playerItr->second);
+            stmt->setUInt32(1, playerItr->first);
+            trans->Append(stmt);
+        }
+    }
+
+    CharacterDatabase.CommitTransaction(trans);
+
+    PlayerPoints.clear();
+
+    sWorld->SendWorldText(LANG_DIST_ARENA_POINTS_ONLINE_END);
+
+    sWorld->SendWorldText(LANG_DIST_ARENA_POINTS_TEAM_START);
+    for (ArenaTeamContainer::iterator titr = GetArenaTeamMapBegin(); titr != GetArenaTeamMapEnd(); ++titr)
+    {
+        if (ArenaTeam* at = titr->second)
+        {
+            at->FinishWeek();
+            at->SaveToDB();
+            at->NotifyStatsChanged();
+        }
+    }
+
+    sWorld->SendWorldText(LANG_DIST_ARENA_POINTS_TEAM_END);
+
+    sWorld->SendWorldText(LANG_DIST_ARENA_POINTS_END);
+}

src/server/game/Battlegrounds/ArenaTeamMgr.h

@@ -0,0 +1,59 @@
+/*
+ * Copyright (C) 
+ *
+ * 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef _ARENATEAMMGR_H
+#define _ARENATEAMMGR_H
+
+#include "ArenaTeam.h"
+
+class ArenaTeamMgr
+{
+    friend class ACE_Singleton<ArenaTeamMgr, ACE_Null_Mutex>;
+    ArenaTeamMgr();
+    ~ArenaTeamMgr();
+
+public:
+    typedef UNORDERED_MAP<uint32, ArenaTeam*> ArenaTeamContainer;
+
+    ArenaTeam* GetArenaTeamById(uint32 arenaTeamId) const;
+    ArenaTeam* GetArenaTeamByName(std::string const& arenaTeamName) const;
+    ArenaTeam* GetArenaTeamByCaptain(uint64 guid) const;
+
+    void LoadArenaTeams();
+    void AddArenaTeam(ArenaTeam* arenaTeam);
+    void RemoveArenaTeam(uint32 Id);
+
+    ArenaTeamContainer::iterator GetArenaTeamMapBegin() { return ArenaTeamStore.begin(); }
+    ArenaTeamContainer::iterator GetArenaTeamMapEnd()   { return ArenaTeamStore.end(); }
+
+    void DistributeArenaPoints();
+
+    uint32 GenerateArenaTeamId();
+    void SetNextArenaTeamId(uint32 Id) { NextArenaTeamId = Id; }
+
+	uint32 GetNextArenaLogId() { return ++LastArenaLogId; }
+	void SetLastArenaLogId(uint32 id) { LastArenaLogId = id; }
+
+protected:
+    uint32 NextArenaTeamId;
+    ArenaTeamContainer ArenaTeamStore;
+	uint32 LastArenaLogId;
+};
+
+#define sArenaTeamMgr ACE_Singleton<ArenaTeamMgr, ACE_Null_Mutex>::instance()
+
+#endif

src/server/game/Battlegrounds/Battleground.h

@@ -0,0 +1,720 @@
+/*
+ * Copyright (C) 
+ * Copyright (C) 
+ *
+ * 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef __BATTLEGROUND_H
+#define __BATTLEGROUND_H
+
+#include "Common.h"
+#include "SharedDefines.h"
+#include "DBCEnums.h"
+#include "GameObject.h"
+
+class Creature;
+class GameObject;
+class Group;
+class Player;
+class WorldPacket;
+class BattlegroundMap;
+class BattlegroundAV;
+class BattlegroundWS;
+class BattlegroundAB;
+class BattlegroundNA;
+class BattlegroundBE;
+class BattlegroundEY;
+class BattlegroundRL;
+class BattlegroundSA;
+class BattlegroundDS;
+class BattlegroundRV;
+class BattlegroundIC;
+
+struct PvPDifficultyEntry;
+struct WorldSafeLocsEntry;
+
+enum BattlegroundSounds
+{
+    SOUND_HORDE_WINS                = 8454,
+    SOUND_ALLIANCE_WINS             = 8455,
+    SOUND_BG_START                  = 3439,
+    SOUND_BG_START_L70ETC           = 11803,
+};
+
+enum BattlegroundQuests
+{
+    SPELL_WS_QUEST_REWARD           = 43483,
+    SPELL_AB_QUEST_REWARD           = 43484,
+    SPELL_AV_QUEST_REWARD           = 43475,
+    SPELL_AV_QUEST_KILLED_BOSS      = 23658,
+    SPELL_EY_QUEST_REWARD           = 43477,
+    SPELL_SA_QUEST_REWARD           = 61213,
+    SPELL_AB_QUEST_REWARD_4_BASES   = 24061,
+    SPELL_AB_QUEST_REWARD_5_BASES   = 24064
+};
+
+enum BattlegroundMarks
+{
+    SPELL_WS_MARK_LOSER             = 24950,
+    SPELL_WS_MARK_WINNER            = 24951,
+    SPELL_AB_MARK_LOSER             = 24952,
+    SPELL_AB_MARK_WINNER            = 24953,
+    SPELL_AV_MARK_LOSER             = 24954,
+    SPELL_AV_MARK_WINNER            = 24955,
+    SPELL_SA_MARK_WINNER            = 61160,
+    SPELL_SA_MARK_LOSER             = 61159,
+	SPELL_WG_MARK_WINNER			= 56902,
+    ITEM_AV_MARK_OF_HONOR           = 20560,
+    ITEM_WS_MARK_OF_HONOR           = 20558,
+    ITEM_AB_MARK_OF_HONOR           = 20559,
+    ITEM_EY_MARK_OF_HONOR           = 29024,
+    ITEM_SA_MARK_OF_HONOR           = 42425,
+    ITEM_IC_MARK_OF_HONOR           = 47395,
+};
+
+enum BattlegroundMarksCount
+{
+    ITEM_WINNER_COUNT               = 3,
+    ITEM_LOSER_COUNT                = 1
+};
+
+enum BattlegroundCreatures
+{
+    BG_CREATURE_ENTRY_A_SPIRITGUIDE      = 13116,           // alliance
+    BG_CREATURE_ENTRY_H_SPIRITGUIDE      = 13117,           // horde
+};
+
+enum BattlegroundSpells
+{
+    SPELL_WAITING_FOR_RESURRECT     = 2584,                 // Waiting to Resurrect
+    SPELL_SPIRIT_HEAL_CHANNEL       = 22011,                // Spirit Heal Channel
+    SPELL_SPIRIT_HEAL               = 22012,                // Spirit Heal
+    SPELL_RESURRECTION_VISUAL       = 24171,                // Resurrection Impact Visual
+    SPELL_ARENA_PREPARATION         = 32727,                // use this one, 32728 not correct
+    SPELL_ALLIANCE_GOLD_FLAG        = 32724,
+    SPELL_ALLIANCE_GREEN_FLAG       = 32725,
+    SPELL_HORDE_GOLD_FLAG           = 35774,
+    SPELL_HORDE_GREEN_FLAG          = 35775,
+    SPELL_PREPARATION               = 44521,                // Preparation
+    SPELL_SPIRIT_HEAL_MANA          = 44535,                // Spirit Heal
+    SPELL_RECENTLY_DROPPED_FLAG     = 42792,                // Recently Dropped Flag
+    SPELL_AURA_PLAYER_INACTIVE      = 43681,                // Inactive
+    SPELL_HONORABLE_DEFENDER_25Y    = 68652,                // +50% honor when standing at a capture point that you control, 25yards radius (added in 3.2)
+    SPELL_HONORABLE_DEFENDER_60Y    = 66157,                // +50% honor when standing at a capture point that you control, 60yards radius (added in 3.2), probably for 40+ player battlegrounds
+    SPELL_THE_LAST_STANDING         = 26549,                // Arena achievement related
+};
+
+enum BattlegroundTimeIntervals
+{
+    CHECK_PLAYER_POSITION_INVERVAL  = 9000,                 // ms
+    RESURRECTION_INTERVAL           = 30000,                // ms
+    //REMIND_INTERVAL                 = 10000,                // ms
+    INVITATION_REMIND_TIME          = 20000,                // ms
+    INVITE_ACCEPT_WAIT_TIME         = 60000,                // ms
+    TIME_TO_AUTOREMOVE              = 120000,               // ms
+    MAX_OFFLINE_TIME                = 300,                  // secs
+    RESPAWN_ONE_DAY                 = 86400,                // secs
+    RESPAWN_IMMEDIATELY             = 0,                    // secs
+    BUFF_RESPAWN_TIME               = 180,                  // secs
+};
+
+enum BattlegroundStartTimeIntervals
+{
+    BG_START_DELAY_2M               = 120000,               // ms (2 minutes)
+    BG_START_DELAY_1M               = 60000,                // ms (1 minute)
+    BG_START_DELAY_30S              = 30000,                // ms (30 seconds)
+    BG_START_DELAY_15S              = 15000,                // ms (15 seconds) Used only in arena
+    BG_START_DELAY_NONE             = 0,                    // ms
+};
+
+#define BATTLEGROUND_UPDATE_INTERVAL 1000
+
+enum BattlegroundBuffObjects
+{
+    BG_OBJECTID_SPEEDBUFF_ENTRY     = 179871,
+    BG_OBJECTID_REGENBUFF_ENTRY     = 179904,
+    BG_OBJECTID_BERSERKERBUFF_ENTRY = 179905
+};
+
+enum BattlegroundRandomRewards
+{
+    BG_REWARD_WINNER_HONOR_FIRST    = 30,
+    BG_REWARD_WINNER_ARENA_FIRST    = 25,
+    BG_REWARD_WINNER_HONOR_LAST     = 15,
+    BG_REWARD_WINNER_ARENA_LAST     = 0,
+    BG_REWARD_LOSER_HONOR_FIRST    = 5,
+    BG_REWARD_LOSER_HONOR_LAST     = 5
+};
+
+const uint32 Buff_Entries[3] = { BG_OBJECTID_SPEEDBUFF_ENTRY, BG_OBJECTID_REGENBUFF_ENTRY, BG_OBJECTID_BERSERKERBUFF_ENTRY };
+
+enum BattlegroundStatus
+{
+    STATUS_NONE         = 0,                                // first status, should mean bg is not instance
+    STATUS_WAIT_QUEUE   = 1,                                // means bg is empty and waiting for queue
+    STATUS_WAIT_JOIN    = 2,                                // this means, that BG has already started and it is waiting for more players
+    STATUS_IN_PROGRESS  = 3,                                // means bg is running
+    STATUS_WAIT_LEAVE   = 4                                 // means some faction has won BG and it is ending
+};
+
+enum BattlegroundTeams
+{
+	BG_TEAMS_COUNT		= 2
+};
+
+struct BattlegroundObjectInfo
+{
+    BattlegroundObjectInfo() : object(NULL), timer(0), spellid(0) {}
+
+    GameObject  *object;
+    int32       timer;
+    uint32      spellid;
+};
+
+enum ScoreType
+{
+    SCORE_KILLING_BLOWS         = 1,
+    SCORE_DEATHS                = 2,
+    SCORE_HONORABLE_KILLS       = 3,
+    SCORE_BONUS_HONOR           = 4,
+    //EY, but in MSG_PVP_LOG_DATA opcode!
+    SCORE_DAMAGE_DONE           = 5,
+    SCORE_HEALING_DONE          = 6,
+    //WS
+    SCORE_FLAG_CAPTURES         = 7,
+    SCORE_FLAG_RETURNS          = 8,
+    //AB and IC
+    SCORE_BASES_ASSAULTED       = 9,
+    SCORE_BASES_DEFENDED        = 10,
+    //AV
+    SCORE_GRAVEYARDS_ASSAULTED  = 11,
+    SCORE_GRAVEYARDS_DEFENDED   = 12,
+    SCORE_TOWERS_ASSAULTED      = 13,
+    SCORE_TOWERS_DEFENDED       = 14,
+    SCORE_MINES_CAPTURED        = 15,
+    SCORE_LEADERS_KILLED        = 16,
+    SCORE_SECONDARY_OBJECTIVES  = 17,
+    //SOTA
+    SCORE_DESTROYED_DEMOLISHER  = 18,
+    SCORE_DESTROYED_WALL        = 19,
+};
+
+enum ArenaType
+{
+    ARENA_TYPE_2v2          = 2,
+    ARENA_TYPE_3v3          = 3,
+    ARENA_TYPE_5v5          = 5
+};
+
+enum BattlegroundType
+{
+    TYPE_BATTLEGROUND     = 3,
+    TYPE_ARENA            = 4
+};
+
+enum BattlegroundStartingEvents
+{
+    BG_STARTING_EVENT_NONE  = 0x00,
+    BG_STARTING_EVENT_1     = 0x01,
+    BG_STARTING_EVENT_2     = 0x02,
+    BG_STARTING_EVENT_3     = 0x04,
+    BG_STARTING_EVENT_4     = 0x08
+};
+
+enum BattlegroundStartingEventsIds
+{
+    BG_STARTING_EVENT_FIRST     = 0,
+    BG_STARTING_EVENT_SECOND    = 1,
+    BG_STARTING_EVENT_THIRD     = 2,
+    BG_STARTING_EVENT_FOURTH    = 3
+};
+#define BG_STARTING_EVENT_COUNT 4
+
+struct BattlegroundScore
+{
+    BattlegroundScore(Player* player) : KillingBlows(0), Deaths(0), HonorableKills(0), BonusHonor(0),
+        DamageDone(0), HealingDone(0), player(player)
+    { }
+
+    virtual ~BattlegroundScore() { }                        //virtual destructor is used when deleting score from scores map
+
+    uint32 KillingBlows;
+    uint32 Deaths;
+    uint32 HonorableKills;
+    uint32 BonusHonor;
+    uint32 DamageDone;
+    uint32 HealingDone;
+	Player* player;
+};
+
+class ArenaLogEntryData
+{
+	public:
+		ArenaLogEntryData() : Guid(0), ArenaTeamId(0), DamageDone(0), HealingDone(0), KillingBlows(0) {}
+		void Fill(const char* name, uint32 guid, uint32 acc, uint32 arenaTeamId, std::string ip)
+		{
+			Name = std::string(name);
+			Guid = guid;
+			Acc = acc;
+			ArenaTeamId = arenaTeamId;
+			IP = ip;
+		}
+
+		std::string Name;
+		uint32 Guid;
+		uint32 Acc;
+		uint32 ArenaTeamId;
+		std::string IP;
+		uint32 DamageDone;
+		uint32 HealingDone;
+		uint32 KillingBlows;
+};
+
+enum BGHonorMode
+{
+    BG_NORMAL = 0,
+    BG_HOLIDAY,
+    BG_HONOR_MODE_NUM
+};
+
+#define BG_AWARD_ARENA_POINTS_MIN_LEVEL 71
+#define ARENA_TIMELIMIT_POINTS_LOSS    -16
+#define ARENA_READY_MARKER_ENTRY 301337
+
+/*
+This class is used to:
+1. Add player to battleground
+2. Remove player from battleground
+3. some certain cases, same for all battlegrounds
+4. It has properties same for all battlegrounds
+*/
+class Battleground
+{
+    public:
+        Battleground();
+        virtual ~Battleground();
+
+        void Update(uint32 diff);
+
+        virtual bool SetupBattleground()                    // must be implemented in BG subclass
+        {
+            return true;
+        }
+        virtual void Init();
+        virtual void StartingEventCloseDoors() { }
+        virtual void StartingEventOpenDoors() { }
+        virtual void ResetBGSubclass() { }                  // must be implemented in BG subclass
+
+        virtual void DestroyGate(Player* /*player*/, GameObject* /*go*/) {}
+
+        /* achievement req. */
+        virtual bool AllNodesConrolledByTeam(TeamId /*teamId*/) const { return false; }
+        void StartTimedAchievement(AchievementCriteriaTimedTypes type, uint32 entry);
+
+        /* Battleground */
+        // Get methods:
+        char const* GetName() const         { return m_Name; }
+        BattlegroundTypeId GetBgTypeID() const { return m_RealTypeID; }
+        uint32 GetInstanceID() const        { return m_InstanceID; }
+        BattlegroundStatus GetStatus() const { return m_Status; }
+        uint32 GetClientInstanceID() const  { return m_ClientInstanceID; }
+        uint32 GetStartTime() const         { return m_StartTime; }
+        uint32 GetEndTime() const           { return m_EndTime; }
+        uint32 GetLastResurrectTime() const { return m_LastResurrectTime; }
+
+        uint32 GetMinLevel() const          { return m_LevelMin; }
+        uint32 GetMaxLevel() const          { return m_LevelMax; }
+
+        uint32 GetMaxPlayersPerTeam() const { return m_MaxPlayersPerTeam; }
+        uint32 GetMinPlayersPerTeam() const { return m_MinPlayersPerTeam; }
+
+        int32 GetStartDelayTime() const     { return m_StartDelayTime; }
+        uint8 GetArenaType() const          { return m_ArenaType; }
+        TeamId GetWinner() const             { return m_WinnerId; }
+        uint32 GetScriptId() const          { return ScriptId; }
+        uint32 GetBonusHonorFromKill(uint32 kills) const;
+
+        // Set methods:
+        void SetName(char const* Name)      { m_Name = Name; }
+        void SetBgTypeID(BattlegroundTypeId TypeID) { m_RealTypeID = TypeID; }
+        void SetInstanceID(uint32 InstanceID) { m_InstanceID = InstanceID; }
+        void SetStatus(BattlegroundStatus Status) { m_Status = Status; }
+        void SetClientInstanceID(uint32 InstanceID) { m_ClientInstanceID = InstanceID; }
+        void SetStartTime(uint32 Time)      { m_StartTime = Time; }
+        void SetEndTime(uint32 Time)        { m_EndTime = Time; }
+        void SetLastResurrectTime(uint32 Time) { m_LastResurrectTime = Time; }
+        void SetLevelRange(uint32 min, uint32 max) { m_LevelMin = min; m_LevelMax = max; }
+        void SetRated(bool state)           { m_IsRated = state; }
+        void SetArenaType(uint8 type)       { m_ArenaType = type; }
+        void SetArenaorBGType(bool _isArena) { m_IsArena = _isArena; }
+        void SetWinner(TeamId winner)        { m_WinnerId = winner; }
+        void SetScriptId(uint32 scriptId)   { ScriptId = scriptId; }
+
+        void ModifyStartDelayTime(int32 diff) { m_StartDelayTime -= diff; }
+        void SetStartDelayTime(int32 Time)    { m_StartDelayTime = Time; }
+
+        void SetMaxPlayersPerTeam(uint32 MaxPlayers) { m_MaxPlayersPerTeam = MaxPlayers; }
+        void SetMinPlayersPerTeam(uint32 MinPlayers) { m_MinPlayersPerTeam = MinPlayers; }
+
+		void DecreaseInvitedCount(TeamId teamId)    { ASSERT(m_BgInvitedPlayers[teamId] > 0); --m_BgInvitedPlayers[teamId]; }
+		void IncreaseInvitedCount(TeamId teamId)    { ++m_BgInvitedPlayers[teamId]; }
+		uint32 GetInvitedCount(TeamId teamId) const { return m_BgInvitedPlayers[teamId]; }
+
+        bool HasFreeSlots() const;
+        uint32 GetFreeSlotsForTeam(TeamId teamId) const;
+		uint32 GetMaxFreeSlots() const;
+ 
+        typedef std::set<Player*> SpectatorList;
+		typedef std::map<uint64, uint64> ToBeTeleportedMap;
+        void AddSpectator(Player* p) { m_Spectators.insert(p); }
+        void RemoveSpectator(Player* p) { m_Spectators.erase(p); }
+        bool HaveSpectators() { return !m_Spectators.empty(); }
+		const SpectatorList& GetSpectators() const { return m_Spectators; }
+		void AddToBeTeleported(uint64 spectator, uint64 participant) { m_ToBeTeleported[spectator] = participant; }
+		void RemoveToBeTeleported(uint64 spectator) { ToBeTeleportedMap::iterator itr = m_ToBeTeleported.find(spectator); if (itr != m_ToBeTeleported.end()) m_ToBeTeleported.erase(itr); }
+		void SpectatorsSendPacket(WorldPacket& data);
+
+        bool isArena() const        { return m_IsArena; }
+        bool isBattleground() const { return !m_IsArena; }
+        bool isRated() const        { return m_IsRated; }
+
+        typedef std::map<uint64, Player*> BattlegroundPlayerMap;
+        BattlegroundPlayerMap const& GetPlayers() const { return m_Players; }
+        uint32 GetPlayersSize() const { return m_Players.size(); }
+
+		void ReadyMarkerClicked(Player* p); // pussywizard
+		std::set<uint32> readyMarkerClickedSet; // pussywizard
+
+        typedef std::map<uint64, BattlegroundScore*> BattlegroundScoreMap;
+        typedef std::map<uint64, ArenaLogEntryData> ArenaLogEntryDataMap;// pussywizard
+        ArenaLogEntryDataMap ArenaLogEntries; // pussywizard
+        BattlegroundScoreMap::const_iterator GetPlayerScoresBegin() const { return PlayerScores.begin(); }
+        BattlegroundScoreMap::const_iterator GetPlayerScoresEnd() const { return PlayerScores.end(); }
+        uint32 GetPlayerScoresSize() const { return PlayerScores.size(); }
+
+        uint32 GetReviveQueueSize() const { return m_ReviveQueue.size(); }
+
+        void AddPlayerToResurrectQueue(uint64 npc_guid, uint64 player_guid);
+        void RemovePlayerFromResurrectQueue(Player* player);
+
+        /// Relocate all players in ReviveQueue to the closest graveyard
+        void RelocateDeadPlayers(uint64 queueIndex);
+
+        void StartBattleground();
+
+        GameObject* GetBGObject(uint32 type);
+        Creature* GetBGCreature(uint32 type);
+
+        // Location
+        void SetMapId(uint32 MapID) { m_MapId = MapID; }
+        uint32 GetMapId() const { return m_MapId; }
+
+        // Map pointers
+        void SetBgMap(BattlegroundMap* map) { m_Map = map; }
+        BattlegroundMap* GetBgMap() const { ASSERT(m_Map); return m_Map; }
+        BattlegroundMap* FindBgMap() const { return m_Map; }
+
+        void SetTeamStartLoc(TeamId teamId, float X, float Y, float Z, float O);
+        void GetTeamStartLoc(TeamId teamId, float &X, float &Y, float &Z, float &O) const
+        {
+            X = m_TeamStartLocX[teamId];
+            Y = m_TeamStartLocY[teamId];
+            Z = m_TeamStartLocZ[teamId];
+            O = m_TeamStartLocO[teamId];
+        }
+
+        void SetStartMaxDist(float startMaxDist) { m_StartMaxDist = startMaxDist; }
+        float GetStartMaxDist() const { return m_StartMaxDist; }
+
+        // Packet Transfer
+        // method that should fill worldpacket with actual world states (not yet implemented for all battlegrounds!)
+        virtual void FillInitialWorldStates(WorldPacket& /*data*/) {}
+        void SendPacketToTeam(TeamId teamId, WorldPacket* packet, Player* sender = NULL, bool self = true);
+        void SendPacketToAll(WorldPacket* packet);
+        void YellToAll(Creature* creature, const char* text, uint32 language);
+
+        template<class Do>
+        void BroadcastWorker(Do& _do);
+
+        void PlaySoundToAll(uint32 soundId);
+        void CastSpellOnTeam(uint32 spellId, TeamId teamId);
+        void RemoveAuraOnTeam(uint32 spellId, TeamId teamId);
+        void RewardHonorToTeam(uint32 honor, TeamId teamId);
+        void RewardReputationToTeam(uint32 factionId, uint32 reputation, TeamId teamId);
+
+        void UpdateWorldState(uint32 Field, uint32 Value);
+        void UpdateWorldStateForPlayer(uint32 Field, uint32 Value, Player* player);
+        void EndBattleground(TeamId winnerTeamId);
+        void BlockMovement(Player* player);
+
+        void SendWarningToAll(int32 entry, ...);
+        void SendMessageToAll(int32 entry, ChatMsg type, Player const* source = NULL);
+        void PSendMessageToAll(int32 entry, ChatMsg type, Player const* source, ...);
+
+        // specialized version with 2 string id args
+        void SendMessage2ToAll(int32 entry, ChatMsg type, Player const* source, int32 strId1 = 0, int32 strId2 = 0);
+
+        // Raid Group
+        Group* GetBgRaid(TeamId teamId) const { return m_BgRaids[teamId]; }
+        void SetBgRaid(TeamId teamId, Group* bg_raid);
+
+        virtual void UpdatePlayerScore(Player* player, uint32 type, uint32 value, bool doAddHonor = true);
+
+        uint32 GetPlayersCountByTeam(TeamId teamId) const { return m_PlayersCount[teamId]; }
+        uint32 GetAlivePlayersCountByTeam(TeamId teamId) const;   // used in arenas to correctly handle death in spirit of redemption / last stand etc. (killer = killed) cases
+        void UpdatePlayersCountByTeam(TeamId teamId, bool remove)
+        {
+            if (remove)
+                --m_PlayersCount[teamId];
+            else
+                ++m_PlayersCount[teamId];
+        }
+
+        // used for rated arena battles
+        void SetArenaTeamIdForTeam(TeamId teamId, uint32 ArenaTeamId) { m_ArenaTeamIds[teamId] = ArenaTeamId; }
+        uint32 GetArenaTeamIdForTeam(TeamId teamId) const             { return m_ArenaTeamIds[teamId]; }
+        void SetArenaTeamRatingChangeForTeam(TeamId teamId, int32 RatingChange) { m_ArenaTeamRatingChanges[teamId] = RatingChange; }
+        int32 GetArenaTeamRatingChangeForTeam(TeamId teamId) const    { return m_ArenaTeamRatingChanges[teamId]; }
+        void SetArenaMatchmakerRating(TeamId teamId, uint32 MMR)      { m_ArenaTeamMMR[teamId] = MMR; }
+        uint32 GetArenaMatchmakerRating(TeamId teamId) const          { return m_ArenaTeamMMR[teamId]; }
+        void CheckArenaAfterTimerConditions();
+        void CheckArenaWinConditions();
+        virtual void UpdateArenaWorldState();
+
+        // Triggers handle
+        // must be implemented in BG subclass
+        virtual void HandleAreaTrigger(Player* /*player*/, uint32 /*trigger*/) {}
+        // must be implemented in BG subclass if need AND call base class generic code
+        virtual void HandleKillPlayer(Player* player, Player* killer);
+        virtual void HandleKillUnit(Creature* /*unit*/, Player* /*killer*/);
+
+        // Battleground events
+        virtual void EventPlayerDroppedFlag(Player* /*player*/) {}
+        virtual void EventPlayerClickedOnFlag(Player* /*player*/, GameObject* /*gameObject*/) {}
+        virtual void EventPlayerDamagedGO(Player* /*player*/, GameObject* /*go*/, uint32 /*eventType*/) {}
+        virtual void EventPlayerUsedGO(Player* /*player*/, GameObject* /*go*/){}
+
+        // this function can be used by spell to interact with the BG map
+        virtual void DoAction(uint32 /*action*/, uint64 /*var*/) {}
+
+        virtual void HandlePlayerResurrect(Player* /*player*/) {}
+
+        // Death related
+        virtual WorldSafeLocsEntry const* GetClosestGraveyard(Player* player);
+
+        virtual void AddPlayer(Player* player);                // must be implemented in BG subclass
+
+        void AddOrSetPlayerToCorrectBgGroup(Player* player, TeamId teamId);
+
+        void RemovePlayerAtLeave(Player* player);
+                                                            // can be extended in in BG subclass
+
+        void HandleTriggerBuff(GameObject* gameObject);
+        void SetHoliday(bool is_holiday);
+
+        // TODO: make this protected:
+        typedef std::vector<uint64> BGObjects;
+        typedef std::vector<uint64> BGCreatures;
+        BGObjects BgObjects;
+        BGCreatures BgCreatures;
+        void SpawnBGObject(uint32 type, uint32 respawntime);
+        bool AddObject(uint32 type, uint32 entry, float x, float y, float z, float o, float rotation0, float rotation1, float rotation2, float rotation3, uint32 respawnTime = 0, GOState goState = GO_STATE_READY);
+        Creature* AddCreature(uint32 entry, uint32 type, float x, float y, float z, float o, uint32 respawntime = 0, MotionTransport* transport = NULL);
+        bool DelCreature(uint32 type);
+        bool DelObject(uint32 type);
+        bool AddSpiritGuide(uint32 type, float x, float y, float z, float o, TeamId teamId);
+        int32 GetObjectType(uint64 guid);
+
+        void DoorOpen(uint32 type);
+        void DoorClose(uint32 type);
+        //to be removed
+        const char* GetTrinityString(int32 entry);
+
+        virtual bool HandlePlayerUnderMap(Player* /*player*/) { return false; }
+
+        // since arenas can be AvA or Hvh, we have to get the "temporary" team of a player
+        static TeamId GetOtherTeamId(TeamId teamId);
+        bool IsPlayerInBattleground(uint64 guid) const;
+
+        bool ToBeDeleted() const { return m_SetDeleteThis; }
+        //void SetDeleteThis() { m_SetDeleteThis = true; }
+
+        void RewardXPAtKill(Player* killer, Player* victim);
+
+        virtual uint64 GetFlagPickerGUID(TeamId /*teamId*/ = TEAM_NEUTRAL) const { return 0; }
+        virtual void SetDroppedFlagGUID(uint64 /*guid*/, TeamId /*teamId*/ = TEAM_NEUTRAL) {}
+        uint32 GetTeamScore(TeamId teamId) const;
+        
+        virtual TeamId GetPrematureWinner();
+
+        BattlegroundAV* ToBattlegroundAV() { if (GetBgTypeID() == BATTLEGROUND_AV) return reinterpret_cast<BattlegroundAV*>(this); else return NULL; }
+        BattlegroundAV const* ToBattlegroundAV() const { if (GetBgTypeID() == BATTLEGROUND_AV) return reinterpret_cast<const BattlegroundAV*>(this); else return NULL; }
+
+        BattlegroundWS* ToBattlegroundWS() { if (GetBgTypeID() == BATTLEGROUND_WS) return reinterpret_cast<BattlegroundWS*>(this); else return NULL; }
+        BattlegroundWS const* ToBattlegroundWS() const { if (GetBgTypeID() == BATTLEGROUND_WS) return reinterpret_cast<const BattlegroundWS*>(this); else return NULL; }
+
+        BattlegroundAB* ToBattlegroundAB() { if (GetBgTypeID() == BATTLEGROUND_AB) return reinterpret_cast<BattlegroundAB*>(this); else return NULL; }
+        BattlegroundAB const* ToBattlegroundAB() const { if (GetBgTypeID() == BATTLEGROUND_AB) return reinterpret_cast<const BattlegroundAB*>(this); else return NULL; }
+
+        BattlegroundNA* ToBattlegroundNA() { if (GetBgTypeID() == BATTLEGROUND_NA) return reinterpret_cast<BattlegroundNA*>(this); else return NULL; }
+        BattlegroundNA const* ToBattlegroundNA() const { if (GetBgTypeID() == BATTLEGROUND_NA) return reinterpret_cast<const BattlegroundNA*>(this); else return NULL; }
+
+        BattlegroundBE* ToBattlegroundBE() { if (GetBgTypeID() == BATTLEGROUND_BE) return reinterpret_cast<BattlegroundBE*>(this); else return NULL; }
+        BattlegroundBE const* ToBattlegroundBE() const { if (GetBgTypeID() == BATTLEGROUND_BE) return reinterpret_cast<const BattlegroundBE*>(this); else return NULL; }
+
+        BattlegroundEY* ToBattlegroundEY() { if (GetBgTypeID() == BATTLEGROUND_EY) return reinterpret_cast<BattlegroundEY*>(this); else return NULL; }
+        BattlegroundEY const* ToBattlegroundEY() const { if (GetBgTypeID() == BATTLEGROUND_EY) return reinterpret_cast<const BattlegroundEY*>(this); else return NULL; }
+
+        BattlegroundRL* ToBattlegroundRL() { if (GetBgTypeID() == BATTLEGROUND_RL) return reinterpret_cast<BattlegroundRL*>(this); else return NULL; }
+        BattlegroundRL const* ToBattlegroundRL() const { if (GetBgTypeID() == BATTLEGROUND_RL) return reinterpret_cast<const BattlegroundRL*>(this); else return NULL; }
+
+        BattlegroundSA* ToBattlegroundSA() { if (GetBgTypeID() == BATTLEGROUND_SA) return reinterpret_cast<BattlegroundSA*>(this); else return NULL; }
+        BattlegroundSA const* ToBattlegroundSA() const { if (GetBgTypeID() == BATTLEGROUND_SA) return reinterpret_cast<const BattlegroundSA*>(this); else return NULL; }
+
+        BattlegroundDS* ToBattlegroundDS() { if (GetBgTypeID() == BATTLEGROUND_DS) return reinterpret_cast<BattlegroundDS*>(this); else return NULL; }
+        BattlegroundDS const* ToBattlegroundDS() const { if (GetBgTypeID() == BATTLEGROUND_DS) return reinterpret_cast<const BattlegroundDS*>(this); else return NULL; }
+
+        BattlegroundRV* ToBattlegroundRV() { if (GetBgTypeID() == BATTLEGROUND_RV) return reinterpret_cast<BattlegroundRV*>(this); else return NULL; }
+        BattlegroundRV const* ToBattlegroundRV() const { if (GetBgTypeID() == BATTLEGROUND_RV) return reinterpret_cast<const BattlegroundRV*>(this); else return NULL; }
+
+        BattlegroundIC* ToBattlegroundIC() { if (GetBgTypeID() == BATTLEGROUND_IC) return reinterpret_cast<BattlegroundIC*>(this); else return NULL; }
+        BattlegroundIC const* ToBattlegroundIC() const { if (GetBgTypeID() == BATTLEGROUND_IC) return reinterpret_cast<const BattlegroundIC*>(this); else return NULL; }
+
+    protected:
+        // this method is called, when BG cannot spawn its own spirit guide, or something is wrong, It correctly ends Battleground
+        void EndNow();
+        void PlayerAddedToBGCheckIfBGIsRunning(Player* player);
+
+        void _ProcessResurrect(uint32 diff);
+        void _ProcessProgress(uint32 diff);
+        void _ProcessLeave(uint32 diff);
+        void _ProcessJoin(uint32 diff);
+        void _CheckSafePositions(uint32 diff);
+
+        // Scorekeeping
+        BattlegroundScoreMap PlayerScores;                // Player scores
+        // must be implemented in BG subclass
+        virtual void RemovePlayer(Player* /*player*/) {}
+
+        // Player lists, those need to be accessible by inherited classes
+        BattlegroundPlayerMap  m_Players;
+        // Spirit Guide guid + Player list GUIDS
+        std::map<uint64, std::vector<uint64> >  m_ReviveQueue;
+
+        // these are important variables used for starting messages
+        uint8 m_Events;
+        BattlegroundStartTimeIntervals  StartDelayTimes[BG_STARTING_EVENT_COUNT];
+        // this must be filled in constructors!
+        uint32 StartMessageIds[BG_STARTING_EVENT_COUNT];
+
+        bool   m_BuffChange;
+
+        BGHonorMode m_HonorMode;
+        int32 m_TeamScores[BG_TEAMS_COUNT];
+
+		// pussywizard:
+		uint32 m_UpdateTimer;
+    private:
+        // Battleground
+        BattlegroundTypeId m_RealTypeID;
+        uint32 m_InstanceID;                                // Battleground Instance's GUID!
+        BattlegroundStatus m_Status;
+        uint32 m_ClientInstanceID;                          // the instance-id which is sent to the client and without any other internal use
+        uint32 m_StartTime;
+        uint32 m_ResetStatTimer;
+        uint32 m_ValidStartPositionTimer;
+        int32 m_EndTime;                                    // it is set to 120000 when bg is ending and it decreases itself
+        uint32 m_LastResurrectTime;
+        uint8  m_ArenaType;                                 // 2=2v2, 3=3v3, 5=5v5
+        bool   m_SetDeleteThis;                             // used for safe deletion of the bg after end / all players leave
+        bool   m_IsArena;
+        TeamId  m_WinnerId;
+        int32  m_StartDelayTime;
+        bool   m_IsRated;                                   // is this battle rated?
+        bool   m_PrematureCountDown;
+        uint32 m_PrematureCountDownTimer;
+        char const* m_Name;
+
+        /* Pre- and post-update hooks */
+
+        /**
+         * @brief Pre-update hook.
+         *
+         * Will be called before battleground update is started. Depending on
+         * the result of this call actual update body may be skipped.
+         *
+         * @param diff a time difference between two worldserver update loops in
+         * milliseconds.
+         *
+         * @return @c true if update must be performed, @c false otherwise.
+         *
+         * @see Update(), PostUpdateImpl().
+         */
+        virtual bool PreUpdateImpl(uint32 /* diff */) { return true; }
+
+        /**
+         * @brief Post-update hook.
+         *
+         * Will be called after battleground update has passed. May be used to
+         * implement custom update effects in subclasses.
+         *
+         * @param diff a time difference between two worldserver update loops in
+         * milliseconds.
+         *
+         * @see Update(), PreUpdateImpl().
+         */
+        virtual void PostUpdateImpl(uint32 /* diff */) { }
+
+        // Player lists
+        std::vector<uint64> m_ResurrectQueue;               // Player GUID
+        std::deque<uint64> m_OfflineQueue;                  // Player GUID
+
+        // Invited counters are useful for player invitation to BG - do not allow, if BG is started to one faction to have 2 more players than another faction
+        // Invited counters will be changed only when removing already invited player from queue, removing player from battleground and inviting player to BG
+        // Invited players counters
+		uint32 m_BgInvitedPlayers[BG_TEAMS_COUNT];
+
+        // Raid Group
+        Group* m_BgRaids[BG_TEAMS_COUNT];                   // 0 - alliance, 1 - horde
+
+		SpectatorList m_Spectators;
+		ToBeTeleportedMap m_ToBeTeleported;
+
+        // Players count by team
+        uint32 m_PlayersCount[BG_TEAMS_COUNT];
+
+        // Arena team ids by team
+        uint32 m_ArenaTeamIds[BG_TEAMS_COUNT];
+
+        int32 m_ArenaTeamRatingChanges[BG_TEAMS_COUNT];
+        uint32 m_ArenaTeamMMR[BG_TEAMS_COUNT];
+
+        // Limits
+        uint32 m_LevelMin;
+        uint32 m_LevelMax;
+        uint32 m_MaxPlayersPerTeam;
+        uint32 m_MinPlayersPerTeam;
+
+        // Start location
+        uint32 m_MapId;
+        BattlegroundMap* m_Map;
+        float m_TeamStartLocX[BG_TEAMS_COUNT];
+        float m_TeamStartLocY[BG_TEAMS_COUNT];
+        float m_TeamStartLocZ[BG_TEAMS_COUNT];
+        float m_TeamStartLocO[BG_TEAMS_COUNT];
+        float m_StartMaxDist;
+        uint32 ScriptId;
+};
+#endif

src/server/game/Battlegrounds/BattlegroundMgr.h

@@ -0,0 +1,168 @@
+/*
+ * Copyright (C) 
+ * Copyright (C) 
+ *
+ * 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef __BATTLEGROUNDMGR_H
+#define __BATTLEGROUNDMGR_H
+
+#include "Common.h"
+#include "DBCEnums.h"
+#include "Battleground.h"
+#include "BattlegroundQueue.h"
+#include "CreatureAIImpl.h"
+#include <ace/Singleton.h>
+
+typedef std::map<uint32, Battleground*> BattlegroundContainer;
+typedef UNORDERED_MAP<uint32, BattlegroundTypeId> BattleMastersMap;
+
+#define WS_ARENA_DISTRIBUTION_TIME 20001 // Custom worldstate
+
+struct CreateBattlegroundData
+{
+    BattlegroundTypeId bgTypeId;
+    bool IsArena;
+    uint32 MinPlayersPerTeam;
+    uint32 MaxPlayersPerTeam;
+    uint32 LevelMin;
+    uint32 LevelMax;
+    char* BattlegroundName;
+    uint32 MapID;
+    float Team1StartLocX;
+    float Team1StartLocY;
+    float Team1StartLocZ;
+    float Team1StartLocO;
+    float Team2StartLocX;
+    float Team2StartLocY;
+    float Team2StartLocZ;
+    float Team2StartLocO;
+    float StartMaxDist;
+    uint32 scriptId;
+};
+
+struct GroupQueueInfo;
+
+// pussywizard
+class RandomBattlegroundSystem
+{
+	public:
+		RandomBattlegroundSystem();
+		void Update(uint32 diff);
+		BattlegroundTypeId GetCurrentRandomBg() const { return m_CurrentRandomBg; }
+		void BattlegroundCreated(BattlegroundTypeId bgTypeId);
+	private:
+		BattlegroundTypeId m_CurrentRandomBg;
+		uint32 m_SwitchTimer;
+		std::vector<BattlegroundTypeId> m_BgOrder;
+};
+
+class BattlegroundMgr
+{
+    friend class ACE_Singleton<BattlegroundMgr, ACE_Null_Mutex>;
+
+    private:
+        BattlegroundMgr();
+        ~BattlegroundMgr();
+
+    public:
+        void Update(uint32 diff);
+
+        /* Packet Building */
+        void BuildPlayerJoinedBattlegroundPacket(WorldPacket* data, Player* player);
+        void BuildPlayerLeftBattlegroundPacket(WorldPacket* data, uint64 guid);
+        void BuildBattlegroundListPacket(WorldPacket* data, uint64 guid, Player* player, BattlegroundTypeId bgTypeId, uint8 fromWhere);
+        void BuildGroupJoinedBattlegroundPacket(WorldPacket* data, GroupJoinBattlegroundResult result);
+        void BuildUpdateWorldStatePacket(WorldPacket* data, uint32 field, uint32 value);
+        void BuildPvpLogDataPacket(WorldPacket* data, Battleground* bg);
+        void BuildBattlegroundStatusPacket(WorldPacket* data, Battleground* bg, uint8 queueSlot, uint8 statusId, uint32 time1, uint32 time2, uint8 arenaType, TeamId teamId, bool isRated = false, BattlegroundTypeId forceBgTypeId = BATTLEGROUND_TYPE_NONE);
+        void BuildPlaySoundPacket(WorldPacket* data, uint32 soundid);
+        void SendAreaSpiritHealerQueryOpcode(Player* player, Battleground* bg, uint64 guid);
+
+        /* Battlegrounds */
+        Battleground* GetBattleground(uint32 InstanceID);
+        Battleground* GetBattlegroundTemplate(BattlegroundTypeId bgTypeId);
+        Battleground* CreateNewBattleground(BattlegroundTypeId bgTypeId, uint32 minLevel, uint32 maxLevel, uint8 arenaType, bool isRated);
+
+        void AddBattleground(Battleground* bg);
+        void RemoveBattleground(BattlegroundTypeId bgTypeId, uint32 instanceId);
+
+        void CreateInitialBattlegrounds();
+        void DeleteAllBattlegrounds();
+
+        void SendToBattleground(Player* player, uint32 InstanceID, BattlegroundTypeId bgTypeId);
+
+        /* Battleground queues */
+        BattlegroundQueue& GetBattlegroundQueue(BattlegroundQueueTypeId bgQueueTypeId) { return m_BattlegroundQueues[bgQueueTypeId]; }
+        void ScheduleArenaQueueUpdate(uint32 arenaRatedTeamId, BattlegroundQueueTypeId bgQueueTypeId, BattlegroundBracketId bracket_id);
+        uint32 GetPrematureFinishTime() const;
+
+        static void InviteGroupToBG(GroupQueueInfo* ginfo, Battleground* bg, TeamId teamId);
+
+        void ToggleArenaTesting();
+        void ToggleTesting();
+
+        void SetHolidayWeekends(uint32 mask);
+
+        bool isArenaTesting() const { return m_ArenaTesting; }
+        bool isTesting() const { return m_Testing; }
+
+        static BattlegroundQueueTypeId BGQueueTypeId(BattlegroundTypeId bgTypeId, uint8 arenaType);
+        static BattlegroundTypeId BGTemplateId(BattlegroundQueueTypeId bgQueueTypeId);
+        static bool IsArenaType(BattlegroundTypeId bgTypeId);
+        static uint8 BGArenaType(BattlegroundQueueTypeId bgQueueTypeId);
+
+        static HolidayIds BGTypeToWeekendHolidayId(BattlegroundTypeId bgTypeId);
+        static BattlegroundTypeId WeekendHolidayIdToBGType(HolidayIds holiday);
+        static bool IsBGWeekend(BattlegroundTypeId bgTypeId);
+
+        PvPDifficultyEntry randomBgDifficultyEntry;
+
+        uint32 GetRatingDiscardTimer()  const;
+        void InitAutomaticArenaPointDistribution();
+        void LoadBattleMastersEntry();
+        void CheckBattleMasters();
+        BattlegroundTypeId GetBattleMasterBG(uint32 entry) const
+        {
+            BattleMastersMap::const_iterator itr = mBattleMastersMap.find(entry);
+            if (itr != mBattleMastersMap.end())
+                return itr->second;
+            return BATTLEGROUND_TYPE_NONE;
+        }
+
+		const BattlegroundContainer& GetBattlegroundList() { return m_Battlegrounds; } // pussywizard
+		RandomBattlegroundSystem RandomSystem; // pussywizard
+
+    private:
+        bool CreateBattleground(CreateBattlegroundData& data);
+        uint32 GetNextClientVisibleInstanceId();
+
+        typedef std::map<BattlegroundTypeId, Battleground*> BattlegroundTemplateContainer;
+		BattlegroundTemplateContainer m_BattlegroundTemplates;
+        BattlegroundContainer m_Battlegrounds;
+
+        BattlegroundQueue m_BattlegroundQueues[MAX_BATTLEGROUND_QUEUE_TYPES];
+
+        std::vector<uint64> m_ArenaQueueUpdateScheduler;
+		uint32 m_lastClientVisibleInstanceId;
+		uint32 m_NextPeriodicQueueUpdateTime;
+        time_t m_NextAutoDistributionTime;
+        bool   m_ArenaTesting;
+        bool   m_Testing;
+        BattleMastersMap mBattleMastersMap;
+};
+
+#define sBattlegroundMgr ACE_Singleton<BattlegroundMgr, ACE_Null_Mutex>::instance()
+#endif

src/server/game/Battlegrounds/BattlegroundQueue.h

@@ -0,0 +1,177 @@
+/*
+ * Copyright (C) 
+ * Copyright (C) 
+ *
+ * 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef __BATTLEGROUNDQUEUE_H
+#define __BATTLEGROUNDQUEUE_H
+
+#include "Common.h"
+#include "DBCEnums.h"
+#include "Battleground.h"
+#include "EventProcessor.h"
+
+#include <deque>
+
+#define COUNT_OF_PLAYERS_TO_AVERAGE_WAIT_TIME 10
+
+struct GroupQueueInfo                                       // stores information about the group in queue (also used when joined as solo!)
+{
+    std::set<uint64> Players;                               // player guid set
+    TeamId  teamId;                                         // Player team (TEAM_ALLIANCE/TEAM_HORDE)
+    BattlegroundTypeId BgTypeId;                            // battleground type id
+    bool    IsRated;                                        // rated
+    uint8   ArenaType;                                      // 2v2, 3v3, 5v5 or 0 when BG
+    uint32  ArenaTeamId;                                    // team id if rated match
+    uint32  JoinTime;                                       // time when group was added
+    uint32  RemoveInviteTime;                               // time when we will remove invite for players in group
+    uint32  IsInvitedToBGInstanceGUID;                      // was invited to certain BG
+    uint32  ArenaTeamRating;                                // if rated match, inited to the rating of the team
+    uint32  ArenaMatchmakerRating;                          // if rated match, inited to the rating of the team
+    uint32  OpponentsTeamRating;                            // for rated arena matches
+    uint32  OpponentsMatchmakerRating;                      // for rated arena matches
+
+	// pussywizard: for internal use
+	uint8 _bracketId;
+	uint8 _groupType;
+};
+
+enum BattlegroundQueueGroupTypes
+{
+    BG_QUEUE_PREMADE_ALLIANCE   = 0,
+    BG_QUEUE_PREMADE_HORDE      = 1,
+    BG_QUEUE_NORMAL_ALLIANCE    = 2,
+    BG_QUEUE_NORMAL_HORDE       = 3
+};
+#define BG_QUEUE_GROUP_TYPES_COUNT 4
+
+class Battleground;
+class BattlegroundQueue
+{
+    public:
+        BattlegroundQueue();
+        ~BattlegroundQueue();
+
+        void BattlegroundQueueUpdate(BattlegroundBracketId bracket_id, uint8 actionMask, bool isRated, uint32 arenaRatedTeamId);
+        void UpdateEvents(uint32 diff);
+
+        void FillPlayersToBG(const int32 aliFree, const int32 hordeFree, BattlegroundBracketId bracket_id);
+        void FillPlayersToBGWithSpecific(const int32 aliFree, const int32 hordeFree, BattlegroundBracketId thisBracketId, BattlegroundQueue* specificQueue, BattlegroundBracketId specificBracketId);
+        bool CheckPremadeMatch(BattlegroundBracketId bracket_id, uint32 MinPlayersPerTeam, uint32 MaxPlayersPerTeam);
+        bool CheckNormalMatch(Battleground* bgTemplate, BattlegroundBracketId bracket_id, uint32 minPlayers, uint32 maxPlayers);
+        bool CheckSkirmishForSameFaction(BattlegroundBracketId bracket_id, uint32 minPlayersPerTeam);
+        GroupQueueInfo* AddGroup(Player* leader, Group* group, PvPDifficultyEntry const*  bracketEntry, bool isRated, bool isPremade, uint32 ArenaRating, uint32 MatchmakerRating, uint32 ArenaTeamId);
+        void RemovePlayer(uint64 guid, bool sentToBg, uint32 playerQueueSlot);
+        bool IsPlayerInvitedToRatedArena(uint64 pl_guid);
+        bool IsPlayerInvited(uint64 pl_guid, const uint32 bgInstanceGuid, const uint32 removeTime);
+        bool GetPlayerGroupInfoData(uint64 guid, GroupQueueInfo* ginfo);
+        void PlayerInvitedToBGUpdateAverageWaitTime(GroupQueueInfo* ginfo);
+        uint32 GetAverageQueueWaitTime(GroupQueueInfo* ginfo) const;
+
+		void SetBgTypeIdAndArenaType(BattlegroundTypeId b, uint8 a) { m_bgTypeId = b; m_arenaType = ArenaType(a); } // pussywizard
+		void AddEvent(BasicEvent* Event, uint64 e_time);
+
+        typedef std::map<uint64, GroupQueueInfo*> QueuedPlayersMap;
+        QueuedPlayersMap m_QueuedPlayers;
+
+        //do NOT use deque because deque.erase() invalidates ALL iterators
+        typedef std::list<GroupQueueInfo*> GroupsQueueType;
+
+        /*
+        This two dimensional array is used to store All queued groups
+        First dimension specifies the bgTypeId
+        Second dimension specifies the player's group types -
+             BG_QUEUE_PREMADE_ALLIANCE  is used for premade alliance groups and alliance rated arena teams
+             BG_QUEUE_PREMADE_HORDE     is used for premade horde groups and horde rated arena teams
+             BG_QUEUE_NORMAL_ALLIANCE   is used for normal (or small) alliance groups or non-rated arena matches
+             BG_QUEUE_NORMAL_HORDE      is used for normal (or small) horde groups or non-rated arena matches
+        */
+        GroupsQueueType m_QueuedGroups[MAX_BATTLEGROUND_BRACKETS][BG_QUEUE_GROUP_TYPES_COUNT];
+
+        // class to select and invite groups to bg
+        class SelectionPool
+        {
+			public:
+				SelectionPool(): PlayerCount(0) {};
+				void Init();
+				bool AddGroup(GroupQueueInfo* ginfo, uint32 desiredCount);
+				bool KickGroup(const uint32 size);
+				uint32 GetPlayerCount() const {return PlayerCount;}
+			public:
+				GroupsQueueType SelectedGroups;
+			private:
+				uint32 PlayerCount;
+        };
+
+        //one selection pool for horde, other one for alliance
+        SelectionPool m_SelectionPools[BG_TEAMS_COUNT];
+    private:
+
+		BattlegroundTypeId m_bgTypeId;
+		ArenaType m_arenaType;
+        uint32 m_WaitTimes[BG_TEAMS_COUNT][MAX_BATTLEGROUND_BRACKETS][COUNT_OF_PLAYERS_TO_AVERAGE_WAIT_TIME];
+        uint32 m_WaitTimeLastIndex[BG_TEAMS_COUNT][MAX_BATTLEGROUND_BRACKETS];
+
+        // Event handler
+        EventProcessor m_events;
+};
+
+/*
+    This class is used to invite player to BG again, when minute lasts from his first invitation
+    it is capable to solve all possibilities
+*/
+class BGQueueInviteEvent : public BasicEvent
+{
+    public:
+        BGQueueInviteEvent(uint64 pl_guid, uint32 BgInstanceGUID, BattlegroundTypeId BgTypeId, uint8 arenaType, uint32 removeTime) :
+          m_PlayerGuid(pl_guid), m_BgInstanceGUID(BgInstanceGUID), m_BgTypeId(BgTypeId), m_ArenaType(arenaType), m_RemoveTime(removeTime)
+          { }
+        virtual ~BGQueueInviteEvent() { }
+
+        virtual bool Execute(uint64 e_time, uint32 p_time);
+        virtual void Abort(uint64 e_time);
+    private:
+        uint64 m_PlayerGuid;
+        uint32 m_BgInstanceGUID;
+        BattlegroundTypeId m_BgTypeId;
+        uint8  m_ArenaType;
+        uint32 m_RemoveTime;
+};
+
+/*
+    This class is used to remove player from BG queue after 1 minute 20 seconds from first invitation
+    We must store removeInvite time in case player left queue and joined and is invited again
+    We must store bgQueueTypeId, because battleground can be deleted already, when player entered it
+*/
+class BGQueueRemoveEvent : public BasicEvent
+{
+    public:
+        BGQueueRemoveEvent(uint64 pl_guid, uint32 bgInstanceGUID, BattlegroundQueueTypeId bgQueueTypeId, uint32 removeTime)
+            : m_PlayerGuid(pl_guid), m_BgInstanceGUID(bgInstanceGUID), m_RemoveTime(removeTime), m_BgQueueTypeId(bgQueueTypeId)
+        {}
+
+        virtual ~BGQueueRemoveEvent() {}
+
+        virtual bool Execute(uint64 e_time, uint32 p_time);
+        virtual void Abort(uint64 e_time);
+    private:
+        uint64 m_PlayerGuid;
+        uint32 m_BgInstanceGUID;
+        uint32 m_RemoveTime;
+        BattlegroundQueueTypeId m_BgQueueTypeId;
+};
+
+#endif

src/server/game/Battlegrounds/Zones/BattlegroundAB.cpp

@@ -0,0 +1,492 @@
+/*
+REWRITTEN BY XINEF
+*/
+
+#include "BattlegroundAB.h"
+#include "World.h"
+#include "WorldPacket.h"
+#include "ObjectMgr.h"
+#include "BattlegroundMgr.h"
+#include "Creature.h"
+#include "Language.h"
+#include "Object.h"
+#include "Player.h"
+#include "Util.h"
+#include "WorldSession.h"
+
+BattlegroundAB::BattlegroundAB()
+{
+    m_BuffChange = true;
+    BgObjects.resize(BG_AB_OBJECT_MAX);
+    BgCreatures.resize(BG_AB_ALL_NODES_COUNT + BG_AB_DYNAMIC_NODES_COUNT); // xinef: +BG_AB_DYNAMIC_NODES_COUNT buff triggers
+
+	_controlledPoints[TEAM_ALLIANCE] = 0;
+	_controlledPoints[TEAM_HORDE] = 0;
+    _teamScores500Disadvantage[TEAM_ALLIANCE] = false;
+	_teamScores500Disadvantage[TEAM_HORDE] = false;
+	_honorTics = 0;
+	_reputationTics = 0;
+
+    StartMessageIds[BG_STARTING_EVENT_FIRST]  = LANG_BG_AB_START_TWO_MINUTES;
+    StartMessageIds[BG_STARTING_EVENT_SECOND] = LANG_BG_AB_START_ONE_MINUTE;
+    StartMessageIds[BG_STARTING_EVENT_THIRD]  = LANG_BG_AB_START_HALF_MINUTE;
+    StartMessageIds[BG_STARTING_EVENT_FOURTH] = LANG_BG_AB_HAS_BEGUN;
+}
+
+BattlegroundAB::~BattlegroundAB()
+{
+}
+
+void BattlegroundAB::PostUpdateImpl(uint32 diff)
+{
+    if (GetStatus() == STATUS_IN_PROGRESS)
+    {
+		_bgEvents.Update(diff);
+		while (uint32 eventId =_bgEvents.ExecuteEvent())
+			switch (eventId)
+			{
+				case BG_AB_EVENT_UPDATE_BANNER_STABLE:
+				case BG_AB_EVENT_UPDATE_BANNER_FARM:
+				case BG_AB_EVENT_UPDATE_BANNER_BLACKSMITH:
+				case BG_AB_EVENT_UPDATE_BANNER_LUMBERMILL:
+				case BG_AB_EVENT_UPDATE_BANNER_GOLDMINE:
+					CreateBanner(eventId - BG_AB_EVENT_UPDATE_BANNER_STABLE, false);
+					break;
+				case BG_AB_EVENT_CAPTURE_STABLE:
+				case BG_AB_EVENT_CAPTURE_FARM:
+				case BG_AB_EVENT_CAPTURE_BLACKSMITH:
+				case BG_AB_EVENT_CAPTURE_LUMBERMILL:
+				case BG_AB_EVENT_CAPTURE_GOLDMINE:
+				{
+					uint8 node = eventId - BG_AB_EVENT_CAPTURE_STABLE;
+					TeamId teamId = _capturePointInfo[node]._state == BG_AB_NODE_STATE_ALLY_CONTESTED ? TEAM_ALLIANCE : TEAM_HORDE;
+					DeleteBanner(node);
+					_capturePointInfo[node]._ownerTeamId = teamId;
+					_capturePointInfo[node]._state = teamId == TEAM_ALLIANCE ? BG_AB_NODE_STATE_ALLY_OCCUPIED : BG_AB_NODE_STATE_HORDE_OCCUPIED;
+					_capturePointInfo[node]._captured = true;
+
+                    CreateBanner(node, false);
+                    NodeOccupied(node);
+                    SendNodeUpdate(node);
+
+					SendMessage2ToAll(LANG_BG_AB_NODE_TAKEN, teamId == TEAM_ALLIANCE ? CHAT_MSG_BG_SYSTEM_ALLIANCE : CHAT_MSG_BG_SYSTEM_HORDE, NULL, teamId == TEAM_ALLIANCE ? LANG_BG_AB_ALLY : LANG_BG_AB_HORDE, LANG_BG_AB_NODE_STABLES + node);
+					PlaySoundToAll(teamId == TEAM_ALLIANCE ? BG_AB_SOUND_NODE_CAPTURED_ALLIANCE : BG_AB_SOUND_NODE_CAPTURED_HORDE);
+					break;
+				}
+				case BG_AB_EVENT_ALLIANCE_TICK:
+				case BG_AB_EVENT_HORDE_TICK:
+				{
+					TeamId teamId = TeamId(eventId - BG_AB_EVENT_ALLIANCE_TICK);
+					uint8 controlledPoints = _controlledPoints[teamId];
+					if (controlledPoints == 0)
+					{
+						_bgEvents.ScheduleEvent(eventId, 3000);
+						break;
+					}
+
+					uint8 honorRewards = uint8(m_TeamScores[teamId] / _honorTics);
+					uint8 reputationRewards = uint8(m_TeamScores[teamId] / _reputationTics);
+					uint8 information = uint8(m_TeamScores[teamId] / BG_AB_WARNING_NEAR_VICTORY_SCORE);
+					m_TeamScores[teamId] += BG_AB_TickPoints[controlledPoints];
+					if (m_TeamScores[teamId] > BG_AB_MAX_TEAM_SCORE)
+						m_TeamScores[teamId] = BG_AB_MAX_TEAM_SCORE;
+
+					if (honorRewards < uint8(m_TeamScores[teamId] / _honorTics))
+						RewardHonorToTeam(GetBonusHonorFromKill(1), teamId);
+					if (reputationRewards < uint8(m_TeamScores[teamId] / _reputationTics))
+						RewardReputationToTeam(teamId == TEAM_ALLIANCE ? 509 : 510, 10, teamId);
+					if (information < uint8(m_TeamScores[teamId] / BG_AB_WARNING_NEAR_VICTORY_SCORE))
+					{
+						SendMessageToAll(teamId == TEAM_ALLIANCE ? LANG_BG_AB_A_NEAR_VICTORY : LANG_BG_AB_H_NEAR_VICTORY, CHAT_MSG_BG_SYSTEM_NEUTRAL);
+						PlaySoundToAll(BG_AB_SOUND_NEAR_VICTORY);
+					}
+
+					UpdateWorldState(teamId == TEAM_ALLIANCE ? BG_AB_OP_RESOURCES_ALLY : BG_AB_OP_RESOURCES_HORDE, m_TeamScores[teamId]);
+					if (m_TeamScores[teamId] > m_TeamScores[GetOtherTeamId(teamId)] + 500)
+						_teamScores500Disadvantage[GetOtherTeamId(teamId)] = true;
+					if (m_TeamScores[teamId] >= BG_AB_MAX_TEAM_SCORE)
+						EndBattleground(teamId);
+
+					_bgEvents.ScheduleEvent(eventId, BG_AB_TickIntervals[controlledPoints]);
+					break;
+				}
+			}
+	}
+}
+
+void BattlegroundAB::StartingEventCloseDoors()
+{
+
+    for (uint32 obj = BG_AB_OBJECT_BANNER_NEUTRAL; obj < BG_AB_DYNAMIC_NODES_COUNT * BG_AB_OBJECTS_PER_NODE; ++obj)
+        SpawnBGObject(obj, RESPAWN_ONE_DAY);
+    for (uint32 i = 0; i < BG_AB_DYNAMIC_NODES_COUNT * 3; ++i)
+        SpawnBGObject(BG_AB_OBJECT_SPEEDBUFF_STABLES + i, RESPAWN_ONE_DAY);
+
+    // Starting doors
+    SpawnBGObject(BG_AB_OBJECT_GATE_A, RESPAWN_IMMEDIATELY);
+    SpawnBGObject(BG_AB_OBJECT_GATE_H, RESPAWN_IMMEDIATELY);
+    DoorClose(BG_AB_OBJECT_GATE_A);
+    DoorClose(BG_AB_OBJECT_GATE_H);
+}
+
+void BattlegroundAB::StartingEventOpenDoors()
+{
+    for (uint32 banner = BG_AB_OBJECT_BANNER_NEUTRAL, i = 0; i < BG_AB_DYNAMIC_NODES_COUNT; banner += BG_AB_OBJECTS_PER_NODE, ++i)
+        SpawnBGObject(banner, RESPAWN_IMMEDIATELY);
+
+    for (uint32 i = 0; i < BG_AB_DYNAMIC_NODES_COUNT; ++i)
+        SpawnBGObject(BG_AB_OBJECT_SPEEDBUFF_STABLES + urand(0, 2) + i * 3, RESPAWN_IMMEDIATELY);
+
+    DoorOpen(BG_AB_OBJECT_GATE_A);
+    DoorOpen(BG_AB_OBJECT_GATE_H);
+    StartTimedAchievement(ACHIEVEMENT_TIMED_TYPE_EVENT, BG_AB_EVENT_START_BATTLE);
+	_bgEvents.ScheduleEvent(BG_AB_EVENT_ALLIANCE_TICK, 3000);
+	_bgEvents.ScheduleEvent(BG_AB_EVENT_HORDE_TICK, 3000);
+}
+
+void BattlegroundAB::AddPlayer(Player* player)
+{
+    Battleground::AddPlayer(player);
+    PlayerScores[player->GetGUID()] = new BattlegroundABScore(player);
+}
+
+void BattlegroundAB::RemovePlayer(Player* player)
+{
+	player->SetPhaseMask(1, false);
+}
+
+void BattlegroundAB::HandleAreaTrigger(Player* player, uint32 trigger)
+{
+    if (GetStatus() != STATUS_IN_PROGRESS)
+        return;
+
+    switch (trigger)
+    {
+        case 3948:                                          // Arathi Basin Alliance Exit.
+            if (player->GetTeamId() != TEAM_ALLIANCE)
+                player->GetSession()->SendAreaTriggerMessage("Only The Alliance can use that portal");
+            else
+                player->LeaveBattleground();
+            break;
+        case 3949:                                          // Arathi Basin Horde Exit.
+            if (player->GetTeamId() != TEAM_HORDE)
+                player->GetSession()->SendAreaTriggerMessage("Only The Horde can use that portal");
+            else
+                player->LeaveBattleground();
+            break;
+        case 3866:                                          // Stables
+        case 3869:                                          // Gold Mine
+        case 3867:                                          // Farm
+        case 3868:                                          // Lumber Mill
+        case 3870:                                          // Black Smith
+        case 4020:                                          // Unk1
+        case 4021:                                          // Unk2
+            break;
+    }
+}
+
+void BattlegroundAB::CreateBanner(uint8 node, bool delay)
+{
+    // Just put it into the queue
+    if (delay)
+    {
+        _bgEvents.RescheduleEvent(BG_AB_EVENT_UPDATE_BANNER_STABLE+node, BG_AB_BANNER_UPDATE_TIME);
+        return;
+    }
+
+	SpawnBGObject(node*BG_AB_OBJECTS_PER_NODE + _capturePointInfo[node]._state, RESPAWN_IMMEDIATELY);
+	SpawnBGObject(node*BG_AB_OBJECTS_PER_NODE + BG_AB_OBJECT_AURA_ALLY + _capturePointInfo[node]._ownerTeamId, RESPAWN_IMMEDIATELY);
+}
+
+void BattlegroundAB::DeleteBanner(uint8 node)
+{
+	SpawnBGObject(node*BG_AB_OBJECTS_PER_NODE + _capturePointInfo[node]._state, RESPAWN_ONE_DAY);
+	SpawnBGObject(node*BG_AB_OBJECTS_PER_NODE + BG_AB_OBJECT_AURA_ALLY + _capturePointInfo[node]._ownerTeamId, RESPAWN_ONE_DAY);
+}
+
+void BattlegroundAB::FillInitialWorldStates(WorldPacket& data)
+{
+    for (uint8 node = 0; node < BG_AB_DYNAMIC_NODES_COUNT; ++node)
+	{
+		if (_capturePointInfo[node]._state == BG_AB_NODE_STATE_NEUTRAL)
+			data << uint32(_capturePointInfo[node]._iconNone) << uint32(1);
+
+		for (uint8 i = BG_AB_NODE_STATE_ALLY_OCCUPIED; i <= BG_AB_NODE_STATE_HORDE_CONTESTED; ++i)
+			data << uint32(_capturePointInfo[node]._iconCapture + i-1) << uint32(_capturePointInfo[node]._state == i);
+	}
+
+    data << uint32(BG_AB_OP_OCCUPIED_BASES_ALLY)  << uint32(_controlledPoints[TEAM_ALLIANCE]);
+    data << uint32(BG_AB_OP_OCCUPIED_BASES_HORDE) << uint32(_controlledPoints[TEAM_HORDE]);
+    data << uint32(BG_AB_OP_RESOURCES_MAX)      << uint32(BG_AB_MAX_TEAM_SCORE);
+    data << uint32(BG_AB_OP_RESOURCES_WARNING)  << uint32(BG_AB_WARNING_NEAR_VICTORY_SCORE);
+    data << uint32(BG_AB_OP_RESOURCES_ALLY)     << uint32(m_TeamScores[TEAM_ALLIANCE]);
+    data << uint32(BG_AB_OP_RESOURCES_HORDE)    << uint32(m_TeamScores[TEAM_HORDE]);
+    data << uint32(0x745) << uint32(0x2);           // 37 1861 unk
+}
+
+void BattlegroundAB::SendNodeUpdate(uint8 node)
+{
+	UpdateWorldState(_capturePointInfo[node]._iconNone, 0);
+	for (uint8 i = BG_AB_NODE_STATE_ALLY_OCCUPIED; i <= BG_AB_NODE_STATE_HORDE_CONTESTED; ++i)
+		UpdateWorldState(_capturePointInfo[node]._iconCapture + i-1, _capturePointInfo[node]._state == i);
+
+    UpdateWorldState(BG_AB_OP_OCCUPIED_BASES_ALLY, _controlledPoints[TEAM_ALLIANCE]);
+    UpdateWorldState(BG_AB_OP_OCCUPIED_BASES_HORDE, _controlledPoints[TEAM_HORDE]);
+}
+
+void BattlegroundAB::NodeOccupied(uint8 node)
+{
+	ApplyPhaseMask();
+	AddSpiritGuide(node, BG_AB_SpiritGuidePos[node][0], BG_AB_SpiritGuidePos[node][1], BG_AB_SpiritGuidePos[node][2], BG_AB_SpiritGuidePos[node][3], _capturePointInfo[node]._ownerTeamId);
+
+	++_controlledPoints[_capturePointInfo[node]._ownerTeamId];
+    if (_controlledPoints[_capturePointInfo[node]._ownerTeamId] >= 5)
+        CastSpellOnTeam(SPELL_AB_QUEST_REWARD_5_BASES, _capturePointInfo[node]._ownerTeamId);
+    if (_controlledPoints[_capturePointInfo[node]._ownerTeamId] >= 4)
+        CastSpellOnTeam(SPELL_AB_QUEST_REWARD_4_BASES, _capturePointInfo[node]._ownerTeamId);
+
+	Creature* trigger = GetBgMap()->GetCreature(BgCreatures[BG_AB_ALL_NODES_COUNT + node]);
+    if (!trigger)
+        trigger = AddCreature(WORLD_TRIGGER, BG_AB_ALL_NODES_COUNT + node, BG_AB_NodePositions[node][0], BG_AB_NodePositions[node][1], BG_AB_NodePositions[node][2], BG_AB_NodePositions[node][3]);
+
+    if (trigger)
+    {
+        trigger->setFaction(_capturePointInfo[node]._ownerTeamId == TEAM_ALLIANCE ? 84 : 83);
+        trigger->CastSpell(trigger, SPELL_HONORABLE_DEFENDER_25Y, false);
+    }
+}
+
+void BattlegroundAB::NodeDeoccupied(uint8 node)
+{
+	--_controlledPoints[_capturePointInfo[node]._ownerTeamId];
+
+	_capturePointInfo[node]._ownerTeamId = TEAM_NEUTRAL;
+	RelocateDeadPlayers(BgCreatures[node]);
+
+    DelCreature(node); // Delete spirit healer
+    DelCreature(BG_AB_ALL_NODES_COUNT + node); // Delete aura trigger
+}
+
+void BattlegroundAB::EventPlayerClickedOnFlag(Player* player, GameObject* gameObject)
+{
+    if (GetStatus() != STATUS_IN_PROGRESS || !player->IsWithinDistInMap(gameObject, 10.0f))
+		return;
+
+    uint8 node = BG_AB_NODE_STABLES;
+	for (; node < BG_AB_DYNAMIC_NODES_COUNT; ++node)
+		if (player->GetDistance2d(BG_AB_NodePositions[node][0], BG_AB_NodePositions[node][1]) < 10.0f)
+			break;
+
+    if (node == BG_AB_DYNAMIC_NODES_COUNT || _capturePointInfo[node]._ownerTeamId == player->GetTeamId() || 
+		(_capturePointInfo[node]._state == BG_AB_NODE_STATE_ALLY_CONTESTED && player->GetTeamId() == TEAM_ALLIANCE) ||
+		(_capturePointInfo[node]._state == BG_AB_NODE_STATE_HORDE_CONTESTED && player->GetTeamId() == TEAM_HORDE))
+        return;
+
+    player->RemoveAurasWithInterruptFlags(AURA_INTERRUPT_FLAG_ENTER_PVP_COMBAT);
+
+    uint32 sound = 0;
+	uint32 message = 0;
+	uint32 message2 = 0;
+	DeleteBanner(node);
+    CreateBanner(node, true);
+
+	if (_capturePointInfo[node]._state == BG_AB_NODE_STATE_NEUTRAL)
+    {
+		player->KilledMonsterCredit(BG_AB_QUEST_CREDIT_BASE + node, 0);
+        UpdatePlayerScore(player, SCORE_BASES_ASSAULTED, 1);
+		_capturePointInfo[node]._state = BG_AB_NODE_STATE_ALLY_CONTESTED + player->GetTeamId();
+		_capturePointInfo[node]._ownerTeamId = TEAM_NEUTRAL;
+		_bgEvents.RescheduleEvent(BG_AB_EVENT_CAPTURE_STABLE + node, BG_AB_FLAG_CAPTURING_TIME);
+        sound = BG_AB_SOUND_NODE_CLAIMED;
+		message = LANG_BG_AB_NODE_CLAIMED;
+		message2 = player->GetTeamId() == TEAM_ALLIANCE ? LANG_BG_AB_ALLY : LANG_BG_AB_HORDE;
+    }
+    else if (_capturePointInfo[node]._state == BG_AB_NODE_STATE_ALLY_CONTESTED || _capturePointInfo[node]._state == BG_AB_NODE_STATE_HORDE_CONTESTED)
+    {
+		if (!_capturePointInfo[node]._captured)
+        {
+			player->KilledMonsterCredit(BG_AB_QUEST_CREDIT_BASE + node, 0);
+            UpdatePlayerScore(player, SCORE_BASES_ASSAULTED, 1);
+			_capturePointInfo[node]._state = BG_AB_NODE_STATE_ALLY_CONTESTED + player->GetTeamId();
+			_capturePointInfo[node]._ownerTeamId = TEAM_NEUTRAL;
+			_bgEvents.RescheduleEvent(BG_AB_EVENT_CAPTURE_STABLE + node, BG_AB_FLAG_CAPTURING_TIME);
+            message = LANG_BG_AB_NODE_ASSAULTED;
+        }
+        else
+        {
+            UpdatePlayerScore(player, SCORE_BASES_DEFENDED, 1);
+			_capturePointInfo[node]._state = BG_AB_NODE_STATE_ALLY_OCCUPIED + player->GetTeamId();
+			_capturePointInfo[node]._ownerTeamId = player->GetTeamId();
+			_bgEvents.CancelEvent(BG_AB_EVENT_CAPTURE_STABLE + node);
+            NodeOccupied(node); // after setting team owner
+            message = LANG_BG_AB_NODE_DEFENDED;
+        }
+		sound = player->GetTeamId() == TEAM_ALLIANCE ? BG_AB_SOUND_NODE_ASSAULTED_ALLIANCE : BG_AB_SOUND_NODE_ASSAULTED_HORDE;
+    }
+    else
+    {
+		player->KilledMonsterCredit(BG_AB_QUEST_CREDIT_BASE + node, 0);
+        UpdatePlayerScore(player, SCORE_BASES_ASSAULTED, 1);
+        NodeDeoccupied(node); // before setting team owner to neutral
+
+		_capturePointInfo[node]._state = BG_AB_NODE_STATE_ALLY_CONTESTED + player->GetTeamId();
+
+		ApplyPhaseMask();
+		_bgEvents.RescheduleEvent(BG_AB_EVENT_CAPTURE_STABLE + node, BG_AB_FLAG_CAPTURING_TIME);
+        message = LANG_BG_AB_NODE_ASSAULTED;
+        sound = player->GetTeamId() == TEAM_ALLIANCE ? BG_AB_SOUND_NODE_ASSAULTED_ALLIANCE : BG_AB_SOUND_NODE_ASSAULTED_HORDE;
+    }
+
+    SendNodeUpdate(node);
+    PlaySoundToAll(sound);
+	SendMessage2ToAll(message, player->GetTeamId() == TEAM_ALLIANCE ? CHAT_MSG_BG_SYSTEM_ALLIANCE : CHAT_MSG_BG_SYSTEM_HORDE, player, LANG_BG_AB_NODE_STABLES + node, message2);
+}
+
+TeamId BattlegroundAB::GetPrematureWinner()
+{
+    if (_controlledPoints[TEAM_ALLIANCE] > _controlledPoints[TEAM_HORDE])
+        return TEAM_ALLIANCE;
+	return _controlledPoints[TEAM_HORDE] > _controlledPoints[TEAM_ALLIANCE] ? TEAM_HORDE : Battleground::GetPrematureWinner();
+}
+
+bool BattlegroundAB::SetupBattleground()
+{
+    for (uint32 i = 0; i < BG_AB_DYNAMIC_NODES_COUNT; ++i)
+    {
+		AddObject(BG_AB_OBJECT_BANNER_NEUTRAL + BG_AB_OBJECTS_PER_NODE*i, BG_AB_OBJECTID_NODE_BANNER_0 + i, BG_AB_NodePositions[i][0], BG_AB_NodePositions[i][1], BG_AB_NodePositions[i][2], BG_AB_NodePositions[i][3], 0, 0, sin(BG_AB_NodePositions[i][3]/2), cos(BG_AB_NodePositions[i][3]/2), RESPAWN_ONE_DAY);
+        AddObject(BG_AB_OBJECT_BANNER_ALLY + BG_AB_OBJECTS_PER_NODE*i, BG_AB_OBJECTID_BANNER_A, BG_AB_NodePositions[i][0], BG_AB_NodePositions[i][1], BG_AB_NodePositions[i][2], BG_AB_NodePositions[i][3], 0, 0, sin(BG_AB_NodePositions[i][3]/2), cos(BG_AB_NodePositions[i][3]/2), RESPAWN_ONE_DAY);
+        AddObject(BG_AB_OBJECT_BANNER_HORDE + BG_AB_OBJECTS_PER_NODE*i, BG_AB_OBJECTID_BANNER_H, BG_AB_NodePositions[i][0], BG_AB_NodePositions[i][1], BG_AB_NodePositions[i][2], BG_AB_NodePositions[i][3], 0, 0, sin(BG_AB_NodePositions[i][3]/2), cos(BG_AB_NodePositions[i][3]/2), RESPAWN_ONE_DAY);
+        AddObject(BG_AB_OBJECT_BANNER_CONT_A + BG_AB_OBJECTS_PER_NODE*i, BG_AB_OBJECTID_BANNER_CONT_A, BG_AB_NodePositions[i][0], BG_AB_NodePositions[i][1], BG_AB_NodePositions[i][2], BG_AB_NodePositions[i][3], 0, 0, sin(BG_AB_NodePositions[i][3]/2), cos(BG_AB_NodePositions[i][3]/2), RESPAWN_ONE_DAY);
+        AddObject(BG_AB_OBJECT_BANNER_CONT_H + BG_AB_OBJECTS_PER_NODE*i, BG_AB_OBJECTID_BANNER_CONT_H, BG_AB_NodePositions[i][0], BG_AB_NodePositions[i][1], BG_AB_NodePositions[i][2], BG_AB_NodePositions[i][3], 0, 0, sin(BG_AB_NodePositions[i][3]/2), cos(BG_AB_NodePositions[i][3]/2), RESPAWN_ONE_DAY);
+        AddObject(BG_AB_OBJECT_AURA_ALLY + BG_AB_OBJECTS_PER_NODE*i, BG_AB_OBJECTID_AURA_A, BG_AB_NodePositions[i][0], BG_AB_NodePositions[i][1], BG_AB_NodePositions[i][2], BG_AB_NodePositions[i][3], 0, 0, sin(BG_AB_NodePositions[i][3]/2), cos(BG_AB_NodePositions[i][3]/2), RESPAWN_ONE_DAY);
+        AddObject(BG_AB_OBJECT_AURA_HORDE + BG_AB_OBJECTS_PER_NODE*i, BG_AB_OBJECTID_AURA_H, BG_AB_NodePositions[i][0], BG_AB_NodePositions[i][1], BG_AB_NodePositions[i][2], BG_AB_NodePositions[i][3], 0, 0, sin(BG_AB_NodePositions[i][3]/2), cos(BG_AB_NodePositions[i][3]/2), RESPAWN_ONE_DAY);
+        AddObject(BG_AB_OBJECT_AURA_CONTESTED + BG_AB_OBJECTS_PER_NODE*i, BG_AB_OBJECTID_AURA_C, BG_AB_NodePositions[i][0], BG_AB_NodePositions[i][1], BG_AB_NodePositions[i][2], BG_AB_NodePositions[i][3], 0, 0, sin(BG_AB_NodePositions[i][3]/2), cos(BG_AB_NodePositions[i][3]/2), RESPAWN_ONE_DAY);
+    }
+
+    AddObject(BG_AB_OBJECT_GATE_A, BG_AB_OBJECTID_GATE_A, BG_AB_DoorPositions[0][0], BG_AB_DoorPositions[0][1], BG_AB_DoorPositions[0][2], BG_AB_DoorPositions[0][3], BG_AB_DoorPositions[0][4], BG_AB_DoorPositions[0][5], BG_AB_DoorPositions[0][6], BG_AB_DoorPositions[0][7], RESPAWN_IMMEDIATELY);
+    AddObject(BG_AB_OBJECT_GATE_H, BG_AB_OBJECTID_GATE_H, BG_AB_DoorPositions[1][0], BG_AB_DoorPositions[1][1], BG_AB_DoorPositions[1][2], BG_AB_DoorPositions[1][3], BG_AB_DoorPositions[1][4], BG_AB_DoorPositions[1][5], BG_AB_DoorPositions[1][6], BG_AB_DoorPositions[1][7], RESPAWN_IMMEDIATELY);
+
+    for (uint32 i = 0; i < BG_AB_DYNAMIC_NODES_COUNT; ++i)
+    {
+        AddObject(BG_AB_OBJECT_SPEEDBUFF_STABLES + 3 * i, Buff_Entries[0], BG_AB_BuffPositions[i][0], BG_AB_BuffPositions[i][1], BG_AB_BuffPositions[i][2], BG_AB_BuffPositions[i][3], 0, 0, sin(BG_AB_BuffPositions[i][3]/2), cos(BG_AB_BuffPositions[i][3]/2), RESPAWN_ONE_DAY);
+        AddObject(BG_AB_OBJECT_SPEEDBUFF_STABLES + 3 * i + 1, Buff_Entries[1], BG_AB_BuffPositions[i][0], BG_AB_BuffPositions[i][1], BG_AB_BuffPositions[i][2], BG_AB_BuffPositions[i][3], 0, 0, sin(BG_AB_BuffPositions[i][3]/2), cos(BG_AB_BuffPositions[i][3]/2), RESPAWN_ONE_DAY);
+        AddObject(BG_AB_OBJECT_SPEEDBUFF_STABLES + 3 * i + 2, Buff_Entries[2], BG_AB_BuffPositions[i][0], BG_AB_BuffPositions[i][1], BG_AB_BuffPositions[i][2], BG_AB_BuffPositions[i][3], 0, 0, sin(BG_AB_BuffPositions[i][3]/2), cos(BG_AB_BuffPositions[i][3]/2), RESPAWN_ONE_DAY);
+    }
+
+	AddSpiritGuide(BG_AB_SPIRIT_ALIANCE, BG_AB_SpiritGuidePos[BG_AB_SPIRIT_ALIANCE][0], BG_AB_SpiritGuidePos[BG_AB_SPIRIT_ALIANCE][1], BG_AB_SpiritGuidePos[BG_AB_SPIRIT_ALIANCE][2], BG_AB_SpiritGuidePos[BG_AB_SPIRIT_ALIANCE][3], TEAM_ALLIANCE);
+	AddSpiritGuide(BG_AB_SPIRIT_HORDE, BG_AB_SpiritGuidePos[BG_AB_SPIRIT_HORDE][0], BG_AB_SpiritGuidePos[BG_AB_SPIRIT_HORDE][1], BG_AB_SpiritGuidePos[BG_AB_SPIRIT_HORDE][2], BG_AB_SpiritGuidePos[BG_AB_SPIRIT_HORDE][3], TEAM_HORDE);
+
+	for (uint32 i = BG_AB_OBJECT_BANNER_NEUTRAL; i < BG_AB_OBJECT_MAX; ++i)
+		if (BgObjects[i] == 0)
+		{
+			sLog->outErrorDb("BatteGroundAB: Failed to spawn some object Battleground not created!");
+			return false;
+		}
+
+	for (uint32 i = BG_AB_SPIRIT_ALIANCE; i <= BG_AB_SPIRIT_HORDE; ++i)
+		if (BgCreatures[i] == 0)
+		{
+			sLog->outErrorDb("BatteGroundAB: Failed to spawn spirit guides Battleground not created!");
+			return false;
+		}
+
+    return true;
+}
+
+void BattlegroundAB::Init()
+{
+    //call parent's class reset
+    Battleground::Init();
+
+	_bgEvents.Reset();
+
+	_honorTics = BattlegroundMgr::IsBGWeekend(GetBgTypeID()) ? BG_AB_HONOR_TICK_WEEKEND : BG_AB_HONOR_TICK_NORMAL;
+	_reputationTics = BattlegroundMgr::IsBGWeekend(GetBgTypeID()) ? BG_AB_REP_TICK_WEEKEND : BG_AB_REP_TICK_NORMAL;
+
+	_capturePointInfo[BG_AB_NODE_STABLES]._iconNone = BG_AB_OP_STABLE_ICON;
+	_capturePointInfo[BG_AB_NODE_FARM]._iconNone = BG_AB_OP_FARM_ICON;
+	_capturePointInfo[BG_AB_NODE_BLACKSMITH]._iconNone = BG_AB_OP_BLACKSMITH_ICON;
+	_capturePointInfo[BG_AB_NODE_LUMBER_MILL]._iconNone = BG_AB_OP_LUMBERMILL_ICON;
+	_capturePointInfo[BG_AB_NODE_GOLD_MINE]._iconNone = BG_AB_OP_GOLDMINE_ICON;
+	_capturePointInfo[BG_AB_NODE_STABLES]._iconCapture = BG_AB_OP_STABLE_STATE_ALIENCE;
+	_capturePointInfo[BG_AB_NODE_FARM]._iconCapture = BG_AB_OP_FARM_STATE_ALIENCE;
+	_capturePointInfo[BG_AB_NODE_BLACKSMITH]._iconCapture = BG_AB_OP_BLACKSMITH_STATE_ALIENCE;
+	_capturePointInfo[BG_AB_NODE_LUMBER_MILL]._iconCapture = BG_AB_OP_LUMBERMILL_STATE_ALIENCE;
+	_capturePointInfo[BG_AB_NODE_GOLD_MINE]._iconCapture = BG_AB_OP_GOLDMINE_STATE_ALIENCE;
+}
+
+void BattlegroundAB::EndBattleground(TeamId winnerTeamId)
+{
+    RewardHonorToTeam(GetBonusHonorFromKill(1), winnerTeamId);
+    RewardHonorToTeam(GetBonusHonorFromKill(1), TEAM_HORDE);
+    RewardHonorToTeam(GetBonusHonorFromKill(1), TEAM_ALLIANCE);
+    Battleground::EndBattleground(winnerTeamId);
+	_bgEvents.Reset();
+}
+
+WorldSafeLocsEntry const* BattlegroundAB::GetClosestGraveyard(Player* player)
+{
+	WorldSafeLocsEntry const* entry = sWorldSafeLocsStore.LookupEntry(BG_AB_GraveyardIds[BG_AB_SPIRIT_ALIANCE + player->GetTeamId()]);
+    WorldSafeLocsEntry const* nearestEntry = entry;
+
+	float pX = player->GetPositionX();
+	float pY = player->GetPositionY();
+	float dist = (entry->x - pX)*(entry->x - pX)+(entry->y - pY)*(entry->y - pY);
+	float minDist = dist;
+
+	for (uint8 i = BG_AB_NODE_STABLES; i < BG_AB_DYNAMIC_NODES_COUNT; ++i)
+		if (_capturePointInfo[i]._ownerTeamId == player->GetTeamId())
+		{
+			entry = sWorldSafeLocsStore.LookupEntry(BG_AB_GraveyardIds[i]);
+            dist = (entry->x - pX)*(entry->x - pX) + (entry->y - pY)*(entry->y - pY);
+            if (dist < minDist)
+            {
+                minDist = dist;
+                nearestEntry = entry;
+            }
+        }
+
+    return nearestEntry;
+}
+
+void BattlegroundAB::UpdatePlayerScore(Player* player, uint32 type, uint32 value, bool doAddHonor)
+{
+    BattlegroundScoreMap::iterator itr = PlayerScores.find(player->GetGUID());
+    if (itr == PlayerScores.end())
+        return;
+
+    switch (type)
+    {
+        case SCORE_BASES_ASSAULTED:
+            ((BattlegroundABScore*)itr->second)->BasesAssaulted += value;
+            player->UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_BG_OBJECTIVE_CAPTURE, BG_AB_OBJECTIVE_ASSAULT_BASE);
+            break;
+        case SCORE_BASES_DEFENDED:
+            ((BattlegroundABScore*)itr->second)->BasesDefended += value;
+            player->UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_BG_OBJECTIVE_CAPTURE, BG_AB_OBJECTIVE_DEFEND_BASE);
+            break;
+        default:
+            Battleground::UpdatePlayerScore(player, type, value, doAddHonor);
+            break;
+    }
+}
+
+bool BattlegroundAB::AllNodesConrolledByTeam(TeamId teamId) const
+{
+    return _controlledPoints[teamId] == BG_AB_DYNAMIC_NODES_COUNT;
+}
+
+void BattlegroundAB::ApplyPhaseMask()
+{
+	uint32 phaseMask = 1;
+	for (uint32 i = BG_AB_NODE_STABLES; i < BG_AB_DYNAMIC_NODES_COUNT; ++i)
+		if (_capturePointInfo[i]._ownerTeamId != TEAM_NEUTRAL)
+			phaseMask |= 1 << (i*2+1 + _capturePointInfo[i]._ownerTeamId);
+
+	const BattlegroundPlayerMap& bgPlayerMap = GetPlayers();
+	for (BattlegroundPlayerMap::const_iterator itr = bgPlayerMap.begin(); itr != bgPlayerMap.end(); ++itr)
+	{
+		itr->second->SetPhaseMask(phaseMask, false);
+		itr->second->UpdateObjectVisibility(true, false);
+	}
+}

src/server/game/Battlegrounds/Zones/BattlegroundAB.h

@@ -0,0 +1,276 @@
+/*
+REWRITTEN BY XINEF
+*/
+
+#ifndef __BATTLEGROUNDAB_H
+#define __BATTLEGROUNDAB_H
+
+#include "Battleground.h"
+
+enum BG_AB_Events
+{
+	BG_AB_EVENT_UPDATE_BANNER_STABLE		= 1,
+	BG_AB_EVENT_UPDATE_BANNER_FARM			= 2,
+	BG_AB_EVENT_UPDATE_BANNER_BLACKSMITH	= 3,
+	BG_AB_EVENT_UPDATE_BANNER_LUMBERMILL	= 4,
+	BG_AB_EVENT_UPDATE_BANNER_GOLDMINE		= 5,
+
+	BG_AB_EVENT_CAPTURE_STABLE				= 6,
+	BG_AB_EVENT_CAPTURE_FARM				= 7,
+	BG_AB_EVENT_CAPTURE_BLACKSMITH			= 8,
+	BG_AB_EVENT_CAPTURE_LUMBERMILL			= 9,
+	BG_AB_EVENT_CAPTURE_GOLDMINE			= 10,
+
+	BG_AB_EVENT_ALLIANCE_TICK				= 11,
+	BG_AB_EVENT_HORDE_TICK					= 12
+};
+
+enum BG_AB_WorldStates
+{
+    BG_AB_OP_OCCUPIED_BASES_HORDE       = 1778,
+    BG_AB_OP_OCCUPIED_BASES_ALLY        = 1779,
+    BG_AB_OP_RESOURCES_ALLY             = 1776,
+    BG_AB_OP_RESOURCES_HORDE            = 1777,
+    BG_AB_OP_RESOURCES_MAX              = 1780,
+    BG_AB_OP_RESOURCES_WARNING          = 1955,
+
+    BG_AB_OP_STABLE_ICON                = 1842,             //Stable map icon (NONE)
+    BG_AB_OP_STABLE_STATE_ALIENCE       = 1767,             //Stable map state (ALIENCE)
+    BG_AB_OP_STABLE_STATE_HORDE         = 1768,             //Stable map state (HORDE)
+    BG_AB_OP_STABLE_STATE_CON_ALI       = 1769,             //Stable map state (CON ALIENCE)
+    BG_AB_OP_STABLE_STATE_CON_HOR       = 1770,             //Stable map state (CON HORDE)
+
+    BG_AB_OP_FARM_ICON                  = 1845,             //Farm map icon (NONE)
+    BG_AB_OP_FARM_STATE_ALIENCE         = 1772,             //Farm state (ALIENCE)
+    BG_AB_OP_FARM_STATE_HORDE           = 1773,             //Farm state (HORDE)
+    BG_AB_OP_FARM_STATE_CON_ALI         = 1774,             //Farm state (CON ALIENCE)
+    BG_AB_OP_FARM_STATE_CON_HOR         = 1775,             //Farm state (CON HORDE)
+
+    BG_AB_OP_BLACKSMITH_ICON            = 1846,             //Blacksmith map icon (NONE)
+    BG_AB_OP_BLACKSMITH_STATE_ALIENCE   = 1782,             //Blacksmith map state (ALIENCE)
+    BG_AB_OP_BLACKSMITH_STATE_HORDE     = 1783,             //Blacksmith map state (HORDE)
+    BG_AB_OP_BLACKSMITH_STATE_CON_ALI   = 1784,             //Blacksmith map state (CON ALIENCE)
+    BG_AB_OP_BLACKSMITH_STATE_CON_HOR   = 1785,             //Blacksmith map state (CON HORDE)
+
+    BG_AB_OP_LUMBERMILL_ICON            = 1844,             //Lumber Mill map icon (NONE)
+    BG_AB_OP_LUMBERMILL_STATE_ALIENCE   = 1792,             //Lumber Mill map state (ALIENCE)
+    BG_AB_OP_LUMBERMILL_STATE_HORDE     = 1793,             //Lumber Mill map state (HORDE)
+    BG_AB_OP_LUMBERMILL_STATE_CON_ALI   = 1794,             //Lumber Mill map state (CON ALIENCE)
+    BG_AB_OP_LUMBERMILL_STATE_CON_HOR   = 1795,             //Lumber Mill map state (CON HORDE)
+
+    BG_AB_OP_GOLDMINE_ICON              = 1843,             //Gold Mine map icon (NONE)
+    BG_AB_OP_GOLDMINE_STATE_ALIENCE     = 1787,             //Gold Mine map state (ALIENCE)
+    BG_AB_OP_GOLDMINE_STATE_HORDE       = 1788,             //Gold Mine map state (HORDE)
+    BG_AB_OP_GOLDMINE_STATE_CON_ALI     = 1789,             //Gold Mine map state (CON ALIENCE
+    BG_AB_OP_GOLDMINE_STATE_CON_HOR     = 1790,             //Gold Mine map state (CON HORDE)
+};
+
+enum BG_AB_ObjectIds
+{
+    BG_AB_OBJECTID_NODE_BANNER_0		= 180087,       // Stables banner
+    BG_AB_OBJECTID_NODE_BANNER_1		= 180088,       // Blacksmith banner
+    BG_AB_OBJECTID_NODE_BANNER_2		= 180089,       // Farm banner
+    BG_AB_OBJECTID_NODE_BANNER_3		= 180090,       // Lumber mill banner
+    BG_AB_OBJECTID_NODE_BANNER_4		= 180091,       // Gold mine banner
+
+    BG_AB_OBJECTID_BANNER_A             = 180058,
+    BG_AB_OBJECTID_BANNER_CONT_A        = 180059,
+    BG_AB_OBJECTID_BANNER_H             = 180060,
+    BG_AB_OBJECTID_BANNER_CONT_H        = 180061,
+
+    BG_AB_OBJECTID_AURA_A               = 180100,
+    BG_AB_OBJECTID_AURA_H               = 180101,
+    BG_AB_OBJECTID_AURA_C               = 180102,
+
+    BG_AB_OBJECTID_GATE_A               = 180255,
+    BG_AB_OBJECTID_GATE_H               = 180256
+};
+
+enum BG_AB_ObjectType
+{
+    BG_AB_OBJECT_BANNER_NEUTRAL          = 0,
+    BG_AB_OBJECT_BANNER_ALLY             = 1,
+    BG_AB_OBJECT_BANNER_HORDE            = 2,
+    BG_AB_OBJECT_BANNER_CONT_A           = 3,
+    BG_AB_OBJECT_BANNER_CONT_H           = 4,
+    BG_AB_OBJECT_AURA_ALLY               = 5,
+    BG_AB_OBJECT_AURA_HORDE              = 6,
+    BG_AB_OBJECT_AURA_CONTESTED          = 7,
+	BG_AB_OBJECTS_PER_NODE				 = 8,
+
+    BG_AB_OBJECT_GATE_A                  = 40,
+    BG_AB_OBJECT_GATE_H                  = 41,
+
+    BG_AB_OBJECT_SPEEDBUFF_STABLES       = 42,
+    BG_AB_OBJECT_REGENBUFF_STABLES       = 43,
+    BG_AB_OBJECT_BERSERKBUFF_STABLES     = 44,
+    BG_AB_OBJECT_SPEEDBUFF_BLACKSMITH    = 45,
+    BG_AB_OBJECT_REGENBUFF_BLACKSMITH    = 46,
+    BG_AB_OBJECT_BERSERKBUFF_BLACKSMITH  = 47,
+    BG_AB_OBJECT_SPEEDBUFF_FARM          = 48,
+    BG_AB_OBJECT_REGENBUFF_FARM          = 49,
+    BG_AB_OBJECT_BERSERKBUFF_FARM        = 50,
+    BG_AB_OBJECT_SPEEDBUFF_LUMBER_MILL   = 51,
+    BG_AB_OBJECT_REGENBUFF_LUMBER_MILL   = 52,
+    BG_AB_OBJECT_BERSERKBUFF_LUMBER_MILL = 53,
+    BG_AB_OBJECT_SPEEDBUFF_GOLD_MINE     = 54,
+    BG_AB_OBJECT_REGENBUFF_GOLD_MINE     = 55,
+    BG_AB_OBJECT_BERSERKBUFF_GOLD_MINE   = 56,
+    BG_AB_OBJECT_MAX                     = 57,
+};
+
+enum BG_AB_BattlegroundNodes
+{
+    BG_AB_NODE_STABLES          = 0,
+    BG_AB_NODE_BLACKSMITH       = 1,
+    BG_AB_NODE_FARM             = 2,
+    BG_AB_NODE_LUMBER_MILL      = 3,
+    BG_AB_NODE_GOLD_MINE        = 4,
+    BG_AB_DYNAMIC_NODES_COUNT   = 5,                        // dynamic nodes that can be captured
+
+    BG_AB_SPIRIT_ALIANCE        = 5,
+    BG_AB_SPIRIT_HORDE          = 6,
+    BG_AB_ALL_NODES_COUNT       = 7,                        // all nodes (dynamic and static)
+};
+
+enum BG_AB_NodeStatus
+{
+	BG_AB_NODE_STATE_NEUTRAL			= 0,
+	BG_AB_NODE_STATE_ALLY_OCCUPIED		= 1,
+	BG_AB_NODE_STATE_HORDE_OCCUPIED		= 2,
+	BG_AB_NODE_STATE_ALLY_CONTESTED		= 3,
+	BG_AB_NODE_STATE_HORDE_CONTESTED	= 4
+};
+
+enum BG_AB_Sounds
+{
+    BG_AB_SOUND_NODE_CLAIMED            = 8192,
+    BG_AB_SOUND_NODE_CAPTURED_ALLIANCE  = 8173,
+    BG_AB_SOUND_NODE_CAPTURED_HORDE     = 8213,
+    BG_AB_SOUND_NODE_ASSAULTED_ALLIANCE = 8212,
+    BG_AB_SOUND_NODE_ASSAULTED_HORDE    = 8174,
+    BG_AB_SOUND_NEAR_VICTORY            = 8456
+};
+
+enum BG_AB_Misc
+{
+    BG_AB_OBJECTIVE_ASSAULT_BASE        = 122,
+    BG_AB_OBJECTIVE_DEFEND_BASE         = 123,
+	BG_AB_EVENT_START_BATTLE			= 9158, // Achievement: Let's Get This Done
+	BG_AB_QUEST_CREDIT_BASE				= 15001,
+
+	BG_AB_HONOR_TICK_NORMAL				= 260,
+	BG_AB_HONOR_TICK_WEEKEND			= 160,
+	BG_AB_REP_TICK_NORMAL				= 160,
+	BG_AB_REP_TICK_WEEKEND				= 120,
+
+    BG_AB_WARNING_NEAR_VICTORY_SCORE    = 1400,
+    BG_AB_MAX_TEAM_SCORE                = 1600,
+
+    BG_AB_FLAG_CAPTURING_TIME           = 60000,
+	BG_AB_BANNER_UPDATE_TIME			= 2000
+};
+
+const uint32 BG_AB_TickIntervals[BG_AB_DYNAMIC_NODES_COUNT+1] = {0, 12000, 9000, 6000, 3000, 1000};
+const uint32 BG_AB_TickPoints[BG_AB_DYNAMIC_NODES_COUNT+1] = {0, 10, 10, 10, 10, 30};
+const uint32 BG_AB_GraveyardIds[BG_AB_ALL_NODES_COUNT] = {895, 894, 893, 897, 896, 898, 899};
+
+const float BG_AB_BuffPositions[BG_AB_DYNAMIC_NODES_COUNT][4] =
+{
+    {1185.71f, 1185.24f, -56.36f, 2.56f},                   // stables
+    {990.75f, 1008.18f, -42.60f, 2.43f},                    // blacksmith
+    {817.66f, 843.34f, -56.54f, 3.01f},                     // farm
+    {807.46f, 1189.16f, 11.92f, 5.44f},                     // lumber mill
+    {1146.62f, 816.94f, -98.49f, 6.14f}                     // gold mine
+};
+
+const float BG_AB_NodePositions[BG_AB_DYNAMIC_NODES_COUNT][4] =
+{
+    {1166.785f, 1200.132f, -56.70859f, 0.9075713f},         // stables
+    {977.0156f, 1046.616f, -44.80923f, -2.600541f},         // blacksmith
+    {806.1821f, 874.2723f, -55.99371f, -2.303835f},         // farm
+    {856.1419f, 1148.902f, 11.18469f, -2.303835f},          // lumber mill
+    {1146.923f, 848.1782f, -110.917f, -0.7330382f}          // gold mine
+};
+
+const float BG_AB_DoorPositions[2][8] =
+{
+    {1284.597f, 1281.167f, -15.97792f, 0.7068594f, 0.012957f, -0.060288f, 0.344959f, 0.93659f},
+    {708.0903f, 708.4479f, -17.8342f, -2.391099f, 0.050291f, 0.015127f, 0.929217f, -0.365784f}
+};
+
+const float BG_AB_SpiritGuidePos[BG_AB_ALL_NODES_COUNT][4] =
+{
+    {1200.03f, 1171.09f, -56.47f, 5.15f},                   // stables
+    {1017.43f, 960.61f, -42.95f, 4.88f},                    // blacksmith
+    {833.00f, 793.00f, -57.25f, 5.27f},                     // farm
+    {775.17f, 1206.40f, 15.79f, 1.90f},                     // lumber mill
+    {1207.48f, 787.00f, -83.36f, 5.51f},                    // gold mine
+    {1354.05f, 1275.48f, -11.30f, 4.77f},                   // alliance starting base
+    {714.61f, 646.15f, -10.87f, 4.34f}                      // horde starting base
+};
+
+struct BattlegroundABScore : public BattlegroundScore
+{
+    BattlegroundABScore(Player* player) : BattlegroundScore(player), BasesAssaulted(0), BasesDefended(0) { }
+    ~BattlegroundABScore() { }
+    uint32 BasesAssaulted;
+    uint32 BasesDefended;
+};
+
+class BattlegroundAB : public Battleground
+{
+    public:
+        BattlegroundAB();
+        ~BattlegroundAB();
+
+        void AddPlayer(Player* player);
+        void StartingEventCloseDoors();
+        void StartingEventOpenDoors();
+        void RemovePlayer(Player* player);
+        void HandleAreaTrigger(Player* player, uint32 trigger);
+        bool SetupBattleground();
+        void Init();
+        void EndBattleground(TeamId winnerTeamId);
+        WorldSafeLocsEntry const* GetClosestGraveyard(Player* player);
+
+        void UpdatePlayerScore(Player* player, uint32 type, uint32 value, bool doAddHonor = true);
+        void FillInitialWorldStates(WorldPacket& data);
+        void EventPlayerClickedOnFlag(Player* source, GameObject* gameObject);
+
+        bool AllNodesConrolledByTeam(TeamId teamId) const;
+        bool IsTeamScores500Disadvantage(TeamId teamId) const { return _teamScores500Disadvantage[teamId]; }
+        
+        TeamId GetPrematureWinner();
+    private:
+        void PostUpdateImpl(uint32 diff);
+
+        void DeleteBanner(uint8 node);
+        void CreateBanner(uint8 node, bool delay);
+        void SendNodeUpdate(uint8 node);
+        void NodeOccupied(uint8 node);
+        void NodeDeoccupied(uint8 node);
+		void ApplyPhaseMask();
+
+		struct CapturePointInfo
+		{
+			CapturePointInfo() : _ownerTeamId(TEAM_NEUTRAL), _iconNone(0), _iconCapture(0), _state(BG_AB_NODE_STATE_NEUTRAL), _captured(false)
+			{
+			}
+
+			uint8 _state;
+			uint32 _iconNone;
+			uint32 _iconCapture;
+			TeamId _ownerTeamId;
+			bool _captured;
+		};
+
+		CapturePointInfo _capturePointInfo[BG_AB_DYNAMIC_NODES_COUNT];
+		EventMap _bgEvents;
+        uint32 _honorTics;
+        uint32 _reputationTics;
+		uint8 _controlledPoints[BG_TEAMS_COUNT];
+        bool _teamScores500Disadvantage[BG_TEAMS_COUNT];
+};
+#endif
+

src/server/game/Battlegrounds/Zones/BattlegroundBE.cpp

@@ -0,0 +1,178 @@
+/*
+ * Copyright (C) 
+ * Copyright (C) 
+ *
+ * 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "BattlegroundBE.h"
+#include "Language.h"
+#include "Object.h"
+#include "ObjectMgr.h"
+#include "Player.h"
+#include "WorldPacket.h"
+#include "WorldSession.h"
+
+BattlegroundBE::BattlegroundBE()
+{
+    BgObjects.resize(BG_BE_OBJECT_MAX);
+
+    StartDelayTimes[BG_STARTING_EVENT_FIRST]  = BG_START_DELAY_1M;
+    StartDelayTimes[BG_STARTING_EVENT_SECOND] = BG_START_DELAY_30S;
+    StartDelayTimes[BG_STARTING_EVENT_THIRD]  = BG_START_DELAY_15S;
+    StartDelayTimes[BG_STARTING_EVENT_FOURTH] = BG_START_DELAY_NONE;
+    //we must set messageIds
+    StartMessageIds[BG_STARTING_EVENT_FIRST]  = LANG_ARENA_ONE_MINUTE;
+    StartMessageIds[BG_STARTING_EVENT_SECOND] = LANG_ARENA_THIRTY_SECONDS;
+    StartMessageIds[BG_STARTING_EVENT_THIRD]  = LANG_ARENA_FIFTEEN_SECONDS;
+    StartMessageIds[BG_STARTING_EVENT_FOURTH] = LANG_ARENA_HAS_BEGUN;
+}
+
+BattlegroundBE::~BattlegroundBE()
+{
+
+}
+
+void BattlegroundBE::StartingEventCloseDoors()
+{
+    for (uint32 i = BG_BE_OBJECT_DOOR_1; i <= BG_BE_OBJECT_DOOR_4; ++i)
+        SpawnBGObject(i, RESPAWN_IMMEDIATELY);
+
+    for (uint32 i = BG_BE_OBJECT_BUFF_1; i <= BG_BE_OBJECT_BUFF_2; ++i)
+        SpawnBGObject(i, RESPAWN_ONE_DAY);
+}
+
+void BattlegroundBE::StartingEventOpenDoors()
+{
+    for (uint32 i = BG_BE_OBJECT_DOOR_1; i <= BG_BE_OBJECT_DOOR_2; ++i)
+        DoorOpen(i);
+
+    for (uint32 i = BG_BE_OBJECT_BUFF_1; i <= BG_BE_OBJECT_BUFF_2; ++i)
+        SpawnBGObject(i, 60);
+}
+
+void BattlegroundBE::AddPlayer(Player* player)
+{
+    Battleground::AddPlayer(player);
+    PlayerScores[player->GetGUID()] = new BattlegroundScore(player);
+    Battleground::UpdateArenaWorldState();
+}
+
+void BattlegroundBE::RemovePlayer(Player* /*player*/)
+{
+    if (GetStatus() == STATUS_WAIT_LEAVE)
+        return;
+
+    Battleground::UpdateArenaWorldState();
+    CheckArenaWinConditions();
+}
+
+void BattlegroundBE::HandleKillPlayer(Player* player, Player* killer)
+{
+    if (GetStatus() != STATUS_IN_PROGRESS)
+        return;
+
+    if (!killer)
+    {
+        sLog->outError("Killer player not found");
+        return;
+    }
+
+    Battleground::HandleKillPlayer(player, killer);
+
+    Battleground::UpdateArenaWorldState();
+    CheckArenaWinConditions();
+}
+
+bool BattlegroundBE::HandlePlayerUnderMap(Player* player)
+{
+    player->NearTeleportTo(6238.930176f, 262.963470f, 0.889519f, player->GetOrientation());
+    return true;
+}
+
+void BattlegroundBE::HandleAreaTrigger(Player* player, uint32 trigger)
+{
+    // this is wrong way to implement these things. On official it done by gameobject spell cast.
+    if (GetStatus() != STATUS_IN_PROGRESS)
+        return;
+
+    switch (trigger)
+    {
+        case 4538:                                          // buff trigger?
+            //buff_guid = BgObjects[BG_BE_OBJECT_BUFF_1];
+            break;
+        case 4539:                                          // buff trigger?
+            //buff_guid = BgObjects[BG_BE_OBJECT_BUFF_2];
+            break;
+		// OUTSIDE OF ARENA, TELEPORT!
+		case 4919:
+			player->NearTeleportTo(6220.90f, 318.94f, 5.1f, 5.3f);
+			break;
+		case 4921:
+			player->NearTeleportTo(6250.27f, 208.50f, 4.77f, 1.9f);
+			break;
+		case 4922:
+			player->NearTeleportTo(6214.4f, 227.12f, 4.28f, 0.8f);
+			break;
+		case 4923:
+			player->NearTeleportTo(6180.98f, 265.28f, 4.27f, 6.06f);
+			break;
+		case 4924:
+			player->NearTeleportTo(6269.0f, 295.06f, 4.46f, 3.98f);
+			break;
+		case 4944: // under arena -20
+		case 5039: // under arena -40
+		case 5040: // under arena -60
+			player->NearTeleportTo(6238.930176f, 262.963470f, 0.889519f, player->GetOrientation());
+			break;
+    }
+}
+
+void BattlegroundBE::FillInitialWorldStates(WorldPacket &data)
+{
+    data << uint32(0x9f3) << uint32(1);           // 9
+    Battleground::UpdateArenaWorldState();
+}
+
+void BattlegroundBE::Init()
+{
+    //call parent's class reset
+    Battleground::Init();
+}
+
+bool BattlegroundBE::SetupBattleground()
+{
+    // gates
+    if (!AddObject(BG_BE_OBJECT_DOOR_1, BG_BE_OBJECT_TYPE_DOOR_1, 6287.277f, 282.1877f, 3.810925f, -2.260201f, 0, 0, 0.9044551f, -0.4265689f, RESPAWN_IMMEDIATELY)
+        || !AddObject(BG_BE_OBJECT_DOOR_2, BG_BE_OBJECT_TYPE_DOOR_2, 6189.546f, 241.7099f, 3.101481f, 0.8813917f, 0, 0, 0.4265689f, 0.9044551f, RESPAWN_IMMEDIATELY)
+        || !AddObject(BG_BE_OBJECT_DOOR_3, BG_BE_OBJECT_TYPE_DOOR_3, 6299.116f, 296.5494f, 3.308032f, 0.8813917f, 0, 0, 0.4265689f, 0.9044551f, RESPAWN_IMMEDIATELY)
+        || !AddObject(BG_BE_OBJECT_DOOR_4, BG_BE_OBJECT_TYPE_DOOR_4, 6177.708f, 227.3481f, 3.604374f, -2.260201f, 0, 0, 0.9044551f, -0.4265689f, RESPAWN_IMMEDIATELY)
+        // buffs
+        || !AddObject(BG_BE_OBJECT_BUFF_1, BG_BE_OBJECT_TYPE_BUFF_1, 6249.042f, 275.3239f, 11.22033f, -1.448624f, 0, 0, 0.6626201f, -0.7489557f, 120)
+        || !AddObject(BG_BE_OBJECT_BUFF_2, BG_BE_OBJECT_TYPE_BUFF_2, 6228.26f, 249.566f, 11.21812f, -0.06981307f, 0, 0, 0.03489945f, -0.9993908f, 120)
+        // Arena Ready Marker
+        || !AddObject(BG_BE_OBJECT_READY_MARKER_1, ARENA_READY_MARKER_ENTRY, 6189.47f, 235.54f, 5.52f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 300)
+        || !AddObject(BG_BE_OBJECT_READY_MARKER_2, ARENA_READY_MARKER_ENTRY, 6287.19f, 288.25f, 5.33f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 300))
+    {
+        sLog->outErrorDb("BatteGroundBE: Failed to spawn some object!");
+        return false;
+    }
+
+    return true;
+}
+
+void BattlegroundBE::UpdatePlayerScore(Player* player, uint32 type, uint32 value, bool doAddHonor)
+{
+    Battleground::UpdatePlayerScore(player, type, value, doAddHonor);
+}

src/server/game/Battlegrounds/Zones/BattlegroundBE.h

@@ -0,0 +1,69 @@
+/*
+ * Copyright (C) 
+ * Copyright (C) 
+ *
+ * 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef __BATTLEGROUNDBE_H
+#define __BATTLEGROUNDBE_H
+
+#include "Battleground.h"
+
+enum BattlegroundBEObjectTypes
+{
+    BG_BE_OBJECT_DOOR_1         = 0,
+    BG_BE_OBJECT_DOOR_2         = 1,
+    BG_BE_OBJECT_DOOR_3         = 2,
+    BG_BE_OBJECT_DOOR_4         = 3,
+    BG_BE_OBJECT_BUFF_1         = 4,
+    BG_BE_OBJECT_BUFF_2         = 5,
+	BG_BE_OBJECT_READY_MARKER_1 = 6,
+	BG_BE_OBJECT_READY_MARKER_2 = 7,
+    BG_BE_OBJECT_MAX            = 8
+};
+
+enum BattlegroundBEObjects
+{
+    BG_BE_OBJECT_TYPE_DOOR_1    = 183971,
+    BG_BE_OBJECT_TYPE_DOOR_2    = 183973,
+    BG_BE_OBJECT_TYPE_DOOR_3    = 183970,
+    BG_BE_OBJECT_TYPE_DOOR_4    = 183972,
+    BG_BE_OBJECT_TYPE_BUFF_1    = 184663,
+    BG_BE_OBJECT_TYPE_BUFF_2    = 184664
+};
+
+class BattlegroundBE : public Battleground
+{
+    public:
+        BattlegroundBE();
+        ~BattlegroundBE();
+
+        /* inherited from BattlegroundClass */
+        void AddPlayer(Player* player);
+        void StartingEventCloseDoors();
+        void StartingEventOpenDoors();
+
+        void RemovePlayer(Player* player);
+        void HandleAreaTrigger(Player* player, uint32 trigger);
+        bool SetupBattleground();
+        void Init();
+        void FillInitialWorldStates(WorldPacket &d);
+        void HandleKillPlayer(Player* player, Player* killer);
+        bool HandlePlayerUnderMap(Player* player);
+
+        /* Scorekeeping */
+        void UpdatePlayerScore(Player* player, uint32 type, uint32 value, bool doAddHonor = true);
+};
+#endif

src/server/game/Battlegrounds/Zones/BattlegroundDS.cpp

@@ -0,0 +1,267 @@
+/*
+ * Copyright (C) 
+ * Copyright (C) 
+ *
+ * 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "BattlegroundDS.h"
+#include "Creature.h"
+#include "GameObject.h"
+#include "Language.h"
+#include "ObjectAccessor.h"
+#include "Player.h"
+#include "WorldPacket.h"
+#include "WorldSession.h"
+
+BattlegroundDS::BattlegroundDS()
+{
+    BgObjects.resize(BG_DS_OBJECT_MAX);
+    BgCreatures.resize(BG_DS_NPC_MAX);
+
+    _waterfallTimer = 0;
+    _waterfallStatus = 0;
+    _waterfallKnockbackTimer = 0;
+    _pipeKnockBackTimer = 0;
+    _pipeKnockBackCount = 0;
+
+    StartDelayTimes[BG_STARTING_EVENT_FIRST]  = BG_START_DELAY_1M;
+    StartDelayTimes[BG_STARTING_EVENT_SECOND] = BG_START_DELAY_30S;
+    StartDelayTimes[BG_STARTING_EVENT_THIRD]  = BG_START_DELAY_15S;
+    StartDelayTimes[BG_STARTING_EVENT_FOURTH] = BG_START_DELAY_NONE;
+    //we must set messageIds
+    StartMessageIds[BG_STARTING_EVENT_FIRST]  = LANG_ARENA_ONE_MINUTE;
+    StartMessageIds[BG_STARTING_EVENT_SECOND] = LANG_ARENA_THIRTY_SECONDS;
+    StartMessageIds[BG_STARTING_EVENT_THIRD]  = LANG_ARENA_FIFTEEN_SECONDS;
+    StartMessageIds[BG_STARTING_EVENT_FOURTH] = LANG_ARENA_HAS_BEGUN;
+}
+
+BattlegroundDS::~BattlegroundDS()
+{
+
+}
+
+void BattlegroundDS::PostUpdateImpl(uint32 diff)
+{
+    if (GetStatus() != STATUS_IN_PROGRESS)
+        return;
+
+    if (getPipeKnockBackCount() < BG_DS_PIPE_KNOCKBACK_TOTAL_COUNT)
+    {
+        if (getPipeKnockBackTimer() < diff)
+        {
+            for (uint32 i = BG_DS_NPC_PIPE_KNOCKBACK_1; i <= BG_DS_NPC_PIPE_KNOCKBACK_2; ++i)
+                if (Creature* waterSpout = GetBgMap()->GetCreature(BgCreatures[i]))
+                    waterSpout->CastSpell(waterSpout, BG_DS_SPELL_FLUSH, true);
+
+            setPipeKnockBackCount(getPipeKnockBackCount() + 1);
+            setPipeKnockBackTimer(BG_DS_PIPE_KNOCKBACK_DELAY);
+        }
+        else
+            setPipeKnockBackTimer(getPipeKnockBackTimer() - diff);
+    }
+
+    if (getWaterFallStatus() == BG_DS_WATERFALL_STATUS_ON) // Repeat knockback while the waterfall still active
+    {
+        if (getWaterFallKnockbackTimer() < diff)
+        {
+            if (Creature* waterSpout = GetBgMap()->GetCreature(BgCreatures[BG_DS_NPC_WATERFALL_KNOCKBACK]))
+                waterSpout->CastSpell(waterSpout, BG_DS_SPELL_WATER_SPOUT, true);
+
+            setWaterFallKnockbackTimer(BG_DS_WATERFALL_KNOCKBACK_TIMER);
+        }
+        else
+            setWaterFallKnockbackTimer(getWaterFallKnockbackTimer() - diff);
+    }
+
+    if (getWaterFallTimer() < diff)
+    {
+        if (getWaterFallStatus() == BG_DS_WATERFALL_STATUS_OFF) // Add the water
+        {
+            DoorClose(BG_DS_OBJECT_WATER_2);
+            setWaterFallTimer(BG_DS_WATERFALL_WARNING_DURATION);
+            setWaterFallStatus(BG_DS_WATERFALL_STATUS_WARNING);
+        }
+        else if (getWaterFallStatus() == BG_DS_WATERFALL_STATUS_WARNING) // Active collision and perform knockback
+        {
+            if (GameObject* gob = GetBgMap()->GetGameObject(BgObjects[BG_DS_OBJECT_WATER_1]))
+                gob->SetGoState(GO_STATE_READY);
+
+            setWaterFallTimer(BG_DS_WATERFALL_DURATION);
+            setWaterFallStatus(BG_DS_WATERFALL_STATUS_ON);
+            setWaterFallKnockbackTimer(BG_DS_WATERFALL_KNOCKBACK_TIMER);
+        }
+        else //if (getWaterFallStatus() == BG_DS_WATERFALL_STATUS_ON) // Remove collision and water
+        {
+            // turn off collision
+            if (GameObject* gob = GetBgMap()->GetGameObject(BgObjects[BG_DS_OBJECT_WATER_1]))
+                gob->SetGoState(GO_STATE_ACTIVE);
+
+            DoorOpen(BG_DS_OBJECT_WATER_2);
+            setWaterFallTimer(urand(BG_DS_WATERFALL_TIMER_MIN, BG_DS_WATERFALL_TIMER_MAX));
+            setWaterFallStatus(BG_DS_WATERFALL_STATUS_OFF);
+        }
+    }
+    else
+        setWaterFallTimer(getWaterFallTimer() - diff);
+}
+
+void BattlegroundDS::StartingEventCloseDoors()
+{
+    for (uint32 i = BG_DS_OBJECT_DOOR_1; i <= BG_DS_OBJECT_DOOR_2; ++i)
+        SpawnBGObject(i, RESPAWN_IMMEDIATELY);
+}
+
+void BattlegroundDS::StartingEventOpenDoors()
+{
+    for (uint32 i = BG_DS_OBJECT_DOOR_1; i <= BG_DS_OBJECT_DOOR_2; ++i)
+        DoorOpen(i);
+
+    for (uint32 i = BG_DS_OBJECT_BUFF_1; i <= BG_DS_OBJECT_BUFF_2; ++i)
+        SpawnBGObject(i, 60);
+
+    setWaterFallTimer(urand(BG_DS_WATERFALL_TIMER_MIN, BG_DS_WATERFALL_TIMER_MAX));
+    setWaterFallStatus(BG_DS_WATERFALL_STATUS_OFF);
+
+    setPipeKnockBackTimer(BG_DS_PIPE_KNOCKBACK_FIRST_DELAY);
+    setPipeKnockBackCount(0);
+
+    SpawnBGObject(BG_DS_OBJECT_WATER_2, RESPAWN_IMMEDIATELY);
+    DoorOpen(BG_DS_OBJECT_WATER_2);
+
+    // Turn off collision
+    if (GameObject* gob = GetBgMap()->GetGameObject(BgObjects[BG_DS_OBJECT_WATER_1]))
+        gob->SetGoState(GO_STATE_ACTIVE);
+
+    // Remove effects of Demonic Circle Summon
+    for (BattlegroundPlayerMap::const_iterator itr = GetPlayers().begin(); itr != GetPlayers().end(); ++itr)
+        if (itr->second->HasAura(48018))
+            itr->second->RemoveAurasDueToSpell(48018);
+}
+
+void BattlegroundDS::AddPlayer(Player* player)
+{
+    Battleground::AddPlayer(player);
+    PlayerScores[player->GetGUID()] = new BattlegroundScore(player);
+    Battleground::UpdateArenaWorldState();
+}
+
+void BattlegroundDS::RemovePlayer(Player* /*player*/)
+{
+    if (GetStatus() == STATUS_WAIT_LEAVE)
+        return;
+
+    Battleground::UpdateArenaWorldState();
+    CheckArenaWinConditions();
+}
+
+void BattlegroundDS::HandleKillPlayer(Player* player, Player* killer)
+{
+    if (GetStatus() != STATUS_IN_PROGRESS)
+        return;
+
+    if (!killer)
+    {
+        sLog->outError("BattlegroundDS: Killer player not found");
+        return;
+    }
+
+    Battleground::HandleKillPlayer(player, killer);
+
+    Battleground::UpdateArenaWorldState();
+    CheckArenaWinConditions();
+}
+
+void BattlegroundDS::HandleAreaTrigger(Player* player, uint32 trigger)
+{
+    if (GetStatus() != STATUS_IN_PROGRESS)
+        return;
+
+    switch (trigger)
+    {
+        case 5347:
+        case 5348:
+            // Remove effects of Demonic Circle Summon
+            if (player->HasAura(48018))
+                player->RemoveAurasDueToSpell(48018);
+
+            // Someone has get back into the pipes and the knockback has already been performed,
+            // so we reset the knockback count for kicking the player again into the arena.
+            if (getPipeKnockBackCount() >= BG_DS_PIPE_KNOCKBACK_TOTAL_COUNT)
+                setPipeKnockBackCount(0);
+            break;
+		// OUTSIDE OF ARENA, TELEPORT!
+		case 5328:
+			player->NearTeleportTo(1290.44f, 744.96f, 3.16f, 1.6f);
+			break;
+		case 5329:
+			player->NearTeleportTo(1292.6f, 837.07f, 3.161f, 4.7f);
+			break;
+		case 5330:
+			player->NearTeleportTo(1250.68f, 790.86f, 3.16f, 0.0f);
+			break;
+		case 5331:
+			player->NearTeleportTo(1332.50f, 790.9f, 3.16f, 3.14f);
+			break;
+		case 5326: // -10
+		case 5343: // -40
+		case 5344: // -60
+			player->NearTeleportTo(1330.0f, 800.0f, 3.16f, player->GetOrientation());
+			break;
+    }
+}
+
+bool BattlegroundDS::HandlePlayerUnderMap(Player* player)
+{
+    player->NearTeleportTo(1299.046f, 784.825f, 9.338f, 2.422f);
+    return true;
+}
+
+void BattlegroundDS::FillInitialWorldStates(WorldPacket &data)
+{
+    data << uint32(3610) << uint32(1);                                              // 9 show
+    Battleground::UpdateArenaWorldState();
+}
+
+void BattlegroundDS::Init()
+{
+    //call parent's class reset
+    Battleground::Init();
+}
+
+bool BattlegroundDS::SetupBattleground()
+{
+    // gates
+    if (!AddObject(BG_DS_OBJECT_DOOR_1, BG_DS_OBJECT_TYPE_DOOR_1, 1350.95f, 817.2f, 20.8096f, 3.15f, 0, 0, 0.99627f, 0.0862864f, RESPAWN_IMMEDIATELY)
+        || !AddObject(BG_DS_OBJECT_DOOR_2, BG_DS_OBJECT_TYPE_DOOR_2, 1232.65f, 764.913f, 20.0729f, 6.3f, 0, 0, 0.0310211f, -0.999519f, RESPAWN_IMMEDIATELY)
+    // water
+        || !AddObject(BG_DS_OBJECT_WATER_1, BG_DS_OBJECT_TYPE_WATER_1, 1291.56f, 790.837f, 7.1f, 3.14238f, 0, 0, 0.694215f, -0.719768f, 120)
+        || !AddObject(BG_DS_OBJECT_WATER_2, BG_DS_OBJECT_TYPE_WATER_2, 1291.56f, 790.837f, 7.1f, 3.14238f, 0, 0, 0.694215f, -0.719768f, 120)
+    // buffs
+        || !AddObject(BG_DS_OBJECT_BUFF_1, BG_DS_OBJECT_TYPE_BUFF_1, 1291.7f, 813.424f, 7.11472f, 4.64562f, 0, 0, 0.730314f, -0.683111f, 120)
+        || !AddObject(BG_DS_OBJECT_BUFF_2, BG_DS_OBJECT_TYPE_BUFF_2, 1291.7f, 768.911f, 7.11472f, 1.55194f, 0, 0, 0.700409f, 0.713742f, 120)
+    // knockback creatures
+        || !AddCreature(BG_DS_NPC_TYPE_WATER_SPOUT, BG_DS_NPC_WATERFALL_KNOCKBACK, 1291.76f, 791.02f, 7.115f, 3.054326f, RESPAWN_IMMEDIATELY)
+        || !AddCreature(BG_DS_NPC_TYPE_WATER_SPOUT, BG_DS_NPC_PIPE_KNOCKBACK_1, 1369.977f, 817.2882f, 16.08718f, 3.106686f, RESPAWN_IMMEDIATELY)
+        || !AddCreature(BG_DS_NPC_TYPE_WATER_SPOUT, BG_DS_NPC_PIPE_KNOCKBACK_2, 1212.833f, 765.3871f, 16.09484f, 0.0f, RESPAWN_IMMEDIATELY)
+    // Arena Ready Marker
+        || !AddObject(BG_DS_OBJECT_READY_MARKER_1, ARENA_READY_MARKER_ENTRY, 1229.44f, 759.35f, 17.89f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 300)
+        || !AddObject(BG_DS_OBJECT_READY_MARKER_2, ARENA_READY_MARKER_ENTRY, 1352.90f, 822.77f, 17.96f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 300))
+    {
+        sLog->outErrorDb("BatteGroundDS: Failed to spawn some object!");
+        return false;
+    }
+
+    return true;
+}

src/server/game/Battlegrounds/Zones/BattlegroundDS.h

@@ -0,0 +1,122 @@
+/*
+ * Copyright (C) 
+ * Copyright (C) 
+ *
+ * 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef __BATTLEGROUNDDS_H
+#define __BATTLEGROUNDDS_H
+
+#include "Battleground.h"
+
+enum BattlegroundDSObjectTypes
+{
+    BG_DS_OBJECT_DOOR_1         = 0,
+    BG_DS_OBJECT_DOOR_2         = 1,
+    BG_DS_OBJECT_WATER_1        = 2, // Collision
+    BG_DS_OBJECT_WATER_2        = 3,
+    BG_DS_OBJECT_BUFF_1         = 4,
+    BG_DS_OBJECT_BUFF_2         = 5,
+	BG_DS_OBJECT_READY_MARKER_1 = 6,
+	BG_DS_OBJECT_READY_MARKER_2 = 7,
+    BG_DS_OBJECT_MAX            = 8
+};
+
+enum BattlegroundDSObjects
+{
+    BG_DS_OBJECT_TYPE_DOOR_1    = 192642,
+    BG_DS_OBJECT_TYPE_DOOR_2    = 192643,
+    BG_DS_OBJECT_TYPE_WATER_1   = 194395, // Collision
+    BG_DS_OBJECT_TYPE_WATER_2   = 191877,
+    BG_DS_OBJECT_TYPE_BUFF_1    = 184663,
+    BG_DS_OBJECT_TYPE_BUFF_2    = 184664
+};
+
+enum BattlegroundDSCreatureTypes
+{
+    BG_DS_NPC_WATERFALL_KNOCKBACK = 0,
+    BG_DS_NPC_PIPE_KNOCKBACK_1    = 1,
+    BG_DS_NPC_PIPE_KNOCKBACK_2    = 2,
+    BG_DS_NPC_MAX                 = 3
+};
+
+enum BattlegroundDSCreatures
+{
+    BG_DS_NPC_TYPE_WATER_SPOUT    = 28567,
+};
+
+enum BattlegroundDSSpells
+{
+    BG_DS_SPELL_FLUSH             = 57405, // Visual and target selector for the starting knockback from the pipe
+    BG_DS_SPELL_FLUSH_KNOCKBACK   = 61698, // Knockback effect for previous spell (triggered, not need to be casted)
+    BG_DS_SPELL_WATER_SPOUT       = 58873, // Knockback effect of the central waterfall
+};
+
+enum BattlegroundDSData
+{ // These values are NOT blizzlike... need the correct data!
+    BG_DS_WATERFALL_TIMER_MIN                    = 30000,
+    BG_DS_WATERFALL_TIMER_MAX                    = 60000,
+    BG_DS_WATERFALL_WARNING_DURATION             = 5000,
+    BG_DS_WATERFALL_DURATION                     = 30000,
+    BG_DS_WATERFALL_KNOCKBACK_TIMER              = 1500,
+
+    BG_DS_PIPE_KNOCKBACK_FIRST_DELAY             = 5000,
+    BG_DS_PIPE_KNOCKBACK_DELAY                   = 3000,
+    BG_DS_PIPE_KNOCKBACK_TOTAL_COUNT             = 2,
+
+    BG_DS_WATERFALL_STATUS_WARNING               = 1, // Water starting to fall, but no LoS Blocking nor movement blocking
+    BG_DS_WATERFALL_STATUS_ON                    = 2, // LoS and Movement blocking active
+    BG_DS_WATERFALL_STATUS_OFF                   = 3,
+};
+
+class BattlegroundDS : public Battleground
+{
+    public:
+        BattlegroundDS();
+        ~BattlegroundDS();
+
+        /* inherited from BattlegroundClass */
+        void AddPlayer(Player* player);
+        void StartingEventCloseDoors();
+        void StartingEventOpenDoors();
+
+        void RemovePlayer(Player* player);
+        void HandleAreaTrigger(Player* player, uint32 trigger);
+        bool SetupBattleground();
+        void Init();
+        void FillInitialWorldStates(WorldPacket &d);
+        void HandleKillPlayer(Player* player, Player* killer);
+        bool HandlePlayerUnderMap(Player* player);
+    private:
+        uint32 _waterfallTimer;
+        uint8 _waterfallStatus;
+        uint32 _waterfallKnockbackTimer;
+        uint32 _pipeKnockBackTimer;
+        uint8 _pipeKnockBackCount;
+
+        void PostUpdateImpl(uint32 diff);
+    protected:
+        uint32 getWaterFallStatus() { return _waterfallStatus; };
+        void setWaterFallStatus(uint8 status) { _waterfallStatus = status; };
+        uint32 getWaterFallTimer() { return _waterfallTimer; };
+        void setWaterFallTimer(uint32 timer) { _waterfallTimer = timer; };
+        uint32 getWaterFallKnockbackTimer() { return _waterfallKnockbackTimer; };
+        void setWaterFallKnockbackTimer(uint32 timer) { _waterfallKnockbackTimer = timer; };
+        uint8 getPipeKnockBackCount() { return _pipeKnockBackCount; };
+        void setPipeKnockBackCount(uint8 count) { _pipeKnockBackCount = count; };
+        uint32 getPipeKnockBackTimer() { return _pipeKnockBackTimer; };
+        void setPipeKnockBackTimer(uint32 timer) { _pipeKnockBackTimer = timer; };
+};
+#endif

src/server/game/Battlegrounds/Zones/BattlegroundEY.cpp

@@ -0,0 +1,610 @@
+/*
+REWRITTEN BY XINEF
+*/
+
+#include "BattlegroundEY.h"
+#include "ObjectMgr.h"
+#include "World.h"
+#include "WorldPacket.h"
+#include "BattlegroundMgr.h"
+#include "Creature.h"
+#include "Language.h"
+#include "Object.h"
+#include "Player.h"
+#include "Util.h"
+#include "WorldSession.h"
+
+BattlegroundEY::BattlegroundEY()
+{
+	m_BuffChange = true;
+    BgObjects.resize(BG_EY_OBJECT_MAX);
+    BgCreatures.resize(BG_EY_CREATURES_MAX);
+
+	_capturePointInfo[POINT_FEL_REAVER]._areaTrigger = AT_FEL_REAVER_BUFF;
+	_capturePointInfo[POINT_BLOOD_ELF]._areaTrigger = AT_BLOOD_ELF_BUFF;
+	_capturePointInfo[POINT_DRAENEI_RUINS]._areaTrigger = AT_DRAENEI_RUINS_BUFF;
+	_capturePointInfo[POINT_MAGE_TOWER]._areaTrigger = AT_MAGE_TOWER_BUFF;
+	_honorTics = 0;
+	_ownedPointsCount[TEAM_ALLIANCE] = 0;
+	_ownedPointsCount[TEAM_HORDE] = 0;
+    _flagKeeperGUID = 0;
+    _droppedFlagGUID = 0;
+    _flagState = BG_EY_FLAG_STATE_ON_BASE;
+    _flagCapturedObject = 0;
+
+    StartMessageIds[BG_STARTING_EVENT_FIRST]  = LANG_BG_EY_START_TWO_MINUTES;
+    StartMessageIds[BG_STARTING_EVENT_SECOND] = LANG_BG_EY_START_ONE_MINUTE;
+    StartMessageIds[BG_STARTING_EVENT_THIRD]  = LANG_BG_EY_START_HALF_MINUTE;
+    StartMessageIds[BG_STARTING_EVENT_FOURTH] = LANG_BG_EY_HAS_BEGUN;
+}
+
+BattlegroundEY::~BattlegroundEY()
+{
+}
+
+void BattlegroundEY::PostUpdateImpl(uint32 diff)
+{
+    if (GetStatus() == STATUS_IN_PROGRESS)
+    {
+		_bgEvents.Update(diff);
+		while (uint32 eventId = _bgEvents.ExecuteEvent())
+			switch (eventId)
+			{
+				case BG_EY_EVENT_ADD_POINTS:
+					if (_ownedPointsCount[TEAM_ALLIANCE] > 0)
+						AddPoints(TEAM_ALLIANCE, BG_EY_TickPoints[_ownedPointsCount[TEAM_ALLIANCE] - 1]);
+					if (_ownedPointsCount[TEAM_HORDE] > 0)
+						AddPoints(TEAM_HORDE, BG_EY_TickPoints[_ownedPointsCount[TEAM_HORDE] - 1]);
+					_bgEvents.ScheduleEvent(BG_EY_EVENT_ADD_POINTS, BG_EY_FPOINTS_TICK_TIME - (World::GetGameTimeMS() % BG_EY_FPOINTS_TICK_TIME));
+					break;
+				case BG_EY_EVENT_FLAG_ON_GROUND:
+					RespawnFlagAfterDrop();
+					break;
+				case BG_EY_EVENT_RESPAWN_FLAG:
+					RespawnFlag();
+					break;
+				case BG_EY_EVENT_CHECK_CPOINTS:
+					UpdatePointsState();
+					_bgEvents.ScheduleEvent(BG_EY_EVENT_CHECK_CPOINTS, BG_EY_FPOINTS_CHECK_TIME - (World::GetGameTimeMS() % BG_EY_FPOINTS_CHECK_TIME));
+					break;
+			}
+    }
+}
+
+void BattlegroundEY::StartingEventCloseDoors()
+{
+    SpawnBGObject(BG_EY_OBJECT_DOOR_A, RESPAWN_IMMEDIATELY);
+    SpawnBGObject(BG_EY_OBJECT_DOOR_H, RESPAWN_IMMEDIATELY);
+
+    for (uint32 i = BG_EY_OBJECT_A_BANNER_FEL_REAVER_CENTER; i < BG_EY_OBJECT_MAX; ++i)
+        SpawnBGObject(i, RESPAWN_ONE_DAY);
+}
+
+void BattlegroundEY::StartingEventOpenDoors()
+{
+    SpawnBGObject(BG_EY_OBJECT_DOOR_A, RESPAWN_ONE_DAY);
+    SpawnBGObject(BG_EY_OBJECT_DOOR_H, RESPAWN_ONE_DAY);
+
+    for (uint32 i = BG_EY_OBJECT_N_BANNER_FEL_REAVER_CENTER; i <= BG_EY_OBJECT_FLAG_NETHERSTORM; ++i)
+        SpawnBGObject(i, RESPAWN_IMMEDIATELY);
+
+    for (uint32 i = 0; i < EY_POINTS_MAX; ++i)
+        SpawnBGObject(BG_EY_OBJECT_SPEEDBUFF_FEL_REAVER + i*3 + urand(0, 2), RESPAWN_IMMEDIATELY);
+
+    // Achievement: Flurry
+    StartTimedAchievement(ACHIEVEMENT_TIMED_TYPE_EVENT, BG_EY_EVENT_START_BATTLE);
+	_bgEvents.ScheduleEvent(BG_EY_EVENT_ADD_POINTS, 0);
+	_bgEvents.ScheduleEvent(BG_EY_EVENT_CHECK_CPOINTS, 0);
+}
+
+void BattlegroundEY::AddPoints(TeamId teamId, uint32 points)
+{
+	uint8 honorRewards = uint8(m_TeamScores[teamId] / _honorTics);
+    m_TeamScores[teamId] += points;
+
+	for (; honorRewards < uint8(m_TeamScores[teamId] / _honorTics); ++honorRewards)
+        RewardHonorToTeam(GetBonusHonorFromKill(1), teamId);
+
+	UpdateWorldState(teamId == TEAM_ALLIANCE ? EY_ALLIANCE_RESOURCES : EY_HORDE_RESOURCES, std::min<uint32>(m_TeamScores[teamId], BG_EY_MAX_TEAM_SCORE));
+    if (m_TeamScores[teamId] >= BG_EY_MAX_TEAM_SCORE)
+		EndBattleground(teamId);
+}
+
+void BattlegroundEY::UpdatePointsState()
+{
+	std::vector<GameObject*> pointsVec;
+	for (uint8 point = 0; point < EY_POINTS_MAX; ++point)
+	{
+		pointsVec.push_back(GetBGObject(BG_EY_OBJECT_TOWER_CAP_FEL_REAVER + point));
+		_capturePointInfo[point]._playersCount[TEAM_ALLIANCE] = 0;
+		_capturePointInfo[point]._playersCount[TEAM_HORDE] = 0;
+	}
+
+	const BattlegroundPlayerMap& bgPlayerMap = GetPlayers();
+	for (BattlegroundPlayerMap::const_iterator itr = bgPlayerMap.begin(); itr != bgPlayerMap.end(); ++itr)
+	{
+		UpdateWorldStateForPlayer(PROGRESS_BAR_SHOW, BG_EY_PROGRESS_BAR_DONT_SHOW, itr->second);
+		for (uint8 point = 0; point < EY_POINTS_MAX; ++point)
+			if (GameObject* pointObject = pointsVec[point])
+				if (itr->second->CanCaptureTowerPoint() && itr->second->IsWithinDistInMap(pointObject, BG_EY_POINT_RADIUS))
+				{
+					UpdateWorldStateForPlayer(PROGRESS_BAR_SHOW, BG_EY_PROGRESS_BAR_SHOW, itr->second);
+					UpdateWorldStateForPlayer(PROGRESS_BAR_PERCENT_GREY, BG_EY_PROGRESS_BAR_PERCENT_GREY, itr->second);
+					UpdateWorldStateForPlayer(PROGRESS_BAR_STATUS, _capturePointInfo[point]._barStatus, itr->second);
+					++_capturePointInfo[point]._playersCount[itr->second->GetTeamId()];
+
+					// Xinef: ugly hax... area trigger is no longer called by client...
+					if (pointObject->GetEntry() == BG_OBJECT_FR_TOWER_CAP_EY_ENTRY && itr->second->GetDistance2d(2043.96f, 1729.68f) < 3.0f)
+						HandleAreaTrigger(itr->second, AT_FEL_REAVER_POINT);
+				}
+    }
+
+    for (uint8 point = 0; point < EY_POINTS_MAX; ++point)
+    {
+		_capturePointInfo[point]._barStatus += std::max<int8>(std::min<int8>(_capturePointInfo[point]._playersCount[TEAM_ALLIANCE] - _capturePointInfo[point]._playersCount[TEAM_HORDE], BG_EY_POINT_MAX_CAPTURERS_COUNT), -BG_EY_POINT_MAX_CAPTURERS_COUNT);
+		_capturePointInfo[point]._barStatus = std::max<int8>(std::min<int8>(_capturePointInfo[point]._barStatus, BG_EY_PROGRESS_BAR_ALI_CONTROLLED), BG_EY_PROGRESS_BAR_HORDE_CONTROLLED);
+
+        TeamId pointOwnerTeamId = TEAM_NEUTRAL;
+		if (_capturePointInfo[point]._barStatus <= BG_EY_PROGRESS_BAR_NEUTRAL_LOW)
+            pointOwnerTeamId = TEAM_HORDE;
+		else if (_capturePointInfo[point]._barStatus >= BG_EY_PROGRESS_BAR_NEUTRAL_HIGH)
+            pointOwnerTeamId = TEAM_ALLIANCE;
+		
+        if (pointOwnerTeamId != _capturePointInfo[point]._ownerTeamId)
+        {
+            if (_capturePointInfo[point].IsUncontrolled())
+                EventTeamCapturedPoint(pointOwnerTeamId, point);
+
+			if (pointOwnerTeamId == TEAM_NEUTRAL && _capturePointInfo[point].IsUnderControl())
+                EventTeamLostPoint(pointOwnerTeamId, point);
+        }
+    }
+}
+
+void BattlegroundEY::EndBattleground(TeamId winnerTeamId)
+{
+    RewardHonorToTeam(GetBonusHonorFromKill(1), winnerTeamId);
+    RewardHonorToTeam(GetBonusHonorFromKill(1), TEAM_ALLIANCE);
+    RewardHonorToTeam(GetBonusHonorFromKill(1), TEAM_HORDE);
+    Battleground::EndBattleground(winnerTeamId);
+}
+
+void BattlegroundEY::UpdatePointsCount()
+{
+    UpdateWorldState(EY_ALLIANCE_BASE, _ownedPointsCount[TEAM_ALLIANCE]);
+    UpdateWorldState(EY_HORDE_BASE, _ownedPointsCount[TEAM_HORDE]);
+}
+
+void BattlegroundEY::UpdatePointsIcons(uint32 point)
+{
+	if (_capturePointInfo[point].IsUnderControl())
+    {
+        UpdateWorldState(m_PointsIconStruct[point].WorldStateControlIndex, 0);
+		UpdateWorldState(m_PointsIconStruct[point].WorldStateAllianceControlledIndex, _capturePointInfo[point].IsUnderControl(TEAM_ALLIANCE));
+		UpdateWorldState(m_PointsIconStruct[point].WorldStateHordeControlledIndex, _capturePointInfo[point].IsUnderControl(TEAM_HORDE));
+    }
+    else
+    {
+        UpdateWorldState(m_PointsIconStruct[point].WorldStateAllianceControlledIndex, 0);
+        UpdateWorldState(m_PointsIconStruct[point].WorldStateHordeControlledIndex, 0);
+        UpdateWorldState(m_PointsIconStruct[point].WorldStateControlIndex, 1);
+    }
+}
+
+void BattlegroundEY::AddPlayer(Player* player)
+{
+    Battleground::AddPlayer(player);
+    PlayerScores[player->GetGUID()] = new BattlegroundEYScore(player);
+}
+
+void BattlegroundEY::RemovePlayer(Player* player)
+{
+	if (GetFlagPickerGUID() == player->GetGUID())
+        EventPlayerDroppedFlag(player);
+}
+
+void BattlegroundEY::HandleAreaTrigger(Player* player, uint32 trigger)
+{
+    if (GetStatus() != STATUS_IN_PROGRESS || !player->IsAlive())
+        return;
+
+    switch (trigger)
+    {
+        case AT_BLOOD_ELF_POINT:
+			if (_capturePointInfo[POINT_BLOOD_ELF].IsUnderControl(player->GetTeamId()))
+                if (_flagState == BG_EY_FLAG_STATE_ON_PLAYER && GetFlagPickerGUID() == player->GetGUID())
+                    EventPlayerCapturedFlag(player, BG_EY_OBJECT_FLAG_BLOOD_ELF);
+            break;
+        case AT_FEL_REAVER_POINT:
+			if (_capturePointInfo[POINT_FEL_REAVER].IsUnderControl(player->GetTeamId()))
+                if (_flagState == BG_EY_FLAG_STATE_ON_PLAYER && GetFlagPickerGUID() == player->GetGUID())
+                    EventPlayerCapturedFlag(player, BG_EY_OBJECT_FLAG_FEL_REAVER);
+            break;
+        case AT_MAGE_TOWER_POINT:
+			if (_capturePointInfo[POINT_MAGE_TOWER].IsUnderControl(player->GetTeamId()))
+                if (_flagState == BG_EY_FLAG_STATE_ON_PLAYER && GetFlagPickerGUID() == player->GetGUID())
+                    EventPlayerCapturedFlag(player, BG_EY_OBJECT_FLAG_MAGE_TOWER);
+            break;
+        case AT_DRAENEI_RUINS_POINT:
+			if (_capturePointInfo[POINT_DRAENEI_RUINS].IsUnderControl(player->GetTeamId()))
+                if (_flagState == BG_EY_FLAG_STATE_ON_PLAYER && GetFlagPickerGUID() == player->GetGUID())
+                    EventPlayerCapturedFlag(player, BG_EY_OBJECT_FLAG_DRAENEI_RUINS);
+            break;
+        case 4512:
+        case 4515:
+        case 4517:
+        case 4519:
+        case 4530:
+        case 4531:
+        case 5866:
+		case AT_BLOOD_ELF_BUFF:
+		case AT_FEL_REAVER_BUFF:
+		case AT_MAGE_TOWER_BUFF:
+		case AT_DRAENEI_RUINS_BUFF:
+            break;
+    }
+}
+
+bool BattlegroundEY::SetupBattleground()
+{
+        // doors
+    AddObject(BG_EY_OBJECT_DOOR_A, BG_OBJECT_A_DOOR_EY_ENTRY, 2527.6f, 1596.91f, 1262.13f, -3.12414f, -0.173642f, -0.001515f, 0.98477f, -0.008594f, RESPAWN_IMMEDIATELY);
+    AddObject(BG_EY_OBJECT_DOOR_H, BG_OBJECT_H_DOOR_EY_ENTRY, 1803.21f, 1539.49f, 1261.09f, 3.14159f, 0.173648f, 0, 0.984808f, 0, RESPAWN_IMMEDIATELY);
+        // banners (alliance)
+    AddObject(BG_EY_OBJECT_A_BANNER_FEL_REAVER_CENTER, BG_OBJECT_A_BANNER_EY_ENTRY, 2057.46f, 1735.07f, 1187.91f, -0.925024f, 0, 0, 0.446198f, -0.894934f, RESPAWN_ONE_DAY);
+    AddObject(BG_EY_OBJECT_A_BANNER_FEL_REAVER_LEFT, BG_OBJECT_A_BANNER_EY_ENTRY, 2032.25f, 1729.53f, 1190.33f, 1.8675f, 0, 0, 0.803857f, 0.594823f, RESPAWN_ONE_DAY);
+    AddObject(BG_EY_OBJECT_A_BANNER_FEL_REAVER_RIGHT, BG_OBJECT_A_BANNER_EY_ENTRY, 2092.35f, 1775.46f, 1187.08f, -0.401426f, 0, 0, 0.199368f, -0.979925f, RESPAWN_ONE_DAY);
+    AddObject(BG_EY_OBJECT_A_BANNER_BLOOD_ELF_CENTER, BG_OBJECT_A_BANNER_EY_ENTRY, 2047.19f, 1349.19f, 1189.0f, -1.62316f, 0, 0, 0.725374f, -0.688354f, RESPAWN_ONE_DAY);
+    AddObject(BG_EY_OBJECT_A_BANNER_BLOOD_ELF_LEFT, BG_OBJECT_A_BANNER_EY_ENTRY, 2074.32f, 1385.78f, 1194.72f, 0.488692f, 0, 0, 0.241922f, 0.970296f, RESPAWN_ONE_DAY);
+    AddObject(BG_EY_OBJECT_A_BANNER_BLOOD_ELF_RIGHT, BG_OBJECT_A_BANNER_EY_ENTRY, 2025.13f, 1386.12f, 1192.74f, 2.3911f, 0, 0, 0.930418f, 0.366501f, RESPAWN_ONE_DAY);
+    AddObject(BG_EY_OBJECT_A_BANNER_DRAENEI_RUINS_CENTER, BG_OBJECT_A_BANNER_EY_ENTRY, 2276.8f, 1400.41f, 1196.33f, 2.44346f, 0, 0, 0.939693f, 0.34202f, RESPAWN_ONE_DAY);
+    AddObject(BG_EY_OBJECT_A_BANNER_DRAENEI_RUINS_LEFT, BG_OBJECT_A_BANNER_EY_ENTRY, 2305.78f, 1404.56f, 1199.38f, 1.74533f, 0, 0, 0.766044f, 0.642788f, RESPAWN_ONE_DAY);
+    AddObject(BG_EY_OBJECT_A_BANNER_DRAENEI_RUINS_RIGHT, BG_OBJECT_A_BANNER_EY_ENTRY, 2245.4f, 1366.41f, 1195.28f, 2.21657f, 0, 0, 0.894934f, 0.446198f, RESPAWN_ONE_DAY);
+    AddObject(BG_EY_OBJECT_A_BANNER_MAGE_TOWER_CENTER, BG_OBJECT_A_BANNER_EY_ENTRY, 2270.84f, 1784.08f, 1186.76f, 2.42601f, 0, 0, 0.936672f, 0.350207f, RESPAWN_ONE_DAY);
+    AddObject(BG_EY_OBJECT_A_BANNER_MAGE_TOWER_LEFT, BG_OBJECT_A_BANNER_EY_ENTRY, 2269.13f, 1737.7f, 1186.66f, 0.994838f, 0, 0, 0.477159f, 0.878817f, RESPAWN_ONE_DAY);
+    AddObject(BG_EY_OBJECT_A_BANNER_MAGE_TOWER_RIGHT, BG_OBJECT_A_BANNER_EY_ENTRY, 2300.86f, 1741.25f, 1187.7f, -0.785398f, 0, 0, 0.382683f, -0.92388f, RESPAWN_ONE_DAY);
+        // banners (horde)
+    AddObject(BG_EY_OBJECT_H_BANNER_FEL_REAVER_CENTER, BG_OBJECT_H_BANNER_EY_ENTRY, 2057.46f, 1735.07f, 1187.91f, -0.925024f, 0, 0, 0.446198f, -0.894934f, RESPAWN_ONE_DAY);
+    AddObject(BG_EY_OBJECT_H_BANNER_FEL_REAVER_LEFT, BG_OBJECT_H_BANNER_EY_ENTRY, 2032.25f, 1729.53f, 1190.33f, 1.8675f, 0, 0, 0.803857f, 0.594823f, RESPAWN_ONE_DAY);
+    AddObject(BG_EY_OBJECT_H_BANNER_FEL_REAVER_RIGHT, BG_OBJECT_H_BANNER_EY_ENTRY, 2092.35f, 1775.46f, 1187.08f, -0.401426f, 0, 0, 0.199368f, -0.979925f, RESPAWN_ONE_DAY);
+    AddObject(BG_EY_OBJECT_H_BANNER_BLOOD_ELF_CENTER, BG_OBJECT_H_BANNER_EY_ENTRY, 2047.19f, 1349.19f, 1189.0f, -1.62316f, 0, 0, 0.725374f, -0.688354f, RESPAWN_ONE_DAY);
+    AddObject(BG_EY_OBJECT_H_BANNER_BLOOD_ELF_LEFT, BG_OBJECT_H_BANNER_EY_ENTRY, 2074.32f, 1385.78f, 1194.72f, 0.488692f, 0, 0, 0.241922f, 0.970296f, RESPAWN_ONE_DAY);
+    AddObject(BG_EY_OBJECT_H_BANNER_BLOOD_ELF_RIGHT, BG_OBJECT_H_BANNER_EY_ENTRY, 2025.13f, 1386.12f, 1192.74f, 2.3911f, 0, 0, 0.930418f, 0.366501f, RESPAWN_ONE_DAY);
+    AddObject(BG_EY_OBJECT_H_BANNER_DRAENEI_RUINS_CENTER, BG_OBJECT_H_BANNER_EY_ENTRY, 2276.8f, 1400.41f, 1196.33f, 2.44346f, 0, 0, 0.939693f, 0.34202f, RESPAWN_ONE_DAY);
+    AddObject(BG_EY_OBJECT_H_BANNER_DRAENEI_RUINS_LEFT, BG_OBJECT_H_BANNER_EY_ENTRY, 2305.78f, 1404.56f, 1199.38f, 1.74533f, 0, 0, 0.766044f, 0.642788f, RESPAWN_ONE_DAY);
+    AddObject(BG_EY_OBJECT_H_BANNER_DRAENEI_RUINS_RIGHT, BG_OBJECT_H_BANNER_EY_ENTRY, 2245.4f, 1366.41f, 1195.28f, 2.21657f, 0, 0, 0.894934f, 0.446198f, RESPAWN_ONE_DAY);
+    AddObject(BG_EY_OBJECT_H_BANNER_MAGE_TOWER_CENTER, BG_OBJECT_H_BANNER_EY_ENTRY, 2270.84f, 1784.08f, 1186.76f, 2.42601f, 0, 0, 0.936672f, 0.350207f, RESPAWN_ONE_DAY);
+    AddObject(BG_EY_OBJECT_H_BANNER_MAGE_TOWER_LEFT, BG_OBJECT_H_BANNER_EY_ENTRY, 2269.13f, 1737.7f, 1186.66f, 0.994838f, 0, 0, 0.477159f, 0.878817f, RESPAWN_ONE_DAY);
+    AddObject(BG_EY_OBJECT_H_BANNER_MAGE_TOWER_RIGHT, BG_OBJECT_H_BANNER_EY_ENTRY, 2300.86f, 1741.25f, 1187.7f, -0.785398f, 0, 0, 0.382683f, -0.92388f, RESPAWN_ONE_DAY);
+        // banners (natural)
+    AddObject(BG_EY_OBJECT_N_BANNER_FEL_REAVER_CENTER, BG_OBJECT_N_BANNER_EY_ENTRY, 2057.46f, 1735.07f, 1187.91f, -0.925024f, 0, 0, 0.446198f, -0.894934f, RESPAWN_ONE_DAY);
+    AddObject(BG_EY_OBJECT_N_BANNER_FEL_REAVER_LEFT, BG_OBJECT_N_BANNER_EY_ENTRY, 2032.25f, 1729.53f, 1190.33f, 1.8675f, 0, 0, 0.803857f, 0.594823f, RESPAWN_ONE_DAY);
+    AddObject(BG_EY_OBJECT_N_BANNER_FEL_REAVER_RIGHT, BG_OBJECT_N_BANNER_EY_ENTRY, 2092.35f, 1775.46f, 1187.08f, -0.401426f, 0, 0, 0.199368f, -0.979925f, RESPAWN_ONE_DAY);
+    AddObject(BG_EY_OBJECT_N_BANNER_BLOOD_ELF_CENTER, BG_OBJECT_N_BANNER_EY_ENTRY, 2047.19f, 1349.19f, 1189.0f, -1.62316f, 0, 0, 0.725374f, -0.688354f, RESPAWN_ONE_DAY);
+    AddObject(BG_EY_OBJECT_N_BANNER_BLOOD_ELF_LEFT, BG_OBJECT_N_BANNER_EY_ENTRY, 2074.32f, 1385.78f, 1194.72f, 0.488692f, 0, 0, 0.241922f, 0.970296f, RESPAWN_ONE_DAY);
+    AddObject(BG_EY_OBJECT_N_BANNER_BLOOD_ELF_RIGHT, BG_OBJECT_N_BANNER_EY_ENTRY, 2025.13f, 1386.12f, 1192.74f, 2.3911f, 0, 0, 0.930418f, 0.366501f, RESPAWN_ONE_DAY);
+    AddObject(BG_EY_OBJECT_N_BANNER_DRAENEI_RUINS_CENTER, BG_OBJECT_N_BANNER_EY_ENTRY, 2276.8f, 1400.41f, 1196.33f, 2.44346f, 0, 0, 0.939693f, 0.34202f, RESPAWN_ONE_DAY);
+    AddObject(BG_EY_OBJECT_N_BANNER_DRAENEI_RUINS_LEFT, BG_OBJECT_N_BANNER_EY_ENTRY, 2305.78f, 1404.56f, 1199.38f, 1.74533f, 0, 0, 0.766044f, 0.642788f, RESPAWN_ONE_DAY);
+    AddObject(BG_EY_OBJECT_N_BANNER_DRAENEI_RUINS_RIGHT, BG_OBJECT_N_BANNER_EY_ENTRY, 2245.4f, 1366.41f, 1195.28f, 2.21657f, 0, 0, 0.894934f, 0.446198f, RESPAWN_ONE_DAY);
+    AddObject(BG_EY_OBJECT_N_BANNER_MAGE_TOWER_CENTER, BG_OBJECT_N_BANNER_EY_ENTRY, 2270.84f, 1784.08f, 1186.76f, 2.42601f, 0, 0, 0.936672f, 0.350207f, RESPAWN_ONE_DAY);
+    AddObject(BG_EY_OBJECT_N_BANNER_MAGE_TOWER_LEFT, BG_OBJECT_N_BANNER_EY_ENTRY, 2269.13f, 1737.7f, 1186.66f, 0.994838f, 0, 0, 0.477159f, 0.878817f, RESPAWN_ONE_DAY);
+    AddObject(BG_EY_OBJECT_N_BANNER_MAGE_TOWER_RIGHT, BG_OBJECT_N_BANNER_EY_ENTRY, 2300.86f, 1741.25f, 1187.7f, -0.785398f, 0, 0, 0.382683f, -0.92388f, RESPAWN_ONE_DAY);
+        // flags
+    AddObject(BG_EY_OBJECT_FLAG_NETHERSTORM, BG_OBJECT_FLAG2_EY_ENTRY, 2174.782227f, 1569.054688f, 1160.361938f, -1.448624f, 0, 0, 0.662620f, -0.748956f, RESPAWN_ONE_DAY);
+    AddObject(BG_EY_OBJECT_FLAG_FEL_REAVER, BG_OBJECT_FLAG1_EY_ENTRY, 2044.28f, 1729.68f, 1189.96f, -0.017453f, 0, 0, 0.008727f, -0.999962f, RESPAWN_ONE_DAY);
+    AddObject(BG_EY_OBJECT_FLAG_BLOOD_ELF, BG_OBJECT_FLAG1_EY_ENTRY, 2048.83f, 1393.65f, 1194.49f, 0.20944f, 0, 0, 0.104528f, 0.994522f, RESPAWN_ONE_DAY);
+    AddObject(BG_EY_OBJECT_FLAG_DRAENEI_RUINS, BG_OBJECT_FLAG1_EY_ENTRY, 2286.56f, 1402.36f, 1197.11f, 3.72381f, 0, 0, 0.957926f, -0.287016f, RESPAWN_ONE_DAY);
+    AddObject(BG_EY_OBJECT_FLAG_MAGE_TOWER, BG_OBJECT_FLAG1_EY_ENTRY, 2284.48f, 1731.23f, 1189.99f, 2.89725f, 0, 0, 0.992546f, 0.121869f, RESPAWN_ONE_DAY);
+        // tower cap
+    AddObject(BG_EY_OBJECT_TOWER_CAP_FEL_REAVER, BG_OBJECT_FR_TOWER_CAP_EY_ENTRY, 2024.600708f, 1742.819580f, 1195.157715f, 2.443461f, 0, 0, 0.939693f, 0.342020f, RESPAWN_ONE_DAY);
+    AddObject(BG_EY_OBJECT_TOWER_CAP_BLOOD_ELF, BG_OBJECT_BE_TOWER_CAP_EY_ENTRY, 2050.493164f, 1372.235962f, 1194.563477f, 1.710423f, 0, 0, 0.754710f, 0.656059f, RESPAWN_ONE_DAY);
+    AddObject(BG_EY_OBJECT_TOWER_CAP_DRAENEI_RUINS, BG_OBJECT_DR_TOWER_CAP_EY_ENTRY, 2301.010498f, 1386.931641f, 1197.183472f, 1.570796f, 0, 0, 0.707107f, 0.707107f, RESPAWN_ONE_DAY);
+    AddObject(BG_EY_OBJECT_TOWER_CAP_MAGE_TOWER, BG_OBJECT_HU_TOWER_CAP_EY_ENTRY, 2282.121582f, 1760.006958f, 1189.707153f, 1.919862f, 0, 0, 0.819152f, 0.573576f, RESPAWN_ONE_DAY);
+
+    for (uint8 i = 0; i < EY_POINTS_MAX; ++i)
+    {
+		AreaTriggerEntry const* at = sAreaTriggerStore.LookupEntry(_capturePointInfo[i]._areaTrigger);
+        AddObject(BG_EY_OBJECT_SPEEDBUFF_FEL_REAVER + i * 3 + 0, Buff_Entries[0], at->x, at->y, at->z, 0.907571f, 0, 0, 0.438371f, 0.898794f, RESPAWN_ONE_DAY);
+        AddObject(BG_EY_OBJECT_SPEEDBUFF_FEL_REAVER + i * 3 + 1, Buff_Entries[1], at->x, at->y, at->z, 0.907571f, 0, 0, 0.438371f, 0.898794f, RESPAWN_ONE_DAY);
+        AddObject(BG_EY_OBJECT_SPEEDBUFF_FEL_REAVER + i * 3 + 2, Buff_Entries[2], at->x, at->y, at->z, 0.907571f, 0, 0, 0.438371f, 0.898794f, RESPAWN_ONE_DAY);
+    }
+
+    WorldSafeLocsEntry const* sg = NULL;
+    sg = sWorldSafeLocsStore.LookupEntry(BG_EY_GRAVEYARD_MAIN_ALLIANCE);
+    AddSpiritGuide(BG_EY_SPIRIT_MAIN_ALLIANCE, sg->x, sg->y, sg->z, 3.124139f, TEAM_ALLIANCE);
+
+    sg = sWorldSafeLocsStore.LookupEntry(BG_EY_GRAVEYARD_MAIN_HORDE);
+    AddSpiritGuide(BG_EY_SPIRIT_MAIN_HORDE, sg->x, sg->y, sg->z, 3.193953f, TEAM_HORDE);
+
+	for (uint32 i = BG_EY_OBJECT_DOOR_A; i < BG_EY_OBJECT_MAX; ++i)
+		if (BgObjects[i] == 0)
+		{
+			sLog->outErrorDb("BatteGroundEY: Failed to spawn some object Battleground not created!");
+			return false;
+		}
+
+	for (uint32 i = BG_EY_SPIRIT_MAIN_ALLIANCE; i <= BG_EY_SPIRIT_MAIN_HORDE; ++i)
+		if (BgCreatures[i] == 0)
+		{
+			sLog->outErrorDb("BatteGroundEY: Failed to spawn spirit guides Battleground not created!");
+			return false;
+		}
+
+    return true;
+}
+
+void BattlegroundEY::Init()
+{
+    //call parent's class reset
+    Battleground::Init();
+
+	_bgEvents.Reset();
+	_honorTics = BattlegroundMgr::IsBGWeekend(GetBgTypeID()) ? BG_EY_HONOR_TICK_WEEKEND : BG_EY_HONOR_TICK_NORMAL;
+	_ownedPointsCount[TEAM_ALLIANCE] = 0;
+	_ownedPointsCount[TEAM_HORDE] = 0;
+    _flagKeeperGUID = 0;
+    _droppedFlagGUID = 0;
+    _flagState = BG_EY_FLAG_STATE_ON_BASE;
+    _flagCapturedObject = 0;
+}
+
+void BattlegroundEY::RespawnFlag()
+{
+	if (_flagState != BG_EY_FLAG_STATE_ON_BASE)
+		return;
+
+    if (_flagCapturedObject > 0)
+        SpawnBGObject(_flagCapturedObject, RESPAWN_ONE_DAY);
+
+    _flagCapturedObject = 0;
+    SpawnBGObject(BG_EY_OBJECT_FLAG_NETHERSTORM, RESPAWN_IMMEDIATELY);
+
+    SendMessageToAll(LANG_BG_EY_RESETED_FLAG, CHAT_MSG_BG_SYSTEM_NEUTRAL);
+    PlaySoundToAll(BG_EY_SOUND_FLAG_RESET);
+    UpdateWorldState(NETHERSTORM_FLAG, 1);
+}
+
+void BattlegroundEY::RespawnFlagAfterDrop()
+{
+	if (_flagState != BG_EY_FLAG_STATE_ON_GROUND)
+		return;
+
+    _flagState = BG_EY_FLAG_STATE_ON_BASE;
+    RespawnFlag();
+	if (GameObject* flag = ObjectAccessor::GetObjectInMap(GetDroppedFlagGUID(), FindBgMap(), (GameObject*)NULL))
+        flag->Delete();
+    SetDroppedFlagGUID(0);
+}
+
+void BattlegroundEY::HandleKillPlayer(Player* player, Player* killer)
+{
+    if (GetStatus() != STATUS_IN_PROGRESS)
+        return;
+
+    Battleground::HandleKillPlayer(player, killer);
+    EventPlayerDroppedFlag(player);
+}
+
+void BattlegroundEY::EventPlayerDroppedFlag(Player* player)
+{
+	if (GetFlagPickerGUID() != player->GetGUID())
+		return;
+
+    SetFlagPicker(0);
+    player->RemoveAurasDueToSpell(BG_EY_NETHERSTORM_FLAG_SPELL);
+    if (GetStatus() != STATUS_IN_PROGRESS)
+        return;
+
+    _flagState = BG_EY_FLAG_STATE_ON_GROUND;
+	_bgEvents.RescheduleEvent(BG_EY_EVENT_FLAG_ON_GROUND, BG_EY_FLAG_ON_GROUND_TIME);
+
+    player->CastSpell(player, SPELL_RECENTLY_DROPPED_FLAG, true);
+    player->CastSpell(player, BG_EY_PLAYER_DROPPED_FLAG_SPELL, true);
+
+	SendMessageToAll(LANG_BG_EY_DROPPED_FLAG, player->GetTeamId() == TEAM_ALLIANCE ? CHAT_MSG_BG_SYSTEM_ALLIANCE : CHAT_MSG_BG_SYSTEM_HORDE);
+}
+
+void BattlegroundEY::EventPlayerClickedOnFlag(Player* player, GameObject* gameObject)
+{
+    if (GetStatus() != STATUS_IN_PROGRESS || GetFlagPickerGUID() || !player->IsWithinDistInMap(gameObject, 10.0f))
+        return;
+
+    _flagState = BG_EY_FLAG_STATE_ON_PLAYER;
+    SpawnBGObject(BG_EY_OBJECT_FLAG_NETHERSTORM, RESPAWN_ONE_DAY);
+    SetFlagPicker(player->GetGUID());
+	SetDroppedFlagGUID(0);
+
+    player->CastSpell(player, BG_EY_NETHERSTORM_FLAG_SPELL, true);
+    player->RemoveAurasWithInterruptFlags(AURA_INTERRUPT_FLAG_ENTER_PVP_COMBAT);
+
+	PSendMessageToAll(LANG_BG_EY_HAS_TAKEN_FLAG, player->GetTeamId() == TEAM_ALLIANCE ? CHAT_MSG_BG_SYSTEM_ALLIANCE : CHAT_MSG_BG_SYSTEM_HORDE, NULL, player->GetName().c_str());
+	PlaySoundToAll(player->GetTeamId() == TEAM_ALLIANCE ? BG_EY_SOUND_FLAG_PICKED_UP_ALLIANCE : BG_EY_SOUND_FLAG_PICKED_UP_HORDE);
+    UpdateWorldState(NETHERSTORM_FLAG, 0);
+}
+
+void BattlegroundEY::EventTeamLostPoint(TeamId teamId, uint32 point)
+{
+	TeamId oldTeamId = _capturePointInfo[point]._ownerTeamId;
+    if (oldTeamId == TEAM_ALLIANCE)
+    {
+        _ownedPointsCount[TEAM_ALLIANCE]--;
+        SpawnBGObject(m_LosingPointTypes[point].DespawnObjectTypeAlliance, RESPAWN_ONE_DAY);
+        SpawnBGObject(m_LosingPointTypes[point].DespawnObjectTypeAlliance + 1, RESPAWN_ONE_DAY);
+        SpawnBGObject(m_LosingPointTypes[point].DespawnObjectTypeAlliance + 2, RESPAWN_ONE_DAY);
+        SendMessageToAll(m_LosingPointTypes[point].MessageIdAlliance, CHAT_MSG_BG_SYSTEM_ALLIANCE);
+    }
+    else
+    {
+        _ownedPointsCount[TEAM_HORDE]--;
+        SpawnBGObject(m_LosingPointTypes[point].DespawnObjectTypeHorde, RESPAWN_ONE_DAY);
+        SpawnBGObject(m_LosingPointTypes[point].DespawnObjectTypeHorde + 1, RESPAWN_ONE_DAY);
+        SpawnBGObject(m_LosingPointTypes[point].DespawnObjectTypeHorde + 2, RESPAWN_ONE_DAY);
+        SendMessageToAll(m_LosingPointTypes[point].MessageIdHorde, CHAT_MSG_BG_SYSTEM_HORDE);
+    }
+
+    SpawnBGObject(m_LosingPointTypes[point].SpawnNeutralObjectType, RESPAWN_IMMEDIATELY);
+    SpawnBGObject(m_LosingPointTypes[point].SpawnNeutralObjectType + 1, RESPAWN_IMMEDIATELY);
+    SpawnBGObject(m_LosingPointTypes[point].SpawnNeutralObjectType + 2, RESPAWN_IMMEDIATELY);
+
+	_capturePointInfo[point]._ownerTeamId = TEAM_NEUTRAL;
+
+    UpdatePointsIcons(point);
+    UpdatePointsCount();
+    DelCreature(BG_EY_TRIGGER_FEL_REAVER + point);
+}
+
+void BattlegroundEY::EventTeamCapturedPoint(TeamId teamId, uint32 point)
+{
+    SpawnBGObject(m_CapturingPointTypes[point].DespawnNeutralObjectType, RESPAWN_ONE_DAY);
+    SpawnBGObject(m_CapturingPointTypes[point].DespawnNeutralObjectType + 1, RESPAWN_ONE_DAY);
+    SpawnBGObject(m_CapturingPointTypes[point].DespawnNeutralObjectType + 2, RESPAWN_ONE_DAY);
+
+    if (teamId == TEAM_ALLIANCE)
+    {
+        _ownedPointsCount[TEAM_ALLIANCE]++;
+        SpawnBGObject(m_CapturingPointTypes[point].SpawnObjectTypeAlliance, RESPAWN_IMMEDIATELY);
+        SpawnBGObject(m_CapturingPointTypes[point].SpawnObjectTypeAlliance + 1, RESPAWN_IMMEDIATELY);
+        SpawnBGObject(m_CapturingPointTypes[point].SpawnObjectTypeAlliance + 2, RESPAWN_IMMEDIATELY);
+        SendMessageToAll(m_CapturingPointTypes[point].MessageIdAlliance, CHAT_MSG_BG_SYSTEM_ALLIANCE);
+    }
+    else
+    {
+        _ownedPointsCount[TEAM_HORDE]++;
+        SpawnBGObject(m_CapturingPointTypes[point].SpawnObjectTypeHorde, RESPAWN_IMMEDIATELY);
+        SpawnBGObject(m_CapturingPointTypes[point].SpawnObjectTypeHorde + 1, RESPAWN_IMMEDIATELY);
+        SpawnBGObject(m_CapturingPointTypes[point].SpawnObjectTypeHorde + 2, RESPAWN_IMMEDIATELY);
+        SendMessageToAll(m_CapturingPointTypes[point].MessageIdHorde, CHAT_MSG_BG_SYSTEM_HORDE);
+    }
+
+	_capturePointInfo[point]._ownerTeamId = teamId;
+    if (BgCreatures[point])
+        DelCreature(point);
+
+    WorldSafeLocsEntry const* sg = sWorldSafeLocsStore.LookupEntry(m_CapturingPointTypes[point].GraveYardId);
+    AddSpiritGuide(point, sg->x, sg->y, sg->z, 3.124139f, teamId);
+
+    UpdatePointsIcons(point);
+    UpdatePointsCount();
+
+	// Xinef: done this way to avoid errors in console
+	Creature* trigger = GetBgMap()->GetCreature(BgCreatures[BG_EY_TRIGGER_FEL_REAVER + point]);
+    if (!trigger)
+       trigger = AddCreature(WORLD_TRIGGER, BG_EY_TRIGGER_FEL_REAVER + point, BG_EY_TriggerPositions[point][0], BG_EY_TriggerPositions[point][1], BG_EY_TriggerPositions[point][2], BG_EY_TriggerPositions[point][3]);
+
+    if (trigger)
+    {
+        trigger->setFaction(teamId == TEAM_ALLIANCE ? 84 : 83);
+        trigger->CastSpell(trigger, SPELL_HONORABLE_DEFENDER_25Y, true);
+    }
+}
+
+void BattlegroundEY::EventPlayerCapturedFlag(Player* player, uint32 BgObjectType)
+{
+    SetFlagPicker(0);
+    _flagState = BG_EY_FLAG_STATE_ON_BASE;
+    player->RemoveAurasDueToSpell(BG_EY_NETHERSTORM_FLAG_SPELL);
+    player->RemoveAurasWithInterruptFlags(AURA_INTERRUPT_FLAG_ENTER_PVP_COMBAT);
+
+    SpawnBGObject(BgObjectType, RESPAWN_IMMEDIATELY);
+	_bgEvents.RescheduleEvent(BG_EY_EVENT_RESPAWN_FLAG, BG_EY_FLAG_RESPAWN_TIME);
+    _flagCapturedObject = BgObjectType;
+
+    if (player->GetTeamId() == TEAM_ALLIANCE)
+	{
+		PlaySoundToAll(BG_EY_SOUND_FLAG_CAPTURED_ALLIANCE);
+        SendMessageToAll(LANG_BG_EY_CAPTURED_FLAG_A, CHAT_MSG_BG_SYSTEM_ALLIANCE, player);
+	}
+    else
+	{
+		PlaySoundToAll(BG_EY_SOUND_FLAG_CAPTURED_HORDE);
+        SendMessageToAll(LANG_BG_EY_CAPTURED_FLAG_H, CHAT_MSG_BG_SYSTEM_HORDE, player);
+	}
+
+    UpdatePlayerScore(player, SCORE_FLAG_CAPTURES, 1);
+    if (_ownedPointsCount[player->GetTeamId()] > 0)
+        AddPoints(player->GetTeamId(), BG_EY_FlagPoints[_ownedPointsCount[player->GetTeamId()] - 1]);
+}
+
+void BattlegroundEY::UpdatePlayerScore(Player* player, uint32 type, uint32 value, bool doAddHonor)
+{
+    if (type == SCORE_FLAG_CAPTURES)
+	{
+		BattlegroundScoreMap::iterator itr = PlayerScores.find(player->GetGUID());
+		if (itr != PlayerScores.end())
+			((BattlegroundEYScore*)itr->second)->FlagCaptures += value;
+        player->UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_BG_OBJECTIVE_CAPTURE, BG_EY_OBJECTIVE_CAPTURE_FLAG);
+		return;
+	}
+
+    Battleground::UpdatePlayerScore(player, type, value, doAddHonor);
+}
+
+void BattlegroundEY::FillInitialWorldStates(WorldPacket& data)
+{
+    data << uint32(EY_HORDE_BASE)					<< uint32(_ownedPointsCount[TEAM_HORDE]);
+    data << uint32(EY_ALLIANCE_BASE)				<< uint32(_ownedPointsCount[TEAM_ALLIANCE]);
+	data << uint32(DRAENEI_RUINS_HORDE_CONTROL)     << uint32(_capturePointInfo[POINT_DRAENEI_RUINS].IsUnderControl(TEAM_HORDE));
+	data << uint32(DRAENEI_RUINS_ALLIANCE_CONTROL)  << uint32(_capturePointInfo[POINT_DRAENEI_RUINS].IsUnderControl(TEAM_ALLIANCE));
+	data << uint32(DRAENEI_RUINS_UNCONTROL)         << uint32(_capturePointInfo[POINT_DRAENEI_RUINS].IsUncontrolled());
+	data << uint32(MAGE_TOWER_ALLIANCE_CONTROL)     << uint32(_capturePointInfo[POINT_MAGE_TOWER].IsUnderControl(TEAM_HORDE));
+	data << uint32(MAGE_TOWER_HORDE_CONTROL)        << uint32(_capturePointInfo[POINT_MAGE_TOWER].IsUnderControl(TEAM_ALLIANCE));
+	data << uint32(MAGE_TOWER_UNCONTROL)            << uint32(_capturePointInfo[POINT_MAGE_TOWER].IsUncontrolled());
+	data << uint32(FEL_REAVER_HORDE_CONTROL)        << uint32(_capturePointInfo[POINT_FEL_REAVER].IsUnderControl(TEAM_HORDE));
+	data << uint32(FEL_REAVER_ALLIANCE_CONTROL)     << uint32(_capturePointInfo[POINT_FEL_REAVER].IsUnderControl(TEAM_ALLIANCE));
+	data << uint32(FEL_REAVER_UNCONTROL)            << uint32(_capturePointInfo[POINT_FEL_REAVER].IsUncontrolled());
+	data << uint32(BLOOD_ELF_HORDE_CONTROL)         << uint32(_capturePointInfo[POINT_BLOOD_ELF].IsUnderControl(TEAM_HORDE));
+	data << uint32(BLOOD_ELF_ALLIANCE_CONTROL)      << uint32(_capturePointInfo[POINT_BLOOD_ELF].IsUnderControl(TEAM_ALLIANCE));
+	data << uint32(BLOOD_ELF_UNCONTROL)             << uint32(_capturePointInfo[POINT_BLOOD_ELF].IsUncontrolled());
+    data << uint32(NETHERSTORM_FLAG)                << uint32(_flagState == BG_EY_FLAG_STATE_ON_BASE);
+    data << uint32(NETHERSTORM_FLAG_STATE_HORDE)	<< uint32(1);
+    data << uint32(NETHERSTORM_FLAG_STATE_ALLIANCE) << uint32(1);
+    data << uint32(EY_HORDE_RESOURCES)				<< uint32(GetTeamScore(TEAM_HORDE));
+    data << uint32(EY_ALLIANCE_RESOURCES)			<< uint32(GetTeamScore(TEAM_ALLIANCE));
+	data << uint32(PROGRESS_BAR_SHOW)				<< uint32(0);
+	data << uint32(PROGRESS_BAR_PERCENT_GREY)		<< uint32(0);
+	data << uint32(PROGRESS_BAR_STATUS)				<< uint32(0);
+}
+
+WorldSafeLocsEntry const* BattlegroundEY::GetClosestGraveyard(Player* player)
+{
+    WorldSafeLocsEntry const* entry = sWorldSafeLocsStore.LookupEntry(BG_EY_GRAVEYARD_MAIN_ALLIANCE + player->GetTeamId());
+    WorldSafeLocsEntry const* nearestEntry = entry;
+
+    float pX = player->GetPositionX();
+    float pY = player->GetPositionY();
+    float pZ = player->GetPositionZ();
+    float dist = (entry->x - pX)*(entry->x - pX) + (entry->y - pY)*(entry->y - pY) + (entry->z - pZ)*(entry->z - pZ);
+	float minDist = dist;
+
+    for (uint8 i = 0; i < EY_POINTS_MAX; ++i)
+		if (_capturePointInfo[i].IsUnderControl(player->GetTeamId()))
+        {
+            entry = sWorldSafeLocsStore.LookupEntry(m_CapturingPointTypes[i].GraveYardId);
+            dist = (entry->x - pX)*(entry->x - pX) + (entry->y - pY)*(entry->y - pY) + (entry->z - pZ)*(entry->z - pZ);
+            if (dist < minDist)
+            {
+                minDist = dist;
+                nearestEntry = entry;
+            }
+        }
+
+    return nearestEntry;
+}
+
+bool BattlegroundEY::AllNodesConrolledByTeam(TeamId teamId) const
+{
+    uint32 count = 0;
+    for (uint8 i = 0; i < EY_POINTS_MAX; ++i)
+		if (_capturePointInfo[i].IsUnderControl(teamId))
+            ++count;
+
+    return count == EY_POINTS_MAX;
+}
+
+TeamId BattlegroundEY::GetPrematureWinner()
+{
+	if (GetTeamScore(TEAM_ALLIANCE) > GetTeamScore(TEAM_HORDE))
+		return TEAM_ALLIANCE;
+
+	return GetTeamScore(TEAM_HORDE) > GetTeamScore(TEAM_ALLIANCE) ? TEAM_HORDE : Battleground::GetPrematureWinner();
+}

src/server/game/Battlegrounds/Zones/BattlegroundEY.h

@@ -0,0 +1,397 @@
+/*
+REWRITTEN BY XINEF
+*/
+
+#ifndef __BATTLEGROUNDEY_H
+#define __BATTLEGROUNDEY_H
+
+#include "Language.h"
+#include "Battleground.h"
+
+enum BG_EY_Events
+{
+	BG_EY_EVENT_ADD_POINTS			= 1,
+	BG_EY_EVENT_FLAG_ON_GROUND		= 2,
+	BG_EY_EVENT_RESPAWN_FLAG		= 3,
+	BG_EY_EVENT_CHECK_CPOINTS		= 4
+};
+
+enum BG_EY_Timers
+{
+    BG_EY_FLAG_RESPAWN_TIME         = 20*IN_MILLISECONDS,
+	BG_EY_FLAG_ON_GROUND_TIME		= 10*IN_MILLISECONDS,
+    BG_EY_FPOINTS_CHECK_TIME        = 2*IN_MILLISECONDS,
+    BG_EY_FPOINTS_TICK_TIME         = 1*IN_MILLISECONDS
+};
+
+enum BG_EY_WorldStates
+{
+    EY_ALLIANCE_RESOURCES           = 2749,
+    EY_HORDE_RESOURCES              = 2750,
+    EY_ALLIANCE_BASE                = 2752,
+    EY_HORDE_BASE                   = 2753,
+    DRAENEI_RUINS_HORDE_CONTROL     = 2733,
+    DRAENEI_RUINS_ALLIANCE_CONTROL  = 2732,
+    DRAENEI_RUINS_UNCONTROL         = 2731,
+    MAGE_TOWER_ALLIANCE_CONTROL     = 2730,
+    MAGE_TOWER_HORDE_CONTROL        = 2729,
+    MAGE_TOWER_UNCONTROL            = 2728,
+    FEL_REAVER_HORDE_CONTROL        = 2727,
+    FEL_REAVER_ALLIANCE_CONTROL     = 2726,
+    FEL_REAVER_UNCONTROL            = 2725,
+    BLOOD_ELF_HORDE_CONTROL         = 2724,
+    BLOOD_ELF_ALLIANCE_CONTROL      = 2723,
+    BLOOD_ELF_UNCONTROL             = 2722,
+    PROGRESS_BAR_PERCENT_GREY       = 2720,                 //100 = empty (only grey), 0 = blue|red (no grey)
+    PROGRESS_BAR_STATUS             = 2719,                 //50 init!, 48 ... hordak bere .. 33 .. 0 = full 100% hordacky, 100 = full alliance
+    PROGRESS_BAR_SHOW               = 2718,                 //1 init, 0 druhy send - bez messagu, 1 = controlled aliance
+    NETHERSTORM_FLAG                = 2757,
+    //set to 2 when flag is picked up, and to 1 if it is dropped
+    NETHERSTORM_FLAG_STATE_ALLIANCE = 2769,
+    NETHERSTORM_FLAG_STATE_HORDE    = 2770
+};
+
+enum BG_EY_ProgressBarConsts
+{
+    BG_EY_POINT_MAX_CAPTURERS_COUNT     = 5,
+    BG_EY_POINT_RADIUS                  = 50,
+    BG_EY_PROGRESS_BAR_DONT_SHOW        = 0,
+    BG_EY_PROGRESS_BAR_SHOW             = 1,
+    BG_EY_PROGRESS_BAR_PERCENT_GREY     = 40,
+    BG_EY_PROGRESS_BAR_STATE_MIDDLE     = 50,
+    BG_EY_PROGRESS_BAR_HORDE_CONTROLLED = 0,
+    BG_EY_PROGRESS_BAR_NEUTRAL_LOW      = 30,
+    BG_EY_PROGRESS_BAR_NEUTRAL_HIGH     = 70,
+    BG_EY_PROGRESS_BAR_ALI_CONTROLLED   = 100
+};
+
+enum BG_EY_Sounds
+{
+    BG_EY_SOUND_FLAG_PICKED_UP_ALLIANCE = 8212,
+    BG_EY_SOUND_FLAG_CAPTURED_HORDE     = 8213,
+    BG_EY_SOUND_FLAG_PICKED_UP_HORDE    = 8174,
+    BG_EY_SOUND_FLAG_CAPTURED_ALLIANCE  = 8173,
+    BG_EY_SOUND_FLAG_RESET              = 8192
+};
+
+enum BG_EY_Spells
+{
+    BG_EY_NETHERSTORM_FLAG_SPELL        = 34976,
+    BG_EY_PLAYER_DROPPED_FLAG_SPELL     = 34991
+};
+
+enum BG_EY_ObjectEntry
+{
+    BG_OBJECT_A_DOOR_EY_ENTRY           = 184719,           //Alliance door
+    BG_OBJECT_H_DOOR_EY_ENTRY           = 184720,           //Horde door
+    BG_OBJECT_FLAG1_EY_ENTRY            = 184493,           //Netherstorm flag (generic)
+    BG_OBJECT_FLAG2_EY_ENTRY            = 184141,           //Netherstorm flag (flagstand)
+    BG_OBJECT_FLAG3_EY_ENTRY            = 184142,           //Netherstorm flag (flagdrop)
+    BG_OBJECT_A_BANNER_EY_ENTRY         = 184381,           //Visual Banner (Alliance)
+    BG_OBJECT_H_BANNER_EY_ENTRY         = 184380,           //Visual Banner (Horde)
+    BG_OBJECT_N_BANNER_EY_ENTRY         = 184382,           //Visual Banner (Neutral)
+    BG_OBJECT_BE_TOWER_CAP_EY_ENTRY     = 184080,           //BE Tower Cap Pt
+    BG_OBJECT_FR_TOWER_CAP_EY_ENTRY     = 184081,           //Fel Reaver Cap Pt
+    BG_OBJECT_HU_TOWER_CAP_EY_ENTRY     = 184082,           //Human Tower Cap Pt
+    BG_OBJECT_DR_TOWER_CAP_EY_ENTRY     = 184083            //Draenei Tower Cap Pt
+};
+
+enum BG_EY_AreaTriggers
+{
+	AT_BLOOD_ELF_POINT					= 4476,
+	AT_FEL_REAVER_POINT					= 4514,
+	AT_MAGE_TOWER_POINT					= 4516,
+	AT_DRAENEI_RUINS_POINT				= 4518,
+	AT_BLOOD_ELF_BUFF					= 4568,
+	AT_FEL_REAVER_BUFF					= 4569,
+	AT_MAGE_TOWER_BUFF					= 4570,
+	AT_DRAENEI_RUINS_BUFF				= 4571
+};
+
+enum BG_EY_Graveyards
+{
+    BG_EY_GRAVEYARD_MAIN_ALLIANCE     = 1103,
+    BG_EY_GRAVEYARD_MAIN_HORDE        = 1104,
+    BG_EY_GRAVEYARD_FEL_REAVER        = 1105,
+    BG_EY_GRAVEYARD_BLOOD_ELF         = 1106,
+    BG_EY_GRAVEYARD_DRAENEI_RUINS     = 1107,
+    BG_EY_GRAVEYARD_MAGE_TOWER        = 1108
+};
+
+enum BG_EY_Points
+{
+    POINT_FEL_REAVER		= 0,
+    POINT_BLOOD_ELF			= 1,
+    POINT_DRAENEI_RUINS		= 2,
+    POINT_MAGE_TOWER		= 3,
+    EY_POINTS_MAX			= 4
+};
+
+enum BG_EY_CreatureTypes
+{
+    BG_EY_SPIRIT_FEL_REAVER       = 0,
+    BG_EY_SPIRIT_BLOOD_ELF        = 1,
+    BG_EY_SPIRIT_DRAENEI_RUINS    = 2,
+    BG_EY_SPIRIT_MAGE_TOWER       = 3,
+    BG_EY_SPIRIT_MAIN_ALLIANCE    = 4,
+    BG_EY_SPIRIT_MAIN_HORDE       = 5,
+
+    BG_EY_TRIGGER_FEL_REAVER      = 6,
+    BG_EY_TRIGGER_BLOOD_ELF       = 7,
+    BG_EY_TRIGGER_DRAENEI_RUINS   = 8,
+    BG_EY_TRIGGER_MAGE_TOWER      = 9,
+
+    BG_EY_CREATURES_MAX           = 10
+};
+
+enum BG_EY_ObjectTypes
+{
+    BG_EY_OBJECT_DOOR_A                         = 0,
+    BG_EY_OBJECT_DOOR_H                         = 1,
+    BG_EY_OBJECT_A_BANNER_FEL_REAVER_CENTER     = 2,
+    BG_EY_OBJECT_A_BANNER_FEL_REAVER_LEFT       = 3,
+    BG_EY_OBJECT_A_BANNER_FEL_REAVER_RIGHT      = 4,
+    BG_EY_OBJECT_A_BANNER_BLOOD_ELF_CENTER      = 5,
+    BG_EY_OBJECT_A_BANNER_BLOOD_ELF_LEFT        = 6,
+    BG_EY_OBJECT_A_BANNER_BLOOD_ELF_RIGHT       = 7,
+    BG_EY_OBJECT_A_BANNER_DRAENEI_RUINS_CENTER  = 8,
+    BG_EY_OBJECT_A_BANNER_DRAENEI_RUINS_LEFT    = 9,
+    BG_EY_OBJECT_A_BANNER_DRAENEI_RUINS_RIGHT   = 10,
+    BG_EY_OBJECT_A_BANNER_MAGE_TOWER_CENTER     = 11,
+    BG_EY_OBJECT_A_BANNER_MAGE_TOWER_LEFT       = 12,
+    BG_EY_OBJECT_A_BANNER_MAGE_TOWER_RIGHT      = 13,
+    BG_EY_OBJECT_H_BANNER_FEL_REAVER_CENTER     = 14,
+    BG_EY_OBJECT_H_BANNER_FEL_REAVER_LEFT       = 15,
+    BG_EY_OBJECT_H_BANNER_FEL_REAVER_RIGHT      = 16,
+    BG_EY_OBJECT_H_BANNER_BLOOD_ELF_CENTER      = 17,
+    BG_EY_OBJECT_H_BANNER_BLOOD_ELF_LEFT        = 18,
+    BG_EY_OBJECT_H_BANNER_BLOOD_ELF_RIGHT       = 19,
+    BG_EY_OBJECT_H_BANNER_DRAENEI_RUINS_CENTER  = 20,
+    BG_EY_OBJECT_H_BANNER_DRAENEI_RUINS_LEFT    = 21,
+    BG_EY_OBJECT_H_BANNER_DRAENEI_RUINS_RIGHT   = 22,
+    BG_EY_OBJECT_H_BANNER_MAGE_TOWER_CENTER     = 23,
+    BG_EY_OBJECT_H_BANNER_MAGE_TOWER_LEFT       = 24,
+    BG_EY_OBJECT_H_BANNER_MAGE_TOWER_RIGHT      = 25,
+    BG_EY_OBJECT_N_BANNER_FEL_REAVER_CENTER     = 26,
+    BG_EY_OBJECT_N_BANNER_FEL_REAVER_LEFT       = 27,
+    BG_EY_OBJECT_N_BANNER_FEL_REAVER_RIGHT      = 28,
+    BG_EY_OBJECT_N_BANNER_BLOOD_ELF_CENTER      = 29,
+    BG_EY_OBJECT_N_BANNER_BLOOD_ELF_LEFT        = 30,
+    BG_EY_OBJECT_N_BANNER_BLOOD_ELF_RIGHT       = 31,
+    BG_EY_OBJECT_N_BANNER_DRAENEI_RUINS_CENTER  = 32,
+    BG_EY_OBJECT_N_BANNER_DRAENEI_RUINS_LEFT    = 33,
+    BG_EY_OBJECT_N_BANNER_DRAENEI_RUINS_RIGHT   = 34,
+    BG_EY_OBJECT_N_BANNER_MAGE_TOWER_CENTER     = 35,
+    BG_EY_OBJECT_N_BANNER_MAGE_TOWER_LEFT       = 36,
+    BG_EY_OBJECT_N_BANNER_MAGE_TOWER_RIGHT      = 37,
+    BG_EY_OBJECT_TOWER_CAP_FEL_REAVER           = 38,
+    BG_EY_OBJECT_TOWER_CAP_BLOOD_ELF            = 39,
+    BG_EY_OBJECT_TOWER_CAP_DRAENEI_RUINS        = 40,
+    BG_EY_OBJECT_TOWER_CAP_MAGE_TOWER           = 41,
+    BG_EY_OBJECT_FLAG_NETHERSTORM               = 42,
+    BG_EY_OBJECT_FLAG_FEL_REAVER                = 43,
+    BG_EY_OBJECT_FLAG_BLOOD_ELF                 = 44,
+    BG_EY_OBJECT_FLAG_DRAENEI_RUINS             = 45,
+    BG_EY_OBJECT_FLAG_MAGE_TOWER                = 46,
+    //buffs
+    BG_EY_OBJECT_SPEEDBUFF_FEL_REAVER           = 47,
+    BG_EY_OBJECT_REGENBUFF_FEL_REAVER           = 48,
+    BG_EY_OBJECT_BERSERKBUFF_FEL_REAVER         = 49,
+    BG_EY_OBJECT_SPEEDBUFF_BLOOD_ELF            = 50,
+    BG_EY_OBJECT_REGENBUFF_BLOOD_ELF            = 51,
+    BG_EY_OBJECT_BERSERKBUFF_BLOOD_ELF          = 52,
+    BG_EY_OBJECT_SPEEDBUFF_DRAENEI_RUINS        = 53,
+    BG_EY_OBJECT_REGENBUFF_DRAENEI_RUINS        = 54,
+    BG_EY_OBJECT_BERSERKBUFF_DRAENEI_RUINS      = 55,
+    BG_EY_OBJECT_SPEEDBUFF_MAGE_TOWER           = 56,
+    BG_EY_OBJECT_REGENBUFF_MAGE_TOWER           = 57,
+    BG_EY_OBJECT_BERSERKBUFF_MAGE_TOWER         = 58,
+    BG_EY_OBJECT_MAX                            = 59
+};
+
+enum BG_EY_Score
+{
+    BG_EY_WARNING_NEAR_VICTORY_SCORE    = 1400,
+    BG_EY_MAX_TEAM_SCORE                = 1600,
+
+	BG_EY_HONOR_TICK_WEEKEND			= 160,
+	BG_EY_HONOR_TICK_NORMAL				= 260,
+
+	BG_EY_EVENT_START_BATTLE			= 13180, // Achievement: Flurry
+	BG_EY_OBJECTIVE_CAPTURE_FLAG		= 183
+};
+
+enum BG_EY_FlagState
+{
+    BG_EY_FLAG_STATE_ON_BASE      = 1,
+    BG_EY_FLAG_STATE_ON_PLAYER    = 2,
+    BG_EY_FLAG_STATE_ON_GROUND    = 3
+};
+
+struct BattlegroundEYPointIconsStruct
+{
+    BattlegroundEYPointIconsStruct(uint32 _WorldStateControlIndex, uint32 _WorldStateAllianceControlledIndex, uint32 _WorldStateHordeControlledIndex)
+        : WorldStateControlIndex(_WorldStateControlIndex), WorldStateAllianceControlledIndex(_WorldStateAllianceControlledIndex), WorldStateHordeControlledIndex(_WorldStateHordeControlledIndex) {}
+    uint32 WorldStateControlIndex;
+    uint32 WorldStateAllianceControlledIndex;
+    uint32 WorldStateHordeControlledIndex;
+};
+
+const float BG_EY_TriggerPositions[EY_POINTS_MAX][4] =
+{
+    {2044.28f, 1729.68f, 1189.96f, 0.017453f},  // FEL_REAVER center
+    {2048.83f, 1393.65f, 1194.49f, 0.20944f},   // BLOOD_ELF center
+    {2286.56f, 1402.36f, 1197.11f, 3.72381f},   // DRAENEI_RUINS center
+    {2284.48f, 1731.23f, 1189.99f, 2.89725f}    // MAGE_TOWER center
+};
+
+struct BattlegroundEYLosingPointStruct
+{
+    BattlegroundEYLosingPointStruct(uint32 _SpawnNeutralObjectType, uint32 _DespawnObjectTypeAlliance, uint32 _MessageIdAlliance, uint32 _DespawnObjectTypeHorde, uint32 _MessageIdHorde)
+        : SpawnNeutralObjectType(_SpawnNeutralObjectType),
+        DespawnObjectTypeAlliance(_DespawnObjectTypeAlliance), MessageIdAlliance(_MessageIdAlliance),
+        DespawnObjectTypeHorde(_DespawnObjectTypeHorde), MessageIdHorde(_MessageIdHorde)
+    {}
+
+    uint32 SpawnNeutralObjectType;
+    uint32 DespawnObjectTypeAlliance;
+    uint32 MessageIdAlliance;
+    uint32 DespawnObjectTypeHorde;
+    uint32 MessageIdHorde;
+};
+
+struct BattlegroundEYCapturingPointStruct
+{
+    BattlegroundEYCapturingPointStruct(uint32 _DespawnNeutralObjectType, uint32 _SpawnObjectTypeAlliance, uint32 _MessageIdAlliance, uint32 _SpawnObjectTypeHorde, uint32 _MessageIdHorde, uint32 _GraveYardId)
+        : DespawnNeutralObjectType(_DespawnNeutralObjectType),
+        SpawnObjectTypeAlliance(_SpawnObjectTypeAlliance), MessageIdAlliance(_MessageIdAlliance),
+        SpawnObjectTypeHorde(_SpawnObjectTypeHorde), MessageIdHorde(_MessageIdHorde),
+        GraveYardId(_GraveYardId)
+    {}
+
+    uint32 DespawnNeutralObjectType;
+    uint32 SpawnObjectTypeAlliance;
+    uint32 MessageIdAlliance;
+    uint32 SpawnObjectTypeHorde;
+    uint32 MessageIdHorde;
+    uint32 GraveYardId;
+};
+
+const uint32 BG_EY_TickPoints[EY_POINTS_MAX] = {1, 2, 5, 10};
+const uint32 BG_EY_FlagPoints[EY_POINTS_MAX] = {75, 85, 100, 500};
+
+//constant arrays:
+const BattlegroundEYPointIconsStruct m_PointsIconStruct[EY_POINTS_MAX] =
+{
+    BattlegroundEYPointIconsStruct(FEL_REAVER_UNCONTROL, FEL_REAVER_ALLIANCE_CONTROL, FEL_REAVER_HORDE_CONTROL),
+    BattlegroundEYPointIconsStruct(BLOOD_ELF_UNCONTROL, BLOOD_ELF_ALLIANCE_CONTROL, BLOOD_ELF_HORDE_CONTROL),
+    BattlegroundEYPointIconsStruct(DRAENEI_RUINS_UNCONTROL, DRAENEI_RUINS_ALLIANCE_CONTROL, DRAENEI_RUINS_HORDE_CONTROL),
+    BattlegroundEYPointIconsStruct(MAGE_TOWER_UNCONTROL, MAGE_TOWER_ALLIANCE_CONTROL, MAGE_TOWER_HORDE_CONTROL)
+};
+
+const BattlegroundEYLosingPointStruct m_LosingPointTypes[EY_POINTS_MAX] =
+{
+    BattlegroundEYLosingPointStruct(BG_EY_OBJECT_N_BANNER_FEL_REAVER_CENTER, BG_EY_OBJECT_A_BANNER_FEL_REAVER_CENTER, LANG_BG_EY_HAS_LOST_A_F_RUINS, BG_EY_OBJECT_H_BANNER_FEL_REAVER_CENTER, LANG_BG_EY_HAS_LOST_H_F_RUINS),
+    BattlegroundEYLosingPointStruct(BG_EY_OBJECT_N_BANNER_BLOOD_ELF_CENTER, BG_EY_OBJECT_A_BANNER_BLOOD_ELF_CENTER, LANG_BG_EY_HAS_LOST_A_B_TOWER, BG_EY_OBJECT_H_BANNER_BLOOD_ELF_CENTER, LANG_BG_EY_HAS_LOST_H_B_TOWER),
+    BattlegroundEYLosingPointStruct(BG_EY_OBJECT_N_BANNER_DRAENEI_RUINS_CENTER, BG_EY_OBJECT_A_BANNER_DRAENEI_RUINS_CENTER, LANG_BG_EY_HAS_LOST_A_D_RUINS, BG_EY_OBJECT_H_BANNER_DRAENEI_RUINS_CENTER, LANG_BG_EY_HAS_LOST_H_D_RUINS),
+    BattlegroundEYLosingPointStruct(BG_EY_OBJECT_N_BANNER_MAGE_TOWER_CENTER, BG_EY_OBJECT_A_BANNER_MAGE_TOWER_CENTER, LANG_BG_EY_HAS_LOST_A_M_TOWER, BG_EY_OBJECT_H_BANNER_MAGE_TOWER_CENTER, LANG_BG_EY_HAS_LOST_H_M_TOWER)
+};
+
+const BattlegroundEYCapturingPointStruct m_CapturingPointTypes[EY_POINTS_MAX] =
+{
+    BattlegroundEYCapturingPointStruct(BG_EY_OBJECT_N_BANNER_FEL_REAVER_CENTER, BG_EY_OBJECT_A_BANNER_FEL_REAVER_CENTER, LANG_BG_EY_HAS_TAKEN_A_F_RUINS, BG_EY_OBJECT_H_BANNER_FEL_REAVER_CENTER, LANG_BG_EY_HAS_TAKEN_H_F_RUINS, BG_EY_GRAVEYARD_FEL_REAVER),
+    BattlegroundEYCapturingPointStruct(BG_EY_OBJECT_N_BANNER_BLOOD_ELF_CENTER, BG_EY_OBJECT_A_BANNER_BLOOD_ELF_CENTER, LANG_BG_EY_HAS_TAKEN_A_B_TOWER, BG_EY_OBJECT_H_BANNER_BLOOD_ELF_CENTER, LANG_BG_EY_HAS_TAKEN_H_B_TOWER, BG_EY_GRAVEYARD_BLOOD_ELF),
+    BattlegroundEYCapturingPointStruct(BG_EY_OBJECT_N_BANNER_DRAENEI_RUINS_CENTER, BG_EY_OBJECT_A_BANNER_DRAENEI_RUINS_CENTER, LANG_BG_EY_HAS_TAKEN_A_D_RUINS, BG_EY_OBJECT_H_BANNER_DRAENEI_RUINS_CENTER, LANG_BG_EY_HAS_TAKEN_H_D_RUINS, BG_EY_GRAVEYARD_DRAENEI_RUINS),
+    BattlegroundEYCapturingPointStruct(BG_EY_OBJECT_N_BANNER_MAGE_TOWER_CENTER, BG_EY_OBJECT_A_BANNER_MAGE_TOWER_CENTER, LANG_BG_EY_HAS_TAKEN_A_M_TOWER, BG_EY_OBJECT_H_BANNER_MAGE_TOWER_CENTER, LANG_BG_EY_HAS_TAKEN_H_M_TOWER, BG_EY_GRAVEYARD_MAGE_TOWER)
+};
+
+struct BattlegroundEYScore : public BattlegroundScore
+{
+    BattlegroundEYScore(Player* player) : BattlegroundScore(player), FlagCaptures(0) { }
+    ~BattlegroundEYScore() { }
+    uint32 FlagCaptures;
+};
+
+class BattlegroundEY : public Battleground
+{
+    public:
+        BattlegroundEY();
+        ~BattlegroundEY();
+
+        /* inherited from BattlegroundClass */
+        void AddPlayer(Player* player);
+        void StartingEventCloseDoors();
+        void StartingEventOpenDoors();
+
+        /* BG Flags */
+        uint64 GetFlagPickerGUID(TeamId /*teamId*/ = TEAM_NEUTRAL) const    { return _flagKeeperGUID; }
+        void SetFlagPicker(uint64 guid)     { _flagKeeperGUID = guid; }
+        uint8 GetFlagState() const          { return _flagState; }
+        void RespawnFlag();
+        void RespawnFlagAfterDrop();
+
+        void RemovePlayer(Player* player);
+        void HandleBuffUse(uint64 buff_guid);
+        void HandleAreaTrigger(Player* player, uint32 trigger);
+        void HandleKillPlayer(Player* player, Player* killer);
+        WorldSafeLocsEntry const* GetClosestGraveyard(Player* player);
+        bool SetupBattleground();
+        void Init();
+        void EndBattleground(TeamId winnerTeamId);
+        void UpdatePlayerScore(Player* player, uint32 type, uint32 value, bool doAddHonor = true);
+        void FillInitialWorldStates(WorldPacket& data);
+        void SetDroppedFlagGUID(uint64 guid, TeamId /*teamId*/ = TEAM_NEUTRAL)  { _droppedFlagGUID = guid; }
+        uint64 GetDroppedFlagGUID() const { return _droppedFlagGUID; }
+
+        /* Battleground Events */
+        void EventPlayerClickedOnFlag(Player* player, GameObject* gameObject);
+        void EventPlayerDroppedFlag(Player* player);
+
+        /* achievement req. */
+        bool AllNodesConrolledByTeam(TeamId teamId) const;
+        TeamId GetPrematureWinner();
+
+    private:
+        void PostUpdateImpl(uint32 diff);
+
+        void EventPlayerCapturedFlag(Player* Source, uint32 BgObjectType);
+        void EventTeamLostPoint(TeamId teamId, uint32 point);
+        void EventTeamCapturedPoint(TeamId teamId, uint32 point);
+        void UpdatePointsCount();
+        void UpdatePointsIcons(uint32 point);
+
+        /* Point status updating procedures */
+        void UpdatePointsState();
+
+        /* Scorekeeping */
+        void AddPoints(TeamId teamId, uint32 points);
+
+		struct CapturePointInfo
+		{
+			CapturePointInfo() : _ownerTeamId(TEAM_NEUTRAL), _barStatus(BG_EY_PROGRESS_BAR_STATE_MIDDLE), _areaTrigger(0)
+			{
+				_playersCount[TEAM_ALLIANCE] = 0;
+				_playersCount[TEAM_HORDE] = 0;
+			}
+
+			TeamId _ownerTeamId;
+			uint32 _areaTrigger;
+			int8 _barStatus;
+			int8 _playersCount[BG_TEAMS_COUNT];
+
+			bool IsUnderControl(TeamId teamId) const { return _ownerTeamId == teamId; }
+			bool IsUnderControl() const { return _ownerTeamId != TEAM_NEUTRAL; }
+			bool IsUncontrolled() const { return _ownerTeamId == TEAM_NEUTRAL; }
+		};
+
+		CapturePointInfo _capturePointInfo[EY_POINTS_MAX];
+		EventMap _bgEvents;
+        uint32 _honorTics;
+        uint8 _ownedPointsCount[BG_TEAMS_COUNT];
+        uint64 _flagKeeperGUID;
+        uint64 _droppedFlagGUID;
+        uint8 _flagState;
+        uint32 _flagCapturedObject;
+};
+#endif
+

src/server/game/Battlegrounds/Zones/BattlegroundNA.cpp

@@ -0,0 +1,151 @@
+/*
+ * Copyright (C) 
+ * Copyright (C) 
+ *
+ * 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "BattlegroundNA.h"
+#include "Language.h"
+#include "Object.h"
+#include "ObjectMgr.h"
+#include "Player.h"
+#include "WorldPacket.h"
+#include "WorldSession.h"
+
+BattlegroundNA::BattlegroundNA()
+{
+    BgObjects.resize(BG_NA_OBJECT_MAX);
+
+    StartDelayTimes[BG_STARTING_EVENT_FIRST]  = BG_START_DELAY_1M;
+    StartDelayTimes[BG_STARTING_EVENT_SECOND] = BG_START_DELAY_30S;
+    StartDelayTimes[BG_STARTING_EVENT_THIRD]  = BG_START_DELAY_15S;
+    StartDelayTimes[BG_STARTING_EVENT_FOURTH] = BG_START_DELAY_NONE;
+    //we must set messageIds
+    StartMessageIds[BG_STARTING_EVENT_FIRST]  = LANG_ARENA_ONE_MINUTE;
+    StartMessageIds[BG_STARTING_EVENT_SECOND] = LANG_ARENA_THIRTY_SECONDS;
+    StartMessageIds[BG_STARTING_EVENT_THIRD]  = LANG_ARENA_FIFTEEN_SECONDS;
+    StartMessageIds[BG_STARTING_EVENT_FOURTH] = LANG_ARENA_HAS_BEGUN;
+}
+
+BattlegroundNA::~BattlegroundNA()
+{
+
+}
+
+void BattlegroundNA::StartingEventCloseDoors()
+{
+    for (uint32 i = BG_NA_OBJECT_DOOR_1; i <= BG_NA_OBJECT_DOOR_4; ++i)
+        SpawnBGObject(i, RESPAWN_IMMEDIATELY);
+}
+
+void BattlegroundNA::StartingEventOpenDoors()
+{
+    for (uint32 i = BG_NA_OBJECT_DOOR_1; i <= BG_NA_OBJECT_DOOR_2; ++i)
+        DoorOpen(i);
+
+    for (uint32 i = BG_NA_OBJECT_BUFF_1; i <= BG_NA_OBJECT_BUFF_2; ++i)
+        SpawnBGObject(i, 60);
+}
+
+void BattlegroundNA::AddPlayer(Player* player)
+{
+    Battleground::AddPlayer(player);
+    PlayerScores[player->GetGUID()] = new BattlegroundScore(player);
+    Battleground::UpdateArenaWorldState();
+}
+
+void BattlegroundNA::RemovePlayer(Player* /*player*/)
+{
+    if (GetStatus() == STATUS_WAIT_LEAVE)
+        return;
+
+    Battleground::UpdateArenaWorldState();
+    CheckArenaWinConditions();
+}
+
+void BattlegroundNA::HandleKillPlayer(Player* player, Player* killer)
+{
+    if (GetStatus() != STATUS_IN_PROGRESS)
+        return;
+
+    if (!killer)
+    {
+        sLog->outError("BattlegroundNA: Killer player not found");
+        return;
+    }
+
+    Battleground::HandleKillPlayer(player, killer);
+
+    Battleground::UpdateArenaWorldState();
+    CheckArenaWinConditions();
+}
+
+bool BattlegroundNA::HandlePlayerUnderMap(Player* player)
+{
+    player->NearTeleportTo(4055.504395f, 2919.660645f, 13.611241f, player->GetOrientation());
+    return true;
+}
+
+void BattlegroundNA::HandleAreaTrigger(Player* player, uint32 trigger)
+{
+    if (GetStatus() != STATUS_IN_PROGRESS)
+        return;
+
+    switch (trigger)
+    {
+        case 4536:                                          // buff trigger?
+        case 4537:                                          // buff trigger?
+            break;
+		// OUTSIDE OF ARENA, TELEPORT!
+		case 4917:
+		case 5006:
+		case 5008:
+			player->NearTeleportTo(4054.15f, 2923.7f, 13.4f, player->GetOrientation());
+			break;
+    }
+}
+
+void BattlegroundNA::FillInitialWorldStates(WorldPacket &data)
+{
+    data << uint32(0xa11) << uint32(1);           // 9
+    Battleground::UpdateArenaWorldState();
+}
+
+void BattlegroundNA::Init()
+{
+    //call parent's class reset
+    Battleground::Init();
+}
+
+bool BattlegroundNA::SetupBattleground()
+{
+    // gates
+    if (!AddObject(BG_NA_OBJECT_DOOR_1, BG_NA_OBJECT_TYPE_DOOR_1, 4031.854f, 2966.833f, 12.6462f, -2.648788f, 0, 0, 0.9697962f, -0.2439165f, RESPAWN_IMMEDIATELY)
+        || !AddObject(BG_NA_OBJECT_DOOR_2, BG_NA_OBJECT_TYPE_DOOR_2, 4081.179f, 2874.97f, 12.39171f, 0.4928045f, 0, 0, 0.2439165f, 0.9697962f, RESPAWN_IMMEDIATELY)
+        || !AddObject(BG_NA_OBJECT_DOOR_3, BG_NA_OBJECT_TYPE_DOOR_3, 4023.709f, 2981.777f, 10.70117f, -2.648788f, 0, 0, 0.9697962f, -0.2439165f, RESPAWN_IMMEDIATELY)
+        || !AddObject(BG_NA_OBJECT_DOOR_4, BG_NA_OBJECT_TYPE_DOOR_4, 4090.064f, 2858.438f, 10.23631f, 0.4928045f, 0, 0, 0.2439165f, 0.9697962f, RESPAWN_IMMEDIATELY)
+    // buffs
+        || !AddObject(BG_NA_OBJECT_BUFF_1, BG_NA_OBJECT_TYPE_BUFF_1, 4009.189941f, 2895.250000f, 13.052700f, -1.448624f, 0, 0, 0.6626201f, -0.7489557f, 120)
+        || !AddObject(BG_NA_OBJECT_BUFF_2, BG_NA_OBJECT_TYPE_BUFF_2, 4103.330078f, 2946.350098f, 13.051300f, -0.06981307f, 0, 0, 0.03489945f, -0.9993908f, 120)
+    // Arena Ready Marker
+        || !AddObject(BG_NA_OBJECT_READY_MARKER_1, ARENA_READY_MARKER_ENTRY, 4090.46f, 2875.43f, 12.16f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 300)
+        || !AddObject(BG_NA_OBJECT_READY_MARKER_2, ARENA_READY_MARKER_ENTRY, 4022.82f, 2966.61f, 12.17f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 300))
+    {
+        sLog->outErrorDb("BatteGroundNA: Failed to spawn some object!");
+        return false;
+    }
+
+    return true;
+}

src/server/game/Battlegrounds/Zones/BattlegroundNA.h

@@ -0,0 +1,65 @@
+/*
+ * Copyright (C) 
+ * Copyright (C) 
+ *
+ * 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, see <http://www.gnu.org/licenses/>.
+ */
+#ifndef __BATTLEGROUNDNA_H
+#define __BATTLEGROUNDNA_H
+
+#include "Battleground.h"
+
+enum BattlegroundNAObjectTypes
+{
+    BG_NA_OBJECT_DOOR_1         = 0,
+    BG_NA_OBJECT_DOOR_2         = 1,
+    BG_NA_OBJECT_DOOR_3         = 2,
+    BG_NA_OBJECT_DOOR_4         = 3,
+    BG_NA_OBJECT_BUFF_1         = 4,
+    BG_NA_OBJECT_BUFF_2         = 5,
+	BG_NA_OBJECT_READY_MARKER_1 = 6,
+	BG_NA_OBJECT_READY_MARKER_2 = 7,
+    BG_NA_OBJECT_MAX            = 8
+};
+
+enum BattlegroundNAObjects
+{
+    BG_NA_OBJECT_TYPE_DOOR_1    = 183978,
+    BG_NA_OBJECT_TYPE_DOOR_2    = 183980,
+    BG_NA_OBJECT_TYPE_DOOR_3    = 183977,
+    BG_NA_OBJECT_TYPE_DOOR_4    = 183979,
+    BG_NA_OBJECT_TYPE_BUFF_1    = 184663,
+    BG_NA_OBJECT_TYPE_BUFF_2    = 184664
+};
+
+class BattlegroundNA : public Battleground
+{
+    public:
+        BattlegroundNA();
+        ~BattlegroundNA();
+
+        /* inherited from BattlegroundClass */
+        void AddPlayer(Player* player);
+        void StartingEventCloseDoors();
+        void StartingEventOpenDoors();
+
+        void RemovePlayer(Player* player);
+        void HandleAreaTrigger(Player* player, uint32 trigger);
+        bool SetupBattleground();
+        void Init();
+        void FillInitialWorldStates(WorldPacket &d);
+        void HandleKillPlayer(Player* player, Player* killer);
+        bool HandlePlayerUnderMap(Player* player);
+};
+#endif

src/server/game/Battlegrounds/Zones/BattlegroundRL.cpp

@@ -0,0 +1,175 @@
+/*
+ * Copyright (C) 
+ * Copyright (C) 
+ *
+ * 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "BattlegroundRL.h"
+#include "Language.h"
+#include "Object.h"
+#include "ObjectMgr.h"
+#include "Player.h"
+#include "WorldPacket.h"
+#include "WorldSession.h"
+
+BattlegroundRL::BattlegroundRL()
+{
+    BgObjects.resize(BG_RL_OBJECT_MAX);
+
+    StartDelayTimes[BG_STARTING_EVENT_FIRST]  = BG_START_DELAY_1M;
+    StartDelayTimes[BG_STARTING_EVENT_SECOND] = BG_START_DELAY_30S;
+    StartDelayTimes[BG_STARTING_EVENT_THIRD]  = BG_START_DELAY_15S;
+    StartDelayTimes[BG_STARTING_EVENT_FOURTH] = BG_START_DELAY_NONE;
+    //we must set messageIds
+    StartMessageIds[BG_STARTING_EVENT_FIRST]  = LANG_ARENA_ONE_MINUTE;
+    StartMessageIds[BG_STARTING_EVENT_SECOND] = LANG_ARENA_THIRTY_SECONDS;
+    StartMessageIds[BG_STARTING_EVENT_THIRD]  = LANG_ARENA_FIFTEEN_SECONDS;
+    StartMessageIds[BG_STARTING_EVENT_FOURTH] = LANG_ARENA_HAS_BEGUN;
+}
+
+BattlegroundRL::~BattlegroundRL()
+{
+
+}
+
+void BattlegroundRL::StartingEventCloseDoors()
+{
+    for (uint32 i = BG_RL_OBJECT_DOOR_1; i <= BG_RL_OBJECT_DOOR_2; ++i)
+        SpawnBGObject(i, RESPAWN_IMMEDIATELY);
+}
+
+void BattlegroundRL::StartingEventOpenDoors()
+{
+    for (uint32 i = BG_RL_OBJECT_DOOR_1; i <= BG_RL_OBJECT_DOOR_2; ++i)
+        DoorOpen(i);
+
+    for (uint32 i = BG_RL_OBJECT_BUFF_1; i <= BG_RL_OBJECT_BUFF_2; ++i)
+        SpawnBGObject(i, 60);
+}
+
+void BattlegroundRL::AddPlayer(Player* player)
+{
+    Battleground::AddPlayer(player);
+    PlayerScores[player->GetGUID()] = new BattlegroundScore(player);
+	Battleground::UpdateArenaWorldState();
+}
+
+void BattlegroundRL::RemovePlayer(Player* /*player*/)
+{
+    if (GetStatus() == STATUS_WAIT_LEAVE)
+        return;
+
+    UpdateArenaWorldState();
+    CheckArenaWinConditions();
+}
+
+void BattlegroundRL::HandleKillPlayer(Player* player, Player* killer)
+{
+    if (GetStatus() != STATUS_IN_PROGRESS)
+        return;
+
+    if (!killer)
+    {
+        sLog->outError("Killer player not found");
+        return;
+    }
+
+    Battleground::HandleKillPlayer(player, killer);
+
+    Battleground::UpdateArenaWorldState();
+    CheckArenaWinConditions();
+}
+
+bool BattlegroundRL::HandlePlayerUnderMap(Player* player)
+{
+    player->NearTeleportTo(1285.810547f, 1667.896851f, 39.957642f, player->GetOrientation());
+    return true;
+}
+
+void BattlegroundRL::HandleAreaTrigger(Player* player, uint32 trigger)
+{
+    if (GetStatus() != STATUS_IN_PROGRESS)
+        return;
+
+    switch (trigger)
+    {
+        case 4696:                                          // buff trigger?
+        case 4697:                                          // buff trigger?
+            break;
+		// OUTSIDE OF ARENA, TELEPORT!
+		case 4927:
+		case 4928:
+			player->NearTeleportTo(1230.77f, 1662.42f, 34.56f, 0.0f);
+			break;
+		case 4929:
+		case 4930:
+			player->NearTeleportTo(1341.16f, 1673.52f, 34.43f, 3.5f);
+			break;
+		case 4931:
+			player->NearTeleportTo(1294.74f, 1584.5f, 31.62f, 1.66f);
+			break;
+		case 4932:
+			player->NearTeleportTo(1277.5f, 1751.07f, 31.61f, 4.7f);
+			break;
+		case 4933:
+			player->NearTeleportTo(1269.14f, 1713.85f, 34.46f, 5.23f);
+			break;
+		case 4934:
+			player->NearTeleportTo(1298.14f, 1713.8f, 33.58f, 4.55f);
+			break;
+		case 4935:
+			player->NearTeleportTo(1306.32f, 1620.75f, 34.25f, 1.97f);
+			break;
+		case 4936:
+			player->NearTeleportTo(1277.97f, 1615.51f, 34.56f, 1.15f);
+			break;
+		case 4941: // under arena +10
+		case 5041: // under arena -10
+		case 5042: // under arena -30
+			player->NearTeleportTo(1285.810547f, 1667.896851f, 39.957642f, player->GetOrientation());
+			break;
+    }
+}
+
+void BattlegroundRL::FillInitialWorldStates(WorldPacket &data)
+{
+    data << uint32(0xbba) << uint32(1);           // 9
+    Battleground::UpdateArenaWorldState();
+}
+
+void BattlegroundRL::Init()
+{
+    //call parent's reset
+    Battleground::Init();
+}
+
+bool BattlegroundRL::SetupBattleground()
+{
+    // gates
+    if (!AddObject(BG_RL_OBJECT_DOOR_1, BG_RL_OBJECT_TYPE_DOOR_1, 1293.561f, 1601.938f, 31.60557f, -1.457349f, 0, 0, -0.6658813f, 0.7460576f, RESPAWN_IMMEDIATELY)
+        || !AddObject(BG_RL_OBJECT_DOOR_2, BG_RL_OBJECT_TYPE_DOOR_2, 1278.648f, 1730.557f, 31.60557f, 1.684245f, 0, 0, 0.7460582f, 0.6658807f, RESPAWN_IMMEDIATELY)
+    // buffs
+        || !AddObject(BG_RL_OBJECT_BUFF_1, BG_RL_OBJECT_TYPE_BUFF_1, 1328.719971f, 1632.719971f, 36.730400f, -1.448624f, 0, 0, 0.6626201f, -0.7489557f, 120)
+        || !AddObject(BG_RL_OBJECT_BUFF_2, BG_RL_OBJECT_TYPE_BUFF_2, 1243.300049f, 1699.170044f, 34.872601f, -0.06981307f, 0, 0, 0.03489945f, -0.9993908f, 120)
+    // Arena Ready Marker
+        || !AddObject(BG_RL_OBJECT_READY_MARKER_1, ARENA_READY_MARKER_ENTRY, 1298.61f, 1598.59f, 31.62f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 300)
+        || !AddObject(BG_RL_OBJECT_READY_MARKER_2, ARENA_READY_MARKER_ENTRY, 1273.71f, 1734.05f, 31.61f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 300))
+    {
+        sLog->outErrorDb("BatteGroundRL: Failed to spawn some object!");
+        return false;
+    }
+
+    return true;
+}

src/server/game/Battlegrounds/Zones/BattlegroundRL.h

@@ -0,0 +1,61 @@
+/*
+ * Copyright (C) 
+ * Copyright (C) 
+ *
+ * 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, see <http://www.gnu.org/licenses/>.
+ */
+#ifndef __BATTLEGROUNDRL_H
+#define __BATTLEGROUNDRL_H
+
+#include "Battleground.h"
+
+enum BattlegroundRLObjectTypes
+{
+    BG_RL_OBJECT_DOOR_1         = 0,
+    BG_RL_OBJECT_DOOR_2         = 1,
+    BG_RL_OBJECT_BUFF_1         = 2,
+    BG_RL_OBJECT_BUFF_2         = 3,
+	BG_RL_OBJECT_READY_MARKER_1 = 4,
+	BG_RL_OBJECT_READY_MARKER_2 = 5,
+    BG_RL_OBJECT_MAX            = 6
+};
+
+enum BattlegroundRLObjects
+{
+    BG_RL_OBJECT_TYPE_DOOR_1    = 185918,
+    BG_RL_OBJECT_TYPE_DOOR_2    = 185917,
+    BG_RL_OBJECT_TYPE_BUFF_1    = 184663,
+    BG_RL_OBJECT_TYPE_BUFF_2    = 184664
+};
+
+class BattlegroundRL : public Battleground
+{
+    public:
+        BattlegroundRL();
+        ~BattlegroundRL();
+
+        /* inherited from BattlegroundClass */
+        void AddPlayer(Player* player);
+        void Init();
+        void FillInitialWorldStates(WorldPacket &d);
+        void StartingEventCloseDoors();
+        void StartingEventOpenDoors();
+
+        void RemovePlayer(Player* player);
+        void HandleAreaTrigger(Player* player, uint32 trigger);
+        bool SetupBattleground();
+        void HandleKillPlayer(Player* player, Player* killer);
+        bool HandlePlayerUnderMap(Player* player);
+};
+#endif

src/server/game/Battlegrounds/Zones/BattlegroundRV.cpp

@@ -0,0 +1,351 @@
+/*
+ * Copyright (C) 
+ * Copyright (C) 
+ *
+ * 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "Battleground.h"
+#include "BattlegroundRV.h"
+#include "ObjectAccessor.h"
+#include "Language.h"
+#include "Player.h"
+#include "WorldPacket.h"
+#include "GameObject.h"
+#include "WorldSession.h"
+#include "Pet.h"
+
+BattlegroundRV::BattlegroundRV()
+{
+    BgObjects.resize(BG_RV_OBJECT_MAX);
+
+    StartDelayTimes[BG_STARTING_EVENT_FIRST]  = BG_START_DELAY_1M;
+    StartDelayTimes[BG_STARTING_EVENT_SECOND] = BG_START_DELAY_30S;
+    StartDelayTimes[BG_STARTING_EVENT_THIRD]  = BG_START_DELAY_15S;
+    StartDelayTimes[BG_STARTING_EVENT_FOURTH] = BG_START_DELAY_NONE;
+    StartMessageIds[BG_STARTING_EVENT_FIRST]  = LANG_ARENA_ONE_MINUTE;
+    StartMessageIds[BG_STARTING_EVENT_SECOND] = LANG_ARENA_THIRTY_SECONDS;
+    StartMessageIds[BG_STARTING_EVENT_THIRD]  = LANG_ARENA_FIFTEEN_SECONDS;
+    StartMessageIds[BG_STARTING_EVENT_FOURTH] = LANG_ARENA_HAS_BEGUN;
+
+    CheckPlayersTimer = 0;
+}
+
+BattlegroundRV::~BattlegroundRV() { }
+
+void BattlegroundRV::TeleportUnitToNewZ(Unit* unit, float newZ, bool casting)
+{
+	if (!unit->IsAlive())
+		return;
+    unit->NearTeleportTo(unit->GetPositionX(), unit->GetPositionY(), newZ, unit->GetOrientation(), casting);
+    unit->m_positionZ = newZ;
+}
+
+void BattlegroundRV::CheckPositionForUnit(Unit* unit)
+{
+	// get height at current pos, if something is wrong (below or high above) - teleport
+	if (!unit->IsFalling() && unit->IsAlive())
+	{
+		float groundZ_vmap = unit->GetMap()->GetHeight(unit->GetPositionX(), unit->GetPositionY(), 37.0f, true, 50.0f);
+		float groundZ_dyntree = unit->GetMap()->GetDynamicMapTree().getHeight(unit->GetPositionX(), unit->GetPositionY(), 37.0f, 50.0f, unit->GetPhaseMask());
+		if (groundZ_vmap > 28.0f && groundZ_vmap < 29.0f || groundZ_dyntree > 28.0f && groundZ_dyntree < 37.0f)
+		{
+			float groundZ = std::max<float>(groundZ_vmap, groundZ_dyntree);
+			if (unit->GetPositionZ() < groundZ - 0.2f || unit->GetPositionZ() > groundZ + 3.5f)
+				TeleportUnitToNewZ(unit, groundZ+1.0f, true);
+		}
+	}
+}
+
+void BattlegroundRV::PostUpdateImpl(uint32 diff)
+{
+    if (GetStatus() != STATUS_IN_PROGRESS)
+        return;
+
+    if (getTimer() < diff)
+    {
+        switch (getState())
+        {
+            case BG_RV_STATE_OPEN_FENCES:
+                for (uint8 i = BG_RV_OBJECT_FIRE_1; i <= BG_RV_OBJECT_FIREDOOR_2; ++i)
+                    DoorOpen(i);
+                setTimer(BG_RV_CLOSE_FIRE_TIMER);
+                setState(BG_RV_STATE_CLOSE_FIRE);
+
+                for (BattlegroundPlayerMap::iterator itr = m_Players.begin(); itr != m_Players.end(); ++itr)
+                    if (Player* player = itr->second)
+                    {
+                        // Demonic Circle Summon
+						if (GameObject* gObj = player->GetGameObject(48018))
+						{
+							gObj->Relocate(gObj->GetPositionX(), gObj->GetPositionY(), 28.28f);
+							gObj->UpdateObjectVisibility(true);
+						}
+
+                        if (player->GetPositionZ() < 27.0f)
+                            TeleportUnitToNewZ(player, 28.28f, true);
+
+                        for (uint8 i = SUMMON_SLOT_TOTEM; i < MAX_TOTEM_SLOT; ++i)
+                            if (player->m_SummonSlot[i])
+                                if (Creature* totem = GetBgMap()->GetCreature(player->m_SummonSlot[i]))
+                                    if (totem->GetPositionZ() < 28.0f)
+                                        TeleportUnitToNewZ(totem, 28.28f, true);
+
+                        for (Unit::ControlSet::const_iterator itr = player->m_Controlled.begin(); itr != player->m_Controlled.end(); ++itr)
+						{
+                            if ((*itr)->GetPositionZ() < 28.0f)
+                                TeleportUnitToNewZ((*itr), 28.28f, true);
+
+							// Xinef: override stay position
+							if (CharmInfo* charmInfo = (*itr)->GetCharmInfo())
+								if (charmInfo->IsAtStay())
+								{
+									(*itr)->StopMovingOnCurrentPos();
+									charmInfo->SaveStayPosition(false);
+								}
+						}
+                    }
+
+                // fix ground on elevators (so aoe spells can be casted there)
+                {
+                    uint32 objects[2] = {BG_RV_OBJECT_ELEVATOR_1, BG_RV_OBJECT_ELEVATOR_2};
+                    for (uint8 i=0; i<2; ++i)
+                        if (GameObject* go = GetBGObject(objects[i]))
+                            go->RemoveFlag(GAMEOBJECT_FLAGS, GO_FLAG_TRANSPORT);
+                }
+                break;
+            case BG_RV_STATE_CLOSE_FIRE:
+                for (uint8 i = BG_RV_OBJECT_FIRE_1; i <= BG_RV_OBJECT_FIREDOOR_2; ++i)
+                    DoorClose(i);
+                // Fire got closed after five seconds, leaves twenty seconds before toggling pillars
+                setTimer(BG_RV_FIRE_TO_PILLAR_TIMER);
+                setState(BG_RV_STATE_SWITCH_PILLARS);
+                break;
+            case BG_RV_STATE_SWITCH_PILLARS:
+                UpdatePillars();
+                setTimer(BG_RV_PILLAR_SWITCH_TIMER);
+                break;
+        }
+    }
+    else
+        setTimer(getTimer() - diff);
+
+	if (getState() == BG_RV_STATE_OPEN_FENCES)
+		return;
+
+    if (CheckPlayersTimer <= diff)
+    {
+        CheckPlayersTimer = 0;
+        for (BattlegroundPlayerMap::iterator itr = m_Players.begin(); itr != m_Players.end(); ++itr)
+            CheckPositionForUnit(itr->second);
+
+		// maybe for pets and m_Controlled also, but not really necessary
+    }
+    else
+        CheckPlayersTimer -= diff;
+}
+
+void BattlegroundRV::StartingEventCloseDoors()
+{
+}
+
+void BattlegroundRV::StartingEventOpenDoors()
+{
+    for (BattlegroundPlayerMap::iterator itr = m_Players.begin(); itr != m_Players.end(); ++itr)
+        itr->second->SetPhaseMask(1, true);
+
+    // Buff respawn
+    SpawnBGObject(BG_RV_OBJECT_BUFF_1, 90);
+    SpawnBGObject(BG_RV_OBJECT_BUFF_2, 90);
+
+    // Elevators
+    DoorOpen(BG_RV_OBJECT_ELEVATOR_1);
+    DoorOpen(BG_RV_OBJECT_ELEVATOR_2);
+
+    setState(BG_RV_STATE_OPEN_FENCES);
+    setTimer(BG_RV_FIRST_TIMER);
+}
+
+void BattlegroundRV::AddPlayer(Player* player)
+{
+	if (GetStatus() == STATUS_WAIT_JOIN && player->GetBgTeamId() == TEAM_HORDE)
+        player->SetPhaseMask(2, true);
+
+    Battleground::AddPlayer(player);
+    PlayerScores[player->GetGUID()] = new BattlegroundScore(player);
+	BattlegroundRV::UpdateArenaWorldState();
+}
+
+void BattlegroundRV::RemovePlayer(Player* player)
+{
+    if (GetStatus() == STATUS_WAIT_LEAVE)
+        return;
+
+    if (GetStatus() == STATUS_WAIT_JOIN)
+        player->SetPhaseMask(1, true);
+
+	BattlegroundRV::UpdateArenaWorldState();
+    CheckArenaWinConditions();
+}
+
+void BattlegroundRV::HandleKillPlayer(Player* player, Player* killer)
+{
+    if (GetStatus() != STATUS_IN_PROGRESS)
+        return;
+
+    if (!killer)
+        return;
+
+    Battleground::HandleKillPlayer(player, killer);
+	BattlegroundRV::UpdateArenaWorldState();
+
+    CheckArenaWinConditions();
+}
+
+bool BattlegroundRV::HandlePlayerUnderMap(Player* player)
+{
+    player->NearTeleportTo(763.5f, -284, 28.276f, 2.422f);
+    return true;
+}
+
+void BattlegroundRV::HandleAreaTrigger(Player* player, uint32 trigger)
+{
+    if (GetStatus() != STATUS_IN_PROGRESS || getState() == BG_RV_STATE_OPEN_FENCES /*during elevator rising it's possible to jump and cause areatrigger*/)
+        return;
+
+    switch (trigger)
+    {
+        // fire was removed in 3.2.0
+        case 5473:
+        case 5474:
+            break;
+        // OUTSIDE OF ARENA, TELEPORT!
+        case 5224:
+            player->NearTeleportTo(765.0f, -294.0f, 28.3f, player->GetOrientation());
+            break;
+        case 5226:
+            player->NearTeleportTo(765.0f, -272.0f, 28.3f, player->GetOrientation());
+            break;
+        case 5447:
+            player->NearTeleportTo(763.5f, -284, 28.276f, 2.422f);
+            break;
+    }
+}
+
+void BattlegroundRV::FillInitialWorldStates(WorldPacket &data)
+{
+    data << uint32(BG_RV_WORLD_STATE) << uint32(1);
+	BattlegroundRV::UpdateArenaWorldState();
+}
+
+void BattlegroundRV::UpdateArenaWorldState()
+{
+    UpdateWorldState(BG_RV_WORLD_STATE_A, GetAlivePlayersCountByTeam(TEAM_ALLIANCE));
+    UpdateWorldState(BG_RV_WORLD_STATE_H, GetAlivePlayersCountByTeam(TEAM_HORDE));
+}
+
+void BattlegroundRV::Init()
+{
+    //call parent's class reset
+    Battleground::Init();
+}
+
+bool BattlegroundRV::SetupBattleground()
+{
+    // elevators
+    if (!AddObject(BG_RV_OBJECT_ELEVATOR_1, BG_RV_OBJECT_TYPE_ELEVATOR_1, 763.536377f, -294.535767f, 0.505383f, 3.141593f, 0, 0, 0, RESPAWN_IMMEDIATELY)
+        || !AddObject(BG_RV_OBJECT_ELEVATOR_2, BG_RV_OBJECT_TYPE_ELEVATOR_2, 763.506348f, -273.873352f, 0.505383f, 0.000000f, 0, 0, 0, RESPAWN_IMMEDIATELY)
+    // buffs
+        || !AddObject(BG_RV_OBJECT_BUFF_1, BG_RV_OBJECT_TYPE_BUFF_1, 735.551819f, -284.794678f, 28.276682f, 0.034906f, 0, 0, 0, RESPAWN_IMMEDIATELY)
+        || !AddObject(BG_RV_OBJECT_BUFF_2, BG_RV_OBJECT_TYPE_BUFF_2, 791.224487f, -284.794464f, 28.276682f, 2.600535f, 0, 0, 0, RESPAWN_IMMEDIATELY)
+    // fire
+        || !AddObject(BG_RV_OBJECT_FIRE_1, BG_RV_OBJECT_TYPE_FIRE_1, 743.543457f, -283.799469f, 28.286655f, 3.141593f, 0, 0, 0, RESPAWN_IMMEDIATELY)
+        || !AddObject(BG_RV_OBJECT_FIRE_2, BG_RV_OBJECT_TYPE_FIRE_2, 782.971802f, -283.799469f, 28.286655f, 3.141593f, 0, 0, 0, RESPAWN_IMMEDIATELY)
+        || !AddObject(BG_RV_OBJECT_FIREDOOR_1, BG_RV_OBJECT_TYPE_FIREDOOR_1, 743.711060f, -284.099609f, 27.542587f, 3.141593f, 0, 0, 0, RESPAWN_IMMEDIATELY)
+        || !AddObject(BG_RV_OBJECT_FIREDOOR_2, BG_RV_OBJECT_TYPE_FIREDOOR_2, 783.221252f, -284.133362f, 27.535686f, 0.000000f, 0, 0, 0, RESPAWN_IMMEDIATELY)
+    // Gear
+        || !AddObject(BG_RV_OBJECT_GEAR_1, BG_RV_OBJECT_TYPE_GEAR_1, 763.664551f, -261.872986f, 26.686588f, 0.000000f, 0, 0, 0, RESPAWN_IMMEDIATELY)
+        || !AddObject(BG_RV_OBJECT_GEAR_2, BG_RV_OBJECT_TYPE_GEAR_2, 763.578979f, -306.146149f, 26.665222f, 3.141593f, 0, 0, 0, RESPAWN_IMMEDIATELY)
+    // Pulley
+        || !AddObject(BG_RV_OBJECT_PULLEY_1, BG_RV_OBJECT_TYPE_PULLEY_1, 700.722290f, -283.990662f, 39.517582f, 3.141593f, 0, 0, 0, RESPAWN_IMMEDIATELY)
+        || !AddObject(BG_RV_OBJECT_PULLEY_2, BG_RV_OBJECT_TYPE_PULLEY_2, 826.303833f, -283.996429f, 39.517582f, 0.000000f, 0, 0, 0, RESPAWN_IMMEDIATELY)
+    // Pilars
+        || !AddObject(BG_RV_OBJECT_PILAR_1, BG_RV_OBJECT_TYPE_PILAR_1, 763.632385f, -306.162384f, 25.909504f, 3.141593f, 0, 0, 0, RESPAWN_IMMEDIATELY)
+        || !AddObject(BG_RV_OBJECT_PILAR_2, BG_RV_OBJECT_TYPE_PILAR_2, 723.644287f, -284.493256f, 24.648525f, 3.141593f, 0, 0, 0, RESPAWN_IMMEDIATELY)
+        || !AddObject(BG_RV_OBJECT_PILAR_3, BG_RV_OBJECT_TYPE_PILAR_3, 763.611145f, -261.856750f, 25.909504f, 0.000000f, 0, 0, 0, RESPAWN_IMMEDIATELY)
+        || !AddObject(BG_RV_OBJECT_PILAR_4, BG_RV_OBJECT_TYPE_PILAR_4, 802.211609f, -284.493256f, 24.648525f, 0.000000f, 0, 0, 0, RESPAWN_IMMEDIATELY)
+
+    // Arena Ready Marker
+        || !AddObject(BG_RV_OBJECT_READY_MARKER_1, ARENA_READY_MARKER_ENTRY, 769.93f, -301.04f, 2.80f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 300)
+        || !AddObject(BG_RV_OBJECT_READY_MARKER_2, ARENA_READY_MARKER_ENTRY, 757.02f, -267.30f, 2.80f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 300)
+    )
+    {
+        sLog->outErrorDb("BatteGroundRV: Failed to spawn some object!");
+        return false;
+    }
+
+    for (uint8 i=0; i<BG_RV_OBJECT_MAX; ++i)
+        if (GameObject* go = GetBGObject(i))
+            go->SetPhaseMask(3, true);
+
+    return true;
+}
+
+void BattlegroundRV::UpdatePillars()
+{
+	GameObject* test = GetBgMap()->GetGameObject(BgObjects[BG_RV_OBJECT_PILAR_1]);
+	if (!test)
+		return;
+
+	if (test->GetGoState() == GO_STATE_READY)
+    {
+        for (uint8 i = BG_RV_OBJECT_PILAR_1; i <= BG_RV_OBJECT_GEAR_2; ++i)
+			if (GameObject* go = GetBgMap()->GetGameObject(BgObjects[i]))
+				go->SetGoState(GO_STATE_ACTIVE);
+        for (uint8 i = BG_RV_OBJECT_PILAR_2; i <= BG_RV_OBJECT_PULLEY_2; ++i)
+			if (GameObject* go = GetBgMap()->GetGameObject(BgObjects[i]))
+				go->SetGoState(GO_STATE_READY);
+    }
+    else
+    {
+        for (uint8 i = BG_RV_OBJECT_PILAR_1; i <= BG_RV_OBJECT_GEAR_2; ++i)
+			if (GameObject* go = GetBgMap()->GetGameObject(BgObjects[i]))
+				go->SetGoState(GO_STATE_READY);
+        for (uint8 i = BG_RV_OBJECT_PILAR_2; i <= BG_RV_OBJECT_PULLEY_2; ++i)
+			if (GameObject* go = GetBgMap()->GetGameObject(BgObjects[i]))
+				go->SetGoState(GO_STATE_ACTIVE);
+    }
+}
+
+uint32 BattlegroundRV::GetPillarIdForPos(Position* p)
+{
+    float range = 1.75f;
+    if (p->GetExactDist2d(763.632385f, -306.162384f) < range)
+        return BG_RV_OBJECT_PILAR_1;
+    if (p->GetExactDist2d(723.644287f, -284.493256f) < 2.0f*range)
+        return BG_RV_OBJECT_PILAR_2;
+    if (p->GetExactDist2d(763.611145f, -261.856750f) < range)
+        return BG_RV_OBJECT_PILAR_3;
+    if (p->GetExactDist2d(802.211609f, -284.493256f) < 2.0f*range)
+        return BG_RV_OBJECT_PILAR_4;
+    return 0;
+}
+
+GameObject* BattlegroundRV::GetPillarAtPosition(Position* p)
+{
+    uint32 pillar = GetPillarIdForPos(p);
+    if (!pillar)
+        return NULL;
+    return GetBgMap()->GetGameObject(BgObjects[pillar]);
+}

src/server/game/Battlegrounds/Zones/BattlegroundRV.h

@@ -0,0 +1,128 @@
+/*
+ * Copyright (C) 
+ * Copyright (C) 
+ *
+ * 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, see <http://www.gnu.org/licenses/>.
+ */
+#ifndef __BATTLEGROUNDRV_H
+#define __BATTLEGROUNDRV_H
+
+#include "Battleground.h"
+
+enum BattlegroundRVObjectTypes
+{
+    BG_RV_OBJECT_BUFF_1,
+    BG_RV_OBJECT_BUFF_2,
+    BG_RV_OBJECT_FIRE_1,
+    BG_RV_OBJECT_FIRE_2,
+    BG_RV_OBJECT_FIREDOOR_1,
+    BG_RV_OBJECT_FIREDOOR_2,
+
+    BG_RV_OBJECT_PILAR_1,
+    BG_RV_OBJECT_PILAR_3,
+    BG_RV_OBJECT_GEAR_1,
+    BG_RV_OBJECT_GEAR_2,
+
+    BG_RV_OBJECT_PILAR_2,
+    BG_RV_OBJECT_PILAR_4,
+    BG_RV_OBJECT_PULLEY_1,
+    BG_RV_OBJECT_PULLEY_2,
+
+    BG_RV_OBJECT_ELEVATOR_1,
+    BG_RV_OBJECT_ELEVATOR_2,
+
+	BG_RV_OBJECT_READY_MARKER_1,
+	BG_RV_OBJECT_READY_MARKER_2,
+
+    BG_RV_OBJECT_MAX,
+};
+
+enum BattlegroundRVObjects
+{
+    BG_RV_OBJECT_TYPE_BUFF_1                     = 184663,
+    BG_RV_OBJECT_TYPE_BUFF_2                     = 184664,
+    BG_RV_OBJECT_TYPE_FIRE_1                     = 192704,
+    BG_RV_OBJECT_TYPE_FIRE_2                     = 192705,
+
+    BG_RV_OBJECT_TYPE_FIREDOOR_2                 = 192387,
+    BG_RV_OBJECT_TYPE_FIREDOOR_1                 = 192388,
+    BG_RV_OBJECT_TYPE_PULLEY_1                   = 192389,
+    BG_RV_OBJECT_TYPE_PULLEY_2                   = 192390,
+    BG_RV_OBJECT_TYPE_GEAR_1                     = 192393,
+    BG_RV_OBJECT_TYPE_GEAR_2                     = 192394,
+
+    BG_RV_OBJECT_TYPE_ELEVATOR_1                 = 194582,
+    BG_RV_OBJECT_TYPE_ELEVATOR_2                 = 194586,
+
+    BG_RV_OBJECT_TYPE_PILAR_1                    = 194583, // axe
+    BG_RV_OBJECT_TYPE_PILAR_2                    = 194584, // arena
+    BG_RV_OBJECT_TYPE_PILAR_3                    = 194585, // lightning
+    BG_RV_OBJECT_TYPE_PILAR_4                    = 194587, // ivory
+};
+
+enum BattlegroundRVData
+{
+    BG_RV_STATE_OPEN_FENCES,
+    BG_RV_STATE_SWITCH_PILLARS,
+    BG_RV_STATE_CLOSE_FIRE,
+
+    BG_RV_PILLAR_SWITCH_TIMER                    = 25000,
+    BG_RV_FIRE_TO_PILLAR_TIMER                   = 20000,
+    BG_RV_CLOSE_FIRE_TIMER                       =  5000,
+    BG_RV_FIRST_TIMER                            = 20500, // elevators rise in 20133ms
+    BG_RV_WORLD_STATE_A                          = 0xe11,
+    BG_RV_WORLD_STATE_H                          = 0xe10,
+    BG_RV_WORLD_STATE                            = 0xe1a,
+};
+
+class BattlegroundRV : public Battleground
+{
+    public:
+        BattlegroundRV();
+        ~BattlegroundRV();
+
+        /* inherited from BattlegroundClass */
+        void AddPlayer(Player* player);
+        void RemovePlayer(Player* player);
+        void StartingEventCloseDoors();
+        void StartingEventOpenDoors();
+        void Init();
+        void FillInitialWorldStates(WorldPacket &d);
+		void UpdateArenaWorldState();
+        void HandleAreaTrigger(Player* player, uint32 trigger);
+        bool SetupBattleground();
+        void HandleKillPlayer(Player* player, Player* killer);
+        bool HandlePlayerUnderMap(Player* player);
+
+        GameObject* GetPillarAtPosition(Position* p);
+
+    private:
+        uint32 Timer;
+        uint32 State;
+        uint16 CheckPlayersTimer;
+
+        void PostUpdateImpl(uint32 diff);
+
+    protected:
+        uint32 getTimer() { return Timer; }
+        void setTimer(uint32 timer) { Timer = timer; }
+        uint32 getState() { return State; };
+        void setState(uint32 state) { State = state; }
+
+        void TeleportUnitToNewZ(Unit* unit, float newZ, bool casting);
+        void CheckPositionForUnit(Unit* unit);
+        void UpdatePillars();
+        uint32 GetPillarIdForPos(Position* p);
+};
+#endif

src/server/game/Battlegrounds/Zones/BattlegroundSA.h

@@ -0,0 +1,606 @@
+/*
+ * Copyright (C) 
+ * Copyright (C) 
+ *
+ * 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef __BATTLEGROUNDSA_H
+#define __BATTLEGROUNDSA_H
+
+#include "Battleground.h"
+
+struct BattlegroundSAScore : public BattlegroundScore
+{
+    BattlegroundSAScore(Player* player) : BattlegroundScore(player), demolishers_destroyed(0), gates_destroyed(0) { }
+    ~BattlegroundSAScore() { }
+    uint8 demolishers_destroyed;
+    uint8 gates_destroyed;
+};
+
+#define BG_SA_FLAG_AMOUNT           3
+#define BG_SA_DEMOLISHER_AMOUNT     4
+#define SPELL_SA_END_OF_ROUND 52459
+
+enum BG_SA_Status
+{
+    BG_SA_NOTSTARTED = 0,
+    BG_SA_WARMUP,
+    BG_SA_ROUND_ONE,
+    BG_SA_SECOND_WARMUP,
+    BG_SA_ROUND_TWO,
+    BG_SA_BONUS_ROUND
+};
+
+enum BG_SA_GateState
+{
+    BG_SA_GATE_OK           = 1,
+    BG_SA_GATE_DAMAGED      = 2,
+    BG_SA_GATE_DESTROYED    = 3
+};
+
+enum BG_SA_Timers
+{
+    BG_SA_BOAT_START    =  60 * IN_MILLISECONDS,
+    BG_SA_WARMUPLENGTH  = 120 * IN_MILLISECONDS,
+    BG_SA_ROUNDLENGTH   = 600 * IN_MILLISECONDS
+};
+
+enum BG_SA_WorldStates
+{
+    BG_SA_TIMER_MINS                = 3559,
+    BG_SA_TIMER_SEC_TENS            = 3560,
+    BG_SA_TIMER_SEC_DECS            = 3561,
+    BG_SA_ALLY_ATTACKS              = 4352,
+    BG_SA_HORDE_ATTACKS             = 4353,
+    BG_SA_PURPLE_GATEWS             = 3614,
+    BG_SA_RED_GATEWS                = 3617,
+    BG_SA_BLUE_GATEWS               = 3620,
+    BG_SA_GREEN_GATEWS              = 3623,
+    BG_SA_YELLOW_GATEWS             = 3638,
+    BG_SA_ANCIENT_GATEWS            = 3849,
+    BG_SA_LEFT_GY_ALLIANCE          = 3635,
+    BG_SA_RIGHT_GY_ALLIANCE         = 3636,
+    BG_SA_CENTER_GY_ALLIANCE        = 3637,
+    BG_SA_RIGHT_ATT_TOKEN_ALL       = 3627,
+    BG_SA_LEFT_ATT_TOKEN_ALL        = 3626,
+    BG_SA_LEFT_ATT_TOKEN_HRD        = 3629,
+    BG_SA_RIGHT_ATT_TOKEN_HRD       = 3628,
+    BG_SA_HORDE_DEFENCE_TOKEN       = 3631,
+    BG_SA_ALLIANCE_DEFENCE_TOKEN    = 3630,
+    BG_SA_RIGHT_GY_HORDE            = 3632,
+    BG_SA_LEFT_GY_HORDE             = 3633,
+    BG_SA_CENTER_GY_HORDE           = 3634,
+    BG_SA_BONUS_TIMER               = 0xdf3,
+    BG_SA_ENABLE_TIMER              = 3564,
+};
+
+enum npc
+{
+    NPC_ANTI_PERSONNAL_CANNON       = 27894,
+    NPC_DEMOLISHER_SA               = 28781,
+    NPC_RIGGER_SPARKLIGHT           = 29260,
+    NPC_GORGRIL_RIGSPARK            = 29262,
+};
+
+enum BG_SA_NPCs
+{
+    BG_SA_GUN_1 = 0,
+    BG_SA_GUN_2,
+    BG_SA_GUN_3,
+    BG_SA_GUN_4,
+    BG_SA_GUN_5,
+    BG_SA_GUN_6,
+    BG_SA_GUN_7,
+    BG_SA_GUN_8,
+    BG_SA_GUN_9,
+    BG_SA_GUN_10,
+    BG_SA_NPC_TRIGGER_1,
+    BG_SA_NPC_TRIGGER_2,
+    BG_SA_NPC_TRIGGER_3,
+    BG_SA_NPC_TRIGGER_4,
+    BG_SA_NPC_TRIGGER_5,
+    BG_SA_DEMOLISHER_1,
+    BG_SA_DEMOLISHER_2,
+    BG_SA_DEMOLISHER_3,
+    BG_SA_DEMOLISHER_4,
+    BG_SA_DEMOLISHER_5,
+    BG_SA_DEMOLISHER_6,
+    BG_SA_DEMOLISHER_7,
+    BG_SA_DEMOLISHER_8,
+    BG_SA_NPC_SPARKLIGHT,
+    BG_SA_NPC_RIGSPARK,
+    BG_SA_MAXNPC
+};
+
+enum BG_SA_Boat
+{
+    BG_SA_BOAT_ONE_A    = 193182,
+    BG_SA_BOAT_TWO_H    = 193183,
+    BG_SA_BOAT_ONE_H    = 193184,
+    BG_SA_BOAT_TWO_A    = 193185,
+};
+
+uint32 const BG_SA_NpcEntries[BG_SA_MAXNPC] =
+{
+    NPC_ANTI_PERSONNAL_CANNON,
+    NPC_ANTI_PERSONNAL_CANNON,
+    NPC_ANTI_PERSONNAL_CANNON,
+    NPC_ANTI_PERSONNAL_CANNON,
+    NPC_ANTI_PERSONNAL_CANNON,
+    NPC_ANTI_PERSONNAL_CANNON,
+    NPC_ANTI_PERSONNAL_CANNON,
+    NPC_ANTI_PERSONNAL_CANNON,
+    NPC_ANTI_PERSONNAL_CANNON,
+    NPC_ANTI_PERSONNAL_CANNON,
+    // Triggers
+    23472,
+    23472,
+    23472,
+    23472,
+    23472,
+    // 4 beach demolishers
+    NPC_DEMOLISHER_SA,
+    NPC_DEMOLISHER_SA,
+    NPC_DEMOLISHER_SA,
+    NPC_DEMOLISHER_SA,
+    // 4 factory demolishers
+    NPC_DEMOLISHER_SA,
+    NPC_DEMOLISHER_SA,
+    NPC_DEMOLISHER_SA,
+    NPC_DEMOLISHER_SA,
+    // Used Demolisher Salesman
+    NPC_RIGGER_SPARKLIGHT,
+    NPC_GORGRIL_RIGSPARK
+};
+
+float const BG_SA_NpcSpawnlocs[BG_SA_MAXNPC][4] =
+{
+    // Cannons
+    { 1436.429f, 110.05f, 41.407f, 5.4f },
+    { 1404.9023f, 84.758f, 41.183f, 5.46f },
+    { 1068.693f, -86.951f, 93.81f, 0.02f },
+    { 1068.83f, -127.56f, 96.45f, 0.0912f },
+    { 1422.115f, -196.433f, 42.1825f, 1.0222f },
+    { 1454.887f, -220.454f, 41.956f, 0.9627f },
+    { 1232.345f, -187.517f, 66.945f, 0.45f },
+    { 1249.634f, -224.189f, 66.72f, 0.635f },
+    { 1236.213f, 92.287f, 64.965f, 5.751f },
+    { 1215.11f, 57.772f, 64.739f, 5.78f },
+    // Triggers
+    { 1453.49f, -250.453f, 30.896f, 4.2883f},
+    { 1377.05f, 97.036f, 30.8605f, 2.46539f},
+    { 1186.05f, 58.8048f, 56.5491f, 2.75992f},
+    { 1042.83f, -72.839f, 84.8145f, 3.58615f},
+    { 1233.62f, -250.49f, 55.4036f, 3.7016f},
+    // Demolishers
+    { 1611.597656f, -117.270073f, 8.719355f, 2.513274f},
+    { 1575.562500f, -158.421875f, 5.024450f, 2.129302f},
+    { 1618.047729f, 61.424641f, 7.248210f, 3.979351f},
+    { 1575.103149f, 98.873344f, 2.830360f, 3.752458f},
+    // Demolishers 2
+    { 1371.055786f, -317.071136f, 35.007359f, 1.947460f},
+    { 1424.034912f, -260.195190f, 31.084425f, 2.820013f},
+    { 1353.139893f, 223.745438f, 35.265411f, 4.343684f},
+    { 1404.809570f, 197.027237f, 32.046032f, 3.605401f},
+    // Npcs
+    { 1348.644165f, -298.786469f, 31.080130f, 1.710423f},
+    { 1358.191040f, 195.527786f, 31.018187f, 4.171337f}
+};
+
+enum BG_SA_Objects
+{
+    BG_SA_GREEN_GATE = 0,
+    BG_SA_YELLOW_GATE,
+    BG_SA_BLUE_GATE,
+    BG_SA_RED_GATE,
+    BG_SA_PURPLE_GATE,
+    BG_SA_ANCIENT_GATE,
+    BG_SA_TITAN_RELIC,
+    BG_SA_BOAT_ONE,
+    BG_SA_BOAT_TWO,
+    BG_SA_SIGIL_1,
+    BG_SA_SIGIL_2,
+    BG_SA_SIGIL_3,
+    BG_SA_SIGIL_4,
+    BG_SA_SIGIL_5,
+    BG_SA_CENTRAL_FLAGPOLE,
+    BG_SA_RIGHT_FLAGPOLE,
+    BG_SA_LEFT_FLAGPOLE,
+    BG_SA_CENTRAL_FLAG,
+    BG_SA_RIGHT_FLAG,
+    BG_SA_LEFT_FLAG,
+    BG_SA_PORTAL_DEFFENDER_BLUE,
+    BG_SA_PORTAL_DEFFENDER_GREEN,
+    BG_SA_PORTAL_DEFFENDER_YELLOW,
+    BG_SA_PORTAL_DEFFENDER_PURPLE,
+    BG_SA_PORTAL_DEFFENDER_RED,
+    BG_SA_BOMB,
+    BG_SA_MAXOBJ = BG_SA_BOMB+68
+};
+
+float const BG_SA_ObjSpawnlocs[BG_SA_MAXOBJ][4] =
+{
+    { 1411.57f, 108.163f, 28.692f, 5.441f },
+    { 1055.452f, -108.1f, 82.134f, 0.034f },
+    { 1431.3413f, -219.437f, 30.893f, 0.9736f },
+    { 1227.667f, -212.555f, 55.372f, 0.5023f },
+    { 1214.681f, 81.21f, 53.413f, 5.745f },
+    { 878.555f, -108.2f, 117.845f, 0.0f },
+    { 836.5f, -108.8f, 120.219f, 0.0f },
+    // Ships
+    { 2679.696777f, -826.891235f, 3.712860f, 5.78367f}, //rot2 1 rot3 0.0002f
+    { 2574.003662f, 981.261475f, 2.603424f, 0.807696f},
+    // Sigils
+    { 1414.054f, 106.72f, 41.442f, 5.441f },
+    { 1060.63f, -107.8f, 94.7f, 0.034f },
+    { 1433.383f, -216.4f, 43.642f, 0.9736f },
+    { 1230.75f, -210.724f, 67.611f, 0.5023f },
+    { 1217.8f, 79.532f, 66.58f, 5.745f },
+    // Flagpoles
+    { 1215.114258f, -65.711861f, 70.084267f, -3.124123f},
+    {1338.863892f, -153.336533f, 30.895121f, -2.530723f},
+    {1309.124268f, 9.410645f, 30.893402f, -1.623156f},
+    // Flags
+    { 1215.108032f, -65.715767f, 70.084267f, -3.124123f},
+    { 1338.859253f, -153.327316f, 30.895077f, -2.530723f},
+    { 1309.192017f, 9.416233f, 30.893402f, 1.518436f},
+    // Portal
+    {1468.380005f, -225.798996f, 30.896200f, 0.0f}, //blue
+    {1394.270020f, 72.551399f, 31.054300f, 0.0f}, //green
+    {1065.260010f, -89.79501f, 81.073402f, 0.0f}, //yellow
+    {1216.069946f, 47.904301f, 54.278198f, 0.0f}, //purple
+    {1255.569946f, -233.548996f, 56.43699f, 0.0f}, //red
+    // Bombs
+    {1333.45f, 211.354f, 31.0538f, 5.03666f},
+    {1334.29f, 209.582f, 31.0532f, 1.28088f},
+    {1332.72f, 210.049f, 31.0532f, 1.28088f},
+    {1334.28f, 210.78f, 31.0538f, 3.85856f},
+    {1332.64f, 211.39f, 31.0532f, 1.29266f},
+    {1371.41f, 194.028f, 31.5107f, 0.753095f},
+    {1372.39f, 194.951f, 31.4679f, 0.753095f},
+    {1371.58f, 196.942f, 30.9349f, 1.01777f},
+    {1370.43f, 196.614f, 30.9349f, 0.957299f},
+    {1369.46f, 196.877f, 30.9351f, 2.45348f},
+    {1370.35f, 197.361f, 30.9349f, 1.08689f},
+    {1369.47f, 197.941f, 30.9349f, 0.984787f},
+    {1592.49f, 47.5969f, 7.52271f, 4.63218f},
+    {1593.91f, 47.8036f, 7.65856f, 4.63218f},
+    {1593.13f, 46.8106f, 7.54073f, 4.63218f},
+    {1589.22f, 36.3616f, 7.45975f, 4.64396f},
+    {1588.24f, 35.5842f, 7.55613f, 4.79564f},
+    {1588.14f, 36.7611f, 7.49675f, 4.79564f},
+    {1595.74f, 35.5278f, 7.46602f, 4.90246f},
+    {1596, 36.6475f, 7.47991f, 4.90246f},
+    {1597.03f, 36.2356f, 7.48631f, 4.90246f},
+    {1597.93f, 37.1214f, 7.51725f, 4.90246f},
+    {1598.16f, 35.888f, 7.50018f, 4.90246f},
+    {1579.6f, -98.0917f, 8.48478f, 1.37996f},
+    {1581.2f, -98.401f, 8.47483f, 1.37996f},
+    {1580.38f, -98.9556f, 8.4772f, 1.38781f},
+    {1585.68f, -104.966f, 8.88551f, 0.493246f},
+    {1586.15f, -106.033f, 9.10616f, 0.493246f},
+    {1584.88f, -105.394f, 8.82985f, 0.493246f},
+    {1581.87f, -100.899f, 8.46164f, 0.929142f},
+    {1581.48f, -99.4657f, 8.46926f, 0.929142f},
+    {1583.2f, -91.2291f, 8.49227f, 1.40038f},
+    {1581.94f, -91.0119f, 8.49977f, 1.40038f},
+    {1582.33f, -91.951f, 8.49353f, 1.1844f},
+    {1342.06f, -304.049f, 30.9532f, 5.59507f},
+    {1340.96f, -304.536f, 30.9458f, 1.28323f},
+    {1341.22f, -303.316f, 30.9413f, 0.486051f},
+    {1342.22f, -302.939f, 30.986f, 4.87643f},
+    {1382.16f, -287.466f, 32.3063f, 4.80968f},
+    {1381, -287.58f, 32.2805f, 4.80968f},
+    {1381.55f, -286.536f, 32.3929f, 2.84225f},
+    {1382.75f, -286.354f, 32.4099f, 1.00442f},
+    {1379.92f, -287.34f, 32.2872f, 3.81615f},
+    {1100.52f, -2.41391f, 70.2984f, 0.131054f},
+    {1099.35f, -2.13851f, 70.3375f, 4.4586f},
+    {1099.59f, -1.00329f, 70.238f, 2.49903f},
+    {1097.79f, 0.571316f, 70.159f, 4.00307f},
+    {1098.74f, -7.23252f, 70.7972f, 4.1523f},
+    {1098.46f, -5.91443f, 70.6715f, 4.1523f},
+    {1097.53f, -7.39704f, 70.7959f, 4.1523f},
+    {1097.32f, -6.64233f, 70.7424f, 4.1523f},
+    {1096.45f, -5.96664f, 70.7242f, 4.1523f},
+    {971.725f, 0.496763f, 86.8467f, 2.09233f},
+    {973.589f, 0.119518f, 86.7985f, 3.17225f},
+    {972.524f, 1.25333f, 86.8351f, 5.28497f},
+    {971.993f, 2.05668f, 86.8584f, 5.28497f},
+    {973.635f, 2.11805f, 86.8197f, 2.36722f},
+    {974.791f, 1.74679f, 86.7942f, 1.5936f},
+    {974.771f, 3.0445f, 86.8125f, 0.647199f},
+    {979.554f, 3.6037f, 86.7923f, 1.69178f},
+    {979.758f, 2.57519f, 86.7748f, 1.76639f},
+    {980.769f, 3.48904f, 86.7939f, 1.76639f},
+    {979.122f, 2.87109f, 86.7794f, 1.76639f},
+    {986.167f, 4.85363f, 86.8439f, 1.5779f},
+    {986.176f, 3.50367f, 86.8217f, 1.5779f},
+    {987.33f, 4.67389f, 86.8486f, 1.5779f},
+    {985.23f, 4.65898f, 86.8368f, 1.5779f},
+    {984.556f, 3.54097f, 86.8137f, 1.5779f},
+};
+
+/* Ships:
+ * 193182 - ally
+ * 193183 - horde
+ * 193184 - horde
+ * 193185 - ally
+ * Banners:
+ * 191308 - left one,
+ * 191306 - right one,
+ * 191310 - central,
+ * Ally ones, substract 1
+ * to get horde ones.
+ */
+
+uint32 const BG_SA_ObjEntries[BG_SA_MAXOBJ + BG_SA_FLAG_AMOUNT] =
+{
+    190722,
+    190727,
+    190724,
+    190726,
+    190723,
+    192549,
+    192834,
+    0, // Boat
+    0, // Boat
+    192687,
+    192685,
+    192689,
+    192690,
+    192691,
+    191311,
+    191311,
+    191311,
+    191310,
+    191306,
+    191308,
+    192819,
+    192819,
+    192819,
+    192819,
+    192819,
+    190753
+};
+
+uint32 const BG_SA_Factions[2] =
+{
+    1732,
+    1735,
+};
+
+enum BG_SA_Graveyards
+{
+    BG_SA_BEACH_GY = 0,
+    BG_SA_DEFENDER_LAST_GY,
+    BG_SA_RIGHT_CAPTURABLE_GY,
+    BG_SA_LEFT_CAPTURABLE_GY,
+    BG_SA_CENTRAL_CAPTURABLE_GY,
+    BG_SA_MAX_GY
+};
+
+const uint32 BG_SA_GYEntries[BG_SA_MAX_GY] =
+{
+    1350,
+    1349,
+    1347,
+    1346,
+    1348,
+};
+
+float const BG_SA_GYOrientation[BG_SA_MAX_GY] =
+{
+    6.202f,
+    1.926f, // right capturable GY
+    3.917f, // left capturable GY
+    3.104f, // center, capturable
+    6.148f, // defender last GY
+};
+
+struct BG_SA_RoundScore
+{
+    TeamId winner;
+    uint32 time;
+};
+
+const float SOTADefPortalDest[5][4] = {
+    { 1388.94f, 103.067f, 34.49f, 5.4571f },
+    { 1043.69f, -87.95f, 87.12f, 0.003f },
+    { 1441.0411f, -240.974f, 35.264f, 0.949f },
+    { 1228.342f, -235.234f, 60.03f, 0.4584f },
+    { 1193.857f, 69.9f, 58.046f, 5.7245f },
+};
+
+/// Class for manage Strand of Ancient battleground
+class BattlegroundSA : public Battleground
+{
+    public:
+        BattlegroundSA();
+        ~BattlegroundSA();
+
+        /**
+         * \brief Called every time for update battle data
+         * -Update timer
+         * -Round switch
+         */
+        void PostUpdateImpl(uint32 diff);
+
+        /* inherited from BattlegroundClass */
+        /// Called when a player join battle
+        void AddPlayer(Player* player);
+        /// Called when battle start
+        void StartingEventCloseDoors();
+        void StartingEventOpenDoors();
+        /// Called for ini battleground, after that the first player be entered
+        bool SetupBattleground();
+        void Init();
+        /// Called for generate packet contain worldstate data
+        void FillInitialWorldStates(WorldPacket& data);
+        /// Called when a player deal damage to building (door)
+        void EventPlayerDamagedGO(Player* player, GameObject* go, uint32 eventType);
+        /// Called when a player kill a unit in bg
+        void HandleKillUnit(Creature* creature, Player* killer);
+        /// Return the nearest graveyard where player can respawn
+        WorldSafeLocsEntry const* GetClosestGraveyard(Player* player);
+        /// Called when a player click on flag (graveyard flag)
+        void EventPlayerClickedOnFlag(Player* Source, GameObject* gameObject);
+        /// Called when a player use a gamobject (relic)
+        void EventPlayerUsedGO(Player* Source, GameObject* object);
+       
+        /// Return worldstate id, according to door id
+        uint32 GetWorldStateFromGateID(uint32 id)
+        {
+            uint32 uws = 0;
+            switch (id)
+            {
+                case BG_SA_GREEN_GATE:   uws = BG_SA_GREEN_GATEWS;   break;
+                case BG_SA_YELLOW_GATE:  uws = BG_SA_YELLOW_GATEWS;  break;
+                case BG_SA_BLUE_GATE:    uws = BG_SA_BLUE_GATEWS;    break;
+                case BG_SA_RED_GATE:     uws = BG_SA_RED_GATEWS;     break;
+                case BG_SA_PURPLE_GATE:  uws = BG_SA_PURPLE_GATEWS;  break;
+                case BG_SA_ANCIENT_GATE: uws = BG_SA_ANCIENT_GATEWS; break;
+            }
+            return uws;
+        }
+
+        /// Called on battleground ending
+        void EndBattleground(TeamId winnerTeamId);
+
+        /// CAlled when a player leave battleground
+        void RemovePlayer(Player* player);
+        void HandleAreaTrigger(Player* player, uint32 trigger);
+
+        /* Scorekeeping */
+        /// Update score board
+        void UpdatePlayerScore(Player* player, uint32 type, uint32 value, bool doAddHonor = true);
+
+		// Teleporters
+		void DefendersPortalTeleport(GameObject* portal, Player* plr);
+
+		// Achievements
+		bool AllowDefenseOfTheAncients(Player* source);
+
+        // Achievement: Not Even a Scratch
+        bool notEvenAScratch(TeamId teamId) const { return _notEvenAScratch[teamId]; }
+
+    private:
+
+		/// Return gate id, relative to bg data, according to gameobject id
+        uint32 GetGateIDFromEntry(uint32 id)
+        {
+            uint32 i = 0;
+            switch(id)
+            {
+                case 190722: i = BG_SA_GREEN_GATE;   break; //Green gate destroyed
+                case 190724: i = BG_SA_BLUE_GATE;    break; //blue gate
+                case 190726: i = BG_SA_RED_GATE;     break; //red gate
+                case 190723: i = BG_SA_PURPLE_GATE;  break; //purple gate
+                case 190727: i = BG_SA_YELLOW_GATE;  break; //yellow gate
+                case 192549: i = BG_SA_ANCIENT_GATE; break; //ancient gate
+            }
+            return i;
+        }
+        /**
+         * \brief Called on setup and between the two round
+         * -Delete all gameobject / creature
+         * -Respawn all gameobject / creature to have good faction
+         */
+        bool ResetObjs();
+        /// Called for start ship movement
+        void StartShips();
+        /**
+         * \brief Called between the two round
+         * -Teleport all players to good location
+         */
+        void TeleportPlayers();
+        void TeleportToEntrancePosition(Player* player);
+        /**
+         * \brief Called on start and between the two round
+         * -Update faction of all vehicle
+         */
+        void OverrideGunFaction();
+        /// Set selectable or not demolisher, called on battle start, when boats arrive to dock
+        void DemolisherStartState(bool start);
+        /// Checks if a player can interact with the given object
+        bool CanInteractWithObject(uint32 objectId);
+        /// Updates interaction flags of specific objects
+        void UpdateObjectInteractionFlags(uint32 objectId);
+        void UpdateObjectInteractionFlags();
+        /**
+         * \brief Called when a gate is destroy
+         * -Give honor to player witch destroy it
+         * -Update worldstate
+         * -Delete gameobject in front of door (lighting object, with different colours for each door)
+         */
+        void DestroyGate(Player* player, GameObject* go);
+        /// Update timer worldstate
+        void SendTime();
+        /**
+         * \brief Called when a graveyard is capture
+         * -Update spiritguide
+         * -Update gameobject (flag)
+         * -Update Worldstate
+         * -Send warning for announce this
+         * \param i : id of graveyard
+         * \param Source : Player who capture gy
+         */
+        void CaptureGraveyard(BG_SA_Graveyards i, Player* Source);
+        /// Switch on/off timer worldstate
+        void ToggleTimer();
+
+        /// Respawn dead demolisher
+        void UpdateDemolisherSpawns();
+
+        /// Send packet to player for create boats (client part)
+        void SendTransportInit(Player* player);
+        /// Send packet to player for destroy boats (client part)
+        void SendTransportsRemove(Player* player);
+
+        /// Id of attacker team
+        TeamId Attackers;
+        /// Totale elapsed time of current round
+        uint32 TotalTime;
+        /// Max time of round
+        uint32 EndRoundTimer;
+        /// For know if boats has start moving or not yet
+        bool ShipsStarted;
+        /// Status of each gate (Destroy/Damage/Intact)
+        BG_SA_GateState GateStatus[6];
+        /// Statu of battle (Start or not, and what round)
+        BG_SA_Status Status;
+        /// Team witch conntrol each graveyard
+        TeamId GraveyardStatus[BG_SA_MAX_GY];
+        /// Score of each round
+        BG_SA_RoundScore RoundScores[2];
+        /// used for know we are in timer phase or not (used for worldstate update)
+        bool TimerEnabled;
+        /// 5secs before starting the 1min countdown for second round
+        uint32 UpdateWaitTimer;
+        /// for know if warning about second round start has been sent
+        bool SignaledRoundTwo;
+        /// for know if warning about second round start has been sent
+        bool SignaledRoundTwoHalfMin;
+        /// for know if second round has been init
+        bool InitSecondRound;
+        std::map<uint32/*id*/, uint32/*timer*/> DemoliserRespawnList;
+
+		// xinef:
+		bool _relicClicked;
+
+        // Achievement: Not Even a Scratch
+        bool _notEvenAScratch[BG_TEAMS_COUNT];
+};
+#endif

src/server/game/Battlegrounds/Zones/BattlegroundWS.cpp

@@ -0,0 +1,551 @@
+/*
+REWRITTEN BY XINEF
+*/
+
+#include "BattlegroundWS.h"
+#include "Creature.h"
+#include "GameObject.h"
+#include "Language.h"
+#include "Object.h"
+#include "ObjectMgr.h"
+#include "BattlegroundMgr.h"
+#include "Player.h"
+#include "World.h"
+#include "WorldPacket.h"
+
+BattlegroundWS::BattlegroundWS()
+{
+    BgObjects.resize(BG_WS_OBJECT_MAX);
+    BgCreatures.resize(BG_CREATURES_MAX_WS);
+
+    StartMessageIds[BG_STARTING_EVENT_FIRST]  = LANG_BG_WS_START_TWO_MINUTES;
+    StartMessageIds[BG_STARTING_EVENT_SECOND] = LANG_BG_WS_START_ONE_MINUTE;
+    StartMessageIds[BG_STARTING_EVENT_THIRD]  = LANG_BG_WS_START_HALF_MINUTE;
+    StartMessageIds[BG_STARTING_EVENT_FOURTH] = LANG_BG_WS_HAS_BEGUN;
+
+    _flagKeepers[TEAM_ALLIANCE] = 0;
+    _flagKeepers[TEAM_HORDE] = 0;
+    _droppedFlagGUID[TEAM_ALLIANCE] = 0;
+    _droppedFlagGUID[TEAM_HORDE] = 0;
+    _flagState[TEAM_ALLIANCE] = BG_WS_FLAG_STATE_ON_BASE;
+    _flagState[TEAM_HORDE] = BG_WS_FLAG_STATE_ON_BASE;
+    _lastFlagCaptureTeam = TEAM_NEUTRAL;
+    _reputationCapture = 0;
+    _honorWinKills = 0;
+    _honorEndKills = 0;
+}
+
+BattlegroundWS::~BattlegroundWS()
+{
+}
+
+void BattlegroundWS::PostUpdateImpl(uint32 diff)
+{
+    if (GetStatus() == STATUS_IN_PROGRESS)
+    {
+		_bgEvents.Update(diff);
+		switch (_bgEvents.ExecuteEvent())
+		{
+			case BG_WS_EVENT_UPDATE_GAME_TIME:
+				UpdateWorldState(BG_WS_STATE_TIMER, GetMatchTime());
+				_bgEvents.ScheduleEvent(BG_WS_EVENT_UPDATE_GAME_TIME, ((BG_WS_TOTAL_GAME_TIME - GetStartTime()) % (MINUTE*IN_MILLISECONDS)) + 1);
+				break;
+			case BG_WS_EVENT_NO_TIME_LEFT:
+				if (GetTeamScore(TEAM_ALLIANCE) == GetTeamScore(TEAM_HORDE))
+					EndBattleground(_lastFlagCaptureTeam);
+				else
+					EndBattleground(GetTeamScore(TEAM_HORDE) > GetTeamScore(TEAM_ALLIANCE) ? TEAM_HORDE : TEAM_ALLIANCE);
+				break;
+			case BG_WS_EVENT_RESPAWN_BOTH_FLAGS:
+                SpawnBGObject(BG_WS_OBJECT_H_FLAG, RESPAWN_IMMEDIATELY);
+				SpawnBGObject(BG_WS_OBJECT_A_FLAG, RESPAWN_IMMEDIATELY);
+				SendMessageToAll(LANG_BG_WS_F_PLACED, CHAT_MSG_BG_SYSTEM_NEUTRAL);
+				PlaySoundToAll(BG_WS_SOUND_FLAGS_RESPAWNED);
+				break;
+			case BG_WS_EVENT_ALLIANCE_DROP_FLAG:
+                RespawnFlagAfterDrop(TEAM_ALLIANCE);
+				break;
+			case BG_WS_EVENT_HORDE_DROP_FLAG:
+                RespawnFlagAfterDrop(TEAM_HORDE);
+				break;
+			case BG_WS_EVENT_BOTH_FLAGS_KEPT10:
+                if (Player* player = ObjectAccessor::GetObjectInMap(GetFlagPickerGUID(TEAM_ALLIANCE), this->FindBgMap(), (Player*)NULL))
+                    player->CastSpell(player, BG_WS_SPELL_FOCUSED_ASSAULT, true);
+                if (Player* player = ObjectAccessor::GetObjectInMap(GetFlagPickerGUID(TEAM_HORDE), this->FindBgMap(), (Player*)NULL))
+                    player->CastSpell(player, BG_WS_SPELL_FOCUSED_ASSAULT, true);
+				break;
+			case BG_WS_EVENT_BOTH_FLAGS_KEPT15:
+				if (Player* player = ObjectAccessor::GetObjectInMap(GetFlagPickerGUID(TEAM_ALLIANCE), this->FindBgMap(), (Player*)NULL))
+				{
+					player->RemoveAurasDueToSpell(BG_WS_SPELL_FOCUSED_ASSAULT);
+                    player->CastSpell(player, BG_WS_SPELL_BRUTAL_ASSAULT, true);
+				}
+                if (Player* player = ObjectAccessor::GetObjectInMap(GetFlagPickerGUID(TEAM_HORDE), this->FindBgMap(), (Player*)NULL))
+				{
+					player->RemoveAurasDueToSpell(BG_WS_SPELL_FOCUSED_ASSAULT);
+                    player->CastSpell(player, BG_WS_SPELL_BRUTAL_ASSAULT, true);
+				}
+				break;
+        }
+    }
+}
+
+void BattlegroundWS::StartingEventCloseDoors()
+{
+    for (uint32 i = BG_WS_OBJECT_DOOR_A_1; i <= BG_WS_OBJECT_DOOR_H_4; ++i)
+    {
+        DoorClose(i);
+        SpawnBGObject(i, RESPAWN_IMMEDIATELY);
+    }
+    for (uint32 i = BG_WS_OBJECT_A_FLAG; i <= BG_WS_OBJECT_BERSERKBUFF_2; ++i)
+        SpawnBGObject(i, RESPAWN_ONE_DAY);
+}
+
+void BattlegroundWS::StartingEventOpenDoors()
+{
+    for (uint32 i = BG_WS_OBJECT_DOOR_A_1; i <= BG_WS_OBJECT_DOOR_A_6; ++i)
+        DoorOpen(i);
+    for (uint32 i = BG_WS_OBJECT_DOOR_H_1; i <= BG_WS_OBJECT_DOOR_H_4; ++i)
+        DoorOpen(i);
+
+    for (uint32 i = BG_WS_OBJECT_A_FLAG; i <= BG_WS_OBJECT_BERSERKBUFF_2; ++i)
+        SpawnBGObject(i, RESPAWN_IMMEDIATELY);
+
+    SpawnBGObject(BG_WS_OBJECT_DOOR_A_5, RESPAWN_ONE_DAY);
+    SpawnBGObject(BG_WS_OBJECT_DOOR_A_6, RESPAWN_ONE_DAY);
+    SpawnBGObject(BG_WS_OBJECT_DOOR_H_3, RESPAWN_ONE_DAY);
+    SpawnBGObject(BG_WS_OBJECT_DOOR_H_4, RESPAWN_ONE_DAY);
+
+    StartTimedAchievement(ACHIEVEMENT_TIMED_TYPE_EVENT, WS_EVENT_START_BATTLE);
+	UpdateWorldState(BG_WS_STATE_TIMER_ACTIVE, 1);
+	_bgEvents.ScheduleEvent(BG_WS_EVENT_UPDATE_GAME_TIME, 0);
+	_bgEvents.ScheduleEvent(BG_WS_EVENT_NO_TIME_LEFT, BG_WS_TOTAL_GAME_TIME - 2*MINUTE*IN_MILLISECONDS); // 27 - 2 = 25 minutes
+}
+
+void BattlegroundWS::AddPlayer(Player* player)
+{
+    Battleground::AddPlayer(player);
+    PlayerScores[player->GetGUID()] = new BattlegroundWGScore(player);
+}
+
+void BattlegroundWS::RespawnFlagAfterDrop(TeamId teamId)
+{
+    if (GetStatus() != STATUS_IN_PROGRESS || GetFlagState(teamId) != BG_WS_FLAG_STATE_ON_GROUND)
+        return;
+
+	UpdateFlagState(teamId, BG_WS_FLAG_STATE_ON_BASE);
+	SpawnBGObject(teamId == TEAM_ALLIANCE ? BG_WS_OBJECT_A_FLAG : BG_WS_OBJECT_H_FLAG, RESPAWN_IMMEDIATELY);
+	SendMessageToAll(teamId == TEAM_ALLIANCE ? LANG_BG_WS_ALLIANCE_FLAG_RESPAWNED : LANG_BG_WS_HORDE_FLAG_RESPAWNED, CHAT_MSG_BG_SYSTEM_NEUTRAL);
+    PlaySoundToAll(BG_WS_SOUND_FLAGS_RESPAWNED);
+
+    if (GameObject* flag = GetBgMap()->GetGameObject(GetDroppedFlagGUID(teamId)))
+        flag->Delete();
+
+    SetDroppedFlagGUID(0, teamId);
+	_bgEvents.CancelEvent(BG_WS_EVENT_BOTH_FLAGS_KEPT10);
+	_bgEvents.CancelEvent(BG_WS_EVENT_BOTH_FLAGS_KEPT15);
+	RemoveAssaultAuras();
+}
+
+void BattlegroundWS::EventPlayerCapturedFlag(Player* player)
+{
+    if (GetStatus() != STATUS_IN_PROGRESS)
+        return;
+
+    player->RemoveAurasWithInterruptFlags(AURA_INTERRUPT_FLAG_ENTER_PVP_COMBAT);
+	RemoveAssaultAuras();
+
+    AddPoints(player->GetTeamId(), 1);
+	SetFlagPicker(0, GetOtherTeamId(player->GetTeamId()));
+	UpdateFlagState(GetOtherTeamId(player->GetTeamId()), BG_WS_FLAG_STATE_ON_BASE);
+    if (player->GetTeamId() == TEAM_ALLIANCE)
+    {
+        player->RemoveAurasDueToSpell(BG_WS_SPELL_WARSONG_FLAG);
+        PlaySoundToAll(BG_WS_SOUND_FLAG_CAPTURED_ALLIANCE);
+        SendMessageToAll(LANG_BG_WS_CAPTURED_HF, CHAT_MSG_BG_SYSTEM_ALLIANCE, player);
+        RewardReputationToTeam(890, _reputationCapture, TEAM_ALLIANCE);
+    }
+    else
+    {
+        player->RemoveAurasDueToSpell(BG_WS_SPELL_SILVERWING_FLAG);
+        PlaySoundToAll(BG_WS_SOUND_FLAG_CAPTURED_HORDE);
+        SendMessageToAll(LANG_BG_WS_CAPTURED_AF, CHAT_MSG_BG_SYSTEM_HORDE, player);
+        RewardReputationToTeam(889, _reputationCapture, TEAM_HORDE);
+    }
+
+    SpawnBGObject(BG_WS_OBJECT_H_FLAG, BG_WS_FLAG_RESPAWN_TIME);
+    SpawnBGObject(BG_WS_OBJECT_A_FLAG, BG_WS_FLAG_RESPAWN_TIME);
+
+	UpdateWorldState(player->GetTeamId() == TEAM_ALLIANCE ? BG_WS_FLAG_CAPTURES_ALLIANCE : BG_WS_FLAG_CAPTURES_HORDE, GetTeamScore(player->GetTeamId()));
+    UpdatePlayerScore(player, SCORE_FLAG_CAPTURES, 1);      // +1 flag captures
+	_lastFlagCaptureTeam = player->GetTeamId();
+
+    RewardHonorToTeam(GetBonusHonorFromKill(2), player->GetTeamId());
+
+    if (GetTeamScore(TEAM_ALLIANCE) == BG_WS_MAX_TEAM_SCORE || GetTeamScore(TEAM_HORDE) == BG_WS_MAX_TEAM_SCORE)
+    {
+        UpdateWorldState(BG_WS_STATE_TIMER_ACTIVE, 0);
+		EndBattleground(GetTeamScore(TEAM_HORDE) == BG_WS_MAX_TEAM_SCORE ? TEAM_HORDE : TEAM_ALLIANCE);
+    }
+    else
+		_bgEvents.ScheduleEvent(BG_WS_EVENT_RESPAWN_BOTH_FLAGS, BG_WS_FLAG_RESPAWN_TIME);
+
+	_bgEvents.CancelEvent(BG_WS_EVENT_BOTH_FLAGS_KEPT10);
+	_bgEvents.CancelEvent(BG_WS_EVENT_BOTH_FLAGS_KEPT15);
+}
+
+void BattlegroundWS::EventPlayerDroppedFlag(Player* player)
+{
+	if (GetFlagPickerGUID(TEAM_HORDE) != player->GetGUID() && GetFlagPickerGUID(TEAM_ALLIANCE) != player->GetGUID())
+		return;
+
+	SetFlagPicker(0, GetOtherTeamId(player->GetTeamId()));
+    player->RemoveAurasDueToSpell(BG_WS_SPELL_WARSONG_FLAG);
+    player->RemoveAurasDueToSpell(BG_WS_SPELL_FOCUSED_ASSAULT);
+    player->RemoveAurasDueToSpell(BG_WS_SPELL_BRUTAL_ASSAULT);
+
+    if (GetStatus() != STATUS_IN_PROGRESS)
+        return;
+
+    player->CastSpell(player, SPELL_RECENTLY_DROPPED_FLAG, true);
+    if (player->GetTeamId() == TEAM_ALLIANCE)
+    {
+		UpdateFlagState(TEAM_HORDE, BG_WS_FLAG_STATE_ON_GROUND);
+        player->CastSpell(player, BG_WS_SPELL_WARSONG_FLAG_DROPPED, true);
+        SendMessageToAll(LANG_BG_WS_DROPPED_HF, CHAT_MSG_BG_SYSTEM_HORDE, player);
+		_bgEvents.RescheduleEvent(BG_WS_EVENT_HORDE_DROP_FLAG, BG_WS_FLAG_DROP_TIME);
+    }
+    else
+    {
+		UpdateFlagState(TEAM_ALLIANCE, BG_WS_FLAG_STATE_ON_GROUND);
+        player->CastSpell(player, BG_WS_SPELL_SILVERWING_FLAG_DROPPED, true);
+        SendMessageToAll(LANG_BG_WS_DROPPED_AF, CHAT_MSG_BG_SYSTEM_ALLIANCE, player);
+		_bgEvents.RescheduleEvent(BG_WS_EVENT_ALLIANCE_DROP_FLAG, BG_WS_FLAG_DROP_TIME);
+    }
+}
+
+void BattlegroundWS::EventPlayerClickedOnFlag(Player* player, GameObject* gameObject)
+{
+    if (GetStatus() != STATUS_IN_PROGRESS)
+        return;
+
+    int32 message_id = 0;
+    ChatMsg type = CHAT_MSG_BG_SYSTEM_NEUTRAL;
+    player->RemoveAurasWithInterruptFlags(AURA_INTERRUPT_FLAG_ENTER_PVP_COMBAT);
+
+    // Alliance Flag picked up from base
+    if (player->GetTeamId() == TEAM_HORDE && GetFlagState(TEAM_ALLIANCE) == BG_WS_FLAG_STATE_ON_BASE && BgObjects[BG_WS_OBJECT_A_FLAG] == gameObject->GetGUID())
+    {
+        SpawnBGObject(BG_WS_OBJECT_A_FLAG, RESPAWN_ONE_DAY);
+        SetFlagPicker(player->GetGUID(), TEAM_ALLIANCE);
+        UpdateFlagState(TEAM_ALLIANCE, BG_WS_FLAG_STATE_ON_PLAYER);
+        player->CastSpell(player, BG_WS_SPELL_SILVERWING_FLAG, true);
+        player->StartTimedAchievement(ACHIEVEMENT_TIMED_TYPE_SPELL_TARGET, BG_WS_SPELL_SILVERWING_FLAG_PICKED);
+
+        PlaySoundToAll(BG_WS_SOUND_ALLIANCE_FLAG_PICKED_UP);
+		SendMessageToAll(LANG_BG_WS_PICKEDUP_AF, CHAT_MSG_BG_SYSTEM_HORDE, player);
+
+		if (GetFlagState(TEAM_HORDE) != BG_WS_FLAG_STATE_ON_BASE)
+		{
+			_bgEvents.RescheduleEvent(BG_WS_EVENT_BOTH_FLAGS_KEPT10, BG_WS_SPELL_FORCE_TIME);
+			_bgEvents.RescheduleEvent(BG_WS_EVENT_BOTH_FLAGS_KEPT15, BG_WS_SPELL_BRUTAL_TIME);
+		}
+		return;
+    }
+
+    // Horde Flag picked up from base
+    if (player->GetTeamId() == TEAM_ALLIANCE && GetFlagState(TEAM_HORDE) == BG_WS_FLAG_STATE_ON_BASE && BgObjects[BG_WS_OBJECT_H_FLAG] == gameObject->GetGUID())
+    {
+        SpawnBGObject(BG_WS_OBJECT_H_FLAG, RESPAWN_ONE_DAY);
+        SetFlagPicker(player->GetGUID(), TEAM_HORDE);
+        UpdateFlagState(TEAM_HORDE, BG_WS_FLAG_STATE_ON_PLAYER);
+        player->CastSpell(player, BG_WS_SPELL_WARSONG_FLAG, true);
+        player->StartTimedAchievement(ACHIEVEMENT_TIMED_TYPE_SPELL_TARGET, BG_WS_SPELL_WARSONG_FLAG_PICKED);
+
+        PlaySoundToAll(BG_WS_SOUND_HORDE_FLAG_PICKED_UP);
+		SendMessageToAll(LANG_BG_WS_PICKEDUP_HF, CHAT_MSG_BG_SYSTEM_ALLIANCE, player);
+
+		if (GetFlagState(TEAM_ALLIANCE) != BG_WS_FLAG_STATE_ON_BASE)
+		{
+			_bgEvents.RescheduleEvent(BG_WS_EVENT_BOTH_FLAGS_KEPT10, BG_WS_SPELL_FORCE_TIME);
+			_bgEvents.RescheduleEvent(BG_WS_EVENT_BOTH_FLAGS_KEPT15, BG_WS_SPELL_BRUTAL_TIME);
+		}
+		return;
+    }
+
+    // Alliance Flag on ground
+    if (GetFlagState(TEAM_ALLIANCE) == BG_WS_FLAG_STATE_ON_GROUND && player->IsWithinDistInMap(gameObject, 10.0f) && gameObject->GetEntry() == BG_OBJECT_A_FLAG_GROUND_WS_ENTRY)
+    {
+		SetDroppedFlagGUID(0, TEAM_ALLIANCE);
+        if (player->GetTeamId() == TEAM_ALLIANCE)
+        {
+            UpdateFlagState(TEAM_ALLIANCE, BG_WS_FLAG_STATE_ON_BASE);
+            SpawnBGObject(BG_WS_OBJECT_A_FLAG, RESPAWN_IMMEDIATELY);
+            UpdatePlayerScore(player, SCORE_FLAG_RETURNS, 1);
+
+			PlaySoundToAll(BG_WS_SOUND_FLAG_RETURNED);
+			SendMessageToAll(LANG_BG_WS_RETURNED_AF, CHAT_MSG_BG_SYSTEM_ALLIANCE, player);
+			_bgEvents.CancelEvent(BG_WS_EVENT_BOTH_FLAGS_KEPT10);
+			_bgEvents.CancelEvent(BG_WS_EVENT_BOTH_FLAGS_KEPT15);
+			RemoveAssaultAuras();
+			return;
+        }
+        else
+        {
+			SetFlagPicker(player->GetGUID(), TEAM_ALLIANCE);
+            UpdateFlagState(TEAM_ALLIANCE, BG_WS_FLAG_STATE_ON_PLAYER);
+            player->CastSpell(player, BG_WS_SPELL_SILVERWING_FLAG, true);
+			if (uint32 assaultSpellId = GetAssaultSpellId())
+              player->CastSpell(player, assaultSpellId, true);
+
+			PlaySoundToAll(BG_WS_SOUND_ALLIANCE_FLAG_PICKED_UP);
+			SendMessageToAll(LANG_BG_WS_PICKEDUP_AF, CHAT_MSG_BG_SYSTEM_HORDE, player);
+			return;
+        }
+    }
+
+    // Horde Flag on ground
+    if (GetFlagState(TEAM_HORDE) == BG_WS_FLAG_STATE_ON_GROUND && player->IsWithinDistInMap(gameObject, 10.0f) && gameObject->GetEntry() == BG_OBJECT_H_FLAG_GROUND_WS_ENTRY)
+    {
+		SetDroppedFlagGUID(0, TEAM_HORDE);
+        if (player->GetTeamId() == TEAM_HORDE)
+        {
+            UpdateFlagState(TEAM_HORDE, BG_WS_FLAG_STATE_ON_BASE);
+            SpawnBGObject(BG_WS_OBJECT_H_FLAG, RESPAWN_IMMEDIATELY);
+            UpdatePlayerScore(player, SCORE_FLAG_RETURNS, 1);
+
+			PlaySoundToAll(BG_WS_SOUND_FLAG_RETURNED);
+			SendMessageToAll(LANG_BG_WS_RETURNED_HF, CHAT_MSG_BG_SYSTEM_HORDE, player);
+			_bgEvents.CancelEvent(BG_WS_EVENT_BOTH_FLAGS_KEPT10);
+			_bgEvents.CancelEvent(BG_WS_EVENT_BOTH_FLAGS_KEPT15);
+			RemoveAssaultAuras();
+			return;
+        }
+        else
+        {
+			SetFlagPicker(player->GetGUID(), TEAM_HORDE);
+            UpdateFlagState(TEAM_HORDE, BG_WS_FLAG_STATE_ON_PLAYER);
+            player->CastSpell(player, BG_WS_SPELL_WARSONG_FLAG, true);
+			if (uint32 assaultSpellId = GetAssaultSpellId())
+              player->CastSpell(player, assaultSpellId, true);
+
+			PlaySoundToAll(BG_WS_SOUND_HORDE_FLAG_PICKED_UP);
+			SendMessageToAll(LANG_BG_WS_PICKEDUP_HF, CHAT_MSG_BG_SYSTEM_ALLIANCE, player);
+			return;
+        }
+    }
+}
+
+void BattlegroundWS::RemovePlayer(Player* player)
+{
+    if (GetFlagPickerGUID(TEAM_ALLIANCE) == player->GetGUID() || GetFlagPickerGUID(TEAM_HORDE) == player->GetGUID())
+        EventPlayerDroppedFlag(player);
+}
+
+void BattlegroundWS::UpdateFlagState(TeamId teamId, uint32 value)
+{
+	_flagState[teamId] = value;
+	UpdateWorldState(teamId == TEAM_ALLIANCE ? BG_WS_FLAG_STATE_HORDE : BG_WS_FLAG_STATE_ALLIANCE, value);
+}
+
+void BattlegroundWS::HandleAreaTrigger(Player* player, uint32 trigger)
+{
+    if (GetStatus() != STATUS_IN_PROGRESS || !player->IsAlive())
+        return;
+
+    switch (trigger)
+    {
+        case 3646: // Alliance Flag spawn
+            if (GetFlagState(TEAM_ALLIANCE) == BG_WS_FLAG_STATE_ON_BASE && GetFlagPickerGUID(TEAM_HORDE) == player->GetGUID())
+                EventPlayerCapturedFlag(player);
+            break;
+        case 3647: // Horde Flag spawn
+            if (GetFlagState(TEAM_HORDE) == BG_WS_FLAG_STATE_ON_BASE && GetFlagPickerGUID(TEAM_ALLIANCE) == player->GetGUID())
+                EventPlayerCapturedFlag(player);
+            break;
+        case 3649: // Not used
+        case 3688: // Not used
+        case 4628: // Not used
+        case 4629: // Not used
+		case 3686: // Alliance elixir of speed spawn
+        case 3687: // Horde elixir of speed spawn
+        case 3706: // Alliance elixir of regeneration spawn
+        case 3708: // Horde elixir of regeneration spawn
+        case 3707: // Alliance elixir of berserk spawn
+        case 3709: // Horde elixir of berserk spawn
+			break;
+    }
+}
+
+bool BattlegroundWS::SetupBattleground()
+{
+    // flags
+    AddObject(BG_WS_OBJECT_A_FLAG, BG_OBJECT_A_FLAG_WS_ENTRY, 1540.423f, 1481.325f, 351.8284f, 3.089233f, 0, 0, 0.9996573f, 0.02617699f, RESPAWN_IMMEDIATELY);
+    AddObject(BG_WS_OBJECT_H_FLAG, BG_OBJECT_H_FLAG_WS_ENTRY, 916.0226f, 1434.405f, 345.413f, 0.01745329f, 0, 0, 0.008726535f, 0.9999619f, RESPAWN_IMMEDIATELY);
+        // buffs
+    AddObject(BG_WS_OBJECT_SPEEDBUFF_1, BG_OBJECTID_SPEEDBUFF_ENTRY, 1449.93f, 1470.71f, 342.6346f, -1.64061f, 0, 0, 0.7313537f, -0.6819983f, BUFF_RESPAWN_TIME);
+    AddObject(BG_WS_OBJECT_SPEEDBUFF_2, BG_OBJECTID_SPEEDBUFF_ENTRY, 1005.171f, 1447.946f, 335.9032f, 1.64061f, 0, 0, 0.7313537f, 0.6819984f, BUFF_RESPAWN_TIME);
+    AddObject(BG_WS_OBJECT_REGENBUFF_1, BG_OBJECTID_REGENBUFF_ENTRY, 1317.506f, 1550.851f, 313.2344f, -0.2617996f, 0, 0, 0.1305263f, -0.9914448f, BUFF_RESPAWN_TIME);
+    AddObject(BG_WS_OBJECT_REGENBUFF_2, BG_OBJECTID_REGENBUFF_ENTRY, 1110.451f, 1353.656f, 316.5181f, -0.6806787f, 0, 0, 0.333807f, -0.9426414f, BUFF_RESPAWN_TIME);
+    AddObject(BG_WS_OBJECT_BERSERKBUFF_1, BG_OBJECTID_BERSERKERBUFF_ENTRY, 1320.09f, 1378.79f, 314.7532f, 1.186824f, 0, 0, 0.5591929f, 0.8290376f, BUFF_RESPAWN_TIME);
+    AddObject(BG_WS_OBJECT_BERSERKBUFF_2, BG_OBJECTID_BERSERKERBUFF_ENTRY, 1139.688f, 1560.288f, 306.8432f, -2.443461f, 0, 0, 0.9396926f, -0.3420201f, BUFF_RESPAWN_TIME);
+        // alliance gates
+    AddObject(BG_WS_OBJECT_DOOR_A_1, BG_OBJECT_DOOR_A_1_WS_ENTRY, 1503.335f, 1493.466f, 352.1888f, 3.115414f, 0, 0, 0.9999143f, 0.01308903f, RESPAWN_IMMEDIATELY);
+    AddObject(BG_WS_OBJECT_DOOR_A_2, BG_OBJECT_DOOR_A_2_WS_ENTRY, 1492.478f, 1457.912f, 342.9689f, 3.115414f, 0, 0, 0.9999143f, 0.01308903f, RESPAWN_IMMEDIATELY);
+    AddObject(BG_WS_OBJECT_DOOR_A_3, BG_OBJECT_DOOR_A_3_WS_ENTRY, 1468.503f, 1494.357f, 351.8618f, 3.115414f, 0, 0, 0.9999143f, 0.01308903f, RESPAWN_IMMEDIATELY);
+    AddObject(BG_WS_OBJECT_DOOR_A_4, BG_OBJECT_DOOR_A_4_WS_ENTRY, 1471.555f, 1458.778f, 362.6332f, 3.115414f, 0, 0, 0.9999143f, 0.01308903f, RESPAWN_IMMEDIATELY);
+    AddObject(BG_WS_OBJECT_DOOR_A_5, BG_OBJECT_DOOR_A_5_WS_ENTRY, 1492.347f, 1458.34f, 342.3712f, -0.03490669f, 0, 0, 0.01745246f, -0.9998477f, RESPAWN_IMMEDIATELY);
+    AddObject(BG_WS_OBJECT_DOOR_A_6, BG_OBJECT_DOOR_A_6_WS_ENTRY, 1503.466f, 1493.367f, 351.7352f, -0.03490669f, 0, 0, 0.01745246f, -0.9998477f, RESPAWN_IMMEDIATELY);
+        // horde gates
+    AddObject(BG_WS_OBJECT_DOOR_H_1, BG_OBJECT_DOOR_H_1_WS_ENTRY, 949.1663f, 1423.772f, 345.6241f, -0.5756807f, -0.01673368f, -0.004956111f, -0.2839723f, 0.9586737f, RESPAWN_IMMEDIATELY);
+    AddObject(BG_WS_OBJECT_DOOR_H_2, BG_OBJECT_DOOR_H_2_WS_ENTRY, 953.0507f, 1459.842f, 340.6526f, -1.99662f, -0.1971825f, 0.1575096f, -0.8239487f, 0.5073641f, RESPAWN_IMMEDIATELY);
+    AddObject(BG_WS_OBJECT_DOOR_H_3, BG_OBJECT_DOOR_H_3_WS_ENTRY, 949.9523f, 1422.751f, 344.9273f, 0.0f, 0, 0, 0, 1, RESPAWN_IMMEDIATELY);
+    AddObject(BG_WS_OBJECT_DOOR_H_4, BG_OBJECT_DOOR_H_4_WS_ENTRY, 950.7952f, 1459.583f, 342.1523f, 0.05235988f, 0, 0, 0.02617695f, 0.9996573f, RESPAWN_IMMEDIATELY);
+    
+
+    WorldSafeLocsEntry const* sg = sWorldSafeLocsStore.LookupEntry(WS_GRAVEYARD_MAIN_ALLIANCE);
+    AddSpiritGuide(WS_SPIRIT_MAIN_ALLIANCE, sg->x, sg->y, sg->z, 3.124139f, TEAM_ALLIANCE);
+
+    sg = sWorldSafeLocsStore.LookupEntry(WS_GRAVEYARD_MAIN_HORDE);
+    AddSpiritGuide(WS_SPIRIT_MAIN_HORDE, sg->x, sg->y, sg->z, 3.193953f, TEAM_HORDE);
+
+	for (uint32 i = BG_WS_OBJECT_DOOR_A_1; i < BG_WS_OBJECT_MAX; ++i)
+		if (BgObjects[i] == 0)
+		{
+			sLog->outErrorDb("BatteGroundWS: Failed to spawn some object Battleground not created!");
+			return false;
+		}
+
+	for (uint32 i = WS_SPIRIT_MAIN_ALLIANCE; i < BG_CREATURES_MAX_WS; ++i)
+		if (BgCreatures[i] == 0)
+		{
+			sLog->outErrorDb("BatteGroundWS: Failed to spawn spirit guides Battleground not created!");
+			return false;
+		}
+
+    return true;
+}
+
+void BattlegroundWS::Init()
+{
+    //call parent's class reset
+    Battleground::Init();
+
+	_bgEvents.Reset();
+    _flagKeepers[TEAM_ALLIANCE]     = 0;
+    _flagKeepers[TEAM_HORDE]        = 0;
+    _droppedFlagGUID[TEAM_ALLIANCE] = 0;
+    _droppedFlagGUID[TEAM_HORDE]    = 0;
+    _flagState[TEAM_ALLIANCE]       = BG_WS_FLAG_STATE_ON_BASE;
+    _flagState[TEAM_HORDE]          = BG_WS_FLAG_STATE_ON_BASE;
+    _lastFlagCaptureTeam            = TEAM_NEUTRAL;
+
+	if (sBattlegroundMgr->IsBGWeekend(GetBgTypeID()))
+    {
+        _reputationCapture = 45;
+        _honorWinKills = 3;
+        _honorEndKills = 4;
+    }
+    else
+    {
+        _reputationCapture = 35;
+        _honorWinKills = 1;
+        _honorEndKills = 2;
+    }
+}
+
+void BattlegroundWS::EndBattleground(TeamId winnerTeamId)
+{
+    // Win reward
+    RewardHonorToTeam(GetBonusHonorFromKill(_honorWinKills), winnerTeamId);
+
+    // Complete map_end rewards (even if no team wins)
+    RewardHonorToTeam(GetBonusHonorFromKill(_honorEndKills), TEAM_ALLIANCE);
+    RewardHonorToTeam(GetBonusHonorFromKill(_honorEndKills), TEAM_HORDE);
+
+    Battleground::EndBattleground(winnerTeamId);
+}
+
+void BattlegroundWS::HandleKillPlayer(Player* player, Player* killer)
+{
+    if (GetStatus() != STATUS_IN_PROGRESS)
+        return;
+
+    EventPlayerDroppedFlag(player);
+    Battleground::HandleKillPlayer(player, killer);
+}
+
+void BattlegroundWS::UpdatePlayerScore(Player* player, uint32 type, uint32 value, bool doAddHonor)
+{
+    BattlegroundScoreMap::iterator itr = PlayerScores.find(player->GetGUID());
+    if (itr == PlayerScores.end())
+        return;
+
+    switch (type)
+    {
+        case SCORE_FLAG_CAPTURES:
+            ((BattlegroundWGScore*)itr->second)->FlagCaptures += value;
+            player->UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_BG_OBJECTIVE_CAPTURE, WS_OBJECTIVE_CAPTURE_FLAG);
+            break;
+        case SCORE_FLAG_RETURNS:
+            ((BattlegroundWGScore*)itr->second)->FlagReturns += value;
+            player->UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_BG_OBJECTIVE_CAPTURE, WS_OBJECTIVE_RETURN_FLAG);
+            break;
+        default:
+            Battleground::UpdatePlayerScore(player, type, value, doAddHonor);
+            break;
+    }
+}
+
+WorldSafeLocsEntry const* BattlegroundWS::GetClosestGraveyard(Player* player)
+{
+    if (GetStatus() == STATUS_IN_PROGRESS)
+		return sWorldSafeLocsStore.LookupEntry(player->GetTeamId() == TEAM_ALLIANCE ? WS_GRAVEYARD_MAIN_ALLIANCE : WS_GRAVEYARD_MAIN_HORDE);
+    else
+		return sWorldSafeLocsStore.LookupEntry(player->GetTeamId() == TEAM_ALLIANCE ? WS_GRAVEYARD_FLAGROOM_ALLIANCE : WS_GRAVEYARD_FLAGROOM_HORDE);
+}
+
+void BattlegroundWS::FillInitialWorldStates(WorldPacket& data)
+{
+    data << uint32(BG_WS_FLAG_CAPTURES_ALLIANCE) << uint32(GetTeamScore(TEAM_ALLIANCE));
+    data << uint32(BG_WS_FLAG_CAPTURES_HORDE) << uint32(GetTeamScore(TEAM_HORDE));
+    data << uint32(BG_WS_FLAG_CAPTURES_MAX) << uint32(BG_WS_MAX_TEAM_SCORE);
+
+    data << uint32(BG_WS_STATE_TIMER_ACTIVE) << uint32(GetStatus() == STATUS_IN_PROGRESS);
+    data << uint32(BG_WS_STATE_TIMER) << uint32(GetMatchTime());
+
+    data << uint32(BG_WS_FLAG_STATE_HORDE) << uint32(GetFlagState(TEAM_HORDE));
+    data << uint32(BG_WS_FLAG_STATE_ALLIANCE) << uint32(GetFlagState(TEAM_ALLIANCE));
+}
+
+TeamId BattlegroundWS::GetPrematureWinner()
+{
+	if (GetTeamScore(TEAM_ALLIANCE) > GetTeamScore(TEAM_HORDE))
+		return TEAM_ALLIANCE;
+
+	return GetTeamScore(TEAM_HORDE) > GetTeamScore(TEAM_ALLIANCE) ? TEAM_HORDE : Battleground::GetPrematureWinner();
+}
+
+uint32 BattlegroundWS::GetAssaultSpellId() const
+{
+	if ((GetFlagPickerGUID(TEAM_ALLIANCE) == 0 && GetFlagState(TEAM_ALLIANCE) != BG_WS_FLAG_STATE_ON_GROUND) || 
+		(GetFlagPickerGUID(TEAM_HORDE) == 0 && GetFlagState(TEAM_HORDE) != BG_WS_FLAG_STATE_ON_GROUND) || 
+		_bgEvents.GetNextEventTime(BG_WS_EVENT_BOTH_FLAGS_KEPT10) > 0)
+		return 0;
+
+	return _bgEvents.GetNextEventTime(BG_WS_EVENT_BOTH_FLAGS_KEPT15) > 0 ? BG_WS_SPELL_FOCUSED_ASSAULT : BG_WS_SPELL_BRUTAL_ASSAULT;
+}
+
+void BattlegroundWS::RemoveAssaultAuras()
+{
+	if (Player* player = ObjectAccessor::GetObjectInMap(GetFlagPickerGUID(TEAM_ALLIANCE), this->FindBgMap(), (Player*)NULL))
+	{
+		player->RemoveAurasDueToSpell(BG_WS_SPELL_FOCUSED_ASSAULT);
+        player->RemoveAurasDueToSpell(BG_WS_SPELL_BRUTAL_ASSAULT);
+	}
+    if (Player* player = ObjectAccessor::GetObjectInMap(GetFlagPickerGUID(TEAM_HORDE), this->FindBgMap(), (Player*)NULL))
+	{
+		player->RemoveAurasDueToSpell(BG_WS_SPELL_FOCUSED_ASSAULT);
+        player->RemoveAurasDueToSpell(BG_WS_SPELL_BRUTAL_ASSAULT);
+	}
+}

src/server/game/Battlegrounds/Zones/BattlegroundWS.h

@@ -0,0 +1,205 @@
+/*
+REWRITTEN BY XINEF
+*/
+
+#ifndef __BATTLEGROUNDWS_H
+#define __BATTLEGROUNDWS_H
+
+#include "Battleground.h"
+
+enum BG_WS_Events
+{
+	BG_WS_EVENT_UPDATE_GAME_TIME	= 1,
+	BG_WS_EVENT_NO_TIME_LEFT		= 2,
+	BG_WS_EVENT_RESPAWN_BOTH_FLAGS	= 3,
+	BG_WS_EVENT_ALLIANCE_DROP_FLAG	= 4,
+	BG_WS_EVENT_HORDE_DROP_FLAG		= 5,
+	BG_WS_EVENT_BOTH_FLAGS_KEPT10	= 6,
+	BG_WS_EVENT_BOTH_FLAGS_KEPT15	= 7
+};
+
+enum BG_WS_TimerOrScore
+{
+	BG_WS_MAX_TEAM_SCORE			= 3,
+
+	BG_WS_TOTAL_GAME_TIME			= 27*MINUTE*IN_MILLISECONDS,
+	BG_WS_FLAG_RESPAWN_TIME			= 23*IN_MILLISECONDS,
+	BG_WS_FLAG_DROP_TIME			= 10*IN_MILLISECONDS,
+	BG_WS_SPELL_FORCE_TIME			= 10*MINUTE*IN_MILLISECONDS,
+	BG_WS_SPELL_BRUTAL_TIME			= 15*MINUTE*IN_MILLISECONDS
+};
+
+enum BG_WS_Sound
+{
+    BG_WS_SOUND_FLAG_CAPTURED_ALLIANCE  = 8173,
+    BG_WS_SOUND_FLAG_CAPTURED_HORDE     = 8213,
+    BG_WS_SOUND_FLAG_PLACED             = 8232,
+    BG_WS_SOUND_FLAG_RETURNED           = 8192,
+    BG_WS_SOUND_HORDE_FLAG_PICKED_UP    = 8212,
+    BG_WS_SOUND_ALLIANCE_FLAG_PICKED_UP = 8174,
+    BG_WS_SOUND_FLAGS_RESPAWNED         = 8232
+};
+
+enum BG_WS_SpellId
+{
+    BG_WS_SPELL_WARSONG_FLAG            = 23333,
+    BG_WS_SPELL_WARSONG_FLAG_DROPPED    = 23334,
+    BG_WS_SPELL_WARSONG_FLAG_PICKED     = 61266,    // fake spell, does not exist but used as timer start event
+    BG_WS_SPELL_SILVERWING_FLAG         = 23335,
+    BG_WS_SPELL_SILVERWING_FLAG_DROPPED = 23336,
+    BG_WS_SPELL_SILVERWING_FLAG_PICKED  = 61265,    // fake spell, does not exist but used as timer start event
+    BG_WS_SPELL_FOCUSED_ASSAULT         = 46392,
+    BG_WS_SPELL_BRUTAL_ASSAULT          = 46393
+};
+
+enum BG_WS_WorldStates
+{
+    BG_WS_FLAG_CAPTURES_ALLIANCE  = 1581,
+    BG_WS_FLAG_CAPTURES_HORDE     = 1582,
+    BG_WS_FLAG_CAPTURES_MAX       = 1601,
+    BG_WS_FLAG_STATE_HORDE        = 2338,
+    BG_WS_FLAG_STATE_ALLIANCE     = 2339,
+    BG_WS_STATE_TIMER             = 4248,
+    BG_WS_STATE_TIMER_ACTIVE      = 4247
+};
+
+enum BG_WS_ObjectTypes
+{
+    BG_WS_OBJECT_DOOR_A_1       = 0,
+    BG_WS_OBJECT_DOOR_A_2       = 1,
+    BG_WS_OBJECT_DOOR_A_3       = 2,
+    BG_WS_OBJECT_DOOR_A_4       = 3,
+    BG_WS_OBJECT_DOOR_A_5       = 4,
+    BG_WS_OBJECT_DOOR_A_6       = 5,
+    BG_WS_OBJECT_DOOR_H_1       = 6,
+    BG_WS_OBJECT_DOOR_H_2       = 7,
+    BG_WS_OBJECT_DOOR_H_3       = 8,
+    BG_WS_OBJECT_DOOR_H_4       = 9,
+    BG_WS_OBJECT_A_FLAG         = 10,
+    BG_WS_OBJECT_H_FLAG         = 11,
+    BG_WS_OBJECT_SPEEDBUFF_1    = 12,
+    BG_WS_OBJECT_SPEEDBUFF_2    = 13,
+    BG_WS_OBJECT_REGENBUFF_1    = 14,
+    BG_WS_OBJECT_REGENBUFF_2    = 15,
+    BG_WS_OBJECT_BERSERKBUFF_1  = 16,
+    BG_WS_OBJECT_BERSERKBUFF_2  = 17,
+    BG_WS_OBJECT_MAX            = 18
+};
+
+enum BG_WS_ObjectEntry
+{
+    BG_OBJECT_DOOR_A_1_WS_ENTRY          = 179918,
+    BG_OBJECT_DOOR_A_2_WS_ENTRY          = 179919,
+    BG_OBJECT_DOOR_A_3_WS_ENTRY          = 179920,
+    BG_OBJECT_DOOR_A_4_WS_ENTRY          = 179921,
+    BG_OBJECT_DOOR_A_5_WS_ENTRY          = 180322,
+    BG_OBJECT_DOOR_A_6_WS_ENTRY          = 180322,
+    BG_OBJECT_DOOR_H_1_WS_ENTRY          = 179916,
+    BG_OBJECT_DOOR_H_2_WS_ENTRY          = 179917,
+    BG_OBJECT_DOOR_H_3_WS_ENTRY          = 180322,
+    BG_OBJECT_DOOR_H_4_WS_ENTRY          = 180322,
+    BG_OBJECT_A_FLAG_WS_ENTRY            = 179830,
+    BG_OBJECT_H_FLAG_WS_ENTRY            = 179831,
+    BG_OBJECT_A_FLAG_GROUND_WS_ENTRY     = 179785,
+    BG_OBJECT_H_FLAG_GROUND_WS_ENTRY     = 179786
+};
+
+enum BG_WS_FlagState
+{
+    BG_WS_FLAG_STATE_ON_BASE      = 1,
+    BG_WS_FLAG_STATE_ON_PLAYER    = 2,
+    BG_WS_FLAG_STATE_ON_GROUND    = 3
+};
+
+enum BG_WS_Graveyards
+{
+    WS_GRAVEYARD_FLAGROOM_ALLIANCE = 769,
+    WS_GRAVEYARD_FLAGROOM_HORDE    = 770,
+    WS_GRAVEYARD_MAIN_ALLIANCE     = 771,
+    WS_GRAVEYARD_MAIN_HORDE        = 772
+};
+
+enum BG_WS_CreatureTypes
+{
+    WS_SPIRIT_MAIN_ALLIANCE   = 0,
+    WS_SPIRIT_MAIN_HORDE      = 1,
+
+    BG_CREATURES_MAX_WS       = 2
+};
+
+
+enum BG_WS_Objectives
+{
+    WS_OBJECTIVE_CAPTURE_FLAG   = 42,
+    WS_OBJECTIVE_RETURN_FLAG    = 44,
+
+	WS_EVENT_START_BATTLE		= 8563
+};
+
+struct BattlegroundWGScore : public BattlegroundScore
+{
+    BattlegroundWGScore(Player* player): BattlegroundScore(player), FlagCaptures(0), FlagReturns(0) { }
+    ~BattlegroundWGScore() { }
+    uint32 FlagCaptures;
+    uint32 FlagReturns;
+};
+
+class BattlegroundWS : public Battleground
+{
+    public:
+        /* Construction */
+        BattlegroundWS();
+        ~BattlegroundWS();
+
+        /* inherited from BattlegroundClass */
+        void AddPlayer(Player* player);
+        void StartingEventCloseDoors();
+        void StartingEventOpenDoors();
+
+        /* BG Flags */
+        uint64 GetFlagPickerGUID(TeamId teamId) const { return _flagKeepers[teamId];  }
+        void SetFlagPicker(uint64 guid, TeamId teamId) { _flagKeepers[teamId] = guid; }
+        void RespawnFlagAfterDrop(TeamId teamId);
+        uint8 GetFlagState(TeamId teamId) const { return _flagState[teamId]; }
+
+        /* Battleground Events */
+        void EventPlayerDroppedFlag(Player* player);
+        void EventPlayerClickedOnFlag(Player* player, GameObject* gameObject);
+        void EventPlayerCapturedFlag(Player* player);
+
+        void RemovePlayer(Player* player);
+        void HandleAreaTrigger(Player* player, uint32 trigger);
+        void HandleKillPlayer(Player* player, Player* killer);
+        bool SetupBattleground();
+        void Init();
+        void EndBattleground(TeamId winnerTeamId);
+        WorldSafeLocsEntry const* GetClosestGraveyard(Player* player);
+
+        void UpdateFlagState(TeamId teamId, uint32 value);
+        void UpdatePlayerScore(Player* player, uint32 type, uint32 value, bool doAddHonor = true);
+        void SetDroppedFlagGUID(uint64 guid, TeamId teamId) { _droppedFlagGUID[teamId] = guid; }
+        uint64 GetDroppedFlagGUID(TeamId teamId) const { return _droppedFlagGUID[teamId];}
+        void FillInitialWorldStates(WorldPacket& data);
+
+        /* Scorekeeping */
+        void AddPoints(TeamId teamId, uint32 points) { m_TeamScores[teamId] += points; }
+        
+        TeamId GetPrematureWinner();
+		uint32 GetMatchTime() const { return 1 + (BG_WS_TOTAL_GAME_TIME - GetStartTime()) / (MINUTE*IN_MILLISECONDS); }
+		uint32 GetAssaultSpellId() const;
+		void RemoveAssaultAuras();
+
+    private:
+		EventMap _bgEvents;
+
+        uint64 _flagKeepers[2];
+        uint64 _droppedFlagGUID[2];
+        uint8  _flagState[2];
+        TeamId _lastFlagCaptureTeam;
+        uint32 _reputationCapture;
+        uint32 _honorWinKills;
+        uint32 _honorEndKills;
+
+        void PostUpdateImpl(uint32 diff);
+};
+#endif

src/server/game/CMakeLists.txt

@@ -0,0 +1,222 @@
+# Copyright (C) 
+#
+# This file is free software; as a special exception the author gives
+# unlimited permission to copy and/or distribute it, with or without
+# modifications, as long as this notice is preserved.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY, to the extent permitted by law; without even the
+# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+
+file(GLOB_RECURSE sources_Accounts Accounts/*.cpp Accounts/*.h)
+file(GLOB_RECURSE sources_Achievements Achievements/*.cpp Achievements/*.h)
+file(GLOB_RECURSE sources_Addons Addons/*.cpp Addons/*.h)
+file(GLOB_RECURSE sources_AI AI/*.cpp AI/*.h)
+file(GLOB_RECURSE sources_AuctionHouse AuctionHouse/*.cpp AuctionHouse/*.h)
+file(GLOB_RECURSE sources_Battlefield Battlefield/*.cpp Battlefield/*.h)
+file(GLOB_RECURSE sources_Battlegrounds Battlegrounds/*.cpp Battlegrounds/*.h)
+file(GLOB_RECURSE sources_Calendar Calendar/*.cpp Calendar/*.h)
+file(GLOB_RECURSE sources_Chat Chat/*.cpp Chat/*.h)
+file(GLOB_RECURSE sources_Combat Combat/*.cpp Combat/*.h)
+file(GLOB_RECURSE sources_Conditions Conditions/*.cpp Conditions/*.h)
+file(GLOB_RECURSE sources_DataStores DataStores/*.cpp DataStores/*.h)
+file(GLOB_RECURSE sources_DungeonFinding DungeonFinding/*.cpp DungeonFinding/*.h)
+file(GLOB_RECURSE sources_Entities Entities/*.cpp Entities/*.h)
+file(GLOB_RECURSE sources_Events Events/*.cpp Events/*.h)
+file(GLOB_RECURSE sources_Globals Globals/*.cpp Globals/*.h)
+file(GLOB_RECURSE sources_Grids Grids/*.cpp Grids/*.h)
+file(GLOB_RECURSE sources_Groups Groups/*.cpp Groups/*.h)
+file(GLOB_RECURSE sources_Guilds Guilds/*.cpp Guilds/*.h)
+file(GLOB_RECURSE sources_Handlers Handlers/*.cpp Handlers/*.h)
+file(GLOB_RECURSE sources_Instances Instances/*.cpp Instances/*.h)
+file(GLOB_RECURSE sources_Loot Loot/*.cpp Loot/*.h)
+file(GLOB_RECURSE sources_Mails Mails/*.cpp Mails/*.h)
+file(GLOB_RECURSE sources_Maps Maps/*.cpp Maps/*.h)
+file(GLOB_RECURSE sources_Miscellaneous Miscellaneous/*.cpp Miscellaneous/*.h)
+file(GLOB_RECURSE sources_Movement Movement/*.cpp Movement/*.h)
+file(GLOB_RECURSE sources_OutdoorPvP OutdoorPvP/*.cpp OutdoorPvP/*.h)
+file(GLOB_RECURSE sources_Petitions Petitions/*.cpp Petitions/*.h)
+file(GLOB_RECURSE sources_Pools Pools/*.cpp Pools/*.h)
+file(GLOB_RECURSE sources_Quests Quests/*.cpp Quests/*.h)
+file(GLOB_RECURSE sources_Reputation Reputation/*.cpp Reputation/*.h)
+file(GLOB_RECURSE sources_Scripting Scripting/*.cpp Scripting/*.h)
+file(GLOB_RECURSE sources_Server Server/*.cpp Server/*.h)
+file(GLOB_RECURSE sources_Skills Skills/*.cpp Skills/*.h)
+file(GLOB_RECURSE sources_Spells Spells/*.cpp Spells/*.h)
+file(GLOB_RECURSE sources_Texts Texts/*.cpp Texts/*.h)
+file(GLOB_RECURSE sources_Tools Tools/*.cpp Tools/*.h)
+file(GLOB_RECURSE sources_Tickets Tickets/*.cpp Tickets/*.h)
+file(GLOB_RECURSE sources_Warden Warden/*.cpp Warden/*.h)
+file(GLOB_RECURSE sources_Weather Weather/*.cpp Weather/*.h)
+file(GLOB_RECURSE sources_World World/*.cpp World/*.h)
+file(GLOB_RECURSE sources_ArenaSpectator ArenaSpectator/*.cpp ArenaSpectator/*.h)
+file(GLOB_RECURSE sources_Misc Misc/*.cpp Misc/*.h)
+
+# Create game-libary
+
+if (USE_COREPCH)
+  set(game_STAT_PCH_HDR PrecompiledHeaders/gamePCH.h)
+  set(game_STAT_PCH_SRC PrecompiledHeaders/gamePCH.cpp)
+endif ()
+
+set(game_STAT_SRCS
+  ${game_STAT_SRCS}
+  ${sources_Accounts}
+  ${sources_Achievements}
+  ${sources_Addons}
+  ${sources_AI}
+  ${sources_AuctionHouse}
+  ${sources_Battlefield}
+  ${sources_Battlegrounds}
+  ${sources_Calendar}
+  ${sources_Chat}
+  ${sources_Combat}
+  ${sources_Conditions}
+  ${sources_DataStores}
+  ${sources_DungeonFinding}
+  ${sources_Entities}
+  ${sources_Events}
+  ${sources_Globals}
+  ${sources_Grids}
+  ${sources_Groups}
+  ${sources_Guilds}
+  ${sources_Handlers}
+  ${sources_Instances}
+  ${sources_Loot}
+  ${sources_Mails}
+  ${sources_Maps}
+  ${sources_Miscellaneous}
+  ${sources_Movement}
+  ${sources_OutdoorPvP}
+  ${sources_Petitions}
+  ${sources_Pools}
+  ${sources_Quests}
+  ${sources_Reputation}
+  ${sources_Scripting}
+  ${sources_Server}
+  ${sources_Skills}
+  ${sources_Spells}
+  ${sources_Texts}
+  ${sources_Tools}
+  ${sources_Tickets}
+  ${sources_Warden}
+  ${sources_Weather}
+  ${sources_World}
+  ${sources_ArenaSpectator}
+  ${sources_Misc}
+)
+
+include_directories(
+  ${CMAKE_BINARY_DIR}
+  ${CMAKE_SOURCE_DIR}/dep/recastnavigation/Detour
+  ${CMAKE_SOURCE_DIR}/dep/recastnavigation/Recast
+  ${CMAKE_SOURCE_DIR}/dep/g3dlite/include
+  ${CMAKE_SOURCE_DIR}/dep/SFMT
+  ${CMAKE_SOURCE_DIR}/dep/zlib
+  ${CMAKE_SOURCE_DIR}/src/server/collision
+  ${CMAKE_SOURCE_DIR}/src/server/collision/Management
+  ${CMAKE_SOURCE_DIR}/src/server/collision/Models
+  ${CMAKE_SOURCE_DIR}/src/server/collision/Maps
+  ${CMAKE_SOURCE_DIR}/src/server/shared
+  ${CMAKE_SOURCE_DIR}/src/server/shared/Configuration
+  ${CMAKE_SOURCE_DIR}/src/server/shared/Cryptography
+  ${CMAKE_SOURCE_DIR}/src/server/shared/Cryptography/Authentication
+  ${CMAKE_SOURCE_DIR}/src/server/shared/Database
+  ${CMAKE_SOURCE_DIR}/src/server/shared/DataStores
+  ${CMAKE_SOURCE_DIR}/src/server/shared/Debugging
+  ${CMAKE_SOURCE_DIR}/src/server/shared/Dynamic/LinkedReference
+  ${CMAKE_SOURCE_DIR}/src/server/shared/Dynamic
+  ${CMAKE_SOURCE_DIR}/src/server/shared/Logging
+  ${CMAKE_SOURCE_DIR}/src/server/shared/Packets
+  ${CMAKE_SOURCE_DIR}/src/server/shared/Threading
+  ${CMAKE_SOURCE_DIR}/src/server/shared/Utilities
+  ${CMAKE_CURRENT_SOURCE_DIR}
+  ${CMAKE_CURRENT_SOURCE_DIR}/Accounts
+  ${CMAKE_CURRENT_SOURCE_DIR}/Achievements
+  ${CMAKE_CURRENT_SOURCE_DIR}/Addons
+  ${CMAKE_CURRENT_SOURCE_DIR}/AI
+  ${CMAKE_CURRENT_SOURCE_DIR}/AI/CoreAI
+  ${CMAKE_CURRENT_SOURCE_DIR}/AI/ScriptedAI
+  ${CMAKE_CURRENT_SOURCE_DIR}/AI/SmartScripts
+  ${CMAKE_CURRENT_SOURCE_DIR}/AuctionHouse
+  ${CMAKE_CURRENT_SOURCE_DIR}/Battlefield
+  ${CMAKE_CURRENT_SOURCE_DIR}/Battlefield/Zones
+  ${CMAKE_CURRENT_SOURCE_DIR}/Battlegrounds
+  ${CMAKE_CURRENT_SOURCE_DIR}/Battlegrounds/Zones
+  ${CMAKE_CURRENT_SOURCE_DIR}/Calendar
+  ${CMAKE_CURRENT_SOURCE_DIR}/Chat
+  ${CMAKE_CURRENT_SOURCE_DIR}/Chat/Channels
+  ${CMAKE_CURRENT_SOURCE_DIR}/Combat
+  ${CMAKE_CURRENT_SOURCE_DIR}/Conditions
+  ${CMAKE_CURRENT_SOURCE_DIR}/DataStores
+  ${CMAKE_CURRENT_SOURCE_DIR}/DungeonFinding
+  ${CMAKE_CURRENT_SOURCE_DIR}/Entities
+  ${CMAKE_CURRENT_SOURCE_DIR}/Entities/Creature
+  ${CMAKE_CURRENT_SOURCE_DIR}/Entities/Corpse
+  ${CMAKE_CURRENT_SOURCE_DIR}/Entities/DynamicObject
+  ${CMAKE_CURRENT_SOURCE_DIR}/Entities/GameObject
+  ${CMAKE_CURRENT_SOURCE_DIR}/Entities/Item
+  ${CMAKE_CURRENT_SOURCE_DIR}/Entities/Item/Container
+  ${CMAKE_CURRENT_SOURCE_DIR}/Entities/Object
+  ${CMAKE_CURRENT_SOURCE_DIR}/Entities/Object/Updates
+  ${CMAKE_CURRENT_SOURCE_DIR}/Entities/Pet
+  ${CMAKE_CURRENT_SOURCE_DIR}/Entities/Player
+  ${CMAKE_CURRENT_SOURCE_DIR}/Entities/Totem
+  ${CMAKE_CURRENT_SOURCE_DIR}/Entities/Unit
+  ${CMAKE_CURRENT_SOURCE_DIR}/Entities/Vehicle
+  ${CMAKE_CURRENT_SOURCE_DIR}/Entities/Transport
+  ${CMAKE_CURRENT_SOURCE_DIR}/Events
+  ${CMAKE_CURRENT_SOURCE_DIR}/Globals
+  ${CMAKE_CURRENT_SOURCE_DIR}/Grids/Cells
+  ${CMAKE_CURRENT_SOURCE_DIR}/Grids/Notifiers
+  ${CMAKE_CURRENT_SOURCE_DIR}/Grids
+  ${CMAKE_CURRENT_SOURCE_DIR}/Groups
+  ${CMAKE_CURRENT_SOURCE_DIR}/Guilds
+  ${CMAKE_CURRENT_SOURCE_DIR}/Handlers
+  ${CMAKE_CURRENT_SOURCE_DIR}/Instances
+  ${CMAKE_CURRENT_SOURCE_DIR}/Loot
+  ${CMAKE_CURRENT_SOURCE_DIR}/Mails
+  ${CMAKE_CURRENT_SOURCE_DIR}/Maps
+  ${CMAKE_CURRENT_SOURCE_DIR}/Miscellaneous
+  ${CMAKE_CURRENT_SOURCE_DIR}/Movement
+  ${CMAKE_CURRENT_SOURCE_DIR}/Movement/Spline
+  ${CMAKE_CURRENT_SOURCE_DIR}/Movement/MovementGenerators
+  ${CMAKE_CURRENT_SOURCE_DIR}/Movement/Waypoints
+  ${CMAKE_CURRENT_SOURCE_DIR}/OutdoorPvP
+  ${CMAKE_CURRENT_SOURCE_DIR}/Petitions
+  ${CMAKE_CURRENT_SOURCE_DIR}/Pools
+  ${CMAKE_CURRENT_SOURCE_DIR}/PrecompiledHeaders
+  ${CMAKE_CURRENT_SOURCE_DIR}/Quests
+  ${CMAKE_CURRENT_SOURCE_DIR}/Reputation
+  ${CMAKE_CURRENT_SOURCE_DIR}/Scripting
+  ${CMAKE_CURRENT_SOURCE_DIR}/Server/Protocol
+  ${CMAKE_CURRENT_SOURCE_DIR}/Server
+  ${CMAKE_CURRENT_SOURCE_DIR}/Skills
+  ${CMAKE_CURRENT_SOURCE_DIR}/Spells
+  ${CMAKE_CURRENT_SOURCE_DIR}/Spells/Auras
+  ${CMAKE_CURRENT_SOURCE_DIR}/Texts
+  ${CMAKE_CURRENT_SOURCE_DIR}/Tools
+  ${CMAKE_CURRENT_SOURCE_DIR}/Tickets
+  ${CMAKE_CURRENT_SOURCE_DIR}/Warden
+  ${CMAKE_CURRENT_SOURCE_DIR}/Warden/Modules
+  ${CMAKE_CURRENT_SOURCE_DIR}/Weather
+  ${CMAKE_CURRENT_SOURCE_DIR}/World
+  ${CMAKE_CURRENT_SOURCE_DIR}/ArenaSpectator
+  ${CMAKE_CURRENT_SOURCE_DIR}/Misc
+  ${CMAKE_SOURCE_DIR}/src/server/scripts/PrecompiledHeaders
+  ${ACE_INCLUDE_DIR}
+  ${MYSQL_INCLUDE_DIR}
+  ${OPENSSL_INCLUDE_DIR}
+)
+
+add_library(game STATIC
+  ${game_STAT_SRCS}
+  ${game_STAT_PCH_SRC}
+)
+
+add_dependencies(game revision.h)
+
+# Generate precompiled header
+if (USE_COREPCH)
+  add_cxx_pch(game ${game_STAT_PCH_HDR} ${game_STAT_PCH_SRC})
+endif ()

src/server/game/Calendar/CalendarMgr.cpp

@@ -0,0 +1,669 @@
+/*
+ * Copyright (C) 
+ *
+ * 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "CalendarMgr.h"
+#include "QueryResult.h"
+#include "Log.h"
+#include "Player.h"
+#include "GuildMgr.h"
+#include "ObjectAccessor.h"
+#include "Opcodes.h"
+
+CalendarInvite::~CalendarInvite()
+{
+    sCalendarMgr->FreeInviteId(_inviteId);
+}
+
+CalendarEvent::~CalendarEvent()
+{
+    sCalendarMgr->FreeEventId(_eventId);
+}
+
+CalendarMgr::CalendarMgr() : _maxEventId(0), _maxInviteId(0) { }
+
+CalendarMgr::~CalendarMgr()
+{
+    for (CalendarEventStore::iterator itr = _events.begin(); itr != _events.end(); ++itr)
+        delete *itr;
+
+    for (CalendarEventInviteStore::iterator itr = _invites.begin(); itr != _invites.end(); ++itr)
+        for (CalendarInviteStore::iterator itr2 = itr->second.begin(); itr2 != itr->second.end(); ++itr2)
+            delete *itr2;
+}
+
+void CalendarMgr::LoadFromDB()
+{
+    uint32 count = 0;
+    _maxEventId = 0;
+    _maxInviteId = 0;
+
+    //                                                       0   1        2      3            4     5        6          7      8
+    if (QueryResult result = CharacterDatabase.Query("SELECT id, creator, title, description, type, dungeon, eventtime, flags, time2 FROM calendar_events"))
+        do
+        {
+            Field* fields = result->Fetch();
+
+            uint64 eventId          = fields[0].GetUInt64();
+            uint64 creatorGUID      = MAKE_NEW_GUID(fields[1].GetUInt32(), 0, HIGHGUID_PLAYER);
+            std::string title       = fields[2].GetString();
+            std::string description = fields[3].GetString();
+            CalendarEventType type  = CalendarEventType(fields[4].GetUInt8());
+            int32 dungeonId         = fields[5].GetInt32();
+            uint32 eventTime        = fields[6].GetUInt32();
+            uint32 flags            = fields[7].GetUInt32();
+            uint32 timezoneTime     = fields[8].GetUInt32();
+            uint32 guildId = 0;
+
+            if (flags & CALENDAR_FLAG_GUILD_EVENT || flags & CALENDAR_FLAG_WITHOUT_INVITES)
+				guildId = Player::GetGuildIdFromStorage(GUID_LOPART(creatorGUID));
+
+            CalendarEvent* calendarEvent = new CalendarEvent(eventId, creatorGUID, guildId, type, dungeonId, time_t(eventTime), flags, time_t(timezoneTime), title, description);
+            _events.insert(calendarEvent);
+
+            _maxEventId = std::max(_maxEventId, eventId);
+
+            ++count;
+        }
+        while (result->NextRow());
+
+    sLog->outString(">> Loaded %u calendar events", count);
+    count = 0;
+
+    //                                                       0   1      2        3       4       5           6     7
+    if (QueryResult result = CharacterDatabase.Query("SELECT id, event, invitee, sender, status, statustime, rank, text FROM calendar_invites"))
+        do
+        {
+            Field* fields = result->Fetch();
+
+            uint64 inviteId             = fields[0].GetUInt64();
+            uint64 eventId              = fields[1].GetUInt64();
+            uint64 invitee              = MAKE_NEW_GUID(fields[2].GetUInt32(), 0, HIGHGUID_PLAYER);
+            uint64 senderGUID           = MAKE_NEW_GUID(fields[3].GetUInt32(), 0, HIGHGUID_PLAYER);
+            CalendarInviteStatus status = CalendarInviteStatus(fields[4].GetUInt8());
+            uint32 statusTime           = fields[5].GetUInt32();
+            CalendarModerationRank rank = CalendarModerationRank(fields[6].GetUInt8());
+            std::string text            = fields[7].GetString();
+
+            CalendarInvite* invite = new CalendarInvite(inviteId, eventId, invitee, senderGUID, time_t(statusTime), status, rank, text);
+            _invites[eventId].push_back(invite);
+
+            _maxInviteId = std::max(_maxInviteId, inviteId);
+
+            ++count;
+        }
+        while (result->NextRow());
+
+    sLog->outString(">> Loaded %u calendar invites", count);
+
+    for (uint64 i = 1; i < _maxEventId; ++i)
+        if (!GetEvent(i))
+            _freeEventIds.push_back(i);
+
+    for (uint64 i = 1; i < _maxInviteId; ++i)
+        if (!GetInvite(i))
+            _freeInviteIds.push_back(i);
+}
+
+void CalendarMgr::AddEvent(CalendarEvent* calendarEvent, CalendarSendEventType sendType)
+{
+    _events.insert(calendarEvent);
+    UpdateEvent(calendarEvent);
+    SendCalendarEvent(calendarEvent->GetCreatorGUID(), *calendarEvent, sendType);
+}
+
+void CalendarMgr::AddInvite(CalendarEvent* calendarEvent, CalendarInvite* invite)
+{
+    SQLTransaction dummy;
+    AddInvite(calendarEvent, invite, dummy);
+}
+
+void CalendarMgr::AddInvite(CalendarEvent* calendarEvent, CalendarInvite* invite, SQLTransaction& trans)
+{
+    if (!calendarEvent->IsGuildAnnouncement())
+        SendCalendarEventInvite(*invite);
+
+    if (!calendarEvent->IsGuildEvent() || invite->GetInviteeGUID() == calendarEvent->GetCreatorGUID())
+        SendCalendarEventInviteAlert(*calendarEvent, *invite);
+
+    if (!calendarEvent->IsGuildAnnouncement())
+    {
+        _invites[invite->GetEventId()].push_back(invite);
+        UpdateInvite(invite, trans);
+    }
+}
+
+CalendarEventStore::iterator CalendarMgr::RemoveEvent(uint64 eventId, uint64 remover)
+{
+    CalendarEventStore::iterator current;
+    CalendarEvent* calendarEvent = GetEvent(eventId, &current);
+
+    if (!calendarEvent)
+    {
+        SendCalendarCommandResult(remover, CALENDAR_ERROR_EVENT_INVALID);
+        return _events.end();
+    }
+
+    SendCalendarEventRemovedAlert(*calendarEvent);
+
+    SQLTransaction trans = CharacterDatabase.BeginTransaction();
+    PreparedStatement* stmt;
+    MailDraft mail(calendarEvent->BuildCalendarMailSubject(remover), calendarEvent->BuildCalendarMailBody());
+
+    CalendarInviteStore& eventInvites = _invites[eventId];
+    for (size_t i = 0; i < eventInvites.size(); ++i)
+    {
+        CalendarInvite* invite = eventInvites[i];
+        stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_CALENDAR_INVITE);
+        stmt->setUInt64(0, invite->GetInviteId());
+        trans->Append(stmt);
+
+        // guild events only? check invite status here?
+        // When an event is deleted, all invited (accepted/declined? - verify) guildies are notified via in-game mail. (wowwiki)
+        if (remover && invite->GetInviteeGUID() != remover)
+            mail.SendMailTo(trans, MailReceiver(invite->GetInviteeGUID()), calendarEvent, MAIL_CHECK_MASK_COPIED);
+
+        delete invite;
+    }
+
+    _invites.erase(eventId);
+
+    stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_CALENDAR_EVENT);
+    stmt->setUInt64(0, eventId);
+    trans->Append(stmt);
+    CharacterDatabase.CommitTransaction(trans);
+
+    delete calendarEvent;
+    current = _events.erase(current);
+    return current;
+}
+
+void CalendarMgr::RemoveInvite(uint64 inviteId, uint64 eventId, uint64 /*remover*/)
+{
+    CalendarEvent* calendarEvent = GetEvent(eventId);
+
+    if (!calendarEvent)
+        return;
+
+    CalendarInviteStore::iterator itr = _invites[eventId].begin();
+    for (; itr != _invites[eventId].end(); ++itr)
+        if ((*itr)->GetInviteId() == inviteId)
+            break;
+
+    if (itr == _invites[eventId].end())
+        return;
+
+    SQLTransaction trans = CharacterDatabase.BeginTransaction();
+    PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_CALENDAR_INVITE);
+    stmt->setUInt64(0, (*itr)->GetInviteId());
+    trans->Append(stmt);
+    CharacterDatabase.CommitTransaction(trans);
+
+    if (!calendarEvent->IsGuildEvent())
+        SendCalendarEventInviteRemoveAlert((*itr)->GetInviteeGUID(), *calendarEvent, CALENDAR_STATUS_REMOVED);
+
+    SendCalendarEventInviteRemove(*calendarEvent, **itr, calendarEvent->GetFlags());
+
+    // we need to find out how to use CALENDAR_INVITE_REMOVED_MAIL_SUBJECT to force client to display different mail
+    //if ((*itr)->GetInviteeGUID() != remover)
+    //    MailDraft(calendarEvent->BuildCalendarMailSubject(remover), calendarEvent->BuildCalendarMailBody())
+    //        .SendMailTo(trans, MailReceiver((*itr)->GetInvitee()), calendarEvent, MAIL_CHECK_MASK_COPIED);
+
+    delete *itr;
+    _invites[eventId].erase(itr);
+}
+
+void CalendarMgr::UpdateEvent(CalendarEvent* calendarEvent)
+{
+    PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_REP_CALENDAR_EVENT);
+    stmt->setUInt64(0, calendarEvent->GetEventId());
+    stmt->setUInt32(1, GUID_LOPART(calendarEvent->GetCreatorGUID()));
+    stmt->setString(2, calendarEvent->GetTitle());
+    stmt->setString(3, calendarEvent->GetDescription());
+    stmt->setUInt8(4, calendarEvent->GetType());
+    stmt->setInt32(5, calendarEvent->GetDungeonId());
+    stmt->setUInt32(6, uint32(calendarEvent->GetEventTime()));
+    stmt->setUInt32(7, calendarEvent->GetFlags());
+    stmt->setUInt32(8, calendarEvent->GetTimeZoneTime()); // correct?
+    CharacterDatabase.Execute(stmt);
+}
+
+void CalendarMgr::UpdateInvite(CalendarInvite* invite)
+{
+    SQLTransaction dummy;
+    UpdateInvite(invite, dummy);
+}
+
+void CalendarMgr::UpdateInvite(CalendarInvite* invite, SQLTransaction& trans)
+{
+    PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_REP_CALENDAR_INVITE);
+    stmt->setUInt64(0, invite->GetInviteId());
+    stmt->setUInt64(1, invite->GetEventId());
+    stmt->setUInt32(2, GUID_LOPART(invite->GetInviteeGUID()));
+    stmt->setUInt32(3, GUID_LOPART(invite->GetSenderGUID()));
+    stmt->setUInt8(4, invite->GetStatus());
+    stmt->setUInt32(5, uint32(invite->GetStatusTime()));
+    stmt->setUInt8(6, invite->GetRank());
+    stmt->setString(7, invite->GetText());
+    CharacterDatabase.ExecuteOrAppend(trans, stmt);
+}
+
+void CalendarMgr::RemoveAllPlayerEventsAndInvites(uint64 guid)
+{
+    for (CalendarEventStore::const_iterator itr = _events.begin(); itr != _events.end();)
+    {
+        if ((*itr)->GetCreatorGUID() == guid)
+        {
+            itr = RemoveEvent((*itr)->GetEventId(), 0); // don't send mail if removing a character
+            continue;
+        }
+        ++itr;
+    }
+
+    CalendarInviteStore playerInvites = GetPlayerInvites(guid);
+    for (CalendarInviteStore::const_iterator itr = playerInvites.begin(); itr != playerInvites.end(); ++itr)
+        RemoveInvite((*itr)->GetInviteId(), (*itr)->GetEventId(), guid);
+}
+
+void CalendarMgr::RemovePlayerGuildEventsAndSignups(uint64 guid, uint32 guildId)
+{
+    for (CalendarEventStore::const_iterator itr = _events.begin(); itr != _events.end();)
+    {
+        if ((*itr)->GetCreatorGUID() == guid && ((*itr)->IsGuildEvent() || (*itr)->IsGuildAnnouncement()))
+        {
+            itr = RemoveEvent((*itr)->GetEventId(), guid);
+            continue;
+        }
+        ++itr;
+    }
+
+    CalendarInviteStore playerInvites = GetPlayerInvites(guid);
+    for (CalendarInviteStore::const_iterator itr = playerInvites.begin(); itr != playerInvites.end(); ++itr)
+        if (CalendarEvent* calendarEvent = GetEvent((*itr)->GetEventId()))
+            if (calendarEvent->IsGuildEvent() && calendarEvent->GetGuildId() == guildId)
+                RemoveInvite((*itr)->GetInviteId(), (*itr)->GetEventId(), guid);
+}
+
+CalendarEvent* CalendarMgr::GetEvent(uint64 eventId, CalendarEventStore::iterator* it)
+{
+    for (CalendarEventStore::iterator itr = _events.begin(); itr != _events.end(); ++itr)
+        if ((*itr)->GetEventId() == eventId)
+        {
+            if (it)
+                *it = itr;
+            return *itr;
+        }
+
+    return NULL;
+}
+
+CalendarInvite* CalendarMgr::GetInvite(uint64 inviteId) const
+{
+    for (CalendarEventInviteStore::const_iterator itr = _invites.begin(); itr != _invites.end(); ++itr)
+        for (CalendarInviteStore::const_iterator itr2 = itr->second.begin(); itr2 != itr->second.end(); ++itr2)
+            if ((*itr2)->GetInviteId() == inviteId)
+                return *itr2;
+
+    ;//sLog->outDebug(LOG_FILTER_CALENDAR, "CalendarMgr::GetInvite: [" UI64FMTD "] not found!", inviteId);
+    return NULL;
+}
+
+void CalendarMgr::FreeEventId(uint64 id)
+{
+    if (id == _maxEventId)
+        --_maxEventId;
+    else
+        _freeEventIds.push_back(id);
+}
+
+uint64 CalendarMgr::GetFreeEventId()
+{
+    if (_freeEventIds.empty())
+        return ++_maxEventId;
+
+    uint64 eventId = _freeEventIds.front();
+    _freeEventIds.pop_front();
+    return eventId;
+}
+
+void CalendarMgr::FreeInviteId(uint64 id)
+{
+    if (id == _maxInviteId)
+        --_maxInviteId;
+    else
+        _freeInviteIds.push_back(id);
+}
+
+uint64 CalendarMgr::GetFreeInviteId()
+{
+    if (_freeInviteIds.empty())
+        return ++_maxInviteId;
+
+    uint64 inviteId = _freeInviteIds.front();
+    _freeInviteIds.pop_front();
+    return inviteId;
+}
+
+CalendarEventStore CalendarMgr::GetPlayerEvents(uint64 guid)
+{
+    CalendarEventStore events;
+
+    for (CalendarEventInviteStore::const_iterator itr = _invites.begin(); itr != _invites.end(); ++itr)
+        for (CalendarInviteStore::const_iterator itr2 = itr->second.begin(); itr2 != itr->second.end(); ++itr2)
+            if ((*itr2)->GetInviteeGUID() == guid)
+                if (CalendarEvent* event = GetEvent(itr->first)) // NULL check added as attempt to fix #11512
+                    events.insert(event);
+
+    if (Player* player = ObjectAccessor::FindPlayerInOrOutOfWorld(guid))
+        for (CalendarEventStore::const_iterator itr = _events.begin(); itr != _events.end(); ++itr)
+            if ((*itr)->GetGuildId() == player->GetGuildId())
+                events.insert(*itr);
+
+    return events;
+}
+
+CalendarInviteStore const& CalendarMgr::GetEventInvites(uint64 eventId)
+{
+    return _invites[eventId];
+}
+
+CalendarInviteStore CalendarMgr::GetPlayerInvites(uint64 guid)
+{
+    CalendarInviteStore invites;
+
+    for (CalendarEventInviteStore::const_iterator itr = _invites.begin(); itr != _invites.end(); ++itr)
+        for (CalendarInviteStore::const_iterator itr2 = itr->second.begin(); itr2 != itr->second.end(); ++itr2)
+            if ((*itr2)->GetInviteeGUID() == guid)
+                invites.push_back(*itr2);
+
+    return invites;
+}
+
+uint32 CalendarMgr::GetPlayerNumPending(uint64 guid)
+{
+    CalendarInviteStore const& invites = GetPlayerInvites(guid);
+
+    uint32 pendingNum = 0;
+    for (CalendarInviteStore::const_iterator itr = invites.begin(); itr != invites.end(); ++itr)
+    {
+        switch ((*itr)->GetStatus())
+        {
+            case CALENDAR_STATUS_INVITED:
+            case CALENDAR_STATUS_TENTATIVE:
+            case CALENDAR_STATUS_NOT_SIGNED_UP:
+                ++pendingNum;
+                break;
+            default:
+                break;
+        }
+    }
+
+    return pendingNum;
+}
+
+std::string CalendarEvent::BuildCalendarMailSubject(uint64 remover) const
+{
+    std::ostringstream strm;
+    strm << remover << ':' << _title;
+    return strm.str();
+}
+
+std::string CalendarEvent::BuildCalendarMailBody() const
+{
+    WorldPacket data;
+    uint32 time;
+    std::ostringstream strm;
+
+    // we are supposed to send PackedTime so i used WorldPacket to pack it
+    data.AppendPackedTime(_eventTime);
+    data >> time;
+    strm << time;
+    return strm.str();
+}
+
+void CalendarMgr::SendCalendarEventInvite(CalendarInvite const& invite)
+{
+    CalendarEvent* calendarEvent = GetEvent(invite.GetEventId());
+    time_t statusTime = invite.GetStatusTime();
+    bool hasStatusTime = statusTime != 946684800;   // 01/01/2000 00:00:00
+
+    uint64 invitee = invite.GetInviteeGUID();
+    Player* player = ObjectAccessor::FindPlayerInOrOutOfWorld(invitee);
+
+    uint8 level = player ? player->getLevel() : Player::GetLevelFromStorage(invitee);
+
+    WorldPacket data(SMSG_CALENDAR_EVENT_INVITE, 8 + 8 + 8 + 1 + 1 + 1 + (statusTime ? 4 : 0) + 1);
+    data.appendPackGUID(invitee);
+    data << uint64(invite.GetEventId());
+    data << uint64(invite.GetInviteId());
+    data << uint8(level);
+    data << uint8(invite.GetStatus());
+    data << uint8(hasStatusTime);
+    if (hasStatusTime)
+        data.AppendPackedTime(statusTime);
+    data << uint8(invite.GetSenderGUID() != invite.GetInviteeGUID()); // false only if the invite is sign-up
+
+    if (!calendarEvent) // Pre-invite
+    {
+        if (Player* player = ObjectAccessor::FindPlayerInOrOutOfWorld(invite.GetSenderGUID()))
+            player->SendDirectMessage(&data);
+    }
+    else
+    {
+        if (calendarEvent->GetCreatorGUID() != invite.GetInviteeGUID()) // correct?
+            SendPacketToAllEventRelatives(data, *calendarEvent);
+    }
+}
+
+void CalendarMgr::SendCalendarEventUpdateAlert(CalendarEvent const& calendarEvent, time_t oldEventTime)
+{
+    WorldPacket data(SMSG_CALENDAR_EVENT_UPDATED_ALERT, 1 + 8 + 4 + 4 + 4 + 1 + 4 +
+        calendarEvent.GetTitle().size() + calendarEvent.GetDescription().size() + 1 + 4 + 4);
+    data << uint8(1);       // unk
+    data << uint64(calendarEvent.GetEventId());
+    data.AppendPackedTime(oldEventTime);
+    data << uint32(calendarEvent.GetFlags());
+    data.AppendPackedTime(calendarEvent.GetEventTime());
+    data << uint8(calendarEvent.GetType());
+    data << int32(calendarEvent.GetDungeonId());
+    data << calendarEvent.GetTitle();
+    data << calendarEvent.GetDescription();
+    data << uint8(CALENDAR_REPEAT_NEVER);   // repeatable
+    data << uint32(CALENDAR_MAX_INVITES);
+    data << uint32(0);      // unk
+
+    SendPacketToAllEventRelatives(data, calendarEvent);
+}
+
+void CalendarMgr::SendCalendarEventStatus(CalendarEvent const& calendarEvent, CalendarInvite const& invite)
+{
+    WorldPacket data(SMSG_CALENDAR_EVENT_STATUS, 8 + 8 + 4 + 4 + 1 + 1 + 4);
+    data.appendPackGUID(invite.GetInviteeGUID());
+    data << uint64(calendarEvent.GetEventId());
+    data.AppendPackedTime(calendarEvent.GetEventTime());
+    data << uint32(calendarEvent.GetFlags());
+    data << uint8(invite.GetStatus());
+    data << uint8(invite.GetRank());
+    data.AppendPackedTime(invite.GetStatusTime());
+
+    SendPacketToAllEventRelatives(data, calendarEvent);
+}
+
+void CalendarMgr::SendCalendarEventRemovedAlert(CalendarEvent const& calendarEvent)
+{
+    WorldPacket data(SMSG_CALENDAR_EVENT_REMOVED_ALERT, 1 + 8 + 1);
+    data << uint8(1); // FIXME: If true does not SignalEvent(EVENT_CALENDAR_ACTION_PENDING)
+    data << uint64(calendarEvent.GetEventId());
+    data.AppendPackedTime(calendarEvent.GetEventTime());
+
+    SendPacketToAllEventRelatives(data, calendarEvent);
+}
+
+void CalendarMgr::SendCalendarEventInviteRemove(CalendarEvent const& calendarEvent, CalendarInvite const& invite, uint32 flags)
+{
+    WorldPacket data(SMSG_CALENDAR_EVENT_INVITE_REMOVED, 8 + 4 + 4 + 1);
+    data.appendPackGUID(invite.GetInviteeGUID());
+    data << uint64(invite.GetEventId());
+    data << uint32(flags);
+    data << uint8(1); // FIXME
+
+    SendPacketToAllEventRelatives(data, calendarEvent);
+}
+
+void CalendarMgr::SendCalendarEventModeratorStatusAlert(CalendarEvent const& calendarEvent, CalendarInvite const& invite)
+{
+    WorldPacket data(SMSG_CALENDAR_EVENT_MODERATOR_STATUS_ALERT, 8 + 8 + 1 + 1);
+    data.appendPackGUID(invite.GetInviteeGUID());
+    data << uint64(invite.GetEventId());
+    data << uint8(invite.GetRank());
+    data << uint8(1); // Unk boolean - Display to client?
+
+    SendPacketToAllEventRelatives(data, calendarEvent);
+}
+
+void CalendarMgr::SendCalendarEventInviteAlert(CalendarEvent const& calendarEvent, CalendarInvite const& invite)
+{
+    WorldPacket data(SMSG_CALENDAR_EVENT_INVITE_ALERT);
+    data << uint64(calendarEvent.GetEventId());
+    data << calendarEvent.GetTitle();
+    data.AppendPackedTime(calendarEvent.GetEventTime());
+    data << uint32(calendarEvent.GetFlags());
+    data << uint32(calendarEvent.GetType());
+    data << int32(calendarEvent.GetDungeonId());
+    data << uint64(invite.GetInviteId());
+    data << uint8(invite.GetStatus());
+    data << uint8(invite.GetRank());
+    data.appendPackGUID(calendarEvent.GetCreatorGUID());
+    data.appendPackGUID(invite.GetSenderGUID());
+
+    if (calendarEvent.IsGuildEvent() || calendarEvent.IsGuildAnnouncement())
+    {
+        if (Guild* guild = sGuildMgr->GetGuildById(calendarEvent.GetGuildId()))
+            guild->BroadcastPacket(&data);
+    }
+    else
+        if (Player* player = ObjectAccessor::FindPlayerInOrOutOfWorld(invite.GetInviteeGUID()))
+            player->SendDirectMessage(&data);
+}
+
+void CalendarMgr::SendCalendarEvent(uint64 guid, CalendarEvent const& calendarEvent, CalendarSendEventType sendType)
+{
+    Player* player = ObjectAccessor::FindPlayerInOrOutOfWorld(guid);
+    if (!player)
+        return;
+
+    CalendarInviteStore const& eventInviteeList = _invites[calendarEvent.GetEventId()];
+
+    WorldPacket data(SMSG_CALENDAR_SEND_EVENT, 60 + eventInviteeList.size() * 32);
+    data << uint8(sendType);
+    data.appendPackGUID(calendarEvent.GetCreatorGUID());
+    data << uint64(calendarEvent.GetEventId());
+    data << calendarEvent.GetTitle();
+    data << calendarEvent.GetDescription();
+    data << uint8(calendarEvent.GetType());
+    data << uint8(CALENDAR_REPEAT_NEVER);   // repeatable
+    data << uint32(CALENDAR_MAX_INVITES);
+    data << int32(calendarEvent.GetDungeonId());
+    data << uint32(calendarEvent.GetFlags());
+    data.AppendPackedTime(calendarEvent.GetEventTime());
+    data.AppendPackedTime(calendarEvent.GetTimeZoneTime());
+    data << uint32(calendarEvent.GetGuildId());
+
+    data << uint32(eventInviteeList.size());
+    for (CalendarInviteStore::const_iterator itr = eventInviteeList.begin(); itr != eventInviteeList.end(); ++itr)
+    {
+        CalendarInvite const* calendarInvite = (*itr);
+        uint64 inviteeGuid = calendarInvite->GetInviteeGUID();
+        Player* invitee = ObjectAccessor::FindPlayerInOrOutOfWorld(inviteeGuid);
+
+        uint8 inviteeLevel = invitee ? invitee->getLevel() : Player::GetLevelFromStorage(inviteeGuid);
+        uint32 inviteeGuildId = invitee ? invitee->GetGuildId() : Player::GetGuildIdFromStorage(GUID_LOPART(inviteeGuid));
+
+        data.appendPackGUID(inviteeGuid);
+        data << uint8(inviteeLevel);
+        data << uint8(calendarInvite->GetStatus());
+        data << uint8(calendarInvite->GetRank());
+        data << uint8(calendarEvent.IsGuildEvent() && calendarEvent.GetGuildId() == inviteeGuildId);
+        data << uint64(calendarInvite->GetInviteId());
+        data.AppendPackedTime(calendarInvite->GetStatusTime());
+        data << calendarInvite->GetText();
+    }
+
+    player->SendDirectMessage(&data);
+}
+
+void CalendarMgr::SendCalendarEventInviteRemoveAlert(uint64 guid, CalendarEvent const& calendarEvent, CalendarInviteStatus status)
+{
+    if (Player* player = ObjectAccessor::FindPlayerInOrOutOfWorld(guid))
+    {
+        WorldPacket data(SMSG_CALENDAR_EVENT_INVITE_REMOVED_ALERT, 8 + 4 + 4 + 1);
+        data << uint64(calendarEvent.GetEventId());
+        data.AppendPackedTime(calendarEvent.GetEventTime());
+        data << uint32(calendarEvent.GetFlags());
+        data << uint8(status);
+
+        player->SendDirectMessage(&data);
+    }
+}
+
+void CalendarMgr::SendCalendarClearPendingAction(uint64 guid)
+{
+    if (Player* player = ObjectAccessor::FindPlayerInOrOutOfWorld(guid))
+    {
+        WorldPacket data(SMSG_CALENDAR_CLEAR_PENDING_ACTION, 0);
+        player->SendDirectMessage(&data);
+    }
+}
+
+void CalendarMgr::SendCalendarCommandResult(uint64 guid, CalendarError err, char const* param /*= NULL*/)
+{
+    if (Player* player = ObjectAccessor::FindPlayerInOrOutOfWorld(guid))
+    {
+        WorldPacket data(SMSG_CALENDAR_COMMAND_RESULT, 0);
+        data << uint32(0);
+        data << uint8(0);
+        switch (err)
+        {
+            case CALENDAR_ERROR_OTHER_INVITES_EXCEEDED:
+            case CALENDAR_ERROR_ALREADY_INVITED_TO_EVENT_S:
+            case CALENDAR_ERROR_IGNORING_YOU_S:
+                data << param;
+                break;
+            default:
+                data << uint8(0);
+                break;
+        }
+
+        data << uint32(err);
+
+        player->SendDirectMessage(&data);
+    }
+}
+
+void CalendarMgr::SendPacketToAllEventRelatives(WorldPacket packet, CalendarEvent const& calendarEvent)
+{
+    // Send packet to all guild members
+    if (calendarEvent.IsGuildEvent() || calendarEvent.IsGuildAnnouncement())
+        if (Guild* guild = sGuildMgr->GetGuildById(calendarEvent.GetGuildId()))
+            guild->BroadcastPacket(&packet);
+
+    // Send packet to all invitees if event is non-guild, in other case only to non-guild invitees (packet was broadcasted for them)
+    CalendarInviteStore invites = _invites[calendarEvent.GetEventId()];
+    for (CalendarInviteStore::iterator itr = invites.begin(); itr != invites.end(); ++itr)
+        if (Player* player = ObjectAccessor::FindPlayerInOrOutOfWorld((*itr)->GetInviteeGUID()))
+            if (!calendarEvent.IsGuildEvent() || (calendarEvent.IsGuildEvent() && player->GetGuildId() != calendarEvent.GetGuildId()))
+                player->SendDirectMessage(&packet);
+}

src/server/game/Calendar/CalendarMgr.h

@@ -0,0 +1,334 @@
+/*
+ * Copyright (C) 
+ *
+ * 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef TRINITY_CALENDARMGR_H
+#define TRINITY_CALENDARMGR_H
+
+#include <ace/Singleton.h>
+#include "Common.h"
+#include "DatabaseEnv.h"
+#include "WorldPacket.h"
+
+enum CalendarMailAnswers
+{
+    // else
+    CALENDAR_EVENT_REMOVED_MAIL_SUBJECT     = 0,
+    // if ( *(_DWORD *)(a1 + 8292) & 0x100 )
+    CALENDAR_INVITE_REMOVED_MAIL_SUBJECT    = 0x100
+};
+
+enum CalendarFlags
+{
+    CALENDAR_FLAG_ALL_ALLOWED       = 0x001,
+    CALENDAR_FLAG_INVITES_LOCKED    = 0x010,
+    CALENDAR_FLAG_WITHOUT_INVITES   = 0x040,
+    CALENDAR_FLAG_GUILD_EVENT       = 0x400
+};
+
+enum CalendarModerationRank
+{
+    CALENDAR_RANK_PLAYER            = 0,
+    CALENDAR_RANK_MODERATOR         = 1,
+    CALENDAR_RANK_OWNER             = 2
+};
+
+enum CalendarSendEventType
+{
+    CALENDAR_SENDTYPE_GET           = 0,
+    CALENDAR_SENDTYPE_ADD           = 1,
+    CALENDAR_SENDTYPE_COPY          = 2
+};
+
+enum CalendarEventType
+{
+    CALENDAR_TYPE_RAID              = 0,
+    CALENDAR_TYPE_DUNGEON           = 1,
+    CALENDAR_TYPE_PVP               = 2,
+    CALENDAR_TYPE_MEETING           = 3,
+    CALENDAR_TYPE_OTHER             = 4
+};
+
+enum CalendarRepeatType
+{
+    CALENDAR_REPEAT_NEVER           = 0,
+    CALENDAR_REPEAT_WEEKLY          = 1,
+    CALENDAR_REPEAT_BIWEEKLY        = 2,
+    CALENDAR_REPEAT_MONTHLY         = 3
+};
+
+enum CalendarInviteStatus
+{
+    CALENDAR_STATUS_INVITED         = 0,
+    CALENDAR_STATUS_ACCEPTED        = 1,
+    CALENDAR_STATUS_DECLINED        = 2,
+    CALENDAR_STATUS_CONFIRMED       = 3,
+    CALENDAR_STATUS_OUT             = 4,
+    CALENDAR_STATUS_STANDBY         = 5,
+    CALENDAR_STATUS_SIGNED_UP       = 6,
+    CALENDAR_STATUS_NOT_SIGNED_UP   = 7,
+    CALENDAR_STATUS_TENTATIVE       = 8,
+    CALENDAR_STATUS_REMOVED         = 9     // correct name?
+};
+
+enum CalendarError
+{
+    CALENDAR_OK                                 = 0,
+    CALENDAR_ERROR_GUILD_EVENTS_EXCEEDED        = 1,
+    CALENDAR_ERROR_EVENTS_EXCEEDED              = 2,
+    CALENDAR_ERROR_SELF_INVITES_EXCEEDED        = 3,
+    CALENDAR_ERROR_OTHER_INVITES_EXCEEDED       = 4,
+    CALENDAR_ERROR_PERMISSIONS                  = 5,
+    CALENDAR_ERROR_EVENT_INVALID                = 6,
+    CALENDAR_ERROR_NOT_INVITED                  = 7,
+    CALENDAR_ERROR_INTERNAL                     = 8,
+    CALENDAR_ERROR_GUILD_PLAYER_NOT_IN_GUILD    = 9,
+    CALENDAR_ERROR_ALREADY_INVITED_TO_EVENT_S   = 10,
+    CALENDAR_ERROR_PLAYER_NOT_FOUND             = 11,
+    CALENDAR_ERROR_NOT_ALLIED                   = 12,
+    CALENDAR_ERROR_IGNORING_YOU_S               = 13,
+    CALENDAR_ERROR_INVITES_EXCEEDED             = 14,
+    CALENDAR_ERROR_INVALID_DATE                 = 16,
+    CALENDAR_ERROR_INVALID_TIME                 = 17,
+
+    CALENDAR_ERROR_NEEDS_TITLE                  = 19,
+    CALENDAR_ERROR_EVENT_PASSED                 = 20,
+    CALENDAR_ERROR_EVENT_LOCKED                 = 21,
+    CALENDAR_ERROR_DELETE_CREATOR_FAILED        = 22,
+    CALENDAR_ERROR_SYSTEM_DISABLED              = 24,
+    CALENDAR_ERROR_RESTRICTED_ACCOUNT           = 25,
+    CALENDAR_ERROR_ARENA_EVENTS_EXCEEDED        = 26,
+    CALENDAR_ERROR_RESTRICTED_LEVEL             = 27,
+    CALENDAR_ERROR_USER_SQUELCHED               = 28,
+    CALENDAR_ERROR_NO_INVITE                    = 29,
+
+    CALENDAR_ERROR_EVENT_WRONG_SERVER           = 36,
+    CALENDAR_ERROR_INVITE_WRONG_SERVER          = 37,
+    CALENDAR_ERROR_NO_GUILD_INVITES             = 38,
+    CALENDAR_ERROR_INVALID_SIGNUP               = 39,
+    CALENDAR_ERROR_NO_MODERATOR                 = 40
+};
+
+#define CALENDAR_MAX_EVENTS         30
+#define CALENDAR_MAX_GUILD_EVENTS   100
+#define CALENDAR_MAX_INVITES        100
+
+struct CalendarInvite
+{
+    public:
+        CalendarInvite(CalendarInvite const& calendarInvite, uint64 inviteId, uint64 eventId)
+        {
+            _inviteId = inviteId;
+            _eventId = eventId;
+            _invitee = calendarInvite.GetInviteeGUID();
+            _senderGUID = calendarInvite.GetSenderGUID();
+            _statusTime = calendarInvite.GetStatusTime();
+            _status = calendarInvite.GetStatus();
+            _rank = calendarInvite.GetRank();
+            _text = calendarInvite.GetText();
+        }
+
+        CalendarInvite() : _inviteId(1), _eventId(0), _invitee(0), _senderGUID(0), _statusTime(time(NULL)),
+            _status(CALENDAR_STATUS_INVITED), _rank(CALENDAR_RANK_PLAYER), _text("") { }
+
+        CalendarInvite(uint64 inviteId, uint64 eventId, uint64 invitee, uint64 senderGUID, time_t statusTime,
+            CalendarInviteStatus status, CalendarModerationRank rank, std::string text) :
+            _inviteId(inviteId), _eventId(eventId), _invitee(invitee), _senderGUID(senderGUID), _statusTime(statusTime),
+            _status(status), _rank(rank), _text(text) { }
+
+        ~CalendarInvite();
+
+        void SetInviteId(uint64 inviteId) { _inviteId = inviteId; }
+        uint64 GetInviteId() const { return _inviteId; }
+
+        void SetEventId(uint64 eventId) { _eventId = eventId; }
+        uint64 GetEventId() const { return _eventId; }
+
+        void SetSenderGUID(uint64 guid) { _senderGUID = guid; }
+        uint64 GetSenderGUID() const { return _senderGUID; }
+
+        void SetInvitee(uint64 guid) { _invitee = guid; }
+        uint64 GetInviteeGUID() const { return _invitee; }
+
+        void SetStatusTime(time_t statusTime) { _statusTime = statusTime; }
+        time_t GetStatusTime() const { return _statusTime; }
+
+        void SetText(const std::string& text) { _text = text; }
+        std::string GetText() const { return _text; }
+
+        void SetStatus(CalendarInviteStatus status) { _status = status; }
+        CalendarInviteStatus GetStatus() const { return _status; }
+
+        void SetRank(CalendarModerationRank rank) { _rank = rank; }
+        CalendarModerationRank GetRank() const { return _rank; }
+
+    private:
+        uint64 _inviteId;
+        uint64 _eventId;
+        uint64 _invitee;
+        uint64 _senderGUID;
+        time_t _statusTime;
+        CalendarInviteStatus _status;
+        CalendarModerationRank _rank;
+        std::string _text;
+};
+
+struct CalendarEvent
+{
+    public:
+        CalendarEvent(CalendarEvent const& calendarEvent, uint64 eventId)
+        {
+            _eventId = eventId;
+            _creatorGUID = calendarEvent.GetCreatorGUID();
+            _guildId = calendarEvent.GetGuildId();
+            _type = calendarEvent.GetType();
+            _dungeonId = calendarEvent.GetDungeonId();
+            _eventTime = calendarEvent.GetEventTime();
+            _flags = calendarEvent.GetFlags();
+            _timezoneTime = calendarEvent.GetTimeZoneTime();
+            _title = calendarEvent.GetTitle();
+            _description = calendarEvent.GetDescription();
+        }
+
+        CalendarEvent(uint64 eventId, uint64 creatorGUID, uint32 guildId, CalendarEventType type, int32 dungeonId,
+            time_t eventTime, uint32 flags, time_t timezoneTime, std::string title, std::string description) :
+            _eventId(eventId), _creatorGUID(creatorGUID), _guildId(guildId), _type(type), _dungeonId(dungeonId),
+            _eventTime(eventTime), _flags(flags), _timezoneTime(timezoneTime), _title(title),
+            _description(description) { }
+
+        CalendarEvent() : _eventId(1), _creatorGUID(0), _guildId(0), _type(CALENDAR_TYPE_OTHER), _dungeonId(-1), _eventTime(0),
+            _flags(0), _timezoneTime(0), _title(""), _description("") { }
+
+        ~CalendarEvent();
+
+        void SetEventId(uint64 eventId) { _eventId = eventId; }
+        uint64 GetEventId() const { return _eventId; }
+
+        void SetCreatorGUID(uint64 guid) { _creatorGUID = guid; }
+        uint64 GetCreatorGUID() const { return _creatorGUID; }
+
+        void SetGuildId(uint32 guildId) { _guildId = guildId; }
+        uint32 GetGuildId() const { return _guildId; }
+
+        void SetTitle(const std::string& title) { _title = title; }
+        std::string GetTitle() const { return _title; }
+
+        void SetDescription(const std::string& description) { _description = description; }
+        std::string GetDescription() const { return _description; }
+
+        void SetType(CalendarEventType type) { _type = type; }
+        CalendarEventType GetType() const { return _type; }
+
+        void SetDungeonId(int32 dungeonId) { _dungeonId = dungeonId; }
+        int32 GetDungeonId() const { return _dungeonId; }
+
+        void SetEventTime(time_t eventTime) { _eventTime = eventTime; }
+        time_t GetEventTime() const { return _eventTime; }
+
+        void SetFlags(uint32 flags) { _flags = flags; }
+        uint32 GetFlags() const { return _flags; }
+
+        void SetTimeZoneTime(time_t timezoneTime) { _timezoneTime = timezoneTime; }
+        time_t GetTimeZoneTime() const { return _timezoneTime; }
+
+        bool IsGuildEvent() const { return _flags & CALENDAR_FLAG_GUILD_EVENT; }
+        bool IsGuildAnnouncement() const { return _flags & CALENDAR_FLAG_WITHOUT_INVITES; }
+
+        std::string BuildCalendarMailSubject(uint64 remover) const;
+        std::string BuildCalendarMailBody() const;
+
+    private:
+        uint64 _eventId;
+        uint64 _creatorGUID;
+        uint32 _guildId;
+        CalendarEventType _type;
+        int32 _dungeonId;
+        time_t _eventTime;
+        uint32 _flags;
+        time_t _timezoneTime;
+        std::string _title;
+        std::string _description;
+};
+typedef std::vector<CalendarInvite*> CalendarInviteStore;
+typedef UNORDERED_SET<CalendarEvent*> CalendarEventStore;
+typedef UNORDERED_MAP<uint64 /* eventId */, CalendarInviteStore > CalendarEventInviteStore;
+
+class CalendarMgr
+{
+    friend class ACE_Singleton<CalendarMgr, ACE_Null_Mutex>;
+
+    private:
+        CalendarMgr();
+        ~CalendarMgr();
+
+        CalendarEventStore _events;
+        CalendarEventInviteStore _invites;
+
+        std::deque<uint64> _freeEventIds;
+        std::deque<uint64> _freeInviteIds;
+        uint64 _maxEventId;
+        uint64 _maxInviteId;
+
+    public:
+        void LoadFromDB();
+
+        CalendarEvent* GetEvent(uint64 eventId, CalendarEventStore::iterator* it = NULL);
+        CalendarEventStore const& GetEvents() const { return _events; }
+        CalendarEventStore GetPlayerEvents(uint64 guid);
+
+        CalendarInvite* GetInvite(uint64 inviteId) const;
+        CalendarEventInviteStore const& GetInvites() const { return _invites; }
+        CalendarInviteStore const& GetEventInvites(uint64 eventId);
+        CalendarInviteStore GetPlayerInvites(uint64 guid);
+
+        void FreeEventId(uint64 id);
+        uint64 GetFreeEventId();
+        void FreeInviteId(uint64 id);
+        uint64 GetFreeInviteId();
+
+        uint32 GetPlayerNumPending(uint64 guid);
+
+        void AddEvent(CalendarEvent* calendarEvent, CalendarSendEventType sendType);
+        CalendarEventStore::iterator RemoveEvent(uint64 eventId, uint64 remover);
+        void UpdateEvent(CalendarEvent* calendarEvent);
+
+        void AddInvite(CalendarEvent* calendarEvent, CalendarInvite* invite);
+        void AddInvite(CalendarEvent* calendarEvent, CalendarInvite* invite, SQLTransaction& trans);
+        void RemoveInvite(uint64 inviteId, uint64 eventId, uint64 remover);
+        void UpdateInvite(CalendarInvite* invite);
+        void UpdateInvite(CalendarInvite* invite, SQLTransaction& trans);
+
+        void RemoveAllPlayerEventsAndInvites(uint64 guid);
+        void RemovePlayerGuildEventsAndSignups(uint64 guid, uint32 guildId);
+
+        void SendCalendarEvent(uint64 guid, CalendarEvent const& calendarEvent, CalendarSendEventType sendType);
+        void SendCalendarEventInvite(CalendarInvite const& invite);
+        void SendCalendarEventInviteAlert(CalendarEvent const& calendarEvent, CalendarInvite const& invite);
+        void SendCalendarEventInviteRemove(CalendarEvent const& calendarEvent, CalendarInvite const& invite, uint32 flags);
+        void SendCalendarEventInviteRemoveAlert(uint64 guid, CalendarEvent const& calendarEvent, CalendarInviteStatus status);
+        void SendCalendarEventUpdateAlert(CalendarEvent const& calendarEvent, time_t oldEventTime);
+        void SendCalendarEventStatus(CalendarEvent const& calendarEvent, CalendarInvite const& invite);
+        void SendCalendarEventRemovedAlert(CalendarEvent const& calendarEvent);
+        void SendCalendarEventModeratorStatusAlert(CalendarEvent const& calendarEvent, CalendarInvite const& invite);
+        void SendCalendarClearPendingAction(uint64 guid);
+        void SendCalendarCommandResult(uint64 guid, CalendarError err, char const* param = NULL);
+
+        void SendPacketToAllEventRelatives(WorldPacket packet, CalendarEvent const& calendarEvent);
+};
+
+#define sCalendarMgr ACE_Singleton<CalendarMgr, ACE_Null_Mutex>::instance()
+
+#endif

src/server/game/Chat/Channels/Channel.h

@@ -0,0 +1,343 @@
+/*
+ * Copyright (C) 
+ * Copyright (C) 
+ *
+ * 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef _CHANNEL_H
+#define _CHANNEL_H
+
+#include <list>
+#include <map>
+#include <string>
+
+#include "Common.h"
+
+#include "Opcodes.h"
+#include "WorldPacket.h"
+
+class Player;
+
+#define CHANNEL_BAN_DURATION			DAY*60
+
+enum ChatNotify
+{
+    CHAT_JOINED_NOTICE                = 0x00,           //+ "%s joined channel.";
+    CHAT_LEFT_NOTICE                  = 0x01,           //+ "%s left channel.";
+    //CHAT_SUSPENDED_NOTICE             = 0x01,           // "%s left channel.";
+    CHAT_YOU_JOINED_NOTICE            = 0x02,           //+ "Joined Channel: [%s]"; -- You joined
+    //CHAT_YOU_CHANGED_NOTICE           = 0x02,           // "Changed Channel: [%s]";
+    CHAT_YOU_LEFT_NOTICE              = 0x03,           //+ "Left Channel: [%s]"; -- You left
+    CHAT_WRONG_PASSWORD_NOTICE        = 0x04,           //+ "Wrong password for %s.";
+    CHAT_NOT_MEMBER_NOTICE            = 0x05,           //+ "Not on channel %s.";
+    CHAT_NOT_MODERATOR_NOTICE         = 0x06,           //+ "Not a moderator of %s.";
+    CHAT_PASSWORD_CHANGED_NOTICE      = 0x07,           //+ "[%s] Password changed by %s.";
+    CHAT_OWNER_CHANGED_NOTICE         = 0x08,           //+ "[%s] Owner changed to %s.";
+    CHAT_PLAYER_NOT_FOUND_NOTICE      = 0x09,           //+ "[%s] Player %s was not found.";
+    CHAT_NOT_OWNER_NOTICE             = 0x0A,           //+ "[%s] You are not the channel owner.";
+    CHAT_CHANNEL_OWNER_NOTICE         = 0x0B,           //+ "[%s] Channel owner is %s.";
+    CHAT_MODE_CHANGE_NOTICE           = 0x0C,           //?
+    CHAT_ANNOUNCEMENTS_ON_NOTICE      = 0x0D,           //+ "[%s] Channel announcements enabled by %s.";
+    CHAT_ANNOUNCEMENTS_OFF_NOTICE     = 0x0E,           //+ "[%s] Channel announcements disabled by %s.";
+    // CHAT_MODERATION_ON_NOTICE         = 0x0F,           //+ "[%s] Channel moderation enabled by %s.";
+    // CHAT_MODERATION_OFF_NOTICE        = 0x10,           //+ "[%s] Channel moderation disabled by %s.";
+    CHAT_MUTED_NOTICE                 = 0x11,           //+ "[%s] You do not have permission to speak.";
+    CHAT_PLAYER_KICKED_NOTICE         = 0x12,           //? "[%s] Player %s kicked by %s.";
+    CHAT_BANNED_NOTICE                = 0x13,           //+ "[%s] You are bannedStore from that channel.";
+    CHAT_PLAYER_BANNED_NOTICE         = 0x14,           //? "[%s] Player %s bannedStore by %s.";
+    CHAT_PLAYER_UNBANNED_NOTICE       = 0x15,           //? "[%s] Player %s unbanned by %s.";
+    CHAT_PLAYER_NOT_BANNED_NOTICE     = 0x16,           //+ "[%s] Player %s is not bannedStore.";
+    CHAT_PLAYER_ALREADY_MEMBER_NOTICE = 0x17,           //+ "[%s] Player %s is already on the channel.";
+    CHAT_INVITE_NOTICE                = 0x18,           //+ "%2$s has invited you to join the channel '%1$s'.";
+    CHAT_INVITE_WRONG_FACTION_NOTICE  = 0x19,           //+ "Target is in the wrong alliance for %s.";
+    CHAT_WRONG_FACTION_NOTICE         = 0x1A,           //+ "Wrong alliance for %s.";
+    CHAT_INVALID_NAME_NOTICE          = 0x1B,           //+ "Invalid channel name";
+    CHAT_NOT_MODERATED_NOTICE         = 0x1C,           //+ "%s is not moderated";
+    CHAT_PLAYER_INVITED_NOTICE        = 0x1D,           //+ "[%s] You invited %s to join the channel";
+    CHAT_PLAYER_INVITE_BANNED_NOTICE  = 0x1E,           //+ "[%s] %s has been bannedStore.";
+    CHAT_THROTTLED_NOTICE             = 0x1F,           //+ "[%s] The number of messages that can be sent to this channel is limited, please wait to send another message.";
+    CHAT_NOT_IN_AREA_NOTICE           = 0x20,           //+ "[%s] You are not in the correct area for this channel."; -- The user is trying to send a chat to a zone specific channel, and they're not physically in that zone.
+    CHAT_NOT_IN_LFG_NOTICE            = 0x21,           //+ "[%s] You must be queued in looking for group before joining this channel."; -- The user must be in the looking for group system to join LFG chat channels.
+    CHAT_VOICE_ON_NOTICE              = 0x22,           //+ "[%s] Channel voice enabled by %s.";
+    CHAT_VOICE_OFF_NOTICE             = 0x23            //+ "[%s] Channel voice disabled by %s.";
+};
+
+enum ChannelFlags
+{
+    CHANNEL_FLAG_NONE       = 0x00,
+    CHANNEL_FLAG_CUSTOM     = 0x01,
+    // 0x02
+    CHANNEL_FLAG_TRADE      = 0x04,
+    CHANNEL_FLAG_NOT_LFG    = 0x08,
+    CHANNEL_FLAG_GENERAL    = 0x10,
+    CHANNEL_FLAG_CITY       = 0x20,
+    CHANNEL_FLAG_LFG        = 0x40,
+    CHANNEL_FLAG_VOICE      = 0x80
+    // General                  0x18 = 0x10 | 0x08
+    // Trade                    0x3C = 0x20 | 0x10 | 0x08 | 0x04
+    // LocalDefence             0x18 = 0x10 | 0x08
+    // GuildRecruitment         0x38 = 0x20 | 0x10 | 0x08
+    // LookingForGroup          0x50 = 0x40 | 0x10
+};
+
+enum ChannelDBCFlags
+{
+    CHANNEL_DBC_FLAG_NONE       = 0x00000,
+    CHANNEL_DBC_FLAG_INITIAL    = 0x00001,              // General, Trade, LocalDefense, LFG
+    CHANNEL_DBC_FLAG_ZONE_DEP   = 0x00002,              // General, Trade, LocalDefense, GuildRecruitment
+    CHANNEL_DBC_FLAG_GLOBAL     = 0x00004,              // WorldDefense
+    CHANNEL_DBC_FLAG_TRADE      = 0x00008,              // Trade, LFG
+    CHANNEL_DBC_FLAG_CITY_ONLY  = 0x00010,              // Trade, GuildRecruitment, LFG
+    CHANNEL_DBC_FLAG_CITY_ONLY2 = 0x00020,              // Trade, GuildRecruitment, LFG
+    CHANNEL_DBC_FLAG_DEFENSE    = 0x10000,              // LocalDefense, WorldDefense
+    CHANNEL_DBC_FLAG_GUILD_REQ  = 0x20000,              // GuildRecruitment
+    CHANNEL_DBC_FLAG_LFG        = 0x40000,              // LFG
+    CHANNEL_DBC_FLAG_UNK1       = 0x80000               // General
+};
+
+enum ChannelMemberFlags
+{
+    MEMBER_FLAG_NONE        = 0x00,
+    MEMBER_FLAG_OWNER       = 0x01,
+    MEMBER_FLAG_MODERATOR   = 0x02,
+    MEMBER_FLAG_VOICED      = 0x04,
+    MEMBER_FLAG_MUTED       = 0x08,
+    MEMBER_FLAG_CUSTOM      = 0x10,
+    MEMBER_FLAG_MIC_MUTED   = 0x20
+    // 0x40
+    // 0x80
+};
+
+class ChannelRights
+{
+public:
+	ChannelRights() : flags(0), speakDelay(0) {}
+	ChannelRights(const uint32& f, const uint32& d, const std::string& jm, const std::string& sm, const std::set<uint32>& ml) : flags(f), speakDelay(d), joinMessage(jm), speakMessage(sm), moderators(ml) {}
+	uint32 flags;
+	uint32 speakDelay;
+	std::string joinMessage;
+	std::string speakMessage;
+	std::set<uint32> moderators;
+};
+
+enum eChannelRights
+{
+	CHANNEL_RIGHT_FORCE_NO_ANNOUNCEMENTS	= 0x001,
+	CHANNEL_RIGHT_FORCE_ANNOUNCEMENTS		= 0x002,
+	CHANNEL_RIGHT_NO_OWNERSHIP				= 0x004,
+	CHANNEL_RIGHT_CANT_SPEAK				= 0x008,
+	CHANNEL_RIGHT_CANT_BAN					= 0x010,
+	CHANNEL_RIGHT_CANT_KICK					= 0x020,
+	CHANNEL_RIGHT_CANT_MUTE					= 0x040,
+	CHANNEL_RIGHT_CANT_CHANGE_PASSWORD		= 0x080,
+	CHANNEL_RIGHT_DONT_PRESERVE				= 0x100,
+};
+
+class Channel
+{
+    struct PlayerInfo
+    {
+        uint64 player;
+        uint8 flags;
+        uint32 lastSpeakTime; // pussywizard
+        Player* plrPtr; // pussywizard
+
+        bool HasFlag(uint8 flag) const { return flags & flag; }
+        void SetFlag(uint8 flag) { if (!HasFlag(flag)) flags |= flag; }
+        bool IsOwner() const { return flags & MEMBER_FLAG_OWNER; }
+        void SetOwner(bool state)
+        {
+            if (state) flags |= MEMBER_FLAG_OWNER;
+            else flags &= ~MEMBER_FLAG_OWNER;
+        }
+        bool IsModerator() const { return flags & MEMBER_FLAG_MODERATOR; }
+        void SetModerator(bool state)
+        {
+            if (state) flags |= MEMBER_FLAG_MODERATOR;
+            else flags &= ~MEMBER_FLAG_MODERATOR;
+        }
+        bool IsMuted() const { return flags & MEMBER_FLAG_MUTED; }
+        void SetMuted(bool state)
+        {
+            if (state) flags |= MEMBER_FLAG_MUTED;
+            else flags &= ~MEMBER_FLAG_MUTED;
+        }
+        bool IsAllowedToSpeak(uint32 speakDelay) // pussywizard
+        {
+            if (lastSpeakTime+speakDelay <= sWorld->GetGameTime())
+            {
+                lastSpeakTime = sWorld->GetGameTime();
+                return true;
+            }
+            else
+                return false;
+        }
+    };
+
+    public:
+        Channel(std::string const& name, uint32 channel_id, uint32 channelDBId, TeamId teamId = TEAM_NEUTRAL, bool announce = true);
+        std::string const& GetName() const { return _name; }
+        uint32 GetChannelId() const { return _channelId; }
+        bool IsConstant() const { return _channelId != 0; }
+        bool IsAnnounce() const { return _announce; }
+        bool IsLFG() const { return GetFlags() & CHANNEL_FLAG_LFG; }
+        std::string const& GetPassword() const { return _password; }
+        void SetPassword(std::string const& npassword) { _password = npassword; }
+        uint32 GetNumPlayers() const { return playersStore.size(); }
+        uint8 GetFlags() const { return _flags; }
+        bool HasFlag(uint8 flag) const { return _flags & flag; }
+
+        void JoinChannel(Player* player, std::string const& pass);
+        void LeaveChannel(Player* player, bool send = true);
+        void KickOrBan(Player const* player, std::string const& badname, bool ban);
+        void Kick(Player const* player, std::string const& badname) { KickOrBan(player, badname, false); }
+        void Ban(Player const* player, std::string const& badname) { KickOrBan(player, badname, true); }
+		void AddBan(uint32 guid, uint32 time) { bannedStore[guid] = time; }
+        void UnBan(Player const* player, std::string const& badname);
+        void UnBan(uint64 guid);
+        void Password(Player const* player, std::string const& pass);
+        void SetMode(Player const* player, std::string const& p2n, bool mod, bool set);
+        void SetOwner(uint64 guid, bool exclaim = true);
+        void SetOwner(Player const* player, std::string const& name);
+        void SendWhoOwner(uint64 guid);
+        void SetModerator(Player const* player, std::string const& newname) { SetMode(player, newname, true, true); }
+        void UnsetModerator(Player const* player, std::string const& newname) { SetMode(player, newname, true, false); }
+        void SetMute(Player const* player, std::string const& newname) { SetMode(player, newname, false, true); }
+        void UnsetMute(Player const* player, std::string const& newname) { SetMode(player, newname, false, false); }
+        void List(Player const* player);
+        void Announce(Player const* player);
+        void Say(uint64 guid, std::string const& what, uint32 lang);
+		void EveryoneSayToSelf(const char *what);
+        void Invite(Player const* player, std::string const& newp);
+        void Voice(uint64 guid1, uint64 guid2);
+        void DeVoice(uint64 guid1, uint64 guid2);
+        void JoinNotify(Player* p);
+        void LeaveNotify(Player* p);
+        void FlagsNotify(Player* p);
+        static void CleanOldChannelsInDB();
+
+		// pussywizard:
+		void AddWatching(Player* p);
+		void RemoveWatching(Player* p);
+
+    private:
+        // initial packet data (notify type and channel name)
+        void MakeNotifyPacket(WorldPacket* data, uint8 notify_type);
+        // type specific packet data
+        void MakeJoined(WorldPacket* data, uint64 guid);                        //+ 0x00
+        void MakeLeft(WorldPacket* data, uint64 guid);                          //+ 0x01
+        void MakeYouJoined(WorldPacket* data);                                  //+ 0x02
+        void MakeYouLeft(WorldPacket* data);                                    //+ 0x03
+        void MakeWrongPassword(WorldPacket* data);                              //? 0x04
+        void MakeNotMember(WorldPacket* data);                                  //? 0x05
+        void MakeNotModerator(WorldPacket* data);                               //? 0x06
+        void MakePasswordChanged(WorldPacket* data, uint64 guid);               //+ 0x07
+        void MakeOwnerChanged(WorldPacket* data, uint64 guid);                  //? 0x08
+        void MakePlayerNotFound(WorldPacket* data, std::string const& name);   //+ 0x09
+        void MakeNotOwner(WorldPacket* data);                                   //? 0x0A
+        void MakeChannelOwner(WorldPacket* data);                               //? 0x0B
+        void MakeModeChange(WorldPacket* data, uint64 guid, uint8 oldflags);    //+ 0x0C
+        void MakeAnnouncementsOn(WorldPacket* data, uint64 guid);               //+ 0x0D
+        void MakeAnnouncementsOff(WorldPacket* data, uint64 guid);              //+ 0x0E
+        void MakeMuted(WorldPacket* data);                                      //? 0x11
+        void MakePlayerKicked(WorldPacket* data, uint64 bad, uint64 good);      //? 0x12
+        void MakeBanned(WorldPacket* data);                                     //? 0x13
+        void MakePlayerBanned(WorldPacket* data, uint64 bad, uint64 good);      //? 0x14
+        void MakePlayerUnbanned(WorldPacket* data, uint64 bad, uint64 good);    //? 0x15
+        void MakePlayerNotBanned(WorldPacket* data, std::string const& name);  //? 0x16
+        void MakePlayerAlreadyMember(WorldPacket* data, uint64 guid);           //+ 0x17
+        void MakeInvite(WorldPacket* data, uint64 guid);                        //? 0x18
+        void MakeInviteWrongFaction(WorldPacket* data);                         //? 0x19
+        void MakeWrongFaction(WorldPacket* data);                               //? 0x1A
+        void MakeInvalidName(WorldPacket* data);                                //? 0x1B
+        void MakeNotModerated(WorldPacket* data);                               //? 0x1C
+        void MakePlayerInvited(WorldPacket* data, std::string const& name);     //+ 0x1D
+        void MakePlayerInviteBanned(WorldPacket* data, std::string const& name);//? 0x1E
+        void MakeThrottled(WorldPacket* data);                                  //? 0x1F
+        void MakeNotInArea(WorldPacket* data);                                  //? 0x20
+        void MakeNotInLfg(WorldPacket* data);                                   //? 0x21
+        void MakeVoiceOn(WorldPacket* data, uint64 guid);                       //+ 0x22
+        void MakeVoiceOff(WorldPacket* data, uint64 guid);                      //+ 0x23
+
+        void SendToAll(WorldPacket* data, uint64 guid = 0);
+        void SendToAllButOne(WorldPacket* data, uint64 who);
+        void SendToOne(WorldPacket* data, uint64 who);
+        void SendToAllWatching(WorldPacket* data);
+
+        bool IsOn(uint64 who) const { return playersStore.find(who) != playersStore.end(); }
+        bool IsBanned(uint64 guid) const;
+
+        void UpdateChannelInDB() const;
+        void UpdateChannelUseageInDB() const;
+		void AddChannelBanToDB(uint32 guid, uint32 time) const;
+		void RemoveChannelBanFromDB(uint32 guid) const;
+
+        uint8 GetPlayerFlags(uint64 guid) const
+        {
+            PlayerContainer::const_iterator itr = playersStore.find(guid);
+            return itr != playersStore.end() ? itr->second.flags : 0;
+        }
+
+        void SetModerator(uint64 guid, bool set)
+        {
+            PlayerInfo& pinfo = playersStore[guid];
+            if (pinfo.IsModerator() != set)
+            {
+                uint8 oldFlag = pinfo.flags;
+                pinfo.SetModerator(set);
+
+                WorldPacket data;
+                MakeModeChange(&data, guid, oldFlag);
+                SendToAll(&data);
+
+                FlagsNotify(pinfo.plrPtr);
+            }
+        }
+
+        void SetMute(uint64 guid, bool set)
+        {
+            PlayerInfo& pinfo = playersStore[guid];
+            if (pinfo.IsMuted() != set)
+            {
+                uint8 oldFlag = pinfo.flags;
+                pinfo.SetMuted(set);
+
+                WorldPacket data;
+                MakeModeChange(&data, guid, oldFlag);
+                SendToAll(&data);
+            }
+        }
+
+        typedef UNORDERED_MAP<uint64, PlayerInfo> PlayerContainer;
+        typedef UNORDERED_MAP<uint32, uint32> BannedContainer;
+        typedef UNORDERED_SET<Player*> PlayersWatchingContainer;
+
+        bool _announce;
+        bool _ownership;
+        bool _IsSaved;
+        uint8 _flags;
+        uint32 _channelId;
+		uint32 _channelDBId;
+        TeamId _teamId;
+        uint64 _ownerGUID;
+        std::string _name;
+        std::string _password;
+        ChannelRights _channelRights;
+        PlayerContainer playersStore;
+        BannedContainer bannedStore;
+        PlayersWatchingContainer playersWatchingStore;
+};
+#endif
+

src/server/game/Chat/Channels/ChannelMgr.cpp

@@ -0,0 +1,201 @@
+/*
+ * Copyright (C) 
+ * Copyright (C) 
+ *
+ * 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "ChannelMgr.h"
+#include "Player.h"
+#include "World.h"
+
+ChannelMgr::~ChannelMgr()
+{
+    for (ChannelMap::iterator itr = channels.begin(); itr != channels.end(); ++itr)
+        delete itr->second;
+
+    channels.clear();
+}
+
+ChannelMgr* ChannelMgr::forTeam(TeamId teamId)
+{
+    if (teamId == TEAM_ALLIANCE)
+        return ACE_Singleton<AllianceChannelMgr, ACE_Null_Mutex>::instance();
+
+    if (teamId == TEAM_HORDE)
+        return ACE_Singleton<HordeChannelMgr, ACE_Null_Mutex>::instance();
+
+    return NULL;
+}
+
+
+void ChannelMgr::LoadChannels()
+{
+	uint32 oldMSTime = getMSTime();
+	uint32 count = 0;
+
+	QueryResult result = CharacterDatabase.PQuery("SELECT channelId, name, team, announce, password FROM channels WHERE team = %u ORDER BY channelId ASC", _teamId);
+    if (!result)
+    {
+		sLog->outString(">> Loaded 0 channels for %s", _teamId == TEAM_ALLIANCE ? "Alliance" : "Horde");
+        sLog->outString();
+        return;
+    }
+
+    do
+    {
+        Field* fields = result->Fetch();
+        if (!fields)
+            break;
+
+		uint32 channelDBId = fields[0].GetUInt32();
+		std::string channelName = fields[1].GetString();
+		std::string password = fields[4].GetString();
+		std::wstring channelWName;
+		Utf8toWStr(channelName, channelWName);
+
+		Channel* newChannel = new Channel(channelName, 0, channelDBId, TeamId(fields[2].GetUInt32()), fields[3].GetUInt8());
+		newChannel->SetPassword(password);
+        channels[channelWName] = newChannel;
+
+		if (QueryResult banResult = CharacterDatabase.PQuery("SELECT playerGUID, banTime FROM channels_bans WHERE channelId = %u", channelDBId))
+		{
+			do
+			{
+				Field* banFields = banResult->Fetch();
+				if (!banFields)
+					break;
+				newChannel->AddBan(banFields[0].GetUInt32(), banFields[1].GetUInt32());		
+			}
+			while (banResult->NextRow());
+		}
+
+		if (channelDBId > ChannelMgr::_channelIdMax) 
+			ChannelMgr::_channelIdMax = channelDBId;
+		++count;
+    }
+    while (result->NextRow());
+
+    sLog->outString(">> Loaded %u channels for %s in %ums", count, _teamId == TEAM_ALLIANCE ? "Alliance" : "Horde", GetMSTimeDiffToNow(oldMSTime));
+    sLog->outString();
+}
+
+Channel* ChannelMgr::GetJoinChannel(std::string const& name, uint32 channelId)
+{
+    std::wstring wname;
+    Utf8toWStr(name, wname);
+    wstrToLower(wname);
+
+    ChannelMap::const_iterator i = channels.find(wname);
+
+    if (i == channels.end())
+    {
+        std::string chNameLower = name;
+        std::transform(chNameLower.begin(), chNameLower.end(), chNameLower.begin(), ::tolower);
+        Channel* nchan = new Channel(chNameLower, channelId, 0, _teamId);
+        channels[wname] = nchan;
+        return nchan;
+    }
+
+    return i->second;
+}
+
+Channel* ChannelMgr::GetChannel(std::string const& name, Player* player, bool pkt)
+{
+    std::wstring wname;
+    Utf8toWStr(name, wname);
+    wstrToLower(wname);
+
+    ChannelMap::const_iterator i = channels.find(wname);
+
+    if (i == channels.end())
+    {
+        if (pkt)
+        {
+            WorldPacket data;
+            MakeNotOnPacket(&data, name);
+            player->GetSession()->SendPacket(&data);
+        }
+
+        return NULL;
+    }
+
+    return i->second;
+}
+
+
+uint32 ChannelMgr::_channelIdMax = 0;
+ChannelMgr::ChannelRightsMap ChannelMgr::channels_rights;
+ChannelRights ChannelMgr::channelRightsEmpty;
+
+void ChannelMgr::LoadChannelRights()
+{
+	uint32 oldMSTime = getMSTime();
+	channels_rights.clear();
+
+	QueryResult result = CharacterDatabase.Query("SELECT name, flags, speakdelay, joinmessage, delaymessage, moderators FROM channels_rights");
+	if (!result)
+	{
+		sLog->outString();
+		sLog->outString(">>  Loaded 0 Channel Rights!");
+		return;
+	}
+
+	uint32 count = 0;
+	do
+	{
+		Field* fields = result->Fetch();
+		std::set<uint32> moderators;
+		const char* moderatorList = fields[5].GetCString();
+		if (moderatorList)
+		{
+			Tokenizer tokens(moderatorList, ' ');
+			for (Tokenizer::const_iterator i = tokens.begin(); i != tokens.end(); ++i)
+			{
+				uint64 moderator_acc = atol(*i);
+				if (moderator_acc && ((uint32)moderator_acc) == moderator_acc)
+					moderators.insert((uint32)moderator_acc);
+			}
+		}
+
+		SetChannelRightsFor(fields[0].GetString(), fields[1].GetUInt32(), fields[2].GetUInt32(), fields[3].GetString(), fields[4].GetString(), moderators);
+
+		++count;
+	} while (result->NextRow());
+
+	sLog->outString(">> Loaded %d Channel Rights in %u ms", count, GetMSTimeDiffToNow(oldMSTime));
+	sLog->outString();
+}
+
+const ChannelRights& ChannelMgr::GetChannelRightsFor(const std::string& name)
+{
+	std::string nameStr = name;
+	std::transform(nameStr.begin(), nameStr.end(), nameStr.begin(), ::tolower);
+	ChannelRightsMap::const_iterator itr = channels_rights.find(nameStr);
+	if (itr != channels_rights.end())
+		return itr->second;
+	return channelRightsEmpty;
+}
+
+void ChannelMgr::SetChannelRightsFor(const std::string& name, const uint32& flags, const uint32& speakDelay, const std::string& joinmessage, const std::string& speakmessage, const std::set<uint32>& moderators)
+{
+	std::string nameStr = name;
+	std::transform(nameStr.begin(), nameStr.end(), nameStr.begin(), ::tolower);
+	channels_rights[nameStr] = ChannelRights(flags, speakDelay, joinmessage, speakmessage, moderators);
+}
+
+void ChannelMgr::MakeNotOnPacket(WorldPacket* data, std::string const& name)
+{
+    data->Initialize(SMSG_CHANNEL_NOTIFY, 1 + name.size());
+    (*data) << uint8(5) << name;

src/server/game/Chat/Channels/ChannelMgr.h

@@ -0,0 +1,66 @@
+/*
+ * Copyright (C) 
+ * Copyright (C) 
+ *
+ * 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, see <http://www.gnu.org/licenses/>.
+ */
+#ifndef __TRINITY_CHANNELMGR_H
+#define __TRINITY_CHANNELMGR_H
+
+#include "Common.h"
+#include "Channel.h"
+#include <ace/Singleton.h>
+
+#include <map>
+#include <string>
+
+#include "World.h"
+
+#define MAX_CHANNEL_PASS_STR 31
+
+class ChannelMgr
+{
+    typedef UNORDERED_MAP<std::wstring, Channel*> ChannelMap;
+    typedef std::map<std::string, ChannelRights> ChannelRightsMap;
+
+    public:
+        ChannelMgr(TeamId teamId) : _teamId(teamId)
+        { }
+
+        ~ChannelMgr();
+
+        static ChannelMgr * forTeam(TeamId teamId);
+
+        Channel* GetJoinChannel(std::string const& name, uint32 channel_id);
+        Channel* GetChannel(std::string const& name, Player* p, bool pkt = true);
+		void LoadChannels();
+
+        static void LoadChannelRights();
+        static const ChannelRights& GetChannelRightsFor(const std::string& name);
+        static void SetChannelRightsFor(const std::string& name, const uint32& flags, const uint32& speakDelay, const std::string& joinmessage, const std::string& speakmessage, const std::set<uint32>& moderators);
+		static uint32 _channelIdMax;
+
+    private:
+        ChannelMap channels;
+        TeamId _teamId;
+        static ChannelRightsMap channels_rights;
+        static ChannelRights channelRightsEmpty; // when not found in the map, reference to this is returned
+
+        void MakeNotOnPacket(WorldPacket* data, std::string const& name);
+};
+
+class AllianceChannelMgr : public ChannelMgr { public: AllianceChannelMgr() : ChannelMgr(TEAM_ALLIANCE) {} };
+class HordeChannelMgr    : public ChannelMgr { public: HordeChannelMgr() : ChannelMgr(TEAM_HORDE) {} };
+
+#endif

src/server/game/Chat/Chat.h

@@ -0,0 +1,162 @@
+/*
+ * Copyright (C) 
+ * Copyright (C) 
+ *
+ * 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef SUNWELLCORE_CHAT_H
+#define SUNWELLCORE_CHAT_H
+
+#include "SharedDefines.h"
+#include "WorldSession.h"
+
+#include <vector>
+
+class ChatHandler;
+class Creature;
+class Group;
+class Player;
+class Unit;
+class WorldSession;
+class WorldObject;
+
+struct GameTele;
+
+class ChatCommand
+{
+    public:
+        const char *       Name;
+        uint32             SecurityLevel;                   // function pointer required correct align (use uint32)
+        bool               AllowConsole;
+        bool (*Handler)(ChatHandler*, const char* args);
+        std::string        Help;
+        ChatCommand*      ChildCommands;
+};
+
+class ChatHandler
+{
+    public:
+        WorldSession* GetSession() { return m_session; }
+        explicit ChatHandler(WorldSession* session) : m_session(session), sentErrorMessage(false) {}
+        virtual ~ChatHandler() { }
+
+        // Builds chat packet and returns receiver guid position in the packet to substitute in whisper builders
+        static size_t BuildChatPacket(WorldPacket& data, ChatMsg chatType, Language language, uint64 senderGUID, uint64 receiverGUID, std::string const& message, uint8 chatTag,
+                                    std::string const& senderName = "", std::string const& receiverName = "",
+                                    uint32 achievementId = 0, bool gmMessage = false, std::string const& channelName = "");
+
+        // Builds chat packet and returns receiver guid position in the packet to substitute in whisper builders
+        static size_t BuildChatPacket(WorldPacket& data, ChatMsg chatType, Language language, WorldObject const* sender, WorldObject const* receiver, std::string const& message, uint32 achievementId = 0, std::string const& channelName = "", LocaleConstant locale = DEFAULT_LOCALE);
+
+        static char* LineFromMessage(char*& pos) { char* start = strtok(pos, "\n"); pos = NULL; return start; }
+
+        // function with different implementation for chat/console
+        virtual const char *GetTrinityString(int32 entry) const;
+        virtual void SendSysMessage(const char *str);
+
+        void SendSysMessage(int32     entry);
+        void PSendSysMessage(const char *format, ...) ATTR_PRINTF(2, 3);
+        void PSendSysMessage(int32     entry, ...);
+        std::string PGetParseString(int32 entry, ...) const;
+
+        bool ParseCommands(const char* text);
+
+        static ChatCommand* getCommandTable();
+
+        bool isValidChatMessage(const char* msg);
+        void SendGlobalSysMessage(const char *str);
+
+        bool hasStringAbbr(const char* name, const char* part);
+
+        // function with different implementation for chat/console
+        virtual bool isAvailable(ChatCommand const& cmd) const;
+        virtual std::string GetNameLink() const { return GetNameLink(m_session->GetPlayer()); }
+        virtual bool needReportToTarget(Player* chr) const;
+        virtual LocaleConstant GetSessionDbcLocale() const;
+        virtual int GetSessionDbLocaleIndex() const;
+
+        bool HasLowerSecurity(Player* target, uint64 guid, bool strong = false);
+        bool HasLowerSecurityAccount(WorldSession* target, uint32 account, bool strong = false);
+
+        void SendGlobalGMSysMessage(const char *str);
+        Player*   getSelectedPlayer();
+        Creature* getSelectedCreature();
+        Unit*     getSelectedUnit();
+        WorldObject* getSelectedObject();
+        // Returns either the selected player or self if there is no selected player
+        Player*   getSelectedPlayerOrSelf();
+
+        char*     extractKeyFromLink(char* text, char const* linkType, char** something1 = NULL);
+        char*     extractKeyFromLink(char* text, char const* const* linkTypes, int* found_idx, char** something1 = NULL);
+
+        // if args have single value then it return in arg2 and arg1 == NULL
+        void      extractOptFirstArg(char* args, char** arg1, char** arg2);
+        char*     extractQuotedArg(char* args);
+
+        uint32    extractSpellIdFromLink(char* text);
+        uint64    extractGuidFromLink(char* text);
+        GameTele const* extractGameTeleFromLink(char* text);
+        bool GetPlayerGroupAndGUIDByName(const char* cname, Player* &player, Group* &group, uint64 &guid, bool offline = false);
+        std::string extractPlayerNameFromLink(char* text);
+        // select by arg (name/link) or in-game selection online/offline player
+        bool extractPlayerTarget(char* args, Player** player, uint64* player_guid = NULL, std::string* player_name = NULL);
+
+        std::string playerLink(std::string const& name) const { return m_session ? "|cffffffff|Hplayer:"+name+"|h["+name+"]|h|r" : name; }
+        std::string GetNameLink(Player* chr) const;
+
+        GameObject* GetNearbyGameObject();
+        GameObject* GetObjectGlobalyWithGuidOrNearWithDbGuid(uint32 lowguid, uint32 entry);
+        bool HasSentErrorMessage() const { return sentErrorMessage; }
+        void SetSentErrorMessage(bool val){ sentErrorMessage = val; }
+        static bool LoadCommandTable() { return load_command_table; }
+        static void SetLoadCommandTable(bool val) { load_command_table = val; }
+
+		bool ShowHelpForCommand(ChatCommand* table, const char* cmd);
+    protected:
+        explicit ChatHandler() : m_session(NULL), sentErrorMessage(false) {}      // for CLI subclass
+        static bool SetDataForCommandInTable(ChatCommand* table, const char* text, uint32 security, std::string const& help, std::string const& fullcommand);
+        bool ExecuteCommandInTable(ChatCommand* table, const char* text, std::string& fullcmd);
+        bool ShowHelpForSubCommands(ChatCommand* table, char const* cmd, char const* subcmd);
+
+    private:
+
+        WorldSession* m_session;                           // != NULL for chat command call and NULL for CLI command
+
+        // common global flag
+        static bool load_command_table;
+        bool sentErrorMessage;
+};
+
+class CliHandler : public ChatHandler
+{
+    public:
+        typedef void Print(void*, char const*);
+        explicit CliHandler(void* callbackArg, Print* zprint) : m_callbackArg(callbackArg), m_print(zprint) {}
+
+        // overwrite functions
+        const char *GetTrinityString(int32 entry) const;
+        bool isAvailable(ChatCommand const& cmd) const;
+        void SendSysMessage(const char *str);
+        std::string GetNameLink() const;
+        bool needReportToTarget(Player* chr) const;
+        LocaleConstant GetSessionDbcLocale() const;
+        int GetSessionDbLocaleIndex() const;
+
+    private:
+        void* m_callbackArg;
+        Print* m_print;
+};
+
+#endif

src/server/game/Chat/ChatLink.cpp

@@ -0,0 +1,692 @@
+/*
+ * Copyright (C) 
+ *
+ * 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "ChatLink.h"
+#include "SpellMgr.h"
+#include "ObjectMgr.h"
+#include "SpellInfo.h"
+#include "DBCStores.h"
+
+// Supported shift-links (client generated and server side)
+// |color|Hachievement:achievement_id:player_guid:0:0:0:0:0:0:0:0|h[name]|h|r
+//                                                                        - client, item icon shift click, not used in server currently
+// |color|Harea:area_id|h[name]|h|r
+// |color|Hcreature:creature_guid|h[name]|h|r
+// |color|Hcreature_entry:creature_id|h[name]|h|r
+// |color|Henchant:recipe_spell_id|h[prof_name: recipe_name]|h|r          - client, at shift click in recipes list dialog
+// |color|Hgameevent:id|h[name]|h|r
+// |color|Hgameobject:go_guid|h[name]|h|r
+// |color|Hgameobject_entry:go_id|h[name]|h|r
+// |color|Hglyph:glyph_slot_id:glyph_prop_id|h[%s]|h|r                    - client, at shift click in glyphs dialog, GlyphSlot.dbc, GlyphProperties.dbc
+// |color|Hitem:item_id:perm_ench_id:gem1:gem2:gem3:0:0:0:0:reporter_level|h[name]|h|r
+//                                                                        - client, item icon shift click
+// |color|Hitemset:itemset_id|h[name]|h|r
+// |color|Hplayer:name|h[name]|h|r                                        - client, in some messages, at click copy only name instead link
+// |color|Hquest:quest_id:quest_level|h[name]|h|r                         - client, quest list name shift-click
+// |color|Hskill:skill_id|h[name]|h|r
+// |color|Hspell:spell_id|h[name]|h|r                                     - client, spellbook spell icon shift-click
+// |color|Htalent:talent_id, rank|h[name]|h|r                              - client, talent icon shift-click
+// |color|Htaxinode:id|h[name]|h|r
+// |color|Htele:id|h[name]|h|r
+// |color|Htitle:id|h[name]|h|r
+// |color|Htrade:spell_id:cur_value:max_value:unk3int:unk3str|h[name]|h|r - client, spellbook profession icon shift-click
+
+inline bool ReadUInt32(std::istringstream& iss, uint32& res)
+{
+    iss >> std::dec >> res;
+    return !iss.fail() && !iss.eof();
+}
+
+inline bool ReadInt32(std::istringstream& iss, int32& res)
+{
+    iss >> std::dec >> res;
+    return !iss.fail() && !iss.eof();
+}
+
+inline std::string ReadSkip(std::istringstream& iss, char term)
+{
+    std::string res;
+    char c = iss.peek();
+    while (c != term && c != '\0')
+    {
+        res += c;
+        iss.ignore(1);
+        c = iss.peek();
+    }
+    return res;
+}
+
+inline bool CheckDelimiter(std::istringstream& iss, char delimiter, const char* context)
+{
+    char c = iss.peek();
+    if (c != delimiter)
+    {
+        ;//sLog->outDebug(LOG_FILTER_CHATSYS, "ChatHandler::isValidChatMessage('%s'): invalid %s link structure ('%c' expected, '%c' found)", iss.str().c_str(), context, delimiter, c);
+        return false;
+    }
+    iss.ignore(1);
+    return true;
+}
+
+inline bool ReadHex(std::istringstream& iss, uint32& res, uint32 length)
+{
+    std::istringstream::pos_type pos = iss.tellg();
+    iss >> std::hex >> res;
+    //uint32 size = uint32(iss.gcount());
+    if (length && uint32(iss.tellg() - pos) != length)
+        return false;
+    return !iss.fail() && !iss.eof();
+}
+
+#define DELIMITER ':'
+#define PIPE_CHAR '|'
+
+bool ChatLink::ValidateName(char* buffer, const char* /*context*/)
+{
+    _name = buffer;
+    return true;
+}
+
+// |color|Hitem:item_id:perm_ench_id:gem1:gem2:gem3:0:random_property:0:reporter_level|h[name]|h|r
+// |cffa335ee|Hitem:812:0:0:0:0:0:0:0:70|h[Glowing Brightwood Staff]|h|r
+bool ItemChatLink::Initialize(std::istringstream& iss)
+{
+    // Read item entry
+    uint32 itemEntry = 0;
+    if (!ReadUInt32(iss, itemEntry))
+    {
+        ;//sLog->outDebug(LOG_FILTER_CHATSYS, "ChatHandler::isValidChatMessage('%s'): sequence finished unexpectedly while reading item entry", iss.str().c_str());
+        return false;
+    }
+    // Validate item
+    _item = sObjectMgr->GetItemTemplate(itemEntry);
+    if (!_item)
+    {
+        ;//sLog->outDebug(LOG_FILTER_CHATSYS, "ChatHandler::isValidChatMessage('%s'): got invalid itemEntry %u in |item command", iss.str().c_str(), itemEntry);
+        return false;
+    }
+    // Validate item's color
+    if (_color != ItemQualityColors[_item->Quality])
+    {
+        ;//sLog->outDebug(LOG_FILTER_CHATSYS, "ChatHandler::isValidChatMessage('%s'): linked item has color %u, but user claims %u", iss.str().c_str(), ItemQualityColors[_item->Quality], _color);
+        return false;
+    }
+    // Number of various item properties after item entry
+    const uint8 propsCount = 8;
+    const uint8 randomPropertyPosition = 5;
+    for (uint8 index = 0; index < propsCount; ++index)
+    {
+        if (!CheckDelimiter(iss, DELIMITER, "item"))
+            return false;
+
+        int32 id = 0;
+        if (!ReadInt32(iss, id))
+        {
+            ;//sLog->outDebug(LOG_FILTER_CHATSYS, "ChatHandler::isValidChatMessage('%s'): sequence finished unexpectedly while reading item property (%u)", iss.str().c_str(), index);
+            return false;
+        }
+        if (id && (index == randomPropertyPosition))
+        {
+            // Validate random property
+            if (id > 0)
+            {
+                _property = sItemRandomPropertiesStore.LookupEntry(id);
+                if (!_property)
+                {
+                    ;//sLog->outDebug(LOG_FILTER_CHATSYS, "ChatHandler::isValidChatMessage('%s'): got invalid item property id %u in |item command", iss.str().c_str(), id);
+                    return false;
+                }
+            }
+            else if (id < 0)
+            {
+                _suffix = sItemRandomSuffixStore.LookupEntry(-id);
+                if (!_suffix)
+                {
+                    ;//sLog->outDebug(LOG_FILTER_CHATSYS, "ChatHandler::isValidChatMessage('%s'): got invalid item suffix id %u in |item command", iss.str().c_str(), -id);
+                    return false;
+                }
+            }
+        }
+        _data[index] = id;
+    }
+    return true;
+}
+
+inline std::string ItemChatLink::FormatName(uint8 index, ItemLocale const* locale, char* const* suffixStrings) const
+{
+    std::stringstream ss;
+    if (locale == NULL || index >= locale->Name.size())
+        ss << _item->Name1;
+    else
+        ss << locale->Name[index];
+    if (suffixStrings)
+        ss << ' ' << suffixStrings[index];
+    return ss.str();
+}
+
+bool ItemChatLink::ValidateName(char* buffer, const char* context)
+{
+    ChatLink::ValidateName(buffer, context);
+
+    char* const* suffixStrings = _suffix ? _suffix->nameSuffix : (_property ? _property->nameSuffix : NULL);
+
+    bool res = (FormatName(LOCALE_enUS, NULL, suffixStrings) == buffer);
+
+    //if (!res)
+        ;//sLog->outDebug(LOG_FILTER_CHATSYS, "ChatHandler::isValidChatMessage('%s'): linked item (id: %u) name wasn't found in any localization", context, _item->ItemId);
+    return res;
+}
+
+// |color|Hquest:quest_id:quest_level|h[name]|h|r
+// |cff808080|Hquest:2278:47|h[The Platinum Discs]|h|r
+bool QuestChatLink::Initialize(std::istringstream& iss)
+{
+    // Read quest id
+    uint32 questId = 0;
+    if (!ReadUInt32(iss, questId))
+    {
+        ;//sLog->outDebug(LOG_FILTER_CHATSYS, "ChatHandler::isValidChatMessage('%s'): sequence finished unexpectedly while reading quest entry", iss.str().c_str());
+        return false;
+    }
+    // Validate quest
+    _quest = sObjectMgr->GetQuestTemplate(questId);
+    if (!_quest)
+    {
+        ;//sLog->outDebug(LOG_FILTER_CHATSYS, "ChatHandler::isValidChatMessage('%s'): quest template %u not found", iss.str().c_str(), questId);
+        return false;
+    }
+    // Check delimiter
+    if (!CheckDelimiter(iss, DELIMITER, "quest"))
+        return false;
+    // Read quest level
+    if (!ReadInt32(iss, _questLevel))
+    {
+        ;//sLog->outDebug(LOG_FILTER_CHATSYS, "ChatHandler::isValidChatMessage('%s'): sequence finished unexpectedly while reading quest level", iss.str().c_str());
+        return false;
+    }
+    // Validate quest level
+    if (_questLevel >= STRONG_MAX_LEVEL)
+    {
+        ;//sLog->outDebug(LOG_FILTER_CHATSYS, "ChatHandler::isValidChatMessage('%s'): quest level %d is too big", iss.str().c_str(), _questLevel);
+        return false;
+    }
+    return true;
+}
+
+bool QuestChatLink::ValidateName(char* buffer, const char* context)
+{
+    ChatLink::ValidateName(buffer, context);
+
+    bool res = (_quest->GetTitle() == buffer);
+
+    //if (!res)
+        ;//sLog->outDebug(LOG_FILTER_CHATSYS, "ChatHandler::isValidChatMessage('%s'): linked quest (id: %u) title wasn't found in any localization", context, _quest->GetQuestId());
+    return res;
+}
+
+// |color|Hspell:spell_id|h[name]|h|r
+// |cff71d5ff|Hspell:21563|h[Command]|h|r
+bool SpellChatLink::Initialize(std::istringstream& iss)
+{
+    if (_color != CHAT_LINK_COLOR_SPELL)
+        return false;
+    // Read spell id
+    uint32 spellId = 0;
+    if (!ReadUInt32(iss, spellId))
+    {
+        ;//sLog->outDebug(LOG_FILTER_CHATSYS, "ChatHandler::isValidChatMessage('%s'): sequence finished unexpectedly while reading spell entry", iss.str().c_str());
+        return false;
+    }
+    // Validate spell
+    _spell = sSpellMgr->GetSpellInfo(spellId);
+    if (!_spell)
+    {
+        ;//sLog->outDebug(LOG_FILTER_CHATSYS, "ChatHandler::isValidChatMessage('%s'): got invalid spell id %u in |spell command", iss.str().c_str(), spellId);
+        return false;
+    }
+    return true;
+}
+
+bool SpellChatLink::ValidateName(char* buffer, const char* context)
+{
+    ChatLink::ValidateName(buffer, context);
+
+    // spells with that flag have a prefix of "$PROFESSION: "
+    if (_spell->HasAttribute(SPELL_ATTR0_TRADESPELL))
+    {
+        SkillLineAbilityMapBounds bounds = sSpellMgr->GetSkillLineAbilityMapBounds(_spell->Id);
+        if (bounds.first == bounds.second)
+        {
+            ;//sLog->outDebug(LOG_FILTER_CHATSYS, "ChatHandler::isValidChatMessage('%s'): skill line not found for spell %u", context, _spell->Id);
+            return false;
+        }
+        SkillLineAbilityEntry const* skillInfo = bounds.first->second;
+        if (!skillInfo)
+        {
+            ;//sLog->outDebug(LOG_FILTER_CHATSYS, "ChatHandler::isValidChatMessage('%s'): skill line ability not found for spell %u", context, _spell->Id);
+            return false;
+        }
+        SkillLineEntry const* skillLine = sSkillLineStore.LookupEntry(skillInfo->skillId);
+        if (!skillLine)
+        {
+            ;//sLog->outDebug(LOG_FILTER_CHATSYS, "ChatHandler::isValidChatMessage('%s'): skill line not found for skill %u", context, skillInfo->skillId);
+            return false;
+        }
+
+        for (uint8 i = 0; i < TOTAL_LOCALES; ++i)
+        {
+            uint32 skillLineNameLength = strlen(skillLine->name[i]);
+            if (skillLineNameLength > 0 && strncmp(skillLine->name[i], buffer, skillLineNameLength) == 0)
+            {
+                // found the prefix, remove it to perform spellname validation below
+                // -2 = strlen(": ")
+                uint32 spellNameLength = strlen(buffer) - skillLineNameLength - 2;
+                memmove(buffer, buffer + skillLineNameLength + 2, spellNameLength + 1);
+                break;
+            }
+        }
+    }
+
+    bool res = false;
+    for (uint8 i = 0; i < TOTAL_LOCALES; ++i)
+        if (*_spell->SpellName[i] && strcmp(_spell->SpellName[i], buffer) == 0)
+        {
+            res = true;
+            break;
+        }
+
+    //if (!res)
+        ;//sLog->outDebug(LOG_FILTER_CHATSYS, "ChatHandler::isValidChatMessage('%s'): linked spell (id: %u) name wasn't found in any localization", context, _spell->Id);
+    return res;
+}
+
+// |color|Hachievement:achievement_id:player_guid:0:0:0:0:0:0:0:0|h[name]|h|r
+// |cffffff00|Hachievement:546:0000000000000001:0:0:0:-1:0:0:0:0|h[Safe Deposit]|h|r
+bool AchievementChatLink::Initialize(std::istringstream& iss)
+{
+    if (_color != CHAT_LINK_COLOR_ACHIEVEMENT)
+        return false;
+    // Read achievemnt Id
+    uint32 achievementId = 0;
+    if (!ReadUInt32(iss, achievementId))
+    {
+        ;//sLog->outDebug(LOG_FILTER_CHATSYS, "ChatHandler::isValidChatMessage('%s'): sequence finished unexpectedly while reading achievement entry", iss.str().c_str());
+        return false;
+    }
+    // Validate achievement
+    _achievement = sAchievementStore.LookupEntry(achievementId);
+    if (!_achievement)
+    {
+        ;//sLog->outDebug(LOG_FILTER_CHATSYS, "ChatHandler::isValidChatMessage('%s'): got invalid achivement id %u in |achievement command", iss.str().c_str(), achievementId);
+        return false;
+    }
+    // Check delimiter
+    if (!CheckDelimiter(iss, DELIMITER, "achievement"))
+        return false;
+    // Read HEX
+    if (!ReadHex(iss, _guid, 0))
+    {
+        ;//sLog->outDebug(LOG_FILTER_CHATSYS, "ChatHandler::isValidChatMessage('%s'): invalid hexadecimal number while reading char's guid", iss.str().c_str());
+        return false;
+    }
+    // Skip progress
+    const uint8 propsCount = 8;
+    for (uint8 index = 0; index < propsCount; ++index)
+    {
+        if (!CheckDelimiter(iss, DELIMITER, "achievement"))
+            return false;
+
+        if (!ReadUInt32(iss, _data[index]))
+        {
+            ;//sLog->outDebug(LOG_FILTER_CHATSYS, "ChatHandler::isValidChatMessage('%s'): sequence finished unexpectedly while reading achievement property (%u)", iss.str().c_str(), index);
+            return false;
+        }
+    }
+    return true;
+}
+
+bool AchievementChatLink::ValidateName(char* buffer, const char* context)
+{
+    ChatLink::ValidateName(buffer, context);
+
+    bool res = false;
+    for (uint8 i = 0; i < TOTAL_LOCALES; ++i)
+        if (*_achievement->name[i] && strcmp(_achievement->name[i], buffer) == 0)
+        {
+            res = true;
+            break;
+        }
+
+    //if (!res)
+        ;//sLog->outDebug(LOG_FILTER_CHATSYS, "ChatHandler::isValidChatMessage('%s'): linked achievement (id: %u) name wasn't found in any localization", context, _achievement->ID);
+    return res;
+}
+
+// |color|Htrade:spell_id:cur_value:max_value:player_guid:base64_data|h[name]|h|r
+// |cffffd000|Htrade:4037:1:150:1:6AAAAAAAAAAAAAAAAAAAAAAOAADAAAAAAAAAAAAAAAAIAAAAAAAAA|h[Engineering]|h|r
+bool TradeChatLink::Initialize(std::istringstream& iss)
+{
+    if (_color != CHAT_LINK_COLOR_TRADE)
+        return false;
+    // Spell Id
+    uint32 spellId = 0;
+    if (!ReadUInt32(iss, spellId))
+    {
+        ;//sLog->outDebug(LOG_FILTER_CHATSYS, "ChatHandler::isValidChatMessage('%s'): sequence finished unexpectedly while reading achievement entry", iss.str().c_str());
+        return false;
+    }
+    // Validate spell
+    _spell = sSpellMgr->GetSpellInfo(spellId);
+    if (!_spell)
+    {
+        ;//sLog->outDebug(LOG_FILTER_CHATSYS, "ChatHandler::isValidChatMessage('%s'): got invalid spell id %u in |trade command", iss.str().c_str(), spellId);
+        return false;
+    }
+    // Check delimiter
+    if (!CheckDelimiter(iss, DELIMITER, "trade"))
+        return false;
+    // Minimum talent level
+    if (!ReadInt32(iss, _minSkillLevel))
+    {
+        ;//sLog->outDebug(LOG_FILTER_CHATSYS, "ChatHandler::isValidChatMessage('%s'): sequence finished unexpectedly while reading minimum talent level", iss.str().c_str());
+        return false;
+    }
+    // Check delimiter
+    if (!CheckDelimiter(iss, DELIMITER, "trade"))
+        return false;
+    // Maximum talent level
+    if (!ReadInt32(iss, _maxSkillLevel))
+    {
+        ;//sLog->outDebug(LOG_FILTER_CHATSYS, "ChatHandler::isValidChatMessage('%s'): sequence finished unexpectedly while reading maximum talent level", iss.str().c_str());
+        return false;
+    }
+    // Check delimiter
+    if (!CheckDelimiter(iss, DELIMITER, "trade"))
+        return false;
+    // Something hexadecimal
+    if (!ReadHex(iss, _guid, 0))
+    {
+        ;//sLog->outDebug(LOG_FILTER_CHATSYS, "ChatHandler::isValidChatMessage('%s'): sequence finished unexpectedly while reading achievement's owner guid", iss.str().c_str());
+        return false;
+    }
+    // Skip base64 encoded stuff
+    _base64 = ReadSkip(iss, PIPE_CHAR);
+    return true;
+}
+
+// |color|Htalent:talent_id:rank|h[name]|h|r
+// |cff4e96f7|Htalent:2232:-1|h[Taste for Blood]|h|r
+bool TalentChatLink::Initialize(std::istringstream& iss)
+{
+    if (_color != CHAT_LINK_COLOR_TALENT)
+        return false;
+    // Read talent entry
+    if (!ReadUInt32(iss, _talentId))
+    {
+        ;//sLog->outDebug(LOG_FILTER_CHATSYS, "ChatHandler::isValidChatMessage('%s'): sequence finished unexpectedly while reading talent entry", iss.str().c_str());
+        return false;
+    }
+    // Validate talent
+    TalentEntry const* talentInfo = sTalentStore.LookupEntry(_talentId);
+    if (!talentInfo)
+    {
+        ;//sLog->outDebug(LOG_FILTER_CHATSYS, "ChatHandler::isValidChatMessage('%s'): got invalid talent id %u in |talent command", iss.str().c_str(), _talentId);
+        return false;
+    }
+    // Validate talent's spell
+    _spell = sSpellMgr->GetSpellInfo(talentInfo->RankID[0]);
+    if (!_spell)
+    {
+        ;//sLog->outDebug(LOG_FILTER_CHATSYS, "ChatHandler::isValidChatMessage('%s'): got invalid spell id %u in |trade command", iss.str().c_str(), talentInfo->RankID[0]);
+        return false;
+    }
+    // Delimiter
+    if (!CheckDelimiter(iss, DELIMITER, "talent"))
+        return false;
+    // Rank
+    if (!ReadInt32(iss, _rankId))
+    {
+        ;//sLog->outDebug(LOG_FILTER_CHATSYS, "ChatHandler::isValidChatMessage('%s'): sequence finished unexpectedly while reading talent rank", iss.str().c_str());
+        return false;
+    }
+    return true;
+}
+
+// |color|Henchant:recipe_spell_id|h[prof_name: recipe_name]|h|r
+// |cffffd000|Henchant:3919|h[Engineering: Rough Dynamite]|h|r
+bool EnchantmentChatLink::Initialize(std::istringstream& iss)
+{
+    if (_color != CHAT_LINK_COLOR_ENCHANT)
+        return false;
+    // Spell Id
+    uint32 spellId = 0;
+    if (!ReadUInt32(iss, spellId))
+    {
+        ;//sLog->outDebug(LOG_FILTER_CHATSYS, "ChatHandler::isValidChatMessage('%s'): sequence finished unexpectedly while reading enchantment spell entry", iss.str().c_str());
+        return false;
+    }
+    // Validate spell
+    _spell = sSpellMgr->GetSpellInfo(spellId);
+    if (!_spell)
+    {
+        ;//sLog->outDebug(LOG_FILTER_CHATSYS, "ChatHandler::isValidChatMessage('%s'): got invalid spell id %u in |enchant command", iss.str().c_str(), spellId);
+        return false;
+    }
+    return true;
+}
+
+// |color|Hglyph:glyph_slot_id:glyph_prop_id|h[%s]|h|r
+// |cff66bbff|Hglyph:21:762|h[Glyph of Bladestorm]|h|r
+bool GlyphChatLink::Initialize(std::istringstream& iss)
+{
+    if (_color != CHAT_LINK_COLOR_GLYPH)
+        return false;
+    // Slot
+    if (!ReadUInt32(iss, _slotId))
+    {
+        ;//sLog->outDebug(LOG_FILTER_CHATSYS, "ChatHandler::isValidChatMessage('%s'): sequence finished unexpectedly while reading slot id", iss.str().c_str());
+        return false;
+    }
+    // Check delimiter
+    if (!CheckDelimiter(iss, DELIMITER, "glyph"))
+        return false;
+    // Glyph Id
+    uint32 glyphId = 0;
+    if (!ReadUInt32(iss, glyphId))
+    {
+        ;//sLog->outDebug(LOG_FILTER_CHATSYS, "ChatHandler::isValidChatMessage('%s'): sequence finished unexpectedly while reading glyph entry", iss.str().c_str());
+        return false;
+    }
+    // Validate glyph
+    _glyph = sGlyphPropertiesStore.LookupEntry(glyphId);
+    if (!_glyph)
+    {
+        ;//sLog->outDebug(LOG_FILTER_CHATSYS, "ChatHandler::isValidChatMessage('%s'): got invalid glyph id %u in |glyph command", iss.str().c_str(), glyphId);
+        return false;
+    }
+    // Validate glyph's spell
+    _spell = sSpellMgr->GetSpellInfo(_glyph->SpellId);
+    if (!_spell)
+    {
+        ;//sLog->outDebug(LOG_FILTER_CHATSYS, "ChatHandler::isValidChatMessage('%s'): got invalid spell id %u in |glyph command", iss.str().c_str(), _glyph->SpellId);
+        return false;
+    }
+    return true;
+}
+
+LinkExtractor::LinkExtractor(const char* msg) : _iss(msg)
+{
+}
+
+LinkExtractor::~LinkExtractor()
+{
+    for (Links::iterator itr = _links.begin(); itr != _links.end(); ++itr)
+        delete *itr;
+    _links.clear();
+}
+
+bool LinkExtractor::IsValidMessage()
+{
+    const char validSequence[6] = "cHhhr";
+    const char* validSequenceIterator = validSequence;
+
+    char buffer[256];
+
+    std::istringstream::pos_type startPos = 0;
+    uint32 color = 0;
+
+    ChatLink* link = NULL;
+    while (!_iss.eof())
+    {
+        if (validSequence == validSequenceIterator)
+        {
+            link = NULL;
+            _iss.ignore(255, PIPE_CHAR);
+            startPos = _iss.tellg() - std::istringstream::pos_type(1);
+        }
+        else if (_iss.get() != PIPE_CHAR)
+        {
+            ;//sLog->outDebug(LOG_FILTER_CHATSYS, "ChatHandler::isValidChatMessage('%s'): sequence aborted unexpectedly", _iss.str().c_str());
+            return false;
+        }
+
+        // pipe has always to be followed by at least one char
+        if (_iss.peek() == '\0')
+        {
+            ;//sLog->outDebug(LOG_FILTER_CHATSYS, "ChatHandler::isValidChatMessage('%s'): pipe followed by '\\0'", _iss.str().c_str());
+            return false;
+        }
+
+        // no further pipe commands
+        if (_iss.eof())
+            break;
+
+        char commandChar;
+        _iss >> commandChar;
+
+        // | in normal messages is escaped by ||
+        if (commandChar != PIPE_CHAR)
+        {
+            if (commandChar == *validSequenceIterator)
+            {
+                if (validSequenceIterator == validSequence+4)
+                    validSequenceIterator = validSequence;
+                else
+                    ++validSequenceIterator;
+            }
+            else
+            {
+                ;//sLog->outDebug(LOG_FILTER_CHATSYS, "ChatHandler::isValidChatMessage('%s'): invalid sequence, expected '%c' but got '%c'", _iss.str().c_str(), *validSequenceIterator, commandChar);
+                return false;
+            }
+        }
+        else if (validSequence != validSequenceIterator)
+        {
+            // no escaped pipes in sequences
+            ;//sLog->outDebug(LOG_FILTER_CHATSYS, "ChatHandler::isValidChatMessage('%s'): got escaped pipe in sequence", _iss.str().c_str());
+            return false;
+        }
+
+        switch (commandChar)
+        {
+            case 'c':
+                if (!ReadHex(_iss, color, 8))
+                {
+                    ;//sLog->outDebug(LOG_FILTER_CHATSYS, "ChatHandler::isValidChatMessage('%s'): invalid hexadecimal number while reading color", _iss.str().c_str());
+                    return false;
+                }
+                break;
+            case 'H':
+                // read chars up to colon = link type
+                _iss.getline(buffer, 256, DELIMITER);
+                if (_iss.eof())
+                {
+                    ;//sLog->outDebug(LOG_FILTER_CHATSYS, "ChatHandler::isValidChatMessage('%s'): sequence finished unexpectedly", _iss.str().c_str());
+                    return false;
+                }
+
+                if (strcmp(buffer, "item") == 0)
+                    link = new ItemChatLink();
+                else if (strcmp(buffer, "quest") == 0)
+                    link = new QuestChatLink();
+                else if (strcmp(buffer, "trade") == 0)
+                    link = new TradeChatLink();
+                else if (strcmp(buffer, "talent") == 0)
+                    link = new TalentChatLink();
+                else if (strcmp(buffer, "spell") == 0)
+                    link = new SpellChatLink();
+                else if (strcmp(buffer, "enchant") == 0)
+                    link = new EnchantmentChatLink();
+                else if (strcmp(buffer, "achievement") == 0)
+                    link = new AchievementChatLink();
+                else if (strcmp(buffer, "glyph") == 0)
+                    link = new GlyphChatLink();
+                else
+                {
+                    ;//sLog->outDebug(LOG_FILTER_CHATSYS, "ChatHandler::isValidChatMessage('%s'): user sent unsupported link type '%s'", _iss.str().c_str(), buffer);
+                    return false;
+                }
+                _links.push_back(link);
+                link->SetColor(color);
+                if (!link->Initialize(_iss))
+                    return false;
+                break;
+            case 'h':
+                // if h is next element in sequence, this one must contain the linked text :)
+                if (*validSequenceIterator == 'h')
+                {
+                    // links start with '['
+                    if (_iss.get() != '[')
+                    {
+                        ;//sLog->outDebug(LOG_FILTER_CHATSYS, "ChatHandler::isValidChatMessage('%s'): link caption doesn't start with '['", _iss.str().c_str());
+                        return false;
+                    }
+                    _iss.getline(buffer, 256, ']');
+                    if (_iss.eof())
+                    {
+                        ;//sLog->outDebug(LOG_FILTER_CHATSYS, "ChatHandler::isValidChatMessage('%s'): sequence finished unexpectedly", _iss.str().c_str());
+                        return false;
+                    }
+
+                    if (!link)
+                        return false;
+
+                    if (!link->ValidateName(buffer, _iss.str().c_str()))
+                        return false;
+                }
+                break;
+            case 'r':
+                if (link)
+                    link->SetBounds(startPos, _iss.tellg());
+            case '|':
+                // no further payload
+                break;
+            default:
+                ;//sLog->outDebug(LOG_FILTER_CHATSYS, "ChatHandler::isValidChatMessage('%s'): got invalid command |%c", _iss.str().c_str(), commandChar);
+                return false;
+        }
+    }
+
+    // check if every opened sequence was also closed properly
+    if (validSequence != validSequenceIterator)
+    {
+        ;//sLog->outDebug(LOG_FILTER_CHATSYS, "ChatHandler::isValidChatMessage('%s'): EOF in active sequence", _iss.str().c_str());
+        return false;
+    }
+
+    return true;
+}

src/server/game/Chat/ChatLink.h

@@ -0,0 +1,176 @@
+/*
+ * Copyright (C) 
+ *
+ * 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef SUNWELLCORE_CHATLINK_H
+#define SUNWELLCORE_CHATLINK_H
+
+#include "SharedDefines.h"
+#include <sstream>
+#include <list>
+
+struct ItemLocale;
+struct ItemTemplate;
+struct ItemRandomSuffixEntry;
+struct ItemRandomPropertiesEntry;
+class SpellInfo;
+struct AchievementEntry;
+struct GlyphPropertiesEntry;
+class Quest;
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// ChatLink - abstract base class for various links
+class ChatLink
+{
+public:
+    ChatLink() : _color(0), _startPos(0), _endPos(0) { }
+    virtual ~ChatLink() { }
+    void SetColor(uint32 color) { _color = color; }
+    // This will allow to extract the whole link string from the message, if necessary.
+    void SetBounds(std::istringstream::pos_type startPos, std::istringstream::pos_type endPos) { _startPos = startPos; _endPos = endPos; }
+
+    virtual bool Initialize(std::istringstream& iss) = 0;
+    virtual bool ValidateName(char* buffer, const char* context) = 0;
+
+protected:
+    uint32 _color;
+    std::string _name;
+    std::istringstream::pos_type _startPos;
+    std::istringstream::pos_type _endPos;
+};
+
+// ItemChatLink - link to item
+class ItemChatLink : public ChatLink
+{
+public:
+    ItemChatLink() : ChatLink(), _item(NULL), _suffix(NULL), _property(NULL)
+    { 
+        memset(_data, 0, sizeof(_data));
+    }
+    virtual bool Initialize(std::istringstream& iss);
+    virtual bool ValidateName(char* buffer, const char* context);
+
+protected:
+    std::string FormatName(uint8 index, ItemLocale const* locale, char* const* suffixStrings) const;
+
+    ItemTemplate const* _item;
+    int32 _data[8];
+    ItemRandomSuffixEntry const* _suffix;
+    ItemRandomPropertiesEntry const* _property;
+};
+
+// QuestChatLink - link to quest
+class QuestChatLink : public ChatLink
+{
+public:
+    QuestChatLink() : ChatLink(), _quest(NULL), _questLevel(0) { }
+    virtual bool Initialize(std::istringstream& iss);
+    virtual bool ValidateName(char* buffer, const char* context);
+
+protected:
+    Quest const* _quest;
+    int32 _questLevel;
+};
+
+// SpellChatLink - link to quest
+class SpellChatLink : public ChatLink
+{
+public:
+    SpellChatLink() : ChatLink(), _spell(NULL) { }
+    virtual bool Initialize(std::istringstream& iss);
+    virtual bool ValidateName(char* buffer, const char* context);
+
+protected:
+    SpellInfo const* _spell;
+};
+
+// AchievementChatLink - link to quest
+class AchievementChatLink : public ChatLink
+{
+public:
+    AchievementChatLink() : ChatLink(), _guid(0), _achievement(NULL)
+    { 
+        memset(_data, 0, sizeof(_data));
+    }
+    virtual bool Initialize(std::istringstream& iss);
+    virtual bool ValidateName(char* buffer, const char* context);
+
+protected:
+    uint32 _guid;
+    AchievementEntry const* _achievement;
+    uint32 _data[8];
+};
+
+// TradeChatLink - link to trade info
+class TradeChatLink : public SpellChatLink
+{
+public:
+    TradeChatLink() : SpellChatLink(), _minSkillLevel(0), _maxSkillLevel(0), _guid(0) { }
+    virtual bool Initialize(std::istringstream& iss);
+private:
+    int32 _minSkillLevel;
+    int32 _maxSkillLevel;
+    uint32 _guid;
+    std::string _base64;
+};
+
+// TalentChatLink - link to talent
+class TalentChatLink : public SpellChatLink
+{
+public:
+    TalentChatLink() : SpellChatLink(), _talentId(0), _rankId(0) { }
+    virtual bool Initialize(std::istringstream& iss);
+
+private:
+    uint32 _talentId;
+    int32 _rankId;
+};
+
+// EnchantmentChatLink - link to enchantment
+class EnchantmentChatLink : public SpellChatLink
+{
+public:
+    EnchantmentChatLink() : SpellChatLink() { }
+    virtual bool Initialize(std::istringstream& iss);
+};
+
+// GlyphChatLink - link to glyph
+class GlyphChatLink : public SpellChatLink
+{
+public:
+    GlyphChatLink() : SpellChatLink(), _slotId(0), _glyph(NULL) { }
+    virtual bool Initialize(std::istringstream& iss);
+private:
+    uint32 _slotId;
+    GlyphPropertiesEntry const* _glyph;
+};
+
+class LinkExtractor
+{
+public:
+    explicit LinkExtractor(const char* msg);
+    ~LinkExtractor();
+
+    bool IsValidMessage();
+
+private:
+    typedef std::list<ChatLink*> Links;
+    Links _links;
+    std::istringstream _iss;
+};
+
+
+#endif

src/server/game/Combat/HostileRefManager.cpp

@@ -0,0 +1,219 @@
+/*
+ * Copyright (C) 
+ * Copyright (C) 
+ *
+ * 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "HostileRefManager.h"
+#include "ThreatManager.h"
+#include "Unit.h"
+#include "DBCStructure.h"
+#include "SpellMgr.h"
+#include "SpellInfo.h"
+
+HostileRefManager::~HostileRefManager()
+{
+    deleteReferences();
+}
+
+//=================================================
+// send threat to all my hateres for the victim
+// The victim is hated than by them as well
+// use for buffs and healing threat functionality
+
+void HostileRefManager::threatAssist(Unit* victim, float baseThreat, SpellInfo const* threatSpell)
+{
+    if (getSize() == 0)
+        return;
+
+    HostileReference* ref = getFirst();
+    float threat = ThreatCalcHelper::calcThreat(victim, iOwner, baseThreat, (threatSpell ? threatSpell->GetSchoolMask() : SPELL_SCHOOL_MASK_NORMAL), threatSpell);
+    threat /= getSize();
+    while (ref)
+    {
+        if (ThreatCalcHelper::isValidProcess(victim, ref->GetSource()->GetOwner(), threatSpell))
+            ref->GetSource()->doAddThreat(victim, threat);
+
+        ref = ref->next();
+    }
+}
+
+//=================================================
+
+void HostileRefManager::addTempThreat(float threat, bool apply)
+{
+    HostileReference* ref = getFirst();
+
+    while (ref)
+    {
+        if (apply)
+        {
+            if (ref->getTempThreatModifier() == 0.0f)
+                ref->addTempThreat(threat);
+        }
+        else
+            ref->resetTempThreat();
+
+        ref = ref->next();
+    }
+}
+
+//=================================================
+
+void HostileRefManager::addThreatPercent(int32 percent)
+{
+    HostileReference* ref = getFirst();
+    while (ref)
+    {
+        ref->addThreatPercent(percent);
+        ref = ref->next();
+    }
+}
+
+//=================================================
+// The online / offline status is given to the method. The calculation has to be done before
+
+void HostileRefManager::setOnlineOfflineState(bool isOnline)
+{
+    HostileReference* ref = getFirst();
+    while (ref)
+    {
+        ref->setOnlineOfflineState(isOnline);
+        ref = ref->next();
+    }
+}
+
+//=================================================
+// The online / offline status is calculated and set
+
+void HostileRefManager::updateThreatTables()
+{
+    HostileReference* ref = getFirst();
+    while (ref)
+    {
+        ref->updateOnlineStatus();
+        ref = ref->next();
+    }
+}
+
+//=================================================
+// The references are not needed anymore
+// tell the source to remove them from the list and free the mem
+
+void HostileRefManager::deleteReferences()
+{
+    HostileReference* ref = getFirst();
+    while (ref)
+    {
+        HostileReference* nextRef = ref->next();
+        ref->removeReference();
+        delete ref;
+        ref = nextRef;
+    }
+}
+
+//=================================================
+// delete one reference, defined by faction
+
+void HostileRefManager::deleteReferencesForFaction(uint32 faction)
+{
+    HostileReference* ref = getFirst();
+    while (ref)
+    {
+        HostileReference* nextRef = ref->next();
+        if (ref->GetSource()->GetOwner()->GetFactionTemplateEntry()->faction == faction)
+        {
+            ref->removeReference();
+            delete ref;
+        }
+        ref = nextRef;
+    }
+}
+
+//=================================================
+// delete one reference, defined by Unit
+
+void HostileRefManager::deleteReference(Unit* creature)
+{
+    HostileReference* ref = getFirst();
+    while (ref)
+    {
+        HostileReference* nextRef = ref->next();
+        if (ref->GetSource()->GetOwner() == creature)
+        {
+            ref->removeReference();
+            delete ref;
+            break;
+        }
+        ref = nextRef;
+    }
+}
+
+//=================================================
+// delete all references out of specified range
+
+void HostileRefManager::deleteReferencesOutOfRange(float range)
+{
+    HostileReference* ref = getFirst();
+    range = range*range;
+    while (ref)
+    {
+        HostileReference* nextRef = ref->next();
+        Unit* owner = ref->GetSource()->GetOwner();
+        if (!owner->isActiveObject() && owner->GetExactDist2dSq(GetOwner()) > range)
+        {
+            ref->removeReference();
+            delete ref;
+        }
+        ref = nextRef;
+    }
+}
+
+//=================================================
+// set state for one reference, defined by Unit
+
+void HostileRefManager::setOnlineOfflineState(Unit* creature, bool isOnline)
+{
+    HostileReference* ref = getFirst();
+    while (ref)
+    {
+        HostileReference* nextRef = ref->next();
+        if (ref->GetSource()->GetOwner() == creature)
+        {
+            ref->setOnlineOfflineState(isOnline);
+            break;
+        }
+        ref = nextRef;
+    }
+}
+
+//=================================================
+
+void HostileRefManager::UpdateVisibility(bool checkThreat)
+{
+    HostileReference* ref = getFirst();
+    while (ref)
+    {
+        HostileReference* nextRef = ref->next();
+		if ((!checkThreat || ref->GetSource()->getThreatList().size() <= 1) && 
+			!ref->GetSource()->GetOwner()->CanSeeOrDetect(GetOwner()))
+        {
+            nextRef = ref->next();
+            ref->removeReference();
+            delete ref;
+        }
+        ref = nextRef;
+    }
+}

src/server/game/Combat/HostileRefManager.h

@@ -0,0 +1,77 @@
+/*
+ * Copyright (C) 
+ * Copyright (C) 
+ *
+ * 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef _HOSTILEREFMANAGER
+#define _HOSTILEREFMANAGER
+
+#include "Common.h"
+#include "RefManager.h"
+
+class Unit;
+class ThreatManager;
+class HostileReference;
+class SpellInfo;
+
+//=================================================
+
+class HostileRefManager : public RefManager<Unit, ThreatManager>
+{
+    private:
+        Unit* iOwner;
+    public:
+        explicit HostileRefManager(Unit* owner) { iOwner = owner; }
+        ~HostileRefManager();
+
+        Unit* GetOwner() { return iOwner; }
+
+        // send threat to all my hateres for the victim
+        // The victim is hated than by them as well
+        // use for buffs and healing threat functionality
+        void threatAssist(Unit* victim, float baseThreat, SpellInfo const* threatSpell = NULL);
+
+        void addTempThreat(float threat, bool apply);
+
+        void addThreatPercent(int32 percent);
+
+        // The references are not needed anymore
+        // tell the source to remove them from the list and free the mem
+        void deleteReferences();
+
+        // Remove specific faction references
+        void deleteReferencesForFaction(uint32 faction);
+
+        // pussywizard: for combat bugs
+        void deleteReferencesOutOfRange(float range);
+
+        HostileReference* getFirst() { return ((HostileReference*) RefManager<Unit, ThreatManager>::getFirst()); }
+
+        void updateThreatTables();
+
+        void setOnlineOfflineState(bool isOnline);
+
+        // set state for one reference, defined by Unit
+        void setOnlineOfflineState(Unit* creature, bool isOnline);
+
+        // delete one reference, defined by Unit
+        void deleteReference(Unit* creature);
+
+        void UpdateVisibility(bool checkThreat);
+};
+//=================================================
+#endif
+

src/server/game/Combat/ThreatManager.cpp

@@ -0,0 +1,616 @@
+/*
+ * Copyright (C) 
+ * Copyright (C) 
+ *
+ * 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "ThreatManager.h"
+#include "Unit.h"
+#include "Creature.h"
+#include "CreatureAI.h"
+#include "Map.h"
+#include "Player.h"
+#include "ObjectAccessor.h"
+#include "UnitEvents.h"
+#include "SpellAuras.h"
+#include "SpellMgr.h"
+
+//==============================================================
+//================= ThreatCalcHelper ===========================
+//==============================================================
+
+// The hatingUnit is not used yet
+float ThreatCalcHelper::calcThreat(Unit* hatedUnit, Unit* /*hatingUnit*/, float threat, SpellSchoolMask schoolMask, SpellInfo const* threatSpell)
+{
+    if (threatSpell)
+    {
+        if (SpellThreatEntry const*  threatEntry = sSpellMgr->GetSpellThreatEntry(threatSpell->Id))
+            if (threatEntry->pctMod != 1.0f)
+                threat *= threatEntry->pctMod;
+
+        // Energize is not affected by Mods
+        for (uint8 i = 0; i < MAX_SPELL_EFFECTS; i++)
+            if (threatSpell->Effects[i].Effect == SPELL_EFFECT_ENERGIZE || threatSpell->Effects[i].ApplyAuraName == SPELL_AURA_PERIODIC_ENERGIZE)
+                return threat;
+
+        if (Player* modOwner = hatedUnit->GetSpellModOwner())
+            modOwner->ApplySpellMod(threatSpell->Id, SPELLMOD_THREAT, threat);
+    }
+
+    return hatedUnit->ApplyTotalThreatModifier(threat, schoolMask);
+}
+
+bool ThreatCalcHelper::isValidProcess(Unit* hatedUnit, Unit* hatingUnit, SpellInfo const* threatSpell)
+{
+    //function deals with adding threat and adding players and pets into ThreatList
+    //mobs, NPCs, guards have ThreatList and HateOfflineList
+    //players and pets have only InHateListOf
+    //HateOfflineList is used co contain unattackable victims (in-flight, in-water, GM etc.)
+
+    if (!hatedUnit || !hatingUnit)
+        return false;
+
+    // not to self
+    if (hatedUnit == hatingUnit)
+        return false;
+
+    // not to GM
+    if (hatedUnit->GetTypeId() == TYPEID_PLAYER && hatedUnit->ToPlayer()->IsGameMaster())
+        return false;
+
+    // not to dead and not for dead
+    if (!hatedUnit->IsAlive() || !hatingUnit->IsAlive())
+        return false;
+
+    // not in same map or phase
+    if (!hatedUnit->IsInMap(hatingUnit) || !hatedUnit->InSamePhase(hatingUnit))
+        return false;
+
+    // spell not causing threat
+    if (threatSpell && threatSpell->HasAttribute(SPELL_ATTR1_NO_THREAT))
+        return false;
+
+    ASSERT(hatingUnit->GetTypeId() == TYPEID_UNIT);
+
+    return true;
+}
+
+//============================================================
+//================= HostileReference ==========================
+//============================================================
+
+HostileReference::HostileReference(Unit* refUnit, ThreatManager* threatManager, float threat)
+{
+    iThreat = threat;
+    iTempThreatModifier = 0.0f;
+    link(refUnit, threatManager);
+    iUnitGuid = refUnit->GetGUID();
+    iOnline = true;
+}
+
+//============================================================
+// Tell our refTo (target) object that we have a link
+void HostileReference::targetObjectBuildLink()
+{
+    getTarget()->addHatedBy(this);
+}
+
+//============================================================
+// Tell our refTo (taget) object, that the link is cut
+void HostileReference::targetObjectDestroyLink()
+{
+    getTarget()->removeHatedBy(this);
+}
+
+//============================================================
+// Tell our refFrom (source) object, that the link is cut (Target destroyed)
+
+void HostileReference::sourceObjectDestroyLink()
+{
+    setOnlineOfflineState(false);
+}
+
+//============================================================
+// Inform the source, that the status of the reference changed
+
+void HostileReference::fireStatusChanged(ThreatRefStatusChangeEvent& threatRefStatusChangeEvent)
+{
+    if (GetSource())
+        GetSource()->processThreatEvent(&threatRefStatusChangeEvent);
+}
+
+//============================================================
+
+void HostileReference::addThreat(float modThreat)
+{
+    iThreat += modThreat;
+    // the threat is changed. Source and target unit have to be available
+    // if the link was cut before relink it again
+    if (!isOnline())
+        updateOnlineStatus();
+    if (modThreat != 0.0f)
+    {
+        ThreatRefStatusChangeEvent event(UEV_THREAT_REF_THREAT_CHANGE, this, modThreat);
+        fireStatusChanged(event);
+    }
+
+    if (isValid() && modThreat >= 0.0f)
+    {
+        Unit* victimOwner = getTarget()->GetCharmerOrOwner();
+        if (victimOwner && victimOwner->IsAlive())
+            GetSource()->addThreat(victimOwner, 0.0f);     // create a threat to the owner of a pet, if the pet attacks
+    }
+}
+
+void HostileReference::addThreatPercent(int32 percent)
+{
+	// Xinef: Do not allow to modify threat by percent if threat is negative (forced to big value < 0 by spells adding temporary threat)
+	// Xinef: When the temporary effect ends, temporary threat is added back which results in huge additional amount of threat
+	if (iThreat <= 0)
+		return;
+
+    float tmpThreat = iThreat;
+    AddPct(tmpThreat, percent);
+    addThreat(tmpThreat - iThreat);
+}
+
+//============================================================
+// check, if source can reach target and set the status
+
+void HostileReference::updateOnlineStatus()
+{
+    bool online = false;
+
+    if (!isValid())
+        if (Unit* target = ObjectAccessor::GetUnit(*GetSourceUnit(), getUnitGuid()))
+            link(target, GetSource());
+
+    // only check for online status if
+    // ref is valid
+    // target is no player or not gamemaster
+    // target is not in flight
+    if (isValid()
+        && (getTarget()->GetTypeId() != TYPEID_PLAYER || !getTarget()->ToPlayer()->IsGameMaster())
+        && !getTarget()->IsInFlight()
+        && getTarget()->IsInMap(GetSourceUnit())
+        && getTarget()->InSamePhase(GetSourceUnit())
+        )
+    {
+        Creature* creature = GetSourceUnit()->ToCreature();
+        online = getTarget()->isInAccessiblePlaceFor(creature);
+        if (!online)
+        {
+            if (creature->IsWithinCombatRange(getTarget(), creature->m_CombatDistance))
+                online = true;                              // not accessible but stays online
+        }
+    }
+
+    setOnlineOfflineState(online);
+}
+
+//============================================================
+// set the status and fire the event on status change
+
+void HostileReference::setOnlineOfflineState(bool isOnline)
+{
+    if (iOnline != isOnline)
+    {
+        iOnline = isOnline;
+
+        ThreatRefStatusChangeEvent event(UEV_THREAT_REF_ONLINE_STATUS, this);
+        fireStatusChanged(event);
+    }
+}
+
+//============================================================
+// prepare the reference for deleting
+// this is called be the target
+
+void HostileReference::removeReference()
+{
+    invalidate();
+
+    ThreatRefStatusChangeEvent event(UEV_THREAT_REF_REMOVE_FROM_LIST, this);
+    fireStatusChanged(event);
+}
+
+//============================================================
+
+Unit* HostileReference::GetSourceUnit()
+{
+    return (GetSource()->GetOwner());
+}
+
+//============================================================
+//================ ThreatContainer ===========================
+//============================================================
+
+void ThreatContainer::clearReferences()
+{
+    for (ThreatContainer::StorageType::const_iterator i = iThreatList.begin(); i != iThreatList.end(); ++i)
+    {
+        (*i)->unlink();
+        delete (*i);
+    }
+
+    iThreatList.clear();
+}
+
+//============================================================
+// Return the HostileReference of NULL, if not found
+HostileReference* ThreatContainer::getReferenceByTarget(Unit* victim) const
+{
+    if (!victim)
+        return NULL;
+
+    uint64 const guid = victim->GetGUID();
+    for (ThreatContainer::StorageType::const_iterator i = iThreatList.begin(); i != iThreatList.end(); ++i)
+    {
+        HostileReference *ref = (*i);
+        if (ref && ref->getUnitGuid() == guid)
+            return ref;
+    }
+
+    return NULL;
+}
+
+//============================================================
+// Add the threat, if we find the reference
+
+HostileReference* ThreatContainer::addThreat(Unit* victim, float threat)
+{
+    HostileReference* ref = getReferenceByTarget(victim);
+    if (ref)
+        ref->addThreat(threat);
+    return ref;
+}
+
+//============================================================
+
+void ThreatContainer::modifyThreatPercent(Unit* victim, int32 percent)
+{
+    if (HostileReference* ref = getReferenceByTarget(victim))
+        ref->addThreatPercent(percent);
+}
+
+//============================================================
+// Check if the list is dirty and sort if necessary
+
+void ThreatContainer::update()
+{
+    if (iDirty && iThreatList.size() > 1)
+        iThreatList.sort(Trinity::ThreatOrderPred());
+
+    iDirty = false;
+}
+
+//============================================================
+// return the next best victim
+// could be the current victim
+
+HostileReference* ThreatContainer::selectNextVictim(Creature* attacker, HostileReference* currentVictim) const
+{
+	// pussywizard: pretty much remade this whole function
+
+	HostileReference* currentRef = NULL;
+	bool found = false;
+	bool noPriorityTargetFound = false;
+	uint32 currTime = sWorld->GetGameTime();
+
+	// pussywizard: currentVictim is needed to compare if threat was exceeded by 10%/30% for melee/range targets (only then switching current target)
+	if (currentVictim)
+	{
+		Unit* cvUnit = currentVictim->getTarget();
+		if (!attacker->_CanDetectFeignDeathOf(cvUnit) || !attacker->CanCreatureAttack(cvUnit) || attacker->isTargetNotAcceptableByMMaps(cvUnit->GetGUID(), currTime, cvUnit)) // pussywizard: if currentVictim is not valid => don't compare the threat with it, just take the highest threat valid target
+			currentVictim = NULL;
+		else if (cvUnit->IsImmunedToDamageOrSchool(attacker->GetMeleeDamageSchoolMask()) || cvUnit->HasNegativeAuraWithInterruptFlag(AURA_INTERRUPT_FLAG_TAKE_DAMAGE)) // pussywizard: no 10%/30% if currentVictim is immune to damage or has auras breakable by damage
+			currentVictim = NULL;
+	}
+
+	ThreatContainer::StorageType::const_iterator lastRef = iThreatList.end();
+	--lastRef;
+
+	// pussywizard: iterate from highest to lowest threat
+	for (ThreatContainer::StorageType::const_iterator iter = iThreatList.begin(); iter != iThreatList.end() && !found;)
+	{
+		currentRef = (*iter);
+
+		Unit* target = currentRef->getTarget();
+		ASSERT(target); // if the ref has status online the target must be there !
+
+		// pussywizard: don't go to threat comparison if this ref is immune to damage or has aura breakable on damage (second choice target)
+		// pussywizard: if this is the last entry on the threat list, then all targets are second choice, set bool to true and loop threat list again, ignoring this section
+		if (!noPriorityTargetFound && (target->IsImmunedToDamageOrSchool(attacker->GetMeleeDamageSchoolMask()) || target->HasNegativeAuraWithInterruptFlag(AURA_INTERRUPT_FLAG_TAKE_DAMAGE) || target->HasAuraTypeWithCaster(SPELL_AURA_IGNORED, attacker->GetGUID())))
+		{
+			if (iter != lastRef)
+			{
+				++iter;
+				continue;
+			}
+			else
+			{
+				noPriorityTargetFound = true;
+				iter = iThreatList.begin();
+				continue;
+			}
+		}
+
+		// pussywizard: skip not valid targets
+		if (attacker->_CanDetectFeignDeathOf(target) && attacker->CanCreatureAttack(target) && !attacker->isTargetNotAcceptableByMMaps(target->GetGUID(), currTime, target))
+		{
+			if (currentVictim) // pussywizard: if not NULL then target must have 10%/30% more threat
+			{
+				if (currentVictim == currentRef) // pussywizard: nothing found previously was good and enough, currentRef passed all necessary tests, so end now
+				{
+					found = true;
+					break;
+				}
+
+				// pussywizard: implement 110% threat rule for targets in melee range and 130% rule for targets in ranged distances
+				if (currentRef->getThreat() > 1.3f * currentVictim->getThreat()) // pussywizard: enough in all cases, end
+				{
+					found = true;
+					break;
+				}
+				else if (currentRef->getThreat() > 1.1f * currentVictim->getThreat()) // pussywizard: enought only if target in melee range
+				{
+					if (attacker->IsWithinMeleeRange(target))
+					{
+						found = true;
+						break;
+					}
+				}
+				else // pussywizard: nothing found previously was good and enough, this and next entries on the list have less than 110% threat, and currentVictim is present and valid as checked before the loop (otherwise it's NULL), so end now
+				{
+					currentRef = currentVictim;
+					found = true;
+					break;
+				}
+			}
+			else // pussywizard: no currentVictim, first passing all checks is chosen (highest threat, list is sorted)
+			{
+				found = true;
+				break;
+			}
+		}
+		++iter;
+	}
+	if (!found)
+		currentRef = NULL;
+
+	return currentRef;
+}
+
+//============================================================
+//=================== ThreatManager ==========================
+//============================================================
+
+ThreatManager::ThreatManager(Unit* owner) : iCurrentVictim(NULL), iOwner(owner), iUpdateTimer(THREAT_UPDATE_INTERVAL)
+{
+}
+
+//============================================================
+
+void ThreatManager::clearReferences()
+{
+    iThreatContainer.clearReferences();
+    iThreatOfflineContainer.clearReferences();
+    iCurrentVictim = NULL;
+    iUpdateTimer = THREAT_UPDATE_INTERVAL;
+}
+
+//============================================================
+
+void ThreatManager::addThreat(Unit* victim, float threat, SpellSchoolMask schoolMask, SpellInfo const* threatSpell)
+{
+    if (!ThreatCalcHelper::isValidProcess(victim, GetOwner(), threatSpell))
+        return;
+
+    doAddThreat(victim, ThreatCalcHelper::calcThreat(victim, iOwner, threat, schoolMask, threatSpell));
+}
+
+void ThreatManager::doAddThreat(Unit* victim, float threat)
+{
+    uint32 redirectThreadPct = victim->GetRedirectThreatPercent();
+
+    // must check > 0.0f, otherwise dead loop
+    if (threat > 0.0f && redirectThreadPct)
+    {
+        if (Unit* redirectTarget = victim->GetRedirectThreatTarget())
+        {
+            float redirectThreat = CalculatePct(threat, redirectThreadPct);
+            threat -= redirectThreat;
+			if (ThreatCalcHelper::isValidProcess(redirectTarget, GetOwner()))
+				_addThreat(redirectTarget, redirectThreat);
+        }
+    }
+
+    _addThreat(victim, threat);
+}
+
+void ThreatManager::_addThreat(Unit* victim, float threat)
+{
+    HostileReference* ref = iThreatContainer.addThreat(victim, threat);
+    // Ref is not in the online refs, search the offline refs next
+    if (!ref)
+        ref = iThreatOfflineContainer.addThreat(victim, threat);
+
+    if (!ref) // there was no ref => create a new one
+    {
+                                                            // threat has to be 0 here
+        HostileReference* hostileRef = new HostileReference(victim, this, 0);
+        iThreatContainer.addReference(hostileRef);
+        hostileRef->addThreat(threat); // now we add the real threat
+        if (victim->GetTypeId() == TYPEID_PLAYER && victim->ToPlayer()->IsGameMaster())
+            hostileRef->setOnlineOfflineState(false); // GM is always offline
+    }
+}
+
+//============================================================
+
+void ThreatManager::modifyThreatPercent(Unit* victim, int32 percent)
+{
+    iThreatContainer.modifyThreatPercent(victim, percent);
+}
+
+//============================================================
+
+Unit* ThreatManager::getHostilTarget()
+{
+    iThreatContainer.update();
+    HostileReference* nextVictim = iThreatContainer.selectNextVictim(GetOwner()->ToCreature(), getCurrentVictim());
+    setCurrentVictim(nextVictim);
+    return getCurrentVictim() != NULL ? getCurrentVictim()->getTarget() : NULL;
+}
+
+//============================================================
+
+float ThreatManager::getThreat(Unit* victim, bool alsoSearchOfflineList)
+{
+    float threat = 0.0f;
+    HostileReference* ref = iThreatContainer.getReferenceByTarget(victim);
+    if (!ref && alsoSearchOfflineList)
+        ref = iThreatOfflineContainer.getReferenceByTarget(victim);
+    if (ref)
+        threat = ref->getThreat();
+    return threat;
+}
+
+//============================================================
+
+float ThreatManager::getThreatWithoutTemp(Unit* victim, bool alsoSearchOfflineList)
+{
+    float threat = 0.0f;
+    HostileReference* ref = iThreatContainer.getReferenceByTarget(victim);
+    if (!ref && alsoSearchOfflineList)
+        ref = iThreatOfflineContainer.getReferenceByTarget(victim);
+    if (ref)
+        threat = ref->getThreat() - ref->getTempThreatModifier();;
+    return threat;
+}
+
+//============================================================
+
+void ThreatManager::tauntApply(Unit* taunter)
+{
+    HostileReference* ref = iThreatContainer.getReferenceByTarget(taunter);
+    if (getCurrentVictim() && ref && (ref->getThreat() < getCurrentVictim()->getThreat()))
+    {
+        if (ref->getTempThreatModifier() == 0.0f) // Ok, temp threat is unused
+            ref->setTempThreat(getCurrentVictim()->getThreat());
+    }
+}
+
+//============================================================
+
+void ThreatManager::tauntFadeOut(Unit* taunter)
+{
+    HostileReference* ref = iThreatContainer.getReferenceByTarget(taunter);
+    if (ref)
+        ref->resetTempThreat();
+}
+
+//============================================================
+
+void ThreatManager::setCurrentVictim(HostileReference* pHostileReference)
+{
+    if (pHostileReference && pHostileReference != iCurrentVictim)
+    {
+        iOwner->SendChangeCurrentVictimOpcode(pHostileReference);
+    }
+    iCurrentVictim = pHostileReference;
+}
+
+//============================================================
+// The hated unit is gone, dead or deleted
+// return true, if the event is consumed
+
+void ThreatManager::processThreatEvent(ThreatRefStatusChangeEvent* threatRefStatusChangeEvent)
+{
+    threatRefStatusChangeEvent->setThreatManager(this);     // now we can set the threat manager
+
+    HostileReference* hostilRef = threatRefStatusChangeEvent->getReference();
+
+    switch (threatRefStatusChangeEvent->getType())
+    {
+        case UEV_THREAT_REF_THREAT_CHANGE:
+            if ((getCurrentVictim() == hostilRef && threatRefStatusChangeEvent->getFValue()<0.0f) ||
+                (getCurrentVictim() != hostilRef && threatRefStatusChangeEvent->getFValue()>0.0f))
+                setDirty(true);                             // the order in the threat list might have changed
+            break;
+        case UEV_THREAT_REF_ONLINE_STATUS:
+            if (!hostilRef->isOnline())
+            {
+                if (hostilRef == getCurrentVictim())
+                {
+                    setCurrentVictim(NULL);
+                    setDirty(true);
+                }
+                if (GetOwner() && GetOwner()->IsInWorld())
+                    if (Unit* target = ObjectAccessor::GetUnit(*GetOwner(), hostilRef->getUnitGuid()))
+                        if (GetOwner()->IsInMap(target))
+                            GetOwner()->SendRemoveFromThreatListOpcode(hostilRef);
+                iThreatContainer.remove(hostilRef);
+                iThreatOfflineContainer.addReference(hostilRef);
+            }
+            else
+            {
+                if (getCurrentVictim() && hostilRef->getThreat() > (1.1f * getCurrentVictim()->getThreat()))
+                    setDirty(true);
+                iThreatContainer.addReference(hostilRef);
+                iThreatOfflineContainer.remove(hostilRef);
+            }
+            break;
+        case UEV_THREAT_REF_REMOVE_FROM_LIST:
+            if (hostilRef == getCurrentVictim())
+            {
+                setCurrentVictim(NULL);
+                setDirty(true);
+            }
+            iOwner->SendRemoveFromThreatListOpcode(hostilRef);
+            if (hostilRef->isOnline())
+                iThreatContainer.remove(hostilRef);
+            else
+                iThreatOfflineContainer.remove(hostilRef);
+            break;
+    }
+}
+
+bool ThreatManager::isNeedUpdateToClient(uint32 time)
+{
+    if (isThreatListEmpty())
+        return false;
+
+    if (time >= iUpdateTimer)
+    {
+        iUpdateTimer = THREAT_UPDATE_INTERVAL;
+        return true;
+    }
+    iUpdateTimer -= time;
+    return false;
+}
+
+// Reset all aggro without modifying the threatlist.
+void ThreatManager::resetAllAggro()
+{
+    ThreatContainer::StorageType &threatList = iThreatContainer.iThreatList;
+    if (threatList.empty())
+        return;
+
+    for (ThreatContainer::StorageType::iterator itr = threatList.begin(); itr != threatList.end(); ++itr)
+        (*itr)->setThreat(0);
+
+    setDirty(true);
+}

src/server/game/Combat/ThreatManager.h

@@ -0,0 +1,289 @@
+/*
+ * Copyright (C) 
+ * Copyright (C) 
+ *
+ * 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef _THREATMANAGER
+#define _THREATMANAGER
+
+#include "Common.h"
+#include "SharedDefines.h"
+#include "LinkedReference/Reference.h"
+#include "UnitEvents.h"
+
+#include <list>
+
+//==============================================================
+
+class Unit;
+class Creature;
+class ThreatManager;
+class SpellInfo;
+
+#define THREAT_UPDATE_INTERVAL 2 * IN_MILLISECONDS    // Server should send threat update to client periodically each second
+
+//==============================================================
+// Class to calculate the real threat based
+
+struct ThreatCalcHelper
+{
+    static float calcThreat(Unit* hatedUnit, Unit* hatingUnit, float threat, SpellSchoolMask schoolMask = SPELL_SCHOOL_MASK_NORMAL, SpellInfo const* threatSpell = NULL);
+    static bool isValidProcess(Unit* hatedUnit, Unit* hatingUnit, SpellInfo const* threatSpell = NULL);
+};
+
+//==============================================================
+class HostileReference : public Reference<Unit, ThreatManager>
+{
+    public:
+        HostileReference(Unit* refUnit, ThreatManager* threatManager, float threat);
+
+        //=================================================
+        void addThreat(float modThreat);
+
+        void setThreat(float threat) { addThreat(threat - getThreat()); }
+
+        void addThreatPercent(int32 percent);
+
+        float getThreat() const { return iThreat; }
+
+        bool isOnline() const { return iOnline; }
+
+        // used for temporary setting a threat and reducting it later again.
+        // the threat modification is stored
+        void setTempThreat(float threat)
+        {
+            addTempThreat(threat - getThreat());
+        }
+
+        void addTempThreat(float threat)
+        {
+            iTempThreatModifier = threat;
+            if (iTempThreatModifier != 0.0f)
+                addThreat(iTempThreatModifier);
+        }
+
+        void resetTempThreat()
+        {
+            if (iTempThreatModifier != 0.0f)
+            {
+                addThreat(-iTempThreatModifier);
+                iTempThreatModifier = 0.0f;
+            }
+        }
+
+        float getTempThreatModifier() { return iTempThreatModifier; }
+
+        //=================================================
+        // check, if source can reach target and set the status
+        void updateOnlineStatus();
+
+        void setOnlineOfflineState(bool isOnline);
+        //=================================================
+
+        bool operator == (const HostileReference& hostileRef) const { return hostileRef.getUnitGuid() == getUnitGuid(); }
+
+        //=================================================
+
+        uint64 getUnitGuid() const { return iUnitGuid; }
+
+        //=================================================
+        // reference is not needed anymore. realy delete it !
+
+        void removeReference();
+
+        //=================================================
+
+        HostileReference* next() { return ((HostileReference*) Reference<Unit, ThreatManager>::next()); }
+
+        //=================================================
+
+        // Tell our refTo (target) object that we have a link
+        void targetObjectBuildLink();
+
+        // Tell our refTo (taget) object, that the link is cut
+        void targetObjectDestroyLink();
+
+        // Tell our refFrom (source) object, that the link is cut (Target destroyed)
+        void sourceObjectDestroyLink();
+    private:
+        // Inform the source, that the status of that reference was changed
+        void fireStatusChanged(ThreatRefStatusChangeEvent& threatRefStatusChangeEvent);
+
+        Unit* GetSourceUnit();
+    private:
+        float iThreat;
+        float iTempThreatModifier;                          // used for taunt
+        uint64 iUnitGuid;
+        bool iOnline;
+};
+
+//==============================================================
+class ThreatManager;
+
+class ThreatContainer
+{
+        friend class ThreatManager;
+
+    public:
+        typedef std::list<HostileReference*> StorageType;
+
+        ThreatContainer(): iDirty(false) { }
+
+        ~ThreatContainer() { clearReferences(); }
+
+        HostileReference* addThreat(Unit* victim, float threat);
+
+        void modifyThreatPercent(Unit* victim, int32 percent);
+
+        HostileReference* selectNextVictim(Creature* attacker, HostileReference* currentVictim) const;
+
+        void setDirty(bool isDirty) { iDirty = isDirty; }
+
+        bool isDirty() const { return iDirty; }
+
+        bool empty() const
+        {
+            return iThreatList.empty();
+        }
+
+        HostileReference* getMostHated() const
+        {
+            return iThreatList.empty() ? NULL : iThreatList.front();
+        }
+
+        HostileReference* getReferenceByTarget(Unit* victim) const;
+
+        StorageType const & getThreatList() const { return iThreatList; }
+
+    private:
+        void remove(HostileReference* hostileRef)
+        {
+            iThreatList.remove(hostileRef);
+        }
+
+        void addReference(HostileReference* hostileRef)
+        {
+            iThreatList.push_back(hostileRef);
+        }
+
+        void clearReferences();
+
+        // Sort the list if necessary
+        void update();
+
+        StorageType iThreatList;
+        bool iDirty;
+};
+
+//=================================================
+
+class ThreatManager
+{
+    public:
+        friend class HostileReference;
+
+        explicit ThreatManager(Unit* owner);
+
+        ~ThreatManager() { clearReferences(); }
+
+        void clearReferences();
+
+        void addThreat(Unit* victim, float threat, SpellSchoolMask schoolMask = SPELL_SCHOOL_MASK_NORMAL, SpellInfo const* threatSpell = NULL);
+
+        void doAddThreat(Unit* victim, float threat);
+
+        void modifyThreatPercent(Unit* victim, int32 percent);
+
+        float getThreat(Unit* victim, bool alsoSearchOfflineList = false);
+
+        float getThreatWithoutTemp(Unit* victim, bool alsoSearchOfflineList = false);
+
+        bool isThreatListEmpty() const { return iThreatContainer.empty(); }
+        bool areThreatListsEmpty() const { return iThreatContainer.empty() && iThreatOfflineContainer.empty(); }
+
+        void processThreatEvent(ThreatRefStatusChangeEvent* threatRefStatusChangeEvent);
+
+        bool isNeedUpdateToClient(uint32 time);
+
+        HostileReference* getCurrentVictim() const { return iCurrentVictim; }
+
+        Unit* GetOwner() const { return iOwner; }
+
+        Unit* getHostilTarget();
+
+        void tauntApply(Unit* taunter);
+        void tauntFadeOut(Unit* taunter);
+
+        void setCurrentVictim(HostileReference* hostileRef);
+
+        void setDirty(bool isDirty) { iThreatContainer.setDirty(isDirty); }
+
+        // Reset all aggro without modifying the threadlist.
+        void resetAllAggro();
+
+        // Reset all aggro of unit in threadlist satisfying the predicate.
+        template<class PREDICATE> void resetAggro(PREDICATE predicate)
+        {
+            ThreatContainer::StorageType &threatList = iThreatContainer.iThreatList;
+            if (threatList.empty())
+                return;
+
+            for (ThreatContainer::StorageType::iterator itr = threatList.begin(); itr != threatList.end(); ++itr)
+            {
+                HostileReference* ref = (*itr);
+
+                if (predicate(ref->getTarget()))
+                {
+                    ref->setThreat(0);
+                    setDirty(true);
+                }
+            }
+        }
+
+        // methods to access the lists from the outside to do some dirty manipulation (scriping and such)
+        // I hope they are used as little as possible.
+        ThreatContainer::StorageType const & getThreatList() const { return iThreatContainer.getThreatList(); }
+        ThreatContainer::StorageType const & getOfflineThreatList() const { return iThreatOfflineContainer.getThreatList(); }
+        ThreatContainer& getOnlineContainer() { return iThreatContainer; }
+        ThreatContainer& getOfflineContainer() { return iThreatOfflineContainer; }
+    private:
+        void _addThreat(Unit* victim, float threat);
+
+        HostileReference* iCurrentVictim;
+        Unit* iOwner;
+        uint32 iUpdateTimer;
+        ThreatContainer iThreatContainer;
+        ThreatContainer iThreatOfflineContainer;
+};
+
+//=================================================
+
+namespace Trinity
+{
+    // Binary predicate for sorting HostileReferences based on threat value
+    class ThreatOrderPred
+    {
+        public:
+            ThreatOrderPred(bool ascending = false) : m_ascending(ascending) {}
+            bool operator() (HostileReference const* a, HostileReference const* b) const
+            {
+                return m_ascending ? a->getThreat() < b->getThreat() : a->getThreat() > b->getThreat();
+            }
+        private:
+            const bool m_ascending;
+    };
+}
+#endif