Core/Creature: implement initial SummonInfo API for handling summons in the future

Author: Ovahlord

src/common/Utilities/advstd.h

@@ -18,9 +18,91 @@
 #ifndef TRINITY_ADVSTD_H
 #define TRINITY_ADVSTD_H
 
+#include <version>
+
+#ifdef __cpp_lib_bit_cast
+#include <bit>
+#else
+#include <cstring> // for memcpy
+#endif
+#include <compare>
+
 // this namespace holds implementations of upcoming stdlib features that our c++ version doesn't have yet
 namespace advstd
 {
+// libc++ is missing these two
+[[nodiscard]] constexpr bool is_eq(std::partial_ordering cmp) noexcept { return cmp == 0; }
+[[nodiscard]] constexpr bool is_neq(std::partial_ordering cmp) noexcept { return cmp != 0; }
+
+#ifdef __cpp_lib_bit_cast
+using std::bit_cast;
+#else
+// libstdc++ v10 is missing this
+template <typename To, typename From,
+    std::enable_if_t<std::conjunction_v<
+        std::bool_constant<sizeof(To) == sizeof(From)>,
+        std::is_trivially_copyable<To>,
+        std::is_trivially_copyable<From>>, int> = 0>
+[[nodiscard]] constexpr To bit_cast(From const& from) noexcept
+{
+    To to;
+    std::memcpy(&to, &from, sizeof(To));
+    return to;
+}
+#endif
+}
+
+// std::forward_like
+#ifdef __cpp_lib_forward_like
+#include <utility>
+namespace advstd
+{
+using std::forward_like;
+}
+#else
+namespace advstd
+{
+template <class T, class U>
+[[nodiscard]] constexpr decltype(auto) forward_like(U&& value) noexcept
+{
+    using ValueU = std::remove_reference_t<U>;
+    using ValueConstU = std::conditional_t<std::is_const_v<std::remove_reference_t<T>>, ValueU const, ValueU>;
+    return static_cast<std::conditional_t<std::is_rvalue_reference_v<T&&>, ValueConstU&&, ValueConstU&>>(value);
+}
+}
+#endif
+
+// std::ranges::contains
+#include <algorithm>
+#ifndef __cpp_lib_ranges_contains
+#include <functional> // for std::ranges::equal_to, std::identity
+#include <iterator> // for std::input_iterator, std::sentinel_for, std::projected
+#endif
+
+namespace advstd::ranges
+{
+#ifndef __cpp_lib_ranges_contains
+struct Contains
+{
+    template<std::input_iterator I, std::sentinel_for<I> S, class T, class Proj = std::identity>
+    requires std::indirect_binary_predicate<std::ranges::equal_to, std::projected<I, Proj>, T const*>
+    [[nodiscard]] inline constexpr bool operator()(I first, S last, T const& value, Proj proj = {}) const
+    {
+        return std::ranges::find(std::move(first), last, value, proj) != last;
+    }
+
+    template<std::ranges::input_range R, class T, class Proj = std::identity>
+    requires std::indirect_binary_predicate<std::ranges::equal_to, std::projected<std::ranges::iterator_t<R>, Proj>, T const*>
+    [[nodiscard]] inline constexpr bool operator()(R&& r, T const& value, Proj proj = {}) const
+    {
+        auto first = std::ranges::begin(r);
+        auto last = std::ranges::end(r);
+        return std::ranges::find(std::move(first), last, value, proj) != last;
+    }
+} inline constexpr contains;
+#else
+using std::ranges::contains;
+#endif
 }
 
 #endif

src/server/game/Entities/Creature/Creature.cpp

@@ -51,6 +51,7 @@
 #include "ScriptedGossip.h"
 #include "SpellAuraEffects.h"
 #include "SpellMgr.h"
+#include "SummonInfo.h"
 #include "TemporarySummon.h"
 #include "Transport.h"
 #include "Util.h"
@@ -316,6 +317,11 @@ void Creature::AddToWorld()
         if (IsVehicle())
             GetVehicleKit()->Install();
 
+        // If the creature has been summoned, register it for the summoner
+        if (IsSummon())
+            if (Unit* summoner = GetSummonInfo()->GetUnitSummoner())
+                summoner->RegisterSummon(GetSummonInfo());
+
         if (GetZoneScript())
             GetZoneScript()->OnCreatureCreate(this);
     }
