Replace rawptr with shared_ptr for class Charter

* refactor class files Charter
* refactor objmgr charter functions
* cleanup some duplicate code

src/world/Chat/Commands/GuildCommands.cpp

@@ -44,8 +44,7 @@ bool ChatHandler::HandleGuildCreateCommand(const char* args, WorldSession* m_ses
     }
 
     Charter tempCharter(0, selected_player->getGuidLow(), CHARTER_TYPE_GUILD);
-    tempCharter.SignatureCount = 0;
-    tempCharter.GuildName = std::string(args);
+    tempCharter.setGuildName(std::string(args));
 
     Guild* guild = new Guild;
     if (!guild->create(selected_player, std::string(args)))

src/world/Management/Charter.cpp

@@ -7,100 +7,111 @@ This file is released under the MIT license. See README-MIT for more information
 #include "Management/ObjectMgr.h"
 #include "Server/MainServerDefines.h"
 #include "Database/Field.hpp"
+#include "Objects/Units/Players/PlayerDefines.hpp"
 
-Charter::Charter(Field* fields)
+Charter::Charter(Field* _field)
 {
-    uint32_t f = 0;
-    CharterId = fields[f++].GetUInt32();
-    CharterType = fields[f++].GetUInt8();
-    LeaderGuid = fields[f++].GetUInt32();
-    GuildName = fields[f++].GetString();
-    ItemGuid = fields[f++].GetUInt64();
-    SignatureCount = 0;
-    Slots = GetNumberOfSlotsByType();
-    Signatures = new uint32_t[Slots];
+    m_charterId = _field[0].GetUInt32();
+    m_charterType = _field[1].GetUInt8();
+    m_leaderGuid = _field[2].GetUInt32();
+    m_guildName = _field[3].GetString();
+    m_itemGuid = _field[4].GetUInt64();
 
-    for (uint32_t i = 0; i < Slots; ++i)
+    m_availableSlots = getNumberOfAvailableSlots();
+
+    for (uint8_t i = 0; i < m_availableSlots; ++i)
     {
-        Signatures[i] = fields[f++].GetUInt32();
-        if (Signatures[i])
-            ++SignatureCount;
-    }
+        constexpr uint8_t fieldOffset = 5;
 
-    PetitionSignerCount = 0;
-}
-
-void Charter::AddSignature(uint32_t PlayerGuid)
-{
-    if (SignatureCount >= Slots)
-        return;
-
-    ++SignatureCount;
-    uint32_t i = 0;
-    for (; i < Slots; ++i)
-    {
-        if (Signatures[i] == 0)
-        {
-            Signatures[i] = PlayerGuid;
-            break;
-        }
+        if (uint32_t playerGuid = _field[i + fieldOffset].GetUInt32())
+            m_signatures.push_back(playerGuid);
     }
 }
 
-void Charter::RemoveSignature(uint32_t PlayerGuid)
+Charter::Charter(uint32_t _id, uint32_t _leaderGuid, uint8_t _type) : m_charterId(_id), m_charterType(_type), m_leaderGuid(_leaderGuid)
 {
-    for (uint32_t i = 0; i < Slots; ++i)
-    {
-        if (Signatures[i] == PlayerGuid)
-        {
-            Signatures[i] = 0;
-            --SignatureCount;
-            SaveToDB();
-            break;
-        }
-    }
+    m_availableSlots = getNumberOfAvailableSlots();
 }
 
-void Charter::Destroy()
+Charter::~Charter() = default;
+
+void Charter::saveToDB()
 {
-    sObjectMgr.RemoveCharter(this);
+    CharacterDatabase.Execute("DELETE FROM charters WHERE charterId = %u;", m_charterId);
 
-    CharacterDatabase.Execute("DELETE FROM charters WHERE charterId = %u", CharterId);
-
-    for (uint32_t i = 0; i < Slots; ++i)
-    {
-        if (!Signatures[i])
-            continue;
-
-        Player* p = sObjectMgr.GetPlayer(Signatures[i]);
-        if (p != nullptr)
-            p->unsetCharter(CharterType);
-    }
-
-    delete this;
-}
-
-void Charter::SaveToDB()
-{
     std::stringstream ss;
-    uint32_t i;
+    ss << "INSERT INTO charters VALUES(" << m_charterId << "," << m_charterType << "," << m_leaderGuid << ",'" << m_guildName << "'," << m_itemGuid;
 
-    ss << "DELETE FROM charters WHERE charterId = ";
-    ss << CharterId;
-    ss << ";";
+    for (const auto playerGuid : m_signatures)
+        ss << "," << playerGuid;
 
-    CharacterDatabase.Execute(ss.str().c_str());
-
-    ss.rdbuf()->str("");
-
-    ss << "INSERT INTO charters VALUES(" << CharterId << "," << CharterType << "," << LeaderGuid << ",'" << GuildName << "'," << ItemGuid;
-
-    for (i = 0; i < Slots; ++i)
-        ss << "," << Signatures[i];
-
-    for (; i < 9; ++i)
+    for (uint8_t i = getSignatureCount(); i < 9; ++i)
         ss << ",0";
 
     ss << ")";
     CharacterDatabase.Execute(ss.str().c_str());
 }
+
+void Charter::destroy()
+{
+    sObjectMgr.removeCharter(shared_from_this());
+
+    CharacterDatabase.Execute("DELETE FROM charters WHERE charterId = %u", m_charterId);
+
+    for (const auto playerGuid : m_signatures)
+    {
+        if (Player* player = sObjectMgr.GetPlayer(playerGuid))
+            player->unsetCharter(m_charterType);
+    }
+
+    delete this;
+}
+
+uint32_t Charter::getLeaderGuid() const { return m_leaderGuid; }
+
+uint32_t Charter::getId() const { return m_charterId; }
+
+uint8_t Charter::getCharterType() const { return m_charterType; }
+
+std::string Charter::getGuildName() { return m_guildName; }
+void Charter::setGuildName(const std::string& _guildName) { m_guildName = _guildName; }
+
+uint64_t Charter::getItemGuid() const { return m_itemGuid; }
+void Charter::setItemGuid(const uint64_t _itemGuid) { m_itemGuid = _itemGuid; }
+
+uint8_t Charter::getNumberOfAvailableSlots() const
+{
+    switch (m_charterType)
+    {
+        case CHARTER_TYPE_GUILD:
+            return 9;
+        case CHARTER_TYPE_ARENA_2V2:
+            return 1;
+        case CHARTER_TYPE_ARENA_3V3:
+            return 2;
+        case CHARTER_TYPE_ARENA_5V5:
+            return 4;
+        default:
+            return 9;
+    }
+}
+bool Charter::isFull() const { return m_signatures.size() == m_availableSlots; }
+uint8_t Charter::getAvailableSlots() const { return m_availableSlots; }
+
+void Charter::addSignature(uint32_t _playerGuid)
+{
+    if (m_signatures.size() >= m_availableSlots)
+        return;
+
+    m_signatures.push_back(_playerGuid);
+}
+
+void Charter::removeSignature(uint32_t _playerGuid)
+{
+    std::erase(m_signatures, _playerGuid);
+
+    saveToDB();
+}
+
+uint8_t Charter::getSignatureCount() const { return m_signatures.size(); }
+std::vector<uint32_t> Charter::getSignatures() { return m_signatures; }

