Scripts/Spells: Fix Argent Tournament mount spells:

 * Break-Shield
 * Charge
 * Defend (visual)
 * Mounted duel
 * Faction Pennants when riding argent tournament mounts
Closes #4917.

6 files changed, 813 insertions, 3 deletions

diff --git a/src/server/game/Entities/Player/Player.h b/src/server/game/Entities/Player/Player.h
index c39d29db12a..2fa171cf3f9 100755
--- a/src/server/game/Entities/Player/Player.h
+++ b/src/server/game/Entities/Player/Player.h
@@ -274,13 +274,14 @@ struct PvPInfo
 
 struct DuelInfo
 {
-    DuelInfo() : initiator(NULL), opponent(NULL), startTimer(0), startTime(0), outOfBound(0) {}
+    DuelInfo() : initiator(NULL), opponent(NULL), startTimer(0), startTime(0), outOfBound(0), isMounted(false) {}
 
     Player* initiator;
     Player* opponent;
     time_t startTimer;
     time_t startTime;
     time_t outOfBound;
+    bool isMounted;
 };
 
 struct Areas
diff --git a/src/server/game/Entities/Unit/Unit.cpp b/src/server/game/Entities/Unit/Unit.cpp
index 6bab63acf1b..e02331e00e7 100755
--- a/src/server/game/Entities/Unit/Unit.cpp
+++ b/src/server/game/Entities/Unit/Unit.cpp
@@ -628,6 +628,7 @@ uint32 Unit::DealDamage(Unit* victim, uint32 damage, CleanDamage const* cleanDam
 
     // duel ends when player has 1 or less hp
     bool duel_hasEnded = false;
+    bool duel_wasMounted = false;
     if (victim->GetTypeId() == TYPEID_PLAYER && victim->ToPlayer()->duel && damage >= (health-1))
     {
         // prevent kill only if killed in duel and killed by opponent or opponent controlled creature
@@ -636,6 +637,20 @@ uint32 Unit::DealDamage(Unit* victim, uint32 damage, CleanDamage const* cleanDam
 
         duel_hasEnded = true;
     }
+    else if (victim->IsVehicle() && damage >= (health-1) && victim->GetCharmer() && victim->GetCharmer()->GetTypeId() ==  TYPEID_PLAYER)
+    {
+        Player* victimRider = victim->GetCharmer()->ToPlayer();
+
+        if (victimRider && victimRider->duel && victimRider->duel->isMounted)
+        {
+            // prevent kill only if killed in duel and killed by opponent or opponent controlled creature
+            if (victimRider->duel->opponent == this || victimRider->duel->opponent->GetGUID() == GetCharmerGUID())
+                damage = health - 1;
+
+            duel_wasMounted = true;
+            duel_hasEnded = true;
+        }
+    }
 
     if (GetTypeId() == TYPEID_PLAYER && this != victim)
     {
@@ -745,8 +760,18 @@ uint32 Unit::DealDamage(Unit* victim, uint32 damage, CleanDamage const* cleanDam
         // last damage from duel opponent
         if (duel_hasEnded)
         {
-            ASSERT(victim->GetTypeId() == TYPEID_PLAYER);
-            Player* he = victim->ToPlayer();
+            Player* he;
+
+            if (duel_wasMounted)
+            {
+                ASSERT(victim->GetCharmer()->GetTypeId() == TYPEID_PLAYER);
+                he = victim->GetCharmer()->ToPlayer();
+            }
+            else
+            {
+                ASSERT(victim->GetTypeId() == TYPEID_PLAYER);
+                he = victim->ToPlayer();
+            }
 
             ASSERT(he->duel);
 
@@ -16954,6 +16979,10 @@ void Unit::_ExitVehicle(Position const* exitPosition)
 
     m_vehicle->RemovePassenger(this);
 
+    // If player is on mouted duel and exits the mount should immediatly lose the duel
+    if (GetTypeId() == TYPEID_PLAYER && ToPlayer()->duel && ToPlayer()->duel->isMounted)
+        ToPlayer()->DuelComplete(DUEL_FLED);
+
     // This should be done before dismiss, because there may be some aura removal
     Vehicle* vehicle = m_vehicle;
     m_vehicle = NULL;
diff --git a/src/server/game/Spells/SpellEffects.cpp b/src/server/game/Spells/SpellEffects.cpp
index c3357b99601..d5a9bf923b4 100755
--- a/src/server/game/Spells/SpellEffects.cpp
+++ b/src/server/game/Spells/SpellEffects.cpp
@@ -5607,6 +5607,7 @@ void Spell::EffectDuel(SpellEffIndex effIndex)
     duel->opponent   = target;
     duel->startTime  = 0;
     duel->startTimer = 0;
+    duel->isMounted  = (GetSpellInfo()->Id == 62875); // Mounted Duel
     caster->duel     = duel;
 
     DuelInfo* duel2   = new DuelInfo;
@@ -5614,6 +5615,7 @@ void Spell::EffectDuel(SpellEffIndex effIndex)
     duel2->opponent   = caster;
     duel2->startTime  = 0;
     duel2->startTimer = 0;
+    duel2->isMounted  = (GetSpellInfo()->Id == 62875); // Mounted Duel
     target->duel      = duel2;
 
     caster->SetUInt64Value(PLAYER_DUEL_ARBITER, pGameObj->GetGUID());
diff --git a/src/server/game/Spells/SpellMgr.cpp b/src/server/game/Spells/SpellMgr.cpp
index f3d5697c672..171382ba4f7 100755
--- a/src/server/game/Spells/SpellMgr.cpp
+++ b/src/server/game/Spells/SpellMgr.cpp
@@ -2889,6 +2889,22 @@ void SpellMgr::LoadSpellCustomAttr()
             case 69293: // Wing Buffet
             case 74439: // Machine Gun
             case 63278: // Mark of the Faceless (General Vezax)
+            case 62544: // Thrust (Argent Tournament)
+            case 64588: // Thrust (Argent Tournament)
+            case 66479: // Thrust (Argent Tournament)
+            case 68505: // Thrust (Argent Tournament)
+            case 62626: // Break-Shield (Argent Tournament, Player)
+            case 64590: // Break-Shield (Argent Tournament, Player)
+            case 64342: // Break-Shield (Argent Tournament, NPC)
+            case 64686: // Break-Shield (Argent Tournament, NPC)
+            case 65147: // Break-Shield (Argent Tournament, NPC)
+            case 68504: // Break-Shield (Argent Tournament, NPC)
+            case 62874: // Charge (Argent Tournament, Player)
+            case 68498: // Charge (Argent Tournament, Player)
+            case 64591: // Charge (Argent Tournament, Player)
+            case 63003: // Charge (Argent Tournament, NPC)
+            case 63010: // Charge (Argent Tournament, NPC)
+            case 68321: // Charge (Argent Tournament, NPC)
             case 72255: // Mark of the Fallen Champion (Deathbringer Saurfang)
             case 72444: // Mark of the Fallen Champion (Deathbringer Saurfang)
             case 72445: // Mark of the Fallen Champion (Deathbringer Saurfang)
@@ -2972,6 +2988,7 @@ void SpellMgr::LoadDbcDataCorrections()
                 spellInfo->EffectImplicitTargetA[0] = TARGET_UNIT_TARGET_ENEMY;
                 spellInfo->EffectImplicitTargetB[0] = 0;
                 break;
+            case 63665: // Charge (Argent Tournament emote on riders)
             case 31447: // Mark of Kaz'rogal (needs target selection script)
             case 31298: // Sleep (needs target selection script)
             case 51904: // Summon Ghouls On Scarlet Crusade (this should use conditions table, script for this spell needs to be fixed)
diff --git a/src/server/scripts/Spells/spell_generic.cpp b/src/server/scripts/Spells/spell_generic.cpp
index d0307966795..96d259817c0 100644
--- a/src/server/scripts/Spells/spell_generic.cpp
+++ b/src/server/scripts/Spells/spell_generic.cpp
@@ -1626,6 +1626,748 @@ class spell_gen_dalaran_disguise : public SpellScriptLoader
         }
 };
 
+/* DOCUMENTATION: Break-Shield spells
+    Break-Shield spells can be classified in three groups:
+
+        - Spells on vehicle bar used by players:
+            + EFFECT_0: SCRIPT_EFFECT
+            + EFFECT_1: NONE
+            + EFFECT_2: NONE
+        - Spells casted by players triggered by script:
+            + EFFECT_0: SCHOOL_DAMAGE
+            + EFFECT_1: SCRIPT_EFFECT
+            + EFFECT_2: FORCE_CAST
+        - Spells casted by NPCs on players:
+            + EFFECT_0: SCHOOL_DAMAGE
+            + EFFECT_1: SCRIPT_EFFECT
+            + EFFECT_2: NONE
+
+    In the following script we handle the SCRIPT_EFFECT for effIndex EFFECT_0 and EFFECT_1.
+        - When handling EFFECT_0 we're in the "Spells on vehicle bar used by players" case
+          and we'll trigger "Spells casted by players triggered by script"
+        - When handling EFFECT_1 we're in the "Spells casted by players triggered by script"
+          or "Spells casted by NPCs on players" so we'll search for the first defend layer and drop it.
+*/
+
+enum BreakShieldSpells
+{
+    SPELL_BREAK_SHIELD_DAMAGE_2K                 = 62626,
+    SPELL_BREAK_SHIELD_DAMAGE_10K                = 64590,
+
+    SPELL_BREAK_SHIELD_TRIGGER_FACTION_MOUNTS    = 62575, // Also on ToC5 mounts
+    SPELL_BREAK_SHIELD_TRIGGER_CAMPAING_WARHORSE = 64595,
+    SPELL_BREAK_SHIELD_TRIGGER_UNK               = 66480,
+};
+
+class spell_gen_break_shield: public SpellScriptLoader
+{
+public:
+    spell_gen_break_shield() : SpellScriptLoader("spell_gen_break_shield") { }
+
+    class spell_gen_break_shield_SpellScript : public SpellScript
+    {
+        PrepareSpellScript(spell_gen_break_shield_SpellScript)
+
+        void HandleScriptEffect(SpellEffIndex effIndex)
+        {
+            Unit* caster = GetCaster();
+            Unit* target = GetTargetUnit();
+
+            if (!caster || !target)
+                return;
+
+            switch (effIndex)
+            {
+                case EFFECT_0: // On spells wich trigger the damaging spell (and also the visual)
+                    uint32 spellId;
+                    switch (GetSpellInfo()->Id)
+                    {
+                        case SPELL_BREAK_SHIELD_TRIGGER_UNK:
+                        case SPELL_BREAK_SHIELD_TRIGGER_CAMPAING_WARHORSE:
+                            spellId = SPELL_BREAK_SHIELD_DAMAGE_10K;
+                            break;
+                        case SPELL_BREAK_SHIELD_TRIGGER_FACTION_MOUNTS:
+                            spellId = SPELL_BREAK_SHIELD_DAMAGE_2K;
+                            break;
+                        default:
+                            return;
+                    }
+
+                    if (Unit* rider = caster->GetCharmer())
+                        rider->CastSpell(target, spellId, false);
+                    else
+                        caster->CastSpell(target, spellId, false);
+                    break;
+                case EFFECT_1: // On damaging spells, for removing the a defend layer
+                    Unit::AuraApplicationMap const& auras = target->GetAppliedAuras();
+                    for (Unit::AuraApplicationMap::const_iterator itr = auras.begin(); itr != auras.end(); ++itr)
+                    {
+                        Aura* aura = itr->second->GetBase();
+                        SpellInfo const* auraInfo = aura->GetSpellInfo();
+                        if (aura && auraInfo->SpellIconID == 2007 && aura->HasEffectType(SPELL_AURA_MOD_DAMAGE_PERCENT_TAKEN))
+                            aura->ModStackAmount(-1, AURA_REMOVE_BY_ENEMY_SPELL);
+                    }
+                    break;
+            }
+        }
+
+        void Register()
+        {
+            OnEffectHit += SpellEffectFn(spell_gen_break_shield_SpellScript::HandleScriptEffect, EFFECT_FIRST_FOUND, SPELL_EFFECT_SCRIPT_EFFECT);
+        }
+    };
+
+    SpellScript* GetSpellScript() const
+    {
+        return new spell_gen_break_shield_SpellScript();
+    }
+};
+
+/* DOCUMENTATION: Charge spells
+    Charge spells can be classified in four groups:
+
+        - Spells on vehicle bar used by players:
+            + EFFECT_0: SCRIPT_EFFECT
+            + EFFECT_1: TRIGGER_SPELL
+            + EFFECT_2: NONE
+        - Spells casted by player's mounts triggered by script:
+            + EFFECT_0: CHARGE
+            + EFFECT_1: TRIGGER_SPELL
+            + EFFECT_2: APPLY_AURA
+        - Spells casted by players on the target triggered by script:
+            + EFFECT_0: SCHOOL_DAMAGE
+            + EFFECT_1: SCRIPT_EFFECT
+            + EFFECT_2: NONE
+        - Spells casted by NPCs on players:
+            + EFFECT_0: SCHOOL_DAMAGE
+            + EFFECT_1: CHARGE
+            + EFFECT_2: SCRIPT_EFFECT
+
+    In the following script we handle the SCRIPT_EFFECT and CHARGE
+        - When handling SCRIPT_EFFECT:
+            + EFFECT_0: Corresponds to "Spells on vehicle bar used by players" and we make player's mount cast
+              the charge effect on the current target ("Spells casted by player's mounts triggered by script").
+            + EFFECT_1 and EFFECT_2: Triggered when "Spells casted by player's mounts triggered by script" hits target,
+              corresponding to "Spells casted by players on the target triggered by script" and "Spells casted by
+              NPCs on players" and we check Defend layers and drop a charge of the first found.
+        - When handling CHARGE:
+            + Only launched for "Spells casted by player's mounts triggered by script", makes the player cast the
+              damaging spell on target with a small chance of failing it.
+*/
+
+enum ChargeSpells
+{
+    SPELL_CHARGE_DAMAGE_8K5             = 62874,
+    SPELL_CHARGE_DAMAGE_20K             = 68498,
+    SPELL_CHARGE_DAMAGE_45K             = 64591,
+
+    SPELL_CHARGE_CHARGING_EFFECT_8K5    = 63661,
+    SPELL_CHARGE_CHARGING_EFFECT_20K_1  = 68284,
+    SPELL_CHARGE_CHARGING_EFFECT_20K_2  = 68501,
+    SPELL_CHARGE_CHARGING_EFFECT_45K_1  = 62563,
+    SPELL_CHARGE_CHARGING_EFFECT_45K_2  = 66481,
+
+    SPELL_CHARGE_TRIGGER_FACTION_MOUNTS = 62960,
+    SPELL_CHARGE_TRIGGER_TRIAL_CHAMPION = 68282,
+
+    SPELL_CHARGE_MISS_EFFECT            = 62977,
+};
+
+class spell_gen_mounted_charge: public SpellScriptLoader
+{
+public:
+    spell_gen_mounted_charge() : SpellScriptLoader("spell_gen_mounted_charge") { }
+
+    class spell_gen_mounted_charge_SpellScript : public SpellScript
+    {
+        PrepareSpellScript(spell_gen_mounted_charge_SpellScript)
+
+        void HandleScriptEffect(SpellEffIndex effIndex)
+        {
+            Unit* caster = GetCaster();
+            Unit* target = GetTargetUnit();
+
+            if (!caster || !target)
+                return;
+
+            switch (effIndex)
+            {
+                case EFFECT_0: // On spells wich trigger the damaging spell (and also the visual)
+                    uint32 spellId;
+
+                    switch (GetSpellInfo()->Id)
+                    {
+                        case SPELL_CHARGE_TRIGGER_TRIAL_CHAMPION:
+                            spellId = SPELL_CHARGE_CHARGING_EFFECT_20K_1;
+                        case SPELL_CHARGE_TRIGGER_FACTION_MOUNTS:
+                            spellId = SPELL_CHARGE_CHARGING_EFFECT_8K5;
+                            break;
+                        default:
+                            return;
+                    }
+
+                    if (Unit* vehicle = caster->GetVehicleBase())
+                        vehicle->CastSpell(target, spellId, false);
+                    else
+                        caster->CastSpell(target, spellId, false);
+                    break;
+                case EFFECT_1: // On damaging spells, for removing the a defend layer
+                case EFFECT_2:
+                    Unit::AuraApplicationMap const& auras = target->GetAppliedAuras();
+                    for (Unit::AuraApplicationMap::const_iterator itr = auras.begin(); itr != auras.end(); ++itr)
+                    {
+                        Aura* aura = itr->second->GetBase();
+                        SpellInfo const* auraInfo = aura->GetSpellInfo();
+                        if (aura && auraInfo->SpellIconID == 2007 && aura->HasEffectType(SPELL_AURA_MOD_DAMAGE_PERCENT_TAKEN))
+                            aura->ModStackAmount(-1, AURA_REMOVE_BY_ENEMY_SPELL);
+                    }
+                    break;
+            }
+        }
+
+        void HandleChargeEffect(SpellEffIndex effIndex)
+        {
+            Unit* caster = GetCaster();
+            Unit* target = GetTargetUnit();
+
+            if (!caster || !target)
+                return;
+
+            uint32 spellId;
+
+            switch (GetSpellInfo()->Id)
+            {
+                case SPELL_CHARGE_CHARGING_EFFECT_8K5:
+                    spellId = SPELL_CHARGE_DAMAGE_8K5;
+                    break;
+                case SPELL_CHARGE_CHARGING_EFFECT_20K_1:
+                case SPELL_CHARGE_CHARGING_EFFECT_20K_2:
+                    spellId = SPELL_CHARGE_DAMAGE_20K;
+                    break;
+                case SPELL_CHARGE_CHARGING_EFFECT_45K_1:
+                case SPELL_CHARGE_CHARGING_EFFECT_45K_2:
+                    spellId = SPELL_CHARGE_DAMAGE_45K;
+                    break;
+                default:
+                    return;
+            }
+
+            // If target isn't a training dummy there's a chance of failing the charge
+            if (!target->HasFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_DISABLE_MOVE) && urand(0,7) == 0)
+                spellId = SPELL_CHARGE_MISS_EFFECT;
+
+            if (Unit* rider = caster->GetCharmer())
+                rider->CastSpell(target, spellId, false);
+            else
+                caster->CastSpell(target, spellId, false);
+        }
+
+        void Register()
+        {
+            SpellInfo const* spell = sSpellMgr->GetSpellInfo(m_scriptSpellId);
+
+            if (spell->HasEffect(SPELL_EFFECT_SCRIPT_EFFECT))
+                OnEffectHit += SpellEffectFn(spell_gen_mounted_charge_SpellScript::HandleScriptEffect, EFFECT_FIRST_FOUND, SPELL_EFFECT_SCRIPT_EFFECT);
+
+            if (spell->Effects[EFFECT_0].Effect == SPELL_EFFECT_CHARGE)
+                OnEffectHit += SpellEffectFn(spell_gen_mounted_charge_SpellScript::HandleChargeEffect, EFFECT_0, SPELL_EFFECT_CHARGE);
+        }
+    };
+
+    SpellScript* GetSpellScript() const
+    {
+        return new spell_gen_mounted_charge_SpellScript();
+    }
+};
+
+enum DefendVisuals
+{
+    SPELL_VISUAL_SHIELD_1 = 63130,
+    SPELL_VISUAL_SHIELD_2 = 63131,
+    SPELL_VISUAL_SHIELD_3 = 63132,
+};
+
+class spell_gen_defend : public SpellScriptLoader
+{
+    public:
+        spell_gen_defend() : SpellScriptLoader("spell_gen_defend") { }
+
+        class spell_gen_defendAuraScript : public AuraScript
+        {
+            PrepareAuraScript(spell_gen_defendAuraScript);
+
+            bool Validate(SpellInfo const* /*spellEntry*/)
+            {
+                if (!sSpellMgr->GetSpellInfo(SPELL_VISUAL_SHIELD_1))
+                    return false;
+                if (!sSpellMgr->GetSpellInfo(SPELL_VISUAL_SHIELD_2))
+                    return false;
+                if (!sSpellMgr->GetSpellInfo(SPELL_VISUAL_SHIELD_3))
+                    return false;
+                return true;
+            }
+
+            void RefreshVisualShields(AuraEffect const* /*aurEff*/, AuraEffectHandleModes /*mode*/)
+            {
+                Unit* caster = GetCaster();
+                Unit* target = GetTarget();
+
+                if(!target)
+                    return;
+
+                if (!caster)
+                {
+                    target->RemoveAurasDueToSpell(GetId());
+                    return;
+                }
+
+                for (uint8 i = 0; i < GetSpellInfo()->StackAmount; ++i)
+                    target->RemoveAurasDueToSpell(SPELL_VISUAL_SHIELD_1 + i);
+
+                target->CastSpell(target, SPELL_VISUAL_SHIELD_1 + GetAura()->GetStackAmount() - 1);
+            }
+
+            void RemoveVisualShields(AuraEffect const* /*aurEff*/, AuraEffectHandleModes /*mode*/)
+            {
+                Unit* target = GetTarget();
+
+                if(!target)
+                    return;
+
+                for (uint8 i = 0; i < GetSpellInfo()->StackAmount; ++i)
+                    target->RemoveAurasDueToSpell(SPELL_VISUAL_SHIELD_1 + i);
+            }
+
+            void RemoveDummyFromDriver(AuraEffect const* /*aurEff*/, AuraEffectHandleModes /*mode*/)
+            {
+                Unit* caster = GetCaster();
+
+                if (caster && caster->ToTempSummon())
+                    if (Unit* rider = caster->ToTempSummon()->GetSummoner())
+                        rider->RemoveAurasDueToSpell(GetId());
+            }
+
+            void Register()
+            {
+                SpellInfo const* spell = sSpellMgr->GetSpellInfo(m_scriptSpellId);
+
+                // Defend spells casted by NPCs (add visuals)
+                if (spell->Effects[EFFECT_0].ApplyAuraName == SPELL_AURA_MOD_DAMAGE_PERCENT_TAKEN)
+                {
+                    AfterEffectApply += AuraEffectApplyFn(spell_gen_defendAuraScript::RefreshVisualShields, EFFECT_0, SPELL_AURA_MOD_DAMAGE_PERCENT_TAKEN, AURA_EFFECT_HANDLE_REAL_OR_REAPPLY_MASK);
+                    OnEffectRemove += AuraEffectRemoveFn(spell_gen_defendAuraScript::RemoveVisualShields, EFFECT_0, SPELL_AURA_MOD_DAMAGE_PERCENT_TAKEN, AURA_EFFECT_HANDLE_REAL);
+                }
+
+                // Remove Defend spell from player when he dismounts
+                if (spell->Effects[EFFECT_2].ApplyAuraName == SPELL_AURA_MOD_DAMAGE_PERCENT_TAKEN)
+                    OnEffectRemove += AuraEffectRemoveFn(spell_gen_defendAuraScript::RemoveDummyFromDriver, EFFECT_2, SPELL_AURA_MOD_DAMAGE_PERCENT_TAKEN, AURA_EFFECT_HANDLE_REAL);
+
+                // Defend spells casted by players (add/remove visuals)
+                if (spell->Effects[EFFECT_1].ApplyAuraName == SPELL_AURA_DUMMY)
+                {
+                    AfterEffectApply += AuraEffectApplyFn(spell_gen_defendAuraScript::RefreshVisualShields, EFFECT_1, SPELL_AURA_DUMMY, AURA_EFFECT_HANDLE_REAL_OR_REAPPLY_MASK);
+                    OnEffectRemove += AuraEffectRemoveFn(spell_gen_defendAuraScript::RemoveVisualShields, EFFECT_1, SPELL_AURA_DUMMY, AURA_EFFECT_HANDLE_REAL);
+                }
+            }
+        };
+
+        AuraScript* GetAuraScript() const
+        {
+            return new spell_gen_defendAuraScript();
+        }
+};
+
+enum MountedDuelSpells
+{
+    SPELL_ON_TOURNAMENT_MOUNT = 63034,
+    SPELL_MOUNTED_DUEL        = 62875,
+};
+
+class spell_gen_tournament_duel : public SpellScriptLoader
+{
+    public:
+        spell_gen_tournament_duel() : SpellScriptLoader("spell_gen_tournament_duel") { }
+
+        class spell_gen_tournament_duel_SpellScript : public SpellScript
+        {
+            PrepareSpellScript(spell_gen_tournament_duel_SpellScript);
+
+            bool Validate(SpellInfo const* /*spellEntry*/)
+            {
+                if (!sSpellMgr->GetSpellInfo(SPELL_ON_TOURNAMENT_MOUNT))
+                    return false;
+                if (!sSpellMgr->GetSpellInfo(SPELL_MOUNTED_DUEL))
+                    return false;
+                return true;
+            }
+
+            void HandleScriptEffect(SpellEffIndex effIndex)
+            {
+                Unit* caster = GetCaster();
+                Unit* target = GetTargetUnit();
+                Unit* player = GetCaster()->GetCharmer();
+
+                if (!caster || !target || !player)
+                    return;
+
+                if (target->GetTypeId() == TYPEID_PLAYER)
+                {
+
+                    if (!target->HasAura(SPELL_ON_TOURNAMENT_MOUNT) || !target->GetVehicleBase())
+                        return;
+
+                    player->CastSpell(target, SPELL_MOUNTED_DUEL, true);
+                }
+                else if (target->GetTypeId() == TYPEID_UNIT)
+                {
+                    if (!target->GetCharmer() || target->GetCharmer()->GetTypeId() != TYPEID_PLAYER || !target->GetCharmer()->HasAura(SPELL_ON_TOURNAMENT_MOUNT))
+                        return;
+
+                    player->CastSpell(target->GetCharmer(), SPELL_MOUNTED_DUEL, true);
+                }
+            }
+
+            void Register()
+            {
+                OnEffectHit += SpellEffectFn(spell_gen_tournament_duel_SpellScript::HandleScriptEffect, EFFECT_0, SPELL_EFFECT_SCRIPT_EFFECT);
+            }
+        };
+
+        SpellScript* GetSpellScript() const
+        {
+            return new spell_gen_tournament_duel_SpellScript();
+        }
+};
+
+enum TournamentMountsSpells
+{
+    SPELL_LANCE_EQUIPPED = 62853,
+};
+
+class spell_gen_summon_tournament_mount : public SpellScriptLoader
+{
+    public:
+        spell_gen_summon_tournament_mount() : SpellScriptLoader("spell_gen_summon_tournament_mount") { }
+
+        class spell_gen_summon_tournament_mount_SpellScript : public SpellScript
+        {
+            PrepareSpellScript(spell_gen_summon_tournament_mount_SpellScript);
+
+            bool Validate(SpellInfo const* /*spellEntry*/)
+            {
+                if (!sSpellMgr->GetSpellInfo(SPELL_LANCE_EQUIPPED))
+                    return false;
+                return true;
+            }
+
+            SpellCastResult CheckIfLanceEquiped()
+            {
+                Unit* caster = GetCaster();
+
+                if (!caster->HasAura(SPELL_LANCE_EQUIPPED))
+                {
+                    SetCustomCastResultMessage(SPELL_CUSTOM_ERROR_MUST_HAVE_LANCE_EQUIPPED);
+                    return SPELL_FAILED_CUSTOM_ERROR;
+                }
+
+                return SPELL_CAST_OK;
+            }
+
+            void Register()
+            {
+                OnCheckCast += SpellCheckCastFn(spell_gen_summon_tournament_mount_SpellScript::CheckIfLanceEquiped);
+            }
+        };
+
+        SpellScript* GetSpellScript() const
+        {
+            return new spell_gen_summon_tournament_mount_SpellScript();
+        }
+};
+
+enum TournamentPennantSpells
+{
+    SPELL_PENNANT_STORMWIND_ASPIRANT      = 62595,
+    SPELL_PENNANT_STORMWIND_VALIANT       = 62596,
+    SPELL_PENNANT_STORMWIND_CHAMPION      = 62594,
+    SPELL_PENNANT_GNOMEREGAN_ASPIRANT     = 63394,
+    SPELL_PENNANT_GNOMEREGAN_VALIANT      = 63395,
+    SPELL_PENNANT_GNOMEREGAN_CHAMPION     = 63396,
+    SPELL_PENNANT_SEN_JIN_ASPIRANT        = 63397,
+    SPELL_PENNANT_SEN_JIN_VALIANT         = 63398,
+    SPELL_PENNANT_SEN_JIN_CHAMPION        = 63399,
+    SPELL_PENNANT_SILVERMOON_ASPIRANT     = 63401,
+    SPELL_PENNANT_SILVERMOON_VALIANT      = 63402,
+    SPELL_PENNANT_SILVERMOON_CHAMPION     = 63403,
+    SPELL_PENNANT_DARNASSUS_ASPIRANT      = 63404,
+    SPELL_PENNANT_DARNASSUS_VALIANT       = 63405,
+    SPELL_PENNANT_DARNASSUS_CHAMPION      = 63406,
+    SPELL_PENNANT_EXODAR_ASPIRANT         = 63421,
+    SPELL_PENNANT_EXODAR_VALIANT          = 63422,
+    SPELL_PENNANT_EXODAR_CHAMPION         = 63423,
+    SPELL_PENNANT_IRONFORGE_ASPIRANT      = 63425,
+    SPELL_PENNANT_IRONFORGE_VALIANT       = 63426,
+    SPELL_PENNANT_IRONFORGE_CHAMPION      = 63427,
+    SPELL_PENNANT_UNDERCITY_ASPIRANT      = 63428,
+    SPELL_PENNANT_UNDERCITY_VALIANT       = 63429,
+    SPELL_PENNANT_UNDERCITY_CHAMPION      = 63430,
+    SPELL_PENNANT_ORGRIMMAR_ASPIRANT      = 63431,
+    SPELL_PENNANT_ORGRIMMAR_VALIANT       = 63432,
+    SPELL_PENNANT_ORGRIMMAR_CHAMPION      = 63433,
+    SPELL_PENNANT_THUNDER_BLUFF_ASPIRANT  = 63434,
+    SPELL_PENNANT_THUNDER_BLUFF_VALIANT   = 63435,
+    SPELL_PENNANT_THUNDER_BLUFF_CHAMPION  = 63436,
+    SPELL_PENNANT_ARGENT_CRUSADE_ASPIRANT = 63606,
+    SPELL_PENNANT_ARGENT_CRUSADE_VALIANT  = 63500,
+    SPELL_PENNANT_ARGENT_CRUSADE_CHAMPION = 63501,
+    SPELL_PENNANT_EBON_BLADE_ASPIRANT     = 63607,
+    SPELL_PENNANT_EBON_BLADE_VALIANT      = 63608,
+    SPELL_PENNANT_EBON_BLADE_CHAMPION     = 63609,
+};
+
+enum TournamentMounts
+{
+    NPC_STORMWIND_STEED             = 33217,
+    NPC_IRONFORGE_RAM               = 33316,
+    NPC_GNOMEREGAN_MECHANOSTRIDER   = 33317,
+    NPC_EXODAR_ELEKK                = 33318,
+    NPC_DARNASSIAN_NIGHTSABER       = 33319,
+    NPC_ORGRIMMAR_WOLF              = 33320,
+    NPC_DARK_SPEAR_RAPTOR           = 33321,
+    NPC_THUNDER_BLUFF_KODO          = 33322,
+    NPC_SILVERMOON_HAWKSTRIDER      = 33323,
+    NPC_FORSAKEN_WARHORSE           = 33324,
+    NPC_ARGENT_WARHORSE             = 33782,
+    NPC_ARGENT_STEED_ASPIRANT       = 33845,
+    NPC_ARGENT_HAWKSTRIDER_ASPIRANT = 33844,
+};
+
+enum TournamentQuestsAchievements
+{
+    ACHIEVEMENT_CHAMPION_STORMWIND     = 2781,
+    ACHIEVEMENT_CHAMPION_DARNASSUS     = 2777,
+    ACHIEVEMENT_CHAMPION_IRONFORGE     = 2780,
+    ACHIEVEMENT_CHAMPION_GNOMEREGAN    = 2779,
+    ACHIEVEMENT_CHAMPION_THE_EXODAR    = 2778,
+    ACHIEVEMENT_CHAMPION_ORGRIMMAR     = 2783,
+    ACHIEVEMENT_CHAMPION_SEN_JIN       = 2784,
+    ACHIEVEMENT_CHAMPION_THUNDER_BLUFF = 2786,
+    ACHIEVEMENT_CHAMPION_UNDERCITY     = 2787,
+    ACHIEVEMENT_CHAMPION_SILVERMOON    = 2785,
+    ACHIEVEMENT_ARGENT_VALOR           = 2758,
+    ACHIEVEMENT_CHAMPION_ALLIANCE      = 2782,
+    ACHIEVEMENT_CHAMPION_HORDE         = 2788,
+
+    QUEST_VALIANT_OF_STORMWIND         = 13593,
+    QUEST_A_VALIANT_OF_STORMWIND       = 13684,
+    QUEST_VALIANT_OF_DARNASSUS         = 13706,
+    QUEST_A_VALIANT_OF_DARNASSUS       = 13689,
+    QUEST_VALIANT_OF_IRONFORGE         = 13703,
+    QUEST_A_VALIANT_OF_IRONFORGE       = 13685,
+    QUEST_VALIANT_OF_GNOMEREGAN        = 13704,
+    QUEST_A_VALIANT_OF_GNOMEREGAN      = 13688,
+    QUEST_VALIANT_OF_THE_EXODAR        = 13705,
+    QUEST_A_VALIANT_OF_THE_EXODAR      = 13690,
+    QUEST_VALIANT_OF_ORGRIMMAR         = 13707,
+    QUEST_A_VALIANT_OF_ORGRIMMAR       = 13691,
+    QUEST_VALIANT_OF_SEN_JIN           = 13708,
+    QUEST_A_VALIANT_OF_SEN_JIN         = 13693,
+    QUEST_VALIANT_OF_THUNDER_BLUFF     = 13709,
+    QUEST_A_VALIANT_OF_THUNDER_BLUFF   = 13694,
+    QUEST_VALIANT_OF_UNDERCITY         = 13710,
+    QUEST_A_VALIANT_OF_UNDERCITY       = 13695,
+    QUEST_VALIANT_OF_SILVERMOON        = 13711,
+    QUEST_A_VALIANT_OF_SILVERMOON      = 13696,
+};
+
+class spell_gen_on_tournament_mount : public SpellScriptLoader
+{
+    public:
+        spell_gen_on_tournament_mount() : SpellScriptLoader("spell_gen_on_tournament_mount") { }
+
+        class spell_gen_on_tournament_mountAuraScript : public AuraScript
+        {
+            PrepareAuraScript(spell_gen_on_tournament_mountAuraScript);
+
+            uint32 _pennantSpellId;
+
+            bool Load()
+            {
+                _pennantSpellId = 0;
+                return (GetCaster()->GetTypeId() == TYPEID_PLAYER);
+            }
+
+            void HandleApplyEffect(AuraEffect const* /*aurEff*/, AuraEffectHandleModes /*mode*/)
+            {
+                Unit* caster = GetCaster();
+
+                if (caster && caster->GetVehicleBase())
+                {
+                    _pennantSpellId = GetPennatSpellId(caster->ToPlayer(), caster->GetVehicleBase());
+                    caster->CastSpell(caster, _pennantSpellId,true);
+                }
+            }
+
+            void HandleRemoveEffect(AuraEffect const* /*aurEff*/, AuraEffectHandleModes /*mode*/)
+            {
+                Unit* caster = GetCaster();
+
+                if (caster)
+                    caster->RemoveAurasDueToSpell(_pennantSpellId);
+            }
+
+            uint32 GetPennatSpellId(Player* player, Unit* mount)
+            {
+                switch (mount->GetEntry())
+                {
+                    case NPC_ARGENT_STEED_ASPIRANT:
+                    case NPC_STORMWIND_STEED:
+                    {
+                        if (player->GetAchievementMgr().HasAchieved(ACHIEVEMENT_CHAMPION_STORMWIND))
+                            return SPELL_PENNANT_STORMWIND_CHAMPION;
+                        else if (player->GetQuestRewardStatus(QUEST_VALIANT_OF_STORMWIND) || player->GetQuestRewardStatus(QUEST_A_VALIANT_OF_STORMWIND))
+                            return SPELL_PENNANT_STORMWIND_VALIANT;
+                        else
+                            return SPELL_PENNANT_STORMWIND_ASPIRANT;
+                    }
+                    case NPC_GNOMEREGAN_MECHANOSTRIDER:
+                    {
+                        if (player->GetAchievementMgr().HasAchieved(ACHIEVEMENT_CHAMPION_GNOMEREGAN))
+                            return SPELL_PENNANT_GNOMEREGAN_CHAMPION;
+                        else if (player->GetQuestRewardStatus(QUEST_VALIANT_OF_GNOMEREGAN) || player->GetQuestRewardStatus(QUEST_A_VALIANT_OF_GNOMEREGAN))
+                            return SPELL_PENNANT_GNOMEREGAN_VALIANT;
+                        else
+                            return SPELL_PENNANT_GNOMEREGAN_ASPIRANT;
+                    }
+                    case NPC_DARK_SPEAR_RAPTOR:
+                    {
+                        if (player->GetAchievementMgr().HasAchieved(ACHIEVEMENT_CHAMPION_SEN_JIN))
+                            return SPELL_PENNANT_SEN_JIN_CHAMPION;
+                        else if (player->GetQuestRewardStatus(QUEST_VALIANT_OF_SEN_JIN) || player->GetQuestRewardStatus(QUEST_A_VALIANT_OF_SEN_JIN))
+                            return SPELL_PENNANT_SEN_JIN_VALIANT;
+                        else
+                            return SPELL_PENNANT_SEN_JIN_ASPIRANT;
+                    }
+                    case NPC_ARGENT_HAWKSTRIDER_ASPIRANT:
+                    case NPC_SILVERMOON_HAWKSTRIDER:
+                    {
+                        if (player->GetAchievementMgr().HasAchieved(ACHIEVEMENT_CHAMPION_SILVERMOON))
+                            return SPELL_PENNANT_SILVERMOON_CHAMPION;
+                        else if (player->GetQuestRewardStatus(QUEST_VALIANT_OF_SILVERMOON) || player->GetQuestRewardStatus(QUEST_A_VALIANT_OF_SILVERMOON))
+                            return SPELL_PENNANT_SILVERMOON_VALIANT;
+                        else
+                            return SPELL_PENNANT_SILVERMOON_ASPIRANT;
+                    }
+                    case NPC_DARNASSIAN_NIGHTSABER:
+                    {
+                        if (player->GetAchievementMgr().HasAchieved(ACHIEVEMENT_CHAMPION_DARNASSUS))
+                            return SPELL_PENNANT_DARNASSUS_CHAMPION;
+                        else if (player->GetQuestRewardStatus(QUEST_VALIANT_OF_DARNASSUS) || player->GetQuestRewardStatus(QUEST_A_VALIANT_OF_DARNASSUS))
+                            return SPELL_PENNANT_DARNASSUS_VALIANT;
+                        else
+                            return SPELL_PENNANT_DARNASSUS_ASPIRANT;
+                    }
+                    case NPC_EXODAR_ELEKK:
+                    {
+                        if (player->GetAchievementMgr().HasAchieved(ACHIEVEMENT_CHAMPION_THE_EXODAR))
+                            return SPELL_PENNANT_EXODAR_CHAMPION;
+                        else if (player->GetQuestRewardStatus(QUEST_VALIANT_OF_THE_EXODAR) || player->GetQuestRewardStatus(QUEST_A_VALIANT_OF_THE_EXODAR))
+                            return SPELL_PENNANT_EXODAR_VALIANT;
+                        else
+                            return SPELL_PENNANT_EXODAR_ASPIRANT;
+                    }
+                    case NPC_IRONFORGE_RAM:
+                    {
+                        if (player->GetAchievementMgr().HasAchieved(ACHIEVEMENT_CHAMPION_IRONFORGE))
+                            return SPELL_PENNANT_IRONFORGE_CHAMPION;
+                        else if (player->GetQuestRewardStatus(QUEST_VALIANT_OF_IRONFORGE) || player->GetQuestRewardStatus(QUEST_A_VALIANT_OF_IRONFORGE))
+                            return SPELL_PENNANT_IRONFORGE_VALIANT;
+                        else
+                            return SPELL_PENNANT_IRONFORGE_ASPIRANT;
+                    }
+                    case NPC_FORSAKEN_WARHORSE:
+                    {
+                        if (player->GetAchievementMgr().HasAchieved(ACHIEVEMENT_CHAMPION_UNDERCITY))
+                            return SPELL_PENNANT_UNDERCITY_CHAMPION;
+                        else if (player->GetQuestRewardStatus(QUEST_VALIANT_OF_UNDERCITY) || player->GetQuestRewardStatus(QUEST_A_VALIANT_OF_UNDERCITY))
+                            return SPELL_PENNANT_UNDERCITY_VALIANT;
+                        else
+                            return SPELL_PENNANT_UNDERCITY_ASPIRANT;
+                    }
+                    case NPC_ORGRIMMAR_WOLF:
+                    {
+                        if (player->GetAchievementMgr().HasAchieved(ACHIEVEMENT_CHAMPION_ORGRIMMAR))
+                            return SPELL_PENNANT_ORGRIMMAR_CHAMPION;
+                        else if (player->GetQuestRewardStatus(QUEST_VALIANT_OF_ORGRIMMAR) || player->GetQuestRewardStatus(QUEST_A_VALIANT_OF_ORGRIMMAR))
+                            return SPELL_PENNANT_ORGRIMMAR_VALIANT;
+                        else
+                            return SPELL_PENNANT_ORGRIMMAR_ASPIRANT;
+                    }
+                    case NPC_THUNDER_BLUFF_KODO:
+                    {
+                        if (player->GetAchievementMgr().HasAchieved(ACHIEVEMENT_CHAMPION_THUNDER_BLUFF))
+                            return SPELL_PENNANT_THUNDER_BLUFF_CHAMPION;
+                        else if (player->GetQuestRewardStatus(QUEST_VALIANT_OF_THUNDER_BLUFF) || player->GetQuestRewardStatus(QUEST_A_VALIANT_OF_THUNDER_BLUFF))
+                            return SPELL_PENNANT_THUNDER_BLUFF_VALIANT;
+                        else
+                            return SPELL_PENNANT_THUNDER_BLUFF_ASPIRANT;
+                    }
+                    case NPC_ARGENT_WARHORSE:
+                    {
+                        if (player->GetAchievementMgr().HasAchieved(ACHIEVEMENT_CHAMPION_ALLIANCE) || player->GetAchievementMgr().HasAchieved(ACHIEVEMENT_CHAMPION_HORDE))
+                            return player->getClass() == CLASS_DEATH_KNIGHT ? SPELL_PENNANT_EBON_BLADE_CHAMPION : SPELL_PENNANT_ARGENT_CRUSADE_CHAMPION;
+                        else if (player->GetAchievementMgr().HasAchieved(ACHIEVEMENT_ARGENT_VALOR))
+                            return player->getClass() == CLASS_DEATH_KNIGHT ? SPELL_PENNANT_EBON_BLADE_VALIANT : SPELL_PENNANT_ARGENT_CRUSADE_VALIANT;
+                        else
+                            return player->getClass() == CLASS_DEATH_KNIGHT ? SPELL_PENNANT_EBON_BLADE_ASPIRANT : SPELL_PENNANT_ARGENT_CRUSADE_ASPIRANT;
+                    }
+                    default:
+                        return 0;
+                }
+            }
+
+            void Register()
+            {
+                AfterEffectApply += AuraEffectApplyFn(spell_gen_on_tournament_mountAuraScript::HandleApplyEffect, EFFECT_0, SPELL_AURA_DUMMY, AURA_EFFECT_HANDLE_REAL_OR_REAPPLY_MASK);
+                OnEffectRemove += AuraEffectRemoveFn(spell_gen_on_tournament_mountAuraScript::HandleRemoveEffect, EFFECT_0, SPELL_AURA_DUMMY, AURA_EFFECT_HANDLE_REAL_OR_REAPPLY_MASK);
+            }
+        };
+
+        AuraScript* GetAuraScript() const
+        {
+            return new spell_gen_on_tournament_mountAuraScript();
+        }
+};
+
+class spell_gen_tournament_pennant : public SpellScriptLoader
+{
+    public:
+        spell_gen_tournament_pennant() : SpellScriptLoader("spell_gen_tournament_pennant") { }
+
+        class spell_gen_tournament_pennantAuraScript : public AuraScript
+        {
+            PrepareAuraScript(spell_gen_tournament_pennantAuraScript);
+
+            void HandleApplyEffect(AuraEffect const* /*aurEff*/, AuraEffectHandleModes /*mode*/)
+            {
+                Unit* caster = GetCaster();
+
+                if (caster && caster->GetTypeId() == TYPEID_PLAYER && !caster->GetVehicleBase())
+                    caster->RemoveAurasDueToSpell(GetId());
+            }
+
+            void Register()
+            {
+                OnEffectApply += AuraEffectApplyFn(spell_gen_tournament_pennantAuraScript::HandleApplyEffect, EFFECT_0, SPELL_AURA_DUMMY, AURA_EFFECT_HANDLE_REAL_OR_REAPPLY_MASK);
+            }
+        };
+
+        AuraScript* GetAuraScript() const
+        {
+            return new spell_gen_tournament_pennantAuraScript();
+        }
+};
+
 void AddSC_generic_spell_scripts()
 {
     new spell_gen_absorb0_hitlimit1();
@@ -1662,4 +2404,11 @@ void AddSC_generic_spell_scripts()
     new spell_gen_dalaran_disguise("spell_gen_sunreaver_disguise");
     new spell_gen_dalaran_disguise("spell_gen_silver_covenant_disguise");
     new spell_gen_elune_candle();
+    new spell_gen_break_shield();
+    new spell_gen_mounted_charge();
+    new spell_gen_defend();
+    new spell_gen_tournament_duel();
+    new spell_gen_summon_tournament_mount();
+    new spell_gen_on_tournament_mount();
+    new spell_gen_tournament_pennant();
 }
diff --git a/src/server/scripts/World/achievement_scripts.cpp b/src/server/scripts/World/achievement_scripts.cpp
index 8ce06685893..135f22e0a01 100755
--- a/src/server/scripts/World/achievement_scripts.cpp
+++ b/src/server/scripts/World/achievement_scripts.cpp
@@ -285,6 +285,17 @@ class achievement_bg_sa_defense_of_ancients : public AchievementCriteriaScript
         }
 };
 
+class achievement_tilted : public AchievementCriteriaScript
+{
+    public:
+        achievement_tilted() : AchievementCriteriaScript("achievement_tilted") {}
+
+        bool OnCheck(Player* player, Unit* /*target*/)
+        {
+            return player && player->duel && player->duel->isMounted;
+        }
+};
+
 void AddSC_achievement_scripts()
 {
     new achievement_resilient_victory();
@@ -302,4 +313,5 @@ void AddSC_achievement_scripts()
     new achievement_arena_kills("achievement_arena_3v3_kills", ARENA_TYPE_3v3);
     new achievement_arena_kills("achievement_arena_5v5_kills", ARENA_TYPE_5v5);
     new achievement_bg_sa_defense_of_ancients();
+    new achievement_tilted();
 }