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

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) {}
 };