src/world/Management/Charter.hpp

@@ -6,74 +6,51 @@ This file is released under the MIT license. See README-MIT for more information
 #pragma once
 
 #include <cstdint>
-#include <cstring>
-
-#include "Objects/Units/Players/PlayerDefines.hpp"
 
 class Field;
 
-class Charter
+class Charter : public std::enable_shared_from_this<Charter>
 {
 public:
+    Charter(Field* _field);
+    Charter(uint32_t _id, uint32_t _leaderGuid, uint8_t _type);
+    ~Charter();
 
-    uint32_t GetNumberOfSlotsByType()
-    {
-        switch (CharterType)
-        {
-        case CHARTER_TYPE_GUILD:
-            return 9;
+    void saveToDB();
+    void destroy();
 
-        case CHARTER_TYPE_ARENA_2V2:
-            return 1;
+    uint32_t getLeaderGuid() const;
 
-        case CHARTER_TYPE_ARENA_3V3:
-            return 2;
+    uint32_t getId() const;
 
-        case CHARTER_TYPE_ARENA_5V5:
-            return 4;
+    uint8_t getCharterType() const;
 
-        default:
-            return 9;
-        }
-    }
+    std::string getGuildName();
+    void setGuildName(const std::string& _guildName);
 
-    uint32_t SignatureCount;
-    uint32_t* Signatures;
-    uint8_t CharterType;
-    uint32_t Slots;
-    uint32_t LeaderGuid;
-    uint64_t ItemGuid;
-    uint32_t CharterId;
-    std::string GuildName;
+    uint64_t getItemGuid() const;
+    void setItemGuid(uint64_t _itemGuid);
 
-    //////////////////////////////////////////////////////////////////////////////////////////
-    // Developer Fields
-    uint32_t PetitionSignerCount;
+    uint8_t getNumberOfAvailableSlots() const;
+    bool isFull() const;
+    uint8_t getAvailableSlots() const;
 
-    Charter(Field* fields);
-    Charter(uint32_t id, uint32_t leader, uint8_t type) : CharterType(type), LeaderGuid(leader), CharterId(id)
-    {
-        SignatureCount = 0;
-        ItemGuid = 0;
-        Slots = GetNumberOfSlotsByType();
-        Signatures = new uint32_t[Slots];
-        memset(Signatures, 0, sizeof(uint32_t) * Slots);
-        PetitionSignerCount = 0;
-    }
+    void addSignature(uint32_t _playerGuid);
+    void removeSignature(uint32_t _playerGuid);
+    uint8_t getSignatureCount() const;
+    std::vector<uint32_t> getSignatures();
 
-    ~Charter()
-    {
-        delete[] Signatures;
-    }
+    uint32_t m_petitionSignerCount = 0;
 
-    void SaveToDB();
-    void Destroy();         // When item is deleted.
+private:
+    uint32_t m_charterId = 0;
+    uint8_t m_charterType = 0;
 
-    void AddSignature(uint32_t PlayerGuid);
-    void RemoveSignature(uint32_t PlayerGuid);
+    uint32_t m_leaderGuid = 0;
+    std::string m_guildName;
+    uint64_t m_itemGuid = 0;
 
-    uint32_t GetLeader() { return LeaderGuid; }
-    uint32_t GetID() { return CharterId; }
+    uint8_t m_availableSlots = 0;
 
-    bool IsFull() { return (SignatureCount == Slots); }
+    std::vector<uint32_t> m_signatures;
 };

src/world/Management/ObjectMgr.cpp

@@ -123,14 +123,9 @@ void ObjectMgr::finalize()
         delete i->second;
     }
 
-    sLogger.info("ObjectMgr : Deleting Charters...");
-    for (uint8 i = 0; i < NUM_CHARTER_TYPES; ++i)
-    {
-        for (std::unordered_map<uint32, Charter*>::iterator itr = m_charters[i].begin(); itr != m_charters[i].end(); ++itr)
-        {
-            delete itr->second;
-        }
-    }
+    sLogger.info("ObjectMgr : Clearing Charters...");
+    for (auto& charter : m_charters)
+        charter.clear();
 
     sLogger.info("ObjectMgr : Deleting Reputation Tables...");
     for (ReputationModMap::iterator itr = m_reputation_creature.begin(); itr != m_reputation_creature.end(); ++itr)
@@ -373,6 +368,101 @@ void ObjectMgr::resetArenaTeamRatings()
     updateArenaTeamRankings();
 }
 
