refactor(Core): apply clang-tidy modernize-use-override (#3817)

src/server/authserver/Main.cpp

@@ -50,7 +50,7 @@ LoginDatabaseWorkerPool LoginDatabase;                      // Accessor to the a
 class AuthServerSignalHandler : public acore::SignalHandler
 {
 public:
-    virtual void HandleSignal(int sigNum)
+    void HandleSignal(int sigNum) override
     {
         switch (sigNum)
         {

src/server/authserver/Server/AuthSocket.cpp

@@ -133,7 +133,7 @@ class PatcherRunnable: public acore::Runnable
 {
 public:
     PatcherRunnable(class AuthSocket*);
-    void run();
+    void run() override;
 
 private:
     AuthSocket* mySocket;

src/server/authserver/Server/AuthSocket.h

@@ -31,11 +31,11 @@ public:
     const static int s_BYTE_SIZE = 32;
 
     AuthSocket(RealmSocket& socket);
-    virtual ~AuthSocket(void);
+    ~AuthSocket(void) override;
 
-    virtual void OnRead(void);
-    virtual void OnAccept(void);
-    virtual void OnClose(void);
+    void OnRead(void) override;
+    void OnAccept(void) override;
+    void OnClose(void) override;
 
     static ACE_INET_Addr const& GetAddressForClient(Realm const& realm, ACE_INET_Addr const& clientAddr);
 

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

@@ -18,7 +18,7 @@ class AggressorAI : public CreatureAI
 public:
     explicit AggressorAI(Creature* c) : CreatureAI(c) {}
 
-    void UpdateAI(uint32);
+    void UpdateAI(uint32) override;
     static int Permissible(const Creature*);
 };
 
@@ -29,11 +29,11 @@ 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);
+    void InitializeAI() override;
+    void Reset() override;
+    void EnterCombat(Unit* who) override;
+    void JustDied(Unit* killer) override;
+    void UpdateAI(uint32 diff) override;
 
     static int Permissible(Creature const* /*creature*/) { return PERMIT_BASE_NO; }
 
@@ -46,10 +46,10 @@ 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*/);
+    void InitializeAI() override;
+    void AttackStart(Unit* victim) override { AttackStartCaster(victim, m_attackDist); }
+    void UpdateAI(uint32 diff) override;
+    void EnterCombat(Unit* /*who*/) override;
 private:
     float m_attackDist;
 };
@@ -58,8 +58,8 @@ struct ArcherAI : public CreatureAI
 {
 public:
     explicit ArcherAI(Creature* c);
-    void AttackStart(Unit* who);
-    void UpdateAI(uint32 diff);
+    void AttackStart(Unit* who) override;
+    void UpdateAI(uint32 diff) override;
 
 
     static int Permissible(Creature const* /*creature*/) { return PERMIT_BASE_NO; }
@@ -72,9 +72,9 @@ struct TurretAI : public CreatureAI
 {
 public:
     explicit TurretAI(Creature* c);
-    bool CanAIAttack(const Unit* who) const;
-    void AttackStart(Unit* who);
-    void UpdateAI(uint32 diff);
+    bool CanAIAttack(const Unit* who) const override;
+    void AttackStart(Unit* who) override;
+    void UpdateAI(uint32 diff) override;
 
     static int Permissible(Creature const* /*creature*/) { return PERMIT_BASE_NO; }
 
@@ -89,10 +89,10 @@ struct VehicleAI : public CreatureAI
 public:
     explicit VehicleAI(Creature* creature);
 
-    void UpdateAI(uint32 diff);
-    void MoveInLineOfSight(Unit*) {}
-    void AttackStart(Unit*) {}
-    void OnCharmed(bool apply);
+    void UpdateAI(uint32 diff) override;
+    void MoveInLineOfSight(Unit*) override {}
+    void AttackStart(Unit*) override {}
+    void OnCharmed(bool apply) override;
 
     static int Permissible(Creature const* /*creature*/) { return PERMIT_BASE_NO; }
 

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

@@ -57,7 +57,7 @@ class NullGameObjectAI : public GameObjectAI
 public:
     explicit NullGameObjectAI(GameObject* g);
 
-    void UpdateAI(uint32 /*diff*/) {}
+    void UpdateAI(uint32 /*diff*/) override {}
 
     static int Permissible(GameObject const* /*go*/) { return PERMIT_BASE_IDLE; }
 };

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

@@ -18,8 +18,8 @@ public:
 
     static int Permissible(Creature const* creature);
 
-    void Reset();
-    void EnterEvadeMode();
-    void JustDied(Unit* killer);
+    void Reset() override;
+    void EnterEvadeMode() override;
+    void JustDied(Unit* killer) override;
 };
 #endif

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

@@ -15,9 +15,9 @@ class PassiveAI : public CreatureAI
 public:
     explicit PassiveAI(Creature* c);
 
-    void MoveInLineOfSight(Unit*) {}
-    void AttackStart(Unit*) {}
-    void UpdateAI(uint32);
+    void MoveInLineOfSight(Unit*) override {}
+    void AttackStart(Unit*) override {}
+    void UpdateAI(uint32) override;
 
     static int Permissible(const Creature*) { return PERMIT_BASE_IDLE;  }
 };
@@ -27,13 +27,13 @@ class PossessedAI : public CreatureAI
 public:
     explicit PossessedAI(Creature* c);
 
-    void MoveInLineOfSight(Unit*) {}
-    void AttackStart(Unit* target);
-    void UpdateAI(uint32);
-    void EnterEvadeMode() {}
+    void MoveInLineOfSight(Unit*) override {}
+    void AttackStart(Unit* target) override;
+    void UpdateAI(uint32) override;
+    void EnterEvadeMode() override {}
 
-    void JustDied(Unit*);
-    void KilledUnit(Unit* victim);
+    void JustDied(Unit*) override;
+    void KilledUnit(Unit* victim) override;
 
     static int Permissible(const Creature*) { return PERMIT_BASE_IDLE;  }
 };
@@ -43,11 +43,11 @@ class NullCreatureAI : public CreatureAI
 public:
     explicit NullCreatureAI(Creature* c);
 
-    void MoveInLineOfSight(Unit*) {}
-    void AttackStart(Unit*) {}
-    void UpdateAI(uint32) {}
-    void EnterEvadeMode() {}
-    void OnCharmed(bool /*apply*/) {}
+    void MoveInLineOfSight(Unit*) override {}
+    void AttackStart(Unit*) override {}
+    void UpdateAI(uint32) override {}
+    void EnterEvadeMode() override {}
+    void OnCharmed(bool /*apply*/) override {}
 
     static int Permissible(const Creature*) { return PERMIT_BASE_IDLE;  }
 };
@@ -57,9 +57,9 @@ 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);
+    void DamageTaken(Unit* /*done_by*/, uint32& /*damage*/, DamageEffectType damagetype, SpellSchoolMask damageSchoolMask) override;
+    void EnterEvadeMode() override;
+    void UpdateAI(uint32) override;
 
     // Xinef: Added
 private:
@@ -70,7 +70,7 @@ class TriggerAI : public NullCreatureAI
 {
 public:
     explicit TriggerAI(Creature* c) : NullCreatureAI(c) {}
-    void IsSummonedBy(Unit* summoner);
+    void IsSummonedBy(Unit* summoner) override;
 };
 
 #endif

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

@@ -38,24 +38,24 @@ public:
 
     explicit PetAI(Creature* c);
 
-    void UpdateAI(uint32);
+    void UpdateAI(uint32) override;
     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);
+    void KilledUnit(Unit* /*victim*/) override;
+    void AttackStart(Unit* target) override;
+    void MovementInform(uint32 moveType, uint32 data) override;
+    void OwnerAttackedBy(Unit* attacker) override;
+    void OwnerAttacked(Unit* target) override;
+    void AttackedBy(Unit* attacker) override;
+    void ReceiveEmote(Player* player, uint32 textEmote) override;
 
     // 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(Unit* /*who*/) override {} // 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);
+    void EnterEvadeMode() override {} // For fleeing, pets don't use this type of Evade mechanic
+    void SpellHit(Unit* caster, const SpellInfo* spellInfo) override;
 
 private:
     bool _isVisible(Unit*) const;

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

@@ -17,8 +17,8 @@ public:
 
     explicit ReactorAI(Creature* c) : CreatureAI(c) {}
 
-    void MoveInLineOfSight(Unit*) {}
-    void UpdateAI(uint32 diff);
+    void MoveInLineOfSight(Unit*) override {}
+    void UpdateAI(uint32 diff) override;
 
     static int Permissible(const Creature*);
 };

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

@@ -19,13 +19,13 @@ 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 MoveInLineOfSight(Unit* who) override;
+    void AttackStart(Unit* victim) override;
+    void EnterEvadeMode() override;
+    void SpellHit(Unit* /*caster*/, const SpellInfo* /*spellInfo*/) override;
+    void DoAction(int32 param) override;
 
-    void UpdateAI(uint32 diff);
+    void UpdateAI(uint32 diff) override;
     static int Permissible(Creature const* creature);
 
 private:
@@ -36,7 +36,7 @@ class KillMagnetEvent : public BasicEvent
 {
 public:
     KillMagnetEvent(Unit& self) : _self(self) { }
-    bool Execute(uint64 /*e_time*/, uint32 /*p_time*/)
+    bool Execute(uint64 /*e_time*/, uint32 /*p_time*/) override
     {
         _self.setDeathState(JUST_DIED);
         return true;

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

@@ -316,13 +316,13 @@ protected:
 public:
     explicit PlayerAI(Player* player) : UnitAI((Unit*)player), me(player) {}
 
-    void OnCharmed(bool apply);
+    void OnCharmed(bool apply) override;
 };
 
 class SimpleCharmedAI : public PlayerAI
 {
 public:
-    void UpdateAI(uint32 diff);
+    void UpdateAI(uint32 diff) override;
     SimpleCharmedAI(Player* player): PlayerAI(player) {}
 };
 

src/server/game/AI/CreatureAI.h

@@ -69,7 +69,7 @@ public:
     void Talk(uint8 id, WorldObject const* whisperTarget = nullptr);
     explicit CreatureAI(Creature* creature) : UnitAI(creature), me(creature), m_MoveInLineOfSight_locked(false) {}
 
-    virtual ~CreatureAI() {}
+    ~CreatureAI() override {}
 
     /// == Reactions At =================================
 
@@ -117,7 +117,7 @@ public:
     // Called at waypoint reached or point movement finished
     virtual void MovementInform(uint32 /*type*/, uint32 /*id*/) {}
 
-    void OnCharmed(bool apply);
+    void OnCharmed(bool apply) override;
 
     // Called at reaching home after evade
     virtual void JustReachedHome() {}

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

@@ -159,7 +159,7 @@ public:
 struct ScriptedAI : public CreatureAI
 {
     explicit ScriptedAI(Creature* creature);
-    virtual ~ScriptedAI() {}
+    ~ScriptedAI() override {}
 
     // *************
     //CreatureAI Functions
@@ -168,31 +168,31 @@ struct ScriptedAI : public CreatureAI
     void AttackStartNoMove(Unit* target);
 
     // Called at any Damage from any attacker (before damage apply)
-    void DamageTaken(Unit* /*attacker*/, uint32& /*damage*/, DamageEffectType /*damagetype*/, SpellSchoolMask /*damageSchoolMask*/) {}
+    void DamageTaken(Unit* /*attacker*/, uint32& /*damage*/, DamageEffectType /*damagetype*/, SpellSchoolMask /*damageSchoolMask*/) override {}
 
     //Called at World update tick
-    virtual void UpdateAI(uint32 diff);
+    void UpdateAI(uint32 diff) override;
 
     //Called at creature death
-    void JustDied(Unit* /*killer*/) {}
+    void JustDied(Unit* /*killer*/) override {}
 
     //Called at creature killing another unit
-    void KilledUnit(Unit* /*victim*/) {}
+    void KilledUnit(Unit* /*victim*/) override {}
 
     // Called when the creature summon successfully other creature
-    void JustSummoned(Creature* /*summon*/) {}
+    void JustSummoned(Creature* /*summon*/) override {}
 
     // Called when a summoned creature is despawned
-    void SummonedCreatureDespawn(Creature* /*summon*/) {}
+    void SummonedCreatureDespawn(Creature* /*summon*/) override {}
 
     // Called when hit by a spell
-    void SpellHit(Unit* /*caster*/, SpellInfo const* /*spell*/) {}
+    void SpellHit(Unit* /*caster*/, SpellInfo const* /*spell*/) override {}
 
     // Called when spell hits a target
-    void SpellHitTarget(Unit* /*target*/, SpellInfo const* /*spell*/) {}
+    void SpellHitTarget(Unit* /*target*/, SpellInfo const* /*spell*/) override {}
 
     //Called at waypoint reached or PointMovement end
-    void MovementInform(uint32 /*type*/, uint32 /*id*/) {}
+    void MovementInform(uint32 /*type*/, uint32 /*id*/) override {}
 
     // Called when AI is temporarily replaced or put back when possess is applied or removed
     void OnPossess(bool /*apply*/) {}
@@ -212,13 +212,13 @@ struct ScriptedAI : public CreatureAI
     // *************
 
     //Called at creature reset either by death or evade
-    void Reset() {}
+    void Reset() override {}
 
     //Called at creature aggro either by MoveInLOS or Attack Start
-    void EnterCombat(Unit* /*victim*/) {}
+    void EnterCombat(Unit* /*victim*/) override {}
 
     // Called before EnterCombat even before the creature is in combat.
-    void AttackStart(Unit* /*target*/);
+    void AttackStart(Unit* /*target*/) override;
 
     // *************
     //AI Helper Functions
@@ -364,15 +364,15 @@ class BossAI : public ScriptedAI
 {
 public:
     BossAI(Creature* creature, uint32 bossId);
-    virtual ~BossAI() {}
+    ~BossAI() override {}
 
     InstanceScript* const instance;
     BossBoundaryMap const* GetBoundary() const { return _boundary; }
 
-    void JustSummoned(Creature* summon);
-    void SummonedCreatureDespawn(Creature* summon);
+    void JustSummoned(Creature* summon) override;
+    void SummonedCreatureDespawn(Creature* summon) override;
 
-    virtual void UpdateAI(uint32 diff);
+    void UpdateAI(uint32 diff) override;
 
     // Hook used to execute events scheduled into EventMap without the need
     // to override UpdateAI
@@ -380,10 +380,10 @@ public:
     // 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(); }
+    void Reset() override { _Reset(); }
+    void EnterCombat(Unit* /*who*/) override { _EnterCombat(); }
+    void JustDied(Unit* /*killer*/) override { _JustDied(); }
+    void JustReachedHome() override { _JustReachedHome(); }
 
 protected:
     void _Reset();
@@ -415,12 +415,12 @@ class WorldBossAI : public ScriptedAI
 {
 public:
     WorldBossAI(Creature* creature);
-    virtual ~WorldBossAI() {}
+    ~WorldBossAI() override {}
 
-    void JustSummoned(Creature* summon);
-    void SummonedCreatureDespawn(Creature* summon);
+    void JustSummoned(Creature* summon) override;
+    void SummonedCreatureDespawn(Creature* summon) override;
 
-    virtual void UpdateAI(uint32 diff);
+    void UpdateAI(uint32 diff) override;
 
     // Hook used to execute events scheduled into EventMap without the need
     // to override UpdateAI
@@ -428,9 +428,9 @@ public:
     // 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 Reset() override { _Reset(); }
+    void EnterCombat(Unit* /*who*/) override { _EnterCombat(); }
+    void JustDied(Unit* /*killer*/) override { _JustDied(); }
 
 protected:
     void _Reset();

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

@@ -40,25 +40,25 @@ struct npc_escortAI : public ScriptedAI
 {
 public:
     explicit npc_escortAI(Creature* creature);
-    ~npc_escortAI() {}
+    ~npc_escortAI() override {}
 
     // CreatureAI functions
-    void AttackStart(Unit* who);
+    void AttackStart(Unit* who) override;
 
-    void MoveInLineOfSight(Unit* who);
+    void MoveInLineOfSight(Unit* who) override;
 
-    void JustDied(Unit*);
+    void JustDied(Unit*) override;
 
-    void JustRespawned();
+    void JustRespawned() override;
 
     void ReturnToLastPoint();
 
-    void EnterEvadeMode();
+    void EnterEvadeMode() override;
 
-    void UpdateAI(uint32 diff);                   //the "internal" update, calls UpdateEscortAI()
+    void UpdateAI(uint32 diff) override;                   //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);
+    void MovementInform(uint32, uint32) override;
 
     // EscortAI functions
     void AddWaypoint(uint32 id, float x, float y, float z, uint32 waitTime = 0);    // waitTime is in ms
@@ -83,7 +83,7 @@ public:
     void SetEscortPaused(bool on);
 
     bool HasEscortState(uint32 escortState) { return (m_uiEscortState & escortState); }
-    virtual bool IsEscorted() { return (m_uiEscortState & STATE_ESCORT_ESCORTING); }
+    bool IsEscorted() override { return (m_uiEscortState & STATE_ESCORT_ESCORTING); }
 
     void SetMaxPlayerDistance(float newMax) { MaxPlayerDistance = newMax; }
     float GetMaxPlayerDistance() { return MaxPlayerDistance; }

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

@@ -23,23 +23,23 @@ class FollowerAI : public ScriptedAI
 {
 public:
     explicit FollowerAI(Creature* creature);
-    ~FollowerAI() {}
+    ~FollowerAI() override {}
 
     //virtual void WaypointReached(uint32 uiPointId) = 0;
 
-    void MovementInform(uint32 motionType, uint32 pointId);
+    void MovementInform(uint32 motionType, uint32 pointId) override;
 
-    void AttackStart(Unit*);
+    void AttackStart(Unit*) override;
 
-    void MoveInLineOfSight(Unit*);
+    void MoveInLineOfSight(Unit*) override;
 
-    void EnterEvadeMode();
+    void EnterEvadeMode() override;
 
-    void JustDied(Unit*);
+    void JustDied(Unit*) override;
 
-    void JustRespawned();
+    void JustRespawned() override;
 
-    void UpdateAI(uint32);                        //the "internal" update, calls UpdateFollowerAI()
+    void UpdateAI(uint32) override;                        //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 = nullptr);

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

@@ -1176,7 +1176,7 @@ public:
 
     SmartTrigger() : AreaTriggerScript("SmartTrigger") {}
 
-    bool OnTrigger(Player* player, AreaTrigger const* trigger)
+    bool OnTrigger(Player* player, AreaTrigger const* trigger) override
     {
         if (!player->IsAlive())
             return false;

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

@@ -34,7 +34,7 @@ enum SmartEscortVars
 class SmartAI : public CreatureAI
 {
 public:
-    ~SmartAI() {};
+    ~SmartAI() override {};
     explicit SmartAI(Creature* c);
 
     // Start moving to the desired MovePoint
@@ -48,7 +48,7 @@ public:
     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); }
+    bool IsEscorted() override { return (mEscortState & SMART_ESCORT_ESCORTING); }
     void RemoveEscortState(uint32 uiEscortState) { mEscortState &= ~uiEscortState; }
     void SetAutoAttack(bool on) { mCanAutoAttack = on; }
     void SetCombatMove(bool on);
@@ -61,94 +61,94 @@ public:
     bool IsEscortInvokerInRange();
 
     // Called when creature is spawned or respawned
-    void JustRespawned();
+    void JustRespawned() override;
 
     // Called at reaching home after evade, InitializeAI(), EnterEvadeMode() for resetting variables
-    void JustReachedHome();
+    void JustReachedHome() override;
 
     // Called for reaction at enter to combat if not in combat yet (enemy can be nullptr)
-    void EnterCombat(Unit* enemy);
+    void EnterCombat(Unit* enemy) override;
 
     // Called for reaction at stopping attack at no attackers or targets
-    void EnterEvadeMode();
+    void EnterEvadeMode() override;
 
     // Called when the creature is killed
-    void JustDied(Unit* killer);
+    void JustDied(Unit* killer) override;
 
     // Called when the creature kills a unit
-    void KilledUnit(Unit* victim);
+    void KilledUnit(Unit* victim) override;
 
     // Called when the creature summon successfully other creature
-    void JustSummoned(Creature* creature);
+    void JustSummoned(Creature* creature) override;
 
     // Tell creature to attack and follow the victim
-    void AttackStart(Unit* who);
+    void AttackStart(Unit* who) override;
 
     // Called if IsVisible(Unit* who) is true at each *who move, reaction at visibility zone enter
-    void MoveInLineOfSight(Unit* who);
+    void MoveInLineOfSight(Unit* who) override;
 
     // Called when hit by a spell
-    void SpellHit(Unit* unit, const SpellInfo* spellInfo);
+    void SpellHit(Unit* unit, const SpellInfo* spellInfo) override;
 
     // Called when spell hits a target
-    void SpellHitTarget(Unit* target, const SpellInfo* spellInfo);
+    void SpellHitTarget(Unit* target, const SpellInfo* spellInfo) override;
 
     // Called at any Damage from any attacker (before damage apply)
-    void DamageTaken(Unit* done_by, uint32& damage, DamageEffectType damagetype, SpellSchoolMask damageSchoolMask);
+    void DamageTaken(Unit* done_by, uint32& damage, DamageEffectType damagetype, SpellSchoolMask damageSchoolMask) override;
 
     // Called when the creature receives heal
-    void HealReceived(Unit* doneBy, uint32& addhealth);
+    void HealReceived(Unit* doneBy, uint32& addhealth) override;
 
     // Called at World update tick
-    void UpdateAI(uint32 diff);
+    void UpdateAI(uint32 diff) override;
 
     // Called at text emote receive from player
-    void ReceiveEmote(Player* player, uint32 textEmote);
+    void ReceiveEmote(Player* player, uint32 textEmote) override;
 
     // Called at waypoint reached or point movement finished
-    void MovementInform(uint32 MovementType, uint32 Data);
+    void MovementInform(uint32 MovementType, uint32 Data) override;
 
     // Called when creature is summoned by another unit
-    void IsSummonedBy(Unit* summoner);
+    void IsSummonedBy(Unit* summoner) override;
 
     // Called at any Damage to any victim (before damage apply)
-    void DamageDealt(Unit* doneTo, uint32& damage, DamageEffectType damagetyp);
+    void DamageDealt(Unit* doneTo, uint32& damage, DamageEffectType damagetyp) override;
 
     // Called when a summoned creature dissapears (UnSommoned)
-    void SummonedCreatureDespawn(Creature* unit);
+    void SummonedCreatureDespawn(Creature* unit) override;
 
     // called when the corpse of this creature gets removed
-    void CorpseRemoved(uint32& respawnDelay);
+    void CorpseRemoved(uint32& respawnDelay) override;
 
     // 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);
+    void PassengerBoarded(Unit* who, int8 seatId, bool apply) override;
 
     // Called when gets initialized, when creature is added to world
-    void InitializeAI();
+    void InitializeAI() override;
 
     // Called when creature gets charmed by another unit
-    void OnCharmed(bool apply);
+    void OnCharmed(bool apply) override;
 
     // Called when victim is in line of sight
-    bool CanAIAttack(const Unit* who) const;
+    bool CanAIAttack(const Unit* who) const override;
 
     // Used in scripts to share variables
-    void DoAction(int32 param = 0);
+    void DoAction(int32 param = 0) override;
 
     // Used in scripts to share variables
-    uint32 GetData(uint32 id = 0) const;
+    uint32 GetData(uint32 id = 0) const override;
 
     // Used in scripts to share variables
-    void SetData(uint32 id, uint32 value);
+    void SetData(uint32 id, uint32 value) override;
 
     // Used in scripts to share variables
-    void SetGUID(uint64 guid, int32 id = 0);
+    void SetGUID(uint64 guid, int32 id = 0) override;
 
     // Used in scripts to share variables
-    uint64 GetGUID(int32 id = 0) const;
+    uint64 GetGUID(int32 id = 0) const override;
 
     //core related
     static int32 Permissible(const Creature*);
@@ -165,14 +165,14 @@ public:
 
     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 sGossipHello(Player* player) override;
+    void sGossipSelect(Player* player, uint32 sender, uint32 action) override;
+    void sGossipSelectCode(Player* player, uint32 sender, uint32 action, const char* code) override;
+    void sQuestAccept(Player* player, Quest const* quest) override;
     //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);
+    void sQuestReward(Player* player, Quest const* quest, uint32 opt) override;
+    void sOnGameEvent(bool start, uint16 eventId) override;
 
     uint32 mEscortQuestID;
 
@@ -183,7 +183,7 @@ public:
     }
     void StartDespawn() { mDespawnState = 2; }
 
-    void OnSpellClick(Unit* clicker, bool& result);
+    void OnSpellClick(Unit* clicker, bool& result) override;
 
     // Xinef
     void SetWPPauseTimer(uint32 time) { mWPPauseTimer = time; }
@@ -236,26 +236,26 @@ class SmartGameObjectAI : public GameObjectAI
 {
 public:
     SmartGameObjectAI(GameObject* g) : GameObjectAI(g) {}
-    ~SmartGameObjectAI() {}
+    ~SmartGameObjectAI() override {}
 
-    void UpdateAI(uint32 diff);
-    void InitializeAI();
-    void Reset();
+    void UpdateAI(uint32 diff) override;
+    void InitializeAI() override;
+    void Reset() override;
     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);
+    bool GossipHello(Player* player, bool reportUse) override;
+    bool GossipSelect(Player* player, uint32 sender, uint32 action) override;
+    bool GossipSelectCode(Player* /*player*/, uint32 /*sender*/, uint32 /*action*/, const char* /*code*/) override;
+    bool QuestAccept(Player* player, Quest const* quest) override;
+    bool QuestReward(Player* player, Quest const* quest, uint32 opt) override;
+    void Destroyed(Player* player, uint32 eventId) override;
+    void SetData(uint32 id, uint32 value) override;
     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);
+    void OnGameEvent(bool start, uint16 eventId) override;
+    void OnStateChanged(uint32 state, Unit* unit) override;
+    void EventInform(uint32 eventId) override;
+    void SpellHit(Unit* unit, const SpellInfo* spellInfo) override;
 
 protected:
     SmartScript mScript;

src/server/game/Battlefield/Battlefield.h

@@ -203,7 +203,7 @@ public:
     /// Constructor
     Battlefield();
     /// Destructor
-    virtual ~Battlefield();
+    ~Battlefield() override;
 
     /// typedef of map witch store capturepoint and the associate gameobject entry
     typedef std::map<uint32 /*lowguid */, BfCapturePoint*> BfCapturePointMap;
@@ -258,12 +258,12 @@ public:
     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; }
+    uint64 GetData64(uint32 dataId) const override { return m_Data64[dataId]; }
+    void SetData64(uint32 dataId, uint64 value) override { 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; }
+    uint32 GetData(uint32 dataId) const override { return m_Data32[dataId]; }
+    void SetData(uint32 dataId, uint32 value) override { m_Data32[dataId] = value; }
     virtual void UpdateData(uint32 index, int32 pad) { m_Data32[index] += pad; }
 
     // Battlefield - generic methods

src/server/game/Battlefield/Zones/BattlefieldWG.h

@@ -250,7 +250,7 @@ public:
 
     void LinkToWorkshop(WGWorkshop* workshop) { m_Workshop = workshop; }
 
-    void ChangeTeam(TeamId oldteam);
+    void ChangeTeam(TeamId oldteam) override;
     TeamId GetTeam() const { return m_team; }
 
 protected:
@@ -264,14 +264,14 @@ protected:
 class BattlefieldWG : public Battlefield
 {
 public:
-    ~BattlefieldWG();
+    ~BattlefieldWG() override;
     /**
      * \brief Called when the battle start
      * - Spawn relic and turret
      * - Rebuild tower and wall
      * - Invite player to war
      */
-    void OnBattleStart();
+    void OnBattleStart() override;
 
     /**
      * \brief Called when battle end
@@ -282,13 +282,13 @@ public:
      * - Remove vehicle
      * \param endByTimer : true if battle ended when timer is at 00:00, false if battle ended by clicking on relic
      */
-    void OnBattleEnd(bool endByTimer);
+    void OnBattleEnd(bool endByTimer) override;
 
     /**
      * \brief Called when grouping starts (15 minutes before battlestart)
      * - Invite all player in zone to join queue
      */
-    void OnStartGrouping();
+    void OnStartGrouping() override;
 
     /**
      * \brief Called when player accept invite to join battle
@@ -298,20 +298,20 @@ public:
      * - Update tenacity
      * \param player: Player who accepted invite
      */
-    void OnPlayerJoinWar(Player* player);
+    void OnPlayerJoinWar(Player* player) override;
 
     /**
      * \brief Called when player left the battle
      * - Update player aura
      * \param player : Player who left the battle
      */
-    void OnPlayerLeaveWar(Player* player);
+    void OnPlayerLeaveWar(Player* player) override;
 
     /**
      * \brief Called when player left the WG zone
      * \param player : Player who left the zone
      */
-    void OnPlayerLeaveZone(Player* player);
+    void OnPlayerLeaveZone(Player* player) override;
 
     /**
      * \brief Called when player enters in WG zone
@@ -319,7 +319,7 @@ public:
      * - Update worldstate
      * \param player : Player who enters the zone
      */
-    void OnPlayerEnterZone(Player* player);
+    void OnPlayerEnterZone(Player* player) override;
 
     /**
      * \brief Called for update battlefield data
@@ -327,24 +327,24 @@ public:
      * - Update imunity aura from graveyard
      * \param diff : time elapsed since the last call (in ms)
      */
-    bool Update(uint32 diff);
+    bool Update(uint32 diff) override;
 
     /**
      * \brief Called when a creature is created
      * - Update vehicle count
      */
-    void OnCreatureCreate(Creature* creature);
+    void OnCreatureCreate(Creature* creature) override;
 
     /**
      * \brief Called when a creature is removed
      * - Update vehicle count
      */
-    void OnCreatureRemove(Creature* creature);
+    void OnCreatureRemove(Creature* creature) override;
 
     /**
      * \brief Called when a gameobject is created
      */
-    void OnGameObjectCreate(GameObject* go);
+    void OnGameObjectCreate(GameObject* go) override;
 
     /**
      * \brief Called when a wall/tower is broken
@@ -372,7 +372,7 @@ public:
     /**
      * \brief Called when battlefield is setup, at server start
      */
-    bool SetupBattlefield();
+    bool SetupBattlefield() override;
 
     /// Return pointer to relic object
     GameObject* GetRelic() { return ObjectAccessor::GetObjectInWorld(m_titansRelic, (GameObject*)NULL); }
@@ -392,18 +392,18 @@ public:
     void CapturePointTaken(uint32 areaId);
 
     void SendInitWorldStatesTo(Player* player);
-    void SendInitWorldStatesToAll();
-    void FillInitialWorldStates(WorldPacket& data);
+    void SendInitWorldStatesToAll() override;
+    void FillInitialWorldStates(WorldPacket& data) override;
 
-    void HandleKill(Player* killer, Unit* victim);
-    void OnUnitDeath(Unit* unit);
+    void HandleKill(Player* killer, Unit* victim) override;
+    void OnUnitDeath(Unit* unit) override;
     void PromotePlayer(Player* killer);
 
     uint32 GetHonorBuff(int32 stack) const;
     void UpdateTenacity();
     void AddUpdateTenacity(Player* player);
     void RemoveUpdateTenacity(Player* player);
-    void ProcessEvent(WorldObject* obj, uint32 eventId);
+    void ProcessEvent(WorldObject* obj, uint32 eventId) override;
 
     bool FindAndRemoveVehicleFromList(Unit* vehicle);
 
@@ -411,7 +411,7 @@ public:
     uint8 GetSpiritGraveyardId(uint32 areaId) const;
     uint32 GetAreaByGraveyardId(uint8 gId) const;
 
-    uint32 GetData(uint32 data) const;
+    uint32 GetData(uint32 data) const override;
 
     bool IsKeepNpc(uint32 entry)
     {

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

@@ -36,22 +36,22 @@ class BattlegroundBE : public Battleground
 {
 public:
     BattlegroundBE();
-    ~BattlegroundBE();
+    ~BattlegroundBE() override;
 
     /* inherited from BattlegroundClass */
-    void AddPlayer(Player* player);
-    void StartingEventCloseDoors();
-    void StartingEventOpenDoors();
+    void AddPlayer(Player* player) override;
+    void StartingEventCloseDoors() override;
+    void StartingEventOpenDoors() override;
 
-    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);
+    void RemovePlayer(Player* player) override;
+    void HandleAreaTrigger(Player* player, uint32 trigger) override;
+    bool SetupBattleground() override;
+    void Init() override;
+    void FillInitialWorldStates(WorldPacket& d) override;
+    void HandleKillPlayer(Player* player, Player* killer) override;
+    bool HandlePlayerUnderMap(Player* player) override;
 
     /* Scorekeeping */
-    void UpdatePlayerScore(Player* player, uint32 type, uint32 value, bool doAddHonor = true);
+    void UpdatePlayerScore(Player* player, uint32 type, uint32 value, bool doAddHonor = true) override;
 };
 #endif

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

@@ -74,20 +74,20 @@ class BattlegroundDS : public Battleground
 {
 public:
     BattlegroundDS();
-    ~BattlegroundDS();
+    ~BattlegroundDS() override;
 
     /* inherited from BattlegroundClass */
-    void AddPlayer(Player* player);
-    void StartingEventCloseDoors();
-    void StartingEventOpenDoors();
+    void AddPlayer(Player* player) override;
+    void StartingEventCloseDoors() override;
+    void StartingEventOpenDoors() override;
 
-    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);
+    void RemovePlayer(Player* player) override;
+    void HandleAreaTrigger(Player* player, uint32 trigger) override;
+    bool SetupBattleground() override;
+    void Init() override;
+    void FillInitialWorldStates(WorldPacket& d) override;
+    void HandleKillPlayer(Player* player, Player* killer) override;
+    bool HandlePlayerUnderMap(Player* player) override;
 private:
     uint32 _waterfallTimer;
     uint8 _waterfallStatus;
@@ -95,7 +95,7 @@ private:
     uint32 _pipeKnockBackTimer;
     uint8 _pipeKnockBackCount;
 
-    void PostUpdateImpl(uint32 diff);
+    void PostUpdateImpl(uint32 diff) override;
 protected:
     uint32 getWaterFallStatus() { return _waterfallStatus; };
     void setWaterFallStatus(uint8 status) { _waterfallStatus = status; };

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

@@ -308,53 +308,53 @@ const BattlegroundEYCapturingPointStruct m_CapturingPointTypes[EY_POINTS_MAX] =
 struct BattlegroundEYScore : public BattlegroundScore
 {
     BattlegroundEYScore(Player* player) : BattlegroundScore(player), FlagCaptures(0) { }
-    ~BattlegroundEYScore() { }
+    ~BattlegroundEYScore() override { }
     uint32 FlagCaptures;
 
-    uint32 GetAttr1() const final override { return FlagCaptures; }
+    uint32 GetAttr1() const final { return FlagCaptures; }
 };
 
 class BattlegroundEY : public Battleground
 {
 public:
     BattlegroundEY();
-    ~BattlegroundEY();
+    ~BattlegroundEY() override;
 
     /* inherited from BattlegroundClass */
-    void AddPlayer(Player* player);
-    void StartingEventCloseDoors();
-    void StartingEventOpenDoors();
+    void AddPlayer(Player* player) override;
+    void StartingEventCloseDoors() override;
+    void StartingEventOpenDoors() override;
 
     /* BG Flags */
-    uint64 GetFlagPickerGUID(TeamId /*teamId*/ = TEAM_NEUTRAL) const    { return _flagKeeperGUID; }
+    uint64 GetFlagPickerGUID(TeamId /*teamId*/ = TEAM_NEUTRAL) const override    { return _flagKeeperGUID; }
     void SetFlagPicker(uint64 guid)     { _flagKeeperGUID = guid; }
     uint8 GetFlagState() const          { return _flagState; }
     void RespawnFlag();
     void RespawnFlagAfterDrop();
 
-    void RemovePlayer(Player* player);
+    void RemovePlayer(Player* player) override;
     void HandleBuffUse(uint64 buff_guid);
-    void HandleAreaTrigger(Player* player, uint32 trigger);
-    void HandleKillPlayer(Player* player, Player* killer);
-    GraveyardStruct 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; }
+    void HandleAreaTrigger(Player* player, uint32 trigger) override;
+    void HandleKillPlayer(Player* player, Player* killer) override;
+    GraveyardStruct const* GetClosestGraveyard(Player* player) override;
+    bool SetupBattleground() override;
+    void Init() override;
+    void EndBattleground(TeamId winnerTeamId) override;
+    void UpdatePlayerScore(Player* player, uint32 type, uint32 value, bool doAddHonor = true) override;
+    void FillInitialWorldStates(WorldPacket& data) override;
+    void SetDroppedFlagGUID(uint64 guid, TeamId /*teamId*/ = TEAM_NEUTRAL) override  { _droppedFlagGUID = guid; }
     uint64 GetDroppedFlagGUID() const { return _droppedFlagGUID; }
 
     /* Battleground Events */
-    void EventPlayerClickedOnFlag(Player* player, GameObject* gameObject);
-    void EventPlayerDroppedFlag(Player* player);
+    void EventPlayerClickedOnFlag(Player* player, GameObject* gameObject) override;
+    void EventPlayerDroppedFlag(Player* player) override;
 
     /* achievement req. */
-    bool AllNodesConrolledByTeam(TeamId teamId) const;
-    TeamId GetPrematureWinner();
+    bool AllNodesConrolledByTeam(TeamId teamId) const override;
+    TeamId GetPrematureWinner() override;
 
 private:
-    void PostUpdateImpl(uint32 diff);
+    void PostUpdateImpl(uint32 diff) override;
 
     void EventPlayerCapturedFlag(Player* Source, uint32 BgObjectType);
     void EventTeamLostPoint(TeamId teamId, uint32 point);

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

@@ -879,52 +879,52 @@ enum HonorRewards
 struct BattlegroundICScore : public BattlegroundScore
 {
     BattlegroundICScore(Player* player) : BattlegroundScore(player), BasesAssaulted(0), BasesDefended(0) { }
-    ~BattlegroundICScore() { }
+    ~BattlegroundICScore() override { }
     uint32 BasesAssaulted;
     uint32 BasesDefended;
 
-    uint32 GetAttr1() const final override { return BasesAssaulted; }
-    uint32 GetAttr2() const final override { return BasesDefended; }
+    uint32 GetAttr1() const final { return BasesAssaulted; }
+    uint32 GetAttr2() const final { return BasesDefended; }
 };
 
 class BattlegroundIC : public Battleground
 {
 public:
     BattlegroundIC();
-    ~BattlegroundIC();
+    ~BattlegroundIC() override;
 
     /* inherited from BattlegroundClass */
-    void AddPlayer(Player* player);
-    void StartingEventCloseDoors();
-    void StartingEventOpenDoors();
-    void PostUpdateImpl(uint32 diff);
+    void AddPlayer(Player* player) override;
+    void StartingEventCloseDoors() override;
+    void StartingEventOpenDoors() override;
+    void PostUpdateImpl(uint32 diff) override;
 
-    void RemovePlayer(Player* player);
-    void HandleAreaTrigger(Player* player, uint32 trigger);
-    bool SetupBattleground();
+    void RemovePlayer(Player* player) override;
+    void HandleAreaTrigger(Player* player, uint32 trigger) override;
+    bool SetupBattleground() override;
     void SpawnLeader(uint32 teamid);
-    void HandleKillUnit(Creature* unit, Player* killer);
-    void HandleKillPlayer(Player* player, Player* killer);
-    void EndBattleground(TeamId winnerTeamId);
-    void EventPlayerClickedOnFlag(Player* source, GameObject* /*gameObject*/);
+    void HandleKillUnit(Creature* unit, Player* killer) override;
+    void HandleKillPlayer(Player* player, Player* killer) override;
+    void EndBattleground(TeamId winnerTeamId) override;
+    void EventPlayerClickedOnFlag(Player* source, GameObject* /*gameObject*/) override;
 
-    void EventPlayerDamagedGO(Player* /*player*/, GameObject* go, uint32 eventType);
-    void DestroyGate(Player* player, GameObject* go);
+    void EventPlayerDamagedGO(Player* /*player*/, GameObject* go, uint32 eventType) override;
+    void DestroyGate(Player* player, GameObject* go) override;
 
-    GraveyardStruct const* GetClosestGraveyard(Player* player);
+    GraveyardStruct const* GetClosestGraveyard(Player* player) override;
 
     /* Scorekeeping */
-    void UpdatePlayerScore(Player* player, uint32 type, uint32 value, bool doAddHonor = true);
+    void UpdatePlayerScore(Player* player, uint32 type, uint32 value, bool doAddHonor = true) override;
 
-    void FillInitialWorldStates(WorldPacket& data);
+    void FillInitialWorldStates(WorldPacket& data) override;
 
-    void HandlePlayerResurrect(Player* player);
+    void HandlePlayerResurrect(Player* player) override;
 
     uint32 GetNodeState(uint8 nodeType) const { return (uint8)nodePoint[nodeType].nodeState; }
 
-    bool AllNodesConrolledByTeam(TeamId teamId) const;  // overwrited
+    bool AllNodesConrolledByTeam(TeamId teamId) const override;  // overwrited
     bool IsResourceGlutAllowed(TeamId teamId) const;
-    void DoAction(uint32 action, uint64 guid);
+    void DoAction(uint32 action, uint64 guid) override;
 private:
     uint32 closeFortressDoorsTimer;
     bool doorsClosed;

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

@@ -35,19 +35,19 @@ class BattlegroundNA : public Battleground
 {
 public:
     BattlegroundNA();
-    ~BattlegroundNA();
+    ~BattlegroundNA() override;
 
     /* inherited from BattlegroundClass */
-    void AddPlayer(Player* player);
-    void StartingEventCloseDoors();
-    void StartingEventOpenDoors();
+    void AddPlayer(Player* player) override;
+    void StartingEventCloseDoors() override;
+    void StartingEventOpenDoors() override;
 
-    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);
+    void RemovePlayer(Player* player) override;
+    void HandleAreaTrigger(Player* player, uint32 trigger) override;
+    bool SetupBattleground() override;
+    void Init() override;
+    void FillInitialWorldStates(WorldPacket& d) override;
+    void HandleKillPlayer(Player* player, Player* killer) override;
+    bool HandlePlayerUnderMap(Player* player) override;
 };
 #endif

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

@@ -31,19 +31,19 @@ class BattlegroundRL : public Battleground
 {
 public:
     BattlegroundRL();
-    ~BattlegroundRL();
+    ~BattlegroundRL() override;
 
     /* inherited from BattlegroundClass */
-    void AddPlayer(Player* player);
-    void Init();
-    void FillInitialWorldStates(WorldPacket& d);
-    void StartingEventCloseDoors();
-    void StartingEventOpenDoors();
+    void AddPlayer(Player* player) override;
+    void Init() override;
+    void FillInitialWorldStates(WorldPacket& d) override;
+    void StartingEventCloseDoors() override;
+    void StartingEventOpenDoors() override;
 
-    void RemovePlayer(Player* player);
-    void HandleAreaTrigger(Player* player, uint32 trigger);
-    bool SetupBattleground();
-    void HandleKillPlayer(Player* player, Player* killer);
-    bool HandlePlayerUnderMap(Player* player);
+    void RemovePlayer(Player* player) override;
+    void HandleAreaTrigger(Player* player, uint32 trigger) override;
+    bool SetupBattleground() override;
+    void HandleKillPlayer(Player* player, Player* killer) override;
+    bool HandlePlayerUnderMap(Player* player) override;
 };
 #endif

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

@@ -78,20 +78,20 @@ class BattlegroundRV : public Battleground
 {
 public:
     BattlegroundRV();
-    ~BattlegroundRV();
+    ~BattlegroundRV() override;
 
     /* 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);
+    void AddPlayer(Player* player) override;
+    void RemovePlayer(Player* player) override;
+    void StartingEventCloseDoors() override;
+    void StartingEventOpenDoors() override;
+    void Init() override;
+    void FillInitialWorldStates(WorldPacket& d) override;
+    void UpdateArenaWorldState() override;
+    void HandleAreaTrigger(Player* player, uint32 trigger) override;
+    bool SetupBattleground() override;
+    void HandleKillPlayer(Player* player, Player* killer) override;
+    bool HandlePlayerUnderMap(Player* player) override;
 
     GameObject* GetPillarAtPosition(Position* p);
 
@@ -100,7 +100,7 @@ private:
     uint32 State;
     uint16 CheckPlayersTimer;
 
-    void PostUpdateImpl(uint32 diff);
+    void PostUpdateImpl(uint32 diff) override;
 
 protected:
     uint32 getTimer() { return Timer; }

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

@@ -12,12 +12,12 @@
 struct BattlegroundSAScore : public BattlegroundScore
 {
     BattlegroundSAScore(Player* player) : BattlegroundScore(player), demolishers_destroyed(0), gates_destroyed(0) { }
-    ~BattlegroundSAScore() { }
+    ~BattlegroundSAScore() override { }
     uint8 demolishers_destroyed;
     uint8 gates_destroyed;
 
-    uint32 GetAttr1() const final override { return demolishers_destroyed; }
-    uint32 GetAttr2() const final override { return gates_destroyed; }
+    uint32 GetAttr1() const final { return demolishers_destroyed; }
+    uint32 GetAttr2() const final { return gates_destroyed; }
 };
 
 #define BG_SA_FLAG_AMOUNT           3
@@ -421,36 +421,36 @@ class BattlegroundSA : public Battleground
 {
 public:
     BattlegroundSA();
-    ~BattlegroundSA();
+    ~BattlegroundSA() override;
 
     /**
      * \brief Called every time for update battle data
      * -Update timer
      * -Round switch
      */
-    void PostUpdateImpl(uint32 diff);
+    void PostUpdateImpl(uint32 diff) override;
 
     /* inherited from BattlegroundClass */
     /// Called when a player join battle
-    void AddPlayer(Player* player);
+    void AddPlayer(Player* player) override;
     /// Called when battle start
-    void StartingEventCloseDoors();
-    void StartingEventOpenDoors();
+    void StartingEventCloseDoors() override;
+    void StartingEventOpenDoors() override;
     /// Called for ini battleground, after that the first player be entered
-    bool SetupBattleground();
-    void Init();
+    bool SetupBattleground() override;
+    void Init() override;
     /// Called for generate packet contain worldstate data
-    void FillInitialWorldStates(WorldPacket& data);
+    void FillInitialWorldStates(WorldPacket& data) override;
     /// Called when a player deal damage to building (door)
-    void EventPlayerDamagedGO(Player* player, GameObject* go, uint32 eventType);
+    void EventPlayerDamagedGO(Player* player, GameObject* go, uint32 eventType) override;
     /// Called when a player kill a unit in bg
-    void HandleKillUnit(Creature* creature, Player* killer);
+    void HandleKillUnit(Creature* creature, Player* killer) override;
     /// Return the nearest graveyard where player can respawn
-    GraveyardStruct const* GetClosestGraveyard(Player* player);
+    GraveyardStruct const* GetClosestGraveyard(Player* player) override;
     /// Called when a player click on flag (graveyard flag)
-    void EventPlayerClickedOnFlag(Player* Source, GameObject* gameObject);
+    void EventPlayerClickedOnFlag(Player* Source, GameObject* gameObject) override;
     /// Called when a player use a gamobject (relic)
-    void EventPlayerUsedGO(Player* Source, GameObject* object);
+    void EventPlayerUsedGO(Player* Source, GameObject* object) override;
 
     /// Return worldstate id, according to door id
     uint32 GetWorldStateFromGateID(uint32 id)
@@ -481,15 +481,15 @@ public:
     }
 
     /// Called on battleground ending
-    void EndBattleground(TeamId winnerTeamId);
+    void EndBattleground(TeamId winnerTeamId) override;
 
     /// CAlled when a player leave battleground
-    void RemovePlayer(Player* player);
-    void HandleAreaTrigger(Player* player, uint32 trigger);
+    void RemovePlayer(Player* player) override;
+    void HandleAreaTrigger(Player* player, uint32 trigger) override;
 
     /* Scorekeeping */
     /// Update score board
-    void UpdatePlayerScore(Player* player, uint32 type, uint32 value, bool doAddHonor = true);
+    void UpdatePlayerScore(Player* player, uint32 type, uint32 value, bool doAddHonor = true) override;
 
     // Teleporters
     void DefendersPortalTeleport(GameObject* portal, Player* plr);
@@ -561,7 +561,7 @@ private:
      * -Update worldstate
      * -Delete gameobject in front of door (lighting object, with different colours for each door)
      */
-    void DestroyGate(Player* player, GameObject* go);
+    void DestroyGate(Player* player, GameObject* go) override;
     /// Update timer worldstate
     void SendTime();
     /**

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

@@ -139,12 +139,12 @@ enum BG_WS_Objectives
 struct BattlegroundWGScore : public BattlegroundScore
 {
     BattlegroundWGScore(Player* player): BattlegroundScore(player), FlagCaptures(0), FlagReturns(0) { }
-    ~BattlegroundWGScore() { }
+    ~BattlegroundWGScore() override { }
     uint32 FlagCaptures;
     uint32 FlagReturns;
 
-    uint32 GetAttr1() const final override { return FlagCaptures; }
-    uint32 GetAttr2() const final override { return FlagReturns; }
+    uint32 GetAttr1() const final { return FlagCaptures; }
+    uint32 GetAttr2() const final { return FlagReturns; }
 };
 
 class BattlegroundWS : public Battleground
@@ -152,42 +152,42 @@ class BattlegroundWS : public Battleground
 public:
     /* Construction */
     BattlegroundWS();
-    ~BattlegroundWS();
+    ~BattlegroundWS() override;
 
     /* inherited from BattlegroundClass */
-    void AddPlayer(Player* player);
-    void StartingEventCloseDoors();
-    void StartingEventOpenDoors();
+    void AddPlayer(Player* player) override;
+    void StartingEventCloseDoors() override;
+    void StartingEventOpenDoors() override;
 
     /* BG Flags */
-    uint64 GetFlagPickerGUID(TeamId teamId) const { return _flagKeepers[teamId];  }
+    uint64 GetFlagPickerGUID(TeamId teamId) const override { 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 EventPlayerDroppedFlag(Player* player) override;
+    void EventPlayerClickedOnFlag(Player* player, GameObject* gameObject) override;
     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);
-    GraveyardStruct const* GetClosestGraveyard(Player* player);
+    void RemovePlayer(Player* player) override;
+    void HandleAreaTrigger(Player* player, uint32 trigger) override;
+    void HandleKillPlayer(Player* player, Player* killer) override;
+    bool SetupBattleground() override;
+    void Init() override;
+    void EndBattleground(TeamId winnerTeamId) override;
+    GraveyardStruct const* GetClosestGraveyard(Player* player) override;
 
     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; }
+    void UpdatePlayerScore(Player* player, uint32 type, uint32 value, bool doAddHonor = true) override;
+    void SetDroppedFlagGUID(uint64 guid, TeamId teamId) override { _droppedFlagGUID[teamId] = guid; }
     uint64 GetDroppedFlagGUID(TeamId teamId) const { return _droppedFlagGUID[teamId];}
-    void FillInitialWorldStates(WorldPacket& data);
+    void FillInitialWorldStates(WorldPacket& data) override;
 
     /* Scorekeeping */
     void AddPoints(TeamId teamId, uint32 points) { m_TeamScores[teamId] += points; }
 
-    TeamId GetPrematureWinner();
+    TeamId GetPrematureWinner() override;
     uint32 GetMatchTime() const { return 1 + (BG_WS_TOTAL_GAME_TIME - GetStartTime()) / (MINUTE * IN_MILLISECONDS); }
     uint32 GetAssaultSpellId() const;
     void RemoveAssaultAuras();
@@ -203,6 +203,6 @@ private:
     uint32 _honorWinKills;
     uint32 _honorEndKills;
 
-    void PostUpdateImpl(uint32 diff);
+    void PostUpdateImpl(uint32 diff) override;
 };
 #endif

src/server/game/Chat/ChatLink.h

@@ -49,8 +49,8 @@ public:
     {
         memset(_data, 0, sizeof(_data));
     }
-    virtual bool Initialize(std::istringstream& iss);
-    virtual bool ValidateName(char* buffer, const char* context);
+    bool Initialize(std::istringstream& iss) override;
+    bool ValidateName(char* buffer, const char* context) override;
 
 protected:
     std::string FormatName(uint8 index, ItemLocale const* locale, char* const* suffixStrings) const;
@@ -66,8 +66,8 @@ class QuestChatLink : public ChatLink
 {
 public:
     QuestChatLink() : ChatLink(), _quest(nullptr), _questLevel(0) { }
-    virtual bool Initialize(std::istringstream& iss);
-    virtual bool ValidateName(char* buffer, const char* context);
+    bool Initialize(std::istringstream& iss) override;
+    bool ValidateName(char* buffer, const char* context) override;
 
 protected:
     Quest const* _quest;
@@ -79,8 +79,8 @@ class SpellChatLink : public ChatLink
 {
 public:
     SpellChatLink() : ChatLink(), _spell(nullptr) { }
-    virtual bool Initialize(std::istringstream& iss);
-    virtual bool ValidateName(char* buffer, const char* context);
+    bool Initialize(std::istringstream& iss) override;
+    bool ValidateName(char* buffer, const char* context) override;
 
 protected:
     SpellInfo const* _spell;
@@ -94,8 +94,8 @@ public:
     {
         memset(_data, 0, sizeof(_data));
     }
-    virtual bool Initialize(std::istringstream& iss);
-    virtual bool ValidateName(char* buffer, const char* context);
+    bool Initialize(std::istringstream& iss) override;
+    bool ValidateName(char* buffer, const char* context) override;
 
 protected:
     uint32 _guid;
@@ -108,7 +108,7 @@ class TradeChatLink : public SpellChatLink
 {
 public:
     TradeChatLink() : SpellChatLink(), _minSkillLevel(0), _maxSkillLevel(0), _guid(0) { }
-    virtual bool Initialize(std::istringstream& iss);
+    bool Initialize(std::istringstream& iss) override;
 private:
     int32 _minSkillLevel;
     int32 _maxSkillLevel;
@@ -121,7 +121,7 @@ class TalentChatLink : public SpellChatLink
 {
 public:
     TalentChatLink() : SpellChatLink(), _talentId(0), _rankId(0) { }
-    virtual bool Initialize(std::istringstream& iss);
+    bool Initialize(std::istringstream& iss) override;
 
 private:
     uint32 _talentId;
@@ -133,7 +133,7 @@ class EnchantmentChatLink : public SpellChatLink
 {
 public:
     EnchantmentChatLink() : SpellChatLink() { }
-    virtual bool Initialize(std::istringstream& iss);
+    bool Initialize(std::istringstream& iss) override;
 };
 
 // GlyphChatLink - link to glyph
@@ -141,7 +141,7 @@ class GlyphChatLink : public SpellChatLink
 {
 public:
     GlyphChatLink() : SpellChatLink(), _slotId(0), _glyph(nullptr) { }
-    virtual bool Initialize(std::istringstream& iss);
+    bool Initialize(std::istringstream& iss) override;
 private:
     uint32 _slotId;
     GlyphPropertiesEntry const* _glyph;

src/server/game/Combat/HostileRefManager.h

@@ -23,7 +23,7 @@ private:
     Unit* iOwner;
 public:
     explicit HostileRefManager(Unit* owner) { iOwner = owner; }
-    ~HostileRefManager();
+    ~HostileRefManager() override;
 
     Unit* GetOwner() { return iOwner; }
 

src/server/game/Combat/ThreatManager.h

@@ -99,13 +99,13 @@ public:
     //=================================================
 
     // Tell our refTo (target) object that we have a link
-    void targetObjectBuildLink();
+    void targetObjectBuildLink() override;
 
     // Tell our refTo (taget) object, that the link is cut
-    void targetObjectDestroyLink();
+    void targetObjectDestroyLink() override;
 
     // Tell our refFrom (source) object, that the link is cut (Target destroyed)
-    void sourceObjectDestroyLink();
+    void sourceObjectDestroyLink() override;
 private:
     // Inform the source, that the status of that reference was changed
     void fireStatusChanged(ThreatRefStatusChangeEvent& threatRefStatusChangeEvent);

src/server/game/DungeonFinding/LFGScripts.h

@@ -24,11 +24,11 @@ namespace lfg
         LFGPlayerScript();
 
         // Player Hooks
-        void OnLevelChanged(Player* player, uint8 oldLevel);
-        void OnLogout(Player* player);
-        void OnLogin(Player* player);
-        void OnBindToInstance(Player* player, Difficulty difficulty, uint32 mapId, bool permanent);
-        void OnMapChanged(Player* player);
+        void OnLevelChanged(Player* player, uint8 oldLevel) override;
+        void OnLogout(Player* player) override;
+        void OnLogin(Player* player) override;
+        void OnBindToInstance(Player* player, Difficulty difficulty, uint32 mapId, bool permanent) override;
+        void OnMapChanged(Player* player) override;
     };
 
     class LFGGroupScript : public GroupScript
@@ -37,11 +37,11 @@ namespace lfg
         LFGGroupScript();
 
         // Group Hooks
-        void OnAddMember(Group* group, uint64 guid);
-        void OnRemoveMember(Group* group, uint64 guid, RemoveMethod method, uint64 kicker, char const* reason);
-        void OnDisband(Group* group);
-        void OnChangeLeader(Group* group, uint64 newLeaderGuid, uint64 oldLeaderGuid);
-        void OnInviteMember(Group* group, uint64 guid);
+        void OnAddMember(Group* group, uint64 guid) override;
+        void OnRemoveMember(Group* group, uint64 guid, RemoveMethod method, uint64 kicker, char const* reason) override;
+        void OnDisband(Group* group) override;
+        void OnChangeLeader(Group* group, uint64 newLeaderGuid, uint64 oldLeaderGuid) override;
+        void OnInviteMember(Group* group, uint64 guid) override;
     };
 
 } // namespace lfg

src/server/game/Entities/Corpse/Corpse.h

@@ -38,7 +38,7 @@ class Corpse : public WorldObject, public GridObject<Corpse>
 {
 public:
     explicit Corpse(CorpseType type = CORPSE_BONES);
-    ~Corpse();
+    ~Corpse() override;
 
     void AddToWorld() override;
     void RemoveFromWorld() override;

src/server/game/Entities/Creature/Creature.h

@@ -430,7 +430,7 @@ class Creature : public Unit, public GridObject<Creature>, public MovableMapObje
 public:
 
     explicit Creature(bool isWorldObject = false);
-    virtual ~Creature();
+    ~Creature() override;
 
     void AddToWorld() override;
     void RemoveFromWorld() override;
@@ -523,8 +523,8 @@ public:
     void SetMeleeDamageSchool(SpellSchools school) { m_meleeDamageSchoolMask = SpellSchoolMask(1 << school); }
 
     void _AddCreatureSpellCooldown(uint32 spell_id, uint32 end_time);
-    virtual void AddSpellCooldown(uint32 spell_id, uint32 /*itemid*/, uint32 end_time, bool needSendToClient = false, bool forceSendToSpectator = false) override;
-    virtual bool HasSpellCooldown(uint32 spell_id) const override;
+    void AddSpellCooldown(uint32 spell_id, uint32 /*itemid*/, uint32 end_time, bool needSendToClient = false, bool forceSendToSpectator = false) override;
+    bool HasSpellCooldown(uint32 spell_id) const override;
     uint32 GetSpellCooldown(uint32 spell_id) const;
     void ProhibitSpellSchool(SpellSchoolMask idSchoolMask, uint32 unTimeMs) override;
     bool IsSpellProhibited(SpellSchoolMask idSchoolMask) const;
@@ -799,7 +799,7 @@ class AssistDelayEvent : public BasicEvent
 public:
     AssistDelayEvent(uint64 victim, Unit& owner) : BasicEvent(), m_victim(victim), m_owner(owner) { }
 
-    bool Execute(uint64 e_time, uint32 p_time);
+    bool Execute(uint64 e_time, uint32 p_time) override;
     void AddAssistant(uint64 guid) { m_assistants.push_back(guid); }
 private:
     AssistDelayEvent();
@@ -813,7 +813,7 @@ class ForcedDespawnDelayEvent : public BasicEvent
 {
 public:
     ForcedDespawnDelayEvent(Creature& owner) : BasicEvent(), m_owner(owner) { }
-    bool Execute(uint64 e_time, uint32 p_time);
+    bool Execute(uint64 e_time, uint32 p_time) override;
 
 private:
     Creature& m_owner;

src/server/game/Entities/Creature/TemporarySummon.h

@@ -29,14 +29,14 @@ class TempSummon : public Creature
 {
 public:
     explicit TempSummon(SummonPropertiesEntry const* properties, uint64 owner, bool isWorldObject);
-    virtual ~TempSummon() {}
-    void Update(uint32 time);
+    ~TempSummon() override {}
+    void Update(uint32 time) override;
     virtual void InitStats(uint32 lifetime);
     virtual void InitSummon();
     virtual void UnSummon(uint32 msTime = 0);
-    void RemoveFromWorld();
+    void RemoveFromWorld() override;
     void SetTempSummonType(TempSummonType type);
-    void SaveToDB(uint32 /*mapid*/, uint8 /*spawnMask*/, uint32 /*phaseMask*/) {}
+    void SaveToDB(uint32 /*mapid*/, uint8 /*spawnMask*/, uint32 /*phaseMask*/) override {}
     Unit* GetSummoner() const;
     uint64 GetSummonerGUID() { return m_summonerGUID; }
     TempSummonType const& GetSummonType() { return m_type; }
@@ -55,14 +55,14 @@ class Minion : public TempSummon
 {
 public:
     Minion(SummonPropertiesEntry const* properties, uint64 owner, bool isWorldObject);
-    void InitStats(uint32 duration);
-    void RemoveFromWorld();
+    void InitStats(uint32 duration) override;
+    void RemoveFromWorld() override;
     Unit* GetOwner() const;
-    float GetFollowAngle() const { return m_followAngle; }
+    float GetFollowAngle() const override { return m_followAngle; }
     void SetFollowAngle(float angle) { m_followAngle = angle; }
     bool IsPetGhoul() const {return GetEntry() == 26125 /*normal ghoul*/ || GetEntry() == 30230 /*Raise Ally ghoul*/;} // Ghoul may be guardian or pet
     bool IsGuardianPet() const;
-    void setDeathState(DeathState s, bool despawn = false);                   // override virtual Unit::setDeathState
+    void setDeathState(DeathState s, bool despawn = false) override;                   // override virtual Unit::setDeathState
 protected:
     const uint64 m_owner;
     float m_followAngle;
@@ -72,27 +72,27 @@ class Guardian : public Minion
 {
 public:
     Guardian(SummonPropertiesEntry const* properties, uint64 owner, bool isWorldObject);
-    void InitStats(uint32 duration);
+    void InitStats(uint32 duration) override;
     bool InitStatsForLevel(uint8 level);
-    void InitSummon();
+    void InitSummon() override;
 
-    bool UpdateStats(Stats stat);
-    bool UpdateAllStats();
-    void UpdateArmor();
-    void UpdateMaxHealth();
-    void UpdateMaxPower(Powers power);
-    void UpdateAttackPowerAndDamage(bool ranged = false);
-    void UpdateDamagePhysical(WeaponAttackType attType);
+    bool UpdateStats(Stats stat) override;
+    bool UpdateAllStats() override;
+    void UpdateArmor() override;
+    void UpdateMaxHealth() override;
+    void UpdateMaxPower(Powers power) override;
+    void UpdateAttackPowerAndDamage(bool ranged = false) override;
+    void UpdateDamagePhysical(WeaponAttackType attType) override;
 };
 
 class Puppet : public Minion
 {
 public:
     Puppet(SummonPropertiesEntry const* properties, uint64 owner);
-    void InitStats(uint32 duration);
-    void InitSummon();
-    void Update(uint32 time);
-    void RemoveFromWorld();
+    void InitStats(uint32 duration) override;
+    void InitSummon() override;
+    void Update(uint32 time) override;
+    void RemoveFromWorld() override;
 protected:
     Player* GetOwner() const;
     const uint64 m_owner;
@@ -102,7 +102,7 @@ class ForcedUnsummonDelayEvent : public BasicEvent
 {
 public:
     ForcedUnsummonDelayEvent(TempSummon& owner) : BasicEvent(), m_owner(owner) { }
-    bool Execute(uint64 e_time, uint32 p_time);
+    bool Execute(uint64 e_time, uint32 p_time) override;
 
 private:
     TempSummon& m_owner;

src/server/game/Entities/DynamicObject/DynamicObject.h

@@ -24,7 +24,7 @@ class DynamicObject : public WorldObject, public GridObject<DynamicObject>, publ
 {
 public:
     DynamicObject(bool isWorldObject);
-    ~DynamicObject();
+    ~DynamicObject() override;
 
     void AddToWorld() override;
     void RemoveFromWorld() override;

src/server/game/Entities/GameObject/GameObject.h

@@ -731,7 +731,7 @@ class GameObject : public WorldObject, public GridObject<GameObject>, public Mov
 {
 public:
     explicit GameObject();
-    ~GameObject();
+    ~GameObject() override;
 
     void BuildValuesUpdate(uint8 updatetype, ByteBuffer* data, Player* target) const override;
 

src/server/game/Entities/Item/Container/Bag.h

@@ -18,12 +18,12 @@ class Bag : public Item
 public:
 
     Bag();
-    ~Bag();
+    ~Bag() override;
 
-    void AddToWorld();
-    void RemoveFromWorld();
+    void AddToWorld() override;
+    void RemoveFromWorld() override;
 
-    bool Create(uint32 guidlow, uint32 itemid, Player const* owner);
+    bool Create(uint32 guidlow, uint32 itemid, Player const* owner) override;
 
     void Clear();
     void StoreItem(uint8 slot, Item* pItem, bool update);
@@ -40,13 +40,13 @@ public:
 
     // DB operations
     // overwrite virtual Item::SaveToDB
-    void SaveToDB(SQLTransaction& trans);
+    void SaveToDB(SQLTransaction& trans) override;
     // overwrite virtual Item::LoadFromDB
-    bool LoadFromDB(uint32 guid, uint64 owner_guid, Field* fields, uint32 entry);
+    bool LoadFromDB(uint32 guid, uint64 owner_guid, Field* fields, uint32 entry) override;
     // overwrite virtual Item::DeleteFromDB
-    void DeleteFromDB(SQLTransaction& trans);
+    void DeleteFromDB(SQLTransaction& trans) override;
 
-    void BuildCreateUpdateBlockForPlayer(UpdateData* data, Player* target) const;
+    void BuildCreateUpdateBlockForPlayer(UpdateData* data, Player* target) const override;
 
 protected:
 

src/server/game/Entities/Item/Item.h

@@ -306,8 +306,8 @@ public:
         uState = state;
     }
 
-    bool hasQuest(uint32 quest_id) const { return GetTemplate()->StartQuest == quest_id; }
-    bool hasInvolvedQuest(uint32 /*quest_id*/) const { return false; }
+    bool hasQuest(uint32 quest_id) const override { return GetTemplate()->StartQuest == quest_id; }
+    bool hasInvolvedQuest(uint32 /*quest_id*/) const override { return false; }
     bool IsPotion() const { return GetTemplate()->IsPotion(); }
     bool IsWeaponVellum() const { return GetTemplate()->IsWeaponVellum(); }
     bool IsArmorVellum() const { return GetTemplate()->IsArmorVellum(); }
@@ -331,7 +331,7 @@ public:
     void ClearSoulboundTradeable(Player* currentOwner);
     bool CheckSoulboundTradeExpire();
 
-    void BuildUpdate(UpdateDataMapType& data_map, UpdatePlayerSet&);
+    void BuildUpdate(UpdateDataMapType& data_map, UpdatePlayerSet&) override;
 
     uint32 GetScriptId() const { return GetTemplate()->ScriptId; }
 private:

src/server/game/Entities/Object/Object.h

@@ -764,7 +764,7 @@ class WorldObject : public Object, public WorldLocation
 protected:
     explicit WorldObject(bool isWorldObject); //note: here it means if it is in grid object list or world object list
 public:
-    virtual ~WorldObject();
+    ~WorldObject() override;
 
 #ifdef ELUNA
     virtual void Update(uint32 /*time_diff*/);
@@ -773,7 +773,7 @@ public:
 #endif
     void _Create(uint32 guidlow, HighGuid guidhigh, uint32 phaseMask);
 
-    virtual void RemoveFromWorld()
+    void RemoveFromWorld() override
     {
         if (!IsInWorld())
             return;
@@ -1005,7 +1005,7 @@ public:
 
     void DestroyForNearbyPlayers();
     virtual void UpdateObjectVisibility(bool forced = true, bool fromUpdate = false);
-    void BuildUpdate(UpdateDataMapType& data_map, UpdatePlayerSet& player_set);
+    void BuildUpdate(UpdateDataMapType& data_map, UpdatePlayerSet& player_set) override;
     void GetCreaturesWithEntryInRange(std::list<Creature*>& creatureList, float radius, uint32 entry);
 
     //relocation and visibility system functions

src/server/game/Entities/Pet/Pet.h

@@ -45,7 +45,7 @@ class Pet : public Guardian
 {
 public:
     explicit Pet(Player* owner, PetType type = MAX_PET_TYPE);
-    virtual ~Pet();
+    ~Pet() override;
 
     void AddToWorld() override;
     void RemoveFromWorld() override;

src/server/game/Entities/Player/Player.h

@@ -1138,7 +1138,7 @@ class Player : public Unit, public GridObject<Player>
     friend void Item::RemoveFromUpdateQueueOf(Player* player);
 public:
     explicit Player(WorldSession* session);
-    ~Player();
+    ~Player() override;
 
     void CleanupsBeforeDelete(bool finalCleanup = true) override;
 
@@ -1805,12 +1805,12 @@ public:
 
     static uint32 const infinityCooldownDelay = 0x9A7EC800;  // used for set "infinity cooldowns" for spells and check, MONTH*IN_MILLISECONDS
     static uint32 const infinityCooldownDelayCheck = 0x4D3F6400; //MONTH*IN_MILLISECONDS/2;
-    virtual bool HasSpellCooldown(uint32 spell_id) const override
+    bool HasSpellCooldown(uint32 spell_id) const override
     {
         SpellCooldowns::const_iterator itr = m_spellCooldowns.find(spell_id);
         return itr != m_spellCooldowns.end() && itr->second.end > World::GetGameTimeMS();
     }
-    virtual bool HasSpellItemCooldown(uint32 spell_id, uint32 itemid) const override
+    bool HasSpellItemCooldown(uint32 spell_id, uint32 itemid) const override
     {
         SpellCooldowns::const_iterator itr = m_spellCooldowns.find(spell_id);
         return itr != m_spellCooldowns.end() && itr->second.end > World::GetGameTimeMS() && itr->second.itemid == itemid;
@@ -2048,7 +2048,7 @@ public:
     void SendResetInstanceFailed(uint32 reason, uint32 MapId);
     void SendResetFailedNotify(uint32 mapid);
 
-    virtual bool UpdatePosition(float x, float y, float z, float orientation, bool teleport = false) override;
+    bool UpdatePosition(float x, float y, float z, float orientation, bool teleport = false) override;
     bool UpdatePosition(const Position& pos, bool teleport = false) { return UpdatePosition(pos.GetPositionX(), pos.GetPositionY(), pos.GetPositionZ(), pos.GetOrientation(), teleport); }
     void UpdateUnderwaterState(Map* m, float x, float y, float z) override;
 

src/server/game/Entities/Totem/Totem.h

@@ -25,26 +25,26 @@ class Totem : public Minion
 {
 public:
     explicit Totem(SummonPropertiesEntry const* properties, uint64 owner);
-    virtual ~Totem() {};
-    void Update(uint32 time);
-    void InitStats(uint32 duration);
-    void InitSummon();
-    void UnSummon(uint32 msTime = 0);
+    ~Totem() override {};
+    void Update(uint32 time) override;
+    void InitStats(uint32 duration) override;
+    void InitSummon() override;
+    void UnSummon(uint32 msTime = 0) override;
     uint32 GetSpell(uint8 slot = 0) const { return m_spells[slot]; }
     uint32 GetTotemDuration() const { return m_duration; }
     void SetTotemDuration(uint32 duration) { m_duration = duration; }
     TotemType GetTotemType() const { return m_type; }
 
-    bool UpdateStats(Stats /*stat*/) { return true; }
-    bool UpdateAllStats() { return true; }
-    void UpdateResistances(uint32 /*school*/) {}
-    void UpdateArmor() {}
-    void UpdateMaxHealth() {}
-    void UpdateMaxPower(Powers /*power*/) {}
-    void UpdateAttackPowerAndDamage(bool /*ranged*/) {}
-    void UpdateDamagePhysical(WeaponAttackType /*attType*/) {}
+    bool UpdateStats(Stats /*stat*/) override { return true; }
+    bool UpdateAllStats() override { return true; }
+    void UpdateResistances(uint32 /*school*/) override {}
+    void UpdateArmor() override {}
+    void UpdateMaxHealth() override {}
+    void UpdateMaxPower(Powers /*power*/) override {}
+    void UpdateAttackPowerAndDamage(bool /*ranged*/) override {}
+    void UpdateDamagePhysical(WeaponAttackType /*attType*/) override {}
 
-    bool IsImmunedToSpellEffect(SpellInfo const* spellInfo, uint32 index) const;
+    bool IsImmunedToSpellEffect(SpellInfo const* spellInfo, uint32 index) const override;
 
 protected:
     TotemType m_type;

src/server/game/Entities/Transport/Transport.h

@@ -18,8 +18,8 @@ class Transport : public GameObject, public TransportBase
 {
 public:
     Transport() : GameObject() {}
-    void CalculatePassengerPosition(float& x, float& y, float& z, float* o = nullptr) const { TransportBase::CalculatePassengerPosition(x, y, z, o, GetPositionX(), GetPositionY(), GetPositionZ(), GetOrientation()); }
-    void CalculatePassengerOffset(float& x, float& y, float& z, float* o = nullptr) const { TransportBase::CalculatePassengerOffset(x, y, z, o, GetPositionX(), GetPositionY(), GetPositionZ(), GetOrientation()); }
+    void CalculatePassengerPosition(float& x, float& y, float& z, float* o = nullptr) const override { TransportBase::CalculatePassengerPosition(x, y, z, o, GetPositionX(), GetPositionY(), GetPositionZ(), GetOrientation()); }
+    void CalculatePassengerOffset(float& x, float& y, float& z, float* o = nullptr) const override { TransportBase::CalculatePassengerOffset(x, y, z, o, GetPositionX(), GetPositionY(), GetPositionZ(), GetOrientation()); }
 
     typedef std::set<WorldObject*> PassengerSet;
     virtual void AddPassenger(WorldObject* passenger, bool withAll = false) = 0;
@@ -38,18 +38,18 @@ class MotionTransport : public Transport
     friend MotionTransport* TransportMgr::CreateTransport(uint32, uint32, Map*);
     MotionTransport();
 public:
-    ~MotionTransport();
+    ~MotionTransport() override;
 
     bool CreateMoTrans(uint32 guidlow, uint32 entry, uint32 mapid, float x, float y, float z, float ang, uint32 animprogress);
-    void CleanupsBeforeDelete(bool finalCleanup = true);
-    void BuildUpdate(UpdateDataMapType& data_map, UpdatePlayerSet&);
+    void CleanupsBeforeDelete(bool finalCleanup = true) override;
+    void BuildUpdate(UpdateDataMapType& data_map, UpdatePlayerSet&) override;
 
-    void Update(uint32 diff);
+    void Update(uint32 diff) override;
     void DelayedUpdate(uint32 diff);
     void UpdatePosition(float x, float y, float z, float o);
 
-    void AddPassenger(WorldObject* passenger, bool withAll = false);
-    void RemovePassenger(WorldObject* passenger, bool withAll = false);
+    void AddPassenger(WorldObject* passenger, bool withAll = false) override;
+    void RemovePassenger(WorldObject* passenger, bool withAll = false) override;
     Creature* CreateNPCPassenger(uint32 guid, CreatureData const* data);
     GameObject* CreateGOPassenger(uint32 guid, GameObjectData const* data);
 
@@ -100,19 +100,19 @@ class StaticTransport : public Transport
 {
 public:
     StaticTransport();
-    ~StaticTransport();
+    ~StaticTransport() override;
 
-    virtual bool Create(uint32 guidlow, uint32 name_id, Map* map, uint32 phaseMask, float x, float y, float z, float ang, G3D::Quat const& rotation, uint32 animprogress, GOState go_state, uint32 artKit = 0);
-    void CleanupsBeforeDelete(bool finalCleanup = true);
-    void BuildUpdate(UpdateDataMapType& data_map, UpdatePlayerSet&);
+    bool Create(uint32 guidlow, uint32 name_id, Map* map, uint32 phaseMask, float x, float y, float z, float ang, G3D::Quat const& rotation, uint32 animprogress, GOState go_state, uint32 artKit = 0) override;
+    void CleanupsBeforeDelete(bool finalCleanup = true) override;
+    void BuildUpdate(UpdateDataMapType& data_map, UpdatePlayerSet&) override;
 
-    void Update(uint32 diff);
+    void Update(uint32 diff) override;
     void RelocateToProgress(uint32 progress);
     void UpdatePosition(float x, float y, float z, float o);
     void UpdatePassengerPositions();
 
-    void AddPassenger(WorldObject* passenger, bool withAll = false);
-    void RemovePassenger(WorldObject* passenger, bool withAll = false);
+    void AddPassenger(WorldObject* passenger, bool withAll = false) override;
+    void RemovePassenger(WorldObject* passenger, bool withAll = false) override;
 
     uint32 GetPauseTime() const { return GetUInt32Value(GAMEOBJECT_LEVEL); }
     void SetPauseTime(uint32 val) { SetUInt32Value(GAMEOBJECT_LEVEL, val); }

src/server/game/Entities/Unit/Unit.cpp

@@ -19074,7 +19074,7 @@ class AuraMunchingQueue : public BasicEvent
 public:
     AuraMunchingQueue(Unit& owner, uint64 targetGUID, int32 basePoints, uint32 spellId) : _owner(owner), _targetGUID(targetGUID), _basePoints(basePoints), _spellId(spellId) { }
 
-    bool Execute(uint64 /*eventTime*/, uint32 /*updateTime*/)
+    bool Execute(uint64 /*eventTime*/, uint32 /*updateTime*/) override
     {
         if (_owner.IsInWorld() && _owner.FindMap())
             if (Unit* target = ObjectAccessor::GetUnit(_owner, _targetGUID))

src/server/game/Entities/Unit/Unit.h

@@ -1373,7 +1373,7 @@ public:
 
     typedef std::map<uint8, AuraApplication*> VisibleAuraMap;
 
-    virtual ~Unit();
+    ~Unit() override;
 
     UnitAI* GetAI() { return i_AI; }
     void SetAI(UnitAI* newAI) { i_AI = newAI; }
@@ -1394,7 +1394,7 @@ public:
     float GetSpellMaxRangeForTarget(Unit const* target, SpellInfo const* spellInfo) const;
     float GetSpellMinRangeForTarget(Unit const* target, SpellInfo const* spellInfo) const;
 
-    virtual void Update(uint32 time) override;
+    void Update(uint32 time) override;
 
     void setAttackTimer(WeaponAttackType type, int32 time) { m_attackTimer[type] = time; }
     void resetAttackTimer(WeaponAttackType type = BASE_ATTACK);
@@ -2638,7 +2638,7 @@ class ConflagrateAuraStateDelayEvent : public BasicEvent
 {
 public:
     ConflagrateAuraStateDelayEvent(uint64 ownerGUID, uint64 casterGUID) : BasicEvent(), m_owner(ownerGUID), m_caster(casterGUID) { }
-    bool Execute(uint64 e_time, uint32 p_time);
+    bool Execute(uint64 e_time, uint32 p_time) override;
 
 private:
     uint64 m_owner;
@@ -2649,7 +2649,7 @@ class RedirectSpellEvent : public BasicEvent
 {
 public:
     RedirectSpellEvent(Unit& self, uint64 auraOwnerGUID, AuraEffect* auraEffect) : _self(self), _auraOwnerGUID(auraOwnerGUID), _auraEffect(auraEffect) { }
-    bool Execute(uint64 e_time, uint32 p_time);
+    bool Execute(uint64 e_time, uint32 p_time) override;
 
 protected:
     Unit& _self;
@@ -2661,7 +2661,7 @@ class VehicleDespawnEvent : public BasicEvent
 {
 public:
     VehicleDespawnEvent(Unit& self, uint32 duration) : _self(self), _duration(duration) { }
-    bool Execute(uint64 e_time, uint32 p_time);
+    bool Execute(uint64 e_time, uint32 p_time) override;
 
 protected:
     Unit& _self;

src/server/game/Entities/Vehicle/Vehicle.h

@@ -52,7 +52,7 @@ protected:
     friend bool Unit::CreateVehicleKit(uint32 id, uint32 creatureEntry);
     Vehicle(Unit* unit, VehicleEntry const* vehInfo, uint32 creatureEntry);
     friend void Unit::RemoveVehicleKit();
-    ~Vehicle();
+    ~Vehicle() override;
 
 private:
     enum Status
@@ -65,7 +65,7 @@ private:
     void InitMovementInfoForBase();
 
     /// This method transforms supplied transport offsets into global coordinates
-    void CalculatePassengerPosition(float& x, float& y, float& z, float* o /*= NULL*/) const
+    void CalculatePassengerPosition(float& x, float& y, float& z, float* o /*= NULL*/) const override
     {
         TransportBase::CalculatePassengerPosition(x, y, z, o,
                 GetBase()->GetPositionX(), GetBase()->GetPositionY(),
@@ -73,7 +73,7 @@ private:
     }
 
     /// This method transforms supplied global coordinates into local offsets
-    void CalculatePassengerOffset(float& x, float& y, float& z, float* o /*= NULL*/) const
+    void CalculatePassengerOffset(float& x, float& y, float& z, float* o /*= NULL*/) const override
     {
         TransportBase::CalculatePassengerOffset(x, y, z, o,
                                                 GetBase()->GetPositionX(), GetBase()->GetPositionY(),

src/server/game/Grids/GridReference.h

@@ -16,25 +16,25 @@ template<class OBJECT>
 class GridReference : public Reference<GridRefManager<OBJECT>, OBJECT>
 {
 protected:
-    void targetObjectBuildLink()
+    void targetObjectBuildLink() override
     {
         // called from link()
         this->getTarget()->insertFirst(this);
         this->getTarget()->incSize();
     }
-    void targetObjectDestroyLink()
+    void targetObjectDestroyLink() override
     {
         // called from unlink()
         if (this->isValid()) this->getTarget()->decSize();
     }
-    void sourceObjectDestroyLink()
+    void sourceObjectDestroyLink() override
     {
         // called from invalidate()
         this->getTarget()->decSize();
     }
 public:
     GridReference() : Reference<GridRefManager<OBJECT>, OBJECT>() {}
-    ~GridReference() { this->unlink(); }
+    ~GridReference() override { this->unlink(); }
     GridReference* next() { return (GridReference*)Reference<GridRefManager<OBJECT>, OBJECT>::next(); }
 };
 #endif

src/server/game/Groups/GroupReference.h

@@ -16,12 +16,12 @@ class GroupReference : public Reference<Group, Player>
 {
 protected:
     uint8 iSubGroup;
-    void targetObjectBuildLink();
-    void targetObjectDestroyLink();
-    void sourceObjectDestroyLink();
+    void targetObjectBuildLink() override;
+    void targetObjectDestroyLink() override;
+    void sourceObjectDestroyLink() override;
 public:
     GroupReference() : Reference<Group, Player>(), iSubGroup(0) {}
-    ~GroupReference() { unlink(); }
+    ~GroupReference() override { unlink(); }
     GroupReference* next() { return (GroupReference*)Reference<Group, Player>::next(); }
     GroupReference const* next() const { return (GroupReference const*)Reference<Group, Player>::next(); }
     uint8 getSubGroup() const { return iSubGroup; }

src/server/game/Guilds/Guild.h

@@ -401,10 +401,10 @@ private:
         EventLogEntry(uint32 guildId, uint32 guid, time_t timestamp, GuildEventLogTypes eventType, uint32 playerGuid1, uint32 playerGuid2, uint8 newRank) :
             LogEntry(guildId, guid, timestamp), m_eventType(eventType), m_playerGuid1(playerGuid1), m_playerGuid2(playerGuid2), m_newRank(newRank) { }
 
-        ~EventLogEntry() { }
+        ~EventLogEntry() override { }
 
-        void SaveToDB(SQLTransaction& trans) const;
-        void WritePacket(WorldPacket& data) const;
+        void SaveToDB(SQLTransaction& trans) const override;
+        void WritePacket(WorldPacket& data) const override;
 
     private:
         GuildEventLogTypes m_eventType;
@@ -433,10 +433,10 @@ private:
             LogEntry(guildId, guid, timestamp), m_eventType(eventType), m_bankTabId(tabId), m_playerGuid(playerGuid),
             m_itemOrMoney(itemOrMoney), m_itemStackCount(itemStackCount), m_destTabId(destTabId) { }
 
-        ~BankEventLogEntry() { }
+        ~BankEventLogEntry() override { }
 
-        void SaveToDB(SQLTransaction& trans) const;
-        void WritePacket(WorldPacket& data) const;
+        void SaveToDB(SQLTransaction& trans) const override;
+        void WritePacket(WorldPacket& data) const override;
 
     private:
         GuildBankEventLogTypes m_eventType;
@@ -615,13 +615,13 @@ private:
         PlayerMoveItemData(Guild* guild, Player* player, uint8 container, uint8 slotId) :
             MoveItemData(guild, player, container, slotId) { }
 
-        bool IsBank() const { return false; }
-        bool InitItem();
-        void RemoveItem(SQLTransaction& trans, MoveItemData* pOther, uint32 splitedAmount = 0);
-        Item* StoreItem(SQLTransaction& trans, Item* pItem);
-        void LogBankEvent(SQLTransaction& trans, MoveItemData* pFrom, uint32 count) const;
+        bool IsBank() const override { return false; }
+        bool InitItem() override;
+        void RemoveItem(SQLTransaction& trans, MoveItemData* pOther, uint32 splitedAmount = 0) override;
+        Item* StoreItem(SQLTransaction& trans, Item* pItem) override;
+        void LogBankEvent(SQLTransaction& trans, MoveItemData* pFrom, uint32 count) const override;
     protected:
-        InventoryResult CanStore(Item* pItem, bool swap);
+        InventoryResult CanStore(Item* pItem, bool swap) override;
     };
 
     class BankMoveItemData : public MoveItemData
@@ -630,17 +630,17 @@ private:
         BankMoveItemData(Guild* guild, Player* player, uint8 container, uint8 slotId) :
             MoveItemData(guild, player, container, slotId) { }
 
-        bool IsBank() const { return true; }
-        bool InitItem();
-        bool HasStoreRights(MoveItemData* pOther) const;
-        bool HasWithdrawRights(MoveItemData* pOther) const;
-        void RemoveItem(SQLTransaction& trans, MoveItemData* pOther, uint32 splitedAmount);
-        Item* StoreItem(SQLTransaction& trans, Item* pItem);
-        void LogBankEvent(SQLTransaction& trans, MoveItemData* pFrom, uint32 count) const;
-        void LogAction(MoveItemData* pFrom) const;
+        bool IsBank() const override { return true; }
+        bool InitItem() override;
+        bool HasStoreRights(MoveItemData* pOther) const override;
+        bool HasWithdrawRights(MoveItemData* pOther) const override;
+        void RemoveItem(SQLTransaction& trans, MoveItemData* pOther, uint32 splitedAmount) override;
+        Item* StoreItem(SQLTransaction& trans, Item* pItem) override;
+        void LogBankEvent(SQLTransaction& trans, MoveItemData* pFrom, uint32 count) const override;
+        void LogAction(MoveItemData* pFrom) const override;
 
     protected:
-        InventoryResult CanStore(Item* pItem, bool swap);
+        InventoryResult CanStore(Item* pItem, bool swap) override;
 
     private:
         Item* _StoreItem(SQLTransaction& trans, BankTab* pTab, Item* pItem, ItemPosCount& pos, bool clone) const;

src/server/game/Instances/InstanceScript.h

@@ -124,7 +124,7 @@ public:
 
     explicit InstanceScript(Map* map) : instance(map), completedEncounters(0) {}
 
-    virtual ~InstanceScript() {}
+    ~InstanceScript() override {}
 
     Map* instance;
 

src/server/game/Loot/LootMgr.h

@@ -269,8 +269,8 @@ class LootValidatorRef :  public Reference<Loot, LootValidatorRef>
 {
 public:
     LootValidatorRef() {}
-    void targetObjectDestroyLink() {}
-    void sourceObjectDestroyLink() {}
+    void targetObjectDestroyLink() override {}
+    void sourceObjectDestroyLink() override {}
 };
 
 //=====================================================

src/server/game/Maps/Map.h

@@ -274,7 +274,7 @@ class Map : public GridRefManager<NGridType>
     friend class MapReference;
 public:
     Map(uint32 id, uint32 InstanceId, uint8 SpawnMode, Map* _parent = nullptr);
-    virtual ~Map();
+    ~Map() override;
 
     MapEntry const* GetEntry() const { return i_mapEntry; }
 
@@ -676,24 +676,24 @@ class InstanceMap : public Map
 {
 public:
     InstanceMap(uint32 id, uint32 InstanceId, uint8 SpawnMode, Map* _parent);
-    ~InstanceMap();
-    bool AddPlayerToMap(Player*);
-    void RemovePlayerFromMap(Player*, bool);
-    void AfterPlayerUnlinkFromMap();
-    void Update(const uint32, const uint32, bool thread = true);
+    ~InstanceMap() override;
+    bool AddPlayerToMap(Player*) override;
+    void RemovePlayerFromMap(Player*, bool) override;
+    void AfterPlayerUnlinkFromMap() override;
+    void Update(const uint32, const uint32, bool thread = true) override;
     void CreateInstanceScript(bool load, std::string data, uint32 completedEncounterMask);
     bool Reset(uint8 method, std::list<uint32>* globalSkipList = nullptr);
     uint32 GetScriptId() { return i_script_id; }
     InstanceScript* GetInstanceScript() { return instance_script; }
     void PermBindAllPlayers();
-    void UnloadAll();
-    bool CanEnter(Player* player, bool loginCheck = false);
+    void UnloadAll() override;
+    bool CanEnter(Player* player, bool loginCheck = false) override;
     void SendResetWarnings(uint32 timeLeft) const;
 
     uint32 GetMaxPlayers() const;
     uint32 GetMaxResetDelay() const;
 
-    virtual void InitVisibilityDistance();
+    void InitVisibilityDistance() override;
 private:
     bool m_resetAfterUnload;
     bool m_unloadWhenEmpty;
@@ -705,16 +705,16 @@ class BattlegroundMap : public Map
 {
 public:
     BattlegroundMap(uint32 id, uint32 InstanceId, Map* _parent, uint8 spawnMode);
-    ~BattlegroundMap();
+    ~BattlegroundMap() override;
 
-    bool AddPlayerToMap(Player*);
-    void RemovePlayerFromMap(Player*, bool);
-    bool CanEnter(Player* player, bool loginCheck = false);
+    bool AddPlayerToMap(Player*) override;
+    void RemovePlayerFromMap(Player*, bool) override;
+    bool CanEnter(Player* player, bool loginCheck = false) override;
     void SetUnload();
     //void UnloadAll(bool pForce);
-    void RemoveAllPlayers();
+    void RemoveAllPlayers() override;
 
-    virtual void InitVisibilityDistance();
+    void InitVisibilityDistance() override;
     Battleground* GetBG() { return m_bg; }
     void SetBG(Battleground* bg) { m_bg = bg; }
 private:

src/server/game/Maps/MapInstanced.h

@@ -18,14 +18,14 @@ public:
     typedef std::unordered_map< uint32, Map*> InstancedMaps;
 
     MapInstanced(uint32 id);
-    ~MapInstanced() {}
+    ~MapInstanced() override {}
 
     // functions overwrite Map versions
-    void Update(const uint32, const uint32, bool thread = true);
-    void DelayedUpdate(const uint32 diff);
+    void Update(const uint32, const uint32, bool thread = true) override;
+    void DelayedUpdate(const uint32 diff) override;
     //void RelocationNotify();
-    void UnloadAll();
-    bool CanEnter(Player* player, bool loginCheck = false);
+    void UnloadAll() override;
+    bool CanEnter(Player* player, bool loginCheck = false) override;
 
     Map* CreateInstanceForPlayer(const uint32 mapId, Player* player);
     Map* FindInstanceMap(uint32 instanceId) const
@@ -36,7 +36,7 @@ public:
     bool DestroyInstance(InstancedMaps::iterator& itr);
 
     InstancedMaps& GetInstancedMaps() { return m_InstancedMaps; }
-    virtual void InitVisibilityDistance();
+    void InitVisibilityDistance() override;
 
 private:
     InstanceMap* CreateInstance(uint32 InstanceId, InstanceSave* save, Difficulty difficulty);

src/server/game/Maps/MapReference.h

@@ -13,25 +13,25 @@
 class MapReference : public Reference<Map, Player>
 {
 protected:
-    void targetObjectBuildLink()
+    void targetObjectBuildLink() override
     {
         // called from link()
         getTarget()->m_mapRefManager.insertFirst(this);
         getTarget()->m_mapRefManager.incSize();
     }
-    void targetObjectDestroyLink()
+    void targetObjectDestroyLink() override
     {
         // called from unlink()
         if (isValid()) getTarget()->m_mapRefManager.decSize();
     }
-    void sourceObjectDestroyLink()
+    void sourceObjectDestroyLink() override
     {
         // called from invalidate()
         getTarget()->m_mapRefManager.decSize();
     }
 public:
     MapReference() : Reference<Map, Player>() {}
-    ~MapReference() { unlink(); }
+    ~MapReference() override { unlink(); }
     MapReference* next() { return (MapReference*)Reference<Map, Player>::next(); }
     MapReference const* next() const { return (MapReference const*)Reference<Map, Player>::next(); }
     MapReference* nockeck_prev() { return (MapReference*)Reference<Map, Player>::nocheck_prev(); }

src/server/game/Maps/MapUpdater.cpp

@@ -43,7 +43,7 @@ class LFGUpdateRequest : public UpdateRequest
 public:
     LFGUpdateRequest(MapUpdater& u, uint32 d) : m_updater(u), m_diff(d) {}
 
-    void call()
+    void call() override
     {
         uint32 startTime = getMSTime();
         sLFGMgr->Update(m_diff, 1);

src/server/game/Misc/AsyncAuctionListing.h

@@ -9,10 +9,10 @@ class AuctionListOwnerItemsDelayEvent : public BasicEvent
 {
 public:
     AuctionListOwnerItemsDelayEvent(uint64 _creatureGuid, uint64 guid, bool o) : creatureGuid(_creatureGuid), playerguid(guid), owner(o) {}
-    virtual ~AuctionListOwnerItemsDelayEvent() {}
+    ~AuctionListOwnerItemsDelayEvent() override {}
 
-    virtual bool Execute(uint64 e_time, uint32 p_time);
-    virtual void Abort(uint64 /*e_time*/) {}
+    bool Execute(uint64 e_time, uint32 p_time) override;
+    void Abort(uint64 /*e_time*/) override {}
     bool getOwner() { return owner; }
 
 private:

src/server/game/Movement/FollowerReference.h

@@ -15,8 +15,8 @@ class Unit;
 class FollowerReference : public Reference<Unit, TargetedMovementGeneratorBase>
 {
 protected:
-    void targetObjectBuildLink();
-    void targetObjectDestroyLink();
-    void sourceObjectDestroyLink();
+    void targetObjectBuildLink() override;
+    void targetObjectDestroyLink() override;
+    void sourceObjectDestroyLink() override;
 };
 #endif

src/server/game/Movement/MovementGenerator.h

@@ -41,25 +41,25 @@ template<class T, class D>
 class MovementGeneratorMedium : public MovementGenerator
 {
 public:
-    void Initialize(Unit* u)
+    void Initialize(Unit* u) override
     {
         //u->AssertIsType<T>();
         (static_cast<D*>(this))->DoInitialize(static_cast<T*>(u));
     }
 
-    void Finalize(Unit* u)
+    void Finalize(Unit* u) override
     {
         //u->AssertIsType<T>();
         (static_cast<D*>(this))->DoFinalize(static_cast<T*>(u));
     }
 
-    void Reset(Unit* u)
+    void Reset(Unit* u) override
     {
         //u->AssertIsType<T>();
         (static_cast<D*>(this))->DoReset(static_cast<T*>(u));
     }
 
-    bool Update(Unit* u, uint32 time_diff)
+    bool Update(Unit* u, uint32 time_diff) override
     {
         //u->AssertIsType<T>();
         return (static_cast<D*>(this))->DoUpdate(static_cast<T*>(u), time_diff);

src/server/game/Movement/MovementGenerators/IdleMovementGenerator.h

@@ -13,11 +13,11 @@ class IdleMovementGenerator : public MovementGenerator
 {
 public:
 
-    void Initialize(Unit*);
-    void Finalize(Unit*) {  }
-    void Reset(Unit*);
-    bool Update(Unit*, uint32) { return true; }
-    MovementGeneratorType GetMovementGeneratorType() { return IDLE_MOTION_TYPE; }
+    void Initialize(Unit*) override;
+    void Finalize(Unit*) override {  }
+    void Reset(Unit*) override;
+    bool Update(Unit*, uint32) override { return true; }
+    MovementGeneratorType GetMovementGeneratorType() override { return IDLE_MOTION_TYPE; }
 };
 
 extern IdleMovementGenerator si_idleMovement;
@@ -27,11 +27,11 @@ class RotateMovementGenerator : public MovementGenerator
 public:
     explicit RotateMovementGenerator(uint32 time, RotateDirection direction) : m_duration(time), m_maxDuration(time), m_direction(direction) {}
 
-    void Initialize(Unit*);
-    void Finalize(Unit*);
-    void Reset(Unit* owner) { Initialize(owner); }
-    bool Update(Unit*, uint32);
-    MovementGeneratorType GetMovementGeneratorType() { return ROTATE_MOTION_TYPE; }
+    void Initialize(Unit*) override;
+    void Finalize(Unit*) override;
+    void Reset(Unit* owner) override { Initialize(owner); }
+    bool Update(Unit*, uint32) override;
+    MovementGeneratorType GetMovementGeneratorType() override { return ROTATE_MOTION_TYPE; }
 
 private:
     uint32 m_duration, m_maxDuration;
@@ -43,11 +43,11 @@ class DistractMovementGenerator : public MovementGenerator
 public:
     explicit DistractMovementGenerator(uint32 timer) : m_timer(timer) {}
 
-    void Initialize(Unit*);
-    void Finalize(Unit*);
-    void Reset(Unit* owner) { Initialize(owner); }
-    bool Update(Unit*, uint32);
-    MovementGeneratorType GetMovementGeneratorType() { return DISTRACT_MOTION_TYPE; }
+    void Initialize(Unit*) override;
+    void Finalize(Unit*) override;
+    void Reset(Unit* owner) override { Initialize(owner); }
+    bool Update(Unit*, uint32) override;
+    MovementGeneratorType GetMovementGeneratorType() override { return DISTRACT_MOTION_TYPE; }
 
 private:
     uint32 m_timer;
@@ -59,8 +59,8 @@ public:
     AssistanceDistractMovementGenerator(uint32 timer) :
         DistractMovementGenerator(timer) {}
 
-    MovementGeneratorType GetMovementGeneratorType() { return ASSISTANCE_DISTRACT_MOTION_TYPE; }
-    void Finalize(Unit*);
+    MovementGeneratorType GetMovementGeneratorType() override { return ASSISTANCE_DISTRACT_MOTION_TYPE; }
+    void Finalize(Unit*) override;
 };
 
 #endif

src/server/game/Movement/MovementGenerators/PointMovementGenerator.h

@@ -59,11 +59,11 @@ class EffectMovementGenerator : public MovementGenerator
 {
 public:
     explicit EffectMovementGenerator(uint32 Id) : m_Id(Id) {}
-    void Initialize(Unit*) {}
-    void Finalize(Unit*);
-    void Reset(Unit*) {}
-    bool Update(Unit*, uint32);
-    MovementGeneratorType GetMovementGeneratorType() { return EFFECT_MOTION_TYPE; }
+    void Initialize(Unit*) override {}
+    void Finalize(Unit*) override;
+    void Reset(Unit*) override {}
+    bool Update(Unit*, uint32) override;
+    MovementGeneratorType GetMovementGeneratorType() override { return EFFECT_MOTION_TYPE; }
 private:
     uint32 m_Id;
 };

src/server/game/OutdoorPvP/OutdoorPvP.h

@@ -185,7 +185,7 @@ public:
     OutdoorPvP();
 
     // dtor
-    virtual ~OutdoorPvP();
+    ~OutdoorPvP() override;
 
     // deletes all gos/creatures spawned by the pvp
     void DeleteSpawns();
@@ -206,9 +206,9 @@ public:
     // setup stuff
     virtual bool SetupOutdoorPvP() {return true;}
 
-    void OnGameObjectCreate(GameObject* go);
-    void OnGameObjectRemove(GameObject* go);
-    void OnCreatureCreate(Creature*) {}
+    void OnGameObjectCreate(GameObject* go) override;
+    void OnGameObjectRemove(GameObject* go) override;
+    void OnCreatureCreate(Creature*) override {}
 
     // send world state update to all players present
     void SendUpdateWorldState(uint32 field, uint32 value);

src/server/game/Scripting/ScriptMgr.h

@@ -194,7 +194,7 @@ protected:
 
 public:
 
-    bool IsDatabaseBound() const { return true; }
+    bool IsDatabaseBound() const override { return true; }
 
     // Should return a fully valid SpellScript pointer.
     virtual SpellScript* GetSpellScript() const { return nullptr; }
@@ -348,7 +348,7 @@ public:
     virtual void OnPlayerLeave(TMap* /*map*/, Player* /*player*/) { }
 
     // Called on every map update tick.
-    virtual void OnUpdate(TMap* /*map*/, uint32 /*diff*/) { }
+    void OnUpdate(TMap* /*map*/, uint32 /*diff*/) override { }
 };
 
 class WorldMapScript : public ScriptObject, public MapScript<Map>
@@ -359,9 +359,9 @@ protected:
 
 public:
 
-    bool isAfterLoadScript() const { return true; }
+    bool isAfterLoadScript() const override { return true; }
 
-    void checkValidity()
+    void checkValidity() override
     {
         checkMap();
 
@@ -378,9 +378,9 @@ protected:
 
 public:
 
-    bool IsDatabaseBound() const { return true; }
+    bool IsDatabaseBound() const override { return true; }
 
-    void checkValidity()
+    void checkValidity() override
     {
         checkMap();
 
@@ -400,9 +400,9 @@ protected:
 
 public:
 
-    bool isAfterLoadScript() const { return true; }
+    bool isAfterLoadScript() const override { return true; }
 
-    void checkValidity()
+    void checkValidity() override
     {
         checkMap();
 
@@ -419,7 +419,7 @@ protected:
 
 public:
 
-    bool IsDatabaseBound() const { return true; }
+    bool IsDatabaseBound() const override { return true; }
 
     // Called when a player accepts a quest from the item.
     virtual bool OnQuestAccept(Player* /*player*/, Item* /*item*/, Quest const* /*quest*/) { return false; }
@@ -525,7 +525,7 @@ protected:
 
 public:
 
-    bool IsDatabaseBound() const { return true; }
+    bool IsDatabaseBound() const override { return true; }
 
     // Called when a player opens a gossip dialog with the creature.
     virtual bool OnGossipHello(Player* /*player*/, Creature* /*creature*/) { return false; }
@@ -563,7 +563,7 @@ protected:
 
 public:
 
-    bool IsDatabaseBound() const { return true; }
+    bool IsDatabaseBound() const override { return true; }
 
     // Called when a player opens a gossip dialog with the gameobject.
     virtual bool OnGossipHello(Player* /*player*/, GameObject* /*go*/) { return false; }
@@ -607,7 +607,7 @@ protected:
 
 public:
 
-    bool IsDatabaseBound() const { return true; }
+    bool IsDatabaseBound() const override { return true; }
 
     // Called when the area trigger is activated by a player.
     virtual bool OnTrigger(Player* /*player*/, AreaTrigger const* /*trigger*/) { return false; }
@@ -621,7 +621,7 @@ protected:
 
 public:
 
-    bool IsDatabaseBound() const { return true; }
+    bool IsDatabaseBound() const override { return true; }
 
     // Should return a fully valid Battleground object for the type ID.
     virtual Battleground* GetBattleground() const = 0;
@@ -636,7 +636,7 @@ protected:
 
 public:
 
-    bool IsDatabaseBound() const { return true; }
+    bool IsDatabaseBound() const override { return true; }
 
     // Should return a fully valid OutdoorPvP object for the type ID.
     virtual OutdoorPvP* GetOutdoorPvP() const = 0;
@@ -662,7 +662,7 @@ protected:
 
 public:
 
-    bool IsDatabaseBound() const { return true; }
+    bool IsDatabaseBound() const override { return true; }
 
     // Called when the weather changes in the zone this script is associated with.
     virtual void OnChange(Weather* /*weather*/, WeatherState /*state*/, float /*grade*/) { }
@@ -718,7 +718,7 @@ protected:
 
 public:
 
-    bool IsDatabaseBound() const { return true; }
+    bool IsDatabaseBound() const override { return true; }
 
     // Called when a single condition is checked for a player.
     virtual bool OnConditionCheck(Condition* /*condition*/, ConditionSourceInfo& /*sourceInfo*/) { return true; }
@@ -766,7 +766,7 @@ protected:
 
 public:
 
-    bool IsDatabaseBound() const { return true; }
+    bool IsDatabaseBound() const override { return true; }
 
     // Called when a player boards the transport.
     virtual void OnAddPassenger(Transport* /*transport*/, Player* /*player*/) { }
@@ -789,7 +789,7 @@ protected:
 
 public:
 
-    bool IsDatabaseBound() const { return true; }
+    bool IsDatabaseBound() const override { return true; }
 
     // deprecated/legacy
     virtual bool OnCheck(Player* /*source*/, Unit* /*target*/) { return true; };
@@ -1050,7 +1050,7 @@ protected:
 
 public:
 
-    bool IsDatabaseBound() const { return false; }
+    bool IsDatabaseBound() const override { return false; }
 
     // Called when a member is added to the guild.
     virtual void OnAddMember(Guild* /*guild*/, Player* /*player*/, uint8& /*plRank*/) { }
@@ -1093,7 +1093,7 @@ protected:
 
 public:
 
-    bool IsDatabaseBound() const { return false; }
+    bool IsDatabaseBound() const override { return false; }
 
     // Called when a member is added to a group.
     virtual void OnAddMember(Group* /*group*/, uint64 /*guid*/) { }
@@ -1150,7 +1150,7 @@ protected:
 
 public:
 
-    bool IsDatabaseBound() const { return false; }
+    bool IsDatabaseBound() const override { return false; }
 
     // Start Battlegroud
     virtual void OnBattlegroundStart(Battleground* /*bg*/) { }
@@ -1188,7 +1188,7 @@ protected:
     ArenaTeamScript(const char* name);
 
 public:
-    bool IsDatabaseBound() const { return false; };
+    bool IsDatabaseBound() const override { return false; };
 
     virtual void OnGetSlotByType(const uint32 /*type*/, uint8& /*slot*/) {}
     virtual void OnGetArenaPoints(ArenaTeam* /*team*/, float& /*points*/) {}
@@ -1205,7 +1205,7 @@ protected:
 
 public:
 
-    bool IsDatabaseBound() const { return false; }
+    bool IsDatabaseBound() const override { return false; }
 
     // Calculate max duration in applying aura
     virtual void OnCalcMaxDuration(Aura const* /*aura*/, int32& /*maxDuration*/) { }

src/server/game/Server/WorldSession.h

@@ -133,11 +133,11 @@ class MapSessionFilter : public PacketFilter
 {
 public:
     explicit MapSessionFilter(WorldSession* pSession) : PacketFilter(pSession) {}
-    ~MapSessionFilter() {}
+    ~MapSessionFilter() override {}
 
-    virtual bool Process(WorldPacket* packet);
+    bool Process(WorldPacket* packet) override;
     //in Map::Update() we do not process player logout!
-    virtual bool ProcessLogout() const { return false; }
+    bool ProcessLogout() const override { return false; }
 };
 
 //class used to filer only thread-unsafe packets from queue
@@ -146,9 +146,9 @@ class WorldSessionFilter : public PacketFilter
 {
 public:
     explicit WorldSessionFilter(WorldSession* pSession) : PacketFilter(pSession) {}
-    ~WorldSessionFilter() {}
+    ~WorldSessionFilter() override {}
 
-    virtual bool Process(WorldPacket* packet);
+    bool Process(WorldPacket* packet) override;
 };
 
 // Proxy structure to contain data passed to callback function,

src/server/game/Server/WorldSocketMgr.cpp

@@ -68,7 +68,7 @@ public:
         m_Reactor = new ACE_Reactor (imp, 1);
     }
 
-    virtual ~ReactorRunnable()
+    ~ReactorRunnable() override
     {
         Stop();
         Wait();
@@ -142,7 +142,7 @@ protected:
         m_NewSockets.clear();
     }
 
-    virtual int svc()
+    int svc() override
     {
 #if defined(ENABLE_EXTRAS) && defined(ENABLE_EXTRA_LOGS)
         sLog->outStaticDebug ("Network Thread Starting");

src/server/game/Spells/Auras/SpellAuras.h

@@ -262,12 +262,12 @@ class UnitAura : public Aura
 protected:
     explicit UnitAura(SpellInfo const* spellproto, uint8 effMask, WorldObject* owner, Unit* caster, int32* baseAmount, Item* castItem, uint64 casterGUID);
 public:
-    void _ApplyForTarget(Unit* target, Unit* caster, AuraApplication* aurApp);
-    void _UnapplyForTarget(Unit* target, Unit* caster, AuraApplication* aurApp);
+    void _ApplyForTarget(Unit* target, Unit* caster, AuraApplication* aurApp) override;
+    void _UnapplyForTarget(Unit* target, Unit* caster, AuraApplication* aurApp) override;
 
-    void Remove(AuraRemoveMode removeMode = AURA_REMOVE_BY_DEFAULT);
+    void Remove(AuraRemoveMode removeMode = AURA_REMOVE_BY_DEFAULT) override;
 
-    void FillTargetMap(std::map<Unit*, uint8>& targets, Unit* caster);
+    void FillTargetMap(std::map<Unit*, uint8>& targets, Unit* caster) override;
 
     // Allow Apply Aura Handler to modify and access m_AuraDRGroup
     void SetDiminishGroup(DiminishingGroup group) { m_AuraDRGroup = group; }
@@ -283,8 +283,8 @@ class DynObjAura : public Aura
 protected:
     explicit DynObjAura(SpellInfo const* spellproto, uint8 effMask, WorldObject* owner, Unit* caster, int32* baseAmount, Item* castItem, uint64 casterGUID);
 public:
-    void Remove(AuraRemoveMode removeMode = AURA_REMOVE_BY_DEFAULT);
+    void Remove(AuraRemoveMode removeMode = AURA_REMOVE_BY_DEFAULT) override;
 
-    void FillTargetMap(std::map<Unit*, uint8>& targets, Unit* caster);
+    void FillTargetMap(std::map<Unit*, uint8>& targets, Unit* caster) override;
 };
 #endif

src/server/game/Spells/Spell.h

@@ -789,11 +789,11 @@ class SpellEvent : public BasicEvent
 {
 public:
     SpellEvent(Spell* spell);
-    virtual ~SpellEvent();
+    ~SpellEvent() override;
 
-    virtual bool Execute(uint64 e_time, uint32 p_time);
-    virtual void Abort(uint64 e_time);
-    virtual bool IsDeletable() const;
+    bool Execute(uint64 e_time, uint32 p_time) override;
+    void Abort(uint64 e_time) override;
+    bool IsDeletable() const override;
 protected:
     Spell* m_Spell;
 };
@@ -802,7 +802,7 @@ class ReflectEvent : public BasicEvent
 {
 public:
     ReflectEvent(uint64 casterGUID, uint64 targetGUID, const SpellInfo* spellInfo) : _casterGUID(casterGUID), _targetGUID(targetGUID), _spellInfo(spellInfo) { }
-    virtual bool Execute(uint64 e_time, uint32 p_time);
+    bool Execute(uint64 e_time, uint32 p_time) override;
 
 protected:
     uint64 _casterGUID;

src/server/game/Spells/SpellScript.h

@@ -176,7 +176,7 @@ public:
     public:
         EffectHandler(SpellEffectFnType _pEffectHandlerScript, uint8 _effIndex, uint16 _effName);
         std::string ToString();
-        bool CheckEffect(SpellInfo const* spellEntry, uint8 effIndex);
+        bool CheckEffect(SpellInfo const* spellEntry, uint8 effIndex) override;
         void Call(SpellScript* spellScript, SpellEffIndex effIndex);
     private:
         SpellEffectFnType pEffectHandlerScript;
@@ -195,7 +195,7 @@ public:
     {
     public:
         TargetHook(uint8 _effectIndex, uint16 _targetType, bool _area, bool _dest);
-        bool CheckEffect(SpellInfo const* spellInfo, uint8 effIndex);
+        bool CheckEffect(SpellInfo const* spellInfo, uint8 effIndex) override;
         std::string ToString();
         uint16 GetTarget() const { return targetType; }
     protected:
@@ -242,7 +242,7 @@ public:
 
 #define PrepareSpellScript(CLASSNAME) SPELLSCRIPT_FUNCTION_TYPE_DEFINES(CLASSNAME) SPELLSCRIPT_FUNCTION_CAST_DEFINES(CLASSNAME)
 public:
-    bool _Validate(SpellInfo const* entry);
+    bool _Validate(SpellInfo const* entry) override;
     bool _Load(Spell* spell);
     void _InitHit();
     bool _IsEffectPrevented(SpellEffIndex effIndex) { return m_hitPreventEffectMask & (1 << effIndex); }
@@ -500,7 +500,7 @@ public:
     public:
         EffectBase(uint8 _effIndex, uint16 _effName);
         std::string ToString();
-        bool CheckEffect(SpellInfo const* spellEntry, uint8 effIndex);
+        bool CheckEffect(SpellInfo const* spellEntry, uint8 effIndex) override;
     };
     class EffectPeriodicHandler : public EffectBase
     {
@@ -621,7 +621,7 @@ public:
 public:
     AuraScript() : _SpellScript(), m_aura(nullptr), m_auraApplication(nullptr), m_defaultActionPrevented(false)
     {}
-    bool _Validate(SpellInfo const* entry);
+    bool _Validate(SpellInfo const* entry) override;
     bool _Load(Aura* aura);
     void _PrepareScriptCall(AuraScriptHookType hookType, AuraApplication const* aurApp = nullptr);
     void _FinishScriptCall();

src/server/game/Warden/WardenMac.h

@@ -20,15 +20,15 @@ class WardenMac : public Warden
 {
 public:
     WardenMac();
-    ~WardenMac();
+    ~WardenMac() override;
 
-    void Init(WorldSession* session, BigNumber* k);
-    ClientWardenModule* GetModuleForClient();
-    void InitializeModule();
-    void RequestHash();
-    void HandleHashResult(ByteBuffer& buff);
-    void RequestData();
-    void HandleData(ByteBuffer& buff);
+    void Init(WorldSession* session, BigNumber* k) override;
+    ClientWardenModule* GetModuleForClient() override;
+    void InitializeModule() override;
+    void RequestHash() override;
+    void HandleHashResult(ByteBuffer& buff) override;
+    void RequestData() override;
+    void HandleData(ByteBuffer& buff) override;
 };
 
 #endif

src/server/game/Warden/WardenWin.h

@@ -62,15 +62,15 @@ class WardenWin : public Warden
 {
 public:
     WardenWin();
-    ~WardenWin();
+    ~WardenWin() override;
 
-    void Init(WorldSession* session, BigNumber* K);
-    ClientWardenModule* GetModuleForClient();
-    void InitializeModule();
-    void RequestHash();
-    void HandleHashResult(ByteBuffer& buff);
-    void RequestData();
-    void HandleData(ByteBuffer& buff);
+    void Init(WorldSession* session, BigNumber* K) override;
+    ClientWardenModule* GetModuleForClient() override;
+    void InitializeModule() override;
+    void RequestHash() override;
+    void HandleHashResult(ByteBuffer& buff) override;
+    void RequestData() override;
+    void HandleData(ByteBuffer& buff) override;
 
 private:
     uint32 _serverTicks;

src/server/scripts/EasternKingdoms/AlteracValley/alterac_valley.cpp

@@ -75,7 +75,7 @@ public:
     {
         npc_av_marshal_or_warmasterAI(Creature* creature) : ScriptedAI(creature) { }
 
-        void Reset()
+        void Reset() override
         {
             events.Reset();
             events.ScheduleEvent(EVENT_CHARGE_TARGET, urand(2 * IN_MILLISECONDS, 12 * IN_MILLISECONDS));
@@ -88,12 +88,12 @@ public:
             _hasAura = false;
         }
 
-        void JustRespawned()
+        void JustRespawned() override
         {
             Reset();
         }
 
-        void UpdateAI(uint32 diff)
+        void UpdateAI(uint32 diff) override
         {
             // I have a feeling this isn't blizzlike, but owell, I'm only passing by and cleaning up.
             if (!_hasAura)
@@ -159,7 +159,7 @@ public:
         bool _hasAura;
     };
 
-    CreatureAI* GetAI(Creature* creature) const
+    CreatureAI* GetAI(Creature* creature) const override
     {
         return new npc_av_marshal_or_warmasterAI(creature);
     }

src/server/scripts/EasternKingdoms/AlteracValley/boss_balinda.cpp

@@ -45,14 +45,14 @@ public:
         uint64 balindaGUID;
         uint32 resetTimer;
 
-        void Reset()
+        void Reset() override
         {
             waterBoltTimer            = 3 * IN_MILLISECONDS;
             resetTimer                = 5 * IN_MILLISECONDS;
             balindaGUID = 0;
         }
 
-        void UpdateAI(uint32 diff)
+        void UpdateAI(uint32 diff) override
         {
             if (!UpdateVictim())
                 return;
@@ -78,7 +78,7 @@ public:
         }
     };
 
-    CreatureAI* GetAI(Creature* creature) const
+    CreatureAI* GetAI(Creature* creature) const override
     {
         return new npc_water_elementalAI(creature);
     }
@@ -102,7 +102,7 @@ public:
 
         SummonList summons;
 
-        void Reset()
+        void Reset() override
         {
             arcaneExplosionTimer      = urand(5 * IN_MILLISECONDS, 15 * IN_MILLISECONDS);
             coneOfColdTimer           = 8 * IN_MILLISECONDS;
@@ -114,17 +114,17 @@ public:
             summons.DespawnAll();
         }
 
-        void EnterCombat(Unit* /*who*/)
+        void EnterCombat(Unit* /*who*/) override
         {
             Talk(YELL_AGGRO);
         }
 
-        void JustRespawned()
+        void JustRespawned() override
         {
             Reset();
         }
 
-        void JustSummoned(Creature* summoned)
+        void JustSummoned(Creature* summoned) override
         {
             CAST_AI(npc_water_elemental::npc_water_elementalAI, summoned->AI())->balindaGUID = me->GetGUID();
             summoned->AI()->AttackStart(SelectTarget(SELECT_TARGET_RANDOM, 0, 50, true));
@@ -132,12 +132,12 @@ public:
             summons.Summon(summoned);
         }
 
-        void JustDied(Unit* /*killer*/)
+        void JustDied(Unit* /*killer*/) override
         {
             summons.DespawnAll();
         }
 
-        void UpdateAI(uint32 diff)
+        void UpdateAI(uint32 diff) override
         {
             if (!UpdateVictim())
                 return;
@@ -194,7 +194,7 @@ public:
         }
     };
 
-    CreatureAI* GetAI(Creature* creature) const
+    CreatureAI* GetAI(Creature* creature) const override
     {
         return new boss_balindaAI(creature);
     }

src/server/scripts/EasternKingdoms/AlteracValley/boss_drekthar.cpp

@@ -43,7 +43,7 @@ public:
         uint32 YellTimer;
         uint32 ResetTimer;
 
-        void Reset()
+        void Reset() override
         {
             WhirlwindTimer    = urand(1 * IN_MILLISECONDS, 20 * IN_MILLISECONDS);
             Whirlwind2Timer   = urand(1 * IN_MILLISECONDS, 20 * IN_MILLISECONDS);
@@ -53,18 +53,18 @@ public:
             YellTimer         = urand(20 * IN_MILLISECONDS, 30 * IN_MILLISECONDS); //20 to 30 seconds
         }
 
-        void EnterCombat(Unit* /*who*/)
+        void EnterCombat(Unit* /*who*/) override
         {
             Talk(YELL_AGGRO);
         }
 
-        void JustRespawned()
+        void JustRespawned() override
         {
             Reset();
             Talk(YELL_RESPAWN);
         }
 
-        void UpdateAI(uint32 diff)
+        void UpdateAI(uint32 diff) override
         {
             if (!UpdateVictim())
                 return;
@@ -120,7 +120,7 @@ public:
         }
     };
 
-    CreatureAI* GetAI(Creature* creature) const
+    CreatureAI* GetAI(Creature* creature) const override
     {
         return new boss_drektharAI(creature);
     }

src/server/scripts/EasternKingdoms/AlteracValley/boss_galvangar.cpp

@@ -38,7 +38,7 @@ public:
         uint32 MortalStrikeTimer;
         uint32 ResetTimer;
 
-        void Reset()
+        void Reset() override
         {
             CleaveTimer                     = urand(1 * IN_MILLISECONDS, 9 * IN_MILLISECONDS);
             FrighteningShoutTimer           = urand(2 * IN_MILLISECONDS, 19 * IN_MILLISECONDS);
@@ -48,17 +48,17 @@ public:
             ResetTimer                      = 5 * IN_MILLISECONDS;
         }
 
-        void EnterCombat(Unit* /*who*/)
+        void EnterCombat(Unit* /*who*/) override
         {
             Talk(YELL_AGGRO);
         }
 
-        void JustRespawned()
+        void JustRespawned() override
         {
             Reset();
         }
 
-        void UpdateAI(uint32 diff)
+        void UpdateAI(uint32 diff) override
         {
             if (!UpdateVictim())
                 return;
@@ -114,7 +114,7 @@ public:
         }
     };
 
-    CreatureAI* GetAI(Creature* creature) const
+    CreatureAI* GetAI(Creature* creature) const override
     {
         return new boss_galvangarAI(creature);
     }

src/server/scripts/EasternKingdoms/AlteracValley/boss_vanndar.cpp

@@ -39,7 +39,7 @@ public:
         uint32 ResetTimer;
         uint32 YellTimer;
 
-        void Reset()
+        void Reset() override
         {
             AvatarTimer        = 3 * IN_MILLISECONDS;
             ThunderclapTimer   = 4 * IN_MILLISECONDS;
@@ -48,12 +48,12 @@ public:
             YellTimer = urand(20 * IN_MILLISECONDS, 30 * IN_MILLISECONDS);
         }
 
-        void EnterCombat(Unit* /*who*/)
+        void EnterCombat(Unit* /*who*/) override
         {
             Talk(YELL_AGGRO);
         }
 
-        void UpdateAI(uint32 diff)
+        void UpdateAI(uint32 diff) override
         {
             if (!UpdateVictim())
                 return;
@@ -102,7 +102,7 @@ public:
         }
     };
 
-    CreatureAI* GetAI(Creature* creature) const
+    CreatureAI* GetAI(Creature* creature) const override
     {
         return new boss_vanndarAI(creature);
     }

src/server/scripts/EasternKingdoms/BlackrockMountain/BlackrockDepths/blackrock_depths.cpp

@@ -100,7 +100,7 @@ class at_ring_of_law : public AreaTriggerScript
 public:
     at_ring_of_law() : AreaTriggerScript("at_ring_of_law") { }
 
-    bool OnTrigger(Player* player, const AreaTrigger* /*at*/)
+    bool OnTrigger(Player* player, const AreaTrigger* /*at*/) override
     {
         if (InstanceScript* instance = player->GetInstanceScript())
         {
@@ -132,7 +132,7 @@ class npc_grimstone : public CreatureScript
 public:
     npc_grimstone() : CreatureScript("npc_grimstone") { }
 
-    CreatureAI* GetAI(Creature* creature) const
+    CreatureAI* GetAI(Creature* creature) const override
     {
         return GetInstanceAI<npc_grimstoneAI>(creature);
     }
@@ -157,19 +157,19 @@ public:
         uint8 MobSpawnId;
         bool theldrenEvent;
 
-        void Reset()
+        void Reset() override
         {
             me->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE);
         }
 
-        void JustSummoned(Creature* summon)
+        void JustSummoned(Creature* summon) override
         {
             summons.Summon(summon);
             if (Unit* target = SelectTargetFromPlayerList(100.0f))
                 summon->AI()->AttackStart(target);
         }
 
-        void SummonedCreatureDies(Creature* summon, Unit*)
+        void SummonedCreatureDies(Creature* summon, Unit*) override
         {
             summons.Despawn(summon);
             // All Summons killed, next phase
@@ -177,7 +177,7 @@ public:
                 eventTimer = 5000;
         }
 
-        void WaypointReached(uint32 waypointId)
+        void WaypointReached(uint32 waypointId) override
         {
             switch (waypointId)
             {
@@ -231,7 +231,7 @@ public:
                 me->SummonCreature(RingBoss[rand() % 6], 644.300f, -175.989f, -53.739f, 3.418f, TEMPSUMMON_DEAD_DESPAWN, 0);
         }
 
-        void UpdateEscortAI(uint32 diff)
+        void UpdateEscortAI(uint32 diff) override
         {
             if (!instance)
                 return;
@@ -329,7 +329,7 @@ class npc_phalanx : public CreatureScript
 public:
     npc_phalanx() : CreatureScript("npc_phalanx") { }
 
-    CreatureAI* GetAI(Creature* creature) const
+    CreatureAI* GetAI(Creature* creature) const override
     {
         return new npc_phalanxAI(creature);
     }
@@ -342,14 +342,14 @@ public:
         uint32 FireballVolley_Timer;
         uint32 MightyBlow_Timer;
 
-        void Reset()
+        void Reset() override
         {
             ThunderClap_Timer = 12000;
             FireballVolley_Timer = 0;
             MightyBlow_Timer = 15000;
         }
 
-        void UpdateAI(uint32 diff)
+        void UpdateAI(uint32 diff) override
         {
             //Return since we have no target
             if (!UpdateVictim())
@@ -1091,7 +1091,7 @@ class npc_rocknot : public CreatureScript
 public:
     npc_rocknot() : CreatureScript("npc_rocknot") { }
 
-    bool OnQuestReward(Player* /*player*/, Creature* creature, Quest const* quest, uint32 /*item*/)
+    bool OnQuestReward(Player* /*player*/, Creature* creature, Quest const* quest, uint32 /*item*/) override
     {
         InstanceScript* instance = creature->GetInstanceScript();
         if (!instance)
@@ -1121,7 +1121,7 @@ public:
         return true;
     }
 
-    CreatureAI* GetAI(Creature* creature) const
+    CreatureAI* GetAI(Creature* creature) const override
     {
         return GetInstanceAI<npc_rocknotAI>(creature);
     }
@@ -1138,7 +1138,7 @@ public:
         uint32 BreakKeg_Timer;
         uint32 BreakDoor_Timer;
 
-        void Reset()
+        void Reset() override
         {
             if (HasEscortState(STATE_ESCORT_ESCORTING))
                 return;
@@ -1153,7 +1153,7 @@ public:
                 go->SetGoState((GOState)state);
         }
 
-        void WaypointReached(uint32 waypointId)
+        void WaypointReached(uint32 waypointId) override
         {
             switch (waypointId)
             {
@@ -1176,7 +1176,7 @@ public:
             }
         }
 
-        void UpdateAI(uint32 diff)
+        void UpdateAI(uint32 diff) override
         {
             if (BreakKeg_Timer)
             {

src/server/scripts/EasternKingdoms/BlackrockMountain/BlackrockDepths/boss_ambassador_flamelash.cpp

@@ -45,7 +45,7 @@ class boss_ambassador_flamelash : public CreatureScript
 public:
     boss_ambassador_flamelash() : CreatureScript("boss_ambassador_flamelash") { }
 
-    CreatureAI* GetAI(Creature* creature) const
+    CreatureAI* GetAI(Creature* creature) const override
     {
         return GetInstanceAI<boss_ambassador_flamelashAI>(creature);
     }
@@ -206,7 +206,7 @@ class npc_burning_spirit : public CreatureScript
 public:
     npc_burning_spirit() : CreatureScript("npc_burning_spirit") { }
 
-    CreatureAI* GetAI(Creature* creature) const
+    CreatureAI* GetAI(Creature* creature) const override
     {
         return GetInstanceAI<npc_burning_spiritAI>(creature);
     }

src/server/scripts/EasternKingdoms/BlackrockMountain/BlackrockDepths/boss_anubshiah.cpp

@@ -21,7 +21,7 @@ class boss_anubshiah : public CreatureScript
 public:
     boss_anubshiah() : CreatureScript("boss_anubshiah") { }
 
-    CreatureAI* GetAI(Creature* creature) const
+    CreatureAI* GetAI(Creature* creature) const override
     {
         return new boss_anubshiahAI(creature);
     }
@@ -36,7 +36,7 @@ public:
         uint32 DemonArmor_Timer;
         uint32 EnvelopingWeb_Timer;
 
-        void Reset()
+        void Reset() override
         {
             ShadowBolt_Timer = 7000;
             CurseOfTongues_Timer = 24000;
@@ -45,9 +45,9 @@ public:
             EnvelopingWeb_Timer = 16000;
         }
 
-        void EnterCombat(Unit* /*who*/) { }
+        void EnterCombat(Unit* /*who*/) override { }
 
-        void UpdateAI(uint32 diff)
+        void UpdateAI(uint32 diff) override
         {
             //Return since we have no target
             if (!UpdateVictim())

src/server/scripts/EasternKingdoms/BlackrockMountain/BlackrockDepths/boss_emperor_dagran_thaurissan.cpp

@@ -25,7 +25,7 @@ class boss_emperor_dagran_thaurissan : public CreatureScript
 public:
     boss_emperor_dagran_thaurissan() : CreatureScript("boss_emperor_dagran_thaurissan") { }
 
-    CreatureAI* GetAI(Creature* creature) const
+    CreatureAI* GetAI(Creature* creature) const override
     {
         return GetInstanceAI<boss_draganthaurissanAI>(creature);
     }
@@ -42,25 +42,25 @@ public:
         uint32 AvatarOfFlame_Timer;
         //uint32 Counter;
 
-        void Reset()
+        void Reset() override
         {
             HandOfThaurissan_Timer = 4000;
             AvatarOfFlame_Timer = 25000;
             //Counter= 0;
         }
 
-        void EnterCombat(Unit* /*who*/)
+        void EnterCombat(Unit* /*who*/) override
         {
             Talk(SAY_AGGRO);
             me->CallForHelp(VISIBLE_RANGE);
         }
 
-        void KilledUnit(Unit* /*victim*/)
+        void KilledUnit(Unit* /*victim*/) override
         {
             Talk(SAY_SLAY);
         }
 
-        void JustDied(Unit* /*killer*/)
+        void JustDied(Unit* /*killer*/) override
         {
             if (Creature* Moira = ObjectAccessor::GetCreature(*me, instance->GetData64(DATA_MOIRA)))
             {
@@ -69,7 +69,7 @@ public:
             }
         }
 
-        void UpdateAI(uint32 diff)
+        void UpdateAI(uint32 diff) override
         {
             //Return since we have no target
             if (!UpdateVictim())

src/server/scripts/EasternKingdoms/BlackrockMountain/BlackrockDepths/boss_general_angerforge.cpp

@@ -19,7 +19,7 @@ class boss_general_angerforge : public CreatureScript
 public:
     boss_general_angerforge() : CreatureScript("boss_general_angerforge") { }
 
-    CreatureAI* GetAI(Creature* creature) const
+    CreatureAI* GetAI(Creature* creature) const override
     {
         return new boss_general_angerforgeAI(creature);
     }
@@ -34,7 +34,7 @@ public:
         uint32 Adds_Timer;
         bool Medics;
 
-        void Reset()
+        void Reset() override
         {
             MightyBlow_Timer = 8000;
             HamString_Timer = 12000;
@@ -43,7 +43,7 @@ public:
             Medics = false;
         }
 
-        void EnterCombat(Unit* /*who*/) { }
+        void EnterCombat(Unit* /*who*/) override { }
 
         void SummonAdds(Unit* victim)
         {
@@ -57,7 +57,7 @@ public:
                 SummonedMedic->AI()->AttackStart(victim);
         }
 
-        void UpdateAI(uint32 diff)
+        void UpdateAI(uint32 diff) override
         {
             //Return since we have no target
             if (!UpdateVictim())

src/server/scripts/EasternKingdoms/BlackrockMountain/BlackrockDepths/boss_gorosh_the_dervish.cpp

@@ -18,7 +18,7 @@ class boss_gorosh_the_dervish : public CreatureScript
 public:
     boss_gorosh_the_dervish() : CreatureScript("boss_gorosh_the_dervish") { }
 
-    CreatureAI* GetAI(Creature* creature) const
+    CreatureAI* GetAI(Creature* creature) const override
     {
         return new boss_gorosh_the_dervishAI(creature);
     }
@@ -30,17 +30,17 @@ public:
         uint32 WhirlWind_Timer;
         uint32 MortalStrike_Timer;
 
-        void Reset()
+        void Reset() override
         {
             WhirlWind_Timer = 12000;
             MortalStrike_Timer = 22000;
         }
 
-        void EnterCombat(Unit* /*who*/)
+        void EnterCombat(Unit* /*who*/) override
         {
         }
 
-        void UpdateAI(uint32 diff)
+        void UpdateAI(uint32 diff) override
         {
             //Return since we have no target
             if (!UpdateVictim())

src/server/scripts/EasternKingdoms/BlackrockMountain/BlackrockDepths/boss_grizzle.cpp

@@ -19,7 +19,7 @@ class boss_grizzle : public CreatureScript
 public:
     boss_grizzle() : CreatureScript("boss_grizzle") { }
 
-    CreatureAI* GetAI(Creature* creature) const
+    CreatureAI* GetAI(Creature* creature) const override
     {
         return new boss_grizzleAI(creature);
     }
@@ -31,15 +31,15 @@ public:
         uint32 GroundTremor_Timer;
         uint32 Frenzy_Timer;
 
-        void Reset()
+        void Reset() override
         {
             GroundTremor_Timer = 12000;
             Frenzy_Timer = 0;
         }
 
-        void EnterCombat(Unit* /*who*/) { }
+        void EnterCombat(Unit* /*who*/) override { }
 
-        void UpdateAI(uint32 diff)
+        void UpdateAI(uint32 diff) override
         {
             //Return since we have no target
             if (!UpdateVictim())

src/server/scripts/EasternKingdoms/BlackrockMountain/BlackrockDepths/boss_high_interrogator_gerstahn.cpp

@@ -20,7 +20,7 @@ class boss_high_interrogator_gerstahn : public CreatureScript
 public:
     boss_high_interrogator_gerstahn() : CreatureScript("boss_high_interrogator_gerstahn") { }
 
-    CreatureAI* GetAI(Creature* creature) const
+    CreatureAI* GetAI(Creature* creature) const override
     {
         return new boss_high_interrogator_gerstahnAI(creature);
     }
@@ -34,7 +34,7 @@ public:
         uint32 PsychicScream_Timer;
         uint32 ShadowShield_Timer;
 
-        void Reset()
+        void Reset() override
         {
             ShadowWordPain_Timer = 4000;
             ManaBurn_Timer = 14000;
@@ -42,9 +42,9 @@ public:
             ShadowShield_Timer = 8000;
         }
 
-        void EnterCombat(Unit* /*who*/) { }
+        void EnterCombat(Unit* /*who*/) override { }
 
-        void UpdateAI(uint32 diff)
+        void UpdateAI(uint32 diff) override
         {
             //Return since we have no target
             if (!UpdateVictim())

src/server/scripts/EasternKingdoms/BlackrockMountain/BlackrockDepths/boss_magmus.cpp

@@ -23,7 +23,7 @@ class boss_magmus : public CreatureScript
 public:
     boss_magmus() : CreatureScript("boss_magmus") { }
 
-    CreatureAI* GetAI(Creature* creature) const
+    CreatureAI* GetAI(Creature* creature) const override
     {
         return new boss_magmusAI(creature);
     }
@@ -35,15 +35,15 @@ public:
         uint32 FieryBurst_Timer;
         uint32 WarStomp_Timer;
 
-        void Reset()
+        void Reset() override
         {
             FieryBurst_Timer = 5000;
             WarStomp_Timer = 0;
         }
 
-        void EnterCombat(Unit* /*who*/) { }
+        void EnterCombat(Unit* /*who*/) override { }
 
-        void UpdateAI(uint32 diff)
+        void UpdateAI(uint32 diff) override
         {
             //Return since we have no target
             if (!UpdateVictim())
@@ -71,7 +71,7 @@ public:
             DoMeleeAttackIfReady();
         }
         // When he die open door to last chamber
-        void JustDied(Unit* killer)
+        void JustDied(Unit* killer) override
         {
             if (InstanceScript* instance = killer->GetInstanceScript())
                 instance->HandleGameObject(instance->GetData64(DATA_THRONE_DOOR), true);

src/server/scripts/EasternKingdoms/BlackrockMountain/BlackrockDepths/boss_moira_bronzebeard.cpp

@@ -22,7 +22,7 @@ class boss_moira_bronzebeard : public CreatureScript
 public:
     boss_moira_bronzebeard() : CreatureScript("boss_moira_bronzebeard") { }
 
-    CreatureAI* GetAI(Creature* creature) const
+    CreatureAI* GetAI(Creature* creature) const override
     {
         return new boss_moira_bronzebeardAI(creature);
     }
@@ -36,7 +36,7 @@ public:
         uint32 ShadowWordPain_Timer;
         uint32 Smite_Timer;
 
-        void Reset()
+        void Reset() override
         {
             Heal_Timer = 12000;                                 //These times are probably wrong
             MindBlast_Timer = 16000;
@@ -44,9 +44,9 @@ public:
             Smite_Timer = 8000;
         }
 
-        void EnterCombat(Unit* /*who*/) { }
+        void EnterCombat(Unit* /*who*/) override { }
 
-        void UpdateAI(uint32 diff)
+        void UpdateAI(uint32 diff) override
         {
             //Return since we have no target
             if (!UpdateVictim())

src/server/scripts/EasternKingdoms/BlackrockMountain/BlackrockDepths/instance_blackrock_depths.cpp

@@ -59,7 +59,7 @@ class instance_blackrock_depths : public InstanceMapScript
 public:
     instance_blackrock_depths() : InstanceMapScript("instance_blackrock_depths", 230) { }
 
-    InstanceScript* GetInstanceScript(InstanceMap* map) const
+    InstanceScript* GetInstanceScript(InstanceMap* map) const override
     {
         return new instance_blackrock_depths_InstanceMapScript(map);
     }
@@ -106,7 +106,7 @@ public:
         uint32 TombEventCounter;
         uint32 OpenedCoofers;
 
-        void Initialize()
+        void Initialize() override
         {
             memset(&encounter, 0, sizeof(encounter));
 
@@ -148,7 +148,7 @@ public:
                 TombBossGUIDs[i] = 0;
         }
 
-        void OnCreatureCreate(Creature* creature)
+        void OnCreatureCreate(Creature* creature) override
         {
             switch (creature->GetEntry())
             {
@@ -190,7 +190,7 @@ public:
             }
         }
 
-        void OnGameObjectCreate(GameObject* go)
+        void OnGameObjectCreate(GameObject* go) override
         {
             switch (go->GetEntry())
             {
@@ -264,7 +264,7 @@ public:
             }
         }
 
-        void SetData64(uint32 type, uint64 data)
+        void SetData64(uint32 type, uint64 data) override
         {
 #if defined(ENABLE_EXTRAS) && defined(ENABLE_EXTRA_LOGS)
             sLog->outDebug(LOG_FILTER_TSCR, "TSCR: Instance Blackrock Depths: SetData64 update (Type: %u Data " UI64FMTD ")", type, data);
@@ -282,7 +282,7 @@ public:
             }
         }
 
-        void SetData(uint32 type, uint32 data)
+        void SetData(uint32 type, uint32 data) override
         {
 #if defined(ENABLE_EXTRAS) && defined(ENABLE_EXTRA_LOGS)
             sLog->outDebug(LOG_FILTER_TSCR, "TSCR: Instance Blackrock Depths: SetData update (Type: %u Data %u)", type, data);
@@ -340,7 +340,7 @@ public:
             }
         }
 
-        uint32 GetData(uint32 type) const
+        uint32 GetData(uint32 type) const override
         {
             switch (type)
             {
@@ -365,7 +365,7 @@ public:
             return 0;
         }
 
-        uint64 GetData64(uint32 data) const
+        uint64 GetData64(uint32 data) const override
         {
             switch (data)
             {
@@ -407,12 +407,12 @@ public:
             return 0;
         }
 
-        std::string GetSaveData()
+        std::string GetSaveData() override
         {
             return str_data;
         }
 
-        void Load(const char* in)
+        void Load(const char* in) override
         {
             if (!in)
             {
@@ -495,7 +495,7 @@ public:
             TombEventStarterGUID = 0;
             SetData(TYPE_TOMB_OF_SEVEN, DONE);
         }
-        void Update(uint32 diff)
+        void Update(uint32 diff) override
         {
             if (TombEventStarterGUID && GhostKillCount < 7)
             {

src/server/scripts/EasternKingdoms/BlackrockMountain/BlackrockSpire/boss_drakkisath.cpp

@@ -50,12 +50,12 @@ public:
     {
         boss_drakkisathAI(Creature* creature) : BossAI(creature, DATA_GENERAL_DRAKKISATH) { }
 
-        void Reset()
+        void Reset() override
         {
             _Reset();
         }
 
-        void EnterCombat(Unit* /*who*/)
+        void EnterCombat(Unit* /*who*/) override
         {
             _EnterCombat();
             CallForHelp();
@@ -77,12 +77,12 @@ public:
             }
         }
 
-        void JustDied(Unit* /*killer*/)
+        void JustDied(Unit* /*killer*/) override
         {
             _JustDied();
         }
 
-        void UpdateAI(uint32 diff)
+        void UpdateAI(uint32 diff) override
         {
             if (!UpdateVictim())
                 return;
@@ -118,7 +118,7 @@ public:
         }
     };
 
-    CreatureAI* GetAI(Creature* creature) const
+    CreatureAI* GetAI(Creature* creature) const override
     {
         return new boss_drakkisathAI(creature);
     }
@@ -135,7 +135,7 @@ public:
 
         EventMap _events;
 
-        void EnterCombat(Unit* who)
+        void EnterCombat(Unit* who) override
         {
             _events.ScheduleEvent(EVENT_MORTAL_STRIKE, urand(5000, 12800));
             _events.ScheduleEvent(EVENT_KNOCKDOWN, urand(5600, 15400));
@@ -158,7 +158,7 @@ public:
             }
         }
 
-        void UpdateAI(uint32 diff)
+        void UpdateAI(uint32 diff) override
         {
             if (!UpdateVictim())
                 return;
@@ -185,7 +185,7 @@ public:
         }
     };
 
-    CreatureAI* GetAI(Creature* creature) const
+    CreatureAI* GetAI(Creature* creature) const override
     {
         return new chromatic_elite_guardAI(creature);
     }

src/server/scripts/EasternKingdoms/BlackrockMountain/BlackrockSpire/boss_gizrul_the_slavener.cpp

@@ -37,29 +37,29 @@ public:
     {
         boss_gizrul_the_slavenerAI(Creature* creature) : BossAI(creature, DATA_GIZRUL_THE_SLAVENER) { }
 
-        void Reset()
+        void Reset() override
         {
             _Reset();
         }
 
-        void IsSummonedBy(Unit* /*summoner*/)
+        void IsSummonedBy(Unit* /*summoner*/) override
         {
             me->GetMotionMaster()->MovePath(GIZRUL_PATH, false);
         }
 
-        void EnterCombat(Unit* /*who*/)
+        void EnterCombat(Unit* /*who*/) override
         {
             _EnterCombat();
             events.ScheduleEvent(EVENT_FATAL_BITE, urand(17000, 20000));
             events.ScheduleEvent(EVENT_INFECTED_BITE, urand(10000, 12000));
         }
 
-        void JustDied(Unit* /*killer*/)
+        void JustDied(Unit* /*killer*/) override
         {
             _JustDied();
         }
 
-        void UpdateAI(uint32 diff)
+        void UpdateAI(uint32 diff) override
         {
             if (!UpdateVictim())
                 return;
@@ -89,7 +89,7 @@ public:
         }
     };
 
-    CreatureAI* GetAI(Creature* creature) const
+    CreatureAI* GetAI(Creature* creature) const override
     {
         return new boss_gizrul_the_slavenerAI(creature);
     }

src/server/scripts/EasternKingdoms/BlackrockMountain/BlackrockSpire/boss_gyth.cpp

@@ -46,7 +46,7 @@ public:
 
         bool SummonedRend;
 
-        void Reset()
+        void Reset() override
         {
             SummonedRend = false;
             if (instance->GetBossState(DATA_GYTH) == IN_PROGRESS)
@@ -57,7 +57,7 @@ public:
             }
         }
 
-        void EnterCombat(Unit* /*who*/)
+        void EnterCombat(Unit* /*who*/) override
         {
             _EnterCombat();
 
@@ -67,12 +67,12 @@ public:
             events.ScheduleEvent(EVENT_KNOCK_AWAY, urand(12000, 18000));
         }
 
-        void JustDied(Unit* /*killer*/)
+        void JustDied(Unit* /*killer*/) override
         {
             instance->SetBossState(DATA_GYTH, DONE);
         }
 
-        void SetData(uint32 /*type*/, uint32 data)
+        void SetData(uint32 /*type*/, uint32 data) override
         {
             switch (data)
             {
@@ -84,13 +84,13 @@ public:
             }
         }
 
-        void JustSummoned(Creature* summon)
+        void JustSummoned(Creature* summon) override
         {
             summons.Summon(summon);
             summon->AI()->AttackStart(me->SelectVictim());
         }
 
-        void UpdateAI(uint32 diff)
+        void UpdateAI(uint32 diff) override
         {
 
             if (!SummonedRend && HealthBelowPct(25))
@@ -156,7 +156,7 @@ public:
         }
     };
 
-    CreatureAI* GetAI(Creature* creature) const
+    CreatureAI* GetAI(Creature* creature) const override
     {
         return GetInstanceAI<boss_gythAI>(creature);
     }

src/server/scripts/EasternKingdoms/BlackrockMountain/BlackrockSpire/boss_halycon.cpp

@@ -36,20 +36,20 @@ public:
     {
         boss_halyconAI(Creature* creature) : BossAI(creature, DATA_HALYCON) { }
 
-        void Reset()
+        void Reset() override
         {
             _Reset();
             Summoned = false;
         }
 
-        void EnterCombat(Unit* /*who*/)
+        void EnterCombat(Unit* /*who*/) override
         {
             _EnterCombat();
             events.ScheduleEvent(EVENT_REND, urand(17000, 20000));
             events.ScheduleEvent(EVENT_THRASH, urand(10000, 12000));
         }
 
-        void JustDied(Unit* /*killer*/)
+        void JustDied(Unit* /*killer*/) override
         {
             me->SummonCreature(NPC_GIZRUL_THE_SLAVENER, SummonLocation, TEMPSUMMON_TIMED_DESPAWN, 300000);
             Talk(EMOTE_DEATH);
@@ -57,7 +57,7 @@ public:
             Summoned = true;
         }
 
-        void UpdateAI(uint32 diff)
+        void UpdateAI(uint32 diff) override
         {
             if (!UpdateVictim())
                 return;
@@ -88,7 +88,7 @@ public:
         bool Summoned;
     };
 
-    CreatureAI* GetAI(Creature* creature) const
+    CreatureAI* GetAI(Creature* creature) const override
     {
         return new boss_halyconAI(creature);
     }

src/server/scripts/EasternKingdoms/BlackrockMountain/BlackrockSpire/boss_highlord_omokk.cpp

@@ -25,7 +25,7 @@ class boss_highlord_omokk : public CreatureScript
 public:
     boss_highlord_omokk() : CreatureScript("boss_highlord_omokk") { }
 
-    CreatureAI* GetAI(Creature* creature) const
+    CreatureAI* GetAI(Creature* creature) const override
     {
         return new boss_highlordomokkAI(creature);
     }
@@ -34,24 +34,24 @@ public:
     {
         boss_highlordomokkAI(Creature* creature) : BossAI(creature, DATA_HIGHLORD_OMOKK) { }
 
-        void Reset()
+        void Reset() override
         {
             _Reset();
         }
 
-        void EnterCombat(Unit* /*who*/)
+        void EnterCombat(Unit* /*who*/) override
         {
             _EnterCombat();
             events.ScheduleEvent(EVENT_FRENZY,      20000);
             events.ScheduleEvent(EVENT_KNOCK_AWAY,  18000);
         }
 
-        void JustDied(Unit* /*killer*/)
+        void JustDied(Unit* /*killer*/) override
         {
             _JustDied();
         }
 
-        void UpdateAI(uint32 diff)
+        void UpdateAI(uint32 diff) override
         {
             if (!UpdateVictim())
                 return;

src/server/scripts/EasternKingdoms/BlackrockMountain/BlackrockSpire/boss_lord_valthalak.cpp

@@ -37,26 +37,26 @@ public:
     {
         boss_lord_valthalakAI(Creature* creature) : BossAI(creature, DATA_LORD_VALTHALAK) { }
 
-        void Reset()
+        void Reset() override
         {
             _Reset();
             frenzy40 = false;
             frenzy15 = false;
         }
 
-        void EnterCombat(Unit* /*who*/)
+        void EnterCombat(Unit* /*who*/) override
         {
             _EnterCombat();
             events.ScheduleEvent(EVENT_SUMMON_SPECTRAL_ASSASSIN, urand(6000, 8000));
             events.ScheduleEvent(EVENT_SHADOW_WRATH, urand(9000, 18000));
         }
 
-        void JustDied(Unit* /*killer*/)
+        void JustDied(Unit* /*killer*/) override
         {
             instance->SetData(DATA_LORD_VALTHALAK, DONE);
         }
 
-        void UpdateAI(uint32 diff)
+        void UpdateAI(uint32 diff) override
         {
             if (!UpdateVictim())
                 return;
@@ -114,7 +114,7 @@ public:
         bool frenzy15;
     };
 
-    CreatureAI* GetAI(Creature* creature) const
+    CreatureAI* GetAI(Creature* creature) const override
     {
         return GetInstanceAI<boss_lord_valthalakAI>(creature);
     }

src/server/scripts/EasternKingdoms/BlackrockMountain/BlackrockSpire/boss_overlord_wyrmthalak.cpp

@@ -38,7 +38,7 @@ class boss_overlord_wyrmthalak : public CreatureScript
 public:
     boss_overlord_wyrmthalak() : CreatureScript("boss_overlord_wyrmthalak") { }
 
-    CreatureAI* GetAI(Creature* creature) const
+    CreatureAI* GetAI(Creature* creature) const override
     {
         return new boss_overlordwyrmthalakAI(creature);
     }
@@ -49,13 +49,13 @@ public:
 
         bool Summoned;
 
-        void Reset()
+        void Reset() override
         {
             _Reset();
             Summoned = false;
         }
 
-        void EnterCombat(Unit* /*who*/)
+        void EnterCombat(Unit* /*who*/) override
         {
             _EnterCombat();
             events.ScheduleEvent(EVENT_BLAST_WAVE, 20 * IN_MILLISECONDS);
@@ -64,12 +64,12 @@ public:
             events.ScheduleEvent(EVENT_KNOCK_AWAY, 12 * IN_MILLISECONDS);
         }
 
-        void JustDied(Unit* /*killer*/)
+        void JustDied(Unit* /*killer*/) override
         {
             _JustDied();
         }
 
-        void UpdateAI(uint32 diff)
+        void UpdateAI(uint32 diff) override
         {
             if (!UpdateVictim())
                 return;

src/server/scripts/EasternKingdoms/BlackrockMountain/BlackrockSpire/boss_pyroguard_emberseer.cpp

@@ -66,7 +66,7 @@ public:
     {
         boss_pyroguard_emberseerAI(Creature* creature) : BossAI(creature, DATA_PYROGAURD_EMBERSEER) { }
 
-        void Reset()
+        void Reset() override
         {
             me->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_IMMUNE_TO_PC | UNIT_FLAG_NOT_SELECTABLE);
             events.Reset();
@@ -84,7 +84,7 @@ public:
                 OpenDoors(false); // Opens 2 entrance doors
         }
 
-        void SetData(uint32 /*type*/, uint32 data)
+        void SetData(uint32 /*type*/, uint32 data) override
         {
             switch (data)
             {
@@ -108,7 +108,7 @@ public:
             }
         }
 
-        void EnterCombat(Unit* /*who*/)
+        void EnterCombat(Unit* /*who*/) override
         {
             // ### TODO Check combat timing ###
             events.ScheduleEvent(EVENT_FIRENOVA,    6000);
@@ -116,7 +116,7 @@ public:
             events.ScheduleEvent(EVENT_PYROBLAST,  14000);
         }
 
-        void JustDied(Unit* /*killer*/)
+        void JustDied(Unit* /*killer*/) override
         {
             // Activate all the runes
             UpdateRunes(GO_STATE_READY);
@@ -126,7 +126,7 @@ public:
             instance->SetBossState(DATA_PYROGAURD_EMBERSEER, DONE);
         }
 
-        void SpellHit(Unit* /*caster*/, SpellInfo const* spell)
+        void SpellHit(Unit* /*caster*/, SpellInfo const* spell) override
         {
             if (spell->Id == SPELL_ENCAGE_EMBERSEER)
             {
@@ -185,7 +185,7 @@ public:
                 rune7->SetGoState(state);
         }
 
-        void UpdateAI(uint32 diff)
+        void UpdateAI(uint32 diff) override
         {
             if (!UpdateVictim())
             {
@@ -293,7 +293,7 @@ public:
         }
     };
 
-    CreatureAI* GetAI(Creature* creature) const
+    CreatureAI* GetAI(Creature* creature) const override
     {
         return GetInstanceAI<boss_pyroguard_emberseerAI>(creature);
     }
@@ -321,19 +321,19 @@ public:
     {
         npc_blackhand_incarceratorAI(Creature* creature) : ScriptedAI(creature) { }
 
-        void Reset()
+        void Reset() override
         {
             me->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_IMMUNE_TO_PC | UNIT_FLAG_IMMUNE_TO_NPC);
             if (Creature* Emberseer = me->FindNearestCreature(NPC_PYROGAURD_EMBERSEER, 30.0f, true))
                 Emberseer->AI()->SetData(1, 3);
         }
 
-        void JustDied(Unit* /*killer*/)
+        void JustDied(Unit* /*killer*/) override
         {
             me->DespawnOrUnsummon(10000);
         }
 
-        void SetData(uint32 data, uint32 value)
+        void SetData(uint32 data, uint32 value) override
         {
             if (data == 1 && value == 1)
             {
@@ -346,7 +346,7 @@ public:
                 _events.ScheduleEvent(EVENT_ENCAGED_EMBERSEER, 1000);
         }
 
-        void EnterCombat(Unit* /*who*/)
+        void EnterCombat(Unit* /*who*/) override
         {
             // Used to close doors
             if (Creature* Emberseer = me->FindNearestCreature(NPC_PYROGAURD_EMBERSEER, 30.0f, true))
@@ -365,7 +365,7 @@ public:
             _events.ScheduleEvent(EVENT_ENCAGE, urand(10000, 20000));
         }
 
-        void UpdateAI(uint32 diff)
+        void UpdateAI(uint32 diff) override
         {
 
 
@@ -417,7 +417,7 @@ public:
         EventMap _events;
     };
 
-    CreatureAI* GetAI(Creature* creature) const
+    CreatureAI* GetAI(Creature* creature) const override
     {
         return new npc_blackhand_incarceratorAI(creature);
     }

src/server/scripts/EasternKingdoms/BlackrockMountain/BlackrockSpire/boss_quartermaster_zigris.cpp

@@ -31,24 +31,24 @@ public:
     {
         boss_quatermasterzigrisAI(Creature* creature) : BossAI(creature, DATA_QUARTERMASTER_ZIGRIS) { }
 
-        void Reset()
+        void Reset() override
         {
             _Reset();
         }
 
-        void EnterCombat(Unit* /*who*/)
+        void EnterCombat(Unit* /*who*/) override
         {
             _EnterCombat();
             events.ScheduleEvent(EVENT_SHOOT,      1000);
             events.ScheduleEvent(EVENT_STUN_BOMB, 16000);
         }
 
-        void JustDied(Unit* /*killer*/)
+        void JustDied(Unit* /*killer*/) override
         {
             _JustDied();
         }
 
-        void UpdateAI(uint32 diff)
+        void UpdateAI(uint32 diff) override
         {
             if (!UpdateVictim())
                 return;
@@ -76,7 +76,7 @@ public:
         }
     };
 
-    CreatureAI* GetAI(Creature* creature) const
+    CreatureAI* GetAI(Creature* creature) const override
     {
         return new boss_quatermasterzigrisAI(creature);
     }

src/server/scripts/EasternKingdoms/BlackrockMountain/BlackrockSpire/boss_rend_blackhand.cpp

@@ -161,7 +161,7 @@ public:
     {
         boss_rend_blackhandAI(Creature* creature) : BossAI(creature, DATA_WARCHIEF_REND_BLACKHAND) { }
 
-        void Reset()
+        void Reset() override
         {
             _Reset();
 
@@ -196,7 +196,7 @@ public:
                 waveDoor->UseDoorOrButton();
         }
 
-        void JustSummoned(Creature* summon)
+        void JustSummoned(Creature* summon) override
         {
             summons.Summon(summon);
 
@@ -213,7 +213,7 @@ public:
                 Reset();
         }
 
-        void EnterCombat(Unit* /*who*/)
+        void EnterCombat(Unit* /*who*/) override
         {
             _EnterCombat();
             events.ScheduleEvent(EVENT_WHIRLWIND,     urand(13000, 15000));
@@ -221,7 +221,7 @@ public:
             events.ScheduleEvent(EVENT_MORTAL_STRIKE, urand(17000, 19000));
         }
 
-        void JustDied(Unit* /*killer*/)
+        void JustDied(Unit* /*killer*/) override
         {
             _JustDied();
             if (Creature* victor = me->FindNearestCreature(NPC_LORD_VICTOR_NEFARIUS, 75.0f, true))
@@ -233,7 +233,7 @@ public:
             instance->SetBossState(DATA_WARCHIEF_REND_BLACKHAND, DONE);
         }
 
-        void SetData(uint32 type, uint32 data)
+        void SetData(uint32 type, uint32 data) override
         {
             if (type == AREATRIGGER && data == AREATRIGGER_BLACKROCK_STADIUM)
             {
@@ -260,7 +260,7 @@ public:
             }
         }
 
-        void MovementInform(uint32 type, uint32 id)
+        void MovementInform(uint32 type, uint32 id) override
         {
             if (type == WAYPOINT_MOTION_TYPE)
             {
@@ -273,7 +273,7 @@ public:
             }
         }
 
-        void UpdateAI(uint32 diff)
+        void UpdateAI(uint32 diff) override
         {
             if (gythEvent)
             {
@@ -471,7 +471,7 @@ public:
         uint64 waveDoorGUID;
     };
 
-    CreatureAI* GetAI(Creature* creature) const
+    CreatureAI* GetAI(Creature* creature) const override
     {
         return GetInstanceAI<boss_rend_blackhandAI>(creature);
     }

src/server/scripts/EasternKingdoms/BlackrockMountain/BlackrockSpire/boss_shadow_hunter_voshgajin.cpp

@@ -27,7 +27,7 @@ class boss_shadow_hunter_voshgajin : public CreatureScript
 public:
     boss_shadow_hunter_voshgajin() : CreatureScript("boss_shadow_hunter_voshgajin") { }
 
-    CreatureAI* GetAI(Creature* creature) const
+    CreatureAI* GetAI(Creature* creature) const override
     {
         return new boss_shadowvoshAI(creature);
     }
@@ -36,13 +36,13 @@ public:
     {
         boss_shadowvoshAI(Creature* creature) : BossAI(creature, DATA_SHADOW_HUNTER_VOSHGAJIN) { }
 
-        void Reset()
+        void Reset() override
         {
             _Reset();
             //DoCast(me, SPELL_ICEARMOR, true);
         }
 
-        void EnterCombat(Unit* /*who*/)
+        void EnterCombat(Unit* /*who*/) override
         {
             _EnterCombat();
             events.ScheduleEvent(EVENT_CURSE_OF_BLOOD, 2 * IN_MILLISECONDS);
@@ -50,12 +50,12 @@ public:
             events.ScheduleEvent(EVENT_CLEAVE, 14 * IN_MILLISECONDS);
         }
 
-        void JustDied(Unit* /*killer*/)
+        void JustDied(Unit* /*killer*/) override
         {
             _JustDied();
         }
 
-        void UpdateAI(uint32 diff)
+        void UpdateAI(uint32 diff) override
         {
             if (!UpdateVictim())
                 return;

src/server/scripts/EasternKingdoms/BlackrockMountain/BlackrockSpire/boss_the_beast.cpp

@@ -27,7 +27,7 @@ class boss_the_beast : public CreatureScript
 public:
     boss_the_beast() : CreatureScript("boss_the_beast") { }
 
-    CreatureAI* GetAI(Creature* creature) const
+    CreatureAI* GetAI(Creature* creature) const override
     {
         return new boss_thebeastAI(creature);
     }
@@ -36,12 +36,12 @@ public:
     {
         boss_thebeastAI(Creature* creature) : BossAI(creature, DATA_THE_BEAST) { }
 
-        void Reset()
+        void Reset() override
         {
             _Reset();
         }
 
-        void EnterCombat(Unit* /*who*/)
+        void EnterCombat(Unit* /*who*/) override
         {
             _EnterCombat();
             events.ScheduleEvent(EVENT_FLAME_BREAK,     12 * IN_MILLISECONDS);
@@ -49,12 +49,12 @@ public:
             events.ScheduleEvent(EVENT_TERRIFYING_ROAR, 23 * IN_MILLISECONDS);
         }
 
-        void JustDied(Unit* /*killer*/)
+        void JustDied(Unit* /*killer*/) override
         {
             _JustDied();
         }
 
-        void UpdateAI(uint32 diff)
+        void UpdateAI(uint32 diff) override
         {
             if (!UpdateVictim())
                 return;

src/server/scripts/EasternKingdoms/BlackrockMountain/BlackrockSpire/boss_urok_doomhowl.cpp

@@ -38,18 +38,18 @@ public:
     {
         boss_urok_doomhowlAI(Creature* creature) : BossAI(creature, DATA_UROK_DOOMHOWL) {}
 
-        void Reset()
+        void Reset() override
         {
             _Reset();
         }
 
-        void InitializeAI()
+        void InitializeAI() override
         {
             me->CastSpell(me, SPELL_UROK_SPAWN, true);
             BossAI::InitializeAI();
         }
 
-        void EnterCombat(Unit* /*who*/)
+        void EnterCombat(Unit* /*who*/) override
         {
             _EnterCombat();
             events.ScheduleEvent(SPELL_REND, urand(17000, 20000));
@@ -57,12 +57,12 @@ public:
             Talk(SAY_AGGRO);
         }
 
-        void JustDied(Unit* /*killer*/)
+        void JustDied(Unit* /*killer*/) override
         {
             _JustDied();
         }
 
-        void UpdateAI(uint32 diff)
+        void UpdateAI(uint32 diff) override
         {
             if (!UpdateVictim())
                 return;
@@ -92,7 +92,7 @@ public:
         }
     };
 
-    CreatureAI* GetAI(Creature* creature) const
+    CreatureAI* GetAI(Creature* creature) const override
     {
         return new boss_urok_doomhowlAI(creature);
     }

src/server/scripts/EasternKingdoms/BlackrockMountain/BlackrockSpire/boss_warmaster_voone.cpp

@@ -37,12 +37,12 @@ public:
     {
         boss_warmastervooneAI(Creature* creature) : BossAI(creature, DATA_WARMASTER_VOONE) { }
 
-        void Reset()
+        void Reset() override
         {
             _Reset();
         }
 
-        void EnterCombat(Unit* /*who*/)
+        void EnterCombat(Unit* /*who*/) override
         {
             _EnterCombat();
             events.ScheduleEvent(EVENT_SNAP_KICK, 8 * IN_MILLISECONDS);
@@ -53,12 +53,12 @@ public:
             events.ScheduleEvent(EVENT_THROW_AXE, 1 * IN_MILLISECONDS);
         }
 
-        void JustDied(Unit* /*killer*/)
+        void JustDied(Unit* /*killer*/) override
         {
             _JustDied();
         }
 
-        void UpdateAI(uint32 diff)
+        void UpdateAI(uint32 diff) override
         {
             if (!UpdateVictim())
                 return;
@@ -102,7 +102,7 @@ public:
         }
     };
 
-    CreatureAI* GetAI(Creature* creature) const
+    CreatureAI* GetAI(Creature* creature) const override
     {
         return new boss_warmastervooneAI(creature);
     }