Hyperlinks.h

Go to the documentation of this file.

/*
 * 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 TRINITY_HYPERLINKS_H
#define TRINITY_HYPERLINKS_H
 
#include "ObjectGuid.h"
#include "StringConvert.h"
#include <array>
#include <string>
#include <string_view>
 
struct AchievementEntry;
struct ArtifactPowerRankEntry;
struct AzeriteEssenceEntry;
struct BattlePetAbilityEntry;
struct BattlePetSpeciesEntry;
struct ChrSpecializationEntry;
struct CurrencyContainerEntry;
struct CurrencyTypesEntry;
struct GarrAbilityEntry;
struct GarrFollowerEntry;
struct GarrMissionEntry;
struct GlyphPropertiesEntry;
struct ItemModifiedAppearanceEntry;
struct ItemNameDescriptionEntry;
struct ItemTemplate;
struct LocalizedString;
struct MapEntry;
struct MapChallengeModeEntry;
struct MawPowerEntry;
struct PvpTalentEntry;
class Quest;
struct SkillLineEntry;
struct SoulbindConduitRankEntry;
class SpellInfo;
struct SpellItemEnchantmentEntry;
struct TalentEntry;
struct TransmogSetEntry;
struct UiMapEntry;
 
namespace Trinity::Hyperlinks
{
 
 struct AchievementLinkData
 {
 AchievementEntry const* Achievement = nullptr;
 ObjectGuid CharacterId;
 bool IsFinished = false;
 int32 Year = 0;
 int32 Month = 0;
 int32 Day = 0;
 std::array<uint32, 4> Criteria = { };
 };
 
 struct ApiLinkData
 {
 std::string_view Type;
 std::string_view Name;
 std::string_view Parent;
 };
 
 struct ArtifactPowerLinkData
 {
 ArtifactPowerRankEntry const* ArtifactPower = nullptr;
 uint8 PurchasedRank = 0;
 uint8 CurrentRankWithBonus = 0;
 };
 
 struct AzeriteEssenceLinkData
 {
 AzeriteEssenceEntry const* Essence = nullptr;
 uint8 Rank = 0;
 };
 
 struct BattlePetLinkData
 {
 BattlePetSpeciesEntry const* Species = nullptr;
 uint8 Level = 0;
 uint8 Quality = 0;
 uint32 MaxHealth = 0;
 uint32 Power = 0;
 uint32 Speed = 0;
 ObjectGuid PetGuid;
 uint32 DisplayId = 0;
 };
 
 struct BattlePetAbilLinkData
 {
 BattlePetAbilityEntry const* Ability = nullptr;
 uint32 MaxHealth = 0;
 uint32 Power = 0;
 uint32 Speed = 0;
 };
 
 struct CurrencyLinkData
 {
 CurrencyTypesEntry const* Currency = nullptr;
 int32 Quantity = 0;
 
 CurrencyContainerEntry const* Container = nullptr;
 };
 
 struct DungeonScoreLinkData
 {
 uint32 Score = 0;
 ObjectGuid Player;
 std::string_view PlayerName;
 uint8 PlayerClass = 0;
 uint32 AvgItemLevel = 0;
 uint8 PlayerLevel = 0;
 uint32 RunsThisSeason = 0;
 uint32 BestSeasonScore = 0;
 uint32 BestSeasonNumber = 0;
 
 struct Dungeon
 {
 uint32 MapChallengeModeID = 0;
 bool CompletedInTime = false;
 uint32 KeystoneLevel = 0;
 };
 
 std::vector<Dungeon> Dungeons;
 };
 
 struct GarrisonFollowerLinkData
 {
 GarrFollowerEntry const* Follower = nullptr;
 uint32 Quality = 0;
 uint32 Level = 0;
 uint32 ItemLevel = 0;
 std::array<uint32, 4> Abilities = { };
 uint32 Traits[4] = { };
 uint32 Specialization = 0;
 };
 
 struct GarrisonMissionLinkData
 {
 GarrMissionEntry const* Mission = nullptr;
 uint64 DbID = 0;
 };
 
 struct InstanceLockLinkData
 {
 ObjectGuid Owner;
 MapEntry const* Map = nullptr;
 uint32 Difficulty = 0;
 uint32 CompletedEncountersMask = 0;
 };
 
 struct ItemLinkData
 {
 ItemTemplate const* Item = nullptr;
 uint32 EnchantId = 0;
 std::array<uint32, 3> GemItemId = { };
 uint8 RenderLevel = 0;
 uint32 RenderSpecialization = 0;
 uint8 Context = 0;
 std::vector<int32> ItemBonusListIDs;
 
 struct Modifier
 {
 uint32 Type = 0;
 int32 Value = 0;
 };
 
 std::vector<Modifier> Modifiers;
 std::vector<int32> GemItemBonusListIDs[3];
 ObjectGuid Creator;
 uint32 UseEnchantId = 0;
 
 uint32 Quality = 0;
 ItemNameDescriptionEntry const* Suffix = nullptr;
 };
 
 struct JournalLinkData
 {
 enum class Types : uint8
 {
 Instance = 0,
 Encounter = 1,
 EncounterSection = 2,
 Tier = 3
 };
 
 uint8 Type = 0;
 LocalizedString const* ExpectedText = nullptr;
 uint32 Difficulty = 0;
 };
 
 struct KeystoneLinkData
 {
 uint32 ItemId = 0;
 MapChallengeModeEntry const* Map = nullptr;
 uint32 Level = 0;
 std::array<uint32, 4> Affix = { };
 };
 
 struct MountLinkData
 {
 SpellInfo const* Spell = nullptr;
 uint32 DisplayId = 0;
 std::string_view Customizations;
 };
 
 struct QuestLinkData
 {
 ::Quest const* Quest = nullptr;
 uint32 ContentTuningId = 0;
 };
 
 struct SpellLinkData
 {
 SpellInfo const* Spell = nullptr;
 GlyphPropertiesEntry const* Glyph = nullptr;
 };
 
 struct TalentBuildLinkData
 {
 ChrSpecializationEntry const* Spec = nullptr;
 uint32 Level = 0;
 std::string_view ImportString;
 };
 
 struct TradeskillLinkData
 {
 ObjectGuid Owner;
 SpellInfo const* Spell = nullptr;
 SkillLineEntry const* Skill = nullptr;
 };
 
 struct WorldMapLinkData
 {
 UiMapEntry const* UiMap = nullptr;
 uint32 X = 0;
 uint32 Y = 0;
 Optional<uint32> Z;
 };
 
 namespace LinkTags {
 
 /************************** LINK TAGS ***************************************************\
 |* Link tags must abide by the following: *|
 |* - MUST expose ::value_type typedef *|
 |* - storage type is remove_cvref_t<value_type> *|
 |* - MUST expose static ::tag method, void -> std::string_view *|
 |* - this method SHOULD be constexpr *|
 |* - returns identifier string for the link ("creature", "creature_entry", "item") *|
 |* - MUST expose static ::StoreTo method, (storage&, std::string_view) *|
 |* - assign storage& based on content of std::string_view *|
 |* - return value indicates success/failure *|
 |* - for integral/string types this can be achieved by extending base_tag *|
 \****************************************************************************************/
 struct base_tag
 {
 static bool StoreTo(std::string_view& val, std::string_view data)
 {
 val = data;
 return true;
 }
 
 static bool StoreTo(std::string& val, std::string_view data)
 {
 val.assign(data);
 return true;
 }
 
 template <typename T>
 static std::enable_if_t<std::is_integral_v<T>, bool> StoreTo(T& val, std::string_view data)
 {
 if (Optional<T> res = Trinity::StringTo<T>(data))
 {
 val = *res;
 return true;
 }
 else
 return false;
 }
 
 static bool StoreTo(ObjectGuid& val, std::string_view data)
 {
 ObjectGuid parsed = ObjectGuid::FromString(std::string(data));
 if (parsed != ObjectGuid::FromStringFailed)
 {
 val = parsed;
 return true;
 }
 else
 return false;
 }
 };
 
 #define make_base_tag(ltag, type) struct ltag : public base_tag { using value_type = type; static constexpr std::string_view tag() { return #ltag; } }
 // custom formats
 make_base_tag(area, uint32);
 make_base_tag(areatrigger, uint32);
 make_base_tag(creature, ObjectGuid::LowType);
 make_base_tag(creature_entry, uint32);
 make_base_tag(gameevent, uint16);
 make_base_tag(gameobject, ObjectGuid::LowType);
 make_base_tag(gameobject_entry, uint32);
 make_base_tag(itemset, uint32);
 make_base_tag(player, std::string_view);
 make_base_tag(skill, uint32);
 make_base_tag(taxinode, uint32);
 make_base_tag(tele, uint32);
 make_base_tag(title, uint32);
 
 // client format
 make_base_tag(clubFinder, ObjectGuid);
 make_base_tag(clubTicket, std::string_view);
 make_base_tag(outfit, std::string_view); // some sort of weird base91 derived encoding
 #undef make_base_tag
 
 struct TC_GAME_API achievement
 {
 using value_type = AchievementLinkData const&;
 static constexpr std::string_view tag() { return "achievement"; }
 static bool StoreTo(AchievementLinkData& val, std::string_view text);
 };
 
 struct TC_GAME_API api
 {
 using value_type = ApiLinkData const&;
 static constexpr std::string_view tag() { return "api"; }
 static bool StoreTo(ApiLinkData& val, std::string_view text);
 };
 
 struct TC_GAME_API apower
 {
 using value_type = ArtifactPowerLinkData const&;
 static constexpr std::string_view tag() { return "apower"; }
 static bool StoreTo(ArtifactPowerLinkData& val, std::string_view text);
 };
 
 struct TC_GAME_API azessence
 {
 using value_type = AzeriteEssenceLinkData const&;
 static constexpr std::string_view tag() { return "azessence"; }
 static bool StoreTo(AzeriteEssenceLinkData& val, std::string_view text);
 };
 
 struct TC_GAME_API battlepet
 {
 using value_type = BattlePetLinkData const&;
 static constexpr std::string_view tag() { return "battlepet"; }
 static bool StoreTo(BattlePetLinkData& val, std::string_view text);
 };
 
 struct TC_GAME_API battlePetAbil
 {
 using value_type = BattlePetAbilLinkData const&;
 static constexpr std::string_view tag() { return "battlePetAbil"; }
 static bool StoreTo(BattlePetAbilLinkData& val, std::string_view text);
 };
 
 struct TC_GAME_API conduit
 {
 using value_type = SoulbindConduitRankEntry const*;
 static constexpr std::string_view tag() { return "conduit"; }
 static bool StoreTo(SoulbindConduitRankEntry const*& val, std::string_view text);
 };
 
 struct TC_GAME_API currency
 {
 using value_type = CurrencyLinkData const&;
 static constexpr std::string_view tag() { return "currency"; }
 static bool StoreTo(CurrencyLinkData& val, std::string_view text);
 };
 
 struct TC_GAME_API dungeonScore
 {
 using value_type = DungeonScoreLinkData const&;
 static constexpr std::string_view tag() { return "dungeonScore"; }
 static bool StoreTo(DungeonScoreLinkData& val, std::string_view text);
 };
 
 struct TC_GAME_API enchant
 {
 using value_type = SpellInfo const*;
 static constexpr std::string_view tag() { return "enchant"; }
 static bool StoreTo(SpellInfo const*& val, std::string_view text);
 };
 
 struct TC_GAME_API garrfollower
 {
 using value_type = GarrisonFollowerLinkData const&;
 static constexpr std::string_view tag() { return "garrfollower"; }
 static bool StoreTo(GarrisonFollowerLinkData& val, std::string_view text);
 };
 
 struct TC_GAME_API garrfollowerability
 {
 using value_type = GarrAbilityEntry const*;
 static constexpr std::string_view tag() { return "garrfollowerability"; }
 static bool StoreTo(GarrAbilityEntry const*& val, std::string_view text);
 };
 
 struct TC_GAME_API garrmission
 {
 using value_type = GarrisonMissionLinkData const&;
 static constexpr std::string_view tag() { return "garrmission"; }
 static bool StoreTo(GarrisonMissionLinkData& val, std::string_view text);
 };
 
 struct TC_GAME_API instancelock
 {
 using value_type = InstanceLockLinkData const&;
 static constexpr std::string_view tag() { return "instancelock"; }
 static bool StoreTo(InstanceLockLinkData& val, std::string_view text);
 };
 
 struct TC_GAME_API item
 {
 using value_type = ItemLinkData const&;
 static constexpr std::string_view tag() { return "item"; }
 static bool StoreTo(ItemLinkData& val, std::string_view text);
 };
 
 struct TC_GAME_API journal
 {
 using value_type = JournalLinkData const&;
 static constexpr std::string_view tag() { return "journal"; }
 static bool StoreTo(JournalLinkData& val, std::string_view text);
 };
 
 struct TC_GAME_API keystone
 {
 using value_type = KeystoneLinkData const&;
 static constexpr std::string_view tag() { return "keystone"; }
 static bool StoreTo(KeystoneLinkData& val, std::string_view text);
 };
 
 struct TC_GAME_API mawpower
 {
 using value_type = MawPowerEntry const*;
 static constexpr std::string_view tag() { return "mawpower"; }
 static bool StoreTo(MawPowerEntry const*& val, std::string_view text);
 };
 
 struct TC_GAME_API mount
 {
 using value_type = MountLinkData const&;
 static constexpr std::string_view tag() { return "mount"; }
 static bool StoreTo(MountLinkData& val, std::string_view text);
 };
 
 struct TC_GAME_API pvptal
 {
 using value_type = PvpTalentEntry const*;
 static constexpr std::string_view tag() { return "pvptal"; }
 static bool StoreTo(PvpTalentEntry const*& val, std::string_view text);
 };
 
 struct TC_GAME_API quest
 {
 using value_type = QuestLinkData const&;
 static constexpr std::string_view tag() { return "quest"; }
 static bool StoreTo(QuestLinkData& val, std::string_view text);
 };
 
 struct TC_GAME_API spell
 {
 using value_type = SpellLinkData const&;
 static constexpr std::string_view tag() { return "spell"; }
 static bool StoreTo(SpellLinkData& val, std::string_view text);
 };
 
 struct TC_GAME_API talent
 {
 using value_type = TalentEntry const*;
 static constexpr std::string_view tag() { return "talent"; }
 static bool StoreTo(TalentEntry const*& val, std::string_view text);
 };
 
 struct TC_GAME_API talentbuild
 {
 using value_type = TalentBuildLinkData const&;
 static constexpr std::string_view tag() { return "talentbuild"; }
 static bool StoreTo(TalentBuildLinkData& val, std::string_view text);
 };
 
 struct TC_GAME_API trade
 {
 using value_type = TradeskillLinkData const&;
 static constexpr std::string_view tag() { return "trade"; }
 static bool StoreTo(TradeskillLinkData& val, std::string_view text);
 };
 
 struct TC_GAME_API transmogappearance
 {
 using value_type = ItemModifiedAppearanceEntry const*;
 static constexpr std::string_view tag() { return "transmogappearance"; }
 static bool StoreTo(ItemModifiedAppearanceEntry const*& val, std::string_view text);
 };
 
 struct TC_GAME_API transmogillusion
 {
 using value_type = SpellItemEnchantmentEntry const*;
 static constexpr std::string_view tag() { return "transmogillusion"; }
 static bool StoreTo(SpellItemEnchantmentEntry const*& val, std::string_view text);
 };
 
 struct TC_GAME_API transmogset
 {
 using value_type = TransmogSetEntry const*;
 static constexpr std::string_view tag() { return "transmogset"; }
 static bool StoreTo(TransmogSetEntry const*& val, std::string_view text);
 };
 
 struct TC_GAME_API worldmap
 {
 using value_type = WorldMapLinkData const&;
 static constexpr std::string_view tag() { return "worldmap"; }
 static bool StoreTo(WorldMapLinkData& val, std::string_view text);
 };
 }
 
 struct HyperlinkColor
 {
 HyperlinkColor(uint32 c) : r(c >> 16), g(c >> 8), b(c), a(c >> 24) {}
 uint8 const r, g, b, a;
 bool operator==(uint32 c) const
 {
 if ((c & 0xff) ^ b)
 return false;
 if (((c >>= 8) & 0xff) ^ g)
 return false;
 if (((c >>= 8) & 0xff) ^ r)
 return false;
 if ((c >>= 8) ^ a)
 return false;
 return true;
 }
 };
 
 struct HyperlinkInfo
 {
 HyperlinkInfo() : ok(false), color(0) {}
 HyperlinkInfo(std::string_view t, uint32 c, std::string_view ta, std::string_view d, std::string_view te) :
 ok(true), tail(t), color(c), tag(ta), data(d), text(te) {}
 
 explicit operator bool() { return ok; }
 bool const ok;
 std::string_view const tail;
 HyperlinkColor const color;
 std::string_view const tag;
 std::string_view const data;
 std::string_view const text;
 };
 HyperlinkInfo TC_GAME_API ParseSingleHyperlink(std::string_view str);
 bool TC_GAME_API CheckAllLinks(std::string_view str);
 
}
 
#endif