+//////////////////////////////////////////////////////////////////////////////////////////
+// Charter
+void ObjectMgr::loadCharters()
+{
+    m_hiCharterId = 0;
+
+    if (QueryResult* result = CharacterDatabase.Query("SELECT * FROM charters"))
+    {
+        do
+        {
+            auto charter = std::make_shared<Charter>(result->Fetch());
+            m_charters[charter->getCharterType()].insert(std::make_pair(charter->getId(), charter));
+            if (charter->getId() > static_cast<int64_t>(m_hiCharterId.load()))
+                m_hiCharterId = charter->getId();
+
+        } while (result->NextRow());
+
+        delete result;
+    }
+    sLogger.info("ObjectMgr : %u charters loaded.", static_cast<uint32_t>(m_charters[0].size()));
+}
+
+void ObjectMgr::removeCharter(const std::shared_ptr<Charter>& _charter)
+{
+    if (_charter)
+    {
+        if (_charter->getCharterType() >= NUM_CHARTER_TYPES)
+        {
+            sLogger.debug("ObjectMgr : Charter %u cannot be destroyed as type %u is not a valid type.", _charter->getId(), static_cast<uint32_t>(_charter->getCharterType()));
+            return;
+        }
+
+        std::lock_guard guard(m_charterLock);
+        m_charters[_charter->getCharterType()].erase(_charter->getId());
+    }
+}
+
+std::shared_ptr<Charter> ObjectMgr::createCharter(uint32_t _leaderGuid, CharterTypes _type)
+{
+    uint32_t charterId = ++m_hiCharterId;
+    auto charter = std::make_shared<Charter>(charterId, _leaderGuid, _type);
+
+    std::lock_guard guard(m_charterLock);
+    m_charters[charter->getCharterType()].insert(std::make_pair(charter->getId(), charter));
+
+    return charter;
+}
+
+std::shared_ptr<Charter> ObjectMgr::getCharterByName(const std::string& _charterName, const CharterTypes _type)
+{
+    std::lock_guard guard(m_charterLock);
+
+    for (auto& charterPair : m_charters[_type])
+        if (charterPair.second->getGuildName() == _charterName)
+            return charterPair.second;
+
+    return nullptr;
+}
+
+std::shared_ptr<Charter> ObjectMgr::getCharter(const uint32_t _charterId, const CharterTypes _type)
+{
+    std::lock_guard guard(m_charterLock);
+    const auto charterPair = m_charters[_type].find(_charterId);
+    return charterPair == m_charters[_type].end() ? nullptr : charterPair->second;
+}
+
+std::shared_ptr<Charter> ObjectMgr::getCharterByGuid(const uint64_t _playerGuid, const CharterTypes _type)
+{
+    std::lock_guard guard(m_charterLock);
+    for (auto& charterPair : m_charters[_type])
+    {
+        if (_playerGuid == charterPair.second->getLeaderGuid())
+            return charterPair.second;
+
+        for (const uint32_t playerGuid : charterPair.second->getSignatures())
+            if (playerGuid == _playerGuid)
+                return charterPair.second;
+    }
+
+    return nullptr;
+}
+
+std::shared_ptr<Charter> ObjectMgr::getCharterByItemGuid(const uint64_t _itemGuid)
+{
+    std::lock_guard guard(m_charterLock);
+    for (auto& charterType : m_charters)
+    {
+        for (auto& charterPair : charterType)
+            if (charterPair.second->getItemGuid() == _itemGuid)
+                return charterPair.second;
+    }
+
+    return nullptr;
+}
+
 //////////////////////////////////////////////////////////////////////////////////////////
 // Misc
 void ObjectMgr::loadCreatureDisplayInfo()
@@ -2016,107 +2106,6 @@ Corpse* ObjectMgr::GetCorpse(uint32 corpseguid)
     return rv;
 }
 
-void ObjectMgr::LoadGuildCharters()
-{
-    m_hiCharterId = 0;
-    QueryResult* result = CharacterDatabase.Query("SELECT * FROM charters");
-    if (!result)
-        return;
-    do
-    {
-        Charter* c = new Charter(result->Fetch());
-        m_charters[c->CharterType].insert(std::make_pair(c->GetID(), c));
-        if (c->GetID() > int64(m_hiCharterId.load()))
-            m_hiCharterId = c->GetID();
-    }
-    while (result->NextRow());
-    delete result;
-    sLogger.info("ObjectMgr : %u charters loaded.", static_cast<uint32_t>(m_charters[0].size()));
-}
-
-Charter* ObjectMgr::GetCharter(uint32 CharterId, CharterTypes Type)
-{
-    std::lock_guard<std::mutex> guard(m_charterLock);
-
-    std::unordered_map<uint32, Charter*>::iterator itr = m_charters[Type].find(CharterId);
-    return (itr == m_charters[Type].end()) ? nullptr : itr->second;
-}
-
-Charter* ObjectMgr::CreateCharter(uint32 LeaderGuid, CharterTypes Type)
-{
-    uint32 charterid = 0;
-    charterid = ++m_hiCharterId;
-
-    Charter* c = new Charter(charterid, LeaderGuid, Type);
-    m_charters[c->CharterType].insert(std::make_pair(c->GetID(), c));
-
-    return c;
-}
-
-Charter* ObjectMgr::GetCharterByItemGuid(uint64 guid)
-{
-    std::lock_guard<std::mutex> guard(m_charterLock);
-
-    for (uint8 i = 0; i < NUM_CHARTER_TYPES; ++i)
-    {
-        for (std::unordered_map<uint32, Charter*>::iterator itr = m_charters[i].begin(); itr != m_charters[i].end(); ++itr)
-        {
-            if (itr->second->ItemGuid == guid)
-                return itr->second;
-        }
-    }
-
-    return nullptr;
-}
-
-Charter* ObjectMgr::GetCharterByGuid(uint64 playerguid, CharterTypes type)
-{
-    std::lock_guard<std::mutex> guard(m_charterLock);
-
-    for (std::unordered_map<uint32, Charter*>::iterator itr = m_charters[type].begin(); itr != m_charters[type].end(); ++itr)
-    {
-        if (playerguid == itr->second->LeaderGuid)
-            return itr->second;
-
-        for (uint32 j = 0; j < itr->second->SignatureCount; ++j)
-        {
-            if (itr->second->Signatures[j] == playerguid)
-                return itr->second;
-        }
-    }
-
-    return nullptr;
-}
-
-Charter* ObjectMgr::GetCharterByName(std::string & charter_name, CharterTypes Type)
-{
-    std::lock_guard<std::mutex> guard(m_charterLock);
-
-    for (std::unordered_map<uint32, Charter*>::iterator itr = m_charters[Type].begin(); itr != m_charters[Type].end(); ++itr)
-    {
-        if (itr->second->GuildName == charter_name)
-            return itr->second;
-    }
-
-    return nullptr;
-}
-
-void ObjectMgr::RemoveCharter(Charter* c)
-{
-    if (c == nullptr)
-        return;
-
-    if (c->CharterType >= NUM_CHARTER_TYPES)
-    {
-        sLogger.debug("ObjectMgr : Charter %u cannot be destroyed as type %u is not a sane type value.", c->CharterId, c->CharterType);
-        return;
-    }
-
-    std::lock_guard<std::mutex> guard(m_charterLock);
-
-    m_charters[c->CharterType].erase(c->CharterId);
-}
-
 void ObjectMgr::LoadReputationModifierTable(const char* tablename, ReputationModMap* dmap)
 {
     QueryResult* result = WorldDatabase.Query("SELECT * FROM %s", tablename);

src/world/Management/ObjectMgr.h

@@ -234,6 +234,22 @@ private:
     std::unordered_map<uint32_t, std::shared_ptr<ArenaTeam>> m_arenaTeamMap[3];
     std::mutex m_arenaTeamLock;
 
+    //////////////////////////////////////////////////////////////////////////////////////////
+    // Charter
+public:
+    void loadCharters();
+    void removeCharter(const std::shared_ptr<Charter>&);
+    std::shared_ptr<Charter> createCharter(uint32_t _leaderGuid, CharterTypes _type);
+
+    std::shared_ptr<Charter> getCharterByName(const std::string& _charterName, CharterTypes _type);
+    std::shared_ptr<Charter> getCharter(uint32_t _charterId, CharterTypes _type);
+    std::shared_ptr<Charter> getCharterByGuid(uint64_t _playerguid, CharterTypes _type);
+    std::shared_ptr<Charter> getCharterByItemGuid(uint64_t _guid);
+
+private:
+    std::unordered_map<uint32, std::shared_ptr<Charter>> m_charters[NUM_CHARTER_TYPES];
+    std::mutex m_charterLock;
+
     //////////////////////////////////////////////////////////////////////////////////////////
     // Misc
 public:
@@ -379,13 +395,7 @@ public:
         uint32 GenerateCreatureSpawnID();
         uint32 GenerateGameObjectSpawnID();
 
-        Charter* CreateCharter(uint32 LeaderGuid, CharterTypes Type);
-        Charter* GetCharter(uint32 CharterId, CharterTypes Type);
-        void RemoveCharter(Charter*);
-        void LoadGuildCharters();
-        Charter* GetCharterByName(std::string & charter_name, CharterTypes Type);
-        Charter* GetCharterByItemGuid(uint64 guid);
-        Charter* GetCharterByGuid(uint64 playerguid, CharterTypes type);
+        
 
         bool HandleInstanceReputationModifiers(Player* pPlayer, Unit* pVictim);
         void LoadInstanceReputationModifiers();
@@ -485,14 +495,11 @@ public:
 #if VERSION_STRING > WotLK
         std::atomic<unsigned long> m_voidItemId;
 #endif
-        std::mutex m_charterLock;
 
         ReputationModMap m_reputation_faction;
         ReputationModMap m_reputation_creature;
         std::unordered_map<uint32, InstanceReputationModifier*> m_reputation_instance;
 
-        std::unordered_map<uint32, Charter*> m_charters[NUM_CHARTER_TYPES];
-
         std::set<uint32> m_disabled_spells;
 
         std::unordered_map<uint32, CachedCharacterInfo*> m_playersinfo;

src/world/Objects/Item.cpp

@@ -1202,6 +1202,31 @@ int32_t Item::getReforgableStat(ItemModType statType) const
 }
 #endif
 