@@ -325,6 +331,11 @@ void Creature::RemoveFromWorld()
 {
     if (IsInWorld())
     {
+        // If the creature about to despawn, unregister it for the summoner
+        if (IsSummon())
+            if (Unit* summoner = GetSummonInfo()->GetUnitSummoner())
+                summoner->UnregisterSummon(GetSummonInfo());
+
         if (GetZoneScript())
             GetZoneScript()->OnCreatureRemove(this);
 
@@ -2761,6 +2772,22 @@ void Creature::InitializeMovementSpeeds()
         SetSpeed(MOVE_WALK, _creatureMovementInfo.WalkSpeed);
 }
 
+void Creature::InitializeSummonInfo(SummonInfoArgs const& args)
+{
+    ASSERT(_summonInfo == nullptr, "SummonInfo has already been initialized and must not be allocated again!");
+    _summonInfo = std::make_unique<SummonInfo>(this, args);
+}
+
+SummonInfo* Creature::GetSummonInfo() const
+{
+    return _summonInfo.get();
+}
+
+bool Creature::IsSummon() const
+{
+    return _summonInfo != nullptr;
+}
+
 void Creature::AllLootRemovedFromCorpse()
 {
     if (loot.loot_type != LOOT_SKINNING && !IsPet() && GetCreatureTemplate()->SkinLootId && hasLootRecipient())

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

@@ -34,8 +34,11 @@ class Group;
 class Quest;
 class Player;
 class SpellInfo;
+class SummonInfo;
 class WorldSession;
 
+struct SummonInfoArgs;
+
 enum MovementGeneratorType : uint8;
 
 struct VendorItemCount
@@ -420,6 +423,13 @@ class TC_GAME_API Creature : public Unit, public GridObject<Creature>, public Ma
         void ResetNoNpcDamageBelowPctHealthValue() { _noNpcDamageBelowPctHealth = 0.f; }
         float GetNoNpcDamageBelowPctHealthValue() const { return _noNpcDamageBelowPctHealth; }
 
+        // Initializes the summon API for this creature which marks it as summon and will be treated accordingly
+        void InitializeSummonInfo(SummonInfoArgs const& args);
+        // Returns a pointer to the SummonInfo API, nullptr if the creature is not a summon
+        SummonInfo* GetSummonInfo() const;
+
+        bool IsSummon() const override;
+
     protected:
         bool CreateFromProto(ObjectGuid::LowType guidlow, uint32 entry, CreatureData const* data = nullptr, uint32 vehId = 0);
         bool InitEntry(uint32 entry, CreatureData const* data = nullptr);
@@ -510,6 +520,9 @@ class TC_GAME_API Creature : public Unit, public GridObject<Creature>, public Ma
 
         Optional<uint32> _defaultMountDisplayIdOverride;
         float _noNpcDamageBelowPctHealth;
+
+        // The Summon API which controls the behavior of summons
+        std::unique_ptr<SummonInfo> _summonInfo;
 };
 
 class TC_GAME_API AssistDelayEvent : public BasicEvent

src/server/game/Entities/Creature/SummonInfo/SummonInfo.cpp

@@ -0,0 +1,124 @@
+/*
+ * This file is part of the TrinityCore Project. See AUTHORS file for Copyright information
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; either version 2 of the License, or (at your
+ * option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "SummonInfo.h"
+
+#include "Creature.h"
+#include "DBCStores.h"
+#include "Log.h"
+#include "ObjectAccessor.h"
+#include "SummonInfoArgs.h"
+
+SummonInfo::SummonInfo(Creature* summonedCreature, SummonInfoArgs const& args) :
+    _summonedCreature(ASSERT_NOTNULL(summonedCreature)), _summonerGUID(args.SummonerGUID), _remainingDuration(args.Duration),
+    _maxHealth(args.MaxHealth), _summonSpellId(args.SummonSpellId),_despawnOnSummonerLogout(false),
+    _despawnOnSummonerDeath(false), _despawnWhenExpired(false)
+{
+    if (args.SummonPropertiesId.has_value())
+        InitializeSummonProperties(*args.SummonPropertiesId);
+}
+
+void SummonInfo::InitializeSummonProperties(uint32 summonPropertiesId)
+{
+    SummonPropertiesEntry const* summonProperties = sSummonPropertiesStore.LookupEntry(summonPropertiesId);
+    if (!summonProperties)
+    {
+        TC_LOG_ERROR("entities.unit", "Creature %s has been summoned with a non-existing SummonProperties.dbc entry (RecId: %u).", _summonedCreature->GetGUID().ToString().c_str(), summonPropertiesId);
+        return;
+    }
+
+    if (summonProperties->Faction)
+        _factionId = summonProperties->Faction;
+
+    _despawnOnSummonerLogout = summonProperties->GetFlags().HasFlag(SummonPropertiesFlags::DespawnOnSummonerLogout);
+    _despawnOnSummonerDeath = summonProperties->GetFlags().HasFlag(SummonPropertiesFlags::DespawnOnSummonerDeath);
+    _despawnWhenExpired = summonProperties->GetFlags().HasFlag(SummonPropertiesFlags::DespawnWhenExpired);
+
+    //if (_despawnOnSummonerDeath && summonProperties->GetFlags().HasFlag(SummonPropertiesFlags::DontDespawnOnSummonerDeath))
+    //    _despawnOnSummonerDeath = false;
+}
+
+Creature* SummonInfo::GetSummonedCreature() const
+{
+    return _summonedCreature;
+}
+
+Unit* SummonInfo::GetUnitSummoner() const
+{
+    if (!_summonerGUID.has_value())
+        return nullptr;
+
+    return ObjectAccessor::GetUnit(*_summonedCreature, *_summonerGUID);
+}
+
+GameObject* SummonInfo::GetGameObjectSummoner() const
+{
+    if (!_summonerGUID.has_value())
+        return nullptr;
+
+    return ObjectAccessor::GetGameObject(*_summonedCreature, *_summonerGUID);
+}
+
+Optional<Milliseconds> SummonInfo::GetRemainingDuration() const
+{
+    return _remainingDuration;
+}
+
+Optional<uint64> SummonInfo::GetMaxHealth() const
+{
+    return _maxHealth;
+}
+
+Optional<uint32> SummonInfo::GetSummonSpellId() const
+{
+    return _summonSpellId;
+}
+
+Optional<uint32> SummonInfo::GetFactionId() const
+{
+    return _factionId;
+}
+
+bool SummonInfo::DespawnsOnSummonerLogout() const
+{
+    return _despawnOnSummonerLogout;
+}
+
+void SummonInfo::SetDespawnOnSummonerLogout(bool set)
+{
+    _despawnOnSummonerLogout = set;
+}
+
+bool SummonInfo::DespawnsOnSummonerDeath() const
+{
+    return _despawnOnSummonerDeath;
+}
+
+void SummonInfo::SetDespawnOnSummonerDeath(bool set)
+{
+    _despawnOnSummonerDeath = set;
+}
+
+bool SummonInfo::DespawnsWhenExpired() const
+{
+    return _despawnWhenExpired;
+}
+
+void SummonInfo::SetDespawnWhenExpired(bool set)
+{
+    _despawnWhenExpired = set;
+}

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

@@ -0,0 +1,85 @@
+/*
+ * This file is part of the TrinityCore Project. See AUTHORS file for Copyright information
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; either version 2 of the License, or (at your
+ * option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef _SummonInfo_h__
+#define _SummonInfo_h__
+
+#include "Define.h"
+#include "Duration.h"
+#include "ObjectGuid.h"
+#include "Optional.h"
+
+class Creature;
+class GameObject;
+class Unit;
+
+struct SummonInfoArgs;
+
+class TC_GAME_API SummonInfo
+{
+public:
+    SummonInfo(SummonInfo const& right) = delete;
+    SummonInfo(SummonInfo&& right) = delete;
+    SummonInfo& operator=(SummonInfo const& right) = delete;
+    SummonInfo& operator=(SummonInfo&& right) = delete;
+
+    explicit SummonInfo(Creature* summonedCreature, SummonInfoArgs const& args);
+
+    // Initializes additional settings based on the provided SummonProperties ID.
+    void InitializeSummonProperties(uint32 summonPropertiesId);
+    // Returns the creature that is tied to this SummonInfo instance.
+    Creature* GetSummonedCreature() const;
+    // Returns the Unit summoner, or nullptr if no summoner has been provided or if the summoner is not a Unit.
+    Unit* GetUnitSummoner() const;
+    // Returns the GameObject summoner, or nullptr if no summoner has been provided or if the summoner is not a GameObject.
+    GameObject* GetGameObjectSummoner() const;
+
+    // Returns the remaining time until the summon expires. Nullopt when no duration was set which implies that the summon is permanent.
+    Optional<Milliseconds> GetRemainingDuration() const;
+    // Returns the health amount that will override the default max health calculation. Nullopt when no amount is provided.
+    Optional<uint64> GetMaxHealth() const;
+    // Returns the ID of the spell that has been used to summon the creature. Nullopt when the creature has not been summoned by a spell (scripted summons/ other APIs).
+    Optional<uint32> GetSummonSpellId() const;
+    // Returns the FactionTemplate ID of the summon that is overriding the default ID of the creature. Nullopt when the faction has not been overriden.
+    Optional<uint32> GetFactionId() const;
+
+    // Returns true when the summon will despawn when the summoner logs out. This also includes despawning and teleporting between map instances.
+    bool DespawnsOnSummonerLogout() const;
+    // Marks the summon to despawn when the summoner logs out. This also includes despawning and teleporting between map instaces.
+    void SetDespawnOnSummonerLogout(bool set);
+    // Returns true when the summon will despawn when its summoner has died.
+    bool DespawnsOnSummonerDeath() const;
+    // Marks the summon to despawn when the summoner has died.
+    void SetDespawnOnSummonerDeath(bool set);
+    // Returns true when the summon will despawn after its duration has expired. If not set, the summon will just die.
+    bool DespawnsWhenExpired() const;
+    // Marks the summon to despawn after its duration has expired. If disabled, the summon will just die.
+    void SetDespawnWhenExpired(bool set);
+
+private:
+    Creature* _summonedCreature;
+    Optional<ObjectGuid> _summonerGUID;
+    Optional<Milliseconds> _remainingDuration;  // NYI
+    Optional<uint64> _maxHealth;                // NYI
+    Optional<uint32> _summonSpellId;            // NYI
+    Optional<uint32> _factionId;                // NYI
+    bool _despawnOnSummonerLogout;              // NYI
+    bool _despawnOnSummonerDeath;               // NYI
+    bool _despawnWhenExpired;                   // NYI
+};
+
+#endif // _SummonInfo_h__