+uint8_t Item::getCharterTypeForEntry() const
+{
+    uint8_t charterType;
+    switch (getEntry())
+    {
+        case CharterEntry::Guild:
+            charterType = CHARTER_TYPE_GUILD;
+            break;
+        case CharterEntry::TwoOnTwo:
+            charterType = CHARTER_TYPE_ARENA_2V2;
+            break;
+        case CharterEntry::ThreeOnThree:
+            charterType = CHARTER_TYPE_ARENA_3V3;
+            break;
+        case CharterEntry::FiveOnFive:
+            charterType = CHARTER_TYPE_ARENA_5V5;
+            break;
+        default:
+            charterType = NUM_CHARTER_TYPES;
+            break;
+    }
+
+    return charterType;
+}
+
 void Item::loadFromDB(Field* fields, Player* plr, bool light)
 {
     uint32_t itemid = fields[2].GetUInt32();
@@ -1292,40 +1317,14 @@ void Item::loadFromDB(Field* fields, Player* plr, bool light)
     applyRandomProperties(false);
 
     // Charter stuff
-    if (getEntry() == CharterEntry::Guild)
+    const uint8_t charterType = getCharterTypeForEntry();
+    if (charterType < NUM_CHARTER_TYPES)
     {
         addFlags(ITEM_FLAG_SOULBOUND);
         setStackCount(1);
         setPropertySeed(57813883);
-        if (plr != nullptr && plr->getCharter(CHARTER_TYPE_GUILD))
-            setEnchantmentId(0, plr->getCharter(CHARTER_TYPE_GUILD)->GetID());
-    }
-
-    if (getEntry() == CharterEntry::TwoOnTwo)
-    {
-        addFlags(ITEM_FLAG_SOULBOUND);
-        setStackCount(1);
-        setPropertySeed(57813883);
-        if (plr != nullptr && plr->getCharter(CHARTER_TYPE_ARENA_2V2))
-            setEnchantmentId(0, plr->getCharter(CHARTER_TYPE_ARENA_2V2)->GetID());
-    }
-
-    if (getEntry() == CharterEntry::ThreeOnThree)
-    {
-        addFlags(ITEM_FLAG_SOULBOUND);
-        setStackCount(1);
-        setPropertySeed(57813883);
-        if (plr != nullptr && plr->getCharter(CHARTER_TYPE_ARENA_3V3))
-            setEnchantmentId(0, plr->getCharter(CHARTER_TYPE_ARENA_3V3)->GetID());
-    }
-
-    if (getEntry() == CharterEntry::FiveOnFive)
-    {
-        addFlags(ITEM_FLAG_SOULBOUND);
-        setStackCount(1);
-        setPropertySeed(57813883);
-        if (plr != nullptr && plr->getCharter(CHARTER_TYPE_ARENA_5V5))
-            setEnchantmentId(0, plr->getCharter(CHARTER_TYPE_ARENA_5V5)->GetID());
+        if (plr && plr->getCharter(charterType))
+            setEnchantmentId(0, plr->getCharter(charterType)->getId());
     }
 }
 

src/world/Objects/Item.hpp

@@ -206,6 +206,7 @@ public:
     bool isInBag() const;
     bool isEquipped() const;
     bool isTradeableWith(Player* player);
+    uint8_t getCharterTypeForEntry() const;
 
     int32_t getReforgableStat(ItemModType statType) const;
     static bool canTransmogrifyItemWithItem(Item const* transmogrified, Item const* transmogrifier);

src/world/Objects/Units/Players/Player.cpp

@@ -7830,20 +7830,20 @@ int32_t Player::getBGEntryInstanceId() const { return m_bgEntryData.instanceId;
 //////////////////////////////////////////////////////////////////////////////////////////
 // Charter
 void Player::unsetCharter(uint8_t charterType) { m_charters[charterType] = nullptr; }
-Charter* Player::getCharter(uint8_t charterType) { return m_charters[charterType]; }
+std::shared_ptr<Charter> Player::getCharter(uint8_t charterType) { return m_charters[charterType]; }
 
-bool Player::canSignCharter(Charter* charter, Player* requester)
+bool Player::canSignCharter(std::shared_ptr<Charter> charter, Player* requester)
 {
     if (charter == nullptr || requester == nullptr)
         return false;
 
-    if (charter->CharterType >= CHARTER_TYPE_ARENA_2V2 && getArenaTeam(charter->CharterType - 1U) != nullptr)
+    if (charter->getCharterType() >= CHARTER_TYPE_ARENA_2V2 && getArenaTeam(charter->getCharterType() - 1U) != nullptr)
         return false;
 
-    if (charter->CharterType == CHARTER_TYPE_GUILD && isInGuild())
+    if (charter->getCharterType() == CHARTER_TYPE_GUILD && isInGuild())
         return false;
 
-    if (m_charters[charter->CharterType] || requester->getTeam() != getTeam() || this == requester)
+    if (m_charters[charter->getCharterType()] || requester->getTeam() != getTeam() || this == requester)
         return false;
 
     return true;
@@ -7852,7 +7852,7 @@ bool Player::canSignCharter(Charter* charter, Player* requester)
 void Player::initialiseCharters()
 {
     for (uint8_t i = 0; i < NUM_CHARTER_TYPES; ++i)
-        m_charters[i] = sObjectMgr.GetCharterByGuid(getGuid(), static_cast<CharterTypes>(i));
+        m_charters[i] = sObjectMgr.getCharterByGuid(getGuid(), static_cast<CharterTypes>(i));
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////

src/world/Objects/Units/Players/Player.hpp

@@ -1188,13 +1188,13 @@ private:
     // Charter
 public:
     void unsetCharter(uint8_t charterType);
-    Charter* getCharter(uint8_t charterType);
+    std::shared_ptr<Charter> getCharter(uint8_t charterType);
 
-    bool canSignCharter(Charter* charter, Player* requester);
+    bool canSignCharter(std::shared_ptr<Charter> charter, Player* requester);
     void initialiseCharters();
 
 private:
-    Charter* m_charters[NUM_CHARTER_TYPES] = {nullptr};
+    std::shared_ptr<Charter> m_charters[NUM_CHARTER_TYPES] = {nullptr};
 
     //////////////////////////////////////////////////////////////////////////////////////////
     // Guild

src/world/Server/Packets/Handlers/CharacterHandler.cpp

@@ -292,8 +292,7 @@ uint8_t WorldSession::deleteCharacter(WoWGuid guid)
     const auto playerInfo = sObjectMgr.GetPlayerInfo(guid.getGuidLow());
     if (playerInfo != nullptr && sObjectMgr.GetPlayer(playerInfo->guid) == nullptr)
     {
-        QueryResult* result = CharacterDatabase.Query("SELECT name FROM characters WHERE guid = %u AND acct = %u",
-            guid.getGuidLow(), _accountId);
+        QueryResult* result = CharacterDatabase.Query("SELECT name FROM characters WHERE guid = %u AND acct = %u", guid.getGuidLow(), _accountId);
         if (!result)
             return E_CHAR_DELETE_FAILED;
 
@@ -312,9 +311,8 @@ uint8_t WorldSession::deleteCharacter(WoWGuid guid)
 
         for (uint8_t i = 0; i < NUM_CHARTER_TYPES; ++i)
         {
-            const auto charter = sObjectMgr.GetCharterByGuid(guid, static_cast<CharterTypes>(i));
-            if (charter != nullptr)
-                charter->RemoveSignature(guid.getGuidLow());
+            if (const auto charter = sObjectMgr.getCharterByGuid(guid, static_cast<CharterTypes>(i)))
+                charter->removeSignature(guid.getGuidLow());
         }
 
 

src/world/Server/Packets/Handlers/GuildHandler.cpp

@@ -504,9 +504,9 @@ void WorldSession::handleCharterShowSignatures(WorldPacket& recvPacket)
     if (!srlPacket.deserialise(recvPacket))
         return;
 
-    if (Charter* charter = sObjectMgr.GetCharterByItemGuid(srlPacket.itemGuid))
-        _player->getSession()->SendPacket(SmsgPetitionShowSignatures(srlPacket.itemGuid, charter->GetLeader(), charter->GetID(), static_cast<uint8_t>(charter->SignatureCount),
-            charter->Slots, charter->Signatures).serialise().get());
+    if (const auto charter = sObjectMgr.getCharterByItemGuid(srlPacket.itemGuid))
+        _player->getSession()->SendPacket(SmsgPetitionShowSignatures(srlPacket.itemGuid, charter->getLeaderGuid(), charter->getId(), charter->getSignatureCount(),
+            charter->getAvailableSlots(), charter->getSignatures()).serialise().get());
 }
 
 void WorldSession::handleCharterOffer(WorldPacket& recvPacket)
@@ -516,7 +516,7 @@ void WorldSession::handleCharterOffer(WorldPacket& recvPacket)
         return;
 
     Player* pTarget = _player->getWorldMap()->getPlayer(srlPacket.playerGuid.getGuidLow());
-    Charter* pCharter = sObjectMgr.GetCharterByItemGuid(srlPacket.itemGuid);
+    const auto pCharter = sObjectMgr.getCharterByItemGuid(srlPacket.itemGuid);
     if (pCharter == nullptr)
     {
         SendNotification(_player->getSession()->LocalizedWorldSrv(ServerString::SS_ITEM_NOT_FOUND));
@@ -535,8 +535,8 @@ void WorldSession::handleCharterOffer(WorldPacket& recvPacket)
         return;
     }
 
-    pTarget->getSession()->SendPacket(SmsgPetitionShowSignatures(srlPacket.itemGuid, pCharter->GetLeader(), pCharter->GetID(), static_cast<uint8_t>(pCharter->SignatureCount),
-        pCharter->Slots, pCharter->Signatures).serialise().get());
+    pTarget->getSession()->SendPacket(SmsgPetitionShowSignatures(srlPacket.itemGuid, pCharter->getLeaderGuid(), pCharter->getId(), pCharter->getSignatureCount(),
+        pCharter->getAvailableSlots(), pCharter->getSignatures()).serialise().get());
 }
 
 namespace PetitionSignResult
@@ -554,11 +554,11 @@ void WorldSession::handleCharterSign(WorldPacket& recvPacket)
     if (!srlPacket.deserialise(recvPacket))
         return;
 
-    if (Charter* charter = sObjectMgr.GetCharterByItemGuid(srlPacket.itemGuid))
+    if (const auto charter = sObjectMgr.getCharterByItemGuid(srlPacket.itemGuid))
     {
-        for (uint32_t i = 0; i < charter->SignatureCount; ++i)
+        for (const uint32_t playerGuid : charter->getSignatures())
         {
-            if (charter->Signatures[i] == _player->getGuid())
+            if (playerGuid == _player->getGuid())
             {
                 SendNotification(_player->getSession()->LocalizedWorldSrv(ServerString::SS_ALREADY_SIGNED_CHARTER));
                 SendPacket(SmsgPetitionSignResult(srlPacket.itemGuid, _player->getGuid(), PetitionSignResult::AlreadySigned).serialise().get());
@@ -566,20 +566,20 @@ void WorldSession::handleCharterSign(WorldPacket& recvPacket)
             }
         }
 
-        if (charter->IsFull())
+        if (charter->isFull())
             return;
 
-        charter->AddSignature(_player->getGuidLow());
-        charter->SaveToDB();
-        _player->m_charters[charter->CharterType] = charter;
+        charter->addSignature(_player->getGuidLow());
+        charter->saveToDB();
+        _player->m_charters[charter->getCharterType()] = charter;
         _player->saveToDB(false);
 
-        Player* player = _player->getWorldMap()->getPlayer(charter->GetLeader());
+        Player* player = _player->getWorldMap()->getPlayer(charter->getLeaderGuid());
         if (player == nullptr)
             return;
 
         player->sendPacket(SmsgPetitionSignResult(srlPacket.itemGuid, _player->getGuid(), PetitionSignResult::OK).serialise().get());
-        SendPacket(SmsgPetitionSignResult(srlPacket.itemGuid, uint64_t(charter->GetLeader()), PetitionSignResult::OK).serialise().get());
+        SendPacket(SmsgPetitionSignResult(srlPacket.itemGuid, uint64_t(charter->getLeaderGuid()), PetitionSignResult::OK).serialise().get());
     }
 }
 
@@ -589,11 +589,11 @@ void WorldSession::handleCharterDecline(WorldPacket& recvPacket)
     if (!srlPacket.deserialise(recvPacket))
         return;
 
-    Charter* charter = sObjectMgr.GetCharterByItemGuid(srlPacket.itemGuid);
+    auto const charter = sObjectMgr.getCharterByItemGuid(srlPacket.itemGuid);
     if (charter == nullptr)
         return;
 
-    Player* player = sObjectMgr.GetPlayer(charter->GetLeader());
+    Player* player = sObjectMgr.GetPlayer(charter->getLeaderGuid());
     if (player)
         player->getSession()->SendPacket(MsgPetitionDecline(_player->getGuid()).serialise().get());
 }
@@ -604,12 +604,12 @@ void WorldSession::handleCharterRename(WorldPacket& recvPacket)
     if (!srlPacket.deserialise(recvPacket))
         return;
 
-    Charter* charter1 = sObjectMgr.GetCharterByItemGuid(srlPacket.itemGuid);
+    auto const charter1 = sObjectMgr.getCharterByItemGuid(srlPacket.itemGuid);
     if (charter1 == nullptr)
         return;
 
     Guild* guild = sGuildMgr.getGuildByName(srlPacket.name);
-    Charter* charter = sObjectMgr.GetCharterByName(srlPacket.name, static_cast<CharterTypes>(charter1->CharterType));
+    auto charter = sObjectMgr.getCharterByName(srlPacket.name, static_cast<CharterTypes>(charter1->getCharterType()));
     if (charter || guild)
     {
         SendNotification("That name is in use by another guild.");
@@ -617,8 +617,8 @@ void WorldSession::handleCharterRename(WorldPacket& recvPacket)
     }
 
     charter = charter1;
-    charter->GuildName = srlPacket.name;
-    charter->SaveToDB();
+    charter->setGuildName(srlPacket.name);
+    charter->saveToDB();
 
     SendPacket(MsgPetitionRename(srlPacket.itemGuid, srlPacket.name).serialise().get());
 }
@@ -629,31 +629,31 @@ void WorldSession::handleCharterTurnInCharter(WorldPacket& recvPacket)
     if (!srlPacket.deserialise(recvPacket))
         return;
 
-    const auto charter = sObjectMgr.GetCharterByItemGuid(srlPacket.itemGuid);
+    const auto charter = sObjectMgr.getCharterByItemGuid(srlPacket.itemGuid);
     if (charter == nullptr)
         return;
 
-    if (charter->CharterType == CHARTER_TYPE_GUILD)
+    if (charter->getCharterType() == CHARTER_TYPE_GUILD)
     {
         const auto playerCharter = _player->m_charters[CHARTER_TYPE_GUILD];
         if (playerCharter == nullptr)
             return;
 
-        if (playerCharter->SignatureCount < playerCharter->GetNumberOfSlotsByType() && worldConfig.guild.requireAllSignatures && !_player->getSession()->HasGMPermissions())
+        if (playerCharter->getSignatureCount() < playerCharter->getNumberOfAvailableSlots() && worldConfig.guild.requireAllSignatures && !_player->getSession()->HasGMPermissions())
         {
             Guild::sendTurnInPetitionResult(this, PETITION_ERROR_NEED_MORE_SIGNATURES);
             return;
         }
 
         const auto guild = new Guild;
-        if (!guild->create(_player, playerCharter->GuildName))
+        if (!guild->create(_player, playerCharter->getGuildName()))
         {
             delete guild;
             return;
         }
 
         _player->m_charters[CHARTER_TYPE_GUILD] = nullptr;
-        playerCharter->Destroy();
+        playerCharter->destroy();
 
         _player->getItemInterface()->RemoveItemAmt(CharterEntry::Guild, 1);
         sHookInterface.OnGuildCreate(_player, guild);
@@ -662,7 +662,7 @@ void WorldSession::handleCharterTurnInCharter(WorldPacket& recvPacket)
     {
         uint8_t type;
 
-        switch (charter->CharterType)
+        switch (charter->getCharterType())
         {
             case CHARTER_TYPE_ARENA_2V2:
                 type = ARENA_TEAM_TYPE_2V2;
@@ -677,17 +677,17 @@ void WorldSession::handleCharterTurnInCharter(WorldPacket& recvPacket)
                 break;
 
             default:
-                SendNotification("Internal Error");
+                SendNotification("Chartertype not allowed for Arena");
                 return;
         }
 
-        if (_player->getArenaTeam(charter->CharterType - 1U) != nullptr)
+        if (_player->getArenaTeam(charter->getCharterType() - 1U) != nullptr)
         {
             sChatHandler.SystemMessage(this, LocalizedWorldSrv(ServerString::SS_ALREADY_ARENA_TEAM));
             return;
         }
 
-        if (charter->SignatureCount < charter->GetNumberOfSlotsByType() && !_player->getSession()->HasGMPermissions())
+        if (charter->getSignatureCount() < charter->getNumberOfAvailableSlots() && !_player->getSession()->HasGMPermissions())
         {
             ///\ todo: missing correct error message for arena charters
             Guild::sendTurnInPetitionResult(this, PETITION_ERROR_NEED_MORE_SIGNATURES);
@@ -695,7 +695,7 @@ void WorldSession::handleCharterTurnInCharter(WorldPacket& recvPacket)
         }
 
         auto arenaTeam = std::make_shared<ArenaTeam>(type, sObjectMgr.GenerateArenaTeamId());
-        arenaTeam->m_name = charter->GuildName;
+        arenaTeam->m_name = charter->getGuildName();
         arenaTeam->m_emblem.emblemColour = srlPacket.iconColor;
         arenaTeam->m_emblem.emblemStyle = srlPacket.icon;
         arenaTeam->m_emblem.borderColour = srlPacket.borderColor;
@@ -708,13 +708,13 @@ void WorldSession::handleCharterTurnInCharter(WorldPacket& recvPacket)
         sObjectMgr.updateArenaTeamRankings();
         arenaTeam->addMember(_player->m_playerInfo);
 
-        for (uint32_t i = 0; i < charter->SignatureCount; ++i)
-            if (CachedCharacterInfo* info = sObjectMgr.GetPlayerInfo(charter->Signatures[i]))
+        for (uint32_t playerGuid : charter->getSignatures())
+            if (CachedCharacterInfo* info = sObjectMgr.GetPlayerInfo(playerGuid))
                 arenaTeam->addMember(info);
 
         _player->getItemInterface()->SafeFullRemoveItemByGuid(srlPacket.itemGuid);
-        _player->m_charters[charter->CharterType] = nullptr;
-        charter->Destroy();
+        _player->m_charters[charter->getCharterType()] = nullptr;
+        charter->destroy();
     }
 
     Guild::sendTurnInPetitionResult(this, PETITION_ERROR_OK);
@@ -726,9 +726,9 @@ void WorldSession::handleCharterQuery(WorldPacket& recvPacket)
     if (!srlPacket.deserialise(recvPacket))
         return;
 
-    if (Charter* charter = sObjectMgr.GetCharterByItemGuid(srlPacket.itemGuid))
-        SendPacket(SmsgPetitionQueryResponse(srlPacket.charterId, static_cast<uint64>(charter->LeaderGuid),
-            charter->GuildName, charter->CharterType, charter->Slots).serialise().get());
+    if (auto const charter = sObjectMgr.getCharterByItemGuid(srlPacket.itemGuid))
+        SendPacket(SmsgPetitionQueryResponse(srlPacket.charterId, charter->getLeaderGuid(),
+            charter->getGuildName(), charter->getCharterType(), charter->getAvailableSlots()).serialise().get());
 }
 
 void WorldSession::handleCharterBuy(WorldPacket& recvPacket)
@@ -763,7 +763,7 @@ void WorldSession::handleCharterBuy(WorldPacket& recvPacket)
             return;
         }
 
-        if (sObjectMgr.GetCharterByName(srlPacket.name, static_cast<CharterTypes>(srlPacket.arenaIndex)))
+        if (sObjectMgr.getCharterByName(srlPacket.name, static_cast<CharterTypes>(srlPacket.arenaIndex)))
         {
             sChatHandler.SystemMessage(this, _player->getSession()->LocalizedWorldSrv(ServerString::SS_PETITION_NAME_ALREADY_USED));
             return;
@@ -810,27 +810,27 @@ void WorldSession::handleCharterBuy(WorldPacket& recvPacket)
         {
             Item* item = sObjectMgr.CreateItem(item_ids[arena_type], _player);
 
-            Charter* charter = sObjectMgr.CreateCharter(_player->getGuidLow(), static_cast<CharterTypes>(srlPacket.arenaIndex));
+            auto const charter = sObjectMgr.createCharter(_player->getGuidLow(), static_cast<CharterTypes>(srlPacket.arenaIndex));
             if (item == nullptr || charter == nullptr)
                 return;
 
-            charter->GuildName = srlPacket.name;
-            charter->ItemGuid = item->getGuid();
+            charter->setGuildName(srlPacket.name);
+            charter->setItemGuid(item->getGuid());
 
-            charter->PetitionSignerCount = srlPacket.signerCount;
+            charter->m_petitionSignerCount = srlPacket.signerCount;
 
             item->setStackCount(1);
             item->addFlags(ITEM_FLAG_SOULBOUND);
-            item->setEnchantmentId(0, charter->GetID());
+            item->setEnchantmentId(0, charter->getId());
             item->setPropertySeed(57813883);
             if (!_player->getItemInterface()->AddItemToFreeSlot(item))
             {
-                charter->Destroy();
+                charter->destroy();
                 item->deleteMe();
                 return;
             }
 
-            charter->SaveToDB();
+            charter->saveToDB();
 
             _player->sendItemPushResultPacket(false, true, false, _player->getItemInterface()->LastSearchItemBagSlot(),
                 _player->getItemInterface()->LastSearchItemSlot(), 1, item->getEntry(), item->getPropertySeed(), item->getRandomPropertiesId(), item->getStackCount());
@@ -849,7 +849,7 @@ void WorldSession::handleCharterBuy(WorldPacket& recvPacket)
         }
 
         Guild* guild = sGuildMgr.getGuildByName(srlPacket.name);
-        Charter* charter = sObjectMgr.GetCharterByName(srlPacket.name, CHARTER_TYPE_GUILD);
+        auto const charter = sObjectMgr.getCharterByName(srlPacket.name, CHARTER_TYPE_GUILD);
         if (guild != nullptr || charter != nullptr)
         {
             SendNotification(_player->getSession()->LocalizedWorldSrv(ServerString::SS_GUILD_NAME_ALREADY_IN_USE));
@@ -884,27 +884,27 @@ void WorldSession::handleCharterBuy(WorldPacket& recvPacket)
 
             Item* item = sObjectMgr.CreateItem(CharterEntry::Guild, _player);
 
-            Charter* guildCharter = sObjectMgr.CreateCharter(_player->getGuidLow(), CHARTER_TYPE_GUILD);
+            auto const guildCharter = sObjectMgr.createCharter(_player->getGuidLow(), CHARTER_TYPE_GUILD);
             if (item == nullptr || guildCharter == nullptr)
                 return;
 
-            guildCharter->GuildName = srlPacket.name;
-            guildCharter->ItemGuid = item->getGuid();
+            guildCharter->setGuildName(srlPacket.name);
+            guildCharter->setItemGuid(item->getGuid());
 
-            guildCharter->PetitionSignerCount = srlPacket.signerCount;
+            guildCharter->m_petitionSignerCount = srlPacket.signerCount;
 
             item->setStackCount(1);
             item->addFlags(ITEM_FLAG_SOULBOUND);
-            item->setEnchantmentId(0, guildCharter->GetID());
+            item->setEnchantmentId(0, guildCharter->getId());
             item->setPropertySeed(57813883);
             if (!_player->getItemInterface()->AddItemToFreeSlot(item))
             {
-                guildCharter->Destroy();
+                guildCharter->destroy();
                 item->deleteMe();
                 return;
             }
 
-            guildCharter->SaveToDB();
+            guildCharter->saveToDB();
 
             _player->sendItemPushResultPacket(false, true, false, _player->getItemInterface()->LastSearchItemBagSlot(),
                 _player->getItemInterface()->LastSearchItemSlot(), 1, item->getEntry(), item->getPropertySeed(), item->getRandomPropertiesId(), item->getStackCount());

src/world/Server/Packets/Handlers/ItemHandler.cpp

@@ -1168,40 +1168,13 @@ void WorldSession::handleDestroyItemOpcode(WorldPacket& recvPacket)
             return;
         }
 
-        if (srcItem->getItemProperties()->ItemId == CharterEntry::Guild)
+        const uint8_t charterType = srcItem->getCharterTypeForEntry();
+        if (charterType < NUM_CHARTER_TYPES)
         {
-            Charter* gc = _player->m_charters[CHARTER_TYPE_GUILD];
-            if (gc)
-                gc->Destroy();
+            if (auto const charter = _player->m_charters[charterType])
+                charter->destroy();
 
-            _player->m_charters[CHARTER_TYPE_GUILD] = nullptr;
-        }
-
-        if (srcItem->getItemProperties()->ItemId == CharterEntry::TwoOnTwo)
-        {
-            Charter* gc = _player->m_charters[CHARTER_TYPE_ARENA_2V2];
-            if (gc)
-                gc->Destroy();
-
-            _player->m_charters[CHARTER_TYPE_ARENA_2V2] = nullptr;
-        }
-
-        if (srcItem->getItemProperties()->ItemId == CharterEntry::FiveOnFive)
-        {
-            Charter* gc = _player->m_charters[CHARTER_TYPE_ARENA_5V5];
-            if (gc)
-                gc->Destroy();
-
-            _player->m_charters[CHARTER_TYPE_ARENA_5V5] = nullptr;
-        }
-
-        if (srcItem->getItemProperties()->ItemId == CharterEntry::ThreeOnThree)
-        {
-            Charter* gc = _player->m_charters[CHARTER_TYPE_ARENA_3V3];
-            if (gc)
-                gc->Destroy();
-
-            _player->m_charters[CHARTER_TYPE_ARENA_3V3] = nullptr;
+            _player->m_charters[charterType] = nullptr;
         }
 
         Item* pItem = _player->getItemInterface()->SafeRemoveAndRetreiveItemFromSlot(srlPacket.srcInventorySlot, srlPacket.srcSlot, false);

src/world/Server/Packets/SmsgPetitionShowSignatures.h

@@ -19,13 +19,13 @@ namespace AscEmu::Packets
         uint32_t chartId;
         uint8_t signatureCount;
         uint32_t petitionSlots;
-        uint32_t* signatures;
+        std::vector<uint32_t> signatures;
 
         SmsgPetitionShowSignatures() : SmsgPetitionShowSignatures(0, 0, 0, 0, 0, { 0 })
         {
         }
 
-        SmsgPetitionShowSignatures(uint64_t itemGuid, uint64_t leaderGuid, uint32_t chartId, uint8_t signatureCount, uint32_t petitionSlots, uint32_t* signatures) :
+        SmsgPetitionShowSignatures(uint64_t itemGuid, uint64_t leaderGuid, uint32_t chartId, uint8_t signatureCount, uint32_t petitionSlots, std::vector<uint32_t> signatures) :
             ManagedPacket(SMSG_PETITION_SHOW_SIGNATURES, 0),
             itemGuid(itemGuid),
             leaderGuid(leaderGuid),
@@ -45,12 +45,12 @@ namespace AscEmu::Packets
             packet << leaderGuid;
             packet << chartId;
             packet << signatureCount;
-            for (uint32_t j = 0; j < petitionSlots; ++j)
+            for (auto const signature : signatures)
             {
-                if (signatures[j] == 0)
+                if (signature == 0)
                     continue;
 
-                packet << signatures[j];
+                packet << signature;
                 packet << uint32_t(1);
             }
             packet << uint8_t(0);

src/world/Server/World.cpp

@@ -938,7 +938,7 @@ void World::loadMySQLTablesByTask()
     sObjectMgr.loadTrainerSpellSets();
     sObjectMgr.loadTrainers();
     sObjectMgr.LoadPetSpellCooldowns();
-    sObjectMgr.LoadGuildCharters();
+    sObjectMgr.loadCharters();
     sTicketMgr.loadGMTickets();
     sObjectMgr.SetHighestGuids();
     sObjectMgr.LoadReputationModifiers();